Promise消除回調(diào)地獄

方法一：

/*需要借助Promise來消除回調(diào)嵌套       鏈式調(diào)用*/
let promiseAjax = function(json) {
    return new Promise((resolve, reject) => {
        $.ajax({
            url: json.url,
            dataType: json.dataType,
            type: 'json',
            success(data) {
                resolve(data);
            },
            error(err) {
                reject(err);
            }
        })
    })
}
promiseAjax({
    url: '1.json',
    type: 'get',
    dataType: 'json',
}).then(data => {
    console.log(data);
}).catch(erro => {

})

方法二：

/* 當所有的異步全部成功之后才會執(zhí)行then，只要有一個異步執(zhí)行失敗，就會執(zhí)行catch    all([promise,....]).then(allData = >{}).catch(err =>{})  */
let promiseAjax = url => {
    return new Promise((resolve, reject) => {
        $.ajax({
            url,
            dataType: 'json',
            success(data) {
                resolve(data)
            },
            error(err) {
                reject(err)
            }
        })
    })
}
let p1 = promiseAjax('1.json');
let p2 = promiseAjax('2.json');
Promise.all([p1, p2]).then(resolve => {
    console.log(resolve)
})

//jQuery3.X版本之后ajax方法中會自動返回一個Promise對象

Export 和 export default的區(qū)別

1. export與export default均可用于導出常量、函數(shù)、文件、模塊等
2. 在一個文件或模塊中，export、import可以有多個，export default僅有一個
3. 通過export方式導出，在導入時要加{ }，export default則不需要
4. 1. 輸出單個值，使用export default
   2. 輸出多個值，使用export
   3. export default與普通的export不要同時使用

Export 和 module.export的區(qū)別

通常exports方式使用方法是：

exports.[function name] = [function name]

moudle.exports方式使用方法是：

moudle.exports= [function name]

這樣使用兩者根本區(qū)別是

exports 返回的是模塊函數(shù)

module.exports 返回的是模塊對象本身，返回的是一個類

使用上的區(qū)別是

exports的方法可以直接調(diào)用

module.exports需要new對象之后才可以調(diào)用

面向?qū)ο蟮睦^承

ES6繼承

Class A extends B{
    Constructor(){
        Super();
    }
    方法名(){
        Super.方法名();
    }
}

ES5繼承

// 原型鏈式繼承
function SuperType() {

    this.property = true;
    
}

SuperType.prototype.getSuperValue = function () {

    return this.property;
    
}
function SubType() {

    this.subpropertype = false;
    
}

SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function () {

    return this.subpropertype;
    
}

var ins = new SubType();

console.log(ins.subpropertype);//false

console.log(ins.getSuperValue());//true

//構(gòu)造函數(shù)式繼承

function SuperType(){

    this.color=['1','2','3','4'];
    
}
function SubType(){

    SuperType.call(this);
    
}

var ins1=new SubType();

ins1.color.pop()

console.log(ins1.color);//[1,2,3]

var ins2=new SubType()

ins2.color.push('5');

console.log(ins2.color);//[1,2,3,4,5]

優(yōu)點：可以在子類型構(gòu)造函數(shù)中向超類型構(gòu)造函數(shù)傳遞參數(shù)

缺點：在超類型的原型中定義的方法，對子類型而言也是不可見的，結(jié)果所有類型都只能ES6的新特性

Function Parent (){
}

Parent.prototype=function fn(){

}

Function Child(){
        Parent.apply(this,arguments)
}

New關鍵字的作用

// 因為JS中，對象都是new 對應的函數(shù)()創(chuàng)建出來的，

// new 關鍵字對函數(shù)的影響(new關鍵字到底做了什么)：

// 1.在該函數(shù)內(nèi)部創(chuàng)建一個對象

// 2.函數(shù)內(nèi)部的this指向創(chuàng)建出來的的這個對象

// 3.對象的proto指向函數(shù)的prototype

// 4. 函數(shù)默認返回該對象

作用域鏈和原型鏈

作用域鏈

當代碼在一個環(huán)境中執(zhí)行時，會創(chuàng)建變量對象的一個作用域鏈（scope chain，不簡稱sc）來保證對執(zhí)行環(huán)境有權(quán)訪問的變量和函數(shù)的有序訪問。

簡單來說外面的不能訪問作用域里定義的變量，作用域里定義的變量可以訪問上級作用域的變量。

原型鏈

當試圖訪問一個對象的屬性時，它不僅僅在該對象上搜尋，還會搜尋該對象的原型，以及該對象的原型的原型，依次層層向上搜索，直到找到一個名字匹配的屬性或到達原型鏈的末尾。原型鏈的末尾就是Object對象。