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

Posted bgml

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数组方法总结 常用数组方法总结 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 






































 


 








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：把符合条件的数组项返回，形成一个数组














1


2


3


4






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：利用某规则映射得到一个新数组














1


2


3


4






var arrayObj = [15,3,2];


var result = arrayObj.map(function(item, index, array)


     return 2*item;


);//[30,6,4]
















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














1


2


3


4






var arrayObj = [15,3,2];


arrayObj.forEach(function(item, index, array)


    ……


);
















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














1


2


3


4






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














1


2


3


4






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：把符合条件的数组项返回，形成一个数组














1


2


3


4







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：利用某规则映射得到一个新数组














1


2


3


4







var arrayObj = [15,3,2];


var result = arrayObj.map(function(item, index, array)


     return 2*item;


);//[30,6,4]
























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














1


2


3


4







var arrayObj = [15,3,2];


arrayObj.forEach(function(item, index, array)


    ……


);
























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














1


2


3


4







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














1


2


3


4







var arrayObj = [15,3,2,6,7,1,9,10];


var result =arrayObj.some(function(item,index,array)


     return item > 10;


);//true




























以上是关于数组方法总结  常用数组方法总结  js的数组或对象常用方法总结的主要内容，如果未能解决你的问题，请参考以下文章
 

 js中数组常用的方法总结汇总


 js与jquery常用数组方法总结


 js数组常用方法总结


 js中数组Array的一些常用方法总结


 js数组常用方法总结(包括ES6)


 js数组常用方法总结(包括ES6)