Эффективный интерфейс обьекта.
Любой обьект имеет определённый интерфейс - список всех свойств обьекта(выше мы обусловились что методы это свойства/поля обьекта  ). Интерфейс обьекта может менятся во время выполнения. Мы также уточнили иключение для нативных обьектов из этотого утверждения(зачем и как нам переопределять window.open?  ).
Теперь поговорим от том как же формируется интерфейс обьекта.
Рекомендуется выспаться, пробежать пару км. для бодрости, выпить кофе
Определение вложенных функций и наследование контекста.
Если в теле одной функции определить вторую функцию, то все переменные доступные в контексте первой функции доступны и в контексте вложенной. Это очень удобно, например для создания различных обработчиков для обьектов, нам не нужно создавать какие то внешние регистры в которых придётся запоминать ссылки на обьекты.
Исключение: ссылка this и arguments являются личными для каждой функции и не наследуются по контексту.
| Код | //в a положим функцию
var a=null;
function test() { //эта функция может быть вызвана как конструктор или просто как функция. резличии увидим ниже.
this.field="vingrad"; //this может указывать на только что созданный обьект или на глобальный(window)
var lnk=this; //копия ссылкия на this
var parg=arguments; //копия копия ссылки на arguments
a=function() { //определяем функцию в контексте test
/* вывод алертов буду приводить в двух вариантов:
* первый - вызов test как конструктора,
* второй - вызов test как просто функциия
*/
alert(this.field); //undefined, vingrad
alert(lnk.field); //vingrad, vingrad
alert(arguments.length); //0, 0
alert(parg.length); //2, 2
}
}
var b=new test("dummy", "arg"); //вызов как конструктора с 2 аргументами
//test("dummy", "arg"); //вызов как функция с 2 аргументами
a(); //вызываем созданную функцию |
Замечаем что переменные lnkи parg также доступны и ниже по контексту в новой функции. Также видим что this и arguments у каждой функции свои, для имортирования их ниже по контексту, нужно создать на них ссылки с другими именами.
При вызове test как конструктора, в this храниться ссылка на только что созданный обьект. При вызове a() мы вызываем функцию в глобальном контексте, т.е. this в a указывает на window. Поэтому alert(this.field) выдаст undefined.
При вызове test как простую функцию this указывет на window, т.е. мы создаём новую переменную в глобальном контексте с именем field. Как и ранее a вызывается в глобальном контексте, потому field нам доступна.
Важно: из теста видно что мы наследуем контекст, т.е. все переменные с их текущими значениями. При следующем вызове эти переменные поменяют свои значения, но тем не менее в созданной функции они продолжают содержать "старые" значения. На самом деле при каждом вызове test создаётся новая функция a! Которая и содержит актуальные значения. Убедитсься мы в этом можем следующим кодом:
| Код | //автоматом создалась а в глобальном
var b=new test("dummy", "arg");
var c=a; //сохранили её в другой переменной
b=new test("dummy", "arg", "arg3"); //автоматом создалась вторая а в глобальном
a(); //смотрим на послендний алерт, количество аргументов: 3
c(); //количество аргументов: 2
alert(c==a); //естественно это две разных функции
|
Может показаться не эффективным вот так транжирить память, но на самом деле всё работает правильно при правильном проектировании программы
На заметку: на самом деле в хорошем интерпретаторе(а плохие быстро умирают ) код функции не дублируется, просто разным "копиям" присваивается ссылка на свой контекст, хранящий все "унаследованные" переменные.
Механизм похож на вложенные анонимные классы в Java.
Теперь более реальные примеры, создание "делегатов", например для вставки их как параметры у window.setTimeout. Напомню что set(Timout|Interval) работает только с обьектом функцией. Делегат в нашем случае это функция содержащая сылку на обьект и метод, который вызывается при её вызове.
| Код | <div id="dbg"></div><!-- здесь будет нашь вывод -->
<script type="text/javascript">
<!--
function msg(str) {
document.getElementById("dbg").innerHTML+="<b>"+str+"</b><br />";
}
//литеральный обьект, удобен, ничем не отличается от new Object ;-)
var a={
test: function() { msg("Object a"); } //в каком контексте эта функция? ;-)
};
//этот синтаксис наверное более привычен...
var b=new Object();
b.test=b_toString;
function b_toString() { msg("Object b");}
//функция возвращает функцию, вызывающую метод обьекта по имени
function createStrDelegate(obj, methodname) {
return function() { obj[methodname](); } //замечаем что значения аргументов сохраняються индивидуально в контексте каждой новой возвращаемой функции
}
//это не столько вызов метода обьекта, сколько вызов функции в некотором контексте =)
//другими словами можем исполнить любую функцию как метод обьекта. жаль что работает сие с версии JS 1.5
function createApplyDelegate(obj, method) {
return function() { method.apply(obj, arguments);}
}
//для подтверждения слов выше. попытаемся исполнить в контексте обьекта
function viewToStringMethod() {
msg("<pre>"+this.test+"</pre>");
}
window.setTimeout(createStrDelegate(a, "test"), 1000);
window.setTimeout(createApplyDelegate(b, b.test), 2000);
window.setTimeout(createApplyDelegate(b, viewToStringMethod), 3000);
//не забываем что в JS нет "тупых" sleep функций, замораживающих тред.
//всё должно работать динамично, не подвисая. другими словами setTimeout
//не остановит исполнение, а запустит новый тред(вернее приостоновит исполнение текущего,
//впрочем это зависит от реализации...), в котором исполнится функция.
msg("Begin"); //поэтому Begin появиться первым
//-->
</script> |
Как видим сохранение контекстов в создаваемых функциях очень удобно, когда нужно определять каких то уникальных обработчиков для обьектов. Например для создания обработчиков событий для элементов страницы.
И так в этой точке должно быть ясно что:- функции это обьекты
- функция может быть созданна простым выражением(выражение в синтаксическом понятии expression)
- как и любое выражение функция может быть создана в любой другой функции(в любом месте)
- при создании функция наследует текущий контекст "родительской" функции. Все переменные кроме this и arguments наследуються(для ясности: этот механизм работает когда ты создаёшь функции в глобальном(window) контексте и видишь все глобальные переменные )
- каждый раз когда мы определяем функцию, мы создаём новый обьект-функцию. Обычно ссылка на старую функцию перезаписывается, если ссылок больше не остаётся, то обьект удаляется сборщиком мусора.
|
