Node.js入门与实战：构建聊天服务器与Express应用

需积分: 10 194 浏览量更新于2024-07-28 收藏 388KB PDF 举报

"《Up and Running with Node.js》是一本针对Node.js初学者的教程，作者尹红亮来自华南理工大学，通过作者的学习笔记，本书旨在帮助读者快速上手并理解Node.js的核心概念。本书共分为八章，涵盖了从基础到进阶的知识点。第2章主要介绍了如何使用Node.js做一些有趣的事情，如构建一个聊天服务器，这将展示如何利用其事件驱动的特点处理并发请求。事件循环（Event Loop）是Node.js的核心机制，它使得异步编程变得高效，这是理解Node.js高效性能的关键。在第3章，作者探讨了构建健壮的Node应用，涉及到了事件模式（Patterns）、I/O问题空间以及如何利用多处理器优化性能。这里强调了I/O操作中的异步模型，以及如何使用Node.js的流（Streams）进行数据处理，包括可读流（Readable Streams）和文件系统（FileSystem）操作，以及如何处理数据缓冲（Buffers）。第4章深入讲解核心API，包括事件（Events）和EventEmitter、回调语法（Callback Syntax）、HTTP相关的功能，如创建HTTP服务器和客户端、URL处理、querystring模块，以及I/O操作和流的概念。这些章节提供了构建Web应用的基础架构。第5章涉及辅助API，如DNS查询，这对于网络通信和域名解析至关重要。接着，第6章转向数据访问，通过介绍MongoDB数据库，讲解如何写入记录，以及使用Mongoose这样的ORM工具提高开发效率。性能优化也是这一章的重点。第7章着重介绍重要的外部模块，如Express框架，它用于构建Web应用，包括设置路由、处理表单数据和中间件（Middleware）。此外，还提到了socket.io，一个实时通信库，如何与Express集成以实现WebSocket功能。第8章则是关于扩展Node.js，包括模块（Modules）、创建和发布包（Creating Packages & Publishing）、链接（Linking）以及Node.js扩展（Add-ons）。最后，附录部分列出了全书的主要章节索引，以及前言和各章节的概述。通过这本书的学习，读者不仅能掌握Node.js的基本语法和框架，还能理解其高效异步处理的优势，以及如何利用这些技术构建实际应用。对于初接触Node.js的开发者来说，这是一份非常实用的学习资料。"

I moved the app.listen() call to the top of the file. It’s important to understand why this doesn’t

cause condition for the functions that respond to requests. You might imagine that when I call

app.listen() any requests that happen between the app.listen() call and the time it takes to run

those functions will be ignored. This isn’t correct for two reasons. The first is that in JavaScript

everything happens in an event loop. That means new events don’t get called until we’ve finished

evaluating the code of the existing loop pass. In this case no request events will be called(and

thus our request based functions) until we’ve evaluated all the initialization code in the file. The

other reason is that the app.listen() call is actually asynchronous because binding to a TCP port

takes time. The additional of event listeners(via app.get() and app.post()) on the other hand is

synchronous.

A middleware is a small piece of code that sits in between the original request event and the

route we defined with app.post(). We use middleware to reuse code for common tasks such as

authentication or logging. In this case the middleware’s job is to stream the POST data from the

client and then turn it into a JavaScript object that we can use.

var express = require(‘express’)

var app = express.createServer()

app.listen(8000)

var tweets = []

app.get(‘/’, function(req, res){

res.send(‘Welcome to Node Twitter’)

})

app.post(‘/send’, express.bodyParser(), function(req, res){

if(req.body && req.body.tweet){

tweets.push(req.body.tweet)

res.send({status:”ok”, message:”Tweet received”})

} else {

//no tweet

res.send({status:”nok”, message:”No tweet received”})

}

})

app.get(‘/tweets’, function(req, res){

res.send(tweets)

})

Chapter 3. Building Robust Node Applications

The Event Loop

A fundamental part of Node is the event loop, a concept underlying the behavior of JavaScript as

well as most other interactive systems.

Why does this make Node more efficient? Imagine ordering food at a fast food restaurant. When

you get in line at the counter the server taking your order can behave in two ways. One of them is

event driven and one of them isn’t. Let’s start with the typical approach taken by PHP and many

other web platforms. When you ask the server for your order, he takes it but won’t serve any

other customers until he has completed your order. There are a few things he can do after he’s

typed in your order: process your payment, pour your drink and so on. However the server is still

going to have to wait an unknown amount of time for the kitchen to make your burger (to one of

the authors, who is vegetarian, orders always seems to takes ages). If, as in the traditional

approach of web application frameworks, each server (thread) is allocated to just one request at

a time, the only way to scale up is to add more threads. However, it’s also very obvious that our

server isn’t being very efficient. He’s spending a lot of time waiting for the kitchen to cook the

food.

Obviously, in real life restaurants use a much more efficient model. When a server has finished

taking your order, you receive a number which they can use to call you back. You could say a

call-back number. This is how Node works. When slow things like I/O start, Node simply gives

them a callback reference and then gets on with other work that is ready now, like the next

customer (or event in Node’s case). It’s important to note that as we saw in the example of the

postman at no time does a restaurant server ever deal with two customers at the same time.

When they are calling someone back to collect an order they are not taking a new one and vice

versa. By acting in an event-driven way, the servers are able to maximize their throughput.

Another interesting thing this analogy illustrates is cases where Node fits well and where it

doesn’t fit. In a small restaurant where the kitchen staff and the wait staff are the same people,

no tradeoff can be made by event-driven. Since all the work is being done by the same people

event-driven architectures don’t add anything. If all (or most of) the working your server does is

computation, Node might not be the ideal model.

However, we can also see when the architecture fits. Image there are two servers and new four

customers in a restaurant. If the servers serve only one customer at a time, the first two

customers will get the fastest possible order, but the third and forth customers will get a terrible

experience. The first two customers will get terrible experience. The first two customers will get

their food as soon as it is ready because the servers have dedicated their whole attention to

fulfilling their order. That comes at the cost of the other two customers. In an event driven model,

the first two customers might have to wait a short amount of time for the servers to finish taking

the orders of the third and forth customers before they got their food, but the average wait time

(latency) of the system will be much much lower.

Let’s consider some numbers. When we run an operation in the CPU (not a line of JavaScript but

a single machine code operation), it takes about 1/3 of a nano second. A 3GHz processor runs

剩余32页未读，继续阅读

smartyin2008

粉丝: 0
资源: 13

Node.js入门与实战：构建聊天服务器与Express应用

JavaScript Applications with Node.js, React, React Native and MongoDB

关于node.js express vue的书

安装了node.js,node.js Runtime是什么

javascript中如何使用Node.js

node.js 环境搭建

node.js服务端开发

idea缺node.js

node.js搭建服务端

html,css,javascript,node.js,Mysql数据库的参考文献

node.js python本地通信

最新资源