JS基础知识之数组_js replace函数生成数组吗

一、类数组转化为数组

1.Array.prototype.slice.call()

function sum (){
    let arr = Array.prototype.slice.call(arguments);
    console.log(arr.reduce((sum,cur)=> sum + cur),arr)//arr可以调用数组原生方法了
}
sum(1,2);//3 [1,2]

2.Array.form()

function sum(a,b){
    let arr = Array.from(arguments);
    console.log(arr.reduce((sum,cur)=> sum + cur))//arr可以调用原生方法
}
sum(1,2);//3

3.ES6展开运算符

function sum (a,b){
    let arr = [...arguments];
    console.log(arr.reduce((sum,cur)=> sum + cur));//arr可以调用数组原生方法
}
sum(1,2)//3

4.利用concat + apply

function sum (a,b){
    let arr = Array.prototype.concat.apply([],arguments);
    console.log(arr.reduce((sum,cur)=> sum + cur));//arr可以调用数组原生方法
}
sum(1,2)//3

二、JS判断数组中是否包含某个值

1.array.indexOf

返回数组原素的下标，否则返回-1
 
var arr = [1,2,3,4];
var index = arr.indexOf(3); 
console.log(index)//返回数组原素的下标，否则返回-1

2.arr.includes(valueToFind[, fromIndex])

此方法判断数组中是否存在某个值，如果存在返回true，否则返回false
 
参数 
valueToFind 需要查找的元素值。
fromIndex 可选 从fromIndex 索引处开始查找 valueToFind。
如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 
（即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。

var arr = [1,2,3,4];
if(arr.includes(3)){
    console.log('存在')
}else{
    console.log('不存在')
}

3.arr.find(callback[, thisArg])

返回数组中满足条件的第一个元素的值，如果没有，返回undefined
 
参数
callback(element,index,array) 可传入三个值 
    element 当前遍历到的元素;index可选 当前遍历到的索引;array可选 数组本身;
thisArg可选 执行回调时用作this 的对象。

var arr = [1,2,3,4,78];
var result = arr.find(item=>{
    return item > 3;
})
console.log(result);//4

4.arr.findIndex(callback[, thisArg])

findIndex()方法返回数组中满足条件的第一个元素的下标。否则返回-1。
参数
callback()针对数组中的每个元素, 都会执行该回调函数, 执行时会自动传入下面三个参数:
    element当前元素。
    index 当前元素的索引
    array 调用findIndex的数组。
 
thisArg 可选。执行callback时作为this对象的值.

var arr = [1,2,3,4];
var result = arr.findIndex(item=>{
    return item > 3
});
console.log(result)//3

三、JS中flat----数组扁平化

需求：多维数组=》一维数组
let arr = [1, [2, [3, [4, 5]]], 6];// -> [1, 2, 3, 4, 5, 6]
let str = JSON.stringify(arr);

1. 调用ES6中的flat方法

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
var newArray = arr.flat([depth])
参数
    depth 可选
    指定要提取嵌套数组的结构深度，默认值为 1。
返回值
    一个包含将数组与子数组中所有元素的新数组。
 
arr = arr.flat(Infinity);

2. replace + split

replace() 方法返回一个由替换值（replacement）替换一些或所有匹配的模式（pattern）后的新字符串。
模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数。
原字符串不会改变。
 
语法：str.replace(regexp|substr, newSubStr|function)
 
参数：
    regexp (pattern)
    一个RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。
    substr (pattern)
    一个将被 newSubStr 替换的 字符串。其被视为一整个字符串，而不是一个正则表达式。仅第一个匹配
   项会被替换                      
    newSubStr (replacement)
    用于替换掉第一个参数在原字符串中的匹配部分的字符串。该字符串中可以内插一些特殊的变量名。
    参考下面的使用字符串作为参数。    
    
    function (replacement)
     一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。
     参考下面的指定一个函数作为参数。
返回值
  一个部分或全部匹配由替代模式所取代的新的字符串。
arr = str.replace(/(\[|\])/g, '').split(',')

3. replace + JSON.parse

str = str.replace(/(\[|\])/g, '');
str = '[' + str + ']';
ary = JSON.parse(str);

4. 普通递归

let result = [];
let fn = function(ary) {
  for(let i = 0; i < ary.length; i++) {
    let item = arr[i];
    if (Array.isArray(arr[i])){
      fn(item);
    } else {
      result.push(item);
    }
  }
}
 

5. 利用reduce函数迭代

reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值

function flatten(arr) {
    return arr.reduce((pre, cur) => {
        return pre.concat(Array.isArray(cur) ? flatten(cur) : cur);
    }, []);
}
let arr = [1, 2, [3, 4], [5, [6, 7]]]
console.log(flatten(arr))

6：扩展运算符

//只要有一个元素有数组，那么循环继续
while (ary.some(Array.isArray)) {
  ary = [].concat(...ary);
}