Resources for Web Developers in 2022

Redux is a predictable state container for JavaScript apps.
It helps you write applications that behave consistently, run in different environments (client, server, and native), and are easy to test.

redux

We’ll refactor our existing code and break the pieces of the application into their own stateless functional components. We’ll use these components to build up our UI. We’ll also see how we can use ES6 destructuring syntax to accept just the keys we need from props to keep our JSX clean.

Refactor JSX in React to Stateless Functional Components

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

We’ll define a simple state object in the entry point of our application. Once the state has been defined, we’ll pass it into our root component as props and replace the static elements in our rendered output with values from the component’s props. We’ll move from static items to an array, seeing how we can use functions like map to render our UI.

Render in React Based on a Global State Object

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

angular

You can load resource based on the url using the a combination of `ActivatedRoute` and Angular’s `Http` service. Since the params and `Http` are both streams, you can use RxJS to get the data off the param then `switchMap` over to an `Http` request using that data.

Load Data Based on Angular Route Params

RxJS is a library for composing asynchronous and event-based programs by using observable sequences. 


rxjs

You often need to update the data flowing through the stream with custom logic based on what you need to output. This lesson covers how to use `scan` for collecting and updating the outputs as your stream progresses.

Updating Data with Scan

React Native lets you build mobile apps using only JavaScript. It uses the same design as React, letting you compose a rich mobile UI from declarative components.

react-native

In React Native you utilize the NavigatorIOS component in order to implement routing. In this tutorial, we'll walk through the app we'll be building in this series as well as how to add routing to your app.

Set up Basic iOS Routing with React Native

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

We see three varied examples of where natural transformations come in handy.

Apply Natural Transformations in everyday work

Sometimes we want to test our Redux reducers to make sure they work as expected. In this lesson we will walk through setting up some Redux reducer tests for common situations and edge cases.

React Testing: Redux Reducers

A JavaScript framework for creating ambitious web applications.

ember

Components in Ember are great for reusing code throughout our application. We’ll see how each instance of an Ember component has isolated state and we can over ride as well as set default values.

In this lesson, we will learn how to make a simple, reusable component within an Ember application.

Create Simple Components in Ember

This lesson introduces the concept of an Observable. We will see how similar it behaves to a function and what is the fundamental difference between them.

Return Multiple Values from Observables in RxJS 

Open source framework for building truly native mobile apps with Angular, TypeScript or JavaScript.

nativescript

The default core theme comes preinstalled and ready to go with every new project. Learn how to use some of the many helpful utility classes that are provided like common `btn` classes for Buttons, `h1`, `h2`, etc. Label classes and convenient `p-10` or `m-10` (shorthand margin/padding) classes ranging from 0 - 30. You can learn all about the rich options you get here: http://docs.nativescript.org/ui/theme

Style NativeScript views using the default core theme

Two-way binding still exists in Angular 2 and `ngModel` makes it simple. The syntax is a combination of the [input] and (output) syntax to represent that the data is being pushed out and pulled in.

Sync Values from Inputs with Angular 2’s ngModel Two-Way Binding

We want to be able to show only items in a certain status so in this lesson, we’ll add a flag to indicate which items to show, and create a function to filter the todos based on that value. We’ll take advantage of route based state to control the filtering behavior.

Filter Data on Property Values in React

Observables are almost like functions, but allow you to return many values. There is another concept in JavaScript (ES6), called Generator Functions, which do something very similar. 

In this lesson we will see what Observables and Generators have in common, and how they differ.

Push Values from Observables in RxJS

When a Todo property updates, you still must create a new Array of Todos and assign a new reference. This lesson walks you through refactoring from the current approach to the immutable approach.

Refactoring mutations to enforce immutable data in Angular 2

React Router v4 doesn’t require a lot of configuration to run. The core examples will run out of the box with Create React App. In this lesson, you will create an application and get React Router v4 up and running.

_**note**: in this video `react-router-dom` is installed with the `--save-dev` flag. This is **not required and may cause issues if used**. Simply install it with `npm install react-router-dom` and it will function as expected._

Run the React Router v4 Examples with Create React App

`some` returns a `boolean` value after passing each item in the source array through the test function that you pass in as the first parameter. This makes it well suited to the types of queries that require a simple `yes` or `no` answer. In this lesson we look at 2 practical use-cases for `some`. The first shows how it can be used with a ternary operator to switch a `class` on an element & the second shows how `some` can be used in an `if` conditional.

Use Some as a Ternary Operator or Conditional

React Router 4 has several routers built in for different purposes. The primary one you will use for building web applications is the BrowserRouter. In this lesson you will import the BrowserRouter and create some basic Route components.

Create Basic Routes with the React Router v4 BrowserRouter

You have complete control over the elements you nest inside of your component instance by using selectors to access and rearrange them. Selecting allows you reconstruct the elements in whatever order you like so you can visual customize the content passed in.

Select From Multiple Nested Angular 2 Elements

Whenever we are writing code, we need to remember that things may go wrong. If an error happens in a function, that error will be thrown. Errors can also happen in Observables. 

In this lesson we will see what the API is for throwing and catching Errors with Observables.

Throw Errors with RxJS Observables

Checking the validity of an Angular 2 input using ngModel is simply a matter of getting a reference to the ngModel itself. You get the reference by using the `#ref` syntax, assigning it a name, then `ngModel` will check all of the validity rules for you.

Check ngModel Validation in Angular 2

In order to resolve a dependency, Angular’s DI uses type annotations. To make sure these types are preserved when transpiled to ES5, TypeScript emits metadata. In this lesson we’ll explore how the @Injectable decorator ensures metadata generation for services that have their own dependencies.