info/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-08-13 18:24:39 +02:00
Code Issues Releases Wiki Activity

Merge branch 'master' of https://github.com/adambard/learnxinyminutes-docs into docker-docs

Browse Source
This commit is contained in:
Akshita Dixit
2022-11-27 14:36:29 +05:30
parent 00b99ceca0 7a505c1d0c
commit 66acfb83d1
11 changed files with 839 additions and 358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
awk.html.markdown
View File

@@ -118,12 +118,12 @@ BEGIN {
# Arrays # Arrays
arr[0] = "foo"; arr[0] = "foo";
arr[1] = "bar"; arr[1] = "bar";
# You can also initialize an array with the built-in function split() # You can also initialize an array with the built-in function split()
n = split("foo:bar:baz", arr, ":"); n = split("foo:bar:baz", arr, ":");
# You also have associative arrays (actually, they're all associative arrays) # You also have associative arrays (indeed, they're all associative arrays)
assoc["foo"] = "bar"; assoc["foo"] = "bar";
assoc["bar"] = "baz"; assoc["bar"] = "baz";
@@ -216,7 +216,8 @@ function string_functions( localvar, arr) {
match(localvar, "t"); # => 4, since the 't' is the fourth character match(localvar, "t"); # => 4, since the 't' is the fourth character
# Split on a delimiter # Split on a delimiter
n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3 n = split("foo-bar-baz", arr, "-");
# result: a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
# Other useful stuff # Other useful stuff
sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3" sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
@@ -238,9 +239,9 @@ function io_functions( localvar) {
# AWK doesn't have file handles, per se. It will automatically open a file # AWK doesn't have file handles, per se. It will automatically open a file
# handle for you when you use something that needs one. The string you used # handle for you when you use something that needs one. The string you used
# for this can be treated as a file handle, for purposes of I/O. This makes # for this can be treated as a file handle, for purposes of I/O. This makes
# it feel sort of like shell scripting, but to get the same output, the string # it feel sort of like shell scripting, but to get the same output, the
# must match exactly, so use a variable: # string must match exactly, so use a variable:
outfile = "/tmp/foobar.txt"; outfile = "/tmp/foobar.txt";
print "foobar" > outfile; print "foobar" > outfile;
@@ -261,7 +262,7 @@ function io_functions( localvar) {
# Reads a line from a file and stores in localvar # Reads a line from a file and stores in localvar
infile = "/tmp/foobar.txt"; infile = "/tmp/foobar.txt";
getline localvar < infile; getline localvar < infile;
close(infile); close(infile);
} }
@@ -273,10 +274,10 @@ function io_functions( localvar) {
# When you pass arguments to AWK, they are treated as file names to process. # When you pass arguments to AWK, they are treated as file names to process.
# It will process them all, in order. Think of it like an implicit for loop, # It will process them all, in order. Think of it like an implicit for loop,
# iterating over the lines in these files. these patterns and actions are like # iterating over the lines in these files. these patterns and actions are like
# switch statements inside the loop. # switch statements inside the loop.
/^fo+bar$/ { /^fo+bar$/ {
# This action will execute for every line that matches the regular # This action will execute for every line that matches the regular
# expression, /^fo+bar$/, and will be skipped for any line that fails to # expression, /^fo+bar$/, and will be skipped for any line that fails to
# match it. Let's just print the line: # match it. Let's just print the line:
@@ -376,11 +377,15 @@ END {
} }
``` ```
Further Reading: Further Reading:
* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html) * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
* [Awk man page](https://linux.die.net/man/1/awk) * [Awk man page](https://linux.die.net/man/1/awk)
* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems. * [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
GNU Awk is found on most Linux systems.
* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html) * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical summary and list of "gotchas" (places where different implementations may behave in different or unexpected ways). * [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical
summary and list of "gotchas" (places where different implementations may
behave in different or unexpected ways).
* [basic libraries for awk](https://github.com/dubiousjim/awkenough) * [basic libraries for awk](https://github.com/dubiousjim/awkenough)

202
bash.html.markdown
View File

@@ -18,6 +18,7 @@ contributors:
- ["Harry Mumford-Turner", "https://github.com/harrymt"] - ["Harry Mumford-Turner", "https://github.com/harrymt"]
- ["Martin Nicholson", "https://github.com/mn113"] - ["Martin Nicholson", "https://github.com/mn113"]
- ["Mark Grimwood", "https://github.com/MarkGrimwood"] - ["Mark Grimwood", "https://github.com/MarkGrimwood"]
- ["Emily Grace Seville", "https://github.com/EmilySeville7cfg"]
filename: LearnBash.sh filename: LearnBash.sh
translators: translators:
- ["Dimitri Kokkonis", "https://github.com/kokkonisd"] - ["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. # As you already figured, comments start with #. Shebang is also a comment.
# Simple hello world example: # 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: # Each command starts on a new line, or after a semicolon:
echo 'This is the first line'; echo 'This is the second line' echo "This is the first command"; echo "This is the second command"
# => This is the first line # => This is the first command
# => This is the second line # => This is the second command
# Declaring a variable looks like this: # Declaring a variable looks like this:
Variable="Some string" variable="Some string"
# But not like this: # But not like this:
Variable = "Some string" # => returns error "Variable: command not found" variable = "Some string" # => returns error "variable: command not found"
# Bash will decide that Variable is a command it must execute and give an error # Bash will decide that `variable` is a command it must execute and give an error
# because it can't be found. # because it can't be found.
# Nor like this: # Nor like this:
Variable= 'Some string' # => returns error: "Some string: command not found" 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 # 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 # 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' # as a variable assignment valid only for the scope of the "Some string"
# command.) # command.
# Using the variable: # Using the variable:
echo $Variable # => Some string echo "$variable" # => Some string
echo "$Variable" # => Some string echo '$variable' # => $variable
echo '$Variable' # => $Variable # When you use a variable itself — assign it, export it, or else — you write
# When you use the 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 $. # its name without $. If you want to use the variable's value, you should use $.
# Note that ' (single quote) won't expand the variables! # Note that ' (single quote) won't expand the variables!
# You can write variable without surrounding quotes but it's not recommended.
# Parameter expansion ${ }: # Parameter expansion ${...}:
echo ${Variable} # => Some string echo "${variable}" # => Some string
# This is a simple usage of parameter expansion # This is a simple usage of parameter expansion such as two examples above.
# Parameter Expansion gets a value from a variable. # Parameter expansion gets a value from a variable.
# It "expands" or prints the value # It "expands" or prints the value.
# During the expansion time the value or parameter can be modified # During the expansion time the value or parameter can be modified.
# Below are other modifications that add onto this expansion # Below are other modifications that add onto this expansion.
# String substitution in variables # String substitution in variables:
echo ${Variable/Some/A} # => A string echo "${variable/Some/A}" # => A string
# This will substitute the first occurrence of "Some" with "A" # This will substitute the first occurrence of "Some" with "A".
# Substring from a variable # Substring from a variable:
Length=7 length=7
echo ${Variable:0:Length} # => Some st echo "${variable:0:length}" # => Some st
# This will return only the first 7 characters of the value # This will return only the first 7 characters of the value
echo ${Variable: -5} # => tring echo "${variable: -5}" # => tring
# This will return the last 5 characters (note the space before -5) # This will return the last 5 characters (note the space before -5).
# The space before minus is mandatory here.
# String length # String length:
echo ${#Variable} # => 11 echo "${#variable}" # => 11
# Indirect expansion # Indirect expansion:
OtherVariable="Variable" other_variable="variable"
echo ${!OtherVariable} # => Some String echo ${!other_variable} # => Some string
# This will expand the value of OtherVariable # This will expand the value of `other_variable`.
# Default value for variable # The default value for variable:
echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"} echo "${foo:-"DefaultValueIfFooIsMissingOrEmpty"}"
# => 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. # Note that it only returns default value and doesn't change variable value.
# Declare an array with 6 elements # Declare an array with 6 elements:
array0=(one two three four five six) array=(one two three four five six)
# Print first element # Print the first element:
echo $array0 # => "one" echo "${array[0]}" # => "one"
# Print first element # Print all elements:
echo ${array0[0]} # => "one" echo "${array[@]}" # => "one two three four five six"
# Print all elements # Print the number of elements:
echo ${array0[@]} # => "one two three four five six" echo "${#array[@]}" # => "6"
# Print number of elements # Print the number of characters in third element
echo ${#array0[@]} # => "6" echo "${#array[2]}" # => "5"
# Print number of characters in third element # Print 2 elements starting from fourth:
echo ${#array0[2]} # => "5" echo "${array[@]:3:2}" # => "four five"
# Print 2 elements starting from fourth # Print all elements each of them on new line.
echo ${array0[@]:3:2} # => "four five" for item in "${array[@]}"; do
# Print all elements. Each of them on new line. echo "$item"
for i in "${array0[@]}"; do
echo "$i"
done 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: # 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 "Last program's return value: $?"
echo "Script's PID: $$" echo "Script's PID: $$"
echo "Number of arguments passed to script: $#" echo "Number of arguments passed to script: $#"
echo "All arguments passed to script: $@" echo "All arguments passed to script: $@"
echo "Script's arguments separated into different variables: $1 $2..." 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, # 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`. # Our current directory is available through the command `pwd`.
# `pwd` stands for "print working directory". # `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 echo "I'm in $PWD" # interpolates the variable
# If you get too much output in your terminal, or from a script, the command # If you get too much output in your terminal, or from a script, the command
# `clear` clears your screen # `clear` clears your screen:
clear clear
# Ctrl-L also works for clearing output # Ctrl-L also works for clearing output.
# Reading a value from input: # Reading a value from input:
echo "What's your name?" echo "What's your name?"
read Name # Note that we didn't need to declare a new variable read name
echo Hello, $Name! # Note that we didn't need to declare a new variable.
echo "Hello, $name!"
# We have the usual if structure: # We have the usual if structure.
# use `man test` for more info about conditionals # Condition is true if the value of $name is not equal to the current user's login username:
if [ $Name != $USER ] if [[ "$name" != "$USER" ]]; then
then
echo "Your name isn't your username" echo "Your name isn't your username"
else else
echo "Your name is your username" echo "Your name is your username"
fi 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: # To use && and || with if statements, you need multiple pairs of square brackets:
if [ != $USER ] read age
# which is invalid syntax if [[ "$name" == "Steve" ]] && [[ "$age" -eq 15 ]]; then
# so the "safe" way to use potentially empty variables in bash is: echo "This will run if $name is Steve AND $age is 15."
if [ "$Name" != $USER ] ... fi
# which, when $Name is empty, is seen by bash as:
if [ "" != $USER ] ... if [[ "$name" == "Daniya" ]] || [[ "$name" == "Zach" ]]; then
# which works as expected 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 # There is also conditional execution
echo "Always executed" || echo "Only executed if first command fails" echo "Always executed" || echo "Only executed if first command fails"
@@ -193,27 +210,6 @@ bg
kill %2 kill %2
# %1, %2, etc. can be used for fg and bg as well # %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 # Redefine command `ping` as alias to send only 5 packets
alias ping='ping -c 5' alias ping='ping -c 5'
# Escape the alias and use command with this name instead # Escape the alias and use command with this name instead

63
c.html.markdown
View File

@@ -2,15 +2,15 @@
language: C language: C
filename: learnc.c filename: learnc.c
contributors: contributors:
- ["Adam Bard", "http://adambard.com/"] - ["Adam Bard", "http://adambard.com/"]
- ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
- ["Jakub Trzebiatowski", "http://cbs.stgn.pl"] - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
- ["Marco Scannadinari", "https://marcoms.github.io"] - ["Marco Scannadinari", "https://marcoms.github.io"]
- ["Zachary Ferguson", "https://github.io/zfergus2"] - ["Zachary Ferguson", "https://github.io/zfergus2"]
- ["himanshu", "https://github.com/himanshu81494"] - ["himanshu", "https://github.com/himanshu81494"]
- ["Joshua Li", "https://github.com/JoshuaRLi"] - ["Joshua Li", "https://github.com/JoshuaRLi"]
- ["Dragos B. Chirila", "https://github.com/dchirila"] - ["Dragos B. Chirila", "https://github.com/dchirila"]
- ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"] - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
--- ---
Ah, C. Still **the** language of modern high-performance computing. Ah, C. Still **the** language of modern high-performance computing.
@@ -101,6 +101,12 @@ int main (int argc, char** argv)
// %d is an integer, \n is a newline // %d is an integer, \n is a newline
printf("%d\n", 0); // => Prints 0 printf("%d\n", 0); // => Prints 0
// take input using scanf
// '&' is used to define the location
// where we want to store the input value
int input;
scanf("%d", &input);
/////////////////////////////////////// ///////////////////////////////////////
// Types // Types
/////////////////////////////////////// ///////////////////////////////////////
@@ -118,7 +124,7 @@ int main (int argc, char** argv)
// shorts are usually 2 bytes (use the `sizeof` operator to check) // shorts are usually 2 bytes (use the `sizeof` operator to check)
short x_short = 0; short x_short = 0;
// chars are defined as the smallest addressable unit for a processor. // chars are defined as the smallest addressable unit for a processor.
// This is usually 1 byte, but for some systems it can be more (ex. for TMS320 from TI it's 2 bytes). // This is usually 1 byte, but for some systems it can be more (ex. for TMS320 from TI it's 2 bytes).
char x_char = 0; char x_char = 0;
char y_char = 'y'; // Char literals are quoted with '' char y_char = 'y'; // Char literals are quoted with ''
@@ -167,19 +173,19 @@ int main (int argc, char** argv)
// where the "{0}" part is called an "array initializer". // where the "{0}" part is called an "array initializer".
// All elements (if any) past the ones in the initializer are initialized to 0: // All elements (if any) past the ones in the initializer are initialized to 0:
int my_array[5] = {1, 2}; int my_array[5] = {1, 2};
// So my_array now has five elements, all but the first two of which are 0: // So my_array now has five elements, all but the first two of which are 0:
// [1, 2, 0, 0, 0] // [1, 2, 0, 0, 0]
// NOTE that you get away without explicitly declaring the size // NOTE that you get away without explicitly declaring the size
// of the array IF you initialize the array on the same line: // of the array IF you initialize the array on the same line:
int my_array[] = {0}; int my_array[] = {0};
// NOTE that, when not declaring the size, the size of the array is the number // NOTE that, when not declaring the size, the size of the array is the number
// of elements in the initializer. With "{0}", my_array is now of size one: [0] // of elements in the initializer. With "{0}", my_array is now of size one: [0]
// To evaluate the size of the array at run-time, divide its byte size by the // To evaluate the size of the array at run-time, divide its byte size by the
// byte size of its element type: // byte size of its element type:
size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]); size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
// WARNING You should evaluate the size *before* you begin passing the array // WARNING You should evaluate the size *before* you begin passing the array
// to functions (see later discussion) because arrays get "downgraded" to // to functions (see later discussion) because arrays get "downgraded" to
// raw pointers when they are passed to functions (so the statement above // raw pointers when they are passed to functions (so the statement above
// will produce the wrong result inside the function). // will produce the wrong result inside the function).
// Indexing an array is like other languages -- or, // Indexing an array is like other languages -- or,
@@ -247,11 +253,11 @@ int main (int argc, char** argv)
(float)i1 / i2; // => 0.5f (float)i1 / i2; // => 0.5f
i1 / (double)i2; // => 0.5 // Same with double i1 / (double)i2; // => 0.5 // Same with double
f1 / f2; // => 0.5, plus or minus epsilon f1 / f2; // => 0.5, plus or minus epsilon
// Floating-point numbers are defined by IEEE 754, thus cannot store perfectly // Floating-point numbers are defined by IEEE 754, thus cannot store perfectly
// exact values. For instance, the following does not produce expected results // exact values. For instance, the following does not produce expected results
// because 0.1 might actually be 0.099999999999 insided the computer, and 0.3 // because 0.1 might actually be 0.099999999999 insided the computer, and 0.3
// might be stored as 0.300000000001. // might be stored as 0.300000000001.
(0.1 + 0.1 + 0.1) != 0.3; // => 1 (true) (0.1 + 0.1 + 0.1) != 0.3; // => 1 (true)
// and it is NOT associative due to reasons mentioned above. // and it is NOT associative due to reasons mentioned above.
1 + (1e123 - 1e123) != (1 + 1e123) - 1e123; // => 1 (true) 1 + (1e123 - 1e123) != (1 + 1e123) - 1e123; // => 1 (true)
@@ -262,7 +268,7 @@ int main (int argc, char** argv)
// eventually calls C which uses IEEE 754. It is mentioned this way not to // eventually calls C which uses IEEE 754. It is mentioned this way not to
// indicate that this is a poor implementation, but instead as a warning // indicate that this is a poor implementation, but instead as a warning
// that when doing floating point comparisons, a little bit of error (epsilon) // that when doing floating point comparisons, a little bit of error (epsilon)
// needs to be considered. // needs to be considered.
// Modulo is there as well, but be careful if arguments are negative // Modulo is there as well, but be careful if arguments are negative
11 % 3; // => 2 as 11 = 2 + 3*x (x=3) 11 % 3; // => 2 as 11 = 2 + 3*x (x=3)
@@ -411,7 +417,7 @@ int main (int argc, char** argv)
*/ */
/* /*
it is generally considered bad practice to do so, except if it is generally considered bad practice to do so, except if
you really know what you are doing. See you really know what you are doing. See
https://en.wikipedia.org/wiki/Spaghetti_code#Meaning https://en.wikipedia.org/wiki/Spaghetti_code#Meaning
*/ */
@@ -424,7 +430,7 @@ int main (int argc, char** argv)
int x_hex = 0x01; // You can assign vars with hex literals int x_hex = 0x01; // You can assign vars with hex literals
// binary is not in the standard, but allowed by some // binary is not in the standard, but allowed by some
// compilers (x_bin = 0b0010010110) // compilers (x_bin = 0b0010010110)
// Casting between types will attempt to preserve their numeric values // Casting between types will attempt to preserve their numeric values
printf("%d\n", x_hex); // => Prints 1 printf("%d\n", x_hex); // => Prints 1
@@ -626,7 +632,7 @@ printf("first: %d\nsecond: %d\n", first, second);
// values will be swapped // values will be swapped
*/ */
// Return multiple values. // Return multiple values.
// C does not allow for returning multiple values with the return statement. If // C does not allow for returning multiple values with the return statement. If
// you would like to return multiple values, then the caller must pass in the // you would like to return multiple values, then the caller must pass in the
// variables where they would like the returned values to go. These variables must // variables where they would like the returned values to go. These variables must
@@ -637,9 +643,9 @@ int return_multiple( int *array_of_3, int *ret1, int *ret2, int *ret3)
return 0; //return error code (false) return 0; //return error code (false)
//de-reference the pointer so we modify its value //de-reference the pointer so we modify its value
*ret1 = array_of_3[0]; *ret1 = array_of_3[0];
*ret2 = array_of_3[1]; *ret2 = array_of_3[1];
*ret3 = array_of_3[2]; *ret3 = array_of_3[2];
return 1; //return error code (true) return 1; //return error code (true)
} }
@@ -901,10 +907,11 @@ Node createLinkedList(int *vals, int len);
#endif /* End of the if precompiler directive. */ #endif /* End of the if precompiler directive. */
``` ```
## Further Reading ## Further Reading
Best to find yourself a copy of [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language) Best to find yourself a copy of [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
It is *the* book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some It is _the_ book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some
inaccuracies (well, ideas that are not considered good anymore) or now-changed practices. inaccuracies (well, ideas that are not considered good anymore) or now-changed practices.
Another good resource is [Learn C The Hard Way](http://learncodethehardway.org/c/) (not free). Another good resource is [Learn C The Hard Way](http://learncodethehardway.org/c/) (not free).

2
cobol.html.markdown
View File

@@ -132,7 +132,7 @@ organizations.
*Now it is time to learn about two related COBOL verbs: string and unstring. *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 *Unstring is used, not surprisingly, to separate a
*string into two or more smaller strings. *string into two or more smaller strings.
*It is important that you remember to use ‘delimited by’ when you *It is important that you remember to use ‘delimited by’ when you

260
de-de/vim-de.html.markdown
View File

@@ -3,94 +3,92 @@ category: tool
tool: vim tool: vim
lang: de-de lang: de-de
contributors: contributors:
- ["RadhikaG", "https://github.com/RadhikaG"] - ["RadhikaG", "https://github.com/RadhikaG"]
translators: translators:
- ["caminsha", "https://github.com/caminsha"] - ["caminsha", "https://github.com/caminsha"]
filename: LearnVim-de.txt filename: LearnVim-de.txt
--- ---
[Vim](http://www.vim.org) [Vim](http://www.vim.org)
(Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein (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 Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
wurde. wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten bearbeiten einer Datei.
einer Datei.
## Grundlagen, um in Vim zu navigieren ## Grundlagen, um in Vim zu navigieren
``` ```
vim <filename> # Öffne <filename> in Vim vim <filename> # Öffne <filename> in Vim
:help <topic> # Öffne die eingebaute Hilfe zum Thema <topic>, wenn :help <topic> # Öffne die eingebaute Hilfe zum Thema <topic>, wenn
# es existiert # es existiert
:q # Schließe vim :q # Schließe vim
:w # Speichere diese Datei :w # Speichere diese Datei
:wq # Speichere diese Datei und schließe vim :wq # Speichere diese Datei und schließe vim
ZZ # Speichere diese Datei und schließe vim ZZ # Speichere diese Datei und schließe vim
:q! # Schließe vim ohne die Datei zu speichern :q! # Schließe vim ohne die Datei zu speichern
# ! *zwingt* die Ausführung von :q, # ! *zwingt* die Ausführung von :q,
# daher wird die Datei nicht gespeichert. # daher wird die Datei nicht gespeichert.
ZQ # Beende vim ohne die Datei zu speichern ZQ # Beende vim ohne die Datei zu speichern
:x # Speichere die Datei und beende vim :x # Speichere die Datei und beende vim
# Dies ist eine kürzere Version von :wq # Dies ist eine kürzere Version von :wq
u # Änderung rückgängig machen u # Änderung rückgängig machen
CTRL+R # Änderung wiederherstellen CTRL+R # Änderung wiederherstellen
h # Den Cursor um ein Zeichen nach links bewegen h # Den Cursor um ein Zeichen nach links bewegen
j # Den Cursor eine Zeile nach unten bewegen j # Den Cursor eine Zeile nach unten bewegen
k # Den Cursor eine Zeile nach oben bewegen k # Den Cursor eine Zeile nach oben bewegen
l # Den Cursor um ein Zeichen nach rechts bewegen l # Den Cursor um ein Zeichen nach rechts bewegen
Ctrl+B # Gehe eine Bildschirmanzeige zurück Ctrl+B # Gehe eine Bildschirmanzeige zurück
Ctrl+F # Gehe eine Bildschirmanzeige vorwärts Ctrl+F # Gehe eine Bildschirmanzeige vorwärts
Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts Ctrl+D # Gehe eine halbe Bildschirmanzeige vorwärts
Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück Ctrl+U # Gehe eine halbe Bildschirmanzeige zurück
# Navigieren innerhalb einer Zeile # Navigieren innerhalb einer Zeile
0 # Navigiere zum Anfang der Zeile 0 # Navigiere zum Anfang der Zeile
$ # Navigiere zum Ende der Zeile $ # Navigiere zum Ende der Zeile
^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist ^ # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
# Im Text suchen # Im Text suchen
/word # Hebt alle Ergebnisse nach dem Cursor hervor /word # Hebt alle Ergebnisse nach dem Cursor hervor
?word # Hebt alle Ergebnisse vor 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 nächsten Ergebnis nach der Suche
N # Bewegt den Cursor zum vorherigen Ergebnis 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 allen Zeilen
:s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile :s/foo/bar/g # Ersetze "foo" durch "bar" in der aktuellen Zeile
:%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch :%s/\n/\r/g # Ersetze das newline-Zeichen bei allen Zeilen durch
# ein carriage return # ein carriage return
# Zu einzelnen Zeichen springen # Zu einzelnen Zeichen springen
f<character> # Springe vorwärts und auf dem Zeichen <character> f<character> # Springe vorwärts und auf dem Zeichen <character>
t<character> # Springe vorwärts und lande vor dem Zeichen <character> t<character> # Springe vorwärts und lande vor dem Zeichen <character>
# Zum Beispiel, # Zum Beispiel,
f< # Springe vorwärts und lande auf < f< # Springe vorwärts und lande auf <
t< # Springe vorwärts und lande vor < t< # Springe vorwärts und lande vor <
# Wortweise navigieren # Wortweise navigieren
w # Springe um ein Wort vorwärts w # Springe um ein Wort vorwärts
b # Gehe ein Wort zurück b # Gehe ein Wort zurück
e # Springe zum Ende des aktuellen Wortes e # Springe zum Ende des aktuellen Wortes
# Weitere Befehle, um zu navigieren # Weitere Befehle, um zu navigieren
gg # Gehe an den Start der Datei gg # Gehe an den Start der Datei
G # Gehe an das Ende der Datei G # Gehe an das Ende der Datei
:NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein) :NUM # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
H # Navigiere zum Start der aktuellen Bildschirmanzeige H # Navigiere zum Start der aktuellen Bildschirmanzeige
M # Navigiere in die Mitte der aktuellen Bildschirmanzeige M # Navigiere in die Mitte der aktuellen Bildschirmanzeige
L # Navigiere an das Ende der aktuellen Bildschirmanzeige L # Navigiere an das Ende der aktuellen Bildschirmanzeige
``` ```
## Hilfsdokumente: ## Hilfsdokumente
Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen
werden kann. 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- `:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
Hilfsdialog an, welcher den Start mit vim einfacher macht. 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**. 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. - 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 - Ex Mode - Wird verwendet, um im ':'-Prompt Befehle einzugeben
``` ```
i # Führt vim in den Insert Mode, vor der Cursorposition i # Führt vim in den Insert Mode, vor der Cursorposition
a # Führt vim in den Insert Mode, nach der Cursorposition a # Führt vim in den Insert Mode, nach der Cursorposition
v # Führt vim in den Visual Mode v # Führt vim in den Visual Mode
: # Führt vim in den Ex Mode : # Führt vim in den Ex Mode
<esc> # Führt zurück in den Command Mode, egal in welchem Mode <esc> # Führt zurück in den Command Mode, egal in welchem Mode
# man sich gerade befindet. # man sich gerade befindet.
# Kopieren und einfügen von Text # Kopieren und einfügen von Text
y # Kopiere alles, was im Moment ausgewählt ist y # Kopiere alles, was im Moment ausgewählt ist
yy # Kopiert die aktuelle Zeile yy # Kopiert die aktuelle Zeile
d # Löscht alles, was im Moment ausgewählt ist d # Löscht alles, was im Moment ausgewählt ist
dd # Löscht die aktuelle Zeile dd # Löscht die aktuelle Zeile
p # Fügt den kopierten Text nach dem Cursor ein p # Fügt den kopierten Text nach dem Cursor ein
P # Fügt den kopierten Text vor dem Cursor ein P # Fügt den kopierten Text vor dem Cursor ein
x # Löscht das Zeichen unter dem Cursor x # Löscht das Zeichen unter dem Cursor
``` ```
## Die 'Grammatik' von Vim ## 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': Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
``` ```
# 'Verb' # 'Verb'
d # löschen d # löschen
c # ändern c # ändern
y # kopieren y # kopieren
v # visuelles auswählen v # visuelles auswählen
# 'Modifiers' # 'Modifiers'
i # innerhalb i # innerhalb
a # außerhalb a # außerhalb
NUM # Nummer (NUM kann irgendeine Zahl sein) NUM # Nummer (NUM kann irgendeine Zahl sein)
f # Sucht nach etwas und landet darauf f # Sucht nach etwas und landet darauf
t # Sucht nach etwas und stoppt davor t # Sucht nach etwas und stoppt davor
/ # Suche eine Zeichenfolge ab dem Cursor / # Suche eine Zeichenfolge ab dem Cursor
? # Suche eine Zeichenfolge vor dem Cursor ? # Suche eine Zeichenfolge vor dem Cursor
# 'Nouns' # 'Nouns'
w # Wort w # Wort
s # Satz s # Satz
p # Abschnitt p # Abschnitt
b # Block b # Block
# Beispielsätze resp. Kommandos # Beispielsätze resp. Kommandos
d2w # lösche zwei Wörter d2w # lösche zwei Wörter
cis # Ändere innerhalb des Satzes. cis # Ändere innerhalb des Satzes.
yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt, yip # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
# in welchem du bist) # in welchem du bist)
ct< # Ändere bis zur spitzen Klammer ct< # Ändere bis zur spitzen Klammer
# Ändere den Text von deiner aktuellen Cursorposition bis # Ändere den Text von deiner aktuellen Cursorposition bis
# zur nächsten spitzen Klammer # zur nächsten spitzen Klammer
d$ # Lösche bis zum Ende der Zeile d$ # Lösche bis zum Ende der Zeile
``` ```
## Einige Shortcuts und Tricks ## Einige Shortcuts und Tricks
``` ```
> # Rücke die Auswahl um einen Block ein > # Rücke die Auswahl um einen Block ein
< # Lösche eine Einrückung der Auswahl < # Lösche eine Einrückung der Auswahl
:earlier 15m # Stellt das Dokument so wieder her, wie es vor 15 :earlier 15m # Stellt das Dokument so wieder her, wie es vor 15 Minuten war
# Minuten war :later 15m # den oberen Befehl rückgängig machen
:later 15m # den oberen Befehl rückgängig machen ddp # Vertauschen zweier aufeinanderfolgenden Zeilen
ddp # Vertauschen zweier aufeinanderfolgenden Zeilen # Zuerst dd, dann p
# Zuerst dd, dann p . # Wiederhole die vorherige Aktion
. # Wiederhole die vorherige Aktion :w !sudo tee % # Speichere die Datei als Root
:w !sudo tee % # Speichere die Datei als Root :set syntax=c # Stelle das Syntax-Highlighting für 'C' ein
:set syntax=c # Stelle das Syntax-Highlighting für 'C' ein :sort # Alle Zeilen sortieren
:sort # Alle Zeilen sortieren :sort! # Alle Zeilen rückwärts sortieren
:sort! # Alle Zeilen rückwärts sortieren :sort u # Alle Zeilen sortieren und Duplikate entfernen
:sort u # Alle Zeilen sortieren und Duplikate entfernen ~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
~ # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes u # Ausgewählten Text zu Kleinschreibung ändern
u # Ausgewählten Text zu Kleinschreibung ändern U # Ausgewählten Text zu Großschreibung ändern
U # Ausgewählten Text zu Großschreibung ändern
# Text-Folding (Textfaltung)
# Text-Folding (Textfaltung) zf # Erstelle eine Faltung des ausgewählten Textes
zf # Erstelle eine Faltung des ausgewählten Textes zo # Öffne die aktuelle Faltung
zo # Öffne die aktuelle Faltung zc # Schließe die aktuelle Faltung
zc # Schließe die aktuelle Faltung zR # Öffne alle Faltungen
zR # Öffne alle Faltungen zM # Schließe alle Faltungen
zM # Schließe alle Faltungen
``` ```
## Makros ## 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. Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht.
``` ```
qa # Starte das Aufnehmen des Makros 'a' qa # Starte das Aufnehmen des Makros 'a'
q # Beende das Aufnehmen q # Beende das Aufnehmen
@a # Führe das Makro 'a' aus @a # Führe das Makro 'a' aus
``` ```
### Konfigurieren mit ~/.vimrc ### Konfigurieren mit ~/.vimrc

44
es-es/awk-es.html.markdown
View File

@@ -11,8 +11,8 @@ lang: es-es
AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX. AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX.
Es como un Perl restringido, perfecto para tareas de procesamiento de texto y Es como un Perl restringido, perfecto para tareas de procesamiento de texto y
otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin
puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo
desde un script de shell o usarlo como un lenguaje stand-alone para scripting. desde un script de shell o usarlo como un lenguaje stand-alone para scripting.
¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX. ¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX.
@@ -74,8 +74,8 @@ BEGIN {
# Bloques formados por múltiples líneas usan llaves # Bloques formados por múltiples líneas usan llaves
while (a < 10) { while (a < 10) {
print "La concatenación de strings se hace " " con series " print "La concatenación de strings se hace " " con series "
print " de" " strings separados por espacios" print " de" " strings separados por espacios"
print a print a
a++ a++
@@ -153,13 +153,13 @@ function arithmetic_functions(a, b, c, localvar) {
# Todo es global. No es problema en scripts pequeños, pero sí para # Todo es global. No es problema en scripts pequeños, pero sí para
# scripts más grandes. # scripts más grandes.
# Hay un work-around (mmm... hack). Los argumentos de las funciones son # Hay un work-around (mmm... hack). Los argumentos de las funciones son
# locales para la función, y AWK permite definir más argumentos de función # locales para la función, y AWK permite definir más argumentos de función
# de los que necesita, por lo que define las variables locales en la # de los que necesita, por lo que define las variables locales en la
# declaración como en la función de arriba. Como convención, agrega # declaración como en la función de arriba. Como convención, agrega
# espacios en blanco para distinguir los parámetros de la función de las # espacios en blanco para distinguir los parámetros de la función de las
# variables locales. En este ejemplo, a, b y c son parámetros y localvar es una # variables locales. En este ejemplo, a, b y c son parámetros y localvar es
# variable local. # una variable local.
# Ahora, a demostrar las funciones aritméticas # Ahora, a demostrar las funciones aritméticas
@@ -222,10 +222,10 @@ function io_functions( localvar) {
# También hay printf # También hay printf
printf("%s %d %d %d\n", "Testing", 1, 2, 3) printf("%s %d %d %d\n", "Testing", 1, 2, 3)
# AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un
# handle de archivo cuando use algo que necesite uno. El string que usaste # handle de archivo cuando use algo que necesite uno. El string que usaste
# para esto puede ser tratada como un handle de archivo para propósitos de I/O. # para esto puede ser tratada como un handle de archivo para propósitos
# Esto lo hace similar al scripting de shell: # de I/O. Esto lo hace similar al scripting de shell:
print "foobar" >"/tmp/foobar.txt" print "foobar" >"/tmp/foobar.txt"
@@ -247,17 +247,17 @@ function io_functions( localvar) {
close("/tmp/foobar.txt") close("/tmp/foobar.txt")
} }
# Como dije al inicio, los programas en AWK son una colección de patrones y # Como dije al inicio, los programas en AWK son una colección de patrones y
# acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás # acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás
# procesando líneas desde archivos o stdin. # procesando líneas desde archivos o stdin.
# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a # Cuando pasas argumentos a AWK, son tratados como nombres de archivos a
# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for # procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for
# implícito, iterando sobre las líneas de estos archivos. Estos patrones y # implícito, iterando sobre las líneas de estos archivos. Estos patrones y
# acciones son como instrucciones switch dentro del ciclo. # acciones son como instrucciones switch dentro del ciclo.
/^fo+bar$/ { /^fo+bar$/ {
# Esta acción se ejecutará por cada línea que haga match con la expresión # Esta acción se ejecutará por cada línea que haga match con la expresión
# regular /^fo+bar$/, y será saltada por cualquier línea que no haga match. # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.
# Vamos a sólo mostrar la línea: # Vamos a sólo mostrar la línea:
@@ -268,7 +268,7 @@ function io_functions( localvar) {
# $0 es el nombre de la línea actual que se está procesando. # $0 es el nombre de la línea actual que se está procesando.
# Se crea automáticamente para ti. # Se crea automáticamente para ti.
# Probablemente puedas adivinar que hay otras variables $. Cada línea es # Probablemente puedas adivinar que hay otras variables $. Cada línea es
# separada implícitamente antes de que se llame cada acción, justo como lo # separada implícitamente antes de que se llame cada acción, justo como lo
# hace shell. Y, como shell, cada campo puede ser accesado con $. # hace shell. Y, como shell, cada campo puede ser accesado con $.
@@ -301,7 +301,7 @@ a > 0 {
# Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez, # Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,
# y haciendo algo con ella, particularmente separando en un deliminator, es tan # y haciendo algo con ella, particularmente separando en un deliminator, es tan
# común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti # común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti
# sin que tengas que pedirlo. Basta con escribir los patrones y acciones # sin que tengas que pedirlo. Basta con escribir los patrones y acciones
# basados en lo que esperas de la entrada y lo quieras quieras hacer con ella. # basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.
# Aquí está un ejemplo de un script simple, para lo que AWK es perfecto. # Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.
@@ -343,7 +343,7 @@ $1 == name {
nlines++ nlines++
} }
# Otro patrón especial es END. Va a ejecutarse después de procesar todos los # Otro patrón especial es END. Va a ejecutarse después de procesar todos los
# archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una # archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una
# entrada a procesar. Se ejecutará después de que todos los archivos hayan sido # entrada a procesar. Se ejecutará después de que todos los archivos hayan sido
# leídos y procesados según las reglas y acciones que programaste. El propósito # leídos y procesados según las reglas y acciones que programaste. El propósito
@@ -356,8 +356,10 @@ END {
} }
``` ```
Más información: Más información:
* [Tutorial de AWK](http://www.grymoire.com/Unix/Awk.html) * [Tutorial de AWK](http://www.grymoire.com/Unix/Awk.html)
* [Página man de AWK](https://linux.die.net/man/1/awk) * [Página man de AWK](https://linux.die.net/man/1/awk)
* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html): GNU Awk se encuentra en la mayoría de los sistemas Linux. * [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html):
GNU Awk se encuentra en la mayoría de los sistemas Linux.

106
fr-fr/awk-fr.html.markdown
View File

@@ -24,14 +24,12 @@ 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 qui nécessitent de lire des fichiers ligne par ligne ; chaque ligne comportant
des champs séparés par des délimiteur. des champs séparés par des délimiteur.
```awk ```awk
#!/usr/bin/awk -f #!/usr/bin/awk -f
# Les commentaires commencent par un # # Les commentaires commencent par un #
# Les programmes AWK consistent en une collection de règles et d'actions.
# les programmes AWK consistent en une collection de règles et d'actions
règle1 { action; } règle1 { action; }
règle2 { action; } règle2 { action; }
@@ -46,14 +44,14 @@ règle2 { action; }
# texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le # texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le
# point d’entrée principal du script. # 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 # À 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). # chaque fin de fichier (EOF : End Of File).
BEGIN { BEGIN {
# Les variables sont globales. Pas besoin de les déclarer. # Les variables sont globales. Pas besoin de les déclarer.
count = 0; count = 0;
# les opérateurs sont identiques au langage C et aux langages similaires # Les opérateurs sont identiques au langage C et aux langages similaires
# (tels que C#, C++, etc.) # (tels que C#, C++, etc.)
a = count + 1; # addition a = count + 1; # addition
b = count - 1; # soustraction b = count - 1; # soustraction
@@ -73,7 +71,8 @@ BEGIN {
a++; a++;
b--; b--;
# En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui
# est retournée
++a; ++a;
--b; --b;
@@ -121,7 +120,6 @@ BEGIN {
arr[1] = "bar"; arr[1] = "bar";
# Vous pouvez aussi initialiser un tableau avec la fonction split() # Vous pouvez aussi initialiser un tableau avec la fonction split()
n = split("foo:bar:baz", arr, ":"); n = split("foo:bar:baz", arr, ":");
# Il y a aussi les tableaux associatifs # Il y a aussi les tableaux associatifs
@@ -130,7 +128,6 @@ BEGIN {
# et les tableaux multi-dimensions, avec certaines limitations que l'on ne # et les tableaux multi-dimensions, avec certaines limitations que l'on ne
# mentionnera pas ici # mentionnera pas ici
multidim[0,0] = "foo"; multidim[0,0] = "foo";
multidim[0,1] = "bar"; multidim[0,1] = "bar";
multidim[1,0] = "baz"; multidim[1,0] = "baz";
@@ -149,18 +146,16 @@ BEGIN {
for (argnum in ARGV) for (argnum in ARGV)
print ARGV[argnum]; print ARGV[argnum];
# Vous pouvez supprimer des éléments d'un tableau # Vous pouvez supprimer des éléments d'un tableau.
# C'est utile pour empêcher AWK de supposer que certains arguments soient # C'est utile pour empêcher AWK de supposer que certains arguments soient
# des fichiers à traiter. # des fichiers à traiter.
delete ARGV[1]; delete ARGV[1];
# Le nombre d'arguments de la ligne de commande est assigné à la variable ARGC # Le nombre d'arguments de la ligne de commande est assigné à
# la variable ARGC
print ARGC; print ARGC;
# AWK inclue trois catégories de fonction. # AWK inclue trois catégories de fonction. On les examinera plus tard.
# On les examinera plus tard
return_value = arithmetic_functions(a, b, c); return_value = arithmetic_functions(a, b, c);
string_functions(); string_functions();
io_functions(); io_functions();
@@ -175,13 +170,13 @@ function arithmetic_functions(a, b, c, d) {
# Il y a cependant 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. # Les arguments d'une fonction sont locaux à cette fonction.
# Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire. # Et AWK vous permet de définir plus d'arguments à la fonction que
# Il suffit donc de mettre une variable locale dans la déclaration de fonction, # nécessaire. Il suffit donc de mettre une variable locale dans la
# comme ci-dessus. La convention veut que vous mettiez quelques espaces # déclaration de fonction, comme ci-dessus. La convention veut que vous
# supplémentaires pour faire la distinction entre les paramètres réels et # mettiez quelques espaces supplémentaires pour faire la distinction entre
# les variables locales. # les paramètres réels et les variables locales.
# Dans cet exemple, a, b et c sont des paramètres réels, # Dans cet exemple, a, b et c sont des paramètres réels, alors que d est
# alors que d est simplement une variable locale. # simplement une variable locale.
# Maintenant, les fonctions arithmétiques # Maintenant, les fonctions arithmétiques
@@ -217,20 +212,21 @@ function string_functions( localvar, arr) {
# AWK a plusieurs fonctions pour le traitement des chaînes de caractères, # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
# dont beaucoup reposent sur des expressions régulières. # dont beaucoup reposent sur des expressions régulières.
# Chercher et remplacer, la première occurrence (sub) ou toutes les # Chercher et remplacer, la première occurrence (sub), ou toutes les
# occurrences (gsub) # occurrences (gsub).
# Les deux renvoient le nombre de correspondances remplacées # Les deux renvoient le nombre de correspondances remplacées
localvar = "fooooobar"; localvar = "fooooobar";
sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar" 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 # Rechercher une chaîne de caractères qui correspond à une expression
# index() fait la même chose, mais n'autorise pas les expressions régulières # régulière index() fait la même chose, mais n'autorise pas les expressions
# régulières.
match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
# Séparer par un délimiteur # Séparer par un délimiteur
n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3 n = split("foo-bar-baz", arr, "-");
# résultat : a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
# Autre astuces utiles # Autre astuces utiles
sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3" sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
@@ -251,23 +247,20 @@ function io_functions( localvar) {
# AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement # 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 # un descripteur de fichier lorsque vous utilisez quelque chose qui en a
# besoin. # besoin. La chaîne de caractères que vous avez utilisée pour cela peut être
# La chaîne de caractères que vous avez utilisée pour cela peut être traitée # traitée comme un descripteur de fichier à des fins d'entrée / sortie.
# comme un descripteur de fichier à des fins d'entrée / sortie.
outfile = "/tmp/foobar.txt"; outfile = "/tmp/foobar.txt";
print "foobar" > outfile; print "foobar" > outfile;
# Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier. # Maintenant, la chaîne de caractères "outfile" est un descripteur de
# Vous pouvez le fermer # fichier. Vous pouvez le fermer.
close(outfile); close(outfile);
# Voici comment exécuter quelque chose dans le shell # Voici comment exécuter quelque chose dans le shell
system("echo foobar"); # => affiche foobar system("echo foobar"); # => affiche foobar
# Lire quelque chose depuis l'entrée standard et la stocker dans une variable # Lire quelque chose depuis l'entrée standard et la stocker dans une
# locale # variable locale
getline localvar; getline localvar;
# Lire quelque chose à partir d'un pipe (encore une fois, utilisez une # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une
@@ -294,23 +287,24 @@ function io_functions( localvar) {
# Cette action sera exécutée pour chaque ligne qui correspond à l'expression # 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 # régulière, /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond
# pas. Imprimons simplement la ligne: # pas. Imprimons simplement la ligne :
print; print;
# Pas d'argument ! C'est parce que print a un défaut : $0. # Pas d'argument ! C'est parce que print a un défaut : $0.
# $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement. # $0 est le nom de la ligne en cours de traitement. Il est créé
# automatiquement.
# Vous devinez probablement qu'il existe d'autres variables $. # Vous devinez probablement qu'il existe d'autres variables $.
# Chaque ligne est divisée implicitement avant que chaque action soit exécutée, # Chaque ligne est divisée implicitement avant que chaque action soit
# comme le fait le shell. Et, comme le shell, chaque champ est accessible # exécutée, comme le fait le shell. Et, comme le shell, chaque champ est
# avec un signe dollar # accessible avec un signe dollar.
# Ceci affichera les deuxième et quatrième champs de la ligne. # Ceci affichera les deuxième et quatrième champs de la ligne.
print $2, $4; print $2, $4;
# AWK défini automatiquement beaucoup d'autres variables qui peuvent vous # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous
# aider à inspecter et traiter chaque ligne. La plus importante est NF # aider à inspecter et traiter chaque ligne. La plus importante est NF.
# Affiche le nombre de champs de la ligne # Affiche le nombre de champs de la ligne
print NF; print NF;
@@ -320,7 +314,6 @@ function io_functions( localvar) {
} }
# Chaque règle est en réalité un test conditionnel. # Chaque règle est en réalité un test conditionnel.
a > 0 { a > 0 {
# Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
} }
@@ -328,19 +321,16 @@ a > 0 {
# Les expressions régulières sont également des tests conditionnels. # 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 # Si le test de l'expression régulières n'est pas vrais alors le bloc
# n'est pas exécuté. # n'est pas exécuté.
$0 /^fobar/ { $0 /^fobar/ {
print "la ligne commence par foobar" print "la ligne commence par foobar"
} }
# Dans le cas où vous voulez tester votre chaîne de caractères sur la ligne # Dans le cas où vous voulez tester votre chaîne de caractères sur la ligne
# en cours de traitement $0 est optionnelle. # en cours de traitement $0 est optionnelle.
/^[a-zA-Z0-9]$/ { /^[a-zA-Z0-9]$/ {
print "La ligne courante ne contient que des caractères alphanumériques."; 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 # 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 # fonction de règles établies. Cela est si courant sous UNIX qu'AWK est un
# langage de script. # langage de script.
@@ -349,7 +339,7 @@ $0 /^fobar/ {
# parfait. Le script lit un nom à partir de l'entrée standard, puis affiche # 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. # l'âge moyen de toutes les personnes portant ce prénom.
# Supposons que vous fournissiez comme argument le nom d'un fichier comportant # Supposons que vous fournissiez comme argument le nom d'un fichier comportant
# ces données: # ces données :
# #
# Bob Jones 32 # Bob Jones 32
# Jane Doe 22 # Jane Doe 22
@@ -364,22 +354,24 @@ BEGIN {
# Premièrement, on demande à l'utilisateur le prénom voulu # Premièrement, on demande à l'utilisateur le prénom voulu
print "Pour quel prénom voudriez 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 # On récupère la ligne à partir de l'entrée standard, pas de la ligne
# de commande :
getline name < "/dev/stdin"; getline name < "/dev/stdin";
} }
# Maintenant, pour chaque ligne dont le premier champ est le prénom donné # Maintenant, pour chaque ligne dont le premier champ est le prénom donné
$1 == name { $1 == name {
# Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées : # Ici, nous avons accès à un certain nombre de variables utiles déjà
# préchargées :
# $0 est la ligne entière # $0 est la ligne entière
# $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
# NF est le nombre de champs et vaut 3 # NF est le nombre de champs et vaut 3
# NR est le nombre d'enregistrements (lignes) vus jusqu'à présent # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
# FILENAME est le nom du fichier en cours de traitement # FILENAME est le nom du fichier en cours de traitement
# FS est séparateur de champs, ici c'est " " (un espace) # FS est séparateur de champs, ici c'est " " (un espace)
# ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man. # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de
# Pour cela exécutez "man awk" dans votre terminal # man. Pour cela exécutez "man awk" dans votre terminal.
# Garder une trace du total accumulé et du nombre de lignes correspondant. # Garder une trace du total accumulé et du nombre de lignes correspondant.
sum += $3; sum += $3;
@@ -390,9 +382,9 @@ $1 == name {
# les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui # les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
# donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers # donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
# auront été lus et traités conformément aux règles et aux actions que vous # auront été lus et traités conformément aux règles et aux actions que vous
# avez fournies. Le but est généralement de produire un rapport final # avez fournies. Le but est généralement de produire un rapport final, ou de
# ou de faire quelque chose avec l'ensemble des données que vous avez # faire quelque chose avec l'ensemble des données que vous avez accumulées
# accumulées au cours du script. # au cours du script.
END { END {
@@ -401,9 +393,11 @@ END {
} }
``` ```
Pour plus d'informations : Pour plus d'informations :
* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html) * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
* [Awk man page](https://linux.die.net/man/1/awk) * [Awk man page](https://linux.die.net/man/1/awk)
* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk est dans la majorité des systèmes Linux. * [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
GNU Awk est dans la majorité des systèmes Linux.
* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html) * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)

3
hy.html.markdown
View File

@@ -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. This tutorial works for hy ≥ 0.9.12, with some corrections for hy 0.11.
```clojure ```clojure
;; this gives an gentle introduction to hy for a quick trial head to ;; this gives an gentle introduction to hy
;; http://try-hy.appspot.com
;; ;;
; Semicolon comments, like other LISPS ; Semicolon comments, like other LISPS

4
pt-br/awk-pt.html.markdown
View File

@@ -370,8 +370,10 @@ END {
} }
``` ```
Leituras adicionais (em inglês): Leituras adicionais (em inglês):
* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html) * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
* [Awk man page](https://linux.die.net/man/1/awk) * [Awk man page](https://linux.die.net/man/1/awk)
* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU AWK é encontrado na maioria dos sistemas GNU/Linux. * [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
GNU AWK é encontrado na maioria dos sistemas GNU/Linux.

480
pt-br/processing-pt.html.markdown Normal file
View File

@@ -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)

2
vimscript.html.markdown
View File

@@ -11,7 +11,7 @@ contributors:
" ############## " ##############
" "
" Vim script (also called VimL) is the subset of Vim's ex-commands which " Vim script (also called VimL) is the subset of Vim's ex-commands which
" supplies a number of features one one would expect from a scripting language, " supplies a number of features one would expect from a scripting language,
" such as values, variables, functions or loops. Always keep in the back of " such as values, variables, functions or loops. Always keep in the back of
" your mind that a Vim script file is just a sequence of ex-commands. It is " your mind that a Vim script file is just a sequence of ex-commands. It is
" very common for a script to mix programming-language features and raw " very common for a script to mix programming-language features and raw