Angular – The Complete Guide (2023 Edition)

Thank you for reading “Angular – The Complete Guide (2023 Edition)”! You will start on an educational journey to learn the ins and outs of Angular in this free video course, which is featured on our website “ Angular – The Complete Guide” This course, with more than 30 hours of with-depth video content, is made to give you the fundamental knowledge necessary to become an expert in Angular.

Our experienced instructors will walk you through the basic ideas and modern techniques of Angular in a series of enjoyable videos so you can create dynamic and responsive websites with ease. This course is appropriate to learners of all ability levels, whether you’re a novice or an expert developer wishing to advance your Angular abilities.

Table of Contents

You’ll begin with getting familiar with Angular’s basics, its guiding principles, and how to set up a development environment. Following that, you’ll delve into subjects like component architecture, data binding, routing, forms, and services, developing a thorough understanding of how to create reliable Angular apps.

We hope to give you a fun learning experience with our “educational” tone and energetic voice. Every module moves easily from one subject to the next, offering a gradual learning curve throughout the course. To help you learn the information, our instructors explain it in a simple and succinct manner using relevant examples and situations from everyday life.

What You’ll Learn:

  • Developing modern, complex, responsive, and scalable web applications using Angular.
  • Gaining a comprehensive understanding of the architecture behind Angular applications and learning how to effectively utilize it.
  • Leveraging deep knowledge of Angular fundamentals to establish yourself as a frontend developer.
  • Creating single-page applications using one of the most advanced JavaScript frameworks available.

Course Content of Angular – The Complete Guide

1. Getting Started

  • Course Introduction
  • What is Angular?
  • Join our Online Learning Community
  • Angular vs Angular 2 vs Latest Angular Version
  • CLI Deep Dive & Troubleshooting
  • ELQject Setup and First App
  • Editing the First App
  • The Course Structure
  • How to get the Most out of the Course
  • What is TypeScript?
  • Optional: TypeScript Quick Introduction
  • A Basic Project Setup using Bootstrap for Styling
  • About the Course Code / Code Snapshots

2. The Basics

  • Module Introduction
  • How an Angular App gets Loaded and Started
  • Components are Important!
  • Creating a New Component
  • Understanding the Role of AppModule and Component
  • Declaration
  • Using Custom Components
  • Creating Components with the CLI & Nesting Components
  • Working with Component Templates
  • Working with Component Styles
  • Fully Understanding the Component Selector
  • Practicing Components
  • [OPTIONAL] Assignment Solution
  • What is Databinding?
  • String Interpolation

3. Property Binding

  • Property Binding vs String Interpolation
  • Event Binding
  • Bindable Properties and Events
  • Passing and Using Data with Event Binding
  • Important: FormsModule is Required for Two-Way-Binding!
  • Two-Way-Databinding
  • Combining all Forms of Databinding
  • Practicing Databinding
  • [OPTIONAL] Assignment Solution
  • Understanding Directives
  • Using nglf to Output Data Conditionally
  • Enhancing nglf with an Else Condition
  • Styling Elements Dynamically with ngStyle
  • Applying CSS Classes Dynamically with ngClass
  • Outputting Lists with ngFor
  • Practicing Directives
  • [OPTIONAL] Assignment Solution
  • Getting the Index when using ngFor

4. Course Project – The Basics Angular – The Complete Guide

  • Project Introduction
  • Planning the App
  • Creating a New App Correctly
  • Setting up the Application
  • Creating the Components
  • Using the Components
  • Adding a Navigation Bar
  • Alternative Non-Collapsable Navigation Bar
  • Creating a “Recipe” Model
  • Adding Content to the Recipes Components
  • Outputting a List of Recipes with ngFor
  • Displaying Recipe Details
  • Working on the ShoppingListComponent
  • Creating an “Ingredient” Model
  • Creating and Outputting the Shopping List
  • Adding a Shopping List Edit Section
  • Wrap Up & Next Steps

5. Debugging of

  • Understanding Angular Error Messages
  • Debugging Code in the Browser Using Sourcemaps

6. Components & Databinding Deep Dive

  • Module Introduction
  • Splitting Apps into Components
  • Property & Event Binding Overview
  • Binding to Custom Properties
  • Assigning an Alias to Custom Properties
  • Binding to Custom Events
  • Assigning an Alias to Custom Events
  • Custom Property and Event Binding Summary
  • Understanding View Encapsulation
  • More on View Encapsulation
  • Using Local References in Templates
  • @ViewChild() in Angular 8+
  • Getting Access to the Template & DOM with @VlewChild
  • Projecting Content into Components with ng-content
  • Understanding the Component Lifecycle
  • Seeing Lifecycle Hooks in Action
  • Lifecycle Hooks and Template Access
  • @ContentChild() in Angular 8+
  • Getting Access to ng-content with @ContentChild
  • Wrap Up
  • Practicing Property & Event Binding and View Encapsulation
  • [OPTIONAL] Assignment Solution

7. Course Project – Components & Databinding

  • Introduction
  • Adding Navigation with Event Binding and nglf
  • Passing Recipe Data with Property Binding
  • Passing Data with Event and Property Binding (Combined)
  • Make sure you have FormsModule added!
  • Allowing the User to Add Ingredients to the Shopping List

8. Directives Deep Dive Angular – The Complete Guide

  • Module Introduction
  • ngFor and nglf Recap
  • ngClass and ngStyle Recap
  • Creating a Basic Attribute Directive
  • Using the Renderer to build a Better Attribute Directive
  • More about the Renderer of Angular – The Complete Guide
  • Using HostListener to Listen to Host Events
  • Using HostBinding to Bind to Host Properties
  • Binding to Directive Properties
  • What Happens behind the Scenes on Structural Directives
  • Building a Structural Directive
  • Understanding ngSwitch

9. Course Project – Directives

  • Building and Using a Dropdown Directive
  • D Closing the Dropdown From Anywhere

10. Using Services & Dependency Injection

  • Module Introduction
  • Why would you Need Services?
  • Creating a Logging Service
  • Injecting the Logging Service into Components
  • Alternative Injection Syntax
  • Creating a Data Service
  • Understanding the Hierarchical Injector
  • How many Instances of Service Should It Be?
  • Injecting Services into Services
  • Using Services for Cross-Component Communication
  • A Different Way Of Injecting Services
  • Practicing Services
  • [OPTIONAL] Assignment Solution

11. Course Project – Services & Dependency Injection

  • Introduction
  • Setting up the Services
  • Managing Recipes in a Recipe Service
  • Using a Service for Cross-Component Communication
  • Adding the Shopping List Service
  • Using Services for Pushing Data from A to B
  • Adding Ingredients to Recipes
  • Passing Ingredients from Recipes to the Shopping List (via a
  • Service)

12. Changing Pages with Routing

  • Module Introduction
  • Why do we need a Router?
  • Understanding the Example Project
  • Setting up and Loading Routes
  • Navigating with Router Links
  • Understanding Navigation Paths
  • Styling Active Router Links
  • Navigating Programmatically
  • Using Relative Paths in Programmatic Navigation
  • Passing Parameters to Routes
  • Fetching Route Parameters
  • Fetching Route Parameters Reactively
  • An Important Note about Route Observables
  • Passing Query Parameters and Fragments
  • Retrieving Query Parameters and Fragments
  • Retrieving Query Parameters and Fragments
  • Practicing and some Common Gotchas
  • Setting up Child (Nested) Routes
  • Using Query Parameters – Practice
  • Configuring the Handling of Query Parameters
  • Redirecting and Wildcard Routes
  • Important: Redirection Path Matching
  • Outsourcing the Route Configuration
  • An Introduction to Guards
  • Protecting Routes with canActivate
  • Protecting Child (Nested) Routes with canActivateChild
  • Using a Fake Auth Service
  • Controlling Navigation with canDeactivate
  • Passing Static Data to a Route
  • Resolving Dynamic Data with the resolve Guard
  • Understanding Location Strategies
  • Wrap Up v

13. Course Project – Routing

  • Planning the General Structure
  • Setting Up Routes
  • Adding Navigation to the App
  • Marking Active Routes
  • Fixing Page Reload Issues
  • Child Routes: Challenge
  • Adding Child Routing Together
  • Configuring Route Parameters
  • Passing Dynamic Parameters to Links
  • Styling Active Recipe Items
  • Adding Editing Routes
  • Retrieving Route Parameters
  • Programmatic Navigation to the Edit Page
  • One Note about Route Observables
  • Project Cleanup

14. Understanding Observables

  • Module Introduction
  • Install RxJS
  • Analyzing Angular Observables
  • Getting Closer to the Core of Observables
  • Building a Custom Observable
  • Errors & Completion
  • Observables & You!
  • Understanding Operators
  • Subjects
  • Wrap Up
  • Useful Resources & Links

15. Course Project – Observables

  • Improving the Reactive Service with Observables (Subjects)
  • D Changed the Subscription Name

16. Handling Forms in Angular Apps

  • Module Introduction
  • Why do we Need Angular’s Help?
  • Template-Driven (TD) vs Reactive Approach
  • An Example Form
  • TD: Creating the Form and Registering the Controls
  • TD: Submitting and Using the Form
  • TD: Understanding Form State
  • TD: Accessing the Form with @ViewChild
  • TD: Adding Validation to check User Input
  • Built-in Validators & Using HTML5 Validation
  • TD: Using the Form State
  • TD: Outputting Validation Error Messages
  • TD: Set Default Values with ngModel Property Binding
  • TD: Using ngModel with Two-Way-Binding
  • TD: Grouping Form Controls
  • TD: Handling Radio Buttons
  • TD: Setting and Patching Form Values
  • TD: Using Form Data
  • TD: Resetting Forms
  • Practicing Template-Driven Forms
  • Introduction to the Reactive Approach
  • Reactive: Setup v
  • Reactive: Creating a Form in Code
  • Reactive: Syncing HTML and Form
  • Reactive: Submitting the Form
  • Reactive: Adding Validation
  • Reactive: Getting Access to Controls
  • Reactive: Grouping Controls
  • Fixing a Bug of Angular – The Complete Guide
  • Reactive: Arrays of Form Controls (FormArray)
  • Reactive: Creating Custom Validators
  • Reactive: Using Error Codes
  • Reactive: Creating a Custom Async Validator
  • Reactive: Reacting to Status or Value Changes
  • Reactive: Setting and Patching Values
  • Practicing Reactive Forms
  • [OPTIONAL] Assignment Solution

17. Course Project – Forms

  • Introduction
  • TD: Adding the Shopping List Form
  • Adding Validation to the Form
  • Allowing the Selection of Items in the List
  • Loading the Shopping List Items into the Form
  • Updating existing Items
  • Resetting the Form
  • Allowing the the User to Clear (Cancel) the Form
  • Allowing the Deletion of Shopping List Items
  • Creating the Template for the (Reactive) Recipe Edit Form
  • Creating the Form For Editing Recipes
  • Syncing HTML with the Form
  • Fixing a Bug
  • Adding Ingredient Controls to a Form Array
  • Adding new Ingredient Controls
  • Validating User Input
  • Submitting the Recipe Edit Form
  • Adding a Delete and Clear (Cancel) Functionality
  • Redirecting the User (after Deleting a Recipe)
  • Adding an Image Preview
  • Providing the Recipe Service Correctly
  • Deleting Ingredients and Some Finishing Touches
  • Deleting all Items in a FormArray

18. Using Pipes to Transform Output

  • Introduction & Why Pipes are Useful
  • Using Pipes
  • Parametrizing Pipes
  • Where to learn more about Pipes
  • Chaining Multiple Pipes
  • Creating a Custom Pipe
  • Parametrizing a Custom Pipe
  • Example: Creating a Filter Pipe
  • Pure and Impure Pipes (or: How to “fix” the Filter Pipe)
  • Understanding the “async” Pipe
  • Practicing Pipes

19. Making Http Requests

  • Module Introduction
  • How Does Angular Interact With Backends?
  • The Anatomy of a Http Request
  • Backend (Firebase) Setup
  • Sending a POST Request
  • GETting Data of Angular – The Complete Guide
  • Using RxJS Operators to Transform Response Data
  • Using Types with the HttpClient
  • Outputting Posts
  • Showing a Loading Indicator
  • Using a Service for Http Requests
  • Services & Components Working Together
  • Sending a DELETE Request
  • Handling Errors
  • Using Subjects for Error Handling
  • Using the catchError Operator
  • Error Handling & UX
  • Setting Headers
  • Adding Query Params
  • Observing Different Types of Responses
  • Changing the Response Body Type
  • Introducing Interceptors
  • Manipulating Request Objects
  • Response Interceptors
  • Multiple Interceptors
  • Wrap Up
  • Useful Resources & Links

20. Course Project – Http

  • Module Introduction
  • Backend (Firebase) Setup
  • Setting Up the DataStorage Service
  • Storing Recipes
  • Fetching Recipes
  • Transforming Response Data
  • Resolving Data Before Loading
  • Fixing a Bug with the Resolver

21. Authentication & Route Protection in Angular

  • Module Introduction
  • How Authentication Works
  • Adding the Auth Page
  • Switching Between Auth Modes
  • Handling Form Input
  • Preparing the Backend
  • Make sure you got Recipes in your backend!
  • Preparing the Signup Request
  • Sending the Signup Request
  • Adding a Loading Spinner & Error Handling Logic
  • Improving Error Handling
  • Sending Login Requests
  • Login Error Handling
  • Creating & Storing the User Data
  • Reflecting the Auth State in the IJI
  • Adding the Token to Outgoing Requests
  • Attaching the Token with an Interceptor
  • Adding Logout
  • Adding Auto-Login
  • Adding Auto-Logout
  • Adding an Auth Guard
  • Wrap Up
  • Useful Resources & Links

22. Dynamic Components

  • Module Introduction
  • Adding an Alert Modal Component
  • Understanding the Different Approaches
  • Using nglf
  • Preparing Programmatic Creation
  • Creating a Component Programmatically
  • About entryComponents
  • Understanding entryComponents
  • Data Binding & Event Binding
  • Wrap Up
  • Useful Resources & Links

23. Angular Modules & Optimizing Angular Apps

  • Module Introduction
  • What are Modules?
  • Analyzing the AppModule
  • Getting Started with Feature Modules of Angular – The Complete Guide
  • Splitting Modules Correctly
  • Adding Routes to Feature Modules
  • Component Declarations
  • The ShoppingList Feature Module
  • Understanding Shared Modules
  • Understanding the Core Module
  • Adding an Auth Feature Module
  • Understanding Lazy Loading
  • Implementing Lazy Loading
  • More Lazy Loading
  • Preloading Lazy-Loaded Code
  • Modules & Services
  • Loading Services Differently
  • D Useful Resources & Links

24. Deploying an Angular App

  • Module Introduction
  • Deployment Preparation & Steps
  • Using Environment Variables
  • Deploying Angular Applications
  • Deployment Example: Firebase Hosting
  • Server Routing vs Browser Routing

25. Standalone Components

  • Module Introduction
  • Starting Setup & Why We Want Standalone Components
  • Building a First Standalone Component
  • Standalone Components Are Now Stable
  • Standalone Directives & Connecting Building Blocks
  • Migrating Another Component
  • A Standalone Root Component
  • Services & Standalone Components
  • Routing with Standalone Components
  • Lazy Loading
  • Summary

26. Angular Signals

  • Module Introduction of Angular – The Complete Guide
  • Signals: What & Why?
  • Creating a New Signal
  • Updating a Signal Value
  • Reading & Outputting a Signal Value
  • Signal Updating: set(), update() & mutate()
  • Important: Signals are NOT Finished Yet!
  • Signals: What’s To Come?
  • Computed Values & Effects
  • Module Summary

27. Bonus: using NgRx For State Management

  • Module Introduction
  • What Is NgRx?
  • Understanding NgRx & Its Building Blocks
  • Project Setup & Installing NgRx
  • Adding a First Reducer & Store Setup
  • An Alternative Way Of Creating Reducers
  • Reading Data From The Store
  • Introducing Actions & State Changing Reducers
  • Dispatching Actions
  • Attaching Data To Actions
  • Handling Actions Without createReducer
  • An Alternative Way Of Defining Actions
  • Time To Practice: A Second Action
  • Exploring Selectors
  • Introducing Effects
  • Installing the Effects Package
  • Defining a First Effect
  • The Old @Effect Decorator & Registering Effects
  • Using Store Data In Effects
  • Adding a Second Effect
  • Summary
  • About The Remaining Section
  • Recipe Project Starting Code
  • Getting Started with Reducers
  • Adding Logic to the Reducer
  • Understanding &Adding Actions
  • Setting Up the NgRx Store
  • Selecting State
  • Dispatching Actions
  • Multiple Actions
  • Preparing Update & Delete Actions
  • Updating & Deleting Ingredients
  • Expanding the State
  • Managing More State via NgRx
  • Removing Redundant Component State Management
  • First Summary & Clean Up
  • One Root State
  • Setting Up Auth Reducer & Actions
  • Dispatching Auth Actions
  • Auth Finished (For Now…)
  • And Important Note on Actions
  • Exploring NgRx Effects
  • Defining the First Effect
  • Important: Avoid @Effect
  • Effects & Error Handling
  • Login via NgRx Effects
  • Managing IJI State in NgRx
  • Finishing the Login Effect
  • Preparing Other Auth Actions
  • Adding Signup
  • Further Auth Effects
  • Addinq Auto-Loqin with NqRx
  • Adding Auto-Logout
  • Finishing the Auth Effects
  • Using the Store Devtools
  • The Router Store
  • Getting Started with NgRx for Recipes
  • Fetching Recipe Detail Data
  • Fetching Recipes & Using the Resolver
  • Fixing the Auth Redirect
  • Update, Delete and Add Recipes
  • Storing Recipes via Effects
  • Cleanup Work
  • Wrap Up
  • Alternative NgRx Syntax
  • Useful Resources & Links

28. Bonus: Angular Universal

  • Module Introduction
  • Angular Universal – What & Why?
  • Converting the App to a Universal App
  • Analyzing & Running Server-side Code
  • A Closer Look At The Server-side Code
  • Integrating a REST API
  • Some Notes About Deploying Angular Universal Apps
  • Angular Universal Gotchas

29. Angular Animations

  • Making Animations Work with Angular 4+
  • Introduction v
  • Setting up the Starting Project v
  • Animations Triggers and State v
  • Switching between States v
  • Transitions v
  • Advanced Transitions v
  • Transition Phases v
  • The “void” State v
  • Using Keyframes for Animations
  • Grouping Transitions v
  • Using Animation Callbacks

30. Adding Offline Capabilities with Service Workers

  • Module Introduction
  • Adding Service Workers
  • Caching Assets for Offline Use
  • Caching Dynamic Assets & URLs
  • Further Links & Resources

31. A Basic Introduction to Unit Testing in Angular Apps

  • About this Section
  • Introduction v
  • Why Unit Tests? v
  • Analyzing the Testing Setup (as created by the CLI)
  • Running Tests (with the CLI) v
  • Adding a Component and some fitting Tests v
  • Testing Dependencies: Components and Services
  • Simulating Async Tasks v
  • Using “fakeAsync” and “tick” v
  • Isolated vs Non-lsolated Tests v
  • Further Resources & Where to Go Next

32. Angular as a Platform & Closer Look at the CLI
Module Introduction

  • A Closer Look at “ng new”
  • IDE & Project setup
  • Understanding the Config Files
  • Important CLI Commands
  • The “angular.json” File – A Closer Look
  • Angular Schematics – An Introduction
  • The “ng add” Command
  • Using Custom “ng generate” Schematics
  • Smooth Updating of Projects with “ng update”
  • Simplified Deployment with “ng deploy”
  • Understanding “Differential Loading”
  • Managing Multiple Projects in One Folder
  • Angular Libraries – An Introduction
  • Wrap Up

33. Angular Changes & New Features

  • A First Look At Angular Elements v

34. Course Roundup

35. Thanks for being part of the course!

  • Bonus: More Content!

36. Bonus: TypeScript Introduction (for Angular 2 Usage)

  • Module Introduction
  • What & Why?
  • Installing & IJsing TypeScript
  • Base Types & Primitives
  • Array & Object Types
  • Type Inference
  • Working with Union Types
  • Assigning Type Aliases
  • Diving into Functions & Function Types
  • Understanding Generics
  • Classes & TypeScript
  • Working with Interfaces
  • Configuring the TypeScript Compiler
  • Module Resources

Requirements: of Angular – The Complete Guide

  • No prior knowledge of Angular 1 or Angular 2+ is required!
  • Basic knowledge of HTML and CSS is beneficial but not mandatory.
  • Prior knowledge of TypeScript is helpful but not necessary to fully benefit from this course.
  • Basic knowledge of JavaScript is required.

Who this course is for:

  • Newcomers and experienced frontend developers seeking to learn a contemporary JavaScript framework.
  • Individuals interested in acquiring knowledge about a cutting-edge frontend JavaScript framework.
  • Enrolling in this course will position you among the early adopters who possess a strong grasp of Angular.

How long is the course?

This course consists of 30+ hours of video content, covering a wide range of Angular topics in depth.

How often may I access the course products?

You will have unrestricted access to the video material after you join in the course. You are welcome to go at your own pace and come return to any fields as often as necessary.

Does this course have any prerequisites?

Previous work with HTML, CSS, and JavaScript is helpful but not necessary. As they come up, our educators will go over the relevant ideas, providing a thorough learning process.

Free now in “Angular – The Complete Guide (2023 Edition)” and unlock the full potential of Angular development. Start building powerful web applications today!

No Waiting Time Direct Download Click on Pro Download – (No Ads) – High Speed

Wait 15 Second For Download This File For Free – Ads Waiting Time – Low Speed

Author :

if you find any wrong activities so kindly read our DMCA policy also contact us. Thank you for understand us…

5/5 - (6 votes)

1 thought on “Angular – The Complete Guide (2023 Edition)”

Leave a Comment