数组创建

*** 1. Array() 构造函数 ***

let arr1 = new Array() 创建一个空数组
let arr1 = new Array(20) 创建一个长度20的数组
let arr1 = new Array('1','2','4') 创建包含三个字符串的数组

*** 2. 字面量表示***

let arr1 = [] 创建一个空数组
let arr1 = [20] 创建一个长度20的数组
let arr1 = ['1','2','4']创建包含三个字符串的数组

数组赋值

简要归纳：

1、普通的赋值是复制栈区内容。

2、基本类型的数据在栈区存放数据自身，var a=b; //a与b无关。

引用类型数据在栈区存放数据地址。 var a=b; //a,b联动

3、基本数据类型包括：undefined，boolean，number，string，null，Symbol(E6新增，表示独一无二)

引用类型：对象、数组、函数。

*** 基本数据类型特点：***

1.值不可变基本数据类型的值是不可改变的

2.存放在栈区原始数据类型直接存储在栈(stack)中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储。

*** 引用数据类型 ***

1.值可变引用类型可以拥有属性和方法，并且是可以动态改变的。

2.同时保存在栈内存和堆内存引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

let arr1[3] = '1';//给数组赋值数组中可包含对象，数组，函数,数字，字符 let arr1[0] = Data.now; let arr1[1] = myFunction; let arr1[2] = mycarts;

*** ES6解构赋值 (数组和对象)***

*** 定义***

ES6中允许按照一定的模式，从数组和对象中提取值，对变量进行赋值，这称为解构赋值，

***1)完全解构（左右匹配，按照对应位置为变量赋值）

let [a, b, c] = [1, 2, 3];
console.log(a, b, c);  //1 2 3

//略微复杂一点的嵌套，但是也是模式匹配的
let [foo, [[bar], baz]] = [1, [[2], 3]];
console.log(foo, bar, baz);  //1 2 3

***2)不完全解构（左右不匹配）

var [a] = [];    //a undefined
var [a,b] = [1] ;  //a=1;b undefined;
let [a,[b],c] = [1,[2,3],4]; //a=1;b=2;c=4;
let [a,[b,c],d] = [1,[2],3] ; // a=1;b=2;c undefined;d=3;

***3)解构报错(左右类型不一致)

var [a] = 1; //报错

var [b] = null; //报错

var [c] = undefined; //报错

var [d] = false; //报错

var [e]  = {}; //报错

***4)解构默认赋值

var [a=1,b=2] = [];  //a=1;b=2;

var [a=1] = [null] ; // a=1;  null !==undefined

var [a=1] = [undefined] ;  // a=1;

默认值可以是表达式：表达式是惰性求值，仅在用到的时候才求值；

function fn(){alert(1)};

var [a=fn()] = []; // fn会执行；

var [b=fn()] = [1] ; //fn不会执行； b=1;

默认值也可引用解构赋值的其他变量，前提是该变量已经声明：

var [a=1,b=a] = []; //a=1;b=1;

var [a=b,b=1] = []; //报错 referenceError；

*** 5) 对象的解构赋值：找同名属性，顺序不重要：***

var {b,a} = {a:1,b:2}; //  a=1;b=2;

赋值的变量名与属性名不一致：

var {color: pink,b} = {color:'#ccc',b:3}; //pink='#ccc'; b=3;

对象的解构赋值，找同名的属性，找到后将值赋给变量。（实际赋值的是后者）。

var {abc:car,bcd:color} = {abc:'丰田',bcd:'green'};  //car = '丰田' ；color='green'; 其中abc和bcd都是模式，不是变量。

var obj={a:1,b:2,c:3};    var {a,b,c}=obj;  //a=1;b=2;c=3;

var obj={a:1,b:2,c:3} ;   var {a:first,b:second,c:third}=obj;  //first=1;second=2;third=3;  a undefined,b undefined ,c undefined; a,b,c都是

模式不是实际的变量；

解构失败的值是undefined；

对象的解构赋值中，变量的声明和赋值是一体的，对于let和const来说，仅能声明一次，若重复声明则报错。

let a;let {a} = {a:1}; // 报错，重复声明变量。

解决：let a; (let {a} = {a:1}) // a=1; javascript会将两次声明区分成两个代码块，不会报错。（容易乱，还是少用）

解构赋值的默认值：(解构赋值生效的条件是属性值严格等于undefined)

var {a:b=1} = {}; //b=1;

var {a:b=2} = {a:null}; //b=null ,null !==undefined

数组属性

*** constructor ***

*** 1.定义和用法***

在 JavaScript 中, constructor 属性返回对象的构造函数。

返回值是函数的引用，不是函数名：

JavaScript 数组 constructor 属性返回 function Array() { [native code] }

JavaScript 数字 constructor 属性返回 function Number() { [native code] }

JavaScript 字符串 constructor 属性返回 function String() { [native code] }

如果一个变量是数组你可以使用 constructor 属性来定义。

*** 2.语法***

array.constructor

返回值：一个函数对象

*** length ***

array.length

返回值：返回长度

*** prototype ***

*** 1.定义和用法***

prototype 属性使您有能力向对象添加属性和方法。

当构建一个属性，所有的数组将被设置属性，它是默认值。

在构建一个方法时，所有的数组都可以使用该方法。

注意： Array.prototype 单独不能引用数组, Array() 对象可以。注意：在JavaScript对象中，Prototype是一个全局属性。

*** 2.语法***

array.length

返回值：返回长度

*** 3.代码示例***

Array.prototype.myUcase=function()
{
    for (i=0;i<this.length;i++)
    {
        this[i]=this[i].toUpperCase();
    }
}
创建一个数组，然后调用 myUcase 方法：

var fruits=["Banana","Orange","Apple","Mango"];
fruits.myUcase();
fruits 数组现在的值为：
BANANA,ORANGE,APPLE,MANGO

数组方法

*** 数组排序方法***

* sort() *

*** 1.定义用法 ***

用于对数组的元素进行排序。

*** 2.参数 ***

无参，按字母顺序排序
参数为比较函数，按比较函数排序

*** 3.比较函数 ***

若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。若 a 等于 b，则返回 0。若 a 大于 b，则返回一个大于 0 的值。

arr=[3,4,2,6]
arr.sort(compare)
function compare(a,b){
  return a-b;
}

此方法可以对数组进行乱序
arr.sort(function(){
 return 0.5-Math.random()
})

* reverse() *

*** 1.定义用法 ***

reverse() 方法用于颠倒数组中元素的顺序。

*** 2.语法 ***

array.reverse()

返回值：一个颠倒原始顺序的数组

*** 3.参数 *** 无

*** 4.示例代码 ***

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse();
fruits 结果输出：
Mango,Apple,Orange,Banana

*** 数组遍历和查找方法***

* forEach() *

*** 1.定义用法 ***

forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。

注意: forEach() 对于空数组是不会执行回调函数的。方法不改变原始数组

*** 2.语法 ***

array.forEach(function(currentValue, index, arr), thisValue)

返回值：undefined

*** 3.参数 ***

function():必须，数组中每个函数都必须调用的函数 currentValue:必须，当前元素值 index:可选，当前元素索引值 arr:可选，当前元素所属的数组对象 thisValue:可选传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值

*** 4.示例代码 ***

var numbers = [1,2,3,4,5];
var sum = 0;
numbers.forEach(numSum)
function numSum(currentValue, index, arr)
{
   console.log(currentValue)///当前元素值 1 2 3 4 5
   console.log(index)///当前元素索引 0 1 2 3 4 
   console.log(arr)///当前元素所属数组或对象 [1,2, 3, 4 ,5]
}

* map() *

*** 1.定义用法 ***

map:将数组映射成另一个数组

map通过指定函数处理数组的每个元素，并返回处理后新的数组，

forEach和map的区别在于，forEach没有返回值。

map需要返回值，如果不给return，默认返回undefined

map 不会改变原始数组。 map 不会对空数组进行检测

*** 2.语法 ***

var newArr=array.map(function(currentValue,index,arr), thisValue)

返回值：一个新的数组

*** 3.参数 ***

*** 4.示例代码 ***

var numbers = [1,2,3,4,5];
var sum = 0;
var newArray=numbers.map(multipl)
console.log(newArray)///[2,4,6,8,10]
function multipl(currentValue, index, arr)
{
   console.log(currentValue)///当前元素值 1 2 3 4 5
   console.log(index)///当前元素索引 0 1 2 3 4 
   console.log(arr)///当前元素所属数组或对象 [1,2, 3, 4 ,5]
   return currentValue*2  //返回处理后的元素
}

使用场景2 假定有一个对象数组(A),将A数中对象某个属性的值存储到B数组中

var cars = [
  {model:"Buick",price:"CHEAP"},
  {model:"BMW",price:"expensive"}
];
var prices = cars.map(function(car){
    return car.price;
})
console.log(prices);//["CHEAP", "expensive"]

* filter() *

*** 1.定义用法 ***

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

filter() 不会改变原始数组。 filter() 不会对空数组进行检测

*** 2.语法 ***

var newArr=array.filter(function(currentValue,index,arr), thisValue)

返回值：一个新的数组

*** 3.参数 ***

*** 4.示例代码 ***

使用场景1：假定有一个对象数组(A),获取数组中指定类型的对象放到B数组中

var porducts = [
  {name:"cucumber",type:"vegetable"},
  {name:"banana",type:"fruit"},
  {name:"celery",type:"vegetable"},
  {name:"orange",type:"fruit"}
];
// es6 filter
var filtered2 = porducts.filter(function(product){
  return product.type === "vegetable";
})
console.log(filtered2);//[{name: "cucumber", type: "vegetable"},

使用场景2 假定有一个对象数组(A),过滤掉不满足以下条件的对象条件: 蔬菜数量大于0,价格小于10

var products = [
  {name:"cucumber",type:"vegetable",quantity:0,price:1},
  {name:"banana",type:"fruit",quantity:10,price:16},
  {name:"celery",type:"vegetable",quantity:30,price:8},
  {name:"orange",type:"fruit",quantity:3,price:6}
];
products = products.filter(function(product){
    return product.type === "vegetable" 
    && product.quantity > 0 
    && product.price < 10
})
console.log(products);//[{name:"celery",type:"vegetable",quantity:30,price:8}]

使用场景3：假定有两个数组(A,B),根据A中id值,过滤掉B数组不符合的数据

var post = {id:4,title:"Javascript"};
var comments = [
   {postId:4,content:"Angular4"},
   {postId:2,content:"Vue.js"},
   {postId:3,content:"Node.js"},
   {postId:4,content:"React.js"},
];
function commentsForPost(post,comments){
   return comments.filter(function(comment){
     return comment.postId === post.id;
   })
}
console.log(commentsForPost(post,comments));
//[{postId:4,content:"Angular4"},{postId:4,content:"React.js"}]

* find() && findIndex() *

*** 1.定义用法 ***

find() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。

find() 方法为数组中的每个元素都调用一次函数执行：

当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。

findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。

findIndex() 方法为数组中的每个元素都调用一次函数执行：

当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。

find() findIndex() 不会改变原始数组。 find() findIndex() 不会对空数组进行检测

*** 2.语法 ***

var newArr=array.find(function(currentValue, index, arr),thisValue)

返回值：符合测试条件的第一个数组元素值，如果没有符合条件的则返回 undefined。

var index=array.findIndex(function(currentValue, index, arr),thisValue)

返回值：返回符合测试条件的第一个数组元素索引，如果没有符合条件的则返回 -1。

*** 3.参数 ***

*** 4.示例代码 ***

使用场景1：假定有一个对象数组(A),找到符合条件的对象

var users = [
  {name:"Jill"},
  {name:"Alex",id:2},
  {name:"Bill"},
  {name:"Alex"}
 ];
// es6 find
user = users.find(function(user){
  return user.name === "Alex";
})
console.log(user);// {name:"Alex",id:2}找到后就终止循环

使用场景2 假定有一个对象数组(A),根据指定对象的条件找到数组中符合条件的对象

var posts = [
 {id:3,title:"Node.js"},
 {id:1,title:"React.js"}
];
var comment = {postId:1,content:"Hello World!"};
function postForComment(posts,comment){
 return posts.find(function(post){
   return post.id === comment.postId;
 })
}
console.log(postForComment(posts,comment));//{id: 1, title: "React.js"}

* every() && some()*

*** 1.定义用法 ***

every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。

every() 方法使用指定函数检测数组中的所有元素：

如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。如果所有元素都满足条件，则返回 true。

some:数组中是否有元素满足指定的条件

如果数组中检测到有一个元素满足，则整个表达式返回 true ，且剩余的元素不会再进行检测。如果所有元素都不满足条件，则返回 false。

every() 不会改变原始数组。 every() 不会对空数组进行检测

*** 2.语法 ***

var newArr=array.every(function(currentValue, index, arr),thisValue)

返回值：布尔值。如果所有元素都通过检测返回 true，否则返回 false。

var newArr=array.some(function(currentValue, index, arr),thisValue)

布尔值。如果数组中有元素满足条件返回 true，否则返回 false。

*** 3.参数 ***

*** 4.示例代码 ***

使用场景1：计算对象数组中每个电脑操作系统是否可用，大于16位操作系统表示可用,否则不可用

var computers = [
 {name:"Apple",ram:16},
 {name:"IBM",ram:4},
 {name:"Acer",ram:32}
];
//ES6 some every 
var every = computers.every(function(computer){
  return computer.ram > 16;
})
console.log(every);//false
var some = computers.some(function(computer){
 return computer.ram > 16;
})
console.log(some);//true

使用场景2 假定有一个对象数组(A),根据指定对象的条件找到数组中符合条件的对象

var posts = [
 {id:3,title:"Node.js"},
 {id:1,title:"React.js"}
];
var comment = {postId:1,content:"Hello World!"};
function postForComment(posts,comment){
 return posts.find(function(post){
   return post.id === comment.postId;
 })
}
console.log(postForComment(posts,comment));//{id: 1, title: "React.js"}

数组分割方法

* slice() && splice()*

*** 1.定义用法 ***

slice() 方法可从已有的数组中返回选定的元素。

slice()方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。

注意： slice() 方法不会改变原始数组。

splice() 方法用于插入、删除或替换数组的元素。也可分割

注意：这种方法会改变原始数组！。

*** 2.语法 ***

array.slice(start, end)

返回值:返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。

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

如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。

*** 3.参数 ***

slice()

start 可选。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。

end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

splice()

index 必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。 howmany 必需。规定应该删除多少元素。必须是数字，但可以是 "0"。如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。 item1, ..., itemX 可选。要添加到数组的新元素

*** 4.示例代码 ***

slice()

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var myBest = fruits.slice(-3,-1);
myBest 结果输出:
Lemon,Apple

splice()

从第三个位置开始删除数组后的两个元素：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,2);
fruits 输出结果：
Banana,Orange

移除数组的第三个元素，并在数组第三个位置添加新元素:
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,1,"Lemon","Kiwi");
fruits 输出结果：
Banana,Orange,Lemon,Kiwi,Mango

*** 数组增删改方法***

* splice() *

以上已讲

* push() && unshift()*

*** 1.定义用法 ***

push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。

unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

注意：两种方法将改变数组的数目。

*** 2.语法 ***

array.push(item1, item2, ..., itemX)

返回值：数组新长度

array.unshift(item1, item2, ..., itemX)

返回值：数组新长度

*** 3.参数 ***

item1, item2, ..., itemX 必需。要添加到数组的元素。

* pop() && shift() *

*** 1.定义用法 ***

pop() 方法用于删除数组的最后一个元素并返回删除的元素。

shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。

注意：此两种方法改变数组的长度！

*** 2.语法 ***

array.pop()

返回值：返回删除的元素/数组元素可以是一个字符串，数字，数组，布尔，或者其他对象类型。

array.shift()

返回值：返回删除的元素/数组元素可以是一个字符串，数字，数组，布尔，或者其他对象类型。

*** 数组计算方法***

* reduce() && reduceRight()*

*** 1.定义用法 ***

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

reduce() 可以作为一个高阶函数，用于函数的 compose。

reduceRight() 方法的功能和 reduce() 功能是一样的，不同的是 reduceRight() 从数组的末尾向前将数组中的数组项做累加。

注意: reduce() reduceRight()对于空数组是不会执行回调函数的。

*** 2.语法 ***

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

返回值：返回计算结果

array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)

返回值：返回计算结果

*** 3.参数 ***

function():必须，数组中每个函数都必须调用的函数 total 必需。初始值, 或者计算结束后的返回值。

如果不设置，reduce()初始值为数组第一个，reduceRight()为最后一个

currentValue 必需。当前元素 currentIndex 可选。当前元素的索引 arr 可选。当前元素所属的数组对象。

initialValue 可选。传递给函数的初始值(total值)

*** 4.示例代码 ***

四舍五入后计算数组元素的总和

var numbers = [15.5, 2.3, 1.1, 4.7];
 
function getSum(total, num) {
    return total + Math.round(num);
}
var sum=numbers.reduce(getSum, 0);
console.log(sum)///

*** 数组转化方法***

* toString() *

*** 1.定义用法 ***

toString() 方法可把数组转换为字符串，并返回结果。

注意：数组中的元素之间用逗号分隔。

*** 2.语法 ***

array.toString()

返回值：字符串，所有值用逗号隔开

* join() *

*** 1.定义用法 ***

join() 方法用于把数组中的所有元素转换一个字符串。

元素是通过指定的分隔符进行分隔的。

*** 2.语法 ***

array.join(separator)

返回值：返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的

*** 3.参数 ***

separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

*** 4.示例代码 ***

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join(" and ");
energy 结果输出：
Banana and Orange and Apple and Mango

*** 数组取元素索引方法***

* findIndex() *

以上有讲

* indexOf() && lastIndexOf() *

*** 1.定义用法 ***

indexOf() 方法可返回数组中某个指定的元素位置。

该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。

如果在数组中没找到指定元素则返回 -1。

lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，在一个数组中的指定位置从后向前搜索。

如果要检索的元素没有出现，则该方法返回 -1。

该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾（没有指定 start 参数时）。如果找到一个 item，则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。

如果在数组中没找到指定元素则返回 -1。

*** 2.语法 ***

array.indexOf(item,start)

返回值：number,元素在数组中的位置,如果没与搜索到则返回 -1

array.lastIndexOf(item,start)

返回值：number,元素在数组中的位置,如果没与搜索到则返回 -1

*** 3.参数 ***

item 必须。规定需检索的字符串值。 start 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0-（stringObject.length - 1）。

如省略start该参数，indexof则将从字符串的首字符开始检索。lastIndexof则将从字符串的最后一个字符开始检索。

*** 数组合并填充复制方法***

* concat() *

*** 1.定义用法 ***

concat() 方法用于连接两个或多个数组。

该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

*** 2.语法 ***

array1.concat(array2,array3,...,arrayX)

返回值：返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。

*** 3.参数 ***

array2, array3, ..., arrayX 必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。

*** 4.示例代码 ***

合并三个数组的值：

var hege = ["Cecilie", "Lone"];
var stale = ["Emil", "Tobias", "Linus"];
var kai = ["Robin"];
var children = hege.concat(stale,kai);
children 输出结果：

Cecilie,Lone,Emil,Tobias,Linus,Robin

* fill() *

*** 1.定义用法 ***

fill() 方法用于将一个固定值替换数组的元素

*** 2.语法 ***

array.fill(value, start, end)

返回值：返回一个新的数组。

*** 3.参数 ***

value 必需。填充的值。 start 可选。开始填充位置。 end 可选。停止填充位置 (默认为 array.length)

*** 4.示例代码 ***

使用固定值填充数组：
var fruts = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob");
fruits 输出结果：
Runoob,Runoob,Runoob,Runoob

* copyWithin() *

*** 1.定义用法 ***

copyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。

*** 2.语法 ***

array.copyWithin(target, start, end)

*** 3.参数 ***

target 必需。复制到指定目标索引位置。 start 可选。元素复制的起始位置。 end 可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。

*** 4.示例代码 ***

复制数组的前面两个元素到第三和第四个位置上：

var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
fruits.copyWithin(2, 0, 2);
输出结果：

Banana,Orange,Banana,Orange,Kiwi,Papaya

* Array.from() *

*** 1.定义用法 ***

Array.from() 方法从一个类似数组或可迭代对象中创建一个新的，浅拷贝的数组实例。

*** 2.语法 ***

Array.from(arrayLike[, mapFn[, thisArg]])

*** 3.参数 ***

arrayLike 想要转换成数组的伪数组对象或可迭代对象。 mapFn (可选参数) 如果指定了该参数，新数组中的每个元素会执行该回调函数。 thisArg (可选参数) 可选参数，执行回调函数 mapFn 时 this 对象。

返回一个新的数组实例

*** 4.示例代码 ***

console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]

js数组 与 数组函数

数组创建

数组赋值

数组属性

数组方法

*** sort() ***

*** reverse() ***

*** forEach() ***

*** map() ***

*** filter() ***

*** find() && findIndex() ***

*** every() && some()***

*** slice() && splice()***

*** splice() ***

*** push() && unshift()***

*** pop() && shift() ***

*** reduce() && reduceRight()***

*** toString() ***

*** join() ***

*** findIndex() ***

*** indexOf() && lastIndexOf() ***

*** concat() ***

*** fill() ***

*** copyWithin() ***

*** Array.from() ***

js数组与数组函数

* sort() *

* reverse() *

* forEach() *

* map() *

* filter() *

* find() && findIndex() *

* every() && some()*

* slice() && splice()*

* splice() *

* push() && unshift()*

* pop() && shift() *

* reduce() && reduceRight()*

* toString() *

* join() *

* findIndex() *

* indexOf() && lastIndexOf() *

* concat() *

* fill() *

* copyWithin() *

* Array.from() *