React components split a user interface into reusable, independently defined pieces. A function component receives properties through a `props` object and returns JSX:

```jsx
const Welcome = (props) => <h1>Hello, {props.name}</h1>;
```

A component can render other components to compose a larger interface:

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

University of Michigan - Ann Arbor

Google

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

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