[ Web Proxy ]
URL:
Viewing: https://developer.mozilla.org/de/docs/Web/API/Web_Animations_API/Using_the_Web_Animations_API [Back]  [Original]
Verwendung der Web Animations API - Web-APIs | MDN
HTML

HTML: Markup language

HTML reference
HTML guides
Markup languages
CSS

CSS: Styling language

CSS reference
CSS guides
Layout cookbook
JavaScriptJS

JavaScript: Scripting language

JS reference
JS guides
Web APIs

Web APIs: Programming interfaces

Web API reference
Web API guides
All

All web technology

Technologies
Topics
Learn

Learn web development

Frontend developer course
Learn HTML
Learn CSS
Learn JavaScript
Tools

Discover our tools

About

Get to know MDN better

Blog
Seitenleiste umschalten
  1. Web
  2. Web-APIs
  3. Web Animations API
  4. Verwendung der Web Animations API
Farbschema
  • Systemeinstellung
  • Hell
  • Dunkel
Deutsch
Sprache merken Mehr erfahren

Dieser Inhalt wurde automatisch aus dem Englischen bersetzt, und kann Fehler enthalten. Erfahre mehr ber dieses Experiment.

View in English Always switch to English

Verwendung der Web Animations API

Die Web Animations API ermglicht es uns, Animationen zu erstellen und deren Wiedergabe mit JavaScript zu steuern. Dieser Artikel wird Sie mit unterhaltsamen Demos und Tutorials, die von "Alice im Wunderland" inspiriert sind, in die richtige Richtung lenken.

In diesem Artikel

Lernen Sie die Web Animations API kennen

Die Web Animations API ffnet das Animations-Engine des Browsers fr Entwickler und Manipulationen durch JavaScript. Diese API wurde entwickelt, um sowohl CSS-Animationen als auch CSS-bergnge zu implementieren und lsst Raum fr zuknftige Animationseffekte. Es ist eine der leistungsfhigsten Mglichkeiten, im Web zu animieren, da der Browser seine eigenen internen Optimierungen ohne Tricks, Zwang oder Window.requestAnimationFrame() vornehmen kann.

Mit der Web Animations API knnen wir interaktive Animationen aus Stylesheets nach JavaScript verlagern und Prsentation von Verhalten trennen. Wir mssen uns nicht mehr auf DOM-lastige Techniken wie das Schreiben von CSS-Eigenschaften und das Scoping von Klassen auf Elemente verlassen, um die Wiedergaberichtung zu steuern. Und im Gegensatz zu rein deklarativem CSS ermglicht JavaScript es uns, Werte von Eigenschaften bis hin zu Dauern dynamisch festzulegen. Fr den Aufbau benutzerdefinierter Animationsbibliotheken und die Erstellung interaktiver Animationen knnte die Web Animations API das perfekte Werkzeug sein. Schauen wir uns an, was sie leisten kann!

Diese Seite enthlt eine Reihe von Beispielen, die die Web Animations API nutzen und von Alice im Wunderland inspiriert sind. Diese Beispiele werden mit freundlicher Genehmigung von Rachel Nabors erstellt und geteilt. Die vollstndige Suite von Beispielen ist auf CodePen verfgbar; hier prsentieren wir die fr unsere Dokumentation relevanten.

Schreiben von CSS-Animationen mit der Web Animations API

Eine der bekannteren Mglichkeiten, um in die Web Animations API einzusteigen, ist der Start mit etwas, das die meisten Webentwickler schon einmal verwendet haben: CSS-Animationen. CSS-Animationen haben eine vertraute Syntax, die sich gut zu Demonstrationszwecken eignet.

Die CSS-Version

Hier ist eine fallende Animation, die in CSS geschrieben wurde und Alice zeigt, wie sie in das Kaninchenloch fllt, das nach Wunderland fhrt:

Beachten Sie, dass sich der Hintergrund bewegt, Alice sich dreht und ihre Farbe sich versetzt zu ihrer Drehung ndert. In diesem Tutorial konzentrieren wir uns nur auf Alice. Sie knnen den vollstndigen Quellcode berprfen, indem Sie auf "Play" im Codeblock klicken. Hier ist das vereinfachte CSS, das Alices Animation steuert:

css
#alice {
  animation: alice-tumbling infinite 3s linear;
}

@keyframes alice-tumbling {
  0% {
    color: black;
    transform: rotate(0) translate3d(-50%, -50%, 0);
  }
  30% {
    color: #431236;
  }
  100% {
    color: black;
    transform: rotate(360deg) translate3d(-50%, -50%, 0);
  }
}

Dies ndert Alices Farbe und ihre Transformationsdrehung ber 3 Sekunden mit einer konstanten (linearen) Rate und wiederholt sich unendlich. Im @keyframes-Block sehen wir, dass sich Alices Farbe 30 % des Weges durch jede Schleife (etwa nach 0,9 Sekunden) von Schwarz zu einem tiefen Burgunderrot ndert und dann bis zum Ende der Schleife wieder zurck wechselt.

Verschiebung zu JavaScript

Jetzt versuchen wir die gleiche Animation mit der Web Animations API zu erstellen.

Darstellung von Keyframes

Das Erste, was wir brauchen, ist die Erstellung eines Keyframe Object entsprechend unserem CSS-@keyframes-Block:

js
const aliceTumbling = [
  { transform: "rotate(0) translate3d(-50%, -50%, 0)", color: "black" },
  { color: "#431236", offset: 0.3 },
  { transform: "rotate(360deg) translate3d(-50%, -50%, 0)", color: "black" },
];

Hier verwenden wir ein Array, das mehrere Objekte enthlt. Jedes Objekt reprsentiert einen Key aus dem ursprnglichen CSS. Im Gegensatz zu CSS muss die Web Animations API jedoch nicht explizit ber die Prozentstze entlang der Animation fr jedes erscheinende Key informiert werden. Sie wird die Animation automatisch in gleiche Teile basierend auf der Anzahl der angegebenen Keys unterteilen. Das bedeutet, dass ein Keyframe-Objekt mit drei Keys den mittleren Key 50 % des Weges durch jede Schleife der Animation abspielt, sofern nicht anders angegeben.

Wenn wir explizit den Versatz eines Keys von den anderen Keys festlegen mchten, knnen wir einen Offset direkt im Objekt spezifizieren, getrennt von der Deklaration durch ein Komma. Im obigen Beispiel, um sicherzustellen, dass Alices Farbnderung bei 30% (nicht 50%) erfolgt, geben wir offset: 0.3 an.

Derzeit sollten mindestens zwei Keyframes spezifiziert sein (die Start- und Endzustnde der Animationssequenz darstellend). Wenn Ihre Keyframe-Liste nur einen Eintrag hat, kann Element.animate() in einigen Browsern einen NotSupportedError DOMException werfen, bis sie aktualisiert werden.

Zusammenfassend sind die Keys standardmig gleichmig verteilt, es sei denn, Sie spezifizieren einen Offset auf einem Key. Praktisch, nicht wahr?

Darstellung von Timingeigenschaften

Wir mssen auch ein Objekt von Timingeigenschaften erstellen, das den Werten in Alices Animation entspricht:

js
const aliceTiming = {
  duration: 3000,
  iterations: Infinity,
};

Hier sind einige Unterschiede zu erkennen, wie quivalente Werte in CSS reprsentiert werden:

  • Zum einen erfolgt die Dauer in Millisekunden anstelle von Sekunden 3000 nicht 3s. Wie bei setTimeout() und Window.requestAnimationFrame(), akzeptiert die Web Animations API nur Millisekunden.
  • Das Andere, was Sie bemerken werden, ist, dass es iterations und nicht iteration-count heit.

Hinweis: Es gibt eine Reihe kleiner Unterschiede zwischen der in CSS-Animationen verwendeten Terminologie und der in Web-Animationen verwendeten. Beispielsweise verwendet Web Animations nicht den String "infinite", sondern stattdessen das JavaScript-Schlsselwort Infinity. Und anstelle von timing-function verwenden wir easing. Hier geben wir keinen easing-Wert an, weil, im Gegensatz zu CSS-Animationen, bei denen der Standardwert der animation-timing-function ease ist, bei der Web Animations API das Standard-easing linear also das, was wir hier wollen.

Die Einzelteile zusammenfgen

Jetzt ist es Zeit, sie beide mit der Methode Element.animate() zusammenzufhren:

js
document.getElementById("alice").animate(aliceTumbling, aliceTiming);

Und boom: Die Animation beginnt zu spielen:

Die animate()-Methode kann auf jedem DOM-Element aufgerufen werden, das mit CSS animiert werden knnte. Und sie kann auf verschiedene Weisen geschrieben werden. Anstatt Objekte fr Keyframes und Timingeigenschaften zu erstellen, knnten wir ihre Werte direkt bergeben, so wie hier:

js
document.getElementById("alice").animate(
  [
    { transform: "rotate(0) translate3d(-50%, -50%, 0)", color: "black" },
    { color: "#431236", offset: 0.3 },
    { transform: "rotate(360deg) translate3d(-50%, -50%, 0)", color: "black" },
  ],
  {
    duration: 3000,
    iterations: Infinity,
  },
);

Noch mehr, wenn wir nur die Dauer der Animation und nicht ihre Iterationen angeben wollten (standardmig iteriert eine Animation einmal), knnten wir einfach die Millisekunden allein bergeben:

js
document.getElementById("alice").animate(
  [
    { transform: "rotate(0) translate3d(-50%, -50%, 0)", color: "black" },
    { color: "#431236", offset: 0.3 },
    { transform: "rotate(360deg) translate3d(-50%, -50%, 0)", color: "black" },
  ],
  3000,
);

Wiedergabesteuerung mit play(), pause(), reverse() und updatePlaybackRate()

Whrend wir CSS-Animationen mit der Web Animations API schreiben knnen, liegt der wahre Nutzen der API in der Manipulation der Wiedergabe der Animation. Die Web Animations API bietet mehrere ntzliche Methoden zur Steuerung der Wiedergabe. Lassen Sie uns einen Blick auf das Pausieren und Spielen von Animationen im "Follow the White Rabbit"-Beispiel werfen:

In diesem Beispiel hat der weie Hase eine Animation, die ihn in ein Kaninchenloch lsst. Sie wird nur ausgelst, wenn der Benutzer darauf klickt.

Animationen pausieren und abspielen

Wir knnen den Hasen wie gewohnt mit der animate()-Methode animieren:

js

Die Methode Element.animate() wird sofort ausgefhrt, nachdem sie aufgerufen wurde. Um zu verhindern, dass der Kuchen sich selbst isst, bevor der Benutzer die Mglichkeit hatte, darauf zu klicken, rufen wir sofort nach der Definition Animation.pause() darauf auf, wie folgt:

js

Hinweis: Alternativ knnen Sie rabbitDownAnimation mit dem Animation()-Konstruktor definieren, das nicht spielt, bis Sie play() aufrufen.

Wir knnen jetzt die Methode Animation.play() verwenden, um sie auszufhren, wann immer wir bereit sind. Speziell wollen wir es mit einer Klickaktion verknpfen. Wir knnen dies ber folgendes erreichen:

js

Wenn ein Benutzer auf den Hasen klickt oder mit dem Finger darauf drckt, knnen wir jetzt downHeGoes aufrufen, um alle Animationen abzuspielen.

Andere ntzliche Methoden

Zustzlich zum Pausieren und Abspielen knnen wir die folgenden Animation-Methoden verwenden:

  • Animation.finish() springt zum Ende der Animation.
  • Animation.cancel() bricht die Animation ab und entfernt deren Effekte.
  • Animation.reverse() setzt die Wiedergaberate (Animation.playbackRate](/de/docs/Web/API/Animation/playbackRate)) der Animation auf einen negativen Wert, sodass sie rckwrts luft.

Schauen wir uns zuerst playbackRate an eine negative playbackRate lsst eine Animation rckwrts laufen. In Durch den Spiegel reist Alice zu einer Welt, in der sie laufen muss, um an Ort und Stelle zu bleiben und doppelt so schnell laufen muss, um sich vorwrts zu bewegen! Im Beispiel "Red Queen's Race" laufen Alice und die Rote Knigin, um an Ort und Stelle zu bleiben:

Da kleine Kinder im Gegensatz zu automatisierten Schachfiguren schnell ermden, verlangsamt sich Alice stndig. Wir knnen dies tun, indem wir ein Abklingen auf ihre playbackRate der Animation einstellen. Wir verwenden updatePlaybackRate() anstelle von playbackRate direkt zu setzen, da dies ein reibungsloses Update erzeugt:

js
setInterval(() => {
  // Make sure the playback rate never falls below .4
  if (redQueenAlice.playbackRate > 0.4) {
    redQueenAlice.updatePlaybackRate(redQueenAlice.playbackRate * 0.9);
  }
  adjustBackgroundPlayback();
}, 1000);

Aber wenn man auf sie klickt oder tippt, werden sie durch Multiplikation ihrer playbackRate beschleunigt:

js
function goFaster() {
  // But you can speed them up by giving the screen a click or a tap.
  redQueenAlice.updatePlaybackRate(redQueenAlice.playbackRate * 1.1);
  adjustBackgroundPlayback();
}

document.addEventListener("click", goFaster);
document.addEventListener("touchstart", goFaster);

Auch die Hintergrundelemente haben playbackRates, die beim Klick oder Tap beeinflusst werden. Ihre Wiedergaberaten werden aus Alice's abgeleitet, siehe unten. Was passiert, wenn Sie Alice und die Rote Knigin doppelt so schnell laufen lassen? Was passiert, wenn sie langsamer werden?

js
/* Alice tires so easily! 
  Every so many seconds, reduce their playback rate so they slow a little. 
*/
const sceneries = [
  foreground1Movement,
  foreground2Movement,
  background1Movement,
  background2Movement,
];

function adjustBackgroundPlayback() {
  // If Alice and the Red Queen are running at a speed of 0.81.2,
  // the background doesn't move.
  // But if they fall under 0.8, the background slides backwards
  if (redQueenAlice.playbackRate < 0.8) {
    sceneries.forEach((anim) => {
      anim.updatePlaybackRate(-redQueenAlice.playbackRate / 2);
    });
  } else if (redQueenAlice.playbackRate > 1.2) {
    sceneries.forEach((anim) => {
      anim.updatePlaybackRate(redQueenAlice.playbackRate / 2);
    });
  } else {
    sceneries.forEach((anim) => {
      anim.updatePlaybackRate(0);
    });
  }
}
adjustBackgroundPlayback();

Animation Styles beibehalten

Ein hufiger Anwendungsfall beim Animieren von Elementen ist, den Endzustand der Animation nach deren Abschluss beizubehalten. Eine manchmal verwendete Methode dafr ist das Setzen des fill mode der Animation auf forwards. Es wird jedoch nicht empfohlen, Fill-Modi zu verwenden, um den Effekt einer Animation unbegrenzt beizubehalten, aus zwei Grnden:

  • Der Browser muss den Zustand der Animation aufrechterhalten, whrend sie noch aktiv ist, sodass die Animation weiterhin Ressourcen verbraucht, obwohl sie nicht mehr animiert. Beachten Sie, dass dies etwas dadurch gemildert wird, dass der Browser Fllanimations automatisch entfernt.
  • Von Animationen angewendete Stile haben eine hhere Prioritt in der Cascade als angegebene Stile, sodass es schwierig sein kann, sie nach Bedarf zu berschreiben.

Ein besserer Ansatz ist die Verwendung der Methode Animation.commitStyles(). Dies schreibt die berechneten Werte der aktuellen Stile der Animation in das style-Attribut ihres Zielelements, danach kann das Element normal umgestylt werden.

Automatische Entfernung von Fill-Animationen

Es ist mglich, eine groe Anzahl von Animationen auf demselben Element auszulsen. Wenn sie unbegrenzt sind (d.h. forward-filling), kann dies zu einer riesigen Animationsliste fhren, die ein Speicherleck verursachen knnte. Aus diesem Grund entfernen Browser automatisch fllende Animationen, nachdem sie durch neuere Animationen ersetzt wurden, es sei denn, der Entwickler gibt ausdrcklich an, sie zu behalten.

Animationen werden entfernt, wenn alle folgenden Bedingungen erfllt sind:

  • Die Animation fllt (Ihr fill ist forwards, wenn sie vorwrts luft, backwards, wenn sie rckwrts luft, oder both).
  • Die Animation ist beendet. (Beachten Sie, dass sie aufgrund des fill trotzdem noch in Kraft ist.)
  • Die Zeitleiste der Animation ist monoton steigend. (Dies ist immer wahr fr DocumentTimeline; andere Zeitleisten wie scroll-timeline knnen rckwrts laufen.)
  • Die Animation wird nicht durch deklarative Markup wie CSS gesteuert.
  • Jeder Stileffekt des AnimationEffect der Animation wird durch eine andere Animation berschrieben, die ebenfalls alle obigen Bedingungen erfllt. (Typischerweise, wenn zwei Animationen die gleiche Stileigenschaft des gleichen Elements setzen, berschreibt die zuletzt erstellte die andere.)

Die ersten vier Bedingungen stellen sicher, dass ohne Eingreifen durch JavaScript-Code der Effekt der Animation sich nie ndern oder enden wird. Die letzte Bedingung stellt sicher, dass die Animation nie tatschlich den Stil eines Elements beeinflussen wird: sie wurde vollstndig ersetzt.

Wenn die Animation automatisch entfernt wird, wird das remove-Ereignis der Animation ausgelst.

Um zu verhindern, dass der Browser Animationen automatisch entfernt, rufen Sie die Methode persist() der Animation auf.

Die Eigenschaft replaceState der Animation wird removed sein, wenn die Animation entfernt wurde, persisted, wenn Sie persist() auf die Animation angewendet haben, oder active, andernfalls.

Informationen aus Animationen herausholen

Stellen Sie sich andere Mglichkeiten vor, wie wir playbackRate verwenden knnten, z. B. zur Verbesserung der Barrierefreiheit fr Benutzer mit vestibulren Strungen, indem wir ihnen ermglichen, Animationen auf einer gesamten Website zu verlangsamen. Das ist mit CSS ohne Neuberechnung der Dauern in jeder CSS-Regel unmglich, aber mit der Web Animations API knnen wir die Methode Document.getAnimations verwenden, um jede Animation auf der Seite zu durchlaufen und ihre playbackRates zu halbieren, so wie hier:

js
document.getAnimations().forEach((animation) => {
  animation.updatePlaybackRate(animation.playbackRate * 0.5);
});

Mit der Web Animations API mssen Sie nur eine kleine Eigenschaft ndern!

Ein weiteres Problem, das mit CSS-Animationen allein schwer zu lsen ist, ist die Schaffung von Abhngigkeiten von Werten, die von anderen Animationen bereitgestellt werden. Im Beispiel des "Growing and Shrinking Alice"-Spiels haben Sie vielleicht bemerkt, dass die Dauer des Kuchens etwas merkwrdig ist:

js
document.getElementById("eat-me-sprite").animate([], {
  duration: aliceChange.effect.getComputedTiming().duration / 2,
});

Um zu verstehen, was hier passiert, schauen wir uns die Animation von Alice an:

js
const aliceChange = document
  .getElementById("alice")
  .animate(
    [
      { transform: "translate(-50%, -50%) scale(.5)" },
      { transform: "translate(-50%, -50%) scale(2)" },
    ],
    {
      duration: 8000,
      easing: "ease-in-out",
      fill: "both",
    },
  );

Alices Animation lsst sie von der Hlfte ihrer Gre auf das Doppelte ihrer Gre ber 8 Sekunden anwachsen. Dann pausieren wir sie:

js
aliceChange.pause();

Wenn wir sie am Anfang ihrer Animation pausiert gelassen htten, wrde sie bei der Hlfte ihrer vollen Gre beginnen, als ob sie die ganze Flasche schon ausgetrunken htte! Wir wollen den "Abspielkopf" ihrer Animation in der Mitte setzen, also ist sie schon zur Hlfte fertig. Wir knnten dies tun, indem wir ihre Animation.currentTime auf 4 Sekunden einstellen, so wie hier:

js
aliceChange.currentTime = 4000;

Aber whrend wir an dieser Animation arbeiten, knnten wir Alices Dauer oft ndern. Wre es nicht besser, wenn wir ihre currentTime dynamisch einstellen, damit wir nicht zwei nderungen gleichzeitig vornehmen mssen? Tatschlich knnen wir dies tun, indem wir auf die Eigenschaft Animation.effect von aliceChange verweisen, die ein Objekt mit allen Details des/der Effekte(s), die auf Alice aktiv sind, zurckgibt:

js
aliceChange.currentTime = aliceChange.effect.getComputedTiming().duration / 2;

effect ermglicht es uns, auf die Keyframes und Timingeigenschaften der Animation zuzugreifen aliceChange.effect.getComputedTiming() zeigt auf Alices Timing-Objekt das enthlt ihre duration. Wir knnen ihre Dauer halbieren, um den Mittelpunkt ihrer Animationszeitleiste zu erhalten, und sie auf normale Gre setzen. Jetzt knnen wir ihre Animation in beide Richtungen umkehren und abspielen, um sie wachsen oder schrumpfen zu lassen!

Und wir knnen dasselbe tun, wenn wir die Dauer von Kuchen und Flasche einstellen:

js
const drinking = document
  .getElementById("liquid")
  .animate([{ height: "100%" }, { height: "0" }], {
    fill: "forwards",
    duration: aliceChange.effect.getComputedTiming().duration / 2,
  });
drinking.pause();

Jetzt sind alle drei Animationen mit nur einer Dauer verknpft, die wir leicht an einem Ort ndern knnen.

Wir knnen auch die Web Animations API verwenden, um die aktuelle Zeit der Animation zu ermitteln. Das Spiel endet, wenn Ihnen der Kuchen zum Essen oder die Flasche leer geht. Welche Vignette den Spielern prsentiert wird, hngt davon ab, wie weit Alice in ihrer Animation war, ob sie zu gro wird und nicht mehr durch die kleine Tr passen kann oder zu klein ist und nicht den Schlssel zur Tr erreichen kann. Wir knnen herausfinden, ob sie am groen oder kleinen Ende ihrer Animation ist, indem wir die currentTime ihrer Animation erhalten und sie durch ihre activeDuration teilen:

js
const endGame = () => {
  // get Alice's timeline's playhead location
  const alicePlayhead = aliceChange.currentTime;
  const aliceTimeline = aliceChange.effect.getComputedTiming().activeDuration;

  // stops Alice's and other animations
  stopPlayingAlice();

  // depending on which third it falls into
  const aliceHeight = alicePlayhead / aliceTimeline;

  if (aliceHeight <= 0.333) {
    // Alice got smaller!
    // 
  } else if (aliceHeight >= 0.666) {
    // Alice got bigger!
    // 
  } else {
    // Alice didn't change significantly
    // 
  }
};

Callbacks und Promises

CSS-Animationen und -bergnge haben ihre eigenen Ereignis-Listener, und diese sind auch mit der Web Animations API mglich:

  • onfinish ist der Ereignishandler fr das finish-Ereignis und kann manuell mit finish() ausgelst werden.
  • oncancel ist der Ereignishandler fr das cancel-Ereignis und kann mit cancel() ausgelst werden.

Hier setzen wir die Callbacks fr den Kuchen, die Flasche und Alice, um die Funktion endGame auszulsen:

js
// When the cake or bottle runs out
nommingCake.onfinish = endGame;
drinking.onfinish = endGame;

// Alice reaches the end of her animation
aliceChange.onfinish = endGame;

Noch besser, die Web Animations API bietet auch ein finished Promise, das erfllt wird, wenn die Animation abgeschlossen ist, oder abgelehnt, wenn sie abgebrochen wird.

Schlussfolgerung

Dies sind die grundlegenden Funktionen der Web Animations API. Jetzt sollten Sie bereit sein, "ins Kaninchenloch" des Animierens im Browser zu springen und bereit sein, Ihre eigenen Animationsexperimente zu schreiben!

Siehe auch

Help improve MDN

War diese bersetzung hilfreich?
Ja Nein
Erfahren Sie, wie Sie beitragen knnen Diese Seite wurde automatisch aus dem Englischen bersetzt.
bersetzung auf GitHub anzeigen Fehler mit dieser bersetzung melden
Filterfeld leeren
  1. Web Animations API
  2. Anleitungen
    1. Verwendung der Web Animations API
    2. Konzepte der Web Animations API
    3. Keyframe-Formate
    4. Web Animation API Tipps und Tricks
  3. Interfaces
    1. Animation
    2. AnimationEffect
    3. AnimationEvent
    4. AnimationTimeline
    5. AnimationPlaybackEvent
    6. DocumentTimeline
    7. KeyframeEffect
    8. ScrollTimeline
    9. ViewTimeline
  4. Eigenschaften
    1. Document.timeline
  5. Methoden
    1. Document.getAnimations()
    2. Element.animate()
    3. Element.getAnimations()
MDN

Der Bauplan fr ein besseres Internet.

MDN
Mitmachen
Entwicklung
Mozilla

Teile dieses Inhalts sind 19982026 von einzelnen mozilla.org-Mitwirkenden. Inhalte sind verfgbar unter einer Creative-Commons-Lizenz.

Web Proxy Viewer  |  New URL  |  Original Page