Choose your language:

France
Germany
Hong Kong
India
Ireland
Japan
Malaysia
Netherlands
New Zealand
Singapore
Sweden
United Kingdom
United States

MEAN JavaScript Technology Stack

Course Code

IN1627

Duration

5 Days

Participants should have basic knowledge of JavaScript programming and web development.
MEAN [MongoDB, Express, Angular5, and Node.JS] represents a new breed of software platforms that creatively leverage a stack of production-ready technologies centered on JavaScript. This intensive training course introduces the participants to the essential concepts, design principles, idioms, and techniques behind the efficient use of the MEAN JavaScript Technology Stack. Upon completion of this training course, participants will have solid understanding of MEANS’ value proposition; they will also gain practical experience working with all the components of the MEAN stack. This high-octane training course is supplemented by hands-on labs that help the participants reinforce their theoretical knowledge of the learned material.

What is Mean Stack? Our Mean Stack course goes in depth to answer this question. MEAN [MongoDB, Express, Angular5, and Node.JS] represents a new breed of software platforms that creatively leverage a stack of production-ready technologies centered on JavaScript. This intensive training course introduces the participants to the essential concepts, design principles, idioms, and techniques behind the efficient use of the MEAN JavaScript Technology Stack. Upon completion of this training course, participants will have a solid understanding of MEANS’ value proposition; they will also gain practical experience working with all the components of the MEAN stack. This high-octane training course is supplemented by hands-on labs that help the participants reinforce their theoretical knowledge of the learned material.
This course is designed for Developers, Technical Leads, and Software Architects.

In this course, participants will:

  • Work with all the components of the MEAN Stack
Chapter 1. Introducing Angular
What is Angular?
Central Features of the Angular Framework
Why Angular?
Building Blocks of an Angular Application
Basic Architecture of an Angular Application
Angular vs. AngularJS
Angular Semantic Versioning
Installing and Using Angular
A Basic Angular Application
Anatomy of a Basic Application
The Main Component File
The Application Module File
The index.html File
The Bootstrap File
Running the Application
Building the Application
Summary

Chapter 2. Development Setup of Angular
Angular Development Lifecycle
Angular is Modular
What is Node.js?
Installing Node.js and NPM
Node Package Manager (NPM)
Package Descriptor File - package.json
Semantic Version Numbering
Package Version Numbering Syntax
Updating Packages
Uninstalling Packages
Installing Angular Packages
Angular CLI
Creating a New Project
Angular
Development
Dependencies
TypeScript Typings
Testing Tools
Development Web Server
Configuring the Web Server
The Build System
Configuring the Build
Summary

Chapter 3. Introduction to TypeScript and ES6
Programming Languages for Use with Angular
TypeScript Syntax
Programming Editors
The Type System – Defining Variables
The Type System – Defining Arrays
The Type System – Classes & Objects
Class Constructors
Class Constructors – Alternate Form
Interfaces
Parameter and Return Value Types
Working with Modules
TypeScript Transpilation
var, let and const - Defined
var, let and const - Usage
Arrow Functions
Template Strings
Template Strings – Variables and Expressions
Template Strings – Multiline
Generics - Class
Generics - Methods
Generics - Restricting Types
Generics - Restricting Types: Example
Summary

Chapter 4. Components in Angular
What is a Component?
An Example Component
The Component Class
Adding a Component to Its Module
Creating a Component Using Angular CLI
Developing a Simple Login Component
Component Template
Login Component: Add HTML
The HTML Component Template
The templateUrl property
Login Component: Add CSS Styling
Login Component: Hook Up Input Fields and Button
Login Component: Fields & Button in the Component Class
Component Decorator Properties
Component Hierarchy
The Application Root Component
Using a Regular Component
The Build System
Component Lifecycle Hooks
Using a Lifecycle Hook:
OnInit
Summary

Chapter 5. Data and Event Binding
Binding Syntax
One-Way Output Binding
Binding Displayed Output Values
Two-Way Binding of Input Fields
Input Binding Examples
Binding Events
Binding Events Examples
Setting DOM Element Properties
Setting Properties: Examples
Passing Data into Components using @Input()
Passing Data from Child to Parent using @Output()
@Output() Example - Child Component
@Output() Example - Parent Component
Summary

Chapter 6. Attribute Directives and Property Bindings
What are Directives
Directive Types
Apply Styles by Changing Classes
Changing Classes – Example
Applying Styles Directly
Applying Styles Directly - Example
Obsolete Directives and Property Binding
Controlling Element Visibility
Setting Image Source Dynamically
Setting Hyperlink Source Dynamically
Summary

Chapter 7. Structural Directives
Structural Directives
Adding and Removing Elements Dynamically
If-Else Syntax of ngIf
Declare Variables in ngIf
Looping Using ngFor
ngFor - Basic Syntax
ngFor - Full Template Syntax
Creating Tables with ngFor
ngFor Local Variables
ngFor Changes in the backing data source
Swapping Elements with ngSwitch
ngSwitch - Basic Syntax
ngSwitch - Full Template Syntax
Summary

Chapter 8. Services and Dependency Injection
What is a Service?
Creating a Basic Service
What is Dependency Injection?
What Dependency Injection Looks Like
Injecting Services
Dependency Injection Hierarchy Diagram
Using a Service in a Component: Dedicated Instance
Injection Hierarchy - Dedicated Instance
Using a Service in a Component: Dedicated Instance - Example Code
Using
onInit
to Initialize Component Data
Using a Shared Service Instance
Injection Hierarchy - Shared Instance
Dependency Injection and @Host
Dependency Injection and @Optional
Summary

Chapter 9. HTTP Client
The Angular HTTP Client
Using The HTTP Client - Overview
Importing HttpClientModule
Importing Individual Providers into Services
Service Using HttpClient
Service Imports
The Observable object type
What does an Observable Object do?
Making a Basic HTTP GET Call
Using the Service in a Component
The PeopleService Client Component
Client Component Code Review
Returning a Response Object
Importing Observable Methods
Enhancing the Service with .catch()
Using .catch()
Using toPromise()
GET Request
Options Object
GET Request with Options
POST Request
POST Request Example
Reading HTTP Response Headers
Summary

Chapter 10. The Angular Component Router
Routing and Navigation
The Component Router
Traditional Browser Navigation
Component Router Terminology
Setting up the Component Router
Local URL Links
Browser pushState and <base href>
Routes
The app.routes.ts File
The app.routes.ts File - Example
Importing Routing in app.module.ts
A Basic App With Routing
App Routes
AppComponent - Code
AppComponent - Router Related Features
AppComponent - <router-outlet>
AppComponent - routerLinks
Programmatic Navigation
Basic Navigation
Passing Data During Navigation
Creating Routes with Route Parameters
Navigating with Route Parameters
Using Route Parameter Values
Retrieving the Route Parameter Synchronously
Retrieving a Route Parameter Asynchronously
Query Parameters
Query Parameters - Example Component
Query Parameters - queryParams
Query Parameters - Navigation
Retrieving Query Parameters Asynchronously
Problems with Manual URL entry and Bookmarking
Fixing Manual URL entry and Bookmarking
Summary

Chapter 11. Introduction to MongoDB
MongoDB
MongoDB Features
MongoDB's Logo
Positioning of MongoDB
MongoDB Applications
MongoDB Data Model
MongoDB Limitations
MongoDB Use Cases
MongoDB Query Language (QL)
The CRUD Operations
The find and findOne methods
A MongoDB QL Example
Data Inserts
MongoDB vs Apache CouchDB
Summary

Chapter 12. MongoDB Data Model
The BSON Data Format
Database Terminology
MongoDB Data Model
The _id Primary Key Filed Considerations
Indexes
(Traditional) Data Modeling in RDBMS
Data Modeling in MongoDB
An Example of a Data Model in MongoDB
MongoDB Data Modeling
A Sample JSON Document Matching the Schema
To Normalize or Denormalize?
MongoDB Limitations
Data Lifecycle Management
Data Lifecycle Management: TTL
Data Lifecycle Management: Capped Collections
Summary

Chapter 13. MongoDB Architecture
MongoDB Nexus Architecture
Blending the Best of Both Worlds
What Makes MongoDB Fast?
Pluggable Storage Engines
Data Sharding
Sharding in MongoDB
Data Replication
A Sample Sharded Cluster Diagram
GridFS
Getting a File from GridFS
MongoDB Security
Authentication
Data and Network Encryption
Summary

Chapter 14. MongoDB Administration
The Admin Shell
Getting Help
Admin Commands
Starting MongoDB
The mongod Web UI
Running MongoDB .JS Scripts
Shell Helper to JavaScript Equivalent Map
A MongoDB Script Example
Connecting to MongoDB
User Authentication
Authentication Options
Import / Export Operations
MongoDB Extended JSON and Strict Mode
Examples of Strict Mode Encoding
Examples of Data Import / Export
The Robomongo Tool
Robomongo Features
Summary

Chapter 15. Working with Data in MongoDB
Reading Data in MongoDB
The Query Interface
Query Syntax is Driver-Specific
Projections
Query and Projection Operators
MongoDB Query to SQL Select Comparison
Cursors
Cursor Expiration
Writing Data in MongoDB
An Insert Operation Example
The Update Operation
An Update Operation Example
A Remove Operation Example
Limiting Return Data
Data Sorting
Aggregating Data
Aggregation Stages
Accumulators
An Example of an Aggregation Pipe-line
Map-Reduce
Summary

Chapter 16. Indexes in MongoDB
Indexes in MongoDB
Creating an Index
Listing Existing Indexes
The Sort Order
Using the Explain() Method
Main Index Types
The _id Field
Single and Compound Indexes
Multikey Indexes
Other Index Types
Index Properties
Examples of Creating Indexes with Index Properties
Summary

Chapter 17. Introduction to Node.js
What is Node.js?
Application of Node.js
Installing Node.js and NPM
"Hello, Node World!"
How it Works
Built on JavaScript – benefits
Traditional Server-Side I/O Model
Disadvantages of the traditional Approach
Event-Driven, Non-Blocking I/O
Concurrency
Using Node Package Manager (NPM)
Express
Summary

Chapter 18. Module and Dependency Management
Nature of a Node.js Project
Introduction to Modules
A Simple Module
Using the Module
Directory Based Modules
Example Directory Based Module
Using the Module
Making a Module Executable
Core Modules
Loading Module from node_modules Folders
Dependency Management Using NPM
Installing a Package
About Global Installation
Setting Up Dependency
Package Version Numbering Syntax
Updating Packages
Uninstalling Packages
Alternate Dependency Management
Summary

Chapter 19. The File System Module
Introduction
Basic File Manipulation
Getting File/Directory Meta Data
Read an Entire File
The Buffer Class
Writing to a File
Reading in Chunks
Writing in Chunks
The open() Method
Stream API
The Readable Interface
Example Reading Data in Chunks
The Writable Interface
Summary

Chapter 20. Basic Web Application Development
Introduction to the HTTP Module
The Request Handler Callback Function
The Server Object
Example Use of Server Object
The Request Object
The Response Object
Parsing Request Body
Serving Static Files
The HTTP Client API
Making POST/PUT/etc. Requests
Where To go from Here?
Summary

Chapter 21. Debugging and Unit Testing
Problem Determination Options
Using console.log
Using the debug Logging Package
Configure Logging
The Node Inspector Debugger
Basic Usage of the Debugger
Unit Testing Node.js Applications
Getting Setup
Writing a Test Script
Running Unit Test
Testing Asynchronous Code
Using the Chai Assert API
The Chai Expect API
Summary

Chapter 22. Introduction to Express
Introduction to Express
Basic Routing Example
Defining Routing Rules
Route Path
The Response Object
Supplying URL Parameters
Ordering of Routes
Defining Catch All Route
Full Example Web Service
Summary

Chapter 23. Express Middleware
Introduction to Express Middleware
Writing a Middleware Function
Binding to a Path
Order of Execution
Raising Error
Handling Error
Serving Static Files
Handling POST Request Body
Enable Response Compression
Summary

Chapter 24. Accessing MongoDB from Node.js
Getting Started
The Connection URL
Obtaining a Collection
Inserting Documents
Updating a Document
Querying for Documents
Deleting a Document
Connection Pooling
Summary

Chapter 25. Jade Template Engine
Introduction to Jade
Using Jade
A Simple Template
Passing Data to a Template
Basic HTML Tag Rendering
Rendering Values
Conditional Rendering
Rendering a List
Layout Template
Creating a Layout Template
Creating a Content Template
Summary

Chapter 26. Clustering and Failover
Process Management
Managing the Process Using OS Tools
Installing a Service in Window
Create an Upstart Script in Ubuntu
Process Management Using forever
Clustering Basics
Example Clustered Application
More About Clustering
Child Process Failover
Summary

Lab Exercises
Lab 1. Introduction to Angular
Lab 2. Introduction to TypeScript
Lab 3. Introduction to Components
Lab 4. Create the Subscription Form Component
Lab 5. Understanding Data Binding
Lab 6. One Way Data Binding in a Custom Component
Lab 7. Using Basic Angular Directives
Lab 8. Using Structural Directives
Lab 9. Service and Dependency Injection
Lab 10. HTTP Client Development
Lab 11. Basic Single Page Application Using Router
Lab 12. Learning the MongoDB Lab Environment
Lab 13. The MongoDB Database Operations
Lab 14. The MongoDB Admin Shell
Lab 15. Import Export Operations in MongoDB
Lab 16. Working with Data in MongoDB
Lab 17. Getting Started With Node.js
Lab 18. Basics of a Node.js Module
Lab 19. Using Node Package Manager (npm)
Lab 20. Building Module Dependency
Lab 21. Using the Stream API
Lab 22. Basic Web Application Development
Lab 23. Debugging a Node.js Application
Lab 24. Introduction to Unit Testing
Lab 25. Web Service Using Express
Lab 26. Using MongoDB
Lab 27. Using the Jade Template Engine
Lab 28. Clustering a Node.js Application

Send Us a Message
Choose one