Translation in German (#183)

* interview-questions/basic-level

* Translation German(array)

* Updated Array Folder in german (#137)

* interview-questions/basic-level

* interview-questions/basic-level

* Translation German(array)

* Translation German: Updated File Name

* fix: added readme file for german translation

* Updated Array in german

---------

Co-authored-by: Suman Kunwar <[email protected]>
Co-authored-by: sumn2u <[email protected]>

* Completed Array Folder in German (#148)

* interview-questions/basic-level


---------

Co-authored-by: Suman Kunwar <[email protected]>
Co-authored-by: sumn2u <[email protected]>

* Added Basic folder in german (#163)

* interview-questions/basic-level

---------

Co-authored-by: Suman Kunwar <[email protected]>
Co-authored-by: sumn2u <[email protected]>

* Completed browser-object-model-bom folder in german (#171)

* interview-questions/basic-level

* interview-questions/basic-level

* Translation German(array)

* Translation German: Updated File Name

* fix: added readme file for german translation

* Updated Array in german

* Completed Array in german

* Completed Basics in german

* Completed browser-object-model in german

* Completed classes in german

---------

Co-authored-by: Suman Kunwar <[email protected]>
Co-authored-by: sumn2u <[email protected]>

---------

Co-authored-by: Ayushi Rastogi <[email protected]>
Co-authored-by: Ayushi Rastogi <[email protected]>

Author: sumn2u

LANGS.md

@@ -3,4 +3,4 @@
 - [Türkiye](tr/)
 - [Français](fr/)
 - [Deutsch](de/)
-- [Indonesian](id/)
+- [Indonesian](id/)

de/README.md

@@ -0,0 +1,57 @@
+---
+capítulo: 1
+número de página: 7
+descripción: JavaScript es un lenguaje de programación de alto nivel, interpretado y de tipado dinámico utilizado principalmente para el desarrollo web. Es una de las tecnologías centrales utilizadas para crear sitios web interactivos y aplicaciones web.
+---
+
+# Capítulo 1
+# Introducción
+
+Las computadoras son comunes en el mundo de hoy, ya que pueden realizar una amplia variedad de tareas de manera rápida y precisa. Se utilizan en muchas industrias diferentes, como negocios, atención médica, educación y entretenimiento, y se han convertido en una parte esencial de la vida diaria para muchas personas. Además, también se utilizan para realizar cálculos científicos y matemáticos complejos, almacenar y procesar grandes cantidades de datos y comunicarse con personas de todo el mundo.
+
+La programación implica crear un conjunto de instrucciones, llamado programa, para que una computadora lo siga. Escribir un programa puede ser tedioso y frustrante a veces porque las computadoras son muy precisas y necesitan instrucciones específicas para completar tareas.
+
+![Página de introducción](../.gitbook/assets/intro.png)
+
+Los lenguajes de programación son lenguajes artificiales utilizados para dar instrucciones a las computadoras. Se utilizan en la mayoría de las tareas de programación y se basan en la forma en que los humanos se comunican entre sí. Al igual que los idiomas humanos, los lenguajes de programación permiten combinar palabras y frases para expresar nuevos conceptos. Es interesante destacar que la forma más efectiva de comunicarse con las computadoras implica el uso de un lenguaje similar al lenguaje humano.
+
+En el pasado, la forma principal de interactuar con las computadoras era a través de interfaces basadas en texto, como los comandos BASIC y DOS. Estos han sido reemplazados en gran medida por interfaces visuales, que son más fáciles de aprender pero ofrecen menos flexibilidad. Sin embargo, los lenguajes de programación como _JavaScript_ todavía se utilizan y se pueden encontrar en navegadores web modernos y en la mayoría de los dispositivos.
+
+JavaScript (_JS abreviado_) es el lenguaje de programación que se utiliza para crear interacciones dinámicas al desarrollar páginas web, juegos, aplicaciones e incluso servidores. JavaScript comenzó en Netscape, un navegador web desarrollado en la década de 1990, y hoy es uno de los lenguajes de programación más famosos y utilizados.
+
+Inicialmente, se creó para dar vida a las páginas web y solo podía ejecutarse en un navegador. Ahora se ejecuta en cualquier dispositivo que admita el motor JavaScript. Objetos estándar como [Array](./arrays/README.md), [Date](./date-and-time.md) y [Math](./numbers/math.md) están disponibles en JavaScript, al igual que operadores, estructuras de control y declaraciones. _JavaScript del lado del cliente_ y _JavaScript del lado del servidor_ son las versiones ampliadas de JavaScript.
+
+* _JavaScript del lado del cliente_ permite la mejora y manipulación de páginas web y navegadores de clientes. Las respuestas a eventos del usuario, como clics de ratón, entrada de formularios y navegación de páginas, son algunos ejemplos.
+
+* _JavaScript del lado del servidor_ permite el acceso a servidores, bases de datos y sistemas de archivos.
+
+JavaScript es un lenguaje interpretado. Mientras se ejecuta JavaScript, un intérprete interpreta cada línea y la ejecuta. El navegador moderno utiliza la tecnología Just In Time (JIT) para la compilación, que compila JavaScript en código ejecutable.
+
+{% hint style="info" %}
+"LiveScript" fue el nombre inicial dado a JavaScript.
+{% endhint %}
+
+### Código y qué hacer con él
+
+El _código_ son las instrucciones escritas que componen un programa. Aquí, muchos capítulos contienen mucho código, y es importante leer y escribir código como parte del aprendizaje de cómo programar. No debes simplemente examinar rápidamente los ejemplos; léelos con atención y trata de comprenderlos. Esto puede ser difícil al principio, pero con la práctica, mejorarás. Lo mismo ocurre con los ejercicios; asegúrate de intentar realmente escribir una solución antes de asumir que los comprendes. También es útil intentar ejecutar tus soluciones a los ejercicios en un intérprete de JavaScript, ya que esto te permitirá ver si tu código funciona correctamente y puede animarte a experimentar y superar los ejercicios.
+
+### Convenciones tipográficas
+
+Aquí, el texto escrito en una fuente de espacio fijo representa elementos de un programa. Esto puede ser un fragmento independiente o una referencia a una parte de un programa cercano. Los programas, como el que se muestra a continuación, se escriben de esta manera:
+
+```javascript
+const números = [45, 4, 9, 16, 25];
+let txt = "";
+for (let x en números) {
+  txt += números[x];
+}
+
+```
+
+A veces, la salida esperada de un programa se escribe después de él, precedida por dos barras diagonales con un Resultado, como esto:
+
+```javascript
+console.log(txt);
+
+// Resultado: txt = '45491625'
+```

de/arrays/README.md

@@ -0,0 +1,75 @@
+---
+layout: editorial
+Kapitel: 6
+Seitenzahl: 36
+Beschreibung: Arrays sind ein grundlegender Bestandteil der Programmierung. Ein Array ist eine Liste von Daten. Wir können viele Daten in einer Variablen speichern, was unseren Code lesbarer und verständlicher macht. Es erleichtert auch die Durchführung von Funktionen in Bezug auf verwandte Daten.
+---
+
+# Kapitel 6
+# Arrays
+
+Arrays sind ein grundlegender Bestandteil der Programmierung. Ein Array ist eine Liste von Daten. Wir können viele Daten in einer Variablen speichern, was unseren Code lesbarer und verständlicher macht. Es erleichtert auch die Durchführung von Funktionen in Bezug auf verwandte Daten.
+
+Die Daten in Arrays werden als **Elemente** bezeichnet.
+
+Hier ist ein einfaches Array:
+
+```javascript
+// 1, 1, 2, 3, 5 und 8 sind die Elemente in diesem Array
+let zahlen = [1, 1, 2, 3, 5, 8];
+```
+
+Arrays können leicht mit Array-Literalen oder mit dem 'new'-Schlüsselwort erstellt werden.
+
+```javascript
+const autos = ["Saab", "Volvo", "BMW"]; // Verwendung von Array-Literalen
+const autos = new Array("Saab", "Volvo", "BMW"); // Verwendung des new-Schlüsselworts
+```
+
+Eine Indexnummer wird verwendet, um auf die Werte eines Arrays zuzugreifen. Der Index des ersten Elements in einem Array ist immer '0', da Array-Indizes mit '0' beginnen. Die Indexnummer kann auch verwendet werden, um die Elemente eines Arrays zu ändern.
+
+```javascript
+const autos = ["Saab", "Volvo", "BMW"];
+console.log(autos[0]); 
+// Ergebnis: Saab
+
+autos[0] = "Opel"; // Ändern des ersten Elements eines Arrays
+console.log(autos);
+// Ergebnis: ['Opel', 'Volvo', 'BMW']
+```
+{% hint style="warning" %}
+Arrays sind eine spezielle Art von Objekt. Es können Objekte in einem Array vorhanden sein.
+{% endhint %}
+
+Die length-Eigenschaft eines Arrays gibt die Anzahl der Elemente zurück. Die von Arrays unterstützten Methoden werden unten angezeigt:
+
+| Name              | Beschreibung                                                                                                                                      |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `concat()`        | RGibt zwei oder mehr kombinierte Arrays zurück                                                                              |
+| `join()`          | Verbindet alle Elemente in einem Array zu einem String                                                                                 |
+| `push()`          | Fügt ein oder mehrere Elemente am Ende des Arrays hinzu und gibt die Länge zurück
+                    |
+| `pop()`           | Entfernt das letzte Element eines Arrays und gibt dieses Element zurück                                                                                     |
+| `shift()`         | Entfernt das erste Element eines Arrays und gibt dieses Element zurück                                                                                    |
+| `unshift()`       | Fügt ein oder mehrere Elemente am Anfang eines Arrays hinzu und gibt die Länge zurück                                                                         |
+| `slice()`         | Extrahiert den Abschnitt eines Arrays und gibt das neue Array zurück                                                                                        |
+| `at()`            | Gibt das Element am angegebenen Index oder `undefined` zurück                                                                                             |
+| `splice()`        | Entfernt Elemente aus einem Array und ersetzt sie (optional) und gibt das Array zurück                                                              |
+| `reverse()`       | TVertauscht die Elemente eines Arrays und gibt eine Referenz auf ein Array zurück                                                                           |
+| `flat()`          | Gibt ein neues Array zurück, in dem alle Unterarray-Elemente rekursiv bis zur angegebenen Tiefe zusammengefügt sind                                        |
+| `sort()`          | Sortiert die Elemente eines Arrays an Ort und Stelle und gibt eine Referenz auf das Array zurück                                                                     |
+| `indexOf()`       | Gibt den Index des ersten Übereinstimmungselements zurück                                                                                        |
+| `lastIndexOf()`   | Gibt den Index des letzten Übereinstimmungselements zurück                                                                                         |
+| `forEach()`       | Führt eine Rückruffunktion in jedem Element eines Arrays aus und gibt undefined zurück                                                                             |
+| `map()`           | Gibt ein neues Array zurück, das einen Rückgabewert ausführt, indem `callback` für jedes Array-Element ausgeführt wird.                                                           |
+| `flatMap()`       | Führt map() gefolgt von flat() der Tiefe 1 aus                                                                                                      |
+| `filter()`        | Gibt ein neues Array zurück, das die Elemente enthält, für die callback true zurückgegeben hat                                                                     |
+| `find()`          | Gibt das erste Element zurück, für das `callback` `true` zurückgegeben hat                                                                                       |
+| `findLast()`      | Gibt das letzte Element zurück, für das `callback` `true` zurückgegeben hat                                                                                        |
+| `findIndex()`     | Gibt den Index des ersten Elements zurück, für das `callback` `true` zurückgegeben hat                                                                          |
+| `findLastIndex()` | Gibt den Index des letzten Elements zurück, für das `callback` `true` zurückgegeben hat                                                                          |
+| `every()`         | Gibt `true` zurück, wenn `callback` für jedes Element im Array `true` zurückgibt                                                                           |
+| `some()`          | Gibt `true` zurück, wenn `callback` für mindestens ein Element im Array `true` zurückgibt                                                                   |
+| `reduce()`        | Verwendet `callback(Akkumulator, aktueller Wert, aktueller Index, Array)` zu Reduzierungszwecken und gibt den endgültigen von der `callback`-Funktion zurückgegebenen Wert zurück  |
+| `reduceRight()`   | Funktioniert ähnlich wie `reduce()`, beginnt jedoch mit dem letzten Element                                                                                   |
+

de/arrays/length.md

@@ -0,0 +1,45 @@
+---
+Kapitel: 6
+Seitenzahl: 44
+Beschreibung: Arrays haben eine Eigenschaft namens "length", die die Länge eines Arrays misst.
+---
+# Länge (Length)
+
+Arrays haben eine Eigenschaft namens "length", und sie ist ziemlich genau das, wonach sie klingt - es ist die Länge des Arrays.
+
+```javascript
+let array = [1, 2, 3];
+
+let l = array.length;
+
+// Ergebnis: l = 3
+```
+
+Die "length"-Eigenschaft legt auch die Anzahl der Elemente in einem Array fest. Zum Beispiel:
+
+```javascript
+let obst = ["Banane", "Orange", "Apfel", "Mango"];
+obst.length = 2;
+
+console.log(obst);
+// Ergebnis: ['Banane', 'Orange']
+```
+
+Sie können die "length"-Eigenschaft auch verwenden, um das letzte Element eines Arrays zu erhalten, indem Sie sie als Index verwenden. Zum Beispiel:
+
+```c
+console.log(obst[obst.length - 1]); // Ergebnis: Orange
+```
+
+Sie können die "length"-Eigenschaft auch verwenden, um Elemente am Ende eines Arrays hinzuzufügen. Zum Beispiel:
+
+```c
+obst[obst.length] = "Ananas";
+console.log(obst); // Ergebnis: ['Banane', 'Orange', 'Ananas']
+```
+
+{% hint style="info" %}
+Die "length"-Eigenschaft wird automatisch aktualisiert, wenn Elemente dem Array hinzugefügt oder daraus entfernt werden.
+{% endhint %}
+
+Es ist auch erwähnenswert, dass die "length"-Eigenschaft keine Methode ist, daher müssen Sie keine Klammern verwenden, wenn Sie darauf zugreifen. Es handelt sich einfach um eine Eigenschaft des Array-Objekts, auf die Sie wie auf jede andere Objekteigenschaft zugreifen können.

de/arrays/map.md

@@ -0,0 +1,47 @@
+---
+Kapitel: 6
+Seitenzahl: 39
+Beschreibung: Die "map"-Methode durchläuft ein Array und ändert seine Elemente mithilfe einer Rückruffunktion. Diese Rückruffunktion wird auf jedes Element des Arrays angewendet.
+---
+# Map
+
+Die Methode `Array.prototype.map()` durchläuft ein Array und ändert seine Elemente mithilfe einer Rückruffunktion. Diese Rückruffunktion wird dann auf jedes Element des Arrays angewendet.
+
+Hier ist die Syntax für die Verwendung von `map`.
+
+```javascript
+let newArray = oldArray.map(function(element, index, array) {
+  // element: aktuell verarbeitetes Element im Array
+  // index: Index des aktuell verarbeiteten Elements im Array
+  // array: das Array, auf dem "map" aufgerufen wurde
+  // Rückgabe des Elements, das zu newArray hinzugefügt werden soll
+});
+```
+
+Beispielsweise nehmen wir an, Sie haben ein Array von Zahlen, und Sie möchten ein neues Array erstellen, das die Werte der Zahlen im ursprünglichen Array verdoppelt. Dies können Sie mithilfe von "map" wie folgt tun.
+
+```javascript
+const zahlen = [2, 4, 6, 8];
+
+const verdoppelteZahlen = zahlen.map(zahl => zahl * 2);
+
+console.log(verdoppelteZahlen);
+
+// Ergebnis: [4, 8, 12, 16]
+```
+
+Sie können auch die Pfeilfunktionssyntax verwenden, um die Funktion, die an "map" übergeben wird, zu definieren.
+
+<pre class="language-typescript"><code class="lang-typescript"><strong>let verdoppelteZahlen = zahlen.map((zahl) => {
+</strong>  return zahl * 2;
+});
+</code></pre>
+oder
+
+```typescript
+let verdoppelteZahlen = zahlen.map(zahl => zahl * 2);
+```
+
+{% hint style="info" %}
+Die "map()"-Methode führt die Funktion nicht für leere Elemente aus und ändert das ursprüngliche Array nicht.
+{% endhint %}

de/arrays/pop.md

@@ -0,0 +1,40 @@
+---
+Kapitel: 6
+Seitenzahl: 42
+Beschreibung: Die "pop"-Methode entfernt das letzte Element aus einem Array und gibt dieses Element zurück. Diese Methode ändert die Länge des Arrays.
+---
+# Pop
+
+Die "pop"-Methode entfernt das letzte Element aus einem Array und gibt dieses Element zurück. Diese Methode ändert die Länge des Arrays.
+
+Hier ist die Syntax für die Verwendung von "pop":
+
+```c
+array.pop();
+```
+
+Beispiel:
+
+```javascript
+let arr = ["eins", "zwei", "drei", "vier", "fünf"];
+arr.pop();
+
+console.log(arr);
+
+// Ergebnis: ['eins', 'zwei', 'drei', 'vier']
+```
+
+Sie können die "pop"-Methode auch in Verbindung mit einer Schleife verwenden, um alle Elemente aus einem Array zu entfernen. Hier ist ein Beispiel, wie Sie dies tun könnten:
+
+```c
+while (array.length > 0) {
+  array.pop();
+}
+
+console.log(array); // Ergebnis: []
+```
+
+{% hint style="warning" %}
+Die "pop"-Methode funktioniert nur bei Arrays und nicht bei anderen Objekten, die Arrays ähneln, wie z.B. Argument-Objekten oder NodeList-Objekten. Wenn Sie Elemente aus einem dieser Arten von Objekten entfernen müssen, müssen Sie es zuerst in ein Array umwandeln, indem Sie die Methode Array.prototype.slice() verwenden.
+
+{% endhint %}

de/arrays/push.md

@@ -0,0 +1,41 @@
+---
+Kapitel: 6
+Seitenzahl: 45
+Beschreibung: Mit der "push"-Methode können bestimmte Elemente am Ende eines Arrays hinzugefügt werden, wobei der letzte Index das neu hinzugefügte Element ist. Dies ändert die Länge des Arrays und gibt eine neue Länge zurück.
+---
+# Push
+
+Mit der "push"-Methode können bestimmte Elemente am Ende eines Arrays hinzugefügt werden, wobei der letzte Index das neu hinzugefügte Element ist. Dies ändert die Länge des Arrays und gibt eine neue Länge zurück.
+
+Hier ist die Syntax für die Verwendung von "push":
+
+```c
+array.push(element1[, ...[, elementN]]);
+```
+
+Die Argumente element1, ..., elementN repräsentieren die Elemente, die am Ende des Arrays hinzugefügt werden sollen.
+
+Beispiel:
+
+```javascript
+let array = [1, 2, 3];
+array.push(4);
+
+console.log(array);
+
+// Ergebnis: array = [1, 2, 3, 4]
+```
+
+Sie können "push" auch verwenden, um Elemente am Ende eines arrayähnlichen Objekts (wie einem Argumente-Objekt oder einem NodeList-Objekt) hinzuzufügen, indem Sie es zuerst in ein Array umwandeln, indem Sie die Methode Array.prototype.slice() verwenden:
+
+```javascript
+function printArguments() {
+  let args = Array.prototype.slice.call(arguments);
+  args.push('d', 'e', 'f');
+  console.log(args);
+}
+
+printArguments('a', 'b', 'c'); // Ergebnis: ["a", "b", "c", "d", "e", "f"]
+```
+
+> **Hinweis**: Die "push"-Methode ändert das ursprüngliche Array. Sie erstellt kein neues Array.

de/arrays/shift.md

@@ -0,0 +1,36 @@
+---
+Kapitel: 6
+Seitenzahl: 41
+Beschreibung: Die "shift"-Methode löscht das erste Indexelement des Arrays und verschiebt alle Indizes nach links. Sie ändert das ursprüngliche Array.
+---
+# Shift
+
+Die "shift"-Methode löscht das erste Indexelement des Arrays und verschiebt alle Indizes nach links. Sie ändert das ursprüngliche Array. Hier ist die Syntax für die Verwendung von "shift":
+
+```c
+array.shift();
+```
+
+Beispiel: 
+
+```javascript
+let array = [1, 2, 3]; 
+array.shift(); 
+
+// Ergebnis: array = [2,3] 
+
+```
+
+Sie können die "shift"-Methode auch in Verbindung mit einer Schleife verwenden, um alle Elemente aus einem Array zu entfernen. Hier ist ein Beispiel, wie Sie dies tun könnten:
+
+```c
+while (array.length > 0) {
+  array.shift();
+}
+
+console.log(array); // Ergebnis: []
+```
+
+{% hint style="warning" %}
+Die "shift"-Methode funktioniert nur bei Arrays und nicht bei anderen Objekten, die Arrays ähneln, wie zum Beispiel Argument-Objekten oder NodeList-Objekten. Wenn Sie Elemente aus einem dieser Arten von Objekten verschieben müssen, müssen Sie es zuerst in ein Array umwandeln, indem Sie die Methode Array.prototype.slice() verwenden.
+{% endhint %}