Merge pull request #10 from SibianDG/variables

iliakan · web-flow · commit 951bfafed627 · 2020-10-17T22:58:53.000+03:00
Variables
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/index.html b/1-js/02-first-steps/01-hello-world/1-hello-alert/index.html
@@ -4,9 +4,9 @@
 <body>
 
   <script>
-    alert( "I'm JavaScript!" );
+    alert( "Ik ben JavaScript!" );
   </script>
 
 </body>
 
-</html>
+</html>
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md b/1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md
@@ -1,2 +1,2 @@
-
-[html src="index.html"]
+
+[html src="index.html"]
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/solution.view/index.html b/1-js/02-first-steps/01-hello-world/1-hello-alert/solution.view/index.html
@@ -4,7 +4,7 @@
 <body>
 
   <script>
-    alert( "I'm JavaScript!" );
+    alert( "Ik ben JavaScript!" );
   </script>
 
 </body>
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
@@ -1,12 +1,8 @@
-importance: 5
+# Toon een waarschuwing
 
----
+Maak een pagina aan met een bericht "Ik ben JavaScript!".
 
-# Show an alert
-
-Create a page that shows a message "I'm JavaScript!".
-
-Do it in a sandbox, or on your hard drive, doesn't matter, just ensure that it works.
+Doe het in een zandbak, of op je harde schijf, maakt niet uit, zorg er gewoon voor dat het werkt.
 
 [demo src="solution"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/alert.js b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/alert.js
@@ -1 +1 @@
-alert("I'm JavaScript!");
+alert ("Ik ben JavaScript!");
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
@@ -1,8 +1,8 @@
-The HTML code:
+De HTML-code:
 
 [html src="index.html"]
 
-For the file `alert.js` in the same folder:
+Voor het bestand `alert.js` in dezelfde map:
 
 [js src="alert.js"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
@@ -1,9 +1,5 @@
-importance: 5
+# Toon een waarschuwing met een extern script
 
----
+Neem de oplossing van de vorige taak <info:task/hello-alert>. Wijzig het door de inhoud van het script uit te pakken in een extern bestand `alert.js`, dat zich in dezelfde map bevindt.
 
-# Show an alert with an external script
-
-Take the solution of the previous task <info:task/hello-alert>. Modify it by extracting the script content into an external file `alert.js`, residing in the same folder.
-
-Open the page, ensure that the alert works.
+Open de pagina, zorg ervoor dat de waarschuwing werkt.
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
@@ -1,132 +1,132 @@
-# Hello, world!
+# Hallo, wereld!
 
-This part of the tutorial is about core JavaScript, the language itself.
+Dit deel van de tutorial gaat over de kern van JavaScript, de taal zelf.
 
-But we need a working environment to run our scripts and, since this book is online, the browser is a good choice. We'll keep the amount of browser-specific commands (like `alert`) to a minimum so that you don't spend time on them if you plan to concentrate on another environment (like Node.js). We'll focus on JavaScript in the browser in the [next part](/ui) of the tutorial.
+Maar we hebben een werkomgeving nodig om onze scripts uit te voeren en aangezien dit boek online is, is de browser een goede keuze. We zullen de hoeveelheid browser-specifieke commando's (zoals `alert`) tot een minimum beperken zodat je er geen tijd aan besteedt als je van plan bent je te concentreren op een andere omgeving (zoals Node.js). We zullen ons concentreren op JavaScript in de browser in het [next part](/ui) van de tutorial.
 
-So first, let's see how we attach a script to a webpage. For server-side environments (like Node.js), you can execute the script with a command like `"node my.js"`.
+Dus laten we eerst eens kijken hoe we een script aan een webpagina koppelen. Voor server-side omgevingen (zoals Node.js) kun je het script uitvoeren met een commando als `"node my.js"`.
 
 
-## The "script" tag
+## De "script" tag
 
-JavaScript programs can be inserted into any part of an HTML document with the help of the `<script>` tag.
+JavaScript-programma's kunnen in elk deel van een HTML-document worden ingevoegd met behulp van de `<script>`-tag.
 
-For instance:
+Bijvoorbeeld:
 
 ```html run height=100
 <!DOCTYPE HTML>
 <html>
 
 <body>
 
-  <p>Before the script...</p>
+  <p>Voor het script...</p>
 
 *!*
   <script>
-    alert( 'Hello, world!' );
+    alert( 'Hallo, wereld!' );
   </script>
 */!*
 
-  <p>...After the script.</p>
+  <p>...Na het script.</p>
 
 </body>
 
 </html>
 ```
 
 ```online
-You can run the example by clicking the "Play" button in the right-top corner of the box above.
+U kunt het voorbeeld uitvoeren door te klikken op de knop "Afspelen" in de rechterbovenhoek van het vak hierboven.
 ```
 
-The `<script>` tag contains JavaScript code which is automatically executed when the browser processes the tag.
+Het `<script>`-tag bevat JavaScript-code die automatisch wordt uitgevoerd wanneer de browser de tag verwerkt.
 
 
-## Modern markup
+## Moderne opmaak
 
-The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
+Het `<script>` tag heeft een aantal attributen die tegenwoordig zelden gebruikt worden, maar nog wel in oude code te vinden zijn:
 
-The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
-: The old HTML standard, HTML4, required a script to have a `type`. Usually it was `type="text/javascript"`. It's not required anymore. Also, the modern HTML standard totally changed the meaning of this attribute. Now, it can be used for JavaScript modules. But that's an advanced topic, we'll talk about modules in another part of the tutorial.
+Het `type`-attribuut: <code>&lt;script <u>type</u>=...&gt;</code>
+: De oude HTML-standaard, HTML4, vereiste een script om een `type` te hebben. Meestal was het `type="tekst/javascript"`. Het is niet meer nodig. Ook de moderne HTML-standaard heeft de betekenis van dit attribuut totaal veranderd. Nu kan het gebruikt worden voor JavaScript-modules. Maar dat is een geavanceerd onderwerp, we zullen het in een ander deel van de tutorial over modules hebben.
 
-The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
-: This attribute was meant to show the language of the script. This attribute no longer makes sense because JavaScript is the default language. There is no need to use it.
+Het `taal`-attribuut: <code>&lt;script <u>taal</u>=...&gt;</code>
+: Dit attribuut was bedoeld om de taal van het script te laten zien. Dit attribuut heeft geen zin meer omdat JavaScript de standaard taal is. Het is niet nodig om het te gebruiken.
 
-Comments before and after scripts.
-: In really ancient books and guides, you may find comments inside `<script>` tags, like this:
+Commentaar voor en na scripts.
+: In echt oude boeken en gidsen vind je misschien commentaar in `<script>`-tags, zoals deze:
 
     ```html no-beautify
-    <script type="text/javascript"><!--
+    <script type="tekst/javascript"><! --
         ...
     //--></script>
     ```
 
-    This trick isn't used in modern JavaScript. These comments hide JavaScript code from old browsers that didn't know how to process the `<script>` tag. Since browsers released in the last 15 years don't have this issue, this kind of comment can help you identify really old code.
+    Deze truc wordt niet gebruikt in moderne JavaScript. Deze commentaren verbergen JavaScript-code voor oude browsers die niet wisten hoe ze de `<script>`-tag moesten verwerken. Aangezien browsers die in de afgelopen 15 jaar zijn uitgebracht dit probleem niet hebben, kan dit soort commentaar u helpen bij het identificeren van echt oude code.
 
 
-## External scripts
+## Externe scripts
 
-If we have a lot of JavaScript code, we can put it into a separate file.
+Als we veel JavaScript-code hebben, kunnen we die in een apart bestand zetten.
 
-Script files are attached to HTML with the `src` attribute:
+Scriptbestanden worden aan HTML gekoppeld met het `src` attribuut:
 
 ```html
-<script src="/path/to/script.js"></script>
+<script src="/pad/naar/script.js"></script>
 ```
 
-Here, `/path/to/script.js` is an absolute path to the script from the site root. One can also provide a relative path from the current page. For instance, `src="script.js"` would mean a file `"script.js"` in the current folder.
+Hier is `/pad/naar/script.js` een absoluut pad naar het script vanuit de site-root. Men kan ook een relatief pad van de huidige pagina opgeven. Bijvoorbeeld, `src="script.js "betekent een bestand `"script.js"` in de huidige map.
 
-We can give a full URL as well. For instance:
+We kunnen ook een volledige URL geven. Bijvoorbeeld:
 
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 ```
 
-To attach several scripts, use multiple tags:
+Om meerdere scripts te bevestigen, gebruik je meerdere tags:
 
 ```html
 <script src="/js/script1.js"></script>
 <script src="/js/script2.js"></script>
 …
 ```
 
-```smart
-As a rule, only the simplest scripts are put into HTML. More complex ones reside in separate files.
+```slimme
+In de regel worden alleen de eenvoudigste scripts in HTML gezet. Complexere scripts staan in aparte bestanden.
 
-The benefit of a separate file is that the browser will download it and store it in its [cache](https://en.wikipedia.org/wiki/Web_cache).
+Het voordeel van een apart bestand is dat de browser het downloadt en opslaat in zijn [cache](https://en.wikipedia.org/wiki/Web_cache).
 
-Other pages that reference the same script will take it from the cache instead of downloading it, so the file is actually downloaded only once.
+Andere pagina's die naar hetzelfde script verwijzen zullen het uit de cache halen in plaats van het te downloaden, zodat het bestand eigenlijk maar één keer wordt gedownload.
 
-That reduces traffic and makes pages faster.
+Dat vermindert het verkeer en maakt de pagina's sneller.
 ```
 
-````warn header="If `src` is set, the script content is ignored."
-A single `<script>` tag can't have both the `src` attribute and code inside.
+````warn header="Als `src` is ingesteld, wordt de inhoud van het script genegeerd."
+Een enkele `<script>` tag kan niet zowel het `src` attribuut als de code bevatten.
 
-This won't work:
+Dit werkt niet:
 
 ```html
-<script *!*src*/!*="file.js">
-  alert(1); // the content is ignored, because src is set
+<script *! *src*/! *="file.js">
+  waarschuwing(1); // de inhoud wordt genegeerd, omdat src is ingesteld
 </script>
 ```
 
-We must choose either an external `<script src="…">` or a regular `<script>` with code.
+We moeten kiezen voor een externe `<script src="...">" of een gewone `<script>` met code.
 
-The example above can be split into two scripts to work:
+Het bovenstaande voorbeeld kan worden opgesplitst in twee scripts om te werken:
 
 ```html
-<script src="file.js"></script>
+<script src="bestand.js"></script>
 <script>
-  alert(1);
+  waarschuwing(1);
 </script>
 ```
 ````
 
-## Summary
+## Samenvatting
 
-- We can use a `<script>` tag to add JavaScript code to a page.
-- The `type` and `language` attributes are not required.
-- A script in an external file can be inserted with `<script src="path/to/script.js"></script>`.
+- We kunnen een `<script>` tag gebruiken om JavaScript-code toe te voegen aan een pagina.
+- De `type` en `taal` attributen zijn niet nodig.
+- Een script in een extern bestand kan worden ingevoegd met `<script src="path/to/script.js"></script>`.
 
 
-There is much more to learn about browser scripts and their interaction with the webpage. But let's keep in mind that this part of the tutorial is devoted to the JavaScript language, so we shouldn't distract ourselves with browser-specific implementations of it. We'll be using the browser as a way to run JavaScript, which is very convenient for online reading, but only one of many.
+Er is nog veel meer te leren over browserscripts en hun interactie met de webpagina. Maar laten we niet vergeten dat dit deel van de tutorial gewijd is aan de JavaScript-taal, dus we moeten onszelf niet afleiden met browser-specifieke implementaties ervan. We zullen de browser gebruiken als een manier om JavaScript uit te voeren, wat erg handig is voor online lezen, maar slechts één van de vele.
diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
@@ -1,12 +1,11 @@
-In the code below, each line corresponds to the item in the task list.
+In de onderstaande code komt elke regel overeen met het item in de takenlijst.
 
 ```js run
-let admin, name; // can declare two variables at once
+let admin, naam; // kan twee variabelen tegelijk aangeven
 
-name = "John";
+naam = "John";
 
-admin = name;
+admin = naam;
 
 alert( admin ); // "John"
-```
-
+```
diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/task.md b/1-js/02-first-steps/04-variables/1-hello-variables/task.md
@@ -1,10 +1,6 @@
-importance: 2
+# Werken met variabelen
 
----
-
-# Working with variables
-
-1. Declare two variables: `admin` and `name`.
-2. Assign the value `"John"` to `name`.
-3. Copy the value from `name` to `admin`.
-4. Show the value of `admin` using `alert` (must output "John").
+1. Verklaar twee variabelen: `admin` en `naam`.
+2. Wijs de waarde `"John"` toe aan `naam`.
+3. Kopieer de waarde van `naam` naar `admin`.
+4. Toon de waarde van `admin` met behulp van `alert` (moet "John" aangeven).
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
@@ -1,21 +1,21 @@
-## The variable for our planet
+## De variabele voor onze planeet
 
-That's simple:
+Dat is eenvoudig:
 
 ```js
-let ourPlanetName = "Earth";
+let onzePlanetNaam = "Aarde";
 ```
 
-Note, we could use a shorter name `planet`, but it might be not obvious what planet it refers to. It's nice to be more verbose. At least until the variable isNotTooLong.
+Let wel, we zouden een kortere naam `planeet` kunnen gebruiken, maar het is misschien niet duidelijk naar welke planeet het verwijst. Het is leuk om meer woorden te gebruiken. Tenminste tot de variabeleNietTeLang is.
 
-## The name of the current visitor
+## De naam van de huidige bezoeker
 
 ```js
 let currentUserName = "John";
 ```
 
-Again, we could shorten that to `userName` if we know for sure that the user is current.
+Nogmaals, we zouden dat kunnen inkorten tot `userName` als we zeker weten dat de gebruiker actueel is.
 
-Modern editors and autocomplete make long variable names easy to write. Don't save on them. A name with 3 words in it is fine.
+Moderne editors en autocompleteurs maken lange variabele namen gemakkelijk te schrijven. Bespaar er niet op. Een naam met 3 woorden is prima.
 
-And if your editor does not have proper autocompletion, get [a new one](/code-editors).
+En als je editors geen goede autocompletion heeft, haal dan [een nieuwe](/code-editors).
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/task.md b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
@@ -1,8 +1,4 @@
-importance: 3
+# Het geven van de juiste naam
 
----
-
-# Giving the right name
-
-1. Create a variable with the name of our planet. How would you name such a variable?
-2. Create a variable to store the name of a current visitor to a website. How would you name that variable?
+1. Creëer een variabele met de naam van onze planeet. Hoe zou je zo'n variabele noemen?
+2. Maak een variabele aan om de naam van een huidige bezoeker van een website op te slaan. Hoe zou u die variabele een naam geven?
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
@@ -1,5 +1,5 @@
-We generally use upper case for constants that are "hard-coded". Or, in other words, when the value is known prior to execution and directly written into the code.
+We gebruiken over het algemeen hoofdletters voor constanten die "hard-coded" zijn. Of, met andere woorden, wanneer de waarde voorafgaand aan de uitvoering bekend is en direct in de code wordt geschreven.
 
-In this code, `birthday` is exactly like that. So we could use the upper case for it.
+In deze code is `birthday` precies zo. We zouden dus de hoofdletters kunnen gebruiken.
 
-In contrast, `age` is evaluated in run-time. Today we have one age, a year after we'll have another one. It is constant in a sense that it does not change through the code execution. But it is a bit "less of a constant" than `birthday`: it is calculated, so we should keep the lower case for it.
+Daarentegen wordt `leeftijd` geëvalueerd in run-time. Vandaag hebben we één leeftijd, een jaar nadat we een andere zullen hebben. Het is constant in zekere zin dat het niet verandert door de uitvoering van de code. Maar het is een beetje "minder constant" dan `verjaardag`: het is berekend, dus we moeten de kleine letters ervoor houden.
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
@@ -1,24 +1,19 @@
-importance: 4
+# Uppercase constante?
 
----
-
-# Uppercase const?
-
-Examine the following code:
+Bestudeer de volgende code:
 
 ```js
-const birthday = '18.04.1982';
+const verjaardag = '18.04.1982';
 
-const age = someCode(birthday);
+const leeftijd = eenCode(verjaardag);
 ```
 
-Here we have a constant `birthday` date and the `age` is calculated from `birthday` with the help of some code (it is not provided for shortness, and because details don't matter here).
+Hier hebben we een constante `verjaardag` datum en de `leeftijd` wordt berekend vanaf `verjaardag` met behulp van een of andere code (het is niet voorzien voor kortstondigheid, en omdat details hier niet van belang zijn).
 
-Would it be right to use upper case for `birthday`? For `age`? Or even for both?
+Zou het juist zijn om hoofdletters te gebruiken voor `verjaardag`? Voor `leeftijd`? Of zelfs voor beide?
 
 ```js
-const BIRTHDAY = '18.04.1982'; // make uppercase?
-
-const AGE = someCode(BIRTHDAY); // make uppercase?
-```
+const VERJAARDAG = '18.04.1982'; // uppercase maken?
 
+const LEEFTIJD = eenCode(BIRTHDAY); // hoofdletters maken?
+```
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
diff --git a/1-js/02-first-steps/04-variables/variable-change.svg b/1-js/02-first-steps/04-variables/variable-change.svg
diff --git a/1-js/02-first-steps/04-variables/variable.svg b/1-js/02-first-steps/04-variables/variable.svg

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-alert("I'm JavaScript!");`
	`1`	`+alert ("Ik ben JavaScript!");`