https://react.dev/learn/conditional-rendering

React Conditional Rendering

https://reactjs.org/docs/state-and-lifecycle.html

State and Lifecycle

https://reactjs.org/docs/handling-events.html

Handling Events in React

https://reactjs.org/docs/introducing-jsx.html

Introducing JSX

https://reactjs.org/docs/rendering-elements.html

Rendering Elements

https://react.dev/learn/describing-the-ui

Describing The UI in React Js

Rendering Lists in React Js

https://react.dev/learn/keeping-components-pure

Keeping Components Pure in Reat Js

This node categorizes official documentation references for the React library, covering core topics such as JSX, element rendering, component state, and lifecycle methods.

University of Michigan - Ann Arbor

Google

React is a user interface library that was created by Jordan Walke at Meta. It was first deployed on Facebook's News Feed in 2011 and later on Instagram in 2012. 

React is based on components, allowing you to divide views into smaller pieces of logic and view, and reuse them. React is declarative, allowing you to create simple views and React will render them efficiently. Data is passed in one direction. React has many features such as the Virtual DOM, Lifecycle Methods, JSX, and React Hooks.

React Js

React needs to create a root element to render components. React will compare previous elements with the changed elements to render only the required parts. 

An element is immutable, like a frame of a movie, representing the current view at a given time.

```tsx
// create root element in element with **root** id
const root = ReactDOM.createRoot(
  document.getElementById('root')
);

// define an element
const element = <h1>Hello, world!</h1>

// render element when is required
root.render(element);
```

Rendering in React

State in React is similar to a private property that is managed by React. Every change in state calls the render method, displaying the new changes in the user interface. 

You can define a state in this way:

```ts
class Clock extends React.Component {
  constructor(props) {
    super(props); // calls parent contructor with props
    this.state = {date: new Date()}; // define state with initial value
  }

  render() {
    return (
      <div>
        <h1>Hello, world!</h1>
        <h2>It is {this.state.date.toLocaleTimeString()}.</h2>
      </div>
    );
  }
}
```

State in React Js

React executes the class constructor to initialize the states. After that, React mounts and renders the component for the first time. React provides us with a function that we can override to be executed at that time, called **componentDidMount**.

States can then be updated, and after re-rendering, we can execute code by overriding the **componentDidUpdate** function.

Finally, when a component is unmounted, we need to remove any unnecessary things from memory, such as timeouts. To do that, React exposes the **componentWillUnmount** function.

Lifecycle Methods in React Class Components

Handling events with React is similar to handling events on DOM elements. 
- In React, event names are written in **camelCase** rather than lowercase.
- Additionally, in React, we can pass functions as event handlers instead of strings.
```js
<button onClick={activateLasers}>
  Activate Lasers
</button>
```
- To prevent default behavior we cannot return `false`, we need to call `preventDefault()`
```js
<button onClick={e=>e.preventDefault()}>
  Activate Lasers
</button>
```
The `e` value is a **synthetic event** is a synthetic event defined by React based **W3C spec**, you don't need to worried about cross-browser compatibility

React Frameworks

The UI can be described in small units like buttons, titles, and other elements. With React, we can combine these elements into reusable and nestable components. React allows us to:

- Create Component
- Importing and Exporting Components
- Writing Markup with JSX
- JavaScript in JSX with Curly Braces
- Passing Props to a Component
- Conditional Rendering
- Rendering Lists
- Keeping Components Pure

Learn Before

Related

Learn After