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

Reset to Adambard's

Browse Source
This commit is contained in:
bk2dcradle 2016-01-05 13:34:10 +05:30
commit 0e3ed9579b
112 changed files with 12699 additions and 1417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
c++.html.markdown
View File

@ -149,7 +149,7 @@ namespace First {
namespace Second { namespace Second {
void foo() void foo()
{ {
printf("This is Second::foo\n") printf("This is Second::foo\n");
} }
} }
@ -801,72 +801,24 @@ void doSomethingWithAFile(const std::string& filename)
// all automatically destroy their contents when they fall out of scope. // all automatically destroy their contents when they fall out of scope.
// - Mutexes using lock_guard and unique_lock // - Mutexes using lock_guard and unique_lock
/////////////////////////////////////// // containers with object keys of non-primitive values (custom classes) require
// Lambda Expressions (C++11 and above) // compare function in the object itself or as a function pointer. Primitives
/////////////////////////////////////// // have default comparators, but you can override it.
class Foo {
// lambdas are a convenient way of defining an anonymous function public:
// object right at the location where it is invoked or passed as int j;
// an argument to a function. Foo(int a) : j(a) {}
};
// For example, consider sorting a vector of pairs using the second struct compareFunction {
// value of the pair bool operator()(const Foo& a, const Foo& b) const {
return a.j < b.j;
vector<pair<int, int> > tester;
tester.push_back(make_pair(3, 6));
tester.push_back(make_pair(1, 9));
tester.push_back(make_pair(5, 0));
// Pass a lambda expression as third argument to the sort function
// sort is from the <algorithm> header
sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs.second < rhs.second;
});
// Notice the syntax of the lambda expression,
// [] in the lambda is used to "capture" variables.
// For Example:
vector<int> dog_ids;
// number_of_dogs = 3;
for(int i = 0; i < 3; i++){
dog_ids.push_back(i);
}
int weight[3] = {30, 50, 10};
// Say you want to sort dog_ids according to the dogs' weights
// So dog_ids should in the end become: [2, 0, 1]
// Here's where lambda expressions come in handy
sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) {
return weight[lhs] < weight[rhs];
});
// Note we captured "weight" by reference in the above example.
// lambda are really useful for the case of structs
// You can use lambda expressions instead of overloading
// the "<" operator
///////////////////////////////
// Range For (C++11 and above)
///////////////////////////////
// You can use a range for loop to iterate over a container
int arr[] = {1, 10, 3};
for(int elem: arr){
cout << elem << endl;
}
// You can use "auto" and not worry about the type of the elements of the container
// For example:
for(auto elem: arr) {
// Do something with each element of arr
} }
};
//this isn't allowed (although it can vary depending on compiler)
//std::map<Foo, int> fooMap;
std::map<Foo, int, compareFunction> fooMap;
fooMap[Foo(1)] = 1;
fooMap.find(Foo(1)); //true
///////////////////// /////////////////////
// Fun stuff // Fun stuff

23
c.html.markdown
View File

@ -148,15 +148,10 @@ int main (int argc, char** argv)
printf("Enter the array size: "); // ask the user for an array size printf("Enter the array size: "); // ask the user for an array size
int size; int size;
fscanf(stdin, "%d", &size); fscanf(stdin, "%d", &size);
char buf[size]; int var_length_array[size]; // declare the VLA
fgets(buf, sizeof buf, stdin);
// strtoul parses a string to an unsigned integer
size_t size2 = strtoul(buf, NULL, 10);
int var_length_array[size2]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array); printf("sizeof array = %zu\n", sizeof var_length_array);
// A possible outcome of this program may be: // Example:
// > Enter the array size: 10 // > Enter the array size: 10
// > sizeof array = 40 // > sizeof array = 40
@ -244,7 +239,7 @@ int main (int argc, char** argv)
z = (e > f) ? e : f; // => 10 "if e > f return e, else return f." z = (e > f) ? e : f; // => 10 "if e > f return e, else return f."
// Increment and decrement operators: // Increment and decrement operators:
char *s = "iLoveC"; char *s = "ILoveC";
int j = 0; int j = 0;
s[j++]; // => "i". Returns the j-th item of s THEN increments value of j. s[j++]; // => "i". Returns the j-th item of s THEN increments value of j.
j = 0; j = 0;
@ -318,9 +313,15 @@ int main (int argc, char** argv)
case 1: case 1:
printf("Huh, 'a' equals 1!\n"); printf("Huh, 'a' equals 1!\n");
break; break;
// Be careful - without a "break", execution continues until the
// next "break" is reached.
case 3:
case 4:
printf("Look at that.. 'a' is either 3, or 4\n");
break;
default: default:
// if `some_integral_expression` didn't match any of the labels // if `some_integral_expression` didn't match any of the labels
fputs("error!\n", stderr); fputs("Error!\n", stderr);
exit(-1); exit(-1);
break; break;
} }
@ -496,7 +497,7 @@ int add_two_ints(int x1, int x2)
/* /*
Functions are call by value. When a function is called, the arguments passed to Functions are call by value. When a function is called, the arguments passed to
≈the function are copies of the original arguments (except arrays). Anything you the function are copies of the original arguments (except arrays). Anything you
do to the arguments in the function do not change the value of the original do to the arguments in the function do not change the value of the original
argument where the function was called. argument where the function was called.
@ -725,7 +726,7 @@ Header files are an important part of c as they allow for the connection of c
source files and can simplify code and definitions by seperating them into source files and can simplify code and definitions by seperating them into
seperate files. seperate files.
Header files are syntaxtically similar to c source files but reside in ".h" Header files are syntactically similar to c source files but reside in ".h"
files. They can be included in your c source file by using the precompiler files. They can be included in your c source file by using the precompiler
command #include "example.h", given that example.h exists in the same directory command #include "example.h", given that example.h exists in the same directory
as the c file. as the c file.

59
coldfusion.html.markdown
View File

@ -3,13 +3,17 @@ language: coldfusion
filename: learncoldfusion.cfm filename: learncoldfusion.cfm
contributors: contributors:
- ["Wayne Boka", "http://wboka.github.io"] - ["Wayne Boka", "http://wboka.github.io"]
- ["Kevin Morris", "https://twitter.com/kevinmorris"]
--- ---
ColdFusion is a scripting language for web development. ColdFusion is a scripting language for web development.
[Read more here.](http://www.adobe.com/products/coldfusion-family.html) [Read more here.](http://www.adobe.com/products/coldfusion-family.html)
```html ### CFML
_**C**old**F**usion **M**arkup **L**anguage_
ColdFusion started as a tag-based language. Almost all functionality is available using tags.
```html
<em>HTML tags have been provided for output readability</em> <em>HTML tags have been provided for output readability</em>
<!--- Comments start with "<!---" and end with "--->" ---> <!--- Comments start with "<!---" and end with "--->" --->
@ -229,40 +233,38 @@ ColdFusion is a scripting language for web development.
<em>Code for reference (Functions must return something to support IE)</em> <em>Code for reference (Functions must return something to support IE)</em>
<pre> <cfcomponent>
&lt;cfcomponent&gt; <cfset this.hello = "Hello" />
&lt;cfset this.hello = "Hello" /&gt; <cfset this.world = "world" />
&lt;cfset this.world = "world" /&gt;
&lt;cffunction name="sayHello"&gt; <cffunction name="sayHello">
&lt;cfreturn this.hello & ", " & this.world & "!" /&gt; <cfreturn this.hello & ", " & this.world & "!" />
&lt;/cffunction&gt; </cffunction>
&lt;cffunction name="setHello"&gt; <cffunction name="setHello">
&lt;cfargument name="newHello" type="string" required="true" /&gt; <cfargument name="newHello" type="string" required="true" />
&lt;cfset this.hello = arguments.newHello /&gt; <cfset this.hello = arguments.newHello />
&lt;cfreturn true /&gt; <cfreturn true />
&lt;/cffunction&gt; </cffunction>
&lt;cffunction name="setWorld"&gt; <cffunction name="setWorld">
&lt;cfargument name="newWorld" type="string" required="true" /&gt; <cfargument name="newWorld" type="string" required="true" />
&lt;cfset this.world = arguments.newWorld /&gt; <cfset this.world = arguments.newWorld />
&lt;cfreturn true /&gt; <cfreturn true />
&lt;/cffunction&gt; </cffunction>
&lt;cffunction name="getHello"&gt; <cffunction name="getHello">
&lt;cfreturn this.hello /&gt; <cfreturn this.hello />
&lt;/cffunction&gt; </cffunction>
&lt;cffunction name="getWorld"&gt; <cffunction name="getWorld">
&lt;cfreturn this.world /&gt; <cfreturn this.world />
&lt;/cffunction&gt; </cffunction>
&lt;/cfcomponent&gt; </cfcomponent>
</pre>
<cfset this.hello = "Hello" /> <cfset this.hello = "Hello" />
<cfset this.world = "world" /> <cfset this.world = "world" />
@ -314,8 +316,13 @@ ColdFusion is a scripting language for web development.
<cfoutput><p>#getWorld()#</p></cfoutput> <cfoutput><p>#getWorld()#</p></cfoutput>
``` ```
### CFScript
_**C**old**F**usion **S**cript_
In recent years, the ColdFusion language has added script syntax to mirror tag functionality. When using an up-to-date CF server, almost all functionality is available using scrypt syntax.
## Further Reading ## Further Reading
The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples.
1. [Coldfusion Reference From Adobe](https://helpx.adobe.com/coldfusion/cfml-reference/topics.html) 1. [Coldfusion Reference From Adobe](https://helpx.adobe.com/coldfusion/cfml-reference/topics.html)
2. [Open Source Documentation](http://cfdocs.org/)

9
common-lisp.html.markdown
View File

@ -614,9 +614,16 @@ nil ; for false - and the empty list
## Further Reading ## Further Reading
[Keep moving on to the Practical Common Lisp book.](http://www.gigamonkeys.com/book/) * [Keep moving on to the Practical Common Lisp book.](http://www.gigamonkeys.com/book/)
* [A Gentle Introduction to...](https://www.cs.cmu.edu/~dst/LispBook/book.pdf)
## Extra Info
* [CLiki](http://www.cliki.net/)
* [common-lisp.net](https://common-lisp.net/)
* [Awesome Common Lisp](https://github.com/CodyReichert/awesome-cl)
## Credits. ## Credits.
Lots of thanks to the Scheme people for rolling up a great starting Lots of thanks to the Scheme people for rolling up a great starting

259
cs-cz/markdown.html.markdown Normal file
View File

@ -0,0 +1,259 @@
---
language: markdown
contributors:
- ["Dan Turkel", "http://danturkel.com/"]
translators:
- ["Michal Martinek", "https://github.com/MichalMartinek"]
filename: markdown.md
lang: cs-cz
---
Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce čitelná
a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
dalších formátů)
```markdown
<!-- Markdown je nadstavba nad HTML, takže jakýkoliv kód HTML je validní
Markdown, to znamená, že můžeme používat HTML elementy, třeba jako komentář, a
nebudou ovlivněny parserem Markdownu. Avšak, pokud vytvoříte HTML element v
Markdownu, tak nemůžete používat syntaxi Markdownu uvnitř tohoto elementu. -->
<!-- Markdown se také mírně liší v jednotlivých interpretacích parseru. Tento
návod vás bude upozorňovat, které vlastnosti jsou obecné a které specifické pro
konkrétní parser. -->
<!-- Nadpisy -->
<!-- Můžete vytvořit HTML elementy <h1> až <h6> jednoduše tak, že text předsadíte
počtem křížků (#), podle toho jaké úrovně to má být nadpis -->
# Toto je <h1>
## Toto je <h2>
### Toto je <h3>
#### Toto je <h4>
##### Toto je <h5>
###### Toto je <h6>
<!-- Markdown obsahuje taky dvě další cesty, jak udělat h1 a h2 -->
Toto je h1
==========
Toto je h2
----------
<!-- Jednoduché stylování textu -->
<!-- Pomocí markdownu můžete text jednoduše označit jako kurzívu či tučný -->
*Tento text je kurzívou;*
_Stejně jako tento._
**Tento text je tučně**
__Stejně jako tento.__
***Tento text je obojí***
**_Jako tento!_**
*__A tento!__*
<!-- Ve verzi Markdownu od Githubu, máme k dispozici taky prošktrnutí: -->
~~Tento text je prošktrnutý.~~
<!-- Odstavce jsou jedna nebo více řádek textu, oddělených jednou nebo více prázdnými řádky. -->
Toto je odstavec. Píši odstavec, není to zábava?
Teď jsem v odstavci 2.
Jsem pořád v odstavci 2!
Toto je odstavec 3.
<!-- Chtěli jste někdy vložit znak <br /> tag? Můžete napsat na konec odstavce
dvě nebo více mezer a potom začít nový odstavec. -->
Tento odstavec končí dvěma mezerami.
Nad tímto odstavcem je <br />!
<!-- Blokové citace se dělají jednoduše pomocí znaku >. -->
> Toto je bloková citace. Můžete dokonce
> manuálně rozdělit řádky, a před každý vložit >, nebo nechat vaše řádky jakkoliv dlouhé, ať se zarovnají sami.
> Nedělá to rozdíl, dokud začínáte vždy znakem >.
> Můžu použít více než jednu
>> odsazení?
> Jak je to úhledné, že?
<!-- Seznamy -->
<!-- Nečíslovaný seznam můžete jednoduše udělat pomocí hvězdiček, plusů, nebo
pomlček -->
* Položka
* Položka
* Jinná položka
nebo
+ Položka
+ Položka
+ Další položka
nebo
- Položka
- Položka
- Další položka
<!-- Číslovaný seznam se dělají pomocí čísla a . -->
1. Položka jedna
2. Položka dvě
3. Položka tři
<!-- Nemusíte dokonce psát čísla správně a markdown je zobrazi správně,
ale nemusí to být vždy dobrý nápad -->
1. Položka jedna
1. Položka dvě
1. Položka tři
<!-- (Toto zobrazí to samě, jako příklad nadtím.) -->
<!-- Můžete také tvořit podseznamy -->
1. Položka jedna
2. Položka dvě
3. Položka tři
* Podpoložka
* Podpoložka
4. Položka čtyři
<!-- Existují i zašktávací seznamy. Toto vytvoří HTML checkboxy. -->
Boxy níže bez 'x' jsou nezašktrnuté checkboxy.
- [ ] První úkol
- [ ] Druhý úkol
Tento box bude zašktrnutý
- [x] Tento úkol byl dokončen
<!-- Bloky ködu -->
<!-- Můžete označit kód bloku (který používá <code> element) odsazením pomocí 4
mezer, nebo tabu -->
Toto je kód
Stejně jako toto
<!-- Můžete dokonce přidat další 4 mezery nebo tab pro další odsazení -->
moje_pole.each do |i|
puts i
end
<!-- Kód na řádku může být označen pomocí zpětných apostrofů ` -->
Jan nevědel, jak se dělá `go_to()` funkce!
<!-- V Markdownu od Githubu , můžete použít speciální syntaxi pro kód -->
\`\`\`ruby <!-- vyjma zpětných lomítek, jenom ```ruby ! -->
def neco
puts "Ahoj světe!"
end
\`\`\` <!-- zde taky, žádné zpětná lomítka, pouze ``` -->
<!-- Text výše nepotřebuje odsazení a navíc Github použije zvýraznění označeného
jazyka. -->
<!-- Horizontální čára (<hr />) -->
<!-- Horizontální čára se jednoduše přidá pomocí 3 nebo více hvězdiček nebo pomlček
s nebo bez mezer. -->
***
---
- - -
****************
<!-- Odkazy -->
<!-- Jedna z nejlepších věcí na Markdownu je, jak jednoduše se dělají odkazy.
Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a je to. -->
[Klikni na mě!](http://test.com/)
<!-- Můžete také přidat jméno linku pomocí uvozovek -->
[Klikni na mě!](http://test.com/ "Odkaz na Test.com")
<!-- Relativní cesty fungují taky -->
[Jdi na hudbu](/hudba/).
<!-- Markdown taktéž podporuje reference odkazů. -->
[Klikni na tento odkaz][link1] pro více informací!
[Taky zkontrolujte tento odkaz][neco], když chcete.
[link1]: http://test.com/ "Cool!"
[neco]: http://neco.czz/ "Dobře!"
<!-- Titulek může být v apostrofech nebo závorkách, nebo vyjmutý úplně. Reference
může být kdekoliv ve vašem dokumentu a identifikátor může být jakýkoliv, dokud
je unikátní.-->
<!-- Také existuje "implicitní pojmenování", které použije text jako id -->
[Toto][] je odkaz..
[toto]: http://totojelink.cz/
<!-- Ale toto není zrovna běžné užívané. -->
<!-- Obrázky -->
<!-- Obrázky se dělají stejně jako odkazy, ale s vykřičníkem na začátku -->
![Toto je atribut alt pro obrázek](http://imgur.com/myimage.jpg "Nepovinný titulek")
<!-- Reference fungují, jak bychom čekali-->
![Toto je atribut alt][mujobrazek]
[mujobrazek]: relativni/cesta/obrazek.jpg "a toto by byl titulek"
<!-- Ostatní -->
<!-- Automatické odkazy -->
<http://stranka.cz/> je stejná jako
[http://stranka.cz/](http://stranka.cz/)
<!-- Automatické odkazy pro emaily-->
<jmeno@prijmeni.cz>
<!-- Escapování znaků -->
Chci napsat *tento text obklopený hvězdičkami*, ale nechci aby to bylo kurzívou, tak udělám: \*tento text obklopený hvězdičkami\*.
<!-- Klávesové zkratky -->
<!-- V Markdownu od Githubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
Váš počítač přestal pracovat? Zkuste
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
<!-- Tabulky -->
<!-- Tabulky jsou povolené pouze v Markdownu od Githubu a jsou trochu podivně,
ale když je opravdu chcete: -->
| Sloupec1 | Sloupec2 | Sloupec3 |
| :----------- | :------: | ------------: |
| Vlevo zarovn.| Na střed | Vpravo zarovn.|
| blah | blah | blah |
<!-- nebo, to jde i taky: -->
Sloupec 1 | Sloupec2 | Sloupec3
:-- | :-: | --:
Ohh toto je tak ošklivé | radši to | nedělejte
<!-- Konec -->
```
Pro více informací, prozkoumejte oficiální článek o syntaxi od Johna Grubera
[zde](http://daringfireball.net/projects/markdown/syntax) a skvělý tahák od Adama Pritcharda [zde](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).

2
cs-cz/python3.html.markdown
View File

@ -566,7 +566,7 @@ Clovek.odkaslej_si() # => "*ehm*"
# Lze importovat moduly # Lze importovat moduly
import math import math
print(math.sqrt(16)) # => 4 print(math.sqrt(16.0)) # => 4
# Lze také importovat pouze vybrané funkce z modulu # Lze také importovat pouze vybrané funkce z modulu
from math import ceil, floor from math import ceil, floor

439
cs-cz/sass.html.markdown Normal file
View File

@ -0,0 +1,439 @@
---
language: sass
filename: learnsass-cz.scss
contributors:
- ["Laura Kyle", "https://github.com/LauraNK"]
- ["Sean Corrales", "https://github.com/droidenator"]
translators:
- ["Michal Martinek", "https://github.com/MichalMartinek"]
lang: cs-cz
---
Sass je rozšíření jazyka CSS, který přidává nové vlastnosti jako proměnné, zanořování, mixiny a další.
Sass (a další preprocesory, jako [Less](http://lesscss.org/)) pomáhají vývojářům psát udržovatelný a neopakující (DRY) kód.
Sass nabízí dvě možnosti syntaxe. SCSS, které je stejná jako CSS, akorát obsahuje nové vlastnosti Sassu. Nebo Sass, který používá odsazení místo složených závorek a středníků.
Tento tutoriál bude používat syntaxi CSS.
Pokud jste již obeznámeni s CSS3, budete schopni používat Sass relativně rychle. Nezprostředkovává nějaké úplně nové stylové možnosti, spíše nátroje, jak psát Vás CSS kód více efektivně, udržitelně a jednoduše.
```scss
//Jednořádkové komentáře jsou ze Sassu při kompilaci vymazány
/*Víceřádkové komentáře jsou naopak zachovány */
/*Proměnné
==============================*/
/* Můžete uložit CSS hodnotu (jako třeba barvu) do proměnné.
Použijte symbol '$' k jejímu vytvoření. */
$hlavni-barva: #A3A4FF;
$sekundarni-barva: #51527F;
$body-font: 'Roboto', sans-serif;
/* Můžete používat proměnné napříč vaším souborem.
Teď, když chcete změnit barvu, stačí ji změnit pouze jednou.*/
body {
background-color: $hlavni-barva;
color: $sekundarni-barva;
font-family: $body-font;
}
/* Toto se zkompiluje do: */
body {
background-color: #A3A4FF;
color: #51527F;
font-family: 'Roboto', sans-serif;
}
/* Toto je o hodně více praktické, než měnit každý výskyt barvy. */
/*Mixiny
==============================*/
/* Pokud zjistíte, že píšete kód pro více než jeden element, můžete jej uložit do mixinu.
Použijte '@mixin' direktivu, plus jméno vašeho mixinu.*/
@mixin na-stred {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
}
/* Mixin vložíte pomocí '@include' a jména mixinu */
div {
@include na-stred;
background-color: $hlavni-barva;
}
/*Což se zkompiluje do: */
div {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
background-color: #A3A4FF;
}
/* Můžete využít mixiny i třeba pro takovéto ušetření práce: */
@mixin velikost($sirka, $vyska) {
width: $sirka;
height: $vyska;
}
/*Stačí vložit argumenty: */
.obdelnik {
@include velikost(100px, 60px);
}
.ctverec {
@include velikost(40px, 40px);
}
/* Toto se zkompiluje do: */
.obdelnik {
width: 100px;
height: 60px;
}
.ctverec {
width: 40px;
height: 40px;
}
/*Funkce
==============================*/
/* Sass obsahuje funkce, které vám pomůžou splnit různé úkoly. */
/* Funkce se spouštějí pomocí jejich jména, které následuje seznam argumentů uzavřený v kulatých závorkách. */
body {
width: round(10.25px);
}
.footer {
background-color: fade_out(#000000, 0.25)
}
/* Se zkompiluje do: */
body {
width: 10px;
}
.footer {
background-color: rgba(0, 0, 0, 0.75);
}
/* Můžete také definovat vlastní funkce. Funkce jsou velmi podobné mixinům.
Když se snažíte vybrat mezi funkcí a mixinem, mějte na paměti, že mixiny
jsou lepší pro generování CSS kódu, zatímco funkce jsou lepší pro logiku.
Příklady ze sekce Matematické operátory jsou skvělí kandidáti na
znovupoužitelné funkce. */
/* Tato funkce vrací poměr k velikosti rodiče v procentech.
@function vypocitat-pomer($velikost, $velikost-rodice) {
@return $velikost / $velikost-rodice * 100%;
}
$hlavni obsah: vypocitat-pomer(600px, 960px);
.hlavni-obsah {
width: $hlavni-obsah;
}
.sloupec {
width: vypocitat-pomer(300px, 960px);
}
/* Zkompiluje do: */
.hlavni-obsah {
width: 62.5%;
}
.sloupec {
width: 31.25%;
}
/*Dědění
==============================*/
/*Dědění je způsob jak používat vlastnosti pro jeden selektor ve druhém. */
.oznameni {
@include velikost(5em, 5em);
border: 5px solid $sekundarni-barva;
}
.oznameni-uspech {
@extend .oznameni;
border-color: #22df56;
}
/* Zkompiluje do: */
.oznameni, .oznameni-uspech {
width: 5em;
height: 5em;
border: 5px solid #51527F;
}
.oznameni-uspech {
border-color: #22df56;
}
/* Dědění CSS výrazů je preferováno před vytvořením mixinu kvůli způsobu,
jakým způsobem Sass dává dohromady třídy, které sdílejí stejný kód.
Kdyby to bylo udělané pomocí mixinu, tak výška, šířka, rámeček by byl v
každém výrazu, který by volal mixin. I když tohle neovlivní vaše workflow,
přidá to kód navíc do souborů. */
/*Zanořování
==============================*/
/*Sass vám umožňuje zanořovat selektory do selektorů */
ul {
list-style-type: none;
margin-top: 2em;
li {
background-color: #FF0000;
}
}
/* '&' nahradí rodičovský element. */
/* Můžete také zanořovat pseudo třídy. */
/* Pamatujte, že moc velké zanoření do hloubky snižuje čitelnost.
Doporučuje se používat maximálně trojité zanoření.
Na příklad: */
ul {
list-style-type: none;
margin-top: 2em;
li {
background-color: red;
&:hover {
background-color: blue;
}
a {
color: white;
}
}
}
/* Zkompiluje do: */
ul {
list-style-type: none;
margin-top: 2em;
}
ul li {
background-color: red;
}
ul li:hover {
background-color: blue;
}
ul li a {
color: white;
}
/*Částečné soubory a importy
==============================*/
/* Sass umožňuje vytvářet částečné soubory. Tyto soubory pomahájí udržovat váš
kód modulární. Tyto soubory by měli začínat vždy '_', např. _reset.css.
Částečné soubory se nepřevádí do CSS. */
/* Toto je kód, který si uložíme do souboru _reset.css */
html,
body,
ul,
ol {
margin: 0;
padding: 0;
}
/* Sass obsahuje @import, které může být použit pro import částečných souborů.
Toto se liší od klasického CSS @import, který dělá HTTP požadavek na stáhnutí
souboru. Sass vezme importovaný soubor a vloží ho do kompilovaného kódu. */
@import 'reset';
body {
font-size: 16px;
font-family: Helvetica, Arial, Sans-serif;
}
/* Zkompiluje do: */
html, body, ul, ol {
margin: 0;
padding: 0;
}
body {
font-size: 16px;
font-family: Helvetica, Arial, Sans-serif;
}
/*Zástupné selektory
==============================*/
/* Zástupné selektory jsou užitečné, když vytváříte CSS výraz, ze kterého
chcete později dědit. Když chcete vytvořit výraz, ze kterého je možné pouze
dědit pomocí @extend, vytvořte zástupný selektor s CSS výrazem. Ten začíná
symbolem '%' místo '.' nebo '#'. Tyto výrazy se neobjeví ve výsledném CSS */
%okno-obsahu {
font-size: 14px;
padding: 10px;
color: #000;
border-radius: 4px;
}
.okno-zpravy {
@extend %okno-obsahu;
background-color: #0000ff;
}
/* Zkompiluje do: */
.okno-zpravy {
font-size: 14px;
padding: 10px;
color: #000;
border-radius: 4px;
}
.okno-zpravy {
background-color: #0000ff;
}
/*Matematické operace
==============================*/
/* Sass obsahuje následující operátory: +, -, *, /, and %. Tyto operátory
můžou být velmi užitečné pro počítání hodnot přímo ve vašem souboru Sass.
Níže je příklad, jak udělat jednoduchý dvousloupcový layout. */
$oblast-obsahu: 960px;
$hlavni-obsah: 600px;
$vedlejsi-sloupec: 300px;
$obsah-velikost: $hlavni-obsah / $oblast-obsahu * 100%;
$vedlejsi-sloupec-velikost: $vedlejsi-sloupec / $oblast-obsahu * 100%;
$zbytek-velikost: 100% - ($main-size + $vedlejsi-sloupec-size);
body {
width: 100%;
}
.hlavni-obsah {
width: $obsah-velikost;
}
.vedlejsi-sloupec {
width: $vedlejsi-sloupec-velikost;
}
.zbytek {
width: $zbytek-velikost;
}
/* Zkompiluje do: */
body {
width: 100%;
}
.hlavni-obsah {
width: 62.5%;
}
.vedlejsi-sloupec {
width: 31.25%;
}
.gutter {
width: 6.25%;
}
```
## SASS nebo Sass?
Divili jste se někdy, jestli je Sass zkratka nebo ne? Pravděpodobně ne, ale řeknu vám to stejně. Jméno tohoto jazyka je slovo, "Sass", a ne zkratka.
Protože to lidé konstatně píší jako "SASS", nazval ho autor jazyka jako "Syntactically Awesome StyleSheets" (Syntaktický úžasně styly).
## Procvičování Sassu
Pokud si chcete hrát se Sassem ve vašem prohlížeči, navštivte [SassMeister](http://sassmeister.com/).
Můžete používát oba dva způsoby zápisu, stačí si vybrat v nastavení SCSS nebo SASS.
## Kompatibilita
Sass může být použit v jakémkoliv projektu, jakmile máte program, pomocí kterého ho zkompilujete do CSS. Pokud si chcete ověřit, že CSS, které Sass produkuje je kompatibilní s prohlížeči:
[QuirksMode CSS](http://www.quirksmode.org/css/) a [CanIUse](http://caniuse.com) jsou skvělé stránky pro kontrolu kompatibility.
## Kam dál?
* [Oficiální dokumentace](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
* [The Sass Way](http://thesassway.com/) obsahuje tutoriál a řadu skvělých článků

6
csharp.html.markdown
View File

@ -45,8 +45,8 @@ using System.Data.Entity;
// Using this code from another source file: using Learning.CSharp; // Using this code from another source file: using Learning.CSharp;
namespace Learning.CSharp namespace Learning.CSharp
{ {
// Each .cs file should at least contain a class with the same name as the file // Each .cs file should at least contain a class with the same name as the file.
// you're allowed to do otherwise, but shouldn't for sanity. // You're allowed to do otherwise, but shouldn't for sanity.
public class LearnCSharp public class LearnCSharp
{ {
// BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before // BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before
@ -630,7 +630,7 @@ on a new line! ""Wow!"", the masses cried";
public static class Extensions public static class Extensions
{ {
// EXTENSION FUNCTIONS // EXTENSION METHODS
public static void Print(this object obj) public static void Print(this object obj)
{ {
Console.WriteLine(obj.ToString()); Console.WriteLine(obj.ToString());

35
css.html.markdown
View File

@ -6,20 +6,21 @@ contributors:
- ["Geoffrey Liu", "https://github.com/g-liu"] - ["Geoffrey Liu", "https://github.com/g-liu"]
- ["Connor Shea", "https://github.com/connorshea"] - ["Connor Shea", "https://github.com/connorshea"]
- ["Deepanshu Utkarsh", "https://github.com/duci9y"] - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
- ["Tyler Mumford", "https://tylermumford.com"]
filename: learncss.css filename: learncss.css
--- ---
In the early days of the web there were no visual elements, just pure text. But with further development of web browsers, fully visual web pages also became common. Web pages are built with HTML, which specifies the content of a page. CSS (Cascading Style Sheets) is a separate language which specifies a page's **appearance**.
CSS helps maintain separation between the content (HTML) and the look-and-feel of a web page. CSS code is made of static *rules*. Each rule takes one or more *selectors* and gives specific *values* to a number of visual *properties*. Those properties are then applied to the page elements indicated by the selectors.
CSS lets you target different elements on an HTML page and assign different visual properties to them. This guide has been written with CSS 2 in mind, which is extended by the new features of CSS 3.
This guide has been written for CSS 2, though CSS 3 is fast becoming popular. **NOTE:** Because CSS produces visual results, in order to learn it, you need to try everything in a CSS playground like [dabblet](http://dabblet.com/).
**NOTE:** Because CSS produces visual results, in order to learn it, you need try everything in a CSS playground like [dabblet](http://dabblet.com/).
The main focus of this article is on the syntax and some general tips. The main focus of this article is on the syntax and some general tips.
## Syntax
```css ```css
/* comments appear inside slash-asterisk, just like this line! /* comments appear inside slash-asterisk, just like this line!
there are no "one-line comments"; this is the only comment style */ there are no "one-line comments"; this is the only comment style */
@ -28,7 +29,7 @@ The main focus of this article is on the syntax and some general tips.
## SELECTORS ## SELECTORS
#################### */ #################### */
/* the selector is used to target an element on a page. /* the selector is used to target an element on a page. */
selector { property: value; /* more properties...*/ } selector { property: value; /* more properties...*/ }
/* /*
@ -69,7 +70,7 @@ div { }
[otherAttr|='en'] { font-size:smaller; } [otherAttr|='en'] { font-size:smaller; }
/* You can concatenate different selectors to create a narrower selector. Don't /* You can combine different selectors to create a more focused selector. Don't
put spaces between them. */ put spaces between them. */
div.some-class[attr$='ue'] { } div.some-class[attr$='ue'] { }
@ -92,7 +93,7 @@ div.some-parent.class-name { }
.i-am-any-element-before ~ .this-element { } .i-am-any-element-before ~ .this-element { }
/* There are some selectors called pseudo classes that can be used to select an /* There are some selectors called pseudo classes that can be used to select an
element when it is in a particular state */ element only when it is in a particular state */
/* for example, when the cursor hovers over an element */ /* for example, when the cursor hovers over an element */
selector:hover { } selector:hover { }
@ -103,7 +104,7 @@ selector:visited { }
/* or hasn't been visited */ /* or hasn't been visited */
selected:link { } selected:link { }
/* or an element in focus */ /* or an element is in focus */
selected:focus { } selected:focus { }
/* any element that is the first child of its parent */ /* any element that is the first child of its parent */
@ -156,10 +157,10 @@ selector {
color: tomato; /* a named color */ color: tomato; /* a named color */
color: rgb(255, 255, 255); /* as rgb values */ color: rgb(255, 255, 255); /* as rgb values */
color: rgb(10%, 20%, 50%); /* as rgb percentages */ 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: 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: transparent; /* equivalent to setting the alpha to 0 */
color: hsl(0, 100%, 50%); /* as hsl percentages (CSS 3) */ color: hsl(0, 100%, 50%); /* as hsl percentages (CSS 3) */
color: hsla(0, 100%, 50%, 0.3); /* as hsla percentages with alpha */ color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
/* Images as backgrounds of elements */ /* Images as backgrounds of elements */
background-image: url(/img-path/img.jpg); /* quotes inside url() optional */ background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
@ -194,7 +195,7 @@ Save a CSS stylesheet with the extension `.css`.
## Precedence or Cascade ## Precedence or Cascade
An element may be targeted by multiple selectors and may have a property set on it in more than once. In these cases, one of the rules takes precedence over others. Generally, a rule in a more specific selector take precedence over a less specific one, and a rule occuring later in the stylesheet overwrites a previous one. An element may be targeted by multiple selectors and may have a property set on it in more than once. In these cases, one of the rules takes precedence over others. Rules with a more specific selector take precedence over a less specific one, and a rule occuring later in the stylesheet overwrites a previous one.
This process is called cascading, hence the name Cascading Style Sheets. This process is called cascading, hence the name Cascading Style Sheets.
@ -238,10 +239,10 @@ Most of the features in CSS 2 (and many in CSS 3) are available across all brows
## Resources ## Resources
* To run a quick compatibility check, [CanIUse](http://caniuse.com). * [CanIUse](http://caniuse.com) (Detailed compatibility info)
* CSS Playground [Dabblet](http://dabblet.com/). * [Dabblet](http://dabblet.com/) (CSS playground)
* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) * [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/) * [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) (Reference)
## Further Reading ## Further Reading

34
d.html.markdown
View File

@ -53,15 +53,15 @@ void main() {
// For and while are nice, but in D-land we prefer 'foreach' loops. // For and while are nice, but in D-land we prefer 'foreach' loops.
// The '..' creates a continuous range, including the first value // The '..' creates a continuous range, including the first value
// but excluding the last. // but excluding the last.
foreach(i; 1..1_000_000) { foreach(n; 1..1_000_000) {
if(n % 2 == 0) if(n % 2 == 0)
writeln(i); writeln(n);
} }
// There's also 'foreach_reverse' when you want to loop backwards. // There's also 'foreach_reverse' when you want to loop backwards.
foreach_reverse(i; 1..int.max) { foreach_reverse(n; 1..int.max) {
if(n % 2 == 1) { if(n % 2 == 1) {
writeln(i); writeln(n);
} else { } else {
writeln("No!"); writeln("No!");
} }
@ -70,7 +70,7 @@ void main() {
``` ```
We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions
are passed to functions by value (i.e. copied) and classes are passed by reference. Futhermore, are passed to functions by value (i.e. copied) and classes are passed by reference. Furthermore,
we can use templates to parameterize all of these on both types and values! we can use templates to parameterize all of these on both types and values!
```c ```c
@ -199,8 +199,8 @@ our getter and setter methods, and keep the clean syntax of
accessing members directly! accessing members directly!
Other object-oriented goodies at our disposal Other object-oriented goodies at our disposal
include `interface`s, `abstract class`es, include interfaces, abstract classes,
and `override`ing methods. D does inheritance just like Java: and overriding methods. D does inheritance just like Java:
Extend one class, implement as many interfaces as you please. Extend one class, implement as many interfaces as you please.
We've seen D's OOP facilities, but let's switch gears. D offers We've seen D's OOP facilities, but let's switch gears. D offers
@ -218,7 +218,7 @@ void main() {
// from 1 to 100. Easy! // from 1 to 100. Easy!
// Just pass lambda expressions as template parameters! // Just pass lambda expressions as template parameters!
// You can pass any old function you like, but lambdas are convenient here. // You can pass any function you like, but lambdas are convenient here.
auto num = iota(1, 101).filter!(x => x % 2 == 0) auto num = iota(1, 101).filter!(x => x % 2 == 0)
.map!(y => y ^^ 2) .map!(y => y ^^ 2)
.reduce!((a, b) => a + b); .reduce!((a, b) => a + b);
@ -228,7 +228,7 @@ void main() {
``` ```
Notice how we got to build a nice Haskellian pipeline to compute num? Notice how we got to build a nice Haskellian pipeline to compute num?
That's thanks to a D innovation know as Uniform Function Call Syntax. That's thanks to a D innovation know as Uniform Function Call Syntax (UFCS).
With UFCS, we can choose whether to write a function call as a method With UFCS, we can choose whether to write a function call as a method
or free function call! Walter wrote a nice article on this or free function call! Walter wrote a nice article on this
[here.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) [here.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
@ -238,21 +238,23 @@ is of some type A on any expression of type A as a method.
I like parallelism. Anyone else like parallelism? Sure you do. Let's do some! I like parallelism. Anyone else like parallelism? Sure you do. Let's do some!
```c ```c
// Let's say we want to populate a large array with the square root of all
// consecutive integers starting from 1 (up until the size of the array), and we
// want to do this concurrently taking advantage of as many cores as we have
// available.
import std.stdio; import std.stdio;
import std.parallelism : parallel; import std.parallelism : parallel;
import std.math : sqrt; import std.math : sqrt;
void main() { void main() {
// We want take the square root every number in our array, // Create your large array
// and take advantage of as many cores as we have available.
auto arr = new double[1_000_000]; auto arr = new double[1_000_000];
// Use an index, and an array element by referece, // Use an index, access every array element by reference (because we're
// and just call parallel on the array! // going to change each element) and just call parallel on the array!
foreach(i, ref elem; parallel(arr)) { foreach(i, ref elem; parallel(arr)) {
ref = sqrt(i + 1.0); elem = sqrt(i + 1.0);
} }
} }
``` ```

2
dart.html.markdown
View File

@ -498,7 +498,7 @@ main() {
## Further Reading ## Further Reading
Dart has a comprehenshive web-site. It covers API reference, tutorials, articles and more, including a Dart has a comprehensive web-site. It covers API reference, tutorials, articles and more, including a
useful Try Dart online. useful Try Dart online.
http://www.dartlang.org/ http://www.dartlang.org/
http://try.dartlang.org/ http://try.dartlang.org/

101
de-de/haskell-de.html.markdown
View File

@ -5,6 +5,7 @@ contributors:
- ["Adit Bhargava", "http://adit.io"] - ["Adit Bhargava", "http://adit.io"]
translators: translators:
- ["Henrik Jürges", "https://github.com/santifa"] - ["Henrik Jürges", "https://github.com/santifa"]
- ["Nikolai Weh", "http://weh.hamburg"]
filename: haskell-de.hs filename: haskell-de.hs
--- ---
@ -58,12 +59,13 @@ not False -- True
-- Strings und Zeichen -- Strings und Zeichen
"Das ist ein String." "Das ist ein String."
'a' -- Zeichen 'a' -- Zeichen
'Einfache Anfuehrungszeichen gehen nicht.' -- error! 'Einfache Anführungszeichen gehen nicht.' -- error!
-- Strings können konkateniert werden. -- Strings können konkateniert werden.
"Hello " ++ "world!" -- "Hello world!" "Hello " ++ "world!" -- "Hello world!"
-- Ein String ist eine Liste von Zeichen. -- Ein String ist eine Liste von Zeichen.
['H', 'a', 'l', 'l', 'o', '!'] -- "Hallo!"
"Das ist eine String" !! 0 -- 'D' "Das ist eine String" !! 0 -- 'D'
@ -76,11 +78,23 @@ not False -- True
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
[1..5] [1..5]
-- Haskell unterstuetzt unendliche Listen! -- Die zweite Variante nennt sich die "range"-Syntax.
[1..] -- Die Liste aller natuerlichen Zahlen -- Ranges sind recht flexibel:
['A'..'F'] -- "ABCDEF"
-- Es ist möglich eine Schrittweite anzugeben:
[0,2..10] -- [0,2,4,6,8,10]
[5..1] -- [], da Haskell standardmässig inkrementiert.
[5,4..1] -- [5,4,3,2,1]
-- Der "!!"-Operator extrahiert das Element an einem bestimmten Index:
[1..10] !! 3 -- 4
-- Haskell unterstützt unendliche Listen!
[1..] -- Die Liste aller natürlichen Zahlen
-- Unendliche Listen funktionieren in Haskell, da es "lazy evaluation" -- Unendliche Listen funktionieren in Haskell, da es "lazy evaluation"
-- unterstuetzt. Haskell evaluiert erst etwas, wenn es benötigt wird. -- unterstützt. Haskell evaluiert erst etwas, wenn es benötigt wird.
-- Somit kannst du nach dem 1000. Element fragen und Haskell gibt es dir: -- Somit kannst du nach dem 1000. Element fragen und Haskell gibt es dir:
[1..] !! 999 -- 1000 [1..] !! 999 -- 1000
@ -92,12 +106,9 @@ not False -- True
-- Zwei Listen konkatenieren -- Zwei Listen konkatenieren
[1..5] ++ [6..10] [1..5] ++ [6..10]
-- Ein Element als Head hinzufuegen -- Ein Element als Head hinzufügen
0:[1..5] -- [0, 1, 2, 3, 4, 5] 0:[1..5] -- [0, 1, 2, 3, 4, 5]
-- Gibt den 5. Index zurueck
[0..] !! 5 -- 5
-- Weitere Listenoperationen -- Weitere Listenoperationen
head [1..5] -- 1 head [1..5] -- 1
tail [1..5] -- [2, 3, 4, 5] tail [1..5] -- [2, 3, 4, 5]
@ -114,7 +125,8 @@ last [1..5] -- 5
-- Ein Tupel: -- Ein Tupel:
("haskell", 1) ("haskell", 1)
-- Auf Elemente eines Tupels zugreifen: -- Ein Paar (Pair) ist ein Tupel mit 2 Elementen, auf die man wie folgt
-- zugreifen kann:
fst ("haskell", 1) -- "haskell" fst ("haskell", 1) -- "haskell"
snd ("haskell", 1) -- 1 snd ("haskell", 1) -- 1
@ -140,9 +152,9 @@ add 1 2 -- 3
(//) a b = a `div` b (//) a b = a `div` b
35 // 4 -- 8 35 // 4 -- 8
-- Guards sind eine einfache Möglichkeit fuer Fallunterscheidungen. -- Guards sind eine einfache Möglichkeit für Fallunterscheidungen.
fib x fib x
| x < 2 = x | x < 2 = 1
| otherwise = fib (x - 1) + fib (x - 2) | otherwise = fib (x - 1) + fib (x - 2)
-- Pattern Matching funktioniert ähnlich. -- Pattern Matching funktioniert ähnlich.
@ -174,7 +186,7 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15
-- 4. Mehr Funktionen -- 4. Mehr Funktionen
---------------------------------------------------- ----------------------------------------------------
-- currying: Wenn man nicht alle Argumente an eine Funktion uebergibt, -- currying: Wenn man nicht alle Argumente an eine Funktion übergibt,
-- so wird sie eine neue Funktion gebildet ("curried"). -- so wird sie eine neue Funktion gebildet ("curried").
-- Es findet eine partielle Applikation statt und die neue Funktion -- Es findet eine partielle Applikation statt und die neue Funktion
-- nimmt die fehlenden Argumente auf. -- nimmt die fehlenden Argumente auf.
@ -190,23 +202,28 @@ foo 5 -- 15
-- Funktionskomposition -- Funktionskomposition
-- Die (.) Funktion verkettet Funktionen. -- Die (.) Funktion verkettet Funktionen.
-- Zum Beispiel, die Funktion Foo nimmt ein Argument addiert 10 dazu und -- Zum Beispiel, die Funktion Foo nimmt ein Argument addiert 10 dazu und
-- multipliziert dieses Ergebnis mit 5. -- multipliziert dieses Ergebnis mit 4.
foo = (*5) . (+10) foo = (*4) . (+10)
-- (5 + 10) * 5 = 75 -- (5 + 10) * 4 = 60
foo 5 -- 75 foo 5 -- 60
-- Haskell hat eine Funktion `$`. Diese ändert den Vorrang, -- Haskell hat einen Operator `$`, welcher Funktionsapplikation durchführt.
-- so dass alles links von ihr zuerst berechnet wird und -- Im Gegenzug zu der Standard-Funktionsapplikation, welche linksassoziativ ist
-- und dann an die rechte Seite weitergegeben wird. -- und die höchstmögliche Priorität von "10" hat, ist der `$`-Operator
-- Mit `.` und `$` kann man sich viele Klammern ersparen. -- rechtsassoziativ und hat die Priorität 0. Dieses hat (idr.) den Effekt,
-- dass der `komplette` Ausdruck auf der rechten Seite als Parameter für die
-- Funktion auf der linken Seite verwendet wird.
-- Mit `.` und `$` kann man sich so viele Klammern ersparen.
-- Vorher (even (fib 7)) -- false
(even (fib 7)) -- true
-- Danach -- Äquivalent:
even . fib $ 7 -- true even $ fib 7 -- false
-- Funktionskomposition:
even . fib $ 7 -- false
---------------------------------------------------- ----------------------------------------------------
-- 5. Typensystem -- 5. Typensystem
@ -221,31 +238,31 @@ even . fib $ 7 -- true
True :: Bool True :: Bool
-- Funktionen haben genauso Typen. -- Funktionen haben genauso Typen.
-- `not` ist Funktion die ein Bool annimmt und ein Bool zurueckgibt: -- `not` ist Funktion die ein Bool annimmt und ein Bool zurückgibt:
-- not :: Bool -> Bool -- not :: Bool -> Bool
-- Eine Funktion die zwei Integer Argumente annimmt: -- Eine Funktion die zwei Integer Argumente annimmt:
-- add :: Integer -> Integer -> Integer -- add :: Integer -> Integer -> Integer
-- Es ist guter Stil zu jeder Funktionsdefinition eine -- Es ist guter Stil zu jeder Funktionsdefinition eine
-- Typdefinition darueber zu schreiben: -- Typdefinition darüber zu schreiben:
double :: Integer -> Integer double :: Integer -> Integer
double x = x * 2 double x = x * 2
---------------------------------------------------- ----------------------------------------------------
-- 6. If-Anweisung und Kontrollstrukturen -- 6. If-Ausdrücke und Kontrollstrukturen
---------------------------------------------------- ----------------------------------------------------
-- If-Anweisung: -- If-Ausdruck:
haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
-- If-Anweisungen können auch ueber mehrere Zeilen verteilt sein. -- If-Ausdrücke können auch über mehrere Zeilen verteilt sein.
-- Das Einruecken ist dabei äußerst wichtig. -- Die Einrückung ist dabei wichtig.
haskell = if 1 == 1 haskell = if 1 == 1
then "awesome" then "awesome"
else "awful" else "awful"
-- Case-Anweisung: Zum Beispiel "commandline" Argumente parsen. -- Case-Ausdruck: Am Beispiel vom Parsen von "commandline"-Argumenten.
case args of case args of
"help" -> printHelp "help" -> printHelp
"start" -> startProgram "start" -> startProgram
@ -276,7 +293,7 @@ foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
-- die Abarbeitung sieht so aus: -- die Abarbeitung sieht so aus:
(2 * 3 + (2 * 2 + (2 * 1 + 4))) (2 * 1 + (2 * 2 + (2 * 3 + 4)))
---------------------------------------------------- ----------------------------------------------------
-- 7. Datentypen -- 7. Datentypen
@ -300,7 +317,7 @@ data Maybe a = Nothing | Just a
-- Diese sind alle vom Typ Maybe: -- Diese sind alle vom Typ Maybe:
Just "hello" -- vom Typ `Maybe String` Just "hello" -- vom Typ `Maybe String`
Just 1 -- vom Typ `Maybe Int` Just 1 -- vom Typ `Maybe Int`
Nothing -- vom Typ `Maybe a` fuer jedes `a` Nothing -- vom Typ `Maybe a` für jedes `a`
---------------------------------------------------- ----------------------------------------------------
-- 8. Haskell IO -- 8. Haskell IO
@ -309,8 +326,8 @@ Nothing -- vom Typ `Maybe a` fuer jedes `a`
-- IO kann nicht völlig erklärt werden ohne Monaden zu erklären, -- IO kann nicht völlig erklärt werden ohne Monaden zu erklären,
-- aber man kann die grundlegenden Dinge erklären. -- aber man kann die grundlegenden Dinge erklären.
-- Wenn eine Haskell Programm ausgefuehrt wird, so wird `main` aufgerufen. -- Wenn eine Haskell Programm ausgeführt wird, so wird `main` aufgerufen.
-- Diese muss etwas vom Typ `IO ()` zurueckgeben. Zum Beispiel: -- Diese muss etwas vom Typ `IO ()` zurückgeben. Zum Beispiel:
main :: IO () main :: IO ()
main = putStrLn $ "Hello, sky! " ++ (say Blue) main = putStrLn $ "Hello, sky! " ++ (say Blue)
@ -338,10 +355,10 @@ sayHello = do
-- an die Variable "name" gebunden -- an die Variable "name" gebunden
putStrLn $ "Hello, " ++ name putStrLn $ "Hello, " ++ name
-- Uebung: Schreibe deine eigene Version von `interact`, -- Übung: Schreibe deine eigene Version von `interact`,
-- die nur eine Zeile einliest. -- die nur eine Zeile einliest.
-- `sayHello` wird niemals ausgefuehrt, nur `main` wird ausgefuehrt. -- `sayHello` wird niemals ausgeführt, nur `main` wird ausgeführt.
-- Um `sayHello` laufen zulassen kommentiere die Definition von `main` -- Um `sayHello` laufen zulassen kommentiere die Definition von `main`
-- aus und ersetze sie mit: -- aus und ersetze sie mit:
-- main = sayHello -- main = sayHello
@ -359,7 +376,7 @@ action = do
input1 <- getLine input1 <- getLine
input2 <- getLine input2 <- getLine
-- Der Typ von `do` ergibt sich aus der letzten Zeile. -- Der Typ von `do` ergibt sich aus der letzten Zeile.
-- `return` ist eine Funktion und keine Schluesselwort -- `return` ist eine Funktion und keine Schlüsselwort
return (input1 ++ "\n" ++ input2) -- return :: String -> IO String return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
-- Nun können wir `action` wie `getLine` benutzen: -- Nun können wir `action` wie `getLine` benutzen:
@ -370,7 +387,7 @@ main'' = do
putStrLn result putStrLn result
putStrLn "This was all, folks!" putStrLn "This was all, folks!"
-- Der Typ `IO` ist ein Beispiel fuer eine Monade. -- Der Typ `IO` ist ein Beispiel für eine Monade.
-- Haskell benutzt Monaden Seiteneffekte zu kapseln und somit -- Haskell benutzt Monaden Seiteneffekte zu kapseln und somit
-- eine rein funktional Sprache zu sein. -- eine rein funktional Sprache zu sein.
-- Jede Funktion die mit der Außenwelt interagiert (z.B. IO) -- Jede Funktion die mit der Außenwelt interagiert (z.B. IO)
@ -387,7 +404,7 @@ main'' = do
-- Starte die REPL mit dem Befehl `ghci` -- Starte die REPL mit dem Befehl `ghci`
-- Nun kann man Haskell Code eingeben. -- Nun kann man Haskell Code eingeben.
-- Alle neuen Werte muessen mit `let` gebunden werden: -- Alle neuen Werte müssen mit `let` gebunden werden:
let foo = 5 let foo = 5
@ -396,7 +413,7 @@ let foo = 5
>:t foo >:t foo
foo :: Integer foo :: Integer
-- Auch jede `IO ()` Funktion kann ausgefuehrt werden. -- Auch jede `IO ()` Funktion kann ausgeführt werden.
> sayHello > sayHello
What is your name? What is your name?
@ -420,6 +437,6 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
Haskell ist sehr einfach zu installieren. Haskell ist sehr einfach zu installieren.
Hohl es dir von [hier](http://www.haskell.org/platform/). Hohl es dir von [hier](http://www.haskell.org/platform/).
Eine sehr viele langsamere Einfuehrung findest du unter: Eine sehr viele langsamere Einführung findest du unter:
[Learn you a Haskell](http://learnyouahaskell.com/) oder [Learn you a Haskell](http://learnyouahaskell.com/) oder
[Real World Haskell](http://book.realworldhaskell.org/). [Real World Haskell](http://book.realworldhaskell.org/).

59
de-de/latex-de.html.markdown
View File

@ -6,19 +6,19 @@ contributors:
- ["Sricharan Chiruvolu", "http://sricharan.xyz"] - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
translators: translators:
- ["Moritz Kammerer", "https://github.com/phxql"] - ["Moritz Kammerer", "https://github.com/phxql"]
- ["Jerome Meinke", "https://github.com/jmeinke"]
lang: de-de lang: de-de
filename: latex-de.tex filename: latex-de.tex
--- ---
``` ```
% Alle Kommentare starten fangen mit % an % Alle Kommentare starten mit einem Prozentzeichen %
% Es gibt keine Kommentare über mehrere Zeilen
% LateX ist keine "What You See Is What You Get" Textverarbeitungssoftware wie z.B. % LaTeX ist keine "What You See Is What You Get" Textverarbeitungssoftware wie z.B.
% MS Word oder OpenOffice Writer % MS Word oder OpenOffice Writer
% Jedes LateX-Kommando startet mit einem Backslash (\) % Jedes LaTeX-Kommando startet mit einem Backslash (\)
% LateX-Dokumente starten immer mit der Definition des Dokuments, die sie darstellen % LaTeX-Dokumente starten immer mit der Definition des Dokuments, die sie darstellen
% Weitere Dokumententypen sind z.B. book, report, presentations, etc. % Weitere Dokumententypen sind z.B. book, report, presentations, etc.
% Optionen des Dokuments stehen zwischen den eckigen Klammern []. In diesem Fall % Optionen des Dokuments stehen zwischen den eckigen Klammern []. In diesem Fall
% wollen wir einen 12 Punkte-Font verwenden. % wollen wir einen 12 Punkte-Font verwenden.
@ -26,7 +26,7 @@ filename: latex-de.tex
% Als nächstes definieren wir die Pakete, die wir verwenden wollen. % Als nächstes definieren wir die Pakete, die wir verwenden wollen.
% Wenn du z.B. Grafiken, farbigen Text oder Quelltext in dein Dokument einbetten möchtest, % Wenn du z.B. Grafiken, farbigen Text oder Quelltext in dein Dokument einbetten möchtest,
% musst du die Fähigkeiten von Latex durch Hinzufügen von Paketen erweitern. % musst du die Fähigkeiten von LaTeX durch Hinzufügen von Paketen erweitern.
% Wir verwenden die Pakete float und caption für Bilder. % Wir verwenden die Pakete float und caption für Bilder.
\usepackage{caption} \usepackage{caption}
\usepackage{float} \usepackage{float}
@ -34,30 +34,41 @@ filename: latex-de.tex
% Mit diesem Paket können leichter Umlaute getippt werden % Mit diesem Paket können leichter Umlaute getippt werden
\usepackage[utf8]{inputenc} \usepackage[utf8]{inputenc}
% Es gibt eigentlich keine Kommentare über mehrere Zeilen, solche kann man
% aber selbst durch die Angabe eigener Kommandos definieren.
% Dieses Kommando kann man später benutzen.
\newcommand{\comment}[1]{}
% Es können durchaus noch weitere Optione für das Dokument gesetzt werden! % Es können durchaus noch weitere Optione für das Dokument gesetzt werden!
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu} \author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
\date{\today} \date{\today}
\title{Learn LaTeX in Y Minutes!} \title{Learn \LaTeX\ in Y Minutes!}
% Nun kann's losgehen mit unserem Dokument. % Nun kann's losgehen mit unserem Dokument.
% Alles vor dieser Zeile wird die Preamble genannt. % Alles vor dieser Zeile wird die Preamble genannt.
\begin{document} \begin{document}
\comment{
Dies ist unser selbst-definierter Befehl
für mehrzeilige Kommentare.
}
% Wenn wir den Autor, das Datum und den Titel gesetzt haben, kann % Wenn wir den Autor, das Datum und den Titel gesetzt haben, kann
% LateX für uns eine Titelseite generieren % LaTeX für uns eine Titelseite generieren
\maketitle \maketitle
% Die meisten Paper haben ein Abstract. LateX bietet dafür einen vorgefertigen Befehl an. % Die meisten Paper haben ein Abstract. LaTeX bietet dafür einen vorgefertigen Befehl an.
% Das Abstract sollte in der logischen Reihenfolge, also nach dem Titel, aber vor dem % Das Abstract sollte in der logischen Reihenfolge, also nach dem Titel, aber vor dem
% Inhalt erscheinen. % Inhalt erscheinen.
% Dieser Befehl ist in den Dokumentenklassen article und report verfügbar. % Dieser Befehl ist in den Dokumentenklassen article und report verfügbar.
\begin{abstract} \begin{abstract}
LateX documentation geschrieben in LateX! Wie ungewöhnlich und garantiert nicht meine Idee! \LaTeX -Documentation geschrieben in \LaTeX ! Wie ungewöhnlich und garantiert nicht meine Idee!
\end{abstract} \end{abstract}
% Section Befehle sind intuitiv. % Section Befehle sind intuitiv.
% Alle Titel der sections werden automatisch in das Inhaltsverzeichnis übernommen. % Alle Titel der sections werden automatisch in das Inhaltsverzeichnis übernommen.
\section{Einleitung} \section{Einleitung}
Hi, mein Name ist Moritz und zusammen werden wir LateX erforschen! Hi, mein Name ist Moritz und zusammen werden wir \LaTeX\ erforschen!
\section{Noch eine section} \section{Noch eine section}
Das hier ist der Text für noch eine section. Ich glaube, wir brauchen eine subsection. Das hier ist der Text für noch eine section. Ich glaube, wir brauchen eine subsection.
@ -72,15 +83,15 @@ So ist's schon viel besser.
% Wenn wir den Stern nach section schreiben, dann unterdrückt LateX die Nummerierung. % Wenn wir den Stern nach section schreiben, dann unterdrückt LateX die Nummerierung.
% Das funktioniert auch bei anderen Befehlen. % Das funktioniert auch bei anderen Befehlen.
\section*{Das ist eine unnummerierte section} \section*{Das ist eine unnummerierte section}
Es müssen nicht alle sections nummeriert sein! Es müssen nicht alle Sections nummeriert sein!
\section{Ein paar Notizen} \section{Ein paar Notizen}
LateX ist ziemlich gut darin, Text so zu platzieren, dass es gut aussieht. \LaTeX\ ist ziemlich gut darin, Text so zu platzieren, dass es gut aussieht.
Falls eine Zeile \\ mal \\ woanders \\ umgebrochen \\ werden \\ soll, füge Falls eine Zeile \\ mal \\ woanders \\ umgebrochen \\ werden \\ soll, füge
\textbackslash\textbackslash in den Code ein.\\ \textbackslash\textbackslash in den Code ein.\\
\section{Listen} \section{Listen}
Listen sind eine der einfachsten Dinge in LateX. Ich muss morgen einkaufen gehen, Listen sind eine der einfachsten Dinge in \LaTeX. Ich muss morgen einkaufen gehen,
also lass uns eine Einkaufsliste schreiben: also lass uns eine Einkaufsliste schreiben:
\begin{enumerate} % Dieser Befehl erstellt eine "enumerate" Umgebung. \begin{enumerate} % Dieser Befehl erstellt eine "enumerate" Umgebung.
% \item bringt enumerate dazu, eins weiterzuzählen. % \item bringt enumerate dazu, eins weiterzuzählen.
@ -96,7 +107,7 @@ also lass uns eine Einkaufsliste schreiben:
\section{Mathe} \section{Mathe}
Einer der Haupteinsatzzwecke von LateX ist das Schreiben von akademischen Einer der Haupteinsatzzwecke von \LaTeX\ ist das Schreiben von akademischen
Artikeln oder Papern. Meistens stammen diese aus dem Bereich der Mathe oder Artikeln oder Papern. Meistens stammen diese aus dem Bereich der Mathe oder
anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle
Symbole zu unserem Paper hinzuzufügen! \\ Symbole zu unserem Paper hinzuzufügen! \\
@ -106,15 +117,15 @@ Symbole für Mengen und relationen, Pfeile, Operatoren und Griechische Buchstabe
um nur ein paar zu nennen.\\ um nur ein paar zu nennen.\\
Mengen und Relationen spielen eine sehr wichtige Rolle in vielen mathematischen Mengen und Relationen spielen eine sehr wichtige Rolle in vielen mathematischen
Papern. So schreibt man in LateX, dass alle y zu X gehören: $\forall$ y $\in$ X. \\ Papern. So schreibt man in \LaTeX, dass alle y zu X gehören: $\forall$ y $\in$ X. \\
% Achte auf die $ Zeichen vor und nach den Symbolen. Wenn wir in LateX schreiben, % Achte auf die $ Zeichen vor und nach den Symbolen. Wenn wir in LaTeX schreiben,
% geschieht dies standardmäßig im Textmodus. Die Mathe-Symbole existieren allerdings % geschieht dies standardmäßig im Textmodus. Die Mathe-Symbole existieren allerdings
% nur im Mathe-Modus. Wir können den Mathe-Modus durch das $ Zeichen aktivieren und % nur im Mathe-Modus. Wir können den Mathe-Modus durch das $ Zeichen aktivieren und
% ihn mit $ wieder verlassen. Variablen können auch im Mathe-Modus angezeigt werden. % ihn mit $ wieder verlassen. Variablen können auch im Mathe-Modus angezeigt werden.
Mein Lieblingsbuchstabe im Griechischen ist $\xi$. Ich mag auch $\beta$, $\gamma$ und $\sigma$. Mein Lieblingsbuchstabe im Griechischen ist $\xi$. Ich mag auch $\beta$, $\gamma$ und $\sigma$.
Bis jetzt habe ich noch keinen griechischen Buchstaben gefunden, den LateX nicht kennt! Bis jetzt habe ich noch keinen griechischen Buchstaben gefunden, den \LaTeX nicht kennt!
Operatoren sind ebenfalls wichtige Bestandteile von mathematischen Dokumenten: Operatoren sind ebenfalls wichtige Bestandteile von mathematischen Dokumenten:
Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$), Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$),
@ -148,7 +159,7 @@ Grafiken, Gleichungen, Sections, etc.
Summen und Integrale können mit den sum und int Befehlen dargestellt werden: Summen und Integrale können mit den sum und int Befehlen dargestellt werden:
% Manche LateX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen % Manche LaTeX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
\begin{equation} \begin{equation}
\sum_{i=0}^{5} f_{i} \sum_{i=0}^{5} f_{i}
\end{equation} \end{equation}
@ -187,9 +198,9 @@ Wir können Tabellen genauso wie Grafiken einfügen.
% \section{Links} % Kommen bald! % \section{Links} % Kommen bald!
\section{Verhindern, dass LateX etwas kompiliert (z.B. Quelltext)} \section{Verhindern, dass \LaTeX\ etwas kompiliert (z.B. Quelltext)}
Angenommen, wir wollen Quelltext in unserem LateX-Dokument. LateX soll Angenommen, wir wollen Quelltext in unserem \LaTeX-Dokument. \LaTeX\ soll
in diesem Fall nicht den Quelltext als LateX-Kommandos interpretieren, in diesem Fall nicht den Quelltext als \LaTeX-Kommandos interpretieren,
sondern es einfach ins Dokument schreiben. Um das hinzubekommen, verwenden sondern es einfach ins Dokument schreiben. Um das hinzubekommen, verwenden
wir eine verbatim Umgebung. wir eine verbatim Umgebung.
@ -208,7 +219,7 @@ verwandeln kannst. (Ja, dieses Dokument kompiliert wirklich!) \\
Dafür musst du folgende Schritte durchführen: Dafür musst du folgende Schritte durchführen:
\begin{enumerate} \begin{enumerate}
\item Schreibe das Dokument. (den LateX-Quelltext). \item Schreibe das Dokument. (den \LaTeX -Quelltext).
\item Kompiliere den Quelltext in ein PDF. \item Kompiliere den Quelltext in ein PDF.
Das Kompilieren sieht so ähnlich wie das hier aus (Linux): \\ Das Kompilieren sieht so ähnlich wie das hier aus (Linux): \\
\begin{verbatim} \begin{verbatim}
@ -216,7 +227,7 @@ Dafür musst du folgende Schritte durchführen:
\end{verbatim} \end{verbatim}
\end{enumerate} \end{enumerate}
Manche LateX-Editoren kombinieren Schritt 1 und 2. Du siehst also nur Schritt 1 und Schritt Manche \LaTeX-Editoren kombinieren Schritt 1 und 2. Du siehst also nur Schritt 1 und Schritt
2 wird unsichtbar im Hintergrund ausgeführt. 2 wird unsichtbar im Hintergrund ausgeführt.
Alle Formatierungsoptionen werden in Schritt 1 in den Quelltext geschrieben. Schritt 2 verwendet Alle Formatierungsoptionen werden in Schritt 1 in den Quelltext geschrieben. Schritt 2 verwendet

506
de-de/scala-de.html.markdown
View File

File diff suppressed because it is too large Load Diff

4
de-de/yaml-de.html.markdown
View File

@ -30,7 +30,7 @@ null_Wert: null
Schlüssel mit Leerzeichen: value Schlüssel mit Leerzeichen: value
# Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber: # Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber:
jedoch: "Ein String in Anführungzeichen" jedoch: "Ein String in Anführungzeichen"
"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schluessel haben willst." "Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schlüssel haben willst."
# Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text) # Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text)
# oder ein 'folded block' (> gefolgt vom text). # oder ein 'folded block' (> gefolgt vom text).
@ -64,7 +64,7 @@ eine_verschachtelte_map:
hallo: hallo hallo: hallo
# Schlüssel müssen nicht immer String sein. # Schlüssel müssen nicht immer String sein.
0.25: ein Float-Wert als Schluessel 0.25: ein Float-Wert als Schlüssel
# Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels # Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels
? | ? |

18
edn.html.markdown
View File

@ -5,18 +5,18 @@ contributors:
- ["Jason Yeo", "https://github.com/jsyeo"] - ["Jason Yeo", "https://github.com/jsyeo"]
--- ---
Extensible Data Notation or EDN for short is a format for serializing data. Extensible Data Notation (EDN) is a format for serializing data.
The notation is used internally by Clojure to represent programs and it also The notation is used internally by Clojure to represent programs. It is also
used as a data transfer format like JSON. Though it is more commonly used in used as a data transfer format like JSON. Though it is more commonly used in
Clojure land, there are implementations of EDN for many other languages. Clojure, there are implementations of EDN for many other languages.
The main benefit of EDN over JSON and YAML is that it is extensible, which we The main benefit of EDN over JSON and YAML is that it is extensible. We
will see how it is extended later on. will see how it is extended later on.
```Clojure ```Clojure
; Comments start with a semicolon. ; Comments start with a semicolon.
; Anythng after the semicolon is ignored. ; Anything after the semicolon is ignored.
;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;
;;; Basic Types ;;; ;;; Basic Types ;;;
@ -59,7 +59,7 @@ false
; Vectors allow random access ; Vectors allow random access
[:gelato 1 2 -2] [:gelato 1 2 -2]
; Maps are associative data structures that associates the key with its value ; Maps are associative data structures that associate the key with its value
{:eggs 2 {:eggs 2
:lemon-juice 3.5 :lemon-juice 3.5
:butter 1} :butter 1}
@ -68,7 +68,7 @@ false
{[1 2 3 4] "tell the people what she wore", {[1 2 3 4] "tell the people what she wore",
[5 6 7 8] "the more you see the more you hate"} [5 6 7 8] "the more you see the more you hate"}
; You may use commas for readability. They are treated as whitespaces. ; You may use commas for readability. They are treated as whitespace.
; Sets are collections that contain unique elements. ; Sets are collections that contain unique elements.
#{:a :b 88 "huat"} #{:a :b 88 "huat"}
@ -82,11 +82,11 @@ false
#MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10} #MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10}
; Let me explain this with a clojure example. Suppose I want to transform that ; Let me explain this with a clojure example. Suppose I want to transform that
; piece of edn into a MenuItem record. ; piece of EDN into a MenuItem record.
(defrecord MenuItem [name rating]) (defrecord MenuItem [name rating])
; To transform edn to clojure values, I will need to use the built in EDN ; To transform EDN to clojure values, I will need to use the built in EDN
; reader, edn/read-string ; reader, edn/read-string
(edn/read-string "{:eggs 2 :butter 1 :flour 5}") (edn/read-string "{:eggs 2 :butter 1 :flour 5}")

3
elisp.html.markdown
View File

@ -2,6 +2,7 @@
language: elisp language: elisp
contributors: contributors:
- ["Bastien Guerry", "http://bzg.fr"] - ["Bastien Guerry", "http://bzg.fr"]
- ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
filename: learn-emacs-lisp.el filename: learn-emacs-lisp.el
--- ---
@ -26,7 +27,7 @@ filename: learn-emacs-lisp.el
;; ;;
;; Going through this tutorial won't damage your computer unless ;; Going through this tutorial won't damage your computer unless
;; you get so angry that you throw it on the floor. In that case, ;; you get so angry that you throw it on the floor. In that case,
;; I hereby decline any responsability. Have fun! ;; I hereby decline any responsibility. Have fun!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;

2
elixir.html.markdown
View File

@ -343,6 +343,7 @@ rescue
RuntimeError -> "rescued a runtime error" RuntimeError -> "rescued a runtime error"
_error -> "this will rescue any error" _error -> "this will rescue any error"
end end
#=> "rescued a runtime error"
# All exceptions have a message # All exceptions have a message
try do try do
@ -351,6 +352,7 @@ rescue
x in [RuntimeError] -> x in [RuntimeError] ->
x.message x.message
end end
#=> "some error"
## --------------------------- ## ---------------------------
## -- Concurrency ## -- Concurrency

346
elm.html.markdown Normal file
View File

@ -0,0 +1,346 @@
---
language: Elm
contributors:
- ["Max Goldstein", "http://maxgoldste.in/"]
---
Elm is a functional reactive programming language that compiles to (client-side)
JavaScript. Elm is statically typed, meaning that the compiler catches most
errors immediately and provides a clear and understandable error message. Elm is
great for designing user interfaces and games for the web.
```haskell
-- Single line comments start with two dashes.
{- Multiline comments can be enclosed in a block like this.
{- They can be nested. -}
-}
{-- The Basics --}
-- Arithmetic
1 + 1 -- 2
8 - 1 -- 7
10 * 2 -- 20
-- Every number literal without a decimal point can be either an Int or a Float.
33 / 2 -- 16.5 with floating point division
33 // 2 -- 16 with integer division
-- Exponents
5 ^ 2 -- 25
-- Booleans
not True -- False
not False -- True
1 == 1 -- True
1 /= 1 -- False
1 < 10 -- True
-- Strings and characters
"This is a string."
'a' -- character
'You cant use single quotes for strings.' -- error!
-- Strings can be appended
"Hello " ++ "world!" -- "Hello world!"
{-- Lists, Tuples, and Records --}
-- Every element in a list must have the same type.
["the", "quick", "brown", "fox"]
[1, 2, 3, 4, 5]
-- The second example can also be written with two dots.
[1..5]
-- Append lists just like strings
[1..5] ++ [6..10] == [1..10] -- True
-- To add one item, use "cons"
0 :: [1..5] -- [0, 1, 2, 3, 4, 5]
-- The head and tail of a list are returned as a Maybe. Instead of checking
-- every value to see if it's null, you deal with missing values explicitly.
List.head [1..5] -- Just 1
List.tail [1..5] -- Just [2, 3, 4, 5]
List.head [] -- Nothing
-- Every element in a tuple can be a different type, but a tuple has a
-- fixed length.
("elm", 42)
-- Access the elements of a pair with the first and second functions.
-- (This is a shortcut; we'll come to the "real way" in a bit.)
fst ("elm", 42) -- "elm"
snd ("elm", 42) -- 42
-- Records are like tuples but the fields have names.
-- Notice that equals signs, not colons, are used.
{ x = 3, y = 7}
-- Access a field with a dot and the field name.
{ x = 3, y = 7}.x -- 3
-- Or with an accessor fuction, a dot and then the field name.
.y { x = 3, y = 7} -- 7
-- Update the fields of a record. (It must have the fields already.)
{ person |
name = "George" }
{ physics |
position = physics.position + physics.velocity,
velocity = physics.velocity + physics.acceleration }
{-- Control Flow --}
-- If statements always have an else, and the branches must be the same type.
if powerLevel > 9000 then
"WHOA!"
else
"meh"
-- If statements can be chained.
if n < 0 then
"n is negative"
else if n > 0 then
"n is positive"
else
"n is zero"
-- Use case statements to pattern match on different possibilities.
case aList of
[] -> "matches the empty list"
x::xs -> "matches a list of at least one item whose head is " ++ toString x
case List.head aList of
Just x -> "The head is " ++ toString x
Nothing -> "The list was empty"
{-- Functions --}
-- Elm's syntax for functions is very minimal, relying mostly on whitespace
-- rather than parentheses and curly brackets. There is no "return" keyword.
-- Define a function with its name, arguments, an equals sign, and the body.
multiply a b =
a * b
-- Apply (call) a function by passing it arguments (no commas necessay).
multiply 7 6 -- 42
-- Partially apply a function by passing only some of its arguments.
-- Then give that function a new name.
double =
multiply 2
-- Constants are similar, except there are no arguments.
answer =
42
-- Pass functions as arguments to other functions.
List.map double [1..4] -- [2, 4, 6, 8]
-- Or write an anonymous function.
List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8]
-- You can pattern match in function definitions when there's only one case.
-- This function takes one tuple rather than two arguments.
area (width, height) =
width * height
area (6, 7) -- 42
-- Use curly brackets to pattern match record field names
-- Use let to define intermediate values
volume {width, height, depth} =
let
area = width * height
in
area * depth
volume { width = 3, height = 2, depth = 7 } -- 42
-- Functions can be recursive
fib n =
if n < 2 then
1
else
fib (n - 1) + fib (n - 2)
List.map fib [0..8] -- [1, 1, 2, 3, 5, 8,13, 21, 34]
listLength aList =
case aList of
[] -> 0
x::xs -> 1 + listLength xs
-- Function application happens before any infix operation
cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
-- First degrees is applied to 30, then the result is passed to the trig
-- functions, which is then squared, and the addition happens last.
{-- Types and Type Annotations --}
-- The compiler will infer the type of every value in your program.
-- Types are always uppercase. Read x : T as "x has type T".
-- Some common types, which you might see in Elm's REPL.
5 : Int
6.7 : Float
"hello" : String
True : Bool
-- Functions have types too. Read -> as "goes to". Think of the rightmost type
-- as the type of the return value.
not : Bool -> Bool
round : Float -> Int
-- When you define a value, it's good practice to write its type above it.
-- The annotation is a form of documentation, which is verified by the compiler.
double : Int -> Int
double x = x * 2
-- Function arguments are passed in parentheses.
-- Lowercase types are type variables: they can be any type, as long as each
-- call is consistent.
List.map : (a -> b) -> List a -> List b
-- "List dot map has type a-goes-to-b, goes to list of a, goes to list of b."
-- There are three special lowercase types: number, comparable, and appendable.
-- Numbers allow you to use arithmetic on Ints and Floats.
-- Comparable allows you to order numbers and strings, like a < b.
-- Appendable things can be combined with a ++ b.
{-- Type Aliases and Union Types --}
-- When you write a record or tuple, its type already exists.
-- (Notice that record types use colon and record values use equals.)
origin : { x : Float, y : Float, z : Float }
origin =
{ x = 0, y = 0, z = 0 }
-- You can give existing types a nice name with a type alias.
type alias Point3D = { x : Float, y : Float, z : Float }
-- If you alias a record, you can use the name as a constructor function.
otherOrigin : Point3D
otherOrigin = Point3D 0 0 0
-- But it's still the same type, you can equate them
origin == otherOrigin -- True
-- By contrast, defining a union type creates a type that didn't exist before.
-- A union type is so called because it can be one of many possibilities.
-- Each of the possibilities is represented as a "tag".
type Direction = North | South | East | West
-- Tags can carry other values of known type. This can work recursively.
type IntTree = Leaf | Node Int IntTree IntTree
-- "Leaf" and "Node" are the tags. Everything following a tag is a type.
-- Tags can be used as values or functions.
root : IntTree
root = Node 7 Leaf Leaf
-- Union types (and type aliases) can use type variables.
type Tree a = Leaf | Node a (Tree a) (Tree a)
-- You can pattern match union tags. The uppercase tags must be matched exactly.
-- The lowercase variables will match anything. Underscore also matches
-- anything, but signifies that you aren't using it.
leftmostElement : Tree a -> Maybe a
leftmostElement tree =
case tree of
Leaf -> Nothing
Node x Leaf _ -> Just x
Node _ subtree _ -> leftmostElement subtree
-- That's pretty much it for the language itself. Now let's see how to organize
-- and run your code.
{-- Modules and Imports --}
-- The core libraries are organized into modulues, as are any third-party
-- libraries you may use. For large projects, you can define your own modulues.
-- Put this at the top of the file. If omitted, you're in Main.
module Name where
-- By default, everything is exported.
-- Limit what values and types are exported
module Name (Type, value) where
-- One common pattern is to export a union type but not its tags. This is known
-- as an "opaque type", and is frequently used in libraries.
-- Import code from other modules to use it in this one
-- Places Dict in scope, so you can call Dict.insert
import Dict
-- Imports the Dict module and the Dict type, so your annotations don't have to
-- say Dict.Dict. You can still use Dict.insert.
import Dict exposing (Dict)
-- Rename an import.
import Graphics.Collage as C
{-- Ports --}
-- A port indicates that you will be communicating with the outside world.
-- Ports are only allowed in the Main module.
-- An incoming port is just a type signature.
port clientID : Int
-- An outgoing port has a defintion.
port clientOrders : List String
port clientOrders = ["Books", "Groceries", "Furniture"]
-- We won't go into the details, but you set up callbacks in JavaScript to send
-- on incoming ports and receive on outgoing ports.
{-- Command Line Tools --}
-- Compile a file.
$ elm make MyFile.elm
-- The first time you do this, Elm will install the core libraries and create
-- elm-package.json, where information about your project is kept.
-- The reactor is a server that compiles and runs your files.
-- Click the wrench next to file names to enter the time-travelling debugger!
$ elm reactor
-- Experiment with simple expressions in a Read-Eval-Print Loop.
$ elm repl
-- Packages are identified by GitHub username and repo name.
-- Install a new package, and record it in elm-package.json.
$ elm package install evancz/elm-html
-- Elm's package manager enforces semantic versioning, so minor version bumps
-- will never break your build!
```
The Elm language is surprisingly small. You can now look through almost any Elm
source code and have a rough idea of what is going on. However, the possibilties
for error-resistant and easy-to-refactor code are endless!
Here are some useful resources.
* The [Elm website](http://elm-lang.org/). Includes:
* Links to the [installers](http://elm-lang.org/install)
* [Documentation guides](http://elm-lang.org/docs), including the [syntax reference](http://elm-lang.org/docs/syntax)
* Lots of helpful [examples](http://elm-lang.org/examples)
* Documentation for [Elm's core libraries](http://package.elm-lang.org/packages/elm-lang/core/latest/). Take note of:
* [Basics](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), which is imported by default
* Data structures like [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict), and [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
* JSON [encoding](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) and [decoding](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode)
* [The Elm Architecture](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). An essay with examples on how to organize code into components.
* The [Elm mailing list](https://groups.google.com/forum/#!forum/elm-discuss). Everyone is friendly and helpful.
Go out and write some Elm!

2
erlang.html.markdown
View File

@ -177,7 +177,7 @@ is_dog(A) -> false.
% A guard sequence is either a single guard or a series of guards, separated % A guard sequence is either a single guard or a series of guards, separated
% by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at % by semicolons (`;`). The guard sequence `G1; G2; ...; Gn` is true if at
% least one of the guards `G1`, `G2`, ..., `Gn` evaluates to `true`. % least one of the guards `G1`, `G2`, ..., `Gn` evaluates to `true`.
is_pet(A) when is_atom(A), (A =:= dog) or (A =:= cat) -> true; is_pet(A) when is_atom(A), (A =:= dog);(A =:= cat) -> true;
is_pet(A) -> false. is_pet(A) -> false.
% Warning: not all valid Erlang expressions can be used as guard expressions; % Warning: not all valid Erlang expressions can be used as guard expressions;

18
es-es/brainfuck-es.html.markdown
View File

@ -9,8 +9,10 @@ lang: es-es
--- ---
Brainfuck (con mayúscula sólo al inicio de una oración) es un Brainfuck (con mayúscula sólo al inicio de una oración) es un
lenguaje de programación mínimo, computacionalmente universal lenguaje de programación extremadamente pequeño, Turing completo con sólo 8 comandos.
en tamaño con sólo 8 comandos.
Puedes probar brainfuck en tu navegador con [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
``` ```
@ -18,7 +20,7 @@ Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
será ignorado. será ignorado.
Brainfuck es representado por un arreglo de 30,000 celdas inicializadas Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
en cero y un apuntador en la celda actual. en cero y un puntero apuntando la celda actual.
Existen ocho comandos: Existen ocho comandos:
@ -26,7 +28,7 @@ Existen ocho comandos:
- : Decrementa 1 al valor de la celda actual. - : Decrementa 1 al valor de la celda actual.
> : Mueve el apuntador a la siguiente celda. (a la derecha) > : Mueve el apuntador a la siguiente celda. (a la derecha)
< : Mueve el apuntador a la celda anterior. (a la izquierda) < : Mueve el apuntador a la celda anterior. (a la izquierda)
. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A') . : Imprime el valor en ASCII de la celda actual (p.e. 65 = 'A')
, : Lee un caracter como input y lo escribe en la celda actual. , : Lee un caracter como input y lo escribe en la celda actual.
[ : Si el valor en la celda actual es cero mueve el apuntador [ : Si el valor en la celda actual es cero mueve el apuntador
hasta el primer ']' que encuentre. Si no es cero sigue a la hasta el primer ']' que encuentre. Si no es cero sigue a la
@ -37,7 +39,7 @@ Existen ocho comandos:
[ y ] forman un while. Obviamente, deben estar balanceados. [ y ] forman un while. Obviamente, deben estar balanceados.
Ahora unos ejemplos de programas escritos con brainfuck. Estos son algunos ejemplos de programas escritos con brainfuck.
++++++ [ > ++++++++++ < - ] > +++++ . ++++++ [ > ++++++++++ < - ] > +++++ .
@ -63,7 +65,7 @@ Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un
cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.). terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
Ten en mente que los espacios son sólo para fines de legibilidad. Ten en cuenta que los espacios son sólo para fines de legibilidad.
Es lo mismo escribir el ejemplo de arriba que esto: Es lo mismo escribir el ejemplo de arriba que esto:
,[>+<-]>. ,[>+<-]>.
@ -81,7 +83,7 @@ hasta la próxima vez. Para resolver este problema también incrementamos la
celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
el resultado. el resultado.
``` ```
Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir Y eso es brainfuck. No es tan difícil, ¿verdad? Como diversión, puedes escribir
tu propio intérprete de brainfuck o tu propio programa en brainfuck. El tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
intérprete es relativamente sencillo de hacer, pero si eres masoquista, intérprete es relativamente sencillo de hacer, pero si eres masoquista,
intenta construir tu proprio intérprete de brainfuck... en brainfuck. puedes intentar construir tu propio intérprete de brainfuck... en brainfuck.

14
es-es/git-es.html.markdown
View File

@ -18,11 +18,11 @@ versionar y administrar nuestro código fuente.
## Versionamiento, conceptos. ## Versionamiento, conceptos.
### Qué es el control de versiones? ### ¿Qué es el control de versiones?
El control de versiones es un sistema que guarda todos los cambios realizados en El control de versiones es un sistema que guarda todos los cambios realizados en
uno o varios archivos, a lo largo del tiempo. uno o varios archivos, a lo largo del tiempo.
### Versionamiento centralizado vs Versionamiento Distribuido. ### Versionamiento centralizado vs versionamiento distribuido.
+ El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar + El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar
archivos. archivos.
@ -33,9 +33,9 @@ uno o varios archivos, a lo largo del tiempo.
[Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones) [Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
### Por qué usar Git? ### ¿Por qué usar Git?
* Se puede trabajar sin conexion. * Se puede trabajar sin conexión.
* ¡Colaborar con otros es sencillo!. * ¡Colaborar con otros es sencillo!.
* Derivar, crear ramas del proyecto (aka: Branching) es fácil. * Derivar, crear ramas del proyecto (aka: Branching) es fácil.
* Combinar (aka: Merging) * Combinar (aka: Merging)
@ -47,7 +47,7 @@ uno o varios archivos, a lo largo del tiempo.
### Repositorio ### Repositorio
Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka: Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
comits), y encabezados (aka: heads). Imagina que un repositorio es una clase, commits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
y que sus atributos otorgan acceso al historial del elemento, además de otras y que sus atributos otorgan acceso al historial del elemento, además de otras
cosas. cosas.
@ -62,12 +62,12 @@ y mas.
### Directorio de trabajo (componentes del repositorio) ### Directorio de trabajo (componentes del repositorio)
Es basicamente los directorios y archivos dentro del repositorio. La mayoría de Es básicamente los directorios y archivos dentro del repositorio. La mayoría de
las veces se le llama "directorio de trabajo". las veces se le llama "directorio de trabajo".
### Índice (componentes del directorio .git) ### Índice (componentes del directorio .git)
El índice es el área de inicio en git. Es basicamente la capa que separa el El índice es el área de inicio en git. Es básicamente la capa que separa el
directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores
más poder sobre lo que se envía y se recibe del repositorio. más poder sobre lo que se envía y se recibe del repositorio.

20
es-es/javascript-es.html.markdown
View File

@ -30,7 +30,7 @@ Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto
// Cada sentencia puede ser terminada con punto y coma ; // Cada sentencia puede ser terminada con punto y coma ;
hazAlgo(); hazAlgo();
// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente // ... aunque no es necesario, ya que el punto y coma se agrega automáticamente
// cada que se detecta una nueva línea, a excepción de algunos casos. // cada que se detecta una nueva línea, a excepción de algunos casos.
hazAlgo() hazAlgo()
@ -109,7 +109,7 @@ null == undefined; // = true
null === undefined; // false null === undefined; // false
// Los Strings funcionan como arreglos de caracteres // Los Strings funcionan como arreglos de caracteres
// Puedes accesar a cada caracter con la función charAt() // Puedes acceder a cada caracter con la función charAt()
"Este es un String".charAt(0); // = 'E' "Este es un String".charAt(0); // = 'E'
// ...o puedes usar la función substring() para acceder a pedazos más grandes // ...o puedes usar la función substring() para acceder a pedazos más grandes
@ -186,7 +186,7 @@ miObjeto.miLlave; // = "miValor"
// agregar nuevas llaves. // agregar nuevas llaves.
miObjeto.miTerceraLlave = true; miObjeto.miTerceraLlave = true;
// Si intentas accesar con una llave que aún no está asignada tendrás undefined. // Si intentas acceder con una llave que aún no está asignada tendrás undefined.
miObjeto.miCuartaLlave; // = undefined miObjeto.miCuartaLlave; // = undefined
/////////////////////////////////// ///////////////////////////////////
@ -301,7 +301,7 @@ i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, per
//inmediatamente", que preveé variables temporales de fugarse al ámbito global //inmediatamente", que preveé variables temporales de fugarse al ámbito global
(function(){ (function(){
var temporal = 5; var temporal = 5;
// Podemos accesar al ámbito global asignando al 'objeto global', el cual // Podemos acceder al ámbito global asignando al 'objeto global', el cual
// en un navegador siempre es 'window'. El objeto global puede tener // en un navegador siempre es 'window'. El objeto global puede tener
// un nombre diferente en ambientes distintos, por ejemplo Node.js . // un nombre diferente en ambientes distintos, por ejemplo Node.js .
window.permanente = 10; window.permanente = 10;
@ -321,7 +321,7 @@ function decirHolaCadaCincoSegundos(nombre){
alert(texto); alert(texto);
} }
setTimeout(interna, 5000); setTimeout(interna, 5000);
// setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos // setTimeout es asíncrono, así que la función decirHolaCadaCincoSegundos
// terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos // terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos
// Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene // Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene
// acceso a la variable 'texto' cuando es llamada. // acceso a la variable 'texto' cuando es llamada.
@ -339,7 +339,7 @@ var miObjeto = {
}; };
miObjeto.miFuncion(); // = "¡Hola Mundo!" miObjeto.miFuncion(); // = "¡Hola Mundo!"
// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables // Cuando las funciones de un objeto son llamadas, pueden acceder a las variables
// del objeto con la palabra clave 'this'. // del objeto con la palabra clave 'this'.
miObjeto = { miObjeto = {
miString: "¡Hola Mundo!", miString: "¡Hola Mundo!",
@ -401,11 +401,11 @@ var MiConstructor = function(){
miNuevoObjeto = new MiConstructor(); // = {miNumero: 5} miNuevoObjeto = new MiConstructor(); // = {miNumero: 5}
miNuevoObjeto.miNumero; // = 5 miNuevoObjeto.miNumero; // = 5
// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una // Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a acceder a una
// propiedad en un objeto que no existe en el objeto el intérprete buscará en // propiedad en un objeto que no existe en el objeto el intérprete buscará en
// el prototipo. // el prototipo.
// Algunas implementaciones de JavaScript te permiten accesar al prototipo de // Algunas implementaciones de JavaScript te permiten acceder al prototipo de
// un objeto con la propiedad __proto__. Mientras que esto es útil para explicar // un objeto con la propiedad __proto__. Mientras que esto es útil para explicar
// prototipos, no es parte del estándar; veremos formas estándar de usar prototipos // prototipos, no es parte del estándar; veremos formas estándar de usar prototipos
// más adelante. // más adelante.
@ -440,7 +440,7 @@ miPrototipo.sentidoDeLaVida = 43;
miObjeto.sentidoDeLaVida; // = 43 miObjeto.sentidoDeLaVida; // = 43
// Mencionabamos anteriormente que __proto__ no está estandarizado, y que no // Mencionabamos anteriormente que __proto__ no está estandarizado, y que no
// existe una forma estándar de accesar al prototipo de un objeto. De todas formas. // existe una forma estándar de acceder al prototipo de un objeto. De todas formas.
// hay dos formas de crear un nuevo objeto con un prototipo dado. // hay dos formas de crear un nuevo objeto con un prototipo dado.
// El primer método es Object.create, el cual es una adición reciente a JavaScript, // El primer método es Object.create, el cual es una adición reciente a JavaScript,
@ -476,7 +476,7 @@ typeof miNumero; // = 'number'
typeof miNumeroObjeto; // = 'object' typeof miNumeroObjeto; // = 'object'
miNumero === miNumeroObjeyo; // = false miNumero === miNumeroObjeyo; // = false
if (0){ if (0){
// Este código no se ejecutara porque 0 es false. // Este código no se ejecutará porque 0 es false.
} }
// Aún así, los objetos que envuelven y los prototipos por defecto comparten // Aún así, los objetos que envuelven y los prototipos por defecto comparten

16
es-es/json-es.html.markdown
View File

@ -21,22 +21,22 @@ JSON en su forma más pura no tiene comentarios, pero la mayoría de los parsead
"llaves": "siempre debe estar entre comillas (ya sean dobles o simples)", "llaves": "siempre debe estar entre comillas (ya sean dobles o simples)",
"numeros": 0, "numeros": 0,
"strings": "Høla, múndo. Todo el unicode está permitido, así como \"escapar\".", "strings": "Høla, múndo. Todo el unicode está permitido, así como \"escapar\".",
"soporta booleanos?": true, "¿soporta booleanos?": true,
"vacios": null, "vacíos": null,
"numero grande": 1.2e+100, "numero grande": 1.2e+100,
"objetos": { "objetos": {
"comentario": "La mayoria de tu estructura vendra de objetos.", "comentario": "La mayoría de tu estructura vendrá de objetos.",
"arreglo": [0, 1, 2, 3, "Los arreglos pueden contener cualquier cosa.", 5], "arreglo": [0, 1, 2, 3, "Los arreglos pueden contener cualquier cosa.", 5],
"otro objeto": { "otro objeto": {
"comentario": "Estas cosas pueden estar anidadas, muy util." "comentario": "Estas cosas pueden estar anidadas, muy útil."
} }
}, },
"tonteria": [ "tontería": [
{ {
"fuentes de potasio": ["bananas"] "fuentes de potasio": ["bananas"]
}, },
@ -50,10 +50,10 @@ JSON en su forma más pura no tiene comentarios, pero la mayoría de los parsead
"estilo alternativo": { "estilo alternativo": {
"comentario": "Mira esto!" "comentario": "Mira esto!"
, "posicion de la coma": "no importa - mientras este antes del valor, entonces sera valido" , "posición de la coma": "no importa - mientras este antes del valor, entonces sera válido"
, "otro comentario": "que lindo" , "otro comentario": "qué lindo"
}, },
"eso fue rapido": "Y, estas listo. Ahora sabes todo lo que JSON tiene para ofrecer." "eso fue rapido": "Y, estás listo. Ahora sabes todo lo que JSON tiene para ofrecer."
} }
``` ```

8
es-es/python3-es.html.markdown
View File

@ -97,7 +97,7 @@ not False # => True
None # => None None # => None
# No uses el símbolo de igualdad `==` para comparar objetos con None # No uses el símbolo de igualdad `==` para comparar objetos con None
# Usa `is` en lugar de # Usa `is` en su lugar
"etc" is None #=> False "etc" is None #=> False
None is None #=> True None is None #=> True
@ -383,7 +383,7 @@ def keyword_args(**kwargs):
keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"} keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
# You can do both at once, if you like# Puedes hacer ambas a la vez si quieres # Puedes hacer ambas a la vez si quieres
def todos_los_argumentos(*args, **kwargs): def todos_los_argumentos(*args, **kwargs):
print args print args
print kwargs print kwargs
@ -478,7 +478,7 @@ Humano.roncar() #=> "*roncar*"
# Puedes importar módulos # Puedes importar módulos
import math import math
print(math.sqrt(16)) #=> 4 print(math.sqrt(16)) #=> 4.0
# Puedes obtener funciones específicas desde un módulo # Puedes obtener funciones específicas desde un módulo
from math import ceil, floor from math import ceil, floor
@ -511,7 +511,7 @@ def duplicar_numeros(iterable):
for i in iterable: for i in iterable:
yield i + i yield i + i
# Un generador cera valores sobre la marcha. # Un generador crea valores sobre la marcha.
# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración. # En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración.
# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'. # Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'.
# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse. # Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse.

6
es-es/ruby-es.html.markdown
View File

@ -29,7 +29,7 @@ Nadie los usa.
Tu tampoco deberías Tu tampoco deberías
=end =end
# Lo primero y principal: Todo es un objeto # En primer lugar: Todo es un objeto
# Los números son objetos # Los números son objetos
@ -128,7 +128,7 @@ ruta = '/mal/nombre/'
# Los símbolos (son objetos) # Los símbolos (son objetos)
# Los símbolos son inmutables, constantes reusables representadas internamente por un # Los símbolos son inmutables, constantes reusables representadas internamente por un
# valor entero. Son usalmente usados en vez de strings para expresar eficientemente # valor entero. Son normalmente usados en vez de strings para expresar eficientemente
# valores específicos y significativos # valores específicos y significativos
:pendiente.class #=> Symbol :pendiente.class #=> Symbol
@ -156,7 +156,7 @@ arreglo[0] #=> 1
arreglo.first #=> 1 arreglo.first #=> 1
arreglo[12] #=> nil arreglo[12] #=> nil
# Tal como la aritmética, el acceso como variable[índice] # Al igual que en aritmética, el acceso como variable[índice]
# es sólo azúcar sintáctica # es sólo azúcar sintáctica
# para llamar el método [] de un objeto # para llamar el método [] de un objeto
arreglo.[] 0 #=> 1 arreglo.[] 0 #=> 1

596
es-es/swift-es.html.markdown Normal file
View File

@ -0,0 +1,596 @@
---
language: swift
contributors:
- ["Grant Timmerman", "http://github.com/grant"]
- ["Christopher Bess", "http://github.com/cbess"]
- ["Joey Huang", "http://github.com/kamidox"]
- ["Anthony Nguyen", "http://github.com/anthonyn60"]
translators:
- ["David Hsieh", "http://github.com/deivuh"]
lang: es-es
filename: learnswift-es.swift
---
Swift es un lenguaje de programación para el desarrollo en iOS y OS X creado
por Apple. Diseñado para coexistir con Objective-C y ser más resistente contra
el código erroneo, Swift fue introducido en el 2014 en el WWDC, la conferencia
de desarrolladores de Apple.
Véase también la guía oficial de Apple, [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/), el cual tiene un completo tutorial de Swift.
```swift
// Importar un módulo
import UIKit
//
// MARK: Básicos
//
// XCode soporta referencias para anotar tu código y agregarlos a lista de la
// barra de saltos.
// MARK: Marca de sección
// TODO: Hacer algo pronto
// FIXME: Arreglar este código
// En Swift 2, println y print fueron combinados en un solo método print.
// Print añade una nueva línea automáticamente.
print("Hola, mundo") // println ahora es print
print("Hola, mundo", appendNewLine: false) // print sin agregar nueva línea
// Valores de variables (var) pueden cambiar después de ser asignados
// Valores de constrantes (let) no pueden cambiarse después de ser asignados
var myVariable = 42
let øπΩ = "value" // nombres de variable unicode
let π = 3.1415926
let convenience = "keyword" // nombre de variable contextual
// Las declaraciones pueden ser separadas por punto y coma (;)
let weak = "keyword"; let override = "another keyword"
// Los acentos abiertos (``) permiten utilizar palabras clave como nombres de
// variable
let `class` = "keyword"
let explicitDouble: Double = 70
let intValue = 0007 // 7
let largeIntValue = 77_000 // 77000
let label = "some text " + String(myVariable) // Conversión (casting)
let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string
// Valores específicos de la compilación (build)
// utiliza la configuración -D
#if false
print("No impreso")
let buildValue = 3
#else
let buildValue = 7
#endif
print("Build value: \(buildValue)") // Build value: 7
/*
Las opcionales son un aspecto del lenguaje Swift que permite el
almacenamiento de un valor `Some` (algo) o `None` (nada).
Debido a que Swift requiere que cada propiedad tenga un valor,
hasta un valor 'nil' debe de ser explicitamente almacenado como un
valor opcional.
Optional<T> es un enum.
*/
var someOptionalString: String? = "opcional" // Puede ser nil
// Al igual que lo anterior, pero ? es un operador postfix (sufijo)
var someOptionalString2: Optional<String> = "opcional"
if someOptionalString != nil {
// No soy nil
if someOptionalString!.hasPrefix("opt") {
print("Tiene el prefijo")
}
let empty = someOptionalString?.isEmpty
}
someOptionalString = nil
// Opcional implícitamente desenvuelto
var unwrappedString: String! = "Un valor esperado."
// Al igual que lo anterior, pero ! es un operador postfix (sufijo)
var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Un valor esperado."
if let someOptionalStringConstant = someOptionalString {
// tiene valor `Some` (algo), no nil
if !someOptionalStringConstant.hasPrefix("ok") {
// No tiene el prefijo
}
}
// Swift tiene soporte de almacenamiento para cualquier tipo de valor.
// AnyObject == id
// A diferencia de Objective-C `id`, AnyObject funciona con cualquier
// valor (Class, Int, struct, etc)
var anyObjectVar: AnyObject = 7
anyObjectVar = "Cambiado a un valor string, no es buena práctica, pero posible."
/*
Comentar aquí
/*
Comentarios anidados también son soportados
*/
*/
//
// MARK: Colecciones
//
/*
Tipos Array (arreglo) y Dictionary (diccionario) son structs (estructuras).
Así que `let` y `var` también indican si son mudables (var) o
inmutables (let) durante la declaración de sus tipos.
*/
// Array (arreglo)
var shoppingList = ["catfish", "water", "lemons"]
shoppingList[1] = "bottle of water"
let emptyArray = [String]() // let == inmutable
let emptyArray2 = Array<String>() // igual que lo anterior
var emptyMutableArray = [String]() // var == mudable
// Dictionary (diccionario)
var occupations = [
"Malcolm": "Captain",
"kaylee": "Mechanic"
]
occupations["Jayne"] = "Public Relations"
let emptyDictionary = [String: Float]() // let == inmutable
let emptyDictionary2 = Dictionary<String, Float>() // igual que lo anterior
var emptyMutableDictionary = [String: Float]() // var == mudable
//
// MARK: Flujo de control
//
// Ciclo for (array)
let myArray = [1, 1, 2, 3, 5]
for value in myArray {
if value == 1 {
print("Uno!")
} else {
print("No es uno!")
}
}
// Ciclo for (dictionary)
var dict = ["uno": 1, "dos": 2]
for (key, value) in dict {
print("\(key): \(value)")
}
// Ciclo for (range)
for i in -1...shoppingList.count {
print(i)
}
shoppingList[1...2] = ["steak", "peacons"]
// Utilizar ..< para excluir el último valor
// Ciclo while
var i = 1
while i < 1000 {
i *= 2
}
// Ciclo do-while
do {
print("Hola")
} while 1 == 2
// Switch
// Muy potente, se puede pensar como declaraciones `if` con _azúcar sintáctico_
// Soportan String, instancias de objetos, y primitivos (Int, Double, etc)
let vegetable = "red pepper"
switch vegetable {
case "celery":
let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
let vegetableComment = "That would make a good tea sandwich."
case let localScopeValue where localScopeValue.hasSuffix("pepper"):
let vegetableComment = "Is it a spicy \(localScopeValue)?"
default: // obligatorio (se debe cumplir con todos los posibles valores de entrada)
let vegetableComment = "Everything tastes good in soup."
}
//
// MARK: Funciones
//
// Funciones son un tipo de primera-clase, quiere decir que pueden ser anidados
// en funciones y pueden ser pasados como parámetros
// Función en documentación de cabeceras Swift (formato reStructedText)
/**
Una operación de saludo
- Una viñeta en la documentación
- Otra viñeta en la documentación
:param: name Un nombre
:param: day Un día
:returns: Un string que contiene el valor de name y day
*/
func greet(name: String, day: String) -> String {
return "Hola \(name), hoy es \(day)."
}
greet("Bob", "Martes")
// Similar a lo anterior, a excepción del compartamiento de los parámetros
// de la función
func greet2(requiredName: String, externalParamName localParamName: String) -> String {
return "Hola \(requiredName), hoy es el día \(localParamName)"
}
greet2(requiredName:"John", externalParamName: "Domingo")
// Función que devuelve múltiples valores en una tupla
func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79)
}
let pricesTuple = getGasPrices()
let price = pricesTuple.2 // 3.79
// Ignorar tupla (u otros) valores utilizando _ (guión bajo)
let (_, price1, _) = pricesTuple // price1 == 3.69
print(price1 == pricesTuple.1) // true
print("Gas price: \(price)")
// Cantidad variable de argumentos
func setup(numbers: Int...) {
// Es un arreglo
let number = numbers[0]
let argCount = numbers.count
}
// Pasando y devolviendo funciones
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
// Pasando como referencia
func swapTwoInts(inout a: Int, inout b: Int) {
let tempA = a
a = b
b = tempA
}
var someIntA = 7
var someIntB = 3
swapTwoInts(&someIntA, &someIntB)
print(someIntB) // 7
//
// MARK: Closures (Clausuras)
//
var numbers = [1, 2, 6]
// Las funciones son un caso especial de closure ({})
// Ejemplo de closure.
// `->` Separa los argumentos del tipo de retorno
// `in` Separa la cabecera del cuerpo del closure
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
// Cuando se conoce el tipo, como en lo anterior, se puede hacer esto
numbers = numbers.map({ number in 3 * number })
// o esto
//numbers = numbers.map({ $0 * 3 })
print(numbers) // [3, 6, 18]
// Closure restante
numbers = sorted(numbers) { $0 > $1 }
print(numbers) // [18, 6, 3]
// Bastante corto, debido a que el operador < infiere los tipos
numbers = sorted(numbers, < )
print(numbers) // [3, 6, 18]
//
// MARK: Estructuras
//
// Las estructuras y las clases tienen capacidades similares
struct NamesTable {
let names = [String]()
// Subscript personalizado
subscript(index: Int) -> String {
return names[index]
}
}
// Las estructuras tienen un inicializador designado autogenerado (implícitamente)
let namesTable = NamesTable(names: ["Me", "Them"])
let name = namesTable[1]
print("Name is \(name)") // Name is Them
//
// MARK: Clases
//
// Las clases, las estructuras y sus miembros tienen tres niveles de control de acceso
// Éstos son: internal (predeterminado), public, private
public class Shape {
public func getArea() -> Int {
return 0;
}
}
// Todos los métodos y las propiedades de una clase son public (públicas)
// Si solo necesitas almacenar datos en un objecto estructurado,
// debes de utilizar `struct`
internal class Rect: Shape {
var sideLength: Int = 1
// Getter y setter personalizado
private var perimeter: Int {
get {
return 4 * sideLength
}
set {
// `newValue` es una variable implícita disponible para los setters
sideLength = newValue / 4
}
}
// Lazily loading (inicialización bajo demanda) a una propiedad
// subShape queda como nil (sin inicializar) hasta que getter es llamado
lazy var subShape = Rect(sideLength: 4)
// Si no necesitas un getter y setter personalizado
// pero aún quieres ejecutar código antes y después de hacer get o set
// a una propiedad, puedes utilizar `willSet` y `didSet`
var identifier: String = "defaultID" {
// El argumento `willSet` será el nombre de variable para el nuevo valor
willSet(someIdentifier) {
print(someIdentifier)
}
}
init(sideLength: Int) {
self.sideLength = sideLength
// Siempre poner super.init de último al momento de inicializar propiedades
// personalizadas
super.init()
}
func shrink() {
if sideLength > 0 {
--sideLength
}
}
override func getArea() -> Int {
return sideLength * sideLength
}
}
// Una clase simple `Square` que extiende de `Rect`
class Square: Rect {
convenience init() {
self.init(sideLength: 5)
}
}
var mySquare = Square()
print(mySquare.getArea()) // 25
mySquare.shrink()
print(mySquare.sideLength) // 4
// Conversión de tipo de instancia
let aShape = mySquare as Shape
// Comparar instancias, no es igual a == que compara objetos (equal to)
if mySquare === mySquare {
print("Yep, it's mySquare")
}
// Inicialización (init) opcional
class Circle: Shape {
var radius: Int
override func getArea() -> Int {
return 3 * radius * radius
}
// Un signo de interrogación como sufijo después de `init` es un init opcional
// que puede devolver nil
init?(radius: Int) {
self.radius = radius
super.init()
if radius <= 0 {
return nil
}
}
}
var myCircle = Circle(radius: 1)
print(myCircle?.getArea()) // Optional(3)
print(myCircle!.getArea()) // 3
var myEmptyCircle = Circle(radius: -1)
print(myEmptyCircle?.getArea()) // "nil"
if let circle = myEmptyCircle {
// no será ejecutado debido a que myEmptyCircle es nil
print("circle is not nil")
}
//
// MARK: Enums
//
// Los enums pueden ser opcionalmente de un tipo específico o de su propio tipo
// Al igual que las clases, pueden contener métodos
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func getIcon() -> String {
switch self {
case .Spades: return "♤"
case .Hearts: return "♡"
case .Diamonds: return "♢"
case .Clubs: return "♧"
}
}
}
// Los valores de enum permite la sintaxis corta, sin necesidad de poner
// el tipo del enum cuando la variable es declarada de manera explícita
var suitValue: Suit = .Hearts
// Enums de tipo no-entero requiere asignaciones de valores crudas directas
enum BookName: String {
case John = "John"
case Luke = "Luke"
}
print("Name: \(BookName.John.rawValue)")
// Enum con valores asociados
enum Furniture {
// Asociación con Int
case Desk(height: Int)
// Asociación con String e Int
case Chair(String, Int)
func description() -> String {
switch self {
case .Desk(let height):
return "Desk with \(height) cm"
case .Chair(let brand, let height):
return "Chair of \(brand) with \(height) cm"
}
}
}
var desk: Furniture = .Desk(height: 80)
print(desk.description()) // "Desk with 80 cm"
var chair = Furniture.Chair("Foo", 40)
print(chair.description()) // "Chair of Foo with 40 cm"
//
// MARK: Protocolos
//
// `protocol` puede requerir que los tipos tengan propiedades
// de instancia específicas, métodos de instancia, métodos de tipo,
// operadores, y subscripts
protocol ShapeGenerator {
var enabled: Bool { get set }
func buildShape() -> Shape
}
// Protocolos declarados con @objc permiten funciones opcionales,
// que te permite evaluar conformidad
@objc protocol TransformShape {
optional func reshaped()
optional func canReshape() -> Bool
}
class MyShape: Rect {
var delegate: TransformShape?
func grow() {
sideLength += 2
// Pon un signo de interrogación después de la propiedad opcional,
// método, o subscript para ignorar un valor nil y devolver nil
// en lugar de tirar un error de tiempo de ejecución
// ("optional chaining")
if let allow = self.delegate?.canReshape?() {
// test for delegate then for method
self.delegate?.reshaped?()
}
}
}
//
// MARK: Otros
//
// `extension`: Agrega funcionalidades a tipos existentes
// Square ahora se "conforma" al protocolo `Printable`
extension Square: Printable {
var description: String {
return "Area: \(self.getArea()) - ID: \(self.identifier)"
}
}
print("Square: \(mySquare)")
// También puedes hacer extend a tipos prefabricados (built-in)
extension Int {
var customProperty: String {
return "This is \(self)"
}
func multiplyBy(num: Int) -> Int {
return num * self
}
}
print(7.customProperty) // "This is 7"
print(14.multiplyBy(3)) // 42
// Generics: Similar Java y C#. Utiliza la palabra clave `where` para
// especificar los requerimientos de los genéricos.
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
let foundAtIndex = findIndex([1, 2, 3, 4], 3)
print(foundAtIndex == 2) // true
// Operadores:
// Operadores personalizados puede empezar con los siguientes caracteres:
// / = - + * % < > ! & | ^ . ~
// o
// Caracteres unicode: math, symbol, arrow, dingbat, y line/box.
prefix operator !!! {}
// Un operador prefix que triplica la longitud del lado cuando es utilizado
prefix func !!! (inout shape: Square) -> Square {
shape.sideLength *= 3
return shape
}
// Valor actual
print(mySquare.sideLength) // 4
// Cambiar la longitud del lado utilizando el operador !!!,
// incrementa el tamaño por 3
!!!mySquare
print(mySquare.sideLength) // 12
```

182
factor.html.markdown Normal file
View File

@ -0,0 +1,182 @@
---
language: factor
contributors:
- ["hyphz", "http://github.com/hyphz/"]
filename: learnfactor.factor
---
Factor is a modern stack-based language, based on Forth, created by Slava Pestov.
Code in this file can be typed into Factor, but not directly imported because the vocabulary and import header would make the beginning thoroughly confusing.
```
! This is a comment
! Like Forth, all programming is done by manipulating the stack.
! Stating a literal value pushes it onto the stack.
5 2 3 56 76 23 65 ! No output, but stack is printed out in interactive mode
! Those numbers get added to the stack, from left to right.
! .s prints out the stack non-destructively.
.s ! 5 2 3 56 76 23 65
! Arithmetic works by manipulating data on the stack.
5 4 + ! No output
! `.` pops the top result from the stack and prints it.
. ! 9
! More examples of arithmetic:
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
! A number of words are provided to manipulate the stack, collectively known as shuffle words.
3 dup - ! duplicate the top item (1st now equals 2nd): 3 - 3
2 5 swap / ! swap the top with the second element: 5 / 2
4 0 drop 2 / ! remove the top item (dont print to screen): 4 / 2
1 2 3 nip .s ! remove the second item (similar to drop): 1 3
1 2 clear .s ! wipe out the entire stack
1 2 3 4 over .s ! duplicate the second item to the top: 1 2 3 4 3
1 2 3 4 2 pick .s ! duplicate the third item to the top: 1 2 3 4 2 3
! Creating Words
! The `:` word sets Factor into compile mode until it sees the `;` word.
: square ( n -- n ) dup * ; ! No output
5 square . ! 25
! We can view what a word does too.
! \ suppresses evaluation of a word and pushes its identifier on the stack instead.
\ square see ! : square ( n -- n ) dup * ;
! After the name of the word to create, the declaration between brackets gives the stack effect.
! We can use whatever names we like inside the declaration:
: weirdsquare ( camel -- llama ) dup * ;
! Provided their count matches the word's stack effect:
: 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 ; ! Also Ok
! Where Factor differs from Forth is in the use of quotations.
! A quotation is a block of code that is pushed on the stack as a value.
! [ starts quotation mode; ] ends it.
[ 2 + ] ! Quotation that adds 2 is left on the stack
4 swap call . ! 6
! And thus, higher order words. TONS of higher order words.
2 3 [ 2 + ] dip .s ! Pop top stack value, run quotation, push it back: 4 3
3 4 [ + ] keep .s ! Copy top stack value, run quotation, push the copy: 7 4
1 [ 2 + ] [ 3 + ] bi .s ! Run each quotation on the top value, push both results: 3 4
4 3 1 [ + ] [ + ] bi .s ! Quotations in a bi can pull values from deeper on the stack: 4 5 ( 1+3 1+4 )
1 2 [ 2 + ] bi@ .s ! Run the quotation on first and second values
2 [ + ] curry ! Inject the given value at the start of the quotation: [ 2 + ] is left on the stack
! Conditionals
! Any value is true except the built-in value f.
! A built-in value t does exist, but its use isn't essential.
! Conditionals are higher order words as with the combinators above.
5 [ "Five is true" . ] when ! Five is true
0 [ "Zero is true" . ] when ! Zero is true
f [ "F is true" . ] when ! No output
f [ "F is false" . ] unless ! F is false
2 [ "Two is true" . ] [ "Two is false" . ] if ! Two is true
! By default the conditionals consume the value under test, but starred variants
! leave it alone if it's true:
5 [ . ] when* ! 5
f [ . ] when* ! No output, empty stack, f is consumed because it's false
! Loops
! You've guessed it.. these are higher order words too.
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
! Loop through the list:
{ 2 4 6 8 } [ 1 + . ] each ! Prints 3 5 7 9
{ 2 4 6 8 } [ 1 + ] map ! Leaves { 3 5 7 9 } on stack
! Loop reducing or building lists:
{ 1 2 3 4 5 } [ 2 mod 0 = ] filter ! Keeps only list members for which quotation yields true: { 2 4 }
{ 2 4 6 8 } 0 [ + ] reduce . ! Like "fold" in functional languages: prints 20 (0+2+4+6+8)
{ 2 4 6 8 } 0 [ + ] accumulate . . ! Like reduce but keeps the intermediate values in a list: prints { 0 2 6 12 } then 20
1 5 [ 2 * dup ] replicate . ! Loops the quotation 5 times and collects the results in a list: { 2 4 8 16 32 }
1 [ dup 100 < ] [ 2 * dup ] produce ! Loops the second quotation until the first returns false and collects the results: { 2 4 8 16 32 64 128 }
! If all else fails, a general purpose while loop:
1 [ dup 10 < ] [ "Hello" . 1 + ] while ! Prints "Hello" 10 times
! Yes, it's hard to read
! That's what all those variant loops are for
! Variables
! Usually Factor programs are expected to keep all data on the stack.
! Using named variables makes refactoring harder (and it's called Factor for a reason)
! Global variables, if you must:
SYMBOL: name ! Creates name as an identifying word
"Bob" name set-global ! No output
name get-global . ! "Bob"
! Named local variables are considered an extension but are available
! In a quotation..
[| m n ! Quotation captures top two stack values into m and n
| m n + ] ! Read them
! Or in a word..
:: lword ( -- ) ! Note double colon to invoke lexical variable extension
2 :> c ! Declares immutable variable c to hold 2
c . ; ! Print it out
! In a word declared this way, the input side of the stack declaration
! becomes meaningful and gives the variable names stack values are captured into
:: double ( a -- result ) a 2 * ;
! Variables are declared mutable by ending their name with a shriek
:: mword2 ( a! -- x y ) ! Capture top of stack in mutable variable a
a ! Push a
a 2 * a! ! Multiply a by 2 and store result back in a
a ; ! Push new value of a
5 mword2 ! Stack: 5 10
! Lists and Sequences
! We saw above how to push a list onto the stack
0 { 1 2 3 4 } nth ! Access a particular member of a list: 1
10 { 1 2 3 4 } nth ! Error: sequence index out of bounds
1 { 1 2 3 4 } ?nth ! Same as nth if index is in bounds: 2
10 { 1 2 3 4 } ?nth ! No error if out of bounds: 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"
! And if you want to get meta, quotations are sequences and can be dismantled..
0 [ 2 + ] nth ! 2
1 [ 2 + ] nth ! +
[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
```
##Ready For More?
* [Factor Documentation](http://docs.factorcode.org/content/article-help.home.html)

441
fi-fi/go-fi.html.markdown Normal file
View File

@ -0,0 +1,441 @@
---
name: Go
category: language
language: Go
filename: learngo-fi.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"]
translators:
- ["Timo Virkkunen", "https://github.com/ComSecNinja"]
lang: fi-fi
---
Go luotiin työn tekemistä varten. Se ei ole tietojenkäsittelyn uusin trendi,
mutta se on uusin nopein tapa ratkaista oikean maailman ongelmia.
Sillä on staattisesti tyypitetyistä imperatiivisista kielistä tuttuja
konsepteja. Se kääntyy ja suorittuu nopeasti, lisää helposti käsitettävän
samanaikaisten komentojen suorittamisen nykyaikaisten moniytimisten
prosessoreiden hyödyntämiseksi ja antaa käyttäjälle ominaisuuksia suurten
projektien käsittelemiseksi.
Go tuo mukanaan loistavan oletuskirjaston sekä innokkaan yhteisön.
```go
// Yhden rivin kommentti
/* Useamman
rivin kommentti */
// Package -lausekkeella aloitetaan jokainen lähdekooditiedosto.
// Main on erityinen nimi joka ilmoittaa
// suoritettavan tiedoston kirjaston sijasta.
package main
// Import -lauseke ilmoittaa tässä tiedostossa käytetyt kirjastot.
import (
"fmt" // Paketti Go:n oletuskirjastosta.
"io/ioutil" // Implementoi hyödyllisiä I/O -funktioita.
m "math" // Matematiikkakirjasto jolla on paikallinen nimi m.
"net/http" // Kyllä, web-palvelin!
"strconv" // Kirjainjonojen muuntajia.
)
// Funktion määrittelijä. Main on erityinen: se on ohjelman suorittamisen
// aloittamisen alkupiste. Rakasta tai vihaa sitä, Go käyttää aaltosulkeita.
func main() {
// Println tulostaa rivin stdoutiin.
// Se tulee paketin fmt mukana, joten paketin nimi on mainittava.
fmt.Println("Hei maailma!")
// Kutsu toista funktiota tämän paketin sisällä.
beyondHello()
}
// Funktioilla voi olla parametrejä sulkeissa.
// Vaikkei parametrejä olisikaan, sulkeet ovat silti pakolliset.
func beyondHello() {
var x int // Muuttujan ilmoittaminen: ne täytyy ilmoittaa ennen käyttöä.
x = 3 // Arvon antaminen muuttujalle.
// "Lyhyet" ilmoitukset käyttävät := joka päättelee tyypin, ilmoittaa
// sekä antaa arvon muuttujalle.
y := 4
sum, prod := learnMultiple(x, y) // Funktio palauttaa kaksi arvoa.
fmt.Println("summa:", sum, "tulo:", prod) // Yksinkertainen tuloste.
learnTypes() // < y minuuttia, opi lisää!
}
/* <- usean rivin kommentti
Funktioilla voi olla parametrejä ja (useita!) palautusarvoja.
Tässä `x`, `y` ovat argumenttejä ja `sum`, `prod` ovat ne, mitä palautetaan.
Huomaa että `x` ja `sum` saavat tyyin `int`.
*/
func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // Palauta kaksi arvoa.
}
// Sisäänrakennettuja tyyppejä ja todellisarvoja.
func learnTypes() {
// Lyhyt ilmoitus antaa yleensä haluamasi.
str := "Opi Go!" // merkkijonotyyppi.
s2 := `"raaka" todellisarvoinen merrkijono
voi sisältää rivinvaihtoja.` // Sama merkkijonotyyppi.
// Ei-ASCII todellisarvo. Go-lähdekoodi on UTF-8.
g := 'Σ' // riimutyyppi, lempinimi int32:lle, sisältää unicode-koodipisteen.
f := 3.14195 //float64, IEEE-754 64-bittinen liukuluku.
c := 3 + 4i // complex128, sisäisesti ilmaistu kahdella float64:lla.
// var -syntaksi alkuarvoilla.
var u uint = 7 // Etumerkitön, toteutus riippuvainen koosta kuten int.
var pi float32 = 22. / 7
// Muuntosyntaksi lyhyellä ilmoituksella.
n := byte('\n') // byte on leminimi uint8:lle.
// Listoilla on kiinteä koko kääntöhetkellä.
var a4 [4]int // 4 int:in lista, alkiot ovat alustettu nolliksi.
a3 := [...]int{3, 1, 5} // Listan alustaja jonka kiinteäksi kooksi tulee 3
// alkiota, jotka saavat arvot 3, 1, ja 5.
// Siivuilla on muuttuva koko. Sekä listoilla että siivuilla on puolensa,
// mutta siivut ovat yleisempiä käyttötapojensa vuoksi.
s3 := []int{4, 5, 9} // Vertaa a3: ei sananheittoa (...).
s4 := make([]int, 4) // Varaa 4 int:n siivun, alkiot alustettu nolliksi.
var d2 [][]float64 // Vain ilmoitus, muistia ei varata.
bs := []byte("a slice") // Tyypinmuuntosyntaksi.
// Koska siivut ovat dynaamisia, niitä voidaan yhdistellä sellaisinaan.
// Lisätäksesi alkioita siivuun, käytä sisäänrakennettua append()-funktiota.
// Ensimmäinen argumentti on siivu, johon alkoita lisätään.
s := []int{1, 2, 3} // Tuloksena on kolmen alkion pituinen lista.
s = append(s, 4, 5, 6) // Lisätty kolme alkiota. Siivun pituudeksi tulee 6.
fmt.Println(s) // Päivitetty siivu on nyt [1 2 3 4 5 6]
// Lisätäksesi siivun toiseen voit antaa append-funktiolle referenssin
// siivuun tai todellisarvoiseen siivuun lisäämällä sanaheiton argumentin
// perään. Tämä tapa purkaa siivun alkiot ja lisää ne siivuun s.
s = append(s, []int{7, 8, 9}...) // 2. argumentti on todellisarvoinen siivu.
fmt.Println(s) // Päivitetty siivu on nyt [1 2 3 4 5 6 7 8 9]
p, q := learnMemory() // Ilmoittaa p ja q olevan tyyppiä osoittaja int:iin.
fmt.Println(*p, *q) // * seuraa osoittajaa. Tämä tulostaa kaksi int:ä.
// Kartat ovat dynaamisesti kasvavia assosiatiivisia listoja, kuten hash tai
// dictionary toisissa kielissä.
m := map[string]int{"three": 3, "four": 4}
m["one"] = 1
// Käyttämättömät muuttujat ovat virheitä Go:ssa.
// Alaviiva antaa sinun "käyttää" muuttujan mutta hylätä sen arvon.
_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
// Tulostaminen tietysti lasketaan muuttujan käyttämiseksi.
fmt.Println(s, c, a4, s3, d2, m)
learnFlowControl() // Takaisin flowiin.
}
// Go:ssa on useista muista kielistä poiketen mahdollista käyttää nimettyjä
// palautusarvoja.
// Nimen antaminen palautettavan arvon tyypille funktion ilmoitusrivillä
// mahdollistaa helpon palaamisen useasta eri funktion suorituskohdasta sekä
// pelkän return-lausekkeen käytön ilman muita mainintoja.
func learnNamedReturns(x, y int) (z int) {
z = x * y
return // z on epäsuorasti tässä, koska nimesimme sen aiemmin.
}
// Go kerää kaikki roskansa. Siinä on osoittajia mutta ei niiden laskentoa.
// Voit tehdä virheen mitättömällä osoittajalla, mutta et
// kasvattamalla osoittajaa.
func learnMemory() (p, q *int) {
// Nimetyillä palautusarvoilla p ja q on tyyppi osoittaja int:iin.
p = new(int) // Sisäänrakennettu funktio new varaa muistia.
// Varattu int on alustettu nollaksi, p ei ole enää mitätön.
s := make([]int, 20) // Varaa 20 int:ä yhteen kohtaan muistissa.
s[3] = 7 // Anna yhdelle niistä arvo.
r := -2 // Ilmoita toinen paikallinen muuttuja.
return &s[3], &r // & ottaa asian osoitteen muistissa.
}
func expensiveComputation() float64 {
return m.Exp(10)
}
func learnFlowControl() {
// If -lausekkeet vaativat aaltosulkeet mutta ei tavallisia sulkeita.
if true {
fmt.Println("mitä mä sanoin")
}
// Muotoilu on standardoitu käyttämällä komentorivin komentoa "go fmt".
if false {
// Nyrpistys.
} else {
// Nautinto.
}
// Käytä switch -lauseketta ketjutettujen if -lausekkeiden sijasta.
x := 42.0
switch x {
case 0:
case 1:
case 42:
// Tapaukset eivät "tipu läpi".
/*
Kuitenkin meillä on erikseen `fallthrough` -avainsana. Katso:
https://github.com/golang/go/wiki/Switch#fall-through
*/
case 43:
// Saavuttamaton.
default:
// Oletustapaus (default) on valinnainen.
}
// Kuten if, for -lauseke ei myöskään käytä tavallisia sulkeita.
// for- ja if- lausekkeissa ilmoitetut muuttujat ovat paikallisia niiden
// piireissä.
for x := 0; x < 3; x++ { // ++ on lauseke. Sama kuin "x = x + 1".
fmt.Println("iteraatio", x)
}
// x == 42 tässä.
// For on kielen ainoa silmukkalauseke mutta sillä on vaihtoehtosia muotoja.
for { // Päättymätön silmukka.
break // Kunhan vitsailin.
continue // Saavuttamaton.
}
// Voit käyttää range -lauseketta iteroidaksesi listojen, siivujen, merkki-
// jonojen, karttojen tai kanavien läpi. range palauttaa yhden (kanava) tai
// kaksi arvoa (lista, siivu, merkkijono ja kartta).
for key, value := range map[string]int{"yksi": 1, "kaksi": 2, "kolme": 3} {
// jokaista kartan paria kohden, tulosta avain ja arvo
fmt.Printf("avain=%s, arvo=%d\n", key, value)
}
// Kuten for -lausekkeessa := if -lausekkeessa tarkoittaa ilmoittamista ja
// arvon asettamista.
// Aseta ensin y, sitten testaa onko y > x.
if y := expensiveComputation(); y > x {
x = y
}
// Todellisarvoiset funktiot ovat sulkeumia.
xBig := func() bool {
return x > 10000 // Viittaa ylempänä ilmoitettuun x:ään.
}
fmt.Println("xBig:", xBig()) // tosi (viimeisin arvo on e^10).
x = 1.3e3 // Tämä tekee x == 1300
fmt.Println("xBig:", xBig()) // epätosi nyt.
// Lisäksi todellisarvoiset funktiot voidaan samalla sekä ilmoittaa että
// kutsua, jolloin niitä voidaan käyttää funtioiden argumentteina kunhan:
// a) todellisarvoinen funktio kutsutaan välittömästi (),
// b) palautettu tyyppi vastaa odotettua argumentin tyyppiä.
fmt.Println("Lisää ja tuplaa kaksi numeroa: ",
func(a, b int) int {
return (a + b) * 2
}(10, 2)) // Kutsuttu argumenteilla 10 ja 2
// => Lisää ja tuplaa kaksi numeroa: 24
// Kun tarvitset sitä, rakastat sitä.
goto love
love:
learnFunctionFactory() // Funktioita palauttavat funktiot
learnDefer() // Nopea kiertoreitti tärkeään avainsanaan.
learnInterfaces() // Hyvää kamaa tulossa!
}
func learnFunctionFactory() {
// Seuraavat kaksi ovat vastaavia, mutta toinen on käytännöllisempi
fmt.Println(sentenceFactory("kesä")("Kaunis", "päivä!"))
d := sentenceFactory("kesä")
fmt.Println(d("Kaunis", "päivä!"))
fmt.Println(d("Laiska", "iltapäivä!"))
}
// Somisteet ovat yleisiä toisissa kielissä. Sama saavutetaan Go:ssa käyttämällä
// todellisarvoisia funktioita jotka ottavat vastaan argumentteja.
func sentenceFactory(mystring string) func(before, after string) string {
return func(before, after string) string {
return fmt.Sprintf("%s %s %s", before, mystring, after) // uusi jono
}
}
func learnDefer() (ok bool) {
// Lykätyt lausekkeet suoritetaan juuri ennen funktiosta palaamista.
defer fmt.Println("lykätyt lausekkeet suorittuvat")
defer fmt.Println("käänteisessä järjestyksessä (LIFO).")
defer fmt.Println("\nTämä rivi tulostuu ensin, koska")
// Defer -lauseketta käytetään yleisesti tiedoston sulkemiseksi, jotta
// tiedoston sulkeva funktio pysyy lähellä sen avannutta funktiota.
return true
}
// Määrittele Stringer rajapintatyypiksi jolla on
// yksi jäsenfunktio eli metodi, String.
type Stringer interface {
String() string
}
// Määrittele pair rakenteeksi jossa on kaksi kenttää, x ja y tyyppiä int.
type pair struct {
x, y int
}
// Määrittele jäsenfunktio pair:lle. Pair tyydyttää nyt Stringer -rajapinnan.
func (p pair) String() string { // p:tä kutsutaan nimellä "receiver"
// Sprintf on toinen julkinen funktio paketissa fmt.
// Pistesyntaksilla viitataan P:n kenttiin.
return fmt.Sprintf("(%d, %d)", p.x, p.y)
}
func learnInterfaces() {
// Aaltosuljesyntaksi on "todellisarvoinen rakenne". Se todentuu alustetuksi
// rakenteeksi. := -syntaksi ilmoittaa ja alustaa p:n täksi rakenteeksi.
p := pair{3, 4}
fmt.Println(p.String()) // Kutsu p:n (tyyppiä pair) jäsenfunktiota String.
var i Stringer // Ilmoita i Stringer-rajapintatyypiksi.
i = p // Pätevä koska pair tyydyttää rajapinnan Stringer.
// Kutsu i:n (Stringer) jäsenfunktiota String. Tuloste on sama kuin yllä.
fmt.Println(i.String())
// Funktiot fmt-paketissa kutsuvat argumenttien String-jäsenfunktiota
// selvittääkseen onko niistä saatavilla tulostettavaa vastinetta.
fmt.Println(p) // Tuloste on sama kuin yllä. Println kutsuu String-metodia.
fmt.Println(i) // Tuloste on sama kuin yllä.
learnVariadicParams("loistavaa", "oppimista", "täällä!")
}
// Funktioilla voi olla muuttuva eli variteettinen
// määrä argumentteja eli parametrejä.
func learnVariadicParams(myStrings ...interface{}) {
// Iteroi jokaisen argumentin läpi.
// Tässä alaviivalla sivuutetaan argumenttilistan kunkin kohdan indeksi.
for _, param := range myStrings {
fmt.Println("param:", param)
}
// Luovuta variteettinen arvo variteettisena parametrinä.
fmt.Println("params:", fmt.Sprintln(myStrings...))
learnErrorHandling()
}
func learnErrorHandling() {
// "; ok" -muotoa käytetään selvittääksemme toimiko jokin vai ei.
m := map[int]string{3: "kolme", 4: "neljä"}
if x, ok := m[1]; !ok { // ok on epätosi koska 1 ei ole kartassa.
fmt.Println("ei ketään täällä")
} else {
fmt.Print(x) // x olisi arvo jos se olisi kartassa.
}
// Virhearvo voi kertoa muutakin ongelmasta.
if _, err := strconv.Atoi("ei-luku"); err != nil { // _ sivuuttaa arvon
// tulostaa strconv.ParseInt: parsing "ei-luku": invalid syntax
fmt.Println(err)
}
// Palaamme rajapintoihin hieman myöhemmin. Sillä välin,
learnConcurrency()
}
// c on kanava, samanaikaisturvallinen viestintäolio.
func inc(i int, c chan int) {
c <- i + 1 // <- on "lähetysoperaattori" kun kanava on siitä vasemmalla.
}
// Käytämme inc -funktiota samanaikaiseen lukujen lisäämiseen.
func learnConcurrency() {
// Sama make -funktio jota käytimme aikaisemmin siivun luomiseksi. Make
// varaa muistin ja alustaa siivut, kartat ja kanavat.
c := make(chan int)
// Aloita kolme samanaikaista gorutiinia (goroutine). Luvut kasvavat
// samanaikaisesti ja ehkäpä rinnakkain jos laite on kykenevä ja oikein
// määritelty. Kaikki kolme lähettävät samalle kanavalle.
go inc(0, c) // go -lauseke aloittaa uuden gorutiinin.
go inc(10, c)
go inc(-805, c)
// Lue kolme palautusarvoa kanavalta ja tulosta ne.
// Niiden saapumisjärjestystä ei voida taata!
// <- on "vastaanotto-operaattori" jos kanava on oikealla
fmt.Println(<-c, <-c, <-c)
cs := make(chan string) // Toinen kanava joka käsittelee merkkijonoja.
ccs := make(chan chan string) // Kanava joka käsittelee merkkijonokanavia.
go func() { c <- 84 }() // Aloita uusi gorutiini arvon lähettämiseksi.
go func() { cs <- "sanaa" }() // Uudestaan, mutta cs -kanava tällä kertaa.
// Select -lausekkeella on syntaksi kuten switch -lausekkeella mutta
// jokainen tapaus sisältää kanavaoperaation. Se valitsee satunnaisen
// tapauksen niistä kanavista, jotka ovat kommunikaatiovalmiita
select {
case i := <-c: // Vastaanotettu arvo voidaan antaa muuttujalle
fmt.Printf("se on %T", i)
case <-cs: // tai vastaanotettu arvo voidaan sivuuttaa.
fmt.Println("se on merkkijono")
case <-ccs: // Tyhjä kanava; ei valmis kommunikaatioon.
fmt.Println("ei tapahtunut.")
}
// Tässä vaiheessa arvo oli otettu joko c:ltä tai cs:ltä. Yksi kahdesta
// ylempänä aloitetusta gorutiinista on valmistunut, toinen pysyy tukossa.
learnWebProgramming() // Go tekee sitä. Sinäkin haluat tehdä sitä.
}
// Yksittäinen funktio http -paketista aloittaa web-palvelimen.
func learnWebProgramming() {
// ListenAndServe:n ensimmäinen parametri on TCP-osoite, jota kuunnellaan.
// Toinen parametri on rajapinta, http.Handler.
go func() {
err := http.ListenAndServe(":8080", pair{})
fmt.Println(err) // älä sivuuta virheitä.
}()
requestServer()
}
// Tee pair:sta http.Handler implementoimalla sen ainoa metodi, ServeHTTP.
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Tarjoa dataa metodilla http.ResponseWriter.
w.Write([]byte("Opit Go:n Y minuutissa!"))
}
func requestServer() {
resp, err := http.Get("http://localhost:8080")
fmt.Println(err)
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
fmt.Printf("\nWeb-palvelin sanoo: `%s`", string(body))
}
```
## Lisää luettavaa
Go-tietämyksen alku ja juuri on sen [virallinen verkkosivu]()(http://golang.org/).
Siellä voit seurata oppitunteja, askarrella vuorovaikutteisesti sekä lukea paljon.
Kierroksen lisäksi [dokumentaatio](https://golang.org/doc/) pitää sisällään tietoa
siistin Go-koodin kirjoittamisesta, pakettien ja komentojen käytöstä sekä julkaisuhistoriasta.
Kielen määritelmä itsessään on suuresti suositeltavissa. Se on helppolukuinen ja
yllättävän lyhyt (niissä määrin kuin kielimääritelmät nykypäivänä ovat.)
Voit askarrella parissa kanssa [Go playgroundissa](https://play.golang.org/p/tnWMjr16Mm).
Muuttele sitä ja aja se selaimestasi! Huomaa, että voit käyttää [https://play.golang.org](https://play.golang.org)
[REPL:na](https://en.wikipedia.org/wiki/Read-eval-print_loop) testataksesi ja koodataksesi selaimessasi, ilman Go:n asentamista.
Go:n opiskelijoiden lukulistalla on [oletuskirjaston lähdekoodi](http://golang.org/src/pkg/).
Kattavasti dokumentoituna se antaa parhaan kuvan helppolukuisesta ja ymmärrettävästä Go-koodista,
-tyylistä ja -tavoista. Voit klikata funktion nimeä [doukumentaatiossa](http://golang.org/pkg/) ja
lähdekoodi tulee esille!
Toinen loistava paikka oppia on [Go by example](https://gobyexample.com/).
Go Mobile lisää tuen mobiilialustoille (Android ja iOS). Voit kirjoittaa pelkällä Go:lla natiiveja applikaatioita tai tehdä kirjaston joka sisältää sidoksia
Go-paketista, jotka puolestaan voidaan kutsua Javasta (Android) ja Objective-C:stä (iOS). Katso [lisätietoja](https://github.com/golang/go/wiki/Mobile).

259
fi-fi/markdown-fi.html.markdown Normal file
View File

@ -0,0 +1,259 @@
---
language: markdown
filename: markdown-fi.md
contributors:
- ["Dan Turkel", "http://danturkel.com/"]
translators:
- ["Timo Virkkunen", "https://github.com/ComSecNinja"]
lang: fi-fi
---
John Gruber loi Markdownin vuona 2004. Sen tarkoitus on olla helposti luettava ja kirjoitettava syntaksi joka muuntuu helposti HTML:ksi (ja nyt myös moneksi muuksi formaatiksi).
```markdown
<!-- Jokainen HTML-tiedosto on pätevää Markdownia. Tämä tarkoittaa että voimme
käyttää HTML-elementtejä Markdownissa, kuten kommentteja, ilman että markdown
-jäsennin vaikuttaa niihin. Tästä johtuen et voi kuitenkaan käyttää markdownia
HTML-elementtien sisällä jos luot sellaisen markdown-tiedostoon. -->
<!-- Markdownin toteutus vaihtelee jäsentimestä toiseen. Tämä opas yrittää
selventää mitkä ominaisuudet ovat yleisiä ja mitkä ovat eritysesti tiettyjen
jäsentimien ominaisuuksia. -->
<!-- Otsikot -->
<!-- Voit luoda HTML-elementtejä <h1> - <h6> helposti aloittamalla rivin
haluamallasi määrällä ristikkomerkkejä (#). -->
# Tämä on <h1>
## Tämä on <h2>
### Tämä on <h3>
#### Tämä on <h4>
##### Tämä on <h5>
###### Tämä on <h6>
<!-- Markdownissa on myös vaihtoehtoisia tapoja ilmaista h1 ja h2. -->
Tämä on h1
=============
Tämä on h2
-------------
<!-- Yksinkertaiset tekstimuotoilut -->
<!-- Tekstin voi helposti muotoilla kursiiviksi tai lihavoiduksi. -->
*Tämä teksti on kursivoitua.*
_Kuten on myös tämä teksti._
**Tämä teksti on lihavoitua.**
__Kuten on tämäkin teksti.__
***Tämä teksti on molempia.***
**_Kuten tämäkin!_**
*__Kuten tämäkin!__*
<!-- Github-tyylisessä Markdownissa, jota käytetään tiedostojen esittämiseksi
Githubissa, meillä on käytössämme myös yliviivaus: -->
~~Tämä teksti on yliviivattua.~~
<!-- Kappaleet ovat yhdellä tai useammalla peräkkäisellä tekstirivillä jotka
erotellaan yhdellä tai useammalla tyhjällä rivillä -->
Tämä on kappala. Kirjoittelen kappaleeseen, eikö tämä olekin hauskaa?
Nyt olen kappaleessa 2.
Olen edelleen toisessa kappaleessa!
Olen kolmannessa kappaleessa!
<!-- Jos haluat lisätä <br /> HTML-elementin, päätä kappale kahdella tai
useammalla välilyönnillä ja aloita sitten uusi kappale -->
Päätän tämän kahteen välilyöntiin (maalaa minut nähdäksesi ne).
There's a <br /> above me!
<!-- Lainaukset ovat helppoja ja ne tehdään >-merkillä -->
> Tämä on lainaus. Voit joko
> manuaalisesti rivittää tekstisi ja laittaa >-merkin jokaisen rivin eteen tai antaa jäsentimen rivittää pitkät tekstirivit.
> Sillä ei ole merkitystä kunhan rivit alkavat >-merkillä.
> Voit myös käyttää useampaa
>> sisennystasoa
> Kuinka hienoa se on?
<!-- Listat -->
<!-- Järjestämättömät listat tehdään asteriskilla, plussalla tai viivalla -->
* Kohta
* Kohta
* Kolmas kohta
tai
+ Kohta
+ Kohta
+ Kolmas kohta
tai
- Kohta
- Kohta
- Kolmas kohta
<!-- Järjestetyt listat tehdään järjestysluvuilla. -->
1. Kohta yksi
2. Kohta kaksi
3. Kohta kolme
<!-- Sinun ei tarvitse edes merkitä kohtia oikein ja silti markdown näyttää
oikean järjestyksen, mutta se ei välttämättä ole hyvä idea. -->
1. Kohta yksi
1. Kohta kaksi
1. Kohta kolme
<!-- (Tämä korjaantuu samanlaiseksi kuin yllä oleva esimerkki) -->
<!-- Voit myös käyttää alalistoja. -->
1. Kohta yksi
2. Kohta kaksi
3. Kohta kolme
* Alakohta
* Alakohta
4. Kohta neljä
<!-- Myös tehtävälistoja on olemassa. Tämä tekee HTML-valintaruutuja. -->
Alla olevat ruudut ilman x-merkkiä ovat merkitsemättömiä HTML-valintaruutuja.
- [ ] Ensimmäinen suoritettava tehtävä.
- [ ] Toinen tehtävä joka täytyy tehdä
Tämä alla oleva ruutu on merkitty HTML-valintaruutu.
- [x] Tämä tehtävä on suoritettu
<!-- Koodiosiot -->
<!-- Voit merkitä koodiosion (jaka käyttää <code> -elementtiä) sisentämällä
rivin neljällä välilyönnillä tai tabulaattorilla. -->
Tämä on koodia
Kuten tämäkin
<!-- Voit myös sisentää koodia samalla tavalla. -->
my_array.each do |item|
puts item
end
<!-- Muun tekstin seassa oleva koodi merkitään kahden `-merkin väliin -->
John ei tiennyt edes mitä `go_to()` -funktio teki!
<!-- Githubin Markdownissa voit käyttää erityissyntaksia koodille. -->
\`\`\`ruby <!-- paitsi että poista nuo kenoviivat, vain ```ruby ! -->
def foobar
puts "Hello world!"
end
\`\`\` <!-- tästä myös, ei kenoviivoja, vain ``` -->
<!-- Yllä oleva teksti ei vaadi sisennystä. Lisäksi Github käyttää ``` jälkeen
mainitsemasi kielen syntaksin korostusta -->
<!-- Vaakaviiva (<hr />) -->
<!-- Vaakaviivojen lisääminen käy näppärästi kolmella tai useammalla
asteriskilla taikka viivalla, välilyönneillä tai ilman -->
***
---
- - -
****************
<!-- Linkit -->
<!-- yksi markdownin parhaita ominaisuuksia on yksinkertaiset hyperlinkit. Laita
näytettävä teksti hakasulkuihin [] ja URL-osoite perään sulkeissa (). -->
[Klikkaa tästä!](http://example.com/)
<!-- Voit myös lisätä linkin otsikon heittomerkeissä osoitteen perään. -->
[Klikkaa tästä!](http://example.com/ "Linkki Example.com:iin")
<!-- Suhteelliset polut toimivat myös. -->
[Musiikkia](/musiikki/).
<!-- Markdown tukee myös viittaustyylisiä linkkejä. -->
[Klikkaa tätä linkkiä][link1] saadaksesi lisätietoja!
[Katso myös tämä linkki][foobar] jos haluat.
[link1]: http://example.com/ "Siistii!"
[foobar]: http://foobar.biz/ "Selkis!"
<!-- Otsikko voi olla myös ykittäisissä heittomerkeissä tai sulkeissa, tai
ohitettu kokonaan. Viittaukset voivat olla missä tahansa kohdassa dokumenttia ja
viittausten ID:t voivat olla mitä tahansa kunhan ne ovat uniikkeja. -->
<!-- Voit myös käyttää linkin tekstiä ID:nä näin: -->
[This][] is a link.
[this]: http://tämäonlinkki.com/
<!-- Mutta tämä tapa ei ole yleinen. -->
<!-- Kuvat -->
<!-- Kuvat tehdään samalla tavalla kuin linkitkin, mutta huutomerkki edessä! -->
![Kuvan alt-attribuutti](http://imgur.com/munkuva.jpg "Vaihtoehtoinen otsikko")
<!-- Ja viittaukset toimivat odotetusti. -->
![Tämä on se alt-attribuutti][munkuva]
[munkuva]: suhteellinen/polku/siitii/kuva.jpg "otsikko tähän tarvittaessa"
<!-- Sekalaista -->
<!-- Automaattiset linkit -->
<http://testwebsite.com/> on sama kuin
[http://testwebsite.com/](http://testwebsite.com/)
<!-- Automaattiset sähköpostilinkit -->
<foo@bar.com>
<!-- Varattujen merkkien käyttö -->
haluan kirjoittaa *tämän tekstin jonka ympärillä on asteriskit* mutta en halua
sen kursivoituvan, joten teen näin: \*tämän tekstin ympärillä on asteriskit\*.
<!-- Näppäimistön näppäimet -->
<!-- Githubin Markdownissa, voit käyttää <kbd> -tagia esittämään näppäimiä -->
Tietokoneesi kaatui? Kokeile painaa
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
<!-- Taulukot -->
<!-- Taulukot ovat saatavilla vain Githubin markdownissa ja ne ovat melko
vaivalloisia käyttää, mutta jos todella haluat: -->
| Kolumni1 | Kolumni2 | Kolumni3 |
| :----------- | :------: | ------------: |
| Vasemmalle | Keskelle | Oikealle |
| blaa | blaa | blaa |
<!-- vaihtoehtoisesti, sama tulos -->
Kolumni 1 | Kolumni 2 | Kolumni 3
:-- | :-: | --:
Hyi tämä on ruma | saa se | loppumaan
<!-- Loppu! -->
```
Lisää tietoa löydät John Gruberin [virallisesta julkaisusta](http://daringfireball.net/projects/markdown/syntax)
ja Adam Pritchardin loistavasta [lunttilapusta](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).

115
fr-fr/HTML-fr.html.markdown Normal file
View File

@ -0,0 +1,115 @@
---
language: html
filename: learnhtml-fr.html
contributors:
- ["Christophe THOMAS", "https://github.com/WinChris"]
lang: fr-fr
---
HTML signifie HyperText Markup Language.
C'est un langage (format de fichiers) qui permet d'écrire des pages internet.
C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais).
Les fichiers HTML sont en réalité de simple fichier texte.
Qu'est-ce que le balisage ? C'est une façon de hiérarchiser ses données en les entourant par une balise ouvrante et une balise fermante.
Ce balisage sert à donner une signification au texte ainsi entouré.
Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parlons de HTML5.
**NOTE :** Vous pouvez tester les différentes balises que nous allons voir au fur et à mesure du tutoriel sur des sites comme [codepen](http://codepen.io/pen/) afin de voir les résultats, comprendre, et vous familiariser avec le langage.
Cet article porte principalement sur la syntaxe et quelques astuces.
```HTML
<!-- Les commentaires sont entouré comme cette ligne! -->
<!-- #################### Les balises #################### -->
<!-- Voici un exemple de fichier HTML que nous allons analyser -->
<!-- Venez voir ce que ça donne -->
<!doctype html>
<html>
<head>
<title>Mon Site</title>
</head>
<body>
<h1>Hello, world!</h1>
<a href = "http://codepen.io/anon/pen/xwjLbZ">Venez voir ce que ça donne</a>
<p>Ceci est un paragraphe</p>
<p>Ceci est un autre paragraphe</p>
<ul>
<li>Ceci est un item d'une liste non ordonnée (liste à puces)</li>
<li>Ceci est un autre item</li>
<li>Et ceci est le dernier item de la liste</li>
</ul>
</body>
</html>
<!-- Un fichier HTML débute toujours par indiquer au navigateur que notre page est faite en HTML -->
<!doctype html>
<!-- Après ça on commence par ouvrir une balise <html> -->
<html>
</html>
<!-- Et puis on la referme à la fin du fichier avec </html> -->
<!-- après cette balise de fin, plus rien ne doit apparaître. -->
<!-- À l'intérieur (entre la balise ouvrant et fermante <html></html>), on trouve : -->
<!-- Un entête (<head> en anglais ; il faut le refermer avec </head>) -->
<!-- L'entête contient des descriptions et informations annexes qui ne sont pas affichées : se sont les métadonnées -->
<head>
<title>Mon Site</title><!-- La balise <title> permet d'indiquer au navigateur le titre à afficher dans la barre de l'onglet de la fenêtre -->
</head>
<!-- Après la balise <head>, on trouve la balise <body> -->
<!-- Pour le moment, rien n'est encore affiché dans la fenêtre du navigateur. -->
<!-- Il faut ensuite remplir le corps (balise <body>) avec du contenu -->
<body>
<h1>Hello, world!</h1> <!-- La balise h1 permet de structurer le texte, c'est un titre -->
<!-- Il exite différents sous-titres à <h1> qui sont hiérarchisés du plus important (h2) au plus précis (h6) -->
<a href = "http://codepen.io/anon/pen/xwjLbZ">Venez voir ce que ça donne</a> <!-- Lien vers la source cible indiqué dans href="" -->
<p>Ceci est un paragraphe </p> <!-- La balise <p> permet d'inclure du texte à la page html -->
<p>Ceci est un autre paragraphe</p>
<ul> <!-- La balise <ul> permet d'introduire une liste à puces -->
<!-- Si on souhaite une liste ordonnée : <ol> liste numérotée, 1. pour le premier élément, 2. pour le second, etc -->
<li>Ceci est un item d'une liste non ordonnée (liste à puces)</li>
<li>Ceci est un autre item</li>
<li>Et ceci est le dernier item de la liste</li>
</ul>
</body>
<!-- Voilà comment créer un fichier HTML simple -->
<!-- Mais il est possible d'ajouter encore des balises plus spécifiques -->
<!-- Pour insérer une image -->
<img src="http://i.imgur.com/XWG0O.gif"/> <!-- On indique la source de l'image dans src="" -->
<!-- La source peut-être un URL ou encore la destination d'un fichier de votre ordinateur -->
<!-- Il est possible de réaliser des tableaux également -->
<table> <!-- On ouvre la balise <table> -->
<tr> <!-- <tr> permet de créer une ligne -->
<th>First Header</th> <!-- <th> permet de créer un titre au tableau -->
<th>Second Header</th>
</tr>
<tr>
<td>Première ligne, première cellule</td> <!-- <td> permet de créer une cellule -->
<td>Première ligne, deuxième cellule</td>
</tr>
<tr>
<td>Deuxième ligne, première cellule</td>
<td>Deuxième ligne, deuxième cellule</td>
</tr>
</table>
## Utilisation
Le HTML s'écrit dans des fichiers `.html`.
## En savoir plus
* [Tutoriel HTML](http://slaout.linux62.org/html_css/html.html)
* [W3School](http://www.w3schools.com/html/html_intro.asp)

8
fr-fr/css-fr.html.markdown
View File

@ -8,7 +8,7 @@ translators:
lang: fr-fr lang: fr-fr
--- ---
Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le dévelopement des navigateurs, Au début du web, il n'y avait pas d'élements visuels, simplement du texte pur. Mais avec le dévelopement des navigateurs,
des pages avec du contenu visuel sont arrivées. des pages avec du contenu visuel sont arrivées.
CSS est le langage standard qui existe et permet de garder une séparation entre CSS est le langage standard qui existe et permet de garder une séparation entre
le contenu (HTML) et le style d'une page web. le contenu (HTML) et le style d'une page web.
@ -16,8 +16,8 @@ le contenu (HTML) et le style d'une page web.
En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents
sur une page HTML afin de leur donner des propriétés visuelles différentes. sur une page HTML afin de leur donner des propriétés visuelles différentes.
Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parlons de CSS2.0 Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parler de CSS2.0
qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateur. qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateurs.
**NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage. **NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage.
Cet article porte principalement sur la syntaxe et quelques astuces. Cet article porte principalement sur la syntaxe et quelques astuces.
@ -33,7 +33,7 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
/* Généralement, la première déclaration en CSS est très simple */ /* Généralement, la première déclaration en CSS est très simple */
selecteur { propriete: valeur; /* autres proprietés...*/ } selecteur { propriete: valeur; /* autres proprietés...*/ }
/* Le sélécteur sert à cibler un élément du HTML /* Le sélecteur sert à cibler un élément du HTML
Vous pouvez cibler tous les éléments d'une page! */ Vous pouvez cibler tous les éléments d'une page! */
* { color:red; } * { color:red; }

264
fr-fr/d.html.markdown Normal file
View File

@ -0,0 +1,264 @@
---
language: D
filename: learnd-fr.d
contributors:
- ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
translators:
- ["Quentin Ladeveze", "aceawan.eu"]
lang: fr-fr
---
```d
// Commençons par un classique
module hello;
import std.stdio;
// args n'est pas obligatoire
void main(string[] args) {
writeln("Bonjour le monde !");
}
```
Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a
de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/).
D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient
des fonctionnalités aussi bien de bas niveau que de haut niveau.
D est activement développé par de nombreuses personnes très intelligents, guidées par
[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
```d
import std.stdio;
void main() {
//Les conditions et les boucles sont classiques.
for(int i = 0; i < 10000; i++) {
writeln(i);
}
// On peut utiliser auto pour inférer automatiquement le
// type d'une variable.
auto n = 1;
// On peut faciliter la lecture des valeurs numériques
// en y insérant des `_`.
while(n < 10_000) {
n += n;
}
do {
n -= (n / 2);
} while(n > 0);
// For et while sont très utiles, mais en D, on préfère foreach.
// Les deux points : '..', créent un intervalle continue de valeurs
// incluant la première mais excluant la dernière.
foreach(i; 1..1_000_000) {
if(n % 2 == 0)
writeln(i);
}
// On peut également utiliser foreach_reverse pour itérer à l'envers.
foreach_reverse(i; 1..int.max) {
if(n % 2 == 1) {
writeln(i);
} else {
writeln("Non !");
}
}
}
```
On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
```d
// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
struct LinkedList(T) {
T data = null;
// Utilisez '!' pour instancier un type paramétré.
// Encore une fois semblable à '<T>'
LinkedList!(T)* next;
}
class BinTree(T) {
T data = null;
// Si il n'y a qu'un seul paramètre de template,
// on peut s'abstenir de mettre des parenthèses.
BinTree!T left;
BinTree!T right;
}
enum Day {
Sunday,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
}
// Utilisez alias pour créer des abreviations pour les types.
alias IntList = LinkedList!int;
alias NumTree = BinTree!double;
// On peut tout aussi bien créer des templates de function !
T max(T)(T a, T b) {
if(a < b)
return b;
return a;
}
// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé
// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur.
// Ici ils seront toujours passés par référence à 'swap()'.
void swap(T)(ref T a, ref T b) {
auto temp = a;
a = b;
b = temp;
}
// Avec les templates, on peut également passer des valeurs en paramètres.
class Matrix(uint m, uint n, T = int) {
T[m] rows;
T[n] columns;
}
auto mat = new Matrix!(3, 3); // T est 'int' par défaut
```
À propos de classes, parlons des propriétés. Une propriété est, en gros,
une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
la syntaxe des structures classiques (`struct.x = 7`) comme si il
s'agissait de méthodes getter ou setter.
```d
// Considérons une classe paramétrée avec les types 'T' et 'U'
class MyClass(T, U) {
T _data;
U _other;
}
// Et des méthodes "getter" et "setter" comme suit:
class MyClass(T, U) {
T _data;
U _other;
// Les constructeurs s'apellent toujours 'this'.
this(T t, U u) {
// Ceci va appeller les setters ci-dessous.
data = t;
other = u;
}
// getters
@property T data() {
return _data;
}
@property U other() {
return _other;
}
// setters
@property void data(T t) {
_data = t;
}
@property void other(U u) {
_other = u;
}
}
// Et on l'utilise de cette façon:
void main() {
auto mc = new MyClass!(int, string)(7, "seven");
// Importer le module 'stdio' de la bibliothèque standard permet
// d'écrire dans la console (les imports peuvent être locaux à une portée)
import std.stdio;
// On appelle les getters pour obtenir les valeurs.
writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
// On appelle les setter pour assigner de nouvelles valeurs.
mc.data = 8;
mc.other = "eight";
// On appelle les setter pour obtenir les nouvelles valeurs.
writefln("Later: data = %d, str = %s", mc.data, mc.other);
}
```
Avec les propriétés, on peut constuire nos setters et nos getters
comme on le souhaite, tout en gardant un syntaxe très propre,
comme si on accédait directement à des membres de la classe.
Les autres fonctionnalités orientées objets à notre disposition
incluent les interfaces, les classes abstraites, et la surcharge
de méthodes. D gère l'héritage comme Java: On ne peut hériter que
d'une seule classe et implémenter autant d'interface que voulu.
Nous venons d'explorer les fonctionnalités objet du D, mais changeons
un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
de premier ordre, les fonctions `pure` et les données immuables.
De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
sont disponibles dans le module `std.algorithm`.
```d
import std.algorithm : map, filter, reduce;
import std.range : iota; // construit un intervalle excluant la dernière valeur.
void main() {
// On veut un algorithm qui affiche la somme de la listes des carrés
// des entiers paires de 1 à 100. Un jeu d'enfant !
// On se content de passer des expressions lambda en paramètre à des templates.
// On peut fournier au template n'importe quelle fonction, mais dans notre
// cas, les lambdas sont pratiques.
auto num = iota(1, 101).filter!(x => x % 2 == 0)
.map!(y => y ^^ 2)
.reduce!((a, b) => a + b);
writeln(num);
}
```
Vous voyez comme on a calculé `num` comme on le ferait en haskell par exemple ?
C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax".
Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière
classique, ou comme un appelle à une méthode. Walter Brighter a écrit un
article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
Pour faire court, on peut appeller une fonction dont le premier paramètre
est de type A, comme si c'était une méthode de A.
J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
Voyons comment on le fait en D !
```d
import std.stdio;
import std.parallelism : parallel;
import std.math : sqrt;
void main() {
// On veut calculer la racine carré de tous les nombres
// dans notre tableau, et profiter de tous les coeurs
// à notre disposition.
auto arr = new double[1_000_000];
// On utilise un index et une référence à chaque élément du tableau.
// On appelle juste la fonction parallel sur notre tableau !
foreach(i, ref elem; parallel(arr)) {
ref = sqrt(i + 1.0);
}
}
```

180
fr-fr/hy-fr.html.markdown Normal file
View File

@ -0,0 +1,180 @@
---
language: hy
filename: learnhy-fr.hy
contributors:
- ["Abhishek L", "http://twitter.com/abhishekl"]
translators:
- ["Hughes Perreault", "https://github.com/hperreault"]
lang: fr-fr
---
Hy est un dialecte du lisp bâti par dessus python. Il fonctionne en
convertissant le code hy en un arbre de syntaxe abstraite de python (ast).
Ceci permet à hy d'appeler du code python et à python d'appeler du code hy.
Ce tutoriel fonctionne pour hy > 0.9.12
```clojure
;; Ceci est une introduction simple à hy, pour un tutoriel rapide aller à
;; http://try-hy.appspot.com
;;
; Les commentaires se font avec des points-virgules, comme les autres LISPS
;; les s-expression de bases
; Les programmes Lisp sont fait d'expressions symboliques ou sexps qui
; ressemblent à
(some-function args)
; maintenant le quintessentiel hello world
(print "hello world")
;; les types de données simples
; Tous les types de données simples sont exactement similaires à leurs
; homologues de python
42 ; => 42
3.14 ; => 3.14
True ; => True
4+10j ; => (4+10j) un nombre complexe
; Commençons par un peu d'arithmétique très simple
(+ 4 1) ;=> 5
; l'opérateur est appliqué à tous les arguments, comme les autres lisps
(+ 4 1 2 3) ;=> 10
(- 2 1) ;=> 1
(* 4 2) ;=> 8
(/ 4 1) ;=> 4
(% 4 2) ;=> 0 l'opérateur modulo
; l'opérateur d'élévation à la puissance est représenté par ** comme en python
(** 3 2) ;=> 9
; les expressions imbriquées vont se comporter comme on s'y attend
(+ 2 (* 4 2)) ;=> 10
; aussi, les opérateurs logiques and or not et equal to etc. vont se comporter
; comme on s'y attend
(= 5 4) ;=> False
(not (= 5 4)) ;=> True
;; variables
; les variables sont déclarées en utilisant setv, les noms de variables
; peuvent utiliser l'UTF-8 à l'exception de ()[]{}",'`;#|
(setv a 42)
(setv π 3.14159)
(def *foo* 42)
;; d'autres types de conteneurs
; les chaînes, les listes, les tuples et dicts
; ce sont exactement les mêmes que les types de conteneurs de python
"hello world" ;=> "hello world"
; les opérations sur les chaînes fonctionnent comme en python
(+ "hello " "world") ;=> "hello world"
; les listes sont créés en utilisant [], l'indexation commence à 0
(setv mylist [1 2 3 4])
; les tuples sont des structures de données immuables
(setv mytuple (, 1 2))
; les dictionnaires sont des paires clé-valeur
(setv dict1 {"key1" 42 "key2" 21})
; :nom peut être utilisé pour définir des mots clés dans hy qui peuvent être
; utilisées comme clés
(setv dict2 {:key1 41 :key2 20})
; utilisez `get' pour obtenir l'élément à l'index / clé
(get mylist 1) ;=> 2
(get dict1 "key1") ;=> 42
; Alternativement, si des mots clés ont été utilisés, l'élément peut être
; obtenu directement
(:key1 dict2) ;=> 41
;; fonctions et autres constructions de programme
; les fonctions sont définies en utilisant defn, la dernière sexp est renvoyé par défaut
(defn greet [name]
"A simple greeting" ; une docstring optionnelle
(print "hello " name))
(greet "bilbo") ;=> "hello bilbo"
; les fonctions peuvent prendre des arguments optionnels ainsi que des
; arguments sous forme de mots clés
(defn foolists [arg1 &optional [arg2 2]]
[arg1 arg2])
(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]
; les fonctions anonymes sont créés en utilisant `fn' ou `lambda'
; qui sont semblable à `defn '
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
;; Opérations sur les séquences
; hy a des utilitaires natifs pour les opérations sur les séquences etc.
; récupérez le premier élément en utilisant `first' ou `car'
(setv mylist [1 2 3 4])
(setv mydict {"a" 1 "b" 2})
(first mylist) ;=> 1
; découpez les listes en utilisant slice
(slice mylist 1 3) ;=> [2 3]
; obtenez les éléments d'une liste ou dict en utilisant `get'
(get mylist 1) ;=> 2
(get mydict "b") ;=> 2
; l'indexation des listes commence à 0 comme en python
; assoc peut définir les éléments à clés/index
(assoc mylist 2 10) ; makes mylist [1 2 10 4]
(assoc mydict "c" 3) ; makes mydict {"a" 1 "b" 2 "c" 3}
; il ya tout un tas d'autres fonctions de base qui rend le travail avec
; les séquences amusant
;; les importations fonctionnent comme en pyhtonn
(import datetime)
(import [functools [partial reduce]]) ; importe fun1 et fun2 de module1
(import [matplotlib.pyplot :as plt]) ; faire une importation foo comme bar
; toutes les méthodes natives de python sont accessibles à partir de hy
; a.foo(arg) est appelé (.foo a arg)
(.split (.strip "hello world ")) ;=> ["hello" "world"]
;; Conditionelles
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
(print "welcome")
(print "Speak friend, and Enter!"))
; imbriquez plusieurs if else if avec le mot clé cond
(cond
[(= someval 42)
(print "Life, universe and everything else!")]
[(> someval 42)
(print "val too large")]
[(< someval 42)
(print "val too small")])
; groupez les expressions avec do, ceux-ci seront executé séquentiellemnt
; les expressions comme defn ont un do implicite
(do
(setv someval 10)
(print "someval is set to " someval)) ;=> 10
; créer une liaison lexicale avec `let', toutes les variables déclarées
; comme cela ont une portée locale
(let [[nemesis {"superman" "lex luther"
"sherlock" "moriarty"
"seinfeld" "newman"}]]
(for [(, h v) (.items nemesis)]
(print (.format "{0}'s nemesis was {1}" h v))))
;; classes
; les classes sont définies comme ceci
(defclass Wizard [object]
[[--init-- (fn [self spell]
(setv self.spell spell) ; init the spell attr
None)]
[get-spell (fn [self]
self.spell)]])
;; allez voir hylang.org
```
### Lectures complémentaires
Ce tutoriel est juste une simple introduction à hy/lisp/python.
La documentation de HY: [http://hy.readthedocs.org](http://hy.readthedocs.org)
Le repo GitHub de HY: [http://github.com/hylang/hy](http://github.com/hylang/hy)
Sur freenode irc #hy, twitter hashtag #hylang

202
fr-fr/javascript-fr.html.markdown
View File

@ -6,6 +6,7 @@ contributors:
filename: javascript-fr.js filename: javascript-fr.js
translators: translators:
- ['@nbrugneaux', 'https://nicolasbrugneaux.me'] - ['@nbrugneaux', 'https://nicolasbrugneaux.me']
- ['Michel Antoine', 'https://github.com/antoin-m']
lang: fr-fr lang: fr-fr
--- ---
@ -23,6 +24,8 @@ interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome,
peut être utilisé directement côté serveur pour exécuter des programmes écrits peut être utilisé directement côté serveur pour exécuter des programmes écrits
en JavaScript. en JavaScript.
ECMAScript (la norme du langage Javascript) entre en version 6. Cette version introduit de nombreuses mises à jour tout en restant rétrocompatible. L'implémentation de ces nouvelles fonctionnalités est en cours et celles-ci ne sont donc pas forcément compatibles avec tous les navigateurs.
```js ```js
// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs, // Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs,
/* et les commentaires sur plusieurs lignes commencent avec slash-étoile /* et les commentaires sur plusieurs lignes commencent avec slash-étoile
@ -79,6 +82,12 @@ false; // faux
"abc"; "abc";
'Hello, world'; 'Hello, world';
// *ES6:* Les chaines de caractères peuvent être crées en utilisant un modèle
// entouré des quotes inverses (`) à la place des quotes classiques (' ou ").
// Les variables sont interprétées avec ${var}
let banta = "Harry", santa = "Hermione";
`${banta}, your santa is ${santa}.` // = "Harry, your santa is Hermione."
// La négation utilise le symbole ! // La négation utilise le symbole !
!true; // = false !true; // = false
!false; // = true !false; // = true
@ -124,9 +133,17 @@ undefined; // utilisé pour une valeur actuellement non présente (cependant,
// est 'presque-vrai' (truthy) // est 'presque-vrai' (truthy)
// Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0') // Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0')
// *ES6:* Introduction d'un nouveau type primitif : Symbol
var symbol_one = Symbol();
var symbol_two = Symbol('This is optional description, for debugging');
typeof symbol_one === 'symbol' // = true
// *ES6:* Un Symbol est immutable et unique
Symbol() === Symbol() // = false
Symbol('learnx') === Symbol('learnx') // = false
/////////////////////////////////// ///////////////////////////////////
// 2. Variables, Tableaux et Objets // 2. Variables, Tableaux, Objets, Maps et Sets
// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est // Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est
// dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =. // dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =.
@ -145,6 +162,32 @@ var someThirdVar = undefined;
// ... sont deux déclarations identiques. // ... sont deux déclarations identiques.
// Il est possible de déclarer plusieurs variables en séparant leur déclaration
// avec l'opérateur virgule
var someFourthVar = 2, someFifthVar = 4;
// *ES6:* Les variables peuvent maintenant être déclarées avec les mots-clés
// `let` et `const`
let someSixthVar = 6;
const someSeventhVar = 7;
// *ES6:* Le mot-clé `let` attache la variable au block de code et non à la fonction
// à l'inverse de `var`
for (let i = 0; i < 10; i++) {
x += 10;
}
i; // = raises ReferenceError
// *ES6:* Les variables "const" doivent être assignées lors de l'initialisation
const someEighthVar = 7;
const someNinthVar; // raises SyntaxError
// *ES6:* Modifier une variable constante ne lève par d'erreur mais échoue
// silencieusement
const someNinthVar = 9;
someNinthVar = 10;
someNinthVar; // = 9
// Il y a des raccourcis pour les opérations mathématiques: // Il y a des raccourcis pour les opérations mathématiques:
someVar += 5; // équivalent pour someVar = someVar + 5; someVar += 5; // équivalent pour someVar = someVar + 5;
someVar *= 10; // de même, someVar = someVar * 100; someVar *= 10; // de même, someVar = someVar * 100;
@ -165,6 +208,22 @@ myArray.length; // = 4
// Ajout/Modification à un index spécifique // Ajout/Modification à un index spécifique
myArray[3] = 'Hello'; myArray[3] = 'Hello';
// *ES6:* Les Arrays peuvent maintenant être déstructurés en utilisant le pattern matching
var [a, b] = [1, 2];
var [a, , b] = [1, -2, 2]
a; // = 1
b; // = 2
// *ES6:* La déstructuration peut échouer silencieusement.
// Il est aussi possible d'utiliser des valeurs par défaut
var [a] = [];
a; // = undefined;
var [a = 1] = [];
a; // = 1;
var [a = 1] = [2];
a; // = 2;
// Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres // Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres
// langages : ils sont une liste non-ordonnée de paires clé-valeur. // langages : ils sont une liste non-ordonnée de paires clé-valeur.
var myObj = {key1: 'Hello', key2: 'World'}; var myObj = {key1: 'Hello', key2: 'World'};
@ -179,12 +238,55 @@ myObj['my other key']; // = 4
// .. ou avec un point si la clé est un identifiant valide. // .. ou avec un point si la clé est un identifiant valide.
myObj.myKey; // = 'myValue' myObj.myKey; // = 'myValue'
// *ES6:* Un Symbol peut être utilisé en tant que clé. Puisque ceux-ci sont uniques,
// le seul moyen d'accéder à la propriété est d'avoir une référence sur ce Symbol.
myObj["key"] = "public value";
myObj[Symbol("key")] = "secret value";
myObj[Symbol("key")]; // = undefined
// Les objets sont eux aussi modifiables. // Les objets sont eux aussi modifiables.
myObj.myThirdKey = true; myObj.myThirdKey = true;
// Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined // Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined
myObj.myFourthKey; // = undefined myObj.myFourthKey; // = undefined
// *ES6:* Comme les Arrays, les Objects peuvent être déstructurés en utilisant le pattern matching
var {foo} = {foo: "bar"};
foo // = "bar"
// *ES6:* Les Objects déstructurés peuvent utiliser des noms de variables différents
// de ceux d'origine grâce au pattern matching
var {foo, moo: baz} = {foo: "bar", moo: "car"};
foo // = "bar"
baz // = "car"
// *ES6:* Il est possible d'utiliser des valeurs par défaut lor de la déstructuration d'un Object
var {foo="bar"} = {moo: "car"};
foo // = "bar"
// *ES6:* Une erreur lors de la déstructuration restera silencieuse
var {foo} = {};
foo // = undefined
// *ES6:* Les Maps sont des objets itérables de type clé-valeur.
// Il est possible de créer une nouvelle map en utilisant `new Map()`
var myMap = new Map();
// *ES6:* Il est possible d'ajouter un couple clé-valeur avec la méthode `.set()`,
// de récupérer une valeur avec `.get()`,
// de vérifier qu'une clé existe avec `.has()`
// et enfin de supprimer un couple clé-valeur avec `.delete()`
myMap.set("name", "Douglas");
myMap.get("name"); // = "Douglas"
myMap.has("name"); // = true
myMap.delete("name");
// *ES6:* Les Sets sont des ensembles de valeurs uniques.
// Il est possible de créer un set avec `new Set()`.
// Toute valeur non unique est ignorée.
var mySet = new Set([1,2,2]);
console.log([...mySet]); // = [1,2]
/////////////////////////////////// ///////////////////////////////////
// 3. Logique et structures de contrôle // 3. Logique et structures de contrôle
@ -218,6 +320,22 @@ for (var i = 0; i < 5; i++){
// sera exécutée 5 fois // sera exécutée 5 fois
} }
// La boucle for...in permet d'itérer sur les noms des propriétés d'un objet
var description = "";
var person = {fname:"Paul", lname:"Ken", age:18};
for (var x in person){
description += person[x] + " ";
}
description; // = "Paul Ken 18 "
// *ES6:* La boucle for...of permet d'itérer sur les propriétés d'un objet
var description = "";
var person = {fname:"Paul", lname:"Ken", age:18};
for (var x of person){
description += x + " ";
}
description; // = "Paul Ken 18 "
// && est le "et" logique, || est le "ou" logique // && est le "et" logique, || est le "ou" logique
if (house.size === 'big' && house.colour === 'blue'){ if (house.size === 'big' && house.colour === 'blue'){
house.contains = 'bear'; house.contains = 'bear';
@ -264,6 +382,20 @@ function myFunction(thing){
} }
myFunction('foo'); // = 'FOO' myFunction('foo'); // = 'FOO'
// Attention, la valeur à retourner doit se trouver sur la même ligne que
// le mot-clé `return` sinon la fonction retournera systématiquement `undefined`
function myFunction(){
return // <- semicolon automatically inserted here
{thisIsAn: 'object literal'}
}
myFunction(); // = undefined
// *ES6:* Les paramètres des fonctions peuvent désormais avoir des valeurs par défaut
function default(x, y = 2) {
return x + y;
}
default(10); // == 12
// Les fonctions JavaScript sont des objets de première classe, donc peuvent // Les fonctions JavaScript sont des objets de première classe, donc peuvent
// être réassignées à d'autres variables et passées en tant que paramètres pour // être réassignées à d'autres variables et passées en tant que paramètres pour
// d'autres fonctions // d'autres fonctions
@ -280,6 +412,10 @@ setTimeout(function(){
// ce code s'exécutera dans 5 secondes // ce code s'exécutera dans 5 secondes
}, 5000); }, 5000);
// *ES6:* Introduction d'un sucre syntaxique permettant de créer
// une fonction anonyme de la forme : `param => returnValue`.
setTimeout(() => console.log('5 seconds, are up.'), 5000);
// Le Javascript crée uniquement un scope, une portée d'action limitée, pour // Le Javascript crée uniquement un scope, une portée d'action limitée, pour
// les fonctions, et pas dans les autres blocs. // les fonctions, et pas dans les autres blocs.
if (true){ if (true){
@ -318,6 +454,18 @@ function sayHelloInFiveSeconds(name){
} }
sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
// *ES6:* Les paramètres des fonctions appelées avec un tableau en entré
// préfixé par `...` vont se peupler avec les éléments du tableau
function spread(x, y, z) {
return x + y + z;
}
spread(...[1,2,3]); // == 6
// *ES6:* Les fonctions peuvent recevoir les paramètres dans un tableau en utilisant l'opérateur `...`
function spread(x, y, z) {
return x + y + z;
}
spread(...[1,2,3]); // == 6
/////////////////////////////////// ///////////////////////////////////
// 5. Encore plus à propos des Objets; Constructeurs and Prototypes // 5. Encore plus à propos des Objets; Constructeurs and Prototypes
@ -492,6 +640,58 @@ if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe
return new Constructor(); return new Constructor();
} }
} }
// *ES6:* Les objets peuvent être équipés de proxies qui permettent d'intercepter
// les actions sur leurs propriétés. Voici comment créer un proxy sur un objet :
var proxyObject = new Proxy(object, handler);
// *ES6:* Les méthodes d'un objet handler sont appelées lors de l'interception d'une action.
// La méthode `.get()` est appelée à chaque lecture d'une propriété
// tandis que la méthode `.set()` est appelée à chaque écriture.
var handler = {
get (target, key) {
console.info('Get on property' + key);
return target[key];
},
set (target, key, value) {
console.info('Set on property' + key);
return true;
}
}
// *ES6:* Les classes peuvent désormais être définies en utilisant le mot-clé `class`.
// Le constructeur s'appelle `constructor` et les méthodes statiques utilisent le mot-clé `static`
class Foo {
constructor() {console.log("constructing Foo");}
bar() {return "bar";}
static baz() {return "baz";}
}
// *ES6:* Les objets issus des classes sont initialisés avec le mot-clé `new`.
// Il est possible d'hériter d'une classe avec le mot-clé `extends`
var FooObject = new Foo(); // = "constructing Foo"
class Zoo extends Foo {}
// *ES6:* Les méthodes statiques doivent être appelées par la classe, les autres méthodes par l'objet
Foo.baz() // = "baz"
FooObject.bar() // = "bar"
// *ES6:* Il est désormais possible d'exporter des valeurs en tant que module.
// Les exports peuvent être n'importe quel objet, valeur ou fonction.
var api = {
foo: "bar",
baz: "ponyfoo"
};
export default api;
// *ES6:* La syntaxe `export default` permet d'exporter l'objet sans en changer le nom.
// Il y a plusieurs façons de l'importer:
import coolapi from "api"; // = importe le module dans la variable `coolapi`
import {foo, baz} from "api"; // = importe les attributs `foo` et `baz` du module
import {foo as moo, baz} from "api"; // = importe les attributs `foo` (en le renommant `moo`) et `baz` du module
import _, {map} from "api"; // = importe les exports par défaut ET `map`
import * as coolapi from "api"; // = importe le namespace global du module
``` ```
## Pour aller plus loin (en anglais) ## Pour aller plus loin (en anglais)

2
fr-fr/livescript-fr.html.markdown
View File

@ -4,7 +4,7 @@ filename: learnLivescript-fr.ls
contributors: contributors:
- ["Christina Whyte", "http://github.com/kurisuwhyte/"] - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
translators: translators:
- ["Morgan Bohn", "https://github.com/morganbohn"] - ["Morgan Bohn", "https://github.com/dotmobo"]
lang: fr-fr lang: fr-fr
--- ---

2
fr-fr/markdown.html.markdown
View File

@ -2,7 +2,7 @@
language: markdown language: markdown
contributors: contributors:
- ["Andrei Curelaru", "http://www.infinidad.fr"] - ["Andrei Curelaru", "http://www.infinidad.fr"]
filename: markdown.md filename: markdown-fr.md
lang: fr-fr lang: fr-fr
--- ---

174
fr-fr/perl-fr.html.markdown Normal file
View File

@ -0,0 +1,174 @@
---
name: perl
category: language
language: perl
filename: learnperl-fr.pl
contributors:
- ["Korjavin Ivan", "http://github.com/korjavin"]
- ["Matteo Taroli", "http://www.matteotaroli.be"]
translators:
- ["Matteo Taroli", "http://www.matteotaroli.be"]
lang: fr-fr
---
Perl 5 est un langage de programmation riche en fonctionnalité, avec plus de 25 ans de développement.
Perl 5 fonctionne sur plus de 100 plateformes, allant des pc portables aux mainframes et
est autant adapté à un prototypage rapide qu'à des projets de grande envergure.
```perl
# Les commentaires en une ligne commencent par un dièse
#### Types de variables de Perl
# Les variables comment par un symbole précisant le type.
# Un nom de variable valide commence par une lettre ou un underscore,
# suivi d'un nombre quelconque de lettres, chiffres ou underscores.
### Perl a trois types principaux de variables: $scalaire, @tableau and %hash
## Scalaires
# Un scalaire représente une valeur unique :
my $animal = "chameau";
my $reponse = 42;
# Les valeurs scalaires peuvent être des strings, des entiers ou des nombres à virgule flottante
# et Perl les convertira automatiquement entre elles quand nécessaire.
## Tableaux
# Un tableau représente une liste de valeurs :
my @animaux = ("chameau", "lama", "chouette");
my @nombres = (23, 42, 69);
my @melange = ("chameau", 42, 1.23);
## Hashes
# Un hash représente un ensemble de paires de clé/valeur :
my %fruit_couleur = ("pomme", "rouge", "banane", "jaune");
# Vous pouvez utiliser des espaces et l'opérateur "=>" pour les disposer plus joliment :
my %fruit_couleur = (
pomme => "rouge",
banane => "jaune"
);
# Les scalaires, tableaux et hashes sont plus amplement documentés dans le perldata
# (perldoc perldata)
# Des types de données plus complexes peuvent être construits en utilisant des références,
# vous permettant de construire des listes et des hashes à l'intérieur d'autres listes et hashes.
#### Conditions et boucles
# Perl possède la plupart des conditions et boucles habituelles.
if ($var) {
...
} elsif ($var eq 'bar') {
...
} else {
...
}
unless (condition) {
...
}
# Ceci est fourni en tant que version plus lisible de "if (!condition)"
# la postcondition à la sauce Perl
print "Yow!" if $zippy;
print "Nous n'avons pas de banane." unless $bananes;
# while
while (condition) {
...
}
# boucle for et iteration
for (my $i = 0; $i < $max; $i++) {
print "l'index est $i";
}
for (my $i = 0; $i < @elements; $i++) {
print "L'élément courant est " . $elements[$i];
}
for my $element (@elements) {
print $element;
}
# implicitement
# La variable de contexte scalaire $_ est utilisée par défaut dans différentes
# situations, comme par exemple dans la boucle foreach ou en argument par défaut
# de la plupart des fonctions pour en simplifier l'écriture.
# Dans l'exemple suivant, $_ prends successivement la valeur de
# chaque élément de la liste.
for (@elements) {
print; # affiche le contenu de $_
}
#### Expressions régulières
# Le support des expressions régulières par Perl est aussi large que profond
# et est sujet à une longue documentation sur perlrequick, perlretut et ailleurs.
# Cependant, pour faire court :
# Simple correspondance
if (/foo/) { ... } # vrai si $_ contient "foo"
if ($a =~ /foo/) { ... } # vrai si $a contient "foo"
# Simple substitution
$a =~ s/foo/bar/; # remplace le premier foo par bar dans $a
$a =~ s/foo/bar/g; # remplace TOUTES LES INSTANCES de foo par bar dans $a
#### Fichiers et E/S
# Vous pouvez ouvrir un fichier pour y écrire ou pour le lire avec la fonction "open()".
open(my $in, "<", "input.txt") or die "Impossible d'ouvrir input.txt: $!";
open(my $out, ">", "output.txt") or die "Impossible d'ouvrir output.txt: $!";
open(my $log, ">>", "my.log") or die "Impossible d'ouvrir my.log: $!";
# Vous pouvez lire depuis un descripteur de fichier grâce à l'opérateur "<>".
# Dans un contexte scalaire, il lit une seule ligne depuis le descripteur de fichier
# et dans un contexte de liste, il lit le fichier complet, assignant chaque ligne à un
# élément de la liste :
my $ligne = <$in>
my $lignes = <$in>
#### Ecrire des fonctions
# Ecrire des fonctions est facile :
sub logger {
my $logmessage = shift;
open my $logfile, ">>", "my.log" or die "Impossible d'ouvrir my.log: $!";
print $logfile $logmessage;
}
# Maintenant, nous pouvons utiliser cette fonction comme n'importe quelle fonction intégrée :
logger("On a une fonction de logging!!");
```
#### Utiliser des modules Perl
Les modules Perl fournissent une palette de fonctionnalités vous évitant de réinventer la roue et peuvent être téléchargés depuis CPAN (http://www.cpan.org/). Un certain nombre de modules populaires sont inclus dans la distribution même de Perl.
Perlfaq contiens des questions et réponses liées aux tâches habituelles et propose souvent des suggestions quant aux bons modules à utiliser.
#### Pour en savoir plus
- [perl-tutorial](http://perl-tutorial.org/)
- [Learn at www.perl.com](http://www.perl.org/learn.html)
- [perldoc](http://perldoc.perl.org/)
- and perl built-in : `perldoc perlintro`

2
fr-fr/python3-fr.html.markdown
View File

@ -627,7 +627,7 @@ Human.grunt() # => "*grunt*"
# On peut importer des modules # On peut importer des modules
import math import math
print(math.sqrt(16)) # => 4 print(math.sqrt(16)) # => 4.0
# On peut importer des fonctions spécifiques d'un module # On peut importer des fonctions spécifiques d'un module
from math import ceil, floor from math import ceil, floor

8
fsharp.html.markdown
View File

@ -284,7 +284,7 @@ module DataTypeExamples =
let threeTuple = "a", 2, true let threeTuple = "a", 2, true
// Pattern match to unpack // Pattern match to unpack
let x,y = twoTuple //sets x=1 y=2 let x, y = twoTuple // sets x = 1, y = 2
// ------------------------------------ // ------------------------------------
// Record types have named fields // Record types have named fields
@ -335,10 +335,10 @@ module DataTypeExamples =
let worker = Worker jdoe let worker = Worker jdoe
// ------------------------------------ // ------------------------------------
// Modelling with types // Modeling with types
// ------------------------------------ // ------------------------------------
// Union types are great for modelling state without using flags // Union types are great for modeling state without using flags
type EmailAddress = type EmailAddress =
| ValidEmailAddress of string | ValidEmailAddress of string
| InvalidEmailAddress of string | InvalidEmailAddress of string
@ -526,7 +526,7 @@ module AsyncExample =
|> Async.RunSynchronously // start them off |> Async.RunSynchronously // start them off
// ================================================ // ================================================
// .NET compatability // .NET compatibility
// ================================================ // ================================================
module NetCompatibilityExamples = module NetCompatibilityExamples =

14
git.html.markdown
View File

@ -6,6 +6,7 @@ contributors:
- ["Leo Rudberg" , "http://github.com/LOZORD"] - ["Leo Rudberg" , "http://github.com/LOZORD"]
- ["Betsy Lorton" , "http://github.com/schbetsy"] - ["Betsy Lorton" , "http://github.com/schbetsy"]
- ["Bruno Volcov", "http://github.com/volcov"] - ["Bruno Volcov", "http://github.com/volcov"]
- ["Andrew Taylor", "http://github.com/andrewjt71"]
filename: LearnGit.txt filename: LearnGit.txt
--- ---
@ -333,6 +334,9 @@ $ git log --oneline
# Show merge commits only # Show merge commits only
$ git log --merges $ git log --merges
# Show all commits represented by an ASCII graph
$ git log --graph
``` ```
### merge ### merge
@ -499,6 +503,16 @@ $ git reset 31f2bb1
# after the specified commit). # after the specified commit).
$ git reset --hard 31f2bb1 $ git reset --hard 31f2bb1
``` ```
### revert
Revert can be used to undo a commit. It should not be confused with reset which restores
the state of a project to a previous point. Revert will add a new commit which is the
inverse of the specified commit, thus reverting it.
```bash
# Revert a specified commit
$ git revert <commit>
```
### rm ### rm

4
haskell.html.markdown
View File

@ -81,7 +81,7 @@ not False -- True
[5,4..1] -- [5, 4, 3, 2, 1] [5,4..1] -- [5, 4, 3, 2, 1]
-- indexing into a list -- indexing into a list
[0..] !! 5 -- 5 [1..10] !! 3 -- 4
-- You can also have infinite lists in Haskell! -- You can also have infinite lists in Haskell!
[1..] -- a list of all the natural numbers [1..] -- a list of all the natural numbers
@ -426,7 +426,7 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
greater = filter (>= p) xs greater = filter (>= p) xs
``` ```
Haskell is easy to install. Get it [here](http://www.haskell.org/platform/). There are two popular ways to install Haskell: The traditional [Cabal-based installation](http://www.haskell.org/platform/), and the newer [Stack-based process](https://www.stackage.org/install).
You can find a much gentler introduction from the excellent You can find a much gentler introduction from the excellent
[Learn you a Haskell](http://learnyouahaskell.com/) or [Learn you a Haskell](http://learnyouahaskell.com/) or

107
hu-hu/coffeescript-hu.html.markdown Normal file
View File

@ -0,0 +1,107 @@
---
language: coffeescript
contributors:
- ["Tenor Biel", "http://github.com/L8D"]
- ["Xavier Yao", "http://github.com/xavieryao"]
translators:
- ["Tamás Diószegi", "http://github.com/ditam"]
lang: hu-hu
filename: coffeescript-hu.coffee
---
A CoffeeScript egy apró nyelv ami egy-az-egyben egyenértékű Javascript kódra fordul, és így futásidőben már nem szükséges interpretálni.
Mint a JavaScript egyik követője, a CoffeeScript mindent megtesz azért, hogy olvasható, jól formázott és jól futó JavaScript kódot állítson elő, ami minden JavaScript futtatókörnyezetben jól működik.
Rézletekért lásd még a [CoffeeScript weboldalát](http://coffeescript.org/), ahol egy teljes CoffeScript tutorial is található.
```coffeescript
# A CoffeeScript egy hipszter nyelv.
# Követi több modern nyelv trendjeit.
# Így a kommentek, mint Ruby-ban és Python-ban, a szám szimbólummal kezdődnek.
###
A komment blokkok ilyenek, és közvetlenül '/ *' és '* /' jelekre fordítódnak
az eredményül kapott JavaScript kódban.
Mielőtt tovább olvasol, jobb, ha a JavaScript alapvető szemantikájával
tisztában vagy.
(A kód példák alatt kommentként látható a fordítás után kapott JavaScript kód.)
###
# Értékadás:
number = 42 #=> var number = 42;
opposite = true #=> var opposite = true;
# Feltételes utasítások:
number = -42 if opposite #=> if(opposite) { number = -42; }
# Függvények:
square = (x) -> x * x #=> var square = function(x) { return x * x; }
fill = (container, liquid = "coffee") ->
"Filling the #{container} with #{liquid}..."
#=>var fill;
#
#fill = function(container, liquid) {
# if (liquid == null) {
# liquid = "coffee";
# }
# return "Filling the " + container + " with " + liquid + "...";
#};
# Szám tartományok:
list = [1..5] #=> var list = [1, 2, 3, 4, 5];
# Objektumok:
math =
root: Math.sqrt
square: square
cube: (x) -> x * square x
#=> var math = {
# "root": Math.sqrt,
# "square": square,
# "cube": function(x) { return x * square(x); }
# };
# "Splat" jellegű függvény-paraméterek:
race = (winner, runners...) ->
print winner, runners
#=>race = function() {
# var runners, winner;
# winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
# return print(winner, runners);
# };
# Létezés-vizsgálat:
alert "I knew it!" if elvis?
#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
# Tömb értelmezések: (array comprehensions)
cubes = (math.cube num for num in list)
#=>cubes = (function() {
# var _i, _len, _results;
# _results = [];
# for (_i = 0, _len = list.length; _i < _len; _i++) {
# num = list[_i];
# _results.push(math.cube(num));
# }
# return _results;
# })();
foods = ['broccoli', 'spinach', 'chocolate']
eat food for food in foods when food isnt 'chocolate'
#=>foods = ['broccoli', 'spinach', 'chocolate'];
#
#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) {
# food = foods[_k];
# if (food !== 'chocolate') {
# eat(food);
# }
#}
```
## További források
- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)

647
it-it/python-it.html.markdown Normal file
View File

@ -0,0 +1,647 @@
---
language: python
contributors:
- ["Louie Dinh", "http://ldinh.ca"]
- ["Amin Bandali", "http://aminbandali.com"]
- ["Andre Polykanine", "https://github.com/Oire"]
filename: learnpython.py
translators:
- ["Ale46", "http://github.com/Ale46/"]
lang: it-it
---
Python è stato creato da Guido Van Rossum agli inizi degli anni 90. Oggi è uno dei più popolari
linguaggi esistenti. Mi sono innamorato di Python per la sua chiarezza sintattica. E' sostanzialmente
pseudocodice eseguibile.
Feedback sono altamente apprezzati! Potete contattarmi su [@louiedinh](http://twitter.com/louiedinh) oppure [at] [google's email service]
Nota: Questo articolo è valido solamente per Python 2.7, ma dovrebbe andar bene anche per
Python 2.x. Per Python 3.x, dai un'occhiata a [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
```python
# I commenti su una sola linea iniziano con un cancelletto
""" Più stringhe possono essere scritte
usando tre ", e sono spesso usate
come commenti
"""
####################################################
## 1. Tipi di dati primitivi ed Operatori
####################################################
# Hai i numeri
3 # => 3
# La matematica è quello che vi aspettereste
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7
# La divisione è un po' complicata. E' una divisione fra interi in cui viene
# restituito in automatico il risultato intero.
5 / 2 # => 2
# Per le divisioni con la virgola abbiamo bisogno di parlare delle variabili floats.
2.0 # Questo è un float
11.0 / 4.0 # => 2.75 ahhh...molto meglio
# Il risultato di una divisione fra interi troncati positivi e negativi
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # funziona anche per i floats
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0
# Operazione Modulo
7 % 3 # => 1
# Elevamento a potenza (x alla y-esima potenza)
2**4 # => 16
# Forzare le precedenze con le parentesi
(1 + 3) * 2 # => 8
# Operatori Booleani
# Nota "and" e "or" sono case-sensitive
True and False #=> False
False or True #=> True
# Note sull'uso di operatori Bool con interi
0 and 2 #=> 0
-5 or 0 #=> -5
0 == False #=> True
2 == True #=> False
1 == True #=> True
# nega con not
not True # => False
not False # => True
# Uguaglianza è ==
1 == 1 # => True
2 == 1 # => False
# Disuguaglianza è !=
1 != 1 # => False
2 != 1 # => True
# Altri confronti
1 < 10 # => True
1 > 10 # => False
2 <= 2 # => True
2 >= 2 # => True
# I confronti possono essere concatenati!
1 < 2 < 3 # => True
2 < 3 < 2 # => False
# Le stringhe sono create con " o '
"Questa è una stringa."
'Anche questa è una stringa.'
# Anche le stringhe possono essere sommate!
"Ciao " + "mondo!" # => Ciao mondo!"
# Le stringhe possono essere sommate anche senza '+'
"Ciao " "mondo!" # => Ciao mondo!"
# ... oppure moltiplicate
"Hello" * 3 # => "HelloHelloHello"
# Una stringa può essere considerata come una lista di caratteri
"Questa è una stringa"[0] # => 'Q'
# % può essere usato per formattare le stringhe, in questo modo:
"%s possono essere %s" % ("le stringhe", "interpolate")
# Un nuovo modo per fomattare le stringhe è il metodo format.
# Questo metodo è quello consigliato
"{0} possono essere {1}".format("le stringhe", "formattate")
# Puoi usare delle parole chiave se non vuoi contare
"{nome} vuole mangiare {cibo}".format(nome="Bob", cibo="lasagna")
# None è un oggetto
None # => None
# Non usare il simbolo di uguaglianza "==" per comparare oggetti a None
# Usa "is" invece
"etc" is None # => False
None is None # => True
# L'operatore 'is' testa l'identità di un oggetto. Questo non è
# molto utile quando non hai a che fare con valori primitivi, ma lo è
# quando hai a che fare con oggetti.
# None, 0, e stringhe/liste vuote sono tutte considerate a False.
# Tutti gli altri valori sono True
bool(0) # => False
bool("") # => False
####################################################
## 2. Variabili e Collections
####################################################
# Python ha una funzione di stampa
print "Sono Python. Piacere di conoscerti!"
# Non c'è bisogno di dichiarare una variabile per assegnarle un valore
una_variabile = 5 # Convenzionalmente si usa caratteri_minuscoli_con_underscores
una_variabile # => 5
# Accedendo ad una variabile non precedentemente assegnata genera un'eccezione.
# Dai un'occhiata al Control Flow per imparare di più su come gestire le eccezioni.
un_altra_variabile # Genera un errore di nome
# if può essere usato come un'espressione
"yahoo!" if 3 > 2 else 2 # => "yahoo!"
# Liste immagazzinano sequenze
li = []
# Puoi partire con una lista pre-riempita
altra_li = [4, 5, 6]
# Aggiungi cose alla fine di una lista con append
li.append(1) # li ora è [1]
li.append(2) # li ora è [1, 2]
li.append(4) # li ora è [1, 2, 4]
li.append(3) # li ora è [1, 2, 4, 3]
# Rimuovi dalla fine della lista con pop
li.pop() # => 3 e li ora è [1, 2, 4]
# Rimettiamolo a posto
li.append(3) # li ora è [1, 2, 4, 3] di nuovo.
# Accedi ad una lista come faresti con un array
li[0] # => 1
# Assegna nuovo valore agli indici che sono già stati inizializzati con =
li[0] = 42
li[0] # => 42
li[0] = 1 # Nota: è resettato al valore iniziale
# Guarda l'ultimo elemento
li[-1] # => 3
# Guardare al di fuori dei limiti è un IndexError
li[4] # Genera IndexError
# Puoi guardare gli intervalli con la sintassi slice (a fetta).
# (E' un intervallo chiuso/aperto per voi tipi matematici.)
li[1:3] # => [2, 4]
# Ometti l'inizio
li[2:] # => [4, 3]
# Ometti la fine
li[:3] # => [1, 2, 4]
# Seleziona ogni seconda voce
li[::2] # =>[1, 4]
# Copia al contrario della lista
li[::-1] # => [3, 4, 2, 1]
# Usa combinazioni per fare slices avanzate
# li[inizio:fine:passo]
# Rimuovi arbitrariamente elementi da una lista con "del"
del li[2] # li è ora [1, 2, 3]
# Puoi sommare le liste
li + altra_li # => [1, 2, 3, 4, 5, 6]
# Nota: i valori per li ed altra_li non sono modificati.
# Concatena liste con "extend()"
li.extend(altra_li) # Ora li è [1, 2, 3, 4, 5, 6]
# Controlla l'esistenza di un valore in una lista con "in"
1 in li # => True
# Esamina la lunghezza con "len()"
len(li) # => 6
# Tuple sono come le liste ma immutabili.
tup = (1, 2, 3)
tup[0] # => 1
tup[0] = 3 # Genera un TypeError
# Puoi fare tutte queste cose da lista anche sulle tuple
len(tup) # => 3
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
tup[:2] # => (1, 2)
2 in tup # => True
# Puoi scompattare le tuple (o liste) in variabili
a, b, c = (1, 2, 3) # a è ora 1, b è ora 2 and c è ora 3
# Le tuple sono create di default se non usi le parentesi
d, e, f = 4, 5, 6
# Guarda come è facile scambiare due valori
e, d = d, e # d è ora 5 ed e è ora 4
# Dizionari immagazzinano mappature
empty_dict = {}
# Questo è un dizionario pre-riempito
filled_dict = {"uno": 1, "due": 2, "tre": 3}
# Accedi ai valori con []
filled_dict["uno"] # => 1
# Ottieni tutte le chiavi come una lista con "keys()"
filled_dict.keys() # => ["tre", "due", "uno"]
# Nota - Nei dizionari l'ordine delle chiavi non è garantito.
# Il tuo risultato potrebbe non essere uguale a questo.
# Ottieni tutt i valori come una lista con "values()"
filled_dict.values() # => [3, 2, 1]
# Nota - Come sopra riguardo l'ordinamento delle chiavi.
# Controlla l'esistenza delle chiavi in un dizionario con "in"
"uno" in filled_dict # => True
1 in filled_dict # => False
# Cercando una chiave non esistente è un KeyError
filled_dict["quattro"] # KeyError
# Usa il metodo "get()" per evitare KeyError
filled_dict.get("uno") # => 1
filled_dict.get("quattro") # => None
# Il metodo get supporta un argomento di default quando il valore è mancante
filled_dict.get("uno", 4) # => 1
filled_dict.get("quattro", 4) # => 4
# nota che filled_dict.get("quattro") è ancora => None
# (get non imposta il valore nel dizionario)
# imposta il valore di una chiave con una sintassi simile alle liste
filled_dict["quattro"] = 4 # ora, filled_dict["quattro"] => 4
# "setdefault()" aggiunge al dizionario solo se la chiave data non è presente
filled_dict.setdefault("five", 5) # filled_dict["five"] è impostato a 5
filled_dict.setdefault("five", 6) # filled_dict["five"] è ancora 5
# Sets immagazzina ... sets (che sono come le liste, ma non possono contenere doppioni)
empty_set = set()
# Inizializza un "set()" con un po' di valori
some_set = set([1, 2, 2, 3, 4]) # some_set è ora set([1, 2, 3, 4])
# l'ordine non è garantito, anche se a volta può sembrare ordinato
another_set = set([4, 3, 2, 2, 1]) # another_set è ora set([1, 2, 3, 4])
# Da Python 2.7, {} può essere usato per dichiarare un set
filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
# Aggiungere elementi ad un set
filled_set.add(5) # filled_set è ora {1, 2, 3, 4, 5}
# Fai intersezioni su un set con &
other_set = {3, 4, 5, 6}
filled_set & other_set # => {3, 4, 5}
# Fai unioni su set con |
filled_set | other_set # => {1, 2, 3, 4, 5, 6}
# Fai differenze su set con -
{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
# Controlla l'esistenza in un set con in
2 in filled_set # => True
10 in filled_set # => False
####################################################
## 3. Control Flow
####################################################
# Dichiariamo una variabile
some_var = 5
# Questo è un controllo if. L'indentazione è molto importante in python!
# stampa "some_var è più piccola di 10"
if some_var > 10:
print "some_var è decisamente più grande di 10."
elif some_var < 10: # Questa clausola elif è opzionale.
print "some_var è più piccola di 10."
else: # Anche questo è opzionale.
print "some_var è precisamente 10."
"""
I cicli for iterano sulle liste
stampa:
cane è un mammifero
gatto è un mammifero
topo è un mammifero
"""
for animale in ["cane", "gatto", "topo"]:
# Puoi usare {0} per interpolare le stringhe formattate. (Vedi di seguito.)
print "{0} è un mammifero".format(animale)
"""
"range(numero)" restituisce una lista di numeri
da zero al numero dato
stampa:
0
1
2
3
"""
for i in range(4):
print i
"""
"range(lower, upper)" restituisce una lista di numeri
dal più piccolo (lower) al più grande (upper)
stampa:
4
5
6
7
"""
for i in range(4, 8):
print i
"""
I cicli while vengono eseguiti finchè una condizione viene a mancare
stampa:
0
1
2
3
"""
x = 0
while x < 4:
print x
x += 1 # Forma compatta per x = x + 1
# Gestisci le eccezioni con un blocco try/except
# Funziona da Python 2.6 in su:
try:
# Usa "raise" per generare un errore
raise IndexError("Questo è un errore di indice")
except IndexError as e:
pass # Pass è solo una non-operazione. Solitamente vorrai fare un recupero.
except (TypeError, NameError):
pass # Eccezioni multiple possono essere gestite tutte insieme, se necessario.
else: # Clausola opzionale al blocco try/except. Deve seguire tutti i blocchi except
print "Tutto ok!" # Viene eseguita solo se il codice dentro try non genera eccezioni
finally: # Eseguito sempre
print "Possiamo liberare risorse qui"
# Invece di try/finally per liberare risorse puoi usare il metodo with
with open("myfile.txt") as f:
for line in f:
print line
####################################################
## 4. Funzioni
####################################################
# Usa "def" per creare nuove funzioni
def aggiungi(x, y):
print "x è {0} e y è {1}".format(x, y)
return x + y # Restituisce valori con il metodo return
# Chiamare funzioni con parametri
aggiungi(5, 6) # => stampa "x è 5 e y è 6" e restituisce 11
# Un altro modo per chiamare funzioni è con parole chiave come argomenti
aggiungi(y=6, x=5) # Le parole chiave come argomenti possono arrivare in ogni ordine.
# Puoi definire funzioni che accettano un numero variabile di argomenti posizionali
# che verranno interpretati come tuple se non usi il *
def varargs(*args):
return args
varargs(1, 2, 3) # => (1, 2, 3)
# Puoi definire funzioni che accettano un numero variabile di parole chiave
# come argomento, che saranno interpretati come un dizionario se non usi **
def keyword_args(**kwargs):
return kwargs
# Chiamiamola per vedere cosa succede
keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}
# Puoi farle entrambi in una volta, se ti va
def all_the_args(*args, **kwargs):
print args
print kwargs
"""
all_the_args(1, 2, a=3, b=4) stampa:
(1, 2)
{"a": 3, "b": 4}
"""
# Quando chiami funzioni, puoi fare l'opposto di args/kwargs!
# Usa * per sviluppare gli argomenti posizionale ed usa ** per espandere gli argomenti parola chiave
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # equivalente a foo(1, 2, 3, 4)
all_the_args(**kwargs) # equivalente a foo(a=3, b=4)
all_the_args(*args, **kwargs) # equivalente a foo(1, 2, 3, 4, a=3, b=4)
# puoi passare args e kwargs insieme alle altre funzioni che accettano args/kwargs
# sviluppandoli, rispettivamente, con * e **
def pass_all_the_args(*args, **kwargs):
all_the_args(*args, **kwargs)
print varargs(*args)
print keyword_args(**kwargs)
# Funzioni Scope
x = 5
def setX(num):
# La variabile locale x non è uguale alla variabile globale x
x = num # => 43
print x # => 43
def setGlobalX(num):
global x
print x # => 5
x = num # la variabile globable x è ora 6
print x # => 6
setX(43)
setGlobalX(6)
# Python ha funzioni di prima classe
def create_adder(x):
def adder(y):
return x + y
return adder
add_10 = create_adder(10)
add_10(3) # => 13
# Ci sono anche funzioni anonime
(lambda x: x > 2)(3) # => True
# Esse sono incluse in funzioni di alto livello
map(add_10, [1, 2, 3]) # => [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
# Possiamo usare la comprensione delle liste per mappe e filtri
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
####################################################
## 5. Classi
####################################################
# Usiamo una sottoclasse da un oggetto per avere una classe.
class Human(object):
# Un attributo della classe. E' condiviso da tutte le istanze delle classe
species = "H. sapiens"
# Costruttore base, richiamato quando la classe viene inizializzata.
# Si noti che il doppio leading e gli underscore finali denotano oggetti
# o attributi che sono usati da python ma che vivono nello spazio dei nome controllato
# dall'utente. Non dovresti usare nomi di questo genere.
def __init__(self, name):
# Assegna l'argomento all'attributo name dell'istanza
self.name = name
# Un metodo dell'istanza. Tutti i metodi prendo "self" come primo argomento
def say(self, msg):
return "{0}: {1}".format(self.name, msg)
# Un metodo della classe è condiviso fra tutte le istanze
# Sono chiamate con la classe chiamante come primo argomento
@classmethod
def get_species(cls):
return cls.species
# Un metodo statico è chiamato senza una classe od una istanza di riferimento
@staticmethod
def grunt():
return "*grunt*"
# Instanziare una classe
i = Human(name="Ian")
print i.say("hi") # stampa "Ian: hi"
j = Human("Joel")
print j.say("hello") # stampa "Joel: hello"
# Chiamare metodi della classe
i.get_species() # => "H. sapiens"
# Cambiare l'attributo condiviso
Human.species = "H. neanderthalensis"
i.get_species() # => "H. neanderthalensis"
j.get_species() # => "H. neanderthalensis"
# Chiamare il metodo condiviso
Human.grunt() # => "*grunt*"
####################################################
## 6. Moduli
####################################################
# Puoi importare moduli
import math
print math.sqrt(16) # => 4
# Puoi ottenere specifiche funzione da un modulo
from math import ceil, floor
print ceil(3.7) # => 4.0
print floor(3.7) # => 3.0
# Puoi importare tutte le funzioni da un modulo
# Attenzione: questo non è raccomandato
from math import *
# Puoi abbreviare i nomi dei moduli
import math as m
math.sqrt(16) == m.sqrt(16) # => True
# puoi anche verificare che le funzioni sono equivalenti
from math import sqrt
math.sqrt == m.sqrt == sqrt # => True
# I moduli di Python sono normali file python. Ne puoi
# scrivere di tuoi ed importarli. Il nome del modulo
# è lo stesso del nome del file.
# Potete scoprire quali funzioni e attributi
# definiscono un modulo
import math
dir(math)
####################################################
## 7. Avanzate
####################################################
# I generatori ti aiutano a fare codice pigro
def double_numbers(iterable):
for i in iterable:
yield i + i
# Un generatore crea valori al volo.
# Invece di generare e ritornare tutti i valori in una volta ne crea uno in ciascuna
# iterazione. Ciò significa che i valori più grandi di 15 non saranno considerati in
# double_numbers.
# Nota xrange è un generatore che fa la stessa cosa di range.
# Creare una lista 1-900000000 occuperebbe molto tempo e spazio.
# xrange crea un oggetto generatore xrange invece di creare l'intera lista
# come fa range.
# Usiamo un underscore finale nel nome delle variabile quando vogliamo usare un nome
# che normalmente colliderebbe con una parola chiave di python
xrange_ = xrange(1, 900000000)
# raddoppierà tutti i numeri fino a che result >=30 non sarà trovato
for i in double_numbers(xrange_):
print i
if i >= 30:
break
# Decoratori
# in questo esempio beg include say
# Beg chiamerà say. Se say_please è True allora cambierà il messaggio
# ritornato
from functools import wraps
def beg(target_function):
@wraps(target_function)
def wrapper(*args, **kwargs):
msg, say_please = target_function(*args, **kwargs)
if say_please:
return "{} {}".format(msg, "Per favore! Sono povero :(")
return msg
return wrapper
@beg
def say(say_please=False):
msg = "Puoi comprarmi una birra?"
return msg, say_please
print say() # Puoi comprarmi una birra?
print say(say_please=True) # Puoi comprarmi una birra? Per favore! Sono povero :(
```
## Pronto per qualcosa di più?
### Gratis Online
* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
* [Dive Into Python](http://www.diveintopython.net/)
* [The Official Docs](http://docs.python.org/2.6/)
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
* [Python Module of the Week](http://pymotw.com/2/)
* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
### Libri cartacei
* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)

73
java.html.markdown
View File

@ -128,7 +128,7 @@ public class LearnJava {
// //
// BigInteger can be initialized using an array of bytes or a string. // BigInteger can be initialized using an array of bytes or a string.
BigInteger fooBigInteger = new BigDecimal(fooByteArray); BigInteger fooBigInteger = new BigInteger(fooByteArray);
// BigDecimal - Immutable, arbitrary-precision signed decimal number // BigDecimal - Immutable, arbitrary-precision signed decimal number
@ -145,6 +145,11 @@ public class LearnJava {
BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt); BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
// Be wary of the constructor that takes a float or double as
// the inaccuracy of the float/double will be copied in BigDecimal.
// Prefer the String constructor when you need an exact value.
BigDecimal tenCents = new BigDecimal("0.1");
// Strings // Strings
@ -207,8 +212,8 @@ public class LearnJava {
System.out.println("1+2 = " + (i1 + i2)); // => 3 System.out.println("1+2 = " + (i1 + i2)); // => 3
System.out.println("2-1 = " + (i2 - i1)); // => 1 System.out.println("2-1 = " + (i2 - i1)); // => 1
System.out.println("2*1 = " + (i2 * i1)); // => 2 System.out.println("2*1 = " + (i2 * i1)); // => 2
System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down) System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
System.out.println("1/2 = " + (i1 / (i2*1.0))); // => 0.5 System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
// Modulo // Modulo
System.out.println("11%3 = "+(11 % 3)); // => 2 System.out.println("11%3 = "+(11 % 3)); // => 2
@ -416,7 +421,7 @@ public class LearnJava {
// easier way, by using something that is called Double Brace // easier way, by using something that is called Double Brace
// Initialization. // Initialization.
private static final Set<String> COUNTRIES = HashSet<String>() {{ private static final Set<String> COUNTRIES = new HashSet<String>() {{
add("DENMARK"); add("DENMARK");
add("SWEDEN"); add("SWEDEN");
add("FINLAND"); add("FINLAND");
@ -697,6 +702,66 @@ public abstract class Mammal()
return true; return true;
} }
} }
// Enum Type
//
// An enum type is a special data type that enables for a variable to be a set
// of predefined constants. The variable must be equal to one of the values that
// have been predefined for it. Because they are constants, the names of an enum
// type's fields are in uppercase letters. In the Java programming language, you
// define an enum type by using the enum keyword. For example, you would specify
// a days-of-the-week enum type as:
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
THURSDAY, FRIDAY, SATURDAY
}
// We can use our enum Day like that:
public class EnumTest {
// Variable Enum
Day day;
public EnumTest(Day day) {
this.day = day;
}
public void tellItLikeItIs() {
switch (day) {
case MONDAY:
System.out.println("Mondays are bad.");
break;
case FRIDAY:
System.out.println("Fridays are better.");
break;
case SATURDAY:
case SUNDAY:
System.out.println("Weekends are best.");
break;
default:
System.out.println("Midweek days are so-so.");
break;
}
}
public static void main(String[] args) {
EnumTest firstDay = new EnumTest(Day.MONDAY);
firstDay.tellItLikeItIs(); // => Mondays are bad.
EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
}
}
// Enum types are much more powerful than we show above.
// The enum body can include methods and other fields.
// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
``` ```
## Further Reading ## Further Reading

11
javascript.html.markdown
View File

@ -101,6 +101,10 @@ false;
// Strings are concatenated with + // Strings are concatenated with +
"Hello " + "world!"; // = "Hello world!" "Hello " + "world!"; // = "Hello world!"
// ... which works with more than just strings
"1, 2, " + 3; // = "1, 2, 3"
"Hello " + ["world", "!"] // = "Hello world,!"
// and are compared with < and > // and are compared with < and >
"a" < "b"; // = true "a" < "b"; // = true
@ -557,7 +561,9 @@ of the language.
[Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with attached terminal [Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with attached terminal
[Javascript: The Right Way][9] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices. [Eloquent Javascript - The Annotated Version][9] by Gordon Zhu is also a great derivative of Eloquent Javascript with extra explanations and clarifications for some of the more complicated examples.
[Javascript: The Right Way][10] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices.
In addition to direct contributors to this article, some content is adapted from In addition to direct contributors to this article, some content is adapted from
@ -573,4 +579,5 @@ Mozilla Developer Network.
[6]: http://www.amazon.com/gp/product/0596805527/ [6]: http://www.amazon.com/gp/product/0596805527/
[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript [7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
[8]: http://eloquentjavascript.net/ [8]: http://eloquentjavascript.net/
[9]: http://jstherightway.org/ [9]: http://watchandcode.com/courses/eloquent-javascript-the-annotated-version
[10]: http://jstherightway.org/

53
json.html.markdown
View File

@ -8,27 +8,24 @@ contributors:
- ["Michael Neth", "https://github.com/infernocloud"] - ["Michael Neth", "https://github.com/infernocloud"]
--- ---
As JSON is an extremely simple data-interchange format, this is most likely going to be the simplest Learn X in Y Minutes ever. JSON is an extremely simple data-interchange format. As [json.org](http://json.org) says, it is easy for humans to read and write and for machines to parse and generate.
A piece of JSON must represent either:
* A collection of name/value pairs (`{ }`). In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
* An ordered list of values (`[ ]`). In various languages, this is realized as an array, vector, list, or sequence.
an array/list/sequence (`[ ]`) or a dictionary/object/associated array (`{ }`).
JSON in its purest form has no actual comments, but most parsers will accept C-style (`//`, `/* */`) comments. Some parsers also tolerate a trailing comma (i.e. a comma after the last element of an array or the after the last property of an object), but they should be avoided for better compatibility. JSON in its purest form has no actual comments, but most parsers will accept C-style (`//`, `/* */`) comments. Some parsers also tolerate a trailing comma (i.e. a comma after the last element of an array or the after the last property of an object), but they should be avoided for better compatibility.
For the purposes of this, however, everything is going to be 100% valid JSON. Luckily, it kind of speaks for itself. For the purposes of this tutorial, everything is going to be 100% valid JSON. Luckily, it kind of speaks for itself.
A JSON value must be a number, a string, an array, an object, or one of the following 3 literal names: true, false, null. Supported data types:
Supporting browsers are: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, and Safari 4.0+. * Strings: `"hello"`, `"\"A quote.\""`, `"\u0abe"`, `"Newline.\n"`
* Numbers: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
File extension for JSON files is ".json" and the MIME type for JSON text is "application/json". * Objects: `{ "key": "value" }`
* Arrays: `["Values"]`
Many programming languages have support for serializing (encoding) and unserializing (decoding) JSON data into native data structures. Javascript has implicit support for manipulating JSON text as data. * Miscellaneous: `true`, `false`, `null`
More information can be found at http://www.json.org/
JSON is built on two structures:
* A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
* An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence.
An object with various name/value pairs.
```json ```json
{ {
@ -66,20 +63,20 @@ An object with various name/value pairs.
"alternative style": { "alternative style": {
"comment": "check this out!" "comment": "check this out!"
, "comma position": "doesn't matter - as long as it's before the next key, then it's valid" , "comma position": "doesn't matter, if it's before the next key, it's valid"
, "another comment": "how nice" , "another comment": "how nice"
} },
"whitespace": "Does not matter.",
"that was short": "And done. You now know everything JSON has to offer."
} }
``` ```
A single array of values by itself is also valid JSON. ## Further Reading
```json * [JSON.org](http://json.org) All of JSON beautifully explained using flowchart-like graphics.
[1, 2, 3, "text", true]
```
Objects can be a part of the array as well.
```json
[{"name": "Bob", "age": 25}, {"name": "Jane", "age": 29}, {"name": "Jack", "age": 31}]
```

16
julia.html.markdown
View File

@ -2,6 +2,7 @@
language: Julia language: Julia
contributors: contributors:
- ["Leah Hanson", "http://leahhanson.us"] - ["Leah Hanson", "http://leahhanson.us"]
- ["Pranit Bauva", "http://github.com/pranitbauva1997"]
filename: learnjulia.jl filename: learnjulia.jl
--- ---
@ -102,6 +103,11 @@ false
# Printing is easy # Printing is easy
println("I'm Julia. Nice to meet you!") println("I'm Julia. Nice to meet you!")
# String can be compared lexicographically
"good" > "bye" # => true
"good" == "good" # => true
"1 + 2 = 3" == "1 + 2 = $(1+2)" # => true
#################################################### ####################################################
## 2. Variables and Collections ## 2. Variables and Collections
#################################################### ####################################################
@ -390,6 +396,14 @@ end
add(5, 6) # => 11 after printing out "x is 5 and y is 6" add(5, 6) # => 11 after printing out "x is 5 and y is 6"
# Compact assignment of functions
f_add(x, y) = x + y # => "f (generic function with 1 method)"
f_add(3, 4) # => 7
# Function can also return multiple values as tuple
f(x, y) = x + y, x - y
f(3, 4) # => (7, -1)
# You can define functions that take a variable number of # You can define functions that take a variable number of
# positional arguments # positional arguments
function varargs(args...) function varargs(args...)
@ -723,7 +737,7 @@ code_native(square_area, (Float64,))
# ret # ret
# #
# Note that julia will use floating point instructions if any of the # Note that julia will use floating point instructions if any of the
# arguements are floats. # arguments are floats.
# Let's calculate the area of a circle # Let's calculate the area of a circle
circle_area(r) = pi * r * r # circle_area (generic function with 1 method) circle_area(r) = pi * r * r # circle_area (generic function with 1 method)
circle_area(5) # 78.53981633974483 circle_area(5) # 78.53981633974483

10
latex.html.markdown
View File

@ -4,6 +4,7 @@ contributors:
- ["Chaitanya Krishna Ande", "http://icymist.github.io"] - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
- ["Colton Kohnke", "http://github.com/voltnor"] - ["Colton Kohnke", "http://github.com/voltnor"]
- ["Sricharan Chiruvolu", "http://sricharan.xyz"] - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
- ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
filename: learn-latex.tex filename: learn-latex.tex
--- ---
@ -227,6 +228,15 @@ format you defined in Step 1.
That's all for now! That's all for now!
% Most often, you would want to have a references section in your document.
% The easiest way to set this up would be by using the bibliography section
\begin{thebibliography}{1}
% similar to other lists, the \bibitem command can be used to list items
% each entry can then be cited directly in the body of the text
\bibitem{latexwiki} The amazing LaTeX wikibook: {\em https://en.wikibooks.org/wiki/LaTeX}
\bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
\end{thebibliography}
% end the document % end the document
\end{document} \end{document}
``` ```

379
less.html.markdown Normal file
View File

@ -0,0 +1,379 @@
---
language: less
filename: learnless.less
contributors:
- ["Saravanan Ganesh", "http://srrvnn.me"]
---
Less is a CSS pre-processor, that adds features such as variables, nesting, mixins and more.
Less (and other preprocessors, such as [Sass](http://sass-lang.com/) help developers to write maintainable and DRY (Don't Repeat Yourself) code.
```less
//Single line comments are removed when Less is compiled to CSS.
/*Multi line comments are preserved. */
/*Variables
==============================*/
/* You can store a CSS value (such as a color) in a variable.
Use the '@' symbol to create a variable. */
@primary-color: #A3A4FF;
@secondary-color: #51527F;
@body-font: 'Roboto', sans-serif;
/* You can use the variables throughout your stylesheet.
Now if you want to change a color, you only have to make the change once.*/
body {
background-color: @primary-color;
color: @secondary-color;
font-family: @body-font;
}
/* This would compile to: */
body {
background-color: #A3A4FF;
color: #51527F;
font-family: 'Roboto', sans-serif;
}
/* This is much more maintainable than having to change the color
each time it appears throughout your stylesheet. */
/*Mixins
==============================*/
/* If you find you are writing the same code for more than one
element, you might want to reuse that easily.*/
.center {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
}
/* You can use the mixin by simply adding the selector as a style */
div {
.center;
background-color: @primary-color;
}
/*Which would compile to: */
.center {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
}
div {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
background-color: #A3A4FF;
}
/* You can omit the mixin code from being compiled by adding paranthesis
after the selector */
.center() {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
}
div {
.center;
background-color: @primary-color;
}
/*Which would compile to: */
div {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
background-color: #A3A4FF;
}
/*Functions
==============================*/
/* Less provides functions that can be used to accomplish a variety of
tasks. Consider the following */
/* Functions can be invoked by using their name and passing in the
required arguments */
body {
width: round(10.25px);
}
.footer {
background-color: fadeout(#000000, 0.25)
}
/* Compiles to: */
body {
width: 10px;
}
.footer {
background-color: rgba(0, 0, 0, 0.75);
}
/* You may also define your own functions. Functions are very similar to
mixins. When trying to choose between a function or a mixin, remember
that mixins are best for generating CSS while functions are better for
logic that might be used throughout your Less code. The examples in
the Math Operators' section are ideal candidates for becoming a reusable
function. */
/* This function will take a target size and the parent size and calculate
and return the percentage */
.average(@x, @y) {
@average_result: ((@x + @y) / 2);
}
div {
.average(16px, 50px); // "call" the mixin
padding: @average_result; // use its "return" value
}
/* Compiles to: */
div {
padding: 33px;
}
/*Extend (Inheritance)
==============================*/
/*Extend is a way to share the properties of one selector with another. */
.display {
height: 50px;
}
.display-success {
&:extend(.display);
border-color: #22df56;
}
/* Compiles to: */
.display,
.display-success {
height: 50px;
}
.display-success {
border-color: #22df56;
}
/* Extending a CSS statement is preferable to creating a mixin
because of the way it groups together the classes that all share
the same base styling. If this was done with a mixin, the properties
would be duplicated for each statement that
called the mixin. While it won't affect your workflow, it will
add unnecessary bloat to the files created by the Less compiler. */
/*Nesting
==============================*/
/*Less allows you to nest selectors within selectors */
ul {
list-style-type: none;
margin-top: 2em;
li {
background-color: #FF0000;
}
}
/* '&' will be replaced by the parent selector. */
/* You can also nest pseudo-classes. */
/* Keep in mind that over-nesting will make your code less maintainable.
Best practices recommend going no more than 3 levels deep when nesting.
For example: */
ul {
list-style-type: none;
margin-top: 2em;
li {
background-color: red;
&:hover {
background-color: blue;
}
a {
color: white;
}
}
}
/* Compiles to: */
ul {
list-style-type: none;
margin-top: 2em;
}
ul li {
background-color: red;
}
ul li:hover {
background-color: blue;
}
ul li a {
color: white;
}
/*Partials and Imports
==============================*/
/* Less allows you to create partial files. This can help keep your Less
code modularized. Partial files conventionally begin with an '_',
e.g. _reset.less. and are imported into a main less file that gets
compiled into CSS */
/* Consider the following CSS which we'll put in a file called _reset.less */
html,
body,
ul,
ol {
margin: 0;
padding: 0;
}
/* Less offers @import which can be used to import partials into a file.
This differs from the traditional CSS @import statement which makes
another HTTP request to fetch the imported file. Less takes the
imported file and combines it with the compiled code. */
@import 'reset';
body {
font-size: 16px;
font-family: Helvetica, Arial, Sans-serif;
}
/* Compiles to: */
html, body, ul, ol {
margin: 0;
padding: 0;
}
body {
font-size: 16px;
font-family: Helvetica, Arial, Sans-serif;
}
/*Math Operations
==============================*/
/* Less provides the following operators: +, -, *, /, and %. These can
be useful for calculating values directly in your Less files instead
of using values that you've already calculated by hand. Below is an example
of a setting up a simple two column design. */
@content-area: 960px;
@main-content: 600px;
@sidebar-content: 300px;
@main-size: @main-content / @content-area * 100%;
@sidebar-size: @sidebar-content / @content-area * 100%;
@gutter: 100% - (@main-size + @sidebar-size);
body {
width: 100%;
}
.main-content {
width: @main-size;
}
.sidebar {
width: @sidebar-size;
}
.gutter {
width: @gutter;
}
/* Compiles to: */
body {
width: 100%;
}
.main-content {
width: 62.5%;
}
.sidebar {
width: 31.25%;
}
.gutter {
width: 6.25%;
}
```
## Practice Less
If you want to play with Less in your browser, check out [LESS2CSS](http://lesscss.org/less-preview/).
## Compatibility
Less can be used in any project as long as you have a program to compile it
into CSS. You'll want to verify that the CSS you're using is compatible
with your target browsers.
[QuirksMode CSS](http://www.quirksmode.org/css/) and [CanIUse](http://caniuse.com) are great resources for checking compatibility.
## Further reading
* [Official Documentation](http://lesscss.org/features/)

81
lt-lt/json-lt.html.markdown Normal file
View File

@ -0,0 +1,81 @@
---
language: json
filename: learnjson.json
lang: lt-lt
contributors:
- ["Zygimantus", "https://github.com/zygimantus"]
---
JSON („džeisonas“) yra itin paprastas duomenų mainų formatas, todėl tai bus pati lengviausia „Learn X in Y Minutes“ pamoka.
JSON savo gryniausioje formoje neturi jokių komentarų, tačiau dauguma analizatorių priimtų C stiliaus komentarus (`//`, `/* */`). Kai kurie analizatoriai taip pat toleruoja gale esantį kablelį, pvz., kablelis po kiekvieno masyvo paskutinio elemento arba po paskutinio objekto lauko, tačiau jų reikėtų vengti dėl geresnio suderinamumo.
JSON reikšmė privalo būti skaičius, eilutė, masyvas, objektas arba viena reikšmė iš šių: true, false, null.
Palaikančios naršyklės yra: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, and Safari 4.0+.
Failo plėtinys JSON failams yra „.json“, o MIME tipas yra „application/json“.
Dauguma programavimo kalbų palaiko JSON duomenų serializaciją (kodavimą) ir deserializaciją (dekodavimą) į natyviasias duomenų struktūras. Javascript turi visišką JSON teksto kaip duomenų manipuliavimo palaikymą.
Daugiau informacijos galima rasti http://www.json.org/
JSON yra pastatytas iš dviejų struktūrų:
* Vardų/reikšmių porų rinkinys. Daugomoje kalbų, tai yra realizuojama kaip objektas, įrašas, struktūra, žodynas, hash lentelė, sąrašas su raktais arba asociatyvusis masyvas.
* Rūšiuotas reikšmių sąrašas. Daugumoje kalbų, toks sąrašas yra realizuojama kaip masyvas, vektorius, sąrašas arba seka.
Objektas su įvairiomis vardo/reikšmės poromis.
```json
{
"raktas": "reikšmė",
"raktai": "privalo visada būti uždaryti dvigubomis kabutėmis",
"skaičiai": 0,
"eilutės": "Labas, pasauli. Visas unikodas yra leidžiamas, kartu su \"vengimu\".",
"turi logiką?": true,
"niekas": null,
"didelis skaičius": 1.2e+100,
"objektai": {
"komentaras": "Dauguma tavo struktūrų ateis iš objektų.",
"masyvas": [0, 1, 2, 3, "Masyvas gali turėti bet ką savyje.", 5],
"kitas objektas": {
"komentaras": "Šie dalykai gali būti įdedami naudingai."
}
},
"kvailumas": [
{
"kalio šaltiniai": ["bananai"]
},
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, "neo"],
[0, 0, 0, 1]
]
],
"alternativus stilius": {
"komentaras": "tik pažiūrėk!"
, "kablelio padėti": "nesvarbi - kol jis prieš kitą raktą, tada teisingas"
, "kitas komentaras": "kaip gražu"
}
}
```
Paprastas reikšmių masyvas pats savaime yra galiojantis JSON.
```json
[1, 2, 3, "tekstas", true]
```
Objektai taip pat gali būti masyvų dalis.
```json
[{"vardas": "Jonas", "amžius": 25}, {"vardas": "Eglė", "amžius": 29}, {"vardas": "Petras", "amžius": 31}]
```

2
lua.html.markdown
View File

@ -190,7 +190,7 @@ end
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
-- A table can have a metatable that gives the table operator-overloadish -- A table can have a metatable that gives the table operator-overloadish
-- behavior. Later we'll see how metatables support js-prototypey behaviour. -- behaviour. Later we'll see how metatables support js-prototypey behaviour.
f1 = {a = 1, b = 2} -- Represents the fraction a/b. f1 = {a = 1, b = 2} -- Represents the fraction a/b.
f2 = {a = 2, b = 3} f2 = {a = 2, b = 3}

2
make.html.markdown
View File

@ -234,10 +234,8 @@ bar = 'hello'
endif endif
``` ```
### More Resources ### More Resources
+ [gnu make documentation](https://www.gnu.org/software/make/manual/) + [gnu make documentation](https://www.gnu.org/software/make/manual/)
+ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/) + [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)
+ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html) + learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)

235
markdown.html.markdown
View File

@ -2,45 +2,63 @@
language: markdown language: markdown
contributors: contributors:
- ["Dan Turkel", "http://danturkel.com/"] - ["Dan Turkel", "http://danturkel.com/"]
- ["Jacob Ward", "http://github.com/JacobCWard/"]
filename: markdown.md filename: markdown.md
--- ---
Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well). Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well).
Give me as much feedback as you want! / Feel free to fork and pull request! Markdown also varies in implementation from one parser to a next. This
guide will attempt to clarify when features are universal or when they are
specific to a certain parser.
- [HTML Elements](#html-elements)
- [Headings](#headings)
- [Simple Text Styles](#simple-text-styles)
- [Paragraphs](#paragraphs)
- [Lists](#lists)
- [Code blocks](#code-blocks)
- [Horizontal rule](#horizontal-rule)
- [Links](#links)
- [Images](#images)
- [Miscellany](#miscellany)
## HTML Elements
Markdown is a superset of HTML, so any HTML file is valid Markdown.
```markdown
<!--This means we can use HTML elements in Markdown, such as the comment element,
and they won't be affected by a markdown parser. However, if you create an HTML element
in your markdown file, you cannot use markdown syntax within that element's contents.-->
```
## Headings
You can create HTML elements `<h1>` through `<h6>` easily by prepending the
text you want to be in that element by a number of hashes (#).
```markdown ```markdown
<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that
means we can use HTML elements in Markdown, such as the comment element, and
they won't be affected by a markdown parser. However, if you create an HTML
element in your markdown file, you cannot use markdown syntax within that
element's contents. -->
<!-- Markdown also varies in implementation from one parser to a next. This
guide will attempt to clarify when features are universal or when they are
specific to a certain parser. -->
<!-- Headers -->
<!-- You can create HTML elements <h1> through <h6> easily by prepending the
text you want to be in that element by a number of hashes (#) -->
# This is an <h1> # This is an <h1>
## This is an <h2> ## This is an <h2>
### This is an <h3> ### This is an <h3>
#### This is an <h4> #### This is an <h4>
##### This is an <h5> ##### This is an <h5>
###### This is an <h6> ###### This is an <h6>
```
Markdown also provides us with two alternative ways of indicating h1 and h2.
<!-- Markdown also provides us with two alternative ways of indicating h1 and h2 --> ```markdown
This is an h1 This is an h1
============= =============
This is an h2 This is an h2
------------- -------------
```
## Simple text styles
<!-- Simple text styles --> Text can be easily styled as italic or bold using markdown.
<!-- Text can be easily styled as italic or bold using markdown -->
```markdown
*This text is in italics.* *This text is in italics.*
_And so is this text._ _And so is this text._
@ -50,15 +68,20 @@ __And so is this text.__
***This text is in both.*** ***This text is in both.***
**_As is this!_** **_As is this!_**
*__And this!__* *__And this!__*
```
<!-- In Github Flavored Markdown, which is used to render markdown files on In Github Flavored Markdown, which is used to render markdown files on
Github, we also have strikethrough: --> Github, we also have strikethrough:
```markdown
~~This text is rendered with strikethrough.~~ ~~This text is rendered with strikethrough.~~
```
## Paragraphs
<!-- Paragraphs are a one or multiple adjacent lines of text separated by one or Paragraphs are a one or multiple adjacent lines of text separated by one or
multiple blank lines. --> multiple blank lines.
```markdown
This is a paragraph. I'm typing in a paragraph isn't this fun? This is a paragraph. I'm typing in a paragraph isn't this fun?
Now I'm in paragraph 2. Now I'm in paragraph 2.
@ -66,16 +89,20 @@ I'm still in paragraph 2 too!
I'm in paragraph three! I'm in paragraph three!
```
<!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph Should you ever want to insert an HTML <br /> tag, you can end a paragraph
with two or more spaces and then begin a new paragraph. --> with two or more spaces and then begin a new paragraph.
```markdown
I end with two spaces (highlight me to see them). I end with two spaces (highlight me to see them).
There's a <br /> above me! There's a <br /> above me!
```
<!-- Block quotes are easy and done with the > character. --> Block quotes are easy and done with the > character.
```markdown
> This is a block quote. You can either > This is a block quote. You can either
> manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own. > manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own.
> It doesn't make a difference so long as they start with a `>`. > It doesn't make a difference so long as they start with a `>`.
@ -84,9 +111,12 @@ There's a <br /> above me!
>> of indentation? >> of indentation?
> How neat is that? > How neat is that?
<!-- Lists --> ```
<!-- Unordered lists can be made using asterisks, pluses, or hyphens -->
## Lists
Unordered lists can be made using asterisks, pluses, or hyphens.
```markdown
* Item * Item
* Item * Item
* Another item * Another item
@ -102,159 +132,182 @@ or
- Item - Item
- Item - Item
- One last item - One last item
```
Ordered lists are done with a number followed by a period.
<!-- Ordered lists are done with a number followed by a period --> ```markdown
1. Item one 1. Item one
2. Item two 2. Item two
3. Item three 3. Item three
```
<!-- You don't even have to label the items correctly and markdown will still You don't even have to label the items correctly and markdown will still
render the numbers in order, but this may not be a good idea --> render the numbers in order, but this may not be a good idea.
```markdown
1. Item one 1. Item one
1. Item two 1. Item two
1. Item three 1. Item three
<!-- (This renders the same as the above example) --> ```
(This renders the same as the above example)
<!-- You can also use sublists -->
You can also use sublists
```markdown
1. Item one 1. Item one
2. Item two 2. Item two
3. Item three 3. Item three
* Sub-item * Sub-item
* Sub-item * Sub-item
4. Item four 4. Item four
```
<!-- There are even task lists. This creates HTML checkboxes. --> There are even task lists. This creates HTML checkboxes.
```markdown
Boxes below without the 'x' are unchecked HTML checkboxes. Boxes below without the 'x' are unchecked HTML checkboxes.
- [ ] First task to complete. - [ ] First task to complete.
- [ ] Second task that needs done - [ ] Second task that needs done
This checkbox below will be a checked HTML checkbox. This checkbox below will be a checked HTML checkbox.
- [x] This task has been completed - [x] This task has been completed
```
<!-- Code blocks --> ## Code blocks
<!-- You can indicate a code block (which uses the <code> element) by indenting
a line with four spaces or a tab -->
You can indicate a code block (which uses the `<code>` element) by indenting
a line with four spaces or a tab.
```markdown
This is code This is code
So is this So is this
```
<!-- You can also re-tab (or add an additional four spaces) for indentation You can also re-tab (or add an additional four spaces) for indentation
inside your code --> inside your code
```markdown
my_array.each do |item| my_array.each do |item|
puts item puts item
end end
```
<!-- Inline code can be created using the backtick character ` --> Inline code can be created using the backtick character `
```markdown
John didn't even know what the `go_to()` function did! John didn't even know what the `go_to()` function did!
```
<!-- In Github Flavored Markdown, you can use a special syntax for code --> In Github Flavored Markdown, you can use a special syntax for code
```markdown
\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! --> \`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
def foobar def foobar
puts "Hello world!" puts "Hello world!"
end end
\`\`\` <!-- here too, no backslashes, just ``` --> \`\`\` <!-- here too, no backslashes, just ``` -->
```
<!-- The above text doesn't require indenting, plus Github will use syntax The above text doesn't require indenting, plus Github will use syntax
highlighting of the language you specify after the ``` --> highlighting of the language you specify after the \`\`\`
<!-- Horizontal rule (<hr />) --> ## Horizontal rule
<!-- Horizontal rules are easily added with three or more asterisks or hyphens,
with or without spaces. -->
Horizontal rules (`<hr/>`) are easily added with three or more asterisks or hyphens,
with or without spaces.
```markdown
*** ***
--- ---
- - - - - -
**************** ****************
```
<!-- Links --> ## Links
<!-- One of the best things about markdown is how easy it is to make links. Put
the text to display in hard brackets [] followed by the url in parentheses () -->
One of the best things about markdown is how easy it is to make links. Put
the text to display in hard brackets [] followed by the url in parentheses ()
```markdown
[Click me!](http://test.com/) [Click me!](http://test.com/)
```
<!-- You can also add a link title using quotes inside the parentheses --> You can also add a link title using quotes inside the parentheses.
```markdown
[Click me!](http://test.com/ "Link to Test.com") [Click me!](http://test.com/ "Link to Test.com")
```
<!-- Relative paths work too. --> Relative paths work too.
```markdown
[Go to music](/music/). [Go to music](/music/).
```
<!-- Markdown also supports reference style links --> Markdown also supports reference style links.
```markdown
[Click this link][link1] for more info about it! [Click this link][link1] for more info about it!
[Also check out this link][foobar] if you want to. [Also check out this link][foobar] if you want to.
[link1]: http://test.com/ "Cool!" [link1]: http://test.com/ "Cool!"
[foobar]: http://foobar.biz/ "Alright!" [foobar]: http://foobar.biz/ "Alright!"
```
<!-- The title can also be in single quotes or in parentheses, or omitted The title can also be in single quotes or in parentheses, or omitted
entirely. The references can be anywhere in your document and the reference IDs entirely. The references can be anywhere in your document and the reference IDs
can be anything so long as they are unique. --> can be anything so long as they are unique.
<!-- There is also "implicit naming" which lets you use the link text as the id -->
There is also "implicit naming" which lets you use the link text as the id.
```markdown
[This][] is a link. [This][] is a link.
[this]: http://thisisalink.com/ [this]: http://thisisalink.com/
```
But it's not that commonly used.
<!-- But it's not that commonly used. --> ## Images
Images are done the same way as links but with an exclamation point in front!
<!-- Images --> ```markdown
<!-- Images are done the same way as links but with an exclamation point in front! -->
![This is the alt-attribute for my image](http://imgur.com/myimage.jpg "An optional title") ![This is the alt-attribute for my image](http://imgur.com/myimage.jpg "An optional title")
```
<!-- And reference style works as expected --> And reference style works as expected.
```markdown
![This is the alt-attribute.][myimage] ![This is the alt-attribute.][myimage]
[myimage]: relative/urls/cool/image.jpg "if you need a title, it's here" [myimage]: relative/urls/cool/image.jpg "if you need a title, it's here"
```
<!-- Miscellany --> ## Miscellany
<!-- Auto-links --> ### Auto-links
```markdown
<http://testwebsite.com/> is equivalent to <http://testwebsite.com/> is equivalent to
[http://testwebsite.com/](http://testwebsite.com/) [http://testwebsite.com/](http://testwebsite.com/)
```
<!-- Auto-links for emails --> ### Auto-links for emails
```markdown
<foo@bar.com> <foo@bar.com>
```
<!-- Escaping characters --> ### Escaping characters
```markdown
I want to type *this text surrounded by asterisks* but I don't want it to be I want to type *this text surrounded by asterisks* but I don't want it to be
in italics, so I do this: \*this text surrounded by asterisks\*. in italics, so I do this: \*this text surrounded by asterisks\*.
```
<!-- Keyboard keys --> ### Keyboard keys
<!-- In Github Flavored Markdown, you can use a <kbd> tag to represent keyboard keys -->
In Github Flavored Markdown, you can use a `<kbd>` tag to represent keyboard keys.
```markdown
Your computer crashed? Try sending a Your computer crashed? Try sending a
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd> <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
```
### Tables
<!-- Tables --> Tables are only available in Github Flavored Markdown and are slightly
<!-- Tables are only available in Github Flavored Markdown and are slightly cumbersome, but if you really want it:
cumbersome, but if you really want it: --> ```markdown
| Col1 | Col2 | Col3 | | Col1 | Col2 | Col3 |
| :----------- | :------: | ------------: | | :----------- | :------: | ------------: |
| Left-aligned | Centered | Right-aligned | | Left-aligned | Centered | Right-aligned |
| blah | blah | blah | | blah | blah | blah |
```
or, for the same results
<!-- or, for the same results --> ```markdown
Col 1 | Col2 | Col3 Col 1 | Col2 | Col3
:-- | :-: | --: :-- | :-: | --:
Ugh this is so ugly | make it | stop Ugh this is so ugly | make it | stop
<!-- The end! -->
``` ```
---
For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).

23
matlab.html.markdown
View File

@ -15,6 +15,7 @@ If you have any feedback please feel free to reach me at
[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com). [osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
```matlab ```matlab
%% Code sections start with two percent signs. Section titles go on the same line.
% Comments start with a percent sign. % Comments start with a percent sign.
%{ %{
@ -72,7 +73,7 @@ c = exp(a)*sin(pi/2) % c = 7.3891
% Calling functions can be done in either of two ways: % Calling functions can be done in either of two ways:
% Standard function syntax: % Standard function syntax:
load('myFile.mat', 'y') % arguments within parantheses, spererated by commas load('myFile.mat', 'y') % arguments within parentheses, separated by commas
% Command syntax: % Command syntax:
load myFile.mat y % no parentheses, and spaces instead of commas load myFile.mat y % no parentheses, and spaces instead of commas
% Note the lack of quote marks in command form: inputs are always passed as % Note the lack of quote marks in command form: inputs are always passed as
@ -123,6 +124,7 @@ x(2:end) % ans = 32 53 7 1
x = [4; 32; 53; 7; 1] % Column vector x = [4; 32; 53; 7; 1] % Column vector
x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10 x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
x = [1:2:10] % Increment by 2, i.e. x = 1 3 5 7 9
% Matrices % Matrices
A = [1 2 3; 4 5 6; 7 8 9] A = [1 2 3; 4 5 6; 7 8 9]
@ -205,6 +207,8 @@ transpose(A) % Transpose the matrix, which is the same as:
A one A one
ctranspose(A) % Hermitian transpose the matrix ctranspose(A) % Hermitian transpose the matrix
% (the transpose, followed by taking complex conjugate of each element) % (the transpose, followed by taking complex conjugate of each element)
A' % Concise version of complex transpose
A.' % Concise version of transpose (without taking complex conjugate)
@ -254,6 +258,8 @@ axis equal % Set aspect ratio so data units are the same in every direction
scatter(x, y); % Scatter-plot scatter(x, y); % Scatter-plot
hist(x); % Histogram hist(x); % Histogram
stem(x); % Plot values as stems, useful for displaying discrete data
bar(x); % Plot bar graph
z = sin(x); z = sin(x);
plot3(x,y,z); % 3D line plot plot3(x,y,z); % 3D line plot
@ -273,7 +279,7 @@ clf clear % clear current figure window, and reset most figure properties
% Properties can be set and changed through a figure handle. % Properties can be set and changed through a figure handle.
% You can save a handle to a figure when you create it. % You can save a handle to a figure when you create it.
% The function gcf returns a handle to the current figure % The function get returns a handle to the current figure
h = plot(x, y); % you can save a handle to a figure when you create it h = plot(x, y); % you can save a handle to a figure when you create it
set(h, 'Color', 'r') set(h, 'Color', 'r')
% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black % 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
@ -400,7 +406,7 @@ exp(x)
sqrt(x) sqrt(x)
log(x) log(x)
log10(x) log10(x)
abs(x) abs(x) %If x is complex, returns magnitude
min(x) min(x)
max(x) max(x)
ceil(x) ceil(x)
@ -411,6 +417,14 @@ rand % Uniformly distributed pseudorandom numbers
randi % Uniformly distributed pseudorandom integers randi % Uniformly distributed pseudorandom integers
randn % Normally distributed pseudorandom numbers randn % Normally distributed pseudorandom numbers
%Complex math operations
abs(x) % Magnitude of complex variable x
phase(x) % Phase (or angle) of complex variable x
real(x) % Returns the real part of x (i.e returns a if x = a +jb)
imag(x) % Returns the imaginary part of x (i.e returns b if x = a+jb)
conj(x) % Returns the complex conjugate
% Common constants % Common constants
pi pi
NaN NaN
@ -465,6 +479,9 @@ median % median value
mean % mean value mean % mean value
std % standard deviation std % standard deviation
perms(x) % list all permutations of elements of x perms(x) % list all permutations of elements of x
find(x) % Finds all non-zero elements of x and returns their indexes, can use comparison operators,
% i.e. find( x == 3 ) returns indexes of elements that are equal to 3
% i.e. find( x >= 3 ) returns indexes of elements greater than or equal to 3
% Classes % Classes

588
ms-my/javascript-my.html.markdown Normal file
View File

@ -0,0 +1,588 @@
---
language: javascript
contributors:
- ["Adam Brenecki", "http://adam.brenecki.id.au"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
filename: javascript-ms.js
translators:
- ["abdalim", "https://github.com/abdalim"]
lang: ms-my
---
Javascript dicipta oleh Brendan Eich dari Netscape pada 1995. Pada awalnya, ia
dicipta sebagai bahasa skrip yang ringkas untuk laman web, melengkapi penggunaan
Java untuk aplikasi web yang lebih rumit, namun begitu, integrasi rapat pada
halaman web dan sokongan tersedia dalam pelayar web telah menyebabkan ia menjadi
lebih kerap digunakan berbanding Java pada bahagian hadapan laman web.
Namun begitu, Javascript tidak terhad pada pelayar web; Node.js, sebuah projek
yang menyediakan 'runtime' berdiri sendiri untuk enjin V8 Google Chrome sedang
kian mendapat sambutan yang hangat.
```js
// Komentar adalah seperti dalam C. Komentar sebaris bermula dengan dua sengkang
/* dan komentar banyak baris bermula dengan sengkang-bintang
dan berakhir dengan bintang-sengkang */
// Pernyataan boleh ditamatkan dengan ';'
doStuff();
// ... tetapi ia tidak wajib, kerana koma bertitik secara automatik akan
// dimasukkan dimana tempat yang ada baris baru, kecuali dalam kes - kes
// tertentu.
doStuff()
// Disebabkan kes - kes itu boleh menyebabkan hasil yang tidak diduga, kami
// akan sentiasa menggunakan koma bertitik dalam panduan ini.
///////////////////////////////////
// 1. Nombor, String dan Operator
// Javascript mempunyai satu jenis nombor (iaitu 64-bit IEEE 754 double).
// Double mempunyai 52-bit mantissa, iaitu ia cukup untuk menyimpan integer
// sehingga 9✕10¹⁵ secara tepatnya.
3; // = 3
1.5; // = 1.5
// Sebahagian aritmetic asas berfungsi seperti yang anda jangkakan.
1 + 1; // = 2
0.1 + 0.2; // = 0.30000000000000004
8 - 1; // = 7
10 * 2; // = 20
35 / 5; // = 7
// Termasuk pembahagian tidak rata.
5 / 2; // = 2.5
// Dan pembahagian modulo.
10 % 2; // = 0
30 % 4; // = 2
18.5 % 7; // = 4.5
// Operasi bitwise juga boleh digunakan; bila anda melakukan operasi bitwise,
// float anda akan ditukarkan kepada int bertanda *sehingga* 32 bit.
1 << 2; // = 4
// Keutamaan ditekankan menggunakan kurungan.
(1 + 3) * 2; // = 8
// Terdapat tiga nilai nombor-tidak-nyata istimewa
Infinity; // hasil operasi seperti 1/0
-Infinity; // hasil operasi seperti -1/0
NaN; // hasil operasi seperti 0/0, bermaksud 'Bukan Sebuah Nombor'
// Terdapat juga jenis boolean
true;
false;
// Talian dicipta dengan ' atau ''.
'abc';
"Hello, world";
// Penafian menggunakan simbol !
!true; // = tidak benar
!false; // = benar
// Sama ialah ===
1 === 1; // = benar
2 === 1; // = tidak benar
// Tidak sama ialah !==
1 !== 1; // = tidak benar
2 !== 1; // = benar
// Lagi perbandingan
1 < 10; // = benar
1 > 10; // = tidak benar
2 <= 2; // = benar
2 >= 2; // = benar
// Talian disambungkan dengan +
"Hello " + "world!"; // = "Hello world!"
// dan dibandingkan dengan < dan >
"a" < "b"; // = benar
// Paksaan jenis dilakukan untuk perbandingan menggunakan dua sama dengan...
"5" == 5; // = benar
null == undefined; // = benar
// ...melainkan anda menggunakan ===
"5" === 5; // = tidak benar
null === undefined; // = tidak benar
// ...yang boleh menghasilkan keputusan yang pelik...
13 + !0; // 14
"13" + !0; // '13true'
// Anda boleh akses huruf dalam perkataan dengan `charAt`
"This is a string".charAt(0); // = 'T'
// ...atau menggunakan `substring` untuk mendapatkan bahagian yang lebih besar.
"Hello world".substring(0, 5); // = "Hello"
// `length` adalah ciri, maka jangan gunakan ().
"Hello".length; // = 5
// Selain itu, terdapat juga `null` dan `undefined`.
null; // digunakan untuk menandakan bukan-nilai yang disengajakan
undefined; // digunakan untuk menandakan nilai yang tidak wujud pada waktu ini (walaupun `undefined` adalah nilai juga)
// false, null, undefined, NaN, 0 dan "" adalah tidak benar; semua selain itu adalah benar.
// Peringatan, 0 adalah tidak benar dan "0" adalah benar, walaupun 0 == "0".
///////////////////////////////////
// 2. Pembolehubah, Array dan Objek
// Pembolehubah digunakan dengan kata kunci 'var'. Javascript ialah sebuah
// bahasa aturcara yang jenisnya dinamik, maka anda tidak perlu spesifikasikan
// jenis pembolehubah. Penetapan menggunakan satu '=' karakter.
var someVar = 5;
// jika anda tinggalkan kata kunci var, anda tidak akan dapat ralat...
someOtherVar = 10;
// ...tetapi pembolehubah anda akan dicipta di dalam skop global, bukan di
// dalam skop anda menciptanya.
// Pembolehubah yang dideklarasikan tanpa ditetapkan sebarang nilai akan
// ditetapkan kepada undefined.
var someThirdVar; // = undefined
// jika anda ingin mendeklarasikan beberapa pembolehubah, maka anda boleh
// menggunakan koma sebagai pembahagi
var someFourthVar = 2, someFifthVar = 4;
// Terdapat cara mudah untuk melakukan operasi - operasi matematik pada
// pembolehubah:
someVar += 5; // bersamaan dengan someVar = someVar +5; someVar sama dengan 10 sekarang
someVar *= 10; // sekarang someVar bernilai 100
// dan cara lebih mudah untuk penambahan atau penolakan 1
someVar++; // sekarang someVar ialah 101
someVar--; // kembali kepada 100
// Array adalah senarai nilai yang tersusun, yang boleh terdiri daripada
// pembolehubah pelbagai jenis.
var myArray = ["Hello", 45, true];
// Setiap ahli array boleh diakses menggunakan syntax kurungan-petak.
// Indeks array bermula pada sifar.
myArray[1]; // = 45
// Array boleh diubah dan mempunyai panjang yang tidak tetap dan boleh ubah.
myArray.push("World");
myArray.length; // = 4
// Tambah/Ubah di index yang spesifik
myArray[3] = "Hello";
// Objek javascript adalah sama dengan "dictionaries" atau "maps" dalam bahasa
// aturcara yang lain: koleksi pasangan kunci-nilai yang tidak mempunyai
// sebarang susunan.
var myObj = {key1: "Hello", key2: "World"};
// Kunci adalah string, tetapi 'quote' tidak diperlukan jika ia adalah pengecam
// javascript yang sah. Nilai boleh mempunyai sebarang jenis.
var myObj = {myKey: "myValue", "my other key": 4};
// Ciri - ciri objek boleh juga diakses menggunakan syntax subskrip (kurungan-
// petak),
myObj["my other key"]; // = 4
// ... atau menggunakan syntax titik, selagi kuncinya adalah pengecam yang sah.
myObj.myKey; // = "myValue"
// Objek adalah boleh diubah; nilai boleh diubah dan kunci baru boleh ditambah.
myObj.myThirdKey = true;
// Jika anda cuba untuk akses nilai yang belum ditetapkan, anda akan mendapat
// undefined.
myObj.myFourthKey; // = undefined
///////////////////////////////////
// 3. Logik dan Struktur Kawalan
// Syntax untuk bahagian ini adalah hampir sama dengan Java.
// Struktur `if` berfungsi seperti yang anda jangkakan.
var count = 1;
if (count == 3){
// dinilai jika count ialah 3
} else if (count == 4){
// dinilai jika count ialah 4
} else {
// dinilai jika count bukan 3 atau 4
}
// Sama juga dengan `while`.
while (true){
// Sebuah ulangan yang tidak terhingga!
// An infinite loop!
}
// Ulangan do-while adalah sama dengan ulangan while, kecuali ia akan diulang
// sekurang-kurangnya sekali.
var input;
do {
input = getInput();
} while (!isValid(input))
// Ulangan `for` adalah sama dengan C dan Java:
// Persiapan; kondisi untuk bersambung; pengulangan.
for (var i = 0; i < 5; i++){
// akan berulang selama 5 kali
}
// Pernyataan ulangan For/In akan mengulang setiap ciri seluruh jaringan
// 'prototype'
var description = "";
var person = {fname:"Paul", lname:"Ken", age:18};
for (var x in person){
description += person[x] + " ";
}
// Jika anda cuma mahu mengambil kira ciri - ciri yang ditambah pada objek it
// sendiri dan bukan 'prototype'nya, sila gunakan semakan hasOwnProperty()
var description = "";
var person = {fname:"Paul", lname:"Ken", age:18};
for (var x in person){
if (person.hasOwnProperty(x)){
description += person[x] + " ";
}
}
// for/in tidak sepatutnya digunakan untuk mengulang sebuah Array di mana
// indeks susunan adalah penting.
// Tiada sebarang jaminan bahawa for/in akan mengembalikan indeks dalam
// mana - mana susunan
// && adalah logikal dan, || adalah logikal atau
if (house.size == "big" && house.colour == "blue"){
house.contains = "bear";
}
if (colour == "red" || colour == "blue"){
// warna adalah sama ada 'red' atau 'blue'
}
// && dan || adalah "lintar pintas", di mana ia berguna untuk menetapkan
// nilai asal.
var name = otherName || "default";
// Pernyataan `switch` menyemak persamaan menggunakan `===`.
// gunakan pernyataan `break` selepas setiap kes
// atau tidak, kes - kes selepas kes yang betul akan dijalankan juga.
grade = 'B';
switch (grade) {
case 'A':
console.log("Great job");
break;
case 'B':
console.log("OK job");
break;
case 'C':
console.log("You can do better");
break;
default:
console.log("Oy vey");
break;
}
///////////////////////////////////
// 4. Functions, Skop dan Closures
// Function javascript dideklarasikan dengan kata kunci `function`.
function myFunction(thing){
return thing.toUpperCase();
}
myFunction("foo"); // = "FOO"
// Perhatikan yang nilai yang dikembalikan mesti bermula pada baris yang sama
// dengan kata kunci `return`, jika tidak, anda akan sentiasa mengembalikan
// `undefined` disebabkan kemasukan 'semicolon' secara automatik. Sila berjaga -
// jaga dengan hal ini apabila menggunakan Allman style.
function myFunction(){
return // <- semicolon dimasukkan secara automatik di sini
{thisIsAn: 'object literal'}
}
myFunction(); // = undefined
// Function javascript adalah objek kelas pertama, maka ia boleh diberikan
// nama pembolehubah yang lain dan diberikan kepada function yang lain sebagai
// input - sebagai contoh, apabila membekalkan pengendali event:
function myFunction(){
// kod ini akan dijalankan selepas 5 saat
}
setTimeout(myFunction, 5000);
// Nota: setTimeout bukan sebahagian daripada bahasa JS, tetapi ia disediakan
// oleh pelayar web dan Node.js.
// Satu lagi function yang disediakan oleh pelayar web adalah setInterval
function myFunction(){
// kod ini akan dijalankan setiap 5 saat
}
setInterval(myFunction, 5000);
// Objek function tidak perlu dideklarasikan dengan nama - anda boleh menulis
// function yang tidak bernama didalam input sebuah function lain.
setTimeout(function(){
// kod ini akan dijalankan dalam 5 saat
}, 5000);
// Javascript mempunyai skop function; function mempunyai skop mereka
// tersendiri tetapi blok tidak.
if (true){
var i = 5;
}
i; // = 5 - bukan undefined seperti yang anda jangkakan di dalam bahasa blok-skop
// Ini telah menyebabkan corak biasa iaitu "immediately-executing anonymous
// functions", yang mengelakkan pembolehubah sementara daripada bocor ke
// skop global.
(function(){
var temporary = 5;
// Kita boleh akses skop global dengan menetapkan nilai ke "objek global",
// iaitu dalam pelayar web selalunya adalah `window`. Objek global mungkin
// mempunyai nama yang berlainan dalam alam bukan pelayar web seperti Node.js.
window.permanent = 10;
})();
temporary; // akan menghasilkan ralat ReferenceError
permanent; // = 10
// Salah satu ciri terhebat Javascript ialah closure. Jika sebuah function
// didefinisikan di dalam sebuah function lain, function yang di dalam akan
// mempunyai akses kepada semua pembolehubah function yang di luar, mahupun
// selepas function yang di luar tersebut selesai.
function sayHelloInFiveSeconds(name){
var prompt = "Hello, " + name + "!";
// Function dalam diletakkan di dalam skop lokal secara asal, seperti
// ia dideklarasikan dengan `var`.
function inner(){
alert(prompt);
}
setTimeout(inner, 5000);
// setTimeout adalah tak segerak atau asinkroni, maka function sayHelloInFiveSeconds akan selesai serta merta, dan setTimeout akan memanggil
// inner selepas itu. Walaubagaimanapun, disebabkan inner terletak didalam
// sayHelloInFiveSeconds, inner tetap mempunyai akses kepada pembolehubah
// `prompt` apabila ia dipanggil.
}
sayHelloInFiveSeconds("Adam"); // akan membuka sebuah popup dengan "Hello, Adam!" selepas 5s
///////////////////////////////////
// 5. Lagi tentang Objek, Constructor dan Prototype
// Objek boleh mengandungi function.
var myObj = {
myFunc: function(){
return "Hello world!";
}
};
myObj.myFunc(); // = "Hello world!"
// Apabila function sesebuah object dipanggil, ia boleh mengakses objek asalnya
// dengan menggunakan kata kunci `this`.
myObj = {
myString: "Hello world!",
myFunc: function(){
return this.myString;
}
};
myObj.myFunc(); // = "Hello world!"
// Nilai sebenar yang ditetapkan kepada this akan ditentukan oleh bagaimana
// sesebuah function itu dipanggil, bukan dimana ia didefinisikan. Oleh it,
// sesebuah function tidak akan berfungsi jika ia dipanggil bukan pada konteks
// objeknya.
var myFunc = myObj.myFunc;
myFunc(); // = undefined
// Sebaliknya, sebuah function boleh ditetapkan kepada objek dan mendapat akses
// kepada objek itu melalui `this`, walaupun ia tidak ditetapkan semasa ia
// didefinisikan.
var myOtherFunc = function(){
return this.myString.toUpperCase();
}
myObj.myOtherFunc = myOtherFunc;
myObj.myOtherFunc(); // = "HELLO WORLD!"
// Kita juga boleh menentukan konteks untuk sebuah function dijalankan apabila
// ia dipanggil menggunakan `call` atau `apply`.
var anotherFunc = function(s){
return this.myString + s;
}
anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
// Function `apply` adalah hampir sama, tetapi ia mengambil sebuah array
// sebagai senarai input.
anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
// Ini sangat berguna apabila menggunakan sebuah function yang menerima senarai
// input dan anda mahu menggunakan sebuah array sebagai input.
Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (uh-oh!)
Math.min.apply(Math, [42, 6, 27]); // = 6
// Tetapi, `call` dan `apply` adalah hanya sementara, sebagaimana hidup ini.
// Apabila kita mahu ia kekal, kita boleh menggunakan `bind`.
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
// `bind` boleh juga digunakan untuk menggunakan sebuah function tidak
// sepenuhnya (curry).
var product = function(a, b){ return a * b; }
var doubler = product.bind(this, 2);
doubler(8); // = 16
// Apabila anda memanggil sebuah function dengan kata kunci `new`, sebuah
// objek baru akan dicipta dan dijadikan tersedia kepada function itu melalui
// kata kunci `this`. Function yang direka bentuk untuk dipanggil sebegitu rupa
// dikenali sebagai constructors.
var MyConstructor = function(){
this.myNumber = 5;
}
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
// Setiap objek JavaScript mempunyai `prototype`. Apabila anda akses sesuatu
// ciri sebuah objek yang tidak wujud dalam objek sebenar itu, interpreter akan
// mencari ciri itu didalam `prototype`nya.
// Sebahagian implementasi JS membenarkan anda untuk akses prototype sebuah
// objek pada ciri istimewa `__proto__`. Walaupun ini membantu dalam menerangkan
// mengenai prototypes, ia bukan sebahagian dari piawai; kita akan melihat
// cara - cara piawai untuk menggunakan prototypes nanti.
var myObj = {
myString: "Hello world!"
};
var myPrototype = {
meaningOfLife: 42,
myFunc: function(){
return this.myString.toLowerCase()
}
};
myObj.__proto__ = myPrototype;
myObj.meaningOfLife; // = 42
// Ini berfungsi untuk function juga.
myObj.myFunc(); // = "hello world!"
// Sudah pasti, jika ciri anda bukan pada prototype anda, prototype kepada
// prototype anda akan disemak, dan seterusnya.
myPrototype.__proto__ = {
myBoolean: true
};
myObj.myBoolean; // = true
// Tiada penyalinan terlibat disini; setiap objek menyimpan rujukan kepada
// prototypenya sendiri. Ini bermaksud, kita boleh mengubah prototypenya dan
// pengubahsuaian itu akan dilihat dan berkesan dimana sahaja.
myPrototype.meaningOfLife = 43;
myObj.meaningOfLife; // = 43
// Kami menyatakan yang `__proto__` adalah bukan piawai, dan tiada cara rasmi
// untuk mengubah prototype sesebuah objek. Walaubagaimanapun, terdapat dua
// cara untuk mencipta objek baru dengan sesebuah prototype.
// Yang pertama ialah Object.create, yang merupakan tambahan terbaru pada JS,
// dan oleh itu tiada dalam semua implementasi buat masa ini.
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
// Cara kedua, yang boleh digunakan dimana sahaja, adalah berkaitan dengan
// constructor. Constructors mempunyai sebuah ciri yang dipanggil prototype.
// Ini *bukan* prototype constructor terbabit; tetapi, ia adalah prototype yang
// diberikan kepada objek baru apabila ia dicipta menggunakan constructor dan
// kata kunci new.
MyConstructor.prototype = {
myNumber: 5,
getMyNumber: function(){
return this.myNumber;
}
};
var myNewObj2 = new MyConstructor();
myNewObj2.getMyNumber(); // = 5
myNewObj2.myNumber = 6
myNewObj2.getMyNumber(); // = 6
// Jenis yang terbina sedia seperti string dan nombor juga mempunyai constructor
// yang mencipta objek pembalut yang serupa.
var myNumber = 12;
var myNumberObj = new Number(12);
myNumber == myNumberObj; // = true
// Kecuali, mereka sebenarnya tak sama sepenuhnya.
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
if (0){
// Kod ini tidak akan dilaksanakan, kerana 0 adalah tidak benar.
}
// Walaubagaimanapun, pembalut objek dan jenis terbina yang biasa berkongsi
// prototype, maka sebagai contoh, anda sebenarnya boleh menambah fungsi
// kepada string.
String.prototype.firstCharacter = function(){
return this.charAt(0);
}
"abc".firstCharacter(); // = "a"
// Fakta ini selalu digunakan dalam "polyfilling", iaitu melaksanakan fungsi
// baru JavaScript didalam subset JavaScript yang lama, supaya ia boleh
// digunakan di dalam persekitaran yang lama seperti pelayar web yang lama.
// Sebagai contoh, kami menyatakan yang Object.create belum lagi tersedia
// di semua implementasi, tetapi kita masih boleh menggunakannya dengan polyfill:
if (Object.create === undefined){ // jangan ganti jika ia sudah wujud
Object.create = function(proto){
// buat satu constructor sementara dengan prototype yang betul
var Constructor = function(){};
Constructor.prototype = proto;
// kemudian gunakannya untuk mencipta objek baru yang diberikan
// prototype yang betul
return new Constructor();
}
}
```
## Bacaan Lanjut
[Mozilla Developer Network][1] menyediakan dokumentasi yang sangat baik untuk
JavaScript kerana ia digunakan di dalam pelayar - pelayar web. Tambahan pula,
ia adalah sebuah wiki, maka, sambil anda belajar lebih banyak lagi, anda boleh
membantu orang lain dengan berkongsi pengetahuan anda.
[A re-introduction to JavaScript][2] oleh MDN meliputi semua konsep yang
diterangkan di sini dengan lebih terperinci. Panduan ini menerangkan bahasa
aturcara JavaScript dengan agak mudah; jika anda mahu belajar lebih lanjut
tentang menggunakan JavaScript didalam laman web, mulakan dengan mempelajari
tentang [Document Object Model][3].
[Learn Javascript by Example and with Challenges][4] adalah variasi panduan ini
dengan cabaran yang tersedia pakai.
[JavaScript Garden][5] pula adalah panduan yang lebih terperinci mengenai
semua bahagian bahasa aturcara ini yang bertentangan dengan naluri atau
kebiasaan.
[JavaScript: The Definitive Guide][6] adalah panduan klasik dan buku rujukan.
Selain daripada penyumbang terus kepada artikel ini, sebahagian kandungannya
adalah adaptasi daripada tutorial Python Louie Dinh di dalam laman web ini,
dan [JS Tutorial][7] di Mozilla Developer Network.
[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
[4]: http://www.learneroo.com/modules/64/nodes/350
[5]: http://bonsaiden.github.io/JavaScript-Garden/
[6]: http://www.amazon.com/gp/product/0596805527/
[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript

102
ms-my/json-my.html.markdown Normal file
View File

@ -0,0 +1,102 @@
---
language: json
filename: learnjson-ms.json
contributors:
- ["Anna Harren", "https://github.com/iirelu"]
- ["Marco Scannadinari", "https://github.com/marcoms"]
- ["himanshu", "https://github.com/himanshu81494"]
- ["Michael Neth", "https://github.com/infernocloud"]
translators:
- ["abdalim", "https://github.com/abdalim"]
lang: ms-my
---
Disebabkan JSON adalah format pertukaran-data yang sangat ringkas, panduan ini
kemungkinan besar adalah Learn X in Y Minutes yang paling mudah.
JSON dalam bentuk paling aslinya sebenarnya tidak mempunyai sebarang komentar,
tetapi kebanyakan pembaca menerima komen dalam bentuk C (`\\`,`/* */`). Beberapa
pembaca juga bertoleransi terhadap koma terakhir (iaitu koma selepas elemen
terakhir di dalam array atau selepas ciri terakhir sesuatu objek), tetapi semua
ini harus dielakkan dan dijauhkan untuk keserasian yang lebih baik.
Untuk tujuan ini bagaimanapun, semua di dalam panduan ini adalah 100% JSON yang
sah. Luckily, it kind of speaks for itself.
Sebuah nilai JSON harus terdiri dari salah satu, iaitu, nombor, string, array,
objek atau salah satu dari nama literal berikut: true, false, null.
Pelayar web yang menyokong adalah: Firefox 3.5+, Internet Explorer 8.0+, Chrome
1.0+, Opera 10.0+, dan Safari 4.0+.
Sambungan fail untuk fail - fail JSON adalah ".json" dan jenis MIME untuk teks
JSON adalah "application/json".
Banyak bahasa aturcara mempunyai fungsi untuk menyirikan (mengekod) dan
menyah-sirikan (men-dekod) data JSON kepada struktur data asal. Javascript
mempunyai sokongon tersirat untuk memanipulasi teks JSON sebagai data.
Maklumat lebih lanjut boleh dijumpai di http://www.json.org/
JSON dibina pada dua struktur:
* Sebuah koleksi pasangan nama/nilai. Di dalam pelbagai bahasa aturcara, ini
direalisasikan sebagai objek, rekod, "struct", "dictionary", "hash table",
senarai berkunci, atau "associative array".
* Sebuah senarai nilai yang tersusun. Dalam kebanyakan bahasa aturcara, ini
direalisasikan sebagai array, vektor, senarai atau urutan.
Sebuah objek dengan pelbagai pasangan nama/nilai.
```json
{
"kunci": "nilai",
"kekunci": "harus sentiasa dibalut dengan 'double quotes'",
"nombor": 0,
"strings": "Hellø, wørld. Semua unicode dibenarkan, bersama \"escaping\".",
"ada bools?": true,
"tiada apa - apa": null,
"nombor besar": 1.2e+100,
"objek": {
"komen": "Sebahagian besar struktur akan terdiri daripada objek.",
"array": [0, 1, 2, 3, "Array boleh mempunyai sebarang jenis data di dalamnya.", 5],
"objek lain": {
"komen": "Objek boleh dibina dengan pelbagai lapisan, sangat berguna."
}
},
"kebendulan": [
{
"punca potassium": ["pisang"]
},
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, "neo"],
[0, 0, 0, 1]
]
],
"stail alternatif": {
"komen": "cuba lihat ini!"
, "posisi koma": "tidak mengapa - selagi ia adalah sebelum nama atau kunci seterusnya, maka ia sah"
, "komen lain": "sungguh bagus"
}
}
```
Sebuah array sahaja yang mengandungi nilai - nilai juga adalah JSON yang sah.
```json
[1, 2, 3, "text", true]
```
Objek - objek boleh menjadi sebahagian dari array juga.
```json
[{"nama": "Abe", "umur": 25}, {"nama": "Jemah", "umur": 29}, {"name": "Yob", "umur": 31}]
```

235
nl-nl/amd-nl.html.markdown Normal file
View File

@ -0,0 +1,235 @@
---
category: tool
tool: amd
contributors:
- ["Frederik Ring", "https://github.com/m90"]
translators:
- ["Reinoud Kruithof", "https://github.com/reinoudk"]
filename: learnamd-nl.js
lang: nl-nl
---
## Aan de slag met AMD
De **Asynchronous Module Definition** API specificeert een mechanisme om JavaScript
modules the definiëren zodat de module en dependencies (afhankelijkheden) asynchroon
geladen kunnen worden. Dit is vooral erg geschikt voor de browseromgeving, waar het
synchroon laden van modules zorgt voor problemen qua prestatie, gebruiksvriendelijkheid,
debugging en cross-domain toegangsproblemen.
### Basis concept
```javascript
// De basis AMD API bestaat uit niks meer dan twee methodes: `define` en `require`
// and gaat vooral over de definitie en gebruik van modules:
// `define(id?, dependencies?, factory)` definieert een module
// `require(dependencies, callback)` importeert een set van dependencies en
// gebruikt ze in de gegeven callback
// Laten we starten met het gebruiken van define om een nieuwe module (met naam)
// te creëeren, welke geen dependencies heeft. Dit doen we door een naam
// en een zogeheten factory functie door te geven aan define:
define('awesomeAMD', function(){
var isAMDAwesome = function(){
return true;
};
// De return waarde van een module's factory functie is
// wat andere modules of require calls ontvangen wanneer
// ze onze `awesomeAMD` module requiren.
// De geëxporteerde waarde kan van alles zijn: (constructor) functies,
// objecten, primitives, zelfs undefined (hoewel dat niet veel nut heeft).
return isAMDAwesome;
});
// We gaan nu een andere module defineren die afhankelijk is van onze
// `awesomeAMD` module. Merk hierbij op dat er nu een extra functieargument
// is die de dependencies van onze module defineert:
define('schreewlelijk', ['awesomeAMD'], function(awesomeAMD){
// dependencies worden naar de factory's functieargumenten
// gestuurd in de volgorde waarin ze gespecificeert zijn
var vertelIedereen = function(){
if (awesomeAMD()){
alert('Dit is zOoOo cool!');
} else {
alert('Vrij saai, niet?');
}
};
return vertelIedereen;
});
// Nu we weten hoe we define moeten gebruiken, kunnen we require gebruiken
// om ons programma mee te starten. De vorm van `require` is
// `(arrayVanDependencies, callback)`.
require(['schreeuwlelijk'], function(schreewlelijk){
schreeuwlelijk();
});
// Om deze tutorial code uit te laten voeren, gaan we hier een vrij basic
// (niet-asynchrone) versie van AMD implementeren:
function define(naam, deps, factory){
// merk op hoe modules zonder dependencies worden afgehandeld
define[naam] = require(factory ? deps : [], factory || deps);
}
function require(deps, callback){
var args = [];
// we halen eerst alle dependecies op die nodig zijn
// om require aan te roepen
for (var i = 0; i < deps.length; i++){
args[i] = define[deps[i]];
}
// voldoe aan alle dependencies van de callback
return callback.apply(null, args);
}
// je kan deze code hier in actie zien (Engels): http://jsfiddle.net/qap949pd/
```
### require.js in de echte wereld
In contrast met het voorbeeld uit de introductie, implementeert `require.js`
(de meest populaire AMD library) de **A** in **AMD**. Dit maakt het mogelijk
om je modules en hun dependencies asynchroon in the laden via XHR:
```javascript
/* file: app/main.js */
require(['modules/someClass'], function(SomeClass){
// de callback word uitgesteld tot de dependency geladen is
var things = new SomeClass();
});
console.log('Dus, hier wachten we!'); // dit wordt als eerste uitgevoerd
```
De afspraak is dat je over het algemeen één module in één bestand opslaat.
`require.js` kan module-namen achterhalen gebaseerd op de bestandslocatie,
dus je hoeft je module geen naam te geven. Je kan simpelweg aan ze referen
door hun locatie te gebruiken.
In het voorbeeld nemen we aan dat `someClass` aanwezig is in de `modules` map,
relatief ten opzichte van de `baseUrl` uit je configuratie.
* app/
* main.js
* modules/
* someClass.js
* someHelpers.js
* ...
* daos/
* things.js
* ...
Dit betekent dat we `someClass` kunnen defineren zonder een module-id te specificeren:
```javascript
/* file: app/modules/someClass.js */
define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
// definitie van de module gebeurt, natuurlijk, ook asynchroon
function SomeClass(){
this.method = function(){/**/};
// ...
}
return SomeClass;
});
```
Gebruik `requirejs.config(configObj)` om het gedrag van de standaard mapping
aan te passen in je `main.js`:
```javascript
/* file: main.js */
requirejs.config({
baseUrl : 'app',
paths : {
// je kan ook modules uit andere locatie inladen
jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
coolLibUitBower : '../bower_components/cool-lib/coollib'
}
});
require(['jquery', 'coolLibUitBower', 'modules/someHelpers'], function($, coolLib, helpers){
// een `main` bestand moet require minstens eenmaal aanroepen,
// anders zal er geen code uitgevoerd worden
coolLib.doFancyDingenMet(helpers.transform($('#foo')));
});
```
Op `require.js` gebaseerde apps hebben vaak een enkel beginpunt (`main.js`)
welke toegevoegd wordt aan de `require.js` script tag als een data-attribuut.
Deze zal automisch geladen en uitgevoerd worden als de pagina laadt:
```html
<!DOCTYPE html>
<html>
<head>
<title>Honder script tags? Nooi meer!</title>
</head>
<body>
<script src="require.js" data-main="app/main"></script>
</body>
</html>
```
### Een heel project optimaliseren met r.js
Veel mensen geven er de voorkeur aan om AMD te gebruiken tijdens de
ontwikkelfase om code op een gezonde manier te organiseren maar
willen nog steeds een enkel scriptbestand gebruiken in productie in
plaats van honderderen XHR verzoeken uit te voeren als de pagina laadt.
`require.js` wordt geleverd met een script genaamd `r.js` (die je waarschijnlijk
uitvoert in node.js, hoewel Rhino ook ondersteund wordt) welke de
dependency book van je project analyseert en een enkel bestand bouwt met daarin
al je module (juist genaamd), geminificeerd en klaar voor productie.
Instaleren met `npm`:
```shell
$ npm install requirejs -g
```
Nu kun je het een configuratiebestand voeden:
```shell
$ r.js -o app.build.js
```
Voor ons bovenstaande voorbeeld zou de configuratie er zo uit kunnen zien:
```javascript
/* file : app.build.js */
({
name : 'main', // naam van het beginpunt
out : 'main-built.js', // naam van het bestand waar de output naar geschreven wordt
baseUrl : 'app',
paths : {
// `empty:` verteld r.js dat dee nog steeds geladen moet worden van de CDN,
// gebruik makend van de locatie gespecificeert in `main.js`
jquery : 'empty:',
coolLibUitBower : '../bower_components/cool-lib/coollib'
}
})
```
Verwissel simpelweg `data-main` om het gebouwde bestand te gebruiken in productie:
```html
<script src="require.js" data-main="app/main-built"></script>
```
Een erg gedetaileerd [overzicht van bouwopties](https://github.com/jrburke/r.js/blob/master/build/example.build.js) is
beschikbar in de GitHub repo (Engels).
Hieronder vind je nog meer informatie over AMD (Engels).
### Onderwerpen die niet aan bod zijn gekomen
* [Loader plugins / transforms](http://requirejs.org/docs/plugins.html)
* [CommonJS style loading and exporting](http://requirejs.org/docs/commonjs.html)
* [Advanced configuration](http://requirejs.org/docs/api.html#config)
* [Shim configuration (loading non-AMD modules)](http://requirejs.org/docs/api.html#config-shim)
* [CSS loading and optimizing with require.js](http://requirejs.org/docs/optimization.html#onecss)
* [Using almond.js for builds](https://github.com/jrburke/almond)
### Verder lezen:
* [Official Spec](https://github.com/amdjs/amdjs-api/wiki/AMD)
* [Why AMD?](http://requirejs.org/docs/whyamd.html)
* [Universal Module Definition](https://github.com/umdjs/umd)
### Implementaties:
* [require.js](http://requirejs.org)
* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
* [cujo.js](http://cujojs.com/)
* [curl.js](https://github.com/cujojs/curl)
* [lsjs](https://github.com/zazl/lsjs)
* [mmd](https://github.com/alexlawrence/mmd)

53
objective-c.html.markdown
View File

@ -1,13 +1,12 @@
--- ---
language: Objective-C language: Objective-C
contributors: contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"] - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- ["Yannick Loriot", "https://github.com/YannickL"] - ["Yannick Loriot", "https://github.com/YannickL"]
- ["Levi Bostian", "https://github.com/levibostian"] - ["Levi Bostian", "https://github.com/levibostian"]
- ["Clayton Walker", "https://github.com/cwalk"] - ["Clayton Walker", "https://github.com/cwalk"]
- ["Fernando Valverde", "http://visualcosita.xyz"]
filename: LearnObjectiveC.m filename: LearnObjectiveC.m
--- ---
Objective-C is the main programming language used by Apple for the OS X and iOS operating systems and their respective frameworks, Cocoa and Cocoa Touch. Objective-C is the main programming language used by Apple for the OS X and iOS operating systems and their respective frameworks, Cocoa and Cocoa Touch.
@ -20,6 +19,10 @@ It is a general-purpose, object-oriented programming language that adds Smalltal
Multi-line comments look like this Multi-line comments look like this
*/ */
// XCode supports pragma mark directive that improve jump bar readability
#pragma mark Navigation Functions // New tag on jump bar named 'Navigation Functions'
#pragma mark - Navigation Functions // Same tag, now with a separator
// Imports the Foundation headers with #import // Imports the Foundation headers with #import
// Use <> to import global files (in general frameworks) // Use <> to import global files (in general frameworks)
// Use "" to import local files (from project) // Use "" to import local files (from project)
@ -599,6 +602,52 @@ int main (int argc, const char * argv[]) {
@end @end
// Starting in Xcode 7.0, you can create Generic classes,
// allowing you to provide greater type safety and clarity
// without writing excessive boilerplate.
@interface Result<__covariant A> : NSObject
- (void)handleSuccess:(void(^)(A))success
failure:(void(^)(NSError *))failure;
@property (nonatomic) A object;
@end
// we can now declare instances of this class like
Result<NSNumber *> *result;
Result<NSArray *> *result;
// Each of these cases would be equivalent to rewriting Result's interface
// and substituting the appropriate type for A
@interface Result : NSObject
- (void)handleSuccess:(void(^)(NSArray *))success
failure:(void(^)(NSError *))failure;
@property (nonatomic) NSArray * object;
@end
@interface Result : NSObject
- (void)handleSuccess:(void(^)(NSNumber *))success
failure:(void(^)(NSError *))failure;
@property (nonatomic) NSNumber * object;
@end
// It should be obvious, however, that writing one
// Class to solve a problem is always preferable to writing two
// Note that Clang will not accept generic types in @implementations,
// so your @implemnation of Result would have to look like this:
@implementation Result
- (void)handleSuccess:(void (^)(id))success
failure:(void (^)(NSError *))failure {
// Do something
}
@end
/////////////////////////////////////// ///////////////////////////////////////
// Protocols // Protocols
/////////////////////////////////////// ///////////////////////////////////////

31
perl6.html.markdown
View File

@ -1,10 +1,9 @@
--- ---
name: perl6
category: language category: language
language: perl6 language: perl6
filename: learnperl6.pl filename: learnperl6.pl
contributors: contributors:
- ["Nami-Doc", "http://github.com/Nami-Doc"] - ["vendethiel", "http://github.com/vendethiel"]
--- ---
Perl 6 is a highly capable, feature-rich programming language made for at Perl 6 is a highly capable, feature-rich programming language made for at
@ -104,7 +103,7 @@ sub say-hello-to(Str $name) { # You can provide the type of an argument
## It can also have optional arguments: ## It can also have optional arguments:
sub with-optional($arg?) { # the "?" marks the argument optional sub with-optional($arg?) { # the "?" marks the argument optional
say "I might return `(Any)` (Perl's "null"-like value) if I don't have say "I might return `(Any)` (Perl's 'null'-like value) if I don't have
an argument passed, or I'll return my argument"; an argument passed, or I'll return my argument";
$arg; $arg;
} }
@ -374,6 +373,8 @@ say @array[^10]; # you can pass arrays as subscripts and it'll return
say join(' ', @array[15..*]); #=> 15 16 17 18 19 say join(' ', @array[15..*]); #=> 15 16 17 18 19
# which is equivalent to: # which is equivalent to:
say join(' ', @array[-> $n { 15..$n }]); say join(' ', @array[-> $n { 15..$n }]);
# Note: if you try to do either of those with an infinite array,
# you'll trigger an infinite loop (your program won't finish)
# You can use that in most places you'd expect, even assigning to an array # You can use that in most places you'd expect, even assigning to an array
my @numbers = ^20; my @numbers = ^20;
@ -735,7 +736,7 @@ try {
# You can throw an exception using `die`: # You can throw an exception using `die`:
die X::AdHoc.new(payload => 'Error !'); die X::AdHoc.new(payload => 'Error !');
# You can access the last exception with `$!` (usually used in a `CATCH` block) # You can access the last exception with `$!` (use `$_` in a `CATCH` block)
# There are also some subtelties to exceptions. Some Perl 6 subs return a `Failure`, # There are also some subtelties to exceptions. Some Perl 6 subs return a `Failure`,
# which is a kind of "unthrown exception". They're not thrown until you tried to look # which is a kind of "unthrown exception". They're not thrown until you tried to look
@ -763,7 +764,8 @@ try {
# and `enum`) are actually packages. (Packages are the lowest common denominator) # and `enum`) are actually packages. (Packages are the lowest common denominator)
# Packages are important - especially as Perl is well-known for CPAN, # Packages are important - especially as Perl is well-known for CPAN,
# the Comprehensive Perl Archive Network. # the Comprehensive Perl Archive Network.
# You usually don't use packages directly: you use `class Package::Name::Here;`, # You're not supposed to use the package keyword, usually:
# you use `class Package::Name::Here;` to declare a class,
# or if you only want to export variables/subs, you can use `module`: # or if you only want to export variables/subs, you can use `module`:
module Hello::World { # Bracketed form module Hello::World { # Bracketed form
# If `Hello` doesn't exist yet, it'll just be a "stub", # If `Hello` doesn't exist yet, it'll just be a "stub",
@ -774,11 +776,6 @@ unit module Parse::Text; # file-scoped form
grammar Parse::Text::Grammar { # A grammar is a package, which you could `use` grammar Parse::Text::Grammar { # A grammar is a package, which you could `use`
} }
# NOTE for Perl 5 users: even though the `package` keyword exists,
# the braceless form is invalid (to catch a "perl5ism"). This will error out:
# package Foo; # because Perl 6 will think the entire file is Perl 5
# Just use `module` or the brace version of `package`.
# You can use a module (bring its declarations into scope) with `use` # You can use a module (bring its declarations into scope) with `use`
use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
say from-json('[1]').perl; #=> [1] say from-json('[1]').perl; #=> [1]
@ -870,8 +867,16 @@ LEAVE { say "Runs everytime you leave a block, even when an exception
PRE { say "Asserts a precondition at every block entry, PRE { say "Asserts a precondition at every block entry,
before ENTER (especially useful for loops)" } before ENTER (especially useful for loops)" }
# exemple:
for 0..2 {
PRE { $_ > 1 } # This is going to blow up with "Precondition failed"
}
POST { say "Asserts a postcondition at every block exit, POST { say "Asserts a postcondition at every block exit,
after LEAVE (especially useful for loops)" } after LEAVE (especially useful for loops)" }
for 0..2 {
POST { $_ < 2 } # This is going to blow up with "Postcondition failed"
}
## * Block/exceptions phasers ## * Block/exceptions phasers
sub { sub {
@ -1239,14 +1244,14 @@ so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the left
# Group: you can group parts of your regexp with `[]`. # Group: you can group parts of your regexp with `[]`.
# These groups are *not* captured (like PCRE's `(?:)`). # These groups are *not* captured (like PCRE's `(?:)`).
so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing
so 'fooABCABCbar' ~~ / foo [ A B C ] + bar /; so 'foo012012bar' ~~ / foo [ '01' <[0..9]> ] + bar /;
# The previous line returns `True`. # The previous line returns `True`.
# We match the "ABC" 1 or more time (the `+` was applied to the group). # We match the "012" 1 or more time (the `+` was applied to the group).
# But this does not go far enough, because we can't actually get back what # But this does not go far enough, because we can't actually get back what
# we matched. # we matched.
# Capture: We can actually *capture* the results of the regexp, using parentheses. # Capture: We can actually *capture* the results of the regexp, using parentheses.
so 'fooABCABCbar' ~~ / foo ( A B C ) + bar /; # `True`. (using `so` here, `$/` below) so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # `True`. (using `so` here, `$/` below)
# So, starting with the grouping explanations. # So, starting with the grouping explanations.
# As we said before, our `Match` object is available as `$/`: # As we said before, our `Match` object is available as `$/`:

2
php.html.markdown
View File

@ -53,6 +53,8 @@ $int1 = 12; // => 12
$int2 = -12; // => -12 $int2 = -12; // => -12
$int3 = 012; // => 10 (a leading 0 denotes an octal number) $int3 = 012; // => 10 (a leading 0 denotes an octal number)
$int4 = 0x0F; // => 15 (a leading 0x denotes a hex literal) $int4 = 0x0F; // => 15 (a leading 0x denotes a hex literal)
// Binary integer literals are available since PHP 5.4.0.
$int5 = 0b11111111; // 255 (a leading 0b denotes a binary number)
// Floats (aka doubles) // Floats (aka doubles)
$float = 1.234; $float = 1.234;

159
pl-pl/python-pl.html.markdown
View File

@ -30,7 +30,7 @@ działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stron
# Pojedyncze komentarze oznaczamy takim symbolem. # Pojedyncze komentarze oznaczamy takim symbolem.
""" Wielolinijkowe napisy zapisywane są przy użyciu """ Wielolinijkowe napisy zapisywane są przy użyciu
trzech znaków cudzysłowiu i często potrójnych cudzysłowów i często
wykorzystywane są jako komentarze. wykorzystywane są jako komentarze.
""" """
@ -47,11 +47,11 @@ działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stron
10 * 2 # => 20 10 * 2 # => 20
35 / 5 # => 7 35 / 5 # => 7
# Dzielenie może być kłopotliwe. Poniższe to dzielenie # Dzielenie może być kłopotliwe. Poniższe działanie to dzielenie
# całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany. # całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany.
5 / 2 # => 2 5 / 2 # => 2
# Aby to naprawić musimy powiedzieć nieco o liczbach zmiennoprzecinkowych. # Aby to naprawić, musimy powiedzieć nieco o liczbach zmiennoprzecinkowych.
2.0 # To liczba zmiennoprzecinkowa, tzw. float 2.0 # To liczba zmiennoprzecinkowa, tzw. float
11.0 / 4.0 # => 2.75 ahhh...znacznie lepiej 11.0 / 4.0 # => 2.75 ahhh...znacznie lepiej
@ -65,7 +65,7 @@ działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stron
# Operator modulo - wyznaczanie reszty z dzielenia # Operator modulo - wyznaczanie reszty z dzielenia
7 % 3 # => 1 7 % 3 # => 1
# Potęgowanie (x do potęgi ytej) # Potęgowanie (x do potęgi y-tej)
2**4 # => 16 2**4 # => 16
# Wymuszanie pierwszeństwa w nawiasach # Wymuszanie pierwszeństwa w nawiasach
@ -83,7 +83,7 @@ False or True #=> True # Prawda
2 == True #=> False 2 == True #=> False
k1 == True #=> True k1 == True #=> True
# aby zanegować użyj "not" # aby zanegować, użyj "not"
not True # => False not True # => False
not False # => True not False # => True
@ -112,7 +112,7 @@ not False # => True
# Napisy można dodawać! # Napisy można dodawać!
"Witaj " + "świecie!" # => "Witaj świecie!" "Witaj " + "świecie!" # => "Witaj świecie!"
# ... a nawet mnożone # ... a nawet mnożyć
"Hej" * 3 # => "HejHejHej" "Hej" * 3 # => "HejHejHej"
# Napis może być traktowany jako lista znaków # Napis może być traktowany jako lista znaków
@ -124,7 +124,7 @@ not False # => True
# Jednak nowszym sposobem formatowania jest metoda "format". # Jednak nowszym sposobem formatowania jest metoda "format".
# Ta metoda jest obecnie polecana: # Ta metoda jest obecnie polecana:
"{0} są {1}".format("napisy", "fajne") "{0} są {1}".format("napisy", "fajne")
# Jeśli nie chce ci się liczyć użyj słów kluczowych. # Jeśli nie chce ci się liczyć, użyj słów kluczowych.
"{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron") "{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
# None jest obiektem # None jest obiektem
@ -135,12 +135,12 @@ None # => None
"etc" is None # => False "etc" is None # => False
None is None # => True None is None # => True
# Operator 'is' testuje identyczność obiektów. To nie jest zbyt # Operator 'is' testuje identyczność obiektów. Nie jest to zbyt
# pożyteczne, gdy działamy tylko na prostych wartościach, # pożyteczne, gdy działamy tylko na prostych wartościach,
# ale przydaje się, gdy mamy do czynienia z obiektami. # ale przydaje się, gdy mamy do czynienia z obiektami.
# None, 0, i pusty napis "" są odpowiednikami logicznego False. # None, 0 i pusty napis "" są odpowiednikami logicznego False.
# Wszystkie inne wartości są True # Wszystkie inne wartości są uznawane za prawdę (True)
bool(0) # => False bool(0) # => False
bool("") # => False bool("") # => False
@ -149,20 +149,20 @@ bool("") # => False
## 2. Zmienne i zbiory danych ## 2. Zmienne i zbiory danych
#################################################### ####################################################
# Python ma wyrażenie wypisujące "print" we wszystkich wersjach 2.x, ale # Python ma instrukcję wypisującą "print" we wszystkich wersjach 2.x, ale
# zostało usunięte z wersji 3. # została ona usunięta z wersji 3.
print "Jestem Python. Miło poznać!" print "Jestem Python. Miło Cię poznać!"
# Python ma też funkcję "print" dostępną w wersjach 2.7 and 3... # Python ma też funkcję "print" dostępną w wersjach 2.7 i 3...
# ale w 2.7 musisz dodać import (odkomentuj): # ale w 2.7 musisz dodać import (odkomentuj):
# from __future__ import print_function # from __future__ import print_function
print("Ja też jestem Python! ") print("Ja też jestem Python! ")
# Nie trzeba deklarować zmiennych przed przypisaniem. # Nie trzeba deklarować zmiennych przed przypisaniem.
jakas_zmienna = 5 # Konwencja mówi: używaj małych znaków i kładki _ jakas_zmienna = 5 # Konwencja mówi: używaj małych liter i znaków podkreślenia _
jakas_zmienna # => 5 jakas_zmienna # => 5
# Próba dostępu do niezadeklarowanej zmiennej da błąd. # Próba dostępu do niezadeklarowanej zmiennej da błąd.
# Przejdź do sekcji Obsługa wyjątków po więcej... # Przejdź do sekcji Obsługa wyjątków, aby dowiedzieć się więcej...
inna_zmienna # Wyrzuca nazwę błędu inna_zmienna # Wyrzuca nazwę błędu
# "if" może być użyte jako wyrażenie # "if" może być użyte jako wyrażenie
@ -173,7 +173,7 @@ li = []
# Możesz zacząć od wypełnionej listy # Możesz zacząć od wypełnionej listy
inna_li = [4, 5, 6] inna_li = [4, 5, 6]
# Dodaj na koniec używając "append" # Dodaj na koniec, używając "append"
li.append(1) # li to teraz [1] li.append(1) # li to teraz [1]
li.append(2) # li to teraz [1, 2] li.append(2) # li to teraz [1, 2]
li.append(4) # li to teraz [1, 2, 4] li.append(4) # li to teraz [1, 2, 4]
@ -185,7 +185,7 @@ li.append(3) # li to znowu [1, 2, 4, 3].
# Dostęp do list jak do każdej tablicy # Dostęp do list jak do każdej tablicy
li[0] # => 1 li[0] # => 1
# Użyj = aby nadpisać wcześniej wypełnione miejsca w liście # Aby nadpisać wcześniej wypełnione miejsca w liście, użyj znaku =
li[0] = 42 li[0] = 42
li[0] # => 42 li[0] # => 42
li[0] = 1 # Uwaga: ustawiamy starą wartość li[0] = 1 # Uwaga: ustawiamy starą wartość
@ -195,7 +195,7 @@ li[-1] # => 3
# Jeżeli wyjdziesz poza zakres... # Jeżeli wyjdziesz poza zakres...
li[4] # ... zobaczysz IndexError li[4] # ... zobaczysz IndexError
# Możesz tworzyć wyniki. # Możesz też tworzyć wycinki.
li[1:3] # => [2, 4] li[1:3] # => [2, 4]
# Bez początku # Bez początku
li[2:] # => [4, 3] li[2:] # => [4, 3]
@ -213,12 +213,12 @@ del li[2] # li to teraz [1, 2, 3]
# Listy można dodawać # Listy można dodawać
li + inna_li # => [1, 2, 3, 4, 5, 6] li + inna_li # => [1, 2, 3, 4, 5, 6]
# Uwaga: wartości poszczególnych list się nie zmieniają. # Uwaga: wartości oryginalnych list li i inna_li się nie zmieniają.
# Do łączenia list użyj "extend()" # Do łączenia list użyj "extend()"
li.extend(other_li) # li to teraz [1, 2, 3, 4, 5, 6] li.extend(other_li) # li to teraz [1, 2, 3, 4, 5, 6]
# Sprawdź czy jest w liście używając "in" # Sprawdź, czy element jest w liście używając "in"
1 in li # => True 1 in li # => True
# "len()" pokazuje długość listy # "len()" pokazuje długość listy
@ -238,7 +238,7 @@ tup[:2] # => (1, 2)
# Można rozpakować krotki i listy do poszczególych zmiennych # Można rozpakować krotki i listy do poszczególych zmiennych
a, b, c = (1, 2, 3) # a to teraz 1, b jest 2, a c to 3 a, b, c = (1, 2, 3) # a to teraz 1, b jest 2, a c to 3
# Jeżeli zapomnisz nawiasów automatycznie tworzone są krotki # Jeżeli zapomnisz nawiasów, automatycznie tworzone są krotki
d, e, f = 4, 5, 6 d, e, f = 4, 5, 6
# Popatrz jak prosto zamienić wartości # Popatrz jak prosto zamienić wartości
e, d = d, e # d to teraz 5 a e to 4 e, d = d, e # d to teraz 5 a e to 4
@ -252,28 +252,28 @@ pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3}
# Podglądany wartość # Podglądany wartość
pelen_slownik["one"] # => 1 pelen_slownik["one"] # => 1
# Wypisz wszystkie klucze używając "keys()" # Wypisz wszystkie klucze, używając "keys()"
pelen_slownik.keys() # => ["trzy", "dwa", "raz"] pelen_slownik.keys() # => ["trzy", "dwa", "raz"]
# Uwaga: słowniki nie gwarantują kolejności występowania kluczy. # Uwaga: słowniki nie zapamiętują kolejności kluczy.
# A teraz wszystkie wartości "values()" # A teraz wszystkie wartości "values()"
pelen_slownik.values() # => [3, 2, 1] pelen_slownik.values() # => [3, 2, 1]
# Uwaga: to samo dotyczy wartości. # Uwaga: to samo dotyczy wartości.
# Sprawdzanie czy występuje to "in" # Sprawdzanie czy klucz występuje w słowniku za pomocą "in"
"raz" in pelen_slownik # => True "raz" in pelen_slownik # => True
1 in pelen_slownik # => False 1 in pelen_slownik # => False
# Próba dobrania się do nieistniejącego klucza da KeyError # Próba dobrania się do nieistniejącego klucza da KeyError
pelen_slownik["cztery"] # KeyError pelen_slownik["cztery"] # KeyError
# Użyj "get()" method aby uniknąć KeyError # Użyj metody "get()", aby uniknąć błędu KeyError
pelen_slownik.get("raz") # => 1 pelen_slownik.get("raz") # => 1
pelen_slownik.get("cztery") # => None pelen_slownik.get("cztery") # => None
# Metoda get zwraca domyślną wartość gdy brakuje klucza # Metoda get zwraca domyślną wartość gdy brakuje klucza
pelen_slownik.get("one", 4) # => 1 pelen_slownik.get("one", 4) # => 1
pelen_slownik.get("cztery", 4) # => 4 pelen_slownik.get("cztery", 4) # => 4
# zauważ, że pelen_slownik.get("cztery") jest wciąż => None # zauważ, że pelen_slownik.get("cztery") wciąż zwraca => None
# (get nie ustawia wartości słownika) # (get nie ustawia wartości słownika)
# przypisz wartość do klucza podobnie jak w listach # przypisz wartość do klucza podobnie jak w listach
@ -284,12 +284,12 @@ pelen_slownik.setdefault("piec", 5) # pelen_slownik["piec"] daje 5
pelen_slownik.setdefault("piec", 6) # pelen_slownik["piec"] to wciąż 5 pelen_slownik.setdefault("piec", 6) # pelen_slownik["piec"] to wciąż 5
# Teraz zbiory (set) ... cóż zbiory (to po prostu listy ale bez potórzeń) # Teraz zbiory (set) - działają jak zwykłe listy, ale bez potórzeń
pusty_zbior = set() pusty_zbior = set()
# Inicjalizujemy "set()" pewnymi wartościami # Inicjalizujemy "set()" pewnymi wartościami
jakis_zbior = set([1, 2, 2, 3, 4]) # jakis_zbior to teraz set([1, 2, 3, 4]) jakis_zbior = set([1, 2, 2, 3, 4]) # jakis_zbior to teraz set([1, 2, 3, 4])
# kolejność nie jest gwarantowana, nawet gdy wydaje się posortowane # kolejność nie jest zachowana, nawet gdy wydaje się posortowane
inny_zbior = set([4, 3, 2, 2, 1]) # inny_zbior to set([1, 2, 3, 4]) inny_zbior = set([4, 3, 2, 2, 1]) # inny_zbior to set([1, 2, 3, 4])
# Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru # Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru
@ -298,7 +298,7 @@ pelen_zbior = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
# Dodaj więcej elementów przez "add()" # Dodaj więcej elementów przez "add()"
pelen_zbior.add(5) # pelen_zbior is now {1, 2, 3, 4, 5} pelen_zbior.add(5) # pelen_zbior is now {1, 2, 3, 4, 5}
# Znajdź przecięcie zbiorów używając & # Znajdź przecięcie (część wspólną) zbiorów, używając &
inny_zbior = {3, 4, 5, 6} inny_zbior = {3, 4, 5, 6}
pelen_zbior & other_set # => {3, 4, 5} pelen_zbior & other_set # => {3, 4, 5}
@ -317,32 +317,32 @@ pelen_zbior | other_set # => {1, 2, 3, 4, 5, 6}
## 3. Kontrola przepływu ## 3. Kontrola przepływu
#################################################### ####################################################
# Tworzymy zmienną some_var # Tworzymy zmienną jakas_zm
some_var = 5 jakas_zm = 5
# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia są ważne Pythonie! # Tutaj widzisz wyrażenie warunkowe "if". Wcięcia w Pythonie są ważne!
# wypisze "some_var jest mniejsza niż 10" # Poniższy kod wypisze "jakas_zm jest mniejsza niż 10"
if some_var > 10: if jakas_zm > 10:
print("some_var jest wieksza niż 10") print("jakas_zm jest wieksza niż 10")
elif some_var < 10: # This elif clause is optional. elif some_var < 10: # Opcjonalna klauzula elif
print("some_var jest mniejsza niż 10") print("jakas_zm jest mniejsza niż 10")
else: # This is optional too. else: # Również opcjonalna klauzula else
print("some_var jest równa 10") print("jakas_zm jest równa 10")
""" """
Pętla for iteruje po elementach listy wypisując: Pętla for iteruje po elementach listy, wypisując:
pies to ssak pies to ssak
kot to ssak kot to ssak
mysz to ssak mysz to ssak
""" """
for zwierze in ["pies", "kot", "mysz"]: for zwierze in ["pies", "kot", "mysz"]:
# Możesz użyć % aby stworzyć sformatowane napisy # Użyj metody format, aby umieścić wartość zmiennej w ciągu
print("%s to ssak" % zwierze) print("{0} to ssak".format(zwierze))
""" """
"range(liczba)" zwraca listę liczb "range(liczba)" zwraca listę liczb
od zera do danej liczby: z przedziału od zera do wskazanej liczby (bez niej):
0 0
1 1
2 2
@ -352,7 +352,7 @@ for i in range(4):
print(i) print(i)
""" """
While to pętla która jest wykonywana dopóki spełniony jest warunek: While to pętla, która jest wykonywana, dopóki spełniony jest warunek:
0 0
1 1
2 2
@ -363,46 +363,46 @@ while x < 4:
print(x) print(x)
x += 1 # Skrót od x = x + 1 x += 1 # Skrót od x = x + 1
# Wyjątki wyłapujemy używając try, except # Wyjątki wyłapujemy, używając try i except
# Działa w Pythonie 2.6 i wyższych: # Działa w Pythonie 2.6 i wyższych:
try: try:
# Użyj "raise" aby wyrzucić wyjąte # Użyj "raise" aby wyrzucić wyjątek
raise IndexError("To błąd indeksu") raise IndexError("To błąd indeksu")
except IndexError as e: except IndexError as e:
pass # Pass to brak reakcji na błąd. Zazwyczaj nanosisz tu poprawki. pass # Pass to brak reakcji na błąd. Zwykle opisujesz tutaj, jak program ma się zachować w przypadku błędu.
except (TypeError, NameError): except (TypeError, NameError):
pass # kilka wyjątków może być przechwyce razem. pass # kilka wyjątków można przechwycić jednocześnie.
else: # Opcjonalna część bloku try/except. Musi wystąpić na końcu else: # Opcjonalna część bloku try/except. Musi wystąpić na końcu
print "Wszystko ok!" # Zadziała tylko, gdy program nie napotka wyjatku. print "Wszystko ok!" # Zadziała tylko, gdy program nie napotka wyjatku.
#################################################### ####################################################
## 4. Funkcjie ## 4. Funkcje
#################################################### ####################################################
# Użyj "def" aby stworzyć nową funkcję # Użyj "def", aby stworzyć nową funkcję
def dodaj(x, y): def dodaj(x, y):
print("x to %s a y to %s" % (x, y)) print("x to %s, a y to %s" % (x, y))
return x + y # słówko kluczowe return zwraca wynik działania return x + y # słowo kluczowe return zwraca wynik działania
# Tak wywołuje się funkcję z parametrami (args): # Tak wywołuje się funkcję z parametrami:
dodaj(5, 6) # => wypisze "x to 5 a y to 6" i zwróci 11 dodaj(5, 6) # => wypisze "x to 5, a y to 6" i zwróci 11
# Innym sposobem jest wywołanie z parametrami nazwanymi. # Innym sposobem jest wywołanie z parametrami nazwanymi.
dodaj(y=6, x=5) # tutaj kolejność podania nie ma znaczenia. dodaj(y=6, x=5) # tutaj kolejność podania nie ma znaczenia.
# Można też stworzyć funkcję, które przyjmują różną ilość parametrów # Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów pozycyjnych,
# nienazwanych args, co będzie interpretowane jako krotka jeśli nie użyjesz * # które zostaną przekazana jako krotka, pisząc w definicji funkcji "*args"
def varargs(*args): def varargs(*args):
return args return args
varargs(1, 2, 3) # => (1, 2, 3) varargs(1, 2, 3) # => (1, 2, 3)
# Można też stworzyć funkcję, które przyjmują różną ilość parametrów # Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów
# nazwanych kwargs, które będa interpretowane jako słownik jeśli nie dasz ** # nazwanych kwargs, które zostaną przekazane jako słownik, pisząc w definicji funkcji "**kwargs"
def keyword_args(**kwargs): def keyword_args(**kwargs):
return kwargs return kwargs
@ -410,12 +410,12 @@ def keyword_args(**kwargs):
keyword_args(wielka="stopa", loch="ness") # => {"wielka": "stopa", "loch": "ness"} keyword_args(wielka="stopa", loch="ness") # => {"wielka": "stopa", "loch": "ness"}
# Możesz też to pomieszać # Możesz też przyjmować jednocześnie zmienną liczbę parametrów pozycyjnych i nazwanych
def all_the_args(*args, **kwargs): def all_the_args(*args, **kwargs):
print(args) print(args)
print(kwargs) print(kwargs)
""" """
all_the_args(1, 2, a=3, b=4) wyrzuci: all_the_args(1, 2, a=3, b=4) wypisze:
(1, 2) (1, 2)
{"a": 3, "b": 4} {"a": 3, "b": 4}
""" """
@ -435,7 +435,7 @@ def pass_all_the_args(*args, **kwargs):
print varargs(*args) print varargs(*args)
print keyword_args(**kwargs) print keyword_args(**kwargs)
# Zakres widoczności # Zasięg zmiennych
x = 5 x = 5
def setX(num): def setX(num):
@ -461,14 +461,14 @@ def rob_dodawacz(x):
dodaj_10 = rob_dodawacz(10) dodaj_10 = rob_dodawacz(10)
dodaj_10(3) # => 13 dodaj_10(3) # => 13
# Są również funkcje nienazwane "lambda" # Są również funkcje anonimowe "lambda"
(lambda x: x > 2)(3) # => True (lambda x: x > 2)(3) # => True
# Są także wbudowane funkcje wysokiego poziomu # Python ma też wbudowane funkcje wyższego rzędu (przyjmujące inną funkcje jako parametr)
map(add_10, [1, 2, 3]) # => [11, 12, 13] map(add_10, [1, 2, 3]) # => [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7] filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
# Można używać wyrażeń listowych do mapowania (map) i filtrowania (filter) # Można używać wyrażeń listowych (list comprehensions) do mapowania i filtrowania
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] [add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] [x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
@ -485,18 +485,18 @@ class Czlowiek(object):
# Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji. # Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji.
# Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają # Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają
# obietky lub atrybuty, który żyją tylko w kontrolowanej przez # specjalne obiekty lub atrybuty wykorzystywane wewnętrznie przez Pythona.
# użytkownika przestrzeni nazw. Nie używaj ich we własnych metodach. # Nie używaj ich we własnych metodach.
def __init__(self, nazwa): def __init__(self, nazwa):
# przypisz parametr "nazwa" do atrybutu instancji # przypisz parametr "nazwa" do atrybutu instancji
self.nazwa = nazwa self.nazwa = nazwa
# Metoda instancji. Wszystkie metody biorą "self" jako pierwszy argument # Metoda instancji. Wszystkie metody przyjmują "self" jako pierwszy argument
def mow(self, wiadomosc): def mow(self, wiadomosc):
return "%s: %s" % (self.nazwa, wiadomosc) return "%s: %s" % (self.nazwa, wiadomosc)
# Metoda klasowa współdzielona przez instancje. # Metoda klasowa współdzielona przez instancje.
# Ma wywołującą klasę jako pierwszy argument. # Przyjmuje wywołującą klasę jako pierwszy argument.
@classmethod @classmethod
def daj_gatunek(cls): def daj_gatunek(cls):
return cls.gatunek return cls.gatunek
@ -540,7 +540,8 @@ print(ceil(3.7)) # => 4.0
print(floor(3.7)) # => 3.0 print(floor(3.7)) # => 3.0
# Można zaimportować wszystkie funkcje z danego modułu. # Można zaimportować wszystkie funkcje z danego modułu.
# Ostrzeżenie: nie jest to polecane. # Uwaga: nie jest to polecane, bo później w kodzie trudno połapać się,
# która funkcja pochodzi z którego modułu.
from math import * from math import *
# Można skracać nazwy modułów. # Można skracać nazwy modułów.
@ -550,7 +551,7 @@ math.sqrt(16) == m.sqrt(16) # => True
from math import sqrt from math import sqrt
math.sqrt == m.sqrt == sqrt # => True math.sqrt == m.sqrt == sqrt # => True
# Moduły pythona to zwykłe skrypty napisane w tym języku. Możesz # Moduły Pythona to zwykłe skrypty napisane w tym języku. Możesz
# pisać własne i importować je. Nazwa modułu to nazwa pliku. # pisać własne i importować je. Nazwa modułu to nazwa pliku.
# W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu. # W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu.
@ -568,14 +569,16 @@ def podwojne_liczby(iterowalne):
yield i + i yield i + i
# Generatory tworzą wartości w locie. # Generatory tworzą wartości w locie.
# W przeciwienstwie do wygenerowania wartości raz i ich zachowania, # Zamiast generować wartości raz i zapisywać je (np. w liście),
# powstają one na bieżąco, w wyniku iteracji. To oznacza, że wartości # generator tworzy je na bieżąco, w wyniku iteracji. To oznacza,
# większe niż 15 nie będą przetworzone w funkcji "podwojne_liczby". # że w poniższym przykładzie wartości większe niż 15 nie będą przetworzone
# w funkcji "podwojne_liczby".
# Zauważ, że xrange to generator, który wykonuje tę samą operację co range. # Zauważ, że xrange to generator, który wykonuje tę samą operację co range.
# Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci, # Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci,
# a xrange tworzy obiekt generatora zamiast tworzyć całą listę jak range. # a xrange tworzy obiekt generatora zamiast budować całą listę jak range.
# Użyto podkreślinika, aby odróżnić nazwę zmiennej od słówka kluczowego
# Pythona. # Aby odróżnić nazwę zmiennej od nazwy zarezerwowanej w Pythonie, używamy
# zwykle na końcu znaku podkreślenia
xrange_ = xrange(1, 900000000) xrange_ = xrange(1, 900000000)
# poniższa pętla będzie podwajać liczby aż do 30 # poniższa pętla będzie podwajać liczby aż do 30
@ -587,7 +590,7 @@ for i in podwojne_liczby(xrange_):
# Dekoratory # Dekoratory
# w tym przykładzie "beg" jest nakładką na "say" # w tym przykładzie "beg" jest nakładką na "say"
# Beg wywołuje say. Jeśli say_please jest prawdziwe wtedy wzracana wartość # Beg wywołuje say. Jeśli say_please jest prawdziwe, wtedy zwracana wartość
# zostanie zmieniona # zostanie zmieniona
from functools import wraps from functools import wraps

593
pl-pl/ruby-pl.html.markdown Normal file
View File

@ -0,0 +1,593 @@
---
language: ruby
filename: learnruby.rb
contributors:
- ["David Underwood", "http://theflyingdeveloper.com"]
- ["Joel Walden", "http://joelwalden.net"]
- ["Luke Holder", "http://twitter.com/lukeholder"]
- ["Tristan Hume", "http://thume.ca/"]
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
- ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
- ["Levi Bostian", "https://github.com/levibostian"]
- ["Rahil Momin", "https://github.com/iamrahil"]
- ["Gabriel Halley", "https://github.com/ghalley"]
- ["Persa Zula", "http://persazula.com"]
translators:
- ["Marcin Klocek", "https://github.com/mklocek"]
lang: pl-pl
---
```ruby
# To jest komentarz
=begin
To jest wielolinijkowy komentarz
Nikt ich nie używa
Ty też nie powinieneś
=end
# Przede wszystkim: Wszystko jest obiektem.
# Liczby są obiektami
3.class #=> Fixnum
3.to_s #=> "3"
# Trochę podstawowej arytmetyki
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
2**5 #=> 32
5 % 3 #=> 2
5 ^ 6 #=> 3
# Arytmetyka jest zastąpeniem składni
# metod wywoływanych na obiektach
1.+(3) #=> 4
10.* 5 #=> 50
# Wartości specjalne są obiektami
nil # To na prawdę jest niczym
true # prawda
false # fałsz
nil.class #=> NilClass
true.class #=> TrueClass
false.class #=> FalseClass
# Równość
1 == 1 #=> true
2 == 1 #=> false
# Nierówność
1 != 1 #=> false
2 != 1 #=> true
# jedyną 'fałszywą' wartością poza false, jest nil
!nil #=> true
!false #=> true
!0 #=> false
# Więcej porównań
1 < 10 #=> true
1 > 10 #=> false
2 <= 2 #=> true
2 >= 2 #=> true
# Operatory logiczne
true && false #=> false
true || false #=> true
!true #=> false
# Istnieją alternatywne wersje operatorów logicznych ze znacznie mniejszym
# pierwszeństwem. Używane są by kontrolować wyrażenia w łańcuchach wyrażeń
# aż jedno z nich wróci true lub false.
# `zrob_cos_innego` wywołaj tylko wtedy gdy `zrob_cos` zakończy się sukcesem.
zrob_cos_innego() and zrob_cos()
# `log_error` wywołaj tylko wtedy gdy `zrob_cos` nie zakończy się sukcesem.
zrob_cos() or log_error()
# Stringi są obiektami
'Jestem stringiem.'.class #=> String
"Ja również jestem stringiem.".class #=> String
wypelnienie = 'użyć interpolacji stringa'
"Potrafię #{wypelnienie} używając podwójnych cudzysłowów."
#=> "Potrafię użyć interpolacji stringa używając podwójnych cudzysłowów."
# Staraj się zapisywać stringi za pomocą apostrof, zamiast cudzysłowów tam, gdzie to możliwe
# Cudzysłowy wykonują dodatkowe wewnętrzne operacje
# Łączenie stringów, ale nie liczb
'hej ' + 'świecie' #=> "hej świecie"
'hej ' + 3 #=> TypeError: can't convert Fixnum into String
'hej ' + 3.to_s #=> "hej 3"
# Łączenie stringów i operatorów
'hej ' * 3 #=> "hej hej hej "
# Dodawanie do stringa
'hej' << ' świecie' #=> "hej świecie"
# wydrukowanie wartości wraz z nową linią na końcu
puts "Drukuję!"
#=> Drukuję!
#=> nil
# wydrukowanie wartości bez nowej linii na końcu
print "Drukuję!"
#=> Drukuję! => nill
# Zmienne
x = 25 #=> 25
x #=> 25
# Zauważ, że przypisanie zwraca przypisywaną wartość
# To znaczy, że możesz wykonać wielokrotne przypisanie:
x = y = 10 #=> 10
x #=> 10
y #=> 10
# Zwyczajowo, używaj notacji nazwa_zmiennej dla nazw zmiennych
nazwa_zmiennej = true
# Używaj opisowych nazw zmiennych
sciezka_do_projektu = '/dobra/nazwa/'
sciezka = '/zla/nazwa/'
# Symbole (są obiektami)
# Symbole są niezmiennymi, wielokrotnie używanymi stałymi reprezentowanymi wewnętrznie jako
# liczby całkowite. Często używane są zamiast stringów w celu wydajniejszego przekazywania danych
:oczekujacy.class #=> Symbol
status = :oczekujacy
status == :oczekujacy #=> true
status == 'oczekujacy' #=> false
status == :zatwierdzony #=> false
# Tablice
# To jest tablica
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
# Tablice mogą zwierać różne typy danych
[1, 'hej', false] #=> [1, "hej", false]
# Tablice mogę być indeksowane
# Od początku
tablica[0] #=> 1
tablica.first #=> 1
tablica[12] #=> nil
# Podobnie jak przy arytmetyce, dostęp poprzez [zmienna]
# jest tylko czytelniejszą składnią
# dla wywoływania metody [] na obiekcie
tablica.[] 0 #=> 1
tablica.[] 12 #=> nil
# Od końca
tablica[-1] #=> 5
tablica.last #=> 5
# Z początkowym indeksem i długością
tablica[2, 3] #=> [3, 4, 5]
# Odwrotność tablicy
a=[1,2,3]
a.reverse! #=> [3,2,1]
# Lub zakres
array[1..3] #=> [2, 3, 4]
# Dodawanie do tablicy w taki sposób
tablica << 6 #=> [1, 2, 3, 4, 5, 6]
# Lub taki
tablica.push(6) #=> [1, 2, 3, 4, 5, 6]
# Sprawdzanie, czy tablica zawiera element
tablica.include?(1) #=> true
# Hasze są Ruby'owymi podstawowymi słownikami z parami klucz/wartość.
# Hasze są zapisywane za pomocą nawiasów klamrowych
hasz = { 'kolor' => 'zielony', 'numer' => 5 }
hasz.keys #=> ['kolor', 'numer']
# Można szybko sprawdzić zawartość hasza za pomocą kluczy:
hasz['kolor'] #=> 'zielony'
hasz['numer'] #=> 5
# Sprawdzenie wartośći dla nieistniejącego klucza zwraca nil:
hasz['nic tutaj nie ma'] #=> nil
# Od wersji 1.9, Ruby posiada specjalną składnię, gdy używamy symboli jako kluczy:
nowy_hasz = { stan: 3, akcja: true }
nowy_hasz.keys #=> [:stan, :akcja]
# Sprawdzenie istnienia kluczy i wartości w haszu
new_hash.has_key?(:defcon) #=> true
new_hash.has_value?(3) #=> true
# Wskazówka: Zarówno tablice, jak i hasze, są policzalne
# Współdzielą wiele metod takich jak each, map, count, i inne
# Instrukcje warunkowe
if true
'wyrażenie if'
elsif false
'wyrażenie if, opcjonalne'
else
'wyrażenie else, również opcjonalne'
end
for licznik in 1..5
puts "powtórzenie #{licznik}"
end
#=> powtórzenie 1
#=> powtórzenie 2
#=> powtórzenie 3
#=> powtórzenie 4
#=> powtórzenie 5
# JEDNAKŻE, Nikt nie używa pętli for.
# Zamiast tego, powinno się używać metody "each" i podawać jej blok.
# Blok jest kawałkiem kodu, który możesz podać metodzie podobnej do "each".
# Jest analogiczny do wyrażeń lambda, funkcji anonimowych lub zamknięć w innych
# językach programowania.
#
# Metoda "each" danego zakresu, wykonuje blok dla każdego elementu w zakresie.
# Do bloku zostaje przekazany licznik jako parametr.
# Wykonanie metody "each" z przekazaniem bloku wygląda następująco:
(1..5).each do |licznik|
puts "powtórzenie #{licznik}"
end
#=> powtórzenie 1
#=> powtórzenie 2
#=> powtórzenie 3
#=> powtórzenie 4
#=> powtórzenie 5
# Możesz również otoczyć blok nawiasami klamrowymi:
(1..5).each { |licznik| puts "powtórzenie #{licznik}" }
# Zawartość struktur danych również może być powtarzana używając each.
tablica.each do |element|
puts "#{element} jest częścią tablicy"
end
hasz.each do |klucz, wartosc|
puts "#{klucz} jest #{wartosc}"
end
# Jeśli nadal potrzebujesz indeksum, możesz użyć "each_with_index" i zdefiniować
# zmienną odpowiadającą indeksowi
tablica.each_with_index do |element, indeks|
puts "#{element} jest numerem #{indeks} w tablicy"
end
licznik = 1
while licznik <= 5 do
puts "powtórzenie #{licznik}"
licznik += 1
end
#=> powtórzenie 1
#=> powtórzenie 2
#=> powtórzenie 3
#=> powtórzenie 4
#=> powtórzenie 5
# W Ruby istnieje dużo pomocnych funkcji wykonujących pętle,
# na przykład "map", "reduce", "inject" i wiele innych. Map,
# w każdym wywołaniu, pobiera tablicę, na której wykonuję pętlę,
# wykonuje kod zapisany za pomocą bloku i zwraca całkowicie nową tablicę.
tablica = [1,2,3,4,5]
podwojone = tablica.map do |element|
element * 2
end
puts podwojona
#=> [2,4,6,8,10]
puts tablica
#=> [1,2,3,4,5]
ocena = 2
case ocena
when 1
puts 'Dobra robota, masz wolne'
when 2
puts 'Następnym razem będziesz miał więcej szczęścia'
when 3
puts 'Możesz to zrobić lepiej'
when 4
puts 'Przebrnąłeś'
when 5
puts 'Oblałeś!'
else
puts 'Inny system oceniania?'
end
#=> "Następnym razem będziesz miał więcej szczęścia"
# case może również użwać zakresów
ocena = 82
case ocena
when 90..100
puts 'Hurra!'
when 80...90
puts 'Dobra robota'
else
puts 'Oblałeś!'
end
#=> "Dobra robota"
# obsługa błędów:
begin
# kod, który może wywołać wyjątek
raise NoMemoryError, 'Zabrakło pamięci.'
rescue NoMemoryError => zmienna_wyjatku
puts 'Został wywołany NoMemoryError', zmienna_wyjatku
rescue RuntimeError => inna_zmienna_wyjatku
puts 'Teraz został wywołany RuntimeError'
else
puts 'To zostanie uruchomione, jeśli nie wystąpi żaden wyjątek'
ensure
puts 'Ten kod wykona się zawsze'
end
# Funkcje
def podwojenie(x)
x * 2
end
# Funkcje (i wszystkie bloki) zawsze zwracają wartość ostatniego wyrażenia
podwojenie(2) #=> 4
# Okrągłe nawiady są opcjonalne, gdy wynik jest jednoznaczny
podwojenie 3 #=> 6
podwojenie podwojenie 3 #=> 12
def suma(x, y)
x + y
end
# Argumenty metod są oddzielone przecinkami
suma 3, 4 #=> 7
suma suma(3, 4), 5 #=> 12
# yield
# Wszystkie metody mają ukryty, opcjonalny parametr bloku,
# który może być wykonany używając słowa kluczowego 'yield'
def otoczenie
puts '{'
yield
puts '}'
end
otoczenie { puts 'hej świecie' }
# {
# hej świecie
# }
# Możesz przekazać blok do funkcji
# "&" oznacza referencję to przekazanego bloku
def goscie(&blok)
blok.call 'jakis_argument'
end
# Możesz przekazać listę argumentów, które będę przekonwertowane na tablicę
# Do tego służy operator ("*")
def goscie(*tablica)
tablica.each { |gosc| puts gosc }
end
# Definiowanie klas używając słowa kluczowego class
class Czlowiek
# Zmienna klasowa. Jest współdzielona przez wszystkie instancje tej klasy.
@@gatunek = 'H. sapiens'
# Podstawowe inicjalizowanie
def initialize(imie, wiek = 0)
# Przypisanie argumentu do zmiennej danej instancji o nazwie "imie"
@imie = imie
# Jeśli nie podano wieku, zostanie użyta domyślna wartość z listy argumentów.
@wiek = wiek
end
# Podstawowa metoda przypisująca wartość
def imie=(imie)
@imie = imie
end
# Podstawowa metoda pobierająca wartość
def imie
@imie
end
# Powyższa funkcjonalność może być zastąpiona używając metody attr_accessor w taki sposób
attr_accessor :imie
# Metody przypisujące/pobierające mogą być stworzone indywidualnie
attr_reader :imie
attr_writer :imie
# Metody klasowe używają self aby odróżnić się od metody instancji.
# To może być wywołane na klasie, nie na instancji.
def self.powiedz(wiadomosc)
puts wiadomosc
end
def gatunek
@@gatunek
end
end
# Tworzenie instancji klasy
jim = Czlowiek.new('Jim Halpert')
dwight = Czlowiek.new('Dwight K. Schrute')
# Wywołajmy parę metod
jim.gatunek #=> "H. sapiens"
jim.imie #=> "Jim Halpert"
jim.imie = "Jim Halpert II" #=> "Jim Halpert II"
jim.imie #=> "Jim Halpert II"
dwight.gatunek #=> "H. sapiens"
dwight.imie #=> "Dwight K. Schrute"
# Wywołanie metody klasowej
Czlowiek.powiedz('Cześć') #=> "Cześć"
# Zasięg zmiennej jest definiowany poprzez jej nazwę.
# Zmienne, które zaczynają się na $ mają zasięg globalny
$zmienna = "Jestem zmienną globalną"
defined? $zmienna #=> "global-variable"
# Zmienne zczynające się na @ mają zasięg danej instancji
@zmienna = "Jestem zmienną instancji"
defined? @zmienna #=> "instance-variable"
# Zmienne, które zaczynają się na @@ mają zasięg danej klasy
@@zmienna = "Jestem zmienną klasową"
defined? @@zmienna #=> "class variable"
# Zmienne, które zaczynają się na dużą literę, są stałymi
Zmienna = "Jestem stałą"
defined? Zmienna #=> "constant"
# Klasa jest również obiektem w ruby. Może więc mieć zmienne instancji.
# Zmienna klasowa może być współdzielona między klasą i jej potomstwem.
# podstawowa klasa
class Czlowiek
@@cokolwiek = 0
def self.cokolwiek
@@cokolwiek
end
def self.cokolwiek=(wartosc)
@@cokolwiek = wartosc
end
end
# klasa pochodna
class Pracownik < Czlowiek
end
Czlowiek.cokolwiek # 0
Pracownik.cokolwiek # 0
Czlowiek.cokolwiek = 2 # 2
Pracownik.cokolwiek # 2
# Zmienna instancji danej klasy nie jest współdzielona przez jej potomstwo.
class Czlowiek
@cos = 0
def self.cos
@cos
end
def self.cos=(wartosc)
@cos = wartosc
end
end
class Doktor < Czlowiek
end
Czlowiek.cos # 0
Doktor.cos # nil
module PrzykladowyModul
def cokolwiek
'cokolwiek'
end
end
# Włączanie modułów łączy ich metody z metodami instancji klasy
# Rozszerzanie modułów łączy ich metody z metodami klasy
class Osoba
include PrzykladowyModul
end
class Ksiazka
extend PrzykladowyModul
end
Osoba.cokolwiek # => NoMethodError: undefined method `cokolwiek' for Osoba:Class
Osoba.new.cokolwiek # => 'cokolwiek'
Ksiazka.cokolwiek # => 'cokolwiek'
Ksiazka.new.cokolwiek # => NoMethodError: undefined method `cokolwiek'
# Gdy włączamy lub rozszerzamy muduły, wykonywane są tzw. wywołania zwrotne
module PrzykladowyModul
def self.included(baza)
baza.extend(MotodyKlasowe)
baza.send(:include, MetodyInstancji)
end
module MotodyKlasowe
def cos
'cos'
end
end
module MetodyInstancji
def xyz
'xyz'
end
end
end
class Cokolwiek
include PrzykladowyModul
end
Cokolwiek.cos # => 'cos'
Cokolwiek.xyz # => NoMethodError: undefined method `xyz'
Cokolwiek.new.cos # => NoMethodError: undefined method `cos'
Cokolwiek.new.xyz # => 'qux'
```
## Dodatkowe źródła
### Polskie
- [Dokumentacja](https://www.ruby-lang.org/pl/documentation/quickstart/)
### Angielskie
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.

320
powershell.html.markdown Normal file
View File

@ -0,0 +1,320 @@
---
category: tool
tool: powershell
contributors:
- ["Wouter Van Schandevijl", "https://github.com/laoujin"]
filename: LearnPowershell.ps1
---
PowerShell is the Windows scripting language and configuration management
framework from Microsoft built on the .NET Framework. Windows 7 and up ship
with PowerShell.
Nearly all examples below can be a part of a shell script or executed directly
in the shell.
A key difference with Bash is that it is mostly objects that you manipulate
rather than plain text.
[Read more here.](https://technet.microsoft.com/en-us/library/bb978526.aspx)
If you are uncertain about your environment:
```
Get-ExecutionPolicy -List
Set-ExecutionPolicy AllSigned
# Execution policies include:
# - Restricted: Scripts won't run.
# - RemoteSigned: Downloaded scripts run only if signed by a trusted publisher.
# - AllSigned: Scripts need to be signed by a trusted publisher.
# - Unrestricted: Run all scripts.
help about_Execution_Policies # for more info
# Current PowerShell version:
$PSVersionTable
```
Getting help:
```
# Find commands
Get-Command about_* # alias: gcm
Get-Command -Verb Add
Get-Alias ps
Get-Alias -Definition Get-Process
Get-Help ps | less # alias: help
ps | Get-Member # alias: gm
Show-Command Get-EventLog # Display GUI to fill in the parameters
Update-Help # Run as admin
```
The tutorial starts here:
```
# As you already figured, comments start with #
# Simple hello world example:
echo Hello world!
# echo is an alias for Write-Output (=cmdlet)
# Most cmdlets and functions follow the Verb-Noun naming convention
# Each command starts on a new line, or after a semicolon:
echo 'This is the first line'; echo 'This is the second line'
# Declaring a variable looks like this:
$aString="Some string"
# Or like this:
$aNumber = 5 -as [double]
$aList = 1,2,3,4,5
$aString = $aList -join '--' # yes, -split exists also
$aHashtable = @{name1='val1'; name2='val2'}
# Using variables:
echo $aString
echo "Interpolation: $aString"
echo "`$aString has length of $($aString.Length)"
echo '$aString'
echo @"
This is a Here-String
$aString
"@
# Note that ' (single quote) won't expand the variables!
# Here-Strings also work with single quote
# Builtin variables:
# There are some useful builtin variables, like
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 ', ')."
# More builtins: `help about_Automatic_Variables`
# Inline another file (dot operator)
. .\otherScriptName.ps1
### Control Flow
# We have the usual if structure:
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 statements are more powerfull compared to most languages
$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" }
}
# The classic for
for($i = 1; $i -le 10; $i++) {
"Loop number $i"
}
# Or shorter
1..10 | % { "Loop number $_" }
# PowerShell also offers
foreach ($var in 'val1','val2','val3') { echo $var }
# while () {}
# do {} while ()
# do {} until ()
# Exception handling
try {} catch {} finally {}
try {} catch [System.NullReferenceException] {
echo $_.Exception | Format-List -Force
}
### Providers
# List files and directories in the current directory
ls # or `dir`
cd ~ # goto home
Get-Alias ls # -> Get-ChildItem
# Uh!? These cmdlets have generic names because unlike other scripting
# languages, PowerShell does not only operate in the current directory.
cd HKCU: # go to the HKEY_CURRENT_USER registry hive
# Get all providers in your session
Get-PSProvider
### Pipeline
# Cmdlets have parameters that control their execution:
Get-ChildItem -Filter *.txt -Name # Get just the name of all txt files
# Only need to type as much of a parameter name until it is no longer ambiguous
ls -fi *.txt -n # -f is not possible because -Force also exists
# Use `Get-Help Get-ChildItem -Full` for a complete overview
# Results of the previous cmdlet can be passed to the next as input.
# `$_` is the current object in the pipeline object.
ls | Where-Object { $_.Name -match 'c' } | Export-CSV export.txt
ls | ? { $_.Name -match 'c' } | ConvertTo-HTML | Out-File export.html
# If you get confused in the pipeline use `Get-Member` for an overview
# of the available methods and properties of the pipelined objects:
ls | Get-Member
Get-Date | gm
# ` is the line continuation character. Or end the line with a |
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
# Use % as a shorthand for ForEach-Object
(a,b,c) | ForEach-Object `
-Begin { "Starting"; $counter = 0 } `
-Process { "Processing $_"; $counter++ } `
-End { "Finishing: $counter" }
# Get-Process as a table with three columns
# The third column is the value of the VM property in MB and 2 decimal places
# Computed columns can be written more verbose as:
# `@{name='lbl';expression={$_}`
ps | Format-Table ID,Name,@{n='VM(MB)';e={'{0:n2}' -f ($_.VM / 1MB)}} -autoSize
### Functions
# The [string] attribute is optional.
function foo([string]$name) {
echo "Hey $name, have a function"
}
# Calling your function
foo "Say my name"
# Functions with named parameters, parameter attributes, parsable documention
<#
.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' }
}
### It's all .NET
# A PS string is in fact a .NET System.String
# All .NET methods and properties are thus available
'string'.ToUpper().Replace('G', 'ggg')
# Or more powershellish
'string'.ToUpper() -replace 'G', 'ggg'
# Unsure how that .NET method is called again?
'string' | gm
# Syntax for calling static .NET methods
[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic')
# Note that .NET functions MUST be called with parentheses
# while PS functions CANNOT be called with parentheses
$writer = New-Object System.IO.StreamWriter($path, $true)
$writer.Write([Environment]::NewLine)
$write.Dispose()
### IO
# Reading a value from input:
$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 # returns a string[]
# Set-Content, Add-Content, Clear-Content
Get-Command ConvertTo-*,ConvertFrom-*
### Useful stuff
# Refresh your PATH
$env:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") +
";" + [System.Environment]::GetEnvironmentVariable("Path", "User")
# Find Python in path
$env:PATH.Split(";") | Where-Object { $_ -like "*python*"}
# Change working directory without having to remember previous path
Push-Location c:\temp # change working directory to c:\temp
Pop-Location # change back to previous working directory
# Unblock a directory after download
Get-ChildItem -Recurse | Unblock-File
# Open Windows Explorer in working directory
ii .
# Any key to exit
$host.UI.RawUI.ReadKey()
return
# Create a shortcut
$WshShell = New-Object -comObject WScript.Shell
$Shortcut = $WshShell.CreateShortcut($link)
$Shortcut.TargetPath = $file
$Shortcut.WorkingDirectory = Split-Path $file
$Shortcut.Save()
```
Configuring your shell
```
# $Profile is the full path for your `Microsoft.PowerShell_profile.ps1`
# All code there will be executed when the PS session starts
if (-not (Test-Path $Profile)) {
New-Item -Type file -Path $Profile -Force
notepad $Profile
}
# More info: `help about_profiles`
# For a more usefull shell, be sure to check the project PSReadLine below
```
Interesting Projects
* [Channel9](https://channel9.msdn.com/Search?term=powershell%20pipeline#ch9Search&lang-en=en) PowerShell tutorials
* [PSGet](https://github.com/psget/psget) NuGet for PowerShell
* [PSReadLine](https://github.com/lzybkr/PSReadLine/) A bash inspired readline implementation for PowerShell (So good that it now ships with Windows10 by default!)
* [Posh-Git](https://github.com/dahlbyk/posh-git/) Fancy Git Prompt (Recommended!)
* [PSake](https://github.com/psake/psake) Build automation tool
* [Pester](https://github.com/pester/Pester) BDD Testing Framework
* [Jump-Location](https://github.com/tkellogg/Jump-Location) Powershell `cd` that reads your mind
* [PowerShell Community Extensions](http://pscx.codeplex.com/) (Dead)
Not covered
* WMI: Windows Management Intrumentation (Get-CimInstance)
* Multitasking: Start-Job -scriptBlock {...},
* Code Signing
* Remoting (Enter-PSSession/Exit-PSSession; Invoke-Command)

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

@ -7,29 +7,30 @@ contributors:
translators: translators:
- ["João Farias", "https://github.com/JoaoGFarias"] - ["João Farias", "https://github.com/JoaoGFarias"]
- ["Elton Viana", "https://github.com/eltonvs"] - ["Elton Viana", "https://github.com/eltonvs"]
- ["Cássio Böck", "https://github.com/cassiobsilva"]
lang: pt-br lang: pt-br
filename: c-pt.el filename: c-pt.el
--- ---
Ah, C. Ainda é **a** linguagem de computação de alta performance. Ah, C. Ainda é **a** linguagem de computação de alta performance.
C é a liguangem de mais baixo nível que a maioria dos programadores C é a linguagem de mais baixo nível que a maioria dos programadores
irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique utilizarão, e isso dá a ela uma grande velocidade bruta. Apenas fique
antento que este manual de gerenciamento de memória e C vai levanter-te atento se este manual de gerenciamento de memória e C vai te levar
tão longe quanto você precisa. tão longe quanto precisa.
```c ```c
// Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99 // Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99
/* /*
Comentários de multiplas linhas se parecem com este. Comentários de múltiplas linhas se parecem com este.
Funcionam no C89 também. Funcionam no C89 também.
*/ */
// Constantes: #define <palavra-chave> // Constantes: #define <palavra-chave>
#definie DAY_IN_YEAR 365 #definie DAY_IN_YEAR 365
//enumarações também são modos de definir constantes. //enumerações também são modos de definir constantes.
enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB}; enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
// SEG recebe 2 automaticamente, TER recebe 3, etc. // SEG recebe 2 automaticamente, TER recebe 3, etc.
@ -120,7 +121,7 @@ int main() {
// Você pode inicializar um array com 0 desta forma: // Você pode inicializar um array com 0 desta forma:
char meu_array[20] = {0}; char meu_array[20] = {0};
// Indexar um array é semelhante a outras linguages // Indexar um array é semelhante a outras linguagens
// Melhor dizendo, outras linguagens são semelhantes a C // Melhor dizendo, outras linguagens são semelhantes a C
meu_array[0]; // => 0 meu_array[0]; // => 0
@ -206,7 +207,7 @@ int main() {
2 <= 2; // => 1 2 <= 2; // => 1
2 >= 2; // => 1 2 >= 2; // => 1
// C não é Python - comparações não se encadeam. // C não é Python - comparações não se encadeiam.
int a = 1; int a = 1;
// Errado: // Errado:
int entre_0_e_2 = 0 < a < 2; int entre_0_e_2 = 0 < a < 2;
@ -341,7 +342,7 @@ int main() {
/////////////////////////////////////// ///////////////////////////////////////
// Um ponteiro é uma variável declarada para armazenar um endereço de memória. // Um ponteiro é uma variável declarada para armazenar um endereço de memória.
// Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você // Sua declaração irá também dizer o tipo de dados para o qual ela aponta. Você
// Pode usar o endereço de memória de suas variáveis, então, brincar com eles. // Pode usar o endereço de memória de suas variáveis, então, brincar com eles.
int x = 0; int x = 0;
@ -363,13 +364,13 @@ int main() {
printf("%d\n", *px); // => Imprime 0, o valor de x printf("%d\n", *px); // => Imprime 0, o valor de x
// Você também pode mudar o valor que o ponteiro está apontando. // Você também pode mudar o valor que o ponteiro está apontando.
// Teremo que cercar a de-referência entre parenteses, pois // Temos que cercar a de-referência entre parênteses, pois
// ++ tem uma precedência maior que *. // ++ tem uma precedência maior que *.
(*px)++; // Incrementa o valor que px está apontando por 1 (*px)++; // Incrementa o valor que px está apontando por 1
printf("%d\n", *px); // => Imprime 1 printf("%d\n", *px); // => Imprime 1
printf("%d\n", x); // => Imprime 1 printf("%d\n", x); // => Imprime 1
// Arrays são um boa maneira de alocar um bloco contínuo de memória // Arrays são uma boa maneira de alocar um bloco contínuo de memória
int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho
int xx; int xx;
for (xx = 0; xx < 20; xx++) { for (xx = 0; xx < 20; xx++) {
@ -379,7 +380,7 @@ int main() {
// Declara um ponteiro do tipo int e inicialize ele para apontar para x_array // Declara um ponteiro do tipo int e inicialize ele para apontar para x_array
int* x_ptr = x_array; int* x_ptr = x_array;
// x_ptr agora aponta para o primeiro elemento do array (o inteiro 20). // x_ptr agora aponta para o primeiro elemento do array (o inteiro 20).
// Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos. // Isto funciona porque arrays são apenas ponteiros para seus primeiros elementos.
// Por exemplo, quando um array é passado para uma função ou é atribuído a um // Por exemplo, quando um array é passado para uma função ou é atribuído a um
// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro. // ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
// Exceções: quando o array é o argumento de um operador `&` (endereço-de): // Exceções: quando o array é o argumento de um operador `&` (endereço-de):
@ -395,7 +396,7 @@ int main() {
printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8" printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8"
// Ponteiros podem ser incrementados ou decrementados baseado no seu tipo // Ponteiros podem ser incrementados ou decrementados baseado no seu tipo
// (isto é chamado aritimética de ponteiros // (isto é chamado aritmética de ponteiros
printf("%d\n", *(x_ptr + 1)); // => Imprime 19 printf("%d\n", *(x_ptr + 1)); // => Imprime 19
printf("%d\n", x_array[1]); // => Imprime 19 printf("%d\n", x_array[1]); // => Imprime 19
@ -413,9 +414,9 @@ int main() {
// "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido" // "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido"
printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa. printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa.
// Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo, // Quando se termina de usar um bloco de memória alocado, você pode liberá-lo,
// ou ninguém mais será capaz de usá-lo até o fim da execução // ou ninguém mais será capaz de usá-lo até o fim da execução
// (Isto cham-se "memory leak"): // (Isto chama-se "memory leak"):
free(my_ptr); free(my_ptr);
// Strings são arrays de char, mas elas geralmente são representadas // Strings são arrays de char, mas elas geralmente são representadas

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

@ -159,11 +159,11 @@ seletor {
    color: # FF66EE; /* Formato hexadecimal longo */     color: # FF66EE; /* Formato hexadecimal longo */
    color: tomato; /* Uma cor nomeada */     color: tomato; /* Uma cor nomeada */
    color: rgb (255, 255, 255); /* Como valores rgb */     color: rgb (255, 255, 255); /* Como valores rgb */
    cor: RGB (10%, 20%, 50%); /* Como porcentagens rgb */     color: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
    cor: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */     color: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
    color: transparent; /* Equivale a definir o alfa a 0 */     color: transparent; /* Equivale a definir o alfa a 0 */
    cor: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */     color: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
    cor: HSLA (0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */     color: HSLA (0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */
    /* Imagens como fundos de elementos */     /* Imagens como fundos de elementos */
    background-image: url (/img-path/img.jpg); /* Citações dentro url () opcional */     background-image: url (/img-path/img.jpg); /* Citações dentro url () opcional */

213
pt-br/java-pt.html.markdown
View File

@ -405,6 +405,219 @@ class Velocipede extends Bicicleta {
} }
// Interfaces
// Sintaxe de declaração de Interface
// <nível de acesso> Interface <nome-da-interface> extends <super-interfaces> {
// // Constantes
// // Declarações de método
//}
// Exemplo - Comida:
public interface Comestivel {
public void comer(); // Qualquer classe que implementa essa interface, deve
                        // Implementar este método.
}
public interface Digestivel {
public void digerir();
}
// Agora podemos criar uma classe que implementa ambas as interfaces.
public class Fruta implements Comestivel, Digestivel {
@Override
public void comer() {
// ...
}
@Override
public void digerir() {
// ...
}
}
// Em Java, você pode estender somente uma classe, mas você pode implementar muitas
// Interfaces. Por exemplo:
public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
InterfaceDois {
@Override
public void InterfaceUmMetodo() {
}
@Override
public void InterfaceDoisMetodo() {
}
}
// Classes abstratas
// Sintaxe de declaração de classe abstrata
// <Nível de acesso> abstract <nome-da-classe-abstrata> extends <estende super-abstratas-classes> {
// // Constantes e variáveis
// // Declarações de método
//}
// Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem
// ser definido em uma classe filha. Semelhante às interfaces, classes abstratas não podem
// ser instanciadas, ao invés disso devem ser extendidas e os métodos abstratos
// definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de
// métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo,
// a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um
// classe abstrata. Classes abstratas também PODEM ter o método "main".
public abstract class Animal
{
public abstract void fazerSom();
// Método pode ter um corpo
public void comer()
{
System.out.println("Eu sou um animal e estou comendo.");
//Nota: Nós podemos acessar variáveis privadas aqui.
idade = 30;
}
// Não há necessidade de inicializar, no entanto, em uma interface
    // a variável é implicitamente final e, portanto, tem
    // de ser inicializado.
protected int idade;
public void mostrarIdade()
{
System.out.println(idade);
}
//Classes abstratas podem ter o método main.
public static void main(String[] args)
{
System.out.println("Eu sou abstrata");
}
}
class Cachorro extends Animal
{
// Nota: ainda precisamos substituir os métodos abstratos na
    // classe abstrata
@Override
public void fazerSom()
{
System.out.println("Bark");
// idade = 30; ==> ERRO! idade é privada de Animal
}
// NOTA: Você receberá um erro se usou a
    // anotação Override aqui, uma vez que java não permite
    // sobrescrita de métodos estáticos.
    // O que está acontecendo aqui é chamado de "esconder o método".
    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
public static void main(String[] args)
{
Cachorro pluto = new Cachorro();
pluto.fazerSom();
pluto.comer();
pluto.mostrarIdade();
}
}
// Classes Finais
// Sintaxe de declaração de classe final
// <nível de acesso> final <nome-da-classe-final> {
// // Constantes e variáveis
// // Declarações de método
//}
// Classes finais são classes que não podem ser herdadas e são, portanto, um
// filha final. De certa forma, as classes finais são o oposto de classes abstratas
// Porque classes abstratas devem ser estendidas, mas as classes finais não pode ser
// estendidas.
public final class TigreDenteDeSabre extends Animal
{
// Nota: Ainda precisamos substituir os métodos abstratos na
     // classe abstrata.
@Override
public void fazerSom();
{
System.out.println("Roar");
}
}
// Métodos Finais
public abstract class Mamifero()
{
// Sintaxe de Métodos Finais:
// <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
// Métodos finais, como, classes finais não podem ser substituídas por uma classe filha,
    // e são, portanto, a implementação final do método.
public final boolean EImpulsivo()
{
return true;
}
}
// Tipo Enum
//
// Um tipo enum é um tipo de dado especial que permite a uma variável ser um conjunto de constantes predefinidas. A
// variável deve ser igual a um dos valores que foram previamente definidos para ela.
// Por serem constantes, os nomes dos campos de um tipo de enumeração estão em letras maiúsculas.
// Na linguagem de programação Java, você define um tipo de enumeração usando a palavra-chave enum. Por exemplo, você poderia
// especificar um tipo de enum dias-da-semana como:
public enum Dia {
DOMINGO, SEGUNDA, TERÇA, QUARTA,
QUINTA, SEXTA, SABADO
}
// Nós podemos usar nosso enum Dia assim:
public class EnumTeste {
// Variável Enum
Dia dia;
public EnumTeste(Dia dia) {
this.dia = dia;
}
public void digaComoE() {
switch (dia) {
case SEGUNDA:
System.out.println("Segundas são ruins.");
break;
case SEXTA:
System.out.println("Sextas são melhores.");
break;
case SABADO:
case DOMINGO:
System.out.println("Finais de semana são os melhores.");
break;
default:
System.out.println("Dias no meio da semana são mais ou menos.");
break;
}
}
public static void main(String[] args) {
EnumTeste primeiroDia = new EnumTeste(Dia.SEGUNDA);
primeiroDia.digaComoE(); // => Segundas-feiras são ruins.
EnumTeste terceiroDia = new EnumTeste(Dia.QUARTA);
terceiroDia.digaComoE(); // => Dias no meio da semana são mais ou menos.
}
}
// Tipos Enum são muito mais poderosos do que nós mostramos acima.
// O corpo de um enum pode incluir métodos e outros campos.
// Você pode ver mais em https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
``` ```
## Leitura Recomendada ## Leitura Recomendada

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

@ -436,7 +436,6 @@ var myPrototype = {
myObj.__proto__ = myPrototype; myObj.__proto__ = myPrototype;
myObj.meaningOfLife; // = 42 myObj.meaningOfLife; // = 42
// This works for functions, too.
// Isto funciona para funções, também. // Isto funciona para funções, também.
myObj.myFunc(); // = "olá mundo!" myObj.myFunc(); // = "olá mundo!"
@ -506,7 +505,7 @@ String.prototype.firstCharacter = function(){
// Havíamos mencionado que `Object.create` não estava ainda disponível em // Havíamos mencionado que `Object.create` não estava ainda disponível em
// todos as implementações, mas nós podemos usá-lo com esse polyfill: // todos as implementações, mas nós podemos usá-lo com esse polyfill:
if (Object.create === undefined){ // don't overwrite it if it exists if (Object.create === undefined){ // Não o sobrescreve se já existir
Object.create = function(proto){ Object.create = function(proto){
// faz um construtor temporário com o prototype certo // faz um construtor temporário com o prototype certo
var Constructor = function(){}; var Constructor = function(){};

15
pt-br/json-pt.html.markdown
View File

@ -3,6 +3,7 @@ language: json
contributors: contributors:
- ["Anna Harren", "https://github.com/iirelu"] - ["Anna Harren", "https://github.com/iirelu"]
- ["Marco Scannadinari", "https://github.com/marcoms"] - ["Marco Scannadinari", "https://github.com/marcoms"]
- ["Francisco Marques", "https://github.com/ToFran"]
translators: translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"] - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
lang: pt-br lang: pt-br
@ -12,10 +13,16 @@ filename: learnjson-pt.json
Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o Como JSON é um formato de intercâmbio de dados, este será, muito provavelmente, o
"Learn X in Y minutes" mais simples existente. "Learn X in Y minutes" mais simples existente.
JSON na sua forma mais pura não tem comentários em reais, mas a maioria dos analisadores JSON na sua forma mais pura não tem comentários, mas a maioria dos analisadores
aceitarão comentários no estilo C (//, /\* \*/). Para os fins do presente, no entanto, aceitarão comentários no estilo C (//, /\* \*/). No entanto estes devem ser evitados para otimizar a compatibilidade.
tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
Um valor JSON pode ser um numero, uma string, um array, um objeto, um booleano (true, false) ou null.
Os browsers suportados são: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, e Safari 4.0+.
A extensão dos ficheiros JSON é “.json” e o tipo de mídia de Internet (MIME) é “application/json”.
Mais informação em: http://www.json.org/
```json ```json
{ {
@ -57,6 +64,6 @@ tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
, "outro comentário": "que bom" , "outro comentário": "que bom"
}, },
"que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer.". "que foi curto": "E, você está feito. Você já sabe tudo que JSON tem para oferecer."
} }
``` ```

27
pt-br/sass-pt.html.markdown
View File

@ -6,6 +6,7 @@ contributors:
- ["Sean Corrales", "https://github.com/droidenator"] - ["Sean Corrales", "https://github.com/droidenator"]
translators: translators:
- ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"] - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
- ["Cássio Böck", "https://github.com/cassiobsilva"]
lang: pt-br lang: pt-br
--- ---
@ -155,16 +156,6 @@ body {
background-color: rgba(0, 0, 0, 0.75); background-color: rgba(0, 0, 0, 0.75);
} }
/* You may also define your own functions. Functions are very similar to
mixins. When trying to choose between a function or a mixin, remember
that mixins are best for generating CSS while functions are better for
logic that might be used throughout your Sass code. The examples in
the Math Operators' section are ideal candidates for becoming a reusable
function. */
/* This function will take a target size and the parent size and calculate
and return the percentage */
/* Você também pode definir suas próprias funções. As funções são muito semelhantes aos /* Você também pode definir suas próprias funções. As funções são muito semelhantes aos
   mixins. Ao tentar escolher entre uma função ou um mixin, lembre-    mixins. Ao tentar escolher entre uma função ou um mixin, lembre-
   que mixins são os melhores para gerar CSS enquanto as funções são melhores para    que mixins são os melhores para gerar CSS enquanto as funções são melhores para
@ -319,11 +310,6 @@ ol {
padding: 0; padding: 0;
} }
/* Sass offers @import which can be used to import partials into a file.
This differs from the traditional CSS @import statement which makes
another HTTP request to fetch the imported file. Sass takes the
imported file and combines it with the compiled code. */
/* Sass oferece @import que pode ser usado para importar parciais em um arquivo. /* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
   Isso difere da declaração CSS @import tradicional, que faz    Isso difere da declaração CSS @import tradicional, que faz
   outra solicitação HTTP para buscar o arquivo importado. Sass converte os    outra solicitação HTTP para buscar o arquivo importado. Sass converte os
@ -354,12 +340,6 @@ body {
==============================*/ ==============================*/
/* Placeholders are useful when creating a CSS statement to extend. If you
wanted to create a CSS statement that was exclusively used with @extend,
you can do so using a placeholder. Placeholders begin with a '%' instead
of '.' or '#'. Placeholders will not appear in the compiled CSS. */
/* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você /* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você
   queria criar uma instrução CSS que foi usado exclusivamente com @extend,    queria criar uma instrução CSS que foi usado exclusivamente com @extend,
   Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez    Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez
@ -396,11 +376,6 @@ body {
============================== * / ============================== * /
/* Sass provides the following operators: +, -, *, /, and %. These can
be useful for calculating values directly in your Sass files instead
of using values that you've already calculated by hand. Below is an example
of a setting up a simple two column design. */
/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
   ser úteis para calcular os valores diretamente no seu Sass arquivos em vez    ser úteis para calcular os valores diretamente no seu Sass arquivos em vez
   de usar valores que você já calculados pela mão. Abaixo está um exemplo    de usar valores que você já calculados pela mão. Abaixo está um exemplo

31
python.html.markdown
View File

@ -123,11 +123,16 @@ not False # => True
# A string can be treated like a list of characters # A string can be treated like a list of characters
"This is a string"[0] # => 'T' "This is a string"[0] # => 'T'
# % can be used to format strings, like this: #String formatting with %
"%s can be %s" % ("strings", "interpolated") #Even though the % string operator will be deprecated on Python 3.1 and removed
#later at some time, it may still be good to know how it works.
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s" % (x,y)
# A newer way to format strings is the format method. # A newer way to format strings is the format method.
# This method is the preferred way # This method is the preferred way
"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted") "{0} can be {1}".format("strings", "formatted")
# You can use keywords if you don't want to count. # You can use keywords if you don't want to count.
"{name} wants to eat {food}".format(name="Bob", food="lasagna") "{name} wants to eat {food}".format(name="Bob", food="lasagna")
@ -144,8 +149,16 @@ None is None # => True
# very useful when dealing with primitive values, but is # very useful when dealing with primitive values, but is
# very useful when dealing with objects. # very useful when dealing with objects.
# None, 0, and empty strings/lists all evaluate to False. # Any object can be used in a Boolean context.
# All other values are True # The following values are considered falsey:
# - None
# - zero of any numeric type (e.g., 0, 0L, 0.0, 0j)
# - empty sequences (e.g., '', (), [])
# - empty containers (e.g., {}, set())
# - instances of user-defined classes meeting certain conditions
# see: https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
#
# All other values are truthy (using the bool() function on them returns True).
bool(0) # => False bool(0) # => False
bool("") # => False bool("") # => False
@ -234,7 +247,7 @@ li.remove(2) # Raises a ValueError as 2 is not in the list
li.insert(1, 2) # li is now [1, 2, 3, 4, 5, 6] again li.insert(1, 2) # li is now [1, 2, 3, 4, 5, 6] again
# Get the index of the first item found # Get the index of the first item found
li.index(2) # => 3 li.index(2) # => 1
li.index(7) # Raises a ValueError as 7 is not in the list li.index(7) # Raises a ValueError as 7 is not in the list
# Check for existence in a list with "in" # Check for existence in a list with "in"
@ -257,8 +270,9 @@ tup[:2] # => (1, 2)
# You can unpack tuples (or lists) into variables # You can unpack tuples (or lists) into variables
a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3 a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3
d, e, f = 4, 5, 6 # you can leave out the parentheses
# Tuples are created by default if you leave out the parentheses # Tuples are created by default if you leave out the parentheses
d, e, f = 4, 5, 6 g = 4, 5, 6 # => (4, 5, 6)
# Now look how easy it is to swap two values # Now look how easy it is to swap two values
e, d = d, e # d is now 5 and e is now 4 e, d = d, e # d is now 5 and e is now 4
@ -444,7 +458,7 @@ add(y=6, x=5) # Keyword arguments can arrive in any order.
# You can define functions that take a variable number of # You can define functions that take a variable number of
# positional args, which will be interpreted as a tuple if you do not use the * # positional args, which will be interpreted as a tuple by using *
def varargs(*args): def varargs(*args):
return args return args
@ -452,7 +466,7 @@ varargs(1, 2, 3) # => (1, 2, 3)
# You can define functions that take a variable number of # You can define functions that take a variable number of
# keyword args, as well, which will be interpreted as a dict if you do not use ** # keyword args, as well, which will be interpreted as a dict by using **
def keyword_args(**kwargs): def keyword_args(**kwargs):
return kwargs return kwargs
@ -712,6 +726,7 @@ print say(say_please=True) # Can you buy me a beer? Please! I am poor :(
* [Python Module of the Week](http://pymotw.com/2/) * [Python Module of the Week](http://pymotw.com/2/)
* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182) * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
* [First Steps With Python](https://realpython.com/learn/python-first-steps/) * [First Steps With Python](https://realpython.com/learn/python-first-steps/)
* [Fullstack Python](https://www.fullstackpython.com/)
### Dead Tree ### Dead Tree

7
python3.html.markdown
View File

@ -224,8 +224,8 @@ li.remove(2) # Raises a ValueError as 2 is not in the list
# Insert an element at a specific index # Insert an element at a specific index
li.insert(1, 2) # li is now [1, 2, 3] again li.insert(1, 2) # li is now [1, 2, 3] again
# Get the index of the first item found # Get the index of the first item found matching the argument
li.index(2) # => 3 li.index(2) # => 1
li.index(4) # Raises a ValueError as 4 is not in the list li.index(4) # Raises a ValueError as 4 is not in the list
# You can add lists # You can add lists
@ -425,7 +425,6 @@ by step. If step is not indicated, the default value is 1.
prints: prints:
4 4
6 6
8
""" """
for i in range(4, 8, 2): for i in range(4, 8, 2):
print(i) print(i)
@ -689,7 +688,7 @@ i.age # => raises an AttributeError
# You can import modules # You can import modules
import math import math
print(math.sqrt(16)) # => 4 print(math.sqrt(16)) # => 4.0
# You can get specific functions from a module # You can get specific functions from a module
from math import ceil, floor from math import ceil, floor

19
pythonstatcomp.html.markdown
View File

@ -9,6 +9,8 @@ This is a tutorial on how to do some typical statistical programming tasks using
```python ```python
# 0. Getting set up ==== # 0. Getting set up ====
""" Get set up with IPython and pip install the following: numpy, scipy, pandas, """ Get set up with IPython and pip install the following: numpy, scipy, pandas,
@ -58,7 +60,9 @@ f.close()
you've used R, you will be familiar with the idea of the "data.frame" already. you've used R, you will be familiar with the idea of the "data.frame" already.
""" """
import pandas as pd, numpy as np, scipy as sp import pandas as pd
import numpy as np
import scipy as sp
pets = pd.read_csv(fn) pets = pd.read_csv(fn)
pets pets
# name age weight species # name age weight species
@ -96,7 +100,8 @@ max(pets.weight) - min(pets.weight) # 20
# 3. Charts ==== # 3. Charts ====
import matplotlib as mpl, matplotlib.pyplot as plt import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline %matplotlib inline
# To do data vizualization in Python, use matplotlib # To do data vizualization in Python, use matplotlib
@ -105,13 +110,17 @@ plt.hist(pets.age);
plt.boxplot(pets.weight); plt.boxplot(pets.weight);
plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight"); plt.scatter(pets.age, pets.weight)
plt.xlabel("age")
plt.ylabel("weight");
# seaborn sits atop matplotlib and makes plots prettier # seaborn sits atop matplotlib and makes plots prettier
import seaborn as sns import seaborn as sns
plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight"); plt.scatter(pets.age, pets.weight)
plt.xlabel("age")
plt.ylabel("weight");
# there are also some seaborn-specific plotting functions # there are also some seaborn-specific plotting functions
# notice how seaborn automatically labels the x-axis on this barplot # notice how seaborn automatically labels the x-axis on this barplot
@ -185,6 +194,7 @@ rx = re.compile(r'\d+$') # match trailing digits
- http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list - http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list
- http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html - http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html
""" """
def extractYear(v): def extractYear(v):
return(pd.Series(reduce(lambda x, y: x + y, map(rx.findall, v), [])).astype(int)) return(pd.Series(reduce(lambda x, y: x + y, map(rx.findall, v), [])).astype(int))
@ -223,6 +233,7 @@ sns.lmplot("BirthY", "EstAge", data=hre);
To see a version of the Holy Roman Emperors analysis using R, see To see a version of the Holy Roman Emperors analysis using R, see
- http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
""" """
``` ```
If you want to learn more, get _Python for Data Analysis_ by Wes McKinney. It's a superb resource and I used it as a reference when writing this tutorial. If you want to learn more, get _Python for Data Analysis_ by Wes McKinney. It's a superb resource and I used it as a reference when writing this tutorial.

4
ru-ru/.directory Normal file
View File

@ -0,0 +1,4 @@
[Dolphin]
SortRole=size
Timestamp=2015,10,31,18,6,13
Version=3

9
ru-ru/bash-ru.html.markdown
View File

@ -95,6 +95,15 @@ else
echo "Имя совпадает с именем пользователя" echo "Имя совпадает с именем пользователя"
fi fi
# Примечание: если $Name пустой, bash интерпретирует код как:
if [ -ne $USER ]
# а это ошибочная команда
# поэтому такие переменные нужно использовать так:
if [ "$Name" -ne $USER ] ...
# когда $Name пустой, bash видит код как:
if [ "" -ne $USER ] ...
# что работает правильно
# Также есть условное исполнение # Также есть условное исполнение
echo "Исполнится всегда" || echo "Исполнится, если первая команда завершится ошибкой" echo "Исполнится всегда" || echo "Исполнится, если первая команда завершится ошибкой"
echo "Исполнится всегда" && echo "Исполнится, если первая команда выполнится удачно" echo "Исполнится всегда" && echo "Исполнится, если первая команда выполнится удачно"

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

@ -144,7 +144,7 @@ Clojure, это представитель семейства Lisp-подобн
;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;
; Функция создается специальной формой fn. ; Функция создается специальной формой fn.
; "Тело"" функции может состоять из нескольких форм, ; "Тело" функции может состоять из нескольких форм,
; но результатом вызова функции всегда будет результат вычисления ; но результатом вызова функции всегда будет результат вычисления
; последней из них. ; последней из них.
(fn [] "Hello World") ; => fn (fn [] "Hello World") ; => fn

753
ru-ru/d-ru.html.markdown Normal file
View File

@ -0,0 +1,753 @@
---
language: d
filename: learnd-ru.d
contributors:
- ["Anton Pastukhov", "http://dprogramming.ru/"]
- ["Robert Brights-Gray", "http://lhs-blog.info/"]
- ["Andre Polykanine", "http://oire.me/"]
lang: ru-ru
---
D - современный компилируемый язык общего назначения с Си-подобным синтаксисом,
который сочетает удобство, продуманный дизайн и высокую производительность.
D - это С++, сделанный правильно.
```d
// Welcome to D! Это однострочный комментарий
/* многострочный
комментарий */
/+
// вложенные комментарии
/* еще вложенные
комментарии */
/+
// мало уровней вложенности? Их может быть сколько угодно.
+/
+/
/*
Имя модуля. Каждый файл с исходным кодом на D — модуль.
Если имя не указано явно, то предполагается, что оно совпадает с именем
файла. Например, для файла "test.d" имя модуля будет "test", если явно
не указать другое
*/
module app;
// импорт модуля. Std — пространство имен стандартной библиотеки (Phobos)
import std.stdio;
// можно импортировать только нужные части, не обязательно модуль целиком
import std.exception : enforce;
// точка входа в программу — функция main, аналогично C/C++
void main()
{
writeln("Hello, world!");
}
/*** типы и переменные ***/
int a; // объявление переменной типа int (32 бита)
float b = 12.34; // тип с плавающей точкой
double c = 56.78; // тип с плавающей точкой (64 бита)
/*
Численные типы в D, за исключением типов с плавающей точкой и типов
комплексных чисел, могут быть беззнаковыми.
В этом случае название типа начинается с префикса "u"
*/
uint d = 10; ulong e = 11;
bool b = true; // логический тип
char d = 'd'; // UTF-символ, 8 бит. D поддерживает UTF "из коробки"
wchar e = 'é'; // символ UTF-16
dchar f; // и даже UTF-32, если он вам зачем-то понадобится
string s = "для строк есть отдельный тип, это не просто массив char-ов из Си";
wstring ws = "поскольку у нас есть wchar, должен быть и wstring";
dstring ds = "...и dstring, конечно";
string кириллица = "Имена переменных должны быть в Unicode, но не обязательно на латинице.";
typeof(a) b = 6; // typeof возвращает тип своего выражения.
// В результате, b имеет такой же тип, как и a
// Тип переменной, помеченной ключевым словом auto,
// присваивается компилятором исходя из значения этой переменной
auto x = 1; // Например, тип этой переменной будет int.
auto y = 1.1; // этой — double
auto z = "Zed is dead!"; // а этой — string
int[3] arr = [1, 2, 3]; // простой одномерный массив с фиксированным размером
int[] arr2 = [1, 2, 3, 4]; // динамический массив
int[string] aa = ["key1": 5, "key2": 6]; // ассоциативный массив
/*
Строки и массивы в D — встроенные типы. Для их использования не нужно
подключать ни внешние, ни даже стандартную библиотеку, хотя в последней
есть множество дополнительных инструментов для работы с ними.
*/
immutable int ia = 10; // неизменяемый тип,
// обозначается ключевым словом immutable
ia += 1; // — вызовет ошибку на этапе компиляции
// перечислимый (enumerable) тип,
// более правильный способ работы с константами в D
enum myConsts = { Const1, Const2, Const3 };
// свойства типов
writeln("Имя типа : ", int.stringof); // int
writeln("Размер в байтах : ", int.sizeof); // 4
writeln("Минимальное значение : ", int.min); // -2147483648
writeln("Максимальное значение : ", int.max); // 2147483647
writeln("Начальное значение : ", int.init); // 0. Это значение,
// присвоенное по умолчанию
// На самом деле типов в D больше, но все мы здесь описывать не будем,
// иначе не уложимся в Y минут.
/*** Приведение типов ***/
// to!(имя типа)(выражение) - для большинства конверсий
import std.conv : to; // функция "to" - часть стандартной библиотеки, а не языка
double d = -1.75;
short s = to!short(d); // s = -1
/*
cast - если вы знаете, что делаете. Кроме того, это единственный способ
преобразования типов-указателей в "обычные" и наоборот
*/
void* v;
int* p = cast(int*)v;
// Для собственного удобства можно создавать псевдонимы
// для различных встроенных объектов
alias int newInt; // теперь можно обращаться к newInt так, как будто бы это int
newInt a = 5;
alias newInt = int; // так тоже допустимо
alias uint[2] pair; // дать псевдоним можно даже сложным структурам данных
/*** Операторы ***/
int x = 10; // присваивание
x = x + 1; // 11
x -= 2; // 9
x++; // 10
++x; // 11
x *= 2; // 22
x /= 2; // 11
x = x ^^ 2; // 121 (возведение в степень)
x ^^= 2; // 1331 (то же самое)
string str1 = "Hello";
string str2 = ", world!";
string hw = str1 ~ str2; // Конкатенация строк
int[] arr = [1, 2, 3];
arr ~= 4; // [1, 2, 3, 4] - добавление элемента в конец массива
/*** Логика и сравнения ***/
int x = 0; int y = 1;
x == y; // false
x > y; // false
x < y; // true
x >= y; // false
x != y; // true. ! — логическое "не"
x > 0 || x < 1; // true. || — логическое "или"
x > 0 && x < 1; // false && — логическое "и"
x ^ y // true; ^ - xor (исключающее "или")
// Тернарный оператор
auto y = (x > 10) ? 1 : 0; // если x больше 10, то y равен 1,
// в противном случае y равен нулю
/*** Управляющие конструкции ***/
// if - абсолютно привычен
if (a == 1) {
// ..
} else if (a == 2) {
// ..
} else {
// ..
}
// switch
switch (a) {
case 1:
// делаем что-нибудь
break;
case 2:
// делаем что-нибудь другое
break;
case 3:
// делаем что-нибудь еще
break;
default:
// default обязателен, без него будет ошибка компиляции
break;
}
// в D есть констукция "final switch". Она не может содержать секцию "defaul"
// и применяется, когда все перечисляемые в switch варианты должны быть
// обработаны явным образом
int dieValue = 1;
final switch (dieValue) {
case 1:
writeln("You won");
break;
case 2, 3, 4, 5:
writeln("It's a draw");
break;
case 6:
writeln("I won");
break;
}
// while
while (a > 10) {
// ..
if (number == 42) {
break;
}
}
while (true) {
// бесконечный цикл
}
// do-while
do {
// ..
} while (a == 10);
// for
for (int number = 1; number < 11; ++number) {
writeln(number); // все абсолютно стандартно
}
for ( ; ; ) {
// секции могут быть пустыми. Это бесконечный цикл в стиле Си
}
// foreach - универсальный и самый "правильный" цикл в D
foreach (element; array) {
writeln(element); // для простых массивов
}
foreach (key, val; aa) {
writeln(key, ": ", val); // для ассоциативных массивов
}
foreach (c; "hello") {
writeln(c); // hello. Поскольку строки - это вариант массива,
// foreach применим и к ним
}
foreach (number; 10..15) {
writeln(number); // численные интервалы можно указывать явным образом
// этот цикл выведет значения с 10 по 14, но не 15,
// поскольку диапазон не включает в себя верхнюю границу
}
// foreach_reverse - в обратную сторону
auto container = [1, 2, 3];
foreach_reverse (element; container) {
writefln("%s ", element); // 3, 2, 1
}
// foreach в массивах и им подобных структурах не меняет сами структуры
int[] a = [1, 2 ,3 ,4 ,5];
foreach (elem; array) {
elem *= 2; // сам массив останется неизменным
}
writeln(a); // вывод: [1, 2, 3, 4, 5] Т.е изменений нет
// добавление ref приведет к тому, что массив будет изменяться
foreach (ref elem; array) {
elem *= 2;
}
writeln(a); // [2, 4, 6, 8, 10]
// foreach умеет рассчитывать индексы элементов
int[] a = [1, 2, 3, 4, 5];
foreach (ind, elem; array) {
writeln(ind, " ", elem); // через ind - доступен индекс элемента,
// а через elem - сам элемент
}
/*** Функции ***/
test(42); // Что, вот так сразу? Разве мы где-то уже объявили эту функцию?
// Нет, вот она. Это не Си, здесь объявление функции не обязательно должно быть
// до первого вызова
int test(int argument) {
return argument * 2;
}
// В D используется единый синтаксис вызова функций
// (UFCS, Uniform Function Call Syntax), поэтому так тоже можно:
int var = 42.test();
// и даже так, если у функции нет аргументов:
int var2 = 42.test;
// можно выстраивать цепочки:
int var3 = 42.test.test;
/*
Аргументы в функцию передаются по значению (т.е. функция работает не с
оригинальными значениями, переданными ей, а с их локальными копиями.
Исключение составляют объекты классов, которые передаются по ссылке.
Кроме того, любой параметр можно передать в функцию по ссылке с помощью
ключевого слова "ref"
*/
int var = 10;
void fn1(int arg) {
arg += 1;
}
void fn2(ref int arg) {
arg += 1;
}
fn1(var); // var все еще = 10
fn2(var); // теперь var = 11
// Возвращаемое значение тоже может быть auto,
// если его можно "угадать" из контекста
auto add(int x, int y) {
return x + y;
}
auto z = add(x, y); // тип int - компилятор вывел его автоматически
// Значения аргументов по умолчанию
float linearFunction(float k, float x, float b = 1)
{
return k * x + b;
}
auto linear1 = linearFunction(0.5, 2, 3); // все аргументы используются
auto linear2 = linearFunction(0.5, 2); // один аргумент пропущен, но в функции
// он все равно использован и равен 1
// допускается описание вложенных функций
float quarter(float x) {
float doubled(float y) {
return y * y;
}
return doubled(doubled(x));
}
// функции с переменным числом аргументов
int sum(int[] a...)
{
int s = 0;
foreach (elem; a) {
s += elem;
}
return s;
}
auto sum1 = sum(1);
auto sum2 = sum(1,2,3,4);
/*
модификатор "in" перед аргументами функций говорит о том, что функция имеет
право их только просматривать. При попытке модификации такого аргумента
внутри функции - получите ошибку
*/
float printFloat(in float a)
{
writeln(a);
}
printFloat(a); // использование таких функций - самое обычное
// модификатор "out" позволяет вернуть из функции несколько результатов
// без посредства глобальных переменных или массивов
uint remMod(uint a, uint b, out uint modulus)
{
uint remainder = a / b;
modulus = a % b;
return remainder;
}
uint modulus; // пока в этой переменной ноль
uint rem = remMod(5, 2, modulus); // наша "хитрая" функция, и теперь
// в modulus - остаток от деления
writeln(rem, " ", modulus); // вывод: 2 1
/*** Структуры, классы, базовое ООП ***/
// Объявление структуры. Структуры почти как в Си
struct MyStruct {
int a;
float b;
void multiply() {
return a * b;
}
}
MyStruct str1; // Объявление переменной с типом MyStruct
str1.a = 10; // Обращение к полю
str1.b = 20;
auto result = str1.multiply();
MyStruct str2 = {4, 8} // Объявление + инициализация в стиле Си
auto str3 = MyStruct(5, 10); // Объявление + инициализация в стиле D
// области видимости полей и методов - 3 способа задания
struct MyStruct2 {
public int a;
private:
float b;
bool c;
protected {
float multiply() {
return a * b;
}
}
/*
в дополнение к знакомым public, private и protected, в D есть еще
область видимости "package". Поля и методы с этим атрибутом будут
доступны изо всех модулей, включенных в "пакет" (package), но не
за его пределами. package - это "папка", в которой может храниться
несколько модулей. Например, в "import.std.stdio", "std" - это
package, в котором есть модуль stdio (и еще множество других)
*/
package:
string d;
/* помимо этого, имеется еще один модификатор - export, который позволяет
использовать объявленный с ним идентификатор даже вне самой программы !
*/
export:
string description;
}
// Конструкторы и деструкторы
struct MyStruct3 {
this() { // конструктор. Для структур его не обязательно указывать явно,
// в этом случае пустой конструктор добавляется компилятором
writeln("Hello, world!");
}
// а вот это конструкция - одна из интересных идиом и представляет собой
// конструктор копирования, т.е конструктор, возвращающий копию структуры.
// Работает только в структурах.
this(this)
{
return this;
}
~this() { // деструктор, также необязателен
writeln("Awww!");
}
}
// Объявление простейшего класса
class MyClass {
int a; // в D по умолчанию данные-члены являются public
float b;
}
auto mc = new MyClass(); // ...и создание его экземпляра
auto mc2 = new MyClass; // ... тоже сработает
// Конструктор
class MyClass2 {
int a;
float b;
this(int a, float b) {
this.a = a; // ключевое слово "this" - ссылка на объект класса
this.b = b;
}
}
auto mc2 = new MyClass2(1, 2.3);
// Классы могут быть вложенными
class Outer
{
int m;
class Inner
{
int foo()
{
return m; // можно обращаться к полям "внешнего" класса
}
}
}
// наследование
class Base {
int a = 1;
float b = 2.34;
// это статический метод, т.е метод который можно вызывать, обращаясь
// к классу напрямую, а не через создание экземпляра объекта
static void multiply(int x, int y)
{
writeln(x * y);
}
}
Base.multiply(2, 5); // используем статический метод. Результат: 10
class Derived : Base {
string c = "Поле класса - наследника";
// override означает то, что наследник предоставит свою реализацию метода,
// переопределив метод базового класса
override static void multiply(int x, int y)
{
super.multiply(x, y); // super - это ссылка на класс-предок, или базовый класс
writeln(x * y * 2);
}
}
auto mc3 = new Derived();
writeln(mc3.a); // 1
writeln(mc3.b); // 2.34
writeln(mc3.c); // Поле класса - наследника
// Финальный класс, наследовать от него нельзя
// кроме того, модификатор final работает не только для классов, но и для методов
// и даже для модулей !
final class FC {
int a;
}
class Derived : FC { // это вызовет ошибку
float b;
}
// Абстрактный класс не может быть истанциирован, но может иметь наследников
abstract class AC {
int a;
}
auto ac = new AC(); // это вызовет ошибку
class Implementation : AC {
float b;
// final перед методом нефинального класса означает запрет возможности
// переопределения метода
final void test()
{
writeln("test passed !");
}
}
auto impl = new Implementation(); // ОК
/*** Примеси (mixins) ***/
// В D можно вставлять код как строку, если эта строка известна на этапе
// компиляции. Например:
void main() {
mixin(`writeln("Hello World!");`);
}
// еще пример
string print(string s) {
return `writeln("` ~ s ~ `");`;
}
void main() {
mixin (print("str1"));
mixin (print("str2"));
}
/*** Шаблоны ***/
/*
Шаблон функции. Эта функция принимает аргументы разных типов, которые
подставляются вместо T на этапе компиляции. "T" - это не специальный
символ, а просто буква. Вместо "T" может быть любое слово, кроме ключевого.
*/
void print(T)(T value) {
writefln("%s", value);
}
void main() {
print(42); // В одну и ту же функцию передается: целое
print(1.2); // ...число с плавающей точкой,
print("test"); // ...строка
}
// "Шаблонных" параметров может быть сколько угодно
void print(T1, T2)(T1 value1, T2 value2) {
writefln(" %s %s", value1, value2);
}
void main() {
print(42, "Test");
print(1.2, 33);
}
// Шаблон класса
class Stack(T)
{
private:
T[] elements;
public:
void push(T element) {
elements ~= element;
}
void pop() {
--elements.length;
}
T top() const @property {
return elements[$ - 1];
}
size_t length() const @property {
return elements.length;
}
}
void main() {
/*
восклицательный знак - признак шаблона. В данном случае мы создаем
класс и указываем, что "шаблонное" поле будет иметь тип string
*/
auto stack = new Stack!string;
stack.push("Test1");
stack.push("Test2");
writeln(stack.top);
writeln(stack.length);
stack.pop;
writeln(stack.top);
writeln(stack.length);
}
/*** Диапазоны (ranges) ***/
/*
Диапазоны - это абстракция, которая позволяет легко использовать разные
алгоритмы с разными структурами данных. Вместо того, чтобы определять свои
уникальные алгоритмы для каждой структуры, мы можем просто указать для нее
несколько единообразных функций, определяющих, _как_ мы получаем доступ
к элементам контейнера, вместо того, чтобы описывать внутреннее устройство
этого контейнера. Сложно? На самом деле не очень.
Простейший вид диапазона - Input Range. Для того, чтобы превратить любой
контейнер в Input Range, достаточно реализовать для него 3 метода:
- empty - проверяет, пуст ли контейнер
- front - дает доступ к первому элементу контейнера
- popFront - удаляет из контейнера первый элемент
*/
struct Student
{
string name;
int number;
string toString() {
return format("%s(%s)", name, number);
}
}
struct School
{
Student[] students;
}
struct StudentRange
{
Student[] students;
this(School school) {
this.students = school.students;
}
bool empty() {
return students.length == 0;
}
Student front() {
return students[0];
}
void popFront() {
students = students[1 .. $];
}
}
void main(){
auto school = School([
Student("Mike", 1),
Student("John", 2) ,
Student("Dan", 3)
]);
auto range = StudentRange(school);
writeln(range); // [Mike(1), John(2), Dan(3)]
writeln(school.students.length); // 3
writeln(range.front()); // Mike(1)
range.popFront();
writeln(range.empty()); // false
writeln(range); // [John(2), Dan(3)]
}
/*
Смысл в том, что нам не так уж важно внутреннее устройство контейнера, если
у нас есть унифицированные методы доступа к его элементам.
Кроме Input Range в D есть и другие типы диапазонов, которые требуют
реализации большего числа методов, зато дают больше контроля. Это большая
тема и мы не будем в подробностях освещать ее здесь.
Диапазоны - это важная часть D, они используются в нем повсеместно.
*/
```
## Что дальше?
- [Официальный сайт](http://dlang.org/)
- [Онлайн-книга](http://ddili.org/ders/d.en/)
- [Официальная вики](http://wiki.dlang.org/)

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

@ -18,7 +18,7 @@ lang: ru-ru
% Пунктуационные знаки, используемые в Erlang: % Пунктуационные знаки, используемые в Erlang:
% Запятая (`,`) разделяет аргументы в вызовах функций, структурах данных и % Запятая (`,`) разделяет аргументы в вызовах функций, структурах данных и
% образцах. % образцах.
% Точка (`.`) (с пробелом после них) разделяет функции и выражения в % Точка (`.`) (с пробелом после неё) разделяет функции и выражения в
% оболочке. % оболочке.
% Точка с запятой (`;`) разделяет выражения в следующих контекстах: % Точка с запятой (`;`) разделяет выражения в следующих контекстах:
% формулы функций, выражения `case`, `if`, `try..catch` и `receive`. % формулы функций, выражения `case`, `if`, `try..catch` и `receive`.

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

@ -330,7 +330,7 @@ function sayHelloInFiveSeconds(name) {
sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!» sayHelloInFiveSeconds("Адам"); // Через 5 с откроется окно «Привет, Адам!»
/////////////////////////////////// ///////////////////////////////////
// 5. Подробнее об объектах; конструкторы и прототипы // 5. Подробнее об объектах; Конструкторы и Прототипы
// Объекты могут содержать в себе функции. // Объекты могут содержать в себе функции.
var myObj = { var myObj = {

27
ru-ru/objective-c-ru.html.markdown
View File

@ -381,20 +381,21 @@ if ([myClass respondsToSelector:selectorVar]) { // Проверяет содер
NSLog(@"MyClass не содержит метод: %@", NSStringFromSelector(selectedVar)); NSLog(@"MyClass не содержит метод: %@", NSStringFromSelector(selectedVar));
} }
// Имплементируйте методы в файле МойКласс.m: // Имплементируйте методы в файле MyClass.m:
@implementation MyClass { @implementation MyClass {
long distance; // Переменная экземпляра с закрытым (private) доступом long distance; // Переменная экземпляра с закрытым (private) доступом
NSNumber height; NSNumber height;
} }
// To access a public variable from the interface file, use '_' followed by variable name: // Для доступа к public переменной, объявленной в интерфейсе, используйте '_' перед названием переменной:
_count = 5; // References "int count" from MyClass interface _count = 5; // Ссылается на "int count" из интерфейса MyClass
// Access variables defined in implementation file: // Получение доступа к переменной, объявленной в реализации происходит следующим образом:
distance = 18; // References "long distance" from MyClass implementation distance = 18; // Ссылается на "long distance" из реализации MyClass
// To use @property variable in implementation, use @synthesize to create accessor variable: // Для использования в иплементации переменной, объявленной в интерфейсе с помощью @property,
@synthesize roString = _roString; // _roString available now in @implementation // следует использовать @synthesize для создания переменной аксессора:
@synthesize roString = _roString; // Теперь _roString доступна в @implementation (реализации интерфейса)
// Called before calling any class methods or instantiating any objects // Вызывается в первую очередь, перед вызовом других медотов класса или инициализации других объектов
+ (void)initialize + (void)initialize
{ {
if (self == [MyClass class]) { if (self == [MyClass class]) {
@ -505,10 +506,10 @@ distance = 18; // References "long distance" from MyClass implementation
@end @end
// Теперь, если мы хотели создать грузовой объект, мы должны вместо создания подкласса класса Car, как это будет // Теперь, если мы хотим создать объект Truck - грузовик, мы должны создать подкласс класса Car, что
// изменять функциональность Car чтобы вести себя подобно грузовику. Но давайте посмотрим, если мы хотим только добавить // изменит функционал Car и позволит вести себя подобно грузовику. Но что, если мы хотим только добавить
// функциональность в существующий Car. Хороший пример должен быть чистить автомобиль. Итак мы создадим // определенный функционал в уже существующий класс Car? Например - чистка автомобиля. Мы просто создадим
// категорию для добавления его очистительных методов: // категорию, которая добавит несколько методов для чистки автомобиля в класс Car:
// @interface ИмяФайла: Car+Clean.h (ИмяБазовогоКласса+ИмяКатегории.h) // @interface ИмяФайла: Car+Clean.h (ИмяБазовогоКласса+ИмяКатегории.h)
#import "Car.h" // Убедитесь в том, что базовый класс импортирован для расширения. #import "Car.h" // Убедитесь в том, что базовый класс импортирован для расширения.
@ -794,7 +795,7 @@ MyClass *arcMyClass = [[MyClass alloc] init];
// weakVar-свойство автоматически примет значение nil, // weakVar-свойство автоматически примет значение nil,
// во избежание падения приложения // во избежание падения приложения
@property (strong) MyClass *strongVar; // 'strong' принимает право на владение @property (strong) MyClass *strongVar; // 'strong' принимает право на владение
// объектом. Гарантирует, что объект останится в памяти для использования // объектом. Гарантирует, что объект останется в памяти для использования
// Для обычных переменных (не объявленных с помощью @property), используйте // Для обычных переменных (не объявленных с помощью @property), используйте
// следующий способ: // следующий способ:

195
ru-ru/perl-ru.html.markdown Normal file
View File

@ -0,0 +1,195 @@
---
category: language
language: perl
filename: learnperl-ru.pl
contributors:
- ["Korjavin Ivan", "http://github.com/korjavin"]
translators:
- ["Elena Bolshakova", "http://github.com/liruoko"]
lang: ru-ru
---
Perl 5 -- высокоуровневый мощный язык с 25-летней историей.
Особенно хорош для обработки разнообразных текстовых данных.
Perl 5 работает более чем на 100 платформах, от портативных устройств
до мейнфреймов, и подходит как для быстрого прототипирования,
так и для крупных проектов.
```perl
# Комментарии начинаются с символа решетки.
#### Типы переменных в Perl
# Скалярные переменные начинаются с знака доллара $.
# Имя переменной состоит из букв, цифр и знаков подчеркивания,
# начиная с буквы или подчеркивания.
### В Perl три основных типа переменных: скаляры, массивы, хеши.
## Скаляры
# Скаляр хранит отдельное значение:
my $animal = "camel";
my $answer = 42;
# Скаляры могут быть строками, целыми и вещественными числами.
# Когда требуется, Perl автоматически выполняет преобразования к нужному типу.
## Массивы
# Массив хранит список значений:
my @animals = ("camel", "llama", "owl");
my @numbers = (23, 42, 69);
my @mixed = ("camel", 42, 1.23);
## Хеши
# Хеш хранит набор пар ключ/значение:
my %fruit_color = ("apple", "red", "banana", "yellow");
# Можно использовать оператор "=>" для большей наглядности:
my %fruit_color = (
apple => "red",
banana => "yellow",
);
# Важно: вставка и поиск в хеше выполняются за константное время,
# независимо от его размера.
# Скаляры, массивы и хеши подробно описаны в разделе perldata
# (perldoc perldata).
# Более сложные структуры данных можно получить, если использовать ссылки.
# С помощью ссылок можно получить массив массивов хешей, в которых хранятся другие хеши.
#### Условные операторы и циклы
# В Perl есть большинсво привычных условных и циклических конструкций.
if ( $var ) {
...
} elsif ( $var eq 'bar' ) {
...
} else {
...
}
unless ( condition ) {
...
}
# Это более читаемый вариант для "if (!condition)"
# Специфические Perl-овые пост-условия:
print "Yow!" if $zippy;
print "We have no bananas" unless $bananas;
# while
while ( condition ) {
...
}
# for, foreach
for ($i = 0; $i <= $max; $i++) {
...
}
foreach (@array) {
print "This element is $_\n";
}
for my $el (@array) {
print "This element is $el\n";
}
#### Регулярные выражения
# Регулярные выражения занимают важное место в Perl-е,
# и подробно описаны в разделах документации perlrequick, perlretut и других.
# Вкратце:
# Сопоставление с образцом
if (/foo/) { ... } # выполняется, если $_ содержит "foo"
if ($a =~ /foo/) { ... } # выполняется, если $a содержит "foo"
# Простые замены
$a =~ s/foo/bar/; # заменяет foo на bar в строке $a
$a =~ s/foo/bar/g; # заменяет ВСЕ ВХОЖДЕНИЯ foo на bar в строке $a
#### Файлы и ввод-вывод
# Открыть файл на чтение или запись можно с помощью функции "open()".
open(my $in, "<", "input.txt") or die "Can't open input.txt: $!";
open(my $out, ">", "output.txt") or die "Can't open output.txt: $!";
open(my $log, ">>", "my.log") or die "Can't open my.log: $!";
# Читать из файлового дескриптора можно с помощью оператора "<>".
# В скалярном контексте он читает одну строку из файла, в списковом --
# читает сразу весь файл, сохраняя по одной строке в элементе массива:
my $line = <$in>;
my @lines = <$in>;
#### Подпрограммы (функции)
# Объявить функцию просто:
sub logger {
my $logmessage = shift;
open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
print $logfile $logmessage;
}
# Теперь можно использовать эту функцию так же, как и встроенные:
logger("We have a logger subroutine!");
```
#### Perl-модули
Perl-овые модули предоставляют широкий набор функциональности,
так что вы можете не изобретать заново велосипеды, а просто скачать
нужный модуль с CPAN (http://www.cpan.org/).
Некоторое количество самых полезных модулей включено в стандартную
поставку Perl.
Раздел документации perlfaq содержит вопросы и ответы о многих частых
задачах, и часто предлагает подходящие CPAN-модули.
#### Unicode
Вам наверняка понадобится работать с не-ASCII текстами.
Добавьте эти прагмы в начало скрипта:
```perl
use utf8;
use open ':std' => ':utf8';
```
Подробнее читайте в perldoc, разделы perlunicode и open.
#### strict, warnings
Прагмы strict и warnings включают полезные проверки во время компиляции:
```perl
use strict;
use warnings;
```
Подробнее смотрите perldoc strict и perldoc warnings.
#### Смотрите также
- [perl-tutorial](http://perl-tutorial.org/)
- [обучающий раздел на www.perl.com](http://www.perl.org/learn.html)
- [perldoc в вебе](http://perldoc.perl.org/)
- встроенная справка : `perldoc perlintro`

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

@ -420,8 +420,6 @@ include_once 'my-file.php';
require 'my-file.php'; require 'my-file.php';
require_once 'my-file.php'; require_once 'my-file.php';
// Same as include(), except require() will cause a fatal error if the
// file cannot be included.
// Действует также как и include(), но если файл не удалось подключить, // Действует также как и include(), но если файл не удалось подключить,
// функция выдает фатальную ошибку // функция выдает фатальную ошибку
@ -485,7 +483,7 @@ echo MyClass::MY_CONST; // Выведет 'value';
echo MyClass::$staticVar; // Выведет 'static'; echo MyClass::$staticVar; // Выведет 'static';
MyClass::myStaticMethod(); // Выведет 'I am static'; MyClass::myStaticMethod(); // Выведет 'I am static';
// Новый экземпляр класса используя new // Создание нового экземпляра класса используя new
$my_class = new MyClass('An instance property'); $my_class = new MyClass('An instance property');
// Если аргументы отсутствуют, можно не ставить круглые скобки // Если аргументы отсутствуют, можно не ставить круглые скобки

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

@ -280,7 +280,7 @@ filled_dict.get("four", 4) #=> 4
# Присваивайте значение ключам так же, как и в списках # Присваивайте значение ключам так же, как и в списках
filled_dict["four"] = 4 # теперь filled_dict["four"] => 4 filled_dict["four"] = 4 # теперь filled_dict["four"] => 4
# Метод setdefault вставляет() пару ключ-значение, только если такого ключа нет # Метод setdefault() вставляет пару ключ-значение, только если такого ключа нет
filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5 filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5 filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5

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

@ -549,7 +549,7 @@ Human.grunt() #=> "*grunt*"
# Вы можете импортировать модули # Вы можете импортировать модули
import math import math
print(math.sqrt(16)) #=> 4 print(math.sqrt(16)) #=> 4.0
# Вы можете импортировать отдельные функции модуля # Вы можете импортировать отдельные функции модуля
from math import ceil, floor from math import ceil, floor

22
ruby.html.markdown
View File

@ -14,6 +14,7 @@ contributors:
- ["Rahil Momin", "https://github.com/iamrahil"] - ["Rahil Momin", "https://github.com/iamrahil"]
- ["Gabriel Halley", "https://github.com/ghalley"] - ["Gabriel Halley", "https://github.com/ghalley"]
- ["Persa Zula", "http://persazula.com"] - ["Persa Zula", "http://persazula.com"]
- ["Jake Faris", "https://github.com/farisj"]
--- ---
```ruby ```ruby
@ -41,7 +42,11 @@ You shouldn't either
35 / 5 #=> 7 35 / 5 #=> 7
2**5 #=> 32 2**5 #=> 32
5 % 3 #=> 2 5 % 3 #=> 2
5 ^ 6 #=> 3
# Bitwise operators
3 & 5 #=> 1
3 | 5 #=> 7
3 ^ 5 #=> 6
# Arithmetic is just syntactic sugar # Arithmetic is just syntactic sugar
# for calling a method on an object # for calling a method on an object
@ -49,7 +54,7 @@ You shouldn't either
10.* 5 #=> 50 10.* 5 #=> 50
# Special values are objects # Special values are objects
nil # Nothing to see here nil # equivalent to null in other languages
true # truth true # truth
false # falsehood false # falsehood
@ -77,6 +82,11 @@ false.class #=> FalseClass
2 <= 2 #=> true 2 <= 2 #=> true
2 >= 2 #=> true 2 >= 2 #=> true
# Combined comparison operator
1 <=> 10 #=> -1
10 <=> 1 #=> 1
1 <=> 1 #=> 0
# Logical operators # Logical operators
true && false #=> false true && false #=> false
true || false #=> true true || false #=> true
@ -122,7 +132,7 @@ puts "I'm printing!"
# print to the output without a newline # print to the output without a newline
print "I'm printing!" print "I'm printing!"
#=> I'm printing! => nill #=> I'm printing! => nil
# Variables # Variables
x = 25 #=> 25 x = 25 #=> 25
@ -220,8 +230,8 @@ new_hash = { defcon: 3, action: true }
new_hash.keys #=> [:defcon, :action] new_hash.keys #=> [:defcon, :action]
# Check existence of keys and values in hash # Check existence of keys and values in hash
new_hash.has_key?(:defcon) #=> true new_hash.key?(:defcon) #=> true
new_hash.has_value?(3) #=> true new_hash.value?(3) #=> true
# Tip: Both Arrays and Hashes are Enumerable # Tip: Both Arrays and Hashes are Enumerable
# They share a lot of useful methods such as each, map, count, and more # They share a lot of useful methods such as each, map, count, and more
@ -579,7 +589,9 @@ Something.new.qux # => 'qux'
## Additional resources ## Additional resources
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges. - [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Learn Ruby through a series of interactive tutorials.
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/) - [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/) - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online. - [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide. - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
- [Try Ruby](http://tryruby.org) - Learn the basic of Ruby programming language, interactive in the browser.

13
sass.html.markdown
View File

@ -4,15 +4,16 @@ filename: learnsass.scss
contributors: contributors:
- ["Laura Kyle", "https://github.com/LauraNK"] - ["Laura Kyle", "https://github.com/LauraNK"]
- ["Sean Corrales", "https://github.com/droidenator"] - ["Sean Corrales", "https://github.com/droidenator"]
- ["Kyle Mendes", "https://github.com/pink401k"]
--- ---
Sass is a CSS extension language that adds features such as variables, nesting, mixins and more. Sass is a CSS extension language that adds features such as variables, nesting, mixins and more.
Sass (and other preprocessors, such as [Less](http://lesscss.org/)) help developers to write maintainable and DRY (Don't Repeat Yourself) code. Sass (and other preprocessors, such as [Less](http://lesscss.org/)) help developers write maintainable and DRY (Don't Repeat Yourself) code.
Sass has two different syntax options to choose from. SCSS, which has the same syntax as CSS but with the added features of Sass. Or Sass (the original syntax), which uses indentation rather than curly braces and semicolons. Sass has two different syntax options to choose from. SCSS, which has the same syntax as CSS but with the added features of Sass. Or Sass (the original syntax), which uses indentation rather than curly braces and semicolons.
This tutorial is written using SCSS. This tutorial is written using SCSS.
If you're already familiar with CSS3, you'll be able to pick up Sass relatively quickly. It does not provide any new styling options but rather the tools to write your CSS more efficiently and make maintenance much easier. If you're already familiar with CSS3, you'll be able to pick up Sass relatively quickly. It does not provide any new styling properties but rather the tools to write your CSS more efficiently and make maintenance much easier.
```scss ```scss
@ -110,7 +111,7 @@ div {
@include size(40px, 40px); @include size(40px, 40px);
} }
/* This compiles to: */ /* Compiles to: */
.rectangle { .rectangle {
width: 100px; width: 100px;
height: 60px; height: 60px;
@ -216,7 +217,7 @@ $main-content: calculate-percentage(600px, 960px);
} }
/* Extending a CSS statement is preferable to creating a mixin /* Extending a CSS statement is preferable to creating a mixin
because of the way it groups together the classes that all share because of the way Sass groups together the classes that all share
the same base styling. If this was done with a mixin, the width, the same base styling. If this was done with a mixin, the width,
height, and border would be duplicated for each statement that height, and border would be duplicated for each statement that
called the mixin. While it won't affect your workflow, it will called the mixin. While it won't affect your workflow, it will
@ -418,11 +419,8 @@ body {
width: 6.25%; width: 6.25%;
} }
``` ```
## SASS or Sass? ## SASS or Sass?
Have you ever wondered whether Sass is an acronym or not? You probably haven't, but I'll tell you anyway. The name of the language is a word, "Sass", and not an acronym. Have you ever wondered whether Sass is an acronym or not? You probably haven't, but I'll tell you anyway. The name of the language is a word, "Sass", and not an acronym.
Because people were constantly writing it as "SASS", the creator of the language jokingly called it "Syntactically Awesome StyleSheets". Because people were constantly writing it as "SASS", the creator of the language jokingly called it "Syntactically Awesome StyleSheets".
@ -434,7 +432,6 @@ You can use either syntax, just go into the settings and select either Sass or S
## Compatibility ## Compatibility
Sass can be used in any project as long as you have a program to compile it Sass can be used in any project as long as you have a program to compile it
into CSS. You'll want to verify that the CSS you're using is compatible into CSS. You'll want to verify that the CSS you're using is compatible
with your target browsers. with your target browsers.

17
scala.html.markdown
View File

@ -169,6 +169,12 @@ def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
// Syntax for calling functions is familiar: // Syntax for calling functions is familiar:
sumOfSquares(3, 4) // => 25 sumOfSquares(3, 4) // => 25
// You can use parameters names to specify them in different order
def subtract(x: Int, y: Int): Int = x - y
subtract(10, 3) // => 7
subtract(y=10, x=3) // => -7
// In most cases (with recursive functions the most notable exception), function // In most cases (with recursive functions the most notable exception), function
// return type can be omitted, and the same type inference we saw with variables // return type can be omitted, and the same type inference we saw with variables
// will work with function return values: // will work with function return values:
@ -321,9 +327,15 @@ divideInts(10, 3) // (Int, Int) = (3,1)
val d = divideInts(10, 3) // (Int, Int) = (3,1) val d = divideInts(10, 3) // (Int, Int) = (3,1)
d._1 // Int = 3 d._1 // Int = 3
d._2 // Int = 1 d._2 // Int = 1
// Alternatively you can do multiple-variable assignment to tuple, which is more
// convenient and readable in many cases
val (div, mod) = divideInts(10, 3)
div // Int = 3
mod // Int = 1
///////////////////////////////////////////////// /////////////////////////////////////////////////
// 5. Object Oriented Programming // 5. Object Oriented Programming
@ -454,6 +466,9 @@ def matchEverything(obj: Any): String = obj match {
// You can nest patterns: // You can nest patterns:
case List(List((1, 2, "YAY"))) => "Got a list of list of tuple" case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
// Match any case (default) if all previous haven't matched
case _ => "Got unknown object"
} }
// In fact, you can pattern match any object with an "unapply" method. This // In fact, you can pattern match any object with an "unapply" method. This

208
sk-sk/LearnGit-sk.txt Normal file
View File

@ -0,0 +1,208 @@
$ git init
# Zobraz a Nastav Základné Konfiguračné Premenné (Globálne)
$ git config --global user.email "MôjEmail@Zoho.com"
$ git config --global user.name "Moje Meno
# Rýchlo zobraz všetky dostupné príkazy
$ git help
# Zobraz všetky dostupné príkazy
$ git help -a
# Zobraz konkrétnu pomoc - použivateľský manuál
# git help <príkaz_tu>
$ git help add
$ git help commit
$ git help init
# alebo git <príkaz_tu> --help
$ git add --help
$ git commit --help
$ git init --help
# Zobrazí vetvu, nesledované súbory, zmeny a ostatné rozdiely
$ git status
# Zistí iné vychytávky o git statuse
$ git help status
# pridá súbor z tvojho pracovného adresára
$ git add HelloWorld.java
# pridá súbor z iného adresára
$ git add /cesta/k/súboru/HelloWorld.c
# Môžeš použiť regulárne výrazy!
$ git add ./*.java
# zobraz existujúce vetvy a vzdialené repozitáre
$ git branch -a
# vytvor novú vetvu
$ git branch myNewBranch
# vymaž vetvu
$ git branch -d myBranch
# premenuj vetvu
# git branch -m <starémeno> <novémeno>
$ git branch -m mojaStaraVetva mojaNovaVetva
# zmeň opis vetvy
$ git branch myBranchName --edit-description
# Zobrazí tagy
$ git tag
# Vytvorí tag so správou
# -m špecifikuje správu, ktorá bude s tagom uložená.
# Ak nešpeficikuješ správu pri tagu so správou,
# Git spustí tvoj editor, aby si ju napísal.
$ git tag -a v2.0 -m 'moja verzia 2.0'
# Ukáž informácie o tagu
# Zobrazí zadané informácie, dátum tagnutia commitu
# a správu pred zobrazením informácií o commite.
$ git show v2.0
# Zverejní (pushne) jediný tag do vzdialeného repozitára
$ git push origin v2.0
# Zverejní viacero tagov do vzdialeného repozitára
$ git push origin --tags
# Aktualizuj strom, aby odpovedal (predvolene)
# hlavnej vetve repozitáru (master branch)
$ git checkout
# Aktualizuj strom, aby odpovedal konrkétnej vetve
$ git checkout menoVetvy
# Vytvor novú vetvu & prepni sa na ňu
# ekvivalentný príkaz: "git branch <meno>; git checkout <meno>"
$ git checkout -b nováVetva
# Naklonuj learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
# povrchné klonovanie - rýchlejšie, uloží iba najnovšiu snímku
$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
# naklonuj iba konkrétnu vetvu
$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
# commitni so správou
$ git commit -m "Pridal som multiplyNumbers() funkciu do HelloWorld.c"
# automaticky pridaj zmenené a vymazané súbory do staging indexu, potom ich commitni.
$ git commit -a -m "Zmenil som foo.php a vymazal bar.php"
# zmeň posledný commit (toto nahradí predchádzajúci commit novým)
$ git commit --amend -m "Správna správa"
# Ukáž rozdiel medzi pracovným repozitárom a indexom.
$ git diff
# Ukáž rozdiely medzi indexom a najnovším commitom.
$ git diff --cached
# Ukáž rozdiely medzi pracovným adresárom a najnovším commitom.
$ git diff HEAD
# Nastav, aby sa vo výsledkoch vyhľadávania zobrazovalo číslo riadku
$ git config --global grep.lineNumber true
# Urob výsledky vyhľadávania čitateľnejšie, vrátane zoskupovania
$ git config --global alias.g "grep --break --heading --line-number"
# Vďaka Travisovi Jefferymu za túto sekciu
# Hľadaj "názovPremennej" vo všetkých java súboroch
$ git grep 'názovPremennej' -- '*.java'
# Hľadaj riadok, ktorý obsahuje "názovPoľa" a "add" alebo "remove"
$ git grep -e 'arrayListName' --and \( -e add -e remove \)
# Zobraz všetky commity
$ git log
# Zobraz iba správy a referencie commitov
$ git log --oneline
# Zobraz zlúčené (merged) commity
$ git log --merges
# Zobraz všetky commity vo forme ASCII grafu
$ git log --graph
# Zlúč vybranú vetvu do aktuálnej.
$ git merge názovVetvy
# Vždy vytvor zlučovací commit
$ git merge --no-ff názovVetvy
# Premenuj súbor
$ git mv HelloWorld.c HelloNewWorld.c
# Presuň súbor
$ git mv HelloWorld.c ./nová/cesta/HelloWorld.c
# "Nasilu" premenuj, alebo presuň
# "existujúciSúbor" už v adresári existuje, bude prepísaný
$ git mv -f môjSúbor existujúciSúbor
# Aktualizuje tvoj lokálny repozitár zlúčením nových zmien
# zo vzdialených "origin" a "master" vetiev.
# git pull <alias-vzdialeného-repo> <vetva>
$ git pull origin master
# Predvolene, git pull aktualizuje tvoju aktuálnu vetvu
# zlúčením nových zmien zo vzdialenej vetvy
$ git pull
# Zlúč zmeny zo vzdialenej vetvy a presuň vetvu do nového základného commitu (rebase)
# vetva commitne na tvoj lokálny repozitár, ekvivalentný príkaz: "git pull <alias-vzdialeného-repo> <vrstva>, git rebase <branch>"
$ git pull origin master --rebase
# Zverejni a zlúč zmeny z lokálneho repozitára do
# vzdialených vetiev s názvom "origin" a "master".
# git push <vzdialené> <vetvy>
$ git push origin master
# Predvolene git zverejní a zlúči zmeny z
# aktuálnej vetvy do vzdialenej vetvy s ňou spojenej
$ git push
# Na spojenie lokálnej vetvy so vzdialenou pridaj -u:
$ git push -u origin master
# Kedykoľvek budeš chcieť zverejniť z rovnakej lokálnej vetvy, použi príkaz:
$ git push
# Aplikuj commity z experimentálnej vetvy na master
# git rebase <základnáVetva> <ináVetva>
$ git rebase master experimentBranch
# Resetni index (vrstvu medzi pracovným stromom a Git repozitárom), aby odpovedal najnovšiemu commitu (adresár ostane nezmenený)
$ git reset
# Resetni index, aby odpovedal najnovšiemu commitu (adresár sa prepíše)
$ git reset --hard
# Presunie vrchol aktuálnuej vetvy do konkrétneho commitu (adresár ostane nezmenený)
# všetky zmeny sú zachované v adresári.
$ git reset 31f2bb1
# Vezmi späť konkrétny commit
$ git revert <commit>
# odstráň HelloWorld.c
$ git rm HelloWorld.c
# Odstráň súbor z vnoreného adresára
$ git rm /pather/to/the/file/HelloWorld.c

523
sk-sk/git.html.markdown Normal file
View File

@ -0,0 +1,523 @@
---
category: tool
tool: git
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
- ["Leo Rudberg" , "http://github.com/LOZORD"]
- ["Betsy Lorton" , "http://github.com/schbetsy"]
- ["Bruno Volcov", "http://github.com/volcov"]
- ["Andrew Taylor", "http://github.com/andrewjt71"]
translators:
- ["Terka Slanináková", "http://github.com/TerkaSlan"]
lang: sk-sk
filename: LearnGit-sk.txt
---
Git je distribuovaný systém riadenia revízií a správy zdrojového kódu.
Funguje robením "snímkov" tvojho projektu, s ktorými ďalej pracuje na revíziach a správe zdrojových kódov.
## Koncept Revízií
### Čo je riadenie revízií?
Riadenie revízií je systém, ktorý postupom času zaznamenáva zmeny súboru (súborov).
### Centralizované Revízie VS Distribuované revízie
* Centralizované riadenie revízií sa zameriava na synchronizáciu, sledovanie a zálohovanie súborov.
* Distribuované riadenie revízií sa zameriava na zdieľanie zmien. Kaťdá zmena má jedinečný identifikátor (id).
* Distribuované systémy nemajú definovanú štruktúru. S gitom môžeš mať centralizovaný systém v subversion (SVN) štýle.
[Ďalšie informácie](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
### Prečo Používať Git?
* Môžeš pracovať offline.
* Spolupráca s ostatnými je jednoduchá!
* Vetvenie je jednoduché!
* Zlučovanie je jednoduché!
* Git je rýchly.
* Git je flexibilný.
## Architektúra Gitu
### Repozitár
Skupina súborov, adresárov, minulých záznamov, commitov (konkrétnych revízií) a odkazy na aktuálu vetvu (HEADs). Predstav si ho ako údajovú štruktúru, kde ti každý "prvok" zdrojového kódu poskytne (okrem iného) prístup k minulým revíziam.
Git repozitár sa skladá z .git adresára a pracovného stromu
### .git Adresár (časť repozitára)
.git adresár obsahuje všetky konfigurácie, logy, vetvy, odkaz na aktuálnu vetvu (HEAD) a ostatné.
[Detailný zoznam.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
### Pracovný Strom (Working Tree - časť repozitára)
Toto sú adresáre a súbory v tvojom repozitári. Tiež sa tomu hovorí pracovný adresár.
### Index (časť .git adresára)
Index je také odpočívadlo Gitu. Je to v podstate vrstva, ktorá oddeľuje pracovný strom od Git repozitára. Toto dáva vývojárom viac možností nad tým, čo do repozitára naozaj pošlú.
### Commit
Commit je "snímka" zmien, či manipulácií s tvojím Pracovným Stromom. Ak si napríklad pridal 5 súborov a odstránil 2 ďalšie, tieto zmeny budú zachytené v commite. Ten môže (ale nemusí) byť zverejnený (pushed) do iných repozitárov.
### Vetva (Branch)
Vetva je ukazateľ na posledný vykonaný commit. Po ďalších commitnutiach sa ukazateľ bude automaticky posúvať na ten najnovší.
### Tag
Tag je označenie špecifického bodu v minulosti. Typicky sa používa na značenie vydaných verzií (v1.0, atď).
### HEAD a head (časť .git adresára)
HEAD je ukazateľ na aktuálnu vetvu. Repozitár má len 1 *aktívny* HEAD.
head je ukazateľ, ktorý môže ukazovať na akýkoľvek commit. Repozitár môže mať niekoľko headov.
### Štádia Gitu
* Modified - Súbor bol zmenený, no nebol ešte commitnutý do Git Databázy.
* Staged - Zmenený súbor, ktorý pôjde do najbližšieho commit snímku.
* Committed - Súbory boli commitnuté do Git Databázy.
### Koncepčné zdroje
* [Git Pre Informatikov](http://eagain.net/articles/git-for-computer-scientists/)
* [Git Pre Designerov](http://hoth.entp.com/output/git_for_designers.html)
## Príkazy
### init
Vytvorí prázdny Git repozitár. Jeho nastavenia, uložené informácie a mnoho iného sú uložené v adresári (zložke) s názvom ".git".
```bash
$ git init
```
### config
Konfiguruj nastavenia. Či už pre repozitár, samotný systém, alebo globálne konfigurácie (súbor pre globálny config je `~/.gitconfig`).
```bash
# Zobraz a Nastav Základné Konfiguračné Premenné (Globálne)
$ git config --global user.email "MôjEmail@Zoho.com"
$ git config --global user.name "Moje Meno "
```
[Prečítaj si viac o git configu.](http://git-scm.com/docs/git-config)
### pomoc
Máš tiež prístup k extrémne detailnej dokumentácií pre každý príkaz (po anglicky). Hodí sa, ak potrebuješ pripomenúť semantiku.
```bash
# Rýchlo zobraz všetky dostupné príkazy
$ git help
# Zobraz všetky dostupné príkazy
$ git help -a
# Zobraz konkrétnu pomoc - použivateľský manuál
# git help <príkaz_tu>
$ git help add
$ git help commit
$ git help init
# alebo git <príkaz_tu> --help
$ git add --help
$ git commit --help
$ git init --help
```
### ignoruj súbory
Zámerne prestaneš sledovať súbor(y) a zložky. Typicky sa používa pre súkromné a dočasné súbory, ktoré by boli inak zdieľané v repozitári.
```bash
$ echo "temp/" >> .gitignore
$ echo "private_key" >> .gitignore
```
### status
Na zobrazenie rozdielov medzi indexovými súbormi (tvoj pracovný repozitár) a aktuálnym HEAD commitom.
```bash
# Zobrazí vetvu, nesledované súbory, zmeny a ostatné rozdiely
$ git status
# Zistí iné vychytávky o git statuse
$ git help status
```
### add
Pripraví súbory na commit pridaním do tzv. staging indexu. Ak ich nepridáš pomocou `git add` do staging indexu, nebudú zahrnuté v commitoch!
```bash
# pridá súbor z tvojho pracovného adresára
$ git add HelloWorld.java
# pridá súbor z iného adresára
$ git add /cesta/k/súboru/HelloWorld.c
# Môžeš použiť regulárne výrazy!
$ git add ./*.java
```
Tento príkaz len pridáva súbory do staging indexu, necommituje ich do repozitára.
### branch
Spravuj svoje vetvy. Môžeš ich pomocou tohto príkazu zobraziť, meniť, vytvoriť, či zmazať.
```bash
# zobraz existujúce vetvy a vzdialené repozitáre
$ git branch -a
# vytvor novú vetvu
$ git branch myNewBranch
# vymaž vetvu
$ git branch -d myBranch
# premenuj vetvu
# git branch -m <starémeno> <novémeno>
$ git branch -m mojaStaraVetva mojaNovaVetva
# zmeň opis vetvy
$ git branch myBranchName --edit-description
```
### tag
Spravuj svoje tagy
```bash
# Zobraz tagy
$ git tag
# Vytvor tag so správou
# -m špecifikuje správu, ktorá bude s tagom uložená.
# Ak nešpeficikuješ správu pri tagu so správou,
# Git spustí tvoj editor, aby si ju napísal.
$ git tag -a v2.0 -m 'moja verzia 2.0'
# Ukáž informácie o tagu
# Zobrazí zadané informácie, dátum tagnutia commitu
# a správu pred zobrazením informácií o commite.
$ git show v2.0
# Zverejní (pushne) jediný tag do vzdialeného repozitára
$ git push origin v2.0
# Zverejní viacero tagov do vzdialeného repozitára
$ git push origin --tags
```
### checkout
Aktualizuje všetky súbory v pracovnom strome, aby odpovedali verzií v indexe, alebo v inom strome.
```bash
# Aktualizuj strom, aby odpovedal (predvolene)
# hlavnej vetve repozitáru (master branch)
$ git checkout
# Aktualizuj strom, aby odpovedal konrkétnej vetve
$ git checkout menoVetvy
# Vytvor novú vetvu & prepni sa na ňu
# ekvivalentný príkaz: "git branch <meno>; git checkout <meno>"
$ git checkout -b nováVetva
```
### clone
"Naklonuje", alebo vytvorí kópiu existujúceho repozitára do nového adresára. Tiež pridá špeciálne ďiaľkovo-monitorujúce vetvy (remote-tracking branches), ktoré ti umožnia zverejňovať do vzdialených vetiev.
```bash
# Naklonuj learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
# povrchné klonovanie - rýchlejšie, uloží iba najnovšiu snímku
$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
# naklonuj iba konkrétnu vetvu
$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
```
### commit
Uloží aktuálny obsah indexu v novom "commite". Ten obsahuje vytvorené zmeny a s nimi súvisiace správy vytvorené použivateľom.
```bash
# commitni so správou
$ git commit -m "Pridal som multiplyNumbers() funkciu do HelloWorld.c"
# automaticky pridaj zmenené a vymazané súbory do staging indexu, potom ich commitni.
$ git commit -a -m "Zmenil som foo.php a vymazal bar.php"
# zmeň posledný commit (toto nahradí predchádzajúci commit novým)
$ git commit --amend -m "Správna správa"
```
### diff
Ukáže rozdiel medzi súborom v pracovnom repozitári, indexe a commitoch.
```bash
# Ukáž rozdiel medzi pracovným repozitárom a indexom.
$ git diff
# Ukáž rozdiely medzi indexom a najnovším commitom.
$ git diff --cached
# Ukáž rozdiely medzi pracovným adresárom a najnovším commitom.
$ git diff HEAD
```
### grep
Umožní ti rýchlo prehľadávať repozitár.
Možná konfigurácia:
```bash
# Nastav, aby sa vo výsledkoch vyhľadávania zobrazovalo číslo riadku
$ git config --global grep.lineNumber true
# Urob výsledky vyhľadávania čitateľnejšie, vrátane zoskupovania
$ git config --global alias.g "grep --break --heading --line-number"
```
```bash
# Vďaka Travisovi Jefferymu za túto sekciu
# Hľadaj "názovPremennej" vo všetkých java súboroch
$ git grep 'názovPremennej' -- '*.java'
# Hľadaj riadok, ktorý obsahuje "názovPoľa" a "add" alebo "remove"
$ git grep -e 'arrayListName' --and \( -e add -e remove \)
```
Google je tvoj kamarát; pre viac príkladov skoč na
[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
### log
Zobral commity do repozitára.
```bash
# Zobraz všetky commity
$ git log
# Zobraz iba správy a referencie commitov
$ git log --oneline
# Zobraz zlúčené (merged) commity
$ git log --merges
# Zobraz všetky commity vo forme ASCII grafu
$ git log --graph
```
### merge
"Zlúč" zmeny externých commitov do aktuálnej vetvy.
```bash
# Zlúč vybranú vetvu do aktuálnej.
$ git merge názovVetvy
# Vždy vytvor zlučovací commit
$ git merge --no-ff názovVetvy
```
### mv
Premenuj, alebo presuň súbor
```bash
# Premenuj súbor
$ git mv HelloWorld.c HelloNewWorld.c
# Presuň súbor
$ git mv HelloWorld.c ./nová/cesta/HelloWorld.c
# "Nasilu" premenuj, alebo presuň
# "existujúciSúbor" už v adresári existuje, bude prepísaný
$ git mv -f môjSúbor existujúciSúbor
```
### pull
Uloží obsah repozitára a zlúči ho s inou vetvou.
```bash
# Aktualizuje tvoj lokálny repozitár zlúčením nových zmien
# zo vzdialených "origin" a "master" vetiev.
# git pull <alias-vzdialeného-repo> <vetva>
$ git pull origin master
# Predvolene, git pull aktualizuje tvoju aktuálnu vetvu
# zlúčením nových zmien zo vzdialenej vetvy
$ git pull
# Zlúč zmeny zo vzdialenej vetvy a presuň vetvu do nového základného commitu (rebase)
# vetva commitne na tvoj lokálny repozitár, ekvivalentný príkaz: "git pull <alias-vzdialeného-repo> <vrstva>, git rebase <branch>"
$ git pull origin master --rebase
```
### push
Zverejní a zlúči zmeny z lokálnej do vzdialenej vetvy.
```bash
# Zverejni a zlúč zmeny z lokálneho repozitára do
# vzdialených vetiev s názvom "origin" a "master".
# git push <vzdialené> <vetvy>
$ git push origin master
# Predvolene git zverejní a zlúči zmeny z
# aktuálnej vetvy do vzdialenej vetvy s ňou spojenej
$ git push
# Na spojenie lokálnej vetvy so vzdialenou pridaj -u:
$ git push -u origin master
# Kedykoľvek budeš chcieť zverejniť z rovnakej lokálnej vetvy, použi príkaz:
$ git push
```
### stash
Umožní ti opustiť chaotický stav pracovného adresára a uloží ho na zásobník nedokončených zmien, ku ktorým sa môžeš kedykoľvek vrátiť.
Povedzme, že si urobil nejaké zmeny vo svojom git repozitári, ale teraz potrebuješ pullnúť zo vzdialenej repo. Keďže máš necommitnuté zmeny, príkaz `git pull` nebude fungovať. Namiesto toho môžeš použiť `git stash` a uložiť svoje nedokončené zmeny na zásobník!
```bash
$ git stash
Saved working directory and index state \
"WIP on master: 049d078 added the index file"
HEAD is now at 049d078 added the index file
(To restore them type "git stash apply")
```
Teraz môžeš uložiť vzdialenú vetvu!
```bash
$ git pull
```
Over, či je všetko v poriadku
```bash
$ git status
# On branch master
nothing to commit, working directory clean
```
Môžeš si pozrieť, čo za chaos je na zásobníku cez `git stash list`.
Nedokončené zmeny sú uložené ako Last-In-First-Out (Prvý dnu, posledný von) štruktúra, navrchu sa objavia najnovšie zmeny.
```bash
$ git stash list
stash@{0}: WIP on master: 049d078 added the index file
stash@{1}: WIP on master: c264051 Revert "added file_size"
stash@{2}: WIP on master: 21d80a5 added number to log
```
Keď so zmenami budeš chcieť pracovať, odstráň ich zo stacku.
```bash
$ git stash pop
# On branch master
# Changes not staged for commit:
# (use "git add <file>..." to update what will be committed)
#
# modified: index.html
# modified: lib/simplegit.rb
#
```
`git stash apply` urobí presne to isté
Hotovo, môžeš pokračovať v práci!
[Čítaj viac.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
### rebase (pozor)
Zober všetky zmeny commitnuté do vetvy a aplikuj ich na inú vetvu.
*Tento príkaz nerob na verejných repozitároch*.
```bash
# Aplikuj commity z experimentálnej vetvy na master
# git rebase <základnáVetva> <ináVetva>
$ git rebase master experimentBranch
```
[Čítaj viac.](http://git-scm.com/book/en/Git-Branching-Rebasing)
### reset (pozor)
Resetni HEAD (ukazateľ na aktuálnu vetvu) do konrkétneho stavu. To ti umožní vziať späť zlúčenia, zverejnenia, commity, pridania atď. Je to užitočný, no nebezpečný príkaz, pokiaľ nevieš, čo robíš.
```bash
# Resetni index (vrstvu medzi pracovným stromom a Git repozitárom), aby odpovedal najnovšiemu commitu (adresár ostane nezmenený)
$ git reset
# Resetni index, aby odpovedal najnovšiemu commitu (adresár sa prepíše)
$ git reset --hard
# Presunie vrchol aktuálnuej vetvy do konkrétneho commitu (adresár ostane nezmenený)
# všetky zmeny sú zachované v adresári.
$ git reset 31f2bb1
# Presunie vrchol aktuálnuej vetvy naopak do konkrétneho commitu
# a zosúladí ju s pracovným adresárom (vymaže nekomitnuté zmeny).
$ git reset --hard 31f2bb1
```
### revert
Vezme naspäť ("od-urobí") commit. Nezamieňaj s resetom, ktorý obnoví stav
projektu do predchádzajúceho bodu v čase. Revert pridá nový commit, inverzný tomu, ktorý chceš vymazať, tým ho od-urobí.
```bash
# Vezmi späť konkrétny commit
$ git revert <commit>
```
### rm
Opak od git add, rm odstráni súbory z aktuálneho pracovného stromu.
```bash
# odstráň HelloWorld.c
$ git rm HelloWorld.c
# Odstráň súbor z vnoreného adresára
$ git rm /pather/to/the/file/HelloWorld.c
```
## Ďalšie informácie
* [tryGit - Zábavný interaktívny spôsob, ako sa naučiť Git.](http://try.github.io/levels/1/challenges/1)
* [Udemy Git Tutoriál: Kompletný návod](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
* [Git Immersion - Návod, ktorý Ťa prevedie základmi Gitu](http://gitimmersion.com/)
* [git-scm - Video Tutoriály](http://git-scm.com/videos)
* [git-scm - Dokumentácia](http://git-scm.com/docs)
* [Atlassian Git - Tutoriály & Postupy](https://www.atlassian.com/git/)
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
* [Git - jednoducho](http://rogerdudler.github.io/git-guide/index.html)
* [Pro Git](http://www.git-scm.com/book/en/v2)
* [Úvod do Gitu a GitHubu pre začiatočníkov (Tutoriál)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)

227
sk-sk/latex.html.markdown.tex Normal file
View File

@ -0,0 +1,227 @@
---
language: latex
contributors:
- ["Chaitanya Krishna Ande", "http://icymist.github.io"]
- ["Colton Kohnke", "http://github.com/voltnor"]
- ["Sricharan Chiruvolu", "http://sricharan.xyz"]
translators:
- ["Terka Slanináková", "http://github.com/TerkaSlan"]
filename: learn-latex-sk.tex
---
```tex
% Všetky komentáre začínajú s %
% Viac-riadkové komentáre sa nedajú urobiť
% LaTeX NIE JE WYSIWY ("What You See Is What You Get") software ako MS Word, alebo OpenOffice Writer
% Každý LaTeX príkaz začína s opačným lomítkom (\)
% LaTeX dokumenty začínajú s definíciou typu kompilovaného dokumentu
% Ostatné typy sú napríklad kniha (book), správa (report), prezentácia (presentation), atď.
% Možnosti dokumentu sa píšu do [] zátvoriek. V tomto prípade tam upresňujeme veľkosť (12pt) fontu.
\documentclass[12pt]{article}
% Ďalej definujeme balíčky, ktoré dokuemnt používa.
% Ak chceš zahrnúť grafiku, farebný text, či zdrojový kód iného jazyka, musíš rozšíriť možnosti LaTeXu dodatočnými balíčkami.
% Zahŕňam float a caption. Na podporu slovenčiny treba zahrnúť aj utf8 balíček.
\usepackage{caption}
\usepackage{float}
\usepackage[utf8]{inputenc}
% Tu môžme definovať ostatné vlastnosti dokumentu!
% Autori tohto dokumentu, "\\*" znamená "choď na nový riadok"
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu, \\*Preklad: Terka Slanináková}
% Vygeneruje dnešný dátum
\date{\today}
\title{Nauč sa LaTeX za Y Minút!}
% Teraz môžme začať pracovať na samotnom dokumente.
% Všetko do tohto riadku sa nazýva "Preambula" ("The Preamble")
\begin{document}
% ak zadáme položky author, date a title, LaTeX vytvorí titulnú stranu.
\maketitle
% Väčšina odborných článkov má abstrakt, na jeho vytvorenie môžeš použiť preddefinované príkazy.
% Ten by sa mal zobraziť v logickom poradí, teda po hlavičke,
% no pred hlavnými sekciami tela..
% Tento príkaz je tiež dostupný v triedach article a report.
% Tzv. makro "abstract" je fixnou súčasťou LaTeXu, ak chceme použiť abstract
% a napísať ho po slovensky, musíme ho redefinovať nasledujúcim príkazom
\renewcommand\abstractname{Abstrakt}
\begin{abstract}
LaTeX dokumentácia v LaTeXe! Aké netradičné riešenie cudzieho nápadu!
\end{abstract}
% Príkazy pre sekciu sú intuitívne
% Všetky nadpisy sekcií sú pridané automaticky do obsahu.
\section{Úvod}
Čaute, volám sa Colton a spoločne sa pustíme do skúmania LaTeXu (toho druhého)!
\section{Ďalšia sekcia}
Toto je text ďalšej sekcie. Myslím, že potrebuje podsekciu.
\subsection{Toto je podsekcia} % Podsekcie sú tiež intuitívne.
Zdá sa mi, že treba ďalšiu.
\subsubsection{Pytagoras}
To je ono!
\label{subsec:pytagoras}
% Použitím '*' môžeme potlačiť zabudované číslovanie LaTeXu.
% Toto funguje aj na iné príkazy.
\section*{Toto je nečíslovaná sekcia}
Všetky číslované byť nemusia!
\section{Nejaké poznámočky}
Zarovnávať veci tam, kde ich chceš mať, je všeobecne ľahké. Ak
potrebuješ \\ nový \\ riadok \\ pridaj \textbackslash\textbackslash do
zdrojového kódu. \\
\section{Zoznamy}
Zoznamy sú jednou z najjednoduchších vecí vôbec! Treba mi zajtra nakúpiť, urobím si zoznam.
\begin{enumerate} % "enumerate" spustí číslovanie prvkov.
% \item povie LaTeXu, ako že treba pripočítať 1
\item Vlašský šalát.
\item 5 rožkov.
\item 3 Horalky.
% číslovanie môžeme pozmeniť použitím []
\item[koľko?] Stredne veľkých guličkoviek.
Ja už nie som položka zoznamu, no stále som časť "enumerate".
\end{enumerate} % Všetky prostredia končia s "end".
\section{Matika}
Jedným z primárnych použití LaTeXu je písanie akademických, či technických prác. Zvyčajne za použitia matematiky a vedy. Podpora špeciálnych symbolov preto nemôže chýbať!\\
Matematika má veľa symbolov, omnoho viac, než by klávesnica mohla reprezentovať;
Množinové a relačné symboly, šípky, operátory a Grécke písmená sú len malou ukážkou.\\
Množiny a relácie hrajú hlavnú rolu v mnohých matematických článkoch.
Takto napíšeš, že niečo platí pre všetky x patriace do X, $\forall$ x $\in$ X. \\
% Všimni si, že som pridal $ pred a po symboloch. Je to
% preto, lebo pri písaní sme v textovom móde,
% no matematické symboly existujú len v matematickom.
% Vstúpime doňho z textového práve '$' znamienkami.
% Platí to aj opačne. Premenná môže byť zobrazená v matematickom móde takisto.
% Do matematického módu sa dá dostať aj s \[\]
\[a^2 + b^2 = c^2 \]
Moje obľúbené Grécke písmeno je $\xi$. Tiež sa mi pozdávajú $\beta$, $\gamma$ a $\sigma$.
Ešte som neprišiel na Grécke písmeno, ktoré by LaTeX nepoznal!
Operátory sú dôležitou súčasťou matematických dokumentov:
goniometrické funkcie ($\sin$, $\cos$, $\tan$),
logaritmy and exponenciálne výrazy ($\log$, $\exp$),
limity ($\lim$), atď.
majú pred-definované LaTeXové príkazy.
Napíšme si rovnicu, nech vidíme, ako to funguje: \\
$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
Zlomky(Čitateľ-menovateľ) sa píšu v týchto formách:
% 10 / 7
$^{10}/_{7}$
% Relatívne komplexné zlomky sa píšu ako
% \frac{čitateľ}{menovateľ}
$\frac{n!}{k!(n - k)!}$ \\
Rovnice tiež môžeme zadať v "rovnicovom prostredí".
% Takto funguje rovnicové prostredie
\begin{equation} % vstúpi do matematického módu
c^2 = a^2 + b^2.
\label{eq:pythagoras} % na odkazovanie
\end{equation} % všetky \begin príkazy musia mať konečný príkaz.
Teraz môžeme odkázať na novovytvorenú rovnicu!
Rovn.~\ref{eq:pythagoras} je tiež známa ako Pytagorova Veta, ktorá je tiež predmetom Sekc.~\ref{subsec:pytagoras}. Odkazovať môžme na veľa vecí, napr na: čísla, rovnice, či sekcie.
Sumácie a Integrály sa píšu príkazmi sum a int:
% Niektoré prekladače LaTeXu sa môžu sťažovať na prázdne riadky (ak tam sú)
% v rovnicovom prostredí.
\begin{equation}
\sum_{i=0}^{5} f_{i}
\end{equation}
\begin{equation}
\int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
\end{equation}
\section{Obrázky}
Vloženie obrázku môže byť zložitejšie. Ja si vždy možnosti vloženia pozerám pre každý obrázok.
\renewcommand\figurename{Obrázok}
\begin{figure}[H] % H značí možnosť zarovnania.
\centering % nacentruje obrázok na stránku
% Vloží obrázok na 80% šírky stránky.
%\includegraphics[width=0.8\linewidth]{right-triangle.png}
% Zakomentované kvôli kompilácií, použi svoju predstavivosť :).
\caption{Pravouhlý trojuholník so stranami $a$, $b$, $c$}
\label{fig:right-triangle}
\end{figure}
% Opäť, fixné makro "table" nahradíme slovenskou tabuľkou. Pokiaľ preferuješ table, nasledujúci riadok nepridávaj
\renewcommand\tablename{Tabuľka}
\subsection{Tabuľky}
Tabuľky sa vkládajú podobne ako obrázky.
\begin{table}[H]
\caption{Nadpis tabuľky.}
% zátvorky: {} hovoria ako sa vykreslí každý riadok.
% Toto si nikdy nepamätám a vždy to musím hľadať. Všetko. Každý. Jeden. Raz!
\begin{tabular}{c|cc}
Číslo & Priezvisko & Krstné meno \\ % Stĺpce sú rozdelené $
\hline % horizontálna čiara
1 & Ladislav & Meliško \\
2 & Eva & Máziková
\end{tabular}
\end{table}
% \section{Hyperlinks} % Už čoskoro :)
\section{Prikáž LaTeXu nekompilovať (napr. Zdrojový Kód)}
Povedzme, že chceme do dokumentu vložiť zdrojový kód, budeme musieť LaTeXu povedať, nech sa ho nesnaží skompilovať, ale nech s ním pracuje ako s textom.
Toto sa robí vo verbatim prostredí.
% Tiež sú na to špeciálne balíčky, (napr. minty, lstlisting, atď.)
% ale verbatim je to najzákladnejšie, čo môžeš použiť.
\begin{verbatim}
print("Hello World!")
a%b; pozri! Vo verbatime môžme použiť % znamienka.
random = 4; #priradené randomným hodom kockou
\end{verbatim}
\section{Kompilácia}
Už by bolo načase túto nádheru skompilovať a zhliadnuť jej úžasnú úžasnosť v podobe LaTeX pdfka, čo povieš?
(áno, tento dokument sa musí kompilovať). \\
Cesta k finálnemu dokumentu pomocou LaTeXu pozostáva z nasledujúcich krokov:
\begin{enumerate}
\item Napíš dokument v čistom texte (v "zdrojáku").
\item Skompiluj zdroják na získanie pdfka.
Kompilácia by mala vyzerať nasledovne (v Linuxe): \\
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
\end{verbatim}
\end{enumerate}
Mnoho LaTeX editorov kombinuje Krok 1 a Krok 2 v jednom prostredí. Krok 1 teda uvidíš, krok 2 už nie.
Ten sa deje za oponou. Kompilácia v 2. kroku sa postará o produkciu dokumentu v tebou zadanom formáte.
\section{Koniec}
To je zatiaľ všetko!
% koniec dokumentu
\end{document}
```
## Viac o LaTeXe (anglicky)
* Úžasná LaTeX wikikniha: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
* Naozajstný tutoriál: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)

209
sk-sk/learn-latex-sk.tex Normal file
View File

@ -0,0 +1,209 @@
% Všetky komentáre začínajú s %
% Viac-riadkové komentáre sa nedajú urobiť
% LaTeX NIE JE WYSIWY ("What You See Is What You Get") software ako MS Word, alebo OpenOffice Writer
% Každý LaTeX príkaz začína s opačným lomítkom (\)
% LaTeX dokumenty začínajú s definíciou typu kompilovaného dokumentu
% Ostatné typy sú napríklad kniha (book), správa (report), prezentácia (presentation), atď.
% Možnosti dokumentu sa píšu do [] zátvoriek. V tomto prípade tam upresňujeme veľkosť (12pt) fontu.
\documentclass[12pt]{article}
% Ďalej definujeme balíčky, ktoré dokuemnt používa.
% Ak chceš zahrnúť grafiku, farebný text, či zdrojový kód iného jazyka, musíš rozšíriť možnosti LaTeXu dodatočnými balíčkami.
% Zahŕňam float a caption. Na podporu slovenčiny treba zahrnúť aj utf8 balíček.
\usepackage{caption}
\usepackage{float}
\usepackage[utf8]{inputenc}
% Tu môžme definovať ostatné vlastnosti dokumentu!
% Autori tohto dokumentu, "\\*" znamená "choď na nový riadok"
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu, \\*Preklad: Terka Slanináková}
% Vygeneruje dnešný dátum
\date{\today}
\title{Nauč sa LaTeX za Y Minút!}
% Teraz môžme začať pracovať na samotnom dokumente.
% Všetko do tohto riadku sa nazýva "Preambula" ("The Preamble")
\begin{document}
% ak zadáme položky author, date a title, LaTeX vytvorí titulnú stranu.
\maketitle
% Väčšina odborných článkov má abstrakt, na jeho vytvorenie môžeš použiť preddefinované príkazy.
% Ten by sa mal zobraziť v logickom poradí, teda po hlavičke,
% no pred hlavnými sekciami tela..
% Tento príkaz je tiež dostupný v triedach article a report.
% Tzv. makro "abstract" je fixnou súčasťou LaTeXu, ak chceme použiť abstract
% a napísať ho po slovensky, musíme ho redefinovať nasledujúcim príkazom
\renewcommand\abstractname{Abstrakt}
\begin{abstract}
LaTeX dokumentácia v LaTeXe! Aké netradičné riešenie cudzieho nápadu!
\end{abstract}
% Príkazy pre sekciu sú intuitívne
% Všetky nadpisy sekcií sú pridané automaticky do obsahu.
\section{Úvod}
Čaute, volám sa Colton a spoločne sa pustíme do skúmania LaTeXu (toho druhého)!
\section{Ďalšia sekcia}
Toto je text ďalšej sekcie. Myslím, že potrebuje podsekciu.
\subsection{Toto je podsekcia} % Podsekcie sú tiež intuitívne.
Zdá sa mi, že treba ďalšiu.
\subsubsection{Pytagoras}
To je ono!
\label{subsec:pytagoras}
% Použitím '*' môžeme potlačiť zabudované číslovanie LaTeXu.
% Toto funguje aj na iné príkazy.
\section*{Toto je nečíslovaná sekcia}
Všetky číslované byť nemusia!
\section{Nejaké poznámočky}
Zarovnávať veci tam, kde ich chceš mať, je všeobecne ľahké. Ak
potrebuješ \\ nový \\ riadok \\ pridaj \textbackslash\textbackslash do
zdrojového kódu. \\
\section{Zoznamy}
Zoznamy sú jednou z najjednoduchších vecí vôbec! Treba mi zajtra nakúpiť, urobím si zoznam.
\begin{enumerate} % "enumerate" spustí číslovanie prvkov.
% \item povie LaTeXu, ako že treba pripočítať 1
\item Vlašský šalát.
\item 5 rožkov.
\item 3 Horalky.
% číslovanie môžeme pozmeniť použitím []
\item[koľko?] Stredne veľkých guličkoviek.
Ja už nie som položka zoznamu, no stále som časť "enumerate".
\end{enumerate} % Všetky prostredia končia s "end".
\section{Matika}
Jedným z primárnych použití LaTeXu je písanie akademických, či technických prác. Zvyčajne za použitia matematiky a vedy. Podpora špeciálnych symbolov preto nemôže chýbať!\\
Matematika má veľa symbolov, omnoho viac, než by klávesnica mohla reprezentovať;
Množinové a relačné symboly, šípky, operátory a Grécke písmená sú len malou ukážkou.\\
Množiny a relácie hrajú hlavnú rolu v mnohých matematických článkoch.
Takto napíšeš, že niečo platí pre všetky x patriace do X, $\forall$ x $\in$ X. \\
% Všimni si, že som pridal $ pred a po symboloch. Je to
% preto, lebo pri písaní sme v textovom móde,
% no matematické symboly existujú len v matematickom.
% Vstúpime doňho z textového práve '$' znamienkami.
% Platí to aj opačne. Premenná môže byť zobrazená v matematickom móde takisto.
% Do matematického módu sa dá dostať aj s \[\]
\[a^2 + b^2 = c^2 \]
Moje obľúbené Grécke písmeno je $\xi$. Tiež sa mi pozdávajú $\beta$, $\gamma$ a $\sigma$.
Ešte som neprišiel na Grécke písmeno, ktoré by LaTeX nepoznal!
Operátory sú dôležitou súčasťou matematických dokumentov:
goniometrické funkcie ($\sin$, $\cos$, $\tan$),
logaritmy and exponenciálne výrazy ($\log$, $\exp$),
limity ($\lim$), atď.
majú pred-definované LaTeXové príkazy.
Napíšme si rovnicu, nech vidíme, ako to funguje: \\
$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
Zlomky(Čitateľ-menovateľ) sa píšu v týchto formách:
% 10 / 7
$^{10}/_{7}$
% Relatívne komplexné zlomky sa píšu ako
% \frac{čitateľ}{menovateľ}
$\frac{n!}{k!(n - k)!}$ \\
Rovnice tiež môžeme zadať v "rovnicovom prostredí".
% Takto funguje rovnicové prostredie
\begin{equation} % vstúpi do matematického módu
c^2 = a^2 + b^2.
\label{eq:pythagoras} % na odkazovanie
\end{equation} % všetky \begin príkazy musia mať konečný príkaz.
Teraz môžeme odkázať na novovytvorenú rovnicu!
Rovn.~\ref{eq:pythagoras} je tiež známa ako Pytagorova Veta, ktorá je tiež predmetom Sekc.~\ref{subsec:pytagoras}. Odkazovať môžme na veľa vecí, napr na: čísla, rovnice, či sekcie.
Sumácie a Integrály sa píšu príkazmi sum a int:
% Niektoré prekladače LaTeXu sa môžu sťažovať na prázdne riadky (ak tam sú)
% v rovnicovom prostredí.
\begin{equation}
\sum_{i=0}^{5} f_{i}
\end{equation}
\begin{equation}
\int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
\end{equation}
\section{Obrázky}
Vloženie obrázku môže byť zložitejšie. Ja si vždy možnosti vloženia pozerám pre každý obrázok.
\renewcommand\figurename{Obrázok}
\begin{figure}[H] % H značí možnosť zarovnania.
\centering % nacentruje obrázok na stránku
% Vloží obrázok na 80% šírky stránky.
%\includegraphics[width=0.8\linewidth]{right-triangle.png}
% Zakomentované kvôli kompilácií, použi svoju predstavivosť :).
\caption{Pravouhlý trojuholník so stranami $a$, $b$, $c$}
\label{fig:right-triangle}
\end{figure}
% Opäť, fixné makro "table" nahradíme slovenskou tabuľkou. Pokiaľ preferuješ table, nasledujúci riadok nepridávaj
\renewcommand\tablename{Tabuľka}
\subsection{Tabuľky}
Tabuľky sa vkládajú podobne ako obrázky.
\begin{table}[H]
\caption{Nadpis tabuľky.}
% zátvorky: {} hovoria ako sa vykreslí každý riadok.
% Toto si nikdy nepamätám a vždy to musím hľadať. Všetko. Každý. Jeden. Raz!
\begin{tabular}{c|cc}
Číslo & Priezvisko & Krstné meno \\ % Stĺpce sú rozdelené $
\hline % horizontálna čiara
1 & Ladislav & Meliško \\
2 & Eva & Máziková
\end{tabular}
\end{table}
% \section{Hyperlinks} % Už čoskoro :)
\section{Prikáž LaTeXu nekompilovať (napr. Zdrojový Kód)}
Povedzme, že chceme do dokumentu vložiť zdrojový kód, budeme musieť LaTeXu povedať, nech sa ho nesnaží skompilovať, ale nech s ním pracuje ako s textom.
Toto sa robí vo verbatim prostredí.
% Tiež sú na to špeciálne balíčky, (napr. minty, lstlisting, atď.)
% ale verbatim je to najzákladnejšie, čo môžeš použiť.
\begin{verbatim}
print("Hello World!")
a%b; pozri! Vo verbatime môžme použiť % znamienka.
random = 4; #priradené randomným hodom kockou
\end{verbatim}
\section{Kompilácia}
Už by bolo načase túto nádheru skompilovať a zhliadnuť jej úžasnú úžasnosť v podobe LaTeX pdfka, čo povieš?
(áno, tento dokument sa musí kompilovať). \\
Cesta k finálnemu dokumentu pomocou LaTeXu pozostáva z nasledujúcich krokov:
\begin{enumerate}
\item Napíš dokument v čistom texte (v "zdrojáku").
\item Skompiluj zdroják na získanie pdfka.
Kompilácia by mala vyzerať nasledovne (v Linuxe): \\
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
\end{verbatim}
\end{enumerate}
Mnoho LaTeX editorov kombinuje Krok 1 a Krok 2 v jednom prostredí. Krok 1 teda uvidíš, krok 2 už nie.
Ten sa deje za oponou. Kompilácia v 2. kroku sa postará o produkciu dokumentu v tebou zadanom formáte.
\section{Koniec}
To je zatiaľ všetko!
% koniec dokumentu
\end{document}

125
swift.html.markdown
View File

@ -6,6 +6,7 @@ contributors:
- ["Joey Huang", "http://github.com/kamidox"] - ["Joey Huang", "http://github.com/kamidox"]
- ["Anthony Nguyen", "http://github.com/anthonyn60"] - ["Anthony Nguyen", "http://github.com/anthonyn60"]
- ["Clayton Walker", "https://github.com/cwalk"] - ["Clayton Walker", "https://github.com/cwalk"]
- ["Fernando Valverde", "http://visualcosita.xyz"]
filename: learnswift.swift filename: learnswift.swift
--- ---
@ -25,12 +26,13 @@ import UIKit
// Xcode supports landmarks to annotate your code and lists them in the jump bar // Xcode supports landmarks to annotate your code and lists them in the jump bar
// MARK: Section mark // MARK: Section mark
// MARK: - Section mark with a separator line
// TODO: Do something soon // TODO: Do something soon
// FIXME: Fix this code // FIXME: Fix this code
// In Swift 2, println and print were combined into one print method. Print automatically appends a new line. // In Swift 2, println and print were combined into one print method. Print automatically appends a new line.
print("Hello, world") // println is now print print("Hello, world") // println is now print
print("Hello, world", appendNewLine: false) // printing without appending a newline print("Hello, world", terminator: "") // printing without appending a newline
// variables (var) value can change after being set // variables (var) value can change after being set
// constants (let) value can NOT be changed after being set // constants (let) value can NOT be changed after being set
@ -44,7 +46,7 @@ let `class` = "keyword" // backticks allow keywords to be used as variable names
let explicitDouble: Double = 70 let explicitDouble: Double = 70
let intValue = 0007 // 7 let intValue = 0007 // 7
let largeIntValue = 77_000 // 77000 let largeIntValue = 77_000 // 77000
let label = "some text " + String(myVariable) // Casting let label = "some text " + String(myVariable) // String construction
let piText = "Pi = \(π), Pi 2 = \(π * 2)" // String interpolation let piText = "Pi = \(π), Pi 2 = \(π * 2)" // String interpolation
// Build Specific values // Build Specific values
@ -128,6 +130,7 @@ shoppingList[1] = "bottle of water"
let emptyArray = [String]() // let == immutable let emptyArray = [String]() // let == immutable
let emptyArray2 = Array<String>() // same as above let emptyArray2 = Array<String>() // same as above
var emptyMutableArray = [String]() // var == mutable var emptyMutableArray = [String]() // var == mutable
var explicitEmptyMutableStringArray: [String] = [] // same as above
// Dictionary // Dictionary
@ -139,12 +142,21 @@ occupations["Jayne"] = "Public Relations"
let emptyDictionary = [String: Float]() // let == immutable let emptyDictionary = [String: Float]() // let == immutable
let emptyDictionary2 = Dictionary<String, Float>() // same as above let emptyDictionary2 = Dictionary<String, Float>() // same as above
var emptyMutableDictionary = [String: Float]() // var == mutable var emptyMutableDictionary = [String: Float]() // var == mutable
var explicitEmptyMutableDictionary: [String: Float] = [:] // same as above
// //
// MARK: Control Flow // MARK: Control Flow
// //
// Condition statements support "where" clauses, which can be used
// to help provide conditions on optional values.
// Both the assignment and the "where" clause must pass.
let someNumber = Optional<Int>(7)
if let num = someNumber where num > 3 {
print("num is greater than 3")
}
// for loop (array) // for loop (array)
let myArray = [1, 1, 2, 3, 5] let myArray = [1, 1, 2, 3, 5]
for value in myArray { for value in myArray {
@ -174,8 +186,8 @@ while i < 1000 {
i *= 2 i *= 2
} }
// do-while loop // repeat-while loop
do { repeat {
print("hello") print("hello")
} while 1 == 2 } while 1 == 2
@ -194,7 +206,6 @@ default: // required (in order to cover all possible input)
let vegetableComment = "Everything tastes good in soup." let vegetableComment = "Everything tastes good in soup."
} }
// //
// MARK: Functions // MARK: Functions
// //
@ -217,10 +228,10 @@ default: // required (in order to cover all possible input)
func greet(name: String, day: String) -> String { func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)." return "Hello \(name), today is \(day)."
} }
greet("Bob", "Tuesday") greet("Bob", day: "Tuesday")
// similar to above except for the function parameter behaviors // similar to above except for the function parameter behaviors
func greet2(#requiredName: String, externalParamName localParamName: String) -> String { func greet2(requiredName requiredName: String, externalParamName localParamName: String) -> String {
return "Hello \(requiredName), the day is \(localParamName)" return "Hello \(requiredName), the day is \(localParamName)"
} }
greet2(requiredName: "John", externalParamName: "Sunday") greet2(requiredName: "John", externalParamName: "Sunday")
@ -236,11 +247,33 @@ let (_, price1, _) = pricesTuple // price1 == 3.69
print(price1 == pricesTuple.1) // true print(price1 == pricesTuple.1) // true
print("Gas price: \(price)") print("Gas price: \(price)")
// Labeled/named tuple params
func getGasPrices2() -> (lowestPrice: Double, highestPrice: Double, midPrice: Double) {
return (1.77, 37.70, 7.37)
}
let pricesTuple2 = getGasPrices2()
let price2 = pricesTuple2.lowestPrice
let (_, price3, _) = pricesTuple2
print(pricesTuple2.highestPrice == pricesTuple2.1) // true
print("Highest gas price: \(pricesTuple2.highestPrice)")
// guard statements
func testGuard() {
// guards provide early exits or breaks, placing the error handler code near the conditions.
// it places variables it declares in the same scope as the guard statement.
guard let aNumber = Optional<Int>(7) else {
return
}
print("number is \(aNumber)")
}
testGuard()
// Variadic Args // Variadic Args
func setup(numbers: Int...) { func setup(numbers: Int...) {
// its an array // its an array
let number = numbers[0] let _ = numbers[0]
let argCount = numbers.count let _ = numbers.count
} }
// Passing and returning functions // Passing and returning functions
@ -261,7 +294,7 @@ func swapTwoInts(inout a: Int, inout b: Int) {
} }
var someIntA = 7 var someIntA = 7
var someIntB = 3 var someIntB = 3
swapTwoInts(&someIntA, &someIntB) swapTwoInts(&someIntA, b: &someIntB)
print(someIntB) // 7 print(someIntB) // 7
@ -289,23 +322,17 @@ numbers = numbers.map({ number in 3 * number })
print(numbers) // [3, 6, 18] print(numbers) // [3, 6, 18]
// Trailing closure // Trailing closure
numbers = sorted(numbers) { $0 > $1 } numbers = numbers.sort { $0 > $1 }
print(numbers) // [18, 6, 3] print(numbers) // [18, 6, 3]
// Super shorthand, since the < operator infers the types
numbers = sorted(numbers, < )
print(numbers) // [3, 6, 18]
// //
// MARK: Structures // MARK: Structures
// //
// Structures and classes have very similar capabilities // Structures and classes have very similar capabilities
struct NamesTable { struct NamesTable {
let names = [String]() let names: [String]
// Custom subscript // Custom subscript
subscript(index: Int) -> String { subscript(index: Int) -> String {
@ -318,6 +345,44 @@ let namesTable = NamesTable(names: ["Me", "Them"])
let name = namesTable[1] let name = namesTable[1]
print("Name is \(name)") // Name is Them print("Name is \(name)") // Name is Them
//
// MARK: Error Handling
//
// The `ErrorType` protocol is used when throwing errors to catch
enum MyError: ErrorType {
case BadValue(msg: String)
case ReallyBadValue(msg: String)
}
// functions marked with `throws` must be called using `try`
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(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(7)
do {
// normal try operation that provides error handling via `catch` block
try fakeFetch(1)
} catch MyError.BadValue(let msg) {
print("Error message: \(msg)")
} catch {
// must be exhaustive
}
}
testTryStuff()
// //
// MARK: Classes // MARK: Classes
// //
@ -349,6 +414,11 @@ internal class Rect: Shape {
} }
} }
// Computed properties must be declared as `var`, you know, cause' they can change
var smallestSideLength: Int {
return self.sideLength - 1
}
// Lazily load a property // Lazily load a property
// subShape remains nil (uninitialized) until getter called // subShape remains nil (uninitialized) until getter called
lazy var subShape = Rect(sideLength: 4) lazy var subShape = Rect(sideLength: 4)
@ -453,9 +523,10 @@ enum Suit {
// when the variable is explicitly declared // when the variable is explicitly declared
var suitValue: Suit = .Hearts var suitValue: Suit = .Hearts
// Non-Integer enums require direct raw value assignments // String enums can have direct raw value assignments
// or their raw values will be derived from the Enum field
enum BookName: String { enum BookName: String {
case John = "John" case John
case Luke = "Luke" case Luke = "Luke"
} }
print("Name: \(BookName.John.rawValue)") print("Name: \(BookName.John.rawValue)")
@ -499,7 +570,7 @@ protocol ShapeGenerator {
// Protocols declared with @objc allow optional functions, // Protocols declared with @objc allow optional functions,
// which allow you to check for conformance // which allow you to check for conformance
@objc protocol TransformShape { @objc protocol TransformShape {
optional func reshaped() optional func reshape()
optional func canReshape() -> Bool optional func canReshape() -> Bool
} }
@ -512,9 +583,9 @@ class MyShape: Rect {
// Place a question mark after an optional property, method, or // Place a question mark after an optional property, method, or
// subscript to gracefully ignore a nil value and return nil // subscript to gracefully ignore a nil value and return nil
// instead of throwing a runtime error ("optional chaining"). // instead of throwing a runtime error ("optional chaining").
if let allow = self.delegate?.canReshape?() { if let reshape = self.delegate?.canReshape?() where reshape {
// test for delegate then for method // test for delegate then for method
self.delegate?.reshaped?() self.delegate?.reshape?()
} }
} }
} }
@ -526,8 +597,8 @@ class MyShape: Rect {
// `extension`s: Add extra functionality to an already existing type // `extension`s: Add extra functionality to an already existing type
// Square now "conforms" to the `Printable` protocol // Square now "conforms" to the `CustomStringConvertible` protocol
extension Square: Printable { extension Square: CustomStringConvertible {
var description: String { var description: String {
return "Area: \(self.getArea()) - ID: \(self.identifier)" return "Area: \(self.getArea()) - ID: \(self.identifier)"
} }
@ -552,8 +623,8 @@ print(14.multiplyBy(3)) // 42
// Generics: Similar to Java and C#. Use the `where` keyword to specify the // Generics: Similar to Java and C#. Use the `where` keyword to specify the
// requirements of the generics. // requirements of the generics.
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? { func findIndex<T: Equatable>(array: [T], _ valueToFind: T) -> Int? {
for (index, value) in enumerate(array) { for (index, value) in array.enumerate() {
if value == valueToFind { if value == valueToFind {
return index return index
} }

4
tmux.html.markdown
View File

@ -7,7 +7,7 @@ filename: LearnTmux.txt
--- ---
[tmux](http://tmux.sourceforge.net) [tmux](http://tmux.github.io)
is a terminal multiplexer: it enables a number of terminals is a terminal multiplexer: it enables a number of terminals
to be created, accessed, and controlled from a single screen. tmux to be created, accessed, and controlled from a single screen. tmux
may be detached from a screen and continue running in the background may be detached from a screen and continue running in the background
@ -240,7 +240,7 @@ set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] |
### References ### References
[Tmux | Home](http://tmux.sourceforge.net) [Tmux | Home](http://tmux.github.io)
[Tmux Manual page](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux) [Tmux Manual page](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)

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

@ -19,7 +19,7 @@ gözardı edilir.
Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir
dizidir. İşaretçi ilk hücreyi işaret eder. dizidir. İşaretçi ilk hücreyi işaret eder.
Sekik komut vardır: Sekiz komut vardır:
+ : Geçerli hücrenin değerini bir artırır. + : Geçerli hücrenin değerini bir artırır.
- : Geçerli hücrenin değerini bir azaltır. - : Geçerli hücrenin değerini bir azaltır.
> : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye). > : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).

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

@ -91,9 +91,9 @@ int main() {
// Örneğin, // Örneğin,
printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words) printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words)
// If the argument of the `sizeof` operator an expression, then its argument // Eger arguman düzenli ifae olan sizeof operatoru ise degerlendirilmez.
// is not evaluated (except VLAs (see below)). // VLAs hariç asagiya bakiniz).
// The value it yields in this case is a compile-time constant. // Bu durumda verimliligin degeri derleme-zamani sabitidir.
int a = 1; int a = 1;
// size_t bir objeyi temsil etmek için kullanılan 2 byte uzunluğundaki bir // size_t bir objeyi temsil etmek için kullanılan 2 byte uzunluğundaki bir
@ -101,7 +101,7 @@ int main() {
size_t size = sizeof(a++); // a++ is not evaluated size_t size = sizeof(a++); // a++ is not evaluated
printf("sizeof(a++) = %zu where a = %d\n", size, a); printf("sizeof(a++) = %zu where a = %d\n", size, a);
// prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture) // yazdirilan "sizeof(a++) = 4 where a = 1" (32-bit mimaride)
// Diziler somut bir boyut ile oluşturulmalıdır. // Diziler somut bir boyut ile oluşturulmalıdır.
char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
@ -119,19 +119,19 @@ int main() {
my_array[1] = 2; my_array[1] = 2;
printf("%d\n", my_array[1]); // => 2 printf("%d\n", my_array[1]); // => 2
// In C99 (and as an optional feature in C11), variable-length arrays (VLAs) // C99'da (ve C11 istege bagli bir ozellik olarak), deÄŸidken-uzunluklu diziler (VLAs) bildirilebilirler.
// can be declared as well. The size of such an array need not be a compile // Böyle bir dizinin boyuunu derlenmesi gerekmez
// time constant: // zaman sabiti:
printf("Enter the array size: "); // ask the user for an array size printf("Enter the array size: "); // dizi boyutu kullaniciya soruluyor
char buf[0x100]; char buf[0x100];
fgets(buf, sizeof buf, stdin); fgets(buf, sizeof buf, stdin);
// strtoul parses a string to an unsigned integer // strtoul isaretsiz integerlar icin string ayiricisidir.
size_t size = strtoul(buf, NULL, 10); size_t size = strtoul(buf, NULL, 10);
int var_length_array[size]; // declare the VLA int var_length_array[size]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array); printf("sizeof array = %zu\n", sizeof var_length_array);
// A possible outcome of this program may be: // Bu programın olası bir sonucu olabilir:
// > Enter the array size: 10 // > Enter the array size: 10
// > sizeof array = 40 // > sizeof array = 40
@ -151,8 +151,8 @@ int main() {
printf("%d\n", a_string[16]); // => 0 printf("%d\n", a_string[16]); // => 0
// i.e., byte #17 is 0 (as are 18, 19, and 20) // i.e., byte #17 is 0 (as are 18, 19, and 20)
// If we have characters between single quotes, that's a character literal. // Tek tirnak arasinda karakterlere sahipsek, bu karakterler degismezdir.
// It's of type `int`, and *not* `char` (for historical reasons). // Tip `int` ise, `char` *degildir* (tarihsel sebeplerle).
int cha = 'a'; // fine int cha = 'a'; // fine
char chb = 'a'; // fine too (implicit conversion from int to char) char chb = 'a'; // fine too (implicit conversion from int to char)
@ -201,10 +201,10 @@ int main() {
0x01 << 1; // => 0x02 (bitwise left shift (by 1)) 0x01 << 1; // => 0x02 (bitwise left shift (by 1))
0x02 >> 1; // => 0x01 (bitwise right shift (by 1)) 0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
// Be careful when shifting signed integers - the following are undefined: // Isaretli sayilari kaydirirken dikkatli olun - tanimsizlar sunlardir:
// - shifting into the sign bit of a signed integer (int a = 1 << 32) // - isaretli sayinin isaret bitinde yapÄilan kaydirma (int a = 1 << 32)
// - left-shifting a negative number (int a = -1 << 2) // - negatif sayilarda sol kaydirma (int a = -1 << 2)
// - shifting by an offset which is >= the width of the type of the LHS: // - LHS tipinde >= ile olan ofset genisletmelerde yapilan kaydirma:
// int a = 1 << 32; // UB if int is 32 bits wide // int a = 1 << 32; // UB if int is 32 bits wide
/////////////////////////////////////// ///////////////////////////////////////

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

@ -538,7 +538,7 @@ Insan.grunt() # => "*grunt*"
# Modülleri içe aktarabilirsiniz # Modülleri içe aktarabilirsiniz
import math import math
print(math.sqrt(16)) # => 4 print(math.sqrt(16)) # => 4.0
# Modülden belirli bir fonksiyonları alabilirsiniz # Modülden belirli bir fonksiyonları alabilirsiniz
from math import ceil, floor from math import ceil, floor

13
tr-tr/swift-tr.html.markdown
View File

@ -25,14 +25,14 @@ import UIKit
//XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot //XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot
listesinde gruplama yapmanıza olanak sağlıyor //listesinde gruplama yapmanıza olanak sağlıyor
// MARK: Bölüm işareti // MARK: Bölüm işareti
// TODO: Daha sonra yapılacak // TODO: Daha sonra yapılacak
// FIXME: Bu kodu düzelt // FIXME: Bu kodu düzelt
//Swift 2 de, println ve print metotları print komutunda birleştirildi. Print //Swift 2 de, println ve print metotları print komutunda birleştirildi.
otomatik olarak yeni satır ekliyor. //Print otomatik olarak yeni satır ekliyor.
print("Merhaba dünya") // println print olarak kullanılıyor. print("Merhaba dünya") // println print olarak kullanılıyor.
print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar. print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar.
@ -75,7 +75,7 @@ print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7
*/ */
var baziOptionalString: String? = "optional" // nil olabilir. var baziOptionalString: String? = "optional" // nil olabilir.
// yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay // yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay
okunabilir) //okunabilir)
var someOptionalString2: Optional<String> = "optional" var someOptionalString2: Optional<String> = "optional"
@ -104,7 +104,8 @@ if let baziOpsiyonelSabitString = baziOptionalString {
// Swift değişkenlerde herhangi bir tip saklanabilir. // Swift değişkenlerde herhangi bir tip saklanabilir.
// AnyObject == id // AnyObject == id
// Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle // Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle
çalışabilir (Class, Int, struct, etc) //çalışabilir
(Class, Int, struct, etc)
var herhangiBirObject: AnyObject = 7 var herhangiBirObject: AnyObject = 7
herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün" herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün"
@ -234,7 +235,7 @@ func fiyatlariGetir() -> (Double, Double, Double) {
let fiyatTuple = fiyatlariGetir() let fiyatTuple = fiyatlariGetir()
let fiyat = fiyatTuple.2 // 3.79 let fiyat = fiyatTuple.2 // 3.79
// _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden // _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden
gelir //gelir
let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69 let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69
print(fiyat1 == fiyatTuple.1) // true print(fiyat1 == fiyatTuple.1) // true
print("Benzin fiyatı: \(fiyat)") print("Benzin fiyatı: \(fiyat)")

8
typescript.html.markdown
View File

@ -159,6 +159,14 @@ var tuple = pairToTuple({ item1:"hello", item2:"world"});
// Including references to a definition file: // Including references to a definition file:
/// <reference path="jquery.d.ts" /> /// <reference path="jquery.d.ts" />
// Template Strings (strings that use backticks)
// String Interpolation with Template Strings
var name = 'Tyrone';
var greeting = `Hi ${name}, how are you?`
// Multiline Strings with Template Strings
var multiline = `This is an example
of a multiline string`;
``` ```
## Further Reading ## Further Reading

296
uk-ua/bash-ua.html.markdown Normal file
View File

@ -0,0 +1,296 @@
---
category: tool
tool: bash
contributors:
- ["Max Yankov", "https://github.com/golergka"]
- ["Darren Lin", "https://github.com/CogBear"]
- ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
- ["Denis Arh", "https://github.com/darh"]
- ["akirahirose", "https://twitter.com/akirahirose"]
- ["Anton Strömkvist", "http://lutic.org/"]
- ["Rahil Momin", "https://github.com/iamrahil"]
- ["Gregrory Kielian", "https://github.com/gskielian"]
- ["Etan Reisner", "https://github.com/deryni"]
translators:
- ["Ehreshi Ivan", "https://github.com/IvanEh"]
lang: uk-ua
---
Bash - командна оболонка unix (unix shell), що також розповсюджувалась як оболонка для
операційної системи GNU і зараз використовується як командна оболонка за замовчуванням
для Linux i Max OS X.
Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell.
Майже всі приклади, що наведені нижче можуть бути частиною shell-скриптів або
виконані в оболонці
[Більш детально тут.](http://www.gnu.org/software/bash/manual/bashref.html)
```bash
#!/bin/bash
# Перший рядок скрипта - це shebang, який вказує системі, як потрібно виконувати
# скрипт. Як ви вже зрозуміли, коментарі починаються з #. Shebang - тоже коментар
# Простий приклад hello world:
echo Hello world!
# Окремі команди починаються з нового рядка або розділяються крапкою з комкою:
echo 'Перший рядок'; echo 'Другий рядок'
# Оголошення змінної
VARIABLE="Просто рядок"
# Але не так!
VARIABLE = "Просто рядок"
# Bash вирішить, що VARIABLE - це команда, яку він може виконати,
# і видасть помилку, тому що не зможе знайти її
# І так також не можна писати:
VARIABLE= 'Просто рядок'
# Bash сприйме рядок 'Просто рядок' як команду. Але такої команди не має, тому
# видасть помилку.
# (тут 'VARIABLE=' інтерпретується як присвоєння тільки в контексті
# виконання команди 'Просто рядок')
# Використання змінних:
echo $VARIABLE
echo "$VARIABLE"
echo '$VARIABLE'
# Коли ви використовуєте змінну - присвоюєте значення, експортуєте і т.д. -
# пишіть її імя без $. А для отримання значення змінної використовуйте $.
# Одинарні лапки ' не розкривають значення змінних
# Підстановка рядків в змінні
echo ${VARIABLE/Просто/A}
# Цей вираз замінить перше входження підрядка "Просто" на "А"
# Отримання підрядка із рядка
LENGTH=7
echo ${VARIABLE:0:LENGTH}
# Цей вираз поверне тільки перші 7 символів змінної VARIABLE
# Значення за замовчуванням
echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"}
# Це спрацює при відсутності значення (FOO=) і при пустому рядку (FOO="")
# Нуль (FOO=0) поверне 0.
# Зауважте, що у всіх випадках значення самої змінної FOO не зміниться
# Вбудовані змінні:
# В bash є корисні вбудовані змінні, наприклад
echo "Значення, яке було повернуте в останній раз: $?"
echo "PID скрипта: $$"
echo "Кількість аргументів: $#"
echo "Аргументи скрипта: $@"
echo "Аргументи скрипта, розподілені по різним змінним: $1 $2..."
# Зчитування змінних з пристроїв введення
echo "Як вас звати?"
read NAME # Зверніть увагу, що вам не потрібно оголошувати нову змінну
echo Привіт, $NAME!
# В bash є звичайна умовна конструкція if:
# наберіть 'man test', щоб переглянути детальну інформацію про формати умов
if [ $NAME -ne $USER ]
then
echo "Ім’я користувача не збігається з введеним"
else
echo "Ім’я збігаєтьяс з іменем користувача"
fi
# Зауважте! якщо $Name пуста, bash інтерпретує код вище як:
if [ -ne $USER ]
# що є неправильним синтаксисом
# тому безпечний спосіб використання потенційно пустих змінних має вигляд:
if [ "$Name" -ne $USER ] ...
# коли $Name пуста, інтерпретується наступним чином:
if [ "" -ne $USER ] ...
# що працює як і очікувалося
# Умовне виконання (conditional execution)
echo "Виконується завжди" || echo "Виконається, якщо перша команда завершиться з помилкою"
echo "Виконується завжди" && echo "Виконається, якщо перша команда завершиться успішно"
# Щоб використати && і || у конструкції if, потрібно декілька пар дужок:
if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
then
echo "Виконається, якщо $NAME="Steve" i AGE=15."
fi
if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
then
echo "Виконається, якщо NAME="Steve" або NAME="Zach"."
fi
# Вирази позначаються наступним форматом:
echo $(( 10 + 5 ))
# На відмінно від інших мов програмування, Bash - це командна оболонка, а
# отже, працює в контексті поточної директорії
ls
# Ця команда може використовуватися з опціями
ls -l # Показати кожен файл і директорію на окремому рядку
# Результат попередньої команди можна перенаправити на вхід наступної.
# Команда grep фільтрує вхід по шаблону.
# Таким чином ми можемо переглянути тільки *.txt файли в поточній директорії:
ls -l | grep "\.txt"
# Ви можете перенаправ вхід і вихід команди (stdin, stdout, stderr).
# Наступна команда означає: читати із stdin, поки не зустрінеться ^EOF$, і
# перезаписати hello.py наступними рядками (до рядка "EOF"):
cat > hello.py << EOF
#!/usr/bin/env python
from __future__ import print_function
import sys
print("#stdout", file=sys.stdout)
print("#stderr", file=sys.stderr)
for line in sys.stdin:
print(line, file=sys.stdout)
EOF
# Запуск hello.py з різними варіантами перенаправлення stdin,
# stdout, stderr (стандартні потоки введення, виведення і помилок):
python hello.py < "input.in"
python hello.py > "output.out"
python hello.py 2> "error.err"
python hello.py > "output-and-error.log" 2>&1
python hello.py > /dev/null 2>&1
# Поток помилок перезапише фпйл, якщо цей файл існує
# тому, якщо ви хочете дописувати до файлу, використовуйте ">>":
python hello.py >> "output.out" 2>> "error.err"
# Перезаписати output.txt, дописати error.err і порахувати кількість рядків:
info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
wc -l output.out error.err
# Запустити команду і вивести її файловий дескриптор (див.: man fd; наприклад /dev/fd/123)
echo <(echo "#helloworld")
# Перезаписати output.txt рядком "#helloworld":
cat > output.out <(echo "#helloworld")
echo "#helloworld" > output.out
echo "#helloworld" | cat > output.out
echo "#helloworld" | tee output.out >/dev/null
# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим)
# Очистити тимчасові файли з детальним виводом (додайте '-i'
# для інтерактивного режиму)
rm -v output.out error.err output-and-error.log
# Команди можуть бути підставлені в інші команди використовуючи $():
# наступна команда виводить кількість файлів і директорій в поточній директорії
echo "Тут $(ls | wc -l) елементів."
# Те саме можна зробити використовуючи зворотні лапки
# Але вони не можуть бути вкладеними, тому перший варіант бажаніший
echo "Тут `ls | wc -l` елементів."
# В Bash є структура case, яка схожа на switch в Java и C++:
case "$VARIABLE" in
# перерахуйте шаблони, які будуть використовуватися в якості умов
0) echo "Тут нуль.";;
1) echo "Тут один.";;
*) echo "Не пусте значення.";;
esac
# Цикл for перебирає елементи передані в аргумент:
# Значення $VARIABLE буде напечатано тричі.
for VARIABLE in {1..3}
do
echo "$VARIABLE"
done
# Aбо можна використати звичний синтаксис for:
for ((a=1; a <= 3; a++))
do
echo $a
done
# Цикл for можно використати, щоб виконувати дії над файлами.
# Цей код запустить команду 'cat' для файлів file1 и file2
for VARIABLE in file1 file2
do
cat "$VARIABLE"
done
# ... або дії над виводом команд
# Запустимо cat для виведення із ls.
for OUTPUT in $(ls)
do
cat "$OUTPUT"
done
# Цикл while:
while [ true ]
do
echo "Тіло циклу..."
break
done
# Ви також можете оголосити функцію
# Оголошення:
function foo ()
{
echo "Аргументи функції доступні так само, як і аргументи скрипта: $@"
echo "$1 $2..."
echo "Це функція"
return 0
}
# Або просто
bar ()
{
echo "Інший спосіб оголошення функцій!"
return 0
}
# Виклик функцій
foo "Мое имя" $NAME
# Є багато корисних команд:
# вивести останні 10 рядків файла file.txt
tail -n 10 file.txt
# вивести перші 10 рядків файла file.txt
head -n 10 file.txt
# відсортувати рядки file.txt
sort file.txt
# відібрати або пропустити рядки, що дублюються (з опцією -d відбирає)
uniq -d file.txt
# вивести тільки першу колонку перед символом ','
cut -d ',' -f 1 file.txt
# замінити кожне 'okay' на 'great' у файлі file.txt (підтримується regex)
sed -i 's/okay/great/g' file.txt
# вивести в stdout все рядки з file.txt, що задовольняють шаблону regex;
# цей приклад виводить рядки, що починаються на foo і закінчуються на bar:
grep "^foo.*bar$" file.txt
# використайте опцію -c, щоб вивести кількість входжень
grep -c "^foo.*bar$" file.txt
# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F)
# щоб здійснити пошук по рядку, а не по шаблону regex, використовуйте fgrea (або grep -F)
fgrep "^foo.*bar$" file.txt
# Читайте вбудовану документацію Bash командою 'help':
help
help help
help for
help return
help source
help .
# Читайте Bash man-документацію
apropos bash
man 1 bash
man bash
# Читайте документацію info (? для допомоги)
apropos info | grep '^info.*('
man info
info info
info 5 info
# Читайте bash info документацію:
info bash
info bash 'Bash Features'
info bash 6
info --apropos bash
```

495
uk-ua/javascript-ua.html.markdown Normal file
View File

@ -0,0 +1,495 @@
---
language: javascript
contributors:
- ["Adam Brenecki", "http://adam.brenecki.id.au"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
filename: javascript-uk.js
translators:
- ["Ivan", "https://github.com/IvanEh"]
- ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
lang: uk-ua
---
JavaScript було створено в 1995 році Бренданом Айком, який працював у копаніх Netscape.
Він був задуманий як проста мова сценаріїв для веб-сайтів, який би доповнював Java
для більш складних веб-застосунків. Але тісна інтеграція з веб-сторінками і
вбудована підтримка браузерами призвела до того, що JavaScript став популярніший
за власне Java.
Зараз JavaScript не обмежується тільки веб-браузеорм. Наприклад, Node.js,
програмна платформа, що дозволяє виконувати JavaScript код з використанням
рушія V8 від браузера Google Chrome, стає все більш і більш популярною.
```js
// С-подібні коментарі. Однорядкові коментарі починаються з двох символів /(слеш)
/* а багаторядкові коментарі починаються з послідовності слеша та зірочки і
закінчуються символами зірочка-слеш */
//Інструкції можуть закінчуватися крапкою з комою ;
doStuff();
// ... але не обов’язково, тому що крапка з комою автоматично вставляється на
// місці символу нового рядка, крім деяких випадків.
doStuff()
// Ми завжди будемо використовувати крапку з комою в цьому посібнику, тому що ці
// винятки можуть призвести до неочікуваних результатів
///////////////////////////////////
// 1. Числа, Рядки і Оператори
// В JavaScript числа зберігаються тільки в одному форматі (64-bit IEEE 754 double)
// Цей тип має 52-бітну мантису, якої достатньо для збереження чисел з
// точністю до 9✕10¹⁵.
3; // = 3
1.5; // = 1.5
// Деякі прості арифметичні операції працють так, як ми очікуємо.
1 + 1; // = 2
0.1 + 0.2; // = 0.30000000000000004 (а деякі - ні)
8 - 1; // = 7
10 * 2; // = 20
35 / 5; // = 7
// В тому числі ділення з остачею
5 / 2; // = 2.5
// В JavaScript є побітові операції; коли ви виконуєте таку операцію,
// число з плаваючою точкою переводиться в ціле зі знаком
// довжиною *до* 32 розрядів.
1 << 2; // = 4
// Пріоритет у виразах можна задати явно круглими дужками
(1 + 3) * 2; // = 8
// Є три спеціальні значення, які не є реальними числами:
Infinity; // "нескінченність", наприклад, як результат ділення на 0
-Infinity; // "мінус нескінченність", як результат ділення від’ємного числа на 0
NaN; // "не число", наприклад, ділення 0/0
// Логічні типи
true;
false;
// Рядки створюються за допомогою подвійних та одинарних лапок
'абв';
"Привіт, світе!";
// Для логічного заперечення використовується знак оклику.
!true; // = false
!false; // = true
// Строга рівність ===
1 === 1; // = true
2 === 1; // = false
// Строга нерівність !==
1 !== 1; // = false
2 !== 1; // = true
// Інші оператори порівняння
1 < 10; // = true
1 > 10; // = false
2 <= 2; // = true
2 >= 2; // = true
// Рядки об’єднуються за допомогою оператора +
"hello, " + "world!"; // = "hello, world!"
// І порівнюються за допомогою > та <
"a" < "b"; // = true
// Перевірка на рівність з приведнням типів здійснюється оператором ==
"5" == 5; // = true
null == undefined; // = true
// ... але приведення не виконується при ===
"5" === 5; // = false
null === undefined; // = false
// ... приведення типів може призвести до дивних результатів
13 + !0; // 14
"13" + !0; // '13true'
// Можна отримати доступ до будь-якого символа рядка за допомгою charAt
"Це рядок".charAt(0); // = 'Ц'
// ... або використати метод substring, щоб отримати більший кусок
"Hello, world".substring(0, 5); // = "Hello"
// length - це не метод, а поле
"Hello".length; // = 5
// Типи null и undefined
null; // навмисна відсутність результату
undefined; // використовується для позначення відсутності присвоєного значення
// false, null, undefined, NaN, 0 та "" — хиба; все інше - істина.
// Потрібно відмітити, що 0 — це хиба, а "0" — істина, не зважаючи на те що:
// 0 == "0".
///////////////////////////////////
// 2. Змінні, Масиви, Об’єкти
// Змінні оголошуються за допомогою ключового слова var. JavaScript — мова з
// динамічною типізацією, тому не потрібно явно вказувати тип. Для присвоєння
// значення змінної використовується символ =
var someVar = 5;
// якщо пропустити слово var, ви не отримаєте повідомлення про помилку, ...
someOtherVar = 10;
// ... але вашу змінну буде створено в глобальному контексті, а не там, де
// ви її оголосили
// Змінні, які оголошені без присвоєння, автоматично приймають значення undefined
var someThirdVar; // = undefined
// У математичних операцій є скорочені форми:
someVar += 5; // як someVar = someVar + 5;
someVar *= 10; // тепер someVar = 100
// Інкремент і декремент
someVar++; // тепер someVar дорівнює 101
someVar--; // а зараз 100
// Масиви — це нумеровані списки, які зберігають значення будь-якого типу.
var myArray = ["Привіт", 45, true];
// Доступ до елементів можна отримати за допомогою синтаксиса з квадратними дужками
// Індексація починається з нуля
myArray[1]; // = 45
// Масиви в JavaScript змінюють свою довжину при додаванні нових елементів
myArray.push("Привіт");
myArray.length; // = 4
// Додавання і редагування елементів
myArray[3] = "світ";
// Об’єкти в JavaScript схожі на словники або асоціативні масиви в інших мовах
var myObj = {key1: "Hello", key2: "World"};
// Ключі - це рядки, але лапки не обов’язкі, якщо ключ задовольняє
// правилам формування назв змінних. Значення можуть бути будь-яких типів.
var myObj = {myKey: "myValue", "my other key": 4};
// Атрибути можна отримати використовуючи квадратні дужки
myObj["my other key"]; // = 4
// Або через точку, якщо ключ є правильним ідентифікатором
myObj.myKey; // = "myValue"
// Об’єкти можна динамічно змінювати й додавати нові поля
myObj.myThirdKey = true;
// Коли ви звертаєтесь до поля, що не існує, ви отримуєте значення undefined
myObj.myFourthKey; // = undefined
///////////////////////////////////
// 3. Керуючі конструкції
// Синтаксис для цього розділу майже такий самий, як у Java
// Умовна конструкція
var count = 1;
if (count == 3) {
// виконується, якщо count дорівнює 3
} else if (count == 4) {
// ..
} else {
// ...
}
// ... цикл while.
while (true){
// Нескінченний цикл!
}
// Цикл do-while такий самий, як while, але завжди виконується принаймні один раз.
var input
do {
input = getInput();
} while (!isValid(input))
// цикл for такий самий, як в C і Java:
// ініціалізація; умова; крок.
for (var i = 0; i < 5; i++) {
// виконається 5 разів
}
// && — логічне І, || — логічне АБО
if (house.size == "big" && house.color == "blue") {
house.contains = "bear";
}
if (color == "red" || color == "blue") {
// колір червоний або синій
}
// && та || використовують скорочене обчислення
// тому їх можна використовувати для задання значень за замовчуванням.
var name = otherName || "default";
// Оператор switch виконує перевірку на рівність за допомогою ===
// використовуйте break, щоб призупити виконання наступного case,
grade = 4;
switch (grade) {
case 5:
console.log("Відмінно");
break;
case 4:
console.log("Добре");
break;
case 3:
console.log("Можна краще");
break;
default:
console.log("Погано!");
break;
}
///////////////////////////////////
// 4. Функції, область видимості і замикання
// Функції в JavaScript оголошуються за допомогою ключового слова function.
function myFunction(thing) {
return thing.toUpperCase();
}
myFunction("foo"); // = "FOO"
// Зверніть увагу, що значення яке буде повернено, повинно починатися на тому ж
// рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
// через автоматичну вставку крапки з комою
function myFunction()
{
return // <- крапка з комою вставляється автоматично
{
thisIsAn: 'object literal'
}
}
myFunction(); // = undefined
// В JavaScript функції - це об`єкти першого класу, тому вони можуть присвоюватися
// іншим змінним і передаватися іншим функціям, наприклад, щоб визначити обробник
// події.
function myFunction() {
// код буде виконано через 5 сек.
}
setTimeout(myFunction, 5000);
// setTimeout не є частиною мови, але реалізований в браузерах і Node.js
// Функції не обов’язково мають мати ім’я при оголошенні — ви можете написати
// анонімну функцію як аргумент іншої функції
setTimeout(function() {
// Цей код буде виконано через п’ять секунд
}, 5000);
// В JavaScript реалізована концепція області видимості; функції мають свою
// область видимості, а інші блоки не мають
if (true) {
var i = 5;
}
i; // = 5, а не undefined, як це звичайно буває в інших мовах
// Така особливість призвела до шаблону "анонімних функцій, які викликають самих себе"
// що дозволяє уникнути проникнення змінних в глобальну область видимості
(function() {
var temporary = 5;
// об’єкт window зберігає глобальний контекст; таким чином ми можемо також додавати
// змінні до глобальної області
window.permanent = 10;
})();
temporary; // повідомлення про помилку ReferenceError
permanent; // = 10
// Замикання - один з найпотужніших інструментів JavaScript. Якщо функція визначена
// всередині іншої функції, то внутрішня функція має доступ до змінних зовнішньої
// функції навіть після того, як код буде виконуватися поза контекстом зовнішньої функції
function sayHelloInFiveSeconds(name) {
var prompt = "Привіт, " + name + "!";
// Внутрішня функція зберігається в локальній області так,
// ніби функція була оголошена за допомогою ключового слова var
function inner() {
alert(prompt);
}
setTimeout(inner, 5000);
// setTimeout асинхронна, тому функція sayHelloInFiveSeconds одразу завершиться,
// після чого setTimeout викличе функцію inner. Але функція inner
// «замкнута» кругом sayHelloInFiveSeconds, вона все рівно має доступ до змінної prompt
}
sayHelloInFiveSeconds("Адам"); // Через 5 с відкриється вікно «Привіт, Адам!»
///////////////////////////////////
// 5. Об’єкти: конструктори і прототипи
// Об’єкти можуть містити функції
var myObj = {
myFunc: function() {
return "Hello, world!";
}
};
myObj.myFunc(); // = "Hello, world!"
// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за
// допомогою ключового слова this.
myObj = {
myString: "Hello, world!",
myFunc: function() {
return this.myString;
}
};
myObj.myFunc(); // = "Hello, world!"
// Значення this залежить від того, як функція викликається
// а не від того, де вона визначена. Таким чином наша функція не працює, якщо
// вона викликана не в контексті об’єкта
var myFunc = myObj.myFunc;
myFunc(); // = undefined
// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до
// цього об’єкта через this
var myOtherFunc = function() {
}
myObj.myOtherFunc = myOtherFunc;
myObj.myOtherFunc(); // = "HELLO, WORLD!"
// Контекст виконання функції можна задати за допомогою сall або apply
var anotherFunc = function(s) {
return this.myString + s;
}
anotherFunc.call(myObj, " Hello!"); // = "Hello, world! Hello!"
// Функцiя apply приймає в якості аргументу масив
anotherFunc.apply(myObj, [" Hello!"]); // = "Hello, world! Hello!"
// apply можна використати, коли функція працює послідовністю аргументів, а
// ви хочете передати масив
Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (Ой-ой!)
Math.min.apply(Math, [42, 6, 27]); // = 6
// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт
// використовують bind
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" Hello!"); // = "Hello world, Hello!"
// Bind можна використати для задання аргументів
var product = function(a, b) { return a * b; }
var doubler = product.bind(this, 2);
doubler(8); // = 16
// Коли ви викликаєте функцію за допомогою ключового слова new, створюється новий об’єкт,
// доступний функції за допомогою this. Такі функції називають конструкторами.
var MyConstructor = function() {
this.myNumber = 5;
}
myNewObj = new MyConstructor(); // = {myNumber: 5}
myNewObj.myNumber; // = 5
// У кожного об’єкта є прототип. Коли ви звертаєтесь до поля, яке не існує в цьому
// об’єкті, інтерпретатор буде шукати поле в прототипі
// Деякі реалізації мови дозволяють отримати доступ до прототипа об’єкта через
// "магічну" властивість __proto__. Це поле не є частиною стандарта, але існують
// стандартні способи використання прототипів, які ми побачимо пізніше
var myObj = {
myString: "Hello, world!"
};
var myPrototype = {
meaningOfLife: 42,
myFunc: function() {
return this.myString.toLowerCase()
}
};
myObj.__proto__ = myPrototype;
myObj.meaningOfLife; // = 42
// Аналогічно для функцій
myObj.myFunc(); // = "Hello, world!"
// Якщо інтерпретатор не знайде властивості в прототипі, то він продовжить пошук
// в прототипі прототипа і так далі
myPrototype.__proto__ = {
myBoolean: true
};
myObj.myBoolean; // = true
// Кожен об’єкт зберігає посилання на свій прототип. Це значить, що ми можемо змінити
// наш прототип, і наші зміни будуть всюди відображені.
myPrototype.meaningOfLife = 43;
myObj.meaningOfLife; // = 43
// Ми сказали, що властивість __proto__ нестандартна, і нема ніякого стандартного способу
// змінити прототип об’єкта, що вже існує. Але є два способи створити новий об’єкт із заданим
// прототипом
// Перший спосіб — це Object.create, який з’явився в JavaScript недавно,
// а тому в деяких реалізаціях може бути недоступним.
var myObj = Object.create(myPrototype);
myObj.meaningOfLife; // = 43
// Другий спосіб: у конструкторів є властивість з іменем prototype. Це *не*
// прототип функції-конструктора, це прототип для нових об’єктів, які будуть створені
// цим конструктором і ключового слова new.
MyConstructor.prototype = {
myNumber: 5,
getMyNumber: function() {
return this.myNumber;
}
};
var myNewObj2 = new MyConstructor();
myNewObj2.getMyNumber(); // = 5
myNewObj2.myNumber = 6
myNewObj2.getMyNumber(); // = 6
// У вбудованих типів(рядок, число) теж є конструктори, які створють еквівалентні
// об’єкти-обгортки
var myNumber = 12;
var myNumberObj = new Number(12);
myNumber == myNumberObj; // = true
// Але вони не ідентичні
typeof myNumber; // = 'number'
typeof myNumberObj; // = 'object'
myNumber === myNumberObj; // = false
if (0) {
// Цей код не виконається, тому що 0 - це хиба.
}
// Об’єкти-обгортки і вбудовані типи мають спільні прототипи, тому
// ви можете розширити функціонал рядків:
String.prototype.firstCharacter = function() {
return this.charAt(0);
}
"abc".firstCharacter(); // = "a"
// Такий прийом часто використовуються в поліфілах, які реалізують нові можливості
// JavaScript в старій реалізації мови, так що вони можуть бути використані в старих
// середовищах
// Наприклад, Object.create доступний не у всіх реалізаціях, але ми можемо
// використати функції за допомогою наступного поліфіла:
if (Object.create === undefined) { // не перезаписуємо метод, якщо він існує
Object.create = function(proto) {
// Створюємо правильний конструктор з правильним прототипом
var Constructor = function(){};
Constructor.prototype = proto;
return new Constructor();
}
}
```
## Що почитати
[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
[4]: http://www.learneroo.com/modules/64/nodes/350
[5]: http://bonsaiden.github.io/JavaScript-Garden/
[6]: http://www.amazon.com/gp/product/0596805527/
[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
[8]: http://eloquentjavascript.net/
[9]: http://jstherightway.org/

Some files were not shown because too many files have changed in this diff Show More