Merge branch 'adambard:master' into update-stale-hack-docs

2024-12-23 17:41:41 +00:00 · 2022-07-15 20:49:24 -04:00 · 2022-07-15 20:49:24 -04:00 · 13743fc49a
commit 13743fc49a
parent dd5c81e40d 4aa0d91d1c
20 changed files with 619 additions and 186 deletions
--- a/bash.html.markdown
+++ b/bash.html.markdown
@ -112,7 +112,7 @@ echo ${array0[@]} # => "one two three four five six"
 echo ${#array0[@]} # => "6"
 # Print number of characters in third element
 echo ${#array0[2]} # => "5"
-# Print 2 elements starting from forth
+# Print 2 elements starting from fourth
 echo ${array0[@]:3:2} # => "four five"
 # Print all elements. Each of them on new line.
 for i in "${array0[@]}"; do
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@ -8,11 +8,15 @@ filename: asciidoc-de.md
 lang: de-de
 ---

-AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an Anpassungen.
+AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles
+verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart
+Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an
+Anpassungen.

 Kopfzeile des Dokuments

-Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen mindestens eine Leerzeile vom Inhalt versetzt sein.
+Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen
+mindestens eine Leerzeile vom Inhalt versetzt sein.

 Nur Titel

@ -104,7 +108,8 @@ Um eine nummerierte Liste zu erstellen, verwendest du Punkte.
 . item 3
 ```

-Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
+Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise
+Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.

 ```
 * foo 1
--- a/de-de/brainfuck-de.html.markdown
+++ b/de-de/brainfuck-de.html.markdown
@ -1,11 +1,11 @@
 ---
-language: brainfuck
+language: bf
 contributors:
    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
    - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
    - ["urfuchs", "https://github.com/urfuchs"]
-filename: brainfuck-de
+filename: brainfuck-de.bf
 lang: de-de

 ---
--- a/docker.html.markdown
+++ b/docker.html.markdown
@ -1,5 +1,6 @@
 ---
-language: docker
+category: tool
+tool: docker
 filename: docker.bat
 contributors:
    - ["Ruslan López", "http://javapro.org/"]
--- a/erlang.html.markdown
+++ b/erlang.html.markdown
@ -1,7 +1,7 @@
 ---
 language: erlang
 contributors:
-    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+    - ["Giovanni Cappellotto", "http://giovanni.curlybrackets.it/"]
 filename: learnerlang.erl
 ---

--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@ -196,7 +196,7 @@ function string_functions(    localvar, arr) {
    # Ambas regresan el número de matches remplazados.
    localvar = "fooooobar"
    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"

    # Buscar una cadena que haga match con una expresión regular
    # index() hace lo mismo, pero no permite expresiones regulares
--- a/fr-fr/awk-fr.html.markdown
+++ b/fr-fr/awk-fr.html.markdown
@ -10,13 +10,19 @@ lang: fr-fr

 ---

-AWK est un outil standard présent dans chaque système UNIX conforme aux normes POSIX.
-C’est un outil en ligne de commande qui ressemble au Perl et qui est excellent dans les tâches de traitement de fichiers texte.
-Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage de script autonome.
+AWK est un outil standard présent dans chaque système UNIX conforme aux normes
+POSIX. C’est un outil en ligne de commande qui ressemble au Perl et qui est
+excellent dans les tâches de traitement de fichiers texte.
+Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage
+de script autonome.

 Pourquoi utiliser AWK au lieu du langage Perl ?
-Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur une très grande partie des systèmes d'exploitation UNIX et Linux. 
-AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour ce qui concerne le traitement de texte simple. Notamment le traitement de ceux qui necéssitent de lire des fichiers ligne par ligne ; chaque ligne comportant des champs séparés par des délimiteur.
+Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur
+une très grande partie des systèmes d'exploitation UNIX et Linux.
+AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour
+ce qui concerne le traitement de texte simple. Notamment le traitement de ceux
+qui nécessitent de lire des fichiers ligne par ligne ; chaque ligne comportant
+des champs séparés par des délimiteur.


 ```awk
@ -30,17 +36,25 @@ règle1 { action; }
 règle2 { action; }

 # AWK lit et analyse automatiquement chaque ligne de chaque fichier fourni.
-# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur peut être changer grâce à l'option -F ou être renseigné au début d'un bloc (exemple: FS = " ").
+# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace
+# (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur
+# peut être changé grâce à l'option -F ou être renseigné au début d'un bloc
+# (exemple: FS = " ").

-# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le point d’entrée principal du script.
-# A l'opposé de BEGIN, il existe la règle END. Cette règle est présente après chaque fin de fichier (EOF : End Of File).
+# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet
+# endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers
+# texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le
+# point d’entrée principal du script.
+# À l'opposé de BEGIN, il existe la règle END. Cette règle est présente après
+#chaque fin de fichier (EOF : End Of File).

 BEGIN {

    # Les variables sont globales. Pas besoin de les déclarer.
    count = 0;

-    # les opérateurs sont identiques au langage C et aux langages similaires (exemple: C#, C++)
+    # les opérateurs sont identiques au langage C et aux langages similaires 
+    # (tels que C#, C++, etc.)
    a = count + 1; # addition
    b = count - 1; # soustraction
    c = count * 1; # multiplication
@ -74,7 +88,8 @@ BEGIN {

    # Les blocs sont composés d'une multitude de lignes entre accolades
    while (a < 10) {
-        print "La concaténation de chaînes de caractères" " se fait avec des séries de chaînes "    " séparées par des espaces";
+        print "La concaténation de chaînes de caractères" " se fait avec"
+            "des séries de chaînes " "séparées par des espaces";
        print a;

        a++;
@ -113,7 +128,9 @@ BEGIN {
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";

-    # et les tableaux multi-dimentions, avec certaines limitations que l'on ne mentionnera pas ici
+    # et les tableaux multi-dimensions, avec certaines limitations que l'on ne
+    # mentionnera pas ici
+
    multidim[0,0] = "foo";
    multidim[0,1] = "bar";
    multidim[1,0] = "baz";
@ -123,7 +140,8 @@ BEGIN {
    if ("foo" in assoc)
        print "Fooey!";

-    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés d'un tableau
+    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés
+    # d'un tableau
    for (key in assoc)
        print assoc[key];

@ -132,10 +150,12 @@ BEGIN {
        print ARGV[argnum];

    # Vous pouvez supprimer des éléments d'un tableau
-    # C'est utile pour empêcher AWK de supposer que certains arguments soient des fichiers à traiter.
+    # C'est utile pour empêcher AWK de supposer que certains arguments soient
+    # des fichiers à traiter.
+
    delete ARGV[1];

-    # Le nombre d'arguments de la ligne de commande est dans une variable appellée ARGC
+    # Le nombre d'arguments de la ligne de commande est assigné à la variable ARGC
    print ARGC;

    # AWK inclue trois catégories de fonction.
@ -149,22 +169,24 @@ BEGIN {
 # Voici comment définir une fonction
 function arithmetic_functions(a, b, c,     d) {

-    # La partie la plus ennuieuse de AWK est probablement l’absence de variables locales.
-    # Tout est global. Pour les scripts courts, c'est très utile, mais pour les scripts plus longs,
-    # cela peut poser problème.
+    # La partie la plus ennuyeuse de AWK est probablement l’absence de variables
+    # locales. Tout est global. Pour les scripts courts, c'est très utile, mais
+    # pour les scripts plus longs, cela peut poser un problème.

-    # Il y a cepandant une solution de contournement (enfin ... une bidouille).
+    # Il y a cependant une solution de contournement (enfin ... une bidouille).
    # Les arguments d'une fonction sont locaux à cette fonction.
    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
-    # comme ci-dessus. La convention veut que vous mettiez quelques espaces supplémentaires
-    # pour faire la distinction entre les paramètres réels et les variables locales.
+    # comme ci-dessus. La convention veut que vous mettiez quelques espaces
+    # supplémentaires pour faire la distinction entre les paramètres réels et
+    # les variables locales.
    # Dans cet exemple, a, b et c sont des paramètres réels,
    # alors que d est simplement une variable locale.

    # Maintenant, les fonctions arithmétiques

-    # La plupart des implémentations de AWK ont des fonctions trigonométriques standards
+    # La plupart des implémentations de AWK ont des fonctions trigonométriques
+    # standards
    localvar = sin(a);
    localvar = cos(a);
    localvar = atan2(b, a); # arc tangente de b / a
@ -180,10 +202,10 @@ function arithmetic_functions(a, b, c,     d) {
    localvar = int(5.34); # localvar => 5

    # Les nombres aléatoires
-    srand(); 
+    srand();
    # L'argument de la fonction srand() est la valeur de départ pour générer
    # les nombres aléatoires . Par défaut, il utilise l'heure du système
-    
+
    localvar = rand(); # Nombre aléatoire entre 0 et 1.

    # Maintenant on retourne la valeur
@ -195,11 +217,13 @@ function string_functions(    localvar, arr) {
    # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
    # dont beaucoup reposent sur des expressions régulières.

-    # Chercher et remplacer, la première occurence (sub) ou toutes les occurences (gsub)
+    # Chercher et remplacer, la première occurrence (sub) ou toutes les
+    # occurrences (gsub)
    # Les deux renvoient le nombre de correspondances remplacées
+
    localvar = "fooooobar";
    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
-    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar); # localvar => "m..t m. at th. bar"

    # Rechercher une chaîne de caractères qui correspond à une expression régulière
    # index() fait la même chose, mais n'autorise pas les expressions régulières
@ -226,7 +250,8 @@ function io_functions(    localvar) {
    printf("%s %d %d %d\n", "Testing", 1, 2, 3);

    # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
-    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a besoin.
+    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a
+    # besoin.
    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
    # comme un descripteur de fichier à des fins d'entrée / sortie.

@ -241,11 +266,12 @@ function io_functions(    localvar) {
    # Voici comment exécuter quelque chose dans le shell
    system("echo foobar"); # => affiche foobar

-    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable locale
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable
+    # locale
    getline localvar;

-    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une chaine de caractère
-    # que vous fermerez proprement)
+    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une
+    # chaîne de caractère que vous fermerez proprement)
    "echo foobar" | getline localvar # localvar => "foobar"
    close("echo foobar")

@ -256,18 +282,19 @@ function io_functions(    localvar) {
 }

 # Comme dit au début, AWK consiste en une collection de règles et d'actions.
-# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont utilisées que si vous traitez 
-# des lignes à partir de fichiers ou l'entrée standard (stdin).
-# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de fichiers à traiter.
-# AWK les traitera tous dans l'ordre. Voyez les comme dans à une boucle implicite,
-# parcourant les lignes de ces fichiers.
-# Ces règles et ces actions ressemblent à des instructions switch dans la boucle.
+# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont
+# utilisées que si vous traitez des lignes à partir de fichiers ou l'entrée
+# standard (stdin).
+# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de
+# fichiers à traiter. AWK les traitera tous dans l'ordre. Voyez les comme dans
+# une boucle implicite, parcourant les lignes de ces fichiers. Ces règles et ces
+# actions ressemblent à des instructions switch dans la boucle.

 /^fo+bar$/ {

-    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression régulière,
-    # /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond pas.
-    # Imprimons simplement la ligne:
+    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression
+    # régulière, /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond
+    # pas. Imprimons simplement la ligne:

    print;

@ -275,14 +302,15 @@ function io_functions(    localvar) {
    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.

    # Vous devinez probablement qu'il existe d'autres variables $.
-    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée, comme
-    # le fait le shell. Et, comme le shell, chaque champ est accessible avec un signe dollar
+    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée,
+    # comme le fait le shell. Et, comme le shell, chaque champ est accessible
+    # avec un signe dollar

     # Ceci affichera les deuxième et quatrième champs de la ligne.
    print $2, $4;

-    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous aider
-    # à inspecter et traiter chaque ligne. La plus importante est NF
+    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous
+    # aider à inspecter et traiter chaque ligne. La plus importante est NF

    # Affiche le nombre de champs de la ligne
    print NF;
@ -291,33 +319,37 @@ function io_functions(    localvar) {
    print $NF;
 }

-# Chaque règle est en réalité un test conditionel. 
+# Chaque règle est en réalité un test conditionnel.

 a > 0 {
    # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
 }

-# Les expressions régulières sont également des tests conditionels.
-#Si le test de l'expression régulières n'est pas vrais alors le bloc n'est pas executé
-$0 /^fobar/ { 
-   print "la ligne commance par fobar"  
+# Les expressions régulières sont également des tests conditionnels.
+# Si le test de l'expression régulières n'est pas vrais alors le bloc
+# n'est pas exécuté.
+
+$0 /^fobar/ {
+   print "la ligne commence par foobar"
 }

-# Dans le cas où vous voulez tester votre chaine de caractères sur la ligne en cours de traitement
-# $0 est optionnelle.
+# Dans le cas où vous voulez tester votre chaîne de caractères sur la ligne
+# en cours de traitement $0 est optionnelle.

 /^[a-zA-Z0-9]$/ {
    print "La ligne courante ne contient que des caractères alphanumériques.";
 }


-# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en fonction de règles établies
-# Cela est si courant sous UNIX qu'AWK est un langage de script.
+# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en
+# fonction de règles établies. Cela est si courant sous UNIX qu'AWK est un
+# langage de script.

-# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est parfait.
-# Le script lit un nom à partir de l'entrée standard, puis affiche l'âge moyen de toutes les
-# personnes portant ce prénom.
-# Supposons que vous fournissiez comme argument le nom d'un fichier comportant ces données:
+# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est
+# parfait. Le script lit un nom à partir de l'entrée standard, puis affiche
+# l'âge moyen de toutes les personnes portant ce prénom.
+# Supposons que vous fournissiez comme argument le nom d'un fichier comportant
+# ces données:
 #
 # Bob Jones 32
 # Jane Doe 22
@ -330,7 +362,7 @@ $0 /^fobar/ {
 BEGIN {

    # Premièrement, on demande à l'utilisateur le prénom voulu
-    print "Pour quel prénom vouldriez vous savoir l'age moyen ?";
+    print "Pour quel prénom voudriez vous savoir l'age moyen ?";

    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
    getline name < "/dev/stdin";
--- a/julia.html.markdown
+++ b/julia.html.markdown
@ -356,6 +356,20 @@ intersect(filledSet, otherSet)      # => Set([4, 3, 5])
 union(filledSet, otherSet)          # => Set([4, 2, 3, 5, 6, 1])
 setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1])

+# Assignment with `=` attaches a new label to the same value without copying
+a = [1, 2, 3]
+b = a
+# Now `b` and `a` point to the same value, so changing one affects the other:
+a[3] = 5
+b[3]  # => 5
+
+# The `copy()` function can create a shallow copy of an array, dictionary,
+# or other container
+a = [1, 2, 3]
+c = copy(a)
+a[3] = 5
+c[3] # => 3
+
 ####################################################
 ## 3. Control Flow
 ####################################################
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@ -169,9 +169,9 @@ render the numbers in order, but this may not be a good idea.
 1. Item three
 ```

-(This renders the same as the above example)
+(This renders the same as the example above.)

-You can also use sublists
+You can also use sublists.

 ```md
 1. Item one
@ -203,7 +203,7 @@ a line with four spaces or a tab.
 ```

 You can also re-tab (or add an additional four spaces) for indentation
-inside your code
+inside your code.

 ```md
    my_array.each do |item|
@ -211,13 +211,13 @@ inside your code
    end
 ```

-Inline code can be created using the backtick character `` ` ``
+Inline code can be created using the backtick character `` ` ``.

 ```md
 John didn't even know what the `go_to()` function did!
 ```

-In GitHub Flavored Markdown, you can use a special syntax for code
+In GitHub Flavored Markdown, you can use a special syntax for code.

 <pre>
 <code class="highlight">&#x60;&#x60;&#x60;ruby
@ -227,7 +227,7 @@ end
 &#x60;&#x60;&#x60;</code></pre>

 The above text doesn't require indenting, plus GitHub will use syntax
-highlighting of the language you specify after the \`\`\`
+highlighting of the language you specify after the opening <code>```</code>.

 ## Horizontal rule

@ -278,7 +278,7 @@ There is also "implicit naming" which lets you use the link text as the id.

 <pre><code class="highlight">&#x5b;<span class="nv">This</span>][] is a link.

-&#x5b;<span class="nv">this</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+&#x5b;<span class="nv">This</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>

 But it's not that commonly used.

--- a/nim.html.markdown
+++ b/nim.html.markdown
@ -142,7 +142,7 @@ when compileBadCode:
 # Arrays

 type
-  RollCounter = array[DieFaces, int]  # Array's are fixed length and
+  RollCounter = array[DieFaces, int]  # Arrays are fixed length and
  DirNames = array[Direction, string] # indexed by any ordinal type.
  Truths = array[42..44, bool]
 var
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@ -202,7 +202,7 @@ function string_functions(    localvar, arr) {
    # Ambas retornam o número de instâncias substituídas
    localvar = "fooooobar"
    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"

    # Localiza um texto que casa com uma expressão regular
    # index() faz a mesma coisa, mas não permite uma expressão regular
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@ -6,36 +6,56 @@ translators:
    - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
    - ["Gabriele Luz", "https://github.com/gabrieleluz"]
    - ["Monique Baptista", "https://github.com/bfmonique"]
+    - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"]

 lang: pt-br    
 filename: learnmarkdown-pt.md
 ---

-Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e 
-escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
+O Markdown foi lançado por John Gruber em 2004. Criado para ser uma sintaxe
+fácil de ler e escrever e que é facilmente convertida em HTML (hoje, suporta
+outros formatos também).

-Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e 
-puxar o projeto (pull request)
+O Markdown varia em termos de implementação de um parser para outro. Esse guia
+irá tentar deixar explícito quando os recursos são universais ou quando são
+específicos para um parser em específico.
+
+- [Elementos HTML](#elementos-html)
+- [Cabeçalhos](#cabeçalhos)
+- [Estilos de texto simples](#estilos-de-texto-simples)
+- [Parágrafos](#parágrafos)
+- [Listas](#listas)
+- [Blocos de código](#blocos-de-código)
+- [Linha Horizontal](#linha-horizontal)
+- [Links](#links)
+  - [Tabela de conteúdo](#tabela-de-conteúdo)
+- [Imagens](#imagens)
+- [Miscelânea](#miscelânea)
+  - [Auto-links](#auto-links)
+  - [Auto-links para e-mails](#auto-links-com-e-mails)
+  - [Escapando caracteres](#escapando-caracteres)
+  - [Teclas do teclado](#teclas-do-teclado)
+  - [Tabelas](#tabelas)
+- [Markdownlint](#markdownlint)
+- [Leitura complementar](#leitura-complementar)

 ## Elementos HTML
-Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
+O Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
 um arquivo Markdown válido.
+
 ```md
-<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é 
-um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML 
-em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
-de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
-não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
-
-<!--A maneira como o Markdown é analisado varia de software para software.
-Este guia vai tentar esclarecer quando as características são universais, ou quando eles são específicos para um determinado interpretador -->
-
+<!--Isso significa que nós podemos usar elementos HTML em Markdown, como o
+elemento de comentário, e eles não serão afetados pelo analisador de
+remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown,
+você não pode usar sintaxe de remarcação dentro do conteúdo desse elemento.-->
+```

 ## Cabeçalhos

 Você pode criar elementos HTML `<h1>` até `<h6>` facilmente antecedendo o texto
-que deseja estar nesse elemento por um número de hashes (#)
+que deseja estar nesse elemento por um número de cerquilhas (#).

+```md
 # Isto é um cabeçalho <h1>
 ## Isto é um cabeçalho <h2>
 ### Isto é um cabeçalho <h3>
@ -44,7 +64,7 @@ que deseja estar nesse elemento por um número de hashes (#)
 ###### Isto é um cabeçalho <h6>
 ```

-Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2
+Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2.

 ```md
 Isto é um cabeçalho h1
@ -55,21 +75,22 @@ Isto é um cabeçalho h2
 ```

 ## Estilos de texto simples
-O texto pode ser facilmente denominado como marcação itálico, negrito ou tachado usando:
+
+O texto pode ser facilmente estilizado como itálico ou negrito usando Markdown.

 ```md
 *Este texto está em itálico*
 _E este também está._

 **Este texto está em negrito**
-__E este também está._
+__E este também está.__

 ***Este texto está em negrito e itálico.***
 **_E este também está_**
-*--Danouse! Este também__*
+*__Danou-se! Este também__*
 ```

-Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
+No GitHub Flavored Markdown, que é usado para processar arquivos Markdown
 GitHub, nós também temos:

 ```md
@ -77,43 +98,46 @@ GitHub, nós também temos:
 ```

 ## Parágrafos
-Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
+Os parágrafos estão em uma ou várias linhas adjacentes de texto separadas por 
 uma ou múltiplas linhas em branco.

 ```md
 Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?

 Agora, eu estou no parágrafo 2.
-... Ainda continuo no parágrafo 2! :)
+Ainda continuo no parágrafo 2!

-Eu estou no parágrafo três.
+
+Eu estou no parágrafo três!
 ```

 Se você quiser inserir uma tag HTML `<br />`, você pode acabar com um parágrafo 
-com dois ou mais espaços e, em seguida, começar um novo parágrafo
+com dois ou mais espaços e, em seguida, começar um novo parágrafo.

 ```md
-Termino com dois espaços (destacar-me para vê-los). 
+Termino com dois espaços (selecione essa linha para vê-los). 

 Há um <br /> acima de mim!
 ```

-
-Bloco de citações são fáceis e feito com o caractere >.
+Blocos de citações são fáceis e feitos com o caractere >.

 ```md
 > Este é um bloco de citação. Você pode 
-> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
-> deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença, 
-> desde que eles começam com um `>`.
-	
+> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você
+> pode deixar suas linhas ficarem muito longas e quebrarem por conta própria.
+> Não faz diferença, desde que elas comecem com um `>`.

 > Você também pode usar mais de um nível 
 >> De recuo?
+> O quão legal é isso?
+
 ```

 ## Listas
-As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens
+
+As listas não ordenadas podem ser feitas usando asteriscos, sinais de positivo
+ou hífens.

 ```md
 * Item
@ -141,18 +165,18 @@ Listas ordenadas são feitas com um número seguido por um ponto.
 3. Item três
 ```

-<!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os 
-itens em ordem, mas isso pode não ser uma boa idéia -->
-
+Você não precisa sequer rotular os itens corretamente e o Markdown ainda
+assim deixará os itens em ordem, mas isso pode não ser uma boa idéia.

 ```md
 1. Item um
 1. Item dois
 1. Item três
 ```
+
 (Isto é processado da mesma forma que o exemplo acima)

-Você também pode usar sublistas
+Você também pode usar sublistas.

 ```md
 1. Item um
@ -163,63 +187,59 @@ Você também pode usar sublistas
 4. Item quatro
 ```

-Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) de HTML
+Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) do 
+HTML.

 ```md
-As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas
- [ ] Primeira tarefa a completar
+As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas.
+- [ ] Primeira tarefa a completar.
 - [ ] Segunda tarefa a completar
-A caixa de seleção abaixo será exibida como uma checkbox HTML marcada
+A caixa de seleção abaixo será exibida como uma checkbox HTML marcada.
 - [x] Essa tarefa foi completa
-
 ```

-
 ## Blocos de código
-Você pode indicar um bloco de código (que utiliza o elemento `<code>`) pelo recuo
-uma linha com quatro espaços ou uma guia
+
+Você pode indicar um bloco de código (que utiliza o elemento `<code>`) através
+de indentação com quatro espaços ou uma tabulação.
+
 ```md
-	Isto é código
-	É assim, sacou?
-	
+    Isto é código
+    É assim, sacou?
 ```

-Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
-dentro do seu código
+Você pode também adicionar mais tabulações (ou adicionar mais quatro espaços
+adicionais) para indentação no seu código.

 ```md
-	my_array.each do |item|
+    my_array.each do |item|
        puts item
    end	
- ```
-
-Código embutido pode ser criada usando o caractere de crase `` ` ``
-
-```md
-John não sabia nem o que o função `goto()` fazia!
 ```

-Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código
+Código embutido pode ser criado usando o caractere de crase `` ` ``.
+
 ```md
-	``` ruby
-	def foobar
-    	puts "Hello world!"
-	end
-	```
+John não sabia nem o que a função `go_to()` fazia!
 ```
-=======
-\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
-ruby! --> 
+
+No GitHub Flavored Markdown, você pode usar uma sintaxe especial para código.
+
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
 def foobar
-    puts "Hello world!"
+    puts "Olá mundo!"
 end
-\`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` -->
+&#x60;&#x60;&#x60;</code></pre>

-O texto acima não requer recuo, além disso o GitHub vai usar a sintaxe highlight da linguagem que você especificar após a \`\`\`.
+
+O texto acima não requer indentação, além disso o GitHub vai usar o destaque
+de sintaxe da linguagem qeu você especificar após a tag <code>```</code>.

 ## Linha Horizontal
-Linhas horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
-com ou sem espaços.
+
+Linhas horizontais são facilmente adicionadas com três ou mais asteriscos ou
+hífens, com ou sem espaços.

 ```md
 ***
@ -229,17 +249,19 @@ com ou sem espaços.
 ```

 ## Links
-Uma das melhores coisas sobre a marcação é o quão fácil é fazer ligações. Colocar 
-o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses ()
+
+Uma das melhores coisas sobre o Mardkwon é o quão fácil é criar links.
+Coloque o texto a ser exibido entre colchetes [] seguido pela url entre
+parênteses ()

 ```md
-[Click aqui!](http://test.com/)
+[Clique aqui!](http://test.com/)
 ```

-Você também pode adicionar um título link usando aspas dentro dos parênteses
+Você também pode adicionar um título ao link usando aspas dentro dos parênteses.

 ```md
-[Click aqui!](http://test.com/ "Link para Test.com")
+[Cliqueaqui!](http://test.com/ "Link para Test.com")
 ```

 Caminhos relativos funcionam também.
@ -248,46 +270,64 @@ Caminhos relativos funcionam também.
 [Ir para música](/música/).
 ```

-Markdown também suporta ligações de estilo de referência
+O Markdown também suporta links para referências no texto.

-```md
-[Clique neste link] [link1] para mais informações sobre isso!
-[Além disso, verifique este link] [foobar] se você quiser.
+<pre><code class="highlight">&#x5b;<span class="nv">Clique nesse link</span>][<span class="ss">link1</span>] para mais informações!
+&#x5b;<span class="nv">Também cheque esse link</span>][<span class="ss">foobar</span>] se você quiser.

-[link1]: http://test.com/ "Legal!"
-[foobar]: http://foobar.biz/ "OK!"
-```
+&#x5b;<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Legal!"</span>
+&#x5b;<span class="nv">link2r</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Certo!"</span></code></pre>

 O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
-inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência 
-pode ser qualquer um, desde que eles são únicos.
+inteiramente. As referências podem estar em qualquer lugar no documento e os
+IDs de referência podem ser qualquer um, desde que eles sejam únicos.

-Existe também a "nomeação implicita", que permite que você use o texto do link como o id
+Existe também a "nomeação implícita", que permite que você use o texto do link
+como o id:
+
+<pre><code class="highlight">&#x5b;<span class="nv">Isso</span>][] é um link.
+
+&#x5b;<span class="nv">Isso</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+
+
+Mas geralmente não são usados.
+
+### Tabela de conteúdo
+
+Alguns sabores de Markdown fazem inclusive uso de combinação de listas, links e
+cabeçalhos de modo a criar uma tabela de conteúdo. Nesse caso, títulos em
+cabeçalhos são precedidos de (`#`) e são usados como ids para links. Se o
+cabeçalho consistir de várias palavras, elas serão conectadas por hífens (`-`),
+que também substitui alguns caracteres especiais. (Embora alguns outros
+carácteres especiais sejam omitidos.)

 ```md
-[Este] [] é um link. 
-
-[este]: http://thisisalink.com/ 
+- [Cabeçalho](#cabecalho)
+- [Um outro cabeçalho](#outro-cabecalho)
+- [Capítulo](#capitulo)
+  - [Subcapítulo <h3 />](#subcapitulo-h3-)
 ```

-Mas não são usados normalmente
+De qualquer modo, esse é um recurso que talvez não funcione em todas as
+implementações do Markdown da mesma forma.

 ## Imagens
-As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente!
+
+As imagens são feitas da mesma forma que os links, mas com um ponto de
+exclamação na frente!

 ```md
-![Este é pairar-texto (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
+![Este é alt-text (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
 ```

 E estilo de referência funciona como esperado

-```md
-![Este é o pairar-texto.][Myimage] 
+<pre><code class="highlight">!&#x5b;<span class="nv">Esse é o alt-attribute.</span>][<span class="ss">myimage</span>]

-[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" 
-```
+&#x5b;<span class="nv">Minha imagem</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"se precisar de um título, está aqui"</span></code></pre>

 ## Miscelânea 
+
 ### Auto-links 

 ```md
@ -303,14 +343,25 @@ E estilo de referência funciona como esperado

 ### Escapando caracteres

-Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja 
+Quero digitar *Este texto entre asteriscos*, mas eu não quero que ele seja 
 em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.

+### Teclas do teclado
+
+No GitHub Flavored Markdown, você pode usar a tag `<kbd>` para representar uma
+tecla do teclado.
+
+```md
+Seu computador travou? Tente apertar
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
 ### Tabelas 
+
 Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
 complicadas, mas se você realmente quer:
-```md

+```md
 | Col1         | Col2     | Col3          |
 | :----------- | :------: | ------------: |
 | esquerda-alin| Centrado | direita-alinh |
@ -325,8 +376,22 @@ Col 1 | Col2 | Col3
 Ugh isso é tão feio | faça isto | parar
 ```

-Fim!
+## Markdownlint
+
+De modo a simplificar o trabalho com Markdown e padronizar estilo de código, o
+`Markdownlint` foi criado. Essa ferramenta está disponível como plugin para
+algumas interfaces de desenvolvimento (IDEs) e pode ser utilizada como um
+utilitário para garantir validade e legibilidade do Markdown.

 ---
-Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
-e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+
+## Leitura complementar
+
+Para mais informações, confira o post oficial de John Gruber sobre sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
+e o do cheatsheet do Adam Pritchard [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+
+Se você quiser aprender mais sobre recursos de alguns sabores específicos de
+Markdown, veja:
+
+- [GitHub flavored Markdown](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax)
+- [GitLab flavored Markdown](https://docs.gitlab.com/ee/user/markdown.html)
--- a/pt-br/pythonstatcomp-pt.html.markdown
+++ b/pt-br/pythonstatcomp-pt.html.markdown
@ -6,6 +6,7 @@ contributors:
 translators:
    - ["waltercjunior", "https://github.com/waltercjunior"]
 filename: pythonstatcomp-pt.py
+lang: pt-br
 ---

 Este é um tutorial sobre como fazer algumas tarefas típicas de programação estatística usando Python.
--- a/rst.html.markdown
+++ b/rst.html.markdown
@ -33,7 +33,7 @@ $ pip install docutils
 A simple example of the file syntax:

 ```
-.. Lines starting with two dots are special commands. But if no command can be found, the line is considered as a comment
+.. Lines starting with two dots are special commands. But if no command can be found, the line is considered as a comment.

 =========================================================
 Main titles are written using equals signs over and under
@ -80,12 +80,12 @@ France      Paris
 Japan       Tokyo
 =========== ========

-More complex tables can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this :)
+More complex tables can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this. :)

 There are multiple ways to make links:

 - By adding an underscore after a word : Github_ and by adding the target URL after the text (this way has the advantage of not inserting unnecessary URLs in the visible text).
- By typing a full comprehensible URL : https://github.com/ (will be automatically converted to a link)
+- By typing a full comprehensible URL : https://github.com/ (will be automatically converted to a link).
 - By making a more Markdown-like link: `Github <https://github.com/>`_ .

 .. _Github: https://github.com/
--- a/solidity.html.markdown
+++ b/solidity.html.markdown
@ -214,7 +214,7 @@ assert(c >= a); // assert tests for internal invariants; require is used for use
 // https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol


-// No random functions built in, you can get a pseduo-random number by hashing the current blockhash, or get a truely random number using something like Chainlink VRF. 
+// No random functions built in, you can get a pseduo-random number by hashing the current blockhash, or get a truly random number using something like Chainlink VRF. 
 // https://docs.chain.link/docs/get-a-random-number

 // Type casting
@ -396,13 +396,13 @@ function increment(uint x) returns (uint) {
    return x;
 }

-// Functions can return many arguments, and by specifying returned arguments
-// name don't need to explicitly return
+// Functions can return many arguments,
+// and by specifying returned arguments name explicit return is not needed
 function increment(uint x, uint y) returns (uint x, uint y) {
    x += 1;
    y += 1;
 }
-// Call previous functon
+// Call previous function
 uint (a,b) = increment(1,1);

 // 'view' (alias for 'constant')
@ -654,7 +654,7 @@ reveal(100, "mySecret");
 // Time-based implementations of contracts are also done through oracles, as 
 // contracts need to be directly called and can not "subscribe" to a time. 
 // Due to smart contracts being decentralized, you also want to get your data
-// in a decentralized manner, other your run into the centralized risk that 
+// in a decentralized manner, otherwise you run into the centralized risk that 
 // smart contract design matter prevents. 

 // To easiest way get and use pre-boxed decentralized data is with Chainlink Data Feeds
--- a/tr-tr/bf-tr.html.markdown
+++ b/tr-tr/bf-tr.html.markdown
@ -1,6 +1,6 @@
 ---
 language: bf
-filename: brainfuck-tr
+filename: brainfuck-tr.bf
 contributors:
    - ["Prajit Ramachandran", "http://prajitr.github.io"]
 translators:
--- a/vimscript.html.markdown
+++ b/vimscript.html.markdown
@ -42,7 +42,7 @@ pwd                   " Displays the current working directory
 " comment (echo assumes that the quotation mark begins a string)
 echo 'Hello world!'  | " Displays a message

-" Line breaks can be escaped by pacing a backslash as the first non-whitespace
+" Line breaks can be escaped by placing a backslash as the first non-whitespace
 " character on the *following* line. Only works in script files, not on the
 " command line
 echo " Hello
--- a/zh-cn/awk-cn.html.markdown
+++ b/zh-cn/awk-cn.html.markdown
@ -179,7 +179,7 @@ function string_functions(    localvar, arr) {
    # 都是返回替换的个数
    localvar = "fooooobar"
    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"

    # 搜索匹配正则的字符串
    # index() 也是搜索, 不支持正则
--- a/zh-cn/docker-cn.html.markdown
+++ b/zh-cn/docker-cn.html.markdown
@ -1,5 +1,6 @@
 ---
-language: docker
+category: tool
+tool: docker
 lang: zh-cn
 filename: docker-cn.bat
 contributors:
--- a/zh-cn/gdscript-cn.html.markdown
+++ b/zh-cn/gdscript-cn.html.markdown
@ -0,0 +1,314 @@
+---
+language: GDScript
+contributors:
+    - ["Wichamir", "https://github.com/Wichamir/"]
+translators:
+    - ["ShiftWatchOut", "https://github.com/ShiftWatchOut"]
+filename: learngdscript-cn.gd
+lang: zh-cn
+---
+
+GDScript 是一种动态类型的脚本语言，专门为免费开源游戏引擎 Godot 制作。 GDScript 的语法类似 Python。
+它的主要优点是易于使用和与引擎深度集成。 它非常适合游戏开发。
+
+## 基础
+
+```nim
+# 单行注释使用 # 号书写。
+"""
+  多行
+  注释
+  是
+  使用
+  文档字符串(docstring)
+  书写。
+"""
+
+# 脚本文件本身默认是一个类，文件名为类名，您也可以为其定义其他名称。
+class_name MyClass
+
+# 继承
+extends Node2D
+
+# 成员变量
+var x = 8 # 整型
+var y = 1.2 # 浮点型
+var b = true # 布尔型
+var s = "Hello World!" # 字符串
+var a = [1, false, "brown fox"] # 数组(Array) - 类似于 Python 的列表(list),
+                                # 它可以同时保存不同类型的变量。
+var d = {
+  "key" : "value",
+  42 : true
+} # 字典包含键值对。
+var p_arr = PoolStringArray(["Hi", "there", "!"]) # 池数组只能包含单一类型。
+                                                  # 放入其他类型会被转换为目标类型
+
+# 内置向量类型:
+var v2 = Vector2(1, 2)
+var v3 = Vector3(1, 2, 3)
+
+# 常量
+const ANSWER_TO_EVERYTHING = 42
+const BREAKFAST = "Spam and eggs!"
+
+# 枚举
+enum { ZERO, ONE , TWO, THREE }
+enum NamedEnum { ONE = 1, TWO, THREE }
+
+# 导出的变量将在检查器中可见。
+export(int) var age
+export(float) var height
+export var person_name = "Bob" # 如果设置了默认值，则不需要类型注解。
+
+# 函数
+func foo():
+  pass # pass 关键字是未书写的代码的占位符
+
+func add(first, second):
+  return first + second
+
+# 打印值
+func printing():
+  print("GDScript ", "简直", "棒呆了")
+  prints("这", "些", "字", "被", "空", "格", "分", "割")
+  printt("这", "些", "字", "被", "制", "表", "符", "分", "割")
+  printraw("这句话将被打印到系统控制台。")
+
+# 数学
+func doing_math():
+  var first = 8
+  var second = 4
+  print(first + second) # 12
+  print(first - second) # 4
+  print(first * second) # 32
+  print(first / second) # 2
+  print(first % second) # 0
+  # 还有 +=, -=, *=, /=, %= 等操作符，但并没有 ++ 和 -- .
+  print(pow(first, 2)) # 64
+  print(sqrt(second)) # 2
+  printt(PI, TAU, INF, NAN) # 内置常量
+
+# 控制流
+func control_flow():
+  x = 8
+  y = 2 # y 最初被设为一个浮点数，
+        # 但我们可以利用语言提供的动态类型能力将它的类型变为整型！
+  
+  if x < y:
+    print("x 小于 y")
+  elif x > y:
+    print("x 大于 y")
+  else:
+    print("x 等于 y")
+  
+  var a = true
+  var b = false
+  var c = false
+  if a and b or not c: # 你也可以用 &&, || 和 !
+    print("看到这句说明上面的条件判断为真！")
+
+  for i in range(20): # GDScript 有类似 Python 的 range 函数
+    print(i) # 所以这句将打印从 0 到 19 的数字
+
+  for i in ["two", 3, 1.0]: # 遍历数组
+    print(i)
+  
+  while x > y:
+    printt(x, y)
+    y += 1
+
+  x = 2
+  y = 10
+  while x < y:
+    x += 1
+    if x == 6:
+      continue # continue 语句使 x 等于 6 时，程序跳过这次循环后面的代码，不会打印 6。
+    prints("x 等于：", x)
+    if x == 7:
+      break # 循环将在 x 等于 7 处跳出，后续所有循环不再执行，因此不会打印 8、9 和 10
+
+  match x:
+    1:
+      print("match 很像其他语言中的 switch.")
+    2:
+      print("但是，您不需要在每个值之前写一个 case 关键字。")
+    3:
+      print("此外，每种情况都会默认跳出。")
+      break # 错误！不要在 match 里用 break 语句！
+    4:
+      print("如果您需要跳过后续代码，这里也使用 continue 关键字。")
+      continue
+    _:
+      print("下划线分支，在其他分支都不满足时，在这里书写默认的逻辑。")
+  
+  # 三元运算符 (写在一行的 if-else 语句)
+  prints("x 是", "正值" if x >= 0 else "负值")
+
+# 类型转换
+func casting_examples():
+  var i = 42
+  var f = float(42) # 使用变量构造函数强制转换
+  var b = i as bool # 或使用 as 关键字
+
+# 重载函数
+# 通常，我们只会重载以下划线开头的内置函数，
+# 但实际上您可以重载几乎任何函数。
+
+# _init 在对象初始化时被调用。
+# 这是对象的构造函数。
+func _init():
+  # 在此处初始化对象的内部属性。
+  pass
+
+# _ready 在脚本节点及其子节点进入场景树时被调用。
+func _ready():
+  pass
+
+# _process 在每一帧上都被调用。
+func _process(delta):
+  # 传递给此函数的 delta 参数是时间，即从上一帧到当前帧经过的秒数。
+  print("Delta 时间为：", delta)
+
+# _physics_process 在每个物理帧上都被调用。
+# 这意味着 delta 应该是恒定的。
+func _physics_process(delta):
+  # 使用向量加法和乘法进行简单移动。
+  var direction = Vector2(1, 0) # 或使用 Vector2.RIGHT
+  var speed = 100.0
+  self.global_position += direction * speed * delta
+  # self 指向当前类的实例
+
+# 重载函数时，您可以使用 . 运算符调用父函数
+# like here:
+func get_children():
+  # 在这里做一些额外的事情。
+  var r = .get_children() # 调用父函数的实现
+  return r
+
+# 内部类
+class InnerClass:
+  extends Object
+
+  func hello():
+    print("来自内部类的 Hello！")
+
+func use_inner_class():
+  var ic = InnerClass.new()
+  ic.hello()
+  ic.free() # 可以自行释放内存
+```
+
+## 访问场景树中其他节点
+
+```nim
+extends Node2D
+
+var sprite # 该变量将用来保存引用。
+
+# 您可以在 _ready 中获取对其他节点的引用。
+func _ready() -> void:
+  # NodePath 对于访问节点很有用。
+  # 将 String 传递给其构造函数来创建 NodePath：
+  var path1 = NodePath("path/to/something")
+  # 或者使用 NodePath 字面量:
+  var path2 = @"path/to/something"
+  # NodePath 示例:
+  var path3 = @"Sprite" # 相对路径，当前节点的直接子节点
+  var path4 = @"Timers/Firerate" # 相对路径，子节点的子节点
+  var path5 = @".." # 当前节点的父节点
+  var path6 = @"../Enemy" # 当前节点的兄弟节点
+  var path7 = @"/root" # 绝对路径，等价于 get_tree().get_root()
+  var path8 = @"/root/Main/Player/Sprite" # Player 的 Sprite 的绝对路径
+  var path9 = @"Timers/Firerate:wait_time" # 访问属性
+  var path10 = @"Player:position:x" # 访问子属性
+
+  # 最后，获取节点引用可以使用以下方法:
+  sprite = get_node(@"Sprite") as Sprite # 始终转换为您期望的类型
+  sprite = get_node("Sprite") as Sprite # 这里 String 被隐式转换为 NodePath
+  sprite = get_node(path3) as Sprite
+  sprite = get_node_or_null("Sprite") as Sprite
+  sprite = $Sprite as Sprite
+
+func _process(delta):
+  # 现在我们就可以在别处使用 sprite 里保存的引用了。
+  prints("Sprite 有一个全局位置 ", sprite.global_position)
+
+# 在 _ready 执行之前，使用 onready 关键字为变量赋值。
+# 这是一种常用的语法糖。
+onready var tween = $Tween as Tween
+
+# 您可以导出这个 NodePath，以便在检查器中给它赋值。
+export var nodepath = @""
+onready var reference = get_node(nodepath) as Node
+```
+
+## 信号(Signals)
+
+信号系统是 Godot 对观察者编程模式的实现。例子如下:
+
+```nim
+class_name Player extends Node2D
+
+var hp = 10
+
+signal died() # 定义一个信号
+signal hurt(hp_old, hp_new) # 信号可以带参数
+
+func apply_damage(dmg):
+  var hp_old = hp
+  hp -= dmg
+  emit_signal("hurt", hp_old, hp) # 发出信号并传递参数
+  if hp <= 0:
+    emit_signal("died")
+
+func _ready():
+  # 将信号 "died" 连接到 self 中定义的 _on_death 函数
+  self.connect("died", self, "_on_death")
+
+func _on_death():
+  self.queue_free() # 死亡时销毁 Player
+```
+
+## 类型注解
+
+GDScript 可以选择性地使用静态类型。
+
+```nim
+extends Node
+
+var x: int # 定义带有类型的变量
+var y: float = 4.2
+var z := 1.0 # 使用 := 运算符根据默认值推断类型
+
+onready var node_ref_typed := $Child as Node
+
+export var speed := 50.0
+
+const CONSTANT := "Typed constant."
+
+func _ready() -> void:
+  # 此函数不返回任何东西
+  x = "string" # 错误！不要更改类型！
+  return
+
+func join(arg1: String, arg2: String) -> String:
+  # 此函数接受两个 String 并返回一个 String。
+  return arg1 + arg2
+
+func get_child_at(index: int) -> Node:
+  # 此函数接受一个 int 并返回一个 Node
+  return get_children()[index]
+
+signal example(arg: int) # 错误！信号不能接受类型参数！
+```
+
+## 延展阅读
+
+* [Godot's Website](https://godotengine.org/)
+* [Godot Docs](https://docs.godotengine.org/en/stable/)
+* [Getting started with GDScript](https://docs.godotengine.org/en/stable/getting_started/scripting/gdscript/index.html)
+* [NodePath](https://docs.godotengine.org/en/stable/classes/class_nodepath.html)
+* [Signals](https://docs.godotengine.org/en/stable/getting_started/step_by_step/signals.html)
+* [GDQuest](https://www.gdquest.com/)
+* [GDScript.com](https://gdscript.com/)