From 3ecbf961d3b75d615a87a204f360842926e7dc7f Mon Sep 17 00:00:00 2001 From: Boris Verkhovskiy Date: Wed, 18 Dec 2024 17:58:08 -0700 Subject: [PATCH] Remove non-breaking spaces --- ansible.md | 2 +- bash.md | 8 +- cs/python.md | 2 +- css.md | 4 +- cue.md | 10 +- de/pythonlegacy.md | 12 +- el/python.md | 2 +- es/c++.md | 12 +- es/fsharp.md | 54 +++---- es/hy.md | 256 +++++++++++++++--------------- es/kotlin.md | 10 +- fr/c++.md | 4 +- fr/livescript.md | 50 +++--- fr/racket.md | 2 +- fr/rust.md | 376 ++++++++++++++++++++++----------------------- fr/xml.md | 14 +- id/smallbasic.md | 10 +- id/xml.md | 30 ++-- it/rst.md | 4 +- julia.md | 8 +- latex.md | 2 +- mips.md | 2 +- pl/java.md | 2 +- pt-br/csharp.md | 10 +- pt-br/java.md | 20 +-- pt-br/sass.md | 34 ++-- raku.md | 2 +- ru/c.md | 6 +- stylus.md | 4 +- tr/php.md | 4 +- tr/pythonlegacy.md | 96 ++++++------ zh-cn/vim.md | 8 +- 32 files changed, 530 insertions(+), 530 deletions(-) diff --git a/ansible.md b/ansible.md index 968eccde..474918ae 100644 --- a/ansible.md +++ b/ansible.md @@ -352,7 +352,7 @@ Get familiar with how you can use roles in the simple_apache_role example ``` playbooks/roles/simple_apache_role/ ├── tasks -│   └── main.yml +│ └── main.yml └── templates └── main.yml ``` diff --git a/bash.md b/bash.md index 6d97e2c1..50680abb 100644 --- a/bash.md +++ b/bash.md @@ -343,7 +343,7 @@ echo "#helloworld" | tee output.out >/dev/null rm -v output.out error.err output-and-error.log rm -r tempDir/ # recursively delete # 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 # Commands can be substituted within other commands using $( ): @@ -360,7 +360,7 @@ case "$Variable" in # List patterns for the conditions you want to meet 0) echo "There is a zero.";; 1) echo "There is a one.";; - *) echo "It is not null.";; # match everything + *) echo "It is not null.";; # match everything esac # `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 # (regex compatible) sed -i 's/okay/great/g' file.txt -# 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) +# 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) # print to stdout all lines of file.txt which match some regex # The example prints lines which begin with "foo" and end in "bar" diff --git a/cs/python.md b/cs/python.md index 09b44798..0ea13ae1 100644 --- a/cs/python.md +++ b/cs/python.md @@ -610,7 +610,7 @@ for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]): break # 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)): # Vypíše postupně: "Zpracovávám číslo 1", ..., "Zpracovávám číslo 5" if nasobek >= 10: diff --git a/css.md b/css.md index d92e46a5..db538fab 100644 --- a/css.md +++ b/css.md @@ -224,13 +224,13 @@ body { /* Nest style rule inside another (CSS 3) */ .main { - .bgred { /* same as: .main .bgred { } */ + .bgred { /* same as: .main .bgred { } */ background: red; } & .bggreen { /* same as: .main .bggreen { } */ background: green; } - &.bgblue { /* (without space) same as: .main.bgblue { } */ + &.bgblue { /* (without space) same as: .main.bgblue { } */ background: blue; } } diff --git a/cue.md b/cue.md index cc1ae083..976cbb96 100644 --- a/cue.md +++ b/cue.md @@ -488,12 +488,12 @@ To make it concrete, consider the following: ``` mymodule ├── config -│   ├── a.cue -│   └── b.cue +│ ├── a.cue +│ └── b.cue ├── cue.mod -│   ├── module.cue -│   ├── pkg -│   └── usr +│ ├── module.cue +│ ├── pkg +│ └── usr └── main.cue ``` diff --git a/de/pythonlegacy.md b/de/pythonlegacy.md index 0c82418f..a0dfb357 100644 --- a/de/pythonlegacy.md +++ b/de/pythonlegacy.md @@ -461,18 +461,18 @@ class Human(object): return "*grunt*" # Eine Eigenschaft (Property) ist wie ein Getter. -    # 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 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. @property def age(self): return self._age -    # Damit kann die Eigenschaft festgelegt werden + # Damit kann die Eigenschaft festgelegt werden @age.setter def age(self, age): self._age = age -    # Damit kann die Eigenschaft gelöscht werden + # Damit kann die Eigenschaft gelöscht werden @age.deleter def age(self): del self._age @@ -561,7 +561,7 @@ class Superhero(Human): # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse # zugreifen, die vom untergeordneten Objekt überschrieben werden, # 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) # überschreiben der "sing" Methode @@ -583,7 +583,7 @@ if __name__ == '__main__': 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. -    # Dieses Attribut ist dynamisch und kann aktualisiert werden. + # Dieses Attribut ist dynamisch und kann aktualisiert werden. print(Superhero.__mro__) # => (, # => , ) diff --git a/el/python.md b/el/python.md index 962d05dc..4e2c8e6d 100644 --- a/el/python.md +++ b/el/python.md @@ -523,7 +523,7 @@ next(our_iterator) # => "one" next(our_iterator) # => "two" next(our_iterator) # => "three" -# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration. +# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration. next(our_iterator) # προκαλεί StopIteration # Μπορείς να πάρεις όλα τα αντικείμενα ενός iteratior καλώντας list() πάνω του. diff --git a/es/c++.md b/es/c++.md index c3d9ce09..6de567f7 100644 --- a/es/c++.md +++ b/es/c++.md @@ -280,7 +280,7 @@ foo(bar(tempObjectFun())) void constReferenceTempObjectFun() { // ConstRef obtiene el objeto temporal, y es válido hasta el final de esta -  // función. + // función. const string& constRef = tempObjectFun(); ... } @@ -328,10 +328,10 @@ public: Dog(); // Declaraciones de funciones de la clase (implementaciones a seguir) -    // Nota que usamos std::string aquí en lugar de colocar -    // using namespace std; -    // arriba. -    // Nunca ponga una declaración "using namespace" en un encabezado. + // Nota que usamos std::string aquí en lugar de colocar + // using namespace std; + // arriba. + // Nunca ponga una declaración "using namespace" en un encabezado. void setName(const std::string& dogsName); void setWeight(int dogsWeight); @@ -471,7 +471,7 @@ public: Point& operator+=(const Point& rhs); // 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 diff --git a/es/fsharp.md b/es/fsharp.md index b953ff3c..90171238 100644 --- a/es/fsharp.md +++ b/es/fsharp.md @@ -248,7 +248,7 @@ module EjemploDeSecuencia = let secuencia1 = seq { yield "a"; yield "b" } // Las secuencias pueden usar yield y -    // puede contener subsecuencias + // puede contener subsecuencias let extranio = seq { // "yield" agrega un elemento yield 1; yield 2; @@ -262,7 +262,7 @@ module EjemploDeSecuencia = extranio |> Seq.toList // 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) -> Some(fst + snd, (snd, fst + snd))) (0,1) @@ -278,8 +278,8 @@ module EejemploDeTipoDeDatos = // Todos los datos son inmutables por defecto -     // las tuplas son tipos anónimos simples y rápidos -     // - Usamos una coma para crear una tupla + // las tuplas son tipos anónimos simples y rápidos + // - Usamos una coma para crear una tupla let dosTuplas = 1,2 let tresTuplas = "a",2,true @@ -301,7 +301,7 @@ module EejemploDeTipoDeDatos = // ------------------------------------ // 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 @@ -326,7 +326,7 @@ module EejemploDeTipoDeDatos = // ------------------------------------ // Los tipos se pueden combinar recursivamente de formas complejas -    // sin tener que crear subclases + // sin tener que crear subclases type Empleado = | Trabajador of Persona | Gerente of Empleado lista @@ -349,9 +349,9 @@ module EejemploDeTipoDeDatos = | DireccionDeCorreoInvalido direccion -> () // no enviar // Combinar juntos, los tipos de unión y tipos de registro -     // ofrece una base excelente para el diseño impulsado por el dominio. -     // Puedes crear cientos de pequeños tipos que reflejarán fielmente -     // 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 + // el dominio. type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int } 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. -     // * Inmutabilidad -     // * Bonita depuración de impresión -     // * Igualdad y comparación -     // * Serialización + // * Inmutabilidad + // * Bonita depuración de impresión + // * Igualdad y comparació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" dosTuplas persona1 temp1 trabajador // 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 Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho | Nueve | Diez | Jack | Reina | Rey | As @@ -398,11 +398,11 @@ module EejemploDeTipoDeDatos = module EjemplosDePatronesActivos = // 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 = if System.Char.IsDigit(ch) then Digito else if System.Char.IsLetter(ch) then Letra @@ -425,7 +425,7 @@ module EjemplosDePatronesActivos = // ----------------------------------------- // 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 (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None @@ -447,7 +447,7 @@ module EjemplosDePatronesActivos = module EjemploDeAlgoritmo = // 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 ------ let sumaDeCuadrados n = @@ -464,7 +464,7 @@ module EjemploDeAlgoritmo = // Si la lista está 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 let elementosMasPequenios = // extraemos los elementos más pequeños otrosElementos // tomamos el resto @@ -487,9 +487,9 @@ module EjemploDeAlgoritmo = module AsyncExample = // F# incluye características para ayudar con el código asíncrono -    // sin conocer la "pirámide del destino" -    // -    // El siguiente ejemplo descarga una secuencia de página web en paralelo. + // sin conocer la "pirámide del destino" + // + // El siguiente ejemplo descarga una secuencia de página web en paralelo. open System.Net open System @@ -531,9 +531,9 @@ module AsyncExample = module EjemploCompatibilidadNet = // 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"); if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida" @@ -559,7 +559,7 @@ module EjemploCompatibilidadNet = // ------- Código orientado a objetos ------- // 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 type IEnumerator<'a> = diff --git a/es/hy.md b/es/hy.md index e734efd5..f4548461 100644 --- a/es/hy.md +++ b/es/hy.md @@ -6,162 +6,162 @@ translators: - ["Roberto R", "https://github.com/rrodriguze"] --- -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 -Hy llamar a código Python nativo y viceversa. +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 +Hy llamar a código Python nativo y viceversa. ```hylang -;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace -;; https://hylang.org/try-hy +;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace +;; 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 -; Los programas List están hechos de expresiones simbólicas como la siguiente -(some-function args) -; ahora el esencial "Hola Mundo" -(print "hello world") +;; Nociones básicas de expresiones +; Los programas List están hechos de expresiones simbólicas como la siguiente +(some-function args) +; ahora el esencial "Hola Mundo" +(print "hello world") -;; Tipos de datos simples -; Todos los tipos de datos simples son exactamente semejantes a sus homólogos -; en Python -42 ; => 42 -3.14 ; => 3.14 -True ; => True -4+10j ; => (4+10j) un número complejo +;; Tipos de datos simples +; Todos los tipos de datos simples son exactamente semejantes a sus homólogos +; en Python +42 ; => 42 +3.14 ; => 3.14 +True ; => True +4+10j ; => (4+10j) un número complejo -; Vamos a comenzar con un poco de arimética simple -(+ 4 1) ;=> 5 -; el operador es aplicado a todos los argumentos, como en otros Lisps -(+ 4 1 2 3) ;=> 10 -(- 2 1) ;=> 1 -(* 4 2) ;=> 8 -(/ 4 1) ;=> 4 -(% 4 2) ;=> 0 o operador módulo -; la exponenciación es representada por el operador ** como Python -(** 3 2) ;=> 9 -; las funciones anidadas funcionan como lo esperado -(+ 2 (* 4 2)) ;=> 10 -; también los operadores lógicos igual o no igual se comportan como se espera -(= 5 4) ;=> False -(not (= 5 4)) ;=> True +; Vamos a comenzar con un poco de arimética simple +(+ 4 1) ;=> 5 +; el operador es aplicado a todos los argumentos, como en otros Lisps +(+ 4 1 2 3) ;=> 10 +(- 2 1) ;=> 1 +(* 4 2) ;=> 8 +(/ 4 1) ;=> 4 +(% 4 2) ;=> 0 o operador módulo +; la exponenciación es representada por el operador ** como Python +(** 3 2) ;=> 9 +; las funciones anidadas funcionan como lo esperado +(+ 2 (* 4 2)) ;=> 10 +; también los operadores lógicos igual o no igual se comportan como se espera +(= 5 4) ;=> False +(not (= 5 4)) ;=> True -;; variables -; las variables se configuran usando SETV, los nombres de las variables pueden -; usar utf-8, excepto for ()[]{}",'`;#| -(setv a 42) -(setv π 3.14159) -(def *foo* 42) -;; otros tipos de datos de almacenamiento -; strings, lists, tuples & dicts -; estos son exactamente los mismos tipos de almacenamiento en Python -"hello world" ;=> "hello world" -; las operaciones de cadena funcionan de manera similar en Python -(+ "hello " "world") ;=> "hello world" -; Las listas se crean usando [], la indexación comienza en 0 -(setv mylist [1 2 3 4]) -; las tuplas son estructuras de datos inmutables -(setv mytuple (, 1 2)) -; los diccionarios son pares de valor-clave -(setv dict1 {"key1" 42 "key2" 21}) -; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves -(setv dict2 {:key1 41 :key2 20}) -; usar 'get' para obtener un elemento en un índice/key -(get mylist 1) ;=> 2 -(get dict1 "key1") ;=> 42 -; Alternativamente, si se usan palabras clave que podrían llamarse directamente -(:key1 dict2) ;=> 41 +;; variables +; las variables se configuran usando SETV, los nombres de las variables pueden +; usar utf-8, excepto for ()[]{}",'`;#| +(setv a 42) +(setv π 3.14159) +(def *foo* 42) +;; otros tipos de datos de almacenamiento +; strings, lists, tuples & dicts +; estos son exactamente los mismos tipos de almacenamiento en Python +"hello world" ;=> "hello world" +; las operaciones de cadena funcionan de manera similar en Python +(+ "hello " "world") ;=> "hello world" +; Las listas se crean usando [], la indexación comienza en 0 +(setv mylist [1 2 3 4]) +; las tuplas son estructuras de datos inmutables +(setv mytuple (, 1 2)) +; los diccionarios son pares de valor-clave +(setv dict1 {"key1" 42 "key2" 21}) +; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves +(setv dict2 {:key1 41 :key2 20}) +; usar 'get' para obtener un elemento en un índice/key +(get mylist 1) ;=> 2 +(get dict1 "key1") ;=> 42 +; Alternativamente, si se usan palabras clave que podrían llamarse directamente +(:key1 dict2) ;=> 41 -;; funciones y otras estructuras de programa -; las funciones son definidas usando defn, o el último sexp se devuelve por defecto -(defn greet [name] -  "A simple greeting" ; un docstring opcional -  (print "hello " name)) +;; funciones y otras estructuras de programa +; las funciones son definidas usando defn, o el último sexp se devuelve por defecto +(defn greet [name] + "A simple greeting" ; un docstring opcional + (print "hello " name)) -(greet "bilbo") ;=> "hello bilbo" +(greet "bilbo") ;=> "hello bilbo" -; las funciones pueden tener argumentos opcionales, así como argumentos-clave -(defn foolists [arg1 &optional [arg2 2]] -  [arg1 arg2]) +; las funciones pueden tener argumentos opcionales, así como argumentos-clave +(defn foolists [arg1 &optional [arg2 2]] + [arg1 arg2]) -(foolists 3) ;=> [3 2] -(foolists 10 3) ;=> [10 3] +(foolists 3) ;=> [3 2] +(foolists 10 3) ;=> [10 3] -; las funciones anonimas son creadas usando constructores 'fn' y 'lambda' -; que son similares a 'defn' -(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16] +; las funciones anonimas son creadas usando constructores 'fn' y 'lambda' +; que son similares a 'defn' +(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16] -;; operaciones de secuencia -; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc. -; recuperar el primer elemento usando 'first' o 'car' -(setv mylist [1 2 3 4]) -(setv mydict {"a" 1 "b" 2}) -(first mylist) ;=> 1 +;; operaciones de secuencia +; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc. +; recuperar el primer elemento usando 'first' o 'car' +(setv mylist [1 2 3 4]) +(setv mydict {"a" 1 "b" 2}) +(first mylist) ;=> 1 -; corte listas usando 'cut' -(cut mylist 1 3) ;=> [2 3] +; corte listas usando 'cut' +(cut mylist 1 3) ;=> [2 3] -; obtener elementos de una lista o dict usando 'get' -(get mylist 1) ;=> 2 -(get mydict "b") ;=> 2 -; la lista de indexación comienza a partir de 0, igual que en Python -; assoc puede definir elementos clave/índice -(assoc mylist 2 10) ; crear mylist [1 2 10 4] -(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3} -; hay muchas otras funciones que hacen que trabajar con secuencias sea -; entretenido +; obtener elementos de una lista o dict usando 'get' +(get mylist 1) ;=> 2 +(get mydict "b") ;=> 2 +; la lista de indexación comienza a partir de 0, igual que en Python +; assoc puede definir elementos clave/índice +(assoc mylist 2 10) ; crear mylist [1 2 10 4] +(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3} +; hay muchas otras funciones que hacen que trabajar con secuencias sea +; entretenido -;; Python interop -;; los import funcionan exactamente como en Python -(import datetime) -(import functools [partial reduce]) ; importa fun1 e fun2 del module1 -(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 -; a.foo(arg) is called as (.foo a arg) -(.split (.strip "hello world  ")) ;=> ["hello" "world"] +;; Python interop +;; los import funcionan exactamente como en Python +(import datetime) +(import functools [partial reduce]) ; importa fun1 e fun2 del module1 +(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 +; a.foo(arg) is called as (.foo a arg) +(.split (.strip "hello world ")) ;=> ["hello" "world"] -;; Condicionales -; (if condition (body-if-true) (body-if-false) -(if (= passcode "moria") -  (print "welcome") -  (print "Speak friend, and Enter!")) +;; Condicionales +; (if condition (body-if-true) (body-if-false) +(if (= passcode "moria") + (print "welcome") + (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 - (= someval 42) (print "Life, universe and everything else!") - (> someval 42) (print "val too large") - (< someval 42) (print "val too small")) + (= someval 42) (print "Life, universe and everything else!") + (> someval 42) (print "val too large") + (< someval 42) (print "val too small")) -; declaraciones de grupo con 'do', son ejecutadas secuencialmente -; formas como defn tienen un 'do' implícito +; declaraciones de grupo con 'do', son ejecutadas secuencialmente +; formas como defn tienen un 'do' implícito (do - (setv someval 10) - (print "someval is set to " someval)) ;=> 10 + (setv someval 10) + (print "someval is set to " someval)) ;=> 10 -; crear enlaces léxicos con 'let', todas las variables definidas de esta manera -; tienen alcance local -(let [[nemesis {"superman" "lex luther" -                "sherlock" "moriarty" -                "seinfeld" "newman"}]] -  (for [(, h v) (.items nemesis)] -    (print (.format "{0}'s nemesis was {1}" h v)))) +; crear enlaces léxicos con 'let', todas las variables definidas de esta manera +; tienen alcance local +(let [[nemesis {"superman" "lex luther" + "sherlock" "moriarty" + "seinfeld" "newman"}]] + (for [(, h v) (.items nemesis)] + (print (.format "{0}'s nemesis was {1}" h v)))) -;; clases -; las clases son definidas de la siguiente manera +;; clases +; las clases son definidas de la siguiente manera (defclass Wizard [object] -  (defn __init__ [self spell] -    (setv self.spell spell)) + (defn __init__ [self spell] + (setv self.spell spell)) -  (defn get-spell [self] -    self.spell)) + (defn get-spell [self] + 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 diff --git a/es/kotlin.md b/es/kotlin.md index d239ff23..6b1dda59 100644 --- a/es/kotlin.md +++ b/es/kotlin.md @@ -36,7 +36,7 @@ fun main(args: Array) { /* 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. -    Podemos declarar explícitamente el tipo de una variable así: + Podemos declarar explícitamente el tipo de una variable así: */ val foo: Int = 7 @@ -59,7 +59,7 @@ fun main(args: Array) { /* 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 = """ fun helloWorld(val name : String) { @@ -70,7 +70,7 @@ fun main(args: Array) { /* 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" println(fooTemplateString) @@ -78,8 +78,8 @@ fun main(args: Array) { /* Para que una variable pueda aceptar valor nulo se debe especificar explícitamente como anulable añadiendole ? a su tipo. -    Podemos acceder a una variable anulable mediante el uso del operador ?. -    Podemos utilizar el operador ?: para especificar un valor alternativo + Podemos acceder a una variable anulable mediante el uso del operador ?. + Podemos utilizar el operador ?: para especificar un valor alternativo a usar si una variable es nula. */ var fooNullable: String? = "abc" diff --git a/fr/c++.md b/fr/c++.md index 8a02fcee..f866ca27 100644 --- a/fr/c++.md +++ b/fr/c++.md @@ -746,8 +746,8 @@ bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier) // Suppose que chaque fonction retourne faux si elle échoue if (!faireQuelqueChoseAvecLeFichier(fh)) { -        fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites -        return false; // Propage l'erreur + fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites + return false; // Propage l'erreur } if (!faireAutreChoseAvec(fh)) { fclose(fh); diff --git a/fr/livescript.md b/fr/livescript.md index 0493d8e9..f6958205 100644 --- a/fr/livescript.md +++ b/fr/livescript.md @@ -93,7 +93,7 @@ fruits = <[ apple orange pear ]> fruits[0] # => "apple" # 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 = name: "Christina" likes: @@ -101,7 +101,7 @@ person = * "and other cute stuff" # A nouveau, vous pouvez utiliser une expression plus consise à l'aide des -# accolades: +# accolades: person = {name: "Christina", likes: ["kittens", "and other cute stuff"]} # 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 # A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs -# lignes! +# lignes! # (les commentaires et les espaces seront ignorés) funRE = // function\s+(.+) # nom @@ -135,9 +135,9 @@ funRE = // # Les comparaisons sont presque identiques, à l'exception que `==` équivaut au -# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la -# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes -# (sans conversion de type) +# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la +# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes +# (sans conversion de type) 2 == 2 # => true 2 == "2" # => false 2 ~= "2" # => true @@ -169,8 +169,8 @@ not false # => true ######################################################################## # Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en -# charge des fonctions. En LiveScript, il est encore plus évident que les -# fonctions sont de premier ordre: +# charge des fonctions. En LiveScript, il est encore plus évident que les +# fonctions sont de premier ordre: add = (left, right) -> left + right add 1, 2 # => 3 @@ -181,7 +181,7 @@ two! # LiveScript utilise l'environnement de la fonction, comme JavaScript. # 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). # 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 -# 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: tail = ([head, ...rest]) -> rest tail [1, 2, 3] # => [2, 3] # 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! # => 3 # 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) -> for k,v of source => target[k] = v target @@ -220,12 +220,12 @@ identity = -> it identity 1 # => 1 # 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) [2, 4, 8, 16].map(divide-by-two).reduce (+) # 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) # 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 -# `|>` et `<|`: +# `|>` et `<|`: map = (f, xs) --> xs.map f [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 -# Le tiret bas est également utilisé pour l'application partielle, -# que vous pouvez utiliser pour toute fonction: +# Le tiret bas est également utilisé pour l'application partielle, +# que vous pouvez utiliser pour toute fonction: div = (left, right) -> left / right div-by-two = div _, 2 div-by-two 4 # => 2 # 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). # Un fonction de rappel est une fonction qui est passée en argument à une autre # fonction: @@ -289,7 +289,7 @@ x = switch | otherwise => \object # `otherwise` et `_` correspondent. # 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]) --> | n == 0 => [] | _ => [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, -# ce qui permet de générer rapidement et de manière élégante une liste de -# valeurs: +# ce qui permet de générer rapidement et de manière élégante une liste de +# valeurs: oneToTwenty = [1 to 20] evens = [x for x in oneToTwenty when x % 2 == 0] # `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: 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 -# outils pour la programmation objet. La syntaxe de déclaration d'une classe -# est héritée de CoffeeScript: +# outils pour la programmation objet. La syntaxe de déclaration d'une classe +# est héritée de CoffeeScript: class Animal (@name, kind) -> @kind = kind @@ -332,7 +332,7 @@ kitten = new Cat 'Mei' kitten.purr! # => "*Mei (a cat) purrs*" # 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 = hug: -> @action 'is hugged' diff --git a/fr/racket.md b/fr/racket.md index 8f3ec175..235be974 100644 --- a/fr/racket.md +++ b/fr/racket.md @@ -416,7 +416,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d' (values i (number->string i))) ; => '#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 (for/sum ([i 10]) (* i i)) ; => 285 (for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000 diff --git a/fr/rust.md b/fr/rust.md index 69cf6404..5c64eda6 100644 --- a/fr/rust.md +++ b/fr/rust.md @@ -35,271 +35,271 @@ Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts // Les fonctions // `I32` est le type 32 bits entiers signés fn add2(x: i32, y: i32) -> i32 { -    // Retour implicite (pas de point virgule) -    x + y + // Retour implicite (pas de point virgule) + x + y } // Fonction principale fn main() { -    // Nombres // + // Nombres // -    // Liaison immutable -    let x: i32 = 1; + // Liaison immutable + let x: i32 = 1; -    // Suffixes entiers et flottants -    let y: I32 = 13i32; -    let f: f64 = 1.3f64; + // Suffixes entiers et flottants + let y: I32 = 13i32; + let f: f64 = 1.3f64; -    // Inférence de type -    // La plupart du temps, le compilateur Rust peut déduire quel est le type + // Inférence de 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. -    // 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. // L'inférence de type peut les générer pour vous la plupart du temps. -    let implicit_x = 1; -    let implicit_f = 1,3; + let implicit_x = 1; + let implicit_f = 1,3; -    // Arithmétique -    let somme = x + y + 13; + // Arithmétique + let somme = x + y + 13; -    // Variable Mutable -    let mut mutable = 1; -    let mutable = 4; -    let mutable += 2; + // Variable Mutable + let mut mutable = 1; + let mutable = 4; + let mutable += 2; -    // Chaînes // + // Chaînes // -    // Chaîne littérales -    let x: &str = "Bonjour tout le monde !"; + // Chaîne littérales + let x: &str = "Bonjour tout le monde !"; -    // Affichage -    println!("{} {}", f, x); // 1.3 Bonjour tout le monde + // Affichage + println!("{} {}", f, x); // 1.3 Bonjour tout le monde -    // Une `Chaîne` - une chaîne de tas alloué -    let s: String = "Bonjour tout le monde".to_string(); + // Une `Chaîne` - une chaîne de tas alloué + let s: String = "Bonjour tout le monde".to_string(); -    // 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 -    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers -    // le début et la fin de la chaîne. -    let s_slice: &str = &s; + // 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 + // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers + // le début et la fin de la chaîne. + 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 -    let four_ints: [i32; 4] = [1, 2, 3, 4]; + // Un tableau de taille fixe + let four_ints: [i32; 4] = [1, 2, 3, 4]; -    // Un tableau dynamique(vecteur) -    let mut vecteur: Vec = vec![1, 2, 3, 4]; -    vecteur.push(5); + // Un tableau dynamique(vecteur) + let mut vecteur: Vec = vec![1, 2, 3, 4]; + vecteur.push(5); -    // 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. -    let tranche: &[i32] = &vecteur; + // 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. + let tranche: &[i32] = &vecteur; -    // Utiliser `{:?}` pour afficher quelque chose en mode debug -    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5] + // Utiliser `{:?}` pour afficher quelque chose en mode debug + 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. -    let x:(i32, &str, f64) = (1, "bonjour", 3.4); + // Un tuple est un ensemble de valeurs qui peuvent être de différents types. + let x:(i32, &str, f64) = (1, "bonjour", 3.4); -    // Déstructurer `let` -    let (a, b, c) = x; -    println!("{} {} {}", a, b, c); // 1 bonjour 3.4 + // Déstructurer `let` + let (a, b, c) = x; + println!("{} {} {}", a, b, c); // 1 bonjour 3.4 -    // indexation -    println!("{}", x.1); // Bonjour + // indexation + println!("{}", x.1); // Bonjour -    ////////////// -    // 2. Types // -    ////////////// + ////////////// + // 2. Types // + ////////////// -    // Struct -    struct Point { -        x: i32, -        y: i32, -    } + // Struct + struct Point { + x: 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'. -    struct Point2(i32, i32); + // Un struct avec des champs sans nom, appelé 'tuple struct'. + struct Point2(i32, i32); -    let origine2 = Point2(0, 0); + let origine2 = Point2(0, 0); -    // Basic C-like enum -    enum Direction { -        Àgauche, -        Droite, -        En_Haut, -        Vers_Le_Bas, -    } + // Basic C-like enum + enum Direction { + Àgauche, + Droite, + En_Haut, + Vers_Le_Bas, + } -    let en_haut = Direction::En_Haut; + let en_haut = Direction::En_Haut; -    // Enum avec des champs -    enum OptionnelI32 { -        AnI32(I32), -        Rien, -    } + // Enum avec des champs + enum OptionnelI32 { + AnI32(I32), + Rien, + } -    let deux: OptionnelI32 = OptionnelI32::AnI32(2); -    let rien = OptionnelI32::Rien; + let deux: OptionnelI32 = OptionnelI32::AnI32(2); + let rien = OptionnelI32::Rien; -    // Generics // + // Generics // -    struct Foo { bar: T } + struct Foo { bar: T } -    // Ceci est défini dans la bibliothèque standard comme `Option`. -    enum Optionnel { -        SomeVal(T), -        NoVal, -    } + // Ceci est défini dans la bibliothèque standard comme `Option`. + enum Optionnel { + SomeVal(T), + NoVal, + } -    // Méthodes // + // Méthodes // -    impl Foo { -        // Méthodes prennent un paramètre explicite `de self`. -        fn get_bar(self) -> T { -            self.bar -        } -    } + impl Foo { + // Méthodes prennent un paramètre explicite `de self`. + fn get_bar(self) -> T { + self.bar + } + } -    let a_foo = Foo { bar: 1 }; -    println!("{}", a_foo.get_bar()); // 1 + let a_foo = Foo { 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). -    trait Frobnicate { -        fn frobnicate(self) -> Option; -    } + trait Frobnicate { + fn frobnicate(self) -> Option; + } -    impl Frobnicate for Foo { -        fn frobnicate(self) -> Option { -            Some(self.bar) -        } -    } + impl Frobnicate for Foo { + fn frobnicate(self) -> Option { + Some(self.bar) + } + } -    let another_foo = Foo { bar: 1 }; -    println!("{:?}", another_foo.frobnicate()); // Some(1) + let another_foo = Foo { bar: 1 }; + println!("{:?}", another_foo.frobnicate()); // Some(1) -    ///////////////////////// -    // 3. Motif correspondant // -    ///////////////////////// + ///////////////////////// + // 3. Motif correspondant // + ///////////////////////// -    let foo = OptionnelI32::AnI32(1); -    match foo { -        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n), -        OptionnelI32::Rien => println!("Il n'y a rien!"), -    } + let foo = OptionnelI32::AnI32(1); + match foo { + OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n), + OptionnelI32::Rien => println!("Il n'y a rien!"), + } -    // Motif avancé correspondant -    struct FooBar { x: i32, y: OptionnelI32 } -    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) }; + // Motif avancé correspondant + struct FooBar { x: i32, y: OptionnelI32 } + let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) }; -    match bar { -        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} => -            println!("Les chiffres sont nuls!"), -        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m => -            println!("Les chiffres sont les mêmes"), -        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} => -            println!("Différents numéros: {} {}", n, m)!, -        FooBar { x: _, y: OptionnelI32 :: Rien} => -            println!("Le deuxième numéro est rien!"), -    } + match bar { + FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} => + println!("Les chiffres sont nuls!"), + FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m => + println!("Les chiffres sont les mêmes"), + FooBar { x: n, y: OptionnelI32 :: AnI32(m)} => + println!("Différents numéros: {} {}", n, m)!, + FooBar { x: _, y: OptionnelI32 :: Rien} => + println!("Le deuxième numéro est rien!"), + } -    ///////////////////// -    // 4. Flux de contrôle // -    ///////////////////// + ///////////////////// + // 4. Flux de contrôle // + ///////////////////// -    // `for` boucles / itération -    let array = [1, 2, 3]; -    for i in array { -        println!("{}", i); -    } + // `for` boucles / itération + let array = [1, 2, 3]; + for i in array { + println!("{}", i); + } -    // Ranges -    for i in 0u32..10 { -        print!("{}", i); -    } -    println!(""); -    // imprime `0 1 2 3 4 5 6 7 8 9` + // Ranges + for i in 0u32..10 { + print!("{}", i); + } + println!(""); + // imprime `0 1 2 3 4 5 6 7 8 9` -    // `if` -    if 1 == 1 { -        println!("Maths est travaille!"); -    } else { -        println!("Oh non ...!"); -    } + // `if` + if 1 == 1 { + println!("Maths est travaille!"); + } else { + println!("Oh non ...!"); + } -    // `if` comme expression -    let valeur = if true { -        "bien" -    } else { -        "mal" -    }; + // `if` comme expression + let valeur = if true { + "bien" + } else { + "mal" + }; -    // `while` boucle -    while 1 == 1 { -        println!("L'univers fonctionne normalement."); -    } + // `while` boucle + while 1 == 1 { + println!("L'univers fonctionne normalement."); + } -    // Boucle infinie -    loop { -        println!("Bonjour!"); -    } + // Boucle infinie + loop { + 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. -    // 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é. -    let mut mine: Box = Box::new(3); -    *mine = 5; // déréférencer -    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes, + let mut mine: Box = Box::new(3); + *mine = 5; // déréférencer + // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes, // `mine` est déplacé. -    let mut now_its_mine = mine; -    *now_its_mine += 2; + let mut now_its_mine = mine; + *now_its_mine += 2; -    println!("{}", now_its_mine); // 7 -    // println!("{}", now_its_mine); // Cela ne compile pas parce + println!("{}", now_its_mine); // 7 + // println!("{}", now_its_mine); // Cela ne compile pas parce // que `now_its_mine` possède maintenant le pointeur -    // 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 + // 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 // 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é. -    // Un emprunt dure jusqu'à la fin de la portée, il a été créé. -    let mut var = 4; -    var = 3; -    let ref_var: &i32 = &var; + // Un emprunt dure jusqu'à la fin de la portée, il a été créé. + let mut var = 4; + var = 3; + let ref_var: &i32 = &var; -    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé -    println!("{}", *ref_var); -    // 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 + println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé + println!("{}", *ref_var); + // 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 // référence immutable. -    // Référence Mutable -    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être + // Référence Mutable + // Même si une valeur est empruntée de façon mutable, elle ne peut pas être // accessible à tous. -    let mut var2 = 4; -    let ref_var2: &mut i32 = &mut var2; + let mut var2 = 4; + let ref_var2: &mut i32 = &mut var2; // '*' est utilisé pour pointer vers le var2 mutably emprunté. *ref_var2 += 2; 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. -    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté. + // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté. } ``` diff --git a/fr/xml.md b/fr/xml.md index fac95d22..32935ee6 100644 --- a/fr/xml.md +++ b/fr/xml.md @@ -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). 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 -   les balises d'ouverture et de fermeture. --> + les balises d'ouverture et de fermeture. --> + avec l'addition de définition DTD. --> @@ -95,10 +95,10 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d ]> diff --git a/id/smallbasic.md b/id/smallbasic.md index ef1906da..5e718b6c 100644 --- a/id/smallbasic.md +++ b/id/smallbasic.md @@ -28,7 +28,7 @@ print "halo" REM Struktur kontrol FOR index = 0 TO 10 STEP 2 -  ? "Ini adalah nomor baris"; indeks + ? "Ini adalah nomor baris"; indeks NEXT J=0 REPEAT @@ -57,10 +57,10 @@ End Try REM Fungsi dan subrutin buatan pengguna func add2(x, y) -  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC -  local k -  k = "k akan lenyap ketika FUNC ini mengembalikan nilai" -  add2 = x + y + 'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC + local k + k = "k akan lenyap ketika FUNC ini mengembalikan nilai" + add2 = x + y akhir Print add2(5,5) sub cetak_ini(ini) diff --git a/id/xml.md b/id/xml.md index e4a26ca2..b44461f3 100644 --- a/id/xml.md +++ b/id/xml.md @@ -95,23 +95,23 @@ Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan pengura + 2 - Elemen -> Itu data yang murni. + Itulah yang parser akan mengambil dari file XML. + Elemen muncul antara tag membuka dan menutup.--> @@ -131,7 +131,7 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi. ```xml + dengan penambahan definisi DTD .--> @@ -155,10 +155,10 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi. + Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'. + Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut + disebut 'kategori', dengan "Sastra" sebagai nilai default. + Node yang 'judul' dan 'harga' mengandung karakter data diurai .--> diff --git a/it/rst.md b/it/rst.md index 358bcd69..19f91414 100644 --- a/it/rst.md +++ b/it/rst.md @@ -57,13 +57,13 @@ Le liste sono semplici come in Markdown: - primo articolo - Secondo elemento -     - Sottoelemento + - Sottoelemento oppure * Primo elemento * Secondo elemento -     * Sottoelemento + * Sottoelemento Le tabelle sono molto semplici da inserire: diff --git a/julia.md b/julia.md index cb1b0cd7..a71e5ed2 100644 --- a/julia.md +++ b/julia.md @@ -94,8 +94,8 @@ false 'a' # Strings are UTF8 encoded, so strings like "π" or "☃" are not directly equivalent -# to an array of single characters. -# Only if they contain only ASCII characters can they be safely indexed. +# to an array of single characters. +# Only if they contain only ASCII characters can they be safely indexed. ascii("This is a string")[1] # => 'T' # => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase) # 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! # 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 @@ -392,7 +392,7 @@ end for animal = ["dog", "cat", "mouse"] println("$animal is a mammal") # 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 # => dog is a mammal # => cat is a mammal diff --git a/latex.md b/latex.md index 4b4d1f24..036c852b 100644 --- a/latex.md +++ b/latex.md @@ -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 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 - % 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 \begin{tabular}{c|cc} % here it means "centered | vertical line, centered centered" Number & First Name & Last Name \\ % Column rows are separated by & diff --git a/mips.md b/mips.md index f4c0b14b..8ac48e44 100644 --- a/mips.md +++ b/mips.md @@ -244,7 +244,7 @@ gateways and routers. ## FUNCTIONS ## _functions: # 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 jal return_1 # jal will store the current PC in $ra diff --git a/pl/java.md b/pl/java.md index 4685fe45..45457601 100644 --- a/pl/java.md +++ b/pl/java.md @@ -119,7 +119,7 @@ public class LearnJava { // Zmienną inicjalizuje się poprzez = 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 , , // = = = int barInt1, barInt2, barInt3; diff --git a/pt-br/csharp.md b/pt-br/csharp.md index b65febc6..5cf25bd4 100644 --- a/pt-br/csharp.md +++ b/pt-br/csharp.md @@ -106,7 +106,7 @@ namespace Learning.CSharp char fooChar = 'A'; // 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)"; 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 -        // Esta sintaxe criará um campo de apoio automaticamente. -        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos) -        // para restringir seu acesso: + // Esta sintaxe criará um campo de apoio automaticamente. + // Você pode definir um modificador de acesso no getter ou no setter (ou ambos) + // para restringir seu acesso: public bool IsBroken { get; private set; } // Properties can be auto-implemented @@ -856,7 +856,7 @@ on a new line! ""Wow!"", the masses cried"; /// /// 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 /// public class BikeRepository : DbContext diff --git a/pt-br/java.md b/pt-br/java.md index b29c351f..c05cb7d9 100644 --- a/pt-br/java.md +++ b/pt-br/java.md @@ -413,7 +413,7 @@ class Velocipede extends Bicicleta { // Exemplo - Comida: public interface Comestivel { public void comer(); // Qualquer classe que implementa essa interface, deve -                        // implementar este método. + // implementar este método. } public interface Digestivel { @@ -483,8 +483,8 @@ public abstract class Animal } // Não há necessidade de inicializar, no entanto, em uma interface -    // a variável é implicitamente final e, portanto, tem -    // de ser inicializada. + // a variável é implicitamente final e, portanto, tem + // de ser inicializada. protected int idade; public void mostrarIdade() @@ -503,7 +503,7 @@ class Cachorro extends Animal { // Nota: ainda precisamos substituir os métodos abstratos na -    // classe abstrata. + // classe abstrata. @Override public void fazerSom() { @@ -512,10 +512,10 @@ class Cachorro extends Animal } // NOTA: Você receberá um erro se usou a -    // anotação Override aqui, uma vez que java não permite -    // sobrescrita de métodos estáticos. -    // O que está acontecendo aqui é chamado de "esconder o método". -    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/ + // anotação Override aqui, uma vez que java não permite + // sobrescrita de métodos estáticos. + // O que está acontecendo aqui é chamado de "esconder o método". + // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/ public static void main(String[] args) { Cachorro pluto = new Cachorro(); @@ -540,7 +540,7 @@ class Cachorro extends Animal public final class TigreDenteDeSabre extends Animal { // Nota: Ainda precisamos substituir os métodos abstratos na -    // classe abstrata. + // classe abstrata. @Override public void fazerSom(); { @@ -555,7 +555,7 @@ public abstract class Mamifero() // final () // 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() { return true; diff --git a/pt-br/sass.md b/pt-br/sass.md index f230faa6..13c680d8 100644 --- a/pt-br/sass.md +++ b/pt-br/sass.md @@ -131,10 +131,10 @@ div { /* 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 -    argumentos necessários */ + argumentos necessários */ body { width: round(10.25px); @@ -162,7 +162,7 @@ body { reutilizável. */ /* 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) { @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, -   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, -   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á -   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */ + 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, + 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á + 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 -   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css. -   Parciais não são geradas em CSS. */ + código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.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. -   Isso difere da declaração CSS @import tradicional, que faz -   outra solicitação HTTP para buscar o arquivo importado. Sass converte os -   arquivo importados e combina com o código compilado. */ + Isso difere da declaração CSS @import tradicional, que faz + outra solicitação HTTP para buscar o arquivo importado. Sass converte os + arquivo importados e combina com o código compilado. */ @import 'reset'; @@ -339,9 +339,9 @@ body { /* 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, -   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez -   de '.' ou '#'. Placeholder não aparece no CSS compilado. */ + 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 + de '.' ou '#'. Placeholder não aparece no CSS compilado. */ %content-window { font-size: 14px; @@ -375,7 +375,7 @@ body { /* 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 um projeto simples de duas colunas. */ diff --git a/raku.md b/raku.md index ec8a4792..cf8fb2a1 100644 --- a/raku.md +++ b/raku.md @@ -6,7 +6,7 @@ contributors: - ["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. The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on diff --git a/ru/c.md b/ru/c.md index 82c82fde..60401575 100644 --- a/ru/c.md +++ b/ru/c.md @@ -33,7 +33,7 @@ translators: void function_1(); void function_2(); -// Точка входа в программу – это функция main. +// Точка входа в программу – это функция main. int main() { // для форматированного вывода в консоль используется printf // %d – означает, что будем выводить целое число, \n переводит указатель вывода @@ -120,7 +120,7 @@ int main() { printf("%d\n", a_string[16]); // => 0 // байт #17 тоже равен 0 (а также 18, 19, и 20) - // Если между одинарными кавычками есть символ – это символьный литерал, + // Если между одинарными кавычками есть символ – это символьный литерал, // но это тип int, а не char (по историческим причинам). int cha = 'a'; // хорошо @@ -325,7 +325,7 @@ int main() { // Вы также можете динамически выделять несколько блоков памяти с помощью // функции malloc из стандартной библиотеки, которая принимает один - // аргумент типа size_t – количество байт необходимых для выделения. + // аргумент типа size_t – количество байт необходимых для выделения. int *my_ptr = malloc(sizeof(*my_ptr) * 20); for (xx = 0; xx < 20; xx++) { *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx diff --git a/stylus.md b/stylus.md index f6fcf222..e43f98a8 100644 --- a/stylus.md +++ b/stylus.md @@ -81,8 +81,8 @@ a { /* 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 -  so you can distinguish a variable from another CSS value. + Although it is optional, it is recommended to add $ before a variable name + so you can distinguish a variable from another CSS value. */ $primary-color = #A3A4FF diff --git a/tr/php.md b/tr/php.md index 21d85489..593e7736 100644 --- a/tr/php.md +++ b/tr/php.md @@ -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 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 *************************************/ -// 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, // devamında da bir sayı, harf veya alt çizgi ile devam eder. diff --git a/tr/pythonlegacy.md b/tr/pythonlegacy.md index f1ccd55e..101df14b 100644 --- a/tr/pythonlegacy.md +++ b/tr/pythonlegacy.md @@ -35,8 +35,8 @@ uygulanabilir. Python 3 için başka bir zaman tekrar bakınız. 10 * 2 #=> 20 35 / 5 #=> 7 -# 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. +# 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. 5 / 2 #=> 2 # 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!" # 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' # % karakter dizisini(string) formatlamak için kullanılır, bunun gibi: "%s can be %s" % ("strings", "interpolated") # 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") -# 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") # None bir objedir None #=> None -# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın. -# Onun yerine "is" kullanın. +# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın. +# Onun yerine "is" kullanın. "etc" is None #=> False None is None #=> True # '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 0 == False #=> True "" == False #=> True @@ -122,12 +122,12 @@ some_var = 5 # Değişken isimlerinde gelenek küçük karakter ve alt çizgi # kullanmaktır. some_var #=> 5 -# 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 -# bilgi için kontrol akışı kısmına göz atınız. +# 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 +# bilgi için kontrol akışı kısmına göz atınız. 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!" # Listeler @@ -151,7 +151,7 @@ li[0] #=> 1 li[-1] #=> 3 # 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 # 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(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[0] #=> 1 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) 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 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 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 @@ -207,24 +207,24 @@ filled_dict["one"] #=> 1 # Tüm anahtarlara(key) "keys()" metodu ile ulaşılır filled_dict.keys() #=> ["three", "two", "one"] -# 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 +# 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 # Tüm değerleri almak için "values()" kullanabilirsiniz. filled_dict.values() #=> [3, 2, 1] # 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 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 -# "get()" metodu KeyError fırlatılmasını önler +# "get()" metodu KeyError fırlatılmasını önler filled_dict.get("one") #=> 1 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. filled_dict.get("one", 4) #=> 1 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 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]) -# 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} # Bir set'e daha fazla eleman eklemek @@ -253,10 +253,10 @@ filled_set & other_set #=> {3, 4, 5} # | işareti ile 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} -# "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 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 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. if some_var > 10: print "some_var is totally bigger than 10." @@ -286,7 +286,7 @@ Ekrana yazdırılan: mouse is a mammal """ 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 """ @@ -315,7 +315,7 @@ while x < 4: # 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: # "raise" bir hata fırlatmak için kullanılabilir 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 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): return args 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. def keyword_args(**kwargs): return kwargs -# Şu şekilde kullanılacaktır +# Şu şekilde kullanılacaktır keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"} # 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} """ -# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz! -# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın. +# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz! +# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın. args = (1, 2, 3, 4) kwargs = {"a": 3, "b": 4} 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(*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 adder(y): return x + y @@ -387,7 +387,7 @@ add_10(3) #=> 13 map(add_10, [1,2,3]) #=> [11, 12, 13] 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] [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. 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" # Basic initializer @@ -408,18 +408,18 @@ class Human(object): # değişkenine atama 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 def say(self, msg): return "%s: %s" % (self.name, msg) # 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 def get_species(cls): 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 def grunt(): return "*grunt*" @@ -452,24 +452,24 @@ Human.grunt() #=> "*grunt*" import math 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 print ceil(3.7) #=> 4.0 print floor(3.7) #=> 3.0 # Modüldeki tüm fonksiyonları dahil edebilirsiniz -# Uyarı: bu önerilmez +# Uyarı: bu önerilmez from math import * -# Modülün adını kısaltabilirsiniz +# Modülün adını kısaltabilirsiniz import math as m math.sqrt(16) == m.sqrt(16) #=> True -# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül -# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı -# aynı olmalıdır. +# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül +# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı +# aynı olmalıdır. -# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz. +# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz. import math dir(math) ``` diff --git a/zh-cn/vim.md b/zh-cn/vim.md index f7e3448c..53924ad1 100644 --- a/zh-cn/vim.md +++ b/zh-cn/vim.md @@ -53,15 +53,15 @@ translators: t<字符> # 向前跳移到 <字符> 的左侧 # 例如， -    f<               # 向前跳移到 < 上 + f< # 向前跳移到 < 上 t< # 向前跳移到 < 的左侧 # 按词移动 # 默认一个单词由字母，数字和下划线组成 -    w               # 移动到下一个词首 -    b               # 移动到前一个词首 -    e               # 移动到下一个词尾 + w # 移动到下一个词首 + b # 移动到前一个词首 + e # 移动到下一个词尾 # 移动的其它命令