数组
一.数组的概念及作用
- 概念：数据的集合
- 作用：用于存放数据(设计合理的数所结构，有利于程序算法实现和逻辑处理)
二.数组的声明
- 字面量方式：
var arr=[];
- 构造函数方式：
var arr=new Array();
两中方式，如果只有一个值，这个值如果是一个number类型的数字
构造函数表示长度
字面量表示元素
三.数组的基本操作
- 数组的元素添加
var arr = [1,2,,5];
arr[arr.length] = 3;//在数组的最后，增加一个元素
//arr[100] = 100;//下标超出原来来的范围，length会自动增加
console.log(arr);
- 数组的索引
数组元素的下标是从0开始
- 数组的length属性
最后一个元素下标 = length-1;
获取数组的最后一个元素：
var lastIndex = arr.length-1;
console.log(arr[lastIndex]);
- 数组元素的增删改查
1.元素查找:arr[index];
var arr = [1,2,,5];
console.log( arr[arr.length-1]);//最后一个元素的查找
console.log(arr[22]);//查找不存在 的下标:返回undefined
2.元素修改
arr[0] = 8;
3.删除元素
delete arr[0];
4.清空数组
arr.length = 0;
- 数组的遍历
for in遍历数组
var arr = [1,2,3,7,54,6,8];
for(var key in arr){//for in遍历数组得到的下标为字符串
//console.log(typeof key);
console.log(arr[key]);
}
四.二维数组
- 概念
数组中的元素是由一维数组构成，这样的数组就是二维数组
- 元素添加
var brr = [[1, 2, 3],[3,56,7],[4,8,9]];
brr[brr.length]=[1,2,6]
console.log(brr);
- 遍历
var brr = [[1,2,3],[4,5,6],[7,8,9]];
for (var i = 0; i < brr.length; i++) {
//console.log(brr[i])
for(var j = 0; j < brr[i].length; j++){
console.log(brr[i][j]);
}
}
五.数组方法
改变元素组
1,arr.push(ele,ele2,ele3…);
//在arr的最后添加一个或多个元素，返回新数组的长度，改变原数组
在arr的最后添加一个或多个元素，返回新数组的长度，改变原数组
var arr = [1,2];
var m = arr.push(3,4,5);
console.log("原数组：",arr,"返回值:" + m);
2. arr.pop();
//删除arr的最后一个元素，返回删除的这个元素
var arr = [1,2];
var num = arr.pop();
console.log("原数组：",arr,"返回值:" + num);
3.arr.unshift(ele,ele2,ele…);
//在arr的最开头添加一个或多个元素，返回新数组的
长度，改变原数组
var arr = [1,2];
var m = arr.unshift("a","b");
console.log("原数组：",arr,"返回值:" + m);
4.arr.shift();
//删除arr的第一个元素，返回删除的这个元素
var arr = [1,2];
var num = arr.shift();
console.log("原数组：",arr,"返回值:" + num);
5.arr.splice(index);
//从index位置开始向后截取arr，截取的所有元素组成 新的一个数组返回，
1. var arr = [4,5,6,3,7,8,8];
var newArr = arr.splice(2);
console.log(arr,newArr);
2.var arr = [4,5,6,3,7,8,8];
var newArr = arr.splice(-2);//下标从最后开始数，最后一个元素的下标是-1
console.log(arr,newArr);
3. var arr = [4,5,6,3,7,8,8];
var newArr = arr.splice(100);//下标不存在 ，返回空数组
console.log(arr,newArr);
6.arr.splice(index,num);
//从index位置开始向后截取arr，截取的num个元素，组成 新的一个数组返回，
1. var arr = [4,5,6,3,7,8,8];
var newArr = arr.splice(3,2);
console.log(arr,newArr);
2. var arr = [4,5,6,3,7,8,8];
var newArr = arr.splice(3,-2);//返回空数组
console.log(arr,newArr);
7.arr.splice(index,num,ele1,ele2,ele3…);
从index位置开始向后截取arr，截取的num个元素，组成 新的一个数组返回，并且从index位置开始，插入ele1,ele2,ele3…这些元素，
var arr = [4,5,6,3,7,8,8];
var newArr = arr.splice(2,1,"a","b");
console.log(arr,newArr);
8.reverse();
//将原数组倒序排列，返回排序后的新数组
var arr = [4,5,6,3,7,8,8];
var newArr = arr.reverse();
console.log(arr,newArr);
不改变元素组
1.arr.slice();
//将原来的数组的元素替换，返回新的数组。不是一种复制
var arr = [4,5,6,3,7,8,8];
var newArr = arr.slice();
newArr[0] = "aaaa";
console.log(arr,newArr);
2.arr.slice(index);
//从index位置开始向后截取arr，截取的所有元素组成 新的一个数组返回，不改变原数组
var arr = [4,5,6,3,7,8,8];
var newArr = arr.slice(3);
console.log(arr,newArr);
3.arr.slice(startIndex,endIndex);
//从index位置向后截取到endIndex-1位置，截取的所有元素组成新数组返回
1. var arr = [4,5,6,3,7,8,8];
var newArr = arr.slice(3,5);
console.log(arr,newArr);
2. var arr = [4,5,6,3,7,8,8];
var newArr = arr.slice(3,0);//后面的下标位置不能低于前面的下标位置，否则返回空数组
console.log(arr,newArr);
3. var arr = [4,5,6,3,7,8,8];
var newArr = arr.slice(3,-2);//后面的下标是负数，从后往前找下标
console.log(arr,newArr);
4. var arr = [4,5,6,3,7,8,8];
var newArr = arr.slice(3,-5);//后面的下标是负数，从后往前找下标
console.log(arr,newArr);
4.arr.join();
//将数组转换成字符串
1.var arr = [4,5,6,3,7,8,8];
var str = arr.join();
console.log(arr,str);
2.var arr = [4,5,6,3,7,8,8];
var str = arr.join("");//把arr的每一个元素连接成字符串返回
console.log(arr,str);
3. var arr = [4,5,6,3,7,8,8];
var str = arr.join("|");//把arr的每一个元素用｜连接成字符串返回
console.log(arr,str);
5.arr.concat(arr1,arr2…);
//将一个或多个数组合并到arr中返回合并后的新数组
var arr = [4,5,6,3,7,8,8];
var arr1 = ["a","b"];
var newArr = arr.concat(arr1,["d","f"]);
console.log(arr,newArr);
ES5新增数组方法
1.Array.isArray();
判断是否是数组，是返回true,不是返回false
Array.isArray();
var arr = [];
console.log(Array.isArray(arr));//true
2.arr.forEach()
遍历数组
var arr=[54,23,65,8,8];
arr.forEach(function(ele,index,array){
//ele:获取对应的元素
//index:对应下标
//array:数组本身
console.log(ele,index,array);
})
3.arr.every()
每一个数组成员都会来执行一个回调，根据回调的返回值，来决定结果，返回值是一个布尔值
var arr = [3, 6, 4, -7, 8, 9];
//判断arr中的元素是否都大于0
//结果都大于0返回true,
var flag = arr.every(function (ele, index) {
//console.log(index);
return ele > 0;
});
console.log(flag);//false
3.arr.some()
有一个满足return就返回true,都不满足返回false
var arr = [3, 6, 4, -7, 8, 9];
//判断arr中的元素是否有小于0的值
var flag = arr.some(function (ele, index) {
//console.log(index);
return ele < 0;
});
console.log(flag);//true
4.arr.filter()
过滤
//每一个数组成员都会执行一个回调
//根据这个回调return的条件，条件为true，这个结果作为一个新的数组的元素返回
//过滤奇数
var arr = [5, 4, 7, 9, 0, 2]
var newArr = arr.filter(function (ele, index, array) {
return ele % 2 == 0;
})
console.log(arr,newArr);.//[5, 4, 7, 9, 0, 2] [4, 0, 2]
5.arr.map()
映射
//每一个数组成员都会执行一个回调
//根据这个回调return的处理结果，这个结果作为一个新的数组的元素返回
var arr = [5, 4, 7, 9, 0, 2]
var newArr=arr.map(function(ele,index,arr){
return ele+1;
});
console.log(arr,newArr);//[5, 4, 7, 9, 0, 2] [6, 5, 8, 10, 1, 3]
6.arr.reduce()
归并
//每一个数组成员都会执行一个回调
//每个回调有一个return的结果
//程序会将每一次的结果合并为一个值，一个数组，一个对象
var arr = [5, 3, 8, 9, 7];
var result = arr.reduce(function (prev, next, index) {
//第一次执行回调
// prev:第一个元素
// next:第二个元素
// index:从1开始
//第二次执行回调
//prev是上一次回调的返回值
console.log(prev, next, index);
/*输出：5 3 1
8 8 2
16 9 3
25 7 4
*/
//return '上一次';
return prev + next;
})
//result获取的是最后一个回调的return结果
console.log(result);//32
ES6(EcmaScript6->ES2015)新增数组方法
1.Array.from()
用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括ES6新增的数据结构Set和Map）
1.
function fn() {
var newArr=Array.from(arguments);
console.log(newArr);// [4, 5, 6, 7]
} fn(4, 5, 6, 7);
2. var obj = {
3:"33333",
0:"00000",
length: 4
}
var newArr = Array.from(obj);
console.log(newArr);//["00000", undefined, undefined, "33333"]
2.Array.of()
方法用于将一组值，转换为数组
1. var arr = Array.of(3, 4, 5, 6, "ww");
console.log(arr);//[3, 4, 5, 6, "ww"]
2. var arr = Array.of(3);
console.log(arr);//[3]
3.copyWithin(index,start,end)
数组实例的copyWithin方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。
它接受三个参数。
index（必需）：从该位置开始替换数据。
start（可选）：从该位置开始读取数据，默认为0。如果为负值，表示倒数。
end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。
1.
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr = arr.copyWithin(3);
console.log(arr, newArr);//[1, 2, 3, 1, 2, 3, 4] [1, 2, 3, 1, 2, 3, 4]
2.
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr = arr.copyWithin(1, 3);
console.log(arr, newArr);// [1, 4, 5, 6, 7, 6, 7] [1, 4, 5, 6, 7, 6, 7]
3.
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr = arr.copyWithin(1, 3, 5);
console.log(arr, newArr);// [1, 4, 5, 4, 5, 6, 7] (7) [1, 4, 5, 4, 5, 6, 7]
4.find()
找元素
var arr = [1, 2, 3, 4, 5, 6, 7];
var ele = arr.find(function (ele, index, array) {
return ele > 5;
});
console.log(ele);//6
5.findIndex()
找下标
var arr = [1, 2, 3, 4, 5, 6, 7];
var index = arr.findIndex(function (ele, index, array) {
return ele > 5;
});
console.log(index);//5
6.fill(val)
方法使用给定val值，填充一个数组。
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr=arr.fill("a");
console.log(arr,newArr);//["a", "a", "a", "a", "a", "a", "a"] ["a", "a", "a", "a", "a", "a", "a"]
7.fill(val,start,end)
方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置.不包含end
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr = arr.fill("a",2,5);
console.log(arr, newArr); [1, 2, "a", "a", "a", 6, 7] (7) [1, 2, "a", "a", "a", 6, 7]
8.includes(val)
方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法属于ES7，但Babel转码器已经支持。
var arr = [1, 2, 3, 4, 5, 6, NaN, 7];
var flag = arr.includes(NaN);//true
var flag = arr.includes(2);//true
console.log(flag);
9.let与const
let关键字，用来声明变量，它的用法类似于var
注：1.let不允许重复声明变量；
let b = 1;
let b = 2;
console.log(b);//报错
2.let声明变量仅在块级作用域内有效；{}
for (let v = 0; v < 10; v++) {
console.log(v);
}
alert(v);//报错
3.不能通过let声明和形参相同的变量；
function test(a) {
let a = 123;
console.log(a);
}
test(456);//报错
4.let声明变量不会提升；
alert(b);
let b = 2;//报错
注意：let声明的变量一定要在声明之后使用，否则报错。
5.暂时性死区TDZ
ES6规定在某个区块中， 一旦用let或const声明一个变量，那么这个区块就变成块级作用域，用let或const声明的变量就“绑定”这个区域，不再受外部的影响。 在该变量声明之前不可以用，在语法上我们叫这种情况为：暂时性死区 (temporal dead zone，简称 TDZ)。
const关键字，用来声明一个只读的常量。
1.const常量一旦声明，常量将不能重新赋值！意味着，const一旦声明，就必须立即初始化，不能留到以后赋值！
const AGE = 18;
alert(AGE);
AGE = 20;
alert(AGE);//报错
本质：const实际上保证的，并不是值不能改变，而是指向的那个内存地址不能改变。
注意：为了和变量区分，一般常量用大写字母。
10.arrow functions(箭头函数)
定义：( 形参 ) => { 函数体 }
var box = document.getElementById('box');
box.onclick = function () { // ES5
console.log(this);
}
box.onclick = () => { // ES6
console.log(this);
}
箭头函数与传统的JavaScript函数主要区别在于以下几点：
1.对 this 的关联。函数内部的 this 指向，取决于箭头函数定义的位置，而非箭头函数的调用对象。
2.new 不可用。箭头函数不能使用 new 关键字来实例化对象，不然会报错。
var Test = () => {};
var obj = new Test(); //Test is not a constructor
3.this 不可变。函数内部 this 不可变，在函数体内整个执行环境中为常量。
var obj1 = {
name: '隔壁王叔叔',
age: 33
}
setTimeout(() => {
console.log(this);
}.bind(obj1),1000); //报错
4.没有arguments对象。更不能通过arguments对象访问传入参数。
var fn = () => {
console.log(arguments[0]); //报错
}
fn(3);
11.template string(（字符串模板）
ES6中字符串模板使用反引号 表示，字符串模板中可以解析变量和函数，使用 ${ } 解析
box.innerHTML = `
<ul>
<li>${val1}</li>
<li>${val2}</li>
<li>${val3}</li>
</ul>
`;
12.Destructuring（解构赋值）
//解构赋值=>解析数据结构进行赋值
let obj={
name:'老王',
age:28,
sayHi:()=>{
alert('hi')
}
}
//把右边对象的key值，赋值给左边的同名变量
let{name,age,sayHi}=obj
console.log(name);
console.log(age);
sayHi()
13.三个点（…）
扩展运算符用三个点号表示，其功能是把数组或类数组对象（部署了iterator接口）展开成一系列用逗号隔开的参数序列。
console.log(...[1, 2, 3]);// 1 2 3
console.log(1, ...[2, 3, 4], 5);// 1 2 3 4 5
rest运算符,与展开运算符相反的操作
var arr=[1,2,3]
function test(arr1,...arr2){
//console.log(arr2);
arr1.push(...arr2)
}
test(arr,4,5,6)
console.log(arr);
14.Set 和 Map
两种新的数据结构 Set 和 Map。
set是一个构造函数，用来生成Set数据结构，它类似于数组，但是成员的值都是唯一的、没有重复的， 初始化 Set 可以接受一个数组或类数组对象作为参数，也可以创建一个空的 Set：
var s1 = new Set();
var s2 = new Set([1, 2, 3]);
console.log(s1);//{}
console.log(s2);//{1,2,3}
在 Set 中成员的值是唯一的，重复的值自动被过滤掉
var s1 = new Set([1, 2, 2, 3, 1, 4]);
console.log(s1);//{1,2,3,4}
用一句话数组去重
var s3=new Set([1,23,3,3,4,4,5,6])
console.log([...s3]);
Set 的一些属性方法：
size：返回成员总数
add(value)：添加某个值，返回Set结构本身
delete(value)：删除某个值，返回一个布尔值，表示删除是否成功
has(value)：返回一个布尔值，表示该值是否为Set的成员
clear()：清除所有成员，没有返回值
var set = new Set([1,2]);
set.add(3);// 添加成员
console.log(set.size);// 3 成员总数
console.log(set);// Set(3) {1, 2, 3}
set.add([4,5]);// 添加成员
console.log(set.size);// 4 成员总数
console.log(set.has(2));// true 有该成员
console.log(set);// Set(4) {1, 2, 3, [4, 5]}
set.delete(2);// 删除成员
console.log(set);// Set(3) {1, 3, [4, 5]}
console.log(set.has(2));// false 没有该成员
set.clear();// 清除所有成员
console.log(set);// Set(0) {}
set不能实现按下标查找元素
var arr = [1,2,3,'a',4,'b'];
var set = new Set(arr);
console.log(set[0]);// undefined
console.log(set['a']);// undefined
Map是一个构造函数，用来生成 Map 数据结构，它类似于对象，也是键值对的集合，但是“键”可以是非字符串， 初始化 Map 需要一个二维数组，或者直接初始化一个空的 Map
var m1 = new Map();
var m2 = new Map([['a', 123], ['b', 456], [3, 'abc']]);
console.log(m1);//{}
console.log(m2);// {"a" => 123, "b" => 456, 3 => "abc"}
Map 的一些操作方法：
set(key, value)：设置键值对
get(key)：获取键对应的值
has(key)：是否存在某个键
delete(key)：删除某个键值对，返回一个布尔值，表示删除是否成功
var map = new Map([['a', 123], ['b', 456], [3, 'abc']]);
map.set('c',789);
console.log(map.get('c')); // 789
console.log(map.has('b')); // true 此key存在
map.delete(3); // true 成功删除key
console.log(map); // Map(3) {"a" => 123, "b" => 456, "c" => 789}
15.Symbol类型
在创建symbol类型数据时的参数只是作为标识使用，直接使用 Symbol() 也是可以的。
Symbol 是 JavaScript 语言的第七种数据类型。
在创建symbol类型数据时的参数只是作为标识使用，直接 使用 Symbol() 也是可以的。
let s = Symbol('xm');
console.log( s );// symbol(xm)
console.log( typeof s );symbol
16.Object扩展
Object.getOwnPropertySymbols(obj)
方法会返回当前对象的所有 Symbol 属性，返回数组
Object.setPrototypeOf(obj1,obj2)方法用来设置一个对象的 prototype 对象，与Object.getPrototypeOf 方法配套
Object. getOwnPropertyDescriptors(obj)获取指定对象的所有自身属性的描述符，如果没有任何自身属性，则返回空对象。
Object.values(obj)方法返回一个数组，成员是参数对象自身的所有可枚举属性的值（与Object.keys配套)
Object.entries(obj)方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组。
Object.assign(target,source)方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。
Object.is(val1,val2)方法用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。（注：一是: +0不等于-0，二是: NaN等于自身。）
六.组排序
1.选择排序
1.假设一个最小值和最小值的下标
2.依次比较找最小值及下标
3.假设的最小值和实际最小值换位
eg:
var arr = [12, 23, 44, 56, 4, 78];
function selectSort(arr, flag) {
for (var i = 0; i < arr.length - 1; i++) {
var min = arr[i];
var minIndex = i;
for (var j = i + 1; j < arr.length; j++) {//依次比较找最小值及下标
if (flag === 'a') {
if (min > arr[j]) {//升序
min = arr[j];
minIndex = j;
}
} else {
if (min < arr[j]) {//降序
min = arr[j];
minIndex = j;
}
}
}
//换位
var temp = arr[i];
arr[i] = min;
arr[minIndex] = temp;
}
return arr;
}
console.log(selectSort(arr, 'a'));
console.log(selectSort(arr, 'b'));
2.冒泡排序
两两比较，互换位置
eg:
var arr = [88, 80, 99, 38, 110, 90, 91, 70];
function maopaoSort(arr) {
for (var n = 0; n < arr.length - 1; n++) {//比较轮数
for (var i = 0; i < arr.length - (n + 1); i++) {
if (arr[i] > arr[i + 1]) {//两两比较
//互换位置
var temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp
}
}
} return arr;
}
console.log(maopaoSort(arr));
3.桶排序
1.创建一个桶
2.遍历数据，向对应编号的桶灌水
3.把所有有水的桶的编号取出
var arr = [14, 7, 2, 9, 5, 1];
function tongSort(arr) {
var bucket = [];//创建一个空桶
for (var i = 0; i < arr.length; i++) {
var item = arr[i];
bucket[item] = 'water';
}
arr.length = 0;//清空数组
for (var index in bucket) {
arr.push(parseInt(index));
}
//return arr;//升序
return arr.reverse()//降序
}
console.log(tongSort(arr));
4.快速排序
找中点，分左右，递归。。
var arr = [24, 15, 7, 28, 9, 2, 9,37, 5, 19];
function quickSort(arr) {//递归
if (arr.length <= 1) {
return arr;
}
//找中点(值和下标)
var minIndex = parseInt(arr.length / 2);
var mid = arr[minIndex];
//分左右
var left = [];
var right = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] === mid) {
continue;//跳过本次循环
}
if (mid < arr[i]) {
right.push(arr[i]);
} else {
left.push(arr[i]);
}
}
return quickSort(left).concat([mid], quickSort(right));//递归执行
}
console.log(quickSort(arr));
5.sort 排序
- 按字符从小到大排，会改变原数组
var arr = [113,4,24,8,4,242,152];
console.log(arr.sort());
// [113, 152, 24, 242, 4, 4, 8]
- sort 按数值大小排序
1.
var arr = [113, 4, 24, 8, 4, 242, 152];
//回调函数，一个函数a,函数a接收一个参数b,这个b也是一个函数，b函数就是a的回调函数
var newArr = arr.sort(function (a, b) {//回调函数
return a - b;//从小到大
});
console.log(newArr);
2.
var arr = [113, 4, 24, 8, 4, 242, 152];
var newArr = arr.sort(function (a, b) {//回调函数
return b - a;//从大到小排序
});
console.log(newArr);
七.数组去重
var arr = [4, 3, 4, 5, 6, 7, 86, 54, 3];
function noRepeat(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (!has(newArr, arr[i])) {
newArr.push(arr[i]);
}
}
return newArr;
}
//判断一个数在数组中知否存在，存在返回true，返回false
function has(newArr, ele) {
for (var i = 0; i < newArr.length; i++) {
if (newArr[i] === ele) {
return true;
}
} return false;
}
console.log(noRepeat(arr));
2.indexOf数组去重
var arr = [4, 5, 5, 6, 7, 8, 9];
function noRepeat(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
//if(arr[i]在newArr中不存在)
if (newArr.indexOf(arr[i]) === -1) {
newArr.push(arr[i])
}
} return newArr;
}
console.log(noRepeat(arr));//[4, 5, 6, 7, 8, 9]
- 利用includes 数组去重
var arr=[1,1,2,3,4,5,11,2,3,5];
function noRepeat(arr){
var newArr=[];
for(var i=0;i<arr.length;i++){
if(!newArr.includes(arr[i])){
newArr.push(arr[i])
}
}
return newArr;
}
console.log(noRepeat(arr));// [1, 2, 3, 4, 5, 11]
- 利用lastIndexOf数组去重
var arr = [4, 5, 5, 6, 7, 8, 9];
function noRepeat(arr){
var newArr=[];
for(var i=0;i<arr.length;i++){
if(newArr.lastIndexOf(arr[i])==-1) {
newArr.push(arr[i])
}
}return newArr;
}console.log(noRepeat(arr));//[4, 5, 6, 7, 8, 9]
5.sort去重
var arr=[1,2,2,2,344,5]
function noRepeat(arr){
arr.sort();
for(var i=0;i<arr.length;i++){
if(arr[i]===arr[i+1]){
arr.splice(i,1);
i--;
}
}return arr;
} console.log(noRepeat(arr));
八.数组遍历
1.for循环
var arr=[43,6,5,78,8];
for(var i=0;i<arr.length;i++){
console.log(arr[i]);
}
2.for in 遍历
var arr=[43,6,5,78,8];
for(var index in arr){
console.log(arr[index]);
}
3.forEach(ES5新增)
var arr = [54, 23, 65, 8, 8];
var newArr = arr.forEach(function (ele, index, array) {
//ele:获取对应的元素
//index:对应下标
//array:数组本身
// console.log(ele,index,array);
});
console.log(arr, newArr);//[54, 23, 65, 8, 8] undefined
4.for of(ES6遍历)
var arr=[43,6,5,78,8];
for(var ele of arr){
console.log(ele);
}
多维数组展开案例：
拍平 arr = [1, “a”, [2, “b”, [3, [4, [5, [6, [7, [8, 9]]]]]]]];
1.Array.isArray();
var arr = [1, "a", [2, "b", [3, [4, [5, [6, [7, [8, 9]]]]]]]];
function fn(arr, newArr) {
//获取arr中的所有元素
//判断元素是否是一个数组
//如果不是，将这个元素添加到一个新的数组
//如果是，继续操作
//var newArr=[];
newArr = newArr || [];
for (var i = 0; i < arr.length; i++) {
if (Array.isArray(arr[i])) {
fn(arr[i], newArr);
} else {
newArr.push(arr[i])
}
} return newArr;
}
console.log(fn(arr));
2.reduce
var arr = [1, "a", [2, "b", [3, [4, [5, [6, [7, [8, 9]]]]]]]];
function fn(arr) {
return arr.reduce(function (prev, next, index) {
return prev.concat(Array.isArray(next) ? fn(next) : next)
}, []);
}
console.log(fn(arr));
535
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
