ES6常用数据类型方法总结

数组方法总结

//获取某个下标可以直接 arr[下标] 修改可以arr[下标]=?

1.splice从某一下标开始删除后多少位

数组名.splice( ? , ? ) 参数一(给一个下标) 参数二(一个数字,意为从某个小标开始往后删除多少个)

第三个参数加上为替换

splice(index,len,[item])    注释：该方法会改变原始数组。

splice有3个参数，它也可以用来<替换/删除/添加>数组内某一个或者几个值

index:数组开始下标        len: 替换/删除的长度       item:替换的值，删除操作的话 item为空

如：arr = [‘a‘,‘b‘,‘c‘,‘d‘]

<删除> ----  item不设置

arr.splice(1,1)   //[‘a‘,‘c‘,‘d‘]         删除起始下标为1，长度为1的一个值，len设置的1，如果为0，则数组不变

arr.splice(1,2)  //[‘a‘,‘d‘]          删除起始下标为1，长度为2的一个值，len设置的2

<替换> ---- item为替换的值

arr.splice(1,1,‘ttt‘)        //[‘a‘,‘ttt‘,‘c‘,‘d‘]         替换起始下标为1，长度为1的一个值为‘ttt’，len设置的1

arr.splice(1,2,‘ttt‘)        //[‘a‘,‘ttt‘,‘d‘]         替换起始下标为1，长度为2的两个值为‘ttt’，len设置的1

<添加> ----  len设置为0，item为添加的值

arr.splice(1,0,‘ttt‘)        //[‘a‘,‘ttt‘,‘b‘,‘c‘,‘d‘]         表示在下标为1处添加一项‘ttt’

2.arr.every(callback) 依据判断条件，数组的元素是否全满足，若满足则返回ture

let arr = [1,2,3,4,5]
 
let arr1 = arr.every( (i, v) => i < 3)
 
console.log(arr1) // false
 
let arr2 = arr.every( (i, v) => i < 10)
 
console.log(arr2) // true

3.some 只要有一个符合条件,就返回true

4…find() 查找(返回值为第一个符合条件的元素)

5.arr.filter(callback) 过滤数组，返回一个满足要求的数组

let arr = [1,2,3,4,5]
 
let arr1 = arr.filter( (i, v) => i < 3)
 
console.log(arr1) // [1, 2]

 

6.reduce() 将数组元素计算为一个值（从左到右），常用于累加，累乘

var numArr=[1,2,3,4];
numArr.reduce(function(prev,current){
    return prev+current;
})
console.log(numArr) //10

7.arr.push() 从后面添加元素，返回值为添加完后的数组的长度

let arr = [1,2,3,4,5]
 
console.log(arr.push(5)) // 6
 
console.log(arr) // [1,2,3,4,5,5]

**8.arr.pop() 从后面删除元素，只能是一个，返回值是删除的元素

let arr = [1,2,3,4,5]
 
console.log(arr.pop()) // 5
 
console.log(arr) //[1,2,3,4]

9.arr.shift()从前面删除,第一个

10.arr.unshift() 从前面添加元素, 返回值是添加完后的数组的长度

let arr = [1,2,3,4,5]
 
console.log(arr.unshift(2)) // 6
 
console.log(arr) //[2,1,2,3,4,5]

11.arr.concat() 连接两个数组 返回值为连接后的新数组

let arr = [1,2,3,4,5]
 
console.log(arr.concat([1,2])) // [1,2,3,4,5,1,2]
 
console.log(arr) // [1,2,3,4,5] 

12.str.split() 将字符串转化为数组

let str = '123456'
 
console.log(str.split('')) // ["1", "2", "3", "4", "5", "6"]

13.arr.sort() 将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的，见例子。

let arr = [2,10,6,1,4,22,3]
 
console.log(arr.sort()) // [1, 10, 2, 22, 3, 4, 6]
 
let arr1 = arr.sort((a, b) =>a - b)
 
console.log(arr1) // [1, 2, 3, 4, 6, 10, 22]
 
let arr2 = arr.sort((a, b) =>b-a)
 
console.log(arr2) // [22, 10, 6, 4, 3, 2, 1]

14.arr.reverse() 将数组反转,返回值是反转后的数组

let arr = [1,2,3,4,5]
 
console.log(arr.reverse()) // [5,4,3,2,1]
 
console.log(arr) // [5,4,3,2,1]

15.arr.slice(start,end) 切去索引值start到索引值end的数组，不包含end索引的值，返回值是切出来的数组

let arr = [1,2,3,4,5]
 
console.log(arr.slice(1,3)) // [2,3]
 
console.log(arr) // [1,2,3,4,5]

16.arr.forEach(callback) 遍历数组,无return

*注意：（伪数组转成真数组才能遍历 Array.prototype.slice.call(伪数组) ）

​ callback的参数： value --当前索引的值

index --索引

array --原数组

let arr = [1,2,3,4,5]
 
arr.forEach( (value,index,array)=>{
 
console.log(`value:${value} index:${index} array:${array}`)
 
})
 
// value:1 index:0 array:1,2,3,4,5
 
// value:2 index:1 array:1,2,3,4,5
 
// value:3 index:2 array:1,2,3,4,5
 
// value:4 index:3 array:1,2,3,4,5
 
// value:5 index:4 array:1,2,3,4,5
 
 
let arr = [1,2,3,4,5]
 
arr.forEach( (value,index,array)=>{
 
value = value * 2
 
console.log(`value:${value} index:${index} array:${array}`)
 
})
 
console.log(arr)
 
// value:2 index:0 array:1,2,3,4,5
 
// value:4 index:1 array:1,2,3,4,5
 
// value:6 index:2 array:1,2,3,4,5
 
// value:8 index:3 array:1,2,3,4,5
 
// value:10 index:4 array:1,2,3,4,5
 
// [1, 2, 3, 4, 5]

17.arr.map(callback) 映射数组(遍历数组),有return 返回一个新数组

callback的参数： value --当前索引的值

index --索引

array --原数组

 
let arr = [1,2,3,4,5]
 
arr.map( (value,index,array)=>{
 
value = value * 2
 
console.log(`value:${value} index:${index} array:${array}`)
 
})
 
console.log(arr)

18.arr.indexOf() 查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1

let arr = [1,2,3,4,5,2]
 
let arr1 = arr.indexOf(2)
 
console.log(arr1) // 1
 
let arr2 = arr.indexOf(9)
 
console.log(arr2) // -1

19.arr.lastIndexOf() 和arr.indexOf()的功能一样，不同的是从后往前查找

20.Array.from() 将伪数组变成数组，就是只要有length的就可以转成数组

let str = '12345'
 
console.log(Array.from(str)) // ["1", "2", "3", "4", "5"]
 
let obj = {0:'a',1:'b',length:2}
 
console.log(Array.from(obj)) // ["a", "b"]

21.arr.includes() 判断数中是否包含给定的值

let arr = [1,2,3,4,5]
 
let arr1 = arr.includes(2)
 
console.log(arr1) // ture
 
let arr2 = arr.includes(9)
 
console.log(arr2) // false
 
let arr3 = [1,2,3,NaN].includes(NaN)
 
console.log(arr3) // true

ps:与indexOf()的区别：

1 indexOf()返回的是数值，而includes()返回的是布尔值

2 indexOf() 不能判断NaN，返回为-1 ，includes()则可以判断

ES6快速删除数组中指定元素的方法

let arr =[{id:1},{id:2},{id:3},{id:8}]
let id = 8
arr.splice(arr.findIndex(item => item.id === id), 1) // [{id:1},{id:2},{id:3}]
arr.findIndex(item => item.id === id)//获取获取id=8的那个对象的下标

对象方法总结

修改对象的某个属性的值可以obj.键=?

1.assgin()把几个对象合并为一个对象,主要为合并属性

const obj = { a: 1 };

let citys = { name: "杭州" };

let container = { des: '你好,heelo' }


let last_obj = Object.assign(obj,citys,container)

console.log(last_obj); 


第二种情况
    const a={a:12,b:13}
    const b={a:116,c:15}
    const assign = Object.assign(a, b);
    console.log(assign)//{a: 116, b: 13, c: 15}

2.获取对象键的集合

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)

3.获取对象值得集合

var obj = { foo: 'bar', baz: 42 };
Object.values(obj)

4.for … in 遍历对象

const a={a:12,b:13}
for (let axValue in a) {
      console.log(axValue)//  循环两次分别打印 a  b
    }
    

5.把对象遍历为集合的形式

///Object.entries遍历键值对
let obj = {a:1,b:2,c:function(){}};
Object.entries(obj); [['a',1],['b', 2], ['c',f]返回对象键值对数组

6.解构一个对象,也就是把这个对象里面的某个对应的键拿出来

const values = {supplierId:12,personId:12}
const {supplierId, personId} = values;
此时supplierId=12      personId=12

Map方法总结

1.Map基本使用

let m = new Map();
m.set('c', 'content')
m.get('c')//content
m.size//1
m.has('c') // true
m.delete('c')
m.has('c')
m.clear()

2.Map结构和数组结构之间的转换

let map = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
]);
[...map.keys()]// [1, 2, 3]
[...map.values()]// ['one', 'two', 'three']
[...map.entries()]// [[1,'one'], [2, 'two'], [3, 'three']]
[...map]// [[1,'one'], [2, 'two'], [3, 'three']]

3.Map 循环遍历

Map 原生提供三个遍历器:

• keys()：返回键名的遍历器。
• values()：返回键值的遍历器。
• entries()：返回所有成员的遍历器。

let map = new Map([
  ['F', 'no'],
  ['T',  'yes'],
]);
for (let key of map.keys()) {
  console.log(key);
}
// "F"
// "T"
for (let value of map.values()) {
  console.log(value);
}
// "no"
// "yes"

4.js Map和java 的map不一样，内部是按顺序存储

const m = new Map();
m.set('key1', 'A');
m.set('key2', 'B');
m.set('keyn', 'N');
//获取第一个（这种方法只能获取第一个）
console.log(m.keys().next().value); // 'key1'
console.log(m.values().next().value); // 'A'
console.log(m.entries().next().value); // [ 'key1', 'A' ]
//获取任意一个没有直接方法，只能通过转换思路获取（这种方法可以获取任意一个）
// The key at index 2
let key = Array.from(m.keys())[2];// 'keyn'
// The value of the item at index 2
let val1 = m.get(key); // 'N'
//获取最后一个的一种方法
 Array.from(map.values()).pop();

5.合并多个map

let merged = new Map([...map1, ...map2, ...map3])

6.普通object转换成map

const map = new Map(Object.entries({foo: 'bar'}));
map.get('foo'); // 'bar'

7.删除前n个值

方法一:
aa = new Map(Array.from(aa).slice(3));

方法二:
for (let i = 0; i < 3; i ++) {
    aa.delete(aa.keys().next());
}

字符串

1.校验字符串中是否包含某字符

在ES6里面添加了一些字符串的方法：includes()、startsWith()、endsWith()，他们可以很方便的判断字符串里是否包含其他字符串；
 

includes()：是否包含了参数字符串，返回布尔值
startsWith()：参数字符串是否在原字符串的头部，返回布尔值
endsWith()：参数字符串是否在原字符串的尾部，返回布尔值
 

例子：
let dessert = 'cake',
drink = 'tea'
let breakfast =`今天的早餐是 ${dessert} 与 ${drink} !`;
 
console.log(breakfast.startsWith('今天')) //true
console.log(breakfast.endsWith('!')) //true
console.log(breakfast.includes('apple')) //false
 

这三个方法都支持第二个参数，表示开始搜索的位置。
console.log(breakfast.startsWith('今天',0)) //true
console.log(breakfast.endsWith('!',19)) //true
console.log(breakfast.includes('cake',5)) //true
 

注意：使用第二个参数时，endsWith的行为与其他两个方法有所不同。它针对前n个字符，而其他两个方法针对从第n个位置直到字符串结束。

题外

1.JSON转换

1.对象转为json
JSONObject.toJSON(Object)
2.json转为对象
Customer customer = JSONArray.parseObject(body, Customer.class);
3.list对象转为json
JSON.toJSONString(list)
4.json转为list对象
List<User> list = JSON.parseArray(json,User.class);

html标签

字体加粗：<b>写上你想bai写的字</b>

字du体加大zhi: <big>写上你想写的字</big>

字体控制大小：dao<h1>写上你想写的字</h1> (其中字体大小可从h1-h5,h1最大，h5最小)