this.hermethod = function ()
{
  object1 = new HerObject();
}

var me = this;
this.hermethod = function ()
{
  me.object1 = new HerObject();
}

//-------------------------
// Вспомогательная функция
//-------------------------

var mixInInterfaces = function (target_class) {
    var mixins = Array.prototype.slice.call(arguments, 1);
    for (let i = 0; i < mixins.length; ++i) {
        for (let prop in mixins[i]) {
            if (typeof target_class[prop] === "undefined") {
                target_class[prop] = mixins[i][prop];
            }
        }
    }
};

//-------------------------
// Interface SleepInterface
//-------------------------

var SleepInterface = function () {
}

SleepInterface.prototype.sleep = function () {
  console.log("I am sleeping");
}

//-------------------------
// Interface EatInterface
//-------------------------

var EatInterface = function () {
}

EatInterface.prototype.eat = function () {
  console.log("I am eating");
}

//-------------------------
// Class UserClass
//-------------------------

var UserClass = function(first_name, last_name) {
  this.first_name = first_name;
  this.last_name = last_name;
}

UserClass.prototype.constructor = UserClass;

UserClass.prototype.getFullInfo = function () {
  return this.first_name + " " + this.last_name;
};

//-------------------------
// Класс WorkerClass наследует от UserClass
//-------------------------

WorkerClass = function (first_name, last_name, profession) {
    UserClass.call(this, first_name, last_name);

    this.profession = profession;
};

WorkerClass.prototype = Object.create(UserClass.prototype);
WorkerClass.prototype.constructor = WorkerClass;

//-------------------------
// Класс WorkerClass реализует интерфесы SleepInterface и EatInterface
//-------------------------

mixInInterfaces(WorkerClass.prototype, SleepInterface.prototype, EatInterface.prototype);

//-------------------------
// Переопределяем метод getFullInfo
//-------------------------

WorkerClass.prototype.getFullInfo = function () {
  return this.first_name + " " + this.last_name + ", " + this.profession;
};

//-------------------------
// Класс VeganClass наследует от UserClass
//-------------------------

VeganClass = function (first_name, last_name) {
    UserClass.call(this, first_name, last_name);
};

VeganClass.prototype = Object.create(UserClass.prototype);
VeganClass.prototype.constructor = VeganClass;

//-------------------------
// Класс VeganClass реализует интерфесы SleepInterface и EatInterface
//-------------------------

mixInInterfaces(VeganClass.prototype, SleepInterface.prototype, EatInterface.prototype);

//-------------------------
// Переопределяем метод интерфейса eat
//-------------------------

VeganClass.prototype.eat = function () {
  console.log("I am a vegan, I am eating only vegetables!");
};

//-------------------------
// Использование
//-------------------------

var user1 = new UserClass("Alex", "Smith");
var user2 = new WorkerClass("Anna", "Connor", "Developer");
var user3 = new VeganClass("Robert", "Bush");

console.log("user1: " + user1.getFullInfo());

console.log("user2: " + user2.getFullInfo());
user2.sleep();
user2.eat();

console.log("user3: " + user3.getFullInfo());
user3.sleep();
user3.eat();

user1: Alex Smith
user2: Anna Connor, Developer
I am sleeping
I am eating
user3: Robert Bush
I am sleeping
I am a vegan, I am eating only vegetables!

/*
Usage example:

function send_post_request()
{
  var ajax = new JR.AJAX();

  ajax.timeout = 10000; // 10 seconds

  ajax.beforestart = function()
  {
    console.log("ajax beforestart");
  };

  ajax.aftercomplete = function(error)
  {
    if(!error)                    console.log("ajax complete with success");
    else if(error == 'UserAbort') console.log("ajax complete with user abort");
    else                          console.log("ajax complete with error: " + error);
  };

  ajax.onload = function(text, xml)
  {
    console.log("ajax success: " + text);
  };

  ajax.onerror = function(error, url, info)
  {
    console.log("ajax error: " + error);
  };

  ajax.setPOST('some_param', "380");
  ajax.setPOST('another_param', "400");

  ajax.request("process.php");
}

function send_get_request()
{
  var ajax = new JR.AJAX();

  ajax.timeout = 10000; // 10 seconds

  ajax.onload = function(text, xml)
  {
    console.log("ajax success: " + text);
  };

  ajax.onerror = function(error)
  {
    console.log("ajax error: " + error);
  };

  ajax.setGET('some_param', "380");
  ajax.setGET('another_param', "400");

  ajax.request("process.php");
}

function send_form_per_ajax()
{
  var ajax = new JR.AJAX();

  ajax.timeout = 10000; // 10 seconds

  ajax.onload = function(text, xml)
  {
    console.log("ajax success: " + text);
  };

  ajax.onerror = function(error)
  {
    console.log("ajax error: " + error);
  };

  var form = document.getElementById('my_form');

  var formData = new FormData(form);
  formData.append('some_param', "380");
  formData.append('another_param', "400");

  ajax.setFormData(formData);

  ajax.request(form.action);
}
*/

//----------------------------------------------------------------------
JR = {};
//----------------------------------------------------
JR.isEmptyObject = function(obj)
{
  for(var prop in obj)
  {
    if(Object.prototype.hasOwnProperty.call(obj, prop))
    {
      return false;
    }
  }

  return true;
}; // isEmptyObject
//----------------------------------------------------
JR.AJAX = function() {
  // Overridable events

  this.onload  = null;
  this.onerror = null;
  this.beforestart = null;
  this.aftercomplete = null;

  this.error_reported = false;
  this.aftercomplete_reported = false;

  this.running = false;

  this.debug = false;

  this.last_url = '';
  this.name = '-';

  this.timeout = 30000;

  // Arrays for GET and POST parameters

  this.GET  = new Array();
  this.POST = new Array();
  this.FORM_DATA = null;
  this.RAW_DATA = null;
  this.headers = new Array();

  // Timeout handle, for calling clearTimeout

  this.TIMEOUT_HANDLE = null;

  // Initialize

  this.XHR = new XMLHttpRequest();
}; // constructor
//----------------------------------------------------------------------
JR.AJAX.prototype.formDataFileFix = function(formData) {
  if(typeof formData.keys == 'undefined') return;

  try {
        if (formData.keys) {
            var formKeysToBeRemoved = [];

            var keyIterator = formData.keys();

            var item = keyIterator.next();

            while (!item.done) {
                var key = item.value;

                var fileName = null || formData.get(key)['name'];
                var fileSize = null || formData.get(key)['size'];
                if (fileName != null && fileSize != null && fileName == '' && fileSize == 0) {
                    formKeysToBeRemoved.push(key);
                }

                item = keyIterator.next();
            }

            for (var i = 0; i < formKeysToBeRemoved.length; i++) {
                formData.delete(formKeysToBeRemoved[i]);
            }
        }
    }
    catch(err) {
    }
} // formDataFileFix
//----------------------------------------------------------------------
JR.AJAX.prototype.resetParams = function()
{
  this.GET  = new Array();
  this.POST = new Array();
  this.FORM_DATA = null;
  this.RAW_DATA = null;
  this.headers = new Array();
};
//----------------------------------------------------------------------
JR.AJAX.prototype.setHeader = function(header, value)
{
  this.headers[header] = value;
};
//----------------------------------------------------------------------
JR.AJAX.prototype.setGET = function(vname, value)
{
  this.GET[vname] = value;
};
//----------------------------------------------------------------------
JR.AJAX.prototype.setPOST = function(vname, value)
{
  this.POST[vname] = value;
};
//----------------------------------------------------------------------
JR.AJAX.prototype.setFormData = function(formData)
{
  this.FORM_DATA = formData;
};
//----------------------------------------------------------------------
JR.AJAX.prototype.setRawData = function(rawData)
{
  this.RAW_DATA = rawData;
};
//----------------------------------------------------------------------
JR.AJAX.prototype.abort = function()
{
  if(this.debug) debug_line(this.name + ': AJAX Request aborted ' + (this.running ? '(was running)' : 'was not running'));

  if(!this.running) return;

  // Aborting fires the event onreadystatechange
  // as if the server did not respond.
  // To prevent unnecssary error messages, we set
  // error_reported to true.

  this.error_reported = true;

  if(this.TIMEOUT_HANDLE)
  {
    clearTimeout(this.TIMEOUT_HANDLE);
    this.TIMEOUT_HANDLE = null;
  }

  this.running = false;
  this.XHR.abort();

  if(!this.aftercomplete_reported && this.aftercomplete !== null)
  {
    this.aftercomplete_reported = true;
    this.aftercomplete('UserAbort');
  }
};
//----------------------------------------------------------------------
JR.AJAX.prototype.request = function(file)
{
  if(this.debug) debug_line(this.name + ': AJAX Request started');

  this.aftercomplete_reported = false;
  this.error_reported = false;
  this.running = true;

  var v;
  var post;

  this.XHR.abort(); // Close any other connections
  if(this.TIMEOUT_HANDLE)
  {
    clearTimeout(me.TIMEOUT_HANDLE);
    this.TIMEOUT_HANDLE = null;
  }

  this.last_url = file;

  if(!JR.isEmptyObject(this.GET))
  {
    if(this.last_url.indexOf("?") == -1) this.last_url += "?";
    else                                 this.last_url += "&";

    for(v in this.GET)
    {
      if(!Object.prototype.hasOwnProperty.call(this.GET, v)) continue;

      this.last_url += encodeURIComponent(v) + "=" + encodeURIComponent(this.GET[v]) + "&";
    }
  }

  if(this.beforestart !== null)
  {
    this.beforestart();
  }

  if(this.FORM_DATA != null)
  {
    this.formDataFileFix(this.FORM_DATA);

    this.XHR.open("POST", this.last_url, true);

    post = this.FORM_DATA;
  }
  else if(this.RAW_DATA != null)
  {
    this.XHR.open("POST", this.last_url, true);

    post = this.RAW_DATA;
  }
  else if(!JR.isEmptyObject(this.POST))
  {
    this.XHR.open("POST", this.last_url, true);

    post = "";

    for(v in this.POST)
    {
      if(!Object.prototype.hasOwnProperty.call(this.POST, v)) continue;

      post += v + "=" + encodeURIComponent(this.POST[v]) + "&";
    }
  }
  else
  {
    this.XHR.open("GET", this.last_url, true);
    post = null;
  }

  // For the IE, this should be done after open(),
  // otherwise it is not called.
  // It works in other browsers OK!
  // I spent hours to find out why the IE does not fire this event.

  var me = this;

  this.XHR.onreadystatechange = function()
  {
    if(!me) return;

    if(this.readyState == 4)
    {
      if(me.debug)
      {
        debug_line(me.name + ': AJAX Request ended (readyState:' + this.readyState + ', status:' + this.status + ', statusText:' + this.statusText + ')');
      }

      if(me.TIMEOUT_HANDLE)
      {
        clearTimeout(me.TIMEOUT_HANDLE);
        me.TIMEOUT_HANDLE = null;
      }

      me.running = false;

      if(this.status == 200)
      {
        // sucess
        if(me.onload !== null) me.onload(this.responseText, this.responseXML);

        if(me.aftercomplete !== null) me.aftercomplete(null);
      }
      else
      {
        var error = '';
        var info = {};

        info.status = this.status;

        if(this.statusText == '')
        {
          error = 'NoResponse';
        }
        else
        {
          error = this.statusText;
        }

        if(!me.error_reported && me.onerror !== null)
        {
          me.error_reported = true;
          me.onerror(error, me.last_url, info);
        }

        if(!me.aftercomplete_reported && me.aftercomplete !== null)
        {
          me.aftercomplete_reported = true;
          me.aftercomplete(error);
        }
      }
    }
    else
    {
      if(me.debug)
      {
        debug_line(me.name + ': AJAX Request state (readyState:' + this.readyState + ', status:' + this.status + ', statusText:' + this.statusText + ')');
      }
    }
  };

  // native timeout

  this.XHR.ontimeout = function()
  {
    if(!me) return;

    if(me.debug) debug_line(me.name + ': AJAX Request aborted due to the internal timeout');

    if(me.TIMEOUT_HANDLE)
    {
      clearTimeout(me.TIMEOUT_HANDLE);
      me.TIMEOUT_HANDLE = null;
    }

    me.running = false;

    var info = {};
    info.timeout = me.timeout;

    if(!me.error_reported && me.onerror !== null)
    {
      me.error_reported = true;
      me.onerror('Timeout', me.last_url, info);
    }

    if(!me.aftercomplete_reported && me.aftercomplete !== null)
    {
      me.aftercomplete_reported = true;
      me.aftercomplete('Timeout');
    }
  };

  // debug event

  this.XHR.onprogress = function(event)
  {
    if (event.lengthComputable)
    {
      if(me.debug) debug_line(me.name + ': AJAX Request progress - ' + Math.round(100 * event.loaded / event.total) + '%');
    }
  };

  this.XHR.timeout = parseInt(me.timeout) + 5000;

  for(h in this.headers)
  {
    this.XHR.setRequestHeader(h, this.headers[h]);
  }

  this.XHR.send(post);

  // Reset params

  this.resetParams();

  // if the native timeout handling fails

  this.TIMEOUT_HANDLE = setTimeout(function()
                                   {
                                     if(!me) return;

                                     if(me.debug) debug_line(me.name + ': AJAX Request aborted due to the timeout handler');

                                     var info = {};
                                     info.timeout = me.timeout;

                                     if(!me.error_reported && me.onerror !== null)
                                     {
                                       me.error_reported = true;
                                       me.onerror('Timeout', me.last_url, info);
                                     }

                                     if(!me.aftercomplete_reported && me.aftercomplete !== null)
                                     {
                                       me.aftercomplete_reported = true;
                                       me.aftercomplete('Timeout');
                                     }

                                     me.running = false;
                                     me.XHR.abort();
                                   }, me.timeout);
};
//----------------------------------------------------------------------

function foo() {
  for (var i = 0; i < arguments.length; i++) {
    console.log(arguments[i]);
  }
}

foo(1, 2, "Sasha", true);