Разница между this и self в JavaScript
Все знают о this javascript, но есть также примеры, self встречающиеся в дикой природе, например здесь
Итак, в чем разница между this и self в JavaScript?
Если вы используете функцию, которая выполняется в глобальной области видимости и не находится в строгом режиме, по this умолчанию window используется и, следовательно,
Небольшое дополнение к этому, поскольку люди могут столкнуться с этим в контексте сервис-воркеров, и в этом случае это означает что-то немного другое.
Вы можете увидеть это в модуле сервис-воркера:
Здесь self относится к WorkerGlobalScope, и это стандартный метод установки прослушивателей событий.
Используя self, вы можете ссылаться на глобальную область видимости таким образом, чтобы это работало не только в контексте окна (self разрешается в window.self), но также и в контексте worker (self затем разрешается в WorkerGlobalScope.self).
Хотя я здесь опоздал, я наткнулся на один пример, который тоже может быть полезен для this дальнейшего понимания :
O / P
До ECMA 5 this внутренняя функция ссылалась на глобальный объект окна; тогда как в ECMA 5 this внутренняя функция не определена.
Ссылка на ECMA 5 требует пояснения.
Следующие шаги выполняются, когда элемент управления входит в контекст выполнения для кода функции, содержащегося в объекте функции F, вызывающий объект предоставил thisArg, а вызывающий объект предоставил argumentsList:
Термин «глобальный объект» относится к любому объекту, находящемуся в верхней части цепочки областей видимости. Для браузеров это будет объект «окно», но это выбор реализации (Windows Script Host имеет невидимый глобальный объект, но не имеет строгого режима, поэтому неквалифицированные ссылки обращаются к его свойствам, а глобального «я» нет). Кроме того, «строгий режим» должен быть явно включен, иначе он не будет активен (раздел 14.1 стандарта). Таким образом, неопределенное «this» все равно будет преобразовано в глобальный объект (окно) в «ECMA 5» с неактивным строгим режимом.
Итак, ответ на вопрос:
«this» всегда относится к объекту, вызывающему функцию. Если функция не была вызвана объектом (т. Е. Не вызовом метода), то «this» (как передано в функцию) равно «undefined». Однако, если НЕ используется строгий режим, тогда неопределенное «this» устанавливается для глобального объекта (правило 2 выше).
«Я» не имеет особого синтаксического значения, это просто идентификатор. Браузеры обычно определяют window.self (просто свойство глобального объекта окна) = window. Это приводит к тому, что неквалифицированные ссылки на «self» являются такими же, как «window», ЕСЛИ «self» не было переопределено во включающей области (например, с помощью «var self = this;» выше. Удачи в переопределении «this»).
Итак, полное объяснение приведенного выше примера:
Интересный вариант примера создает замыкание, возвращая ссылку на внутреннюю функцию.
Обратите внимание, что внутренняя функция не вызывается, пока не будет вызвана yourObject. Итак, this.foo теперь является yourObject.foo, но self по-прежнему преобразуется в переменную в охватывающей области видимости, которая на момент возврата внутреннего объекта функции была (и в результирующем закрытии все еще остается) myObject. Итак, внутри внутренней функции «this» относится к объекту, вызывающему внутреннюю функцию, а «self» относится к объекту, который вызвал внешнюю функцию, чтобы создать ссылку на внутреннюю функцию.
Подводя итог резюме резюме, «this» определяется стандартом языка, «self» определяется тем, кто его определяет (разработчик среды выполнения или конечный программист).
Внутренний и внешний интерфейс
Материал на этой странице устарел, поэтому скрыт из оглавления сайта.
Один из важнейших принципов ООП – отделение внутреннего интерфейса от внешнего.
Это – обязательная практика в разработке чего угодно сложнее hello world.
Чтобы это понять, отвлечёмся от разработки и переведём взгляд на объекты реального мира.
Как правило, устройства, с которыми мы имеем дело, весьма сложны. Но разделение интерфейса на внешний и внутренний позволяет использовать их без малейших проблем.
Пример из жизни
Например, кофеварка. Простая снаружи: кнопка, индикатор, отверстия,… И, конечно, результат – кофе 🙂
Но внутри… (картинка из пособия по ремонту)
Масса деталей. Но мы можем пользоваться ей, совершенно не зная об этом.
Кофеварки – довольно-таки надёжны, не правда ли? Можно пользоваться годами, и только когда что-то пойдёт не так – придётся нести к мастеру.
Секрет надёжности и простоты кофеварки – в том, что все детали отлажены и спрятаны внутри.
Если снять с кофеварки защитный кожух, то использование её будет более сложным (куда нажимать?) и опасным (током ударить может).
Как мы увидим, объекты очень схожи с кофеварками.
Только для того, чтобы прятать внутренние детали, используется не кожух, а специальные средства языка и соглашения.
Внутренний и внешний интерфейс
В программировании мы будем разделять методы и свойства объекта на две группы:
Если продолжить аналогию с кофеваркой – то, что спрятано внутри кофеварки: трубка кипятильника, нагревательный элемент, тепловой предохранитель и так далее – это её внутренний интерфейс.
Внутренний интерфейс используется для обеспечения работоспособности объекта, его детали используют друг друга. Например, трубка кипятильника подключена к нагревательному элементу.
Но снаружи кофеварка закрыта специальным кожухом, чтобы никто к ним не подобрался. Детали скрыты и недоступны. Виден лишь внешний интерфейс.
Получив объект, всё, что нужно для пользования им – это знать внешний интерфейс. О внутреннем же знать вообще не обязательно.
Это были общие слова по теории программирования.
Далее мы реализуем кофеварку на JavaScript с приватными и публичными свойствами. В кофеварке много деталей, мы конечно, не будем моделировать каждый винтик, а сосредоточимся на основных приёмах разработки.
Шаг 1: публичное и приватное свойство
Локальные переменные, включая параметры конструктора, можно считать приватными свойствами.
В примере выше это power – мощность кофеварки, которая указывается при создании и далее будет использована для расчёта времени кипячения.
К локальным переменным конструктора нельзя обратиться снаружи, но они доступны внутри самого конструктора.
Здесь свойство waterAmount записано в объект, а значит – доступно для модификации снаружи. Можно доливать и выливать воду в любом количестве.
Далее мы будем называть power как «локальной переменной», так и «приватным свойством» объекта.
Это, смотря, с какой стороны посмотреть.
Термины «приватное свойство/метод», «публичное свойство/метод» относятся к общей теории ООП. А их конкретная реализация в языке программирования может быть различной.
Здесь ООП-принцип «приватного свойства» реализован через локальные переменные, поэтому и «локальная переменная» и «приватное свойство» – правильные термины, в зависимости от того, с какой точки зрения взглянуть – кода или архитектуры ООП.
Шаг 2: публичный и приватный методы
В результате естественным образом получается, что доступ к ним (через замыкание) имеют только другие функции, объявленные в том же конструкторе.
Шаг 3: константа
Удельная теплоёмкость WATER_HEAT_CAPACITY выделена большими буквами, так как это константа.
Внимание, при запуске кода выше в методе getBoilTime будет ошибка. Как вы думаете, почему?
Шаг 4: доступ к объекту из внутреннего метода
Её можно решить, если вызвать getBoilTime с явным указанием контекста: getBoilTime.call(this) :
К счастью существуют более элегантные решения.
Привязка через bind
Сохранение this в замыкании
Пожалуй, самый удобный и часто применяемый путь решения состоит в том, чтобы предварительно скопировать this во вспомогательную переменную и обращаться из внутренних функций уже к ней.
Теперь getBoilTime получает self из замыкания.
Итого
Итак, мы сделали кофеварку с публичными и приватными методами и заставили их корректно работать.
В терминологии ООП отделение и защита внутреннего интерфейса называется инкапсуляция.
Кратко перечислим бонусы, которые она даёт:
Защита пользователей от выстрела себе в ногу
Представьте, команда разработчиков пользуется кофеваркой. Кофеварка создана фирмой «Лучшие Кофеварки» и, в общем, работает хорошо, но с неё сняли защитный кожух и, таким образом, внутренний интерфейс стал доступен.
Все разработчики цивилизованны – и пользуются кофеваркой как обычно. Но хитрый Вася решил, что он самый умный, и подкрутил кое-что внутри кофеварки, чтобы кофе заваривался покрепче. Вася не знал, что те изменения, которые он произвёл, приведут к тому, что кофеварка испортится через два дня.
Виноват, разумеется, не только Вася, но и тот, кто снял защитный кожух с кофеварки, и тем самым позволил Васе проводить манипуляции.
В программировании – то же самое. Если пользователь объекта будет менять то, что не рассчитано на изменение снаружи – последствия могут быть непредсказуемыми.
Удобство в поддержке
Ситуация в программировании сложнее, чем с кофеваркой, т.к. кофеварку один раз купили и всё, а программа может улучшаться и дорабатываться.
При наличии чётко выделенного внешнего интерфейса, разработчик может свободно менять внутренние свойства и методы, без оглядки на коллег.
Гораздо легче разрабатывать, если знаешь, что ряд методов (все внутренние) можно переименовывать, менять их параметры, и вообще, переписать как угодно, так как внешний код к ним абсолютно точно не обращается.
Ближайшая аналогия в реальной жизни – это когда выходит «новая версия» кофеварки, которая работает гораздо лучше. Разработчик мог переделать всё внутри, но пользоваться ей по-прежнему просто, так как внешний интерфейс сохранён.
Люди обожают пользоваться вещами, которые просты с виду. А что внутри – дело десятое.
Программисты здесь не исключение.
Всегда удобно, когда детали реализации скрыты, и доступен простой, понятно документированный внешний интерфейс.
Задачи
Добавить метод и свойство кофеварке
Что лежит в основе этой идиомы JavaScript: var self = this?
автор использует self в некоторых местах (тело функции) и этой в других местах (тела функций, заданных в списке аргументов метода). Что происходит? Теперь, когда я заметил это однажды, я начну видеть это повсюду?
10 ответов
self используется для поддержания ссылки на оригинал this даже при изменении контекста. Это метод, часто используемый в обработчиках событий (особенно в закрытиях).
Я думаю, что имя переменной «self» больше не должно использоваться таким образом, поскольку современные браузеры предоставляют глобальная переменная self указывает на глобальный объект обычного окна или веб-пользователя.
чтобы избежать путаницы и потенциальных конфликтов, вы можете написать var thiz = this или var that = this вместо.
причина self по-прежнему доступен для функций, хотя они могут выполняться только после Note() функция закончила выполнять, что внутренние функции получают контекст внешней функции из-за закрытие.
следует также отметить, что существует альтернативный шаблон прокси для поддержания ссылки на оригинал this в обратном вызове, если вам не нравится var self = this идиома.
wrappedFunc затем можно вызвать и будет иметь вашу версию this в зависимости от контекста.
переменная захватывается встроенными функциями, определенными в методе. this в функции будет ссылаться на другой объект. Таким образом, вы можете сделать функцию ссылкой на this во внешней области.
это причуда JavaScript. Когда функция является свойством объекта, более метко называемым методом,этой относится к объекту. В Примере обработчика событий содержащим объектом является элемент, который инициировал событие. Когда вызывается стандартная функция, этой будет ссылаться на глобальный объект. Когда у вас есть вложенные функции, как в вашем примере, этой не относится к контексту внешней функции вообще. Внутренние функции делят область с содержащей функцией, поэтому разработчики будут использовать вариации var that = this для того, чтобы сохранить этой они нуждаются во внутренней функции.
как пояснил var self = this; позволяет код закрытие вернуться к родительской области.
однако теперь 2018 и ES6 широко поддерживаются всеми основными веб-браузерами. The var self = this; идиома не так важна, как когда-то.
теперь можно избежать var self = this; С помощью функции стрелочку.
в случаях, когда мы бы использовали var self = this :
теперь мы можем использовать функцию стрелки без var self = this :
функции стрелки не имеют своих собственных this и просто предположить видимости.
на самом деле self является ссылкой на окно ( window.self ), поэтому когда вы говорите var self = ‘something’ вы переопределяете ссылку окна на себя-потому что self существует в объекте окна.
вот почему большинство разработчиков предпочитают var that = this над var self = this;
Как упоминалось несколько раз выше, » я «просто используется для сохранения ссылки на» это » до входа в функцию. Когда-то в функции » это » относится к чему-то другому.
Difference between this and self in JavaScript
Everyone is aware of this in javascript, but there are also instances of self encountered in the wild, such as here
So, what is the difference between this and self in JavaScript?
5 Answers 5
A slight addition to this as people may encounter this in the context of service workers, in which case it means something slightly different.
You might see this in a service worker module:
Here self refers to the WorkerGlobalScope, and this is the standard method for setting event listeners.
By using self, you can refer to the global scope in a way that will work not only in a window context (self will resolve to window.self) but also in a worker context (self will then resolve to WorkerGlobalScope.self).
Although I am late here but I came across one example which too can be helpful to understand this further:
Prior to ECMA 5, this in the inner function would refer to the global window object; whereas, as of ECMA 5, this in the inner function would be undefined.
The reference to ECMA 5 needs clarifying.
I assume it means ECMA-262 Edition 5. It should be noted that ECMA-262 (a.k.a. ECMAScript or, less accurately, Javascript) is a general scripting language which has been implemented in Internet Browsers. From the Edition 5.1 standard:
The following steps are performed when control enters the execution context for function code contained in function object F, a caller provided thisArg, and a caller provided argumentsList:
The term «global object» refers to whatever object is at the top of the scope chain. For browsers this would be the «window» object but this is an implementation choice (Windows Script Host has an invisible global object but no strict mode so unqualified references access its properties and there is no global «self»). Also, «strict mode» must be explicitly enabled otherwise it is not active (section 14.1 of the standard). As such, an undefined «this» would still resolve to the global object (window) in «ECMA 5» with strict mode not active.
So the answer to the question is:
«this» always refers to the object invoking the function. If the function was not invoked by an object (i.e. not a method call) then «this» (as passed to the function) is «undefined». However, if NOT using strict mode then an undefined «this» is set to the global object (rule 2 above).
«self» has no special syntactic meaning, it is just an identifier. Browsers tend to define window.self (just a property of the global window object) = window. This results in unqualified references to «self» being the same as «window» UNLESS «self» has been redefined within an enclosing scope (such as by «var self = this;» above. Good luck redefining «this».)
So the full explanation of the example above is:
An interesting variation of the example creates a closure by returning a reference to the inner function.
Note how the inner function is not called until invoked by yourObject. So this.foo is now yourObject.foo but self still resolves to the variable in the enclosing scope which, at the time the inner function object was returned, was (and in the resulting closure still is) myObject. So, within the inner function, «this» refers to the object calling the inner function while «self» refers to the object which called the outer function to create the reference to the inner function.
To summarize the summary of the summary, «this» is defined by the language standard, «self» is defined by whoever defines it (runtime implementer or end programmer).
Что означает «self» в javascript?
Самость в данном случае, по-видимому, не относится к текущей форме:
Однако в этом случае он работает (ссылаясь на окно):
5 ответов
То ЕСТЬ Странности
self не является зарезервированным ключевым словом или стандартным типом, но стало стандартным именем defacto, когда для сохранения ссылки на объект для closures.
Никогда, если только я не хотел создать переменную self в области действия функции, ссылающейся на контекст для последующего использования,
self относится к глобальной области контекста:
Я много раз сталкивался с этой строкой в модулях perl, но не мог понять, что именно это означает. my ($self, %myInputs) = @_; Пожалуйста, объясните мне это заявление,чтобы я мог продолжить.
Это используется в паттерне weakify Objective-C Я предполагаю, что это означает: назначьте слабую ссылку на self с именем ‘weakSelf’ и типом self (например, MyViewController) Если это правильно и кажется вам очевидным: я хочу быть абсолютно уверен, что все будет правильно. Спасибо.
Похожие вопросы:
Кажется, я не могу понять, что означает 1..self в этом code..more конкретно, я не могу понять, что возвращает self в этой области? ( Например, я знаю, что означает 1. 10 class Fixnum def.
Я новичок в Python. Я не мог понять, что означает is True в этом случае: class Answers(): def get_reference(self): return None def is_private(self): return getattr(self, ‘private’, False) is True Я.
