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>;
```

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

Rendering Lists 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>
  }
}
```

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

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