数组字符串对象的常用方法

陌路&情殇

已于 2023-05-12 16:19:56 修改

阅读量710

点赞数 1

文章标签： html linq p2p

于 2021-12-22 20:31:33 首次发布

本文链接：https://blog.csdn.net/hjdjhh/article/details/122094401

版权

reduce() 方法，为数组中的每一个元素依次执行回调函数

findIndex find 可以传入多种检索方法

intersection 返回所有传入数组的相同元素并组成新数组

union 返回所有传入数组拼接后的数组，并去重

uniq 数组去重

head / last 返回数组第一个元素与最后一个元素

深拷贝

对象方法

get 获取数据路径，防止重复判断路径，也可设置默认值

set 根据数据路径修改数据，会改变对象，路径不存在就创建

merge 合并对象，路径重复后者覆盖前者

数组

数组去重 只适用于简单数据 data = [...new Set(data)]

数组合并

第一种：let arr1 = arr1.concat(arr2,arr3)

第二种： [...arr1,...arr2,...arr3]

通过设置长度，移除数组中长度之后的数据

map 方法字典对象转下拉使用的数组

   this.disposeStatus = [
            ...Object.keys(dispose_status).map(item => ({
              label: dispose_status[item],
              value: item,
            })),
   ];

map 方法，数组转为数组对象

// 现有数组
let arr = ['你好'，'中国']；
this.options = states.map((item) => {
  return { value: `${item}`, label: `${item}` };
});
console.log(this.options)
// [{value:"你好",label:"你好"},{value:"中国",label:"中国"}]

sort排序的注意事项

1 sort 排序默认为是 a-b 即升序排序，而此时如果对应属性为 null ，或者无法进行排序，这个数据将会被放在最前方

let arr = [null,undefined,2,1,3];
arr.sort((a,b)=>{
  return a-b
});
console.log(arr)
// 
[null,undefined,1,2,3]

2 设置 sort 排序为 b-a ，即降序排序时，对应属性为 null 或无法进行排序，这个数据将会放在最后面，

let arr = [null,undefined,2,1,3];
arr.sort((a,b)=>{
  return b-a
});
console.log(arr)
// 
[3,2,1,null,undefined]

3 如果想要即是升序排序，而不能排列的值放在最后面时，可以使用以下方法

let arr = [null,undefined,2,1,3];
arr.sort((a, b)=> {
    return (b != null || b != undefined ) - (a != null || a != undefined) || a - b;
  });
console.log(arr)
// 
[1,2,3,null,undefined]

数组基本方法

pop() 数组末尾删除返回数组中被删除的元素

shift() 数组头部删除返回值是数组中被删除的元素

push() 数组末尾添加返回的是添加后的数组的长度

unShift() 数组头部添加返回的是添加后的数组的长度

reverse() 翻转数组

slice(a,b) 数组从第a个下标开始截取到下标b，包含a，不包含b，

返回值是被截取的数据

如果只有一个参数，从参数的下标直接截取到末尾不改变原数组

splice(a,b,c); 方法：从索引a开始截取b个元素，并用c替换截取的元素，并改变原来的数组

splice(a,b) 从索引a开始截取，截取b个元素，返回值是被截取的数据

concat() 用于拼接数组，不会改变原有数组使用： var arr2 = arr1.concat()

数组转字符串：数组名.join(‘分隔符’)

数组转对象

let arr =[a,b,c,d]   
var obj ={ ...arr }
//obj的值为 {0:a, 1:b, 2:c, 3:d}

ES5新增的一些方法

forEach 数组遍历

filter 数组内容过滤，返回一个新数组

some 查找数组中是否有满足条件的元素,只要有一个就返回true。

every 查找数组所有元素是否满足条件，全部满足返回true，有一个不满返false

trim 快捷方法去除字符串两端的空格

使用方法：

var newArr = arr.新增方法((item,i)=> { return 条件代码 })

item 当前元素 i 当前下标这里的return不能终止函数，只是用来设置返回值

ES6数组新增的扩展方法

Array.from() 将伪数组或可遍历对象转换为真正的数组

Array.find() 找到第一个符合条件就返回数据，没有就返回undefined

Array.findIndex() 找到第一个符合条件就返回下标，没有就返回-1

includes() 判断是否含有这个值，返回值为true和false

Array.fill() 用于数据的初始化和修改某一位置的数据

['a', 'b', 'c'].fill(7)
// [7, 7, 7]
new Array(3).fill(7)
// [7, 7, 7]  第一个参数表示填充的数据，默认全部修改
['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']  第二个和第三个参数，用于指定填充的起始位置和结束位置

Array.flat() 用于将数组中嵌套的数组拉平，该方法返回一个新数组，对原数据没有影响

[1, 2, [3, 4]].flat()
// [1, 2, 3, 4]  没有参数默认拉平一层
[1, 2, [3, [4, 5]]].flat(2)
// [1, 2, 3, 4, 5]  有参数表示想要拉平的层数
[1, [2, [3]]].flat(Infinity)
// [1, 2, 3]  表示不论有多少层，全都拉平
[1, 2, , 4, 5].flat()
// [1, 2, 4, 5] 有空格会跳过

reduce() 方法，为数组中的每一个元素依次执行回调函数

用来相加数组或对象的值

 let total = 0;
  '存储最后结果的变量' = '要累加的数组或对象'.reduce(function (
   pre,
   item
  ) {
    return pre + item.value;
  },
    total);

统计一个数组中有多少个不重复的单词

var arr = ["apple","orange","apple","orange","pear","orange"]; 
function getWordCnt(){ 
  return arr.reduce(function(prev,next){ 
    prev[next] = (prev[next] + 1) || 1; 
    return prev; 
  },{}); 
} 
console.log(getWordCnt());//{apple: 2, orange: 3, pear: 1}

数组求和

var arr = [1,5,8,6,15,78,65,25,48,55]
var sum = arr.reduce(function(total,currentValue){
  return total+currentValue;
});
console.log(sum);//306

合并二维数组

var twoArr = [['mu','zi'],['dig','big'],['lucky','jiji']];
var oneArr = twoArr.reduce(function(total,currentValue){
  return total.concat(currentValue);
})
console.log(oneArr);//["mu", "zi", "dig", "big", "lucky", "jiji"]

字符串

Math.PI（）圆周率 Math.abs（）绝对值，取正整数 Math.max（）最大值

Math.min（）最小值 Math.floor（）向下取整 Math.ceil（）向上取整

Math.round（）四舍五入，但是.5向上取

Math.random（）取随机数 [0，1）取到0，但是不能取到1

charAt ( i ) 找到索引对应的字符串

str [ i ] 找到索引对应的字符串，从0 开始，必须是 [ ]

.concat() 拼接字符串

slice(a,b) 从下标a的位置截取到下标b，不包含b ,返回值是被截取的数据，不改变原数据

只有一个参数，就是从对应下标直接截取到末尾

substring(a,b) 从下标a的位置截取到下标b，不包含b ,返回值是被截取的数据，不改变原数据

只有一个参数，就是从对应下标直接截取到末尾

如果第一个参数为负数的话，会自动转化为0，从索引0开始截取

substr(a,c) 从下标a开始截取b个，返回值是被截取的元素，不会改变原数据

如果还有一个参数，从下标a直接截取到末尾，不改变原数据

indexOf() 从前往后查找字符串对应的索引

lastIndexOf() 从后往前查找字符串对应的索引

search() 返回字符串对应的索引

match() 返回找到的字符串，没有就返回null

toFixed() 保留字符串的几位小数

padStart() 字符串从前填充，第一个参数, 填充到多少位; 第二个参数, 用什么来填充

padEnd() 字符串从后填充，第一个参数, 填充到多少位; 第二个参数, 用什么来填充

const message = "Hello";

// 在开头用a填充到10位
console.log(message.padStart(10, "a")); // aaaaaHello
// 在结尾用b填充到10位
console.log(message.padEnd(10, "b")); // Hellobbbbb

replace() 替换字符串对应字符

var str = 'ab12ba21/k1'
替换第一个指定字符
str.replace('a','z');  //'zb12ba21/k1'
替换全部指定字符
str.replace(/a/g,'z');  //'zb12bz21/k1'
替换特殊字符
str.replace(/\//,'?');  //'ab12ba21?k1'

字符串转数组：字符串名.split(‘分隔符’)

字符串使用Set去重

[...new Set('ababbc')].join('')

注意：使用 Set 去重后，将会被转化为数组，所以要使用 join 将其再次转化为字符串

对象

对象的forEach循环 obj.forEach(value,key,index) { }

value是键值对的值 key是键值对的键 index是下标

对象转数组： Array.from() 将伪数组或可遍历对象转换为真正的数组

Object.keys(obj) 以数组的形式返回所有对象中的key

Object.values(obj) 以数组的形式返回所有对象中的value

Object.entries(obj) 返回一个给定对象自身可枚举属性的键值对数组

const obj = {
  name: "why",
  age: 18,
  height: 1.88,
};

console.log(Object.entries(obj)); // [['name', 'why'], ['age', 18], ['height', 1.88]]

const arr = [10, 20];
const str = "ab";

console.log(Object.entries(arr)); // [['0', 10], ['1', 20]]
console.log(Object.entries(str)); // [['0', 'a'], ['1', 'b']]

Object.assign 用于对象的合并方法：var copyObj = Object.assign({}, obj);