CSS

1、三欄布局問題（左右固定寬度 中間自適應(yīng)）

flex

<div class="container">
     <div class="left"></div>
     <div class="middle"></div>
     <div class="right"></div>
</div>

.container {
    display: flex;
}

.left, .right {
    width: 200px
}

.middle {
    flex: 1;
}

優(yōu)點(diǎn)：比較完美 移動端首選；
缺點(diǎn)：不兼容 ie9 及以下；

grid

<div class="container">
     <div class="left"></div>
     <div class="middle"></div>
     <div class="right"></div>
</div>


.container {
    display: grid;
    grid-template-columns: 200px auto 200px;
}

優(yōu)點(diǎn)：簡單強(qiáng)大 解決二維布局問題；
缺點(diǎn)：不兼容 ie9 及以下，很多國產(chǎn)手機(jī)瀏覽器有兼容問題；

float + margin

<div class="container">
     <div class="left"></div>
     <div class="middle"></div>
     <div class="right"></div>
</div>

.container {
    overflow: hidden;
}

.left {
    float:left;
    height:100%;
    width:200px;
}

.right {
    float:right;
    height:100%;
    width:200px;
}

.middle{
    height:100%;
    margin:0 200px;
}

優(yōu)點(diǎn)：快捷 簡單 兼容性較好;
缺點(diǎn): 有局限性 脫離文檔流 需要清除浮動等;

2、CSS 盒模型

margin-area: 外邊距區(qū)域；
border-area: 邊框區(qū)域；
padding-area: 內(nèi)邊距區(qū)域；
content-area: 內(nèi)容區(qū)域；

標(biāo)準(zhǔn)盒模型和 IE 盒模型：
標(biāo)準(zhǔn)盒模型： box-sizing 值為 content-box 時(shí)，在高度和寬度之外繪制內(nèi)外邊距以及邊框；
IE盒模型：box-sizing 值為 border-box 時(shí)，內(nèi)邊距和邊框在已設(shè)置的寬高內(nèi)繪制；

3、BFC

BFC（Block Formatting Context）塊級格式化上下文，是 Web 頁面中盒模型布局的 CSS 渲染模式，指一個(gè)獨(dú)立的渲染區(qū)域或者說是一個(gè)隔離的獨(dú)立容器。

形成條件：

• 浮動元素，float 除 none 以外的值；
• 定位元素，position（absolute，fixed）；
• display 為以下其中之一的值 inline-block，table-cell，table-caption；
• overflow 除了 visible 以外的值（hidden，auto，scroll）；

特征：

• 內(nèi)部的 Box 會在垂直方向上一個(gè)接一個(gè)的放置；
• 垂直方向上的距離由margin 決定；（解決外邊距重疊問題）
• bfc 的區(qū)域不會與 float 的元素區(qū)域重疊；（防止浮動文字環(huán)繞）
• 計(jì)算 bfc 的高度時(shí)，浮動元素也參與計(jì)算；（清除浮動）
• bfc 就是頁面上的一個(gè)獨(dú)立容器，容器里面的子元素不會影響外面元素；

4、外邊距重疊

塊的上外邊距(margin-top)和下外邊距(margin-bottom)有時(shí)合并(折疊)為單個(gè)邊距，其大小為單個(gè)邊距的最大值(或如果它們相等，則僅為其中一個(gè))，這種行為稱為邊距折疊。

注意有設(shè)定float和position=absolute的元素不會產(chǎn)生外邊距重疊行為。

相關(guān)文章：MDN 文檔

DOM

1、DOM 事件級別

DOM 0級：

寫法：el.οnclick=function(){}
DOM 0事件綁定，給元素的事件行為綁定方法，這些方法都是在當(dāng)前元素事件行為的冒泡階段(或者目標(biāo)階段)執(zhí)行的。

DOM 2級

寫法：el.addEventListener(event-name, callback, useCapture)
event-name: 事件名稱，可以是標(biāo)準(zhǔn)的DOM事件；
callback: 回調(diào)函數(shù)，當(dāng)事件觸發(fā)時(shí)，函數(shù)會被注入一個(gè)參數(shù)為當(dāng)前的事件對象 event；
useCapture: 默認(rèn)是false，代表事件句柄在冒泡階段執(zhí)行；

DOM 3級

寫法和DOM2級一致 只是在DOM 2級事件的基礎(chǔ)上添加了更多的事件類型
新增事件：

• UI事件，當(dāng)用戶與頁面上的元素交互時(shí)觸發(fā)，如：load、scroll；
• 焦點(diǎn)事件，當(dāng)元素獲得或失去焦點(diǎn)時(shí)觸發(fā)，如：blur、focus；
• 鼠標(biāo)事件，當(dāng)用戶通過鼠標(biāo)在頁面執(zhí)行操作時(shí)觸發(fā)如：dblclick、mouseup；
• 滾輪事件，當(dāng)使用鼠標(biāo)滾輪或類似設(shè)備時(shí)觸發(fā)，如：mousewheel；
• 文本事件，當(dāng)在文檔中輸入文本時(shí)觸發(fā)，如：textInput；
• 鍵盤事件，當(dāng)用戶通過鍵盤在頁面上執(zhí)行操作時(shí)觸發(fā)，如：keydown、keypress；
• 合成事件，當(dāng)為IME（輸入法編輯器）輸入字符時(shí)觸發(fā)，如：compositionstart；
• 變動事件，當(dāng)?shù)讓覦OM結(jié)構(gòu)發(fā)生變化時(shí)觸發(fā)，如：DOMsubtreeModified；

2、事件模型 事件流

事件模型： 捕獲和冒泡；
事件流：

• 捕獲階段：事件從 window 對象自上而下向目標(biāo)節(jié)點(diǎn)傳遞階段；
• 目標(biāo)階段：目標(biāo)節(jié)點(diǎn)處理對應(yīng)事件；
• 冒泡階段：事件從目標(biāo)節(jié)點(diǎn)向 window 對象自下而上傳播階段；

3、事件代理

由于在冒泡階段事件從下而上傳播，因此可以將子節(jié)點(diǎn)的監(jiān)聽函數(shù)放置在父節(jié)點(diǎn)上，統(tǒng)一處理子節(jié)點(diǎn)的事件。減少內(nèi)存消耗，提高性能(不需要為每一個(gè)子元素綁定事件)。

4、Event 對象

阻止默認(rèn)行為：

event.preventDefault()

阻止冒泡：

• event.stopPropation 阻止事件冒泡到父元素
• event.stopImmediatePropation 既能阻止事件向父元素冒泡，也能阻止元素同事件類型的其它監(jiān)聽器被觸發(fā)

target 和 currentTarget：

currentTarget始終是監(jiān)聽事件者，而target是事件的真正發(fā)出者。

5、自定義事件

// 創(chuàng)建事件：
// event 不能傳參
let event = new Event('eventName')
// CustomEvent是可以傳遞參數(shù)的
let customEvent = new CustomEvent('eventName',  {})
// 監(jiān)聽事件
/*
*  addEventListener(event, function, useCapture)
*  useCapture 指定事件是否 在捕獲或冒泡階段執(zhí)行;
*      true - 事件在捕獲階段執(zhí)行
*      false- 默認(rèn),事件在冒泡階段執(zhí)行
*/
dom.addEventListener('eventName', function (e) {...}, false)

// 觸發(fā)事件
dom. dispatchEvent('eventName')

JavaScript

1、JavaScript 單線程

js 作為瀏覽器腳本語言，其主要用途是與用戶互動，以及操作DOM。如果存在多個(gè)線程就會有很復(fù)雜的同步問題，例如：一個(gè)線程在某個(gè)DOM節(jié)點(diǎn)上添加內(nèi)容，另一個(gè)線程刪除了這個(gè)節(jié)點(diǎn)，這時(shí)瀏覽器應(yīng)該以哪個(gè)線程為準(zhǔn)？

2、JavaScript 同步任務(wù)與異步任務(wù)

由于 js 單線程的特點(diǎn)，每次只能執(zhí)行單個(gè)任務(wù)。如果前序任務(wù)始終沒有結(jié)束，后序的任務(wù)只能等待，效率較低。所以增加了同步任務(wù)和異步任務(wù)的區(qū)分。

• 同步任務(wù)：在主線程上排隊(duì)執(zhí)行的任務(wù)，需要按順序一一執(zhí)行；
• 異步任務(wù)：不進(jìn)入主線程而是進(jìn)入任務(wù)隊(duì)列，只有通知主線程任務(wù)可以被執(zhí)行時(shí)，才會加入主線程執(zhí)行；

3、Event-Loop 事件輪詢：

Javascript 的“線程”有一種機(jī)制：在每次調(diào)用 JS 引擎時(shí)，可以隨著時(shí)間的推移執(zhí)行你的程序的多個(gè)代碼塊兒，這稱為“事件輪詢（Event Loop）。

JavaScript 實(shí)現(xiàn)異步的具體方式：

• 同步代碼直接執(zhí)行
• 異步函數(shù)放置到異步隊(duì)列中
• 同步代碼執(zhí)行完畢，異步隊(duì)列輪詢執(zhí)行

宏任務(wù)與微任務(wù)

宏任務(wù)：

分類：

特性：

• 宏任務(wù)所在的隊(duì)列就是宏任務(wù)隊(duì)列；
• 第一個(gè)宏任務(wù)隊(duì)列中只有一個(gè)任務(wù)：執(zhí)行主線程上的JS代碼；如果遇到上方表格中的異步任務(wù)，會創(chuàng)建出一個(gè)新的宏任務(wù)隊(duì)列，存放這些異步函數(shù)執(zhí)行完成后的回調(diào)函數(shù)；
• 宏任務(wù)中可以創(chuàng)建微任務(wù)，但是在宏任務(wù)中創(chuàng)建的微任務(wù)不會影響當(dāng)前宏任務(wù)的執(zhí)行；
• 當(dāng)一個(gè)宏任務(wù)隊(duì)列中的任務(wù)全部執(zhí)行完后，會查看是否有微任務(wù)隊(duì)列，如果有就會優(yōu)先執(zhí)行微任務(wù)隊(duì)列中的所有任務(wù)，如果沒有就查看是否有宏任務(wù)隊(duì)列；

微任務(wù)：

分類：

mutionObserver:

• 用來監(jiān)視 DOM 變動
• 等待所有腳本任務(wù)完成后，才會運(yùn)行，即采用異步方式
• 把 DOM 變動記錄封裝成一個(gè)數(shù)組進(jìn)行處理，而不是一條條地個(gè)別處理 DOM 變動
• 即可以觀察發(fā)生在 DOM 節(jié)點(diǎn)的所有變動，也可以觀察某一類變動

經(jīng)典面試題

console.log(1);

setTimeout(()=>{
    console.log(2);
    new Promise((resolve,reject)=>{
    console.log(3);
    resolve()
}).then(res=>{
    console.log(4);
})
})

new Promise((resolve,reject)=>{
    resolve()
}).then(res=>{
    console.log(5);
}).then(res=>{
    console.log(6);

})

new Promise((resolve,reject)=>{
    console.log(7);
    resolve()
}).then(res=>{
    console.log(8);
}).then(res=>{
    console.log(9);

})

setTimeout(()=>{
    console.log(10);
    new Promise((resolve,reject)=>{
    console.log(11);
    resolve()
}).then(res=>{
    console.log(12);
})
})

console.log(13);

輸出結(jié)果：
依次 1、7、13、5、8、6、9、2、3、4、10、11、12

4、創(chuàng)建對象：

• 字面量方式（簡單，運(yùn)行速度更快）

let obj = { test: a}

• 構(gòu)造函數(shù)

function Test () {
    this.test =  a
}
let obj = new Test()

• Object.create(proto, [propertiesObject])

//Object.create()方法創(chuàng)建的對象時(shí)，屬性是在原型下面的
let obj = Object.creat({test: a})

5、原型鏈：

原型鏈和原型對象是js的核心，原型鏈保證函數(shù)或?qū)ο笾械姆椒?、屬性可以讓向下傳遞，js通過原型鏈才得以實(shí)現(xiàn)函數(shù)或?qū)ο蟮睦^承

prototype 和 constructor:

prototype 指向函數(shù)的原型對象，只有函數(shù)才擁有該屬性。
constructor 指向原型對象的構(gòu)造函數(shù)。

_proto_:

每個(gè)對象都有 proto，指向了創(chuàng)建該對象的構(gòu)造函數(shù)原型。由于js中是沒有類的概念，而為了實(shí)現(xiàn)繼承，通過 proto 將對象和原型聯(lián)系起來組成原型鏈，就可以讓對象訪問到不屬于自己的屬性。

Foo、Function 和 Object 都是函數(shù)，它們的 proto 都指向 Function.prototype.

原型對象 _proto_都指向了 Object.prototype，js原型鏈最終指向的是 Object 原型對象。

總結(jié)

實(shí)例的 _proto_ 指向原型對象的 prototype，實(shí)例遠(yuǎn)行對象的 _proto_ 是 Object 的原型對象（null 除外）

image.png

舉例：

• instanceof 原理

<script>
function Person(){
}
function Foo(){
}

//顯示改變Foo.prototype指向Person的實(shí)例對象（原型繼承）

Foo.prototype=new Person()

let a=new Foo()

console.log(a.__proto__===Foo.prototype); //true

console.log(a instanceof Foo);//true

console.log(Foo.prototype.__proto__===Person.prototype);//true

console.log(a instanceof Person);//true

console.log(a instanceof Object);//true

// 這個(gè)時(shí)候改變Foo.prototype的指向

Foo.prototype={}

// Foo.prototype已經(jīng)不在a的原型鏈上面了

console.log(a.__proto__===Foo.prototype);//false

console.log(a instanceof Foo);//false

//Person.prototype依然在a的原型鏈上面

console.log(a instanceof Person);//true
</script>

• new運(yùn)算符原理
  1、創(chuàng)建一個(gè)新對象；
  2、將空對象的 _proto_ 指向構(gòu)造函的 prototype；
  3、使用apply調(diào)用構(gòu)造器函數(shù)，屬性和方法被添加到 this 引用的對象中；
  4、如果構(gòu)造函數(shù)中沒有返回其它對象，那么返回 this，即創(chuàng)建的這個(gè)的新對象，否則，返回構(gòu)造函數(shù)中返回的對象;

function _new(func) {
    // 第一步 創(chuàng)建新對象
    let obj= {};
    // 第二步 空對象的_proto_指向了構(gòu)造函數(shù)的prototype成員對象
    obj.__proto__ = func.prototype;//
    // 一二步合并就相當(dāng)于 let obj=Object.create(func.prototype)

    // 第三步 使用apply調(diào)用構(gòu)造器函數(shù)，屬性和方法被添加到 this 引用的對象中
    let result = func.apply(obj);
    if (result && (typeof (result) == "object" || typeof (result) == "function")) {
    // 如果構(gòu)造函數(shù)執(zhí)行的結(jié)果返回的是一個(gè)對象，那么返回這個(gè)對象
        return result;
    }
    // 如果構(gòu)造函數(shù)返回的不是一個(gè)對象，返回創(chuàng)建的新對象
    return obj;
}

5、繼承實(shí)現(xiàn)：

聲明父類：

function Father(name) {
      this.name = name || "father";
      this.sayName = function() {
        console.log(this.name);
      }
      this.color = ["red", "blue"]
}

Father.prototype.age = 18;
Father.prototype.sayAge = function() {
      console.log(this.age)    
}

1） 原型鏈繼承

function Son(name) {
    this.name = name || 'son'
}

Son.prototype = new Father()

優(yōu)點(diǎn)：

• 簡單易于實(shí)現(xiàn)；
• 父類新增的屬性和方法，子類都可以訪問到；

缺點(diǎn)：

• 無法實(shí)現(xiàn)多繼承，因?yàn)樵鸵淮沃荒鼙灰粋€(gè)實(shí)例更改；
• 來自原型對象的所有屬性被所有實(shí)例共享；
• 創(chuàng)建子類實(shí)例時(shí)，無法向父構(gòu)造函數(shù)傳參；

2）構(gòu)造繼承：復(fù)制父類的實(shí)例屬性給子類

function Son(name) {
    Father.call(this, '父級需要的參數(shù)')
    this.name = name
}

let s = new Son("son");
console.log(s.name); // son
//s.sayAge(); // 拋出錯(cuò)誤（無法繼承父類原型方法）
 s.sayName(); // son
console.log(s.age); // undefined （無法繼承父類原型屬性）
console.log(s instanceof Father); // false
console.log(s instanceof Son); // true

優(yōu)點(diǎn)：

• 解決了原型鏈繼承中子類實(shí)例共享父類引用屬性的問題；
• 創(chuàng)建子類實(shí)例時(shí)，可以向父類傳遞參數(shù)；
• 可以實(shí)現(xiàn)多繼承（call多個(gè)父類對象）；

缺點(diǎn)：

• 實(shí)例并不是父類的實(shí)例，只是子類的實(shí)例；
• 只能繼承父類實(shí)例的屬性和方法，不能繼承其原型上的屬性和方法；
• 無法實(shí)現(xiàn)函數(shù)復(fù)用，每個(gè)子類都有父類實(shí)例函數(shù)的副本，影響性能；

3）原型鏈、構(gòu)造函數(shù)組合繼承

使用原型鏈實(shí)現(xiàn)對原型屬性和方法的繼承，而通過構(gòu)造函數(shù)來實(shí)現(xiàn)對實(shí)例屬性的繼承。

function Son(name) {
   // 第一次調(diào)用父類構(gòu)造器 子類實(shí)例增加父類實(shí)例
    Father.call(this, "我是傳給父類的參數(shù)");
    this.name = name || "son";
}
// 經(jīng)過new運(yùn)算符 第二次調(diào)用父類構(gòu)造器 子類原型也增加了父類實(shí)例
Son.prototype = new Father();

let s = new Son("son");
console.log(s.name); // son
s.sayAge(); // 18
s.sayName(); // son
console.log(s.age); // 18
console.log(s instanceof Father); // true
console.log(s instanceof Son); // true
console.log(s.constructor === Father); // true
console.log(s.constructor === Son); // false

優(yōu)點(diǎn)：

• 彌補(bǔ)了構(gòu)造繼承的缺點(diǎn)，現(xiàn)在既可以繼承實(shí)例的屬性和方法，也可以繼承原型的屬性和方法；
• 既是子類的實(shí)例，也是父類的實(shí)例；
• 可以向父類傳遞參數(shù)；
• 函數(shù)可以復(fù)用；

缺點(diǎn)：

• 調(diào)用了兩次父類構(gòu)造函數(shù)，生成了兩份實(shí)例；
• constructor指向問題；

4）*寄生組合繼承：

通過寄生方式，砍掉父類的實(shí)例屬性，避免了組合繼承生成兩份實(shí)例的缺點(diǎn)；

function Son (name) {
    let f = Father.call(this, '傳遞給父級的參數(shù)')
    f.name = name || 'son'
}

# 借用Object.create()方法
Son.prototype = Object.create(Father.prototype)
Son.prototype.constructor = Son

# 自己動手創(chuàng)建一個(gè)中間類
// (function() {
//   let NoneFun = function() {};
//   NoneFun.prototype = Father.prototype;
//   Son.prototype = new NoneFun();
//   Son.prototype.constructor = Son;
// })();

let s = new Son("son");
console.log(s.name); // son
s.sayAge(); // 18
s.sayName(); // son
console.log(s.age); // 18
console.log(s instanceof Father); // true
console.log(s instanceof Son); // true
console.log(s.constructor === Father); // false
console.log(s.constructor === Son); // true

優(yōu)點(diǎn)：

• js實(shí)現(xiàn)繼承首選方式；

缺點(diǎn)：

• 實(shí)現(xiàn)較復(fù)雜（可通過Object.create簡化）；

5）實(shí)例繼承：為父類實(shí)例添加新特征，作為子類實(shí)例返回

function Son (name) {
    let f = new Father('傳遞給父級的參數(shù)')
    f.name = name || 'son'
    return f
}

let s = new Son("son"); //或者直接調(diào)用子類構(gòu)造函數(shù) let s = Son("son");
console.log(s.name); // son
s.sayAge(); // 18
s.sayName(); // son
console.log(s.age); // 18
console.log(s instanceof Father); // true
console.log(s instanceof Son); // false
console.log(s.constructor === Father); // true
console.log(s.constructor === Son); // false

優(yōu)點(diǎn)：

• 不限制調(diào)用方式，不管是new 的方式聲明子類還是通過直接調(diào)用函數(shù)方法聲明,返回的對象具有相同的效果；

缺點(diǎn)：

• 實(shí)例是父類的實(shí)例，不是子類的實(shí)例；
• 不支持多繼承；

6）拷貝繼承：對父類實(shí)例中的的方法與屬性拷貝給子類的原型

function Son (name) {
    let f = new Father('要傳給父級的數(shù)據(jù)')
    for (let k in f) {
        Son.prototype[k] = f[k]
    }
    Son.prototype.name = name
}

let s = new Son("son");
console.log(s.name); // son
s.sayAge(); // 18
s.sayName(); // son
console.log(s.age); // 18
console.log(s instanceof Father); // false
console.log(s instanceof Son); // true
console.log(s.constructor === Father); // false
console.log(s.constructor === Son); // true

優(yōu)點(diǎn)：

• 支持多繼承；

缺點(diǎn)：

• 效率低，性能差，占用內(nèi)存高（因?yàn)樾枰截惛割悓傩裕?/li>
• 無法獲取父類不可枚舉的方法（不可枚舉的方法，不能使用for-in訪問到)；

7）ES6 Class 繼承

class Son extends Father {
constructor(name) {
    super(name);
        this.name = name || "son";
      }
 }

let s = new Son("son");
console.log(s.name); // son
s.sayAge(); // 18
s.sayName(); // son
console.log(s.age); // 18
console.log(s instanceof Father); // true
console.log(s instanceof Son); // true
console.log(s.constructor === Father); // false
console.log(s.constructor === Son); // true

6、節(jié)流和防抖

節(jié)流：一定時(shí)間內(nèi)執(zhí)行的操作只執(zhí)行一次。

應(yīng)用場景：

• 鼠標(biāo)不斷點(diǎn)擊觸發(fā)，mousedown(單位時(shí)間內(nèi)只觸發(fā)一次)；
• 監(jiān)聽滾動事件，比如是否滑到底部自動加載更多（懶加載）；

function throttle (fn, timer) {
    let canRun = true
    return function () {
        if ( !canRun ) return 
        canRun = false
        setTimeout(() => {
            fn().apply(this, arguments)
            canRun = true
        }, timer)
    }
}

防抖：動作停止后的時(shí)間超過設(shè)定的時(shí)間時(shí)執(zhí)行一次函數(shù)。注意：這里的動作停止表示你停止了觸發(fā)這個(gè)函數(shù)，從這個(gè)時(shí)間點(diǎn)開始計(jì)算，當(dāng)間隔時(shí)間等于你設(shè)定時(shí)間，才會執(zhí)行里面的回調(diào)函數(shù)。如果你一直在觸發(fā)這個(gè)函數(shù)并且兩次觸發(fā)間隔小于設(shè)定時(shí)間，則函數(shù)一直不會執(zhí)行.

應(yīng)用場景：

• 搜索欄用戶輸入結(jié)束后，請求聯(lián)想數(shù)據(jù)；
• window resize時(shí)，頁面不斷調(diào)整會不斷觸犯；

function debance (fn, delayTime) {
    let timer = null
    return function () {
        if (timer) {
            clearTimeout(timer)      
        } 
        timer = setTimeout(() => {
            fn.call(this, arguments)
        },  delayTime)
    }
}

HTTP 相關(guān)

框架 Framework

1、SSR 框架的選擇， Nuxt、Next、Nest？

Next：性能居中，lighthouse 測試報(bào)告中比其他兩者低。
優(yōu)勢：

• 默認(rèn)情況每一個(gè)組件都是服務(wù)端渲染；
• 自動代碼拆分，加快頁面加載速度；

缺點(diǎn)：

• 數(shù)據(jù)會在客戶端和服務(wù)器重復(fù)加載；

Nuxt：性能為三者中最低，lighthouse 測試報(bào)告中的大多項(xiàng)都是領(lǐng)先者。
優(yōu)點(diǎn)：

• 主要范圍是UI渲染，同時(shí)抽象出客戶端/服務(wù)器分布；
• 項(xiàng)目結(jié)構(gòu)清晰；
• 路由級別的異步數(shù)據(jù)獲?。?/li>

缺點(diǎn)：

• 周邊資源較少；
• 高流量可能會給服務(wù)器帶來壓力；

Nest：性能是三者中最好的，lighthouse 測試報(bào)告得分較低。
優(yōu)點(diǎn)：

• 基于TypeScript的Web框架，可以進(jìn)行嚴(yán)格的類型定義；
• 自動生成Swagger文檔；
• 為開發(fā)人員提供更少的上下文切換。從Angular代碼到Nest的過渡相對容易；

缺點(diǎn)：

• 缺少文檔；
• 與其他框架相比，Nest的社區(qū)規(guī)模較??；

參考文章：原文鏈接