创建数组的方式有？那种比较高效？原因是？

第一种模式

var nums = [];

var numbers = [1,2,3,4,5];
console.log(numbers.length)//5

第二种模式

var nums = new Array[];

var numbers = new Array(10);

console.log(numbers.length)//10

从效率上说 第一种[]这个的效率更高

判断一个对象是否是数组：可以调用Array.isArray();

第三种模式
参见2.2.3

var numbers = [1,2,3,4,5];

var sum=0;

if (Array.isArray(numbers)) {

   // perform array tasks on numbers

    sum=numbers[0]+numbers[1]+numbers[2]+numbers[3]+numbers[4];

    console.log(sum);//15

}

当然更好的求和方案是用for循环，数组固有属性

numbers.length

var sentence = "the quick brown fox jumped over the lazy dog";

var words = sentence.split(" ");//根据空格分组

for (var i = 0; i < words.length; ++i) {

   print("word " + i + ": " + words[i]);

}
//结果参见下图

//浅复制：

var nums=[1,2,3];

var samenums=nums;

nums[0]=0;

console.log(samenums[0]); //0 这里是0，而不是复制过来时候的1.

//深复制

for(var i=0;i<nums.length;i++){

    samenums[i]=nums[i];

}

//这时候我们再：
nums[0]=0;

console.log(samenums[0])    //1，这里依旧是1.

var names = ["David","Cynthia","Raymond","Clayton","Jennifer"];

//putstr("Enter a name to search for: ");

var name ="Clayton";

var position = names.indexOf(name);

if (position >= 0) {

   console.log("Found " + name + " at position " + position);

}

else {

   console.log(name + " not found in array.");

}

//Found Clayton at position 3

有两个方法可以将数组转化为字符串： join() 和 toString() 。这两个方法都返回一个包含

数组所有元素的字符串，各元素之间用逗号分隔开。下面是一些例子：

var names = ["David", "Cynthia", "Raymond", "Clayton", "Mike", "Jennifer"];

var namestr = names.join();

print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer

namestr = names.toString();

print(namestr); // David,Cynthia,Raymond,Clayton,Mike,Jennifer

事实上，当直接对一个数组使用 print() 函数时，系统会自动调用那个数组的 toString()

方法：

print(names); // David,Cynthia,Raymond,Clayton,Mike,Jennifer

concat() 和 splice() 方法允许通过已有数组创建新数组。 concat 方法可以合并多个数组

创建一个新数组， splice() 方法截取一个数组的子集创建一个新数组。

我们先来看看 concat() 方法的工作原理。该方法的发起者是一个数组，参数是另一个数

组。作为参数的数组，其中的所有元素都被连接到调用 concat() 方法的数组后面。下面的

程序展示了 concat() 方法的工作原理：

var cisDept = ["Mike", "Clayton", "Terrill", "Danny", "Jennifer"];

var dmpDept = ["Raymond", "Cynthia", "Bryan"];

var itDiv = cis.concat(dmp);

print(itDiv);

itDiv = dmp.concat(cisDept);

print(itDiv);

输出为：

Mike,Clayton,Terrill,Danny,Jennifer,Raymond,Cynthia,Bryan

Raymond,Cynthia,Bryan,Mike,Clayton,Terrill,Danny,Jennifer

第一行首先输出 cis 数组里的元素，第二行首先输出 dmp 数组里的元素。

/**

 * 请用浏览器的控制台直接拷贝运行分段测试

 * @type {number[]}

 */

//Test1

var nums = [1,2,3,4,5];

console.log(nums); // 1,2,3,4,5

nums.push(6);

console.log(nums);

//Test2

//unshift() 方法可以将元素添加在数组的开头，下述代码展示了该方法的用法：

var nums = [2,3,4,5];

console.log(nums); // 2,3,4,5

var newnum = 1;

nums.unshift(newnum);

console.log(nums); // 1,2,3,4,5

nums = [3,4,5];

nums.unshift(newnum,1,2);

console.log(nums); // 1,2,3,4,5

使用 pop() 方法可以删除数组末尾的元素：

var nums = [1,2,3,4,5,9];

nums.pop();

print(nums); // 1,2,3,4,5

如果没有可变函数，从数组中删除第一个元素需要将后续元素各自向前移动一个位置，和

在数组开头添加一个元素一样低效：

var nums = [9,1,2,3,4,5];

print(nums);

for (var i = 0; i < nums.length; ++i) {

nums[i] = nums[i+1];

}

print(nums); // 1,2,3,4,5,

除了要将后续元素前移一位，还多出了一个元素。当打印出数组中的元素时，会发现最后

多出一个逗号。

shift() 方法可以删除数组的第一个元素，下述代码展示了该方法的用法：

var nums = [9,1,2,3,4,5];

nums.shift();

print(nums); // 1,2,3,4,5

这回数组末尾那个多余的逗号消失了。 pop() 和 shift() 方法都将删掉的元素作为方法的

返回值返回，因此可以使用一个变量来保存删除的元素：

var nums = [6,1,2,3,4,5];

var first = nums.shift(); // first gets the value 9

nums.push(first);

print(nums); // 1,2,3,4,5,6

剩下的两个可变方法是为数组排序。第一个方法是 reverse() ，该方法将数组中元素的顺

序进行翻转。下面这个例子展示了该如何使用该方法：

var nums = [1,2,3,4,5];

nums.reverse();

print(nums); // 5,4,3,2,1

对数组进行排序是经常会遇到的需求，如果元素是字符串类型，那么数组的可变方法

sort() 就非常好使：

var names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];

names.sort();

print(names); // Bryan,Clayton,Cynthia,David,Mike,Raymond

但是如果数组元素是数字类型， sort() 方法的排序结果就不能让人满意了：

var nums = [3,1,2,100,4,200];

nums.sort();

print(nums); // 1,100,2,200,3,4

sort() 方法是按照字典顺序对元素进行排序的，因此它假定元素都是字符串类型，在上一

个例子中，即使元素是数字类型，也被认为是字符串类型。为了让 sort() 方法也能排序数

字类型的元素，可以在调用方法时传入一个大小比较函数，排序时， sort() 方法将会根据

该函数比较数组中两个元素的大小，从而决定整个数组的顺序。

对于数字类型，该函数可以是一个简单的相减操作，从一个数字中减去另外一个数字。如

果结果为负，那么被减数小于减数；如果结果为 0，那么被减数与减数相等；如果结果为

正，那么被减数大于减数。

将这些搞清楚之后，传入一个大小比较函数，再来看看前面的例子：

function compare(num1, num2) {

return num1 - num2;

}

var nums = [3,1,2,100,4,200];

nums.sort(compare);

print(nums); // 1,2,3,4,100,200

sort() 函数使用了 compare() 函数对数组按照数字大小进行排序，而不是按照字典顺序。