adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-10-05 09:08:02 +03:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'adambard/master'

Browse Source
This commit is contained in:
Bohdan Shtepan 2016-04-05 20:27:09 +03:00
commit 8abfffd183
184 changed files with 23166 additions and 1728 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.gitignore vendored Normal file
View File

@ -0,0 +1,16 @@
**/*~
**/*#
**/#*#
**/*.swp
**/*.swo
**/*.bak
**/*.log*
**/*.sublime-workspace
**/.DS_Store
**/.DS_Store?
**/._*
**/.Spotlight-V100
**/.Trashes
**/ehthumbs.db
**/Thumbs.db
**/desktop.ini

70
CONTRIBUTING.markdown Normal file
View File

@ -0,0 +1,70 @@
# Contributing
All contributions are welcome, from the tiniest typo to a brand new article.
Translations in all languages are welcome (or, for that matter, original
articles in any language). Send a pull request or open an issue any time of day
or night.
**Please prepend the tag `[language/lang-code]` to your issues and pull
requests.** For example, `[python/en]` for English Python. This will help
everyone pick out things they care about.
We're happy for any contribution in any form, but if you're making more than one
major change (i.e. translations for two different languages) it would be super
cool of you to make a separate pull request for each one so that someone can
review them more effectively and/or individually.
## Style Guidelines
- **Keep lines of under 80 chars**
+ Try to keep **line length in code blocks to 80 characters or fewer**.
+ Otherwise, the text will overflow and look odd.
- **Prefer example to exposition**
+ Try to use as few words as possible.
+ Code examples are preferred over exposition in all cases.
- **Eschew surplusage**
+ We welcome newcomers, but the target audience for this site is programmers
with some experience.
+ Try to avoid explaining basic concepts except for those specific to the
language in question.
+ Keep articles succinct and scannable. We all know how to use Google here.
- **Use UTF-8**
+ For translations (or EN articles with non-ASCII characters) please make sure
your file is UTF-8 encoded.
+ Try to leave out the byte-order-mark at the start of the file. (`:set nobomb`
in Vim)
### Header configuration
The actual site uses Middleman to generate HTML files from these Markdown ones.
Middleman, or at least the custom scripts underpinning the site, requires that
some key information be defined in the header.
The following fields are necessary for English articles about programming
languages:
- **language** The *programming language* in question
- **contributors** A list of [author, URL] lists to credit
Other fields:
- **filename**: The filename for this article's code. It will be fetched, mashed
together, and made downloadable.
+ For non-English articles, *filename* should have a language-specific
suffix.
- **lang**: For translations, the human language this article is in. For
categorization, mostly.
Here's an example header for an Esperanto translation of Ruby:
```yaml
---
language: ruby
filename: learnruby-epo.ruby
contributors:
- ["Doktor Esperanto", "http://example.com/"]
- ["Someone else", "http://someoneelseswebsite.com/"]
lang: ep-ep
---
```

4
PULL_REQUEST_TEMPLATE.md Normal file
View File

@ -0,0 +1,4 @@
- [ ] PR touches only one file (or a set of logically related files with similar changes made)
- [ ] Content changes are aimed at *intermediate to experienced programmers* (this is a poor format for explaining fundamental programming concepts)
- [ ] YAML Frontmatter formatted according to [CONTRIBUTING.md](https://github.com/adambard/learnxinyminutes-docs/blob/master/CONTRIBUTING.markdown)
- [ ] Seriously, look at it now. Watch for quotes and double-check field names.

103
README.markdown
View File

@ -1,88 +1,45 @@
# [Learn X in Y minutes](http://learnxinyminutes.com)
# [Learn X in Y minutes][1]
Whirlwind tours of (several, hopefully many someday) popular and
ought-to-be-more-popular programming languages, presented as valid,
commented code and explained as they go.
ought-to-be-more-popular programming languages, presented as valid, commented
code and explained as they go.
## We need YOU!...
... to write more inline code tutorials. Just grab an existing file from
this repo and copy the formatting (don't worry, it's all very simple).
Make a new file, send a pull request, and if it passes muster I'll get it up pronto.
Remember to fill in the "contributors" fields so you get credited
properly!
... to write more inline code tutorials. Just grab an existing file from this
repo and copy the formatting (don't worry, it's all very simple). Make a new
file, send a pull request, and if it passes muster I'll get it up pronto.
Remember to fill in the "contributors" fields so you get credited properly!
## Contributing
All contributions are welcome, from the tiniest typo to a brand new article. Translations
in all languages are welcome (or, for that matter, original articles in any language).
Send a pull request or open an issue any time of day or night.
All contributions are welcome, from the tiniest typo to a brand new article.
Translations in all languages are welcome (or, for that matter, original
articles in any language). Send a pull request or open an issue any time of day
or night.
**Please tag your issues and pull requests with [language/lang-code] at the beginning**
**(e.g. [python/en] for English Python).** This will help everyone pick out things they
care about.
**Please prepend the tag `[language/lang-code]` to your issues and pull
requests.** For example, `[python/en]` for English Python. This will help
everyone pick out things they care about.
We're happy for any contribution in any form, but if you're making more than one major change
(i.e. translations for two different languages) it would be super cool of you to make a
separate pull request for each one so that someone can review them more effectively and/or
individually.
We're happy for any contribution in any form, but if you're making more than one
major change (i.e. translations for two different languages) it would be super
cool of you to make a separate pull request for each one so that someone can
review them more effectively and/or individually.
### Style Guidelines
* **Keep lines under 80 chars**
* **Prefer example to exposition**
* **Eschew surplusage**
* **Use UTF-8**
Long version:
* Try to keep **line length in code blocks to 80 characters or fewer**, or they'll overflow
and look odd.
* Try to use as few words as possible. Code examples are preferred over exposition in all cases.
* We welcome newcomers, but the target audience for this site is programmers with some experience.
So, try to avoid explaining basic concepts except for those specific to the language in question,
to keep articles succinct and scannable. We all know how to use Google here.
* For translations (or English articles with non-ASCII characters), please make sure your file is
UTF-8 encoded, and try to leave out the byte-order-mark at the start of the file. (`:set nobomb` in Vim)
### Header configuration
The actual site uses Middleman to generate HTML files from these Markdown ones. Middleman, or at least
the custom scripts underpinning the site, required that some key information be defined in the header.
The following fields are necessary for English articles about programming languages:
* **language** The *programming language* in question
* **contributors** A list of [author, URL] lists to credit
Other fields:
* **filename**: The filename for this article's code. It will be fetched, mashed together, and made downloadable.
For non-English articles, *filename* should have a language-specific suffix.
* **lang**: For translations, the human language this article is in. For categorization, mostly.
Here's an example header for an Esperanto translation of Ruby:
```yaml
---
language: ruby
filename: learnruby-epo.ruby
contributors:
- ["Doktor Esperanto", "http://example.com/"]
- ["Someone else", "http://someoneelseswebsite.com/"]
lang: ep-ep
---
```
For a detailed style guide, please review the full [CONTRIBUTING][2] guidelines.
## License
Contributors retain copyright to their work, and can request removal at any time.
By uploading a doc here, you agree to publish your work under the default
[Creative Commons Attribution-ShareAlike 3.0 Unported](http://creativecommons.org/licenses/by-sa/3.0/deed.en_US)
licensing included on each doc page.
Contributors retain copyright to their work, and can request removal at any
time. By uploading a doc here, you agree to publish your work under the default
[Creative Commons Attribution-ShareAlike 3.0 Unported][3] licensing included on
each doc page.
Anything not covered by the above -- basically, this README -- you can use
as you wish, I guess.
Anything not covered by the above -- basically, this README -- you can use as
you wish, I guess.
[1]: http://learnxinyminutes.com
[2]: /CONTRIBUTING.markdown
[3]: http://creativecommons.org/licenses/by-sa/3.0/deed.en_US

122
asciidoc.html.markdown Normal file
View File

@ -0,0 +1,122 @@
---
language: asciidoc
contributors:
- ["Ryan Mavilia", "http://unoriginality.rocks/"]
filename: asciidoc.md
---
AsciiDoc is a markup language similar to Markdown and it can be used for anything from books to blogs. Created in 2002 by Stuart Rackham the language is simple but it allows for a great amount of customization.
Document Header
Headers are optional and can't contain blank lines. It must be offset from content by at least one blank line.
Title Only
```
= Document Title
First sentence of document.
```
Title and Author
```
= Document Title
First Last <first.last@learnxinyminutes.com>
Start of this document.
```
Multiple Authors
```
= Document Title
John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
Start of a doc with multiple authors.
```
Revision Line (requires an author line)
```
= Doc Title V1
Potato Man <chip@crunchy.com>
v1.0, 2016-01-13
This article about chips is going to be fun.
```
Paragraphs
```
You don't need anything special for paragraphs.
Add a blank line between paragraphs to separate them.
To create a line blank add a +
and you will receive a line break!
```
Formatting Text
```
_underscore creates italics_
*asterisks for bold*
*_combine for extra fun_*
`use ticks to signify monospace`
`*bolded monospace*`
```
Section Titles
```
= Level 0 (may only be used in document's header)
== Level 1 <h2>
=== Level 2 <h3>
==== Level 3 <h4>
===== Level 4 <h5>
====== Level 5 <h6>
======= Level 6 <h7>
```
Lists
To create a bulleted list use asterisks.
```
* foo
* bar
* baz
```
To create a numbered list use periods.
```
. item 1
. item 2
. item 3
```
You can nest lists by adding extra asterisks or periods up to five times.
```
* foo 1
** foo 2
*** foo 3
**** foo 4
***** foo 5
. foo 1
.. foo 2
... foo 3
.... foo 4
..... foo 5
```

147
asymptotic-notation.html.markdown
View File

@ -3,41 +3,52 @@ category: Algorithms & Data Structures
name: Asymptotic Notation
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
- ["Divay Prakash", "http://github.com/divayprakash"]
---
# Asymptotic Notations
## What are they?
Asymptotic Notations are languages that allow us to analyze an algorithm's running time by
identifying its behavior as the input size for the algorithm increases. This is also known as
an algorithm's growth rate. Does the algorithm suddenly become incredibly slow when the input
size grows? Does it mostly maintain its quick run time as the input size increases?
Asymptotic Notation gives us the ability to answer these questions.
Asymptotic Notations are languages that allow us to analyze an algorithm's
running time by identifying its behavior as the input size for the algorithm
increases. This is also known as an algorithm's growth rate. Does the
algorithm suddenly become incredibly slow when the input size grows? Does it
mostly maintain its quick run time as the input size increases? Asymptotic
Notation gives us the ability to answer these questions.
## Are there alternatives to answering these questions?
One way would be to count the number of primitive operations at different input sizes.
Though this is a valid solution, the amount of work this takes for even simple algorithms
does not justify its use.
One way would be to count the number of primitive operations at different
input sizes. Though this is a valid solution, the amount of work this takes
for even simple algorithms does not justify its use.
Another way is to physically measure the amount of time an algorithm takes to complete
given different input sizes. However, the accuracy and relativity (times obtained would
only be relative to the machine they were computed on) of this method is bound to
environmental variables such as computer hardware specifications, processing power, etc.
Another way is to physically measure the amount of time an algorithm takes to
complete given different input sizes. However, the accuracy and relativity
(times obtained would only be relative to the machine they were computed on)
of this method is bound to environmental variables such as computer hardware
specifications, processing power, etc.
## Types of Asymptotic Notation
In the first section of this doc we described how an Asymptotic Notation identifies the
behavior of an algorithm as the input size changes. Let us imagine an algorithm as a function
f, n as the input size, and f(n) being the running time. So for a given algorithm f, with input
size n you get some resultant run time f(n). This results in a graph where the Y axis is the
runtime, X axis is the input size, and plot points are the resultants of the amount of time
for a given input size.
In the first section of this doc we described how an Asymptotic Notation
identifies the behavior of an algorithm as the input size changes. Let us
imagine an algorithm as a function f, n as the input size, and f(n) being
the running time. So for a given algorithm f, with input size n you get
some resultant run time f(n). This results in a graph where the Y axis is the
runtime, X axis is the input size, and plot points are the resultants of the
amount of time for a given input size.
You can label a function, or algorithm, with an Asymptotic Notation in many different ways.
Some examples are, you can describe an algorithm by its best case, worse case, or equivalent case.
The most common is to analyze an algorithm by its worst case. You typically don't evaluate by best case because those conditions aren't what you're planning for. A very good example of this is sorting algorithms; specifically, adding elements to a tree structure. Best case for most algorithms could be as low as a single operation. However, in most cases, the element you're adding will need to be sorted appropriately through the tree, which could mean examining an entire branch. This is the worst case, and this is what we plan for.
You can label a function, or algorithm, with an Asymptotic Notation in many
different ways. Some examples are, you can describe an algorithm by its best
case, worse case, or equivalent case. The most common is to analyze an
algorithm by its worst case. You typically don't evaluate by best case because
those conditions aren't what you're planning for. A very good example of this
is sorting algorithms; specifically, adding elements to a tree structure. Best
case for most algorithms could be as low as a single operation. However, in
most cases, the element you're adding will need to be sorted appropriately
through the tree, which could mean examining an entire branch. This is the
worst case, and this is what we plan for.
### Types of functions, limits, and simplification
@ -45,16 +56,25 @@ The most common is to analyze an algorithm by its worst case. You typically don'
Logarithmic Function - log n
Linear Function - an + b
Quadratic Function - an^2 + bn + c
Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some constant
Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some
constant
Exponential Function - a^n, where a is some constant
```
These are some basic function growth classifications used in various notations. The list starts at the slowest growing function (logarithmic, fastest execution time) and goes on to the fastest growing (exponential, slowest execution time). Notice that as 'n', or the input, increases in each of those functions, the result clearly increases much quicker in quadratic, polynomial, and exponential, compared to logarithmic and linear.
These are some basic function growth classifications used in various
notations. The list starts at the slowest growing function (logarithmic,
fastest execution time) and goes on to the fastest growing (exponential,
slowest execution time). Notice that as 'n', or the input, increases in each
of those functions, the result clearly increases much quicker in quadratic,
polynomial, and exponential, compared to logarithmic and linear.
One extremely important note is that for the notations about to be discussed you should do your best to use simplest terms. This means to disregard constants, and lower order terms, because as the input size (or n in our f(n)
example) increases to infinity (mathematical limits), the lower order terms and constants are of little
to no importance. That being said, if you have constants that are 2^9001, or some other ridiculous,
unimaginable amount, realize that simplifying will skew your notation accuracy.
One extremely important note is that for the notations about to be discussed
you should do your best to use simplest terms. This means to disregard
constants, and lower order terms, because as the input size (or n in our f(n)
example) increases to infinity (mathematical limits), the lower order terms
and constants are of little to no importance. That being said, if you have
constants that are 2^9001, or some other ridiculous, unimaginable amount,
realize that simplifying will skew your notation accuracy.
Since we want simplest form, lets modify our table a bit...
@ -67,10 +87,13 @@ Exponential - a^n, where a is some constant
```
### Big-O
Big-O, commonly written as O, is an Asymptotic Notation for the worst case, or ceiling of growth
for a given function. Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time complexity
you are trying to relate to your algorithm. `f(n)` is O(g(n)), if for any real constant c (c > 0),
`f(n)` <= `c g(n)` for every input size n (n > 0).
Big-O, commonly written as **O**, is an Asymptotic Notation for the worst
case, or ceiling of growth for a given function. It provides us with an
_**asymptotic upper bound**_ for the growth rate of runtime of an algorithm.
Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time
complexity you are trying to relate to your algorithm. `f(n)` is O(g(n)), if
for some real constant c (c > 0), `f(n)` <= `c g(n)` for every input size
n (n > 0).
*Example 1*
@ -114,19 +137,62 @@ Is there some constant c that satisfies this for all n?
No, there isn't. `f(n)` is NOT O(g(n)).
### Big-Omega
Big-Omega, commonly written as Ω, is an Asymptotic Notation for the best case, or a floor growth rate
for a given function.
Big-Omega, commonly written as **Ω**, is an Asymptotic Notation for the best
case, or a floor growth rate for a given function. It provides us with an
_**asymptotic lower bound**_ for the growth rate of runtime of an algorithm.
`f(n)` is Ω(g(n)), if for any real constant c (c > 0), `f(n)` is >= `c g(n)` for every input size n (n > 0).
`f(n)` is Ω(g(n)), if for some real constant c (c > 0), `f(n)` is >= `c g(n)`
for every input size n (n > 0).
Feel free to head over to additional resources for examples on this. Big-O is the primary notation used
for general algorithm time complexity.
### Note
The asymptotic growth rates provided by big-O and big-omega notation may or
may not be asymptotically tight. Thus we use small-o and small-omega notation
to denote bounds that are not asymptotically tight.
### Small-o
Small-o, commonly written as **o**, is an Asymptotic Notation to denote the
upper bound (that is not asymptotically tight) on the growth rate of runtime
of an algorithm.
`f(n)` is o(g(n)), if for any real constant c (c > 0), `f(n)` is < `c g(n)`
for every input size n (n > 0).
The definitions of O-notation and o-notation are similar. The main difference
is that in f(n) = O(g(n)), the bound f(n) <= g(n) holds for _**some**_
constant c > 0, but in f(n) = o(g(n)), the bound f(n) < c g(n) holds for
_**all**_ constants c > 0.
### Small-omega
Small-omega, commonly written as **ω**, is an Asymptotic Notation to denote
the lower bound (that is not asymptotically tight) on the growth rate of
runtime of an algorithm.
`f(n)` is ω(g(n)), if for any real constant c (c > 0), `f(n)` is > `c g(n)`
for every input size n (n > 0).
The definitions of Ω-notation and ω-notation are similar. The main difference
is that in f(n) = Ω(g(n)), the bound f(n) >= g(n) holds for _**some**_
constant c > 0, but in f(n) = ω(g(n)), the bound f(n) > c g(n) holds for
_**all**_ constants c > 0.
### Theta
Theta, commonly written as **Θ**, is an Asymptotic Notation to denote the
_**asymptotically tight bound**_ on the growth rate of runtime of an algorithm.
`f(n)` is Θ(g(n)), if for some real constants c1, c2 (c1 > 0, c2 > 0),
`c1 g(n)` is < `f(n)` is < `c2 g(n)` for every input size n (n > 0).
∴ `f(n)` is Θ(g(n)) implies `f(n)` is O(g(n)) as well as `f(n)` is Ω(g(n)).
Feel free to head over to additional resources for examples on this. Big-O
is the primary notation use for general algorithm time complexity.
### Ending Notes
It's hard to keep this kind of topic short, and you should definitely go through the books and online
resources listed. They go into much greater depth with definitions and examples.
More where x='Algorithms & Data Structures' is on its way; we'll have a doc up on analyzing actual
code examples soon.
It's hard to keep this kind of topic short, and you should definitely go
through the books and online resources listed. They go into much greater depth
with definitions and examples. More where x='Algorithms & Data Structures' is
on its way; we'll have a doc up on analyzing actual code examples soon.
## Books
@ -137,3 +203,4 @@ code examples soon.
* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
* [Big-O Cheatsheet](http://bigocheatsheet.com/) - common structures, operations, and algorithms, ranked by complexity.

17
bash.html.markdown
View File

@ -83,7 +83,7 @@ echo Hello, $Name!
# We have the usual if structure:
# use 'man test' for more info about conditionals
if [ $Name -ne $USER ]
if [ $Name != $USER ]
then
echo "Your name isn't your username"
else
@ -91,12 +91,12 @@ else
fi
# NOTE: if $Name is empty, bash sees the above condition as:
if [ -ne $USER ]
if [ != $USER ]
# which is invalid syntax
# so the "safe" way to use potentially empty variables in bash is:
if [ "$Name" -ne $USER ] ...
if [ "$Name" != $USER ] ...
# which, when $Name is empty, is seen by bash as:
if [ "" -ne $USER ] ...
if [ "" != $USER ] ...
# which works as expected
# There is also conditional execution
@ -130,6 +130,15 @@ ls -l # Lists every file and directory on a separate line
# .txt files in the current directory:
ls -l | grep "\.txt"
# Since bash works in the context of a current directory, you might want to
# run your command in some other directory. We have cd for changing location:
cd ~ # change to home directory
cd .. # go up one directory
# (^^say, from /home/username/Downloads to /home/username)
cd /home/username/Documents # change to specified directory
cd ~/Documents/.. # still in home directory..isn't it??
# You can redirect command input and output (stdin, stdout, and stderr).
# Read from stdin until ^EOF$ and overwrite hello.py with the lines
# between "EOF":

2
brainfuck.html.markdown → bf.html.markdown
View File

@ -1,5 +1,5 @@
---
language: brainfuck
language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]

132
c++.html.markdown
View File

@ -149,7 +149,7 @@ namespace First {
namespace Second {
void foo()
{
printf("This is Second::foo\n")
printf("This is Second::foo\n");
}
}
@ -330,7 +330,7 @@ ECarTypes GetPreferredCarType()
}
// As of C++11 there is an easy way to assign a type to the enum which can be
// useful in serialization of data and converting enums back-and-forth between
// useful in serialization of data and converting enums back-and-forth between
// the desired type and their respective constants
enum ECarTypes : uint8_t
{
@ -352,7 +352,7 @@ void WritePreferredCarTypeToFile(ECarTypes InputCarType)
}
// On the other hand you may not want enums to be accidentally cast to an integer
// type or to other enums so it is instead possible to create an enum class which
// type or to other enums so it is instead possible to create an enum class which
// won't be implicitly converted
enum class ECarTypes : uint8_t
{
@ -468,7 +468,7 @@ int main() {
// Inheritance:
// This class inherits everything public and protected from the Dog class
// as well as private but may not directly access private members/methods
// as well as private but may not directly access private members/methods
// without a public or protected method for doing so
class OwnedDog : public Dog {
@ -820,6 +820,76 @@ std::map<Foo, int, compareFunction> fooMap;
fooMap[Foo(1)] = 1;
fooMap.find(Foo(1)); //true
///////////////////////////////////////
// Lambda Expressions (C++11 and above)
///////////////////////////////////////
// lambdas are a convenient way of defining an anonymous function
// object right at the location where it is invoked or passed as
// an argument to a function.
// For example, consider sorting a vector of pairs using the second
// value of the pair
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
// The "Capture List" defines what from the outside of the lambda should be available inside the function body and how.
// It can be either:
// 1. a value : [x]
// 2. a reference : [&x]
// 3. any variable currently in scope by reference [&]
// 4. same as 3, but by value [=]
// 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.
// More on Lambdas in C++ : http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
///////////////////////////////
// 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
}
/////////////////////
// Fun stuff
/////////////////////
@ -870,20 +940,50 @@ Foo f1;
f1 = f2;
// How to truly clear a container:
class Foo { ... };
vector<Foo> v;
for (int i = 0; i < 10; ++i)
v.push_back(Foo());
///////////////////////////////////////
// Tuples (C++11 and above)
///////////////////////////////////////
// Following line sets size of v to 0, but destructors don't get called
// and resources aren't released!
v.empty();
v.push_back(Foo()); // New value is copied into the first Foo we inserted
#include<tuple>
// Truly destroys all values in v. See section about temporary objects for
// explanation of why this works.
v.swap(vector<Foo>());
// Conceptually, Tuples are similar to old data structures (C-like structs) but instead of having named data members ,
// its elements are accessed by their order in the tuple.
// We start with constructing a tuple.
// Packing values into tuple
auto first = make_tuple(10, 'A');
const int maxN = 1e9;
const int maxL = 15;
auto second = make_tuple(maxN, maxL);
// printing elements of 'first' tuple
cout << get<0>(first) << " " << get<1>(first) << "\n"; //prints : 10 A
// printing elements of 'second' tuple
cout << get<0>(second) << " " << get<1>(second) << "\n"; // prints: 1000000000 15
// Unpacking tuple into variables
int first_int;
char first_char;
tie(first_int, first_char) = first;
cout << first_int << " " << first_char << "\n"; // prints : 10 A
// We can also create tuple like this.
tuple<int, char, double> third(11, 'A', 3.14141);
// tuple_size returns number of elements in a tuple (as a constexpr)
cout << tuple_size<decltype(third)>::value << "\n"; // prints: 3
// tuple_cat concatenates the elements of all the tuples in the same order.
auto concatenated_tuple = tuple_cat(first, second, third);
// concatenated_tuple becomes = (10, 'A', 1e9, 15, 11, 'A' ,3.14141)
cout << get<0>(concatenated_tuple) << "\n"; // prints: 10
cout << get<3>(concatenated_tuple) << "\n"; // prints: 15
cout << get<5>(concatenated_tuple) << "\n"; // prints: 'A'
```
Further Reading:

49
c.html.markdown
View File

@ -36,7 +36,6 @@ Multi-line comments don't nest /* Be careful */ // comment ends on this line...
enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
// MON gets 2 automatically, TUE gets 3, etc.
// Import headers with #include
#include <stdlib.h>
#include <stdio.h>
@ -76,7 +75,7 @@ int main (int argc, char** argv)
///////////////////////////////////////
// Types
///////////////////////////////////////
// All variables MUST be declared at the top of the current block scope
// we declare them dynamically along the code for the sake of the tutorial
@ -114,7 +113,6 @@ int main (int argc, char** argv)
// sizeof(obj) yields the size of the expression (variable, literal, etc.).
printf("%zu\n", sizeof(int)); // => 4 (on most machines with 4-byte words)
// If the argument of the `sizeof` operator is an expression, then its argument
// is not evaluated (except VLAs (see below)).
// The value it yields in this case is a compile-time constant.
@ -130,7 +128,6 @@ int main (int argc, char** argv)
int my_int_array[20]; // This array occupies 4 * 20 = 80 bytes
// (assuming 4-byte words)
// You can initialize an array to 0 thusly:
char my_array[20] = {0};
@ -146,9 +143,9 @@ int main (int argc, char** argv)
// can be declared as well. The size of such an array need not be a compile
// time constant:
printf("Enter the array size: "); // ask the user for an array size
int size;
fscanf(stdin, "%d", &size);
int var_length_array[size]; // declare the VLA
int array_size;
fscanf(stdin, "%d", &array_size);
int var_length_array[array_size]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array);
// Example:
@ -239,7 +236,7 @@ int main (int argc, char** argv)
z = (e > f) ? e : f; // => 10 "if e > f return e, else return f."
// Increment and decrement operators:
char *s = "iLoveC";
char *s = "ILoveC";
int j = 0;
s[j++]; // => "i". Returns the j-th item of s THEN increments value of j.
j = 0;
@ -313,9 +310,15 @@ int main (int argc, char** argv)
case 1:
printf("Huh, 'a' equals 1!\n");
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:
// if `some_integral_expression` didn't match any of the labels
fputs("error!\n", stderr);
fputs("Error!\n", stderr);
exit(-1);
break;
}
@ -340,8 +343,7 @@ int main (int argc, char** argv)
https://ideone.com/GuPhd6
this will print out "Error occured at i = 52 & j = 99."
*/
///////////////////////////////////////
// Typecasting
///////////////////////////////////////
@ -380,7 +382,6 @@ int main (int argc, char** argv)
// (%p formats an object pointer of type void *)
// => Prints some address in memory;
// Pointers start with * in their declaration
int *px, not_a_pointer; // px is a pointer to an int
px = &x; // Stores the address of x in px
@ -426,7 +427,6 @@ int main (int argc, char** argv)
printf("%zu, %zu\n", sizeof arraythethird, sizeof ptr);
// probably prints "40, 4" or "40, 8"
// Pointers are incremented and decremented based on their type
// (this is called pointer arithmetic)
printf("%d\n", *(x_ptr + 1)); // => Prints 19
@ -440,7 +440,7 @@ int main (int argc, char** argv)
for (xx = 0; xx < 20; xx++) {
*(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
} // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints)
// Note that there is no standard way to get the length of a
// dynamically allocated array in C. Because of this, if your arrays are
// going to be passed around your program a lot, you need another variable
@ -491,7 +491,7 @@ int add_two_ints(int x1, int x2)
/*
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
argument where the function was called.
@ -572,8 +572,6 @@ void testFunc2() {
}
//**You may also declare functions as static to make them private**
///////////////////////////////////////
// User-defined types and structs
///////////////////////////////////////
@ -690,6 +688,7 @@ typedef void (*my_fnp_type)(char *);
"%o"; // octal
"%%"; // prints %
*/
///////////////////////////////////////
// Order of Evaluation
///////////////////////////////////////
@ -716,13 +715,13 @@ typedef void (*my_fnp_type)(char *);
/******************************* Header Files **********************************
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
seperate files.
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 separating them into
separate files.
Header files are syntaxtically similar to c source files but reside in ".h"
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
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
command #include "example.h", given that example.h exists in the same directory
as the c file.
*/
@ -758,7 +757,7 @@ enum traffic_light_state {GREEN, YELLOW, RED};
Node createLinkedList(int *vals, int len);
/* Beyond the above elements, other definitions should be left to a c source */
/* file. Excessive includeds or definitions should, also not be contained in */
/* file. Excessive includes or definitions should, also not be contained in */
/* a header file but instead put into separate headers or a c file. */
#endif /* End of the if precompiler directive. */
@ -780,4 +779,4 @@ Readable code is better than clever code and fast code. For a good, sane coding
Other than that, Google is your friend.
[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member

2
chapel.html.markdown
View File

@ -1066,7 +1066,7 @@ The more information you give the Chapel development team about issues you encou
Feel free to email the team and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
If you're really interested in the development of the compiler or contributing to the project,
[check out the master Github repository](https://github.com/chapel-lang/chapel).
[check out the master GitHub repository](https://github.com/chapel-lang/chapel).
It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).
Installing the Compiler

48
coldfusion.html.markdown
View File

@ -233,40 +233,38 @@ ColdFusion started as a tag-based language. Almost all functionality is availabl
<em>Code for reference (Functions must return something to support IE)</em>
<pre>
&lt;cfcomponent&gt;
&lt;cfset this.hello = "Hello" /&gt;
&lt;cfset this.world = "world" /&gt;
<cfcomponent>
<cfset this.hello = "Hello" />
<cfset this.world = "world" />
&lt;cffunction name="sayHello"&gt;
&lt;cfreturn this.hello & ", " & this.world & "!" /&gt;
&lt;/cffunction&gt;
<cffunction name="sayHello">
<cfreturn this.hello & ", " & this.world & "!" />
</cffunction>
&lt;cffunction name="setHello"&gt;
&lt;cfargument name="newHello" type="string" required="true" /&gt;
<cffunction name="setHello">
<cfargument name="newHello" type="string" required="true" />
&lt;cfset this.hello = arguments.newHello /&gt;
<cfset this.hello = arguments.newHello />
&lt;cfreturn true /&gt;
&lt;/cffunction&gt;
<cfreturn true />
</cffunction>
&lt;cffunction name="setWorld"&gt;
&lt;cfargument name="newWorld" type="string" required="true" /&gt;
<cffunction name="setWorld">
<cfargument name="newWorld" type="string" required="true" />
&lt;cfset this.world = arguments.newWorld /&gt;
<cfset this.world = arguments.newWorld />
&lt;cfreturn true /&gt;
&lt;/cffunction&gt;
<cfreturn true />
</cffunction>
&lt;cffunction name="getHello"&gt;
&lt;cfreturn this.hello /&gt;
&lt;/cffunction&gt;
<cffunction name="getHello">
<cfreturn this.hello />
</cffunction>
&lt;cffunction name="getWorld"&gt;
&lt;cfreturn this.world /&gt;
&lt;/cffunction&gt;
&lt;/cfcomponent&gt;
</pre>
<cffunction name="getWorld">
<cfreturn this.world />
</cffunction>
</cfcomponent>
<cfset this.hello = "Hello" />
<cfset this.world = "world" />

4
common-lisp.html.markdown
View File

@ -339,7 +339,7 @@ nil ; for false - and the empty list
;; The () in the above is the list of arguments for the function
(defun hello (name)
(format nil "Hello, ~a " name))
(format nil "Hello, ~a" name))
(hello "Steve") ; => "Hello, Steve"
@ -430,7 +430,7 @@ nil ; for false - and the empty list
(defun walker (n)
(if (zerop n)
:walked
(walker (1- n))))
(walker (- n 1))))
(walker 5) ; => :walked

87
cs-cz/brainfuck.html.markdown Normal file
View File

@ -0,0 +1,87 @@
---
language: brainfuck
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]
translators:
- ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
filename: learnbrainfuck-cz.bf
lang: cs-cz
---
Brainfuck (psaný bez kapitálek s vyjímkou začátku věty) je extrémně minimální
Turingovsky kompletní (ekvivalentní) programovací jazyk a má pouze 8 příkazů.
Můžete si ho vyzkoušet přímo v prohlížeči s [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
```
Jakýkoliv znak mimo "><+-.,[]" (bez uvozovek) je ignorován.
Brainfuck je reprezentován jako pole, které má 30.000 buněk s počátkem v nule
a datovým ukazatelem na aktuální buňce.
Můžeme využít těchto osm příkazů:
+ : Přičte k aktuální buňce jedničku.
- : Odečte od aktuální buňky jedničku.
> : Posune datový ukazatel na další buňku, která je napravo.
< : Posune datový ukazatel na předchozí buňku, která je nalevo.
. : Vytiskne ASCII hodnotu aktuální buňky (například 65 = 'A').
, : Načte jeden znak do aktuální buňky.
[ : Pokud je hodnota aktuální buňky nulová, přeskočí na buňku odpovídající ] .
Jinak skočí na další instrukci.
] : Pokud je hodnota aktuální buňky nulova, přeskočí na další instrukci.
Jinak skočí zpět na instrukci odpovídající [ .
[ a ] tak tvoří 'while' smyčku a tyto symboly musí tak být v páru.
Pojďme se mrknout na některé brainfuck programy.
++++++ [ > ++++++++++ < - ] > +++++ .
Tento program vypíše písmeno 'A' (v ASCII je to číslo 65). Nejdříve navýší
buňku #1 na hodnotu 6. Buňka #1 bude použita pro smyčku. Potom program vstoupí
do smyčky ([) a sníží hodnotu buňky #1 o jedničku. Ve smyčce zvýší hodnotu
buňky #2 desetkrát, vrátí ze zpět na buňku #1 a sníží její hodnotu o jedničku.
Toto se stane šestkrát (je potřeba šestkrát snížit hodnotu buňky #1, aby byla
nulová a program přeskočil na konec cyklu označený znakem ].
Na konci smyčky, kdy jsme na buňce #1 (která má hodnotu 0), tak má buňka #2
hodnotu 60. Přesuneme se na buňku #2 a pětkrát zvýšíme její hodnotu o jedničku
na hodnotu 65. Na konci vypíšeme hodnotu buňky #2 - 65, což je v ASCII znak 'A'
na terminálu.
, [ > + < - ] > .
Tento program přečte znak z uživatelského vstupu a zkopíruje ho do buňky #1.
Poté začne smyčka - přesun na buňku #2, zvýšení hodnoty buňky #2 o jedničku,
přesun zpět na buňku #1 a snížení její hodnoty o jedničku. Takto smyčka pokračuje
do té doby, než je buňka #1 nulová a buňka #2 nabyde původní hodnotu buňky #1.
Protože jsme na buňce #1, přesuneme se na buňku #2 a vytiskneme její hodnotu
v ASCII.
Je dobré vědět, že mezery jsou v programu uvedené pouze z důvodu čitelnosti.
Program je možné klidně zapsat i takto:
,[>+<-]>.
Nyní se podívejte na tento program a zkuste zjistit co dělá:
,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
Tento program vezme dvě čísla ze vstupu a vynásobí je.
Program nejdříve načte dvě vstupní hodnoty. Poté začíná smyčka řízená hodnotou
v buňce #1 - přesun na buňku #2 a start druhé vnořené smyčky, která je řízená
hodnotou v buňce #2 a zvyšuje hodnotu v buňce #3. Nicméně je zde problém
kdy na konci vnitřní smyčky je v buňce #2 nula a smyčka by tak znovu
napokračovala. Vyřešíme to tak, že zvyšujeme o jedničku i buňku #4 a její
hodnotu poté překopírujeme do buňky #2. Na konci programu je v buňce #3
výsledek.
```
A to je brainbuck. Zase tak složitý není, co? Zkuste si nyní napsat nějaký
vlastní brainfuck program a nebo interpretr v jiném jazyce, což není zase
tak složité, ale pokud jste opravdový masochista, zkuste si naprogramovat
interpretr jazyka brainfuck v jazyce... brainfuck :)

373
cs-cz/elm.html.markdown Normal file
View File

@ -0,0 +1,373 @@
---
language: Elm
contributors:
- ["Max Goldstein", "http://maxgoldste.in/"]
translators:
- ["Robin Pokorný", "http://robinpokorny.com/"]
filename: learnelm-cz.elm
lang: cs-cz
---
Elm je funkcionální reaktivní jazyk, který se kompiluje do (klientského) JavaScriptu.
Elm je silně typovaný, díky tomu je překladač schopen zachytit většinu chyb okamžitě a
vypsat snadno srozumitelná chybová hlášení.
Elm se hodí k tvorbě webových uživatelských rozhraní a her.
```haskell
-- Jednořádkové komentáře začínají dvěma pomlčkami.
{- Víceřádkové komentáře mohou být takto uzavřeny do bloku.
{- Mohou být i zanořeny. -}
-}
{-- Základy --}
-- Aritmetika
1 + 1 -- 2
8 - 1 -- 7
10 * 2 -- 20
-- Každé číslo bez desetinné tečky je typu Int nebo Float.
33 / 2 -- 16.5 s reálným dělením
33 // 2 -- 16 s celočíselným dělením
-- Umocňování
5 ^ 2 -- 25
-- Pravdivostní proměnné
not True -- False
not False -- True
1 == 1 -- True
1 /= 1 -- False
1 < 10 -- True
-- Řetězce a znaky
"Toto je textový řetězec, protože používá dvojité uvozovky."
'a' -- znak v jednoduchých uvozovkách
-- Řetězce lze spojovat.
"Ahoj " ++ "světe!" -- "Ahoj světe!"
{-- Seznamy (List), n-tice (Tuple) a Záznamy (Record) --}
-- Každá položka seznamu musí být stejného typu.
["příliš", "žluťoučký", "kůň", "úpěl"]
[1, 2, 3, 4, 5]
-- Druhý příklad lze zapsat také pomocí dvou teček.
[1..5]
-- Spojovat seznamy lze stejně jako řetězce.
[1..5] ++ [6..10] == [1..10] -- True
-- K přidání položky do seznamu použijte funkci "cons".
0 :: [1..5] -- [0, 1, 2, 3, 4, 5]
-- Funkce "head" pro získání první položky seznamu i funkce "tail" pro získání následujích položek
-- vrací typ Maybe. Místo zjišťování, jestli nějaká položka není null,
-- se s chybějcími hodnotami vypořádáme explicitně.
List.head [1..5] -- Just 1
List.tail [1..5] -- Just [2, 3, 4, 5]
List.head [] -- Nothing
-- List.nazevFunkce odkazuje na funkci, která žije v modulu List.
-- Každý prvek v n-tici může být jiného typu, ale n-tice má pevný počet prvků.
("elm", 42)
-- K získání hodnot z dvojice použijte funkce first a second.
-- (Toto je pouze zkratka. Brzy si ukážeme, jak na to "správně".)
fst ("elm", 42) -- "elm"
snd ("elm", 42) -- 42
-- Prázná n-tice, neboli "unit", se občas používá jako zástupný symbol.
-- Je to jediná hodnota svého typu, který se také nazývá "Unit".
()
-- Záznamy jsou podobné n-ticím, ale prvky jsou pojmenovány. Na pořadí nezáleží.
-- Povšimněte si, že hodnoty vlastností se přiřazují rovnítky, ne dvojtečkami.
{ x = 3, y = 7 }
-- K hodnotám se přistupuje pomocí tečky a názvu vlastnosti.
{ x = 3, y = 7 }.x -- 3
-- Nebo využitím přístupové funkce, což je jen tečka a název vlastnosti.
.y { x = 3, y = 7 } -- 7
-- Změna hodnoty vlastnosti v záznamu. (Záznam tuto vlastnost už musí mít.)
{ osoba |
jmeno = "Jiří" }
-- Změna více vlastností s využitím aktuálních hodnot.
{ hmotnyBod |
poloha = hmotnyBod.poloha + hmotnyBod.rychlost,
rychlost = hmotnyBod.rychlost + hmotnyBod.zrychleni }
{-- Řídicí struktury --}
-- Podmínky vždy musí mít větev "else" a obě větve musí být stejného typu.
if powerLevel > 9000 then
"PÁNI!"
else
"hmm"
-- Podmínky lze skládat za sebe.
if n < 0 then
"n je záporné"
else if n > 0 then
"n je kladné"
else
"n je nula"
-- Použíjte příkaz "case" k nalezení shody vzoru a různých možností.
case seznam of
[] -> "odpovídá práznému seznamu"
[x]-> "odpovídá seznamu o právě jedné položce, " ++ toString x
x::xs -> "odpovídá seznamu o alespoň jedné položce, jehož prvním prvkem je " ++ toString x
-- Shody se vyhodnocují v zapsaném pořadí. Kdybychom umístili [x] poslední, nikdy by nenastala shoda,
-- protože x::xs také odpovídá (xs by byl prázdný seznam). Shody "nepropadají".
-- Překladač vždy upozorní na chybějící nebo přebývající větve.
-- Větvení typu Maybe.
case List.head seznam of
Just x -> "První položka je " ++ toString x
Nothing -> "Seznam byl prázdný."
{-- Funkce --}
-- Syntaxe funkcí je v Elmu velmi úsporná, založená spíše na mezerách
-- než na závorkách. Neexistuje tu klíčové slovo "return".
-- Funkci definujeme jejím jménem, parametry, rovnítkem a tělem.
vynasob a b =
a * b
-- Funkci voláme předáním parametrů (bez oddělujících čárek).
vynasob 7 6 -- 42
-- Částečně aplikované funkci předáme pouze některé parametry.
-- Poté zvolíme nové jméno.
zdvoj =
vynasob 2
-- Konstanty jsou podobné, ale nepřijímají žádné parametry.
odpoved =
42
-- Předejte funkci jako parametr jiným funkcím.
List.map zdvoj [1..4] -- [2, 4, 6, 8]
-- Nebo použijte anonymní funkci.
List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8]
-- V definici funkce lze zapsat vzor, může-li nastat pouze jeden případ.
-- Tato funkce přijímá jednu dvojici místo dvou parametrů.
obsah (sirka, delka) =
sirka * delka
obsah (6, 7) -- 42
-- Složenými závorkami vytvořte vzor pro názvy vlastností v záznamu.
-- Použijte "let" k definici lokálních proměnných.
objem {sirka, delka, hloubka} =
let
obsah = sirka * delka
in
obsah * hloubka
objem { sirka = 3, delka = 2, hloubka = 7 } -- 42
-- Funkce mohou být rekurzivní.
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]
-- Jiná rekurzivní funkce (v praxi použijte List.length).
delkaSeznamu seznam =
case seznam of
[] -> 0
x::xs -> 1 + delkaSeznamu xs
-- Funkce se volají před jakýmkoli infixovým operátorem. Závorky určují prioritu.
cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
-- Nejprve se aplikuje "degrees" na číslo 30, výsledek je pak předán trigonometrickým
-- funkcím, které jsou následně umocněny na druhou, na závěr proběhne sčítání.
{-- Typy a typové anotace --}
-- Překladač odvodí typ každé hodnoty ve vašem programu.
-- Typy vždy začínají velkým písmenem. Čtete x : T jako "x je typu T".
-- Některé běžné typy, které můžete videt v Elmovém REPLu.
5 : Int
6.7 : Float
"ahoj" : String
True : Bool
-- Funkce mají také typy. Čtěte "->" jako "vrací".
-- O typu na konci uvažujte jako návratovém typu, o ostatních jako typech argumentů.
not : Bool -> Bool
round : Float -> Int
-- Když definujete hodnotu, je dobrým zvykem zapsat nad ni její typ.
-- Anotace je formou dokumentace, která je ověřována překladačem.
zdvoj : Int -> Int
zdvoj x = x * 2
-- Funkce jako parametr je uzavřena v závorkách.
-- Typy s malým počátečním písmenem jsou typové proměnné:
-- mohou být libovolného typu, ale v každém volání musí být stejné.
List.map : (a -> b) -> List a -> List b
-- "List tečka map je typu a-vrací-b, vrací seznam-položek-typu-a, vrací seznam-položek-typu-b."
-- Existují tři speciální typové proměnné:
-- číslo (number), porovnatelné (comparable), and spojitelné (appendable).
-- Čísla dovolují použít aritmetiku na Int a Float.
-- Porovnatelné dovolují uspořádat čísla a řetězce, např. a < b.
-- Spojitelné lze zřetězit pomocí a ++ b.
{-- Typové aliasy a výčtové typy --}
-- Pro záznamy a n-tice již typy automaticky existují.
-- (Povšimněte si, že typ vlatnosti záznamu přiřazujeme dvojtečkou a hodnotu rovnítkem.)
pocatek : { x : Float, y : Float, z : Float }
pocatek =
{ x = 0, y = 0, z = 0 }
-- Stávajícím typům lze dávat jména využitím aliasů.
type alias Bod3D =
{ x : Float, y : Float, z : Float }
-- Alias pro záznam funguje také jako jeho konstruktor.
jinyPocatek : Bod3D
jinyPocatek =
Bod3D 0 0 0
-- Jedná se stále o stejný typ, lze je tedy porovnat.
pocatek == jinyPocatek -- True
-- Oproti tomu výčtový (union) typ definuje zcela nový typ.
-- Výčtový typ se takto jmenuje, protože může být jedním z několika vybraných možností.
-- Každá možnost je reprezentována jako "tag".
type Smer =
Sever | Jih | Vychod | Zapad
-- Tagy mohou obsahovat další hodnoty známých typů. Lze využít i rekurze.
type IntStrom =
Vrchol | Uzel Int IntStrom IntStrom
-- "Vrchol" i "Uzel" jsou tagy. Vše, co následuje za tagem, je typ.
-- Tagy lze použít jako hodnoty funkcí.
koren : IntStrom
koren =
Vrchol 7 List List
-- Výčtové typy (a typové aliasy) mohou obsahovat typové proměnné.
type Strom a =
Vrchol | Uzel a (Strom a) (Strom a)
-- "Typ strom-prvků-a je vrchol, nebo uzel obsahující a, strom-prvků-a a strom-prvků-a."
-- Vzory se shodují s tagy. Tagy s velkým počátečním písmenem odpovídají přesně.
-- Proměnné malým písmem odpovídají čemukoli. Podtržítko také odpovídá čemukoli,
-- ale určuje, že tuto hodnotu dále nechceme používat.
nejviceVlevo : Strom a -> Maybe a
nejviceVlevo strom =
case strom of
Vrchol -> Nothing
Uzel x Vrchol _ -> Just x
Uzel _ podstrom _ -> nejviceVlevo podstrom
-- To je víceméně vše o jazyku samotném.
-- Podívejme se nyní, jak organizovat a spouštět náš kód.
{-- Moduly a importování --}
-- Standardní knihovny jsou organizovány do modulů, stejně jako knihovny třetích stran,
-- které můžete využívat. Ve větších projektech můžete definovat vlastní moduly.
-- Vložte toto na začátek souboru. Pokud nic neuvedete, předpokládá se "Main".
module Jmeno where
-- Výchozím chováním je, že se exportuje vše.
-- Případně můžete definovat exportované vlastnosti explicitně.
module Jmeno (MujTyp, mojeHodnota) where
-- Běžný návrhový vzor je expotovat pouze výčtový typ bez jeho tagů.
-- Tento vzor je znám jako krycí typ a často se využívá v knihovnách.
-- Z jiných modulů lze importovat kód a použít jej v aktuálním modulu.
-- Nasledující umístí Dict do aktuálního scope, takže lze volat Dict.insert.
import Dict
-- Importuje modul Dict a typ Dict, takže v anotacích není nutné psát Dict.Dict.
-- Stále lze volat Dict.insert.
import Dict exposing (Dict)
-- Přejmenování importu.
import Graphics.Collage as C
{-- Porty --}
-- Port oznamuje, že budete komunikovat s vnějším světem.
-- Porty jsou dovoleny pouze v modulu Main.
-- Příchozí port je jen typová anotace.
port idKlienta : Int
-- Odchozí port má definici.
port objednavkaKlienta : List String
port objednavkaKlienta = ["Knihy", "Potraviny", "Nábytek"]
-- Nebudeme zacházet do detailů, ale v JavaScriptu se dají nastavit
-- callbacky pro zasílání na příchozí porty a čtení z odchozích portů.
{-- Nástroje pro příkazovou řádku --}
-- Kompilace souboru.
$ elm make MujSoubor.elm
-- Při prvním spuštění nainstaluje Elm standardní knihovny a vytvoří soubor
-- elm-package.json, kde jsou uloženy informace o vašem projektu.
-- Elm reactor je server, který překládá a spouští vaše soubory.
-- Kliknutím na klíč vedle názvu souboru spustíte debugger s cestovám v čase!
$ elm reactor
-- Zkoušejte si jednoduché příkazy v Read-Eval-Print Loop.
$ elm repl
-- Balíčky jsou určeny uživatelským jménem na GitHubu a názvem repozitáře.
-- Nainstalujte nový balíček a uložte jej v souboru elm-package.json.
$ elm package install evancz/elm-html
-- Porovnejte změny mezi verzemi jednoho balíčku.
$ elm package diff evancz/elm-html 3.0.0 4.0.2
-- Správce balíčků v Elmu vyžaduje sémantické verzování,
-- takže minor verze nikdy nerozbije váš build.
```
Jazyk Elm je překvapivě malý. Nyní se můžete podívat do skoro jakéhokoli zdrojového kódu
v Elmu a budete mít zběžnou představu o jeho fungování.
Ovšem možnosti, jak psát kód, který je odolný vůči chybám a snadno se refaktoruje, jsou neomezené!
Zde jsou některé užitečné zdroje (v angličtině).
* [Hlavní stránka Elmu](http://elm-lang.org/). Obsahuje:
* Odkazy na [instalátory](http://elm-lang.org/install)
* [Documentaci](http://elm-lang.org/docs), včetně [popisu syntaxe](http://elm-lang.org/docs/syntax)
* Spoustu nápomocných [příkladů](http://elm-lang.org/examples)
* Documentace pro [standardní knihovny Elmu](http://package.elm-lang.org/packages/elm-lang/core/latest/). Povšimněte si:
* [Základy](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), které jsou automaticky importovány
* Typ [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) a jeho bratranec typ [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), které se běžně používají pro chybějící hodnoty a ošetření chyb.
* Datové struktury jako [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) a [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
* JSON [enkódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) a [dekódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode)
* [Architektura Elmu](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Esej od tvůrce Elmu s příklady, jak organizovat kód do komponent.
* [Elm mailing list](https://groups.google.com/forum/#!forum/elm-discuss). Všichni jsou přátelští a nápomocní.
* [Scope v Elmu](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) a [Jak číst typové anotace](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Další komunitní návody o základech Elmu, psáno pro JavaScriptové vývojáře.
Běžte si zkusit něco napsat v Elmu!

62
cs-cz/json.html.markdown Normal file
View File

@ -0,0 +1,62 @@
---
language: json
contributors:
- ["Anna Harren", "https://github.com/iirelu"]
- ["Marco Scannadinari", "https://github.com/marcoms"]
translators:
- ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
filename: learnjson-cz.json
lang: cs-cz
---
JSON je exterémně jednoduchý datově nezávislý formát a bude asi jeden z
nejjednodušších 'Learn X in Y Minutes' ze všech.
JSON nemá ve své nejzákladnější podobě žádné komentáře, ale většina parserů
umí pracovat s komentáři ve stylu jazyka C (`//`, `/* */`). Pro tyto účely
však budeme používat 100% validní JSON bez komentářů. Pojďme se podívat na
syntaxi formátu JSON:
```json
{
"klic": "value",
"hodnoty": "Musí být vždy uvozený v dvojitých uvozovkách",
"cisla": 0,
"retezce": "Hellø, wørld. Všechny unicode znaky jsou povolené, společně s \"escapováním\".",
"pravdivostni_hodnota": true,
"prazdna_hodnota": null,
"velke_cislo": 1.2e+100,
"objekt": {
"komentar": "Most of your structure will come from objects.",
"pole": [0, 1, 2, 3, "Pole nemusí být pouze homogenní.", 5],
"jiny_objekt": {
"comment": "Je povolené jakkoli hluboké zanoření."
}
},
"cokoli": [
{
"zdroje_drasliku": ["banány"]
},
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, "neo"],
[0, 0, 0, 1]
]
],
"alternativni_styl_zapisu": {
"komentar": "Mrkni se na toto!"
, "pozice_carky": "Na pozici čárky nezáleží - pokud je před hodnotou, ať už je kdekoli, tak je validní."
, "dalsi_komentar": "To je skvělé."
},
"to_bylo_rychle": "A tím jsme hotový. Nyní již víte vše, co může formát JSON nabídnout!"
}
```

14
cs-cz/markdown.html.markdown
View File

@ -1,10 +1,12 @@
---
language: markdown
lang: cs-cz
contributors:
- ["Dan Turkel", "http://danturkel.com/"]
translators:
- ["Michal Martinek", "https://github.com/MichalMartinek"]
filename: markdown.md
filename: markdown-cz.md
lang: cs-cz
---
Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce čitelná
@ -51,7 +53,7 @@ __Stejně jako tento.__
**_Jako tento!_**
*__A tento!__*
<!-- Ve verzi Markdownu od Githubu, máme k dispozici taky prošktrnutí: -->
<!-- Ve verzi Markdownu od GitHubu, máme k dispozici taky prošktrnutí: -->
~~Tento text je prošktrnutý.~~
@ -150,7 +152,7 @@ Tento box bude zašktrnutý
Jan nevědel, jak se dělá `go_to()` funkce!
<!-- V Markdownu od Githubu , můžete použít speciální syntaxi pro kód -->
<!-- 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
@ -158,7 +160,7 @@ def neco
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
<!-- Text výše nepotřebuje odsazení a navíc GitHub použije zvýraznění označeného
jazyka. -->
<!-- Horizontální čára (<hr />) -->
@ -230,13 +232,13 @@ Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a j
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 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ě,
<!-- Tabulky jsou povolené pouze v Markdownu od GitHubu a jsou trochu podivně,
ale když je opravdu chcete: -->
| Sloupec1 | Sloupec2 | Sloupec3 |

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

@ -7,7 +7,7 @@ contributors:
- ["Tomáš Bedřich", "http://tbedrich.cz"]
translators:
- ["Tomáš Bedřich", "http://tbedrich.cz"]
filename: learnpython3.py
filename: learnpython3-cz.py
lang: cs-cz
---

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ů

35
csharp.html.markdown
View File

@ -24,10 +24,12 @@ Multi-line comments look like this
/// This is an XML documentation comment which can be used to generate external
/// documentation or provide context help within an IDE
/// </summary>
//public void MethodOrClassOrOtherWithParsableHelp() {}
/// <param name="firstParam">This is some parameter documentation for firstParam</param>
/// <returns>Information on the returned value of a function</returns>
//public void MethodOrClassOrOtherWithParsableHelp(string firstParam) {}
// Specify the namespaces this source code will be using
// The namespaces below are all part of the standard .NET Framework Class Libary
// The namespaces below are all part of the standard .NET Framework Class Library
using System;
using System.Collections.Generic;
using System.Dynamic;
@ -421,7 +423,7 @@ on a new line! ""Wow!"", the masses cried";
// Item is an int
Console.WriteLine(item.ToString());
}
// YIELD
// Usage of the "yield" keyword indicates that the method it appears in is an Iterator
// (this means you can use it in a foreach loop)
@ -437,7 +439,7 @@ on a new line! ""Wow!"", the masses cried";
foreach (var counter in YieldCounter())
Console.WriteLine(counter);
}
// you can use more than one "yield return" in a method
public static IEnumerable<int> ManyYieldCounter()
{
@ -446,7 +448,7 @@ on a new line! ""Wow!"", the masses cried";
yield return 2;
yield return 3;
}
// you can also use "yield break" to stop the Iterator
// this method would only return half of the values from 0 to limit.
public static IEnumerable<int> YieldCounterWithBreak(int limit = 10)
@ -482,7 +484,7 @@ on a new line! ""Wow!"", the masses cried";
// ?? is syntactic sugar for specifying default value (coalesce)
// in case variable is null
int notNullable = nullable ?? 0; // 0
// ?. is an operator for null-propagation - a shorthand way of checking for null
nullable?.Print(); // Use the Print() extension method if nullable isn't null
@ -630,7 +632,7 @@ on a new line! ""Wow!"", the masses cried";
public static class Extensions
{
// EXTENSION FUNCTIONS
// EXTENSION METHODS
public static void Print(this object obj)
{
Console.WriteLine(obj.ToString());
@ -692,7 +694,10 @@ on a new line! ""Wow!"", the masses cried";
public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
// Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on
[Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc
// Any class derived from Attribute can be used to decorate types, methods, parameters etc
// Bitwise operators & and | can be used to perform and/or operations
[Flags]
public enum BikeAccessories
{
None = 0,
@ -879,8 +884,8 @@ on a new line! ""Wow!"", the masses cried";
bool Broken { get; } // interfaces can contain properties as well as methods & events
}
// Class can inherit only one other class, but can implement any amount of interfaces, however
// the base class name must be the first in the list and all interfaces follow
// Classes can inherit only one other class, but can implement any amount of interfaces,
// however the base class name must be the first in the list and all interfaces follow
class MountainBike : Bicycle, IJumpable, IBreakable
{
int damage = 0;
@ -913,17 +918,17 @@ on a new line! ""Wow!"", the masses cried";
public DbSet<Bicycle> Bikes { get; set; }
}
// Classes can be split across multiple .cs files
// A1.cs
public partial class A
public partial class A
{
public static void A1()
{
Console.WriteLine("Method A1 in class A");
}
}
// A2.cs
public partial class A
{
@ -932,9 +937,9 @@ on a new line! ""Wow!"", the masses cried";
Console.WriteLine("Method A2 in class A");
}
}
// Program using the partial class "A"
public class Program
public class Program
{
static void Main()
{

57
css.html.markdown
View File

@ -7,16 +7,23 @@ contributors:
- ["Connor Shea", "https://github.com/connorshea"]
- ["Deepanshu Utkarsh", "https://github.com/duci9y"]
- ["Tyler Mumford", "https://tylermumford.com"]
filename: learncss.css
---
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**.
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 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 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.
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 with CSS 2 in mind, which is extended by the new
features of CSS 3.
**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 to
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.
## Syntax
@ -66,7 +73,7 @@ div { }
[otherAttr~='foo'] { }
[otherAttr~='bar'] { }
/* or contains a value in a dash-separated list, ie, "-" (U+002D) */
/* or contains a value in a dash-separated list, e.g., "-" (U+002D) */
[otherAttr|='en'] { font-size:smaller; }
@ -113,7 +120,8 @@ selector:first-child {}
/* any element that is the last child of its parent */
selector:last-child {}
/* Just like pseudo classes, pseudo elements allow you to style certain parts of a document */
/* Just like pseudo classes, pseudo elements allow you to style certain parts of
a document */
/* matches a virtual first child of the selected element */
selector::before {}
@ -132,9 +140,9 @@ selector::after {}
#################### */
selector {
/* Units of length can be absolute or relative. */
/* Relative units */
width: 50%; /* percentage of parent element width */
font-size: 2em; /* multiples of element's original font-size */
@ -143,14 +151,14 @@ selector {
font-size: 2vh; /* or its height */
font-size: 2vmin; /* whichever of a vh or a vw is smaller */
font-size: 2vmax; /* or greater */
/* Absolute units */
width: 200px; /* pixels */
font-size: 20pt; /* points */
width: 5cm; /* centimeters */
min-width: 50mm; /* millimeters */
max-width: 5in; /* inches */
/* Colors */
color: #F6E; /* short hex format */
color: #FF66EE; /* long hex format */
@ -161,10 +169,10 @@ selector {
color: transparent; /* equivalent to setting the alpha to 0 */
color: hsl(0, 100%, 50%); /* as hsl percentages (CSS 3) */
color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
/* Images as backgrounds of elements */
background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
/* Fonts */
font-family: Arial;
/* if the font family name has a space, it must be quoted */
@ -195,7 +203,13 @@ Save a CSS stylesheet with the extension `.css`.
## 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. 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.
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 occurring later in the stylesheet overwrites a previous one
(which also means that if two different linked stylesheets contain rules for an
element and if the rules are of the same specificity, then order of linking
would take precedence and the sheet linked latest would govern styling) .
This process is called cascading, hence the name Cascading Style Sheets.
@ -224,18 +238,25 @@ and the following markup:
<p style='/*F*/ property:value;' class='class1 class2' attr='value' />
```
The precedence of style is as follows. Remember, the precedence is for each **property**, not for the entire block.
The precedence of style is as follows. Remember, the precedence is for each
**property**, not for the entire block.
* `E` has the highest precedence because of the keyword `!important`. It is recommended that you avoid its usage.
* `E` has the highest precedence because of the keyword `!important`. It is
recommended that you avoid its usage.
* `F` is next, because it is an inline style.
* `A` is next, because it is more "specific" than anything else. It has 3 specifiers: The name of the element `p`, its class `class1`, an attribute `attr='value'`.
* `C` is next, even though it has the same specificity as `B`. This is because it appears after `B`.
* `A` is next, because it is more "specific" than anything else. It has 3
specifiers: The name of the element `p`, its class `class1`, an attribute
`attr='value'`.
* `C` is next, even though it has the same specificity as `B`.
This is because it appears after `B`.
* `B` is next.
* `D` is the last one.
## Compatibility
Most of the features in CSS 2 (and many in CSS 3) are available across all browsers and devices. But it's always good practice to check before using a new feature.
Most of the features in CSS 2 (and many in CSS 3) are available across all
browsers and devices. But it's always good practice to check before using
a new feature.
## Resources

2
d.html.markdown
View File

@ -254,7 +254,7 @@ void main() {
// Use an index, access every array element by reference (because we're
// going to change each element) and just call parallel on the array!
foreach(i, ref elem; parallel(arr)) {
ref = sqrt(i + 1.0);
elem = sqrt(i + 1.0);
}
}
```

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

@ -92,12 +92,12 @@ echo "immer ausgeführt" || echo "Nur ausgeführt wenn der erste Befehl fehlschl
echo "immer ausgeführt" && echo "Nur ausgeführt wenn der erste Befehl Erfolg hat"
# Um && und || mit if statements zu verwenden, braucht man mehrfache Paare eckiger Klammern:
if [ $NAME == "Steve" ] && [ $Alter -eq 15 ]
if [ "$NAME" == "Steve" ] && [ "$Alter" -eq 15 ]
then
echo "Wird ausgeführt wenn $NAME gleich 'Steve' UND $Alter gleich 15."
fi
if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
then
echo "Wird ausgeführt wenn $NAME gleich 'Daniya' ODER $NAME gleich 'Zach'."
fi

250
de-de/d-de.html.markdown Normal file
View File

@ -0,0 +1,250 @@
---
language: D
filename: learnd-de.d
contributors:
- ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
translators:
- ["Dominik Süß", "www.thesuess.me"]
lang: de-de
---
```c
// Es war klar dass das kommt...
module hello;
import std.stdio;
// argumente sind optional
void main(string[] args) {
writeln("Hello, World!");
}
```
Wenn du so wie ich bist und viel zeit im Internet verbringst stehen die Chancen gut
das du schonmal über [D](http://dlang.org/) gehört hast.
Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von Low bis
High Level verwendet werden kann und dabei viele Stile anbietet.
D wird aktiv von Walter Bright und Andrei Alexandrescu entwickelt, zwei super schlaue,
richtig coole leute. Da das jetzt alles aus dem weg ist - auf zu den Beispielen!
```c
import std.stdio;
void main() {
// Logische Ausdrücke und Schleifen funktionieren wie erwartet
for(int i = 0; i < 10000; i++) {
writeln(i);
}
auto n = 1; // auto um den typ vom Compiler bestimmen zu lassen
// Zahlenliterale können _ verwenden für lesbarkeit
while(n < 10_000) {
n += n;
}
do {
n -= (n / 2);
} while(n > 0);
// For und while sind ja schön und gut aber D bevorzugt foreach
// .. erstellt eine spanne von zahlen, exklusive dem Ende
foreach(i; 1..1_000_000) {
if(n % 2 == 0)
writeln(i);
}
foreach_reverse(i; 1..int.max) {
if(n % 2 == 1) {
writeln(i);
} else {
writeln("No!");
}
}
}
```
Neue Typen können mit `struct`, `class`, `union`, und `enum` definiert werden. Structs und unions
werden as-value (koppiert) an methoden übergeben wogegen Klassen als Referenz übergeben werden.
Templates können verwendet werden um alle typen zu parameterisieren.
```c
// Hier, T ist ein Type-Parameter, Er funktioniert wie Generics in C#/Java/C++
struct LinkedList(T) {
T data = null;
LinkedList!(T)* next; // Das ! wird verwendet um T zu übergeben. (<T> in C#/Java/C++)
}
class BinTree(T) {
T data = null;
// Wenn es nur einen T parameter gibt können die Klammern um ihn weggelassen werden
BinTree!T left;
BinTree!T right;
}
enum Day {
Sunday,
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
}
// Aliase können verwendet werden um die Entwicklung zu erleichtern
alias IntList = LinkedList!int;
alias NumTree = BinTree!double;
// Funktionen können genau so Templates beinhalten
T max(T)(T a, T b) {
if(a < b)
return b;
return a;
}
// Steht ref vor einem Parameter wird sichergestellt das er als Referenz übergeben wird.
// Selbst bei werten wird es immer eine Referenz sein.
void swap(T)(ref T a, ref T b) {
auto temp = a;
a = b;
b = temp;
}
// Templates können ebenso werte parameterisieren.
class Matrix(uint m, uint n, T = int) {
T[m] rows;
T[n] columns;
}
auto mat = new Matrix!(3, 3); // Standardmäßig ist T vom typ Integer
```
Wo wir schon bei Klassen sind - Wie wäre es mit Properties! Eine Property
ist eine Funktion die wie ein Wert agiert. Das gibt uns viel klarere Syntax
im Stil von `structure.x = 7` was gleichgültig wäre zu `structure.setX(7)`
```c
// Diese Klasse ist parameterisiert mit T, U
class MyClass(T, U) {
T _data;
U _other;
}
// Ihre Getter und Setter Methoden sehen so aus
class MyClass(T, U) {
T _data;
U _other;
// Konstruktoren heißen immer `this`
this(T t, U u) {
data = t;
other = u;
}
// getters
@property T data() {
return _data;
}
@property U other() {
return _other;
}
// setters
// @property kann genauso gut am ende der Methodensignatur stehen
void data(T t) @property {
_data = t;
}
void other(U u) @property {
_other = u;
}
}
// Und so kann man sie dann verwenden
void main() {
auto mc = MyClass!(int, string);
mc.data = 7;
mc.other = "seven";
writeln(mc.data);
writeln(mc.other);
}
```
Mit properties können wir sehr viel logik hinter unseren gettern
und settern hinter einer schönen syntax verstecken
Other object-oriented goodies at our disposal
Andere Objektorientierte features sind beispielsweise
`interface`s, `abstract class` und `override`.
Vererbung funktioniert in D wie in Java:
Erben von einer Klasse, so viele interfaces wie man will.
Jetzt haben wir Objektorientierung in D gesehen aber schauen
wir uns noch was anderes an.
D bietet funktionale programmierung mit _first-class functions_
puren funktionen und unveränderbare daten.
Zusätzlich können viele funktionale Algorithmen wie z.B
map, filter, reduce und friends im `std.algorithm` Modul gefunden werden!
```c
import std.algorithm : map, filter, reduce;
import std.range : iota; // builds an end-exclusive range
void main() {
// Wir wollen die summe aller quadratzahlen zwischen
// 1 und 100 ausgeben. Nichts leichter als das!
// Einfach eine lambda funktion als template parameter übergeben
// Es ist genau so gut möglich eine normale funktion hier zu übergeben
// Lambdas bieten sich hier aber an.
auto num = iota(1, 101).filter!(x => x % 2 == 0)
.map!(y => y ^^ 2)
.reduce!((a, b) => a + b);
writeln(num);
}
```
Ist dir aufgefallen wie wir eine Haskell-Style pipeline gebaut haben
um num zu berechnen?
Das war möglich durch die Uniform Function Call Syntax.
Mit UFCS können wir auswählen ob wir eine Funktion als Methode oder
als freie Funktion aufrufen. Walters artikel dazu findet ihr
[hier.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
Kurzgesagt kann man Funktionen deren erster parameter vom typ A ist, als
Methode auf A anwenden.
Parrallel Computing ist eine Tolle sache, findest du nicht auch?
```c
import std.stdio;
import std.parallelism : parallel;
import std.math : sqrt;
void main() {
// Wir wollen die Wurzel von jeder Zahl in unserem Array berechnen
// und dabei alle Kerne verwenden die wir zur verfügung haben
auto arr = new double[1_000_000];
// Wir verwenden den index und das element als referenz
// und rufen einfach parallel auf!
foreach(i, ref elem; parallel(arr)) {
ref = sqrt(i + 1.0);
}
}
```

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

@ -33,6 +33,7 @@ Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichn
* Ist offline einsetzbar.
* Einfache Kollaboration!
* Branching ist einfach!
* Branching ist schnell!
* Merging ist einfach!
* Git ist schnell.
* Git ist flexibel.
@ -53,11 +54,11 @@ Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und meh
### Arbeitsverzeichnis (Teil des Repositorys)
Dies sind die Verzeichnisse und Dateien in deinem Repository.
Dies sind die Verzeichnisse und Dateien in deinem Repository, also z.B. dein Programmcode.
### Index (Teil des .git-Verzeichnisses)
Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
Der Index ist die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
### Commit
@ -84,7 +85,7 @@ Ein *head* ist ein Pointer, der auf einen beliebigen Commit zeigt. Ein Reposito
### init
Erstelle ein leeres Git-Repository. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
Erstelle ein leeres Git-Repository im aktuellen Verzeichnis. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
```bash
$ git init
@ -180,6 +181,8 @@ Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angeg
```bash
# Ein Repo auschecken - wenn nicht anders angegeben ist das der master
$ git checkout
# Eine Datei auschecken - sie befindet sich dann auf dem aktuellen Stand im Repository
$ git checkout /path/to/file
# Einen bestimmten Branch auschecken
$ git checkout branchName
# Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch <name>; git checkout <name>"
@ -217,6 +220,9 @@ $ git diff --cached
# Unterschiede zwischen deinem Arbeitsverzeichnis und dem aktuellsten Commit anzeigen
$ git diff HEAD
# Unterschiede zwischen dem Index und dem aktuellsten Commit (betrifft nur Dateien im Index)
$ git diff --staged
```
### grep
@ -374,3 +380,5 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
* [gitflow - Ein Modell um mit Branches zu arbeiten](http://nvie.com/posts/a-successful-git-branching-model/)

51
de-de/go-de.html.markdown
View File

@ -4,17 +4,17 @@ filename: learngo-de.go
contributors:
- ["Joseph Adams", "https://github.com/jcla1"]
- ["Dennis Keller", "https://github.com/denniskeller"]
translators:
- ["Jerome Meinke", "https://github.com/jmeinke"]
lang: de-de
---
Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in
der Informatik, aber sie ist einer der neuesten und schnellsten Wege, um Aufgabe in
der realen Welt zu lösen.
Sie hat vertraute Elemente von imperativen Sprachen mit statischer Typisierung
und kann schnell kompiliert und ausgeführt werden. Verbunden mit leicht zu
verstehenden Parallelitäts-Konstrukten, um die heute üblichen mehrkern
Prozessoren optimal nutzen zu können, eignet sich Go äußerst gut für große
Programmierprojekte.
Die Sprache Go (auch golang) wurde von Google entwickelt und wird seit 2007
benutzt. Go ähnelt in der Syntax der Sprache C, bietet darüber hinaus aber viele
Vorteile. Einerseits verzichtet Gp auf Speicherarithmetik und
benutzt einen Garbabe Collector. Andererseits enthält Go native Sprachelemente
für die Unterstützung von Nebenläufigkeit. Durch den Fokus auf einen schnellen
Kompilierprozess wird außerdem die Softwareentwicklung in Großprojekten
erleichtert.
Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine
aktive Community.
@ -24,7 +24,7 @@ aktive Community.
/* Mehr-
zeiliger Kommentar */
// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
// Wie bei Java gehört jede Quelldatei einem Paket an (Modularisierung).
// "main" ist ein besonderer Paketname, da er ein ausführbares Programm
// einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek
// deklariert.
@ -40,7 +40,7 @@ import (
// Es folgt die Definition einer Funktion, in diesem Fall von "main". Auch hier
// ist der Name wieder besonders. "main" markiert den Eintrittspunkt des
// Programms. Vergessen Sie nicht die geschweiften Klammern!
// Programms.
func main() {
// Println gibt eine Zeile zu stdout aus.
// Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt.
@ -50,8 +50,8 @@ func main() {
beyondHello()
}
// Funktionen können Parameter akzeptieren, diese werden in Klammern deklariert,
// die aber auch bei keinen Parametern erforderlich sind.
// Funktionen können Parameter akzeptieren. Diese werden in Klammern deklariert,
// die aber auch ohne Parameter erforderlich sind.
func beyondHello() {
var x int // Deklaration einer Variable, muss vor Gebrauch geschehen.
x = 3 // Zuweisung eines Werts.
@ -99,7 +99,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
// "slices" haben eine dynamische Größe. Arrays und Slices haben beide ihre
// Vorzüge, aber slices werden viel häufiger verwendet
s3 := []int{4, 5, 9} // Vergleichen Sie mit a3, hier: keine Ellipse
s4 := make([]int, 4) // Weist Speicher für 4 ints zu, alle mit Initialwert 0
s4 := make([]int, 4) // Weist Speicher für 4 ints zu, alle mit Wert 0
var d2 [][]float64 // Nur eine Deklaration, keine Speicherzuweisung
bs := []byte("eine slice") // Umwandlungs-Syntax
@ -201,7 +201,8 @@ type pair struct {
x, y int
}
// Definiere eine Methode von "pair". Dieser Typ erfüllt jetzt das Stringer interface.
// Definiere eine Methode von "pair".
// Dieser Typ erfüllt jetzt das Stringer interface.
func (p pair) String() string { // p ist der Empfänger
// Sprintf ist eine weitere öffentliche Funktion von fmt.
// Der Syntax mit Punkt greift auf die Felder zu.
@ -255,8 +256,9 @@ func learnConcurrency() {
// Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für
// maps, slices und Kanäle.
c := make(chan int)
// Starte drei parallele "Goroutines". Die Zahlen werden parallel (concurrently)
// erhöht. Alle drei senden ihr Ergebnis in den gleichen Kanal.
// Starte drei parallele "Goroutines".
// Die Zahlen werden parallel (concurrently) erhöht.
// Alle drei senden ihr Ergebnis in den gleichen Kanal.
go inc(0, c) // "go" ist das Statement zum Start einer neuen Goroutine
go inc(10, c)
go inc(-805, c)
@ -306,14 +308,13 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
```
## Weitere Resourcen
Alles zu Go finden Sie auf der [offiziellen Go Webseite](http://golang.org/).
Dort können sie dem Tutorial folgen, interaktiv Quelltext ausprobieren und viel
Dokumentation lesen.
Informationen zu Go findet man auf der [offiziellen Go Webseite](http://golang.org/).
Dort gibt es unter anderem ein Tutorial und interaktive Quelltext-Beispiele, vor
allem aber Dokumentation zur Sprache und den Paketen.
Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/).
Gut dokumentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
kurz und gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/)
einzusehen. Dieser kann als Referenz für leicht zu verstehendes und im idiomatischen Stil
verfasstes Go dienen. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).

322
de-de/hack-de.html.markdown Normal file
View File

@ -0,0 +1,322 @@
---
language: Hack
lang: de-de
contributors:
- ["Stephen Holdaway", "https://github.com/stecman"]
- ["David Lima", "https://github.com/davelima"]
translators:
- ["Jerome Meinke", "https://github.com/jmeinke"]
filename: learnhack-de.hh
---
Hack ist eine von Facebook neu entwickelte Programmiersprache auf Basis von PHP.
Sie wird von der HipHop Virtual Machine (HHVM) ausgeführt. Die HHVM kann
aufgrund der Ähnlichkeit der Programmiersprachen nicht nur Hack, sondern auch
PHP-Code ausführen. Der wesentliche Unterschied zu PHP besteht in der statischen
Typisierung der Sprache, die eine wesentlich höhere Performance erlaubt.
Hier werden nur Hack-spezifische Eigenschaften beschrieben. Details über PHP's
Syntax findet man im [PHP Artikel](http://learnxinyminutes.com/docs/php/) dieser
Seite.
```php
<?hh
// Hack-Syntax ist nur für Dateien aktiv, die mit dem <?hh Prefix starten.
// Der <?hh Prefix kann nicht wie <?php mit HTML gemischt werden.
// Benutzung von "<?hh //strict" aktiviert den Strikt-Modus des Type-Checkers.
// Typisierung für Funktions-Argumente
function repeat(string $word, int $count)
{
$word = trim($word);
return str_repeat($word . ' ', $count);
}
// Typisierung für Rückgabewerte
function add(...$numbers) : int
{
return array_sum($numbers);
}
// Funktionen ohne Rückgabewert, werden mit "void" typisiert
function truncate(resource $handle) : void
{
// ...
}
// Typisierung unterstützt die explizit optionale Ein- / Ausgabe von "null"
function identity(?string $stringOrNull) : ?string
{
return $stringOrNull;
}
// Typisierung von Klassen-Eigenschaften
class TypeHintedProperties
{
public ?string $name;
protected int $id;
private float $score = 100.0;
// Hack erfordert es, dass typisierte Eigenschaften (also "non-null")
// einen Default-Wert haben oder im Konstruktor initialisiert werden.
public function __construct(int $id)
{
$this->id = $id;
}
}
// Kurzgefasste anonyme Funktionen (lambdas)
$multiplier = 5;
array_map($y ==> $y * $multiplier, [1, 2, 3]);
// Weitere, spezielle Felder (Generics)
// Diese kann man sich als ein zugreifbares Interface vorstellen
class Box<T>
{
protected T $data;
public function __construct(T $data) {
$this->data = $data;
}
public function getData(): T {
return $this->data;
}
}
function openBox(Box<int> $box) : int
{
return $box->getData();
}
// Formen
//
// Hack fügt das Konzept von Formen hinzu, wie struct-ähnliche arrays
// mit einer typ-geprüften Menge von Schlüsseln
type Point2D = shape('x' => int, 'y' => int);
function distance(Point2D $a, Point2D $b) : float
{
return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
}
distance(
shape('x' => -1, 'y' => 5),
shape('x' => 2, 'y' => 50)
);
// Typen-Definition bzw. Aliasing
//
// Hack erlaubt es Typen zu definieren und sorgt somit für bessere Lesbarkeit
newtype VectorArray = array<int, Vector<int>>;
// Ein Tupel mit zwei Integern
newtype Point = (int, int);
function addPoints(Point $p1, Point $p2) : Point
{
return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
}
addPoints(
tuple(1, 2),
tuple(5, 6)
);
// Erstklassige Aufzählungen (enums)
enum RoadType : int
{
Road = 0;
Street = 1;
Avenue = 2;
Boulevard = 3;
}
function getRoadType() : RoadType
{
return RoadType::Avenue;
}
// Automatische Erstellung von Klassen-Eigenschaften durch Konstruktor-Argumente
//
// Wiederkehrende Definitionen von Klassen-Eigenschaften können durch die Hack-
// Syntax vermieden werden. Hack erlaubt es die Klassen-Eigenschaften über
// Argumente des Konstruktors zu definieren.
class ArgumentPromotion
{
public function __construct(public string $name,
protected int $age,
private bool $isAwesome) {}
}
class WithoutArgumentPromotion
{
public string $name;
protected int $age;
private bool $isAwesome;
public function __construct(string $name, int $age, bool $isAwesome)
{
$this->name = $name;
$this->age = $age;
$this->isAwesome = $isAwesome;
}
}
// Kooperatives Multitasking
//
// Die Schlüsselworte "async" and "await" führen Multitasking ein.
// Achtung, hier werden keine Threads benutzt, sondern nur Aktivität getauscht.
async function cooperativePrint(int $start, int $end) : Awaitable<void>
{
for ($i = $start; $i <= $end; $i++) {
echo "$i ";
// Geben anderen Tasks die Möglichkeit aktiv zu werden
await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
}
}
// Die Ausgabe von folgendem Code ist "1 4 7 2 5 8 3 6 9"
AwaitAllWaitHandle::fromArray([
cooperativePrint(1, 3),
cooperativePrint(4, 6),
cooperativePrint(7, 9)
])->getWaitHandle()->join();
// Attribute
//
// Attribute repräsentieren eine Form von Metadaten für Funktionen.
// Hack bietet Spezial-Attribute, die nützliche Eigenschaften mit sich bringen.
// Das __Memoize Attribut erlaubt es die Ausgabe einer Funktion zu cachen.
<<__Memoize>>
function doExpensiveTask() : ?string
{
return file_get_contents('http://example.com');
}
// Der Funktionsrumpf wird im Folgenden nur ein einziges mal ausgeführt:
doExpensiveTask();
doExpensiveTask();
// Das __ConsistentConstruct Attribut signalisiert dem type-checker, dass
// die Funktionsdeklaration von __construct für alle Unterklassen dieselbe ist.
<<__ConsistentConstruct>>
class ConsistentFoo
{
public function __construct(int $x, float $y)
{
// ...
}
public function someMethod()
{
// ...
}
}
class ConsistentBar extends ConsistentFoo
{
public function __construct(int $x, float $y)
{
// Der Type-checker erzwingt den Aufruf des Eltern-Klassen-Konstruktors
parent::__construct($x, $y);
// ...
}
// Das __Override Attribut ist ein optionales Signal an den Type-Checker,
// das erzwingt, dass die annotierte Methode die Methode der Eltern-Klasse
// oder des Traits verändert.
<<__Override>>
public function someMethod()
{
// ...
}
}
class InvalidFooSubclass extends ConsistentFoo
{
// Wenn der Konstruktor der Eltern-Klasse nicht übernommen wird,
// wird der Type-Checker einen Fehler ausgeben:
//
// "This object is of type ConsistentBaz. It is incompatible with this object
// of type ConsistentFoo because some of their methods are incompatible"
//
public function __construct(float $x)
{
// ...
}
// Auch bei der Benutzung des __Override Attributs für eine nicht veränderte
// Methode wird vom Type-Checker eine Fehler ausgegeben:
//
// "InvalidFooSubclass::otherMethod() is marked as override; no non-private
// parent definition found or overridden parent is defined in non-<?hh code"
//
<<__Override>>
public function otherMethod()
{
// ...
}
}
// Ein Trait ist ein Begriff aus der objektorientierten Programmierung und
// beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen,
// ähnlich einer Klasse.
// Anders als in PHP können Traits auch als Schnittstellen (Interfaces)
// implementiert werden und selbst Schnittstellen implementieren.
interface KittenInterface
{
public function play() : void;
}
trait CatTrait implements KittenInterface
{
public function play() : void
{
// ...
}
}
class Samuel
{
use CatTrait;
}
$cat = new Samuel();
$cat instanceof KittenInterface === true; // True
```
## Weitere Informationen
Die Hack [Programmiersprachen-Referenz](http://docs.hhvm.com/manual/de/hacklangref.php)
erklärt die neuen Eigenschaften der Sprache detailliert auf Englisch. Für
allgemeine Informationen kann man auch die offizielle Webseite [hacklang.org](http://hacklang.org/)
besuchen.
Die offizielle Webseite [hhvm.com](http://hhvm.com/) bietet Infos zum Download
und zur Installation der HHVM.
Hack's [nicht-untersützte PHP Syntax-Elemente](http://docs.hhvm.com/manual/en/hack.unsupported.php)
werden im offiziellen Handbuch beschrieben.

156
de-de/haml-de.html.markdown Normal file
View File

@ -0,0 +1,156 @@
---
language: haml
filename: learnhaml-de.haml
contributors:
- ["Simon Neveu", "https://github.com/sneveu"]
- ["Sol Bekic", "https://github.com/S0lll0s"]
lang: de-de
---
Haml ist eine Markup- und Templatingsprache, aufgesetzt auf Ruby, mit der HTML Dokumente einfach beschrieben werden können.
Haml vermindert Wiederholung und Fehleranfälligkeit, indem es Tags basierend auf der Markup-Struktur schließt und schachtelt.
Dadurch ergibt sich kurzes, präzises und logisches Markup.
Haml kann außerhalb eines Ruby-projekts verwendet werden. Mit dem installierten Haml gem kann man das Terminal benutzen um Haml zu HTML umzuwandeln:
$ haml input_file.haml output_file.html
```haml
/ -------------------------------------------
/ Einrückung
/ -------------------------------------------
/
Einrückung ist ein wichtiges Element des Haml Syntax, deswegen ist es
wichtig ein konsequentes Schema zu verwenden. Meistens werden zwei spaces
verwendet, solange die Einrückungen das gleiche Schema verfolgen können
aber auch andere Breiten und Tabs verwendet werden
/ -------------------------------------------
/ Kommentare
/ -------------------------------------------
/ Kommentare beginnen mit einem Slash
/
Mehrzeilige Kommentare werden eingerückt und mit einem Slash
eingeführt
-# Diese Zeile ist ein "stummes" Kommentar, es wird nicht mitgerendert
/ -------------------------------------------
/ HTML Elemente
/ -------------------------------------------
/ Tags werden durch ein Prozentzeichen und den Tagnamen erzeugt
%body
%header
%nav
/ Die Zeilen oben würden folgendes ergeben:
<body>
<header>
<nav></nav>
</header>
</body>
/ Text kann direkt nach dem Tagnamen eingefügt werden:
%h1 Headline copy
/ Mehrzeilige Inhalte müssen stattdessen eingerückt werden:
%p
This is a lot of content that we could probably split onto two
separate lines.
/
HTML kann mit &= escaped werden. So werden HTML-sensitive Zeichen
enkodiert. Zum Beispiel:
%p
&= "Ja & Nein"
/ würde 'Ja &amp; Nein' ergeben
/ HTML kann mit != dekodiert werden:
%p
!= "so schreibt man ein Paragraph-Tag: <p></p>"
/ ...was 'This is how you write a paragraph tag <p></p>' ergeben würde
/ CSS Klassen können mit '.classname' an Tags angehängt werden:
%div.foo.bar
/ oder über einen Ruby Hash:
%div{:class => 'foo bar'}
/ Das div Tag wird standardmäßig verwendet, divs können also verkürzt werden:
.foo
/ andere Attribute können über den Hash angegeben werden:
%a{:href => '#', :class => 'bar', :title => 'Bar'}
/ Booleesche Attribute können mit 'true' gesetzt werden:
%input{:selected => true}
/ data-Attribute können in einem eigenen Hash im :data key angegeben werden:
%div{:data => {:attribute => 'foo'}}
/ -------------------------------------------
/ Verwendung von Ruby
/ -------------------------------------------
/ Mit dem = Zeichen können Ruby-werte evaluiert und als Tag-text verwendet werden:
%h1= book.name
%p
= book.author
= book.publisher
/ Code nach einem Bindestrich wird ausgeführt aber nicht gerendert:
- books = ['book 1', 'book 2', 'book 3']
/ So können zum Beispiel auch Blöcke verwendet werden:
- books.shuffle.each_with_index do |book, index|
%h1= book
if book do
%p This is a book
/
Auch hier werden wieder keine End-Tags benötigt!
Diese ergeben sich aus der Einrückung.
/ -------------------------------------------
/ Inline Ruby / Ruby Interpolation
/ -------------------------------------------
/ Ruby variablen können mit #{} in Text interpoliert werden:
%p dein bestes Spiel ist #{best_game}
/ -------------------------------------------
/ Filter
/ -------------------------------------------
/
Mit dem Doppelpinkt können Haml Filter benutzt werden.
Zum Beispiel gibt es den :javascript Filter, mit dem inline JS
geschrieben werden kann:
:javascript
console.log('Dies ist ein <script>');
```
## Weitere Resourcen
- [What is HAML?](http://haml.info/) - Eine gute Einleitung auf der Haml homepage (englisch)
- [Official Docs](http://haml.info/docs/yardoc/file.REFERENCE.html) - Die offizielle Haml Referenz (englisch)

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

@ -100,7 +100,7 @@ not False -- True
[1..] !! 999 -- 1000
-- Haskell evaluiert nun die ersten 1 - 1000 Elemente, aber der Rest der Liste
-- bleibt unangetastet. Haskell wird sie solange nicht weiterevalieren
-- bleibt unangetastet. Haskell wird sie solange nicht weiterevaluieren
-- bis es muss.
-- Zwei Listen konkatenieren
@ -115,7 +115,7 @@ tail [1..5] -- [2, 3, 4, 5]
init [1..5] -- [1, 2, 3, 4]
last [1..5] -- 5
-- list comprehensions | Listen erschaffen
-- Listen erschaffen ("list comprehensions")
[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
-- Mit Bedingungen
@ -179,7 +179,7 @@ myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
-- Fold (`inject` in einigen Sprachen)
-- Foldl1 bedeutet: fold von links nach rechts und nehme den ersten
-- Wert der Liste als Basiswert f[r den Akkumulator.
-- Wert der Liste als Basiswert für den Akkumulator.
foldl1 (\acc x -> acc + x) [1..5] -- 15
----------------------------------------------------
@ -201,7 +201,7 @@ foo 5 -- 15
-- Funktionskomposition
-- 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 4.
foo = (*4) . (+10)
@ -212,7 +212,7 @@ foo 5 -- 60
-- Haskell hat einen Operator `$`, welcher Funktionsapplikation durchführt.
-- Im Gegenzug zu der Standard-Funktionsapplikation, welche linksassoziativ ist
-- und die höchstmögliche Priorität von "10" hat, ist der `$`-Operator
-- rechtsassoziativ und hat die Priorität 0. Dieses hat (idr.) den Effekt,
-- rechtsassoziativ und hat die Priorität 0. Dieses hat (i.d.R.) 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.
@ -283,7 +283,7 @@ for [0..5] $ \i -> show i
for [0..5] show
-- foldl oder foldr reduziren Listen auf einen Wert.
-- foldl <fn> <initial value> <list>
-- foldl <Funktion> <initialer Wert> <Liste>
foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
-- die Abarbeitung sieht so aus:
@ -435,7 +435,7 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
```
Haskell ist sehr einfach zu installieren.
Hohl es dir von [hier](http://www.haskell.org/platform/).
Hol es dir von [hier](http://www.haskell.org/platform/).
Eine sehr viele langsamere Einführung findest du unter:
[Learn you a Haskell](http://learnyouahaskell.com/) oder

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

@ -6,19 +6,19 @@ contributors:
- ["Sricharan Chiruvolu", "http://sricharan.xyz"]
translators:
- ["Moritz Kammerer", "https://github.com/phxql"]
- ["Jerome Meinke", "https://github.com/jmeinke"]
lang: de-de
filename: latex-de.tex
---
```
% Alle Kommentare starten fangen mit % an
% Es gibt keine Kommentare über mehrere Zeilen
% Alle Kommentare starten mit einem Prozentzeichen %
% 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
% 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.
% Optionen des Dokuments stehen zwischen den eckigen Klammern []. In diesem Fall
% 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.
% 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.
\usepackage{caption}
\usepackage{float}
@ -34,30 +34,41 @@ filename: latex-de.tex
% Mit diesem Paket können leichter Umlaute getippt werden
\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!
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
\date{\today}
\title{Learn LaTeX in Y Minutes!}
\title{Learn \LaTeX\ in Y Minutes!}
% Nun kann's losgehen mit unserem Dokument.
% 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
% LateX für uns eine Titelseite generieren
% LaTeX für uns eine Titelseite generieren
\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
% Inhalt erscheinen.
% Dieser Befehl ist in den Dokumentenklassen article und report verfügbar.
\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}
% Section Befehle sind intuitiv.
% Alle Titel der sections werden automatisch in das Inhaltsverzeichnis übernommen.
\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}
Das hier ist der Text für noch eine section. Ich glaube, wir brauchen eine subsection.
@ -71,16 +82,16 @@ So ist's schon viel besser.
% Wenn wir den Stern nach section schreiben, dann unterdrückt LateX die Nummerierung.
% Das funktioniert auch bei anderen Befehlen.
\section*{Das ist eine unnummerierte section}
Es müssen nicht alle sections nummeriert sein!
\section*{Das ist eine unnummerierte section}
Es müssen nicht alle Sections nummeriert sein!
\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
\textbackslash\textbackslash in den Code ein.\\
\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:
\begin{enumerate} % Dieser Befehl erstellt eine "enumerate" Umgebung.
% \item bringt enumerate dazu, eins weiterzuzählen.
@ -96,7 +107,7 @@ also lass uns eine Einkaufsliste schreiben:
\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
anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle
Symbole zu unserem Paper hinzuzufügen! \\
@ -106,18 +117,18 @@ Symbole für Mengen und relationen, Pfeile, Operatoren und Griechische Buchstabe
um nur ein paar zu nennen.\\
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
% 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.
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:
Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$),
Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$),
Logarithmus und Exponenten ($\log$, $\exp$),
Grenzwerte ($\lim$), etc. haben vordefinierte Befehle.
Lass uns eine Gleichung schreiben: \\
@ -127,7 +138,7 @@ $\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$\\
Brüche (Zähler / Nenner) können so geschrieben werden:
% 10 / 7
$^{10}/_{7}$
$^{10}/_{7}$
% Komplexere Brüche können so geschrieben werden:
% \frac{Zähler}{Nenner}
@ -142,19 +153,19 @@ Wir können Gleichungen auch in einer equation Umgebung verwenden.
\end{equation} % Alle \begin Befehle müssen einen \end Befehl besitzen
Wir können nun unsere Gleichung referenzieren!
Gleichung ~\ref{eq:pythagoras} ist auch als das Theorem des Pythagoras bekannt. Dieses wird in
Gleichung ~\ref{eq:pythagoras} ist auch als das Theorem des Pythagoras bekannt. Dieses wird in
Abschnitt ~\ref{subsec:pythagoras} behandelt. Es können sehr viele Sachen mit Labels versehen werden:
Grafiken, Gleichungen, Sections, etc.
Summen und Integrale können mit den sum und int Befehlen dargestellt werden:
% Manche LateX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
\begin{equation}
% Manche LaTeX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
\begin{equation}
\sum_{i=0}^{5} f_{i}
\end{equation}
\begin{equation}
\end{equation}
\begin{equation}
\int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
\end{equation}
\end{equation}
\section{Grafiken}
@ -164,7 +175,7 @@ Aber keine Sorge, ich muss auch jedes mal nachschauen, welche Option wie wirkt.
\begin{figure}[H] % H ist die Platzierungsoption
\centering % Zentriert die Grafik auf der Seite
% Fügt eine Grafik ein, die auf 80% der Seitenbreite einnimmt.
%\includegraphics[width=0.8\linewidth]{right-triangle.png}
%\includegraphics[width=0.8\linewidth]{right-triangle.png}
% Auskommentiert, damit es nicht im Dokument auftaucht.
\caption{Dreieck mit den Seiten $a$, $b$, $c$}
\label{fig:right-triangle}
@ -177,7 +188,7 @@ Wir können Tabellen genauso wie Grafiken einfügen.
\caption{Überschrift der Tabelle.}
% Die {} Argumente geben an, wie eine Zeile der Tabelle dargestellt werden soll.
% Auch hier muss ich jedes Mal nachschauen. Jedes. einzelne. Mal.
\begin{tabular}{c|cc}
\begin{tabular}{c|cc}
Nummer & Nachname & Vorname \\ % Spalten werden durch & getrennt
\hline % Eine horizontale Linie
1 & Biggus & Dickus \\
@ -187,36 +198,36 @@ Wir können Tabellen genauso wie Grafiken einfügen.
% \section{Links} % Kommen bald!
\section{Verhindern, dass LateX etwas kompiliert (z.B. Quelltext)}
Angenommen, wir wollen Quelltext in unserem LateX-Dokument. LateX soll
in diesem Fall nicht den Quelltext als LateX-Kommandos interpretieren,
\section{Verhindern, dass \LaTeX\ etwas kompiliert (z.B. Quelltext)}
Angenommen, wir wollen Quelltext in unserem \LaTeX-Dokument. \LaTeX\ soll
in diesem Fall nicht den Quelltext als \LaTeX-Kommandos interpretieren,
sondern es einfach ins Dokument schreiben. Um das hinzubekommen, verwenden
wir eine verbatim Umgebung.
% Es gibt noch weitere Pakete für Quelltexte (z.B. minty, lstlisting, etc.)
% aber verbatim ist das simpelste.
\begin{verbatim}
\begin{verbatim}
print("Hello World!")
a%b; % Schau dir das an! Wir können % im verbatim verwenden!
random = 4; #decided by fair random dice roll
\end{verbatim}
\section{Kompilieren}
\section{Kompilieren}
Ich vermute, du wunderst dich, wie du dieses tolle Dokument in ein PDF
verwandeln kannst. (Ja, dieses Dokument kompiliert wirklich!) \\
Dafür musst du folgende Schritte durchführen:
\begin{enumerate}
\item Schreibe das Dokument. (den LateX-Quelltext).
\item Kompiliere den Quelltext in ein PDF.
\item Schreibe das Dokument. (den \LaTeX -Quelltext).
\item Kompiliere den Quelltext in ein PDF.
Das Kompilieren sieht so ähnlich wie das hier aus (Linux): \\
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
\end{verbatim}
\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.
Alle Formatierungsoptionen werden in Schritt 1 in den Quelltext geschrieben. Schritt 2 verwendet

426
de-de/lua-de.html.markdown Normal file
View File

@ -0,0 +1,426 @@
---
language: Lua
contributors:
- ["Tyler Neylon", "http://tylerneylon.com/"]
translators:
- ["Martin Schimandl", "https://github.com/Git-Jiro"]
filename: learnlua-de.lua
lang: de-de
---
```lua
-- Zwei Gedankenstriche starten ein einzeiliges Kommentar.
--[[
Fügt man zwei '[' und ']' hinzu,
erzeugt man einen mehrzeiligen Kommentar.
--]]
--------------------------------------------------------------------------------
-- 1. Variablen und Fluß-Kontrolle.
--------------------------------------------------------------------------------
num = 42 -- Alle Nummern sind vom Typ: Double.
-- Werd nicht nervös, 64-Bit Double haben 52 Bits zum Speichern von exakten
-- Ganzzahlen; Maschinen-Genauigkeit ist kein Problem für Ganzzahlen kleiner als
-- 52 Bit.
s = 'walternate' -- Zeichenketten sind unveränderlich, wie bei Python.
t = "Doppelte Anführungszeichen sind auch OK"
u = [[ Doppelte eckige Klammern
beginnen und beenden
mehrzeilige Zeichenketten.]]
t = nil -- Undefineren von t; Lua hat einen Garbage Collection.
-- Blöcke werden durch Schlüsselwörter wie do/end markiert:
while num < 50 do
num = num + 1 -- Es gibt Keine Operatoren wie ++ oder +=
end
-- If Bedingungen:
if num > 40 then
print('over 40')
elseif s ~= 'walternate' then -- ~= bedeutet ungleich
-- Gleichheits-Check == wie bei Python; OK für Zeichenketten.
io.write('not over 40\n') -- Standard ist stdout.
else
-- Variablen sind standardmäßig global.
thisIsGlobal = 5 -- Camel case ist üblich.
-- So macht man eine Variable lokal:
local line = io.read() -- Lies die nächste Zeile von stdin.
-- Zeichenketten zusammenführen mit dem .. Operator:
print('Winter is coming, ' .. line)
end
-- Undefinierte Variablen geben nil zurück.
-- Das ist kein Fehler:
foo = anUnknownVariable -- Nun ist foo = nil.
aBoolValue = false
-- Nur nil und false sind unwahr; 0 and '' sind wahr!
if not aBoolValue then print('was false') end
-- 'or' und 'and' sind "kurz-geschlossen". Das ist so ähnlich wie der a?b:c
-- operator in C/js:
-- in C/js:
ans = aBoolValue and 'yes' or 'no' --> 'no'
karlSum = 0
for i = 1, 100 do -- Ein Bereich inkludiert beide Enden.
karlSum = karlSum + i
end
-- Verwende "100, 1, -1" als Breich für Countdowns:
fredSum = 0
for j = 100, 1, -1 do fredSum = fredSum + j end
-- Im Allgemeinen besteht ein Bereich aus: Anfang, Ende, [, Schrittweite].
-- Ein anderes Schleifen-Konstrukt:
repeat
print('Der Weg der Zukunft')
num = num - 1
until num == 0
--------------------------------------------------------------------------------
-- 2. Funktionen.
--------------------------------------------------------------------------------
function fib(n)
if n < 2 then return n end
return fib(n - 2) + fib(n - 1)
end
-- Closures und anonyme Funktionen sind ok:
function adder(x)
-- Die zurückgegebene Funktion wird erzeugt wenn addr aufgerufen wird und merkt
-- sich den Wert von x:
return function (y) return x + y end
end
a1 = adder(9)
a2 = adder(36)
print(a1(16)) --> 25
print(a2(64)) --> 100
-- Rückgabewerte, Funktions-Aufrufe und Zuweisungen funktionieren alle mit
-- Listen die nicht immer gleich lang sein müssen. Überzählige Empfänger
-- bekommen nil; überzählige Sender werden ignoriert.
x, y, z = 1, 2, 3, 4
-- Nun ist x = 1, y = 2, z = 3, und 4 wird ignoriert.
function bar(a, b, c)
print(a, b, c)
return 4, 8, 15, 16, 23, 42
end
x, y = bar('zaphod') --> prints "zaphod nil nil"
-- Nun ist x = 4, y = 8, die Werte 15..42 werden ignoriert.
-- Funktionen sind erste Klasse, und können lokal oder global sein.
-- Das ist alles das Gleiche:
function f(x) return x * x end
f = function (x) return x * x end
-- Das auch:
local function g(x) return math.sin(x) end
local g = function(x) return math.sin(x) end
-- Äquivalent zu local function g(x)..., außer das Referenzen auf g im
-- Funktions-Körper nicht wie erwartet funktionieren.
local g; g = function (x) return math.sin(x) end
-- Die Deklaration 'local g' macht Selbst-Referenzen auf g OK.
-- Nebenbei gesagt, Trigonometrie-Funktionen verwenden Radianten.
-- Funktionsaufrufe mit nur einem Zeichenketten-Parameter brauch keine runden
-- Klammern.
print 'hello' -- Funktioniert wunderbar.
-- Funktionsaufrufe mit einem Tabellen-Parameter brauchen auch keine runden
-- Klammern. Mehr zu Tabellen kommt später.
print {} -- Funktioniert auch wunderbar.
--------------------------------------------------------------------------------
-- 3. Tabellen.
--------------------------------------------------------------------------------
-- Tabellen sind die einzige zusammengesetzte Struktur in Lua. Sie sind
-- assoziative Arrays. Sie sind so ähnlich wie PHP arrays oder JavaScript
-- Objekte. Sie sind Hash-Lookup-Dictionaries die auch als Listen verwendet
-- werden können.
-- Verwenden von Tabellen als Dictionaries oder Maps:
-- Dict-Literale haben standardmäßig Zeichenketten als Schlüssel:
t = {key1 = 'value1', key2 = false}
-- Zeichenketten-Schlüssel verwenden eine JavaScript ähnliche Punkt-Notation.
print(t.key1) -- Ausgabe 'value1'.
t.newKey = {} -- Neues Schlüssel/Wert-Paar hinzufügen.
t.key2 = nil -- key2 aus der Tabelle entfernen.
-- Literale notation für jeden (nicht-nil) Wert als Schlüssel:
u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
print(u[6.28]) -- Ausgabe "tau"
-- Schlüssel-Vergleiche funktionieren per Wert für Nummern und Zeichenketten,
-- aber über die Identität bei Tabellen.
a = u['@!#'] -- Nun ist a = 'qbert'.
b = u[{}] -- Wir würden 1729 erwarten, aber es ist nil:
-- b = nil weil der Lookup fehlschlägt. Er schlägt Fehl, weil der Schlüssel
-- den wir verwendet haben nicht das gleiche Objekt ist das wir verwendet
-- haben um den original Wert zu speichern. Zahlen und Zeichnkette sind daher
-- die praktischeren Schlüssel.
-- Eine Funktion mit nur einem Tabellen-Parameter benötigt keine Klammern.
function h(x) print(x.key1) end
h{key1 = 'Sonmi~451'} -- Ausgabe 'Sonmi~451'.
for key, val in pairs(u) do -- Tabellen-Iteration.
print(key, val)
end
-- _G ist eine spezielle Tabelle die alles Globale enthält.
print(_G['_G'] == _G) -- Ausgabe 'true'.
-- Verwenden von Tabellen als Listen/Arrays:
-- Listen-Literale verwenden implizit Ganzzahlen als Schlüssel:
v = {'value1', 'value2', 1.21, 'gigawatts'}
for i = 1, #v do -- #v ist die Größe von v für Listen.
print(v[i]) -- Indices beginnen mit 1 !! SO VERRÜCKT!
end
-- Eine 'Liste' ist kein echter Typ. v ist nur eine Tabelle mit fortlaufenden
-- Ganzzahlen als Schlüssel, die behandelt wird wie eine Liste.
--------------------------------------------------------------------------------
-- 3.1 Metatabellen und Metamethoden
--------------------------------------------------------------------------------
-- Eine Tabelle kann eine Metatabelle haben. Diese verleiht ihr so etwas wie
-- Tabellen-Operator-Überladungs-Verhalten. Später sehen wir wie
-- Metatabellen js-prototypen artiges Verhalten unterstützen.
f1 = {a = 1, b = 2} -- Repräsentiert den Bruch a/b.
f2 = {a = 2, b = 3}
-- Dies würde Fehlschlagen:
-- s = f1 + f2
metafraction = {}
function metafraction.__add(f1, f2)
local sum = {}
sum.b = f1.b * f2.b
sum.a = f1.a * f2.b + f2.a * f1.b
return sum
end
setmetatable(f1, metafraction)
setmetatable(f2, metafraction)
s = f1 + f2 -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf.
-- f1 und f2 haben keine Schlüssel für ihre Metatabellen, anders als bei js
-- Prototypen. Daher muss mithilfe von getmetatable(f1) darauf zugegriffen
-- werden. Eine Metatabelle ist wie eine normale Tabelle mit Schlüsseln die
-- Lua bekannt sind, so wie __add.
-- Die nächste Zeile schlägt fehl weil s keine Metatabelle hat:
-- t = s + s
-- Mihilfe von Klassen ähnlichen Mustern kann das gelöst werden.
-- Siehe weiter unten.
-- Ein __index einer Metatabelle überlädt Punkt-Lookups:
defaultFavs = {animal = 'gru', food = 'donuts'}
myFavs = {food = 'pizza'}
setmetatable(myFavs, {__index = defaultFavs})
eatenBy = myFavs.animal -- Funktioniert dank Metatabelle!
--------------------------------------------------------------------------------
-- Direkte Tabellen-Lookups die fehlschlagen werden mithilfe von __index der
-- Metatabelle wiederholt. Das geschieht rekursiv.
-- __index kann auch eine Funktion mit der Form function(tbl, key) sein.
-- Damit kann man Lookups weiter anpassen.
-- Werte wie __index,add, .. werden Metamethoden genannt.
-- HIer eine vollständige Liste aller Metamethoden.
-- __add(a, b) für a + b
-- __sub(a, b) für a - b
-- __mul(a, b) für a * b
-- __div(a, b) für a / b
-- __mod(a, b) für a % b
-- __pow(a, b) für a ^ b
-- __unm(a) für -a
-- __concat(a, b) für a .. b
-- __len(a) für #a
-- __eq(a, b) für a == b
-- __lt(a, b) für a < b
-- __le(a, b) für a <= b
-- __index(a, b) <fn or a table> für a.b
-- __newindex(a, b, c) für a.b = c
-- __call(a, ...) für a(...)
--------------------------------------------------------------------------------
-- 3.2 Klassen-Artige Tabellen und Vererbung.
--------------------------------------------------------------------------------
-- Klassen sind in Lua nicht eingebaut. Es gibt verschieden Wege sie mithilfe
-- von Tabellen und Metatabellen zu erzeugen.
-- Die Erklärund des Beispiels erfolgt unterhalb.
Dog = {} -- 1.
function Dog:new() -- 2.
local newObj = {sound = 'woof'} -- 3.
self.__index = self -- 4.
return setmetatable(newObj, self) -- 5.
end
function Dog:makeSound() -- 6.
print('I say ' .. self.sound)
end
mrDog = Dog:new() -- 7.
mrDog:makeSound() -- 'I say woof' -- 8.
-- 1. Dog verhält sich wie eine Klasse; Ist aber eine Tabelle.
-- 2. "function tablename:fn(...)" ist das gleiche wie
-- "function tablename.fn(self, ...)", Der : fügt nur ein Argument namens
-- self hinzu. Siehe 7 & 8 um zu sehen wie self seinen Wert bekommt.
-- 3. newObj wird eine Instanz von Dog.
-- 4. "self" ist die zu Instanzierende Klasse. Meistern ist self = Dog, aber
-- dies kann durch Vererbung geändert werden. newObj bekommt die Funktionen
-- von self wenn wir die Metatabelle von newObj und __index von self auf
-- self setzen.
-- 5. Zur Erinnerung: setmetatable gibt sein erstes Argument zurück.
-- 6. Der Doppelpunkt funktioniert wie bei 2, aber dieses Mal erwarten wir das
-- self eine Instanz ist und keine Klasse.
-- 7. Das Selbe wie Dog.new(Dog), also self = Dog in new().
-- 8. Das Selbe wie mrDog.makeSound(mrDog); self = mrDog.
--------------------------------------------------------------------------------
-- Vererbungs-Beispiel:
LoudDog = Dog:new() -- 1.
function LoudDog:makeSound()
local s = self.sound .. ' ' -- 2.
print(s .. s .. s)
end
seymour = LoudDog:new() -- 3.
seymour:makeSound() -- 'woof woof woof' -- 4.
--------------------------------------------------------------------------------
-- 1. LoudDog bekommt die Methoden und Variablen von Dog.
-- 2. self hat einen 'sound' Schlüssel von new(), siehe 3.
-- 3. Das Gleiche wie "LoudDog.new(LoudDog)", und umgewandelt zu "Dog.new(LoudDog)"
-- denn LoudDog hat keinen 'new' Schlüssel, aber "__index = Dog" steht in der
-- Metatabelle.
-- Ergebnis: Die Metatabelle von seymour ist LoudDog und "LoudDog.__index = Dog".
-- Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nachdem
-- welche Tabelle als erstes einen passenden Schlüssel hat.
-- 4. Der 'makeSound' Schlüssel wird in LoudDog gefunden: Das ist das Gleiche
-- wie "LoudDog.makeSound(seymour)".
-- Wenn nötig, sieht new() einer Sub-Klasse genau so aus wie new() der
-- Basis-Klasse:
function LoudDog:new()
local newObj = {}
-- set up newObj
self.__index = self
return setmetatable(newObj, self)
end
--------------------------------------------------------------------------------
-- 4. Module.
--------------------------------------------------------------------------------
--[[ Dieser Abschnitt ist auskommentiert damit der Rest des Skripts lauffähig
-- bleibt.
```
```lua
-- Angenommen mod.lua sieht so aus:
local M = {}
local function sayMyName()
print('Hrunkner')
end
function M.sayHello()
print('Why hello there')
sayMyName()
end
return M
-- Eine andere Datei könnte die Funktionen in mod.lua so verwenden:
local mod = require('mod') -- Führe mod.lua aus.
-- require ist der Standard-Weg um Module zu inkludieren.
-- require verhält sich wie: (Wenn nicht gecached wird; siehe später)
local mod = (function ()
<Inhalt von mod.lua>
end)()
-- Es ist als ob mod.lua eine Funktion wäre, sodass lokale Variablen in
-- mod.lua ausserhalb unsichtbar sind.
-- Das funktioniert weil mod hier das Gleiche wie M in mod.lua ist:
mod.sayHello() -- Says hello to Hrunkner.
-- Das ist Falsch: sayMyName existiert nur in mod.lua:
mod.sayMyName() -- Fehler
-- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass Module nur
-- einmal abgearbeitet werden, auch wenn sie mit require öfters eingebunden
-- werden.
-- Nehmen wir an mod2.lua enthält "print('Hi!')".
local a = require('mod2') -- Ausgabe Hi!
local b = require('mod2') -- Keine Ausgabe; a=b.
-- dofile ist wie require aber ohne Zwischenspeichern.
dofile('mod2') --> Hi!
dofile('mod2') --> Hi! (läuft nochmal, nicht wie require)
-- loadfile ladet eine lua Datei aber die Datei wird noch nicht abgearbeitet.
f = loadfile('mod2') -- Sobald f() aufgerufen wird läuft mod2.lua.
-- loadstring ist loadfile für Zeichenketten
g = loadstring('print(343)') -- Gibt eine Funktion zurück..
g() -- Ausgabe 343; Vorher kam keine Ausgabe.
--]]
```
## Referenzen
Ich war so begeistert Lua zu lernen, damit ich Spiele mit <a href="http://love2d.org/">Love 2D game engine</a> programmieren konnte.
Ich habe angefangen mit <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
Danach habe ich das offizielle Lua Buch gelesen: <a href="http://www.lua.org/pil/contents.html">Programming in Lua</a>
Es kann auch hilfreich sein hier vorbeizuschauen: <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Lua short
reference</a>
Wichtige Themen die hier nicht angesprochen wurden; die Standard-Bibliotheken:
* <a href="http://lua-users.org/wiki/StringLibraryTutorial">string library</a>
* <a href="http://lua-users.org/wiki/TableLibraryTutorial">table library</a>
* <a href="http://lua-users.org/wiki/MathLibraryTutorial">math library</a>
* <a href="http://lua-users.org/wiki/IoLibraryTutorial">io library</a>
* <a href="http://lua-users.org/wiki/OsLibraryTutorial">os library</a>
Übrigends, die gesamte Datei ist gültiges Lua. Speichere sie als learn.lua und
starte sie als "lua learn.lua" !
Die Erstfassung ist von tylerneylon.com, und ist auch hier verfügbar: <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Viel Spaß mit Lua!

260
de-de/make-de.html.markdown Normal file
View File

@ -0,0 +1,260 @@
---
language: make
contributors:
- ["Robert Steed", "https://github.com/robochat"]
translators:
- ["Martin Schimandl", "https://github.com/Git-Jiro"]
filename: Makefile-de
lang: de-de
---
Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele)
zu erzeugen. Es dient dazu die geringste Menge an Arbeit zu verrichten um
ein Ziel in einklang mit dem Quellcode zu bringen. Make wurde berühmterweise
von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer
sehr verbreitet (vorallem im Unix umfeld) obwohl es bereits sehr viel
Konkurrenz und Kritik zu Make gibt.
Es gibt eine vielzahl an Varianten von Make, dieser Artikel beschäftig sich
mit der Version GNU Make. Diese Version ist standard auf Linux.
```make
# Kommentare können so geschrieben werden.
# Dateien sollten Makefile heißen, denn dann können sie als `make <ziel>`
# aufgerufen werden. Ansonsten muss `make -f "dateiname" <ziel>` verwendet
# werden.
# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet
# werden. Niemals Leerzeichen!
#-----------------------------------------------------------------------
# Grundlagen
#-----------------------------------------------------------------------
# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt
# nicht existiert.
file0.txt:
echo "foo" > file0.txt
# Selbst Kommentare in der 'Rezept' Sektion werden an die Shell
# weitergegeben. Versuche `make file0.txt` oder einfach `make`
# die erste Regel ist die Standard-Regel.
# Diese Regel wird nur abgearbeitet wenn file0.txt aktueller als file1.txt ist.
file1.txt: file0.txt
cat file0.txt > file1.txt
# Verwende die selben Quoting-Regeln wie die Shell
@cat file0.txt >> file1.txt
# @ unterdrückt die Ausgabe des Befehls an stdout.
-@echo 'hello'
# - bedeutet das Make die Abarbeitung fortsetzt auch wenn Fehler passieren.
# Versuche `make file1.txt` auf der Kommandozeile.
# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben.
file2.txt file3.txt: file0.txt file1.txt
touch file2.txt
touch file3.txt
# Make wird sich beschweren wenn es mehrere Rezepte für die gleiche Regel gibt.
# Leere Rezepte zählen nicht und können dazu verwendet werden weitere
# Voraussetzungen hinzuzufügen.
#-----------------------------------------------------------------------
# Phony-Ziele
#-----------------------------------------------------------------------
# Ein Phony-Ziel ist ein Ziel das keine Datei ist.
# Es wird nie aktuell sein, daher wird Make immer versuchen es abzuarbeiten
all: maker process
# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren.
maker:
touch ex0.txt ex1.txt
# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den
# selben namen wie ein Phony-Ziel hat:
.PHONY: all maker process
# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon.
# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet
ex0.txt ex1.txt: maker
# Häufige Phony-Ziele sind: all make clean install ...
#-----------------------------------------------------------------------
# Automatische Variablen & Wildcards
#-----------------------------------------------------------------------
process: file*.txt # Eine Wildcard um Dateinamen zu Vergleichen
@echo $^ # $^ ist eine Variable die eine Liste aller
# Voraussetzungen enthält.
@echo $@ # Namen des Ziels ausgeben.
#(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung
#der Regel.)
@echo $< # Die erste Voraussetzung aus der Liste
@echo $? # Nur die Voraussetzungen die nicht aktuell sind.
@echo $+ # Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich)
#@echo $| # Alle 'order only' Voraussetzungen
# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden.
process: ex1.txt file0.txt
# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert.
#-----------------------------------------------------------------------
# Muster
#-----------------------------------------------------------------------
# Mit Mustern kann man make beibringen wie Dateien in andere Dateien
# umgewandelt werden.
%.png: %.svg
inkscape --export-png $^
# Muster-Vergleichs-Regeln werden nur abgearbeitet wenn make entscheidet das Ziel zu
# erzeugen
# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert.
# Aber make wird versuchen die am besten passende Regel zu verwenden.
small/%.png: %.svg
inkscape --export-png --export-dpi 30 $^
# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden die es
# findet.
%.png: %.svg
@echo this rule is chosen
# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden die das
# Ziel erzeugen kann.
%.png: %.ps
@echo this rule is not chosen if *.svg and *.ps are both present
# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel
# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt.
# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt
# Muster-Vergleichs-Regeln.
.png.ps:
@echo this rule is similar to a pattern rule.
# Aktivieren der Suffix-Regel
.SUFFIXES: .png
#-----------------------------------------------------------------------
# Variablen
#-----------------------------------------------------------------------
# auch Makros genannt.
# Variablen sind im Grunde genommen Zeichenketten-Typen.
name = Ted
name2="Sarah"
echo:
@echo $(name)
@echo ${name2}
@echo $name # Das funktioniert nicht, wird als $(n)ame behandelt.
@echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt.
# Es git 4 Stellen um Variablen zu setzen.
# In Reihenfolge der Priorität von höchster zu niedrigster:
# 1: Befehls-Zeilen Argumente
# 2: Makefile
# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch.
# 3: MAke hat einige vordefinierte Variablen.
name4 ?= Jean
# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch
# nicht gibt.
override name5 = David
# Verhindert das Kommando-Zeilen Argumente diese Variable ändern können.
name4 +=grey
# Werte an eine Variable anhängen (inkludiert Leerzeichen).
# Muster-Spezifische Variablen Werte (GNU Erweiterung).
echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb
# rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören
# kann wenn es zu kompilizert wird!)
# Ein paar Variablen die von Make automatisch definiert werden.
echo_inbuilt:
echo $(CC)
echo ${CXX)}
echo $(FC)
echo ${CFLAGS)}
echo $(CPPFLAGS)
echo ${CXXFLAGS}
echo $(LDFLAGS)
echo ${LDLIBS}
#-----------------------------------------------------------------------
# Variablen 2
#-----------------------------------------------------------------------
# Der erste Typ von Variablen wird bei jeder verwendung ausgewertet.
# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen.
# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung)
var := hello
var2 ::= $(var) hello
#:= und ::= sind äquivalent.
# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie
# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache!
# Das funktioniert nicht
var3 ::= $(var4) and good luck
var4 ::= good night
#-----------------------------------------------------------------------
# Funktionen
#-----------------------------------------------------------------------
# Make verfügt über eine vielzahl von Funktionen.
sourcefiles = $(wildcard *.c */*.c)
objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
# Das Format ist $(func arg0,arg1,arg2...)
# Ein paar Beispiele
ls: * src/*
@echo $(filter %.txt, $^)
@echo $(notdir $^)
@echo $(join $(dir $^),$(notdir $^))
#-----------------------------------------------------------------------
# Direktiven
#-----------------------------------------------------------------------
# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code
include foo.mk
sport = tennis
# Konditionale kompiliereung
report:
ifeq ($(sport),tennis)
@echo 'game, set, match'
else
@echo "They think it's all over; it is now"
endif
# Es gibt auch ifneq, ifdef, ifndef
foo = true
ifdef $(foo)
bar = 'hello'
endif
```
### Mehr Resourcen
+ [gnu make documentation](https://www.gnu.org/software/make/manual/)
+ [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)

10
de-de/markdown-de.html.markdown
View File

@ -56,7 +56,7 @@ __Genau wie dieser.__
**_Dieser auch!_**
*__Und dieser genau so!__*
<!-- In "Github Flavored Markdown", dem von Github verwendeten Dialekt / Parser,
<!-- In "GitHub Flavored Markdown", dem von GitHub verwendeten Dialekt / Parser,
gibt es auch noch durchgestrichenen Text: -->
~~Dieser Text wird durchgestrichen dargestellt.~~
@ -148,7 +148,7 @@ indem du eine Zeile mit vier Leerzeichen oder einem Tabulator einrückst -->
Hermann hatte nicht die leiseste Ahnung, was dieses `go_to()` bedeuten könnte!
<!-- In "Github Flavored Markdown" gibt es für Code nocheinmal eine
<!-- In "GitHub Flavored Markdown" gibt es für Code nocheinmal eine
besondere Syntax -->
\`\`\`ruby <!-- in "echt" musst du die Backslashes entfernen: ```ruby ! -->
@ -157,7 +157,7 @@ def foobar
end
\`\`\` <!-- hier auch keine Backslashes, nur ``` -->
<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt Github
<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt GitHub
Syntax-Highlighting für die nach dem ``` angegebene Sprache hinzu -->
<!-- Horizontale Linie (<hr />) -->
@ -233,7 +233,7 @@ Ich würde *diesen Teil gerne mit Sternen umschließen*, doch ohne dass er kursi
wird. Also mache ich folgendes: \*Ich umschließe diesen Text mit Sternen\*!
<!-- Tabellen -->
<!-- Tabellen gibt es bis jetzt nur in "Github Flavored Markdown".
<!-- Tabellen gibt es bis jetzt nur in "GitHub Flavored Markdown".
Zudem sind sie ziemlich mühselig, aber wenn du es wirklich wissen willst: -->
| Spalte1 | Spalte2 | Spalte3 |
@ -253,4 +253,4 @@ Ganz schön hässlich | vielleicht doch lieber | wieder aufhören
Mehr Informationen gibt es in [John Gruber's offiziellem Blog-Post](http://daringfireball.net/projects/markdown/syntax)
und bei Adam Pritchards [grandiosem Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
Infos zu Github Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
Infos zu GitHub Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).

475
de-de/tcl-de.html.markdown Normal file
View File

@ -0,0 +1,475 @@
---
language: Tcl
contributors:
- ["Poor Yorick", "http://pooryorick.com/"]
translators:
- ["Martin Schimandl", "https://github.com/Git-Jiro"]
filename: learntcl-de.tcl
lang: de-de
---
Tcl wurde kreiert von [John Ousterhout](http://wiki.tcl.tk/John Ousterout) als
eine wiederverwendbare Script-Sprache für Chip-Design Werkzeuge die er kreiert
hat. Im Jahre 1997 wurde er mit dem [ACM Software System
Award](http://en.wikipedia.org/wiki/ACM_Software_System_Award) für Tcl
ausgezeichnet. Tcl kann sowohl als eingebettete Scipt-Sprache als auch als
allgemeine Programmier-Sprache verwendet werden. Tcl kann auch als portable
C-Bibliothek verwendet werden. Sogar in Fällen in denen die Script-Fähigkeiten
nicht nötig sind. Denn Tcl stellt Daten-Strukturen wie dynamische Zeichenketten,
Listen und Hash-Tabellen bereit. Die C-Bilbiothek stellt auch portable
Funktionen zur Verfügung: Laden von dynamischen Bibliotheken, Zeichenketten
formatierung und Code Konversion, Dateisystem Operationen, Netzwerk Operationen
und mehr.
Verschiedenste herausragende Fähigkeiten von Tcl:
* Praktische Cross-Platform Netzwerk-API
* Vollständig virtualisiertes Dateisystem
* Stapelbare I/O Kanäle
* Asynchron bis zum Kern
* Vollständige Ko-Routinen
* Robustes und einfach zu verwendendes Thread-Modell
Wenn Lisp ein Listen-Prozessor ist, dann ist TCl ein Zeichenketten-Prozessor.
Alle Werte sind Zeichenketten. Eine Liste ist ein Zeichenketten-Format. Eine
Prozedur-Definition ist ein Zeichenketten-Format. Um leistungsfähig zu sein,
werden Tcl-intern diese Zeichenketten in Strukutierter-Form gepuffert. Ein
Beispiel: Der "list" Befehl arbeitet mit diesen internen gepufferten
Repräsentationen. Tcl kümmert sich selbständig darum die String-Repräsentationen
zu aktualisieren, falls dies im Skript benötigt werden sollten. Das Kopieren-
beim-Schreiben-Design von Tcl erlaubt es Skript-Authoren mit großen Daten-
Strukturen zu arbeiten ohne zuätzlichen Speicher-Overhead. Prozeduren werden
automatisch byte-kompiliert außer sie verwenden dynamsiche Befehle wie zum
Beispiel "uplevel", "upvar und "trace".
Es ist eine freude in Tcl zu programmieren. Hacker-Typen werden gefallen daran
finden, wenn sie Lisp, Forth oder Smalltalk interessant finden. Tcl wird auch
Ingenieuren und Wissenshaftlern gefallen die nur den Job erledigen wollen,
und zwar mit Werkzeugen die sich ihrem Willen anpassen. Bei Tcl ist jegliche
funktionalität in Befehlen ausgeführt, selbst Dinge wie Schleifen und
Mathematische-Funktionen die bei anderen Sprachen normalerweise Teil der Syntax
sind. Das erlaubt Tcl in den Hintergrund von Domänen spezischen Sprachen zu
treten die das jeweilige Projekt gerade benötigt. Die Tcl-Syntax ist sehr
leichtgewichtig. Sie ist selbst leichtgewichtiger als die Syntax von Lisp.
Tcl steht dir einfach nicht im Weg.
```tcl
#! /bin/env tclsh
################################################################################
## 1. Richtlinien
################################################################################
# Tcl ist nicht Bash oder C! Das muss gesagt werden, denn standard Shell-Quoting
# funktioniert fast mit Tcl. Daher glauben viele sie können diese Syntax für
# Tcl übernehmen. Am Beginn funktioniert das meist, führt aber schnell zu
# Frustrationen wenn die Skripte komplexer werden.
# Eckige-Klammern sind nur Quoting-Mechanismen, keine Code-Block-Konstruktoren
# und auch keine Listen-Konstruktoren. In Tcl gibt es diese beiden Dinge nicht.
# Eckige-Klammern werden verwendet um Spezial-Zeichen in Prozeduren zu escapen
# und in Zeichenketten die als Listen formattiert sind.
################################################################################
## 2. Syntax
################################################################################
# Jede Zeile ist ein Befehl. Das erste Wort ist der Name des Befehls, jedes
# weitere Wort ist ein Argument des Befehls. Wörter sind begrenzt durch
# Leerzeichen. Da jedes Wort auch ein String ist, sind keine speziellen
# auszeichnungen wie Anführungs-Zeichen, Klammern oder Backslashes nötig.
# Selbst wenn Anführungs-Zeichen verwendet werden, denn sie sind ja keine
# String-Konstruktoren, sondern nur Escape-Zeichen.
set greeting1 Sal
set greeting2 ut
set greeting3 ations
# Strichpunkte begrenzen auch Befehle
set greeting1 Sal; set greeting2 ut; set greeting3 ations
# Das Dollar-Zeichen zeigt eine Variablen-Substitution an.
set greeting $greeting1$greeting2$greeting3
# Eckige-Klammern zeigen Befehls-Substitionen an. Das Ergebnis des Befehls wird an
# Stelle des Klammern-Ausdrucks eingefügt. Wenn man dem "set" Befehl nur den
# Namen einer Variablen übergibt, gibt er den Wert der Variablen zurück.
set greeting $greeting1$greeting2[set greeting3]
# Befehls-Substitution sollte eigentlich Script-Substitution heißen, denn ein
# komplettes Script, und nicht nur ein Befehl, kann zwischen die Eckigen-Klammern
# geschrieben werden. Der "incr" Befehl erhöht den Wert einer Variable um 1
# und gibt den neuen Wert der Variable zurück.
set greeting $greeting[
incr i
incr i
incr i
]
# Der Backslash unterdrück die Bedeutung von Sonderzeichen
set amount \$16.42
# Der Backslash macht bestimmte Zeichen zu Sonderzeichen
puts lots\nof\n\n\n\n\n\nnewlines
# Ein Wort das in geschweiften Klammern eingeschlossen wurde ist von jeglichen
# speziellen Interpretationen ausgeschlossen. Eine Ausnahme bilden Backslashes
# vor geschweiften Klammern, hiermit wird die geschweifte Klammer von der Suche
# nach der schließenden geschweiften Klammer ausgeschlossen.
set somevar {
Das ist ein literales $ Zeichen, diese geschweifte Klammer \} wird nicht
als Ende interpretiert.
}
# Bei einem Wort das in doppelten Anführungszeichen steht verlieren Leerzeichen
# ihre spezielle Bedeutung.
set name Neo
set greeting "Hallo, $name"
#Variablen-Namen können irgend eine Zeichenkette sein.
set {first name} New
# Die Geschweifte-Klammern-Form der Variablen-Substitution kann sehr komplexe
# Variblen-Namen handhaben.
set greeting "Hello, ${first name}"
# Der "set" Befehl kann immer anstatt einer Variablen-Substition verwendet
# werden.
set greeting "Hello, [set {first name}]"
# Mit dem Expansions-Operator "{*}" werden Wörter innerhalb eines Wortes wieder
# individuell als Teile des aktuellen Befehls behandelt.
set {*}{name Neo}
# Ist Äquivalent zu
set name Neo
# Ein Array ist eine spezielle Varible die also Kontainer für andere Variablen
# dient.
set person(name) Neo
set person(gender) male
set greeting "Hello, $person(name)"
# Ein Namensraum enthält Befehle und Variablen
namespace eval people {
namespace eval person1 {
variable name Neo
}
}
#Der volle Name einer Variablen beihaltet den/die umschließenden
# Namensraum/Namensräume begrenzt durch zwei Doppelpunkte.
set greeting "Hello $people::person1::name"
```
```tcl
################################################################################
## 3. Einige Notizen
################################################################################
# Jede weitere Funktion ist über Befehle implementiert. Von nun an kommt keine
# neue Syntax hinzu. Alles weitere das es über Tcl zu lernen gibt ist das
# Verhalten individueller Befehle und die bedeutung ihrer Argumente.
# Um einen Interpreter zu bekommen mit dem man nichts mehr machen kann, lösche
# einfach den globalen Namensraum. Das ist nicht sehr sinnvoll, zeigt aber die
# Natur von Tcl.
namespace delete ::
# Wegen des Verhaltens der Namens-Auflösung ist es sicherer den "variable"
# Befehl zu verwenden um in einem Namensraum einen Wert zu deklarieren oder
# zuzuweisen. Wenn eine Variable mit dem namen "name" bereits im globalen
# Namensraum existiert, bewirkt der "set" Befehl das der globalen Variable ein
# Wert zugewiesen wird, anstatt eine Variable im lokalen Namensraum zu erzeugen
namespace eval people {
namespace eval person1 {
variable name Neo
}
}
# Es kann immer der vollständige Name einer Variable verwendet werden, falls
# gewünscht.
set people::person1::name Neo
################################################################################
## 4. Befehle
################################################################################
# Berechnungen werde mit dem "expr" Befehl durchgeführt.
set a 3
set b 4
set c [expr {$a + $b}]
# Since "expr" performs variable substitution on its own, brace the expression
# to prevent Tcl from performing variable substitution first. See
# Da der "expr" Befehl eigene Variablen-Substitutionen durchführt, setze den
# zu berechnenden Ausdruck in Eckige-Klammern. Das hindert Tcl daran Variablen-
# Substitutionen durchzuführen. Für Details siehe:
# "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions"
# Der "expr" Befehl versteht Variablen- und Befehls-Substitutionen
set c [expr {$a + [set b]}]
# Der "expr" Befehl stellt Mathematische-Funktionen zur Verfügung.
set c [expr {pow($a,$b)}]
# Mathematische Operatoren sind als Befehle auch im Namensraum
# ::tcl::mathop verfügbar.
::tcl::mathop::+ 5 3
# Befehle können aus anderen Namensräumen importiert werden.
namespace import ::tcl::mathop::+
set result [+ 5 3]
# Neu Befehle werden mit dem "proc" Befehl gebildet.
proc greet name {
return "Hello, $name!"
}
#Es können mehrere Parameter spezifiziert werden.
proc greet {greeting name} {
return "$greeting, $name!"
}
# Wie bereits erwähnt, geschwungene Klammern erzeugen keinen Code-Block.
# Jeder Wert, sogar das dritte Argument für den "proc" Befehl ist eine
# Zeichenkette. Der vorherige Befehl kann daher auch ohne
# geschwungene Klammern geschrieben werden:
proc greet greeting\ name return\ \"Hello,\ \$name!
# Wenn der letzte Parameter der literale Wert "args" ist, sammelt dieser Wert
# alle übrigen Argumente des Befehls ein wenn dieser aufgerufen wird.
proc fold {cmd args} {
set res 0
foreach arg $args {
set res [$cmd $res $arg]
}
}
fold ::tcl::mathop::* 5 3 3 ;# -> 45
# Bedingte Ausführung ist auch als Befehl implementiert
if {3 > 4} {
puts {This will never happen}
} elseif {4 > 4} {
puts {This will also never happen}
} else {
puts {This will always happen}
}
# Auch Schleifen sind Befehle. Das erste, zweite und dritte Argument des "for"
# Befehls wird als mathematischer Ausdruck behandelt.
for {set i 0} {$i < 10} {incr i} {
set res [expr {$res + $i}]
}
# Das erste Argument des "while" Befehls wird auch als mathematischer Ausdruck
# behandelt.
set i 0
while {$i < 10} {
incr i 2
}
# Eine Liste ist eine speziell formatierte Zeichenkette. Im einfachsten Fall
# genügen Leerzeichen als Trennzeichen zwischen den einzelnen Werten.
set amounts 10\ 33\ 18
set amount [lindex $amounts 1]
# Geschwungene Klammern und Backslashes können verwendet werden um komplexe
# Werte in einer Liste zu formatieren. Eine Liste sieht aus wie ein Skript,
# allerdings verlieren verlieren Zeilenumbrüche und Doppelüunkte ihre
# besondere Bedeutung. Diese Funktionalität macht Tcl homoikonisch. Die
# folgende Liste enhtält drei Elemente.
set values {
one\ two
{three four}
five\{six
}
# Da Listen auch Zeichenketten sind, kann man Zeichenketten-Operationen auf
# ihnen anwenden. Allerdings mit dem Risiko die Formatierung der Liste zu
# beschädigen.
set values {one two three four}
set values [string map {two \{} $values] ;# $values is no-longer a \
properly-formatted listwell-formed list
# Der sicherste Weg korrekt formatierte Liste zu erzeugen, ist den "list"
# Befehl zu verwenden.
set values [list one \{ three four]
lappend values { } ;# Ein Leerzeichen als Element der Liste hinzufügen
# Mit "eval" können Werte als Skripts evaluiert weden.
eval {
set name Neo
set greeting "Hello, $name"
}
# Eine Liste kann immer an "eval" übergeben werden, solange die Liste einen
# einzigen Befehl entält.
eval {set name Neo}
eval [list set greeting "Hello, $name"]
# Daher: Wenn "eval" verwendet wird, verwende [list] um den gewünschten Befehl
# aufzubauen.
set command {set name}
lappend command {Archibald Sorbisol}
eval $command
# Es ist ein häufiger Fehler die Listen funktionen beim Aufbauen von Listen
# nicht zu verwenden.
set command {set name}
append command { Archibald Sorbisol}
eval $command ;# Hier passiert eine Fehler, denn der "set" Befehl hat nun zu \
viele Argumente {set name Archibald Sorbisol}
# Dieser Fehler kann auch leicht beim "subst" Befehl passieren.
set replacement {Archibald Sorbisol}
set command {set name $replacement}
set command [subst $command]
eval $command ;# The same error as before: too many arguments to "set" in \
{set name Archibald Sorbisol}
# Die korrekte Vorgangsweise ist es den substituierten Wert mit dem "list"
# Befehl zu formatieren.
set replacement [list {Archibald Sorbisol}]
set command {set name $replacement}
set command [subst $command]
eval $command
# Der "list" Befehl wird sehr häufig verwendet um Werte zu formatieren die
# in Tcl Skript Vorlagen substituiert werden. Es gibt dazu viele Beispiele,
# siehe unterhalb.
# Der "apply" Befehl evaluiert eine Zeichenkette als Befehl.
set cmd {{greeting name} {
return "$greeting, $name!"
}}
apply $cmd Whaddup Neo
# Der "uplevel" Befehl evaluiert ein Skript in einem höher liegenden
Gültigkeitsbereich.
proc greet {} {
uplevel {puts "$greeting, $name"}
}
proc set_double {varname value} {
if {[string is double $value]} {
uplevel [list variable $varname $value]
} else {
error [list {not a double} $value]
}
}
# Der "upvar" Befehl verknüpft eine Variable im aktuellen Gültigkeitsbereich
# mit einer Variable in einem höher liegenden Gültigkeitsbereich.
proc set_double {varname value} {
if {[string is double $value]} {
upvar 1 $varname var
set var $value
} else {
error [list {not a double} $value]
}
}
# Werde den eingebauten "while" Befehl los.
rename ::while {}
# Definieren einen neuen "while" Befehl mit hilfe des "proc" Befehls.
# Ausführlichere Fehler-Behandlung wird dem Leser als Übung überlassen.
proc while {condition script} {
if {[uplevel 1 [list expr $condition]]} {
uplevel 1 $script
tailcall [namespace which while] $condition $script
}
}
# Der "coroutine" Befehl erzeugt einen separaten Call-Stack, zusammen mit einem
# Befehl um diesem Call-Stack zu verwenden. Der "yield" Befehl unterbricht
# die Ausführung des aktuellen Call-Stacks.
proc countdown {} {
#send something back to the initial "coroutine" command
yield
set count 3
while {$count > 1} {
yield [incr count -1]
}
return 0
}
coroutine countdown1 countdown
coroutine countdown2 countdown
puts [countdown 1] ;# -> 2
puts [countdown 2] ;# -> 2
puts [countdown 1] ;# -> 1
puts [countdown 1] ;# -> 0
puts [coundown 1] ;# -> invalid command name "countdown1"
puts [countdown 2] ;# -> 1
```
## Referenzen
[Official Tcl Documentation](http://www.tcl.tk/man/tcl/)
[Tcl Wiki](http://wiki.tcl.tk)
[Tcl Subreddit](http://www.reddit.com/r/Tcl)

2
edn.html.markdown
View File

@ -14,7 +14,7 @@ Clojure, there are implementations of EDN for many other languages.
The main benefit of EDN over JSON and YAML is that it is extensible. We
will see how it is extended later on.
```Clojure
```clojure
; Comments start with a semicolon.
; Anything after the semicolon is ignored.

4
elixir.html.markdown
View File

@ -170,7 +170,7 @@ case {:one, :two} do
{:four, :five} ->
"This won't match"
{:one, x} ->
"This will match and bind `x` to `:two`"
"This will match and bind `x` to `:two` in this clause"
_ ->
"This will match any value"
end
@ -411,7 +411,7 @@ self() #=> #PID<0.27.0>
## References
* [Getting started guide](http://elixir-lang.org/getting_started/1.html) from [elixir webpage](http://elixir-lang.org)
* [Getting started guide](http://elixir-lang.org/getting-started/introduction.html) from the [Elixir website](http://elixir-lang.org)
* [Elixir Documentation](http://elixir-lang.org/docs/master/)
* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas
* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)

367
elm.html.markdown Normal file
View File

@ -0,0 +1,367 @@
---
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 because it uses double quotes."
'a' -- characters in single quotes
-- 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
-- List.functionName means the function lives in the List module.
-- 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
-- The empty tuple, or "unit", is sometimes used as a placeholder.
-- It is the only value of its type, also called "Unit".
()
-- Records are like tuples but the fields have names. The order of fields
-- doesn't matter. Notice that record values use equals signs, not colons.
{ x = 3, y = 7 }
-- Access a field with a dot and the field name.
{ x = 3, y = 7 }.x -- 3
-- Or with an accessor function, which is a dot and the field name on its own.
.y { x = 3, y = 7 } -- 7
-- Update the fields of a record. (It must have the fields already.)
{ person |
name = "George" }
-- Update multiple fields at once, using the current values.
{ particle |
position = particle.position + particle.velocity,
velocity = particle.velocity + particle.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]-> "matches a list of exactly one item, " ++ toString x
x::xs -> "matches a list of at least one item whose head is " ++ toString x
-- Pattern matches go in order. If we put [x] last, it would never match because
-- x::xs also matches (xs would be the empty list). Matches do not "fall through".
-- The compiler will alert you to missing or extra cases.
-- Pattern match on a Maybe.
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 necessary).
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]
-- Another recursive function (use List.length in real code).
listLength aList =
case aList of
[] -> 0
x::xs -> 1 + listLength xs
-- Function calls happen before any infix operator. Parens indicate precedence.
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, and the others as arguments.
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, so 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)
-- "The type tree-of-a is a leaf, or a node of a, tree-of-a, and tree-of-a."
-- Pattern match union tags. The uppercase tags will 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 modules, as are any third-party
-- libraries you may use. For large projects, you can define your own modules.
-- Put this at the top of the file. If omitted, you're in Main.
module Name where
-- By default, everything is exported. You can specify exports explicity.
module Name (MyType, myValue) 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 definition.
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
-- See what changed between versions of a package.
$ elm package diff evancz/elm-html 3.0.0 4.0.2
-- 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 possibilities
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
* [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) and its cousin [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), commonly used for missing values or error handling
* Data structures like [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [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 by Elm's creator 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.
* [Scope in Elm](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) and [How to Read a Type Annotation](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). More community guides on the basics of Elm, written for JavaScript developers.
Go out and write some Elm!

2
es-es/brainfuck-es.html.markdown → es-es/bf-es.html.markdown
View File

@ -1,5 +1,5 @@
---
language: brainfuck
language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]

2
es-es/c++-es.html.markdown
View File

@ -1,6 +1,6 @@
---
language: c++
filename: learncpp.cpp
filename: learncpp-es.cpp
contributors:
- ["Steven Basart", "http://github.com/xksteven"]
- ["Matt Kline", "https://github.com/mrkline"]

226
es-es/forth-es.html.markdown Normal file
View File

@ -0,0 +1,226 @@
---
language: forth
contributors:
- ["Horse M.D.", "http://github.com/HorseMD/"]
translators:
- ["Zach Larsen", "http://zachariahlarsen.com/"]
lang: es-es
filename: learnforth-es.fs
---
Forth fue criado por Charles H. Moore en los 70s. Forth es un lenguaje imperativo, basado en pila y entorno de programación, siendo usado en proyectos como Open Firmware. También esta usado por NASA.
Nota: Este articulo enfoca predominantemente en la Gforth implementación de Forth, pero casi todo
de lo que esta escrito aquí debe funcionar en otro sitio.
```
\ Este es un comentario
( Este es un comentario también pero solo esta usado cuando definiendo palabras. )
\ --------------------------------- Precursor ----------------------------------
\ Todo programación en Forth se hace manipulando el parámetro pila (mas
\ común se refiere como "el pila").
5 2 3 56 76 23 65 \ ok
\ estos números se añadieron al pila desde izquierda a derecho.
.s \ <7> 5 2 3 56 76 23 65 ok
\ En Forth, todo es o una palabra o un numero.
\ ------------------------------ Básico Aritmética ------------------------------
\ Aritmética (de hecho casi todas palabras que requieren datos) funciona manipulando datos
\ en el pila.
5 4 + \ ok
\ `.` saca lo alto resulto desde el pila:
. \ 9 ok
\ Mas ejemplos de aritmética:
6 7 * . \ 42 ok
1360 23 - . \ 1337 ok
12 12 / . \ 1 ok
13 2 mod . \ 1 ok
99 negate . \ -99 ok
-99 abs . \ 99 ok
52 23 max . \ 52 ok
52 23 min . \ 23 ok
\ ----------------------------- Pila Manipulación -----------------------------
\ Naturalmente, cuando trabajaremos con el pila, querremos algunos metidos útiles:
3 dup - \ duplicar el primero articulo (1ra ahora igual a 2da): 3 - 3
2 5 swap / \ intercambiar la primera con la segunda elemento: 5 / 2
6 4 5 rot .s \ rotar los tres primero elementos: 4 5 6
4 0 drop 2 / \ sacar el primero articulo (no imprima a la pantalla): 4 / 2
1 2 3 nip .s \ sacar el segundo articulo (similar a drop): 1 3
\ ---------------------- Mas Avanzado Pila Manipulación ----------------------
1 2 3 4 tuck \ duplicar el primero articulo en el segundo hueco: 1 2 4 3 4 ok
1 2 3 4 over \ duplicar el segundo articulo a la primera del pila: 1 2 3 4 3 ok
1 2 3 4 2 roll \ *mover* el articulo en este posición a la primera del pila: 1 3 4 2 ok
1 2 3 4 2 pick \ *duplicar* el articulo en este posición a la primera del pila: 1 2 3 4 2 ok
\ Cuando refiere a pila indices, ellos son basado en cero.
\ ------------------------------ Creando Palabras --------------------------------
\ La `:` palabra hace que Forth entra modo de compilar hasta que se ve la `;` palabra.
: cuadrado ( n -- n ) dup * ; \ ok
5 cuadrado . \ 25 ok
\ Podemos ver lo que hace una palabra también.:
see cuadrado \ : cuadrado dup * ; ok
\ -------------------------------- Condicionales --------------------------------
\ -1 == cierto, 0 == falso. No obstante, valores que no son cero es usualmente tratado como
\ siendo cierto:
42 42 = \ -1 ok
12 53 = \ 0 ok
\ `if` es una palabra que solamente compila. `if` <cosas para hacer> `then` <los de mas del programa>.
: ?>64 ( n -- n ) dup 64 > if ." Mas que 64!" then ; \ ok
100 ?>64 \ Mas que 64! ok
\ Else:
: ?>64 ( n -- n ) dup 64 > if ." Mas que 64!" else ." Menos que 64!" then ;
100 ?>64 \ Mas que 64! ok
20 ?>64 \ Menos que 64! ok
\ ------------------------------------ Loops -----------------------------------
\ `do` también es una palabra que solamente compila.
: miloop ( -- ) 5 0 do cr ." Hola!" loop ; \ ok
miloop
\ Hola!
\ Hola!
\ Hola!
\ Hola!
\ Hola! ok
\ `do` espera dos números en el pila: el último numero y el primero numero.
\ Podemos recibir el valor del indice mientras damos vuelta con `i`:
: uno-a-12 ( -- ) 12 0 do i . loop ; \ ok
uno-a-12 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok
\ `?do` funciona similarmente, pero salta el loop si el último y primero
\ números son iguales.
: cuadrados ( n -- ) 0 ?do i cuadrado . loop ; \ ok
10 cuadrado \ 0 1 4 9 16 25 36 49 64 81 ok
\ cambiar el "paso" con `+loop`:
: treces ( n n -- ) ?do i . 3 +loop ; \ ok
15 0 treces \ 0 3 6 9 12 ok
\ Indefinido loops empiezan `begin` <cosas para hacer> <bandera> `until`:
: death ( -- ) begin ." Ya hemos llegado?" 0 until ; \ ok
\ ---------------------------- Variables y Memoria ----------------------------
\ Use `variable` declarar `edad` ser un variable.
variable edad \ ok
\ Ahora escribimos 21 a edad con la palabra `!`.
21 edad ! \ ok
\ Por fin podemos imprimir nuestro variable usando la "leer" palabra `@`, que agregue el
\ valor a la pila, or usa `?` que lee y imprime todo juntos.
edad @ . \ 21 ok
edad ? \ 21 ok
\ Constantes son muy similar, pero no nos importa los direcciones de memoria:
100 constant PUNTA-QUE-AQUA-HIERVA \ ok
PUNTA-QUE-AQUA-HIERVA . \ 100 ok
\ ----------------------------------- Arrays -----------------------------------
\ Creando arrays es similar a variables, pero necesitamos alocar mas
\ memoria a ellos.
\ Puede usar `2 cells allot` para crear un array que es sea 3 cédulas de tamaño:
variable minumeros 2 cells allot \ ok
\ Inicializar todos los valores a 0
minumeros 3 cells erase \ ok
\ Alternativamente podemos usar `fill`:
minumeros 3 cells 0 fill
\ o podemos saltar todo arriba y inicializar con valores específicos:
create minumeros 64 , 9001 , 1337 , \ ok (el último `,` es importante!)
\ ...que es equivalente a:
\ Manualmente escribiendo valores a cada indice:
64 minumeros 0 cells + ! \ ok
9001 minumeros 1 cells + ! \ ok
1337 minumeros 2 cells + ! \ ok
\ Leyendo valores en particular array indices:
0 cells minumeros + ? \ 64 ok
1 cells minumeros + ? \ 9001 ok
\ Podemos simplificar un poco cuando hacemos una palabra que ayuda cuando manipulando arrays:
: de-arr ( n n -- n ) cells + ; \ ok
minumeros 2 de-arr ? \ 1337 ok
\ Que podemos usar cuando escribimos también:
20 minumeros 1 de-arr ! \ ok
minumeros 1 de-arr ? \ 20 ok
\ ------------------------------ El Pila de Regreso ------------------------------
\ El pila de regreso se usa para retener punteros a cosas cuando palabras están
\ ejecutando otras palabras como loops.
\ Ya hemos visto un uso de esto: `i`, que duplica el primero del pila
\ de regreso. `i` es equivalente a `r@`.
: miloop ( -- ) 5 0 do r@ . loop ; \ ok
\ También como leyendo, podemos agregar al pila de regreso y sacarlo:
5 6 4 >r swap r> .s \ 6 5 4 ok
\ NOTA: Porque Forth usa el pila de regreso por punteros de palabras, `>r` debe
\ siempre ser seguido por un `r>`.
\ ------------------------- Flotante Punto Operaciones --------------------------
\ La mayoría Forths evitan el uso de flotante punto operaciones.
8.3e 0.8e f+ f. \ 9.1 ok
\ Usualmente agregamos al frente palabras con 'f' cuando usando flotantes:
variable miflotantevar \ ok
4.4e miflotantevar f! \ ok
miflotantevar f@ f. \ 4.4 ok
\ --------------------------------- Notas al Final --------------------------------
\ Usando una palabra que no existe vaciara el pila. No obstante, también hay una palabra
\ específicamente por esto:
clearstack
\ vaciar la pantalla:
page
\ Cargando Forth archivos:
\ s" archivodeforth.fs" included
\ Puede listar cada palabra en el diccionario de Forth (pero es una lista gigante!):
\ words
\ Terminando Gforth:
\ bye
```
##Listo Para Mas?
* [Starting Forth](http://www.forth.com/starting-forth/)
* [Simple Forth](http://www.murphywong.net/hello/simple.htm)
* [Thinking Forth](http://thinking-forth.sourceforge.net/)

307
es-es/hack-es.html.markdown Normal file
View File

@ -0,0 +1,307 @@
---
language: Hack
contributors:
- ["Stephen Holdaway", "https://github.com/stecman"]
- ["David Lima", "https://github.com/davelima"]
translators:
- ["César Suárez", "https://github.com/csuarez"]
lang: es-es
filename: learnhack-es.hh
---
Hack es un superconjunto de PHP que se ejecuta en una máquina virtual llamada HHVM. Hack es casi totalmente compatible con código PHP ya existente y añade varias características típicas de los lenguajes de programación estáticamente tipados.
En este artículo sólo se cubren las características específicas de Hack. Los detalles sobre la sintaxis de PHP están en el [artículo sobre PHP](http://learnxinyminutes.com/docs/php/) de esta misma web.
```php
<?hh
// La sintaxis de Hack sólo se habilita para los ficheros que comienzan con
// un marcador <?hh. Estos marcadores no pueden intercalarse con código HTML,
// tal como se puede hacer con <?php. Al usar el marcador "<?hh //strict" el
// comprobador de tipado en modo estricto se pone en modo estricto.
// Indicando el tipo de parámetros escalares
function repeat(string $word, int $count)
{
$word = trim($word);
return str_repeat($word . ' ', $count);
}
// Indicando el tipo que devuelve una función
function add(...$numbers) : int
{
return array_sum($numbers);
}
// Las funciones que no devuelven nada usan el tipo "void"
function truncate(resource $handle) : void
{
// ...
}
// Al determinar un tipo, hay que indicar explícitamente si permite el valor
// NULL
function identity(?string $stringOrNull) : ?string
{
return $stringOrNull;
}
// Se puede especificar el tipo de las propiedades de una clase
class TypeHintedProperties
{
public ?string $name;
protected int $id;
private float $score = 100.0;
// El comprobador de tipos de Hack fuerza que las propiedades tipadas
// tengan un valor por defecto o que estén asignadas en el constructor
public function __construct(int $id)
{
$this->id = $id;
}
}
// Funciones anónimas concisas (lambdas)
$multiplier = 5;
array_map($y ==> $y * $multiplier, [1, 2, 3]);
// Genéricos
class Box<T>
{
protected T $data;
public function __construct(T $data) {
$this->data = $data;
}
public function getData(): T {
return $this->data;
}
}
function openBox(Box<int> $box) : int
{
return $box->getData();
}
// Shapes
//
// Hack añade el concepto de shape para definir estructuras similares a
// vectores, pero con un conjunto de claves garantizado y tipado
type Point2D = shape('x' => int, 'y' => int);
function distance(Point2D $a, Point2D $b) : float
{
return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
}
distance(
shape('x' => -1, 'y' => 5),
shape('x' => 2, 'y' => 50)
);
// Alias de tipos
//
// Hack permite crear alias para hacer que los tipos complejos sean más legibles
newtype VectorArray = array<int, Vector<int>>;
// Una tupla que contiene dos enteros
newtype Point = (int, int);
function addPoints(Point $p1, Point $p2) : Point
{
return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
}
addPoints(
tuple(1, 2),
tuple(5, 6)
);
// Enumerados de primera clase
enum RoadType : int
{
Road = 0;
Street = 1;
Avenue = 2;
Boulevard = 3;
}
function getRoadType() : RoadType
{
return RoadType::Avenue;
}
// Promoción de argumentos en constructores
//
// Para evitar repetir una y otra vez la definición de constructores que
// sólo asignan propiedades, Hack añade una sintaxis concisa para definir
// propiedades junto al constructor.
class ArgumentPromotion
{
public function __construct(public string $name,
protected int $age,
private bool $isAwesome) {}
}
class WithoutArgumentPromotion
{
public string $name;
protected int $age;
private bool $isAwesome;
public function __construct(string $name, int $age, bool $isAwesome)
{
$this->name = $name;
$this->age = $age;
$this->isAwesome = $isAwesome;
}
}
// Multitarea cooperativa
//
// "async" y "await" son dos palabras claves nuevas para realizar multi-tarea.
// Esto no implica que se usen hilos, sólo permiten transferir el control de la
// ejecución.
{
for ($i = $start; $i <= $end; $i++) {
echo "$i ";
// Da a otras tareas la oportunidad de hacer algo
await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
}
}
// Esto imprime "1 4 7 2 5 8 3 6 9"
AwaitAllWaitHandle::fromArray([
cooperativePrint(1, 3),
cooperativePrint(4, 6),
cooperativePrint(7, 9)
])->getWaitHandle()->join();
// Atributos
//
// Los atributos son una especie de metadatos para funciones. Hack implementa
// algunos atributos especiales para introducir esta característica.
// El atributo especial __Memoize hace que el resultado de la función se cacheé.
<<__Memoize>>
function doExpensiveTask() : ?string
{
return file_get_contents('http://example.com');
}
// Esta función se va a ejecutar sólo una vez:
doExpensiveTask();
doExpensiveTask();
// El atributo __ConsistentConstruct indica al comprobador de tipos de Hack que
// asegure que la signatura de __construct sea la misma para todas las
// subclases.
<<__ConsistentConstruct>>
class ConsistentFoo
{
public function __construct(int $x, float $y)
{
// ...
}
public function someMethod()
{
// ...
}
}
class ConsistentBar extends ConsistentFoo
{
public function __construct(int $x, float $y)
{
// El comprobador de tipos de Hack fuerza que los constructores de
// los padres sean llamados.
parent::__construct($x, $y);
// ...
}
// La anotación __Override es un atributo opcional para que el comprobador
// de tipos fuerce que ese método esté sobrecargando un método de un padre
// o de un trait. Sino, fallará.
<<__Override>>
public function someMethod()
{
// ...
}
}
class InvalidFooSubclass extends ConsistentFoo
{
// Este constructor no coincide con el padre y causará el siguiente error:
//
// "This object is of type ConsistentBaz. It is incompatible with this
// object of type ConsistentFoo because some of their methods are
// incompatible"
public function __construct(float $x)
{
// ...
}
// Usando la anotación __Override en un método que no sobrecarga nada se
// producirá el siguiente error:
//
// "InvalidFooSubclass::otherMethod() is marked as override; no non-private
// parent definition found or overridden parent is defined in non-<?hh
// code"
<<__Override>>
public function otherMethod()
{
// ...
}
}
// Los traits pueden implementar interfaces (PHP no soporta esto).
interface KittenInterface
{
public function play() : void;
}
trait CatTrait implements KittenInterface
{
public function play() : void
{
// ...
}
}
class Samuel
{
use CatTrait;
}
$cat = new Samuel();
$cat instanceof KittenInterface === true; // True
```
## Más información
Para obtener una explicación más detallada de las características que añade Hack a PHP visita la página de [referencia de Hack](http://docs.hhvm.com/manual/en/hacklangref.php) o la [página oficial de Hack](http://hacklang.org/) para información de caracter más general.
Visita la [página oficial de HHVM](http://hhvm.com/) para ver las instrucciones de su instalación.
También puedes visitar la [sección de características de PHP no soportadas por Hack](http://docs.hhvm.com/manual/en/hack.unsupported.php) para más detalles sobre la retrocompatibilidad entre Hack y PHP.

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

@ -23,7 +23,9 @@ Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto
[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
```js
// Los comentarios son como en C. Los comentarios de una sola línea comienzan con //,
// Los comentarios en JavaScript son los mismos como comentarios en C.
//Los comentarios de una sola línea comienzan con //,
/* y los comentarios multilínea comienzan
y terminan con */

213
es-es/latex-es.html.markdown Normal file
View File

@ -0,0 +1,213 @@
---
language: latex
lang: es-es
contributors:
- ["Chaitanya Krishna Ande", "http://icymist.github.io"]
- ["Colton Kohnke", "http://github.com/voltnor"]
- ["Sricharan Chiruvolu", "http://sricharan.xyz"]
translators:
- ["Mario Pérez", "https://github.com/MarioPerezEsteso"]
filename: learn-latex-es.tex
---
```tex
% Todas las líneas comentadas comienzan con %
% No existen los comentarios multilínea
% LaTeX NO es un software de procesamiento de texto que cumple con
% "Lo que ves es lo que tienes" como MS Word u OpenOffice
% Todos los comandos de LaTeX comienzan con una contrabarra (\)
% Los documentos LaTeX comienzan definiendo el tipo de documento que se va a
% compilar. Algunos tipos de documentos son libros, informes, presentaciones,
% etc. Las opciones para el documento comienzan en los corchetes []. En este
% caso, se especifica que queremos utilizar una fuente de tamaño 12pt.
\documentclass[12pt]{article}
% A continuación, definimos los paquetes que utilizará el documento.
% Si quieres incluir gráficos, texto coloreado o código fuente de otro lenguaje,
% debes extender las funciones de LaTeX. Esto se consigue añadiendo paquetes.
% A continuación se incluirán los paquetes float y caption para figuras.
\usepackage{caption}
\usepackage{float}
% También podemos definir otras propiedades en el documento
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
\date{\today}
\title{Learn LaTeX in Y Minutes!}
% Ahora estamos preparados para comenzar el documento
% Todo lo que se encuentre antes de esta línea se llama "El Preámbulo"
\begin{document}
% Si especificamos el autor, fecha y título, LaTeX creará una página como título
% por nosotros
\maketitle
% La mayoría de los artículos de investigación tienen un abstract. Es posible
% utilizar comandos predefinidos para ello.
% Esto debería aparecer en su orden lógico. Tras el título pero antes de las
% secciones principales del cuerpo.
% Este comando está disponible en los tipos de documentos article y report.
\begin{abstract}
Documentación de LaTex escrita en LaTex.
\end{abstract}
% Los comandos de sección son intuitivos.
% Todos los títulos de secciones son añadidos automáticamente a la tabla de contenidos.
\section{Introducción}
Hola, mi nombre es Mario Pérez y estoy traduciendo este documento para aprender LaTex.
\section{Otra sección}
Este es el texto de otra sección. Creo que necesitará una subsección.
\subsection{Esto es una subsección} % Las subsecciones también son fáciles.
Creo que necesitamos otra más.
\subsubsection{Pitágoras}
Mejor ahora.
\label{subsec:pitagoras}
% Utilizando el asterisco podemos decirle a LaTeX que no ponga los números de secciones y subsecciones.
% Esto también funciona con otros comandos de LaTeX.
\section*{Esto es una sección no numerada}
¡No todas las secciones tienen que estar numeradas!
\section{Algunas notas}
LaTeX es generalmente bastante bueno situando el texto donde debe ir. Si una lína \\ necesita \\ ser \\ rota \\ puedes poner \textbackslash\textbackslash en el código fuente. \\
\section{Listas}
Las listas son de las cosas más fáciles de crear en LaTeX. Necesito ir a comprar mañana, así que vamos a crear una lista de la compra.
\begin{enumerate} % Esto crea una lista numerada.
% \item crea un elemento
\item Ensalada.
\item 27 sandías.
\item Pescado.
% podemos incluso sobreescribir el número del ítem usando []
\item[cuántos?] Plátanos.
No es un ítem de la lista, pero sigue siendo parte de la enumeración.
\end{enumerate} % Todos los contextos deben tener un final.
\section{Matemáticas}
Uno de los usos principales de LaTeX es la producción de artículos académicos o técnicos. Normalmente relacionados con la ciencia y las matemáticas. Debido a esto, necesitamos poder añadir símbolos especiales a nuestro artículo.\\
En matemáticas hay muchos símbolos. Más de los que podemos encontrar en un teclado. Flechas o letras por nombrar un par.\\
Algunos símbolos juegan un papel fundamental en muchos artículos de investigación matemática. Así es como se establece que todo Y pertenece a X: $\forall$ x $\in$ X. \\
He necesitado añadir el signo $ antes de los símbolos. Esto se debe a que cuando escribimos, estamos en modo texto. Sin embargo, los símbolos solo pueden utilizarse en modo matemático, al cual se entra con el signo $.
% Lo opuesto también se cumple. Una variable también puede ser mostrada en modo matemático, al que también se puede entrar con \[\]
\[a^2 + b^2 = c^2 \]
Mi letra griega favorita es $\xi$. También me gustan $\beta$, $\gamma$ y $\sigma$.
Todavía no he encontrado una letra griega que LaTeX no conozca.
Los operadores son también una parte esencial de un documento matemático:
funciones trigonométricas ($\sin$, $\cos$, $\tan$), logaritmos y exponenciales ($\log$, $\exp$), límites ($\lim$), etc. tienen comandos predefinidos en LaTeX.
Vamos a escribir una ecuación para ver cómo se hace: \\
$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
Las fracciones (numeradores-denominadores) pueden escribirse de la siguiente forma:
% 10 / 7
$^{10}/_{7}$
% Las fracciones relativamente complejas pueden escribirse como
% \frac{numerador}{denominador}
$\frac{n!}{k!(n - k)!}$ \\
También podemos insertar ecuaciones en un contexto de ecuación.
% Mostrar matemáticas en el contexto de ecuaciones
\begin{equation} % entra en modo matemático
c^2 = a^2 + b^2.
\label{eq:pitagoras} % para referencias
\end{equation} % Todos los contextos deben tener un final.
Podemos referenciar nuestra nueva ecuación.
Ecuación ~\ref{eq:pythagoras} también se conoce como el Teorema de Pitágoras, el cual también se encuentra en la sección ~\ref{subsec:pythagoras}. Muchas cosas pueden ser etiquetadas: figures, equations, sections, etc.
Los sumatorios e integrales son escritor son los comandos sum e int:
% Algunos compiladores de LaTeX se quejarán si hay líneas en blanco
% En un contexto de ecuación.
\begin{equation}
\sum_{i=0}^{5} f_{i}
\end{equation}
\begin{equation}
\int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
\end{equation}
\section{Figuras}
Vamos a insertar una figura. Situarla puede ser algo complicado.
\begin{figure}[H] % H aquí establece la situación de la figura.
\centering % centra la figura en la página
% Inserta una figura escalada por 0.8 el ancho de la página.
%\includegraphics[width=0.8\linewidth]{right-triangle.png}
% La línea anterior ha sido comentada para poder compilar este archivo. Por favor, usa tu imaginación.
\caption{Triángulo con lados $a$, $b$, $c$}
\label{fig:right-triangle}
\end{figure}
\subsection{Tablas}
También podemos insertar tablas de la misma manera que las figuras.
\begin{table}[H]
\caption{Título para la tabla.}
% los argumentos en {} describen cómo cada fila va a ser representada.
\begin{tabular}{c|cc}
Número & Nombre & Apellido \\
\hline % una línea horizontal
1 & Biggus & Dickus \\
2 & Monty & Python
\end{tabular}
\end{table}
% \section{Hyperlinks} % En construcción
\section{Haciendo que LaTeX no compile algo (por ejemplo, código fuente)}
Digamos que queremos incluir código fuente dentro de nuestro documento LaTex. En ese caso, debemos indicarle a LaTeX que no trate de compilarlo y simplemente lo muestre en el documento. Esto lo realizamos en el contexto verbatim.
% Hay otros paquetes para esta misma tarea, pero verbatim es el más básico.
\begin{verbatim}
print("Hola Mundo!")
a%b; % Podemos usar los signos % en verbatim.
aleatorio = 4; # Número aleatorio
\end{verbatim}
\section{Compilación}
Ahora mismo te estarás preguntando cómo compilar este fabuloso documento y obtener un documento PDF.\\
Para obtener el documento final utilizando LaTeX hay que seguir los siguientes pasos:
\begin{enumerate}
\item Escribe el documento en texto plano.
\item Compila el código para producir un PDF.
Los pasos de compilación serán algo parecido a esto (en Linux): \\
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
\end{verbatim}
\end{enumerate}
Un gran número de editores LaTeX combinan ambos pasos para que sea más sencillo obtener el documento.
Escribe toda la información de formato en el paso 1 y con el paso 2 obtendrás el documento que has definido en el paso anterior.
\section{End}
Esto es todo por ahora.
% fin del documento
\end{document}
```
## Más información sobre LaTeX
* El wikilibro LaTeX: [https://es.wikibooks.org/wiki/Manual_de_LaTeX](https://es.wikibooks.org/wiki/Manual_de_LaTeX)
* Un tutorial real: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)

10
es-es/markdown-es.html.markdown
View File

@ -57,8 +57,8 @@ __Al igual que este texto.__
**_Al igual que este!_**
*__¡Y este!__*
<!-- En Github Flavored Markdown, el cual es usado para mostrar archivos
Markdown en Github, también tenemos: -->
<!-- En GitHub Flavored Markdown, el cual es usado para mostrar archivos
Markdown en GitHub, también tenemos: -->
~~Este texto está tachado.~~
@ -150,7 +150,7 @@ para indentar dentro del código -->
¡John no sabía lo que la función `go_to()` hacía!
<!-- Con Github Flavored Markdown, puedes usar una sintaxis especial para código -->
<!-- Con GitHub Flavored Markdown, puedes usar una sintaxis especial para código -->
\`\`\`ruby <!-- quita esas comillas cuando lo hagas, deja sólo ```ruby ! -->
def foobar
@ -158,7 +158,7 @@ def foobar
end
\`\`\` <!-- aquí también, sin comillas, sólo ``` -->
<!-- El texto de arriba no necesita indentación, aparte Github usará
<!-- El texto de arriba no necesita indentación, aparte GitHub usará
resaltará la sintaxis del lenguaje que especifiques después de ``` -->
<!-- Regla horizontal (<hr />) -->
@ -231,7 +231,7 @@ Quiero escribir *este texto rodeado por asteriscos* pero no quiero que esté en
así que hago esto: \*Este texto está rodeado de asteriscos\*.
<!-- Tablas -->
<!-- Las tablas sólo están disponibles en Github Flavored Markdown y son un poco pesadas,
<!-- Las tablas sólo están disponibles en GitHub Flavored Markdown y son un poco pesadas,
pero si de verdad las quieres: -->
| Col1 | Col2 | Col3 |

851
es-es/objective-c-es.html.markdown Normal file
View File

@ -0,0 +1,851 @@
---
language: Objective-C
contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- ["Yannick Loriot", "https://github.com/YannickL"]
- ["Levi Bostian", "https://github.com/levibostian"]
translators:
- ["David Hsieh", "http://github.com/deivuh"]
lang: es-es
filename: LearnObjectiveC-es.m
---
Objective C es el lenguaje de programación principal utilizado por Apple para los sistemas operativos OS X y iOS y sus respectivos frameworks, Cocoa y Cocoa Touch.
Es un lenguaje de programación para propósito general que le agrega al lenguaje de programación C una mensajería estilo "Smalltalk".
```objective_c
// Los comentarios de una sola línea inician con //
/*
Los comentarios de múltiples líneas se ven así.
*/
// Importa los encabezados de Foundation con #import
// Utiliza <> para importar archivos globales (generalmente frameworks)
// Utiliza "" para importar archivos locales (del proyecto)
#import <Foundation/Foundation.h>
#import "MyClass.h"
// Si habilitas módulos para proyectos de iOS >= 7.0 u OS X >= 10.9 en
// Xcode 5, puedes importarlos de la siguiente manera:
@import Foundation;
// El punto de entrada de tu programa es una función llamada
// main con un tipo de retorno entero.
int main (int argc, const char * argv[])
{
// Crear un autorelease pool para manejar la memoria al programa
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
// Si se utiliza el conteo automático de referencias (ARC),
// utiliza @autoreleasepool:
@autoreleasepool {
// Utiliza NSLog para imprimir líneas a la consola
NSLog(@"Hello World!"); // Imprimir el string "Hello World!"
///////////////////////////////////////
// Tipos y variables
///////////////////////////////////////
// Declaraciones de primitivos
int myPrimitive1 = 1;
long myPrimitive2 = 234554664565;
// Declaraciones de objetos
// Pon el * como prefijo de los nombre de las variables para declaraciones
// de objetos de tipos fuertes
MyClass *myObject1 = nil; // Tipo fuerte
id myObject2 = nil; // Tipo débil
// %@ es un objeto
// 'description' es una convención para mostrar el valor de los objetos
NSLog(@"%@ and %@", myObject1, [myObject2 description]);
// imprime => "(null) and (null)"
// String
NSString *worldString = @"World";
NSLog(@"Hello %@!", worldString); // imprime => "Hello World!"
// NSMutableString es una versión mutable del objeto NSString
NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
[mutableString appendString:@" World!"];
NSLog(@"%@", mutableString); // imprime => "Hello World!"
// Literales de caracteres
NSNumber *theLetterZNumber = @'Z';
char theLetterZ = [theLetterZNumber charValue]; // o 'Z'
NSLog(@"%c", theLetterZ);
// Literales de enteros
NSNumber *fortyTwoNumber = @42;
int fortyTwo = [fortyTwoNumber intValue]; // o 42
NSLog(@"%i", fortyTwo);
NSNumber *fortyTwoUnsignedNumber = @42U;
unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // o 42
NSLog(@"%u", fortyTwoUnsigned);
NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
short fortyTwoShort = [fortyTwoShortNumber shortValue]; // o 42
NSLog(@"%hi", fortyTwoShort);
NSNumber *fortyOneShortNumber = [NSNumber numberWithShort:41];
unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // o 41
NSLog(@"%u", fortyOneUnsigned);
NSNumber *fortyTwoLongNumber = @42L;
long fortyTwoLong = [fortyTwoLongNumber longValue]; // o 42
NSLog(@"%li", fortyTwoLong);
NSNumber *fiftyThreeLongNumber = @53L;
unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // o 53
NSLog(@"%lu", fiftyThreeUnsigned);
// Literales de punto flotante
NSNumber *piFloatNumber = @3.141592654F;
float piFloat = [piFloatNumber floatValue]; // o 3.141592654f
NSLog(@"%f", piFloat); // imprime => 3.141592654
NSLog(@"%5.2f", piFloat); // imprime => " 3.14"
NSNumber *piDoubleNumber = @3.1415926535;
double piDouble = [piDoubleNumber doubleValue]; // o 3.1415926535
NSLog(@"%f", piDouble);
NSLog(@"%4.2f", piDouble); // imprime => "3.14"
// NSDecimalNumber es una clase de punto-fijo que es más preciso que float o double
NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
// NSDecimalNumber no tiene la capacidad de utilizar los operadores estándares
// +, -, * , /, por lo que cuenta con sus propios operadores:
[oneDecNum decimalNumberByAdding:twoDecNum];
[oneDecNum decimalNumberBySubtracting:twoDecNum];
[oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
[oneDecNum decimalNumberByDividingBy:twoDecNum];
NSLog(@"%@", oneDecNum); // imprime => 10.99 como NSDecimalNumber es inmutable
// Literales BOOL
NSNumber *yesNumber = @YES;
NSNumber *noNumber = @NO;
// o
BOOL yesBool = YES;
BOOL noBool = NO;
NSLog(@"%i", yesBool); // prints => 1
// Objecto arreglo
// Puede contener diferentes tipos de datos, pero deben de ser un objeto de
// Objective-C
NSArray *anArray = @[@1, @2, @3, @4];
NSNumber *thirdNumber = anArray[2];
NSLog(@"Third number = %@", thirdNumber); // imprime => "Third number = 3"
// NSMutableArray es una versión mutable de NSArray, permitiendo el cambio
// de los elementos del arreglo y el agrandado o encojimiento del objeto arreglo.
// Conveniente, pero no tan eficiente como NSArray en cuanto a rendimiento.
NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
[mutableArray addObject:@"Hello"];
[mutableArray addObject:@"World"];
[mutableArray removeObjectAtIndex:0];
NSLog(@"%@", [mutableArray objectAtIndex:0]); // imprime => "World"
// Objecto Diccionario
NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
NSObject *valueObject = aDictionary[@"A Key"];
NSLog(@"Object = %@", valueObject); // imprime => "Object = (null)"
// NSMutableDictionary también está disponible como un objeto mutable
NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
[mutableDictionary setObject:@"value1" forKey:@"key1"];
[mutableDictionary setObject:@"value2" forKey:@"key2"];
[mutableDictionary removeObjectForKey:@"key1"];
// Objeto de Set
NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
NSLog(@"%@", set); // imprime => {(Hello, World)} (el orden puede variar)
// NSMutableSet también está disponible como un objeto mutable
NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
[mutableSet addObject:@"Hello"];
[mutableSet addObject:@"Hello"];
NSLog(@"%@", mutableSet); // prints => {(Hello)}
///////////////////////////////////////
// Operadores
///////////////////////////////////////
// Los operadores funcionan como en el lenguaje C
// Por ejemplo:
2 + 5; // => 7
4.2f + 5.1f; // => 9.3f
3 == 2; // => 0 (NO)
3 != 2; // => 1 (YES)
1 && 1; // => 1 (and lógico)
0 || 1; // => 1 (or lógico)
~0x0F; // => 0xF0 (negación bitwise)
0x0F & 0xF0; // => 0x00 (AND bitwise)
0x01 << 1; // => 0x02 (acarreamiento a la izquierda bitwise (por 1))
///////////////////////////////////////
// Estructuras de control
///////////////////////////////////////
// Declaraciones If-Else
if (NO)
{
NSLog(@"I am never run");
} else if (0)
{
NSLog(@"I am also never run");
} else
{
NSLog(@"I print");
}
// Declaración Switch
switch (2)
{
case 0:
{
NSLog(@"I am never run");
} break;
case 1:
{
NSLog(@"I am also never run");
} break;
default:
{
NSLog(@"I print");
} break;
}
// Declaración de ciclos While
int ii = 0;
while (ii < 4)
{
NSLog(@"%d,", ii++); // ii++ incrementa ii en la misma línea, luego de
// utilizar su valor
} // imprime => "0,"
// "1,"
// "2,"
// "3,"
// Declaración de ciclos For
int jj;
for (jj=0; jj < 4; jj++)
{
NSLog(@"%d,", jj);
} // imprime => "0,"
// "1,"
// "2,"
// "3,"
// Declaraciones foreach
NSArray *values = @[@0, @1, @2, @3];
for (NSNumber *value in values)
{
NSLog(@"%@,", value);
} // imprime => "0,"
// "1,"
// "2,"
// "3,"
// Objeto de ciclos For. Puede ser utilizado con cualquier tipo de objecto de
// Objective-C
for (id item in values) {
NSLog(@"%@,", item);
} // imprime => "0,"
// "1,"
// "2,"
// "3,"
// Declaraciones Try-Catch-Finally
@try
{
// Tus declaraciones aquí
@throw [NSException exceptionWithName:@"FileNotFoundException"
reason:@"File Not Found on System" userInfo:nil];
} @catch (NSException * e) // utiliza: @catch (id exceptionName) para atrapar
// todos los objetos
{
NSLog(@"Exception: %@", e);
} @finally
{
NSLog(@"Finally. Time to clean up.");
} // imprime => "Exception: File Not Found on System"
// "Finally. Time to clean up."
// Los objetos NSError son útiles para argumentos de función para los
// errores de usuario.
NSError *error = [NSError errorWithDomain:@"Invalid email." code:4 userInfo:nil];
///////////////////////////////////////
// Objetos
///////////////////////////////////////
// Crea una instancia de objeto alocando memoria e inicializándola
// Un objeto no es completamente funcional hasta que ambos pasos hayan sido
// completados
MyClass *myObject = [[MyClass alloc] init];
// El modelo de programación orientada a objetos de Objective-C es basada en
// el envío de mensajes a instancias de objetos
// En Objective-C no se llama a un método; se envía un mensaje
[myObject instanceMethodWithParameter:@"Steve Jobs"];
// Limpiar la memoria que se utilizó en el programa
[pool drain];
// Fin de @autoreleasepool
}
// Fin del programa
return 0;
}
///////////////////////////////////////
// Clases y funciones
///////////////////////////////////////
// Declara tu clase en archivo de encabezado (MyClass.h)
// Sintaxis de declaración de clase:
// @interface NombreDeClase : NombreDeClasePadre <ProtocolosImplementados>
// {
// type nombre; <= declaraciones de variables;
// }
// @property tipo nombre; <= declaración de propiedades
// -/+ (tipo) Declaración de método; <= Declaración de método
// @end
@interface MyClass : NSObject <MyProtocol> // NSObject es la clase de objeto
// base de Objective-C.
{
// Declaraciones de variables de instancia (puede existir en el archivo de
// interfaz o de implementación)
int count; // Acceso protegido por defecto.
@private id data; // Acceso privado (Más conveniente de declarar en el
// archivo de implementación)
NSString *name;
}
// Notación conveneinte para acceso público de las variables para generar un
// método setter
// Por defecto, el nombre del método setter 'set' seguido del nombre de
// variable @property
@property int propInt; // Nombre del método 'setter' = 'setPropInt'
@property (copy) id copyId; // (copy) => Copia el objeto durante la asignación
// (readonly) => No se le puede asignar un valor fuera de @interface
@property (readonly) NSString *roString; // utiliza @synthesize en
// @implementation para crear un accesor
// Puedes personalizar el nombre del getter y del setter en lugar de utilizar
// el nombre por defecto "set".
@property (getter=lengthGet, setter=lengthSet:) int length;
// Métodos
+/- (return type)methodSignature:(Parameter Type *)parameterName;
// + Para métodos de clase:
+ (NSString *)classMethod;
+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight;
// - Para métodos de instancia:
- (NSString *)instanceMethodWithParameter:(NSString *)string;
- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
// Métodos de constructor con argumentos
- (id)initWithDistance:(int)defaultDistance;
// Los nombres de los métodos de Objective-C son muy descriptivos.
// Siempre nombra los métodos de acuerdo con sus argumentos
@end // Define el final de la interfaz
// Para acceder a las variables públicas desde el archivo de implementación,
// @property genera un método setter automáticamente. El nombre del método
// es 'set' seguido de un nombre de variable @property:
MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia del objeto MyClass
[myClass setCount:10];
NSLog(@"%d", [myClass count]); // imprime => 10
// O utilizando los métodos getter y setter personalizados en @interface:
[myClass lengthSet:32];
NSLog(@"%i", [myClass lengthGet]); // imprime => 32
// Por conveniencia, puedes utilizar la notación de punto para asignar y
// acceder a las variables de una instancia de objeto.
myClass.count = 45;
NSLog(@"%i", myClass.count); // imprime => 45
// Llama a métodos de clase:
NSString *classMethodString = [MyClass classMethod];
MyClass *classFromName = [MyClass myClassFromName:@"Hello"];
// Llama a métodos de instancia:
MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia de objeto Myclass
NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hello"];
// Selectors
// Una forma dinámica de representar métodos. Utilizados para llamar métodos
// de una clase, pasar métodos a través de funciones para avisar a otras clases
// para que lo llamen, y para guardar métodos como una variable.
// SEL es el tipo de dato. @selector() devuelve un selector del nombre de
// método proveído methodAparameterAsString:andAParameterAsNumber: es un nombre
// para un método en MyClass
SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:);
if ([myClass respondsToSelector:selectorVar]) { // Revisa si la clase contiene el método
// Debe de poner todos los argumentos de método en un solo objeto para mandar una
// función performSelector.
NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
[myClass performSelector:selectorVar withObject:arguments]; // Calls the method
} else {
// NSStringFromSelector() devuelve un NSString del nombre de método de un selector dado
NSLog(@"MyClass does not have method: %@", NSStringFromSelector(selectedVar));
}
// Implementa los métodos de un archivo de implementación (MyClass.m):
@implementation MyClass {
long distance; // Variable de instancia de acceso privado
NSNumber height;
}
// Para acceder a una variable pública del archivo de interfaz, utiliza '_' seguido del
// nombre de la variable:
_count = 5; // Hace referencia a "int count" de la interfaz de MyClass
// Accede variables definidas en el archivo de implementación:
distance = 18; // Hace referencia a "long distance" de la implementación de MyClass
// Para utilizar una variable @property en el archivo de implementación, utiliza
// @synthesize para crear una variable de acceso:
@synthesize roString = _roString; // _roString ahora está disponible en @implementation
// Lamado antes de llamar algún método o instanciar cualquier objeto
+ (void)initialize
{
if (self == [MyClass class]) {
distance = 0;
}
}
// Contraparte para inicializar un método. Llamado cuando el contador de referencias
// del objeto es cero
- (void)dealloc
{
[height release]; // Si no utilizas ARC, asegúrate de liberar las variables de
// objeto de las clases
[super dealloc]; // y llama el método dealloc de la clase padre
}
// Los constructores son una manera de crear instancias de una clase
// Este es el constructor por defecto que es llamado cuando el objeto es inicializado.
- (id)init
{
if ((self = [super init])) // 'super' es utilizado para acceder a los
// métodos de la clase padre.
{
self.count = 1; // 'self' es utilizado para que el objeto se llame a sí mismo.
}
return self;
}
// Se pueden crear constructores que contiene argumentos
- (id)initWithDistance:(int)defaultDistance
{
distance = defaultDistance;
return self;
}
+ (NSString *)classMethod
{
return @"Some string";
}
+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight
{
height = defaultHeight;
return [[self alloc] init];
}
- (NSString *)instanceMethodWithParameter:(NSString *)string
{
return @"New string";
}
- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
{
return @42;
}
// Objective-C no tiene declaraciones de métodos privados, pero pueden ser simulados.
// Para simular un método privado, crea un método en @implementation pero no en @interface.
- (NSNumber *)secretPrivateMethod {
return @72;
}
[self secretPrivateMethod]; // Calls private method
// Métodos declarados dentro de MyProtocol
- (void)myProtocolMethod
{
// statements
}
@end // Declara el final de la implementación
///////////////////////////////////////
// Categorías
///////////////////////////////////////
// Una categoría es un grupo de métodos diseñados para extender una clase.
// Te permiten agregar nuevos métodos a una clase existente por propósitos
// de organización. Éstos no deben de serconfundidos con subclases.
// Las subclases existen para CAMBIAR la funcionalidad de un objeto mientras
// que las categoríasle AGREGAN funcionalidad de un objeto.
// Las categorías te permiten:
// -- Agregar métodos a una clase existente por propósitos de oganización.
// -- Extender clases de objetos de Objective-C (ejemplo: NSString) para
// agregar tus propios métodos.
// -- Agregar la habilidad de crear métodos protegidos y privados para las clases.
// NOTA: No sobreescribas los métodos de las clases base en una categoría
// aunque tengas la habilidad de poder hacerlo. Sobreescribir métodos puede
// causar errores en la compilación después entre diferentes categorías y
// puede arruinar el propósito de las categorías de solo AGREGAR funcionalidad.
// Utiliza subclass para sobreescribir métodos.
// Aquí una clase base simple, Car.
@interface Car : NSObject
@property NSString *make;
@property NSString *color;
- (void)turnOn;
- (void)accelerate;
@end
// Y la implementación de la clase simple, Car
#import "Car.h"
@implementation Car
@synthesize make = _make;
@synthesize color = _color;
- (void)turnOn {
NSLog(@"Car is on.");
}
- (void)accelerate {
NSLog(@"Accelerating.");
}
@end
// Ahora, si quisieramos crear un objeto Truck (Camión), crearíamos una
// subclase de Car (Carro) como si le cambiaramos de funcionalidad de Car
// para que se comporte como un camión. Pero digamos que únicamente queremos
// agregar funcionalidad al Car (Carro) existente. Un buen ejemplo sería
// limpiar el carro. Así que crearíamos una cateog®iea para agregar los
// métodos de limpieza:
// Archivo @interface: Car+Clean.h (NombreBaseDeClase+NombreDeCategoria.h)
#import "Car.h" // Asegúrate de improtar la clase que deseas extener.
@interface Car (Clean) // El nombre de la categoría está dentro de (),
// seguido del nombre de la clase base
- (void)washWindows; // Nombres de los nuevos métodos que le agregamos
// a nuestro objeto Car
- (void)wax;
@end
// Archivo @implementation: Car+Clean.m (NombreBaseDeClase+NombreDeCategoria.m)
#import "Car+Clean.h" // Importa el archivo de @interface de la categoría Clean
@implementation Car (Clean)
- (void)washWindows {
NSLog(@"Windows washed.");
}
- (void)wax {
NSLog(@"Waxed.");
}
@end
// Cualquier instancia del objeto Car tiene la habilidad de utilizar una
// categoría. Todo lo que necesitan es importarlo:
#import "Car+Clean.h" // Importa todas las diferentes categorías que
// necesites utilizar
#import "Car.h" // También debes de importar la clase base para su
// funcionalidad original
int main (int argc, const char * argv[]) {
@autoreleasepool {
Car *mustang = [[Car alloc] init];
mustang.color = @"Red";
mustang.make = @"Ford";
[mustang turnOn]; // Utiliza métodos de la clase base Car.
[mustang washWindows]; // Utiliza métodos de la categoría Clean de Car.
}
return 0;
}
// Objective-C no tiene declaraciones para métodos protegidos, pero los puedes
// simular. Crea una categoría conteniendo todos los métodos protegidos,
// luego importa ÚNICAMENTE al archivo @implementation de una clase que
// pertenece a la clase Car.
@interface Car (Protected) // Nombrando la categoría 'Protected' para
// recordar que los métodos están protegidos
- (void)lockCar; // Los métodos enlistados aquí solo puedens ser creados
// por objetos Car
@end
// Para utilizar los métodos protegidos, importa la categoría,
// luego implementa sus métodos:
#import "Car+Protected.h" // Recuerda, importa únicamente el archivo
// de @implementation
@implementation Car
- (void)lockCar {
NSLog(@"Car locked."); // Las instancias de Car no puede utilizar
// lockCar porque no se encuentra en @interface
}
@end
///////////////////////////////////////
// Extensiones
///////////////////////////////////////
// Las Extensions te permiten sobreescribir atributos de propiedades de
// acceso público y métodos de un @interface
// Archivo @interface: Shape.h
@interface Shape : NSObject
@property (readonly) NSNumber *numOfSides;
- (int)getNumOfSides;
@end
// Puedes sobreescribir la variable numOfSides o el métodos getNumOfSlides
// para modificarlos con una extensión:
// Archivo @implementation: Shape.m
#import "Shape.h"
// Las extensiones se encuentran en el mismo archivo que el archivo
// de @implementation
@interface Shape () // () después del nombre de la clase base declara
// una extensión
@property (copy) NSNumber *numOfSides; // Hacer numOfSlides copy en lugar
// de readonly.
-(NSNumber)getNumOfSides; // Hacer que getNumOfSides devuelva un NSNumber
// en lugar de un int.
-(void)privateMethod; // También puedes crear una nuevos métodos privados
// dentro de las extensiones
@end
// @implementation principal:
@implementation Shape
@synthesize numOfSides = _numOfSides;
-(NSNumber)getNumOfSides { // Todas las declaraciones dentro de extensions
// deben de ser dentro de @implementation
return _numOfSides;
}
-(void)privateMethod {
NSLog(@"Private method created by extension. Shape instances cannot call me.");
}
@end
///////////////////////////////////////
// Protocolos
///////////////////////////////////////
// Un protocolo declara métodos que pueden ser implementados por cualquier otra
// clase. Los protocolos no son clases. Simplementen define una interfaz que
// otros objetos deben de implementar.
// Archivo @protocol: "CarUtilities.h"
@protocol CarUtilities <NSObject> // <NSObject> => Nombre de otro protocolo
// que se incluye en éste
@property BOOL engineOn; // La clase que lo adopta debe de utilizar
// @synthesize para todas las @properties definidas
- (void)turnOnEngine; // y todos los métodos definidos
@end
// A continuación una clase ejemplo que implementa el protcolo
#import "CarUtilities.h" // Importar el archivo @protocol.
@interface Car : NSObject <CarUtilities> // El nombre del protocolo dentro de <>
// No necesitas los nombres de @property o métodos aquí para CarUtilities.
// Estos solo es requerido por @implementation.
- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // También Puedes
// utilizar protocolos
// como datos.
@end
// El @implementation necesita que se implementen @properties y métodos
// del protocolo.
@implementation Car : NSObject <CarUtilities>
@synthesize engineOn = _engineOn; // Crear una declaración @synthesize para el
// @property engineOn.
- (void)turnOnEngine { // Implementa turnOnEngine como quieras. Los
// protocolos no definen
_engineOn = YES; // cómo implementas un método, con tal de que lo implementes.
}
// Puedes utilizar un protocolo como data mientras sepas quee métodos y variables
// tiene implementado.
- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind {
[objectOfSomeKind engineOn]; // Tienes acceso a las variables
[objectOfSomeKind turnOnEngine]; // y los métodos del objeto
[objectOfSomeKind engineOn]; // Puede o no puede ser YES. La clase lo
// implementa como se quiera.
}
@end
// Las instancias de Car ahora tienen acceso al protocolo.
Car *carInstance = [[Car alloc] init];
[carInstance setEngineOn:NO];
[carInstance turnOnEngine];
if ([carInstance engineOn]) {
NSLog(@"Car engine is on."); // imprime => "Car engine is on."
}
// Asegúrate de revisar si un objeto de tipo 'id' implementa un protocolo antes
// de llamar a sus métodos:
if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
NSLog(@"This does not run as the MyClass class does not implement the CarUtilities protocol.");
} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) {
NSLog(@"This does run as the Car class implements the CarUtilities protocol.");
}
// Las categorías también pueden implementar protcolos: @interface Car
// (CarCategory) <CarUtilities>
// Puedes implementar varios protocolos:
// @interface Car : NSObject <CarUtilities, CarCleaning>
// NOTA: Si dos o más protocolos dependen entre sí, asegúrate de declararlos
// de manera adelantada:
#import "Brother.h"
@protocol Brother; // Declaración adelantada. Sin ésto, el compilador
// tira un error.
@protocol Sister <NSObject>
- (void)beNiceToBrother:(id <Brother>)brother;
@end
// Ver si el problema es que Sister depende de Brother,
// y Brother dependa de Sister.
#import "Sister.h"
@protocol Sister; // Estas líneas detienen la recursión, resolviendo el problema.
@protocol Brother <NSObject>
- (void)beNiceToSister:(id <Sister>)sister;
@end
///////////////////////////////////////
// Bloques
///////////////////////////////////////
// Los bloques son declaraciones de código, tal como una función, pueden
// ser utilizados como data.
// A continuación un bloque simple con un argumento entero que devuelve
// un el argumento más 4.
int (^addUp)(int n); // Declarar una variable para almacenar el bloque.
void (^noParameterBlockVar)(void); // Ejemplo de una declaración de variable
// de bloque sin argumentos.
// Los bloques tienen acceso a variables del mismo ámbito. Pero las variables
// son solo readonly y el valor pasado al bloque es el valor de la variable
// cuando el bloque es creado.
int outsideVar = 17; // Si modificamos outsideVar después de declarar addUp,
// outsideVar AÚN es 17.
__block long mutableVar = 3; // __block hace que las variables se puedan
// escribir en bloques.
addUp = ^(int n) { // Remueve (int n) para tener un bloque que no recibe
// ningún parámetro
NSLog(@"You may have as many lines in a block as you would like.");
NSSet *blockSet; // También puedes declarar variables locales.
mutableVar = 32; // Asignar un nuevo valor a la variable __block.
return n + outsideVar; // Declaraciones de retorno son opcionales.
}
int addUp = add(10 + 16); // Llama al bloque de código con argumentos.
// Los bloques son usualmente utilizados como argumentos a funciones que
// son llamados más adelante o para callbacks.
@implementation BlockExample : NSObject
- (void)runBlock:(void (^)(NSString))block {
NSLog(@"Block argument returns nothing and takes in a NSString object.");
block(@"Argument given to block to execute."); // Calling block.
}
@end
///////////////////////////////////////
// Manejo de memoria
///////////////////////////////////////
/*
Para cada objeto utilizado en una aplicación, la memoria debe de ser alocada
para ese objeto. Cuando la aplicación termina de utilizar ese objeto, la
memoria debe de ser desalocada para asegurar la eficiencia de la aplicación.
Objetive-C no utiliza garbage collection, y en lugar de eso utiliza conteos
de referencias. Mientras haya al menos una referencia del objeto (también
conocido como tener un objeto de adueñado), entonces el objeto estará
disponible para su uso.
Cuando una instancia es dueña un objeto, su contador de referencia incrementa
por uno. Cuando el objeto es liberado, el contador de referencia decrementa uno.
Cuando el conteo de referencia es cero, el objeto es removido de la memoria.
Con todas las interacciones de los objetos, sigue el patrón de:
(1) Crear e lobjeto, (2) utiliza el objeto, (3) libera el objeto de la memoria.
*/
MyClass *classVar = [MyClass alloc]; // 'alloc' asigna uno al conteo de
// referencias de classVar. Devuelve un
// puntero al objeto
[classVar release]; // Decrementa el conteo de referencias de classVar's
// 'retain'
// 'retain' adueña la instancia de objeto existente e incrementa el conteo de
// referencia por uno. Devuelve un puntero al objeto.
MyClass *newVar = [classVar retain]; // Si classVar es liberado, el objeto
// aún se queda en memoria porque newVar
// es el dueño.
[classVar autorelease]; // Remueve el adueñamiento de un objeto al final del
// bloque @autoreleasepool. Devuelve un puntero al objeto.
// @property puede utilizar 'retain' y 'assign' también para pequeñas
// definiciones convenientes
@property (retain) MyClass *instance; // Libera el valor viejo y retiene
// uno nuevo (referencia fuerte)
@property (assign) NSSet *set; // Apunta a un nuevo valor sin retener/liberar
// una referencia vieja (débil)
// Conteo Automático de Referencias (ARC)
// Debido a que el manejo de memoria puede ser un dolor, en Xcode 4.2 y iOS 4
// se introdujo el Conteo Automático de Referencias (ARC).
// ARC es una funcionalidad del compilador que agrega retain, release y
// autorealase automáticamente, así que al
// utilizar ARC, no se debe de utilizar retain, release o autorelease.
MyClass *arcMyClass = [[MyClass alloc] init];
// ... código utilizando arcMyClass
// Sin ARC, necesitarás llamar: [arcMyClass release] luego de terminar de
// utilizar arcMyClass. Pero con ARC, no hay necesidad. Insertará
// automáticamente la declaración de liberación.
// Mientras que para los atributos de @property 'assign' y 'retain', con ARC
// utilizarás 'weak' y 'strong'
@property (weak) MyClass *weakVar; // 'weak' no adueña el objeto. El conteo de
// referencias de la instancia original
// es fijado a ceor, weakVar automáticamente recibe el valor de nil para
// evitar cualquier 'crashing'.
@property (strong) MyClass *strongVar; // 'strong' se adueña del objeto.
// Asegura que el objeto se quede en memoria.
// Para variables regulares (no variables de @property), utiliza lo siguiente:
__strong NSString *strongString; // Por defecto. La variables de retenida en
// memoria hasta que se salga del ámbito.
__weak NSSet *weakSet; // Referencia débil a un objeto existente. Cuando el
// objeto existente es liberado, weakSet le es asginado
// un valor nil
__unsafe_unretained NSArray *unsafeArray; // Como __weak, pero unsafeArray no
// es asginado a nil cuando el objeto
// existente es liberado.
```
## Lecturas sugeridas
[Wikipedia Objective-C](http://es.wikipedia.org/wiki/Objective-C)
[Programming with Objective-C. Libro PDF de Apple](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)

825
es-es/php-es.html.markdown Normal file
View File

@ -0,0 +1,825 @@
---
language: PHP
contributors:
- ["Malcolm Fell", "http://emarref.net/"]
- ["Trismegiste", "https://github.com/Trismegiste"]
translators:
- ["Mario Pérez", "https://github.com/MarioPerezEsteso"]
lang: es-es
filename: learnphp-es.php
---
Este documento explica el funcionamiento de PHP 5+.
```php
<?php // El código PHP debe estar dentro de etiquetas <?php
// Si tu fichero php solo contiene código php, es una buena práctica
// omitir la etiqueta de cierre php para prevenir salidas acidentales.
// Dos barras comienzan un comentario de una línea.
# También lo hará una almohadilla, pero // es más común
/*
Escribir texto entre una barra-asterisco y asterisco-barra
crea un comentario multilínea.
*/
// Utiliza "echo" o "print" para imprimir por pantalla
print('Hola '); // Imprime "Hola " sin salto de línea
// () son opcionales para print y echo
echo "Mundo\n"; // Imprime "Mundo" con un salto de línea
// (todas las sentencias deben finalizar con un punto y coma)
// Cualquier cosa fuera de las etiquetas <?php se imprime automáticamente
?>
¡Hola Mundo de nuevo!
<?php
/************************************
* Tipos y variables
*/
// Las variables comienzan con el símbolo $.
// Una variable válida comienza con una letra o guión bajo,
// seguida de cualquier cantidad de letras, números o guiones bajos.
// Las variables booleanas no distinguen entre mayúsculas o minúsculas
$boolean = true; // o TRUE o True
$boolean = false; // o FALSE o False
// Enteros
$int1 = 12; // => 12
$int2 = -12; // => -12
$int3 = 012; // => 10 (un 0 al comienzo declara un número octal)
$int4 = 0x0F; // => 15 (un 0x al comienzo declara un hexadecimal)
// Floats (también conocidos como doubles)
$float = 1.234;
$float = 1.2e3;
$float = 7E-10;
// Eliminar variable
unset($int1);
// Operaciones aritméticas
$suma = 1 + 1; // 2
$diferencia = 2 - 1; // 1
$producto = 2 * 2; // 4
$cociente = 2 / 1; // 2
// Operaciones aritméticas de escritura rápida
$numero = 0;
$numero += 1; // Incrementa $numero en 1
echo $numero++; // Imprime 1 (incremento después la evaluación)
echo ++$numero; // Imprime 3 (incremento antes de la evaluación)
$numero /= $float; // Divide y asigna el cociente a $numero
// Las cadenas de caracteres deben declararse entre comillas simples
$sgl_quotes = '$String'; // => '$String'
// Evita utilizar comillas dobles excepto para embeber otras variables
$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
// Los caracteres especiales solo son válidos entre comillas dobles
$escaped = "Esto contiene \t un caracter tabulador.";
$unescaped = 'Esto solo contiene una barra y una t: \t';
// Rodea una variable entre corchetes si es necesario
$dinero = "Tengo $${numero} en el banco.";
// Desde PHP 5.3, los nowdocs pueden ser utilizados para multilíneas no interpoladas
$nowdoc = <<<'END'
Multi line
string
END;
// Heredocs interpola cadenas de caracteres
$heredoc = <<<END
Multi line
$sgl_quotes
END;
// La concatenación de cadenas de caracteres se realiza con .
echo 'Esta cadena de caracteres ' . 'está concatenada';
// Las cadenas de caracteres pueden ser pasadas como parámetros en un echo
echo 'Multiples', 'Parametros', 'Validos'; // Devuelve 'MultiplesParametrosValidos'
/********************************
* Constantes
*/
// Una constante se define utilizando define()
// y nunca puede ser cambiada en tiempo de ejecución
// un nombre válido para una constante debe comenzar con una letra o guión bajo,
// seguido por cualquier número de letras, números o guiones bajos.
define("FOO", "algo");
// el acceso a una constante se puede realizar llamando a la variable elegida sin un símbolo de $
echo FOO; // Devuelve 'algo'
echo 'Esto imprime '.FOO; // Devuelve 'Esto imprime algo'
/********************************
* Arrays
*/
// Todos los arrays en PHP son asociativos (hashmaps),
// Los arrays asociativos son conocidos como hashmaps en algunos lenguajes.
// Funciona con todas las versiones de php
$asociativo = array('Uno' => 1, 'Dos' => 2, 'Tres' => 3);
// PHP 5.4 introdujo una nueva sintaxis
$asociativo = ['Uno' => 1, 'Dos' => 2, 'Tres' => 3];
echo $asociativo['Uno']; // imprime 1
// Lista literales implícitamente asignados con claves enteras
$array = ['Uno', 'Dos', 'Tres'];
echo $array[0]; // => "Uno"
// Añadir un elemento al final de un array
$array[] = 'Cuatro';
// o
array_push($array, 'Cinco');
// Eliminar un elemento de un array
unset($array[3]);
/********************************
* Salidas por pantalla
*/
echo('¡Hola Mundo!');
// Imprime ¡Hola Mundo! en stdout.
// Stdout es la página web si se está ejecutando en un navegador.
print('!Hola Mundo!'); // Es lo mismo que echo
// No es necesario el paréntesis en echo y print
echo '¡Hola Mundo!';
print '¡Hola Mundo!';
$parrafo = 'parrafo';
echo 100; // Haz echo de escalares directamente
echo $parrafo; // o de variables
// Si las etiquetas cortas estás configuradas y tu versión de PHP es
// la 5.4.0 o superior, puede utilizar la sintaxis abreviada de echo
?>
<p><?= $parrafo?></p>
<?php
$x = 1;
$y = 2;
$x = $y; // $x ahora contiene el mismo valor que $y
$z = &$y;
// $z contiene ahora una referencia a $y. Un cambio en el valor de
// $z cambiará también el valor de $y, y viceversa.
// $x sin embargo, tendrá el valor original de $y
echo $x; // => 2
echo $z; // => 2
$y = 0;
echo $x; // => 2
echo $z; // => 0
// Dump muestra el tipo y valor de una variable en stdout
var_dump($z); // imprime int(0)
// Para mostrar el valor de una variable en un formato legible para humanos
print_r($array); // imprime: Array ( [0] => Uno [1] => Dos [2] => Tres )
/********************************
* Lógica
*/
$a = 0;
$b = '0';
$c = '1';
$d = '1';
// assert lanza una advertencia si su argumento no es verdadero
// Estas comparaciones siempre serán verdaderas, incluso si los tipos no son los mismos.
assert($a == $b); // igualdad
assert($c != $a); // desigualdad
assert($c <> $a); // desigualdad alternativa
assert($a < $c);
assert($c > $b);
assert($a <= $b);
assert($c >= $d);
// Los siguiente solo será verdadero si los valores coinciden y son del mismo tipo.
assert($c === $d);
assert($a !== $d);
assert(1 === '1');
assert(1 !== '1');
// Operador 'Spaceship' (desde PHP 7)
// Devuelve 0 si ambos valores son iguales
// Devuelve 1 si el valor de la izquierda es mayor
// Devuelve -1 si el valor de la derecha es mayor
$a = 100;
$b = 1000;
echo $a <=> $a; // 0 porque son iguales
echo $a <=> $b; // -1 porque $a < $b
echo $b <=> $a; // 1 porque $b > $a
// Las variables pueden ser convertidas entre tipos, dependiendo de su uso.
$entero = 1;
echo $entero + $entero; // => 2
$string = '1';
echo $string + $string; // => 2 (los strings son convertidos a enteros)
$string = 'uno';
echo $string + $string; // => 0
// Muestra un 0 porque el operador + no puede convertir la cadena de caracteres 'uno' a un número
// La conversión de tipos puede ser utilizada para tratar a una variable como otro tipo
$boolean = (boolean) 1; // => true
$cero = 0;
$boolean = (boolean) $cero; // => false
// También hay funciones dedicadas a la conversión de tipos
$entero = 5;
$string = strval($entero);
$var = null; // Valor nulo
/********************************
* Estructuras de control
*/
if (true) {
print 'He sido imprimido';
}
if (false) {
print 'Yo no';
} else {
print 'He sido imprimido';
}
if (false) {
print 'No se imprime';
} elseif(true) {
print 'Sí se imprime';
}
// operador ternario
print (false ? 'No se imprime' : 'Sí se imprime');
// atajo para el operador ternario desde PHP 5.3
// equivalente de "$x ? $x : 'Sí'""
$x = false;
print($x ?: 'Sí');
// operador 'no definido' desde php 7
$a = null;
$b = 'Imprime';
echo $a ?? 'a no está definido'; // imprime 'a no está definido'
echo $b ?? 'b no está definido'; // imprime 'Imprime'
$x = 0;
if ($x === '0') {
print 'No imprime';
} elseif($x == '1') {
print 'No imprime';
} else {
print 'Imprime';
}
// Esta sintaxis alternativa se utiliza para plantillas:
?>
<?php if ($x): ?>
Esto se muestra si la evaluación es verdadera.
<?php else: ?>
En otro caso, se muestra esto.
<?php endif; ?>
<?php
// Utiliza el switch para tener algo más de lógica.
switch ($x) {
case '0':
print 'Switch does type coercion';
break; // Debes incluir un break para no seguir con los casos 'Dos' y 'Tres'
case 'Dos':
case 'Tres':
// Hacer algo si la variables es 'Dos' o 'Tres'
break;
default:
// Hacer algo por defecto
}
// Los bucles While, do...while y for te serán familiares
$i = 0;
while ($i < 5) {
echo $i++;
}; // Imprime "01234"
echo "\n";
$i = 0;
do {
echo $i++;
} while ($i < 5); // Imprime "01234"
echo "\n";
for ($x = 0; $x < 10; $x++) {
echo $x;
} // Imprime "0123456789"
echo "\n";
$ruedas = ['bicicleta' => 2, 'coche' => 4];
// Los bucles foreach pueden iterar por arrays
foreach ($ruedas as $numero_ruedas) {
echo $numero_ruedas;
} // Imprime "24"
echo "\n";
// También se puede iterar sobre las claves, así como sobre los valores
foreach ($ruedas as $vehiculo => $numero_ruedas) {
echo "Un $vehiculo tiene $numero_ruedas ruedas";
}
echo "\n";
$i = 0;
while ($i < 5) {
if ($i === 3) {
break; // Sale fuera del bucle while
}
echo $i++;
} // Imprime "012"
for ($i = 0; $i < 5; $i++) {
if ($i === 3) {
continue; // Se salta esta iteración del bucle
}
echo $i;
} // Imprime "0124"
/********************************
* Funciones
*/
// Define una función con "function":
function mi_funcion () {
return 'Hola';
}
echo mi_funcion(); // => "Hola"
// Un nombre válido de función comienza con una letra o guión bajo, seguido de cualquier
// número de letras, números o guiones bajos.
function anadir ($x, $y = 1) { // $y es opcional y por defecto es 1
$resultado = $x + $y;
return $resultado;
}
echo anadir(4); // => 5
echo anadir(4, 2); // => 6
// $resultado no es accesible fuera de la función
// print $resultado; // Devuelve una advertencia.
// Desde PHP 5.3 se pueden declarar funciones anónimas
$inc = function ($x) {
return $x + 1;
};
echo $inc(2); // => 3
function foo ($x, $y, $z) {
echo "$x - $y - $z";
}
// Las funciones pueden devolver funciones
function bar ($x, $y) {
// Utiliza 'use' para meter variables de fuera de la función
return function ($z) use ($x, $y) {
foo($x, $y, $z);
};
}
$bar = bar('A', 'B');
$bar('C'); // Imprime "A - B - C"
// Puedes llamar a funciones utilizando cadenas de caracteres
$nombre_funcion = 'add';
echo $nombre_funcion(1, 2); // => 3
// Es útil para determinarl qué función ejecutar.
// O, utiliza call_user_func(callable $callback [, $parameter [, ... ]]);
// Puedes obtener todos los parámetros pasados a una función
function parametros() {
$numero_argumentos = func_num_args();
if ($numero_argumentos > 0) {
echo func_get_arg(0) . ' | ';
}
$args_array = func_get_args();
foreach ($args_array as $key => $arg) {
echo $key . ' - ' . $arg . ' | ';
}
}
parametros('Hola', 'Mundo'); // Hola | 0 - Hola | 1 - Mundo |
// Desde PHP 5.6 se puede obtener un número variable de argumentos
function variable($palabra, ...$lista) {
echo $palabra . " || ";
foreach ($lista as $item) {
echo $item . ' | ';
}
}
variable("Separa", "Hola", "Mundo") // Separa || Hola | Mundo |
/********************************
* Includes
*/
<?php
// Los ficheros PHP incluidos deben comenzar también con la etiqueta de <?php
include 'mi-fichero.php';
// El código de mi-fichero.php ya está disponible en el entorno actual.
// Si el fichero no puede ser incluido (por ejemplo porque no se ha encontrado),
// se muestra una advertencia.
include_once 'mi-fichero.php';
// Si el código del fichero mi-fichero.php ya ha sido incluido, ya no se
// incluirá de nuevo. Este previene errores por múltiples declaraciones.
require 'mi-fichero.php';
require_once 'mi-fichero.php';
// Es lo mismo que el include(), pero require() causará un error fatal si el archivo
// no ha podido ser incluido.
// Contenido de mi-include.php:
<?php
return 'Cualquier cosa.';
// acabar archivo
// Los include y require también pueden devolver un valor.
$valor = include 'mi-include.php';
// Los archivos son incluidos en función de la ruta data o, si ninguna ruta es
// especificada se utilizará la directiva de configuración de include_path. Si el
// fichero no se encuentra en el include_path, include comprobará la ruta del código
// que lo llama antes de fallar.
/* */
/********************************
* Clases
*/
// Las clases son definidas con la palabra clave class
class MiClase
{
const MI_CONSTANTE = 'valor'; // Una constante
static $staticVar = 'static';
// Las variables estáticas y su visibilidad
public static $publicStaticVar = 'publicStatic';
// Accesible solo dentro de su clase
private static $privateStaticVar = 'privateStatic';
// Accesible desde la clase y las subclases
protected static $protectedStaticVar = 'protectedStatic';
// Las propiedades deben declarar su visibilidad
public $propiedad = 'public';
public $instanceProp;
protected $prot = 'protected'; // Accesible desde la clase y las subclases
private $priv = 'private'; // Accesible solo desde la clase
// Crear un constructor con __construct
public function __construct($instanceProp) {
// Accede a las variables de la instancia con $this
$this->instanceProp = $instanceProp;
}
// Los métodos son declarados como funciones dentro de una clase
public function miMetodo()
{
print 'MiClase';
}
// la palabra clave final hará una función no sobreescribible
final function noMePuedesSobreEscribir()
{
}
/*
* Declarar propiedades de clase o métodos como estáticos los hace accesibles sin
* necesidad de instanciar la clase. Una propiedad declarada como estática no
* puede ser accedida mediante una instancia de la clase, pero sí mediante un
* método estático.
*/
public static function miMetodoEstatico()
{
print 'Soy estático';
}
}
// Las constantes de una clase siempre pueden ser accedidas estáticamente
echo MiClase::MI_CONSTANTE; // Muestra 'valor';
echo MiClase::$staticVar; // Muestra 'static';
MiClase::miMetodoEstatico(); // Muestra 'Soy estático';
// Instancia una clase usando new
$mi_clase = new MiClase('Una instancia');
// Los paréntesis son opcionales si no se pasa ningún argumento.
// Accede a los miembros de una clase utilizando ->
echo $mi_clase->propiedad; // => "public"
echo $mi_clase->instanceProp; // => "Una instancia"
$mi_clase->miMetodo(); // => "MiClase"
// Extender clases utilizando "extends"
class MiOtraClase extends MiClase
{
function imprimePropiedadProtegida()
{
echo $this->prot;
}
// Sobreescribe un método
function miMetodo()
{
parent::miMetodo();
print ' > MiOtraClase';
}
}
$mi_otra_clase = new MiOtraClase('Propiedad de instancia');
$mi_otra_clase->imprimePropiedadProtegida(); // => Imprime "protected"
$mi_otra_clase->miMetodo(); // Imprime "MiClase > MiOtraClase"
final class NoMePuedesExtender
{
}
// Puedes utilizar "métodos mágicos" para crear los getters y setters
class MiClaseMapeada
{
private $propiedad;
public function __get($key)
{
return $this->$key;
}
public function __set($key, $value)
{
$this->$key = $value;
}
}
$x = new MiClaseMapeada();
echo $x->propiedad; // Utilizará el método __get()
$x->propiedad = 'Algo'; // Utilizará el método __set()
// Las clases pueden ser abstractas (utilizando la palabra clave abstract) o
// implementando interfaces (utilizando la palabra clave implements).
// Una interfaz puede ser declarada con la palabra clave interface.
interface InterfazUno
{
public function hazAlgo();
}
interface InterfazDos
{
public function hazOtraCosa();
}
// las interfaces pueden ser extendidas
interface InterfazTres extends InterfazDos
{
public function hazCualquierOtraCosa();
}
abstract class MiClaseAbstracta implements InterfazUno
{
public $x = 'hazAlgo';
}
class MiOtraClase extends MiClaseAbstracta implements InterfazDos
{
public function hazAlgo()
{
echo $x;
}
public function hazOtraCosa()
{
echo 'hazOtraCosa';
}
}
// Las clases pueden implementar más de una interfaz
class CualquierOtraClase implements InterfazUno, InterfazDos
{
public function hazAlgo()
{
echo 'hazAlgo';
}
public function hazOtraCosa()
{
echo 'hazOtraCosa';
}
}
/********************************
* Traits
*/
// Los traits están disponibles desde PHP 5.4.0 y son declarados utilizando "trait"
trait MiTrait
{
public function miMetodoTrait()
{
print 'Tengo trait';
}
}
class MiClaseTrait
{
use MiTrait;
}
$cls = new MiClaseTrait();
$cls->miMetodoTrait(); // Imprime "Tengo trait"
/********************************
* Namespaces
*/
// Esta sección está separada porque una declaración de namespace debe
// ser la primera sentencia en un archivo. Vamos a suponer que no es el caso
<?php
// Por defecto, las clases existen en el namespace global y pueden ser llamadas
// explícitamente con una contrabarra.
$cls = new \MiClase();
// Estableder el namespace para un archivo
namespace Mi\Namespace;
class MiClase
{
}
// (de otro archivo)
$cls = new Mi\Namespace\MiClase;
// O de otro namespace.
namespace Mi\Otro\Namespace;
use Mi\Namespace\MiClase;
$cls = new MiClase();
// O se puede asignar un ales al namespace
namespace Mi\Otro\Namespace;
use Mi\Namespace as OtroNamespace;
$cls = new OtroNamespace\MiClase();
/**********************
* Late Static Binding
*
*/
class ClasePadre {
public static function quien() {
echo "Soy una " . __CLASS__ . "\n";
}
public static function test() {
// Auto referencia a la clase en la que el método está definido
self::quien();
// Referencia estáticamente a la clase donde el método ha sido llamado
static::quien();
}
}
ClasePadre::test();
/*
Soy una ClasePadre
Soy una ClasePadre
*/
class ClaseHija extends ClasePadre {
public static function quien() {
echo "Pero soy una " . __CLASS__ . "\n";
}
}
ClaseHija::test();
/*
Soy una ClasePadre
Pero soy una ClaseHija
*/
/**********************
* Manejo de errores
*
*/
// Una simple gestión de errores puede ser realizada con un bloque try catch
try {
// Haz algo
} catch (Exception $e) {
// Maneja la excepción
}
// Cuando se utilicen bloques try catch en un entorno con namespaces hay que
// usar lo siguiente
try {
// Haz algo
} catch (\Exception $e) {
// Maneja la excepción
}
// Excepciones personalizadas
class MiExcepcion extends Exception {}
try {
$condicion = true;
if ($condicion) {
throw new MiExcepcion('Ha pasado algo');
}
} catch (MiExcepcion $e) {
// Manejar la excepción
}
```
## Más información
Visita la [documentación oficial de PHP](http://www.php.net/manual/) para más referencias
y apoyo de la comunidad.
Si estás interesado en buenas prácticas, visita
[PHP The Right Way](http://www.phptherightway.com/).
Si vienes de un lenguaje con una buena gestión de paquetes, visita
[Composer](http://getcomposer.org/).
Para estándares comunes, visita el PHP Framework Interoperability Group
[PSR standards](https://github.com/php-fig/fig-standards).

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

@ -9,8 +9,8 @@ lang: es-es
filename: learnpython-es.py
---
Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
Python fue creado por Guido Van Rossum en el principio de los 90. Ahora es uno
de los lenguajes más populares que existen. Me enamoré de Python por su claridad sintáctica.
Es básicamente pseudocódigo ejecutable.
¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
@ -19,8 +19,8 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
```python
# Comentarios de una línea comienzan con una almohadilla (o signo gato)
""" Strings multilinea pueden escribirse
usando tres "'s, y comunmente son usados
""" Strings multilínea pueden escribirse
usando tres "'s, y comúnmente son usados
como comentarios.
"""
@ -48,7 +48,7 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
# Resultado de la división de enteros truncada para positivos y negativos
5 // 3 # => 1
5.0 // 3.0 # => 1.0 # funciona con números en coma flotante
5.0 // 3.0 # => 1.0 # funciona con números de coma flotante
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0
@ -436,7 +436,7 @@ class Humano(object):
def get_especie(cls):
return cls.especie
# Un metodo estatico es llamado sin la clase o instancia como referencia
# Un metodo estático es llamado sin la clase o instancia como referencia
@staticmethod
def roncar():
return "*roncar*"
@ -507,7 +507,7 @@ def duplicar_numeros(iterable):
# Nota: xrange es un generador que hace lo mismo que range.
# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
# xrange crea un generador, mientras que range crea toda la lista.
# Añadimos un guion bajo a los nombres de variable que coinciden con palabras
# Añadimos un guión bajo a los nombres de variable que coinciden con palabras
# reservadas de python.
xrange_ = xrange(1, 900000000)

717
es-es/r-es.html.markdown Normal file
View File

@ -0,0 +1,717 @@
---
language: R
contributors:
- ["e99n09", "http://github.com/e99n09"]
- ["isomorphismes", "http://twitter.com/isomorphisms"]
translators:
- ["David Hsieh", "http://github.com/deivuh"]
lang: es-es
filename: learnr-es.r
---
R es un lenguaje de computación estadística. Tiene muchas librerías para cargar
y limpiar sets de datos, ejecutar procedimientos estadísticos y generar
gráficas. También puedes ejecutar comandos `R` dentro de un documento de
LaTeX.
```r
# Los comentariso inician con símbolos numéricos.
# No puedes hacer comentarios de múltiples líneas
# pero puedes agrupar múltiples comentarios de esta manera.
# En Windows puedes utilizar CTRL-ENTER para ejecutar una línea.
# En Mac utilizas COMMAND-ENTER
#############################################################################
# Cosas que puedes hacer sin entender nada acerca de programación
#############################################################################
# En esta sección, mostramos algunas cosas chileras / cool que puedes hacer en
# R sin entender nada de programación. No te preocupes en entender nada
# de lo que hace este código. Solo disfruta!
data() # Examinar sets de datos pre-cargados
data(rivers) # Obtiene este: Lengths of Major North American Rivers"
ls() # Fijarse que "rivers" ahora aparece en el workspace
head(rivers) # Echarle un ojo al set de datos
# 735 320 325 392 524 450
length(rivers) # ¿Cuántos ríos fueron medidos?
# 141
summary(rivers) # ¿Cuáles son algunas estadísticas generales?
# Min. 1st Qu. Median Mean 3rd Qu. Max.
# 135.0 310.0 425.0 591.2 680.0 3710.0
# Generar una gráfica tallo-y-hoja (Visualización de datos tipo histograma)
stem(rivers)
# El punto decimal son 2 dígitos a la derecha de |
#
# 0 | 4
# 2 | 011223334555566667778888899900001111223333344455555666688888999
# 4 | 111222333445566779001233344567
# 6 | 000112233578012234468
# 8 | 045790018
# 10 | 04507
# 12 | 1471
# 14 | 56
# 16 | 7
# 18 | 9
# 20 |
# 22 | 25
# 24 | 3
# 26 |
# 28 |
# 30 |
# 32 |
# 34 |
# 36 | 1
stem(log(rivers)) # Fijarse que la data no es normal ni log-normal!
# Toma eso, fundamentalistas de la curva de campana!
# El punto decimal está a 1 dígito a la izquierda del |
#
# 48 | 1
# 50 |
# 52 | 15578
# 54 | 44571222466689
# 56 | 023334677000124455789
# 58 | 00122366666999933445777
# 60 | 122445567800133459
# 62 | 112666799035
# 64 | 00011334581257889
# 66 | 003683579
# 68 | 0019156
# 70 | 079357
# 72 | 89
# 74 | 84
# 76 | 56
# 78 | 4
# 80 |
# 82 | 2
# Generar un histograma:
hist(rivers, col="#333333", border="white", breaks=25) # Juega con los estos parámetros
hist(log(rivers), col="#333333", border="white", breaks=25) # Generarás más gráficas después
# Aquí hay otro set de datos pre-cargado. R tiene bastantes de éstos.
data(discoveries)
plot(discoveries, col="#333333", lwd=3, xlab="Year",
main="Number of important discoveries per year")
plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year",
main="Number of important discoveries per year")
# En lugar de dejar el orden por defecto (por año),
# podemos ordenar de tal manera que muestre qué es típico:
sort(discoveries)
# [1] 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2
# [26] 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3
# [51] 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4
# [76] 4 4 4 4 5 5 5 5 5 5 5 6 6 6 6 6 6 7 7 7 7 8 9 10 12
stem(discoveries, scale=2)
#
# El punto decimal se encuentra en |
#
# 0 | 000000000
# 1 | 000000000000
# 2 | 00000000000000000000000000
# 3 | 00000000000000000000
# 4 | 000000000000
# 5 | 0000000
# 6 | 000000
# 7 | 0000
# 8 | 0
# 9 | 0
# 10 | 0
# 11 |
# 12 | 0
max(discoveries)
# 12
summary(discoveries)
# Min. 1st Qu. Median Mean 3rd Qu. Max.
# 0.0 2.0 3.0 3.1 4.0 12.0
# Tirar los dados varias veces
round(runif(7, min=.5, max=6.5))
# 1 4 6 1 4 6 4
# Tus números será diferente de los míos, a menos que tengamos el mismo valor
# de random.seed(31337)
# Dibuja de un Gaussian 9 veces
rnorm(9)
# [1] 0.07528471 1.03499859 1.34809556 -0.82356087 0.61638975 -1.88757271
# [7] -0.59975593 0.57629164 1.08455362
##################################################
# Tipos de datos y aritmética básica
##################################################
# Ahora para la parte de programación orientada a objetos del tutorial.
# En esta sección conocerás los tipos de datos importantes de R:
# Enteros, numéricos, caracteres, lógicos, y factores.
# Hay otros, pero esos son los que menos necesitas para empezar.
# ENTEROS
# Enteros de almacenamiento largo son escritos con L
5L # 5
class(5L) # "integer"
# (Try ?class para más información en la función class().)
# En R, cada valor único, como 5L, es considerado un vector de logitud 1
length(5L) # 1
# También puedes tener un vector de enteros con longitud > 1:
c(4L, 5L, 8L, 3L) # 4 5 8 3
length(c(4L, 5L, 8L, 3L)) # 4
class(c(4L, 5L, 8L, 3L)) # "integer"
# NUMÉRICOS
# Un "numérico" es un número de punto flotante de doble precisión.
5 # 5
class(5) # "numeric"
# Nuevamente, todo en R es un vector;
# puedes hacer un vector numérico con más de un elemento
c(3,3,3,2,2,1) # 3 3 3 2 2 1
# También puedes utilizar el notación científica
5e4 # 50000
6.02e23 # Número de Avogadro
1.6e-35 # Logintud Planck
# También puedes tener números infinitamente grandes o pequeños
class(Inf) # "numeric"
class(-Inf) # "numeric"
# Puede que uses "Inf", por ejemplo, en integrate(dnorm, 3, Inf);
# esto obvia las tablas de puntos Z.
# ARITMÉTICA BÁSICA
# Puedes hacer aritmética con números
# Haciendo aritmética en un mix de enteros y numéricos, te da otro numérico
10L + 66L # 76 # entero mas entero da entero
53.2 - 4 # 49.2 # entero menos entero da numérico
2.0 * 2L # 4 # numérico veces entero da numérico
3L / 4 # 0.75 # entero sobre numérico da numérico
3 %% 2 # 1 # el residuo de dos numéricos es otro numérico
# La aritmética ilegal rinde un "not-a-number"
0 / 0 # NaN
class(NaN) # "numeric"
# Puedes hacer aritmética con dos vectores con longitud mayor a 1,
# siempre que la longitud del vector mayor es un entero múltiplo del menor.
c(1,2,3) + c(1,2,3) # 2 4 6
# CARACTERES
# No hay diferencia entre strings y caracteres en R
"Horatio" # "Horatio"
class("Horatio") # "character"
class('H') # "character"
# Ambos eran vectores de caracteres de longitud 1
# Aquí hay uno más largo:
c('alef', 'bet', 'gimmel', 'dalet', 'he')
# =>
# "alef" "bet" "gimmel" "dalet" "he"
length(c("Call","me","Ishmael")) # 3
# Puedes hacer operaciones regex en vectores de caracteres:
substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis."
# R tiene varios vectores predefinidos de caracteres
letters
# =>
# [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
# [20] "t" "u" "v" "w" "x" "y" "z"
month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
# LÓGICOS
# En R, un "logical" es un boolean
class(TRUE) # "logical"
class(FALSE) # "logical"
# Ese comportamiento es normal
TRUE == TRUE # TRUE
TRUE == FALSE # FALSE
FALSE != FALSE # FALSE
FALSE != TRUE # TRUE
# El dato faltante (NA) es lógico también
class(NA) # "logical"
# Utiliza | y & para operaciones lógicas
# OR
TRUE | FALSE # TRUE
# AND
TRUE & FALSE # FALSE
# Puedes probar si x es TRUE (verdadero)
isTRUE(TRUE) # TRUE
# Aquí tenemos un vector lógico con varios elementos:
c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
# FACTORES
# La clase factor es para datos de categoría
# Los factores pueden ser ordenados (como las calificaciones de los niños)
# o sin orden (como el género)
factor(c("female", "female", "male", NA, "female"))
# female female male <NA> female
# Levels: female male
# Los "levels" son los valores que los datos categóricos pueden tener
# Tomar nota que los datos faltantes no entran a los niveles
levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
# Si un vector de factores tiene longitud 1, sus niveles también tendrán
# una longitud de 1 también
length(factor("male")) # 1
length(levels(factor("male"))) # 1
# Los factores son comúnmente vistos en marcos de dato, y una estructura de
# datos que cubriremos después
data(infert) # "Infertility after Spontaneous and Induced Abortion"
levels(infert$education) # "0-5yrs" "6-11yrs" "12+ yrs"
# NULL
# "NULL" es uno raro; utilízalo para "limpiar" un vector
class(NULL) # NULL
parakeet = c("beak", "feathers", "wings", "eyes")
parakeet
# =>
# [1] "beak" "feathers" "wings" "eyes"
parakeet <- NULL
parakeet
# =>
# NULL
# COERCIÓN DE TIPO
# La coerción de tipos es cuando forzas un valor diferente tipo al que puede tomar.
as.character(c(6, 8)) # "6" "8"
as.logical(c(1,0,1,1)) # TRUE FALSE TRUE TRUE
# Si pones elementos de diferentes tipos en un vector, coerciones raras pasan:
c(TRUE, 4) # 1 4
c("dog", TRUE, 4) # "dog" "TRUE" "4"
as.numeric("Bilbo")
# =>
# [1] NA
# Warning message:
# NAs introduced by coercion
# También tomar nota: Esos solo eran datos de tipos básicos
# Hay mucho más tipos de datos, como las fechas, series de tiempo, etc.
##################################################
# Variables, ciclos, condiciones (if/else)
##################################################
# A variable is like a box you store a value in for later use.
# We call this "assigning" the value to the variable.
# Having variables lets us write loops, functions, and if/else statements
# VARIABLES
# Muchas maneras de asignar valores:
x = 5 # esto es posible
y <- "1" # esto es preferido
TRUE -> z # estos funciona pero es raro
# CICLOS
# Tenemos ciclos 'for'
for (i in 1:4) {
print(i)
}
# Tenemos ciclos 'while'
a <- 10
while (a > 4) {
cat(a, "...", sep = "")
a <- a - 1
}
# Ten en mente que los ciclos 'for' y 'while' son lentos en R
# Operaciones con vectores enteros (i.e. una fila o columna completa)
# o tipos de función apply() (que discutiremos después) son preferidos
# CONDICIONES (IF/ELSE)
# De nuevo, bastante normal
if (4 > 3) {
print("4 is greater than 3")
} else {
print("4 is not greater than 3")
}
# =>
# [1] "4 is greater than 3"
# FUNCIONES
# Definidos de la siguiente manera:
jiggle <- function(x) {
x = x + rnorm(1, sd=.1) #agregar un poco de ruido (controlado)
return(x)
}
# Llamados como cualquier otra función de R
jiggle(5) # 5±ε. luego de set.seed(2716057), jiggle(5)==5.005043
###########################################################################
# Estructura de datos: Vectores, matrices, marcos da datos y arreglos
###########################################################################
# UNIDIMENSIONAL
# Empecemos desde el principio, y con algo que ya conoces: vectores.
vec <- c(8, 9, 10, 11)
vec # 8 9 10 11
# Preguntamos por elementos específicos poniendo un subconjunto en corchetes
# (Toma nota de que R empieza los conteos desde 1)
vec[1] # 8
letters[18] # "r"
LETTERS[13] # "M"
month.name[9] # "September"
c(6, 8, 7, 5, 3, 0, 9)[3] # 7
# También podes buscar por los índices de componentes específicos,
which(vec %% 2 == 0) # 1 3
# obtener la primera o las últimas entradas de un vector,
head(vec, 1) # 8
tail(vec, 2) # 10 11
# o averiguar si cierto valor se encuentra dentro de un vector
any(vec == 10) # TRUE
# Si un índice "se pasa", obtendrás un NA:
vec[6] # NA
# Puedes encontrar la longitud de un vector con length()
length(vec) # 4
# Puedes realizar operaciones con vectores enteros o con subconjuntos de vectores
vec * 4 # 16 20 24 28
vec[2:3] * 5 # 25 30
any(vec[2:3] == 8) # FALSE
# y R tiene muchas funciones pre-definidas para resumir vectores
mean(vec) # 9.5
var(vec) # 1.666667
sd(vec) # 1.290994
max(vec) # 11
min(vec) # 8
sum(vec) # 38
# Otras funciones pre-definidas:
5:15 # 5 6 7 8 9 10 11 12 13 14 15
seq(from=0, to=31337, by=1337)
# =>
# [1] 0 1337 2674 4011 5348 6685 8022 9359 10696 12033 13370 14707
# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751
# BIDIMENCIONAL (TODO EN UNA CLASE)
# Puedes hacer una matriz de las entradas todos de un mismo tipo como:
mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
mat
# =>
# [,1] [,2]
# [1,] 1 4
# [2,] 2 5
# [3,] 3 6
# A diferencia de un vector, una clase matriz es una 'matriz',
# sin importar qué contiene
class(mat) # => "matrix"
# Consulta la primera fila
mat[1,] # 1 4
# Realiza una operación en la primera columna
3 * mat[,1] # 3 6 9
# Consulta por una celda específica
mat[3,2] # 6
# Transpone una matriz entera
t(mat)
# =>
# [,1] [,2] [,3]
# [1,] 1 2 3
# [2,] 4 5 6
# Multiplicación de matrices
mat %*% t(mat)
# =>
# [,1] [,2] [,3]
# [1,] 17 22 27
# [2,] 22 29 36
# [3,] 27 36 45
# cbind() une vectores como columnas para hacer una matriz
mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
mat2
# =>
# [,1] [,2]
# [1,] "1" "dog"
# [2,] "2" "cat"
# [3,] "3" "bird"
# [4,] "4" "dog"
class(mat2) # matrix
# De nuevo, ten en cuenta lo que sucedió
# Debido a que las matrices deben de contener todas las entradas del mismo tipo,
# todo fue convertido a la clase caracter
c(class(mat2[,1]), class(mat2[,2]))
# rbind() une vectores como filas para hacer una matriz
mat3 <- rbind(c(1,2,4,5), c(6,7,0,4))
mat3
# =>
# [,1] [,2] [,3] [,4]
# [1,] 1 2 4 5
# [2,] 6 7 0 4
# Ah, todo es de la misma clase. No hay coerciones. Mucho mejor.
# BIDIMENSIONAL (DIFERENTES CLASES)
# Para columnas de tipos diferentes, utiliza un data frame
# Esta estructura de datos es muy útil para programación estadística,
# una versión de ésta fue agregada a Python en el paquete "pandas".
students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"),
c(3,2,2,1,0,-1),
c("H", "G", "G", "R", "S", "G"))
names(students) <- c("name", "year", "house") # name the columns
class(students) # "data.frame"
students
# =>
# name year house
# 1 Cedric 3 H
# 2 Fred 2 G
# 3 George 2 G
# 4 Cho 1 R
# 5 Draco 0 S
# 6 Ginny -1 G
class(students$year) # "numeric"
class(students[,3]) # "factor"
# encontrar las dimensiones
nrow(students) # 6
ncol(students) # 3
dim(students) # 6 3
# La función data.frame() convierte vectores de caracteres en vectores
# de factores por defecto; deshabilita este atributo
# stringsAsFactors = FALSE cuando vayas a crear el data.frame
?data.frame
# Hay otras formas de hacer subconjuntos de data frames
students$year # 3 2 2 1 0 -1
students[,2] # 3 2 2 1 0 -1
students[,"year"] # 3 2 2 1 0 -1
# Una versión aumentada de la estructura data.frame es el data.table
# Si estás trabajando huge o panel data, o necesitas unificar algunos
# subconjuntos de datos, data.table puede ser una buena elección.
# Aquí un tour:
install.packages("data.table") # Descarga el paquete de CRAN
require(data.table) # Cárgalo
students <- as.data.table(students)
students # Tomar en cuenta la diferencia de la impresión
# =>
# name year house
# 1: Cedric 3 H
# 2: Fred 2 G
# 3: George 2 G
# 4: Cho 1 R
# 5: Draco 0 S
# 6: Ginny -1 G
students[name=="Ginny"] # obtener filas con name == "Ginny"
# =>
# name year house
# 1: Ginny -1 G
students[year==2] # obtener filas con year == 2
# =>
# name year house
# 1: Fred 2 G
# 2: George 2 G
# data.table hace que la unificación de dos sets de datos sea fácil
# Hagamos otro data.table para unifiar a los estudiantes
founders <- data.table(house=c("G","H","R","S"),
founder=c("Godric","Helga","Rowena","Salazar"))
founders
# =>
# house founder
# 1: G Godric
# 2: H Helga
# 3: R Rowena
# 4: S Salazar
setkey(students, house)
setkey(founders, house)
students <- founders[students] # Unifica los dos sets de datos comparando "house"
setnames(students, c("house","houseFounderName","studentName","year"))
students[,order(c("name","year","house","houseFounderName")), with=F]
# =>
# studentName year house houseFounderName
# 1: Fred 2 G Godric
# 2: George 2 G Godric
# 3: Ginny -1 G Godric
# 4: Cedric 3 H Helga
# 5: Cho 1 R Rowena
# 6: Draco 0 S Salazar
# data.table hace que sea fácil obtener resúmenes de las tablas
students[,sum(year),by=house]
# =>
# house V1
# 1: G 3
# 2: H 3
# 3: R 1
# 4: S 0
# Para eliminar una columna de un data.frame o data.table,
# asignarle el valor NULL.
students$houseFounderName <- NULL
students
# =>
# studentName year house
# 1: Fred 2 G
# 2: George 2 G
# 3: Ginny -1 G
# 4: Cedric 3 H
# 5: Cho 1 R
# 6: Draco 0 S
# Elimina una fila poniendo un subconjunto
# Usando data.table:
students[studentName != "Draco"]
# =>
# house studentName year
# 1: G Fred 2
# 2: G George 2
# 3: G Ginny -1
# 4: H Cedric 3
# 5: R Cho 1
# Usando data.frame:
students <- as.data.frame(students)
students[students$house != "G",]
# =>
# house houseFounderName studentName year
# 4 H Helga Cedric 3
# 5 R Rowena Cho 1
# 6 S Salazar Draco 0
# MULTI-DIMENSIONAL (TODOS LOS ELEMENTOS DE UN TIPO)
# Arreglos crean una tabla de dimensión n
# Todos los elementos deben de ser del mismo tipo
# Puedes hacer una tabla bi-dimensional (como una matriz)
array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4))
# =>
# [,1] [,2] [,3] [,4]
# [1,] 1 4 8 3
# [2,] 2 5 9 6
# Puedes utilizar un arreglo para hacer una matriz tri-dimensional también
array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
# =>
# , , 1
#
# [,1] [,2]
# [1,] 2 8
# [2,] 300 9
# [3,] 4 0
#
# , , 2
#
# [,1] [,2]
# [1,] 5 66
# [2,] 60 7
# [3,] 0 847
# LISTAS (MULTI-DIMENSIONAL, POSIBLEMENTE DESIGUALES, DE DIFERENTES TIPOS)
# Finalmente, R tiene listas (de vectores)
list1 <- list(time = 1:40)
list1$price = c(rnorm(40,.5*list1$time,4)) # aleatorio
list1
# Puedes obtener elementos de una lista de la siguiente manera
list1$time # Una manera
list1[["time"]] # Otra manera
list1[[1]] # Y otra manera
# =>
# [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
# [34] 34 35 36 37 38 39 40
# Puedes crear una lista de subconjuntos como cualquier otro vector
list1$price[4]
# Las listas no son la estructura de datos más eficiente para trabajar en R;
# a menos de que tengas una buena razón, deberías de quedarte con data.frames
# Las listas son usualmente devueltas por funciones que realizan regresiones
# lineales
##################################################
# La familia de funciones apply()
##################################################
# Te recuerdas de mat?
mat
# =>
# [,1] [,2]
# [1,] 1 4
# [2,] 2 5
# [3,] 3 6
# Utiliza apply(X, MARGIN, FUN) paraaplicar una función FUN a la matriz X
# sobre las filas (MAR = 1) o las columnas (MAR = 2)
# Eso es, R aplica FUN sobre cada fila (o columna) de X, mucho más rápido que
# lo que haría un ciclo 'for' o 'loop'
apply(mat, MAR = 2, jiggle)
# =>
# [,1] [,2]
# [1,] 3 15
# [2,] 7 19
# [3,] 11 23
# Otras funciones: ?lapply, ?sapply
# No te sientas muy intimidado; todos están de acuerdo que son confusas
# El paquete plyr busca reemplazar (y mejorar) la familiar *apply()
install.packages("plyr")
require(plyr)
?plyr
#########################
# Carga de datos
#########################
# "pets.csv" es un archivo en internet
# (pero puede ser tan fácil como tener el archivo en tu computadora)
pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv")
pets
head(pets, 2) # primeras dos filas
tail(pets, 1) # última fila
# Para guardar un data frame o una matriz como un archivo .csv
write.csv(pets, "pets2.csv") # para hacer un nuevo archivo .csv
# definir el directorio de trabajo con setwd(), búscalo con getwd()
# Prueba ?read.csv ?write.csv para más información
#########################
# Gráficas
#########################
# FUNCIONES PREDEFINIDAS DE GRAFICACIÓN
# Gráficos de dispersión!
plot(list1$time, list1$price, main = "fake data")
# Regresiones!
linearModel <- lm(price ~ time, data = list1)
linearModel # Muestra el resultado de la regresión
# Grafica la línea de regresión
abline(linearModel, col = "red")
# Obtiene una veridad de diagnósticos
plot(linearModel)
# Histogramas!
hist(rpois(n = 10000, lambda = 5), col = "thistle")
# Barras!
barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
# GGPLOT2
# Pero éstas no son las gráficas más bonitas de R
# Prueba el paquete ggplot2 para mayor variedad y mejores gráficas
install.packages("ggplot2")
require(ggplot2)
?ggplot2
pp <- ggplot(students, aes(x=house))
pp + geom_histogram()
ll <- as.data.table(list1)
pp <- ggplot(ll, aes(x=time,price))
pp + geom_point()
# ggplot2 tiene una excelente documentación
# (disponible en http://docs.ggplot2.org/current/)
```
## ¿Cómo obtengo R?
* Obtén R y R GUI de [http://www.r-project.org/](http://www.r-project.org/)
* [RStudio](http://www.rstudio.com/ide/) es otro GUI

324
es-es/rust-es.html.markdown Normal file
View File

@ -0,0 +1,324 @@
---
language: rust
contributors:
- ["P1start", "http://p1start.github.io/"]
translators:
- ["Razican", "https://www.razican.com/"]
filename: learnrust-es.rs
lang: es-es
---
Rust es un lenguaje de programación desarrollado por Mozzilla Research. Rust
combina el control del rendimiento a bajo nivel con la comodidad del alto nivel
y garantías de seguridad.
Consigue cumplir estos objetivos sin necesidad de un recolector de basura o
runtime, haciendo posible usar las librerías de Rust como sustituto de C.
La primera versión de Rust, la 0.1, fue lanzada en enero de 2012, y durante 3
años el desarrollo fue tan rápido que hasta hace poco el uso de las versiones
estables no era recomendable, y se aconsejaba usar las compilaciones nocturnas.
El 15 de mayo de 2015 se lanzó Rust 1.0, con una garantía completa de
retrocompatibilidad. A día de hoy los tiempos de compilación han mejorado mucho
desde ese lanzamiento, así como otros aspectos del lenguaje y el compilador.
Rust ha adoptado un modelo de desarrollo por series de publicaciones periódicas,
con lanzamientos cada 6 semanas. Junto con cada lanzamiento, se lanza la beta de
la siguiente versión.
A pesar de que Rust es un lenguaje relativamente de bajo nivel, tiene conceptos
funcionales que generalmente se encuentran en lenguajes de más alto nivel. Esto
hace que Rust sea rápido y al mismo tiempo fácil y eficiente a la hora de
programar.
```rust
// Esto es un comentario. Los comentarios de una sola línea se hacen así...
/* ...y los de múltiples líneas así */
//////////////////////////
// 1. Conceptos básicos //
//////////////////////////
// Funciones
// `i32` es el tipo para enteros de 32 bits con signo
fn suma2(x: i32, y: i32) -> i32 {
// Retorno implícito (sin punto y coma)
x + y
}
// Función principal
fn main() {
// N;umeros //
// Bindings (variables) inmutables
let x: i32 = 1;
// Sufijos para enteros / floats
let y: i32 = 13i32;
let f: f64 = 1.3f64;
// Inferencia de tipos
// La mayor parte del tiempo, el compilador de Rust puede inferir el tipo de
// una variable, por lo que no necesitas escribir una anotación de tipo
// explícita. A lo largo de este tutorial, los tipos están anotados
// explícitamente en varios sitios, pero solo con propósito demostrativo. La
// inferencia de tipos puede manejar esto por ti la mayor parte del tiempo.
let x_implicita = 1;
let f_implicita = 1.3;
// Aritmética
let sum = x + y + 13;
// Variable mutable
let mut mutable = 1;
mutable = 4;
mutable += 2;
// Strings (cadenas de caracteres) //
// Strings literales
let x: &str = "hola mundo!";
// Impresión por consola
println!("{} {}", f, x); // 1.3 hola mundo!
// Un `String` – una cadena en memoria dinámica (heap)
let s: String = "hola mundo".to_string();
// Una porión de cadena (slice) – una vista inmutable a otra cadena
// Esto es básicamente un puntero inmutable a un string string – en realidad
// no contiene los caracteres de la cadena, solo un puntero a algo que los
// tiene (en este caso, `s`)
let s_slice: &str = &s;
println!("{} {}", s, s_slice); // hola mundo hola mundo
// Vectores/arrays //
// A fixed-size array
let cuatro_enteros: [i32; 4] = [1, 2, 3, 4];
// Un array dinámico (vector)
let mut vector: Vec<i32> = vec![1, 2, 3, 4];
vector.push(5);
// Una porción (slice) – una vista inmutable a un vector o array
// Esto es parecido a un slice de un string, pero para vectores
let slice: &[i32] = &vector;
// Usa `{:?}` para imprimir algo en estilo debug
println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
// Tuplas //
// Una tupla es un conjunto de tamaño fijo de valores. Pueden ser de diferente tipo.
let x: (i32, &str, f64) = (1, "hola", 3.4);
// Desestructurando `let`
let (a, b, c) = x;
println!("{} {} {}", a, b, c); // 1 hola 3.4
// Indexando
println!("{}", x.1); // hola
//////////////
// 2. Tipos //
//////////////
// Estructuras
struct Punto {
x: i32,
y: i32,
}
let origen: Punto = Punto { x: 0, y: 0 };
// Una estructura con campos sin nombre, una ‘estructura de tupla’
struct Punto2(i32, i32);
let origen2 = Punto2(0, 0);
// Enums básicos como en C
enum Direccion {
Izquierda,
Derecha,
Arriba,
Abajo,
}
let arriba = Direccion::Arriba;
// Enum con campos
enum OpcionalI32 {
UnI32(i32),
Nada,
}
let dos: OpcionalI32 = OpcionalI32::UnI32(2);
let nada = OpcionalI32::Nada;
// Genéricos //
struct Foo<T> { bar: T }
// Esto está definido en la librería estándar como `Option`
enum Opcional<T> {
AlgunVal(T),
SinVal,
}
// Métodos //
impl<T> Foo<T> {
// Los métodos reciben un parámetro explícito `self`
fn get_bar(self) -> T {
self.bar
}
}
let un_foo = Foo { bar: 1 };
println!("{}", un_foo.get_bar()); // 1
// Traits (conocidos como interfaces o typeclasses en otros lenguajes) //
trait Frobnicate<T> {
fn frobnicate(self) -> Option<T>;
}
impl<T> Frobnicate<T> for Foo<T> {
fn frobnicate(self) -> Option<T> {
Some(self.bar)
}
}
let otro_foo = Foo { bar: 1 };
println!("{:?}", otro_foo.frobnicate()); // Some(1)
/////////////////////////////////
// 3. Comparación con patrones //
/////////////////////////////////
let foo = OpcionalI32::UnI32(1);
match foo {
OpcionalI32::UnI32(n) => println!("es un i32: {}", n),
OpcionalI32::Nada => println!("no es nada!"),
}
// comparación de patrones avanzada
struct FooBar { x: i32, y: OpcionalI32 }
let bar = FooBar { x: 15, y: OpcionalI32::UnI32(32) };
match bar {
FooBar { x: 0, y: OpcionalI32::UnI32(0) } =>
println!("Los números son cero!"),
FooBar { x: n, y: OpcionalI32::UnI32(m) } if n == m =>
println!("Los números son iguales"),
FooBar { x: n, y: OpcionalI32::UnI32(m) } =>
println!("Números diferentes: {} {}", n, m),
FooBar { x: _, y: OpcionalI32::Nada } =>
println!("El segudo número no es nada!"),
}
/////////////////////////
// 4. Flujo de control //
/////////////////////////
// bucles `for`
let array = [1, 2, 3];
for i in array.iter() {
println!("{}", i);
}
// Rangos
for i in 0u32..10 {
print!("{} ", i);
}
println!("");
// imprime `0 1 2 3 4 5 6 7 8 9 `
// `if`
if 1 == 1 {
println!("Las matemáticas funcionan!");
} else {
println!("Oh no...");
}
// `if` como una expresión
let valor = if true {
"bueno"
} else {
"malo"
};
// bucle `while`
while 1 == 1 {
println!("El universo está funcionando correctamente.");
}
// Bucle infinito
loop {
println!("Hola!");
}
////////////////////////////////////////
// 5. Seguridad de memoria y punteros //
////////////////////////////////////////
// Posesión de punteros – solo uno puede ‘poseer’ un puntero en cada momento
// Esto significa que cuando la `Box` queda fuera del ámbito, puede ser
// liberada automáticamente de manera segura.
let mut mio: Box<i32> = Box::new(3);
*mio = 5; // dereferenciar
// Aquí, `ahora_es_mio`, toma posesión de `mio`. En otras palabras, `mio` se
// mueve.
let mut ahora_es_mio = mio;
*ahora_es_mio += 2;
println!("{}", ahora_es_mio); // 7
// println!("{}", mio); // esto no compilaría, porque `now_its_mine` es el
// que posee el puntero
// Referencia – un puntero inmutable que referencia a otro dato
// Cuando se crea una referencia a un valor, decimos que el valor ha sido
// ‘tomado prestado’.
// Mientras un valor está prestado como inmutable, no puede ser modificado o
// movido.
// Una prestación dura hasta el fin del ámbito en el que se creó.
let mut var = 4;
var = 3;
let ref_var: &i32 = &var;
println!("{}", var); // A diferencia de `mio`, `var` se puede seguir usando
println!("{}", *ref_var);
// var = 5; // esto no compilaría, porque `var` está prestada
// *ref_var = 6; // esto tampoco, porque `ref_var` es una referencia
// inmutable
// Referencia mutable
// Mientras que un valor está prestado como mutable, no puede ser accedido
// desde ningún otro sitio.
let mut var2 = 4;
let ref_var2: &mut i32 = &mut var2;
*ref_var2 += 2; // '*' se usa para apuntar al var2 prestado como mutable
println!("{}", *ref_var2); // 6 , //var2 no compilaría. //ref_var2 es de
// tipo &mut i32, por lo que guarda una
// referencia a un i32 no el valor.
// var2 = 2; // esto no compilaría porque `var2` está prestado
}
```
## Lectura adicional
Rust es mucho más que esto. Esto es solo lo más básico para que puedas entender
las cosas más importantes. Para aprender más sobre Rust, lee [The Rust
Programming Language](http://doc.rust-lang.org/book/index.html) y echa un
vistazo al subreddit [/r/rust](http://reddit.com/r/rust). Los compañeros en el
canal #rust en irc.mozilla.org también son muy buenos con los recien llegados.
También puedes acceder a [Rust users](https://users.rust-lang.org/) a pedir
ayuda o a [Rust internals](https://internals.rust-lang.org/) para aprender más
sobre el lenguaje y colaborar en su desarrollo.
También puedes probar Rust con un compilador online en el oficial [Rust
playpen](http://play.rust-lang.org) o en la [web principal de
Rust](http://rust-lang.org).

189
es-es/yaml-es.html.markdown
View File

@ -4,6 +4,7 @@ lang: es-es
filename: learnyaml-es.yaml
contributors:
- ["Adam Brenecki", "https://github.com/adambrenecki"]
- ["Everardo Medina","https://github.com/everblut"]
translators:
- ["Daniel Zendejas","https://github.com/DanielZendejas"]
---
@ -14,7 +15,7 @@ leído y escrito por humanos.
Basa su funcionalidad en JSON, con la adición de líneas nuevas
e indentación inspirada en Python. A diferencia de Python, YAML
no permite tabs literales.
no permite tabulaciones literales.
```yaml
# Los comentarios en YAML se ven así.
@ -38,97 +39,177 @@ llave con espacios: valor
llave: "Un string, entre comillas."
"Las llaves tambien pueden estar entre comillas.": "valor entre comillas"
# Los strings de líneas múltiples pueden ser escritos
# Los strings de líneas múltiples pueden ser escritos
# como un 'bloque literal' (usando pipes |)
# o como un 'bloque doblado' (usando >)
bloque_literal: |
Este bloque completo de texto será preservado como el valor de la llave
'bloque_literal', incluyendo los saltos de línea.
Se continúa guardando la literal hasta que se cese la indentación.
Se continúa guardando la literal hasta que se cese la indentación.
Cualquier línea que tenga más indentación, mantendrá los espacios dados
(por ejemplo, estas líneas se guardarán con cuatro espacios)
nloque_doblado: >
bloque_doblado: >
De la misma forma que el valor de 'bloque_literal', todas estas
líneas se guardarán como una sola literal, pero en esta ocasión todos los
saltos de línea serán reemplazados por espacio.
Las líneas en blanco, como la anterior, son convertidos a un salto de línea.
Las líneas en blanco, como la anterior, son convertidas a un salto de línea.
Las líneas con mayor indentación guardan sus saltos de línea.
Esta literal ocuparán dos líneas.
########################
# TIPOS DE COLECCIONES #
########################
# La indentación se usa para anidar.
# La indentación se usa para anidar elementos
un_mapa_indentado:
llave: valor
otra_llave: otro valor
otro_mapa_indentado:
llave_interna: valor_interno
# Las llaves de los mapas no deben ser strings necesariamente
# Las llaves de los mapas no requieren ser strings necesariamente
0.25: una llave numérica
# Las llaves también pueden ser objetos de multi línea, usando ? para indicar
# el inicio de una llave
# Las llaves también pueden ser objetos de multiples líneas,
# usando ? para indicar el inicio de una llave
? |
Esto es una llave
que tiene múltiples líneas
: y este es su valor
# YAML tambien permite colecciones como llaves, pero muchos lenguajes de
########################
# TIPOS DE COLECCIONES #
########################
# Las colecciones en YAML usan la indentación para delimitar el alcance
# y cada elemento de la colección inicia en su propia línea.
# YAML tambien permite colecciones como llaves, pero muchos lenguajes de
# programación se quejarán.
# Las secuencias (equivalentes a listas o arreglos) se ven así:
una_secuencia:
- Item 1
- Item 2
- 0.5 # las secuencias pueden tener distintos tipos en su contenido.
- Item 4
- llave: valor
otra_llave: otro_valor
- Amarillo
- Verde
- Azul
# Se puede usar una secuencia como valor para una llave.
secuencia:
- Elemento 1
- Elemento 2
- Elemento 3
- Elemento 4
# Las secuencias pueden contener secuencias como elementos.
- [Uno, Dos, Tres]
- [Domingo, Lunes, Martes]
- [Luna, Marte, Tierra]
# Las secuencias pueden tener distintos tipos en su contenido.
secuencia_combinada:
- texto
- 5
- 0.6
- llave: valor # se convierte en un json dentro de la secuencia
-
- Esta es una secuencia
- ...dentro de otra secuencia
# Dado que todo JSON está incluído dentro de YAML, también puedes escribir
# mapas con la sintaxis de JSON y secuencias:
mapa_de_json: {"llave": "valor"}
secuencia_de_json: [3, 2, 1, "despegue"]
# Dado que todo JSON está incluído dentro de YAML, también puedes escribir
# mapas con la sintaxis de JSON y secuencias:
mapa_de_json_1: {"llave": "valor"}
mapa_de_json_2:
llave: valor
# Las secuencias tambien se pueden escribir como un arreglo al estilo JSON
secuencia_de_json_1: [3, 2, 1, "despegue"]
secuencia_de_json_2:
- 3
- 2
- 1
- "despegue"
# YAML también soporta conjuntos usando el simbolo ?
# y se ven de la siguiente forma:
set:
? item1
? item2
? item3
# Se puede usar el tag !!set
# Al igual que Python, los conjuntos sólo son mapas con valores nulos.
# El ejemplo de arriba es equivalente a:
set2:
item1: null
item2: null
item3: null
##################################
# CARACTERÍSTICAS EXTRAS DE YAML #
##################################
# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten
# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo
# a continuación, ambas llaves tendrán el mismo valor:
contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves
otra_ancla: *nombre_del_ancla
# YAML usa tres guiones (---) para diferenciar entre directivas
# y contenido del documento.
# Por otra parte, tres puntos (...) se utilizan para indicar
# el final del documento en casos especiales.
# YAML también tiene tags, que puedes usar para declarar tipos explícitamente.
string_explícito: !!str 0.5
# Algunos parseadores implementar tags específicas del lenguaje, como el
# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten
# duplicar fácilmente contenido a lo largo de tu documento.
# El ampersand indica la declaración del ancla,
declara_ancla: &texto texto de la llave
# el asterisco indica el uso de dicha ancla.
usa_ancla: *texto # tendrá el valor "texto de la llave"
################
# TAGS EN YAML #
################
# En YAML, los nodos que no tienen un tag obtienen su tipo
# según la aplicación que los use, al usar un tag
# se pueden declarar tipos explícitamente.
string_explicito: !!str 0.5 # !!str para declarar un string
integer_explicito: !!int 5 # !!int para declarar un integer
float_explicito: !!float 1.2 # !!float para declarar un float
conjunto_explicito: !!set # !!set para declarar un conjunto
? Uno
? Dos
? Tres
mapa_ordenado_explicito: !!omap # !!omap para declarar un mapa ordenado
- Primero: 1
- Segundo: 2
- Tercero: 3
- Cuarto: 4
# Tags para los numeros enteros
llave_canonica: 5222
llave_decimal: +5222
llave_octal: 010
llave_hexadecimal: 0xC
#Tags para los numeros flotantes
llave_canonica: 1.215e+3
llave_exponencial: 12.3555e+02
llave_fija: 12.15
llave_negativa_infinita: -.inf
llave_numero_invalido: .NaN
# Tags para las fechas y horas
llave_canonica: 2001-12-15T02:59:43.1Z
llave_iso8601: 2001-12-14t21:59:43.10-05:00
llave_con_espacios: 2001-12-14 21:59:43.10 -5
llave_fecha: 2002-12-14
# Además existen tags para
null: #valor nulo
booleans: [ true, false ] # Valores booleanos
string: '012345' # Valor en string
# Algunos parseadores implementan tags específicas del lenguaje, como el
# que se muestra a continuación, encargado de manejar números complejos en
# Python:
numero_complejo_python: !!python/complex 1+2j
########################
# TIPOS EXTRAS EN YAML #
########################
# Stirngs y números no son los únicos escalares que YAML puede entener.
# YAML también puede parsear fechas en formato ISO .
fechaHora: 2001-12-15T02:59:43.1Z
fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5
fecha: 2002-12-14
# La tag !!binary indica que un string es, en realidad, un blob
# El tag !!binary indica que un string es en realidad un blob
# representado en base-64.
archivo_gif: !!binary |
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
@ -136,16 +217,10 @@ archivo_gif: !!binary |
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
# YAML también tiene un tipo set, que se ve de la siguiente forma:
set:
? item1
? item2
? item3
# Al igual que Python, los sets sólo son mapas con valores nulos.
# El ejemplo de arriba es equivalente a:
set2:
item1: null
item2: null
item3: null
```
### Recursos adicionales
+ [Sitio oficial de YAML](http://yaml.org/)
+ [Parser en línea de de YAML](http://yaml-online-parser.appspot.com/)
+ [Validador en línea de YAML](http://codebeautify.org/yaml-validator)

2
fa-ir/brainfuck-fa.html.markdown → fa-ir/bf-fa.html.markdown
View File

@ -1,5 +1,5 @@
---
language: brainfuck
language: bf
contributors:
- ["Mohammad Valipour", "https://github.com/mvalipour"]
lang: fa-ir

307
fa-ir/css-fa.html.markdown Normal file
View File

@ -0,0 +1,307 @@
---
language: css
contributors:
- ["Mohammad Valipour", "https://github.com/mvalipour"]
- ["Marco Scannadinari", "https://github.com/marcoms"]
- ["Geoffrey Liu", "https://github.com/g-liu"]
- ["Connor Shea", "https://github.com/connorshea"]
- ["Deepanshu Utkarsh", "https://github.com/duci9y"]
- ["Tyler Mumford", "https://tylermumford.com"]
translators:
- ["Arashk", "https://github.com/Arashk-A"]
lang: fa-ir
filename: learncss-fa.css
---
<p dir='rtl'>در روزهای آغازین وب هیچگونه عنصر بصری مشاهده نمیشد و محتوا به صورت متن خالی بود. </p>
<p dir='rtl'>اما با توسعه بیشتر مرورگرها صفحات وب کاملاً تصویری نیز رایج شد</p>
<p dir='rtl'>CSS زبان استانداردی که موجودیت آن برای حفظ جدایی بین محتوا (HTML) و نگاه و احساس از</p>
<p dir='rtl'>صفحات وب است.</p>
<p dir='rtl'>به طور خلاصه, کاری که CSS انجام میدهد ارائه نحوه ایست که شما را قادر به هدف قرار دادن</p>
<p dir='rtl'>عناصر مختلف در یک صفحه HTML کرده و امکان اختصاص خواص متفاوت بصری به آنها را میدهد.</p>
<p dir='rtl'>مانند هر زبانی, CSS نسخه های زیادی دارد که در اینجا توجه ما روی CSS2.0 است. با وجودی که این نسخه جدیدترین نسخه نمیباشد اما بیشترین پشتیبانی و سازگاری را در میان نسخه های مختلف را دارد</p>
<p dir='rtl'><strong>توجه: </strong> برای مشاهده برخی از نتایج جلوه های تصویری CSS به منظور یادگیری بیشتر شما باید چیزهای گوناگونی در محیطی مثل [dabblet](http://dabblet.com/) امتحان کنید. توجه اصلی این مقاله روی دستورات و برخی از نکات عمومی است.</p>
<p dir='rtl'>در CSS همه توضیحات داخل ستاره-بروم نوشته میشوند زیرا CSS دستوری برای توضیحات تک خطی مثل C ندارد</p>
```CSS
/* comments appear inside slash-asterisk, just like this line!
there are no "one-line comments"; this is the only comment style */
```
<p dir='rtl'>به طور کلی دستورات CSS بسیار ساده هستند که در آن یک انتخابگر (selector) عنصری را در روی صفحه هدف قرار میدهد.</p>
```CSS
selector { property: value; /* more properties...*/ }
```
<p dir='rtl'>با استفاده از ستاره می توان برای همه عناصر روی صفحه استایل تعریف کرد</p>
```CSS
* { color:red; }
```
<p dir='rtl'>فرض کنید عنصری مثل این بر روی صفحه قرار دارد</p>
```html
<div class='some-class class2' id='someId' attr='value' otherAttr='en-us foo bar' />
```
<p dir='rtl'>شما میتوانید با استفاده از نام کلاس آنرا انتخاب کنید</p>
```CSS
.some-class { }
```
<p dir='rtl'>یا با استفاده از نام دو کلاس</p>
```CSS
.some-class.class2 { }
```
<p dir='rtl'>یا با استفاده از نام id</p>
```CSS
#someId { }
```
<p dir='rtl'>یا با استفاده از نام خود عنصر</p>
```CSS
div { }
```
<p dir='rtl'>یا با استفاده از `attr`</p>
```CSS
[attr] { font-size:smaller; }
```
<p dir='rtl'>یا با استفاده از ارزشی که برای `attr` مشخص شده</p>
```CSS
[attr='value'] { font-size:smaller; }
```
<p dir='rtl'>با استفاده از ارزشی که برای `attr` مشخص شده و آن ارزش با `val` شروع میشود در CSS3</p>
```CSS
[attr^='val'] { font-size:smaller; }
```
<p dir='rtl'>با استفاده از ارزشی که برای `attr` مشخص شده و آن ارزش با `ue` به پایان میرسد در CSS3</p>
```CSS
[attr$='ue'] { font-size:smaller; }
```
<p dir='rtl'>یا با انتخاب بوسیله یکی از ارزشهایی که در لیست `otherAttr` بوسیله فاصله از هم جدا شده اند در CSS3</p>
```CSS
[attr$='ue'] { font-size:smaller; }
```
<p dir='rtl'>یا ارزش(`value`) دقیقاً خود ارزش(`value`) یا بوسیله `-` که یونیکد (U+002D) از حرف بعدی جدا شود</p>
```CSS
[otherAttr|='en'] { font-size:smaller; }
```
<p dir='rtl'>و مهمتر از همه اینکه میتوان آنها را ترکیب کرد. نکته مهمی که در اینجا باید مد نظر داشته باشید این است که هنگام ترکیب نباید هیچگونه فاصله ای بین آنها قرار گیرد زیرا در این حالت معنای دستور تغییر میکند</p>
```CSS
div.some-class[attr$='ue'] { }
```
<p dir='rtl'>CSS این امکان را به شما میدهد که یک عنصر را بوسیله والدین آن انتخاب کنید</p>
<p dir='rtl'>برای مثال دستور زیر همه عناصری را که نام کلاس آنها <span dir="ltr">`.class-name`</span> و دارای پدر و مادری با این مشخصه <span dir="ltr">`div.some-parent`</span> هستند را انتخاب میکند.</p>
```CSS
div.some-parent > .class-name {}
```
<p dir='rtl'>یا دستور زیر که همه عناصری را که نام کلاس آنها <span dir="ltr">`.class-name`</span> و داخل عنصری با مشخصه <span dir="ltr">`div.some-parent`</span> هستند را در هر عمقی که باشند (یعنی فرزندی از فرزندان <span dir="ltr">`div.some-parent`</span><span dir="ltr"> باشند) انتخاب میکند.</p>
```CSS
div.some-parent .class-name {}
```
<p dir='rtl'>نکته ای که در اینجا باید به آن توجه کنید این است که این رستور با فاصله ای بین نام دو کلاس همراه است و با مثال زیر که در بالا هم ذکر شد تفاوت دارد.</p>
```CSS
div.some-parent.class-name {}
```
<p dir='rtl'>دستور زیر همه عناصری را که نام کلاس آنها <span dir="ltr">`.this-element`</span> و بلافاصله بعد از عنصری با مشخصه <span dir="ltr">`.i-am-before`</span> قرار دارد را انتخاب میکند.</p>
```CSS
.i-am-before + .this-element { }
```
<p dir='rtl'>هر خواهر یا برادری که بعد از <span dir="ltr">`.i-am-before`</span> بیاید در اینجا لازم نیست بلافاصله بعد از هم قرار بگیرند ولی باید دارای پدر و مادری یکسان باشند.</p>
```CSS
.i-am-any-before ~ .this-element {}
```
<p dir='rtl'>در زیر چند نمونه از شبه کلاسها را معرفی میکنیم که به شما اجازه میدهد عناصر را بر اساس رفتار آنها در صفحه انتخاب کنید.</p>
<p dir='rtl'>برای مثال زمانی که اشاره گر ماوس روی عنصری بر روی صفحه قرار دارد.</p>
```CSS
selector:hover {}
```
<p dir='rtl'>یا زمانی از یک لینک بازید کردید.</p>
```CSS
selected:visited {}
```
<p dir='rtl'>یا زمانی از لینکی بازید نشده است.</p>
```CSS
selected:link {}
```
<p dir='rtl'>یا زمانی که روی یک عنصر ورودی متمرکز شده.</p>
```CSS
selected:focus {}
```
<h3 dir='rtl'>واحدها</h3>
```CSS
selector {
/* واحدها اندازه */
width: 50%; /* در اساس درصد */
font-size: 2em; /* بر اساس اندازه font-size یعنی دو برابر اندازه فونت فعلی */
width: 200px; /* بر اساس پیکسل */
font-size: 20pt; /* بر اساس points (نکات) */
width: 5cm; /* بر اساس سانتیمتر */
min-width: 50mm; /* بر اساس میلیمتر */
max-width: 5in; /* بر اساس اینچ. max-(width|height) */
height: 0.2vh; /* بر اساس ارتفاع دید `vh = نسبت به 1٪ از ارتفاع دید` (CSS3) */
width: 0.4vw; /* بر اساس عرض دید `vw = نسبت به 1٪ از عرض دید` (CSS3) */
min-height: 0.1vmin; /* بر اساس کوچکترین مقدار از ارتفاع یا عرض دید (CSS3) */
max-width: 0.3vmax; /* مانند مثال بالا برای بیشترین مقدار (CSS3) */
/* رنگها */
background-color: #F6E; /* بر اساس short hex */
background-color: #F262E2; /* بر اساس long hex format */
background-color: tomato; /* بر اساس نام رنگ */
background-color: rgb(255, 255, 255); /* بر اساس rgb */
background-color: rgb(10%, 20%, 50%); /* بر اساس درصد rgb , (rgb percent) */
background-color: rgba(255, 0, 0, 0.3); /* بر اساس rgba (نیمه شفاف) , (semi-transparent rgb) (CSS3) */
background-color: transparent; /* شفاف */
background-color: hsl(0, 100%, 50%); /* بر اساس hsl format (CSS3). */
background-color: hsla(0, 100%, 50%, 0.3); /* بر اساس hsla ,مثل RGBAکه میتوان شفافیت را در آخر انتخاب کرد (CSS3) */
/* عکسها */
background-image: url(/path-to-image/image.jpg); /* گذاشتن نقل قول داخل url() اختیاری است*/
/* فونتها */
font-family: Arial;
font-family: "Courier New"; /* اگر اسم فونت با فاصله همراه باشد باید داخل نقل قول یک یا دو نوشته شود */
font-family: "Courier New", Trebuchet, Arial, sans-serif; /* اگر فونت اولی پیدا نشد مرورگر به سراغ نام بعدی میرود */
}
```
<h2 dir='rtl'>نحوه استفاده</h2>
<p dir='rtl'>هر دستور CSS را که می خواهید در فایلی با پسوند <span dir="ltr">.css</span> ذخیره کنید </p>
<p dir='rtl'>حالا با استفاده از کد زیر آنرا در قسمت `head` داخل فایل html خود تعریف کنید </p>
```html
<link rel='stylesheet' type='text/css' href='path/to/style.css' />
```
<p dir='rtl'>یا میتوان با استفاده از تگ `style` درون `head` دستورات CSS را به صورت درون برنامه ای تعریف کرد اما توسیه میشود تا جای ممکن از این کار اجتناب کنید. </p>
```html
<style>
a { color: purple; }
</style>
```
<p dir='rtl'>همچنین شما میتوانید دستورات CSS را به عنوان یک مشخصه برای عنصر تعریف کنید ولی تا جای ممکن باید از این کار اجتناب کنید.</p>
```html
<div style="border: 1px solid red;">
</div>
```
<h2 dir='rtl'>حق تقدم یا اولویت</h2>
<p dir='rtl'>همانگونه که مشاهده کردید یک مشخصه می تواند به وسیله چندین انتخابگر انتخاب گردد.</p>
<p dir='rtl'>و همچنین یک ویژگی میتواند چندین بار برای یک عنصر تعریف شود.</p>
<p dir='rtl'>در این صورت یک دستور میتواند بر دستورات دیگر حق تقدم یا اولویت پیدا کند.</p>
<p dir='rtl'>به مثال زیر توجه کنید:</p>
```CSS
/*A*/
p.class1[attr='value']
/*B*/
p.class1 {}
/*C*/
p.class2 {}
/*D*/
p {}
/*E*/
p { property: value !important; }
```
<p dir='rtl'>و همچنین به کد زیر:</p>
```html
<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
</p>
```
‍‍
<p dir='rtl'>حق تقدم یا اولویت برای مثال بالا به این صورت است:</p>
<p dir='rtl'>توجه داشته باشید که حق تقدم برای هر کدام از ویژگیها است نه برای کل مجموعه.</p>
<p dir='rtl'>E دارای بیشترین الویت برای اینکه از <span dir="ltr">`!important`</span> استفاده کرده.</p>
<p dir='rtl'>اما توصیه میشود تا جای ممکن از این کار اجتناب کنید مگر اینکه اینکار ضرورت داشته باشد</p>
<p dir='rtl'>اولویت بعدی با F است زیرا که از روش درون برنامه ای استفاده کرده </p>
<p dir='rtl'>اولویت بعدی با A است زیرا که بیشتر از بقیه مشخص تر تعریف شپه </p>
<p dir='rtl'>مشخص تر = مشخص کننده بیشتر. دارای ۳ مشخص کننده: ۱ تگ <span dir="ltr">`p`</span> + ۱ کلاس با نام <span dir="ltr">`class1`</span> + ۱ خاصیت <span dir="ltr">`attr="value"`</span></p>
<p dir='rtl'>اولویت بعدی با C است که مشخصه یکسانی با B دارد ولی بعد از آن تعریف شده است.</p>
<p dir='rtl'>اولویت بعدی با B</p>
<p dir='rtl'>و در آخر D</p>
<h2 dir='rtl'>سازگاری</h2>
<p dir='rtl'>بسیار از ویژگیهای CSS2 (و به تدریج CSS3) بر روی تمام مرورگرها و دستگاه ها سازگارند.اما همیشه حیاتی است که سازگاری CSS مورد استفاده خود را با مرورگر هدف چک کنید.</p>
<p dir='rtl'> یک منبع خوب برای این کار است</p>
[QuirksMode CSS](http://www.quirksmode.org/css/)
<p dir='rtl'>برای یک تست سازگاری سریع, منبع زیر میتواند کمک بزرگی برای این کار باشد.</p>
[CanIUse](http://caniuse.com/)
<h2 dir='rtl'> منابع دیگر </h2>
[Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
[QuirksMode CSS](http://www.quirksmode.org/css/)
[Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)

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 (don't 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)

12
fi-fi/markdown-fi.html.markdown
View File

@ -50,8 +50,8 @@ __Kuten on tämäkin teksti.__
**_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: -->
<!-- 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.~~
@ -150,7 +150,7 @@ rivin neljällä välilyönnillä tai tabulaattorilla. -->
John ei tiennyt edes mitä `go_to()` -funktio teki!
<!-- Githubin Markdownissa voit käyttää erityissyntaksia koodille. -->
<!-- GitHubin Markdownissa voit käyttää erityissyntaksia koodille. -->
\`\`\`ruby <!-- paitsi että poista nuo kenoviivat, vain ```ruby ! -->
def foobar
@ -158,7 +158,7 @@ def foobar
end
\`\`\` <!-- tästä myös, ei kenoviivoja, vain ``` -->
<!-- Yllä oleva teksti ei vaadi sisennystä. Lisäksi Github käyttää ``` jälkeen
<!-- Yllä oleva teksti ei vaadi sisennystä. Lisäksi GitHub käyttää ``` jälkeen
mainitsemasi kielen syntaksin korostusta -->
<!-- Vaakaviiva (<hr />) -->
@ -231,13 +231,13 @@ haluan kirjoittaa *tämän tekstin jonka ympärillä on asteriskit* mutta en hal
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ä -->
<!-- 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
<!-- Taulukot ovat saatavilla vain GitHubin markdownissa ja ne ovat melko
vaivalloisia käyttää, mutta jos todella haluat: -->
| Kolumni1 | Kolumni2 | Kolumni3 |

608
fi-fi/ruby-fi.html.markdown Normal file
View File

@ -0,0 +1,608 @@
---
language: ruby
filename: learnruby-fi.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"]
- ["Jake Faris", "https://github.com/farisj"]
translators:
- ["Oliver Vartiainen", "https://github.com/firoxer"]
lang: fi-fi
---
```ruby
# Tässä yhden rivin kommentti
=begin
Tässä usean rivin kommentti
Näitä ei kylläkään käytetä
Joten käytetään vastedes vain yksirivisiä
=end
# Tärkeintä on muistaa, että Rubyssa kaikki pohjautuu olioihin.
# Luvutkin ovat olioita:
3.class #=> Fixnum
3.to_s #=> "3"
# Peruslaskutoimituksia:
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
2**5 #=> 32
5 % 3 #=> 2
# Bittioperaatioita:
3 & 5 #=> 1
3 | 5 #=> 7
3 ^ 5 #=> 6
# Laskutoimitukset ovat vain syntaksisokeria lukuolion laskumetodin kutsulle:
1.+(3) #=> 4
10.* 5 #=> 50
# Erityisarvotkin ovat olioita:
nil # vastaa joidenkin kielten "null"-arvoa
true # tosi
false # epätosi
nil.class #=> NilClass
true.class #=> TrueClass
false.class #=> FalseClass
# Samanvertaisuuden testaus:
1 == 1 #=> true
2 == 1 #=> false
# ...ja sama eriarvoisuudelle:
1 != 1 #=> false
2 != 1 #=> true
# "nil" ja "false" ovat ainoat epätodet arvot; kaikki muu ymmärretään todeksi:
!nil #=> true
!false #=> true
!0 #=> false
# Lisää vertailuoperaatioita:
1 < 10 #=> true
1 > 10 #=> false
2 <= 2 #=> true
2 >= 2 #=> true
# Kahdensuuntainen vertailuoperaattori:
1 <=> 10 #=> -1
10 <=> 1 #=> 1
1 <=> 1 #=> 0
# Logiikkaoperaattorit:
true && false #=> false
true || false #=> true
!true #=> false
# Merkkipohjaisten logiikkaoperaattorien vaihtoehtona on sanalliset muodot,
# joilla on hyvin matala presedenssi. Niillä voi muokata ohjelman kulkua
# esimerkiksi väitelausekkeita ketjuttaen.
# Metodia `do_something_else` kutsutaan vain, jos `do_something` onnistuu:
do_something() and do_something_else()
# Metodia `log_error` kutsutaan vain, jos `do_something` epäonnistuu:
do_something() or log_error()
# Merkkijonot ovat olioita:
'Tässä on merkkijono'.class #=> String
"Rajaavat lainausmerkit voivat olla yksin- tai kaksinkertaisia".class #=> String
täyte = 'sisällyttää muita merkkijonoja'
"Kaksinkertaisilla lainausmerkeillä voi #{täyte}"
#=> "Kaksinkertaisilla lainausmerkeillä voi sisällyttää muita merkkijonoja"
# Yksinkertaisia lainausmerkkejä kannattaa silti suosia, sillä kaksinkertaiset
# merkit saattavat aiheuttaa turhia kielensisäisiä tarkistuksia.
# Merkkijonoja voi yhdistellä toisiinsa:
'hello ' + 'world' #=> "hello world"
# ...mutta luvut vaativat ensin tyyppimuunnoksen:
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
'hello ' + 3.to_s #=> "hello 3"
# Merkkijonoja voi soveltaa laskutoimituksiin... odotettavin seurauksin:
'hello ' * 3 #=> "hello hello hello "
# Merkkijonoa voi jatkaa toisella:
'hello' << ' world' #=> "hello world"
# Tulosteen luonti kera rivinvaihdon:
puts "I'm printing!"
#=> I'm printing!
#=> nil
# ...ja ilman rivinvaihtoa:
print "I'm printing!"
#=> I'm printing! => nil
# Muuttujien määrittely:
x = 25 #=> 25
x #=> 25
# Arvon asettaminen palauttaa arvon itsensä, joten usean muuttujan arvon
# yhtäaikainen määrittely käy vaivatta:
x = y = 10 #=> 10
x #=> 10
y #=> 10
# Muuttujien sanaerottimena käytetään alaviivaa:
snake_case = true
# Lisäksi Rubyssa suositaan ytimekkäitä nimiä:
path_to_project_root = '/good/name/'
path = '/bad/name/'
# Symbolit
# Symbolit ovat muuttumattomia, uudelleenkäytettäviä vakioita.
# Niitä käytetään merkkijonojen sijaan, kun tarkoitus on viitata arvoon,
# jolla on tietty, pysyvä merkitys:
:pending.class #=> Symbol
status = :pending
status == :pending #=> true
status == 'pending' #=> false
status == :approved #=> false
# Taulukot
# Tässä taulukko:
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
# Taulukko saa koostua erityyppisistä arvoista:
[1, 'hello', false] #=> [1, "hello", false]
# Taulukon alkioihin voi viitata järjestysnumerolla nollasta alkaen:
array[0] #=> 1
array.first #=> 1
array[12] #=> nil
# Kuten laskutoimituksissa nähty syntaksisokeri on myös taulukon alkioiden haku
# pohjimmiltaan vain taulukko-olioon kuuluvan "[]"-metodin kutsu:
array.[] 0 #=> 1
array.[] 12 #=> nil
# Haku käy myös lopustapäin:
array[-1] #=> 5
array.last #=> 5
# Alitaulukon haku käy indeksiparilla...
array[2, 3] #=> [3, 4, 5]
# ...tai määrittelemällä väli:
array[1..3] #=> [2, 3, 4]
# Taulukon voi kääntää:
a=[1,2,3]
a.reverse! #=> [3,2,1]
# Ja sitä voi jatkaa näin...
array << 6 #=> [1, 2, 3, 4, 5, 6]
# ...tai näin:
array.push(6) #=> [1, 2, 3, 4, 5, 6]
# Alkion olemassaolon tarkistus:
array.include?(1) #=> true
# Hashit eli assosiaatiotaulut ovat Rubyn tärkein avain-/arvoparirakenne.
# Hash luodaan aaltosulkeilla:
hash = { 'color' => 'green', 'number' => 5 }
hash.keys #=> ['color', 'number']
# Hash toimii erityisen nopeasti, kun haetaan arvoa avaimen perusteella:
hash['color'] #=> 'green'
hash['number'] #=> 5
# Jos hashistä ei löyty avainta vastaavaa arvoa, palautetaan nil-arvo:
hash['nothing here'] #=> nil
# Symbolihashin määrittelylle on oma syntaksinsa (alkaen Rubyn versiosta 1.9):
new_hash = { defcon: 3, action: true }
new_hash.keys #=> [:defcon, :action]
# Hashin avaimen ja arvon olemassaolon tarkistus:
new_hash.key?(:defcon) #=> true
new_hash.value?(3) #=> true
# Vinkki! Sekä taulukot että hashit sisältävät Enumerable-moduulin,
# johon kuuluu useita hyödyllisiä iterointimetodeja kuten .each, .map,
# .reduce ja .count
# Rakenteita
if true
'if statement'
elsif false
'else if, optional'
else
'else, also optional'
end
for counter in 1..5
puts "iteration #{counter}"
end
#=> iteration 1
#=> iteration 2
#=> iteration 3
#=> iteration 4
#=> iteration 5
# HUOMAA, että for-rakennetta kannattaa välttää, sillä Rubyssa suosittu
# each-metodi ajaa saman asian idiomaattisemmin. Each-metodi ottaa ainoana
# argumenttinaan lohkon. Lohkot toimivat pitkälti samoin kuin muiden kielten
# anonyymit funktiot, lambdat tai sulkeumat.
# Lukuvälit vastaavat each-metodiin, jolloin sille annettu lohko ajetaan
# kerran jokaiselle välin kokonaisluvulle.
# Lukuvälin each-rakenne lohkoineen näyttää tältä:
(1..5).each do |counter|
puts "iteration #{counter}"
end
#=> iteration 1
#=> iteration 2
#=> iteration 3
#=> iteration 4
#=> iteration 5
# Lohkoa ympäröivät do/end-avainsanat voi korvata myös aaltosulkeilla:
(1..5).each { |counter| puts "iteration #{counter}" }
# Lukuvälien lisäksi myös tietorakenteita voidaan iteroida each-metodilla:
array.each do |element|
puts "#{element} is part of the array"
end
hash.each do |key, value|
puts "#{key} is #{value}"
end
# Taulukoita voi iteroida metodilla each_with_index, jolloin lohko saa
# argumenteikseen sekä alkion että indeksin:
array.each_with_index do |element, index|
puts "#{element} is number #{index} in the array"
end
counter = 1
while counter <= 5 do
puts "iteration #{counter}"
counter += 1
end
#=> iteration 1
#=> iteration 2
#=> iteration 3
#=> iteration 4
#=> iteration 5
# Each-metodin lisäksi Rubyssa on useita muita iterointimetodeja kuten
# "map" ja "reduce". Näistä "map" kutsuttuna taulukolla ottaa argumentikseen
# lohkon, suorittaa sen kerran jokaiselle rakenteen jäsenelle, ja lopuksi
# palauttaa uuden taulukon, jonka jäsenet ovat lohkon suorituksen tuloksia.
array = [1, 2, 3, 4, 5]
doubled = array.map do |element|
element * 2
end
puts doubled
#=> [2,4,6,8,10]
puts array
#=> [1,2,3,4,5]
# Case-rakenne siirtää ohjelman kulun yhdelle monista määritellyistä poluista:
grade = 'B'
case grade
when 'A'
puts 'Way to go kiddo'
when 'B'
puts 'Better luck next time'
when 'C'
puts 'You can do better'
when 'D'
puts 'Scraping through'
when 'F'
puts 'You failed!'
else
puts 'Alternative grading system, eh?'
end
#=> "Better luck next time"
# Case-rakenteessa voidaan hyödyntää lukuvälejä:
grade = 82
case grade
when 90..100
puts 'Hooray!'
when 80...90
puts 'OK job'
else
puts 'You failed!'
end
#=> "OK job"
# Virheidenkäsittely:
begin
# Seuraava koodinpätkä aiheuttaa NoMemoryError-poikkeuksen
raise NoMemoryError, 'You ran out of memory.'
rescue NoMemoryError => exception_variable
puts 'NoMemoryError was raised', exception_variable
rescue RuntimeError => other_exception_variable
puts 'RuntimeError was raised now'
else
puts 'This runs if no exceptions were thrown at all'
ensure
puts 'This code always runs no matter what'
end
# Ylimmän näkyvyysalueen metodi näyttää itsenäiseltä funktiolta:
def double(x)
x * 2
end
# Funktiot (ja lohkot) palauttavat implisiittisesti
# viimeiseksi ajamansa lausekkeen arvon:
double(2) #=> 4
# Metodikutsun argumentteja ympäröivät kaarisulkeet voi jättää pois,
# kunhan koodi ei muutu monitulkintaiseksi:
double 3 #=> 6
double double 3 #=> 12
def sum(x, y)
x + y
end
# Argumentit erotetaan pilkuilla:
sum 3, 4 #=> 7
sum sum(3, 4), 5 #=> 12
# Kaikilla metodeilla on implisiittinen lohkoparametri,
# joka voidaan suorittaa yield-avainsanalla:
def surround
puts '{'
yield
puts '}'
end
surround { puts 'hello world' }
# {
# hello world
# }
# Metodille annetun lohkon voi nimetä parametrilistassa &-merkin avulla,
# minkä jälkeen se suoritetaan call-metodilla:
def guests(&block)
block.call 'some_argument'
end
# Metodille voi antaa vaihtelevan määrän muuttujia. Ne siirretään taulukkoon,
# jolle annetaan parametrilistassa nimi \*-merkin avulla
def guests(*array)
array.each { |guest| puts guest }
end
# Luokan määritys aloitetaan class-avainsanalla:
class Human
# Tässä luokkamuuttuja, joka on yhteinen kaikille luokan olioille:
@@species = 'H. sapiens'
# Alustusmetodin määrittely:
def initialize(name, age = 0)
# name-oliomuuttujan arvon asetus metodille annetun name-muuttujan mukaan:
@name = name
# Jos tätä metodia kutsuessa jätetään toinen argumentti (age) antamatta,
# saa se parametriluettelossa määritetyn arvon 0:
@age = age
end
# Tyypillinen oliomuuttujan arvon asettava metodi:
def name=(name)
@name = name
end
# Tyypillinen oliomuuttujan arvon palauttava metodi:
def name
@name
end
# Edelliset kaksi metodia voi ilmaista idiomaattisemmin myös näin:
attr_accessor :name
# Lisäksi arvon palauttavan ja asettavan metodin voi määritellä erikseen:
attr_reader :name
attr_writer :name
# Luokkametodeissa käytetään avainsanaa self erotuksena oliometodeista.
# Luokkametodia voi kutsua vain luokalla itsellään, ei olioilla:
def self.say(msg)
puts msg
end
def species
@@species
end
end
# Olion luonti:
jim = Human.new('Jim Halpert')
dwight = Human.new('Dwight K. Schrute')
# Olion metodien kutsuja:
jim.species #=> "H. sapiens"
jim.name #=> "Jim Halpert"
jim.name = "Jim Halpert II" #=> "Jim Halpert II"
jim.name #=> "Jim Halpert II"
dwight.species #=> "H. sapiens"
dwight.name #=> "Dwight K. Schrute"
# Luokkametodin kutsu:
Human.say('Hi') #=> "Hi"
# Muuttujan näkyvyysalueen voi määritellä etuliitteellä.
# $-alkuiset muuttujat ovat globaaleja:
$var = "I'm a global var"
defined? $var #=> "global-variable"
# @-alkuiset muuttujat kuuluvat oliolle,
# jonka näkyvyysalueella määrittely tehdään:
@var = "I'm an instance var"
defined? @var #=> "instance-variable"
# @@-alkuiset muuttujat kuuluvat vastaavasti näkyvyysalueensa luokalle:
@@var = "I'm a class var"
defined? @@var #=> "class variable"
# Isolla alkukirjaimella nimetyt muuttujat ovatkin vakioita:
Var = "I'm a constant"
defined? Var #=> "constant"
# Kuten odottaa saattaa, myös luokat itsessään ovat olioita.
# Siksi niille voi määritellä muuttujia, jotka ovat yhteisiä kaikille
# luokan ilmentymille ja perillisille.
# Tavallisen luokan määrittely:
class Human
@@foo = 0
def self.foo
@@foo
end
def self.foo=(value)
@@foo = value
end
end
# Perillisluokan määrittely:
class Worker < Human
end
Human.foo # 0
Worker.foo # 0
Human.foo = 2 # 2
Worker.foo # 2
# Oliomuuttuja on kuitenkin olion oma eikä periydy:
class Human
@bar = 0
def self.bar
@bar
end
def self.bar=(value)
@bar = value
end
end
class Doctor < Human
end
Human.bar # 0
Doctor.bar # nil
module ModuleExample
def foo
'foo'
end
end
# Moduulien lisääminen luokkaan "include"-avainsanalla siirtää moduulin metodit
# luokan ilmentymille, kun taas "extend" avainsana siirtää metodit
# luokalle itselleen:
class Person
include ModuleExample
end
class Book
extend ModuleExample
end
Person.foo # => NoMethodError: undefined method `foo' for Person:Class
Person.new.foo # => 'foo'
Book.foo # => 'foo'
Book.new.foo # => NoMethodError: undefined method `foo'
# Callback-tyyppiset metodit suoritetaan moduulia sisällyttäessä:
module ConcernExample
def self.included(base)
base.extend(ClassMethods)
base.send(:include, InstanceMethods)
end
module ClassMethods
def bar
'bar'
end
end
module InstanceMethods
def qux
'qux'
end
end
end
class Something
include ConcernExample
end
Something.bar # => 'bar'
Something.qux # => NoMethodError: undefined method `qux'
Something.new.bar # => NoMethodError: undefined method `bar'
Something.new.qux # => 'qux'
```
## Lisämateriaalia englanniksi
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Selaimessa tehtäviä harjoituksia tämän dokumentin hengessä
- [An Interactive Tutorial for Ruby](https://rubymonk.com/)
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/) - Virallinen dokumentaatio
- [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/) - Vanhempi, mutta [ilmainen painos](http://ruby-doc.com/docs/ProgrammingRuby/) on luettavissa netissä
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Yhteisön luoma Ruby-tyyliopas
- [Try Ruby](http://tryruby.org) - Rubyn perusteet interaktiivisesti

2
forth.html.markdown
View File

@ -54,7 +54,7 @@ Forth, but most of what is written here should work elsewhere.
3 dup - \ duplicate the top item (1st now equals 2nd): 3 - 3
2 5 swap / \ swap the top with the second element: 5 / 2
6 4 5 rot .s \ rotate the top 3 elements: 4 5 6
4 0 drop 2 / \ remove the top item (dont print to screen): 4 / 2
4 0 drop 2 / \ remove the top item (don't print to screen): 4 / 2
1 2 3 nip .s \ remove the second item (similar to drop): 1 3
\ ---------------------- More Advanced Stack Manipulation ----------------------

3
fr-fr/HTML-fr.html.markdown
View File

@ -5,6 +5,7 @@ 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).
@ -17,7 +18,7 @@ Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parl
Cet article porte principalement sur la syntaxe et quelques astuces.
```HTML
```html
<!-- Les commentaires sont entouré comme cette ligne! -->
<!-- #################### Les balises #################### -->

2
fr-fr/brainfuck-fr.html.markdown → fr-fr/bf-fr.html.markdown
View File

@ -1,5 +1,5 @@
---
language: brainfuck
language: bf
filename: learnbrainfuck-fr.bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]

12
fr-fr/d.html.markdown
View File

@ -8,7 +8,7 @@ translators:
lang: fr-fr
---
```d
```c
// Commençons par un classique
module hello;
@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui
[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
```d
```c
import std.stdio;
void main() {
@ -75,7 +75,7 @@ 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
```c
// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
struct LinkedList(T) {
T data = null;
@ -140,7 +140,7 @@ 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
```c
// Considérons une classe paramétrée avec les types 'T' et 'U'
class MyClass(T, U) {
T _data;
@ -212,7 +212,7 @@ 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
```c
import std.algorithm : map, filter, reduce;
import std.range : iota; // construit un intervalle excluant la dernière valeur.
@ -242,7 +242,7 @@ 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
```c
import std.stdio;
import std.parallelism : parallel;
import std.math : sqrt;

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

@ -3,7 +3,7 @@ name: Go
category: language
language: Go
lang: fr-fr
filename: learngo.go
filename: learngo-fr.go
contributors:
- ["Sonia Keys", "https://github.com/soniakeys"]
- ["Christopher Bess", "https://github.com/cbess"]

268
fr-fr/make-fr.html.markdown Normal file
View File

@ -0,0 +1,268 @@
---
language: make
contributors:
- ["Robert Steed", "https://github.com/robochat"]
translators:
- ["altaris", "https://github.com/altaris"]
filename: Makefile-fr
lang: fr-fr
---
Un makefile est un fichier qui définit un ensemble de règles liées entre elles
pour créer une ou plusieurs cibles. L'idée est d'effectuer le moins de travail
possible afin de mettre à jour la ou les cibles en fonction des dépendances.
Écrit en un week-end par Stuart Feldman en 1976, le make et les
makefiles sont encore très utilisés (principalement dans les systèmes Unix),
malgré la concurrence et les critiques faites à son égard.
Le programme make a plusieurs variantes. Dans ce tutoriel, nous utiliserons
l'implémentation standard : GNU make.
```make
# Ceci est un commentaire.
# Un makefile devrait être nommé "Makefile" (avec ou sans la
# majuscule). Il peut alors être exécuté par `make <cible>`.
# Ce nommage n'est toutefois pas obligatoire : utiliser
# `make -f "fichier" <cible>`.
# ATTENTION : l'indentation est quant à elle obligatoire, et se fait avec des
# tabulations, pas avec des espaces !
#-----------------------------------------------------------------------
# Les basiques
#-----------------------------------------------------------------------
# Une règle. Elle ne sera exécutée que si fichier0.txt n'existe pas.
fichier0.txt:
echo "truc" > fichier0.txt
# Même les commentaires sont transférés dans le terminal.
# Cette règle ne sera exécutée que si fichier0.txt est plus récent que
# fichier1.txt.
fichier1.txt: fichier0.txt
cat fichier0.txt > fichier1.txt
# Utiliser la même syntaxe que dans un terminal.
@cat fichier0.txt >> fichier1.txt
# @ empêche l'affichage de la sortie texte d'une commande.
-@echo 'hello'
# - signifie que la règle devrait continuer à s'exécuter si cette commande
# échoue.
# Une règle peut avoir plusieurs cibles et plusieurs dépendances.
fichier2.txt fichier3.txt: fichier0.txt fichier1.txt
touch fichier2.txt
touch fichier3.txt
# Make affichera un avertissement si le makefile comporte plusieurs règles pour
# une même cible. Cependant les règles vides ne comptent pas, et peuvent être
# utilisées pour ajouter des dépendances plus facilement.
#-----------------------------------------------------------------------
# Fausses règles
#-----------------------------------------------------------------------
# Une fausse règle est une règle qui ne correspond pas à un fichier.
# Par définition, elle ne peut pas être à jour, et donc make l’exécutera à
# chaque demande.
all: maker process
# La déclaration des règles peut être faite dans n'importe quel ordre.
maker:
touch ex0.txt ex1.txt
# On peut transformer une règle en fausse règle grâce à la cible spéciale
# suivante :
.PHONY: all maker process
# Une règle dépendante d'une fausse règle sera toujours exécutée.
ex0.txt ex1.txt: maker
# Voici quelques exemples fréquents de fausses règles : all, make, clean,
# install...
#-----------------------------------------------------------------------
# Variables automatiques et wildcards
#-----------------------------------------------------------------------
# Utilise un wildcard pour des noms de fichier
process: fichier*.txt
@echo $^ # $^ est une variable contenant la liste des dépendances de la
# cible actuelle.
@echo $@ # $@ est le nom de la cible actuelle. En cas de cibles
# multiples, $@ est le nom de la cible ayant causé l'exécution
# de cette règle.
@echo $< # $< contient la première dépendance.
@echo $? # $? contient la liste des dépendances qui ne sont pas à jour.
@echo $+ # $+ contient la liste des dépendances avec d'éventuels
# duplicatas, contrairement à $^.
@echo $| # $| contient la liste des cibles ayant préséance sur la cible
# actuelle.
# Même si la définition de la règle est scindée en plusieurs morceaux, $^
# listera toutes les dépendances indiquées.
process: ex1.txt fichier0.txt
# Ici, fichier0.txt est un duplicata dans $+.
#-----------------------------------------------------------------------
# Pattern matching
#-----------------------------------------------------------------------
# En utilisant le pattern matching, on peut par exemple créer des règles pour
# convertir les fichiers d'un certain format dans un autre.
%.png: %.svg
inkscape --export-png $^
# Make exécute une règle même si le fichier correspondant est situé dans un sous
# dossier. En cas de conflit, la règle avec la meilleure correspondance est
# choisie.
small/%.png: %.svg
inkscape --export-png --export-dpi 30 $^
# Dans ce type de conflit (même cible, même dépendances), make exécutera la
# dernière règle déclarée...
%.png: %.svg
@echo cette règle est choisie
# Dans ce type de conflit (même cible mais pas les mêmes dépendances), make
# exécutera la première règle pouvant être exécutée.
%.png: %.ps
@echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
# Make a des règles pré établies. Par exemple, il sait comment créer la cible
# *.o à partir de *.c.
# Les makefiles plus vieux utilisent un matching par extension de fichier.
.png.ps:
@echo cette règle est similaire à une règle par pattern matching
# Utiliser cette règle spéciale pour déclarer une règle comme ayant un
# matching par extension de fichier.
.SUFFIXES: .png
#-----------------------------------------------------------------------
# Variables, ou macros
#-----------------------------------------------------------------------
# Les variables sont des chaînes de caractères.
variable = Ted
variable2="Sarah"
echo:
@echo $(variable)
@echo ${variable2}
@echo $variable # Cette syntaxe signifie $(n)ame et non pas $(variable) !
@echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
# Les variables sont déclarées de 4 manières, de la plus grande priorité à la
# plus faible :
# 1 : dans la ligne de commande qui invoque make,
# 2 : dans le makefile,
# 3 : dans les variables d’environnement du terminal qui invoque make,
# 4 : les variables prédéfinies.
# Assigne la variable si une variable d’environnement du même nom n'existe pas
# déjà.
variable4 ?= Jean
# Empêche cette variable d'être modifiée par la ligne de commande.
override variable5 = David
# Concatène à une variable (avec un espace avant).
variable4 +=gris
# Assignations de variable pour les règles correspondant à un pattern
# (spécifique à GNU make).
*.png: variable2 = Sara # Pour toutes les règles correspondant à *.png, et tous
# leurs descendants, la variable variable2 vaudra
# "Sara".
# Si le jeux des dépendances et descendances devient vraiment trop compliqué,
# des incohérences peuvent survenir.
# Certaines variables sont prédéfinies par make :
affiche_predefinies:
echo $(CC)
echo ${CXX}
echo $(FC)
echo ${CFLAGS}
echo $(CPPFLAGS)
echo ${CXXFLAGS}
echo $(LDFLAGS)
echo ${LDLIBS}
#-----------------------------------------------------------------------
# Variables : le retour
#-----------------------------------------------------------------------
# Les variables sont évaluées à chaque instance, ce qui peut être coûteux en
# calculs. Pour parer à ce problème, il existe dans GNU make une seconde
# manière d'assigner des variables pour qu'elles ne soient évaluées qu'une seule
# fois seulement.
var := A B C
var2 ::= $(var) D E F # := et ::= sont équivalents.
# Ces variables sont évaluées procéduralement (i.e. dans leur ordre
# d'apparition), contrairement aux règles par exemple !
# Ceci ne fonctionne pas.
var3 ::= $(var4) et fais de beaux rêves
var4 ::= bonne nuit
#-----------------------------------------------------------------------
# Fonctions
#-----------------------------------------------------------------------
# Make a une multitude de fonctions. La syntaxe générale est
# $(fonction arg0,arg1,arg2...).
# Quelques exemples :
fichiers_source = $(wildcard *.c */*.c)
fichiers_objet = $(patsubst %.c,%.o,$(fichiers_source))
ls: * src/*
@echo $(filter %.txt, $^)
@echo $(notdir $^)
@echo $(join $(dir $^),$(notdir $^))
#-----------------------------------------------------------------------
# Directives
#-----------------------------------------------------------------------
# Inclut d'autres makefiles.
include meuh.mk
# Branchements conditionnels.
sport = tennis
report:
ifeq ($(sport),tennis) # Il y a aussi ifneq.
@echo 'jeu, set et match'
else
@echo "C'est pas ici Wimbledon ?"
endif
truc = true
ifdef $(truc) # Il y a aussi ifndef.
machin = 'salut'
endif
```
## Quelques références
### En français
+ [Introduction à Makefile (developpez.com)]
(http://gl.developpez.com/tutoriel/outil/makefile/),
+ [Compilez sous GNU/Linux ! (openclassrooms)]
(https://openclassrooms.com/courses/compilez-sous-gnu-linux).
### En anglais
+ [Documentation de GNU make](https://www.gnu.org/software/make/manual/),
+ [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).

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

@ -62,8 +62,8 @@ __Celui-là aussi.__
**_Pareil ici_**
*__Et là!__*
<!-- Dans le "Github Flavored Markdown", utilisé pour interpréter le Markdown
sur Github, on a également le strikethrough ( texte barré ) : -->
<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown
sur GitHub, on a également le strikethrough ( texte barré ) : -->
~~Ce texte est barré avec strikethrough.~~
@ -172,7 +172,7 @@ fonctionne aussi à l'intérieur du bloc de code -->
La fonction `run()` ne vous oblige pas à aller courir!
<!-- Via Github Flavored Markdown, vous pouvez utiliser
<!-- Via GitHub Flavored Markdown, vous pouvez utiliser
des syntaxes spécifiques -->
\`\`\`ruby
@ -183,7 +183,7 @@ puts "Hello world!"
end
\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github
<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub
va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
<!-- Ligne Horizontale (<hr />) -->
@ -264,7 +264,7 @@ Pour taper *ce texte* entouré d'astérisques mais pas en italique :
Tapez \*ce texte\*.
<!-- Tableaux -->
<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown
<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
et c'est ce n'est pas super agréable d'utilisation.
Mais si vous en avez besoin :
-->

3
fr-fr/objective-c-fr.html.markdown
View File

@ -1,5 +1,4 @@
---
language: Objective-C
contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
@ -9,7 +8,6 @@ translators:
- ["Yannick Loriot", "https://github.com/YannickL"]
filename: LearnObjectiveC-fr.m
lang: fr-fr
---
L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
@ -519,6 +517,7 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es
// l'objet est supprimé
```
## Lectures Complémentaires
[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)

56
fr-fr/typescript-fr.html.markdown
View File

@ -87,22 +87,22 @@ mySearch = function(src: string, sub: string) {
// Les membres des classes sont publiques par défaut.
class Point {
// Propriétés
x: number;
// Propriétés
x: number;
// Constructeur - Les mots clés "public" et "private" dans ce contexte
// génèrent le code de la propriété et son initialisation dans le
// constructeur. Ici, "y" sera défini de la même façon que "x",
// mais avec moins de code. Les valeurs par défaut sont supportées.
constructor(x: number, public y: number = 0) {
this.x = x;
}
// Constructeur - Les mots clés "public" et "private" dans ce contexte
// génèrent le code de la propriété et son initialisation dans le
// constructeur. Ici, "y" sera défini de la même façon que "x",
// mais avec moins de code. Les valeurs par défaut sont supportées.
constructor(x: number, public y: number = 0) {
this.x = x;
}
// Fonctions
dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
// Fonctions
dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
// Membres statiques
static origin = new Point(0, 0);
// Membres statiques
static origin = new Point(0, 0);
}
var p1 = new Point(10 ,20);
@ -110,17 +110,17 @@ var p2 = new Point(25); // y sera 0
// Héritage
class Point3D extends Point {
constructor(x: number, y: number, public z: number = 0) {
// Un appel explicite au constructeur de la super classe
// est obligatoire.
super(x, y);
}
constructor(x: number, y: number, public z: number = 0) {
// Un appel explicite au constructeur de la super classe
// est obligatoire.
super(x, y);
}
// Redéfinition
dist() {
var d = super.dist();
return Math.sqrt(d * d + this.z * this.z);
}
// Redéfinition
dist() {
var d = super.dist();
return Math.sqrt(d * d + this.z * this.z);
}
}
// Modules, "." peut être utilisé comme un séparateur de sous modules.
@ -144,19 +144,19 @@ var s2 = new G.Square(10);
// Génériques
// Classes
class Tuple<T1, T2> {
constructor(public item1: T1, public item2: T2) {
}
constructor(public item1: T1, public item2: T2) {
}
}
// Interfaces
interface Pair<T> {
item1: T;
item2: T;
item1: T;
item2: T;
}
// Et fonctions
var pairToTuple = function<T>(p: Pair<T>) {
return new Tuple(p.item1, p.item2);
return new Tuple(p.item1, p.item2);
};
var tuple = pairToTuple({ item1:"hello", item2:"world"});

167
fr-fr/wolfram-fr.html.markdown Normal file
View File

@ -0,0 +1,167 @@
---
language: wolfram
contributors:
- ["hyphz", "http://github.com/hyphz/"]
translators:
- ["altaris", "http://github.com/altaris/"]
filename: learnwolfram-fr.nb
lang: fr-fr
---
Le langage Wolfram est utilisé dans les programmes suivants :
* La ligne de commandes interactive noyau du Raspberry Pi, mais elle ne peut pas
gérer des éléments graphiques.
* _Mathematica_, un éditeur de texte riche spécialisé pour les mathématiques :
appuyer sur `Shift + Entrée` dans une cellule de code crée un nouvelle cellule
contenant le résultat.
* _Wolfram Wokbench_, une variante d'Eclipse spécialisée pour le langage
Wolfram.
Ce code d'exemple peut être utilisé et modifié dans ces logiciels. Cependant, le
copier-coller directement dans Mathematica peut causer des problèmes de
formatage, car il ne contient aucune information de mise en page.
```
(* Ceci est un commentaire *)
(* Dans Mathematica, au lieu d'utiliser ces commentaires, vous pouvez créer des
cellules de texte et insérer de jolies images *)
(* Saisissez une opération et appuyez sur Shift + Entrée pour obtenir le
résultat *)
2*2 (* 4 *)
5+8 (* 13 *)
(* Appels de fonction *)
Sin[Pi/2] (* 1 *)
(* Syntaxe alternative pour les appels de fonction à 1 paramètre *)
Sin@(Pi/2) (* 1 *)
(Pi/2) // Sin (* 1 *)
(* Attention : le langage est sensible à la casse ! *)
(* Toutes les expressions sont en réalité des appels de fonction *)
Times[2, 2] (* 4 *)
Plus[5, 8] (* 13 *)
(* Utiliser une variable pour la première fois la déclare globalement *)
x = 5 (* 5 *)
x == 5 (* True, l'assignation et le test d'égalité est écrit comme
en C *)
x (* 5 *)
x = x + 5 (* 10 *)
x (* 10 *)
Set[x, 20] (* TOUT est un appel de fonction, TOUUUUUUUUT *)
x (* 20 *)
(* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des
variables non déclarées est légal *)
truc + 5 (* 5 + truc, comme truc n'est pas déclarée, l'évaluation
s'arrête là *)
truc + 5 + 10 (* 15 + truc, on évalue ce qu'on peut... *)
% (* 15 + truc, % représente le dernier résultat *)
% - truc (* 15, les variables non déclarées peuvent quand même
s'annuler *)
chose = truc + 5 (* Attention : chose est ici une expression et non un nombre *)
(* Déclaration d'une fonction *)
Double[x_] := x * 2 (* Le symbole := empêche l'évaluation immédiate du terme
à droite *)
Double[10] (* 20 *)
Double[Sin[Pi/2]] (* 2 *)
Double @ Sin @ (Pi/2) (* 2, Utiliser @ évite les paquets de crochets
fermants si moches *)
(Pi/2) // Sin // Double (* 2, Utiliser // permet d'écrire les fonctions dans
l'ordre d'appel *)
(* En programmation impérative, utiliser ; pour séparer les expressions *)
Salut[] := (Print@"Hello"; Print@"World") (* Les parenthèses sont nécessaires
car ; est prioritaire sur := *)
Salut[] (* Hello World *)
(* Boucles For à la C *)
Compter[x_] := For[y=0, y<x, y++, (Print[y])] (* L'évaluation des boucles For
se fait comme en C *)
Compter[5] (* 0 1 2 3 4 *)
(* Boucles While *)
x = 0; While[x < 2, (Print@x; x++)] (* De nouveau, comme en C *)
(* Expressions conditionnelles et If *)
x = 8; If[x==8, Print@"Huit", Print@"Pas huit"] (* If [condition, si vrai,
si faux] *)
Switch[x, 2, Print@"Deux", 8, Print@"Huit"] (* Switch par valeur *)
Which[x==2, Print@"Deux", x==8, Print@"Huit"] (* Switch du type if, else if,
else if, ..., else *)
(* Les variables autres que les paramètres de fonctions sont par défaut
globales, même à l'intérieur des fonctions *)
y = 10 (* 10, y est une variable globale *)
Compter[5] (* 0 1 2 3 4 *)
y (* 5, y a été modifiée par Compter *)
x = 20 (* 20, x est une variable globale *)
Compter[5] (* 0 1 2 3 4 *)
x (* 20, dans Compter, le paramètre x masque la variable
globale x *)
(* La fonction Module permet d'utiliser des variables locales *)
MieuxCompter[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
y = 20 (* y est une variable globale *)
MieuxCompter[5] (* 0 1 2 3 4 *)
y (* 20, y n'a pas été modifiée car le y du Module masque le
y global. C'est bien mieux comme ça ! *)
(* Module permet de faire des déclarations globales aussi *)
Module[{compte}, compte=0; (* compte est une variable locale *)
(Incrementer[] := ++compte); (* Ce module déclare des fonctions, mais elles
ne sont globales. Elles ont cependant accès
aux variables locales au module. *)
(Decrementer[] := --compte)]
compte (* compte, car il n'y a pas de variable globale nommée
compte *)
Incrementer[] (* 1, la fonction utilise la variable compte du module *)
Incrementer[] (* 2, le précédent appel de Incrementer a modifié compte *)
Decrementer[] (* 1 *)
compte (* compte, car il n'existe toujours pas de variable globale
nommé compte *)
(* Listes *)
liste = {1, 2, 3, 4} (* {1, 2, 3, 4} *)
liste[[1]] (* 1, les indexes commencent à 1 et non 0 !!! *)
Map[Double, liste] (* {2, 4, 6, 8}, appliquer une fonction à une liste de
manière fonctionnelle *)
Double /@ liste (* {2, 4, 6, 8}, syntaxe abrégée de la ligne
précédente *)
Scan[Print, liste] (* 1 2 3 4, boucle impérative sur une liste *)
Fold[Plus, 0, liste] (* 10 (0+1+2+3+4) *)
FoldList[Plus, 0, liste] (* {0, 1, 3, 6, 10}, variante de la fonction
précédente qui donne aussi les résultats
intermédiaires *)
Append[liste, 5] (* {1, 2, 3, 4, 5}, liste n'est pas modifiée... *)
Prepend[liste, 5] (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en
écrivant "liste = " *)
Join[liste, {3, 4}] (* {1, 2, 3, 4, 3, 4} *)
liste[[2]] = 5 (* {1, 5, 3, 4}, ceci modifie bien la liste *)
(* Tables associatives, ou dictionnaires *)
table = <|"Vert" -> 2, "Rouge" -> 1|> (* Crée une table associative *)
table[["Vert"]] (* 2, l'utilise *)
table[["Vert"]] := 5 (* 5, la modifie *)
table[["Bleu"]] := 3.5 (* 3.5, l'étend *)
KeyDropFrom[table, "Vert"] (* Supprime la clé "Vert" *)
Keys[table] (* {Rouge, Bleu} *)
Values[table] (* {1, 3.5} *)
(* Pour finir, toute bonne démonstration du langage Wolfram contient un
Manipulate ! *)
Manipulate[y^2, {y, 0, 20}] (* Crée une interface graphique interactive qui
affiche y^2, permettant à l'utilisateur de
modifier la valeur de y grâce à un contrôle
allant de 0 à 20. Ne fonctionne que si le
logiciel utilisé gère les éléments graphiques. *)
```
## Envie d'aller plus loin ?
* [Documentation du langage Wolfram (en anglais)]
(http://reference.wolfram.com/language/)

8
fsharp.html.markdown
View File

@ -346,7 +346,7 @@ module DataTypeExamples =
let trySendEmail email =
match email with // use pattern matching
| ValidEmailAddress address -> () // send
| InvalidEmailAddress address -> () // dont send
| InvalidEmailAddress address -> () // don't send
// The combination of union types and record types together
// provide a great foundation for domain driven design.
@ -426,7 +426,7 @@ module ActivePatternExamples =
// -----------------------------------
// You can create partial matching patterns as well
// Just use underscore in the defintion, and return Some if matched.
// Just use underscore in the definition, and return Some if matched.
let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
@ -627,7 +627,3 @@ module NetCompatibilityExamples =
For more demonstrations of F#, go to the [Try F#](http://www.tryfsharp.org/Learn) site, or my [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) series.
Read more about F# at [fsharp.org](http://fsharp.org/).

100
git.html.markdown
View File

@ -24,9 +24,12 @@ Version control is a system that records changes to a file(s), over time.
### Centralized Versioning VS Distributed Versioning
* Centralized version control focuses on synchronizing, tracking, and backing up files.
* Distributed version control focuses on sharing changes. Every change has a unique id.
* Distributed systems have no defined structure. You could easily have a SVN style, centralized system, with git.
* Centralized version control focuses on synchronizing, tracking, and backing
up files.
* Distributed version control focuses on sharing changes. Every change has a
unique id.
* Distributed systems have no defined structure. You could easily have a SVN
style, centralized system, with git.
[Additional Information](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
@ -35,13 +38,13 @@ Version control is a system that records changes to a file(s), over time.
* Can work offline.
* Collaborating with others is easy!
* Branching is easy!
* Branching is fast!
* Merging is easy!
* Git is fast.
* Git is flexible.
## Git Architecture
### Repository
A set of files, directories, historical records, commits, and heads. Imagine it
@ -52,7 +55,8 @@ A git repository is comprised of the .git directory & working tree.
### .git Directory (component of repository)
The .git directory contains all the configurations, logs, branches, HEAD, and more.
The .git directory contains all the configurations, logs, branches, HEAD, and
more.
[Detailed List.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
### Working Tree (component of repository)
@ -62,16 +66,16 @@ referred to as your working directory.
### Index (component of .git dir)
The Index is the staging area in git. It's basically a layer that separates your working tree
from the Git repository. This gives developers more power over what gets sent
to the Git repository.
The Index is the staging area in git. It's basically a layer that separates
your working tree from the Git repository. This gives developers more power
over what gets sent to the Git repository.
### Commit
A git commit is a snapshot of a set of changes, or manipulations to your Working
Tree. For example, if you added 5 files, and removed 2 others, these changes
will be contained in a commit (or snapshot). This commit can then be pushed to
other repositories, or not!
A git commit is a snapshot of a set of changes, or manipulations to your
Working Tree. For example, if you added 5 files, and removed 2 others, these
changes will be contained in a commit (or snapshot). This commit can then be
pushed to other repositories, or not!
### Branch
@ -85,11 +89,14 @@ functionality to mark release points (v1.0, and so on)
### HEAD and head (component of .git dir)
HEAD is a pointer that points to the current branch. A repository only has 1 *active* HEAD.
head is a pointer that points to any commit. A repository can have any number of heads.
HEAD is a pointer that points to the current branch. A repository only has 1
*active* HEAD.
head is a pointer that points to any commit. A repository can have any number
of heads.
### Stages of Git
* Modified - Changes have been made to a file but file has not been committed to Git Database yet
* Modified - Changes have been made to a file but file has not been committed
to Git Database yet
* Staged - Marks a modified file to go into your next commit snapshot
* Committed - Files have been committed to the Git Database
@ -98,14 +105,12 @@ head is a pointer that points to any commit. A repository can have any number of
* [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/)
* [Git For Designers](http://hoth.entp.com/output/git_for_designers.html)
## Commands
### init
Create an empty Git repository. The Git repository's settings, stored information,
and more is stored in a directory (a folder) named ".git".
Create an empty Git repository. The Git repository's settings, stored
information, and more is stored in a directory (a folder) named ".git".
```bash
$ git init
@ -116,7 +121,6 @@ $ git init
To configure settings. Whether it be for the repository, the system itself,
or global configurations ( global config file is `~/.gitconfig` ).
```bash
# Print & Set Some Basic Config Variables (Global)
$ git config --global user.email "MyEmail@Zoho.com"
@ -157,13 +161,11 @@ $ echo "temp/" >> .gitignore
$ echo "private_key" >> .gitignore
```
### status
To show differences between the index file (basically your working copy/repo)
and the current HEAD commit.
```bash
# Will display the branch, untracked files, changes and other differences
$ git status
@ -174,8 +176,8 @@ $ git help status
### add
To add files to the staging area/index. If you do not `git add` new files to the
staging area/index, they will not be included in commits!
To add files to the staging area/index. If you do not `git add` new files to
the staging area/index, they will not be included in commits!
```bash
# add a file in your current working directory
@ -193,7 +195,8 @@ working directory/repo.
### branch
Manage your branches. You can view, edit, create, delete branches using this command.
Manage your branches. You can view, edit, create, delete branches using this
command.
```bash
# list existing branches & remotes
@ -220,54 +223,64 @@ Manage your tags
```bash
# List tags
$ git tag
# Create a annotated tag
# The -m specifies a tagging message,which is stored with the tag.
# If you don’t specify a message for an annotated tag,
# Git launches your editor so you can type it in.
$ git tag -a v2.0 -m 'my version 2.0'
# Show info about tag
# That shows the tagger information, the date the commit was tagged,
# and the annotation message before showing the commit information.
$ git show v2.0
# Push a single tag to remote
$ git push origin v2.0
# Push a lot of tags to remote
$ git push origin --tags
```
### checkout
Updates all files in the working tree to match the version in the index, or specified tree.
Updates all files in the working tree to match the version in the index, or
specified tree.
```bash
# Checkout a repo - defaults to master branch
$ git checkout
# Checkout a specified branch
$ git checkout branchName
# Create a new branch & switch to it
# equivalent to "git branch <name>; git checkout <name>"
$ git checkout -b newBranch
```
### clone
Clones, or copies, an existing repository into a new directory. It also adds
remote-tracking branches for each branch in the cloned repo, which allows you to push
to a remote branch.
remote-tracking branches for each branch in the cloned repo, which allows you
to push to a remote branch.
```bash
# Clone learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
# shallow clone - faster cloning that pulls only latest snapshot
$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
# clone only a specific branch
$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
```
### commit
Stores the current contents of the index in a new "commit." This commit contains
the changes made and a message created by the user.
Stores the current contents of the index in a new "commit." This commit
contains the changes made and a message created by the user.
```bash
# commit with a message
@ -382,7 +395,8 @@ $ git pull origin master
$ git pull
# Merge in changes from remote branch and rebase
# branch commits onto your local repo, like: "git pull <remote> <branch>, git rebase <branch>"
# branch commits onto your local repo, like: "git pull <remote> <branch>, git
# rebase <branch>"
$ git pull origin master --rebase
```
@ -408,8 +422,8 @@ $ git push
### stash
Stashing takes the dirty state of your working directory and saves it on a stack
of unfinished changes that you can reapply at any time.
Stashing takes the dirty state of your working directory and saves it on a
stack of unfinished changes that you can reapply at any time.
Let's say you've been doing some work in your git repo, but you want to pull
from the remote. Since you have dirty (uncommited) changes to some files, you
@ -440,7 +454,8 @@ nothing to commit, working directory clean
```
You can see what "hunks" you've stashed so far using `git stash list`.
Since the "hunks" are stored in a Last-In-First-Out stack, our most recent change will be at top.
Since the "hunks" are stored in a Last-In-First-Out stack, our most recent
change will be at top.
```bash
$ git stash list
@ -470,7 +485,8 @@ Now you're ready to get back to work on your stuff!
### rebase (caution)
Take all changes that were committed on one branch, and replay them onto another branch.
Take all changes that were committed on one branch, and replay them onto
another branch.
*Do not rebase commits that you have pushed to a public repo*.
```bash
@ -484,8 +500,8 @@ $ git rebase master experimentBranch
### reset (caution)
Reset the current HEAD to the specified state. This allows you to undo merges,
pulls, commits, adds, and more. It's a great command but also dangerous if you don't
know what you are doing.
pulls, commits, adds, and more. It's a great command but also dangerous if you
don't know what you are doing.
```bash
# Reset the staging area, to match the latest commit (leaves dir unchanged)
@ -503,11 +519,12 @@ $ git reset 31f2bb1
# after the specified commit).
$ 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.
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
@ -540,7 +557,7 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [SalesForce Cheat Sheet](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
@ -549,4 +566,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [Pro Git](http://www.git-scm.com/book/en/v2)
* [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)

6
groovy.html.markdown
View File

@ -13,8 +13,8 @@ Groovy - A dynamic language for the Java platform [Read more here.](http://www.g
/*
Set yourself up:
1) Install GVM - http://gvmtool.net/
2) Install Groovy: gvm install groovy
1) Install SDKMAN - http://sdkman.io/
2) Install Groovy: sdk install groovy
3) Start the groovy console by typing: groovyConsole
*/
@ -280,7 +280,7 @@ def clos = { print it }
clos( "hi" )
/*
Groovy can memorize closure results [1][2][3]
Groovy can memoize closure results [1][2][3]
*/
def cl = {a, b ->
sleep(3000) // simulate some time consuming processing

41
haskell.html.markdown
View File

@ -189,16 +189,16 @@ foo = add 10 -- foo is now a function that takes a number and adds 10 to it
foo 5 -- 15
-- Another way to write the same thing
foo = (+10)
foo = (10+)
foo 5 -- 15
-- function composition
-- the (.) function chains functions together.
-- the operator `.` chains functions together.
-- For example, here foo is a function that takes a value. It adds 10 to it,
-- multiplies the result of that by 4, and then returns the final value.
foo = (*4) . (+10)
foo = (4*) . (10+)
-- (5 + 10) * 4 = 60
-- 4*(10 + 5) = 60
foo 5 -- 60
-- fixing precedence
@ -222,7 +222,7 @@ even . fib $ 7 -- false
-- 5. Type signatures
----------------------------------------------------
-- Haskell has a very strong type system, and everything has a type signature.
-- Haskell has a very strong type system, and every valid expression has a type.
-- Some basic types:
5 :: Integer
@ -259,7 +259,7 @@ case args of
_ -> putStrLn "bad args"
-- Haskell doesn't have loops; it uses recursion instead.
-- map applies a function over every element in an array
-- map applies a function over every element in a list
map (*2) [1..5] -- [2, 4, 6, 8, 10]
@ -279,7 +279,7 @@ foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
-- This is the same as
(2 * (2 * (2 * 4 + 1) + 2) + 3)
-- foldl is left-handed, foldr is right-
-- foldl is left-handed, foldr is right-handed
foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
-- This is now the same as
@ -318,7 +318,7 @@ Nothing -- of type `Maybe a` for any `a`
-- it is not hard to explain enough to get going.
-- When a Haskell program is executed, `main` is
-- called. It must return a value of type `IO ()`. For example:
-- called. It must return a value of type `IO a` for some type `a`. For example:
main :: IO ()
main = putStrLn $ "Hello, sky! " ++ (say Blue)
@ -361,7 +361,7 @@ sayHello = do
-- You can think of a value of type `IO a` as representing a
-- computer program that will generate a value of type `a`
-- when executed (in addition to anything else it does). We can
-- store and reuse this value using `<-`. We can also
-- name and reuse this value using `<-`. We can also
-- make our own action of type `IO String`:
action :: IO String
@ -401,11 +401,26 @@ main'' = do
let foo = 5
-- You can see the type of any value with `:t`:
-- You can see the type of any value or expression with `:t`:
>:t foo
> :t foo
foo :: Integer
-- Operators, such as `+`, `:` and `$`, are functions.
-- Their type can be inspected by putting the operator in parentheses:
> :t (:)
(:) :: a -> [a] -> [a]
-- You can get additional information on any `name` using `:i`:
> :i (+)
class Num a where
(+) :: a -> a -> a
...
-- Defined in ‘GHC.Num’
infixl 6 +
-- You can also run any action of type `IO ()`
> sayHello
@ -417,7 +432,7 @@ Hello, Friend!
There's a lot more to Haskell, including typeclasses and monads. These are the
big ideas that make Haskell such fun to code in. I'll leave you with one final
Haskell example: an implementation of quicksort in Haskell:
Haskell example: an implementation of a quicksort variant in Haskell:
```haskell
qsort [] = []
@ -426,7 +441,7 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
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
[Learn you a Haskell](http://learnyouahaskell.com/) or

4
hu-hu/ruby-hu.html.markdown
View File

@ -1,7 +1,7 @@
---
language: ruby
lang: hu-hu
filenev: learnruby.rb
filename: learnruby-hu.rb
contributors:
- ["David Underwood", "http://theflyingdeveloper.com"]
- ["Joel Walden", "http://joelwalden.net"]
@ -13,7 +13,7 @@ contributors:
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
- ["Levi Bostian", "https://github.com/levibostian"]
- ["Rahil Momin", "https://github.com/iamrahil"]
translators:
translators:
- ["Zsolt Prontvai", "https://github.com/prozsolt"]
---

147
hu-hu/yaml-hu.html.markdown Normal file
View File

@ -0,0 +1,147 @@
---
language: yaml
filename: learnyaml-hu.yaml
contributors:
- ["Adam Brenecki", "https://github.com/adambrenecki"]
translators:
- ["Tamás Diószegi", "https://github.com/ditam"]
lang: hu-hu
---
A YAML egy adat sorosító nyelv, amit úgy terveztek, hogy közvetlenül is
olvasható és írható legyen emberi szemmel.
A JSON formátum egy szigorú befoglaló halmazát alkotja, kiegészítve azt
szintaktikai jelentéssel bíró sortörésekkel és indentációval,
a Pythonhoz hasonlóan. A Pythonnal ellentétben azonban a YAML nem engedélyezi
a közvetlen tab karakterek jelenlétét.
Megjegyzés: UTF-8 ékezetes betűk használhatóak, ha a fájl kódlása megfelelő,
a kódolást a tartalomban explicit nem kell (és nem is lehet) feltüntetni.
```yaml
# A kommentek YAML-ban így néznek ki.
##################
# Skalár típusok #
##################
# A gyökér objektumunk (az egész dokumentumra értve) egy map,
# ami a más nyelvekből ismert dictionary, hash vagy object típusokkal egyenértékű.
kulcs: érték
masik_kulcs: Másik érték jön ide.
egy_szam: 100
tudomanyos_jelolessel: 1e+12
boolean: true
null_value: null
kulcs benne szóközökkel: érték
# Látható, hogy a sztringeket nem szükséges idézőjelek közé zárni, bár szabad.
Továbbá: "Idézőjelekkel megadott sztring."
"A kulcs is lehet idézőjeles.": "Hasznos lehet, ha ':'-ot akarsz a kulcsban."
# Többsoros sztringek írhatóak 'literal block'-ként ('|' jelet használva)
# vagy 'folded block'-ként is ('>' jelet használva).
literal_block: |
Ez az egész szöveg-blokk lesz az értéke a literal_block kulcsnak,
a sortöréseket megtartva.
Az ilyen sztringet az indentáció visszahúzása zárja le, a behúzás pedig
eltávolításra kerül.
A 'még jobban' behúzott részek megtartják a behúzásukat -
ezeknek a soroknak 4 szóköz behúzása lesz.
folded_style: >
Az az egész szöveg-blokk lesz az értéke a 'folded_style' kulcsnak, de
ezúttal minden sortörés egy szóközre lesz cserélve.
Az üres sorok, mint a fenti, új sor karakterre cserélődnek.
A 'még jobban' behúzott sorok megtartják a sortöréseiket, -
ez a szöveg két sorban jelenik meg.
######################
# Gyűjtemény típusok #
######################
# Egymásba ágyazás a behúzás változtatásával érhető el.
beagyazott_map:
key: value
another_key: Another Value
masik_beagyazott_map:
hello: hello
# A mapeknek nem csak sztring kulcsaik lehetnek.
0.25: lebegőpontos kulcs
# A kulcsok lehetnek többsoros objektumok is, ? jellel jelezve a kulcs kezdetét
? |
Ez itt egy
többsoros kulcs
: és ez az értéke
# Szintén engedélyezett a kollekció típusok használata kulcsként, de egyéb
# nyelvekben ez gyakran problémákat fog okozni.
# Szekvenciák (listákkal vagy tömbökkel egyenértékűek) így néznek ki:
egy_szekvencia:
- Item 1
- Item 2
- 0.5 # Többféle típust is tartalmazhat
- Item 4
- key: value
another_key: another_value
-
- Ez egy szekvencia
- egy másik szekvenciába ágyazva
# Mivel a YAML a JSON befoglaló halmazát alkotja, JSON szintaxisú
# mapek és szekvenciák is használhatóak:
json_map: {"key": "value"}
json_seq: [3, 2, 1, "takeoff"]
#########################
# EXTRA YAML KÉPESSÉGEK #
#########################
# A YAML-ben ún. 'anchor'-ök segítségével könnyen lehet duplikálni
# tartalmakat a dokumentumon belül. A következő kulcsok azonos értékkel bírnak:
anchored_tartalom: &anchor_neve Ez a sztring két kulcs értéke is lesz.
másik_anchor: *anchor_neve
# Vannak a YAML-ben tagek is, amivel explicit lehet típusokat jelölni.
explicit_string: !!str 0.5
# Bizonyos implementációk nyelv-specifikus tageket tartalmaznak, mint
# például ez a Python komplex szám típusának jelölésére:
python_complex_number: !!python/complex 1+2j
######################
# EXTRA YAML TÍPUSOK #
######################
# Nem a sztringek és a számok az egyedüli skalár típusok YAML-ben.
# ISO-formátumú dátumok és dátumot jelölő literal kifejezések is értelmezettek.
datetime: 2001-12-15T02:59:43.1Z
datetime_with_spaces: 2001-12-14 21:59:43.10 -5
date: 2002-12-14
# A !!binary tag jelöli, hogy egy sztring valójában base64-kódolású
# reprezentációja egy bináris blob-nak
gif_file: !!binary |
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
# Létezik a YAML-ban egy halmaz típus (set) is, ami így néz ki:
set:
? elem1
? elem2
? elem3
# Mint Pythonban, a halmazok null értékekkel feltöltött mapek, vagyis a fenti
# halmaz egyenértékű a következővel:
set2:
elem1: null
elem2: null
elem3: null
```

42
hy.html.markdown
View File

@ -3,13 +3,14 @@ language: hy
filename: learnhy.hy
contributors:
- ["Abhishek L", "http://twitter.com/abhishekl"]
- ["Zirak", "http://zirak.me"]
---
Hy is a lisp dialect built on top of python. This is achieved by
converting hy code to python's abstract syntax tree (ast). This allows
hy to call native python code or python to call native hy code as well
This tutorial works for hy ≥ 0.9.12
This tutorial works for hy ≥ 0.9.12, with some corrections for hy 0.11.
```clojure
;; this gives an gentle introduction to hy for a quick trial head to
@ -89,6 +90,17 @@ True ; => True
(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]
; you can use rest arguments and kwargs too:
(defn something-fancy [wow &rest descriptions &kwargs props]
(print "Look at" wow)
(print "It's" descriptions)
(print "And it also has:" props))
(something-fancy "My horse" "amazing" :mane "spectacular")
; you use apply instead of the splat operators:
(apply something-fancy ["My horse" "amazing"] { "mane" "spectacular" })
; anonymous functions are created using `fn' or `lambda' constructs
; which are similiar to `defn'
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
@ -102,6 +114,8 @@ True ; => True
; slice lists using slice
(slice mylist 1 3) ;=> [2 3]
; or, in hy 0.11, use cut instead:
(cut mylist 1 3) ;=> [2 3]
; get elements from a list or dict using `get'
(get mylist 1) ;=> 2
@ -122,6 +136,22 @@ True ; => True
; a.foo(arg) is called as (.foo a arg)
(.split (.strip "hello world ")) ;=> ["hello" "world"]
; there is a shortcut for executing multiple functions on a value called the
; "threading macro", denoted by an arrow:
(-> "hello world " (.strip) (.split)) ;=> ["hello" "world]
; the arrow passes the value along the calls as the first argument, for instance:
(-> 4 (* 3) (+ 2))
; is the same as:
(+ (* 4 3) 2)
; there is also a "threading tail macro", which instead passes the value as the
; second argument. compare:
(-> 4 (- 2) (+ 1)) ;=> 3
(+ (- 4 2) 1) ;=> 3
; to:
(->> 4 (- 2) (+ 1)) ;=> -1
(+ 1 (- 2 4)) ;=> -1
;; Conditionals
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
@ -160,6 +190,14 @@ True ; => True
[get-spell (fn [self]
self.spell)]])
; or, in hy 0.11:
(defclass Wizard [object]
(defn --init-- [self spell]
(setv self.spell spell))
(defn get-spell [self]
self.spell))
;; do checkout hylang.org
```
@ -169,6 +207,6 @@ This tutorial is just a very basic introduction to hy/lisp/python.
Hy docs are here: [http://hy.readthedocs.org](http://hy.readthedocs.org)
Hy's Github repo: [http://github.com/hylang/hy](http://github.com/hylang/hy)
Hy's GitHub repo: [http://github.com/hylang/hy](http://github.com/hylang/hy)
On freenode irc #hy, twitter hashtag #hylang

5
id-id/json-id.html.markdown
View File

@ -1,11 +1,12 @@
---
language: json
filename: learnjson.json
filename: learnjson-id.json
contributors:
- ["Anna Harren", "https://github.com/iirelu"]
- ["Marco Scannadinari", "https://github.com/marcoms"]
translators
translators:
- ["Rizky Luthfianto", "https://github.com/rilut"]
lang: id-id
---
JSON adalah format pertukaran data yang sangat simpel, kemungkinan besar,

848
id-id/php-id.html.markdown Normal file
View File

@ -0,0 +1,848 @@
---
language: PHP
contributors:
- ["Malcolm Fell", "http://emarref.net/"]
- ["Trismegiste", "https://github.com/Trismegiste"]
filename: learnphp-id.php
translators:
- ["Ahmad Zafrullah", "https://github.com/23Pstars"]
lang: id-id
---
Dokumen ini menjelaskan tentang PHP5 keatas.
```php
<?php // Skrip PHP harus diawali dengan tag <?php
// Jika dokumen PHP hanya mengandung kode PHP, sebaiknya tidak menggunakan
// tag penutup PHP untuk menghindari ketidaksengajaan tampilnya sesuatu.
// Dua garis miring diawal digunakan untuk komentar satu baris.
/*
Membatasi teks dalam garis miring-bintang dan bintang-garis miring
membuat komentar untuk banyak-baris sekaligus.
*/
// Gunakan "echo" or "print" untuk menampilkan sesuatu
print('Halo '); // Menampilkan "Halo " tanpa baris baru
// () boleh tidak digunakan dalam menggunakan "print" dan "echo"
echo "Dunia\n"; // Menampilkan "Dunia" dengan baris baru
// (semua perintah harus diakhiri dengan titik koma)
// Apapun yang berada diluar tag <?php akan ditampilkan secara otomatis
?>
Halo Dunia, lagi!
<?php
/************************************
* Tipe Data & Variabel
*/
// Variabel diawali dengan simnbol $.
// Nama variabel yang benar diawali dengan huruf atau garis-bawah,
// diikuti dengan beberapa huruf, angka, dan garis-bawah lainnya.
// Nilai Boolean adalah case-insensitive
$boolean = true; // atau TRUE atau True
$boolean = false; // atau FALSE atau False
// Nilai Integer
$int1 = 12; // => 12
$int2 = -12; // => -12
$int3 = 012; // => 10 (awalan 0 menandakan bilangan Oktal)
$int4 = 0x0F; // => 15 (awalan 0x menandakan bilangan Heksadesimal)
// Bilangan Biner Integer tersedia mulai dari PHP 5.4.0.
$int5 = 0b11111111; // 255 (awalan 0b menandakan bilangan Biner)
// Nilai Floats (dikenal juga sebagai Doubles)
$float = 1.234;
$float = 1.2e3;
$float = 7E-10;
// Menghapus variable
unset($int1);
// Aritmatika
$jumlah = 1 + 1; // 2
$selisih = 2 - 1; // 1
$perkalian = 2 * 2; // 4
$pembagian = 2 / 1; // 2
// Aritmatika singkat
$angka = 0;
$angka += 1; // Menjumlahkan $angka dengan 1
echo $angka++; // Menampilkan 1 (dijumlahkan dengan 1 setelah ditampilkan)
echo ++$angka; // Menampilkan 3 (dijumlahkan dengan 1 sebelum ditampilkan)
$angka /= $float; // Membagi dan menyimpan hasil pembagian pada $angka;
// String biasanya diawali dan ditutup dengan petik satu.
$sgl_quotes = '$String'; // => '$String'
// Hindari menggunakan petik dua kecuali menyertakan variabel lain
$dbl_quotes = "Ini adalah $sgl_quotes."; // => 'Ini adalah $String.'
// Karakter khusus hanya berlaku pada petik dua
$berfungsi = "Ini mengandung \t karakter tab.";
$tidak_berfungsi = 'Ini hanya mengandung garis miring dan huruf t: \t';
// Batasi variabel dengan kurung kurawal jika diperlukan
$uang = "Saya memiliki $${angka} di Bank.";
// Sejak PHP 5.3, nowdocs dapat digunakan untuk tak-terinterpolasi banyak-baris
$nowdoc = <<<'END'
Banyak baris
string
END;
// Heredocs akan melakukan interpolasi
$heredoc = <<<END
Banyak baris
$sgl_quotes
END;
// Menyambung string dapat dilakukan menggunakan .
echo 'String ini ' . 'tersambung';
// String dapat dijadikan parameter pada "echo"
echo 'Banyak', 'Parameter', 'String'; // Menampilkan 'BanyakParameterString'
/********************************
* Konstan
*/
// Sebuah konstan didifinisikan menggunakan fungsi define()
// dan tidak bisa diganti/rubah selama program berjalan!
// Nama konstan yang benar diawali dengan huruf dan garis-bawah,
// diikuti dengan beberapa huruf, angka, atau garis-bawah.
define("FOO", "sesuatu");
// Mengakses konstan memungkinkan untuk dapat dipanggil tanpa menggunakan simbol $
echo FOO; // Menampilkan 'sesuatu'
echo 'Keluaran ini adalah ' . FOO; // Menampilkan 'Keluaran ini adalah sesuatu'
/********************************
* Larik (Array)
*/
// Semua larik dalam PHP bersifat asosiatif (saling berhubungan).
// Berfungsi pada semua versi PHP
$asosiatif = array('Satu' => 1, 'Dua' => 2, 'Tiga' => 3);
// Pada PHP 5.4 diperkenalkan cara penulisan (sintaks) baru
$asosiatif = ['Satu' => 1, 'Dua' => 2, 'Tiga' => 3];
echo $asosiatif['Satu']; // menampilkan 1
// Daftar literal secara tidak langsung ditentukan oleh kunci integer
$larik = ['Satu', 'Dua', 'Tiga'];
echo $larik[0]; // => "Satu"
// Menambahkan sebuah elemen pada akhir larik
$larik[] = 'Empat';
// atau
array_push($larik, 'Lima');
// Menghapus elemen dari larik
unset($larik[3]);
/********************************
* Keluaran
*/
echo('Halo Dunia!');
// Menampilkan Halo Dunia! ke "stdout".
// "stdout" adalah sebuah halaman web ketika dijalankan dalam peramban (browser).
print('Halo Dunia!'); // Sama seperti "echo"
// "echo" dan "print" merupakan bahasa konstruksi, jadi tanda kurung dapat dihilangkan
echo 'Halo Dunia!';
print 'Halo Dunia!';
$paragraf = 'paragraf';
echo 100; // Menampilkan variabel skalar secara langsung
echo $paragraf; // atau sebuat variabel
// Jika PHP tag-singkat telah dikonfigurasi, atau versi PHP yang digunakan
// adalah 5.4.0 keatas, dapat digunakan sintaks "echo" singkat
?>
<p><?= $paragraf ?></p>
<?php
$x = 1;
$y = 2;
$x = $y; // $x sekarang berisi nilai yang sama dengan $y
$z = &$y;
// $z sekarang berisi referensi ke $y. Mengubah nilai dari $z
// akan mengubah nilai dari $y juga, begitupun sebaliknya.
// $x tetap tidak berubah sebagaimana nilai asli dari $y
echo $x; // => 2
echo $z; // => 2
$y = 0;
echo $x; // => 2
echo $z; // => 0
// Menampilkan tipe dan nilai dari variabel ke "stdout"
var_dump($z); // prints int(0)
// Menampilkan variabel ke "stdout" dalam format yang mudah dibaca
print_r($larik); // menampilkan: Array ( [0] => Satu [1] => Dua [2] => Tiga )
/********************************
* Logika
*/
$a = 0;
$b = '0';
$c = '1';
$d = '1';
// menegaskan lemparan sebuah peringatan jika pernyataan tidak benar
// Perbandingan berikut akan selalu benar, meskipun memiliki tipe yang berbeda.
assert($a == $b); // kesamaan
assert($c != $a); // ketidak-samaan
assert($c <> $a); // versi lain dari ketidak-samaan
assert($a < $c);
assert($c > $b);
assert($a <= $b);
assert($c >= $d);
// Dibawah ini hanya akan bernilai benar jika nilainya memiliki tipe yang sama.
assert($c === $d);
assert($a !== $d);
assert(1 === '1');
assert(1 !== '1');
// Operator 'Spaceship' (sejak PHP 7)
// Mengembalikan 0 jika nilai pada kedua sisi adalah sama
// Mengembalikan 1 jika nilai pada sisi kiri lebih besar
// Mengembalikan -1 jika nilai pada sisi kanan lebih besar
$a = 100;
$b = 1000;
echo $a <=> $a; // 0 karena keduanya sama
echo $a <=> $b; // -1 karena $a < $b
echo $b <=> $a; // 1 karena $b > $a
// Variabel dapat dikonversi menjadi tipe lain, sesuai penggunaannya.
$integer = 1;
echo $integer + $integer; // => 2
$string = '1';
echo $string + $string; // => 2 (string dipaksa menjadi integer)
$string = 'satu';
echo $string + $string; // => 0
// Menghasilkan 0 karena operator (+) tidak dapat memaksa string 'satu' menjadi sebuah integer
// Perubahan tipe dapat dimanfaatkan untuk diperlakukan sebagai tipe lainnya
$boolean = (boolean) 1; // => true
$nol = 0;
$boolean = (boolean) $nol; // => false
// Terdapat juga fungsi khusus untuk melakukan perubahan terhadap beberapa tipe
$integer = 5;
$string = strval($integer);
$var = null; // Nilai Null
/********************************
* Struktur Kontrol
*/
if (true) {
print 'Saya tampil';
}
if (false) {
print 'Saya tidak tampil';
} else {
print 'Saya tampil';
}
if (false) {
print 'Tidak tampil';
} elseif(true) {
print 'Tampil';
}
// operator ternary
print (false ? 'Tidak tampil' : 'Tampil');
// cara pintas operator ternary mulai dirilis sejak PHP 5.3
// persamaan dari "$x ? $x : 'Kerjakan'"
$x = false;
print($x ?: 'Kerjakan');
// operator null coalesce sejak PHP 7
$a = null;
$b = 'Ditampilkan';
echo $a ?? 'a belum di-set'; // menampilkan 'a belum di-set'
echo $b ?? 'b belum di-set'; // menampilkan 'Ditampilkan'
$x = 0;
if ($x === '0') {
print 'Tidak ditampilkan';
} elseif($x == '1') {
print 'Tidak ditampilkan';
} else {
print 'Tampil';
}
// Alternatif sintaks untuk kebutuhan templat:
?>
<?php if ($x): ?>
Ini ditampilkan jika pengujian benar.
<?php else: ?>
Selain tersebut ini yang akan ditampilkan.
<?php endif; ?>
<?php
// Gunakan "switch" untuk menghemat logika.
switch ($x) {
case '0':
print 'Switch mendukung tipe paksaan';
break; // Kata kunci "break" harus disertakan, jika tidak
// maka logika tersebut akan berlanjut ke bagian "dua" dan "tiga"
case 'dua':
case 'tiga':
// Lakukan sesuatu jika $x bernilai "dua" atau "tiga"
break;
default:
// Aksi cadangan
}
// "while", "do...while" dan perulangan "for"
$i = 0;
while ($i < 5) {
echo $i++;
}; // Menampilkan "01234"
echo "\n";
$i = 0;
do {
echo $i++;
} while ($i < 5); // Menampilkan "01234"
echo "\n";
for ($x = 0; $x < 10; $x++) {
echo $x;
} // Menampilkan "0123456789"
echo "\n";
$roda = ['sepeda' => 2, 'mobil' => 4];
// Perulangan "foreach" dapat melakukan iterasi pada larik (array)
foreach ($roda as $jumlah_roda) {
echo $jumlah_roda;
} // Menampilkan "24"
echo "\n";
// Iterasi dapat dilakukan terhadap "key" (kunci) dan "value" (nilai)
foreach ($roda as $mesin => $jumlah_roda) {
echo "$mesin memiliki $jumlah_roda buah roda";
}
echo "\n";
$i = 0;
while ($i < 5) {
if ($i === 3) {
break; // Menghentikan proses perulangan
}
echo $i++;
} // Menampilkan "012"
for ($i = 0; $i < 5; $i++) {
if ($i === 3) {
continue; // Melewati tahapan iterasi saat ini
}
echo $i;
} // Menampilkan "0124"
/********************************
* Fungsi
*/
// Fungsi didefinisikan dengan "function":
function fungsi_saya () {
return 'Halo';
}
echo fungsi_saya(); // => "Halo"
// Nama fungsi yang baik dan benar diawali dengan sebuah huruf atau garis-bawah, diikuti oleh
// beberapa huruf, angka, atau garis-bawah.
function jumlah ($x, $y = 1) { // $y merupakan opsional, jika tidak ditentukan akan bernilai 1
$hasil = $x + $y;
return $hasil;
}
echo jumlah(4); // => 5
echo jumlah(4, 2); // => 6
// $hasil tidak dapat diakses dari luar fungsi
// print $hasil; // Akan menghasilkan sebuah "warning".
// Sejak PHP 5.3 fungsi dapat dideklarasikan menjadi tanpa-nama (anonymous);
$inc = function ($x) {
return $x + 1;
};
echo $inc(2); // => 3
function foo ($x, $y, $z) {
echo "$x - $y - $z";
}
// Fungsi dapat mengembalikan fungsi juga
function bar ($x, $y) {
// Gunakan "use" untuk mengakses variabel diluar fungsi
return function ($z) use ($x, $y) {
foo($x, $y, $z);
};
}
$bar = bar('A', 'B');
$bar('C'); // Menampilkan "A - B - C"
// Fungsi uang memiliki nama dapat dipanggil berdasarkan string
$nama_fungsi = 'jumlah';
echo $nama_fungsi(1, 2); // => 3
// Bermanfaat untuk menentukan fungsi mana yang akan dipanggil secara dinamis.
// Atau, dapat juga menggunakan fungsi call_user_func(callable $callback [, $parameter [, ... ]]);
// Akses semua parameter yang dikirim ke sebuah fungsi
function parameter() {
$jumlah_param = func_num_args();
if( $jumlah_param > 0 ) {
echo func_get_arg(0) . ' | ';
}
$daftar_param = func_get_args();
foreach( $daftar_param as $kunci => $param ) {
echo $kunci . ' - ' . $param . ' | ';
}
}
parameter('Halo', 'Dunia'); // Halo | 0 - Halo | 1 - Dunia |
// Sejak PHP 5.6, mendapatkan jumlah variabel yang ada pada parameter
function variabel($kata, ...$daftar) {
echo $kata . " || ";
foreach ($daftar as $item) {
echo $item . ' | ';
}
}
variable("Pemisah", "Halo", "Dunia") // Pemisah || Halo | Dunia |
/********************************
* Penyertaan ("include")
*/
<?php
// Skrip PHP yang berada dalam dokumen "include" juga harus dibuka dengan tag PHP.
include 'dokumen-saya.php';
// Kode yang ada dalam dokumen-saya.php sekarang dapat diakses dari cakupan saat ini.
// Jika dokumen tidak dapat disertakan (include, seperti dokumen tidak ditemukan), maka pesan peringatan akan muncul.
include_once 'dokumen-saya.php';
// Jika dokumen-saya telah disertakan (include) oleh perintah sebelumnya, maka
// dokumen tersebut tidak akan disertakan lagi. Ini bertujuan untuk menghindari kesalahan
// yang diakibatkan oleh deklarasi ganda.
require 'dokumen-saya.php';
require_once 'dokumen-saya.php';
// Memiliki fungsi yang sama dengan "include", namun jika dokumen tidak ditemukan
// atau tidak dapat disertakan maka akan menghasilkan pesan kesalahan fatal.
// Isi dari dokumen-saya.php:
<?php
return 'Apapun yang kamu suka.';
// akhir dari dokumen
// "include" dan "require" dapat mengembalikan sebuah nilai.
$nilai = include 'dokumen-saya.php';
// Dokumen akan disertakan berdasarkan lokasi direktori dokumen (file path) yang diberikan, jika tidak didefinisikan
// maka akan digunakan konfigurasi dari "include_path". Jika dokumen tidak ditemukan dalam "include_path",
// fungsi include akan melakukan pengecekan pada direktori yang sama dengan dokumen yang menggunakan fungsi include tersebut,
// jika tidak ditemukan juga maka pesan gagal akan dimunculkan.
/* */
/********************************
* Kelas (class)
*/
// Kelas didefinisikan dengan kata "class"
class KelasSaya
{
const NILAI_KONSTAN = 'nilai'; // Sebuah konstan
static $nilaiStatis = 'statis';
// Variabel statis dan hak jenis aksesnya
public static $variabelStatisPublik = 'nilaiStatisPublik';
// Hanya dapat diakses dalam kelas
private static $variabelStatisPrivat = 'nilaiStatisPrivat';
// Dapat diakses dalam kelas dan kelas turunan
protected static $variabelStatisTerlindungi = 'nilaiStatisTerlindungi';
// Properti harus mendeklarasikan hak aksesnya
public $properti = 'publik';
public $PropertiInstansi;
protected $variabel = 'terlindungi'; // Dapat diakses dari kelas itu sendiri dan kelas turunannya
private $variabel = 'tersembunyi'; // Hanya dapat diakses dari kelas itu sendiri
// Membuat konstruktor dengan perintah __construct
public function __construct($PropertiInstansi) {
// Akses variabel instansi menggunakan perintah $this
$this->PropertiInstansi = $PropertiInstansi;
}
// Method dideklarasikan sebagai fungsi didalam kelas
public function methodSaya()
{
print 'KelasSaya';
}
// Perintah "final" membuat sebuah fungsi tidak dapat di-override oleh kelas turunannya
final function tidakDapatDiOverride()
{
}
/*
* Deklarasi properti atau method pada kelas sebagai statis membuat properti atau method tersebut
* dapat diakses tanpa melakukan instansiasi kelas. Properti statis tidak dapat diakses melalui
* objek kelas yang hasil instansiasi, sedangkan method statis bisa.
*/
public static function methodStatisSaya()
{
print 'Saya adalah statis';
}
}
// Konstan pada kelas dapat diakses secara statis
echo KelasSaya::NILAI_KONSTAN; // Menampilkan 'nilai'
echo KelasSaya::$nilaiStatis; // Menampilkan 'statis'
KelasSaya::methodStatisSaya(); // Menampilkan 'Saya adalah statis'
// Instansi kelas menggunakan perintah "new"
$kelas_saya = new KelasSaya('Sebuah properti instansiasi');
// Tanda kurung adalah opsional jika tidak ingin menggunakan argumen.
// Akses anggota kelas menggunakan ->
echo $kelas_saya->properti; // => "publik"
echo $kelas_saya->propertiInstansi; // => "Sebuah properti instansi"
$kelas_saya->methodSaya(); // => "KelasSaya"
// Menurunkan kelas menggunakan kata kunci "extends"
class KelasSayaLainnya extends KelasSaya
{
function tampilkanPropertiTerlindungi()
{
echo $this->properti;
}
// "override" terhadap sebuah method
function methodSaya()
{
parent::methodSaya();
print ' > KelasSayaLainnya';
}
}
$kelas_saya_lainnya = new KelasSayaLainnya('Instansiasi properti');
$kelas_saya_lainnya->tampilkanPropertiTerlindung(); // => Menampilkan "terlindungi"
$kelas_saya_lainnya->methodSaya(); // Menampilkan "KelasSaya > KelasSayaLainnya"
final class SayaTidakBisaDiturunkan
{
}
// Gunakan method ajaib (magic method) untuk membuat fungsi "getters" dan "setters"
class PetaKelasSaya
{
private $properti;
public function __get($key)
{
return $this->$key;
}
public function __set($key, $value)
{
$this->$key = $value;
}
}
$x = new PetaKelasSaya();
echo $x->properti; // akan memanggil method __get()
$x->properti = 'Sesuatu'; // akan memanggil method __set();
// Kelas dapat dijadikan abstrak (menggunakan kata kunci "abstract"), atau
// meng-implementasikan interfaces (menggunakan kata kunci "implements").
// Sebuah interface dideklarasikan dengan perintah "interface".
interface InterfaceSatu
{
public function kerjakanSesuatu();
}
interface InterfaceDua
{
public function kerjakanYangLain();
}
// interface dapat diturunkan
interface InterfaceTiga extends InterfaceDua
{
public function kerjakanYangBerbeda();
}
abstract class KelasAbstrakSaya implements InterfaceSatu
{
public $x = 'kerjakanSesuatu';
}
class KelasKongkritSaya extends KelasAbstrakSaya implements InterfaceTwo
{
public function kerjakanSesuatu()
{
echo $x;
}
public function kerjakanYangLain()
{
echo 'kerjakanYangLain';
}
}
// Kelas dapat diimplementasikan pada banyak interface
class KelasLainnya implements InterfaceSatu, InterfaceDua
{
public function kerjakanSesuatu()
{
echo 'kerjakanSesuatu';
}
public function kerjakanYangLain()
{
echo 'kerjakanYangLain';
}
}
/********************************
* Sifat (Traits)
*/
// Traits mulai tersedia sejak PHP 5.4.0 dan dideklarasikan menggunakan kata kunci "trait"
trait TraitSaya
{
public function methodTraitSaya()
{
print 'Saya menggunakan Trait';
}
}
class KelasTraitSaya
{
use TraitSaya;
}
$kls = new KelasTraitSaya();
$kls->methodTraitSaya(); // menampilkan "Saya menggunakan Trait"
/********************************
* Namespaces
*/
// Bagian ini telah dibatasi, karena deklarasi "namespace"
// karena harus ditempatkan diawal dokumen.
<?php
// Secara default, kelas tersedia sebagai namespace umum, dan dapat
// secara khusus dipanggil dengan garis-miring terbalik (backslash).
$kls = new \KelasSaya();
// Menentukan namespace untuk sebuah dokumen
namespace Saya\Namespace;
class KelasSaya
{
}
// (dari dokumen lainnya)
$kls = new Saya\Namespace\KelasSaya;
// Atau dari dalam namespace lainnya.
namespace Saya\Lainnya\Namespace;
use Saya\Namespace\KelasSaya;
$kls = new KelasSaya();
// Namespace dapat menggunakan alias
namespace Saya\Lainnya\Namespace;
use Saya\Namespace as SuatuKelasLainnya;
$kls = new SuatuKelasLainnya\KelasSaya();
/**********************
* Late Static Binding
*
*/
class KelasInduk {
public static function siapa() {
echo "Ini adalah " . __CLASS__ . "\n";
}
public static function coba() {
// kata kunci "self" merujuk pada method yang berada dalam satu kelas
self::who();
// kata kunci "static" merujuk pada method yang berada di kelas dimana method itu dijalankan
static::who();
}
}
KelasInduk::coba();
/*
Ini adalah KelasInduk
Ini adalah KelasInduk
*/
class KelasAnak extends KelasInduk {
public static function siapa() {
echo "Tapi ini adalah " . __CLASS__ . "\n";
}
}
KelasAnak::tes();
/*
Ini adalah KelasInduk
Tapi ini adalah KelasAnak
*/
/**********************
* Magic constants
*
*/
// Mendapatkan nama dari suatu kelas. Harus dideklarasikan didalam kelas tersebut.
echo "Nama kelas ini adalah " . __CLASS__;
// Mendapatkan alamat lengkap direktori
echo "Alamat direktori ini adalah " . __DIR__;
// Beberapa yang banyak digunakan
require __DIR__ . '/vendor/autoload.php';
// Mendapatkan alamat lengkap dokumen
echo "Alamat dokumen ini adalah " . __FILE__;
// Mendapatkan nama fungsi
echo "Nama fungsi ini adalah " . __FUNCTION__;
// Mendapatkan nomor baris perintah
echo "Nomor baris perintah ini adalah " . __LINE__;
// Mendapatkan nama method. Hanya mengembalikan sebuah nilai jika berada didalam trait atau deklarasi objek.
echo "Nama method ini adalah " . __METHOD__;
// Mendapatkan nama namespace
echo "Namespace saat ini adalah " . __NAMESPACE__;
// Mendapatkan nama dari trait. Hanya mengembalikan sebuah nilai jika berada didalam trait atau deklarasi objek.
echo "Namespace saat ini adalah " . __TRAIT__;
/**********************
* Penanganan Kesalahan (Error)
*
*/
// Penanganan error sederhana menggunakan "try...catch"
try {
// Kerjakan sesuatu
} catch (Exception $e) {
// Penanganan exception
}
// Menggunakan "try...catch" blok pada namespace
try {
// Kerjakan sesuatu
} catch (\Exception $e) {
// Penanganan exception
}
// Exception khusus
class ExceptionSaya extends Exception {}
try {
$kondisi = true;
if ($kondisi) {
throw new ExceptionSaya('Terjadi sesuatu');
}
} catch (ExceptionSaya $e) {
// Penanganan untuk exception khusus
}
```
## Informasi lainnya
Kunjungi [Dokumentasi resmi PHP](http://www.php.net/manual/) untuk referensi dan masukan komunitas.
Jika anda tertarik untuk belajar lebih dalam, kunjungi
[PHP The Right Way](http://www.phptherightway.com/).
Jika anda terbiasa dengan manajemen paket, kunjungi
[Composer](http://getcomposer.org/).
Untuk standar umum, kunjungi PHP Framework Interoperability Group's
[PSR standards](https://github.com/php-fig/fig-standards).

622
id-id/ruby-id.html.markdown Normal file
View File

@ -0,0 +1,622 @@
---
language: ruby
filename: learnruby-id.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"]
- ["Jake Faris", "https://github.com/farisj"]
translators:
- ["Ukaza Perdana", "https://github.com/ukazap"]
lang: id-id
---
```ruby
# Ini adalah sebuah komentar
=begin
Ini adalah komentar multibaris
Tak seorang pun menggunakannya
Kamu juga tidak perlu
=end
# Pertama-tama dan yang terpenting: Semuanya adalah objek.
# Angka adalah objek
3.class #=> Fixnum
3.to_s #=> "3"
# Beberapa aritmetika dasar
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
2**5 #=> 32
5 % 3 #=> 2
# Operator-operator bitwise
3 & 5 #=> 1
3 | 5 #=> 7
3 ^ 5 #=> 6
# Aritmetika tidak lain adalah pemanis sintaks (syntactic sugar)
# untuk memanggil sebuah metode pada suatu objek
1.+(3) #=> 4
10.* 5 #=> 50
# Nilai-nilai khusus adalah objek
nil # setara dengan "null" di bahasa-bahasa lain
true # kebenaran
false # ketidakbenaran
nil.class #=> NilClass
true.class #=> TrueClass
false.class #=> FalseClass
# Kesamaan
1 == 1 #=> true
2 == 1 #=> false
# Ketidaksamaan
1 != 1 #=> false
2 != 1 #=> true
# selain false itu sendiri, nil adalah nilai lain yang "salah"
!nil #=> true
!false #=> true
!0 #=> false
# Perbandingan lain
1 < 10 #=> true
1 > 10 #=> false
2 <= 2 #=> true
2 >= 2 #=> true
# Operator pembanding yang dikombinasikan ("spaceship operator")
1 <=> 10 #=> -1
10 <=> 1 #=> 1
1 <=> 1 #=> 0
# Operator-operator logika
true && false #=> false
true || false #=> true
!true #=> false
# Terdapat versi-versi operator logika yang berbeda dengan lebih sedikit awalan.
# Mereka digunakan sebagai kendali alur untuk merangkai beberapa pernyataan
# hingga salah satunya mengembalikan (return) nilai true atau false.
# `lakukan_suatu_lainnya` hanya dipanggil jika `lakukan_sesuatu` berhasil.
lakukan_sesuatu() and lakukan_suatu_lainnya()
# `catat_error` hanya dipanggil jika `lakukan_sesuatu` gagal.
lakukan_sesuatu() or catat_error()
# String adalah objek
'Aku adalah string'.class #=> String
"Aku juga adalah string".class #=> String
wadah = 'menggunakan string interpolation'
"Aku bisa #{wadah} ketika memakai tanda kutip ganda"
#=> "Aku bisa menggunakan string interpolation ketika memakai tanda kutip ganda"
# Gunakan tanda kutip tunggal daripada tanda kutip ganda jika memungkinkan
# String bertanda kutip ganda melakukan kalkulasi tambahan di dalam
# Kombinasikan string, tapi tidak dengan angka
'halo ' + 'dunia' #=> "halo dunia"
'halo ' + 3 #=> TypeError: can't convert Fixnum into String
'halo ' + 3.to_s #=> "halo 3"
# Kombinasikan string dengan operator
'halo ' * 3 #=> "halo halo halo "
# Membubuhkan ke string
'halo' << ' dunia' #=> "halo dunia"
# cetak ke output dan buat baris baru (newline) di akhir
puts "Aku mencetak!"
#=> Aku mencetak!
#=> nil
# cetak ke output tanpa baris baru
print "Aku mencetak!"
#=> Aku mencetak! => nil
# Variabel
x = 25 #=> 25
x #=> 25
# Catat bahwa pemberian nilai mengembalikan nilai yang diberikan
# Artinya kamu bisa melakukan pemberian nilai secara jamak:
x = y = 10 #=> 10
x #=> 10
y #=> 10
# Berdasarkan adat, gunakan gaya snake_case untuk menulis nama variabel
snake_case = true
# Gunakan nama variabel yang deskriptif
path_to_project_root = '/good/name/'
path = '/bad/name/'
# Simbol (adalah objek)
# Simbol adalah konstanta yang dapat didaur ulang yang tidak dapat diubah
# (immutable), secara internal diwakili oleh nilai integer. Seringkali
# digunakan sebagai pengganti string untuk menyampaikan nilai yang mengandung
# makna spesifik secara efisien.
:menunggu.class #=> Symbol
status = :menunggu
status == :menunggu #=> true
status == 'menunggu' #=> false
status == :diterima #=> false
# Array
# Ini adalah sebuah array
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
# Array bisa menampung item dengan beragam tipe
[1, 'halo', false] #=> [1, "halo", false]
# Array bisa di-indeks-kan
# Dari depan
array[0] #=> 1
array.first #=> 1
array[12] #=> nil
# Sama dengan aritmetika, pengaksesan [var]
# hanyalah pemanis sintaks
# untuk memanggil metode [] pada suatu objek
array.[] 0 #=> 1
array.[] 12 #=> nil
# Dari belakang
array[-1] #=> 5
array.last #=> 5
# Dengan indeks awal dan panjang (jumlah item)
array[2, 3] #=> [3, 4, 5]
# Membalik sebuah Array
a=[1,2,3]
a.reverse! #=> [3,2,1]
# Atau menggunakan jangkauan (range)
array[1..3] #=> [2, 3, 4]
# Tambahkan ke array seperti ini
array << 6 #=> [1, 2, 3, 4, 5, 6]
# Atau seperti ini
array.push(6) #=> [1, 2, 3, 4, 5, 6]
# Periksa apakah suatu item ada dalam sebuah array
array.include?(1) #=> true
# Hash adalah kamus utama Ruby berupa pasangan kunci/nilai (key/value pair).
# Hash ditandai dengan kurung kurawal:
hash = { 'warna' => 'hijau', 'angka' => 5 }
hash.keys #=> ['warna', 'angka']
# Nilai dalam Hash bisa diperoleh menggunakan kunci:
hash['warna'] #=> 'hijau'
hash['angka'] #=> 5
# Meminta hash untuk kunci yang tidak ada akan mengembalikan nil:
hash['tidak ada di sini'] #=> nil
# Sejak Ruby 1.9, ada sintaks khusus ketika menggunakan simbol sebagai kunci:
hash_baru = { defcon: 3, action: true }
hash_baru.keys #=> [:defcon, :action]
# Periksa ada/atau tidaknya kunci dan nilai dalam hash
hash_baru.key?(:defcon) #=> true
hash_baru.value?(3) #=> true
# Tip: Baik array maupun hash adalah Enumerable
# Mereka berbagi banyak metode yang berguna diantaranya each, map, count, dll.
# Struktur-struktur kendali
if true
'pernyataan if'
elsif false
'else if, opsional'
else
'else, opsional juga'
end
for penghitung in 1..5
puts "iterasi #{penghitung}"
end
#=> iterasi 1
#=> iterasi 2
#=> iterasi 3
#=> iterasi 4
#=> iterasi 5
# NAMUN, tidak ada orang yang menggunakan pengulangan for.
# Sebagai ganti, gunakan metode "each" dan memberinya sebuah blok (block).
# Blok adalah serangkaian kode yang bisa dimasukkan ke metode seperti "each".
# Ia serupa dengan lambda, fungsi anonim atau closure di bahasa lainnya.
#
# Metode "each" dari range menjalankan blok untuk setiap elemen dari range.
# Bloknya diberikan penghitung sebagai parameter.
# Memanggil metode "each" dengan blok terlihat seperti ini:
(1..5).each do |penghitung|
puts "iterasi #{penghitung}"
end
#=> iterasi 1
#=> iterasi 2
#=> iterasi 3
#=> iterasi 4
#=> iterasi 5
# Kamu juga bisa mengurung blok dalam kurung kurawal:
(1..5).each { |penghitung| puts "iterasi #{penghitung}" }
# Isi dari struktur-struktur data juga bisa di-iterasi menggunakan each.
array.each do |elemen|
puts "#{elemen} adalah bagian dari array"
end
hash.each do |kunci, nilai|
puts "#{kunci} adalah #{nilai}"
end
# Jika kamu masih membutuhkan indeks, bisa menggunakan "each_with_index"
# dan definisikan variabel indeks
array.each_with_index do |elemen, indeks|
puts "#{elemen} adalah nomor #{indeks} dalam array"
end
penghitung = 1
while penghitung <= 5 do
puts "iterasi #{penghitung}"
penghitung += 1
end
#=> iterasi 1
#=> iterasi 2
#=> iterasi 3
#=> iterasi 4
#=> iterasi 5
# Ada kumpulan fungsi pengulangan lainnya yang berguna di Ruby,
# contohnya "map", "reduce", "inject", daftarnya sangat panjang. Map,
# misalnya, mengambil array yang di-iterasi-nya, melakukan sesuatu pada
# setiap elemen sesuai definisi pada blok, dan mengembalikan array baru.
array = [1,2,3,4,5]
berganda = array.map do |elemen|
elemen * 2
end
puts berganda
#=> [2,4,6,8,10]
puts array
#=> [1,2,3,4,5]
nilai = 'B'
case nilai
when 'A'
puts 'Pertahankan, nak'
when 'B'
puts 'Semoga lebih beruntung di lain waktu'
when 'C'
puts 'Kamu bisa lebih baik'
when 'D'
puts 'Susah payah'
when 'F'
puts 'Kamu gagal!'
else
puts 'Sistem penilaian lainnya, heh?'
end
#=> "Semoga lebih beruntung di lain waktu"
# case juga bisa menggunakan range
nilai = 82
case nilai
when 90..100
puts 'Hore!'
when 80...90
puts 'Cukup bagus'
else
puts 'Kamu gagal!'
end
#=> "Cukup bagus"
# penanganan kesalahan (exception handling):
begin
# kode di sini yang mungkin membangkitkan exception
raise NoMemoryError, 'Kamu kehabisan memori.'
rescue NoMemoryError => variabel_exception
puts 'NoMemoryError dibangkitkan', variabel_exception
rescue RuntimeError => variabel_exception_lainnya
puts 'RuntimeError dibangkitkan sekarang'
else
puts 'Ini dijalankan bila tidak ada exceptions sama sekali'
ensure
puts 'Kode ini akan berjalan bagaimanapun juga'
end
# Fungsi (atau metode)
def gandakan(x)
x * 2
end
# Fungsi dan semua blok secara tersirat mengembalikan nilai pernyataan terakhir
gandakan(2) #=> 4
# Tanda kurung bersifat optional, boleh ditiadakan jika tidak ambigu
gandakan 3 #=> 6
gandakan gandakan 3 #=> 12
def jumlah(x, y)
x + y
end
# Argumen-argumen dari metode dipisahkan dengan koma
sum 3, 4 #=> 7
sum sum(3, 4), 5 #=> 12
# yield
# Semua metode secara tersirat mempunyai parameter blok opsional
# yang bisa dipanggil dengan kata kunci 'yield'
def kurung
puts '{'
yield
puts '}'
end
kurung { puts 'halo dunia' }
# {
# halo dunia
# }
# Kamu bisa memasukkan blok ke sebuah fungsi
# "&" adalah penanda blok yang masuk
def tamu_tamu(&blok)
blok.call 'beberapa_argumen'
end
# Kamu bisa memasukkan daftar argumen yang akan dikonversi menjadi array
# Itulah gunanya operator splat ("*")
def tamu_tamu(*array)
array.each { |tamu| puts tamu }
end
# Bila metode mengembalikan array, bisa memberi nilai dengan destrukturisasi
# (destructuring assignment):
def makanan
['tempe penyet', 'sayur asam', 'nasi goreng']
end
sarapan, makan_siang, makan_malam = makanan
sarapan #=> 'tempe penyet'
makan_malam #=> 'nasi goreng'
# Menurut adat, nama metode yang mengembalikan boolean diakhiri tanda tanya
5.even? # false
5.odd? # true
# Dan jika suatu metode berakhiran tanda seru, ia melakukan sesuatu yang merusak
# seperti mengubah penerimanya. Banyak metode mempunyai versi ! untuk melakukan
# perubahan dan versi non-! untuk sekedar mengembalikan perubahannya
nama_perusahaan = "Putra Sejahtera"
nama_perusahaan.upcase #=> "PUTRA SEJAHTERA"
nama_perusahaan #=> "Putra Sejahtera"
nama_perusahaan.upcase! # kali ini kita benar-benar mengubah nama_perusahaan!
nama_perusahaan #=> "PUTRA SEJAHTERA"
# Definisikan kelas menggunakan kata kunci class
class Manusia
# Variabel kelas. Ini dibagi oleh semua instans (instance) dari kelas ini.
@@spesies = 'H. sapiens'
# Inisialisasi dasar
def initialize(nama, usia = 0)
# Berikan argumen ke variabel instans "nama" dalam instans ini
@nama = nama
# Jika tidak diberi usia, nilai default dalam daftar argumen digunakan.
@usia = usia
end
# Metode setter dasar
def nama=(nama)
@nama = nama
end
# Metode getter dasar
def nama
@nama
end
# Fungsi di atas bisa disingkat dengan metode attr_accessor sebagai berikut
attr_accessor :nama
# Metode getter/setter juga bisa dibuat secara terpisah seperti ini
attr_reader :nama
attr_writer :nama
# Metode kelas menggunakan self untuk membedakannya dari metode instans.
# Ia hanya bisa dipanggil pada kelas, bukan pada instans-nya.
def self.katakan(pesan)
puts pesan
end
def spesies
@@spesies
end
end
# Membuat instans kelas
jim = Manusia.new('Jim Halpert')
dwight = Manusia.new('Dwight K. Schrute')
# Mari panggil beberapa metode
jim.spesies #=> "H. sapiens"
jim.nama #=> "Jim Halpert"
jim.nama = "Jim Halpert II" #=> "Jim Halpert II"
jim.nama #=> "Jim Halpert II"
dwight.spesies #=> "H. sapiens"
dwight.nama #=> "Dwight K. Schrute"
# Panggil metode kelas
Manusia.katakan('Hai') #=> "Hai"
# Lingkup variabel didefinisikan berdasarkan bagaimana kita memberikannya nama
# Variabel yang berawalan $ memiliki lingkup global
$var = "Aku adalah variabel global"
defined? $var #=> "global-variable"
# Variabel yang berawalan @ memiliki lingkup instans
@var = "Aku adalah variabel instans"
defined? @var #=> "instance-variable"
# Variabel yang berawalan @@ memiliki lingkup kelas
@@var = "Aku adalah variabel kelas"
defined? @@var #=> "class variable"
# Variabel yang berawalan huruf kapital adalah konstanta
Var = "Aku adalah konstanta"
defined? Var #=> "constant"
# Kelas juga adalah objek sehingga kelas bisa memiliki variabel instans.
# Variabel kelas dibagi diantara kelas dan semua pewarisnya.
# kelas dasar
class Manusia
@@foo = 0
def self.foo
@@foo
end
def self.foo=(nilai)
@@foo = nilai
end
end
# kelas turunan
class Buruh < Manusia
end
Manusia.foo # 0
Buruh.foo # 0
Manusia.foo = 2 # 2
Buruh.foo # 2
# Variabel instans milik kelas tidak dibagikan dengan pewaris kelas tersebut.
class Manusia
@bar = 0
def self.bar
@bar
end
def self.bar=(nilai)
@bar = nilai
end
end
class Dokter < Manusia
end
Manusia.bar # 0
Dokter.bar # nil
module ContohModul
def foo
'foo'
end
end
# Include modul mengikat metode-metodenya pada instans-instans kelas
# Extend modul mengikat metode-metodenya pada kelas
class Orang
include ContohModul
end
class Buku
extend ContohModul
end
Orang.foo # => NoMethodError: undefined method `foo' for Orang:Class
Orang.new.foo # => 'foo'
Buku.foo # => 'foo'
Buku.new.foo # => NoMethodError: undefined method `foo'
# Callbacks dijalankan ketika meng-include dan meng-extend sebuah modul
module ContohUrusan
def self.included(base)
base.extend(MetodeKelas)
base.send(:include, MetodeInstans)
end
module MetodeKelas
def bar
'bar'
end
end
module MetodeInstans
def qux
'qux'
end
end
end
class Sesuatu
include ContohUrusan
end
Sesuatu.bar # => 'bar'
Sesuatu.qux # => NoMethodError: undefined method `qux'
Sesuatu.new.bar # => NoMethodError: undefined method `bar'
Sesuatu.new.qux # => 'qux'
```
## Sumber tambahan
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Varian dari referensi ini dengan tantangan dalam browser.
- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Belajar Ruby melalui serangkaian tutorial interaktif.
- [Dokumentasi resmi](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/) - Edisi lama yang [gratis](http://ruby-doc.com/docs/ProgrammingRuby/) tersedia online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Panduan penulisan kode Ruby oleh komunitas.
- [Try Ruby](http://tryruby.org) - Pelajari dasar bahasa pemrograman Ruby, secara interaktif di browser.

79
id-id/xml-id.html.markdown
View File

@ -5,19 +5,76 @@ contributors:
- ["João Farias", "https://github.com/JoaoGFarias"]
translators:
- ["Rizky Luthfianto", "https://github.com/rilut"]
- ["Ahmad Zafrullah", "https://github.com/23Pstars"]
lang: id-id
---
XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data.
XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data. XML mudah dibaca oleh manusia dan mesin.
Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data, hanya membawanya.
* Sintaks XML
Terdapat perbedaan antara **konten** dan **markup**. Singkatnya, konten dapat berupa apapun dan markup adalah sebagai penentu.
## Definisi dan Pendahuluan
Dokumen XML pada dasarnya disusun oleh *elemen* yang dapat memiliki *atribut* untuk menjelaskan elemen tersebut dan dapat memiliki beberapa konten tekstual atau beberapa elemen sebagai anak-nya. Setiap dokumen XML hendaknya memiliki satu elemen akar, yang menjadi induk dari semua elemen dalam dokumen XML.
Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan penguraian terhadap dokumen yang cacat. Oleh karena itu semua dokumen XML harus mengikuti [Aturan Sintaks XML](http://www.w3schools.com/xml/xml_syntax.asp).
```xml
<!-- Komentar di XML seperti ini -->
<!-- Ini adalah komentar. Komentar harus memiliki dua tanda penghubung secara berurutan (-). -->
<!-- Komentar dapat renggang
menjadi banyak baris -->
<!-- Elemen -->
<!-- Elemen merupakan komponen dasar dari XML. Ada dua tipe dari elemen, kosong: -->
<elemen1 atribut="nilai" /> <!-- Elemen kosong tidak memiliki konten apapun -->
<!-- dan tidak-kosong: -->
<elemen2 atribut="nilai">Konten</elemen2>
<!-- Nama elemen hanya dapat berupa huruf dan angka saja. -->
<kosong /> <!-- Elemen yang terdiri dari tag elemen kosong… -->
<!-- …tidak memiliki content apapun dan murni markup. -->
<tidakkosong> <!-- Atau, elemen ini memiliki tag pembuka… -->
<!-- …suatu konten… -->
</tidakkosong> <!-- dan sebuah tag penutup. -->
<!-- Nama elemen merupakan *case sensitive*. -->
<elemen />
<!-- …tidak sama dengan elemen sebelumnya -->
<eLEMEN />
<!-- Atribut -->
<!-- Sebuah atribut merupakan hubungan kunci-nilai yang terdapat pada elemen. -->
<elemen atribut="nilai" lainnya="nilaiLainnya" banyakNilai="daftar nilai ber-spasi" />
<!-- Sebuah atribut digunakan hanya sekali dalam sebuah elemen. Dan hanya memiliki satu nilai.
Salah satu solusi untuk mengatasi permasalahan tersebut adalah dengan menggunakan daftar nilai ber-spasi. -->
<!-- Elemen bersarang -->
<!-- Konten dari sebuah elemen dapat berupa elemen lainnya:: -->
<ayah>
<anak>Teks</anak>
<oranglain />
</ayah>
<!-- Mengikuti standar tatanan pohon. Setiap elemen disebut *node*.
Induk yang berada satu tingkat diatasnya disebut *parent*, keturunan yang berada satu tingkat dibawahnya disebut *children*.
Elemen yang berada pada *parent* yang sama disebut Saudara (*siblings*). -->
<!-- XML mempertahankan spasi. -->
<anak>
Teks
</anak>
<!-- …tidak sama dengan -->
<anak>Teks</anak>
```
## Dokumen XML
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML prolog, boleh tidak digunakan namun direkomendasikan untuk digunakan. -->
<tokobuku>
<buku category="MEMASAK">
<judul lang="en">Everyday Italian</judul>
@ -65,7 +122,7 @@ Tidak seperti HTML, XML tidak menentukan bagaimana menampilkan atau format data,
```
* Dokumen yang well-formated & Validasi
## Dokumen yang well-formated & Validasi
Sebuah dokumen XML disebut well-formated jika sintaksisnya benar.
Namun, juga mungkin untuk mendefinisikan lebih banyak batasan dalam dokumen,
@ -128,3 +185,17 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
</buku>
</tokobuku>
```
## Kompatibilitas DTD dan Definisi Skema XML
Dukungan untuk DTD dapat ditemukan dimana-mana karena sudah sangat lama. Namun sayangnya, fitur XML terkini seperti *namespaces* tidak didukung oleh DTD. XML Xchema Definitions (XSDs) bertujuan untuk mengganti DTD dalam mendefinisikan tatabahasa dokumen XML.
## Sumber
* [Validasi dokumen XML](http://www.xmlvalidation.com)
## Bacaan lainnya
* [XML Schema Definitions Tutorial](http://www.w3schools.com/schema/)
* [DTD Tutorial](http://www.w3schools.com/xml/xml_dtd_intro.asp)
* [XML Tutorial](http://www.w3schools.com/xml/default.asp)
* [Using XPath queries to parse XML](http://www.w3schools.com/xml/xml_xpath.asp)

195
inform7.html.markdown Normal file
View File

@ -0,0 +1,195 @@
---
language: Inform7
contributors:
- ["Hyphz", "http://github.com/hyphz/"]
filename: LearnInform.Inform
---
Inform 7 is a natural language based language created by Graham Nelson and Emily Short for writing text adventures, but also potentially usable for other text based applications, especially data backed ones.
```
"LearnInform" by Hyphz
[This is a comment.]
[Inform 7 is a language designed for building text adventures.
It can be used for other purposes too, although the default
library builds a text adventure. Inform 7 is object oriented.]
[This creates a class by subclassing. "Value" is the universal subclass,
but "object" is the most basic that behaves like an OO object.]
A datablock is a kind of object.
[Classes can have properties.]
A datablock can be broken. [This creates a boolean property.]
A datablock is usually not broken. [This sets its default value.]
A datablock can be big or small. [This creates an enumerated property.]
A datablock is usually small. [This sets its default value.]
A datablock has a number called the sequence number. [This creates a typed property.]
A datablock has some text called the name. ["Some text" means a string.]
A datablock has a datablock called the chain. [Declared classes become types.]
[This creates a global named instance.]
Block1 is a datablock.
The sequence number of Block1 is 1.
The name of Block1 is "Block One."
[Functions and procedures are defined as "phrases".]
To do the thing everyone does with their first program:
say "Hello World.". [Full stop indicates the end, indent indicates the scope.]
To dump (the block - a datablock): [That's how we create a parameter.]
say the sequence number of the block;
say the name of the block;
if the block is broken, say "(Broken)".
To toggle (the block - a datablock):
if the block is broken: [Conditional.]
now the block is not broken; [Updating a property.]
else:
now the block is broken.
[Multiple parameters.]
To fix (the broken block - a datablock) using (the repair block - a datablock):
if the broken block is not broken, stop; [Comma for a non indented single command.]
if the repair block is broken, stop;
now the sequence number of the broken block is the sequence number of the repair block;
now the broken block is not broken.
[Because of its text adventure origins, Inform 7 doesn't generally allow objects
to be created dynamically, although there's a language extension that enables it.]
Block2 is a datablock.
Block2 is broken.
The sequence number of Block2 is 2.
The name of Block2 is "Block two."
To demonstrate calling a phrase with two parameters:
Let the second block be block2; [Local pointer variable.]
fix the second block using Block1;
say the sequence number of the second block. [1.]
[Lists.]
To show how to use list types:
let the list be a list of datablocks;
add Block1 to the list;
add Block2 to the list;
say the list; ["Block1 and Block2"]
[Membership.]
if Block1 is listed in the list:
say "Block1 is there.";
[Loop.]
repeat with the block running through the list:
dump the block; [1 Block One. 1 Block Two.]
[Remember block two's sequence number was changed above.]
let X be entry 2 of the list; [Counting starts at 1.]
dump X; ["1 Block two."]
remove X from the list;
say the list. [Block1]
[Here's how we define a function and do arithmetic.]
To decide which number is the sum of all numbers up to (X - a number) (this is summing up):
let the total so far be a number;
repeat with the current number running from 1 to X:
now the total so far is the total so far + the current number;
decide on the total so far. [This is the return statement.]
[ We have higher order functions too. ]
To demonstrate a higher order function:
say summing up applied to {1, 2, 3, 4}.
To decide which number is the result of applying (phrase - phrase A -> A) twice to (B - a value of kind A):
let b1 be phrase applied to B;
let b2 be phrase applied to b1;
decide on b2.
To demonstrate defining a higher order function:
let X be 5;
say the result of applying summing up twice to X.
[ Rulebooks allow a number of functions which apply to the same type under different conditions to be stacked. ]
Datablock validation rules is a datablock based rulebook.
A datablock validation rule for a broken datablock: rule fails.
A datablock validation rule for a datablock (called the block):
dump the block;
rule succeeds.
To demonstrate invoking a rulebook:
follow datablock validation rules for Block1;
follow datablock validation rules for Block2.
[ Objects can also have relations, which resemble those in a relational database. ]
A dog is a kind of thing.
Rover is a dog.
The kennel is a container. [This is a built in base class.]
Rover is in the kennel. [This creates an inbuilt relation called "containment".]
[We can create relations by declaring their type.]
Guide dog ownership relates one dog to one person. [One-to-one.]
Property ownership relates various things to one person. [Many-to-one.]
Friendship relates various people to various people. [Many-to-many.]
[To actually use them we must assign verbs or prepositions to them.]
The verb to own means the property ownership relation.
The verb to be the guide dog of means the guide dog ownership relation.
The verb to be guided by means the reversed guide dog ownership relation.
The verb to be friends with means the friendship relation.
Edward is a person. A person can be blind. Edward is blind.
Edward is guided by Rover.
Benny is a person. Edward is friends with Benny.
To demonstrate looking something up with a relation:
repeat with the dog running through things that are the guide dog of Edward:
say the dog;
repeat with the friend running through things that are friends with Edward:
say the friend.
[We can also define relations that exist procedurally.]
Helpfulness relates a person (called the helper) to a person (called the helpee) when the helpee is blind and the helper is not blind.
The verb to be helpful to means the helpfulness relation.
To demonstrate using a procedural relation:
repeat with the helper running through people that are helpful to Edward:
say the helper.
[ Interface to the text adventure harness to allow the above code to be run. ]
Tutorial room is a room.
"A rather strange room full of buttons. Push them to run the exercises, or turn on the robot to run them all."
A button is a kind of thing. A button is fixed in place.
The red button is a button in tutorial room.
Instead of pushing the red button, do the thing everyone does with their first program.
The green button is a button in tutorial room.
Instead of pushing the green button, demonstrate calling a phrase with two parameters.
The blue button is a button in tutorial room.
Instead of pushing the blue button, show how to use list types.
The cyan button is a button in tutorial room.
Instead of pushing the cyan button, say the sum of all numbers up to 5.
The purple button is a button in tutorial room.
Instead of pushing the purple button, demonstrate a higher order function.
The black button is a button in tutorial room.
Instead of pushing the black button, demonstrate defining a higher order function.
The white button is a button in tutorial room.
Instead of pushing the white button, demonstrate invoking a rulebook.
The puce button is a button in tutorial room.
Instead of pushing the puce button, demonstrate looking something up with a relation.
The orange button is a button in tutorial room.
Instead of pushing the orange button, demonstrate using a procedural relation.
The robot is an object in tutorial room.
Instead of switching on the robot:
say "The robot begins to frantically flail its arms about.";
repeat with button running through buttons in the tutorial room:
say "The robot randomly hits [the button].";
try pushing button.
```
##Ready For More?
* [Inform 7](http://www.inform7.com/)

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

@ -10,7 +10,7 @@ contributors:
- ["Anton Strömkvist", "http://lutic.org/"]
- ["Rahil Momin", "https://github.com/iamrahil"]
- ["Gregrory Kielian", "https://github.com/gskielian"]
filename: LearnBash.sh
filename: LearnBash-it.sh
translators:
- ["Robert Margelli", "http://github.com/sinkswim/"]
- ["Tommaso Pifferi", "http://github.com/neslinesli93/"]

2
it-it/brainfuck-it.html.markdown → it-it/bf-it.html.markdown
View File

@ -1,5 +1,5 @@
---
language: brainfuck
language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]

2
it-it/coffeescript-it.html.markdown
View File

@ -4,8 +4,6 @@ contributors:
- ["Luca 'Kino' Maroni", "http://github.com/kino90"]
- ["Tenor Biel", "http://github.com/L8D"]
- ["Xavier Yao", "http://github.com/xavieryao"]
translators:
- ["Tommaso Pifferi","http://github.com/neslinesli93"]
filename: coffeescript-it.coffee
lang: it-it
---

498
it-it/git-it.html.markdown Normal file
View File

@ -0,0 +1,498 @@
---
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"]
translators:
- ["Christian Grasso", "http://chris54721.net"]
filename: LearnGit-it.txt
lang: it-it
---
Git è un sistema di
[controllo versione distribuito](https://it.wikipedia.org/wiki/Controllo_versione_distribuito)
e di gestione del codice sorgente.
Git esegue una serie di _snapshot_ per salvare lo stato di un progetto, così
facendo può fornirti la possibilità di gestire il tuo codice e di salvarne lo
stato assegnando delle versioni.
## Basi del controllo versione
### Cos'è il controllo versione?
Il controllo versione (_Version Control_ o _Versioning_) è un sistema che
registra le modifiche apportate a uno o più file nel tempo.
### Controllo versione centralizzato e distribuito
* Il controllo versione centralizzato si concentra sulla sincronizzazione, il
monitoraggio e il backup dei file.
* Il controllo versione distribuito si concentra sulla condivisione delle
modifiche. Ogni modifica ha un identificatore univoco.
* I sistemi distribuiti non hanno una struttura definita. Si potrebbe creare
ad esempio un sistema centralizzato simile a SVN utilizzando Git.
[Ulteriori informazioni](http://git-scm.com/book/it/v1/Per-Iniziare-Il-Controllo-di-Versione)
### Perchè usare Git?
* Consente di lavorare offline.
* Collaborare con altre persone è semplice!
* Utilizzare i branch (rami di sviluppo) è semplice!
* Git è veloce.
* Git è flessibile.
## Architettura di Git
### Repository
Un insieme di file, cartelle, registrazioni della cronologia e versioni.
Immaginalo come una struttura dati del codice, con la caratteristica che ogni
"elemento" del codice ti fornisce accesso alla sua cronologia delle revisioni,
insieme ad altre cose.
Un repository comprende la cartella .git e il working tree.
### Cartella .git (componente del repository)
La cartella .git contiene tutte le configurazioni, i log, i rami e altro.
[Lista dettagliata](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
### Working Tree (componente del repository)
Si tratta semplicemente delle cartelle e dei file presenti nel repository.
Spesso viene indicato come "directory di lavoro" ("working directory").
### Index (componente della cartella .git)
L'Index è l'area di staging di Git. Si tratta di un livello che separa il
working tree dal repository. Ciò fornisce agli sviluppatori più controllo su
cosa viene inviato al repository.
### Commit
Un commit è uno snapshot di una serie di modifiche apportate al working tree.
Ad esempio, se hai aggiunto 5 file e ne hai rimossi 2, ciò sarà registrato in
un commit. Il commit può essere pushato (inviato) o meno ad altri repository.
### Branch (ramo)
Un branch (ramo) è essenzialmente un puntatore all'ultimo commit che hai
effettuato. Effettuando altri commit, il puntatore verrà automaticamente
aggiornato per puntare all'ultimo commit.
### Tag
Un tag è un contrassegno applicato a un punto specifico nella cronologia dei
commit. Di solito i tag vengono utilizzati per contrassegnare le versioni
rilasciate (v1.0, v1.1, etc.).
### HEAD e head (componenti della cartella .git)
HEAD (in maiuscolo) è un puntatore che punta al branch corrente. Un repository
può avere solo 1 puntatore HEAD *attivo*.
head (in minuscolo) è un puntatore che può puntare a qualsiasi commit. Un
repository può avere un numero qualsiasi di puntatori head.
### Stadi di Git
* _Modified_ - Un file è stato modificato, ma non è ancora stato effettuato
un commit per registrare le modifiche nel database di Git
* _Staged_ - Un file modificato è stato contrassegnato per essere incluso nel
prossimo commit
* _Committed_ - È stato effettuato un commit e le modifiche sono state
registrate nel database di Git
## Comandi
### init
Crea un repository Git vuoto. Le impostazioni e le informazioni del repository
sono salvate nella cartella ".git".
```bash
$ git init
```
### config
Utilizzato per configurare le impostazioni, sia specifiche del repository, sia
a livello globale. Le impostazioni globali sono salvate in `~/.gitconfig`.
```bash
$ git config --global user.email "email@example.com"
$ git config --global user.name "Nome utente"
```
[Ulteriori informazioni su git config](http://git-scm.com/docs/git-config)
### help
Fornisce una documentazione molto dettagliata di ogni comando.
```bash
# Mostra i comandi più comuni
$ git help
# Mostra tutti i comandi disponibili
$ git help -a
# Documentazione di un comando specifico
# git help <nome_comando>
$ git help add
$ git help commit
$ git help init
# oppure git <nome_comando> --help
$ git add --help
$ git commit --help
$ git init --help
```
### Ignorare file
Per impedire intenzionalmente che file privati o temporanei vengano inviati
al repository Git.
```bash
$ echo "temp/" >> .gitignore
$ echo "privato.txt" >> .gitignore
```
### status
Mostra le differenza tra lo stato attuale del working tree e l'attuale commit
HEAD.
```bash
$ git status
```
### add
Aggiunge file alla staging area, ovvero li contrassegna per essere inclusi nel
prossimo commit. Ricorda di aggiungere i nuovi file, altrimenti non saranno
inclusi nei commit!
```bash
# Aggiunge un file nella directory attuale
$ git add HelloWorld.java
# Aggiunge un file in una sottocartella
$ git add /path/to/file/HelloWorld.c
# Il comando supporta le espressioni regolari
$ git add ./*.java
# Aggiunge tutti i file non ancora contrassegnati
$ git add --all
```
Questo comando contrassegna soltanto i file, senza effettuare un commit.
### branch
Utilizzato per gestire i branch (rami). Puoi visualizzare, modificare, creare o
eliminare branch utilizzando questo comando.
```bash
# Visualizza i branch e i remote
$ git branch -a
# Crea un nuovo branch
$ git branch nuovoBranch
# Elimina un branch
$ git branch -d nomeBranch
# Rinomina un branch
$ git branch -m nomeBranch nuovoNomeBranch
# Permette di modificare la descrizione di un branch
$ git branch nomeBranch --edit-description
```
### tag
Utilizzato per gestire i tag.
```bash
# Visualizza i tag esistenti
$ git tag
# Crea un nuovo tag
# L'opzione -m consente di specificare una descrizione per il tag.
# Se l'opzione -m non viene aggiunta, Git aprirà un editor per consentire
# l'inserimento del messaggio.
$ git tag -a v2.0 -m 'Versione 2.0'
# Mostra informazioni relative a un tag
# Include informazioni sul creatore del tag, la data di creazione, e il
# messaggio assegnato al tag oltre alle informazioni sul commit.
$ git show v2.0
```
### checkout
Consente di cambiare branch o ripristinare i file a una revisione specifica.
Tutti i file nel working tree vengono aggiornati per corrispondere alla versione
presente nel branch o nel commit specificato.
```bash
# Effettua il checkout di un repository - il branch predefinito è 'master'
$ git checkout
# Effettua il checkout di un branch specifico
$ git checkout nomeBranch
# Crea un nuovo branch e ne effettua il checkout
# Equivalente a "git branch <nomeBranch>; git checkout <nomeBranch>"
$ git checkout -b nuovoBranch
```
### clone
Clona, o copia, un repository esistente in una nuova directory. Inoltre,
aggiunge dei branch _remote-tracking_, utilizzati per monitorare i branch
remoti corrispondenti a quelli locali, e consentendo così di inviare le
modifiche al repository remoto.
```bash
# Clona learnxinyminutes-docs
$ git clone https://github.com/adambard/learnxinyminutes-docs.git
# Clona solo l'ultima revisione di un repository
$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
# Clona solo un branch specifico
$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
```
### commit
Effettua uno _snapshot_ dello stato attuale del working tree e registra le
modifiche in un nuovo commit. Il commit contiene, oltre alle modifiche apportate,
anche l'autore e una descrizione.
```bash
# Crea un nuovo commit con un messaggio
$ git commit -m "Aggiunta la funzione multiplyNumbers() in HelloWorld.c"
# Aggiunge (git add) automaticamente i file modificati o eliminati (ESCLUSI
# i nuovi file) e quindi effettua il commit
$ git commit -a -m "Modificato foo.php e rimosso bar.php"
# Modifica l'ultimo commit (il comando elimina il commit precedente e lo
# sostituisce con uno nuovo)
$ git commit --amend -m "Messaggio corretto"
```
### diff
Mostra la differenza tra un file nel working tree e la sua versione nell'index,
in un branch o ad un commit specifico.
```bash
# Mostra la differenza tra il working tree e l'index
$ git diff
# Mostra la differenza tra l'index e il commit più recente
$ git diff --cached
# Mostra la differenza tra il working tree e un commit specifico
$ git diff <commit>
# Mostra la differenza tra due commit
$ git diff <commit1> <commit2>
```
### grep
Consente di effettuare una ricerca veloce nel repository.
```bash
# Cerca "variableName" nei file Java
$ git grep 'variableName' -- '*.java'
# Cerca una riga contenente "arrayListName" E "add" oppure "remove"
$ git grep -e 'arrayListName' --and \( -e add -e remove \)
```
Impostazioni relative a `git grep`:
```bash
# Mostra il numero delle righe
$ git config --global grep.lineNumber true
# Rende i risultati più leggibili
$ git config --global alias.g "grep --break --heading --line-number"
```
### log
Mostra la cronologia dei commit inviati al repository.
```bash
# Mostra tutti i commit
$ git log
# Mostra ogni commit su una sola riga
$ git log --oneline
# Mostra solo i commit legati ai merge
$ git log --merges
```
### merge
Effettua un "merge", ovvero unisce le modifiche di un branch in quello attuale.
```bash
# Unisce il branch specificato a quello attuale
$ git merge nomeBranch
# Genera un commit in ogni caso dopo aver eseguito il merge
$ git merge --no-ff nomeBranch
```
### mv
Rinomina o sposta un file.
```bash
# Rinomina un file
$ git mv HelloWorld.c HelloNewWorld.c
# Sposta un file
$ git mv HelloWorld.c ./new/path/HelloWorld.c
# Forza l'esecuzione del comando
# Se un file "nuovoNomeFile" esiste già nella directory, verrà sovrascritto
$ git mv -f nomeFile nuovoNomeFile
```
### pull
Aggiorna il repository effettuando il merge delle nuove modifiche.
```bash
# Aggiorna il branch attuale dal remote "origin"
$ git pull
# Di default, git pull aggiorna il branch attuale effettuando il merge
# delle nuove modifiche presenti nel branch remote-tracking corrispondente
$ git pull
# Aggiorna le modifiche dal branch remoto, quindi effettua il rebase dei commit
# nel branch locale
# Equivalente a: "git pull <remote> <branch>; git rebase <branch>"
$ git pull origin master --rebase
```
### push
Invia ed effettua il merge delle modifiche da un branch locale ad uno remoto.
```bash
# Invia ed effettua il merge delle modifiche dal branch "master"
# al remote "origin".
# git push <remote> <branch>
$ git push origin master
# Di default, git push invia ed effettua il merge delle modifiche
# dal branch attuale al branch remote-tracking corrispondente
$ git push
# Per collegare il branch attuale ad uno remoto, basta aggiungere l'opzione -u
$ git push -u origin master
```
### stash
Salva lo stato attuale del working tree in una lista di modifiche non ancora
inviate al repository con un commit che possono essere applicate nuovamente
in seguito.
Questo comando può essere utile se, ad esempio, mentre stai effettuando delle
modifiche non ancora completate, hai bisogno di aggiornare il repository locale
con `git pull`. Poichè non hai ancora effettuato il commit di tutte le modifiche,
non sarà possibile effettuare il pull. Tuttavia, puoi utilizzare `git stash` per
salvare temporaneamente le modifiche e applicarle in seguito.
```bash
$ git stash
```
Ora puoi effettuare il pull:
```bash
$ git pull
```
A questo punto, come già suggerito dall'output del comando `git stash`, puoi
applicare le modifiche:
```bash
$ git stash apply
```
Infine puoi controllare che tutto sia andato bene:
```bash
$ git status
```
Puoi visualizzare gli accantonamenti che hai effettuato finora utilizzando:
```bash
$ git stash list
```
### rebase (attenzione)
Applica le modifiche effettuate su un branch su un altro branch.
*Non effettuare il rebase di commit che hai già inviato a un repository pubblico!*
```bash
# Effettua il rebase di experimentBranch in master
$ git rebase master experimentBranch
```
[Ulteriori informazioni](https://git-scm.com/book/it/v1/Diramazioni-in-Git-Rifondazione)
### reset (attenzione)
Effettua il reset del commit HEAD attuale ad uno stato specifico.
Questo comando consente di annullare `merge`, `pull`, `commit`, `add` e altro.
Tuttavia, può essere pericoloso se non si sa cosa si sta facendo.
```bash
# Effettua il reset della staging area (annullando le aggiunte e le rimozioni
# di file dal repository, senza modificare il working tree)
$ git reset
# Effettua il reset completo della staging area, ovvero annulla qualsiasi
# modifica al repository eliminando definitivamente anche tutte le modifiche
# ai file non inviate e ripristinando il working tree
$ git reset --hard
# Effettua il reset del branch attuale al commit specificato (lasciando il
# working tree intatto)
$ git reset 31f2bb1
# Effettua il reset completo del branch attuale al commit specificato,
# eliminando qualsiasi modifica non inviata
$ git reset --hard 31f2bb1
```
### rm
Consente di rimuovere un file dal working tree e dal repository.
Per eliminare un file solo dal working tree ma non dal repository, è invece
necessario utilizzare `/bin/rm`.
```bash
# Elimina un file nella directory attuale
$ git rm HelloWorld.c
# Elimina un file da una sottocartella
$ git rm /pather/to/the/file/HelloWorld.c
```

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)

145
it-it/ruby-ecosystem-it.html.markdown Normal file
View File

@ -0,0 +1,145 @@
---
category: tool
tool: ruby ecosystem
contributors:
- ["Jon Smock", "http://github.com/jonsmock"]
- ["Rafal Chmiel", "http://github.com/rafalchmiel"]
translators:
- ["Cristian Achille", "http://github.com/blackdev1l/"]
lang: it-it
---
Generalmente chi usa ruby ha l'esigenza di avere differenti versioni di Ruby
installate, gestire le proprie gemme, e le loro dipendenze.
## Manager Ruby
Alcune piattaforme hanno Ruby pre-installato o disponibile come pacchetto.
Molti sviluppatori Ruby non usano questi pacchetti, o se lo fanno, li usano solo
per installare dei manager Ruby, i quali permettono di installare e gestire più
versioni di Ruby in base al progetto su cui si lavora.
Di seguito i più famosi manager Ruby:
* [RVM](https://rvm.io/) - Installa e permette di utilizzare diverse versioni di
Ruby. RVM Ha anche il concetto di gemsets i quali isolano completamente l'ambiente di sviluppo del progetto.
* [ruby-build](https://github.com/sstephenson/ruby-build) - Installa solamente
multiple versioni di ruby. Usa questo se vuoi maggior controllo sull'installazione di Ruby.
* [rbenv](https://github.com/sstephenson/rbenv) -
Permette solo la scelta di quale versione Ruby utilizzare. Usato insieme a ruby-build.
Utilizza questo per un maggior controllo su quale versione di Ruby utilizzare.
* [chruby](https://github.com/postmodern/chruby) -
Permette solo la scelta di quale Ruby utilizzare, simile a rbenv.
## Ruby Versions
Ruby fu creato da Yukihiro "Matz" Matsumoto, il [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life),
(acronimo inglese che sta per "Benevolo dittatore a vita") , seppur
ultimamente non è più del tutto vera; l'implementazione di Ruby
è detta MRI (Matz' Reference Implementation), e dunque quando si legge di una
versione Ruby, essa si riferisce sempre al rilascio di una MRI
Le tre maggiori versioni di Ruby in uso sono:
* 2.0.0 - Rilasciata nel febbraio 2013. La maggior parte delle librerie e
framework supportano la 2.0.0
* 1.9.3 - Rilasciata nel ottobre 2011. QUesta è la versione che molti
svluppatori usano, il supporto è
[concluso](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
* 1.8.7 - Il supporto per Ruby 1.8.7 è
[concluso](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
I cambiamenti tra la 1.8.7 a la 1.9.x sono maggiori di quelli tra la 1.9.3 a la
2.0.0. Per esempio, nella 1.9 vengono introdotti encodings e bytecode VM.
Esistono ancora dei progetti basati sulla 1.8.7, ma stanno diventando una
minoranza man mano che la community si trasferisce alle versioni 1.92 e
1.9.3
## Ruby Implementations
L'ecosistema Ruby gode di molte implementazioni differenti di Ruby, ognuna con
particolari punti di forza, da chiarire che ogni implementazione è scritta con
un linguaggio diverso, ma esse *sono tutte Ruby*. Ogni implementazione ha
feature extra ma tutte esse possono eseguire file ruby. Per esempio, JRuby è
scritto in Java, ma non devi conoscere java per usarlo.
Implementazioni mature e compatibili:
* [MRI](https://github.com/ruby/ruby) - Scritto in C, Questa è l'implementazione
standard di Ruby, per definizione è 100% compatibile (con se stessa). Tutte le
altre implemetazioni mantengono la compatibilità con MRI
(vedere [RubySpec](#rubyspec) sotto).
* [JRuby](http://jruby.org/) - Scritto in Java e Ruby, Questa implementazione è
molto veloce e robusta, la forza di JRuby consiste nell'interoperabilità
tra JVM/Java, permettendo l'utilizzo di struemnti Java già esistenti, progetti
e linguaggi
* [Rubinius](http://rubini.us/) - Scritto principalmente in Ruby con un
c++ bytecode VM, molto matura e veloce, permette alcune feature riguardo VM.
Mediamente mature e compatibili:
* [Maglev](http://maglev.github.io/) - Sviluppata sui Gemstone, è una Smalltalk
VM, Smalltalk è degli strumenti molto utili, e questo progetto cerca di portare
questi strumenti nello sviluppo Ruby.
* [RubyMotion](http://www.rubymotion.com/) - Porta ruby nello sviluppo iOS.
Poco mature e compatibili:
* [Topaz](http://topazruby.com/) - Scritto in RPython (usando PyPy come
toolchain) Topaz è un progetto ancora giovane e non compatibile, ha le
possibilità di diventare una implementazione Ruby molto performante
* [IronRuby](http://ironruby.net/) - Scritto in C# e prendendo di mira la
piattaforma .NET, lo sviluppo sembra fermo da quando Microsoft ha rimosso il
suo supporto.
Le implementazioni Ruby possono avere una propria versione, ma hanno sempre come
target una specifica versione di MRI. Molte implementazioni hanno l'abilità di
selezionare una versione specifica di MRI.
##RubySpec
La maggior parte delle implementazioni Ruby dipendono pesantemente su
[RubySpec](http://rubyspec.org/). Ruby non ha una specifica ufficiale, quindi la
community ha scritto una specifica eseguibile in Ruby per testare la compatibilità
con MRI.
## RubyGems
[RubyGems](http://rubygems.org/) è un package manager gestito dalla communtiy
per Ruby. Rubygems viene installato con Ruby, quindi non c'è bisogno di
scaricarlo separatamente.
I pacchetti Ruby sono chiamate "gemme", e possono essere hostate dalla community
su RubyGems.org . Ogni gemma contiene il codice sorgente e del metadata, tra cui
la versione, le dipendenze, autor* e licenz*.
## Bundler
[Bundler](http://bundler.io/) è un risolvitore di dipendenze, Esso usa il Gemfile
di un progetto per cercare le dipendenze, dopo di che ottiene le dipendenze delle
dipendenze ricorsivamente, Questo procedimento viene eseguito finchè tutte le
dipendenze sono state risolte e scaricate, o si fermerà se un conflitto verrà
trovato.
Bundler genererà un error se troverà dipendenze in conflitto, Per esempio,
se la gemma A richiede la versione 3 o maggiore della gemma Z, ma la gemma B
richiede la versione 2, Bundler ti notificherà del conflitto. Questo diventa
di aiuto nel momento in cui si hanno molte gemme nel progetto, il che porta a
un grande grafo di dipendenza da risolvere.
# Testing
Il testing è un pezzo fondamentale della cultura Ruby, Ruby viene installato con
il proprio testing framework chiamato minitest (O TestUnit per ruby 1.8.x).
Esistono molte librerie con obiettivi differenti
* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Testing frameowrk rilasciato insieme a Ruby 1.8.x
* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Testing frameowrk rilasciato insieme a Ruby 1.9/2.0
* [RSpec](http://rspec.info/) - Un testing framework che si concentra nella chiarezza
* [Cucumber](http://cukes.info/) - Un BDD testing framework che estrapola testo formattato in Gherkin
## Sii cordiale
La community Ruby è orgogliosa di essere una communtiy aperta, accogliente e
variegata. Matz stesso è estremamente amichevole, e la generosità degli sviluppatori
Ruby è fantastica.

4
ja-jp/bash-jp.html.markdown
View File

@ -66,7 +66,7 @@ echo "Last program return value: $?"
echo "Script's PID: $$"
echo "Number of arguments: $#"
echo "Scripts arguments: $@"
echo "Scripts arguments seperated in different variables: $1 $2..."
echo "Scripts arguments separated in different variables: $1 $2..."
# 入力値の読み込み
echo "What's your name?"
@ -117,7 +117,7 @@ echo "There are $(ls | wc -l) items here."
echo "There are `ls | wc -l` items here."
# BashはJavaやC++のように、case文による分岐ができます
case "$VARIABLE" in
case "$VARIABLE" in
#分岐条件として使いたいパターンを並べてください
0) echo "There is a zero.";;
1) echo "There is a one.";;

777
ja-jp/php-jp.html.markdown Normal file
View File

@ -0,0 +1,777 @@
---
language: PHP
contributors:
- ["Malcolm Fell", "http://emarref.net/"]
- ["Trismegiste", "https://github.com/Trismegiste"]
translators:
- ["Kazushige Tominaga", "https://github.com/kazu9su"]
filename: learnphp-jp.php
lang: ja-jp
---
このドキュメントでは、 PHP 5+ について説明します。
```php
<?php // PHPのコードは、<?php タグで囲む必要があります。
// もしあなたのphpファイルがPHPのみで構成される場合、
// 意図しない出力を防ぐために、phpの閉じタグは省略するのがベストプラクティスです。
// 一行のコメントを書く場合、2つのスラッシュで始めます。
# ハッシュ(ポンド記号として知られる)を使いたいでしょうが、//のほうが一般的です
/*
スラッシュとアスタリスク、アスタリスクとスラッシュで囲むと、
複数行のコメントを書けます。
*/
// 出力をプリントしたい場合は、"echo" か "print" を使います。
print('Hello '); // これは "Hello " という改行なしの文字列をプリントします。
// カッコ()はprintとecho関数に置いては省略できます。
echo "World\n"; // これは改行ありの"World"という文字列をプリントします。
// (全ての命令文では、セミコロンを最後に付けることが必須です。)
// <?php タグの外側にあるものは、自動的にプリントされます。
?>
Hello World Again!
<?php
/************************************
* 型と変数について
*/
// 変数は"$"マークで始まります
// 有効な変数名にするには、文字またはアンダースコア(_)で始めて,
// その後はどんな数字でも、文字でも、アンダースコアで続けても構いません
//ブーリアン値は大文字、小文字問いません
$boolean = true; // or TRUE or True
$boolean = false; // or FALSE or False
// 数値
$int1 = 12; // => 12
$int2 = -12; // => -12
$int3 = 012; // => 10 (先頭の0は8進法を示す)
$int4 = 0x0F; // => 15 (先頭の0xは16進法を示す)
// floats(浮動小数) (別名double)
$float = 1.234;
$float = 1.2e3;
$float = 7E-10;
// 変数の削除
unset($int1);
// 計算式
$sum = 1 + 1; // 2
$difference = 2 - 1; // 1
$product = 2 * 2; // 4
$quotient = 2 / 1; // 2
// 式の省略
$number = 0;
$number += 1; // $numberに1加算Increment $number by 1
echo $number++; // 1 がプリントされる(式の評価の後に加算される)
echo ++$number; // 3 がプリントされる(式の評価の前に加算される)
$number /= $float; // 割り算した結果の商を$numberに割り当てる
// 文字列はシングルクォートで囲むのが望ましいです
$sgl_quotes = '$String'; // => '$String'
// 文字列中に、他の変数を埋め込みたい場合以外は、ダブルクォートを使用するのはやめましょう
$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
// Special characters are only escaped in double quotes
// 特殊文字はダブルクォートによってのみ、エスケープされます
$escaped = "This contains a \t tab character.";
$unescaped = 'This just contains a slash and a t: \t';
// 必要があれば、変数を波括弧で囲みます
$money = "I have $${number} in the bank.";
// PHP 5.3から、nowdocs形式が変数の挿入をしない複数行の文字列の定義に使用できます
$nowdoc = <<<'END'
Multi line
string
END;
// ヒアドキュメント形式なら、文字列中に変数の挿入を行えます。
$heredoc = <<<END
Multi line
$sgl_quotes
END;
// 文字列の連結は . で行います
echo 'This string ' . 'is concatenated';
// 別々のパラメータとしてechoに渡すこともできます
echo 'Multiple', 'Parameters', 'Valid';
/********************************
* 定数
*/
// 定数は define() を使って定義します
// また、実行中は変更することができないので注意が必要です！
// 有効は定数は文字かアンダースコアで始めます
// それ移行のは、どんな数値でも文字列でもアンダースコアでも構いません
define("FOO", "something");
// 定義した名前をそのまま($はつけずに)使用することで、定数にアクセスできます
// access to a constant is possible by direct using the choosen name
echo 'This outputs '.FOO;
/********************************
* 配列
*/
// PHPの配列はすべて連想配列です
// 連想配列は、他の言語ではハッシュ(ハッシュマップ)として知られています
// すべてのバージョンのPHPで動作します
$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
// PHP 5.4 から、新しいシンタックスが導入されました
$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
echo $associative['One']; // 1とプリントされます
// キーを指定しないシンプルな配列にも、自動的に数値キーが振られます
$array = ['One', 'Two', 'Three'];
echo $array[0]; // => "One"
// 配列の最後に要素を追加する
$array[] = 'Four';
// または、次のようにも書けます
array_push($array, 'Five');
// 配列から要素を削除
unset($array[3]);
/********************************
* 出力
*/
echo('Hello World!');
// 標準出力にHello World! とプリントします
// 標準出力はブラウザーで実行していればWebページに出力されます
// Stdout is the web page if running in a browser.
print('Hello World!'); // echoの結果と同じです
// echo は言語自体の構成要素であり、括弧なしで呼び出せます
// echo is actually a language construct, so you can drop the parentheses.
echo 'Hello World!';
print 'Hello World!'; // printも同様です
$paragraph = 'paragraph';
echo 100; // スカラー数値を直接出力します
echo $paragraph; // 変数も使用できます
// PHPタグの短縮型が設定されているか、使用しているPHPのバージョンが
// 5.4.0 以上であれば、短縮echoシンタックスを使用できます
?>
<p><?= $paragraph ?></p>
<?php
$x = 1;
$y = 2;
$x = $y; // $xに$yの値を代入します
$z = &$y;
// $zは$yへの参照です。
// $zの値を変更すると$yの値も変更されるでしょう。逆も同様です。
// $xは$yの最初の値を変わらず保持しています
echo $x; // => 2
echo $z; // => 2
$y = 0;
echo $x; // => 2
echo $z; // => 0
// 変数の型と値を標準出力へダンプします
var_dump($z); // int(0) と出力されます
// 人間が読めるフォーマットで変数を標準出力にプリントします
print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
/********************************
* ロジック
*/
$a = 0;
$b = '0';
$c = '1';
$d = '1';
// assertは引数がfalseの場合、Exceptionを投げます
//これらの比較は型が違ったとしても、常に真です。
assert($a == $b); // equality
assert($c != $a); // inequality
assert($c <> $a); // alternative inequality
assert($a < $c);
assert($c > $b);
assert($a <= $b);
assert($c >= $d);
// 次の比較は値が等しく、かつ同じ型である場合のみ真です
assert($c === $d);
assert($a !== $d);
assert(1 === '1');
assert(1 !== '1');
// spaceship演算子はPHP7から使用可能です
$a = 100;
$b = 1000;
echo $a <=> $a; // 等しいので0になります
echo $a <=> $b; // $a < $b なので -1 です
echo $b <=> $a; // $b > $a なので 1 です
// 変数は使用するコンテキストによって、変換されます
$integer = 1;
echo $integer + $integer; // => 2
$string = '1';
echo $string + $string; // => 2 (文字列は強制的に数値として処理されます)
$string = 'one';
echo $string + $string; // => 0
// '+'演算子は文字列'one'を数値にキャストできないので、0と出力されます
// 型のキャスティングによって、変数を指定したもう一つの型として扱うことができます
// Type casting can be used to treat a variable as another type
$boolean = (boolean) 1; // => true
$zero = 0;
$boolean = (boolean) $zero; // => false
// 型をキャストするため専用の関数も存在します
$integer = 5;
$string = strval($integer);
$var = null; // Null値
/********************************
* 制御構造
*/
if (true) {
print 'I get printed';
}
if (false) {
print 'I don\'t';
} else {
print 'I get printed';
}
if (false) {
print 'Does not get printed';
} elseif(true) {
print 'Does';
}
// 三項演算子
print (false ? 'Does not get printed' : 'Does');
// PHP 5.3から、三項演算子の短縮形が使用できます
// $x ? $x : 'Does'と同義です
$x = false;
print($x ?: 'Does');
// null合体演算子はPHP 7から使用できます
$a = null;
$b = 'Does print';
echo $a ?? 'a is not set'; // prints 'a is not set'
echo $b ?? 'b is not set'; // prints 'Does print'
$x = 0;
if ($x === '0') {
print 'Does not print';
} elseif($x == '1') {
print 'Does not print';
} else {
print 'Does print';
}
// :を用いる別の構文はテンプレートで有用です
?>
<?php if ($x): ?>
この部分はifが真のとき表示されます
<?php else: ?>
それ以外の場合は、この部分が表示されます
<?php endif; ?>
<?php
// いくつかのロジックを保存するにはswitchを使用します
switch ($x) {
case '0':
print 'Switch does type coercion';
break; // breakを書く必要があります。
// でなければ、次の'two', 'three'のcase文を続けて実行することになります。
case 'two':
case 'three':
// 変数が'two'または'three'の場合、何かを実行します
break;
default:
//デフォルトで何かを実行します
}
// while, do, forの構文は、おそらく他の言語とも共通なものです
$i = 0;
while ($i < 5) {
echo $i++;
}; // Prints "01234"
echo "\n";
$i = 0;
do {
echo $i++;
} while ($i < 5); // Prints "01234"
echo "\n";
for ($x = 0; $x < 10; $x++) {
echo $x;
} // Prints "0123456789"
echo "\n";
$wheels = ['bicycle' => 2, 'car' => 4];
//Foreachループによって、 配列を反復処理できます
foreach ($wheels as $wheel_count) {
echo $wheel_count;
} // Prints "24"
echo "\n";
// 値と同じ様に、keyも反復処理できます
foreach ($wheels as $vehicle => $wheel_count) {
echo "A $vehicle has $wheel_count wheels";
}
echo "\n";
$i = 0;
while ($i < 5) {
if ($i === 3) {
break; // Exit out of the while loop
}
echo $i++;
} // Prints "012"
for ($i = 0; $i < 5; $i++) {
if ($i === 3) {
continue; // Skip this iteration of the loop
}
echo $i;
} // Prints "0124"
/********************************
* 関数
*/
// 関数を"function"で定義します
function my_function () {
return 'Hello';
}
echo my_function(); // => "Hello"
// 有効な関数名は、文字またはアンダースコアで始めます。それ以降は
// どれだけ長い文字、数値、アンダースコアを続けても構いません
function add ($x, $y = 1) { // $yはオプショナルな値であり、デフォルトで 1 です
$result = $x + $y;
return $result;
}
echo add(4); // => 5
echo add(4, 2); // => 6
// $result には、関数の外からアクセス出来ません
// print $result; // エラーになります
// PHP 5.3 から、無名関数が使えます
$inc = function ($x) {
return $x + 1;
};
echo $inc(2); // => 3
function foo ($x, $y, $z) {
echo "$x - $y - $z";
}
// 関数は、関数を返すことができます
function bar ($x, $y) {
// 関数外の変数を利用したいときは、'use'を使います
return function ($z) use ($x, $y) {
foo($x, $y, $z);
};
}
$bar = bar('A', 'B');
$bar('C'); // Prints "A - B - C"
// 文字列を使って、定義済みの関数を呼び出すことができます
$function_name = 'add';
echo $function_name(1, 2); // => 3
// プログラミング中に、動的に動かす関数を決める場合に便利です。
// もしくは、call_user_func(callable $callback [, $parameter [, ... ]]) を使っても同じことができます
// 特に指定しなくても、渡された引数を受け取ることもできます
function parameters() {
$numargs = func_num_args();
if ($numargs > 0) {
echo func_get_arg(0) . ' | ';
}
$args_array = func_get_args();
foreach ($args_array as $key => $arg) {
echo $key . ' - ' . $arg . ' | ';
}
}
parameters('Hello', 'World'); // Hello | 0 - Hello | 1 - World |
/********************************
* ファイルの読み込み
*/
<?php
// 読み込まれたファイル中のPHPは、同じくPHPのオープンタグで始める必要があります
include 'my-file.php';
// my-file.php中のコードは、現在のスコープの中で使用可能です
// もしファイルを読み込めなければ (例:file not found)、警告が発せられます
include_once 'my-file.php';
// my-file.phpのコードが既にどこかで読み込まれていれば、
// ファイルを読み込みません。これは、クラスの多重定義のエラーを防ぎます
require 'my-file.php';
require_once 'my-file.php';
// include()と同じように、require()はもしファイルを読み込むことができなければ、
// 致命的エラーの原因となります
// my-include.phpの内容
<?php
return 'Anything you like.';
// End file
// include()とrequire()は一つの値を返します
$value = include 'my-include.php';
// ファイルは与えられたファイルパスを基に読み込まれます。
// ファイルパスを指定しない場合は、include_path の設定を利用します。
// もしファイルがinclude_path中に見つからない場合は、
// 呼び出し元スクリプトのディレクトリと作業ディレクトリの中も探します。
// それでも見つからない場合、失敗します。
/* */
/********************************
* クラス
*/
// クラスはclassキーワードで定義します
class MyClass
{
const MY_CONST = 'value'; // クラス定数です
static $staticVar = 'static';
// スタティック変数とアクセス制限
public static $publicStaticVar = 'publicStatic';
// クラス内でのみアクセス可能
private static $privateStaticVar = 'privateStatic';
// そのクラスと子クラスで参照可能
protected static $protectedStaticVar = 'protectedStatic';
// プロパティはアクセス制限を宣言する必要があります
public $property = 'public';
public $instanceProp;
protected $prot = 'protected'; // そのクラスと子クラスで参照可能
private $priv = 'private'; // クラス内でのみアクセス可能
// __constructでコンストラクターを生成します
public function __construct($instanceProp) {
// $thisでインスタンス変数にアクセスします
$this->instanceProp = $instanceProp;
}
// メソッドはクラス内で関数として定義されます
public function myMethod()
{
print 'MyClass';
}
// finalキーワードは関数の上書きを禁止します
final function youCannotOverrideMe()
{
}
/*
* クラスプロパティまたはメソッドをstaticとして作成すれば、
* クラスをインスタンス化(newすること)しなくてもアクセスできます。
* プロパティをstaticとして定義すると、
* インスタンス化されたクラスオブジェクトを通してのアクセスはできなくなります。
*/
public static function myStaticMethod()
{
print 'I am static';
}
}
// クラス定数は、いつでも静的にアクセスできます。
echo MyClass::MY_CONST; // Outputs 'value';
echo MyClass::$staticVar; // Outputs 'static';
MyClass::myStaticMethod(); // Outputs 'I am static';
// クラスをインスタンス化するには、newを使います。
$my_class = new MyClass('An instance property');
// 括弧はもし引数を渡す必要がなければ省略可能です。
// ->を使ってクラスのメンバにアクセスします。
echo $my_class->property; // => "public"
echo $my_class->instanceProp; // => "An instance property"
$my_class->myMethod(); // => "MyClass"
// extendsを使用してクラスを継承します。
class MyOtherClass extends MyClass
{
function printProtectedProperty()
{
echo $this->prot;
}
// メソッドを上書きします。
function myMethod()
{
parent::myMethod();
print ' > MyOtherClass';
}
}
$my_other_class = new MyOtherClass('Instance prop');
$my_other_class->printProtectedProperty(); // => Prints "protected"
$my_other_class->myMethod(); // Prints "MyClass > MyOtherClass"
final class YouCannotExtendMe
{
}
// 「マジックメソッド」を使ってゲッターとセッターを生成できます。
class MyMapClass
{
private $property;
public function __get($key)
{
return $this->$key;
}
public function __set($key, $value)
{
$this->$key = $value;
}
}
$x = new MyMapClass();
echo $x->property; // __get() メソッドを使用します
$x->property = 'Something'; // __set() メソッドを使用します
// クラスは抽象クラスにもできます(abstractキーワードを使用します)し、
// インターフェースを実装することもできます(implementsキーワードを使用します)。
// インターフェースはinterfaceキーワードで定義します。
interface InterfaceOne
{
public function doSomething();
}
interface InterfaceTwo
{
public function doSomethingElse();
}
// インターフェースは継承することができます
interface InterfaceThree extends InterfaceTwo
{
public function doAnotherContract();
}
abstract class MyAbstractClass implements InterfaceOne
{
public $x = 'doSomething';
}
class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
{
public function doSomething()
{
echo $x;
}
public function doSomethingElse()
{
echo 'doSomethingElse';
}
}
// クラスは1つ以上のインターフェースを実装できます。
class SomeOtherClass implements InterfaceOne, InterfaceTwo
{
public function doSomething()
{
echo 'doSomething';
}
public function doSomethingElse()
{
echo 'doSomethingElse';
}
}
/********************************
* トレイト
*/
// トレイトはPHP 5.4.0 以上で使用可能で、traitキーワードで定義します。
trait MyTrait
{
public function myTraitMethod()
{
print 'I have MyTrait';
}
}
class MyTraitfulClass
{
use MyTrait;
}
$cls = new MyTraitfulClass();
$cls->myTraitMethod(); // Prints "I have MyTrait"
/********************************
* 名前空間
*/
// このセクションは名前空間の定義はファイルの先頭で宣言される必要があるため、
// 独立しています。
// そのケースには当てはまらないふりをして続けましょう。
<?php
// デフォルトでは、クラスはグローバルな名前空間に存在し、
// バックスラッシュによって明確にコールできます。
$cls = new \MyClass();
// ファイルに名前空間をセットします
namespace My\Namespace;
class MyClass
{
}
// (別のファイルからの呼び出し)
$cls = new My\Namespace\MyClass;
// 異なる名前空間からの呼び出し
namespace My\Other\Namespace;
use My\Namespace\MyClass;
$cls = new MyClass();
// 名前空間に別名をつけることもできます
namespace My\Other\Namespace;
use My\Namespace as SomeOtherNamespace;
$cls = new SomeOtherNamespace\MyClass();
/**********************
* エラーハンドリング
*
*/
// シンプルなエラーハンドリングは、try catchを使えば行えます
try {
// 処理を実行します
} catch ( Exception $e) {
// 例外を処理します
}
// try catchを名前空間を持った環境で使用するときは、次のようにします。
try {
// Do something
// 処理を実行します
} catch (\Exception $e) {
// 例外を処理します
}
// 例外のカスタマイズ
class MyException extends Exception {}
try {
$condition = true;
if ($condition) {
throw new MyException('Something just happend');
}
} catch (MyException $e) {
// Handle my exception
}
```
## より詳しい情報
リファレンスを見るため、またコミュニティへの情報提供のために、 [PHP公式ドキュメント](http://www.php.net/manual/) を訪れてみてください。
もし最新のベストプラクティスに興味があるなら、
[PHP The Right Way](http://www.phptherightway.com/)を訪れてみてください。
もしあなたがよいパッケージマネジメント・システムを持つ言語で開発経験があるのなら、
[Composer](http://getcomposer.org/)も確かめてみてください。
共通基準を知るためには、PHP Framework Interoperability Groupの
[PSR standards](https://github.com/php-fig/fig-standards)にも訪れてみてください。

97
java.html.markdown
View File

@ -17,9 +17,11 @@ programming language.
```java
// Single-line comments start with //
/*
Multi-line comments look like this.
*/
/**
JavaDoc comments look like this. Used to describe the Class or various
attributes of a Class.
@ -30,11 +32,12 @@ import java.util.ArrayList;
// Import all classes inside of java.security package
import java.security.*;
// Each .java file contains one outer-level public class, with the same name as
// the file.
// Each .java file contains one outer-level public class, with the same name
// as the file.
public class LearnJava {
// In order to run a java program, it must have a main method as an entry point.
// In order to run a java program, it must have a main method as an entry
// point.
public static void main (String[] args) {
// Use System.out.println() to print lines.
@ -60,7 +63,8 @@ public class LearnJava {
*/
// Declare a variable using <type> <name>
int fooInt;
// Declare multiple variables of the same type <type> <name1>, <name2>, <name3>
// Declare multiple variables of the same
// type <type> <name1>, <name2>, <name3>
int fooInt1, fooInt2, fooInt3;
/*
@ -69,7 +73,8 @@ public class LearnJava {
// Initialize a variable using <type> <name> = <val>
int fooInt = 1;
// Initialize multiple variables of same type with same value <type> <name1>, <name2>, <name3> = <val>
// Initialize multiple variables of same type with same
// value <type> <name1>, <name2>, <name3> = <val>
int fooInt1, fooInt2, fooInt3;
fooInt1 = fooInt2 = fooInt3 = 1;
@ -119,18 +124,15 @@ public class LearnJava {
final double E;
E = 2.71828;
// BigInteger - Immutable arbitrary-precision integers
//
// BigInteger is a data type that allows programmers to manipulate
// integers longer than 64-bits. Integers are stored as an array of
// of bytes and are manipulated using functions built into BigInteger
//
// 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 BigInteger(fooByteArray);
// BigDecimal - Immutable, arbitrary-precision signed decimal number
//
// A BigDecimal takes two parts: an arbitrary precision integer
@ -142,16 +144,13 @@ public class LearnJava {
//
// BigDecimal can be initialized with an int, long, double or String
// or by initializing the unscaled value (BigInteger) and scale (int).
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
String fooString = "My String Is Here!";
@ -175,7 +174,7 @@ public class LearnJava {
// Another way to declare & initialize an array
int[] y = {9000, 1000, 1337};
String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
boolean bools[] = new boolean[] {true, false, false};
boolean bools[] = {true, false, false};
// Indexing an array - Accessing an element
System.out.println("intArray @ 0: " + intArray[0]);
@ -184,7 +183,7 @@ public class LearnJava {
intArray[1] = 1;
System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Others to check out
// Other data types worth checking out
// ArrayLists - Like arrays except more functionality is offered, and
// the size is mutable.
// LinkedLists - Implementation of doubly-linked list. All of the
@ -212,7 +211,7 @@ public class LearnJava {
System.out.println("1+2 = " + (i1 + i2)); // => 3
System.out.println("2-1 = " + (i2 - i1)); // => 1
System.out.println("2*1 = " + (i2 * i1)); // => 2
System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
// Modulo
@ -242,7 +241,7 @@ public class LearnJava {
| Bitwise inclusive OR
*/
// Incrementations
// Increment operators
int i = 0;
System.out.println("\n->Inc/Dec-rementation");
// The ++ and -- operators increment and decrement by 1 respectively.
@ -314,7 +313,6 @@ public class LearnJava {
// for each loop structure => for (<object> : <iterable>)
// reads as: for each element in the iterable
// note: the object type must match the element type of the iterable.
for (int bar : fooList) {
System.out.println(bar);
//Iterates 9 times and prints 1-9 on new lines
@ -364,7 +362,6 @@ public class LearnJava {
String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Prints A, because the statement is true
////////////////////////////////////////
// Converting Data Types And Typecasting
////////////////////////////////////////
@ -387,7 +384,6 @@ public class LearnJava {
// with some more intermediate concepts. Feel free to check it out here:
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
///////////////////////////////////////
// Classes And Functions
///////////////////////////////////////
@ -409,7 +405,6 @@ public class LearnJava {
// Double Brace Initialization
// The Java Language has no syntax for how to create static Collections
// in an easy way. Usually you end up in the following way:
private static final Set<String> COUNTRIES = new HashSet<String>();
static {
validCodes.add("DENMARK");
@ -420,7 +415,6 @@ public class LearnJava {
// But there's a nifty way to achieve the same thing in an
// easier way, by using something that is called Double Brace
// Initialization.
private static final Set<String> COUNTRIES = new HashSet<String>() {{
add("DENMARK");
add("SWEDEN");
@ -436,10 +430,8 @@ public class LearnJava {
} // End main method
} // End LearnJava class
// You can include other, non-public outer-level classes in a .java file,
// but it is good practice. Instead split classes into separate files.
// but it is not good practice. Instead split classes into separate files.
// Class Declaration Syntax:
// <public/private/protected> class <class name> {
@ -454,7 +446,6 @@ class Bicycle {
private int speed; // Private: Only accessible from within the class
protected int gear; // Protected: Accessible from the class and subclasses
String name; // default: Only accessible from within this package
static String className; // Static class variable
// Static block
@ -476,7 +467,6 @@ class Bicycle {
speed = 5;
name = "Bontrager";
}
// This is a constructor that takes arguments
public Bicycle(int startCadence, int startSpeed, int startGear,
String name) {
@ -501,23 +491,18 @@ class Bicycle {
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void speedUp(int increment) {
speed += increment;
}
public void slowDown(int decrement) {
speed -= decrement;
}
public void setName(String newName) {
name = newName;
}
public String getName() {
return name;
}
@ -535,7 +520,7 @@ class PennyFarthing extends Bicycle {
// (Penny Farthings are those bicycles with the big front wheel.
// They have no gears.)
public PennyFarthing(int startCadence, int startSpeed){
public PennyFarthing(int startCadence, int startSpeed) {
// Call the parent constructor with super
super(startCadence, startSpeed, 0, "PennyFarthing");
}
@ -566,10 +551,8 @@ public interface Digestible {
public void digest();
}
// We can now create a class that implements both of these interfaces.
public class Fruit implements Edible, Digestible {
public class Fruit implements Edible, Digestible {
@Override
public void eat() {
// ...
@ -585,7 +568,6 @@ public class Fruit implements Edible, Digestible {
// interfaces. For example:
public class ExampleClass extends ExampleClassParent implements InterfaceOne,
InterfaceTwo {
@Override
public void InterfaceOneMethod() {
}
@ -604,14 +586,13 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
// // Method declarations
// }
// Marking a class as abstract means that it contains abstract methods that must
// be defined in a child class. Similar to interfaces, abstract classes cannot
// be instantiated, but instead must be extended and the abstract methods
// defined. Different from interfaces, abstract classes can contain a mixture of
// Marking a class as abstract means that it contains abstract methods that
// must be defined in a child class. Similar to interfaces, abstract classes
// cannot be instantiated, but instead must be extended and the abstract
// methods defined. Different from interfaces, abstract classes can contain a
// concrete and abstract methods. Methods in an interface cannot have a body,
// unless the method is static, and variables are final by default, unlike an
// abstract class. Also abstract classes CAN have the "main" method.
// mixture of unless the method is static, and variables are final by default,
// unlike an abstract class. Also abstract classes CAN have the "main" method.
public abstract class Animal
{
public abstract void makeSound();
@ -656,7 +637,7 @@ class Dog extends Animal
// @Override annotation here, since java doesn't allow
// overriding of static methods.
// What is happening here is called METHOD HIDING.
// Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
// Check out this SO post: http://stackoverflow.com/questions/16313649/
public static void main(String[] args)
{
Dog pluto = new Dog();
@ -695,33 +676,29 @@ public abstract class Mammal()
// Final Method Syntax:
// <access modifier> final <return type> <function name>(<args>)
// Final methods, like, final classes cannot be overridden by a child class,
// and are therefore the final implementation of the method.
// Final methods, like, final classes cannot be overridden by a child
// class, and are therefore the final implementation of the method.
public final boolean isWarmBlooded()
{
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:
// 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;
@ -734,16 +711,13 @@ public class EnumTest {
case MONDAY:
System.out.println("Mondays are bad.");
break;
case FRIDAY:
System.out.println("Fridays are better.");
break;
break;
case SATURDAY:
case SUNDAY:
System.out.println("Weekends are best.");
break;
break;
default:
System.out.println("Midweek days are so-so.");
break;
@ -793,7 +767,6 @@ The links provided here below are just to get an understanding of the topic, fee
* [Codingbat.com](http://codingbat.com/java)
**Books**:
* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
@ -802,4 +775,4 @@ The links provided here below are just to get an understanding of the topic, fee
* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)

39
julia.html.markdown
View File

@ -9,7 +9,7 @@ filename: learnjulia.jl
Julia is a new homoiconic functional language focused on technical computing.
While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
This is based on Julia 0.3.
This is based on Julia 0.4.
```ruby
@ -23,7 +23,7 @@ This is based on Julia 0.3.
## 1. Primitive Datatypes and Operators
####################################################
# Everything in Julia is a expression.
# Everything in Julia is an expression.
# There are several basic types of numbers.
3 # => 3 (Int64)
@ -151,12 +151,16 @@ a = Int64[] # => 0-element Int64 Array
# 1-dimensional array literals can be written with comma-separated values.
b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
b = [4; 5; 6] # => 3-element Int64 Array: [4, 5, 6]
b[1] # => 4
b[end] # => 6
# 2-dimentional arrays use space-separated values and semicolon-separated rows.
# 2-dimensional arrays use space-separated values and semicolon-separated rows.
matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
# Arrays of a particular Type
b = Int8[4, 5, 6] # => 3-element Int8 Array: [4, 5, 6]
# Add stuff to the end of a list with push! and append!
push!(a,1) # => [1]
push!(a,2) # => [1,2]
@ -268,8 +272,8 @@ values(filled_dict)
# Note - Same as above regarding key ordering.
# Check for existence of keys in a dictionary with in, haskey
in(("one", 1), filled_dict) # => true
in(("two", 3), filled_dict) # => false
in(("one" => 1), filled_dict) # => true
in(("two" => 3), filled_dict) # => false
haskey(filled_dict, "one") # => true
haskey(filled_dict, 1) # => false
@ -288,7 +292,7 @@ get(filled_dict,"four",4) # => 4
# Use Sets to represent collections of unordered, unique values
empty_set = Set() # => Set{Any}()
# Initialize a set with values
filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)
# Add more values to a set
push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
@ -298,7 +302,7 @@ in(2, filled_set) # => true
in(10, filled_set) # => false
# There are functions for set intersection, union, and difference.
other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
other_set = Set([3, 4, 5, 6]) # => Set{Int64}(6,4,5,3)
intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
@ -416,14 +420,12 @@ varargs(1,2,3) # => (1,2,3)
# The ... is called a splat.
# We just used it in a function definition.
# It can also be used in a fuction call,
# It can also be used in a function call,
# where it will splat an Array or Tuple's contents into the argument list.
Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)
add([5,6]...) # this is equivalent to add(5,6)
x = (1,2,3) # => (1,2,3)
Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples
Set(x...) # => Set{Int64}(2,3,1)
x = (5,6) # => (5,6)
add(x...) # this is equivalent to add(5,6)
# You can define functions with optional positional arguments
@ -545,12 +547,8 @@ abstract Cat # just a name and point in the type hierarchy
# Abstract types cannot be instantiated, but can have subtypes.
# For example, Number is an abstract type
subtypes(Number) # => 6-element Array{Any,1}:
# Complex{Float16}
# Complex{Float32}
# Complex{Float64}
subtypes(Number) # => 2-element Array{Any,1}:
# Complex{T<:Real}
# ImaginaryUnit
# Real
subtypes(Cat) # => 0-element Array{Any,1}
@ -568,10 +566,11 @@ subtypes(AbstractString) # 8-element Array{Any,1}:
# Every type has a super type; use the `super` function to get it.
typeof(5) # => Int64
super(Int64) # => Signed
super(Signed) # => Real
super(Signed) # => Integer
super(Integer) # => Real
super(Real) # => Number
super(Number) # => Any
super(super(Signed)) # => Number
super(super(Signed)) # => Real
super(Any) # => Any
# All of these type, except for Int64, are abstract.
typeof("fire") # => ASCIIString

2
ko-kr/brainfuck-kr.html.markdown → ko-kr/bf-kr.html.markdown
View File

@ -1,5 +1,5 @@
---
language: brainfuck
language: bf
contributors:
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
- ["Mathias Bynens", "http://mathiasbynens.be/"]

333
ko-kr/erlang-kr.html.markdown Normal file
View File

@ -0,0 +1,333 @@
---
language: erlang
contributors:
- ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
filename: learnerlang-kr.erl
translators:
- ["Taesung Jung", "https://github.com/tsj"]
lang: ko-kr
---
```erlang
% 퍼센트 기호는 한 줄 주석을 시작한다.
%% 두 개의 퍼센트 문자는 함수의 주석에 사용된다.
%%% 세 개의 퍼센트 문자는 모듈의 주석에 사용된다.
% Erlang에선 3가지 유형의 문장 부호를 사용한다.
% 쉼표(`,`)는 함수 호출에서 인수, 데이터 생성자(constructors), 패턴을 구분한다.
% 마침표(`.`)(다음에 오는 공백)는 셸에서 함수 전체와 식을 구분한다.
% 세미콜론(`;`)은 절을 구분한다. 몇 가지 문맥(contexts)에서 절이 발견된다:
% 함수 정의와 `case`, `if`, `try..catch`, 그리고 `receive` 식
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 1. 변수와 패턴 매칭
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Erlang에서 새로운 변수는 `=` 문장에 의해 바인딩 된다.
Num = 42. % 모든 변수 이름은 반드시 대문자로 시작해야 한다.
% Erlang은 단일 할당 변수(single-assignment variables)를 가진다;
% 만약 다른 값을 `Num` 변수에 할당하려고 시도하면 오류가 발생한다.
Num = 43. % ** 예외 오류: 우변의 값 43과 매칭되지 않음
% 대부분 언어에서 `=`는 할당문을 나타낸다. 그러나 Erlang에서
% `=`는 패턴 매칭 연산자를 나타낸다. 비어 있는 변수가 `=` 연산자의 좌변에
% 사용되면 바인드(할당) 된다, 그러나 바인드 변수가 좌변에 사용된 경우에
% 다음 행동은 그 바인드 변수가 관측된다.
% `Lhs = Rhs`의 진짜 의미: 우변(`Rhs`)을 평가하고, 그리고
% 그 결과를 좌변(`Lhs`)의 패턴과 매치시켜라.
Num = 7 * 6.
% 부동 소수점 수.
Pi = 3.14159.
% Atom은 숫자가 아닌 서로 다른 상숫값을 표현하는 데 사용한다. Atom은
% 소문자로 시작하고, 연속적인 영숫자(alphanumeric) 문자나 밑줄(`_`) 또는
% 골뱅이(`@`) 기호가 따라온다.
Hello = hello.
OtherNode = example@node.
% 영숫자 값이 아닌 Atom은 작은따옴표로 묶여서 작성될 수 있다.
AtomWithSpace = 'some atom with space'.
% Tuple은 C의 struct와 비슷하다.
Point = {point, 10, 45}.
% Tuple에서 어떤 값을 추출하려면, 패턴 매칭 연산자 `=`를 사용한다.
{point, X, Y} = Point. % X = 10, Y = 45
% 관심 없는 변수를 위해 자리 표시자(placeholder) `_`를 사용할 수 있다.
% 기호 `_`는 익명 변수(anonymous variable)라 부른다. 일반적인 변수들과
% 다르게 같은 패턴에서 여러 번 나오더라도 동일한 값으로 바인드되지 않아도 된다.
Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
{_, {_, {_, Who}, _}, _} = Person. % Who = joe
% List를 만들기 위해서 List의 원소는 대괄호([])로 둘러싸고 쉼표(,)로 구분한다.
% List의 각각의 원소는 어떤 타입도 가능하다.
% List의 첫 번째 원소는 List의 HEAD이다. 만약 List의 HEAD를 제거하면,
% 남은 부분은 List의 TAIL이라 부른다.
ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
% 만약 `T`가 List이면, `[H|T]`도 HEAD가 `H`이고 TAIL이 `T`인 List이다.
% 세로 막대(`|`)는 List의 HEAD와 TAIL을 분리한다. `[]`는 빈 List다.
% List의 원소들은 패턴 매칭 연산으로 추출할 수 있다.
% 만약 비어있지 않은 List `L`이 있을 때, `[X|Y] = L` 식의 `X`와 `Y`가
% 바인드되지 않은 변수이면, List의 HEAD는 X에 그리고 TAIL은 Y로 추출된다.
[FirstThing|OtherThingsToBuy] = ThingsToBuy.
% FirstThing = {apples, 10}
% OtherThingsToBuy = [{pears, 6}, {milk, 3}]
% Erlang에는 문자열(String)이 없다. 문자열은 사실 정수의 List일 뿐이다.
% 문자열은 큰따옴표(`"`)로 묶인다.
Name = "Hello".
[72, 101, 108, 108, 111] = "Hello".
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 2. 순차 프로그래밍
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Erlang에서 Module은 코드의 기본 단위이다. 우리가 작성한 모든 함수는
% Module에 담긴다. Module은 확장자가 `.erl`인 파일에 저장된다.
% 코드가 실행되기 전에 Module은 컴파일되어야 한다. 컴파일된 Module은
% `.beam` 확장자를 가진다.
-module(geometry).
-export([area/1]). % Module로부터 내보내진(exported) 함수의 List
% 함수 `area`는 두 개의 절로 구성된다. 절은 세미콜론(`;`)으로 구분되며,
% 마지막 절은 마침표-공백(dot-whitespace)으로 끝난다.
% 각 절은 서문(head)과 본문(body)을 가진다. 서문은 함수의 이름에 이어서
% 패턴이(괄호 속에) 따라온다. 본문은 연속적인 식으로 구성되고,
% 연속적인 식은 서문의 패턴과 호출한 인수가 성공적으로 매치되면 평가된다.
% 패턴은 함수 정의가 나타나는 순서대로 매치된다.
area({rectangle, Width, Ht}) -> Width * Ht;
area({circle, R}) -> 3.14159 * R * R.
% geometry.erl 파일의 코드 컴파일
c(geometry). % {ok,geometry}
% 호출하려는 함수를 정확히 알아내기 위해 함수 이름을 Module 이름과 함께
% 명시하는 것이 필요하다.
geometry:area({rectangle, 10, 5}). % 50
geometry:area({circle, 1.4}). % 6.15752
% Erlang에서, 같은 Module에 이름이 같고 Arity(인수의 갯수)가 다른
% 두 함수는 전혀 다른 함수를 나타낸다.
-module(lib_misc).
-export([sum/1]). % Arity가 1인 내보내진(export) 함수 `sum`
% 하나의 인수만 받음: 정수의 List
sum(L) -> sum(L, 0).
sum([], N) -> N;
sum([H|T], N) -> sum(T, H+N).
% Fun은 "익명(anonymous)" 함수다. 이름이 없어서 이렇게 부른다.
% 그러나, 변수에 할당될 수 있다.
Double = fun(X) -> 2 * X end. % `Double`은 익명 함수를 가리킨다:
% #Fun<erl_eval.6.17052888>
Double(2). % 4
% 함수는 인수로 Fun을 받거나, Fun을 반환할 수 있다.
Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.
Triple = Mult(3).
Triple(5). % 15
% List 해석(List comprehensions)은 Fun, Map, Filter 없이 List를 만드는 식이다.
% 표기법 `[F(X) || X <- L]`은 `F(X)`의 List라는 의미이다.
% 이때 `X`는 List `L`로부터 가져온다.
L = [1,2,3,4,5].
[2 * X || X <- L]. % [2,4,6,8,10]
% List 해석은 Generator와 생성된 값들의 부분 집합을 선택하는 Filter를 가질 수 있다.
EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
% Guard는 패턴 매칭의 능력을 향상시키는데 사용할 수 있는 구조다.
% Guard를 사용하면, 패턴에 있는 변수에 대해 간단한 검사와 비교를 수행할 수 있다.
% 함수 정의의 서문(head)에 `when` 키워드로 시작되는 Guard를 사용할 수도 있고,
% 또는 식이 허용되는 언어의 어떤 곳에도 사용될 수 있다.
max(X, Y) when X > Y -> X;
max(X, Y) -> Y.
% Guard는 쉼표(`,`)로 구분된 연속된 Guard 식이다.
% 모든 Guard 식 `GuardExpr1`, `GuardExpr2`, ..., `GuardExprN`이
% `true`로 평가된다면, Guard `GuardExpr1`, `GuardExpr2`, ..., `GuardExprN`는
% 참이다.
is_cat(A) when is_atom(A), A =:= cat -> true;
is_cat(A) -> false.
is_dog(A) when is_atom(A), A =:= dog -> true;
is_dog(A) -> false.
% `=:=` 연산자는 여기서 자세히 다루지 않을 것이다; 두 개의 Erlang 식의 값이 같고
% *그리고* 같은 타입인지 검사하는 데 사용된다고만 알면 된다.
% `==` 연산자의 작동과 대조할 것:
1 + 2 =:= 3. % true
1 + 2 =:= 3.0. % false
1 + 2 == 3.0. % true
% 연속적인 Guard는 단일 Guard 또는 세미콜론(`;`)으로 구분된 연속된 Guard다.
% Guard `G1; G2; ...; Gn` 중에 적어도 하나의 Guard가 `true`로 평가된다면,
% 연속적인 Guard `G1; G2; ...; Gn`는 참이다.
is_pet(A) when is_atom(A), (A =:= dog);(A =:= cat) -> true;
is_pet(A) -> false.
% 주의: 모든 유효한 Erlang 식이 Guard 식으로 사용될 수 있는 것은 아니다;
% 특히, 함수 `is_cat`과 `is_dog`는 `is_pet`의 정의 안에 있는
% 연속적인 Guard 사이에 사용될 수 없다.
% 연속적인 Guard에 허용되는 식의 자세한 설명은 Erlang 레퍼런스 메뉴얼
% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912)
% 을 참조하라.
% Record는 Tuple 안에 이름과 특정 요소를 연결하는 방법을 제공한다.
% Record 정의는 Erlang 소스 코드 파일에 포함되거나 Erlang 소스 코드 파일에
% 포함될 수 있는 확장자가 `.hrl`인 파일에 집어넣을 수 있다.
-record(todo, {
status = reminder, % 기본 값
who = joe,
text
}).
% Record를 사용할 수 있기 전에 Record 정의를 반드시 셸로 읽어 들여야 한다.
% 셸로 읽어 들이기 위해 셸 함수 `rr`(read records의 약자)을 사용한다.
rr("records.hrl"). % [todo]
% Record 생성과 수정
X = #todo{}.
% #todo{status = reminder, who = joe, text = undefined}
X1 = #todo{status = urgent, text = "Fix errata in book"}.
% #todo{status = urgent, who = joe, text = "Fix errata in book"}
X2 = X1#todo{status = done}.
% #todo{status = done, who = joe, text = "Fix errata in book"}
% `case` 식
% `filter`는 List `L`의 원소 `X` 중에서 `P(X)`가 참인 모든 `X`의 List를 반환한다.
filter(P, [H|T]) ->
case P(H) of
true -> [H|filter(P, T)];
false -> filter(P, T)
end;
filter(P, []) -> [].
filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]
% `if` 식.
max(X, Y) ->
if
X > Y -> X;
X < Y -> Y;
true -> nil
end.
% 주의: 적어도 if 식의 Guard 중의 하나는 반드시 `true`로 평가되어야 한다.
% 그렇지 않으면 예외가 발생한다.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 3. 예외
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 예외는 내부에 에러가 생겼거나 명시적으로 `throw(Exception)`,
% `exit(Exception)` 또는 `erlang:error(Exception)`를 호출하면
% 시스템에 의해 발생한다.
generate_exception(1) -> a;
generate_exception(2) -> throw(a);
generate_exception(3) -> exit(a);
generate_exception(4) -> {'EXIT', a};
generate_exception(5) -> erlang:error(a).
% Erlang은 예외를 잡는 두 가지 방법을 가지고 있다. 한 가지는
% 예외를 발생시키는 함수의 호출 부분을 `try...catch` 식으로 감싸는 것이다.
catcher(N) ->
try generate_exception(N) of
Val -> {N, normal, Val}
catch
throw:X -> {N, caught, thrown, X};
exit:X -> {N, caught, exited, X};
error:X -> {N, caught, error, X}
end.
% 다른 방법은 그 호출 부분을 `catch` 식으로 감싸는 것이다.
% 예외를 잡았을 때, 그 예외는 오류를 설명하는 Tuple로 변환된다.
catcher(N) -> catch generate_exception(N).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 4. 병행성
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Erlang은 병행성을 위해 Actor 모델을 사용한다. Erlang에서 병행 프로그램을
% 작성하는 데 필요한 모든 것은 3가지 기본 형식(primitivies)이다:
% 프로세스 생성, 메시지 보내기, 메시지 받기
% 새로운 프로세스를 시작하기 위해, 함수를 인수로 받는 `spawn` 함수를 사용한다.
F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768>
spawn(F). % <0.44.0>
% `spawn`은 pid(프로세스 식별자)를 반환한다. 이 pid를 프로세스로
% 메시지를 보내는 데 사용할 수 있다. 메시지 전달을 위해, `!` 연산자를 사용한다.
% 위의 기능이 유용하려면, 메시지를 받을 수 있어야 한다. 메시지를 받는 것은
% `receive` 메커니즘을 사용한다.
-module(calculateGeometry).
-compile(export_all).
calculateArea() ->
receive
{rectangle, W, H} ->
W * H;
{circle, R} ->
3.14 * R * R;
_ ->
io:format("We can only calculate area of rectangles or circles.")
end.
% Module을 컴파일하고 셸에서 `calculateArea`를 평가한 프로세스를 생성한다.
c(calculateGeometry).
CalculateArea = spawn(calculateGeometry, calculateArea, []).
CalculateArea ! {circle, 2}. % 12.56000000000000049738
% 셸도 마찬가지로 프로세스이다. 현재 pid를 얻기 위해서 `self`를 사용할 수 있다.
self(). % <0.41.0>
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 5. EUnit과 테스트
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% EUnit의 테스트 생성기(generators)와 assert 매크로를 이용해
% 단위 테스트를 작성할 수 있다.
-module(fib).
-export([fib/1]).
-include_lib("eunit/include/eunit.hrl").
fib(0) -> 1;
fib(1) -> 1;
fib(N) when N > 1 -> fib(N-1) + fib(N-2).
fib_test_() ->
[?_assert(fib(0) =:= 1),
?_assert(fib(1) =:= 1),
?_assert(fib(2) =:= 2),
?_assert(fib(3) =:= 3),
?_assert(fib(4) =:= 5),
?_assert(fib(5) =:= 8),
?_assertException(error, function_clause, fib(-1)),
?_assert(fib(31) =:= 2178309)
].
% EUnit은 Erlang 셸에서 테스트를 실행할 수 있게
% 자동으로 test() 함수를 내보낸다(export).
fib:test()
% Erlang의 유명한 빌드 툴인 Rebar는 EUnit과 호환된다.
% ```
% rebar eunit
% ```
```
## 참조
* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang)
* [조 암스트롱, 김석준 역, "프로그래밍 얼랭: Software for a Concurrent World", 인사이트](http://ebook.insightbook.co.kr/book/23)
* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/)
* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)

2
ko-kr/lua-kr.html.markdown
View File

@ -418,5 +418,5 @@ lua-users.org에 있는 <a href="http://lua-users.org/files/wiki_insecure/users/
learn.lua로 저장한 후 "lua learn.lua"를 실행해 보세요!
이 글은 tylerneylon.com에 처음으로 써본 글이며,
<a href="https://gist.github.com/tylerneylon/5853042">Github의 Gist</a>에서도 확인할 수 있습니다.
<a href="https://gist.github.com/tylerneylon/5853042">GitHub의 Gist</a>에서도 확인할 수 있습니다.
루아로 즐거운 시간을 보내세요!

322
kotlin.html.markdown Normal file
View File

@ -0,0 +1,322 @@
---
language: kotlin
contributors:
- ["S Webber", "https://github.com/s-webber"]
filename: LearnKotlin.kt
---
Kotlin is a Statically typed programming language for the JVM, Android and the
browser. It is 100% interoperable with Java.
[Read more here.](https://kotlinlang.org/)
```java
// Single-line comments start with //
/*
Multi-line comments look like this.
*/
// The "package" keyword works in the same way as in Java.
package com.learnxinyminutes.kotlin
/*
The entry point to a Kotlin program is a function named "main".
The function is passed an array containing any command line arguments.
*/
fun main(args: Array<String>) {
/*
Declaring values is done using either "var" or "val".
"val" declarations cannot be reassigned, whereas "vars" can.
*/
val fooVal = 10 // we cannot later reassign fooVal to something else
var fooVar = 10
fooVar = 20 // fooVar can be reassigned
/*
In most cases, Kotlin can determine what the type of a variable is,
so we don't have to explicitly specify it every time.
We can explicitly declare the type of a variable like so:
*/
val foo : Int = 7
/*
Strings can be represented in a similar way as in Java.
Escaping is done with a backslash.
*/
val fooString = "My String Is Here!";
val barString = "Printing on a new line?\nNo Problem!";
val bazString = "Do you want to add a tab?\tNo Problem!";
println(fooString);
println(barString);
println(bazString);
/*
A raw string is delimited by a triple quote (""").
Raw strings can contain newlines and any other characters.
*/
val fooRawString = """
fun helloWorld(val name : String) {
println("Hello, world!")
}
"""
println(fooRawString)
/*
Strings can contain template expressions.
A template expression starts with a dollar sign ($).
*/
val fooTemplateString = "$fooString has ${fooString.length} characters"
println(fooTemplateString)
/*
For a variable to hold null it must be explicitly specified as nullable.
A variable can be specified as nullable by appending a ? to its type.
We can access a nullable variable by using the ?. operator.
We can use the ?: operator to specify an alternative value to use
if a variable is null
*/
var fooNullable: String? = "abc"
println(fooNullable?.length) // => 3
println(fooNullable?.length ?: -1) // => 3
fooNullable = null
println(fooNullable?.length) // => null
println(fooNullable?.length ?: -1) // => -1
/*
Functions can be declared using the "fun" keyword.
Function arguments are specified in brackets after the function name.
Function arguments can optionally have a default value.
The function return type, if required, is specified after the arguments.
*/
fun hello(name: String = "world") : String {
return "Hello, $name!"
}
println(hello("foo")) // => Hello, foo!
println(hello(name = "bar")) // => Hello, bar!
println(hello()) // => Hello, world!
/*
A function parameter may be marked with the "vararg" keyword
to allow a variable number of arguments to be passed to the function.
*/
fun varargExample(vararg names: Int) {
println("Argument has ${names.size} elements")
}
varargExample() // => Argument has 0 elements
varargExample(1) // => Argument has 1 elements
varargExample(1, 2, 3) // => Argument has 3 elements
/*
When a function consists of a single expression then the curly brackets can
be omitted. The body is specified after a = symbol.
*/
fun odd(x: Int): Boolean = x % 2 == 1
println(odd(6)) // => false
println(odd(7)) // => true
// If the return type can be inferred then we don't need to specify it.
fun even(x: Int) = x % 2 == 0
println(even(6)) // => true
println(even(7)) // => false
// Functions can take functions as arguments and return functions.
fun not(f: (Int) -> Boolean) : (Int) -> Boolean {
return {n -> !f.invoke(n)}
}
// Named functions can be specified as arguments using the :: operator.
val notOdd = not(::odd)
val notEven = not(::even)
// Anonymous functions can be specified as arguments.
val notZero = not {n -> n == 0}
/*
If an anonymous function has only one parameter
then its declaration can be omitted (along with the ->).
The name of the single parameter will be "it".
*/
val notPositive = not {it > 0}
for (i in 0..4) {
println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
}
//The "class" keyword is used to declare classes.
class ExampleClass(val x: Int) {
fun memberFunction(y: Int) : Int {
return x + y
}
infix fun infixMemberFunction(y: Int) : Int {
return x * y
}
}
/*
To create a new instance we call the constructor.
Note that Kotlin does not have a "new" keyword.
*/
val fooExampleClass = ExampleClass(7)
// Member functions can be called using dot notation.
println(fooExampleClass.memberFunction(4)) // => 11
/*
If a function has been marked with the "infix" keyword then it can be
called using infix notation.
*/
println(fooExampleClass infixMemberFunction 4) // => 28
/*
Data classes are a concise way to create classes that just hold data.
The "hashCode"/"equals" and "toString" methods are automatically generated.
*/
data class DataClassExample (val x: Int, val y: Int, val z: Int)
val fooData = DataClassExample(1, 2, 4)
println(fooData) // => DataClassExample(x=1, y=2, z=4)
// Data classes have a "copy" function.
val fooCopy = fooData.copy(y = 100)
println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
// Objects can be destructured into multiple variables.
val (a, b, c) = fooCopy
println("$a $b $c") // => 1 100 4
// The "with" function is similar to the JavaScript "with" statement.
data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
val fooMutableDate = MutableDataClassExample(7, 4, 9)
with (fooMutableDate) {
x -= 2
y += 2
z--
}
println(fooMutableDate) // => MutableDataClassExample(x=5, y=6, z=8)
/*
We can create a list using the "listOf" function.
The list will be immutable - elements cannot be added or removed.
*/
val fooList = listOf("a", "b", "c")
println(fooList.size) // => 3
println(fooList.first()) // => a
println(fooList.last()) // => c
// elements can be accessed by index
println(fooList[1]) // => b
// A mutable list can be created using the "mutableListOf" function.
val fooMutableList = mutableListOf("a", "b", "c")
fooMutableList.add("d")
println(fooMutableList.last()) // => d
println(fooMutableList.size) // => 4
// We can create a set using the "setOf" function.
val fooSet = setOf("a", "b", "c")
println(fooSet.contains("a")) // => true
println(fooSet.contains("z")) // => false
// We can create a map using the "mapOf" function.
val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
// Map values can be accessed by their key.
println(fooMap["a"]) // => 8
// Kotlin provides higher-order functions for working with collections.
val x = (1..9).map {it * 3}
.filter {it < 20}
.groupBy {it % 2 == 0}
.mapKeys {if (it.key) "even" else "odd"}
println(x) // => {odd=[3, 9, 15], even=[6, 12, 18]}
// A "for" loop can be used with anything that provides an iterator.
for (c in "hello") {
println(c)
}
// "while" loops work in the same way as other languages.
var ctr = 0
while (ctr < 5) {
println(ctr)
ctr++
}
do {
println(ctr)
ctr++
} while (ctr < 10)
// "when" can be used as an alternative to "if-else if" chains.
val i = 10
when {
i < 7 -> println("first block")
fooString.startsWith("hello") -> println("second block")
else -> println("else block")
}
// "when" can be used with an argument.
when (i) {
0, 21 -> println("0 or 21")
in 1..20 -> println("in the range 1 to 20")
else -> println("none of the above")
}
// "when" can be used as a function that returns a value.
var result = when (i) {
0, 21 -> "0 or 21"
in 1..20 -> "in the range 1 to 20"
else -> "none of the above"
}
println(result)
/*
We can check if an object is a particular type by using the "is" operator.
If an object passes a type check then it can be used as that type without
explicitly casting it.
*/
fun smartCastExample(x: Any) : Boolean {
if (x is Boolean) {
// x is automatically cast to Boolean
return x
} else if (x is Int) {
// x is automatically cast to Int
return x > 0
} else if (x is String) {
// x is automatically cast to String
return x.isNotEmpty()
} else {
return false
}
}
println(smartCastExample("Hello, world!")) // => true
println(smartCastExample("")) // => false
println(smartCastExample(5)) // => true
println(smartCastExample(0)) // => false
println(smartCastExample(true)) // => true
/*
Extensions are a way to add new functionality to a class.
This is similar to C# extension methods.
*/
fun String.remove(c: Char): String {
return this.filter {it != c}
}
println("Hello, world!".remove('l')) // => Heo, word!
println(EnumExample.A) // => A
println(ObjectExample.hello()) // => hello
}
// Enum classes are similar to Java enum types.
enum class EnumExample {
A, B, C
}
/*
The "object" keyword can be used to create singleton objects.
We cannot assign it to a variable, but we can refer to it by its name.
This is similar to Scala singleton objects.
*/
object ObjectExample {
fun hello() : String {
return "hello"
}
}
```
### Further Reading
* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/)
* [Try Kotlin in your browser](http://try.kotlinlang.org/)
* [A list of Kotlin resources](http://kotlin.link/)

6
latex.html.markdown
View File

@ -178,7 +178,7 @@ We can also insert Tables in the same way as figures.
% the {} arguments below describe how each row of the table is drawn.
% Again, I have to look these up. Each. And. Every. Time.
\begin{tabular}{c|cc}
Number & Last Name & First Name \\ % Column rows are separated by $
Number & Last Name & First Name \\ % Column rows are separated by &
\hline % a horizontal line
1 & Biggus & Dickus \\
2 & Monty & Python
@ -205,14 +205,14 @@ environment.
By now you're probably wondering how to compile this fabulous document
and look at the glorious glory that is a LaTeX pdf.
(yes, this document actually does compiles). \\
(yes, this document actually does compile). \\
Getting to the final document using LaTeX consists of the following steps:
\begin{enumerate}
\item Write the document in plain text (the "source code").
\item Compile source code to produce a pdf.
The compilation step looks something like this (in Linux): \\
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
> pdflatex learn-latex.tex learn-latex.pdf
\end{verbatim}
\end{enumerate}

4
less.html.markdown
View File

@ -8,7 +8,7 @@ contributors:
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
```css
//Single line comments are removed when Less is compiled to CSS.
@ -89,7 +89,7 @@ div {
background-color: #A3A4FF;
}
/* You can omit the mixin code from being compiled by adding paranthesis
/* You can omit the mixin code from being compiled by adding parenthesis
after the selector */
.center() {

2
lt-lt/json-lt.html.markdown
View File

@ -1,6 +1,6 @@
---
language: json
filename: learnjson.json
filename: learnjson-lt.json
lang: lt-lt
contributors:
- ["Zygimantus", "https://github.com/zygimantus"]

23
make.html.markdown
View File

@ -9,16 +9,16 @@ A Makefile defines a graph of rules for creating a target (or targets).
Its purpose is to do the minimum amount of work needed to update a
target to the most recent version of the source. Famously written over a
weekend by Stuart Feldman in 1976, it is still widely used (particularly
on Unix) despite many competitors and criticisms.
on Unix and Linux) despite many competitors and criticisms.
There are many varieties of make in existance, this article assumes that
we are using GNU make which is the standard on Linux.
There are many varieties of make in existence, however this article
assumes that we are using GNU make which is the standard on Linux.
```make
# Comments can be written like this.
# Files should be named Makefile and then be can run as `make <target>`.
# File should be named Makefile and then can be run as `make <target>`.
# Otherwise we use `make -f "filename" <target>`.
# Warning - only use TABS to indent in Makefiles, never spaces!
@ -27,13 +27,16 @@ we are using GNU make which is the standard on Linux.
# Basics
#-----------------------------------------------------------------------
# Rules are of the format
# target: <prerequisite>
# where prerequisites are optional.
# A rule - this rule will only run if file0.txt doesn't exist.
file0.txt:
echo "foo" > file0.txt
# Even comments in these 'recipe' sections get passed to the shell.
# Try `make file0.txt` or simply `make` - first rule is the default.
# This rule will only run if file0.txt is newer than file1.txt.
file1.txt: file0.txt
cat file0.txt > file1.txt
@ -99,8 +102,8 @@ process: ex1.txt file0.txt
%.png: %.svg
inkscape --export-png $^
# Pattern rules will only do anything if make decides to create the \
target.
# Pattern rules will only do anything if make decides to create the
# target.
# Directory paths are normally ignored when matching pattern rules. But
# make will try to use the most appropriate rule available.
@ -145,11 +148,11 @@ echo:
# In order of priority from highest to lowest:
# 1: commandline arguments
# 2: Makefile
# 3: shell enviroment variables - make imports these automatically.
# 3: shell environment variables - make imports these automatically.
# 4: make has some predefined variables
name4 ?= Jean
# Only set the variable if enviroment variable is not already defined.
# Only set the variable if environment variable is not already defined.
override name5 = David
# Stops commandline arguments from changing this variable.
@ -185,7 +188,7 @@ var := hello
var2 ::= $(var) hello
#:= and ::= are equivalent.
# These variables are evaluated procedurely (in the order that they
# These variables are evaluated procedurally (in the order that they
# appear), thus breaking with the rest of the language !
# This doesn't work

80
markdown.html.markdown
View File

@ -7,7 +7,9 @@ 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).
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
@ -26,10 +28,12 @@ specific to a certain parser.
## 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.-->
<!--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
@ -54,6 +58,7 @@ This is an h1
This is an h2
-------------
```
## Simple text styles
Text can be easily styled as italic or bold using markdown.
@ -70,8 +75,8 @@ __And so is this text.__
*__And this!__*
```
In Github Flavored Markdown, which is used to render markdown files on
Github, we also have strikethrough:
In GitHub Flavored Markdown, which is used to render markdown files on
GitHub, we also have strikethrough:
```markdown
~~This text is rendered with strikethrough.~~
@ -133,6 +138,7 @@ or
- Item
- One last item
```
Ordered lists are done with a number followed by a period.
```markdown
@ -152,6 +158,7 @@ render the numbers in order, but this may not be a good idea.
(This renders the same as the above example)
You can also use sublists
```markdown
1. Item one
2. Item two
@ -196,22 +203,23 @@ Inline code can be created using the backtick character `
John didn't even know what the `go_to()` function did!
```
In Github Flavored Markdown, you can use a special syntax for code
```markdown
\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
In GitHub Flavored Markdown, you can use a special syntax for code
<pre>
<code class="highlight">&#x60;&#x60;&#x60;ruby
def foobar
puts "Hello world!"
end
\`\`\` <!-- here too, no backslashes, just ``` -->
```
&#x60;&#x60;&#x60;</code></pre>
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 \`\`\`
## Horizontal rule
Horizontal rules (`<hr/>`) 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
***
---
@ -228,58 +236,64 @@ the text to display in hard brackets [] followed by the url in parentheses ()
[Click me!](http://test.com/)
```
You can also add a link title using quotes inside the parentheses.
```markdown
[Click me!](http://test.com/ "Link to Test.com")
```
Relative paths work too.
```markdown
[Go to music](/music/).
```
Markdown also supports reference style links.
```markdown
[Click this link][link1] for more info about it!
[Also check out this link][foobar] if you want to.
[link1]: http://test.com/ "Cool!"
[foobar]: http://foobar.biz/ "Alright!"
```
Markdown also supports reference style links.
<pre><code class="highlight">&#x5b;<span class="nv">Click this link</span>][<span class="ss">link1</span>] for more info about it!
&#x5b;<span class="nv">Also check out this link</span>][<span class="ss">foobar</span>] if you want to.
&#x5b;<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Cool!"</span>
&#x5b;<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Alright!"</span></code></pre>
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
can be anything so long as they are unique.
There is also "implicit naming" which lets you use the link text as the id.
```markdown
[This][] is a link.
[this]: http://thisisalink.com/
```
<pre><code class="highlight">&#x5b;<span class="nv">This</span>][] is a link.
&#x5b;<span class="nv">this</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
But it's not that commonly used.
## Images
Images are done the same way as links but with an exclamation point in front!
```markdown
![This is the alt-attribute for my image](http://imgur.com/myimage.jpg "An optional title")
```
And reference style works as expected.
```markdown
![This is the alt-attribute.][myimage]
[myimage]: relative/urls/cool/image.jpg "if you need a title, it's here"
```
<pre><code class="highlight">!&#x5b;<span class="nv">This is the alt-attribute.</span>][<span class="ss">myimage</span>]
&#x5b;<span class="nv">myimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"if you need a title, it's here"</span></code></pre>
## Miscellany
### Auto-links
```markdown
<http://testwebsite.com/> is equivalent to
[http://testwebsite.com/](http://testwebsite.com/)
```
### Auto-links for emails
```markdown
<foo@bar.com>
```
### Escaping characters
```markdown
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\*.
@ -287,15 +301,18 @@ in italics, so I do this: \*this text surrounded by asterisks\*.
### 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
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
```
### 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:
```markdown
| Col1 | Col2 | Col3 |
| :----------- | :------: | ------------: |
@ -309,5 +326,6 @@ Col 1 | Col2 | Col3
:-- | :-: | --:
Ugh this is so ugly | make it | stop
```
---
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).

284
ms-my/bash-my.html.markdown Normal file
View File

@ -0,0 +1,284 @@
---
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"]
filename: LearnBash-ms.sh
translators:
- ["hack1m", "https://github.com/hack1m"]
lang: ms-my
---
Bash adalah nama daripada unix shell, yang mana telah diagihkan sebagai shell untuk sistem operasi GNU dan sebagai shell lalai pada Linux dan Mac OS X. Hampir semua contoh di bawah boleh menjadi sebahagian daripada skrip shell atau dijalankan terus dalam shell.
[Baca lebih lanjut di sini.](http://www.gnu.org/software/bash/manual/bashref.html)
```bash
#!/bin/bash
# Baris pertama daripada skrip ialah shebang yang mana memberitahu sistem bagaimana untuk melaksana
# skrip: http://en.wikipedia.org/wiki/Shebang_(Unix)
# Seperti yang anda sudah gambarkan, komen bermula dengan #. Shebang juga ialah komen.
# Contoh mudah hello world:
echo Hello world!
# Setiap arahan bermula pada baris baru, atau selepas semikolon:
echo 'This is the first line'; echo 'This is the second line'
# Mengisytihar pembolehubah kelihatan seperti ini:
Variable="Some string"
# Tetapi bukan seperti ini:
Variable = "Some string"
# Bash akan memutuskan yang pembolehubah adalah arahan ia mesti laksanakan dan memberi ralat
# kerana ia tidak boleh dijumpai.
# Atau seperti ini:
Variable= 'Some string'
# Bash akan memutuskan yang ‘Beberapa rentetan’ adalah arahan ia mesti laksanakan dan memberi
# ralat kerana ia tidak dijumpai. (Dalam kes ini ‘Variable=' sebahagian dilihat
# sebagai penetapan pembolehubah sah hanya untuk skop ‘Beberapa rentetan’
# arahan.)
# Menggunakan pembolehubah:
echo $Variable
echo "$Variable"
echo '$Variable'
# Apabila anda guna pembolehubah itu sendiri - menetapkan, mengeksport, atau lain-lain - anda menulis
# nama ia tanpa $. Atau anda ingin menggunakan nilai pembolehubah, anda mesti guna $.
# Perlu diingatkan ‘(Petikan tunggal) tidak akan memperluaskan pembolehubah!
# Penggantian rentetan dalam pembolehubah
echo ${Variable/Some/A}
# Ini akan menukarkan sebutan pertama bagi "Some" dengan "A"
# Subrentetan daripada pembolehubah
Length=7
echo ${Variable:0:Length}
# Ini akan kembalikan hanya 7 aksara pertama pada nilai
# Nilai lalai untuk pembolehubah
echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
# Ini berfungsi untuk null (Foo=) dan rentetan kosong (Foo=“”); sifar (Foo=0) kembali 0.
# Perlu diingatkan ia hanya kembalikan nilai lalai dan tidak mengubah nilai pembolehubah.
# Pembolehubah terbina:
# Terdapat beberapa pembolehubah terbina berguna, seperti
echo "Last program's return value: $?"
echo "Script's PID: $$"
echo "Number of arguments passed to script: $#"
echo "All arguments passed to script: $@"
echo "Script's arguments separated into different variables: $1 $2..."
# Membaca nilai dari input:
echo "What's your name?"
read Name # Perlu diingatkan kita tidak perlu isytihar pembolehubah baru
echo Hello, $Name!
# Kita ada yang biasa jika struktur:
# guna 'man test' untuk maklumat lanjut tentang bersyarat
if [ $Name -ne $USER ]
then
echo "Your name isn't your username"
else
echo "Your name is your username"
fi
# Terdapat juga pelaksanaan bersyarat
echo "Always executed" || echo "Only executed if first command fails"
echo "Always executed" && echo "Only executed if first command does NOT fail"
# Untuk guna && dan || bersama kenyataan ‘if’, anda perlu beberapa pasang daripada tanda kurung siku:
if [ $Name == "Steve" ] && [ $Age -eq 15 ]
then
echo "This will run if $Name is Steve AND $Age is 15."
fi
if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
then
echo "This will run if $Name is Daniya OR Zach."
fi
# Eskspresi ia ditandai dengan format berikut:
echo $(( 10 + 5 ))
# Tidak seperti bahasa pengaturcaraan lain, bash adalah shell jadi ia berfungsi dalam konteks
# daripada direktori semasa. Anda boleh menyenaraikan fail dan direktori dalam direktori
# semasa dengan arahan ini:
ls
# Arahan ini mempunyai opsyen yang mengawal perlaksanaannya:
ls -l # Senarai setiap fail dan direktori pada baris yang berbeza
# Keputusan arahan sebelum boleh diberikan kepada arahan selepas sebagai input.
# arahan grep menapis input dengan memberi paten. Ini bagaimana kita boleh senaraikan
# fail .txt di dalam direktori semasa:
ls -l | grep "\.txt"
# Anda boleh mengubah hala arahan input dan output (stdin, stdout, dan stderr).
# Baca dari stdin sampai ^EOF$ dan menulis ganti hello.py dengan baris
# antara “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
# Jalankan hello.py dengan pelbagai penghantaran semula stdin, stdout, dan 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
# Output ralat akan menulis ganti fail jika ia wujud,
# jika anda ingin menambah sebaliknya, guna ‘>>”:
python hello.py >> "output.out" 2>> "error.err"
# Menulis ganti output.out, menambah ke error.err, dan mengira baris:
info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
wc -l output.out error.err
# Jalankan arahan dan cetak fail Deskriptor (e.g. /dev/fd/123)
# lihat: man fd
echo <(echo "#helloworld")
# Menulis ganti output.out dengan “#helloworld":
cat > output.out <(echo "#helloworld")
echo "#helloworld" > output.out
echo "#helloworld" | cat > output.out
echo "#helloworld" | tee output.out >/dev/null
# Membersihkan fail semantara keseluruhan (tambah ‘-i’ untuk interaktif)
rm -v output.out error.err output-and-error.log
# Arahan boleh digantikan dalam arahan lain menggunakan $():
# Arahan berikut memaparkan jumlah fail dan direktori dalam
# direktori semasa.
echo "There are $(ls | wc -l) items here."
# Perkara yang sama boleh dilakukan dengan menggunakan backticks `` tetapi ia tidak boleh bersarang - cara yang terbaik
# ialah menggunakan $( ).
echo "There are `ls | wc -l` items here."
# Bash menggunakan penyataan case yang berfungsi sama seperti ‘switch’ pada Java dan C++:
case "$Variable" in
# Senarai paten untuk syarat yang ada ingin ketemui
0) echo "There is a zero.";;
1) echo "There is a one.";;
*) echo "It is not null.";;
esac
# ‘for loops iterate' untuk sebanyak mana argumen yang ditetapkan:
# Kandungan dari $Variable dicetakan sebanyak tiga kali.
for Variable in {1..3}
do
echo "$Variable"
done
# Atau tulis ia cara "traditional for loop":
for ((a=1; a <= 3; a++))
do
echo $a
done
# Ia juga boleh digunakan untuk bertindak ke atas fail..
# Ini akan menjalankan arahan 'cat' pada file1 dan file2
for Variable in file1 file2
do
cat "$Variable"
done
# ..atau output daripada arahan
# Ini akan 'cat' output dari ls.
for Output in $(ls)
do
cat "$Output"
done
# while loop:
while [ true ]
do
echo "loop body here..."
break
done
# Anda juga boleh mendefinasikan fungsi
# Definasi:
function foo ()
{
echo "Arguments work just like script arguments: $@"
echo "And: $1 $2..."
echo "This is a function"
return 0
}
# atau lebih mudah
bar ()
{
echo "Another way to declare functions!"
return 0
}
# Memanggil fungsi
foo "My name is" $Name
# Terdapat banyak arahan yang berguna yang perlu anda belajar:
# cetak 10 baris terakhir dalam file.txt
tail -n 10 file.txt
# cetak 10 baris pertama dalam file.txt
head -n 10 file.txt
# menyusun baris fail.txt
sort file.txt
# laporan atau meninggalkan garisan berulang, dengan -d ia melaporkan
uniq -d file.txt
# cetak hanya kolum pertama sebelum aksara ','
cut -d ',' -f 1 file.txt
# menggantikan setiap kewujudan 'okay' dengan 'great' dalam file.txt, (serasi regex)
sed -i 's/okay/great/g' file.txt
# cetak ke stdoout semua baris dalam file.txt yang mana sepadan beberapa regex
# contoh cetak baris yang mana bermula dengan “foo” dan berakhir dengan “bar”
grep "^foo.*bar$" file.txt
# beri opsyen “-c” untuk sebaliknya mencetak jumlah baris sepadan regex
grep -c "^foo.*bar$" file.txt
# jika anda secara literal mahu untuk mencari rentetan,
# dan bukannya regex, guna fgrep (atau grep -F)
fgrep "^foo.*bar$" file.txt
# Baca dokumentasi Bash shell terbina dengan 'help' terbina:
help
help help
help for
help return
help source
help .
# Baca dokumentasi Bash manpage dengan man
apropos bash
man 1 bash
man bash
# Baca dokumentasi info dengan info (? for help)
apropos info | grep '^info.*('
man info
info info
info 5 info
# Baca dokumentasi bash info:
info bash
info bash 'Bash Features'
info bash 6
info --apropos bash
```

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}]
```

232
ms-my/sass-my.html.markdown Normal file
View File

@ -0,0 +1,232 @@
---
language: sass
filename: learnsass-ms.scss
contributors:
- ["Laura Kyle", "https://github.com/LauraNK"]
translators:
- ["hack1m", "https://github.com/hack1m"]
lang: ms-my
---
Sass ialah bahasa sambungan CSS yang menambah ciri-ciri seperti pembolehubah, bersarang, mixins dan banyak lagi.
Sass (dan prapemproses lain, seperti [Less](http://lesscss.org/)) membantu pembangun untuk menulis kod mampu diselenggara dan DRY (Don't Repeat Yourself).
Sass mempunyai dua perbezaan pilihan sintaks untuk dipilih. SCSS, yang mana mempunyai sintaks yang sama seperti CSS tetapi dengan ditambah ciri-ciri Sass. Atau Sass (sintaks asal), yang menggunakan indentasi bukannya tanda kurung dakap dan semikolon.
Tutorial ini ditulis menggunakan SCSS.
```scss
//Komen baris tunggal dikeluarkan apabila Sass dikompil ke CSS.
/*Komen multi dikekalkan. */
/*Pembolehubah
==============================*/
/* Anda boleh menyimpan nilai CSS (seperti warna) dalam pembolehubah.
Guna simbol '$' untuk membuat pembolehubah. */
$primary-color: #A3A4FF;
$secondary-color: #51527F;
$body-font: 'Roboto', sans-serif;
/* Anda boleh mengguna pembolehubah diseluruh lembaran gaya anda.
Kini jika anda ingin mengubah warna, anda hanya perlu membuat perubahan sekali.*/
body {
background-color: $primary-color;
color: $secondary-color;
font-family: $body-font;
}
/* Ia akan dikompil kepada: */
body {
background-color: #A3A4FF;
color: #51527F;
font-family: 'Roboto', sans-serif;
}
/* Ini jauh lebih mampu diselenggara daripada perlu menukar warna
setiap yang ada diseluruh lembaran gaya anda. */
/*Mixins
==============================*/
/* Jika anda jumpa yang anda menulis kod yang sama pada lebih dari satu
elemen, anda mungkin ingin menyimpan kod itu di dalam mixin.
Guna arahan '@mixin', tambah dengan nama untuk mixin anda.*/
@mixin center {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
}
/* Anda boleh guna mixin bersama '@include' dan nama mixin. */
div {
@include center;
background-color: $primary-color;
}
/*Ia akan dikompil kepada: */
div {
display: block;
margin-left: auto;
margin-right: auto;
left: 0;
right: 0;
background-color: #A3A4FF;
}
/* Anda boleh guna mixins untuk membuat singkatan property. */
@mixin size($width, $height) {
width: $width;
height: $height;
}
/*Yang mana anda boleh seru dengan memberi argumen lebar dan tinggi. */
.rectangle {
@include size(100px, 60px);
}
.square {
@include size(40px, 40px);
}
/* Ia dikompil kepada: */
.rectangle {
width: 100px;
height: 60px;
}
.square {
width: 40px;
height: 40px;
}
/*Extend (Inheritance)
==============================*/
/*Extend ialah jalan untuk berkongsi sifat dengan satu pemilih dengan yang lain. */
.display {
@include size(5em, 5em);
border: 5px solid $secondary-color;
}
.display-success {
@extend .display;
border-color: #22df56;
}
/* Dikompil kepada: */
.display, .display-success {
width: 5em;
height: 5em;
border: 5px solid #51527F;
}
.display-success {
border-color: #22df56;
}
/*Bersarang
==============================*/
/*Sass membenarkan anda untuk sarangkan pemilih dengan pemilih */
ul {
list-style-type: none;
margin-top: 2em;
li {
background-color: #FF0000;
}
}
/* '&' akan digantikan dengan pemilih induk. */
/* Anda juga boleh sarangkan kelas-pseudo. */
/* Perlu diingat terlebih bersarang akan membuat kod anda kurang mampu diselenggara.
Sebagai contoh: */
ul {
list-style-type: none;
margin-top: 2em;
li {
background-color: red;
&:hover {
background-color: blue;
}
a {
color: white;
}
}
}
/* Dikompil kepada: */
ul {
list-style-type: none;
margin-top: 2em;
}
ul li {
background-color: red;
}
ul li:hover {
background-color: blue;
}
ul li a {
color: white;
}
```
## SASS atau Sass?
Adakah anda tertanya-tanya sama ada Sass adalah akronim atau tidak? Anda mungkin tidak perlu, tetapi saya akan memberitahu. Nama bahasa ini adalah perkataan, "Sass", dan tidak akronim.
Kerana orang sentiasa menulis ia sebagai "Sass", pencipta bahasa bergurau memanggilnya "Syntactically Awesome StyleSheets".
## Berlatih Sass
Jika anda ingin bermain dengan Sass di pelayar anda, lihat [SassMeister](http://sassmeister.com/).
Anda boleh guna salah satu sintaks, hanya pergi ke tetapan dan pilih sama ada Sass atau SCSS.
## Bacaan lanjut
* [Dokumentasi Rasmi](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
* [The Sass Way](http://thesassway.com/) menyediakan tutorial (asas-lanjutan) dan artikel.

130
ms-my/xml-my.html.markdown Normal file
View File

@ -0,0 +1,130 @@
---
language: xml
filename: learnxml-ms.xml
contributors:
- ["João Farias", "https://github.com/JoaoGFarias"]
translators:
- ["hack1m", "https://github.com/hack1m"]
lang: ms-my
---
XML adalah bahasa markup direka untuk menyimpan dan mengangkutan data.
Tidak seperti HTML, XML tidak menyatakan bagaimana paparan atau mengformat data, hanya membawanya.
* Sintaks XML
```xml
<!-- Komen di XML seperti ini -->
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="COOKING">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="CHILDREN">
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="WEB">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
</book>
</bookstore>
<!-- Di atas adalah fail XML biasa.
Ia bermula dengan perisytiharan, memaklumkan beberapa metadata (pilihan).
XML menggunakan struktur pokok, Di atas, nod akar ialah ‘bookstore’, yang mana mempunyai tiga nod anak, semua ‘books’. Nod itu mempunyai lebih nod anak (atau anak-anak), dan seterusnya…
Nod dibuat menggunakan tag pembuka/penutup, dan anak-anak hanya nod antara
pembuka dan penutup tag.-->
<!-- XML membawa dua jenis data:
1 - Atribut -> Iaitu metadata mengenai nod.
Biasanya, penghurai XML menggunakan informasi untuk menyimpan data dengan betul.
Ia mempunyai ciri-ciri yang dipaparkan bersama format name=“value” dalam tag
pembuka.
2 - Elemen -> Iaitu data tulen.
Iaitu apa penghurai akan menerima daripada fail XML.
Elemen memaparkan diantara pembuka dan penutup tag. —>
<!-- Di bawah, elemen dengan dua atribut -->
<file type="gif" id="4293">computer.gif</file>
```
* Dokumen Format sempurna x Pengesahan
Satu dokumen XML adalah format sempurna jika ia adalah sintaksis yang betul.
Walau bagaimanapun, ia mungkin menyuntik lebih banyak kekangan dalam dokumen itu,
menggunakan definasi dokumen, seperti DTD dan Skema XML.
Satu dokumen XML yang mana mengikut definasi dokumen dipanggil sah,
mengenai dokumen itu.
Dengan alat ini, anda boleh menyemak data XML di luar logik aplikasi.
```xml
<!-- Dibawah, anda boleh melihat versi ringkas daripada dokumen bookstore,
dengan tambahan definisi DTD. -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note SYSTEM "Bookstore.dtd">
<bookstore>
<book category="COOKING">
<title >Everyday Italian</title>
<price>30.00</price>
</book>
</bookstore>
<!-- DTD boleh menjadi sesuatu seperti ini: -->
<!DOCTYPE note
[
<!ELEMENT bookstore (book+)>
<!ELEMENT book (title,price)>
<!ATTLIST book category CDATA "Literature">
<!ELEMENT title (#PCDATA)>
<!ELEMENT price (#PCDATA)>
]>
<!-- DTD bermula dengan pengisytiharan.
Berikut, nod akar diisytihar, memerlukan 1 atau lebih nod anak ‘book’.
Setiap ‘book’ harus mengandungi betul-betul satu ‘title’ dan ‘price’ dan atribut
dipanggil ‘category’, bersama “Literature" sebagai nilai lalai ia.
Nod ‘title’ dan ‘price’ mengandungi aksara data terhurai.-—>
<!-- DTD boleh diisytiharkan di dalam fail XML itu sendiri. -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note
[
<!ELEMENT bookstore (book+)>
<!ELEMENT book (title,price)>
<!ATTLIST book category CDATA "Literature">
<!ELEMENT title (#PCDATA)>
<!ELEMENT price (#PCDATA)>
]>
<bookstore>
<book category="COOKING">
<title >Everyday Italian</title>
<price>30.00</price>
</book>
</bookstore>
```

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