首页学习记录

[toc]

# JavaScript 中常用方法

# 一、数组

# 1. 截取数组

  1. slice：获取数组某一区间的元素并形成新的数组将其返回，不改变原数组.

  2. splice：删除数组元素同时可以插入元素，会改变原数组.

    slice 方法接收两个参数都为下标，区间为左闭右开。如果省略第一个参数则从第一个元素开始获取如果省略第二个参数则会一直获取到最后一个值。这两个参数都可以是负数。当参数为负数时，最后一个值的下标为 - 1 并以此往前依次减 1. 如果未获取到元素则返回空数组

    splice 方法接收三个参数，第一个参数是要删除值的下标不可省略另外这个参数同样也可以是负数，第二个参数的删除值的个数如果为 0 则不会删除元素，如果省略则一直删到结尾，第三个参数为插入的元素，元素不只是数字或者字符串，数组，函数或者对象都可以传入。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    let a = [1,2,3,4,5,6,7,8,9]
    let b = ['a','b']

    //获取下标0到2不包括2的元素并返回形成新的数组
    console.log(a.slice(0,2))//[ 1, 2 ]
    //如果第一个参数没有的话，则从头开始，第二个参数没有的话则获取到结尾//[1, 2, 3, 4, 5,6, 7, 8, 9]
    console.log(a.slice())
    //获取倒数第三个到倒数第一个不包括倒数第一个元素//[ 7, 8 ]
    console.log(a.slice(-3,-1))
    let fun= ()=>{return 1}
    let obj ={a,b}
    a.splice(2,4,obj,fun,...b)//从删除下标2以及之后的3的元素并在2后插入对象函数等元素

# 2. 查找数组中某一元素的位置

  1. indexOf： 获取某一元素在数组首次出现的下标。

  2. lastIndexOf： 获取某一元素在数组中最后一次出现的下标。

    这两个方法都接收两个参数，第一个参数是要找的值，第二个参数是从那一个下标开始包括此下标（indexOf 向后，lastIndexOf 向前）找，如果没有第二个参数就默认 indexO 从头开始找，lastIndexOf 从最后向前开始找。如果没有找到该元素则返回 - 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let a =1
const b = [1,2,3,1,2,3,2,1,2,1]

console.log(b.indexOf(a)) //0
console.log(b.lastIndexOf(a)) //9

console.log(b.indexOf(a,1)) //3
console.log(b.lastIndexOf(a,8)) //7

console.log(b.indexOf(a,b.indexOf(a)+1)) 获取第二个出现此元素下标
console.log(b.lastIndexOf(a,b.lastIndexOf(a)-1)) 获取倒数第二个出现此元素下标

console.log(b.indexOf(4) //-1
console.log(b.lastIndexOf(4) //-1

# 3. 查找数组中满足条件的元素或者下标

  1. find：获取数组中满足条件的元素

  2. findIndex：获取数组中满足条件的元素的下标

    这两个方法都接收一个函数做参数，函数有三个参数，第一个为数组的值，第二个为该值在数组中所在的下标，第三个为该数组。其中 find 返回元素，如果没有发现满足条件的元素则返回 undefined，如果有多个元素满足也只会返回第一个满足条件的元素。findIn 返回下标，如果没有发现满足条件的元素则返回 - 1，如果有多个元素满足也只会返回第一个满足条件的下标。

    1
    2
    3
    let a = [1,2,3,4]
    console.log(a.find((val)=>val>1)) //2
    console.log(a.findIndex((val)=>val>1)) //1

# 4. 检查数组中的元素是否存在或者都满足某一条件

  1. every：检查数组中的元素是否都满足某一条件

  2. some：检查数组中的元素是否存在满足某一条件

    这两个方法都接收一个函数做参数，函数有三个参数，第一个为数组的值，第二个为该值在数组中所在的下标，第三个为该数组。返回值均为布尔值。

    1
    2
    3
    4
    5
    let a = [1,2,3]
    console.log(a.every((val)=>val>0)) //true
    console.log(a.every((val)=>val>1)) //false
    console.log(a.some((val)=>val>3)) //false
    console.log(a.some((val)=>val>1)) //true

# 5. 将数组转化为字符串

  1. join：获取参数作为分割符，如果没有则默认用‘,’(逗号) 并返回字符串。

  2. toString： 将数组转化为字符串并用‘,’(逗号) 分割并返回字符串。

    这两个方法都不会改变原数组

    1
    2
    3
    4
    5
    let a = [1,2,3]
    console.log(a.toString())//1,2,3
    console.log(a.join())//1,2,3
    console.log(a.join(''))//123
    console.log(a.join('-'))//1-2-3

# 6. 在数组开头或者结尾删除或者添加元素

  1. push：向数组末尾添加一个或多个元素，并返回新的长度。
  2. pop：从数组末尾删除一个元素，并返回被删除的元素。
  3. shift：从数组开头删除一个元素，并返回被删除的元素。
  4. unshift：向数组开头添加一个或多个元素，并返回新的长度。

# 二、字符串

# 1. 字符串转化为数组

  1. split：将字符串以某种方式分割成数组。

    split 传入一个参数可以是正则表达式并匹配数组中的元素将其分割为数组，返回一个数组不改变字符串。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    let str = '1,3 4'

    console.log(str.split()) // 如果不传参数则会将返回一个数组第一个元素为整个字符串
    [ '1,3 4' ]

    console.log(str.split('')) // 如果参数为空字符串的话，则会将字符串每一个元素传入数组中并返回这个数组
    [ '1', ',', '3', ' ', '4' ]

    console.log(str.split(' '))// 参数可以是空格，将空格作为分割符并传入数组并返回这个数组
    [ '1,3', '4' ]

    console.log(str.split(','))
    [ '1', '3 4' ]

    console.log(str.split(/[0-9]/))// 参数可以是正则表达式
    [ '', ',', ' ', '' ]

# 2. 查找字符串中某个值的位置

1.indexOf：查找某个值在字符串的位置，这个值可以是字符串。

2.lastIndexOf：查找某个值在字符串的位置，同样这个值可以是字符串。

用法与数组的方法一致，不过这个方法可以很方便的求两个字符串的子串。

1
2
3
4
let str1 = 'abc',str2='abccbabc'
console.log(str2.indexOf(str1))//0
console.log(str2.lastIndexOf(str1))//5
只要返回值不是-1就说明str是str2的子串。

# 三、哈希表

  1. set (key,value): 设置键值对，如果某一键已经存在则会覆盖。第一个参数可以是数字，字符串，布尔值，数组，对象，函数等等值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    let arr1 =[1,2],obj1={a:1},arr2 =[1,2],obj2={a:1},map = new Map(),fun1 =()=>{},fun2=()=>{}
    map.set(arr1,1)
    map.set(obj1,1)
    map.set(arr2,1)
    map.set(obj2,1)
    map.set(fun1,1)
    map.set(fun2,1)
    console.log(map.size)//6


    let arr1 =[1,2],arr2 =arr1,map = new Map()
    map.set(arr1,1)
    map.set(arr2,1)
    console.log(map.size)//1

    可以发现像数组，对象，函数尽管一模一样，但是其变量储存的地址不同所以看做是不同的键，但是如果是浅拷贝储存变量的地址一致就视作是同一个键

  2. get (key): 获取某一键值在哈希表中的值。

    1
    2
    3
    4
    let map = new Map()
    map.set(1,2)
    map.get(1)//2
    map.get(2)//undefined 如果找不到就会返回undefined

  3. has (key): 判断某个键是否存在，并返回布尔值。

    1
    2
    3
    4
    let map = new Map()
    map.set(1,2)
    console.log(map.has(1))//true
    console.log(map.has(2))//false

  4. clear (): 清除哈希表所有键值对。

    1
    2
    3
    4
    5
    let map = new Map()
    map.set(1,2)
    console.log(map.has(1))//true
    map.clear()
    console.log(map.has(1))//false

  5. delete (key): 删除某键。

    1
    2
    3
    4
    5
    let map = new Map()
    map.set(1,2)
    console.log(map.has(1))//true
    map.delete()
    console.log(map.has(1))//false

  6. keys (): 返回一个包含哈希表所有键的迭代器。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    let arr1 =[1,2],obj1={a:1},arr2 =[1,2],obj2={a:1},map = new Map(),fun1 =()=>{},fun2=()=>{}
    map.set(arr1,1)
    map.set(obj1,1)
    map.set(arr2,1)
    map.set(obj2,1)
    map.set(fun1,1)
    map.set(fun2,1)
    let key = map.keys()
    for(let i of key){
        console.log(i) //[ 1, 2 ] { a: 1 } [ 1, 2 ] { a: 1 } [Function: fun1] [Function: fun2]
    }

  7. values (): 返回一个包含哈希表所有值的迭代器。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    let arr1 =[1,2],obj1={a:1},arr2 =[1,2],obj2={a:1},map = new Map(),fun1 =()=>{},fun2=()=>{}
    map.set(arr1,1)
    map.set(obj1,1)
    map.set(arr2,1)
    map.set(obj2,1)
    map.set(fun1,1)
    map.set(fun2,1)
    let val = map.values()
    for(let i of val){
        console.log(i) // 1 1 1 1 1 1
    }