JavaScript Frameworks React JS and Angular (2+)

Audience

• Web Developers

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

14. 2. Sending data asynchronously with POST
    3. Invoking different HTTP methods
    4. Gracefully handling errors
15. Extending Angular Capabilities
    1. Adding functionality to the DOM
    2. Creating a custom styling directive
    3. Performing animation

       ReactJSOutline

       1. React Introduction
          1. React Version
          2. React Installation
          3. create-react-app
          4. React Features
          5. Pros & Cons
          6. Conditional Rendering
          7. React Lists
          8. React Keys
          9. React Refs
          10. React Fragments
          11. React Router
          12. React CSS
          13. React Animation
          14. React Bootstrap
          15. React Map
          16. React Table
          17. Higher-Order Components
       1. 18. React Code Splitting
          19. React Context
          20. React Hooks
          21. React Flux Concept
          22. React Flux Vs MVC
          23. React Redux
          24. React Redux Example
          25. React Portals
          26. React Error Boundaries

       Angular Outline

       1. Architectural overview
          1. Simplifying development of complex modern applications
          2. The organization of an Angular app
          3. Supporting multiple client devices
          4. Configuring an Angular development environment
          5. Bootstrapping your first Angular application
       2. Getting started with TypeScript
          1. Transpiling TypeScript to JavaScript
          2. Building an app with TypeScript
          3. Constructing User Interface (UI) Components
       3. Defining components
          1. Structure of a component
          2. Introducing the component hierarchy
          3. Declaring metadata with the @Component decorator
          4. Controlling HTML5 generation with Templates
          5. Displaying repeating data with *ngFor
          6. Conditional generation of DOM content
       4. Debugging techniques and strategies
          1. Interpreting framework error messages
          2. Exploring the component hierarchy with Augury
       5. Reducing code complexity with Dependency Injection (DI)
          1. Principles of DI
          2. Creating loosely coupled applications
          3. Configuring providers and declaring Injectables
          4. Satisfying dependencies with Provider metadata
          5. Testing Angular Components & Functionality
       6. Structuring test strategies
          1. Unit testing vs. integration testing
          2. Working with mock Angular components
          3. Asynchronous testing with ES6 arrow functions
          4. Adding Interactivity to Your Applications
       7. Coordinating Component interaction
          1. Passing data from parent to child with Input bindings
          2. Listening for property changes with ngOnChanges
          3. Binding a model to display with interpolation
       8. Managing events
          1. Detecting and responding to user interaction
          2. Capturing browser events
          3. Emitting custom events to trigger behavior
          4. Navigation and Data Transformation
       9. Creating modular applications
          1. Controlling application flow with the Component Router
          2. Dividing application functionality across multiple Component trees
          3. Parameterizing routes for dynamic navigation
       10. Manipulating data with Pipes
           1. Formatting dates for display
           2. Chaining pipes to combine functionality
           3. Filtering data with custom Pipes
           4. Building Interactive Forms
       11. Displaying and capturing data
           1. Developing forms with ngFormModel and FormBuilder
           2. Creating a form from a business object
           3. Two-way binding between input controls and data model
       12. Validating form input
           1. Leveraging HTML5 and custom validation
           2. Providing user feedback from validators
           3. Managing Asynchronous Behavior
       13. Keeping the App responsive
           1. Subscribing to Observables
           2. Converting stream data types with the Observable map function
           3. Optimizing change detection with immutability and onPush
       14. Interacting with a REST Web service
           1. Retrieving data with the HTTP object
    4. 2. Sending data asynchronously with POST
       3. Invoking different HTTP methods
       4. Gracefully handling errors
    5. Extending Angular Capabilities
       1. Adding functionality to the DOM
       2. Creating a custom styling directive
       3. Performing animation

Troubleshooting

Summary and Next Steps