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、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 |