Skip to content

Commit a225873

Browse files
jakeherpjakeherp
authored
Questions 64-69 added
1 parent 6a7b94b commit a225873

File tree

1 file changed

+224
-10
lines changed

1 file changed

+224
-10
lines changed

‎README-de_DE.md

+224-10
Original file line numberDiff line numberDiff line change
@@ -6,16 +6,21 @@ Von einfach bis fortgeschritten: teste wie gut du JavaScript kennst, frische dei
66

77
Die Antworten sind unterhalb der Fragen versteckt. Du kannst einfach darauf klicken um die Antworten anzuzeigen. Viel Glück :heart:
88

9-
### Andere verfügbare Sprachen
10-
[English](./README.md) <br />
11-
[Bosanski Jezik](./README-bs_BS.md) <br />
12-
[日本語](./README-ja_JA.md) <br />
13-
[한국어](./README-ko_KR.md) <br />
14-
[Português Brasil](./README_pt_BR.md) <br />
15-
[Русский](./README_ru-RU.md) <br />
16-
[Українська мова](./README-ua_UA.md) <br />
17-
[Tiếng Việt](./README-vi.md) <br />
18-
[中文版本](./README-zh_CN.md) <br />
9+
### Alle verfügbaren Sprachen
10+
* [English](./README.md)
11+
* [العربية](./README_AR.md)
12+
* [اللغة العامية - Egyptian Arabic](./README_ar-EG.md)
13+
* [Bosanski](./README-bs_BS.md)
14+
* [Deutsch](./README-de_DE.md)
15+
* [Español](./README-ES.md)
16+
* [日本語](./README-ja_JA.md)
17+
* [한국어](./README-ko_KR.md)
18+
* [Português Brasil](./README_pt_BR.md)
19+
* [Русский](./README_ru-RU.md)
20+
* [Türkçe](./README-tr_TR.md)
21+
* [Українська мова](./README-ua_UA.md)
22+
* [Tiếng Việt](./README-vi.md)
23+
* [中文版本](./README-zh_CN.md)
1924

2025
---
2126

@@ -1956,3 +1961,212 @@ Der unäre Operator `++` _gibt zuerst_ den Wert des Operanden aus und _erhöht d
19561961

19571962
</p>
19581963
</details>
1964+
1965+
1966+
1967+
---
1968+
1969+
###### <a name=20190707></a>64. Was ist der Output?
1970+
1971+
```javascript
1972+
const value = { number: 10 };
1973+
1974+
const multiply = (x = { ...value }) => {
1975+
console.log((x.number * 2));
1976+
};
1977+
1978+
multiply();
1979+
multiply();
1980+
multiply(value);
1981+
multiply(value);
1982+
```
1983+
1984+
- A: `20`, `40`, `80`, `160`
1985+
- B: `20`, `40`, `20`, `40`
1986+
- C: `20`, `20`, `20`, `40`
1987+
- D: `NaN`, `NaN`, `20`, `40`
1988+
1989+
<details><summary><b>Antwort</b></summary>
1990+
<p>
1991+
1992+
#### Antwort: C
1993+
1994+
In ES6 können wir Parameter mit einem Standardwert initialisieren. Der Wert des Parameters wird als Standard gesetzt, wenn kein anderer Wert übergeben wird oder der Wert des Parameters `"undefined"` ist. In diesem Fall verteilen wir die Properties von `value` in einem neuen Objekt, sodass `x` den Standardwert `{ number: 10 }` bekommt.
1995+
1996+
Das Standard Argument wird beim _Aufruf_ evaluiert. Jedes Mal, wenn wir die Funktion aufrufen, wird ein _neues_ Objekt erstellt. Wir rufen die `multiply` Funktion die ersten beiden Male auf ohne einen Wert zu übergeben: `x` hat daher den Standardwert `{ number: 10 }`. Wir loggen dann den multiplizierten Wert davon, sodass wir `20` bekommen.
1997+
1998+
Beim dritten Mal wird die `multiply` Funktion mit einem Argument für `value` aufgerufen. Der `*=` Operator ist kurz für `x.number = x.number * 2`: wir ändern den Wert von `x.number` und loggen den multiplizierten Wert `20`.
1999+
2000+
Beim vierten Mal übergeben wir wieder eine `value`. `x.number` wurde zuvor in `20` geändert, sodass `x.number *= 2` jetzt `40` loggt.
2001+
2002+
</p>
2003+
</details>
2004+
2005+
---
2006+
2007+
###### 65. Was ist der Output?
2008+
2009+
```javascript
2010+
[1, 2, 3, 4].reduce((x, y) => console.log(x, y));
2011+
```
2012+
2013+
- A: `1` `2` and `3` `3` and `6` `4`
2014+
- B: `1` `2` and `2` `3` and `3` `4`
2015+
- C: `1` `undefined` and `2` `undefined` and `3` `undefined` and `4` `undefined`
2016+
- D: `1` `2` and `undefined` `3` and `undefined` `4`
2017+
2018+
<details><summary><b>Antwort</b></summary>
2019+
<p>
2020+
2021+
#### Antwort: D
2022+
2023+
Das erste Argument, welches die `reduce` Methode erhält ist der _Akkumulator_ `x`. Das zweite Argument ist der _aktuelle Wert_, `y`. Durch die `reduce` Methode führen wir eine Callback Funktion an jedem Element des Arrays aus, was im Endeffekt einen einzelnen Wert ausgibt.
2024+
2025+
In diesem Beispiel geben wir nicht irgendwelche Werte aus, sondern loggen einfach nur den Akkumulator und den momentanen Wert.
2026+
2027+
Der Wert des Akkumulators ist gleich dem vorhergehenden Wert der Callback Funktion. Wenn wir `initialValue` nicht an die `reduce` Methode übergeben bleibt der Akkumulator gleich dem ersten Element des ersten Calls.
2028+
2029+
Beim ersten Call ist der Akkumulator (`x`) gleich `1` und der aktuelle Wert (`y`) ist `2`. Da wir in der Callback Funktion bleiben loggen wir den Akkumulator und den aktuellen Wert: `1` und `2`.
2030+
2031+
Wenn wir keinen Wert einer Funktion ausgeben wird `undefined` ausgegeben. Beim nächsten Call ist der Akkumulator daher `undefined` und der aktuelle Wert ist `3`. `undefined` und `3` werden geloggt.
2032+
2033+
Beim vierten Call geben wir wieder nichts aus, sodass der Akkumulator wieder `undefined` ist und der aktuelle Wert `4`. `undefined` und `4` werden geloggt.
2034+
</p>
2035+
</details>
2036+
2037+
---
2038+
2039+
###### 66. Mit welchem Constructor können wir die `Dog` Klasse erweitern?
2040+
2041+
```javascript
2042+
class Dog {
2043+
constructor(name) {
2044+
this.name = name;
2045+
}
2046+
};
2047+
2048+
class Labrador extends Dog {
2049+
// 1
2050+
constructor(name, size) {
2051+
this.size = size;
2052+
}
2053+
// 2
2054+
constructor(name, size) {
2055+
super(name);
2056+
this.size = size;
2057+
}
2058+
// 3
2059+
constructor(size) {
2060+
super(name);
2061+
this.size = size;
2062+
}
2063+
// 4
2064+
constructor(name, size) {
2065+
this.name = name;
2066+
this.size = size;
2067+
}
2068+
2069+
};
2070+
```
2071+
2072+
- A: 1
2073+
- B: 2
2074+
- C: 3
2075+
- D: 4
2076+
2077+
<details><summary><b>Antwort</b></summary>
2078+
<p>
2079+
2080+
#### Antwort: B
2081+
2082+
In einer abgeleiteten Klasse kann das `this` Keyword nicht aufgerufen werden, bevor `super` aufgerufen wurde. Wenn man das versucht wird ein ReferenceError ausgeworfen: 1 und 4 würden daher einen Referenz-Fehler ausgeben.
2083+
2084+
Mit dem `super` Keyword können wir den Constructor der Elternklasse mit gegebenen Argumenten aufrufen. Der Constructor der Elternklasse erhält das `name` Argument, sodass wir `name` an `super` übergeben müssen.
2085+
2086+
Die `Dog` Klasse erhält zwei Argumente, `name` da es `Animal` erweitert und `size` als extra Property der `Dog` Klasse. Beide müssen an die Constructor Funktion von `Dog` übergeben werden, was nur bei Constructor 2 richtig ist.
2087+
</p>
2088+
</details>
2089+
2090+
---
2091+
2092+
###### 67. Mit welchem Constructor können wir die `Dog` Klasse erweitern?
2093+
2094+
```javascript
2095+
// index.js
2096+
console.log('running index.js);
2097+
import { sum } from './sum.js';
2098+
console.log(sum(1, 2));
2099+
2100+
// sum.js
2101+
console.log('running sum.js');
2102+
export const sum = (a, b) => a + b;
2103+
```
2104+
2105+
- A: `running index.js`, `running sum.js`, `3`
2106+
- B: `running sum.js`, `running index.js`, `3`
2107+
- C: `running sum.js`, `3`, `running index.js`
2108+
- D: `running index.js`, `undefined`, `running sum.js`
2109+
2110+
<details><summary><b>Antwort</b></summary>
2111+
<p>
2112+
2113+
#### Antwort: B
2114+
2115+
Mit dem `import` Keyword werden alle importierten Module _vorgeparsed_. Das bedeutet, dass importierte Module _zuerst_ ausgeführt werden, der Code in der eigentlichen Datei wird _danach_ ausgeführt.
2116+
2117+
Das ist der große Unterschied zwischen `require()` in CommonJS und `import`. Mit `require()` können Dependencies bei Bedarf geladen werden, während der Code ausgeführt wird. Hätten wir `require()` anstelle von `import` verwendet, wäre `running index.js`, `running sum.js`, `3` in der Konsole geloggt worden.
2118+
2119+
</p>
2120+
</details>
2121+
2122+
---
2123+
2124+
###### 68. Was ist der Output?
2125+
2126+
```javascript
2127+
console.log(Number(2) === Number(2))
2128+
console.log(Boolean(false) === Boolean(false))
2129+
console.log(Symbol('foo') === Symbol('foo'))
2130+
```
2131+
2132+
- A: `true`, `true`, `false`
2133+
- B: `false`, `true`, `false`
2134+
- C: `true`, `false`, `true`
2135+
- D: `true`, `true`, `true`
2136+
2137+
<details><summary><b>Antwort</b></summary>
2138+
<p>
2139+
2140+
#### Antwort: A
2141+
2142+
Jedes Symbol ist eindeutig. Der Sinn des Argumentes, welches an das Symbol weitergegeben wird, ist dem Symbol eine Beschreibung zu geben. Der Wert des Symbols hängt nicht von diesem Argument ab. Beim vergleichen der Symbole werden zwei komplett neue Symbole erstellt: das erste `Symbol('foo')` und das zweite `Symbol('foo')`. Diese beiden Werte sind eindeutig und nicht identisch, weshalb `Symbol('foo') === Symbol('foo')` `false` ausgibt.
2143+
2144+
</p>
2145+
</details>
2146+
2147+
---
2148+
2149+
###### 69. Was ist der Output?
2150+
2151+
```javascript
2152+
const name = "Lydia Hallie"
2153+
console.log(name.padStart(13))
2154+
console.log(name.padStart(2))
2155+
```
2156+
2157+
- A: `"Lydia Hallie"`, `"Lydia Hallie"`
2158+
- B: `" Lydia Hallie"`, `" Lydia Hallie"` (`"[13x whitespace]Lydia Hallie"`, `"[2x whitespace]Lydia Hallie"`)
2159+
- C: `" Lydia Hallie"`, `"Lydia Hallie"` (`"[1x whitespace]Lydia Hallie"`, `"Lydia Hallie"`)
2160+
- D: `"Lydia Hallie"`, `"Lyd"`,
2161+
2162+
<details><summary><b>Antwort</b></summary>
2163+
<p>
2164+
2165+
#### Antwort: C
2166+
2167+
Mit der `padStart` Methode können wir Padding am Anfang des Strings hinzufügen. Der Wert, der an die Methode übergeben wird ist die _absolute_ Länge des Strings mit dem Padding. Der String `"Lydia Hallie"` hat eine Länge von `12`. `name.padStart(13)` fügt ein Leerzeichen am Anfang des Strings ein, weil 12 + 1 = 13 ist.
2168+
2169+
Falls der Wert, der an `padStart` übergeben wurde kleiner ist, als die Länge des Arrays, so wird kein Padding hinzugefügt.
2170+
2171+
</p>
2172+
</details>

0 commit comments

Comments
 (0)