常见字符串和数组的方法

内置函数

字符串

  • indexOf()：返回参数在字符串中的位置，如果都没有则返回-1

  • split(分隔符)：将字符串转换成数组

    var str = 'adhg'
// 返回一个数组
var re_str = str.split('h')
// [ab,g]

    注意

    • 如果不带分隔符或分割符不存在，则返回包含一个的数组
    • 常有连调str.split('h').join('--')
      join：表示将数组中的元素用--连接起来

  • substr(start,length)：返回一个字符串，从指定位置开始到指定长度

    var str = 'ajgoaigfo'
str.substr(-3,2) // gf

    注意

    • substr()是小写的
    • start可以取负数，取负数则为length + start开始取值
    • length可选

  • slice()：提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串

    str.slice(beginIndex[, endIndex])

  • charAt()：从一个字符串中返回指定的字符

    str.charAt(index)

  • charCodeAt()：返回 0 到 65535 之间的整数，表示给定索引处的 UTF-16 代码单元

    str.charCodeAt(index)

  • indexOf()：第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，否则返回 -1。

    str.indexOf(searchValue [, fromIndex])

  • lastIndexOf()：最后一次出现的索引，在一个字符串中的指定位置 fromIndex处从后向前搜索。如果没找到这个特定值则返回-1

    str.lastIndexOf(searchValue[, fromIndex])

  • split()

    str.split([separator[, limit]])
// seprator 分隔符 可以是正则表达式
// limit 限制返回分割片段数目

    返回值：返回源字符串以分隔符出现位置分隔而成的一个Arrray

  • replace()：方法返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数。如果pattern是字符串，则仅替换第一个匹配项

    str.replace(regexp|substr, newSubStr|function)

  • search()：返回str第一个符合正则表达式的索引

    str.search(regexp)

  • match()：检索返回一个字符串匹配正则表达式的结果

    var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var regexp = /[A-E]/gi;
var matches_array = str.match(regexp);

console.log(matches_array);
// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

    返回值：返回与完整正则表达式匹配的所有结果

  • match()

  • toLowerCase()：会将调用该方法的字符串值转为小写形式，并返回

  • toUpperCase()：将调用该方法的字符串转为大写形式并返回

  • concat()：将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回

  • substring(indexStart,indexEnd)：返回一个字符串，从开始索引到结束索引

  • str[0]/charAt(0)

加特效

  • anchor()：创建一个标签 a HTML 锚元素，被用作超文本靶标

  • blink()：闪烁的HTML元素

  • sub()和sup()：上标和下标

  • includes()

    str.includes(searchString[, position])
//position 可选 在 str 中搜索 searchString 的开始位置，默认值为 0

    返回值：如果在字符串的开头找到了给定的字符则返回true；否则返回false

  • startsWith()

    str.startsWith(searchString[, position])
//position 可选 在 str 中搜索 searchString 的开始位置，默认值为 0

  • endsWith()

    str.endsWith(searchString[, length])
//length 可选  作为 str 的长度。默认值为 str.length

    注意：

    • 这三个方法只返回布尔值，如果需要知道子串的位置，还是得用 indexOf 和 lastIndexOf 。
    • 这三个方法如果传入了正则表达式而不是字符串，会抛出错误。而 indexOf 和 lastIndexOf 这两个方法，它们会将正则表达式转换为字符串并搜索它。

  • repeat()
    返回新的字符串，表示将字符串重复指定次数返回。

        console.log("Hello,".repeat(2));  // "Hello,Hello,"
如果参数是小数，向下取整
    console.log("Hello,".repeat(3.2));  // "Hello,Hello,Hello,"
如果参数是 0 至 -1 之间的小数，会进行取整运算，0 至 -1 之间的小数取整得到 -0 ，等同于 repeat 零次
    console.log("Hello,".repeat(-0.5));  // "" 
如果参数是 NaN，等同于 repeat 零次
    console.log("Hello,".repeat(NaN));  // "" 
如果参数是负数或者 Infinity ，会报错:
    console.log("Hello,".repeat(-1));  
    // RangeError: Invalid count value
    
    console.log("Hello,".repeat(Infinity));  
    // RangeError: Invalid count value
如果传入的参数是字符串，则会先将字符串转化为数字
    console.log("Hello,".repeat("hh")); // ""
    console.log("Hello,".repeat("2"));  // "Hello,Hello,"

  • padStart

    str.padStart(targetLength [, padString])
//targetLength 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
//padString 可选 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。此参数的默认值为 " "（U+0020）。

    从头部补齐
    返回值：在首部填充后形成的新字符串

  • padEnd

    str.padEnd(targetLength [, padString])
//targetLength 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
//padString 可选 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。此参数的默认值为 " "（U+0020）。

    从尾部补齐
    返回值：在原字符串末尾填充指定的填充字符串直到目标长度所形成的新字符串。

  • padStart

    str.padStart(targetLength [, padString])
//targetLength 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
//padString 可选 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。此参数的默认值为 " "（U+0020）。

    从头部补齐
    返回值：在首部填充后形成的新字符串

  • padEnd

    str.padEnd(targetLength [, padString])
//targetLength 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
//padString 可选 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。此参数的默认值为 " "（U+0020）。

    从尾部补齐
    返回值：在原字符串末尾填充指定的填充字符串直到目标长度所形成的新字符串。

  • padStart

    str.padStart(targetLength [, padString])
//targetLength 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
//padString 可选 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。此参数的默认值为 " "（U+0020）。

    从头部补齐
    返回值：在首部填充后形成的新字符串

  • padEnd

    str.padEnd(targetLength [, padString])
//targetLength 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
//padString 可选 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。此参数的默认值为 " "（U+0020）。

    从尾部补齐
    返回值：在原字符串末尾填充指定的填充字符串直到目标长度所形成的新字符串。

数组

所有数组方法返回一个新方法，新数组中的元素 区分是否为同一个引用

  • concat()：用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组

  • join()：将数组转换成字符串，把数组中的每个元素调用tostring() 然后连接

  • pop()：方法从数组中删除最后一个元素，并返回该元素的值

  • push()：方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

  • reverse()：法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。

  • shift()：方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

  • unshift()：方法将一个或多个元素添加到数组的开头，并返回该数组的新长度（该方法修改原有数组）。

  • slice()：方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

    arr.slice([begin[, end]])

  • splice()：方法通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容。此方法会改变原数组。

    array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
// start： 起始位置 可以为负
// deletecount 删除几个元素
//item 添加几个元素

  • sort()

    arr.sort([compareFunction])

var arr=[10,2,33,42]
var arr2 = arr.sort()
var arr3 = arr.sort(function(n1,n2) {
    return n1-n2
})
// unicode编码

var numbers = [4, 2, 5, 1, 3];
numbers.sort((a, b) => a - b);
console.log(numbers);

    返回值：排序后的数组。请注意，数组已原地排序，并且不进行复制。

  • map()
    创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成

    var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])

    返回值：一个由原数组每个元素执行回调函数的结果组成的新数组

  • filter()
    创建一个新数组，其包含通过所提供函数实现的测试的所有元素。

    var arr = [10,203,44,32]
var re = arr.filter(function(el,index,arr) {
    console.log(el)
    // 返回值el作为筛选条件 为true？返回el : undefined
    return el
})

    返回值：一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组

  • some()：方法测试数组中是不是至少有 1 个元素通过了被提供的函数测试。它返回的是一个 Boolean 类型的值。

    arr.every(callback(element[, index[, array]])[, thisArg])

    返回值：数组中有至少一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为 false。

  • every()：方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值

    arr.every(callback(element[, index[, array]])[, thisArg])
// element 元素值
// index 用于测试索引值
// array 调式every的当前数组
// thisArg 设置this

    返回值：如果回调函数的每一次返回都为true值，返回 true，否则返回 false。

  • includes()
    用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false

    arr.includes(valueToFind[, fromIndex])

    formIndex为负值则倒数

  • reduce()
    reduce(callbackFn, initialValue)
    arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    // 如果设置初始值 则accumulator = 初始值 之后为返回值
    // currentValue 为 arr[0]
    arr = [10,23,45]
    var re = arr.reduce(function(n1,n2){
    // 返回的值是下一次调用的n1
    return n1+n2
    })

  • rudeceRight()：方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。

    arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
// accumulator 第一次默认是数组最后一个元素，之后为返回值
// currentValue 当前被处理的元素

    返回值：执行之后的返回值。

  • Array.of()：将参数中所有值作为元素形成数组，参数为空时返回

    let arry = Array.of(1,2,3,'ajog',24)

  • Array.from()：将类数组对象或可迭代对象转化为数组

    Array.from(arrayLike[, mapFn[, thisArg]])
// mapFn：可选，map 函数，用于对每个元素进行处理，放入数组的是处理后的元素。
//thisArg：可选，用于指定 map 函数执行时的 this 对象。

    可以转换Set,Map和字符串形式的为数组

  • find()：查找数组中符合条件的元素,若有多个符合条件的元素，则返回第一个元素

    let arr = Array.of(3,32,1)
console.log(arr.find(function(el) {
  return el > 2
}))

  • findIndex()：查找数组中符合条件的元素索引，若有多个符合条件的元素，则返回第一个元素索引

  • fill()：将一定范围索引的数组元素内容填充为单个指定的值

    let arr = Array.of(1, 2, 3, 4);
// 参数1：用来填充的值
// 参数2：被填充的起始索引
// 参数3(可选)：被填充的结束索引，默认为数组末尾
console.log(arr.fill(0,1,2)); // [1, 0, 3, 4]

  • entries()：遍历键值对

    let arr = [3,23,2,'ajog',Symbol()]
        let arrentry = arr.entries()
        for(let i = 0;i < arr.length; i++) {
            console.log(arrentry.next().value)
        }
// --------------for...of...---------
let arr = [3,23,2,'ajog',Symbol()]
        let arrentry = arr.entries()
        for(let [key,value] of arrentry) {
            console.log(value)
        }

  • keys()：遍历键名

    let arr = [3,23,2,'ajog',Symbol()]
        for(let key of arr.keys()) {
            console.log(key)
        }
        console.log(arr.keys())

  • values()：遍历键值

    let arr = [3,23,2,'ajog',Symbol()]
        for(let value of arr.values()) {
            console.log(value)
        }
        console.log(arr.values())

  • includes()：数组是否包含指定值。注意：与 Set 和 Map 的 has 方法区分；Set 的 has 方法用于查找值；Map 的 has 方法用于查找键名。

    arr.includes(valueToFind[, fromIndex])
[3,23,1,'ajoa'].includes('aa')

    返回值： turn 或者false

  • flat()：降维

    console.log([1 ,[2, 3]].flat()); // [1, 2, 3]
 
// 指定转换的嵌套层数
console.log([1, [2, [3, [4, 5]]]].flat(2)); // [1, 2, 3, [4, 5]]
 
// 不管潜逃多少层
console.log([1, [2, [3, [4, 5]]]].flat(Infinity)); // [1, 2, 3, 4, 5]
 
// 自动跳过空位
console.log([1, [2, , 3]].flat());<p> // [1, 2, 3]
posted @ 2022-07-15 09:15  a立方  阅读(23)  评论(0)  编辑  收藏  举报