Angular Framework Development

AngularJS Programming

AngularJS is a powerful JavaScript framework used for building dynamic, single-page web applications (SPAs). In the AngularJS course at Prolytics, you will learn the fundamentals of AngularJS, including its architecture, directives, controllers, and dependency injection. This course will equip you with the skills to develop interactive and efficient web applications using AngularJS.

The course covers essential topics such as AngularJS core concepts, data binding, routing, services, and best practices for optimizing application performance. Whether you're new to front-end development or an experienced developer looking to enhance your skills, this course will help you master AngularJS and build scalable web applications.

What will you learn
  • Introduction to AngularJS

    Understand the fundamentals of AngularJS, its features, and advantages for building modern web applications.

  • Directives and Data Binding

    Learn about AngularJS directives, two-way data binding, and how to create reusable UI components.

  • Controllers and Scope

    Explore how controllers manage application data and interact with the view using scope and dependency injection.

  • Routing and Navigation

    Master AngularJS routing to build single-page applications with smooth navigation and dynamic content loading.

  • Services and Dependency Injection

    Understand how to use services and dependency injection for modular and maintainable application development.

By completing this course, you will develop expertise in the following areas:

  • Understanding AngularJS architecture and MVC pattern
  • Implementing data binding and dynamic UI updates
  • Developing single-page applications using AngularJS
  • Creating custom directives and reusable components
  • Managing application state with services and factories
  • Handling client-side routing and navigation
  • Optimizing application performance and debugging
  • Integrating AngularJS with RESTful APIs
  • Implementing authentication and authorization
  • Preparing for front-end development career opportunities

Learning Modules

Course Setup & Resources
Module Introduction
A New Starting Project & Analyzing The Project Structure
Understanding Components & How Content Ends Up On The Screen
Creating a First Custom Component
[Optional] JavaScript Refresher: Classes, Properties & More
Configuring the Custom Component
Using the Custom Component
Styling the Header Component & Adding An Image
Managing & Creating Components with the Angular CLI
Styling & Using Our Next Custom Component
Preparing User Data (To Output Dynamic Content)
Storing Data in a Component Class
Outputting Dynamic Content with String Interpolation
Property Binding & Outputting Computed Values
Attribute Binding
Using Getters For Computed Values
Listening to Events with Event Binding
Managing State & Changing Data
A Look Behind The Scenes Of Angular's Change Detection Mechanism
Introducing Signals
We Need More Flexible Components!
Defining Component Inputs
Required & Optional Inputs
Using Signal Inputs
We Need Custom Events!
Working with Outputs & Emitting Data
Using the output() Function
Adding Extra Type Information To EventEmitter
Exercise: Create a Configurable Component
TypeScript: Working With Potentially Undefined Values & Union Types
Accepting Objects As Inputs & Adding Appropriate Typings
TypeScript: Type Aliases & Interfaces
Outputting List Content
Outputting Conditional Content
Legacy Angular: Using ngFor & ngIf
Adding More Components to the Demo App
Outputting User-specific Tasks
Outputting Task Data in the Task Component
Storing Data Models in Separate Files
Dynamic CSS Styling with Class Bindings
More Component Communication: Deleting Tasks
Creating & Conditionally Rendering Another Component
Managing The "New Task" Dialog
Using Directives & Two-Way-Binding
Signals & Two-Way-Binding
Handling Form Submission
Using the Submitted Data
Content Projection with ng-content
Transforming Template Data with Pipes
Getting Started with Services
Getting Started with Dependency Injection
More Service Usage & Alternative Dependency Injection Mechanism
Time to Practice: Services
Using localStorage for Data Storage
Module Summary
Module Introduction
A First Introduction To Angular Modules (NgModule)
Creating a First Empty Module
Bootstrapping Apps with Angular Modules
Declaring & Using Components
A First Summary
Migrating All Components To Use Modules
Creating & Using Shared Modules
Creating More Complex Module-based App Structures
Module Introduction & Starting Project
Exercise Hints
Adding a Header Component With An Image
Adding a User Input Component
Handling Form Submission
Extracting Values with Two-Way-Binding
Calculating the Annual Investment Data
Cross-Component Communication with Outputs
Creating & Using a Data Model
Passing Data from Parent to Child with Inputs
Outputting Data in a Table
Formatting Output with a Pipe
Using Signals & Resetting The Form After Submission
Using a Service for Cross-Component Communication
Using Signals in Services
Migrating to Angular Modules
Module Summary
Module Introduction
Understanding Error Messages & Fixing Errors
Debugging Logical Errors with the Browser DevTools & Breakpoints
Exploring the Angular DevTools
Module Introduction
Starting Project & An Opportunity For Smaller Components?
When & How To Split Up Components
Splitting A Component Into Multiple Components
Creating Reusable Components
Component Inputs: Repetition
Property Binding: Repetition
Using Content Projection & ng-content
Adding Forms to Components
A Possible, But Not Ideal Way Of Extending Built-in Elements
Extending Built-in Elements with Custom Components via Attribute Selectors
Supporting Content Projection with Multiple Slots
Exploring Advanced Content Projection
Defining Content Projection Fallbacks
Multi-Element Custom Components & Content Projection
Scoping CSS Styles to Components
Understanding & Configuring View Encapsulation
Making Sense of Component Host Elements
Using Host Elements Like Regular Elements
Interacting With Host Elements From Inside Components
When (Not) To Rely On Host Elements
Interacting with Host Elements via @HostListener & @HostBinding
Accessing Host Elements Programmatically
Class Bindings: Repetition
There's More Than One Way Of Binding CSS Classes Dynamically
A Closer Look At Dynamic Inline Style Binding
Manipulating State & Using Literal Values
Introducing the Component Lifecycle: ngOnInit
Implementing Lifecycle Interfaces
Component Lifecycle - A Deep Dive
Component Cleanup with ngOnDestroy
Component Cleanup with DestroyRef
Handling Form Submissions: Repetition
Working with Template Variables
Extracting Input Values via Template Variables
Template Variables & Component Instances
Getting Access to Template Elements via ViewChild
Using The viewChild Signal Function
ViewChild vs ContentChild
A Closer Look at Decorator-based Queries & Lifecycle Hooks
The afterRender and afterNextRender Lifecycle Functions
Making Sense of Signal Effects
Signal Effects Cleanup Functions
TypeScript & Type Models: Repetition
Component Outputs: Repetition
A Closer Look At Template For Loops
Revisiting Inputs & Signals
Updating Signal Values
Cross-Component Communication & State Management
Configuring Component Inputs & Outputs
Two-Way Binding: Repetition
Setting Up Custom Two-Way Binding
An Easier Way of Setting Up Custom Two-Way Binding
Module Introduction
Understanding Directives
The Starting Project
Analyzing a Built-in Attribute Directive: ngModel
Analyzing a Built-in Structural Directive: ngIf
Getting Started with Custom Directives
Using Attribute Directives To Change Element Behavior
Working with Inputs in Custom Directives
Directives & Dependency Injection
Building Another Directive
Building a Custom Structural Directive
Structural Directives & Syntactic Sugar
Host Directives & Composition
Module Introduction
Making Sense of Pipes
Using Built-in Pipes
More Built-in Pipes Examples
Building a First Custom Pipe
Using Custom Pipes to Perform Custom Transformations
Accepting Parameters in Custom Pipes
Chaining Pipes & Being Aware of Limitations
Building a Pipe That Sorts Items
Understanding How Pipes Are Executed
Pure & Impure Pipes
Pipe Limitations & When Not To Use Them
Module Introduction
The Starting Project & The Need For A Centralized Service
Creating a Service
How NOT To Provide A Service
Using Angular's Dependency Injection Mechanism
Using The Alternative Dependency Injection Syntax
Outsourcing & Reusing Logic with Services
Angular Has Multiple Injectors!
There Are Multiple Ways Of Providing a Service
Providing Services via the Element Injector
Understanding the Element Injector's Behavior
Injecting Services Into Services
Analyzing Dependency Injection with the Angular DevTools
Using Custom DI Tokens & Providers
Preparing A Non-Class Value For Injection
Injecting Other Values (NOT Services)
Angular Modules (NgModule) & Dependency Injection
Working with Services Without Using Signals
Module Introduction
Analyzing the Starting Project
Understanding How Angular Performs Change Detection
Change Detection During Development: ExpressionChangedAfterChecked Errors
Writing Efficient Template Bindings
Avoiding Zone Pollution
Using the OnPush Strategy
Understanding the OnPush Strategy
Working with OnPush & Signals
Using Signals for Sharing Data Across Components (with OnPush)
The Problem With OnPush, Cross-Component Data & Not Using Signals
Triggering Change Detection Manually & Using RxJS Subjects
Introducing The async Pipe
Going Zoneless!
Module Introduction
What Are Observables & What Is RxJS?
Creating & Using an Observable
Working with RxJS Operators
Working with Signals
Signals vs Observables
Converting Signals To Observables
Converting Observables To Signals
Deep Dive: Creating & Using A Custom Observable From Scratch
Module Summary
Module Introduction
The Starting Projects: Frontend & Backend
How To Connect Angular Apps To A Backend
Optional: HTTP Essentials
Getting Started with Angular's Http Client
Providing the HttpClient when using NgModules
Sending a GET Request To Fetch Data
Configuring Http Requests
Transforming & Using Response Data
Showing a Loading Fallback
Handling HTTP Errors
Sending Data To A Backend
More Data Fetching & Some Code Duplication
Outsourcing HTTP Request Logic Into A Service
Managing HTTP-loaded Data via a Service
Implementing Optimistic Updating
Potential Problems Introduced by Optimistic Updating
Improved Optimistic Updating
Implementing App-wide Error Management
Practice: Sending DELETE Requests
Introducing HTTP Interceptors
Optional: Class-based Interceptors
Introducing HTTP Response Interceptors
Module Introduction
Template-driven vs Reactive Forms
Template-driven: Registering Form Controls
Getting Access to the Angular-managed Form
Extracting User Input Values
Validating Input with Form Validation Directives
Using the Form Validation Status To Provide User Feedback
Adding Validation Styles
Interacting With The Underlying Form Object In The Component
Updating Form Values Programmatically
Reactive Forms: Getting Started
Syncing Reactive Form Definition & Template
Handling Form Submission (Reactive Forms)
Adding Validators To Reactive Forms
Building Custom Validators
Creating & Using Async Validators
Interacting with the Form Programmatically
Exercise: Problem
Exercise: Solution
Connecting & Registering Inputs For A Complex Form
Working with Nested Form Groups
Working with Form Arrays
Practice: Adding More Validation
Creating Multi-Input Validators / Form Group Validators
Module Summary
Module Introduction
What Is Routing?
Enabling Routing & Adding a First Route
Rendering Routes
Registering Multiple Routes
Adding Links The Right Way
Styling Active Navigation Links
Setting Up & Navigating To Dynamic Routes
Extracting Dynamic Route Parameters via Inputs
Extracting Dynamic Route Parameters via @Input()
Extracting Dynamic Route Parameters via Observables
Working with Nested Routes
Route Links & Relative Links
Accessing Parent Route Data From Inside Nested Routes
Loading Data Based On Route Parameters In Child Routes
Link Shortcuts & Programmatic Navigation
Adding A "Not Found" Route
Redirecting Users
Splitting Route Definitions Across Multiple Files
Activated Route vs Activated Route Snapshot
Setting Query Parameters
Extracting Query Parameters via Inputs
Extracting Query Parameters via Observables
Using Query Parameters For Data Manipulation
Adding Static Data To Routes
Resolving Route-related Dynamic Data
Optional: Class-based Resolvers
Accessing Route Data In Components
Controlling Route Resolver Execution
Setting & Resolving Titles
Introducing Route Guards
Optional: Class-based Guards
Making Sense of The CanDeactivate Guard
Improving The CanDeactivate Logic
Reloading Pages via the Angular Router & Configuring Programmatic Navigation
Module Introduction
What Is Lazy Loading / Code Splitting?
Introducing Route-based Lazy Loading
Implementing Route-based Lazy Loading
Lazy Loading Entire Route Groups
Using Lazy Loading & Routing to Lazy-load Services
Introducing Deferrable Views
Defer Loading Until Viewport Visibility
Deferrable Views: Using Other Triggers
Prefetching Lazy-loaded Code
Deferrable Views: Summary
Module Introduction
The Starting Project
Preparing a Project For Deployment: Building It For Production
Building SPAs: Pros & Cons
SPAs: Deployment Example
Using "ng add", "ng deploy" & Angular's Built-in Deployment Support
Server-side Rendering (SSR) Introduction
Setting Up SSR For An Angular App
Building and Service an SSR App
Authoring SSR-ready Code (Beware of Pitfalls!)
SSR and Client-Server Mismatches
Static Site Generation (SSG) Introduction
Configuring & Using SSG
Deployment Methods - A Summary
SSR & SSG Deployment Example
Course Roundup
Bonus: More Content!
About The Rest Of This Course
Where To Go Next?
About This Section
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
Working with Standalone Components
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
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 ngIf to Output Data Conditionally
Enhancing ngIf with an Else Condition
Angular 17: Alternative "if" Syntax
Styling Elements Dynamically with ngStyle
Applying CSS Classes Dynamically with ngClass
Outputting Lists with ngFor
Angular 17: Alternative "for" Syntax
Practicing Directives
[OPTIONAL] Assignment Solution
Getting the Index when using ngFor
About This Section
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
Understanding Angular Error Messages
Debugging Code in the Browser Using Sourcemaps
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 @ViewChild
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
Introduction
Adding Navigation with Event Binding and ngIf
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
Module Introduction
ngFor and ngIf Recap
ngClass and ngStyle Recap
Creating a Basic Attribute Directive
Using the Renderer to build a Better Attribute Directive
More about the Renderer
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
Building and Using a Dropdown Directive
Closing the Dropdown From Anywhere
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
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)
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
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
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
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
Improving the Reactive Service with Observables (Subjects)
Changed the Subscription Name
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
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
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
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
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
A New IDE
Module Introduction
How Does Angular Interact With Backends?
The Anatomy of a Http Request
Backend (Firebase) Setup
Sending a POST Request
GETting Data
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
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
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 UI
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
Module Introduction
Adding an Alert Modal Component
Understanding the Different Approaches
Using ngIf
Preparing Programmatic Creation
Creating a Component Programmatically
About entryComponents
Understanding entryComponents
Data Binding & Event Binding
Wrap Up
Useful Resources & Links
Module Introduction
What are Modules?
Analyzing the AppModule
Getting Started with Feature Modules
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
Useful Resources & Links
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
Module Introduction
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
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
NgRx - The Old Syntax
Making Animations Work with Angular 4+
Introduction
Setting up the Starting Project
Animations Triggers and State
Switching between States
Transitions
Advanced Transitions
Transition Phases
The "void" State
Using Keyframes for Animations
Grouping Transitions
Using Animation Callbacks
Module Introduction
Adding Service Workers
Caching Assets for Offline Use
Caching Dynamic Assets & URLs
Further Links & Resources
About this Section
Introduction
Why Unit Tests?
Analyzing the Testing Setup (as created by the CLI)
Running Tests (with the CLI)
Adding a Component and some fitting Tests
Testing Dependencies: Components and Services
Simulating Async Tasks
Using "fakeAsync" and "tick"
Isolated vs Non-Isolated Tests
Further Resources & Where to Go Next
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
Module Introduction
What & Why?
Installing & Using 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

You Can Trust with Global Certification

At Prolytics Institute, our certifications are globally recognized, ensuring that your skills are validated by a trusted authority. Whether you're advancing in your current role or exploring new career opportunities, our credentials give you a competitive edge in today’s global job market.

Our certification programs are designed to meet international standards while catering to local industry needs. This ensures that your expertise is not only widely accepted but also practically applicable wherever you go.

  • 100% Jobs Placements

Committed to preparing you for successful career placement and acing job interviews.

  • Advanced Curriculum

Our curriculum is thoughtfully crafted by senior angular specialists with extensive industry experience.

  • Latest Technologies

The course prioritizes cutting-edge technologies that are in high demand among top web design firms and global corporations.

  • Confidence Development

A Personality Development program that enhances skills in professional communication, email writing, and effective interview techniques.

  • Work on Real Projects

Engaging hands-on practice and real-world projects form a key part of the learning experience.

  • Top IT Professionals

Learn directly from professionals who are currently active as developer in top IT companies.

certification

FAQs

General frequently asked questions for students.

Our instructors are experienced professionals actively working in the IT industry. They bring real-world insights, practical knowledge, and expertise to the classroom, enhancing the learning experience.

Yes, we offer dedicated job placement support to our graduates. This includes resume workshops, mock interviews, and direct connections with our industry partners to help students transition smoothly into their careers.

Prolytics provides both in-person and online classes to cater to various learning preferences. Our online classes are live and interactive, allowing students to engage directly with instructors and peers.

Absolutely! We prioritize hands-on learning through practical projects and assignments based on real-world scenarios. These projects help students gain practical experience and build a portfolio to showcase to potential employers.

Yes, upon successfully completing a course, students receive a certificate from Prolytics, recognized by industry partners and highly valued in the job market.

Prolytics has a flexible refund policy. Students who need to withdraw may be eligible for a partial refund, depending on the timing and course structure. Please contact our support team for detailed information on refunds.

To enroll, visit our website and register the enrollment form for your desired course. You can also reach out to our admissions team for guidance on course selection and the enrollment process.

Students Reviews

Arun Sharma – 05-Nov-18:

Right from a basic introduction to Angular JS to its more advanced concepts and techniques, the Prolytics team helped me become proficient in this method of programming. Thank you guys!

Monty Bhel – 28-Oct-18:

My favorite part of the Angular JS course taught at Prolytics is that it covers so much in such a short span of time! And the material provided is very comprehensive.

Aman Singh – 21-Sep-18:

I wanted a course on Angular JS that taught everything there is to learn about it and the Prolytics course did just that. That too, at a very fantastic price!