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 des Sticky Position-Attributs in CSS

Beim Entwickeln mobiler Apps stoßen Sie häufig au...

So erstellen Sie einen pptpd-Dienst in Alibaba Cloud Ubuntu 16.04

1. Um ein PPTP-VPN aufzubauen, müssen Sie Port 17...

Lösung für den ES-Speicherüberlauf beim Starten von Docker

Fügen Sie die Datei jvm.options zur Elasticsearch...

Tägliche Studiennotizen im HTML-Designmuster

Studiennotizen zu HTML-Entwurfsmustern Diese Woch...

Detaillierte Erklärung der Rolle des Schlüssels in React

Inhaltsverzeichnis Frage: Wird die Farbe des Bere...

Einführung in RHCE-Bridging, passwortfreie Anmeldung und Portnummernänderung

Inhaltsverzeichnis 1. Konfigurieren Sie Bridging ...

CocosCreator Erste Schritte Tutorial: Netzwerkkommunikation

Übersicht zur Netzwerkkommunikation Bei der Entwi...

Beispiel für das Einfügen eines HTML-Bilds (html add image)

Zum Einfügen von Bildern in HTML sind HTML-Tags f...

So verwenden Sie CSS, um mehrere Bilder horizontal in der Mitte anzuzeigen

Lassen Sie mich zunächst über die Implementierung...

Tutorial zum schnellen Bereitstellen von Clickhouse mit Docker-Compose

ClickHouse ist ein spaltenorientiertes Open-Sourc...