React implementiert dynamische Popup-Fensterkomponente

React implementiert dynamische Popup-Fensterkomponente

Wenn wir beim Schreiben einiger UI-Komponenten die Animation nicht berücksichtigen, ist dies sehr einfach zu erreichen. Die Hauptsache besteht darin, das Vorhandensein oder Fehlen (ähnlich dem v-if-Attribut in Vue) oder die Sichtbarkeit (ähnlich dem v-show-Attribut in Vue) umzuschalten.

1. Pop-ups ohne Animation

In React kann dies wie folgt erreicht werden:

Schnittstelle ModalProps {
  öffnen: Boolesch;
  beim Schließen?: () => ungültig;
  Kinder?: irgendwelche;
}
const Modal = ({open.onClose, children}: ModalProps) => {
  wenn (!öffnen) {
    gibt null zurück;
  }
  returniere Portal erstellen(<div>
    <div Klassenname = "modal-content">{Kinder}</div>
    <div Klassenname = "modal-close-btn" onclick = "{onClose}">x</div>
  </div>, Dokument.Text);
};

Anwendung:

const App = () => {
  const [öffnen, setOpen] = useState(false);

  zurückkehren (
    <div Klassenname="App">
      <button onclick="{()" ==""> setOpen(true)}>Modal anzeigen</button>
      <modal öffnen="{öffnen}" onclose="{()" ==""> setzeÖffnen(false)}>
        Modale Inhalte
      </modal>
    </div>
  );
};

Hier verwenden wir das open Attribut, um zu steuern, ob angezeigt werden soll oder nicht, aber es gibt überhaupt keinen Farbverlaufseffekt.

Wenn wir Animationseffekte wie Überblenden und Zoomen erzielen möchten, müssen wir dies ändern.

2. Animierte Pop-ups selbst erstellen

Wenn viele Studierende Animationseffekte selbst implementieren, stellen sie häufig fest, dass die Animation beim Anzeigen funktioniert, jedoch nicht beim Schließen. Das liegt alles daran, dass das Timing der Animation nicht gut kontrolliert wurde. Dabei setzen wir den Ablauf der dynamischen Effekte zunächst selbst um.

Als ich mit der Implementierung begann, hatte die Animation nur einen Start- und einen Endzustand und zur Steuerung der Animation waren zahlreiche Variablen und viel Logik erforderlich.

Später bezog ich mich auf die Implementierung react-transition-group , die die Animation in mehrere Teile aufteilte und jeden Teil separat steuerte.

  1. Die Reihenfolge der Erweiterungsanimation: Eingabe -> Eingabe-Aktiv -> Eingabe-Fertig;
  2. Die Reihenfolge der schließenden Animationseffekte: Beenden -> Beenden-Aktiv -> Beenden-Fertig;

Der Animationsvorgang befindet sich im enter-active und exit-active Prozess.

Wir verwenden eine Variable „active“, um zu steuern, ob die Abschlussanimation ausgeführt wurde, und der Parameter „open“ steuert nur, ob die Erweiterungsanimation oder die Abschlussanimation ausgeführt wird.

Das Popup-Fenster wird nur zerstört, wenn sowohl „open“ als auch „active“ falsch sind.

const Modal = ({ öffnen, untergeordnete Elemente, beim Schließen }) => {
  const [active, setActive] = useState(false); // Existenzzyklus des Popup-Fensters if (!open && !active) {
    gibt null zurück;
  }

  ReactDOM.createPortal zurückgeben (
    <div Klassenname="modal">
      <div Klassenname = "modal-content">{Kinder}</div>
      <div Klassenname="modal-close-btn" onclick="{onClose}">
        X
      </div>
    </div>,
    Dokument.Text,
  );
};

Hier fügen wir weiterhin Änderungen im Animationsprozess hinzu:

const [aniClassName, setAniClassName] = useState(''); // Animationsklasse

// Ausführung des Übergangs abgeschlossen. Listening-Funktion const onTransitionEnd = () => {
  // Wenn „open“ aktiv ist, ist der Endzustand „enter-done“
  // Wenn „open“ nicht „false“ ist, lautet der Endstatus „exit-done“
  setAniClassName(öffnen? 'Eingeben-Fertig': 'Beenden-Fertig');

  // Wenn open false ist, endet der Lebenszyklus des Popup-Fensters, wenn die Animation endet if (!open) {
    setzeAktiv(falsch);
  }
};

useEffect(() => {
  wenn (öffnen) {
    setzeAktiv(true);
    setAniClassName('eingeben');
    // setTimeout wird verwendet, um Klassen zu wechseln und den Übergang zu ermöglichen setTimeout(() => {
      setAniClassName('aktiv eintreten');
    });
  } anders {
    setAniClassName('beenden');
    setzeTimeout(() => {
      setAniClassName('exit-aktiv');
    });
  }
}, [offen]);

Der vollständige Code der Modalkomponente lautet wie folgt:

const Modal = ({ öffnen, untergeordnete Elemente, beim Schließen }) => {
  const [active, setActive] = useState(false); // Existenzzyklus des Popup-Fensters const [aniClassName, setAniClassName] = useState(''); // Animationsklasse
  const onTransitionEnd = () => {
    setAniClassName(öffnen? 'Eingeben-Fertig': 'Beenden-Fertig');
    wenn (!öffnen) {
      setzeAktiv(falsch);
    }
  };

  useEffect(() => {
    wenn (öffnen) {
      setzeAktiv(true);
      setAniClassName('eingeben');
      setzeTimeout(() => {
        setAniClassName('aktiv eintreten');
      });
    } anders {
      setAniClassName('beenden');
      setzeTimeout(() => {
        setAniClassName('exit-aktiv');
      });
    }
  }, [offen]);

  wenn (!öffnen && !aktiv) {
    gibt null zurück;
  }

  ReactDOM.createPortal zurückgeben (
    <div classname="{'modal" '="" +="" aniclassname}="" ontransitionend="{onTransitionEnd}">
      <div Klassenname = "modal-content">{Kinder}</div>
      <div Klassenname="modal-close-btn" onclick="{onClose}">
        X
      </div>
    </div>,
    Dokument.Text,
  );
};

Der Ablauf der Animation ist umgesetzt, auch der Stil soll gemeinsam geschrieben werden. Wir möchten beispielsweise einen Fade-Effekt erzielen:

.eingeben {
  Deckkraft: 0;
}
.aktiv eingeben {
  Übergang: Deckkraft 200 ms, leichtes Ein-Aus;
  Deckkraft: 1;
}
.Eingabe-fertig {
  Deckkraft: 1;
}
.Ausfahrt {
  Deckkraft: 1;
}
.exit-aktiv {
  Deckkraft: 0;
  Übergang: Deckkraft 200 ms, leichtes Ein-Aus;
}
.beenden-fertig {
  Deckkraft: 0;
}

Wenn Sie den Zoomeffekt erzielen möchten, ändern Sie einfach diese Klassen.

Es wurde ein Popup-Fenster mit Animation implementiert.

Anwendung:

const App = () => {
  const [öffnen, setOpen] = useState(false);

  zurückkehren (
    <div Klassenname="App">
      <button onclick="{()" ==""> setOpen(true)}>Modal anzeigen</button>
      <modal öffnen="{öffnen}" onclose="{()" ==""> setzeÖffnen(false)}>
        Modale Inhalte
      </modal>
    </div>
  );
};

Klicken Sie auf den Link, um Ihre eigene React-Popup-Fenster-Demo zu implementieren und den Effekt zu sehen.

Ebenso gibt es Toast und Co., die ebenfalls auf diese Weise umgesetzt werden können.

3. Reaktionsübergangsgruppe

Um den dynamischen Effekt zu erzielen, haben wir die CSSTransition-Komponente in der React-Transition-Group übernommen. CSSTransition hat für mich den Prozess des dynamischen Aufklappens und Schließens gekapselt. Wir können diese Komponente direkt bei der Implementierung von Popup-Fenstern verwenden.

Hier gibt es eine wichtige Eigenschaft: unmountOnExit , die bedeutet, dass die Komponente nach Ende der Animation deinstalliert wird.

const Modal = ({ öffnen, beim Schließen }) => {
  // http://reactcommunity.org/react-transition-group/css-transition/
  // in der Eigenschaft ist true/false, true bedeutet, die Animation zu erweitern, false bedeutet, die Animation zu schließen return createPortal(
    <csstransition in="{open}" timeout="{200}" unmountonexit="">
      <div Klassenname="modal">
        <div Klassenname = "modal-content">{Kinder}</div>
        <div Klassenname="modal-close-btn" onclick="{onClose}">
          X
        </div>
      </div>
    </csstransition>,
    Dokument.Text,
  );
};

Nach der Verwendung der CSSTransition-Komponente wird die Modalanimation viel komfortabler.

4. Fazit

Bisher wurde die zu animierende React Modal-Komponente implementiert. Obwohl es in React keinen <transition> -Tag ähnlich der offiziellen Definition von Vue gibt, können wir ihn selbst oder mit Hilfe von Komponenten von Drittanbietern implementieren.

Oben finden Sie Einzelheiten zur Implementierung dynamischer Popup-Fensterkomponenten in React. Weitere Informationen zu Popup-Fensterkomponenten von React finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • React verwendet die Upload-Komponente von Antd, um die Funktion zum Senden von Dateiformularen zu implementieren (vollständiger Code).
  • Lösung für das React-Programm „reine Funktionskomponente setState“ aktualisiert die Seitenaktualisierung nicht
  • Implementierung der React-Sternebewertungskomponente
  • So machen Sie React-Komponenten im Vollbildmodus

<<:  Detaillierte Erläuterung des Dockerfiles zum Erstellen eines benutzerdefinierten Docker-Images und Vergleich der CMD- und ENTRYPOINT-Anweisungen

>>:  Erläuterung der Konfiguration und Verwendung der MySQL-Speicher-Engine InnoDB

Artikel empfehlen

Detaillierte Erklärung der CSS-Animationsattribut-Keyframes

Wie lange ist es her, dass ich meine Kolumne aktu...

Detaillierte Erläuterung des Datenproxys und der Ereignisse von VUE

Inhaltsverzeichnis Überprüfung der Object.defineP...

Eine kurze Analyse der startReactApplication-Methode von React Native

In diesem Artikel haben wir den Startvorgang von ...

Warum verwendet der MySQL-Datenbankindex den B+-Baum?

Bevor wir weiter analysieren, warum der MySQL-Dat...

Win2008 R2 MySQL 5.5 ZIP-Format MySQL-Installation und -Konfiguration

Installation und Konfiguration von MySQL im ZIP-F...

Neue Funktionen in MySQL 8.0: Hash Join

Das MySQL-Entwicklungsteam hat am 14. Oktober 201...

React implementiert den Beispielcode der Radiokomponente

Ziel dieses Artikels ist es, die Grundfunktionen ...

So richten Sie Textfelder in mehreren Formularen in HTML aus

Der Formularcode ist wie in der Abbildung dargest...

Komprimierungs- und Optimierungsvorgänge für Docker-Images

Der Grund für die heutige Beliebtheit von Docker ...

5 Möglichkeiten, den diagonalen Kopfzeileneffekt in der Tabelle zu erzielen

Jeder muss mit Tabellen vertraut sein. Wir stoßen...

Klassen in TypeScript

Inhaltsverzeichnis 1. Übersicht 2. Definieren Sie...

Drei Diskussionen zum Iframe Adaptive Height Code

Beim Erstellen einer B/S-Systemschnittstelle stößt...