数组方法总结
//获取某个下标可以直接 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) // true3.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) //107.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) // -119.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) // trueps:与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=12Map方法总结
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最小)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
