adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-26 16:53:10 +03:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into dart-formatting

Browse Source
This commit is contained in:
Divay Prakash 2020-01-24 20:02:22 +05:30 committed by GitHub
commit 9f41d38cec
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
72 changed files with 6527 additions and 2555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CONTRIBUTING.markdown
View File

@ -103,11 +103,3 @@ You can buid the site locally to test your changes. Follow the steps below.
these commands at `learnxinyminutes-site/`).
* Build - `bundle exec middleman build`
* Dev server - `bundle exec middleman --force-polling --verbose`
## Building the site locally, for Nix users
You can buid the site locally to test your changes too:
* Clone or zip download the [learnxinyminutes-site](https://github.com/adambard/learnxinyminutes-site) repo.
* Get the source in place following the instructions above
* Install all site dependencies and start a dev server by running `nix-shell` at the `learnxinyminutes-site/` root directory.

2
ansible.html.markdown
View File

@ -513,7 +513,7 @@ $ # Now we would run the above playbook with roles
You can use the jinja in the CLI too
```bash
ansible -m shell -a 'echo {{ my_variable }}` -e 'my_variable=something, playbook_parameter=twentytwo" localhost
ansible -m shell -a 'echo {{ my_variable }}' -e 'my_variable=something, playbook_parameter=twentytwo' localhost
```
In fact - jinja is used to template parts of the playbooks too

3
c.html.markdown
View File

@ -10,6 +10,7 @@ contributors:
- ["himanshu", "https://github.com/himanshu81494"]
- ["Joshua Li", "https://github.com/JoshuaRLi"]
- ["Dragos B. Chirila", "https://github.com/dchirila"]
- ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
---
Ah, C. Still **the** language of modern high-performance computing.
@ -820,7 +821,7 @@ Best to find yourself a copy of [K&R, aka "The C Programming Language"](https://
It is *the* book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some
inaccuracies (well, ideas that are not considered good anymore) or now-changed practices.
Another good resource is [Learn C The Hard Way](http://c.learncodethehardway.org/book/).
Another good resource is [Learn C The Hard Way](http://learncodethehardway.org/c/).
If you have a question, read the [compl.lang.c Frequently Asked Questions](http://c-faq.com).

3
clojure.html.markdown
View File

@ -416,3 +416,6 @@ Clojuredocs.org has documentation with examples for most core functions:
Clojure-doc.org (yes, really) has a number of getting started articles:
[http://clojure-doc.org/](http://clojure-doc.org/)
Clojure for the Brave and True has a great introduction to Clojure and a free online version:
[https://www.braveclojure.com/clojure-for-the-brave-and-true/](https://www.braveclojure.com/clojure-for-the-brave-and-true/)

2
common-lisp.html.markdown
View File

@ -69,7 +69,7 @@ t ; another atom, denoting true
;;; is a good starting point. Third party libraries can be easily installed with
;;; Quicklisp
;;; CL is usually developed with a text editor and a Real Eval Print
;;; CL is usually developed with a text editor and a Read Eval Print
;;; Loop (REPL) running at the same time. The REPL allows for interactive
;;; exploration of the program while it is running "live".

478
coq.html.markdown Normal file
View File

@ -0,0 +1,478 @@
---
language: Coq
filename: learncoq.v
contributors:
- ["Philip Zucker", "http://www.philipzucker.com/"]
---
The Coq system is a proof assistant. It is designed to build and verify mathematical proofs. The Coq system contains the functional programming language Gallina and is capable of proving properties about programs written in this language.
Coq is a dependently typed language. This means that the types of the language may depend on the values of variables. In this respect, it is similar to other related languages such as Agda, Idris, F*, Lean, and others. Via the Curry-Howard correspondence, programs, properties and proofs are formalized in the same language.
Coq is developed in OCaml and shares some syntactic and conceptual similarity with it. Coq is a language containing many fascinating but difficult topics. This tutorial will focus on the programming aspects of Coq, rather than the proving. It may be helpful, but not necessary to learn some OCaml first, especially if you are unfamiliar with functional programming. This tutorial is based upon its OCaml equivalent
The standard usage model of Coq is to write it with interactive tool assistance, which operates like a high powered REPL. Two common such editors are the CoqIDE and Proof General Emacs mode.
Inside Proof General `Ctrl+C Ctrl+<Enter>` will evaluate up to your cursor.
```coq
(*** Comments ***)
(* Comments are enclosed in (* and *). It's fine to nest comments. *)
(* There are no single-line comments. *)
(*** Variables and functions ***)
(* The Coq proof assistant can be controlled and queried by a command language called
the vernacular. Vernacular keywords are capitalized and the commands end with a period.
Variable and function declarations are formed with the Definition vernacular. *)
Definition x := 10.
(* Coq can sometimes infer the types of arguments, but it is common practice to annotate
with types. *)
Definition inc_nat (x : nat) : nat := x + 1.
(* There exists a large number of vernacular commands for querying information.
These can be very useful. *)
Compute (1 + 1). (* 2 : nat *) (* Compute a result. *)
Check tt. (* tt : unit *) (* Check the type of an expressions *)
About plus. (* Prints information about an object *)
(* Print information including the definition *)
Print true. (* Inductive bool : Set := true : Bool | false : Bool *)
Search nat. (* Returns a large list of nat related values *)
Search "_ + _". (* You can also search on patterns *)
Search (?a -> ?a -> bool). (* Patterns can have named parameters *)
Search (?a * ?a).
(* Locate tells you where notation is coming from. Very helpful when you encounter
new notation. *)
Locate "+".
(* Calling a function with insufficient number of arguments
does not cause an error, it produces a new function. *)
Definition make_inc x y := x + y. (* make_inc is int -> int -> int *)
Definition inc_2 := make_inc 2. (* inc_2 is int -> int *)
Compute inc_2 3. (* Evaluates to 5 *)
(* Definitions can be chained with "let ... in" construct.
This is roughly the same to assigning values to multiple
variables before using them in expressions in imperative
languages. *)
Definition add_xy : nat := let x := 10 in
let y := 20 in
x + y.
(* Pattern matching is somewhat similar to switch statement in imperative
languages, but offers a lot more expressive power. *)
Definition is_zero (x : nat) :=
match x with
| 0 => true
| _ => false (* The "_" pattern means "anything else". *)
end.
(* You can define recursive function definition using the Fixpoint vernacular.*)
Fixpoint factorial n := match n with
| 0 => 1
| (S n') => n * factorial n'
end.
(* Function application usually doesn't need parentheses around arguments *)
Compute factorial 5. (* 120 : nat *)
(* ...unless the argument is an expression. *)
Compute factorial (5-1). (* 24 : nat *)
(* You can define mutually recursive functions using "with" *)
Fixpoint is_even (n : nat) : bool := match n with
| 0 => true
| (S n) => is_odd n
end with
is_odd n := match n with
| 0 => false
| (S n) => is_even n
end.
(* As Coq is a total programming language, it will only accept programs when it can
understand they terminate. It can be most easily seen when the recursive call is
on a pattern matched out subpiece of the input, as then the input is always decreasing
in size. Getting Coq to understand that functions terminate is not always easy. See the
references at the end of the article for more on this topic. *)
(* Anonymous functions use the following syntax: *)
Definition my_square : nat -> nat := fun x => x * x.
Definition my_id (A : Type) (x : A) : A := x.
Definition my_id2 : forall A : Type, A -> A := fun A x => x.
Compute my_id nat 3. (* 3 : nat *)
(* You can ask Coq to infer terms with an underscore *)
Compute my_id _ 3.
(* An implicit argument of a function is an argument which can be inferred from contextual
knowledge. Parameters enclosed in {} are implicit by default *)
Definition my_id3 {A : Type} (x : A) : A := x.
Compute my_id3 3. (* 3 : nat *)
(* Sometimes it may be necessary to turn this off. You can make all arguments explicit
again with @ *)
Compute @my_id3 nat 3.
(* Or give arguments by name *)
Compute my_id3 (A:=nat) 3.
(* Coq has the ability to extract code to OCaml, Haskell, and Scheme *)
Require Extraction.
Extraction Language OCaml.
Extraction "factorial.ml" factorial.
(* The above produces a file factorial.ml and factorial.mli that holds:
type nat =
| O
| S of nat
(** val add : nat -> nat -> nat **)
let rec add n m =
match n with
| O -> m
| S p -> S (add p m)
(** val mul : nat -> nat -> nat **)
let rec mul n m =
match n with
| O -> O
| S p -> add m (mul p m)
(** val factorial : nat -> nat **)
let rec factorial n = match n with
| O -> S O
| S n' -> mul n (factorial n')
*)
(*** Notation ***)
(* Coq has a very powerful Notation system that can be used to write expressions in more
natural forms. *)
Compute Nat.add 3 4. (* 7 : nat *)
Compute 3 + 4. (* 7 : nat *)
(* Notation is a syntactic transformation applied to the text of the program before being
evaluated. Notation is organized into notation scopes. Using different notation scopes
allows for a weak notion of overloading. *)
(* Imports the Zarith module containing definitions related to the integers Z *)
Require Import ZArith.
(* Notation scopes can be opened *)
Open Scope Z_scope.
(* Now numerals and addition are defined on the integers. *)
Compute 1 + 7. (* 8 : Z *)
(* Integer equality checking *)
Compute 1 =? 2. (* false : bool *)
(* Locate is useful for finding the origin and definition of notations *)
Locate "_ =? _". (* Z.eqb x y : Z_scope *)
Close Scope Z_scope.
(* We're back to nat being the default interpretation of "+" *)
Compute 1 + 7. (* 8 : nat *)
(* Scopes can also be opened inline with the shorthand % *)
Compute (3 * -7)%Z. (* -21%Z : Z *)
(* Coq declares by default the following interpretation scopes: core_scope, type_scope,
function_scope, nat_scope, bool_scope, list_scope, int_scope, uint_scope. You may also
want the numerical scopes Z_scope (integers) and Q_scope (fractions) held in the ZArith
and QArith module respectively. *)
(* You can print the contents of scopes *)
Print Scope nat_scope.
(*
Scope nat_scope
Delimiting key is nat
Bound to classes nat Nat.t
"x 'mod' y" := Nat.modulo x y
"x ^ y" := Nat.pow x y
"x ?= y" := Nat.compare x y
"x >= y" := ge x y
"x > y" := gt x y
"x =? y" := Nat.eqb x y
"x <? y" := Nat.ltb x y
"x <=? y" := Nat.leb x y
"x <= y <= z" := and (le x y) (le y z)
"x <= y < z" := and (le x y) (lt y z)
"n <= m" := le n m
"x < y <= z" := and (lt x y) (le y z)
"x < y < z" := and (lt x y) (lt y z)
"x < y" := lt x y
"x / y" := Nat.div x y
"x - y" := Init.Nat.sub x y
"x + y" := Init.Nat.add x y
"x * y" := Init.Nat.mul x y
*)
(* Coq has exact fractions available as the type Q in the QArith module.
Floating point numbers and real numbers are also available but are a more advanced
topic, as proving properties about them is rather tricky. *)
Require Import QArith.
Open Scope Q_scope.
Compute 1. (* 1 : Q *)
Compute 2. (* 2 : nat *) (* only 1 and 0 are interpreted as fractions by Q_scope *)
Compute (2 # 3). (* The fraction 2/3 *)
Compute (1 # 3) ?= (2 # 6). (* Eq : comparison *)
Close Scope Q_scope.
Compute ( (2 # 3) / (1 # 5) )%Q. (* 10 # 3 : Q *)
(*** Common data structures ***)
(* Many common data types are included in the standard library *)
(* The unit type has exactly one value, tt *)
Check tt. (* tt : unit *)
(* The option type is useful for expressing computations that might fail *)
Compute None. (* None : option ?A *)
Check Some 3. (* Some 3 : option nat *)
(* The type sum A B allows for values of either type A or type B *)
Print sum.
Check inl 3. (* inl 3 : nat + ?B *)
Check inr true. (* inr true : ?A + bool *)
Check sum bool nat. (* (bool + nat)%type : Set *)
Check (bool + nat)%type. (* Notation for sum *)
(* Tuples are (optionally) enclosed in parentheses, items are separated
by commas. *)
Check (1, true). (* (1, true) : nat * bool *)
Compute prod nat bool. (* (nat * bool)%type : Set *)
Definition my_fst {A B : Type} (x : A * B) : A := match x with
| (a,b) => a
end.
(* A destructuring let is available if a pattern match is irrefutable *)
Definition my_fst2 {A B : Type} (x : A * B) : A := let (a,b) := x in
a.
(*** Lists ***)
(* Lists are built by using cons and nil or by using notation available in list_scope. *)
Compute cons 1 (cons 2 (cons 3 nil)). (* (1 :: 2 :: 3 :: nil)%list : list nat *)
Compute (1 :: 2 :: 3 :: nil)%list.
(* There is also list notation available in the ListNotations modules *)
Require Import List.
Import ListNotations.
Compute [1 ; 2 ; 3]. (* [1; 2; 3] : list nat *)
(*
There are a large number of list manipulation functions available, including:
• length
• head : first element (with default)
• tail : all but first element
• app : appending
• rev : reverse
• nth : accessing n-th element (with default)
• map : applying a function
• flat_map : applying a function returning lists
• fold_left : iterator (from head to tail)
• fold_right : iterator (from tail to head)
*)
Definition my_list : list nat := [47; 18; 34].
Compute List.length my_list. (* 3 : nat *)
(* All functions in coq must be total, so indexing requires a default value *)
Compute List.nth 1 my_list 0. (* 18 : nat *)
Compute List.map (fun x => x * 2) my_list. (* [94; 36; 68] : list nat *)
Compute List.filter (fun x => Nat.eqb (Nat.modulo x 2) 0) my_list. (* [18; 34] : list nat *)
Compute (my_list ++ my_list)%list. (* [47; 18; 34; 47; 18; 34] : list nat *)
(*** Strings ***)
Require Import Strings.String.
(* Use double quotes for string literals. *)
Compute "hi"%string.
Open Scope string_scope.
(* Strings can be concatenated with the "++" operator. *)
Compute String.append "Hello " "World". (* "Hello World" : string *)
Compute "Hello " ++ "World". (* "Hello World" : string *)
(* Strings can be compared for equality *)
Compute String.eqb "Coq is fun!" "Coq is fun!". (* true : bool *)
Compute "no" =? "way". (* false : bool *)
Close Scope string_scope.
(*** Other Modules ***)
(* Other Modules in the standard library that may be of interest:
• Logic : Classical logic and dependent equality
• Arith : Basic Peano arithmetic
• PArith : Basic positive integer arithmetic
• NArith : Basic binary natural number arithmetic
• ZArith : Basic relative integer arithmetic
• Numbers : Various approaches to natural, integer and cyclic numbers (currently
axiomatically and on top of 2^31 binary words)
• Bool : Booleans (basic functions and results)
• Lists : Monomorphic and polymorphic lists (basic functions and results),
Streams (infinite sequences defined with co-inductive types)
• Sets : Sets (classical, constructive, finite, infinite, power set, etc.)
• FSets : Specification and implementations of finite sets and finite maps
(by lists and by AVL trees)
• Reals : Axiomatization of real numbers (classical, basic functions, integer part,
fractional part, limit, derivative, Cauchy series, power series and results,...)
• Relations : Relations (definitions and basic results)
• Sorting : Sorted list (basic definitions and heapsort correctness)
• Strings : 8-bits characters and strings
• Wellfounded : Well-founded relations (basic results)
*)
(*** User-defined data types ***)
(* Because Coq is dependently typed, defining type aliases is no different than defining
an alias for a value. *)
Definition my_three : nat := 3.
Definition my_nat : Type := nat.
(* More interesting types can be defined using the Inductive vernacular. Simple enumeration
can be defined like so *)
Inductive ml := OCaml | StandardML | Coq.
Definition lang := Coq. (* Has type "ml". *)
(* For more complicated types, you will need to specify the types of the constructors. *)
(* Type constructors don't need to be empty. *)
Inductive my_number := plus_infinity
| nat_value : nat -> my_number.
Compute nat_value 3. (* nat_value 3 : my_number *)
(* Record syntax is sugar for tuple-like types. It defines named accessor functions for
the components. Record types are defined with the notation {...} *)
Record Point2d (A : Set) := mkPoint2d { x2 : A ; y2 : A }.
(* Record values are constructed with the notation {|...|} *)
Definition mypoint : Point2d nat := {| x2 := 2 ; y2 := 3 |}.
Compute x2 nat mypoint. (* 2 : nat *)
Compute mypoint.(x2 nat). (* 2 : nat *)
(* Types can be parameterized, like in this type for "list of lists
of anything". 'a can be substituted with any type. *)
Definition list_of_lists a := list (list a).
Definition list_list_nat := list_of_lists nat.
(* Types can also be recursive. Like in this type analogous to
built-in list of naturals. *)
Inductive my_nat_list := EmptyList | NatList : nat -> my_nat_list -> my_nat_list.
Compute NatList 1 EmptyList. (* NatList 1 EmptyList : my_nat_list *)
(** Matching type constructors **)
Inductive animal := Dog : string -> animal | Cat : string -> animal.
Definition say x :=
match x with
| Dog x => (x ++ " says woof")%string
| Cat x => (x ++ " says meow")%string
end.
Compute say (Cat "Fluffy"). (* "Fluffy says meow". *)
(** Traversing data structures with pattern matching **)
(* Recursive types can be traversed with pattern matching easily.
Let's see how we can traverse a data structure of the built-in list type.
Even though the built-in cons ("::") looks like an infix operator,
it's actually a type constructor and can be matched like any other. *)
Fixpoint sum_list l :=
match l with
| [] => 0
| head :: tail => head + (sum_list tail)
end.
Compute sum_list [1; 2; 3]. (* Evaluates to 6 *)
(*** A Taste of Proving ***)
(* Explaining the proof language is out of scope for this tutorial, but here is a taste to
whet your appetite. Check the resources below for more. *)
(* A fascinating feature of dependently type based theorem provers is that the same
primitive constructs underly the proof language as the programming features.
For example, we can write and prove the proposition A and B implies A in raw Gallina *)
Definition my_theorem : forall A B, A /\ B -> A := fun A B ab => match ab with
| (conj a b) => a
end.
(* Or we can prove it using tactics. Tactics are a macro language to help build proof terms
in a more natural style and automate away some drudgery. *)
Theorem my_theorem2 : forall A B, A /\ B -> A.
Proof.
intros A B ab. destruct ab as [ a b ]. apply a.
Qed.
(* We can prove easily prove simple polynomial equalities using the automated tactic ring. *)
Require Import Ring.
Require Import Arith.
Theorem simple_poly : forall (x : nat), (x + 1) * (x + 2) = x * x + 3 * x + 2.
Proof. intros. ring. Qed.
(* Here we prove the closed form for the sum of all numbers 1 to n using induction *)
Fixpoint sumn (n : nat) : nat :=
match n with
| 0 => 0
| (S n') => n + (sumn n')
end.
Theorem sum_formula : forall n, 2 * (sumn n) = (n + 1) * n.
Proof. intros n. induction n.
- reflexivity. (* 0 = 0 base case *)
- simpl. ring [IHn]. (* induction step *)
Qed.
```
With this we have only scratched the surface of Coq. It is a massive ecosystem with many interesting and peculiar topics leading all the way up to modern research.
## Further reading
* [The Coq reference manual](https://coq.inria.fr/refman/)
* [Software Foundations](https://softwarefoundations.cis.upenn.edu/)
* [Certified Programming with Dependent Types](http://adam.chlipala.net/cpdt/)
* [Mathematical Components](https://math-comp.github.io/mcb/)
* [Coq'Art: The Calculus of Inductive Constructions](http://www.cse.chalmers.se/research/group/logic/TypesSS05/resources/coq/CoqArt/)
* [FRAP](http://adam.chlipala.net/frap/)

70
csharp.html.markdown
View File

@ -14,20 +14,22 @@ filename: LearnCSharp.cs
C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework.
[Read more here.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
[Read more here.](https://docs.microsoft.com/dotnet/csharp/getting-started/introduction-to-the-csharp-language-and-the-net-framework)
```c#
// Single-line comments start with //
/*
Multi-line comments look like this
*/
/// <summary>
/// This is an XML documentation comment which can be used to generate external
/// documentation or provide context help within an IDE
/// </summary>
/// <param name="firstParam">This is some parameter documentation for firstParam</param>
/// <returns>Information on the returned value of a function</returns>
//public void MethodOrClassOrOtherWithParsableHelp(string firstParam) {}
public void MethodOrClassOrOtherWithParsableHelp(string firstParam) {}
// Specify the namespaces this source code will be using
// The namespaces below are all part of the standard .NET Framework Class Library
@ -254,7 +256,7 @@ on a new line! ""Wow!"", the masses cried";
int fooWhile = 0;
while (fooWhile < 100)
{
//Iterated 100 times, fooWhile 0->99
// Iterated 100 times, fooWhile 0->99
fooWhile++;
}
@ -273,10 +275,10 @@ on a new line! ""Wow!"", the masses cried";
} while (fooDoWhile < 100);
//for loop structure => for(<start_statement>; <conditional>; <step>)
// for loop structure => for(<start_statement>; <conditional>; <step>)
for (int fooFor = 0; fooFor < 10; fooFor++)
{
//Iterated 10 times, fooFor 0->9
// Iterated 10 times, fooFor 0->9
}
// For Each Loop
@ -287,7 +289,7 @@ on a new line! ""Wow!"", the masses cried";
// (The ToCharArray() could be removed, because a string also implements IEnumerable)
foreach (char character in "Hello World".ToCharArray())
{
//Iterated over all the characters in the string
// Iterated over all the characters in the string
}
// Switch Case
@ -329,7 +331,7 @@ on a new line! ""Wow!"", the masses cried";
// Convert String To Integer
// this will throw a FormatException on failure
int.Parse("123");//returns an integer version of "123"
int.Parse("123"); // returns an integer version of "123"
// try parse will default to type default on failure
// in this case: 0
@ -373,7 +375,7 @@ on a new line! ""Wow!"", the masses cried";
Console.Read();
} // End main method
// CONSOLE ENTRY A console application must have a main method as an entry point
// CONSOLE ENTRY - A console application must have a main method as an entry point
public static void Main(string[] args)
{
OtherInterestingFeatures();
@ -404,7 +406,7 @@ on a new line! ""Wow!"", the masses cried";
ref int maxCount, // Pass by reference
out int count)
{
//the argument passed in as 'count' will hold the value of 15 outside of this function
// the argument passed in as 'count' will hold the value of 15 outside of this function
count = 15; // out param must be assigned before control leaves the method
}
@ -552,7 +554,7 @@ on a new line! ""Wow!"", the masses cried";
}
// PARALLEL FRAMEWORK
// http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
// https://devblogs.microsoft.com/csharpfaq/parallel-programming-in-net-framework-4-getting-started/
var words = new List<string> {"dog", "cat", "horse", "pony"};
@ -564,11 +566,11 @@ on a new line! ""Wow!"", the masses cried";
}
);
//Running this will produce different outputs
//since each thread finishes at different times.
//Some example outputs are:
//cat dog horse pony
//dog horse pony cat
// Running this will produce different outputs
// since each thread finishes at different times.
// Some example outputs are:
// cat dog horse pony
// dog horse pony cat
// DYNAMIC OBJECTS (great for working with other languages)
dynamic student = new ExpandoObject();
@ -725,10 +727,10 @@ on a new line! ""Wow!"", the masses cried";
int _speed; // Everything is private by default: Only accessible from within this class.
// can also use keyword private
public string Name { get; set; }
// Properties also have a special syntax for when you want a readonly property
// that simply returns the result of an expression
public string LongName => Name + " " + _speed + " speed";
public string LongName => Name + " " + _speed + " speed";
// Enum is a value type that consists of a set of named constants
// It is really just mapping a name to a value (an int, unless specified otherwise).
@ -865,7 +867,7 @@ on a new line! ""Wow!"", the masses cried";
}
}
//Method to display the attribute values of this Object.
// Method to display the attribute values of this Object.
public virtual string Info()
{
return "Gear: " + Gear +
@ -960,7 +962,7 @@ on a new line! ""Wow!"", the masses cried";
/// <summary>
/// Used to connect to DB for LinqToSql example.
/// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// https://docs.microsoft.com/ef/ef6/modeling/code-first/workflows/new-database
/// </summary>
public class BikeRepository : DbContext
{
@ -1069,7 +1071,7 @@ on a new line! ""Wow!"", the masses cried";
{
private static bool LogException(Exception ex)
{
/* log exception somewhere */
// log exception somewhere
return false;
}
@ -1089,7 +1091,7 @@ on a new line! ""Wow!"", the masses cried";
// Spell failed
return false;
}
// Other exceptions, or MagicServiceException where Code is not 42
// Other exceptions, or MagicServiceException where Code is not 42
catch(Exception ex) when (LogException(ex))
{
// Execution never reaches this block
@ -1117,12 +1119,12 @@ on a new line! ""Wow!"", the masses cried";
[Obsolete("Use NewMethod instead", false)]
public static void ObsoleteMethod()
{
/* obsolete code */
// obsolete code
}
public static void NewMethod()
{
/* new code */
// new code
}
public static void Main()
@ -1154,9 +1156,9 @@ namespace Learning.More.CSharp
}
}
//New C# 7 Feature
//Install Microsoft.Net.Compilers Latest from Nuget
//Install System.ValueTuple Latest from Nuget
// New C# 7 Feature
// Install Microsoft.Net.Compilers Latest from Nuget
// Install System.ValueTuple Latest from Nuget
using System;
namespace Csharp7
{
@ -1213,7 +1215,7 @@ namespace Csharp7
Console.WriteLine(tt.GetLastName());
}
}
// PATTERN MATCHING
class PatternMatchingTest
{
@ -1310,13 +1312,13 @@ namespace Csharp7
## Further Reading
* [C# language reference](https://docs.microsoft.com/dotnet/csharp/language-reference/)
* [Learn .NET](https://dotnet.microsoft.com/learn)
* [C# Coding Conventions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/coding-conventions)
* [DotNetPerls](http://www.dotnetperls.com)
* [C# in Depth](http://manning.com/skeet2)
* [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
* [LINQ](http://shop.oreilly.com/product/9780596519254.do)
* [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
* [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
* [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
* [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
* [Programming C# 5.0](http://shop.oreilly.com/product/0636920024064.do)
* [LINQ Pocket Reference](http://shop.oreilly.com/product/9780596519254.do)
* [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
* [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
* [freeCodeCamp - C# Tutorial for Beginners](https://www.youtube.com/watch?v=GhQdlIFylQ8)

19
css.html.markdown
View File

@ -164,14 +164,14 @@ selector {
max-width: 5in; /* inches */
/* Colors */
color: #F6E; /* short hex format */
color: #FF66EE; /* long hex format */
color: tomato; /* a named color */
color: rgb(255, 255, 255); /* as rgb values */
color: rgb(10%, 20%, 50%); /* as rgb percentages */
color: rgba(255, 0, 0, 0.3); /* as rgba values (CSS 3) Note: 0 <= a <= 1 */
color: transparent; /* equivalent to setting the alpha to 0 */
color: hsl(0, 100%, 50%); /* as hsl percentages (CSS 3) */
color: #F6E; /* short hex format */
color: #FF66EE; /* long hex format */
color: tomato; /* a named color */
color: rgb(255, 255, 255); /* as rgb values */
color: rgb(10%, 20%, 50%); /* as rgb percentages */
color: rgba(255, 0, 0, 0.3); /* as rgba values (CSS 3) Note: 0 <= a <= 1 */
color: transparent; /* equivalent to setting the alpha to 0 */
color: hsl(0, 100%, 50%); /* as hsl percentages (CSS 3) */
color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
/* Borders */
@ -179,7 +179,7 @@ selector {
border-style:solid;
border-color:red; /* similar to how background-color is set */
border: 5px solid red; /* this is a short hand approach for the same */
border-radius:20px; /* this is a CSS3 property */
border-radius:20px; /* this is a CSS3 property */
/* Images as backgrounds of elements */
background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
@ -317,6 +317,7 @@ a new feature.
* [Dabblet](http://dabblet.com/) (CSS playground)
* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) (Tutorials and reference)
* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) (Reference)
* [DevTips' CSS Basics](https://www.youtube.com/playlist?list=PLqGj3iMvMa4IOmy04kDxh_hqODMqoeeCy) (Tutorials)
## Further Reading

41
dart.html.markdown
View File

@ -536,6 +536,44 @@ example30() {
}
}
// Optional Positional Parameter:
// parameter will be disclosed with square bracket [ ] & square bracketed parameter are optional.
example31() {
findVolume31(int length, int breath, [int height]) {
print('length = $length, breath = $breath, height = $height');
}
findVolume31(10,20,30); //valid
findVolume31(10,20); //also valid
}
// Optional Named Parameter:
// parameter will be disclosed with curly bracket { }
// curly bracketed parameter are optional.
// have to use parameter name to assign a value which separated with colan :
// in curly bracketed parameter order does not matter
// these type parameter help us to avoid confusion while passing value for a function which has many parameter.
example32() {
findVolume32(int length, int breath, {int height}) {
print('length = $length, breath = $breath, height = $height');
}
findVolume32(10,20,height:30);//valid & we can see the parameter name is mentioned here.
findVolume32(10,20);//also valid
}
// Optional Default Parameter:
// same like optional named parameter in addition we can assign default value for this parameter.
// which means no value is passed this default value will be taken.
example33() {
findVolume33(int length, int breath, {int height=10}) {
print('length = $length, breath = $breath, height = $height');
}
findVolume33(10,20,height:30);//valid
findVolume33(10,20);//valid
}
// Programs have only one entry point in the main function.
// Nothing is expected to be executed on the outer scope before a program
// starts running with what's in its main function.
@ -562,6 +600,3 @@ Dart has a comprehensive web-site. It covers API reference, tutorials, articles
useful Try Dart online.
[https://www.dartlang.org](https://www.dartlang.org)
[https://try.dartlang.org](https://try.dartlang.org)

2
de-de/bash-de.html.markdown
View File

@ -217,7 +217,7 @@ done
function foo ()
{
echo "Argumente funktionieren wie bei skripts: $@"
echo Und: $1 $2..."
echo "Und: $1 $2..."
echo "Dies ist eine Funktion"
return 0
}

51
de-de/c++-de.html.markdown
View File

@ -9,6 +9,7 @@ contributors:
- ["Ankush Goyal", "http://github.com/ankushg07"]
- ["Jatin Dhankhar", "https://github.com/jatindhankhar"]
- ["Maximilian Sonnenburg", "https://github.com/LamdaLamdaLamda"]
- ["caminsha", "https://github.com/caminsha"]
lang: de-de
---
@ -22,9 +23,9 @@ entworfen wurde um,
- Objektorientierung zu unterstützen
- generische Programmierung zu unterstützen
Durch seinen Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein.
Durch seine Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein.
Sie ist weit verbreitet, weil sie in Maschinen-Code kompiliert, welches direkt vom Prozessor ausgeführt
Sie ist weit verbreitet, weil sie in Maschinen-Code kompiliert, welcher direkt vom Prozessor ausgeführt
werden kann und somit eine strikte Kontrolle über die Hardware bietet und gleichzeitig
High-Level-Features wie generics, exceptions und Klassen enthält.
@ -36,7 +37,7 @@ weitverbreitesten Programmiersprachen.
// Vergleich zu C
//////////////////
// C ist fast eine Untermenge von C++ und teilt sich grundsätzlich den
// C ist fast eine Untermenge von C++ und teilt sich grundsätzlich die
// Syntax für Variablen Deklarationen, primitiven Typen und Funktionen.
// Wie in C ist der Programmeinsprungpunkt eine Funktion, welche "main" genannt wird und
@ -137,7 +138,7 @@ void invalidDeclaration(int a = 1, int b) // Fehler!
/////////////
// Namespaces (Namesräume)
// Namespaces (Namensräume)
/////////////
// Namespaces stellen einen getrennten Gültigkeitsbereich für Variablen,
@ -169,7 +170,7 @@ void foo()
int main()
{
// Fügt all Symbole aus dem namespace Second in den aktuellen Gültigkeitsbereich (scope).
// Fügt alle Symbole aus dem namespace Second in den aktuellen Gültigkeitsbereich (scope).
// "foo()" wird nun nicht länger funktionieren, da es nun doppeldeutig ist, ob foo aus
// dem namespace foo oder darüberliegenden aufgerufen wird.
using namespace Second;
@ -283,7 +284,7 @@ string retVal = tempObjectFun();
// für Details). Wie in diesem Code:
foo(bar(tempObjectFun()))
// Nehmen wir an foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben,
// Nehmen wir an, foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben,
// wird an bar übergeben und ist zerstört bevor foo aufgerufen wird.
// Zurück zu Referenzen. Die Annahme, dass die "am Ende des Ausdrucks" Regel gültig ist,
@ -335,7 +336,7 @@ ECarTypes GetPreferredCarType()
return ECarTypes::Hatchback;
}
// Mit C++11 existiert eine einfache Möglichkeit einem Typ dem Enum zu zuweisen. Dies
// Mit C++11 existiert eine einfache Möglichkeit einem Typ dem Enum zuzuweisen. Dies
// kann durchaus sinnvoll bei der Serialisierung von Daten sein, oder bei der Konvertierung
// zwischen Typen bzw. Konstanten.
enum ECarTypes : uint8_t
@ -574,7 +575,7 @@ int main ()
// Templates in C++ werden in erster Linie dafür verwendet generisch zu programmieren.
// Sie unterstützen explizite und partielle Spezialisierung und darüber hinaus können
// sie für funktionale Klassen verwendet werden.
// Tatsächlich bilden templates die Turing-Vollständigkeit
// Tatsächlich bilden Templates die Turing-Vollständigkeit
// (universelle Programmierbarkeit) ab.
@ -588,12 +589,12 @@ public:
void insert(const T&) { ... }
};
// Während der Kompilierung generiert der Compiler Kopien für jedes template, wobei
// Während der Kompilierung generiert der Compiler Kopien für jedes Template, wobei
// hierbei die Parameter substituiert werden. Somit muss bei jedem Aufruf die gesamte
// Definition der Klasse zur Verfügung stehen. Aus diesem Grund wird ein Template
// komplett im header definiert.
// Erzeugung einer Template-Klasse auf dem stack:
// Erzeugung einer Template-Klasse auf dem Stack:
Box<int> intBox;
// eine der zu erwartenden Verwendungen:
@ -612,7 +613,7 @@ boxOfBox.insert(intBox);
// sind fast identisch hinsichtlich der Funktionalität. Weitere
// Informationen auf: http://en.wikipedia.org/wiki/Typename
// Eine template-Funktion:
// Eine Template-Funktion:
template<class T>
void barkThreeTimes(const T& input)
{
@ -622,7 +623,7 @@ void barkThreeTimes(const T& input)
}
// Hierbei ist zu beachten, dass an dieser Stelle nichts über den Typen des Parameters
// definiert wurde. Der Kompiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen
// definiert wurde. Der Compiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen
// prüfen. Somit funktioniert die zuvor definierte Funktion für jeden Typ 'T', die die
// const Methode 'bark' implementiert hat.
@ -637,10 +638,10 @@ void printMessage()
cout << "Learn C++ in " << Y << " minutes!" << endl;
}
// Des Weiteren können templates aus Effizienzgründen genauer spezifiziert werden.
// Selbstverständlich sind reale-Problemen, welche genauer spezifiziert werden nicht
// Des Weiteren können Templates aus Effizienzgründen genauer spezifiziert werden.
// Selbstverständlich sind reale Probleme, welche genauer spezifiziert werden, nicht
// derart trivial. Auch wenn alle Parameter explizit definiert wurden, muss die
// Funktion oder Klasse als template deklariert werden.
// Funktion oder Klasse als Template deklariert werden.
template<>
void printMessage<10>()
{
@ -818,9 +819,9 @@ void doSomethingWithAFile(const std::string& filename)
// Container
/////////////////////
// Die Container der Standard template Bibliothek beinhaltet einige vordefinierter templates.
// Die Container der Standard template Bibliothek beinhaltet einige vordefinierte Templates.
// Diese verwalten die Speicherbereiche für die eigenen Elemente und stellen Member-Funktionen
// für den Zugriff und die Maniplulation bereit.
// für den Zugriff und die Manipulation bereit.
// Beispielhafte Container:
@ -876,7 +877,7 @@ for(it=ST.begin();it<ST.end();it++)
// 10
// 30
// Zum leeren des gesamten Container wird die Methode
// Zum leeren des gesamten Containers wird die Methode
// Container._name.clear() verwendet.
ST.clear();
cout << ST.size(); // Ausgabe der Set-Größe
@ -948,11 +949,11 @@ fooMap.find(Foo(1)); // Wahr
// Lambda Ausdrücke (C++11 und höher)
///////////////////////////////////////
// Lambdas sind eine gängige Methodik um anonyme Funktionen an dem
// Lambdas sind eine gängige Methodik, um anonyme Funktionen an dem
// Ort der Verwendung zu definieren. Darüber hinaus auch bei der
// Verwendung von Funktionen als Argument einer Funktion.
// Nehmen wir an es soll ein Vektor von "pairs" (Paaren) mithilfe
// Nehmen wir an, es soll ein Vektor von "pairs" (Paaren) mithilfe
// des zweiten Werts des "pairs" sortiert werden.
vector<pair<int, int> > tester;
@ -966,7 +967,7 @@ sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int,
return lhs.second < rhs.second;
});
// Beachte den Syntax von Lambda-Ausdrücken.
// Beachte die Syntax von Lambda-Ausdrücken.
// Die [] im Lambda Ausdruck werden für die Variablen verwendet.
// Diese so genannte "capture list" definiert, was außerhalb des Lambdas,
// innerhalb der Funktion verfügbar sein soll und in welcher Form.
@ -1025,7 +1026,7 @@ for(auto elem: arr)
// Einige Aspekte von C++ sind für Neueinsteiger häufig überraschend (aber auch für
// C++ Veteranen).
// Der nachfolgende Abschnitt ist leider nicht vollständig:
// C++ ist eine der Sprachen, bei der es ein leichtes ist sich selbst ins Bein zu schießen.
// C++ ist eine der Sprachen, bei der es ein Leichtes ist, sich selbst ins Bein zu schießen.
// Private-Methoden können überschrieben werden
class Foo
@ -1074,10 +1075,10 @@ f1 = f2;
#include<tuple>
// Konzeptionell sind Tuple´s alten Datenstrukturen sehr ähnlich, allerdings haben diese keine
// Konzeptionell sind Tupel alten Datenstrukturen sehr ähnlich, allerdings haben diese keine
// bezeichneten Daten-Member, sondern werden durch die Reihenfolge angesprochen.
// Erstellen des Tuples und das Einfügen eines Werts.
// Erstellen des Tupels und das Einfügen eines Werts.
auto first = make_tuple(10, 'A');
const int maxN = 1e9;
const int maxL = 15;
@ -1102,7 +1103,7 @@ tuple<int, char, double> third(11, 'A', 3.14141);
cout << tuple_size<decltype(third)>::value << "\n"; // prints: 3
// tuple_cat fügt die Elemente eines Tuples aneinander (in der selben Reihenfolge).
// tuple_cat fügt die Elemente eines Tupels aneinander (in der selben Reihenfolge).
auto concatenated_tuple = tuple_cat(first, second, third);
// concatenated_tuple wird zu = (10, 'A', 1e9, 15, 11, 'A', 3.14141)

22
de-de/nix-de.html.markdown
View File

@ -8,11 +8,11 @@ translators:
lang: de-de
---
Nix ist eine simple funktionale Programmiersprache, die für den
Nix ist eine simple funktionale Programmiersprache, die für den
[Nix package manager](https://nixos.org/nix/) und
[NixOS](https://nixos.org/) entwickelt wurde.
Du kannst Nix Ausdrücke evaluieren mithilfe von
Du kannst Nix Ausdrücke evaluieren mithilfe von
[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
oder [`nix-repl`](https://github.com/edolstra/nix-repl).
@ -24,7 +24,7 @@ with builtins; [
# Inline Kommentare sehen so aus.
/* Multizeilen Kommentare
/* Multizeilen Kommentare
sehen so aus. */
@ -61,7 +61,7 @@ with builtins; [
"String Literale sind in Anführungszeichen."
"
String Literale können mehrere
String Literale können mehrere
Zeilen umspannen.
"
@ -95,7 +95,7 @@ with builtins; [
tutorials/learn.nix
#=> /the-base-path/tutorials/learn.nix
# Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine
# Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine
# Datei im selben Verzeichnis benötigt ein ./ Präfix.
./learn.nix
#=> /the-base-path/learn.nix
@ -238,7 +238,7 @@ with builtins; [
#=> { d = 2; e = 3; }
# Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn
# das Attribut selbst nicht zugewiesen wurde.
# das Attribut selbst nicht zugewiesen wurde.
{
a = { b = 1; };
a.c = 2;
@ -261,9 +261,9 @@ with builtins; [
#=> 7
# Die erste Linie diese Tutorials startet mit "with builtins;",
# weil builtins ein Set mit allen eingebauten
# weil builtins ein Set mit allen eingebauten
# Funktionen (length, head, tail, filter, etc.) umfasst.
# Das erspart uns beispielsweise "builtins.length" zu schreiben,
# Das erspart uns beispielsweise "builtins.length" zu schreiben,
# anstatt nur "length".
@ -305,7 +305,7 @@ with builtins; [
(tryEval (abort "foo"))
#=> error: evaluation aborted with the following error message: ‘foo’
# `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst
# `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst
# löst es eine abfangbare Exception aus.
(assert 1 < 2; 42)
#=> 42
@ -319,7 +319,7 @@ with builtins; [
#=========================================
# Da die Wiederholbarkeit von Builds für den Nix Packetmanager entscheidend ist,
# werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar
# werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar
# unreine Elemente.
# Du kannst auf Umgebungsvariablen verweisen.
(getEnv "HOME")
@ -355,4 +355,4 @@ with builtins; [
(https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
* [Susan Potter - Nix Cookbook - Nix By Example]
(http://funops.co/nix-cookbook/nix-by-example/)
(https://ops.functionalalgebra.com/nix-by-example/)

12
dynamic-programming.html.markdown
View File

@ -3,6 +3,7 @@ category: Algorithms & Data Structures
name: Dynamic Programming
contributors:
- ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
- ["Miltiadis Stouras", "https://github.com/mstou"]
---
# Dynamic Programming
@ -48,6 +49,15 @@ for i=0 to n-1
## Online Resources
* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
* MIT 6.006: [Lessons 19,20,21,22](https://www.youtube.com/playlist?list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
* TopCoder: [Dynamic Programming from Novice to Advanced](https://www.topcoder.com/community/data-science/data-science-tutorials/dynamic-programming-from-novice-to-advanced/)
* [CodeChef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
* [InterviewBit](https://www.interviewbit.com/courses/programming/topics/dynamic-programming/)
* GeeksForGeeks:
* [Overlapping Subproblems](https://www.geeksforgeeks.org/dynamic-programming-set-1/)
* [Tabulation vs Memoization](https://www.geeksforgeeks.org/tabulation-vs-memoizatation/)
* [Optimal Substructure Property](https://www.geeksforgeeks.org/dynamic-programming-set-2-optimal-substructure-property/)
* [How to solve a DP problem](https://www.geeksforgeeks.org/solve-dynamic-programming-problem/)
* [How to write DP solutions](https://www.quora.com/Are-there-any-good-resources-or-tutorials-for-dynamic-programming-DP-besides-the-TopCoder-tutorial/answer/Michal-Danilák)
And a [quiz](https://www.commonlounge.com/discussion/cdbbfe83bcd64281964b788969247253) to test your knowledge.

3
es-es/c-es.html.markdown
View File

@ -5,6 +5,7 @@ contributors:
- ["Adam Bard", "http://adambard.com/"]
translators:
- ["Francisco García", "http://flaskbreaker.tumblr.com/"]
- ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
lang: es-es
---
@ -423,7 +424,7 @@ libro de C, escrito por Dennis Ritchie, creador de C y Brian Kernighan. Aún as
se cuidadoso, es antiguo, contiene algunas inexactitudes, y algunas prácticas
han cambiado.
Otro buen recurso es [Learn C the hard way](http://c.learncodethehardway.org/book/).
Otro buen recurso es [Learn C the hard way](http://learncodethehardway.org/c/).
Si tienes una pregunta, lee [compl.lang.c Frequently Asked Questions](http://c-faq.com).

200
es-es/factor-es.html.markdown Normal file
View File

@ -0,0 +1,200 @@
---
language: factor
contributors:
- ["hyphz", "http://github.com/hyphz/"]
translators:
- ["Roberto R", "https://github.com/rrodriguze"]
filename: learnfactor-es.factor
lang: es-es
---
Factor es un lenguaje moderno basado en la pila, basado en Forth, creado por
Slava Pestov.
El código de este archivo puede escribirse en Factor, pero no importa
directamente porque el encabezado del vocabulario de importación haria que el
comienzo fuera totalmente confuso.
```factor
! Esto es un comentario
! Como Forth, toda la programación se realiza mediante la manipulación de la
! pila.
! La intruducción de un valor literal lo coloca en la pila
5 2 3 56 76 23 65 ! No hay salida pero la pila se imprime en modo interactivo
! Esos números se agregan a la pila de izquierda a derecha
! .s imprime la pila de forma no destructiva.
.s ! 5 2 3 56 76 23 65
! La aritmética funciona manipulando datos en la pila.
5 4 + ! Sem saída
! `.` muestra el resultado superior de la pila y lo imprime.
. ! 9
! Más ejemplos de aritmética:
6 7 * . ! 42
1360 23 - . ! 1337
12 12 / . ! 1
13 2 mod . ! 1
99 neg . ! -99
-99 abs . ! 99
52 23 max . ! 52
52 23 min . ! 23
! Se proporcionan varias palabras para manipular la pila, conocidas
colectivamente como palabras codificadas.
3 dup - ! duplica el primer item (1st ahora igual a 2nd): 3 - 3
2 5 swap / ! intercambia el primero con el segundo elemento: 5 / 2
4 0 drop 2 / ! elimina el primer item (no imprime en pantalla): 4 / 2
1 2 3 nip .s ! elimina el segundo item (semejante a drop): 1 3
1 2 clear .s ! acaba con toda la pila
1 2 3 4 over .s ! duplica el segundo item superior: 1 2 3 4 3
1 2 3 4 2 pick .s ! duplica el tercer item superior: 1 2 3 4 2 3
! Creando Palabras
! La palabra `:` factoriza los conjuntos en modo de compilación hasta que vea
la palabra`;`.
: square ( n -- n ) dup * ; ! Sin salida
5 square . ! 25
! Podemos ver lo que las palabra hacen también.
! \ suprime la evaluación de una palabra y coloca su identificador en la pila.
\ square see ! : square ( n -- n ) dup * ;
! Después del nombre de la palabra para crear, la declaración entre paréntesis
da efecto a la pila.
! Podemos usar los nombres que queramos dentro de la declaración:
: weirdsquare ( camel -- llama ) dup * ;
! Mientras su recuento coincida con el efecto de pila de palabras:
: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong
: doubledup ( a -- a a a ) dup dup ; ! Ok
: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok
! Donde Factor difiere de Forth es en el uso de las citaciones.
! Una citacion es un bloque de código que se coloca en la pila como un valor.
! [ inicia el modo de citación; ] termina.
[ 2 + ] ! La cita que suma dos queda en la pila
4 swap call . ! 6
! Y así, palabras de orden superior. TONOS de palabras de orden superior
2 3 [ 2 + ] dip .s ! Tomar valor de la parte superior de la pilar, cotizar, retroceder: 4 3
3 4 [ + ] keep .s ! Copiar el valor desde la parte superior de la pila, cotizar, enviar copia: 7 4
1 [ 2 + ] [ 3 + ] bi .s ! Ejecute cada cotización en el valor superior, empuje amabos resultados: 3 4
4 3 1 [ + ] [ + ] bi .s ! Las citas en un bi pueden extraer valores más profundos de la pila: 4 5 ( 1+3 1+4 )
1 2 [ 2 + ] bi@ .s ! Citar en primer y segundo valor
2 [ + ] curry ! Inyecta el valor dado al comienzo de la pila: [ 2 + ] se deja en la pila
! Condicionales
! Cualquier valor es verdadero, excepto el valor interno f.
! no existe un valor interno, pero su uso no es esencial.
! Los condicionales son palabras de orden superior, como con los combinadores
! anteriores
5 [ "Five is true" . ] when ! Cinco es verdadero
0 [ "Zero is true" . ] when ! Cero es verdadero
f [ "F is true" . ] when ! Sin salida
f [ "F is false" . ] unless ! F es falso
2 [ "Two is true" . ] [ "Two is false" . ] if ! Two es verdadero
! Por defecto, los condicionales consumen el valor bajo prueba, pero las
! variantes con un
! asterisco se dejan solo si es verdad:
5 [ . ] when* ! 5
f [ . ] when* ! Sin salida, pila vacía, se consume porque f es falso
! Lazos
! Lo has adivinado... estas son palabras de orden superior también.
5 [ . ] each-integer ! 0 1 2 3 4
4 3 2 1 0 5 [ + . ] each-integer ! 0 2 4 6 8
5 [ "Hello" . ] times ! Hello Hello Hello Hello Hello
! Here's a list:
{ 2 4 6 8 } ! Goes on the stack as one item
! Aqui está uma lista:
{ 2 4 6 8 } [ 1 + . ] each ! Exibe 3 5 7 9
{ 2 4 6 8 } [ 1 + ] map ! Salida { 3 5 7 9 } de la pila
! Reduzir laços ou criar listas:
{ 1 2 3 4 5 } [ 2 mod 0 = ] filter ! Solo mantenga miembros de la lista para los cuales la cita es verdadera: { 2 4 }
{ 2 4 6 8 } 0 [ + ] reduce . ! Como "fold" en lenguajes funcinales: exibe 20 (0+2+4+6+8)
{ 2 4 6 8 } 0 [ + ] accumulate . . ! Como reducir, pero mantiene los valores intermedios en una lista: { 0 2 6 12 } así que 20
1 5 [ 2 * dup ] replicate . ! Repite la cita 5 veces y recoge los resultados en una lista: { 2 4 8 16 32 }
1 [ dup 100 < ] [ 2 * dup ] produce ! Repite la segunda cita hasta que la primera devuelva falso y recopile los resultados: { 2 4 8 16 32 64 128 }
! Si todo lo demás falla, un propósito general a repetir.
1 [ dup 10 < ] [ "Hello" . 1 + ] while ! Escribe "Hello" 10 veces
! Sí, es dificil de leer
! Para eso están los bucles variantes
! Variables
! Normalmente, se espera que los programas de Factor mantengan todos los datos
! en la pila.
! El uso de variables con nombre hace que la refactorización sea más difícil
! (y se llama Factor por una razón)
! Variables globales, si las necesitas:
SYMBOL: name ! Crea un nombre como palabra de identificación
"Bob" name set-global ! Sin salída
name get-global . ! "Bob"
! Las variables locales nombradas se consideran una extensión, pero están
! disponibles
! En una cita ..
[| m n ! La cita captura los dos valores principales de la pila en m y n
| m n + ] ! Leerlos
! Ou em uma palavra..
:: lword ( -- ) ! Tenga en cuenta los dos puntos dobles para invocar la extensión de variable léxica
2 :> c ! Declara la variable inmutable c para contener 2
c . ; ! Imprimirlo
! En una palabra declarada de esta manera, el lado de entrada de la declaración
! de la pila
! se vuelve significativo y proporciona los valores de las variables en las que
! se capturan los valores de pila
:: double ( a -- result ) a 2 * ;
! Las variables se declaran mutables al terminar su nombre con su signo de
! exclamación
:: mword2 ( a! -- x y ) ! Capture la parte superior de la pila en la variable mutable a
a ! Empujar a
a 2 * a! ! Multiplique por 2 y almacenar el resultado en a
a ; ! Empujar el nuevo valor de a
5 mword2 ! Pila: 5 10
! Listas y Secuencias
! Vimos arriba cómo empujar una lista a la pila
0 { 1 2 3 4 } nth ! Acceder a un miembro específico de una lista: 1
10 { 1 2 3 4 } nth ! Error: índice de secuencia fuera de los límites
1 { 1 2 3 4 } ?nth ! Lo mismo que nth si el índice está dentro de los límites: 2
10 { 1 2 3 4 } ?nth ! Sin errores si está fuera de los límites: f
{ "at" "the" "beginning" } "Append" prefix ! { "Append" "at" "the" "beginning" }
{ "Append" "at" "the" } "end" suffix ! { "Append" "at" "the" "end" }
"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" }
"Concat" "enate" append ! "Concatenate" - strings are sequences too
"Concatenate" "Reverse " prepend ! "Reverse Concatenate"
{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs"
{ "Connect" "subseqs" "with" "separators" } " " join ! "Connect subseqs with separators"
! Y si desea obtener meta, las citas son secuencias y se pueden desmontar
0 [ 2 + ] nth ! 2
1 [ 2 + ] nth ! +
[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
```
##Listo para más?
* [Documentación de Factor](http://docs.factorcode.org/content/article-help.home.html)

44
es-es/hq9+-es.html.markdown Normal file
View File

@ -0,0 +1,44 @@
---
language: HQ9+
filename: hq9+-es.html
contributors:
- ["Alexey Nazaroff", "https://github.com/rogaven"]
translators:
- ["Roberto R", "https://github.com/rrodriguze"]
lang: es-es
---
HQ9+ es una parodia de los lenguajes de programación esotéricos y fue creado
por Cliff Biffle.
El lenguaje tiene solo cuatro comandos y no está completo de Turing.
```
Solo hay cuatro comandos, representados por los siguientes cuatro caracteres
H: imprime "Hello, world!"
Q: imprime el código fuente del programa (ein Quine)
9: imprime la letra de "99 Bottles of Beer"
+: aumenta el acumulador en uno (el valod del acumulador no se puede leer)
Cualquier otro caracter es ignorado.
Ok. Escribamos el programa:
HQ
Resultado:
Hello world!
HQ
HQ9+ es muy simple, pero te permite hacer cosas en él. Otros lenguajes son muy
difíciles.Por ejemplo, el siguiente programa imprime tres copias de sí mismo en
la pantalla:
QQQ
Esto imprime:
QQQ
QQQ
QQQ
```
Y esto es todo. Hay muchos intérpretes para HQ9+.
A continuación encontrarás uno de ellos.
+ [One of online interpreters](https://almnet.de/esolang/hq9plus.php)
+ [HQ9+ official website](http://cliffle.com/esoterica/hq9plus.html)

176
es-es/hy-es.html.markdown Normal file
View File

@ -0,0 +1,176 @@
---
language: hy
filename: learnhy-es.hy
contributors:
- ["Abhishek L", "http://twitter.com/abhishekl"]
translators:
- ["Roberto R", "https://github.com/rrodriguze"]
lang: es-es
---
Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
Hy llamar a código Pyhton nativo y viceversa.
Este tutorial funciona para hy >= 0.9.12
```clojure
;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
;; http://try-hy.appspot.com
;;
; Comentarios usando punto y coma, como en otros LISPS
;; Nociones básicas de expresiones
; Los programas List están hechos de expresiones simbólicas como la siguiente
(some-function args)
; ahora el esencial "Hola Mundo"
(print "hello world")
;; Tipos de datos simples
; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
; en python
42 ; => 42
3.14 ; => 3.14
True ; => True
4+10j ; => (4+10j) un número complejo
; Vamos a comenzar con un poco de arimética simple
(+ 4 1) ;=> 5
; el operador es aplicado a todos los argumentos, como en otros lisps
(+ 4 1 2 3) ;=> 10
(- 2 1) ;=> 1
(* 4 2) ;=> 8
(/ 4 1) ;=> 4
(% 4 2) ;=> 0 o operador módulo
; la exponenciación es representada por el operador ** como python
(** 3 2) ;=> 9
; las funciones anidadas funcionan como lo esperado
(+ 2 (* 4 2)) ;=> 10
; también los operadores lógicos igual o no igual se comportan como se espera
(= 5 4) ;=> False
(not (= 5 4)) ;=> True
;; variables
; las variables se configuran usando SETV, los nombres de las variables pueden
; usar utf-8, excepto for ()[]{}",'`;#|
(setv a 42)
(setv π 3.14159)
(def *foo* 42)
;; otros tipos de datos de almacenamiento
; strings, lists, tuples & dicts
; estos son exactamente los mismos tipos de almacenamiento en python
"hello world" ;=> "hello world"
; las operaciones de cadena funcionan de manera similar en python
(+ "hello " "world") ;=> "hello world"
; Las listas se crean usando [], la indexación comienza en 0
(setv mylist [1 2 3 4])
; las tuplas son estructuras de datos inmutables
(setv mytuple (, 1 2))
; los diccionarios son pares de valor-clave
(setv dict1 {"key1" 42 "key2" 21})
; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
(setv dict2 {:key1 41 :key2 20})
; usar 'get' para obtener un elemento en un índice/key
(get mylist 1) ;=> 2
(get dict1 "key1") ;=> 42
; Alternativamente, si se usan palabras clave que podrían llamarse directamente
(:key1 dict2) ;=> 41
;; funciones y otras estructuras de programa
; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
(defn greet [name]
  "A simple greeting" ; un docstring opcional
  (print "hello " name))
(greet "bilbo") ;=> "hello bilbo"
; las funciones pueden tener argumentos opcionales, así como argumentos-clave
(defn foolists [arg1 &optional [arg2 2]]
  [arg1 arg2])
(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]
; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
; que son similares a 'defn'
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
;; operaciones de secuencia
; hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
; recuperar el primer elemento usando 'first' o 'car'
(setv mylist [1 2 3 4])
(setv mydict {"a" 1 "b" 2})
(first mylist) ;=> 1
; corte listas usando 'slice'
(slice mylist 1 3) ;=> [2 3]
; obtener elementos de una lista o dict usando 'get'
(get mylist 1) ;=> 2
(get mydict "b") ;=> 2
; la lista de indexación comienza a partir de 0, igual que en python
; assoc puede definir elementos clave/índice
(assoc mylist 2 10) ; crear mylist [1 2 10 4]
(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
; hay muchas otras funciones que hacen que trabajar con secuencias sea 
; entretenido
;; Python interop
;; los import funcionan exactamente como en python
(import datetime)
(import [functools [partial reduce]]) ; importa fun1 e fun2 del module1
(import [matplotlib.pyplot :as plt]) ; haciendo una importación en foo como en bar
; todos los métodos de python incluídos etc. son accesibles desde hy
; a.foo(arg) is called as (.foo a arg)
(.split (.strip "hello world  ")) ;=> ["hello" "world"]
;; Condicionales
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
  (print "welcome")
  (print "Speak friend, and Enter!"))
; anidar múltiples cláusulas 'if else if' con condiciones
(cond
 [(= someval 42)
  (print "Life, universe and everything else!")]
 [(> someval 42)
  (print "val too large")]
 [(< someval 42)
  (print "val too small")])
; declaraciones de grupo con 'do', son ejecutadas secuencialmente
; formas como defn tienen un 'do' implícito
(do
 (setv someval 10)
 (print "someval is set to " someval)) ;=> 10
; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
; tienen alcance local
(let [[nemesis {"superman" "lex luther"
                "sherlock" "moriarty"
                "seinfeld" "newman"}]]
  (for [(, h v) (.items nemesis)]
    (print (.format "{0}'s nemesis was {1}" h v))))
;; clases
; las clases son definidas de la siguiente manera
(defclass Wizard [object]
  [[--init-- (fn [self spell]
             (setv self.spell spell) ; init the attr magic
             None)]
   [get-spell (fn [self]
              self.spell)]])
;; acesse hylang.org
```
### Otras lecturas
Este tutorial apenas es una introducción básica para hy/lisp/python.
Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org)
Repo Hy en GitHub: [http://github.com/hylang/hy](http://github.com/hylang/hy)
Acceso a freenode irc con #hy, hashtag en twitter: #hylang

84
es-es/pcre-es.html.markdown Normal file
View File

@ -0,0 +1,84 @@
---
language: PCRE
filename: pcre-es.txt
contributors:
- ["Sachin Divekar", "http://github.com/ssd532"]
translators:
- ["Roberto R", "https://github.com/rrodriguze"]
lang: es-es
---
Una expresión regular (regex o regexp para abreviar) es una cadena especial
utilizada para definir un patrón, por ejemplo, buscar una secuencia de
caracteres; por ejemplo, `/^[a-z]+:/` se puede usar para extraer `http:`
desde la URL `http://github.com/`.
PCRE (Pearl Compatible Regular Expressions) es una biblioteca para expresiones
muy similar a la Perls, desde ahí el nombre. Se trata de una de las sintaxis
más comunes para escribir expresiones regulares.
Hay dos tipos de metacaracteres (caracteres con una función especial):
* Caracteres reconocidos en todas partes excepto corchetes
```
\ caracter de escape
^ buscar al principio de la cadena (o línea, en modo multilínea)
$ busca al final de la cadena (o línea, en modo multilínea)
. cualquier caracter exceptoo las nuevas líneas
[ inicio de clase de caracter
| condiciones alternativas del separador
( inicio del subpatrón
) fin del subpatrón
? cuantificador "0 o 1"
* quantificatore "0 o más"
+ quantificatore "1 o más"
{ inicio de cuantificador numérico
```
* Caracteres reconocidos entre corchetes
```
\ caracter de escape
^ negar la clase si es el primer caracter
- indica una serie de caracteres
[ clase de caracteres POSIX (si sigue la sintaxis POSIX)
] termina la clase de caracteres
```
PCRE también proporciona clases de caracteres predefinidas
```
\d cifra decimal
\D cifra NO decimal
\h espacio horizontal vacío
\H espacio horizontal NO vacío
\s espacio
\S NO esoacui
\v espacio vertical vacío
\V espacio vertical NO vacío
\w palabra
\W "NO palabra"
```
## Ejemplos
Usaremos la siguiente cadena para nuestras pruebas:
```
66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
```
Se trata de una línea de log del servidor web Apache.
| Regex | Resultado | Comentario |
| :---- | :-------------- | :------ |
| `GET` | GET | Busque exactamente la cadena "GET" (distingue entre mayúsculas y minúsculas) |
| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` identifica uno o más (cuantificador `+`) números [0-9], `\.` identifica el caracter `.` |
| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` busca el grupo (`\d+\.`) exactamente 3 veces. |
| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` identifica cualquier caracter, excepto las nuevas líneas; `.` indica cualquier carácter |
| `^\S+` | 66.249.64.13 | `^` buscar al inicio de la cadena, `\S+` identifica la primera cadena de caracteres que no sea espacio |
| `\+[0-9]+` | +1000 | `\+` identifica el caracter `+`. `[0-9]` indica una cifra de 0 a 9. La expresión es equivalente a `\+\d+` |
## Otros recursos
[Regex101](https://regex101.com/) - probador de expresiones regulares

6
go.html.markdown
View File

@ -30,6 +30,12 @@ Go comes with a good standard library and a sizeable community.
/* Multi-
line comment */
/* A build tag is a line comment starting with // +build
and can be execute by go build -tags="foo bar" command.
Build tags are placed before the package clause near or at the top of the file
followed by a blank line or other line comments. */
// +build prod, dev, test
// A package clause starts every source file.
// Main is a special name declaring an executable rather than a library.
package main

32
haxe.html.markdown
View File

@ -6,8 +6,8 @@ contributors:
- ["Dan Korostelev", "https://github.com/nadako/"]
---
Haxe is a web-oriented language that provides platform support for C++, C#,
Swf/ActionScript, Javascript, Java, PHP, Python, Lua, HashLink, and Neko byte code
[Haxe](https://haxe.org/) is a general-purpose language that provides platform support for C++, C#,
Swf/ActionScript, JavaScript, Java, PHP, Python, Lua, HashLink, and Neko bytecode
(the latter two being also written by the Haxe author). Note that this guide is for
Haxe version 3. Some of the guide may be applicable to older versions, but it is
recommended to use other references.
@ -189,7 +189,7 @@ class LearnHaxe3 {
trace(m.get('bar') + " is the value for m.get('bar')");
trace(m['bar'] + " is the value for m['bar']");
var m2 = ['foo' => 4, 'baz' => 6]; // Alternative map syntax
var m2 = ['foo' => 4, 'baz' => 6]; // Alternative map syntax
trace(m2 + " is the value for m2");
// Remember, you can use type inference. The Haxe compiler will
@ -234,10 +234,9 @@ class LearnHaxe3 {
^ Bitwise exclusive OR
| Bitwise inclusive OR
*/
// increments
var i = 0;
trace("Increments and decrements");
trace("Pre-/Post- Increments and Decrements");
trace(i++); // i = 1. Post-Increment
trace(++i); // i = 2. Pre-Increment
trace(i--); // i = 1. Post-Decrement
@ -287,7 +286,7 @@ class LearnHaxe3 {
}
// do-while loop
var l = 0;
var l = 0;
do {
trace("do statement always runs at least once");
} while (l > 0);
@ -338,7 +337,7 @@ class LearnHaxe3 {
*/
var my_dog_name = "fido";
var favorite_thing = "";
switch(my_dog_name) {
switch (my_dog_name) {
case "fido" : favorite_thing = "bone";
case "rex" : favorite_thing = "shoe";
case "spot" : favorite_thing = "tennis ball";
@ -366,7 +365,7 @@ class LearnHaxe3 {
trace("k equals ", k); // outputs 10
var other_favorite_thing = switch(my_dog_name) {
var other_favorite_thing = switch (my_dog_name) {
case "fido" : "teddy";
case "rex" : "stick";
case "spot" : "football";
@ -559,7 +558,7 @@ class SimpleEnumTest {
// You can specify the "full" name,
var e_explicit:SimpleEnum = SimpleEnum.Foo;
var e = Foo; // but inference will work as well.
switch(e) {
switch (e) {
case Foo: trace("e was Foo");
case Bar: trace("e was Bar");
case Baz: trace("e was Baz"); // comment this line to throw an error.
@ -572,7 +571,7 @@ class SimpleEnumTest {
You can also specify a default for enum switches as well:
*/
switch(e) {
switch (e) {
case Foo: trace("e was Foo again");
default : trace("default works here too");
}
@ -595,21 +594,21 @@ class ComplexEnumTest {
var e1:ComplexEnum = IntEnum(4); // specifying the enum parameter
// Now we can switch on the enum, as well as extract any parameters
// it might have had.
switch(e1) {
switch (e1) {
case IntEnum(x) : trace('$x was the parameter passed to e1');
default: trace("Shouldn't be printed");
}
// another parameter here that is itself an enum... an enum enum?
var e2 = SimpleEnumEnum(Foo);
switch(e2){
switch (e2){
case SimpleEnumEnum(s): trace('$s was the parameter passed to e2');
default: trace("Shouldn't be printed");
}
// enums all the way down
var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3)));
switch(e3) {
switch (e3) {
// You can look for certain nested enums by specifying them
// explicitly:
case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : {
@ -668,7 +667,7 @@ class TypedefsAndStructuralTypes {
That would give us a single "Surface" type to work with across
all of those platforms.
*/
*/
}
}
@ -700,8 +699,7 @@ class UsingExample {
instance, and the compiler still generates code equivalent to a
static method.
*/
}
}
}
```

19
it-it/bash-it.html.markdown
View File

@ -140,6 +140,25 @@ then
echo "Questo verrà eseguito se $Nome è Daniya O Zach."
fi
# C'è anche l'operatore `=~`, che serve per confrontare una stringa con un'espressione regolare:
Email=me@example.com
if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
then
echo "Email valida!"
fi
# L'operatore =~ funziona solo dentro alle doppie parentesi quadre [[ ]],
# che hanno un comportamento leggermente diverso rispetto alle singole [ ].
# Se vuoi approfondire, visita questo link (in inglese):
# http://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs
# Usando `alias`, puoi definire nuovi comandi o modificare quelli già esistenti.
# Ad esempio, così puoi ridefinire il comando ping per inviare solo 5 pacchetti
alias ping='ping -c 5'
# "Scavalca" l'alias e usa il comando vero, utilizzando il backslash
\ping 192.168.1.1
# Stampa la lista di tutti gli alias
alias -p
# Le espressioni sono nel seguente formato:
echo $(( 10 + 5 ))

52
it-it/elixir-it.html.markdown
View File

@ -24,7 +24,7 @@ e molte altre funzionalità.
# Per usare la shell di elixir usa il comando `iex`.
# Compila i tuoi moduli con il comando `elixirc`.
# Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato
# Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato
# elixir correttamente.
## ---------------------------
@ -65,7 +65,7 @@ coda #=> [2,3]
# le tuple hanno dimensione differente.
# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
# Ci sono anche i binari
# Ci sono anche i binari
<<1,2,3>> # binari (Binary)
# Stringhe e liste di caratteri
@ -80,7 +80,7 @@ multi-linea.
#=> "Sono una stringa\nmulti-linea.\n"
# Le stringhe sono tutte codificate in UTF-8:
"cìaò"
"cìaò"
#=> "cìaò"
# le stringhe in realtà sono dei binari, e le liste di caratteri sono liste.
@ -124,10 +124,11 @@ rem(10, 3) #=> 1
# Questi operatori si aspettano un booleano come primo argomento.
true and true #=> true
false or true #=> true
# 1 and true #=> ** (ArgumentError) argument error
# 1 and true
#=> ** (BadBooleanError) expected a boolean on left-side of "and", got: 1
# Elixir fornisce anche `||`, `&&` e `!` che accettano argomenti
# di qualsiasi tipo.
# di qualsiasi tipo.
# Tutti i valori tranne `false` e `nil` saranno valutati come true.
1 || true #=> 1
false && 1 #=> false
@ -147,7 +148,7 @@ nil && 20 #=> nil
1 < :ciao #=> true
# L'ordine generale è definito sotto:
# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste
# numeri < atomi < riferimenti < funzioni < porte < pid < tuple < liste
# < stringhe di bit
# Per citare Joe Armstrong su questo: "L'ordine non è importante,
@ -171,7 +172,7 @@ else
"Questo sì"
end
# Ti ricordi il pattern matching?
# Ti ricordi il pattern matching?
# Moltre strutture di controllo di flusso in elixir si basano su di esso.
# `case` ci permette di confrontare un valore a diversi pattern:
@ -214,7 +215,7 @@ cond do
"Questa sì! (essenzialmente funziona come un else)"
end
# `try/catch` si usa per gestire i valori lanciati (throw),
# `try/catch` si usa per gestire i valori lanciati (throw),
# Supporta anche una clausola `after` che è invocata in ogni caso.
try do
throw(:ciao)
@ -235,7 +236,7 @@ quadrato = fn(x) -> x * x end
quadrato.(5) #=> 25
# Accettano anche guardie e condizioni multiple.
# le guardie ti permettono di perfezionare il tuo pattern matching,
# le guardie ti permettono di perfezionare il tuo pattern matching,
# sono indicate dalla parola chiave `when`:
f = fn
x, y when x > 0 -> x + y
@ -265,13 +266,13 @@ end
Matematica.somma(1, 2) #=> 3
Matematica.quadrato(3) #=> 9
# Per compilare il modulo 'Matematica' salvalo come `matematica.ex` e usa
# Per compilare il modulo 'Matematica' salvalo come `matematica.ex` e usa
# `elixirc`.
# nel tuo terminale: elixirc matematica.ex
# All'interno di un modulo possiamo definire le funzioni con `def` e funzioni
# private con `defp`.
# Una funzione definita con `def` è disponibile per essere invocata anche da
# Una funzione definita con `def` è disponibile per essere invocata anche da
# altri moduli, una funziona privata può essere invocata solo localmente.
defmodule MatematicaPrivata do
def somma(a, b) do
@ -286,7 +287,11 @@ end
MatematicaPrivata.somma(1, 2) #=> 3
# MatematicaPrivata.esegui_somma(1, 2) #=> ** (UndefinedFunctionError)
# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple:
# Anche le dichiarazioni di funzione supportano guardie e condizioni multiple.
# Quando viene chiamata una funzione dichiarata con più match, solo la prima
# che matcha viene effettivamente invocata.
# Ad esempio: chiamando area({:cerchio, 3}) vedrà invocata la seconda definizione
# di area mostrata sotto, non la prima:
defmodule Geometria do
def area({:rettangolo, w, h}) do
w * h
@ -322,16 +327,25 @@ defmodule Modulo do
Questo è un attributo incorporato in un modulo di esempio.
"""
@miei_dati 100 # Questo è un attributo personalizzato .
@miei_dati 100 # Questo è un attributo personalizzato.
IO.inspect(@miei_dati) #=> 100
end
# L'operatore pipe |> permette di passare l'output di una espressione
# come primo parametro di una funzione.
# Questo facilita operazioni quali pipeline di operazioni, composizione di
# funzioni, ecc.
Range.new(1,10)
|> Enum.map(fn x -> x * x end)
|> Enum.filter(fn x -> rem(x, 2) == 0 end)
#=> [4, 16, 36, 64, 100]
## ---------------------------
## -- Strutture ed Eccezioni
## ---------------------------
# Le Strutture (Structs) sono estensioni alle mappe che portano
# Le Strutture (Structs) sono estensioni alle mappe che portano
# valori di default, garanzia alla compilazione e polimorfismo in Elixir.
defmodule Persona do
defstruct nome: nil, eta: 0, altezza: 0
@ -367,7 +381,7 @@ end
## -- Concorrenza
## ---------------------------
# Elixir si basa sul modello degli attori per la concorrenza.
# Elixir si basa sul modello degli attori per la concorrenza.
# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in elixir
# sono tre primitive: creare processi, inviare messaggi e ricevere messaggi.
@ -379,12 +393,12 @@ spawn(f) #=> #PID<0.40.0>
# `spawn` restituisce un pid (identificatore di processo). Puoi usare questo
# pid per inviare messaggi al processo.
# Per passare messaggi si usa l'operatore `send`.
# Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi,
# Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi,
# oltre ad inviarli. Questo è realizzabile con `receive`:
# Il blocco `receive do` viene usato per mettersi in ascolto di messaggi
# ed elaborarli quando vengono ricevuti. Un blocco `receive do` elabora
# un solo messaggio ricevuto: per fare elaborazione multipla di messaggi,
# un solo messaggio ricevuto: per fare elaborazione multipla di messaggi,
# una funzione con un blocco `receive do` al suo intero dovrà chiamare
# ricorsivamente sé stessa per entrare di nuovo nel blocco `receive do`.
defmodule Geometria do
@ -405,7 +419,7 @@ pid = spawn(fn -> Geometria.calcolo_area() end) #=> #PID<0.40.0>
# Alternativamente
pid = spawn(Geometria, :calcolo_area, [])
# Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive
# Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive
send pid, {:rettangolo, 2, 3}
#=> Area = 6
# {:rettangolo,2,3}
@ -421,7 +435,7 @@ self() #=> #PID<0.27.0>
## Referenze
* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di elixir](http://elixir-lang.org)
* [Documentazione Elixir](http://elixir-lang.org/docs/master/)
* [Documentazione Elixir](https://elixir-lang.org/docs.html)
* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) di Dave Thomas
* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) di Fred Hebert

12
java.html.markdown
View File

@ -289,7 +289,7 @@ public class LearnJava {
// interface. This allows the execution time of basic
// operations, such as get and insert element, to remain
// constant-amortized even for large sets.
// TreeMap - A Map that is sorted by its keys. Each modification
// TreeMap - A Map that is sorted by its keys. Each modification
// maintains the sorting defined by either a Comparator
// supplied at instantiation, or comparisons of each Object
// if they implement the Comparable interface.
@ -381,7 +381,7 @@ public class LearnJava {
do {
System.out.println(fooDoWhile);
// Increment the counter
// Iterated 99 times, fooDoWhile 0->99
// Iterated 100 times, fooDoWhile 0->99
fooDoWhile++;
} while(fooDoWhile < 100);
System.out.println("fooDoWhile Value: " + fooDoWhile);
@ -470,11 +470,11 @@ public class LearnJava {
// <second value>"
int foo = 5;
String bar = (foo < 10) ? "A" : "B";
System.out.println("bar : " + bar); // Prints "bar : A", because the
System.out.println("bar : " + bar); // Prints "bar : A", because the
// statement is true.
// Or simply
System.out.println("bar : " + (foo < 10 ? "A" : "B"));
////////////////////////////////////////
// Converting Data Types
@ -918,7 +918,7 @@ public class Lambdas {
planets.keySet().forEach(p -> System.out.format("%s\n", p));
// Tracing the above, we see that planets is a HashMap, keySet() returns
// a Set of its keys, forEach applies each element as the lambda
// a Set of its keys, forEach applies each element as the lambda
// expression of: (parameter p) -> System.out.format("%s\n", p). Each
// time, the element is said to be "consumed" and the statement(s)
// referred to in the lambda body is applied. Remember the lambda body
@ -998,6 +998,8 @@ The links provided here below are just to get an understanding of the topic, fee
* [Codewars - Java Katas](https://www.codewars.com/?language=java)
* [University of Helsinki - Object-Oriented programming with Java](http://moocfi.github.io/courses/2013/programming-part-1/)
**Books**:
* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)

42
javascript.html.markdown
View File

@ -586,6 +586,48 @@ if (Object.create === undefined){ // don't overwrite it if it exists
return new Constructor();
};
}
// ES6 Additions
// The "let" keyword allows you to define variables in a lexical scope,
// as opposed to a block scope like the var keyword does.
let name = "Billy";
// Variables defined with let can be reassigned new values.
name = "William";
// The "const" keyword allows you to define a variable in a lexical scope
// like with let, but you cannot reassign the value once one has been assigned.
const pi = 3.14;
pi = 4.13; // You cannot do this.
// There is a new syntax for functions in ES6 known as "lambda syntax".
// This allows functions to be defined in a lexical scope like with variables
// defined by const and let.
const isEven = (number) => {
return number % 2 === 0;
};
isEven(7); // false
// The "equivalent" of this function in the traditional syntax would look like this:
function isEven(number) {
return number % 2 === 0;
};
// I put the word "equivalent" in double quotes because a function defined
// using the lambda syntax cannnot be called before the definition.
// The following is an example of invalid usage:
add(1, 8);
const add = (firstNumber, secondNumber) => {
return firstNumber + secondNumber;
};
```
## Further Reading

2
latex.html.markdown
View File

@ -141,7 +141,7 @@ Operators are essential parts of a mathematical document:
trigonometric functions ($\sin$, $\cos$, $\tan$),
logarithms and exponentials ($\log$, $\exp$),
limits ($\lim$), etc.\
have per-defined LaTeX commands.
have pre-defined LaTeX commands.
Let's write an equation to see how it's done:
$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$

91
lsf/lambda-calculus-lsf.html.markdown Normal file
View File

@ -0,0 +1,91 @@
---
category: Algorithms & Data Structures
name: Lambda Calculus
contributors:
- ["Max Sun", "http://github.com/maxsun"]
translators:
- ["Victore Leve", "https://github.com/AcProIL"]
lang: lsf
---
# Calculo λ
Calculo lambda, creato principto per Alonzo Church, es lingua de programmatura
computatro maximo parvo. Quamquam non habe numero, serie de charactere vel ullo
typo de data non functionale, id pote repraesenta omne machina de Turing.
Tres elemento compone calculo lambda: **quantitate variabile** (q.v.),
**functione** et **applicatione**.
| Elemento | Syntaxe | Exemplo |
|----------------------|-----------------------------------|-----------|
| Quantitate variabile | `<nomine>` | `x` |
| Functione | `λ<parametro>.<corpore>` | `λx.x` |
| Applicatione | `<functione><q.v. aut functione>` | `(λx.x)a` |
Functione fundamentale es identitate: `λx.x` cum argumento primo `x` et cum
corpore secundo `x`. In mathematica, nos scribe `id: x↦x`.
## Quantitate variabile libero et ligato
* In functione praecedente, `x` es q.v. ligato nam id es et in copore et
argumento.
* In `λx.y`, `y` es q.v. libero nam non es declarato ante.
## Valutatione
Valutatione es facto per reductione beta (reductione β) que es essentialiter
substitutione lexicale.
Dum valutatione de formula `(λx.x)a`, nos substitue omne evento de `x` in
corpore de functione pro `a`.
* `(λx.x)a` vale `a`
* `(λx.y)a` vale `y`
Pote etiam crea functione de ordine supero: `(λx.(λy.x))a` vale `λy.a`.
Etsi calculo lambda solo tracta functione de uno parametro, nos pote crea
functione cum plure argumento utente methodo de Curry: `λx.(λy.(λz.xyz))`
es scriptura informatica de formula mathematico `f: x, y, z ↦ x(y(z)))`.
Ergo, interdum, nos ute `λxy.<corpore>` pro `λx.λy.<corpore>`.
## Arithmetica
### Logica de Boole
Es nec numero nec booleano in calculo lambda.
* «vero» es `v = λx.λy.x`
* «falso» es `f = λx.λy.y`
Primo, nos pote defini functione «si t tunc a alio b» per `si = λtab.tab`.
Si `t` es vero, valutatione da `(λxy.x) a b` id es `a`. Similiter si `t` es
falso, nos obtine `b`.
Secundo, nos pote defini operatore de logica:
* «a et b» es `et = λa.λb.si a b f`
* «a vel b» es `vel = λa.λb.si a t b`
* «non a» es `non = λa.si a f t`
### Numeros
Nos pone:
* `0 = λf.λx.x` (`0: f↦id`)
* `1 = λf.λx.f x` (`1: f↦f`)
* `2 = λf.λx.f(f x)` (`2: f↦f⚬f`)
Cum mente generale, successore de numero `n` es `S n = λf.λx.f((n f) x)`
(`n+1: f↦f⚬fⁿ`). Id es **`n` est functione que da `fⁿ` ex functione `f`**.
Postremo additione es `λab.(a S)b`
## Ut progrede
### In lingua anglo
1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf) per Raúl Roja
2. [The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html), CS 312 Recitation 26

146
lsf/latex-lsf.html.markdown Normal file
View File

@ -0,0 +1,146 @@
---
language: latex
lang: lsf
contributors:
- ["Chaitanya Krishna Ande", "http://icymist.github.io"]
- ["Colton Kohnke", "http://github.com/voltnor"]
- ["Sricharan Chiruvolu", "http://sricharan.xyz"]
translators:
- ["Victore Leve", "https://github.com/AcProIL"]
filename: learn-latex-lsf.tex
---
```tex
% Solo existe commentario monolinea, illo incipe cum charactere %
% LaTeX non es sicut MS Word aut OpenOffice: que scribe non es que obtine.
% Primo, scribe imperio (que semper incipe cum \) et secundo programma crea
% lima.
% Nos defini typo de document (id es articulo aut libro aut libello etc.).
% Optione muta quomodo programma age, per exemplo altore de littera.
\documentclass[12pt]{article}
% Deinde nos lista paccettos que nos vol ute. Es classe de imperio que alio
% utatore e scribe. Pote muta funda, geometria de pagina, etc. vel adde
% functionnalitate.
\usepackage{euler}
\usepackage{graphicx}
% Ultimo statione ante scribe documento es metadata id es titulo, auctore et
% tempore. Charactere ~ es spatio que non pote es secato.
\title{Disce LaTeX in~Y Minutos!}
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
\date{\today}
% Principio de documento
\begin{document}
\maketitle % Nos vol adfige metadata.
% Saepe nos adde breviario us describe texto.
\begin{abstract}
Hic es exmplo de documento sibre cum lingua de LaTeX.
\end{abstract}
% \section crea sectione cum titulo dato sicut sperato
\section{Introductione}
Traductione de hic cursu es importante.
\subsection{Methodo}
Iste parte non es utile.
\subsubsection{Methodo peculiare}
% \label da nomine ad parte ut post ute imperio de referentia \ref.
\label{subsec:metpec}
% Cum asteritco nos indice que nos non vol numero ante titulo de sectione.
\section*{Me non aestima numero…}
…sed de Peano aut de Church.
\section{Listas}
Que me debe scribe:
\begin{enumerate} % `enumerate` designa lista cum numeros contra `itemize`.
\item articulo,
\item libro,
\item cursu.
\end{enumerate}
\section{Mathematica}
Methematicas ute multo programma LaTeX ut communica suo decooperito.
Illo necessita symbolo multo instar de logica vel sagitta vel littera cum
accento.
% Fornula es in linea si nos scribe inter \( et \) (aut duo $) sed magno si
% nos ute \[ et \].
\(\forall n\in N_0\) % pro omne n in classe N₀
\[^{3}/_{4} = \frac{3}{4} < 1\] % ¾ < 1
Alphabeta graeco contine littera $\alpha$.
% Ut scribe equatione cum numero et nomine, existe circumiecto `equation`.
\begin{equation}
c^2 = a^2 + b^2
\label{eq:pythagoras}
\end{equation}
\begin{equation}
% Summa ab 1 ad n de numeros dimidio de n(n+1)
\sum_{i=1}^n i = \frac{n(n+1)}{2}
\end{equation}
\section{Figura}
% Nos adde imagine `right-triangle.png` cum latitudo de quinque centimetro,
% horizontaliter in centro et cum capite «Triangulo recto».
\begin{figure}
\centering
\includegraphics[width=5cm]{right-triangle.png}
\caption{Triangulo recto}
\label{fig:right-triangle}
\end{figure}
\subsection{Tabula}
\begin{table}
\caption{Título para la tabla.}
% Argumento de `tabular` es lineamente de columna.
% c: centro, l: sinistra, r: destra, | linea verticale
\begin{tabular}{c|cc}
Numero & B & C \\
\hline % linea horizontale
1 & et & aut \\
2 & atque & vel
\end{tabular}
\end{table}
\section{Stylo}
Texto pote es \textbf{crasso} et \textit{italico}!
\section{Texto puro}
% Circumiecto `verbatim` ignora imperio, nos saepe ute id pro monstra
% programma.
\begin{verbatim}
from math import tau, e
print(e ** tau)
\end{verbatim}
\section{Et plus!}
LaTeX habe facultate crea bibliographia, paritura, scaccarip… cum paccetto
dedicato.
\end{document}
```
Imperio ut conge documento es `pdflatex documento` in terminale.
## Ut progrede
### In lingua anglo
* [LaTeX tutorial](http://www.latex-tutorial.com/) per Claudio Vellage

1976
perl6.html.markdown
View File

File diff suppressed because it is too large Load Diff

2
pl-pl/bf-pl.html.markdown
View File

@ -7,7 +7,7 @@ contributors:
- ["Mathias Bynens", "http://mathiasbynens.be/"]
translators:
- ["Jakub Młokosiewicz", "https://github.com/hckr"]
- ["Mateusz Burniak", "https://gitbub.com/matbur"]
- ["Mateusz Burniak", "https://github.com/matbur"]
lang: pl-pl
---

22
pt-br/bash-pt.html.markdown
View File

@ -33,7 +33,7 @@ diretamente no shell.
# Exemplo simples de hello world:
echo Hello World!
# Cada comando começa com uma nova linha, ou após um ponto virgula:
# Cada comando começa com uma nova linha, ou após um ponto e vírgula:
echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha'
# A declaração de variáveis é mais ou menos assim
@ -41,14 +41,14 @@ Variavel="Alguma string"
# Mas não assim:
Variavel = "Alguma string"
# Bash interpretará Variavel como um comando e tentará executar e lhe retornar
# Bash interpretará Variavel como um comando e tentará executar e lhe retornará
# um erro porque o comando não pode ser encontrado.
# Ou assim:
Variavel= 'Alguma string'
# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornar
# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornará
# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel='
# é vista com uma declaração de variável valida apenas para o escopo do comando 'Uma string').
# é vista com uma declaração de variável válida apenas para o escopo do comando 'Uma string').
# Usando a variável:
echo $Variavel
@ -65,12 +65,12 @@ echo ${Variavel/Alguma/Uma}
# Substring de uma variável
Tamanho=7
echo ${Variavel:0:Tamanho}
# Isso retornará apenas os 7 primeiros caractéres da variável
# Isso retornará apenas os 7 primeiros caracteres da variável
# Valor padrão de uma variável
echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
# Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0.
# Note que isso apenas retornar o valor padrão e não mudar o valor da variável.
# Note que isso apenas retornará o valor padrão e não mudará o valor da variável.
# Variáveis internas
# Tem algumas variáveis internas bem uteis, como
@ -86,7 +86,7 @@ read Nome # Note que nós não precisamos declarar a variável
echo Ola, $Nome
# Nós temos a estrutura if normal:
# use 'man test' para mais infomações para as condicionais
# use 'man test' para mais informações para as condicionais
if [ $Nome -ne $USER ]
then
echo "Seu nome não é o seu username"
@ -109,7 +109,7 @@ then
echo "Isso vai rodar se $Nome é Daniela ou Jose."
fi
# Expressões são denotadas com o seguinte formato
# Expressões são escritas com o seguinte formato
echo $(( 10 + 5))
# Diferentemente das outras linguagens de programação, bash é um shell, então ele
@ -118,9 +118,9 @@ echo $(( 10 + 5))
ls
#Esse comando tem opções que controlam sua execução
ls -l # Lista todo arquivo e diretorio em linhas separadas
ls -l # Lista todo arquivo e diretório em linhas separadas
# Os resultados do comando anterior pode ser passado para outro comando como input.
# Os resultados do comando anterior podem ser passados para outro comando como input.
# O comando grep filtra o input com o padrão passado. É assim que listamos apenas
# os arquivos .txt no diretório atual:
ls -l | grep "\.txt"
@ -241,7 +241,7 @@ head -n 10 arquivo.txt
sort arquivo.txt
# reporta ou omite as linhas repetidas, com -d você as reporta
uniq -d arquivo.txt
# exibe apenas a primeira coluna após o caráctere ','
# exibe apenas a primeira coluna após o caractere ','
cut -d ',' -f 1 arquivo.txt
# substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex)
sed -i 's/okay/legal/g' file.txt

3
pt-br/c-pt.html.markdown
View File

@ -8,6 +8,7 @@ translators:
- ["João Farias", "https://github.com/JoaoGFarias"]
- ["Elton Viana", "https://github.com/eltonvs"]
- ["Cássio Böck", "https://github.com/cassiobsilva"]
- ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
lang: pt-br
filename: c-pt.el
---
@ -641,7 +642,7 @@ typedef void (*minha_função_type)(char *);
Este é *o* livro sobre C, escrito pelos criadores da linguagem. Mas cuidado - ele é antigo e contém alguns erros (bem,
ideias que não são mais consideradas boas) ou práticas ultrapassadas.
Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/).
Outra boa referência é [Learn C the hard way](http://learncodethehardway.org/c/).
Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com).

16
pt-br/clojure-macros-pt.html.markdown
View File

@ -13,15 +13,15 @@ do Clojure lhe dá acesso a toda a extensão da linguagem
para escrever rotinas de geração de código chamados "macros". Macros fornecem uma poderosa forma de adequar a linguagem
às suas necessidades.
Pórem Tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas
quando você precisar do controle sobre quando ou se os argumentos para um formulário será avaliado.
Pórem, tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas
quando você precisar de controle sobre quando ou se os argumentos de um formulário serão avaliados.
Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo em
[Clojure em Y Minutos](/docs/clojure/).
[Aprenda Clojure em Y Minutos](/docs/clojure/).
```clojure
;; Defina uma macro utilizando defmacro. Sua macro deve ter como saida uma lista que possa
;; ser avaliada como codigo Clojure.
;; Defina uma macro utilizando defmacro. Sua macro deve ter como saída uma lista que possa
;; ser avaliada como código Clojure.
;;
;; Essa macro é a mesma coisa que se você escrever (reverse "Hello World")
(defmacro my-first-macro []
@ -33,14 +33,14 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo
(macroexpand '(my-first-macro))
;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World")
;; Você pode avaliar o resultad de macroexpand diretamente:
;; Você pode avaliar o resultado de macroexpand diretamente:
(eval (macroexpand '(my-first-macro)))
; -> (\d \l \o \r \W \space \o \l \l \e \H)
;; mas você deve usar esse mais suscinto, sintax como de função:
;; mas você deve usar essa sintaxe mais sucinta e familiar a funções:
(my-first-macro) ; -> (\d \l \o \r \W \space \o \l \l \e \H)
;; Você pode tornar as coisas mais faceis pra você, utilizando a sintaxe de citação mais suscinta
;; Você pode tornar as coisas mais fáceis pra você, utilizando a sintaxe de citação mais suscinta
;; para criar listas nas suas macros:
(defmacro my-first-quoted-macro []
'(reverse "Hello World"))

598
pt-br/clojure-pt.html.markdown
View File

@ -5,12 +5,13 @@ contributors:
- ["Adam Bard", "http://adambard.com/"]
translators:
- ["Mariane Siqueira Machado", "https://twitter.com/mariane_sm"]
- ["Ygor Sad", "https://github.com/ysads"]
lang: pt-br
---
Clojure é uma linguagem da família do Lisp desenvolvida para a JVM (máquina virtual Java). Possui uma ênfase muito mais forte em [programação funcional] (https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional) pura do que Common Lisp, mas inclui diversas utilidades [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado a medida que isso se torna necessário.
Clojure é uma linguagem da família do Lisp desenvolvida para a JVM (máquina virtual Java). Possui uma ênfase muito mais forte em [programação funcional] (https://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional) pura do que Common Lisp, mas inclui diversos recursos [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) para lidar com estado e mutabilidade, caso isso seja necessário.
Essa combinação permite gerenciar processamento concorrente de maneira muito simples, e frequentemente de maneira automática.
Essa combinação permite gerenciar processamento concorrente de maneira muito simples - frequentemente, de modo automático.
(Sua versão de clojure precisa ser pelo menos 1.2)
@ -18,367 +19,552 @@ Essa combinação permite gerenciar processamento concorrente de maneira muito s
```clojure
; Comentários começam por ponto e vírgula
; Clojure é escrito em "forms", os quais são simplesmente
; listas de coisas dentro de parênteses, separados por espaços em branco.
; Código Clojure é escrito em formas - 'forms', em inglês. Tais estruturas são
; simplesmente listas de valores encapsuladas dentro de parênteses, separados por
; espaços em branco.
; O "reader" (leitor) de Clojure presume que o primeiro elemento de
; uma par de parênteses é uma função ou macro, e que os resto são argumentos.
; Ao interpretar um código em Clojure, o interpretador ou leitor - do inglês 'reader' - assume
; que o primeiro valor dentro de uma forma é uma função ou macro, de modo que os demais valores
; são seus argumentos. Isso se deve ao fato de que Clojure, por ser uma derivação de Lisp,
; usa notação prefixa (ou polonesa).
: A primeira chamada de um arquivo deve ser ns, para configurar o namespace (espaço de nomes)
; Num arquivo, a primeira chamada deve ser sempre para a função ns,
; que é responsável por definir em qual namespace o código em questão
; deve ser alocado
(ns learnclojure)
; Alguns exemplos básicos:
; str cria uma string concatenando seus argumentos
(str "Hello" " " "World") ; => "Hello World"
; Aqui, str é uma função e "Olá" " " e "Mundo" são seus argumentos. O que ela faz é criar
; uma string concatenando seus argumentos.
(str "Olá" " " "Mundo") ; => "Olá Mundo"
; Cálculos são feitos de forma direta e intuitiva
; Note que espaços em branco separam os argumentos de uma função. Opcionalmente vírgulas
; podem ser usadas, se você quiser.
(str, "Olá", " ", "Mundo") ; => "Olá Mundo"
; As operações matemáticas básicas usam os operadores de sempre
(+ 1 1) ; => 2
(- 2 1) ; => 1
(* 1 2) ; => 2
(/ 2 1) ; => 2
; Você pode comparar igualdade utilizando =
; Esses operadores aceitam um número arbitrário de argumentos
(+ 2 2 2) ; = 2 + 2 + 2 => 6
(- 5 1 1) ; = 5 - 1 - 1 => 3
(* 3 3 3 3) ; = 3 * 3 * 3 * 3 => 81
; Para verificar se dois valores são iguais, o operador = pode ser usado
(= 1 1) ; => true
(= 2 1) ; => false
; Negação para operações lógicas
(not true) ; => false
; Para saber se dois valores são diferentes
(not= 1 2) ; => true
(not (= 1 2)) ; => true
; Aninhar "forms" funciona como esperado
; Conforme vimos acima, é possível aninhar duas formas
(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
(* (- 3 2) (+ 1 2)) ; = (3 - 2) * (1 + 2) => 3
; Se a leitura ficar comprometida, as fórmulas também podem ser escritas em múltiplas linhas
(* (- 3 2)
(+ 1 2)) ; => 3
(*
(- 3 2)
(+ 1 2)) ; => 3
; Tipos
;;;;;;;;;;;;;
; Clojure usa os tipos de objetos de Java para booleanos, strings e números.
; Use `class` para inspecioná-los
(class 1) ; Literais Integer são java.lang.Long por padrão
(class 1.); Literais Float são java.lang.Double
(class ""); Strings são sempre com aspas duplas, e são java.lang.String
; Por ter interoperabilidade com Java, Clojure usa os tipos de objetos de Java para booleanos,
; strings e números. Para descobrir qual o tipo de um valor, você pode usar a função `class`:
(class 1234) ; Literais Integer são java.lang.Long por padrão
(class 1.50) ; Literais Float são java.lang.Double
(class "oi") ; Strings sempre usam aspas duplas e são java.lang.String
(class false) ; Booleanos são java.lang.Boolean
(class nil); O valor "null" é chamado nil
; Se você quiser criar um lista de literais, use aspa simples para
; ela não ser avaliada
'(+ 1 2) ; => (+ 1 2)
; (que é uma abreviação de (quote (+ 1 2)))
; Tenha cuidado, ao dividir valores inteiros:
(= (/ 1 2)
(/ 1.0 2.0)) ; => false
(class (/ 1 2)) ; => clojure.lang.Ratio
(class (/ 1.0 2.0)) ; => java.lang.Double
; Aqui temos uma diferença em relação a Java, pois valores nulos são representados por `nil`
(class nil) ; nil
; É possível avaliar uma lista com aspa simples
(eval '(+ 1 2)) ; => 3
; Coleções e sequências
;;;;;;;;;;;;;;;;;;;
; Listas são estruturas encadeadas, enquanto vetores são implementados como arrays.
; Listas e Vetores são classes Java também!
(class [1 2 3]); => clojure.lang.PersistentVector
(class '(1 2 3)); => clojure.lang.PersistentList
; Os dois tipos básicos de coleção são listas - "list" em inglês - e vetores - "vectors"
; no original. A principal diferença entre eles se
; dá pela implementação:
; - Vetores são implementados como arrays
; - Listas são listas ligadas
(class [1 2 3]) ; => clojure.lang.PersistentVector
(class '(1 2 3)) ; => clojure.lang.PersistentList
; Uma lista é escrita como (1 2 3), mas temos que colocar a aspa
; simples para impedir o leitor (reader) de pensar que é uma função.
; Também, (list 1 2 3) é o mesmo que '(1 2 3)
; Outra forma de declarar listas é usando a função list
(list 1 2 3) ; => '(1 2 3)
; "Coleções" são apenas grupos de dados
; Listas e vetores são ambos coleções:
; Clojure classifica conjuntos de dados de duas maneiras
; "Coleções" são grupos simples de dados
; Tanto listas quanto vetores são coleções:
(coll? '(1 2 3)) ; => true
(coll? [1 2 3]) ; => true
; "Sequências" (seqs) são descrições abstratas de listas de dados.
; Apenas listas são seqs.
; Sequências - ou seqs - são conjuntos de dados com avaliação "lazy"
; Apenas listas são seqs:
(seq? '(1 2 3)) ; => true
(seq? [1 2 3]) ; => false
; Um seq precisa apenas prover uma entrada quando é acessada.
; Portanto, já que seqs podem ser avaliadas sob demanda (lazy) -- elas podem definir séries infinitas:
(range 4) ; => (0 1 2 3)
(range) ; => (0 1 2 3 4 ...) (uma série infinita)
(take 4 (range)) ; (0 1 2 3)
; Ter avaliação lazy significa que uma seq somente precisa prover uma informação quando
; ela for requisitada. Isso permite às seqs representar listas infinitas.
(range) ; => (0 1 2 3 4 ...)
(cycle [1 2]) ; => (1 2 1 2 1 2 ...)
(take 4 (range)) ; => (0 1 2 3)
; Use cons para adicionar um item no início de uma lista ou vetor
; A função cons é usada para adicionar um item ao início de uma lista ou vetor:
(cons 4 [1 2 3]) ; => (4 1 2 3)
(cons 4 '(1 2 3)) ; => (4 1 2 3)
; Conj adiciona um item em uma coleção sempre do jeito mais eficiente.
; Para listas, elas inserem no início. Para vetores, é inserido no final.
; Já conj adiciona um item em uma coleção sempre do jeito mais eficiente.
; Em listas, isso significa inserir no início. Já em vetores, ao final.
(conj [1 2 3] 4) ; => [1 2 3 4]
(conj '(1 2 3) 4) ; => (4 1 2 3)
; Use concat para concatenar listas e vetores
; Concatenação de coleções pode ser feita usando concat. Note que ela sempre gera uma
; seq como resultado e está sujeita a problemas de perfomance em coleções grandes, por
; conta da natureza lazy das seqs.
(concat '(1 2) [3 4]) ; => (1 2 3 4)
(concat [1 2] '(3 4)) ; => (1 2 3 4)
; Use filter, map para interagir com coleções
; Outra forma de concatenar coleções é usando into. Ela não está sujeita a problemas
; com a avaliação lazy, mas o resultado final da ordem e do tipo dos argumentos passados
(into [1 2] '(3 4)) ; => [1 2 3 4]
(into '(1 2) [3 4]) ; => (4 3 1 2)
; Note que em into a ordem dos parâmetros influencia a coleção final.
(into [1 2] '(3 4)) ; => (1 2 3 4)
(into '(1 2) [3 4]) ; => (4 3 1 2)
; As funções filter e map podem ser usadas para interagir com as coleções. Repare que
; elas sempre retornam seqs, independentemente do tipo do seu argumento.
(map inc [1 2 3]) ; => (2 3 4)
(filter even? [1 2 3]) ; => (2)
(filter even? [1 2 3 4]) ; => (2 4)
; Use reduce para reduzi-los
(reduce + [1 2 3 4])
; = (+ (+ (+ 1 2) 3) 4)
; => 10
; Use reduce reduzir coleções a um único valor. Também é possível passar um argumento
; para o valor inicial das operações
(reduce + [1 2 3]) ; = (+ (+ (+ 1 2) 3) 4) => 10
(reduce + 10 [1 2 3 4]) ; = (+ (+ (+ (+ 10 1) 2) 3) 4) => 20
(reduce conj [] '(3 2 1)) ; = (conj (conj (conj [] 3) 2) 1) => [3 2 1]
; Reparou na semelhança entre listas e as chamadas de código Clojure? Isso se deve ao
; fato de que todo código clojure é escrito usando listas. É por isso que elas sempre
; são declaradas com o caracter ' na frente. Dessa forma o interpretador não tenta
; avaliá-las.
'(+ 2 3) ; cria uma lista com os elementos +, 2 e 3
(+ 2 3) ; o interpretador chama a função + passando como argumentos 2 e 3
; Note que ' é apenas uma abreviação para a função quote.
(quote (1 2 3)) ; => '(1 2 3)
; É possível passar uma lista para que o interpretador a avalie. Note que isso está
; sujeito ao primeiro elemento da lista ser um literal com um nome de uma função válida.
(eval '(+ 2 3)) ; => 5
(eval '(1 2 3)) ; dá erro pois o interpretador tenta chamar a função 1, que não existe
; Reduce pode receber um argumento para o valor inicial
(reduce conj [] '(3 2 1))
; = (conj (conj (conj [] 3) 2) 1)
; => [3 2 1]
; Funções
;;;;;;;;;;;;;;;;;;;;;
; Use fn para criar novas funções. Uma função sempre retorna
; sua última expressão.
(fn [] "Hello World") ; => fn
; Use fn para criar novas funções. Uma função sempre retorna sua última expressão.
(fn [] "Olá Mundo") ; => fn
; (É necessário colocar parênteses para chamá-los)
((fn [] "Hello World")) ; => "Hello World"
; Para executar suas funções, é preciso chamá-las, envolvendo-as em parênteses.
((fn [] "Olá Mundo")) ; => "Olá Mundo"
; Você pode atribuir valores a variáveis utilizando def
(def x 1)
x ; => 1
; Como isso não é muito prático, você pode nomear funções atribuindo elas a literais.
; Isso torna muito mais fácil chamá-las:
(def ola-mundo (fn [] "Olá Mundo")) ; => fn
(ola-mundo) ; => "Olá Mundo"
; Atribua uma função para uma var
(def hello-world (fn [] "Hello World"))
(hello-world) ; => "Hello World"
; Você pode abreviar esse processo usando defn:
(defn ola-mundo [] "Olá Mundo")
; Você pode abreviar esse processo usando defn
(defn hello-world [] "Hello World")
; Uma função pode receber uma lista de argumentos:
(defn ola
[nome]
(str "Olá " nome))
(ola "Jonas") ; => "Olá Jonas"
; O [] é uma lista de argumentos para um função.
(defn hello [name]
(str "Hello " name))
(hello "Steve") ; => "Hello Steve"
; É possível criar funções que recebam multivariadas, isto é, que aceitam números
; diferentes de argumentos:
(defn soma
([] 0)
([a] a)
([a b] (+ a b)))
; Você pode ainda usar essa abreviação para criar funcões:
(def hello2 #(str "Hello " %1))
(hello2 "Fanny") ; => "Hello Fanny"
(soma) ; => 0
(soma 1) ; => 1
(soma 1 2) ; => 3
; Vocé pode ter funções multi-variadic, isto é, com um número variável de argumentos
(defn hello3
([] "Hello World")
([name] (str "Hello " name)))
(hello3 "Jake") ; => "Hello Jake"
(hello3) ; => "Hello World"
; Funções podem agrupar argumentos extras em uma seq:
(defn conta-args
[& args]
(str "Você passou " (count args) " argumentos: " args))
(conta-args 1 2 3 4) ; => "Você passou 4 argumentos: (1 2 3 4)"
; Funções podem agrupar argumentos extras em uma seq
(defn count-args [& args]
(str "You passed " (count args) " args: " args))
(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
; Você pode misturar argumentos regulares e argumentos em seq:
(defn ola-e-conta
[nome & args]
(str "Olá " nome ", você passou " (count args) " argumentos extras"))
(ola-e-conta "Maria" 1 2 3 4) ; => "Olá Maria, você passou 4 argumentos extras"
; Você pode misturar argumentos regulares e argumentos em seq
(defn hello-count [name & args]
(str "Hello " name ", you passed " (count args) " extra args"))
(hello-count "Finn" 1 2 3)
; => "Hello Finn, you passed 3 extra args"
; Nos exemplos acima usamos def para associar nomes a funções, mas poderíamos usá-lo
; para associar nomes a quaisquer valores:
(def xis :x)
xis ; => :x
; Inclusive, tais literais podem possuir alguns caracteres não usuais em outras linguagens:
(def *num-resposta* 42)
(def conexao-ativa? true)
(def grito-de-medo! "AAAAAAA")
(def ->vector-vazio [])
; É possível, inclusive, criar apelidos a nomes que já existem:
(def somar! soma)
(somar! 41 1) ; => 42
; Uma forma rápida de criar funções é por meio de funções anônimas. Elas são ótimas
; para manipulação de coleções e seqs, já que podem ser passadas para map, filter
; e reduce. Nessas funções, % é substituído por cada um dos items na seq ou na coleção:
(filter #(not= % nil) ["Joaquim" nil "Maria" nil "Antônio"]) ; => ("Joaquim" "Maria" "Antônio")
(map #(* % (+ % 2)) [1 2]) ; => (3 8)
; Mapas
;;;;;;;;;;
; Hash maps e array maps compartilham uma mesma interface. Hash maps são mais
; rápidos para pesquisa mas não mantém a ordem da chave.
; Existem dois tipos de mapas: hash maps e array maps. Ambos compartilham uma mesma
; interface e funções. Hash maps são mais rápidos para retornar dados, mas não mantém
; as chaves ordenadas.
(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
; Arraymaps pode automaticamente se tornar hashmaps através da maioria das
; operações se eles ficarem grandes o suficiente, portanto não há necessida de
; se preocupar com isso.
; Clojure converte automaticamente array maps em hash maps, por meio da maioria das
; funções de manipulação de mapas, caso eles fiquem grandes o suficiente. Não é
; preciso se preocupar com isso.
;Mapas podem usar qualquer valor que se pode derivar um hash como chave
; Mapas podem usar qualquer valor em que se pode derivar um hash como chave,
; mas normalmente palavras-chave (keywords) são melhores.
; Keywords são como strings mas com algumas vantagens.
; Chaves podem ser qualquer valor do qual possa ser obtido um hash, mas normalmente
; usam-se keywords como chave, por possuírem algumas vantagens.
(class :a) ; => clojure.lang.Keyword
(def stringmap {"a" 1, "b" 2, "c" 3})
stringmap ; => {"a" 1, "b" 2, "c" 3}
; Keywords são como strings, porém, duas keywords de mesmo valor são sempre armazenadas
; na mesma posição de memória, o que as torna mais eficientes.
(identical? :a :a) ; => true
(identical? (String. "a") (String. "a")) ; => false
(def keymap {:a 1, :b 2, :c 3})
keymap ; => {:a 1, :c 3, :b 2}
(def mapa-strings {"a" 1 "b" 2 "c" 3})
mapa-strings ; => {"a" 1, "b" 2, "c" 3}
; A propósito, vírgulas são sempre tratadas como espaçoes em branco e não fazem nada.
(def mapa-keywords {:a 1 :b 2 :c 3})
mapa-keywords ; => {:a 1, :c 3, :b 2}
; Recupere o valor de um mapa chamando ele como uma função
(stringmap "a") ; => 1
(keymap :a) ; => 1
; Você pode usar um mapa como função para recuperar um valor dele:
(mapa-strings "a") ; => 1
(mapa-keywords :a) ; => 1
; Uma palavra-chave pode ser usada pra recuperar os valores de um mapa
(:b keymap) ; => 2
; Se a chave buscada for uma keyword, ela também pode ser usada como função para recuperar
; valores. Note que isso não funciona com strings.
(:b mapa-keywords) ; => 2
("b" mapa-strings) ; => java.lang.String cannot be cast to clojure.lang.IFn
; Não tente isso com strings
;("a" stringmap)
; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
; Se você buscar uma chave que não existe, Clojure retorna nil:
(mapa-strings "d") ; => nil
; Buscar uma chave não presente retorna nil
(stringmap "d") ; => nil
; Use assoc para adicionar novas chaves em um mapa.
(def mapa-keywords-estendido (assoc mapa-keywords :d 4))
mapa-keywords-estendido ; => {:a 1, :b 2, :c 3, :d 4}
; Use assoc para adicionar novas chaves para hash-maps
(def newkeymap (assoc keymap :d 4))
newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
; Mas lembre-se que tipos em Clojure são sempre imutáveis! Isso significa que o mapa
; inicial continua com as mesmas informações e um novo mapa, com mais dados, é criado
; a partir dele
mapa-keywords ; => {:a 1, :b 2, :c 3}
; Mas lembre-se, tipos em Clojure são sempre imutáveis!
keymap ; => {:a 1, :b 2, :c 3}
; assoc também pode ser usado para atualizar chaves:
(def outro-mapa-keywords (assoc mapa-keywords :a 0))
outro-mapa-keywords ; => {:a 0, :b 2, :c 3}
; Use dissoc para remover chaves
(dissoc keymap :a :b) ; => {:c 3}
(dissoc mapa-keywords :a :b) ; => {:c 3}
; Mapas também são coleções - mas não seqs!
(coll? mapa-keywords) ; => true
(seq? mapa-keywords) ; => false
; É possível usar filter, map e qualquer outra função de coleções em mapas.
; Porém a cada iteração um vetor no formato [chave valor] vai ser passado como
; argumento. Por isso é conveniente usar funções anônimas.
(filter #(odd? (second %)) mapa-keywords) ; => ([:a 1] [:c 3])
(map #(inc (second %)) mapa-keywords) ; => (2 3 4)
; Conjuntos
;;;;;;
(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
; Conjuntos são um tipo especial de coleções que não permitem elementos repetidos.
; Eles podem ser criados com #{} ou com a função set.
(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
; Adicione um membro com conj
(conj #{1 2 3} 4) ; => #{1 2 3 4}
; Note que nem sempre um set vai armazenar seus elementos na ordem esperada.
(def meu-conjunto #{1 2 3})
meu-conjunto ; => #{1 3 2}
; Remova um membro com disj
(disj #{1 2 3} 1) ; => #{2 3}
; Adição funciona normalmente com conj.
(conj meu-conjunto 4) ; => #{1 4 3 2}
; Test por existência usando set como função:
(#{1 2 3} 1) ; => 1
(#{1 2 3} 4) ; => nil
; Remoção, no entanto, precisa ser feita com disj:
(disj meu-conjunto 1) ; => #{3 2}
; Existem muitas outras funções no namespace clojure.sets
; Para saber se um elemento está em um conjunto, use-o como função. Nesse aspecto
; conjuntos funcionam de maneira semelhante a mapas.
(meu-conjunto 1) ; => 1
(meu-conjunto 4) ; => nil
; Forms úteis
; Condicionais e blocos
;;;;;;;;;;;;;;;;;
; Construções lógicas em Clojure são como macros, e
; se parecem com as demais
; Você pode usar um bloco let para criar um escopo local, no qual estarão disponíveis
; os nomes que você definir:
(let [a 1 b 2]
(+ a b)) ; => 3
(let [cores {:yellow "Amarelo" :blue "Azul"}
nova-cor :red
nome-cor "Vermelho"]
(assoc cores nova-cor nome-cor)) ; => {:yellow "Amarelo", :blue "Azul", :red "Vermelho"}
; Formas do tipo if aceitam três argumentos: a condição de teste, o comando a ser
; executado caso a condição seja positiva; e o comando para o caso de ela ser falsa.
(if true "a" "b") ; => "a"
(if false "a" "b") ; => "b"
; Opcionalmente você pode não passar o último argumento, mas se a condição for falsa
; o if vai retornar nil.
(if false "a") ; => nil
; Use let para criar um novo escopo associando sîmbolos a valores (bindings)
(let [a 1 b 2]
(> a b)) ; => false
; A forma if somente aceita um comando para ser executado em cada caso. Se você
; precisar executar mais comandos, você pode usar a função do:
(if true
(do
(print "Olá ")
(print "Mundo"))) ; => escreve "Olá Mundo" na saída
; Agrupe comandos juntos com "do"
(do
(print "Hello")
"World") ; => "World" (prints "Hello")
; Se você só deseja tratar o caso de sua condição ser verdadeira, o comando when é
; uma alternativa melhor. Seu comportamento é idêntico a um if sem condição negativa.
; Uma de suas vantagens é permitir a execução de vários comandos sem exigir do:
(when true "a") ; => "a"
(when true
(print "Olá ")
(print "Mundo")) ; => também escreve "Olá Mundo" na saída
; Funções tem um do implícito
(defn print-and-say-hello [name]
(print "Saying hello to " name)
(str "Hello " name))
(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
; Isso ocorre porque when possui um bloco do implícito. O mesmo se aplica a funções e
; comandos let:
(defn escreve-e-diz-xis
[nome]
(print "Diga xis, " nome)
(str "Olá " nome))
(escreve-e-diz-xis "João") ;=> "Olá João", além de escrever "Diga xis, João" na saída.
(let [nome "Nara"]
(print "Diga xis, " nome)
(str "Olá " nome)) ;=> "Olá João", além de escrever "Diga xis, João" na saída.
; Assim como let
(let [name "Urkel"]
(print "Saying hello to " name)
(str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
; Módulos
;;;;;;;;;;;;;;;
; Use "use" para poder usar todas as funções de um modulo
; Você pode usar a função use para carregar todas as funções de um módulo.
(use 'clojure.set)
; Agora nós podemos usar operações com conjuntos
; Agora nós podemos usar operações de conjuntos definidas nesse módulo:
(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
(difference #{1 2 3} #{2 3 4}) ; => #{1}
; Você pode escolher um subconjunto de funções para importar
(use '[clojure.set :only [intersection]])
; Use require para importar um módulo
; Isso porém não é uma boa prática pois dificulta saber de qual módulo cada função
; veio, além de expor o código a conflitos de nomes, caso dois módulos diferentes
; definam funções com o mesmo nome. A melhor forma de referenciar módulos é por meio
; de require:
(require 'clojure.string)
; Use / para chamar funções de um módulo
; Com isso podemos chamar as funções de clojure.string usando o operador /
; Aqui, o módulo é clojure.string e a função é blank?
(clojure.string/blank? "") ; => true
; Você pode dar para um módulo um nome mais curto no import
; Porém isso não é muito prático, por isso é possível dar para um nome mais curto para
; o módulo ao carregá-lo:
(require '[clojure.string :as str])
(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
; (#"" denota uma expressão regular literal)
(str/replace "alguém quer teste?" #"[aeiou]" str/upper-case) ; => "AlgUém qUEr tEstE?"
; Você pode usar require (e até "use", mas escolha require) de um namespace utilizando :require.
; Não é necessário usar aspa simples nos seus módulos se você usar desse jeito.
; Nesse exemplo usamos também a construção #"", que delimita uma expressão regular.
; É possível carregar outros módulos direto na definição do namespace. Note que nesse
; contexto não é preciso usar ' antes do vetor que define a importação do módulo.
(ns test
(:require
[clojure.string :as str]
[clojure.set :as set]))
; Operadores thread
;;;;;;;;;;;;;;;;;
; Uma das funções mais interessantes de clojure são os operadores -> e ->> - respectivamente
; thread-first e thread-last macros. Elas permitem o encadeamento de chamadas de funções,
; sendo perfeitas para melhorar a legibilidade em transformações de dados.
; -> usa o resultado de uma chamada como o primeiro argumento da chamada à função seguinte:
(-> " uMa StRIng com! aLG_uNs ##problemas. "
(str/replace #"[!#_]" "")
(str/replace #"\s+" " ")
str/trim ; se a função só aceitar um argumento, não é preciso usar parênteses
(str/lower-case)) ; => "uma string com alguns problemas."
; Na thread uma string com vários problemas foi passada como primeiro argumento à função
; str/replace, que criou uma nova string, a partir da original, porém somente com caracteres
; alfabéticos. Essa nova string foi passada como primeiro argumento para a chamada str/replace
; seguinte, que criou uma nova string sem espaços duplos. Essa nova string foi então passada
; como primeiro argumento para str/trim, que removeu espaços de seu início e fim, passando essa
; última string para str/lower-case, que a converteu para caracteres em caixa baixa.
; ->> é equivalente a ->, porém o retorno de cada função é passado como último argumento da
; função seguinte. Isso é particularmente útil para lidar com seqs, já que as funções que
; as manipulam sempre as tomam como último argumento.
(->> '(1 2 3 4)
(filter even?) ; => '(2 4)
(map inc) ; => '(3 5)
(reduce *)) ; => 15
; Java
;;;;;;;;;;;;;;;;;
; Java tem uma biblioteca padrão enorme e muito útil,
; portanto é importante aprender como utiliza-la.
; A biblioteca padrão de Java é enorme e possui inúmeros algoritmos e estruturas de
; dados já implementados. Por isso é bastante conveniente saber como usá-la dentro
; de Clojure.
; Use import para carregar um modulo java
; Use import para carregar um módulo Java.
(import java.util.Date)
; Você pode importar usando ns também.
; Você pode importar classes Java dentro de ns também:
(ns test
(:import java.util.Date
java.util.Calendar))
java.util.Calendar
java.util.ArrayList))
; Use o nome da clase com um "." no final para criar uma nova instância
(Date.) ; <a date object>
(def instante (Date.))
(class instante) => ; java.util.Date
; Use . para chamar métodos. Ou, use o atalho ".method"
(. (Date.) getTime) ; <a timestamp>
(.getTime (Date.)) ; exatamente a mesma coisa.
; Para chamar um método, use o operador . com o nome do método. Outra forma é
; usar simplesmente .<nome do método>
(. instante getTime) ; => retorna um inteiro representando o instante
(.getTime instante) ; => exatamente o mesmo que acima
; Use / para chamar métodos estáticos
(System/currentTimeMillis) ; <a timestamp> (o módulo System está sempre presente)
; Para chamar métodos estáticos dentro de classes Java, use /
(System/currentTimeMillis) ; => retorna um timestamp
; Note que não é preciso importar o módulo System, pois ele está sempre presente
; Caso queira submeter uma instância de uma classe mutável a uma sequência de operações,
; você pode usar a função doto. Ela é funciona de maneira semelhante à função -> - ou
; thread-first -, exceto pelo fato de que ele opera com valores mutáveis.
(doto (java.util.ArrayList.)
(.add 11)
(.add 3)
(.add 7)
(java.util.Collections/sort)) ; => #<ArrayList [3, 7, 11]>
; Use doto para pode lidar com classe (mutáveis) de forma mais tolerável
(import java.util.Calendar)
(doto (Calendar/getInstance)
(.set 2000 1 1 0 0 0)
.getTime) ; => A Date. set to 2000-01-01 00:00:00
; STM
;;;;;;;;;;;;;;;;;
; Software Transactional Memory é o mecanismo que Clojure usa para gerenciar
; estado persistente. Tem algumas construções em Clojure que o utilizam.
; Até aqui usamos def para associar nomes a valores. Isso, no entanto, possui algumas
; limitações, já que, uma vez definido essa associação, não podemos alterar o valor
; para o qual um nome aponta. Isso significa que nomes definidos com def não se
; comportam como as variáveis de outras linguagens.
; O atom é o mais simples. Passe pra ele um valor inicial
(def my-atom (atom {}))
; Para lidar com estado persistente e mutação de valores, Clojure usa o mecanismo Software
; Transactional Memory. O atom é o mais simples de todos. Passe pra ele um valor inicial e
; e ele criará um objeto que é seguro de atualizar:
(def atom-mapa (atom {}))
; Atualize o atom com um swap!.
; swap! pega uma função e chama ela com o valor atual do atom
; como primeiro argumento, e qualquer argumento restante como o segundo
(swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de (assoc {} :a 1)
(swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2)
; Para acessar o valor de um atom, você pode usar a função deref ou o operador @:
@atom-mapa ; => {}
(deref atom-mapa) ; => {}
; Use '@' para desreferenciar um atom e acessar seu valor
my-atom ;=> Atom<#...> (Retorna o objeto do Atom)
@my-atom ; => {:a 1 :b 2}
; Para mudar o valor de um atom, você deve usar a função swap!
; O que ela faz é chamar a função passada usando o atom como seu primeiro argumento. Com
; isso, ela altera o valor do atom de maneira segura.
(swap! atom-mapa assoc :a 1) ; Atribui a atom-mapa o resultado de (assoc {} :a 1)
(swap! atom-mapa assoc :b 2) ; Atribui a atom-mapa o resultado de (assoc {:a 1} :b 2)
; Abaixo um contador simples usando um atom
(def counter (atom 0))
(defn inc-counter []
(swap! counter inc))
; Observe que essas chamadas alteraram de fato o valor de atom-mapa. Seu novo valor é:
@atom-mapa ; => {:a 1 :b 2}
(inc-counter)
(inc-counter)
(inc-counter)
(inc-counter)
(inc-counter)
; Isso é diferente de fazer:
(def atom-mapa-2 (atom {}))
(def atom-mapa-3 (assoc @atom-mapa-2 :a 1))
@counter ; => 5
; Nesse exemplo, atom-mapa-2 permanece com o seu valor original e é gerado um novo mapa,
; atom-mapa-3, que contém o valor de atom-mapa-2 atualizado. Note que atom-mapa-3 é um
; simples mapa, e não uma instância de um atom
@atom-mapa-2 ; => {}
atom-mapa-3 ; => {:a 1}
; Outras construção STM são refs e agents.
(class atom-mapa-2) ; => clojure.lang.Atom
(class atom-mapa-3) ; => clojure.lang.PersistentArrayMap
; A ideia é que o valor do atom só será atualizado se, após ser executada a função passada
; para swap!, o atom ainda estiver com o mesmo valor de antes. Isto é, se durante a execução
; da função alguém alterar o valor do atom, swap! reexecutará a função recebida usando o valor
; atual do átoma como argumento.
; Isso é ótimo em situações nas quais é preciso garantir a consistência de algum valor - tais
; como sistemas bancários e sites de compra. Para mais exemplos e informações sobre outras
; construções STM:
; Exemplos e aplicações: https://www.braveclojure.com/zombie-metaphysics/
; Refs: http://clojure.org/refs
; Agents: http://clojure.org/agents
```
### Leitura adicional
Esse tutorial está longe de ser exaustivo, mas deve ser suficiente para que você possa começar.
Esse tutorial está longe de ser completo, mas deve ser suficiente para que você possa dar seus primeiros passos em Clojure.
Caso queira aprender mais:
Clojure.org tem vários artigos:
* clojure.org tem vários artigos:
[http://clojure.org/](http://clojure.org/)
Clojuredocs.org tem documentação com exemplos para quase todas as funções principais (pertecentes ao core):
* Brave Clojure possui um e-book que explora em profundidade diversos recursos de clojure, incluindo ótimos exemplos:
[https://www.braveclojure.com/](https://www.braveclojure.com/)
* clojuredocs.org tem documentação com exemplos para quase todas as funções principais (pertecentes ao core):
[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
4Clojure é um grande jeito de aperfeiçoar suas habilidades em Clojure/Programação Funcional:
* 4clojure possui alguns problemas e desafios interessantes para quem quiser treinar clojure ou programação funcional:
[http://www.4clojure.com/](http://www.4clojure.com/)
Clojure-doc.org tem um bom número de artigos para iniciantes:
* clojure-doc.org tem um bom número de artigos para iniciantes:
[http://clojure-doc.org/](http://clojure-doc.org/)
Clojure for the Brave and True é um livro de introdução ao Clojure e possui uma versão gratuita online:
[https://www.braveclojure.com/clojure-for-the-brave-and-true/](https://www.braveclojure.com/clojure-for-the-brave-and-true/)

45
pt-br/csharp-pt.html.markdown
View File

@ -78,15 +78,17 @@ namespace Learning.CSharp
short fooShort = 10000;
ushort fooUshort = 10000;
// Integer - 32-bit integer
// Integer - inteiro de 32 bits
int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
//Números por padrão são int ou uint, dependendo do tamanho.
// Long - 64-bit integer
long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
// Numbers default to being int or uint depending on size.
// L is used to denote that this variable value is of type long or ulong
// Números por padrão são int ou uint dependendo do tamanho.
// L é usado para denotar que o valor da variável é do tipo long ou ulong.
// Double - Double-precision 64-bit IEEE 754 Floating Point
double fooDouble = 123.4; // Precision: 15-16 digits
@ -308,25 +310,26 @@ on a new line! ""Wow!"", the masses cried";
}
///////////////////////////////////////
// Converting Data Types And Typecasting
// Convertendo Data Types e Typecasting
///////////////////////////////////////
// Converting data
// Convertendo dados
// Convert String To Integer
// this will throw a FormatException on failure
int.Parse("123");//returns an integer version of "123"
// Converter String para Integer
// try parse will default to type default on failure
// in this case: 0
// isso vai jogar um erro FormatException quando houver falha
int.Parse("123");//retorna uma verão em Integer da String "123"
// try parse vai ir por padrão para o typo default quando houver uma falha
// nesse caso: 0
int tryInt;
if (int.TryParse("123", out tryInt)) // Function is boolean
if (int.TryParse("123", out tryInt)) // Função booleana
Console.WriteLine(tryInt); // 123
// Convert Integer To String
// Convert class has a number of methods to facilitate conversions
// Converter Integer para String
// A classe Convert possuí métodos para facilitar as conversões
Convert.ToString(123);
// or
// ou
tryInt.ToString();
// Casting
@ -407,12 +410,12 @@ on a new line! ""Wow!"", the masses cried";
return result;
}
// You can narrow down the objects that are passed in
// Você pode pode restringir os objetos que são passados
public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
{
// We can iterate, since T is a IEnumerable
// Nos podemos iterar, desde que T seja um "IEnumerable"
foreach (var item in toPrint)
// Item is an int
// Item é um inteiro
Console.WriteLine(item.ToString());
}
@ -720,9 +723,9 @@ on a new line! ""Wow!"", the masses cried";
_speed -= decrement;
}
// properties get/set values
// when only data needs to be accessed, consider using properties.
// properties may have either get or set, or both
// propriedade recupera e/ou atribui valores (get/set).
// quando os dados precisam apenas ser acessados, considere o uso de propriedades.
// uma propriedade pode ter "get" ou "set", ou ambos.
private bool _hasTassles; // private variable
public bool HasTassles // public accessor
{

24
pt-br/css-pt.html.markdown
View File

@ -14,15 +14,15 @@ translators:
lang: pt-br
---
Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornara comum.
CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
CSS ajuda a manter a separação entre o conteúdo (HTML) e o visual de uma página web.
CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
Este guia foi escrito para CSS2, embora CSS3 esteja rapidamente se tornando popular.
**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa treinar em um playground CSS como [dabblet](http://dabblet.com/).
O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais.
```css
@ -42,7 +42,7 @@ Abaixo um elemento de exemplo:
<div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
*/
/* Você pode direciona-lo usando uma das suas classes CSS */
/* Você pode direcioná-lo usando uma das suas classes CSS */
.class1 { }
/* ou ambas as classes! */
@ -82,9 +82,9 @@ classe div.some [attr $ = 'ue'] {}
/* Você pode selecionar um elemento que é filho de outro elemento */
div.some-parent> .class-name {}
/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
   nivelar por baixo da árvore. */
/* Ou um descendente de um outro elemento. Os filhos são os descendentes diretos de
   seu elemento pai, apenas um nível abaixo da árvore. Pode ser quaisquer descendentes
   nivelados por baixo da árvore. */
div.some-parent class-name {}
/* Atenção: o mesmo seletor sem espaço tem um outro significado.
@ -97,7 +97,7 @@ div.some-parent.class-name {}
/* Ou qualquer irmão que o precede */
.i am-qualquer-elemento antes ~ .Este elemento {}
/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
/* Existem alguns seletores chamados pseudo classes que podem ser usados para selecionar um
   elemento quando ele está em um determinado estado */
/* Por exemplo, quando o cursor passa sobre um elemento */
@ -118,7 +118,7 @@ seletor:first-child {}
/* Qualquer elemento que é o último filho de seu pai */
seletor:last-child {}
/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
/* Assim como pseudo classes, pseudo elementos permitem que você estilize certas partes de um documento */
/* Corresponde a um primeiro filho virtual do elemento selecionado */
seletor::before {}
@ -127,7 +127,7 @@ seletor::before {}
seletor::after {}
/* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos
   elemento */
   os elementos */
* {} /* */ Todos os elementos
.parent * {} /* */ todos os descendentes
.parent> * {} /* */ todas as crianças
@ -181,7 +181,7 @@ seletor {
## Uso
Guardar uma folha de estilo CSS com a extensão `.css`.
Salvar uma folha de estilo CSS com a extensão `.css`.
```xml
<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o

2
pt-br/cypher-pt.html.markdown
View File

@ -101,7 +101,7 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
Crie consultas
---
Create a new node
Crie um novo nó
```
CREATE (a:Person {name:"Théo Gauchoux"})
RETURN a

2
pt-br/elisp-pt.html.markdown
View File

@ -111,7 +111,7 @@ filename: learn-emacs-lisp-pt.el
(hello)
;; `C-xC-e' => Hello, I am Bastien
;; Os parêntesis vazios na definição da função significam que ela
;; Os parênteses vazios na definição da função significam que ela
;; não aceita argumentos. Mas sempre utilizar `my-name' é um tédio!
;; Vamos dizer à função para aceitar um argumento (o argumento é
;; chamado "name"):

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

@ -41,7 +41,7 @@ o desenvolvimento deste paradigma de programação.
7 * 7 -- 7 vezes 7
7 / 7 -- 7 dividido por 7
-- Divisões não são inteiras, são fracionádas por padrão da linguagem
-- Divisões não são inteiras, são fracionadas por padrão da linguagem
28736 / 82374 -- 0.3488479374559934
@ -67,7 +67,7 @@ not False -- Nega uma falácia
7 > 7 -- 7 é maior que 7 ?
{- Haskell é uma linguagem que tem uma sintáxe bastante familiar na
{- Haskell é uma linguagem que tem uma sintaxe bastante familiar na
matemática, por exemplo em chamadas de funções você tem:
NomeFunção ArgumentoA ArgumentoB ArgumentoC ...

6
pt-br/javascript-pt.html.markdown
View File

@ -361,7 +361,7 @@ myObj.myFunc(); // = "Olá mundo!"
var myFunc = myObj.myFunc;
myFunc(); // = undefined
// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
// Inversamente, uma função pode ser atribuída à um objeto e ganhar a acesso
// através do `this`, até mesmo se ela não for chamada quando foi definida.
var myOtherFunc = function(){
return this.myString.toUpperCase();
@ -416,7 +416,7 @@ myNewObj.myNumber; // = 5
// vai olhar imediatamente para o seu prototype.
// Algumas implementações em JS deixam você acessar o objeto prototype com a
// propriedade mágica `__proto__`. Enquanto isso é util para explicar
// propriedade mágica `__proto__`. Enquanto isso é útil para explicar
// prototypes, não é parte de um padrão; nós vamos falar de algumas formas de
// usar prototypes depois.
@ -489,7 +489,7 @@ if (0){
}
// Entretanto, esses objetos encapsulados e as funções originais compartilham
// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
// um mesmo prototype, portanto você pode adicionar funcionalidades à uma string,
// por exemplo.
String.prototype.firstCharacter = function(){
return this.charAt(0);

2
pt-br/julia-pt.html.markdown
View File

@ -8,7 +8,7 @@ translators:
lang: pt-br
---
Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python.
Julia é uma linguagem homoicônica funcional focada na computação técnica. Ao mesmo tempo que ela tem todo o poder dos macros homoicônicos, funções de primeira classe, e controle de baixo nível, Julia é tão fácil para aprender e usar quanto Python.
Este tutorial é baseado no Julia 0.3.

2
pt-br/latex-pt.html.markdown
View File

@ -62,7 +62,7 @@ Svetlana Golubeva}
\newpage
% Muitos artigos de pesquisa possuem um resumo, e pode-se isar comandos
% Muitos artigos de pesquisa possuem um resumo, e pode-se usar comandos
% predefinidos para isso.
% Isso deve aparecer em sua ordem lógica, portanto, após o topo,
% mas antes das seções principais do corpo.

44
pt-br/markdown-pt.html.markdown
View File

@ -4,6 +4,7 @@ contributors:
- ["Dan Turkel", "http://danturkel.com/"]
translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"]
- ["Monique Baptista", "https://github.com/bfmonique"]
lang: pt-br
filename: learnmarkdown-pt.md
---
@ -11,23 +12,23 @@ filename: learnmarkdown-pt.md
Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e
escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e
Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e
puxar o projeto (pull request)
```md
<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é
um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML
<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é
um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML
em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
<!--Markdown também varia de implementação de um analisador para uma próxima.
<!--A maneira como o Markdown é analisado varia de software para software.
Este guia vai tentar esclarecer quando as características são universais, ou quando eles são
específico para um determinado parser -->
específico para um determinado interpretador -->
<!-- Cabeçalhos -->
<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
que deseja estar nesse elemento por um número de hashes (#) -->
que deseja estar nesse elemento por um número de cerquilhas (#) -->
# Isto é um cabeçalho <h1>
## Isto é um cabeçalho <h2>
### Isto é um cabeçalho <h3>
@ -65,7 +66,7 @@ uma ou múltiplas linhas em branco. -->
Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
Agora, eu estou no parágrado 2.
Agora, eu estou no parágrafo 2.
... Ainda continuo no parágrafo 2! :)
Eu estou no parágrafo três.
@ -77,19 +78,20 @@ Termino com dois espaços (destacar-me para vê-los).
Há um <br /> acima de mim!
<!-- Bloco de citações são fáceis e feito com o caractere >. -->
<!-- Bloco de citações são fáceis e feitos com o caractere >. -->
> Este é um bloco de citação. Você pode
> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença,
> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
> deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença,
> desde que eles começam com um `>`.
> Você também pode usar mais de um nível
>> De recuo?
> Como pura é isso?
<!-- Listas -->
<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens -->
<!-- As listas não ordenadas podem ser feitas usando asteriscos, soma ou hífens -->
* Item
* Item
@ -111,10 +113,10 @@ ou
1. Item um
2. Item dois
3. Tem três
3. Item três
<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
tornar os números em ordem, mas isso pode não ser uma boa idéia -->
<!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os
itens em ordem, mas isso pode não ser uma boa idéia -->
1. Item um
1. Item dois
@ -137,14 +139,14 @@ uma linha com quatro espaços ou uma guia -->
Isto é código
É assim, sacou?
<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo
<!-- Você pode também tabular (ou adicionar mais quatro espaços adicionais) para o recuo
dentro do seu código -->
my_array.each do |item|
puts item
end
<!-- Código embutido pode ser criada usando o caractere de crase ` -->
<!-- Código embutido pode ser criado usando o caractere de crase ` -->
John não sabia nem o que o função 'goto()' fazia!
@ -155,13 +157,13 @@ ruby! -->
def foobar
puts "Hello world!"
end
\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
\`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` -->
<-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe
destacando do idioma que você especificar após a ``` -->
<!-- Regra Horizontal (<hr />) -->
<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
<!-- Regras horizontais são facilmente adicionadas com três ou mais asteriscos ou hífens,
com ou sem espaços. -->
***
@ -175,7 +177,7 @@ o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênte
[Click aqui!](http://test.com/)
<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses -->
<!-- Você também pode adicionar um título para o link usando aspas dentro dos parênteses -->
[Click aqui!](http://test.com/ "Link para Test.com")

2
pt-br/pascal-pt.html.markdown
View File

@ -157,7 +157,7 @@ BEGIN
r := int; // um real pode receber um valor inteiro (mas não o contrário)
c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento]
str := 'hello' + 'world'; //concatenção de strings
str := 'hello' + 'world'; //concatenação de strings
my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento
por elemento (não o vetor inteiro de uma vez) }

2
pt-br/php-pt.html.markdown
View File

@ -20,7 +20,7 @@ Este documento descreve PHP 5+.
// Duas barras iniciam o comentário de uma linha.
# O hash (aka pound symbol) também inicia, mas // é mais comum.
# O hash (conhecido como "pound symbol") também inicia, mas // é mais comum.
/*
O texto envolto por barra-asterisco e asterisco-barra

36
pt-br/python3-pt.html.markdown
View File

@ -7,15 +7,16 @@ contributors:
- ["Zachary Ferguson", "http://github.com/zfergus2"]
translators:
- ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
- ["Monique Baptista", "https://github.com/bfmonique"]
lang: pt-br
filename: learnpython3-pt.py
---
Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
das mais populares linguagens em existência. Eu fiquei morrendo de amor
pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
das linguagens mais populares existentes. Eu me apaixonei por
Python por sua clareza sintática. É praticamente pseudocódigo executável.
Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
Opniões são muito bem vindas. Você pode encontrar-me em
[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
[serviço de e-mail do google].
@ -44,7 +45,7 @@ aprender o velho Python 2.7.
8 - 1 # => 7
10 * 2 # => 20
# Números inteiros por padrão, exceto na divisão, que retorna número
# Números são inteiros por padrão, exceto na divisão, que retorna número
# de ponto flutuante (float).
35 / 5 # => 7.0
@ -64,7 +65,7 @@ aprender o velho Python 2.7.
# Exponenciação (x**y, x elevado à potência y)
2**4 # => 16
# Determine a precedência usando parêntesis
# Determine a precedência usando parênteses
(1 + 3) * 2 # => 8
# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
@ -105,9 +106,8 @@ False or True # => True
1 < 2 < 3 # => True
2 < 3 < 2 # => False
# (operador 'is' e operador '==') is verifica se duas variáveis
# referenciam um mesmo objeto, mas == verifica se as variáveis
# apontam para o mesmo valor.
# 'is' verifica se duas variáveis representam o mesmo endereço
# na memória; '==' verifica se duas variáveis têm o mesmo valor
a = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4]
b = a # b referencia o que está referenciado por a
b is a # => True, a e b referenciam o mesmo objeto
@ -174,7 +174,7 @@ input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado e
# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
# Não é necessário declarar variáveis antes de iniciá-las
# È uma convenção usar letras_minúsculas_com_sublinhados
# É uma convenção usar letras_minúsculas_com_sublinhados
alguma_variavel = 5
alguma_variavel # => 5
@ -182,31 +182,31 @@ alguma_variavel # => 5
# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
alguma_variavel_nao_inicializada # Gera a exceção NameError
# Listas armazenam sequencias
# Listas armazenam sequências
li = []
# Você pode iniciar com uma lista com alguns valores
# Você pode iniciar uma lista com valores
outra_li = [4, 5, 6]
# Adicionar conteúdo ao fim da lista com append
# Adicione conteúdo ao fim da lista com append
li.append(1) # li agora é [1]
li.append(2) # li agora é [1, 2]
li.append(4) # li agora é [1, 2, 4]
li.append(3) # li agora é [1, 2, 4, 3]
# Remover do final da lista com pop
# Remova do final da lista com pop
li.pop() # => 3 e agora li é [1, 2, 4]
# Vamos colocá-lo lá novamente!
li.append(3) # li agora é [1, 2, 4, 3] novamente.
# Acessar uma lista da mesma forma que você faz com um array
# Acesse uma lista da mesma forma que você faz com um array
li[0] # => 1
# Acessa o último elemento
# Acessando o último elemento
li[-1] # => 3
# Acessando além dos limites gera um IndexError
# Acessar além dos limites gera um IndexError
li[4] # Gera o IndexError
# Você pode acessar vários elementos com a sintaxe de limites
# (É um limite fechado, aberto pra você que gosta de matemática.)
# Inclusivo para o primeiro termo, exclusivo para o segundo
li[1:3] # => [2, 4]
# Omitindo o final
li[2:] # => [4, 3]

8
pt-br/stylus-pt.html.markdown
View File

@ -132,7 +132,7 @@ body {
background-color: $primary-color
}
/* Apoś compilar ficaria assim: */
/* Após compilar ficaria assim: */
div {
display: block;
margin-left: auto;
@ -184,13 +184,13 @@ button
/* Funções
==============================*/
/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, menipular algum dado. */
/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, manipular algum dado. */
body {
background darken(#0088DD, 50%) // Escurece a cor #0088DD em 50%
}
/** Criando sua própria função */
/* Criando sua própria função */
somar(a, b)
a + b
@ -221,7 +221,7 @@ for <val-name> [, <key-name>] in <expression>
for $item in (1..2) /* Repete o bloco 12 vezes */
.col-{$item}
width ($item / 12) * 100% /* Calcula a largula pelo número da coluna*
width ($item / 12) * 100% /* Calcula a largura pelo número da coluna*
```

6
pt-br/typescript-pt.html.markdown
View File

@ -10,7 +10,7 @@ lang: pt-br
Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
É um super conjunto de JavaScript: todo o código JavaScript é TypeScript válido então ele pode ser adicionado diretamente a qualquer projeto. O compilador emite typescript JavaScript.
Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
@ -22,7 +22,7 @@ var isDone: boolean = false;
var lines: number = 42;
var name: string = "Anders";
// Quando é impossível saber, há o "Qualquer" tipo
// Quando é impossível saber, há o tipo "Qualquer"
var notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // Ok, definitivamente um boolean
@ -65,7 +65,7 @@ interface Person {
move(): void;
}
// Objeto que implementa a "Pessoa" Interface
// Objeto que implementa a Interface "Pessoa"
// Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades
var p: Person = { name: "Bobby", move: () => {} };
// Os objetos que têm a propriedade opcional:

2
pt-br/whip-pt.html.markdown
View File

@ -71,7 +71,7 @@ false
(= 1 1) ; => true
(equal 2 1) ; => false
; Por exemplo, inigualdade pode ser verificada combinando as funções
; Por exemplo, desigualdade pode ser verificada combinando as funções
;`not` e `equal`.
(! (= 2 1)) ; => true

10
pt-br/yaml-pt.html.markdown
View File

@ -11,10 +11,10 @@ lang: pt-br
YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
legível por seres humanos.
É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
É um superconjunto de JSON, com a adição de identação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
```yaml
# Commentários em YAML são como este.
# Comentários em YAML são como este.
###################
# TIPOS ESCALARES #
@ -33,7 +33,7 @@ chave com espaco: valor
porem: "Uma string, entre aspas."
"Chaves podem estar entre aspas tambem.": "É útil se você quiser colocar um ':' na sua chave."
# Seqüências de várias linhas podem ser escritos como um 'bloco literal' (utilizando |),
# Seqüências de várias linhas podem ser escritas como um 'bloco literal' (utilizando |),
# ou em um 'bloco compacto' (utilizando '>').
bloco_literal: |
Todo esse bloco de texto será o valor da chave 'bloco_literal',
@ -76,7 +76,7 @@ um_mapa_aninhado:
# também permite tipos de coleção de chaves, mas muitas linguagens de programação
# vão reclamar.
# Sequências (equivalente a listas ou arrays) semelhante à isso:
# Sequências (equivalente a listas ou arrays) semelhante a isso:
uma_sequencia:
- Item 1
- Item 2
@ -118,7 +118,7 @@ datetime: 2001-12-15T02: 59: 43.1Z
datetime_com_espacos 2001/12/14: 21: 59: 43.10 -5
Data: 2002/12/14
# A tag !!binary indica que a string é na verdade um base64-encoded (condificado)
# A tag !!binary indica que a string é na verdade um base64-encoded (codificado)
# representação de um blob binário.
gif_file: !!binary |
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5

17
python3.html.markdown
View File

@ -8,6 +8,7 @@ contributors:
- ["evuez", "http://github.com/evuez"]
- ["Rommel Martinez", "https://ebzzry.io"]
- ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
- ["caminsha", "https://github.com/caminsha"]
filename: learnpython3.py
---
@ -230,7 +231,7 @@ li[4] # Raises an IndexError
# (It's a closed/open range for you mathy types.)
li[1:3] # Return list from index 1 to 3 => [2, 4]
li[2:] # Return list starting from index 2 => [4, 3]
li[:3] # Return list from beginning uptil index 3 => [1, 2, 4]
li[:3] # Return list from beginning until index 3 => [1, 2, 4]
li[::2] # Return list selecting every second entry => [1, 4]
li[::-1] # Return list in reverse order => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
@ -466,8 +467,8 @@ prints:
1 cat
2 mouse
"""
list = ["dog", "cat", "mouse"]
for i, value in enumerate(list):
animals = ["dog", "cat", "mouse"]
for i, value in enumerate(animals):
print(i, value)
"""
@ -550,8 +551,14 @@ next(our_iterator) # => "three"
# After the iterator has returned all of its data, it raises a StopIteration exception
next(our_iterator) # Raises StopIteration
# You can grab all the elements of an iterator by calling list() on it.
list(filled_dict.keys()) # => Returns ["one", "two", "three"]
# We can also loop over it, in fact, "for" does this implicitly!
our_iterator = iter(our_iterable)
for i in our_iterator:
print(i) # Prints one, two, three
# You can grab all the elements of an iterable or iterator by calling list() on it.
list(our_iterable) # => Returns ["one", "two", "three"]
list(our_iterator) # => Returns [] because state is saved
####################################################

2412
raku.html.markdown Normal file
View File

File diff suppressed because it is too large Load Diff

2
reason.html.markdown
View File

@ -162,7 +162,7 @@ let maxPassengers = firstTrip.capacity;
/* If you define the record type in a different file, you have to reference the
filename, if trainJourney was in a file called Trips.re */
let secondTrip: Trips.firstTrip = {
let secondTrip: Trips.trainJourney = {
destination: "Paris",
capacity: 50,
averageSpeed: 150.0,

21
ru-ru/c++-ru.html.markdown
View File

@ -43,11 +43,11 @@ int main(int argc, char** argv)
// Аргументы командной строки, переданные в программу, хранятся в переменных
// argc и argv, так же, как и в C.
// argc указывает на количество аргументов,
// а argv является массивом C-подобных строк (char*), который непосредсвенно
// а argv является массивом C-подобных строк (char*), который непосредственно
// содержит аргументы.
// Первым аргументом всегда передается имя программы.
// argc и argv могут быть опущены, если вы не планируете работать с аругментами
// коммандной строки.
// argc и argv могут быть опущены, если вы не планируете работать с аргументами
// командной строки.
// Тогда сигнатура функции будет иметь следующий вид: int main()
// Возвращаемое значение 0 указывает на успешное завершение программы.
@ -162,7 +162,7 @@ void foo()
int main()
{
// Включает все функци из пространства имен Second в текущую область видимости.
// Включает все функции из пространства имен Second в текущую область видимости.
// Обратите внимание, что простой вызов foo() больше не работает,
// так как теперь не ясно, вызываем ли мы foo из пространства имен Second, или
// из глобальной области видимости.
@ -471,6 +471,7 @@ int main() {
// членам\методам без открытых или защищенных методов для этого.
class OwnedDog : public Dog {
public:
void setOwner(const std::string& dogsOwner);
// Переопределяем поведение функции печати для всех OwnedDog. Смотрите
@ -582,10 +583,10 @@ public:
// Во время компиляции компилятор фактически генерирует копии каждого шаблона
// с замещенными параметрами, поэтому полное определение класса должно присутствовать
// при каждом вызове. Именно поэтому классы шаблонов полностью определены в
// при каждом вызове. Именно поэтому шаблоны классов полностью определены в
// заголовочных файлах.
// Чтобы создать экземпляр класса шаблона на стеке:
// Чтобы создать экземпляр шаблона класса на стеке:
Box<int> intBox;
// и вы можете использовать его, как и ожидалось:
@ -605,7 +606,7 @@ boxOfBox.insert(intBox);
// http://en.wikipedia.org/wiki/Typename
// (да-да, это ключевое слово имеет собственную страничку на вики).
// Аналогичным образом, шаблонная функция:
// Аналогичным образом, шаблон функции:
template<class T>
void barkThreeTimes(const T& input)
{
@ -622,7 +623,7 @@ Dog fluffy;
fluffy.setName("Fluffy");
barkThreeTimes(fluffy); // Печатает "Fluffy barks" три раза.
//Параметры шаблона не должны быть классами:
// Параметры шаблона не должны быть классами:
template<int Y>
void printMessage() {
cout << "Learn C++ in " << Y << " minutes!" << endl;
@ -680,7 +681,7 @@ catch (...)
// некоторого ресурса неразрывно совмещается с инициализацией, а освобождение -
// с уничтожением объекта.
// Чтобы понять, на сколько это полезно,
// Чтобы понять, насколько это полезно,
// рассмотрим функцию, которая использует обработчик файлов в С:
void doSomethingWithAFile(const char* filename)
{
@ -796,7 +797,7 @@ void doSomethingWithAFile(const std::string& filename)
// - Контейнеры - стандартная библиотека связанных списков, векторы
// (т.е. самоизменяемые массивы), хэш-таблицы и все остальное автоматически
// уничтожается сразу же, когда выходит за пределы области видимости.
// - Ипользование мьютексов lock_guard и unique_lock
// - Использование мьютексов lock_guard и unique_lock
// Контейнеры с пользовательскими классами в качестве ключей требуют
// сравнивающих функций в самом объекте или как указатель на функцию. Примитивы

10
ru-ru/c-ru.html.markdown
View File

@ -77,7 +77,7 @@ int main() {
// sizeof(obj) возвращает размер объекта obj в байтах.
printf("%zu\n", sizeof(int)); // => 4 (на большинстве машин int занимает 4 байта)
// Если аргуметом sizeof будет выражение, то этот аргумент вычисляется
// Если аргументом sizeof будет выражение, то этот аргумент вычисляется
// ещё во время компиляции кода (кроме динамических массивов).
int a = 1;
// size_t это беззнаковый целый тип который использует как минимум 2 байта
@ -308,7 +308,7 @@ int main() {
// Это работает, потому что при обращении к имени массива возвращается
// указатель на первый элемент.
// Например, когда массив передаётся в функцию или присваивается указателю, он
// неяввно преобразуется в указатель.
// неявно преобразуется в указатель.
// Исключения: когда массив является аргументом для оператор '&':
int arr[10];
int (*ptr_to_arr)[10] = &arr; // &arr не является 'int *'!
@ -335,7 +335,7 @@ int main() {
// Работа с памятью с помощью указателей может давать неожиданные и
// непредсказуемые результаты.
printf("%d\n", *(my_ptr + 21)); // => Напечатает кто-нибудь-знает-что?
printf("%d\n", *(my_ptr + 21)); // => Напечатает кто-нибудь знает, что?
// Скорей всего программа вылетит.
// Когда вы закончили работать с памятью, которую ранее выделили, вам необходимо
@ -426,7 +426,7 @@ void function_1() {
// Можно получить доступ к структуре и через указатель
(*my_rec_ptr).width = 30;
// ... или ещё лучше: используйте оператор -> для лучшей читабельночти
// ... или ещё лучше: используйте оператор -> для лучшей читабельности
my_rec_ptr->height = 10; // то же что и "(*my_rec_ptr).height = 10;"
}
@ -471,7 +471,7 @@ void str_reverse_through_pointer(char *str_in) {
Лучше всего найдите копию [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
Это **книга** написанная создателями Си. Но будьте осторожны, она содержит идеи которые больше не считаются хорошими.
Другой хороший ресурс: [Learn C the hard way](http://c.learncodethehardway.org/book/).
Другой хороший ресурс: [Learn C the hard way](http://learncodethehardway.org/c/).
Если у вас появился вопрос, почитайте [compl.lang.c Frequently Asked Questions](http://c-faq.com).

4
ru-ru/go-ru.html.markdown
View File

@ -35,7 +35,7 @@ package main
// Import предназначен для указания зависимостей этого файла.
import (
"fmt" // Пакет в стандартной библиотеке Go
"io/ioutil" // Реализация функций ввод/ввывода.
"io/ioutil" // Реализация функций ввод/вывода.
"net/http" // Да, это веб-сервер!
"strconv" // Конвертирование типов в строки и обратно
m "math" // Импортировать math под локальным именем m.
@ -270,7 +270,7 @@ func learnErrorHandling() {
// c – это тип данных channel (канал), объект для конкурентного взаимодействия.
func inc(i int, c chan int) {
c <- i + 1 // когда channel слева, <- являтся оператором "отправки".
c <- i + 1 // когда channel слева, <- является оператором "отправки".
}
// Будем использовать функцию inc для конкурентной инкрементации чисел.

61
ru-ru/rust-ru.html.markdown
View File

@ -6,36 +6,33 @@ contributors:
- ["P1start", "http://p1start.github.io/"]
translators:
- ["Anatolii Kosorukov", "https://github.com/java1cprog"]
- ["Vasily Starostin", "https://github.com/Basil22"]
lang: ru-ru
---
Rust сочетает в себе низкоуровневый контроль над производительностью с удобством высокого уровня и предоставляет гарантии
безопасности.
Он достигает этих целей, не требуя сборщика мусора или времени выполнения, что позволяет использовать библиотеки Rust как замену
для C-библиотек.
Язык Rust разработан в Mozilla Research. Он сочетает низкоуровневую производительность с удобством языка высокого уровня и одновременно гарантирует безопасность памяти.
Первый выпуск Rust, 0.1, произошел в январе 2012 года, и в течение 3 лет развитие продвигалось настолько быстро, что до
недавнего времени использование стабильных выпусков было затруднено, и вместо этого общий совет заключался в том, чтобы
использовать последние сборки.
Он достигает этих целей без сборщика мусора или сложной среды выполнения, что позволяет использовать библиотеки Rust как прямую замену
C-библиотек. И наоборот, Rust умеет использовать готовые С-библиотеки как есть, без накладных расходов.
15 мая 2015 года был выпущен Rust 1.0 с полной гарантией обратной совместимости. Усовершенствования времени компиляции и
других аспектов компилятора в настоящее время доступны в ночных сборках. Rust приняла модель выпуска на поезде с регулярными выпусками каждые шесть недель. Rust 1.1 beta был доступен одновременно с выпуском Rust 1.0.
Первый выпуск Rust, 0.1, произошел в январе 2012 года. В течение 3 лет развитие продвигалось настолько быстро, что язык серьезно менялся без сохранения совместимости. Это дало возможность обкатать и отполировать синтаксис и возможности языка.
Хотя Rust является языком относительно низкого уровня, Rust имеет некоторые функциональные концепции, которые обычно
встречаются на языках более высокого уровня. Это делает Rust не только быстрым, но и простым и эффективным для ввода кода.
15 мая 2015 года был выпущен Rust 1.0 с полной гарантией обратной совместимости. Сборка поставляется в трех вариантах: стабильная версия, бета-версия, ночная версия. Все нововведения языка сперва обкатываются на ночной и бета-версиях, и только потом попадают в стабильную. Выход очередной версии происходит раз в 6 недель. В 2018 году вышло второе большое обновление языка, добавившее ему новых возможностей.
Хотя Rust является языком относительно низкого уровня, он имеет все возможности высокоуровневых языков: процедурное, объектное, функциональное, шаблонное и другие виды программирования. На данный момент Rust является одним из самых мощных (а может быть и самым) по возможностям среди статически типизированных языков. Это делает Rust не только быстрым, но и простым и эффективным для разработки сложного кода.
```rust
// Это однострочный комментарии
// Это однострочный комментарий
//
/// Так выглядит комментарий для документации
/// # Examples
///
///
/// ```
/// let seven = 7
///
/// ```
///////////////
// 1. Основы //
@ -63,10 +60,9 @@ fn main() {
let y: i32 = 13i32;
let f: f64 = 1.3f64;
// Автоматическое выявление типа данных
// Автоматическое выведение типа данных
// В большинстве случаев компилятор Rust может вычислить
// тип переменной, поэтому
// вам не нужно писать явные аннотации типа.
// тип переменной, поэтому вам не нужно явно указывать тип.
let implicit_x = 1;
let implicit_f = 1.3;
@ -87,12 +83,11 @@ fn main() {
// Печать на консоль
println!("{} {}", f, x); // 1.3 hello world
// `String` – изменяемя строка
// `String` – изменяемая строка
let s: String = "hello world".to_string();
// Строковый срез - неизменяемый вид в строки
// Это в основном неизменяемая пара указателей на строку -
// Это указатель на начало и конец строкового буфера
// Строковый срез - неизменяемое представление части строки
// Представляет собой пару из указателя на начало фрагмента и его длины
let s_slice: &str = &s;
@ -130,7 +125,7 @@ fn main() {
// 2. Типы //
//////////////
// Struct
// Структура
struct Point {
x: i32,
y: i32,
@ -154,6 +149,8 @@ fn main() {
let up = Direction::Up;
// Перечисление с полями
// В отличие от C и C++ компилятор автоматически следит за тем,
// какой именно тип хранится в перечислении.
enum OptionalI32 {
AnI32(i32),
Nothing,
@ -175,7 +172,7 @@ fn main() {
// Методы //
impl<T> Foo<T> {
fn get_bar(self) -> T {
fn get_bar(self) -> T {
self.bar
}
}
@ -198,9 +195,9 @@ fn main() {
let another_foo = Foo { bar: 1 };
println!("{:?}", another_foo.frobnicate()); // Some(1)
/////////////////////////
// 3. Поиск по шаблону //
/////////////////////////
/////////////////////////////////
// 3. Сопоставление по шаблону //
/////////////////////////////////
let foo = OptionalI32::AnI32(1);
match foo {
@ -223,9 +220,9 @@ fn main() {
println!("The second number is Nothing!"),
}
/////////////////////
//////////////////////////////////////////////
// 4. Управление ходом выполнения программы //
/////////////////////
//////////////////////////////////////////////
// `for` loops/iteration
let array = [1, 2, 3];
@ -233,7 +230,7 @@ fn main() {
println!("{}", i);
}
// Отрезки
// Диапазоны
for i in 0u32..10 {
print!("{} ", i);
}
@ -266,12 +263,12 @@ fn main() {
break;
}
/////////////////////////////////
//////////////////////////////////
// 5. Защита памяти и указатели //
/////////////////////////////////
//////////////////////////////////
// Владеющий указатель – такой указатель может быть только один
// Это значит, что при вызоде из блока переменная автоматически становится недействительной.
// Это значит, что при выходе из блока переменная автоматически становится недействительной.
let mut mine: Box<i32> = Box::new(3);
*mine = 5; // dereference
// Здесь, `now_its_mine` получает во владение `mine`. Т.е. `mine` была перемещена.

2
ru-ru/yaml-ru.html.markdown
View File

@ -24,7 +24,7 @@ YAML как язык сериализации данных предназнач
# Скалярные величины #
######################
# Наш корневой объект (который продолжается для всего документа) будет соответствовать
# Наш корневой объект (который продолжается до конца документа) будет соответствовать
# типу map, который в свою очередь соответствует словарю, хешу или объекту в других языках.
key: value
another_key: Другое значение ключа.

11
ruby.html.markdown
View File

@ -23,6 +23,15 @@ contributors:
```ruby
# This is a comment
=begin
This is a multi-line comment.
The beginning line must start with "=begin"
and the ending line must start with "=end".
You can do this, or start each line in
a multi-line comment with the # character.
=end
# In Ruby, (almost) everything is an object.
# This includes numbers...
3.class #=> Integer
@ -410,7 +419,7 @@ def guests(&block)
end
# The 'call' method on the Proc is similar to calling 'yield' when a block is
# present. The arguments passed to 'call' will be forwarded to the block as arugments.
# present. The arguments passed to 'call' will be forwarded to the block as arguments.
guests { |n| "You have #{n} guests." }
# => "You have 4 guests."

41
sql.html.markdown
View File

@ -9,14 +9,14 @@ Structured Query Language (SQL) is an ISO standard language for creating and wor
Implementations typically provide a command line prompt where you can enter the commands shown here interactively, and they also offer a way to execute a series of these commands stored in a script file. (Showing that you’re done with the interactive prompt is a good example of something that isn’t standardized--most SQL implementations support the keywords QUIT, EXIT, or both.)
Several of these sample commands assume that the [MySQL employee sample database](https://dev.mysql.com/doc/employee/en/) available on [github](https://github.com/datacharmer/test_db) has already been loaded. The github files are scripts of commands, similar to the relevant commands below, that create and populate tables of data about a fictional company’s employees. The syntax for running these scripts will depend on the SQL implementation you are using. A utility that you run from the operating system prompt is typical.
Several of these sample commands assume that the [MySQL employee sample database](https://dev.mysql.com/doc/employee/en/) available on [github](https://github.com/datacharmer/test_db) has already been loaded. The github files are scripts of commands, similar to the relevant commands below, that create and populate tables of data about a fictional company’s employees. The syntax for running these scripts will depend on the SQL implementation you are using. A utility that you run from the operating system prompt is typical.
```sql
-- Comments start with two hyphens. End each command with a semicolon.
-- SQL is not case-sensitive about keywords. The sample commands here
-- follow the convention of spelling them in upper-case because it makes
-- follow the convention of spelling them in upper-case because it makes
-- it easier to distinguish them from database, table, and column names.
-- Create and delete a database. Database and table names are case-sensitive.
@ -26,47 +26,47 @@ DROP DATABASE someDatabase;
-- List available databases.
SHOW DATABASES;
-- Use a particular existing database.
-- Use a particular existing database.
USE employees;
-- Select all rows and columns from the current database's departments table.
-- Default activity is for the interpreter to scroll the results on your screen.
-- Default activity is for the interpreter to scroll the results on your screen.
SELECT * FROM departments;
-- Retrieve all rows from the departments table,
-- but only the dept_no and dept_name columns.
-- Retrieve all rows from the departments table,
-- but only the dept_no and dept_name columns.
-- Splitting up commands across lines is OK.
SELECT dept_no,
dept_name FROM departments;
-- Retrieve all departments columns, but just 5 rows.
-- Retrieve all departments columns, but just 5 rows.
SELECT * FROM departments LIMIT 5;
-- Retrieve dept_name column values from the departments
-- table where the dept_name value has the substring 'en'.
-- table where the dept_name value has the substring 'en'.
SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
-- Retrieve all columns from the departments table where the dept_name
-- column starts with an 'S' and has exactly 4 characters after it.
-- column starts with an 'S' and has exactly 4 characters after it.
SELECT * FROM departments WHERE dept_name LIKE 'S____';
-- Select title values from the titles table but don't show duplicates.
SELECT DISTINCT title FROM titles;
-- Same as above, but sorted (case-sensitive) by the title values.
-- Same as above, but sorted (case-sensitive) by the title values.
SELECT DISTINCT title FROM titles ORDER BY title;
-- Show the number of rows in the departments table.
SELECT COUNT(*) FROM departments;
-- Show the number of rows in the departments table that
-- have 'en' as a substring of the dept_name value.
-- have 'en' as a substring of the dept_name value.
SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
-- A JOIN of information from multiple tables: the titles table shows
-- who had what job titles, by their employee numbers, from what
-- A JOIN of information from multiple tables: the titles table shows
-- who had what job titles, by their employee numbers, from what
-- date to what date. Retrieve this information, but instead of the
-- employee number, use the employee number as a cross-reference to
-- employee number, use the employee number as a cross-reference to
-- the employees table to get each employee's first and last name
-- instead. (And only get 10 rows.)
@ -85,12 +85,12 @@ WHERE TABLE_TYPE='BASE TABLE';
-- for how you specify the columns, such as their datatypes.
CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
-- Insert a row of data into the table tablename1. This assumes that the
-- table has been defined to accept these values as appropriate for it.
-- Insert a row of data into the table tablename1. This assumes that the
-- table has been defined to accept these values as appropriate for it.
INSERT INTO tablename1 VALUES('Richard','Mutt');
-- In tablename1, change the fname value to 'John'
-- for all rows that have an lname value of 'Mutt'.
-- for all rows that have an lname value of 'Mutt'.
UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
-- Delete rows from the tablename1 table
@ -100,6 +100,11 @@ DELETE FROM tablename1 WHERE lname like 'M%';
-- Delete all rows from the tablename1 table, leaving the empty table.
DELETE FROM tablename1;
-- Remove the entire tablename1 table.
-- Remove the entire tablename1 table.
DROP TABLE tablename1;
```
## Further Reading
* [Codecademy - SQL](https://www.codecademy.com/learn/learn-sql) A good introduction to SQL in a "learn by doing it" format.
* [Database System Concepts](https://www.db-book.com) book's Chapter 3 - Introduction to SQL has an in depth explanation of SQL concepts.

56
swift.html.markdown
View File

@ -91,7 +91,7 @@ let multiLineString = """
This is a multi-line string.
It's called that because it takes up multiple lines (wow!)
Any indentation beyond the closing quotation marks is kept, the rest is discarded.
You can include " or "" in multi-line strings because the delimeter is three "s.
You can include " or "" in multi-line strings because the delimiter is three "s.
"""
// Arrays
@ -159,12 +159,12 @@ let `class` = "keyword"
or contains nil (no value) to indicate that a value is missing.
Nil is roughly equivalent to `null` in other languages.
A question mark (?) after the type marks the value as optional of that type.
If a type is not optional, it is guaranteed to have a value.
Because Swift requires every property to have a type, even nil must be
explicitly stored as an Optional value.
Optional<T> is an enum, with the cases .none (nil) and .some(T) (the value)
*/
@ -178,7 +178,7 @@ let someOptionalString4 = String?.none //nil
To access the value of an optional that has a value, use the postfix
operator !, which force-unwraps it. Force-unwrapping is like saying, "I
know that this optional definitely has a value, please give it to me."
Trying to use ! to access a non-existent optional value triggers a
runtime error. Always make sure that an optional contains a non-nil
value before using ! to force-unwrap its value.
@ -194,7 +194,7 @@ if someOptionalString != nil {
// Swift supports "optional chaining," which means that you can call functions
// or get properties of optional values and they are optionals of the appropriate type.
// You can even do this multiple times, hence the name "chaining."
let empty = someOptionalString?.isEmpty // Bool?
// if-let structure -
@ -370,7 +370,7 @@ func say(_ message: String) {
}
say("Hello")
// Default parameters can be ommitted when calling the function.
// Default parameters can be omitted when calling the function.
func printParameters(requiredParameter r: Int, optionalParameter o: Int = 10) {
print("The required parameter was \(r) and the optional parameter was \(o)")
}
@ -443,7 +443,7 @@ func testGuard() {
return // guard statements MUST exit the scope that they are in.
// They generally use `return` or `throw`.
}
print("number is \(aNumber)")
}
testGuard()
@ -564,7 +564,7 @@ enum Furniture {
case desk(height: Int)
// Associate with String and Int
case chair(String, Int)
func description() -> String {
//either placement of let is acceptable
switch self {
@ -591,15 +591,15 @@ print(chair.description()) // "Chair of Foo with 40 cm"
- Define initializers to set up their initial state
- Be extended to expand their functionality beyond a default implementation
- Conform to protocols to provide standard functionality of a certain kind
Classes have additional capabilities that structures don't have:
- Inheritance enables one class to inherit the characteristics of another.
- Type casting enables you to check and interpret the type of a class instance at runtime.
- Deinitializers enable an instance of a class to free up any resources it has assigned.
- Reference counting allows more than one reference to a class instance.
Unless you need to use a class for one of these reasons, use a struct.
Structures are value types, while classes are reference types.
*/
@ -607,7 +607,7 @@ print(chair.description()) // "Chair of Foo with 40 cm"
struct NamesTable {
let names: [String]
// Custom subscript
subscript(index: Int) -> String {
return names[index]
@ -629,7 +629,7 @@ class Shape {
class Rect: Shape {
var sideLength: Int = 1
// Custom getter and setter property
var perimeter: Int {
get {
@ -640,16 +640,16 @@ class Rect: Shape {
sideLength = newValue / 4
}
}
// Computed properties must be declared as `var`, you know, cause' they can change
var smallestSideLength: Int {
return self.sideLength - 1
}
// Lazily load a property
// subShape remains nil (uninitialized) until getter called
lazy var subShape = Rect(sideLength: 4)
// If you don't need a custom getter and setter,
// but still want to run code before and after getting or setting
// a property, you can use `willSet` and `didSet`
@ -659,19 +659,19 @@ class Rect: Shape {
print(someIdentifier)
}
}
init(sideLength: Int) {
self.sideLength = sideLength
// always super.init last when init custom properties
super.init()
}
func shrink() {
if sideLength > 0 {
sideLength -= 1
}
}
override func getArea() -> Int {
return sideLength * sideLength
}
@ -703,13 +703,13 @@ class Circle: Shape {
override func getArea() -> Int {
return 3 * radius * radius
}
// Place a question mark postfix after `init` is an optional init
// which can return nil
init?(radius: Int) {
self.radius = radius
super.init()
if radius <= 0 {
return nil
}
@ -813,7 +813,7 @@ for _ in 0..<10 {
- Internal: Accessible and subclassible in the module it is declared in.
- Fileprivate: Accessible and subclassible in the file it is declared in.
- Private: Accessible and subclassible in the enclosing declaration (think inner classes/structs/enums)
See more here: https://docs.swift.org/swift-book/LanguageGuide/AccessControl.html
*/
@ -878,11 +878,11 @@ extension Int {
var doubled: Int {
return self * 2
}
func multipliedBy(num: Int) -> Int {
return num * self
}
mutating func multiplyBy(num: Int) {
self *= num
}
@ -965,18 +965,18 @@ func fakeFetch(value: Int) throws -> String {
guard 7 == value else {
throw MyError.reallyBadValue(msg: "Some really bad value")
}
return "test"
}
func testTryStuff() {
// assumes there will be no error thrown, otherwise a runtime exception is raised
let _ = try! fakeFetch(value: 7)
// if an error is thrown, then it proceeds, but if the value is nil
// it also wraps every return value in an optional, even if its already optional
let _ = try? fakeFetch(value: 7)
do {
// normal try operation that provides error handling via `catch` block
try fakeFetch(value: 1)

42
ta_in/css-ta.html.markdown
View File

@ -233,6 +233,48 @@ css முன்னுரிமை பின்வருமாறு
* `B` இது அடுத்தது.
* `D` இதுவே கடைசி .
## Media Queries [மீடியா குரிஸ்]
CSS மீடியா குரிஸ் CSS 3 அம்சங்கள். பயன்படுத்தும் கணினி, கைபேசி அல்லது சாதனத்தின் பிஸேல் டென்சிட்டிக்கு ஏற்றவாறு மீடியா குரிஸ் விதிகளை பயன்படுத்தலாம்.
```css
/* அனைத்து டேவிஸ்களுக்கும் பொதுவான விதி */
h1 {
font-size: 2em;
color: white;
background-color: black;
}
/* பிரிண்ட் செய்யும்போது h1 கலர் மாற்ற */
@media print {
h1 {
color: black;
background-color: white;
}
}
/* 480 பிஸேல்ளுக்கு மேல் சிகிரீன் அளவு உள்ள சாதனத்தில் எழுத்து அளவு மிகை படுத்த */
@media screen and (min-width: 480px) {
h1 {
font-size: 3em;
font-weight: normal;
}
}
```
மீடியா குரிஸ் வழங்கும் அம்சங்கள் :
`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. இவையுள் பெரும்பான்மை `min-` அல்லது `max-` வுடன் பயன்படுத்தலாம் .
`resolution` பழைய சாதனங்களில் பயன்படாது, எனவே `device-pixel-ratio` பயன்படுத்தவும்.
பல கைபேசி மற்றும் கணினிகள், வீடு கணினி திரை அளவு காட்ட முற்படும். எனவே `viewport` மெட்டா டேக் பயன்படுத்தவும்.
```html
<head>
<meta name="viewport" content="width=device-width; initial-scale=1.0">
</head>
```
## css அம்சங்களின் பொருந்தகூடிய தன்மை
பெரும்பாலான css 2 வின் அம்சங்கள் எல்லா உலாவிகளிலும் , கருவிகளிலும் உள்ளன. ஆனால் முன்கூட்டியே அந்த அம்சங்களை பரிசோதிப்பது நல்லது.

52
ta_in/xml-ta.html.markdown
View File

@ -5,6 +5,7 @@ contributors:
- ["João Farias", "https://github.com/JoaoGFarias"]
translators:
- ["Rasendran Kirushan", "https://github.com/kirushanr"]
- ["Sridhar Easwaran", "https://github.com/sridhareaswaran"]
lang: in-ta
---
@ -14,6 +15,57 @@ XML ஆனது ஒரு கட்டமைப்பு மொழி ஆகு
HTML போல் அன்றி , XML ஆனது தகவலை மட்டும் கொண்டு செல்ல்கிறது
## சில வரையறை மற்றும் முன்னுரை
பல கூறுகளால் அமைக்கப்பட்டது. ஒவொரு கூறுகளிலும் அட்ட்ரிபூட்க்கள் இருக்கும், அவை அந்தந்த கூறுகளை வரையறுக்க பயன்படும். மேலும் அந்த கூறுகளை தகவல் அல்லது கிளை கூறுகள் இருக்கலாம். அணைத்து கோப்புகளிலும் ரூட்/ஆரம்ப கூறு இருக்கும், அது தனக்குள் கிளை கூறுகளை கொண்டுருக்கும்.
XML பாகுபடுத்தி மிகவும் கண்டிப்பான வீதிகளைக்கொண்டது. [XML தொடரியல் விதிகளை அறிய] (http://www.w3schools.com/xml/xml_syntax.asp).
```xml
<!-- இது ஒரு XML குறிப்ப -->
<!-- குறிப்புக்கள்
பலவரி இருக்கலாம் -->
<!-- கூறுகள்/Elements -->
<!-- Element எனப்படுவது அடிப்படை கூறு. அவை இருவகைப்பாடு. காலியான கூறு: -->
<element1 attribute="value" /> <!-- காலியான கூறு - உள்ளடக்கம் இல்லாதது -->
<!-- மற்றும் காலி-இல்லாத கூறு : -->
<element2 attribute="value">Content</element2>
<!-- கூற்றின் பெயர் எழுத்துக்கள் மற்றும் எண் கொண்டு மட்டுமே இருக்கவேண்டும்.. -->
<empty /> <!-- காலியான கூறு - உள்ளடக்கம் இல்லாதது -->
<notempty> <!-- காலி-இல்லாத கூற - துவக்கம் -->
<!-- உள்ளடக்கம் -->
</notempty> <!-- முடிவு -->
<!-- கூற்றின் பெயர்கள் எழுத்து வடிவுணர்வு கொண்டது-->
<element />
<!-- ஓட்றது அல்ல -->
<eLEMENT />
<!-- Attributes/பண்புகளை -->
<!-- Attribute ஒரு மதிப்பு இணை -->
<element attribute="value" another="anotherValue" many="space-separated list" />
<!-- ஒரு கூற்றில் Attribute ஒருமுறைதான் தோன்றும். அது ஒரேயொரு பணப்பை கொண்டிருக்கும் -->
<!-- கீழை கூறுகள் -->
<!-- ஒரு கூரானது பல கீழை கூறுகளை கொண்டிருக்கலாம் : -->
<parent>
<child>Text</child>
<emptysibling />
</parent>
<!-- XML இடைவெளி கான்கெடுக்கப்படும். -->
<child>
Text
</child>
<!-- ஓட்றது அல்ல -->
<child>Text</child>
```
* XML வாக்கிய அமைப்பு

2
th-th/typescript.th.html.markdown
View File

@ -190,7 +190,7 @@ interface Person {
}
var p1: Person = { name: "Tyrone", age: 42 };
p1.age = 25; // Error แน่นอน เพราะ p1.x ถูกกำหนดเป็น read-only
p1.age = 25; // Error แน่นอน เพราะ p1.age ถูกกำหนดเป็น read-only
var p2 = { name: "John", age: 60 }; // สังเกตว่า p2 ไม่ได้กำหนดเป็น Person
var p3: Person = p2; // ทำได้ เป็น read-only alias ของ p2 และกำหนดเป็น Person

2
tr-tr/c-tr.html.markdown
View File

@ -477,7 +477,7 @@ typedef void (*my_fnp_type)(char *);
[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)'in bir kopyasını bulundurmak mükemmel olabilir
Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/)
Diğer bir iyi kaynak ise [Learn C the hard way](http://learncodethehardway.org/c/)
It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the

20
typescript.html.markdown
View File

@ -16,7 +16,7 @@ This article will focus only on TypeScript extra syntax, as opposed to
[JavaScript](/docs/javascript).
To test TypeScript's compiler, head to the
[Playground] (http://www.typescriptlang.org/Playground) where you will be able
[Playground](https://www.typescriptlang.org/play) where you will be able
to type code, have auto completion and directly see the emitted JavaScript.
```ts
@ -199,7 +199,7 @@ interface Person {
}
var p1: Person = { name: "Tyrone", age: 42 };
p1.age = 25; // Error, p1.x is read-only
p1.age = 25; // Error, p1.age is read-only
var p2 = { name: "John", age: 60 };
var p3: Person = p2; // Ok, read-only alias for p2
@ -257,8 +257,24 @@ for (const i in list) {
console.log(i); // 0, 1, 2
}
// Type Assertion
let foo = {} // Creating foo as an empty object
foo.bar = 123 // Error: property 'bar' does not exist on `{}`
foo.baz = 'hello world' // Error: property 'baz' does not exist on `{}`
// Because the inferred type of foo is `{}` (an object with 0 properties), you
// are not allowed to add bar and baz to it. However with type assertion,
// the following will pass:
interface Foo {
bar: number;
baz: string;
}
let foo = {} as Foo; // Type assertion here
foo.bar = 123;
foo.baz = 'hello world'
```

254
uk-ua/cypher-ua.html.markdown Normal file
View File

@ -0,0 +1,254 @@
---
language: cypher
filename: LearnCypher-ua.cql
contributors:
- ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
translators:
- ["AstiaSun", "https://github.com/AstiaSun"]
lang: uk-ua
---
Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтаксис SQL та перемішує його з таким собі ascii стилем для відображення структури графа.
Цей навчальний матеріал передбачає, що ви вже знайомі із концепцією графів, зобрема що таке вершини та зв'язки між ними.
[Деталі тут](https://neo4j.com/developer/cypher-query-language/)
Вершини
---
**Відображує запис у графі.**
`()`
Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
`(n)`
Це вершина, яка має назву **n**, до неї можна повторно звертатись у запиті. Звернення до вершини **n** починається з нижнього підкреслення та використовує camelCase (верблюжий регіст).
`(p:Person)`
Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та використовує верблюжу нотацію.
`(p:Person:Manager)`
Вершина може мати кілька *ярликів*.
`(p:Person {name : 'Théo Gauchoux', age : 22})`
Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починатися з великої літери та використовувати верблюжу нотацію.
Наступні типи дозволяється використовувати у властивостях:
- Чиселиний
- Булевий
- Рядок
- Списки попередніх примітивних типів
*Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.*
`p.name`
За допомогою крапки можна звернутись до властивості вершини.
Зв'язки (або ребра)
---
**Сполучають дві вершини**
`[:KNOWS]`
Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
`[k:KNOWS]`
Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково.
`[k:KNOWS {since:2017}]`
Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це **since**.
`[k:KNOWS*..4]`
Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
Шляхи
---
**Спосіб поєднувати вершини та зв'язки.**
`(a:Person)-[:KNOWS]-(b:Person)`
Шлях описує, що вершини **a** та **b** знають (knows) один одного.
`(a:Person)-[:MANAGES]->(b:Person)`
Шлях може бути направленим. Цей описує, що **а** є менеджером **b**.
`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
Можна створювати ланцюги зі зв'язків. Цей шлях описує друга друга (**a** знає **b**, який в свою чергу знає **c**).
`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
Ланцюг, аналогічно, також може бути направленим. Шлях описує, що **a** - бос **b** і супер бос для **c**.
Шаблони, які часто використовуються (з документації Neo4j):
```
// Друг-мого-друга
(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
// Найкоротший шлях
path = shortestPath( (user)-[:KNOWS*..5]-(other) )
// Спільна фільтрація
(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
// Навігація по дереву
(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
```
Запити на створення
---
Створити нову вершину:
```
CREATE (a:Person {name:"Théo Gauchoux"})
RETURN a
```
*`RETURN` дозволяє повернути результат після виконання запиту. Можна повертати кілька значень, наприклад, `RETURN a, b`.*
Створити новий зв'язок (із двома вершинами):
```
CREATE (a:Person)-[k:KNOWS]-(b:Person)
RETURN a,k,b
```
Запити на знаходження
---
Знайти всі вершини:
```
MATCH (n)
RETURN n
```
Знайти вершини за ярликом:
```
MATCH (a:Person)
RETURN a
```
Знайти вершини за ярликом та властивістю:
```
MATCH (a:Person {name:"Théo Gauchoux"})
RETURN a
```
Знайти вершини відповідно до зв'язків (ненаправлених):
```
MATCH (a)-[:KNOWS]-(b)
RETURN a,b
```
Знайти вершини відповідно до зв'язків (направлених):
```
MATCH (a)-[:MANAGES]->(b)
RETURN a,b
```
Знайти вершини за допомогою `WHERE`:
```
MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
WHERE s.since = 2015
RETURN p,state
```
Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`:
```
MATCH (a), (b)
WHERE a.name = "Jacquie" AND b.name = "Michel"
CREATE (a)-[:KNOWS]-(b)
```
Запити на оновлення
---
Оновити окрему властивість вершини:
```
MATCH (p:Person)
WHERE p.name = "Théo Gauchoux"
SET p.age = 23
```
Оновити всі властивості вершини:
```
MATCH (p:Person)
WHERE p.name = "Théo Gauchoux"
SET p = {name: "Michel", age: 23}
```
Додати нову властивіcть до вершини:
```
MATCH (p:Person)
WHERE p.name = "Théo Gauchoux"
SET p + = {studies: "IT Engineering"}
```
Повісити ярлик на вершину:
```
MATCH (p:Person)
WHERE p.name = "Théo Gauchoux"
SET p:Internship
```
Запити на видалення
---
Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим):
```
MATCH (p:Person)-[relationship]-()
WHERE p.name = "Théo Gauchoux"
DELETE relationship, p
```
Видалити властивість певної вершини:
```
MATCH (p:Person)
WHERE p.name = "Théo Gauchoux"
REMOVE p.age
```
*Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й `DELETE`!*
Видалити ярлик певної вершини:
```
MATCH (p:Person)
WHERE p.name = "Théo Gauchoux"
DELETE p:Person
```
Видалити всю базу даних:
```
MATCH (n)
OPTIONAL MATCH (n)-[r]-()
DELETE n, r
```
*Так, це `rm -rf /` на мові Cypher !*
Інші корисні запити
---
`PROFILE`
Перед виконанням, показати план виконання запитів.
`COUNT(e)`
Порахувати елементи (вершини та зв'язки), що відповідають **e**.
`LIMIT x`
Обмежити результат до x перших результатів.
Особливі підказки
---
- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
- Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
- Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко.
- Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як **OpenCypher**).

449
uk-ua/go-ua.html.markdown Normal file
View File

@ -0,0 +1,449 @@
---
name: Go
category: language
language: Go
filename: learngo-ua.go
contributors:
- ["Sonia Keys", "https://github.com/soniakeys"]
- ["Christopher Bess", "https://github.com/cbess"]
- ["Jesse Johnson", "https://github.com/holocronweaver"]
- ["Quint Guvernator", "https://github.com/qguv"]
- ["Jose Donizetti", "https://github.com/josedonizetti"]
- ["Alexej Friesen", "https://github.com/heyalexej"]
- ["Clayton Walker", "https://github.com/cwalk"]
- ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
translators:
- ["AstiaSun", "https://github.com/AstiaSun"]
lang: uk-ua
---
Go був створений для того, щоб виконати задачу. Це не останній тренд в теорії мов програмування, а спосіб вирішення реальних проблем.
Він увібрав принципи з імперативних мов зі статичною типізацією.
Go швидко компілюється та виконується, а його багатопоточність легка для
вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 мільйонів в Google, Inc.)
Go має чудову стандартну бібліотеку та чимале ком'юніті.
```go
// Однорядковий коментар
/* Багато-
рядковий коментар */
// Кожен файл вихідного коду має починатись із ключового слова package.
// main - це спеціальна назва, що оголошує виконуваний код, а не бібліотеку.
package main
// import оголошує бібліотеки, що використовуються в даному файлі.
import (
"fmt" // Пакет стандартної бібліотеки Go.
"io/ioutil" // Цей пакет реалізує деякі I/O функції утиліт.
m "math" // Бібліотека математичних операцій з локальним псевдонімом m.
"net/http" // Так, веб сервер!
"os" // Функції операційної системи, такі як робота з файловою системою.
"strconv" // Перетворення текстових змінних.
)
// Оголошення функції.
// Функція main - особлива. Це вхідна точка для виконуваних програм.
// Ви можете любити це, або ж ненавидіти, але Go використовує фігурні дужки.
func main() {
// Println виводить рядок в stdout.
// Ця функція входить у пакет fmt.
fmt.Println("Hello world!")
// Викликати іншу функцію з цього файлу.
beyondHello()
}
// Аргументи функцій описуються у круглих дужках.
// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обов`язкові.
func beyondHello() {
var x int // Оголошення змінної. Перед використанням змінні обов'язково мають бути оголошені.
x = 3 // Присвоєння значення.
// "Короткі" оголошення використовують := щоб окреслити тип, оголосити та присвоїти значення.
y := 4
sum, prod := learnMultiple(x, y) // Функція повертає два значення.
fmt.Println("sum:", sum, "prod:", prod) // Просто вивід.
learnTypes() // < y хвилин, потрібно вивчити більше!
}
/* <- багаторядковий коментар
Функції можуть мати параметри та повертати довільну кількість значень.
В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертаються.
Зверніть увагу, що `x` та `sum` мають тип `int`.
*/
func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // Повернути два значення.
}
// Кілька вбудованих типів та літералів.
func learnTypes() {
// Короткі оголошення зазвичай виконують все, що необхідно.
str := "Вчи Go!" // рядок (string).
s2 := `"Необроблений" текст
може містити переноси рядків.` // Також має тип рядок.
// Не ASCII символи. Go використовує UTF-8.
g := 'Σ' // руничний тип, псевдонім для int32, містить позицію юнікод кода.
f := 3.14195 // float64, IEEE-754 64-бітне число з плаваючою крапкою.
c := 3 + 4i // complex128, комплексні числа, що являють собою два float64.
// Синтаксис ініціалізації з var.
var u uint = 7 // Беззнаковий цілочисельний тип, проте розмір залежить від імплементації, так само як і int.
var pi float32 = 22. / 7
// Синтаксис перетворення типів з коротким оголошенням.
n := byte('\n') // Байт - це переіменований uint8.
// Розмір масива фіксований протягом часу виконання.
var a4 [4]int // Масив з 4 чисел, всі проініціалізовані 0.
a5 := [...]int{3, 1, 5, 10, 100} // Масив проініціалізованих чисел з фіксованим розміром у
// п'ять елементів, що мають значення 3, 1, 5, 10, та 100.
// Зрізи мають динамічний розмір. Переваги є і у масивів, й у зрізів, проте
// останні використовуються частіше.
s3 := []int{4, 5, 9} // Порівняйте з a5. Тут немає трьокрапки.
s4 := make([]int, 4) // Виділяє пам'ять для зрізу з 4 чисел, проініціалізованих 0.
var d2 [][]float64 // Декларація, нічого не виділяється.
bs := []byte("a slice") // Синтаксис переведення у інший тип.
// Оскільки зрізи динамічні, до них можна додавати елементи за необхідністю.
// Для цієї операції використовується вбудована функція append().
// Перший аргумент - це зріз, до якого додається елемент. Зазвичай
// змінна масиву оновлюється на місці, як у прикладі нижче.
s := []int{1, 2, 3} // В результаті отримуємо зріз із 3 чисел.
s = append(s, 4, 5, 6) // додаємо 3 елементи. Зріз тепер довжини 6.
fmt.Println(s) // Оновлений зріз тепер має значення [1 2 3 4 5 6]
// Щоб об'єднати два зрізи, замість того, щоб проходитись по всім елементам,
// можна передати посилання на зріз із трьокрапкою, як у прикладі нижче. Таким чином,
// зріз розпакується і його елементи додадуться до зріза s.
s = append(s, []int{7, 8, 9}...)
fmt.Println(s) // Оновлений зріз тепер дорівнює [1 2 3 4 5 6 7 8 9]
p, q := learnMemory() // Оголошує змінні p, q, що є вказівниками на числа.
fmt.Println(*p, *q) // * іде попереду вказівника. Таким чином, виводяться числа.
// Асоціативний масив (map) - це динамічно розширюваний тип даних, як хеш
// або словник в інших мовах програмування
m := map[string]int{"three": 3, "four": 4}
m["one"] = 1
// В Go змінні, які не використовуються, вважаються помилкою.
// Нижнє підкреслення дозволяє "використати" змінну, але проігнорувати значення.
_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs
// Зазвичай це використовується, щоб проігнорувати значення, що повертає функція.
// Наприклад, в скрипті нашвидкоруч можна проігнорувати помилку, яку повертає
// функція os.Create, вважаючи, що файл буде створений за будь-яких умов.
file, _ := os.Create("output.txt")
fmt.Fprint(file, "Приклад, як відбувається запис у файл.")
file.Close()
// Вивід значень змінних.
fmt.Println(s, c, a4, s3, d2, m)
learnFlowControl() // Рухаємось далі.
}
// Навідміну від більшості інших мов програмування, функції в Go підтримують
// іменоване значення, що повертається.
// Змінні, значення яких повертається функцією, вказуються із зазначенням типу при
// оголошенні функції. Таким чином, можна з легкістю повернути їхні значення в різних
// точках коду, не перелічуючи їх після ключового слова return.
func learnNamedReturns(x, y int) (z int) {
z = x * y
return // z не потрібно вказувати, при оголошенні описано змінну для повернення.
}
// Go використовує сміттєзбірник. В ньому використовуються вказівники, проте немає
// операцій з вказівниками. Можлива помилка при використовуванні вказівника nil, але не
// при збільшенні значення вказівника (перехід по адресам пам'яті).
func learnMemory() (p, q *int) {
// Іменовані змінні, що повертаються, p та q, мають тип вказівника на чисельне значення.
p = new(int) // Вбудована функція виділяє нову пам'ять.
// Виділена адреса пам'яті чисельного типу int ініціалізовується 0, p більше не nil.
s := make([]int, 20) // Виділити пам'ять для 20 чисел у вигляді суцільного блоку в пам'яті.
s[3] = 7 // Присвоїти значення одному з них.
r := -2 // Оголосити нову локальну змінну.
return &s[3], &r // Оператор & повертає адресу в пам'яті об'єкта.
}
func expensiveComputation() float64 {
return m.Exp(10)
}
func learnFlowControl() {
// if твердження вимагає фігурні дужки, але не вимагає округлих.
if true {
fmt.Println("Кажу ж")
}
// Форматування стандартизовано командою командного рядка "go fmt".
if false {
// Pout.
} else {
// Gloat.
}
// Використання перемикача (switch) замість ланцюга if-тверджень.
x := 42.0
switch x {
case 0:
case 1:
case 42:
// Кейси не "провалюються". Натомість, є ключове слово `fallthrough`:
// https://github.com/golang/go/wiki/Switch#fall-through (англ)
case 43:
// Недоступний.
default:
// Кейс за замовчуванням не обов'язковий.
}
// Як і if, формат оголошення циклу for не вимагає круглих дужок:
// Змінні, оголошені всередині if та for - належать цій області видимості.
for x := 0; x < 3; x++ { // ++ - це твердження.
fmt.Println("iteration", x)
}
// Тут x == 42.
// For - це єдиний цикл в Go, проте він має кілька різних форм.
for { // Ініціалізація циклу.
break // Упс, помилково зайшли.
continue // Недоступне твердження.
}
// Можна використовувати діапазони, зрізи, рядки, асоціативні масиви, або ж
// канал для ітерації в циклі. Діапазон (range) повертає один (канал) або два
// значення (масив, зріз, рядок та асоціативний масив).
for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
// для кожної пари в асоціативному масиві, надрукувати ключ та значення
fmt.Printf("key=%s, value=%d\n", key, value)
}
// якщо потрібне тільки значення, можна застосувати нижнє підкреслення як ключ
for _, name := range []string{"Bob", "Bill", "Joe"} {
fmt.Printf("Hello, %s\n", name)
}
// так само, як і з циклом for, оператор := в розгалуженні означає оголосити
// локальну змінну в області видимості if та присвоїти значення. Далі
// значення змінної проходить перевірку y > x.
if y := expensiveComputation(); y > x {
x = y
}
// Літерали функцій - це замикання
xBig := func() bool {
return x > 10000 // Посилання на x, що був оголошений раніше, перед switch.
}
x = 99999
fmt.Println("xBig:", xBig()) // true
x = 1.3e3 // Тобто, тепер x == 1300
fmt.Println("xBig:", xBig()) // false тепер.
// Функція може бути оголошена та викликана в одному рядку, поводячи себе
// як аргумент функції, але за наступних умов:
// 1) літерал функції негайно викликається за допомогою ()
// 2) тип значення, що повертається, точно відповідає очікуваному типу аргументу
fmt.Println("Add + double two numbers: ",
func(a, b int) int {
return (a + b) * 2
}(10, 2)) // Викликаємо з аргументами 10 та 2
// => Додати + подвоїти два числа: 24
// Коли вам це знадобиться, ви полюбите це
goto love
love:
learnFunctionFactory() // функція, що повертає функцію - це весело(3)(3)
learnDefer() // Швидкий обхід до важливого ключового слова.
learnInterfaces() // Тут на вас чекає крута штука!
}
func learnFunctionFactory() {
// Два наступних твердження роблять однакові дії, але другий приклад частіше
// застосовується
fmt.Println(sentenceFactory("summer")("A beautiful", "day!"))
d := sentenceFactory("summer")
fmt.Println(d("A beautiful", "day!"))
fmt.Println(d("A lazy", "afternoon!"))
}
// Декоратори звична річ для багатьох мов програмування. В Go їх можна реалізувати
// за допомогою літералів функцій, що приймають аргументи.
func sentenceFactory(mystring string) func(before, after string) string {
return func(before, after string) string {
return fmt.Sprintf("%s %s %s", before, mystring, after) // новий рядок
}
}
func learnDefer() (ok bool) {
// твердження defer змушує функцію посилатись на список. Список
// збережених викликів виконується ПІСЛЯ того, як оточуюча функція закінчує
// виконання.
defer fmt.Println("відкладені твердження виконуються у зворотньому порядку (LIFO).")
defer fmt.Println("\nЦей рядок надрукується першим, тому що")
// Відкладення зазвичай використовується для того, щоб закрити файл. Таким чином,
// функція, що закриває файл, залишається близькою до функції, що відкриває файл.
return true
}
// Оголошує Stringer як тип інтерфейсу з одним методом, String.
type Stringer interface {
String() string
}
// Оголошує pair як структуру з двома полями, цілими числами x та y.
type pair struct {
x, y int
}
// Оголошує метод для типу pair. pair тепер реалізує Stringer, оскільки pair оголосив
// всі методи в цьому інтерфейсі.
func (p pair) String() string { // p тепер називається "приймачем"
// Sprintf - ще одна функція з пакету fmt.
// Крапка використовується, щоб звернутись до полів об'єкту p.
return fmt.Sprintf("(%d, %d)", p.x, p.y)
}
func learnInterfaces() {
// Синтаксис з використанням фігурних дужок називається "літералом структури".
// Він застосовується до ініціалізованої структури. Оператор := оголошує
// та ініціалізує p цією структурою.
p := pair{3, 4}
fmt.Println(p.String()) // Викликає метод String об'єкта p типу pair.
var i Stringer // Оголошує і інтерфейсного типу Stringer.
i = p // Допустиме, оскільки pair реалізує Stringer
// Викликає метод String об'єкта і, що має тип Stringer. Виводить те ж саме, що й
// аналогічний метод вище.
fmt.Println(i.String())
// Функції з бібліотеки fmt викликають метод String, щоб запросити у об'єкта
// своє представлення, яке можна надрукувати.
fmt.Println(p) // Виводить те ж саме, що й раніше.
fmt.Println(i) // Виводить те ж саме, що й раніше.
learnVariadicParams("great", "learning", "here!")
}
// Кількість аргументів функції може бути змінною.
func learnVariadicParams(myStrings ...interface{}) {
// Пройтись по значенням всіх аргументів.
// _ - це ігнорування порядкового номеру аргумента в масиві.
for _, param := range myStrings {
fmt.Println("param:", param)
}
// Передати значення аргументів як параметр змінної величини.
fmt.Println("params:", fmt.Sprintln(myStrings...))
learnErrorHandling()
}
func learnErrorHandling() {
// Ідіома ", ok"використовується, щоб перевірити виконання команди без помилок.
m := map[int]string{3: "three", 4: "four"}
if x, ok := m[1]; !ok { // ok буде мати значення false, тому що 1 не знаходиться
// в асоціативному масиві.
fmt.Println("немає таких")
} else {
fmt.Print(x) // x буде мати значення 1, якщо 1 знаходиться в m.
}
// Значення помилки повідомляє не тільки, що все добре, але й може розповісти
// більше про проблему.
if _, err := strconv.Atoi("non-int"); err != nil { // _ ігнорує значення
// виводить помилку 'strconv.ParseInt: parsing "non-int": invalid syntax'
fmt.Println(err)
}
// Ми розглянемо інтерфейси дещо пізніше. А поки, розглянемо багатопоточність.
learnConcurrency()
}
// Канал с - це потокозохищений об'єкт для спілкування між потоками.
func inc(i int, c chan int) {
c <- i + 1 // Оператор <- виконує операцію "надіслати",якщо змінна каналу
// знаходиться зліва від нього.
}
// inc виконує збільшення значення на 1. Ми використаємо його, щоб збільшувати
// числа рівночасно.
func learnConcurrency() {
// вже знайома функція make, яка раніше використовувалась для виділення пам'яті,
// тут використовується для створення каналу. Make виділяє пам'ять та ініціалізує
// зрізи, асоційовані масиви та канали. Новостворений канал буде передавати
// цілочисельні значення.
c := make(chan int)
// Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовірно
// паралельно якщо пристрій здатний до цього та правильно сконфігурований.
// Всі три ґорутини надсилають значення в один канал.
go inc(0, c) // Твердження go запускає нову ґорутину.
go inc(10, c)
go inc(-805, c)
// Читаємо три результати з каналу та друкуємо їх.
// Порядок результатів - невідомий!
fmt.Println(<-c, <-c, <-c) // якщо канал знаходиться справа від оператора <-,
// він виконує функцію "приймача".
cs := make(chan string) // Ще один канал, який примає рядки.
ccs := make(chan chan string) // Канал каналів рядків.
go func() { c <- 84 }() // Запустимо нову ґорутину, щоб надіслати значення в канал с.
go func() { cs <- "wordy" }() // Надсилаємо "wordy" в канал cs.
// Ключове слово select має синтаксис, подібний до switch, проте кожен кейс
// включає в себе операцію з каналом. Він обирає довільний кейс з наявних, які готові
// комунікувати (передавати дані).
select {
case i := <-c: // Отримане значення може бути присвоєно змінній,
fmt.Printf("it's a %T", i)
case <-cs: // або значення може бути проігнороване.
fmt.Println("it's a string")
case <-ccs: // Пустий канал, не готовий комунікувати.
fmt.Println("Не відбудеться.")
}
// На цьому етапі, значення було прочитане або з с або з cs. Одна з двох
// ґорутин завершилась, але інша все ще заблокована.
learnWebProgramming() // Go вміє й у веб. Так, ти хочеш зробити це.
}
// Лиш одна функція з пакету http запускає веб сервер.
func learnWebProgramming() {
// перший аргумент ListenAndServe - це TCP адреса, який сервер буде слухати.
// Другий аргумент - це інтерфейс, а точніше http.Handler.
go func() {
err := http.ListenAndServe(":8080", pair{})
fmt.Println(err) // не ігноруйте помилки
}()
requestServer()
}
// pair матиме тип http.Handler, якщо реалізувати один його метод, ServeHTTP.
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Відповідати на запити можна методом, що належить http.ResponseWriter.
w.Write([]byte("Ти вивчив Go за Y хвилин!"))
}
func requestServer() {
resp, err := http.Get("http://localhost:8080")
fmt.Println(err)
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
fmt.Printf("\nWebserver said: `%s`", string(body))
}
```
## Подальше вивчення
Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати.
Окрім туру, у [документації](https://golang.org/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів.
Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами).
Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://uk.wikipedia.org/wiki/REPL) до тестів та коду в твоєму браузері, без встановлення Go.
В списку для прочитання новачкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно задокоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/pkg/), щоб перейти до її реалізації.
Іншим прекрасним посиланням для вивчення Go є [Go by example](https://gobyexample.com/).
Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go для мобільних застосунків або написати бібліотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile).

464
uk-ua/kotlin-ua.html.markdown Normal file
View File

@ -0,0 +1,464 @@
---
language: kotlin
filename: LearnKotlin-uk.kt
lang: uk-ua
contributors:
- ["S Webber", "https://github.com/s-webber"]
translators:
- ["AstiaSun", "https://github.com/AstiaSun"]
---
Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера.
Вона має 100% сумісність із Java.
[Детальніше](https://kotlinlang.org/)
```kotlin
// Однорядкові коментарі починаються з //
/*
Такий вигляд мають багаторядкові коментарі
*/
// Ключове слово package працює так само, як і в Java.
package com.learnxinyminutes.kotlin
/*
Точкою входу для програм на Kotlin є функція під назвою main.
Вона приймає масив із аргументів, що були передані через командний рядок.
Починаючи з Kotlin 1.3, функція main може бути оголошена без параметрів взагалі.
*/
fun main(args: Array<String>) {
/*
Оголошення змінних відбувається за допомогою ключових слів var або val.
Відмінність між ними полягає в тому, що значення змінних, оголошених через
val, не можна змінювати. Водночас, змінній "var" можна переприсвоїти нове
значення в подальшому.
*/
val fooVal = 10 // більше ми не можемо змінити значення fooVal на інше
var fooVar = 10
fooVar = 20 // fooVar може змінювати значення
/*
В більшості випадків Kotlin може визначати, якого типу змінна, тому не
потрібно щоразу точно вказувати її тип.
Тип змінної вказується наступним чином:
*/
val foo: Int = 7
/*
Рядки мають аналогічне з Java представлення. Спеціальні символи
позначаються за допомогою зворотнього слеша.
*/
val fooString = "My String Is Here!"
val barString = "Printing on a new line?\nNo Problem!"
val bazString = "Do you want to add a tab?\tNo Problem!"
println(fooString)
println(barString)
println(bazString)
/*
Необроблений рядок розмежовується за допомогою потрійних лапок (""").
Необроблені рядки можуть містити переніс рядка (не спеціальний символ \n) та
будь-які інші символи.
*/
val fooRawString = """
fun helloWorld(val name : String) {
println("Hello, world!")
}
"""
println(fooRawString)
/*
Рядки можуть містити шаблонні вирази.
Шаблонний вираз починається із символа доллара "$".
*/
val fooTemplateString = "$fooString has ${fooString.length} characters"
println(fooTemplateString) // => My String Is Here! has 18 characters
/*
Щоб змінна могла мати значення null, потрібно це додатково вказати.
Для цього після оголошеного типу змінної додається спеціальний символ "?".
Отримати значення такої змінної можна використавши оператор "?.".
Оператор "?:" застосовується, щоб оголосити альтернативне значення змінної
у випадку, якщо вона буде рівна null.
*/
var fooNullable: String? = "abc"
println(fooNullable?.length) // => 3
println(fooNullable?.length ?: -1) // => 3
fooNullable = null
println(fooNullable?.length) // => null
println(fooNullable?.length ?: -1) // => -1
/*
Функції оголошуються з використанням ключового слова fun.
Аргументи функції перелічуються у круглих дужках після назви функції.
Аргументи можуть мати значення за замовчуванням. Тип значення, що повертатиметься
функцією, вказується після оголошення аргументів за необхідністю.
*/
fun hello(name: String = "world"): String {
return "Hello, $name!"
}
println(hello("foo")) // => Hello, foo!
println(hello(name = "bar")) // => Hello, bar!
println(hello()) // => Hello, world!
/*
Аргументи функції можуть бути помічені ключовим словом vararg. Це дозволяє
приймати довільну кількість аргументів функції зазначеного типу.
*/
fun varargExample(vararg names: Int) {
println("Argument has ${names.size} elements")
}
varargExample() // => Argument has 0 elements
varargExample(1) // => Argument has 1 elements
varargExample(1, 2, 3) // => Argument has 3 elements
/*
Коли функція складається з одного виразу, фігурні дужки не є обов'язковими.
Тіло функції вказується після оператора "=".
*/
fun odd(x: Int): Boolean = x % 2 == 1
println(odd(6)) // => false
println(odd(7)) // => true
// Якщо тип значення, що повертається функцією, може бути однозначно визначено,
// його непотрібно вказувати.
fun even(x: Int) = x % 2 == 0
println(even(6)) // => true
println(even(7)) // => false
// Функції можуть приймати інші функції як аргументи, а також повертати інші функції.
fun not(f: (Int) -> Boolean): (Int) -> Boolean {
return {n -> !f.invoke(n)}
}
// Іменовані функції можуть бути вказані як аргументи за допомогою оператора "::".
val notOdd = not(::odd)
val notEven = not(::even)
// Лямбда-вирази також можуть бути аргументами функції.
val notZero = not {n -> n == 0}
/*
Якщо лямбда-вираз приймає лише один параметр, його оголошення може бути пропущене
(разом із ->). Всередині виразу до цього параметра можна звернутись через
змінну "it".
*/
val notPositive = not {it > 0}
for (i in 0..4) {
println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
}
// Ключове слово class використовується для оголошення класів.
class ExampleClass(val x: Int) {
fun memberFunction(y: Int): Int {
return x + y
}
infix fun infixMemberFunction(y: Int): Int {
return x * y
}
}
/*
Щоб створити новий об'єкт, потрібно викликати конструктор класу.
Зазначте, що в Kotlin немає ключового слова new.
*/
val fooExampleClass = ExampleClass(7)
// Методи класу викликаються через крапку.
println(fooExampleClass.memberFunction(4)) // => 11
/*
Якщо функція була позначена ключовим словом infix, тоді її можна викликати через
інфіксну нотацію.
*/
println(fooExampleClass infixMemberFunction 4) // => 28
/*
Класи даних - це лаконічний спосіб створювати класи, що містимуть тільки дані.
Методи "hashCode"/"equals" та "toString" автоматично генеруються.
*/
data class DataClassExample (val x: Int, val y: Int, val z: Int)
val fooData = DataClassExample(1, 2, 4)
println(fooData) // => DataClassExample(x=1, y=2, z=4)
// Класи даних також мають функцію "copy".
val fooCopy = fooData.copy(y = 100)
println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
// Об'єкти можуть бути деструктурувані кількома способами.
val (a, b, c) = fooCopy
println("$a $b $c") // => 1 100 4
// деструктурування у циклі for
for ((a, b, c) in listOf(fooData)) {
println("$a $b $c") // => 1 100 4
}
val mapData = mapOf("a" to 1, "b" to 2)
// Map.Entry також деструктурувуються
for ((key, value) in mapData) {
println("$key -> $value")
}
// Функція із "with" працює майже так само як це ж твердження у JavaScript.
data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
val fooMutableData = MutableDataClassExample(7, 4, 9)
with (fooMutableData) {
x -= 2
y += 2
z--
}
println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
/*
Список можна створити використовуючи функцію listOf.
Список буде незмінним, тобто елементи не можна буде додавати або видаляти.
*/
val fooList = listOf("a", "b", "c")
println(fooList.size) // => 3
println(fooList.first()) // => a
println(fooList.last()) // => c
// доступ до елементів здійснюється через їхні порядковий номер.
println(fooList[1]) // => b
// Змінні списки можна створити використовуючи функцію mutableListOf.
val fooMutableList = mutableListOf("a", "b", "c")
fooMutableList.add("d")
println(fooMutableList.last()) // => d
println(fooMutableList.size) // => 4
// Функція setOf створює об'єкт типу множина.
val fooSet = setOf("a", "b", "c")
println(fooSet.contains("a")) // => true
println(fooSet.contains("z")) // => false
// mapOf створює асоціативний масив.
val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
// Доступ до значень в асоціативних масивах здійснюється через їхні ключі.
println(fooMap["a"]) // => 8
/*
Послідовності представлені як колекції лінивих обчислень. Функція generateSequence
створює послідовність.
*/
val fooSequence = generateSequence(1, { it + 1 })
val x = fooSequence.take(10).toList()
println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// Приклад використання послідовностей, генерація чисел Фібоначчі:
fun fibonacciSequence(): Sequence<Long> {
var a = 0L
var b = 1L
fun next(): Long {
val result = a + b
a = b
b = result
return a
}
return generateSequence(::next)
}
val y = fibonacciSequence().take(10).toList()
println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
// Kotlin має функції вищого порядку для роботи з колекціями.
val z = (1..9).map {it * 3}
.filter {it < 20}
.groupBy {it % 2 == 0}
.mapKeys {if (it.key) "even" else "odd"}
println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
// Цикл for може використовуватись з будь-чим, що має ітератор.
for (c in "hello") {
println(c)
}
// Принцип роботи циклів "while" не відрізняється від інших мов програмування.
var ctr = 0
while (ctr < 5) {
println(ctr)
ctr++
}
do {
println(ctr)
ctr++
} while (ctr < 10)
/*
if може бути використаний як вираз, що повертає значення. Тому тернарний
оператор ?: не потрібний в Kotlin.
*/
val num = 5
val message = if (num % 2 == 0) "even" else "odd"
println("$num is $message") // => 5 is odd
// "when" використовується як альтернатива ланцюгам "if-else if".
val i = 10
when {
i < 7 -> println("first block")
fooString.startsWith("hello") -> println("second block")
else -> println("else block")
}
// "when" може приймати аргумент.
when (i) {
0, 21 -> println("0 or 21")
in 1..20 -> println("in the range 1 to 20")
else -> println("none of the above")
}
// "when" також може використовуватись як функція, що повертає значення.
var result = when (i) {
0, 21 -> "0 or 21"
in 1..20 -> "in the range 1 to 20"
else -> "none of the above"
}
println(result)
/*
Тип об'єкта можна перевірити використавши оператор is. Якщо перевірка проходить
успішно, тоді можна використовувати об'єкт як данний тип не приводячи до нього
додатково.
*/
fun smartCastExample(x: Any) : Boolean {
if (x is Boolean) {
// x тепер має тип Boolean
return x
} else if (x is Int) {
// x тепер має тип Int
return x > 0
} else if (x is String) {
// x тепер має тип String
return x.isNotEmpty()
} else {
return false
}
}
println(smartCastExample("Hello, world!")) // => true
println(smartCastExample("")) // => false
println(smartCastExample(5)) // => true
println(smartCastExample(0)) // => false
println(smartCastExample(true)) // => true
// Smartcast (розумне приведення) також працює з блоком when
fun smartCastWhenExample(x: Any) = when (x) {
is Boolean -> x
is Int -> x > 0
is String -> x.isNotEmpty()
else -> false
}
/*
Розширення - це ще один спосіб розширити функціонал класу.
Подібні методи розширення реалізовані у С#.
*/
fun String.remove(c: Char): String {
return this.filter {it != c}
}
println("Hello, world!".remove('l')) // => Heo, word!
}
// Класи перелічення також подібні до тих типів, що і в Java.
enum class EnumExample {
A, B, C // Константи перелічення розділені комами.
}
fun printEnum() = println(EnumExample.A) // => A
// Оскільки кожне перелічення - це об'єкт класу enum, воно може бути
// проініціалізоване наступним чином:
enum class EnumExample(val value: Int) {
A(value = 1),
B(value = 2),
C(value = 3)
}
fun printProperty() = println(EnumExample.A.value) // => 1
// Кожне перелічення має властивості, які дозволяють отримати його ім'я
// та порядок (позицію) в класі enum:
fun printName() = println(EnumExample.A.name) // => A
fun printPosition() = println(EnumExample.A.ordinal) // => 0
/*
Ключове слово object можна використати для створення об'єкту сінглтону. Об'єкт не
можна інстанціювати, проте на його унікальний екземпляр можна посилатись за іменем.
Подібна можливість є в сінглтон об'єктах у Scala.
*/
object ObjectExample {
fun hello(): String {
return "hello"
}
override fun toString(): String {
return "Hello, it's me, ${ObjectExample::class.simpleName}"
}
}
fun useSingletonObject() {
println(ObjectExample.hello()) // => hello
// В Kotlin, "Any" - це корінь ієрархії класів, так само, як і "Object" у Java.
val someRef: Any = ObjectExample
println(someRef) // => Hello, it's me, ObjectExample
}
/*
Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає виняток, якщо значення рівне null.
*/
var b: String? = "abc"
val l = b!!.length
// Далі - приклади перевизначення методів класу Any в класі-насліднику
data class Counter(var value: Int) {
// перевизначити Counter += Int
operator fun plusAssign(increment: Int) {
this.value += increment
}
// перевизначити Counter++ та ++Counter
operator fun inc() = Counter(value + 1)
// перевизначити Counter + Counter
operator fun plus(other: Counter) = Counter(this.value + other.value)
// перевизначити Counter * Counter
operator fun times(other: Counter) = Counter(this.value * other.value)
// перевизначити Counter * Int
operator fun times(value: Int) = Counter(this.value * value)
// перевизначити Counter in Counter
operator fun contains(other: Counter) = other.value == this.value
// перевизначити Counter[Int] = Int
operator fun set(index: Int, value: Int) {
this.value = index + value
}
// перевизначити виклик екземпляру Counter
operator fun invoke() = println("The value of the counter is $value")
}
// Можна також перевизначити оператори через методи розширення.
// перевизначити -Counter
operator fun Counter.unaryMinus() = Counter(-this.value)
fun operatorOverloadingDemo() {
var counter1 = Counter(0)
var counter2 = Counter(5)
counter1 += 7
println(counter1) // => Counter(value=7)
println(counter1 + counter2) // => Counter(value=12)
println(counter1 * counter2) // => Counter(value=35)
println(counter2 * 2) // => Counter(value=10)
println(counter1 in Counter(5)) // => false
println(counter1 in Counter(7)) // => true
counter1[26] = 10
println(counter1) // => Counter(value=36)
counter1() // => The value of the counter is 36
println(-counter2) // => Counter(value=-5)
}
```
### Подальше вивчення
* [Уроки Kotlin](https://kotlinlang.org/docs/tutorials/)
* [Спробувати попрацювати з Kotlin в браузері](https://play.kotlinlang.org/)
* [Список корисних посилань](http://kotlin.link/)

366
uk-ua/mips-ua.html.markdown Normal file
View File

@ -0,0 +1,366 @@
---
language: "MIPS Assembly"
filename: MIPS.asm
contributors:
- ["Stanley Lim", "https://github.com/Spiderpig86"]
translators:
- ["AstiaSun", "https://github.com/AstiaSun"]
lang: uk-ua
---
Мова ассемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропроцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
[Детальніше](https://en.wikipedia.org/wiki/MIPS_architecture)
```asm
# Коментарі позначені як'#'
# Всі символи після '#' ігноруються лексичним аналізатором асемблера.
# Зазвичай програми поділяються на .data та .text частини
.data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
# в мовах програмування вищого рівня
# Змінна оголошується наступним чином: [назва]: .[тип] [значення]
# Наприклад:
hello_world: .asciiz "Hello World\n" # Оголосити текстову змінну
num1: .word 42 # word - це чисельний тип 32-бітного розряду
arr1: .word 1, 2, 3, 4, 5 # Масив чисел
arr2: .byte 'a', 'b' # Масив буквених символів (розмір кожного - 1 байт)
buffer: .space 60 # Виділити місце в RAM
# (не очищується, тобто не заповнюється 0)
# Розміри типів даних
_byte: .byte 'a' # 1 байт
_halfword: .half 53 # 2 байти
_word: .word 3 # 4 байти
_float: .float 3.14 # 4 байти
_double: .double 7.0 # 8 байтів
.align 2 # Вирівнювання пам'яті даних, де число
# показує кількість байтів, вирівнених
# у степені 2. (.align 2 означає
# чисельне (word) вирівнювання оскільки
# 2^2 = 4 байти)
.text # Розділ, що містить інструкції та
# логіку програми
.globl _main # Оголошує назву інструкції як
# глобальну, тобто, яка є доступною для
# всіх інших файлів
_main: # програми MIPS виконують інструкції
# послідовно, тобто першочергово код
# буде виконуватись після цієї позначки
# Виведемо на екран "hello world"
la $a0, hello_world # Завантажує адресу тексту у пам'яті
li $v0, 4 # Завантажує значення системної
# команди (вказуючи тип функціоналу)
syscall # Виконує зазначену системну команду
# з обраним аргументом ($a0)
# Регістри (використовуються, щоб тримати дані протягом виконання програми)
# $t0 - $t9 # Тимчасові регістри використовуються
# для проміжних обчислень всередині
# підпрограм (не зберігаються між
# викликами функцій)
# $s0 - $s7 # Збережені регістри, у яких значення
# зберігаються між викликами підпрограм.
# Зазвичай зберігаються у стеку.
# $a0 - $a3 # Регістри для передачі аргументів для
# підпрограм
# $v0 - $v1 # Регістри для значень, що повертаються
# від викликаної функції
# Типи інструкції завантаження / збереження
la $t0, label # Скопіювати адресу в пам'яті, де
# зберігається значення змінної label
# в регістр $t0
lw $t0, label # Скопіювати чисельне значення з пам'яті
lw $t1, 4($s0) # Скопіювати чисельне значення з адреси
# пам'яті регістра зі зміщенням в
# 4 байти (адреса + 4)
lb $t2, label # Скопіювати буквений символ в частину
# нижчого порядку регістра $t2
lb $t2, 0($s0) # Скопіювати буквений символ з адреси
# в $s0 із зсувом 0
# Подібне використання і 'lh' для halfwords
sw $t0, label # Зберегти чисельне значення в адресу в
# пам'яті, що відповідає змінній label
sw $t0, 8($s0) # Зберегти чисельне значення в адресу,
# що зазначена у $s0, та зі зсувом у 8 байтів
# Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords.
# 'sa' не існує
### Математичні операції ###
_math:
# Пам'ятаємо, що попередньо потрібно завантажити дані в пам'ять
lw $t0, num # Із розділа з даними
li $t0, 5 # Або безпосередньо з константи
li $t1, 6
add $t2, $t0, $t1 # $t2 = $t0 + $t1
sub $t2, $t0, $t1 # $t2 = $t0 - $t1
mul $t2, $t0, $t1 # $t2 = $t0 * $t1
div $t2, $t0, $t1 # $t2 = $t0 / $t1 (Може не підтримуватись
# деякими версіями MARS)
div $t0, $t1 # Виконує $t0 / $t1. Отримати частку можна
# за допомогою команди 'mflo', остаток - 'mfhi'
# Бітовий зсув
sll $t0, $t0, 2 # Побітовий зсув вліво на 2. Біти вищого порядку
# не зберігаються, нищого - заповнюються 0
sllv $t0, $t1, $t2 # Зсув вліво зі змінною кількістю у
# регістрі
srl $t0, $t0, 5 # Побітовий зсув вправо на 5 (не зберігає
# біти, біти зліва заповнюються 0)
srlv $t0, $t1, $t2 # Зсув вправо зі змінною кількістю у
# регістрі
sra $t0, $t0, 7 # Побітовий арифметичний зсув вправо
# (зберігає біти)
srav $t0, $t1, $t2 # Зсув вправо зі змінною кількістю у
# регістрі зі збереження значеннь бітів
# Побітові операції
and $t0, $t1, $t2 # Побітове І (AND)
andi $t0, $t1, 0xFFF # Побітове І з безпосереднім значенням
or $t0, $t1, $t2 # Побітове АБО (OR)
ori $t0, $t1, 0xFFF # Побітове АБО з безпосереднім значенням
xor $t0, $t1, $t2 # Побітова виключна диз'юнкція (XOR)
xori $t0, $t1, 0xFFF # Побітове XOR з безпосереднім значенням
nor $t0, $t1, $t2 # Побітова стрілка Пірса (NOR)
## Розгалуження ##
_branching:
# В основному інструкції розгалуження мають наступну форму:
# <instr> <reg1> <reg2> <label>
# де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
# правдиве
beq $t0, $t1, reg_eq # Перейдемо у розгалуження reg_eq
# якщо $t0 == $t1, інакше -
# виконати наступний рядок
bne $t0, $t1, reg_neq # Розгалужується, якщо $t0 != $t1
b branch_target # Розгалуження без умови завжди виконується
beqz $t0, req_eq_zero # Розгалужується, якщо $t0 == 0
bnez $t0, req_neq_zero # Розгалужується, якщо $t0 != 0
bgt $t0, $t1, t0_gt_t1 # Розгалужується, якщо $t0 > $t1
bge $t0, $t1, t0_gte_t1 # Розгалужується, якщо $t0 >= $t1
bgtz $t0, t0_gt0 # Розгалужується, якщо $t0 > 0
blt $t0, $t1, t0_gt_t1 # Розгалужується, якщо $t0 < $t1
ble $t0, $t1, t0_gte_t1 # Розгалужується, якщо $t0 <= $t1
bltz $t0, t0_lt0 # Розгалужується, якщо $t0 < 0
slt $s0, $t0, $t1 # Інструкція, що посилає сигнал коли
# $t0 < $t1, результат зберігається в $s0
# (1 - правдиве твердження)
# Просте твердження якщо (if)
# if (i == j)
# f = g + h;
# f = f - i;
# Нехай $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
bne $s3, $s4, L1 # if (i !=j)
add $s0, $s1, $s2 # f = g + h
L1:
sub $s0, $s0, $s3 # f = f - i
# Нижче наведений приклад знаходження максимального значення з 3 чисел
# Пряма трансляція в Java з логіки MIPS:
# if (a > b)
# if (a > c)
# max = a;
# else
# max = c;
# else
# max = b;
# else
# max = c;
# Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регістр
ble $s0, $s1, a_LTE_b # якщо (a <= b) розгалуження(a_LTE_b)
ble $s0, $s2, max_C # якщо (a > b && a <=c) розгалуження(max_C)
move $v0, $s1 # інакше [a > b && a > c] max = a
j done # Перейти в кінець програми
a_LTE_b: # Мітка розгалуження, коли a <= b
ble $s1, $s2, max_C # якщо (a <= b && b <= c) розгалуження(max_C)
move $v0, $s1 # якщо (a <= b && b > c) max = b
j done # Перейти в кінець програми
max_C:
move $v0, $s2 # max = c
done: # Кінець програми
## Цикли ##
_loops:
# Цикл складається з умови виходу та з інструкції переходу після його завершення
li $t0, 0
while:
bgt $t0, 10, end_while # Коли $t0 менше 10, продовжувати ітерації
addi $t0, $t0, 1 # Збільшити значення
j while # Перейти на початок циклу
end_while:
# Транспонування 2D матриці
# Припустимо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
li $t0, 0 # Лічильник для i
li $t1, 0 # Лічильник для j
matrix_row:
bgt $t0, 3, matrix_row_end
matrix_col:
bgt $t1, 3, matrix_col_end
# ...
addi $t1, $t1, 1 # Збільшити лічильник стовпця (col)
matrix_col_end:
# ...
addi $t0, $t0, 1
matrix_row_end:
## Функції ##
_functions:
# Функції - це процедури, що викликаються, приймають аргументи та повертають значення
main: # Програма починається з головної функції
jal return_1 # jal збереже поточний ПЦ (програмний центр) в $ra,
# а потім перейде до return_1
# Як передати аргументи?
# По-перше, ми маємо передати значення аргументів у регістри аргументів
li $a0, 1
li $a1, 2
jal sum # Тепер ми можемо викликати функцію
# Як щодо рекурсії?
# Тут потрібно дещо більше роботи оскільки ми маємо впевнитись, що ми збережемо
# та зчитаємо попередній ПЦ в $ra, оскільки jal автоматично перепише її при виклику
li $a0, 3
jal fact
li $v0, 10
syscall
# Ця функція повертає 1
return_1:
li $v0, 1 # Завантажити val в регіст $v0
jr $ra # Повернутись до попереднього ПЦ і продовжити виконання
# Функція з двома аргументами
sum:
add $v0, $a0, $a1
jr $ra # Повернутись
# Рекурсивна функція, яка знаходить факторіал
fact:
addi $sp, $sp, -8 # Виділити місце в стеку
sw $s0, ($sp) # Зберегти регістр, що містить поточне число
sw $ra, 4($sp) # Зберегти попередній ПЦ
li $v0, 1 # Проініціалізувати значення, що повертатиметься
beq $a0, 0, fact_done # Закінчити, якщо параметр 0
# Інакше, продовжити рекурсію
move $s0, $a0 # Скопіювати $a0 в $s0
sub $a0, $a0, 1
jal fact
mul $v0, $s0, $v0 # Множення
fact_done:
lw $s0, ($sp)
lw $ra, ($sp) # Відновити ПЦ
addi $sp, $sp, 8
jr $ra
## Макроси ##
_macros:
# Макроси надзвичайно корисні для заміни блоків коду, що повторюються, за допомогою
# однієї змінної, для покращення читабельності
# Це не заміна функцій.
# Вони мають бути оголошені перед використанням
# Макрос для виведення нових рядків (оскільки операція досить часто виконується)
.macro println()
la $a0, newline # Значення нового рядка зберігатиметься тут
li $v0, 4
syscall
.end_macro
println() # Асемблер скопіює цей блок коду сюди
# перед тим, як виконувати його
# Можна передавати параметри у макроси.
# Параметри позначаються знаком '%' з довільною назвою
.macro print_int(%num)
li $v0, 1
lw $a0, %num
syscall
.end_macro
li $t0, 1
print_int($t0)
# Значення також можна передавати безпосередньо в макроси
.macro immediates(%a, %b)
add $t0, %a, %b
.end_macro
immediates(3, 5)
# Одночасно із назвами змінних
.macro print(%string)
la $a0, %string
li $v0, 4
syscall
.end_macro
print(hello_world)
## Масиви ##
.data
list: .word 3, 0, 1, 2, 6 # Це масив чисел
char_arr: .asciiz "hello" # Це текстовий масив
buffer: .space 128 # Виділяє блок пам'яті, що
# автоматично не очищується
# Ці блоки пам'яті вирівнені
# вирівнені поруч один з одним
.text
la $s0, list # Завантажити адресу списку
li $t0, 0 # Лічильник
li $t1, 5 # Довжина списку
loop:
bgt $t0, $t1, end_loop
lw $a0, ($s0)
li $v0, 1
syscall # Вивести число
addi $s0, $s0, 4 # Розмір числа - 4 байти
addi $t0, $t0, 1 # Збільшити
j loop
end_loop:
## Включення ##
# Потрібно для імпорту сторонніх файлів у програму (насправді, код з цього файлу
# копіюється та вставляється в місце, де оголошений імпорт)
.include "somefile.asm"
```

2
zh-cn/c-cn.html.markdown
View File

@ -612,7 +612,7 @@ typedef void (*my_fnp_type)(char *);
最好找一本 [K&R, aka "The C Programming Language", “C程序设计语言”](https://en.wikipedia.org/wiki/The_C_Programming_Language)。它是关于C最重要的一本书，由C的创作者撰写。不过需要留意的是它比较古老了，因此有些不准确的地方。
另一个比较好的资源是 [Learn C the hard way](http://c.learncodethehardway.org/book/)
另一个比较好的资源是 [Learn C the hard way](http://learncodethehardway.org/c/)
如果你有问题，请阅读[compl.lang.c Frequently Asked Questions](http://c-faq.com/)。

325
zh-cn/powershell-cn.html.markdown Normal file
View File

@ -0,0 +1,325 @@
---
category: tool
tool: powershell
contributors:
- ["Wouter Van Schandevijl", "https://github.com/laoujin"]
translators:
- ["Feng Gao", "https://github.com/gaufung"]
filename: LearnPowershell-cn.ps1
lang: zh-cn
---
PowerShell 是 Windows 平台下的脚本语言同时也是配置管理框架，它是建立在微软 .Net Framework 之上，Windows 7 以及之后版本都内置 Poweshell。下面的示例中都是 PoweShell 脚本的一部分或者直接能够在 Shell 交互窗口中执行。
与 Bash 最大的不同是你大部分操作的东西是对象而不是普通的文本。
[延伸阅读](https://technet.microsoft.com/en-us/library/bb978526.aspx)
如果你不确定你的环境，执行如下操作：
```powershell
Get-ExecutionPolicy -List
Set-ExecutionPolicy AllSigned
# Execution Policy 包含以下：
# - Restricted: 不会运行脚本。
# - RemoteSigned: 只会运行受信任的发行商下载的脚本。
# - AllSigned: 运行需要被信任发行商签名的脚本。
# - Unrestricted: 运行所有脚本
help about_Execution_Policies # 查看更多信息
# 当前 PowerShell 版本
$PSVersionTable
```
获取帮助
```powershell
# 查找命令
Get-Command about_* # 别名: gcm
Get-Command -Verb Add
Get-Alias ps
Get-Alias -Definition Get-Process
Get-Help ps | less # 别名: help
ps | Get-Member # 别名: gm
Show-Command Get-EventLog # GUI 填充参数
Update-Help # 管理员运行
```
接下来是教程
```powershell
# 正如你看到的，每一行开头是 # 都是注释
# 简单的 Hello World 实例
echo Hello world!
# echo 是 Write-Output (cmdlet) 的别名
# 大部分 cmdlet 和函数都遵循 "动词-名词" 命名规则。
# 每个命令都从新的一行开始或者是一个分号
echo 'This is the first line'; echo 'This is the second line'
# 声明一个变量如下：
$aString="Some string"
# 或者像这样：
$aNumber = 5 -as [double]
$aList = 1,2,3,4,5
$anEmptyList = @()
$aString = $aList -join '--' # 也包含 join 方法
$aHashtable = @{name1='val1'; name2='val2'}
# 使用变量：
echo $aString
echo "Interpolation: $aString"
echo "$aString has length of $($aString.Length)"
echo '$aString'
echo @"
This is a Here-String
$aString
"@
# 注意 ' (单引号) 不是变量的一部分
# 在这里字符串也可以是单引号
# 内置变量:
# 下面是一些有用的内置变量，比如：
echo "Booleans: $TRUE and $FALSE"
echo "Empty value: $NULL"
echo "Last program's return value: $?"
echo "Exit code of last run Windows-based program: $LastExitCode"
echo "The last token in the last line received by the session: $$"
echo "The first token: $^"
echo "Script's PID: $PID"
echo "Full path of current script directory: $PSScriptRoot"
echo 'Full path of current script: ' + $MyInvocation.MyCommand.Path
echo "FUll path of current directory: $Pwd"
echo "Bound arguments in a function, script or code block: $PSBoundParameters"
echo "Unbound arguments: $($Args -join ', ')."
# 更多的内置类型: `help about_Automatic_Variables`
# 内联其他文件 (点操作符)
. .\otherScriptName.ps1
### 控制流
# 下面是条件判断结构
if ($Age -is [string]) {
echo 'But.. $Age cannot be a string!'
} elseif ($Age -lt 12 -and $Age -gt 0) {
echo 'Child (Less than 12. Greater than 0)'
} else {
echo 'Adult'
}
# Switch 语句比其他语言更强大
$val = "20"
switch($val) {
{ $_ -eq 42 } { "The answer equals 42"; break }
'20' { "Exactly 20"; break }
{ $_ -like 's*' } { "Case insensitive"; break }
{ $_ -clike 's*'} { "clike, ceq, cne for case sensitive"; break }
{ $_ -notmatch '^.*$'} { "Regex matching. cnotmatch, cnotlike, ..."; break }
{ 'x' -contains 'x'} { "FALSE! -contains is for lists!"; break }
default { "Others" }
}
# 经典的 For 循环
for($i = 1; $i -le 10; $i++) {
"Loop number $i"
}
# 或者可以更简洁
1..10 | % { "Loop number $_" }
# PowerShell 还提供其他循环方式
foreach ($var in 'val1','val2','val3') { echo $var }
# while () {}
# do {} while ()
# do {} until ()
# 异常处理
try {} catch {} finally {}
try {} catch [System.NullReferenceException] {
echo $_.Exception | Format-List -Force
}
### Providers
# 列出当前目录下的文件和子目录
ls # 或者 `dir`
cd ~ # 回到主目录
Get-Alias ls # -> Get-ChildItem
# 这些 cmdlet 有更加通用的名称，因为它不仅仅只操作当前目录，这一点和其他脚本语言不同。
cd HKCU: # 跳转 HKEY_CURRENT_USER 注册表中的值
# 获取当前会话中的提供者
Get-PSProvider
### 管道
# Cmdlets 中的参数用来控制它们的行为：
Get-ChildItem -Filter *.txt -Name # 获取所有 txt 文件名。
# 需要输入足够多的参数来确保没有歧义。
ls -fi *.txt -n # -f 是不可以的因为 -Force 同样存在。
# 使用 `Get-Help Get-ChildItem -Full` 来查看全部参数。
# 之前 cmdlet 获取的结果输出可以作为一下个输入。
# `$_` 指代当前管道处理的对象。
ls | Where-Object { $_.Name -match 'c' } | Export-CSV export.txt
ls | ? { $_.Name -match 'c' } | ConvertTo-HTML | Out-File export.html
# 如果对管道的对象感到疑惑，使用 `Get-Member` 来查看该对象的可使用的方法和属性。
ls | Get-Member
Get-Date | gm
# ` 是行连续标识符，或者在每一行结尾添加一个 |
Get-Process | Sort-Object ID -Descending | Select-Object -First 10 Name,ID,VM `
| Stop-Process -WhatIf
Get-EventLog Application -After (Get-Date).AddHours(-2) | Format-List
# 使用 % 作为 ForEach-Object 的简称。
(a,b,c) | ForEach-Object `
-Begin { "Starting"; $counter = 0 } `
-Process { "Processing $_"; $counter++ } `
-End { "Finishing: $counter" }
# Get-Process 返回包含三列的表
# 第三列是使用 2 位精度数值表示 VM 属性
# 计算出来的列也可以表示更多的信息:
# `@{name='lbl';expression={$_}`
ps | Format-Table ID,Name,@{n='VM(MB)';e={'{0:n2}' -f ($_.VM / 1MB)}} -autoSize
### 函数
# [string] 注记是可选的。
function foo([string]$name) {
echo "Hey $name, have a function"
}
# 调用你的函数
foo "Say my name"
# 函数可以包含命名参数、参数的注记和可解析的文档
<#
.SYNOPSIS
Setup a new website
.DESCRIPTION
Creates everything your new website needs for much win
.PARAMETER siteName
The name for the new website
.EXAMPLE
New-Website -Name FancySite -Po 5000
New-Website SiteWithDefaultPort
New-Website siteName 2000 # ERROR! Port argument could not be validated
('name1','name2') | New-Website -Verbose
#>
function New-Website() {
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline=$true, Mandatory=$true)]
[Alias('name')]
[string]$siteName,
[ValidateSet(3000,5000,8000)]
[int]$port = 3000
)
BEGIN { Write-Verbose 'Creating new website(s)' }
PROCESS { echo "name: $siteName, port: $port" }
END { Write-Verbose 'Website(s) created' }
}
### 都是 .NET
# PS 中的字符串事实上就是 .NET 的 System.String 类型
# 所有 .NET 方法和属性都可用
'string'.ToUpper().Replace('G', 'ggg')
# 或者更加 PowerShell 一点
'string'.ToUpper() -replace 'G', 'ggg'
# 不确定这样的话 .NET 方法如何调用
'string' | gm
# 调用静态 .NET 方法的语法：
[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic')
# 注意 .NET 方法调用必须使用括号，然而 PS 函数调用不能使用括号；
# 如果你调用 cmdlet/PS 函数使用了括号，就相当于传递了参数列表。
$writer = New-Object System.IO.StreamWriter($path, $true)
$writer.Write([Environment]::NewLine)
$writer.Dispose()
### IO
# 从输入读入一个值
$Name = Read-Host "What's your name?"
echo "Hello, $Name!"
[int]$Age = Read-Host "What's your age?"
# Test-Path, Split-Path, Join-Path, Resolve-Path
# Get-Content filename # 返回字符串数组 string[]
# Set-Content, Add-Content, Clear-Content
Get-Command ConvertTo-*,ConvertFrom-*
### 有用的东西
# 更新 PATH
$env:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") +
";" + [System.Environment]::GetEnvironmentVariable("Path", "User")
# 找到 Python 的 PATH
$env:PATH.Split(";") | Where-Object { $_ -like "*python*"}
# 改变工作目录而不需要记住之前的路径
Push-Location c:\temp # 改变工作目录至 c:\temp
Pop-Location # 改变到之前的工作目录
# 别名: pushd 和 popd
# 在下载之后解除目录阻塞
Get-ChildItem -Recurse | Unblock-File
# Windows 资源管理器打开当前目录
ii .
# 按任意键退出
$host.UI.RawUI.ReadKey()
return
# 创建快捷方式
$WshShell = New-Object -comObject WScript.Shell
$Shortcut = $WshShell.CreateShortcut($link)
$Shortcut.TargetPath = $file
$Shortcut.WorkingDirectory = Split-Path $file
$Shortcut.Save()
```
配置你的 PowerShell
```powershell
# $Profile 是文件 `Microsoft.PowerShell_profile.ps1` 完整路径
# 下面所有的代码都在 PS 会话开始的时候执行
if (-not (Test-Path $Profile)) {
New-Item -Type file -Path $Profile -Force
notepad $Profile
}
# 更多信息: `help about_profiles`
# 更多关于 Shell 有用的信息，确保查看下面的 PSReadLine 项目。
```
更多项目
* [Channel9](https://channel9.msdn.com/Search?term=powershell%20pipeline#ch9Search&lang-en=en) PowerShell 教程
* [PSGet](https://github.com/psget/psget) PowerShell NuGet 包
* [PSReadLine](https://github.com/lzybkr/PSReadLine/) 仿 bash 按行读取（ Window10 默认包含）
* [Posh-Git](https://github.com/dahlbyk/posh-git/) Git 命令提示 (推荐!)
* [PSake](https://github.com/psake/psake) 自动构建工作
* [Pester](https://github.com/pester/Pester) BDD 测试框架
* [Jump-Location](https://github.com/tkellogg/Jump-Location) Poweshell 中 `cd` 来跳转目录
* [PowerShell Community Extensions](http://pscx.codeplex.com/) (废弃)
尚未涉及
* WMI: Windows 管理规范 (Get-CimInstance)
* 多任务: Start-Job -scriptBlock {...},
* 代码签名
* 远程 (Enter-PSSession/Exit-PSSession; Invoke-Command)

31
zh-cn/yaml-cn.html.markdown
View File

@ -33,8 +33,13 @@ scientific_notation: 1e+12
boolean: true
null_value: null
key with spaces: value
# 注意到字符串不需要被括在引号中。但是，它们可以被括起来。
"Keys can be quoted too.": "Useful if you want to put a ':' in your key."
# 注意，字符串不必被括在引号中，但也可以被括起来。
however: 'A string, enclosed in quotes.'
'Keys can be quoted too.': "Useful if you want to put a ':' in your key."
single quotes: 'have ''one'' escape pattern'
double quotes: "have many: \", \0, \t, \u263A, \x0d\x0a == \r\n, and more."
# UTF-8/16/32 字符需要被转义(encoded)
Superscript two: \u00B2
# 多行字符串既可以写成像一个'文字块'(使用 |)，
# 或像一个'折叠块'(使用 '>')。
@ -73,8 +78,8 @@ a_nested_map:
# 键也可以是复合型的，比如多行对象
# 我们用 ? 后跟一个空格来表示一个复合键的开始。
? |
This is a key
that has multiple lines
This is a key
that has multiple lines
: and this is its value
# YAML 也允许使用复杂键语法表示序列间的映射关系。
@ -85,6 +90,7 @@ a_nested_map:
: [ 2001-01-01, 2002-02-02 ]
# 序列 (等价于列表或数组) 看起来像这样：
# 注意 '-' 算作缩进
a_sequence:
- Item 1
- Item 2
@ -95,6 +101,8 @@ a_sequence:
-
- This is a sequence
- inside another sequence
- - - Nested sequence indicators
- can be collapsed
# 因为 YAML 是 JSON 的超集，你也可以写 JSON 风格的映射和序列：
json_map: {"key": "value"}
@ -157,15 +165,18 @@ gif_file: !!binary |
# YAML 还有一个集合类型，它看起来像这样：
set:
? item1
? item2
? item3
? item1
? item2
? item3
or: {item1, item2, item3}
# 集合只是值为 null 的映射；上面的集合等价于：
set2:
item1: null
item2: null
item3: null
item1: null
item2: null
item3: null
... # document end
```
### 更多资源