iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 09:41:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove non-breaking spaces

Browse Source
This commit is contained in:
Boris Verkhovskiy 2024-12-18 17:58:08 -07:00
parent f888151153
commit 3ecbf961d3
32 changed files with 530 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ansible.md
View File

@ -352,7 +352,7 @@ Get familiar with how you can use roles in the simple_apache_role example
``` ```
playbooks/roles/simple_apache_role/ playbooks/roles/simple_apache_role/
├── tasks ├── tasks
│   └── main.yml │ └── main.yml
└── templates └── templates
└── main.yml └── main.yml
``` ```

8
bash.md
View File

@ -343,7 +343,7 @@ echo "#helloworld" | tee output.out >/dev/null
rm -v output.out error.err output-and-error.log rm -v output.out error.err output-and-error.log
rm -r tempDir/ # recursively delete rm -r tempDir/ # recursively delete
# You can install the `trash-cli` Python package to have `trash` # You can install the `trash-cli` Python package to have `trash`
# which puts files in the system trash and doesn't delete them directly # which puts files in the system trash and doesn't delete them directly
# see https://pypi.org/project/trash-cli/ if you want to be careful # see https://pypi.org/project/trash-cli/ if you want to be careful
# Commands can be substituted within other commands using $( ): # Commands can be substituted within other commands using $( ):
@ -360,7 +360,7 @@ case "$Variable" in
# List patterns for the conditions you want to meet # List patterns for the conditions you want to meet
0) echo "There is a zero.";; 0) echo "There is a zero.";;
1) echo "There is a one.";; 1) echo "There is a one.";;
*) echo "It is not null.";; # match everything *) echo "It is not null.";; # match everything
esac esac
# `for` loops iterate for as many arguments given: # `for` loops iterate for as many arguments given:
@ -462,8 +462,8 @@ cut -d ',' -f 1 file.txt
# replaces every occurrence of 'okay' with 'great' in file.txt # replaces every occurrence of 'okay' with 'great' in file.txt
# (regex compatible) # (regex compatible)
sed -i 's/okay/great/g' file.txt sed -i 's/okay/great/g' file.txt
# be aware that this -i flag means that file.txt will be changed # be aware that this -i flag means that file.txt will be changed
# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up) # -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
# print to stdout all lines of file.txt which match some regex # print to stdout all lines of file.txt which match some regex
# The example prints lines which begin with "foo" and end in "bar" # The example prints lines which begin with "foo" and end in "bar"

2
cs/python.md
View File

@ -610,7 +610,7 @@ for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
break break
# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo # Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
# hodně času i paměti, proto se místo toho čísla generují postupně. # hodně času i paměti, proto se místo toho čísla generují postupně.
for nasobek in nasobicka_2(range(900000000)): for nasobek in nasobicka_2(range(900000000)):
# Vypíše postupně: "Zpracovávám číslo 1", ..., "Zpracovávám číslo 5" # Vypíše postupně: "Zpracovávám číslo 1", ..., "Zpracovávám číslo 5"
if nasobek >= 10: if nasobek >= 10:

4
css.md
View File

@ -224,13 +224,13 @@ body {
/* Nest style rule inside another (CSS 3) */ /* Nest style rule inside another (CSS 3) */
.main { .main {
.bgred { /* same as: .main .bgred { } */ .bgred { /* same as: .main .bgred { } */
background: red; background: red;
} }
& .bggreen { /* same as: .main .bggreen { } */ & .bggreen { /* same as: .main .bggreen { } */
background: green; background: green;
} }
&.bgblue { /* (without space) same as: .main.bgblue { } */ &.bgblue { /* (without space) same as: .main.bgblue { } */
background: blue; background: blue;
} }
} }

10
cue.md
View File

@ -488,12 +488,12 @@ To make it concrete, consider the following:
``` ```
mymodule mymodule
├── config ├── config
│   ├── a.cue │ ├── a.cue
│   └── b.cue │ └── b.cue
├── cue.mod ├── cue.mod
│   ├── module.cue │ ├── module.cue
│   ├── pkg │ ├── pkg
│   └── usr │ └── usr
└── main.cue └── main.cue
``` ```

12
de/pythonlegacy.md
View File

@ -461,18 +461,18 @@ class Human(object):
return "*grunt*" return "*grunt*"
# Eine Eigenschaft (Property) ist wie ein Getter. # Eine Eigenschaft (Property) ist wie ein Getter.
    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen. # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben. # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
@property @property
def age(self): def age(self):
return self._age return self._age
    # Damit kann die Eigenschaft festgelegt werden # Damit kann die Eigenschaft festgelegt werden
@age.setter @age.setter
def age(self, age): def age(self, age):
self._age = age self._age = age
    # Damit kann die Eigenschaft gelöscht werden # Damit kann die Eigenschaft gelöscht werden
@age.deleter @age.deleter
def age(self): def age(self):
del self._age del self._age
@ -561,7 +561,7 @@ class Superhero(Human):
# Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse
# zugreifen, die vom untergeordneten Objekt überschrieben werden, # zugreifen, die vom untergeordneten Objekt überschrieben werden,
# in diesem Fall die Methode __init__. # in diesem Fall die Methode __init__.
        # Dies ruft den Konstruktor der übergeordneten Klasse auf: # Dies ruft den Konstruktor der übergeordneten Klasse auf:
super().__init__(name) super().__init__(name)
# überschreiben der "sing" Methode # überschreiben der "sing" Methode
@ -583,7 +583,7 @@ if __name__ == '__main__':
print('I am a superhero') print('I am a superhero')
# Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird. # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird.
    # Dieses Attribut ist dynamisch und kann aktualisiert werden. # Dieses Attribut ist dynamisch und kann aktualisiert werden.
print(Superhero.__mro__) # => (<class '__main__.Superhero'>, print(Superhero.__mro__) # => (<class '__main__.Superhero'>,
# => <class 'human.Human'>, <class 'object'>) # => <class 'human.Human'>, <class 'object'>)

2
el/python.md
View File

@ -523,7 +523,7 @@ next(our_iterator) # => "one"
next(our_iterator) # => "two" next(our_iterator) # => "two"
next(our_iterator) # => "three" next(our_iterator) # => "three"
# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration. # Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
next(our_iterator) # προκαλεί StopIteration next(our_iterator) # προκαλεί StopIteration
# Μπορείς να πάρεις όλα τα αντικείμενα ενός iteratior καλώντας list() πάνω του. # Μπορείς να πάρεις όλα τα αντικείμενα ενός iteratior καλώντας list() πάνω του.

12
es/c++.md
View File

@ -280,7 +280,7 @@ foo(bar(tempObjectFun()))
void constReferenceTempObjectFun() { void constReferenceTempObjectFun() {
// ConstRef obtiene el objeto temporal, y es válido hasta el final de esta // ConstRef obtiene el objeto temporal, y es válido hasta el final de esta
  // función. // función.
const string& constRef = tempObjectFun(); const string& constRef = tempObjectFun();
... ...
} }
@ -328,10 +328,10 @@ public:
Dog(); Dog();
// Declaraciones de funciones de la clase (implementaciones a seguir) // Declaraciones de funciones de la clase (implementaciones a seguir)
    // Nota que usamos std::string aquí en lugar de colocar // Nota que usamos std::string aquí en lugar de colocar
    // using namespace std; // using namespace std;
    // arriba. // arriba.
    // Nunca ponga una declaración "using namespace" en un encabezado. // Nunca ponga una declaración "using namespace" en un encabezado.
void setName(const std::string& dogsName); void setName(const std::string& dogsName);
void setWeight(int dogsWeight); void setWeight(int dogsWeight);
@ -471,7 +471,7 @@ public:
Point& operator+=(const Point& rhs); Point& operator+=(const Point& rhs);
// También tendría sentido añadir los operadores - y -=, // También tendría sentido añadir los operadores - y -=,
    // pero vamos a omitirlos por razones de brevedad. // pero vamos a omitirlos por razones de brevedad.
}; };
Point Point::operator+(const Point& rhs) const Point Point::operator+(const Point& rhs) const

54
es/fsharp.md
View File

@ -248,7 +248,7 @@ module EjemploDeSecuencia =
let secuencia1 = seq { yield "a"; yield "b" } let secuencia1 = seq { yield "a"; yield "b" }
// Las secuencias pueden usar yield y // Las secuencias pueden usar yield y
    // puede contener subsecuencias // puede contener subsecuencias
let extranio = seq { let extranio = seq {
// "yield" agrega un elemento // "yield" agrega un elemento
yield 1; yield 2; yield 1; yield 2;
@ -262,7 +262,7 @@ module EjemploDeSecuencia =
extranio |> Seq.toList extranio |> Seq.toList
// Las secuencias se pueden crear usando "unfold" // Las secuencias se pueden crear usando "unfold"
    // Esta es la secuencia de fibonacci // Esta es la secuencia de fibonacci
let fib = Seq.unfold (fun (fst,snd) -> let fib = Seq.unfold (fun (fst,snd) ->
Some(fst + snd, (snd, fst + snd))) (0,1) Some(fst + snd, (snd, fst + snd))) (0,1)
@ -278,8 +278,8 @@ module EejemploDeTipoDeDatos =
// Todos los datos son inmutables por defecto // Todos los datos son inmutables por defecto
     // las tuplas son tipos anónimos simples y rápidos // las tuplas son tipos anónimos simples y rápidos
     // - Usamos una coma para crear una tupla // - Usamos una coma para crear una tupla
let dosTuplas = 1,2 let dosTuplas = 1,2
let tresTuplas = "a",2,true let tresTuplas = "a",2,true
@ -301,7 +301,7 @@ module EejemploDeTipoDeDatos =
// ------------------------------------ // ------------------------------------
// Los tipos de unión (o variantes) tienen un conjunto de elección // Los tipos de unión (o variantes) tienen un conjunto de elección
     // Solo un caso puede ser válido a la vez. // Solo un caso puede ser válido a la vez.
// ------------------------------------ // ------------------------------------
// Usamos "type" con barra/pipe para definir una unión estándar // Usamos "type" con barra/pipe para definir una unión estándar
@ -326,7 +326,7 @@ module EejemploDeTipoDeDatos =
// ------------------------------------ // ------------------------------------
// Los tipos se pueden combinar recursivamente de formas complejas // Los tipos se pueden combinar recursivamente de formas complejas
    // sin tener que crear subclases // sin tener que crear subclases
type Empleado = type Empleado =
| Trabajador of Persona | Trabajador of Persona
| Gerente of Empleado lista | Gerente of Empleado lista
@ -349,9 +349,9 @@ module EejemploDeTipoDeDatos =
| DireccionDeCorreoInvalido direccion -> () // no enviar | DireccionDeCorreoInvalido direccion -> () // no enviar
// Combinar juntos, los tipos de unión y tipos de registro // Combinar juntos, los tipos de unión y tipos de registro
     // ofrece una base excelente para el diseño impulsado por el dominio. // ofrece una base excelente para el diseño impulsado por el dominio.
     // Puedes crear cientos de pequeños tipos que reflejarán fielmente // Puedes crear cientos de pequeños tipos que reflejarán fielmente
     // el dominio. // el dominio.
type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int } type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
type Pago = Pago of float type Pago = Pago of float
@ -368,17 +368,17 @@ module EejemploDeTipoDeDatos =
// ------------------------------------ // ------------------------------------
// Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar. // Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
     // * Inmutabilidad // * Inmutabilidad
     // * Bonita depuración de impresión // * Bonita depuración de impresión
     // * Igualdad y comparación // * Igualdad y comparación
     // * Serialización // * Serialización
     // La impresión bonita se usa con %A // La impresión bonita se usa con %A
printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A" printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
dosTuplas persona1 temp1 trabajador dosTuplas persona1 temp1 trabajador
// La igualdad y la comparación son innatas // La igualdad y la comparación son innatas
     // Aquí hay un ejemplo con tarjetas. // Aquí hay un ejemplo con tarjetas.
type JuegoDeCartas = Trebol | Diamante | Espada | Corazon type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
| Nueve | Diez | Jack | Reina | Rey | As | Nueve | Diez | Jack | Reina | Rey | As
@ -398,11 +398,11 @@ module EejemploDeTipoDeDatos =
module EjemplosDePatronesActivos = module EjemplosDePatronesActivos =
// F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos" // F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
    // donde el patrón puede ser analizado o detectado dinámicamente. // donde el patrón puede ser analizado o detectado dinámicamente.
    // "clips de banana" es la sintaxis de los patrones activos // "clips de banana" es la sintaxis de los patrones activos
    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ... // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
let (|Digito|Latra|EspacioEnBlanco|Otros|) ch = let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
if System.Char.IsDigit(ch) then Digito if System.Char.IsDigit(ch) then Digito
else if System.Char.IsLetter(ch) then Letra else if System.Char.IsLetter(ch) then Letra
@ -425,7 +425,7 @@ module EjemplosDePatronesActivos =
// ----------------------------------------- // -----------------------------------------
// Puede crear un patrón de coincidencia parcial también // Puede crear un patrón de coincidencia parcial también
    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide. // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
@ -447,7 +447,7 @@ module EjemplosDePatronesActivos =
module EjemploDeAlgoritmo = module EjemploDeAlgoritmo =
// F# tiene una alta relación señal / ruido, lo que permite leer el código // F# tiene una alta relación señal / ruido, lo que permite leer el código
    // casi como un algoritmo real // casi como un algoritmo real
// ------ Ejemplo: definir una función sumaDeCuadrados ------ // ------ Ejemplo: definir una función sumaDeCuadrados ------
let sumaDeCuadrados n = let sumaDeCuadrados n =
@ -464,7 +464,7 @@ module EjemploDeAlgoritmo =
// Si la lista está vacía // Si la lista está vacía
| [] -> | [] ->
[] // devolvemos una lista vacía [] // devolvemos una lista vacía
       // si la lista no está vacía // si la lista no está vacía
| primerElemento::otrosElementos -> // tomamos el primer elemento | primerElemento::otrosElementos -> // tomamos el primer elemento
let elementosMasPequenios = // extraemos los elementos más pequeños let elementosMasPequenios = // extraemos los elementos más pequeños
otrosElementos // tomamos el resto otrosElementos // tomamos el resto
@ -487,9 +487,9 @@ module EjemploDeAlgoritmo =
module AsyncExample = module AsyncExample =
// F# incluye características para ayudar con el código asíncrono // F# incluye características para ayudar con el código asíncrono
    // sin conocer la "pirámide del destino" // sin conocer la "pirámide del destino"
    // //
    // El siguiente ejemplo descarga una secuencia de página web en paralelo. // El siguiente ejemplo descarga una secuencia de página web en paralelo.
open System.Net open System.Net
open System open System
@ -531,9 +531,9 @@ module AsyncExample =
module EjemploCompatibilidadNet = module EjemploCompatibilidadNet =
// F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta // F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
    // perfectamente con bibliotecas .NET o Mono. // perfectamente con bibliotecas .NET o Mono.
  // ------- Trabaja con las funciones de las bibliotecas existentes ------- // ------- Trabaja con las funciones de las bibliotecas existentes -------
let (i1success,i1) = System.Int32.TryParse("123"); let (i1success,i1) = System.Int32.TryParse("123");
if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida" if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"
@ -559,7 +559,7 @@ module EjemploCompatibilidadNet =
// ------- Código orientado a objetos ------- // ------- Código orientado a objetos -------
// F# es también un verdadero lenguaje OO. // F# es también un verdadero lenguaje OO.
    // Admite clases, herencia, métodos virtuales, etc. // Admite clases, herencia, métodos virtuales, etc.
// interfaz de tipo genérico // interfaz de tipo genérico
type IEnumerator<'a> = type IEnumerator<'a> =

256
es/hy.md
View File

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

10
es/kotlin.md
View File

@ -36,7 +36,7 @@ fun main(args: Array<String>) {
/* /*
En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable, En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
de tal manera que no tenemos que especificarlo explícitamente cada vez. de tal manera que no tenemos que especificarlo explícitamente cada vez.
    Podemos declarar explícitamente el tipo de una variable así: Podemos declarar explícitamente el tipo de una variable así:
*/ */
val foo: Int = 7 val foo: Int = 7
@ -59,7 +59,7 @@ fun main(args: Array<String>) {
/* /*
Una cadena está delimitada por comillas triple ("""). Una cadena está delimitada por comillas triple (""").
    Estas cadenas pueden contener saltos de línea y otros caracteres. Estas cadenas pueden contener saltos de línea y otros caracteres.
*/ */
val fooRawString = """ val fooRawString = """
fun helloWorld(val name : String) { fun helloWorld(val name : String) {
@ -70,7 +70,7 @@ fun main(args: Array<String>) {
/* /*
Las cadenas pueden contener interpolación de cadenas. Las cadenas pueden contener interpolación de cadenas.
    La interpolación de cadenas comienza con un signo de dólar ($). La interpolación de cadenas comienza con un signo de dólar ($).
*/ */
val fooTemplateString = "$fooString tiene ${fooString.length} caracteres" val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
println(fooTemplateString) println(fooTemplateString)
@ -78,8 +78,8 @@ fun main(args: Array<String>) {
/* /*
Para que una variable pueda aceptar valor nulo se debe especificar Para que una variable pueda aceptar valor nulo se debe especificar
explícitamente como anulable añadiendole ? a su tipo. explícitamente como anulable añadiendole ? a su tipo.
    Podemos acceder a una variable anulable mediante el uso del operador ?. Podemos acceder a una variable anulable mediante el uso del operador ?.
    Podemos utilizar el operador ?: para especificar un valor alternativo Podemos utilizar el operador ?: para especificar un valor alternativo
a usar si una variable es nula. a usar si una variable es nula.
*/ */
var fooNullable: String? = "abc" var fooNullable: String? = "abc"

4
fr/c++.md
View File

@ -746,8 +746,8 @@ bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
// Suppose que chaque fonction retourne faux si elle échoue // Suppose que chaque fonction retourne faux si elle échoue
if (!faireQuelqueChoseAvecLeFichier(fh)) { if (!faireQuelqueChoseAvecLeFichier(fh)) {
       fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
       return false; // Propage l'erreur return false; // Propage l'erreur
} }
if (!faireAutreChoseAvec(fh)) { if (!faireAutreChoseAvec(fh)) {
fclose(fh); fclose(fh);

50
fr/livescript.md
View File

@ -93,7 +93,7 @@ fruits = <[ apple orange pear ]>
fruits[0] # => "apple" fruits[0] # => "apple"
# Les objets sont une collection non ordonnées de paires clé/valeur, et # Les objets sont une collection non ordonnées de paires clé/valeur, et
# d'autres choses (que nous verrons plus tard). # d'autres choses (que nous verrons plus tard).
person = person =
name: "Christina" name: "Christina"
likes: likes:
@ -101,7 +101,7 @@ person =
* "and other cute stuff" * "and other cute stuff"
# A nouveau, vous pouvez utiliser une expression plus consise à l'aide des # A nouveau, vous pouvez utiliser une expression plus consise à l'aide des
# accolades: # accolades:
person = {name: "Christina", likes: ["kittens", "and other cute stuff"]} person = {name: "Christina", likes: ["kittens", "and other cute stuff"]}
# Vous pouvez récupérer une entrée via sa clé: # Vous pouvez récupérer une entrée via sa clé:
@ -113,7 +113,7 @@ person["name"] # => "Christina"
trailing-space = /\s$/ # les mots-composés deviennent motscomposés trailing-space = /\s$/ # les mots-composés deviennent motscomposés
# A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs # A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs
# lignes! # lignes!
# (les commentaires et les espaces seront ignorés) # (les commentaires et les espaces seront ignorés)
funRE = // funRE = //
function\s+(.+) # nom function\s+(.+) # nom
@ -135,9 +135,9 @@ funRE = //
# Les comparaisons sont presque identiques, à l'exception que `==` équivaut au # Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la # `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la
# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes # comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
# (sans conversion de type) # (sans conversion de type)
2 == 2 # => true 2 == 2 # => true
2 == "2" # => false 2 == "2" # => false
2 ~= "2" # => true 2 ~= "2" # => true
@ -169,8 +169,8 @@ not false # => true
######################################################################## ########################################################################
# Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en # Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en
# charge des fonctions. En LiveScript, il est encore plus évident que les # charge des fonctions. En LiveScript, il est encore plus évident que les
# fonctions sont de premier ordre: # fonctions sont de premier ordre:
add = (left, right) -> left + right add = (left, right) -> left + right
add 1, 2 # => 3 add 1, 2 # => 3
@ -181,7 +181,7 @@ two!
# LiveScript utilise l'environnement de la fonction, comme JavaScript. # LiveScript utilise l'environnement de la fonction, comme JavaScript.
# A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de # A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de
# déclaration, et il déclarera toujours la variable située à gauche (sauf si # déclaration, et il déclarera toujours la variable située à gauche (sauf si
# la variable a été déclarée dans l'environnement parent). # la variable a été déclarée dans l'environnement parent).
# L'opérateur `:=` est disponible pour réutiliser un nom provenant de # L'opérateur `:=` est disponible pour réutiliser un nom provenant de
@ -189,18 +189,18 @@ two!
# Vous pouvez extraire les arguments d'une fonction pour récupérer # Vous pouvez extraire les arguments d'une fonction pour récupérer
# rapidement les valeurs qui vous intéressent dans une structure de données # rapidement les valeurs qui vous intéressent dans une structure de données
# complexe: # complexe:
tail = ([head, ...rest]) -> rest tail = ([head, ...rest]) -> rest
tail [1, 2, 3] # => [2, 3] tail [1, 2, 3] # => [2, 3]
# Vous pouvez également transformer les arguments en utilisant les opérateurs # Vous pouvez également transformer les arguments en utilisant les opérateurs
# binaires et unaires. Définir des arguments par défaut est aussi possible. # binaires et unaires. Définir des arguments par défaut est aussi possible.
foo = (a = 1, b = 2) -> a + b foo = (a = 1, b = 2) -> a + b
foo! # => 3 foo! # => 3
# You pouvez utiliser cela pour cloner un argument en particulier pour éviter # You pouvez utiliser cela pour cloner un argument en particulier pour éviter
# les effets secondaires. Par exemple: # les effets secondaires. Par exemple:
copy = (^^target, source) -> copy = (^^target, source) ->
for k,v of source => target[k] = v for k,v of source => target[k] = v
target target
@ -220,12 +220,12 @@ identity = -> it
identity 1 # => 1 identity 1 # => 1
# Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez # Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez
# facilement les transformer en fonction: # facilement les transformer en fonction:
divide-by-two = (/ 2) divide-by-two = (/ 2)
[2, 4, 8, 16].map(divide-by-two).reduce (+) [2, 4, 8, 16].map(divide-by-two).reduce (+)
# Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions # Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions
# composées d'autres fonctions: # composées d'autres fonctions:
double-minus-one = (- 1) . (* 2) double-minus-one = (- 1) . (* 2)
# En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>` # En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
@ -235,7 +235,7 @@ double-minus-one = (- 1) << (* 2)
# Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs # Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs
# `|>` et `<|`: # `|>` et `<|`:
map = (f, xs) --> xs.map f map = (f, xs) --> xs.map f
[1 2 3] |> map (* 2) # => [2 4 6] [1 2 3] |> map (* 2) # => [2 4 6]
@ -248,15 +248,15 @@ reduce = (f, xs, initial) --> xs.reduce f, initial
[1 2 3] |> reduce (+), _, 0 # => 6 [1 2 3] |> reduce (+), _, 0 # => 6
# Le tiret bas est également utilisé pour l'application partielle, # Le tiret bas est également utilisé pour l'application partielle,
# que vous pouvez utiliser pour toute fonction: # que vous pouvez utiliser pour toute fonction:
div = (left, right) -> left / right div = (left, right) -> left / right
div-by-two = div _, 2 div-by-two = div _, 2
div-by-two 4 # => 2 div-by-two 4 # => 2
# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel. # Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel.
# (mais vous devriez essayer des approches plus fonctionnelles, comme # (mais vous devriez essayer des approches plus fonctionnelles, comme
# Promises). # Promises).
# Un fonction de rappel est une fonction qui est passée en argument à une autre # Un fonction de rappel est une fonction qui est passée en argument à une autre
# fonction: # fonction:
@ -289,7 +289,7 @@ x = switch
| otherwise => \object # `otherwise` et `_` correspondent. | otherwise => \object # `otherwise` et `_` correspondent.
# Le corps des fonctions, les déclarations et les assignements disposent d'un # Le corps des fonctions, les déclarations et les assignements disposent d'un
# `switch` implicite, donc vous n'avez pas besoin de le réécrire: # `switch` implicite, donc vous n'avez pas besoin de le réécrire:
take = (n, [x, ...xs]) --> take = (n, [x, ...xs]) -->
| n == 0 => [] | n == 0 => []
| _ => [x] ++ take (n - 1), xs | _ => [x] ++ take (n - 1), xs
@ -300,14 +300,14 @@ take = (n, [x, ...xs]) -->
######################################################################## ########################################################################
# Comme en python, vous allez pouvoir utiliser les listes en compréhension, # Comme en python, vous allez pouvoir utiliser les listes en compréhension,
# ce qui permet de générer rapidement et de manière élégante une liste de # ce qui permet de générer rapidement et de manière élégante une liste de
# valeurs: # valeurs:
oneToTwenty = [1 to 20] oneToTwenty = [1 to 20]
evens = [x for x in oneToTwenty when x % 2 == 0] evens = [x for x in oneToTwenty when x % 2 == 0]
# `when` et `unless` peuvent être utilisés comme des filtres. # `when` et `unless` peuvent être utilisés comme des filtres.
# Cette technique fonctionne sur les objets de la même manière. Vous allez # Cette technique fonctionne sur les objets de la même manière. Vous allez
# pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante: # pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante:
copy = { [k, v] for k, v of source } copy = { [k, v] for k, v of source }
@ -317,8 +317,8 @@ copy = { [k, v] for k, v of source }
######################################################################## ########################################################################
# Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants # Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants
# outils pour la programmation objet. La syntaxe de déclaration d'une classe # outils pour la programmation objet. La syntaxe de déclaration d'une classe
# est héritée de CoffeeScript: # est héritée de CoffeeScript:
class Animal class Animal
(@name, kind) -> (@name, kind) ->
@kind = kind @kind = kind
@ -332,7 +332,7 @@ kitten = new Cat 'Mei'
kitten.purr! # => "*Mei (a cat) purrs*" kitten.purr! # => "*Mei (a cat) purrs*"
# En plus de l'héritage classique, vous pouvez utiliser autant de mixins # En plus de l'héritage classique, vous pouvez utiliser autant de mixins
# que vous voulez pour votre classe. Les mixins sont juste des objets: # que vous voulez pour votre classe. Les mixins sont juste des objets:
Huggable = Huggable =
hug: -> @action 'is hugged' hug: -> @action 'is hugged'

2
fr/racket.md
View File

@ -416,7 +416,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
(values i (number->string i))) (values i (number->string i)))
; => '#hash((1 . "1") (2 . "2") (3 . "3")) ; => '#hash((1 . "1") (2 . "2") (3 . "3"))
;; Il y a plein d'autres fonctions natives pour collecter des données à ;; Il y a plein d'autres fonctions natives pour collecter des données à
;; l'aide de boucles ;; l'aide de boucles
(for/sum ([i 10]) (* i i)) ; => 285 (for/sum ([i 10]) (* i i)) ; => 285
(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000 (for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000

376
fr/rust.md
View File

@ -35,271 +35,271 @@ Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts
// Les fonctions // Les fonctions
// `I32` est le type 32 bits entiers signés // `I32` est le type 32 bits entiers signés
fn add2(x: i32, y: i32) -> i32 { fn add2(x: i32, y: i32) -> i32 {
    // Retour implicite (pas de point virgule) // Retour implicite (pas de point virgule)
    x + y x + y
} }
// Fonction principale // Fonction principale
fn main() { fn main() {
    // Nombres // // Nombres //
    // Liaison immutable // Liaison immutable
    let x: i32 = 1; let x: i32 = 1;
    // Suffixes entiers et flottants // Suffixes entiers et flottants
    let y: I32 = 13i32; let y: I32 = 13i32;
    let f: f64 = 1.3f64; let f: f64 = 1.3f64;
    // Inférence de type // Inférence de type
    // La plupart du temps, le compilateur Rust peut déduire quel est le type // La plupart du temps, le compilateur Rust peut déduire quel est le type
// de variable, donc vous n'avez pas à écrire une annotation de type explicite. // de variable, donc vous n'avez pas à écrire une annotation de type explicite.
    // Tout au long de ce tutoriel, les types sont explicitement annotées dans // Tout au long de ce tutoriel, les types sont explicitement annotées dans
// de nombreux endroits, mais seulement à des fins de démonstration. // de nombreux endroits, mais seulement à des fins de démonstration.
// L'inférence de type peut les générer pour vous la plupart du temps. // L'inférence de type peut les générer pour vous la plupart du temps.
    let implicit_x = 1; let implicit_x = 1;
    let implicit_f = 1,3; let implicit_f = 1,3;
    // Arithmétique // Arithmétique
    let somme = x + y + 13; let somme = x + y + 13;
    // Variable Mutable // Variable Mutable
    let mut mutable = 1; let mut mutable = 1;
    let mutable = 4; let mutable = 4;
    let mutable += 2; let mutable += 2;
    // Chaînes // // Chaînes //
    // Chaîne littérales // Chaîne littérales
    let x: &str = "Bonjour tout le monde !"; let x: &str = "Bonjour tout le monde !";
    // Affichage // Affichage
    println!("{} {}", f, x); // 1.3 Bonjour tout le monde println!("{} {}", f, x); // 1.3 Bonjour tout le monde
    // Une `Chaîne` - une chaîne de tas alloué // Une `Chaîne` - une chaîne de tas alloué
    let s: String = "Bonjour tout le monde".to_string(); let s: String = "Bonjour tout le monde".to_string();
    // Un morceau de chaîne - une vue immutable sur une autre chaîne. // Un morceau de chaîne - une vue immutable sur une autre chaîne.
    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne // C'est essentiellement un pointeur immutable sur une chaîne - ça ne
    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
    // le début et la fin de la chaîne. // le début et la fin de la chaîne.
    let s_slice: &str = &s; let s_slice: &str = &s;
    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
    // Vecteurs/tableau // // Vecteurs/tableau //
    // Un tableau de taille fixe // Un tableau de taille fixe
    let four_ints: [i32; 4] = [1, 2, 3, 4]; let four_ints: [i32; 4] = [1, 2, 3, 4];
    // Un tableau dynamique(vecteur) // Un tableau dynamique(vecteur)
    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4]; let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
    vecteur.push(5); vecteur.push(5);
    // Une tranche - une vue immutable sur un vecteur ou un tableau. // Une tranche - une vue immutable sur un vecteur ou un tableau.
    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs. // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
    let tranche: &[i32] = &vecteur; let tranche: &[i32] = &vecteur;
    // Utiliser `{:?}` pour afficher quelque chose en mode debug // Utiliser `{:?}` pour afficher quelque chose en mode debug
    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
    // Tuples // // Tuples //
    // Un tuple est un ensemble de valeurs qui peuvent être de différents types. // Un tuple est un ensemble de valeurs qui peuvent être de différents types.
    let x:(i32, &str, f64) = (1, "bonjour", 3.4); let x:(i32, &str, f64) = (1, "bonjour", 3.4);
    // Déstructurer `let` // Déstructurer `let`
    let (a, b, c) = x; let (a, b, c) = x;
    println!("{} {} {}", a, b, c); // 1 bonjour 3.4 println!("{} {} {}", a, b, c); // 1 bonjour 3.4
    // indexation // indexation
    println!("{}", x.1); // Bonjour println!("{}", x.1); // Bonjour
    ////////////// //////////////
    // 2. Types // // 2. Types //
    ////////////// //////////////
    // Struct // Struct
    struct Point { struct Point {
        x: i32, x: i32,
        y: i32, y: i32,
    } }
    let origine: Point = Point { x: 0, y: 0 }; let origine: Point = Point { x: 0, y: 0 };
    // Un struct avec des champs sans nom, appelé 'tuple struct'. // Un struct avec des champs sans nom, appelé 'tuple struct'.
    struct Point2(i32, i32); struct Point2(i32, i32);
    let origine2 = Point2(0, 0); let origine2 = Point2(0, 0);
    // Basic C-like enum // Basic C-like enum
    enum Direction { enum Direction {
        Àgauche, Àgauche,
        Droite, Droite,
        En_Haut, En_Haut,
        Vers_Le_Bas, Vers_Le_Bas,
    } }
    let en_haut = Direction::En_Haut; let en_haut = Direction::En_Haut;
    // Enum avec des champs // Enum avec des champs
    enum OptionnelI32 { enum OptionnelI32 {
        AnI32(I32), AnI32(I32),
        Rien, Rien,
    } }
    let deux: OptionnelI32 = OptionnelI32::AnI32(2); let deux: OptionnelI32 = OptionnelI32::AnI32(2);
    let rien = OptionnelI32::Rien; let rien = OptionnelI32::Rien;
    // Generics // // Generics //
    struct Foo<T> { bar: T } struct Foo<T> { bar: T }
    // Ceci est défini dans la bibliothèque standard comme `Option`. // Ceci est défini dans la bibliothèque standard comme `Option`.
    enum Optionnel<T> { enum Optionnel<T> {
        SomeVal(T), SomeVal(T),
        NoVal, NoVal,
    } }
    // Méthodes // // Méthodes //
    impl<T> Foo<T> { impl<T> Foo<T> {
        // Méthodes prennent un paramètre explicite `de self`. // Méthodes prennent un paramètre explicite `de self`.
        fn get_bar(self) -> T { fn get_bar(self) -> T {
            self.bar self.bar
        } }
    } }
    let a_foo = Foo { bar: 1 }; let a_foo = Foo { bar: 1 };
    println!("{}", a_foo.get_bar()); // 1 println!("{}", a_foo.get_bar()); // 1
    // Traits (connu sous le nom des interfaces ou des classes de types dans // Traits (connu sous le nom des interfaces ou des classes de types dans
// d'autres langues). // d'autres langues).
    trait Frobnicate<T> { trait Frobnicate<T> {
        fn frobnicate(self) -> Option<T>; fn frobnicate(self) -> Option<T>;
    } }
    impl<T> Frobnicate<T> for Foo<T> { impl<T> Frobnicate<T> for Foo<T> {
        fn frobnicate(self) -> Option<T> { fn frobnicate(self) -> Option<T> {
            Some(self.bar) Some(self.bar)
        } }
    } }
    let another_foo = Foo { bar: 1 }; let another_foo = Foo { bar: 1 };
    println!("{:?}", another_foo.frobnicate()); // Some(1) println!("{:?}", another_foo.frobnicate()); // Some(1)
    ///////////////////////// /////////////////////////
    // 3. Motif correspondant // // 3. Motif correspondant //
    ///////////////////////// /////////////////////////
    let foo = OptionnelI32::AnI32(1); let foo = OptionnelI32::AnI32(1);
    match foo { match foo {
        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n), OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
        OptionnelI32::Rien => println!("Il n'y a rien!"), OptionnelI32::Rien => println!("Il n'y a rien!"),
    } }
    // Motif avancé correspondant // Motif avancé correspondant
    struct FooBar { x: i32, y: OptionnelI32 } struct FooBar { x: i32, y: OptionnelI32 }
    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) }; let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
    match bar { match bar {
        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} => FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
            println!("Les chiffres sont nuls!"), println!("Les chiffres sont nuls!"),
        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m => FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
            println!("Les chiffres sont les mêmes"), println!("Les chiffres sont les mêmes"),
        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} => FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
            println!("Différents numéros: {} {}", n, m)!, println!("Différents numéros: {} {}", n, m)!,
        FooBar { x: _, y: OptionnelI32 :: Rien} => FooBar { x: _, y: OptionnelI32 :: Rien} =>
            println!("Le deuxième numéro est rien!"), println!("Le deuxième numéro est rien!"),
    } }
    ///////////////////// /////////////////////
    // 4. Flux de contrôle // // 4. Flux de contrôle //
    ///////////////////// /////////////////////
    // `for` boucles / itération // `for` boucles / itération
    let array = [1, 2, 3]; let array = [1, 2, 3];
    for i in array { for i in array {
        println!("{}", i); println!("{}", i);
    } }
    // Ranges // Ranges
    for i in 0u32..10 { for i in 0u32..10 {
        print!("{}", i); print!("{}", i);
    } }
    println!(""); println!("");
    // imprime `0 1 2 3 4 5 6 7 8 9` // imprime `0 1 2 3 4 5 6 7 8 9`
    // `if` // `if`
    if 1 == 1 { if 1 == 1 {
        println!("Maths est travaille!"); println!("Maths est travaille!");
    } else { } else {
        println!("Oh non ...!"); println!("Oh non ...!");
    } }
    // `if` comme expression // `if` comme expression
    let valeur = if true { let valeur = if true {
        "bien" "bien"
    } else { } else {
        "mal" "mal"
    }; };
    // `while` boucle // `while` boucle
    while 1 == 1 { while 1 == 1 {
        println!("L'univers fonctionne normalement."); println!("L'univers fonctionne normalement.");
    } }
    // Boucle infinie // Boucle infinie
    loop { loop {
        println!("Bonjour!"); println!("Bonjour!");
    } }
    ///////////////////////////////// /////////////////////////////////
    // 5. Sécurité & pointeurs mémoire // // 5. Sécurité & pointeurs mémoire //
    ///////////////////////////////// /////////////////////////////////
// Pointeur occasion - une seule chose peut "posséder" pointeur à un moment. // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
    // Cela signifie que lorsque le `Box` laisse son champ d'application, il // Cela signifie que lorsque le `Box` laisse son champ d'application, il
// peut être automatiquement libérée en toute sécurité. // peut être automatiquement libérée en toute sécurité.
    let mut mine: Box<i32> = Box::new(3); let mut mine: Box<i32> = Box::new(3);
    *mine = 5; // déréférencer *mine = 5; // déréférencer
    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes, // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
// `mine` est déplacé. // `mine` est déplacé.
    let mut now_its_mine = mine; let mut now_its_mine = mine;
    *now_its_mine += 2; *now_its_mine += 2;
    println!("{}", now_its_mine); // 7 println!("{}", now_its_mine); // 7
    // println!("{}", now_its_mine); // Cela ne compile pas parce // println!("{}", now_its_mine); // Cela ne compile pas parce
// que `now_its_mine` possède maintenant le pointeur // que `now_its_mine` possède maintenant le pointeur
    // Référence - un pointeur immutable qui fait référence à d'autres données. // Référence - un pointeur immutable qui fait référence à d'autres données.
    // Quand une référence est prise à une valeur, nous disons que la valeur // Quand une référence est prise à une valeur, nous disons que la valeur
// a été "emprunté". // a été "emprunté".
    // Même si une valeur est emprunté immutablement, il ne peut pas être // Même si une valeur est emprunté immutablement, il ne peut pas être
// muté ou déplacé. // muté ou déplacé.
    // Un emprunt dure jusqu'à la fin de la portée, il a été créé. // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
    let mut var = 4; let mut var = 4;
    var = 3; var = 3;
    let ref_var: &i32 = &var; let ref_var: &i32 = &var;
    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
    println!("{}", *ref_var); println!("{}", *ref_var);
    // Var = 5; // Cela ne compile pas parce que `var` est emprunté. // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
// référence immutable. // référence immutable.
    // Référence Mutable // Référence Mutable
    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être // Même si une valeur est empruntée de façon mutable, elle ne peut pas être
// accessible à tous. // accessible à tous.
    let mut var2 = 4; let mut var2 = 4;
    let ref_var2: &mut i32 = &mut var2; let ref_var2: &mut i32 = &mut var2;
// '*' est utilisé pour pointer vers le var2 mutably emprunté. // '*' est utilisé pour pointer vers le var2 mutably emprunté.
*ref_var2 += 2; *ref_var2 += 2;
println!("{}", * ref_var2); // 6, // var2 ne compilerait pas. println!("{}", * ref_var2); // 6, // var2 ne compilerait pas.
    // ref_var2 est de type &mut i32 donc stocke la référence à i32, // ref_var2 est de type &mut i32 donc stocke la référence à i32,
// pas la valeur. // pas la valeur.
    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté. // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
} }
``` ```

14
fr/xml.md
View File

@ -41,10 +41,10 @@ Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les inf
Il commence par une déclaration, qui informe certaines métadonnées (en option). Il commence par une déclaration, qui informe certaines métadonnées (en option).
XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a
   trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ... trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre
   les balises d'ouverture et de fermeture. --> les balises d'ouverture et de fermeture. -->
<!-- XML porte deux types d'informations: <!-- XML porte deux types d'informations:
@ -72,7 +72,7 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
```xml ```xml
<!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie, <!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie,
   avec l'addition de définition DTD. --> avec l'addition de définition DTD. -->
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note SYSTEM "Librairie.dtd"> <!DOCTYPE note SYSTEM "Librairie.dtd">
@ -95,10 +95,10 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
]> ]>
<!-- La DTD commence par une déclaration. <!-- La DTD commence par une déclaration.
   Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants. Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants.
   Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut
   appelé «catégorie», avec «littérature» comme valeur par défaut. appelé «catégorie», avec «littérature» comme valeur par défaut.
   Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
(Anglais: «parsed character data») --> (Anglais: «parsed character data») -->
<!-- La DTD pourrait être déclarée dans le fichier XML lui-même --> <!-- La DTD pourrait être déclarée dans le fichier XML lui-même -->

10
id/smallbasic.md
View File

@ -28,7 +28,7 @@ print "halo"
REM Struktur kontrol REM Struktur kontrol
FOR index = 0 TO 10 STEP 2 FOR index = 0 TO 10 STEP 2
  ? "Ini adalah nomor baris"; indeks ? "Ini adalah nomor baris"; indeks
NEXT NEXT
J=0 J=0
REPEAT REPEAT
@ -57,10 +57,10 @@ End Try
REM Fungsi dan subrutin buatan pengguna REM Fungsi dan subrutin buatan pengguna
func add2(x, y) func add2(x, y)
  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC 'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
  local k local k
  k = "k akan lenyap ketika FUNC ini mengembalikan nilai" k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
  add2 = x + y add2 = x + y
akhir akhir
Print add2(5,5) Print add2(5,5)
sub cetak_ini(ini) sub cetak_ini(ini)

30
id/xml.md
View File

@ -95,23 +95,23 @@ Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan pengura
</tokobuku> </tokobuku>
<!-- Di atas adalah contoh file XML biasa. <!-- Di atas adalah contoh file XML biasa.
   Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional). Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
  
   XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku', XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki
node-node anak, dan seterusnya ... node-node anak, dan seterusnya ...
  
   Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
berada di antara tag buka dan tutup .--> berada di antara tag buka dan tutup .-->
<!-- XML membawa dua jenis data: <!-- XML membawa dua jenis data:
   1 - Atribut -> Itu metadata tentang sebuah node. 1 - Atribut -> Itu metadata tentang sebuah node.
       Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag. benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag.
   2 - Elemen -> Itu data yang murni. 2 - Elemen -> Itu data yang murni.
       Itulah yang parser akan mengambil dari file XML. Itulah yang parser akan mengambil dari file XML.
       Elemen muncul antara tag membuka dan menutup.--> Elemen muncul antara tag membuka dan menutup.-->
<!-- Di bawah ini, unsur dengan dua atribut--> <!-- Di bawah ini, unsur dengan dua atribut-->
@ -131,7 +131,7 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
```xml ```xml
<!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku, <!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku,
  dengan penambahan definisi DTD .--> dengan penambahan definisi DTD .-->
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE catatan SYSTEM "tokobuku.dtd"> <!DOCTYPE catatan SYSTEM "tokobuku.dtd">
@ -155,10 +155,10 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
<!-- DTD dimulai dengan deklarasi. <!-- DTD dimulai dengan deklarasi.
  Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'. Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
  Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
  disebut 'kategori', dengan "Sastra" sebagai nilai default. disebut 'kategori', dengan "Sastra" sebagai nilai default.
  Node yang 'judul' dan 'harga' mengandung karakter data diurai .--> Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
<!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .--> <!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .-->

4
it/rst.md
View File

@ -57,13 +57,13 @@ Le liste sono semplici come in Markdown:
- primo articolo - primo articolo
- Secondo elemento - Secondo elemento
     - Sottoelemento - Sottoelemento
oppure oppure
* Primo elemento * Primo elemento
* Secondo elemento * Secondo elemento
     * Sottoelemento * Sottoelemento
Le tabelle sono molto semplici da inserire: Le tabelle sono molto semplici da inserire:

8
julia.md
View File

@ -94,8 +94,8 @@ false
'a' 'a'
# Strings are UTF8 encoded, so strings like "π" or "☃" are not directly equivalent # Strings are UTF8 encoded, so strings like "π" or "☃" are not directly equivalent
# to an array of single characters. # to an array of single characters.
# Only if they contain only ASCII characters can they be safely indexed. # Only if they contain only ASCII characters can they be safely indexed.
ascii("This is a string")[1] # => 'T' ascii("This is a string")[1] # => 'T'
# => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase) # => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
# Beware, Julia indexes everything from 1 (like MATLAB), not 0 (like most languages). # Beware, Julia indexes everything from 1 (like MATLAB), not 0 (like most languages).
@ -114,7 +114,7 @@ ascii("This is a string")[1] # => 'T'
println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you! println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you!
# Another way to format strings is the printf macro from the stdlib Printf. # Another way to format strings is the printf macro from the stdlib Printf.
using Printf # this is how you load (or import) a module using Printf # this is how you load (or import) a module
@printf "%d is less than %f\n" 4.5 5.3 # => 5 is less than 5.300000 @printf "%d is less than %f\n" 4.5 5.3 # => 5 is less than 5.300000
@ -392,7 +392,7 @@ end
for animal = ["dog", "cat", "mouse"] for animal = ["dog", "cat", "mouse"]
println("$animal is a mammal") println("$animal is a mammal")
# You can use $ to interpolate variables or expression into strings. # You can use $ to interpolate variables or expression into strings.
# In this special case, no need for parenthesis: $animal and $(animal) give the same # In this special case, no need for parenthesis: $animal and $(animal) give the same
end end
# => dog is a mammal # => dog is a mammal
# => cat is a mammal # => cat is a mammal

2
latex.md
View File

@ -202,7 +202,7 @@ We can also insert Tables in the same way as figures.
% the {} arguments below describe how each row of the table is drawn. % the {} arguments below describe how each row of the table is drawn.
% The basics are simple: one letter for each column, to control alignment: % The basics are simple: one letter for each column, to control alignment:
% basic options are: c, l, r and p for centered, left, right and paragraph % basic options are: c, l, r and p for centered, left, right and paragraph
% optionally, you can add a | for a vertical line % optionally, you can add a | for a vertical line
% See https://en.wikibooks.org/wiki/LaTeX/Tables for more details % See https://en.wikibooks.org/wiki/LaTeX/Tables for more details
\begin{tabular}{c|cc} % here it means "centered | vertical line, centered centered" \begin{tabular}{c|cc} % here it means "centered | vertical line, centered centered"
Number & First Name & Last Name \\ % Column rows are separated by & Number & First Name & Last Name \\ % Column rows are separated by &

2
mips.md
View File

@ -244,7 +244,7 @@ gateways and routers.
## FUNCTIONS ## ## FUNCTIONS ##
_functions: _functions:
# Functions are callable procedures that can accept arguments and return # Functions are callable procedures that can accept arguments and return
# values all denoted with labels, like above # values all denoted with labels, like above
main: # Programs begin with main func main: # Programs begin with main func
jal return_1 # jal will store the current PC in $ra jal return_1 # jal will store the current PC in $ra

2
pl/java.md
View File

@ -119,7 +119,7 @@ public class LearnJava {
// Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość> // Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
int barInt = 1; int barInt = 1;
// Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością // Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
// rodzaj <nazwa1>, <nazwa2>, <nazwa3> // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
// <nazwa1> = <nazwa2> = <nazwa3> = <wartość> // <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
int barInt1, barInt2, barInt3; int barInt1, barInt2, barInt3;

10
pt-br/csharp.md
View File

@ -106,7 +106,7 @@ namespace Learning.CSharp
char fooChar = 'A'; char fooChar = 'A';
// Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor, // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)"; string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
Console.WriteLine(fooString); Console.WriteLine(fooString);
@ -732,9 +732,9 @@ on a new line! ""Wow!"", the masses cried";
} }
// Você também pode definir uma propriedade automática em uma linha // Você também pode definir uma propriedade automática em uma linha
        // Esta sintaxe criará um campo de apoio automaticamente. // Esta sintaxe criará um campo de apoio automaticamente.
        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos) // Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
        // para restringir seu acesso: // para restringir seu acesso:
public bool IsBroken { get; private set; } public bool IsBroken { get; private set; }
// Properties can be auto-implemented // Properties can be auto-implemented
@ -856,7 +856,7 @@ on a new line! ""Wow!"", the masses cried";
/// <summary> /// <summary>
/// Exemplo de como conectar-se ao DB via LinqToSql. /// Exemplo de como conectar-se ao DB via LinqToSql.
    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional) /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// </summary> /// </summary>
public class BikeRepository : DbContext public class BikeRepository : DbContext

20
pt-br/java.md
View File

@ -413,7 +413,7 @@ class Velocipede extends Bicicleta {
// Exemplo - Comida: // Exemplo - Comida:
public interface Comestivel { public interface Comestivel {
public void comer(); // Qualquer classe que implementa essa interface, deve public void comer(); // Qualquer classe que implementa essa interface, deve
                        // implementar este método. // implementar este método.
} }
public interface Digestivel { public interface Digestivel {
@ -483,8 +483,8 @@ public abstract class Animal
} }
// Não há necessidade de inicializar, no entanto, em uma interface // Não há necessidade de inicializar, no entanto, em uma interface
    // a variável é implicitamente final e, portanto, tem // a variável é implicitamente final e, portanto, tem
    // de ser inicializada. // de ser inicializada.
protected int idade; protected int idade;
public void mostrarIdade() public void mostrarIdade()
@ -503,7 +503,7 @@ class Cachorro extends Animal
{ {
// Nota: ainda precisamos substituir os métodos abstratos na // Nota: ainda precisamos substituir os métodos abstratos na
    // classe abstrata. // classe abstrata.
@Override @Override
public void fazerSom() public void fazerSom()
{ {
@ -512,10 +512,10 @@ class Cachorro extends Animal
} }
// NOTA: Você receberá um erro se usou a // NOTA: Você receberá um erro se usou a
    // anotação Override aqui, uma vez que java não permite // anotação Override aqui, uma vez que java não permite
    // sobrescrita de métodos estáticos. // sobrescrita de métodos estáticos.
    // O que está acontecendo aqui é chamado de "esconder o método". // O que está acontecendo aqui é chamado de "esconder o método".
    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/ // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
public static void main(String[] args) public static void main(String[] args)
{ {
Cachorro pluto = new Cachorro(); Cachorro pluto = new Cachorro();
@ -540,7 +540,7 @@ class Cachorro extends Animal
public final class TigreDenteDeSabre extends Animal public final class TigreDenteDeSabre extends Animal
{ {
// Nota: Ainda precisamos substituir os métodos abstratos na // Nota: Ainda precisamos substituir os métodos abstratos na
    // classe abstrata. // classe abstrata.
@Override @Override
public void fazerSom(); public void fazerSom();
{ {
@ -555,7 +555,7 @@ public abstract class Mamifero()
// <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>) // <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
// Métodos finais, como classes finais, não podem ser substituídos por uma classe filha, // Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
    // e são, portanto, a implementação final do método. // e são, portanto, a implementação final do método.
public final boolean EImpulsivo() public final boolean EImpulsivo()
{ {
return true; return true;

34
pt-br/sass.md
View File

@ -131,10 +131,10 @@ div {
/* Sass fornece funções que podem ser utilizados para realizar uma variedade de /* Sass fornece funções que podem ser utilizados para realizar uma variedade de
    tarefas. Considere o seguinte */ tarefas. Considere o seguinte */
/* Funções pode ser chamado usando seu nome e passando o /* Funções pode ser chamado usando seu nome e passando o
    argumentos necessários */ argumentos necessários */
body { body {
width: round(10.25px); width: round(10.25px);
@ -162,7 +162,7 @@ body {
reutilizável. */ reutilizável. */
/* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular /* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular
   e voltar a percentagem */ e voltar a percentagem */
@function calculate-percentage($target-size, $parent-size) { @function calculate-percentage($target-size, $parent-size) {
@return $target-size / $parent-size * 100%; @return $target-size / $parent-size * 100%;
@ -219,11 +219,11 @@ $main-content: calculate-percentage(600px, 960px);
} }
/* Ao ampliar uma declaração CSS é preferível a criação de um mixin, /* Ao ampliar uma declaração CSS é preferível a criação de um mixin,
   por causa da maneira em que agrupa as classes com todos que compartilham por causa da maneira em que agrupa as classes com todos que compartilham
   o mesmo estilo base. Se isso for feito com um mixin, a largura, o mesmo estilo base. Se isso for feito com um mixin, a largura,
   altura, e a borda seria duplicado para cada instrução que altura, e a borda seria duplicado para cada instrução que
   o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */ adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
@ -293,8 +293,8 @@ ul li a {
/* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass /* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass
   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css. código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
   Parciais não são geradas em CSS. */ Parciais não são geradas em CSS. */
@ -309,9 +309,9 @@ ol {
} }
/* Sass oferece @import que pode ser usado para importar parciais em um arquivo. /* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
   Isso difere da declaração CSS @import tradicional, que faz Isso difere da declaração CSS @import tradicional, que faz
   outra solicitação HTTP para buscar o arquivo importado. Sass converte os outra solicitação HTTP para buscar o arquivo importado. Sass converte os
   arquivo importados e combina com o código compilado. */ arquivo importados e combina com o código compilado. */
@import 'reset'; @import 'reset';
@ -339,9 +339,9 @@ body {
/* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você /* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você
   deseja criar uma instrução CSS que foi usado exclusivamente com @extend, deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
   de '.' ou '#'. Placeholder não aparece no CSS compilado. */ de '.' ou '#'. Placeholder não aparece no CSS compilado. */
%content-window { %content-window {
font-size: 14px; font-size: 14px;
@ -375,7 +375,7 @@ body {
/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
   ser úteis para calcular os valores diretamente no seu arquivos Sass em vez ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
de usar valores que você já calcula manualmente. O exemplo abaixo é de usar valores que você já calcula manualmente. O exemplo abaixo é
de um projeto simples de duas colunas. */ de um projeto simples de duas colunas. */

2
raku.md
View File

@ -6,7 +6,7 @@ contributors:
- ["Samantha McVey", "https://cry.nu"] - ["Samantha McVey", "https://cry.nu"]
--- ---
Raku (formerly Perl 6) is a highly capable, feature-rich programming language Raku (formerly Perl 6) is a highly capable, feature-rich programming language
made for at least the next hundred years. made for at least the next hundred years.
The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on

6
ru/c.md
View File

@ -33,7 +33,7 @@ translators:
void function_1(); void function_1();
void function_2(); void function_2();
// Точка входа в программу – это функция main. // Точка входа в программу – это функция main.
int main() { int main() {
// для форматированного вывода в консоль используется printf // для форматированного вывода в консоль используется printf
// %d – означает, что будем выводить целое число, \n переводит указатель вывода // %d – означает, что будем выводить целое число, \n переводит указатель вывода
@ -120,7 +120,7 @@ int main() {
printf("%d\n", a_string[16]); // => 0 printf("%d\n", a_string[16]); // => 0
// байт #17 тоже равен 0 (а также 18, 19, и 20) // байт #17 тоже равен 0 (а также 18, 19, и 20)
// Если между одинарными кавычками есть символ – это символьный литерал, // Если между одинарными кавычками есть символ – это символьный литерал,
// но это тип int, а не char (по историческим причинам). // но это тип int, а не char (по историческим причинам).
int cha = 'a'; // хорошо int cha = 'a'; // хорошо
@ -325,7 +325,7 @@ int main() {
// Вы также можете динамически выделять несколько блоков памяти с помощью // Вы также можете динамически выделять несколько блоков памяти с помощью
// функции malloc из стандартной библиотеки, которая принимает один // функции malloc из стандартной библиотеки, которая принимает один
// аргумент типа size_t – количество байт необходимых для выделения. // аргумент типа size_t – количество байт необходимых для выделения.
int *my_ptr = malloc(sizeof(*my_ptr) * 20); int *my_ptr = malloc(sizeof(*my_ptr) * 20);
for (xx = 0; xx < 20; xx++) { for (xx = 0; xx < 20; xx++) {
*(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx

4
stylus.md
View File

@ -81,8 +81,8 @@ a {
/* /*
You can store a CSS value (such as the color) of a variable. You can store a CSS value (such as the color) of a variable.
  Although it is optional, it is recommended to add $ before a variable name Although it is optional, it is recommended to add $ before a variable name
  so you can distinguish a variable from another CSS value. so you can distinguish a variable from another CSS value.
*/ */
$primary-color = #A3A4FF $primary-color = #A3A4FF

4
tr/php.md
View File

@ -17,7 +17,7 @@ PHP 5+ versiyonu için geçerlidir.
// // işareti ile tek satırlık yorum satırı başlar. // // işareti ile tek satırlık yorum satırı başlar.
# # işareti de aynı görevi görür ancak // daha genel kullanımdadır. # # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
@ -45,7 +45,7 @@ Hello World Again!
* Tipler ve Değişkenler * Tipler ve Değişkenler
*************************************/ *************************************/
// Değişkenler $ sembolü ile başlar. // Değişkenler $ sembolü ile başlar.
// Geçerli bir değişken bir harf veya alt çizgi ile başlar, // Geçerli bir değişken bir harf veya alt çizgi ile başlar,
// devamında da bir sayı, harf veya alt çizgi ile devam eder. // devamında da bir sayı, harf veya alt çizgi ile devam eder.

96
tr/pythonlegacy.md
View File

@ -35,8 +35,8 @@ uygulanabilir. Python 3 için başka bir zaman tekrar bakınız.
10 * 2 #=> 20 10 * 2 #=> 20
35 / 5 #=> 7 35 / 5 #=> 7
# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız # Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
# sonuç otomatik olarak kırpılır. # sonuç otomatik olarak kırpılır.
5 / 2 #=> 2 5 / 2 #=> 2
# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir. # Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
@ -80,30 +80,30 @@ not False #=> True
"Hello " + "world!" #=> "Hello world!" "Hello " + "world!" #=> "Hello world!"
# A string can be treated like a list of characters # A string can be treated like a list of characters
# Bir string'e karakter listesi gibi davranabilirsiniz. # Bir string'e karakter listesi gibi davranabilirsiniz.
"This is a string"[0] #=> 'T' "This is a string"[0] #=> 'T'
# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi: # % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
"%s can be %s" % ("strings", "interpolated") "%s can be %s" % ("strings", "interpolated")
# String'leri formatlamanın yeni bir yöntem ise format metodudur. # String'leri formatlamanın yeni bir yöntem ise format metodudur.
# Bu metod tercih edilen yöntemdir. # Bu metod tercih edilen yöntemdir.
"{0} can be {1}".format("strings", "formatted") "{0} can be {1}".format("strings", "formatted")
# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz. # Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
"{name} wants to eat {food}".format(name="Bob", food="lasagna") "{name} wants to eat {food}".format(name="Bob", food="lasagna")
# None bir objedir # None bir objedir
None #=> None None #=> None
# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın. # "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
# Onun yerine "is" kullanın. # Onun yerine "is" kullanın.
"etc" is None #=> False "etc" is None #=> False
None is None #=> True None is None #=> True
# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler # 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır. # için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
# None, 0 ve boş string/list'ler False olarak değerlendirilir. # None, 0 ve boş string/list'ler False olarak değerlendirilir.
# Tüm eşitlikler True döner # Tüm eşitlikler True döner
0 == False #=> True 0 == False #=> True
"" == False #=> True "" == False #=> True
@ -122,12 +122,12 @@ some_var = 5 # Değişken isimlerinde gelenek küçük karakter ve alt çizgi
# kullanmaktır. # kullanmaktır.
some_var #=> 5 some_var #=> 5
# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye # Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye
# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla # çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla
# bilgi için kontrol akışı kısmına göz atınız. # bilgi için kontrol akışı kısmına göz atınız.
some_other_var # isim hatası fırlatılır some_other_var # isim hatası fırlatılır
# isterseniz "if"i bir ifade gibi kullanabilirsiniz. # isterseniz "if"i bir ifade gibi kullanabilirsiniz.
"yahoo!" if 3 > 2 else 2 #=> "yahoo!" "yahoo!" if 3 > 2 else 2 #=> "yahoo!"
# Listeler # Listeler
@ -151,7 +151,7 @@ li[0] #=> 1
li[-1] #=> 3 li[-1] #=> 3
# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası # Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası
# fırlatılır # fırlatılır
li[4] # IndexError fırlatılır li[4] # IndexError fırlatılır
# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz. # slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
@ -177,7 +177,7 @@ li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
# "len" ile listenin uzunluğunu bulmak # "len" ile listenin uzunluğunu bulmak
len(li) #=> 6 len(li) #=> 6
# Tüpler listeler gibidir sadece değişmezler(immutable) # Tüpler listeler gibidir sadece değişmezler(immutable)
tup = (1, 2, 3) tup = (1, 2, 3)
tup[0] #=> 1 tup[0] #=> 1
tup[0] = 3 # TypeError fırlatılır. tup[0] = 3 # TypeError fırlatılır.
@ -188,12 +188,12 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
tup[:2] #=> (1, 2) tup[:2] #=> (1, 2)
2 in tup #=> True 2 in tup #=> True
# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere # Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
# atanabilir # atanabilir
a, b, c = (1, 2, 3) # a şu anda 1, b şu anda 2 ve c şu anda 3 a, b, c = (1, 2, 3) # a şu anda 1, b şu anda 2 ve c şu anda 3
# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur # Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
d, e, f = 4, 5, 6 d, e, f = 4, 5, 6
# şimdi iki değeri değiş tokuş etmek çok kolaydır. # şimdi iki değeri değiş tokuş etmek çok kolaydır.
e, d = d, e # d şimdi 5 ve e şimdi 4 e, d = d, e # d şimdi 5 ve e şimdi 4
@ -207,24 +207,24 @@ filled_dict["one"] #=> 1
# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır # Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
filled_dict.keys() #=> ["three", "two", "one"] filled_dict.keys() #=> ["three", "two", "one"]
# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir # Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir # Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir
# Tüm değerleri almak için "values()" kullanabilirsiniz. # Tüm değerleri almak için "values()" kullanabilirsiniz.
filled_dict.values() #=> [3, 2, 1] filled_dict.values() #=> [3, 2, 1]
# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir. # Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir # Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
"one" in filled_dict #=> True "one" in filled_dict #=> True
1 in filled_dict #=> False 1 in filled_dict #=> False
# Olmayan bir anahtar çağrıldığında KeyError fırlatılır. # Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
filled_dict["four"] # KeyError filled_dict["four"] # KeyError
# "get()" metodu KeyError fırlatılmasını önler # "get()" metodu KeyError fırlatılmasını önler
filled_dict.get("one") #=> 1 filled_dict.get("one") #=> 1
filled_dict.get("four") #=> None filled_dict.get("four") #=> None
# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama # get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
# imknaı sağlar. # imknaı sağlar.
filled_dict.get("one", 4) #=> 1 filled_dict.get("one", 4) #=> 1
filled_dict.get("four", 4) #=> 4 filled_dict.get("four", 4) #=> 4
@ -237,10 +237,10 @@ filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
# Sets store ... well sets # Sets store ... well sets
empty_set = set() empty_set = set()
# Bir demek değer ile bir "set" oluşturmak # Bir demek değer ile bir "set" oluşturmak
some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4]) some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir # Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4} filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
# Bir set'e daha fazla eleman eklemek # Bir set'e daha fazla eleman eklemek
@ -253,10 +253,10 @@ filled_set & other_set #=> {3, 4, 5}
# | işareti ile # | işareti ile
filled_set | other_set #=> {1, 2, 3, 4, 5, 6} filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
# "-" işareti ile iki set'in farkları alınabilir # "-" işareti ile iki set'in farkları alınabilir
{1,2,3,4} - {2,3,5} #=> {1, 4} {1,2,3,4} - {2,3,5} #=> {1, 4}
# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz # "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
2 in filled_set #=> True 2 in filled_set #=> True
10 in filled_set #=> False 10 in filled_set #=> False
@ -268,7 +268,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
# Bir değişken oluşturmak # Bir değişken oluşturmak
some_var = 5 some_var = 5
# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir! # Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
# "some_var is smaller than 10" yazdırılır. # "some_var is smaller than 10" yazdırılır.
if some_var > 10: if some_var > 10:
print "some_var is totally bigger than 10." print "some_var is totally bigger than 10."
@ -286,7 +286,7 @@ Ekrana yazdırılan:
mouse is a mammal mouse is a mammal
""" """
for animal in ["dog", "cat", "mouse"]: for animal in ["dog", "cat", "mouse"]:
# Biçimlendirmeleri string'e katmak için % kullanabilirsiniz # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
print "%s is a mammal" % animal print "%s is a mammal" % animal
""" """
@ -315,7 +315,7 @@ while x < 4:
# try/except bloğu ile hatalar ayıklanabilir # try/except bloğu ile hatalar ayıklanabilir
# Python 2.6 ve üstü için çalışacaktır: # Python 2.6 ve üstü için çalışacaktır:
try: try:
# "raise" bir hata fırlatmak için kullanılabilir # "raise" bir hata fırlatmak için kullanılabilir
raise IndexError("This is an index error") raise IndexError("This is an index error")
@ -339,18 +339,18 @@ add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak # Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
add(y=6, x=5) # Anahtar argümanlarının sırası farklı da olabilir add(y=6, x=5) # Anahtar argümanlarının sırası farklı da olabilir
# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz # Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
def varargs(*args): def varargs(*args):
return args return args
varargs(1, 2, 3) #=> (1,2,3) varargs(1, 2, 3) #=> (1,2,3)
# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da # Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da
# tanımlayabilirsiniz. # tanımlayabilirsiniz.
def keyword_args(**kwargs): def keyword_args(**kwargs):
return kwargs return kwargs
# Şu şekilde kullanılacaktır # Şu şekilde kullanılacaktır
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
# Eğer isterseniz ikisini aynı anda da yapabilirsiniz # Eğer isterseniz ikisini aynı anda da yapabilirsiniz
@ -363,15 +363,15 @@ all_the_args(1, 2, a=3, b=4) prints:
{"a": 3, "b": 4} {"a": 3, "b": 4}
""" """
# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz! # Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın. # Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
args = (1, 2, 3, 4) args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4} kwargs = {"a": 3, "b": 4}
all_the_args(*args) # foo(1, 2, 3, 4) ile eşit all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
all_the_args(**kwargs) # foo(a=3, b=4) ile eşit all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
# Python first-class fonksiyonlara sahiptir # Python first-class fonksiyonlara sahiptir
def create_adder(x): def create_adder(x):
def adder(y): def adder(y):
return x + y return x + y
@ -387,7 +387,7 @@ add_10(3) #=> 13
map(add_10, [1,2,3]) #=> [11, 12, 13] map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. # Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz.
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] [add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7] [x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
@ -399,7 +399,7 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# We subclass from object to get a class. # We subclass from object to get a class.
class Human(object): class Human(object):
# Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır. # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
species = "H. sapiens" species = "H. sapiens"
# Basic initializer # Basic initializer
@ -408,18 +408,18 @@ class Human(object):
# değişkenine atama # değişkenine atama
self.name = name self.name = name
# Bir instance metodu. Tüm metodlar ilk argüman olarak "self" # Bir instance metodu. Tüm metodlar ilk argüman olarak "self"
# parametresini alır # parametresini alır
def say(self, msg): def say(self, msg):
return "%s: %s" % (self.name, msg) return "%s: %s" % (self.name, msg)
# Bir sınıf metodu tüm "instance"lar arasında paylaşılır # Bir sınıf metodu tüm "instance"lar arasında paylaşılır
# İlk argüman olarak sınıfı çağırarak çağrılırlar # İlk argüman olarak sınıfı çağırarak çağrılırlar
@classmethod @classmethod
def get_species(cls): def get_species(cls):
return cls.species return cls.species
# Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
@staticmethod @staticmethod
def grunt(): def grunt():
return "*grunt*" return "*grunt*"
@ -452,24 +452,24 @@ Human.grunt() #=> "*grunt*"
import math import math
print math.sqrt(16) #=> 4.0 print math.sqrt(16) #=> 4.0
# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz # Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
from math import ceil, floor from math import ceil, floor
print ceil(3.7) #=> 4.0 print ceil(3.7) #=> 4.0
print floor(3.7) #=> 3.0 print floor(3.7) #=> 3.0
# Modüldeki tüm fonksiyonları dahil edebilirsiniz # Modüldeki tüm fonksiyonları dahil edebilirsiniz
# Uyarı: bu önerilmez # Uyarı: bu önerilmez
from math import * from math import *
# Modülün adını kısaltabilirsiniz # Modülün adını kısaltabilirsiniz
import math as m import math as m
math.sqrt(16) == m.sqrt(16) #=> True math.sqrt(16) == m.sqrt(16) #=> True
# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül # Python modülleri sıradan python dosyalarıdır. Kendinize bir modül
# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı # yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
# aynı olmalıdır. # aynı olmalıdır.
# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz. # Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
import math import math
dir(math) dir(math)
``` ```

8
zh-cn/vim.md
View File

@ -53,15 +53,15 @@ translators:
t<字符> # 向前跳移到 <字符> 的左侧 t<字符> # 向前跳移到 <字符> 的左侧
# 例如， # 例如，
   f<               # 向前跳移到 < 上 f< # 向前跳移到 < 上
t< # 向前跳移到 < 的左侧 t< # 向前跳移到 < 的左侧
# 按词移动 # 按词移动
# 默认一个单词由字母，数字和下划线组成 # 默认一个单词由字母，数字和下划线组成
   w               # 移动到下一个词首 w # 移动到下一个词首
   b               # 移动到前一个词首 b # 移动到前一个词首
   e               # 移动到下一个词尾 e # 移动到下一个词尾
# 移动的其它命令 # 移动的其它命令