Неверный оператор JavaScript: "var x = new this();"

Ответ 1

AJS.Class эффективно * переводит это:

var Person = new AJS.Class({
    init: function(name) {
        this.name = name;
        Person.count++;
    },
    getName: function() {
        return this.name;
    }
});
Person.count = 0;

в это:

var Person = function (name) {
    this.name = name;
    Person.count++;
};

Person.prototype = {
    getName: function() {
        return this.name;
    }
};

Person.extend = AJS.Class.prototype.extend;
Person.implement = AJS.Class.prototype.implement;

Person.count = 0;

Следовательно, в этом случае this в AJS.Class.prototype.extend относится к Person, потому что:

Person.extend(...);
// is the same as
Person.extend.call(Person, ...);
// is the same as
AJS.Class.prototype.extend.call(Person, ...);

* Есть много случаев, когда я не перехожу; это переписать для простоты в понимании проблемы.

Ответ 2

Что вас сбивает с толку, я думаю, именно там, где действительно существует "this". Так что медведь со мной - вот очень краткое объяснение, которое, я надеюсь, станет понятным.

В JavaScript, что "this" относится к функции, всегда определяется во время вызова функции. Когда вы выполните:

jimmy.nap();

Функция nap (method) запускается и принимает jimmy как "this".

Какие объекты имеют ссылки на сон, не имеет значения. Например:

var jimmy = {}, billy = {};
jimmy.nap = function(){ alert("zzz"); };
var jimmy_nap = jimmy.nap;
jimmy_nap(); // during this function execution, this is *NOT* jimmy!
             // it is the global object ("window" in browsers), which is given as the 
             // context ("this") to all functions which are not given another context.
billy.sleep = jimmy.nap;
billy.sleep(); // during this function excution, this is billy, *NOT* jimmy
jimmy.nap(); //okay, this time,  this is jimmy!

Другими словами, всякий раз, когда у вас есть:

var some_func = function(arg1, arg2){ /*....*/ };
// let say obj and other_obj are some objects that came from somewhere or another
obj.some_meth = some_func;
other_obj.some_meth = some_func;
obj.some_meth(2, 3);
other_obj.some_meth(2, 3);

То, что он "переводится" (а не буквально - это педагогически, а не о том, как фактически работают переводчики javascript), выглядит примерно так:

var some_func = function(this, arg1, arg2){ /* ...*/ };
// let say obj and other_obj are some objects that came from somewhere or another
obj.some_meth = some_func;
other_obj.some_meth = some_func;
obj.some_meth(obj, 2, 3);
other_obj.some_meth(other_obj, 2, 3);

Итак, обратите внимание, как расширение используется в примере на этой странице:

UniversityPerson = Person.extend({ /* ... */ });

Поп-опрос: когда продлевает пробеги, что думает "this"? Ответ: Правильно. "Человек".

Таким образом, озадачивающий код на самом деле такой же, как (в этом конкретном случае):

var prototype = new Person('no_init');

Не так загадочно, а? Это возможно, потому что, в отличие от некоторых языков, переменная JavaScript, включая "this", может содержать любое значение, включая функцию, такую ​​как Person.

(Нет ничего, что делает Person конкретным конструктором. Любая функция может быть вызвана с помощью нового ключевого слова. Если я назову точную семантику, я думаю, что это то, что когда функция вызывается с новым ключевым словом, она автоматически задается пустой объект ({}) в качестве его контекста ("this"), а когда функция возвращается, возвращаемое значение - это тот же самый объект, если только (возможно?) функция возвращает что-то еще)

Это крутой вопрос, потому что он говорит о довольно важной части четкости или странности JavaScript (в зависимости от того, как вы его видите).

Отвечает ли это на ваш вопрос? При необходимости я могу уточнить.

Ответ 3

Представьте себе следующую ситуацию:

var inner = function () {
    var obj = new this;
    console.log(obj.myProperty);
};

var f1 = function () {
    this.myProperty = "my Property"
}

f1.f2 = inner;
f1.f2();

Здесь вызывающий объект сам является функцией, поэтому этот возвращает функцию, и мы можем создать экземпляр.

Чтобы использовать this() (не this), внешняя функция (контекст) должна сама возвращать smth, которая может быть создана (другая функция):

var inner = function () {
    var obj = new this();
    console.log(obj.myProperty);
};

var f1 = function () {
    var func = function () {};
    func.myProperty = 'my property';
    return func;
};

f1.f2 = inner;
f1.f2();

Ответ 4

В javascript static вы можете вызвать new this() так,

var Class = function(){}; // constructor
Class.foo = function(){return this;} // will return the Class function which is also an object

Следовательно,

Class.foo = function(){ return new this();} // Will invoke the global Class func as a constructor

Мораль истории состоит в том, чтобы не забывать, что функции такие же, как любые другие объекты, когда вы их не называете.

Ответ 5

см. ссылку http://www.quirksmode.org/js/this.html Он расскажет вам об этом ключевом слове, но я не уверен, что это(), может быть его определенной функцией, определяемой пользователем...... что вы не знаете...

Ответ 6

"this" означает контекст текущей функции.

Код, который вы отправляете, определенно отображается в функции, которая действует как метод для объекта. Таким образом, объект является контекстом функции.

"new this()" вернет клон текущего объекта после запуска его функции-конструктора с переданными аргументами.

Ответ 7

this() относится к функции, в которой находится код, но это() должно быть в пределах этой функции. Вызов new this(); внутри функции создаст бесконечный цикл. Вызов его вне функции будет лишним, потому что нет функции/класса, заданного как this().