91超碰碰碰碰久久久久久综合_超碰av人澡人澡人澡人澡人掠_国产黄大片在线观看画质优化_txt小说免费全本

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

nodejs的關鍵節點有哪些

發布時間:2022-09-20 15:02:49 來源:億速云 閱讀:129 作者:iii 欄目:web開發

本文小編為大家詳細介紹“nodejs的關鍵節點有哪些”,內容詳細,步驟清晰,細節處理妥當,希望這篇“nodejs的關鍵節點有哪些”文章能幫助大家解決疑惑,下面跟著小編的思路慢慢深入,一起來學習新知識吧。

非阻塞I/O

I/O:即 Input / Output,一個系統的輸入和輸出。

一個系統可以理解為一個個體,比如說一個人,你說話就是輸出,你聽就是輸入。

阻塞 I/O 與非阻塞 I/O 的區別就在于系統接收輸入再到輸出期間,能不能接收其他輸入

下面以兩個例子來說明什么是阻塞 I/O 和非阻塞 I/O:

1、打飯

nodejs的關鍵節點有哪些

首先我們要確定一個系統的范圍,在這個例子中食堂阿姨和餐廳的服務生看成是一個系統,輸入就是點菜,輸出就是端菜

那么在點菜和端菜之間能不能接受其他人的點菜,就可以判斷是阻塞I/O還是非阻塞I/O。

對于食堂阿姨,他在點菜的時候,是不能幫其他同學點菜的,只有這個同學點完菜端菜走了之后,才能接受下一個同學的點菜,所以食堂阿姨是阻塞I/O。

對于餐廳服務員,他可以在點完菜以后,這個客人端菜之前是可以服務下一位客人的,所以服務員是非阻塞I/O。

2、做家務

nodejs的關鍵節點有哪些

在洗衣服的時候,是不需要等著洗衣機旁邊的,這個時候可以去掃地和整理書桌,當整理完書桌后衣服也洗好了,這個時候去晾衣服,那么總共只需要25分鐘。

洗衣服其實就是一個非阻塞I/O,在把衣服扔進洗衣機和洗完衣服期間,你是可以干其他事情的。

非阻塞I/O之所以能提升性能,是因為它可以把不必要的等待給節省掉。

理解非阻塞I/O的要點在于

  • 確定一個進行I/O的系統邊界。這非常關鍵,如果把系統擴大,上面餐廳的例子,如果把系統擴大到整個餐廳,那么廚師肯定是一個阻塞 I/O。

  • 在 I/O 過程中,能不能進行其他 I/O。

nodejs的非阻塞 I/O

nodejs的非阻塞 I/O 是怎么體現的呢?前面說過理解非阻塞 I/O 的一個重要點是先確定一個系統邊界,node的系統邊界就是主線程

如果下面的架構圖按照線程的維護劃分,左邊虛線部分是nodejs線程,右邊虛線部分是c++線程。

nodejs的關鍵節點有哪些

現在 nodejs 線程需要去查詢數據庫,這是一個典型的 I/O 操作,它不會等待 I/O 的結果,而且繼續處理其他的操作,它會把大量的計算能力分發到其他的c++線程去計算。

等到結果出來后返回給nodejs線程,在獲得結果之前nodejs 線程還能進行其他的I/O操作,所以是非阻塞的。

nodejs 線程 相當于左邊部分是服務員,c++ 線程是廚師。

所以,node的非阻塞I/O是通過調用c++的worker threads來完成的。

那當 c++ 線程獲取結果后怎么通知 nodejs 線程呢?答案是事件驅動

事件驅動

阻塞:I/O時進程休眠,等待I/O完成后進行下一步;

非阻塞:I/O時函數立即返回,進程不等待I/O完成。

那怎么知道返回的結果,就需要用到事件驅動

所謂事件驅動可以理解為跟前端點擊事件一樣,我首先寫一個點擊事件,但是我不知道什么時候觸發,只有觸發的時候就去讓主線程執行事件驅動函數。

這種模式也是一種觀察者模式,就是我首先先監聽這個事件,等觸發時我就去執行。

那怎么實現事件驅動呢?答案是異步編程

異步編程

上面說過nodejs有大量的非阻塞I/O,那么非阻塞I/O的結果是需要通過回調函數來獲取的,這種通過回調函數的方式,就是異步編程。比如下面的代碼是通過回調函數獲取結果的:

glob(__dirname+'/**/*', (err, res) => {
    result = res
    console.log('get result')
})

回調函數格式規范

nodejs的回調函數第一個參數是error,后面的參數才是結果。為什么要這么做呢?

try {
  interview(function () {
       console.log('smile')
  })
} catch(err) {
    console.log('cry', err)
}

function interview(callback) {
    setTimeout(() => {
        if(Math.random() < 0.1) {
            callback('success')
        } else {
            throw new Error('fail')
        }
    }, 500)
}

執行之后,沒有被捕獲,錯誤被扔到了全局,導致整個nodejs程序崩潰了。

nodejs的關鍵節點有哪些

沒有被try catch捕獲是因為setTimeout重新開啟了事件循環,每開啟一個事件循環就重新生一個調用棧context,try catch是屬于上一個事件循環的調用棧的,setTimeout的回調函數執行的時候,調用棧都不一樣了,在這個新的調用棧中是沒有try catch,所以這個錯誤被扔到全局,無法捕獲。

那么怎么辦呢?把錯誤也作為一個參數:

function interview(callback) {
    setTimeout(() => {
        if(Math.random() < 0.5) {
            callback('success')
        } else {
            callback(new Error('fail'))
        }
    }, 500)
}

interview(function (res) {
    if (res instanceof Error) {
        console.log('cry')
        return
    } 
    console.log('smile')
})

但是這樣就比較麻煩,在回調中還要判斷,所以就產生一種約定成熟的規定,第一個參數是err,如果不存在表示執行成功。

function interview(callback) {
    setTimeout(() => {
        if(Math.random() < 0.5) {
            callback(null, 'success')
        } else {
            callback(new Error('fail'))
        }
    }, 500)
}

interview(function (res) {
    if (res) {
        return
    } 
    console.log('smile')
})

異步流程控制

nodejs的回調寫法,不僅會帶來回調地域,還會帶來異步流程控制的問題。

異步流程控制主要是指當并發的時候,怎么來處理并發的邏輯。還是上面的例子,如果你同事面試兩家公司,只有當成功面試兩家的時候,才可以不面試第三家,那么怎么寫這個邏輯呢?需要全局頂一個一個變量count:

var count = 0
interview((err) => {
    if (err) {
        return
    }
    count++
    if (count >= 2) {
        // 處理邏輯
    }
})

interview((err) => {
    if (err) {
        return
    }
    count++
    if (count >= 2) {
        // 處理邏輯
    }
})

像上面這種寫法就非常麻煩,且難看。所以,后來就出現了promise,async/await的寫法。

promise

當前事件循環得不到的結果,但未來的事件循環會給你結果。很像一個渣男說的話。

promise不僅是一個渣男,還是一個狀態機:

  • pending

  • fulfilled/resolved

  • rejectd

const pro = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('2')
    }, 200)
})
console.log(pro) // 打印:Promise { <pending> }
then & .catch
  • resolved 狀態的 promise 會調用后面的第一個 then

  • rejected 狀態的 promise 會調用后面的第一個 catch

  • 任何一個 reject 狀態且后面沒有 .catch 的 promise,都會造成瀏覽器或者 node 環境的全局錯誤。uncaught 表示未捕獲的錯誤。

nodejs的關鍵節點有哪些

執行then或者catch會返回一個新的promise,該promise最終狀態根據then和catch的回調函數的執行結果決定:

  • 如果回調函數始終是throw new Error,該promise是rejected狀態

  • 如果回調函數始終是return,該promise是resolved狀態

  • 但如果回調函數始終是return一個promise,該promise會和回調函數return的promise狀態保持一致

function interview() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() > 0.5) {
                resolve('success')
            } else {
                reject(new Error('fail'))
            }
        })
    })
}

var promise = interview()
var promise1 = promise.then(() => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('accept')
        }, 400)
    })
})

promise1的狀態是由return里面的promise的狀態決定的,也就是return里面的promise執行完后的狀態就是promise1的狀態。這樣有什么好處呢?這樣可以解決回調地獄的問題

var promise = interview()
    .then(() => {
        return interview()
    })
    .then(() => {
        return interview()
    })
    .then(() => {
        return interview()
    })
    .catch(e => {
        console.log(e)
    })

then如果返回的promise的狀態是rejected,那么會調用后面第一個catch,后面的then就不會在調用了。記住:rejected調用后面的第一個catch,resolved調用后面的第一個then。

promise解決異步流程控制

如果promise僅僅是為了解決地獄回調,太小看promise了,promise最主要的作用是解決異步流程控制問題。下面如果要同時面試兩家公司:

function interview() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() > 0.5) {
                resolve('success')
            } else {
                reject(new Error('fail'))
            }
        })
    })
}

promise
    .all([interview(), interview()])
    .then(() => {
        console.log('smile')
    })
    // 如果有一家公司rejected,就catch
    .catch(() => {
        console.log('cry')
    })

async/await

sync/await到底是什么:

console.log(async function() {
    return 4
})

console.log(function() {
    return new Promise((resolve, reject) => {
        resolve(4)
    })
})

打印的結果一樣,也就是async/await是promse的語法糖而已。

我們知道try catch捕獲錯誤是依賴調用棧的,只能捕獲到調用棧以上的錯誤。但是如果使用await后能捕捉到調用棧所有函數的錯誤。即便這個錯誤是在另一個事件循環的調用棧拋出的,比如setTimeout。

改造面試代碼,可以看到代碼精簡了很多。

try {
    await interview(1)
    await interview(2)
    await interview(2)
} catch(e => {
    console.log(e)
})

如果是并行任務呢?

await Promise.all([interview(1), interview(2)])

事件循環

因為nodejs的非阻塞 I/0, 所以需要利用事件驅動的方式獲取 I/O 的結果,實現事件驅動拿到結果必須使用異步編程,比如回調函數。那么如何來有序的執行這些回調函數來獲取結果呢?那就需要使用事件循環。

事件循環是實現 nodejs 非阻塞 I/O 功能的關鍵基礎,非阻塞I/O和事件循環都是屬于 libuv 這個c++庫提供的能力。

nodejs的關鍵節點有哪些

代碼演示:

const eventloop = {
    queue: [],
    loop() {
        while(this.queue.length) {
            const callback = this.queue.shift()
            callback()
        }
        setTimeout(this.loop.bind(this), 50)
    },
    add(callback) {
        this.queue.push(callback)
    }
}

eventloop.loop()

setTimeout(() => {
    eventloop.add(() => {
        console.log('1')
    })
}, 500)

setTimeout(() => {
	eventloop.add(() => {
		console.log('2')
	})
}, 800)

setTimeout(this.loop.bind(this), 50)保證了50ms就會去看隊列中是否有回調,如果有就去執行。這樣就形成了一個事件循環。

當然實際的事件要復雜的多,隊列也不止一個,比如有一個文件操作對列,一個時間對列。

const eventloop = {
    queue: [],
    fsQueue: [],
    timerQueue: [],
    loop() {
        while(this.queue.length) {
            const callback = this.queue.shift()
            callback()
        }
        this.fsQueue.forEach(callback => {
            if (done) {
                callback()
            }
        })
        setTimeout(this.loop.bind(this), 50)
    },
    add(callback) {
        this.queue.push(callback)
    }
}

讀到這里,這篇“nodejs的關鍵節點有哪些”文章已經介紹完畢,想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會,如果想了解更多相關內容的文章,歡迎關注億速云行業資訊頻道。

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

扎囊县| 文化| 河源市| 龙南县| 昌宁县| 合川市| 五指山市| 宁安市| 河南省| 武夷山市| 卓资县| 涟水县| 门源| 洛南县| 孟州市| 成安县| 玉环县| 比如县| 微博| 开平市| 昭觉县| 都昌县| 临桂县| 陇川县| 河东区| 松原市| 上杭县| 玉山县| 西平县| 东辽县| 石楼县| 东乌珠穆沁旗| 汾阳市| 应用必备| 页游| 佛坪县| 保康县| 金湖县| 新龙县| 金乡县| 柳河县|