JavaScript 常用数组、字符串，对象方法

数组

一、变异方法（会改变原始数组） 

1.push

向数组的末尾增加一个元素或多个元素，并返回新的长度

let arr = [0,1,2]
console.log(arr.push(3)) //返回新的数组长度 4
console.log(arr) //[0,1,2,3]
复制代码

2.pop

删除并返回数组的最后一个元素

let arr = [0,1,2]
console.log(arr.pop()) //删除并返回数组最后一个元素 2
console.log(arr) //[0,1]
复制代码

3.shift

删除并返回数组的第一个元素

let arr = [0,1,2]
console.log(arr.shift()) //删除并返回数组第一个元素 0
console.log(arr) //[1,2]
复制代码

4.unshift

向数组的开头增加一个或多个元素，并返回新的长度

let arr = [0,1,2]
console.log(arr.unshift(-2,-1)) //返回新的数组长度 5
console.log(arr) //[-2, -1, 0, 1, 2]
复制代码

5.splice

对数组的内容进行删除，增加，替换。

arr.splice(index,howmany,item1,item2...)
复制代码

index是执行操作的位置，必须

howmany是删除的个数，为0时就是不删除只增加

let arr = ["方案1", "方案2", "方案3", "方案4", "方案5"];

for (let i = 0, len = arr.length; i < len; i++) {
    if (
        arr[i] === "方案1" ||
        arr[i] === "方案2" ||
        arr[i] === "方案3"
    ) {
        arr.splice(i, 1);
        i--; //因为删除后，数组长度会减1，所以 i 也要减1，才能对应新的数组
    }
}
console.log(arr)//["方案4", "方案5"]
复制代码

6.sort

对数组排序

let array = [1, 2, 10, 18, 3, 95, 2, 5];
//升序
array.sort((a,b)=>a-b); 
//降序
array.sort((a,b)=>b-a);
复制代码

7.reverse

颠倒数组中的元素

let arr = [1,2,3]
arr.reverse()
console.log(arr) //[3,2,1]
复制代码

二、非变异方法（不会改变原始数组）

1. map

返回一个新数组，新数组的元素为原始数组元素调用函数处理后的值

let arr = [1,2,3]
let newArr = arr.map((item,index)=>item+1)
console.log(newArr) //[2, 3, 4]
复制代码

2. reduce

reduce方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算的得到一个值

array.reduce(function(total, currentValue, currentIndex), initialValue)
复制代码

（1）累加器

let arry = [1, 25, 85, 36];
let totalValue = arry.reduce((total, currentValue)=> total * currentValue);
console.log(totalValue);//76500
复制代码

（2）访问嵌套对象

<script>
    let obj = {
        a: {
            b: {
                c: 666
            }
        }
    }

    var str = 'a.b.c';

    let newArr = str.split('.').reduce(function (total, current) {
        return total[current]
    }, obj)
    
    console.log(newArr)
</script>
复制代码

3. filter

返回符合条件的项组成的数组

let array = [1, 2, 5, 6];
let arrayNew = array.filter(item => item > 2); 
console.log(arrayNew) //[5,6]
复制代码

4. concat

用于连接两个或者多个数组，相同的值不会被覆盖

let arr = [1, 2, 3];
let newArr = a.concat(3,4, 5);
console.log(newArr) //[1,2,3,3,4,5]
复制代码

5. slice

从已有的数组中返回选定的元素

array.slice(start,end)
复制代码

start：规定从何处开始选取

end：规定何处结束

如果都没有指定，array.slice()则将拷贝整个数组

let arr = [1, 2, 3];
let newArr = arr.slice(1,3) 
console.log(newArr) //[2,3]
复制代码

6. join

array.join(separator) // separator= “.” 分隔符，默认为,

将所有数组元素拼接成字符串

const arr = [1,2,3,4,5];
console.log(arr.join("")) // 12345
复制代码

7. toString

将数组作为字符串返回

注意：使用toString()方法将数组转为字符串时，只能转化数值数组或字符串数组。不能用在对象数组上

const arr = [1, 2, 3, 4, 5];
let str = arr.toString()
console.log(str) // 1,2,3,4,5

const arr2 = [{name:'张三'},{age:24}];
console.log(arr2.toString())  // [object Object],[object Object]
复制代码

三、对数组的检测

1.every

对数组中的每一项运行给定函数，全部满足条件则返回true

let arr = array.every(value => value > 18)
复制代码

2.some

对数组中的每一项运行给定函数，如果有一项满足条件则返回true

3.indexOf

返回第一个与给定参数相等的数组元素的索引，没有的话返回-1

例子：

let arr = [1,2,3,56,57]

arr.indexOf(1)
复制代码

4.lastIndexOf

返回最后一个与给定参数相等的数组元素的索引，没有的话返回-1

5. includes

检测数组是否包含某个数

[5,6,7,8,24,25,26,27,28,29,30,31,32,33].includes(val)
复制代码

存在返回true，不存在返回false

6.find

找出第一个符合条件的数组成员，如果没有符合条件的则返回undefined

[1, 4, -5, 10].find((n) => n < 0)
复制代码

7.findIndex

返回第一个符合条件的数组成员的位置，如果没有符合条件的，则返回-1

var ages = [3, 10, 18, 20];
 
function checkAdult(age) {
    return age >= 18;
}

ages.findIndex(checkAdult)
复制代码

字符串

一、非变异方法（不会改变原始字符串）

1.split

把一个字符分割成字符串数组 。非变异方法，不会改变原字符串，所以需创建变量去接收。

let array = string.split(separator，howmany)
复制代码

separator 必须，字符串或正则表达式，从该参数指定的位置分割

howmany 可选 分割的长度 默认不考虑长度 “,”

let str = '123';
let newArr = str.split("") 
console.log(newArr) //[1,2,3]
复制代码

2.substr

在字符串中抽取从start下标开始的指定数目的字符

str.substr(start,length)
复制代码

start（必需）：要抽取的字符串起始下标，如果是负数，那么位置从尾部开始

length（可选）：字串中的字符数，必修是数值

let str = '123';
let newStr = str.substr(1) 
console.log(newStr) //'23'
复制代码

3. substring

提取字符串中介于两个指定下标之间的字符

str.substring(start,stop)
复制代码

start：非负整数，开始下标

stop：结束位置，但比提取的最后字符的位置要多1（比如stop为5，提取的最后一个字符下标为4）

let str = '123456';
let newStr = str.substring(1,4) 
console.log(newStr) //'234'
复制代码

4.parseInt

解析一个字符串，返回一个整数

let str = '123456';
let newStr = parseInt(str) 
console.log(newStr) //123456
复制代码

5.parseFloat

解析一个字符串，返回一个浮点数

let str = '123456.5';
let newStr = parseFloat(str) 
console.log(newStr) //123456.5
复制代码

6.+

将字符串类型转为Number类型

const obj={
  a:'12'
}

console.log(+obj.a) //12(Number类型)
复制代码

7.replace

可将字符串中特定的内容转为自己想要的

replace(regexp/substr,replacement)
复制代码

1.使用字符串匹配

let str = "Visit Microsoft!"
let newStr = str.replace("Microsoft", "WSchool")
console.log(newStr) //Visit WSchool!
复制代码

2.使用正则匹配

var str = "{{msg}}--{{person.name}}"

str = str.replace(/\{\{(.+?)\}\}/g,(args)=>{
    //args: {{msg}}   {{person.name}}
   return '替换的值'
})

console.log(str) //替换的值--替换的值
复制代码

二、对字符串的检测

1.indexOf()

可以返回指定字符串值或数字在字符串或数组中首次(第一个)出现的位置，有的话会出现对应的下标，没有的话会返回 -1。

扩展：使用正则

（一）除了使用indexOf查找外，还可以使用match()方法

indexOf返回的是下标；match返回的是指定的值，没有就返回null，区分大小写

//实例1：通过match检索字符串 

let str = "Hello World";
str.match("Hello") //Hello
str.match("hello") //null

//实例2：通过match检索一个正则匹配
let str = '1 plus 2 equal 3';
let regular = /\d+/g
str.match(regular) //1,2,3
复制代码

（二）也可以通过test()方法，去判断是否存在这个字符串

let str = "state1"
//加了^与$标志后代表从开头到结尾都要遵循
let regular = /^state\d$/
regular.test(str) //true 只有state+数字才可匹配成功
复制代码

2.includes()

includes()方法除了检测数组，还可以检测字符串；如果存在返回true，不存在返回false

let s = 'Hello world!';
s.includes('o') // true
复制代码

3. startsWith()

检测字符串是否以指定的子字符串开始，对大小写敏感

var str = "Hello world, welcome to the Runoob.";
var n = str.startsWith("Hello");  //true
复制代码

对象

一、操作对象

1.Object.assign()

用于拼接，或者创建一个新对象

拼接：相同字段后面会覆盖前面的

let obj = {
    name:'张三',
    sex:'男'
}
Object.assign(obj,{name:'李四',age:20})
console.log(obj)//{name: "李四", sex: "男", age: 20}
复制代码

创建新对象：

let obj = {
    name:'张三',
    sex:'男'
}
let newObj = Object.assign({},obj,{name:'李四',age:20})
console.log(newObj)//{name: "李四", sex: "男", age: 20}
复制代码

2.delete

删除对象某个属性

delete a.age;
复制代码

3.Object.keys()

返回对象可枚举属性（返回一个数组）

let obj = {
    name:'张三',
    sex:'男'
}
let newArr = Object.keys(obj)
console.log(newArr)//["name", "sex"]
复制代码

4.Object.values()

返回对象可枚举的值（返回一个数组）

let obj = {
    name:'张三',
    sex:'男'
}
let newArr = Object.values(obj)
console.log(newArr)//["张三", "男"]
复制代码

5.Object.entries()

返回键值对 [[key, value],[key, value]] 数组

let obj = {
    name:'张三',
    sex:'男'
}
let newArr = Object.entries(obj)
console.log(newArr)//[["name":"张三"],["sex":"男"]]
复制代码

6.Object.fromEntries()

Object.fromEntries()方法是Object.entries()的逆操作，用于将键值对数组转为对象

Object.fromEntries([
  ['foo', 'bar'],
  ['baz', 42]
])
// { foo: "bar", baz: 42 }
复制代码

二、对对象的检测

1. name in obj

检测对象中是否有某个属性

var person = {
    name:'张三'
}
console.log('name' in person) //true
复制代码

2. 判断对象是否为空

（1）JSON方式

将对象转化为json字符串，再判断字符串是否为” {} “

let data = {};
let b = (JSON.Stringify(data) == "{}")  

//注意：这里双括号外面要有双引号,因为JSON数据括号外面有双引号
复制代码

（2）使用Object.keys()

let data = {};
let arr = Object.keys(data);
console.log(arr.length == 0); //true
复制代码

创作不易，点赞支持！！！