舉報 
會員
Switching to Angular（Third Edition）
最新章節：
Summary
ThisbookisforsoftwaredeveloperswhowanttoalignwithamodernversionofAngularthat’salignedwithGoogle’svisionofAngularversion5andbeyond,usingstableAPIsthattheycandependontodayandinthefuture.AlsoforanyoneassessingchangestoAngularandsquaringupforastrategicmigrationtoAngularv5,andforAngularJSdeveloperswhowanttotransfertheirmindsettomodernAngularversion5andbeyond.
最新章節
- Summary
- How to use the ahead-of-time compilation of Angular
- Constraints of the ahead-of-time compilation
- Introducing the concept of ahead-of-time compilation
- How code generation works
- Ahead-of-time compilation in Angular
品牌：中圖公司
上架時間：2021-07-02 12:42:48
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Summary 更新時間：2021-07-02 15:24:04
- How to use the ahead-of-time compilation of Angular
- Constraints of the ahead-of-time compilation
- Introducing the concept of ahead-of-time compilation
- How code generation works
- Ahead-of-time compilation in Angular
- Angular webpack starter
- Angular seed
- Angular quick starters
- Using angular-cli
- Bootstrapping a project with angular-cli
- Angular language service
- Text editors and IDEs
- Enhancing our development experience
- Server-side rendering with Angular
- Initial load of a single-page application with server-side rendering
- Initial load of a single-page application
- Making an application compatible with web workers
- Migrating an application to web workers
- Bootstrapping an application running in a web worker
- Web workers and Angular
- Running an application in a web worker
- Tooling and Development Experience
- Summary
- Using AsyncPipe with observables
- Using Angular's AsyncPipe
- Using stateful pipes
- Developing stateful pipes
- Using Angular's built-in pipes
- Developing stateless pipes
- Transforming data with pipes
- Defining nested routes
- Defining parameterized views
- Using Angular's HTTP module
- Exploring the HTTP module of Angular
- Using composition of control validators
- Developing model-driven forms in Angular
- Explaining Pipes and Communicating with RESTful Services
- Summary
- Listing all the stored data
- Storing the form data
- Two-way data binding with Angular
- Using the NgForm directive
- Using select inputs with Angular
- Defining custom validators
- Using the built-in validators
- Digging into the markup of the template-driven form
- Developing template-driven forms
- Using Angular's forms module
- RouterModule.forRoot versus RouterModule.forChild
- Prefetching of the lazy-loaded routes
- Lazy-loading with loadChildren
- Using routerLink and router-outlet
- Configuring routes
- Using PathLocationStrategy
- Exploring the Angular router
- Developing the "Coders repository" application
- Working with the Angular Router and Forms
- Summary
- Using the @SkipSelf decorator
- View providers versus providers
- Exploring dependency injection with components
- Declaring providers for the element injectors
- Introducing the element injectors
- Using dependency injection with components and directives
- Building a hierarchy of injectors
- Instantiating an injector
- Child injectors and visibility
- Understanding multiproviders
- Declaring optional dependencies
- Defining factories for instantiating services
- Using existing providers
- Configuring providers
- Introducing forward references
- Using the @Injectable decorator
- Declaring providers
- Benefits of using dependency injection
- Dependency injection in Angular
- Why do I need dependency injection?
- Dependency Injection in Angular
- Summary
- Using immutable data in Angular
- Introducing immutable data structures and OnPush
- Understanding Angular's change detection strategies
- The order of execution of the change detectors
- Understanding and enhancing the change detection
- Defining generic views with TemplateRef
- Order of execution of the life cycle hooks
- Hooking into the component's life cycle
- View child versus content child
- Using view children and content children
- Nesting components
- Projecting multiple content chunks
- Basic content projection in Angular
- Explaining Angular's content projection
- An alternative syntax to define inputs and outputs
- Renaming the inputs and outputs
- Event bubbling
- Passing inputs and consuming the outputs
- Defining the inputs and outputs
- Determining the inputs and outputs
- Using inputs and outputs
- Handling user actions
- Implementing the component's controllers
- Introducing the component's view encapsulation
- Creating custom Angular components
- Using the custom element schema
- Using NgModules for declaring reusable components
- Better encapsulation of directives with NgModules
- Understanding the directive's constructor
- Setting the directive's inputs
- Defining Angular directives
- Using syntax sugar in templates
- Declaring variables inside a template
- Improved semantics of the directives syntax
- The ngFor directive
- Using Angular directives
- Using Angular and TypeScript
- Installing the sample project repository
- Setting up our environment
- The "Hello world!" application in Angular
- Getting Started with Angular Components and Directives
- Summary
- Custom ambient type definitions
- Using predefined ambient type definitions
- Using ambient type definitions
- Introducing structural typing
- Contextual type inference
- Best common type
- Writing less verbose code with the type inference of TypeScript
- Having multiple type parameters
- Using generic functions
- Writing generic code using type parameters
- Further expressiveness with TypeScript decorators
- Implementing multiple interfaces
- Interface inheritance
- Defining interfaces
- Using access modifiers
- Defining classes
- The Function types
- The array types
- Understanding the object types
- The Enum types
- Understanding the primitive types
- The any type
- Using explicit type declarations
- Taking advantage of static typing
- ES2015 and ES2016 recap
- ES2015 module loader
- Default exports
- Importing all the module exports
- Using aliases
- Taking advantage of the implicit asynchronous behavior of the module
- Using the ES2015 module syntax
- Writing modular code with ES2015
- Using configurable decorators
- Meta-programming with ES2016 decorators
- Defining variables with block scope
- Using the ES2015 and ES2016 classes
- ES2015 arrow functions
- TypeScript syntaxes and features introduced by ES2015 and ES2016
- Running our first TypeScript program
- Installing TypeScript with npm
- Using TypeScript
- There's even more to TypeScript
- Better support by text editors and IDEs
- Compile-time type checking
- Introduction to TypeScript
- TypeScript Crash Course
- Summary
- Angular route definition syntax
- The new router
- Services
- Enhancing AngularJS's change detection
- Simplified data flow
- In zone.js
- Change detection in AngularJS
- Classical change detection
- Improving change detection
- Defining pipes
- Pipes
- Bootstrapping an Angular application
- Angular modules
- Components in Angular
- Components in action
- Getting to know Angular components
- Changing directives
- A conceptual overview of Angular
- The Building Blocks of an Angular Application
- Summary
- Change detection
- Templates
- Applications that scale
- Server-side rendering
- Dependency injection
- Scope
- Controllers
- Lessons learned from AngularJS in the wild
- Web workers
- Web components
- The evolution of ECMAScript
- The evolution of the web – time for a new framework
- Get Going with Angular
- Summary
- Angular and SemVer
- The new beginning
- From AngularJS to Angular
- Introducing the One Angular
- Switching to the One Angular
- Questions
- Piracy
- Errata
- Downloading the color images of this book
- Downloading the example code
- Customer support
- Reader feedback
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Author
- Foreword
- Credits
- Third Edition
- Switching to Angular
- Copyright
- Third Edition
- Title Page
- coverpage
- coverpage
- Title Page
- Third Edition
- Copyright
- Switching to Angular
- Third Edition
- Credits
- Foreword
- About the Author
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Reader feedback
- Customer support
- Downloading the example code
- Downloading the color images of this book
- Errata
- Piracy
- Questions
- Switching to the One Angular
- Introducing the One Angular
- From AngularJS to Angular
- The new beginning
- Angular and SemVer
- Summary
- Get Going with Angular
- The evolution of the web – time for a new framework
- The evolution of ECMAScript
- Web components
- Web workers
- Lessons learned from AngularJS in the wild
- Controllers
- Scope
- Dependency injection
- Server-side rendering
- Applications that scale
- Templates
- Change detection
- Summary
- The Building Blocks of an Angular Application
- A conceptual overview of Angular
- Changing directives
- Getting to know Angular components
- Components in action
- Components in Angular
- Angular modules
- Bootstrapping an Angular application
- Pipes
- Defining pipes
- Improving change detection
- Classical change detection
- Change detection in AngularJS
- In zone.js
- Simplified data flow
- Enhancing AngularJS's change detection
- Services
- The new router
- Angular route definition syntax
- Summary
- TypeScript Crash Course
- Introduction to TypeScript
- Compile-time type checking
- Better support by text editors and IDEs
- There's even more to TypeScript
- Using TypeScript
- Installing TypeScript with npm
- Running our first TypeScript program
- TypeScript syntaxes and features introduced by ES2015 and ES2016
- ES2015 arrow functions
- Using the ES2015 and ES2016 classes
- Defining variables with block scope
- Meta-programming with ES2016 decorators
- Using configurable decorators
- Writing modular code with ES2015
- Using the ES2015 module syntax
- Taking advantage of the implicit asynchronous behavior of the module
- Using aliases
- Importing all the module exports
- Default exports
- ES2015 module loader
- ES2015 and ES2016 recap
- Taking advantage of static typing
- Using explicit type declarations
- The any type
- Understanding the primitive types
- The Enum types
- Understanding the object types
- The array types
- The Function types
- Defining classes
- Using access modifiers
- Defining interfaces
- Interface inheritance
- Implementing multiple interfaces
- Further expressiveness with TypeScript decorators
- Writing generic code using type parameters
- Using generic functions
- Having multiple type parameters
- Writing less verbose code with the type inference of TypeScript
- Best common type
- Contextual type inference
- Introducing structural typing
- Using ambient type definitions
- Using predefined ambient type definitions
- Custom ambient type definitions
- Summary
- Getting Started with Angular Components and Directives
- The "Hello world!" application in Angular
- Setting up our environment
- Installing the sample project repository
- Using Angular and TypeScript
- Using Angular directives
- The ngFor directive
- Improved semantics of the directives syntax
- Declaring variables inside a template
- Using syntax sugar in templates
- Defining Angular directives
- Setting the directive's inputs
- Understanding the directive's constructor
- Better encapsulation of directives with NgModules
- Using NgModules for declaring reusable components
- Using the custom element schema
- Creating custom Angular components
- Introducing the component's view encapsulation
- Implementing the component's controllers
- Handling user actions
- Using inputs and outputs
- Determining the inputs and outputs
- Defining the inputs and outputs
- Passing inputs and consuming the outputs
- Event bubbling
- Renaming the inputs and outputs
- An alternative syntax to define inputs and outputs
- Explaining Angular's content projection
- Basic content projection in Angular
- Projecting multiple content chunks
- Nesting components
- Using view children and content children
- View child versus content child
- Hooking into the component's life cycle
- Order of execution of the life cycle hooks
- Defining generic views with TemplateRef
- Understanding and enhancing the change detection
- The order of execution of the change detectors
- Understanding Angular's change detection strategies
- Introducing immutable data structures and OnPush
- Using immutable data in Angular
- Summary
- Dependency Injection in Angular
- Why do I need dependency injection?
- Dependency injection in Angular
- Benefits of using dependency injection
- Declaring providers
- Using the @Injectable decorator
- Introducing forward references
- Configuring providers
- Using existing providers
- Defining factories for instantiating services
- Declaring optional dependencies
- Understanding multiproviders
- Child injectors and visibility
- Instantiating an injector
- Building a hierarchy of injectors
- Using dependency injection with components and directives
- Introducing the element injectors
- Declaring providers for the element injectors
- Exploring dependency injection with components
- View providers versus providers
- Using the @SkipSelf decorator
- Summary
- Working with the Angular Router and Forms
- Developing the "Coders repository" application
- Exploring the Angular router
- Using PathLocationStrategy
- Configuring routes
- Using routerLink and router-outlet
- Lazy-loading with loadChildren
- Prefetching of the lazy-loaded routes
- RouterModule.forRoot versus RouterModule.forChild
- Using Angular's forms module
- Developing template-driven forms
- Digging into the markup of the template-driven form
- Using the built-in validators
- Defining custom validators
- Using select inputs with Angular
- Using the NgForm directive
- Two-way data binding with Angular
- Storing the form data
- Listing all the stored data
- Summary
- Explaining Pipes and Communicating with RESTful Services
- Developing model-driven forms in Angular
- Using composition of control validators
- Exploring the HTTP module of Angular
- Using Angular's HTTP module
- Defining parameterized views
- Defining nested routes
- Transforming data with pipes
- Developing stateless pipes
- Using Angular's built-in pipes
- Developing stateful pipes
- Using stateful pipes
- Using Angular's AsyncPipe
- Using AsyncPipe with observables
- Summary
- Tooling and Development Experience
- Running an application in a web worker
- Web workers and Angular
- Bootstrapping an application running in a web worker
- Migrating an application to web workers
- Making an application compatible with web workers
- Initial load of a single-page application
- Initial load of a single-page application with server-side rendering
- Server-side rendering with Angular
- Enhancing our development experience
- Text editors and IDEs
- Angular language service
- Bootstrapping a project with angular-cli
- Using angular-cli
- Angular quick starters
- Angular seed
- Angular webpack starter
- Ahead-of-time compilation in Angular
- How code generation works
- Introducing the concept of ahead-of-time compilation
- Constraints of the ahead-of-time compilation
- How to use the ahead-of-time compilation of Angular
- Summary 更新時間：2021-07-02 15:24:04
