Aide-mémoire React (Cheat Sheet)

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
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;
    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'))
    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
    Ce composant peut ensuite être importé
    import Greeting from './Gretting'
    
    function App(){
        return <Greeting />
    }
    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
  • 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>
    )
    Fermez le tag de chaque élément
    return (
        <img src="http:example.com/image.jpg" />
        <input type="text" name="first_name" />
    )
    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 />
          </>
      )
    }
    Component CSS
    (src/App.css)
    h1 {
        color: red;
    }
    (src/App.js)
    Import the CSS file
    import './App.css'
    
    function App(){
      return <h1>Hello World</h1>
    }
    Inline CSS
    function App(){
      return <h1 style={{ color: 'red' }}>Hello World</h1>
    }
    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>
          </>
        )
    }
    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>
    }
    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>
        )
    }
    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,
    }
    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>
      )
    }
    List with key (for React internal reference)
    function App(){
        return (
            people.map(person => {
                return <Person key={person.id} name={person.name} age={person.age}/>
            })
         )
    }
    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>
      )
    }
    Click Event
    const clickHandler = () => alert('Hello World')
    function App(){
        return (
            <>
                <h1>Welcome to my app</h1>
                <button onClick={clickHandler}>Say Hi</button>
            </> 
        )
    }
    ou inline...
    function App(){
        return (
            <>
                <h1>Welcome to my app</h1>
                <button onClick={ () => alert('Hello World') }>Say Hi</button>
            </>
         )
    }
    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>
            </> 
        )
    }
    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>
            </> 
        )
    }
    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}/>
        }
      )
    }
    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;
    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>
      </>
    };
    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>
        </>
      )
    }
    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>
    }
    Conditional useEffect
    Le conditionnel doit être placé dans la fonction useEffect
    useEffect(() => {
        if (value > 0) {
            document.title = `New value: ${value}` 
        }
    })
    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.
    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)
    }, [])
    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> 
    }
    Inline If-Else
    return (
        <div>
          The user is <b>{isLoggedIn ? 'currently' : 'not'}</b> logged in.
        </div>
      );
    }
    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>
        );
    }
    Multiple inline If
    <span className={count === 0 && 'text-gray-500' || count > 0 && 'text-green-500' || count < 0 && 'text-red-500'}>{count}</span>
    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;
    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>
      )
    };
    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

    36

    This website collects cookies to deliver better user experience

    Aide-mémoire React (Cheat Sheet)