Learn how to leverage the power of Angular to build powerful real-world applications from the ground up. We will start from ground zero and learn how to use the Angular CLI to quickstart our app and then learn about components, templates, routing, forms, and server-side communication along the way. As our application comes together, we will discuss proven techniques and patterns that you can use right away to start developing great web applications.

Published: June 29, 2020

Table of Contents
Introduction
Introduction
00:00:00 - 00:07:47
Introduction
Lukas Ruebbelke gives an overview of the course curriculum, demonstrates how to set up Angular with the CLI, and introduces the main APIs that will be used in the course.
Setting Up the Repo
00:07:48 - 00:11:29
Setting Up the Repo
Lukas demonstrates how to set up the course repo, runs the npm run server:all command to set up a JSON API server that the client-side app can communicate with, and uses ng serve to start the application.
Angular Overview
00:11:30 - 00:18:33
Angular Overview
Lukas describes the main differences between Angular 1.x and the new version of Angular, and explains that the new version of Angular is a component based framework containing modules, routes, components, and services.
Generate an App with the Angular CLI
00:18:34 - 00:28:52
Generate an App with the Angular CLI
Lukas demonstrates how to generate a new Angular application with the Angular CLI from scratch.
Angular Files & Style Guide
00:28:53 - 00:37:17
Angular Files & Style Guide
Lukas walks through the files generated in an Angular application through the CLI, and references the Angular style guide as the community guidelines for writing good Angular code.
Generate a New Component
00:37:18 - 00:45:15
Generate a New Component
Lukas demonstrates how to generate a new component with the Angular CLI, and explains that there are two parallel module systems: one is at the language level, ES6 and above, to manage the source code and the other, ng module, is in charge of the application configuration. A module can have multiple components.
Angular and ES6 Modules
00:45:16 - 00:52:13
Angular and ES6 Modules
Lukas answers questions from the audience about when to create a module when using Angular, explains that every component does not need a module, and describes why a module is necessary when using lazy loading.
Adding Angular Material
00:52:14 - 01:03:50
Adding Angular Material
Lukas adds Angular material into the project, demonstrates how to import Angular material modules in a barrel role of modules, and uses a few material modules, which are material design components for angular on the generated application from a previous section.
Components
Component Fundamentals
01:03:51 - 01:16:36
Component Fundamentals
Lukas describes the anatomy of a component in Angular, demonstrates how to add a component to an application using the @Component decorator, and explains how to attach the decorator to the application using the component selector. In this section an application that allows users to list the courses taken on Frontend Masters and their progress is being built.
Component Routes
01:16:37 - 01:19:45
Component Routes
Lukas demonstrates how to add routes to an application that then loads the component in the component outlet.
Component Data
01:19:46 - 01:24:58
Component Data
Lukas explains the fundamentals of components and component data flow, and demonstrates how to render data on the application's main page.
Property Binding
01:24:59 - 01:34:24
Property Binding
Lukas explains that property binding is from class to template, demonstrates how to display data from the component into the markup using Angular templates, and uses a popular debugging technique that involves the JSON pipe filter.
Event Binding
01:34:25 - 01:39:29
Event Binding
Lukas demonstrates how to attach events to components, how to allow events to be triggered, and how to allow data to flow back into the component events.
ngFor
01:39:30 - 01:48:20
ngFor
Lukas shows how to loop through data using ngFor template syntax.
Selecting an Item & ngIf
01:48:21 - 01:54:35
Selecting an Item & ngIf
Lukas demonstrates how to render the selected data item, or lesson in the template, and how to only render the data if it is available using ngIf.
Local Templates & else
01:54:36 - 01:58:01
Local Templates & else
Lukas creates a local template and displays it inside an else reference using the elseBlock.
Sanitizing Input Data
01:58:02 - 02:03:18
Sanitizing Input Data
Lukas answers a question about how to sanitize user data in form inputs by demonstrating how to use DomSanitizer and the Sanitizer class.
Component Fundamentals Exercise
02:03:19 - 02:10:00
Component Fundamentals Exercise
Students are instructed to create a component, bind properties and events to the component, and display the selected data.
Component Fundamentals Solution
02:10:01 - 02:20:51
Component Fundamentals Solution
Lukas live codes the solution to the component fundamentals exercise.
Forms
Template Forms
02:20:52 - 02:36:50
Template Forms
Lukas demonstrates how to set up an Angular form, how to add fields and make some fields required, and how to render a form.
Submitting Forms & Valid States
02:36:51 - 02:42:13
Submitting Forms & Valid States
Lukas adds a submit button to the form, and demonstrates how to display a button that is active or disabled depending on the state associated with the button.
Form Template Exercise
02:42:14 - 02:43:33
Form Template Exercise
Students are instructed to add additional fields to the form started in the previous sections, and link them to the appropriate Angular component.
Form Template Solution
02:43:34 - 02:54:35
Form Template Solution
Lukas live codes the solution to the form template exercise.
Services & HTTP Client
Services
02:54:36 - 03:03:37
Services
Lukas explains the need for services to orchestrate data coming to and from the server, demonstrates how to uses services, and use services to render data on the UI.
Services CRUD Methods
03:03:38 - 03:16:09
Services CRUD Methods
Lukas creates the create, read, update, and delete methods in a service, and demonstrates how to use the methods in the application developed in the previous sections.
Services Exercise
03:16:10 - 03:20:07
Services Exercise
Students are instructed to build a new service that will allow users to create and add new lessons.
Services Solution: Building a Service
03:20:08 - 03:25:04
Services Solution: Building a Service
Lukas live codes the first part of the solution to the services exercise, and starts by creating a new service.
Services Solution: Remote Endpoint
03:25:05 - 03:43:02
Services Solution: Remote Endpoint
Lukas continues live coding the solution to the services exercise by fetching data from an API and explaining what optimistic and pessimistic loading of data is.
HTTP Client Exercise
03:43:03 - 03:45:51
HTTP Client Exercise
Students are instructed to complete the remote update call, the remote delete call, and to fix the UI when the operation is complete.
HTTP Client Solution
03:45:52 - 03:54:32
HTTP Client Solution
Lukas live codes the solution to the HTTP client exercise.
Component State
Component Driven Architecture
03:54:33 - 04:09:36
Component Driven Architecture
Lukas explains that Angular strongly encourages the component architecture by making it necessary to build every feature as a component, and adds that components allow developers to develop custom properties and custom events. Angular has a component hiearchy that leads to better structure and communication within the components of application.
Component API Input & Output
04:09:37 - 04:24:18
Component API Input & Output
Lukas refactors the application started in the previous section, creates children components, and adds input and output properties to a component.
Handling Shared Mutable State
04:24:19 - 04:31:12
Handling Shared Mutable State
Lukas explains that shared mutable state is the basis of some of the most common bugs in large applications, and demonstrates how to unshare a mutable state by creating a local copy of the data so that it doesn't allow other consumers to mutate that data.
Component Architecture Exercise
04:31:13 - 04:32:16
Component Architecture Exercise
Students are instructed to create a lessons component, the appropriate input and output properties, and to render the correct lessons list of the component.
Component Architecture Solution
04:32:17 - 04:39:25
Component Architecture Solution
Lukas live codes the solution to the component architecture exercise.
Routing
Router Links
04:39:26 - 04:44:16
Router Links
Lukas demonstrates how to create links to other routes in the application using the RouterLink directive.
Routing to Components
04:44:17 - 04:49:02
Routing to Components
Lukas explains how to route to a specific component and render that component in an outlet based on the route. An outlet activates an event when a new component is instantiated.
Creating a Lazy Loaded Route
04:49:03 - 04:59:25
Creating a Lazy Loaded Route
Lukas demonstrates how to set up a lazy loaded route so you can separate the applications module payloads and not have to load everything upfront for performance.
Router Service
04:59:26 - 05:02:28
Router Service
Lukas builds a router service and triggers routes from events and behaviors from within the application.
Create a Route Exercise
05:02:29 - 05:03:51
Create a Route Exercise
Students are instructed to generate a new users component, create a new users route, and to update sidenav to route to new users.
Create a Route Solution
05:03:52 - 05:07:09
Create a Route Solution
Lukas live codes the solution to the create a route exercise.
Testing
Unit Testing in Angular
05:07:10 - 05:22:59
Unit Testing in Angular
Lukas introduces unit testing in Angular, and demonstrates how to build unit tests.
Template Testing
05:23:00 - 05:31:39
Template Testing
Lukas demonstrates how to link unit tests to templates, and explains that change detection in a testing environment is not automated and needs to be added.
Resolving Dependencies & Mocking
05:31:40 - 05:40:16
Resolving Dependencies & Mocking
Lukas goes through the application's testing errors and resolves the errors using module dependencies and mocking services.
Spying & Component Testing
05:40:17 - 05:50:50
Spying & Component Testing
Lukas demonstrates how to set up spies on methods that run when events happen in an application, and explains how to test components.
Wrapping Up
Wrapping Up
05:50:51 - 06:00:45
Wrapping Up
Lukas thanks the audience, wraps up the course, and answers questions about unit testing, end to end testing, lazy loading and framework parity.

General
Complete name : 2. Component API Input & Output.mp4
Format : WebM
Format version : Version 2
File size : 71.5 MiB
Duration : 14 min 41 s
Overall bit rate mode : Variable
Overall bit rate : 680 kb/s
Writing application : Lavf57.71.100
Writing library : Lavf57.71.100
FileExtension_Invalid : webm

Video
ID : 2
Format : VP8
Codec ID : V_VP8
Duration : 14 min 41 s
Bit rate : 452 kb/s
Width : 1 920 pixels
Height : 1 080 pixels
Display aspect ratio : 16:9
Frame rate mode : Constant
Frame rate : 29.970 (30000/1001) FPS
Compression mode : Lossy
Bits/(Pixel*Frame) : 0.007
Stream size : 47.5 MiB (67%)
Language : English
Default : Yes
Forced : No

Audio
ID : 1
Format : Vorbis
Format settings, Floor : 1
Codec ID : A_VORBIS
Duration : 14 min 41 s
Bit rate mode : Variable
Bit rate : 192 kb/s
Channel(s) : 2 channels
Sampling rate : 48.0 kHz
Compression mode : Lossy
Delay relative to video : -3 ms
Stream size : 20.2 MiB (28%)
Writing application : Lavc57.89.100
Language : English
Default : Yes
Forced : No

Citación :

rapidgator_net:
https://rapidgator.net/file/c88703a0f7ad766dd2fb6831e8dbcb1d/zocay.Frontendmasters..Angular.9.Fundamentals.2020.rar.html

nitroflare_com:
https://nitroflare.com/view/F135C50CDC1FB3B/zocay.Frontendmasters..Angular.9.Fundamentals.2020.rar

uploadgig_com:
http://uploadgig.com/file/download/0eCa4fc04038deb4/zocay.Frontendmasters..Angular.9.Fundamentals.2020.rar