iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-04-27 15:43:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

spaces in code and link spans

Browse Source
This commit is contained in:
Boris Verkhovskiy 2024-04-20 22:52:07 -07:00
parent c9f7d9a92c
commit 12cb60f1b7
9 changed files with 156 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/lint.yml vendored
View File

@ -15,4 +15,4 @@ jobs:
with: with:
ruby-version: '3.2' ruby-version: '3.2'
- run: gem install mdl - run: gem install mdl
- run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD047 - run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD038,MD039,MD047

115
es-es/raku-es.html.markdown
View File

@ -10,7 +10,6 @@ translators:
- ["Luis F. Uceta", "https://github.com/uzluisf"] - ["Luis F. Uceta", "https://github.com/uzluisf"]
lang: es-es lang: es-es
--- ---
Raku es un lenguaje de programación altamente capaz y con características Raku es un lenguaje de programación altamente capaz y con características
abundantes para hacerlo el lenguage ideal por los próximos 100 años. abundantes para hacerlo el lenguage ideal por los próximos 100 años.
@ -58,7 +57,7 @@ my $nombre'de-variable_ = 5; # Esto funciona!
my $booleano = True; # `True` y `False` son valores booleanos en Raku. my $booleano = True; # `True` y `False` son valores booleanos en Raku.
my $inverso = !$booleano; # Puedes invertir un booleano con el operador prefijo `!` my $inverso = !$booleano; # Puedes invertir un booleano con el operador prefijo `!`
my $bool-forzado = so $str; # Y puedes usar el operador prefijo `so` que my $bool-forzado = so $str; # Y puedes usar el operador prefijo `so` que
# convierte su operador en un Bool # convierte su operador en un Bool
``` ```
### Arrays y Listas ### Arrays y Listas
@ -74,7 +73,7 @@ my @letras = <a b c>; # array de palabras, delimitado por espacios.
my @array = 1, 2, 3; my @array = 1, 2, 3;
say @array[2]; # Los índices de un array empiezan por el 0 -- Este es say @array[2]; # Los índices de un array empiezan por el 0 -- Este es
# el tercer elemento. # el tercer elemento.
say "Interpola todos los elementos de un array usando [] : @array[]"; say "Interpola todos los elementos de un array usando [] : @array[]";
#=> Interpola todos los elementos de un array usando [] : 1 2 3 #=> Interpola todos los elementos de un array usando [] : 1 2 3
@ -84,7 +83,7 @@ say "Interpola todos los elementos de un array usando [] : @array[]";
my @llaves = 0, 2; my @llaves = 0, 2;
@array[@llaves] = @letras; # Asignación usando un array que contiene valores @array[@llaves] = @letras; # Asignación usando un array que contiene valores
# índices # índices
say @array; #=> a 6 b say @array; #=> a 6 b
``` ```
@ -99,8 +98,8 @@ say @array; #=> a 6 b
## cualquier llave duplicada es deduplicada. ## cualquier llave duplicada es deduplicada.
my %hash = 1 => 2, my %hash = 1 => 2,
3 => 4; 3 => 4;
my %hash = foo => "bar", # las llaves reciben sus comillas my %hash = foo => "bar", # las llaves reciben sus comillas
# automáticamente. # automáticamente.
"some other" => "value", # las comas colgantes estań bien. "some other" => "value", # las comas colgantes estań bien.
; ;
@ -151,9 +150,9 @@ say devolver-vacio; # imprime Nil
## Algunas estructuras de control producen un valor. Por ejemplo if: ## Algunas estructuras de control producen un valor. Por ejemplo if:
sub devuelva-si { sub devuelva-si {
if True { if True {
"Truthy"; "Truthy";
} }
} }
say devuelva-si; # imprime Truthy say devuelva-si; # imprime Truthy
@ -166,7 +165,7 @@ say return-for; # imprime Nil
## Una subrutina puede tener argumentos opcionales: ## Una subrutina puede tener argumentos opcionales:
sub con-opcional($arg?) { # el signo "?" marca el argumento opcional sub con-opcional($arg?) { # el signo "?" marca el argumento opcional
say "Podría returnar `(Any)` (valor de Perl parecido al 'null') si no me pasan say "Podría returnar `(Any)` (valor de Perl parecido al 'null') si no me pasan
un argumento, o returnaré mi argumento"; un argumento, o returnaré mi argumento";
$arg; $arg;
} }
con-opcional; # devuelve Any con-opcional; # devuelve Any
@ -178,9 +177,9 @@ con-opcional(1); # devuelve 1
sub hola-a($nombre = "Mundo") { sub hola-a($nombre = "Mundo") {
say "¡Hola, $nombre!"; say "¡Hola, $nombre!";
} }
hola-a; #=> ¡Hola, Mundo! hola-a; #=> ¡Hola, Mundo!
hola-a(); #=> ¡Hola, Mundo! hola-a(); #=> ¡Hola, Mundo!
hola-a('Tú'); #=> ¡Hola, Tú! hola-a('Tú'); #=> ¡Hola, Tú!
## De igual manera, al usar la sintaxis parecida a la de los hashes ## De igual manera, al usar la sintaxis parecida a la de los hashes
## (¡Hurra, sintaxis unificada!), puedes pasar argumentos *nombrados* ## (¡Hurra, sintaxis unificada!), puedes pasar argumentos *nombrados*
@ -204,12 +203,12 @@ sub con-nombre-mandatorio(:$str!) {
say "$str!"; say "$str!";
} }
con-nombre-mandatorio(str => "Mi texto"); #=> Mi texto! con-nombre-mandatorio(str => "Mi texto"); #=> Mi texto!
con-nombre-mandatorio; # error al tiempo de ejecución: con-nombre-mandatorio; # error al tiempo de ejecución:
# "Required named parameter not passed" # "Required named parameter not passed"
# ("Parámetro nombrado requerido no proveído") # ("Parámetro nombrado requerido no proveído")
con-nombre-mandatorio(3);# error al tiempo de ejecución: con-nombre-mandatorio(3); # error al tiempo de ejecución:
# "Too many positional parameters passed" # "Too many positional parameters passed"
# ("Demasiados argumentos posicionales proveídos") # ("Demasiados argumentos posicionales proveídos")
## Si una subrutina toma un argumento booleano nombrado ... ## Si una subrutina toma un argumento booleano nombrado ...
sub toma-un-bool($nombre, :$bool) { sub toma-un-bool($nombre, :$bool) {
@ -277,7 +276,7 @@ mutar $m; # ¡$n es ahora 43!
## por naturaleza: ## por naturaleza:
mutar 42; # Parámetro '$n' esperaba un contenedor mutable, mutar 42; # Parámetro '$n' esperaba un contenedor mutable,
# pero recibió un valor Int # pero recibió un valor Int
## Si en cambio quieres una copia, debes usar `is copy`. ## Si en cambio quieres una copia, debes usar `is copy`.
@ -287,7 +286,7 @@ my $x = 42;
sub x-almacena() is rw { $x } sub x-almacena() is rw { $x }
x-almacena() = 52; # En este caso, los paréntesis son mandatorios x-almacena() = 52; # En este caso, los paréntesis son mandatorios
# (porque de otra forma, Raku piensa que la función # (porque de otra forma, Raku piensa que la función
# `x-almacena` es un identificador). # `x-almacena` es un identificador).
say $x; #=> 52 say $x; #=> 52
``` ```
@ -347,7 +346,7 @@ say $edad > 18 ?? "Eres un adulto" !! "Eres menor de 18";
given "foo bar" { given "foo bar" {
say $_; #=> foo bar say $_; #=> foo bar
when /foo/ { # No te preocupies acerca de la coincidencia inteligente – when /foo/ { # No te preocupies acerca de la coincidencia inteligente –
# solo ten presente que `when` la usa. # solo ten presente que `when` la usa.
# Esto es equivalente a `if $_ ~~ /foo/`. # Esto es equivalente a `if $_ ~~ /foo/`.
say "¡Yay!"; say "¡Yay!";
} }
@ -379,9 +378,9 @@ loop {
loop (my $i = 0; $i < 5; $i++) { loop (my $i = 0; $i < 5; $i++) {
next if $i == 3; # `next` salta a la siguiente iteración, al igual next if $i == 3; # `next` salta a la siguiente iteración, al igual
# que `continue` en otros lenguajes. Ten en cuenta que # que `continue` en otros lenguajes. Ten en cuenta que
# también puedes usar la condicionales postfix (sufijas) # también puedes usar la condicionales postfix (sufijas)
# bucles, etc. # bucles, etc.
say "¡Este es un bucle al estilo de C!"; say "¡Este es un bucle al estilo de C!";
} }
@ -398,18 +397,18 @@ for @array {
.say; # Esto es también permitido. .say; # Esto es también permitido.
# Una invocación con punto (dot call) sin "tópico" (recibidor) es # Una invocación con punto (dot call) sin "tópico" (recibidor) es
# enviada a `$_` por defecto. # enviada a `$_` por defecto.
$_.say; # lo mismo de arriba, lo cual es equivalente. $_.say; # lo mismo de arriba, lo cual es equivalente.
} }
for @array { for @array {
# Puedes... # Puedes...
next if $_ == 3; # Saltar a la siguiente iteración (`continue` en next if $_ == 3; # Saltar a la siguiente iteración (`continue` en
# lenguages parecido a C) # lenguages parecido a C)
redo if $_ == 4; # Re-hacer la iteración, manteniendo la redo if $_ == 4; # Re-hacer la iteración, manteniendo la
# misma variable tópica (`$_`) # misma variable tópica (`$_`)
last if $_ == 5; # Salir fuera del bucle (como `break` last if $_ == 5; # Salir fuera del bucle (como `break`
# en lenguages parecido a C) # en lenguages parecido a C)
} }
## La sintaxis de "bloque puntiagudo" no es específica al bucle for. ## La sintaxis de "bloque puntiagudo" no es específica al bucle for.
@ -433,7 +432,7 @@ if computación-larga() -> $resultado {
## - "infix" (infijo): en medio de (como `*` en `4 * 3`). ## - "infix" (infijo): en medio de (como `*` en `4 * 3`).
## - "circumfix" (circunfijo): alrededor de (como `[`-`]` en `[1, 2]`). ## - "circumfix" (circunfijo): alrededor de (como `[`-`]` en `[1, 2]`).
## - "post-circumfix" (pos-circunfijo): alrededor de un término, ## - "post-circumfix" (pos-circunfijo): alrededor de un término,
## posterior a otro término. ## posterior a otro término.
## (como `{`-`}` en `%hash{'key'}`) ## (como `{`-`}` en `%hash{'key'}`)
## La lista de asociatividad y precedencia se explica más abajo. ## La lista de asociatividad y precedencia se explica más abajo.
@ -506,8 +505,8 @@ False ~~ True; # True
## ociosos/infinitos, usando la Whatever Star: ## ociosos/infinitos, usando la Whatever Star:
my @array = 1..*; # 1 al Infinito! `1..Inf` es lo mismo. my @array = 1..*; # 1 al Infinito! `1..Inf` es lo mismo.
say @array[^10]; # puedes pasar arrays como subíndices y devolverá say @array[^10]; # puedes pasar arrays como subíndices y devolverá
# un array de resultados. Esto imprimirá # un array de resultados. Esto imprimirá
# "1 2 3 4 5 6 7 8 9 10" (y no se quedaré sin memoria!) # "1 2 3 4 5 6 7 8 9 10" (y no se quedaré sin memoria!)
## Nota: Al leer una lista infinita, Raku "cosificará" los elementos que ## Nota: Al leer una lista infinita, Raku "cosificará" los elementos que
## necesita y los mantendrá en la memoria. Ellos no serán calculados más de ## necesita y los mantendrá en la memoria. Ellos no serán calculados más de
## una vez. Tampoco calculará más elementos de los que necesita. ## una vez. Tampoco calculará más elementos de los que necesita.
@ -518,7 +517,7 @@ say join(' ', @array[15..*]); #=> 15 16 17 18 19
## lo que es equivalente a: ## lo que es equivalente a:
say join(' ', @array[-> $n { 15..$n }]); say join(' ', @array[-> $n { 15..$n }]);
## Nota: Si tratas de hacer cualquiera de esos con un array infinito, ## Nota: Si tratas de hacer cualquiera de esos con un array infinito,
## provocará un array infinito (tu programa nunca terminará) ## provocará un array infinito (tu programa nunca terminará)
## Puedes usar eso en los lugares que esperaría, como durante la asignación ## Puedes usar eso en los lugares que esperaría, como durante la asignación
## a un array ## a un array
@ -716,8 +715,7 @@ multi dilo(Str $s) { # un multi es una subrutina por defecto
} }
dilo("azul"); # prints "Cadena de texto: azul" dilo("azul"); # prints "Cadena de texto: azul"
dilo(True); # falla al *tiempo de compilación* con dilo(True); # falla al *tiempo de compilación* con
# "calling 'dilo' will never work with arguments of types ..." # (invocar 'dilo' nunca funcionará con argumentos de tipos ...")
# (invocar 'dilo' nunca funcionará con argumentos de tipos ...")
## con precondición arbitraria (¿recuerdas los subconjuntos?): ## con precondición arbitraria (¿recuerdas los subconjuntos?):
multi es-grande(Int $n where * > 50) { "¡Sí!" } # usando una clausura multi es-grande(Int $n where * > 50) { "¡Sí!" } # usando una clausura
multi es-grande(Int $ where 10..50) { "Tal vez." } # Usando coincidencia inteligente multi es-grande(Int $ where 10..50) { "Tal vez." } # Usando coincidencia inteligente
@ -743,7 +741,7 @@ multi sin_ti-o-contigo {
## en muchos lugares. ## en muchos lugares.
## ##
## - `is`, por ejemplo, es actualmente un `multi sub` llamado ## - `is`, por ejemplo, es actualmente un `multi sub` llamado
## `trait_mod:<is>`. ## `trait_mod:<is>`.
## - `is rw`, es simplemente un despacho a una función con esta signatura: ## - `is rw`, es simplemente un despacho a una función con esta signatura:
## sub trait_mod:<is>(Routine $r, :$rw!) {} ## sub trait_mod:<is>(Routine $r, :$rw!) {}
## ##
@ -847,7 +845,7 @@ class Clase-Atrib {
method asignar-valor($param) { # Métodos pueden tomar parámetros. method asignar-valor($param) { # Métodos pueden tomar parámetros.
$!attrib = $param; # Esto funciona porque `$!` es siempre mutable. $!attrib = $param; # Esto funciona porque `$!` es siempre mutable.
# $.attrib = $param; # Incorrecto: No puedes usar la versión inmutable `$.`. # $.attrib = $param; # Incorrecto: No puedes usar la versión inmutable `$.`.
$.otro-atrib = 5; # Esto funciona porque `$.otro-atrib` es `rw`. $.otro-atrib = 5; # Esto funciona porque `$.otro-atrib` es `rw`.
} }
@ -864,7 +862,7 @@ my $class-obj = Clase-Atrib.new(atrib => 5);
say $class-obj.devolver-valor; #=> 5 say $class-obj.devolver-valor; #=> 5
# $class-obj.atrib = 5; # Esto falla porque `has $.atrib` es inmutable # $class-obj.atrib = 5; # Esto falla porque `has $.atrib` es inmutable
$class-obj.otro-atrib = 10; # En cambio, esto funciona porque el atributo $class-obj.otro-atrib = 10; # En cambio, esto funciona porque el atributo
# público es mutable (`rw`). # público es mutable (`rw`).
``` ```
### Herencia de Objeto ### Herencia de Objeto
@ -900,7 +898,7 @@ $Richard.hablar; #=> "Hola, mi nombre es Richard"
my Niño $Madison .= new(edad => 1, nombre => 'Madison'); my Niño $Madison .= new(edad => 1, nombre => 'Madison');
$Madison.hablar; # imprime "Goo goo ga ga" dado que el método fue cambiado $Madison.hablar; # imprime "Goo goo ga ga" dado que el método fue cambiado
# en la clase Niño. # en la clase Niño.
# $Madison.color-favorito # no funciona porque no es heredado # $Madison.color-favorito # no funciona porque no es heredado
## Cuando se usa `my T $var` (donde `T` es el nombre de la clase), `$var` ## Cuando se usa `my T $var` (donde `T` es el nombre de la clase), `$var`
@ -1022,11 +1020,11 @@ try {
when X::AdHoc { say "Error: $_" } when X::AdHoc { say "Error: $_" }
#=>Error: Failed to open file /dir/foo: no such file or directory #=>Error: Failed to open file /dir/foo: no such file or directory
## Cualquier otra excepción será levantada de nuevo, dado que no ## Cualquier otra excepción será levantada de nuevo, dado que no
## tenemos un `default`. ## tenemos un `default`.
## Básicamente, si un `when` ## Básicamente, si un `when`
## Basically, if a `when` matches (or there's a `default`) marks the ## Basically, if a `when` matches (or there's a `default`) marks the
## exception as ## exception as
## "handled" so that it doesn't get re-thrown from the `CATCH`. ## "handled" so that it doesn't get re-thrown from the `CATCH`.
## You still can re-throw the exception (see below) by hand. ## You still can re-throw the exception (see below) by hand.
} }
@ -1084,7 +1082,7 @@ module Hello::World { # forma de llaves
unit module Parse::Text; # forma de ámbito de archivo unit module Parse::Text; # forma de ámbito de archivo
grammar Parse::Text::Grammar { # Una gramática (grammar en inglés) es un paquete, grammar Parse::Text::Grammar { # Una gramática (grammar en inglés) es un paquete,
# en el cual puedes usar `use` # en el cual puedes usar `use`
} # Aprenderás más acerca de gramáticas en la sección de regex } # Aprenderás más acerca de gramáticas en la sección de regex
## Como se dijo anteriormente, cualquier parte del modelo seis es también un ## Como se dijo anteriormente, cualquier parte del modelo seis es también un
@ -1180,19 +1178,19 @@ for ^5 -> $a {
## * Phasers al tiempo de compilación ## * Phasers al tiempo de compilación
BEGIN { say "[*] Se ejecuta al tiempo de compilación, " ~ BEGIN { say "[*] Se ejecuta al tiempo de compilación, " ~
"tan pronto como sea posible, una sola vez" } "tan pronto como sea posible, una sola vez" }
CHECK { say "[*] Se ejecuta al tiempo de compilación, " ~ CHECK { say "[*] Se ejecuta al tiempo de compilación, " ~
"tan tarde como sea posible, una sola vez" } "tan tarde como sea posible, una sola vez" }
## * Phasers al tiempo de ejecución ## * Phasers al tiempo de ejecución
INIT { say "[*] Se ejecuta al tiempo de ejecución, " ~ INIT { say "[*] Se ejecuta al tiempo de ejecución, " ~
"tan pronto como sea posible, una sola vez" } "tan pronto como sea posible, una sola vez" }
END { say "Se ejecuta al tiempo de ejecución, " ~ END { say "Se ejecuta al tiempo de ejecución, " ~
"tan tarde como sea posible, una sola vez" } "tan tarde como sea posible, una sola vez" }
## * Phasers de bloques ## * Phasers de bloques
ENTER { say "[*] Se ejecuta cada vez que entra en un bloque, " ~ ENTER { say "[*] Se ejecuta cada vez que entra en un bloque, " ~
"se repite en bloques de bucle" } "se repite en bloques de bucle" }
LEAVE { say "Se ejecuta cada vez que abandona un bloque, incluyendo " ~ LEAVE { say "Se ejecuta cada vez que abandona un bloque, incluyendo " ~
"cuando una excepción ocurre. Se repite en bloques de bucle"} "cuando una excepción ocurre. Se repite en bloques de bucle"}
@ -1381,8 +1379,8 @@ say 5!; #=> 120
sub infix:<veces>(Int $n, Block $r) { # infijo va en el medio sub infix:<veces>(Int $n, Block $r) { # infijo va en el medio
for ^$n { for ^$n {
$r(); # Necesitas los paréntesis explícitos para invocar la función $r(); # Necesitas los paréntesis explícitos para invocar la función
# almacenada en la variable `$r`. De lo contrario, te estaría # almacenada en la variable `$r`. De lo contrario, te estaría
# refiriendo a la variable (no a la función), como con `&r`. # refiriendo a la variable (no a la función), como con `&r`.
} }
} }
3 veces -> { say "hola" }; #=> hola 3 veces -> { say "hola" }; #=> hola
@ -1412,7 +1410,7 @@ say "abc"{1}; #=> b
%h{$llave}:delete; %h{$llave}:delete;
## es equivalente a: ## es equivalente a:
postcircumfix:<{ }>(%h, $llave, :delete); # (puedes invocar postcircumfix:<{ }>(%h, $llave, :delete); # (puedes invocar
# operadores de esta forma) # operadores de esta forma)
## ¡*Todos* usan los mismos bloques básicos! ## ¡*Todos* usan los mismos bloques básicos!
## Categorías sintácticas (prefix, infix, ...), argumentos nombrados ## Categorías sintácticas (prefix, infix, ...), argumentos nombrados
## (adverbios), ... - usados para construir el lenguaje - están al alcance ## (adverbios), ... - usados para construir el lenguaje - están al alcance
@ -1542,7 +1540,7 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
## para los parseos ambiguos es determinado por un examen multi-nivel de ## para los parseos ambiguos es determinado por un examen multi-nivel de
## desempate: ## desempate:
## - La coincidencia de token más larga. `foo\s+` le gana a `foo` ## - La coincidencia de token más larga. `foo\s+` le gana a `foo`
## (por 2 o más posiciones) ## (por 2 o más posiciones)
## - El prefijo literal más largo. `food\w*` le gana a `foo\w*` (por 1) ## - El prefijo literal más largo. `food\w*` le gana a `foo\w*` (por 1)
## - Declaración desde la gramática más derivada a la menos derivada ## - Declaración desde la gramática más derivada a la menos derivada
## (las gramáticas son actualmente clases) ## (las gramáticas son actualmente clases)
@ -1688,7 +1686,7 @@ so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # `True`. (usando `so`
## Ok. Comenzando con las explicaciones de grupos. Como dijimos, ## Ok. Comenzando con las explicaciones de grupos. Como dijimos,
### nuestra objeto `Match` está disponible en la variable `$/`: ### nuestra objeto `Match` está disponible en la variable `$/`:
say $/; # Imprimirá algo extraño (explicaremos luego) o say $/; # Imprimirá algo extraño (explicaremos luego) o
# "Nil" si nada coincidió # "Nil" si nada coincidió
## Como dijimos anteriormente, un objeto Match tiene indexación de array: ## Como dijimos anteriormente, un objeto Match tiene indexación de array:
say $/[0]; #=> ｢ABC｣ ｢ABC｣ say $/[0]; #=> ｢ABC｣ ｢ABC｣
@ -1733,9 +1731,9 @@ say $/[0][0].Str; #=> ~
say $/[0].list.perl; #=> (Match.new(...),).list say $/[0].list.perl; #=> (Match.new(...),).list
# Podemos ver que es una lista de objetos Match. # Podemos ver que es una lista de objetos Match.
# Estos contienen un montón de información: dónde la # Estos contienen un montón de información: dónde la
# coincidencia comenzó o terminó, el "ast" # coincidencia comenzó o terminó, el "ast"
# (chequea las acciones más abajo), etc. # (chequea las acciones más abajo), etc.
# Verás capturas nombradas más abajo con las gramáticas. # Verás capturas nombradas más abajo con las gramáticas.
## Alternativas - el `or` de regexes ## Alternativas - el `or` de regexes
## Advertencia: Es diferente a los regexes de PCRE. ## Advertencia: Es diferente a los regexes de PCRE.
@ -1794,7 +1792,7 @@ sub MAIN($nombre) { say "¡Hola, $nombre!" }
## (usando un "Bool" por un argumento nombrado para que podamos hacer ## (usando un "Bool" por un argumento nombrado para que podamos hacer
## `--replace` a cambio de `--replace=1`) ## `--replace` a cambio de `--replace=1`)
subset File of Str where *.IO.d; # convierte a un objeto IO para chequear si subset File of Str where *.IO.d; # convierte a un objeto IO para chequear si
# un archivo existe # un archivo existe
multi MAIN('add', $key, $value, Bool :$replace) { ... } multi MAIN('add', $key, $value, Bool :$replace) { ... }
multi MAIN('remove', $key) { ... } multi MAIN('remove', $key) { ... }
@ -1926,8 +1924,7 @@ Si quieres ir más allá de lo que se muestra aquí, puedes:
explicaciones. Las publicaciones fueron suspendidas al final del 2015 cuando explicaciones. Las publicaciones fueron suspendidas al final del 2015 cuando
el lenguaje fue declarado estable y Raku.c fue lanzado. el lenguaje fue declarado estable y Raku.c fue lanzado.
- Unirte a `#raku` en `irc.freenode.net`. Las personas aquí son siempre serviciales. - Unirte a `#raku` en `irc.freenode.net`. Las personas aquí son siempre serviciales.
- Chequear la [fuente de las funciones y clases de Raku - Chequear la [fuente de las funciones y clases de Raku](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo está principalmente
](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo está principalmente
escrito en Raku (con mucho de NQP, "Not Quite Perl" ("No Perl Todavía"), un escrito en Raku (con mucho de NQP, "Not Quite Perl" ("No Perl Todavía"), un
subconjunto de Raku que es más fácil de implementar y optimizar). subconjunto de Raku que es más fácil de implementar y optimizar).
- Leer [documentos acerca del diseño del lenguaje](http://design.raku.org). - Leer [documentos acerca del diseño del lenguaje](http://design.raku.org).

49
fr-fr/elixir-fr.html.markdown
View File

@ -11,8 +11,7 @@ filename: learnelixir-fr.ex
lang: fr-fr lang: fr-fr
--- ---
Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang. Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang.
Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités. Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités.
```elixir ```elixir
# Un commentaire simple sur une seule ligne commence par un dièse. # Un commentaire simple sur une seule ligne commence par un dièse.
@ -30,21 +29,21 @@ Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréab
## --------------------------- ## ---------------------------
# Il y a les nombres # Il y a les nombres
3 # Integer 3 # Integer
0x1F # Integer 0x1F # Integer
3.0 # Float 3.0 # Float
# Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom. # Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom.
# Ils commencent par `:`. # Ils commencent par `:`.
:hello # atom :hello # atom
# Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë # Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë
# en mémoire. # en mémoire.
{1,2,3} # tuple {1,2,3} # tuple
# Il est possible d'accéder à un element d'un tuple avec la fonction # Il est possible d'accéder à un element d'un tuple avec la fonction
# `elem`: # `elem`:
elem({1, 2, 3}, 0) #=> 1 elem({1, 2, 3}, 0) #=> 1
@ -56,10 +55,10 @@ elem({1, 2, 3}, 0) #=> 1
head #=> 1 head #=> 1
tail #=> [2,3] tail #=> [2,3]
# En Elixir, comme en Erlang, le `=` dénote un 'pattern matching' # En Elixir, comme en Erlang, le `=` dénote un 'pattern matching'
# (Filtrage par motif) et non une affectation. # (Filtrage par motif) et non une affectation.
# Cela signifie que la partie de gauche (pattern) est comparé (match) à # Cela signifie que la partie de gauche (pattern) est comparé (match) à
# la partie de droite. # la partie de droite.
# Une erreur sera lancée si aucun model (match) est trouvé. # Une erreur sera lancée si aucun model (match) est trouvé.
@ -151,7 +150,7 @@ nil && 20 #=> nil
1 != 1 #=> false 1 != 1 #=> false
1 < 2 #=> true 1 < 2 #=> true
# `===` et `!==` sont plus stricts en comparant les Integers (entiers) # `===` et `!==` sont plus stricts en comparant les Integers (entiers)
# et les Floats (nombres à virgules) : # et les Floats (nombres à virgules) :
1 == 1.0 #=> true 1 == 1.0 #=> true
1 === 1.0 #=> false 1 === 1.0 #=> false
@ -177,7 +176,7 @@ else
end end
# Condition avec `unless` (sauf). # Condition avec `unless` (sauf).
# Il correspond à la négation d'un `if` (si) # Il correspond à la négation d'un `if` (si)
unless true do unless true do
"Cela ne sera pas vu" "Cela ne sera pas vu"
else else
@ -223,11 +222,11 @@ cond do
2 * 5 == 12 -> 2 * 5 == 12 ->
"Moi non plus" "Moi non plus"
true -> true ->
"Mais moi oui (représente un else)" "Mais moi oui (représente un else)"
end end
# `try/catch` est utilisé pour attraper les valeurs rejetées. # `try/catch` est utilisé pour attraper les valeurs rejetées.
# Il supporte aussi un # Il supporte aussi un
# `after` qui est appelé autant si une valeur est jetée ou non. # `after` qui est appelé autant si une valeur est jetée ou non.
try do try do
throw(:hello) throw(:hello)
@ -299,8 +298,8 @@ end
PrivateMath.sum(1, 2) #=> 3 PrivateMath.sum(1, 2) #=> 3
# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError) # PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
# La déclaration de fonction supporte également les guards (gardes) # La déclaration de fonction supporte également les guards (gardes)
# et les clauses. # et les clauses.
# Quand une fonction avec plusieurs clauses est appelée, # Quand une fonction avec plusieurs clauses est appelée,
# la première fonction dont la clause est satisfaite par les arguments sera appelée. # la première fonction dont la clause est satisfaite par les arguments sera appelée.
# Exemple: le code `area({:circle, 3})` appelle la deuxième fonction definie plus bas, # Exemple: le code `area({:circle, 3})` appelle la deuxième fonction definie plus bas,
@ -346,7 +345,7 @@ defmodule MyMod do
end end
# L'opérateur pipe (|>) permet de passer la sortie d'une expression # L'opérateur pipe (|>) permet de passer la sortie d'une expression
# en premier paramètre d'une fonction. # en premier paramètre d'une fonction.
Range.new(1,10) Range.new(1,10)
|> Enum.map(fn x -> x * x end) |> Enum.map(fn x -> x * x end)
@ -358,7 +357,7 @@ Range.new(1,10)
## --------------------------- ## ---------------------------
# Les Structs sont des extensions des Maps. # Les Structs sont des extensions des Maps.
# Apportant en plus les valeurs par defaut, le polymorphisme et # Apportant en plus les valeurs par defaut, le polymorphisme et
# la vérification à la compilation dans Elixir. # la vérification à la compilation dans Elixir.
defmodule Person do defmodule Person do
defstruct name: nil, age: 0, height: 0 defstruct name: nil, age: 0, height: 0
@ -397,26 +396,26 @@ end
## --------------------------- ## ---------------------------
# Elixir se repose sur le modèle d'acteur pour gérer la concurrence. # Elixir se repose sur le modèle d'acteur pour gérer la concurrence.
# Pour écrire un programme concurrent en Elixir il faut trois # Pour écrire un programme concurrent en Elixir il faut trois
# primitives: spawning processes (création), sending messages (envoi) # primitives: spawning processes (création), sending messages (envoi)
# et receiving messages (réception). # et receiving messages (réception).
# Pour débuter un nouveau processus, il faut utiliser # Pour débuter un nouveau processus, il faut utiliser
# la fonction `spawn` qui prend en argument une fonction. # la fonction `spawn` qui prend en argument une fonction.
f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245> f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
spawn(f) #=> #PID<0.40.0> spawn(f) #=> #PID<0.40.0>
# `spawn` retourn un pid (identifiant de processus), il est possible # `spawn` retourn un pid (identifiant de processus), il est possible
# d'utiliser ce pid pour envoyer un message au processus. # d'utiliser ce pid pour envoyer un message au processus.
# Pour faire parvenir le message il faut utiliser l'opérateur `send`. # Pour faire parvenir le message il faut utiliser l'opérateur `send`.
# Pour que cela soit utile il faut être capable de recevoir les # Pour que cela soit utile il faut être capable de recevoir les
# messages. # messages.
# Cela est possible grâce au mechanisme de `receive`: # Cela est possible grâce au mechanisme de `receive`:
# Le bloc `receive do` est utilisé pour écouter les messages et les traiter # Le bloc `receive do` est utilisé pour écouter les messages et les traiter
# au moment de la réception. Un bloc `receive do` pourra traiter un seul # au moment de la réception. Un bloc `receive do` pourra traiter un seul
# message reçu. # message reçu.
# Pour traiter plusieurs messages, une fonction avec un bloc `receive do` # Pour traiter plusieurs messages, une fonction avec un bloc `receive do`
# doit s'appeler elle-même récursivement. # doit s'appeler elle-même récursivement.
defmodule Geometry do defmodule Geometry do
@ -471,7 +470,7 @@ Agent.update(my_agent, fn colors -> ["blue" | colors] end)
## Références ## Références
* [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org) * [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org)
* [Documentation Elixir ](https://elixir-lang.org/docs.html) * [Documentation Elixir](https://elixir-lang.org/docs.html)
* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert * ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert

59
hi-in/amd.html.markdown
View File

@ -14,10 +14,10 @@ lang: hi-in
### मूल अवधारणा ### मूल अवधारणा
```javascript ```javascript
// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : ` define` और` require` // बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : `define` और `require`
// और सभी मॉड्यूल परिभाषा और खपत के बारे में है : // और सभी मॉड्यूल परिभाषा और खपत के बारे में है :
// `define` एक मॉड्यूल को परिभाषित करता है // `define` एक मॉड्यूल को परिभाषित करता है
// ` require` निर्भरता का एक सेट का आयात करता है और // `require` निर्भरता का एक सेट का आयात करता है और
// पारित कर दिया कॉलबैक में उन्हें सेवन करती है // पारित कर दिया कॉलबैक में उन्हें सेवन करती है
// एक नया नाम देकर हम मॉड्यूल को परिभाषित करने का उपयोग करके शुरू करते हैं // एक नया नाम देकर हम मॉड्यूल को परिभाषित करने का उपयोग करके शुरू करते हैं
@ -29,13 +29,13 @@ define('awesomeAMD', function(){
}; };
// एक मॉड्यूल के कारखाने समारोह की मान है // एक मॉड्यूल के कारखाने समारोह की मान है
// जब प्राप्त होगा क्या अन्य मॉड्यूल या आवश्यकता कॉल // जब प्राप्त होगा क्या अन्य मॉड्यूल या आवश्यकता कॉल
// हमारे ` awesomeAMD` मॉड्यूल की आवश्यकता होती है । // हमारे `awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
// निर्यात मूल्य कुछ भी हो सकता है, (निर्माता ) काम करता है, // निर्यात मूल्य कुछ भी हो सकता है, (निर्माता ) काम करता है,
// वस्तुओं, पुरातन, (जो कि बहुत ज्यादा मदद नहीं करेगा , हालांकि) भी अपरिभाषित । // वस्तुओं, पुरातन, (जो कि बहुत ज्यादा मदद नहीं करेगा , हालांकि) भी अपरिभाषित ।
return isAMDAwesome; return isAMDAwesome;
}); });
// अब, हमारे ` awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं। // अब, हमारे `awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
// हमारे परिभाषित करने के लिए एक अतिरिक्त तर्क है कि नोटिस // हमारे परिभाषित करने के लिए एक अतिरिक्त तर्क है कि नोटिस
अब // मॉड्यूल की निर्भरता : अब // मॉड्यूल की निर्भरता :
define('loudmouth', ['awesomeAMD'], function(awesomeAMD){ define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
@ -51,8 +51,8 @@ define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
return tellEveryone; return tellEveryone;
}); });
// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए ` require` का उपयोग करते हैं // हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए `require` का उपयोग करते हैं
// हमारे कार्यक्रम बंद किक । ` require` के हस्ताक्षर है :(arrayOfDependencies, callback)`. // हमारे कार्यक्रम बंद किक । `require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
require(['loudmouth'], function(loudmouth){ require(['loudmouth'], function(loudmouth){
loudmouth(); loudmouth();
}); });
@ -90,7 +90,7 @@ require(['modules/someClass'], function(SomeClass){
console.log('So here we are, waiting!'); // this will run first console.log('So here we are, waiting!'); // this will run first
``` ```
परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । ` require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की ` baseUrl` के सापेक्ष ` modules` फ़ोल्डर में माना गया है : परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । `require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की `baseUrl` के सापेक्ष `modules` फ़ोल्डर में माना गया है :
* app/ * app/
* main.js * main.js
@ -102,7 +102,7 @@ console.log('So here we are, waiting!'); // this will run first
* things.js * things.js
* ... * ...
इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना ` someClass` परिभाषित कर सकते हैं : इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना `someClass` परिभाषित कर सकते हैं :
```javascript ```javascript
/* file: app/modules/someClass.js */ /* file: app/modules/someClass.js */
@ -116,7 +116,7 @@ define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
}); });
``` ```
अपने ` main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग ` requirejs.config ( configObj ) ` में परिवर्तन करने के लिए: अपने `main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग `requirejs.config ( configObj )` में परिवर्तन करने के लिए:
```javascript ```javascript
/* file: main.js */ /* file: main.js */
@ -129,13 +129,13 @@ requirejs.config({
} }
}); });
require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
//एक ` main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है, //एक `main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
// अन्यथा कोई कोड कभी चलेंगे // अन्यथा कोई कोड कभी चलेंगे
coolLib.doFancyStuffWith(helpers.transform($('#foo'))); coolLib.doFancyStuffWith(helpers.transform($('#foo')));
}); });
``` ```
` require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में ` require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु (` main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा : `require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में `require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु ( `main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :
```html ```html
<!DOCTYPE html> <!DOCTYPE html>
@ -153,7 +153,7 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL
कई लोगों को विकास के दौरान समझदार कोड संगठन के लिए एएमडी का उपयोग कर पसंद करते हैं, लेकिन अभी भी पेज लोड पर XHRs के सैकड़ों करने के बजाय उत्पादन में एक भी स्क्रिप्ट फ़ाइल जहाज करने के लिए चाहते हैं। कई लोगों को विकास के दौरान समझदार कोड संगठन के लिए एएमडी का उपयोग कर पसंद करते हैं, लेकिन अभी भी पेज लोड पर XHRs के सैकड़ों करने के बजाय उत्पादन में एक भी स्क्रिप्ट फ़ाइल जहाज करने के लिए चाहते हैं।
(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) ` require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि ` r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है। (राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) `require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि `r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
Install it using `npm`: Install it using `npm`:
```shell ```shell
@ -183,33 +183,34 @@ $ r.js -o app.build.js
}) })
``` ```
उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस ` Data-main` स्वैप: उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस `Data-main` स्वैप:
```html ```html
<script src="require.js" data-main="app/main-built"></script> <script src="require.js" data-main="app/main-built"></script>
``` ```
एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन] (https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है। एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन](https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।
### विषय इस ट्यूटोरियल में शामिल नहीं ### विषय इस ट्यूटोरियल में शामिल नहीं
* [लोडर प्लगइन्स / रूपांतरण] (http://requirejs.org/docs/plugins.html)
* [CommonJS शैली लोड हो रहा है और निर्यात] (http://requirejs.org/docs/commonjs.html) * [लोडर प्लगइन्स / रूपांतरण](http://requirejs.org/docs/plugins.html)
* [उन्नत विन्यास] (http://requirejs.org/docs/api.html#config) * [CommonJS शैली लोड हो रहा है और निर्यात](http://requirejs.org/docs/commonjs.html)
* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)] (http://requirejs.org/docs/api.html#config-shim) * [उन्नत विन्यास](http://requirejs.org/docs/api.html#config)
* [सीएसएस लदान और require.js साथ अनुकूलन] (http://requirejs.org/docs/optimization.html#onecss) * [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)](http://requirejs.org/docs/api.html#config-shim)
* (Https://github.com/jrburke/almond) [बनाता है के लिए almond.js का प्रयोग] * [सीएसएस लदान और require.js साथ अनुकूलन](http://requirejs.org/docs/optimization.html#onecss)
* [बनाता है के लिए almond.js का प्रयोग](Https://github.com/jrburke/almond)
### अग्रिम पठन: ### अग्रिम पठन:
* [सरकारी कल्पना] (https://github.com/amdjs/amdjs-api/wiki/AMD) * [सरकारी कल्पना](https://github.com/amdjs/amdjs-api/wiki/AMD)
* [क्यों एएमडी?] (Http://requirejs.org/docs/whyamd.html) * [क्यों एएमडी?](Http://requirejs.org/docs/whyamd.html)
* [यूनिवर्सल मॉड्यूल परिभाषा] (https://github.com/umdjs/umd) * [यूनिवर्सल मॉड्यूल परिभाषा](https://github.com/umdjs/umd)
### कार्यान्वयन: ### कार्यान्वयन:
* [Require.js] (http://requirejs.org) * [Require.js](http://requirejs.org)
* [डोजो टूलकिट] (http://dojotoolkit.org/documentation/tutorials/1.9/modules/) * [डोजो टूलकिट](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
* [Cujo.js] (http://cujojs.com/) * [Cujo.js](http://cujojs.com/)
* [Curl.js] (https://github.com/cujojs/curl) * [Curl.js](https://github.com/cujojs/curl)
* [Lsjs] (https://github.com/zazl/lsjs) * [Lsjs](https://github.com/zazl/lsjs)
* [एमडी] (https://github.com/alexlawrence/mmd) * [एमडी](https://github.com/alexlawrence/mmd)

29
hi-in/d.html.markdown
View File

@ -18,16 +18,15 @@ void main(string[] args) {
``` ```
अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है
के बारे में [डी ] ( http://dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है , के बारे में [डी](http://dlang.org/)। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा
अर्थपूर्ण उच्च स्तरीय चीजें । अर्थपूर्ण उच्च स्तरीय चीजें ।
D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है
[ वाल्टर ब्राइट ] ( https://en.wikipedia.org/wiki/Walter_Bright ) और [वाल्टर ब्राइट](https://en.wikipedia.org/wiki/Walter_Bright) और
[ आंद्रेई Alexandrescu ] ( https://en.wikipedia.org/wiki/Andrei_Alexandrescu )। [आंद्रेई Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu)।
जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं! जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!
```c ```c
import std.stdio; import std.stdio;
@ -48,9 +47,9 @@ void main() {
do { do {
n -= (n / 2); n -= (n / 2);
} while(n > 0); } while(n > 0);
    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं। // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है, // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
    // लेकिन पिछले छोड़कर। // लेकिन पिछले छोड़कर।
foreach(i; 1..1_000_000) { foreach(i; 1..1_000_000) {
if(n % 2 == 0) if(n % 2 == 0)
writeln(i); writeln(i);
@ -67,7 +66,7 @@ void main() {
} }
``` ```
हम ' struct`, `class`,` union`, और `` enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions हम `struct`, `class`, `union`, और `enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा, मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं! हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!
@ -130,8 +129,8 @@ auto mat = new Matrix!(3, 3);
Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति
एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं
के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (` structure.x = 7` ) है के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (`structure.x = 7`) है
मनुष्य और सेटर तरीकों ( ` object.setX (7) `) ! मनुष्य और सेटर तरीकों (`object.setX(7)`) !
```c ```c
// Consider a class parameterized on types 'T' & 'U'. // Consider a class parameterized on types 'T' & 'U'.
@ -197,15 +196,15 @@ void main() {
सीधे सदस्यों तक पहुँचने ! सीधे सदस्यों तक पहुँचने !
हमारे निपटान पर अन्य वस्तु उन्मुख उपहार हमारे निपटान पर अन्य वस्तु उन्मुख उपहार
` interface`s , ` सार class`es शामिल `interface`s , `सार class`es शामिल
और ` तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है: और `तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार । आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार ।
हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों
प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, ` pure` प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, `pure`
काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी
कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं) कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
अद्भुत ` std.algorithm` मॉड्यूल में पाया! अद्भुत `std.algorithm` मॉड्यूल में पाया!
```c ```c
import std.algorithm : map, filter, reduce; import std.algorithm : map, filter, reduce;
@ -229,7 +228,7 @@ void main() {
यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं। यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं।
UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं
या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था
[यहाँ ।] ( http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 ) [यहाँ ।](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं
एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है । एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है ।

8
it-it/logtalk-it.html.markdown
View File

@ -45,7 +45,7 @@ Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggett
# Compilazione e il caricamento dei file sorgenti # Compilazione e il caricamento dei file sorgenti
Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file` list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa): Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file `list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
```logtalk ```logtalk
?- {list}. ?- {list}.
@ -53,7 +53,7 @@ yes
``` ```
In generale, le entità potrebbero avere dipendenze sulle entità definite in altri file di origine (ad esempio le entità di biblioteca). Per caricare un file e tutte le sue dipendenze, la soluzione consigliata consiste nel definire un file _loader_ che carica tutti i file necessari per un'applicazione. Un file loader è semplicemente un file di origine, in genere denominato `loader.lgt`, che effettua chiamate ai predicati built-in `logtalk_load/1-2`, di solito In generale, le entità potrebbero avere dipendenze sulle entità definite in altri file di origine (ad esempio le entità di biblioteca). Per caricare un file e tutte le sue dipendenze, la soluzione consigliata consiste nel definire un file _loader_ che carica tutti i file necessari per un'applicazione. Un file loader è semplicemente un file di origine, in genere denominato `loader.lgt`, che effettua chiamate ai predicati built-in `logtalk_load/1-2`, di solito
da una direttiva `initialization/1` per la portabilità e conformità agli standard. Caricatore file vengono forniti per tutte le librerie, strumenti ed esempi. da una direttiva `initialization/1` per la portabilità e conformità agli standard. Caricatore file vengono forniti per tutte le librerie, strumenti ed esempi.
# Inviare un messaggio ad un oggetto # Inviare un messaggio ad un oggetto
@ -67,7 +67,7 @@ X = 3
yes yes
``` ```
Analogamente alla programmazione object-oriented, logtalk consente anche l'Incapsulamento. Analogamente alla programmazione object-oriented, logtalk consente anche l'Incapsulamento.
Un predicato può essere dichiarata pubblico, protetto o privato. Può anche essere _local_ quando non esiste una direttiva specifica per esso all'interno dello scope. Per esempio: Un predicato può essere dichiarata pubblico, protetto o privato. Può anche essere _local_ quando non esiste una direttiva specifica per esso all'interno dello scope. Per esempio:
```logtalk ```logtalk
@ -475,7 +475,7 @@ X = 3
yes yes
``` ```
Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e` abolish_events/5` . Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e `abolish_events/5`.
La programmazione event-driven può essere vista come una forma di _computational reflection_. Si noti però che gli eventi sono generati solo quando si utilizza il costrutto di controllo per l'invio di messaggi `::/2`. La programmazione event-driven può essere vista come una forma di _computational reflection_. Si noti però che gli eventi sono generati solo quando si utilizza il costrutto di controllo per l'invio di messaggi `::/2`.

24
pt-br/d-pt.html.markdown
View File

@ -21,13 +21,13 @@ void main(string[] args) {
``` ```
Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral, sobre [D](http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
abstrações expressivas de alto nível. abstrações expressivas de alto nível.
D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e [Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) e
[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu). [Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos! Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!
```d ```d
@ -71,7 +71,7 @@ void main() {
} }
``` ```
Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões Podemos definir novos tipos com `struct`, `class`, `union` e `enum`. Estruturas e uniões
são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso, são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
podemos usar modelos para parametrizar tudo isso em tipos e valores! podemos usar modelos para parametrizar tudo isso em tipos e valores!
@ -114,7 +114,7 @@ T max(T)(T a, T b) {
return a; return a;
} }
// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' // Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a'
// e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'. // e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'.
void swap(T)(ref T a, ref T b) { void swap(T)(ref T a, ref T b) {
auto temp = a; auto temp = a;
@ -179,7 +179,7 @@ class MyClass(T, U) {
void main() { void main() {
auto mc = new MyClass!(int, string)(7, "seven"); auto mc = new MyClass!(int, string)(7, "seven");
// Importe o módulo 'stdio' da biblioteca padrão para gravar no // Importe o módulo 'stdio' da biblioteca padrão para gravar no
// console (as importações podem ser locais para um escopo). // console (as importações podem ser locais para um escopo).
import std.stdio; import std.stdio;
@ -215,7 +215,7 @@ import std.algorithm : map, filter, reduce;
import std.range : iota; // cria uma gama exclusiva de final import std.range : iota; // cria uma gama exclusiva de final
void main() { void main() {
// Queremos imprimir a soma de uma lista de quadrados de ints pares // Queremos imprimir a soma de uma lista de quadrados de ints pares
// de 1 a 100. Fácil! // de 1 a 100. Fácil!
// Basta passar expressões lambda como parâmetros de modelo! // Basta passar expressões lambda como parâmetros de modelo!
@ -232,16 +232,16 @@ Observe como conseguimos construir um bom pipeline haskelliano para calcular num
Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS). Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
Com o UFCS, podemos optar por escrever uma chamada de função como método Com o UFCS, podemos optar por escrever uma chamada de função como método
ou chamada de função grátis! Walter escreveu um bom artigo sobre isso ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) [aqui](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394).
Em resumo, você pode chamar funções cujo primeiro parâmetro Em resumo, você pode chamar funções cujo primeiro parâmetro
é de algum tipo A em qualquer expressão do tipo A como método. é de algum tipo A em qualquer expressão do tipo A como método.
Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco! Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco!
```d ```d
// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos // Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos
// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos // os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos
// fazer isso simultaneamente, aproveitando o número de núcleos que temos // fazer isso simultaneamente, aproveitando o número de núcleos que temos
// disponível. // disponível.
import std.stdio; import std.stdio;
@ -252,7 +252,7 @@ void main() {
// Crie sua grande variedade // Crie sua grande variedade
auto arr = new double[1_000_000]; auto arr = new double[1_000_000];
// Use um índice, acesse todos os elementos da matriz por referência (porque vamos // Use um índice, acesse todos os elementos da matriz por referência (porque vamos
// mudar cada elemento) e apenas chame paralelo na matriz! // mudar cada elemento) e apenas chame paralelo na matriz!
foreach(i, ref elem; parallel(arr)) { foreach(i, ref elem; parallel(arr)) {
elem = sqrt(i + 1.0); elem = sqrt(i + 1.0);

16
ru-ru/php-composer-ru.html.markdown
View File

@ -27,12 +27,12 @@ curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filena
``` ```
Пользователи Windows должны следовать Пользователи Windows должны следовать
[Инструкциям по установке в Windows ](https://getcomposer.org/doc/00-intro.md#installation-windows) [Инструкциям по установке в Windows](https://getcomposer.org/doc/00-intro.md#installation-windows)
## Подтверждение установки ## Подтверждение установки
```sh ```sh
# # Проверить версию и перечислить параметры # Проверить версию и перечислить параметры
composer composer
# Получить дополнительную помощь для параметров # Получить дополнительную помощь для параметров
@ -56,13 +56,13 @@ Composer сохраняет ваши зависимости проекта в `c
# Создать новый проект в текущей папке # Создать новый проект в текущей папке
composer init composer init
# запускается интерактивная анкета с просьбой предоставить подробную информацию о вашем проекте. # запускается интерактивная анкета с просьбой предоставить подробную информацию о вашем проекте.
# Вы прекрасно можете оставить ответы пустыми, если не делаете другие проекты # Вы прекрасно можете оставить ответы пустыми, если не делаете другие проекты
# зависимыми от создаваемого проекта. # зависимыми от создаваемого проекта.
# Если файл composer.json уже существует, загрузите зависимости # Если файл composer.json уже существует, загрузите зависимости
composer install composer install
# Чтобы загрузить только зависимости для готового продукта, т.е. # Чтобы загрузить только зависимости для готового продукта, т.е.
# исключая зависимости для разработки # исключая зависимости для разработки
composer install --no-dev composer install --no-dev
@ -99,12 +99,11 @@ composer search mailgun
[Packagist.org](https://packagist.org/) является основным хранилищем для пакетов Composer. [Packagist.org](https://packagist.org/) является основным хранилищем для пакетов Composer.
Существующие сторонние пакеты ищите там. Существующие сторонние пакеты ищите там.
## composer.json` и `composer.lock` ## `composer.json` и `composer.lock`
Файл `composer.json` хранит параметры допустимых версий каждой зависимости Файл `composer.json` хранит параметры допустимых версий каждой зависимости
вашего проекта, а также другую информацию. вашего проекта, а также другую информацию.
Файл `composer.lock` хранит точную загруженную версию каждой зависимости. Файл `composer.lock` хранит точную загруженную версию каждой зависимости.
Никогда не редактируйте этот файл. Никогда не редактируйте этот файл.
@ -121,7 +120,7 @@ composer update
# Если вам нужна новая версия определённой зависимости: # Если вам нужна новая версия определённой зависимости:
composer update phpunit/phpunit composer update phpunit/phpunit
# Если вы хотите перенести пакет на более новую версию # Если вы хотите перенести пакет на более новую версию
#с изменением предпочитаемой версии, #с изменением предпочитаемой версии,
# вам может потребоваться сначала удалить старый пакет и его зависимости. # вам может потребоваться сначала удалить старый пакет и его зависимости.
composer remove --dev phpunit/phpunit composer remove --dev phpunit/phpunit
@ -141,7 +140,6 @@ $mailgun = new Mailgun\Mailgun("key");
### PSR-4-совместимый автозагрузчик ### PSR-4-совместимый автозагрузчик
Вы можете добавить в автозагрузчик свои собственные пространства имён. Вы можете добавить в автозагрузчик свои собственные пространства имён.
Добавьте поле `autoload` в `composer.json`: Добавьте поле `autoload` в `composer.json`:
@ -190,7 +188,7 @@ composer clear-cache
* Создание и распространение ваших собственных пакетов на Packagist.org или в другом репозитории * Создание и распространение ваших собственных пакетов на Packagist.org или в другом репозитории
* Предварительные и пост-скриптовые перехватчики: запуск задач, * Предварительные и пост-скриптовые перехватчики: запуск задач,
когда происходят определенные события Composer когда происходят определенные события Composer
### Ссылки ### Ссылки

16
tr-tr/css-tr.html.markdown
View File

@ -134,19 +134,19 @@ selector::after {}
#################### */ #################### */
selector { selector {
/* Ölçü birimleri kesin veya göreceli olabilir.*/
/* Göreceli birimler */ /* Ölçü birimleri kesin veya göreceli olabilir.*/
/* Göreceli birimler */
width: 50%; /* Ebeveyn elementin yüzdesel olarak genişliği */ width: 50%; /* Ebeveyn elementin yüzdesel olarak genişliği */
font-size: 2em; /* Öğenin özgün yazı tipi boyutunda katları */ font-size: 2em; /* Öğenin özgün yazı tipi boyutunda katları */
font-size: 2rem; /* veya kök ögenin yazı tipi boyutu */ font-size: 2rem; /* veya kök ögenin yazı tipi boyutu */
font-size: 2vw; /* Görüntüleme çerçevesinin genişliğinin %1 olarak katları (CSS 3) */ font-size: 2vw; /* Görüntüleme çerçevesinin genişliğinin %1 olarak katları (CSS 3) */
font-size: 2vh; /* veya onun yüksekliğinin */ font-size: 2vh; /* veya onun yüksekliğinin */
font-size: 2vmin; /* Bir vh veya vw'nin hangisi küçükse */ font-size: 2vmin; /* Bir vh veya vw'nin hangisi küçükse */
font-size: 2vmax; /* veya daha büyük... */ font-size: 2vmax; /* veya daha büyük... */
/* Kesin birimler */ /* Kesin birimler */
width: 200px; /* Piksel */ width: 200px; /* Piksel */
font-size: 20pt; /* Nokta */ font-size: 20pt; /* Nokta */
width: 5cm; /* Santimetre */ width: 5cm; /* Santimetre */
@ -236,7 +236,7 @@ Stilin önceliği ise aşağıdaki gibidir. Unutmayın, öncelik **her bir özel
* `E` `!important` kelimesi yüzünden en yüksek önceliğe sahiptir. Kullanımından kaçınmanız önerilir. * `E` `!important` kelimesi yüzünden en yüksek önceliğe sahiptir. Kullanımından kaçınmanız önerilir.
* `F` satıriçi stil olduğu için bir sonraki önceliğe sahiptir. * `F` satıriçi stil olduğu için bir sonraki önceliğe sahiptir.
* `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf` class1`, bir öznitelik `attr = 'değer'. * `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf `class1`, bir öznitelik `attr = 'değer'.
* `C`, `B` ile aynı özdeşliğe sahip olsa da, bundan sonra geldiğinden dolayı öncelik hakkına sahiptir. * `C`, `B` ile aynı özdeşliğe sahip olsa da, bundan sonra geldiğinden dolayı öncelik hakkına sahiptir.
* `B` bir sonraki önceliğe sahiptir. * `B` bir sonraki önceliğe sahiptir.
* Sonuncu önceliğe sahip olan`D`'dir. * Sonuncu önceliğe sahip olan`D`'dir.
@ -271,7 +271,7 @@ h1 {
``` ```
Medya sorguları aşağıdaki bu özellikleri içerebilir: Medya sorguları aşağıdaki bu özellikleri içerebilir:
`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Bu özelliklerin birçoğunu `min-` veya `max-` öneki ile kullanabilirsiniz. `width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Bu özelliklerin birçoğunu `min-` veya `max-` öneki ile kullanabilirsiniz.
`resolution` özelliği eski cihazlarda desteklenmediğinden ötürü `device-pixel-ratio` kullanın. `resolution` özelliği eski cihazlarda desteklenmediğinden ötürü `device-pixel-ratio` kullanın.