精华内容
下载资源
问答
  • js中数组常用API总结

    2021-09-14 22:13:16
    今天捋捋有关JS中数组API的知识。先来看Array的静态方法,然后是Array的实例方法。 1.静态方法: 1.1 Array.from():从类数组对象或者可迭代对象中创建一个新的数组实例 let set = new Set(['a', 'b', 'c', 'd']) ...

    今天捋捋有关JS中数组API的知识。先来看Array的静态方法,然后是Array的实例方法。

    1.静态方法:

    1.1 Array.from()

    从类数组对象或者可迭代对象中创建一个新的数组实例

    	let set = new Set(['a', 'b', 'c', 'd'])
        let arr = Array.from(set)
        console.log(arr, arr instanceof Array);
    

    浏览器打印结果:
    在这里插入图片描述

    1.2 Array.isArray()

    用来判断某个变量是否是一个数组对象

    	let arr = [1, 2, 3]
        console.log(Array.isArray(arr));
    

    浏览器打印结果:
    在这里插入图片描述

    1.3 Array.of()

    根据一组参数来创建新的数组实例,支持任意的参数数量和类型

     	let arr3 = Array.of('开发小白', { name: 'Liderder ' })
        console.log(arr3);
    

    浏览器打印结果:
    在这里插入图片描述

    2.实例方法:

    设arr为Array对象的实例对象:

    let arr = new Array()
    

    2.1 arr.at()

    返回给定索引处的数组项。接受从最后一项开始倒数的负整数。

     	let arr = [1, 5, 6, 8, 7, 9]
        console.log('arr.at(-1)', arr.at(-1));
        console.log('arr.at(1)', arr.at(1));
    

    浏览器打印结果:
    在这里插入图片描述

    2.2 arr.concat()

    用于合并两个或多个数组。此方法不会更改现有数组,而是返回一个新数组

    	let arr2 = [1, 2, 3], arr3 = [4, 5, 6]
        let arr = arr2.concat(arr3, arr2)
        console.log(arr,arr2,arr3);
    

    浏览器打印结果:
    在这里插入图片描述

    2.3 arr.copyWithin()

    浅复制数组的一部分到同一数组中的另一个位置,并返回它,不会改变原数组的长度,但是会 改变数原数组元素

    	let arr = [1, 2, 3]
        arr.copyWithin(0, 1, 2)
        console.log(arr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.4 arr.entries()

    方法返回一个新的Array Iterator对象,该对象包含数组中每个索引的键/值对。

    	let arr = ['a', 'b', 'c']
        let iterator1 = arr.entries()
        console.dir(iterator1);
        console.log(iterator1.next().value);
        console.log(iterator1.next().value);
    

    浏览器打印结果:
    在这里插入图片描述

    2.5 arr.every()

    方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值

    	let arr = [1, 5, 6, 8, 7, 9]
        let res = arr.every((item, index, array) => {
            return item > 1
        })
        console.log(res);
    

    浏览器打印结果:
    在这里插入图片描述

    2.6 arr.fill()

    方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引
    需要注意的是:
    fill 方法接受三个参数 value, start 以及 end. start 和 end 参数是可选的, 其默认值分别为 0 和 this 对象的 length 属性值。

    如果 start 是个负数, 则开始索引会被自动计算成为 length+start, 其中 length 是 this 对象的 length 属性值。如果 end 是个负数, 则结束索引会被自动计算成为 length+end。

    fill 方法故意被设计成通用方法, 该方法不要求 this 是数组对象。

    fill 方法是个可变方法, 它会改变调用它的 this 对象本身, 然后返回它, 而并不是返回一个副本。

    当一个对象被传递给 fill方法的时候, 填充数组的是这个对象的引用
    这里只介绍一下最基本的使用:

    	let arr = [1, 5, 6, 8, 7, 9]
        arr.fill(0, 1, 3)
        console.log(arr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.7 arr.filter()

    方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

    	let arr = [1, 5, 6, 8, 7, 9]
        let newArr = arr.filter((item) => {
            return item > 6
        })
        console.log(newArr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.7 arr.find()

    方法返回数组中满足提供的测试函数的=第一个元素的值。否则返回 undefined=

    et arr = [1, 5, 6, 8, 7, 9]
        let res = arr.find((item) => {
            return item > 6
        })
        console.log(res);
    

    浏览器打印结果:
    在这里插入图片描述

    2.8 arr.find()

    返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1

    	let arr = [1, 5, 6, 8, 7, 9]
        let res = arr.findIndex((item) => {
            return item > 6
        })
        console.log(res);
    

    浏览器打印结果:
    在这里插入图片描述

    2.9 arr.flat()

    方法会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素**合并为一个新数组返回**
    接收一个参数,指定要提取嵌套数组的结构深度,默认值为 1。
    当然也可以使用Infinity,可展开任意深度的嵌套数组

    	let arr = [1, 2, [3, 4, [5, 6]]]
        let newArr = arr.flat(2)
        console.log(newArr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.10 arr.flatMap()

    使用映射函数映射每个元素,然后将结果压缩成一个新数组

    2.11 arr.forEach()

    对数组的每个元素执行一次给定的函数

    	let arr = [1, 2, 3, 4, 5]
        arr.forEach((item, index, a) => {
            a[index] = item + 1
        })
        console.log(arr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.12 arr.includes()

    方法用来判断一个数组是否包含一个指定的值,根据情况,如果包含则返回 true,否则返回false

    	let arr = ['cat', 'dog', 'bat'];
        console.log(arr.includes('cat'));
        console.log(arr.includes('at'));
    

    浏览器打印结果:
    在这里插入图片描述

    2.13 arr.indexOf()

    方法返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。

    2.13 arr.join()

    方法将一个数组(或一个类数组对象)的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目,那么将返回该项目而不使用分隔符。
    参数:separator 可选
    指定一个字符串来分隔数组的每个元素。如果需要,将分隔符转换为字符串。如果缺省该值,数组元素用逗号(,)分隔。如果separator是空字符串(""),则所有元素之间都没有任何字符。

    	let arr = ['cat', 'dog', 'bat'];
        let newStr = arr.join('*');
        console.log(newStr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.14 arr.keys()

    方法返回一个包含数组中每个索引键的Array Iterator对象。

    	let arr = ['cat', 'dog', 'bat'];
        let iterator = arr.keys()
        for (const key of iterator) {
            console.log(key);
        }
    

    浏览器打印如下:
    在这里插入图片描述

    2.15 arr.lastIndexOf()

    语法:arr.lastIndexOf(searchElement[, fromIndex])
    lastIndexOf() 方法返回指定元素(也即有效的 JavaScript 值或变量)在数组中的最后一个的索引,如果不存在则返回 -1。从数组的后面向前查找,从 fromIndex 处开始。

    2.16 arr.map()

    方法创建一个新数组,其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

    	let arr = [1, 2, 3, 4, 5]
        let arr1 = arr.map((item) => item + 1)
        console.log(arr1,arr);
    

    浏览器打印如下:
    在这里插入图片描述

    2.17 arr.pop()

    从数组中删除最后一个元素,并返回该元素的

    2.18 arr.push()

    将一个或多个元素添加到数组的末尾,并返回该数组的新长度

    2.18 arr.reduce()

    对数组中的每个元素执行一个由提供的reducer函数(升序执行),将其结果汇总为单个返回值

    	let arr = [1, 2, 3, 4, 5]
        let sum = arr.reduce((pre, cur) => pre + cur)
        console.log(sum);
    

    浏览器打印结果:
    在这里插入图片描述

    2.19 arr.reverse()

    将数组中元素的位置颠倒,并返回该数组。该方法会改变原数组

    2.20 arr.shift()

    从数组中删除第一个元素,并返回该元素的值

    2.21 arr.slice()

    方法返回一个新的数组对象,这一对象是一个由 begin 和 end 决定的原数组的浅拷贝(包括 begin,不包括end)。原始数组不会被改变。

    	let arr = ['a', 'b', 'c', 'd', 'e']
        let arr1 = arr.slice(1, 2)
        console.log(arr1, arr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.22 arr.some()

    方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。

    	let arr = ['a', 'b', 'c', 'd', 'e']
        let a = arr.some((item => item === 'b'))
        console.log(a);
    

    浏览器打印结果:
    在这里插入图片描述

    2.23 arr.sort()

    sort() 方法用原地算法对数组的元素进行排序,并返回数组。默认排序顺序是在将元素转换为字符串,然后比较它们的UTF-16代码单元值序列时构建的

    由于它取决于具体实现,因此无法保证排序的时间和空间复杂性。

    	let arr = [1, 8, 13, 2,0]
        let a = arr.sort((a, b) => a - b)
        console.log(a);
    

    浏览器打印结果:
    在这里插入图片描述

    2.23 arr.splice()

    通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容,此方法会改变原数组

    参数:

    start​
    指定修改的开始位置(从0计数)。如果超出了数组的长度,则从数组末尾开始添加内容;如果是负值,则表示从数组末位开始的第几位(从-1计数,这意味着-n是倒数第n个元素并且等价于array.length-n);如果负数的绝对值大于数组的长度,则表示开始位置为第0位。
    deleteCount 可选
    整数,表示要移除的数组元素的个数。
    如果 deleteCount 大于 start 之后的元素的总数,则从 start 后面的元素都将被删除(含第 start 位)。
    如果 deleteCount 被省略了,或者它的值大于等于array.length - start(也就是说,如果它大于或者等于start之后的所有元素的数量),那么start之后数组的所有元素都会被删除。
    如果 deleteCount 是 0 或者负数,则不移除元素。这种情况下,至少应添加一个新元素。
    item1, item2, … 可选
    要添加进数组的元素,从start 位置开始。如果不指定,则 splice() 将只删除数组元素。

    返回值:

    由被删除的元素组成的一个数组。如果只删除了一个元素,则返回只包含一个元素的数组。如果没有删除元素,则返回空数组。

    	let arr = [1, 8, 13, 2,0]
        arr.splice(1,2,10,10)
        console.log(arr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.24 arr.toLocaleString()

    toLocaleString() 返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串,这些字符串将使用一个特定语言环境的字符串(例如一个逗号 “,”)隔开。

    2.25 arr.toString()

    toString() 返回一个字符串,表示指定的数组及其元素。

    2.26 arr.unshift()

    unshift() 方法将一个或多个元素添加到数组的开头,并返回该数组的新长度(该方法修改原有数组)。

    	let arr = [1, 8, 13, 2, 0]
        let res = arr.unshift(1, 22)
        console.log(res, arr);
    

    浏览器打印结果:
    在这里插入图片描述

    2.26 arr.values()

    values() 方法返回一个新的 Array Iterator 对象,该对象包含数组每个索引的值

    let array1 = ['a', 'b', 'c'];
    let iterator = array1.values();
    for (const value of iterator) {
      console.log(value);
    }
    

    浏览器打印结果:
    在这里插入图片描述

    常用的数组API大概就是上面的这些了,碰到新的再继续总结。欢迎补充~

    展开全文
  • java-数组常用api

    2021-03-20 23:46:53
    Java 数组相关api数组array中的api 1.获取数组长度: arrays .length() 在Java中要求一个数组的长度是可以直接用length属性来获取的int []A = {1,2,3}; int len = A.length; 在Java中这种方式就可以直接获取到...

    Java 数组相关api
     数组array中的api
    1.获取数组长度: arrays .length()
    在Java中要求一个数组的长度是可以直接用length属性来获取的int []A = {1,2,3}; int len = A.length;
    在Java中这种方式就可以直接获取到数组的长度。值得注意的是,在Java中还有一个length()方法。这个方法是针对字符串而言的,只能用来求字符串长度。此外还有一个size()方法,是用来求泛型集合元素个数的。
    注意:Java和C++中都有length()和size()方法,这两种语言中的两个方法名字相同但用法却有区别。其中length()都是一样的,求字符串长度,而size()方法在Java中求的是泛型集合的元素个数,在C++中这两个方法作用是一样的。
    2.返回指定数组的元素以字符串的形式:arrays.toString();所以toSrting方法可以直接通过类名Arrays调用,可以提取目标数组所有元素,并按顺序转化为字符串
    System.out.println(Arrays.toString(newArr));
    for(var e:newArr)
    {
    System.out.print(e+" ");
    }
    输出:
    [1, 2, 4, 5, 6, 6, 5, 4, 7, 6, 7, 5]
    1 2 4 5 6 6 5 4 7 6 7 、
    3.数组也有对应的增强for语句,语法结构如下:
    for(声明变量 :数组名){

    }
    需要注意的是,必须新声明一个变量,使用声明过的变量是不可以的。
    //打印数组的所有元素
    for(int i : array){
    System.out.println(i) //i依次取数组array每一个元素的值
    }
    4.System.arraysCopy将源数组sourceArray从下标 index1开始共length个元素复制到数组copyArray之中,copyArray从下标index2开始依次存放复制过来的元素。
    需要注意的是,如果length超出了copyArray的长度就会发生异常。
    方法原型:
    public static void arraycopy(sourceArray, int index1, copyArray,int index2, int length)
    包含在System类里

    int a[]={1,2,3,4,5};
    int b[];
    int c[]={9,8,7,6,5,4,3,2,1};
    b=new int[5];
    System.arraycopy(a,0,b,0,a.length);
    System.arraycopy(a,1,c,0,3);//从下标1开始3个元素
    运行后
    b :[1, 2, 3, 4, 5]
    c :[2, 3, 4, 6, 5, 4, 3, 2, 1]
    5.arrays.copyOf数组方法:将数组a赋值到数组b中
    方法原型:
    public static 数组类型 copyOf(数组类型 sourceArray ,int newLength )
    包含在Arrays类中
    int[] a={1,2,3,4,5};
    int [] b=Arrays.copyOf(a,10);
    运行后 b: [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
    把源数组sourceArray从下标0开始的newLength个元素复制到一个新的数组中,并返回这个新数组,新数组的长度为newLength
    需要注意的是如果newLength大于sourceArray的长度,超出的元素取默认值。

    6.copyOfRange 数组方法:
    方法原型:
    public static(代表不用实例化) 数组类型 copyOfRang(数组类型 original,int from ,int to)
    包含在Arrays类中

    int[] a={1,2,3,4,5};
    int [] b=Arrays.copyOfRange(a,3,10);
    运行后 b :[4, 5, 0, 0, 0, 0, 0]
    把参数original指定的数组从下标0到下标(to-1)(数组original的第to个元素)
    复制到一个新的数组中,新数组长度为to-from。如果to的值大于数组数组original的长度,那么超出部分取默认值。
    7.sort:数组排序
    方法原型:
    public static void sort(数组类型 array)

    包含在Arrays类中,可以把数组array按升序排序

    方法原型:
    public static void sort(数组类型 array, int start, int end)

    包含在Arrays类中,可以把参数array中下标start至下标end-1的元素(第end个元素)按升序排序。
    int[] a={10,2,30,45,5};
    int [] b={9,4,6,20,11,12};
    Arrays.sort(a);
    Arrays.sort(b,0,3);
    运行之后:
    a :[2, 5, 10, 30, 45]
    b :[4, 6, 9, 20, 11, 12]
    8.binarySearch (二分查找)
    方法原型:
    public static int binarySearch(数组类型 array, 类型 target)
    包含在Arrays类中
    判断参数target指定的数据是否在参数array指定的数组当中,如果target和数组array中的某个元素相同,该方法就返回该元素的索引(下标),否则返回一个负数。
    需要注意的是array必须是已排序好的数组。

    int [] b={9,4,6,20,11,12};
    Arrays.sort(b);
    int x=Arrays.binarySearch(b,20);
    if(x>=0){
    System.out.println(x); //输出索引
    }

    展开全文
  • 数组常用API

    2020-07-26 21:51:10
     在我们学习数组中,经常会碰到需要使用数组API的地方,在恰巧的代码中使用数组API可以达到事半功倍的效果,下面我就来列举下我门经常使用到的数组API吧 连接和拼接 concat() 连接一个或多个数组 返回新数组 var ...

     在我们学习数组中,经常会碰到需要使用数组API的地方,在恰巧的代码中使用数组API可以达到事半功倍的效果,下面我就来列举下我门经常使用到的数组API吧

    连接和拼接

    concat() 连接一个或多个数组 返回新数组

    var myArr1 = [1,2,3];
    var myArr2 = [4,5,6];
    var myArr3 = [7,8,9];
     
    console.log(myArr1.concat(myArr2,myArr3));	//[1, 2, 3, 4, 5, 6, 7, 8, 9]
    

    join() 将数组元素拼接成字符串(参数接收拼接符)

    var arr1 = [1,2,3];
    console.log(arr1.join("到"));	//'1到2到3'--以'到'对arr1数组的元素进行拼接
     
    var arr2 = ['a','b','c'];
    console.log(arr2.join(''));    //'abc'--以空字符串为拼接符对arr2数组进行拼接
    

    反转和排序

    reverse() --将数组元素进行反转

    var arr = [1,2,3,4,5,'a'];
    console.log(arr.reverse());    //['a',5,4,3,2,1]
    

    sort()–数组元素排序(参数接收一个排序函数)

    var arr= [11,99,33,4,4,35,3,46,9];
        console.log(arr.sort((a,b)=>a-b);    //升序[3, 4, 4, 9, 11, 33, 35, 46, 99]
        console.log(arr.sort((a,b)=>b-a);    //降序[99, 46, 35, 33, 11, 9, 4, 4, 3]
    

    删除和添加

    push()–向数组的最后面添加元素(返回数组长度, 会改变原数组)

    //后插(返回数组长度,会改变原数组)
    var arr1 = [1,2,3];
    var arr2 = arr1.push(9,10,11);
    console.log(arr2);	//6(返回数组长度)
    console.log(arr1);	//改变原数组[1,2,3,9,10,11]
    

    pop()–删除数组的最后面的元素(返回被删除的元素)

    //后删(返回被删除的元素,会改变原数组)
    var arr1 = [1,2,3,4,5];
    var arr2 = arr1.pop();
    console.log(arr2);	//5(返回被删除的元素)
    console.log(arr1);	//[1,2,3,4]
    

    unshift()–在数组的最前面插入元素(返回数组长度, 会改变原数组)

    //前插(返回数组长度, 会改变原数组)
    var arr1 = [1,2,3,4,5];
    var arr2= arr1.unshift(0,'a','b');
    console.log(arr2);	//8(返回新数组长度)
    console.log(arr1);	//[0, 'a', 'b', 1, 2, 3, 4, 5]
    

    shift()–删除数组的最前面的元素(返回被删除的元素)

    //前删--返回被删除的元素,会改变原数组
    var arr1 = [1,2,3,4,5];
    var arr2= arr1.shift();
    console.log(arr2);    //1(返回被删除的元素)
    console.log(arr1);    //[2,3,4,5]
    

    增删改查四合一

    splice()法始终会返回一个数组,该数组包含从原始数组中删除的项
    如果没有删除任何项,则返回一个空数组)

    //删除:需指定2个参数,要删除的第一项位置和要删除的项数
    var colors = ['red','green','blue'];
    var removed = colors.splice(0,1);//位置下标,删除个数
    console.log(colors);      //green,blue
    console.log(removed);     //red//返回被删除数据的数组
    
    //插入:需提供3个参数,起始位置、0(要删除的项数)和要插入的项,如要插入多个项
    // ,再传入第四,五...
    var removed = colors.splice(1,0,'black');//位置下标,删除个数,插入数据
    console.log(colors);     //green,black,blue
    console.log(removed);    // 返回空数组
    
    //替换:需指定3个参数,起始位置、要删除的项数和要插入的任意数量的项
    var removed = colors.splice(0,2,'yellow','white');//位置下标,删除个数,插入数据
    console.log(colors);     //yellow,white,blue
    console.log(removed);    //red,green
    

    截取数组

    slice()含头不含尾 返回值为截取之后的数组

    var arr=[1,2,3];
    var newArr=arr.slice(0,2);
    console.log(newArr); //[1,2]
    console.log(arr); //[1,2,3]
    
    

    重新包装数组

    map()对元素重新组装,返回值生成新数组

    var arr = [1,2,3,5]
    var arr2= arr.map(function(item,index){
        // 将元素重新组装并返回
        return '<b>'+item+'</b>'
    })
    
    console.log(arr2)//["<b>1</b>", "<b>2</b>", "<b>3</b>", "<b>5</b>"]
    

    过滤数组

    filter()过滤符合条件的元素 返回过滤后的数组

    var arr = [1,2,3,5]
    var arr2= arr.filter(function(item,index){
        // 通过某个条件过滤数组
        if(item>2){
          return true
       }
    })
    
    console.log(arr2)
    
    展开全文
  • 静态方法: Array.of(…args): 使用指定的数组项创建一个新数组 Array.from(arg): 通过给定的类数组 或 可迭代对象 创建...其他api按具体作用分为: 一、添加 1、push() 方法将一个或多个元素添加到数组的末尾,并返回数

    静态方法:

    Array.of(…args): 使用指定的数组项创建一个新数组
    Array.from(arg): 通过给定的类数组 或 可迭代对象 创建一个新的数组。
    
    const arr = Array.of(5);//值为5,length为1
    const arr1 = new Array(10);//length为10的空数组
    console.log(arr);
    console.log(arr1);
    
    

    其他api按具体作用分为:

    一、添加

    1、push() 方法将一个或多个元素添加到数组的末尾,并返回数组的新长度。

    2、unshift() 方法将一个或多个元素添加到数组的开头,并返回新数组的长度。

    二、删除

    1、pop()方法从数组中删除最后一个元素,并返回该元素的值。此方法更改数组的长度。

    2、shift() 方法从数组中删除第一个元素,并返回该元素的值。此方法更改数组的长度。
    三、操作

    1、concat() 方法用于合并两个或多个数组。此方法不会更改现有数组,而是返回一个新数组。

    var color = [‘red’,‘green’,‘blue’];
    var color2 = color.concat(‘yellow’,[‘black’,‘white’]);
    console.log(color2) //red,green,blue,yellow,black,white

    2、slice()方法返回一个从开始到结束(不包括结束)选择的数组的一部分浅拷贝到一个新数组对象,原始数组不会被修改。

    var colors = [‘red’,‘green’,‘blue’,‘black’,‘white’];
    var colors2 = colors.slice(1) //green,blue,black,white
    var colors3 = colors.slice(1,4) //green,blue,black

    3、splice()方法始终会返回一个数组,该数组包含从原始数组中删除的项(如果没有删除任何项,则返回一个空数组),用途最广,有如下3种

    删除:需指定2个参数,要删除的第一项位置和要删除的项数
    插入:需提供3个参数,起始位置、0(要删除的项数)和要插入的项,如要插入多个项 ,再传入第四,五...
    替换:需指定3个参数,起始位置、要删除的项数和要插入的任意数量的项
    

    var colors = [‘red’,‘green’,‘blue’];
    var removed = colors.splice(0,1);
    console.log(colors); //green,blue
    console.log(removed); //red

    var removed = colors.splice(1,0,‘black’);
    console.log(colors); //green,black,blue
    console.log(removed); // 返回空数组

    var removed = colors.splice(0,2,‘yellow’,‘white’);
    console.log(colors); //yellow,white,blue
    console.log(removed); //red,green

    四、位置方法

    indexOf()方法从数组的开头(位置0)开始向后查找,

    lastIndexOf()方法从数组的末尾开始向前查找,

    这两个方法都接收两个参数:要查找的项和(可选的)表示查找起点位置的索引,没找到返回-1
    五、重排序方法

    sort()方法按升序排列数组项–即最小的值位于最前面,最大的值排在后面。

    reverse()降序排列;

    注意:如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点,首先应把数组的元素都转换成字符串(如有必要),以便进行比较,再接收一个比较函数作为参数,以便我们指定哪个值位于哪个值的前面;

    function compare(val1,val2) {

    if(val1 < val2){
        return -1;
    }else if(val1 > val2){
        return 1;
    }else {
        return 0
    }
    

    }
    var val = [0,1,35,2,18];
    console.log(val.sort(compare)); // 0,1,2,18,35
    console.log(val.reverse(compare)); //35,18,2,1,0

    console.log(val.sort()); // 0,1,18,2,35
    console.log(val.reverse()); //35,2,18,1,0

    六、迭代方法

    1、forEach(),对数组的每一项运行给定函数,这个方法没有返回值。本质上与使用for循环迭代数组是一样的

    2、map() 创建一个新数组,其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
    七、转换方法

    1、toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串

    2、valueOf()返回的还是数组

    3、toLocaleString()方法也会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串

    区别:

    var date = new Date();
    console.log(date.valueOf()); //1524815456865
    console.log(date.toString()); //Fri Apr 27 2018 15:50:56 GMT+0800 (CST)
    console.log(date.toLocaleString()); //2018/4/27 下午3:50:56

    var num = new Number(1337);
    console.log(num.valueOf()); //1337,返回一个 Number 对象的基本数字值
    console.log(num.toString()); //1337,字符串
    console.log(num.toLocaleString()); //1,337,把数字转换为字符串,使用本地数字格式顺序

    注意:

    toLocalString()是调用每个数组元素的 toLocaleString() 方法,然后使用地区特定的分隔符把生成的字符串连接起来,形成一个字符串。
    
    toString()方法获取的是String(传统字符串),而toLocaleString()方法获取的是LocaleString(本地环境字符串)。
    
    如果你开发的脚本在世界范围都有人使用,那么将对象转换成字符串时请使用toString()方法来完成。
    
    LocaleString()会根据你机器的本地环境来返回字符串,它和toString()返回的值在不同的本地环境下使用的符号会有微妙的变化。
    
    所以使用toString()是保险的,返回唯一值的方法,它不会因为本地环境的改变而发生变化。如果是为了返回时间类型的数据,推荐使用LocaleString()。若是在后台处理字符串,请务必使用toString()。
    
    展开全文
  • js中数组常用api汇总

    2020-07-06 19:06:31
    js中数组常用api汇总 在此对js中数组常用的api进行汇总。 1.检测数组:判断value是否为数组类型 Array.isArray(value); 2.转换方法:将数组colors转化成以逗号分隔的字符串 alert(colors.toString()); 3.栈、队列...
  • Java 数组常用API

    2020-12-25 16:29:00
    Arrays.toString(数组类型 数组名): 可以放8种基本数据类型数组和对象数组, 返回指定数组的内容, 是字符串类型; int[] a = {1,2,3}; String s = Arrays.toString(int[] a); System.out.println(s); binarySearch...
  • JS数组常用API

    2019-12-15 11:52:37
    对数组的一些补充: 二维数组:就是一个数组里面再去嵌套一个数组或几个数组 二维数组的创建方式: var arr = [[1,2],[3,4]…]; 读取二维数组的数据:数组名.[ 行 ] [ 列 ];...数组常用API: 1、String(数组名...
  • 数组常用 API

    2018-07-20 03:24:55
    数组常用 api 介绍 split():拆分字符串变成数组(对字符串操作) join() :合并数组变成字符串(对数组操作) concat():连接两数组 splice(begin,deleteCount,insert):拼接 splic(begin,end):截取[begin,end) ...
  • 数组常用API操作 arr.reduce() var arr = [1,2,3,4,5]; var reduceArr = arr.reduce(function(pre,cur,index,array){ return prev + cur; }) arr.filter(callback)数组过滤,返回满足条件的元素组成的一个新数组 arr...
  • 数组常用API整理

    2020-07-05 21:56:49
    2.arr.toString() // 返回数组内容的字符串表示形式 const arr = [1, 2, 3, 4, 56, 6]; console.log(arr.toString()); //1,2,3,4,56,6 3.String(arr) // 将数组中每个元素转为字符串,并用逗号连接。 const arr ...
  • 数组常用api

    2020-03-18 15:19:28
    数组常用api 1、splite(' ')可以将字符串按某个字符或者其他分割。返回数组。 2、reverse()该方法会改变原来的数组,而不会创建新的数组。此函数可以将数组倒序排列。 3、join()方法用于把数组中的所有元素放入一...
  • JS 数组常用API

    2020-12-07 19:09:18
    JS 数组常用API arr.filter(callback):数组过滤,返回满足条件的元素组成的一个新数组 arr.map(callback):对数组每一项进行计算处理,返回一个新数组 arr.some(function(item,index,array){}):依次执行数组元素,...
  • JavaScript之数组常用API

    2019-12-14 23:33:30
    API(Application Programming Interface,应用程序编程接口)是一套用来控制Windows的各个部件(从桌面的外观到为一个新进程分配的内存)的外观和行为的一套预先定义的Windows函数.用户的每个动作都会引发一个或几个函数...
  • 不改变原数组 1、join()方法——把数组中的所有元素放入一个字符串 把数组中的所有元素放入一个字符串: join()——默认每个元素中之间是逗号隔开 join("-")——每个元素之间以 - 隔开 var arr=[1,2,3]; var...
  • push() 方法将一个或多个元素添加到数组的末尾,并返回该数组的新长度。 更改原数组 参数 elementN 被添加到数组末尾的元素。 返回值 当调用该方法时,新的 length 属性值将被返回。 示例 //添加元素到数组...
  • 数组 什么是数组数组是一种特殊变量,可以存放一个至多个值;并且可以引用索引访问它们。 创建数组的方法: // 这是第一种方法 var arr = [ 1 , "字符串" , true , undefined ];//值与值之间用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,799
精华内容 73,519
关键字:

数组常用api