Aide-mémoire React.js complète pour les développeurs

React.js est devenu la pierre angulaire du développement Web moderne pour la création d'applications Web dynamiques et hautes performances. Cette aide-mémoire complète couvrira tout ce que vous devez savoir pour maîtriser React.js, y compris des exemples pratiques, des extraits de code et des explications détaillées de toutes les fonctionnalités. L'objectif est de fournir un guide détaillé auquel vous pouvez vous référer à tout moment.

---

1. Introduction à Réagir

React.js, souvent simplement appelé React, est une bibliothèque JavaScript open source utilisée pour créer des interfaces utilisateur, en particulier pour les applications d'une seule page où vous avez besoin d'une expérience utilisateur rapide et interactive. Développé par Facebook, React permet aux développeurs de créer de grandes applications Web capables de se mettre à jour et de s'afficher efficacement en réponse aux modifications des données.

Le concept principal de React est le composant, qui est un module autonome qui restitue certains résultats. Les composants peuvent être imbriqués, gérés et gérés indépendamment, ce qui rend le processus de développement efficace et maintenable.

2. Premiers pas avec React

Configuration de l'environnement

Avant de commencer avec React, vous devez configurer l'environnement de développement. Voici comment :

1. Installez Node.js et npm : React s'appuie sur Node.js et npm (Node Package Manager) pour gérer les dépendances.

• Téléchargez et installez Node.js depuis le site officiel.

• Vérifiez l'installation en exécutant :
  

   node -v
   npm -v
  

1. Installer Create React App : Create React App est un environnement confortable pour apprendre React et un excellent moyen de démarrer une nouvelle application d'une seule page dans React.
   

   npm install -g create-react-app
   

Création d'une nouvelle application React

Une fois l'environnement configuré, vous pouvez créer une nouvelle application React.

1. Créer un nouveau projet :
   

   npx create-react-app my-app
   cd my-app
   npm start
   

Cette commande crée un nouveau répertoire avec le nom spécifié (my-app), configure un nouveau projet React et démarre le serveur de développement. Vous pouvez ouvrir votre navigateur et accéder à http://localhost:3000 pour voir votre nouvelle application React.

3. Composants de réaction

Les composants sont les éléments constitutifs de toute application React. Ils vous permettent de diviser l'interface utilisateur en éléments indépendants et réutilisables.

Composants fonctionnels

Les composants fonctionnels sont des fonctions JavaScript qui acceptent les accessoires comme argument et renvoient des éléments React. Ils sont plus simples et plus faciles à écrire que les composants de classe.

import React from 'react';

const Welcome = ({ name }) => {
  return <h1>Welcome, {name}!</h1>;
};

export default Welcome;

Composants de classe

Les composants de classe sont des classes ES6 qui étendent React.Component et ont une méthode de rendu qui renvoie un élément React.

import React, { Component } from 'react';

class Welcome extends Component {
  render() {
    return <h1>Welcome, {this.props.name}!</h1>;
  }
}

export default Welcome;

Différences entre les composants fonctionnels et de classe

• Gestion de l'état : les composants fonctionnels utilisent des hooks (useState, useEffect, etc.) pour la gestion de l'état, tandis que les composants de classe utilisent les méthodes this.state et lifecycle.

• Méthodes de cycle de vie : les composants de classe ont des méthodes de cycle de vie telles que composantDidMount, composantDidUpdate et composantWillUnmount. Les composants fonctionnels utilisent le hook useEffect pour gérer les effets secondaires.

• Simplicité : les composants fonctionnels sont plus simples et moins verbeux, ce qui les rend plus faciles à lire et à maintenir.

4.JSX

JSX est une extension de syntaxe qui vous permet d'écrire du HTML directement dans JavaScript. Il produit des "éléments" React.

Syntaxe JSX

JSX ressemble à HTML mais est transformé en JavaScript.

const element = <h1>Hello, world!</h1>;

Incorporation d'expressions

Vous pouvez intégrer n'importe quelle expression JavaScript dans JSX en l'enveloppant entre accolades.

const name = 'John';
const element = <h1>Hello, {name}!</h1>;

Attributs JSX

JSX vous permet d'utiliser des attributs avec une syntaxe similaire au HTML.

const element = <img src={user.avatarUrl} alt={user.name} />;

5. État et accessoires

Comprendre l'état

State est un objet intégré qui stocke les valeurs de propriété appartenant au composant. Lorsque l'objet d'état change, le composant est restitué.

Gestion de l'état avec useState Hook

Le hook useState est utilisé pour ajouter un état aux composants fonctionnels.

import React, { useState } from 'react';

const Counter = () => {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
};

export default Counter;

Comprendre les accessoires

Les accessoires sont des arguments transmis aux composants React. Les accessoires sont transmis aux composants via les attributs HTML.

Passer des accessoires

Les accessoires sont en lecture seule et immuables.

const Greeting = (props) => {
  return <h1>Hello, {props.name}!</h1>;
};

const App = () => {
  return <Greeting name="Alice" />;
};

Types d'accessoires et accessoires par défaut

PropTypes vous permettent de définir le type d'accessoires qu'un composant doit recevoir. Les accessoires par défaut peuvent être définis pour garantir qu'un accessoire aura une valeur si elle n'a pas été spécifiée.

import React from 'react';
import PropTypes from 'prop-types';

const Greeting = ({ name }) => {
  return <h1>Hello, {name}!</h1>;
};

Greeting.propTypes = {
  name: PropTypes.string.isRequired,
};

Greeting.defaultProps = {
  name: 'Guest',
};

export default Greeting;

6. Component Lifecycle

Lifecycle Methods in Class Components

Lifecycle methods are special methods in class components that run at specific points in a component's life.

• componentDidMount: Executed after the component is rendered.

• componentDidUpdate: Executed after the component's updates are flushed to the DOM.

• componentWillUnmount: Executed before the component is removed from the DOM.
  

class MyComponent extends React.Component {
  componentDidMount() {
    // Runs after component is mounted
  }

  componentDidUpdate(prevProps, prevState) {
    // Runs after component updates
  }

  componentWillUnmount() {
    // Runs before component is unmounted
  }

  render() {
    return <div>My Component</div>;
  }
}

Using useEffect Hook

The useEffect hook combines the functionalities of componentDidMount, componentDidUpdate, and componentWillUnmount.

import React, { useState, useEffect } from 'react';

const MyComponent = () => {
  const [count, setCount] = useState(0);

  useEffect(() => {
    // Runs on mount and update
    document.title = `You clicked ${count} times`;

    // Cleanup function (runs on unmount)
    return () => {
      console.log('Cleanup');
    };
  }, [count]); // Dependency array

  return (
    <div>
      <p>You

 clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
};

export default MyComponent;

7. Handling Events

Event Handling in React

React events are named using camelCase, rather than lowercase. With JSX, you pass a function as the event handler, rather than a string.

const handleClick = () => {
  console.log('Button clicked');
};

const MyComponent = () => {
  return <button onClick={handleClick}>Click me</button>;
};

Synthetic Events

React's event system is known as Synthetic Events. It is a cross-browser wrapper around the browser's native event system.

Handling Forms

Handling forms in React involves controlling the input elements and managing the state.

import React, { useState } from 'react';

const MyForm = () => {
  const [value, setValue] = useState('');

  const handleChange = (event) => {
    setValue(event.target.value);
  };

  const handleSubmit = (event) => {
    event.preventDefault();
    alert('A name was submitted: ' + value);
  };

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" value={value} onChange={handleChange} />
      </label>
      <input type="submit" value="Submit" />
    </form>
  );
};

export default MyForm;

Event Handler Best Practices

• Avoid inline event handlers: Define event handlers outside of the JSX for better readability and performance.

• Use Arrow Functions: Use arrow functions to avoid issues with this binding.

• Debounce Expensive Operations: Debounce expensive operations like API calls to avoid performance issues.

8. Conditional Rendering

if-else Statements

You can use JavaScript if-else statements inside the render method.

const MyComponent = ({ isLoggedIn }) => {
  if (isLoggedIn) {
    return <h1>Welcome back!</h1>;
  } else {
    return <h1>Please sign in.</h1>;
  }
};

Ternary Operators

Ternary operators are a concise way to perform conditional rendering.

const MyComponent = ({ isLoggedIn }) => {
  return (
    <div>
      {isLoggedIn ? <h1>Welcome back!</h1> : <h1>Please sign in.</h1>}
    </div>
  );
};

Logical && Operator

You can use the logical && operator to include elements conditionally.

const MyComponent = ({ isLoggedIn }) => {
  return (
    <div>
      {isLoggedIn && <h1>Welcome back!</h1>}
    </div>
  );
};

Inline If with Logical && Operator

Inline if with logical && operator allows you to conditionally include an element in the output.

const Mailbox = ({ unreadMessages }) => {
  return (
    <div>
      <h1>Hello!</h1>
      {unreadMessages.length > 0 &&
        <h2>
          You have {unreadMessages.length} unread messages.
        </h2>
      }
    </div>
  );
};

9. Lists and Keys

Rendering Lists

You can build collections of elements and include them in JSX using curly braces {}.

const numbers = [1, 2, 3, 4, 5];
const listItems = numbers.map((number) =>
  <li key={number.toString()}>
    {number}
  </li>
);

const NumberList = () => {
  return (
    <ul>{listItems}</ul>
  );
};

Using Keys

Keys help React identify which items have changed, are added, or are removed. Keys should be given to the elements inside the array to give the elements a stable identity.

const NumberList = (props) => {
  const numbers = props.numbers;
  const listItems = numbers.map((number) =>
    <li key={number.toString()}>
      {number}
    </li>
  );
  return (
    <ul>{listItems}</ul>
  );
};

Keys Must Only Be Unique Among Siblings

Keys used within arrays should be unique among their siblings.

function Blog(props) {
  const sidebar = (
    <ul>
      {props.posts.map((post) =>
        <li key={post.id}>
          {post.title}
        </li>
      )}
    </ul>
  );
  const content = props.posts.map((post) =>
    <div key={post.id}>
      <h3>{post.title}</h3>
      <p>{post.content}</p>
    </div>
  );
  return (
    <div>
      {sidebar}
      <hr />
      {content}
    </div>
  );
}

10. Forms and Controlled Components

Handling Form Data

Handling form data in React involves managing the state of the form fields.

import React, { useState } from 'react';

const MyForm = () => {
  const [value, setValue] = useState('');

  const handleChange = (event) => {
    setValue(event.target.value);
  };

  const handleSubmit = (event) => {
    event.preventDefault();
    alert('A name was submitted: ' + value);
  };

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" value={value} onChange={handleChange} />
      </label>
      <input type="submit" value="Submit" />
    </form>
  );
};

export default MyForm;

Controlled vs Uncontrolled Components

Controlled components are those that are controlled by React state. Uncontrolled components are those that maintain their own internal state.

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.state = { value: '' };

    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleChange(event) {
    this.setState({ value: event.target.value });
  }

  handleSubmit(event) {
    alert('A name was submitted: ' + this.state.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          Name:
          <input type="text" value={this.state.value} onChange={this.handleChange} />
        </label>
        <input type="submit" value="Submit" />
      </form>
    );
  }
}

Using Refs for Uncontrolled Components

Refs provide a way to access DOM nodes or React elements created in the render method.

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.input = React.createRef();
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleSubmit(event) {
    alert('A name was submitted: ' + this.input.current.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          Name:
          <input type="text" ref={this.input} />
        </label>
        <input type="submit" value="Submit" />
      </form>
    );
  }
}

Form Validation

Form validation ensures that user inputs are valid.

const MyForm = () => {
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');
  const [error, setError] = useState('');

  const handleSubmit = (event) => {
    event.preventDefault();
    if (!name || !email) {
      setError('Name and Email are required');
    } else {
      setError('');
      // Submit form
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      {error && <p>{error}</p>}
      <label>
        Name:
        <input type="text" value={name} onChange={(e) => setName(e.target.value)} />
      </label>
      <label>
        Email:
        <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} />
      </label>
      <input type="submit" value="Submit" />
    </form>
  );
};

export default MyForm;

11. React Router

React Router is a library for routing in React applications. It allows you to handle navigation and rendering of different components based on the URL.

Setting Up React Router

1. Install React Router:
   

   npm install react-router-dom
   

2. Set Up Routes:
   

   import React from 'react';
   import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
   
   const Home = () => <h2>Home</h2>;
   const About = () => <h2>About</h2>;
   
   const App = () => {
     return (
       <Router>
         <Switch>
           <Route exact path="/" component={Home} />
           <Route path="/about" component={About} />
         </Switch>
       </Router>
     );
   };
   
   export default App;
   

Route Parameters

You can use route parameters to capture values from the URL.

import React from 'react';
import { BrowserRouter as Router, Route,

 Switch, useParams } from 'react-router-dom';

const User = () => {
  const { id } = useParams();
  return <h2>User ID: {id}</h2>;
};

const App = () => {
  return (
    <Router>
      <Switch>
        <Route path="/user/:id" component={User} />
      </Switch>
    </Router>
  );
};

export default App;

Nested Routes

Nested routes allow you to render sub-components within a parent component.

import React from 'react';
import { BrowserRouter as Router, Route, Switch, Link, useRouteMatch } from 'react-router-dom';

const Topic = ({ match }) => <h3>Requested Topic ID: {match.params.topicId}</h3>;

const Topics = ({ match }) => {
  let { path, url } = useRouteMatch();
  return (
    <div>
      <h2>Topics</h2>
      <ul>
        <li>
          <Link to={`${url}/components`}>Components</Link>
        </li>
        <li>
          <Link to={`${url}/props-v-state`}>Props v. State</Link>
        </li>
      </ul>
      <Switch>
        <Route exact path={path}>
          <h3>Please select a topic.</h3>
        </Route>
        <Route path={`${path}/:topicId`} component={Topic} />
      </Switch>
    </div>
  );
};

const App = () => {
  return (
    <Router>
      <div>
        <ul>
          <li>
            <Link to="/">Home</Link>
          </li>
          <li>
            <Link to="/topics">Topics</Link>
          </li>
        </ul>
        <hr />
        <Switch>
          <Route exact path="/" component={Home} />
          <Route path="/topics" component={Topics} />
        </Switch>
      </div>
    </Router>
  );
};

export default App;

Redirects and Navigation

You can use the Redirect component to redirect to a different route programmatically.

import React from 'react';
import { BrowserRouter as Router, Route, Switch, Redirect } from 'react-router-dom';

const Home = () => <h2>Home</h2>;
const About = () => <h2>About</h2>;

const App = () => {
  return (
    <Router>
      <Switch>
        <Route exact path="/" component={Home} />
        <Route path="/about" component={About} />
        <Redirect from="/old-path" to="/new-path" />
      </Switch>
    </Router>
  );
};

export default App;

12. Context API

The Context API provides a way to pass data through the component tree without having to pass props down manually at every level.

Creating Context

To create a context, use React.createContext.

const MyContext = React.createContext();

Consuming Context

To consume a context value, use the useContext hook in functional components or Context.Consumer in class components.

const MyComponent = () => {
  const value = useContext(MyContext);
  return <div>{value}</div>;
};

Context with Functional Components

const MyComponent = () => {
  return (
    <MyContext.Provider value="Hello">
      <AnotherComponent />
    </MyContext.Provider>
  );
};

const AnotherComponent = () => {
  const value = useContext(MyContext);
  return <div>{value}</div>;
};

Updating Context

To update context, create a provider component with state.

const MyProvider = ({ children }) => {
  const [value, setValue] = useState('Hello');
  return (
    <MyContext.Provider value={{ value, setValue }}>
      {children}
    </MyContext.Provider>
  );
};

const MyComponent = () => {
  const { value, setValue } = useContext(MyContext);
  return (
    <div>
      {value}
      <button onClick={() => setValue('Updated Value')}>Update</button>
    </div>
  );
};

Context Best Practices

• Avoid overusing context: Use context sparingly and only for global data.

• Use multiple contexts: Separate concerns by using multiple contexts.

• Memoize context values: Use useMemo to avoid unnecessary re-renders.

13. Hooks

Hooks are functions that let you use state and other React features in functional components.

Basic Hooks (useState, useEffect)

• useState: Adds state to functional components.

• useEffect: Performs side effects in functional components.

Additional Hooks (useContext, useReducer)

• useContext: Accesses context values.

• useReducer: Manages complex state logic.
  

const initialState = { count: 0 };

function reducer(state, action) {
  switch (action.type) {
    case 'increment':
      return { count: state.count + 1 };
    case 'decrement':
      return { count: state.count - 1 };
    default:
      throw new Error();
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, initialState);
  return (
    <div>
      Count: {state.count}
      <button onClick={() => dispatch({ type: 'increment' })}>+</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
    </div>
  );
}

Custom Hooks

Custom hooks are functions that encapsulate logic and can be reused across components.

const useFetch = (url) => {
  const [data, setData] = useState(null);

  useEffect(() => {
    fetch(url)
      .then((response) => response.json())
      .then((data) => setData(data));
  }, [url]);

  return data;
};

const MyComponent = () => {
  const data = useFetch('https://api.example.com/data');
  return <div>{data ? JSON.stringify(data) : 'Loading...'}</div>;
};

Rules of Hooks

• Call hooks at the top level: Do not call hooks inside loops, conditions, or nested functions.

• Only call hooks from React functions: Call hooks from functional components or custom hooks.

14. Higher-Order Components (HOC)

Higher-Order Components (HOC) are functions that take a component and return a new component.

Understanding HOCs

HOCs are used to add additional functionality to components.

const withLogging = (WrappedComponent) => {
  return (props) => {
    console.log('Rendering', WrappedComponent.name);
    return <WrappedComponent {...props} />;
  };
};

Creating HOCs

const EnhancedComponent = withLogging(MyComponent);

Using HOCs

const MyComponent = (props) => {
  return <div>My Component</div>;
};

const EnhancedComponent = withLogging(MyComponent);

HOC Best Practices

• Do not mutate the original component: Return a new component.

• Use display names for debugging: Set displayName on the HOC for better debugging.

15. Error Boundaries

Error boundaries are React components that catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI.

Implementing Error Boundaries

Error boundaries catch errors during rendering, in lifecycle methods, and in constructors of the whole tree below them.

class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false };
  }

  static getDerivedStateFromError(error) {
    return { hasError: true };
  }

  componentDidCatch(error, errorInfo) {
    // You can also log the error to an error reporting service
    console.log(error, errorInfo);
  }

  render() {
    if (this.state.hasError) {
      return <h1>Something went wrong.</h1>;
    }

    return this.props.children; 
  }
}

Catching Errors

Error boundaries catch errors in the render method and in lifecycle methods.

const MyComponent = () => {
  throw new Error('An error occurred');
  return <div>My Component</div>;
};

const App = () => {
  return (
    <ErrorBoundary>
      <MyComponent />
    </ErrorBoundary>
  );
};

Error Boundaries Best Practices

• Use error boundaries to catch errors in components: Use error boundaries to catch and display errors in UI components.

• Log errors for debugging: Log errors to external services for debugging.

16. React Performance Optimization

Memoization

Memoization helps to avoid re-rendering components unnecessarily.

import React, { memo } from 'react';

const MyComponent = memo(({ value }) => {
  return <div>{value}</div>;
});

Code Splitting

Code splitting helps to load only the necessary code and improve performance.

import React, { Suspense, lazy } from 'react';

const OtherComponent = lazy(() => import('./OtherComponent'));

const MyComponent = () => {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <OtherComponent />
    </Suspense>
  );
};

Lazy Loading

Lazy loading helps to load components only when they are needed.

import React, { Suspense, lazy } from 'react';

const Other

Component = lazy(() => import('./OtherComponent'));

const MyComponent = () => {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <OtherComponent />
    </Suspense>
  );
};

useMemo and useCallback

• useMemo: Memoizes expensive calculations.

• useCallback: Memoizes functions.
  

const MyComponent = ({ value }) => {
  const memoizedValue = useMemo(() => {
    return computeExpensiveValue(value);
  }, [value]);

  const memoizedCallback = useCallback(() => {
    doSomething(value);
  }, [value]);

  return (
    <div>
      {memoizedValue}
      <button onClick={memoizedCallback}>Click me</button>
    </div>
  );
};

React Developer Tools

Use React Developer Tools to identify performance bottlenecks.

17. Testing in React

Jest and React Testing Library

Jest and React Testing Library are popular tools for testing React components.

Writing Tests

• Snapshot Testing: Capture the rendered component and compare it with a saved snapshot.

• Unit Testing: Test individual components and functions.

• Integration Testing: Test the integration between components and services.
  

import { render, screen } from '@testing-library/react';
import MyComponent from './MyComponent';

test('renders MyComponent', () => {
  render(<MyComponent />);
  const element = screen.getByText(/My Component/i);
  expect(element).toBeInTheDocument();
});

18. React Best Practices

Component Structure

• Organize components by feature: Group related components together.

• Use descriptive names: Use clear and descriptive names for components and props.

• Keep components small: Break down large components into smaller, reusable components.

State Management

• Lift state up: Lift state to the nearest common ancestor.

• Utiliser le contexte pour l'état global : utiliser l'API Context pour la gestion de l'état global.

Stylisme

• Utiliser les modules CSS : utilisez des modules CSS pour les styles étendus et modulaires.

• Utiliser des composants stylisés : utilisez des composants stylisés pour un style dynamique.

Performance

• Évitez les nouveaux rendus inutiles : utilisez la mémorisation et les outils d'optimisation des performances intégrés de React.

• Utiliser le fractionnement du code : divisez votre code pour charger uniquement les composants nécessaires.

Essai

• Écrivez des tests complets : rédigez des tests pour toutes les parties critiques de votre application.

• Utiliser les tests d'instantanés : utilisez les tests d'instantanés pour détecter les changements involontaires.

Conclusion

React.js est une bibliothèque puissante pour créer des applications Web modernes. En comprenant et en utilisant ses concepts de base, vous pouvez créer des applications efficaces, maintenables et évolutives. Cette aide-mémoire sert de guide complet pour vous aider à maîtriser React.js, couvrant tout, des concepts de base aux sujets avancés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!