js数组Array

js数组Array

JavaScript 中的数组是一种特殊的对象，用来表示偏移量的索引是该对象的属性

在脚本语言里很常见的一个特性是，数组中的元素不必是同一种数据类型

一般方法

indexOf(),lastIndexOf()

indexOf() 函数是最常用的存取函数之一，用来查找传进来的参数在目标数组中是否存在。如果目标数组包含该参数，就返回该元素在数组中的索引；如果不包含，就返回 -1

如果数组中包含多个相同的元素， indexOf() 函数总是返回第一个与参数相同的元素的索引。有另外一个功能与之类似的函数： lastIndexOf() ，该函数返回相同元素中最后一个元素的索引，如果没找到相同元素，则返回 -1

join(),toString()

有两个方法可以将数组转化为字符串： 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

​ join()有一个参数，确定分隔符，默认是，

concat(),splice(),slice（）

concat() 方法的工作原理。该方法的发起者是一个数组，参数是另一个（或多个）数组。作为参数的数组，其中的所有元素都被连接到调用 concat() 方法的数组后面

var cisDept = ["Mike", "Clayton", "Terrill", "Danny", "Jennifer"];
var dmpDept = ["Raymond", "Cynthia", "Bryan"];
var itDiv = cisDept.concat(dmpDept);
print(itDiv);
itDiv = cisDept.concat(cisDept);
print(itDiv);
//Mike,Clayton,Terrill,Danny,Jennifer,Raymond,Cynthia,Bryan
//Raymond,Cynthia,Bryan,Mike,Clayton,Terrill,Danny,Jennifer

splice() 方法从现有数组里删除元素。该方法的第一个参数是截取的起始索引，第二个参数是截取的长度

splice()还可以添加元素,splice(元素添加后的索引，删除的元素个数，…)

nums = [1,2,3,4,5,6]
nums.splice(2,2,'a','b')
//[1,2,'a','b',5,6]

Array.slice() 方法从数组中返回选定的元素，作为一个新数组。

const fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
const citrus = fruits.slice(1, 3);
//原理
function slice(start, end) { 
    var startToUse = start || 0, 
        endToUse = end || ToUint32(this.length), 
        result = []; 
    for(var i = startToUse; i < endToUse; i++) { 
        result.push(this[i]); 
    }
    return result; 
}

push(),unshift()

push在末尾添加，unshift在开头添加

pop()，shift()

pop删除末尾，shift删除开头

pop() 和 shift() 方法都将删掉的元素作为方法的返回值返回，因此可以使用一个变量来保存删除的元素

reverse()

翻转

sort()

默认排序顺序是根据字符串UniCode码

var names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];
names.sort();
print(names); // Bryan,Clayton,Cynthia,David,Mike,Raymond

如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b。

返回负的值，小的排前面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s3cb05xG-1653379021785)(https://lms-1307517629.cos.ap-guangzhou.myqcloud.com/typera/image-20211003145233563.png “null”)]

image-20211003145233563

迭代器方法

不生成新数组

forEach(function)

function 是function(value,[index],[array])

该方法接受一个函数作为参数，对数组中的每个元素使用该函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oabfzd4u-1653379021787)(https://lms-1307517629.cos.ap-guangzhou.myqcloud.com/typera/image-20211028180311078.png “null”)]

image-20211028180311078

a.forEach(i=>i = 1)//这样是无效的
a.forEach((i,index)=>a[index] = 1)//这样写才有效
或者var b = a.map(i=>)
应该用a = new Array().fill()新建数组才可以

every()

该方法接受一个返回值为布尔类型的函数，对数组中的每个元素使用该函数。如果对于所有的元素，该函数均返回 true ，则该方法返回 true

function isEven(num) {
    return num % 2 == 0;
}
var nums = [2,4,6,8,10];
var even = nums.every(isEven);
if (even) {
    print("all numbers are even");
}
else {
    print("not all numbers are even");
}
//all numbers are even

some()

方法也接受一个返回值为布尔类型的函数，只要有一个元素使得该函数返回 true ，该方法就返回 true

reduce(), reduceRight()

reduce会从一个累加值开始，不断对累加值和数组中的后续元素调用该函数，直到数组中的最后一个元素，最后返回得到的累加值

function add(runningTotal, currentValue) {
    return runningTotal + currentValue;
}
var nums = [1,2,3,4,5,6,7,8,9,10];
var sum = nums.reduce(add);
print(sum); // 显示 55

arr.reduce((a,b)=>a>b? a:b)//求最大
arr.reduce((a,b)=>a<b? a:b)//求最小
arr.reduce((a,b)=>a+b)//求和
arr.reduce((a,b)=>a*b)//求积

var num = [1,2,3,4,5];
var res = num.reduce(function(returnValue,everyNum){
    return returnValue+everyNum;
    //return returnValue + Math.round(everyNum);//对数组元素四舍五入并计算总和
},0);
console.log(res)；//15
//num.reduce((total,num) => total += num, 0);
//没有初始值initialValue（即上面例子中的0），当数组为0时会抛出异常提示reduce函数没有初始值，所以为兼容性一般加上initialValue

var arr = ["apple","orange","apple","orange","pear","orange"];
function getWordCnt(){
  return arr.reduce(function(prev,next){
    prev[next] = (prev[next] + 1) || 1;
    return prev;
  },{});
}
console.log(getWordCnt());
VM3704:14 {apple: 2, orange: 3, pear: 1}
当没有传入初始值时，prev是从数组中第一个元素开始的，next数组是第二个元素。
但是当传入初始值（initiaValue）后,第一个prev将是initivalValue，next将是数组中的第一个元素。
```

reduceRight()从最右边开始

#### 生成新数组

#### map()

与forEach()的区别是 map() 返回一个新的数组，该数组的元素是对原有元素应用某个函数得到的结果

#### filter()

和 every() 类似，传入一个返回值为布尔类型的函数。和 every() 方法不同的是，当对数组中的所有元素应用该函数，结果均为 true 时，该方法并不返回 true ，而是返回一个新数组，该数组包含应用该函数后结果为 true 的元素

```
//语法
a.filter((p)=>p>1)
```

### 特性

> 当把一个数组赋给另外一个数组时，只是为被赋值的数组增加了一个新的引用。当你通过原引用修改了数组的值，另外一个引用也会感知到这个变化。下面的代码展示了这种情况：

```
var nums = [];
for (var i = 0; i < 100; ++i) {
nums[i] = i+1;
}
var samenums = nums;
nums[0] = 400;
print(samenums[0]); // 显示 400
```

> 这种行为被称为浅复制，新数组依然指向原来的数组。一个更好的方案是使用深复制，将原数组中的每一个元素都复制一份到新数组中。可以写一个深复制函数来做这件事：

```
function copy(arr1, arr2) {
for (var i = 0; i < arr1.length; ++i) {
arr2[i] = arr1[i];
}
}
```