In some cases we won't want to render nothing, in that case we need to return null.
```jsx
function Item({ name, isPacked }) {
  if (isPacked) {
    return null;
  }
  return <li className="item">{name}</li>;
}
```

Conditionally Rendering with Null in React

You can use ternary operator from JavaScript to render.

Instead of this:
```jsx
if (isPacked) {
  return <li className="item">{name} ✔</li>;
}
return <li className="item">{name}</li>;
```

You can write this:
```jsx
return (
  <li className="item">
    {isPacked ? name + ' ✔' : name}
  </li>
);
```

Conditional Rendering with ternary operator in React Js

It is used when you want to render content if a condition is true; otherwise, nothing will be rendered.
```jsx
return (
  <li className="item">
    {name} {isPacked && '✔'}
  </li>
);
```

Conditional rendering with AND operator in React Js

With an "if" statement, you can reassign a "let" variable. First, set the default value that you want to display. Then, in the "if" condition, you can reassign the variable.
```jsx
let itemContent = name;
if (isPacked) {   itemContent = name + " ✔"; }
<li className="item">
  {itemContent}
</li>
```

Conditionally assigning JSX to a variable in React Js

Conditional rendering works the same as JavaScript's if statement and ternary operators.

```jsx
class MyComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = props.state;
  }

  render() {
    if (this.state) return <div>State is true</div>
    return <div>State is false</div>
  }
}
```

University of Michigan - Ann Arbor

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

Describing the UI in React

Conditional Rendering

JSX is a syntax extension to JavaScript that is used to produce React components. Its syntax is similar to that of HTML. You can use any valid JavaScript expression inside the curly braces. Additionally, you can use JSX inside of if statements and for loops, assign it to variables, accept it as arguments, and return it from functions. 

You can also pass attributes and children. JSX is the representation of objects, and Babel compiles JSX to **React.createElement()** which returns an object.

This is an example
```tsx
const name = 'Josh Perez';
const element = <h1>Hello, {name}</h1>;
```

Components let you split the UI into independent, reusable pieces, and think about each piece in isolation. 
The simplest way to define a component is to write a JavaScript function
```jsx
const Welcome = (props) => <h1>Hello, {props.name}</h1>
```
Also, you can define it in classes. We can pass properties through an object called **props**. You can also pass other components and split them into smaller components like this:

```jsx
const Header = () => <header>Header</header>
const Main = (props) => <main>Hello {props.name} 🏈</main>
const Footer = () => <footer>Footer</footer>

const Page = () => <div>
    <Header/>
    <Main name={'Jimy'}/>
    <Footer/>
</div>
```

Components and Props

To display an array of elements in React, you can use array methods like `map` and `filter` to generate an array of React components, which can then be rendered.

Each item in the array should be given a unique key to enable React to differentiate between elements and components.

```jsx
// 1. Move data into an array
const cakes = [
  { id:'01', name:'Chocolate Cake' },
  { id:'02', name: 'Red Velvet Cake' },
  { id:'03', name: 'Vanilla Cake' },
]

// 2. Map into a new array of JSX nodes
const listItems = cakes.map(cake => <li key={cakes.id}>
  {cakes.name}
</li>);

// 3. return a list of elements
// wrapped in a `ul` component
return <ul>{listItems}</ul>;
```

Rendering Lists in React

Some JavaScript functions are pure functions. A pure function does only one thing and returns the same output for the same input. By building only pure functions, you can avoid confusing bugs and unpredictable behavior as your codebase grows.

Learn Before

Related

Learn After