数组，对象，字符串-高频面试2022

一、数组**

检测数组：
instanceof运算符：

let arr = [1,2,3];
console.log(arr instanceof Array); //true

constructor
判断实例（arr）的构造函数是否等于某个对象。

let arr = [1,2,3];
console.log(arr.constructor == Array); //true

Arrqy.isArray
ES5新增数组方法，判断数组是不是数组。

let arr = [1,2,3];
console.log(Array.isArray(arr)); //true

Object.prototype.toString.call()
把对象转化成字符串和一个已知的对象进行对比

let arr = [1,2,3];
let str = '1111'
console.log(Object.prototype.toString.call(arr)); //[object Array]
console.log(Object.prototype.toString.call(str)); //[object String]

注意：
typeof 可用于检测Function、String、number、Undefined等常用的数据类型
但是无法检测Array数组对象。

删除数组的某一项：

1. 删除数组中的某一项？ 删除数组中对象的某一个属性？

 //  删除数组
      let arr = [1,2,34,5,6];
      arr.splice(1,1) // 删除第二项，删除一项
      某一项
// 方法1：  删除数组中对象的某一个属性
   let arr = [1,2,3,4,{name:'xiao',age:12, },6,7]
     for (const key in arr) {
          // 删除id属性
          if( typeof arr[key] == 'object'){
            delete arr[key].name;
          }
   }
   console.log('arr---',arr) //原数组没有 name:‘xiao’  这一属性
// 方法2：  删除数组中对象的某一个属性
 let newArr =  arr.find(item =>{
    if( typeof item== 'object'){
      return item
    }
   })
  delete newArr.name
  console.log('newArr', newArr)
  

2. forin和for of，Object.keys(),Object.valuses(),Object.entries()

for in

• L只能获得对象的键名，不能获得键值
• for…in 循环不仅遍历数字键名，还会遍历手动添加的其它键，甚至包括原型链上的键。for…of 则不会这样
• for…in 循环主要是为了遍历对象而生，不适用于遍历数组

for of

• 允许遍历获得键值

• 对于普通对象，没有部署原生的 iterator 接口，直接使用 for…of 会报错
  for…of 循环可以与break、continue 和 return 配合使用，跳出循环。foreach则不会

• for…of 循环可以用来遍历数组、类数组对象，字符串、Set、Map 以及 Generator 对象

Object.keys
也是遍历的一种方法，它会遍历对象的key值，返回到一个数组；如果用它遍历一个数组的话会返回数组的索引值成为一个数组；遍历字符串时也把字符串分割为数组之后返回索引值；

 let a = {a: '11', b: '22'}
      console.log('aaaa', Object.keys(a))    // ['a','b']

Object.values
是遍历数组的每一个value值，返回一个数组；遍历时遇到symbel会忽略；而且只会遍历自己本身可遍历属性
同上的例子；改为Object.values(a)

 let a = {a: '11', b: '22'}
      console.log('aaaa', Object.values(a))   // ['11', '22']

Object.entries
Object.entries()返回一个数组，其元素是与直接在object上找到的可枚举属性键值对相对应的数组。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。

const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// array like object
const obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// array like object with random key ordering
const anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// getFoo is property which isn't enumerable
const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });
myObj.foo = 'bar';
console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]

// non-object argument will be coerced to an object
console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]

// iterate through key-value gracefully
const obj = { a: 5, b: 7, c: 9 };
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key} ${value}`); // ['a': 5, 'b': 7, 'c': 9]
}

// Or, using array extras
Object.entries(obj).forEach(([key, value]) => {
console.log(`${key} ${value}`); // ['a': 5, 'b': 7, 'c': 9]
});

3. 递归

<script>
	let arr = [{
      num: 1,
      children: [
        {
          num: 11,
          children: [
            {
              num: 111
            },
            {
              num: 112
            },
            {
              num: 113
            }
          ]
        }
      ]
    }]


    //  递归的方法
    let numArr = []
    function recurrence(arr) {
      arr.forEach(item => {
        if (item.children) {
          recurrence(item.children)
        } else {
          // 不是数组，push到新数组
          numArr.push(item)
        }
      })
    }
    recurrence(arr)
</script>

4. 数组铺平（递归的方法）

 var arr6 = [1, 2, [3, 4, [5, 6]]];
	 function flatten(arr){
		    var res=[];
        arr.forEach(item =>{
          if(Array.isArray(item)){
            res = res.concat(flatten(item))
		        }else{
              res.push(item);
		        }

        })
		    return res;
	}
   console.log( flatten(arr6));// [1, 2, 3, 4, 5, 6]

4. 比较两个数组的内容是否相同并取出

方法1:

//找出相同的内容
var arr1 = [1, 2, 3,];//原数组
var arr2 = [1, 2, 3, 4];//新数组
//首先循环新数组
 let list = arr2.filter(items => {
 	//循环拿到新数组的值 使用includes函数去原数组中查找
     if (!arr1.includes(items)){
     	//判断结构为true进入判断 并把内容返回给新数组
         return items;
     }
 })
 console.log(list);//[4]
 //找出相同的内容把不等于“！”去除即可

方法2：

let arr1 = [],
    arr2 = [1, 2, 3, 4, 5],//原数组
    arr3 = [7, 5,8,9] //新数组
//同样是循环新数组，拿到每一个值
arr1 = arr3.filter(item => {
    let arrList = arr2.map(it => it)
    return !arrList.includes(item)
})
console.log(arr1)

方法3：

二、对象

检测对象：
删除对象的某个属性：

var obj={
	name: 'zhagnsan',
	age: 19 
}
delete obj.name //true
typeof obj.name //undefined

删除数组中，某一个对象中的属性
方式一：（for循环）删除数组对象中的某个属性，如删除id属性

let newArr = [
	{title:'小明', id:18},
	{title:'小红', id:16}
]
for (const key in newArr) {
// key是下标，
   // 删除id属性,newArr[key]拿到第一项
   delete newArr[key].id;  // 是把id的属性值与value一起删掉
}

三、字符串,数组转字符串

检测字符串typeof, Object.prototype.toString.call()

数组转字符串：

1. 数组中 toString() 方法能够把每个元素转换为字符串，然后以逗号连接输出显示。

var a = [1,2,3,4,5,6,7,8,9,0];  //定义数组
var s = a.toString();  //把数组转换为字符串
console.log(s);  //返回字符串“1,2,3,4,5,6,7,8,9,0”
console.log(typeof s);  //返回字符串string，说明是字符串类型

2.下面使用 toLocalString() 方法读取数组的值

var a = [1,2,3,4,5];  //定义数组
var s = a.toLocalString();  //把数组转换为本地字符串
console.log(s);  //返回字符串“1,2,3,4,5,6,7,8,9,0”

3. 下面使用 join() 方法可以把数组转换为字符串。

join() 方法可以把数组转换为字符串，不过它可以指定分隔符。在调用 join() 方法时，可以传递一个参数作为分隔符来连接每个元素。如果省略参数，默认使用逗号作为分隔符，这时与 toString() 方法转换操作效果相同。

var a = [1,2,3,4,5];  //定义数组
var s = a.join("==");  //指定分隔符
console.log(s);  //返回字符串“1==2==3==4==5”

字符串转数组：

1. 下面使用 split() 方法把字符串转换为数组。

split() 方法是 String 对象方法，与 join() 方法操作正好相反。该方法可以指定两个参数，第 1 个参数为分隔符，指定从哪儿进行分隔的标记；第 2 个参数指定要返回数组的长度。

var s = "1==2== 3==4 ==5";
var a = s.split("==");
console.log(a);
console.log(a.constructor == Array);

2. 展开运算符
   展开运算符 ( …) 允许在需要多个元素（如数组文字）的地方扩展诸如字符串之类的可迭代对象。

这是将字符串扩展为字符数组的示例。正确处理采用两个代码单元的字符。

const text = "abc????";
const chars = [ ...text ];
console.log(chars);
//["a", "b", "c", "????"]

3. Array.from
   Array.from辅助创建从阵列状或迭代的对象的新数组。字符串既可迭代又类似于数组，因此，可以成功地将其转换为字符数组

const text = "abc????";
const chars = Array.from(text);
console.log(chars);
//["a", "b", "c", "????"]