diff options
Diffstat (limited to 'es-es')
| -rw-r--r-- | es-es/bash-es.html.markdown | 195 | ||||
| -rw-r--r-- | es-es/brainfuck-es.html.markdown | 87 | ||||
| -rw-r--r-- | es-es/go-es.html.markdown | 2 | ||||
| -rw-r--r-- | es-es/javascript-es.html.markdown | 4 | ||||
| -rw-r--r-- | es-es/perl-es.html.markdown | 120 | ||||
| -rw-r--r-- | es-es/whip-es.html.markdown | 255 | ||||
| -rw-r--r-- | es-es/xml-es.html.markdown | 131 | ||||
| -rw-r--r-- | es-es/yaml-es.html.markdown | 151 |
8 files changed, 880 insertions, 65 deletions
diff --git a/es-es/bash-es.html.markdown b/es-es/bash-es.html.markdown new file mode 100644 index 00000000..489fd39e --- /dev/null +++ b/es-es/bash-es.html.markdown @@ -0,0 +1,195 @@ +--- +category: tool +tool: bash +contributors: + - ["Max Yankov", "https://github.com/golergka"] + - ["Darren Lin", "https://github.com/CogBear"] + - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"] + - ["Denis Arh", "https://github.com/darh"] + - ["akirahirose", "https://twitter.com/akirahirose"] + - ["Anton Strömkvist", "http://lutic.org/"] +translators: + - ["Daniel Zendejas", "https://github.com/danielzendejas"] +filename: LearnBash-es.sh +--- + +Tutorial de Shell en español. + +Bash es el nombre del shell de unix, el cual también es distribuido como +el shell del sistema operativo GNU. También es el shell +por defecto de Linux y Mac OS X. Casi todos los ejemplos abajo pueden +ser parte de un script shell o ser ejecutados directamente en la terminal. + +[Leer más aquí.](http://www.gnu.org/software/bash/manual/bashref.html) + +```bash +#!/bin/bash + +# La primera línea del script es el [shebang](http://en.wikipedia.org/wiki/Shebang_(Unix)) que le indica al sistema +# cómo ejecutar el script. +# Como te habrás dado cuenta, los comentarios en shell empiezan con #. +# El shebang también es un comentario. + +# Ejemplo sencillo de hola mundo: +echo ¡Hola mundo! + +# Cada comando empieza con una nueva línea, o después de un punto y coma: +echo 'Esta es la primera línea'; echo 'Esta es la segunda línea' + +# Para declarar una variable se hace lo siguiente: +VARIABLE="Mi string" + +# Pero no así: +VARIABLE = "Mi string" + +# Bash decidirá que VARIABLE es un comando a ejecutar, dando un error. + +# Usando la variable: +echo $VARIABLE +echo "$VARIABLE" +echo '$VARIABLE' + +# Cuando la variable es usada - o asignada, exportada, etcétera - se +# escribe su nombre sin $. Si se quiere saber el valor de la variables, +# entonces sí se usa $. Note que ' (comilla simple) no expandirá las +# variables. + +# Sustitución de strings en variables. +echo ${VARIABLE/Mi/Una} +# Esto sustituirá la primera cadena "Mi" con "Una". + +# Substring de una variable. +echo ${VARIABLE:0:7} +# Esto va a regresar sólo los primeros 7 caracteres del valor. + +# Valor por defecto de una variable +echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"} +# Esto trabaja para null (VARIABLE=), string vacío (VARIABLE=""), } +# cero (VARIABLE=0) regresa 0 + +# Variables del sistema: +# Aquí hay algunas variables incluídas en el sistema: +echo "El valor de regreso del último programa: $?" +echo "PID del sistema: $$" +echo "Número de argumentos: $#" +echo "Argumentos del script: $@" +echo "Argumentos del script separados en variables: $1 $2..." + +# Para leer un valor del input: +echo "¿Cuál es tu nombre?" +read NOMBRE # Note que no necesitamos declarar una variable +echo ¡Hola, $NOMBRE! + +# Tenemos la estructura 'if' usual: +# use 'man test' para más información sobre condicionales +if [ $NOMBRE -ne $USER ] +then + echo "Tu nombre es tu usuario." +else + echo "Tu nombre no es tu usuario." +fi + +# También hay ejecuciones condicionadas. +echo "Siempre ejecutado" || echo "Sólo ejecutado si el primer comando falla" +echo "Siempre ejecutado" && echo "Sólo ejecutado si el primer comando NO falla" + +# Para usar && y || con condicionales, se necesitan +# múltiples pares de corchetes: +if [ $NOMBRE == "Steve" ] && [ $EDAD -eq 15 ] +then + echo "Esto correrá si $NOMBRE es Steve Y $EDAD es 15." +fi + +if [ $NOMBRE == "Daniya" ] || [ $NOMBRE == "Zach" ] +then + echo "Esto correrá si $NOMBRE es Daniya O Zach." +fi + +# Las expresiones se denotan con el siguiente formato: +echo $(( 10 + 5 )) + +# A diferencia de otros lenguajes de programación, bash es shell , así que +# funciona en un contexto de directorio actual. Puedes listar archivos y +# directorios en un directorio actual con el comando 'ls': +ls + +# Estos comandos tienen opciones que controlan su ejecución: +ls -l # Lista todos los archivos y directorios en líneas distintas. + +# Los resultados del comando anterior pueden ser pasados al siguiente +# como input. El comando 'grep' filtra el input con los comandos provistos. +# Así es como podemos listar archivos .txt en el directorio actual: +ls -l | grep "\.txt" + +# Puedes también redireccionar el input y el error lanzado de algún comando. +python2 hello.py < "input.in" +python2 hello.py > "output.out" +python2 hello.py 2> "error.err" + +# El error lanzado eliminará el contenido del archivo si es que existe, +# para después escribir el error. Para que se concatene (en lugar de eliminar) +# use el comando ">>". + +# Los comandos pueden ser sustituidos dentro de otros comandos usando $(): +# El siguiente ejemplo despliega el número de archivos y directorios en el +# directorio actual. +echo "Hay $(ls | wc -l) elementos aquí." + +# Lo mismo puede ser hecho usando comillas invertidas `` pero no pueden ser +# anidadas. El método preferido es $(). +echo "Hay `ls | wc -l` elementos aquí." + +# Bash usa una estructura de casos similar al switch de Java o C++: +case "$VARIABLE" in + # Lista de patrones que las condiciones deben cumplir: + 0) echo "Hay un cero.";; + 1) echo "Hay un uno.";; + *) echo "No es null.";; +esac + +# Para los ciclos, se usa la estructura 'for'. Cicla para cada argumento dado: +# El contenido de $VARIABLE se imprime tres veces. +for VARIABLE in {1..3} +do + echo "$VARIABLE" +done + +# ciclos while: +while [true] +do + echo "cuerpo del ciclo..." + break +done + +# También se pueden definir sub-rutinas (funciones) +# Definición: +function miFuncion () +{ + echo "Los argumentos trabajan igual que argumentos de script: $@" + echo "Y: $1 $2..." + echo "Esto es una función" + return 0 +} + +# O simplemente: +miOtraFuncion () +{ + echo "¡Otra forma de declarar funciones!" + return 0 +} + +# Para llamar a tu función +foo "Mi nombre es:" $NOMBRE + +# Hay muchos comandos útiles que puedes aprender: +# imprime las últimas 10 líneas del archivo file.txt +tail -n 10 file.txt +# imprime las primeras 10 líneas del archivo file.txt +head -n 10 file.txt +# ordena las líneas del archivo file.txt +sort file.txt +# identifica u omite las líneas repetidas, con -d las reporta +uniq -d file.txt +# imprime sólo la primera columna antes de cada ',' en el archivo| +cut -d ',' -f 1 file.txt +``` diff --git a/es-es/brainfuck-es.html.markdown b/es-es/brainfuck-es.html.markdown new file mode 100644 index 00000000..e33d672d --- /dev/null +++ b/es-es/brainfuck-es.html.markdown @@ -0,0 +1,87 @@ +--- +language: brainfuck +contributors: + - ["Prajit Ramachandran", "http://prajitr.github.io/"] + - ["Mathias Bynens", "http://mathiasbynens.be/"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +lang: es-es +--- + +Brainfuck (con mayúscula sólo al inicio de una oración) es un +lenguaje de programación mínimo, computacionalmente universal +en tamaño con sólo 8 comandos. + +``` + +Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas) +será ignorado. + +Brainfuck es representado por un arreglo de 30,000 celdas inicializadas +en cero y un apuntador en la celda actual. + +Existen ocho comandos: + ++ : Incrementa 1 al valor de la celda actual. +- : Decrementa 1 al valor de la celda actual. +> : Mueve el apuntador a la siguiente celda. (a la derecha) +< : Mueve el apuntador a la celda anterior. (a la izquierda) +. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A') +, : Lee un caracter como input y lo escribe en la celda actual. +[ : Si el valor en la celda actual es cero mueve el apuntador + hasta el primer ']' que encuentre. Si no es cero sigue a la + siguiente instrucción. +] : Si el valor en la celda actual es cero, entonces sigue con + la siguiente instrucción. Si no entonces mueve el apuntador + hacia atrás hasta encontrar el primer '['. + +[ y ] forman un while. Obviamente, deben estar balanceados. + +Ahora unos ejemplos de programas escritos con brainfuck. + +++++++ [ > ++++++++++ < - ] > +++++ . + +Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a +6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo +([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces, +y se regresa a la celda #1 (<), para después decrementarla en 1 (-). +Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0), +cuando esto pasa se salta a (]) y continúa. + +En este punto estamos en la celda #1, que tiene un valor de 0, mientras +que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>), +la incrementamos 5 veces para tener un valor de 65 y luego imprimimos +el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A' +se imprime. + +, [ > + < - ] > . + +Este programa lee un caracter del input y lo copia en la celda #2 (,). +Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su +valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-). +Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un +cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre +terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.). + +Ten en mente que los espacios son sólo para fines de legibilidad. +Es lo mismo escribir el ejemplo de arriba que esto: +,[>+<-]>. + +Intenta descrifrar lo que hace este programa: + +,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >> + +Este programa toma dos números como input y los multiplica. + +Primero recibe dos números del usuario. Luego empieza el ciclo externo, +condicionado en la celda #1. Luego se mueve a la celda #2, comenzando +el ciclo interno condicionado en la celda #2 incrementando la celda #3. +Sin embargo viene un problema: El ciclo interior no funcionará nuevamente +hasta la próxima vez. Para resolver este problema también incrementamos la +celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene +el resultado. +``` +Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir +tu propio intérprete de brainfuck o tu propio programa en brainfuck. El +intérprete es relativamente sencillo de hacer, pero si eres masoquista, +intenta construir tu proprio intérprete de brainfuck... en brainfuck. diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown index e788e810..86de33ec 100644 --- a/es-es/go-es.html.markdown +++ b/es-es/go-es.html.markdown @@ -77,7 +77,7 @@ func learnTypes() { saltos de línea.` // mismo tipo cadena // Literal no ASCII. Los fuentes de Go son UTF-8. - g := 'Σ' // Tipo rune, un alias de uint32, alberga un punto unicode. + g := 'Σ' // Tipo rune, un alias de int32, alberga un punto unicode. f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit. c := 3 + 4i // complex128, representado internamente por dos float64. // Sintaxis Var con inicializadores. diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown index 9b412f6e..a1348508 100644 --- a/es-es/javascript-es.html.markdown +++ b/es-es/javascript-es.html.markdown @@ -471,8 +471,8 @@ var miNumeroObjeto = new Number(12); miNumero == miNumeroObjeto; // = true // No son exactamente iguales. -typeof(miNumero); // = 'number' -typeof(miNumeroObjeto); // = 'object' +typeof miNumero; // = 'number' +typeof miNumeroObjeto; // = 'object' miNumero === miNumeroObjeyo; // = false if (0){ // Este código no se ejecutara porque 0 es false. diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown index 4f0c26c1..644182ff 100644 --- a/es-es/perl-es.html.markdown +++ b/es-es/perl-es.html.markdown @@ -7,23 +7,24 @@ contributors: - ["Korjavin Ivan", "http://github.com/korjavin"] translators: - ["Francisco Gomez", "http://github.com/frncscgmz"] + - ["Joaquín Ferrero", "http://github.com/joaquinferrero"] lang: es-es --- -Perl 5 es un lenguaje de programación altamente capaz, rico en características con mas de 25 años de desarrollo. +Perl 5 es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo. -Perl 5 corre en mas de 100 plataformas desde portales hasta mainframes y es adecuado para realizar prototipos rápidos hasta desarrollar proyectos a gran escala. +Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala. ```perl -# Comentarios de una sola linea con un carácter hash. +# Comentarios de una sola línea con un carácter hash #### Tipos de variables en Perl -# Las variables comienzan con el símbolo $. -# Un nombre de variable valido empieza con una letra o un guión bajo, -# seguido por cualquier numero de letras, números o guiones bajos. +# Las variables comienzan con el símbolo $ +# Un nombre de variable válido empieza con una letra o un guión bajo, +# seguido por cualquier número de letras, números o guiones bajos -### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes. +### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes ## Escalares # Un escalar representa un solo valor: @@ -31,99 +32,98 @@ my $animal = "camello"; my $respuesta = 42; # Los valores escalares pueden ser cadenas de caracteres, números enteros o -# de punto flotante, Perl automáticamente los convertirá como sea requerido. +# de punto flotante; Perl automáticamente los convertirá como sea requerido ## Arreglos # Un arreglo representa una lista de valores: -my @animales = {"camello","llama","buho"}; -my @numeros = {23,42,69}; -my @mixto = {"camello",42,1.23}; - - +my @animales = ("camello","llama","buho"}; +my @numeros = (23, 42, 69); +my @mixto = ("camello", 42, 1.23); ## Hashes -# Un hash representa un conjunto de pares llave/valor: - -my %color_fruta = {"manzana","rojo","banana","amarillo"}; - -# Puedes usar un espacio en blanco y el operador "=>" para asignarlos mas -# fácilmente. +# Un hash representa un conjunto de pares llave/valor: +my %color_fruta = ("manzana","rojo","banana","amarillo"); +# Puede usar un espacio en blanco y el operador "=>" para asignarlos más fácilmente my %color_fruta = ( manzana => "rojo", banana => "amarillo", - ); -# Los escalares, arreglos y hashes están mas documentados en perldata. (perldoc perldata). +); -# Los tipos de datos mas complejos pueden ser construidos utilizando -# referencias, las cuales te permiten construir listas y hashes dentro -# de listas y hashes. +# Los escalares, arreglos y hashes están más documentados en perldata (perldoc perldata) -#### Estructuras condicionales y de ciclos +# Los tipos de datos más complejos se pueden construir utilizando +# referencias, las cuales le permiten construir listas y hashes dentro +# de listas y hashes -# Perl tiene la mayoría de las estructuras condicionales y de ciclos mas comunes. +#### Estructuras condicionales y de ciclos +# Perl tiene la mayoría de las estructuras condicionales y de ciclos más comunes if ( $var ) { - ... + ...; } elsif ( $var eq 'bar' ) { - ... + ...; } else { - ... + ...; } unless ( condicion ) { - ... - } -# Esto es proporcionado como una version mas fácil de leer que "if (!condición)" + ...; +} -# La post condición al modo Perl +# Esto se ofrece como una versión más fácil de leer que "if (!condición)" + +# La postcondición al modo Perl: print "Yow!" if $zippy; print "No tenemos bananas" unless $bananas; # while - while ( condicion ) { - ... - } - +while ( condicion ) { + ...; +} # for y foreach for ($i = 0; $i <= $max; $i++) { - ... - } + ...; +} + +for $i (0 .. $max) { + ...; +} foreach (@array) { - print "Este elemento es $_\n"; - } + print "Este elemento es $_\n"; +} #### Expresiones regulares -# El soporte de expresiones regulares en Perl es muy amplio y profundo, y es -# sujeto a una extensa documentación en perlrequick, perlretut, entre otros. +# El soporte de expresiones regulares en Perl es muy amplio y profundo, y +# está sujeto a una extensa documentación en perlrequick, perlretut, entre otros. # Sin embargo, resumiendo: -# Pareo simple +# Coincidencia simple if (/foo/) { ... } # verdadero si $_ contiene "foo" if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo" # Substitución simple -$a =~ s/foo/bar/; # remplaza foo con bar en $a -$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de foo con bar en $a +$a =~ s/foo/bar/; # remplaza "foo" con "bar" en $a +$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de "foo" con "bar" en $a -#### Archivos e I/O +#### Archivos y E/S -# Puedes abrir un archivo para obtener datos o escribirlos utilizando la -# función "open()". +# Puede abrir un archivo para obtener datos o escribirlos utilizando la +# función "open()" open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!"; open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!"; open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!"; -# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>" -# operador. En contexto escalar leer una sola linea desde el gestor de -# archivo, y en contexto de lista leer el archivo completo en donde, asigna -# cada linea a un elemento de la lista. +# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>". +# En contexto escalar, leer una sola línea desde el gestor de archivo, y +# en contexto de lista, leer el archivo completo en donde asigna +# cada línea a un elemento de la lista my $linea = <$entrada>; my @lineas = <$entrada>; @@ -131,30 +131,26 @@ my @lineas = <$entrada>; #### Escribiendo subrutinas # Escribir subrutinas es fácil: - sub logger { my $mensajelog = shift; open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!"; print $archivolog $mensajelog; } -# Ahora podemos utilizar la subrutina al igual que cualquier otra función -# incorporada: - +# Ahora podemos utilizar la subrutina al igual que cualquier otra función incorporada: logger("Tenemos una subrutina logger!"); - ``` #### Utilizando módulos Perl -Los módulos en Perl proveen una gama de funciones que te pueden ayudar a evitar reinventar la rueda, estas pueden ser descargadas desde CPAN( http://www.cpan.org/ ). Algunos de los módulos mas populares ya están incluidos con la misma distribución de Perl. +Los módulos en Perl proveen de una gama de funciones que le pueden ayudar a evitar reinventar la rueda. Éstas se pueden descargar desde CPAN ( http://www.cpan.org/ ). Algunos de los módulos más populares ya están incluidos con la misma distribución de Perl. -perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos CPAN para usar. +perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos de CPAN que puede usar. #### Material de Lectura - [perl-tutorial](http://perl-tutorial.org/) - - [Aprende en www.perl.com](http://www.perl.org/learn.html) + - [Learn Perl](http://www.perl.org/learn.html) - [perldoc](http://perldoc.perl.org/) - - y perl incorporado: `perldoc perlintro` + - y en su propio perl: `perldoc perlintro` diff --git a/es-es/whip-es.html.markdown b/es-es/whip-es.html.markdown new file mode 100644 index 00000000..7c2f4bd2 --- /dev/null +++ b/es-es/whip-es.html.markdown @@ -0,0 +1,255 @@ +--- +language: whip +contributors: + - ["Tenor Biel", "http://github.com/L8D"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +author: Tenor Biel +author_url: http://github.com/L8D +filename: whip-es.lisp +lang: es-es +--- +Tutorial de Whip en español. + +Whip es un dialecto de LISP hecho para escribir código y conceptos +simples. Ha tomado prestado bastante de la sintaxis de Haskell +(un lenguaje no relacionado). + +Esta documentación fue escrita por el creador del lenguaje + +```scheme +; Los comentarios son como en LISP, con punto y coma... + +; La mayoría de las sentencias de primer nivel están dentro de +; "formas". Una forma no es más que cosas dentro de paréntesis +no_en_la_forma +(en_la_form) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 1. Números, Strings y Operadores + +;Whip tiene un tipo para números (es el estándar 64-bit IEEE 754 double, de JS) +3 ; => 3 +1.5 ; => 1.5 + +; Las funciones son llamadas si son el primer elemento de una forma +(funcion_llamada argumentos) + +; La mayoría de los operadores se hacen con funciones +; Toda la aritmética básica es bastante estándar +(+ 1 1) ; => 2 +(- 2 1) ; => 1 +(* 1 2) ; => 2 +(/ 2 1) ; => 2 +; incluso el módulo +(% 9 4) ; => 1 +; división impar al estilo de JavaScript. +(/ 5 2) ; => 2.5 + +; Las formas anidadas funcionan como se espera. +(* 2 (+ 1 3)) ; => 8 + +; Hay un tipo booleano. +true +false + +; Los Strings son creados con comillas dobles ". +"Hola mundo" + +; Los caracteres solos se declaran con comillas simples '. +'a' + +; La negación usa la función 'not'. +(not true) ; => false +(not false) ; => true + +; La mayoría de las funcions que no vienen de Haskell tienen +; atajos. La función 'not' también se puede declarar con '!'. +(! (! true)) ; => true + +; La igualdad es `equal` o `=`. +(= 1 1) ; => true +(equal 2 1) ; => false + +; Por ejemplo, la desigualdad sería combinar la función 'not' con +; la función de igualdad +(! (= 2 1)) ; => true + +; Más comparaciones +(< 1 10) ; => true +(> 1 10) ; => false +; y su contraparte textual. +(lesser 1 10) ; => true +(greater 1 10) ; => false + +; Los Strings pueden concatenarse con la función +. +(+ "Hola " "mundo!") ; => "Hello world!" + +; También puedes usar las comparativas de JavaScript +(< 'a' 'b') ; => true +; ...y la coerción de tipos +(= '5' 5) + +; La función 'at' o @ accesa a los caracteres dentro de los strings, +; empezando en 0. +(at 0 'a') ; => 'a' +(@ 3 "foobar") ; => 'b' + +; También están las variables `null` and `undefined`. +null; usado para indicar una falta de valor deliberada. +undefined; usado para indicar un valor que aún no está definido. + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 2. Variables, Listas y Diccionarios + +; Las variables son declaradas con las funciones `def` o `let`. +; Las variables que aún no son asignadas tendrán el valor `undefined`. +(def mi_variable 5) +; `def` asignará la variable al contexto global. +; `let` asignará la variable al contexto local, +; y tiene una sintaxis distinta. +(let ((mi_variable 5)) (+ mi_variable 5)) ; => 10 +(+ mi_variable 5) ; = undefined + 5 => undefined + +; Las listas son arreglos de valores de cualquier tipo. +; Básicamente, son formas sin funciones al inicio. +(1 2 3) ; => [1, 2, 3] (sintaxis JavaScript) + +; Los diccionarios son el equivalente en Whip de los 'objetos' de JavaScript, +; los 'dicts' de Python o los 'hashes' de Ruby: una colección desordenada +; de pares llave-valor +{"llave1" "valor1" "llave2" 2 3 3} + +; Las llaves son sólo valores, identificadores, números o strings. +(def mi_diccionario {mi_llave "mi_valor" "mi otra llave" 4}) +; Pero con Whip, los diccionarios son leidos así: +; "llave" "espacio en blanco" "valor" "espacio en blanco" +{"llave" "valor" +"otra llave" +1234 +} + +; Las definiciones de los diccionarios pueden accesarse con la función @ +; (como los strings y las listas) +(@ "mi otra llave" mi_diccionario) ; => 4 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; 3. Logica y secuencias de control + +; La funcion `if` es bastante simple, aunque distinta que en otros lenguajes. +(if true "regresa esto si es true" "regresa esto si es false") +; => "regresa esto si es true" + +; Y para el operador ternario `?` +(? false true false) ; => false + +? `both` es un 'y' lógico, mientras que la función `either` es un 'o'. +(both true true) ; => true +(both true false) ; => false +(either true false) ; => true +(either false false) ; => false +; Y sus atajos son '&' y '^' respectivamente +; & => both +; ^ => either +(& true true) ; => true +(^ false true) ; => true + +;;;;;;;;; +; Lambdas + +; Las Lambdas en Whip son declaradas con las funciones `lambda` o `->`. +; Las funciones regulares en realidad sólo son lambdas con nombre. +(def mi_funcion (-> (x y) (+ (+ x y) 10))) +; | | | | +; | | | valor regresado(estas son las variables argumentos) +; | | argumentos +; | declaración de lambda +; | +; nombre de la lambda + +(mi_funcion 10 10) ; = (+ (+ 10 10) 10) => 30 + +; Obviamente, todas las lambdas por definición son anónimas y +; técnicamente siempre usadas anónimamente. Redundancia. +((lambda (x) x) 10) ; => 10 + +;;;;;;;;;;;;;;;; +; Comprensiones + +; `range` o `..` genera una lista de números que comprende +; cada entero dentro de los argumentos. +(range 1 5) ; => (1 2 3 4 5) +(.. 0 2) ; => (0 1 2) + +; `map` aplica su primer argumento (que debe ser una función) +; al siguiente argumento (que es una lista). +(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4) + +; Reducir +(reduce + (.. 1 5)) +; equivale a +((+ (+ (+ 1 2) 3) 4) 5) + +; Nota: map y reduce no tienen atajos. + +; `slice` o `\` es idéntico a la función .slice() de JavaScript +; Pero toma la lista del primer argumento, no del último. +(slice (.. 1 5) 2) ; => (3 4 5) +(\ (.. 0 100) -5) ; => (96 97 98 99 100) + +; `append` o `<<` se explica solo. +(append 4 (1 2 3)) ; => (1 2 3 4) +(<< "bar" ("foo")) ; => ("foo" "bar") + +; Length se explica solo. +(length (1 2 3)) ; => 3 +(_ "foobar") ; => 6 + +;;;;;;;;;;;;;;; +; Elementos de Haskell + +; Primer elemento en una lista +(head (1 2 3)) ; => 1 + +; Lista del segundo elemento al último en una lista +(tail (1 2 3)) ; => (2 3) + +; Último elemento en una lista +(last (1 2 3)) ; => 3 + +; Contrario a `tail` +(init (1 2 3)) ; => (1 2) + +; Lista del primer elemento al argumento +(take 1 (1 2 3 4)) ; (1 2) + +; Contrario a `take` +(drop 1 (1 2 3 4)) ; (3 4) + +; Valor más pequeño de una lista +(min (1 2 3 4)) ; 1 + +; Valor más grande de una lista +(max (1 2 3 4)) ; 4 + +; Comprobar que el elemento está en la lista +(elem 1 (1 2 3)) ; true +(elem "foo" {"foo" "bar"}) ; true +(elem "bar" {"foo" "bar"}) ; false + +; Invertir el orden de la lista +(reverse (1 2 3 4)) ; => (4 3 2 1) + +; Comprobar si un elemento es par o impar +(even 1) ; => false +(odd 1) ; => true + +; Separar string en una lista de strings, separados por espacios +(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese") +; Juntar lista de strings. +(unwords ("foo" "bar")) ; => "foobar" +(pred 21) ; => 20 +(succ 20) ; => 21 +``` + +Para más información, revisa el [repositorio](http://github.com/L8D/whip) diff --git a/es-es/xml-es.html.markdown b/es-es/xml-es.html.markdown new file mode 100644 index 00000000..2e9326cf --- /dev/null +++ b/es-es/xml-es.html.markdown @@ -0,0 +1,131 @@ +--- +language: xml +filename: learnxml.xml +contributors: + - ["João Farias", "https://github.com/JoaoGFarias"] +translators: + - ["Daniel Zendejas", "https://github.com/DanielZendejas"] +lang: es-es +--- +XML es un lenguaje diseñado para guardar y transportar datos + +A diferencia de HTML, XML no especifica cómo desplegar la información, +sólo la guarda. + +* Sintaxis XML + +```xml +<!-- Los comentarios en XML son de esta forma --> + +<?xml version="1.0" encoding="UTF-8"?> +<tiendaDeLibros> + <libro categoria="COCINA"> + <titulo lenguaje="en">Everyday Italian</titulo> + <autor>Giada De Laurentiis</autor> + <anio>2005</anio> + <precio>30.00</precio> + </libro> + <libro categoria="INFANTES"> + <titulo lenguaje="en">Harry Potter</titulo> + <autor>J K. Rowling</autor> + <anio>2005</anio> + <precio>29.99</precio> + </libro> + <libro categoria="WEB"> + <titulo lenguaje="en">Learning XML</titulo> + <autor>Erik T. Ray</autor> + <anio>2003</anio> + <precio>39.95</precio> + </libro> +</tiendaDeLibros> + +<!-- Este es un archivo típico de XML. + Empieza con una declaración de metadatos (opcional). + + XML usa una estructura de árbol. El nodo raíz es 'tiendaDeLibros', el cual + tiene tres nodos hijos, todos llamados 'libros'. + Esos nodos tienen más nodos hijos, y así continúa... + + Los nodos son creados usando tags que abren y cierran, y los hijos + son sólo nodos entre estas tags.--> + + +<!-- XML guarda dos tipos de datos: + 1 - Atributos -> Son los metadatos de un nodo. + Usualmente el parseador XML usa esta información para guardar los datos + apropiadamente. Aparecen con el formato (nombre="valor") dentro de la + tag que abre. + 2 - Elementos -> Ese es el dato puro. + Eso es lo que el parseador recuperará del archivo XML. + Los elementos aparecen entre las tags que abren y cierran.--> + + +<!-- Debajo, un elemento con dos atributos. --> +<archivo tipo="gif" id="4293">computer.gif</archivo> + + +``` + +* Documentos con buen formato x Validación + +Un documento XML está bien formado cuando es sintácticamente correcto. +Aún esto, es posible inyectar más restricciones en el documento, +usando definiciones de documento, así como DTD o XML Schemas. + +Un documento XML que sigue a una definición de documento (un esquema) es +válida. + +Con esta herramienta puedes validar datos XML fuera de la aplicación + +```xml + +<!-- Debajo puedes encontrar una versión simplificada del documento + tiendaDeLibros en adición a la definición DTD.--> + +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE note SYSTEM "tiendaDeLibros.dtd"> +<tiendaDeLibros> + <libro categoriq="COCINA"> + <titulo>Everyday Italian</titulo> + <precio>30.00</precio> + </libro> +</tiendaDeLibros> + +<!-- El DTD de este documento podría verse algo así:--> + +<!DOCTYPE note +[ +<!ELEMENT tiendaDeLibros (libro+)> +<!ELEMENT libro (titulo,precio)> +<!ATTLIST libro categoria CDATA "Literatura"> +<!ELEMENT titulo (#PCDATA)> +<!ELEMENT precio (#PCDATA)> +]> + +<!--El DTD empieza con una declaración. + Después el nodo raíz es declarado, requiriendo 1 o más nodos 'libro' + Cada 'libro' debe contener exactamente un 'titulo' y un 'precio' y + un atributo llamado 'categoria', con "Literatura" como su valor + default. + Los nodos 'titulo' y 'precio' contienen datos de caracteres + parseados. + + El DTD puede ser declarado dentro del XML mismo.--> + +<?xml version="1.0" encoding="UTF-8"?> + +<!DOCTYPE note +[ +<!ELEMENT tiendaDeLibros (libro+)> +<!ELEMENT libro (titulo,precio)> +<!ATTLIST libro categoria CDATA "Literatura"> +<!ELEMENT titulo (#PCDATA)> +<!ELEMENT precio (#PCDATA)> +]> +<tiendaDeLibros> + <libro categoriq="COCINA"> + <titulo>Everyday Italian</titulo> + <precio>30.00</precio> + </libro> +</tiendaDeLibros> +``` diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown new file mode 100644 index 00000000..a5157b5d --- /dev/null +++ b/es-es/yaml-es.html.markdown @@ -0,0 +1,151 @@ +--- +language: yaml +lang: es-es +filename: learnyaml-es.yaml +contributors: + - ["Adam Brenecki", "https://github.com/adambrenecki"] +translators: + - ["Daniel Zendejas","https://github.com/DanielZendejas"] +--- +Tutorial de YAML en español. + +YAML es un lenguaje de serialización de datos diseñado para ser +leído y escrito por humanos. + +Basa su funcionalidad en JSON, con la adición de líneas nuevas +e indentación inspirada en Python. A diferencia de Python, YAML +no permite tabs literales. + +```yaml +# Los comentarios en YAML se ven así. + +################### +# TIPOS ESCALARES # +################### + +# Nuestro objeto raíz (el cual es el mismo a lo largo de todo el +# documento) será un mapa, equivalente a un diccionario, hash, +# u objeto en otros lenguajes. + +llave: valor +otra_llave: Otro valor +un_valor_numerico: 100 +notacion_cientifica: 1e+12 +booleano: true +valor_nulo: null +llave con espacios: valor +# Nótese que los strings no deben estar entre comillas, aunqué también es válido. +llave: "Un string, entre comillas." +"Las llaves tambien pueden estar entre comillas.": "valor entre comillas" + +# Los strings de líneas múltiples pueden ser escritos +# como un 'bloque literal' (usando pipes |) +# o como un 'bloque doblado' (usando >) + +bloque_literal: | + Este bloque completo de texto será preservado como el valor de la llave + 'bloque_literal', incluyendo los saltos de línea. + + Se continúa guardando la literal hasta que se cese la indentación. + Cualquier línea que tenga más indentación, mantendrá los espacios dados + (por ejemplo, estas líneas se guardarán con cuatro espacios) + +nloque_doblado: > + De la misma forma que el valor de 'bloque_literal', todas estas + líneas se guardarán como una sola literal, pero en esta ocasión todos los + saltos de línea serán reemplazados por espacio. + + Las líneas en blanco, como la anterior, son convertidos a un salto de línea. + + Las líneas con mayor indentación guardan sus saltos de línea. + Esta literal ocuparán dos líneas. + +######################## +# TIPOS DE COLECCIONES # +######################## + +# La indentación se usa para anidar. +un_mapa_indentado: + llave: valor + otra_llave: otro valor + otro_mapa_indentado: + llave_interna: valor_interno + +# Las llaves de los mapas no deben ser strings necesariamente +0.25: una llave numérica + +# Las llaves también pueden ser objetos de multi línea, usando ? para indicar +# el inicio de una llave +? | + Esto es una llave + que tiene múltiples líneas +: y este es su valor + +# YAML tambien permite colecciones como llaves, pero muchos lenguajes de +# programación se quejarán. + +# Las secuencias (equivalentes a listas o arreglos) se ven así: +una_secuencia: + - Item 1 + - Item 2 + - 0.5 # las secuencias pueden tener distintos tipos en su contenido. + - Item 4 + - llave: valor + otra_llave: otro_valor + - + - Esta es una secuencia + - ...dentro de otra secuencia + +# Dado que todo JSON está incluído dentro de YAML, también puedes escribir +# mapas con la sintaxis de JSON y secuencias: +mapa_de_json: {"llave": "valor"} +secuencia_de_json: [3, 2, 1, "despegue"] + +################################## +# CARACTERÍSTICAS EXTRAS DE YAML # +################################## + +# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten +# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo +# a continuación, ambas llaves tendrán el mismo valor: +contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves +otra_ancla: *nombre_del_ancla + +# YAML también tiene tags, que puedes usar para declarar tipos explícitamente. +string_explícito: !!str 0.5 +# Algunos parseadores implementar tags específicas del lenguaje, como el +# que se muestra a continuación, encargado de manejar números complejos en +# Python: +numero_complejo_python: !!python/complex 1+2j + +######################## +# TIPOS EXTRAS EN YAML # +######################## + +# Stirngs y números no son los únicos escalares que YAML puede entener. +# YAML también puede parsear fechas en formato ISO . +fechaHora: 2001-12-15T02:59:43.1Z +fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5 +fecha: 2002-12-14 + +# La tag !!binary indica que un string es, en realidad, un blob +# representado en base-64. +archivo_gif: !!binary | + R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5 + OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+ + +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC + AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs= + +# YAML también tiene un tipo set, que se ve de la siguiente forma: +set: + ? item1 + ? item2 + ? item3 + +# Al igual que Python, los sets sólo son mapas con valores nulos. +# El ejemplo de arriba es equivalente a: +set2: + item1: null + item2: null + item3: null +``` |