Mô tả

If you want to build large, scalable apps, Angular is the Javascript framework to learn!

Angular has been under development by Google for nearly a full decade.  It has one purpose: scale up to gracefully handle the largest and most complex web apps around.  If you want to build a big app, Angular is the way to go.  Every other course online around Angular shows you how to use the basic syntax and features of Angular, but only this course will show you how to build large, professional projects using Angular. 

Mastering Angular by reading the documentation alone is challenging.  The official documentation always offers multiple ways to achieve any simple task, but never clarifies what the best way to do something is.  In this course, you will gain a fundamental understanding of the best way to achieve any goal with Angular, along with an explanation of the pros and cons of each possible approach.

Top companies are hungry for Angular developers.  You've probably heard of the crazy salaries being offered for front-end developers.  The average starting salary for an Angular developer is $115k USD.  That is not an exaggeration, it is not a joke - this is how badly employers are looking for Angular developers.  You can be the latest hire at a new tech startup, a fantastic engineer with amazing skills in Angular!  All you have to do to earn this salary is understand Angular, and this course will help you do that.

Learning Angular will make you a better software engineer.  Here's the little secret of Angular that nobody tells you about: Angular is really three different topics in one!  You've got Angular itself, Typescript, and RxJs.  Learning Angular isn't just about Angular, its about Typescript and RxJs as well!  Typescript's goal is to help you catch errors quickly during development, rather than when you are running your app, while RxJs has a goal of helping you manage data transparently throughout your application.  Understanding Typescript and RxJS will undoubtedly help you become a more knowledgeable, productive, and successful engineer.  Note that you do not need any prior experience with Typescript or RxJs to take this course - I will teach you everything you need to know!

Planning on building your own apps? This course will give you a countless number of reusable code snippets that you can utilize on your own personal projects, saving you valuable time.  Angular is all about code reusability, and this course will get you started on the right track.  Not only will you get incredibly reusable code, but you'll also learn to integrate multiple different CSS frameworks with Angular, so you can get some custom styling that suits the needs of your app.

Learn from someone who has worked with Angular since its 1.0 release.  I have worked with Angular since version 1.0, released many years ago.  I've seen an incredible number of design patterns and approaches, and I've narrowed down that list to the critical topics that you need to understand.  Rather than showing you every last tiny feature of Angular, you'll learn only the best way to achieve any given task.

But don't just take my word for it - check out the reviews for this course!  You'll see that other engineers - just like yourself - have had great success and acquired a new understanding of how to build large web apps using Angular.


------ What You'll Learn ------

This is a long course, with just about every fact about Angular you could ever hope to know. Here's a brief subset of the topics you'll cover:

  • Master the fundamentals of Angular, including components, services, pipes, and directives

  • Create reusable components that you can plug-and-play to create dynamic, complex apps

  • Understand how to design and architect large apps, with a careful eye on code maintainability

  • Build modular apps that can easily be updated and changed

  • Get a handle on performance by leveraging lazy loading, supercharging the speed of your apps

  • Take a look at Typescript, which will help you write perfect code the first time, rather than encountering errors in the browser

  • Use RxJs to declaratively manage data throughout your app, leveraging built-in functions to transform your data

  • Connect to backend databases like MySQL, Postgres, or MS SQL Server to add data to your app

  • Understand how to handle security in your Angular code

  • ...And so much more!

This course is the resource that I wish I had when I was learning Angular - a course that is up-to-date, complete, and full of practical examples.  I learned Angular years ago before any courses like this existed.  Now you can learn at 10x the speed I did. Sign up today, master Angular, and get a job as a Software Engineer!

Bạn sẽ học được gì

Build amazing single page applications with Angular and Typescript

Master fundamental concepts behind structuring Angular applications

Realize the power of building composable components

Be the engineer who explains how Angular works to everyone else, because you know the fundamentals so well

Build a portfolio of projects to show any potential employer

Architect large apps effectively using Typescript + Angular's Module system

Handle and process data declaratively using RxJs

Yêu cầu

  • Basic understanding of Javascript
  • Basic understanding of how to use the command line

Nội dung khoá học

27 sections

Welcome! Start Here!

9 lectures
How to Get Help
01:05
Course Resources
00:38
Join Our Community!
00:07
Intro - Our First App
08:49
A Few Questions Answered
07:23
Four Major File Types
3 questions
Environment Setup - Node JS
00:26
Environment Setup - Angular CLI
00:37
Environment Setup - Visual Studio Code
01:00

Understanding Angular Template Syntax

19 lectures
Project Overview
03:24
Starting and Stopping an Angular Project
02:32
Updating a Component Template
06:07
Event Binding Syntax
07:02
Property Binding Syntax
06:54
Interpolation Syntax
04:15
Angular vs JavaScript Design Patterns
04:13
Tracking Input State
04:38
Tracking Additional Properties
04:47
Handling Text Input
08:22
Generating a Random Password
06:35
Review on Property Binding
04:30
Adding Third Party CSS
03:18
CSS Import Statements
03:12
Adding Some Styling
02:24
Structural Directives
05:41
Deploying Angular Apps
03:53
Terminology Review
02:24
Terminology Review
4 questions

Building Components

18 lectures
App Overview
02:16
Project Setup
03:37
A Quick HTML Dump
05:28
Adding Static Files to Angular
03:50
Scoped CSS Files
06:17
Components in Angular
06:59
Creating Components
05:22
How Angular Creates Components
07:01
More on CSS Scoping
04:13
Tying Data to a Component
05:01
Accepting Data in a Child Component
09:08
Communicating from Parent to Child
05:13
Fixing Template References
04:27
Building Lists with NgFor
04:30
Two Notes on NgFor
03:47
Host Element Selectors
06:41
Deployment and Review
04:31
What We've Learned So Far
4 questions

Exercise! Building a Typing Game

10 lectures
App Overview
03:54
Initial Steps
01:35
Adding CSS
04:36
IMPORTANT Info About Faker Installation
00:39
Displaying Content
08:50
Randomly Generating Text
03:32
Handling User Input
02:47
Conditional Display
08:54
Character by Character Comparison
06:20
Styling by Comparison
08:30

Mastering Pipes

13 lectures
Pipes Overview
03:12
Adding an Input
03:43
Pipes in Action
02:26
A Touch of Styling
04:30
Adding a Date Picker
03:16
Formatting Dates
07:15
Displaying Currency
03:25
Formatting the Currency
03:03
Formatting Numbers
05:04
Displaying JSON
02:52
Creating Custom Pipes
06:57
Custom Arguments
05:03
Two Neat Things with Pipes
05:10

Directives in Angular

20 lectures
App Overview
02:02
App Setup
02:45
Getting Some Data
02:40
Review on NgFor
04:46
The NgClass Directive
03:39
More on NgClass
04:36
Conditionally Disabling Buttons
04:03
Changes Pages
02:56
Displaying Images
01:42
Reminder on NgIf
03:47
Multiple Directives with Ng-Container
08:19
NgSwitch
04:33
Generating Custom Directives
03:09
Accessing Elements from a Custom Directive
03:26
Communicating Properties to Directives
06:41
Intercepting a Property Assignment
06:12
Input Aliasing
02:58
Replacing NgClass
04:06
Custom Structural Directives
08:54
Context in Structural Directives
04:40

The Module System

9 lectures
App Overview
04:46
Tackling Some Challenges
04:41
Modules Overview
05:03
Generating Modules
05:17
Importing and Exporting Modules
06:40
Modules Exercise
02:09
Quick Note
00:12
Modules Exercise Solution
03:28
Module Property Definitions
02:24

Routing and Navigation Between Pages

10 lectures
Adding Basic Routing
05:26
Routing Exercise
01:36
Exercise Solution
02:10
The RouterOutlet Element
04:03
Navigating with RouterLink
04:17
A Touch of Styling
04:24
Styling an Active Link
01:40
Adding Home and NotFound Routes
05:58
Reordering Routing Rules
04:37
Landing and NotFound Components
01:42

Lazy Loading with Modules

18 lectures
Lazy vs Eager Loading
04:14
Implementing Lazy Loading
09:13
Lazy Loading Exercise
02:53
Exercise Solution
03:43
Creating a Placeholder Component
05:14
Customizing Components
04:56
Reminder on Structural Directives
05:05
Widget Modules
04:38
Implementing a Titled Divider
04:59
Grabbing Content with NgContent
05:02
Creating a Segment Component
03:42
NgContent with Selects
09:36
Hiding Empty Elements
03:34
Building a Reusable Table
04:10
Generating and Displaying the Table
02:47
Communicating Down Table Data
04:30
Assembling the Table
07:27
Passing Down Class Names
04:07

Advanced Component Routing

12 lectures
Tab Based Navigation
03:04
Adding Child Navigation Routes
04:20
Understanding Child Component Routing
05:24
RouterLink Configuration
05:45
Relative RouterLink References
09:01
Alternate RouterLink Syntax
03:17
Matching Exact Paths
02:21
A Reusable Tabs Component
03:47
Views Module Exercise
01:54
Exercise Solution
04:36
Displaying a List of Statistics
07:00
Displaying a List of Items
09:02

Advanced Component Reusability + Hooks

14 lectures
The Mods Module
02:19
Modal Window Setup
05:15
More Basic Modal Setup
04:13
Natural Issues with Modal Windows
06:29
Solving the Modal Issue
05:50
Lifecycle Hooks
07:54
Hiding the Modal with NgOnDestroy
04:35
Opening the Modal
04:44
Closing the Modal
04:05
Stopping Event Bubbling
02:47
Making the Modal Reusable
11:15
Building an Accordion
02:12
Listing Accordion Elements
07:29
Expanding the Active Element
05:19

A Typescript Overview

18 lectures
Intro to TypeScript
04:21
Basic Types
06:54
Type Inference
05:06
Why TypeScript at All?
04:41
TS with Functions
07:00
Difficulties with Objects
05:02
Introducing Interfaces
08:26
Classes and Properties
07:20
Public and Private
06:49
Property Assignment Shortcut
02:25
Enabling Decorator Support
05:38
Decorators
08:25
The Module System
02:14
Strict Mode
06:03
Combining Interfaces and Classes
06:19
Class Generics
07:22
Function Generics
08:24
That's a Lot of Typescript!
4 questions

Handling Data and HTTP Requests

17 lectures
App Overview
03:33
App Architecture
06:26
Generating Services
02:49
Component Design Methodology
07:17
Handling Form Submission
04:20
Child to Parent Communication
05:36
The Wikipedia API
06:19
Notes on Services
02:57
Accessing Services
04:59
Really Weird Behavior
13:52
Where'd That Come From
08:30
Ok, But Why?
06:48
Why Dependency Injection is Useful
12:18
Making HTTP Requests
05:45
Seeing the Request's Response
05:05
More Parent to Child Communication
06:51
Building the Table
05:15

App Security in Angular

6 lectures
Escaping HTML Characters
07:19
XSS Attacks
09:27
More on XSS Attacks
08:19
Adding Title Links
05:22
Another CSS Gotcha
04:09
Last Bit of Styling
04:42

RxJs From the Fundamentals

17 lectures
Notes on RxJs
06:17
A Quick JS Example
07:34
Adding RxJs Terminology
06:05
Creating an Observable
07:49
Implementing the Processing Pipeline
09:06
More Processing!
09:29
Adding an Observer
07:09
Operator Groups
04:45
Specific Operators
05:24
Low Level Observables
11:38
Alternative Observer Syntax
03:20
Unicast Observables
04:31
More on Unicast Observables
07:03
Multicast Observables
03:05
Multicast in Action
05:24
Hot vs Cold Observables
04:47
RxJs Terminology
3 questions

Bonus - Typescript + RxJs!

6 lectures
RxJs in an Angular World
03:33
Applying TypeScript to RxJs
07:59
Generics with RxJs
06:53
Using TypeScript to Catch Errors
05:46
TypeScript is Smart
07:39
Summary
02:30

Exercise! A Photo-Fetching App

11 lectures
App Overview
02:02
App Architecture Design
02:55
API Signup
05:32
HTTP Module Hookup
03:34
HTTP Dependency Injection
06:21
Making the Request
04:11
Displaying the Component
02:33
Making the Request
04:01
Using a Generic Type
03:13
Displaying the Image
02:50
Refetching Data
04:22

Credit Card Payments with Reactive Forms

22 lectures
App Overview
04:26
Reactive Forms vs Template Forms
05:50
Creating a Form Instance
07:12
Binding a FormGroup to a Form
05:37
Validating Fields
03:52
Finding Validation Errors
03:54
Nasty Error Handling
07:01
Showing and Hiding Validation Messages
07:41
Making a Reusable Input
06:20
Adding Message Cases
06:21
Changing Styling on Validation Errors
05:38
Adding Additional Inputs
03:39
Handling Form Submission
04:09
Additional Validations
06:58
Input Masking
04:08
Hijacking Form Control Values
08:53
Inserting Extra Characters
05:34
Reformatting the Input
06:57
Using a Library for Masking
09:48
Resetting a Form
06:10
A Touch of Styling
03:58
Adding a Credit Card
06:45

Simple Data Entry with Template Forms

8 lectures
App Overview
01:13
Basic Template Form Setup
05:36
Two Way Binding Syntax
03:23
Differences Between Template and Reactive Forms
09:11
Validation Around Template Forms
03:51
Conditional Validation
04:24
Handling Form Submission
02:16
Adding Styling and Wrapup
04:07

Build a Fast-Paced Math Game

17 lectures
App Overview
03:05
App Setup
02:04
Possible Design Approaches
05:29
Displaying Form Values
06:32
Adding Custom Validation
08:33
Extracting Custom Validation Logic
06:18
Making Validators Reusable
05:21
RxJs with Reactive Forms
03:05
Handling Correct Answers
05:18
The Delay Operator
03:45
Adding a Statistic
04:38
RxJs Solution
06:28
A Touch of Styling
03:08
Helping the User Along
03:04
Accessing FormGroups from Custom Directives
11:01
Detecting Changes
07:16
Applying a Class Name
03:14

Custom Validators

20 lectures
App Overview
04:30
The API Server
01:55
Contacting the Backend API
08:46
Cookie Based Authentication
05:26
File Generation
03:58
Navigation Reminder
06:17
Adding a Signup Form
05:25
Adding Basic Styling
03:44
Username and Password Validation
09:05
Writing Custom Validators
09:39
Connecting Custom Validators
06:05
Implementing Async Validators
09:52
Nasty Async Validators
07:41
Understanding Async Validators
11:43
Handling Errors from Async Validation
10:37
Building an Auth Service
07:36
Another Reusable Input
06:09
Robust Error Handling
08:33
Customizing Input Type
04:59
Fixing a Few Odds and Ends
07:11

Handling Authentication

26 lectures
Signup Process Overview
04:09
Making the Signup Request
09:34
Cleaning up the Auth Service
06:30
Handling Signup Errors
07:59
Generic Error Handling
02:50
Adding a Navigation Header
04:53
Maintaining Authentication State
06:59
Oh No, More RxJs
12:16
Using BehaviorSubjects
08:22
The Async Pipe
04:36
Exact Active Links
01:52
Checking Auth Status
06:46
A Gotcha Around the HttpClient
05:36
HTTP Interceptors
08:59
Wiring up an Interceptor
06:35
Modifying Outgoing Requests
04:08
Other Uses of Interceptors
08:07
A Little Record Keeping
04:51
Adding Sign Out
06:31
Automated Signouts
06:39
Programmatic Navigation
03:19
Building the Sign In Flow
05:50
Sign In Authentication
08:13
Showing Authentication Errors
07:32
Inbox Module Design
08:14
Navigation on Authentication
03:51

More on Angular App Security

5 lectures
Restricting Routing with Guards
09:15
Issues With Guards
10:29
A Solution to the Guard with RxJs
09:51
Implementing Our RxJs Solution
04:58
Navigation on Failing a Guard
03:21

Build a Real Email Client!

36 lectures
Generating Inbox Components
04:41
Retrieving Emails
06:32
Adding Email Fetching to the Service
05:37
Connecting the Service
04:33
Rendering a List of Emails
04:55
Child Route Navigation
07:48
Relative Links with Router Link
04:05
Styling the Selected Email
04:34
Placeholder Markup
01:01
Extracting URL Params
06:26
Accessing Route Information
07:26
Snapshot vs Observable Route Params
04:21
Issues with Nested Subscribes
06:59
Canceling Previous Email Requests
04:49
Handling Undefined Data
07:26
Reusable Data Fetching with Resolvers
04:26
Using a Resolver
07:12
Communicating Data Out of a Resolver
08:33
Error Handling with Resolvers
08:14
Showing Email HTML
06:35
Component Reuse in Email Creation
03:08
A Reusable Modal
04:52
Some More Modal Implementation
08:52
Where to Place the Modal?
06:08
Toggling Modal Visibility
05:12
Providing a Form Default Values
08:12
Displaying Email Inputs
05:29
Adding Form Validation
05:28
Displaying Textarea instead of Text Input
03:41
Capturing the Username
06:46
Submitting a New Email
07:16
Sending Original Email
05:18
Replying to Emails
05:04
Formatting Reply Emails
09:56
Sending Replies
04:05
Quick Bug Fix! (Final Lecture)
01:14

Appendix - TypeScript

85 lectures
Type Annotations and Inference
02:03
Annotations and Variables
04:53
Object Literal Annotations
06:53
Annotations Around Functions
05:55
Understanding Inference
03:51
The Any Type
07:47
Fixing the "Any" Type
01:49
Delayed Initialization
03:05
When Inference Doesn't Work
04:37
Annotations Around Functions
04:56
Inference Around Functions
06:08
Annotations for Anonymous Functions
01:42
Void and Never
02:49
Destructuring with Annotations
03:35
Annotations and Objects
07:05
Arrays in TypeScript
05:05
Why Typed Arrays?
04:30
Multiple Types in Arrays
02:57
When to Use Typed Arrays
00:54
Tuples in TypeScript
04:04
Tuples in Action
05:28
Why Tuples?
03:20
Interfaces
01:26
Long Type Annotations
04:42
Fixing Annotations With Interfaces
04:36
Syntax Around Interfaces
03:31
Functions in Interfaces
04:46
Code Reuse with Interfaces
04:15
General Plan with Interfaces
03:12
Classes
03:47
Basic Inheritance
03:03
Class Method Modifiers
06:41
Fields in Classes
06:18
Fields with Inheritance
04:18
Where to Use Classes
01:09
Updated Parcel Instructions
00:13
App Overview
02:45
Bundling with Parcel
04:54
Project Structure
03:19
IMPORTANT Info About Faker Installation
00:25
Generating Random Data
05:29
Type Definition Files
05:17
Using Type Definition Files
06:20
Export Statements in TypeScript
05:06
Defining a Company
04:43
A Note on API Keys
00:27
Adding Google Maps Support
07:38
Required Update for New @types Library
00:18
Google Maps Integration with TypeScript
04:06
Exploring Type Definition Files
12:46
Hiding Functionality
06:28
Why Use Private Modifiers? Here's Why
08:25
Adding Markers
09:18
Duplicate Code
02:45
One Possible Solution
06:38
Restricting Access with Interfaces
05:35
Implicit Type Checks
03:26
Showing Popup Windows
06:47
Updating Interface Definitions
07:11
Optional Implements Clauses
06:06
App Wrapup
08:08
App Overview
01:34
Configuring the TS Compiler
07:40
Concurrently Compilation and Execution
05:05
A Simple Sorting Algorithm
04:47
Sorter Scaffolding
03:10
Sorting Implementation
05:17
Two Huge Issues
07:37
TypeScript is Really Smart
09:34
Type Guards
09:13
Why Is This Bad?
02:22
Extracting Key Logic
07:29
Seperating Swapping and Comparison
13:58
The Big Reveal
04:38
Interface Definition
04:48
Sorting Abritrary Collections
11:08
Linked List Implementation
24:15
Completed Linked List Code
00:01
Just... One... More... Fix...
04:03
Integrating the Sort Method
02:44
Issues with Inheritance
06:54
Abstract Classes
06:25
Abstract Classes in Action
04:30
Solving All Our Issues with Abstract Classes
04:00
Interfaces vs Abstract Classes
03:23

BONUS - A Multi-Feature Landing Page App

69 lectures
IMPORTANT - Unfinished Application
00:17
App Overview
05:10
Modules Overview
06:37
Generating Modules
04:22
Module Properties
06:45
Connecting Modules
06:59
Examining the API
05:31
Reading the Users Location
04:59
The Angular Way
03:43
Geolocation in an Observable
05:26
Connecting the Service to a Component
03:33
Transforming Coordinates to Query Params
09:02
SwitchMap vs MergeMap
11:26
But Why SwitchMap?
05:33
Making a Request
08:03
Further Processing
04:24
Generics on HTTP Requests
08:56
Filter, MergeMap, Pluck Operators
14:18
Map and toArray Operators
02:48
Accessing Data in the Template
03:57
Pipes Overview
07:08
Data Pipes
04:06
The Async Pipe
06:15
Adding Bootstrap
02:29
Styling the Forecast Component
04:20
Reminder on the Share Operator
04:36
How to Structure Services
10:47
Generating the Notification Module
05:43
Notifications Service Design
04:45
Introducing Subjects
11:03
Subject Variations
08:13
More Design on Notifications
09:07
Building a Command Structure
09:18
The Scan Operator
12:57
Scan in the Service
03:02
Fixing a Few Errors
03:28
Replay Subject in Action
07:18
A Preferred Solution
05:16
Displaying Messages
05:49
Automatic Timeout
03:18
Notification Styling
03:32
Clearing Messages
03:51
When to Add Notifications
04:53
Showing Success and Errors
05:37
CatchError and ThrowError
09:37
The Retry Operator
04:47
Service Design
07:43
More on API Pagination
05:33
Service Generation
04:17
Subject Declarations
04:46
Building the HTTP Params
03:57
Applying a Type to the Response
06:24
Calculating Pages Available
04:43
Wrapping the Input Subject
04:23
A Better Interface
02:59
The Article List Component
03:44
Accessing the Data
04:06
Rendering Articles
03:34
Fetching a Page
01:17
Fixing Some Styling
02:16
Creating Custom Pipes
04:08
Custom Pipe Arguments
04:46
The Shared Module Pattern
02:36
Connecting the Paginator
03:41
Paginator Strategy
03:12
Paginator Internals
07:24
Styling the Current Page
03:09
Parent to Child Communication
03:45
REMINDER - Unfinished Application
00:12

Bonus!

1 lectures
Bonus!
00:36

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.