Heim > Web-Frontend > js-Tutorial > Praktikantenebene: Lebenszyklusmethoden und Hooks in React

Praktikantenebene: Lebenszyklusmethoden und Hooks in React

PHPz
Freigeben: 2024-07-18 04:24:30
Original
929 Leute haben es durchsucht

Intern level: Lifecycle Methods and Hooks in React

Einführung in React Hooks

React Hooks sind Funktionen, mit denen Sie Status- und andere React-Funktionen in Funktionskomponenten verwenden können. Vor Hooks war zustandsbehaftete Logik nur in Klassenkomponenten verfügbar. Hooks bieten eine direktere API für die React-Konzepte, die Sie bereits kennen, wie z. B. Status, Lebenszyklusmethoden und Kontext.

Schlüsselhaken in React

useState

useState ist ein Hook, mit dem Sie Funktionskomponenten einen Status hinzufügen können.

Beispiel:

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;
Nach dem Login kopieren

In diesem Beispiel initialisiert useState die Count-Statusvariable auf 0. Die setCount-Funktion wird verwendet, um den Status zu aktualisieren, wenn auf die Schaltfläche geklickt wird.

useEffect

useEffect ist ein Hook, mit dem Sie Nebeneffekte in Funktionskomponenten ausführen können, z. B. das Abrufen von Daten, die direkte Interaktion mit dem DOM und das Einrichten von Abonnements. Es kombiniert die Funktionalität mehrerer Lebenszyklusmethoden in Klassenkomponenten (componentDidMount, ComponentDidUpdate und ComponentWillUnmount).

Beispiel:

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

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

  useEffect(() => {
    fetch('https://api.example.com/data')
      .then(response => response.json())
      .then(data => setData(data));
  }, []);

  return (
    <div>
      {data ? <pre class="brush:php;toolbar:false">{JSON.stringify(data, null, 2)}
: 'Loading...'}
); }; export default DataFetcher;
Nach dem Login kopieren

In diesem Beispiel ruft useEffect Daten von einer API ab, wenn die Komponente bereitgestellt wird.

useContext

useContext ist ein Hook, mit dem Sie auf den Kontextwert für einen bestimmten Kontext zugreifen können.

Beispiel:

import React, { useContext } from 'react';

const ThemeContext = React.createContext('light');

const ThemedComponent = () => {
  const theme = useContext(ThemeContext);

  return <div>The current theme is {theme}</div>;
};

export default ThemedComponent;
Nach dem Login kopieren

In diesem Beispiel greift useContext auf den aktuellen Wert von ThemeContext zu.

useReducer

useReducer ist ein Hook, mit dem Sie komplexe Zustandslogik in einer Funktionskomponente verwalten können. Es ist eine Alternative zu useState.

Beispiel:

import React, { useReducer } from 'react';

const initialState = { count: 0 };

const reducer = (state, action) => {
  switch (action.type) {
    case 'increment':
      return { count: state.count + 1 };
    case 'decrement':
      return { count: state.count - 1 };
    default:
      return state;
  }
};

const Counter = () => {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <div>
      <p>Count: {state.count}</p>
      <button onClick={() => dispatch({ type: 'increment' })}>Increment</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>Decrement</button>
    </div>
  );
};

export default Counter;
Nach dem Login kopieren
Nach dem Login kopieren

In diesem Beispiel verwaltet useReducer den Zählstatus mit einer Reduzierfunktion.

Benutzerdefinierte Haken

Mit benutzerdefinierten Hooks können Sie zustandsbehaftete Logik über mehrere Komponenten hinweg wiederverwenden. Ein benutzerdefinierter Hook ist eine Funktion, die integrierte Hooks verwendet.

Beispiel:

import { useState, useEffect } from 'react';

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

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

  return data;
};

const DataFetcher = ({ url }) => {
  const data = useFetch(url);

  return (
    <div>
      {data ? <pre class="brush:php;toolbar:false">{JSON.stringify(data, null, 2)}
: 'Loading...'}
); }; export default DataFetcher;
Nach dem Login kopieren

In diesem Beispiel ist useFetch ein benutzerdefinierter Hook, der Daten von einer bestimmten URL abruft.

Erweiterte Hook-Muster

Komplexen Zustand mit useReducer verwalten

Beim Umgang mit komplexer Zustandslogik mit mehreren Unterwerten oder wenn der nächste Zustand vom vorherigen abhängt, kann useReducer besser geeignet sein als useState.

Beispiel:

import React, { useReducer } from 'react';

const initialState = { count: 0 };

const reducer = (state, action) => {
  switch (action.type) {
    case 'increment':
      return { count: state.count + 1 };
    case 'decrement':
      return { count: state.count - 1 };
    default:
      return state;
  }
};

const Counter = () => {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <div>
      <p>Count: {state.count}</p>
      <button onClick={() => dispatch({ type: 'increment' })}>Increment</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>Decrement</button>
    </div>
  );
};

export default Counter;
Nach dem Login kopieren
Nach dem Login kopieren

In diesem Beispiel verwaltet useReducer den Zählstatus mit einer Reduzierfunktion.

Optimieren der Leistung mit useMemo und useCallback

Verwenden Sie Memo

useMemo ist ein Hook, der einen berechneten Wert speichert und ihn nur dann neu berechnet, wenn sich eine der Abhängigkeiten ändert. Es hilft, die Leistung zu optimieren, indem teure Berechnungen bei jedem Rendern vermieden werden.

Beispiel:

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

const ExpensiveCalculation = ({ number }) => {
  const computeFactorial = (n) => {
    console.log('Computing factorial...');
    return n <= 1 ? 1 : n * computeFactorial(n - 1);
  };

  const factorial = useMemo(() => computeFactorial(number), [number]);

  return <div>Factorial of {number} is {factorial}</div>;
};

const App = () => {
  const [number, setNumber] = useState(5);

  return (
    <div>
      <input
        type="number"
        value={number}
        onChange={(e) => setNumber(parseInt(e.target.value, 10))}
      />
      <ExpensiveCalculation number={number} />
    </div>
  );
};

export default App;
Nach dem Login kopieren

In diesem Beispiel stellt useMemo sicher, dass die Fakultätsberechnung nur dann neu berechnet wird, wenn sich die Zahl ändert.

useCallback

useCallback ist ein Hook, der sich eine Funktion merkt und deren Neuerstellung bei jedem Rendern verhindert, es sei denn, eine ihrer Abhängigkeiten ändert sich. Es ist nützlich, um stabile Funktionen an untergeordnete Komponenten zu übergeben, die auf Referenzgleichheit basieren.

Beispiel:

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

const Button = React.memo(({ onClick, children }) => {
  console.log(`Rendering button - ${children}`);
  return <button onClick={onClick}>{children}</button>;
});

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

  const increment = useCallback(() => setCount((c) => c + 1), []);

  return (
    <div>
      <Button onClick={increment}>Increment</Button>
      <p>Count: {count}</p>
    </div>
  );
};

export default App;
Nach dem Login kopieren

In diesem Beispiel stellt useCallback sicher, dass die Inkrementierungsfunktion nur dann neu erstellt wird, wenn sich ihre Abhängigkeiten ändern, wodurch unnötige erneute Renderings der Button-Komponente vermieden werden.

Abschluss

Das Verständnis von React Hooks ist für die moderne React-Entwicklung unerlässlich. Sie ermöglichen es Ihnen, saubereren und wartbareren Code in Funktionskomponenten zu schreiben. Indem Sie Hooks wie useState, useEffect, useContext und useReducer sowie erweiterte Muster wie benutzerdefinierte Hooks und Leistungsoptimierungen mit useMemo und useCallback beherrschen, können Sie robuste und effiziente React-Anwendungen erstellen. Wenn Sie als Praktikant ein solides Verständnis dieser Konzepte erlangen, legen Sie eine solide Grundlage für Ihre Reise in die React-Entwicklung.

Das obige ist der detaillierte Inhalt vonPraktikantenebene: Lebenszyklusmethoden und Hooks in React. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Quelle:dev.to
Vorheriger Artikel:Erkunden von Optionskonvertierungen in Effect-TS Nächster Artikel:Den Prisma-Workflow mithilfe von Migrationen verstehen
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Aktuelle Ausgaben
verwandte Themen
Mehr>
Beliebte Empfehlungen
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage