The Complete Angular Course: Beginner to Advanced

Udemy

Gain a thorough understanding of the principles and functions of Angular, Bootstrap, and Firebase for designing e-commerce applications.

Online

₹ 4099

particular

details

                                    Medium of instructions
                                    English

                                    Mode of learning
                                    Self study

                                    Mode of Delivery
                                    Video and Text Based

Introduction

Introduction
What is Angular
Architecture of Angular Apps
Setting Up the Development Environment
Your First Angular App
Structure of Angular Projects
Webpack
Angular Version History
Angular Basics
Course Structure
Making a Promise
Asking Questions

TypeScript Fundamentals

Introduction
What is TypeScript?
Your First TypeScript Program
Declaring Variables
Types
Type Assertions
Arrow Functions
Interfaces
Classes
Objects
Constructors
Access Modifiers
Access Modifiers in Constructor Parameters
Properties
Modules
Exercise
Solution
A Problem with the Current Implementation

Angular Fundamentals

Introduction
Building Blocks of Angular Apps
Components
Generating Components Using Angular CLI
Templates
Directives
Services
Dependency Injection
Generating Services Using Angular CLI
List of Authors

Displaying Data and Handling Events

Introduction
Property Binding
Attribute Binding
Adding Bootstrap
Class Binding
Style Binding
Event Binding
Event Filtering
Template Variables
Two-way Binding
Pipes
Custom Pipes
Favorite Component
Title Casing

Building Re-usable Components

Introduction
Component API
Input Properties
Aliasing Input Properties
Output Properties
Passing Event Data
Aliasing Output Properties
Templates
Styles
View Encapsulation
ngContent
ngContainer
Like Component

Directives

Introduction
ngIf
Hidden Property
ngSwitchCase
ngFor
ngFor and Change Detection
ngFor and Trackby
The Leading Asterisk
ngClass
ngStyle
Safe Traversal Operator
Creating Custom Directives
Exercise: ZippyComponent

Template-driven Forms

Introduction
Building a Bootstrap Form
Types of Forms
ngModel
Adding Validation
Specific Validation Errors
Styling Invalid Input Fields
Cleaner Templates
ngForm
ngModelGroup
Control Classes and Directives
Disabling the Submit Button
Working with Check Boxes
Working with Drop-down Lists
Working with Radio Buttons
Course Form

Reactive Forms

Introduction
Building a Bootstrap Form
Creating Controls Programmatically
Adding Validation
Specific Validation Errors
Implementing Custom Validation
Asynchronous Operations
Asynchronous Validators
Showing a Loader Image
Validating the Form Input Upon Submit
Nested FormGroups
FormArray
FormBuilder
Quick Recap
Change Password Form

Consuming HTTP Services

Introduction
JSONPlaceHolder
Getting Data
Creating Data
Updating Data
Deleting Data
OnInit Interface
Separation of Concerns
Extracting a Service
Handling Errors
Handling Unexpected Errors
Handling Expected Errors
Throwing Application-specific Errors
Handling Bad Request Errors
Importing Observable Operators and Factory Methods
Global Error Handling
Extracting a Reusable Error Handling Method
Extracting a Reusable Data Service
The Map Operator
Optimistic vs Pessimistic Updates
Observables vs Promises
GitHub Followers Page

Routing and Navigation

Introduction
Routing in a Nutshell
Configuring Routes
RouterOutlet
RouterLink
RouterLinkActive
Getting the Route Parameters
Why Route Parameters Are Observables
Routes with Multiple Parameters
Query Parameters
Subscribing to Multiple Observables
The SwitchMap Operator
Programmatic Navigation
Blog Archives

Authentication and Authorization

Introduction
Application Overview
Architecture
JSON Web Tokens
Starter Code
Implementing Login
Implementing Logout
Showing or Hiding Elements
Showing or Hiding Elements based on the User's Role
Getting the Current User
CanActivate Interface
Redirecting Users After Logging In
Protecting Routes Based on the User's Role
Accessing Protected API Resources
Quick Recap

Deployment

Introduction
Preparing for Deployment
JIT vs AOT Compilation
Angular Compiler in Action
Building Applications with Angular CLI
Environments
Adding Custom Environments
Linting with Angular CLI
Linting in VSCode
Other Deployment Options
Deploying to GitHub Pages
Deploying to Firebase
Heroku
Deploying to Heroku
Engines
Exercise

Building Real-time Server-less Apps with Firebase

Introduction
What is Firebase?
Your First Firebase Project
Working with Firebase Databases
Installing Firebase
Reading Lists
A Real-time Database
Observables and Memory Leaks
Unsubscribing from Subscriptions
Async Pipe
Reading an Object
As Keyword
Adding an Object
Updating an Object
Removing an Object
Additional Resources

Animations

Introduction
Examples of Animations
Different Ways to Create Animations
Angular Animations
Importing the Animations Module and Polyfills
Implementing a Fade-in Animation
Implementing a Fade-out Animation
States
Transitions
Animatable Properties
Creating Reusable Triggers
Build a re-usable slide animation
Easings
Keyframes
Creating Reusable Animations with animation()
Parameterizing Reusable Animations
Animation Callbacks
Querying Child Elements with query()
Animating Child Elements with animateChild()
Running Parallel Animations with group()
Staggering Animations with stagger()
Working with Custom States
Multi-step Animations
Separation of Concerns

Angular Material 2

Introduction
What is Angular Material
Installing Angular Material
Check Boxes
Radio Buttons
Selects
Inputs
Text Areas
Date Pickers
Icons
Buttons
Chips
Progress Spinners
Tooltips
Tabs
Dialogs
Passing Data to Dialogs
Other Components
Creating a Reusable Module
Themes
SASS
Creating a Custom Theme
Using Angular Material's Typography
Customizing Typography
An Important Note

Redux

Introduction
What is Redux
Building Blocks of Redux
Pure Functions
Installing Redux
Working with Actions
The Select Decorator
Avoiding State Mutation
Using Immutable.js
Exercise
Redux DevTools
Calling Backend APIs
Refactoring Fat Case Statements
Dealing with Complex Domains

Unit Testing

Introduction
What is Automated Testing?
Types of Tests
Unit Testing Fundamentals
Working with Strings and Arrays
Set Up and Tear Down
Working with Forms
Working with Event Emitters
Working with Spies
Interaction Testing
Working with Confirmation Boxes
Limitations of Unit Tests
Code Coverage
Exercises

Integration Testing

Introduction
The Setup
Generating the Setup Code
Testing Property Bindings
Testing Event Bindings
Providing Dependencies
Getting the Dependencies
Providing Stubs
Testing the Navigation
Dealing with Route Params
Testing RouterOutlet Components
Shallow Component Tests
Testing Attribute Directives
Dealing with Asynchronous Operations

Project: Getting Started

Introduction
Challenge
Accessing the Source Code
Creating a New Project
Installing Bootstrap 4
Extracting NavBar Component
Defining the Routes
Adding a Drop-down Menu
Cleaning Up the NavBar
Fixing a Few Minor Issues
Deployment

Project: Authentication and Authorization

Introduction
Implementing Google Login
Implementing the Logout
Displaying the Current User
Using the Async Pipe
Extracting a Service
Protecting the Routes
Redirecting after Logging In
Storing Users in Firebase
Defining Admins
Protecting the Admin Routes
Showing or Hiding the Admin Links
Fixing a Bug

Project: Product Management Module

Introduction
Building a Bootstrap Form
Populating the Categories Drop-down List
Saving the Product in Firebase
Implementing Validation
Adding Custom Validation
Adding a Bootstrap Card
Displaying the List of Products
Editing a Product
Updating a Product
Deleting a Product
Searching for Products
Extracting an Interface
Adding a Data Table Component
Configuring the Data Table
Feeding the Data Table
Filtering with the Data Table
Fixing a Bug with Redirecting Users
Cleaning Up the Product Form

Project: Product Catalog Module

Introduction
Displaying All the Products
Displaying the Categories
Filtering Products by Category
Dealing with Multiple Asynchronous Operations
Refactoring: Extracting ProductFilterComponent
Refactoring: Extracting ProductCardComponent
Improving the Product Card
Making Categories Sticky
Wrap Up

Project: Shopping Cart Module

Introduction
Creating a Shopping Cart
Refactoring: Moving the Responsibility to the Service
Adding a Product to the Shopping Cart
Refactoring the addToCart Method
Displaying the Quantity
Improving the Card Footer
Implementing the Change Quantity Buttons
Displaying the Number of Shopping Cart Items in NavBar
Refactoring: Creating a Rich Model
Building the Shopping Cart Page
Fixing a Design Issue
Displaying the Total Price
Refactoring: Extracting ProductQuantityComponents
Discovering a Design Issue
Flattening Shopping Cart Item Objects
Better Object Initialization
Clearing the Shopping Cart
Fixing a Bug with Updating the Quantity
Improving the Layout
Adding a Thumbnail
More Refactoring

Project: Check Out Module

Introduction
Adding the Check Out Button
Building a Shipping Form
Saving the Order in Firebase
Associating the Order with the Current User
Refactoring: Extract an Order Model
Redirecting the User to the Order Success Page
Clearing the Shopping Cart
Transactions
Adding an Order Summary Widget
Refactoring: Extract ShippingFormComponent
Displaying the Orders
Fixing a Bug
What about Processing Payments?

Project: Modularization and Final Improvements

Introduction
Modules
Essential TypeScript Plugins
Moving Files and Folders
Creating the Shared Module
Creating the Admin Module
Creating the Shopping Module
Creating the Core Module
Importing and Exporting Modules
Adding Icons
Aligning the NavBar Items
Defining a Theme
Coupon to My Other Courses

Popular Courses

Popular Platforms

Popular Searches

The Complete Angular Course: Beginner to Advanced

Online

₹ 4099

Quick Facts

Course overview

The highlights

Program offerings

Course and certificate fees

Fees information

certificate availability

certificate providing authority

Who it is for

What you will learn

The syllabus