[javascript] JavaScript는 참조 기준 또는 값 기준 언어입니까?

내 두 센트 … 이것이 내가 이해하는 방식입니다. (내가 틀렸다면 자유롭게 고쳐주십시오)

이제 당신이 아는 모든 것을 가치 / 기준으로 전달할 때입니다.

JavaScript에서는 값으로 전달되는지 또는 참조로 전달되는지 여부는 중요하지 않습니다. 중요한 것은 함수에 전달 된 매개 변수의 돌연변이 대 돌연변이입니다.

자, 제가 의미하는 바를 설명하기 위해 최선을 다하겠습니다. 몇 가지 물건이 있다고 가정 해 봅시다.

var object1 = {};
var object2 = {};

우리가 한 것은 “할당”… 변수 “object1″과 “object2″에 2 개의 별도의 빈 개체를 할당했습니다.

이제 object1을 더 좋아한다고 가정 해 봅시다. 그래서 새로운 변수를 “할당”합니다.

var favoriteObject = object1;

다음으로, 어떤 이유로 든 객체 2를 더 좋아하기로 결정합니다. 그래서 우리는 단순히 약간의 재 할당을합니다.

favoriteObject = object2;

object1 또는 object2에 아무런 변화가 없습니다. 우리는 데이터를 전혀 변경하지 않았습니다. 우리가 한 일은 우리가 가장 좋아하는 물건을 다시 할당하는 것입니다. object2와 favoriteObject가 모두 동일한 오브젝트에 지정되어 있음을 알아야합니다. 변수 중 하나를 통해 해당 개체를 변경할 수 있습니다.

object2.name = 'Fred';
console.log(favoriteObject.name) // Logs Fred
favoriteObject.name = 'Joe';
console.log(object2.name); // Logs Joe

자, 예를 들어 문자열과 같은 프리미티브를 살펴 보겠습니다.

var string1 = 'Hello world';
var string2 = 'Goodbye world';

다시, 우리는 마음에 드는 것을 골라냅니다.

var favoriteString = string1;

우리의 favoriteString과 string1 변수는 모두 ‘Hello world’에 할당됩니다. 이제 favoriteString을 변경하려면 어떻게해야합니까 ??? 무슨 일이 일어날 것???

favoriteString = 'Hello everyone';
console.log(favoriteString); // Logs 'Hello everyone'
console.log(string1); // Logs 'Hello world'

어 .. 무슨 일이야. favoriteString을 변경하여 string1을 변경할 수 없습니다 … 왜 ?? 문자열 객체를 변경 하지 않았기 때문 입니다. 우리가 한 것은 favoriteString 변수 를 새 문자열 에 “RE ASSIGN”하는 것뿐입니다 . 이것은 본질적으로 string1에서 연결을 끊었습니다. 이전 예제에서 객체의 이름을 바꿀 때 아무 것도 할당하지 않았습니다. ( 변수 자체가 아니라 , name 속성을 새 문자열에 할당했습니다.) 대신, 단순히 2 개의 변수와 기본 개체 사이의 연결을 유지하는 개체를 변경했습니다. ( 문자열 객체 자체 를 수정하거나 변경 하려는 경우에도문자열은 실제로 JavaScript에서 변경할 수 없기 때문에 가질 수 없었습니다.)

이제 함수와 매개 변수 전달에 대해 … 함수를 호출하고 매개 변수를 전달할 때 기본적으로 수행하는 작업은 새 변수에 “할당”하는 것입니다. 등호 (=) 부호

이 예제들을 보자.

var myString = 'hello';

// Assign to a new variable (just like when you pass to a function)
var param1 = myString;
param1 = 'world'; // Re assignment

console.log(myString); // Logs 'hello'
console.log(param1);   // Logs 'world'

자, 똑같은 기능이지만

function myFunc(param1) {
    param1 = 'world';

    console.log(param1);   // Logs 'world'
}

var myString = 'hello';
// Calls myFunc and assigns param1 to myString just like param1 = myString
myFunc(myString);

console.log(myString); // logs 'hello'

자, 이제 함수없이 먼저 객체를 사용하는 몇 가지 예를 들어 보겠습니다.

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Assign to a new variable (just like when you pass to a function)
var otherObj = myObject;

// Let's mutate our object
otherObj.firstName = 'Sue'; // I guess Joe decided to be a girl

console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Sue'

// Now, let's reassign the variable
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'
};

// Now, otherObj and myObject are assigned to 2 very different objects
// And mutating one object has no influence on the other
console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Jack';

자, 똑같은 것이지만 함수 호출

function myFunc(otherObj) {

    // Let's mutate our object
    otherObj.firstName = 'Sue';
    console.log(otherObj.firstName); // Logs 'Sue'

    // Now let's re-assign
    otherObj = {
        firstName: 'Jack',
        lastName: 'Frost'
    };
    console.log(otherObj.firstName); // Logs 'Jack'

    // Again, otherObj and myObject are assigned to 2 very different objects
    // And mutating one object doesn't magically mutate the other
}

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Calls myFunc and assigns otherObj to myObject just like otherObj = myObject
myFunc(myObject);

console.log(myObject.firstName); // Logs 'Sue', just like before

이 글 전체를 읽으면 JavaScript에서 함수 호출이 어떻게 작동하는지 더 잘 이해할 수있을 것입니다. 무언가가 참조에 의해 전달되는지 또는 가치에 의해 전달되는지는 중요하지 않습니다 … 중요한 것은 할당 대 돌연변이입니다.

변수를 함수에 전달할 때마다 등호 (=) 기호를 사용하는 것처럼 매개 변수 변수의 이름이 무엇이든 “할당”됩니다.

항상 등호 (=)는 할당을 의미합니다. JavaScript에서 매개 변수를 함수 에 전달하는 것도 할당을 의미한다는 것을 항상 기억하십시오 . 그것들은 동일하고 2 개의 변수는 정확히 같은 방식으로 연결됩니다 (즉, 동일한 객체에 할당되었다고 계산하지 않는 한 그렇지 않습니다).

“변수 수정”이 다른 변수에 영향을 미치는 유일한 시간은 기본 개체가 변경되는 경우입니다 (이 경우 변수를 수정하지 않고 개체 자체).

객체와 프리미티브를 구별 할 필요는 없습니다. 왜냐하면 함수가없는 것과 같은 방식으로 작동하고 등호를 사용하여 새 변수에 할당했기 때문입니다.

함수에 전달하는 변수의 이름이 함수 매개 변수의 이름과 같은 경우가 유일한 문제입니다. 이런 일이 발생하면 함수 내부의 매개 변수를 함수 전용의 완전히 새로운 변수 인 것처럼 취급해야합니다.

function myFunc(myString) {
    // myString is private and does not affect the outer variable
    myString = 'hello';
}

var myString = 'test';
myString = myString; // Does nothing, myString is still 'test';

myFunc(myString);
console.log(myString); // Logs 'test'

답변

// 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

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
}
var x = 10;
changePrimitive(x);
// x === 10

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
}
var x = { val: 10 };
changeObject(x);
// x === { val: 100 }

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
}
var x = { val: 10 };
changeObject(x);
// x === { val: 10}