mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 01:51:38 +00:00
Merge remote-tracking branch 'adambard/master'
This commit is contained in:
Jacob Ward
commit
861ee64223
@ -5,13 +5,13 @@ contributors:
|
||||
- ["Jason Yeo", "https://github.com/jsyeo"]
|
||||
---
|
||||
|
||||
Extensible Data Notation or EDN for short is a format for serializing data.
|
||||
Extensible Data Notation (EDN) is a format for serializing data.
|
||||
|
||||
The notation is used internally by Clojure to represent programs and it also
|
||||
The notation is used internally by Clojure to represent programs. It is also
|
||||
used as a data transfer format like JSON. Though it is more commonly used in
|
||||
Clojure land, there are implementations of EDN for many other languages.
|
||||
Clojure, there are implementations of EDN for many other languages.
|
||||
|
||||
The main benefit of EDN over JSON and YAML is that it is extensible, which we
|
||||
The main benefit of EDN over JSON and YAML is that it is extensible. We
|
||||
will see how it is extended later on.
|
||||
|
||||
```Clojure
|
||||
@ -59,7 +59,7 @@ false
|
||||
; Vectors allow random access
|
||||
[:gelato 1 2 -2]
|
||||
|
||||
; Maps are associative data structures that associates the key with its value
|
||||
; Maps are associative data structures that associate the key with its value
|
||||
{:eggs 2
|
||||
:lemon-juice 3.5
|
||||
:butter 1}
|
||||
@ -68,7 +68,7 @@ false
|
||||
{[1 2 3 4] "tell the people what she wore",
|
||||
[5 6 7 8] "the more you see the more you hate"}
|
||||
|
||||
; You may use commas for readability. They are treated as whitespaces.
|
||||
; You may use commas for readability. They are treated as whitespace.
|
||||
|
||||
; Sets are collections that contain unique elements.
|
||||
#{:a :b 88 "huat"}
|
||||
@ -82,11 +82,11 @@ false
|
||||
#MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10}
|
||||
|
||||
; Let me explain this with a clojure example. Suppose I want to transform that
|
||||
; piece of edn into a MenuItem record.
|
||||
; piece of EDN into a MenuItem record.
|
||||
|
||||
(defrecord MenuItem [name rating])
|
||||
|
||||
; To transform edn to clojure values, I will need to use the built in EDN
|
||||
; To transform EDN to clojure values, I will need to use the built in EDN
|
||||
; reader, edn/read-string
|
||||
|
||||
(edn/read-string "{:eggs 2 :butter 1 :flour 5}")
|
||||
|
||||
@ -9,8 +9,10 @@ lang: es-es
|
||||
---
|
||||
|
||||
Brainfuck (con mayúscula sólo al inicio de una oración) es un
|
||||
lenguaje de programación mínimo, computacionalmente universal
|
||||
en tamaño con sólo 8 comandos.
|
||||
lenguaje de programación extremadamente pequeño, Turing completo con sólo 8 comandos.
|
||||
|
||||
Puedes probar brainfuck en tu navegador con [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
|
||||
```
|
||||
|
||||
@ -18,7 +20,7 @@ Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
|
||||
será ignorado.
|
||||
|
||||
Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
|
||||
en cero y un apuntador en la celda actual.
|
||||
en cero y un puntero apuntando la celda actual.
|
||||
|
||||
Existen ocho comandos:
|
||||
|
||||
@ -26,7 +28,7 @@ Existen ocho comandos:
|
||||
- : Decrementa 1 al valor de la celda actual.
|
||||
> : Mueve el apuntador a la siguiente celda. (a la derecha)
|
||||
< : Mueve el apuntador a la celda anterior. (a la izquierda)
|
||||
. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A')
|
||||
. : Imprime el valor en ASCII de la celda actual (p.e. 65 = 'A')
|
||||
, : Lee un caracter como input y lo escribe en la celda actual.
|
||||
[ : Si el valor en la celda actual es cero mueve el apuntador
|
||||
hasta el primer ']' que encuentre. Si no es cero sigue a la
|
||||
@ -37,7 +39,7 @@ Existen ocho comandos:
|
||||
|
||||
[ y ] forman un while. Obviamente, deben estar balanceados.
|
||||
|
||||
Ahora unos ejemplos de programas escritos con brainfuck.
|
||||
Estos son algunos ejemplos de programas escritos con brainfuck.
|
||||
|
||||
++++++ [ > ++++++++++ < - ] > +++++ .
|
||||
|
||||
@ -63,7 +65,7 @@ Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un
|
||||
cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
|
||||
terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
|
||||
|
||||
Ten en mente que los espacios son sólo para fines de legibilidad.
|
||||
Ten en cuenta que los espacios son sólo para fines de legibilidad.
|
||||
Es lo mismo escribir el ejemplo de arriba que esto:
|
||||
,[>+<-]>.
|
||||
|
||||
@ -81,7 +83,7 @@ hasta la próxima vez. Para resolver este problema también incrementamos la
|
||||
celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
|
||||
el resultado.
|
||||
```
|
||||
Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir
|
||||
Y eso es brainfuck. No es tan difícil, ¿verdad? Como diversión, puedes escribir
|
||||
tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
|
||||
intérprete es relativamente sencillo de hacer, pero si eres masoquista,
|
||||
intenta construir tu proprio intérprete de brainfuck... en brainfuck.
|
||||
puedes intentar construir tu propio intérprete de brainfuck... en brainfuck.
|
||||
|
||||
@ -18,11 +18,11 @@ versionar y administrar nuestro código fuente.
|
||||
|
||||
## Versionamiento, conceptos.
|
||||
|
||||
### Qué es el control de versiones?
|
||||
### ¿Qué es el control de versiones?
|
||||
El control de versiones es un sistema que guarda todos los cambios realizados en
|
||||
uno o varios archivos, a lo largo del tiempo.
|
||||
|
||||
### Versionamiento centralizado vs Versionamiento Distribuido.
|
||||
### Versionamiento centralizado vs versionamiento distribuido.
|
||||
|
||||
+ El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar
|
||||
archivos.
|
||||
@ -33,9 +33,9 @@ uno o varios archivos, a lo largo del tiempo.
|
||||
|
||||
[Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
|
||||
|
||||
### Por qué usar Git?
|
||||
### ¿Por qué usar Git?
|
||||
|
||||
* Se puede trabajar sin conexion.
|
||||
* Se puede trabajar sin conexión.
|
||||
* ¡Colaborar con otros es sencillo!.
|
||||
* Derivar, crear ramas del proyecto (aka: Branching) es fácil.
|
||||
* Combinar (aka: Merging)
|
||||
@ -47,7 +47,7 @@ uno o varios archivos, a lo largo del tiempo.
|
||||
### Repositorio
|
||||
|
||||
Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
|
||||
comits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
|
||||
commits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
|
||||
y que sus atributos otorgan acceso al historial del elemento, además de otras
|
||||
cosas.
|
||||
|
||||
@ -62,12 +62,12 @@ y mas.
|
||||
|
||||
### Directorio de trabajo (componentes del repositorio)
|
||||
|
||||
Es basicamente los directorios y archivos dentro del repositorio. La mayoría de
|
||||
Es básicamente los directorios y archivos dentro del repositorio. La mayoría de
|
||||
las veces se le llama "directorio de trabajo".
|
||||
|
||||
### Índice (componentes del directorio .git)
|
||||
|
||||
El índice es el área de inicio en git. Es basicamente la capa que separa el
|
||||
El índice es el área de inicio en git. Es básicamente la capa que separa el
|
||||
directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores
|
||||
más poder sobre lo que se envía y se recibe del repositorio.
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto
|
||||
// Cada sentencia puede ser terminada con punto y coma ;
|
||||
hazAlgo();
|
||||
|
||||
// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente
|
||||
// ... aunque no es necesario, ya que el punto y coma se agrega automáticamente
|
||||
// cada que se detecta una nueva línea, a excepción de algunos casos.
|
||||
hazAlgo()
|
||||
|
||||
@ -109,7 +109,7 @@ null == undefined; // = true
|
||||
null === undefined; // false
|
||||
|
||||
// Los Strings funcionan como arreglos de caracteres
|
||||
// Puedes accesar a cada caracter con la función charAt()
|
||||
// Puedes acceder a cada caracter con la función charAt()
|
||||
"Este es un String".charAt(0); // = 'E'
|
||||
|
||||
// ...o puedes usar la función substring() para acceder a pedazos más grandes
|
||||
@ -186,7 +186,7 @@ miObjeto.miLlave; // = "miValor"
|
||||
// agregar nuevas llaves.
|
||||
miObjeto.miTerceraLlave = true;
|
||||
|
||||
// Si intentas accesar con una llave que aún no está asignada tendrás undefined.
|
||||
// Si intentas acceder con una llave que aún no está asignada tendrás undefined.
|
||||
miObjeto.miCuartaLlave; // = undefined
|
||||
|
||||
///////////////////////////////////
|
||||
@ -301,7 +301,7 @@ i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, per
|
||||
//inmediatamente", que preveé variables temporales de fugarse al ámbito global
|
||||
(function(){
|
||||
var temporal = 5;
|
||||
// Podemos accesar al ámbito global asignando al 'objeto global', el cual
|
||||
// Podemos acceder al ámbito global asignando al 'objeto global', el cual
|
||||
// en un navegador siempre es 'window'. El objeto global puede tener
|
||||
// un nombre diferente en ambientes distintos, por ejemplo Node.js .
|
||||
window.permanente = 10;
|
||||
@ -321,7 +321,7 @@ function decirHolaCadaCincoSegundos(nombre){
|
||||
alert(texto);
|
||||
}
|
||||
setTimeout(interna, 5000);
|
||||
// setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos
|
||||
// setTimeout es asíncrono, así que la función decirHolaCadaCincoSegundos
|
||||
// terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos
|
||||
// Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene
|
||||
// acceso a la variable 'texto' cuando es llamada.
|
||||
@ -339,7 +339,7 @@ var miObjeto = {
|
||||
};
|
||||
miObjeto.miFuncion(); // = "¡Hola Mundo!"
|
||||
|
||||
// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables
|
||||
// Cuando las funciones de un objeto son llamadas, pueden acceder a las variables
|
||||
// del objeto con la palabra clave 'this'.
|
||||
miObjeto = {
|
||||
miString: "¡Hola Mundo!",
|
||||
@ -401,11 +401,11 @@ var MiConstructor = function(){
|
||||
miNuevoObjeto = new MiConstructor(); // = {miNumero: 5}
|
||||
miNuevoObjeto.miNumero; // = 5
|
||||
|
||||
// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una
|
||||
// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a acceder a una
|
||||
// propiedad en un objeto que no existe en el objeto el intérprete buscará en
|
||||
// el prototipo.
|
||||
|
||||
// Algunas implementaciones de JavaScript te permiten accesar al prototipo de
|
||||
// Algunas implementaciones de JavaScript te permiten acceder al prototipo de
|
||||
// un objeto con la propiedad __proto__. Mientras que esto es útil para explicar
|
||||
// prototipos, no es parte del estándar; veremos formas estándar de usar prototipos
|
||||
// más adelante.
|
||||
@ -440,7 +440,7 @@ miPrototipo.sentidoDeLaVida = 43;
|
||||
miObjeto.sentidoDeLaVida; // = 43
|
||||
|
||||
// Mencionabamos anteriormente que __proto__ no está estandarizado, y que no
|
||||
// existe una forma estándar de accesar al prototipo de un objeto. De todas formas.
|
||||
// existe una forma estándar de acceder al prototipo de un objeto. De todas formas.
|
||||
// hay dos formas de crear un nuevo objeto con un prototipo dado.
|
||||
|
||||
// El primer método es Object.create, el cual es una adición reciente a JavaScript,
|
||||
@ -476,7 +476,7 @@ typeof miNumero; // = 'number'
|
||||
typeof miNumeroObjeto; // = 'object'
|
||||
miNumero === miNumeroObjeyo; // = false
|
||||
if (0){
|
||||
// Este código no se ejecutara porque 0 es false.
|
||||
// Este código no se ejecutará porque 0 es false.
|
||||
}
|
||||
|
||||
// Aún así, los objetos que envuelven y los prototipos por defecto comparten
|
||||
|
||||
@ -21,22 +21,22 @@ JSON en su forma más pura no tiene comentarios, pero la mayoría de los parsead
|
||||
"llaves": "siempre debe estar entre comillas (ya sean dobles o simples)",
|
||||
"numeros": 0,
|
||||
"strings": "Høla, múndo. Todo el unicode está permitido, así como \"escapar\".",
|
||||
"soporta booleanos?": true,
|
||||
"vacios": null,
|
||||
"¿soporta booleanos?": true,
|
||||
"vacíos": null,
|
||||
|
||||
"numero grande": 1.2e+100,
|
||||
|
||||
"objetos": {
|
||||
"comentario": "La mayoria de tu estructura vendra de objetos.",
|
||||
"comentario": "La mayoría de tu estructura vendrá de objetos.",
|
||||
|
||||
"arreglo": [0, 1, 2, 3, "Los arreglos pueden contener cualquier cosa.", 5],
|
||||
|
||||
"otro objeto": {
|
||||
"comentario": "Estas cosas pueden estar anidadas, muy util."
|
||||
"comentario": "Estas cosas pueden estar anidadas, muy útil."
|
||||
}
|
||||
},
|
||||
|
||||
"tonteria": [
|
||||
"tontería": [
|
||||
{
|
||||
"fuentes de potasio": ["bananas"]
|
||||
},
|
||||
@ -50,10 +50,10 @@ JSON en su forma más pura no tiene comentarios, pero la mayoría de los parsead
|
||||
|
||||
"estilo alternativo": {
|
||||
"comentario": "Mira esto!"
|
||||
, "posicion de la coma": "no importa - mientras este antes del valor, entonces sera valido"
|
||||
, "otro comentario": "que lindo"
|
||||
, "posición de la coma": "no importa - mientras este antes del valor, entonces sera válido"
|
||||
, "otro comentario": "qué lindo"
|
||||
},
|
||||
|
||||
"eso fue rapido": "Y, estas listo. Ahora sabes todo lo que JSON tiene para ofrecer."
|
||||
"eso fue rapido": "Y, estás listo. Ahora sabes todo lo que JSON tiene para ofrecer."
|
||||
}
|
||||
```
|
||||
|
||||
@ -8,7 +8,7 @@ translators:
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le dévelopement des navigateurs,
|
||||
Au début du web, il n'y avait pas d'élements visuels, simplement du texte pur. Mais avec le dévelopement des navigateurs,
|
||||
des pages avec du contenu visuel sont arrivées.
|
||||
CSS est le langage standard qui existe et permet de garder une séparation entre
|
||||
le contenu (HTML) et le style d'une page web.
|
||||
@ -16,8 +16,8 @@ le contenu (HTML) et le style d'une page web.
|
||||
En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents
|
||||
sur une page HTML afin de leur donner des propriétés visuelles différentes.
|
||||
|
||||
Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parlons de CSS2.0
|
||||
qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateur.
|
||||
Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parler de CSS2.0
|
||||
qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateurs.
|
||||
|
||||
**NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage.
|
||||
Cet article porte principalement sur la syntaxe et quelques astuces.
|
||||
@ -33,7 +33,7 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
|
||||
/* Généralement, la première déclaration en CSS est très simple */
|
||||
selecteur { propriete: valeur; /* autres proprietés...*/ }
|
||||
|
||||
/* Le sélécteur sert à cibler un élément du HTML
|
||||
/* Le sélecteur sert à cibler un élément du HTML
|
||||
|
||||
Vous pouvez cibler tous les éléments d'une page! */
|
||||
* { color:red; }
|
||||
|
||||
264
fr-fr/d.html.markdown
Normal file
264
fr-fr/d.html.markdown
Normal file
@ -0,0 +1,264 @@
|
||||
---
|
||||
language: D
|
||||
filename: learnd-fr.d
|
||||
contributors:
|
||||
- ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
|
||||
translators:
|
||||
- ["Quentin Ladeveze", "aceawan.eu"]
|
||||
lang: fr-fr
|
||||
---
|
||||
|
||||
```d
|
||||
// Commençons par un classique
|
||||
module hello;
|
||||
|
||||
import std.stdio;
|
||||
|
||||
// args n'est pas obligatoire
|
||||
void main(string[] args) {
|
||||
writeln("Bonjour le monde !");
|
||||
}
|
||||
```
|
||||
|
||||
Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a
|
||||
de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/).
|
||||
D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient
|
||||
des fonctionnalités aussi bien de bas niveau que de haut niveau.
|
||||
|
||||
D est activement développé par de nombreuses personnes très intelligents, guidées par
|
||||
[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
|
||||
[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
|
||||
Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
|
||||
|
||||
```d
|
||||
import std.stdio;
|
||||
|
||||
void main() {
|
||||
//Les conditions et les boucles sont classiques.
|
||||
for(int i = 0; i < 10000; i++) {
|
||||
writeln(i);
|
||||
}
|
||||
|
||||
// On peut utiliser auto pour inférer automatiquement le
|
||||
// type d'une variable.
|
||||
auto n = 1;
|
||||
|
||||
// On peut faciliter la lecture des valeurs numériques
|
||||
// en y insérant des `_`.
|
||||
while(n < 10_000) {
|
||||
n += n;
|
||||
}
|
||||
|
||||
do {
|
||||
n -= (n / 2);
|
||||
} while(n > 0);
|
||||
|
||||
// For et while sont très utiles, mais en D, on préfère foreach.
|
||||
// Les deux points : '..', créent un intervalle continue de valeurs
|
||||
// incluant la première mais excluant la dernière.
|
||||
foreach(i; 1..1_000_000) {
|
||||
if(n % 2 == 0)
|
||||
writeln(i);
|
||||
}
|
||||
|
||||
// On peut également utiliser foreach_reverse pour itérer à l'envers.
|
||||
foreach_reverse(i; 1..int.max) {
|
||||
if(n % 2 == 1) {
|
||||
writeln(i);
|
||||
} else {
|
||||
writeln("Non !");
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
|
||||
`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
|
||||
De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
|
||||
|
||||
```d
|
||||
// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
|
||||
struct LinkedList(T) {
|
||||
T data = null;
|
||||
|
||||
// Utilisez '!' pour instancier un type paramétré.
|
||||
// Encore une fois semblable à '<T>'
|
||||
LinkedList!(T)* next;
|
||||
}
|
||||
|
||||
class BinTree(T) {
|
||||
T data = null;
|
||||
|
||||
// Si il n'y a qu'un seul paramètre de template,
|
||||
// on peut s'abstenir de mettre des parenthèses.
|
||||
BinTree!T left;
|
||||
BinTree!T right;
|
||||
}
|
||||
|
||||
enum Day {
|
||||
Sunday,
|
||||
Monday,
|
||||
Tuesday,
|
||||
Wednesday,
|
||||
Thursday,
|
||||
Friday,
|
||||
Saturday,
|
||||
}
|
||||
|
||||
// Utilisez alias pour créer des abreviations pour les types.
|
||||
alias IntList = LinkedList!int;
|
||||
alias NumTree = BinTree!double;
|
||||
|
||||
// On peut tout aussi bien créer des templates de function !
|
||||
T max(T)(T a, T b) {
|
||||
if(a < b)
|
||||
return b;
|
||||
|
||||
return a;
|
||||
}
|
||||
|
||||
// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé
|
||||
// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur.
|
||||
// Ici ils seront toujours passés par référence à 'swap()'.
|
||||
void swap(T)(ref T a, ref T b) {
|
||||
auto temp = a;
|
||||
|
||||
a = b;
|
||||
b = temp;
|
||||
}
|
||||
|
||||
// Avec les templates, on peut également passer des valeurs en paramètres.
|
||||
class Matrix(uint m, uint n, T = int) {
|
||||
T[m] rows;
|
||||
T[n] columns;
|
||||
}
|
||||
|
||||
auto mat = new Matrix!(3, 3); // T est 'int' par défaut
|
||||
|
||||
```
|
||||
À propos de classes, parlons des propriétés. Une propriété est, en gros,
|
||||
une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
|
||||
la syntaxe des structures classiques (`struct.x = 7`) comme si il
|
||||
s'agissait de méthodes getter ou setter.
|
||||
|
||||
```d
|
||||
// Considérons une classe paramétrée avec les types 'T' et 'U'
|
||||
class MyClass(T, U) {
|
||||
T _data;
|
||||
U _other;
|
||||
}
|
||||
|
||||
// Et des méthodes "getter" et "setter" comme suit:
|
||||
class MyClass(T, U) {
|
||||
T _data;
|
||||
U _other;
|
||||
|
||||
// Les constructeurs s'apellent toujours 'this'.
|
||||
this(T t, U u) {
|
||||
// Ceci va appeller les setters ci-dessous.
|
||||
data = t;
|
||||
other = u;
|
||||
}
|
||||
|
||||
// getters
|
||||
@property T data() {
|
||||
return _data;
|
||||
}
|
||||
|
||||
@property U other() {
|
||||
return _other;
|
||||
}
|
||||
|
||||
// setters
|
||||
@property void data(T t) {
|
||||
_data = t;
|
||||
}
|
||||
|
||||
@property void other(U u) {
|
||||
_other = u;
|
||||
}
|
||||
}
|
||||
|
||||
// Et on l'utilise de cette façon:
|
||||
void main() {
|
||||
auto mc = new MyClass!(int, string)(7, "seven");
|
||||
|
||||
// Importer le module 'stdio' de la bibliothèque standard permet
|
||||
// d'écrire dans la console (les imports peuvent être locaux à une portée)
|
||||
import std.stdio;
|
||||
|
||||
// On appelle les getters pour obtenir les valeurs.
|
||||
writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
|
||||
|
||||
// On appelle les setter pour assigner de nouvelles valeurs.
|
||||
mc.data = 8;
|
||||
mc.other = "eight";
|
||||
|
||||
// On appelle les setter pour obtenir les nouvelles valeurs.
|
||||
writefln("Later: data = %d, str = %s", mc.data, mc.other);
|
||||
}
|
||||
```
|
||||
Avec les propriétés, on peut constuire nos setters et nos getters
|
||||
comme on le souhaite, tout en gardant un syntaxe très propre,
|
||||
comme si on accédait directement à des membres de la classe.
|
||||
|
||||
Les autres fonctionnalités orientées objets à notre disposition
|
||||
incluent les interfaces, les classes abstraites, et la surcharge
|
||||
de méthodes. D gère l'héritage comme Java: On ne peut hériter que
|
||||
d'une seule classe et implémenter autant d'interface que voulu.
|
||||
|
||||
Nous venons d'explorer les fonctionnalités objet du D, mais changeons
|
||||
un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
|
||||
de premier ordre, les fonctions `pure` et les données immuables.
|
||||
De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
|
||||
sont disponibles dans le module `std.algorithm`.
|
||||
|
||||
```d
|
||||
import std.algorithm : map, filter, reduce;
|
||||
import std.range : iota; // construit un intervalle excluant la dernière valeur.
|
||||
|
||||
void main() {
|
||||
// On veut un algorithm qui affiche la somme de la listes des carrés
|
||||
// des entiers paires de 1 à 100. Un jeu d'enfant !
|
||||
|
||||
// On se content de passer des expressions lambda en paramètre à des templates.
|
||||
// On peut fournier au template n'importe quelle fonction, mais dans notre
|
||||
// cas, les lambdas sont pratiques.
|
||||
auto num = iota(1, 101).filter!(x => x % 2 == 0)
|
||||
.map!(y => y ^^ 2)
|
||||
.reduce!((a, b) => a + b);
|
||||
|
||||
writeln(num);
|
||||
}
|
||||
```
|
||||
|
||||
Vous voyez comme on a calculé `num` comme on le ferait en haskell par exemple ?
|
||||
C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax".
|
||||
Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière
|
||||
classique, ou comme un appelle à une méthode. Walter Brighter a écrit un
|
||||
article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
|
||||
Pour faire court, on peut appeller une fonction dont le premier paramètre
|
||||
est de type A, comme si c'était une méthode de A.
|
||||
|
||||
J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
|
||||
Voyons comment on le fait en D !
|
||||
|
||||
```d
|
||||
import std.stdio;
|
||||
import std.parallelism : parallel;
|
||||
import std.math : sqrt;
|
||||
|
||||
void main() {
|
||||
// On veut calculer la racine carré de tous les nombres
|
||||
// dans notre tableau, et profiter de tous les coeurs
|
||||
// à notre disposition.
|
||||
auto arr = new double[1_000_000];
|
||||
|
||||
// On utilise un index et une référence à chaque élément du tableau.
|
||||
// On appelle juste la fonction parallel sur notre tableau !
|
||||
foreach(i, ref elem; parallel(arr)) {
|
||||
ref = sqrt(i + 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
```
|
||||
174
fr-fr/perl-fr.html.markdown
Normal file
174
fr-fr/perl-fr.html.markdown
Normal file
@ -0,0 +1,174 @@
|
||||
---
|
||||
name: perl
|
||||
category: language
|
||||
language: perl
|
||||
filename: learnperl-fr.pl
|
||||
contributors:
|
||||
- ["Korjavin Ivan", "http://github.com/korjavin"]
|
||||
- ["Matteo Taroli", "http://www.matteotaroli.be"]
|
||||
translators:
|
||||
- ["Matteo Taroli", "http://www.matteotaroli.be"]
|
||||
lang: fr-fr
|
||||
---
|
||||
Perl 5 est un langage de programmation riche en fonctionnalité, avec plus de 25 ans de développement.
|
||||
|
||||
Perl 5 fonctionne sur plus de 100 plateformes, allant des pc portables aux mainframes et
|
||||
est autant adapté à un prototypage rapide qu'à des projets de grande envergure.
|
||||
|
||||
```perl
|
||||
# Les commentaires en une ligne commencent par un dièse
|
||||
|
||||
|
||||
#### Types de variables de Perl
|
||||
|
||||
# Les variables comment par un symbole précisant le type.
|
||||
# Un nom de variable valide commence par une lettre ou un underscore,
|
||||
# suivi d'un nombre quelconque de lettres, chiffres ou underscores.
|
||||
|
||||
### Perl a trois types principaux de variables: $scalaire, @tableau and %hash
|
||||
|
||||
## Scalaires
|
||||
# Un scalaire représente une valeur unique :
|
||||
my $animal = "chameau";
|
||||
my $reponse = 42;
|
||||
|
||||
# Les valeurs scalaires peuvent être des strings, des entiers ou des nombres à virgule flottante
|
||||
# et Perl les convertira automatiquement entre elles quand nécessaire.
|
||||
|
||||
## Tableaux
|
||||
# Un tableau représente une liste de valeurs :
|
||||
my @animaux = ("chameau", "lama", "chouette");
|
||||
my @nombres = (23, 42, 69);
|
||||
my @melange = ("chameau", 42, 1.23);
|
||||
|
||||
## Hashes
|
||||
# Un hash représente un ensemble de paires de clé/valeur :
|
||||
my %fruit_couleur = ("pomme", "rouge", "banane", "jaune");
|
||||
|
||||
# Vous pouvez utiliser des espaces et l'opérateur "=>" pour les disposer plus joliment :
|
||||
|
||||
my %fruit_couleur = (
|
||||
pomme => "rouge",
|
||||
banane => "jaune"
|
||||
);
|
||||
|
||||
# Les scalaires, tableaux et hashes sont plus amplement documentés dans le perldata
|
||||
# (perldoc perldata)
|
||||
|
||||
# Des types de données plus complexes peuvent être construits en utilisant des références,
|
||||
# vous permettant de construire des listes et des hashes à l'intérieur d'autres listes et hashes.
|
||||
|
||||
#### Conditions et boucles
|
||||
|
||||
# Perl possède la plupart des conditions et boucles habituelles.
|
||||
|
||||
if ($var) {
|
||||
...
|
||||
} elsif ($var eq 'bar') {
|
||||
...
|
||||
} else {
|
||||
...
|
||||
}
|
||||
|
||||
unless (condition) {
|
||||
...
|
||||
}
|
||||
# Ceci est fourni en tant que version plus lisible de "if (!condition)"
|
||||
|
||||
# la postcondition à la sauce Perl
|
||||
|
||||
print "Yow!" if $zippy;
|
||||
print "Nous n'avons pas de banane." unless $bananes;
|
||||
|
||||
# while
|
||||
while (condition) {
|
||||
...
|
||||
}
|
||||
|
||||
# boucle for et iteration
|
||||
for (my $i = 0; $i < $max; $i++) {
|
||||
print "l'index est $i";
|
||||
}
|
||||
|
||||
for (my $i = 0; $i < @elements; $i++) {
|
||||
print "L'élément courant est " . $elements[$i];
|
||||
}
|
||||
|
||||
for my $element (@elements) {
|
||||
print $element;
|
||||
}
|
||||
|
||||
# implicitement
|
||||
|
||||
# La variable de contexte scalaire $_ est utilisée par défaut dans différentes
|
||||
# situations, comme par exemple dans la boucle foreach ou en argument par défaut
|
||||
# de la plupart des fonctions pour en simplifier l'écriture.
|
||||
|
||||
# Dans l'exemple suivant, $_ prends successivement la valeur de
|
||||
# chaque élément de la liste.
|
||||
|
||||
for (@elements) {
|
||||
print; # affiche le contenu de $_
|
||||
}
|
||||
|
||||
|
||||
#### Expressions régulières
|
||||
|
||||
# Le support des expressions régulières par Perl est aussi large que profond
|
||||
# et est sujet à une longue documentation sur perlrequick, perlretut et ailleurs.
|
||||
# Cependant, pour faire court :
|
||||
|
||||
# Simple correspondance
|
||||
if (/foo/) { ... } # vrai si $_ contient "foo"
|
||||
if ($a =~ /foo/) { ... } # vrai si $a contient "foo"
|
||||
|
||||
# Simple substitution
|
||||
|
||||
$a =~ s/foo/bar/; # remplace le premier foo par bar dans $a
|
||||
$a =~ s/foo/bar/g; # remplace TOUTES LES INSTANCES de foo par bar dans $a
|
||||
|
||||
|
||||
#### Fichiers et E/S
|
||||
|
||||
# Vous pouvez ouvrir un fichier pour y écrire ou pour le lire avec la fonction "open()".
|
||||
|
||||
open(my $in, "<", "input.txt") or die "Impossible d'ouvrir input.txt: $!";
|
||||
open(my $out, ">", "output.txt") or die "Impossible d'ouvrir output.txt: $!";
|
||||
open(my $log, ">>", "my.log") or die "Impossible d'ouvrir my.log: $!";
|
||||
|
||||
# Vous pouvez lire depuis un descripteur de fichier grâce à l'opérateur "<>".
|
||||
# Dans un contexte scalaire, il lit une seule ligne depuis le descripteur de fichier
|
||||
# et dans un contexte de liste, il lit le fichier complet, assignant chaque ligne à un
|
||||
# élément de la liste :
|
||||
|
||||
my $ligne = <$in>
|
||||
my $lignes = <$in>
|
||||
|
||||
#### Ecrire des fonctions
|
||||
|
||||
# Ecrire des fonctions est facile :
|
||||
|
||||
sub logger {
|
||||
my $logmessage = shift;
|
||||
|
||||
open my $logfile, ">>", "my.log" or die "Impossible d'ouvrir my.log: $!";
|
||||
|
||||
print $logfile $logmessage;
|
||||
}
|
||||
|
||||
# Maintenant, nous pouvons utiliser cette fonction comme n'importe quelle fonction intégrée :
|
||||
|
||||
logger("On a une fonction de logging!!");
|
||||
```
|
||||
|
||||
#### Utiliser des modules Perl
|
||||
|
||||
Les modules Perl fournissent une palette de fonctionnalités vous évitant de réinventer la roue et peuvent être téléchargés depuis CPAN (http://www.cpan.org/). Un certain nombre de modules populaires sont inclus dans la distribution même de Perl.
|
||||
|
||||
Perlfaq contiens des questions et réponses liées aux tâches habituelles et propose souvent des suggestions quant aux bons modules à utiliser.
|
||||
|
||||
#### Pour en savoir plus
|
||||
- [perl-tutorial](http://perl-tutorial.org/)
|
||||
- [Learn at www.perl.com](http://www.perl.org/learn.html)
|
||||
- [perldoc](http://perldoc.perl.org/)
|
||||
- and perl built-in : `perldoc perlintro`
|
||||
@ -335,10 +335,10 @@ module DataTypeExamples =
|
||||
let worker = Worker jdoe
|
||||
|
||||
// ------------------------------------
|
||||
// Modelling with types
|
||||
// Modeling with types
|
||||
// ------------------------------------
|
||||
|
||||
// Union types are great for modelling state without using flags
|
||||
// Union types are great for modeling state without using flags
|
||||
type EmailAddress =
|
||||
| ValidEmailAddress of string
|
||||
| InvalidEmailAddress of string
|
||||
@ -526,7 +526,7 @@ module AsyncExample =
|
||||
|> Async.RunSynchronously // start them off
|
||||
|
||||
// ================================================
|
||||
// .NET compatability
|
||||
// .NET compatibility
|
||||
// ================================================
|
||||
|
||||
module NetCompatibilityExamples =
|
||||
|
||||
@ -561,7 +561,9 @@ of the language.
|
||||
|
||||
[Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with attached terminal
|
||||
|
||||
[Javascript: The Right Way][9] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices.
|
||||
[Eloquent Javascript - The Annotated Version][9] by Gordon Zhu is also a great derivative of Eloquent Javascript with extra explanations and clarifications for some of the more complicated examples.
|
||||
|
||||
[Javascript: The Right Way][10] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices.
|
||||
|
||||
|
||||
In addition to direct contributors to this article, some content is adapted from
|
||||
@ -577,4 +579,5 @@ Mozilla Developer Network.
|
||||
[6]: http://www.amazon.com/gp/product/0596805527/
|
||||
[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
|
||||
[8]: http://eloquentjavascript.net/
|
||||
[9]: http://jstherightway.org/
|
||||
[9]: http://watchandcode.com/courses/eloquent-javascript-the-annotated-version
|
||||
[10]: http://jstherightway.org/
|
||||
|
||||
@ -15,6 +15,7 @@ If you have any feedback please feel free to reach me at
|
||||
[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
|
||||
|
||||
```matlab
|
||||
%% Code sections start with two percent signs. Section titles go on the same line.
|
||||
% Comments start with a percent sign.
|
||||
|
||||
%{
|
||||
|
||||
@ -53,7 +53,7 @@ You shouldn't either
|
||||
10.* 5 #=> 50
|
||||
|
||||
# Special values are objects
|
||||
nil # Nothing to see here
|
||||
nil # equivalent to null in other languages
|
||||
true # truth
|
||||
false # falsehood
|
||||
|
||||
@ -131,7 +131,7 @@ puts "I'm printing!"
|
||||
|
||||
# print to the output without a newline
|
||||
print "I'm printing!"
|
||||
#=> I'm printing! => nill
|
||||
#=> I'm printing! => nil
|
||||
|
||||
# Variables
|
||||
x = 25 #=> 25
|
||||
|
||||
@ -9,13 +9,13 @@ filename: learnvisualbasic.vb
|
||||
Module Module1
|
||||
|
||||
Sub Main()
|
||||
' A Quick Overview of Visual Basic Console Applications before we dive
|
||||
' in to the deep end.
|
||||
' Apostrophe starts comments.
|
||||
' To Navigate this tutorial within the Visual Basic Complier, I've put
|
||||
' together a navigation system.
|
||||
' This navigation system is explained however as we go deeper into this
|
||||
' tutorial, you'll understand what it all means.
|
||||
'A Quick Overview of Visual Basic Console Applications before we dive
|
||||
'in to the deep end.
|
||||
'Apostrophe starts comments.
|
||||
'To Navigate this tutorial within the Visual Basic Complier, I've put
|
||||
'together a navigation system.
|
||||
'This navigation system is explained however as we go deeper into this
|
||||
'tutorial, you'll understand what it all means.
|
||||
Console.Title = ("Learn X in Y Minutes")
|
||||
Console.WriteLine("NAVIGATION") 'Display
|
||||
Console.WriteLine("")
|
||||
@ -32,9 +32,9 @@ Module Module1
|
||||
Console.WriteLine("50. About")
|
||||
Console.WriteLine("Please Choose A Number From The Above List")
|
||||
Dim selection As String = Console.ReadLine
|
||||
' The "Case" in the Select statement is optional.
|
||||
' For example, "Select selection" instead of "Select Case selection"
|
||||
' will also work.
|
||||
'The "Case" in the Select statement is optional.
|
||||
'For example, "Select selection" instead of "Select Case selection"
|
||||
'will also work.
|
||||
Select Case selection
|
||||
Case "1" 'HelloWorld Output
|
||||
Console.Clear() 'Clears the application and opens the private sub
|
||||
@ -91,12 +91,12 @@ Module Module1
|
||||
'Two
|
||||
Private Sub HelloWorldInput()
|
||||
Console.Title = "Hello World YourName | Learn X in Y Minutes"
|
||||
' Variables
|
||||
' Data entered by a user needs to be stored.
|
||||
' Variables also start with a Dim and end with an As VariableType.
|
||||
'Variables
|
||||
'Data entered by a user needs to be stored.
|
||||
'Variables also start with a Dim and end with an As VariableType.
|
||||
|
||||
' In this tutorial, we want to know what your name, and make the program
|
||||
' respond to what is said.
|
||||
'In this tutorial, we want to know what your name, and make the program
|
||||
'respond to what is said.
|
||||
Dim username As String
|
||||
'We use string as string is a text based variable.
|
||||
Console.WriteLine("Hello, What is your name? ") 'Ask the user their name.
|
||||
|
||||
@ -9,7 +9,7 @@ filename: whip.lisp
|
||||
---
|
||||
|
||||
Whip is a LISP-dialect made for scripting and simplified concepts.
|
||||
It has also borrowed a lot of functions and syntax from Haskell(a non-related language).
|
||||
It has also borrowed a lot of functions and syntax from Haskell (a non-related language).
|
||||
|
||||
These docs were written by the creator of the language himself. So is this line.
|
||||
|
||||
@ -172,12 +172,12 @@ undefined ; user to indicate a value that hasn't been set
|
||||
; Comprehensions
|
||||
|
||||
; `range` or `..` generates a list of numbers for
|
||||
; each number between it's two args.
|
||||
; each number between its two args.
|
||||
(range 1 5) ; => (1 2 3 4 5)
|
||||
(.. 0 2) ; => (0 1 2)
|
||||
|
||||
; `map` applies it's first arg(which should be a lambda/function)
|
||||
; to each item in the following arg(which should be a list)
|
||||
; `map` applies its first arg (which should be a lambda/function)
|
||||
; to each item in the following arg (which should be a list)
|
||||
(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
|
||||
|
||||
; Reduce
|
||||
|
||||
Loading…
Reference in New Issue
Block a user