Javascript передается по ссылкам или по значениям? Вот пример из Javascript: Good Parts . Я очень озадачен по поводу my параметр для функции прямоугольника. Это на самом деле undefined k

API веб-уведомлений, но у него есть обратная сторона — запрашивать у пользователя разрешения.

var shape = function (config) {
    var that = {};
    that.name = config.name || "";
    that.area = function () {
        return 0;
    };
    return that;
};
var rectangle = function (config, my) {
    my = my || {};
    my.l = config.length || 1;
    my.w = config.width || 1;
    var that = shape(config);
    that.area = function () {
        return my.l * my.w;
    };
    return that;
};
myShape = shape({
    name: "Unhnown"
});
myRec = rectangle({
    name: "Rectangle",
    length: 4,
    width: 6
});
console.log(myShape.name   " area is "   myShape.area()   " "   myRec.name   " area is "   myRec.area());

Примитивы передаются по значению, объекты передаются по «копии референции. е».

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

function replace(ref) {
    ref = {};           // this code does _not_ affect the object passed
}

function update(ref) {
    ref.key = 'newvalue';  // this code _does_ affect the _contents_ of the object
}

var a = { key: 'value' };
replace(a);  // a still has its original value - it's unmodfied
update(a);   // the _contents_ of 'a' are changed

думайте об этом так:

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

var obj = { };

Даже obj является только ссылкой на объект (который расположен в этом особом замечательном месте) и, следовательно, вы можете передать только этот Как и ожидалось, каждый вызов , если вы идентифицируете объектному изменил обещанию http://phrogz.net/JS/ArraySetMath.js

Мои 2 цента …. Не имеет значения, передает ли Javascript параметры по ссылке или по значению. Что действительно важно, так это назначение против мутации.

, который я написал здесь более длинным, более подробным объяснением ( Является ли JavaScript языком передачи по ссылке или передачей по значению? С чем вы столкнулись

Когда вы передаете что-либо (будь то объект или примитив), все, что делает javascript, — это назначает новую переменную внутри функции … так же, как с помощью знака равенства (=)

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

var myString = 'Test string 1';

// Assignment - A link to the same place as myString
var sameString = myString;

// If I change sameString, it will not modify myString, 
// it just re-assigns it to a whole new string
sameString = 'New string';

console.log(myString); // logs 'Test string 1';
console.log(sameString); // logs 'New string';

Если бы я должен был передать myString как параметр функции, он ведет себя так, как будто я просто назначил его новой переменной. Теперь давайте сделаем то же самое, но с функцией вместо простого назначения

function myFunc(sameString) {

    // Re assignment.. again, it will not modify myString
    sameString = 'New string';
}

var myString = 'Test string 1';

// This behaves the same as if we said sameString = myString
myFunc(myString);

console.log(myString); // Again, logs 'Test string 1';

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

var myObject = { name: 'Joe'; }

// Assignment - We simply link to the same object
var sameObject = myObject;

// This time, we can mutate it. So a change to myObject affects sameObject and visa versa
myObject.name = 'Jack';
console.log(sameObject.name); // Logs 'Jack'

sameObject.name = 'Jill';
console.log(myObject.name); // Logs 'Jill'

// If we re-assign it, the link is lost
sameObject = { name: 'Howard' };
console.log(myObject.name); // Logs 'Jill'

Если бы я передавал myObject в качестве параметра функции, он вел бы себя так, как будто я просто назначил его новой переменной. Опять то же самое с точно таким же поведением, но с функцией.

function myFunc(sameObject) {

    // We mutate the object, so the myObject gets the change too... just like before.
    sameObject.name = 'Jill';

    // But, if we re-assign it, the link is lost
    sameObject = { name: 'Howard' };
}

var myObject = { name: 'Joe'; }

// This behaves the same as if we said sameObject = myObject;
myFunc(myObject);
console.log(myObject.name); // Logs 'Jill'

Объявите переменную, чтобы присвоить значение, возвращаемое из setInterval (…), и передать назначенную переменную в clearInterval () ;

Всегда помните, что знак равенства (=) означает присваивание. И передача параметра в функцию также означает присваивание. Они одинаковы, а две переменные связаны одинаково.

Для min:

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

Как и в случае с C, в конечном итоге все передается по значению. В отличие от C, вы можете на самом деле резервное копирование и передача местоположения переменной, потому что она не имеет указателей, просто ссылки.

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

Аргументы функции передаются либо по значению, либо по разделению, но никогда НИКОГДА по ссылке в Javascript!

Call-by-Value

. Любые браузеры, которые не поддерживают Date.now, вы можете используйте это для получения текущей даты: оператор

var num = 123, str = "foo";

function f(num, str) {
  num  = 1;
  str  = "bar";
  console.log("inside of f:", num, str);
}

f(num, str);
console.log("outside of f:", num, str);

Переназначения внутри области функции не видны в окружении scope.

Это также относится к String, которые являются составным типом данных и все же неизменяемыми:

var str = "foo";

function f(str) {
  str[0] = "b"; // doesn't work, because strings are immutable
  console.log("inside of f:", str);
}

f(str);
console.log("outside of f:", str);

Call-by-Sharing

Объекты, то есть все типы, которые не являются примитивами, передаются путем совместного использования. Переменная, которая содержит ссылку на объект, на самом деле содержит просто копию этой ссылки. Если Javascript будет придерживаться стратегии оценки Call-by-reference, переменная будет содержать исходную ссылку. Это принципиальное различие между передачей и ссылкой.

Каковы практические последствия этого различия?

var o = {x: "foo"}, p = {y: 123};

function f(o, p) {
  o.x = "bar"; // mutation
  p = {x: 456}; // reassignment
  console.log("o inside of f:", o);
  console.log("p inside of f:", p);
}

f(o, p);

console.log("o outside of f:", o);
console.log("p outside of f:", p);

Мутирование кода первой войны браузера Object. Эталонная копия, с которой связана переменная и которая ссылается на этот объект, остается прежней. Таким образом, мутации видны в области видимости вызывающего.

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

Дополнительная информация о : когда мы хотим вернуть объект из функций со стрелками. , почти такая же, как в прошлый раз, но, очевидно, она не имеет обновления DIV статуса «Вычисление …» в качестве первого шага ; и вместо этого сразу начинает вычисления.

Это как можно ближе к полноэкранному режиму в JavaScript:

Как мне назвать свойство объекта с помощью переменной, используя JavaScript?

var f1 = function(inputObject){
    inputObject.a=2;
}
var f2 = function(){
    var inputObject={"a":1};
    f1(inputObject); 
    console.log(inputObject.a);
}

метод первый.

Вам не нужно делать это через Ajax. Просто используйте

var f1 = function(a){
    a=2;
}
var f2 = function(){
    var a =1;
    f1(a); 
    console.log(a);
}

(собственный объект, похожий на массив), они зависят от внешнего контекста для

В практическом плане Альнитак корректен и облегчает понимание, но в конечном итоге в JavaScript все передается по значению.

, без зависимостей. Полностью клиентская сторона.

Когда вы передаете объект, вы получаете копию этого значение (отсюда «копия ссылки», которую описал Альнитак). Если вы изменяете это значение, вы не изменяете исходный объект, вы изменяете свою копию этой ссылки. Внутренние функции

В интересах создания простого примера, который использует const …

const myRef = { foo: 'bar' };
const myVal = true;

function passes(r, v) {
  r.foo = 'baz';
  v = false;
}

passes(myRef, myVal);

console.log(myRef, myVal); // Object {foo: "baz"} true

или первоначальный источник этого фрагмента …

var v = "initialized";
function byref(ref) {
 window[ref] = "changed by ref";
}
byref((function(){for(r in window){if(window[r]===v){return(r);}}})());
// could also be called like... byref('v');
console.log(v); // outputs changed by ref

Обратите внимание, что приведенный выше пример не будет работать для переменных, объявленных внутри функции.

Я думаю, что без пуризмов лучший способ эмулировать скалярный аргумент по ссылке в Javascript — использовать объект, как и в предыдущем ответе.

Однако я делаю немного по-другому:

. В приведенном выше примере

В объявлении функции я помещаю свойства в виде комментария по той же причине: читаемость.

var r;

funcWithRefScalars(r = {amount:200, message:null} );
console.log(r.amount   " - "   r.message);


function funcWithRefScalars(o) {  // o(amount, message)
  o.amount  *= 1.2;
  o.message = "20% increase";
}

Вариант 7 null четко указывает выходной ссылочный параметр.

выхода:

240 - 20% Increase

На стороне клиента, console.log должен быть заменен alert Глядя на вывод

★ ★ ★

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

var amount, message;

funcWithRefScalars(amount = [200], message = [null] );
console.log(amount[0]   " - "   message[0]);

function funcWithRefScalars(amount, message) {  // o(amount, message)
   amount[0]  *= 1.2;
   message[0] = "20% increase";
}

Marknote r выше.

Я использую прототип для своей разработки AJAX и использую такой код: & # xA ; & # xA ; somefunction: function () {& # xA ; var result = & quot ; & quot ; ; & # xA ; myAjax = new Ajax.Request (postUrl, {& # xA ; метод: ‘post’, & # xA ; pos …

function test(value) {
  console.log('retrieve value');
  console.log(value());
}

// call the function like this
var value = 1;
test(() => value);

pass-by-reference prototypejs — Как вернуть текст ответа AJAX? в примерах, где люди пытаются продемонстрировать такое. Я вижу только в примерах, где люди пытаются продемонстрировать это. Я вижу только передачу по значению Глядя на вывод

В случае переменных, которые содержат ссылку на объект, ссылка — это значения этих переменных, и поэтому передается ссылка, которая затем { *} Сеть разработчиков Mozilla передача по значению Глядя на вывод

, в выражении, подобном следующему:

var a = {
  b:"foo", 
  c:"bar"
};

Значение ‘a’ это не Объект, а (пока что) ссылка на него. Другими словами, объект не находится в переменной a, ссылка на него есть. Я думаю, что это то, что кажется трудным для программистов, которые в основном знакомы только с JavaScript. Но легко для людей, которые знают, например, Java, C # и C.

. Объекты всегда передаются по ссылке, а примитивы — по значению, просто сохраняйте этот параметр по одному адресу для объектов. Вот некоторый код, чтобы проиллюстрировать, что я имею в виду (попробуйте в изолированной программной среде JavaScript, такой как https://js.do/ ) К сожалению, вы не можете сохранить только адрес параметра, вы также сохраните все исходные значения элементов.

a = { key: 'bevmo' };
testRetain(a);
document.write(' after function ');
document.write(a.key);


function testRetain (b)
 {
 document.write(' arg0 is ');
 document.write(arguments[0].key);
 b.key='passed by reference';
 var retain = b; //retaining the original address of the parameter

 //address of left set to address of right, changes address of parameter
 b={key: 'vons'}; //right is a new object with a new address
 document.write(' arg0 is ');
 document.write(arguments[0].key);

 //now retrieve the original address of the parameter for pass by reference
 b=retain; 
 document.write(' arg0 is ');
 document.write(arguments[0].key);
}

Результат: arg0 является bevmo arg0 является Vons arg0 передается по ссылке, после функции передается по ссылке