Home Page Icon
Home Page
Table of Contents for
II: Learning Node.js
Close
II: Learning Node.js
by Brad Dayley
Node.js, MongoDB, and AngularJS Web Development
About This eBook
Title Page
Copyright Page
Developer’s Library
Dedication Page
Contents
Acknowledgments
About the Author
We Want to Hear from You!
Reader Services
Introduction
Who Should Read This Book
Why You Should Read This Book
What You Will Learn from This Book
What Is Node.js?
What Is MongoDB?
What Is AngularJS?
How This Book Is Organized
Getting the Code Examples
A Final Word
1. Introducing the Node.js-to-AngularJS Stack
Understanding the Basic Web Development Framework
Users
The Browser
Webservers
Backend Services
Understanding the Node.js-to-AngularJS Stack Components
Node.js
MongoDB
Express
AngularJS
Summary
Up Next
2. JavaScript Primer
Defining Variables
Understanding JavaScript Data Types
Using Operators
Arithmetic Operators
Assignment Operators
Applying Comparison and Conditional Operators
Implementing Looping
while Loops
do/while Loops
for Loops
for/in Loops
Interrupting Loops
Creating Functions
Defining Functions
Passing Variables to Functions
Returning Values from Functions
Using Anonymous Functions
Understanding Variable Scope
Using JavaScript Objects
Using Object Syntax
Creating Custom Defined Objects
Using a Prototyping Object Pattern
Manipulating Strings
Combining Strings
Searching a String for a Substring
Replacing a Word in a String
Splitting a String into an Array
Working with Arrays
Combining Arrays
Iterating Through Arrays
Converting an Array into a String
Checking Whether an Array Contains an Item
Adding Items to and Removing Items from Arrays
Adding Error Handling
try/catch Blocks
Throwing Your Own Errors
Using Finally
Summary
Up Next
II: Learning Node.js
3. Getting Started with Node.js
Understanding Node.js
Who Uses Node.js?
What Is Node.js Used For?
Installing Node.js
Looking at the Node.js Install Location
Verifying Node.js Executables
Selecting a Node.js IDE
Working with Node.js Packages
What Are Node Packaged Modules?
Understanding the Node Package Registry
Using the Node Package Manager
Searching for Node Packaged Modules
Installing Node Packaged Modules
Using package.json
Creating a Node.js Application
Creating a Node.js Packaged Module
Publishing a Node.js Packaged Module to the NPM Registry
Using a Node.js Packaged Module in a Node.js Application
Writing Data to the Console
Summary
Up Next
4. Using Events, Listeners, Timers, and Callbacks in Node.js
Understanding the Node.js Event Model
Comparing Event Callbacks and Threaded Models
Blocking I/O in Node.js
A Conversation Example
Adding Work to the Event Queue
Implementing Timers
Using nextTick to Schedule Work
Implementing Event Emitters and Listeners
Implementing Callbacks
Passing Additional Parameters to Callbacks
Implementing Closure in Callbacks
Chaining Callbacks
Summary
Up Next
5. Handling Data I/O in Node.js
Working with JSON
Converting JSON to JavaScript Objects
Converting JavaScript Objects to JSON
Using the Buffer Module to Buffer Data
Understanding Buffered Data
Creating Buffers
Writing to Buffers
Determining Buffer Length
Copying Buffers
Slicing Buffers
Concatenating Buffers
Using the Stream Module to Stream Data
Writable Streams
Duplex Streams
Transform Streams
Piping Readable Streams to Writable Streams
Compressing and Decompressing Data with Zlib
Compressing and Decompressing Buffers
Compressing/Decompressing Streams
Summary
Up Next
6. Accessing the File System from Node.js
Synchronous Versus Asynchronous File System Calls
Opening and Closing Files
Writing Files
Simple File Writing
Asynchronous File Writing
Streaming File Writing
Reading Files
Synchronous File Reading
Asynchronous File Reading
Streaming File Reading
Other File System Tasks
Verifying Path Existence
Getting File Info
Listing Files
Deleting Files
Truncating Files
Making and Removing Directories
Renaming Files and Directories
Watching for File Changes
Summary
Up Next
7. Implementing HTTP Services in Node.js
Processing URLs
Understanding the URL Object
Resolving the URL Components
Processing Query Strings and Form Parameters
Understanding Request, Response, and Server Objects
The http.ClientRequest Object
The http.ServerResponse Object
The HTTP Server Object
Implementing HTTP Clients and Servers in Node.js
Serving Static Files
Implementing Dynamic GET Servers
Implementing POST Servers
Interacting with External Sources
Implementing HTTPS Servers and Clients
Creating an HTTPS Client
Creating an HTTPS Server
Summary
Up Next
8. Implementing Socket Services in Node.js
Understanding Network Sockets
Understanding TCP Server and Socket Objects
The net.Socket Object
The net.Server Object
Implementing a TCP Socket Client
Implementing a TCP Socket Server
Implementing TLS Servers and Clients
Creating a TLS Socket Client
Creating a TLS Socket Server
Summary
Up Next
Understanding the process Module
Understanding Process I/O Pipes
Understanding Process Signals
Controlling Process Execution with the process Module
Getting Information from the process Module
Implementing Child Processes
Understanding the ChildProcess Object
Executing a System Command on Another Process by Using exec()
Executing an Executable File on Another Process Using execFile()
Implementing Child Forks
Using the cluster Module
Understanding the Worker Object
Implementing an HTTP Cluster
Summary
Up Next
10. Using Additional Node.js Modules
Using the os Module
Using the util Module
Formatting Strings
Checking Object Types
Synchronous Writing to Output Streams
Converting JavaScript Objects to Strings
Inheriting Functionality from Other Objects
Using the dns Module
Summary
Up Next
III: Learning MongoDB
11. Understanding NoSQL and MongoDB
Why NoSQL?
Understanding MongoDB
Understanding Collections
Understanding Documents
MongoDB Data Types
Planning Your Data Model
Normalizing Data with Document References
Denormalizing Data with Embedded Documents
Using Capped Collections
Understanding Atomic Write Operations
Considering Document Growth
Identifying Indexing, Sharding, and Replication Opportunities
Large Collections Versus Large Numbers of Collections
Deciding on Data Life Cycles
Considering Data Usability and Performance
Up Next
12. Getting Started with MongoDB
Building the MongoDB Environment
Starting MongoDB
Stopping MongoDB
Accessing MongoDB from the Shell Client
Administering User Accounts
Listing Users
Creating User Accounts
Configuring Access Control
Creating a User Administrator Account
Turning on Authentication
Creating a Database Administrator Account
Administering Databases
Displaying a List of Databases
Changing the Current Database
Creating Databases
Deleting Databases
Copying Databases
Managing Collections
Displaying a List of Collections in a Database
Creating Collections
Deleting Collections
Finding Documents in a Collection
Adding Documents to a Collection
Deleting Documents from a Collection
Updating Documents in a Collection
Up Next
Adding the MongoDB Driver to Node.js
Connecting to MongoDB from Node.js
Understanding the Write Concern
Understanding the Server Object
Connecting to MongoDB via a Connection String
Understanding the Db Object
Understanding the Admin Object
Understanding the Collection Object
Understanding the Cursor Object
Accessing and Manipulating Databases
Listing Databases
Creating a Database
Deleting a Database
Creating, Listing, and Deleting Databases Example
Getting the Status of the MongoDB Server
Accessing and Manipulating Collections
Listing Collections
Creating Collections
Deleting Collections
Collection Creation, Listing, and Deleting Example
Getting Collection Information
Summary
Up Next
14. Manipulating MongoDB Documents from Node.js
Understanding Database Change Options
Understanding Database Update Operators
Adding Documents to a Collection
Updating Documents in a Collection
Atomically Modifying Documents in a Collection
Saving Documents in a Collection
Using upsert to Insert Documents in a Collection
Deleting Documents from a Collection
Removing a Single Document from a Collection
Summary
15. Accessing MongoDB Documents from Node.js
Introducing the Data Set
Understanding Query Objects
Understanding Query options Objects
Finding Specific Sets of Documents
Counting Documents
Limiting Result Sets
Limiting Results by Size
Limiting Fields Returned in Objects
Paging Results
Sorting Result Sets
Finding Distinct Field Values
Grouping Results
Applying MapReduce by Aggregating Results
Understanding the aggregate() Method
Using Aggregation Framework Operators
Implementing Aggregation Expression Operators
Aggregation Examples
Summary
Up Next
16. Using Mongoose for Structured Schema and Validation
Understanding Mongoose
Additional Objects
Defining a Schema
Understanding Paths
Creating a Schema Definition
Adding Indexes to a Schema
Implementing Unique Fields
Forcing Required Fields
Adding Methods to the Schema Object
Implementing a Schema on the Words Database
Compiling a Model
Understanding the Query Object
Setting Query Database Operation
Setting the Query Database Operation Options
Setting the Query Operators
Understanding the Document Object
Finding Documents by Using Mongoose
Adding Documents by Using Mongoose
Updating Documents by Using Mongoose
Saving Document Changes
Updating a Single Document
Updating Multiple Documents
Removing Documents by Using Mongoose
Removing a Single Document
Removing Multiple Documents
Aggregating Documents by Using Mongoose
Using the Validation Framework
Implementing Middleware Functions
Summary
Up Next
17. Advanced MongoDB Concepts
Adding Indexes
Using Capped Collections
Applying Replication
Replication Strategy
Deploying a Replica Set
Implementing Sharding
Sharding Server Types
Choosing a Shard Key
Selecting a Partitioning Method
Deploying a Sharded MongoDB Cluster
Implementing a GridFS Store
Implementing a Grid Object from Node.js
Implementing a GridStore Object from Node.js
Repairing a MongoDB Database
Backing Up MongoDB
Summary
Up Next
IV: Using Express to Make Life Easier
Getting Started with Express
Configuring Express Settings
Configuring Routes
Implementing Routes
Applying Parameters in Routes
Using Request Objects
Using Response Objects
Setting Headers
Setting the Status
Sending Response
Sending JSON Responses
Sending Files
Sending a Download Response
Redirecting a Response
Implementing a Template Engine
Defining a Template Engine
Adding Locals
Creating Templates
Rendering Templates in a Response
Summary
Up Next
19. Implementing Express Middleware
Understanding Middleware
Assigning Middleware Globally to a Path
Assigning Middleware to a Single Route
Adding Multiple Middleware Functions
Using the query Middleware
Serving Static Files
Handling POST Body Data
Sending and Receiving Cookies
Implementing Sessions
Applying Basic HTTP Authentication
Implementing Session Authentication
Creating Custom Middleware
Summary
Up Next
V: Learning AngularJS
20. Getting Started with AngularJS
Why AngularJS?
Understanding AngularJS
Modules
Scopes and the Data Model
Views with Templates and Directives
Expressions
Controllers
Data Binding
Services
Dependency Injection
Separation of Responsibilities
An Overview of the AngularJS Life Cycle
The Bootstrap Phase
The Compilation Phase
The Runtime Data Binding Phase
Integrating AngularJS with Existing JavaScript and jQuery
Adding AngularJS to the Node.js Environment
Bootstrapping AngularJS in an HTML Document
Using the Global APIs
Creating a Basic AngularJS Application
Defining the AngularJS Application Root Element
Adding a Controller to the Template
Implementing the Scope Model
Summary
Up Next
21. Understanding AngularJS Modules and Dependency Injection
Overview of Modules and Dependency Injection
Understanding Modules
Dependency Injection
Defining AngularJS Modules
Creating an AngularJS Module Object
Using Configuration Blocks
Using Run Blocks
Adding Providers to AngularJS Modules
Implementing Dependency Injection
Summary
Up Next
22. Implementing the Scope as a Data Model
Understanding Scopes
The Relationship Between the Root Scope and Applications
The Relationship Between Scopes and Controllers
The Relationship Between Scopes and Templates
The Relationship Between Scope and Backend Server Data
The Scope Life Cycle
Implementing Scope Hierarchy
Emitting and Broadcasting Events
Summary
Up Next
23. Using AngularJS Templates to Create Views
Understanding Templates
Using Expressions
Using Filters
Using Built-in Filters
Using Filters to Implement Ordering and Filtering
Creating Custom Filters
Summary
Up Next
24. Implementing Directives in AngularJS Views
Understanding Directives
Using Built-in Directives
Directives That Support AngularJS Functionality
Directives That Extend Form Elements
Directives That Bind the Model to Page Elements
Directives That Bind Page Events to Controllers
Creating Your Own Directives to Extend HTML
Defining the Directive View Template
Restricting Directive Behavior
Replacing the Template Element
Transcluding External Scopes
Configuring the Directive Scope
Manipulating the DOM with a Link Function
Adding a Controller to a Directive
Creating a Custom Directive
Summary
Up Next
25. Implementing AngularJS Services in Web Applications
Understanding AngularJS Services
Using the Built-in Services
Sending HTTP GET and PUT Requests with the $http Service
Using the $cacheFactory Service
Implementing Browser Alerts Using the $window Service
Interacting with Browser Cookies Using the $cookieStore Service
Implementing Timers with $interval and $timeout Services
Using the $animate Service
Creating Custom Services
Creating value Services
Creating constant Services
Creating factory Services
Integrating Services in a Module
Summary
Up Next
VI: Building Practical Web Application Components
Libraries Used
Project Directory Structure
Defining the User Model
Creating the Server
Implementing Routes
Implementing the User Signup Route
Implementing the User Login Route
Implementing the Get User Profile Route
Implementing the Update User Route
Implementing the Delete User Route
Full User Controller Code
Implementing the User and Authentication Views
Implementing the signup View
Implementing the index View
Implementing the login View
Implementing the user View
Adding CSS Code to Style Views
Implementing the AngularJS Module and Controller
Using Social Media Accounts as Authentication Sources
Adding Passport
Adding Authentication Strategies
Implementing Application Middleware
Adding Authenticated User Serialization and Deserialization
Implementing Routes to Use Authentication
Authenticating Using Google
Summary
Up Next
27. Adding Comment Threads to Pages
Libraries Used
Defining the Comment, Reply, Photo, and Page Models
Defining the Page Model
Defining the Photo Model
Defining the CommentThread Model
Creating the Comments Server
Implementing Routes to Support Viewing and Adding Comments
Implementing the Model-Based Controller Routes
Implementing the Page Model Controller
Implementing the Photo Model Controller
Implementing the CommentThread Model Controller
Implementing Photo and Comment Views
Implementing the Photo View
Implementing the Comment Thread View
Implementing the Comment View
Adding CSS to Stylize the Views
Implementing the AngularJS Module and Controller to Support Comment Views
Creating a Comment Service
Implementing the Photo Controller
Implementing the Page AngularJS Controller
The Full AngularJS Application
Initializing the Application
Summary
Up Next
28. Creating Your Own Shopping Cart
Project Description
Libraries Used
Project Directory Structure
Defining the Customer, Product, and Orders Models
Defining the Address Schema
Defining the Billing Schema
Defining the Product Schema
Defining the Order Schema
Defining the Customer Schema
Creating the Shopping Cart Server
Implementing Routes to Support Product, Cart, and Order Requests
Implementing the Model-Based Controller Routes
Implementing the Product Model Controller
Implementing the Order Model Controller
Implementing the Customer Model Controller
Implementing Shopping Cart and Checkout Views
Implementing the Shopping View
Implementing the Products View
Implementing the Product Page View
Implementing the Cart View
Implementing the Shipping View
Implementing the Billing View
Implementing the Review View
Implementing the Orders View
Adding CSS to Stylize the Views
Implementing the AngularJS Module and Controller to Support Shopping Cart Views
Initializing the Shopping Scope
Implementing Helper Functions
Adding Items to the Cart
Deleting Items from the Cart
Checking Out
Setting Shipping Information
Making the Purchase
The Full Controller
Initializing the Application
Summary
Up Next
29. Building Interactive Web 2.0 Application Components
Project Description
Libraries Used
Project Directory Structure
Defining the Project Model
Creating the Application Server
Implementing Routes to Support the Views
Implementing a Tabbed View
Creating the AngularJS Tabbed View Templates
Defining the Pane Template
Defining the Tabs Template
Implementing the Tabbed View
Implementing the AngularJS Custom Directives
Styling the Tabs View
Creating the Backend Weather Service
Defining the Weather AngularJS Controller
Defining the Weather AngularJS View
Styling the Weather View
Implementing Draggable Elements
Defining the Draggable Custom AngularJS Directive
Implementing the Draggable Directive in an AngularJS View
Styling the Draggable View
Implementing Dynamic Data Access
Creating the Express Route Controller for the /words Route
Defining the Table AngularJS Controller
Implementing the Tables AngularJS View
Styling the Tables View
Initializing the Application
Summary
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
Up Next
Next
Next Chapter
3. Getting Started with Node.js
II: Learning Node.js
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset