summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
-rw-r--r--bash.html.markdown66
-rw-r--r--c++.html.markdown146
-rw-r--r--clojure.html.markdown2
-rw-r--r--compojure.html.markdown8
-rw-r--r--elisp.html.markdown12
-rw-r--r--erlang.html.markdown96
-rw-r--r--fr-fr/json-fr.html.markdown62
-rw-r--r--fr-fr/r-fr.html.markdown746
-rw-r--r--fr-fr/typescript-fr.html.markdown174
-rw-r--r--groovy.html.markdown2
-rw-r--r--haxe.html.markdown23
-rw-r--r--it-it/bash-it.html.markdown275
-rw-r--r--it-it/c++-it.html.markdown720
-rw-r--r--java.html.markdown202
-rw-r--r--json.html.markdown2
-rw-r--r--julia.html.markdown8
-rw-r--r--nim.html.markdown20
-rw-r--r--perl6.html.markdown5
-rw-r--r--php.html.markdown2
-rw-r--r--python3.html.markdown42
-rw-r--r--rust.html.markdown23
-rw-r--r--standard-ml.html.markdown42
-rw-r--r--visualbasic.html.markdown4
-rw-r--r--zh-cn/bash-cn.html.markdown189
-rw-r--r--zh-cn/javascript-cn.html.markdown2
25 files changed, 2575 insertions, 298 deletions
diff --git a/bash.html.markdown b/bash.html.markdown
index e0c12f97..08182c2c 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -32,39 +32,41 @@ echo Hello world!
echo 'This is the first line'; echo 'This is the second line'
# Declaring a variable looks like this:
-VARIABLE="Some string"
+Variable="Some string"
# But not like this:
-VARIABLE = "Some string"
-# Bash will decide that VARIABLE is a command it must execute and give an error
+Variable = "Some string"
+# Bash will decide that Variable is a command it must execute and give an error
# because it can't be found.
# Or like this:
-VARIABLE= 'Some string'
+Variable= 'Some string'
# 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'
# command.)
# Using the variable:
-echo $VARIABLE
-echo "$VARIABLE"
-echo '$VARIABLE'
+echo $Variable
+echo "$Variable"
+echo '$Variable'
# When you use the variable itself — assign it, export it, or else — you write
# its name without $. If you want to use variable's value, you should use $.
# Note that ' (single quote) won't expand the variables!
# String substitution in variables
-echo ${VARIABLE/Some/A}
-# This will substitute the first occurance of "Some" with "A"
+echo ${Variable/Some/A}
+# This will substitute the first occurrence of "Some" with "A"
# Substring from a variable
-echo ${VARIABLE:0:7}
+Length=7
+echo ${Variable:0:Length}
# This will return only the first 7 characters of the value
# Default value for variable
-echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"}
-# This works for null (FOO=), empty string (FOO=""), zero (FOO=0) returns 0
+echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# 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.
# Builtin variables:
# There are some useful builtin variables, like
@@ -72,16 +74,16 @@ echo "Last program return value: $?"
echo "Script's PID: $$"
echo "Number of arguments: $#"
echo "Scripts arguments: $@"
-echo "Scripts arguments seperated in different variables: $1 $2..."
+echo "Scripts arguments separated in different variables: $1 $2..."
# 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 -ne $USER ]
+if [ $Name -ne $USER ]
then
echo "Your name isn't your username"
else
@@ -93,14 +95,14 @@ echo "Always executed" || echo "Only executed if first command fails"
echo "Always executed" && echo "Only executed if first command does NOT fail"
# To use && and || with if statements, you need multiple pairs of square brackets:
-if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
+if [ $Name == "Steve" ] && [ $Age -eq 15 ]
then
- echo "This will run if $NAME is Steve AND $AGE is 15."
+ echo "This will run if $Name is Steve AND $Age is 15."
fi
-if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
+if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
then
- echo "This will run if $NAME is Daniya OR Zach."
+ echo "This will run if $Name is Daniya OR Zach."
fi
# Expressions are denoted with the following format:
@@ -142,7 +144,7 @@ python hello.py > /dev/null 2>&1
# if you want to append instead, use ">>":
python hello.py >> "output.out" 2>> "error.err"
-# Overwrite output.txt, append to error.err, and count lines:
+# Overwrite output.out, append to error.err, and count lines:
info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
wc -l output.out error.err
@@ -150,7 +152,7 @@ wc -l output.out error.err
# see: man fd
echo <(echo "#helloworld")
-# Overwrite output.txt with "#helloworld":
+# Overwrite output.out with "#helloworld":
cat > output.out <(echo "#helloworld")
echo "#helloworld" > output.out
echo "#helloworld" | cat > output.out
@@ -169,7 +171,7 @@ echo "There are $(ls | wc -l) items here."
echo "There are `ls | wc -l` items here."
# Bash uses a case statement that works similarly to switch in Java and C++:
-case "$VARIABLE" in
+case "$Variable" in
#List patterns for the conditions you want to meet
0) echo "There is a zero.";;
1) echo "There is a one.";;
@@ -177,10 +179,10 @@ case "$VARIABLE" in
esac
# for loops iterate for as many arguments given:
-# The contents of $VARIABLE is printed three times.
-for VARIABLE in {1..3}
+# The contents of $Variable is printed three times.
+for Variable in {1..3}
do
- echo "$VARIABLE"
+ echo "$Variable"
done
# Or write it the "traditional for loop" way:
@@ -191,16 +193,16 @@ done
# They can also be used to act on files..
# This will run the command 'cat' on file1 and file2
-for VARIABLE in file1 file2
+for Variable in file1 file2
do
- cat "$VARIABLE"
+ cat "$Variable"
done
# ..or the output from a command
# This will cat the output from ls.
-for OUTPUT in $(ls)
+for Output in $(ls)
do
- cat "$OUTPUT"
+ cat "$Output"
done
# while loop:
@@ -228,7 +230,7 @@ bar ()
}
# Calling your function
-foo "My name is" $NAME
+foo "My name is" $Name
# There are a lot of useful commands you should learn:
# prints last 10 lines of file.txt
diff --git a/c++.html.markdown b/c++.html.markdown
index ae93ceba..ff2a98fd 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -288,7 +288,7 @@ public:
// Functions can also be defined inside the class body.
// Functions defined as such are automatically inlined.
- void bark() const { std::cout << name << " barks!\n" }
+ void bark() const { std::cout << name << " barks!\n"; }
// Along with constructors, C++ provides destructors.
// These are called when an object is deleted or falls out of scope.
@@ -300,7 +300,7 @@ public:
}; // A semicolon must follow the class definition.
// Class member functions are usually implemented in .cpp files.
-void Dog::Dog()
+Dog::Dog()
{
std::cout << "A dog has been constructed\n";
}
@@ -323,7 +323,7 @@ void Dog::print() const
std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}
-void Dog::~Dog()
+Dog::~Dog()
{
cout << "Goodbye " << name << "\n";
}
@@ -332,7 +332,7 @@ int main() {
Dog myDog; // prints "A dog has been constructed"
myDog.setName("Barkley");
myDog.setWeight(10);
- myDog.printDog(); // prints "Dog is Barkley and weighs 10 kg"
+ myDog.print(); // prints "Dog is Barkley and weighs 10 kg"
return 0;
} // prints "Goodbye Barkley"
@@ -341,7 +341,7 @@ int main() {
// This class inherits everything public and protected from the Dog class
class OwnedDog : public Dog {
- void setOwner(const std::string& dogsOwner)
+ void setOwner(const std::string& dogsOwner);
// Override the behavior of the print function for all OwnedDogs. See
// http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
@@ -425,7 +425,7 @@ int main () {
Point up (0,1);
Point right (1,0);
// This calls the Point + operator
- // Point up calls the + (function) with right as its paramater
+ // Point up calls the + (function) with right as its parameter
Point result = up + right;
// Prints "Result is upright (1,1)"
cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
@@ -433,6 +433,85 @@ int main () {
}
/////////////////////
+// Templates
+/////////////////////
+
+// Templates in C++ are mostly used for generic programming, though they are
+// much more powerful than generics constructs in other languages. It also
+// supports explicit and partial specialization, functional-style type classes,
+// and also it's Turing-complete.
+
+// We start with the kind of generic programming you might be familiar with. To
+// define a class or function that takes a type parameter:
+template<class T>
+class Box {
+public:
+ // In this class, T can be used as any other type.
+ void insert(const T&) { ... }
+};
+
+// During compilation, the compiler actually generates copies of each template
+// with parameters substituted, and so the full definition of the class must be
+// present at each invocation. This is why you will see template classes defined
+// entirely in header files.
+
+// To instantiate a template class on the stack:
+Box<int> intBox;
+
+// and you can use it as you would expect:
+intBox.insert(123);
+
+// You can, of course, nest templates:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// Up until C++11, you must place a space between the two '>'s, otherwise '>>'
+// will be parsed as the right shift operator.
+
+// You will sometimes see
+// template<typename T>
+// instead. The 'class' keyword and 'typename' keyword are _mostly_
+// interchangeable in this case. For full explanation, see
+// http://en.wikipedia.org/wiki/Typename
+// (yes, that keyword has its own Wikipedia page).
+
+// Similarly, a template function:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+ input.bark();
+ input.bark();
+ input.bark();
+}
+
+// Notice that nothing is specified about the type parameters here. The compiler
+// will generate and then type-check every invocation of the template, so the
+// above function works with any type 'T' that has a const 'bark' method!
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Prints "Fluffy barks" three times.
+
+// Template parameters don't have to be classes:
+template<int Y>
+void printMessage() {
+ cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// And you can explicitly specialize templates for more efficient code. Of
+// course, most real-world uses of specialization are not as trivial as this.
+// Note that you still need to declare the function (or class) as a template
+// even if you explicitly specified all parameters.
+template<>
+void printMessage<10>() {
+ cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>(); // Prints "Learn C++ in 20 minutes!"
+printMessage<10>(); // Prints "Learn C++ faster in only 10 minutes!"
+
+
+/////////////////////
// Exception Handling
/////////////////////
@@ -440,12 +519,13 @@ int main () {
// (see http://en.cppreference.com/w/cpp/error/exception)
// but any type can be thrown an as exception
#include <exception>
+#include <stdexcept>
// All exceptions thrown inside the _try_ block can be caught by subsequent
// _catch_ handlers.
try {
// Do not allocate exceptions on the heap using _new_.
- throw std::exception("A problem occurred");
+ throw std::runtime_error("A problem occurred");
}
// Catch exceptions by const reference if they are objects
catch (const std::exception& ex)
@@ -536,7 +616,7 @@ void doSomethingWithAFile(const char* filename)
{
FILE* fh = fopen(filename, "r"); // Open the file in read mode
if (fh == nullptr)
- throw std::exception("Could not open the file.");
+ throw std::runtime_error("Could not open the file.");
try {
doSomethingWithTheFile(fh);
@@ -585,8 +665,56 @@ void doSomethingWithAFile(const std::string& filename)
// vector (i.e. self-resizing array), hash maps, and so on
// all automatically destroy their contents when they fall out of scope.
// - Mutexes using lock_guard and unique_lock
+
+
+/////////////////////
+// Fun stuff
+/////////////////////
+
+// Aspects of C++ that may be surprising to newcomers (and even some veterans).
+// This section is, unfortunately, wildly incomplete; C++ is one of the easiest
+// languages with which to shoot yourself in the foot.
+
+// You can override private methods!
+class Foo {
+ virtual void bar();
+};
+class FooSub : public Foo {
+ virtual void bar(); // overrides Foo::bar!
+};
+
+
+// 0 == false == NULL (most of the time)!
+bool* pt = new bool;
+*pt = 0; // Sets the value points by 'pt' to false.
+pt = 0; // Sets 'pt' to the null pointer. Both lines compile without warnings.
+
+// nullptr is supposed to fix some of that issue:
+int* pt2 = new int;
+*pt2 = nullptr; // Doesn't compile
+pt2 = nullptr; // Sets pt2 to null.
+
+// But somehow 'bool' type is an exception (this is to make `if (ptr)` compile).
+*pt = nullptr; // This still compiles, even though '*pt' is a bool!
+
+
+// '=' != '=' != '='!
+// Calls Foo::Foo(const Foo&) or some variant copy constructor.
+Foo f2;
+Foo f1 = f2;
+
+// Calls Foo::Foo(const Foo&) or variant, but only copies the 'Foo' part of
+// 'fooSub'. Any extra members of 'fooSub' are discarded. This sometimes
+// horrifying behavior is called "object slicing."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Calls Foo::operator=(Foo&) or variant.
+Foo f1;
+f1 = f2;
+
```
-Futher Reading:
+Further Reading:
An up-to-date language reference can be found at
<http://cppreference.com/w/cpp>
diff --git a/clojure.html.markdown b/clojure.html.markdown
index 7917ab08..a125d18f 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -22,7 +22,7 @@ and often automatically.
; Clojure is written in "forms", which are just
; lists of things inside parentheses, separated by whitespace.
;
-; The clojure reader assumes that the first thing is a
+; The clojure reader assumes that the first thing is a
; function or macro to call, and the rest are arguments.
; The first call in a file should be ns, to set the namespace
diff --git a/compojure.html.markdown b/compojure.html.markdown
index 36a8d123..32181e26 100644
--- a/compojure.html.markdown
+++ b/compojure.html.markdown
@@ -155,8 +155,8 @@ Now, your handlers may utilize query parameters:
```clojure
(defroutes myapp
(GET "/posts" req
- (let [title (get (:params req) "title")
- author (get (:params req) "author")]
+ (let [title (get (:params req) :title)
+ author (get (:params req) :author)]
(str "Title: " title ", Author: " author))))
```
@@ -165,8 +165,8 @@ Or, for POST and PUT requests, form parameters as well
```clojure
(defroutes myapp
(POST "/posts" req
- (let [title (get (:params req) "title")
- author (get (:params req) "author")]
+ (let [title (get (:params req) :title)
+ author (get (:params req) :author)]
(str "Title: " title ", Author: " author))))
```
diff --git a/elisp.html.markdown b/elisp.html.markdown
index 3208ffb8..3bed5d1c 100644
--- a/elisp.html.markdown
+++ b/elisp.html.markdown
@@ -29,7 +29,7 @@ filename: learn-emacs-lisp.el
;; I hereby decline any responsability. Have fun!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
+;;
;; Fire up Emacs.
;;
;; Hit the `q' key to dismiss the welcome message.
@@ -42,9 +42,9 @@ filename: learn-emacs-lisp.el
;; The scratch buffer is the default buffer when opening Emacs.
;; You are never editing files: you are editing buffers that you
;; can save to a file.
-;;
+;;
;; "Lisp interaction" refers to a set of commands available here.
-;;
+;;
;; Emacs has a built-in set of commands available in every buffer,
;; and several subsets of commands available when you activate a
;; specific mode. Here we use the `lisp-interaction-mode', which
@@ -109,7 +109,7 @@ filename: learn-emacs-lisp.el
;; The empty parentheses in the function's definition means that
;; it does not accept arguments. But always using `my-name' is
;; boring, let's tell the function to accept one argument (here
-;; the argument is called "name"):
+;; the argument is called "name"):
(defun hello (name) (insert "Hello " name))
;; `C-xC-e' => hello
@@ -305,7 +305,7 @@ filename: learn-emacs-lisp.el
(defun boldify-names ()
(switch-to-buffer-other-window "*test*")
(goto-char (point-min))
- (while (re-search-forward "Bonjour \\([^!]+\\)!" nil 't)
+ (while (re-search-forward "Bonjour \\(.+\\)!" nil 't)
(add-text-properties (match-beginning 1)
(match-end 1)
(list 'face 'bold)))
@@ -318,7 +318,7 @@ filename: learn-emacs-lisp.el
;; The regular expression is "Bonjour \\(.+\\)!" and it reads:
;; the string "Bonjour ", and
;; a group of | this is the \\( ... \\) construct
-;; any character not ! | this is the [^!]
+;; any character | this is the .
;; possibly repeated | this is the +
;; and the "!" string.
diff --git a/erlang.html.markdown b/erlang.html.markdown
index a7390c3e..a3b571d1 100644
--- a/erlang.html.markdown
+++ b/erlang.html.markdown
@@ -18,7 +18,7 @@ filename: learnerlang.erl
% Periods (`.`) (followed by whitespace) separate entire functions and
% expressions in the shell.
% Semicolons (`;`) separate clauses. We find clauses in several contexts:
-% function definitions and in `case`, `if`, `try..catch` and `receive`
+% function definitions and in `case`, `if`, `try..catch`, and `receive`
% expressions.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -27,20 +27,20 @@ filename: learnerlang.erl
Num = 42. % All variable names must start with an uppercase letter.
-% Erlang has single assignment variables, if you try to assign a different value
-% to the variable `Num`, you’ll get an error.
+% Erlang has single-assignment variables; if you try to assign a different
+% value to the variable `Num`, you’ll get an error.
Num = 43. % ** exception error: no match of right hand side value 43
% In most languages, `=` denotes an assignment statement. In Erlang, however,
-% `=` denotes a pattern matching operation. `Lhs = Rhs` really means this:
-% evaluate the right side (Rhs), and then match the result against the pattern
-% on the left side (Lhs).
+% `=` denotes a pattern-matching operation. `Lhs = Rhs` really means this:
+% evaluate the right side (`Rhs`), and then match the result against the
+% pattern on the left side (`Lhs`).
Num = 7 * 6.
-% Floating point number.
+% Floating-point number.
Pi = 3.14159.
-% Atoms, are used to represent different non-numerical constant values. Atoms
+% Atoms are used to represent different non-numerical constant values. Atoms
% start with lowercase letters, followed by a sequence of alphanumeric
% characters or the underscore (`_`) or at (`@`) sign.
Hello = hello.
@@ -53,34 +53,34 @@ AtomWithSpace = 'some atom with space'.
% Tuples are similar to structs in C.
Point = {point, 10, 45}.
-% If we want to extract some values from a tuple, we use the pattern matching
+% If we want to extract some values from a tuple, we use the pattern-matching
% operator `=`.
{point, X, Y} = Point. % X = 10, Y = 45
% We can use `_` as a placeholder for variables that we’re not interested in.
% The symbol `_` is called an anonymous variable. Unlike regular variables,
-% several occurrences of _ in the same pattern don’t have to bind to the same
-% value.
+% several occurrences of `_` in the same pattern don’t have to bind to the
+% same value.
Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
{_, {_, {_, Who}, _}, _} = Person. % Who = joe
% We create a list by enclosing the list elements in square brackets and
% separating them with commas.
% The individual elements of a list can be of any type.
-% The first element of a list is the head of the list. If you imagine removing the
-% head from the list, what’s left is called the tail of the list.
+% The first element of a list is the head of the list. If you imagine removing
+% the head from the list, what’s left is called the tail of the list.
ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
% If `T` is a list, then `[H|T]` is also a list, with head `H` and tail `T`.
% The vertical bar (`|`) separates the head of a list from its tail.
% `[]` is the empty list.
-% We can extract elements from a list with a pattern matching operation. If we
+% We can extract elements from a list with a pattern-matching operation. If we
% have a nonempty list `L`, then the expression `[X|Y] = L`, where `X` and `Y`
% are unbound variables, will extract the head of the list into `X` and the tail
% of the list into `Y`.
[FirstThing|OtherThingsToBuy] = ThingsToBuy.
% FirstThing = {apples, 10}
-% OtherThingsToBuy = {pears, 6}, {milk, 3}
+% OtherThingsToBuy = [{pears, 6}, {milk, 3}]
% There are no strings in Erlang. Strings are really just lists of integers.
% Strings are enclosed in double quotation marks (`"`).
@@ -117,17 +117,19 @@ c(geometry). % {ok,geometry}
geometry:area({rectangle, 10, 5}). % 50
geometry:area({circle, 1.4}). % 6.15752
-% In Erlang, two functions with the same name and different arity (number of arguments)
-% in the same module represent entirely different functions.
+% In Erlang, two functions with the same name and different arity (number of
+% arguments) in the same module represent entirely different functions.
-module(lib_misc).
--export([sum/1]). % export function `sum` of arity 1 accepting one argument: list of integers.
+-export([sum/1]). % export function `sum` of arity 1
+ % accepting one argument: list of integers.
sum(L) -> sum(L, 0).
sum([], N) -> N;
sum([H|T], N) -> sum(T, H+N).
-% Funs are "anonymous" functions. They are called this way because they have no
-% name. However they can be assigned to variables.
-Double = fun(X) -> 2*X end. % `Double` points to an anonymous function with handle: #Fun<erl_eval.6.17052888>
+% Funs are "anonymous" functions. They are called this way because they have
+% no name. However, they can be assigned to variables.
+Double = fun(X) -> 2 * X end. % `Double` points to an anonymous function
+ % with handle: #Fun<erl_eval.6.17052888>
Double(2). % 4
% Functions accept funs as their arguments and can return funs.
@@ -140,8 +142,9 @@ Triple(5). % 15
% The notation `[F(X) || X <- L]` means "the list of `F(X)` where `X` is taken
% from the list `L`."
L = [1,2,3,4,5].
-[2*X || X <- L]. % [2,4,6,8,10]
-% A list comprehension can have generators and filters which select subset of the generated values.
+[2 * X || X <- L]. % [2,4,6,8,10]
+% A list comprehension can have generators and filters, which select subset of
+% the generated values.
EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
% Guards are constructs that we can use to increase the power of pattern
@@ -155,17 +158,24 @@ max(X, Y) -> Y.
% A guard is a series of guard expressions, separated by commas (`,`).
% The guard `GuardExpr1, GuardExpr2, ..., GuardExprN` is true if all the guard
-% expressions `GuardExpr1, GuardExpr2, ...` evaluate to true.
+% expressions `GuardExpr1`, `GuardExpr2`, ..., `GuardExprN` evaluate to `true`.
is_cat(A) when is_atom(A), A =:= cat -> true;
is_cat(A) -> false.
is_dog(A) when is_atom(A), A =:= dog -> true;
is_dog(A) -> false.
-% A `guard sequence` is either a single guard or a series of guards, separated
-%by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at least
-% one of the guards `G1, G2, ...` evaluates to true.
-is_pet(A) when is_dog(A); is_cat(A) -> true;
-is_pet(A) -> false.
+% A guard sequence is either a single guard or a series of guards, separated
+% by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at
+% least one of the guards `G1`, `G2`, ..., `Gn` evaluates to `true`.
+is_pet(A) when is_atom(A), (A =:= dog) or (A =:= cat) -> true;
+is_pet(A) -> false.
+
+% Warning: not all valid Erlang expressions can be used as guard expressions;
+% in particular, our `is_cat` and `is_dog` functions cannot be used within the
+% guard sequence in `is_pet`'s definition. For a description of the
+% expressions allowed in guard sequences, refer to this
+% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912)
+% of the Erlang reference manual.
% Records provide a method for associating a name with a particular element in a
% tuple.
@@ -188,7 +198,7 @@ X = #todo{}.
X1 = #todo{status = urgent, text = "Fix errata in book"}.
% #todo{status = urgent, who = joe, text = "Fix errata in book"}
X2 = X1#todo{status = done}.
-% #todo{status = done,who = joe,text = "Fix errata in book"}
+% #todo{status = done, who = joe, text = "Fix errata in book"}
% `case` expressions.
% `filter` returns a list of all elements `X` in a list `L` for which `P(X)` is
@@ -209,8 +219,8 @@ max(X, Y) ->
true -> nil
end.
-% Warning: at least one of the guards in the `if` expression must evaluate to true;
-% otherwise, an exception will be raised.
+% Warning: at least one of the guards in the `if` expression must evaluate to
+% `true`; otherwise, an exception will be raised.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -218,7 +228,7 @@ max(X, Y) ->
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Exceptions are raised by the system when internal errors are encountered or
-% explicitly in code by calling `throw(Exception)`, `exit(Exception)` or
+% explicitly in code by calling `throw(Exception)`, `exit(Exception)`, or
% `erlang:error(Exception)`.
generate_exception(1) -> a;
generate_exception(2) -> throw(a);
@@ -227,7 +237,7 @@ generate_exception(4) -> {'EXIT', a};
generate_exception(5) -> erlang:error(a).
% Erlang has two methods of catching an exception. One is to enclose the call to
-% the function, which raised the exception within a `try...catch` expression.
+% the function that raises the exception within a `try...catch` expression.
catcher(N) ->
try generate_exception(N) of
Val -> {N, normal, Val}
@@ -241,23 +251,24 @@ catcher(N) ->
% exception, it is converted into a tuple that describes the error.
catcher(N) -> catch generate_exception(N).
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 4. Concurrency
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Erlang relies on the actor model for concurrency. All we need to write
-% concurrent programs in erlang are three primitives: spawning processes,
+% concurrent programs in Erlang are three primitives: spawning processes,
% sending messages and receiving messages.
-% To start a new process we use the `spawn` function, which takes a function
+% To start a new process, we use the `spawn` function, which takes a function
% as argument.
F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768>
spawn(F). % <0.44.0>
-% `spawn` returns a pid (process identifier), you can use this pid to send
-% messages to the process. To do message passing we use the `!` operator.
-% For all of this to be useful we need to be able to receive messages. This is
+% `spawn` returns a pid (process identifier); you can use this pid to send
+% messages to the process. To do message passing, we use the `!` operator.
+% For all of this to be useful, we need to be able to receive messages. This is
% achieved with the `receive` mechanism:
-module(calculateGeometry).
@@ -272,12 +283,13 @@ calculateArea() ->
io:format("We can only calculate area of rectangles or circles.")
end.
-% Compile the module and create a process that evaluates `calculateArea` in the shell
+% Compile the module and create a process that evaluates `calculateArea` in the
+% shell.
c(calculateGeometry).
CalculateArea = spawn(calculateGeometry, calculateArea, []).
CalculateArea ! {circle, 2}. % 12.56000000000000049738
-% The shell is also a process, you can use `self` to get the current pid
+% The shell is also a process; you can use `self` to get the current pid.
self(). % <0.41.0>
```
diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown
new file mode 100644
index 00000000..49c95820
--- /dev/null
+++ b/fr-fr/json-fr.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+filename: learnjson-fr.json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+ - ["Alois de Gouvello","https://github.com/aloisdg"]
+lang: fr-fr
+---
+
+Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes
+est susceptible d'être le plus simple jamais réalisé.
+
+JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons
+les commentaires du langage C (`//`, `/* */`). Pour les besoins de ce document, cependant,
+tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même.
+
+
+```json
+{
+ "Clé": "valeur",
+
+ "Clés": "devront toujours être entourées par des guillemets",
+ "nombres": 0,
+ "chaînes de caractères": "Hellø, wørld. Tous les caractères Unicode sont autorisés, accompagné d'un \"caractère d'échappement\".",
+ "a des booléens ?": true,
+ "rien": null,
+
+ "grand nombre": 1.2e+100,
+
+ "objets": {
+ "commentaire": "La majorité de votre strucutre sera des objets.",
+
+ "tableau": [0, 1, 2, 3, "Les tableaux peuvent contenir n'importe quoi.", 5],
+
+ "un autre objet": {
+ "commentaire": "Ces choses peuvent être imbriquées. C'est très utile."
+ }
+ },
+
+ "bêtises": [
+ {
+ "sources de potassium": ["bananes"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "style alternatif": {
+ "commentaire": "regarde ça !"
+ , "position de la virgule": "n'a pas d'importance - aussi longtemps qu'elle est avant la valeur, alors elle est valide."
+ , "un autre commentaire": "comme c'est gentil"
+ },
+
+ "C'était court": "Et, vous avez terminé. Maintenant, vous savez tout ce que JSON a à offrir."
+}
+```
diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown
new file mode 100644
index 00000000..3f225a0f
--- /dev/null
+++ b/fr-fr/r-fr.html.markdown
@@ -0,0 +1,746 @@
+---
+language: R
+contributors:
+ - ["e99n09", "http://github.com/e99n09"]
+ - ["isomorphismes", "http://twitter.com/isomorphisms"]
+translators:
+ - ["Anne-Catherine Dehier", "https://github.com/spellart"]
+filename: learnr-fr.r
+---
+
+R est un langage de programmation statistique. Il dispose de nombreuses
+bibliothèques pour le téléchargement et le nettoyage d'ensembles de données,
+l'exécution de procédures statistiques, et la réalisation de graphiques.
+On peut également exécuter des commmandes `R` au sein d'un document LaTeX.
+
+
+```r
+
+# Les commentaires commencent avec des symboles numériques.
+
+# Il n'est pas possible de faire des commentaires multilignes,
+# mais on peut placer plusieurs commentaires les uns en dessous
+# des autres comme ceci.
+
+# Sur Mac, taper COMMAND-ENTER pour exécuter une ligne
+# et sur Windows taper CTRL-ENTER
+
+
+
+########################################################################
+# Les choses que vous pouvez faire sans rien comprendre
+# à la programmation
+########################################################################
+
+# Dans cette section, nous vous montrons quelques trucs cools que vous
+# pouvez faire avec R sans rien comprendre à la programmation.
+# Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait.
+# Profitez simplement !
+
+data() # parcours les ensembles de données préchargées
+data(rivers) # récupère ceci : "Lengths of Major North American Rivers"
+ls() # notez que "rivers" apparaît maintenant dans votre espace de travail
+head(rivers) # donne un aperçu des données
+# 735 320 325 392 524 450
+
+length(rivers) # Combien de rivers ont été mesurées ?
+# 141
+summary(rivers) # Quelles sont les principales données statistiques ?
+# Min. 1st Qu. Median Mean 3rd Qu. Max.
+# 135.0 310.0 425.0 591.2 680.0 3710.0
+
+# Fait un diagramme à tiges et à feuilles (visualisation de données de
+# types histogramme)
+stem(rivers)
+
+
+# Le point décimal est de 2 chiffres à droite du |
+#
+# 0 | 4
+# 2 | 011223334555566667778888899900001111223333344455555666688888999
+# 4 | 111222333445566779001233344567
+# 6 | 000112233578012234468
+# 8 | 045790018
+# 10 | 04507
+# 12 | 1471
+# 14 | 56
+# 16 | 7
+# 18 | 9
+# 20 |
+# 22 | 25
+# 24 | 3
+# 26 |
+# 28 |
+# 30 |
+# 32 |
+# 34 |
+# 36 | 1
+
+stem(log(rivers)) # Notez que les données ne sont ni normales
+# ni lognormales !
+# Prenez-ça, la courbe en cloche
+
+# Le point décimal est à 1 chiffre à gauche du |
+#
+# 48 | 1
+# 50 |
+# 52 | 15578
+# 54 | 44571222466689
+# 56 | 023334677000124455789
+# 58 | 00122366666999933445777
+# 60 | 122445567800133459
+# 62 | 112666799035
+# 64 | 00011334581257889
+# 66 | 003683579
+# 68 | 0019156
+# 70 | 079357
+# 72 | 89
+# 74 | 84
+# 76 | 56
+# 78 | 4
+# 80 |
+# 82 | 2
+
+# Fait un histogramme :
+hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres
+hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard
+
+# Ici d'autres données qui viennent préchargées. R en a des tonnes.
+data(discoveries)
+plot(discoveries, col="#333333", lwd=3, xlab="Year",
+ main="Number of important discoveries per year")
+plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year",
+ main="Number of important discoveries per year")
+
+# Plutôt que de laisser l'ordre par défaut (par année)
+# Nous pourrions aussi trier pour voir ce qu'il y a de typique
+sort(discoveries)
+# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2
+# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3
+# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4
+# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12
+
+stem(discoveries, scale=2)
+#
+# Le point décimale est à la |
+#
+# 0 | 000000000
+# 1 | 000000000000
+# 2 | 00000000000000000000000000
+# 3 | 00000000000000000000
+# 4 | 000000000000
+# 5 | 0000000
+# 6 | 000000
+# 7 | 0000
+# 8 | 0
+# 9 | 0
+# 10 | 0
+# 11 |
+# 12 | 0
+
+max(discoveries)
+# 12
+summary(discoveries)
+# Min. 1st Qu. Median Mean 3rd Qu. Max.
+# 0.0 2.0 3.0 3.1 4.0 12.0
+
+# Lance un dé plusieurs fois
+round(runif(7, min=.5, max=6.5))
+# 1 4 6 1 4 6 4
+# Vos numéros diffèreront des miens à moins que nous mettions
+# le même random.seed(31337)
+
+# Dessine à partir d'une normale Gaussienne 9 fois
+rnorm(9)
+# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271
+# [7] -0.59975593 0.57629164 1.08455362
+
+
+
+##############################################################
+# les types de données et l'arithmétique de base
+##############################################################
+
+# Maintenant pour la partie orientée programmation du tutoriel.
+# Dans cette section vous rencontrerez les types de données importants de R :
+# les entiers, les numériques, les caractères, les logiques, et les facteurs.
+
+# LES ENTIERS
+# Les entiers de type long sont écrits avec L
+5L # 5
+class(5L) # "integer"
+# (Essayez ?class pour plus d'informations sur la fonction class().)
+# Avec R, chaque valeur seule, comme 5L, est considérée comme
+# un vecteur de longueur 1
+length(5L) # 1
+# On peut avoir un vecteur d'entiers avec une longueur > 1 :
+c(4L, 5L, 8L, 3L) # 4 5 8 3
+length(c(4L, 5L, 8L, 3L)) # 4
+class(c(4L, 5L, 8L, 3L)) # "integer"
+
+# LES NUMÉRIQUES
+# Un "numeric" est un nombre à virgule flottante d'une précision double
+5 # 5
+class(5) # "numeric"
+# Encore une fois, tout dans R est un vecteur ;
+# Vous pouvez faire un vecteur numérique avec plus d'un élément
+c(3,3,3,2,2,1) # 3 3 3 2 2 1
+# Vous pouvez aussi utiliser la notation scientifique
+5e4 # 50000
+6.02e23 # nombre d'Avogadro
+1.6e-35 # longueur de Planck
+# Vous pouvez également avoir des nombres infiniments grands ou petits
+class(Inf) # "numeric"
+class(-Inf) # "numeric"
+# Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf);
+# Ça permet d'éviter de réaliser une table de la loi normale.
+
+# ARITHMÉTIQUES DE BASE
+# Vous pouvez faire de l'arithmétique avec des nombres
+# Faire des opérations arithmétiques en mixant des entiers
+# et des numériques
+# donne un autre numérique
+10L + 66L # 76 # un entier plus un entier donne un entier
+53.2 - 4 # 49.2 # un numérique moins un numérique donne un numérique
+2.0 * 2L # 4 # un numérique multiplié par un entier donne un numérique
+3L / 4 # 0.75 # un entier sur un numérique donne un numérique
+3 %% 2 # 1 # le reste de deux numériques est un autre numérique
+# Les opérations arithmétiques illégales donnent un "Not A Number" :
+0 / 0 # NaN
+class(NaN) # "numeric"
+# Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une
+# longueur plus grande que 1, à condition que la longueur du plus grand
+# vecteur soit un multiple entier du plus petit
+c(1,2,3) + c(1,2,3) # 2 4 6
+
+# LES CARACTÈRES
+# Il n'y a pas de différences entre les chaînes de caractères et
+# les caractères en R
+"Horatio" # "Horatio"
+class("Horatio") # "character"
+class('H') # "character"
+# Ceux-ci sont tous les deux des vecteurs de longueur 1
+# Ici un plus long :
+c('alef', 'bet', 'gimmel', 'dalet', 'he')
+# =>
+# "alef" "bet" "gimmel" "dalet" "he"
+length(c("Call","me","Ishmael")) # 3
+# Vous pouvez utiliser des expressions rationnelles sur les vecteurs de caractères :
+substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
+gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis."
+# R possède plusieurs vecteurs de caractères préconstruits :
+letters
+# =>
+# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
+# [20] "t" "u" "v" "w" "x" "y" "z"
+month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
+
+# LES TYPES BOOLÉENS
+# En R, un "logical" est un booléen
+class(TRUE) # "logical"
+class(FALSE) # "logical"
+# Leur comportement est normal
+TRUE == TRUE # TRUE
+TRUE == FALSE # FALSE
+FALSE != FALSE # FALSE
+FALSE != TRUE # TRUE
+# Les données manquantes (NA) sont logiques également
+class(NA) # "logical"
+# On utilise | et & pour les operations logiques.
+# OR
+TRUE | FALSE # TRUE
+# AND
+TRUE & FALSE # FALSE
+# Vous pouvez tester si x est TRUE
+isTRUE(TRUE) # TRUE
+# Ici nous avons un vecteur de type logique avec plusieurs éléments :
+c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
+c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
+
+# LES FACTEURS
+# Les facteurs sont généralement utilisés pour y stocker des
+# variables qualitatives (catégorielles).
+# Les facteurs peuvent être ordonnés (comme le niveau scolaire
+# des enfants) ou non ordonnés (comme le sexe)
+factor(c("female", "female", "male", NA, "female"))
+# female female male <NA> female
+# Les niveaux : female male
+# Les facteurs possèdent un attribut appelé niveau ("level").
+# Les niveaux sont des vecteurs contenant toutes les valeurs
+# que peuvent prendre les données catégorielles.
+# Notez que les données manquantes n'entrent pas dans le niveau
+levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
+# Si le vecteur de facteurs a une longueur 1, ses niveaux seront
+# de longueur 1 également
+length(factor("male")) # 1
+length(levels(factor("male"))) # 1
+# On rencontre communément des facteurs dans des "data frame",
+# un type de données que nous couvrirons plus tard
+data(infert) # "Infertility after Spontaneous and Induced Abortion"
+levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs"
+
+# NULL
+# "NULL" est bizarre ; on l'utilise pour effacer un vecteur
+class(NULL) # NULL
+parakeet = c("beak", "feathers", "wings", "eyes")
+parakeet
+# =>
+# [1] "beak" "feathers" "wings" "eyes"
+parakeet <- NULL
+parakeet
+# =>
+# NULL
+
+# LES CONVERSIONS DE TYPES
+# Les conversions de types servent à forcer une valeur à prendre
+# un type différent
+as.character(c(6, 8)) # "6" "8"
+as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE
+# Si vous mettez des éléments de différents types dans un vecteur,
+# des coercitions bizarres se produisent :
+c(TRUE, 4) # 1 4
+c("dog", TRUE, 4) # "dog" "TRUE" "4"
+as.numeric("Bilbo")
+# =>
+# [1] NA
+# Message d'avertissement :
+# NAs est introduit par coercition
+
+# Notez également : ce n'étaient que des types de données basiques
+# Il y a beaucoup d'autres types de données, comme les dates,
+# les séries temporelles, etc ...
+
+
+
+#######################################
+# Variables, boucles , if/else
+#######################################
+
+# Une variable est comme une boîte dans laquelle on garde une valeur
+# pour l'utiliser plus tard.
+# Nous appellons ça "assigner" une valeur à une variable.
+# Avoir des variables nous permet d'écrire des boucles, des fonctions, et
+# des instructions conditionnelles (if/else)
+
+# LES VARIABLES
+# Beaucoup de façons d'assigner des choses :
+x = 5 # c'est correct
+y <- "1" # c'est préféré
+TRUE -> z # ça marche mais c'est bizarre
+
+# LES BOUCLES
+# Il y a les boucles for :
+for (i in 1:4) {
+ print(i)
+}
+# Il y a les boucles while :
+a <- 10
+while (a > 4) {
+ cat(a, "...", sep = "")
+ a <- a - 1
+}
+# Gardez à l'esprit que les boucles for et while s'exécutent lentement
+# en R.
+# Des opérations sur la totalité d'un vecteur (ex une ligne entière,
+# une colonne entière),
+# ou les fonctions de type apply() (nous en parlerons plus tard),
+# sont préférées.
+
+# IF/ELSE
+# Encore une fois assez standard
+if (4 > 3) {
+ print("4 is greater than 3")
+} else {
+ print("4 is not greater than 3")
+}
+# =>
+# [1] "4 is greater than 3"
+
+# LES FONCTIONS
+# se définissent comme ceci :
+jiggle <- function(x) {
+ x = x + rnorm(1, sd=.1) # ajoute un peu de bruit (contrôlé)
+ return(x)
+}
+# Appelées comme n'importe quelles autres fonction R :
+jiggle(5) # 5±ε. After set.seed(2716057), jiggle(5)==5.005043
+
+
+
+##########################################################################
+# Les structures de données : les vecteurs, les matrices,
+# les data frames et les tableaux
+##########################################################################
+
+# À UNE DIMENSION
+
+# Commençons par le tout début, et avec quelque chose que
+# vous connaissez déjà : les vecteurs.
+vec <- c(8, 9, 10, 11)
+vec # 8 9 10 11
+# Nous demandons des éléments spécifiques en les mettant entre crochets
+# (Notez que R commence à compter à partir de 1)
+vec[1] # 8
+letters[18] # "r"
+LETTERS[13] # "M"
+month.name[9] # "September"
+c(6, 8, 7, 5, 3, 0, 9)[3] # 7
+# Nous pouvons également rechercher des indices de composants spécifiques,
+which(vec %% 2 == 0) # 1 3
+# Récupèrer seulement les premières ou dernières entrées du vecteur,
+head(vec, 1) # 8
+tail(vec, 2) # 10 11
+# ou vérifier si un certaine valeur est dans le vecteur
+any(vec == 10) # TRUE
+# Si un index "dépasse" vous obtiendrez NA :
+vec[6] # NA
+# Vous pouvez trouver la longueur de votre vecteur avec length()
+length(vec) # 4
+# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des
+# sous-ensembles de vecteurs
+vec * 4 # 16 20 24 28
+vec[2:3] * 5 # 25 30
+any(vec[2:3] == 8) # FALSE
+# Et R a beaucoup de méthodes statistiques pré-construites pour les vecteurs :
+mean(vec) # 9.5
+var(vec) # 1.666667
+sd(vec) # 1.290994
+max(vec) # 11
+min(vec) # 8
+sum(vec) # 38
+# Quelques fonctions préconstruites sympas supplémentaires :
+5:15 # 5 6 7 8 9 10 11 12 13 14 15
+seq(from=0, to=31337, by=1337)
+# =>
+# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707
+# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751
+
+# À DEUX DIMENSIONS (TOUT DANS UNE CLASSE)
+
+# Vous pouvez créer une matrice à partir d'entrées du même type comme ceci :
+mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
+mat
+# =>
+# [,1] [,2]
+# [1,] 1 4
+# [2,] 2 5
+# [3,] 3 6
+# Différemment du vecteur, la classe d'une matrice est "matrix",
+# peut importe ce qu'elle contient
+class(mat) # => "matrix"
+# Récupérer la première ligne
+mat[1,] # 1 4
+# Réaliser une opération sur la première colonne
+3 * mat[,1] # 3 6 9
+# Demander une cellule spécifique
+mat[3,2] # 6
+
+# Transposer la matrice entière
+t(mat)
+# =>
+# [,1] [,2] [,3]
+# [1,] 1 2 3
+# [2,] 4 5 6
+
+# La multiplication de matrices
+mat %*% t(mat)
+# =>
+# [,1] [,2] [,3]
+# [1,] 17 22 27
+# [2,] 22 29 36
+# [3,] 27 36 45
+
+# cbind() colle des vecteurs ensemble en colonne pour faire une matrice
+mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
+mat2
+# =>
+# [,1] [,2]
+# [1,] "1" "dog"
+# [2,] "2" "cat"
+# [3,] "3" "bird"
+# [4,] "4" "dog"
+class(mat2) # matrix
+# Encore une fois regardez ce qui se passe !
+# Parce que les matrices peuvent contenir des entrées de toutes sortes de
+# classes, tout sera converti en classe caractère
+c(class(mat2[,1]), class(mat2[,2]))
+
+# rbind() colle des vecteurs ensemble par lignes pour faire une matrice
+mat3 <- rbind(c(1,2,4,5), c(6,7,0,4))
+mat3
+# =>
+# [,1] [,2] [,3] [,4]
+# [1,] 1 2 4 5
+# [2,] 6 7 0 4
+# Ah, tout de la même classe. Pas de coercitions. Beaucoup mieux.
+
+# À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES)
+
+# Pour des colonnes de différents types, utiliser une data frame
+# Cette structure de données est si utile pour la programmation statistique,
+# qu'une version a été ajoutée à Python dans le paquet "pandas".
+
+students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"),
+ c(3,2,2,1,0,-1),
+ c("H", "G", "G", "R", "S", "G"))
+names(students) <- c("name", "year", "house") # name the columns
+class(students) # "data.frame"
+students
+# =>
+# name year house
+# 1 Cedric 3 H
+# 2 Fred 2 G
+# 3 George 2 G
+# 4 Cho 1 R
+# 5 Draco 0 S
+# 6 Ginny -1 G
+class(students$year) # "numeric"
+class(students[,3]) # "factor"
+# Trouver les dimensions
+nrow(students) # 6
+ncol(students) # 3
+dim(students) # 6 3
+# La fonction data.frame() convertit les vecteurs caractères en vecteurs de
+# facteurs par défaut; désactiver cette fonction en règlant
+# stringsAsFactors = FALSE quand vous créer la data.frame
+?data.frame
+
+# Il y a plusieurs façons de subdiviser les data frames,
+# toutes subtilement différentes
+students$year # 3 2 2 1 0 -1
+students[,2] # 3 2 2 1 0 -1
+students[,"year"] # 3 2 2 1 0 -1
+
+# Une version améliorée de la structure data.frame est data.table.
+# Si vous travaillez avec des données volumineuses ou des panels, ou avez
+# besoin de fusionner quelques ensembles de données, data.table peut être
+# un bon choix. Ici un tour éclair :
+install.packages("data.table") # télécharge le paquet depuis CRAN
+require(data.table) # le charge
+students <- as.data.table(students)
+students # regardez la différence à l'impression
+# =>
+# name year house
+# 1: Cedric 3 H
+# 2: Fred 2 G
+# 3: George 2 G
+# 4: Cho 1 R
+# 5: Draco 0 S
+# 6: Ginny -1 G
+students[name=="Ginny"] # obtiens les lignes avec name == "Ginny"
+# =>
+# name year house
+# 1: Ginny -1 G
+students[year==2] # obtiens les lignes avec year == 2
+# =>
+# name year house
+# 1: Fred 2 G
+# 2: George 2 G
+# data.table facilite la fusion entre deux ensembles de données
+# Faisons une autre data.table pour fusionner students
+founders <- data.table(house=c("G","H","R","S"),
+ founder=c("Godric","Helga","Rowena","Salazar"))
+founders
+# =>
+# house founder
+# 1: G Godric
+# 2: H Helga
+# 3: R Rowena
+# 4: S Salazar
+setkey(students, house)
+setkey(founders, house)
+students <- founders[students] # merge les deux ensembles de données qui matchent "house"
+setnames(students, c("house","houseFounderName","studentName","year"))
+students[,order(c("name","year","house","houseFounderName")), with=F]
+# =>
+# studentName year house houseFounderName
+# 1: Fred 2 G Godric
+# 2: George 2 G Godric
+# 3: Ginny -1 G Godric
+# 4: Cedric 3 H Helga
+# 5: Cho 1 R Rowena
+# 6: Draco 0 S Salazar
+
+# data.table facilite le résumé des tableaux
+students[,sum(year),by=house]
+# =>
+# house V1
+# 1: G 3
+# 2: H 3
+# 3: R 1
+# 4: S 0
+
+# Pour supprimer une colonne d'une data.frame ou data.table,
+# assignez-lui la valeur NULL
+students$houseFounderName <- NULL
+students
+# =>
+# studentName year house
+# 1: Fred 2 G
+# 2: George 2 G
+# 3: Ginny -1 G
+# 4: Cedric 3 H
+# 5: Cho 1 R
+# 6: Draco 0 S
+
+# Supprimer une ligne en subdivisant
+# En utilisant data.table :
+students[studentName != "Draco"]
+# =>
+# house studentName year
+# 1: G Fred 2
+# 2: G George 2
+# 3: G Ginny -1
+# 4: H Cedric 3
+# 5: R Cho 1
+# En utilisant data.frame :
+students <- as.data.frame(students)
+students[students$house != "G",]
+# =>
+# house houseFounderName studentName year
+# 4 H Helga Cedric 3
+# 5 R Rowena Cho 1
+# 6 S Salazar Draco 0
+
+# MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE)
+
+# Les arrays créent des tableaux de n dimensions.
+# Tous les éléments doivent être du même type.
+# Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice)
+array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4))
+# =>
+# [,1] [,2] [,3] [,4]
+# [1,] 1 4 8 3
+# [2,] 2 5 9 6
+# Vous pouvez aussi utiliser array pour faire des matrices à 3 dimensions :
+array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
+# =>
+# , , 1
+#
+# [,1] [,2]
+# [1,] 2 8
+# [2,] 300 9
+# [3,] 4 0
+#
+# , , 2
+#
+# [,1] [,2]
+# [1,] 5 66
+# [2,] 60 7
+# [3,] 0 847
+
+# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES,
+# DE DIFFÉRENTS TYPES)
+
+# Enfin, R a des listes (de vecteurs)
+list1 <- list(time = 1:40)
+list1$price = c(rnorm(40,.5*list1$time,4)) # random
+list1
+# Vous pouvez obtenir des éléments de la liste comme ceci
+list1$time # une façon
+list1[["time"]] # une autre façon
+list1[[1]] # encore une façon différente
+# =>
+# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
+# [34] 34 35 36 37 38 39 40
+# Vous pouvez subdiviser les éléments d'une liste comme n'importe quel vecteur
+list1$price[4]
+
+# Les listes ne sont pas les structures de données les plus efficaces
+# à utiliser avec R ;
+# À moins d'avoir une très bonne raison, vous devriez utiliser data.frames
+# Les listes sont souvent retournées par des fonctions qui effectuent
+# des régressions linéaires.
+
+##########################################
+# La famille de fonction apply()
+##########################################
+
+# Vous vous rappelez mat ?
+mat
+# =>
+# [,1] [,2]
+# [1,] 1 4
+# [2,] 2 5
+# [3,] 3 6
+# Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X
+# sur les lignes (MAR = 1) ou les colonnes (MAR = 2)
+# R exécute FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement
+# que le ferait une boucle for ou while
+apply(mat, MAR = 2, jiggle)
+# =>
+# [,1] [,2]
+# [1,] 3 15
+# [2,] 7 19
+# [3,] 11 23
+# D'autres fonctions : ?lapply, ?sapply
+
+# Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant
+
+# Le paquet plyr vise à remplacer (et améliorer !) la famille *apply().
+install.packages("plyr")
+require(plyr)
+?plyr
+
+
+
+############################
+# Charger des données
+############################
+
+# "pets.csv" est un fichier sur internet
+# (mais il pourrait être tout aussi facilement sur votre ordinateur)
+pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv")
+pets
+head(pets, 2) # first two rows
+tail(pets, 1) # last row
+
+# Pour sauvegarder une data frame ou une matrice en fichier .csv
+write.csv(pets, "pets2.csv") # to make a new .csv file
+# définir le répertoire de travail avec setwd(), le récupérer avec getwd()
+
+# Essayez ?read.csv et ?write.csv pour plus d'informations
+
+
+
+################
+# Les tracés
+################
+
+# LES FONCTIONS DE TRACÉ PRÉCONSTRUITES
+# Les diagrammes de dispersion !
+plot(list1$time, list1$price, main = "fake data")
+# Les régressions !
+linearModel <- lm(price ~ time, data = list1)
+linearModel # sort le résultat de la régression
+# Tracer une ligne de regression sur une tracé existant
+abline(linearModel, col = "red")
+# Obtenir une variété de diagnostiques sympas
+plot(linearModel)
+# Les histogrammes !
+hist(rpois(n = 10000, lambda = 5), col = "thistle")
+# Les diagrammes en bâtons !
+barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
+
+# GGPLOT2
+# Mais ceux-ci ne sont même pas les plus jolis tracés de R
+# Essayez le paquet ggplot2 pour d'avantages de graphiques
+install.packages("ggplot2")
+require(ggplot2)
+?ggplot2
+pp <- ggplot(students, aes(x=house))
+pp + geom_histogram()
+ll <- as.data.table(list1)
+pp <- ggplot(ll, aes(x=time,price))
+pp + geom_point()
+# ggplot2 a une documentation excellente
+#(disponible sur http://docs.ggplot2.org/current/)
+
+
+
+```
+
+## Comment obtenir R ?
+
+* Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/)
+* [RStudio](http://www.rstudio.com/ide/) est un autre GUI
diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
new file mode 100644
index 00000000..b8807104
--- /dev/null
+++ b/fr-fr/typescript-fr.html.markdown
@@ -0,0 +1,174 @@
+---
+language: TypeScript
+contributors:
+ - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+ - ["Alois de Gouvello", "https://github.com/aloisdg"]
+filename: learntypescript-fr.ts
+lang: fr-fr
+---
+
+TypeScript est un langage visant à faciliter le développement d'applications larges et scalables, écrites en JavaScript.
+TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript.
+C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur.
+
+Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/).
+
+Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et accéder directement au rendu JavaScript.
+
+```js
+// Il y a 3 types basiques en TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Si nous ne pouvons pas déterminer le type, on utilise `Any`
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // ok, définitivement un booléen
+
+// Pour les collections, il y a les tableaux typés et les tableaux génériques
+var list: number[] = [1, 2, 3]; // Un tableaux typé
+var list: Array<number> = [1, 2, 3]; // un tableau générique
+
+// Pour les énumeration
+enum Color { Red, Green, Blue };
+var c: Color = Color.Green;
+
+// Enfin, `void` est utilisé dans le cas spécifique
+// d'une fonction ne retournant rien
+function bigHorribleAlert(): void {
+ alert("Je suis une petite boîte ennuyeuse !");
+}
+
+// Les fonctions sont des entités de première classe. Le langage supporte
+// les expressions lambda et utilise l'inférence de type
+
+// Les fonctions ci-dessous sont équivalentes, une signature identique
+// sera inférée par le compilateur, et le même JavaScript sera généré
+var f1 = function(i: number): number { return i * i; }
+// Retourne un type inféré
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Retourne un type inféré
+var f4 = (i: number) => { return i * i; }
+// Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire
+var f5 = (i: number) => i * i;
+
+// Les interfaces sont structurées, tout les objets qui ont ces propriétés
+// sont compatible avec l'interface
+interface Person {
+ name: string;
+ // Les propriétés optionnelles sont identifiées avec un "?"
+ age?: number;
+ // Et bien sûr, les fonctions
+ move(): void;
+}
+
+// Un objet implémentant l'interface "Person" peut être traité comme
+// une Person car il a les propriétés "name" et "move"
+var p: Person = { name: "Bobby", move: () => {} };
+// Des objets implémentants la propriété optionnelle :
+// valide car "age" est un nombre
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// invalide car "age" n'est pas un nombre
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Les interfaces peuvent aussi décrire un type de fonction
+interface SearchFunc {
+ (source: string, subString: string): boolean;
+}
+
+// Seul les types des paramètres sont importants. Les noms ne le sont pas.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+ return src.search(sub) != -1;
+}
+
+// Les membres des classes sont publiques par défaut.
+class Point {
+ // Propriétés
+ x: number;
+
+ // Constructeur - Les mots clés "public" et "private" dans ce contexte
+ // génèrent le code de la propriété et son initialisation dans le
+ // constructeur. Ici, "y" sera défini de la même façon que "x",
+ // mais avec moins de code. Les valeurs par défaut sont supportées.
+ constructor(x: number, public y: number = 0) {
+ this.x = x;
+ }
+
+ // Fonctions
+ dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+ // Membres statiques
+ static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); // y sera 0
+
+// Héritage
+class Point3D extends Point {
+ constructor(x: number, y: number, public z: number = 0) {
+ // Un appel explicite au constructeur de la super classe
+ // est obligatoire.
+ super(x, y);
+ }
+
+ // Redéfinition
+ dist() {
+ var d = super.dist();
+ return Math.sqrt(d * d + this.z * this.z);
+ }
+}
+
+// Modules, "." peut être utilisé comme un séparateur de sous modules.
+module Geometry {
+ export class Square {
+ constructor(public sideLength: number = 0) {
+ }
+ area() {
+ return Math.pow(this.sideLength, 2);
+ }
+ }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Alias local pour référencer un module
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Génériques
+// Classes
+class Tuple<T1, T2> {
+ constructor(public item1: T1, public item2: T2) {
+ }
+}
+
+// Interfaces
+interface Pair<T> {
+ item1: T;
+ item2: T;
+}
+
+// Et fonctions
+var pairToTuple = function<T>(p: Pair<T>) {
+ return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Inclure des références à un fichier :
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Lectures complémentaires
+ * [Site officiel de TypeScript] (http://www.typescriptlang.org/)
+ * [Spécification du langage TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Code source sur GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/groovy.html.markdown b/groovy.html.markdown
index 8fb1b346..629b6d18 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -405,7 +405,7 @@ assert sum(2,5) == 7
## Further resources
-[Groovy documentation](http://groovy.codehaus.org/Documentation)
+[Groovy documentation](http://www.groovy-lang.org/documentation.html)
[Groovy web console](http://groovyconsole.appspot.com/)
diff --git a/haxe.html.markdown b/haxe.html.markdown
index c807d2d7..ee214540 100644
--- a/haxe.html.markdown
+++ b/haxe.html.markdown
@@ -323,7 +323,7 @@ class LearnHaxe3{
var l = 0;
do{
trace("do statement always runs at least once");
- } while (i > 0);
+ } while (l > 0);
// for loop
/*
@@ -340,7 +340,7 @@ class LearnHaxe3{
// (more on ranges later as well)
var n = ['foo', 'bar', 'baz'];
for (val in 0...n.length){
- trace(val + " is the value for val (an index for m)");
+ trace(val + " is the value for val (an index for n)");
}
@@ -375,7 +375,7 @@ class LearnHaxe3{
case "rex" : favorite_thing = "shoe";
case "spot" : favorite_thing = "tennis ball";
default : favorite_thing = "some unknown treat";
- // case _ : "some unknown treat"; // same as default
+ // case _ : favorite_thing = "some unknown treat"; // same as default
}
// The "_" case above is a "wildcard" value
// that will match anything.
@@ -397,7 +397,7 @@ class LearnHaxe3{
// if statements
var k = if (true) 10 else 20;
- trace("K equals ", k); // outputs 10
+ trace("k equals ", k); // outputs 10
var other_favorite_thing = switch(my_dog_name) {
case "fido" : "teddy";
@@ -495,8 +495,10 @@ class LearnHaxe3{
// foo_instance.public_read = 4; // this will throw an error if uncommented:
// trace(foo_instance.public_write); // as will this.
- trace(foo_instance + " is the value for foo_instance"); // calls the toString method
- trace(foo_instance.toString() + " is the value for foo_instance.toString()"); // same thing
+ // calls the toString method:
+ trace(foo_instance + " is the value for foo_instance");
+ // same thing:
+ trace(foo_instance.toString() + " is the value for foo_instance.toString()");
/*
@@ -524,8 +526,8 @@ class LearnHaxe3{
*/
class FooClass extends BarClass implements BarInterface{
public var public_any:Int; // public variables are accessible anywhere
- public var public_read (default,null): Int; // use this style to only enable public read
- public var public_write (null, default): Int; // or public write
+ public var public_read (default, null): Int; // enable only public read
+ public var public_write (null, default): Int; // or only public write
public var property (get, set): Int; // use this style to enable getters/setters
// private variables are not available outside the class.
@@ -534,9 +536,10 @@ class FooClass extends BarClass implements BarInterface{
// a public constructor
public function new(arg:Int){
- super(); // call the constructor of the parent object, since we extended BarClass
+ // call the constructor of the parent object, since we extended BarClass:
+ super();
- this.public_any= 0;
+ this.public_any = 0;
this._private = arg;
}
diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown
new file mode 100644
index 00000000..f892845f
--- /dev/null
+++ b/it-it/bash-it.html.markdown
@@ -0,0 +1,275 @@
+---
+category: tool
+tool: bash
+contributors:
+ - ["Max Yankov", "https://github.com/golergka"]
+ - ["Darren Lin", "https://github.com/CogBear"]
+ - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+ - ["Denis Arh", "https://github.com/darh"]
+ - ["akirahirose", "https://twitter.com/akirahirose"]
+ - ["Anton Strömkvist", "http://lutic.org/"]
+ - ["Rahil Momin", "https://github.com/iamrahil"]
+ - ["Gregrory Kielian", "https://github.com/gskielian"]
+filename: LearnBash.sh
+translators:
+ - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+---
+
+Bash è il nome della shell di unix, la quale è stata distribuita anche come shell del sistema oprativo GNU e la shell di default su Linux e Mac OS X.
+Quasi tutti gli esempi sottostanti possono fare parte di uno shell script o eseguiti direttamente nella shell.
+
+[Per saperne di piu'.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# La prima riga dello script è lo shebang il quale dice al sistema come eseguire
+# lo script: http://it.wikipedia.org/wiki/Shabang
+# Come avrai già immaginato, i commenti iniziano con #. Lo shebang stesso è un commento.
+
+# Semplice esempio ciao mondo:
+echo Ciao mondo!
+
+# Ogni comando inizia su una nuova riga, o dopo un punto e virgola:
+echo 'Questa è la prima riga'; echo 'Questa è la seconda riga'
+
+# Per dichiarare una variabile:
+VARIABILE="Una stringa"
+
+# Ma non così:
+VARIABILE = "Una stringa"
+# Bash stabilirà che VARIABILE è un comando da eseguire e darà un errore
+# perchè non esiste.
+
+# Usare la variabile:
+echo $VARIABILE
+echo "$VARIABILE"
+echo '$VARIABILE'
+# Quando usi la variabile stessa - assegnala, esportala, oppure — scrivi
+# il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $.
+# Nota che ' (singolo apice) non espande le variabili!
+
+# Sostituzione di stringhe nelle variabili
+echo ${VARIABILE/Una/A}
+# Questo sostituirà la prima occorrenza di "Una" con "La"
+
+# Sottostringa di una variabile
+echo ${VARIABILE:0:7}
+# Questo ritornerà solamente i primi 7 caratteri
+
+# Valore di default per la variabile
+echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"}
+# Questo funziona per null (FOO=), stringa vuota (FOO=""), zero (FOO=0) ritorna 0
+
+# Variabili builtin:
+# Ci sono delle variabili builtin molto utili, come
+echo "Valore di ritorno dell'ultimo programma eseguito: $?"
+echo "PID dello script: $$"
+echo "Numero di argomenti: $#"
+echo "Argomenti dello script: $@"
+echo "Argomenti dello script separati in variabili distinte: $1 $2..."
+
+# Leggere un valore di input:
+echo "Come ti chiami?"
+read NOME # Nota che non abbiamo dovuto dichiarare una nuova variabile
+echo Ciao, $NOME!
+
+# Classica struttura if:
+# usa 'man test' per maggiori informazioni sulle condizionali
+if [ $NOME -ne $USER ]
+then
+ echo "Il tuo nome non è lo username"
+else
+ echo "Il tuo nome è lo username"
+fi
+
+# C'è anche l'esecuzione condizionale
+echo "Sempre eseguito" || echo "Eseguito solo se la prima condizione fallisce"
+echo "Sempre eseguito" && echo "Eseguito solo se la prima condizione NON fallisce"
+
+# Per usare && e || con l'if, c'è bisogno di piu' paia di parentesi quadre:
+if [ $NOME == "Steve" ] && [ $ETA -eq 15 ]
+then
+ echo "Questo verrà eseguito se $NOME è Steve E $ETA è 15."
+fi
+
+if [ $NOME == "Daniya" ] || [ $NOME == "Zach" ]
+then
+ echo "Questo verrà eseguito se $NAME è Daniya O Zach."
+fi
+
+# Le espressioni sono nel seguente formato:
+echo $(( 10 + 5 ))
+
+# A differenza di altri linguaggi di programmazione, bash è una shell - quindi lavora nel contesto
+# della cartella corrente. Puoi elencare i file e le cartelle nella cartella
+# corrente con il comando ls:
+ls
+
+# Questi comandi hanno opzioni che controllano la loro esecuzione:
+ls -l # Elenca tutti i file e le cartelle su una riga separata
+
+# I risultati del comando precedente possono essere passati al comando successivo come input.
+# Il comando grep filtra l'input con il pattern passato. Ecco come possiamo elencare i
+# file .txt nella cartella corrente:
+ls -l | grep "\.txt"
+
+# Puoi redirezionare l'input e l'output del comando (stdin, stdout, e stderr).
+# Leggi da stdin finchè ^EOF$ e sovrascrivi hello.py con le righe
+# comprese tra "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+ print(line, file=sys.stdout)
+EOF
+
+# Esegui hello.py con diverse redirezioni stdin, stdout, e stderr:
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Lo output error sovrascriverà il file se esiste,
+# se invece vuoi appendere usa ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Sovrascrivi output.txt, appendi a error.err, e conta le righe:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Esegui un comando e stampa il suo file descriptor (esempio: /dev/fd/123)
+# vedi: man fd
+echo <(echo "#ciaomondo")
+
+# Sovrascrivi output.txt con "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Pulisci i file temporanei verbosamente (aggiungi '-i' per la modalità interattiva)
+rm -v output.out error.err output-and-error.log
+
+# I comandi possono essere sostituiti con altri comandi usando $( ):
+# Il comando seguente mostra il numero di file e cartelle nella
+# cartella corrente.
+echo "Ci sono $(ls | wc -l) oggetti qui."
+
+# Lo stesso puo' essere usato usando backticks `` ma non possono essere innestati - il modo migliore
+# è usando $( ).
+echo "Ci sono `ls | wc -l` oggetti qui."
+
+# Bash utilizza uno statemente case che funziona in maniera simile allo switch in Java e C++:
+case "$VARIABILE" in
+ #Lista di pattern per le condizioni che vuoi soddisfare
+ 0) echo "C'è uno zero.";;
+ 1) echo "C'è un uno.";;
+ *) echo "Non è null.";;
+esac
+
+# I cicli for iterano per ogni argomento fornito:
+# I contenuti di $VARIABILE sono stampati tre volte.
+for VARIABILE in {1..3}
+do
+ echo "$VARIABILE"
+done
+
+# O scrivilo con il "ciclo for tradizionale":
+for ((a=1; a <= 3; a++))
+do
+ echo $a
+done
+
+# Possono essere usati anche per agire su file..
+# Questo eseguirà il comando 'cat' su file1 e file2
+for VARIABILE in file1 file2
+do
+ cat "$VARIABILE"
+done
+
+# ..o dall'output di un comando
+# Questo eseguirà cat sull'output di ls.
+for OUTPUT in $(ls)
+do
+ cat "$OUTPUT"
+done
+
+# while loop:
+while [ true ]
+do
+ echo "corpo del loop..."
+ break
+done
+
+# Puoi anche definire funzioni
+# Definizione:
+function foo ()
+{
+ echo "Gli argomenti funzionano come gli argomenti dello script: $@"
+ echo "E: $1 $2..."
+ echo "Questa è una funzione"
+ return 0
+}
+
+# o semplicemente
+bar ()
+{
+ echo "Un altro modo per dichiarare funzioni!"
+ return 0
+}
+
+# Per chiamare la funzione
+foo "Il mio nome è" $NOME
+
+# Ci sono un sacco di comandi utili che dovresti imparare:
+# stampa le ultime 10 righe di file.txt
+tail -n 10 file.txt
+# stampa le prime 10 righe di file.txt
+head -n 10 file.txt
+# ordina le righe di file.txt
+sort file.txt
+# riporta o ometti le righe ripetute, con -d le riporta
+uniq -d file.txt
+# stampa solamente la prima colonna prima del carattere ','
+cut -d ',' -f 1 file.txt
+# sostituisce ogni occorrenza di 'okay' con 'great' in file.txt (compatible con le regex)
+sed -i 's/okay/great/g' file.txt
+# stampa su stdout tutte le righe di file.txt che soddisfano una certa regex
+# L'esempio stampa le righe che iniziano con "foo" e che finiscono con "bar"
+grep "^foo.*bar$" file.txt
+# passa l'opzione "-c" per stampare invece il numero delle righe che soddisfano la regex
+grep -c "^foo.*bar$" file.txt
+# se vuoi letteralmente cercare la stringa,
+# e non la regex, usa fgrep (o grep -F)
+fgrep "^foo.*bar$" file.txt
+
+
+# Leggi la documentazione dei builtin di bash con il builtin 'help' di bash:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Leggi la manpage di bash con man
+apropos bash
+man 1 bash
+man bash
+
+# Leggi la documentazione con info (? per help)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Leggi la documentazione di bash:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
new file mode 100644
index 00000000..4f5ac8a2
--- /dev/null
+++ b/it-it/c++-it.html.markdown
@@ -0,0 +1,720 @@
+---
+language: c++
+filename: learncpp.cpp
+contributors:
+ - ["Steven Basart", "http://github.com/xksteven"]
+ - ["Matt Kline", "https://github.com/mrkline"]
+translators:
+ - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+---
+
+Il C++ è un linguaggio di programmazione il quale,
+[secondo il suo inventore Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+è stato progettato per
+
+- essere un "miglior C"
+- supportare l'astrazione dei dati
+- supportare la programmazione orientata agli oggetti
+- supportare la programmazione generica
+
+Nonostante la sintassi possa risultare più difficile o complessa di linguaggi più recenti,
+è usato in maniera vasta poichè viene compilato in istruzioni macchina che possono
+essere eseguite direttamente dal processore ed offre un controllo stretto sull'hardware (come il linguaggio C)
+ed allo stesso tempo offre caratteristiche ad alto livello come i generici, le eccezioni, e le classi.
+Questa combinazione di velocità e funzionalità rende il C++
+uno dei più utilizzati linguaggi di programmazione.
+
+```c++
+//////////////////
+// Confronto con il C
+//////////////////
+
+// Il C++ è _quasi_ un superset del C e con esso condivide la sintassi di base per
+// la dichiarazione di variabili, tipi primitivi, e funzioni.
+
+// Proprio come nel C, l'inizio del programma è una funzione chiamata
+// main con un intero come tipo di ritorno,
+// Questo valore serve come stato d'uscita del programma.
+// Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni.
+int main(int argc, char** argv)
+{
+ // Gli argomenti a linea di comando sono passati tramite argc e argv così come
+ // avviene in C.
+ // argc indica il numero di argomenti,
+ // e argv è un array di stringhe in stile-C (char*)
+ // che rappresenta gli argomenti.
+ // Il primo argomento è il nome che è stato assegnato al programma.
+ // argc e argv possono essere omessi se non hai bisogno di argomenti,
+ // in questa maniera la funzione avrà int main() come firma.
+
+ // Lo stato di uscita 0 indica successo.
+ return 0;
+}
+
+// Tuttavia, il C++ varia nei seguenti modi:
+
+// In C++, i caratteri come letterali sono da un byte.
+sizeof('c') == 1
+
+// In C, i caratteri come letterali sono della stessa dimensione degli interi.
+sizeof('c') == sizeof(10)
+
+
+// C++ ha prototipizzazione rigida
+void func(); // funziona che non accetta argomenti
+
+// In C
+void func(); // funzione che può accettare un qualsiasi numero di argomenti
+
+// Usa nullptr invece di NULL in C++
+int* ip = nullptr;
+
+// Gli header C standard sono disponibili in C++,
+// ma sono prefissati con "c" e non hanno il suffisso ".h".
+#include <cstdio>
+
+int main()
+{
+ printf("Ciao, mondo!\n");
+ return 0;
+}
+
+///////////////////////////////
+// Overloading per le funzioni
+//////////////////////////////
+
+// Il C++ supporta l'overloading per le funzioni
+// sia dato che ogni funzione accetta parametri diversi.
+
+void print(char const* myString)
+{
+ printf("Stringa %s\n", myString);
+}
+
+void print(int myInt)
+{
+ printf("Il mio int è %d", myInt);
+}
+
+int main()
+{
+ print("Ciao"); // Viene chiamata void print(const char*)
+ print(15); // Viene chiamata void print(int)
+}
+
+////////////////////////
+// Argomenti di default
+///////////////////////
+
+// Puoi fornire argomenti di default per una funzione
+// se non sono forniti dal chiamante.
+
+void faiQualcosaConInteri(int a = 1, int b = 4)
+{
+ // fai qualcosa con gli interi qui
+}
+
+int main()
+{
+ faiQualcosaConInteri(); // a = 1, b = 4
+ faiQualcosaConInteri(20); // a = 20, b = 4
+ faiQualcosaConInteri(20, 5); // a = 20, b = 5
+}
+
+// Gli argomenti di default devono essere alla fine della lista degli argomenti.
+
+void dichiarazioneInvalida(int a = 1, int b) // Errore!
+{
+}
+
+
+/////////////
+// Namespaces
+/////////////
+
+// I namespaces forniscono visibilità separata per dichiarazioni di variabili, funzioni,
+// ed altro.
+// I namespaces possono essere annidati.
+
+namespace Primo {
+ namespace Annidato {
+ void foo()
+ {
+ printf("Questa è Primo::Annidato::foo\n");
+ }
+ } // fine di namespace Annidato
+} // fine di namespace Primo
+
+namespace Secondo {
+ void foo()
+ {
+ printf("Questa è Secondo::foo\n")
+ }
+}
+
+void foo()
+{
+ printf("Questa è foo globale\n");
+}
+
+int main()
+{
+ // Assume che tutto venga dal namespace "Secondo"
+ // a meno che non venga dichiarato altrimenti.
+ using namespace Secondo;
+
+ foo(); // stampa "Questa è Secondo::foo"
+ Primo::Annidato::foo(); // stampa "Questa è Primo::Annidato::foo"
+ ::foo(); // stampa "Questa è foo globale"
+}
+
+///////////////
+// Input/Output
+///////////////
+
+// L'input e l'output in C++ utilizza gli streams
+// cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr.
+// << è l'operatore di inserzione >> è l'operatore di estrazione.
+
+#include <iostream> // Include gli streams di I/O
+
+using namespace std; // Gli streams sono nel namespace std (libreria standard)
+
+int main()
+{
+ int myInt;
+
+ // Stampa su stdout (o terminalee/schermo)
+ cout << "Inserisci il tuo numero preferito:\n";
+ // Prende l'input
+ cin >> myInt;
+
+ // cout può anche essere formattato
+ cout << "Il tuo numero preferito è " << myInt << "\n";
+ // stampa "Il tuo numero preferito è <myInt>"
+
+ cerr << "Usato per messaggi di errore";
+}
+
+////////////
+// Stringhe
+///////////
+
+// Le stringhe in C++ sono oggetti ed hanno molte funzioni membro
+#include <string>
+
+using namespace std; // Anche le stringhe sono contenute nel namespace std (libreria standard)
+
+string myString = "Ciao";
+string myOtherString = " Mondo";
+
+// + è usato per la concatenazione.
+cout << myString + myOtherString; // "Ciao Mondo"
+
+cout << myString + " Bella"; // "Ciao Bella"
+
+// le stringhe in C++ possono essere modificate.
+myString.append(" Mario");
+cout << myString; // "Ciao Mario"
+
+
+///////////////
+// Riferimenti
+//////////////
+
+// Oltre ai puntatori come quelli in C,
+// il C++ ha i _riferimenti_.
+// Questi non sono tipi puntatori che non possono essere riassegnati una volta settati
+// e non possono essere null.
+// Inoltre, essi hanno la stessa sintassi della variabile stessa:
+// * non è necessario per la dereferenziazione e
+// & ("indirizzo di") non è usato per l'assegnamento.
+
+using namespace std;
+
+string foo = "Io sono foo";
+string bar = "Io sono bar";
+
+
+string& fooRef = foo; // Questo crea un riferimento a foo.
+fooRef += ". Ciao!"; // Modifica foo attraverso il riferimento
+cout << fooRef; // Stampa "Io sono foo. Ciao!"
+
+// Non riassegna "fooRef". Questo è come scrivere "foo = bar", e
+// foo == "Io sono bar"
+// dopo questa riga.
+fooRef = bar;
+
+const string& barRef = bar; // Crea un riferimento const a bar.
+// Come in C, i valori const (i puntatori e i riferimenti) non possono essere modificati.
+barRef += ". Ciao!"; // Errore, i riferimenti const non possono essere modificati.
+
+//////////////////////////////////////////////////
+// Classi e programmazione orientata agli oggetti
+/////////////////////////////////////////////////
+
+// Primo esempio delle classi
+#include <iostream>
+
+// Dichiara una classe.
+// Le classi sono in genere dichiara in un header file (.h o .hpp).
+class Cane {
+ // Variabili e funzioni membro sono private di default.
+ std::string nome;
+ int peso;
+
+// Tutti i membri dopo questo sono pubblici (public)
+// finchè "private:" o "protected:" non compaiono.
+public:
+
+ // Costruttore di default
+ Cane();
+
+ // Dichiarazioni di funzioni membro (le implentazioni sono a seguito)
+ // Nota che stiamo usando std::string invece di porre
+ // using namespace std;
+ // sopra.
+ // Mai usare uno statement "using namespace" in uno header.
+ void impostaNome(const std::string& nomeCane);
+
+ void impostaPeso(int pesoCane);
+
+ // Le funzioni che non modificano lo stato dell'oggetto
+ // dovrebbero essere marcate come const.
+ // Questo permette di chiamarle con un riferimento const all'oggetto.
+ // Inoltre, nota che le funzioni devono essere dichiarate espliciamente come _virtual_
+ // per essere sovrascritte in classi derivate.
+ // Le funzioni non sono virtual di default per motivi di performance.
+ virtual void print() const;
+
+ // Le funzioni possono essere definite anche all'interno del corpo della classe.
+ // Le funzioni definite in questo modo sono automaticamente inline.
+ void abbaia() const { std::cout << nome << " abbaia!\n"; }
+
+ // Assieme con i costruttori, il C++ fornisce i distruttori.
+ // Questi sono chiamati quando un oggetto è rimosso o esce dalla visibilità.
+ // Questo permette paradigmi potenti come il RAII
+ // (vedi sotto)
+ // I distruttori devono essere virtual per permettere a classi di essere derivate da questa.
+ virtual ~Dog();
+
+}; // Un punto e virgola deve seguire la definizione della funzione
+
+// Le funzioni membro di una classe sono generalmente implementate in files .cpp .
+void Cane::Cane()
+{
+ std::cout << "Un cane è stato costruito\n";
+}
+
+// Gli oggetti (ad esempio le stringhe) devono essere passati per riferimento
+// se li stai modificando o come riferimento const altrimenti.
+void Cane::impostaNome(const std::string& nomeCane)
+{
+ nome = nomeCane;
+}
+
+void Cane::impostaPeso(int pesoCane)
+{
+ peso = pesoCane;
+}
+
+// Notare che "virtual" è solamente necessario nelle dichiarazioni, non nelle definizioni.
+void Cane::print() const
+{
+ std::cout << "Il cane è " << nome << " e pesa " << peso << "kg\n";
+}
+
+void Cane::~Cane()
+{
+ cout << "Ciao ciao " << nome << "\n";
+}
+
+int main() {
+ Cane myDog; // stampa "Un cane è stato costruito"
+ myDog.impostaNome("Barkley");
+ myDog.impostaPeso(10);
+ myDog.print(); // stampa "Il cane è Barkley e pesa 10 kg"
+ return 0;
+} // stampa "Ciao ciao Barkley"
+
+// Ereditarietà:
+
+// Questa classe eredita tutto ciò che è public e protected dalla classe Cane
+class MioCane : public Cane {
+
+ void impostaProprietario(const std::string& proprietarioCane)
+
+ // Sovrascrivi il comportamento della funzione print per tutti i MioCane. Vedi
+ // http://it.wikipedia.org/wiki/Polimorfismo_%28informatica%29
+ // per una introduzione più generale se non sei familiare con
+ // il polimorfismo.
+ // La parola chiave override è opzionale ma fa sì che tu stia effettivamente
+ // sovrascrivendo il metodo nella classe base.
+ void print() const override;
+
+private:
+ std::string proprietario;
+};
+
+// Nel frattempo, nel file .cpp corrispondente:
+
+void MioCane::impostaProprietario(const std::string& proprietarioCane)
+{
+ proprietario = proprietarioCane;
+}
+
+void MioCane::print() const
+{
+ Cane::print(); // Chiama la funzione print nella classe base Cane
+ std::cout << "Il cane è di " << proprietario << "\n";
+ // stampa "Il cane è <nome> e pesa <peso>"
+ // "Il cane è di <proprietario>"
+}
+
+///////////////////////////////////////////////////
+// Inizializzazione ed Overloading degli Operatori
+//////////////////////////////////////////////////
+
+// In C++ puoi sovrascrivere il comportamento di operatori come +, -, *, /, ecc...
+// Questo è possibile definendo una funzione che viene chiamata
+// ogniqualvolta l'operatore è usato.
+
+#include <iostream>
+using namespace std;
+
+class Punto {
+public:
+ // Così si assegna alle variabili membro un valore di default.
+ double x = 0;
+ double y = 0;
+
+ // Definisce un costruttore di default che non fa nulla
+ // ma inizializza il Punto ai valori di default (0, 0)
+ Punto() { };
+
+ // La sintassi seguente è nota come lista di inizializzazione
+ // ed è il modo appropriato di inizializzare i valori membro della classe
+ Punto (double a, double b) :
+ x(a),
+ y(b)
+ { /* Non fa nulla eccetto inizializzare i valori */ }
+
+ // Sovrascrivi l'operatore +.
+ Punto operator+(const Punto& rhs) const;
+
+ // Sovrascrivi l'operatore +=
+ Punto& operator+=(const Punto& rhs);
+
+ // Avrebbe senso aggiungere gli operatori - e -=,
+ // ma li saltiamo per rendere la guida più breve.
+};
+
+Punto Punto::operator+(const Punto& rhs) const
+{
+ // Crea un nuovo punto come somma di questo e di rhs.
+ return Punto(x + rhs.x, y + rhs.y);
+}
+
+Punto& Punto::operator+=(const Punto& rhs)
+{
+ x += rhs.x;
+ y += rhs.y;
+ return *this;
+}
+
+int main () {
+ Punto su (0,1);
+ Punto destro (1,0);
+ // Questo chiama l'operatore + di Punto
+ // Il Punto su chiama la funzione + con destro come argomento
+ Punto risultato = su + destro;
+ // Stampa "Risultato è spostato in (1,1)"
+ cout << "Risultato è spostato (" << risultato.x << ',' << risultato.y << ")\n";
+ return 0;
+}
+
+/////////////////
+// Templates
+////////////////
+
+// Generalmente i templates in C++ sono utilizzati per programmazione generica, anche se
+// sono molto più potenti dei costrutti generici in altri linguaggi. Inoltre,
+// supportano specializzazione esplicita e parziale, classi in stile funzionale,
+// e sono anche complete per Turing.
+
+// Iniziamo con il tipo di programmazione generica con cui forse sei familiare. Per
+// definire una classe o una funzione che prende un parametro di un dato tipo:
+template<class T>
+class Box {
+ // In questa classe, T può essere usato come qualsiasi tipo.
+ void inserisci(const T&) { ... }
+};
+
+// Durante la compilazione, il compilatore in effetti genera copie di ogni template
+// con i parametri sostituiti, e così la definizione completa della classe deve essere
+// presente ad ogni invocazione. Questo è il motivo per cui vedrai le classi template definite
+// interamente in header files.
+
+// Per instanziare una classe template sullo stack:
+Box<int> intBox;
+
+// e puoi usarla come aspettato:
+intBox.inserisci(123);
+
+//Puoi, ovviamente, innestare i templates:
+Box<Box<int> > boxOfBox;
+boxOfBox.inserisci(intBox);
+
+// Fino al C++11, devi porre uno spazio tra le due '>', altrimenti '>>'
+// viene visto come l'operatore di shift destro.
+
+// Qualche volta vedrai
+// template<typename T>
+// invece. La parole chiavi 'class' e 'typename' sono _generalmente_
+// intercambiabili in questo caso. Per una spiegazione completa, vedi
+// http://en.wikipedia.org/wiki/Typename
+// (si, quella parola chiave ha una sua pagina di Wikipedia propria).
+
+// Similmente, una funzione template:
+template<class T>
+void abbaiaTreVolte(const T& input)
+{
+ input.abbaia();
+ input.abbaia();
+ input.abbaia();
+}
+
+// Nota che niente è specificato relativamente al tipo di parametri. Il compilatore
+// genererà e poi verificherà il tipo di ogni invocazione del template, così che
+// la funzione di cui sopra funzione con ogni tipo 'T' che ha const 'abbaia' come metodo!
+
+Cane fluffy;
+fluffy.impostaNome("Fluffy")
+abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia" tre volte.
+
+// I parametri template non devono essere classi:
+template<int Y>
+void stampaMessaggio() {
+ cout << "Impara il C++ in " << Y << " minuti!" << endl;
+}
+
+// E poi esplicitamente specializzare i template per avere codice più efficiente. Ovviamente,
+// la maggior parte delle casistiche reali non sono così triviali.
+// Notare che avrai comunque bisogna di dichiarare la funzione (o classe) come un template
+// anche se hai esplicitamente specificato tutti i parametri.
+template<>
+void stampaMessaggio<10>() {
+ cout << "Impara il C++ più velocemente in soli 10 minuti!" << endl;
+}
+
+printMessage<20>(); // Stampa "impara il C++ in 20 minuti!"
+printMessage<10>(); // Stampa "Impara il C++ più velocemente in soli 10 minuti!"
+
+////////////////////////////
+// Gestione delle eccezioni
+///////////////////////////
+
+// La libreria standard fornisce un paio di tipi d'eccezioni
+// (vedi http://en.cppreference.com/w/cpp/error/exception)
+// ma ogni tipo può essere lanciato come eccezione
+#include <exception>
+
+// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi
+// handlers _catch_.
+try {
+ // Non allocare eccezioni nello heap usando _new_.
+ throw std::exception("È avvenuto un problema");
+}
+// Cattura le eccezioni come riferimenti const se sono oggetti
+catch (const std::exception& ex)
+{
+ std::cout << ex.what();
+// Cattura ogni eccezioni non catturata dal blocco _catch_ precedente
+} catch (...)
+{
+ std::cout << "Catturata un'eccezione sconosciuta";
+ throw; // Rilancia l'eccezione
+}
+
+///////
+// RAII
+///////
+
+// RAII sta per Resource Allocation Is Initialization.
+// Spesso viene considerato come il più potente paradigma in C++.
+// È un concetto semplice: un costruttore di un oggetto
+// acquisisce le risorse di tale oggetto ed il distruttore le rilascia.
+
+// Per comprendere come questo sia vantaggioso,
+// consideriamo una funzione che usa un gestore di file in C:
+void faiQualcosaConUnFile(const char* nomefile)
+{
+ // Per cominciare, assumiamo che niente possa fallire.
+
+ FILE* fh = fopen(nomefile, "r"); // Apri il file in modalità lettura.
+
+ faiQualcosaConIlFile(fh);
+ faiQualcosAltroConEsso(fh);
+
+ fclose(fh); // Chiudi il gestore di file.
+}
+
+// Sfortunatamente, le cose vengono complicate dalla gestione degli errori.
+// Supponiamo che fopen fallisca, e che faiQualcosaConUnFile e
+// faiQualcosAltroConEsso ritornano codici d'errore se falliscono.
+// (Le eccezioni sono la maniera preferita per gestire i fallimenti,
+// ma alcuni programmatori, specialmente quelli con un passato in C,
+// non sono d'accordo con l'utilità delle eccezioni).
+// Adesso dobbiamo verificare che ogni chiamata per eventuali fallimenti e chiudere il gestore di file
+// se un problema è avvenuto.
+bool faiQualcosaConUnFile(const char* nomefile)
+{
+ FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
+ if (fh == nullptr) // Il puntatore restituito è null in caso di fallimento.
+ return false; // Riporta il fallimento al chiamante.
+
+ // Assumiamo che ogni funzione ritorni false se ha fallito
+ if (!faiQualcosaConIlFile(fh)) {
+ fclose(fh); // Chiude il gestore di file così che non sprechi memoria.
+ return false; // Propaga l'errore.
+ }
+ if (!faiQualcosAltroConEsso(fh)) {
+ fclose(fh); // Chiude il gestore di file così che non sprechi memoria.
+ return false; // Propaga l'errore.
+ }
+
+ fclose(fh); // Chiudi il gestore di file così che non sprechi memoria.
+ return true; // Indica successo
+}
+
+// I programmatori C in genere puliscono questa procedura usando goto:
+bool faiQualcosaConUnFile(const char* nomefile)
+{
+ FILE* fh = fopen(nomefile, "r");
+ if (fh == nullptr)
+ return false;
+
+ if (!faiQualcosaConIlFile(fh))
+ goto fallimento;
+
+ if (!faiQualcosAltroConEsso(fh))
+ goto fallimento;
+
+ fclose(fh); // Chiude il file
+ return true; // Indica successo
+
+fallimento:
+ fclose(fh);
+ return false; // Propaga l'errore
+}
+
+// Se le funzioni indicano errori usando le eccezioni,
+// le cose sono un pò più pulite, ma sono sempre sub-ottimali.
+void faiQualcosaConUnFile(const char* nomefile)
+{
+ FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
+ if (fh == nullptr)
+ throw std::exception("Non è stato possibile aprire il file.").
+
+ try {
+ faiQualcosaConIlFile(fh);
+ faiQualcosAltroConEsso(fh);
+ }
+ catch (...) {
+ fclose(fh); // Fai sì che il file venga chiuso se si ha un errore.
+ throw; // Poi rilancia l'eccezione.
+ }
+
+ fclose(fh); // Chiudi il file
+ // Tutto è andato bene
+}
+
+// Confronta questo con l'utilizzo della classe C++ file stream (fstream)
+// fstream usa i distruttori per chiudere il file.
+// Come detto sopra, i distruttori sono automaticamente chiamati
+// ogniqualvolta un oggetto esce dalla visibilità.
+void faiQualcosaConUnFile(const std::string& nomefile)
+{
+ // ifstream è l'abbreviazione di input file stream
+ std::ifstream fh(nomefile); // Apre il file
+
+ // Fai qualcosa con il file
+ faiQualcosaConIlFile(fh);
+ faiQualcosAltroConEsso(fh);
+
+} // Il file viene chiuso automaticamente chiuso qui dal distruttore
+
+// Questo ha vantaggi _enormi_:
+// 1. Può succedere di tutto ma
+// la risorsa (in questo caso il file handler) verrà ripulito.
+// Una volta che scrivi il distruttore correttamente,
+// È _impossibile_ scordarsi di chiudere l'handler e sprecare memoria.
+// 2. Nota che il codice è molto più pulito.
+// Il distruttore gestisce la chiusura del file dietro le scene
+// senza che tu debba preoccupartene.
+// 3. Il codice è sicuro da eccezioni.
+// Una eccezione può essere lanciata in qualunque punto nella funzione e la ripulitura
+// avverrà lo stesso.
+
+// Tutto il codice C++ idiomatico usa RAII in maniera vasta su tutte le risorse.
+// Esempi aggiuntivi includono
+// - Utilizzo della memoria con unique_ptr e shared_ptr
+// - I contenitori - la lista della libreria standard,
+// vettori (i.e. array auto-aggiustati), mappe hash, e così via
+// sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità.
+// - I mutex usano lock_guard e unique_lock
+
+///////////////////////
+// Roba divertente
+//////////////////////
+
+// Aspetti del C++ che potrebbero sbalordire i nuovi arrivati (e anche qualche veterano).
+// Questa sezione è, sfortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi
+// più facili con cui puoi spararti da solo nel piede.
+
+// Puoi sovrascrivere metodi privati!
+class Foo {
+ virtual void bar();
+};
+class FooSub : public Foo {
+ virtual void bar(); // sovrascrive Foo::bar!
+};
+
+
+// 0 == false == NULL (la maggior parte delle volte)!
+bool* pt = new bool;
+*pt = 0; // Setta il valore puntato da 'pt' come falso.
+pt = 0; // Setta 'pt' al puntatore null. Entrambe le righe vengono compilate senza warnings.
+
+// nullptr dovrebbe risolvere alcune di quei problemi:
+int* pt2 = new int;
+*pt2 = nullptr; // Non compila
+pt2 = nullptr; // Setta pt2 a null.
+
+// Ma in qualche modo il tipo 'bool' è una eccezione (questo è per rendere compilabile `if (ptr)`.
+*pt = nullptr; // Questo compila, anche se '*pt' è un bool!
+
+
+// '=' != '=' != '='!
+// Chiama Foo::Foo(const Foo&) o qualche variante del costruttore di copia.
+Foo f2;
+Foo f1 = f2;
+
+// Chiama Foo::Foo(const Foo&) o qualche variante, ma solo copie di 'Foo' che fanno parte di
+// 'fooSub'. Ogni altro membro di 'fooSub' viene scartato. Questo comportamento
+// orribile viene chiamato "object slicing."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Chiama Foo::operator=(Foo&) o una sua variante.
+Foo f1;
+f1 = f2;
+
+```
+Letture consigliate:
+
+Un riferimento aggiornato del linguaggio può essere trovato qui
+<http://cppreference.com/w/cpp>
+
+Risorse addizionali possono essere trovate qui <http://cplusplus.com>
diff --git a/java.html.markdown b/java.html.markdown
index 10dd498c..928eb39f 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -1,16 +1,16 @@
---
-
language: java
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
- - ["Madison Dickson", "http://github.com/mix3d"]
- ["Jakukyo Friel", "http://weakish.github.io"]
+ - ["Madison Dickson", "http://github.com/mix3d"]
+ - ["Simon Morgan", "http://sjm.io/"]
filename: LearnJava.java
-
---
-Java is a general-purpose, concurrent, class-based, object-oriented computer programming language.
-[Read more here.](http://docs.oracle.com/javase/tutorial/java/index.html)
+Java is a general-purpose, concurrent, class-based, object-oriented computer
+programming language.
+[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
```java
// Single-line comments start with //
@@ -31,17 +31,17 @@ import java.security.*;
// the file.
public class LearnJava {
- // A program must have a main method as an entry point
+ // A program must have a main method as an entry point.
public static void main (String[] args) {
- // Use System.out.println to print lines
+ // Use System.out.println() to print lines.
System.out.println("Hello World!");
System.out.println(
"Integer: " + 10 +
" Double: " + 3.14 +
" Boolean: " + true);
- // To print without a newline, use System.out.print
+ // To print without a newline, use System.out.print().
System.out.print("Hello ");
System.out.print("World");
@@ -69,7 +69,7 @@ public class LearnJava {
// L is used to denote that this variable value is of type Long;
// anything without is treated as integer by default.
- // Note: Java has no unsigned types
+ // Note: Java has no unsigned types.
// Float - Single-precision 32-bit IEEE 754 Floating Point
float fooFloat = 234.5f;
@@ -86,7 +86,7 @@ public class LearnJava {
// Char - A single 16-bit Unicode character
char fooChar = 'A';
- // final variables can't be reassigned to another object
+ // final variables can't be reassigned to another object.
final int HOURS_I_WORK_PER_WEEK = 9001;
// Strings
@@ -101,10 +101,10 @@ public class LearnJava {
System.out.println(bazString);
// Arrays
- //The array size must be decided upon instantiation
- //The following formats work for declaring an array
- //<datatype>[] <var name> = new <datatype>[<array size>];
- //<datatype> <var name>[] = new <datatype>[<array size>];
+ // The array size must be decided upon instantiation
+ // The following formats work for declaring an array
+ // <datatype>[] <var name> = new <datatype>[<array size>];
+ // <datatype> <var name>[] = new <datatype>[<array size>];
int[] intArray = new int[10];
String[] stringArray = new String[1];
boolean boolArray[] = new boolean[100];
@@ -122,17 +122,17 @@ public class LearnJava {
System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Others to check out
- // ArrayLists - Like arrays except more functionality is offered,
- // and the size is mutable
+ // ArrayLists - Like arrays except more functionality is offered, and
+ // the size is mutable.
// LinkedLists - Implementation of doubly-linked list. All of the
- // operations perform as could be expected for
- // a doubly-linked list.
- // Maps - A set of objects that maps keys to values. A map cannot contain
- // duplicate keys; each key can map to at most one value.
- // HashMaps - This class uses a hashtable to implement the Map interface.
- // This allows the execution time of basic operations,
- // such as get and insert element, to remain constant even
- // for large sets.
+ // operations perform as could be expected for a
+ // doubly-linked list.
+ // Maps - A set of objects that maps keys to values. A map cannot
+ // contain duplicate keys; each key can map to at most one value.
+ // HashMaps - This class uses a hashtable to implement the Map
+ // interface. This allows the execution time of basic
+ // operations, such as get and insert element, to remain
+ // constant even for large sets.
///////////////////////////////////////
// Operators
@@ -160,13 +160,13 @@ public class LearnJava {
// Bitwise operators!
/*
- ~ Unary bitwise complement
- << Signed left shift
- >> Signed right shift
- >>> Unsigned right shift
- & Bitwise AND
- ^ Bitwise exclusive OR
- | Bitwise inclusive OR
+ ~ Unary bitwise complement
+ << Signed left shift
+ >> Signed right shift
+ >>> Unsigned right shift
+ & Bitwise AND
+ ^ Bitwise exclusive OR
+ | Bitwise inclusive OR
*/
// Incrementations
@@ -175,10 +175,10 @@ public class LearnJava {
// The ++ and -- operators increment and decrement by 1 respectively.
// If they are placed before the variable, they increment then return;
// after the variable they return then increment.
- System.out.println(i++); //i = 1, prints 0 (post-increment)
- System.out.println(++i); //i = 2, prints 2 (pre-increment)
- System.out.println(i--); //i = 1, prints 2 (post-decrement)
- System.out.println(--i); //i = 0, prints 0 (pre-decrement)
+ System.out.println(i++); // i = 1, prints 0 (post-increment)
+ System.out.println(++i); // i = 2, prints 2 (pre-increment)
+ System.out.println(i--); // i = 1, prints 2 (post-decrement)
+ System.out.println(--i); // i = 0, prints 0 (pre-decrement)
///////////////////////////////////////
// Control Structures
@@ -197,73 +197,69 @@ public class LearnJava {
// While loop
int fooWhile = 0;
- while(fooWhile < 100)
- {
- //System.out.println(fooWhile);
- //Increment the counter
- //Iterated 100 times, fooWhile 0,1,2...99
+ while(fooWhile < 100) {
+ System.out.println(fooWhile);
+ // Increment the counter
+ // Iterated 100 times, fooWhile 0,1,2...99
fooWhile++;
}
System.out.println("fooWhile Value: " + fooWhile);
// Do While Loop
int fooDoWhile = 0;
- do
- {
- //System.out.println(fooDoWhile);
- //Increment the counter
- //Iterated 99 times, fooDoWhile 0->99
+ do {
+ System.out.println(fooDoWhile);
+ // Increment the counter
+ // Iterated 99 times, fooDoWhile 0->99
fooDoWhile++;
- }while(fooDoWhile < 100);
+ } while(fooDoWhile < 100);
System.out.println("fooDoWhile Value: " + fooDoWhile);
// For Loop
int fooFor;
- //for loop structure => for(<start_statement>; <conditional>; <step>)
- for(fooFor=0; fooFor<10; fooFor++){
- //System.out.println(fooFor);
- //Iterated 10 times, fooFor 0->9
+ // for loop structure => for(<start_statement>; <conditional>; <step>)
+ for (fooFor = 0; fooFor < 10; fooFor++) {
+ System.out.println(fooFor);
+ // Iterated 10 times, fooFor 0->9
}
System.out.println("fooFor Value: " + fooFor);
// For Each Loop
- // An automatic iteration through an array or list of objects.
- int[] fooList = {1,2,3,4,5,6,7,8,9};
- //for each loop structure => for(<object> : <array_object>)
- //reads as: for each object in the array
- //note: the object type must match the array.
-
- for( int bar : fooList ){
- //System.out.println(bar);
+ // The for loop is also able to iterate over arrays as well as objects
+ // that implement the Iterable interface.
+ int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ // for each loop structure => for (<object> : <iterable>)
+ // reads as: for each element in the iterable
+ // note: the object type must match the element type of the iterable.
+
+ for (int bar : fooList) {
+ System.out.println(bar);
//Iterates 9 times and prints 1-9 on new lines
}
// Switch Case
// A switch works with the byte, short, char, and int data types.
- // It also works with enumerated types (discussed in Enum Types),
- // the String class, and a few special classes that wrap
- // primitive types: Character, Byte, Short, and Integer.
+ // It also works with enumerated types (discussed in Enum Types), the
+ // String class, and a few special classes that wrap primitive types:
+ // Character, Byte, Short, and Integer.
int month = 3;
String monthString;
- switch (month){
- case 1:
- monthString = "January";
- break;
- case 2:
- monthString = "February";
+ switch (month) {
+ case 1: monthString = "January";
break;
- case 3:
- monthString = "March";
+ case 2: monthString = "February";
break;
- default:
- monthString = "Some other month";
+ case 3: monthString = "March";
break;
+ default: monthString = "Some other month";
+ break;
}
System.out.println("Switch Case Result: " + monthString);
// Conditional Shorthand
// You can use the '?' operator for quick assignments or logic forks.
- // Reads as "If (statement) is true, use <first value>, otherwise, use <second value>"
+ // Reads as "If (statement) is true, use <first value>, otherwise, use
+ // <second value>"
int foo = 5;
String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Prints A, because the statement is true
@@ -287,9 +283,8 @@ public class LearnJava {
// String
// Typecasting
- // You can also cast java objects, there's a lot of details and
- // deals with some more intermediate concepts.
- // Feel free to check it out here:
+ // You can also cast Java objects, there's a lot of details and deals
+ // with some more intermediate concepts. Feel free to check it out here:
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
@@ -319,9 +314,9 @@ public class LearnJava {
// Class Declaration Syntax:
-// <public/private/protected> class <class name>{
-// //data fields, constructors, functions all inside.
-// //functions are called as methods in Java.
+// <public/private/protected> class <class name> {
+// // data fields, constructors, functions all inside.
+// // functions are called as methods in Java.
// }
class Bicycle {
@@ -342,7 +337,8 @@ class Bicycle {
}
// This is a constructor that takes arguments
- public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ String name) {
this.gear = startGear;
this.cadence = startCadence;
this.speed = startSpeed;
@@ -388,10 +384,8 @@ class Bicycle {
//Method to display the attribute values of this Object.
@Override
public String toString() {
- return "gear: " + gear +
- " cadence: " + cadence +
- " speed: " + speed +
- " name: " + name;
+ return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+ " name: " + name;
}
} // end class Bicycle
@@ -405,26 +399,26 @@ class PennyFarthing extends Bicycle {
super(startCadence, startSpeed, 0, "PennyFarthing");
}
- // You should mark a method you're overriding with an @annotation
- // To learn more about what annotations are and their purpose
- // check this out: http://docs.oracle.com/javase/tutorial/java/annotations/
+ // You should mark a method you're overriding with an @annotation.
+ // To learn more about what annotations are and their purpose check this
+ // out: http://docs.oracle.com/javase/tutorial/java/annotations/
@Override
public void setGear(int gear) {
gear = 0;
}
-
}
-//Interfaces
-//Interface declaration syntax
-//<access-level> interface <interface-name> extends <super-interfaces> {
-// //Constants
-// //Method declarations
-//}
+// Interfaces
+// Interface declaration syntax
+// <access-level> interface <interface-name> extends <super-interfaces> {
+// // Constants
+// // Method declarations
+// }
-//Example - Food:
+// Example - Food:
public interface Edible {
- public void eat(); //Any class that implements this interface, must implement this method
+ public void eat(); // Any class that implements this interface, must
+ // implement this method.
}
public interface Digestible {
@@ -432,33 +426,31 @@ public interface Digestible {
}
-//We can now create a class that implements both of these interfaces
+// We can now create a class that implements both of these interfaces.
public class Fruit implements Edible, Digestible {
@Override
public void eat() {
- //...
+ // ...
}
@Override
public void digest() {
- //...
+ // ...
}
}
-//In java, you can extend only one class, but you can implement many interfaces.
-//For example:
-public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
+// In Java, you can extend only one class, but you can implement many
+// interfaces. For example:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+ InterfaceTwo {
@Override
public void InterfaceOneMethod() {
-
}
@Override
public void InterfaceTwoMethod() {
-
}
}
-
```
## Further Reading
@@ -500,5 +492,3 @@ The links provided here below are just to get an understanding of the topic, fee
* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
-
-
diff --git a/json.html.markdown b/json.html.markdown
index f5287138..f57b82b8 100644
--- a/json.html.markdown
+++ b/json.html.markdown
@@ -10,7 +10,7 @@ As JSON is an extremely simple data-interchange format, this is most likely goin
to be the simplest Learn X in Y Minutes ever.
JSON in its purest form has no actual comments, but most parsers will accept
-C-style (//, /\* \*/) comments. For the purposes of this, however, everything is
+C-style (`//`, `/* */`) comments. For the purposes of this, however, everything is
going to be 100% valid JSON. Luckily, it kind of speaks for itself.
```json
diff --git a/julia.html.markdown b/julia.html.markdown
index 3a52018c..5ccd6484 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -8,7 +8,7 @@ filename: learnjulia.jl
Julia is a new homoiconic functional language focused on technical computing.
While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
-This is based on the current development version of Julia, as of October 18th, 2013.
+This is based on Julia 0.3.
```ruby
@@ -91,7 +91,7 @@ false
# $ can be used for string interpolation:
"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
-# You can put any Julia expression inside the parenthesis.
+# You can put any Julia expression inside the parentheses.
# Another way to format strings is the printf macro.
@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
@@ -190,7 +190,7 @@ end
# inside the julia folder to find these files.
# You can initialize arrays from ranges
-a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5]
# You can look at ranges with slice syntax.
a[1:3] # => [1, 2, 3]
@@ -264,7 +264,7 @@ in(("two", 3), filled_dict) # => false
haskey(filled_dict, "one") # => true
haskey(filled_dict, 1) # => false
-# Trying to look up a non-existant key will raise an error
+# Trying to look up a non-existent key will raise an error
try
filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
catch e
diff --git a/nim.html.markdown b/nim.html.markdown
index aa15e591..c9548a1c 100644
--- a/nim.html.markdown
+++ b/nim.html.markdown
@@ -155,7 +155,7 @@ var anotherArray = ["Default index", "starts at", "0"]
# More data structures are available, including tables, sets, lists, queues,
# and crit bit trees.
-# http://nimrod-lang.org/lib.html#collections-and-algorithms
+# http://nim-lang.org/docs/lib.html#collections-and-algorithms
#
# IO and Control Flow
@@ -174,7 +174,7 @@ else:
# `while`, `if`, `continue`, `break`
-import strutils as str # http://nimrod-lang.org/strutils.html
+import strutils as str # http://nim-lang.org/docs/strutils.html
echo "I'm thinking of a number between 41 and 43. Guess which!"
let number: int = 42
var
@@ -263,11 +263,11 @@ performance, and compile-time features.
## Further Reading
-* [Home Page](http://nimrod-lang.org)
-* [Download](http://nimrod-lang.org/download.html)
-* [Community](http://nimrod-lang.org/community.html)
-* [FAQ](http://nimrod-lang.org/question.html)
-* [Documentation](http://nimrod-lang.org/documentation.html)
-* [Manual](http://nimrod-lang.org/manual.html)
-* [Standard Library](http://nimrod-lang.org/lib.html)
-* [Rosetta Code](http://rosettacode.org/wiki/Category:Nimrod)
+* [Home Page](http://nim-lang.org)
+* [Download](http://nim-lang.org/download.html)
+* [Community](http://nim-lang.org/community.html)
+* [FAQ](http://nim-lang.org/question.html)
+* [Documentation](http://nim-lang.org/documentation.html)
+* [Manual](http://nim-lang.org/docs/manual.html)
+* [Standard Library](http://nim-lang.org/docs/lib.html)
+* [Rosetta Code](http://rosettacode.org/wiki/Category:Nim)
diff --git a/perl6.html.markdown b/perl6.html.markdown
index b2d7d48c..3bb87916 100644
--- a/perl6.html.markdown
+++ b/perl6.html.markdown
@@ -10,8 +10,7 @@ contributors:
Perl 6 is a highly capable, feature-rich programming language made for the
upcoming hundred years.
-Perl 6 runs on [the Parrot VM](http://parrot.org/), the JVM
-and [the MoarVM](http://moarvm.com).
+Perl 6 runs on [the MoarVM](http://moarvm.com) and the JVM.
Meta-note : the triple pound signs are here to denote headlines,
double paragraphs, and single notes.
@@ -211,7 +210,7 @@ say $x; #=> 52
# - `if`
# Before talking about `if`, we need to know which values are "Truthy"
# (represent True), and which are "Falsey" (or "Falsy") -- represent False.
-# Only these values are Falsey: (), 0, "0", "", Nil, A type (like `Str` or `Int`),
+# Only these values are Falsey: (), 0, "", Nil, A type (like `Str` or `Int`),
# and of course False itself.
# Every other value is Truthy.
if True {
diff --git a/php.html.markdown b/php.html.markdown
index 039288a0..2d4565e0 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -60,7 +60,7 @@ $float = 1.2e3;
$float = 7E-10;
// Delete variable
-unset($int1)
+unset($int1);
// Arithmetic
$sum = 1 + 1; // 2
diff --git a/python3.html.markdown b/python3.html.markdown
index 470eb6e4..a112912f 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -39,7 +39,7 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
# Except division which returns floats by default
35 / 5 # => 7.0
-# Result of integer division truncated down both for positive and negative.
+# Result of integer division truncated down both for positive and negative.
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # works on floats too
-5 // 3 # => -2
@@ -73,8 +73,8 @@ False or True #=> True
# Note using Bool operators with ints
0 and 2 #=> 0
-5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
+0 == False #=> True
+2 == True #=> False
1 == True #=> True
# Equality is ==
@@ -145,7 +145,7 @@ bool({}) #=> False
# Python has a print function
print("I'm Python. Nice to meet you!")
-# No need to declare variables before assigning to them.
+# No need to declare variables before assigning to them.
# Convention is to use lower_case_with_underscores
some_var = 5
some_var # => 5
@@ -186,7 +186,7 @@ li[2:] # => [4, 3]
li[:3] # => [1, 2, 4]
# Select every second entry
li[::2] # =>[1, 4]
-# Revert the list
+# Return a reversed copy of the list
li[::-1] # => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
# li[start:end:step]
@@ -196,7 +196,7 @@ del li[2] # li is now [1, 2, 3]
# You can add lists
# Note: values for li and for other_li are not modified.
-li + other_li # => [1, 2, 3, 4, 5, 6]
+li + other_li # => [1, 2, 3, 4, 5, 6]
# Concatenate lists with "extend()"
li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
@@ -213,7 +213,7 @@ tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # Raises a TypeError
-# You can do all those list thingies on tuples too
+# You can do most of the list operations on tuples too
len(tup) # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
tup[:2] # => (1, 2)
@@ -235,15 +235,15 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
# Look up values with []
filled_dict["one"] # => 1
-# Get all keys as a list with "keys()".
-# We need to wrap the call in list() because we are getting back an iterable. We'll talk about those later.
-# Note - Dictionary key ordering is not guaranteed.
-# Your results might not match this exactly.
+# Get all keys as an iterable with "keys()". We need to wrap the call in list()
+# to turn it into a list. We'll talk about those later. Note - Dictionary key
+# ordering is not guaranteed. Your results might not match this exactly.
list(filled_dict.keys()) # => ["three", "two", "one"]
-# Get all values as a list with "values()". Once again we need to wrap it in list() to get it out of the iterable.
-# Note - Same as above regarding key ordering.
+# Get all values as an iterable with "values()". Once again we need to wrap it
+# in list() to get it out of the iterable. Note - Same as above regarding key
+# ordering.
list(filled_dict.values()) # => [3, 2, 1]
@@ -281,7 +281,7 @@ some_set = {1, 1, 2, 2, 3, 4} # some_set is now {1, 2, 3, 4}
# Can set new variables to a set
filled_set = some_set
-# Add one more item to the set
+# Add one more item to the set
filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}
# Do set intersection with &
@@ -328,7 +328,7 @@ for animal in ["dog", "cat", "mouse"]:
print("{} is a mammal".format(animal))
"""
-"range(number)" returns a list of numbers
+"range(number)" returns an iterable of numbers
from zero to the given number
prints:
0
@@ -340,7 +340,7 @@ for i in range(4):
print(i)
"""
-"range(lower, upper)" returns a list of numbers
+"range(lower, upper)" returns an iterable of numbers
from the lower number to the upper number
prints:
4
@@ -458,14 +458,14 @@ all_the_args(**kwargs) # equivalent to foo(a=3, b=4)
all_the_args(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4)
-# Function Scope
+# Function Scope
x = 5
def setX(num):
# Local var x not the same as global variable x
x = num # => 43
print (x) # => 43
-
+
def setGlobalX(num):
global x
print (x) # => 5
@@ -512,8 +512,8 @@ class Human(object):
# Basic initializer, this is called when this class is instantiated.
# 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 magic methods (or sometimes called dunder methods)
+ # namespaces. Methods(or objects or attributes) like: __init__, __str__,
+ # __repr__ etc. are called magic 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
@@ -600,7 +600,7 @@ def double_numbers(iterable):
# double_numbers.
# Note range is a generator too. Creating a list 1-900000000 would take lot of
# time to be made
-# We use a trailing underscore in variable names when we want to use a name that
+# We use a trailing underscore in variable names when we want to use a name that
# would normally collide with a python keyword
range_ = range(1, 900000000)
# will double all numbers until a result >=30 found
diff --git a/rust.html.markdown b/rust.html.markdown
index dcb54733..17f7dc90 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -6,14 +6,21 @@ filename: learnrust.rs
---
Rust is an in-development programming language developed by Mozilla Research.
-It is relatively unique among systems languages in that it can assert memory
-safety *at compile time* without resorting to garbage collection. Rust’s first
-release, 0.1, occurred in January 2012, and development moves so quickly that at
-the moment the use of stable releases is discouraged, and instead one should use
-nightly builds. On January 9 2015, Rust 1.0 Alpha was released, and the rate of
-changes to the Rust compiler that break existing code has dropped significantly
-since. However, a complete guarantee of backward compatibility will not exist
-until the final 1.0 release.
+Rust combines low-level control over performance with high-level convenience and
+safety guarantees.
+
+It achieves these goals without requiring a garbage collector or runtime, making
+it possible to use Rust libraries as a "drop-in replacement" for C.
+
+Rust’s first release, 0.1, occurred in January 2012, and for 3 years development
+moved so quickly that until recently the use of stable releases was discouraged
+and instead the general advise was to use nightly builds.
+
+On May 15th 2015, Rust 1.0 was released with a complete guarantee of backward
+compatibility. Improvements to compile times and other aspects of the compiler are
+currently available in the nightly builds. Rust has adopted a train-based release
+model with regular releases every six weeks. Rust 1.1 beta was made available at
+the same time of the release of Rust 1.0.
Although Rust is a relatively low-level language, Rust has some functional
concepts that are generally found in higher-level languages. This makes
diff --git a/standard-ml.html.markdown b/standard-ml.html.markdown
index 07896beb..143980e7 100644
--- a/standard-ml.html.markdown
+++ b/standard-ml.html.markdown
@@ -4,6 +4,7 @@ contributors:
- ["Simon Shine", "http://shine.eu.org/"]
- ["David Pedersen", "http://lonelyproton.com/"]
- ["James Baker", "http://www.jbaker.io/"]
+ - ["Leo Zovic", "http://langnostic.inaimathi.ca/"]
---
Standard ML is a functional programming language with type inference and some
@@ -136,9 +137,29 @@ val mixup = [ ("Alice", 39),
val good_bad_stuff =
(["ice cream", "hot dogs", "chocolate"],
- ["liver", "paying the rent" ]) (* string list * string list *)
+ ["liver", "paying the rent" ]) (* : string list * string list *)
+(* Records are tuples with named slots *)
+
+val rgb = { r=0.23, g=0.56, b=0.91 } (* : {b:real, g:real, r:real} *)
+
+(* You don't need to declare their slots ahead of time. Records with
+ different slot names are considered different types, even if their
+ slot value types match up. For instance... *)
+
+val Hsl = { H=310.3, s=0.51, l=0.23 } (* : {H:real, l:real, s:real} *)
+val Hsv = { H=310.3, s=0.51, v=0.23 } (* : {H:real, s:real, v:real} *)
+
+(* ...trying to evaluate `Hsv = Hsl` or `rgb = Hsl` would give a type
+ error. While they're all three-slot records composed only of `real`s,
+ they each have different names for at least some slots. *)
+
+(* You can use hash notation to get values out of tuples. *)
+
+val H = #H Hsv (* : real *)
+val s = #s Hsl (* : real *)
+
(* Functions! *)
fun add_them (a, b) = a + b (* A simple function that adds two numbers *)
val test_it = add_them (3, 4) (* gives 7 *)
@@ -225,17 +246,26 @@ fun fibonacci 0 = 0 (* Base case *)
| fibonacci 1 = 1 (* Base case *)
| fibonacci n = fibonacci (n - 1) + fibonacci (n - 2) (* Recursive case *)
-(* Pattern matching is also possible on composite types like tuples and lists.
- Writing "fun solve2 (a, b, c) = ..." is in fact a pattern match on the one
- three-tuple solve2 takes as argument. Similarly, but less intuitively, you
- can match on a list consisting of elements in it (from the beginning of the
- list only). *)
+(* Pattern matching is also possible on composite types like tuples, lists and
+ records. Writing "fun solve2 (a, b, c) = ..." is in fact a pattern match on
+ the one three-tuple solve2 takes as argument. Similarly, but less intuitively,
+ you can match on a list consisting of elements in it (from the beginning of
+ the list only). *)
fun first_elem (x::xs) = x
fun second_elem (x::y::xs) = y
fun evenly_positioned_elems (odd::even::xs) = even::evenly_positioned_elems xs
| evenly_positioned_elems [odd] = [] (* Base case: throw away *)
| evenly_positioned_elems [] = [] (* Base case *)
+(* When matching on records, you must use their slot names, and you must bind
+ every slot in a record. The order of the slots doesn't matter though. *)
+
+fun rgbToTup {r, g, b} = (r, g, b) (* fn : {b:'a, g:'b, r:'c} -> 'c * 'b * 'a *)
+fun mixRgbToTup {g, b, r} = (r, g, b) (* fn : {b:'a, g:'b, r:'c} -> 'c * 'b * 'a *)
+
+(* If called with {r=0.1, g=0.2, b=0.3}, either of the above functions
+ would return (0.1, 0.2, 0.3). But it would be a type error to call them
+ with {r=0.1, g=0.2, b=0.3, a=0.4} *)
(* Higher order functions: Functions can take other functions as arguments.
Functions are just other kinds of values, and functions don't need names
diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown
index fbfa500d..00d61843 100644
--- a/visualbasic.html.markdown
+++ b/visualbasic.html.markdown
@@ -159,7 +159,7 @@ Module Module1
Console.Write(a.ToString() + " - " + b.ToString())
Console.WriteLine(" = " + e.ToString.PadLeft(3))
Console.Write(a.ToString() + " / " + b.ToString())
- Console.WriteLine(" = " + e.ToString.PadLeft(3))
+ Console.WriteLine(" = " + f.ToString.PadLeft(3))
Console.ReadLine()
End Sub
@@ -189,7 +189,7 @@ Module Module1
Console.Write(a.ToString() + " - " + b.ToString())
Console.WriteLine(" = " + e.ToString.PadLeft(3))
Console.Write(a.ToString() + " / " + b.ToString())
- Console.WriteLine(" = " + e.ToString.PadLeft(3))
+ Console.WriteLine(" = " + f.ToString.PadLeft(3))
Console.ReadLine()
'Ask the question, does the user wish to continue? Unfortunately it
'is case sensitive.
diff --git a/zh-cn/bash-cn.html.markdown b/zh-cn/bash-cn.html.markdown
index 6afa659a..558d9110 100644
--- a/zh-cn/bash-cn.html.markdown
+++ b/zh-cn/bash-cn.html.markdown
@@ -5,7 +5,14 @@ contributors:
- ["Max Yankov", "https://github.com/golergka"]
- ["Darren Lin", "https://github.com/CogBear"]
- ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+ - ["Denis Arh", "https://github.com/darh"]
+ - ["akirahirose", "https://twitter.com/akirahirose"]
+ - ["Anton Strömkvist", "http://lutic.org/"]
+ - ["Rahil Momin", "https://github.com/iamrahil"]
+ - ["Gregrory Kielian", "https://github.com/gskielian"]
+ - ["Etan Reisner", "https://github.com/deryni"]
translators:
+ - ["Jinchang Ye", "https://github.com/Alwayswithme"]
- ["Chunyang Xu", "https://github.com/XuChunyang"]
filename: LearnBash-cn.sh
lang: zh-cn
@@ -23,31 +30,45 @@ Bash 是一个为 GNU 计划编写的 Unix shell,是 Linux 和 Mac OS X 下的
# 如你所见,注释以 # 开头,shebang 也是注释。
# 显示 “Hello world!”
-echo Hello, world!
+echo Hello world!
# 每一句指令以换行或分号隔开:
echo 'This is the first line'; echo 'This is the second line'
# 声明一个变量:
-VARIABLE="Some string"
+Variable="Some string"
# 下面是错误的做法:
-VARIABLE = "Some string"
-# Bash 会把 VARIABLE 当做一个指令,由于找不到该指令,因此这里会报错。
+Variable = "Some string"
+# Bash 会把 Variable 当做一个指令,由于找不到该指令,因此这里会报错。
+# 也不可以这样:
+Variable= 'Some string'
+# Bash 会认为 'Some string' 是一条指令,由于找不到该指令,这里再次报错。
+# (这个例子中 'Variable=' 这部分会被当作仅对 'Some string' 起作用的赋值。)
# 使用变量:
-echo $VARIABLE
-echo "$VARIABLE"
-echo '$VARIABLE'
+echo $Variable
+echo "$Variable"
+echo '$Variable'
# 当你赋值 (assign) 、导出 (export),或者以其他方式使用变量时,变量名前不加 $。
# 如果要使用变量的值, 则要加 $。
# 注意: ' (单引号) 不会展开变量(即会屏蔽掉变量)。
# 在变量内部进行字符串代换
-echo ${VARIABLE/Some/A}
-# 会把 VARIABLE 中首次出现的 "some" 替换成 “A”。
+echo ${Variable/Some/A}
+# 会把 Variable 中首次出现的 "some" 替换成 “A”。
+
+# 变量的截取
+Length=7
+echo ${Variable:0:Length}
+# 这样会仅返回变量值的前7个字符
+
+# 变量的默认值
+echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# 对 null (Foo=) 和空串 (Foo="") 起作用; 零(Foo=0)时返回0
+# 注意这仅返回默认值而不是改变变量的值
# 内置变量:
# 下面的内置变量很有用
@@ -55,26 +76,37 @@ echo "Last program return value: $?"
echo "Script's PID: $$"
echo "Number of arguments: $#"
echo "Scripts arguments: $@"
-echo "Scripts arguments separeted in different variables: $1 $2..."
+echo "Scripts arguments separated in different variables: $1 $2..."
# 读取输入:
echo "What's your name?"
-read NAME # 这里不需要声明新变量
-echo Hello, $NAME!
+read Name # 这里不需要声明新变量
+echo Hello, $Name!
# 通常的 if 结构看起来像这样:
# 'man test' 可查看更多的信息
-if [ $NAME -ne $USER ]
+if [ $Name -ne $USER ]
then
- echo "Your name is you username"
+ echo "Your name isn't your username"
else
- echo "Your name isn't you username"
+ echo "Your name is your username"
fi
# 根据上一个指令执行结果决定是否执行下一个指令
-echo "Always executed" || echo "Only executed if first command fail"
+echo "Always executed" || echo "Only executed if first command fails"
echo "Always executed" && echo "Only executed if first command does NOT fail"
+# 在 if 语句中使用 && 和 || 需要多对方括号
+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
+
# 表达式的格式如下:
echo $(( 10 + 5 ))
@@ -88,18 +120,54 @@ ls -l # 列出文件和目录的详细信息
# 用下面的指令列出当前目录下所有的 txt 文件:
ls -l | grep "\.txt"
+# 重定向输入和输出(标准输入,标准输出,标准错误)。
+# 以 ^EOF$ 作为结束标记从标准输入读取数据并覆盖 hello.py :
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+ print(line, file=sys.stdout)
+EOF
+
# 重定向可以到输出,输入和错误输出。
-python2 hello.py < "input.in"
-python2 hello.py > "output.out"
-python2 hello.py 2> "error.err"
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
# > 会覆盖已存在的文件, >> 会以累加的方式输出文件中。
+python hello.py >> "output.out" 2>> "error.err"
+
+# 覆盖 output.out , 追加 error.err 并统计行数
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# 运行指令并打印文件描述符 (比如 /dev/fd/123)
+# 具体可查看: man fd
+echo <(echo "#helloworld")
+
+# 以 "#helloworld" 覆盖 output.out:
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# 清理临时文件并显示详情(增加 '-i' 选项启用交互模式)
+rm -v output.out error.err output-and-error.log
# 一个指令可用 $( ) 嵌套在另一个指令内部:
# 以下的指令会打印当前目录下的目录和文件总数
echo "There are $(ls | wc -l) items here."
+# 反引号 `` 起相同作用,但不允许嵌套
+# 优先使用 $( ).
+echo "There are `ls | wc -l` items here."
+
# Bash 的 case 语句与 Java 和 C++ 中的 switch 语句类似:
-case "$VARIABLE" in
+case "$Variable" in
# 列出需要匹配的字符串
0) echo "There is a zero.";;
1) echo "There is a one.";;
@@ -107,11 +175,37 @@ case "$VARIABLE" in
esac
# 循环遍历给定的参数序列:
-# 变量$VARIABLE 的值会被打印 3 次。
-# 注意 ` ` 和 $( ) 等价。seq 返回长度为 3 的数组。
-for VARIABLE in `seq 3`
+# 变量$Variable 的值会被打印 3 次。
+for Variable in {1..3}
+do
+ echo "$Variable"
+done
+
+# 或传统的 “for循环” :
+for ((a=1; a <= 3; a++))
do
- echo "$VARIABLE"
+ echo $a
+done
+
+# 也可以用于文件
+# 用 cat 输出 file1 和 file2 内容
+for Variable in file1 file2
+do
+ cat "$Variable"
+done
+
+# 或作用于其他命令的输出
+# 对 ls 输出的文件执行 cat 指令。
+for Output in $(ls)
+do
+ cat "$Output"
+done
+
+# while 循环:
+while [ true ]
+do
+ echo "loop body here..."
+ break
done
# 你也可以使用函数
@@ -132,17 +226,52 @@ bar ()
}
# 调用函数
-foo "My name is" $NAME
+foo "My name is" $Name
# 有很多有用的指令需要学习:
-tail -n 10 file.txt
# 打印 file.txt 的最后 10 行
-head -n 10 file.txt
+tail -n 10 file.txt
# 打印 file.txt 的前 10 行
-sort file.txt
+head -n 10 file.txt
# 将 file.txt 按行排序
-uniq -d file.txt
+sort file.txt
# 报告或忽略重复的行,用选项 -d 打印重复的行
-cut -d ',' -f 1 file.txt
+uniq -d file.txt
# 打印每行中 ',' 之前内容
+cut -d ',' -f 1 file.txt
+# 将 file.txt 文件所有 'okay' 替换为 'great', (兼容正则表达式)
+sed -i 's/okay/great/g' file.txt
+# 将 file.txt 中匹配正则的行打印到标准输出
+# 这里打印以 "foo" 开头, "bar" 结尾的行
+grep "^foo.*bar$" file.txt
+# 使用选项 "-c" 统计行数
+grep -c "^foo.*bar$" file.txt
+# 如果只是要按字面形式搜索字符串而不是按正则表达式,使用 fgrep (或 grep -F)
+fgrep "^foo.*bar$" file.txt
+
+
+# 以 bash 内建的 'help' 指令阅读 Bash 自带文档:
+help
+help help
+help for
+help return
+help source
+help .
+
+# 用 mam 指令阅读相关的 Bash 手册
+apropos bash
+man 1 bash
+man bash
+
+# 用 info 指令查阅命令的 info 文档 (info 中按 ? 显示帮助信息)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# 阅读 Bash 的 info 文档:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
```
diff --git a/zh-cn/javascript-cn.html.markdown b/zh-cn/javascript-cn.html.markdown
index 64b0aadc..b450ab84 100644
--- a/zh-cn/javascript-cn.html.markdown
+++ b/zh-cn/javascript-cn.html.markdown
@@ -341,7 +341,7 @@ var myFunc = myObj.myFunc;
myFunc(); // = undefined
// 相应的,一个函数也可以被指定为一个对象的方法,并且可以通过`this`访问
-// 这个对象的成员,即使在行数被定义时并没有依附在对象上。
+// 这个对象的成员,即使在函数被定义时并没有依附在对象上。
var myOtherFunc = function(){
return this.myString.toUpperCase();
}