JS Array Operation Encyclopedia

Shift: Deletes the first item of the original array and returns the value of the deleted element, or returns undefined if the array is empty
var a = [1,2,3,4,5];
var B = A.shift ();
Results a:[2,3,4,5] B:1
Unshift: Adds a parameter to the beginning of the original array and returns the length of the array
var a = [1,2,3,4,5];
var B = A.unshift ( -2,-1);
Results a:[-2,-1,1,2,3,4,5] B:7
Note: The test return value under IE6.0 is always undefined,ff2.0 the test return value is 7, so the return value of this method is unreliable, and it is necessary to use splice instead of this method with the return value.

Pop: Deletes the last item of the original array and returns the value of the deleted element, or returns undefined if the array is empty
var a = [1,2,3,4,5];
var B = A.pop ();
Results a:[1,2,3,4] B:5

Push: Adds a parameter to the end of the original array and returns the length of the array
var a = [1,2,3,4,5];
var B = A.push (6,7);
Results a:[1,2,3,4,5,6,7] B:7
Concat: Returns a new array that adds a parameter to the original array.
var a = [1,2,3,4,5];
var B = A.concat (6,7);
Results a:[1,2,3,4,5] b:[1,2,3,4,5,6,7]

Splice (Start,deletecount,val1,val2,...) : Deletes the DeleteCount entry from the start position and inserts the Val1,val2 from that location,...
var a = [1,2,3,4,5];
var B = A.splice (2,2,7,8,9);
Results a:[1,2,7,8,9,5] b:[3,4]

var B = a.splice (0,1); With shift
A.splice (0,0,-2,-1);                     var B = a.length; With Unshift
var B = A.splice (a.length-1,1); Same pop
A.splice (a.length,0,6,7);                 var B = a.length; Same push

Reverse: Reverse-order the array
var a = [1,2,3,4,5];
var B = A.reverse ();
Results a:[5,4,3,2,1] b:[5,4,3,2,1]

Sort (orderfunction): Sorting by specified array of parameters
var a = [1,2,3,4,5];
var B = A.sort ();
Results a:[1,2,3,4,5] b:[1,2,3,4,5]

Slice (Start,end): Returns a new array of items from the original array specifying the start subscript to the end subscript
var a = [1,2,3,4,5];
var B = a.slice (2,5);
Results a:[1,2,3,4,5] b:[3,4,5]

Join (Separator): Sets the element of an array to a string, separator as a delimiter, and omitted by default with a comma as the delimiter
var a = [1,2,3,4,5];
var B = A.join ("");
Results a:[1,2,3,4,5] B: "12345"

An array is an internal object provided by JavaScript, it is a standard set, we can add (push), delete (shift) elements, and we can iterate through the elements in the for loop, so can we have any other collection in JavaScript except the array?
Because of the language characteristics of JavaScript, we can dynamically add and remove properties to common objects. So object can also be considered as a special set of JS.

Here's a comparison of the array and object features:
Array:
NEW: var ary = new Array (); or var ary = [];
Increase: Ary.push (value);
Delete: delete Ary[n];
Traversal: for (var i=0 i < ary.length; ++i) ary[i];

Object:
NEW: var obj = new Object (); or var obj = {};
Add: Obj[key] = value; (Key is String)
Delete: delete Obj[key];
Traversal: for (var key in obj) Obj[key];

From the comparison above, you can see that object can be used as a collection, and in creating an infinite-level Web page menu (3) using the popup window I introduced the __menucache__ that Eric implemented, which is a mock collection object.

If we want to retrieve a specified value in the array, we need to traverse the entire array:
var keyword =;
for (Var i=0 i < ary.length; ++i)
{
if (ary[i] = = keyword)
{
}
}

And we retrieve an entry for the specified key in object, which is only required to use:
var key = ';
var value = Obj[key];
This feature of object can be used to efficiently retrieve a unique set of strings, and the time complexity of traversing an array is O (n), while the time complexity of traversing the object is O (1). Although for the 10,000 collection for retrieval cost is also dozens of MS, but if it is 1000*1000 or more, the advantage of using the object is reflected. Before that, I made a mapping of 100 unique characters mapping to 1000 string arrays, which took a long time 25-30s! later changed the for traversal to a member reference of the set of object simulation, the same amount of data mapping, Time Consuming only 1.7-2S!!!
For the traversal efficiency of the set (from high to low): var value = Obj[key]; > for (;;) > for (in). The least efficient is for (in), and if the collection is too large, try not to use for (in) traversal.