数组方法总结常用数组方法总结 js的数组或对象常用方法总结

js常用数据类型的方法使用归纳

* String---->是一个对象
* 字符串可以看成是字符组成的数组,但是js中没有字符类型

* 字符是一个一个的,在别的语言中字符用一对单引号括起来

* 在js中字符串可以使用单引号也可以使用双引号

* 因为字符串可以看成是数组,所以,可以通过for循环进行遍历

* 字符串特性:不可变性,字符串的值是不能改变

* 字符串的值之所以看起来是改变的,那是因为指向改变了,并不是真的值改变了

* 字符串的常用属性:
* .length------>字符串的长度

* .charAt(索引),返回值是指定索引位置的字符串,超出索引,结果是空字符串

* .fromCharCode(数字值,可以是多个参数),返回的是ASCII码对应的值

* .concat(字符串1,字符串2,...);返回的是拼接之后的新的字符串

* .indexOf(要找的字符串,从某个位置开始的索引);返回的是这个字符串的索引值,没找到则返回-1

* .lastIndexOf(要找的字符串);从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1

* .replace("原来的字符串","新的字符串");用来替换字符串的

* .slice(开始的索引,结束的索引); 从索引5的位置开始提取,到索引为10的前一个结束,没有10，并返回这个提取后的字符串

* .split("要干掉的字符串",切割后留下的个数);切割字符串

* .substr(开始的位置,个数);返回的是截取后的新的字符串

* .substring(开始的索引,结束的索引),返回截取后的字符串,不包含结束的索引的字符串

* .toLocaleLowerCase();转小写

* .toLowerCase();转小写

* .toLocaleUpperCase()转大写

* .toUpperCase();转大写

* .trim();干掉字符串两端的空格

总结Date对象的用法：
var dt=new Date();

var dt=+new Date();//一种特殊的写法,只适用于这个Date的对象

console.log(dt);

dt.getFullYear();//年

dt.getMonth();//月---从0开始

dt.getDate();//日

dt.getHours();//小时

dt.getMinutes();//分钟

dt.getSeconds();//秒

dt.getDay();//星期---从0开始

dt.toDateString();//日期

dt.toLocaleDateString();//日期

dt.toTimeString();//时间

dt.toLocaleTimeString();//时间

dt.valueOf();//毫秒

Array对象的方法;
* Array.isArray(对象)---->判断这个对象是不是数组

* instanceof关键字

* .concat(数组,数组,数组,...) 组合一个新的数组

* .every(函数)--返回值是布尔类型,函数作为参数使用,函数中有三个参数,第一个参数是元素的值，第二个参数是索引值,第三个参数是原来的数组(没用)

* 如果这个数组中的每个元素的值都符合条件,最后才返回的是true

* .filter(函数);返回的是数组中每一个元素都复合条件的元素,组成了一个新的数组

* .push(值);--->把值追加到数组中,加到最后了---返回值也是追加数据之后的数组长度

* .pop();--->删除数组中最后一个元素,返回值就是删除的这个值

* .shift();--->删除数组中第一个元素,返回值就是删除的这个值

* .unshift();--->向数组的第一个元素前面插入一个新的元素,----返回值是插入后的程度

* .forEach(函数)方法---遍历数组用---相当于for循环

* .indexOf(元素值);返回的是索引,没有则是-1

* .join("字符串");----返回的是一个字符串

* .map(函数);--->数组中的每个元素都要执行这个函数,把执行后的结果重新的全部的放在一个新的数组中

* .reverse();----->反转数组

* .sort();---排序的,可能不稳定,如果不稳定,请写MDN中的那个固定的代码

* .arr.slice(开始的索引,结束的索引);把截取的数组的值放在一个新的数组中,但是不包含结束的索引对应的元素值

* .splice(开始的位置,要删除的个数,替换的元素的值);一般是用于删除数组中的元素,或者是替换元素,或者是插入元素

基本包装类型

普通变量不能直接调用属性或者方法

对象可以直接调用属性和方法

*基本包装类型:本身是基本类型,但是在执行代码的过程中,如果这种类型的变量调用了属性或者是方法,那么这种类型就不再是基本类型了,而是基本包装类型,这个变量也不是普通的变量了,而是基本包装类型对象

//string number boolean

var str="hello";

// str=str.replace("ll","HH");

// console.log(str);

// var str=new String("hello");

// str=str.replace("ll","HH");

// console.log(str);

// str=null;

// var num=10;//number---->

// console.log(num.toString())

//如果是一个对象&&true,那么结果是true

//如果是一个true&&对象,那么结果是对象

// var flag=new Boolean(false);

// var result=true&&flag;

// console.log(result);

实例对象:通过构造函数创建出来,实例化的对象
*静态对象:不需要创建,直接就是一个对象,方法(静态方法)直接通过这个对象名字调用,

实例方法必须通过实例对象调用

静态方法必须通过大写的对象调用

>Math.PI----π---

>Math.E----常数的底数

>Math.abs(值)-----绝对值

>Math.ceil(值)----向上取整

>Math.floor(值)---向下取整
————————————————

数组的基本使用方法

concat()方法可以基于当前数组中的所有项创建一个新数组1. concat() ：数组拼接

　　1) 当参数是数组：将参数数组拼接在原始数组后面；

　　2）当参数非数组：将参数每一项一次拼接在原始数组后面

　　 var colors = ["red", "green", "blue"];
    var colors2 = colors.concat("yellow", ["black", "brown"]);    alert(colors);     //red,green,blue

    alert(colors2);    //red,green,blue,yellow,black,brown
2.slice() ：数组截取，接受1个或2个参数（返回项的起始和结束位置）

　基于当前数组中的一或多个项创建一个新数组

　　1）当只有一个参数：参数为截取的起始位置下标（包含此项），一直截取到原始数据最后

　　2）当有两个参数：第一个参数代表起始位置下标（包含此项），第二个参数代表结束位置下标（不包含此项）（下标含前不含后）

　　　　var colors = ["red", "green", "blue", "yellow", "purple"];
　　　　var colors2 = colors.slice(1);
　　　　var colors3 = colors.slice(1,4);

　　　　alert(colors2);   //green,blue,yellow,purple
　　　　alert(colors3);   //green,blue,yellow
3.splice() ：号称最强大的数组方法
　　三种使用方式
　　　　1）删除
　　　　　可以删除任意数量的项，只需指定 2 个参数:要删除的第一项的位置和要删除的项数。
　　　　　　 例如，splice(0,2)会删除数组中的前两项。
　　　　2）插入
　　　　　可以向指定位置插入任意数量的项，只需提供 3 个参数:起始位置、0(要删除的项数) 和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。
　　　　　　例如， splice(2,0,"red","green")会从当前数组的位置 2 开始插入字符串"red"和"green"。
　　　　3）替换
　　　　　可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数:起 始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
　　　　　　例如， splice (2,1,"red","green")会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串 "red"和"green"。

　　splice()方法始终都会返回一个数组，该数组中包含从原始数组中删除的项(如果没有删除任何 项，则返回一个空数组)。下面的代码展示了上述 3 种使用 splice()方法的方式。

var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1); // 删除第一项

alert(colors); // green,blue

alert(removed); // red，返回的数组中只包含一项

removed = colors.splice(1, 0, "yellow", "orange"); // 从位置 1 开始插入两项

alert(colors); // green,yellow,orange,blue

alert(removed); // 返回的是一个空数组

removed = colors.splice(1, 1, "red", "purple"); // 插入两项，删除一项

alert(colors); // green,red,purple,orange,blue

alert(removed); // yellow，返回的数组中只包含一项

数组常用的方法filter、map、forEach、every、some

1 var arr=[1,2,3,4];
2 console.log( arr.map((n)=>n*n) );//[1, 4, 9, 16]
3 console.log( arr.map((n)=>n-1) );//[0, 1, 2, 3]

从数组[1，4，-5，10]当中给我找出小于0的数字。在你看到这里的时候相信你也是对箭头函数了解，(n)=>n*n 就不用赘述了。

filter方法：

 1 var users = [
 2   {name: "张含韵", "email": "zhang@email.com"},
 3   {name: "江一燕",   "email": "jiang@email.com"},
 4   {name: "李小璐",  "email": "li@email.com"}
 5 ];
 6 //获取所有人的email
 7 var emails=users.map(user=>user.email) 
 8 console.log(emails.join(',')) //"zhang@email.com", "jiang@email.com", "li@email.com"
 9 //获取指定人的email
10 var liEmail=emails.filter(email=>/^li/.test(email))
11 console.log(liEmail.join('')) //li@email.com

获取用户列表里的所有用户的email，map帮我们做到了，map方法通过传一个形参，这个形参就代表users里的每一项，map内部通过遍历所有的用户项，获取到每个用户项的email，再push到一个数组，再作为值给我们返回。第二步，我们需要获取指定人的email，filter方法登场了，通过过滤筛选email是数组，给我们返回结果，筛选方法得我们定，这里筛选方法是以正则匹配到li开头的那一个email，然后返回。

find方法：

1 [1, 4, -5, 10].find((n) => n < 0)    // -5

find方法比较好理解，这里的参数n代表数组里的每一项，然后find方法内部通过遍历数组里的每一项，找到＜0的这一项( - 5 )。

findIndex方法：find方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。看一个例子：

1 [1, 4, -5, 10].findIndex((value,index,arr) => value < 0)  // 2

在这个例子当中，value代表这个数组的每一项，1，4，-5，10。index代表每一项的索引值，arr代表这个数组[1, 4, -5, 10]，然后我们需要返回的是＜0的这一项的索引值，即是2了。

这4个方法内部机制都有一个遍历过程，比起forEach确实简洁多了。

接着补充ES6-some( ) 和 every( )方法的讲解:

 1     //every()
 2     let numbers = [2, 4, 10, 4, 8];
 3     let a = numbers.every((item,index)=>{
 4         if(item%2===0){
 5             return true;
 6         }else{
 7             return false;
 8         }
 9     });
10     console.log(a)
11 
12     //some()
13     let b=numbers.some((item,index)=>{
14          if(item%3===0){
15             return true;
16         }else{
17             return false;
18         }
19     })
20     console.log(b)

some 英语翻译为一些,every翻译为所有,每个，所以some方法只要其中一个为true 就会返回true的，相反，every（）方法必须所有都返回true才会返回true，哪怕有一个false，就会返回false；every（）和 some（）目的：确定数组的所有成员是否满足指定的测试。具体请参考MDNhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some

后续补充：最近看很多小伙伴都在学习ES6，比如ES6中的map，在ES5中是怎么实现的呢？

  1 /*
  2  * MAP对象，实现MAP功能
  3  *
  4  * 接口：
  5  * size()                     获取MAP元素个数
  6  * isEmpty()                  判断MAP是否为空
  7  * clear()                    删除MAP所有元素
  8  * put(key, value)            向MAP中增加元素（key, value) 
  9  * remove(key)                删除指定KEY的元素，成功返回True，失败返回False
 10  * get(key)                   获取指定KEY的元素值VALUE，失败返回NULL
 11  * element(index)             获取指定索引的元素（使用element.key，element.value获取KEY和VALUE），失败返回NULL
 12  * containsKey(key)           判断MAP中是否含有指定KEY的元素
 13  * containsValue(value)       判断MAP中是否含有指定VALUE的元素
 14  * values()                   获取MAP中所有VALUE的数组（ARRAY）
 15  * keys()                     获取MAP中所有KEY的数组（ARRAY）
 16  *
 17  * 例子：
 18  * var map = new Map();
 19  *
 20  * map.put("key", "value");
 21  * var val = map.get("key")
 22  * ……
 23  *
 24  */
 25 function Map() {
 26     this.elements = new Array();
 27 
 28     //获取MAP元素个数
 29     this.size = function() {
 30         return this.elements.length;
 31     };
 32 
 33     //判断MAP是否为空
 34     this.isEmpty = function() {
 35         return (this.elements.length < 1);
 36     };
 37 
 38     //删除MAP所有元素
 39     this.clear = function() {
 40         this.elements = new Array();
 41     };
 42 
 43     //向MAP中增加元素（key, value) 
 44     this.put = function(_key, _value) {
 45         this.elements.push( {
 46             key : _key,
 47             value : _value
 48         });
 49     };
 50 
 51     //删除指定KEY的元素，成功返回True，失败返回False
 52     this.removeByKey = function(_key) {
 53         var bln = false;
 54         try {
 55             for (i = 0; i < this.elements.length; i++) {
 56                 if (this.elements[i].key == _key) {
 57                     this.elements.splice(i, 1);
 58                     return true;
 59                 }
 60             }
 61         } catch (e) {
 62             bln = false;
 63         }
 64         return bln;
 65     };
 66     //删除指定KEY的所有元素
 67     this.removeAllByKey=function(_key){
 68         for (var i = this.elements.length - 1; i >= 0; i--) {
 69             if (this.elements[i].key == _key) {
 70                 this.elements.splice(i, 1);
 71             }
 72         }
 73     }
 74     
 75     //删除指定VALUE的元素，成功返回True，失败返回False
 76     this.removeByValue = function(_value) {//removeByValueAndKey
 77         var bln = false;
 78         try {
 79             for (i = 0; i < this.elements.length; i++) {
 80                 if (this.elements[i].value == _value) {
 81                     this.elements.splice(i, 1);
 82                     return true;
 83                 }
 84             }
 85         } catch (e) {
 86             bln = false;
 87         }
 88         return bln;
 89     };
 90     
 91     //删除指定VALUE的元素，成功返回True，失败返回False
 92     this.removeByValueAndKey = function(_key,_value) {
 93         var bln = false;
 94         try {
 95             for (i = 0; i < this.elements.length; i++) {
 96                 if (this.elements[i].value == _value && this.elements[i].key == _key) {
 97                     this.elements.splice(i, 1);
 98                     return true;
 99                 }
100             }
101         } catch (e) {
102             bln = false;
103         }
104         return bln;
105     };
106 
107     //获取指定KEY的所有元素值VALUE，以数组形式返回,失败返回false
108     this.get = function(_key) {
109         var arr=[];
110         try {
111             for (i = 0; i < this.elements.length; i++) {
112                 if (this.elements[i].key == _key) {
113                     arr.push(this.elements[i].value)
114                 }
115             }
116             return arr;
117         } catch (e) {
118             return false;
119         }
120         return false;
121     };
122 
123     //获取指定索引的元素（使用element.key，element.value获取KEY和VALUE），失败返回NULL
124     this.element = function(_index) {
125         if (_index < 0 || _index >= this.elements.length) {
126             return null;
127         }
128         return this.elements[_index];
129     };
130 
131     //判断MAP中是否含有指定KEY的元素
132     this.containsKey = function(_key) {
133         var bln = false;
134         try {
135             for (i = 0; i < this.elements.length; i++) {
136                 if (this.elements[i].key == _key) {
137                     bln = true;
138                 }
139             }
140         } catch (e) {
141             bln = false;
142         }
143         return bln;
144     };
145 
146     //判断MAP中是否含有指定VALUE的元素
147     this.containsValue = function(_value) {
148         var bln = false;
149         try {
150             for (i = 0; i < this.elements.length; i++) {
151                 if (this.elements[i].value == _value) {
152                     bln = true;
153                 }
154             }
155         } catch (e) {
156             bln = false;
157         }
158         return bln;
159     };
160     
161     //判断MAP中是否含有指定key,VALUE的元素
162     this.containsObj = function(_key,_value) {
163         var bln = false;
164         try {
165             for (i = 0; i < this.elements.length; i++) {
166                 if (this.elements[i].value == _value && this.elements[i].key == _key) {
167                     bln = true;
168                 }
169             }
170         } catch (e) {
171             bln = false;
172         }
173         return bln;
174     };
175 
176     //获取MAP中所有VALUE的数组（ARRAY）
177     this.values = function() {
178         var arr = new Array();
179         for (i = 0; i < this.elements.length; i++) {
180             arr.push(this.elements[i].value);
181         }
182         return arr;
183     };
184     //获取MAP中所有指定VALUE的元素数组（ARRAY）
185     this.getAllByValue=function(_value){
186         var arr=[];
187         for (var i = this.elements.length - 1; i >= 0; i--) {
188             if (this.elements[i].value == _value) {
189                 arr.push(this.elements[i]);
190             }
191         }
192         return arr;   
193     }
194     
195     //获取MAP中指定key的所有VALUE的数组（ARRAY）
196     this.valuesByKey = function(_key) {
197         var arr = new Array();
198         for (i = 0; i < this.elements.length; i++) {
199             if (this.elements[i].key == _key) {
200                 arr.push(this.elements[i].value);
201             }
202         }
203         return arr;
204     };
205 
206     //获取MAP中所有KEY的数组（ARRAY）
207     this.keys = function() {
208         var arr = new Array();
209         for (i = 0; i < this.elements.length; i++) {
210             arr.push(this.elements[i].key);
211         }
212         return arr;
213     };
214     
215     //获取key通过value
216     this.keysByValue = function(_value) {
217         var arr = new Array();
218         for (i = 0; i < this.elements.length; i++) {
219             if(_value == this.elements[i].value){
220                 arr.push(this.elements[i].key);
221             }
222         }
223         return arr;
224     };
225     
226     //获取MAP中所有KEY的数组（ARRAY）key有相同的 取出的key为去重后的 数组里去重后的key的数组
227     this.keysRemoveDuplicate = function() {
228         var arr = new Array();
229         for (i = 0; i < this.elements.length; i++) {
230             var flag = true;
231             for(var j=0;j<arr.length;j++){
232                 if(arr[j] == this.elements[i].key){
233                     flag = false;
234                     break;
235                 } 
236             }
237             if(flag){
238                 arr.push(this.elements[i].key);
239             }
240         }
241         return arr;
242     };
243 }

数组常用遍历的方法filter、map、forEach、every、some。

1、filter：把符合条件的数组项返回，形成一个数组

var arrayObj = [15,3,2,6,7,1,9,10];
var result = arrayObj.filter(function(item,index,array){
       return item > 7;
 });//[15,9,10]

2、map：利用某规则映射得到一个新数组

var arrayObj = [15,3,2];
var result = arrayObj.map(function(item, index, array){
     return 2*item;
});//[30,6,4]

3、forEach：遍历数组，只是遍历，没有返回值，相当于for循环

var arrayObj = [15,3,2];
arrayObj.forEach(function(item, index, array){
    ……
});

4、every：数组中所有元素都满足满足条件，就返回true；有一个为false，就为false

var arrayObj = [15,3,2,6,7,1,9,10];
var result =arrayObj.every(function(item,index,array){
      return item > 1 ;   
});//false

5、some：数组中部分元素满足条件，返回true；有一个为true，就为true

var arrayObj = [15,3,2,6,7,1,9,10];
var result =arrayObj.some(function(item,index,array){
     return item > 10;
});//true

声明数组：

let list = new Array()

list[0] = 0;

list[1] = 1;

list[2] = 2;

或者这样声明：let list = [0,1,2]

或者let d = Array.of(1,2,3); console.log(d) [1,2,3]

(1)基本的数组方法：

unshift：向数组开头增加一项，返回值是数组的新长度， 直接在原数组上操作的，不生成新数组

push：向数组的末尾增加一项，返回值是数组的新长度， 直接在原数组上操作的，不生成新数组

shift : 删除数组开头项，返回被删除的项，直接在原数组上操作的，不生成新数组

pop : 删除数组的末尾项，返回被删除的项，直接在原数组上操作的，不生成新数组

includes [1,2,3].includes(2);//true [1,2,3].includes(4);//false

indexof

var beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];

console.log(beasts.indexOf('bison'));

// expected output: 1

// start from index 2

console.log(beasts.indexOf('bison', 2));

// expected output: 4

console.log(beasts.indexOf('giraffe'));

// expected output: -1

splice（2,3）：从下标为2（包含2）的项开始切取3项；如果只传一个参数那就是切到最后

splice(start,deleteCount,val1,val2,...)：从start位置开始删除deleteCount项，并从该位置起插入val1,val2,... (切除并插值)

直接在原数组上操作的，返回值是切下的元素新组成的数组

var a = [1,2,3,4,5,6,7,8]; var a = [1,2,3,4,5,6,7,8]; var a = [1,2,3,4,5,6,7,8];

var b = a.splice(2,3); var b = a.splice(2,3,9,10); var b = a.splice(2);

console.log(a) [1,2,6,7,8] console.log(a) [1,2,9,10,6,7,8] console.log(a) [1,2]

console.log(b) [3,4,5] console.log(b) [3,4,5] console.log(b) [3,4,5,6,7,8]

slice （2,4）：从下标为2（包含2）的项开始切，直到下标为4停止(不包含4)，如果只传一个参数那就是切到最后

原数组不变，返回值是切下的元素新组成的数组

var a = [1,2,3,4,5,6,7,8]; var a = [1,2,3,4,5,6,7,8];

var b = a.slice(2,4); var b = a.slice(2);

console.log(a) [1,2,3,4,5,6,7,8] console.log(a) [1,2,3,4,5,6,7,8]

console.log(b) [3,4] console.log(b) [3,4,5,6,7,8]

concat:把一个数组和另一个数组拼接在一起返回拼接好的数组 原数组不变，返回新的数组

var a = [1,2,3,4,5,6,7,8];

var b = [9,10,11];

var c = a.concat(b);

console.log(a) [1,2,3,4,5,6,7,8]

console.log(b) [9,10,11]

console.log(c) [1,2,3,4,5,6,7,8,9,10,11]

join: 把数组中的每一项按照指定的分隔符拼接成字符串

原数组不变，返回新的数组

var a = [1,2,3,4,5,6,7,8]; var a = [1,2,3,4,5,6,7,8];

var c = a.join(''); var c = a.join('|');

console.log(a) [1,2,3,4,5,6,7,8] console.log(a) [1,2,3,4,5,6,7,8]

console.log(c) 12345678 console.log(c) 1|2|3|4|5|6|7|8

reverse：将数组反序

原数组改变，返回新的数组就是反序后的数组

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

var b = a.reverse();

console.log(a) [5,4,3,2,1]

console.log(b) [5,4,3,2,1]

toString： 可把数组转换为字符串，并返回结果

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

var b = a.toString();

console.log(a) [1,2,3,4,5]

console.log(b) 1,2,3,4,5

sort(orderfunction)：方法将数组中的元素排序并返回排序后的数组

原数组也改变，返回重新排序后的新数组

var a = [9,2,4,3,5,8,7,6];

var c = a.sort();

console.log(a) [2, 3, 4, 5, 6, 7, 8, 9]

console.log(c) [2, 3, 4, 5, 6, 7, 8, 9]

当不带参数时，默认按照顺序排序，也就是从小到大。当然，也可以直接给sort加一个比较函数比较

var arr = [1,4,7];

arr.sort();

console.log(arr);//[1,4,7]

arr.sort(function(a,b){

returna-b;//从小到大

});

console.log(arr);//[1,4,7]

arr.sort(function(a,b){

returnb-a;//从大到小

});

console.log(arr);//[7,4,1]

varnum =newArray('one','three','Six','Five');

num.sort();//区分大小写排序

console.log(num);// ["Five", "Six", "one", "three"]

num.sort(function(s,t){

vara = s.toLowerCase();

varb = t.toLowerCase();

if(a<b) return -1

if(a>b) return 1;

return0;

});

console.log(num);// ["Five", "one", "Six", "three"]

2）ECMAScript5中的数组方法

这一类数组方法大多数有统一大致的规则。它们都不会修改原始数组。

大多数方法的第一个参数接收一个函数，并且对数组的每个元素（或一些元素）调用一次该函数。

如果是稀疏数组，对不存在的元素不调用传递的函数；

在大多数情况下，调用的这个函数一般使用三个参数：数组元素、元素的索引、数组本身。通常后两个参数也不需要填写进去。

除了这里第一个参数（函数）之外，还有第二个参数（它是可选的），如果第二个参数存在，则调用的函数将被看做是第二个参数的方法。

也就是说，在调用函数时传递进去的第二个参数作为它的this关键字的值来使用。

1.forEach()

这个方法从头至尾遍历数组，为每个数组调用指定的函数。

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

var sum = 0;

data.forEach(function(value){//只使用了第一个参数（函数），调用的函数也只使用了第一个参数数组元素

sum += value;

});

console.log(sum); //15

console.log(data); // [1, 2, 3, 4, 5]

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

var sum = 0;

data.forEach(function(value,item,data){//调用的函数具有了三个参数

data[item] = value*value;//取平方

});

console.log(data); // [1, 4, 9, 16, 25]

2.map()

这个方法将调用的数组中每个元素传递给指定的函数，并返回一个数组，它包含这个函数的返回值。

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

var data1 = data.map(function(value){

return++ value;

});

console.log(data); // [1, 2, 3, 4, 5]

console.log(data1); // [2, 3, 4, 5, 6]

3.filter()

这个方法返回的数组元素是调用的数组的一个子集。传递的函数是用来逻辑判定的，该函数返回true或false。

如果返回值是true或者能转化为true的值，那么传递给判定函数的元素就是这个子集的成员，它将被添加到一个作为返回值的数组中。

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

var data1 = data.filter(function(value){

returnvalue <= 3;

});

vardata2 = data.filter(function(value){

returnvalue > 3;

});

console.log(data); // [1, 2, 3, 4, 5]

console.log(data1); // [1,2,3]

console.log(data2); // [4,5]

4.every()和some()

顾名思义，every()就是数组中所以元素都满足函数指定的条件时返回true; some()就是某一项满足时就返回 true

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

var data1 = data.every(function(value){

returnvalue < 4;

});

var data2 = data.some(function(value){

returnvalue >4;

});

console.log(data); // [1, 2, 3, 4, 5]

console.log(data1); // false

console.log(data2); // true

5.reduce()和reduceRight()

这两个方法使用指定的函数将数组元素进行组合，生成单个值。

reduce()有两个参数。第一个是执行化简操作的函数，就是说用某种方法把两个值化简为一个值，并返回化简后的值。

第二个参数可选，用来传递给第一个参数函数作为初始值。如果第二个参数没有，则初始值就使用数组的第一个元素值。

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

var sum = data.reduce(function(a,b){

returna+b;

});

varsum1 = data.reduce(function(a,b){

returna+b;

},5);

var min = data.reduce(function(a,b){

return(a

});

console.log(data); // [1, 2, 3, 4, 5]

console.log(sum); // 15

console.log(sum1); // 20

console.log(min);// 1

sum中没有第二个参数，所以初始值为第一个数组元素，第一步1+2=3，第二步3+3=6... 最后得15

sum1中有第二个参数，所以初始值为5，第一步5+1=6，第二步6+2=8... 最后得20

reduceRight()和reduce()差不多，不同的是它按照数组索引从高到低（从右到左）处理数组，而不是正常的从低到高。

var data = ['a','b','c'];

var str = data.reduce(function(x,y){//顺序

returnx+y;

});

var str1 = data.reduceRight(function(x,y){//逆序

returnx+y;

});

console.log(data); // [1, 2, 3]

console.log(str); //"abc"

console.log(str1); //"cba"

6.indexOf()和lastIndexOf()

这个方法搜索整个数组中具有给定值的元素，返回找到的元素的索引（找到了一个就退出了），没有找到则返回-1.

一个从头至尾，一个从尾至头

var data = ['a','b','a','c','a'];

console.log(data.indexOf('a')); //0

console.log(data.indexOf('d')); //-1

console.log(data.lastIndexOf('a')); //4

console.log(data.lastIndexOf('a',-2)); //2 从倒数第二个开始

console.log(data.lastIndexOf('a',1)); //0 从顺序第二个往前

7.数组类型 isArray()

判断一个对象是不是数组

console.log(Array.isArray([])); //true

console.log(Array.isArray({})); //false

//模拟上边的

varisArray1 = Function.isArray||function(o){

returntypeofo ==="object"&&

Object.prototype.toString.call(o) ==="[object Array]";

};

console.log(isArray1([])); //true

console.log(isArray1({})); //false

8.数组includes()

判断数组是否包含某个元素，如果包含则返回true,不包含返回false

var a = [9,2,4,3,5,6,7,8];

var c = a.includes(3);

console.log(a) [9,2,4,3,5,6,7,8]

console.log(c) true

9.数组find()

Array.find(function(v,i,arr),thisArgs}

数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

v：数组值

i：索引

arr：当前数组

thisArgs：fn函数中this指向

var re = [1,2,3,4].find(function(v,i,arr){

console.log(arr); //[1,2,3,4]

console.log(this); //{this: 'this'}

returnv>=2;

},{this:'this'})

console.log(re); //2

var re2 = [1,2,3,4].find(function(v,i,arr){

console.log(this); //{0: "_", 1: "t", 2: "h", 3: "i", 4: "s", length: 5}

returnv>=10;

},'_this')

console.log(re2); //undefined

Object

obj= {

"aa" : 123,

"bb" : 564,

"cc" : 989

}

var keysArr = Object.keys(obj) //返回一个包含对象key值的数组

console.log(keysArr) // ['aa' , 'bb' ,'cc']

循环对象

作者：hk_sky
链接：https://www.jianshu.com/p/f55912c20cf1
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

数组处理方法总结（操作方法）

数组常用的方法filter、map、forEach、every、some

1、filter：把符合条件的数组项返回，形成一个数组

var arrayObj = [15,3,2,6,7,1,9,10];
var result = arrayObj.filter(function(item,index,array){
       return item > 7;
 });//[15,9,10]

2、map：利用某规则映射得到一个新数组

var arrayObj = [15,3,2];
var result = arrayObj.map(function(item, index, array){
     return 2*item;
});//[30,6,4]

3、forEach：遍历数组，只是遍历，没有返回值，相当于for循环

var arrayObj = [15,3,2];
arrayObj.forEach(function(item, index, array){
    ……
});

4、every：数组中所有元素都满足满足条件，就返回true；有一个为false，就为false

var arrayObj = [15,3,2,6,7,1,9,10];
var result =arrayObj.every(function(item,index,array){
      return item > 1 ;   
});//false

5、some：数组中部分元素满足条件，返回true；有一个为true，就为true

var arrayObj = [15,3,2,6,7,1,9,10];
var result =arrayObj.some(function(item,index,array){
     return item > 10;
});//true

posted @ 2019-08-21 22:59 wen521 阅读(395) 评论(0) 编辑收藏举报

刷新页面返回顶部

WL11

数组方法总结常用数组方法总结 js的数组或对象常用方法总结

concat()方法可以基于当前数组中的所有项创建一个新数组1. concat() ：数组拼接

数组常用的方法filter、map、forEach、every、some

数组常用遍历的方法filter、map、forEach、every、some。

声明数组：

(1)基本的数组方法：

2）ECMAScript5中的数组方法

Object

数组处理方法总结（操作方法）

数组常用的方法filter、map、forEach、every、some

公告

WL11

数组方法总结 常用数组方法总结 js的数组或对象常用方法总结

concat()方法可以基于当前数组中的所有项创建一个新数组1. concat() ：数组拼接

数组常用的方法filter、map、forEach、every、some

数组常用遍历的方法filter、map、forEach、every、some。

声明数组：

(1)基本的数组方法：

2）ECMAScript5中的数组方法

Object

数组处理方法总结（操作方法）

数组常用的方法filter、map、forEach、every、some

公告

数组方法总结常用数组方法总结 js的数组或对象常用方法总结