JS高阶面试过

day1
1.学习目标：
    1.作用域和作用域链【30%】
    2.函数的进阶(箭头函数)【50%】
    3.闭包【20%】
2.作用域和作用域链【背】
    1.什么是作用域？
        标识符可以访问的范围
    2.什么标识符
        变量名、函数名、函数的形参、对象的属性
    3.作用域链的查找规则--就近原则
        先找自己，自己有就用自己的，自己没有，就一层层向上找。找到就不再找了，如果找到window没有找到就报错。
    4.作用域的分类
        1.全局作用域
        2.局部作用域
        3.块级作用域【ES6】

3.函数的进阶
    1.函数的声明
        1.声明式[最多]
            function xxx(){

            }
        2.表达式
            var 变量=function(){

            }
    2.函数的参数
        1.形参 占位置
        2.实参 实际的值
    3.函数的返回值
        如果没有返回值，默认返回undefinded

    4.参数的默认值
        es6的默认值
            function xxx(a,b,xxx="xxx"){

            }
    5. arguments[回顾]
        arguments实参的一个伪数组
        箭头函数没有这个对象

    6. rest参数[es6] 
        实参的数组
        function xxx(...参数名){

        }
    7.箭头函数
        由表达式改成箭头函数
        1.省略function,在()和{}之间添加=>
        2.如果函数体只有一行代码,{}和return省略
        3.如果形参只有一个，()省略。

    8.IIFE立即执行函数【了解】
        1.语法结构
            ;(function(){
                xxx
            })();
        2.作用？
            1.立即执行
            2.保护变量，形成一个块级作用域
            3.一般情况下，一个js文件只有一个iife函数

4.什么是闭包？【背】
    1.函数的标识符跨作用域。
    2.写法
        1.外部函数把内部函数返回去，内部函数要跨作用域。
            function xxx(){
                var num=100;
                return function(){
                    num++
                }
            }

            var fn=xxx();
            fn();
            fn();
            fn();
        2.外部函数把内部函数挂载window上，内部函数要跨作用域
    
            ;(function(){
                var num=100
                window.xxx=function(){
                    num++
                }
            })();
            xxx();
            xxx();
            xxx();
    3.作用
        1.保护变量，“间接访问变量”,形成一个简单的块级作用域。

 day2
 1.学习目标
    1.构造函数【30%】
    2.原型和原型链【60%】
    3.this的指向【10%】

2.构造函数
    1.构造函数的名称是大驼峰命名规则
    2.构造函数属性和方法都是挂载在this
    3.通过关键new得到实例对象
    4.构造函数没有返回值

  new关键字4步【背】
    1.创建一个空对象
    2.把this指向这个空对象
    3.执行this上的属性和方法
    4.把这个对象返回给实例对象
3.原型和原型链
    1.原型[背]： 
        1.每个函数(除开箭头函数)都有一个原型，prototype.也可以叫显式原型,他的值是一个对象哟。
        2.每个对象都有一个__proto__,他隐式原型，他指向构造函数的prototype.
            对象的隐式原型(__proto__)指向他的构造函数的显式原型(prototype)。
        3.显式原型里面constructor(构造器)，他指向构造函数本身。
        4.原型链查找规则--就近原则
            自己有就用自己的，自己没有就一层层向上找，如果找了就不再找了。如果一直没有找到就报错。

4.this的指向---看在哪里调用，不看在哪里写。
    1.全局的this 指向window
    2.一般函数的this 谁调用指向谁【!!】
    3.对象的this 谁调用指向谁【!!】
    4.事件处理函数 指向事件源
    5.构造函数this 指向实例对象
    6.定时器的this 指向window
    7.箭头函数this 指向上一级

    借来的this
        1.立即执行
            call
            apply

            要借的对象.要借的方法.call(借给谁,参数1,参数2...)
            要借的对象.要借的方法.apply(借给谁,[参数1,参数2...])
        2.永久借
            bind
            新的方法=要借的对象.要借的方法.bind(借给谁,参数1,参数2...)

        区别：
            call和bind是一样的，使用参数列表，apply是数组
            call和apply立即执行，bind永久借。
            

day3
1.学习目标：
    1.深浅拷贝【60%】
    2.变量的检测【20%】
    3.ES5继承【背20%】

2.深浅拷贝
    1.变量的内存分配
        基本类型存储在栈内存中。
        引用类型他的名存储在栈内存，数据存储在堆内存中，通过地址(指针)链接起来。

    2.变量的拷贝
        基本类型拷贝只是值，引用类型拷贝是地址，数据共享的问题。

    3.变量的传递
        基本类型传递只是值，引用类型传递是地址，数据共享的问题。

    4.浅拷贝
        1.for...in
        2.Object.assgin() 对象的合并 第一个参数传递一个空对象

    5.深拷贝
        JSON2个核心方法

3.检测变量类型
    1.typeof 检测 number/string/boolean/undefined/function
    2.instanceof  变量 instanceof 构造函数
    3.Array.isArray() 是不是数组 判断数组和对象
    4.Object.prototype.toString.call() 万能检测变量类型

4.ES5继承【背】
    1.子类要继承父类的属性 借来的this call apply
    2.子类要继承父类原型上的方法 Object.create()
    3.子类原型上构造器要重新指向自己本身
    4.子类的原型上添加自己的方法

    
    day4
    1.学习目标：
    1.ES6的语法糖【40%】
    2.ES6的class【40%】
    3.ES6的模块【20%】

2.ES6的语法糖
    1.解构
        1.对数组的解构---两个变量交换值
        2.对对象的解构---后端拿来的数组
        3.对函数形参的解构---数组的解构

    2.展开运算符
        1.字符串的展开---转数组、字符串翻转
        2.数组的展开---浅拷贝、合并数组、转真数组
        3.对象的展开---浅拷贝、对象的合并
    3.模板字符串

    4.对象的简明表达方式
        1.如果key和value是一样的，就只写一个
        2.:function省略

3.ES6的class
    1.关键字class
    2.constuctor构造器，相当于构造函数，如果不写，自动创建一个空的构造器。在new的时候自动调用
    3.静态方法，关键字 static。只能类去调用，实例对象不能调用。

    4.ES6的继承
        1. 子类继承父类  子类 extends 父类
        2. super() 超类、父类 不需要改变this指向

4.ES6的模块
    1.语法一
        导出 export 导出的内容1
        导入 import {xxx,xxx}  from "路径/文件"

    2.语法二
        导出 export default {xxx,yyy,zzz}
        导入  import 变量  from "路径/文件"

    3.注意：
        1.路径和后缀名不能省略
        2.script type="module"
        3.只能live server打开

    4.模块
        一个js文件就是一个模块。


        day5
        1.学习目标
    1.Promise【30%】
    2.axios【35%】
    3.async和await【35%】


2.同步和异步
    同步：一步步走
    异步：先走完同步，再执行异步。常见异步：定时器、ajax、回调函数


3.Promise
    1.基本语法
        new Promise((resolve, reject)=>{
            if(true){
                resolve("成功");//成功
            }else{
                reject("失败");//失败
            }
        })
        .then(data=>console.log(data))
        .catch(err=>console.log(err))

4.axios
    1.什么是axios
        Axios 是一个基于 promise 的 HTTP 库，可以用在浏览器和 node.js 中。
5.async和await
    1.async修饰函数，写在函数前面。表明这个函数有异步操作
    2.await只能出现在async修饰的函数内。
    3.和Promise配合使用。