DEV Community

loading...
Cover image for Aide-mémoire React (Cheat Sheet)

Aide-mémoire React (Cheat Sheet)

Eric Le Codeur
Entrepreneur et blogueur. Ma passion c'est d'apprendre et de partager ! Je travail avec NodeJS, React et Laravel. J'aime beaucoup Tailwind CSS
Originally published at ericlecodeur.com Updated on ・6 min read

Cet article fut publié originalement sur mon blog: https://www.ericlecodeur.com

Si vous aimez, svp visitez mon blog et/ou suivez-moi sur Twitter


React est une librairie vraiment extraordinaire. Par contre, elle n'est pas si simple et il y a beaucoup de chose qu'il faut mémoriser

C'est pourquoi j'ai fait ce monstrueux aide-mémoire avec tous les concepts de base de React.

Voici mon aide-mémoire React

 

Création d'une application React

npx create-react-app my-app-name

// Exécuter le serveur local
cd my-app-name
yarn start

// http://localhost:3000
Enter fullscreen mode Exit fullscreen mode

Règles pour la création d'un component React

  • La fonction doit avoir la première lettre de son nom en majuscule

  • La fonction doit retourner du JSX

(src/App.js)

Exemple :

// React component
function App(){
  return <h1>Hello World</h1>
} 

export default App;
Enter fullscreen mode Exit fullscreen mode

Comment ce composant est-il rendu dans le navigateur ? Le fichier principal du projet est src/index.js et dans ce fichier il y a des instructions pour le rendu du component

ReactDOM.render(<App />, document.getElementById('root'))
Enter fullscreen mode Exit fullscreen mode

Le component App sera ensuite rendu dans public/index.html 'root' div

Importer un component

Les components React seront créé dans des fichiers séparé. Chaque component doit être exporté puis importé

function Greeting(){
    return <h1>Hello World</h2>
}
export default Greeting
Enter fullscreen mode Exit fullscreen mode

Ce composant peut ensuite être importé

import Greeting from './Gretting'

function App(){
    return <Greeting />
}
Enter fullscreen mode Exit fullscreen mode

Règles d'utilisation du JSX

Renvoie un seul élément (un seul élément parent)

// non valide
return <h1>Hello world</h1><h2>Hi!</h2>

// valide grâce à l'utilisation du tag <fragment> 
return (
    <>
        <h1>Hello World</h1>
        <h2>Hi!</h2>
    </>
)
// A noté les parenthèse pour le formatage multiligne
Enter fullscreen mode Exit fullscreen mode
  • Utiliser className au lieu de class

  • De plus, tous les noms d'attributs doivent être camelCase

// not valid
return (
    <div class="title">
        Hello World
    </div>
)

// valid
return (
    <div className="title">
    </div>
)

Enter fullscreen mode Exit fullscreen mode

Fermez le tag de chaque élément

return (
    <img src="http:example.com/image.jpg" />
    <input type="text" name="first_name" />
)
Enter fullscreen mode Exit fullscreen mode

Nested Components

// Arrow function shorthand component
const Person = () => <h1>Mike Taylor</h1>

// Arrow function component
const Message = () => {
    return <h1>Hello</h1>
}

// Function component
function HelloWorld(){
  return (
      <>
          <Message />
          <Person />
      </>
  )
} 
Enter fullscreen mode Exit fullscreen mode

Component CSS

(src/App.css)

h1 {
    color: red;
}

Enter fullscreen mode Exit fullscreen mode

(src/App.js)
Import the CSS file

import './App.css'

function App(){
  return <h1>Hello World</h1>
} 
Enter fullscreen mode Exit fullscreen mode

Inline CSS

function App(){
  return <h1 style={{ color: 'red' }}>Hello World</h1>
} 
Enter fullscreen mode Exit fullscreen mode

Javascript in JSX

  • Écrire entre {}

  • Doit être une expression (retourner une valeur)

function App(){
    const name = 'Mike'
    return (
      <>
          <h1>Hello {name}</h1>
          <p>{name === 'Mike' ? '(admin)': '(user)'}</p>
      </>
    )
} 
Enter fullscreen mode Exit fullscreen mode

Component Properties (Props)

function App()
    return <Person name='Mike' age={29} />
} 

const Person = (props) => {
    return <h1>Name: {props.name}, Age: {props.age}</h1>
}

// or props object deconstructing
const Person = ({name, age}) => {
    return <h1>Name: {name} Age: {age}</h1>
}
Enter fullscreen mode Exit fullscreen mode

Children Props (slot)

function App()
    return (
        <Person name='Mike' age={29}>
            Hi, this is a welcome message
        </Person>
    )
} 

const Person = (props) => {
    return (
        <h1>Name: {props.name}, Age: {props.age}</h1>
        <p>{props.children}</p>
    )
}

// or props object deconstructing
const Person = ({name, age, children}) => {
    return (
        <h1>Name: {name} Age: {age}</h1>
        <p>{children}</p>
    )
}
Enter fullscreen mode Exit fullscreen mode

Default Props value

const Person = ({name, age, children}) => {
    return (
        <h1>Name: {name} Age: {age}</h1>
        <p>{children}</p>
    )
}

Person.defaultProps = {
    name: 'No name',
    age: 0,
}
Enter fullscreen mode Exit fullscreen mode

List

const people = [
  {id: 1, name: 'Mike', age: 29},
  {id: 2, name: 'Peter', age: 24},
  {id: 3, name: 'John', age: 39},
]
function App(){
    return (
        people.map(person => {
            return <Person name={person.name} age={person.age}/>
        })
    )
} 

const Person = (props) => {
  return (
      <h1>Name: {props.name}, Age: {props.age}</h1>
  )
}
Enter fullscreen mode Exit fullscreen mode

List with key (for React internal reference)

function App(){
    return (
        people.map(person => {
            return <Person key={person.id} name={person.name} age={person.age}/>
        })
     )
} 
Enter fullscreen mode Exit fullscreen mode

Props object destructuring

function App(){
  return people.map(person => <Person key={person.id} {...person} />)
}

const Person = ({name, age}) => {
  return (
      <h1>Name: {name}, Age: {age}</h1>
  )
} 
Enter fullscreen mode Exit fullscreen mode

Click Event

const clickHandler = () => alert('Hello World')
function App(){
    return (
        <>
            <h1>Welcome to my app</h1>
            <button onClick={clickHandler}>Say Hi</button>
        </> 
    )
} 
Enter fullscreen mode Exit fullscreen mode

ou inline...

function App(){
    return (
        <>
            <h1>Welcome to my app</h1>
            <button onClick={ () => alert('Hello World') }>Say Hi</button>
        </>
     )
} 
Enter fullscreen mode Exit fullscreen mode

Pour passer des arguments, nous devons utiliser les arrow function

const clickHandler = (message) => alert(message)
function App(){
    return (
        <>
            <h1>Welcome to my app</h1>
            <button onClick={() => clickHandler('Hello World')}>Say Hi</button>
        </> 
    )
} 
Enter fullscreen mode Exit fullscreen mode

e pour event arguments

const clickHandler = (e) => console.log(e.target)
function App(){
    return (
        <>
            <h1>Welcome to my app</h1>
            <button onClick={clickHandler}>Say Hi</button>
        </> 
    )
} 
Enter fullscreen mode Exit fullscreen mode

Passer event du child au parent

function Todo({item, onDelete}) {
    return (
      <div>
        {item}
        <button onClick={() => onDelete(item)} 
      </div>
    )
}

function Todos() {
  const handleDelete = (todo) => {
    const newTodos = todos.filter(item => item !== todo)
    setTodos(() => newTodos)
  }

  return (
    {todos.map(todo => (
       <Todo item={todo} onDelete={handleDelete}/>
    }
  )
}
Enter fullscreen mode Exit fullscreen mode

useState Hook

Le but de useState est de gérer les données réactives. toute donnée qui change dans l'application est appelée 'state'. Et lorsque l'état change, vous souhaitez réagir pour mettre à jour l'interface utilisateur.

  • Les Hook commence toujours par le préfixe 'use'

  • Doit être invoqué uniquement dans un component React

  • Doit être appelé au plus haut niveau d'un component

  • La déclaration ne peut pas être appelée conditionnellement

  • useState renvoie un tableau : [valeur d'état, fonction d'état définie]

import React, {useState} from 'react';

const DisplayTitle = () => {
  const [title, setTitle] = useState('This is the Title')
  const handleClick = () => setTitle('New Title')
  return <>
    <h2>{title}</h2>
    <button type="button" className="btn" onClick={handleClick}>
      Change Title
    </button>
  </>
};

export default DisplayTitle;
Enter fullscreen mode Exit fullscreen mode

useState with object

const DisplayTitle = () => {
  const [person, setPerson] = useState({name: 'Mike', age: 29})
  const handleClick = () => setPerson({...person, age: 35})
  return <>
    <h2>{title}</h2>
    <button type="button" className="btn" onClick={handleClick}>
      Change Age
    </button>
  </>
};
Enter fullscreen mode Exit fullscreen mode

setState functional form

function Counter() {
  const [count, setCount] = useState(0)
  // Use a function to set State
  const increase = () => setCount(() => count + 1)
  return (
    <>
      <h1>Counter</h1>
      <p>{count}</p>
      <button onClick={increase} className='btn'> + </button>
      <button onClick={() => setCount(() => count - 1)} className='btn'> - </button>
    </>
  )
}
Enter fullscreen mode Exit fullscreen mode

useEffect

Dans React, vous souhaiterez peut-être exécuter du code après des événements de lifecylce ou des side effects.

Par défaut, la fonction useEffect est exécutée après chaque nouveau rendu. Vous pouvez ensuite exécuter du code à chaque mise à jour du component.

import React, { useEffect } from 'react';

function IncreaseValue() {
    const [value, setValue] = useState(0)
    useEffect(() => {
        document.title = `New value: ${value}` 
    })
    return <button onClick={() => setValue(value + 1)}>Increase</button>
}
Enter fullscreen mode Exit fullscreen mode

Conditional useEffect

Le conditionnel doit être placé dans la fonction useEffect

useEffect(() => {
    if (value > 0) {
        document.title = `New value: ${value}` 
    }
})
Enter fullscreen mode Exit fullscreen mode

useEffect Dependency List

Que se passe-t-il si vous souhaitez exécuter du code uniquement lors du premier rendu ou uniquement lorsqu'un 'state' particulier change ? Vous pouvez utiliser la fonction useEffect et envoyer un tableau de dépendances en paramètre.

useEffect ne s'exécutera que si l'état est dans la liste de dépendances.
Si la liste est vide [], useEffect ne s'exécutera que lors du rendu initial.

useEffect(() => {
    document.title = `New value: ${value}` 
}, [])
// Noted the empty array. useEffect will then only run once on initial render

useEffect(() => {
    document.title = `New value: ${value}` 
}, [value])
// Will run each time 'value' state change.
Enter fullscreen mode Exit fullscreen mode

useEffect cleanup function

Et si vous vouliez exécuter du code à chaque 'destroy' du component ?

Pour exécuter du code uniquement lorsqu'un component est démonté/détruit, vous devez ajouter une instruction 'return' à votre fonction useEffect.

useEffect(() =>  { 
    const timer = window.setInterval(() => { 
        setCount(count => count + 1)
    }, 1000)
    return () => clearInterval(timer)
}, [])
Enter fullscreen mode Exit fullscreen mode

Le code 'clearInterval(timer)' ne sera exécuté qu'avant la suppression du component de l'interface utilisateur (démontage)

Conditional Rendering

function DisplayGreeting() {
    const [name, setName] = useState('Mike')
    if (name === 'Mike') {
        return <h1>Hello admin {name}</h1> 
    }
    return <h1>Hello user {name}</h1> 
}
Enter fullscreen mode Exit fullscreen mode

Inline If-Else

  return (
    <div>
      The user is <b>{isLoggedIn ? 'currently' : 'not'}</b> logged in.
    </div>
  );
}
Enter fullscreen mode Exit fullscreen mode

Inline Logical && Operator.
Afficher uniquement si la première expression est vraie
truthy = Not : 0, "", null, undefined, and NaN

  function DisplayUserInfo({active}) {
    return (
      <div>
        { active && <h1>User is active</h1>}
      </div>
    );
}
Enter fullscreen mode Exit fullscreen mode

Multiple inline If

<span className={count === 0 && 'text-gray-500' || count > 0 && 'text-green-500' || count < 0 && 'text-red-500'}>{count}</span>
Enter fullscreen mode Exit fullscreen mode

Form

const UserForm = () => {
  const [userName, setUserName] = useState('')
  const handleSubmit = (e) => {
    e.preventDefault()
    console.log(userName)
  }
return (
<>
    <form onSubmit={handleSubmit}>
      <input 
          value={userName} 
          onChange={(e) => setUserName(e.target.value)} 
          type="text" id="userName" 
          name="userName"
      />
       <button type="submit">Submit</button>
    </form>
</>
)
};

export default UserForm;
Enter fullscreen mode Exit fullscreen mode

useRef

useRef est principalement utilisé pour cibler un élément DOM. Mais il peut également être utilisé pour conserver/préserver une valeur modifiable entre chaque rendu. useRef ne déclenche pas un nouveau rendu (comme un useState).

const UseRefBasics = () => {
  const refContainer = useRef(null)
  const handleSubmit = (e) => {
    e.preventDefault()
    console.log(refContainer.current.value)
  }

  useEffect(() => {
    refContainer.current.focus()
  }, [])

  return (
    <div>
      <form className="form" onSubmit={handleSubmit}>
        <div>
          <input ref={refContainer} type="text" />
          <button type="submit">Submit</button>
        </div>
      </form>
    </div>
  )
};
Enter fullscreen mode Exit fullscreen mode

Conclusion

Merci d'avoir lu. J'ai passé beaucoup de temps à la rédaction de cet aide-mémoire, j'espère que vous avez aimé!

Si vous voulez plus de contenu comme celui-ci, vous pouvez me suivre sur Twitter

Discussion (0)