Изучить что то что может запускать объекты

Работа с объектами в JavaScript: теория и практика

В этой статье я хочу по возможности полно и последовательно рассказать о том, что такое объект в JavaScript, каковы его возможности, какие взаимоотношения могут строиться между объектами и какие способы «родного» наследования из этого вытекают, как это все влияет на производительность и что вообще со всем этим делать 🙂

В статье НЕ будет ни слова про: эмуляцию традиционной класс-объектной парадигмы, синтаксический сахар, обертки и фреймворки.

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

Объекты в JavaScript

Во многих статьях встречается фраза «В JavaScript — всё объект». Технически это не совсем верно, однако производит должное впечатление на новичков 🙂

Действительно, многое в языке является объектом, и даже то, что объектом не является, может обладать некоторыми его возможностями.

Важно понимать, что слово «объект» употребляется здесь не в смысле «объект некоторого класса». Объект в JavaScript — это в первую очередь просто коллекция свойств (если кому проще, может называть это ассоциативным массивом или списком), состоящая из пар ключ-значение. Причем ключом может быть только строка (даже у элементов массива), а вот значением — любой тип данных из перечисленных ниже.

Итак, в JavaScript есть 6 базовых типов данных — это Undefined (обозначающий отсутствие значения), Null, Boolean (булев тип), String (строка), Number (число) и Object (объект).
При этом первые 5 являются примитивными типами данных, а Object — нет. Кроме того, условно можно считать, что у типа Object есть «подтипы»: массив (Array), функция (Function), регулярное выражение (RegExp) и другие.
Это несколько упрощенное описание, но на практике обычно достаточное.

Кроме того, примитивные типы String, Number и Boolean определенным образом связаны с не-примитивными «подтипами» Object: String, Number и Boolean соответственно.
Это означает, что строку ‘Hello, world’, например, можно создать и как примитивное значение, и как объект типа String.
Если вкратце, то это сделано для того, чтобы программист мог и в работе с примитивными значениями использовать методы и свойства, как будто это объекты. А подробнее об этом можно будет прочитать в соответствующем разделе данной статьи.

Работа по ссылке

Ссылка — это средство доступа к объекту под различными именами. Работа с любыми объектами ведется исключительно по ссылке.
Продемонстрируем это на примере:

Как мы видим, и первая ссылка, и вторая дают один и тот же результат.
Необходимо осознать, что у нас нет никакой функции с именем test, и что переменная test не является какой-то «главной» или «основной» ссылкой, а «test_link» — второстепенной.

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

Посмотрим, почему так важно это понимать:

test= //Создаем объект со свойством prop
test_link=test; //Создаем еще одну ссылку на этот объект

alert(test.prop); //sometext
alert(test_link.prop); //sometext

//Изменяем свойство объекта
test_link.prop= ‘newtext’ ;

//Добавляем новое свойство и удаляем старое
test.new_prop= ‘hello’ ;
delete test.prop;

//Удаляем ссылку
delete test;
alert(test.new_prop);
/*В этом месте скрипт выкинет ошибку, потому что test уже не существует, и test.new_prop не существует тем более */
alert(test_link.new_prop); //hello
/* а вот тут все в порядке, ведь мы удалили не сам объект, а лишь ссылку на него. Теперь на наш объект указывает единственная ссылка test_link */

//Создаем новый объект
test=test_link; //Сперва снова создадим ссылку test
test_link= //А вот и новый объект

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

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

Примитивные значения

obj= new String( ‘hello’ ); //Создаем строку как объект
simple= ‘hello’ ; //Создаем примитивное значение

obj.prop= ‘text’ ;
simple.prop= ‘text’ ;

Все то же самое справедливо и для типа Number, и для Boolean (ну, кроме того, что в них нет свойства length, а есть ряд других замечательных свойств).
Использование строк и чисел как объектов не несет в себе никакой практической пользы, т.к. примитивные значения удобнее в работе, но сохраняют при этом весь необходимый функционал. Тем не менее, для полноты картины необходимо понимать этот механизм.

Не стоит путать использование примитивных значений с использованием литералов — например, независимо от того, создаем мы массив как «test=new Array()» или как «test=[]», в результате все равно будет один и тот же объект. Никаких примитивных значений мы не получим.

Создание и использование объектов

test.function_property( ‘user_1’ ); //Hello, Петя.

Перед нами объект test, имеющий 3 свойства, названия которых, как я надеюсь, говорят сами за себя. Больше всего нас в нем интересует свойство function_property, содержащее функцию. Такую функцию можно назвать методом объекта.

В нашей функции дважды используется ключевое слово this, которое является указателем (т.е. ссылкой) на объект, из которого вызывается функция. Таким образом, this.simple_property=test.simple_property=’Hello’, а this.object_property[user]=test.object_property[user]=’Петя’.

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

test.function_property( ‘user_1’ ); //Hello, Петя.

test2= new Object(); //Еще одна форма создания нового объекта, аналогичная test2=<>

test.function_property.call(test2, ‘user_1’ ); //ошибка
/* Метод call позволяет вызвать функцию от имени другого объекта. В данном случае, мы вызываем метод function_property объекта test, и его this указывает уже не на объект test, а на объект test2. А т.к. в нем нет свойства object_property, то при попытке получить this.object_property[user]скрипт выдаст ошибку */

//попробуем исправить ситуацию
test2.simple_property= ‘Good day’ ;
test2.object_property=test.object_property; //В данном случае воспользуемся указанием объекта по ссылке, чтобы не дублировать код

test.function_property.call(test2, ‘user_1’ ); //Good day, Петя.

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

Конструктор

В примере выше мы создавали 2 объекта, обладающих некой схожестью. И там и там имелись свойства simple_property и object_property. Очевидно, что при написании реального кода также нередко встает задача создания одинаковых или просто похожих объектов. И разумеется, мы не должны каждый такой объект создавать вручную.

На помощь нам придет конструктор. Конструктор в JavaScript — это не часть класса (потому что здесь нет классов), а просто самостоятельная функция. Самая обычная функция.

alert(child.name); //Вася
child.show_name(); //Вася

child2= new make_me( ‘Петя’ );
child2.show_name(); //Петя

child2.show_name= function () //Не забываем, что можем изменять наши объекты в любой момент
child2.show_name(); //Не буду говорить свое имя

Если мы вспомним про описание типов данных в начале статьи, то становится понятно, что Object и его подтипы (Function, Array и другие) — это на самом деле конструкторы, придающие создаваемому объекту возможности функции, массива и т.д.

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

Прототип

Затем, данному объекту (на который указывает свойство prototype) также автоматически добавляется свойство constructor, указывающее обратно на функцию. Получается такая вот циклическая ссылка.

alert(child.name); //Вася
child.show_name(); //Вася

make_me.prototype= //Попробуем пересоздать прототип заново

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

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

Как я заметил после чтения многочисленных форумов на эту тему, основные проблемы возникают у людей, когда они путают свойство prototype у функции и скрытое свойство [[Prototype]] у объекта, созданного с помощью этой функции.
Оба этих свойства являются ссылкой на один и тот же объект (до тех пор, пока первичная связь прототипа с конструктором не нарушена), но это тем не менее разные свойства, с разными именами, одно из них доступно для программиста, а другое нет.

Необходимо всегда четко понимать, что если речь идет о прототипе конструктора — то это всегда свойство prototype, а если о прототипе созданного объекта — то это скрытое свойство [[Prototype]].

Наследование

bird= function () <> //Это конструктор птички
bird.prototype.cry= function () //Птичка умеет кричать
bird.prototype.fly= function () //и летать

duck= function () <>
duck.prototype= new bird();
duck.prototype.cry= function () //Утка кричит по другому
duck.prototype.constructor=duck; //Принудительно устанавливаем свойство prototype.constructor в duck, т.к. иначе оно будет ссылаться на bird

Так можно реализовывать иерархию любого уровня вложенности.

Задача на звездочку

В первой строке мы создаем новую функцию и переменную make_me, которая указывает на эту функцию. При этом создается прототип функции, make_me.prototype, в котором содержится свойство constructor, указывающее на make_me.
Но это далеко не все 🙂
Т.к. функция make_me — это тоже объект, то он в свою очередь имеет папу и маму, т.е. конструктор и прототип. Его конструктор — это родная функция языка Function(), а прототип — объект, содержащий в себе методы call, apply и т.д. — именно благодаря этому прототипу мы и можем пользоваться этими методами в любой функции. Таким образом, у функции make_me появляется свойство [[Prototype]], указывающее на Function.prototype.

В свою очередь, прототип конструктора Function — тоже объект, конструктором которого является (сюрприз!) Object (т.е. Function.prototype.[[Prototype]].constructor===Object), а прототипом — объект, содержащий стандартные свойства и методы объекта, такие как toString, hasOwnProperty и другие (другими словами — Function.prototype.[[Prototype]][‘hasOwnProperty’] — это как раз тот самый метод, которым мы можем пользоваться во всех производных объектах — причем это именно собственной метод данного объекта, а не наследованный). Вот таким вот интересным образом мы обнаруживаем, что все виды объектов являются производными от Object.

Можем ли мы продолжить дальше? Оказывается, нет. Object.prototype именно потому и содержит базовые свойства объекта, что не имеет собственного прототипа. Object.prototype.[[Prototype]]=null; В этом месте путешествие по цепочке прототипов в поиске свойства или метода прекращается.

Еще один интересный факт — конструктором Object является Function. Т.е. Object.[[Prototype]].constructor===Function.
Налицо еще одна циклическая ссылка — конструктор Object это Function, а конструктор Function.prototype — это Object.

Вернемся к нашему примеру. Как создается функция мы уже поняли, теперь перейдем ко второй строке. Там мы создаем объект child, конструктором которого является функция make_me, а прототипом — make_me.prototype.

Ну и в третей строчке мы видим, как интепретатор поднимается по цепочке, от child к child.[[Prototype]] (он же make_me.prototype), затем к child.[[Prototype]].[[Prototype]] (он же Object.prototype), и уже там находит метод toString, который и запускает на выполнение.

Примеси

Может показаться, что наследование через прототипы — единственный способ, возможный в JavaScript. Это не так.
Мы имеем дело с очень гибким языком, который предоставляет не столько правила, сколько возможности.

Например, при желании мы можем вообще не использовать прототипы, а программировать с помощью концепции примесей. Для этого нам пригодятся наши старые добрые друзья — конструкторы.

Что мы видим в данном примере? Во-первых, это возможность наследования от нескольких объектов, не находящихся в одной иерархии. В примере их 2, но может быть сколько угодно.
Во-вторых, это отсутствие какой-либо иерархии вообще. Переопределение свойств и методов определяется исключительно поряком вызова конструкторов.
В-третьих, это возможность еще более динамически менять объект, причем именно отдельный объект, а не всех потомков, как при изменении прототипа.

Upd: Замыкания и приватные свойства

Чтобы не раздувать эту и без того немаленькую статью, даю ссылку на пост Замыкания в JavaScript, где про это довольно подробно написано.

Что теперь со всем этим делать

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

Причем вопрос о цене довольно нетривиален, особенно если мы говорим о разработке под браузер Internet Explorer 6 и 7 версий.
1. Память — тут все просто. Во всех браузерах наследование на прототипах отнимает в разы меньше памяти, чем при создании методов через конструкторы. Причем, чем больше методов и свойств у нас есть, тем больше разница. Однако, стоит помнить, что если у нас не тысяча одинаковых объектов а всего лишь один, то расходы памяти в любом случае будут небольшими, т.к. здесь стоит учитывать другие факторы.
2. Процессорное время — здесь основные тонкости связанны именно с браузерами от Microsoft.
С одной стороны, объекты, где методы и свойства создаются через конструктор — могут создаваться в разы (в некоторых случаях в десятки и сотни раз) медленнее, чем через прототип. Чем больше методов — тем медленнее. Так что если у вас в IE замирает на несколько секунд во время инициализации скрипта — есть повод копать в эту сторону.

С другой стороны, собственные методы объекта (созданные через конструктор) могут выполняется немного быстрее, чем прототипные. В случае, если позарез необходимо ускорить именно выполнение какого-то метода в этом браузере, то нужно это учесть. Имейте ввиду, ускоряется именно вызов метода (т.е. поиск его в объекте), а не его выполнение. Так что если сам метод у вас выполняется секунду, то особого увеличения быстродействия вы не заметите.

В других браузерах подобных проблем наблюдается, там время создания объектов и вызова их методов примерно одинаково для обоих подходов.

Источник

Опции темы

Поиск по теме

Отображение

Гайд по моду ThaumCraft 4.2 (4.2.3.5)

Данный гайд поможет тем, кто только начал познавать таумкрафт и играет на наших серверах (Divine, RPG, TechnoMagic). Гайд разделён на несколько глав, а они на несколько частей, что поможет вам лучше ориентироваться в нём.

Глава 1. Начало:
Часть 1. Азы:
Для начала изучения мода нам понадобятся следующие вещи: чернильница (лучше скрафтить сразу 2), наш первый жезл 25vis и наконечники.

Далее нам нужно скрафтить «ГайдБук»-таумономикон (Ставим книжную полку, берём жезл и тыкаем ПКМ по ней).

Наш стол исследований (далее «стол») готов. Далее для миниигры нам понадобятся аспекты.

Изначально у нас их всего 6 видов (основные), но для продвижения нам их нужно намного больше. Всего же различных аспектов 48. Составить другие не сложно: нам нужно тыкнуть по двум различным аспектами и нажать кнопочку.

Если ваша пара верна, то появится новый вид аспектов, он отобразится в окне аспектов, а также в правом нижнем углу экрана. Также хочу отметить, что первое открытие аспекта даёт вам +3 аспекта этого вида. Кроме составления аспектов в столе, можно доставать их (а в будущем это будет ваш основной источник аспектов), изучая разные вещи таумометром, но об этом позже.

Далее нам нужно будет сходить в шахту ещё раз за кристаллами, всего их 6 видов, помимо этой руды вам может встретится и 2 эти:

Теперь вернёмся к таумометру. Для его крафта нам понадобятся как раз 2 любых кристалла с шахты.

С его помощью мы можем изучать вещи, блоки и т.д., наведя на предмет и зажав ПКМ. Если аспекты находящиеся в предмете «доступны» вам (а точнее говоря у вас есть хотя бы составляющие тех аспектов, что в предмете), то вы получите столько аспектов, сколько указано в предмете (забегая вперёд скажу, что если у вас 100+ аспектов какого-то вида, то давать за изучение предметов вам будут гораздо меньше), а также будете знать кол-во и вид аспектов в данном предмете (навести мышку на предмет и зажать шифт). Конечно угадать, какие аспекты есть в предмете, не зная их, нельзя, поэтому при отсутствии нужных аспектов вам будет писать то, что нужно изучить прежде в правом нижнем углу экрана, но не стоит сильно опираться на эту информацию, т.к. зачастую она дезинформирует, либо заводит в тупик (первое требует второе, второе первое). Так что советую перед изучением предметов сделать хотя бы некоторую часть составных аспектов в столе. Маленький секретик: некоторые вещи можно изучать многоразово, просто изменив их цвет или содержимое (к примеру шерсть, сундуки, зелья), но работает это не со всем. Также небольшая ссылочка: Тык, тут указано в каких предметах есть какой аспект. Теперь же, когда у нас достаточно «игровых элементов», мы можем перейти к самой минигре-изучению: берём себе в инвентарь бумагу, чернильницу, заходим в таумономикон и тыкаем по тому, что хотим изучить, некоторые исследования изучаются засчёт лишь аспектов, которые показываются, если навести на них (6-угольники), остальные же дают в инвентарь свиток, который и нужно положить в стол. Вот мы и дошли до самой миниигры.

Суть такова: Нам нужно соединить все начальные аспекты, уже расположенные на поле (всё поле заполнять не обязательно). Если вместо аспектов у вас вопросики, то значит вы ещё не открыли тот аспект, который есть в свитке. Как соединять?: Аспект соединится с другим в том случае, если он нужен для «крафта» другого аспекта, либо другой для первого.

На этом и закончился основной гайд для новичка, который не имеет ни малейшего представления о данном моде. Весь дальнейший гайд будет основан на таумономиконе и моём опыте. Если вы впервые играете с данным модом, то настоятельно Рекомендую! закончить просмотр гайда на этом и попробовать изучить мод самому! Ведь это же намного интереснее 🙂

Подробнее об узлах написано тут.

справа сверху есть отверстие для жезла, туда и поместился наш жезл. Далее, чтобы что-то скрафтить на нём, мы выкладываем крафт по таумономикону.

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

Часть 4. Тигель:
Перед началом работы с тигелем стоит изучить и сделать очки откровения (находятся во вкладке изобретения).

Часть 5. Алхимия:
Крафтим алхимическую печь и перегонные кубы (желательно 4 на каждую печь).

Далее крафтим банки:

В них помещается до 64 эссенции, но одного типа. С помощью этой печки мы можем плавить аспекты в банки: кладём предметы для плавки в верхний слот и топливо в нижний (то же, что и для обычной печки). Готовая эссенция помещается во внутренний резервуар, а потом и в перегонные кубы (до 32 эссенции, но одного типа). Из них вы можете доставать эссенцию вручную (тык ПКМ банкой по кубу), либо же через трубы.

Также вы можете использовать пустотную банку.

Её отличие от обычной такое: когда она полная, то вся попадающая в неё эссенция просто сливается (удобно для производства только нужной эссенции (ненужная в пустотные банки)).

Часть 6. Автоалхимия:
По сути это «безпотерьная» замена обычного тигеля. Делаем 2 алхим. конструкции и ставим всё так

Не забудьте поставить под тигель лаву/огонь/нитор, а в него залить воду. Активируем всё жезлом (для этого, как и для активации будущих многоблочных структур, нам понадобится вис в палке, его кол-во указано в таумономиконе, не забываем про затраты вис). Работает это всё очень просто, подключаем через трубы эссенцию, кладём внутрь катализатор, выбираем (если возможно) стрелочками, что именно скрафтить и жмём по предмету (появляется жёлтенький ободок). Снаружи из центральной дырки будет выпадать готовый предмет или же класться в сундук (если поставить перед дыркой сундук).

Часть Extra. Искажение:
Всё в этой темке 🙂

Строим такую вот конструкцию:

Тыкаем жезлом ПКМ по блоку матрицы. Для работы с матрицей нам также надо расставить остальные пьедесталы. На центральный пьедестал мы будем класть вещь, которую будем наполнять, остальные пьедесталы для дополнительных вещей.
Но кроме предметов для наполнения нужна и эссенция, для этого ставим банки с нужной эссенцией вокруг алтаря (до 12 блоков в ширину/длину/высоту считая от блока матрицы (сам блок матрицы не считать), только вот сверху от себя она принимает до 11 блока).

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

Дальнейшие главы в разработке 🙂

Источник