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

Для юристов на языке программирования я просмотрел следующие разделы ECMAScript 5.1 (который легче читать, чем последнее издание), и дойдите до , задав его в списке рассылки ECMAScript ,

TL; DR : все передаются по значению, но свойства объектов - это ссылки, а определение объекта, как правило, отсутствует в стандарте.

Построение списков аргументов

Раздел 11.2.4 «Списки аргументов» говорит следующее о создании списка аргументов, состоящего всего из 1 аргумента:

Вывод ArgumentList: AssignmentExpression оценивается следующим образом:

1. Пусть ref является результатом оценки AssignmentExpression.
2. Пусть arg - GetValue (ref).
3. Возвращает список, единственным элементом которого является arg.

В этом разделе также перечислены случаи, когда список аргументов имеет 0 или> 1 аргумент.

Таким образом, все передается по ссылке.

Доступ к свойствам объекта

Раздел 11.2.1 «Аксессоры свойств»

Вывод MemberExpression: MemberExpression [Expression] оценивается следующим образом:

1. Пусть baseReference будет результатом оценки MemberExpression.
2. Пусть baseValue будет GetValue (baseReference).
3. Пусть свойствоNameReference является результатом вычисления выражения.
4. Пусть свойствоNameValue будет GetValue (свойствоNameReference).
5. Вызов CheckObjectCoercible (baseValue).
6. Пусть свойствоNameString будет ToString (propertyNameValue).
7. If синтаксическое производство, которое оценивается, содержится в коде строгого режима, пусть строгое истинно, иначе пусть строгое будет ложным.
8. Возвращает значение типа Reference , базовое значение которого baseValue и ссылочным именем которого является свойствоNameString, а флаг строгого режима - строгий.

Таким образом, свойства объектов всегда доступны как рефери се.

On Reference

Описан в разделе 8.7 «Тип ссылочной спецификации», что ссылки не являются реальными типами на языке - они используются только для описания поведения delete, typeof и операторы присваивания.

Определение «Object»

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

Мой простой способ понять это ...

• При вызове функции вы передаете содержимое (ссылку или значение) переменных аргумента, а не сами переменные.

  var var1 = 13;
  var var2 = { prop: 2 };
  
  //13 and var2's content (reference) are being passed here
  foo(var1, var2); 
  

• Внутри функции переменные параметра inVar1 и inVar2 получают переданное содержимое.

  function foo(inVar1, inVar2){
      //changing contents of inVar1 and inVar2 won't affect variables outside
      inVar1 = 20;
      inVar2 = { prop: 7 };
  }
  

• Поскольку inVar2 получил ссылку { prop: 2 }, вы можете изменить значение свойства объекта.

  function foo(inVar1, inVar2){
      inVar2.prop = 7; 
  }
  

Рассмотрим следующее:

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

Итак, забудьте о «pass by reference / value» не зацикливаться на «pass by reference / value», потому что:

1. Термины используются только для описания поведения языка языка, не обязательно фактическая базовая реализация. В результате этой абстракции теряются критические детали, которые необходимы для достойного объяснения, что неизбежно приводит к текущей ситуации, когда один термин не описывает адекватное описание фактического поведения и дополнительной информации
2. Эти понятия изначально не были определены с целью описания javascript в частности, и поэтому я не чувствую себя вынужденным использовать их, когда они только добавляют к путанице.

Чтобы ответить на ваш вопрос : указатели переданы.

// code
var obj = {
    name: 'Fred',
    num: 1
};

// illustration
               'Fred'
              /
             /
(obj) ---- {}
             \
              \
               1

// code
obj.name = 'George';


// illustration
                 'Fred'


(obj) ---- {} ----- 'George'
             \
              \
               1

// code
obj = {};

// illustration
                 'Fred'


(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1

// code
var obj = {
    text: 'Hello world!'
};

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */
someFunc(obj);


// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
                  |
                  |
                  |
            'Hello world'

Некоторые окончательные комментарии:

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

var a = [1,2];
var b = a;

a = [];
console.log(b); // [1,2]
// doesn't work because `b` is still pointing at the original array

Очень подробное объяснение о копировании, прохождении и сравнении по значению и по ссылке содержится в в этой главе книги «JavaScript: окончательное руководство».

До мы оставляем тему манипуляции объектами и массивами по ссылке, нам нужно прояснить точку номенклатуры. Фраза «пройти по ссылке» может иметь несколько значений. Для некоторых читателей фраза относится к методу вызова функции, которая позволяет функции назначать новые значения своим аргументам и изменять эти измененные значения вне функции. Это не значит, что термин используется в этой книге. Здесь мы имеем в виду просто, что ссылка на объект или массив - не сам объект - передается функции. Функция может использовать ссылку для изменения свойств объекта или элементов массива. Но если функция перезаписывает ссылку ссылкой на новый объект или массив, эта модификация не видна вне функции. Читатели, знакомые с другим значением этого термина, могут предпочесть сказать, что объекты и массивы передаются по значению, но переданное значение на самом деле является ссылкой, а не самим объектом.

One вещь, которую я до сих пор не могу понять. Проверьте код ниже. Любые мысли?

function A() {}
A.prototype.foo = function() {
    return 'initial value';
}


function B() {}
B.prototype.bar = A.prototype.foo;

console.log(A.prototype.foo()); //initial value
console.log(B.prototype.bar()); //initial value

A.prototype.foo = function() {
    return 'changed now';
}

console.log(A.prototype.foo()); //changed now
console.log(B.prototype.bar()); //Why still 'initial value'???

Я нашел метод extend библиотеки Underscore.js очень полезен, когда я хочу передать объект в качестве параметра, который может быть либо изменен, либо полностью заменен .

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

   var newObj = new MyObject();
   // _.extend(destination, *sources) 
   _.extend(newObj, aObj);
  }
}

Передача аргументов функции в JavaScript аналогична передаче параметров по значению указателя в C:

/*
The following C program demonstrates how arguments
to JavaScript functions are passed in a way analogous
to pass-by-pointer-value in C. The original JavaScript
test case by @Shog9 follows with the translation of
the code into C. This should make things clear to
those transitioning from C to JavaScript.

function changeStuff(num, obj1, obj2)
{
    num = num * 10;
    obj1.item = "changed";
    obj2 = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};
changeStuff(num, obj1, obj2);
console.log(num);
console.log(obj1.item);    
console.log(obj2.item);

This produces the output:

10
changed
unchanged
*/

#include <stdio.h>
#include <stdlib.h>

struct obj {
    char *item;
};

void changeStuff(int *num, struct obj *obj1, struct obj *obj2)
{
    // make pointer point to a new memory location
    // holding the new integer value
    int *old_num = num;
    num = malloc(sizeof(int));
    *num = *old_num * 10;
    // make property of structure pointed to by pointer
    // point to the new value
    obj1->item = "changed";
    // make pointer point to a new memory location
    // holding the new structure value
    obj2 = malloc(sizeof(struct obj));
    obj2->item = "changed";
    free(num); // end of scope
    free(obj2); // end of scope
}

int num = 10;
struct obj obj1 = { "unchanged" };
struct obj obj2 = { "unchanged" };

int main()
{
    // pass pointers by value: the pointers
    // will be copied into the argument list
    // of the called function and the copied
    // pointers will point to the same values
    // as the original pointers
    changeStuff(&num, &obj1, &obj2);
    printf("%d\n", num);
    puts(obj1.item);
    puts(obj2.item);
    return 0;
}

Все аргументы функции в ECMAScript передаются по значению. Это означает, что значение вне функции копируется в аргумент внутри функции так же, как значение копируется из одной переменной в другую. Если значение является примитивным, то оно действует так же, как и примитивная переменная, и если значение является ссылкой, оно действует как копия ссылочной переменной. Это часто является путаницей для разработчиков, поскольку к переменным обращаются как по значению, так и по ссылке, но аргументы передаются только по значению. Когда аргумент передается по значению, значение копируется в локальную переменную (именованный аргумент и в ECMAScript - слот в объекте arguments). Когда аргумент передается по ссылке, местоположение значения в памяти сохраняется в локальной переменной, что означает, что изменения в локальной переменной отражаются вне функции. (Это невозможно в ECMAScript.)

В некоторых случаях это может быть полезно изменить anArg:

function alterMyArg(func) {
    // process some data
    // ...
    func(data);
}

alertMyArg(function(d) {anArg = d;});

Наиболее кратким объяснением, которое я нашел, было в руководстве по стилю AirBNB :

• Примитивы: при доступе к примитивному типу вы работаете непосредственно со своим номером строки значений boolean null undefined

Например:

var foo = 1,
    bar = foo;

bar = 9;

console.log(foo, bar); // => 1, 9

• Сложность: Когда вы получаете доступ к сложному типу, вы работаете над ссылкой на его функцию массива объектов объекта

Например:

var foo = [1, 2],
    bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

Т.е. эффективно примитивные типы передаются по значению, а сложные типы передаются по ссылке.

Я бы сказал, что это pass-by-copy -

. Рассмотрение аргументов и объектов переменных - это объекты, созданные во время контекста выполнения, созданного в начале вызова функции, - и ваше фактическое значение / ссылка, переданная в функция просто хранится в этих аргументах + объекты переменных.

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

Javascript всегда pass-by-value , все имеет тип значения. Объекты являются значениями, функции-члены объектов сами являются значениями (помните, что функции являются первоклассными объектами в Javascript). Кроме того, в отношении концепции, что все в Javascript является объектом , это неверно. Строками, символами, числами, булевыми значениями, нулями и неопределенными являются примитивы . Иногда они могут использовать некоторые функции-члены и свойства, унаследованные от их базовых прототипов, но это только для удобства, это не значит, что они сами объекты. Попробуйте следующее для справки

x = "test";
alert(x.foo);
x.foo = 12;
alert(x.foo);

В обоих предупреждениях вы найдете неопределенное значение.