码迷,mamicode.com
首页 > 编程语言 > 详细

数组方法总结 常用数组方法总结 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
技术图片

获取用户列表里的所有用户的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的数组或对象常用方法总结

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

原文地址:https://www.cnblogs.com/bgml/p/11391795.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
分享档案
周排行
mamicode.com排行更多图片
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!