summaryrefslogtreecommitdiffhomepage
path: root/nl-nl
diff options
context:
space:
mode:
Diffstat (limited to 'nl-nl')
-rw-r--r--nl-nl/bash-nl.html.markdown235
-rw-r--r--nl-nl/bf.html.markdown (renamed from nl-nl/brainfuck-nl.html.markdown)2
-rw-r--r--nl-nl/coffeescript-nl.html.markdown11
-rw-r--r--nl-nl/json-nl.html.markdown71
-rw-r--r--nl-nl/json.html.markdown61
-rw-r--r--nl-nl/markdown-nl.html.markdown242
-rw-r--r--nl-nl/typescript-nl.html.markdown174
-rw-r--r--nl-nl/xml-nl.html.markdown134
-rw-r--r--nl-nl/yaml-nl.html.markdown53
9 files changed, 951 insertions, 32 deletions
diff --git a/nl-nl/bash-nl.html.markdown b/nl-nl/bash-nl.html.markdown
new file mode 100644
index 00000000..da47e2a9
--- /dev/null
+++ b/nl-nl/bash-nl.html.markdown
@@ -0,0 +1,235 @@
+---
+category: tool
+tool: bash
+contributors:
+ - ["Max Yankov", "https://github.com/golergka"]
+ - ["Darren Lin", "https://github.com/CogBear"]
+ - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+ - ["Denis Arh", "https://github.com/darh"]
+ - ["akirahirose", "https://twitter.com/akirahirose"]
+ - ["Anton Strömkvist", "http://lutic.org/"]
+ - ["Rahil Momin", "https://github.com/iamrahil"]
+ - ["Gregrory Kielian", "https://github.com/gskielian"]
+ - ["Etan Reisner", "https://github.com/deryni"]
+translators:
+ - ["Jeroen Deviaene", "https://www.github.com/jerodev"]
+lang: nl-nl
+filename: LearnBash-nl.sh
+---
+
+Bash is de naam van den unix shell, deze wordt gebruikt voor het GNU operating system en is de standaard shell op Linux en Mac OS X.
+Bijna alle voorbeelden hier onder kunnen deel uitmaken van een shell script of kunnen uitgevoerd worden in de shell.
+
+[Lees er meer over hier.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# De eerste lijn in het schript is shebang, deze laat het systeem weten hoe
+# het script uitgevoerd moet worden: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Zoals je kan zien wordt # gebruikt om een commentaar lijn te starten.
+
+# Simpel hello world voorbeeld:
+echo Hello world!
+
+# Elke command start op een nieuwe lijn, of achter een puntkomma (;):
+echo 'Dit is de eerste lijn'; echo 'Dit is de tweede lijn'
+
+# Een varialbe declareren gebeurt op volgende manier:
+Variabele="Een string"
+
+# Maar niet op deze manier:
+Variabele = "Een string"
+# Bash ziet variable als een commando en zal een error geven omdat dit commando
+# niet bestaat.
+
+# Of op deze manier:
+Variabele= 'Een string'
+# Bash zal 'Een string' zien als een commanda en een error geven omdat het niet
+# gevonden kan worden.
+
+# Variabelen gebruiken:
+echo $Variabele
+echo "$Variabele"
+echo '$Variabele'
+# Wanneer je een variable wil toekennen, exporteren of nog anders gebruik je
+# de naam zonder '$'. Als je de waarde van de variabele wilt, gebruik je een
+# '$' voor de naam.
+
+# Strings vervangen in variables
+echo ${Variabele/Een/De}
+# Dit zal 'Een' vervangen door 'De' in de string
+
+# Substring
+Length=7
+echo ${Variabele:0:Length}
+# Dit zal de eerste 7 tekens van de string weergeven.
+
+# Standaard waarde voor variabele
+echo ${Foo:-"StandaardwaardeAlsFooLeegIsOfNietBestaat"}
+# Dit werkt voor null en lege strings (Foo=""). Dit werkt niet voor 0 (Foo=0).
+# Merk op dat dit enkel de waarde retourneerd en de variable niet aanpast.
+
+
+# Ingebouwde variabelen:
+# Er zijn enkele zeer handige ingebouwde variabelen, zoals:
+echo "Return waarde van laatste programma: $?"
+echo "PID van dit script: $$"
+echo "Aantal argumenten voor dit script: $#"
+echo "Alle argumenten voor dit script: $@"
+echo "Argumenten voor dit script in apparte variabelen: $1 $2..."
+
+# Een waarde lezen via input:
+echo "Wat is uw naam?"
+read Naam # Merk op dat we geen variabele gedeclareerd hebben
+echo Hallo, $Naam!
+
+# We hebben ook if structuren
+# Gebruik 'man test' voor meer informatie over condities.
+if [ $Naam -ne $USER ]
+then
+ echo "Uw naam is niet gelijk aan de gebruikersnaam"
+else
+ echo "Uw naam is de gebruikersnaam"
+fi
+
+# MERK OP: als $Naam leeg is ziet bash het bovenstaande als volgt:
+if [ -ne $USER ]
+# dit is ongeldige syntax
+# Dus de beter manier om dit te schrijven is
+if [ "$Naam" -ne $USER ] ...
+# Als naam nu leeg is, ziet bash nu nog steeds
+if [ "" -ne $USER ] ...
+# Dit werkt wel zoals het hoort
+
+# Er is ook conditionele executie
+echo "Altijd uitvoeren" || echo "Enkel uitvoeren als vorige command mislukt"
+echo "Altijd uitvoeren" && echo "Enkel uitvoeren als vorige command NIET mislukt"
+
+# Om && en || te gebruiken in if structuren moeten vierkante haken gebruikt worden:
+if [ "$Naam" == "Steve" ] && [ "$Leeftijd" -eq 15 ]
+then
+ echo "Dit wordt uitgevoerd als $Naam Steve is en $Leeftijd 15 is."
+fi
+
+# Expressies worden gemaakt met volgende syntax:
+echo $(( 10 + 5 ))
+
+# Bash werkt steeds in de context van een huidige map in het bestandssysteem.
+# Bestanden en mappen in de huidige map kunnen weergegeven worden met het ls
+# commando.
+ls
+
+# Commandos hebben opties die de uitvoer beinvloeden
+ls -l # Lijst elk bestand en map op een nieuwe lijn.
+
+# Resultaten van een vorig commando kunnen doorgegeven worden aan een volgend
+# commando als input.
+# Het grep commando filter de input met een bepaald patroon. Op deze manier kunnen
+# we alle .txt bestanden weergeven in de huidige map.
+ls -l | grep "\.txt"
+
+# Commando's kunnen gekoppeld worden met andere commando's door gebruik te maken van
+# $( ):
+# Het volgende commando geeft het aantal bestanden weer in de huidige map
+echo "Er zijn hier $(ls | wc -l) bestanden."
+
+# Het zelfde kan gedaan worden met `, maar die kunnen niet genest worden. De methode
+# bij voorkeur is om $( ) te gebruiken.
+echo "Er zijn hier `ls | wc -l` bestanden."
+
+# Bash heeft een case statement dat werkt zoals in Java en C++
+case "$Variabele" in
+ 0) echo "Er is een 0";;
+ 1) echo "Er is een 1";;
+ *) echo "Er is iets";;
+esac
+
+# For lussen itereren over de gegeven argumenten
+# De waarde van $Variabele wordt hier drie keer afgeprint
+for Variable in {1..3}
+do
+ echo "$Variabele"
+done
+
+# Of schrijf een traditionele for loop op deze manier
+for ((a=1; a <= 3; a++))
+do
+ echo $a
+done
+
+# Lussen kunnen ook gebruikt worden met bestanden
+# Deze lus voert het cat commando uit op file1 en file2
+for Variable in file1 file2
+do
+ cat "$Variable"
+done
+
+# Of met het output commando
+for Output in $(ls)
+do
+ cat "$Output"
+done
+
+# while lus:
+while [ true ]
+do
+ echo "body van de lus..."
+ break
+done
+
+# Je kan ook functies aanmaken
+# Defenitie:
+function foo ()
+{
+ echo "Alle argumenten: $@"
+ echo "Apparte argumenten: $1 $2..."
+ echo "Dit is een functie"
+ return 0
+}
+
+# Of simpeler
+bar ()
+{
+ echo "Dit is een andere manier om functies te maken."
+ return 0
+}
+
+# Functies oproepen
+foo "Mijn naam is" $Naam
+
+# Enkele zeer handige commando's die je moet kennen
+# print de laatste 10 lijnen van file.txt
+tail -n 10 file.txt
+# print de eerste 10 lijnen van file.txt
+head -n 10 file.txt
+# Sorteer de lijnen in file.txt
+sort file.txt
+# Vind dubbele lijnen in file.txt
+uniq -d file.txt
+# Print de eerste kolom voor het ',' karakter
+cut -d ',' -f 1 file.txt
+# Vervang elke 'okay' met 'great' in file.txt (werkt ook met regex)
+sed -i 's/okay/great/g' file.txt
+# Print alle lijnen die voldoen aan de regex naar stdout
+grep "^foo.*bar$" file.txt
+
+
+# Gebruik de ingebouwde help functies door het help commando te gebruiken:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Lees de bash documentatie met het man commando:
+apropos bash
+man 1 bash
+man bash
+
+# Lees bash info documentatie:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/nl-nl/brainfuck-nl.html.markdown b/nl-nl/bf.html.markdown
index 6062b24c..016e2ba2 100644
--- a/nl-nl/brainfuck-nl.html.markdown
+++ b/nl-nl/bf.html.markdown
@@ -1,5 +1,5 @@
---
-language: brainfuck
+language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/nl-nl/coffeescript-nl.html.markdown b/nl-nl/coffeescript-nl.html.markdown
index dc0b1e19..390e6572 100644
--- a/nl-nl/coffeescript-nl.html.markdown
+++ b/nl-nl/coffeescript-nl.html.markdown
@@ -6,6 +6,7 @@ contributors:
translators:
- ["Jelle Besseling", "https://github.com/Jell-E"]
- ["D.A.W. de Waal", "http://github.com/diodewaal"]
+ - ["Sam van Kampen", "http://tehsvk.net"]
filename: coffeescript-nl.coffee
lang: nl-nl
---
@@ -13,10 +14,10 @@ lang: nl-nl
CoffeeScript is een kleine programmeertaal die direct compileert naar
JavaScript en er is geen interpretatie tijdens het uitvoeren.
CoffeeScript probeert om leesbare, goed geformatteerde en goed draaiende
-JavaScript code te genereren, die in elke JavaScript runtime werkt, als een
+JavaScript code te genereren, die in elke JavaScript-runtime werkt, als een
opvolger van JavaScript.
-Op [de CoffeeScript website](http://coffeescript.org/), staat een
+Op [de CoffeeScript-website](http://coffeescript.org/), staat een
volledigere tutorial voor CoffeeScript.
``` coffeescript
@@ -26,7 +27,7 @@ volledigere tutorial voor CoffeeScript.
###
Blokken commentaar maak je zo, ze vertalen naar JavaScripts */ en /*
-in de uitvoer van de CoffeeScript compiler.
+in de uitvoer van de CoffeeScript-compiler.
Het is belangrijk dat je ongeveer snapt hoe JavaScript
werkt voordat je verder gaat.
@@ -43,7 +44,7 @@ getal = -42 if tegengestelde #=> if(tegengestelde) { getal = -42; }
kwadraat = (x) -> x * x #=> var kwadraat = function(x) { return x * x; }
vul = (houder, vloeistof = "koffie") ->
- "Nu de #{houder} met #{koffie} aan het vullen..."
+ "Nu de #{houder} met #{vloeistof} aan het vullen..."
#=>var vul;
#
#vul = function(houder, vloeistof) {
@@ -80,7 +81,7 @@ wedstrijd = (winnaar, lopers...) ->
alert "Ik wist het!" if elvis?
#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
-# Lijst abstractie:
+# Lijstabstracties:
derdemachten = (wiskunde.derdemacht num for num in lijst)
#=>derdemachten = (function() {
# var _i, _len, _results;
diff --git a/nl-nl/json-nl.html.markdown b/nl-nl/json-nl.html.markdown
new file mode 100644
index 00000000..906112ff
--- /dev/null
+++ b/nl-nl/json-nl.html.markdown
@@ -0,0 +1,71 @@
+---
+language: json
+filename: learnjson-nl.json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+ - ["himanshu", "https://github.com/himanshu81494"]
+translators:
+ - ["Niels van Velzen", "https://nielsvanvelzen.me"]
+lang: nl-nl
+---
+
+Gezien JSON een zeer eenvouding formaat heeft zal dit een van de simpelste
+Learn X in Y Minutes ooit zijn.
+
+JSON heeft volgens de specificaties geen commentaar, ondanks dat hebben de
+meeste parsers support voor C-stijl (`//`, `/* */`) commentaar.
+Sommige parsers staan zelfs trailing komma's toe.
+(Een komma na het laatste element in een array of ahter de laatste eigenshap van een object).
+Het is wel beter om dit soort dingen te vermijden omdat het niet overal zal werken.
+
+In het voorbeeld zal alleen 100% geldige JSON gebruikt worden.
+
+Data types gesupport door JSON zijn: nummers, strings, booleans, arrays, objecten en null.
+Gesupporte browsers zijn: Firefox(Mozilla) 3.5, Internet Explorer 8, Chrome, Opera 10, Safari 4.
+De extensie voor JSON bestanden is ".json". De MIME type is "application/json"
+Enkele nadelen van JSON zijn het gebrek een type definities en een manier van DTD.
+
+```json
+{
+ "sleutel": "waarde",
+
+ "sleutels": "zijn altijd in quotes geplaatst",
+ "nummers": 0,
+ "strings": "Hallø, wereld. Alle unicode karakters zijn toegestaan, samen met \"escaping\".",
+ "boolean": true,
+ "niks": null,
+
+ "groot nummer": 1.2e+100,
+
+ "objecten": {
+ "commentaar": "In JSON gebruik je vooral objecten voor je strutuur",
+
+ "array": [0, 1, 2, 3, "Arrays kunnen alles in zich hebben.", 5],
+
+ "nog een object": {
+ "commentaar": "Objecten kunnen genest worden, erg handig."
+ }
+ },
+
+ "dwaasheid": [
+ {
+ "bronnen van kalium": ["bananen"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "alternatieve stijl": {
+ "commentaar": "Kijk dit!"
+ , "De komma positie": "maakt niet uit zolang het er maar is"
+ , "nog meer commentaar": "wat leuk"
+ },
+
+ "dat was kort": "En nu ben je klaar, dit was alles wat je moet weten over JSON."
+}
+```
diff --git a/nl-nl/json.html.markdown b/nl-nl/json.html.markdown
new file mode 100644
index 00000000..bedfb70a
--- /dev/null
+++ b/nl-nl/json.html.markdown
@@ -0,0 +1,61 @@
+---
+language: json
+filename: learnjson-nl.json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+ - ["Mathieu De Coster", "https://github.com/m-decoster"]
+lang: nl-nl
+---
+
+Aangezien JSON een extreem eenvoudig datauitwisselingsformaat is, zal dit waarschijnlijk
+de meest eenvoudige Learn X in Y Minutes ooit zijn.
+
+Puur JSON heeft geen commentaar, maar de meeste parsers zullen commentaar in de stijl
+van C (`//`, `/* */`) aanvaarden. In dit voorbeeld zal alles 100% correcte JSON zijn.
+Gelukkig spreekt het meeste voor zichzelf.
+
+```json
+{
+ "key": "value",
+
+ "keys": "moeten altijd tussen dubbele aanhalingstekens staan",
+ "getallen": 0,
+ "strings": "Hellø, world. Alle Unicode-karakters zijn toegelaten, zo ook \"escaping\".",
+ "heeft json booleans?": true,
+ "niets": null,
+
+ "groot getal": 1.2e+100,
+
+ "objecten": {
+ "commentaar": "De meeste structuur wordt gemaakt met objecten.",
+
+ "array": [0, 1, 2, 3, "Arrays kunnen eender wat bevatten.", 5],
+
+ "nog een object": {
+ "commentaar": "Hoe handig, we kunnen objecten nesten."
+ }
+ },
+
+ "dwaasheid": [
+ {
+ "bronnen van kalium": ["bananen"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "alternatieve stijl": {
+ "commentaar": "kijk hier eens naar!"
+ , "komma locatie": "maakt niet uit - zo lang het voor de value komt, is alles in orde"
+ , "nog commentaar": "hoe leuk"
+ },
+
+ "dat was kort": "Je bent klaar. Je kent nu alles dat JSON kan aanbieden."
+}
+```
diff --git a/nl-nl/markdown-nl.html.markdown b/nl-nl/markdown-nl.html.markdown
new file mode 100644
index 00000000..35cc67c5
--- /dev/null
+++ b/nl-nl/markdown-nl.html.markdown
@@ -0,0 +1,242 @@
+---
+language: markdown
+filename: markdown-nl.md
+contributors:
+ - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+ - ["Jeroen Deviaene", "https://www.github.com/jerodev"]
+lang: nl-nl
+---
+
+Markdown is gecreëerd door John Gruber in 2004. Het is bedoeld om met een gemakkelijke te lezen en
+schrijven syntax te zijn die gemakkelijk omgevormd kan worden naar HTML (en op heden verschillende
+andere formaten)
+
+```markdown
+<!-- Markdown erft over van HTML, dus ieder HTML bestand is een geldig Markdown
+bestand. Dit betekend ook dat html elementen gebruikt kunnen worden in Markdown
+zoals het commentaar element. Echter, als je een html element maakt in een Markdown
+document kan je geen markdown gebruiken voor de waarde van dat element. -->
+
+<!-- Markdown varieert ook van implementatie tot implementatie en per parser. Deze
+tutorial zal de universele functies van Markdown -->
+
+<!-- Headers -->
+<!-- Je kan de HTML elementen <h1> tot <h6> gemakkelijk maken door voor de titel
+een aantal hashes (#) te plaatsen gelijk aan het level van de header.
+# Dit is een <h1>
+## Dit is een <h2>
+### Dit is een <h3>
+#### Dit is een <h4>
+##### Dit is een <h5>
+###### Dit is een <h6>
+
+<!-- Markdown heeft ook een alternatieve manier om h1 en h2 te maken -->
+Dit is een h1
+=============
+
+Dit is een h2
+-------------
+
+<!-- Simpele tekst stijlen -->
+<!-- Tekst kan heel gemakelijk gestyled worden cursief of bold met markdown -->
+
+*Deze tekst is cursief*
+_Deze tekst ook_
+
+**Deze tekst is vet gedrukt**
+__En deze tekst ook!__
+
+***Deze tekst is zowel bold als schuin gedrukt***
+**_Deze ook!_**
+*__En zelfs deze!__*
+
+<!-- In de github versie van markdown, die gebruikt wordt om markdown te renderen
+op Github, is er ook doorstrepen -->
+
+~~Deze tekst wordt doorstreept.~~
+
+<!-- Paragrafen worden onderscheiden door een of meerdere lege lijnen -->
+
+Dit is een paragraaf.
+
+Dit is paragraaf 2.
+Dit is nog steeds paragraaf 2!
+
+
+Hallo, ik ben paragraaf 3.
+
+<!-- Citaten zijn gemakkelijk te maken met het '>' karakter. -->
+
+> Dit is een citaat. Je kan alle lijnen manueel starten met een '>'.
+> Of je kan de lijn heel heel, heel, lang laten worden zodat de parser deze automatisch zal afbreken en op een nieuwe lijn plaatsen.
+> Het maakt niet uit, zolang je start met een '>'.
+
+> Je kan ook in niveaus werken
+>> Niveau 2
+> Hoe leuk is dat?
+
+<!-- Lijsten -->
+<!-- Niet geordende lijsten kunnen gemaakt worden met sterretjes, plussen of streepjes -->
+
+* Item
+* Item
+* Nog een item
+
+of
+
++ Item
++ Item
++ Nog een item
+
+of
+
+- Item
+- Item
+- Een laatste item
+
+<!-- Geordende lijsten kunnen gemaakt wroden met cijfers -->
+
+1. Item een
+2. Item twee
+3. Item drie
+
+<!-- Het getal moet zelfs niet overeen komen met het item in de lijst, markdown zal
+automatisch de nummers aanpassen -->
+
+1. Item een
+1. Item twe
+1. Item drie
+<!-- (De output is gelijk aan de vorige lijst) -->
+
+<!-- Je kan ook gebruik maken van sub lijsten -->
+
+1. Item een
+2. Item twee
+3. Item drie
+ * Sub-item
+ * Sub-item
+4. Item vier
+
+<!-- Er zijn zelfs todo lijsten. Dit genereert HTML checkboxen. -->
+
+Boxen zonder een 'x' zijn niet aangevinkt
+- [ ] Eerste to-do item.
+- [ ] Tweede to-do item
+Dit item zal aangevinkt zijn in de gerenderde html.
+- [x] Deze taak is uitgevoerd
+
+<!-- Code blokken -->
+<!-- Een code block kan aangeduid worden door vier spaties of een tab -->
+
+ Dit is code
+ En dit ook
+
+<!-- Extra tabs kunnen gebruikt worden om tabs in de code aan te geven -->
+
+ my_array.each do |item|
+ puts item
+ end
+
+<!-- Inline code kan aangeduid worden met ` -->
+
+John wist zelfs niet dat de `go_to()` functie bestond!
+
+<!-- In Github Markdown kan je een speciale syntax gebruiken die aangeeft welke
+taal gebruikt wordt in het code blok. -->
+
+\`\`\`ruby <!-- Wis de backslashes om dit te doen, juist ```ruby ! -->
+def foobar
+ puts "Hello world!"
+end
+\`\`\` <!-- Hier ook, geen backslashes, juist ``` -->
+
+<!-- Voor bovenstaande tekst moet geen tab gebruikt worden. Plus, Github zal syntax
+highlighting gebruiken voor deze specifieke taal. Hier, Ruby.
+
+<!-- Horizontale lijn (<hr />) -->
+<!-- Horizontale lijnen kunnen gemakkelijk toegevoegd worden door drie of meer
+sterretjes, of streepjes te plaatsen -->
+
+***
+---
+- - -
+****************
+
+<!-- Links -->
+<!-- Een van de beste dingen in Markdown is hoe simpel het is om links te maken.
+plaats de tekst om weer te geven tussen [ en ] gevolgd door de link tussen ( en ) -->
+
+[Klik mij!](http://test.com/)
+
+<!-- Een titel kan ook toegevoegd worden aan de link met aanhalingstekens -->
+
+[Klik mij!](http://test.com/ "Titel voor de link")
+
+<!-- Relative paden werken ook -->
+
+[Naar de muziek](/music/).
+
+<!-- Links kunnen ook gelegd worden met referenties -->
+
+[Klik deze link][link1] voor meer info!
+[Beijk ook dit][foobar] als je echt wil.
+
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Tof!"
+
+
+<!-- Afbeeldingen -->
+<!-- Afbeeldingen worden toegevoegd op exact de zelfde manier als links maar met een
+uitroepteken aan het begin van de lijn. -->
+
+![Dit is de alt waarde van een afbeelding](http://imgur.com/myimage.jpg "Optionele titel")
+
+<!-- Referenties werkt ook zals bij links -->
+
+![Dit is de alt waarde][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "als een titel nodig is, staat deze hier"
+
+<!-- Varia -->
+<!-- Auto-links -->
+
+<http://testwebsite.com/> is gelijk aan
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto-links for emails -->
+
+<foo@bar.com>
+
+<!-- Karakters escapen -->
+
+Als je sterretjes wil gebruiken in je tekst zoals *dit* dan zal dit schuingedrukt weergegeven
+worden.
+Dit kan je oplossen met backslashes: \*dit\* staat tussen sterretjes
+
+<!-- Toetsenbord toetsen -->
+<!-- In Github Markdown, kan je <kbd> gebruiken om toetsenbord toetsen weer te geven -->
+
+Loopt je computer vast? Probeer volgende toetsen combinatie:
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
+<!-- Tabellen -->
+<!-- Tabellen zijn momenteel enkel beschikbaar in Github Markdown en zijn redelijk omslachtig.
+Maar als je er echt wilt toevoegen: -->
+
+| Col1 | Col2 | Col3 |
+| :--------------- | :---------: | ----------------: |
+| Links uitgelijnt | Gecentreerd | Rechts uitgelijnt |
+| blah | blah | blah |
+
+<!-- of, Voor het zelfde resultaat -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Zeer | Lelijke | Code!
+
+<!-- The end! -->
+
+```
+
+Voor meer info, bekijk de officiële post van John Gruber [hier](http://daringfireball.net/projects/markdown/syntax) en de handige cheatsheet van Adam Pritchard [hier](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/nl-nl/typescript-nl.html.markdown b/nl-nl/typescript-nl.html.markdown
new file mode 100644
index 00000000..dcea2a4d
--- /dev/null
+++ b/nl-nl/typescript-nl.html.markdown
@@ -0,0 +1,174 @@
+---
+language: TypeScript
+contributors:
+ - ["Philippe Vlérick", "https://github.com/pvlerick"]
+filename: learntypescript-nl.ts
+translators:
+ - ["Niels van Velzen", "https://nielsvanvelzen.me"]
+lang: nl-nl
+---
+
+TypeScript is een taal gericht op het versoepelen van de ontwikkeling van
+grote applicaties gemaakt in JavaScript.
+TypeScript voegt veelgebruikte technieken zoals klassen, modules, interfaces,
+generieken en statische typen toe aan JavaScript.
+TypeScript is een superset van JavaScript: alle JavaScript code is geldige
+TypeScript code waardoor de overgang van JavaScript naar TypeScript wordt versoepeld.
+
+Dit artikel focust zich alleen op de extra's van TypeScript tegenover [JavaScript] (../javascript-nl/).
+
+Om de compiler van TypeScript te kunnen proberen kun je naar de [Playground] (http://www.typescriptlang.org/Playground) gaan.
+Hier kun je automatisch aangevulde code typen in TypeScript en de JavaScript variant bekijken.
+
+```js
+// Er zijn 3 basis typen in TypeScript
+var isKlaar: boolean = false;
+var lijnen: number = 42;
+var naam: string = "Peter";
+
+// Wanneer het type onbekend is gebruik je "Any"
+var nietZeker: any = 4;
+nietZeker = "misschien een string";
+nietZeker = false; // Toch een boolean
+
+// Voor collecties zijn er "typed arrays"
+var lijst: number[] = [1, 2, 3];
+// of generieke arrays
+var lijst: Array<number> = [1, 2, 3];
+
+// Voor enumeraties:
+enum Kleur {Rood, Groen, Blauw};
+var c: Kleur = Kleur.Groen;
+
+// Als laatst, "void" wordt gebruikt voor als een functie geen resultaat geeft
+function groteVerschrikkelijkeMelding(): void {
+ alert("Ik ben een vervelende melding!");
+}
+
+// Functies zijn eersteklas ?, supporten de lambda "fat arrow" syntax en
+// gebruiken gebruiken "type inference"
+
+// Het volgende is allemaal hetzelfde
+var f1 = function(i: number): number { return i * i; }
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+var f4 = (i: number) => { return i * i; }
+// Omdat we maar 1 lijn gebruiken hoeft het return keyword niet gebruikt te worden
+var f5 = (i: number) => i * i;
+
+// Interfaces zijn structureel, elk object wat de eigenschappen heeft
+// is een gebruiker van de interface
+interface Persoon {
+ naam: string;
+ // Optionele eigenschappen worden gemarkeerd met "?"
+ leeftijd?: number;
+ // En natuurlijk functies
+ verplaats(): void;
+}
+
+// Object die gebruikt maakt van de "Persoon" interface
+// Kan gezien worden als persoon sinds het de naam en verplaats eigenschappen bevat
+var p: Persoon = { naam: "Bobby", verplaats: () => {} };
+// Object met de optionele leeftijd eigenschap
+var geldigPersoon: Persoon = { naam: "Bobby", leeftijd: 42, verplaats: () => {} };
+// Ongeldig persoon vanwege de leeftijds type
+var ongeldigPersoon: Persoon = { naam: "Bobby", leeftijd: true };
+
+// Interfaces kunnen ook een functie ype beschrijven
+interface ZoekFunc {
+ (bron: string, subString: string): boolean;
+}
+// Alleen de parameters types zijn belangrijk, namen maken niet uit.
+var mySearch: ZoekFunc;
+mySearch = function(src: string, sub: string) {
+ return src.search(sub) != -1;
+}
+
+// Classes - leden zijn standaard publiek
+class Punt {
+ // Eigenschappen
+ x: number;
+
+ // Constructor - de publieke / prive trefwoorden in deze context zullen
+ // eigenschappen in de klasse kunnen aanmaken zonder ze te defineren.
+ // In dit voorbeeld zal "y" net als "x" gedefineerd worden met minder code.
+ // Standaard waardes zijn ook gesupport
+
+ constructor(x: number, public y: number = 0) {
+ this.x = x;
+ }
+
+ // Functies
+ dist(): number { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+ // Statische leden
+ static origin = new Punt(0, 0);
+}
+
+var p1 = new Punt(10 ,20);
+var p2 = new Punt(25); // y zal de waarde 0 krijgen
+
+// Overnemen
+class Punt3D extends Punt {
+ constructor(x: number, y: number, public z: number = 0) {
+ super(x, y); // Constructor van ouder aanroepen (Punt)
+ }
+
+ // Overschrijven
+ dist(): number {
+ var d = super.dist();
+ return Math.sqrt(d * d + this.z * this.z);
+ }
+}
+
+// Modules werken ongeveer hetzelfde als namespaces
+// met "." kan je submodules defineren
+module Geometrie {
+ export class Vierkant {
+ constructor(public zijLengte: number = 0) {
+ }
+
+ oppervlakte() {
+ return Math.pow(this.zijLengte, 2);
+ }
+ }
+}
+
+var s1 = new Geometrie.Vierkant(5);
+
+// Local alias for referencing a module
+import G = Geometrie;
+
+var s2 = new G.Vierkant(10);
+
+// Generieken
+// Classes
+class Tupel<T1, T2> {
+ constructor(public item1: T1, public item2: T2) {
+ }
+}
+
+// Interfaces
+interface Paar<T> {
+ item1: T;
+ item2: T;
+}
+
+// En functies
+var paarNaarTupel = function<T>(p: Paar<T>) {
+ return new Tupel(p.item1, p.item2);
+};
+
+var tupel = paarNaarTupel({ item1: "hallo", item2: "wereld" });
+
+// Refferentie naar een definitie bestand:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Verder lezen (engels)
+ * [TypeScript Official website] (http://www.typescriptlang.org/)
+ * [TypeScript language specifications (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/nl-nl/xml-nl.html.markdown b/nl-nl/xml-nl.html.markdown
new file mode 100644
index 00000000..930f7cf4
--- /dev/null
+++ b/nl-nl/xml-nl.html.markdown
@@ -0,0 +1,134 @@
+---
+language: xml
+filename: learnxml-nl.xml
+contributors:
+ - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+ - ["Frank van Gemeren", "https://github.com/frvge"]
+lang: nl-nl
+---
+
+XML is een markuptaal die ontwikkeld is om data in te bewaren en data mee te
+verzenden.
+
+Anders dan HTML specificeert XML niet hoe data getoond of geformatteerd moet worden.
+Het bevat de data slechts.
+
+* XML Syntax
+
+```xml
+<!-- Dit is commentaar in XML -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<boekenwinkel>
+ <boek categorie="KOKEN">
+ <title taal="nl">Alledaags Italiaans</titel>
+ <auteur>Giada De Laurentiis</auteur>
+ <jaar>2005</jaar>
+ <prijs>30.00</prijs>
+ </boek>
+ <boek categorie="KINDEREN">
+ <titel taal="nl">Harry Potter</titel>
+ <auteur>J K. Rowling</auteur>
+ <jaar>2005</jaar>
+ <prijs>29.99</prijs>
+ </boek>
+ <boek categorie="WEB">
+ <titel taal="en">Learning XML</titel>
+ <auteur>Erik T. Ray</auteur>
+ <jaar>2003</jaar>
+ <prijs>39.95</prijs>
+ </boek>
+</boekenwinkel>
+
+<!-- Hierboven staat een standaard XML bestand.
+ Het begint met een declaratie die optionele metadata bevat.
+
+ XML werkt met een boomstructuur. De stamknoop hierboven is 'boekenwinkel'.
+ Deze heeft drie kinderen die allemaal 'boek' zijn. Deze knopen hebben op
+ hun beurt weer kinderen, enzovoort...
+
+ Knopen hebben open- en sluittags. Kinderen zijn knopen die zich tussen de
+ open- en sluittags van hun ouders bevinden. -->
+
+<!-- XML bevat two soorten data:
+ 1 - Attributen -> Dit is metadata van een knoop.
+ Deze informatie wordt meestal door de XML parser gebruikt om de data op
+ de juiste manier op te slaan. Je herkent het door de syntax in de vorm
+ van naam="waarde" in de open tag.
+ 2 - Elementen -> Dit is de pure data
+ Deze gegevens worden door de parser uit het XML bestand gehaald.
+ Elementen staan tussen de open- en sluittags. -->
+
+
+<!-- Hieronder staat een element met twee attributen -->
+<bestand type="gif" id="4293">computer.gif</bestand>
+
+
+```
+
+* Grammaticaal correcte documenten x Validatie
+
+Een XML document is "grammaticaal correct" of "well-formatted" als de
+syntax correct is. Het is ook mogelijk om meer structuur in het document
+aan te brengen met document definities zoals DTD en XML Schema.
+
+Een XML document dat aan een document definitie voldoet wordt "valide" volgens
+die document definitie genoemd.
+
+Met deze gereedschappen kan je de XML data buiten je applicatie logica
+controleren.
+
+```xml
+
+<!-- Hieronder staat een versimpelde versie voor een boekenwinkel document,
+ met een toevoeging van een DTD definitie. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "boekenwinkel.dtd">
+<boekenwinkel>
+ <boek categorie="KOKEN">
+ <titel>Alledaags Italiaans</titel>
+ <prijs>30.00</prijs>
+ </boek>
+</boekenwinkel>
+
+<!-- De DTD kan er als volgt uitzien:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT boekenwinkel (boek+)>
+<!ELEMENT boek (titel,prijs)>
+<!ATTLIST boek categorie CDATA "Literatuur">
+<!ELEMENT titel (#PCDATA)>
+<!ELEMENT prijs (#PCDATA)>
+]>
+
+
+<!-- De DTD begint met een declaratie.
+ Hierna volgt de declaratie van de stamknoop, die 1 of meer 'boek' kinderen
+ moet bevatten.
+ Elk 'boek' moet precies 1 'titel' en 'prijs' element bevatten en een attribuut
+ 'categorie' hebben waarvan 'Literatuur' de standaard waarde is.
+ De 'titel' en 'prijs' knopen bevatten parsed character data.-->
+
+<!-- De DTD kan ook in het XML bestand zelf gedeclareerd worden.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT boekenwinkel (boek+)>
+<!ELEMENT boek (titel,prijs)>
+<!ATTLIST boek categorie CDATA "Literatuur">
+<!ELEMENT titel (#PCDATA)>
+<!ELEMENT prijs (#PCDATA)>
+]>
+
+<boekenwinkel>
+ <boek categorie="KOKEN">
+ <titel>Alledaags Italiaans</titel>
+ <prijs>30.00</prijs>
+ </boek>
+</boekenwinkel>
+``` \ No newline at end of file
diff --git a/nl-nl/yaml-nl.html.markdown b/nl-nl/yaml-nl.html.markdown
index a4a9d5fc..11af784f 100644
--- a/nl-nl/yaml-nl.html.markdown
+++ b/nl-nl/yaml-nl.html.markdown
@@ -5,21 +5,22 @@ contributors:
- ["Adam Brenecki", "https://github.com/adambrenecki"]
translators:
- ["Niels van Velzen", "https://nielsvanvelzen.me"]
+ - ["Sam van Kampen", "http://tehsvk.net"]
lang: nl-nl
---
-YAML is een data serialisatie taal ontworpen om snel te kunnen worden begrepen door mensen.
+YAML is een dataserialisatietaal ontworpen om snel te kunnen worden begrepen door mensen.
-Het is een strikte superset van JSON en bevat nieuwe regels en een stricte manier van inspringen, zoals bij Python. In tegenstelling tot Python kan je alleen geen tab tekens gebruiken.
+Het is een strikte superset van JSON en bevat nieuwe regels en een strikte manier van inspringen die lijkt op de manier van Python. In tegenstelling tot Python kan je alleen geen tabtekens gebruiken.
```yaml
# Commentaar in YAML ziet er zo uit
-################
-# SCALAR TYPES #
-################
+##################
+# SCALAIRE TYPES #
+##################
-# Ons hoofd object (Wat in het hele document gebruikt wordt) is een map,
+# Ons hoofdobject (Wat in het hele document gebruikt wordt) is een map;
# dit staat gelijk aan een dictionary, hash of object in andere talen.
sleutel: waarde
nog_een_sleutel: Een andere waarde
@@ -35,10 +36,10 @@ quote_waarde: "Een string in quotes"
# Tekst over meerdere lijnen kan je schrijven als een 'letterlijk blok' (met |)
# Of een 'gevouwen blok' (met >)
letterlijk_blok: |
- Dit hele blok met tekst is de waarde van de 'letterlijk_blok' sleutel,
+ Dit hele blok met tekst is de waarde van de 'letterlijk_blok'-sleutel,
met nieuwe lijnen behouden.
- Het blok blijft door gaan tot het geeindigd wordt door korter te inspringen.
+ Het blok blijft door gaan tot het geeindigd wordt door korter in te springen.
Lijnen die groter zijn ingesprongen behouden dit.
gevouwen_stijl: >
@@ -50,9 +51,9 @@ gevouwen_stijl: >
Meer ingesprongen lijnen zullen hun nieuwe lijnen ook behouden,
deze tekst zal over 2 lijnen te zien zijn.
-####################
-# COLLECTION TYPES #
-####################
+##################
+# COLLECTIETYPES #
+##################
# Nesten wordt bereikt met inspringen.
geneste_map:
@@ -61,7 +62,7 @@ geneste_map:
andere_geneste_map:
hallo: wereld
-# In een map is een sleutel niet verplicht om een string te gebruiken
+# In een map hoeft de sleutel geen string te zijn.
0.25: een float als sleutel
# Sleutels kunnen ook meerdere lijnen gebruiken met behulp van het vraagteken
@@ -70,14 +71,14 @@ geneste_map:
met meerdere lijnen
: en dit is de waarde
-# YAML staat ook collection types toe in sleutels, maar veel programmeertalen
+# YAML staat ook collectietypes toe in sleutels, maar veel programmeertalen
# zullen hierover klagen.
# Sequences (gelijk aan lijsten of arrays) zien er zo uit:
een_sequence:
- Item 1
- Item 2
- - 0.5 # sequences kunnen meerdere type waardes bevatten.
+ - 0.5 # sequences kunnen meerdere typen waardes bevatten.
- Item 4
- sleutel: waarde
andere_sleutel: andere waarde
@@ -85,13 +86,13 @@ een_sequence:
- Dit is een sequence
- in een andere sequence
-# Doordat YAML een superset van JSON is kan je ook JSON-stijl mappen en
-# sequences maken:
+# Doordat YAML een superset van JSON is kan je ook mappen en
+# sequences volgens de JSON-stijl maken:
json_map: {"sleutel": "waarde"}
json_seq: [3, 2, 1, "takeoff"]
#######################
-# EXTRA YAML FUNCTIES #
+# EXTRA YAML-FUNCTIES #
#######################
# YAML heeft ook een handige functie genaamd 'anchors' (ankers), deze laten je
@@ -102,16 +103,16 @@ andere_anker: *anker_naam
# YAML heeft ook tags, deze gebruik je om een expliciet type te verklaren
expliciete_string: !!str 0.5
-# Sommige parsers gebruiken taal specifieke tags, zoals deze voor Python's
-# complexe nummer type:
+# Sommige parsers gebruiken taalspecifieke tags, zoals deze voor Python's
+# complexe nummertype:
python_complex_nummer: !!python/complex 1+2j
-####################
-# EXTRA YAML TYPES #
-####################
+#######################
+# EXTRA TYPES IN YAML #
+#######################
-# Strings en nummer zijn niet de enige types die YAML begrijpt.
-# ISO opgemaakte datum en datumtijd notaties werken ook:
+# Strings en nummers zijn niet de enige types die YAML begrijpt.
+# ISO opgemaakte datum- en datumtijdnotaties werken ook:
datumtijd: 2001-12-15T02:59:43.1Z
datumtijd_met_spaties: 2001-12-14 21:59:43.10 -5
datum: 2002-12-14
@@ -124,13 +125,13 @@ gif_bestand: !!binary |
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
-# YAML heeft ook een set type, dat ziet er zo uit:
+# YAML heeft ook een settype, dat ziet er zo uit:
set:
? item1
? item2
? item3
-# Zoals in Python zijn sets gewoon mappen met null waardes;
+# Zoals in Python zijn sets gewoon mappen met nulwaarden;
# bovenstaand is gelijk aan:
set2:
item1: null