Skip to content

Commit c317f4d

Browse files
christianhegedueschristianhegedues
authored
Merge branch 'master' into de/07-operators
2 parents 8e945a0 + 6ced657 commit c317f4d

File tree

118 files changed

+963
-694
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

118 files changed

+963
-694
lines changed

‎1-js/01-getting-started/1-intro/article.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ Die Fähigkeiten von JavaScript im Browser sind aus Gründen der Sicherheit des
6363

6464
Beispiele für solche Beschränkungen sind:
6565

66-
- JavaScript auf einer Webebsite darf keine Dateien auf dem Speichermedium lesen, schreiben oder kopieren. Zudem darf es keine Programme ausführen. Es hat keinen direkten Zugriff auf die Funktionen des Betriebsystems.
66+
- JavaScript auf einer Webseite darf keine beliebigen Dateien auf der Festplatte lesen/schreiben, sie kopieren oder Programme ausführen. Es hat keinen direkten Zugriff auf die Funktionen des Betriebssystems.
6767

6868
Moderne Browsers erlauben es mit Dateien zu arbeiten. Der Zugriff ist jedoch beschränkt und nur möglich wenn der Benutzer bestimmte Aktionen ausführt, z.B. die Datei in den Browser per "drag and drop" lädt oder sie via `<input>` tag auswählt.
6969

@@ -73,7 +73,7 @@ Beispiele für solche Beschränkungen sind:
7373
Dies wird die "Same Origin Policy" genannt. Um das zu umgehen, müssen *beide Seiten* für den Datenaustausch übereinstimmen und einen speziellen JavaScript-Code enthalten, der dies behandelt. Wir werden das im Tutorial behandeln.
7474

7575
Auch diese Einschränkung dient der Sicherheit des Benutzers. Eine Seite von `http://anysite.com`, die ein Benutzer geöffnet hat, darf nicht in der Lage sein, auf einen anderen Browser-Tab mit der URL `http://gmail.com` zuzugreifen und Informationen von dort zu stehlen.
76-
- JavaScript kann leicht über das Netz mit dem Server kommunizieren, von dem die aktuelle Seite stammt. Aber seine Fähigkeit, Daten von anderen Seiten/Domains zu empfangen, ist eingeschränkt.
76+
- JavaScript kann leicht über das Netz mit dem Server kommunizieren, von dem die aktuelle Seite stammt. Aber seine Fähigkeit, Daten von anderen Seiten/Domains zu empfangen, ist eingeschränkt.
7777
Obwohl es möglich ist, erfordert es eine ausdrückliche Zustimmung (ausgedrückt in HTTP-Headern) von der entfernten Seite. Auch dies ist eine Sicherheitseinschränkung.
7878

7979
![](limitations.svg)

‎1-js/02-first-steps/01-hello-world/1-hello-alert/index.html‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
<!DOCTYPE html>
2+
<html>
3+
4+
<body>
5+
6+
<script>
7+
alert( "I'm JavaScript!" );
8+
</script>
9+
10+
</body>
11+
12+
</html>

‎1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
2+
[html src="index.html"]

‎1-js/02-first-steps/01-hello-world/article.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ Der `<script>`-Tag beinhaltet JavaScript-Code, welcher automatisch ausgeführt w
4646
Der `<script>`-Tag hat einige Attribute die heutzutage nur selten Verwendung finden, aber noch immer in alten Code vorhanden sind:
4747

4848
Das `type`-Attribute: <code>&lt;script <u>type</u>=...&gt;</code>
49-
: Der alte HTML-Standard, HTML4, setzte bei einem Skript den `Typ` voraus. Üblicherweise war es `type="text/javascript"`. Dies wird nicht länger benötigt. Zudem, der moderne HTML-Standard hat die Bedeutung des Attributs völlig verändert. Jetzt kann es für JavaScript-Module verwendet werden. Aber dies ist ein weiterführendes Thema; wir werden über Module in einem anderen Teil des Tutorials sprechen.
49+
: Der alte HTML-Standard, HTML4, setzte bei einem Skript den `Typ` voraus. Üblicherweise war es `type="text/javascript"`. Dies wird nicht länger benötigt. Zudem, der moderne HTML-Standard hat die Bedeutung des Attributs völlig verändert. Jetzt kann es für JavaScript-Module verwendet werden. Aber dies ist ein weiterführendes Thema, wir werden über Module in einem anderen Teil des Tutorials sprechen.
5050

5151
Das `language`-Attribute: <code>&lt;script <u>language</u>=...&gt;</code>
5252
: Dieses Attribute war gedacht, um die Sprache des Skripts anzuzeigen. Dieses Attribute macht nicht länger Sinn, weil JavaScript die Standard-Sprache ist. Es gibt keinen Grund es zu nutzen.

‎1-js/02-first-steps/02-structure/article.md‎

Lines changed: 71 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -1,159 +1,164 @@
1-
# Code structure
1+
# Code-Struktur
22

3-
The first thing we'll study is the building blocks of code.
3+
Das Erste, was wir untersuchen werden, sind die Bausteine des Codes.
44

5-
## Statements
5+
## Anweisungen
66

7-
Statements are syntax constructs and commands that perform actions.
7+
Anweisungen sind Syntaxkonstrukte und Befehle, die Aktionen ausführen.
88

9-
We've already seen a statement, `alert('Hello, world!')`, which shows the message "Hello, world!".
9+
Wir haben bereits eine Anweisung `alert('Hallo, Welt!')` gesehen, welche die Meldung "Hallo, Welt!" zeigt.
1010

11-
We can have as many statements in our code as we want. Statements can be separated with a semicolon.
11+
Wir können so viele Anweisungen in unserem Code haben, wie wir wollen. Anweisungen können durch ein Semikolon getrennt werden.
1212

13-
For example, here we split "Hello World" into two alerts:
13+
Zum Beispiel teilen wir hier "Hallo Welt" in zwei Warnungen:
1414

1515
```js run no-beautify
16-
alert('Hello'); alert('World');
16+
alert('Hallo'); alert('Welt');
1717
```
1818

19-
Usually, statements are written on separate lines to make the code more readable:
19+
Normalerweise werden Anweisungen in separate Zeilen geschrieben, um den Code besser lesbar zu machen:
2020

2121
```js run no-beautify
22-
alert('Hello');
23-
alert('World');
22+
alert('Hallo');
23+
alert('Welt');
2424
```
2525

26-
## Semicolons [#semicolon]
26+
## Semikolons [#semicolon]
2727

28-
A semicolon may be omitted in most cases when a line break exists.
28+
Ein Semikolon kann in den meisten Fällen weggelassen werden, wenn ein Zeilenumbruch vorliegt.
2929

30-
This would also work:
30+
Das würde auch funktionieren:
3131

3232
```js run no-beautify
33-
alert('Hello')
34-
alert('World')
33+
alert('Hallo')
34+
alert('Welt')
3535
```
3636

37-
Here, JavaScript interprets the line break as an "implicit" semicolon. This is called an [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
37+
Hier interpretiert JavaScript den Zeilenumbruch als "implizites" Semikolon. Dies wird als [automatische Semikoloneinfügung](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion) bezeichnet.
3838

39-
**In most cases, a newline implies a semicolon. But "in most cases" does not mean "always"!**
39+
**In den meisten Fällen bedeutet ein Zeilenumbruch ein Semikolon. "Meistens" heißt aber nicht "immer"!**
4040

41-
There are cases when a newline does not mean a semicolon. For example:
41+
Es gibt Fälle, in denen ein Zeilenumbruch kein Semikolon bedeutet. Beispielsweise:
4242

4343
```js run no-beautify
4444
alert(3 +
4545
1
4646
+ 2);
4747
```
4848

49-
The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so the semicolon is not required. And in this case that works as intended.
49+
Der Code gibt `6` aus, da JavaScript hier keine Semikolons einfügt. Es ist intuitiv klar, dass, wenn die Zeile mit einem Pluszeichen `"+"` endet, es sich um einen "unvollständigen Ausdruck" handelt, sodass das Semikolon nicht erforderlich ist. Und in diesem Fall funktioniert das wie vorgesehen.
5050

51-
**But there are situations where JavaScript "fails" to assume a semicolon where it is really needed.**
51+
**Es gibt jedoch Situationen, in denen JavaScript ein Semikolon nicht annimmt, wenn es wirklich benötigt wird.**
5252

53-
Errors which occur in such cases are quite hard to find and fix.
53+
Fehler, die in solchen Fällen auftreten, sind schwer zu finden und zu beheben.
5454

55-
````smart header="An example of an error"
56-
If you're curious to see a concrete example of such an error, check this code out:
55+
````smart header="Ein Beispiel für einen Fehler"
56+
Wenn du ein konkretes Beispiel für einen solchen Fehler sehen möchten, lies den folgenden Code:
5757
5858
```js run
5959
[1, 2].forEach(alert)
6060
```
6161
62-
No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of the code: it shows `1` then `2`.
62+
Über die Bedeutung der Klammern `[]` und `forEach` muss noch nicht nachgedacht werden. Wir werden sie später studieren. Denk vorerst nur an das Ergebnis des Codes: Es zeigt `1`, dann `2`.
6363
64-
Now, let's add an `alert` before the code and *not* finish it with a semicolon:
64+
Fügen wir nun vor dem Code einen `alert` ein und beenden ihn *nicht* mit einem Semikolon:
6565
6666
```js run no-beautify
67-
alert("There will be an error")
67+
alert("Es wird ein Fehler auftreten")
6868
6969
[1, 2].forEach(alert)
7070
```
7171
72-
Now if we run the code, only the first `alert` is shown and then we have an error!
72+
Wenn wir nun den Code ausführen, wird nur der erste `alert` angezeigt und dann haben wir einen Fehler!
7373
74-
But everything is fine again if we add a semicolon after `alert`:
74+
Aber alles ist wieder in Ordnung, wenn wir nach `alert` ein Semikolon einfügen:
7575
```js run
76-
alert("All fine now");
76+
alert("Jetzt ist alles in Ordnung");
7777
78-
[1, 2].forEach(alert)
78+
[1, 2].forEach(alert)
7979
```
8080
81-
Now we have the "All fine now" message followed by `1` and `2`.
81+
Jetzt haben wir die Nachricht "Jetzt ist alles in Ordnung" gefolgt von `1` und `2`.
8282
8383
84-
The error in the no-semicolon variant occurs because JavaScript does not assume a semicolon before square brackets `[...]`.
84+
Der Fehler in der Variante ohne Semikolon tritt auf, weil JavaScript kein Semikolon vor eckigen Klammern `[...]` annimmt.
8585
86-
So, because the semicolon is not auto-inserted, the code in the first example is treated as a single statement. Here's how the engine sees it:
86+
Da das Semikolon nicht automatisch eingefügt wird, wird der Code im ersten Beispiel als einzelne Anweisung behandelt. So sieht es die Engine:
8787
8888
```js run no-beautify
89-
alert("There will be an error")[1, 2].forEach(alert)
89+
alert("Es wird ein Fehler auftreten")[1, 2].forEach(alert)
9090
```
9191
92-
But it should be two separate statements, not one. Such a merging in this case is just wrong, hence the error. This can happen in other situations.
92+
Aber es sollten zwei getrennte Anweisungen sein, nicht eine. Eine solche Verschmelzung ist in diesem Fall einfach falsch, daher der Fehler. Dies kann auch in anderen Situationen auftreten.
9393
````
9494

95-
We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
95+
Es wird empfohlen, Semikolons zwischen Anweisungen zu setzen, auch wenn diese durch Zeilenumbrüche getrennt sind. Diese Regel wird von der Community weitgehend übernommen. Lass uns noch einmal festhalten -- es ist möglich, Semikolons die meiste Zeit wegzulassen. Aber es ist sicherer -- besonders für Anfänger -- sie zu benutzen.
9696

97-
## Comments
97+
## Kommentare [#code-comments]
9898

99-
As time goes on, programs become more and more complex. It becomes necessary to add *comments* which describe what the code does and why.
99+
Mit der Zeit werden Programme immer komplexer. Es müssen *Kommentare* hinzugefügt werden, die beschreiben, was der Code macht und warum.
100100

101-
Comments can be put into any place of a script. They don't affect its execution because the engine simply ignores them.
101+
Kommentare können an jeder Stelle eines Skripts eingefügt werden. Sie haben keinen Einfluss auf die Ausführung, da die Engine sie einfach ignoriert.
102102

103-
**One-line comments start with two forward slash characters `//`.**
103+
**Einzeilige Kommentare beginnen mit zwei Schrägstrichen `//`.**
104104

105-
The rest of the line is a comment. It may occupy a full line of its own or follow a statement.
105+
Der Rest der Zeile ist ein Kommentar. Er kann eine ganze eigene Zeile belegen oder einer Anweisung folgen.
106106

107-
Like here:
107+
Wie hier:
108108
```js run
109-
// This comment occupies a line of its own
110-
alert('Hello');
109+
// Dieser Kommentar belegt eine eigene Zeile
110+
alert('Hallo');
111111

112-
alert('World'); // This comment follows the statement
112+
alert('Welt'); // Dieser Kommentar folgt der Anweisung
113113
```
114114

115-
**Multiline comments start with a forward slash and an asterisk <code>/&#42;</code> and end with an asterisk and a forward slash <code>&#42;/</code>.**
115+
**Mehrzeilige Kommentare beginnen mit einem Schrägstrich und einem Sternchen <code>/&#42;</code> und enden mit einem Sternchen und einem Schrägstrich <code>&#42;/</code>.**
116116

117-
Like this:
117+
So wie hier:
118118

119119
```js run
120-
/* An example with two messages.
121-
This is a multiline comment.
120+
/* Ein Beispiel mit zwei Nachrichten.
121+
Dies ist ein mehrzeiliger Kommentar.
122122
*/
123-
alert('Hello');
124-
alert('World');
123+
alert('Hallo');
124+
alert('Welt');
125125
```
126126

127-
The content of comments is ignored, so if we put code inside <code>/&#42; ... &#42;/</code>, it won't execute.
127+
Der Inhalt von Kommentaren wird ignoriert. Wenn wir also Code innerhalb <code>/&#42; ... &#42;/</code> einfügen, wird er nicht ausgeführt.
128128

129-
Sometimes it can be handy to temporarily disable a part of code:
129+
Manchmal kann es nützlich sein, einen Teil des Codes vorübergehend zu deaktivieren:
130130

131131
```js run
132-
/* Commenting out the code
133-
alert('Hello');
132+
/* Code auskommentieren
133+
alert('Hallo');
134134
*/
135-
alert('World');
135+
alert('Welt');
136136
```
137137

138+
<<<<<<< HEAD
139+
```smart header="Benutze Tastenkombination!"
140+
In den meisten Editoren kannst du eine Codezeile auskommentieren, indem du die Tastenkombination `key:Strg+/` für einen einzeiligen Kommentar und die Tastenkombination `key:Strg+Umschalt+/` für mehrzeilige Kommentare drückst (wähle ein Stück Code aus und drücke die Tastenkombination). Für Mac versuche "key:Cmd" anstelle von "key:Strg" und `key:Option` statt `key:Umschalt`.
141+
=======
138142
```smart header="Use hotkeys!"
139-
In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl`.
143+
In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl` and `key:Option` instead of `key:Shift`.
144+
>>>>>>> 23ffde780605b3418101850a61d9496c3d7f927c
140145
```
141146

142-
````warn header="Nested comments are not supported!"
143-
There may not be `/*...*/` inside another `/*...*/`.
147+
````warn header="Verschachtelte Kommentare werden nicht unterstützt!"
148+
Es ist nicht möglich `/*...*/` innerhalb eines anderen `/*...*/` zu setzen.
144149
145-
Such code will die with an error:
150+
Solcher Code resultiert in einem Fehler:
146151
147152
```js run no-beautify
148153
/*
149-
/* nested comment ?!? */
154+
/* verschachtelter Kommentar ?!? */
150155
*/
151-
alert( 'World' );
156+
alert( 'Welt' );
152157
```
153158
````
154159

155-
Please, don't hesitate to comment your code.
160+
Bitte zögere nicht, deinen Code zu kommentieren.
156161

157-
Comments increase the overall code footprint, but that's not a problem at all. There are many tools which minify code before publishing to a production server. They remove comments, so they don't appear in the working scripts. Therefore, comments do not have negative effects on production at all.
162+
Kommentare vergrößern den gesamten Code-Fussabdruck, aber das ist überhaupt kein Problem. Es gibt viele Werkzeuge, die den Code vor dem Veröffentlichen auf einem Produktionsserver minimieren. Sie entfernen Kommentare, sodass sie nicht in den Arbeitsskripten angezeigt werden. Kommentare wirken sich daher überhaupt nicht negativ auf die Produktion aus.
158163

159-
Later in the tutorial there will be a chapter <info:code-quality> that also explains how to write better comments.
164+
Später im Tutorial wird es ein Kapitel <info:code-quality> geben, in dem auch erklärt wird, wie man bessere Kommentare schreibt.

0 commit comments

Comments
 (0)