Introduction to the use of Javascript reference pointers_javascript tips

Please try to complete the following cloze:

Copy code The code is as follows:

/* Create a Queue, head is head0, tail is tail0 */
function IntList(head0, tail0){
this.head = head0 || 0;
this.tail = tail0 || null;
}
/* Return an IntList containing all the numbers in the array*/
IntList.list = function(__args){
var sentinel = new IntList(),
len = __args.length,

p = sentinel;
for(var i = 0; i p.tail = new IntList(__args[i]);
p = p.tail ;
}
return sentinel.tail;
};
/* Return the string representation of the object*/
IntList.prototype.toString = function(){
var temp = "";
temp = "[";
for(var L = this; L !== null; L = L.tail){
temp = temp " " L.head;
}
temp = " ]";
return temp;
};

/**Returns an IntList containing IntList A and IntList B,
* where the elements of B are after A. The new keyword cannot be used.
*/
function dcatenate(A, B){
/* Complete function*/
}

/**Returns a new IntList with length len,
* starting with the #start element (where #0 is the first element),
* cannot change L.
*/
function sublist(L, start, len){
/* Complete function*/
}

This is a linked list question written in Javascript. Since linked lists have relatively complex reference operations, they can be used to examine the understanding of Javascript references. Comes with a simple test case:

Copy code The code is as follows:

/* Test dcatenate and sublist Is the function correct*/
function test(){
var A = IntList.list([4,6,7,3,8]),
B = IntList.list([3,2, 5,9]);
dcatenate(A, B);
if(A.toString() === "[ 4 6 7 3 8 3 2 5 9 ]"){
alert(" The dcatenate function is correct. ");
}else{
alert("The dcatenate function is wrong.");
}
var L = IntList.list([3,4,5,2,6 ,8,1,9]),
result = sublist(L, 3, 3);
if(result.toString() === "[ 2 6 8 ]"){
alert( "The sublist function is correct.");
}else{
alert("The sublist function is correct.");
}
}

Javascript reference?

In fact, when assigning a reference type instance to a variable, the variable holds a reference to the instance:

　var temp = new Object();

This behavior is very consistent with its name, reference type, and its instances are of course referenced.

And when the variable is assigned to another variable, it is actually just a copy of the reference:

　var temp2 = temp;

So although from the definition: temp2 = temp, they are not directly related. For example, the reference of temp is modified:

Copy code The code is as follows:

var temp = {
name: "temp"
};
var temp2 = temp;
temp = {
name: "not temp2"
};
temp === temp2; //false

Of course, if we modify only the instance pointed to by the pointer, then temp2 is still equal to temp:

Copy code The code is as follows:

var temp = {
name: " temp"
};
var temp2 = temp;
temp.name = "also temp2";
temp === temp2; //true

What is IntList?

Let’s analyze the picture below:

Create two empty variables, so L and Q in the picture on the right are empty. Create a new IntList with a head of 3 and an empty tail, and assign the value referenced by L to Q, so both L and Q point to this new IntList. Q points to a newly created IntList whose head is 42 and whose tail is empty. The pointer of Q is assigned to L.tail, so that the two IntLists are nested.

It can be seen that IntList is a data structure that achieves multiple nesting through pointers, which is called a Linked List.

1. Create two empty variables, so L and Q in the picture on the right are empty.
2. Create a new IntList with a head of 3 and an empty tail. Assign the value referenced by L to Q, so both L and Q point to this new IntList.
3.Q points to a newly created IntList whose head is 42 and whose tail is empty. Assign the pointer of Q to L.tail, so that the two IntLists are nested.
It can be seen that IntList is a data structure that achieves multiple nesting through pointers, which is called a Linked List.

IntList merge

We just need to point the tail of one to the other. In this way, the two IntLists are connected:

Copy the code The code is as follows:

/**Returns an IntList containing IntList A and IntList B,
* where the elements of B are after A. The new keyword cannot be used.
*/
function dcatenate(A, B){
var p;
for(p = A; p != null; p = p.tail){
if(p.tail === null){
p.tail = B;
break;
}
}
return A
}

IntList interception
Since the question requires that the original IntList cannot be changed, we can only take out the data from the original IntList and reconstruct new data.

Copy code The code is as follows:

/**Returns a new IntList with length len,
* starting with the #start element (where #0 is the first element),
* cannot change L.
*/
function sublist(L, start, len){
var K,
P,
J;
var i = 0,
end = start len;
for(P = L; i if(i continue;
}else if(i === start){
K = new IntList(P.head);
J = K;
}else if(i > start && i J.tail = new IntList(P.head);
J = J.tail;
}else if(i >= end){
break;
}
}
return K;
}

Thinking Questions
1. How do functions pass parameters when they are passed? For example, what is the citation process for the following code?

Copy code The code is as follows:

var obj = {
name: "anything"
};
function getName(__obj){
return __obj.name;
}
var name = getName(obj);