前端学习总结——JavaScript基础语法

变量类型和计算

• 值类型和引用类型
  • 值在栈中存储，i = 1，将 i 的值赋值给 j ，在栈中新开辟一块区域存储 j = 1，j 跟 i 是两个独立的值，各自占用一块内存空间；
  • 引用类型在堆中存储，a = {x: 20}，a在堆中申请一个内存地址1，把值放在这个地址上，变量a在栈中保存，其值为内存地址1，这个地址指向{x: 20}这个对象，当把a赋值给b，其实是把地址1赋值给b，经过b修改这个对象，a也会改变，也就是“传址”；
  • 值类型和引用类型的保存其实是计算机一种性能优化的手段，几乎全部语言都是这样保存数据的，因为值类型比引用类型占用的内存小，赋一次值开辟一块内存来存储一个值类型的数据也还无妨。
  • 写个深拷贝的实现：

function deepClone (obj = {}) {
    if (typeof obj !== 'object' || obj == null){
        // 不是对象或者数组, 直接返回
        return obj;
    }
    let result;
    if (obj instanceof Array) {
        result = [];
    } else {
        result = {};
    }

    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            // 保证 key 不是原型的属性
            //递归
            result[key] = deepClone(obj[key]);
        }
    }
    return result;
}

• 类型判断
  • typeof能判断哪些类型?
    • 数据类型分简单数据类型/复杂数据类型（原始类型/对象类型, 值类型/引用类型 ），简单数据类型有： undefined\number\string\Boolean\symbol，复杂数据类型：object\function\null\array\RegExp；
    • typeof 可以检测全部值类型, 识别函数, 判断是不是引用类型(object: array, obj, null), 不可再细分, 更具体的 array 等引用类型须要用到 instanceof 来进行检测；
    • 函数 function 是特殊的引用类型, 但不用于存储数据, 因此没有拷贝\复制函数一说。

原型和原型链

• 原型：建立一个构造函数函数，它会按照规则建立一个prototype属性，这个属性指向原型对象，这个原型对象上有一个默认constructor属性指回这个构造函数。原型上的非手动添加的属性和方法都继承自上一级构造函数的原型，调用这个构造函数建立新的实例，这个实例上的__proto__指针就被赋值为构造函数的原型对象。

　　　实例与构造函数的原型之间有直接的联系，可是实例与构造函数之间没有。

• 原型链：原型是有层级的，实例经过原型继承属性和方法。每一个构造函数都有一个原型，原型上有一个属性指回构造函数，而实例上有一个内部指针__proto__指向原型。原型多是另外一个构造函数的实例，那么他也有一个指针__proto__指向它的构造函数的原型，这种关系能够是不少层的，这就在实例和原型之间造成一条原型链。

　　  原型链的顶端是object.prototype，其上定义的toString()、valueOf()、hasOwnProperty()。

　　  实例的隐式原型引用的是对应构造函数的显式原型：children.__proto__  === Parent.prototype

• instanceof操做符：instanceof 返回一个布尔值，方法只要原型链上沾边就是true, [] instancemof Array/Object 返回true；
•  手写jQuery考虑插件和扩展性代码

class jQuery {
    constructor(selector) {
        const result = document.querySelectorAll(selector);
        const length = result.length;
        for (let i = 0; i < length; i++) {
            this[i] = result[i];
        }
        this.length = length;
        this.selector = selector;
    }
    get(index) {
        return this[index];;
    }
    each(fn) {
        for (let i = 0; i < this.length; i++) {
            const elem = this[i];
            fn(elem)
        }
    }
    on(type, fn) {
        return this.each(elem => {
            elem.addEventListener(type, fn, false)
        })
    }
}
    // 本身写的jQuery插件
    jQuery.prototype.dialog = function (info) {
    alert(info);
}
// 造轮子
class myJQuery extends jQuery {
    constructor(selector) {
        super(selector);
    }
    // 扩展本身的方法
    addClass(className) {
        
    }
    style(data) {

    }
}

 

做用域和闭包

• 自由变量：一个变量在当前做用域内没有被定义，可是被使用了，会向上层做用域逐级寻找，直到顶级做用域没找到报错：XX is not defined
• 闭包：是做用域应用的特殊状况，函数做为参数被传递或者函数做为返回值返回，函数做为返回值的时候，函数定义在局部做用域，在全局做用域调用的时候，局部做用域内定义的自由变量，在定义的地方向上级逐级查找变量的值，而不是在全局做用域处调用的地方向上查找自由变量的值；函数做为参数被传递的时候，函数定义在全局做用域，在局部做为参数被调用，仍是在定义的地方去向上级查找自由变量的值。
• 利用闭包隐藏数据, 作一个简单的cache工具

function createCache() {
    const data = {}; // 闭包中的数据, 被隐藏, 不被外界访问
    return {
        set: function(key, val) {
            data[key] = val;
        },
        get: function(key) {
            return data[key];
        }
    }
}

const c = createCache();
c.set('a', 100);
console.log(c.get('a'));

 

• this指向：this的指向是由调用的时候决定的，不是由定义的时候决定的：
  • 在普通函数中：window
  • 在对象方法中被调用：指向对象自己
  • 经过call、apply、bind：根据传入的值来决定
  • 在class中：当前实例自己
  • 在箭头函数中：箭头函数没有this，须要向上级做用域的this寻找
• 写一个bind方法：

Function.prototype.bind1 = function () {
    // **将参数列表拆解为数组
    const args = Array.prototype.slice.call(arguments); 
    // 获取this ( 数组第一项 )
    const this1 = args.shift();
    // fn1.bind( ... )中的 fn1
    const self = this;
    // 返回一个函数
    return function() {
        return self.apply(this1, args);
    };
}

 

• 写一个call方法：

Function.prototype.myCall = function (ctx, ...args) {
            if (typeof this !== 'function') {
                throw new Error('not a function')
            }
            let fn = Symbol();
            ctx = ctx || window;
            ctx[fn] = this;
            ctx[fn](...args);
            delete ctx[fn];
        }
        function fn1(a, b) {
            console.log(this.name);
            console.log(a, b);
        }

 

• 写一个apply方法：

 Function.prototype.myApply = function (ctx, args = []) {
            if (typeof this !== 'function') {
                throw new Error('not a function')
            }
            let fn = Symbol();
            ctx = ctx || window;
            if(!(args instanceof Array)){
                throw new TypeError('请输入数组做为参数');
            }
            ctx[fn] = this;
            ctx[fn](...args);
            delete ctx[fn];
        }

 

异步

• 如何理解JS是单线程语言？
  • JS主线程在同一时间只能执行一个任务，而像网络请求、定时器等须要耗时的任务，咱们浏览器遇到这些不能等待，会将耗时的任务放在队列中，等待主线程的任务执行完，再执行。这种异步的方式不阻塞代码的执行。
• 什么是异步编程？
  • JS是单线程语言，主线程只能同一时间执行一个任务，待主线程执行完再去任务队列里面轮询任务，在执行任务期间，中间进来的任务都是排列在任务队列里。代码间有相互依赖关系，要求任务队列按照必定的次序排列，大量会用到嵌套来解决这个问题，但嵌套会增长代码复杂性，甚至产生“回调地狱”。ES6的promise语法是一种异步编程机制，解决大量的回调的问题。
• Promise：
  • 类型：Function
  • 参数：执行器函数，通常为两个函数参数，用于控制期约的状态转换。
  • 期约的状态：
    • pending：能够转化为兑现或者拒绝，一旦落定不可更改；
    • fulfilled/resolved
    • rejected
  • 传入的参数为一个promise对象，其兑现和拒绝的状态会被保留 ，向后传递，期约状态改变，不会再被重设，不可逆不可撤销；
  • then返回的也是一个promise，链式，成对的promise-then关系，下个then处理上一个返回的promise；
  • then/catch默认返回的是解决状态的promise
  • 最后放catch，统一对前面的错误进行处理
  • 用promise实现图片加载的函数：

function ajax(url) {
    const p = new Promise((resolve, reject) => {
        const xhr = new XMLHttpRequest();
        xhr.open('get', url, true);
        xhr.onreadystatechange = function () {
            if(xhr.readyState === 4) {
                if(xhr.status === 200) {
                    resolve(
                        JSON.parse(xhr.responseText)
                    )
                } else if (xhr.status === 404) {
                    reject(new Error('404 not found'))
                }
            }
        }
        xhr.send(null);
    })
    return p;
}