The relationship between JavaScript variables, value transfer, address transfer, and parameters_jquery

Let the harvest dry for a while first:

1.javascript variables contain two types of values, one is a reference type value, and the other is a basic type value. Reference types include: Array, Object, Function (it can be understood that non-basic types are reference types); the 5 basic types include: undefined, null, string, boolean, number

2. The mechanism for passing function parameters is to copy the variable value.

The book says: "Copying the value outside the function to the parameter inside the function is the same as copying the value from one variable to another variable. The transfer of basic types is the same as the copying of basic type variables, and the transfer of reference types It is the same as the copy of the reference type variable "

.

" When a variable copies a value of a reference type, a copy of the value stored in the variable object is also copied to the space allocated for the new variable. The difference is that the copy of the value is actually a pointer , and this pointer points to an object stored in the heap. After the copy operation is completed, the two variables will actually refer to the same object. Therefore, changing one of the variables will affect the other variable.

[Note: Copying the value of the reference type is the only way to pass the address]

3. Parameters are actually local variables of the function.

-------------------------------------------------- --------------------------

Explanation of basic concepts:

Transfer value: transfer the value of A to B, change B, A will not change accordingly, B stores the same value as A;

Transfer address: transfer the address of A to B, change B, and A will change at the same time. B only stores the address of A (similar to a computer shortcut).

A data with value type is stored in a variable on the stack. That is, allocating memory space in the stack and directly storing the contained value, the value represents the data itself. Value type data has faster access speed.

A data with a reference type does not reside on the stack, but is stored in the heap. That is, allocating memory space in the heap does not directly store the contained value, but points to the value to be stored, and its value represents the pointed address. When accessing data with a reference type, you need to check the contents of the variable on the stack, which refers to an actual data in the heap. Reference type data has larger storage size and lower access speed than value type data.

-------------------------------------------------- --------------------------

Here are three questions.

[Question 1]:

Why is the outside a not disturbed after the change(a) function is executed?

<script>
var a = [1, 2, 3];
function change(a) {
 console.log(a);//[1,2,3]
 a = 2;   //传值
 console.log(a);//2
}
change(a);
console.log(a);  //[1,2,3] 
</script>

Answer to question 1: Because the execution process of change(a) is like this, after the object a (array) is first passed into change, it is copied to the parameter a of change. Then a=2 is an assignment statement and becomes pass-by-value. At this time, a=2 is a value type and does not involve the issue of reference address. So it does not affect the external a.

[Question 2]:

Why is the outside a disturbed after the change(a) function is executed?

<script>
 var a = [1, 2, 3];
 function change() { 
  a = 2;//传值
 }
 change();
 console.log(a);  //2 
</script>

Answer to question 2: When executing change(), the function looks for the scope chain in its own execution environment. The activation object does not contain the variable a, so it searches upward along the scope chain to find the global Execution environment, variable a is found, so at this time the internal a of the function and the external a are the same address in the memory. Naturally, if the internal a of the function changes, the external one will also change.

Analysis: The difference between question 2 and question 1 is that question 2 does not introduce parameters, so it does not involve copying variables.

[Question 3]:

Why is the outside a disturbed after the change(a) function is executed?

<script>
 var a = [1, 2, 3];
 function change(b) { 
  b[0] = 2;
 }
 change(a);
 console.log(a);  //[2,2,3]
</script>

Answer to question 3: This is very similar to question 1. The only difference is that a=2 is replaced by b[0]=2. I was confused at first. Isn’t it copying? Parameter b should be a copied value, how can it affect the outside a?

Indeed, when the change function is executed, parameter b is the copied value of a. Because a is a reference type, inside the function, b and a access an address object by reference. The occurrence of b[0]=2 does not affect the fact that b and a refer to the same object inside the function.

[Question 4]:

Why is the outside a not disturbed after the change(a) function is executed?

 var a = [1, 2, 3];
 function change(b) { 
  console.log(b);//[1,2,3]
  b=2;
  b[0] = 2;
 }
 change(a);
 console.log(a);  //[1,2,3]

Answer to question 4: The execution process of change(b) is as follows: object a is passed into the change function, and the value and address are copied to b. The sentence b=2, b becomes a value type at this time, and does not involve the issue of address reference. The sentence b[0]=2 is actually meaningless after that, because b is no longer an array at this time, and naturally it does not have Indexing method like b[0]. Therefore, the address reference relationship between b and a actually disappears after b=2. At this time, the external a is still [1,2,3];

The above is the entire content of this article, I hope you all like it.