Javascript-форум (https://javascript.ru/forum/)
-   Общие вопросы Javascript (https://javascript.ru/forum/misc/)
-   -   хитросплетения Global,контекст,this,Reference (https://javascript.ru/forum/misc/3158-khitrospleteniya-global-kontekst-reference.html)

kefi 23.03.2009 15:37

хитросплетения Global,контекст,this,Reference
 
Не въезжаю в стандарт, может кто поможет:
Вот почему так получается :
function al(o){document.write(o,'<br>')} // для html
function al(o){WScript.Echo(o)} ; // для WSH
for (var x in this) al([[x]]) // Здесь Ошибка после распечатки первого значения свойства Глобального объекта (или this, не знаю - совпадут ли они ...) 
// Ошибка выполнения Microsoft JScript: Предполагается наличие объекта


(function qq() {})(); // - вызывает ошибку в for in см выше, если строчку закоментировать, или сделать так v=(function qq() {})() , то ошибки нет ! 
// даже так (function qq() {return {}})() , т.е. вроде как я возвращаю обхект в качестве свойства, но все равно возникает та же ошибка в for in выше
(1); // - та же ошибка в for in
1 ;//  - не вызывает ошибки, т.е. вроде как свойствами глобального объекта могут быть примитивные значения . а не только объекты ?!


Если кто понимает хитросплетения Global,контекст,this,Reference (в стандарте) , объясните, плз, понятными словами , я пока никак не могу въехать.

Zeroglif 23.03.2009 18:40

Точку с запятой надо ставить после al([[x]]).

пысы: "Хитросплетения Global,контекст,this,Reference" понимаю, но желательно получить более конкретный вопрос. ;)

kefi 23.03.2009 20:10

2 Zeroglif > на точку с зпт я - то и не подумал. В этом-то собствно и была причина непоняток.
Вот правда еще есть - ведь все реализации обязаны делать расширяемыми свойства всех своих объектов в том числе и объектов среды типа WScript? Или я не правильно понимаю? Но MS почему-то сделал this.WScript не могущим добавлять новые /переопределять существующие свойства у этог объекта. Как такое понимать ?

Zeroglif 23.03.2009 21:53

Цитата:

Сообщение от kefi
все реализации обязаны делать расширяемыми свойства всех своих объектов

Не обязаны.

kefi 24.03.2009 16:43

Вот еще вопрос :
function al(o){document.write(o,'<br>')} ;
for (var x in this) {al([[x]])      } ; // здесь будет function Person() { al("qqq")   }   ;
function Person() { al("zxc")   }   ;
///*
var Person = function () {al("123")}; 
//	*/
function Person() { al("qqq")   }   ;
al(Person) ; // Здесь распечатается function () {al("123")}
Person() ; // 123 здесь вызовется, соответствующая var Person=function

Почему глобальный объект получает в качестве свойства Person то , которое в строке function Person() ... , а не которое в строке
var Person = function ... ?

twolf 24.03.2009 17:06

потому что вы переопределили Person, т.е. объявили еще раз эту функцию, но другим способом.

Gvozd 24.03.2009 17:11

twolf,
я тоже так подумал сперва.но это не так.
как вы объясните такой код, тогда
function al(o){document.write(o,'<br>')} ;
al(Person) ;

var Person = function () {al("123")}; 
function Person() { al("zxc")   }   ;

al(Person) ;

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

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

kefi 24.03.2009 17:17

2 twolf ,Gvozd> Да я подправил предыдущий пост

Gvozd 24.03.2009 17:19

походу мои измышления верны только для общего контекста
то есть достаточно обернуть любой из кодов выше просто в фигурные скобочки, для смены контекста, и уже будет работать нормальная логика, с переопределением

все, что я сейчас написал было результатом моих размышлений, а не точным знанием

kefi 24.03.2009 17:19

Цитата:

PS я так подозреваю, что сперва в глобальную область видимости пихаются именованные функции, и лиш затем по порядку анонимные.в свете такой теории, становится понятно почему эти два примера так работают
Так а разве var Person=function ... не есть определение именованной , ей же присваивается имя ?!

Gvozd 24.03.2009 17:21

Цитата:

Сообщение от kefi
Так а разве var Person=function ... не есть определение именованной , ей же присваивается имя ?!

нет.это анонимная функция.

kefi 24.03.2009 17:30

2 Gvozd >
Насчет анонимных функций как-то еще нужно проверить ...
И еще - ведь можно сделать var Person = function PPP ... // - результат не изменится !!
PS .
Что-то не получается меня со скобочками , опубликуйте пример, плз.

twolf 24.03.2009 17:32

читаем тут. http://javascript.ru/tutorial/basic/...aniie-funktsii

Gvozd,
в вашем примере сначала выводится person который определен с помощью function(виден везде), а var Person еще не определен.
После определения var Person заменяется соответствующая функция Person, и выводится новое значение

Gvozd 24.03.2009 17:38

function al(o){document.write(o,'<br>')} ;
al(Person) ;//здесь будет указана именованая функция.та, которая была объявлена последней
function Person() { al("zxc")   }   ;
al(Person) ;// та же ботва
var Person = function () {al("123")}; 
al(Person) ;//опаньки.появилась анонимная.ее и пишем
function Person() { al("qqq")   }   ;
al(Person) ; //та же ботва

al('-----------------') ;
	{
	//создали новый контекст исполнения
	al(Person_) ;//нету еще никакой функции
	function Person_() { al("zxc")   }   ;
	al(Person_) ;//каждая новая функция переопределяет старую
	var Person_ = function () {al("123")}; 
	al(Person_) ;//каждая новая функция переопределяет старую
	function Person_() { al("qqq")   }   ;
	al(Person_) ; //каждая новая функция переопределяет старую
	
	}

//судя по всему интепретатор сначала прогоняет глобальный контекст, на предмет наличия именованных функций, и создавая их
//причем в подконтексты он не лезет
//в памяти остается  последняя из именованных функций
//потом неспеша строку за строкой выполняет программу, переопределяя по мере необходимости
//в подконтекстах то же самое, но без предвариловки с именованными функциями

PS IMHO.

Gvozd 24.03.2009 17:39

Цитата:

Сообщение от twolf
в вашем примере сначала выводится person который определен с помощью function(виден везде), а var Person еще не определен.
После определения var Person заменяется соответствующая функция Person, и выводится новое значение

да. я так собственно уже и понял

kefi 24.03.2009 21:36

2 Gvozd > Дайте плз ссылку , в ECMA не нашел, не понял этой синтаксической структуры :
{
    //создали новый контекст исполнения
  // ....
}

Zeroglif 24.03.2009 21:47

http://javascript.ru/ecma/part10#a-10.1.3

Для объявленных функций:
Цитата:

Если в объекте переменных уже есть свойство с таким именем, заменить его значение и атрибуты.
Для переменных:
Цитата:

Если в объекте переменных уже существует свойство с именем объявленной переменной, значение свойства и его атрибуты не изменяются.
И не путайте "создание/конкретизацию переменных" при котором переменная наполняется свойством 'undefined' и обычное построчное наполнение переменной тем, что справа от знака 'равно'. Первое происходит на "нулевой" строке кода, второе - по ходу дела. В вышеприведённых примерах 'var Person' при конкретизации "слабее" 'function Person', переменная не создаётся, т.к. имя уже занято, слово 'var' мысленно можно зачеркнуть, оставив только присвоение "Person = ...". А уже присвоение выкидывает предыдущее значение, занятое функцией на нулевой строке.

Zeroglif 24.03.2009 21:48

Цитата:

Сообщение от kefi
Дайте плз ссылку , в ECMA не нашел

Это его раз(из)мышления, фигурные контекст не создают... ;)

Gvozd 24.03.2009 21:55

kefi,
блин даже не знаю.
термин взял из головы.
справки по тому что написал дать не могу, ибо теперь я не понимаю, почему оно так!)
походу такое поведение не подчиняется каким-либо стандартам
более того, поведение указанное мною в коментариях наблюдается только в мозилле. в остальных же все в порядке вещей, независимо от "контекста исполнения"
согласно стандартам должно быть так:
Цитата:

Сообщение от http://javascript.ru/tutorial/basic/functions
В отличие от ряда языков, блоки не задают отдельную область видимости. Без разницы - определена переменная внутри блока или вне его. Так что эти два фрагмента совершенно эквивалентны:

в опере и осле так и работает:
Код:

function Person() { al("qqq") }
function Person() { al("qqq") }
function () {al("123")}
function () {al("123")}
-----------------
function Person_() { al("qqq_") }
function Person_() { al("qqq_") }
function () {al("123_")}
function () {al("123_")}

в мозилле же такое:
Код:

function Person() { al("qqq"); }
function Person() { al("qqq"); }
function () { al("123"); }
function () { al("123"); }
-----------------
undefined
function Person_() { al("zxc"); }
function () { al("123"); }
function Person_() { al("qqq"); }

судя по всему в огнелисе в такой хитрой конструкции создается свой контекст, по правилам отличным от каких-либо стандартов.
протестируйте код ниже в огнелисе, и в другом браузере.
реально странные вещи творятся у огнелиса
function al(o){document.write(o,'<br>')} ;
al(Person) ;//здесь будет указана именованая функция.та, которая была объявлена последней
function Person() { al("zxc")   }   ;
al(Person) ;// та же ботва
var Person = function () {al("123")}; 
al(Person) ;//опаньки.появилась анонимная.ее и пишем
function Person() { al("qqq")   }   ;
al(Person) ; //та же ботва
al('-----------------') ;
    {
    //создали новый контекст исполнения
    al(Person_) ;//нету еще никакой функции
    function Person_() { al("zxc_")   }   ;
    al(Person_) ;//каждая новая функция переопределяет старую
    var Person_ = function () {al("123_")}; 
    al(Person_) ;//каждая новая функция переопределяет старую
    function Person_() { al("qqq_")   }   ;
    al(Person_) ; //каждая новая функция переопределяет старую
 
    }
al('-----------------') ;
(function(){
	
	
    //создали новый контекст исполнения
    al(Person__) ;//нету еще никакой функции
    function Person__() { al("zxc__")   }   ;
    al(Person__) ;//каждая новая функция переопределяет старую
    var Person__ = function () {al("123__")}; 
    al(Person__) ;//каждая новая функция переопределяет старую
    function Person__() { al("qqq__")   }   ;
    al(Person__) ; //каждая новая функция переопределяет старую
	
	})()
al('-----------------') ;
for(i=0;i<1;i++)
	{
    //создали новый контекст исполнения
    al(Person__1) ;//нету еще никакой функции
    function Person__1() { al("zxc__1")   }   ;
    al(Person__1) ;//каждая новая функция переопределяет старую
    var Person__1 = function () {al("123__1")}; 
    al(Person__1) ;//каждая новая функция переопределяет старую
    function Person__1() { al("qqq__1")   }   ;
    al(Person__1) ; //каждая новая функция переопределяет старую
	}

Dmitry A. Soshnikov 24.03.2009 22:03

Цитата:

Сообщение от Gvozd
нет.это анонимная функция.

Точнее, Function Expression (FE). FE может быть и именованной функцией:

var a = function a() {...};


Основных отличий FE от FD (Function Declaration) два:

1. FE создаётся в рантайме (тогда как FD создается до построчного выполнения скрипта);
2. FE не воздействует на Variable object (VO) функции/контекста.

Первый пункт, вроде, и так все знают (кто более-менее знаком с JS). Однако, во многих статьях он описан поверхностно, и в основном FE приравнивается лишь к анонимной функции (что и создаёт путаницу). В то время как, разновидностей FE гораздо больше.

(function a() {...}); // это тоже, например, FE
alert(a); // как видим, на VO это не повлияло, и такой переменной нет - ошибка.


Цитата:

Сообщение от Gvozd
//создали новый контекст исполнения al(Person_) ;//нету еще никакой функции

Туда же относится (к FE). В скобках может быть только FE (не важно, что лексически они записаны в виде FD), поэтому функции будут созданы в рантайме, а не до начала выполнения скрипта. Кстати, это правильное (согласно стандарту) поведение сейчас можно наблюдать только в Firefox (в остальных браузерах - там будут построены FD).

Новый контекст исполнения здесь не создаётся. Однако, в новых версиях, блок из фигурных скобок может создавать отдельный scope (если интересно, почитайте про let на MDC и т.д.).

upd:

Цитата:

Сообщение от Gvozd
судя по всему в огнелисе в такой хитрой конструкции создается свой контекст, по правилам отличным от каких-либо стандартов.

Повторю, как раз-таки, наоборот. В Firefox - правильное поведение, в остальных (пока) - неправильное.

kefi 31.03.2009 22:01

Цитата:

Сообщение от 2 Dmitry A. Soshnikov
1. FE создаётся в рантайме (тогда как FD создается до построчного выполнения скрипта);

Это Значит, что если в конструкторе есть такое выражение
this.action1=function(){ /* код функции */; },
то оно будет создавать новую функцию при каждом вызове этого конструктора для построения объекта ?
Если да, то тогда будет лучше для экономии памяти и времени делать
в конструкторе так :
function F (){ /* код функции */; },
this.action1=F ;
?

Dmitry A. Soshnikov 31.03.2009 23:05

kefi, нет. Всё-таки, слово "скрипт" получилось несколько путанным в этой формулировке (вот только недавно насчёт этого же вопрос был).

Перефразирую точнее:

FD создается при входе в контекст исполнения, до построчного его выполнения. Если контекст один - глобальный, то тут можно сказать и "весь скрипт".

Всего есть три контекста: глобальный, функция и eval (подробней - в ссылке ниже).

Поэтому, при входе в функцию её Variable object (Объект переменных, пункт 10.1.3) наполняется снова.

В случае же с Вашим конструктором, - да, функция будет создаваться каждый раз новая - для каждого порождаемого этим конструктором объекта.

В первом случае, у Вас FE:

this.action1=function(){ /* код функции */; };


Такая функция, как было сказано, создаётся в рантайме и не воздействует на VO, однако, последующее присвоение её свойству this.action1 оставляет функцию в памяти (иначе FE можно выполнить только сразу при объявлении, т.к. в VO они не попадают и дальше вызвать их нельзя).

Во втором случае, у Вас FD:

function F (){ /* код функции */; }
this.action1=F ;


И, хотя, эта функция будет создана при входе в контекст исполнения (до выполнения кода функции), всё равно, функция будет так же создана новая - для каждого объекта своя.

Цитата:

Сообщение от kefi
Если да, то тогда будет лучше для экономии памяти

А вот для экономии памяти, общие свойства объектов (как правило, это методы), лучше вынести в прототип:

function A(state) {
  this.state = state; // у каждого объекта своё свойство
  this.fn = function () {}; // тоже своё
  function fn2() {}
  this.fn2 = fn; // тоже своё
}

// а вот методы - описаны единожды,
// но так же доступны всем порождённым
// объектам - за счёт делегации к прототипу
A.prototype = {
  constructor: A,
  test: function () {
    alert(this.a);
  }
};

// можно и отдельно описывать методы в прототипе
A.prototype.test2 = function () {
  alert(this.state + ' test2');
};

var a = new A(10);
var b = new A(20);

a.test(); // 10
b.test(); // 20

alert([
  a.hasOwnProperty('state'), // true
  b.hasOwnProperty('state'), // true

  a.hasOwnProperty('fn'), // true
  b.hasOwnProperty('fn'), // true

  a.hasOwnProperty('fn2'), // true
  b.hasOwnProperty('fn2'), // true

  a.hasOwnProperty('test'), // false, нет родного свойства, возьмётся из прототипа
  b.hasOwnProperty('test') // false, аналогично
]);


Ссылка: http://javascript.ru/ecma/part10#a-10. Особенно можно посмотреть пункт 10.1.3, именно там говорится, что (var'ы, FD, и формальные параметры) и когда (при входе в контекст исполнения) создаётся (попадает в Variable object функции).

Zeroglif 31.03.2009 23:35

Цитата:

Сообщение от kefi
в конструкторе так :
function F (){ /* код функции */; },
this.action1=F ;

Можно вынести F наружу из конструктора.

kefi 31.03.2009 23:48

Цитата:

Во втором случае, у Вас FD:
Код:

function F (){ /* код функции */; }
this.action1=F ;

И, хотя, эта функция будет создана при входе в контекст исполнения (до выполнения кода функции), всё равно, функция будет так же создана новая - для каждого объекта своя.
Ну я еще могу понять для первого случая с FE, логично: каждый создаваемый объект содержит одельную копию тела метода. Расход памяти , правда, большой.
Но! Как же так получается для второго случая с FD, функция определяется единожды - еще до run-time, но опять каждый объект содержит отдельную копию тела функции ?
Или все же не тела в обоих случаях, а ссылки на одно и тоже тело ?
В чем причина? В ECMA упорно не могу догнать, что написано.


PS
Цитата:

Можно вынести F наружу из конструктора.
Да, я понимаю это. Но не хочется из-за разрущения инкапсуляции.

Zeroglif 01.04.2009 00:00

Цитата:

Сообщение от kefi
еще до run-time

Функция - это свой маленький скриптик. Поэтому до рантайма этого скриптика. А так как вы вызываете каждый раз, то и создание каждый раз.

Dmitry A. Soshnikov 01.04.2009 00:11

Цитата:

Сообщение от kefi
Как же так получается для второго случая с FD, функция определяется единожды - еще до run-time

Нет, не единожды. Каждый раз при входе в контекст исполнения. Функция - это тоже контекст исполнения. Runtime здесь имеется в виду - выполнения кода контекста исполнения.

function fn () {
  var a = function _a() {};
  function b() {}
}


Что произошло:

1. Входим в контекст исполения функции "fn":

- Заполняется VO:

VO['a'] - создалась переменная "а", значение undefined;
VO['b'] - создалась FD "b";

2. Выполняем код контекста функции "fn" (вот он, runtime контекста):

- создалась FE "_a"
- VO['a'] = FE "_a"

Цитата:

Сообщение от kefi
Или все же не тела в обоих случаях, а ссылки на одно и тоже тело ?

Вообще, это вопрос о связывании переменных. Есть блок кода под определённым именем:

name ---> блок кода


Или:

function name() {
  // блок кода
}


Далее, присваиваем _name ссылку (тип Reference) на тот же блок кода:

var _name = name;

name ---> блок кода <--- _name

alert(name === _name); // true


Старое имя связываем с новым блоком кода:

name = function () {
  // новый блок кода
};

_name ---> блок кода
name ---> новый блок кода

alert(name === _name); // false


Восстанавливаем:

name = _name;


P.S.: а, отвлекался, долго писал, Zeroglif ответил уже.

kefi 01.04.2009 00:59

Цитата:

долго писал, Zeroglif ответил уже.
Спасибо, за усилия конечно, но все же :
Что же получается, что если в теле функции опредлены внутренние функции, то при каждом вызове этой функции ( входе в ее контекст )
будут создаваться и компилироваться новые копии тел вложеных функций ? Но зачем их создавать заново, и компилировать заново, если и после первого одного входа в контекст внешней функции уже интерпретатору должно быть понятно, что текстуально все нутро этой функции определено и меняться более оно текстуально не будет ?

Где же тогда рациональность спецификации ?

Zeroglif 01.04.2009 09:27

Цитата:

Сообщение от kefi
Где же тогда рациональность спецификации ?

Рациональность заключается в том, что объекты уникальны и функция не исключение. Если рассматривать совокупное значение (value) функции, как некое сочетание 'body+scope chain+object value', то в вашем конструкторе при одном и том же 'body' у вложенной функции разный 'scope chain' и разный 'object value' (иначе присваиваемые свойства у метода одного "экземпляра" отражались бы на методе другого).

С другой стороны стандарт предусматривает оптимизацию, разрешая 'joined objects', но я чего-то сейчас не вижу, чтобы этим кто-то пользовался. Внутренняя самодельная оптимизация наверняка существует, но нам это не важно, если это не противоречит установленной логике или не выпячивает разницу в скорости.

kefi 01.04.2009 09:50

2 Zeroglif > А ну так все же у вложенной функции для разных объектов разный 'scope chain' , но "при одном и том же 'body' " ?
Т.е. на каждом объекте замыкается только свой [[scope]], но текст тела для всех один общий ?

Zeroglif 01.04.2009 10:07

Даже не знаю, как объяснять. Ну, вот вы видите внутри конструктора некую функцию:

this.x = function(){...};

Представьте, что вместо функции там объект:

this.x = {};

Создавая "экземпляры", вы создаёте разные объекты 'this.x' иначе у каждого экземпляра был бы один и тот же. Та же самая история с функциями, которые те же объекты, только сложнее. У них разница усиливается необходимостью удерживать scope chain, которая (цепь) теоретически всегда разная, т.к. создаётся в момент вызова и "привязывается" к создаваемой функции в момент создания. К тому же у каждой функции при создании есть пара - прототип будущих экземпляров, это тоже уникальная черта каждого потенциального конструктора.

kefi 01.04.2009 10:23

Цитата:

Сообщение от Zeroglif
Даже не знаю, как объяснять

Это все понятно, спасибо. Но Вы не замечаете почему-то моего акцентирования на теле функции. Вы прямо не говорите - тело у всех функций одно сохраняется, [[Scope]] разный , а текст тела один ?

Zeroglif 01.04.2009 10:51

Цитата:

Сообщение от kefi
а текст тела один ?

Ну, конечно же.

Dmitry A. Soshnikov 01.04.2009 11:57

kefi, реализация может создавать объединённые объекты (join object's), тем самым, обеспечивая оптимизацию. Вот у таких объектов, тело (блок кода) будет использоваться одно, а внутренние свойства (включая [[scope]]) будут разделены.

Могу продемонстрировать на Python'e, если есть желание (там два одинаковых метода у двух созданных инстансов будут разные (False на ==), но внутреннее свойство функции этих методов - будет ссылаться на один и тот же блок кода (True на ==)).

kefi 10.04.2009 19:37

Вот еще пример, в котрый я не могу въехать :
function al(o){document.write(o,'<br>')} 
function Class2(arg1) {
	this._featureAction1=function(){ al(["Class2._featureAction1"])     }  ;
           this._featureAction1() ; // как и ожидалось вызывается метод объекта, на который показывает this, т.е. function(){ al(["Class2._featureAction1"])     }  ;
	//this.constructor.prototype._featureAction1.call(this);  
	this.constructor.prototype._featureAction1();  
};
Class2.prototype._featureAction1=function(){ 
	this._featureAction1();  // переполнение стека .
	//al(["Class2.prototype._featureAction1"])     
};
c=new Class2();

На строке "this._featureAction1(); // переполнение ... " происходит зацикливание(переполнение стека).
Хотя я ожидал , что this сработает так же как и в строке
" this._featureAction1() ; // как и ожидалось ..." , т.е. просто будет вызван как Собственый метод this.функция из тела Конструктора.

Почему же при вызове из тел функций прототипа работает иначе, чем из тела Конструктора ?

Zeroglif 10.04.2009 20:16

Цитата:

Сообщение от kefi
Почему же при вызове из тел функций прототипа работает иначе, чем из тела Конструктора ?

Разное значение 'this' - при вызове конструктора значением является создаваемый объект, при вызове второй функции значением 'this' является 'Class2.prototype'.

В js значение 'this' меняется динамически и зависит от контекста вызова (от того, каким образом вызывается функция). Вам нужно просто почитать про это.

kefi 10.04.2009 20:23

Цитата:

при вызове второй функции значением 'this' является 'Class2.prototype'.
Ну вот вроде как там где я читал написано, что значением this будет являться объект, а не прототип ...
Гдк сказано , что значением this в теле метода прототипа будет прототип ?

Zeroglif 10.04.2009 20:33

Цитата:

Сообщение от kefi
Гдк сказано , что значением this в теле метода прототипа будет прототип ?

Значение 'this' к телу не имеет никакого отношения, методы живут самостоятельно, никакой жёсткой связи с объектами, значение 'this' зависит только от вызова.

kefi 10.04.2009 23:08

А ну где читал , там не обращено внимание видно на то, что this в теле вызываемой функции укажет на "все, что стоит перед вызовом"
т.е. я подумал, что this внутри будет равен (this) :
(this).constructor.prototype._featureAction1()
а он на самом деле равен (this.constructor.prototype) :
(this.constructor.prototype)._featureAction1()

Dmitry A. Soshnikov 10.04.2009 23:33

Цитата:

Сообщение от kefi
что this в теле вызываемой функции укажет на "все, что стоит перед вызовом"

this может быть не определён, в этом случае его значением подставляется window.

И, кстати, не зависимо от того, есть ли у Вас собственный метод this._featureAction1 - всё равно будет зацикливанием (в этом случае this будет указывать на объект "с", но вызываться будет снова этот метод из прототипа).

kefi 12.04.2009 16:08

Может кто-нибудь понятно объяснить, что называют
- контекстом функции ;
- объектом переменных функции (VO) ;
- [[scope]] функции
?

Например для функции верхнего уровня F:
var I ;
function F() { var i;} ;
Говоря "контекст функции F" имеют ввиду глобальный код , в котором находится функция F с переменной I или же - ее внутренний код с переменной i ?
Говоря "[[scope]] функции F" - аналогичный вопрос, что имеют ввиду ?.
Говоря "VO функции F" - аналогичный вопрос , что имеют ввиду ?

Мне кажется , что порой эти понятия путаются (у меня в голове так точно, чтение стандарта не помогло ) ...


Часовой пояс GMT +3, время: 08:22.