diff options
| -rw-r--r-- | fr-fr/python-fr.html.markdown | 491 | ||||
| -rw-r--r-- | matlab.html.markdown | 17 | ||||
| -rw-r--r-- | objective-c.html.markdown | 2 | ||||
| -rw-r--r-- | php.html.markdown | 29 | ||||
| -rw-r--r-- | pt-br/erlang-pt.html.markdown | 253 | ||||
| -rw-r--r-- | pt-pt/git-pt.html.markdown | 414 | ||||
| -rw-r--r-- | ruby-ecosystem.html.markdown | 6 | ||||
| -rw-r--r-- | ruby.html.markdown | 51 |
8 files changed, 1247 insertions, 16 deletions
diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown new file mode 100644 index 00000000..2f10e410 --- /dev/null +++ b/fr-fr/python-fr.html.markdown @@ -0,0 +1,491 @@ +--- +langage: python + +contributeurs: + - ["Louie Dinh", "http://ldinh.ca"] + +traducteurs: + - ["Sylvain Zyssman", "https://github.com/sylzys"] + +fichier: learnpython.py + +--- + +Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de programmation les plus populaires. +Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiquement du pseudo-code exécutable. + +Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service] + +NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x +Vous pourrez bientôt trouver un article pour Python 3! + +```python +# Une ligne simple de commentaire commence par un dièse +""" Les lignes de commenatires multipes peuvent être écrites + en utilisant 3 guillemets ("), et sont souvent utilisées + pour les commentaires +""" + +#################################################### +## 1. Types Primaires et Opérateurs +#################################################### + +# Les nombres +3 #=> 3 + +# Les calculs produisent les résultats mathématiques escomptés +1 + 1 #=> 2 +8 - 1 #=> 7 +10 * 2 #=> 20 +35 / 5 #=> 7 + +# La division est un peu spéciale. C'est une division d'entiers, et Python arrondi le résultat par défaut automatiquement. +5 / 2 #=> 2 + +# Pour corriger ce problème, on utilise les float. +2.0 # Voici un float +11.0 / 4.0 #=> 2.75 ahhh... beaucoup mieux + +# Forcer la priorité avec les parenthèses +(1 + 3) * 2 #=> 8 + +# Les valeurs booléenes sont de type primitif +True +False + +# Pour la négation, on utilise "not" +not True #=> False +not False #=> True + +# Pour l'égalité, == +1 == 1 #=> True +2 == 1 #=> False + +# L'inégalité est symbolisée par != +1 != 1 #=> False +2 != 1 #=> True + +# D'autres comparateurs +1 < 10 #=> True +1 > 10 #=> False +2 <= 2 #=> True +2 >= 2 #=> True + +# On peut enchaîner les comparateurs ! +1 < 2 < 3 #=> True +2 < 3 < 2 #=> False + +# Les chaînes de caractères sont créées avec " ou ' +"C'est une chaîne." +'C'est aussi une chaîne.' + +# On peut aussi les "additioner" ! +"Hello " + "world!" #=> "Hello world!" + +# Une chaîne peut être traitée comme une liste de caractères +"C'est une chaîne"[0] #=> 'C' + +# % peut être utilisé pour formatter des chaîne, comme ceci: +"%s can be %s" % ("strings", "interpolated") + +# Une autre manière de formatter les chaînes de caractères est d'utiliser la méthode 'format' +# C'est la méthode à privilégier +"{0} peut être {1}".format("La chaîne", "formattée") +# On peut utiliser des mot-clés au lieu des chiffres. +"{name} veut manger des {food}".format(name="Bob", food="lasagnes") + +# None est un objet +None #=> None + +# Ne pas utiliser le symbole d'inégalité "==" pour comparer des objet à None +# Il faut utiliser "is" +"etc" is None #=> False +None is None #=> True + +# L'opérateur 'is' teste l'identité de l'objet. +# Ce n'est pas très utilisé avec les types primitifs, mais cela peut être très utile +# lorsque l'on utilise des objets. + +# None, 0, et les chaînes de caractères vides valent False. +# Toutes les autres valeurs valent True +0 == False #=> True +"" == False #=> True + + +#################################################### +## 2. Variables et Collections +#################################################### + +# Afficher du texte, c'est facile +print "Je suis Python. Enchanté!" + + +# Il n'y a pas besoin de déclarer les variables avant de les assigner. +some_var = 5 # La convention veut que l'on utilise des minuscules_avec_underscores +some_var #=> 5 + +# Accéder à une variable non assignée lève une exception +# Voyez les structures de contrôle pour en apprendre plus sur la gestion des exceptions. +some_other_var # Lève une exception + +# 'if' peut être utilisé comme expression +"yahoo!" if 3 > 2 else 2 #=> "yahoo!" + +# Listes +li = [] +# On peut remplir liste dès l'instanciation +other_li = [4, 5, 6] + +# On ajoute des éléments avec 'append' +li.append(1) #li contient [1] +li.append(2) #li contient [1, 2] +li.append(4) #li contient [1, 2, 4] +li.append(3) #li contient [1, 2, 4, 3] + +# Et on les supprime avec 'pop' +li.pop() #=> 3 et li contient [1, 2, 4] +# Remettons-le dans la liste +li.append(3) # li contient [1, 2, 4, 3] de nouveau. + +# On accède aux éléments d'une liste comme à ceux un tableau. +li[0] #=> 1 +# Le dernier élément +li[-1] #=> 3 + +# Accèder aux indices hors limite lève une exception +li[4] # Lève un 'IndexError' + +# On peut accèder à des rangs de valeurs avec la syntaxe "slice" +# (C'est un rang de type 'fermé/ouvert' pour les plus matheux) +li[1:3] #=> [2, 4] +# Sans spécifier de début de rang +li[2:] #=> [4, 3] +# Sans spécifier de fin de rang +li[:3] #=> [1, 2, 4] + +# Retirer un élément spécifique dee la liste avec "del" +del li[2] # li contient [1, 2, 3] + +# On peut additionner des listes entre elles +li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li et other_li existent toujours à part entière + +# Concaténer des listes avec "extend()" +li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6] + +# Vérifier l'existence d'un élément dans une liste avec "in" +1 in li #=> True + +# Récupérer la longueur avec "len()" +len(li) #=> 6 + + +# Les "tuples" sont comme des listes, mais sont immuables. +tup = (1, 2, 3) +tup[0] #=> 1 +tup[0] = 3 # Lève un 'TypeError' + +# Mais vous pouvez faire tout ceci sur les tuples: +len(tup) #=> 3 +tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6) +tup[:2] #=> (1, 2) +2 in tup #=> True + +# Vous pouvez "dé-packager" les tuples (ou les listes) dans des variables +a, b, c = (1, 2, 3) # a vaut maintenant 1, b vaut maintenant 2 and c vaut maintenant 3 +# Sans parenthèses, un tuple est créé par défaut +d, e, f = 4, 5, 6 +# Voyez maintenant comme il est facile d'inverser 2 valeurs +e, d = d, e # d is now 5 and e is now 4 + + +# Dictionnaires +empty_dict = {} +# Un dictionnaire pré-rempli +filled_dict = {"one": 1, "two": 2, "three": 3} + +# Trouver des valeurs avec [] +filled_dict["one"] #=> 1 + +# Récupérer toutes les clés sous forme de liste avec "keys()" +filled_dict.keys() #=> ["three", "two", "one"] +# Note - l'ordre des clés du dictionnaire n'est pas garanti. +# Vos résultats peuvent différer de ceux ci-dessus. + +# Récupérer toutes les valeurs sous forme de liste avec "values()" +filled_dict.values() #=> [3, 2, 1] +# Note - Même remarque qu'au-dessus concernant l'ordre des valeurs. + +# Vérifier l'existence d'une clé dans le dictionnaire avec "in" +"one" in filled_dict #=> True +1 in filled_dict #=> False + +# Chercher une clé non existante lève une 'KeyError' +filled_dict["four"] # KeyError + +# Utiliser la méthode "get()" pour éviter 'KeyError' +filled_dict.get("one") #=> 1 +filled_dict.get("four") #=> None +# La méthode get() prend un argument par défaut quand la valeur est inexistante +filled_dict.get("one", 4) #=> 1 +filled_dict.get("four", 4) #=> 4 + +# La méthode "setdefault()" permet d'ajouter de manière sécuris une paire clé-valeur dans le dictionnnaire +filled_dict.setdefault("five", 5) #filled_dict["five"] vaut 5 +filled_dict.setdefault("five", 6) #filled_dict["five"] is toujours 5 + + +# Les sets stockent ... des sets +empty_set = set() +# On initialise un "set()" avec tout un tas de valeurs +some_set = set([1,2,2,3,4]) # some_set vaut maintenant set([1, 2, 3, 4]) + +# Depuis Python 2.7, {} peut être utilisé pour déclarer un 'set' +filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} + +# Ajouter plus d'éléments au set +filled_set.add(5) # filled_set contient maintenant {1, 2, 3, 4, 5} + +# Intersection de sets avec & +other_set = {3, 4, 5, 6} +filled_set & other_set #=> {3, 4, 5} + +# Union de sets avec | +filled_set | other_set #=> {1, 2, 3, 4, 5, 6} + +# Différence de sets avec - +{1,2,3,4} - {2,3,5} #=> {1, 4} + +# Vérifier l'existence d'une valeur dans un set avec "in" +2 in filled_set #=> True +10 in filled_set #=> False + + +#################################################### +## 3. Structure de contrôle +#################################################### + +# Initialisons une variable +some_var = 5 + +# Voici une condition 'if'. L'indentation est significative en Python ! +# Affiche "some_var est inférieur à 10" +if some_var > 10: + print "some_var est supérieur à 10." +elif some_var < 10: # La clause elif est optionnelle + print "some_var iinférieur à 10." +else: # La clause else également + print "some_var vaut 10." + + +""" +Les boucles "for" permettent d'itérer sur les listes +Affiche: + chien : mammifère + chat : mammifère + souris : mammifère +""" +for animal in ["chien", "chat", "souris"]: + # On peut utiliser % pour l'interpolation des chaînes formattées + print "%s : mammifère" % animal + +""" +"range(number)" retourne une liste de nombres +de 0 au nombre donné +Affiche: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print i + +""" +Les boucles "while" boucle jusqu'à ce que leur condition ne soit plus vraie +Affiche: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print x + x += 1 # Raccourci pour x = x + 1 + +# Gérer les exceptions avec un bloc try/except + +# Fonctionne pour Python 2.6 et ultérieur: +try: + # Utiliser "raise" pour lever une exception + raise IndexError("This is an index error") +except IndexError as e: + pass # Pass ne prend pas d'arguments. Généralement, on gère l'erreur ici. + + +#################################################### +## 4. Fonctions +#################################################### + +# Utiliser "def" pour créer une nouvelle fonction +def add(x, y): + print "x vaut %s et y vaur %s" % (x, y) + return x + y # Renvoi de valeur avec 'return' + +# Appeller une fonction avec des paramètres +add(5, 6) #=> Affichet "x is 5 et y vaut 6" et renvoie 11 + +# Une autre manière d'appeller une fonction, avec les arguments +add(y=6, x=5) # Les arguments peuvent venir dans n'importe quel ordre. + +# On peut définir une foncion qui prend un nombre variable de paramètres +def varargs(*args): + return args + +varargs(1, 2, 3) #=> (1,2,3) + + +# On peut également définir une fonction qui prend un nombre +# variable d'arguments +def keyword_args(**kwargs): + return kwargs + +# Appelons-là et voyons ce qu'il se passe +keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} + +# On peut faire les deux à la fois si on le souhaite +def all_the_args(*args, **kwargs): + print args + print kwargs +""" +all_the_args(1, 2, a=3, b=4) affiche: + (1, 2) + {"a": 3, "b": 4} +""" + +# En appellant les fonctions, on peut faire l'inverse des paramètres / arguments ! +# Utiliser * pour développer les paramètres, et ** pour développer les arguments +params = (1, 2, 3, 4) +args = {"a": 3, "b": 4} +all_the_args(*args) # equivaut à foo(1, 2, 3, 4) +all_the_args(**kwargs) # equivaut à foo(a=3, b=4) +all_the_args(*args, **kwargs) # equivaut à foo(1, 2, 3, 4, a=3, b=4) + +# Python a des fonctions de première classe +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) #=> 13 + +# Mais également des fonctions anonymes +(lambda x: x > 2)(3) #=> True + +# On trouve aussi des fonctions intégrées plus évoluées +map(add_10, [1,2,3]) #=> [11, 12, 13] +filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] + +# On peut utiliser la syntaxe des liste pour construire les "maps" et les "filters" +[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. Classes +#################################################### + +# Une classe est un objet +class Human(object): + + # Un attribut de classe. Il est partagé par toutes les instances de cette classe. + species = "H. sapiens" + + # Initialiseur basique + def __init__(self, name): + # Assigne le paramètre à l'attribut de l'instance de classe. + self.name = name + + # Une méthode de l'instance. Toutes les méthodes prennent "self" comme 1er paramètre. + def say(self, msg): + return "%s: %s" % (self.name, msg) + + # Une méthode de classe est partagée par toutes les instances. + # On les appelle avec le nom de la classe en premier paramètre + @classmethod + def get_species(cls): + return cls.species + + # Une méthode statique est appellée sans référence à une classe ou à une instance + @staticmethod + def grunt(): + return "*grunt*" + + +# Instancier une classe +i = Human(name="Ian") +print i.say("hi") # Affiche "Ian: hi" + +j = Human("Joel") +print j.say("hello") #Affiche "Joel: hello" + +# Appeller notre méthode de classe +i.get_species() #=> "H. sapiens" + +# Changer les attributs partagés +Human.species = "H. neanderthalensis" +i.get_species() #=> "H. neanderthalensis" +j.get_species() #=> "H. neanderthalensis" + +# Appeller la méthode statique +Human.grunt() #=> "*grunt*" + + +#################################################### +## 6. Modules +#################################################### + +# On peut importer des modules +import math +print math.sqrt(16) #=> 4 + +# Et récupérer des fonctions spécifiques d'un module +from math import ceil, floor +print ceil(3.7) #=> 4.0 +print floor(3.7) #=> 3.0 + +# Récuperer toutes les fonctions d'un module +# Attention, ce n'est pas recommandé. +from math import * + +# On peut raccourcir le nom d'un module +import math as m +math.sqrt(16) == m.sqrt(16) #=> True + +# Les modules Python sont juste des fichiers Python ordinaires. +# On peut écrire ses propres modules et les importer. +# Le nom du module doit être le même que le nom du fichier. + +# On peut trouver quelle fonction et attributs déterminent un module +import math +dir(math) + + +``` + +## Prêt à aller plus loin? + +### En ligne gratuitement + +* [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/) + +### Format papier + +* [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) + diff --git a/matlab.html.markdown b/matlab.html.markdown index 507e9c85..3bcc4bbc 100644 --- a/matlab.html.markdown +++ b/matlab.html.markdown @@ -250,7 +250,22 @@ eig(A) %Eigenvalues and eigenvectors of A isempty(A) % Tests if array is empty isequal(A, B) %Tests equality of two arrays numel(A) %Number of elements in matrix - +triu(x) % Returns the upper triangular part of x +tril(x) % Returns the lower triangular part of x +cross(A,B) % Returns the cross product of the vectors A and B +dot(A,B) % Returns the scalar product of the vectors A and B. A and B must be vectors of the same length. +transpose(A) % Returns the transpose of A + +% Common vector functions +max %largest component +min %smallest component +length %length of a vector +sort %sort in ascending order +sum %sum of elements +prod %product of elements +median %median value +mean %mean value +std %standard deviation ``` diff --git a/objective-c.html.markdown b/objective-c.html.markdown index 926a4a0d..1ed0ed58 100644 --- a/objective-c.html.markdown +++ b/objective-c.html.markdown @@ -80,7 +80,7 @@ int main (int argc, const char * argv[]) NSLog(@"%f", piFloat); NSNumber *piDoubleNumber = @3.1415926535; - piDouble = [piDoubleNumber doubleValue]; + double piDouble = [piDoubleNumber doubleValue]; NSLog(@"%f", piDouble); // BOOL literals diff --git a/php.html.markdown b/php.html.markdown index 0caa07b6..1952d833 100644 --- a/php.html.markdown +++ b/php.html.markdown @@ -107,7 +107,7 @@ echo 'This string ' . 'is concatenated'; /******************************** * Constants */ - + // A constant is defined by using define() // and can never be changed during runtime! @@ -143,7 +143,7 @@ echo $array[0]; // => "One" $array[] = 'Four'; // Remove element from array -unset($array[3]); +unset($array[3]); /******************************** * Output @@ -455,8 +455,10 @@ class MyClass // Static variables and their visibility public static $publicStaticVar = 'publicStatic'; - private static $privateStaticVar = 'privateStatic'; // Accessible within the class only - protected static $protectedStaticVar = 'protectedStatic'; // Accessible from the class and subclasses + // Accessible within the class only + private static $privateStaticVar = 'privateStatic'; + // Accessible from the class and subclasses + protected static $protectedStaticVar = 'protectedStatic'; // Properties must declare their visibility public $property = 'public'; @@ -476,14 +478,15 @@ class MyClass print 'MyClass'; } - //final keyword would make a function unoverridable + //final keyword would make a function unoverridable final function youCannotOverrideMe() { } /* -Declaring class properties or methods as static makes them accessible without needing an instantiation of the class. -A property declared as static can not be accessed with an instantiated class object (though a static method can). + * Declaring class properties or methods as static makes them accessible without + * needing an instantiation of the class. A property declared as static can not + * be accessed with an instantiated class object (though a static method can). */ public static function myStaticMethod() @@ -674,10 +677,14 @@ $cls = new SomeOtherNamespace\MyClass(); ## More Information -Visit the [official PHP documentation](http://www.php.net/manual/) for reference and community input. +Visit the [official PHP documentation](http://www.php.net/manual/) for reference +and community input. -If you're interested in up-to-date best practices, visit [PHP The Right Way](http://www.phptherightway.com/). +If you're interested in up-to-date best practices, visit +[PHP The Right Way](http://www.phptherightway.com/). -If you're coming from a language with good package management, check out [Composer](http://getcomposer.org/). +If you're coming from a language with good package management, check out +[Composer](http://getcomposer.org/). -For common standards, visit the PHP Framework Interoperability Group's [PSR standards](https://github.com/php-fig/fig-standards). +For common standards, visit the PHP Framework Interoperability Group's +[PSR standards](https://github.com/php-fig/fig-standards). diff --git a/pt-br/erlang-pt.html.markdown b/pt-br/erlang-pt.html.markdown new file mode 100644 index 00000000..6a86aafc --- /dev/null +++ b/pt-br/erlang-pt.html.markdown @@ -0,0 +1,253 @@ +--- +language: erlang +filename: learnerlang-pt.erl +contributors: + - ["Giovanni Cappellotto", "http://www.focustheweb.com/"] + - ["Guilherme Heuser Prestes", "http://twitter.com/gprestes"] +lang: pt-br +--- + +```erlang +% Símbolo de porcento começa comentários de uma linha. + +%% Dois caracteres de porcento devem ser usados para comentar funções. + +%%% Três caracteres de porcento devem ser usados para comentar módulos. + +% Nós usamos três tipos de pontuação em Erlang. +% Vírgulas (`,`) separam argumentos em chamadas de função, construtores de +% dados, e padrões. +% Pontos finais (`.`) separam totalmente funções e expressões no prompt. +% Ponto e vírgulas (`;`) separam cláusulas. Nós encontramos cláusulas em +% vários contextos: definições de função e em expressões com `case`, `if`, +% `try..catch` e `receive`. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 1. Variáveis e casamento de padrões. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +Num = 42. % Todos nomes de variáveis devem começar com uma letra maiúscula. + +% Erlang tem atribuição única de variáveis, se você tentar atribuir um valor +% diferente à variável `Num`, você receberá um erro. +Num = 43. % ** exception error: no match of right hand side value 43 + +% Na maioria das linguagens, `=` denota um comando de atribuição. Em Erlang, no +% entanto, `=` denota uma operação de casamento de padrão. `Lhs = Rhs` realmente +% significa isso: avalia o lado direito (Rhs), e então casa o resultado com o +% padrão no lado esquerdo (Lhs). +Num = 7 * 6. + +% Número de ponto flutuante. +Pi = 3.14159. + +% Átomos são usados para representar diferentes valores constantes não +% numéricos. Átomos começam com letras minúsculas seguidas por uma sequência de +% caracteres alfanuméricos ou sinais de subtraço (`_`) ou arroba (`@`). +Hello = hello. +OtherNode = example@node. + +% Átomos com valores alfanuméricos podem ser escritos colocando aspas por fora +% dos átomos. +AtomWithSpace = 'some atom with space'. + +% Tuplas são similares a structs em C. +Point = {point, 10, 45}. + +% Se nós queremos extrair alguns valores de uma tupla, nós usamos o operador `=`. +{point, X, Y} = Point. % X = 10, Y = 45 + +% Nós podemos usar `_` para ocupar o lugar de uma variável que não estamos interessados. +% O símbolo `_` é chamado de variável anônima. Ao contrário de variáveis regulares, +% diversas ocorrências de _ no mesmo padrão não precisam se amarrar ao mesmo valor. +Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}. +{_, {_, {_, Who}, _}, _} = Person. % Who = joe + +% Nós criamos uma lista colocando valores separados por vírgula entre colchetes. +% Cada elemento de uma lista pode ser de qualquer tipo. +% O primeiro elemento de uma lista é a cabeça da lista. Se removermos a cabeça +% da lista, o que sobra é chamado de cauda da lista. +ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}]. + +% Se `T` é uma lista, então `[H|T]` também é uma lista, com cabeça `H` e cauda `T`. +% A barra vertical (`|`) separa a cabeça de uma lista de sua cauda. +% `[]` é uma lista vazia. +% Podemos extrair elementos de uma lista com uma operação de casamento de +% padrão. Se temos uma lista não-vazia `L`, então a expressão `[X|Y] = L`, onde +% `X` e `Y` são variáveis desamarradas, irá extrair a cabeça de uma lista para +% `X` e a cauda da lista para `Y`. +[FirstThing|OtherThingsToBuy] = ThingsToBuy. +% FirstThing = {apples, 10} +% OtherThingsToBuy = {pears, 6}, {milk, 3} + +% Não existe o tipo string em Erlang. Strings são somente listas de inteiros. +% Strings são representadas dentro de aspas duplas (`"`). +Name = "Hello". +[72, 101, 108, 108, 111] = "Hello". + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 2. Programação sequencial. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Módulos são a unidade básica de código em Erlang. Todas funções que +% escrevemos são armazenadas em módulos. Módulos são armazenados em arquivos +% com extensão `.erl`. +% Módulos devem ser compilados antes que o código possa ser rodado. Um módulo +% compilado tem a extensão `.beam`. +-module(geometry). +-export([area/1]). % lista de funções exportadas de um módulo. + +% A função `area` consiste de duas cláusulas. As cláusulas são separadas por um +% ponto e vírgula, e a cláusula final é terminada por um ponto final. +% Cada cláusula tem uma cabeça em um corpo; a cabeça consiste de um nome de +% função seguido por um padrão (entre parêntesis), e o corpo consiste de uma +% sequência de expressões, que são avaliadas se o padrão na cabeça é um par bem +% sucedido dos argumentos da chamada. Os padrões são casados na ordem que +% aparecem na definição da função. +area({rectangle, Width, Ht}) -> Width * Ht; +area({circle, R}) -> 3.14159 * R * R. + +% Compila o código no arquivo geometry.erl. +c(geometry). % {ok,geometry} + +% Nós precisamos incluir o nome do módulo junto com o nome da função de maneira +% a identificar exatamente qual função queremos chamar. +geometry:area({rectangle, 10, 5}). % 50 +geometry:area({circle, 1.4}). % 6.15752 + +% Em Erlang, duas funções com o mesmo nome e diferentes aridades (números de +% argumentos) no mesmo módulo representam funções totalmente diferentes. +-module(lib_misc). +-export([sum/1]). % exporta a função `sum` de aridade 1 aceitando um argumento: lista de inteiros. +sum(L) -> sum(L, 0). +sum([], N) -> N; +sum([H|T], N) -> sum(T, H+N). + +% Funs são funções "anônimas". Elas são chamadas desta maneira por que elas não +% têm nome. No entanto podem ser atribuídas a variáveis. +Double = fun(X) -> 2*X end. % `Double` aponta para uma função anônima com referência: #Fun<erl_eval.6.17052888> +Double(2). % 4 + +% Funções aceitam funs como seus argumentos e podem retornar funs. +Mult = fun(Times) -> ( fun(X) -> X * Times end ) end. +Triple = Mult(3). +Triple(5). % 15 + +% Compreensão de lista são expressões que criam listas sem precisar usar funs, +% maps, ou filtros. +% A notação `[F(X) || X <- L]` significa "a lista de `F(X)` onde `X` é tomada +% da lista `L`." +L = [1,2,3,4,5]. +[2*X || X <- L]. % [2,4,6,8,10] +% Uma compreensão de lista pode ter geradores e filtros que selecionam +% subconjuntos dos valores gerados. +EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4] + +% Sentinelas são contruções que podemos usar para incrementar o poder de +% casamento de padrão. Usando sentinelas, podemos executar testes simples e +% comparações nas variáveis em um padrão. +% Você pode usar sentinelas nas cabeças das definições de função onde eles são +% introduzidos pela palavra-chave `when`, ou você pode usá-los em qualquer +% lugar na linguagem onde uma expressão é permitida. +max(X, Y) when X > Y -> X; +max(X, Y) -> Y. + +% Um sentinela é uma série de expressões sentinelas, separadas por +% vírgulas (`,`). +% O sentinela `GuardExpr1, GuardExpr2, ..., GuardExprN` é verdadeiro se todas +% expressões sentinelas `GuardExpr1, GuardExpr2, ...` forem verdadeiras. +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. + +% Uma `sequência sentinela` é um sentinela ou uma série de sentinelas separados +% por ponto e vírgula (`;`). A sequência sentinela `G1; G2; ...; Gn` é +% verdadeira se pelo menos um dos sentinelas `G1, G2, ...` for verdadeiro. +is_pet(A) when is_dog(A); is_cat(A) -> true; +is_pet(A) -> false. + +% Registros provêem um método para associar um nome com um elemento particular +% em uma tupla. +% Definições de registro podem ser incluídas em arquivos fonte Erlang ou em +% arquivos com extensão `.hrl`, que então são incluídos em arquivos fonte Erlang. +-record(todo, { + status = reminder, % Default value + who = joe, + text +}). + +% Nós temos que ler definições de registro no prompt antes que possamos definir +% um registro. Nós usamos a função de prompt `rr` (abreviação de read records) +% para fazer isso. +rr("records.hrl"). % [todo] + +% Criando e atualizando registros: +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"} + +% Expressões `case`. +% A função `filter` retorna uma lista de todos elementos `X` em uma lista `L` +% para qual `P(X)` é verdadeiro. +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] + +% Expressões `if`. +max(X, Y) -> + if + X > Y -> X; + X < Y -> Y; + true -> nil; + end. + +% Aviso: pelo menos um dos sentinelas na expressão `if` deve retornar +% verdadeiro; Caso contrário, uma exceção será levantada. + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% 3. Exceções. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +% Exceções são levantadas pelo sistema quando erros internos são encontrados ou +% explicitamente em código pela chamada `throw(Exception)`, `exit(Exception)` +% ou `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 tem dois métodos para capturar uma exceção. Uma é encapsular a chamada +% para a função que levanta uma exceção dentro de uma expressão `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. + +% O outro é encapsular a chamada em uma expressão `catch`. Quando você captura +% uma exceção, é convertida em uma tupla que descreve o erro. +catcher(N) -> catch generate_exception(N). + +``` + +## Referências + +* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/) +* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang2/programming-erlang) +* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/) +* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml) + diff --git a/pt-pt/git-pt.html.markdown b/pt-pt/git-pt.html.markdown new file mode 100644 index 00000000..213f1ad3 --- /dev/null +++ b/pt-pt/git-pt.html.markdown @@ -0,0 +1,414 @@ +--- +category: tool +tool: git +lang: pt-pt +filename: LearnGit.txt +contributors: + - ["Rafael Jegundo", "http://rafaeljegundo.github.io/"] +--- + +Git é um sistema distribuido de gestão para código fonte e controlo de versões. + +Funciona através de uma série de registos de estado do projecto e usa esse +registo para permitir funcionalidades de versionamento e gestão de código +fonte. + +## Conceitos de versionamento + +### O que é controlo de versões + +Controlo de versões (*source control*) é um processo de registo de alterações +a um ficheiro ou conjunto de ficheiros ao longo do tempo. + +### Controlo de versões: Centralizado VS Distribuido + +* Controlo de versões centralizado foca-se na sincronização, registo e *backup* +de ficheiros. +* Controlo de versões distribuido foca-se em partilhar alterações. Cada +alteração é associada a um *id* único. +* Sistemas distribuidos não têm estrutura definida. É possivel ter um sistema +centralizado ao estilo SVN usando git. + +[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control) + +### Porquê usar git? + +* Permite trabalhar offline. +* Colaborar com outros é fácil! +* Criar *branches* é fácil! +* Fazer *merge* é fácil! +* Git é rápido. +* Git é flexivel. + +## Git - Arquitectura + + +### Repositório + +Um conjunto de ficheiros, directórios, registos históricos, *commits* e +referências. Pode ser imaginado como uma estrutura de dados de código fonte +com a particularidade de cada elemento do código fonte permitir acesso ao +histórico das suas alterações, entre outras coisas. + +Um repositório git é constituido pelo directório .git e a *working tree* + +### Directório .git (componente do repositório) + +O repositório .git contém todas as configurações, *logs*, *branches*, +referências e outros. + +[Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html) + +### *Working Tree* (componente do repositório) + +Isto é basicamente os directórios e ficheiros do repositório. É frequentemente +referido como o directório do projecto. + +### *Index* (componente do directório .git) + +O *Index* é a camada de interface no git. Consistente num elemento que separa +o directório do projecto do repositório git. Isto permite aos programadores um +maior controlo sobre o que é registado no repositório git. + +### *Commit* + +Um *commit** de git é um registo de um cojunto de alterações ou manipulações +no nos ficheiros do projecto. +Por exemplo, ao adicionar cinco ficheiros e remover outros 2, estas alterações +serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado +para outros repositórios ou não! + +### *Branch* + +Um *branch* é essencialmente uma referência que aponta para o último *commit* +efetuado. à medida que são feitos novos commits, esta referência é atualizada +automaticamente e passa a apontar para o commit mais recente. + +### *HEAD* e *head* (componentes do directório .git) + +*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem +uma *HEAD* activa. +*head* é uma referência que aponta para qualquer *commit*. Um repositório pode +ter um número indefinido de *heads* + +### Recursos conceptuais (EN) + +* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/) +* [Git para Designers](http://hoth.entp.com/output/git_for_designers.html) + +## Comandos + +### *init* + +Cria um repositório Git vazio. As definições, informação guardada e outros do +repositório git são guardados num directório (pasta) denominado ".git". + +```bash +$ git init +``` + +### *config* + +Permite configurar as definições, sejam as definições do repositório, sistema +ou configurações globais. + +```bash +# Imprime & Define Algumas Variáveis de Configuração Básicas (Global) +$ git config --global user.email +$ git config --global user.name + +$ git config --global user.email "MyEmail@Zoho.com" +$ git config --global user.name "My Name" +``` + +[Aprenda Mais Sobre git config. (EN)](http://git-scm.com/docs/git-config) + +### help + +Para aceder rapidamente a um guia extremamente detalhada sobre cada comando. +Ou para dar apenas uma lembraça rápida de alguma semântica. + +```bash +# Ver rapidamente os comandos disponiveis +$ git help + +# Ver todos os comandos disponiveis +$ git help -a + +# Requerer *help* sobre um comando especifico - manual de utilizador +# git help <command_here> +$ git help add +$ git help commit +$ git help init +``` + +### status + +Apresenta as diferenças entre o ficheiro *index* (no fundo a versão corrente +do repositório) e o *commit* da *HEAD* atual. + + +```bash +# Apresenta o *branch*, ficheiros não monitorizados, alterações e outras +# difereças +$ git status + +# Para aprender mais detalhes sobre git *status* +$ git help status +``` + +### add + +Adiciona ficheiros ao repositório corrente. Se os ficheiros novos não forem +adicionados através de `git add` ao repositório, então eles não serão +incluidos nos commits! + +```bash +# adiciona um ficheiro no directório do project atual +$ git add HelloWorld.java + +# adiciona um ficheiro num sub-directório +$ git add /path/to/file/HelloWorld.c + +# permite usar expressões regulares! +$ git add ./*.java +``` + +### branch + +Gere os *branches*. É possível ver, editar, criar e apagar branches com este +comando. + +```bash +# listar *branches* existentes e remotos +$ git branch -a + +# criar um novo *branch* +$ git branch myNewBranch + +# apagar um *branch* +$ git branch -d myBranch + +# alterar o nome de um *branch* +# git branch -m <oldname> <newname> +$ git branch -m myBranchName myNewBranchName + +# editar a descrição de um *branch* +$ git branch myBranchName --edit-description +``` + +### checkout + +Atualiza todos os ficheiros no directório do projecto de forma a ficarem iguais +à versão do index ou do *branch* especificado. + +```bash +# Checkout de um repositório - por predefinição para o branch master +$ git checkout +# Checkout de um branch especifico +$ git checkout branchName +# Cria um novo branch e faz checkout para ele. +# Equivalente a: "git branch <name>; git checkout <name>" +$ git checkout -b newBranch +``` + +### clone + +Clona ou copia um repositório existente para um novo directório. Também +adiciona *branches* de monitorização remota para cada *branch* no repositório +clonado o que permite enviar alterações para um *branch* remoto. + +```bash +# Clona learnxinyminutes-docs +$ git clone https://github.com/adambard/learnxinyminutes-docs.git +``` + +### commit + +Guarda o conteudo atual do index num novo *commit*. Este *commit* contém +as alterações feitas e a mensagem criada pelo utilizador. + +```bash +# commit com uma mensagem +$ git commit -m "Added multiplyNumbers() function to HelloWorld.c" +``` + +### diff + +Apresenta as diferenças entre um ficheiro no repositório do projecto, *index* +e *commits* + +```bash +# Apresenta a diferença entre o directório atual e o index +$ git diff + +# Apresenta a diferença entre o index e os commits mais recentes +$ git diff --cached + +# Apresenta a diferença entre o directório atual e o commit mais recente +$ git diff HEAD +``` + +### grep + +Permite procurar facilmente num repositório + +Configurações opcionais: + +```bash +# Obrigado a Travis Jeffery por estas +# Define a apresentação de números de linha nos resultados do grep +$ git config --global grep.lineNumber true + +# Torna os resultados da pesquisa mais fáceis de ler, agrupando-os +$ git config --global alias.g "grep --break --heading --line-number" +``` + +```bash +# Pesquisa por "variableName" em todos os ficheiros de java +$ git grep 'variableName' -- '*.java' + +# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove" +$ git grep -e 'arrayListName' --and \( -e add -e remove \) +``` + +Google é teu amigo; para mais exemplos: +[Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja) + +### log + +Apresenta commits do repositório. + +```bash +# Apresenta todos os commits +$ git log + +# Apresenta X commits +$ git log -n 10 + +# Apresenta apenas commits de merge +$ git log --merges +``` + +### merge + +"Merge" (junta) as alterações de commits externos com o *branch* atual. + +```bash +# Junta o branch especificado com o atual +$ git merge branchName + +# Para gerar sempre um commit ao juntar os branches +$ git merge --no-ff branchName +``` + +### mv + +Alterar o nome ou mover um ficheiro. + +```bash +# Alterar o nome de um ficheiro +$ git mv HelloWorld.c HelloNewWorld.c + +# Mover um ficheiro +$ git mv HelloWorld.c ./new/path/HelloWorld.c + +# Forçar a alteração de nome ou mudança local +# "existingFile" já existe no directório, será sobre-escrito. +$ git mv -f myFile existingFile +``` + +### pull + +Puxa alterações de um repositório e junta-as com outro branch + +```bash +# Atualiza o repositório local, juntando as novas alterações +# do repositório remoto 'origin' e branch 'master' +# git pull <remote> <branch> +# git pull => aplica a predefinição => git pull origin master +$ git pull origin master + +# Juntar alterações do branch remote e fazer rebase commits do branch +# no repositório local, como: "git pull <remote> <branch>, git rebase <branch>" +$ git pull origin master --rebase +``` + +### push + +Enviar e juntar alterações de um branch para o seu branch correspondente +num repositório remoto. + +```bash +# Envia e junta as alterações de um repositório local +# para um remoto denominado "origin" no branch "master". +# git push <remote> <branch> +# git push => aplica a predefinição => git push origin master +$ git push origin master +``` + +### rebase (cautela!) + +Pega em todas as alterações que foram registadas num branch e volta a +aplicá-las em outro branch. +*Não deve ser feito rebase de commits que foram enviados para um repositório +público* + +```bash +# Faz Rebase de experimentBranch para master +# git rebase <basebranch> <topicbranch> +$ git rebase master experimentBranch +``` + +[Additional Reading (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing) + +### reset (cautela!) + +Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*, +*pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também +perigoso se não há certeza quanto ao que se está a fazer. + +```bash +# Restabelece a camada intermediária dr registo para o último +# commit (o directório fica sem alterações) +$ git reset + +# Restabelece a camada intermediária de registo para o último commit, e +# sobre-escreve o projecto atual +$ git reset --hard + +# Move a head do branch atual para o commit especificado, sem alterar o projecto. +# todas as alterações ainda existem no projecto +$ git reset 31f2bb1 + +# Inverte a head do branch atual para o commit especificado +# fazendo com que este esteja em sintonia com o directório do projecto +# Remove alterações não registadas e todos os commits após o commit especificado +$ git reset --hard 31f2bb1 +``` + +### rm + +O oposto de git add, git rm remove ficheiros do branch atual. + +```bash +# remove HelloWorld.c +$ git rm HelloWorld.c + +# Remove um ficheiro de um sub-directório +$ git rm /pather/to/the/file/HelloWorld.c +``` + +## Informação complementar (EN) + +* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1) + +* [git-scm - Video Tutorials](http://git-scm.com/videos) + +* [git-scm - Documentation](http://git-scm.com/docs) + +* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/) + +* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf) + +* [GitGuys](http://www.gitguys.com/) diff --git a/ruby-ecosystem.html.markdown b/ruby-ecosystem.html.markdown index c2a2087b..d186f712 100644 --- a/ruby-ecosystem.html.markdown +++ b/ruby-ecosystem.html.markdown @@ -121,9 +121,9 @@ dependency graph to resolve. # Testing -Testing is a large of ruby culture. Ruby comes with its own Unit-style testing -framework called minitest (Or TestUnit for ruby version 1.8.x). There are many -testing libraries with different goals. +Testing is a large part of ruby culture. Ruby comes with its own Unit-style +testing framework called minitest (Or TestUnit for ruby version 1.8.x). There +are many testing libraries with different goals. * TestUnit - Ruby 1.8's built-in "Unit-style" testing framework * minitest - Ruby 1.9/2.0's built-in testing framework diff --git a/ruby.html.markdown b/ruby.html.markdown index 80682682..b9ba83cb 100644 --- a/ruby.html.markdown +++ b/ruby.html.markdown @@ -403,4 +403,55 @@ end Human.bar # 0 Doctor.bar # nil +module ModuleExample + def foo + 'foo' + end +end + +# Including modules binds the methods to the object instance +# Extending modules binds the methods to the class instance + +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' + +# Callbacks when including and extending a module are executed + +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' ``` |