Details

Professional Node.js

Building Javascript Based Scalable Software
1. Aufl.

von: Pedro Teixeira
28,99 €
Verlag:	Wiley
Format:	PDF
Veröffentl.:	01.10.2012
ISBN/EAN:	9781118227541
Sprache:	englisch
Anzahl Seiten:	408

In den Warenkorb

Als Gutschein

DRM-geschütztes eBook, Sie benötigen z.B. Adobe Digital Editions und eine Adobe ID zum Lesen.

Beschreibungen

Titelbeschreibung

Learn to build fast and scalable software in JavaScript with Node.js Node.js is a powerful and popular new framework for writing scalable network programs using JavaScript. This no nonsense book begins with an overview of Node.js and then quickly dives into the code, core concepts, and APIs. In-depth coverage pares down the essentials to cover debugging, unit testing, and flow control so that you can start building and testing your own modules right away. <ul> <li>Covers node and asynchronous programming main concepts</li> <li>Addresses the basics: modules, buffers, events, and timers</li> <li>Explores streams, file systems, networking, and automated unit testing</li> <li>Goes beyond the basics, and shares techniques and tools for debugging, unit testing, and flow control</li> </ul> If you already know JavaScript and are curious about the power of Node.js, then this is the ideal book for you.

Inhaltsverzeichnis

INTRODUCTION xxvii PART I: INTRODUCTION AND SETUP CHAPTER 1: INSTALLING NODE 3 Installing Node on Windows 4 Installing on Mac OS X 5 Installing Node Using the Source Code 6 Choosing the Node Version 6 Downloading the Node Source Code 6 Building Node 7 Installing Node 7 Running Node 8 Setting Up and Using Node Package Manager 8 Using NPM to Install, Update, and Uninstall Packages 9 Summary 13 CHAPTER 2: INTRODUCING NODE 15 Introducing the Event-Driven Programming Style 16 How Node and JavaScript Make Writing Asynchronous Applications Easier 17 What Are Closures? 18 How Closures Help When Programming Asynchronously 19 Summary 19 PART II: NODE CORE API BASICS CHAPTER 3: LOADING MODULES 23 Understanding How Node Loads Modules 24 Exporting a Module 24 Loading a Module 25 Summary 28 CHAPTER 4: USING BUFFERS TO MANIPULATE, ENCODE, AND DECODE BINARY DATA 29 Creating a Buffer 30 Getting and Setting Bytes in a Buffer 30 Slicing a Buffer 32 Copying a Buffer 32 Decoding a Buffer 32 Summary 33 CHAPTER 5: USING THE EVENT EMITTER PATTERN TO SIMPLIFY EVENT BINDING 35 Understanding the Standard Callback Pattern 36 Understanding the Event Emitter Pattern 36 Understanding Event Types 37 Using the Event Emitter API 38 Binding Callbacks Using .addListener() or .on() 38 Binding Multiple Event Listeners 39 Removing an Event Listener from an Event Emitter Using .removeListener() 40 Getting a Callback Executed at Most Once Using .once() 40 Removing All Event Listeners from an Event Emitter Using .removeAllListeners() 41 Creating an Event Emitter 41 Inheriting from Node Event Emitter 42 Emitting Events 42 Summary 43 CHAPTER 6: SCHEDULING THE EXECUTION OF FUNCTIONS USING TIMERS 45 Using setTimeout to Defer the Execution of a Function 46 Using clearTimeout to Cancel the Execution of a Function 46 Scheduling and Canceling the Repetitive Execution of a Function 47 Using process.nextTick to Defer the Execution of a Function Until the Next Event Loop Iteration 47 Blocking the Event Loop 48 Escaping the Event Loop 49 Using setTimeout Instead of setInterval to Force Serialization 49 Summary 50 PART III: FILES, PROCESSES, STREAMS, AND NETWORKING CHAPTER 7: QUERYING, READING FROM, AND WRITING TO FILES 53 Manipulating File Paths 54 Normalizing Paths 54 Joining Paths 54 Resolving Paths 55 Finding the Relative Path Between Two Absolute Paths 55 Extracting Components of a Path 55 Determining the Existence of a Path 56 Introducing the fs Module 57 Querying File Statistics 57 Opening a File 58 Reading from a File 59 Writing to a File 60 Closing a File 60 Summary 62 CHAPTER 8: CREATING AND CONTROLLING EXTERNAL PROCESSES 63 Executing External Commands 64 Spawning Child Processes 69 Creating the Child Process 69 Listening for Data from the Child Process 69 Sending Data to the Child Process 70 Receiving Notification When the Child Process Exits 72 Signaling and Killing Processes 73 Summary 74 CHAPTER 9: READING AND WRITING STREAMS OF DATA 75 Using a Readable Stream 76 Waiting for Data 76 Pausing and Resuming a Stream 77 Knowing When the Stream Ends 77 Using Writable Streams 77 Writing Data into a Stream 78 Waiting for a Stream to Drain 78 Considering Some Stream Examples 78 Creating File-System Streams 79 Understanding Networking Streams 80 Avoiding the Slow Client Problem and Saving Your Server 80 Understanding the Slow Client Problem 80 Avoiding the Slow Client Problem 81 Using stream.pipe() to Prevent the Slow Client Problem and Assembling Readable and Writable Streams Using pipe() 82 Summary 82 CHAPTER 10: BUILDING TCP SERVERS 83 Creating a TCP Server 83 Using the Socket Object 85 Understanding Idle Sockets 86 Setting Up Keep-Alive 87 Using Delay or No Delay 87 Listening for Client Connections 88 Closing the Server 88 Handling Errors 88 Building a Simple TCP Chat Server 89 Accepting Connections 89 Reading Data from a Connection 90 Collecting All the Clients 90 Broadcasting Data 91 Removing Closed Connections 92 Using Your TCP Chat Server 93 Summary 93 CHAPTER 11: BUILDING HTTP SERVERS 95 Understanding the http.ServerRequest Object 97 Understanding the http.ServerResponse Object 98 Writing a Header 98 Changing or Setting a Header 99 Removing a Header 99 Writing a Piece of the Response Body 99 Streaming HTTP Chunked Responses 99 Piping a File 100 Piping the Output of Another Process 100 Shutting Down the Server 101 Example 1: Building a Server that Serves Static Files 101 Example 2: Making Use of HTTP Chunked Responses and Timers 102 Summary 102 CHAPTER 12: BUILDING A TCP CLIENT 103 Connecting to a Server 104 Sending and Receiving Data 105 Ending the Connection 105 Handling Errors 106 Building an Example Command-Line TCP Client 106 Connecting to the Server 107 Sending the Command Line to the Server 107 Printing Server Messages 107 Reconnecting if the Connection Dies 108 Closing the Connection 109 Putting the Client Together 111 Summary 112 CHAPTER 13: MAKING HTTP REQUESTS 113 Making GET Requests 113 Using Other HTTP Verbs 114 Inspecting the Response Object 115 Obtaining the Response Body 116 Streaming the Response Body 116 Pooling Sockets Using http.Agent 116 Using a Third-Party Request Module to Simplify HTTP Requests 118 Installing and Using Request 118 Creating a Testing Server 120 Following Redirects 121 Setting Some Request Options 123 Encoding the Request Body 125 Streaming 127 Using a Cookie Jar 127 Summary 128 CHAPTER 14: USING DATAGRAMS (UDP) 129 Understanding UDP 129 Understanding the Uses of UDP 130 Building a Datagram Server 130 Listening for Messages 130 Testing the Server 131 Inspecting Additional Message Information 132 Creating a Simple Datagram Echo Server 132 Waiting for Messages 132 Sending Messages Back to Senders 132 Putting the Echo Server Together 133 Building a Datagram Client 134 Creating the Client 134 Sending Messages 134 Closing the Socket 134 Creating a Simple Datagram Command-Line Client 135 Reading from the Command Line 135 Sending Data to the Server 135 Receiving Data from the Server 136 Putting the Command-Line UDP Client Together 136 Understanding and Using Datagram Multicast 136 Receiving Multicast Messages 137 Sending Multicast Messages 138 Understanding Maximum Datagram Size 138 Summary 138 CHAPTER 15: SECURING YOUR TCP SERVER WITH TLS/SSL 139 Understanding Private and Public Keys 139 Generating a Private Key 140 Generating a Public Key 140 Building a TLS Server 141 Initializing the Server 141 Listening for Connections 141 Reading Data from the Client 142 Sending Data to the Client 142 Ending the Connection 142 Building a TLS Client 143 Initializing the Client 143 Connecting to the Server 143 Verifying the Server Certificate 143 Sending Data to the Server 144 Reading Data from the Server 144 Ending the Connection 144 Building Some Examples 145 Creating a TLS Chat Server 145 Creating a TLS Command-Line Chat Client 146 Verifying the Client Certificate 147 Summary 148 CHAPTER 16: SECURING YOUR HTTP SERVER WITH HTTPS 149 Building a Secure HTTP Server 149 Setting Up the Server Options 150 Listening for Connections 150 Validating the HTTPS Client Certificate 151 Creating an HTTPS Client 152 Initializing the Client 152 Making the Request 152 Validating the HTTPS Server Certificate 153 Summary 154 PART IV: BUILDING AND DEBUGGING MODULES AND APPLICATIONS CHAPTER 17: TESTING MODULES AND APPLICATIONS 157 Using a Test Runner 157 Writing Tests 158 Running Tests 159 Using an Assertion Testing Module 159 Using the assert Module 159 Using the Built-in Assertion Functions in Node-Tap 161 Testing Your Asynchronous Module 163 Summary 166 CHAPTER 18: DEBUGGING MODULES AND APPLICATIONS 167 Using console.log 167 Using Node’s Built-in Debugger 169 Using Node Inspector 173 Summary 175 CHAPTER 19: CONTROLLING THE CALLBACK FLOW 177 Understanding the Boomerang Effect 177 Avoiding the Boomerang Effect by Declaring Functions 179 Using the async Flow Control Library 183 Executing in Series 184 Executing in Parallel 185 Cascading 186 Queuing 187 Iterating 189 Mapping 190 Reducing 191 Filtering 192 Detecting 193 Summary 194 PART V: BUILDING WEB APPLICATIONS CHAPTER 20: BUILDING AND USING HTTP MIDDLEWARE 197 Understanding the Connect HTTP Middleware Framework 198 Building Your Own HTTP Middleware 198 Creating Asynchronous Middleware 200 Registering Callbacks Inside Middleware 201 Handling Errors Inside Middleware 203 Using the HTTP Middleware Bundled in Connect 206 Logging Requests 206 Handling Errors 208 Serving Static Files 209 Parsing the Query String 210 Parsing the Request Body 211 Parsing Cookies 212 Using a Session 213 Other Available Middleware 216 Summary 216 CHAPTER 21: MAKING A WEB APPLICATION USING EXPRESS.JS 217 Initializing Your Express.js Application 218 Setting Up Middleware in Your Application 220 Routing Requests 222 Handling Routes 222 Using Sessions 229 Using Route Middleware 234 Summary 238 CHAPTER 22: MAKING UNIVERSAL REAL-TIME WEB APPLICATIONS USING SOCKET.IO 241 Understanding How WebSockets Work 242 Using Socket.IO to Build WebSocket Applications 243 Installing and Running Socket.IO on the Server 243 Building a Real-Time Web Chat with Socket.IO 245 Extending the Chat Application 250 Detecting Disconnections 254 Separating Users into Rooms 255 Using Namespaces 259 Distributing the Server-Side Application Using Redis 259 Summary 263 PART VI: CONNECTING TO DATABASES CHAPTER 23: CONNECTING TO MYSQL USING NODE-MYSQL 267 Using a Library to Connect to and Communicate with a MySQL Database 268 Adding Data to the Database with Security Concerns in Mind 270 Reading Data Effi ciently 272 Summary 276 CHAPTER 24: CONNECTING TO COUCHDB USING NANO 277 Installing Nano 278 Connecting and Creating a Database 281 Storing Documents 285 Creating and Using CouchDB Views 286 Attaching Files to a CouchDB Document 298 Summary 310 CHAPTER 25: CONNECTING TO MONGODB USING MONGOOSE 311 Installing Mongoose 313 Understanding How Mongoose Uses Models to Encapsulate Database Access 313 Connecting to MongoDB 314 Defining a Schema 314 Defining a Model 315 Using Validators 324 Using Modifiers 330 Using Getters 331 Using Virtual Attributes 332 Using Default Values 338 Defining Indexes 340 Referencing Other Documents Using DB Refs 341 Defining Instance Methods 347 Defining Static Methods 348 Summary 349 INDEX 351

Autorenportrait

Pedro Teixeira is a prolific open-source programmer and author of many Node.js modules. He is a founding partner of The Node Firm and a senior programmer at Nodejitsu Inc., the leading Node.js platform-as-a-service provider. He is also the author of the popular Node Tuts screencasts. Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Back cover copy

Learn to build scalable software in JavaScript with Node.js Node.js is a popular framework that allows you to build fast, highly scalable network programs using JavaScript. However, it comes with a learning curve. This in-depth guide walks you through the installation of the Node.js platform and then focuses on the essentials of creating and loading modules; using buffers to manipulate, encode, and decode binary data; simplifying event binding with the event emitter pattern; and more. Covering everything from scheduling the execution of functions using timers to creating and controlling external processes, this book gets you up and running and building and testing your own modules. Professional Node.js: <ul> <li>Addresses querying, reading from, and writing to files</li> <li>Explores streams, file systems, networking, and automated unit testing</li> <li>Details how to read and write streams of data</li> <li>Zeroes-in on building TCP and HTTP servers and clients</li> <li>Reviews using datagrams, testing and debugging modules, and controlling the callback flow</li> <li>Shows how to develop real-time web applications using Connect, Express, and Socket.IO</li> <li>Walks you through connecting to MySQL, CouchDB, and MongoDB</li> </ul> Programmer Forums Join our Programmer to Programmer forums to ask and answer programming questions about this book, join discussions on the hottest topics in the industry, and connect with fellow programmers from around the world. Code Downloads Take advantage of free code samples from this book, as well as code samples from hundreds of other books, all ready to use. Read More Find articles, ebooks, sample chapters, and tables of contents for hundreds of books, and more reference resources on programming topics that matter to you.