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

Instanzmethode für MySQL-String-Verkettung und Festlegen von Nullwerten

#String-Verkettung concat(s1,s2); verkette die St...

Neulinge lernen schnell die Schritte zum Erstellen von Website-Symbolen

<br />Original-URL: http://www.lxdong.com/po...

Methoden und Schritte zum Upgrade von MySql5.x auf MySql8.x

Mehrere Unterschiede zwischen MySQL 5.x und MySQL...

CentOS 8-Installationsdiagramm (superdetailliertes Tutorial)

CentOS 8 ist offiziell veröffentlicht! CentOS ent...

MySQL-Benutzer und -Berechtigungen und Beispiele zum Knacken des Root-Passworts

MySQL-Benutzer und -Berechtigungen In MySQL gibt ...

JavaScript imitiert die Spezialeffekte der Jingdong-Lupe

In diesem Artikel wird der spezifische Code von J...

Verwenden von js, um einen Wasserfalleffekt zu erzielen

In diesem Artikelbeispiel wird der spezifische Co...

So mounten Sie die CD, um das RPM-Paket unter Linux zu finden

Vorne geschrieben Manchmal müssen Sie bei der Ver...

Detaillierte Erklärung, wie Tomcat asynchrone Servlets implementiert

Vorwort Durch meine vorherige Tomcat-Artikelserie...

Detaillierte Erklärung zur Verwendung der JavaScript-Paging-Komponente

Die Paginierungskomponente ist eine häufige Kompo...

MySQL 8.0.13 Download- und Installations-Tutorial mit Bildern und Text

MySQL ist die am häufigsten verwendete Datenbank....

Grafisches Tutorial zur Installation und Konfiguration von MySQL 8.0.13

In diesem Artikel finden Sie das Installations- u...

Detaillierte Erklärung der MySQL-Dreiwertelogik und NULL

Inhaltsverzeichnis Was ist NULL Zwei Arten von NU...