一、javascript中创建数组的方式

（1）使用 array构造函数：

var arr1 = new array();
     //创建一个空数组
var arr2 = new array(15);
     // 创建一个长度为15的数组
var a = new array([15]);
     //指创建一个数组，长度为1，并且第一位是15
var arr3 = new array("sf","zs","zsf");
     // 创建一个包含3个字符串的数组

（2）使用数组字面量表示法：

var arr4 = [];
     //创建一个空数组
var arr5 = [15];
     // 创建一个数组，长度为1，包含‘15'数字
var arr6 = ["sf","zs","zsf"];
     // 创建一个包含3个字符串的数组

二、数组方法概括

数组的方法我们一般以是否会改变原数组进行区分

使用以下方法会改变原数据

使用以下方法不会改变原数据

三、方法详解

1、pop()

pop()：数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项

ar arr = [1,2,3];
    
console.log(arr.pop());
         //3
console.log(arr);
               //[1,2]---原数组改变

2、shift()

功能：方法用于删除并返回数组的第一个元素。

var arr = [1,2,3]
console.log(arr.shift());
           //1
console.log(arr);
                   //[2,3]---原数组改变

3、push()

功能：向数组的末尾添加一个或更多元素，并返回新的长度。

var arr = [1,2,3];
    
console.log(arr.push("hello"));
      //4
console.log(arr);
                    //[1,2,3,"hello"]---原数组改变
console.log(arr.push("a","b"));
      //6
console.log(arr);
                    //[1,2,3,"hello","a","b"]---原数组改变

4、unshift()

功能：向数组的开头添加一个或更多元素，并返回新的长度。

var arr = [1,2,3];
    
console.log(arr.unshift("hello"));
      //4
console.log(arr);
                       //["hello",1,2,3]---原数组改变
console.log(arr.unshift("a","b"));
      //6
console.log(arr);
                       //["a","b","hello",1,2,3]---原数组改变

5、sort()

功能：对数组中的元素进行排序，默认是升序。

var arr = [6,1,5,2,3];
    
console.log(arr.sort());
        //[1, 2, 3, 5, 6]
console.log(arr);
               //[1, 2, 3, 5, 6]---原数组改变

注意：sort默认把所有元素先转换为string再排序，而字符串根据ascii码进行排序

// 案例一：看上去正常的结果
['google', 'apple', 'microsoft'].sort();
     // ['apple', 'google', 'microsoft'];
    

// 案例二：apple排在了最后
['google', 'apple', 'microsoft'].sort();
     // ['google', 'microsoft", 'apple']

// 案例三：无法理解的结果
[10, 20, 1, 2].sort();
     // [1, 10, 2, 20]

我们可以看到案例二和案例三，就会发现直接使用sort()没有办法排序复杂的数组

因此我们可以如下使用它

var arr = [10, 20, 1, 2];
    
arr.sort((x, y)=>
 {

	if (x  y) {
    
		return -1;

	}
    
	if (x >
 y) {
    
		return 1;

	}
    
	return 0;

}
    );
    
console.log(arr);
     // [1, 2, 10, 20]

6、reverse()

功能: 反转数组项的顺序。

var arr = [13, 24, 51, 3];
    
console.log(arr.reverse());
     //[3, 51, 24, 13]
console.log(arr);
     //[3, 51, 24, 13](原数组改变)

7、splice()

功能：很强大的数组方法，它有很多种用法，可以实现删除、插入和替换。

array.splice(index, howmany, item1, ....., itemx)

• index:必需。整数，指定在什么位置添加/删除项目，使用负值指定从数组末尾开始的位置
• howmany:可选。要删除的项目数。如果设置为 0，则不会删除任何项目。
• item1, …, itemx:可选。要添加到数组中的新项目。

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

var arr = [1,3,5,7,9,11];
    
var arrremoved = arr.splice(0,2);
    
console.log(arr);
     //[5, 7, 9, 11]
console.log(arrremoved);
     //[1, 3]
var arrremoved2 = arr.splice(2,0,4,6);
    
console.log(arr);
     // [5, 7, 4, 6, 9, 11]
console.log(arrremoved2);
     // []
var arrremoved3 = arr.splice(1,1,2,4);
    
console.log(arr);
     // [5, 2, 4, 4, 6, 9, 11]
console.log(arrremoved3);
     //[7]

1、join()

功能：根据指定分隔符将数组中的所有元素放入一个字符串，并返回这个字符串。
参数：join(str); 参数可选，默认为","号，以传入的字符作为分隔符。

var arr = [1,2,3];
    
console.log(arr.join());
             //1,2,3
console.log(arr.join("-"));
      //1-2-3

通过join()方法可以实现重复字符串，只需传入字符串以及重复的次数，就能返回重复后的字符串，函数如下：

function repeatstring(str, n) {
    
	return new array(n + 1).join(str);

}
    
console.log(repeatstring("abc", 3));
     // abcabcabc
console.log(repeatstring("hi", 5));
     // hihihihihi

2、concat()

功能: 将参数添加到原数组中。这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。

const arr1 = [1,2,3];
    
const arr2 = [4,5,6];
    
const arr3 = arr1.concat(arr2);
    
console.log(arr3);
      //[1,2,3,4,5,6]

3、slice()

功能: 返回从原数组中指定开始下标到结束下标之间的项组成的新数组。

array.slice(start, end)

slice()方法可以接受一或两个参数，即要返回项的起始(start)和结束位置(end)。

• 在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
• 如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。
• 如果start > end 的索引的话，则返回空数组

var arr = [1,3,5,7,9,11];
    
var arrcopy1 = arr.slice(1);
    
var arrcopy2 = arr.slice(1,4);
    
var arrcopy3 = arr.slice(1,-2);
    
var arrcopy4 = arr.slice(-4,-1);
    
console.log(arr);
     //[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrcopy1);
     //[3, 5, 7, 9, 11]
console.log(arrcopy2);
     //[3, 5, 7]
console.log(arrcopy3);
     //[3, 5, 7]
console.log(arrcopy4);
     //[5, 7, 9]

4、tostring()

功能：转换成字符串，类似于没有参数的join()。该方法会在数据发生隐式类型转换时被自动调用，如果手动调用，就是直接转为字符串。

var arr = [1,2,3];
    
console.log(arr.tostring());
         //1,2,3
console.log(arr);
                    //[1,2,3]---原数组未改变

5、valueof()

功能：返回数组的原始值（一般情况下其实就是数组自身），一般由js在后台调用，并不显式的出现在代码中

var arr = [1,2,3];
    
console.log(arr.valueof());
             //[1,2,3]
console.log(arr);
                       //[1,2,3]
//为了证明返回的是数组自身
console.log(arr.valueof() == arr);
      //true

6、indexof()

功能：根据指定的数据，从左向右，查询在数组中出现的位置，如果不存在指定的数据，返回-1。该方法是查询方法，不会对数组产生改变。

indexof(value, start);

• value：要查询的数据；
• start：可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1

var arr = ["h","e","l","l","o"];
    
console.log(arr.indexof("l"));
            //2
console.log(arr.indexof("l",3));
          //3
console.log(arr.indexof("l",4));
          //-1
console.log(arr.indexof("l",-1));
         //-1
console.log(arr.indexof("l",-3));
         //2

7、lastindexof()

功能：根据指定的数据，从右向左，查询在数组中出现的位置，如果不存在指定的数据，返回-1。该方法是查询方法，不会对数组产生改变。

lastindexof(value, start);

• value：要查询的数据；
• start：可选，表示开始查询的位置，当start为负数时，从数组的尾部向前数；如果查询不到value的存在，则方法返回-1

var arr = ["h","e","l","l","o"];
    
console.log(arr.lastindexof("l"));
            //3
console.log(arr.lastindexof("l",3));
          //3
console.log(arr.lastindexof("l",1));
          //-1
console.log(arr.lastindexof("l",-3));
         //2
console.log(arr.lastindexof("l",-4));
         //-1

8、foreach()

功能：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。

参数: 都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

var arr = [1, 2, 3, 4, 5];
    
arr.foreach((item, index, a)=>
{
    
	console.log(item + '|' + index + '|' + (a === arr));

}
    );
    
// 输出为：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true

9、map()

功能：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

如果你想要数组里的每一个值都发生变化就使用map

 let arr = [10, 30, 50, 60, 120, 230, 340, 450]
 let newarr = arr.map(item =>
 {

     return item * 2
 }
    )
 console.log(newarr);
     //[20, 60, 100, 120, 240, 460, 680, 900]
 console.log(arr);
     //[10, 30, 50, 60, 120, 230, 340, 450]

10、filter()

功能: 过滤，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。

//过滤出索引为3的倍数 或者 值大于8的元素
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
var arr2 = arr.filter((item, index) =>
 {
     
	return index % 3 === 0 || item >
    = 8;
 
}
    );
     
console.log(arr2);
     //[1, 4, 7, 8, 9, 10]

11、every()

功能：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

var arr = [1, 2, 3, 4, 5];
    
var arr2 = arr.every((x)=>
 {
    
	return x  10;

}
    );
     
console.log(arr2);
     //true
var arr3 = arr.every((x) =>
 {
    
	return x  3;

}
    );
     
console.log(arr3);
     // false

12、some()

功能: 判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

var arr = [1, 2, 3, 4, 5];
    
var arr2 = arr.some((x)=>
 {
    
	return x  3;

}
    );
     
console.log(arr2);
     //true
var arr3 = arr.some((x)=>
 {
    
	return x  1;

}
    );
     
console.log(arr3);
     // false

13、reduce()

功能：从数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值。

array.reduce(function(total, currentvalue, currentindex, arr), initialvalue)

参数：

• total是当前聚合值即合并的值，他可以是任何类型
• currentvalue是数组循环时的当前元素
• currentindex 是数组元素的索引值
• arr是数组本身
• initialvalue传递给函数的初始值

一般常用的是前面的两个参数,后面两个参数不常用,常用的使用场景便是数组的求和

 // 作用:对数组中所有的内容进行汇总   要传至少两个值
 let arr = [10, 30, 50, 60, 120, 230, 340, 450]
 let newarr = arr.reduce((pre, n) =>
 {

     return pre + n
 }
    , 0)
 console.log(newarr);
    

14、reduceright()

功能：（与reduce类似）从数组的最后一项开始，向前逐个遍历到第一位，迭代数组的所有项，然后构建一个最终返回的值。

array.reduceright(function(total, currentvalue, currentindex, arr), initialvalue)

参数：同reduce。

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

var sum = arr.reduceright(function(pre, cur, index, array){
    
	return pre + cur;

}
    ,10);
    
console.log(sum);
     //25

15、findindex()

功能: 返回数组中满足提供的测试函数的第一个元素的索引。若没有则返回-1。

let arr = [10, 2, 9, 17, 22];
    
let index = arr.findindex((item) =>
     item >
     13)
console.log(index);
      // 3

四、实战

一些算法我们可以使用此方法实现，此处我只写一些简单可实现的方法

4.1、实现数组排序（升序 || 降序）

我们使用sort搭配reverse可以快速实现排序，但是我们也可以使用冒泡排序、快速排序等方法

sort的原理本身就是冒泡排序的一种写法

升序

var arr = [6,1,5,2,3];
    
console.log(arr.sort());
        //[1, 2, 3, 5, 6]

降序

var arr = [6,1,5,2,3];
    
console.log(arr.sort((a,b)=>
{
return b - a}
    ));
    //[6,5,4,3,2,1]

降序

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

4.2、数组去重

适用indexof和push实现

function uniquearray(arr) {
    
	var temp = [];
    
	for (var i = 0;
     i  arr.length;
 i++) {

		if (temp.indexof(arr[i]) == -1) {
    
			temp.push(arr[i]);

		}

	}
    
	return temp;

}
    

使用filter去重

var r = [],
arr = ['apple', 'strawberry', 'banana', 'pear', 'apple', 'orange', 'orange', 'strawberry'];

r = arr.filter(function (element, index, self) {
    
  return self.indexof(element) === index;

}
    );

consolo.log(r)//['apple', 'strawberry', 'banana', 'pear', 'orange']

使用reduce实现数组对象去重

//数组重名去重
var resources = [
  {
 name: "张三", age: "18" }
,
  {
 name: "张三", age: "19" }
,
  {
 name: "张三", age: "20" }
,
  {
 name: "李四", age: "19" }
,
  {
 name: "王五", age: "20" }
,
  {
 name: "赵六", age: "21" }

]
var temp = {
}
    ;
    
resources = resources.reduce((prev, curv) =>
 {

  if (!temp[curv.name]) {
    // 如果临时对象没有就把这个名字加进去，同时把当前的这个对象加入到prev中
  	temp[curv.name] = true;
    
    prev.push(curv);

  }

	return prev
}
    , []);
    
console.log(resources);

//[
//  {
 name: "张三", age: "18" }
,
//  {
 name: "李四", age: "19" }
,
//  {
 name: "王五", age: "20" }
,
//  {
 name: "赵六", age: "21" }
    
//]

4.3、找数组元素

数组中重复次数最多的一个元素

var arr = [1,1,1,2,2,2,2,2,2,2,3,3,3,4,4,5,6,7,7,8];
    
var maxnum = 0;
    
var maxname = "";

var obj = {
}
    ;
    
arr.foreach((ele,index)=>
{
    
	obj[ele] ? obj[ele] += 1 : obj[ele] = 1;

}
)
for(let r in obj) {
    
	if(obj[r]>
maxnum){

		maxnum = obj[r]
		maxname = r
	}

}


console.log(`最多重复的数${
maxname}
,重复次数为:${
maxnum}
    `) //最多重复的数2,重复次数为:7

更多关于js创建数组，js数组排序，js查找数组的知识请相看下面的相关链接

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！