记录array与string的用法作用：遍历数组,过滤数组内的元素。返回条件之外的元素。作用：遍历数组,找到组内的元素

以下为Array的方法

Array.filter

作用：遍历数组,过滤数组内的元素。返回条件之外的元素。

删除数组arr中name为'lfz'的对象

const arr = [{name: 'lfz'}, {name: 'sxy'}, {name: 'xxx'}];
            const newArr = arr.filter((val) => {
                return val.name !== 'lfz';
            });
            console.log(48, newArr);

Array.find

作用：遍历数组,找到组内的元素。找到返回这个元素，若没有，返回undefind

const arr = [{name: 'lfz'}, {name: 'sxy'}, {name: 'xxx'}];
            const flag = arr.find((val) => {
                return val.name === 'lfz22';
            });
            console.log(48, flag);//undefind

const arr = [{name: 'lfz'}, {name: 'sxy'}, {name: 'xxx'}];
            const flag = arr.find((val) => {
                return val.name === 'lfz';
            });
            console.log(48, flag);//{name: 'lfz'}

总结下filter和find的区别

这两者有点相似，都是找出数组中相匹配的元素。
filter找出多个匹配的元素，返回数组。
find找出一个匹配的元素，返回对象（遇到第一个匹配的就返回）。

Array.findIndex

用法与Array.find类似。findIndex就是返回索引,没找到返回-1

//findIndex
    const objList = [
        {name:'a', age: 1},
        {name:'b', age: 2},
        {name:'c', age: 3},
    ]
    const curIndex  = objList.findIndex(i=>{
        return i.age === 3
    })
    console.log(curIndex)//2  若没有找到返回-1

Array.from()

文档

1、类似扩展运算符用法

Array.form('foo') //['f','o','o']
[...'foo'] // ['f','o','o']

2、处理数组每项的参数

const arr = [{name:'lfz',age:24},{name:'sxy',age:23}]
        const endArr = Array.from(arr, item =>{
          return {name: item.name, age: item.age+1}
        })
        console.log(43,endArr) //[{name:'lfz',age:25},{name:'sxy',age:24}]

map也能实现,forEach用法相同。

  const arr = [{name:'lfz',age:24},{name:'sxy',age:23}]
  arr.map((item,index)=>{
          item.age = ++item.age
        })
        
  console.log(47, arr)

3、1=>[0,1], 2=>[0,1,2]，实现长度为i的，索引的数组

Array.from({length:10},(_,i)=>i)

循环

for...in..主要遍历对象
for...of..主要遍历map,set,generate

map&forEach用法

区别：

map有返回值，forEach没有。
map速度小于forEach。
map不会改变原来的数组，而forEach会改变。
map和forEach都无法跳出循环。
map默认都会给每一项返回值。

场景： 需要改变数组的值的时候，使用map,反之使用forEach。

map

        const arr = [{name:'lfz',age:24},{name:'sxy',age:23}]
        const endArr = arr.map((item,index)=>{
          return ++item.age
        })
    console.log(endArr)//[25, 24]
    //改变数组内每个对象的值--最佳方法
    const endArr2 = arr.map(i=>{
		return {
        		...item,
                age: 100
				}
	})

forEach

无法跳出循环，使用some()/every()

        const arr = [{name:'lfz',age:24},{name:'sxy',age:23}]
        const endArr = arr.forEach((item,index)=>{
          return ++item.age
        })
    console.log(endArr)//undefind

sort

排序字符串的时候是用Ascii码来比较的。所以字符串不能使用+,-操作来返回。

按照name升序排序

const arr = [
          {name:'c',age:24},
          {name:'b',age:23},
          {name:'a',age:25},
          {name:'d',age:25},
          ]
        arr.sort(sortByAge)

        function sortByAge(a, b) {
            //return a.age-b.age
            if(a.name>b.name){
                return 1
            }else if(a.name<b.name){
                return -1
            }
        }

        console.log(46, arr)

结果:

some&every

some(),只要有一个返回true,就返回true
every(),每项返回true,才返回true

//some
const a = [1,2,3,4]
const res = a.some(i=>{
  console.log(i)
  return i===3
})
console.log('res', res)
//1
//2
//3
//'res', true

//////
//every

const a = [1,2,3,4]
const res = a.every(i=>{
  console.log(i)
  return i===3
})
console.log('res', res)
//第一次就return false了， 所以是false
//1
//'res', false

every()当内部return false时跳出整个循环, return true会继续执行(与every相反)
every()当内部不return，只会执行一次就跳出，返回false

1、案例a

var arr = [1,2,3,4,5];
var num = 3;
arr.every(function(v){
   if(v == num) {
       return false;
   }else{
       console.log(v);
       return true;
   }
});
//1
//2
//false

2、案例b,不return false，只会执行一次, 返回false

const arr = [1,2,3,4]
            const res = arr.some((i,index)=>{
                console.log(i)
            })
            console.log(res) 
            // 1
            //false

摘自

以下内容摘自小红书

every与some 都用于查询数组中的项是否满足某个条件
every传入的函数必须对每一项都返回true，这个方法才返回true,否则就返回false
some 传入的函数的某一项返回false, 这个方法返回true。

Array.fill(val,start,end) 填充

面试题，生成长度为100的数组，且值为1

let arr = new Array(100)
arr.fill(1)

Array.slice(start, end) 分割

slice(start, end),包括start,不包括end
不会改变原来数组

    [1,2,3].slice(1)//[2,3] 
    [1,2,3].slice(1,2) // [2]

Array.splice(startIndex,delCount,item1,item2)

删除操作

  let arr = [1,2,3]
  //1、删除
  arr.splice(1,2)//1是索引，2是删除的个数
  console.log(35, arr)

在某个元素位置插入元素

//2、插入
arr.splice(2, 0, 'x')//2是插入的索引， 0是不删除的意思， 'x'是值
console.log(35, arr)

Array.reduce()

reduce参考
prevreduce的返回项
cur当前项
index 索引
initVal(可选,第一次初始化的值,可以是空，数组，对象，字符串)
如果没有提供initialValue，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供initialValue，从索引0开始。

arr.reduce((prev,cur,index,arr)=>{
  console.log(index, prev,cur)
  return prev+cur
}，initialValue )

1、reduce计算数组每项出现的次数

let arr = ['a','a','c','d']
let sum = arr.reduce((prev,cur,index,arr)=>{
  console.log('prev', 'cur', 'index')
  console.log(prev,cur, index)

  if(cur in prev){
    prev[cur] ++
  }else{
    prev[cur] = 1
  }
  return prev
}, {})

//输出 
{
a: 2
c: 1
d: 1
}

2、单数组去重

  //单数组去重
  let arrTemp = ['a', 'a', 'c', 'd']
  const arr_1 = arrTemp.reduce((prev, cur, index, arr)=>{
    console.log(cur)
    if(!prev.includes(cur)){
      prev.push(cur)
    }
    return prev
  }, [])
  console.log(46, arr_1)

3、数组对象去重

  //数组对象去重
  let arrTemp = [
    {name: 'a', age: 1},
    {name: 'a', age: 1},
    {name: 'b', age: 1},
    {name: 'c', age: 1},
    {name: 'c', age: 1},
  ]
  const arr_1 = arrTemp.reduce((prev, cur, index, arr)=>{
    const findIndex = prev.findIndex(i=>i.name===cur.name)
    if(findIndex === -1){
      prev.push(cur)
    }
    return prev
  }, [])

4、数组降维 2=>1

  let arr = [[0, 1], [2, 3], [4, 5]]
  let newArr = arr.reduce((pre, cur, index, arr)=>{
    console.log(pre)
    pre = pre.concat(cur)
    return pre
  },[])
  console.log(newArr); // [0, 1, 2, 3, 4, 5]

5、n次数组降维

  //数组降维 多=>1
  let arr = [-1, [0, 1], [2, 3], [4, [5, 6, 7, [8]]]]
  function arrFlat(arr, val) {
    return arr.reduce((prev, cur, index, arr) => {
      if(Array.isArray(cur)){
        //如果是数组，继续遍历当前对象，并且返回prev
        prev = prev.concat(arrFlat(cur))
      }else{
        //如果已经不是数组了，直接拼接cur
        prev = prev.concat(cur)
      }
      return prev
    }, [])
  }

迭代器 `iterator`

keys()
values()
entries()

const a = ["foo", "bar", "baz", "qux"]
Array.from(a.keys()) //[0,1,2,3]
Array.form(a.values()) //["foo", "bar", "baz", "qux"]
Array.from(a.entries())//[[0,'foo'],[1,'bar']]

Array.join&& Array.toString()

这两个方法都是数组转字符串

[1,2,3]=>'1,2,3'

toString()

数组类型转换为字符串 number类型转换为对应的进制

var num = 33
num.toString()//'33'
num.toString(2)//'100001' //转换为二进制

arr.pop()&& arr.shift()

删除第一个或者最后一个元素，返回删除的元素

const arr = [1,2,3]
//pop
arr.pop()//返回3 
arr//[1,2]
//shift与pop相反，删除第一个

Array.reverse()

翻转元素

[1,2,3].reverse() //[3,2,1]

es6找出最大最小值

var arr = [22,13,6,55,30];
console.log(Math.max(...arr)); // 55

以下为`String`的用法

chartAt

找出索引位置的值

'abcd'.chartAt(2) //c

concat

连接

'a'.concat('b')// 'ab'

indexOf,lastIndexOf, includes

找出当前字符的位置,数组也可以使用

'abc'.indexOf('b') //1
'abcbb'.lastIndexOf('b')//4
'abcbb'.lastIndexOf('cbb')//2
'aa'.includes('a')//true

startWith,endWith,includes

是否包含

'abccba'.startsWith('abc') //true
'abcbb'.includes('b')//true

trim()

删除前后空格

repeat(num)

复制当前字符串

var str = 'abc '
star.repeat(10)
//"abc abc abc abc abc abc abc abc abc abc "

padStart(len, val),padEnd()

填充字符串

var str = 'abc'
str.padStart(5) //"  abc"
str.padEnd(10, 'de')// "abcdededed"

localeCompare()

也是比较，本人觉得没必要用

记录array与string的用法