Was sind die zehn häufigsten Fehler in NodeJS?

Zehn häufige Fehler im Knoten: 1. Blockieren der Ereignisschleife; 2. Aufrufen einer Callback-Funktion; 4. Erwarten, dass Callback-Funktionen synchron ausgeführt werden; 6. Geben Sie einen Fehler aus dem Rückruf aus. 7. Denken Sie, dass Number ein ganzzahliges Datenformat ist. 8. Ignorieren Sie die Vorteile der Streaming-API usw.

Die Betriebsumgebung dieses Tutorials: Windows7-System, NodeJS-Version 12.19.0, DELL G3-Computer.

Seit Node.js auf den Markt kam, hat es viel Lob und Kritik erhalten. Diese Debatte wird weitergehen und nicht so schnell enden. In diesen Debatten übersehen wir oft, dass alle Sprachen und Plattformen aufgrund einiger Kernthemen kritisiert werden, nämlich der Art und Weise, wie wir diese Plattformen nutzen. Egal wie schwierig es ist, mit Node.js zuverlässigen Code zu schreiben, und wie einfach es ist, hochgradig gleichzeitigen Code zu schreiben, die Plattform gibt es schon seit einiger Zeit und wurde zur Erstellung einer großen Anzahl robuster und komplexer Webdienste verwendet. Diese Webdienste lassen sich nicht nur gut skalieren, sondern beweisen auch ihre Robustheit, wenn sie im Internet verfügbar sind.

Doch genau wie andere Plattformen macht es Node.js Entwicklern leicht, Fehler zu machen. Einige dieser Fehler können die Programmleistung beeinträchtigen, während andere dazu führen können, dass Node.js unbrauchbar wird. In diesem Artikel werfen wir einen Blick auf häufige Fehler, die Node.js-Neulinge machen, und wie man sie vermeidet. <span class="pun">十种错误</span>

Fehler 1: Blockieren der Ereignisschleife

JavaScript in Node.js bietet (genau wie der Browser) eine Single-Threaded-Umgebung. Dies bedeutet, dass in Ihrem Programm nicht zwei Dinge gleichzeitig ausgeführt werden, sondern die Parallelität durch die asynchrone Verarbeitung E/A-intensiver Vorgänge gewährleistet wird. Wenn Node.js beispielsweise eine Anfrage an die Datenbank initiiert, um einige Daten abzurufen, kann sich Node.js auf andere Teile des Programms konzentrieren:

// Trying to fetch an user object from the database. Node.js is free to run other parts of the code from the moment this function is invoked..	
db.User.get(userId, function(err, user) {	
    // .. until the moment the user object has been retrieved here	
})

In einer Node.js-Instanz mit Tausenden von Clientverbindungen gibt es jedoch kleine Abschnitte CPU-intensiver Code kann die Ereignisschleife blockieren und dazu führen, dass alle Clients warten. CPU-intensiver Code umfasst den Versuch, ein großes Array zu sortieren, eine lange Funktion auszuführen usw. Zum Beispiel:

function sortUsersByAge(users) {	
    users.sort(function(a, b) {	
        return a.age < b.age ? -1 : 1	
    })	
}

Es ​​ist kein Problem, die Methode „sortUsersByAge“ für ein kleines „users“-Array aufzurufen, aber wenn es sich um ein großes Array handelt, hat es große Auswirkungen auf die Gesamtleistung. Wenn so etwas getan werden muss und Sie sicherstellen können, dass keine anderen Ereignisse in der Ereignisschleife warten (dies ist beispielsweise nur ein Node.js-Befehlszeilentool, und es ist ihm egal, dass alles synchron funktioniert). ), dann ist das kein Problem. Allerdings kann es in Situationen zu Problemen kommen, in denen ein Node.js-Server versucht, Tausende von Benutzern gleichzeitig zu bedienen.

Wenn dieses Benutzerarray aus der Datenbank abgerufen wird, besteht die ideale Lösung darin, die sortierten Daten aus der Datenbank abzurufen. Wenn die Ereignisschleife durch eine Schleife blockiert wird, die die historische Summe von Finanztransaktionsdaten berechnet, sollte die Berechnungsschleife in eine Warteschlange außerhalb der Ereignisschleife verschoben werden, um eine Blockierung der Ereignisschleife zu vermeiden.

Wie Sie sehen, gibt es kein Allheilmittel, um diese Art von Fehler zu beheben, sondern nur eine individuelle Lösung für jede Situation. Die Grundidee besteht darin, keine CPU-intensive Arbeit an der Node.js-Instanz durchzuführen, die gleichzeitige Clientverbindungen verarbeitet.

Fehler 2: Mehrmaliges Aufrufen einer Rückruffunktion

JavaScript hat sich immer auf Rückruffunktionen verlassen. In Browsern werden Ereignisse behandelt, indem ein Verweis auf das Ereignisobjekt an eine Rückruffunktion (normalerweise eine anonyme Funktion) übergeben wird. In Node.js waren Rückruffunktionen bis zur Einführung von Versprechen die einzige Möglichkeit, asynchron mit anderem Code zu kommunizieren. Callback-Funktionen werden auch heute noch verwendet und viele Entwickler richten ihre APIs immer noch darum herum ein. Ein häufiger Fehler bei der Verwendung von Rückruffunktionen besteht darin, sie mehrmals aufzurufen. Normalerweise ist der letzte Parameter einer Methode, die eine asynchrone Verarbeitung kapselt, so konzipiert, dass sie eine Funktion übergibt, die nach Abschluss der asynchronen Verarbeitung aufgerufen wird:

module.exports.verifyPassword = function(user, password, done) {	
    if(typeof password !== ‘string’) {	
        done(new Error(‘password should be a string’))	
        return	
    }	
    computeHash(password, user.passwordHashOpts, function(err, hash) {	
        if(err) {	
            done(err)	
            return	
        }	
        done(null, hash === user.passwordHash)	
    })	
}

Beachten Sie, dass bis auf das letzte Mal jede „erledigte“ Methode vorhanden ist nach dem Aufruf eine Return-Anweisung sein. Dies liegt daran, dass der Aufruf der Callback-Funktion die Ausführung der aktuellen Methode nicht automatisch beendet. Wenn wir die erste Return-Anweisung auskommentieren und dann ein Kennwort ohne Zeichenfolge an diese Funktion übergeben, rufen wir am Ende immer noch die Methode „computeHash“ auf. Abhängig davon, wie ComputeHash mit dieser Situation umgeht, wird die Funktion „done“ mehrmals aufgerufen. Jeder kann überrascht sein, wenn eine übergebene Callback-Funktion mehrmals aufgerufen wird.

Um dieses Problem zu vermeiden, seien Sie einfach vorsichtig. Einige Node.js-Entwickler haben daher die Angewohnheit entwickelt, vor allen Anweisungen, die Rückruffunktionen aufrufen, ein Schlüsselwort „return“ einzufügen:

if(err) {	
    return done(err)	
}

Bei vielen asynchronen Funktionen ist der Rückgabewert dieser Rückgabe bedeutungslos, daher dient diese Aktion lediglich dazu, diesen Fehler zu vermeiden .

Fehler 3: Tief verschachtelte Callback-Funktionen

Tief verschachtelte Callback-Funktionen werden oft als „Callback-Hölle“ bezeichnet. Sie stellen an sich kein Problem dar, können aber dazu führen, dass der Code schnell außer Kontrolle gerät:

function handleLogin(..., done) {	
    db.User.get(..., function(..., user) {	
        if(!user) {	
            return done(null, ‘failed to log in’)	
        }	
        utils.verifyPassword(..., function(..., okay) {	
            if(okay) {	
                return done(null, ‘failed to log in’)	
            }	
            session.login(..., function() {	
                done(null, ‘logged in’)	
            })	
        })	
    })	
}

越复杂的任务，这个的坏处就越大。像这样嵌套回调函数，我们的程序很容易出错，而且代码难以阅读和维护。一个权宜之计是把这些任务声明为一个个的小函数，然后再将它们联系起来。不过，（有可能是）最简便的解决方法之一是使用一个 Node.js 公共组件来处理这种异步 js，比如 Async.js：

function handleLogin(done) {	
    async.waterfall([	
        function(done) {	
            db.User.get(..., done)	
        },	
        function(user, done) {	
            if(!user) {	
            return done(null, ‘failed to log in’)	
            }	
            utils.verifyPassword(..., function(..., okay) {	
                done(null, user, okay)	
            })	
        },	
        function(user, okay, done) {	
            if(okay) {	
                return done(null, ‘failed to log in’)	
            }	
            session.login(..., function() {	
                done(null, ‘logged in’)	
            })	
        }	
    ], function() {	
        // ...	
    })	
}

Async.js 还提供了很多类似“async.waterfall” 的方法去处理不同的异步场景。为了简便起见，这里我们演示了一个简单的示例，实际情况往往复杂得多。

（打个广告，隔壁的《ES6 Generator 介绍》提及的 Generator 也是可以解决回调地狱的哦，而且结合 Promise 使用更加自然，请期待隔壁楼主的下篇文章吧:D）

错误4：期待回调函数同步执行

使用回调函数的异步程序不只是 JavaScript 和 Node.js 有，只是它们让这种异步程序变得流行起来。在其他编程语言里，我们习惯了两个语句一个接一个执行，除非两个语句之间有特殊的跳转指令。即使那样，这些还受限于条件语句、循环语句以及函数调用。

然而在 JavaScript 里，一个带有回调函数的方法直到回调完成之前可能都无法完成任务。当前函数会一直执行到底：

function testTimeout() {	
    console.log(“Begin”)	
    setTimeout(function() {	
        console.log(“Done!”)	
    }, duration * 1000)	
    console.log(“Waiting..”)	
}

你可能会注意到，调用“testTimeout” 函数会先输出“Begin”，然后输出“Waiting..”，紧接着几秒后输出“Done!”。

任何要在回调函数执行完后才执行的代码，都需要在回调函数里调用。

错误5：给“exports” 赋值，而不是“module.exports”

Node.js 认为每个文件都是一个独立的模块。如果你的包有两个文件，假设是“a.js” 和“b.js”，然后“b.js” 要使用“a.js” 的功能，“a.js” 必须要通过给 exports 对象增加属性来暴露这些功能：

// a.js	
exports.verifyPassword = function(user, password, done) { ... }

完成这步后，所有需要“a.js” 的都会获得一个带有“verifyPassword” 函数属性的对象：

// b.js	
require(‘a.js’) // { verifyPassword: function(user, password, done) { ... } }

然而，如果我们想直接暴露这个函数，而不是让它作为某些对象的属性呢？我们可以覆写 exports 来达到目的，但是我们绝对不能把它当做一个全局变量：

// a.js	
module.exports = function(user, password, done) { ... }

注意到我们是把“exports” 当做 module 对象的一个属性。“module.exports” 和“exports” 这之间区别是很重要的，而且经常会使 Node.js 新手踩坑。

错误6：从回调里抛出错误

JavaScript 有异常的概念。在语法上，学绝大多数传统语言（如 Java、C++）对异常的处理那样，JavaScript 可以抛出异常以及在 try-catch 语句块中捕获异常：

function slugifyUsername(username) {	
    if(typeof username === ‘string’) {	
        throw new TypeError(‘expected a string username, got '+(typeof username))	
    }	
    // ...	
}	
try {	
    var usernameSlug = slugifyUsername(username)	
} catch(e) {	
    console.log(‘Oh no!’)	
}

然而，在异步环境下，tary-catch 可能不会像你所想的那样。比如说，如果你想用一个大的 try-catch 去保护一大段含有许多异步处理的代码，它可能不会正常的工作：

try {	
    db.User.get(userId, function(err, user) {	
        if(err) {	
            throw err	
        }	
        // ...	
        usernameSlug = slugifyUsername(user.username)	
        // ...	
    })	
} catch(e) {	
    console.log(‘Oh no!’)	
}

如果“db.User.get” 的回调函数异步执行了，那么 try-catch 原来所在的作用域就很难捕获到回调函数里抛出的异常了。

这就是为什么在 Node.js 里通常使用不同的方式处理错误，而且这使得所有回调函数的参数都需要遵循 (err, ...) 这种形式，其中第一个参数是错误发生时的 error 对象。

错误7：认为 Number 是一种整型数据格式

在 JavaScript 里数字都是浮点型，没有整型的数据格式。你可能认为这不是什么问题，因为数字大到溢出浮点型限制的情况很少出现。可实际上，当这种情况发生时就会出错。因为浮点数在表达一个整型数时只能表示到一个最大上限值，在计算中超过这个最大值时就会出问题。也许看起来有些奇怪，但在 Node.js 中下面代码的值是 true：

Math.pow(2, 53)+1 === Math.pow(2, 53)

很不幸的是，JavaScript 里有关数字的怪癖可还不止这些。尽管数字是浮点型的，但如下这种整数运算能正常工作：

5 % 2 === 1 // true	
5 >> 1 === 2 // true

然而和算术运算不同的是，位运算和移位运算只在小于 32 位最大值的数字上正常工作。例如，让“Math.pow(2, 53)” 位移 1 位总是得到 0，让其与 1 做位运算也总是得到 0：

Math.pow(2, 53) / 2 === Math.pow(2, 52) // true	
Math.pow(2, 53) >> 1 === 0 // true	
Math.pow(2, 53) | 1 === 0 // true

你可能极少会去处理如此大的数字，但如果你需要的话，有很多实现了大型精密数字运算的大整数库可以帮到你，比如 node-bigint。

错误8：忽略了流式 API 的优势

现在我们想创建一个简单的类代理 web 服务器，它能通过拉取其他 web 服务器的内容来响应和发起请求。作为例子，我们创建一个小型 web 服务器为 Gravatar 的图像服务。

var http = require('http')	
var crypto = require('crypto')	
http.createServer()	
.on('request', function(req, res) {	
    var email = req.url.substr(req.url.lastIndexOf('/')+1)	
    if(!email) {	
        res.writeHead(404)	
        return res.end()	
    }	
    var buf = new Buffer(1024*1024)	
    http.get('http://www.gravatar.com/avatar/'+crypto.createHash('md5').update(email).digest('hex'), function(resp) {	
        var size = 0	
        resp.on('data', function(chunk) {	
            chunk.copy(buf, size)	
            size += chunk.length	
        })	
        .on('end', function() {	
            res.write(buf.slice(0, size))	
            res.end()	
        })	
    })	
})	
.listen(8080)

在这个例子里，我们从 Gravatar 拉取图片，将它存进一个 Buffer 里，然后响应请求。如果 Gravatar 的图片都不是很大的话，这样做没问题。但想象下如果我们代理的内容大小有上千兆的话，更好的处理方式是下面这样：

http.createServer()	
.on('request', function(req, res) {	
    var email = req.url.substr(req.url.lastIndexOf('/')+1)	
    if(!email) {	
        res.writeHead(404)	
        return res.end()	
    }	
    http.get('http://www.gravatar.com/avatar/'+crypto.createHash('md5').update(email).digest('hex'), function(resp) {	
        resp.pipe(res)	
    })	
})	
.listen(8080)

这里我们只是拉取图片然后简单地以管道方式响应给客户端，而不需要在响应它之前读取完整的数据存入缓存。

错误9：出于 Debug 的目的使用 Console.log

在 Node.js 里，“console.log” 允许你打印任何东西到控制台上。比如传一个对象给它，它会以 JavaScript 对象的字符形式打印出来。它能接收任意多个的参数并将它们以空格作为分隔符打印出来。有很多的理由可以解释为什么开发者喜欢使用它来 debug 他的代码，然而我强烈建议你不要在实时代码里使用“console.log”。你应该要避免在所有代码里使用“console.log” 去 debug，而且应该在不需要它们的时候把它们注释掉。你可以使用一种专门做这种事的库代替，比如 debug。

这些库提供了便利的方式让你在启动程序的时候开启或关闭具体的 debug 模式，例如，使用 debug 的话，你能够阻止任何 debug 方法输出信息到终端上，只要不设置 DEBUG 环境变量即可。使用它十分简单：

// app.js	
var debug = require(‘debug’)(‘app’)	
debug(’Hello, %s!’, ‘world’)

开启 debug 模式只需简单地运行下面的代码把环境变量 DEBUG 设置到“app” 或“*” 上：

DEBUG=app node app.js

错误10：不使用监控程序

不管你的 Node.js 代码是跑在生产环境或是你的本地开发环境，一个能协调你程序的监控程序是十分值得拥有的。一条经常被开发者提及的，针对现代程序设计和开发的建议是你的代码应该有 <span class="pln">fail</span><span class="pun">-</span><span class="pln">fast</span> 机制。如果发生了一个意料之外的错误，不要尝试去处理它，而应该让你的程序崩溃然后让监控程序在几秒之内重启它。监控程序的好处不只是重启崩溃的程序，这些工具还能让你在程序文件发生改变的时候重启它，就像崩溃重启那样。这让开发 Node.js 程序变成了一个更加轻松愉快的体验。

Node.js 有太多的监控程序可以使用了，例如：

<span class="pln">pm2</span>

<span class="pln">forever</span>

<span class="pln">nodemon</span>

<span class="pln">supervisor</span>

所有这些工具都有它的优缺点。一些擅长于在一台机器上处理多个应用程序，而另一些擅长于日志管理。不管怎样，如果你想开始写一个程序，这些都是不错的选择。

总结

你可以看到，这其中的一些错误能给你的程序造成破坏性的影响，在你尝试使用 Node.js 实现一些很简单的功能时一些错误也可能会导致你受挫。即使 Node.js 已经使得新手上手十分简单，但它依然有些地方容易让人混乱。从其他语言过来的开发者可能已知道了这其中某些错误，但在 Node.js 新手里这些错误都是很常见的。幸运的是，它们都可以很容易地避免。我希望这个简短指南能帮助新手更好地编写 Node.js 代码，而且能够给我们大家开发出健壮高效的软件。

更多node相关知识，请访问：nodejs 教程！！

Das obige ist der detaillierte Inhalt vonWas sind die zehn häufigsten Fehler in NodeJS?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!