javascript数组详解

一、数组基础

var box = [,,] 数组有2个元素，都是undefined

• 区别数组的索引和对象的属性名

　　　　所有的索引都是属性名，但只有在0~2^32 - 2之间的整数属性名才是索引.

• 数组的长度问题

　　　　如果不想让别人修改数组长度，可以使用Object.defineProperty()来定义数组长度　　　　

var box = [1,2,3];
Object.defineProperty(box, 'length', {
    writable: false
});

•  对一个数组元素使用delete不会修改数组的length属性，只是会让它变成稀疏数组

二、数组方法

• join()

　　　　将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串

var box = [1,2,3];
box.join();  //=> "1,2,3"
box.join(" ");  //=> "1 2 3"

• reverse()

　　　　将数组中的元素颠倒顺序，返回逆序的数组，并且是在原数组中重新排列它们

var box = [1,2,3];
a.reverse().join()  //=> "3,2,1",并且现在的box是[3,2,1]

• sort()

　　　　将数组中的元素排序并返回排序后的数组，如果不带参数时，数组元素以字母表顺序排序.如果数组中包含undefined元素，直接排到末尾

var box = new Aarry("banana", "cherry", "apple");
var s = box.join(", ")  //=> "apple, banana, cherry"
var box = [33, 4, 1111, 222];
box.sort();  //=> 1111, 222, 33, 4 根据字母表顺序排序
box.sort(funtion() {
    return a-b; //=> 4,33,222,1111
    //return b-a; //=> 1111,222,33,4
});

• concat()

　　　　将新元素和数组的元素连接，并返回一个新数组.不会修改原数组

var box = [1,2,3];
box.concat(4, 5);  //=> [1,2,3,4,5]
box.concat([4,5]) //=> [1,2,3,4,5]
box.concat([4,5],[6,7]) //=> [1,2,3,4,5,6,7]
box.concat(4,[5,[6,7]]) //=> [1,2,3,4,5,[6,7]]

• slice()

　　　　返回指定数组的一个片段或子数组，不会修改调用的数组

var box = [1,2,3,4,5];
box.slice(0,3)  //=> [1,2,3]
box.slice(3)  //=> [4,5]
box.slice(1,-1) //=> [2,3,4]
box.slice(-3,-1) //=> [3,4]

• splice()

　　　　在数组中插入或删除元素，会修改调用的数组

var box = [1,2,3,4,5];
box.splice(3) //=> 返回[4,5] a=[1,2,3]
box.splice(1,2) //=> 返回[2,3] a=[1]
var box = [1,2,3,4,5];
box.splice(2,0,6,7)  //=> 返回[] a=[1,2,6,7,3,4,5]

• push()和pop()

　　　　push()方法在数组的尾部添加一个或多个元素，并返回数组新的长度

　　　　pop()方法删除数组的最后一个元素，减小数组长度并返回它删除的值，都修改并替换原始数组

var box = [1,2,3]
box.push(4,5)  //=> 返回4,5  box = [1,2,3,4,5]
box.pop() //=> 返回5  box = [1,2,3,4]

• unshift()和shift()

　　　　unshift()方法在数组的头部添加一个或多个元素

　　　　shift()方法删除数组的第一个元素并将其返回

var box = [1,2,3]
box.unshift(4) //=> 返回4  box = [4,1,2,3]
box.unshift(5,6) //=> 返回5,6  box = [5,6,4,1,2,3]
box.shift() //=> 返回5  box = [6,4,1,2,3]

• toString()和toLocalString()

　　　　数组和其它对象一样也拥有toString()方法.该方法将其每个元素转化为字符串并以逗号分隔输出

[1,2,3].toString()  //=> '1,2,3'
[1,[2,'c']].toString() //=> '1,2,c'

• forEach()

　　　　forEach()方法从头至尾遍历数组.forEach()可传入三个参数，分别为：数组元素、元素的索引、数组本身

var box = [1,2,3,4,5]
var sum = 0
box.forEach(function(value) {
    sum += value;
})
sum //=> 15
box.forEach(function(v, i ,a) {
    a[i] = v + 1;
})  //=> [2,3,4,5,6]

 

• map()

　　　　map()方法将调用的数组的每个元素传递给指定的函数，并返回一个数组

var box = [1,2,3]
a = box.map(function(x) {
    return x*x;
})  //=> a=[1,4,9]

• filter()

　　　　filter()方法返回得数组元素是调用的数组的一个子集

var box = [5,4,3,2,1]
a = box.filter(function(x) {
    return x<3}); //=> [2,1]
b = box.filter(function(x,i) {
    return i%==0}) //=> [5,3,1]

• every()和some()

　　　　every()方法当对数组中的所有元素调用判定函数都返回true，结果才返回true.它在判定函数第一次返回false后就返回false

　　　　some()方法当数组中至少有一个元素调用判定函数返回true，它就返回true.它在判定函数第一次返回true后就返回true

var box = [1,2,3,4,5]
box.every(function(x) {
    return x<10;}) //true
box.some(function(x) {
    return x>3}) //true

• reduce()和reduceRight()

　　　　reduce()方法使用指定的函数将数组元素进行组合，生成单个值.需要传递两个参数，第一个是执行的函数，第二个是传递给函数的初始值

　　　　reduceRight()方法和reduce()一样，不同的是它按照数组索引从高到低(从右到左)处理数组

var box = [1,2,3,4]
var sum = box.reduce(function(x,y) {
    return x+y}, 0); //数组求和
var product = box.reduce(function(x,y) {
    return x*y},1)  //数组求积
var max = box.reduce((function(x,y) {
    return (x>y)?x:y;}) //求最大值
var box = [2,3,4]
var big = box.reduceRight(function(a,b) {
　　return Math.pow(b,a)
})  //2^(3^4)

• indexOf()和lastIndexOf()

　　　　indexOf()方法搜索数组中具有给定值的元素，返回找到的第一个元素的索引，如果没有找到就返回-1

　　　　lastIndexOf()方法从末尾开始搜索.它们都可以传两个参数，第一个是需要搜索的值，第二个是一个索引值，代表从哪里开始搜索

var box = [1,2,3,4]
box.indexOf(1)  //0
box.lastIndexOf(1) //3
box.indexOf(5) //-1

• charAt()

　　　　charAt()方法来访问单个的字符，也可用方括号

var box = "test"
box.charAt(0)  //t
box[0] //t

 三、类数组对象

• 什么是类数组

　　　　具有length属性

　　　　length属性大于该对象的最大索引

var box = {"0": "a", "1": "b", "2": "c", length: 3};
var result = Array.map(box, function() {
    return x.toUpperCase();
})   // ["A","B","C"]   

•  类数组有：arguments，NodeList，字符串
• 几乎所有的数组方法都是通用的，但除了concat()方法，因为concat在连接时，会检查其参数的[[class]]属性

四、补充

• 数组优先使用for循环，而不是for in 循环，因为for in更多用于遍历对象，他会去检查对象的原型，如果浏览器支持for of，最好使用，因为for of不会去遍历原型
• 迭代优于循环

　　　　因为迭代可以消除没必要的终止条件和任何数组索引，但是循环对于控制流操作如：break和continue优于迭代

for(var i = 0; i < box.length; i ++) {
    box[i].score++;
}

//使用迭代
box[i].forEach(function(x){
    x.score++;
})

•  数组类型检测

　　　　ES5可以使用Array.isArray()函数来检测

Array.isArray([])  //true
Array.isArray({}) //false

 　　　　typeof操作对于方法，数组都返回object，所以不行，instanceof操作符能用于简单的情形

[] instanceof Array  // true
({}) instanceof Array // false

　　

转载于:https://www.cnblogs.com/laof/p/6073748.html