Complete Intro to React, v5 [2019, ENG] torrent

Обучающие видео » Компьютерные видеоуроки и обучающие интерактивные DVD » Программирование (видеоуроки)

Complete Intro to React, v5

Год выпуска: 2019
Производитель: frontendmasters.com
Сайт производителя: https://frontendmasters.com/courses/complete-react-v5/
Автор: Brian Holt
Продолжительность: 5 hours, 35 min
Тип раздаваемого материала: Видеоклипы
Язык: Английский
Описание: Learn to build real-world applications using modern React! Much more than an intro, you’ll start from the ground up, getting all the way to using the latest features in React, including hooks, effects, context, and portals. Throughout the course, you’ll piece together tools from the entire React ecosystem (like Reach Router) to build a full application to browse adoptable pets.

Published: June 4, 2019

Code Repository- https://github.com/btholt/complete-intro-to-react-v5
Course Website - https://btholt.github.io/complete-intro-to-react-v5/
Special note Access to courses was provided by one of the rutracker users who wants to stay anonymous let's say all thanks to him, and i just downloaded it
[spoiler="Содержание"]
Table of Contents
Introduction
Introduction
00:00:00 - 00:08:22
Introduction
Brian Holt introduces the course, discusses how the previous versions of the course differ from the current version, the structure of the course, and how to to switch between commits. - https://bit.ly/react-v5 - https://github.com/btholt/complete-intro-to-react-v5
Project Setup
00:08:23 - 00:19:21
Project Setup
Brian sets up the folder, the HTML document, and imports the CSS to begin building the course application.
A Note on the Course Font
00:19:22 - 00:22:17
A Note on the Course Font
Brian briefly explains the font that's used during the course, and demonstrates how to enable font ligatures in VS Code settings.
Pure React
Getting Started with Pure React
00:22:18 - 00:26:45
Getting Started with Pure React
Brian begins by writing a React App component that "stamps" the app on the page.
createElement Arguments
00:26:46 - 00:31:22
createElement Arguments
Brian answers a question regarding what happens to content within an element that React is creating elements within, then goes on to explain the nested createElement call, and the arguments passed into the returned function.
Reusable Components
00:31:23 - 00:36:52
Reusable Components
Brian extracts the JavaScript into its own file, then creates a second component that is reusable within the parent component.
Passing in Component Props
00:36:53 - 00:39:49
Passing in Component Props
Brian demonstrates how to create and pass in attributes to components.
Destructuring Props
00:39:50 - 00:41:47
Destructuring Props
Brian demonstrates how to utilize a Vanilla JavaScript principle to simplify attribute names being passed into components.
Tools
npm & Generating a package.json File
00:41:48 - 00:45:37
npm & Generating a package.json File
Brian explains what npm is, and generates a package.json file for the application. - https://nodejs.org/en/
Prettier
00:45:38 - 00:48:08
Prettier
Brian introduces Prettier, a tool that allows a team to maintain consistency, and eliminate syntax arguments across a codebase.
npm Scripts
00:48:09 - 00:51:18
npm Scripts
Brian demonstrates how to create an npm script in the package.json file that allows anyone to run Prettier from the command line with many less keystrokes.
Prettier Setup
00:51:19 - 00:55:57
Prettier Setup
Brian demonstrates how to install the Prettier extension in VS Code, create the prettier configuration file, and set it to auto-format on save only when the configuration file exists.
ESLint Setup
00:55:58 - 01:00:12
ESLint Setup
Brian introduces ESLint to find syntax or style errors before execution, creates the eslintrc configuration file, and installs the eslint-config-prettier to ensure that linter isn't overlapping with the tasks that Prettier is performing. What the package-lock.json file does, and how to install only the versions of packages in that file are also briefly discussed.
ESLint Configuration
01:00:13 - 01:08:22
ESLint Configuration
Brian sets up ESLint configuration file, eslintrc.json, with the application's settings. A script is set up within the package.json file to run the linter.
gitignore
01:08:23 - 01:10:24
gitignore
Brian demonstrates how to specify which files not to track when commiting to a repo.
Parcel
01:10:25 - 01:15:32
Parcel
Brian configures Parcel, a bundler that automatically includes React and ReactDOM from the registry.
Installing React & ReactDom
01:15:33 - 01:21:46
Installing React & ReactDom
Brian imports React, and ReactDom in the application, and explains how to import only a single module from a package. A question is also answered regarding how determine whether to import modules or a whole package, and Parcel's tree shaking functionality is explained.
Separate App into Modules
01:21:47 - 01:26:15
Separate App into Modules
Brian moves the components into different files to make the code more maintainable. Alternatives to Parcel are also given, as well as instructions on how to move forward with the commits. - https://github.com/btholt/complete-intro-to-react-v5/commit/6963d65a8808e3d342fb005e42ab2317193c7065
JSX
Converting to JSX
01:26:16 - 01:33:48
Converting to JSX
Brian introduces JSX by writing what appears to be HTML in a JavaScript file, and explains how React transpiles the code.
Configuring ESLint for React
01:33:49 - 01:41:41
Configuring ESLint for React
Brian configures ESLint to identify the plugins used, sets rules, and sets the linter to automatically identify what version of React is being used.
JSX Composite Components & Expressions
01:41:42 - 01:49:20
JSX Composite Components & Expressions
Brian demonstrates how to insert named components and props into the JSX, then explains how brackets can be used to insert expressions.
Hooks
Creating a Search Component
01:49:21 - 01:56:45
Creating a Search Component
Brian begins constructing a component to allow a user to search by a specific location.
Setting State with Hooks
01:56:46 - 02:06:49
Setting State with Hooks
Brian explains why two-way data binding isn't free in React, and why this makes the code more maintainable. The useState hook is utilized to update the state, and the onChange event handler is tasked with displaying it in the component.
Best Practices for Hooks
02:06:50 - 02:09:08
Best Practices for Hooks
Brian explains why hooks cannot be utilized within control flow statements.
Configuring ESLint for Hooks
02:09:09 - 02:12:16
Configuring ESLint for Hooks
Brian installs the ESLint plugin for React hooks, and configures ESLint to check and warn for conditionally called hooks.
Calling the Pet API
02:12:17 - 02:19:24
Calling the Pet API
Brian imports the Pet client module from npm with Parcel. A dropdown with animals from the Pet client data is populated within the search form.
Unique List Item Keys
02:19:25 - 02:21:51
Unique List Item Keys
Brian explains why a unique key must be provided when rendering lists of elements in JSX, and why providing it increases performance.
Breed Dropdown
02:21:52 - 02:26:41
Breed Dropdown
Brian populates a dropdown with breeds from the Pet client data, mirroring the way that the animal dropdown was created.
Custom Hooks
02:26:42 - 02:36:24
Custom Hooks
Brian creates a custom hook that performs the task of being a reusable dropdown component, and replaces redundant code from the animal and breed dropdowns.
Effects
Effects
02:36:25 - 02:45:23
Effects
Brian utilizes the useEffect built-in hook to asynchronously request data from the Petfinder API. This effect takes the place of several lifecycle hooks, including componentDidMount, componentWillUnmount, and componentDidUpdate.
Declaring Effect Dependencies
02:45:24 - 02:48:44
Declaring Effect Dependencies
Brian declares the dependencies that useEffect relies on in order to specify which parameters that React should be checking for changes on during a re-render. It's demonstrated that this prevents the code from running the effect unnecessarily.
Effect Lifecycle Walkthrough
02:48:45 - 02:54:11
Effect Lifecycle Walkthrough
Brian walks through the effects and hooks lifecycle to demonstrate how state propagates through the component.
Run Only Once
02:54:12 - 02:56:38
Run Only Once
Brian demonstrates how to ensure an effect only runs once by passing in an empty array as the hook dependency.
Hooks Review and Q&A
02:56:39 - 03:00:37
Hooks Review and Q&A
Brian clarifies why a variable isn't a dependency of the effect hook, and answers a question about why hooks were created to replace other lifestyle components. A clarification is made about how the propagation of state is given for free in hooks. Which hooks to focus on is also discussed.
Dev Tools
Environment Variables & Strict Mode
03:00:38 - 03:03:32
Environment Variables & Strict Mode
Brian explains how Parcel compiles the development server using the NODE_ENV environment variable, then automatically flips the switch when the application is built for production, erasing unnecessary debugging tools for a more performant application. React strict mode is also introduced as a tool that throws errors when using React features that are soon to be deprecated.
React Browser Dev Tools
03:03:33 - 03:08:46
React Browser Dev Tools
Brian introduces the React browser dev tools, available in Firefox and Chrome, that allow developers to inspect and select components within the browser for another approach to debugging and development.
Async & Routing
Asynchronous API Requests
03:08:47 - 03:15:13
Asynchronous API Requests
Brian introduces async functionality to make a request to the API, and configures the package.json to target modern browsers.
Using the Fallback Mock API
03:15:14 - 03:18:20
Using the Fallback Mock API
Brian demonstrates an optional feature that allows students to complete course offline by running the mock API in the place of the API that will be run for the rest of the course.
One-Way Data Flow
03:18:21 - 03:25:27
One-Way Data Flow
Brian renders the list of pets returning from the Pet client by passing from data parent to child, and demonstrates a key pattern of React called one-way data flow, also known as "one-way binding".
Reformatting the Pet Component
03:25:28 - 03:29:05
Reformatting the Pet Component
Brian adds a hero image and renders a more complete version of the component that shows for each pet in the search results.
Reach Router
03:29:06 - 03:37:27
Reach Router
Brian introduces several options for routers, but explains that Reach Router will be used for the course because of emphasis on accessibility, and also its intuitive path scoring algorithm.
Debugging & Reach Router Link
03:37:28 - 03:43:17
Debugging & Reach Router Link
Brian demonstrates a debugging technique that dumps data out to the DOM to see what’s coming in on the props in a component, then uses a link tag to connect the branding to the home page that React Router handles for the user.
Class Components
Class Components
03:43:18 - 03:54:40
Class Components
Brian introduces ES6 classes in React by discussing the constructor function, and the super keyword. An explanation is given on setting how a component maintains state, and how to update state with setState in a class component via a shallow merge. How context influenced the decision for the React development team to utilize arrow functions in class components is also discussed.
Rendering the Component
03:54:41 - 03:58:47
Rendering the Component
Brian completes the render method to include a loading display and the final JSX to be outputted to the DOM after the API response.
Configuring Babel for Parcel
03:58:48 - 04:08:46
Configuring Babel for Parcel
Brian demonstrates how to use Babel and Parcel together by creating a Babel configuration file and changing the default parser of the existing ESLint configuration file. The application is configured to accept proposed JavaScript implementations as well as the landed standards.
Creating an Image Carousel
04:08:47 - 04:17:41
Creating an Image Carousel
Brian creates the image carousel class component.
Context
04:17:42 - 04:22:53
Context
Brian implements the click handler to switch images in the gallery, and explains how context is passed down through event listeners and functions that are being passed into children.
Index Click Q&A
04:22:54 - 04:25:36
Index Click Q&A
Brian answers an audience question about the functionality of the incrementing function in the carousel component. Further explanation is given as to why this is a more performant option than using a bind function to do the same task. The carousel is then implemented into the details module.
Carousel Implementation
04:25:37 - 04:27:29
Carousel Implementation
Brian ties the pieces of the application together to display the image carousel in the app.
Error Boundaries
Error Boundaries
04:27:30 - 04:34:16
Error Boundaries
Brian introduces error boundaries that allow for graceful capture of errors without an application blowing up. To implement the error boundaries, getDreivedStateFromError, and componentDidCatch React methods are introduced.
Error Boundary Middleware
04:34:17 - 04:39:46
Error Boundary Middleware
Brian demonstrates how to wrap the application in the error boundary and wire it up to a component.
404 Page Redirect
04:39:47 - 04:44:15
404 Page Redirect
Brian uses a 404 page redirect as a way to demonstrate the componentDidUpdate React lifecycle method's capabilities.
Lifecycle Methods & Error Boundary Q&A
04:44:16 - 04:47:46
Lifecycle Methods & Error Boundary Q&A
Students ask for clarification on the componentDidUpdate, and getDerivedStateFromError lifecycle methods, how React uses unhandled errors, as well as whether it's possible to use error boundaries with hooks.
Context
React Context
04:47:47 - 04:54:23
React Context
Brian demonstrates how to provide global application state by using a Context hook. Further applications for React Context are also briefly discussed.
Context with Hooks
04:54:24 - 04:59:33
Context with Hooks
Brian demonstrates how to provide a global CSS style to a button using the useContext hook.
Context with Classes
04:59:34 - 05:05:16
Context with Classes
Brian demonstrates how to provide a global CSS style to a button in a class component.
Persisting State with Context Hooks
05:05:17 - 05:14:34
Persisting State with Context Hooks
Brian demonstrates how utilizing a globally accessible variable within Context hooks allows a user to navigate away from the original page, and allow settings changed by the user to persist. The application is refactored to use Link tags instead of a tags to allow html history to navigate the pages. A question is asked about how to ignore a variable that's being returned from a hook.
Portals
Modal Dialog with Portals
05:14:35 - 05:24:00
Modal Dialog with Portals
Brian introduces Portals as a method to render components outside the current component while keeping its events and state inside its current component.
Displaying the Modal
05:24:01 - 05:32:38
Displaying the Modal
Brian wires the portal display state to the component. Utilizing Portals turns what was once an extremely complicated implementation to a much simpler feature.
Wrapping Up
Wrapping Up
05:32:39 - 05:36:05
Wrapping Up
Brian reviews further resources for learning, discusses the Preact framework, and speaks to what the future will look like for React.
FrontendMasters

Courses Learn Workshops Teachers Books
[/spoiler]
Файлы примеров: присутствуют
Формат видео: MP4
Видео: 1920x1080, 16:9, 23.98 fps, avg 1200 kb/s
Аудио: AAC, 48kHz, 127, stereo
[spoiler="Скриншоты"]

[/spoiler]