javascript 数组总结

刚刚结束春节假期，这个春节想了很多，关于未来长远的发展方向也大致明确了。。。

言归正传，下面来总结一下js中数组的用法，以后发现有其他用法也会更新这篇文章。

一：定义

1. 使用Array构造函数

   let test1 = new Array();// []
   let test2 = new Array(3);// [undefined, undefined] // 使用Array.of方法创建数组时可以消除这种差异
   let test3 = new Array(3, 4);// [3, 4]

2. 使用数组字面量方法

   let test1 = [];// []
   let test2 = [3];// [3]
   let test3 = [3, 4];// [3,4]

   可以看到，数组字面量方法比较符合正常的逻辑。

二：属性

1. 索引
   • 索引是基于0的
   • 索引小于0时返回undefined
   • 索引最大值为arr.length - 1,获取超过索引最大值对应的值时返回undefined，赋值超过索引最大值对应的值时添加元素。arr[arr.length]  = value相当于arr.push(value)
2. length
   • length是基于1的，是数组的项数
   • 数组的length不是readonly项目，所以可以通过设置数组的length进行在数组末尾的增项减项（Gets or sets the length of the array. This is a number one higher than the highest element defined in an array.

三：检测

1. 假定只有一个全局执行环境， array instanceof Array
2. ES5新方法， Array.isArray(array)

四：数组方法

　　数组实现了Array这个接口，讨论数组的方法就是要搞明白这个接口定义。

// ES5定义的接口
interface Array<T> {
    /**
      * Gets or sets the length of the array. This is a number one higher than the highest element defined in an array.
      * 数组的length属性不是readonly的，可以通过数组length来实现在数组末尾的增项减项(可以多个一起)，
      * 和数组的栈方法（push pop）（只能单个）一致，
      */
    length: number;
    /**
      * Returns a string representation of an array.
      * 中间加上, 相当于array.join(',')
      */
    toString(): string;
    /**
      * Returns a string representation of an array. The elements are converted to string using their toLocalString methods.
      * 一般情况下返回的结果和toString方法相同
      */
    toLocaleString(): string;
    /**
      * Removes the last element from an array and returns it.
      * 栈方法，弹出数组末尾的项目
      */
    pop(): T | undefined;
    /**
      * Appends new elements to an array, and returns the new length of the array.
      * 栈方法，在数组末尾增加项目
      * @example
      * let array = [1, 2];
      * array.push(3); // [ 1, 2, 3 ]
      * array.push(3, 4); // [ 1, 2, 3, 4 ] 注意push方法的参数不是数组
      * array.push([3, 4]); // [ 1, 2, [ 3, 4 ] ]
      * @param items New elements of the Array.
      */
    push(...items: T[]): number;
    /**
      * Removes the first element from an array and returns it.
      * 队列方法，弹出数组开头项目
      */
    shift(): T | undefined;
    /**
     * Inserts new elements at the start of an array.
     * 队列方法，在数组开头增加项目
     * 和栈方法类似，unshift方法的参数不是数组。
     * 栈方法和队列方法是js实现栈数据结构和队列数据结构的具体表现，使用时大多数情况下不会刻意的想到数据结构，
     * 不过还是要锻炼把问题简化为数据结构的能力。
     * @param items  Elements to insert at the start of the Array.
     */
    unshift(...items: T[]): number;
    /**
      * Reverses the elements in an Array.
      * 翻转数组,基本没什么用
      * @example
      * let array = [1, 2];
      * array.reverse();
      * console.log(array)// [ 2, 1 ]
      */
    reverse(): T[];
    /**
      * Sorts an array.
      * 排序方法，可选参数，省略时默认升序，按照Ascll码进行比较
      * 比较函数接受数组中的任意2个项目，返回一个数字，数字小于0时，第一个参数在前，数字大于0时，第二个参数在前
      * 大规模的排序使用这个方法会造成性能问题，这要研究sort方法的实现原理，这里留个坑，以后来补。（TODO）
      * @param compareFn The name of the function used to determine the order of the elements. If omitted, the elements are sorted in ascending, ASCII character order.
      */
    sort(compareFn?: (a: T, b: T) => number): this;
    /**
      * Combines two or more arrays.
      * 使用concat方法主要要分清与push方法的差别，
      * push方法会改变原来的数组，返回的是新的数组的长度，concat方法是创建原来数组的副本，不改变原来的数组，返回的是连接好的新的数组
      * push方法的参数是数组时，只会把数组当做一个元素进行处理，concat方法的参数是数组时则会展开
      * concat方法更符合函数式编程思想（concat可以用来创建数组的副本）
      * @param items Additional items to add to the end of array1.
      */
    concat(...items: ConcatArray<T>[]): T[];
    /**
      * Combines two or more arrays.
      * concat方法的参数可以是单个元素，也可以是多个数组，数组会被展开成多个元素进行连接
      * @param items Additional items to add to the end of array1.
      */
    concat(...items: (T | ConcatArray<T>)[]): T[];
    /**
      * Adds all the elements of an array separated by the specified separator string.
      * 把数组转换为字符串，可以指定连接符，不指定连接符时默认为逗号
      * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
      */
    join(separator?: string): string;
    /**
      * Returns a section of an array.
      * 返回数组的一部分,对原数组没有影响，这里可以原来创建数组的副本。根据函数式编程的思想，编写操作数组的函数时，应尽量使用slice创建副本，不改变传递参数数组
      * @example1
      * let array = [5, 6, 3, 8];
      * let array1 = array;//这里array1和array指向内存的同一个地址，值改变时相互影响
      * console.log(array1)// [ 5, 6, 3, 8 ]
      * array.length = 3;
      * console.log(array1)// [ 5, 6, 3 ]
      * @example2
      * let array = [5, 6, 3, 8];
      * let array1 = array.slice();//这里array1和array指向内存的不同地址，值改变时不会相互影响
      * console.log(array1)// [ 5, 6, 3, 8 ]
      * array.length = 3;
      * console.log(array1)// [ 5, 6, 3, 8 ]
      * 指定开始位置和结束位置，位置都是从0开始的,注意，返回的数组包含开始位置的值，不包含结束位置的值
      * 这里特殊的是位置可以为负数，为负数时则会加上数组的长度重新进行计算（为了方便从数组末尾取值）
      * @example3
      * console.log(array.slice(0, 2))//[ 5, 6 ]取得数组前面2个项目
      * console.log(array.slice(-2))//[ 3, 8 ]取得数组后面2个项目
      * console.log(array.slice(3, 2))//[]开始位置大于结束位置时，返回空数组
      * @param start The beginning of the specified portion of the array.
      * @param end The end of the specified portion of the array.
      */
    slice(start?: number, end?: number): T[];
    /**
      * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
      * 向数组中（删除、插入、替换）项目,会改变原来的数组，不符合函数式编程的思想
      * （这里返回的是删除的项目，如果返回的是删除后的数组，就可以做到不改变原来的数组，不过这样和slice提取数组中的部分元素类似）
      * @example1 删除项目
      * let array = [5, 6, 3, 8];
      * console.log(array.splice(0, 2))//[ 5, 6 ] 从位置0开始删除2个元素，返回删除的元素组成的数组
      * console.log(array)// [ 3, 8 ] 原来的数组被改变了
      * @example2 插入项目
      * let array = [5, 6, 3, 8];
      * console.log(array.splice(1, 0, 7, 9))//[] 插入项目时第2个参数为0，后面的参数就是要插入的元素
      * console.log(array)// [ 5, 7, 9, 6, 3, 8 ]
      * @example3 替换项目
      * let array = [5, 6, 3, 8];
      * console.log(array.splice(1, 1, 7, 9))//[ 6 ] 替换项目就是把原来的项目删除，把新的项目添加进去
      * console.log(array)// [ 5, 7, 9, 3, 8 ]
      * @param start The zero-based location in the array from which to start removing elements.
      * @param deleteCount The number of elements to remove.
      */
    splice(start: number, deleteCount?: number): T[];
    /**
      * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
      * @param start The zero-based location in the array from which to start removing elements. 
      * 开始位置
      * @param deleteCount The number of elements to remove. 
      * 要删除的项数
      * @param items Elements to insert into the array in place of the deleted elements. 
      * 从开始位置插入的项目，参数不是数组，传递数组则会被当做一个元素
      */
    splice(start: number, deleteCount: number, ...items: T[]): T[];
    /**
      * Returns the index of the first occurrence of a value in an array.
      * 位置方法，如果没有找到返回-1，indexOf方法主要用来找index，但是一直以来使用都是判断数组中是否包含某个元素
      * @example1 判断数组中是否包含某个元素
      * array.indexOf(value) !== -1 // 包含这个元素
      * ES7中提供includes方法，返回的是true或者false，更适合判断数组中是否包含某个元素
      * @param searchElement The value to locate in the array.
      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
      */
    indexOf(searchElement: T, fromIndex?: number): number;
    /**
      * Returns the index of the last occurrence of a specified value in an array.
      * 与indexOf方法的区别在于搜索顺序
      * @param searchElement The value to locate in the array.
      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array.
      */
    lastIndexOf(searchElement: T, fromIndex?: number): number;
    /**
      * Determines whether all the members of an array satisfy the specified test.
      * 数组中的所有元素运行给定的判定函数，判定函数都返回true时，every方法的返回结果才为true，否则为false
      * 一旦遇到false就不会继续执行其他的元素，直接返回false
      * @example1 判断数组中的元素是否都是奇数
      * array.every((v) => {return v % 2 !== 0})
      * 判定函数接受3个参数，当前元素，当前元素在数组中对应的位置，当前数组
      * @example2 every方法接受第2个可选参数，this对象指向的对象，不指定时this对象指向空对象。every方法中想要使用外部的数据时，可以使用thisArg，但是要注意不能使用箭头函数
      * let array = [5];
      * let obj = {}
      * obj.name = 'WT'
      * array.every(function (v) {console.log(this)}, obj) // { name: 'WT' } 
      * array.every((v) => {console.log(this)}, obj) // {} 注意，如果使用了箭头函数，指定thisArg是没有作用的
      * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
    every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
    /**
      * Determines whether the specified callback function returns true for any element of an array.
      * 数组中的所有元素运行给定的判定函数，判定函数有一个返回true时，some方法的返回结果就为true，运行结果都为false时，some方法的结果才为false
      * 一旦遇到true就不会继续执行其他的元素，直接返回true
      * 想要使用外部的数据时，可以使用thisArg，但是要注意不能使用箭头函数，参考every方法的说明
      * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
    some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
    /**
      * Performs the specified action for each element in an array.
      * 没有返回值，单纯的遍历数组中的元素，不能中途return，如果需要return使用for循环替代
      * 想要使用外部的数据时，可以使用thisArg，但是要注意不能使用箭头函数，参考every方法的说明
      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
      * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
    /**
      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
      * 重组数组，返回参数函数的返回值组成的数组，不改变原来的数组，可以用来创建数组的副本（slice和concat方法也可以），符合函数式编程思想
      * 想要使用外部的数据时，可以使用thisArg，但是要注意不能使用箭头函数，参考every方法的说明
      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
    /**
     * Returns the elements of an array that meet the condition specified in a callback function.
     * 过滤数组，返回参数函数的返回值为true时对应的元素组成的数组
     * 想要使用外部的数据时，可以使用thisArg，但是要注意不能使用箭头函数，参考every方法的说明
     * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
     * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
     */
    filter<S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
    /**
      * Returns the elements of an array that meet the condition specified in a callback function.
      * 想要使用外部的数据时，可以使用thisArg，但是要注意不能使用箭头函数，参考every方法的说明
      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
    filter(callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[];
    /**
      * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
      * 规约方法，用于需要保留状态的情况，也就是说，想得到一个值，必须知道上一个值是什么
      * 接受可选参数，初始值，没有指定时初始值为数组的第一个元素
      * 规约函数接受4个参数，之前的值，当前元素，当前元素对应的index， 数组
      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
      */
    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
    /**
      * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
      */
    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
    /**
      * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
      * 规约方法，reduce方法是从数组的第一个开始合并，reduceRight方法是从数组的最后一个元素开始合并
      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
      */
    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
    /**
      * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
      */
    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;

    // 索引取得值
    [n: number]: T;
}

 ES5的数组方法是最基本的，在实际的业务开发中用到的也是最多的。ES6中对数组进行了扩展

1.  数组实例的遍历（返回的都是遍历器，操作遍历器可以使用for of ，Array.from）

interface Array<T> {
    /** Iterator */
    [Symbol.iterator](): IterableIterator<T>;
    // 注意，3个方法返回的都是遍历器，不是返回的数组
    // 要想取得遍历器的值，提供3种方法
    
    // let array = [5,6];
    // for (let v of array.entries()) { // for of 遍历接口
    //     console.log(v)// [ 0, 5 ] [ 1, 6 ]
    // }
    // let entries = array.entries(); // 当做遍历器来遍历
    // console.log(entries.next().value); // [ 0, 5 ]
    // console.log(entries.next().value); // [ 1, 6 ]
    // Array.from(array.entries()).forEach((v) => {console.log(v)}) // 使用Array.from方法转换为数组
    /**
     * Returns an iterable of key, value pairs for every entry in the array
     * 返回键值对组成的遍历器(用来把一维数组转成2维数组)
     */
    entries(): IterableIterator<[number, T]>;

    /**
     * Returns an iterable of keys in the array
     * 返回键组成的遍历器
     */
    keys(): IterableIterator<number>;

    /**
     * Returns an iterable of values in the array
     * 返回值组成的遍历器
     */
    values(): IterableIterator<T>;
}

 　　2. ES6中在数组实例上还添加了其他的操作方法

interface Array<T> {
    /**
     * Returns the value of the first element in the array where predicate is true, and undefined
     * otherwise.
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found, find
     * immediately returns that element value. Otherwise, find returns undefined.
     * @param thisArg If provided, it will be used as the this value for each invocation of
     * predicate. If it is not provided, undefined is used instead.
     * 找到第一个返回值为true的元素，返回这个元素,如果都为false返回undefined(使用indexof也可以完成同样的操作，先取得index，再通过array[index]取得元素，不过这没有find方便)
     */
    find<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
    find(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): T | undefined;

    /**
     * Returns the index of the first element in the array where predicate is true, and -1
     * otherwise.
     * @param predicate find calls predicate once for each element of the array, in ascending
     * order, until it finds one where predicate returns true. If such an element is found,
     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
     * @param thisArg If provided, it will be used as the this value for each invocation of
     * predicate. If it is not provided, undefined is used instead.
     * 找到第一个返回值为true的元素，返回这个元素,如果都为false返回-1
     */
    findIndex(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): number;

    /**
     * Returns the this object after filling the section identified by start and end with value
     * @param value value to fill array section with
     * @param start index to start filling the array at. If start is negative, it is treated as
     * length+start where length is the length of the array.
     * @param end index to stop filling the array at. If end is negative, it is treated as
     * length+end.
     * 使用给定值替换数组中的元素
     */
    fill(value: T, start?: number, end?: number): this;

    /**
     * Returns the this object after copying a section of the array identified by start and end
     * to the same array starting at position target
     * @param target If target is negative, it is treated as length+target where length is the
     * length of the array.
     * @param start If start is negative, it is treated as length+start. If end is negative, it
     * is treated as length+end.
     * @param end If not specified, length of the this object is used as its default value.
     */
    copyWithin(target: number, start: number, end?: number): this;
}

find 和findIndex弥补了indexOf方法在检测NaN时的不足

[NaN].indexOf(NaN) // -1

[NaN].findIndex(v => Object.is(NaN, v)) // 0

补充： fill的作用是替换数组中的一些值（使用开始和结束的index），可以使用splice实现，不过没有fill方便

let a = [1, 2, 3];
// a.fill(8); // [ 8, 8, 8 ]
// a.fill(8, 0, 1); // [ 8, 2, 3 ]
// a.fill(8, -1); // [ 1, 2, 8 ]

 

3.ES6还在Array这个全局对象上添加了2个方法

interface ArrayConstructor {
    /**
     * Creates an array from an iterable object.
     * @param iterable An iterable object to convert to an array.
     */
    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];

    /**
     * Creates an array from an iterable object.
     * @param iterable An iterable object to convert to an array.
     * @param mapfn A mapping function to call on every element of the array.
     * @param thisArg Value of 'this' used to invoke the mapfn.
     */
    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
}

Array.from方法可以把2类数据转换为数组，一是遍历器（使用扩展运算符...也可以把遍历器转换为数组），二是类数组对象（有length属性）

let array = [5,6];
let entries = array.entries();
console.log(entries)// {}
console.log([...entries])// [ [ 0, 5 ], [ 1, 6 ] ]
console.log(Array.from(entries))// [] 这里是因为遍历器已经被遍历完成，从这里可以看出了遍历器不符合函数式编程的思想

let array = [5,6];
let entries = array.entries();
console.log(entries)// {}
console.log(Array.from(entries))// [ [ 0, 5 ], [ 1, 6 ] ] 这里就符合预期了

of<T>(...items: T[]): T[]; of方法是为了弥补Array构造函数的不足

new Array(3) // [undefined, undefined, undefined]

Array.of(3) // [3] 更加符合预期，Array.of方法总是符合参数值组成的数组。

五：总结

js对数组的支持是比较友好的，可以进行链式调用，并且一部分方法符合函数式编程的思想。

数组的方法很多，在什么场景是使用什么方法非常重要。

关于数组的总结就到这里了，后期会持续维护文章

 

作成： 2019-02-08

修改： 

1. 2019-02-10 23:26:18 添加分类
2. 2019-02-16 18:03:45 添加fill方法的例子