5 ответов
Следование Вашему примеру линию за линией:
a = {}
a теперь ссылается на новый объект.
b = a;
b теперь ссылается на тот же объект это a ссылки. Обратите внимание, что это не ссылается a.
a['one'] = {};
новый объект теперь имеет индекс 'one' что ссылки другой новый объект.
, Когда Вы делаете
a = a['one'];
, Вы - установка a для обращения к [1 113], который является, что новый объект, который Вы создали, когда Вы сделали a['one'] = {}. b все еще ссылается на объект, который Вы создали с [1 116].
Вы путаете проблему, когда Вы говорите" a, потерял ее ссылку на [1 118]", потому что a не относится к [1 120], ни наоборот. a и b относятся к [1 126] объекты , и они могут быть заставлены обратиться к другим объектам. Как это:
С [1 123], Вы добираетесь
a
\
\
{ }
/
/
b
Затем с [1 124], Вы добираетесь
a
\
\
{ one: { } }
/
/
b
Затем с [1 125], Вы добираетесь
a - - - -
\
{ one: { } }
/
/
b
:P Вы убываете в knitty песчаные детали, и я рад, что Вы спросили, поскольку Вы будете более мудрыми к концу.
не смотрят на него с точки зрения указателей, потому что я думаю, что это - то, где Вы запутываетесь. Думайте о нем скорее с точки зрения "кучи" (или просто "память", если Вы будете), и таблица символов.
Позволяет, запускаются путем провожения первых нескольких строк кода:
var a, b;
a = {}
b = a;
то, Что Вы сделали здесь, создается один объект на "куче" и два символа на таблице символов. Это выглядит примерно так:
<час>Таблица символов :
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| a | 0x400000 |
+--------+-----------------+
| b | 0x400000 |
+--------+-----------------+
"куча" :
+----------+-----------------+
| Location | Value |
+----------+-----------------+
| 0x400000 | <object val 1> |
+----------+-----------------+
.
<час>Вот то, где вещи становятся интересными: Объекты имеют свои собственные "таблицы символов" (обычно, это просто хеш-таблицы, но вызов его таблица символов может сделать его более ясным).
Теперь, после Вашего следующего оператора, у Вас есть 3 вещи рассмотреть: глобальная таблица символов, <object val 1> таблица символов и "куча".
Выполнение следующая строка:
a['one'] = {}
И теперь вещи похожи на это:
<час>Глобальная Таблица символов :
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| a | 0x400000 |
+--------+-----------------+
| b | 0x400000 |
+--------+-----------------+
<object val 1> Таблица символов
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| one | 0x400004 |
+--------+-----------------+
"куча" :
+----------+-----------------+
| Location | Value |
+----------+-----------------+
| 0x400000 | <object val 1> |
+----------+-----------------+
| 0x400004 | <object val 2> | <---we created a new object on the heap
+----------+-----------------+
.
<час>Теперь Вы выполнили следующий код:
a = a['one'];
Это, должно, надо надеяться, казаться, тривиальное изменение. Результат:
<час>Глобальная Таблица символов :
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| a | 0x400004 |
+--------+-----------------+
| b | 0x400000 |
+--------+-----------------+
<object val 1> Таблица символов
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| one | 0x400004 |
+--------+-----------------+
"куча" :
+----------+-----------------+
| Location | Value |
+----------+-----------------+
| 0x400000 | <object val 1> |
+----------+-----------------+
| 0x400004 | <object val 2> |
+----------+-----------------+
.
<час>После ячеек памяти к "куче" должен, надо надеяться, прояснить, почему Вы получили вывод, который Вы сделали.
Теперь вещи становятся еще более интересными, потому что теперь Вы делаете:
a['two'] = 2;
хорошо, поэтому давайте возьмем это шаг за шагом.
-
aточки к ячейке памяти0x400004, который содержит<object val 2> -
<object val 2>, являются пустым объектом, таким образом его таблица символов начинается пустая - Путем выполнения этой строки, мы добавляем переменную 'два' к [1 123] таблица символов.
, Если Вы еще не устали от рассмотрения этих схем, Вы будете. Вещи теперь похожи на это:
<час>Глобальная Таблица символов :
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| a | 0x400004 |
+--------+-----------------+
| b | 0x400000 |
+--------+-----------------+
<object val 1> Таблица символов
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| one | 0x400004 |
+--------+-----------------+
<object val 2> Таблица символов
+--------+-----------------+
| Symbol | Memory Location |
+--------+-----------------+
| two | 0x400008 |
+--------+-----------------+
"куча" :
+----------+-----------------+
| Location | Value |
+----------+-----------------+
| 0x400000 | <object val 1> |
+----------+-----------------+
| 0x400004 | <object val 2> |
+----------+-----------------+
| 0x400008 | 2 (literal val) | <-- yes, even integers are stored on the heap
+----------+-----------------+ in JavaScript.
.
<час>, Если Вы старательно не торопитесь для следования за ячейками памяти, Вы будете видеть, что Ваш браузер отобразил корректный вывод.
Думайте об анонимном объекте как о нем наличии имени:
a = {}; // The variable "a" now points to (holds) an anonymous object.
b = a; // "b" points to the same anonymous object held by "a".
a = 123; // "a" now holds some other value.
b; // "b" still holds the anonymous object.
ключ должен помнить, что переменные содержат ссылки на объекты , не ссылки на другие переменные. И тот же объект может быть упомянут любым количеством переменных.
Объекты в JavaScript могут существовать собой, не нуждаясь в имени. Например:
{}
новый экземпляр объекта словаря.
a = {};
создает новый объект словаря и делает a, относятся к нему. Теперь
b = a;
делает b, относятся к тому же основному объекту. Можно затем сделать a точка где-то в другом месте:
a = "hi";
и b неподвижные точки к тому же словарю возражают, что он сделал прежде. Поведение b не связано с тем, как Вы изменяетесь что a точки к.
Насколько я знаю Вас overwrited , таким образом, я предполагаю, что механизм сохраняет его в другом пространстве памяти, тогда как b, все еще указывающий на старое адрес памяти (который так или иначе не становится уничтоженным).