Gestione dell’interfaccia: metodo imperativo | Aulab

GUIDE PER ASPIRANTI PROGRAMMATORI

Gestione dell’interfaccia: metodo imperativo

L’approccio imperativo prevede l’analisi di quali step vanno fatti. La documentazione ufficiale di React propone questa metafora: immaginiamo di essere passeggeri di un auto e, senza dire a chi guida dove vogliamo andare, diamo indicazioni sulle svolte da fare, una alla volta. Chi guida non sa dove stiamo andando e le nostre probabilità di successo…

Lezione 19 / 41
Enza Neri
Immagine di copertina

Vuoi avviare una nuova carriera o fare un upgrade?

Trova il corso Digital & Tech più adatto a te nel nostro catalogo!

L’approccio imperativo prevede l’analisi di quali step vanno fatti. La documentazione ufficiale di React propone questa metafora: immaginiamo di essere passeggeri di un auto e, senza dire a chi guida dove vogliamo andare, diamo indicazioni sulle svolte da fare, una alla volta. Chi guida non sa dove stiamo andando e le nostre probabilità di successo sono basate sul fatto che daremo tutte le indicazioni giuste al momento giusto.

Prendiamo ad esempio la gestione dell’interfaccia di un form, il perfetto esempio di come passare da un approccio imperativo a uno dichiarativo

Ecco cosa vogliamo ottenere:

  • Quando viene premuto il pulsante “Create”, il bottone, l’input di testo e la checkbox si disabilitano.
  • Quando la richiesta ha successo, il bottone, l’input di testo e la checkbox si abilitano.
  • Quando la richiesta va in errore, il bottone, l’input di testo e la checkbox si abilitano. L’errore viene visualizzato.
import { useState } from "react";
import "./TodoItemForm.css";

export default function TodoItemForm({ todoItem, onChange, onSubmit }) {
  const [error, setError] = useState(null);
  const [isSubmitButtonDisabled, setIsSubmitButtonDisabled] = useState(false);
  const [isDescriptionInputDisabled, setIsDescriptionInputDisabled] =
    useState(false);
  const [isCheckboxDisabled, setIsCheckboxDisabled] = useState(false);

  // ...

  const onFormSubmit = (event) => {
    event.preventDefault();

    setError(null);
    setIsSubmitButtonDisabled(true);
    setIsDescriptionInputDisabled(true);
    setIsCheckboxDisabled(true);

    onSubmit().then(
      (_todoItem) => {
        setIsSubmitButtonDisabled(false);
        setIsDescriptionInputDisabled(false);
        setIsCheckboxDisabled(false);
      },
      (error) => {
        setError(error.message);
        setIsSubmitButtonDisabled(false);
        setIsDescriptionInputDisabled(false);
        setIsCheckboxDisabled(false);
      }
    );
  };

  return (
    <form className="TodoItemForm" onSubmit={onFormSubmit}>
      <input
        type="checkbox"
        checked={todoItem.isDone}
        onChange={(event) => {
          onIsDoneChange(event.currentTarget.checked);
        }}
        disabled={isCheckboxDisabled}
      />
      <input
        type="text"
        placeholder="Description"
        value={todoItem.description}
        onInput={(event) => {
          onDescriptionChange(event.currentTarget.value);
        }}
        disabled={isDescriptionInputDisabled}
      />
      <input type="submit" value="Create" disabled={isSubmitButtonDisabled} />
      {error ? <p style={{ color: "red" }}>{error}</p> : null}
    </form>
  );
}

Abbiamo creato quattro stati: uno per l’errore ed uno per ogni elemento che vogliamo venga disabilitato durante il salvataggio dei dati.

Nota: potresti aver notato l’uso di un trattino basso per _todoItem nel metodo then della Promise. Si tratta di una convenzione per indicare argomenti di funzioni che scegliamo deliberatamente di non utilizzare, ma che vogliamo dichiarare, di solito perché ci serve un argomento successivo (per esempio il secondo argomento) oppure, come in questo caso, perché non vogliamo rischiare di dimenticarci che a quella funzione viene passato un argomento!!

Se stai pensando qualcosa come “non avrebbe avuto più senso usare un solo stato, per esempio isLoading, che indichi che la richiesta è in fase di caricamento?”, allora stai già pensando in modo dichiarativo. È difficile fare esempi di programmazione imperativa in React, perché la libreria stessa spinge a un approccio dichiarativo, ma pensiamo a come una cosa del genere potrebbe essere implementata in linguaggio JavaScript:

e.preventDefault();

hide(errorMessage);
disable(checkbox);
disable(descriptionInput);
disable(submitButton);

submit().then(
  () => {
    enable(checkbox);
    enable(descriptionInput);
    enable(submitButton);
  },
  () => {
    show(errorMessage);
    enable(checkbox);
    enable(descriptionInput);
    enable(submitButton);
  }
);

Sei indeciso sul percorso? 💭

Parliamone! Scrivici su Whatsapp e risponderemo a tutte le tue domande per capire quale dei nostri corsi è il più adatto alle tue esigenze.

Oppure chiamaci al 800 128 626