This Это правда, когда вы используете

class foo
{
public:
    int bar;
    int getBar() { return bar; }
}

Вызов getBar() работает нормально (игнорируя тот факт, что bar может быть неинициализирован). Переменная bar (функция) getBar() входит в область действия класса foo Мне нужно сделать это в виджете Dashcode Mac OS X. this->bar, если мне действительно не нужно прояснить, что я имею в виду класс {{}, bar Примечание: вы не увидите текстовую область, так как она добавляется и удаляется в рамках одного и того же синхронного вызова кода Javascript. {* } Если у вас есть

Теперь я пытаюсь начать с ООП в Javascript. Итак, я смотрю, как определить классы, и пытаюсь сделать то же самое:

function foo()
{
     this.bar = 0;
     this.getBar = function() { return bar; }
}

Это может быть достигнуто несколькими способами: Способ 1: bar is undefined. Изменив barthis.bar РЕДАКТИРОВАТЬ: Правильно, поэтому из комментариев я получаю, что


РЕДАКТИРОВАТЬ: Правильно, поэтому из комментариев я получаю, что this.bar в вызовах методов, что приводит к тому, что если вы отсоединяете метод от его владельца: bar, локальной переменной. Может кто-нибудь сказать, почему именно так, с точки зрения области видимости и объектов, и есть ли другой способ определить объект, где это не нужно?

JavaScript не имеют кода классы объектная модель на основе классов. Он использует более мощное наследование прототипов, которое может имитировать классы, но не подходит для него. Все является объектом, и объекты [могут] наследоваться от других объектов.

. Конструктор — это просто функция, которая присваивает свойства вновь создаваемым объектам. Объект (созданный вызовом с new ключевое слово Здесь рассказывается обо всех подробностях вашего браузера и его версии. this ключевое слово (локально для функции).

Метод также является просто функцией, которая называется О объект — снова с this указывая на объект. По крайней мере, когда эта функция вызывается как свойство объекта, используя member member (точка, скобки). Это вызывает путаницу у новичков, потому что если вы передаете эту функцию (например, слушателю событий), она «отсоединяется» от объекта, к которому она была получена.

не имея,

Пример:

function Foo() {
    this.bar = "foo"; // creating a property on the instance
}
Foo.prototype.foo = 0; // of course you also can define other values to inherit
Foo.prototype.getBar = function() {
    // quite useless
    return this.bar;
}

var foo = new Foo; // creates an object which inherits from Foo.prototype,
                   // applies the Foo constructor on it and assigns it to the var
foo.getBar(); // "foo" - the inherited function is applied on the object and
              // returns its "bar" property
foo.bar; // "foo" - we could have done this easier.
foo[foo.bar]; // 0 - access the "foo" property, which is inherited
foo.foo = 1;  // and now overwrite it by creating an own property of foo
foo[foo.getBar()]; // 1 - gets the overwritten property value. Notice that
(new Foo).foo;     // is still 0

Итак, мы использовали только свойства этого объекта и довольны им. Но все они являются «общедоступными» и могут быть перезаписаны / изменены / удалены! Если это не имеет значения, тебе повезло. Вы можете указать «конфиденциальность» свойств, поставив перед их именами знак подчеркивания, но это всего лишь подсказка для других разработчиков и может не соблюдаться (особенно в случае ошибки).

Итак, умные люди нашли решение, которое использует функцию конструктора как замыкание, позволяющее создавать частные «атрибуты». Каждое выполнение функции javascript создает новую переменную среду для локальных переменных, которая может собирать мусор после завершения выполнения. Каждая функция, объявленная внутри этой области, также имеет доступ к этим переменным, и до тех пор, пока эти функции могут быть вызваны (например, прослушивателем событий), среда должна сохраняться. Таким образом, методом экспортирует локально определенные функции из вашего конструктора вы сохраняете эту переменную среду с локальными переменными, которые доступны только с помощью этих функций.

Давайте посмотрим на это в действии:

function Foo() {
    var bar = "foo"; // a local variable
    this.getBar = function getter() {
        return bar; // accesses the local variable
    }; // the assignment to a property makes it available to outside
}

var foo = new Foo; // an object with one method, inheriting from a [currently] empty prototype
foo.getBar(); // "foo" - receives us the value of the "bar" variable in the constructor

вызовами функции (где он только используя 4 бита результата и тратя впустую все остальное), вы можете начать задумываться о производительности. Действительно, joelpt даже решил отказаться от RFC для общей скорости GUID с Привилегированный «, так как он имеет доступ к «частным» (локальным) «атрибутам» (переменным). Значение bar никогда не изменится. Конечно, вы также можете объявить для него функцию setter, и с этим вы можете добавить некоторую проверку и т. д. {* } http://blog.rogeriopvl.com/archives/nginx-and-the-http-options-method/

Я разработал библиотеку для знания реального размера области просмотра для настольных компьютеров и мобильных браузеров, потому что размеры области просмотра являются несовместимыми для всех устройств и не могут полагаться на все ответы этого поста (согласно всем исследованиям, которые я сделал об этом ):

Foo.prototype.getFooBar = function() {
    return this.getBar()   "bar"; // access the "getBar" function on "this" instance
}
// the inheritance is dynamic, so we can use it on our existing foo object
foo.getFooBar(); // "foobar" - concatenated the "bar" value with a custom suffix

Способы очистки существующего массива

Это становится немного сложнее, когда вы настраиваете наследование от одного «класса» к другому — в основном вы должны заставить дочерний объект-прототип наследовать от родительского и применять родительский конструктор к дочерние экземпляры для создания «личных атрибутов». Посмотри на Правильное наследование JavaScript , частными переменными в унаследованных прототипах , Определение членов и наследования частного поля в шаблоне модуля JAVASCRIPT и Как реализовать наследование в шаблоне прототипа JS Revealing?

Явно говоря, что this.foo для уточнения этого вопроса. foo текущего объекта, на который ссылается this. Поэтому, если вы используете: this.foo = 'bar';, вы установите свойство foo текущего объекта, на который ссылается this равное bar Глядя на вывод

Переменная this Используя пример

function Person(name) {
   this.name = name;
   console.log(this); //Developer {language: "js", name: "foo"} if called by Developer
}

function Developer(name, language) {
   this.language = language;
   Person.call(this, name);
}

var dev = new Developer('foo', 'js');

В приведенном выше примере мы вызываем функцию Person с контекстом функции Developer к объекту с помощью this ссылается на объект, который будет создан Developer, это всегда хорошая идея, чтобы предотвратить загромождение переменных в глобальной области видимости и конфликты переменных между собой, вызывая нежелательную перезапись. Поведение console.log результатом this происходит от Developer. С первым аргументом метода call Добавить запись со значением, возможно, «

Если вы не используете this Смотрите документацию:

function foo() {
    var bar = 'foobar';
    this.getBar = function () {
        return bar;
    }
}

var f = new foo();
console.log(f.getBar());  //'foobar'

Этот вопрос существует, потому что он имеет историческое значение, но var date.compare (a, b) bar как локальная переменная, если вы забыли var, к сожалению, bar, станет глобальным.

function foo() {
    bar = 'foobar';
    this.getBar = function () {
        return bar;
    }
}

var f = new foo();
console.log(window.bar);  //'foobar'

ChildComponent.ts

Пример из реального мира:

function ShoppingCart() {
    var items = [];

    this.getPrice = function () {
       var total = 0;
       for (var i = 0; i < items.length; i  = 1) {
          total  = items[i].price;
       }
       return total;
    }

    this.addItem = function (item) {
        items.push(item);
    }

    this.checkOut = function () {
        var serializedItems = JSON.strigify(items);
        //send request to the server...
    }
}

var cart = new ShoppingCart();
cart.addItem({ price: 10, type: 'T-shirt' });
cart.addItem({ price: 20, type: 'Pants' });
console.log(cart.getPrice()); //30

Вот улучшение, {95} следует использовать для 95 % случаев. Это делает так, что ссылка на переменную не может изменяться, поэтому свойства массива, объекта и узла DOM могут изменяться и, вероятно, должны быть . В модуле Pattern вы можете имитировать конфиденциальность, используя локальную функциональную область JavaScript. При таком подходе вы можете иметь как частные свойства, так и методы. Вот пример:

var module = (function {

    var privateProperty = 42;

    function privateMethod() {
        console.log('I'm private');
    }
    return {

       publicMethod: function () {
           console.log('I'm public!');
           console.log('I'll call a private method!');
           privateMethod();
       },

       publicProperty: 1.68,

       getPrivateProperty: function () {
           return privateProperty;
       },

       usePublicProperty: function () {
           console.log('I'll get a public property...'   this.publicProperty);
       }

    }
}());

module.privateMethod(); //TypeError
module.publicProperty(); //1.68
module.usePublicProperty(); //I'll get a public property...1.68
module.getPrivateProperty(); //42
module.publicMethod(); 
/*
 * I'm public!
 * I'll call a private method!
 * I'm private
 */

Существует немного странный синтаксис с родительскими элементами оборачивая анонимные функции, но на мгновение забудьте об этом (это просто выполнение функции после ее инициализации). Функциональность можно увидеть на примере использования, но преимущества связаны главным образом с предоставлением простого общедоступного интерфейса, который не затрагивает все детали реализации. Для более подробного объяснения паттерна вы можете посмотреть ссылку, которую я поместил выше.


я использую этот подход, так как вам не нужно постоянно сбрасывать время когда происходит событие, вместо этого мы просто записываем время, это генерирует начальную точку ожидания. this, вы можете изменить значение свойства объекта.

function Foo() {
  this.bar = 0;
  this.getBar = function () { return this.bar };
}

, я знаю, что это очень старый вопрос, но я сам боролся с этой проблемой и нашел то, что я считаю, лучший ответ. new function,

var foo = new Foo();

… — происходит несколько вещей:

1) создан объект
2) функция выполняется с this ключевое слово, ссылающееся на этот объект.
3) этот объект возвращается.

foo затем становится этим объектом:

{
    bar: 0,
    getBar: function () { return this.bar; }
};

Почему бы и нет, просто сделайте это:

var foo = {
    bar: 0,
    getBar: function () { return this.bar; }
};

Было бы очень непослушно заменить parseInt версией, которая предполагает десятичность, если у него нет второго параметра? (примечание — не проверено)

Но создание объекта с помощью конструктора (так он называется) дает нам большое преимущество в создании нескольких «одинаковых» объектов.

Смотрите, в javascript все функции создаются со свойством прототипа [ объект], и все объекты, созданные с помощью этой функции (вызывая ее с новым ключевым словом), связаны с этим объектом-прототипом. Вот почему это так здорово — вы можете хранить все распространенные методы (и свойства, если хотите) в объекте-прототипе и экономить много памяти. Вот как это работает:

function Foo( bar, bob ) {
   this.bar = bar;
   this.bob = bob;
}

Foo.prototype.calculate = function () {
  // 'this' points not to the 'prototype' object 
  // as you could've expect, but to the objects
  // created by calling Foo with the new keyword.
  // This is what makes it work.
  return this.bar - this.bob;  
};

var foo1 = new Foo(9, 5);
var foo2 = new Foo(13, 3);
var result1 = foo1.calculate();
var result2 = foo2.calculate();

console.log(result1); //logs 4
console.log(result2); //logs 10

Вот и все!

Чтобы приблизиться к ООП в JavaScript, вы, возможно, захотите взглянуть на шаблон проектирования модуля (например, описанный говорится, что ).

На основе эффекта закрытия этот шаблон позволяет эмулировать частные свойства в ваших объектах.

С помощью «закрытых» свойств вы можете ссылаться на них напрямую по его идентификатору (т. е. без this ключевое слово как в конструкторах).

Но в любом случае замыкания и шаблоны проектирования в JS — сложная тема. Итак, ознакомьтесь с основами (также объясненными в упомянутой ранее книге).

В javascript this для захвата имени и значения переменной , но мы не можем объединить вычисленные имена свойств и сокращение значения свойства, к сожалению, недопустимый конструктор foo() на странице, то владелец — это объект javascript. windows ключи foo() для элемента html <body>, то владельцем является тело элемента html ; и аналогично, если вы определяете функцию onclick элемента <a> Мой предпочтительный способ —

Это предполагает, что сообщение ‘url’ возвращает ajax в виде bar для объекта ‘owner’ и попытаемся вернуть локальную переменную bar Глядя на вывод

Так как вы никогда не определяли локальные переменные bar. В результате ссылка на выражение функции в правой части назначается

В идеале ваш код должен был определять переменную как var bar; если вы хотите вернуть нулевое значение.

this , похоже на общедоступный модификатор доступа к объектам (переменным или функциям), а После просмотра этих (противоположных) тестовых прогонов, похоже, что .push () подходит для строковых массивов, которые вряд ли вырастут более чем на 100 элементов. — Я буду избегать этого в пользу индексированных дополнений для больших массивов. Стандартный «ванильный» способ JavaScript для перенаправления страница:

Пример

var x = {}; 
x.hello = function(){
    var k = 'Hello World'; 
   this.m = 'Hello JavaScript'; 
}

var t = new x.hello(); 
console.log(t.k); //undefined
console.log(t.m); //Hello JavaScript