summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--bash.html.markdown208
-rw-r--r--cobol.html.markdown2
-rw-r--r--de-de/vim-de.html.markdown308
-rw-r--r--fr-fr/javascript-fr.html.markdown2
-rw-r--r--fr-fr/set-theory-fr.html.markdown2
-rw-r--r--hy.html.markdown3
-rw-r--r--ldpl.html.markdown7
-rw-r--r--markdown.html.markdown13
-rw-r--r--pt-br/dart-pt.html.markdown5
-rw-r--r--pt-br/processing-pt.html.markdown480
-rw-r--r--python.html.markdown95
-rw-r--r--rdf.html.markdown2
-rw-r--r--vim.html.markdown2
-rw-r--r--yaml.html.markdown112
14 files changed, 884 insertions, 357 deletions
diff --git a/bash.html.markdown b/bash.html.markdown
index c9a805ba..e0e4f88a 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -18,6 +18,7 @@ contributors:
- ["Harry Mumford-Turner", "https://github.com/harrymt"]
- ["Martin Nicholson", "https://github.com/mn113"]
- ["Mark Grimwood", "https://github.com/MarkGrimwood"]
+ - ["Emily Grace Seville", "https://github.com/EmilySeville7cfg"]
filename: LearnBash.sh
translators:
- ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
@@ -37,104 +38,107 @@ or executed directly in the shell.
# As you already figured, comments start with #. Shebang is also a comment.
# Simple hello world example:
-echo Hello world! # => Hello world!
+echo "Hello world!" # => Hello world!
# Each command starts on a new line, or after a semicolon:
-echo 'This is the first line'; echo 'This is the second line'
-# => This is the first line
-# => This is the second line
+echo "This is the first command"; echo "This is the second command"
+# => This is the first command
+# => This is the second command
# Declaring a variable looks like this:
-Variable="Some string"
+variable="Some string"
# But not like this:
-Variable = "Some string" # => returns error "Variable: command not found"
-# Bash will decide that Variable is a command it must execute and give an error
+variable = "Some string" # => returns error "variable: command not found"
+# Bash will decide that `variable` is a command it must execute and give an error
# because it can't be found.
# Nor like this:
-Variable= 'Some string' # => returns error: "Some string: command not found"
-# Bash will decide that 'Some string' is a command it must execute and give an
-# error because it can't be found. (In this case the 'Variable=' part is seen
-# as a variable assignment valid only for the scope of the 'Some string'
-# command.)
+variable= "Some string" # => returns error: "Some string: command not found"
+# Bash will decide that "Some string" is a command it must execute and give an
+# error because it can't be found. In this case the "variable=" part is seen
+# as a variable assignment valid only for the scope of the "Some string"
+# command.
# Using the variable:
-echo $Variable # => Some string
-echo "$Variable" # => Some string
-echo '$Variable' # => $Variable
-# When you use the variable itself — assign it, export it, or else — you write
+echo "$variable" # => Some string
+echo '$variable' # => $variable
+# When you use a variable itself — assign it, export it, or else — you write
# its name without $. If you want to use the variable's value, you should use $.
# Note that ' (single quote) won't expand the variables!
-
-# Parameter expansion ${ }:
-echo ${Variable} # => Some string
-# This is a simple usage of parameter expansion
-# Parameter Expansion gets a value from a variable.
-# It "expands" or prints the value
-# During the expansion time the value or parameter can be modified
-# Below are other modifications that add onto this expansion
-
-# String substitution in variables
-echo ${Variable/Some/A} # => A string
-# This will substitute the first occurrence of "Some" with "A"
-
-# Substring from a variable
-Length=7
-echo ${Variable:0:Length} # => Some st
+# You can write variable without surrounding quotes but it's not recommended.
+
+# Parameter expansion ${...}:
+echo "${variable}" # => Some string
+# This is a simple usage of parameter expansion such as two examples above.
+# Parameter expansion gets a value from a variable.
+# It "expands" or prints the value.
+# During the expansion time the value or parameter can be modified.
+# Below are other modifications that add onto this expansion.
+
+# String substitution in variables:
+echo "${variable/Some/A}" # => A string
+# This will substitute the first occurrence of "Some" with "A".
+
+# Substring from a variable:
+length=7
+echo "${variable:0:length}" # => Some st
# This will return only the first 7 characters of the value
-echo ${Variable: -5} # => tring
-# This will return the last 5 characters (note the space before -5)
+echo "${variable: -5}" # => tring
+# This will return the last 5 characters (note the space before -5).
+# The space before minus is mandatory here.
-# String length
-echo ${#Variable} # => 11
+# String length:
+echo "${#variable}" # => 11
-# Indirect expansion
-OtherVariable="Variable"
-echo ${!OtherVariable} # => Some String
-# This will expand the value of OtherVariable
+# Indirect expansion:
+other_variable="variable"
+echo ${!other_variable} # => Some string
+# This will expand the value of `other_variable`.
-# Default value for variable
-echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# The default value for variable:
+echo "${foo:-"DefaultValueIfFooIsMissingOrEmpty"}"
# => DefaultValueIfFooIsMissingOrEmpty
-# This works for null (Foo=) and empty string (Foo=""); zero (Foo=0) returns 0.
+# This works for null (foo=) and empty string (foo=""); zero (foo=0) returns 0.
# Note that it only returns default value and doesn't change variable value.
-# Declare an array with 6 elements
-array0=(one two three four five six)
-# Print first element
-echo $array0 # => "one"
-# Print first element
-echo ${array0[0]} # => "one"
-# Print all elements
-echo ${array0[@]} # => "one two three four five six"
-# Print number of elements
-echo ${#array0[@]} # => "6"
-# Print number of characters in third element
-echo ${#array0[2]} # => "5"
-# 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
- echo "$i"
+# Declare an array with 6 elements:
+array=(one two three four five six)
+# Print the first element:
+echo "${array[0]}" # => "one"
+# Print all elements:
+echo "${array[@]}" # => "one two three four five six"
+# Print the number of elements:
+echo "${#array[@]}" # => "6"
+# Print the number of characters in third element
+echo "${#array[2]}" # => "5"
+# Print 2 elements starting from fourth:
+echo "${array[@]:3:2}" # => "four five"
+# Print all elements each of them on new line.
+for item in "${array[@]}"; do
+ echo "$item"
done
-# Brace Expansion { }
-# Used to generate arbitrary strings
-echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
-echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
-# This will output the range from the start value to the end value
-
# Built-in variables:
-# There are some useful built-in variables, like
+# There are some useful built-in variables, like:
echo "Last program's return value: $?"
echo "Script's PID: $$"
echo "Number of arguments passed to script: $#"
echo "All arguments passed to script: $@"
echo "Script's arguments separated into different variables: $1 $2..."
+# Brace Expansion {...}
+# used to generate arbitrary strings:
+echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
+echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
+# This will output the range from the start value to the end value.
+# Note that you can't use variables here:
+from=1
+to=10
+echo {$from..$to} # => {$from..$to}
+
# Now that we know how to echo and use variables,
-# let's learn some of the other basics of bash!
+# let's learn some of the other basics of Bash!
# Our current directory is available through the command `pwd`.
# `pwd` stands for "print working directory".
@@ -144,33 +148,46 @@ echo "I'm in $(pwd)" # execs `pwd` and interpolates output
echo "I'm in $PWD" # interpolates the variable
# If you get too much output in your terminal, or from a script, the command
-# `clear` clears your screen
+# `clear` clears your screen:
clear
-# Ctrl-L also works for clearing output
+# Ctrl-L also works for clearing output.
# Reading a value from input:
echo "What's your name?"
-read Name # Note that we didn't need to declare a new variable
-echo Hello, $Name!
+read name
+# Note that we didn't need to declare a new variable.
+echo "Hello, $name!"
-# We have the usual if structure:
-# use `man test` for more info about conditionals
-if [ $Name != $USER ]
-then
+# We have the usual if structure.
+# Condition is true if the value of $name is not equal to the current user's login username:
+if [[ "$name" != "$USER" ]]; then
echo "Your name isn't your username"
else
echo "Your name is your username"
fi
-# True if the value of $Name is not equal to the current user's login username
-# NOTE: if $Name is empty, bash sees the above condition as:
-if [ != $USER ]
-# which is invalid syntax
-# so the "safe" way to use potentially empty variables in bash is:
-if [ "$Name" != $USER ] ...
-# which, when $Name is empty, is seen by bash as:
-if [ "" != $USER ] ...
-# which works as expected
+# To use && and || with if statements, you need multiple pairs of square brackets:
+read age
+if [[ "$name" == "Steve" ]] && [[ "$age" -eq 15 ]]; then
+ echo "This will run if $name is Steve AND $age is 15."
+fi
+
+if [[ "$name" == "Daniya" ]] || [[ "$name" == "Zach" ]]; then
+ echo "This will run if $name is Daniya OR Zach."
+fi
+# There are other comparison operators for numbers listed below:
+# -ne - not equal
+# -lt - less than
+# -gt - greater than
+# -le - less than or equal to
+# -ge - greater than or equal to
+
+# There is also the `=~` operator, which tests a string against the Regex pattern:
+email=me@example.com
+if [[ "$email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
+then
+ echo "Valid email!"
+fi
# There is also conditional execution
echo "Always executed" || echo "Only executed if first command fails"
@@ -193,27 +210,6 @@ bg
kill %2
# %1, %2, etc. can be used for fg and bg as well
-# To use && and || with if statements, you need multiple pairs of square brackets:
-if [ "$Name" == "Steve" ] && [ "$Age" -eq 15 ]
-then
- echo "This will run if $Name is Steve AND $Age is 15."
-fi
-
-if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
-then
- echo "This will run if $Name is Daniya OR Zach."
-fi
-
-# There is also the `=~` operator, which tests a string against a Regex pattern:
-Email=me@example.com
-if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
-then
- echo "Valid email!"
-fi
-# Note that =~ only works within double [[ ]] square brackets,
-# which are subtly different from single [ ].
-# See https://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs for more on this.
-
# Redefine command `ping` as alias to send only 5 packets
alias ping='ping -c 5'
# Escape the alias and use command with this name instead
diff --git a/cobol.html.markdown b/cobol.html.markdown
index 1c858396..1350c66f 100644
--- a/cobol.html.markdown
+++ b/cobol.html.markdown
@@ -132,7 +132,7 @@ organizations.
*Now it is time to learn about two related COBOL verbs: string and unstring.
- *The string verb is used to concatenate, or put together, two or more stings.
+ *The string verb is used to concatenate, or put together, two or more strings.
*Unstring is used, not surprisingly, to separate a
*string into two or more smaller strings.
*It is important that you remember to use ‘delimited by’ when you
diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 93fd9773..d0b4eb9d 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -3,94 +3,92 @@ category: tool
tool: vim
lang: de-de
contributors:
- - ["RadhikaG", "https://github.com/RadhikaG"]
+- ["RadhikaG", "https://github.com/RadhikaG"]
translators:
- - ["caminsha", "https://github.com/caminsha"]
+- ["caminsha", "https://github.com/caminsha"]
filename: LearnVim-de.txt
---
-
[Vim](http://www.vim.org)
(Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
-Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt
-wurde.
-Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten
-einer Datei.
+Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
+wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
+bearbeiten einer Datei.
## Grundlagen, um in Vim zu navigieren
```
- vim <filename> # Öffne <filename> in Vim
- :help <topic> # Öffne die eingebaute Hilfe zum Thema <topic>, wenn
- # es existiert
- :q # Schließe vim
- :w # Speichere diese Datei
- :wq # Speichere diese Datei und schließe vim
- ZZ # Speichere diese Datei und schließe vim
- :q! # Schließe vim ohne die Datei zu speichern
- # ! *zwingt* die Ausführung von :q,
- # daher wird die Datei nicht gespeichert.
- ZQ # Beende vim ohne die Datei zu speichern
- :x # Speichere die Datei und beende vim
- # Dies ist eine kürzere Version von :wq
-
- u # Änderung rückgängig machen
- CTRL+R # Änderung wiederherstellen
-
- h # Den Cursor um ein Zeichen nach links bewegen
- j # Den Cursor eine Zeile nach unten bewegen
- k # Den Cursor eine Zeile nach oben bewegen
- l # Den Cursor um ein Zeichen nach rechts bewegen
-
- Ctrl+B # Gehe eine Bildschirmanzeige zurück
- Ctrl+F # Gehe eine Bildschirmanzeige vorwärts
- Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts
- Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück
-
- # Navigieren innerhalb einer Zeile
-
- 0 # Navigiere zum Anfang der Zeile
- $ # Navigiere zum Ende der Zeile
- ^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
-
- # Im Text suchen
-
- /word # Hebt alle Ergebnisse nach dem Cursor hervor
- ?word # Hebt alle Ergebnisse vor dem Cursor hervor
- n # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
- N # Bewegt den Cursor zum vorherigen Ergebnis der Suche
-
- :%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen
- :s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile
- :%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch
- # ein carriage return
-
- # Zu einzelnen Zeichen springen
-
- f<character> # Springe vorwärts und auf dem Zeichen <character>
- t<character> # Springe vorwärts und lande vor dem Zeichen <character>
-
- # Zum Beispiel,
- f< # Springe vorwärts und lande auf <
- t< # Springe vorwärts und lande vor <
-
- # Wortweise navigieren
-
- w # Springe um ein Wort vorwärts
- b # Gehe ein Wort zurück
- e # Springe zum Ende des aktuellen Wortes
-
- # Weitere Befehle, um zu navigieren
-
- gg # Gehe an den Start der Datei
- G # Gehe an das Ende der Datei
- :NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
- H # Navigiere zum Start der aktuellen Bildschirmanzeige
- M # Navigiere in die Mitte der aktuellen Bildschirmanzeige
- L # Navigiere an das Ende der aktuellen Bildschirmanzeige
+vim <filename> # Öffne <filename> in Vim
+:help <topic> # Öffne die eingebaute Hilfe zum Thema <topic>, wenn
+ # es existiert
+:q # Schließe vim
+:w # Speichere diese Datei
+:wq # Speichere diese Datei und schließe vim
+ZZ # Speichere diese Datei und schließe vim
+:q! # Schließe vim ohne die Datei zu speichern
+ # ! *zwingt* die Ausführung von :q,
+ # daher wird die Datei nicht gespeichert.
+ZQ # Beende vim ohne die Datei zu speichern
+:x # Speichere die Datei und beende vim
+ # Dies ist eine kürzere Version von :wq
+
+u # Änderung rückgängig machen
+CTRL+R # Änderung wiederherstellen
+
+h # Den Cursor um ein Zeichen nach links bewegen
+j # Den Cursor eine Zeile nach unten bewegen
+k # Den Cursor eine Zeile nach oben bewegen
+l # Den Cursor um ein Zeichen nach rechts bewegen
+
+Ctrl+B # Gehe eine Bildschirmanzeige zurück
+Ctrl+F # Gehe eine Bildschirmanzeige vorwärts
+Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts
+Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück
+
+# Navigieren innerhalb einer Zeile
+
+0 # Navigiere zum Anfang der Zeile
+$ # Navigiere zum Ende der Zeile
+^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
+
+# Im Text suchen
+
+/word # Hebt alle Ergebnisse nach dem Cursor hervor
+?word # Hebt alle Ergebnisse vor dem Cursor hervor
+n # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
+N # Bewegt den Cursor zum vorherigen Ergebnis der Suche
+
+:%s/foo/bar/g # Ersetze "foo" durch "bar" in allen Zeilen
+:s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile
+:%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch
+ # ein carriage return
+
+# Zu einzelnen Zeichen springen
+
+f<character> # Springe vorwärts und auf dem Zeichen <character>
+t<character> # Springe vorwärts und lande vor dem Zeichen <character>
+
+# Zum Beispiel,
+f< # Springe vorwärts und lande auf <
+t< # Springe vorwärts und lande vor <
+
+# Wortweise navigieren
+
+w # Springe um ein Wort vorwärts
+b # Gehe ein Wort zurück
+e # Springe zum Ende des aktuellen Wortes
+
+# Weitere Befehle, um zu navigieren
+
+gg # Gehe an den Start der Datei
+G # Gehe an das Ende der Datei
+:NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
+H # Navigiere zum Start der aktuellen Bildschirmanzeige
+M # Navigiere in die Mitte der aktuellen Bildschirmanzeige
+L # Navigiere an das Ende der aktuellen Bildschirmanzeige
```
-## Hilfsdokumente:
+## Hilfsdokumente
Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen
werden kann.
@@ -98,34 +96,33 @@ Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren
`:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
Hilfsdialog an, welcher den Start mit vim einfacher macht.
-that aims to make getting started with vim more approachable!
-## Modi:
+## Modi
Vim basiert auf dem Konzept von **modes**.
-- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und Befehle eingeben
+- Command Mode - Vims erster Modus, hier kann man navigieren und Befehle eingeben
- Insert Mode - Wird verwendet, um Änderungen in der Datei zu machen.
-- Visual Mode - Wird verwendet, um Text zu markieren und Operationen durchzuführen
+- Visual Mode - Wird verwendet, um Text zu markieren und diesen zu verändern
- Ex Mode - Wird verwendet, um im ':'-Prompt Befehle einzugeben
```
- i # Führt vim in den Insert Mode, vor der Cursorposition
- a # Führt vim in den Insert Mode, nach der Cursorposition
- v # Führt vim in den Visual Mode
- : # Führt vim in den Ex Mode
- <esc> # Führt zurück in den Command Mode, egal in welchem Mode
- # man sich gerade befindet.
-
- # Kopieren und einfügen von Text
-
- y # Kopiere alles, was im Moment ausgewählt ist
- yy # Kopiert die aktuelle Zeile
- d # Löscht alles, was im Moment ausgewählt ist
- dd # Löscht die aktuelle Zeile
- p # Fügt den kopierten Text nach dem Cursor ein
- P # Fügt den kopierten Text vor dem Cursor ein
- x # Löscht das Zeichen unter dem Cursor
+i # Führt vim in den Insert Mode, vor der Cursorposition
+a # Führt vim in den Insert Mode, nach der Cursorposition
+v # Führt vim in den Visual Mode
+: # Führt vim in den Ex Mode
+<esc> # Führt zurück in den Command Mode, egal in welchem Mode
+ # man sich gerade befindet.
+
+# Kopieren und einfügen von Text
+
+y # Kopiere alles, was im Moment ausgewählt ist
+yy # Kopiert die aktuelle Zeile
+d # Löscht alles, was im Moment ausgewählt ist
+dd # Löscht die aktuelle Zeile
+p # Fügt den kopierten Text nach dem Cursor ein
+P # Fügt den kopierten Text vor dem Cursor ein
+x # Löscht das Zeichen unter dem Cursor
```
## Die 'Grammatik' von Vim
@@ -140,68 +137,67 @@ Vim kann als Satz von Kommandos angesehen werden, welche im Format
Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
```
- # 'Verb'
-
- d # löschen
- c # ändern
- y # kopieren
- v # visuelles auswählen
-
- # 'Modifiers'
-
- i # innerhalb
- a # außerhalb
- NUM # Nummer (NUM kann irgendeine Zahl sein)
- f # Sucht nach etwas und landet darauf
- t # Sucht nach etwas und stoppt davor
- / # Suche eine Zeichenfolge ab dem Cursor
- ? # Suche eine Zeichenfolge vor dem Cursor
-
- # 'Nouns'
-
- w # Wort
- s # Satz
- p # Abschnitt
- b # Block
-
- # Beispielsätze resp. Kommandos
-
- d2w # lösche zwei Wörter
- cis # Ändere innerhalb des Satzes.
- yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
- # in welchem du bist)
- ct< # Ändere bis zur spitzen Klammer
- # Ändere den Text von deiner aktuellen Cursorposition bis
- # zur nächsten spitzen Klammer
- d$ # Lösche bis zum Ende der Zeile
+# 'Verb'
+
+d # löschen
+c # ändern
+y # kopieren
+v # visuelles auswählen
+
+# 'Modifiers'
+
+i # innerhalb
+a # außerhalb
+NUM # Nummer (NUM kann irgendeine Zahl sein)
+f # Sucht nach etwas und landet darauf
+t # Sucht nach etwas und stoppt davor
+/ # Suche eine Zeichenfolge ab dem Cursor
+? # Suche eine Zeichenfolge vor dem Cursor
+
+# 'Nouns'
+
+w # Wort
+s # Satz
+p # Abschnitt
+b # Block
+
+# Beispielsätze resp. Kommandos
+
+d2w # lösche zwei Wörter
+cis # Ändere innerhalb des Satzes.
+yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
+ # in welchem du bist)
+ct< # Ändere bis zur spitzen Klammer
+ # Ändere den Text von deiner aktuellen Cursorposition bis
+ # zur nächsten spitzen Klammer
+d$ # Lösche bis zum Ende der Zeile
```
## Einige Shortcuts und Tricks
```
- > # Rücke die Auswahl um einen Block ein
- < # Lösche eine Einrückung der Auswahl
- :earlier 15m # Stellt das Dokument so wieder her, wie es vor 15
- # Minuten war
- :later 15m # den oberen Befehl rückgängig machen
- ddp # Vertauschen zweier aufeinanderfolgenden Zeilen
- # Zuerst dd, dann p
- . # Wiederhole die vorherige Aktion
- :w !sudo tee % # Speichere die Datei als Root
- :set syntax=c # Stelle das Syntax-Highlighting für 'C' ein
- :sort # Alle Zeilen sortieren
- :sort! # Alle Zeilen rückwärts sortieren
- :sort u # Alle Zeilen sortieren und Duplikate entfernen
- ~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
- u # Ausgewählten Text zu Kleinschreibung ändern
- U # Ausgewählten Text zu Großschreibung ändern
-
- # Text-Folding (Textfaltung)
- zf # Erstelle eine Faltung des ausgewählten Textes
- zo # Öffne die aktuelle Faltung
- zc # Schließe die aktuelle Faltung
- zR # Öffne alle Faltungen
- zM # Schließe alle Faltungen
+> # Rücke die Auswahl um einen Block ein
+< # Lösche eine Einrückung der Auswahl
+:earlier 15m # Stellt das Dokument so wieder her, wie es vor 15 Minuten war
+:later 15m # den oberen Befehl rückgängig machen
+ddp # Vertauschen zweier aufeinanderfolgenden Zeilen
+ # Zuerst dd, dann p
+. # Wiederhole die vorherige Aktion
+:w !sudo tee % # Speichere die Datei als Root
+:set syntax=c # Stelle das Syntax-Highlighting für 'C' ein
+:sort # Alle Zeilen sortieren
+:sort! # Alle Zeilen rückwärts sortieren
+:sort u # Alle Zeilen sortieren und Duplikate entfernen
+~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
+u # Ausgewählten Text zu Kleinschreibung ändern
+U # Ausgewählten Text zu Großschreibung ändern
+
+# Text-Folding (Textfaltung)
+zf # Erstelle eine Faltung des ausgewählten Textes
+zo # Öffne die aktuelle Faltung
+zc # Schließe die aktuelle Faltung
+zR # Öffne alle Faltungen
+zM # Schließe alle Faltungen
```
## Makros
@@ -212,9 +208,9 @@ Kommandos, welche du braucht, aufgenommen bis die Aufnahme gestoppt wird.
Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht.
```
- qa # Starte das Aufnehmen des Makros 'a'
- q # Beende das Aufnehmen
- @a # Führe das Makro 'a' aus
+qa # Starte das Aufnehmen des Makros 'a'
+q # Beende das Aufnehmen
+@a # Führe das Makro 'a' aus
```
### Konfigurieren mit ~/.vimrc
diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 186859ab..308f1ca8 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -94,7 +94,7 @@ let banta = "Harry", santa = "Hermione";
// L'égalité est === ou ==
// === compare la valeur exacte 2 === '2' // = false
-// == convertit la valeur pour comparer 2 === '2' // = true
+// == convertit la valeur pour comparer 2 == '2' // = true
// En général, il vaut mieux utiliser === pour ne pas faire d'erreur.
1 === 1; // = true
2 === 1; // = false
diff --git a/fr-fr/set-theory-fr.html.markdown b/fr-fr/set-theory-fr.html.markdown
index 543bd98b..d1ac2711 100644
--- a/fr-fr/set-theory-fr.html.markdown
+++ b/fr-fr/set-theory-fr.html.markdown
@@ -125,7 +125,7 @@ A △ B = (A \ B) ∪ (B \ A)
```
### Produit cartésien
-Le produit cartésien de deux ensembles `A` et `B` est l'ensemble contenant tous les couples dont la première élément appartient à `A` et la deuxième à `B`.
+Le produit cartésien de deux ensembles `A` et `B` est l'ensemble contenant tous les couples dont le premier élément appartient à `A` et le deuxième à `B`.
```
A × B = { (x, y) | x ∈ A, y ∈ B }
diff --git a/hy.html.markdown b/hy.html.markdown
index 1287095f..f6bdead0 100644
--- a/hy.html.markdown
+++ b/hy.html.markdown
@@ -13,8 +13,7 @@ hy to call native python code or python to call native hy code as well
This tutorial works for hy ≥ 0.9.12, with some corrections for hy 0.11.
```clojure
-;; this gives an gentle introduction to hy for a quick trial head to
-;; http://try-hy.appspot.com
+;; this gives an gentle introduction to hy
;;
; Semicolon comments, like other LISPS
diff --git a/ldpl.html.markdown b/ldpl.html.markdown
index 86603d94..449c8670 100644
--- a/ldpl.html.markdown
+++ b/ldpl.html.markdown
@@ -3,6 +3,7 @@ language: LDPL
filename: learnLDPL.ldpl
contributors:
- ["Martín del Río", "https://github.com/lartu"]
+ - ["John Paul Wohlscheid", "https://github.com/JohnBlood"]
---
**LDPL** is a powerful, C++ transpiled, open-source programming language designed
@@ -68,7 +69,7 @@ else if myMap:"someIndex" is not equal to 45 then
else
display "Else!" crlf
end if
-# Valid LDPL comparisson operators are
+# Valid LDPL comparison operators are
# - IS EQUAL TO
# - IS NOT EQUAL TO
# - IS LESS THAN
@@ -123,8 +124,8 @@ get random in myNumber # get a random number between 0 and 1
# files, are divided in sections. The sections found in sub-procedures are
# the PARAMETERS section, the LOCAL DATA section and the PROCEDURE section.
# All sections except the PROCEDURE section can be skipped if they aren't
-# used. If no PARAMTERS nor LOCAL DATA sections are used, the PROCEDURE
-# keyword may be omited.
+# used. If no PARAMETERS nor LOCAL DATA sections are used, the PROCEDURE
+# keyword may be omitted.
sub myFunction
parameters:
a is number # LDPL is pass by reference
diff --git a/markdown.html.markdown b/markdown.html.markdown
index a6000910..cfc0ddf3 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -40,9 +40,9 @@ specific to a certain parser.
Markdown is a superset of HTML, so any HTML file is valid Markdown.
```md
-<!--This means we can use HTML elements in Markdown, such as the comment
-element, and they won't be affected by a markdown parser. However, if you
-create an HTML element in your markdown file, you cannot use markdown syntax
+<!--This means we can use HTML elements in Markdown, such as the comment
+element, and they won't be affected by a markdown parser. However, if you
+create an HTML element in your markdown file, you cannot use markdown syntax
within that element's contents.-->
```
@@ -370,9 +370,10 @@ Ugh this is so ugly | make it | stop
## Markdownlint
In order to simplify work with Markdown and to unify its coding style,
-`Markdownlint` has been created. This tool is available also as a plugin for
-some IDEs and can be used as an utility to ensure validity and readability of
-Markdown.
+`Markdownlint` has been created. Available as a
+[separate tool](https://github.com/markdownlint/markdownlint)
+as well as a plugin for some IDEs, it can be used to ensure validity and
+readability of Markdown.
---
diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown
index e9d72850..6aff1ac3 100644
--- a/pt-br/dart-pt.html.markdown
+++ b/pt-br/dart-pt.html.markdown
@@ -3,15 +3,16 @@ language: dart
filename: learndart-pt.dart
contributors:
- ["Joao Pedrosa", "https://github.com/jpedrosa/"]
+ - ["Hélio Oliveira", "https://github.com/insign/"]
translators:
- ["Junior Damacena", "https://github.com/jdamacena/"]
lang: pt-br
---
Dart é uma novata no reino das linguagens de programação.
-Ela empresta muito de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o Browser.
+Ela absorve muitas teorias de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o navegador.
-A característica mais controversa da Dart é a sua Tipagem Opcional, ou seja, não é obrigatório declarar tipos.
+As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à função de [detecção automática](https://dart.dev/guides/language/type-system#type-inference).
```dart
import "dart:collection";
diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
new file mode 100644
index 00000000..5ed2950a
--- /dev/null
+++ b/pt-br/processing-pt.html.markdown
@@ -0,0 +1,480 @@
+---
+language: processing
+filename: learnprocessing.pde
+contributors:
+ - ["Phone Thant Ko", "http://github.com/phonethantko"]
+ - ["Divay Prakash", "https://github.com/divayprakash"]
+translators:
+ - ["Kemel Zaidan", "https://github.com/kemelzaidan"]
+lang: pt-br
+---
+
+## Introdução
+
+Processing é uma linguagem de programação para criação de artes digitais e
+conteúdo multimídia, permitindo que não programadores aprendam os fundamentos
+da programação computacional em um contexto visual.
+
+Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente
+influenciado por ambas as sintaxes Java e Javascript.
+[Veja mais aqui](https://processing.org/reference/)
+
+A linguagem é tipada estaticamente e também vem com o seu Ambiente de Desenvolvimento
+Integrado (do inglês Integrated Development Environment - IDE) oficial para
+compilar e executar os scripts.
+
+```
+/* ---------
+ Comentários
+ ---------
+*/
+
+// Comentário de linha única começa com //
+
+/*
+ Como o Processing é baseado em Java,
+ a sintaxe para seus comentários é a mesma do Java (como você deve ter notado
+ acima)!
+ Comentários de várias linhas são agrupados como visto aqui.
+*/
+
+/* ---------------------------------------
+ Escrevendo e executando programas em Processing
+ ---------------------------------------
+*/
+
+// No Processing, o ponto de entrada do programa é uma função chamada setup()
+// com um tipo de retorno void.
+// Observação! A sintaxe é muito semelhante à do C++.
+void setup() {
+ // Isso imprime a saída clássica "Hello World!" no console quando executado.
+ println("Olá Mundo!"); // Mais uma linguagem com esse maldito ponto e vírgula, não é?
+}
+
+// Normalmente, colocamos todos os códigos estáticos dentro do método setup()
+// como o próprio nome sugere, uma vez que é executado apenas uma vez.
+// Pode variar da definição das cores de fundo, ou o tamanho da tela.
+background(color); //define a cor do fundo
+size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro
+// opcional para definir o renderizador
+// Você verá mais sobre isso ao longo deste documento.
+
+// Se você deseja executar os códigos indefinidamente, eles devem ser colocados
+// dentro do método draw()
+// draw() deve existir caso você queira que o código seja executado
+// continuamente e, obviamente, só pode haver um método draw().
+int = 0;
+void draw(){
+ // Este bloco de código faz um loop para sempre até parar
+ imprima(i);
+ i++; // Operador de incremento!
+}
+
+// Agora que sabemos como escrever o script de trabalho e como executá-lo,
+// continuaremos a explorar quais tipos de dados e coleções são suportados no
+// Processing.
+
+/* ------------------------
+ Tipos de dados e coleções
+ ------------------------
+*/
+
+// De acordo com as Referências do Processing, ele suporta 8 tipos primitivos
+// de dados da seguinte forma.
+
+boolean valorBoleano = true; // Boleano
+byte valorByteDeA = 23; // Byte
+char valorCharDeA = 'A'; // Caractere
+color valorDeCorBrancoM = color(255, 255, 255); // Cor (especificada usando
+// método color())
+color valorDeCorBrancoH = #FFFFFF; // Cor (especificada usando valor de hash)
+int valor = 5; // Inteiro (Número sem decimais)
+long valorLongo = 2147483648L; // "L" é adicionado ao número para marcá-lo como um longo
+float valorFloat = 1,12345; // Float (números de ponto flutuante de 32 bits)
+double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits)
+
+// NOTA!
+// Embora os tipos de dados "long" e "double" funcionem na linguagem,
+// funções do Processing não usam esses tipos de dados, portanto
+// eles precisam ser convertidos em tipos de dados "int" e "float",
+// respectivamente, usando a sintaxe (int) e (float) antes de passar para uma
+// função.
+
+// Existem vários tipos de dados compostos que estão disponíveis por padrão para
+// uso no Processing.
+// Primeiramente, farei um resumo dos mais usados ​​para economizar tempo.
+
+// String
+// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas
+// duplas.
+string stringExemplo = "Olá, Processing!";
+// String também pode ser criada a partir de um array de tipos de dados char.
+// Nós vamos discutir array muito em breve.
+char fonte = {'H', 'E', 'L', 'L', 'O'};
+String stringDeFonte = new String(source); // HELLO
+// Como em Java, strings podem ser concatenadas usando o operador "+".
+print("Olá " + "Mundo!"); // Olá Mundo!
+
+// Array
+// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os
+// próprios objetos. Como os arrays são semelhantes aos objetos, eles devem
+// ser criados com a palavra-chave "new".
+int[] arrayInt = new int[5];
+int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados.
+
+// Lista de Arrays
+// As funções são semelhantes às do array; arraylists podem conter qualquer
+// tipo de dados. A única diferença é que as listas de matrizes são
+// redimensionadas dinamicamente, pois é uma forma de implementação de matriz
+// redimensionável da interface "List" do Java .
+ArrayList<Integer> intArrayList = new ArrayList<Integer>();
+
+// Objeto
+// Como é baseado em Java, o Processing suporta programação orientada a objetos.
+// Isso significa que você pode basicamente definir quaisquer tipos de dados de
+// sua preferência e manipulá-los para suas necessidades.
+// Claro, uma classe tem que ser definida antes para o objeto que você quer.
+// Formato --> NomeClasse NameInstancia
+UmaClasseQualquer meuObjeto // então instancia mais tarde
+//ou
+UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
+
+// O Processing surge com mais coleções (ex. - Dicionários e Listas) por
+// padrão, por uma questão de simplicidade, vou deixá-los fora da discussão aqui.
+
+/* ------------
+ Matemática
+ ------------
+*/
+
+// Aritmética
+1 + 1 // 2
+2 - 1 // 1
+2 * 3 // 6
+3/2 // 1
+3.0 / 2 // 1.5
+3.0% 2 // 1.0
+
+// O Processing também vem com um conjunto de funções que simplificam operações
+// matemáticas.
+float f = sq(3); // f = 9.0
+float p = pow(3, 3); // p = 27.0
+int a = abs(-13); // a = 13
+int r1 = round(3.1); // r1 = 3
+int r2 = round(3.7); // r2 = 4
+float sr = sqrt(25); // sr = 5.0
+
+// Vetores
+// O Processing fornece uma maneira fácil de implementar vetores em seu ambiente
+// usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e
+// vem com um conjunto de métodos que são úteis para operações com matrizes.
+// Você pode encontrar mais informações sobre a classe PVector e suas funções
+// aqui. (https://processing.org/reference/PVector.html)
+
+// Trigonometria
+// O Processing também suporta operações trigonométricas fornecendo um
+// conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também
+// degrees() e radians() para conversão conveniente.
+// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é
+// necessário converter previamente.
+float um = sin(PI/2); // um = 1.0
+// Como você deve ter notado, existe um conjunto de constantes para usos
+// trigonométricos; PI, HALF_PI, QUARTER_PI e assim por diante...
+
+/* -------------
+ Controle de fluxo
+ -------------
+*/
+
+// Declarações Condicionais
+// Instruções If - A mesma sintaxe das instruções if em Java.
+if (author.getAppearance().equals("quente")) {
+ print("Narcisismo no máximo!");
+} else {
+ // Você pode verificar outras condições aqui.
+ print("Algo está realmente errado aqui!");
+}
+// Um ​​atalho para instruções if-else também pode ser usado.
+int = 3;
+String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
+
+// A estrutura switch-case pode ser usada para verificar várias condições de
+// forma concisa. É importante usar a instrução break. Se a instrução `break`
+// não existe o programa executa todos os casos a seguir após um caso ser
+// verdadeiro.
+int valor = 2;
+switch(valor) {
+ case 0:
+ print("Nada!"); // Isso não é executado.
+ break; // Salta para a próxima instrução
+ case 1:
+ print("Chegando lá..."); // Isso novamente não é executado.
+ break;
+ case 2:
+ print("Bravo!"); // Esta linha é executada.
+ break;
+ default:
+ print("Não encontrado!"); // Esta linha é executada se nosso valor for algum outro valor.
+ break;
+}
+
+// Declarações iterativas
+// Declarações For - Novamente, a mesma sintaxe que em Java
+for(int i = 0; i < 5; i++){
+ print(i); // imprime de 0 a 4
+}
+
+// Declarações While - Novamente, nada de novo se você estiver familiarizado com
+// a sintaxe Java.
+int j = 3;
+while(j > 0) {
+ print(j);
+ j--; // Isso é importante para evitar que o código seja executado indefinidamente.
+}
+
+// loop()| noLoop() | redraw() | exit()
+// Estas são mais funções específicas do Processing para configurar o fluxo do
+// programa.
+loop(); // permite que o método draw() seja executado para sempre enquanto
+noLoop(); // só permite que ele seja executado uma vez.
+redraw(); // executa o método draw() mais uma vez.
+exit(); // Isso para o programa. É útil para programas com draw()
+// rodando continuamente.
+```
+
+## Desenho com Processing
+
+Como você já deve ter entendido o básico da linguagem, vamos agora
+ver a melhor parte do Processing - DESENHAR.
+
+```
+/* ------
+ Formas
+ ------
+*/
+
+// Formas 2D
+
+// Ponto
+point(x, y); // No espaço 2D
+point(x, y, z); // No espaço 3D
+// Desenha um ponto no espaço de coordenadas.
+
+// Linha
+line(x1, y1, x2, y2); // No espaço 2D
+line(x1, y1, z1, x2, y2, z2); // No espaço 3D
+// Desenha uma linha conectando dois pontos definidos por (x1, y1) e (x2, y2).
+
+// Triângulo
+triangle(x1, y1, x2, y2, x3, y3);
+// Desenha um triângulo conectando três pontos definidos por parâmetros de coordenadas.
+
+// Retângulo
+rect(a, b, c, d, [r]); // Com parâmetro opcional definindo o raio de todos os cantos
+rect(a, b, c, d, [te, td, bd, be]); // Com conjunto opcional de parâmetros definindo
+// raio de cada canto
+// Desenha um retângulo com {a, b} como coordenada superior esquerda e c e d como largura
+// e altura respectivamente.
+
+// Quad
+quad(x, y, x2, y2, x3, y3, x4, y4);
+// Desenha um quadrilátero com parâmetros que definem as coordenadas de cada canto
+// ponto.
+
+// Elipse
+ellipse(x, y, largura, altura);
+// Desenha um eclipse no ponto {x, y} com largura e altura especificadas.
+
+// Arco
+arc(x, y, largura, altura, inicio, fim, [modo]);
+// Enquanto os primeiros quatro parâmetros são autoexplicativos,
+// início e fim definem os ângulos que o arco começa e termina (em radianos).
+// O parâmetro opcional [mode] define o preenchimento;
+// PIE dá o contorno de torta, CHORD dá o contorno reto e OPEN é como
+// CHORD porém sem contorno
+
+// Curvas
+// O Processing fornece duas implementações de curvas; usando curve() e
+// bezier(). Como pretendo manter isso simples, não vou discutir mais detalhes.
+// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as
+// referências: (https://processing.org/reference/curve_.html)
+// (https://processing.org/reference/bezier_.html)
+
+// Formas 3D
+
+// espaço 3D
+pode ser configurado definindo "P3D" para o parâmetro do renderizador no
+// método size().
+size(largura, altura, P3D);
+// No espaço 3D, você terá que traduzir para a coordenada específica para
+// renderiza as formas 3D.
+
+// Caixa
+box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho
+box(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente
+
+// Esfera
+sphere(raio); // Seu tamanho é definido usando o parâmetro raio
+// O mecanismo por trás da renderização das esferas é implementado por
+// triângulos em mosaico. Dito isso, o nível de detalhe sendo renderizado é
+// controlado pela função sphereDetail(res)
+// Mais informações aqui: (https://processing.org/reference/sphereDetail_.html)
+
+// Formas irregulares
+// E se você quiser desenhar algo que não foi disponibilizado pelo Processing
+// funções?
+// Você pode usar beginShape(), endShape(), vertex(x,y) para definir formas por
+// especificando cada ponto. Mais informações aqui:
+// (https://processing.org/reference/beginShape_.html)
+// Você também pode usar formas personalizadas usando a classe PShape:
+// (https://processing.org/reference/PShape.html)
+
+/* ---------------
+ Transformações
+ ---------------
+*/
+
+// As transformações são particularmente úteis para acompanhar o espaço de
+// coordenadas e os vértices das formas que você desenhou. Particularmente;
+// métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y)
+pushMatriz(); // Salva o sistema de coordenadas atual na pilha
+// ... aplique todas as transformações aqui ...
+popMatriz(); // Restaura o sistema de coordenadas salvo
+// Usando-os, o sistema de coordenadas pode ser preservado e visualizado sem
+// causar qualquer conflito.
+
+// Traduzir
+translate(x,y); // Traduz para o ponto{x, y} ou seja - configurando a origem para esse ponto
+translate(x, y, z); // Contraparte 3D da função
+
+// Rotacionar
+rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo
+// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão:
+// rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo)
+
+// Escala
+scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
+
+/* --------------------
+ Estilo e texturas
+ --------------------
+*/
+
+// Cores
+// Como discuti anteriormente, a cor de fundo pode ser configurada usando a
+// função background(). Você pode definir a cor de um objeto de antemão e depois
+// passar para a função como um argumento.
+color c = cor(255, 255, 255); // BRANCO!
+// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado
+// para HSB usando colorMode(). Leia mais aqui:
+// (https://processing.org/reference/colorMode_.html)
+background(c); // Até agora, a cor de fundo deve ser branca.
+// Você pode usar a função fill() para selecionar a cor para preencher as formas.
+// Tem que ser configurado antes de você começar a desenhar formas para que as
+// cores fiquem aplicadas.
+fill(color(0, 0, 0));
+// Se você quiser apenas colorir os contornos das formas, você pode usar
+// função stroke().
+stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparência
+// definido para um valor menor.
+
+// Imagens
+// O Processing pode renderizar imagens e usá-las de várias maneiras.
+// Principalmente armazenado como Tipo de dados PImage.
+filter(sombreador); // O Processing suporta várias funções de filtro para manipulação de imagens.
+texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas.
+```
+
+Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer. Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma
+documentação curta, então vou deixá-los aqui. Se você se interessar, por favor verifique as referências.
+
+```
+// Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas
+// para que você possa estender a funcionalidade do Processing para outros horizontes.
+
+/* -------
+ Importações
+ -------
+*/
+
+// As possibilidades do Processing pode ser estendidas ainda mais quando
+// importamos bibliotecas e pacotes em nossos esboços.
+// A instrução de importação pode ser escrita como abaixo na parte superior
+// do código-fonte.
+import processing.algumacoisa.*;
+```
+
+## VAC?
+
+Vamos ao código? Vamos sujar as mãos!
+
+Vamos ver um exemplo do openprocessing para visualizar o quanto o Processing é
+capaz de fazer com poucas linhas de código.
+
+Copie o código abaixo em seu IDE do Processing e veja a mágica.
+
+```
+// Isenção de responsabilidade: eu não escrevi este programa porque atualmente
+// estou ocupado com meu estágio e este sketch é adaptado do openprocessing pois
+// mostra algo legal com um código simples.
+// Recuperado de: (https://www.openprocessing.org/sketch/559769)
+
+float theta;
+float a;
+float col;
+float num;
+
+void setup() {
+ size(600,600);
+}
+
+void draw() {
+ background(#F2F2F2);
+ translate(width/2, height/2);
+ theta = map(sin(millis()/1000.0), -1, 1, 0, PI/6);
+
+ float num=6;
+ for (int i=0; i<num; i++) {
+ a =350;
+ rotate(TWO_PI/num);
+ branch(a);
+ }
+
+}
+
+void branch(float len) {
+ col=map(len, 0, 90, 150, 255);
+ fill(col, 0, 74);
+ stroke (col, 0, 74);
+ line(0, 0, 0, -len);
+ ellipse(0, -len, 3, 3);
+ len *= 0.7;
+
+ if (len>30) {
+ pushMatrix();
+ translate(0, -30);
+ rotate(theta);
+ branch(len);
+ popMatrix();
+
+ pushMatrix();
+ translate(0, -30);
+ rotate(-theta);
+ branch(len);
+ popMatrix();
+
+ }
+}
+```
+
+A linguagem Processing é fácil de aprender e é particularmente útil para criar
+conteúdo (mesmo em 3D) sem ter que digitar muitos códigos. É tão simples
+que você pode ler o código e ter uma ideia aproximada do fluxo do programa.
+
+No entanto, isso não se aplica quando você introduz bibliotecas externas, pacotes
+e até mesmo suas próprias aulas. (Confie em mim! Projetos em processing podem ficar realmente monstruosos...)
+
+## Alguns recursos úteis
+
+ - [Site do Processing](http://processing.org)
+ - [Sketches em Processing](http://openprocessing.org)
diff --git a/python.html.markdown b/python.html.markdown
index 0b115c4e..2247f263 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -9,14 +9,17 @@ contributors:
- ["Rommel Martinez", "https://ebzzry.io"]
- ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
- ["caminsha", "https://github.com/caminsha"]
+ - ["Stanislav Modrak", "https://stanislav.gq"]
filename: learnpython.py
---
-Python was created by Guido van Rossum in the early 90s. It is now one of the most popular
-languages in existence. I fell in love with Python for its syntactic clarity. It's basically
-executable pseudocode.
+Python was created by Guido van Rossum in the early 90s. It is now one of the
+most popular languages in existence. I fell in love with Python for its
+syntactic clarity. It's basically executable pseudocode.
-Note: This article applies to Python 3 specifically. Check out [here](http://learnxinyminutes.com/docs/pythonlegacy/) if you want to learn the old Python 2.7
+Note: This article applies to Python 3 specifically. Check out
+[here](http://learnxinyminutes.com/docs/pythonlegacy/) if you want to learn the
+old Python 2.7
```python
@@ -96,8 +99,9 @@ bool(set()) # => False
bool(4) # => True
bool(-6) # => True
-# Using boolean logical operators on ints casts them to booleans for evaluation, but their non-cast value is returned
-# Don't mix up with bool(ints) and bitwise and/or (&,|)
+# Using boolean logical operators on ints casts them to booleans for evaluation,
+# but their non-cast value is returned. Don't mix up with bool(ints) and bitwise
+# and/or (&,|)
bool(0) # => False
bool(2) # => True
0 and 2 # => 0
@@ -151,10 +155,10 @@ b == a # => True, a's and b's objects are equal
# You can find the length of a string
len("This is a string") # => 16
-# You can also format using f-strings or formatted string literals (in Python 3.6+)
+# Since Python 3.6, you can use f-strings or formatted string literals.
name = "Reiko"
f"She said her name is {name}." # => "She said her name is Reiko"
-# You can basically put any Python expression inside the braces and it will be output in the string.
+# Any valid Python expression inside these braces is returned to the string.
f"{name} is {len(name)} characters long." # => "Reiko is 5 characters long."
# None is an object
@@ -165,15 +169,6 @@ None # => None
"etc" is None # => False
None is None # => True
-# None, 0, and empty strings/lists/dicts/tuples/sets all evaluate to False.
-# All other values are True
-bool(0) # => False
-bool("") # => False
-bool([]) # => False
-bool({}) # => False
-bool(()) # => False
-bool(set()) # => False
-
####################################################
## 2. Variables and Collections
####################################################
@@ -302,7 +297,7 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
# Note keys for dictionaries have to be immutable types. This is to ensure that
# the key can be converted to a constant hash value for quick look-ups.
# Immutable types include ints, floats, strings, tuples.
-invalid_dict = {[1,2,3]: "123"} # => Raises a TypeError: unhashable type: 'list'
+invalid_dict = {[1,2,3]: "123"} # => Yield a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]} # Values can be of any type, however.
# Look up values with []
@@ -356,7 +351,7 @@ del filled_dict["one"] # Removes the key "one" from filled dict
# Sets store ... well sets
empty_set = set()
-# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
+# Initialize a set with a bunch of values.
some_set = {1, 1, 2, 2, 3, 4} # some_set is now {1, 2, 3, 4}
# Similar to keys of a dictionary, elements of a set have to be immutable.
@@ -428,7 +423,7 @@ for animal in ["dog", "cat", "mouse"]:
"""
"range(number)" returns an iterable of numbers
-from zero to the given number
+from zero up to (but excluding) the given number
prints:
0
1
@@ -462,8 +457,7 @@ for i in range(4, 8, 2):
print(i)
"""
-To loop over a list, and retrieve both the index and the value of each item in the list
-prints:
+Loop over a list to retrieve both the index and the value of each list item:
0 dog
1 cat
2 mouse
@@ -490,10 +484,11 @@ try:
# Use "raise" to raise an error
raise IndexError("This is an index error")
except IndexError as e:
- pass # Pass is just a no-op. Usually you would do recovery here.
+ pass # Refrain from this, provide a recovery (next example).
except (TypeError, NameError):
- pass # Multiple exceptions can be handled together, if required.
-else: # Optional clause to the try/except block. Must follow all except blocks
+ pass # Multiple exceptions can be processed jointly.
+else: # Optional clause to the try/except block. Must follow
+ # all except blocks.
print("All good!") # Runs only if the code in try raises no exceptions
finally: # Execute under all circumstances
print("We can clean up resources here")
@@ -529,7 +524,8 @@ print(contents)
filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
-print(our_iterable) # => dict_keys(['one', 'two', 'three']). This is an object that implements our Iterable interface.
+print(our_iterable) # => dict_keys(['one', 'two', 'three']). This is an object
+ # that implements our Iterable interface.
# We can loop over it.
for i in our_iterable:
@@ -541,15 +537,16 @@ our_iterable[1] # Raises a TypeError
# An iterable is an object that knows how to create an iterator.
our_iterator = iter(our_iterable)
-# Our iterator is an object that can remember the state as we traverse through it.
-# We get the next object with "next()".
+# Our iterator is an object that can remember the state as we traverse through
+# it. We get the next object with "next()".
next(our_iterator) # => "one"
# It maintains state as we iterate.
next(our_iterator) # => "two"
next(our_iterator) # => "three"
-# After the iterator has returned all of its data, it raises a StopIteration exception
+# After the iterator has returned all of its data, it raises a
+# StopIteration exception
next(our_iterator) # Raises StopIteration
# We can also loop over it, in fact, "for" does this implicitly!
@@ -557,7 +554,7 @@ our_iterator = iter(our_iterable)
for i in our_iterator:
print(i) # Prints one, two, three
-# You can grab all the elements of an iterable or iterator by calling list() on it.
+# You can grab all the elements of an iterable or iterator by call of list().
list(our_iterable) # => Returns ["one", "two", "three"]
list(our_iterator) # => Returns [] because state is saved
@@ -607,9 +604,9 @@ all_the_args(1, 2, a=3, b=4) prints:
# Use * to expand tuples and use ** to expand kwargs.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
-all_the_args(*args) # equivalent to all_the_args(1, 2, 3, 4)
-all_the_args(**kwargs) # equivalent to all_the_args(a=3, b=4)
-all_the_args(*args, **kwargs) # equivalent to all_the_args(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args) # equivalent: all_the_args(1, 2, 3, 4)
+all_the_args(**kwargs) # equivalent: all_the_args(a=3, b=4)
+all_the_args(*args, **kwargs) # equivalent: all_the_args(1, 2, 3, 4, a=3, b=4)
# Returning multiple values (with tuple assignments)
def swap(x, y):
@@ -619,17 +616,19 @@ def swap(x, y):
x = 1
y = 2
x, y = swap(x, y) # => x = 2, y = 1
-# (x, y) = swap(x,y) # Again parenthesis have been excluded but can be included.
+# (x, y) = swap(x,y) # Again the use of parenthesis is optional.
-# Function Scope
+# global scope
x = 5
def set_x(num):
- # Local var x not the same as global variable x
+ # local scope begins here
+ # local var x not the same as global var x
x = num # => 43
print(x) # => 43
def set_global_x(num):
+ # global indicates that particular var lives in the global scope
global x
print(x) # => 5
x = num # global var x is now set to 6
@@ -637,6 +636,12 @@ def set_global_x(num):
set_x(43)
set_global_x(6)
+"""
+prints:
+ 43
+ 5
+ 6
+"""
# Python has first class functions
@@ -659,7 +664,7 @@ list(map(max, [1, 2, 3], [4, 2, 1])) # => [4, 2, 3]
list(filter(lambda x: x > 5, [3, 4, 5, 6, 7])) # => [6, 7]
# We can use list comprehensions for nice maps and filters
-# List comprehension stores the output as a list which can itself be a nested list
+# List comprehension stores the output as a list (which itself may be nested).
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
@@ -719,8 +724,8 @@ class Human:
# Note that the double leading and trailing underscores denote objects
# or attributes that are used by Python but that live in user-controlled
# namespaces. Methods(or objects or attributes) like: __init__, __str__,
- # __repr__ etc. are called special methods (or sometimes called dunder methods)
- # You should not invent such names on your own.
+ # __repr__ etc. are called special methods (or sometimes called dunder
+ # methods). You should not invent such names on your own.
def __init__(self, name):
# Assign the argument to the instance's name attribute
self.name = name
@@ -774,7 +779,7 @@ if __name__ == '__main__':
i.say("hi") # "Ian: hi"
j = Human("Joel")
j.say("hello") # "Joel: hello"
- # i and j are instances of type Human, or in other words: they are Human objects
+ # i and j are instances of type Human; i.e., they are Human objects.
# Call our class method
i.say(i.get_species()) # "Ian: H. sapiens"
@@ -811,8 +816,8 @@ if __name__ == '__main__':
# "species", "name", and "age", as well as methods, like "sing" and "grunt"
# from the Human class, but can also have its own unique properties.
-# To take advantage of modularization by file you could place the classes above in their own files,
-# say, human.py
+# To take advantage of modularization by file you could place the classes above
+# in their own files, say, human.py
# To import functions from other files use the following format
# from "filename-without-extension" import "function-or-class"
@@ -936,8 +941,8 @@ class Batman(Superhero, Bat):
# However we are dealing with multiple inheritance here, and super()
# only works with the next base class in the MRO list.
# So instead we explicitly call __init__ for all ancestors.
- # The use of *args and **kwargs allows for a clean way to pass arguments,
- # with each parent "peeling a layer of the onion".
+ # The use of *args and **kwargs allows for a clean way to pass
+ # arguments, with each parent "peeling a layer of the onion".
Superhero.__init__(self, 'anonymous', movie=True,
superpowers=['Wealthy'], *args, **kwargs)
Bat.__init__(self, *args, can_fly=False, **kwargs)
@@ -1036,8 +1041,6 @@ print(say()) # Can you buy me a beer?
print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :(
```
-## Ready For More?
-
### Free Online
* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
diff --git a/rdf.html.markdown b/rdf.html.markdown
index 4cb7ddd0..5b2105b8 100644
--- a/rdf.html.markdown
+++ b/rdf.html.markdown
@@ -28,7 +28,7 @@ usually look like URLs but function as identifiers, not locators. The use of
URIs provides context for resource identifiers to make them unambiguous—for
example, to tell a book title from a job title.
-```turtle
+```
# The hash symbol is the comment delimiter.
# Turtle triple statements end with periods like natural language sentences.
diff --git a/vim.html.markdown b/vim.html.markdown
index f5be9b0d..e0fdf2e0 100644
--- a/vim.html.markdown
+++ b/vim.html.markdown
@@ -29,7 +29,7 @@ specific points in the file, and for fast editing.
:q! # Quit vim without saving file
# ! *forces* :q to execute, hence quiting vim without saving
ZQ # Quit vim without saving file
- :x # Save file and quit vim, shorter version of :wq
+ :x # Save file(only when the file is modified) and quit vim
u # Undo
CTRL+R # Redo
diff --git a/yaml.html.markdown b/yaml.html.markdown
index 6dc5905e..5c898148 100644
--- a/yaml.html.markdown
+++ b/yaml.html.markdown
@@ -2,8 +2,10 @@
language: yaml
filename: learnyaml.yaml
contributors:
+
- [Leigh Brenecki, 'https://leigh.net.au']
- [Suhas SG, 'https://github.com/jargnar']
+
---
YAML is a data serialisation language designed to be directly writable and
@@ -17,6 +19,7 @@ YAML doesn't allow literal tab characters for indentation.
--- # document start
# Comments in YAML look like this.
+# YAML support single-line comments.
################
# SCALAR TYPES #
@@ -28,11 +31,23 @@ key: value
another_key: Another value goes here.
a_number_value: 100
scientific_notation: 1e+12
-# The number 1 will be interpreted as a number, not a boolean. if you want
-# it to be interpreted as a boolean, use true
+hex_notation: 0x123 # evaluates to 291
+octal_notation: 0123 # evaluates to 83
+
+# The number 1 will be interpreted as a number, not a boolean.
+# If you want it to be interpreted as a boolean, use true.
boolean: true
null_value: null
key with spaces: value
+
+# Yes and No (doesn't matter the case) will be evaluated to boolean
+# true and false values respectively.
+# To use the actual value use single or double quotes.
+no: no # evaluates to "false": false
+yes: No # evaluates to "true": false
+not_enclosed: yes # evaluates to "not_enclosed": true
+enclosed: "yes" # evaluates to "enclosed": yes
+
# Notice that strings don't need to be quoted. However, they can be.
however: 'A string, enclosed in quotes.'
'Keys can be quoted too.': "Useful if you want to put a ':' in your key."
@@ -41,25 +56,49 @@ double quotes: "have many: \", \0, \t, \u263A, \x0d\x0a == \r\n, and more."
# UTF-8/16/32 characters need to be encoded
Superscript two: \u00B2
-# Multiple-line strings can be written either as a 'literal block' (using |),
+# Special characters must be enclosed in single or double quotes
+special_characters: "[ John ] & { Jane } - <Doe>"
+
+# Multiple-line strings can be written either as a 'literal block' (using |),
# or a 'folded block' (using '>').
+# Literal block turn every newline within the string into a literal newline (\n).
+# Folded block removes newlines within the string.
literal_block: |
- This entire block of text will be the value of the 'literal_block' key,
- with line breaks being preserved.
+ This entire block of text will be the value of the 'literal_block' key,
+ with line breaks being preserved.
- The literal continues until de-dented, and the leading indentation is
- stripped.
+ The literal continues until de-dented, and the leading indentation is
+ stripped.
- Any lines that are 'more-indented' keep the rest of their indentation -
- these lines will be indented by 4 spaces.
+ Any lines that are 'more-indented' keep the rest of their indentation -
+ these lines will be indented by 4 spaces.
folded_style: >
- This entire block of text will be the value of 'folded_style', but this
- time, all newlines will be replaced with a single space.
+ This entire block of text will be the value of 'folded_style', but this
+ time, all newlines will be replaced with a single space.
- Blank lines, like above, are converted to a newline character.
+ Blank lines, like above, are converted to a newline character.
- 'More-indented' lines keep their newlines, too -
- this text will appear over two lines.
+ 'More-indented' lines keep their newlines, too -
+ this text will appear over two lines.
+
+# |- and >- removes the trailing blank lines (also called literal/block "strip")
+literal_strip: |-
+ This entire block of text will be the value of the 'literal_block' key,
+ with trailing blank line being stripped.
+block_strip: >-
+ This entire block of text will be the value of 'folded_style', but this
+ time, all newlines will be replaced with a single space and
+ trailing blank line being stripped.
+
+# |+ and >+ keeps trailing blank lines (also called literal/block "keep")
+literal_keep: |+
+ This entire block of text will be the value of the 'literal_block' key,
+ with trailing blank line being kept.
+
+block_keep: >+
+ This entire block of text will be the value of 'folded_style', but this
+ time, all newlines will be replaced with a single space and
+ trailing blank line being kept.
####################
# COLLECTION TYPES #
@@ -87,7 +126,7 @@ a_nested_map:
# An example
? - Manchester United
- Real Madrid
-: [2001-01-01, 2002-02-02]
+: [ 2001-01-01, 2002-02-02 ]
# Sequences (equivalent to lists or arrays) look like this
# (note that the '-' counts as indentation):
@@ -98,24 +137,26 @@ a_sequence:
- Item 4
- key: value
another_key: another_value
- -
- - This is a sequence
+ - - This is a sequence
- inside another sequence
- - - Nested sequence indicators
- can be collapsed
# Since YAML is a superset of JSON, you can also write JSON-style maps and
# sequences:
-json_map: {"key": "value"}
-json_seq: [3, 2, 1, "takeoff"]
-and quotes are optional: {key: [3, 2, 1, takeoff]}
+json_map: { "key": "value" }
+json_seq: [ 3, 2, 1, "takeoff" ]
+and quotes are optional: { key: [ 3, 2, 1, takeoff ] }
#######################
# EXTRA YAML FEATURES #
#######################
# YAML also has a handy feature called 'anchors', which let you easily duplicate
-# content across your document. Both of these keys will have the same value:
+# content across your document.
+# Anchors identified by & character which define the value.
+# Aliases identified by * character which acts as "see above" command.
+# Both of these keys will have the same value:
anchored_content: &anchor_name This string will appear as the value of two keys.
other_anchor: *anchor_name
@@ -123,28 +164,35 @@ other_anchor: *anchor_name
base: &base
name: Everyone has same name
-# The regexp << is called Merge Key Language-Independent Type. It is used to
+# The regexp << is called 'Merge Key Language-Independent Type'. It is used to
# indicate that all the keys of one or more specified maps should be inserted
# into the current map.
-
+# NOTE: If key already exists alias will not be merged
foo:
- <<: *base
+ <<: *base # doesn't merge the anchor
age: 10
-
+ name: John
bar:
- <<: *base
+ <<: *base # base anchor will be merged
age: 20
# foo and bar would also have name: Everyone has same name
# YAML also has tags, which you can use to explicitly declare types.
+# Syntax: !![typeName] [value]
+explicit_boolean: !!bool true
+explicit_integer: !!int 42
+explicit_float: !!float -42.24
explicit_string: !!str 0.5
+explicit_datetime: !!timestamp 2022-11-17 12:34:56.78 +9
+explicit_null: !!null null
+
# Some parsers implement language specific tags, like this one for Python's
# complex number type.
python_complex_number: !!python/complex 1+2j
# We can also use yaml complex keys with language specific tags
-? !!python/tuple [5, 7]
+? !!python/tuple [ 5, 7 ]
: Fifty Seven
# Would be {(5, 7): 'Fifty Seven'} in Python
@@ -154,9 +202,10 @@ python_complex_number: !!python/complex 1+2j
# Strings and numbers aren't the only scalars that YAML can understand.
# ISO-formatted date and datetime literals are also parsed.
-datetime: 2001-12-15T02:59:43.1Z
-datetime_with_spaces: 2001-12-14 21:59:43.10 -5
-date: 2002-12-14
+datetime_canonical: 2001-12-15T02:59:43.1Z
+datetime_space_seperated_with_time_zone: 2001-12-14 21:59:43.10 -5
+date_implicit: 2002-12-14
+date_explicit: !!timestamp 2002-12-14
# The !!binary tag indicates that a string is actually a base64-encoded
# representation of a binary blob.
@@ -171,7 +220,7 @@ set:
? item1
? item2
? item3
-or: {item1, item2, item3}
+or: { item1, item2, item3 }
# Sets are just maps with null values; the above is equivalent to:
set2:
@@ -186,3 +235,4 @@ set2:
+ [YAML official website](https://yaml.org/)
+ [Online YAML Validator](http://www.yamllint.com/)
++ [JSON ⇆ YAML](https://www.json2yaml.com/)