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

时间：2019-08-22 00:46:08 阅读：103 评论：0 收藏：0 [点我收藏+]

标签：length max arc bar 学习 text 大小著作权 amp

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 }

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

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

这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)

后续补充：最近看很多小伙伴都在学习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 }

声明数组：

(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

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

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

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

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

声明数组：

(1)基本的数组方法：

2）ECMAScript5中的数组方法

Object

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

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

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

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

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

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

声明数组：

(1)基本的数组方法：

2）ECMAScript5中的数组方法

Object

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

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

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