JS原生面试题

1.ES6的新特性：
let(声明变量)
const(声明常量,常量不能修改的量)
var、let、const的区别
1. let和const声明变量不存在变量提升，如果要使用这个变量，我们需要在变量定义之后使用;
2. let和const不能重复声明变量，如果重复声明会报错;
3. 用let 和 const 在全局声明变量不会给window增加属性;
4. let和const出现在代码块中，会把代码块(字面量声明对象除外)变成块级作用域,并且出现暂时 性死区 class(创建类)
import/export(基于ES6的模块规范创建导入/导出模块(文件/组件))
new set(数组去重)
Symbol(唯一的值) ** var a = Symbol(‘qqq’)
…ary(展开运算符、剩余运算符)
${} 模板字符串 **
解构赋值 let {a} = obj; let [b] = ary
for of 循环
()=>{} 箭头函数
箭头函数与普通函数的区别：
1. 箭头函数是匿名函数，不能作为构造函数，不能使用new
2. 箭头函数没有原型属性
3.this指向不同，箭头函数的this是定义时所在的对象，普通函数看前面有没有.,点前面是谁this 就是谁,没有.就是window
4. 不可以使用arguments对象，该对象在函数体内不存在。
**数组新增方法：**some every filter reduce …
对象新增方法： Object.assign() Object.values() Object.keys() Object.create()…

2.JS的数据类型：
基本数据类型: number 数字； boolean 布尔值 :有两个值 true、false ；string 字符串
null 空对象； undefined 未定义的值(很多浏览器的初始值是undefined)
Symbol() 产生一个唯一的值,和谁都不重复

null和undefined的区别：
null 是一个表示"无"的对象，转为数值时为 0
undefined 是一个表示"无"的原始值，转为数值时为 NaN  
  当声明的变量还未被初始化时，变量的默认值为 undefined
null 用来表示尚未存在的对象，常用来表示函数企图返回一个不存在的对象  
undefined 表示 “缺少值”，就是此处应该有一个值，但是还没有定义。
  典型用法是：
  1. 变量被声明了，但没有赋值时，就等于 undefined
  2. 调用函数时，应该提供的参数没有提供，该参数等于 undefined
  3. 对象没有赋值的属性，该属性的值为 undefined
  4. 函数没有返回值时，默认返回 undefined  
null 表示“没有对象”，即该处不应该有值。
  典型用法是：
  1. 作为函数的参数，表示该函数的参数不是对象
  2. 作为对象原型链的终点
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
引用数据类型:
对象
.普通对象
.数组对象
.正则对象(匹配字符串的规则)
.日期对象
.函数对象
…
对象的存储过程：
1. 开辟一个空间地址
2. 把键值对存储到这个空间地址的堆内存中
3. 把这个对象指针赋值给变量名

let obj = { 
  a:1, 
  fn:(function (val) {
    // 赋给fn的是自执行函数的执行结果 也就是一个undefined
    // 该自执行函数只会执行一次
    console.log(val);
  })(obj.a) 
};
let obj2 = obj;// 两者代表了同一个地址；
// 获取属性的值 obj.fn 或者 obj['fn']
// 新增属性： obj.c = 100 或者 obj['c'] = 100
// 真删除 delete obj.a (在严格模式下不支持该方法)； 假删除： obj.a = null;

// 引用类型小习题
let a = 3;
let b = new Number(3);
let c = 3;
console.log(a == b);
console.log(a === b);
console.log(b === c);
//=========================
const a = {};
const b = { key: "b" };
const c = { key: "c" };
a[b] = 123;
a[c] = 456;
console.log(a[b]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
基本数据类型与引用数据类型的区别：
基本数据类型是操作值,引用数据类型操作的是堆内存空间地址

布尔值转换:0 NaN '' null undefined 转化成布尔值是false，其余的都是true
检验有效数字的方法：isNaN
常用的数据类型检测方式: typeof constructor instanceof Object.prototype.toString.call()
1
2
3
比较运算符:
== 相对比较：会进行默认的类型转化； 若转换之后的值相等，则结果就是true
=== 绝对比较，值不但要相同、类型也得相同。
引用数据类型之间的比较，就看是不是同一个地址；
逻辑运算符:
|| 表示或者,前边成立给前边，前边不成立给后边
&& 表示并且前边成立给后边，前边不成立给前边

3.定义函数的方法
1.function声明

//ES5
function getSum(){}
function (){}//匿名函数
//ES6
()=>{}
1
2
3
4
5

2.函数表达式

//ES5
var getSum=function(){}
//ES6
let getSum=()=>{}
1
2
3
4
3.构造函数

const getSum = new Function('a', 'b' , 'return a + b')
1
4.JS作用域的理解
JS中的作用域分为两种：
    全局作用域和函数作用域。
  函数作用域中定义的变量，只能在函数中调用，外界无法访问。
  没有块级作用域导致了if或for这样的逻辑语句中定义的变量可以被外界访问，
  因此ES6中新增了let和const命令来进行块级作用域的声明。
  
  //循环绑定的问题
  for (var i = 0; i < 3; i++) {
    setTimeout(() => console.log(i), 1);
  }
  for (let i = 0; i < 3; i++) {
    setTimeout(() => console.log(i), 1);
  }

//作用域链  变量的查找机制
// 上级作用域  函数在哪里定义的，那么该函数执行形成的作用的上级作用域就是谁
// 了解了上级作用域， 就比较容易查找变量对应的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
5.闭包的理解
简单来说闭包就是在函数里面声明函数，本质上说就是在函数内部和函数外部搭建起一座桥梁，使得子函数可以访问父函数中所有的局部变量，但是反之不可以，这只是闭包的作用之一，另一个作用，则是保护变量不受外界污染，使其一直存在内存中，在工作中我们还是少使用闭包的好，因为闭包太消耗内存，不到万不得已的时候尽量不使用。

6.数组
// 数组去重
1、双for循环去重
2、利用对象的属性名不能重复去重
3、利用es6的Set不能重复去重
（具体代码自己查）
1
2
3
4
5
// 数组重组  （将name值相同的合并，并去除age的属性）
let ary = [
    {name:1,age:2,number:1,son:'son1'},
    {name:2,age:23,number:2,son:'son2'},
    {name:2,age:22,number:3,son:'son3'},
    {name:1,age:12,number:4,son:'son4'},
    {name:1,age:42,number:5,son:'son5'}
]
fn(ary) // 结果为
[
  {
    "name":1,
    "list":[{"number":1,"son":"son1"},{"number":4,"son":"son4"},{"number":5,"son":"son5"}]
  },
  {
    "name":2,
    "list":[{"number":2,"son":"son2"},{"number":3,"son":"son3"}]
  }
]
function fn(ary){
    let arr = [];
    ary.forEach(item=>{
        let bol = arr.some(val=>{
            if(val.name===item.name){
                let obj = {};
                Object.keys(item).forEach(v=>{
                    if(v!='name'&&v!='age'){
                        obj[v] = item[v]
                    }
                })
                val.list.push(obj);
                return true
            }
        })
        if(!bol){
            let obj = {};
            Object.keys(item).forEach(v=>{
                if(v!='name'&&v!='age'){
                    obj[v] = item[v]
                }
            })
            arr.push({name:item.name,list:[obj]});
        }
    })
    return arr;
}
fn(ary)

// 数组扁平化
var arr = [
  [1, 2, 2],
  [3, 4, 5, 5],<