React 16 – The Complete Guide (incl. React Router 4 & Redux)

React 16 – The Complete Guide (incl. React Router 4 & Redux)
React 16 – The Complete Guide (incl. React Router 4 & Redux)

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 33.5 Hours | 5.28 GB
eLearning | Skill level: All Levels

Dive in and learn React from scratch! Learn Reactjs, Redux, React Routing, Animations, Next.js basics and way more!

Learn React or dive deeper into it. Learn the theory, solve assignments, practice in demo projects and build one big application which is improved throughout the course: The Burger Builder!

More details please!

JavaScript is the major driver of modern web applications since it’s the only programming language which runs in the browser and hence allows you to provide highly reactive apps. You’ll be able to achieve mobile-app like user experiences in the web.

But using JavaScript can be challenging – it quickly becomes overwhelming to create a nice web app with vanilla JavaScript and jQuery only.

React to the rescue!

React is all about components – basically custom HTML elements – with which you can quickly build amazing and powerful web apps. Just build a component once, configure it to your needs, dynamically pass data into it (or listen to your own events!) and re-use it as often as needed.

Need to display a list of users in your app? It’s as simple as creating a “User” component and outputting it as often as needed.

This course will start at the very basics and explain what exactly React is and how you may use it (and for which kind of apps). Thereafter, we’ll go all the way from basic to advanced. We’ll not just scratch the surface but dive deeply into React as well as popular libraries like react-router and Redux.

By the end of the course, you can build amazing React (single page) applications!

A detailed list with the course content can be found below.

What’s inside the course?

  • The “What”, “Why” and “How”
  • React Basics (Base features, syntax and concepts)
  • How to output lists and conditional content
  • Styling of React components
  • A deep dive into the internals of React and advanced component features
  • How to access Http content from within React apps (AJAX)
  • Redux, Redux, Redux … from basics to advanced!
  • Forms and form validation in React apps
  • Authentication
  • An introduction to unit testing
  • An introduction to Next.js
  • React app deployment instructions
  • …and much more!
+ Table of Contents

Getting Started
1 Introduction
2 What is React
3 Real-World SPAs React Web Apps
4 Adding the Right React Version to Codepen
5 Writing our First React Code
6 Why Should we Choose React
7 React Alternatives
8 Understanding Single Page Applications and Multi Page Applications
9 Course Outline
10 How to get the Most out of This Course
11 Useful Resources Links

Refreshing Next Generation JavaScript (Optional)
12 Module Introduction
13 Understanding let and const
14 Arrow Functions
15 Exports and Imports
16 Understanding Classes
17 Classes Properties and Methods
18 The Spread Rest Operator
19 Destructuring
20 Reference and Primitive Types Refresher
21 Refreshing Array Functions
22 Wrap Up
23 Next-Gen JavaScript – Summary
24 JS Array Functions

Understanding the Base Features Syntax
25 Module Introduction
26 The Build Workflow
27 Using Create React App
28 Understanding the Folder Structure
29 Understanding Component Basics
30 Understanding JSX
31 JSX Restrictions
32 Creating a Functional Component
33 Components JSX Cheat Sheet
34 Working with Components Re-Using Them
35 Outputting Dynamic Content
36 Working with Props
37 Understanding the Children Property
38 Understanding Using State
39 Props State
40 Handling Events with Methods
41 To Which Events Can You Listen
42 Manipulating the State
43 Functional (Stateless) vs class (Stateful) Components
44 Passing Method References Between Components
45 Adding Two Way Binding
46 Adding Styling with Stylesheets
47 Working with Inline Styles
48 Useful Resources Links

Working with Lists and Conditionals
49 Module Introduction
50 Rendering Content Conditionally
51 Handling Dynamic Content The JavaScript Way
52 Outputting Lists (Intro)
53 Outputting Lists
54 Lists State
55 Updating State Immutably
56 Lists Keys
57 Flexible Lists
58 Wrap Up
59 Useful Resources Links

Styling React Components Elements
60 Module Introduction
61 Outlining the Problem Set
62 Setting Styles Dynamically
63 Setting Class Names Dynamically
64 Adding and Using Radium
65 Using Radium for Media Queries
66 Enabling Using CSS Modules
67 More on CSS Modules
68 Adding Pseudo Selectors
69 Working with Media Queries
70 Useful Resources Links

Debugging React Apps
71 Module Introduction
72 Understanding Error Messages
73 Finding Logical Errors by using Dev Tools Sourcemaps
74 Working with the React Developer Tools
75 Using Error Boundaries (React 16)
76 Wrap Up
77 Useful Resources Links

Diving Deeper into Components React Internals
78 Module Introduction
79 A Better Project Structure
80 Splitting an App Into Components
81 Comparing Stateless and Stateful Components
82 Understanding the Component Lifecycle
83 Converting Stateless to Stateful Components
84 Component Creation Lifecycle in Action
85 componentWillUnmount()
86 Component Updating Lifecycle Hooks
87 Component Updating Lifecycle in Action
88 Updating Lifecycle Hooks (Triggered by State Changes)
89 Performance Gains with PureComponents
90 How React Updates the App Component Tree
91 Understanding Reacts DOM Updating Strategy
92 Returning Adjacent Elements (React 16)
93 React 16.2 Feature Fragments
94 Understanding Higher Order Components (HOCs)
95 Windows Users Must Read – File Downloads
96 A Different Approach to HOCs
97 Passing Unknown Props
98 Using setState Correctly
99 Validating Props
100 Available PropTypes
101 Using References (ref)
102 More on the Ref API (React 16.3)
103 The Context API (React 16.3)
104 Updated Lifecycle Hooks (React 16.3)
105 Wrap Up
106 Useful Resources Links

A Real App The Burger Builder (Basic Version)
107 Module Introduction
108 Planning an App in React – Core Steps
109 Planning our App – Layout and Component Tree
110 Planning the State
111 Setting up the Project
112 Creating a Layout Component
113 Starting Implementation of The Burger Builder Container
114 Adding a Dynamic Ingredient Component
115 Adding Prop Type Validation
116 Starting the Burger Component
117 Outputting Burger Ingredients Dynamically
118 Calculating the Ingredient Sum Dynamically
119 Adding the Build Control Component
120 Outputting Multiple Build Controls
121 Connecting State to Build Controls
122 Removing Ingredients Safely
123 Displaying and Updating the Burger Price
124 Adding the Order Button
125 Creating the Order Summary Modal
126 Showing Hiding the Modal (with Animation)
127 Implementing the Backdrop Component
128 Adding a Custom Button Component
129 Implementing the Button Component
130 Adding the Price to the Order Summary
131 Adding a Toolbar
132 Using a Logo in our Application
133 Adding Reusable Navigation Items
134 Creating a Responsive Sidedrawer
135 Working on Responsive Adjustments
136 More about Responsive Adjustments
137 Reusing the Backdrop
138 Adding a Sidedrawer Toggle Button
139 Adding a Hamburger Icon
140 Improving the App – Introduction
141 Prop Type Validation
142 Improving Performance
143 Using Component Lifecycle Methods
144 Changing the Folder Structure
145 Wrap Up
146 Useful Resources Links

Reaching out to the Web (Http Ajax)
147 Module Introduction
148 Understanding Http Requests in React
149 Understanding our Project and Introducing Axios
150 Creating a Http Request to GET Data
151 Rendering Fetched Data to the Screen
152 Transforming Data
153 Making a Post Selectable
154 Fetching Data on Update (without Creating Infinite Loops)
155 POSTing Data to the Server
156 Sending a DELETE Request
157 Fixing a Bug
158 Handling Errors Locally
159 Adding Interceptors to Execute Code Globally
160 Removing Interceptors
161 Setting a Default Global Configuration for Axios
162 Creating and Using Axios Instances
163 Wrap Up
164 Useful Resources Links

Burger Builder Project Accessing a Server
165 Module Introduction
166 Creating the Firebase Project
167 Creating the Axios Instance
168 Sending a POST Request
169 Displaying a Spinner while Sending a Request
170 Handling Errors
171 Retrieving Data from the Backend
172 Removing Old Interceptors
173 Useful Resources Links

Multi-Page-Feeling in a Single-Page-App Routing
174 Module Introduction
175 Routing and SPAs
176 Setting Up Links
177 Setting Up the Router Package
178 react-router vs react-router-dom
179 Preparing the Project For Routing
180 Setting Up and Rendering Routes
181 Rendering Components for Routes
182 Switching Between Pages
183 Using Links to Switch Pages
184 Using Routing-Related Props
185 The withRouter HOC Route Props
186 Absolute vs Relative Paths
187 Absolute vs Relative Paths (Article)
188 Styling the Active Route
189 Passing Route Parameters
190 Extracting Route Parameters
191 Parsing Query Parameters the Fragment
192 Using Switch to Load a Single Route
193 Navigating Programmatically
194 Additional Information Regarding Active Links
195 Understanding Nested Routes
196 Creating Dynamic Nested Routes
197 Redirecting Requests
198 Conditional Redirects
199 Using the History Prop to Redirect (Replace)
200 Working with Guards
201 Handling the 404 Case (Unknown Routes)
202 Loading Routes Lazily
203 Routing and Server Deployment
204 Wrap Up
205 Useful Resources Links

Adding Routing to our Burger Project
206 Module Introduction
207 Building the Checkout Container
208 Setting Up Routing Routes
209 Navigating to the Checkout Page
210 Navigating Back To Next Page
211 Passing Ingredients via Query Params
212 Navigating to the Contact Data Component
213 Order Submission Passing Data Between Pages
214 Adding an Orders Page
215 Implementing Navigation Links
216 Fetching Orders
217 Outputting the Orders
218 Wrap Up
219 Useful Resources Links

Forms and Form Validation
220 Module Introduction
221 Analyzing the App
222 Creating a Custom Dynamic Input Component
223 Setting Up a JS Config for the Form
224 Dynamically Create Inputs based on JS Config
225 Adding a Dropdown Component
226 Handling User Input
227 Handling Form Submission
228 Adding Custom Form Validation
229 Fixing a Common Validation Gotcha
230 Adding Validation Feedback
231 Improving Visual Feedback
232 Showing Error Messages
233 Handling Overall Form Validity
234 Wrap Up
235 Fixing a Bug
236 Useful Resources Links

237 Module Introduction
238 Understanding State
239 The Complexity of Managing State
240 Understanding the Redux Flow
241 Setting Up Reducer and Store
242 Dispatching Actions
243 Adding Subscriptions
244 Connecting React to Redux
245 Connecting the Store to React
246 Dispatching Actions from within the Component
247 Passing and Retrieving Data with Action
248 Switch-Case in the Reducer
249 Updating State Immutably
250 Updating Arrays Immutably
251 Immutable Update Patterns
252 Outsourcing Action Types
253 Combining Multiple Reducers
254 Understanding State Types
255 Combining Local UI State and Redux
256 Wrap Up
257 Useful Resources Links

Adding Redux to our Project
258 Module Introduction
259 Installing Redux and React Redux
260 Basic Redux Setup
261 Finishing the Reducer for Ingredients
262 Connecting the Burger Builder Container to our Store
263 Working on the Total Price Calculation
264 Redux UI State
265 Adjusting Checkout and Contact Data
266 Wrap Up
267 Useful Resources Links

Redux Advanced
268 Module Introduction
269 Adding Middleware
270 Using the Redux Devtools
271 Executing Asynchronous Code – Introduction
272 Introducing Action Creators
273 Action Creators Async Code
274 Handling Asynchronous Code
275 Restructuring Actions
276 Where to Put Data Transforming Logic
277 Using Action Creators and Get State
278 Using Utility Functions
279 A Leaner Switch Case Statement
280 An Alternative Folder Structure
281 Diving Much Deeper
282 Wrap Up
283 Useful Resources Links

Redux Advanced Burger Project
284 Module Introduction
285 Installing the Redux Devtools
286 Preparing the Folder Structure
287 Creating Action Creators
288 Executing Asynchronous Code
289 Fetching Ingredients Asynchronously
290 Initializing Ingredients in the BurgerBuilder
291 Changing the Order of our Ingredients Manually
292 Adding Order Actions
293 Connecting Contact Data Container Actions
294 The Order Reducer
295 Working on Order Actions
296 Redirect to Improve UX
297 Combining Reducers
298 Handling Purchases Updating the UI
299 Resetting the Price after Purchases
300 Fetching Orders (via Redux)
301 Checking our Implemented Functionalities
302 Refactoring Reducers
303 Refactoring Reducers Continued
304 Wrap Up
305 Useful Resources Links

Adding Authentication to our Burger Project
306 Module Introduction
307 Understanding Authentication in Single Page Applications
308 Required App Adjustments
309 Adding an Auth Form
310 Adding Actions
311 Getting a Token from the Backend
312 Adding Sign-In
313 Storing the Token
314 Adding a Spinner
315 Logging Users Out
316 Accessing Protected Resources
317 Updating the UI Depending on Auth State
318 Adding a Logout Link
319 Forwarding Unauthenticated Users
320 Redirecting the User to the Checkout Page
321 Persistent Auth State with localStorage
322 Fixing Connect Routing Errors
323 Ensuring App Security
324 Guarding Routes
325 Displaying User Specific Orders
326 Wrap Up
327 Useful Resources Links

Improving our Burger Project
328 Module Introduction
329 Fixing the Redirect to the Frontpage
330 Using updateObject in the Entire App
331 Sharing the Validation Method
332 Using Environment Variables
333 Removing console.log()s
334 Adding Lazy Loading
335 Wrap Up
336 Useful Resources Links

337 Module Introduction
338 What is Testing
339 Required Testing Tools
340 What To Test
341 Writing our First Test
342 Testing Components Continued
343 Jest and Enzyme Documentations
344 Testing Components Correctly
345 Testing Containers
346 How to Test Redux
347 Wrap Up
348 Useful Resources Links

Deploying the App to the Web
349 Module Introduction
350 Deployment Steps
351 Building the Project
352 Example Deploying on Firebase
353 Wrap Up
354 Useful Resources Links

Bonus Working with Webpack
355 Module Introduction
356 Important Use Webpack 3
357 Introducing Webpack
358 How Webpack works
359 Basic Workflow Requirements
360 Project npm Setup
361 Creating a Basic Folder File Structure
362 Creating the Basic React Application
363 Installing Production Dependencies
364 Setting Up the Basic Webpack Config
365 Adding File Rules
366 Introducing Babel
367 Adding CSS File Support
368 Creating Rules for Images
369 Lazy Loading
370 Injecting the Script into the index.html File
371 Creating the Production Workflow
372 Wrap Up
373 Adding babel-polyfill
374 Useful Resources Links

Bonus Next.js
375 Module Introduction
376 Understanding Server Side Rendering
377 Setting Up a Project
378 Understanding the Basics
379 Next.js Components Pages
380 Styling our App in Next.js
381 Handling (404) Errors
382 A Special Lifecyle Hook
383 Deploying our App
384 Useful Resources Links

Bonus Animations in React Apps
385 Module Introduction
386 Preparing the Demo Project
387 Using CSS Transitions
388 Using CSS Animations
389 CSS Transition Animations Limitations
390 Using ReactTransitionGroup
391 Using the Transition Component
392 Wrapping the Transition Component
393 Animation Timings
394 Transition Events
395 The CSSTransition Component
396 Customizing CSS Classnames
397 Animating Lists
398 Alternative Animation Packages
399 Wrap Up
400 Useful Resources Links

Bonus A Brief Introduction to Redux Saga
401 Module Introduction
402 Installing Redux Saga
403 Creating our First Saga
404 Hooking the Saga Up (to the Store and Actions)
405 Moving Logic from the Action Creator to a Saga
406 Moving More Logic Into Sagas
407 Handling Authentication with a Saga
408 Handling Auto-Sign-In with a Saga
409 Moving the BurgerBuilder Side Effects into a Saga
410 Moving the Orders Side Effects into Sagas
411 Why Sagas can be Helpful
412 Diving Deeper into Sagas
413 Useful Resources Links

Bonus Building the Burger CSS
414 Building the Burger CSS Code

Next Steps and Course Roundup
415 Module Introduction
416 React Rocks Where to find more Examples
417 More Inspiration Real-World Projects Built with React
418 Static React Apps with Gatsby.js
419 Introducing React Native
420 Component Libraries (Example Material UI)
421 Smaller Apps with Preact
422 Comparing React with Preact
423 Congratulations

Download from Rapidgator

Download from Turbobit