Cien etiquetas de script? Nunca más!

Hola, Mundo!

ven mira lo que esto muestra.

Esto es un párrafo.

Este es otro párrafo.

+ +

Este es un elemento de una lista no numerada (lista de viñetas)

Este es otro ítem

Y este es el último ítem de la lista

Primer encabezado	Segundo encabezado
Primera fila, primera columna	Primera fila, segunda columna
Segunda fila, primera columna	Segunda fila, segunda columna

Primer encabezado

Segundo encabezado

Primera fila, primera columna

Primera fila, segunda columna

Segunda fila, primera columna

Segunda fila, segunda columna

Date: Wed, 5 Oct 2016 09:38:38 -0800 Subject: [kotlin/es] Translated Kotlin to spanish (#2397) * Initial translation * Fixing typos and orthography * Added (EN) tags and missing accent marks --- es-es/kotlin-es.html.markdown | 361 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 es-es/kotlin-es.html.markdown (limited to 'es-es') diff --git a/es-es/kotlin-es.html.markdown b/es-es/kotlin-es.html.markdown new file mode 100644 index 00000000..5d2f165a --- /dev/null +++ b/es-es/kotlin-es.html.markdown @@ -0,0 +1,361 @@ +--- +language: kotlin +contributors: +- ["S Webber", "https://github.com/s-webber"] +translators: +- ["Ivan Alburquerque", "https://github.com/AlburIvan"] +lang: es-es +filename: LearnKotlin-es.kt +--- + +Kotlin es un lenguaje estático tipado para la JVM, Android y el navegador. Es +100% interoperable con Java. +[Leer mas aqui.](https://kotlinlang.org/) + +```java +// Los comentarios de una sóla línea comienzan con // + +/* + Los comentarios multilínea lucen así +*/ + +// La palabra clave "package" funciona de la misma manera que Java. + +/* +El punto de entrada para un programa de Kotlin es una función llamada "main". +A dicha función se le pasa un arreglo que contiene los argumentos de la linea de comando. +*/ +fun main(args: Array) { + /* + La declaración de valores se realiza utilizando tanto "var" como "val". + Las declaraciones "val" no pueden ser reasignadas, mientras que "var" sí. + */ + val fooVal = 10 // más adelante no podremos reasignar fooVal con un valor distinto. + var fooVar = 10 + fooVar = 20 // fooVar puede ser reasignado + + /* + En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable, + de tal manera que no tenemos que especificarlo explícitamente cada vez. + Podemos declarar explícitamente el tipo de una variable así: + */ + val foo : Int = 7 + + /* + Las cadenas pueden ser representadas de la misma manera que Java. + El escape de caracteres se realiza con una barra invertida. + */ + val fooString = "Mi Cadena está aquí!"; + val barString = "¿Imprimiendo en una nueva línea?\nNo hay problema!"; + val bazString = "¿Quíeres agregar una tabulación?\tNo hay problema!"; + println(fooString); + println(barString); + println(bazString); + + /* + Una cadena está delimitada por comillas triple ("""). + Estas cadenas pueden contener saltos de línea y otros caracteres. + */ + val fooRawString = """ + fun helloWorld(val name : String) { + println("Hola, mundo!") + } + """ + println(fooRawString) + + /* + Las cadenas pueden contener interpolación de cadenas. + La interpolación de cadenas comienza con un signo de dólar ($). + */ + val fooTemplateString = "$fooString tiene ${fooString.length} caracteres" + println(fooTemplateString) + + /* + Para que una variable pueda aceptar valor nulo se debe especificar + explícitamente como anulable añadiendole ? a su tipo. + Podemos acceder a una variable anulable mediante el uso del operador ?. + Podemos utilizar el operador ?: para especificar un valor alternativo + a usar si una variable es nula. + */ + var fooNullable: String? = "abc" + println(fooNullable?.length) // => 3 + println(fooNullable?.length ?: -1) // => 3 + fooNullable = null + println(fooNullable?.length) // => null + println(fooNullable?.length ?: -1) // => -1 + + + /* + Las funciones pueden ser declaras usando la palabra clave "fun". + Los argumentos de las funciones son especificados entre corchetes despues del nombre de la función. + Los argumentos de las funciones pueden tener opcionalmente un valor por defecto. + El tipo de retorno de las funciones, de ser requerido, es especificado despues del argumento. + */ + fun hello(name: String = "mundo") : String { + return "Hola, $name!" + } + println(hello("foo")) // => Hola, foo! + println(hello(name = "bar")) // => Hola, bar! + println(hello()) // => Hola, mundo! + + /* + Un parametro de la función puede ser marcado con la palabra clave "vararg" + que permite que una función acepte un numero variable de argumentos. + */ + fun varargExample(vararg names: Int) { + println("Argument tiene ${names.size} elementos") + } + varargExample() // => Argument tiene 0 elementos + varargExample(1) // => Argument tiene 1 elementos + varargExample(1, 2, 3) // => Argument tiene 3 elementos + + /* + Cuando una función consiste de una sola expresión entonces las llaves + pueden ser omitidas. El cuerpo es especificado despues del símbolo = + */ + fun odd(x: Int): Boolean = x % 2 == 1 + println(odd(6)) // => false + println(odd(7)) // => true + + // Si el tipo de retorno puede ser inferido entonces no se necesita + // especificarlo. + fun even(x: Int) = x % 2 == 0 + println(even(6)) // => true + println(even(7)) // => false + + // Las funciones pueden tomar funciones como argumentos y + // retornar funciones. + fun not(f: (Int) -> Boolean) : (Int) -> Boolean { + return {n -> !f.invoke(n)} + } + + // Las funciones con nombre pueden ser especificadas como argumentos + // utilizando el operador ::. + val notOdd = not(::odd) + val notEven = not(::even) + // Las funciones anónimas pueden ser especificadas como argumentos. + val notZero = not {n -> n == 0} + /* + Si una función anónima tiene un solo parametro entonces la declaración + puede ser omitida (junto con ->). El nombre del único parametro será "it". + */ + val notPositive = not {it > 0} + for (i in 0..4) { + println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") + } + + // La palabra clave "class" es usada para declarar clases. + class ExampleClass(val x: Int) { + fun memberFunction(y: Int) : Int { + return x + y + } + + infix fun infixMemberFunction(y: Int) : Int { + return x * y + } + } + /* + Para crear una nueva instancia llamamos al constructor. + Nótese que Kotlin no usa la palabra clave "new". + */ + val fooExampleClass = ExampleClass(7) + // Las funciones miembros pueden ser llamadas usando la notación de punto (.) + println(fooExampleClass.memberFunction(4)) // => 11 + /* + Si una función ha sido marcada con la palabra clave "infix" entonces + esta puede ser invocada usando la notación infija. + */ + println(fooExampleClass infixMemberFunction 4) // => 28 + + /* + Las clases "data" son una manera concisa de crear clases que solo contengan datos. + Los metodos "hashCode"/"equals" y "toString" son generados automáticamente. + */ + data class DataClassExample (val x: Int, val y: Int, val z: Int) + val fooData = DataClassExample(1, 2, 4) + println(fooData) // => DataClassExample(x=1, y=2, z=4) + + // las clases de datos tienen una función "copy". + val fooCopy = fooData.copy(y = 100) + println(fooCopy) // => DataClassExample(x=1, y=100, z=4) + + // Los objetos pueden ser estructurados en múltiples variables. + val (a, b, c) = fooCopy + println("$a $b $c") // => 1 100 4 + + // La función "with" es similar a la expresión de JavaScript "with". + data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) + val fooMutableDate = MutableDataClassExample(7, 4, 9) + with (fooMutableDate) { + x -= 2 + y += 2 + z-- + } + println(fooMutableDate) // => MutableDataClassExample(x=5, y=6, z=8) + + /* + Podemos crear una lista utilizando la función "listOf". + La lista será inmutable - los elementos no pueden ser añadidos o eliminados. + */ + val fooList = listOf("a", "b", "c") + println(fooList.size) // => 3 + println(fooList.first()) // => a + println(fooList.last()) // => c + // Los elementos de una lista se pueden acceder a través de su índice. + println(fooList[1]) // => b + + // Una lista mutable puede ser creada usando la función "mutableListOf". + val fooMutableList = mutableListOf("a", "b", "c") + fooMutableList.add("d") + println(fooMutableList.last()) // => d + println(fooMutableList.size) // => 4 + + // Podemos crear un set usando la función "setOf". + val fooSet = setOf("a", "b", "c") + println(fooSet.contains("a")) // => true + println(fooSet.contains("z")) // => false + + // Podemos crear un mapa usando la función "mapOf". + val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) + // Se puede acceder a los valores del mapa por su llave. + println(fooMap["a"]) // => 8 + + /* + Las secuencias representan colecciones evaluadas diferidamente. + Podemos crear una secuencia con la función "generateSequence". + */ + val fooSequence = generateSequence(1, {it + 1}) + val x = fooSequence.take(10).toList() + println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + + // Un ejemplo usando las secuencias para generar los números de Fibonacci: + fun fibonacciSequence() : Sequence { + var a = 0L + var b = 1L + + fun next() : Long { + val result = a + b + a = b + b = result + return a + } + + return generateSequence(::next) + } + val y = fibonacciSequence().take(10).toList() + println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] + + // Kotlin provee funciones de Orden-Mayor para trabajar con colecciones. + val z = (1..9).map {it * 3} + .filter {it < 20} + .groupBy {it % 2 == 0} + .mapKeys {if (it.key) "even" else "odd"} + println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]} + + // Un bucle "for" puede ser usado con cualquier cosa que provea un iterador. + for (c in "hello") { + println(c) + } + + // El bucle "while" funciona de la misma manera que en los demás lenguajes. + var ctr = 0 + while (ctr < 5) { + println(ctr) + ctr++ + } + do { + println(ctr) + ctr++ + } while (ctr < 10) + + /* + "if" puede ser usado como una expresión que retorna un valor. + Por esta razón el operador ternario ?: no es necesario en Kotlin. + */ + val num = 5 + val message = if (num % 2 == 0) "even" else "odd" + println("$num is $message") // => 5 is odd + + // "when" puede ser usado como alternativa a cadenas de "if-else if". + val i = 10 + when { + i < 7 -> println("primer bloque") + fooString.startsWith("hello") -> println("segundo bloque") + else -> println("else bloque") + } + + // "when" puede ser usado con argumentos. + when (i) { + 0, 21 -> println("0 or 21") + in 1..20 -> println("in the range 1 to 20") + else -> println("none of the above") + } + + // "when" puede ser usado como una función que retorna un valor. + var result = when (i) { + 0, 21 -> "0 or 21" + in 1..20 -> "in the range 1 to 20" + else -> "none of the above" + } + println(result) + + /* + Podemos analizar si un objeto es de un tipo particular usando el operador "is". + Si un objeto pasa un chequeo de tipo entonces éste se puede utilizar como + ese tipo sin convertido de forma explícita. + */ + fun smartCastExample(x: Any) : Boolean { + if (x is Boolean) { + // x es automaticamente convertido a Boolean + return x + } else if (x is Int) { + // x es automaticamente convertido a Int + return x > 0 + } else if (x is String) { + // x es automaticamente convertido a String + return x.isNotEmpty() + } else { + return false + } + } + println(smartCastExample("Hola, mundo!")) // => true + println(smartCastExample("")) // => false + println(smartCastExample(5)) // => true + println(smartCastExample(0)) // => false + println(smartCastExample(true)) // => true + + /* + Las extensiones son una manera de añadir nuevas funcionalidades a una clase. + Estas son similares a la extensión de métodos en C#. + */ + fun String.remove(c: Char): String { + return this.filter {it != c} + } + println("Hola, mundo!".remove('l')) // => Hoa, mundo! + + println(EnumExample.A) // => A + println(ObjectExample.hello()) // => hola +} + +// Las clases "enum" son similares a los tipos "enum" de Java. +enum class EnumExample { + A, B, C +} + +/* +La palabra clave "object" se puede utilizar para crear objetos únicos. +No podemos asignarlo a una variable, pero podemos hacer referencia a ella por su nombre. +Esto es similar a los objetos únicos de Scala +*/ +object ObjectExample { + fun hello() : String { + return "hola" + } +} +``` + +### Lectura Adicional + +* [Kotlin tutorials (EN)](https://kotlinlang.org/docs/tutorials/) +* [Try Kotlin in your browser (EN)](http://try.kotlinlang.org/) +* [A list of Kotlin resources (EN)](http://kotlin.link/) -- cgit v1.2.3 From fba82d2f797e07778b76b160c5125cca512a05e2 Mon Sep 17 00:00:00 2001 From: Ivan Alberto Date: Wed, 5 Oct 2016 23:23:03 -0800 Subject: [vim/es] Translated Vim to spanish (#2420) * Initial version of translation * Traslated - Vim english to spanish * Fixed indentations --- es-es/vim-es.html.markdown | 242 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 242 insertions(+) create mode 100644 es-es/vim-es.html.markdown (limited to 'es-es') diff --git a/es-es/vim-es.html.markdown b/es-es/vim-es.html.markdown new file mode 100644 index 00000000..df97aa3d --- /dev/null +++ b/es-es/vim-es.html.markdown @@ -0,0 +1,242 @@ +--- +category: tool +tool: vim +contributors: + - ["RadhikaG", "https://github.com/RadhikaG"] +translators: + - ["Ivan Alburquerque", "https://github.com/AlburIvan"] +lang: es-es +filename: LearnVim-es.txt +--- + + +[Vim](http://www.vim.org) +(Vi IMproved) es un clón del popular editor vi para UNIX. Es un editor de texto +diseñado para ser veloz e incrementar la productividad, es ubicuo en la mayoría +de los sistemas basados en UNIX. Cuenta con numerosas combinaciones de teclas +para la navegación rápida a puntos especificos en un archivo y para rápida edición. + + + +## Fundamentos de la navegación en Vim + +``` + vim # Abre en vim + :q # Salir de vim + :w # Guardar archivo actual + :wq # Guardar archivo y salir de vim + :q! # Salir de vim sin guardar el archivo + # ! *forza* :q a ejecutarse, por lo tanto sale de vim sin guardar + :x # Guardar el archivo y salir de vim, versión corta de :wq + + u # Deshacer + CTRL+R # Rehacer + + h # Desplazarse un carácter hacía la izquierda + j # Desplazarse una línea hacía abajo + k # Desplazarse una línea hacía arriba + l # Desplazarse un carácter hacía la derecha + + # Desplazarse dentro de la línea + + 0 # Desplazarse hacia el inicio de la línea + $ # Desplazarse al final de la línea + ^ # Desplazarse al primer carácter no blanco en la línea + + # Buscando en el texto + + /word # Resalta todas las ocurrencias de la palabra después del cursor + ?word # Resalta todas las ocurrencias de la palabra antes del cursor + n # Desplaza el cursor a la siguiente ocurrencia de la palabra después de una búsqueda + N # Desplaza el cursor a la anterior ocurrencia de la palabra + + :%s/foo/bar/g # Cambia 'foo' a 'bar' en cada línea en el archivo + :s/foo/bar/g # Cambia 'foo' a 'bar' en la línea actual + + # Saltando caracteres + + f # Salta adelante y aterriza en + t # Salta adelante y aterriza antes de + + # Por ejemplo, + f< # Salta adelante y aterriza en < + t< # Salta adelante y aterriza justo antes de < + + # Desplazarse por palabras + + w # Desplazarse hacia adelante por una palabra + b # Desplazarse hacia atrás por una palabra + e # Desplazarse al final de la palabra actual + + # Otros caracteres para desplazarse + + gg # Ir al principio del archivo + G # Ir al final del archivo + :NUM # Ir a la línea número NUM (NUM es cualquier número) + H # Desplazarse al principio de la pantalla + M # Desplazarse a la mitad de la pantalla + L # Desplazarse al final de la pantalla +``` + +## Modos: + +Vim se basa en el concepto de **modos**. + + +Modo Comando - Vim se pone en marcha en éste modo, se usa para navegar y escribir comandos +Modo Inserción - Utilizado para realizar cambios en el archivo +Modo Visual - Utilizado para resaltar texto y operar en ellos +Modo Ex - Utilizado para ir hacia la parte inferior con ':' para introducir comandos + + +``` + i # Pone a Vim en modo de inserción, antes de la posición del cursor + a # Pone a Vim en modo de inserción, después de la posición del cursor + v # Pone a Vim en modo de visual + : # Pone a Vim en modo Ex + # Sale de cualquier modo en que se encuentre, al modo comando + + # Copiando y pegando texto + + y # Copia lo que se encuentre seleccionado + yy # Copia la linea actual + d # Elimina lo que se encuentre seleccionado + dd # Elimina la linea actual + p # Pega el texto copiado después de la posición del cursor + P # Pega el texto copiado antes de la posición del cursor + x # Elimina el carácter debajo de la posición del cursor +``` + +## La "Gramática" de vim + +Vim puede ser pensado como un conjunto de comandos en un +formato "verbo-sustantivo-modificador ', donde: + +Verbo - La acción a realizar +Modificador - Como vas hacer la acción +Sustantivo - el objeto al que se le va a aplicar la acción + +Algunos ejemplos importantes de "Verbos", "Modificadores" y "Sustantivos": + +``` + # 'Verbos' + + d # Eliminar + c # Cambiar + y # Copiar + v # Seleccionar visualmente + + # 'Modificadores' + + i # Dentro + a # Alrededor + NUM # Número (NUM es cualquier número) + f # Busca algo y aterriza sobre el + t # Busca algo y se detiene antes de + / # Encuentra una cadena desde el cursor en adelante + ? # Encuentra una cadena antes del cursor + + # 'Sustantivos' + + w # Palabra + s # Oración + p # Párrafo + b # Bloque + + # "Frases" de ejemplo o comandos + + d2w # Elimina 2 palabras + cis # Cambia dentro de una oración + yip # Copia dentro de un párrafo (copia el párrafo donde estás) + ct< # Cambia para abrir un paréntesis + # Cambie el texto desde donde está a la siguiente paréntesis abierto + d$ # Eliminar hasta el final de la línea +``` + +## Algunos accesos directos y trucos + +``` + > # Sangrar la selección por un bloque + < # Desangrar la selección por un bloque + :earlier 15m # Devuelve el documento de nuevo a como era hace 15 minutos + :later 15m # Deshace el comando anterior + ddp # Intercambia la posición de las lineas consecutivas, dd después p + . # Repite la acción previa +``` + +## Macros + +Las macros son, básicamente, las acciones que se pueden grabar. +Cuando comienzas a grabar un macro, registra **todas** las acciones y comandos +que se utilizan hasta que detenga la grabación. En la invocación de un macro, +se aplica exactamente la misma secuencia de acciones y comandos de nuevo +en la selección de texto. + +``` + qa # Comienza a grabar un macro llamada 'a' + q # Detiene la grabación + @a # Comienza la reproducción del macro +``` + +### Configurando ~/.vimrc + +El archivo .vimrc puede ser usado para configurar Vim en el arranque. + +Aquí está un ejemplo de un archivo ~ / .vimrc: + +``` +" Ejemplo ~/.vimrc +" 2015.10 + +" Se requiere para que vim sea 'mejor' +set nocompatible + +" Determina la extensión del archivo por el nombre para permitir el auto-indentado inteligente, etc... +filetype indent plugin on + +" Habilita el resaltado de sintaxis +syntax on + +" Mejor terminación de línea de comandos +set wildmenu + +" Usa búsqueda sensible a mayúsculas excepto cuando se utilizan letras mayúsculas +set ignorecase +set smartcase + +" Al abrir una nueva línea, si la sangría especifica del archivo no está habilitada, +" mantén la misma sangría que la línea que estás actualmente +set autoindent + +" Despliega el número de línea a la izquierda +set number + +" Opciones de sangría, cambialas de acuerdo a tus preferencias personales + +" Número de espacios visuales por tabulación +set tabstop=4 + +" Número de espacios de las tabulaciones al editar +set softtabstop=4 + +" Número de espacios sangrados cuando las operaciones de resangrado (>> y <<) son usadas +set shiftwidth=4 + +" Convertir tabulaciones en espacios +set expandtab + +" Habilitar la tabulación inteligente y el espaciamiento para el sangrado y la alineación +set smarttab +``` + +### Referencias + +[Vim | Home (EN)](http://www.vim.org/index.php) + +`$ vimtutor` Command + +[A vim Tutorial and Primer (EN)](https://danielmiessler.com/study/vim/) + +[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread) (EN)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) + +[Arch Linux Wiki (EN)](https://wiki.archlinux.org/index.php/Vim) \ No newline at end of file -- cgit v1.2.3 From 877fa11984110c963eed754b3fb6f5ac170381ab Mon Sep 17 00:00:00 2001 From: Ivan Alberto Date: Thu, 6 Oct 2016 06:05:31 -0800 Subject: [jQuery/es] Translated jQuery to spanish (#2422) * Initial translation * Added missing end mark --- es-es/jquery-es.html.markdown | 141 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) create mode 100644 es-es/jquery-es.html.markdown (limited to 'es-es') diff --git a/es-es/jquery-es.html.markdown b/es-es/jquery-es.html.markdown new file mode 100644 index 00000000..d35e6f17 --- /dev/null +++ b/es-es/jquery-es.html.markdown @@ -0,0 +1,141 @@ +--- +category: tool +tool: jquery +contributors: + - ["Sawyer Charles", "https://github.com/xssc"] +translators: + - ["Ivan Alburquerque", "https://github.com/AlburIvan"] +lang: es-es +filename: jquery-es.js +--- + +jQuery es una librería de JavaScript que le ayuda a "hacer más y escribir menos". Esto hace que muchas de las tareas comunes de JavaScript sean más fáciles de escribir. jQuery es utilizado por muchas de las grandes empresas y desarrolladores de todo el mundo. Hace que AJAX, la gestión de eventos, la manipulación de documentos, y mucho más, sea más fácil y rápido. + +Debido a que jQuery es una librería de JavaScript debes [aprender JavaScript primero](https://learnxinyminutes.com/docs/es-es/javascript-es/) + +```js + + +/////////////////////////////////// +// 1. Selectores + +// Los selectores en jQuery son usados para seleccionar un elemento +var page = $(window); // Selecciona toda la ventana gráfica + +// Los selectores también pueden ser selectores CSS +var paragraph = $('p'); // Selecciona todos los elementos de párrafo +var table1 = $('#table1'); // Selecciona el elemento con id 'tabla1' +var squares = $('.square'); // Selecciona todos los elementos con la clase "square" +var square_p = $('p.square') // Selecciona los párrafos con la clase "square" + + +/////////////////////////////////// +// 2. Eventos y efectos + +// Un evento muy común que se utiliza es el evento 'ready' en el documento +// Se puede utilizar el método de 'ready' para esperar hasta que el elemento haya terminado de cargar +$(document).ready(function(){ + // El código no se ejecutará hasta que el documento haya terminado de cargar +}); + +// jQuery es muy bueno activando eventos +// Y también en el manejo de lo que ocurre cuando se activa un evento +$('#button').click(); // Dispara un evento click en $ ('# botón') +$('#button').click(function(){ + // El código es ejecutado cuando se hace clic en el elemento de botón # +}); + +function onAction() { + // Esto se ejecuta cuando se activa el evento +} + +// Algunos otros eventos comunes son: +$('#btn').dblclick(onAction); //Doble clic +$('#btn').hover(onAction); // Pasar el cursor por encima +$('#btn').focus(onAction); // Enfocado +$('#btn').blur(onAction); // Pierde enfoque +$('#btn').submit(onAction); // Enviado +$('#btn').select(onAction); // Cuando se selecciona un elemento +$('#btn').keydown(onAction); // Cuando una tecla es empujada hacia abajo +$('#btn').keyup(onAction); // Cuando se suelta una tecla +$('#btn').keypress(onAction); // Cuando se pulsa una tecla +$('#btn').mousemove(onAction); // Cuando se mueve el mouse +$('#btn').mouseenter(onAction); // El mouse entra en el elemento +$('#btn').mouseleave(onAction); // El mouse sale en el elemento + +// También se puede utilizar una función anónima +$('#btn').hover(function(){ + // Se ejecuta al pasar por encima +}); + +// Todos estos pueden también desencadenar el evento en lugar de manejarlo +// Simplemente no pasando ningún parámetro +$('#btn').dblclick(); // Dispara el evento de doble clic sobre el elemento + +// Se puede manejar múltiples eventos, usando el selector una vez +$('#btn').on( + {dblclick: myFunction1} // Activado con doble clic + {blur: myFunction1} // Activo en la perdida de enfoque +); + +// Puede mover y ocultar elementos con algunos métodos de efecto +$('.table').hide(); # Oculta el(los) elemento(s) + +// Nota: llamar a una función en estos métodos aún oculta el elemento +$('.table').hide(function(){ + // El elemento se oculta entonces función ejecutada +}); + +// Puedes almacenar los selectores en las variables +var tables = $('.table'); + +// Algunos métodos básicos de manipulación de documento son: +tables.hide(); // Oculta elemento(s) +tables.show(); // Muestra elemento(s) +tables.toggle(); // Cambia el estado de ocultar / mostrar +tables.fadeOut(); // Desvanece +tables.fadeIn(); // Fundirse +tables.fadeToggle(); // Desvanece dentro o fuera +tables.fadeTo(0.5); // Desvanece a una opacidad (entre 0 y 1) +tables.slideUp(); // Desliza hacia arriba +tables.slideDown(); // Desliza hacia abajo +tables.slideToggle(); // Desliza hacia arriba o hacia abajo + +// Todo lo anterior toma una velocidad (milisegundos) y la función de devolución de llamada +tables.hide(1000, myFunction); // Animación de ocultar elemento a 1 segundo y luego la funcion de devolución + +// 'fadeTo' requiere de una opacidad como su segundo parámetro +tables.fadeTo(2000, 0.1, myFunction); // 2 segundos. decolorar a opacidad de 0.1 luego la función + +// Puede conseguir un efecto un poco más avanzado con el método 'animate' +tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction); +// El método 'animate' toma un objeto de CSS y los valores finales, +// Parámetro opcional de opciones para afinar la animación, +// Y por supuesto la función de devolución de llamada + +/////////////////////////////////// +// 3. Manipulación + +// Estos son similares a los efectos, pero pueden hacer más +$('div').addClass('div') // Añade la clase div a todos los divs + +// Métodos comunes de manipulación +$('p').append('Hola mundo'); // Añade al final del elemento +$('p').attr('class'); // Obtiene atributo +$('p').attr('class', 'content'); // Configura atributos +$('p').hasClass('div'); //Devuelve verdadero si tiene la clase +$('p').height(); // Obtiene la altura del elemento o define la altura + + +// Para muchos métodos de manipulación, obtener información sobre un elemento +// consigue solamente el primer elemento coincidente +$('p').height(); // Obtiene sólo la altura de la primera etiqueta 'p' + +// Puedes utilizar 'each' para recorrer todos los elementos +var heights = []; +$('p').each(function() { + heights.push($(this.height)); // Añade todas las alturas "p" de la etiqueta a la matriz +}); + + +``` \ No newline at end of file -- cgit v1.2.3 From 347996a2fc6ea18eccff806fa0f78c0b2b93e787 Mon Sep 17 00:00:00 2001 From: Ivan Alberto Date: Thu, 6 Oct 2016 07:44:58 -0800 Subject: [php-composer/es] Translated php-composer to spanish (#2423) * Initial translation * Fixed accent marks --- es-es/php-composer-es.html.markdown | 176 ++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 es-es/php-composer-es.html.markdown (limited to 'es-es') diff --git a/es-es/php-composer-es.html.markdown b/es-es/php-composer-es.html.markdown new file mode 100644 index 00000000..3add3e31 --- /dev/null +++ b/es-es/php-composer-es.html.markdown @@ -0,0 +1,176 @@ +--- +category: tool +tool: composer +contributors: + - ["Brett Taylor", "https://github.com/glutnix"] +translators: + - ["Ivan Alburquerque", "https://github.com/AlburIvan"] +lang: es-es +filename: LearnComposer-es.sh +--- + +[Composer](https://getcomposer.org/) es una herramienta para manejar las dependencias en PHP. Nos permite declarar las librerías de las cuales el proyecto depende y las maneja automáticamente (instala/actualiza) por ti. + +# Instalando + +```sh +# Instala el binario 'composer.phar' en el directorio actual +curl -sS https://getcomposer.org/installer | php +# Si utiliza este método, tendrá que invocar a 'composer' de esta manera: +php composer.phar about + +# Instala el binario en ~/bin/composer +# Nota: asegúrese de que ~/bin está en la variable de entorno PATH del shell +curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer +``` + +Los usuarios de Windows deben seguir las [instrucciones de instalación de Windows (EN)](https://getcomposer.org/doc/00-intro.md#installation-windows) + +## Confirmación de la instalación + +```sh +# Comprobar la versión y lista las opciones +composer + +# Obtener más ayuda para las opciones +composer help require + +# Comprueba si composer es capaz hacer las cosas que necesita y si está actualizado +composer diagnose +composer diag # versión corta + +# Actualiza el binario composer a la última versión +composer self-update +composer self # versión corta +``` + +# Uso + +Composer almacena sus dependencias del proyecto en `composer.json`. Usted puede editar este archivo, pero lo mejor es dejar que composer lo gestione por usted. + +```sh +# Crear un nuevo proyecto en la carpeta actual +composer init +# Este corre un cuestionario interactivo que le pide detalles sobre su proyecto. +# Dejándolos en blanco está bien a menos que usted está haciendo otros proyectos que dependen de éste. + +# Si un archivo 'composer.json' ya existe, descargar las dependencias +composer install + +# Para descargar solo las dependencias de producción, es decir, excluyendo las +# dependencias de desarrollo +composer install --no-dev + +# Añadir una dependencia de producción a este proyecto +composer require guzzlehttp/guzzle +# Composer buscará cuál es la última versión de guzzlehttp/Guzzle, lo descarga, +# y finalmente añade la nueva dependencia al campo requerido en 'composer.json'. + +composer require guzzlehttp/guzzle:6.0.* +# Composer descargará la versión más reciente que coincida con el patrón +# (ej 6.0.2) y añade la dependencia al campo requerido en 'composer.json'. + +composer require --dev phpunit/phpunit:~4.5.0 +# Se requerirá como una dependencia de desarrollo. Se usará la última +# versión >= 4.5.0 y < 4.6.0 + +composer require-dev phpunit/phpunit:^4.5.0 +# Se requerirá como una dependencia de desarrollo. Se usará la última versión >= 4.5.0 y < 5.0 + +# Para obtener más información sobre las coincidencias de versiones de Composer, +ver [La Documentación de Composer\'s Sobre Versiones (EN)](https://getcomposer.org/doc/articles/versions.md) + +# Para ver qué opciones están disponibles para instalar y los paquetes instalados actualmente +composer show + +# Para ver qué paquetes están instalados actualmente +composer show --installed + +# Para encontrar un paquete con 'mailgun' en su nombre o descripción +composer search mailgun +``` + +[Packagist.org (EN)](https://packagist.org/) es el repositorio principal de paquetes de Composer. Busca allí para paquetes existentes de terceros. + +## `composer.json` vs `composer.lock` + +El archivo `composer.json` almacena las preferencias de versión flotantes de su proyecto para cada dependencia, junto con otra información. + +El archivo `composer.lock` almacena exactamente cuál es la versión que ha descargado para cada dependencia. Nunca editar este archivo. + +Si se incluye el archivo `composer.lock` en su repositorio git, todos los desarrolladores instalarán la versión utilizada actualmente de la dependencia. Incluso cuando se libera una nueva versión de una dependencia, Composer continuará para descargar la versión grabada en el archivo '.lock'. + +```sh +# Si desea actualizar todas las dependencias a su versión más reciente aún que coincidan con sus preferencias versión +composer update + +# Si desea la nueva versión de una dependencia particular: +composer update phpunit/phpunit + +# Si desea migrar la preferencia de un paquete a una versión más reciente, puede que tenga que quitar primero el paquete de más antiguo y sus dependencias. +composer remove --dev phpunit/phpunit +composer require --dev phpunit/phpunit:^5.0 + +``` + +## Autocargador + +Composer crea una clase de cargador automático que puede requerir su aplicación. Se puede hacer instancias de clases a través de su espacio de nombres. + +```php +require __DIR__ . '/vendor/autoload.php'; + +$mailgun = new Mailgun\Mailgun("key"); +``` + +### PSR-4 Autocargador + +Usted puede añadir sus propios espacios de nombres para el cargador automático. + +En `composer.json`, añadir el campo 'autoload': + +```json +{ + "autoload": { + "psr-4": {"Acme\\": "src/"} + } +} +``` +Esto le indicará al cargador automático que busque cualquier cosa en el espacio de nombres `\Acme\` dentro de la carpeta src`. + +También puedes usar [usar PSR-0, un mapa de clase o simplemente una lista de archivos para incluir (EN)](https://getcomposer.org/doc/04-schema.md#autoload). También está el campo `autoload-dev` para espacios de nombres de sólo desarrollo. + +Al añadir o modificar la clave de carga automática, tendrá que reconstruir el cargador automático: + +```sh +composer dump-autoload +composer dump # shorthand + +# Optimiza los paquetes PSR0 y PSR4 a ser cargados con classmaps también. Es lento para correr, pero mejora el rendimiento en producción. +composer dump-autoload --optimize --no-dev +``` + +# El Cache de Composer + +```sh +# Composer retendrá los paquetes descargados para su uso en el futuro. Puede removerlos con: +composer clear-cache +``` + +# Solución de problemas + +```sh +composer diagnose +composer self-update +composer clear-cache +``` + +## Temas (todavía) no cubiertos en este tutorial + +* Crear y distribuir tus propios paquetes en Packagist.org o en otra parte +* Pre- y post- script: ejecutar tareas cuando ciertos eventos tienen lugar composer + +### Referencias + +* [Composer - Dependency Manager for PHP (EN)](https://getcomposer.org/) +* [Packagist.org (EN)](https://packagist.org/) \ No newline at end of file -- cgit v1.2.3 From 6f3c07ce8ac3431f7e3b35568e51f9ecc736b329 Mon Sep 17 00:00:00 2001 From: Gino Amaury Date: Fri, 7 Oct 2016 03:07:48 -0500 Subject: Translate binary search to spanish (#2425) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Añadido html en español * traduccion html a español sin revision * Traduccion html al español corregido * Correccion de la configuraciond el header * Correccion de links * creacion del archivo en la carpeta de traduccion * traduccion busqueda binaria español --- es-es/binary-search-es.html.markdown | 68 ++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 es-es/binary-search-es.html.markdown (limited to 'es-es') diff --git a/es-es/binary-search-es.html.markdown b/es-es/binary-search-es.html.markdown new file mode 100644 index 00000000..a1b42d21 --- /dev/null +++ b/es-es/binary-search-es.html.markdown @@ -0,0 +1,68 @@ +--- +category: Algorithms & Data Structures +name: Binary Search +contributors: + - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"] +translators: + - ["Gino Amaury", "https://github.com/ginoamaury"] +lang: es-es +--- + +# Búsqueda Binaria + +## Por qué Búsqueda Binaria? + +La búsqueda es uno de los problemas principales en el dominio de la ciencia de la computación. Hoy en dia hay mas de 1 billon de búsquedas por año, y necesitamos tener algoritmos que puedan hacer esto muy rápido. La búsqueda binaria es uno de los algoritmos fundamentales en la ciencia de la computación. Con el fin de explorarlo, vamos a construir por primera vez un esqueleto teórico y lo utilizaremos para implementar el algoritmo apropiadamente. + +## Introducción + +Un método sencillo para poner en práctica la búsqueda es hacer una búsqueda lineal, pero este método requiere mucho tiempo y este crece linealmente con la cantidad o el número de datos. es decir, empezar desde el elemento a la izquierda de la matriz [] y uno por uno compara x con cada elemento de la matriz [], si x coincide con un elemento, devuelve el índice. Si x no coincide con ninguno de los elementos, devuelve -1. + +``` +Búsqueda Lineal: O (n) Tiempo lineal + +Búsqueda Binaria: O ( log(n) ) Tiempo logarítmico + +``` +``` +def search(arr, x): + + for i in range(len(arr)): + + if arr[i] == x: + return i + + return -1 + +``` +## Algoritmo de Búsqueda Binaria + +El requisito básico para que la búsqueda binaria funcione es que los datos a buscar deben estar ordenados (en cualquier orden). + + +### Algo + +``` +La idea de la búsqueda binaria es usar la información de que la matriz está ordenada y así reducir la complejidad del tiempo a O(Logn). Básicamente ignoramos la mitad de los elementos después de la primera comparación. +1) Compare x con el elemento del medio. +2) si x coincide con el elemento del medio , retornamos el índice del elemento del medio. +3) Si no coincide, si x es mayor que el elemento del medio, entonces x solo puede estar en la mitad derecha justo después del elemento del medio. Así que recurrimos a la mitad derecha. +4) Si no (x es más pequeño) recurrimos a la mitad izquierda. +Siguiendo la implementación recursiva de búsqueda binaria. + +``` + +### Notas finales + +Hay otra forma de búsqueda binaria que es muy útil. + +## Libros + +* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms) +* [Algoritmos EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X) +* [Diseño de Algoritmos EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651) + +## Recursos en línea + +* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/) +* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/) -- cgit v1.2.3 From bba5f6c57cbed0d6cbc73394e7fb36c211437c28 Mon Sep 17 00:00:00 2001 From: Gino Amaury Date: Tue, 11 Oct 2016 02:34:29 -0500 Subject: Translate - Dynamic Programming to spanish (#2428) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Añadido html en español * traduccion html a español sin revision * Traduccion html al español corregido * Correccion de la configuraciond el header * Correccion de links * creacion del archivo en la carpeta de traduccion * traduccion busqueda binaria español * traduccion programación dináica al español --- es-es/dynamic-programming-es.html.markdown | 54 ++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 es-es/dynamic-programming-es.html.markdown (limited to 'es-es') diff --git a/es-es/dynamic-programming-es.html.markdown b/es-es/dynamic-programming-es.html.markdown new file mode 100644 index 00000000..11930653 --- /dev/null +++ b/es-es/dynamic-programming-es.html.markdown @@ -0,0 +1,54 @@ +--- +category: Algorithms & Data Structures +name: Dynamic Programming +contributors: + - ["Akashdeep Goel", "http://github.com/akashdeepgoel"] +translators: + - ["Gino Amaury", "https://github.com/ginoamaury"] +lang: es-es +--- + +# programación dinámica + +## Introducción + +La programación dinámica es una técnica poderosa usada para resolver una clase particular de problemas como veremos más adelante. La idea es muy simple, si usted ha solucionado un problema con la entrada dada, entonces , guardaremos el resultado para una futura referencia, con el fin de evitar la solución del mismo problema de nuevo. + + +Recuerde siempre!! +"Aquellos que no pueden recordar el pasado están condenados a repetirlo" + +## Formas de resolver este tipo de problemas + +1.) De arriba hacia abajo : Empezamos resolviendo el problema dado descomponiendolo. Si ves que el problema fue resuelto, entonces retorna la respuesta guardada. si no se ha resuelto, resuélvelo y guarda la respuesta. Esto suele ser fácil pensar y muy intuitivo. Esto se conoce como memorización. + +2.) De abajo hacia arriba : Analiza el problema y mira el orden en que los subproblemas deben ser resueltos y empieza resolviendo el subproblema más trivial, hacia el problema dado.En este proceso, se garantiza que los subproblemas se resuelven antes de resolver el problema. Esto se conoce como programación dinámica. + +## Ejemplo de Programación Dinámica + +El problema de la subsecuencia creciente máxima consiste en encontrar la subsecuencia creciente máxima en una secuencia dada . Dada la secuencia S= {a1 , a2 , a3, a4, ............., an-1, an } tenemos que encontrar un subconjunto más largo tal que para todo j y i, j a[j] and LS[i] Date: Mon, 17 Oct 2016 19:40:31 +1300 Subject: Move Spanish SASS tutorial to the ES folder (#2468) --- es-es/sass-es.html.markdown | 584 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 584 insertions(+) create mode 100644 es-es/sass-es.html.markdown (limited to 'es-es') diff --git a/es-es/sass-es.html.markdown b/es-es/sass-es.html.markdown new file mode 100644 index 00000000..3719dfe9 --- /dev/null +++ b/es-es/sass-es.html.markdown @@ -0,0 +1,584 @@ +--- +language: sass +filename: learnsass.scss +contributors: + - ["Laura Kyle", "https://github.com/LauraNK"] + - ["Sean Corrales", "https://github.com/droidenator"] + - ["Kyle Mendes", "https://github.com/pink401k"] + - ["Keith Miyake", "https://github.com/kaymmm"] +translators: + - ["César Suárez", "https://github.com/csuarez"] +--- + +Sass es un lenguaje que extiende CSS y que añade características tales como variables, anidación, mixins y más. Sass (y otros preprocesadores tales como [Less](http://lesscess.org/)) ayudan a los desarrolladores a escribir código mantenible y DRY (Don't Repeat Yourself). + +Sass tiene dos sintaxis para elegir: SCSS, que usa la misma que CSS pero con las características añadidas de Sass, y Sass (la sintaxis original) que usa identación en vez de llaves y puntos y comas. Este tutorial está escrito en SCSS. + +Si ya estás familiarizado con CSS3, vas a entender Sass relativamente rápido. Sass no ofrece nuevas propiedades de estilo, si no que añade herramientas para escribir tus CSS de manera más eficiente, haciendo su mantenimiento mucho más sencillo. + +```scss + + +//Los comentarios en una sola línea son eliminados cuando Sass es compilado a CSS. + +/* Los comentarios multi-línea se mantienen. */ + + + +/* Variables +============================== */ + + +/* Puedes almacenar valores CSS (como un color) en una variable. +Usa el símbolo '$' para crear una variable */ + +$primary-color: #A3A4FF; +$secondary-color: #51527F; +$body-font: 'Roboto', sans-serif; + +/* Puedes usar las variables a lo largo de tu hoja de estilos. +Ahora, si quieres cambiar el color, sólo lo tienes que hacer una vez. */ + +body { + background-color: $primary-color; + color: $secondary-color; + font-family: $body-font; +} + +/* Este código compilará en: */ +body { + background-color: #A3A4FF; + color: #51527F; + font-family: 'Roboto', sans-serif; +} + +/* El resultado es mucho más mantenible que tener que cambiar el color +cada vez que aparece en la hoja de estilos. */ + + + +/* Directivas de control +============================== */ + + +/* Sass permite usar @if, @else, @for, @while, y @each para controlar la + compilación de tu código en CSS. */ + +/* Los bloques @if/@else se comportan tal como es de esperar */ + +$debug: true !default; + +@mixin debugmode { + @if $debug { + @debug "Modo debug activado"; + + display: inline-block; + } + @else { + display: none; + } +} + +.info { + @include debugmode; +} + +/* Si $debug es true, .info es mostrado; si es false entonces +no se muestra. + +Nota: @debug mostrará información de depuración en la consola. +Es muy útil para ver el contenido de tus variables cuando estás depurando. */ + +.info { + display: inline-block; +} + +/* @for es un bucle que itera un conjunto de valores. +Es particularmente útil para dar estilos a una colección de objetos. +Hay dos formas "through" y "to". El primero incluye el último valor +mientras que el segundo para antes del último valor. */ + +@for $c from 1 to 4 { + div:nth-of-type(#{$c}) { + left: ($c - 1) * 900 / 3; + } +} + +@for $c from 1 through 3 { + .myclass-#{$c} { + color: rgb($c * 255 / 3, $c * 255 / 3, $c * 255 / 3); + } +} + +/* Esto compila en: */ + +div:nth-of-type(1) { + left: 0; +} + +div:nth-of-type(2) { + left: 300; +} + +div:nth-of-type(3) { + left: 600; +} + +.myclass-1 { + color: #555555; +} + +.myclass-2 { + color: #aaaaaa; +} + +.myclass-3 { + color: white; +// SASS convierte automáticamente #FFFFFF a white +} + +/* @while es bastante sencillo: */ + +$columns: 4; +$column-width: 80px; + +@while $columns > 0 { + .col-#{$columns} { + width: $column-width; + left: $column-width * ($columns - 1); + } + + $columns: $columns - 1; +} + +/* Esto se convierte en el siguiente CSS: */ + +.col-4 { + width: 80px; + left: 240px; +} + +.col-3 { + width: 80px; + left: 160px; +} + +.col-2 { + width: 80px; + left: 80px; +} + +.col-1 { + width: 80px; + left: 0px; +} + +/* @each funciona parecido a @for, pero usa una lista en ver del valor ordinal +Nota: puedes especificar listas como cualquier otra variable usando espacios +como delimitadores. */ + +$social-links: facebook twitter linkedin reddit; + +.social-links { + @each $sm in $social-links { + .icon-#{$sm} { + background-image: url("images/#{$sm}.png"); + } + } +} + +/* Esto resultará en: */ + +.social-links .icon-facebook { + background-image: url("images/facebook.png"); +} + +.social-links .icon-twitter { + background-image: url("images/twitter.png"); +} + +.social-links .icon-linkedin { + background-image: url("images/linkedin.png"); +} + +.social-links .icon-reddit { + background-image: url("images/reddit.png"); +} + + + +/* Mixins +==============================*/ + + +/* Si te encuentras con que estás escribiendo el mismo código en más de un +elemento, puede que quieras almacenarlo en un mixin. + +Usa la directiva '@mixin', más un nombre para tu mixin. */ + +@mixin center { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +/* Puedes usarlo con '@include' y el nombre del mixin. */ + +div { + @include center; + background-color: $primary-color; +} + +/* Esto compilará en: */ +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #A3A4FF; +} + +/* Puedes usar mixins para crear una propiedad shorthand. */ + +@mixin size($width, $height) { + width: $width; + height: $height; +} + +/* La que puedes invocar pasándole los argumentos width y height. */ + +.rectangle { + @include size(100px, 60px); +} + +.square { + @include size(40px, 40px); +} + +/* Compila en: */ +.rectangle { + width: 100px; + height: 60px; +} + +.square { + width: 40px; + height: 40px; +} + + + +/* Funciones +============================== */ + + +/* Sass ofrece funciones que pueden ser usadas para realizar una gran variedad + de tareas. Por ejemplo: */ + +/* Se pueden invocar funciones usando su nombre y pasándole los + argumentos requeridos. */ +body { + width: round(10.25px); +} + +.footer { + background-color: fade_out(#000000, 0.25); +} + +/* Compila en: */ + +body { + width: 10px; +} + +.footer { + background-color: rgba(0, 0, 0, 0.75); +} + +/* Puedes definir tus propias funciones. Las funciones son muy similares a + los mixins. Cuando tengas que elegir entre una función y un mixin, recuerda + que los mixins son mejores para generar CSS, mientras que las funciones son + mejores para la lógica que puedas necesitar en tu código Sass. Los ejemplos + de la sección 'Operadores matemáticos' son candidatos ideales para ser + usados como una función reusable. */ + +/* Esta función toma un tamaño objetivo y el tamaño de un padre y + devuelve el porcentaje. */ + +@function calculate-percentage($target-size, $parent-size) { + @return $target-size / $parent-size * 100%; +} + +$main-content: calculate-percentage(600px, 960px); + +.main-content { + width: $main-content; +} + +.sidebar { + width: calculate-percentage(300px, 960px); +} + +/* Compila en: */ + +.main-content { + width: 62.5%; +} + +.sidebar { + width: 31.25%; +} + + + +/* Extender (Herencia) +============================== */ + + +/* Extend es una manera de compartir propiedades de un selector con otro. */ + +.display { + @include size(5em, 5em); + border: 5px solid $secondary-color; +} + +.display-success { + @extend .display; + border-color: #22df56; +} + +/* Compila en: */ +.display, .display-success { + width: 5em; + height: 5em; + border: 5px solid #51527F; +} + +.display-success { + border-color: #22df56; +} + +/* Extender una declaración CSS es preferible a crear un mixin + debido a la manera en la que Sass agrupa las clases que comparten + los mismos estilos base. Si esto fuese hecho con un mixin, el ancho, + alto y el borden aparecerían duplicados para cada una de las declaraciones + que usasen el mixin. Esto no afectará a tu workflow, pero infla + innecesariamente los ficheros generados por el compilador Sass. */ + + + +/* Anidación +============================== */ + + +/* Sass permite anidar selectores dentro de otros selectores. */ + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: #FF0000; + } +} + +/* '&' será reemplazado por el selector del padre. */ + +/* También puedes anidar seudo clases. */ + +/* Ten en cuenta que anidar demasiado hará tu código menos mantenible. +Como buena práctica, se recomienda no tener más de 3 niveles de anidación. +Por ejemplo: */ + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: red; + + &:hover { + background-color: blue; + } + + a { + color: white; + } + } +} + +/* Compila en: */ + +ul { + list-style-type: none; + margin-top: 2em; +} + +ul li { + background-color: red; +} + +ul li:hover { + background-color: blue; +} + +ul li a { + color: white; +} + + + +/* Parciales e importaciones +============================== */ + + +/* Sass permite que crees ficheros parciales. Esto te puede ayudar a mantener + tu código Sass modularizado. Los ficheros parciales deben comenzar por '_', + p.e. _reset.css. + Los parciales no son convertidos en CSS. */ + +/* Mira este al que vamos a añadir un fichero llamado _reset.css */ + +html, +body, +ul, +ol { + margin: 0; + padding: 0; +} + +/* Con @import puedes importar parciales a un fichero. Este se diferencia del + @import de CSS en que no hace otra petición HTTP para importar el fichero. + Sass, sino que combina el código importado en el código compilado. */ + +@import 'reset'; + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + +/* Compila en: */ + +html, body, ul, ol { + margin: 0; + padding: 0; +} + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + + + +/* Placeholders +============================== */ + + +/* Los placeholders son útiles cuando estás creando una declaración CSS a + extender. Si quieres crear una declaración que sólo va a ser usada con @extend, + puedes hacerlo mediante un placeholder. Los placeholders comienzan con '%' + en vez de '.' o '#'. Esto no aparecen en el código CSS compilado. */ + +%content-window { + font-size: 14px; + padding: 10px; + color: #000; + border-radius: 4px; +} + +.message-window { + @extend %content-window; + background-color: #0000ff; +} + +/* Compila en: */ + +.message-window { + font-size: 14px; + padding: 10px; + color: #000; + border-radius: 4px; +} + +.message-window { + background-color: #0000ff; +} + + + +/* Operaciones matemáticas +============================== */ + + +/* Sass provee los siguientes operadores: +, -, *, / y %. Estos son útiles + para calcular valores directamente en tu código Sass en vez de usar valores + calculados a mano. Mira el siguiente ejemplo que prepara un sencillo diseño + de dos columnas. */ + +$content-area: 960px; +$main-content: 600px; +$sidebar-content: 300px; + +$main-size: $main-content / $content-area * 100%; +$sidebar-size: $sidebar-content / $content-area * 100%; +$gutter: 100% - ($main-size + $sidebar-size); + +body { + width: 100%; +} + +.main-content { + width: $main-size; +} + +.sidebar { + width: $sidebar-size; +} + +.gutter { + width: $gutter; +} + +/* Compila en: */ + +body { + width: 100%; +} + +.main-content { + width: 62.5%; +} + +.sidebar { + width: 31.25%; +} + +.gutter { + width: 6.25%; +} + +``` + +## ¿SASS o Sass? +¿Alguna vez has pensado si Sass es un acrónimo o no? Seguramente no, pero te lo vamos a explicar de todas maneras. "Sass" es una palabra, no un acrónimo. +Como todo el mundo lo escribe como "SASS", el creador del lenguaje lo ha llamado de broma "Syntactically Awesome StyleSheets" (Hojas de estilo sintácticamente increíbles). + + +## Practica Sass +Si quieres probar Sass en tu navegador, prueba [SassMeister](http://sassmeister.com/). +Puedes usar cualquier sintaxis, o elegir en la configuración entre Sass y SCSS. + +## Compatibilidad +Sass puede ser usado en cualquier proyecto mientras tengas un programa que lo compile en CSS. Quizás quieras comprobar si el CSS que estás usando es compatible con tus navegadores objetivo. + +[QuirksMode CSS](http://www.quirksmode.org/css/) y [CanIUse](http://caniuse.com) son buenos recursos para comprobar la compatibilidad de navegadores. + + +## Más información +* [Documentación oficial (EN)](http://sass-lang.com/documentation/file.SASS_REFERENCE.html) +* [The Sass Way (EN)](http://thesassway.com/) tiene tutoriales (para principiantes y avanzandos) and artículos. -- cgit v1.2.3 From 038bf6d596df645835a408a9e71d9a17e4bd8dec Mon Sep 17 00:00:00 2001 From: Gino Amaury Date: Fri, 21 Oct 2016 10:34:01 -0500 Subject: translate edn to spanish (#2467) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Añadido html en español * traduccion html a español sin revision * Traduccion html al español corregido * Correccion de la configuraciond el header * Correccion de links * creacion del archivo en la carpeta de traduccion * traduccion busqueda binaria español * traduccion programación dináica al español * creacion del archivo en español de edn * traduccion edn al español * Move Spanish SASS tutorial to the ES folder (#2468) * [c/pt_br]Fix correct name #define (#2469) --- es-es/edn-es.html.markdown | 111 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 es-es/edn-es.html.markdown (limited to 'es-es') diff --git a/es-es/edn-es.html.markdown b/es-es/edn-es.html.markdown new file mode 100644 index 00000000..f8c7611d --- /dev/null +++ b/es-es/edn-es.html.markdown @@ -0,0 +1,111 @@ +--- +language: edn +filename: learnedn.edn +contributors: + - ["Jason Yeo", "https://github.com/jsyeo"] +translators: + - ["Gino Amaury", "https://github.com/ginoamaury"] +lang: es-es +--- + +La notación de datos extensible (Extensible Data Notation (EDN)) es un formato para serializar los datos. + +La notación se utiliza internamente por Clojure para representar programas. También es +utilizado como un formato de transferencia de datos como JSON. A pesar de que se utiliza más comúnmente en +Clojure, existen implementaciones de EDN para muchos otros lenguajes. + +El principal beneficio de EDN sobre JSON y YAML es que es extensible. +Vamos a ver cómo se extiende más adelante. + +```clojure +; Los comentarios comienzan con un punto y coma. +; Cualquier cosa después del punto y coma es ignorado. + +;;;;;;;;;;;;;;;;;;; +;;;Tipos Básicos;;; +;;;;;;;;;;;;;;;;;;; + +nil ; También conocido en otros lenguajes como nulo (null). + +; Booleanos +true +false + +; Las cadenas se encierran entre comillas dobles +"desayuno húngaro" +"tortilla de queso del granjero" + +; Los caracteres están precedidos por barras invertidas +\g \r \a \c \e + +; Las palabras claves comienzan con dos puntos.Se comportan como las enumeraciones. Más o menos +; Como símbolos en Ruby +:huevos +:queso +:aceitunas + +; Los símbolos se utilizan para representar los identificadores.Estos empiezan con #. +; puedes tener espacios usando el símbolo /. cualquier cosa precedida / es +; un espacio en el nombre. +#cuchara +#cocina/cuchara ; no es lo mismo que #spoon +#cocina/tenedor +#github/tenedor ; no se puede comer con este. + +; Números enteros y flotantes +42 +3.14159 + +; Las listas son secuencias de valores. +(:bollo :empanada-de-res 9 "yum!") + +; Vectores permiten acceso aleatorio +[:helado 1 2 -2] + +; Los mapas son estructuras de datos asociativos que se asocian con la clave de su valor. +{:huevos 2 + :jugo-de-limon 3.5 + :mantequilla 1} + +; Usted no está restringido a usar palabras clave como claves. +{[1 2 3 4] "decirle a la gente lo que llevaba", + [5 6 7 8] "Entre mas tu ves, mas lo odias"} + +; Puede usar comas para facilitar la lectura. Se tratan como espacios en blanco. + +; Los conjuntos son colecciones que contienen elementos únicos. +#{:a :b 88 "huat"} + +;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;Elementos de etiqueta ;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; EDN puede ser extendido por elementos de etiqueta con el símbolo #. + +#MyYelpClone/MenuItem {:nombre "huevos-Benedict" :clasificacion 10} + +; Permíteme explicar esto con un ejemplo en colujre. Supongamos que quiero +; transformar ese pedazo de EDN en un registro del Menú. + +(defrecord MenuItem [nombre clasificacion]) + +; Para transformar EDN en valores clojure, necesitaremos usar el constructor en EDN +; lectura, edn/read-string + +(edn/read-string "{:huevos 2 :mantequilla 1 :harina 5}") +; -> {:huevos 2 :mantequilla 1 :harina 5} + +; Para transformar los elementos de etiqueta, definir la función de lectura y pasar un mapa +; que asigna etiquetas a funciones del lector de edn/read-string al igual que. + +(edn/read-string {:lectores {'MyYelpClone/MenuItem map->menu-item}} + "#MyYelpClone/MenuItem {:nombre \"huevos-benedict\" :clasificacion 10}") +; -> #user.MenuItem{:nombre "huevos-benedict", :clasificacion 10} + +``` + +# Referencias + +- [EDN spec (EN)](https://github.com/edn-format/edn) +- [Implementations (EN)](https://github.com/edn-format/edn/wiki/Implementations) +- [Tagged Elements (EN)](http://www.compoundtheory.com/clojure-edn-walkthrough/) -- cgit v1.2.3 From 78617f6c8c2fcf0fc303c52c0fc11e003d7d2f67 Mon Sep 17 00:00:00 2001 From: ven Date: Fri, 21 Oct 2016 17:34:23 +0200 Subject: Update edn-es.html.markdown --- es-es/edn-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/edn-es.html.markdown b/es-es/edn-es.html.markdown index f8c7611d..32bba37d 100644 --- a/es-es/edn-es.html.markdown +++ b/es-es/edn-es.html.markdown @@ -1,6 +1,6 @@ --- language: edn -filename: learnedn.edn +filename: learnedn-es.edn contributors: - ["Jason Yeo", "https://github.com/jsyeo"] translators: -- cgit v1.2.3 From 8d0e3d6d5ce498d5f55fd8553c0775f9efe87e5f Mon Sep 17 00:00:00 2001 From: Hughes Perreault Date: Fri, 21 Oct 2016 16:33:09 -0400 Subject: Added line "lang: es-es" (#2483) Fixes #2482 --- es-es/sass-es.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'es-es') diff --git a/es-es/sass-es.html.markdown b/es-es/sass-es.html.markdown index 3719dfe9..89e56ba5 100644 --- a/es-es/sass-es.html.markdown +++ b/es-es/sass-es.html.markdown @@ -8,6 +8,7 @@ contributors: - ["Keith Miyake", "https://github.com/kaymmm"] translators: - ["César Suárez", "https://github.com/csuarez"] +lang: es-es --- Sass es un lenguaje que extiende CSS y que añade características tales como variables, anidación, mixins y más. Sass (y otros preprocesadores tales como [Less](http://lesscess.org/)) ayudan a los desarrolladores a escribir código mantenible y DRY (Don't Repeat Yourself). -- cgit v1.2.3 From b652505def57ce6580d2e34ae9946f288a8099b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9sar=20Su=C3=A1rez=20Ortega?= Date: Sun, 23 Oct 2016 00:33:04 +0200 Subject: Add Spanish version of Less tutorial (#2459) --- es-es/less-es.html.markdown | 392 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 392 insertions(+) create mode 100644 es-es/less-es.html.markdown (limited to 'es-es') diff --git a/es-es/less-es.html.markdown b/es-es/less-es.html.markdown new file mode 100644 index 00000000..bfae6fc6 --- /dev/null +++ b/es-es/less-es.html.markdown @@ -0,0 +1,392 @@ +--- +language: less +filename: learnless.less +contributors: + - ["Saravanan Ganesh", "http://srrvnn.me"] +translators: + - ["César Suárez", "https://github.com/csuarez"] +--- + +Less es un pre-procesador CSS, que añade características como variables, anidación, mixins y más. +Less (y otros pre-procesadores como [Sass](http://sass-lang.com/) ayudan a los desarrolladores a escribir código mantenible y DRY (Don't Repeat Yourself). + +```css + + +//Los comentarios de una línea son borrados cuando Less es compilado a CSS. + +/* Los comentarios multi-línea se mantienen. */ + + + +/*Variables +==============================*/ + + +/* Puedes almacenar un valor CSS (como un color) en una variable. +Usa el símbolo '@' para crear una variable. */ + +@primary-color: #a3a4ff; +@secondary-color: #51527f; +@body-font: 'Roboto', sans-serif; + +/* Puedes usar las variables por toda tu hoja de estilos. +Ahora, si quieres cambiar un color, sólo lo tienes que hacer una vez.*/ + +body { + background-color: @primary-color; + color: @secondary-color; + font-family: @body-font; +} + +/* Esto compilará en: */ + +body { + background-color: #a3a4ff; + color: #51527F; + font-family: 'Roboto', sans-serif; +} + + +/* Esto es mucho más mantenible que tener que cambiar el color + cada vez que aparece en tu hoja de estilos. */ + + + +/* Mixins +==============================*/ + + +/* Si tienes el mismo código para más de un elemento, puede que + quieras reutilizarlo fácilmente. */ + +.center { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +/* Puedes usar un mixin simplemente añadiendo el selector como un estilo. */ + +div { + .center; + background-color: @primary-color; +} + +/* Esto compilará en: */ + +.center { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #a3a4ff; +} + +/* Puedes omitir que se compile el código del mixin añadiendo un + paréntesis después del selector. */ + +.center() { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; +} + +div { + .center; + background-color: @primary-color; +} + +/* Esto compilará en: */ +div { + display: block; + margin-left: auto; + margin-right: auto; + left: 0; + right: 0; + background-color: #a3a4ff; +} + + + +/* Anidación +==============================*/ + + +/* Less te permite anidar selectores dentro de otros selectores. */ + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: #f00; + } +} + +/* '&' es replazado por el selector padre. */ +/* También se pueden anidar seudo clases. */ +/* Ten en cuenta que anidar demasiado puede hacer tu código menos + mantenible. Las buenas prácticas recomiendan no tener más de 3 niveles de + anidación. Por ejemplo: */ + +ul { + list-style-type: none; + margin-top: 2em; + + li { + background-color: red; + + &:hover { + background-color: blue; + } + + a { + color: white; + } + } +} + +/* Compila en: */ + +ul { + list-style-type: none; + margin-top: 2em; +} + +ul li { + background-color: red; +} + +ul li:hover { + background-color: blue; +} + +ul li a { + color: white; +} + + + +/* Funciones +==============================*/ + + +/* Less ofrece funciones que pueden ser usadas para cumplir una gran variedad + de tareas. Considera lo siguiente: */ + +/* Las funciones pueden ser llamadas usando su nombre y pasándole los argumentos + requeridos. */ + +body { + width: round(10.25px); +} + +.header { + background-color: lighten(#000, 0.5); +} + +.footer { + background-color: fadeout(#000, 0.25) +} + +/* Compila en: */ + +body { + width: 10px; +} + +.header { + background-color: #010101; +} + +.footer { + background-color: rgba(0, 0, 0, 0.75); +} + +/* Puedes definir tus propias funciones. Las funciones son muy similares a + los mixins. Cuando tengas que elegir entre una función y un mixin, recuerda + que los mixins son mejores para generar CSS, mientras que las funciones son + mejores para la lógica que puedas necesitar en tu código Sass. Los ejemplos + de la sección 'Operadores matemáticos' son candidatos ideales para ser + usados como una función reusable. */ + +/* Esta función calcula la media de dos números. */ + +.average(@x, @y) { + @average-result: ((@x + @y) / 2); +} + +div { + .average(16px, 50px); // aquí se llama a la función + padding: @average-result; // y aquí se usa el valor "devuelto" +} + +/* Compila en: */ + +div { + padding: 33px; +} + + + +/* Extender (Herencia) +==============================*/ + + +/* Extend es una manera de compartir propiedades de un selector con otro. */ + +.display { + height: 50px; +} + +.display-success { + &:extend(.display); + border-color: #22df56; +} + +/* Compila en: */ +.display, +.display-success { + height: 50px; +} +.display-success { + border-color: #22df56; +} + +/* Extender una declaración CSS es preferible a crear un mixin + debido a la manera en la que Sass agrupa las clases que comparten + los mismos estilos base. Si esto fuese hecho con un mixin, el ancho, + alto y el borden aparecerían duplicados para cada una de las declaraciones + que usasen el mixin. Esto no afectará a tu workflow, pero infla + innecesariamente los ficheros generados por el compilador Less. */ + + +/*Partials and Imports +==============================*/ + + + +/* Less allows you to create partial files. This can help keep your Less + code modularized. Partial files conventionally begin with an '_', + e.g. _reset.less. and are imported into a main less file that gets + compiled into CSS */ + +/* Consider the following CSS which we'll put in a file called _reset.less */ + +html, +body, +ul, +ol { + margin: 0; + padding: 0; +} + + /* Less ofrece @import para poder importar parciales a un fichero. Esto se + diferencia del @import de CSS en que no hace otra petición HTTP para + importar el fichero, sino que combina el código importado en el código + compilado. */ + +@import 'reset'; + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + +/* Compila en: */ + +html, body, ul, ol { + margin: 0; + padding: 0; +} + +body { + font-size: 16px; + font-family: Helvetica, Arial, Sans-serif; +} + + + +/* Operaciones matemáticas +==============================*/ + + +/* Less ofrece los siguientes operadores: +, -, *, / y %. Estos son útiles + para calcular valores directamente en tu código Less en vez de usar valores + calculados a mano. Mira el siguiente ejemplo que prepara un sencillo diseño + de dos columnas. */ + +@content-area: 960px; +@main-content: 600px; +@sidebar-content: 300px; + +@main-size: @main-content / @content-area * 100%; +@sidebar-size: @sidebar-content / @content-area * 100%; +@gutter: 100% - (@main-size + @sidebar-size); + +body { + width: 100%; +} + +.main-content { + width: @main-size; +} + +.sidebar { + width: @sidebar-size; +} + +.gutter { + width: @gutter; +} + +/* Compila en: */ + +body { + width: 100%; +} + +.main-content { + width: 62.5%; +} + +.sidebar { + width: 31.25%; +} + +.gutter { + width: 6.25%; +} + + +``` + +## Practica Less + +Si quieres probar Less en tu navegador, prueba: +* [Codepen](http://codepen.io/) +* [LESS2CSS](http://lesscss.org/less-preview/) + +## Compatibilidad + +Sass puede ser usado en cualquier proyecto mientras tengas un programa que lo compile en CSS. Quizás quieras comprobar si el CSS que estás usando es compatible con tus navegadores objetivo. + +[QuirksMode CSS](http://www.quirksmode.org/css/) y [CanIUse](http://caniuse.com) son buenos recursos para comprobar la compatibilidad de navegadores. + +## Más información +* [Documentación oficial (EN)](http://lesscss.org/features/) +* [Less CSS - Guía para principiantes (EN)](http://www.hongkiat.com/blog/less-basic/) -- cgit v1.2.3 From c76be299aa8aff26128735b169d6a80dc9ffda84 Mon Sep 17 00:00:00 2001 From: ven Date: Sun, 23 Oct 2016 00:33:28 +0200 Subject: Update less-es.html.markdown --- es-es/less-es.html.markdown | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/less-es.html.markdown b/es-es/less-es.html.markdown index bfae6fc6..fa09db9f 100644 --- a/es-es/less-es.html.markdown +++ b/es-es/less-es.html.markdown @@ -1,6 +1,7 @@ --- language: less -filename: learnless.less +filename: learnless-es.less +lang: es-es contributors: - ["Saravanan Ganesh", "http://srrvnn.me"] translators: -- cgit v1.2.3 From 40550bd7a9ab8d9dc8323bb12324f0ce1a4d3123 Mon Sep 17 00:00:00 2001 From: ven Date: Sun, 23 Oct 2016 14:22:52 +0200 Subject: Final fix #2498 --- es-es/powershell-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/powershell-es.html.markdown b/es-es/powershell-es.html.markdown index dd92eb97..9eb35967 100644 --- a/es-es/powershell-es.html.markdown +++ b/es-es/powershell-es.html.markdown @@ -18,7 +18,7 @@ Una diferencia clave con respecto a Bash es que en PowerShell casi todo son mani Si no está seguro sobre el ambiente de ejecución en su sistema: -``` +```powershell Get-ExecutionPolicy -List Set-ExecutionPolicy AllSigned # Otras opciones de políticas de ejecución son: -- cgit v1.2.3 From 78a4ae7da90139fecb2add55722ae7a54f43c593 Mon Sep 17 00:00:00 2001 From: Gnomino Date: Thu, 27 Oct 2016 13:36:08 +0200 Subject: [jQuery/en] [jQuery/es] Fixes syntax errors (#2525) * Fixed syntax errors * Fixes syntax errors --- es-es/jquery-es.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'es-es') diff --git a/es-es/jquery-es.html.markdown b/es-es/jquery-es.html.markdown index d35e6f17..27ad48bb 100644 --- a/es-es/jquery-es.html.markdown +++ b/es-es/jquery-es.html.markdown @@ -79,7 +79,7 @@ $('#btn').on( ); // Puede mover y ocultar elementos con algunos métodos de efecto -$('.table').hide(); # Oculta el(los) elemento(s) +$('.table').hide(); // Oculta el(los) elemento(s) // Nota: llamar a una función en estos métodos aún oculta el elemento $('.table').hide(function(){ @@ -134,7 +134,7 @@ $('p').height(); // Obtiene sólo la altura de la primera etiqueta 'p' // Puedes utilizar 'each' para recorrer todos los elementos var heights = []; $('p').each(function() { - heights.push($(this.height)); // Añade todas las alturas "p" de la etiqueta a la matriz + heights.push($(this).height()); // Añade todas las alturas "p" de la etiqueta a la matriz }); -- cgit v1.2.3 From 85a3b44613cdb75a2ac1708b39ae8a5ecb116328 Mon Sep 17 00:00:00 2001 From: Daniel Caballero Date: Mon, 7 Nov 2016 16:42:56 -0500 Subject: Translate to Spanish Wolfram.html.markdown (#2556) --- es-es/wolfram-es.html.markdown | 137 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 es-es/wolfram-es.html.markdown (limited to 'es-es') diff --git a/es-es/wolfram-es.html.markdown b/es-es/wolfram-es.html.markdown new file mode 100644 index 00000000..187eda7b --- /dev/null +++ b/es-es/wolfram-es.html.markdown @@ -0,0 +1,137 @@ +--- +Lenguaje: wolfram +contribuidor: + - ["Daniel Caballero", "http://github.com/danielcaballero796/"] +nombre de archivo: learnwolfram.nb +--- + +Wolfram es un lenguaje subyacente originalmente utilizado en Mathematica, pero ahora esta disponible para su uso en múltiples contextos. + +El lenguaje de Wolfram tiene varias interfaces: +* La interfaz de línea de comandos kernel de Raspberry Pi (recién llamada _The Wolfram Language_) que se ejecuta interactivamente y no puede producir entrada gráfica. +* _Mathematica_ que es un texto rico / editor de matemáticas con Wolfram interactivo construido: presionando shift + Return en una "celda de código" crea una celda de salida con el resultado, que no es dinámica +* _Wolfram Workbench_ la cual es la interfaz de Eclipse del lenguaje Wolfram + +El código de este ejemplo se puede escribir en cualquier interfaz y editarlo con Wolfram Workbench. Cargar directamente en Matematica puede resultar incómodo porque el archivo no contiene información de formato de celda (lo que haría que el archivo sea un desastre enorme para ser leído como texto) - puede ser visto / editado pero tal vez requerira algún ajuste. + +``` +(* Esto es un comentario *) + +(* En Mathematica en lugar de utilizar estos comentarios, puede crear una celda de texto + Y anotar su código con texto e imágenes bien escritas *) + +(* Escribe una expresión devuelve el resultado *) +2*2 (* 4 *) +5+8 (* 13 *) + +(* Llamada de función *) +(* Nota, los nombres de funciones (y todo lo demás) distingue entre mayúsculas y minúsculas *) +Sin[Pi/2] (* 1 *) + +(* Sintaxis alternativa para la Llamada de una función con un parámetro *) +Sin@(Pi/2) (* 1 *) +(Pi/2) // Sin (* 1 *) + +(* Cada sintaxis en WL tiene algún equivalente como una llamada de función *) +Veces[2, 2] (* 4 *) +Mas[5, 8] (* 13 *) + +(* El uso de una variable por primera vez lo define y lo hace global *) +x = 5 (* 5 *) +x == 5 (* verdadero, Estilo-C asignación y pruebas de igualdad *) +x (* 5 *) +x = x + 5 (* 10 *) +x (* 10 *) +Modifique[x, 20] (* No estaba bromeando cuando dije que TODO tiene una función equivalente *) +x (* 20 *) + +(* Debido a que WL se basa en un sistema de álgebra computacional, *) +(* El uso de variables indefinidas está bien, simplemente obstruyen la evaluación *) +cow + 5 (* 5 + cow, cow es indefinido por lo que no puede evaluar más *) +cow + 5 + 10 (* 15 + cow, Va a evaluar lo que puede *) +% (* 15 + cow, % Busca el último retorno *) +% - cow (* 15, cow variable indefinida cancelada *) +moo = cow + 5 (* Cuidado, moo ahora tiene una expresión, no un número! *) + +(* Definición de una función *) +Double[x_] := x * 2 (* Nota: = para evitar la evaluación inmediata del RHS + y después de x para indicar que no hay restricciones de concordancia de patrones *) +Double[10] (* 20 *) +Double[Sin[Pi/2]] (* 2 *) +Double @ Sin @ (Pi/2) (* 2, @-Sintaxis evita colas de paréntesis *) +(Pi/2) // Sin // Double(* 2, //-Sintaxis lista las funciones en orden de ejecución *) + +(* Para un uso de programación de estilo imperativo; Para separar declaraciones *) +(* Descarta cualquier salida de LHS y ejecuta RHS *) +miPrimero[] := (Print@"Hola"; Print@"Mundo") (* Tenga en cuenta que los padres externos son críticos + ; La precedencia es menor que := *) +miPrimero[] (* Hola Mundo *) + +(* Estilo-C para bucle *) +PrintTo[x_] := For[y=0, y 2, "Red" -> 1|> (* crea una asociación *) +miHash[["Green"]] (* 2, uselo *) +miHash[["Green"]] := 5 (* 5, actualizalo *) +miHash[["Puce"]] := 3.5 (* 3.5, extiendalo *) +KeyDropFrom[miHash, "Verde"] (* Limpia la llave Verde *) +Claves[miHash] (* {Rojo} *) +Valores[miHash] (* {1} *) + +(* Y no puedes hacer ninguna demo de Wolfram sin mostrar esto *) +Manipular[y^2, {y, 0, 20}] (* Devuelve una interfaz de usuario reactiva que muestra y ^ 2 + Y permite ajustar y entre 0-20 con un deslizador. + Sólo funciona en interfaces gráficas *) +``` + +##Listo para mas? + +* [Centro de Documentación](http://reference.wolfram.com/language/) -- cgit v1.2.3 From 8b4313d26b80cb00360d028a99a0d25da3d728eb Mon Sep 17 00:00:00 2001 From: ven Date: Mon, 7 Nov 2016 22:43:29 +0100 Subject: Update wolfram-es.html.markdown --- es-es/wolfram-es.html.markdown | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'es-es') diff --git a/es-es/wolfram-es.html.markdown b/es-es/wolfram-es.html.markdown index 187eda7b..44ec9e09 100644 --- a/es-es/wolfram-es.html.markdown +++ b/es-es/wolfram-es.html.markdown @@ -1,8 +1,9 @@ --- -Lenguaje: wolfram -contribuidor: +language: wolfram +lang: es-es +contributors: - ["Daniel Caballero", "http://github.com/danielcaballero796/"] -nombre de archivo: learnwolfram.nb +filename: learnwolfram-es.md --- Wolfram es un lenguaje subyacente originalmente utilizado en Mathematica, pero ahora esta disponible para su uso en múltiples contextos. -- cgit v1.2.3 From 0074c8f351fcbeb91ea126526704121b27a60f95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adri=C3=A1n=20Carrascal?= Date: Thu, 22 Dec 2016 15:20:48 -0500 Subject: Add Spanish translation for Elixir (#2604) --- es-es/elixir-es.html.markdown | 457 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 457 insertions(+) create mode 100644 es-es/elixir-es.html.markdown (limited to 'es-es') diff --git a/es-es/elixir-es.html.markdown b/es-es/elixir-es.html.markdown new file mode 100644 index 00000000..885165a6 --- /dev/null +++ b/es-es/elixir-es.html.markdown @@ -0,0 +1,457 @@ +--- +language: elixir +contributors: + - ["Joao Marques", "http://github.com/mrshankly"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] + - ["Ryan Plant", "https://github.com/ryanplant-au"] +translator: + - ["Adrian Carrascal", "https://github.com/acarrascalgarcia"] +filename: learnelixir-es.ex +lang: es-es + +--- + +Elixir es un lenguaje funcional moderno construido sobre la máquina virtual de Erlang. +Es completamente compatibe con Erlang, sin embargo, ofrece una sintaxis más estandar +y otras características más. + +```elixir + +# Los comentarios de única línea +# comienzan con un símbolo numérico. + +# No hay comentarios multilinea, +# pero se pueden apilar varios comentarios. + +# Para usar el shell de elixir se usa el comando `iex`. +# Los módulos se compilan con el comando `elixirc`. + +# Ambos deberían estar en la ruta si elixir se instaló correctamente. + +## --------------------------- +## -- Tipos básicos +## --------------------------- + +# Hay números +3 # integer +0x1F # integer +3.0 # float + +# Átomos, que son literales, una constante con nombre. Comienzan con `:`. +:hello # atom + +# Tuples that are stored contiguously in memory. +# Tuplas que se almacenan contiguamente en memoria. +{1,2,3} # tuple + +# Se puede acceder a un elemento de una tupla con la función `elem`: +elem({1, 2, 3}, 0) #=> 1 + +# Listas que se implementan como listas enlazadas. +[1,2,3] # list + +# Se puede acceder al primer y último elemento de la lista como: +[head | tail] = [1,2,3] +head #=> 1 +tail #=> [2,3] + +# En elixir, solo como Erlang, el `=` denota la coincidencia de patrones y +# no una asignación. +# +# This is how the above example of accessing the head and tail of a list works. +# Así es como el ejemplo anterior de acceder al +# primer y último elemento de una lista trabaja. + +# Una coincidencia de patrón errará cuando los lados no coincidan, en este ejemplo +# las tuplas tienen diferentes tamaños. +# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2} + +# También hay binarios +<<1,2,3>> # binary + +# Cadenas y listas de caracteres +"hello" # string +'hello' # char list + +# Cadenas de varias lineas +""" +I'm a multi-line +string. +""" +#=> "I'm a multi-line\nstring.\n" + +# Todas las cadenas se codifican en UTF-8: +"héllò" #=> "héllò" + +# Las cadenas son solo binarios realmente, y la lista de caracteres solo listas. +<> #=> "abc" +[?a, ?b, ?c] #=> 'abc' + +# `?a` en elixir devuelve el valor ASCII para el caracter `a` +?a #=> 97 + +# Para concatenar listas se usa `++`, para binarios `<>` +[1,2,3] ++ [4,5] #=> [1,2,3,4,5] +'hello ' ++ 'world' #=> 'hello world' + +<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> +"hello " <> "world" #=> "hello world" + +# Los rangos se representan como `start..end` (Es inclusivo) +1..10 #=> 1..10 +lower..upper = 1..10 # Se puede usar la coincidencia de patrones en los rangos también +[lower, upper] #=> [1, 10] + +# Los mapas son pares de llave-valor +genders = %{"david" => "male", "gillian" => "female"} +genders["david"] #=> "male" + +# Los mapas con llaves de tipo átomo se pueden usar como esto +genders = %{david: "male", gillian: "female"} +genders.gillian #=> "female" + +## --------------------------- +## -- Opetadores +## --------------------------- + +# Aritméticos +1 + 1 #=> 2 +10 - 5 #=> 5 +5 * 2 #=> 10 +10 / 2 #=> 5.0 + +# En elixir el operador `/` siempre devuelve un número flotante + +# Para hacer la división de número entero se debe usar `div` +div(10, 2) #=> 5 + +# Para obtener el residuo de la división se debe usar `rem` +rem(10, 3) #=> 1 + +# También hay operadores lógicos: `or`, `and` y `not`. +# Estos operadores esperan un boolean como su primer argumento. +true and true #=> true +false or true #=> true +# 1 and true #=> ** (ArgumentError) argument error + +# Elixir también provee `||`, `&&` y `!` donde acepta argumentos de cualquier tipo. +# Todos los valores excepto `false` y `nil` se evaluarán como verdadero. +1 || true #=> 1 +false && 1 #=> false +nil && 20 #=> nil +!true #=> false + +# Para comparaciones se tiene: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` y `>` +1 == 1 #=> true +1 != 1 #=> false +1 < 2 #=> true + +# `===` y `!==` son más estrictos cuando comparan números: +1 == 1.0 #=> true +1 === 1.0 #=> false + +# También se puede comparar dos tipos de datos diferentes: +1 < :hello #=> true + +# No se necesita memorizar el orden pero es importante tenerlo en cuenta: +# number < atom < reference < functions < port < pid < tuple < list < bit string + +## --------------------------- +## -- Control de flujo +## --------------------------- + +# Expresión `if` +if false do + "This will never be seen" +else + "This will" +end + +# También está la expresión `unless` +unless true do + "This will never be seen" +else + "This will" +end + +# Se acuerda de la coincidencia de patrones? +# Muchas estructuras de control de flujo en elixir confían en ella. + +# `case` permite comparar un valor con muchos patrones: +case {:one, :two} do + {:four, :five} -> + "This won't match" + {:one, x} -> + "This will match and bind `x` to `:two` in this clause" + _ -> + "This will match any value" +end + +# Es común vincular el valor a `_` si no se necesita. +# Por ejemplo, si unicamente el primer elemento de la lista es importante: +[head | _] = [1,2,3] +head #=> 1 + +# Para una mejor lectura se puede hace lo siguiente: +[head | _tail] = [:a, :b, :c] +head #=> :a + +# `cond` permite comprobar muchas condiciones al mismo tiempo. +# Usar `cond` en vez de muchas expresiones `if` anidadas. +cond do + 1 + 1 == 3 -> + "I will never be seen" + 2 * 5 == 12 -> + "Me neither" + 1 + 2 == 3 -> + "But I will" +end + +# Es común estabecer la última condición como `true`, donde siempre va a coincidir. +cond do + 1 + 1 == 3 -> + "I will never be seen" + 2 * 5 == 12 -> + "Me neither" + true -> + "But I will (this is essentially an else)" +end + +# `try/catch` se usa para atrapar valores que se lanzan, también soporta una +# clausula `after` que se invoca sin importar si un valor se atrapó o no. +try do + throw(:hello) +catch + message -> "Got #{message}." +after + IO.puts("I'm the after clause.") +end +#=> I'm the after clause +# "Got :hello" + +## --------------------------- +## -- Módulos y Funciones +## --------------------------- + +# Anonymous functions (notice the dot) +# Funciones anónimas (Ver el punto `.`) +square = fn(x) -> x * x end +square.(5) #=> 25 + +# También aceptan muchas cláusulas y guards. +# Los guards permiten afinar las coincidencias de patrones, +# se indican por la palabra reservada `when`: +f = fn + x, y when x > 0 -> x + y + x, y -> x * y +end + +f.(1, 3) #=> 4 +f.(-1, 3) #=> -3 + +# Elixir también provee muchas funciones incorporadas. +# Esas están disponibles en el ámbito actual. +is_number(10) #=> true +is_list("hello") #=> false +elem({1,2,3}, 0) #=> 1 + +# Se pueden agrupar varias funciones en un módulo. Dentro de un módulo +# se usa `def` para definir las funciones. +defmodule Math do + def sum(a, b) do + a + b + end + + def square(x) do + x * x + end +end + +Math.sum(1, 2) #=> 3 +Math.square(3) #=> 9 + +# Para compilar el módulo simple de Math se guarda como `math.ex` y se usa `elixirc` +# en la terminal: elixirc math.ex + +# Dentro de un módulo se puede definir funciones con `def` y funciones privadas con `defp`. +# Una función definida con `def` está disponible para ser invocada desde otros módulos, +# una función privada se puede solo invocar localmente. +defmodule PrivateMath do + def sum(a, b) do + do_sum(a, b) + end + + defp do_sum(a, b) do + a + b + end +end + +PrivateMath.sum(1, 2) #=> 3 +# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError) + +# La declaración de funciones también soportan guards y múltiples cláusulas: +defmodule Geometry do + def area({:rectangle, w, h}) do + w * h + end + + def area({:circle, r}) when is_number(r) do + 3.14 * r * r + end +end + +Geometry.area({:rectangle, 2, 3}) #=> 6 +Geometry.area({:circle, 3}) #=> 28.25999999999999801048 +# Geometry.area({:circle, "not_a_number"}) +#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1 + +# Debido a la inmutabilidad, la recursión es una gran parte de elixir +defmodule Recursion do + def sum_list([head | tail], acc) do + sum_list(tail, acc + head) + end + + def sum_list([], acc) do + acc + end +end + +Recursion.sum_list([1,2,3], 0) #=> 6 + +# Los módulos de Elixir soportan atributos, hay atributos incorporados y +# se pueden agregar otros personalizados. +defmodule MyMod do + @moduledoc """ + This is a built-in attribute on a example module. + """ + + @my_data 100 # This is a custom attribute. + IO.inspect(@my_data) #=> 100 +end + +# El operador pipe |> permite que se pase la salida de una expresión +# como el primer parámetro en una función. + +Range.new(1,10) +|> Enum.map(fn x -> x * x end) +|> Enum.filter(fn x -> rem(x, 2) == 0 end) +#=> [4, 16, 36, 64, 100] + +## --------------------------- +## -- Structs and Excepciones +## --------------------------- + +# Los Structs son extensiones de los mapas que traen valores por defecto, +# garantes en tiempo de compilación y polimorfismo en Elixir. +defmodule Person do + defstruct name: nil, age: 0, height: 0 +end + +joe_info = %Person{ name: "Joe", age: 30, height: 180 } +#=> %Person{age: 30, height: 180, name: "Joe"} + +# Acceder al valor de name +joe_info.name #=> "Joe" + +# Actualizar el valor de age +older_joe_info = %{ joe_info | age: 31 } +#=> %Person{age: 31, height: 180, name: "Joe"} + +# El bloque `try` con la palabra reservada `rescue` se usa para manejar excepciones +try do + raise "some error" +rescue + RuntimeError -> "rescued a runtime error" + _error -> "this will rescue any error" +end +#=> "rescued a runtime error" + +# Todas las excepciones tienen un mensaje +try do + raise "some error" +rescue + x in [RuntimeError] -> + x.message +end +#=> "some error" + +## --------------------------- +## -- Concurrencia +## --------------------------- + +# Elixir confía en el modelo actor para la concurrencia. Todo lo que se necesita para escribir +# programas concurrentes en elixir son tres primitivas: procesos de desove, +# envío de mensajes y recepción de mensajes. + +# Para empezar un nuevo proceso se usa la función `spawn`, +# donde toma una función como argumento. +f = fn -> 2 * 2 end #=> #Function +spawn(f) #=> #PID<0.40.0> + +# `spawn` devuelve un pid (identificador de proceso), se puede usar este pid para enviar +# mensajes para el proceso. Para hacer que un mensaje pase se usa el operador `send`. +# Para que todo esto se útil se necesita estar disponibles para recibir mensajes. Esto se +# alcanza con el mecanismo `receive`: + +# El bloque `receive do` se usa para escuchar los mensajes y procesarlos +# cuando se reciben. Un bloque `receive do` solo procesará +# un mensaje recibido. Para procesar múltiples mensajes, +# una función con un bloque `receive do` tiene que llamarse recursivamente +# para entrar en el bloque `receive do` otra vez. + +defmodule Geometry do + def area_loop do + receive do + {:rectangle, w, h} -> + IO.puts("Area = #{w * h}") + area_loop() + {:circle, r} -> + IO.puts("Area = #{3.14 * r * r}") + area_loop() + end + end +end + +# Compilar el módulo y crear un proceso que evalue `area_loop` en el shell +pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0> +# Como alternativa +pid = spawn(Geometry, :area_loop, []) + +# Enviar un mensaje al `pid` que coincidirá con un patrón en el que recibe una sentencia +send pid, {:rectangle, 2, 3} +#=> Area = 6 +# {:rectangle,2,3} + +send pid, {:circle, 2} +#=> Area = 12.56000000000000049738 +# {:circle,2} + +# El shell también es un proceso, se puede usar `self` para obtener el pid actual +self() #=> #PID<0.27.0> + +## --------------------------- +## -- Agentes +## --------------------------- + +# Un agente es un proceso que mantiene el seguimiento de algún valor cambiante + +# Un agente se crea con `Agent.start_link`, introducuendole una función +# El estado inicial del agente será lo que sea que la función devuelva +{ok, my_agent} = Agent.start_link(fn -> ["red, green"] end) + +# `Agent.get` toma un nombre de agente y un `fn` que se pasa como el estado actual +# Lo que sea que este `fn` devuelva es lo que se obtendrá de vuelta +Agent.get(my_agent, fn colors -> colors end) #=> ["red, "green"] + +# El estado del agente se actualiza de la misma manera +Agent.update(my_agent, fn colors -> ["blue" | colors] end) +``` + +## Referencias + +* [Getting started guide](http://elixir-lang.org/getting-started/introduction.html) from the [Elixir website](http://elixir-lang.org) +* [Elixir Documentation](http://elixir-lang.org/docs/master/) +* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas +* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) +* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) by Fred Hebert +* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) by Joe Armstrong -- cgit v1.2.3 From ae16d450781aecd9ff4423deb2cf67317d309080 Mon Sep 17 00:00:00 2001 From: omgee Date: Tue, 3 Jan 2017 09:41:35 +0200 Subject: [c++/en,es,it,br,ru,ch] Fix forgotten namespace std:: (#2619) --- es-es/c++-es.html.markdown | 126 ++++++++++++++++++++++----------------------- 1 file changed, 63 insertions(+), 63 deletions(-) (limited to 'es-es') diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown index 07c8bc03..bd1ad07c 100644 --- a/es-es/c++-es.html.markdown +++ b/es-es/c++-es.html.markdown @@ -20,11 +20,11 @@ fue diseñado para - soportar programación orientada a objetos - soportar programación genérica -Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes, -es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser -directamente ejecutadas por el procesador y ofrece un estricto control sobre -el hardware (como C), mientras ofrece características de alto nivel como -genericidad, excepciones, y clases. Esta combinación de velocidad y +Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes, +es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser +directamente ejecutadas por el procesador y ofrece un estricto control sobre +el hardware (como C), mientras ofrece características de alto nivel como +genericidad, excepciones, y clases. Esta combinación de velocidad y funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados. ```c++ @@ -32,22 +32,22 @@ funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados // Comparación con C //////////////////// -// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las +// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las // declaraciones de variables, tipos primitivos y funciones. -// Al igual que en C, el punto de entrada de tu programa es una función llamada -// main con un retorno de tipo entero. +// Al igual que en C, el punto de entrada de tu programa es una función llamada +// main con un retorno de tipo entero. // Este valor sirve como código de salida del programa. // Mira http://en.wikipedia.org/wiki/Exit_status para mayor información. int main(int argc, char** argv) { - // Los argumentos de la línea de comandos se pasan por argc y argv de la + // Los argumentos de la línea de comandos se pasan por argc y argv de la // misma manera que en C. - // argc indica el número de argumentos, - // y argv es un arreglo de strings de estilo C (char*) + // argc indica el número de argumentos, + // y argv es un arreglo de strings de estilo C (char*) // representando los argumentos. // El primer argumento es el nombre con el que el programa es llamado. - // argc y argv pueden omitirse si no te preocupan los argumentos, + // argc y argv pueden omitirse si no te preocupan los argumentos, // dejando la definición de la función como int main () // Un estado de salida 0 indica éxito. @@ -72,7 +72,7 @@ void func(); // función que puede aceptar cualquier número de argumentos // Use nullptr en lugar de NULL en C++ int* ip = nullptr; -// Las cabeceras (headers) estándar de C están disponibles en C ++, +// Las cabeceras (headers) estándar de C están disponibles en C ++, // pero tienen el prefijo "c" y no tienen sufijo .h. #include @@ -109,7 +109,7 @@ int main() // Argumentos de función por defecto //////////////////////////////////// -// Puedes proporcionar argumentos por defecto para una función si no son +// Puedes proporcionar argumentos por defecto para una función si no son // proporcionados por quien la llama. void doSomethingWithInts(int a = 1, int b = 4) @@ -134,7 +134,7 @@ void invalidDeclaration(int a = 1, int b) // Error! // Espacios de nombre ///////////////////// -// Espacios de nombres proporcionan ámbitos separados para variable, función y +// Espacios de nombres proporcionan ámbitos separados para variable, función y // otras declaraciones. // Los espacios de nombres se pueden anidar. @@ -162,8 +162,8 @@ void foo() int main() { - // Incluye todos los símbolos del espacio de nombre Second en el ámbito - // actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora + // Incluye todos los símbolos del espacio de nombre Second en el ámbito + // actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora // es ambigua si estamos llamando a foo en espacio de nombres Second o en // el nivel superior. using namespace Second; @@ -254,7 +254,7 @@ const string& barRef = bar; // Crea una referencia constante a bar. // modificados. barRef += ". Hola!"; // Error, referencia constante no puede ser modificada. -// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un +// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un // concepto llamado objeto temporal. Supongamos que tenemos el siguiente código: string tempObjectFun() { ... } string retVal = tempObjectFun(); @@ -267,16 +267,16 @@ string retVal = tempObjectFun(); // El objeto devuelto se llama objeto temporal. Objetos temporales son // creados cada vez que una función devuelve un objeto, y es destruido en el // fin de la evaluación de la expresión que encierra (Bueno, esto es lo que la -// norma dice, pero los compiladores están autorizados a cambiar este -// comportamiento. Busca "return value optimization" para ver mas detalles). +// norma dice, pero los compiladores están autorizados a cambiar este +// comportamiento. Busca "return value optimization" para ver mas detalles). // Así que en este código: foo(bar(tempObjectFun())) // Suponiendo que foo y bar existen, el objeto retornado de tempObjectFun es // pasado al bar, y se destruye antes de llamar foo. -// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo -// de la expresión encerrada" es si un objeto temporal se une a una +// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo +// de la expresión encerrada" es si un objeto temporal se une a una // referencia constante, en cuyo caso su vida se extiende al ámbito actual: void constReferenceTempObjectFun() { @@ -287,7 +287,7 @@ void constReferenceTempObjectFun() { } // Otro tipo de referencia introducida en C ++ 11 es específicamente para -// objetos temporales. No se puede tener una variable de este tipo, pero tiene +// objetos temporales. No se puede tener una variable de este tipo, pero tiene // prioridad en resolución de sobrecarga: void someFun(string& s) { ... } // Referencia regular @@ -302,7 +302,7 @@ someFun(tempObjectFun()); // Llama la versión con referencia temporal basic_string(const basic_string& other); basic_string(basic_string&& other); -// La idea es que si estamos construyendo una nueva cadena de un objeto temporal +// La idea es que si estamos construyendo una nueva cadena de un objeto temporal // (que va a ser destruido pronto de todos modos), podemos tener un constructor // mas eficiente que "rescata" partes de esa cadena temporal. Usted verá este // Concepto denominado "movimiento semántico". @@ -341,13 +341,13 @@ public: // Funciones que no modifican el estado del objeto // Deben marcarse como const. // Esto le permite llamarlas si se envia una referencia constante al objeto. - // También tenga en cuenta que las funciones deben ser declaradas - // explícitamente como _virtual_ para que sea reemplazada en las clases + // También tenga en cuenta que las funciones deben ser declaradas + // explícitamente como _virtual_ para que sea reemplazada en las clases // derivadas. - // Las funciones no son virtuales por defecto por razones de rendimiento. + // Las funciones no son virtuales por defecto por razones de rendimiento. virtual void print() const; - // Las funciones también se pueden definir en el interior + // Las funciones también se pueden definir en el interior // del cuerpo de la clase. // Funciones definidas como tales están entre líneas automáticamente. void bark() const { std::cout << name << " barks!\n"; } @@ -358,7 +358,7 @@ public: // (mira abajo) // El destructor debe ser virtual si una clase es dervada desde el; // Si no es virtual, entonces la clase derivada destructor - // No será llamada si el objeto se destruye a través de una referencia de + // No será llamada si el objeto se destruye a través de una referencia de // la clase base o puntero. virtual ~Dog(); @@ -392,7 +392,7 @@ void Dog::print() const Dog::~Dog() { - cout << "Adiós " << name << "\n"; + std::cout << "Adiós " << name << "\n"; } int main() { @@ -410,7 +410,7 @@ class OwnedDog : public Dog { void setOwner(const std::string& dogsOwner); - // Reemplaza el comportamiento de la función de impresión + // Reemplaza el comportamiento de la función de impresión // de todos los OwnedDogs. Mira // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping // Para una introducción más general si no está familiarizado con el @@ -442,7 +442,7 @@ void OwnedDog::print() const // Inicialización y sobrecarga de operadores //////////////////////////////////////////// -// En C ++ se puede sobrecargar el comportamiento +// En C ++ se puede sobrecargar el comportamiento // de los operadores como +, -, *, /, etc. // Esto se hace mediante la definición de una función que es llamada // cada vez que se utiliza el operador. @@ -505,14 +505,14 @@ int main () { // Plantillas (Templates) ///////////////////////// -// Las plantillas en C++ se utilizan sobre todo en la programación genérica, -// a pesar de que son mucho más poderoso que los constructores genéricos -// en otros lenguajes. Ellos también soportan especialización explícita y -// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje +// Las plantillas en C++ se utilizan sobre todo en la programación genérica, +// a pesar de que son mucho más poderoso que los constructores genéricos +// en otros lenguajes. Ellos también soportan especialización explícita y +// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje // funcional Turing-completo incrustado en C ++! -// Empezamos con el tipo de programación genérica que podría estar -// familiarizado. +// Empezamos con el tipo de programación genérica que podría estar +// familiarizado. // Para definir una clase o función que toma un parámetro de tipo: template class Box { @@ -521,9 +521,9 @@ public: void insert(const T&) { ... } }; -// Durante la compilación, el compilador realmente genera copias de cada -// plantilla con parámetros sustituidos, por lo que la definición completa -// de la clase debe estar presente en cada invocación. +// Durante la compilación, el compilador realmente genera copias de cada +// plantilla con parámetros sustituidos, por lo que la definición completa +// de la clase debe estar presente en cada invocación. // Es por esto que usted verá clases de plantilla definidas // Enteramente en archivos de cabecera. @@ -537,8 +537,8 @@ intBox.insert(123); Box > boxOfBox; boxOfBox.insert(intBox); -// Hasta C++11, había que colocar un espacio entre los dos '>'s, -// de lo contrario '>>' serían analizados como el operador de desplazamiento +// Hasta C++11, había que colocar un espacio entre los dos '>'s, +// de lo contrario '>>' serían analizados como el operador de desplazamiento // a la derecha. @@ -558,9 +558,9 @@ void barkThreeTimes(const T& input) input.bark(); } -// Observe que no se especifica nada acerca de los tipos de parámetros aquí. -// El compilador generará y comprobará cada invocación de la plantilla, -// por lo que la función anterior funciona con cualquier tipo "T" +// Observe que no se especifica nada acerca de los tipos de parámetros aquí. +// El compilador generará y comprobará cada invocación de la plantilla, +// por lo que la función anterior funciona con cualquier tipo "T" // que tenga un método 'bark' constante! @@ -574,12 +574,12 @@ void printMessage() { cout << "Aprende C++ en " << Y << " minutos!" << endl; } -// Y usted puede especializar explícitamente plantillas -// para código más eficiente. -// Por supuesto, la mayor parte del mundo real que utiliza una especialización +// Y usted puede especializar explícitamente plantillas +// para código más eficiente. +// Por supuesto, la mayor parte del mundo real que utiliza una especialización // no son tan triviales como esta. -// Tenga en cuenta que usted todavía tiene que declarar la función (o clase) -// como plantilla incluso si ha especificado de forma explícita todos +// Tenga en cuenta que usted todavía tiene que declarar la función (o clase) +// como plantilla incluso si ha especificado de forma explícita todos // los parámetros. template<> @@ -601,7 +601,7 @@ printMessage<10>(); // Prints "Aprende C++ rapido en solo 10 minutos!" #include #include -//Todas las excepciones lanzadas dentro del bloque _try_ pueden ser +//Todas las excepciones lanzadas dentro del bloque _try_ pueden ser // capturados por los siguientes manejadores _catch_. try { // No asignar excepciones en el heap usando _new_. @@ -651,7 +651,7 @@ void doSomethingWithAFile(const char* filename) // (Excepciones son la mejor forma de manejar los fallos, // pero algunos programadores, especialmente los que tienen un fondo C, // estan en desacuerdo sobre la utilidad de las excepciones). -// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador +// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador // del archivo si se ha producido un problema. bool doSomethingWithAFile(const char* filename) { @@ -716,7 +716,7 @@ void doSomethingWithAFile(const char* filename) // Compare esto con el uso de la clase de flujo de archivos de C++ (fstream) // fstream utiliza su destructor para cerrar el archivo. -// Los destructores son llamados automáticamente +// Los destructores son llamados automáticamente // cuando un objeto queda fuera del ámbito. void doSomethingWithAFile(const std::string& filename) { @@ -734,7 +734,7 @@ void doSomethingWithAFile(const std::string& filename) // 1. No importa lo que pase, // El recurso (en este caso el manejador de archivo) será limpiado. // Una vez que escribes el destructor correctamente, -// Es _imposible_ olvidar cerrar el identificador y permitir +// Es _imposible_ olvidar cerrar el identificador y permitir // fugas del recurso. // 2. Tenga en cuenta que el código es mucho más limpio. // El destructor se encarga de cerrar el archivo detrás de cámaras @@ -743,13 +743,13 @@ void doSomethingWithAFile(const std::string& filename) // Una excepción puede ser lanzado en cualquier lugar de la función // y la limpieza ocurrirá. -// Todo el código idiomático C++ utiliza RAII ampliamente para todos los +// Todo el código idiomático C++ utiliza RAII ampliamente para todos los // recursos. // Otros ejemplos incluyen // - Memoria usando unique_ptr y shared_ptr // - Contenedores (Containers) - la biblioteca estándar linked list, // vector (es decir, array con auto-cambio de tamaño), hash maps, etc. -// Destruimos todos sus contenidos de forma automática +// Destruimos todos sus contenidos de forma automática // cuando quedan fuera del ámbito. // - Mutex utilizando lock_guard y unique_lock @@ -758,9 +758,9 @@ void doSomethingWithAFile(const std::string& filename) // Cosas divertidas ///////////////////// -// Aspectos de C ++ que pueden sorprender a los recién llegados +// Aspectos de C ++ que pueden sorprender a los recién llegados // (e incluso algunos veteranos). -// Esta sección es, por desgracia, salvajemente incompleta; +// Esta sección es, por desgracia, salvajemente incompleta; // C++ es uno de los lenguajes con los que mas facil te disparas en el pie. // Tu puedes sobreescribir métodos privados! @@ -788,13 +788,13 @@ pt2 = nullptr; // Establece pt2 como null. *pt = nullptr; // Esto todavía compila, a pesar de que '*pt' es un bool! // '=' != '=' != '='! -// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos) +// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos) // copia del constructor. Foo f2; Foo f1 = f2; // Llama Foo::Foo(const Foo&) o variante, pero solo copia el 'Foo' parte de -// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este +// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este // comportamiento horrible se llama "Corte de objetos." FooSub fooSub; Foo f1 = fooSub; @@ -809,13 +809,13 @@ class Foo { ... }; vector v; for (int i = 0; i < 10; ++i) v.push_back(Foo()); -// La siguiente línea establece el tamaño de v en 0, +// La siguiente línea establece el tamaño de v en 0, // pero los destructores no son llamados y los recursos no se liberan! v.empty(); v.push_back(Foo()); // Nuevo valor se copia en el primer Foo que insertamos -// En verdad destruye todos los valores en v. +// En verdad destruye todos los valores en v. // Consulta la sección acerca de los objetos temporales para la // explicación de por qué esto funciona. v.swap(vector()); -- cgit v1.2.3 From c1d773eab766891c8c9f5820bf18c8fafa6a8d5e Mon Sep 17 00:00:00 2001 From: Pablo Najt Date: Fri, 24 Mar 2017 14:53:41 -0300 Subject: [kotlin/all] Rename variable fooMutableDate to fooMutableData (#2688) (#2689) --- es-es/kotlin-es.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'es-es') diff --git a/es-es/kotlin-es.html.markdown b/es-es/kotlin-es.html.markdown index 5d2f165a..f48f6536 100644 --- a/es-es/kotlin-es.html.markdown +++ b/es-es/kotlin-es.html.markdown @@ -185,13 +185,13 @@ fun main(args: Array) { // La función "with" es similar a la expresión de JavaScript "with". data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) - val fooMutableDate = MutableDataClassExample(7, 4, 9) - with (fooMutableDate) { + val fooMutableData = MutableDataClassExample(7, 4, 9) + with (fooMutableData) { x -= 2 y += 2 z-- } - println(fooMutableDate) // => MutableDataClassExample(x=5, y=6, z=8) + println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8) /* Podemos crear una lista utilizando la función "listOf". -- cgit v1.2.3 From 63a6eb1182205389388e13b680962199ac9b3ffb Mon Sep 17 00:00:00 2001 From: Andy Date: Sat, 1 Apr 2017 22:19:58 +0200 Subject: [haskell] Updating second headline (#2695) * Haskell: Updating second headline * Haskell: Updating second headline (es) * Haskell: Updating second headline (fr) * Haskell: Updating second headline (pl) * Haskell: Updating second headline (pt) * Haskell: Updating second headline (ro) * Haskell: Updating second headline (ru) * Haskell: Updating second headline (cn) --- es-es/haskell-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/haskell-es.html.markdown b/es-es/haskell-es.html.markdown index babb1060..66ce109d 100644 --- a/es-es/haskell-es.html.markdown +++ b/es-es/haskell-es.html.markdown @@ -66,7 +66,7 @@ not False -- True ---------------------------------------------------- --- Listas y Tuplas +-- 2. Listas y Tuplas ---------------------------------------------------- -- Cada elemento en una lista debe ser del mismo tipo. -- cgit v1.2.3 From d30d6f69ca07014efdce95d771403a43423d2143 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Vitor=20Verona=20Biazibetti?= Date: Fri, 19 May 2017 18:34:27 -0300 Subject: [Kotlin/all] Remove whitespace in variable declaration with explicit type (#2733) * Removed whitespace in variable declaration with explicit type (Kotlin) * Removed whitespace in variable declaration with explicit type (Kotlin translations) --- es-es/kotlin-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/kotlin-es.html.markdown b/es-es/kotlin-es.html.markdown index f48f6536..045f92d1 100644 --- a/es-es/kotlin-es.html.markdown +++ b/es-es/kotlin-es.html.markdown @@ -39,7 +39,7 @@ fun main(args: Array) { de tal manera que no tenemos que especificarlo explícitamente cada vez. Podemos declarar explícitamente el tipo de una variable así: */ - val foo : Int = 7 + val foo: Int = 7 /* Las cadenas pueden ser representadas de la misma manera que Java. -- cgit v1.2.3 From 3c7750b5639cc4072014af9dafceb7cf6ec5e15d Mon Sep 17 00:00:00 2001 From: ven Date: Tue, 23 May 2017 17:45:17 +0200 Subject: fix css-es directory --- es-es/css-es.html | 327 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 327 insertions(+) create mode 100644 es-es/css-es.html (limited to 'es-es') diff --git a/es-es/css-es.html b/es-es/css-es.html new file mode 100644 index 00000000..506a9467 --- /dev/null +++ b/es-es/css-es.html @@ -0,0 +1,327 @@ +--- +language: css +contributors: + - ["Mohammad Valipour", "https://github.com/mvalipour"] + - ["Marco Scannadinari", "https://github.com/marcoms"] + - ["Geoffrey Liu", "https://github.com/g-liu"] + - ["Connor Shea", "https://github.com/connorshea"] + - ["Deepanshu Utkarsh", "https://github.com/duci9y"] + - ["Brett Taylor", "https://github.com/glutnix"] + - ["Tyler Mumford", "https://tylermumford.com"] +translators: + - ["miky ackerman", "https://github.com/mikyackerman"] +lang: es-es +filename: learncss-es.css +--- + +Paginas web estan contruidas en HTML, lo cual especifica el contenido de una pagina +CSS(Hoja de Estilos en Cascada) es un lenguaje separado el cual especifica +la **apariencia** de una pagina. + +codigo CSS esta hecho de *reglas* estaticas. Cada regla toma uno o mas *selectores* y da *valores* especificos a un numero de *propiedades* visuales. Esas propiedades estan entonces aplicadas a los elementos indicados en una pagina por los selectores + +Esta guia ha sido escrita con CSS 2 en mente, la cual es extendida por una nueva caracterica de CSS 3. + +**NOTA:** Debido a que CSS produce resultados visuales, para aprenderlo, necesitas +Probar todo en un patio de juegos CSS como [dabblet] (http://dabblet.com/). +El objetivo principal de este artículo es la sintaxis y algunos consejos generales. + +## Sintaxis + +```css +/* Los comentarios aparecen dentro de un diagonal-asterisco, justo como esta linea + no hay "comentarios en una linea"; este es el unico estilo de comentario.*/ + + +/* #################### + ## SELECTORS + #################### */ + +/* el selector es usado para apuntar a un elemento de la pagina. */ +selector { property: value; /* more properties...*/ } + +/* +Here is an example element: + +
+*/ + +/* You can target it using one of its CSS classes */ +.class1 { } + +/* or both classes! */ +.class1.class2 { } + +/* or its name */ +div { } + +/* or its id */ +#anID { } + +/* or using the fact that it has an attribute! */ +[attr] { font-size:smaller; } + +/* or that the attribute has a specific value */ +[attr='value'] { font-size:smaller; } + +/* starts with a value (CSS 3) */ +[attr^='val'] { font-size:smaller; } + +/* or ends with a value (CSS 3) */ +[attr$='ue'] { font-size:smaller; } + +/* or contains a value in a space-separated list */ +[otherAttr~='foo'] { } +[otherAttr~='bar'] { } + +/* or contains a value in a dash-separated list, e.g., "-" (U+002D) */ +[otherAttr|='en'] { font-size:smaller; } + + +/* You can combine different selectors to create a more focused selector. Don't + put spaces between them. */ +div.some-class[attr$='ue'] { } + +/* You can select an element which is a child of another element */ +div.some-parent > .class-name { } + +/* or a descendant of another element. Children are the direct descendants of + their parent element, only one level down the tree. Descendants can be any + level down the tree. */ +div.some-parent .class-name { } + +/* Warning: the same selector without a space has another meaning. + Can you guess what? */ +div.some-parent.class-name { } + +/* You may also select an element based on its adjacent sibling */ +.i-am-just-before + .this-element { } + +/* or any sibling preceding it */ +.i-am-any-element-before ~ .this-element { } + +/* There are some selectors called pseudo classes that can be used to select an + element only when it is in a particular state */ + +/* for example, when the cursor hovers over an element */ +selector:hover { } + +/* or a link has been visited */ +selector:visited { } + +/* or hasn't been visited */ +selected:link { } + +/* or an element is in focus */ +selected:focus { } + +/* any element that is the first child of its parent */ +selector:first-child {} + +/* any element that is the last child of its parent */ +selector:last-child {} + +/* Just like pseudo classes, pseudo elements allow you to style certain parts of + a document */ + +/* matches a virtual first child of the selected element */ +selector::before {} + +/* matches a virtual last child of the selected element */ +selector::after {} + +/* At appropriate places, an asterisk may be used as a wildcard to select every + element */ +* { } /* all elements */ +.parent * { } /* all descendants */ +.parent > * { } /* all children */ + +/* #################### + ## PROPERTIES + #################### */ + +selector { + + /* Units of length can be absolute or relative. */ + + /* Relative units */ + width: 50%; /* percentage of parent element width */ + font-size: 2em; /* multiples of element's original font-size */ + font-size: 2rem; /* or the root element's font-size */ + font-size: 2vw; /* multiples of 1% of the viewport's width (CSS 3) */ + font-size: 2vh; /* or its height */ + font-size: 2vmin; /* whichever of a vh or a vw is smaller */ + font-size: 2vmax; /* or greater */ + + /* Absolute units */ + width: 200px; /* pixels */ + font-size: 20pt; /* points */ + width: 5cm; /* centimeters */ + min-width: 50mm; /* millimeters */ + max-width: 5in; /* inches */ + + /* Colors */ + color: #F6E; /* short hex format */ + color: #FF66EE; /* long hex format */ + color: tomato; /* a named color */ + color: rgb(255, 255, 255); /* as rgb values */ + color: rgb(10%, 20%, 50%); /* as rgb percentages */ + color: rgba(255, 0, 0, 0.3); /* as rgba values (CSS 3) Note: 0 <= a <= 1 */ + color: transparent; /* equivalent to setting the alpha to 0 */ + color: hsl(0, 100%, 50%); /* as hsl percentages (CSS 3) */ + color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */ + + /* Borders */ + border-width:5px; + border-style:solid; + border-color:red; /* similar to how background-color is set */ + border: 5px solid red; /* this is a short hand approach for the same */ + border-radius:20px; /* this is a CSS3 property */ + + /* Images as backgrounds of elements */ + background-image: url(/img-path/img.jpg); /* quotes inside url() optional */ + + /* Fonts */ + font-family: Arial; + /* if the font family name has a space, it must be quoted */ + font-family: "Courier New"; + /* if the first one is not found, the browser uses the next, and so on */ + font-family: "Courier New", Trebuchet, Arial, sans-serif; +} +``` + +## Usage + +Save a CSS stylesheet with the extension `.css`. + +```html + + + + + + + +
+
+``` + +## Precedence or Cascade + +An element may be targeted by multiple selectors and may have a property set on +it in more than once. In these cases, one of the rules takes precedence over +others. Rules with a more specific selector take precedence over a less specific +one, and a rule occurring later in the stylesheet overwrites a previous one +(which also means that if two different linked stylesheets contain rules for an +element and if the rules are of the same specificity, then order of linking +would take precedence and the sheet linked latest would govern styling) . + +This process is called cascading, hence the name Cascading Style Sheets. + +Given the following CSS: + +```css +/* A */ +p.class1[attr='value'] + +/* B */ +p.class1 { } + +/* C */ +p.class2 { } + +/* D */ +p { } + +/* E */ +p { property: value !important; } +``` + +and the following markup: + +```html +
+``` + +The precedence of style is as follows. Remember, the precedence is for each +**property**, not for the entire block. + +* `E` has the highest precedence because of the keyword `!important`. It is +recommended that you avoid its usage. +* `F` is next, because it is an inline style. +* `A` is next, because it is more "specific" than anything else. It has 3 + specifiers: The name of the element `p`, its class `class1`, an attribute + `attr='value'`. +* `C` is next, even though it has the same specificity as `B`. + This is because it appears after `B`. +* `B` is next. +* `D` is the last one. + +## Media Queries + +CSS Media Queries are a feature in CSS 3 which allows you to specify when certain CSS rules should be applied, such as when printed, or when on a screen with certain dimensions or pixel density. They do not add to the selector's specificity. + +```css +/* A rule that will be used on all devices */ +h1 { + font-size: 2em; + color: white; + background-color: black; +} + +/* change the h1 to use less ink on a printer */ +@media print { + h1 { + color: black; + background-color: white; + } +} + +/* make the font bigger when shown on a screen at least 480px wide */ +@media screen and (min-width: 480px) { + h1 { + font-size: 3em; + font-weight: normal; + } +} +``` + +Media queries can include these features: +`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Most of these features can be prefixed with `min-` or `max-`. + +The `resolution` feature is not supported by older devices, instead use `device-pixel-ratio`. + +Many smartphones and tablets will attempt to render the page as if it were on a desktop unless you provide a `viewport` meta-tag. + +```html + + + +``` + +## Compatibility + +Most of the features in CSS 2 (and many in CSS 3) are available across all +browsers and devices. But it's always good practice to check before using +a new feature. + +## Resources + +* [CanIUse](http://caniuse.com) (Detailed compatibility info) +* [Dabblet](http://dabblet.com/) (CSS playground) +* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) (Tutorials and reference) +* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) (Reference) + +## Further Reading + +* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/) +* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/) +* [QuirksMode CSS](http://www.quirksmode.org/css/) +* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context) +* [SASS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing +* [CSS-Tricks](https://css-tricks.com) + + -- cgit v1.2.3 From 98912234c121c78b49b557725229db337ac4a0f5 Mon Sep 17 00:00:00 2001 From: Alexis Ortega Date: Fri, 7 Jul 2017 14:49:01 -0600 Subject: [go/es] Fix typos --- es-es/go-es.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'es-es') diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown index c41d693d..78267695 100644 --- a/es-es/go-es.html.markdown +++ b/es-es/go-es.html.markdown @@ -26,7 +26,7 @@ Es rápido compilando y rápido al ejecutar, añade una concurrencia fácil de entender para las CPUs de varios núcleos de hoy día, y tiene características que ayudan con la programación a gran escala. -Go viene con una biblioteca estándar muy buena y una entusiasta comunidad. +Go viene con una biblioteca estándar muy buena y una comunidad entusiasta. ```go // Comentario de una sola línea @@ -52,7 +52,7 @@ import ( // para el ejecutable. Te guste o no, Go utiliza llaves. func main() { // Println imprime una línea a stdout. - // Cualificalo con el nombre del paquete, fmt. + // Llámalo con el nombre del paquete, fmt. fmt.Println("¡Hola mundo!") // Llama a otra función de este paquete. @@ -90,12 +90,12 @@ saltos de línea.` // mismo tipo cadena g := 'Σ' // Tipo rune, un alias de int32, alberga un carácter 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 iniciadores. + // Sintaxis var con iniciadores. var u uint = 7 // Sin signo, pero la implementación depende del tamaño // como en int. var pi float32 = 22. / 7 - // Sintáxis de conversión con una declaración corta. + // Sintaxis de conversión con una declaración corta. n := byte('\n') // byte es un alias para uint8. // Los Arreglos tienen un tamaño fijo a la hora de compilar. @@ -377,8 +377,8 @@ func aprendeConcurrencia() { go func() { c <- 84 }() // Inicia una nueva rutinago solo para // enviar un valor. go func() { cs <- "verboso" }() // Otra vez, para cs en esta ocasión. - // Select tiene una sintáxis parecida a la instrucción switch pero cada - // caso involucra una operacion con un canal. Selecciona un caso de + // Select tiene una sintaxis parecida a la instrucción switch pero cada + // caso involucra una operación con un canal. Selecciona un caso de // forma aleatoria de los casos que están listos para comunicarse. select { case i := <-c: // El valor recibido se puede asignar a una variable, -- cgit v1.2.3 From ade91a6fd955841d2573753c419ffec44f1ba596 Mon Sep 17 00:00:00 2001 From: hromojaro Date: Mon, 10 Jul 2017 15:55:40 +0200 Subject: =?UTF-8?q?[amd/es-es]=20Replace=20'T=C3=B3pico'=20with=20'Tema'?= =?UTF-8?q?=20(#2790)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- es-es/amd-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown index 7a59ddd6..40aa6647 100644 --- a/es-es/amd-es.html.markdown +++ b/es-es/amd-es.html.markdown @@ -190,7 +190,7 @@ Para usar el fichero creado en producción, simplemente intercambia `data-main`: Un increíblemente detallado [resumen de opciones de generación](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponible en el repositorio de GitHub. -### Tópicos no cubiertos en este tutorial +### Temas no cubiertos en este tutorial * [Cargador de plugins / transformaciones](http://requirejs.org/docs/plugins.html) * [Cargando y exportando estilos CommonJS](http://requirejs.org/docs/commonjs.html) * [Configuración avanzada](http://requirejs.org/docs/api.html#config) -- cgit v1.2.3 From ba3847a9f20779a8b9cacb54ea7db3f1a20d2c06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A9ctor=20Romojaro?= Date: Mon, 10 Jul 2017 20:53:55 +0200 Subject: [tcl/es-es] First version of the spanish translation --- es-es/tcl-es.html.markdown | 600 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 600 insertions(+) create mode 100644 es-es/tcl-es.html.markdown (limited to 'es-es') diff --git a/es-es/tcl-es.html.markdown b/es-es/tcl-es.html.markdown new file mode 100644 index 00000000..5db72ae1 --- /dev/null +++ b/es-es/tcl-es.html.markdown @@ -0,0 +1,600 @@ +--- +language: Tcl +contributors: + - ["Poor Yorick", "https://pooryorick.com/"] +translators: + - ["Héctor Romojaro", "https://github.com/hromojaro"] +lang: es-es +filename: learntcl-es.tcl +--- + +Tcl fue creado por [John Ousterhout](https://wiki.tcl.tk/John%20Ousterout) como +un lenguaje reutilizable de scripting para herramientas de diseño de circuitos +de las que él era autor. En 1997 recibió el +[ACM Software System Award](https://en.wikipedia.org/wiki/ACM_Software_System_Award) +por Tcl. Tcl puede ser utilizado tanto como lenguaje de scripting embebido, +como lenguaje de programación general. Puede ser utilizado también como una +biblioteca portable de C, incluso en casos donde no se requieren capacidades +de scripting, ya que provee de estructuras de datos tales como cadenas (*string*) +de caracteres dinámicas, listas y tablas hash. La biblioteca de C también +provee funcionalidad portable para cargar bibliotecas dinámicas, formato de +cadenas y conversión de código, operaciones sobre el sistema de ficheros, +operaciones de red y más. Algunas características reseñables de Tcl: + +* Conveniente API de red multiplataforma + +* Sistema de ficheros totalmente virtualizado + +* Canales apilables de E/S + +* Asíncrono hasta el núcleo + +* Corrutinas completas + +* Un modelo de hebras reconocido como robusto y fácil de usar + + +Tcl tiene mucho en común con Lisp pero, en lugar de listas, Tcl utiliza cadenas +de caracteres como moneda de cambio del lenguaje. Todos los valores son cadenas. +Una lista es una cadena con un formato definido, y el cuerpo de un procedimiento +(un script) es también una cadena en lugar de un bloque. Para incrementar el +rendimiento, Tcl cachea internamente representaciones estructuradas de estos +valores. Las rutinas con listas, por ejemplo, operan en la representación interna +en caché, y Tcl se ocupa de actualizar la representación en cadenas si es realmente +necesario en el script. El diseño *copy-on-write* de Tcl permite a los autores +de scripts mover grandes volúmenes de datos sin incurrir en el consumo adicional +de memoria. Los procedimientos son automáticamente compilados (*byte-compiled*) +a no ser que utilicen rutinas dinámicas como "uplevel", "upvar" o "trace". + +Programar en Tcl es un placer. Le resultará atractivo a hackers que encuentren +atractivo Lisp, Forth o Smalltalk, y a ingenieros y científicos que simplemente +quieren ponerse a trabajar con una herramienta que se doblega a su voluntad. La +disciplina de exponer toda la funcionalidad programática como rutinas, incluyendo +cosas como iteraciones y operaciones matemáticas que normalmente están en la +sintaxis de otros lenguajes, permitiendo fundirse en el fondo de cualquier +funcionalidad específica del dominio que necesita un proyecto. Su sintaxis, +incluso más simple que la de lisp, simplemente se quita de en medio. + + + +```tcl +#! /bin/env tclsh + +############################################################################### +## 1. Directrices +############################################################################### + +# ¡Tcl no es ni Sh ni C! Es necesario decirlo porque el entrecomillado estándar +# de shell casi funciona en Tcl, y es común que la gente empiece con Tcl e +# intente utilizar sintaxis de otros lenguajes. Funciona al principio, pero +# rápidamente conduce a frustración cuando los scripts se vuelven más complejos. + +# Las llaves son un mecanismo de entrecomillado, no de sintaxis para la construcción +# de bloques de código o listas. Tcl no tiene ninguna de ellas. Las llaves se +# usan para escapar caracteres especiales, lo que las hace apropiadas para +# entrecomillar cuerpos de procedimientos y cadenas que deberían ser interpretadas +# como listas. + + +############################################################################### +## 2. Sintaxis +############################################################################### + +# Un script consiste en comandos delimitados por saltos de línea o puntos y coma. +# Cada comando es una llamada a una rutina. La primera palabra es el nombre de +# la rutina a llamar, y las siguientes palabras son argumentos de la rutina. +# Las palabras están delimitadas por espacios. Puesto que cada argumento es una +# palabra en el comando, y una cadena de caracteres, puede no ser entrecomillada: +set part1 Sal +set part2 ut; set part3 ations + + +# el símbolo del dólar introduce la sustitución de variables: +set greeting $part1$part2$part3 + + +# Cuando "set"recibe sólamente el nombre de una variable, devuelve su valor: +set part3 ;# Returns the value of the variable. + + +# Los corchetes delimitan un script que será evaluado y sustituido por su resultado: +set greeting $part1$part2[set part3] + + +# Un script incrustado puede estar compuesto de múltiples comandos, el último de +# los cuales devuelve el resultado de la sustitución: +set greeting $greeting[ + incr i + incr i + incr i +] +puts $greeting ;# La salida es "Salutations3" + +# Cada palabra en un comando es una cadena, incluyendo el nombre de la rutina, +# así que se pueden utilizar sustituciones allí también. Dada esta asignación +# de variable, + +set action pu + +# los siguientes tres comandos son equivalentes: +puts $greeting +${action}ts $greeting +[set action]ts $greeting + + +# La barra invertida suprime el significado especial de los caracteres: +set amount \$16.42 + + +# La barra invertida añade significado especial a ciertos caracteres: +puts lots\nof\n\n\n\n\n\nnewlines + + +# Una palabra encerrada entre llaves no está sujeta a interpretación especial o +# sustitución, excepto que una barra invertida antes de una llave no cuenta al +# buscar la llave de cierre: +set somevar { + This is a literal $ sign, and this \} escaped + brace remains uninterpreted +} + + +# En una palabra delimitada por comillas dobles, los espacios pierden su significado +# especial: +set name Neo +set greeting "Hello, $name" + + +# Un nombre de variable puede ser cualquier cadena: +set {first name} New + + +# La forma de sustitución de variables utilizando llaves permite nombres de +# variable más complejos: +set greeting "Hello, ${first name}" + + +# "set" puede utilizarse siempre en lugar de la sustitución de variables, y permite +# utilizar cualquier nombre de variable: +set greeting "Hello, [set {first name}]" + + +# Para desempaquetar una lista en un el comando, se utiliza el operador de expansión, +# "{*}". Estos dos comandos son equivalentes: +set name Neo +set {*}{name Neo} + + +# Un array es una variable especial que sirve como contenedor de otras variables. +set person(name) Neo +set person(destiny) {The One} +set greeting "Hello, $person(name)" + + +# "variable" se puede utilizar para declarar o asignar variables. Al contrario +# que "set", que utiliza el espacio de nombres global y el actual para resolver +# un nombre de variable, "variable" usa solamente el actual: +variable name New + + +# "namespace eval" crea un nuevo espacio de nombres en caso de no existir. +# Un espacio de nombres puede contener tanto rutinas como variables: +namespace eval people { + namespace eval person1 { + variable name Neo + } +} + + +# Use dos o más ":" para delimitar componentes del espacio de nombres en nombres +# de variables: +namespace eval people { + set greeting "Hello $person1::name" +} + +# Dos o más ":" también delimitan componentes del espacio de nombres en nombres +# de rutinas: +proc people::person1::speak {} { + puts {I am The One.} +} + +# Nombres completos comienzan con dos ":": +set greeting "Hello $::people::person1::name" + + + +############################################################################### +## 3. No más sintaxis +############################################################################### + +# El resto de funcionalidades se implementa mediante rutinas. Desde este punto, +# no hay nueva sintaxis. Todo lo que queda para aprender Tcl es acerca del +# comportamiento de rutinas individuales y el significado que asignan a sus +# argumentos. + + + +############################################################################### +## 4. Variables y espacios de nombres +############################################################################### + +# Cada variable y cada rutina están asociadas a algún espacio de nombres + +# Para terminar con un intérprete inútil, sólo hay que eliminar el espacio de +# nombres global. No es algo muy útil, pero sirve para ilustrar la naturaleza +# de Tcl. El nombre del espacio de nombres global es en realidad la cadena +# vacía, pero la única forma de representarlo es como un nombre completo. Para +# probarlo, se puede usar esta rutina. +proc delete_global_namespace {} { + namespace delete :: +} + +# Como "set" siempre mantiene su vista en los espacios de nombres global y actual, +# es más seguro utilizar "variable" para declarar o asignar un valor a una +# variable. Si una variable llamada "nombre" ya existe en el espacio de nombres +# global, usar "set" asignará un valor a la variable local en lugar de a la +# variable del espacio de nombres actual, mientras que "variable" opera en el +# espacio de nombres actual solamente. +namespace eval people { + namespace eval person1 { + variable name Neo + } +} + +# Una vez que una variable es declarada en un espacio de nombres, [set] la vé +# en lugar de una variable de idéntico nombre en el espacio de nombres global: +namespace eval people { + namespace eval person1 { + variable name + set name Neo + } +} + +# En cambio, si "set" tiene que crear una nueva variable, siempre lo hace en el +# espacio de nombres actual: +unset name +namespace eval people { + namespace eval person1 { + set name neo + } + +} +set people::person1::name + + +# Un nombre absoluto siempre comienza con el nombre del espacio de nombres global +# (cadena vacía), seguido de dos ":": +set ::people::person1::name Neo + + +# En el interior de un procedimiento, la variable enlaza una variable en el espacio +# de nombres actual en el ámbito local: +namespace eval people::person1 { + proc fly {} { + variable name + puts "$name is flying!" + } +} + + + + +############################################################################### +## 4. Rutinas incorporadas +############################################################################### + +# Las operaciones matemáticas se pueden hacer con "expr": +set a 3 +set b 4 +set c [expr {$a + $b}] + +# Como "expr" realiza sustituciones de variables por sí mismo, es necesario +# poner la expresión entre llaves para prevenir a Tcl sustituir las variables +# primero. Ver "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions" para más +# detalles. + + +# "expr" entiende sustitución de variables y scripts: +set c [expr {$a + [set b]}] + + +# "expr" provee de un conjunto de funciones matemáticas: +set c [expr {pow($a,$b)}] + + +# Los operadores matemáticos están disponibles como rutinas en el espacio de +# nombres ::tcl::mathop +::tcl::mathop::+ 5 3 + +# Las rutinas pueden ser importadas desde otros espacios de nombres: +namespace import ::tcl::mathop::+ +set result [+ 5 3] + + +# Los valores no numéricos deben ser entrecomillados, y los operadores como "eq" +# pueden utilizarse para restringir la operación a una comparación de cadenas: +set name Neo +expr {{Bob} eq $name} + +# Los operadores generales recurren a la comparación de cadenas si una operación +# numérica no es factible. +expr {{Bob} == $name} + + +# "proc" crea nuevas rutinas: +proc greet name { + return "Hello, $name!" +} + +# Se pueden especificar múltiples parámetros: +proc greet {greeting name} { + return "$greeting, $name!" +} + + +# Como se dijo antes, las llaves no construyen un bloque de código. Cada valor, +# incluso el tercer argumento de "proc", es una cadena. El comando anterior +# puede ser reescrito sin usar llaves: +proc greet greeting\ name return\ \"\$greeting,\ \$name!\" + + + +# Cuando el último parámetro es el valor literal "args", todos los argumentos +# extra pasados a la rutina son recogidos en una lista y asignado a "args": +proc fold {cmd first args} { + foreach arg $args { + set first [$cmd $first $arg] + } + return $first +} +fold ::tcl::mathop::* 5 3 3 ;# -> 45 + + +# La ejecución condicional se implementa como una rutina: +if {3 > 4} { + puts {This will never happen} +} elseif {4 > 4} { + puts {This will also never happen} +} else { + puts {This will always happen} +} + + +# Los bucles se implementan como rutinas. Los primer y tercer argumentos de "for" +# son tratados como scripts, mientras que el segundo lo es como una expresión: +set res 0 +for {set i 0} {$i < 10} {incr i} { + set res [expr {$res + $i}] +} +unset res + + +# El primer argumento de "while" se trata también como una expresión: +set i 0 +while {$i < 10} { + incr i 2 +} + + +# Una lista es una cadena, y los elementos de la lista se delimitan con espacios +# en blanco: +set amounts 10\ 33\ 18 +set amount [lindex $amounts 1] + +# El espacio en blanco dentro de una lista debe ser entrecomillado: +set inventory {"item 1" item\ 2 {item 3}} + + +# Generalmente, es mejor idea usar rutinas de listas al modificarlas: +lappend inventory {item 1} {item 2} {item 3} + + +# Las llaves y barras invertidas pueden utilizarse para formatear valores más +# complejos en una lista. Una lista parece un script, excepto en que el carácter +# de nueva línea y el ":" pierden su significado especial, y no hay sustitución +# de variable o scripts. Esta característica hace Tcl homoicónico. Hay tres +# elementos en la siguiente lista: +set values { + + one\ two + + {three four} + + five\{six + +} + + +# Como, al igual que todos los valores, una lista es una cadena, operaciones de +# cadenas pueden ser realizadas sobre ellas, corriendo el riesgo de corromper +# el formato de la lista: +set values {one two three four} +set values [string map {two \{} $values] ;# $values is no-longer a \ + properly-formatted list + + +# La forma segura de conseguir una lista debidamente formateada es utilizando +# las rutinas propias de lista: +set values [list one \{ three four] +lappend values { } ;# add a single space as an item in the list + + +# Se puede utilizar "eval" para evaluar un valor como un script: +eval { + set name Neo + set greeting "Hello, $name" +} + + +# Una lista siempre puede ser pasada a "eval" como un script compuesto de un único +# comando: +eval {set name Neo} +eval [list set greeting "Hello, $name"] + + +# Por lo tanto, cuando se utiliza "eval", use "list" para construir el comando +# deseado: +set command {set name} +lappend command {Archibald Sorbisol} +eval $command + + +# Un error común es no usar funciones de listas al construir un comando: +set command {set name} +append command { Archibald Sorbisol} +try { + eval $command ;# El error es que "set" tiene demasiados argumentos en \ + {set name Archibald Sorbisol} +} on error {result eoptions} { + puts [list {received an error} $result] +} + +# Este error puede ocurrir fácilmente con "subst": + +set replacement {Archibald Sorbisol} +set command {set name $replacement} +set command [subst $command] +try { + eval $command ;# El mismo error que antes: demasiados argumentos a "set" en \ + {set name Archibald Sorbisol} +} trap {TCL WRONGARGS} {result options} { + puts [list {received another error} $result] +} + + +# "list" formatea correctamente un valor para su sustitución: +set replacement [list {Archibald Sorbisol}] +set command {set name $replacement} +set command [subst $command] +eval $command + + +# "list" se utiliza normalmente para formatear valores para su sustitución en +# scripts: Hay muchos ejemplos de esto más abajo. + + +# "apply" evalúa una lista de dos elementos como una rutina: +set cmd {{greeting name} { + return "$greeting, $name!" +}} +apply $cmd Whaddup Neo + +# Un tercer elemento puede ser utilizado para especificar el espacio de nombres +# donde aplicar la rutina: +set cmd [list {greeting name} { + return "$greeting, $name!" +} [namespace current]] +apply $cmd Whaddup Neo + + +# "uplevel" evalúa un script en un nivel superior de la pila de llamadas: +proc greet {} { + uplevel {puts "$greeting, $name"} +} + +proc set_double {varname value} { + if {[string is double $value]} { + uplevel [list variable $varname $value] + } else { + error [list {not a double} $value] + } +} + + +# "upvar" enlaza una variable en el nivel actual de la pila de llamadas a una +# variable en un nivel superior: +proc set_double {varname value} { + if {[string is double $value]} { + upvar 1 $varname var + set var $value + } else { + error [list {not a double} $value] + } +} + + +# Deshacerse de la rutina "while" incorporada, y utilizar "proc" para definir +# una nueva: +rename ::while {} +# la manipulación se deja como ejercicio: +proc while {condition script} { + if {[uplevel 1 [list expr $condition]]} { + uplevel 1 $script + tailcall [namespace which while] $condition $script + } +} + + +# "coroutine" crea una nueva pila de llamadas, una nueva rutina en la que +# introducir esa pila de llamadas, y luego llama a dicha rutina. "yield" suspende +# la evaluación en esa pila y devuelve el control a la pila que efectúa la llamada. +proc countdown count { + # devuelve algo al creador de la corrutina, efectivamente pausando esta + # pila de llamadas por ahora. + yield [info coroutine] + + while {$count > 1} { + yield [incr count -1] + } + return 0 +} +coroutine countdown1 countdown 3 +coroutine countdown2 countdown 5 +puts [countdown1] ;# -> 2 +puts [countdown2] ;# -> 4 +puts [countdown1] ;# -> 1 +puts [countdown1] ;# -> 0 +catch { + puts [coundown1] ;# -> invalid command name "countdown1" +} cres copts +puts $cres +puts [countdown2] ;# -> 3 + + +# Pilas de corrutinas pueden cederse el control entre sí: + +proc pass {whom args} { + return [yieldto $whom {*}$args] +} + +coroutine a apply {{} { + yield + set result [pass b {please pass the salt}] + puts [list got the $result] + set result [pass b {please pass the pepper}] + puts [list got the $result] +}} + +coroutine b apply {{} { + set request [yield] + while 1 { + set response [pass c $request] + puts [list [info coroutine] is now yielding] + set request [pass a $response] + } +}} + +coroutine c apply {{} { + set request [yield] + while 1 { + if {[string match *salt* $request]} { + set request [pass b salt] + } else { + set request [pass b huh?] + } + } +}} + +# Pon las cosas en marcha +a + + +``` + +## Reference + +[Documentación oficial de Tcl](http://www.tcl.tk/man/tcl/) + +[Tcl Wiki](http://wiki.tcl.tk) + +[Tcl Subreddit](http://www.reddit.com/r/Tcl) -- cgit v1.2.3 From 05dba0fb2447c4969a2a92bdabd7d761bdcb9340 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 00:27:55 -0700 Subject: awk-es created --- es-es/awk-es.html.markdown | 361 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 es-es/awk-es.html.markdown (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown new file mode 100644 index 00000000..7899fcb5 --- /dev/null +++ b/es-es/awk-es.html.markdown @@ -0,0 +1,361 @@ +--- +language: awk +filename: learnawk-es.awk +contributors: + - ["Marshall Mason", "http://github.com/marshallmason"] +translators: + - ["Hugo Guillén-Ramírez", "http://github.com/HugoGuillen"] +lang: es-es +--- + +AWK is a standard tool on every POSIX-compliant UNIX system. It's like a +stripped-down Perl, perfect for text-processing tasks and other scripting +needs. It has a C-like syntax, but without semicolons, manual memory +management, or static typing. It excels at text processing. You can call to it +from a shell script, or you can use it as a stand-alone scripting language. + +Why use AWK instead of Perl? Mostly because AWK is part of UNIX. You can always +count on it, whereas Perl's future is in question. AWK is also easier to read +than Perl. For simple text-processing scripts, particularly ones that read +files line by line and split on delimiters, AWK is probably the right tool for +the job. + +```awk +#!/usr/bin/awk -f + +# Comments are like this + +# AWK programs consist of a collection of patterns and actions. The most +# important pattern is called BEGIN. Actions go into brace blocks. +BEGIN { + + # BEGIN will run at the beginning of the program. It's where you put all + # the preliminary set-up code, before you process any text files. If you + # have no text files, then think of BEGIN as the main entry point. + + # Variables are global. Just set them or use them, no need to declare.. + count = 0 + + # Operators just like in C and friends + a = count + 1 + b = count - 1 + c = count * 1 + d = count / 1 + e = count % 1 # modulus + f = count ^ 1 # exponentiation + + a += 1 + b -= 1 + c *= 1 + d /= 1 + e %= 1 + f ^= 1 + + # Incrementing and decrementing by one + a++ + b-- + + # As a prefix operator, it returns the incremented value + ++a + --b + + # Notice, also, no punctuation such as semicolons to terminate statements + + # Control statements + if (count == 0) + print "Starting with count of 0" + else + print "Huh?" + + # Or you could use the ternary operator + print (count == 0) ? "Starting with count of 0" : "Huh?" + + # Blocks consisting of multiple lines use braces + while (a < 10) { + print "String concatenation is done" " with a series" " of" + " space-separated strings" + print a + + a++ + } + + for (i = 0; i < 10; i++) + print "Good ol' for loop" + + # As for comparisons, they're the standards: + a < b # Less than + a <= b # Less than or equal + a != b # Not equal + a == b # Equal + a > b # Greater than + a >= b # Greater than or equal + + # Logical operators as well + a && b # AND + a || b # OR + + # In addition, there's the super useful regular expression match + if ("foo" ~ "^fo+$") + print "Fooey!" + if ("boo" !~ "^fo+$") + print "Boo!" + + # Arrays + arr[0] = "foo" + arr[1] = "bar" + # Unfortunately, there is no other way to initialize an array. Ya just + # gotta chug through every value line by line like that. + + # You also have associative arrays + assoc["foo"] = "bar" + assoc["bar"] = "baz" + + # And multi-dimensional arrays, with some limitations I won't mention here + multidim[0,0] = "foo" + multidim[0,1] = "bar" + multidim[1,0] = "baz" + multidim[1,1] = "boo" + + # You can test for array membership + if ("foo" in assoc) + print "Fooey!" + + # You can also use the 'in' operator to traverse the keys of an array + for (key in assoc) + print assoc[key] + + # The command line is in a special array called ARGV + for (argnum in ARGV) + print ARGV[argnum] + + # You can remove elements of an array + # This is particularly useful to prevent AWK from assuming the arguments + # are files for it to process + delete ARGV[1] + + # The number of command line arguments is in a variable called ARGC + print ARGC + + # AWK has several built-in functions. They fall into three categories. I'll + # demonstrate each of them in their own functions, defined later. + + return_value = arithmetic_functions(a, b, c) + string_functions() + io_functions() +} + +# Here's how you define a function +function arithmetic_functions(a, b, c, localvar) { + + # Probably the most annoying part of AWK is that there are no local + # variables. Everything is global. For short scripts, this is fine, even + # useful, but for longer scripts, this can be a problem. + + # There is a work-around (ahem, hack). Function arguments are local to the + # function, and AWK allows you to define more function arguments than it + # needs. So just stick local variable in the function declaration, like I + # did above. As a convention, stick in some extra whitespace to distinguish + # between actual function parameters and local variables. In this example, + # a, b, and c are actual parameters, while d is merely a local variable. + + # Now, to demonstrate the arithmetic functions + + # Most AWK implementations have some standard trig functions + localvar = sin(a) + localvar = cos(a) + localvar = atan2(a, b) # arc tangent of b / a + + # And logarithmic stuff + localvar = exp(a) + localvar = log(a) + + # Square root + localvar = sqrt(a) + + # Truncate floating point to integer + localvar = int(5.34) # localvar => 5 + + # Random numbers + srand() # Supply a seed as an argument. By default, it uses the time of day + localvar = rand() # Random number between 0 and 1. + + # Here's how to return a value + return localvar +} + +function string_functions( localvar, arr) { + + # AWK, being a string-processing language, has several string-related + # functions, many of which rely heavily on regular expressions. + + # Search and replace, first instance (sub) or all instances (gsub) + # Both return number of matches replaced + localvar = "fooooobar" + sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar" + gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar" + + # Search for a string that matches a regular expression + # index() does the same thing, but doesn't allow a regular expression + match(localvar, "t") # => 4, since the 't' is the fourth character + + # Split on a delimiter + split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"] + + # Other useful stuff + sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3" + substr("foobar", 2, 3) # => "oob" + substr("foobar", 4) # => "bar" + length("foo") # => 3 + tolower("FOO") # => "foo" + toupper("foo") # => "FOO" +} + +function io_functions( localvar) { + + # You've already seen print + print "Hello world" + + # There's also printf + printf("%s %d %d %d\n", "Testing", 1, 2, 3) + + # AWK doesn't have file handles, per se. It will automatically open a file + # handle for you when you use something that needs one. The string you used + # for this can be treated as a file handle, for purposes of I/O. This makes + # it feel sort of like shell scripting: + + print "foobar" >"/tmp/foobar.txt" + + # Now the string "/tmp/foobar.txt" is a file handle. You can close it: + close("/tmp/foobar.txt") + + # Here's how you run something in the shell + system("echo foobar") # => prints foobar + + # Reads a line from standard input and stores in localvar + getline localvar + + # Reads a line from a pipe + "echo foobar" | getline localvar # localvar => "foobar" + close("echo foobar") + + # Reads a line from a file and stores in localvar + getline localvar <"/tmp/foobar.txt" + close("/tmp/foobar.txt") +} + +# As I said at the beginning, AWK programs consist of a collection of patterns +# and actions. You've already seen the all-important BEGIN pattern. Other +# patterns are used only if you're processing lines from files or standard +# input. +# +# When you pass arguments to AWK, they are treated as file names to process. +# It will process them all, in order. Think of it like an implicit for loop, +# iterating over the lines in these files. these patterns and actions are like +# switch statements inside the loop. + +/^fo+bar$/ { + + # This action will execute for every line that matches the regular + # expression, /^fo+bar$/, and will be skipped for any line that fails to + # match it. Let's just print the line: + + print + + # Whoa, no argument! That's because print has a default argument: $0. + # $0 is the name of the current line being processed. It is created + # automatically for you. + + # You can probably guess there are other $ variables. Every line is + # implicitely split before every action is called, much like the shell + # does. And, like the shell, each field can be access with a dollar sign + + # This will print the second and fourth fields in the line + print $2, $4 + + # AWK automatically defines many other variables to help you inspect and + # process each line. The most important one is NF + + # Prints the number of fields on this line + print NF + + # Print the last field on this line + print $NF +} + +# Every pattern is actually a true/false test. The regular expression in the +# last pattern is also a true/false test, but part of it was hidden. If you +# don't give it a string to test, it will assume $0, the line that it's +# currently processing. Thus, the complete version of it is this: + +$0 ~ /^fo+bar$/ { + print "Equivalent to the last pattern" +} + +a > 0 { + # This will execute once for each line, as long as a is positive +} + +# You get the idea. Processing text files, reading in a line at a time, and +# doing something with it, particularly splitting on a delimiter, is so common +# in UNIX that AWK is a scripting language that does all of it for you, without +# you needing to ask. All you have to do is write the patterns and actions +# based on what you expect of the input, and what you want to do with it. + +# Here's a quick example of a simple script, the sort of thing AWK is perfect +# for. It will read a name from standard input and then will print the average +# age of everyone with that first name. Let's say you supply as an argument the +# name of a this data file: +# +# Bob Jones 32 +# Jane Doe 22 +# Steve Stevens 83 +# Bob Smith 29 +# Bob Barker 72 +# +# Here's the script: + +BEGIN { + + # First, ask the user for the name + print "What name would you like the average age for?" + + # Get a line from standard input, not from files on the command line + getline name <"/dev/stdin" +} + +# Now, match every line whose first field is the given name +$1 == name { + + # Inside here, we have access to a number of useful variables, already + # pre-loaded for us: + # $0 is the entire line + # $3 is the third field, the age, which is what we're interested in here + # NF is the number of fields, which should be 3 + # NR is the number of records (lines) seen so far + # FILENAME is the name of the file being processed + # FS is the field separator being used, which is " " here + # ...etc. There are plenty more, documented in the man page. + + # Keep track of a running total and how many lines matched + sum += $3 + nlines++ +} + +# Another special pattern is called END. It will run after processing all the +# text files. Unlike BEGIN, it will only run if you've given it input to +# process. It will run after all the files have been read and processed +# according to the rules and actions you've provided. The purpose of it is +# usually to output some kind of final report, or do something with the +# aggregate of the data you've accumulated over the course of the script. + +END { + if (nlines) + print "The average age for " name " is " sum / nlines +} + +``` +Further Reading: + +* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html) +* [Awk man page](https://linux.die.net/man/1/awk) +* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems. -- cgit v1.2.3 From 0f90bc5e5c5a7eca4d140d00d22add2f0c36c57f Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 00:40:58 -0700 Subject: awk-es intro --- es-es/awk-es.html.markdown | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index 7899fcb5..3b93e03d 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -8,17 +8,17 @@ translators: lang: es-es --- -AWK is a standard tool on every POSIX-compliant UNIX system. It's like a -stripped-down Perl, perfect for text-processing tasks and other scripting -needs. It has a C-like syntax, but without semicolons, manual memory -management, or static typing. It excels at text processing. You can call to it -from a shell script, or you can use it as a stand-alone scripting language. - -Why use AWK instead of Perl? Mostly because AWK is part of UNIX. You can always -count on it, whereas Perl's future is in question. AWK is also easier to read -than Perl. For simple text-processing scripts, particularly ones that read -files line by line and split on delimiters, AWK is probably the right tool for -the job. +AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX. +Es como un Perl restringido, perfecto para tareas de procesamiento de texto y +otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin +puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo +desde un script de shell o usarlo como un lenguaje stand-alone para scripting. + +¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX. +Siempre puedes contar con él, mientras que el futuro de Perl está en duda. AWK +es más fácil de leer que Perl. Para scripts sencillos de procesamiento de texto, +particularmente si es para leer archivos línea a línea y dividir por +delimitadores, probablemente AWK es la herramienta correcta para el trabajo. ```awk #!/usr/bin/awk -f -- cgit v1.2.3 From a276468f2989dbb61eb16428d163c0c4333e25bf Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 01:16:11 -0700 Subject: awk-es script start --- es-es/awk-es.html.markdown | 45 +++++++++++++++++++++++---------------------- 1 file changed, 23 insertions(+), 22 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index 3b93e03d..ef0a975f 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -23,26 +23,27 @@ delimitadores, probablemente AWK es la herramienta correcta para el trabajo. ```awk #!/usr/bin/awk -f -# Comments are like this +# Los comentarios tienen este aspecto. + +# Los programas AWK son una colección de patrones y acciones. El patrón más +# importante es BEGIN. Las acciones van en bloques delimitados por llaves. -# AWK programs consist of a collection of patterns and actions. The most -# important pattern is called BEGIN. Actions go into brace blocks. BEGIN { - # BEGIN will run at the beginning of the program. It's where you put all - # the preliminary set-up code, before you process any text files. If you - # have no text files, then think of BEGIN as the main entry point. + # BEGIN correrá al inicio del programa. Es donde pones todo el código + # preliminar antes de procesar los archivos de texto. Si no tienes archivos + # de texto, piensa en BEGIN como el punto de entrada principal del script. - # Variables are global. Just set them or use them, no need to declare.. + # Las variables son globales. Asígnalas o úsalas sin declararlas. count = 0 - # Operators just like in C and friends + # Los operadores son justo como en C (y amigos). a = count + 1 b = count - 1 c = count * 1 d = count / 1 - e = count % 1 # modulus - f = count ^ 1 # exponentiation + e = count % 1 # módulo + f = count ^ 1 # exponenciación a += 1 b -= 1 @@ -51,36 +52,36 @@ BEGIN { e %= 1 f ^= 1 - # Incrementing and decrementing by one + # Incremento y decremento en uno a++ b-- - # As a prefix operator, it returns the incremented value + # Como un operador prefijo, regresa el valor modificado ++a --b - # Notice, also, no punctuation such as semicolons to terminate statements + # Nota que no hay puntación para terminar las instrucciones - # Control statements + # Instrucciones de control if (count == 0) - print "Starting with count of 0" + print "Iniciando count en 0" else - print "Huh?" + print "Eh?" - # Or you could use the ternary operator - print (count == 0) ? "Starting with count of 0" : "Huh?" + # O puedes usar el operador ternario + print (count == 0) ? "Iniciando count en 0" : "Eh?" - # Blocks consisting of multiple lines use braces + # Bloques formados por múltiples líneas usan llaves while (a < 10) { - print "String concatenation is done" " with a series" " of" - " space-separated strings" + print "La concatenación de strings se hace " " con series " " de" + " strings separados por espacios" print a a++ } for (i = 0; i < 10; i++) - print "Good ol' for loop" + print "El viejo confiable ciclo for" # As for comparisons, they're the standards: a < b # Less than -- cgit v1.2.3 From fed2f2a19e3a5f36c666bc46063dd90f535b311c Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 01:21:00 -0700 Subject: awk-es script concatenate --- es-es/awk-es.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index ef0a975f..628bf9ae 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -73,8 +73,8 @@ BEGIN { # Bloques formados por múltiples líneas usan llaves while (a < 10) { - print "La concatenación de strings se hace " " con series " " de" - " strings separados por espacios" + print "La concatenación de strings se hace " " con series " + print " de" " strings separados por espacios" print a a++ -- cgit v1.2.3 From 915a4b21f7f996e2c94e5e2d810e749b2cdaa570 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 02:02:03 -0700 Subject: awk-es script trig funcs --- es-es/awk-es.html.markdown | 88 ++++++++++++++++++++++++---------------------- 1 file changed, 45 insertions(+), 43 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index 628bf9ae..75b5d946 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -83,19 +83,19 @@ BEGIN { for (i = 0; i < 10; i++) print "El viejo confiable ciclo for" - # As for comparisons, they're the standards: - a < b # Less than - a <= b # Less than or equal - a != b # Not equal - a == b # Equal - a > b # Greater than - a >= b # Greater than or equal - - # Logical operators as well + # Los operaciones de comparación son estándar... + a < b # Menor que + a <= b # Menor o igual que + a != b # No igual + a == b # Igual + a > b # Mayor que + a >= b # Mayor o igual que + + # ...así como los operadores lógicos a && b # AND a || b # OR - # In addition, there's the super useful regular expression match + # Además están las expresiones regulares if ("foo" ~ "^fo+$") print "Fooey!" if ("boo" !~ "^fo+$") @@ -104,83 +104,85 @@ BEGIN { # Arrays arr[0] = "foo" arr[1] = "bar" - # Unfortunately, there is no other way to initialize an array. Ya just - # gotta chug through every value line by line like that. + # Desafortunadamente no hay otra manera de inicializar un array. + # Tienes que inicializar cada posición del array. - # You also have associative arrays + # También hay arrays asociativos assoc["foo"] = "bar" assoc["bar"] = "baz" - # And multi-dimensional arrays, with some limitations I won't mention here + # Y arrays multidimensionales con limitaciones que no mencionaré aquí multidim[0,0] = "foo" multidim[0,1] = "bar" multidim[1,0] = "baz" multidim[1,1] = "boo" - # You can test for array membership + # Puedes probar pertenencia a un array if ("foo" in assoc) print "Fooey!" - # You can also use the 'in' operator to traverse the keys of an array + # También puedes usar el operador 'in' para iterar las claves de un array for (key in assoc) print assoc[key] - # The command line is in a special array called ARGV + # La terminal es un array especial llamado ARGV for (argnum in ARGV) print ARGV[argnum] - # You can remove elements of an array - # This is particularly useful to prevent AWK from assuming the arguments - # are files for it to process + # Puedes eliminar elementos de un array. + # Esto es útil para prevenir que AWK suponga que algunos argumentos + # son archivos por procesar. delete ARGV[1] - # The number of command line arguments is in a variable called ARGC + # El número de argumentos de la terminal está en la variable ARGC print ARGC - # AWK has several built-in functions. They fall into three categories. I'll - # demonstrate each of them in their own functions, defined later. + # AWK tiene tres categorías de funciones incluidas. + # Demostraré esas funciones posteriormente. return_value = arithmetic_functions(a, b, c) string_functions() io_functions() } -# Here's how you define a function +# Así se define una función function arithmetic_functions(a, b, c, localvar) { - # Probably the most annoying part of AWK is that there are no local - # variables. Everything is global. For short scripts, this is fine, even - # useful, but for longer scripts, this can be a problem. + # Probablemente la parte más molesta de AWK es que no hay variables locales + # Todo es global. No es problema en scripts pequeños, pero sí para + # scripts más grandes. - # There is a work-around (ahem, hack). Function arguments are local to the - # function, and AWK allows you to define more function arguments than it - # needs. So just stick local variable in the function declaration, like I - # did above. As a convention, stick in some extra whitespace to distinguish - # between actual function parameters and local variables. In this example, - # a, b, and c are actual parameters, while d is merely a local variable. + # Hay un work-around (mmm... hack). Los argumentos de las funciones son + # locales para la función, y AWK permite definir más argumentos de función + # de los que necesita, por lo que define las variables locales en la + # declaración como en la función de arriba. Como convención, agrega + # espacios en blanco para distinguir los parámetros de la función de las + # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una + # variable local. - # Now, to demonstrate the arithmetic functions + # Ahora, a demostrar las funciones aritméticas - # Most AWK implementations have some standard trig functions + # La mayoría de las implementaciones de AWK tienen funciones + # trigonométricas estándar localvar = sin(a) localvar = cos(a) - localvar = atan2(a, b) # arc tangent of b / a + localvar = atan2(a, b) # arcotangente de b / a - # And logarithmic stuff + # Y cosas logarítmicas localvar = exp(a) localvar = log(a) - # Square root + # Raíz cuadrada localvar = sqrt(a) - # Truncate floating point to integer + # Trucar un flotante a entero localvar = int(5.34) # localvar => 5 - # Random numbers - srand() # Supply a seed as an argument. By default, it uses the time of day - localvar = rand() # Random number between 0 and 1. + # Números aleatorios + srand() # La semilla es el argumento. Por defecto usa el tiempo del sistema + localvar = rand() # Número aleatorio entre 0 y 1. - # Here's how to return a value + # Y aquí se regresa el valor return localvar } -- cgit v1.2.3 From 3d3ab700d17a701e2363047c0c9c54397a99d700 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 11:33:24 -0700 Subject: string funcs --- es-es/awk-es.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index 75b5d946..3e319267 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -188,11 +188,11 @@ function arithmetic_functions(a, b, c, localvar) { function string_functions( localvar, arr) { - # AWK, being a string-processing language, has several string-related - # functions, many of which rely heavily on regular expressions. + # AWK tiene algunas funciones para procesamiento de strings, + # y muchas dependen fuertemente en expresiones regulares. - # Search and replace, first instance (sub) or all instances (gsub) - # Both return number of matches replaced + # Buscar y remplazar, primer instancia (sub) o todas las instancias (gsub) + # Ambas regresan el número de matches remplazados. localvar = "fooooobar" sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar" gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar" -- cgit v1.2.3 From 1a2d09eb811d23d5c805562c6e910e338e39b0d9 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 11:50:55 -0700 Subject: string patterns --- es-es/awk-es.html.markdown | 91 +++++++++++++++++++++++----------------------- 1 file changed, 45 insertions(+), 46 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index 3e319267..8a1be9dc 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -197,14 +197,14 @@ function string_functions( localvar, arr) { sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar" gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar" - # Search for a string that matches a regular expression - # index() does the same thing, but doesn't allow a regular expression - match(localvar, "t") # => 4, since the 't' is the fourth character + # Buscar una cadena que haga match con una expresión regular + # index() hace lo mismo, pero no permite expresiones regulares + match(localvar, "t") # => 4, dado que 't' es el cuarto caracter - # Split on a delimiter + # Separar con base en un delimitador split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"] - # Other useful stuff + # Otras funciones útiles sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3" substr("foobar", 2, 3) # => "oob" substr("foobar", 4) # => "bar" @@ -215,87 +215,86 @@ function string_functions( localvar, arr) { function io_functions( localvar) { - # You've already seen print + # Ya has visto print print "Hello world" - # There's also printf + # También hay printf printf("%s %d %d %d\n", "Testing", 1, 2, 3) - # AWK doesn't have file handles, per se. It will automatically open a file - # handle for you when you use something that needs one. The string you used - # for this can be treated as a file handle, for purposes of I/O. This makes - # it feel sort of like shell scripting: + # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un + # handle de archivo cuando use algo que necesite uno. El string que usaste + # para esto puede ser tratada como un handle de archivo para propósitos de I/O. + # Esto lo hace similar al scripting de shell: print "foobar" >"/tmp/foobar.txt" - # Now the string "/tmp/foobar.txt" is a file handle. You can close it: + # Ahora el string "/tmp/foobar.txt" es un handle. Puedes cerrarlo: close("/tmp/foobar.txt") - # Here's how you run something in the shell - system("echo foobar") # => prints foobar + # Aquí está como correr algo en el shell + system("echo foobar") # => muestra foobar - # Reads a line from standard input and stores in localvar + # Lee una línea de la entrada estándar (stdin) y lo guarda en localvar getline localvar - # Reads a line from a pipe + # Lee una línea desde un pipe "echo foobar" | getline localvar # localvar => "foobar" close("echo foobar") - # Reads a line from a file and stores in localvar + # Lee una línea desde un archivo y la guarda en localvar getline localvar <"/tmp/foobar.txt" close("/tmp/foobar.txt") } -# As I said at the beginning, AWK programs consist of a collection of patterns -# and actions. You've already seen the all-important BEGIN pattern. Other -# patterns are used only if you're processing lines from files or standard -# input. -# -# When you pass arguments to AWK, they are treated as file names to process. -# It will process them all, in order. Think of it like an implicit for loop, -# iterating over the lines in these files. these patterns and actions are like -# switch statements inside the loop. +# Como dije al inicio, los programas en AWK son una colección de patrones y +# acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás +# procesando líneas desde archivos o stdin. + +# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a +# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for +# implícito, iterando sobre las líneas de estos archivos. Estos patrones y +# acciones son como instrucciones switch dentro del ciclo. /^fo+bar$/ { - # This action will execute for every line that matches the regular - # expression, /^fo+bar$/, and will be skipped for any line that fails to - # match it. Let's just print the line: + # Esta acción se ejecutará por cada línea que haga match con la expresión + # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match. + # Vamos a sólo mostrar la línea: print - # Whoa, no argument! That's because print has a default argument: $0. - # $0 is the name of the current line being processed. It is created - # automatically for you. + # ¡Wow, sin argumento! Eso es porque print tiene uno por defecto: $0. + # $0 es el nombre de la línea actual que se está procesando. + # Se crea automáticamente para ti. - # You can probably guess there are other $ variables. Every line is - # implicitely split before every action is called, much like the shell - # does. And, like the shell, each field can be access with a dollar sign + # Probablemente puedas adivinar que hay otras variables $. Cada línea es + # separada implícitamente antes de que se llame cada acción, justo como lo + # hace shell. Y, como shell, cada campo puede ser accesado con $. - # This will print the second and fourth fields in the line + # Esto mostrará el segundo y cuarto campos de la línea print $2, $4 - # AWK automatically defines many other variables to help you inspect and - # process each line. The most important one is NF + # AWK automáticamente define muchas otras variables que te ayudan a + # inspeccionar y procesar cada línea. La más importante es NF - # Prints the number of fields on this line + # Imprime el número de campos de esta línea print NF - # Print the last field on this line + # Imprime el último campo de esta línea print $NF } -# Every pattern is actually a true/false test. The regular expression in the -# last pattern is also a true/false test, but part of it was hidden. If you -# don't give it a string to test, it will assume $0, the line that it's -# currently processing. Thus, the complete version of it is this: +# Cada patrón es realmente un prueba de verdadero/falso. La expresión regular +# en el último patrón también es una prueba verdadero/falso, pero parte de eso +# estaba oculto. Si no le das un string a la prueba, supondrá $0, la línea que +# se está procesando. La versión completa de esto es: $0 ~ /^fo+bar$/ { - print "Equivalent to the last pattern" + print "Equivalente al último patrón" } a > 0 { - # This will execute once for each line, as long as a is positive + # Esto se ejecutará una vez por línea, mientras a sea positivo } # You get the idea. Processing text files, reading in a line at a time, and -- cgit v1.2.3 From bad152cde0ca4561ba7ee0adb1f197139bd76867 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 12:08:09 -0700 Subject: example --- es-es/awk-es.html.markdown | 74 +++++++++++++++++++++++----------------------- 1 file changed, 37 insertions(+), 37 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index 8a1be9dc..f3d7b841 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -297,16 +297,16 @@ a > 0 { # Esto se ejecutará una vez por línea, mientras a sea positivo } -# You get the idea. Processing text files, reading in a line at a time, and -# doing something with it, particularly splitting on a delimiter, is so common -# in UNIX that AWK is a scripting language that does all of it for you, without -# you needing to ask. All you have to do is write the patterns and actions -# based on what you expect of the input, and what you want to do with it. - -# Here's a quick example of a simple script, the sort of thing AWK is perfect -# for. It will read a name from standard input and then will print the average -# age of everyone with that first name. Let's say you supply as an argument the -# name of a this data file: +# Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez, +# y haciendo algo con ella, particularmente separando en un deliminator, es tan +# común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti +# sin que tengas que pedirlo. Basta con escribir los patrones y acciones +# basados en lo que esperas de la entrada y lo quieras quieras hacer con ella. + +# Aquí está un ejemplo de un script simple, para lo que AWK es perfecto. +# El script lee un nombre de stdin y muestra el promedio de edad para todos los +# que tengan ese nombre. Digamos que como argumento pasamos el nombre de un +# archivo con este contenido: # # Bob Jones 32 # Jane Doe 22 @@ -314,50 +314,50 @@ a > 0 { # Bob Smith 29 # Bob Barker 72 # -# Here's the script: +# Éste es el script: BEGIN { - # First, ask the user for the name - print "What name would you like the average age for?" + # Primero, pedir al usuario el nombre + print "¿Para qué nombre quieres el promedio de edad?" - # Get a line from standard input, not from files on the command line + # Recuperar una línea de stdin, no de archivos en la línea de comandos getline name <"/dev/stdin" } -# Now, match every line whose first field is the given name +# Ahora, hacer match con cada línea cuyo primer campo es el nombre dado $1 == name { - # Inside here, we have access to a number of useful variables, already - # pre-loaded for us: - # $0 is the entire line - # $3 is the third field, the age, which is what we're interested in here - # NF is the number of fields, which should be 3 - # NR is the number of records (lines) seen so far - # FILENAME is the name of the file being processed - # FS is the field separator being used, which is " " here - # ...etc. There are plenty more, documented in the man page. - - # Keep track of a running total and how many lines matched + # Aquí dentro tenemos acceso a variables útiles precargadas: + # $0 es toda la línea + # $3 es el tercer campo, la edad, que es lo que nos interesa + # NF es el número de campos, que debe ser 3 + # NR es el número de registros (líneas) vistos hasta ahora + # FILENAME es el nombre del archivo que está siendo procesado + # FS es el campo separador, " " en este caso + # Y muchas más que puedes conocer ejecutando 'man awk' en la terminal. + + # Llevar el registro de la suma y cuantas líneas han hecho match. sum += $3 nlines++ } -# Another special pattern is called END. It will run after processing all the -# text files. Unlike BEGIN, it will only run if you've given it input to -# process. It will run after all the files have been read and processed -# according to the rules and actions you've provided. The purpose of it is -# usually to output some kind of final report, or do something with the -# aggregate of the data you've accumulated over the course of the script. +# Otro patrón especial es END. Va a ejecutarse después de procesar todos los +# archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una +# entrada a procesar. Se ejecutará después de que todos los archivos hayan sido +# leídos y procesados según las reglas y acciones que programaste. El propósito +# es usualmente para mostrar un reporte final, o hacer algo con el agregado de +# los datos que has acumulado durante la ejecución del script. END { if (nlines) - print "The average age for " name " is " sum / nlines + print "La edad promedio para " name " es " sum / nlines } ``` -Further Reading: +Más información: -* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html) -* [Awk man page](https://linux.die.net/man/1/awk) -* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems. +* [Tutorial de AWK](http://www.grymoire.com/Unix/Awk.html) +* [Página man de AWK](https://linux.die.net/man/1/awk) +* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html) +GNU Awk se encuentra en la mayoría de los sistemas Linux. -- cgit v1.2.3 From 1bfd17ee7da8bd5e1446b056e266fb4807219505 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 12:09:52 -0700 Subject: example 2 --- es-es/awk-es.html.markdown | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'es-es') diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown index f3d7b841..307ba817 100644 --- a/es-es/awk-es.html.markdown +++ b/es-es/awk-es.html.markdown @@ -359,5 +359,4 @@ Más información: * [Tutorial de AWK](http://www.grymoire.com/Unix/Awk.html) * [Página man de AWK](https://linux.die.net/man/1/awk) -* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html) -GNU Awk se encuentra en la mayoría de los sistemas Linux. +* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html): GNU Awk se encuentra en la mayoría de los sistemas Linux. -- cgit v1.2.3 From ad2f371471698668a780141a0406d9898d935e84 Mon Sep 17 00:00:00 2001 From: hugo Date: Sat, 15 Jul 2017 12:39:25 -0700 Subject: accurate translations, typos, formatting --- es-es/dynamic-programming-es.html.markdown | 49 ++++++++++++++++-------------- 1 file changed, 26 insertions(+), 23 deletions(-) (limited to 'es-es') diff --git a/es-es/dynamic-programming-es.html.markdown b/es-es/dynamic-programming-es.html.markdown index 11930653..fb49dd99 100644 --- a/es-es/dynamic-programming-es.html.markdown +++ b/es-es/dynamic-programming-es.html.markdown @@ -8,47 +8,50 @@ translators: lang: es-es --- -# programación dinámica +# Programación Dinámica ## Introducción -La programación dinámica es una técnica poderosa usada para resolver una clase particular de problemas como veremos más adelante. La idea es muy simple, si usted ha solucionado un problema con la entrada dada, entonces , guardaremos el resultado para una futura referencia, con el fin de evitar la solución del mismo problema de nuevo. +La programación dinámica es una técnica poderosa usada para resolver una clase particular de problemas como veremos más adelante. +La idea es muy simple: si has solucionado un problema con la entrada dada, entonces, guardaremos el resultado para una futura referencia, con el fin de evitar la solución del mismo problema de nuevo. - -Recuerde siempre!! +Recuerda siempre: "Aquellos que no pueden recordar el pasado están condenados a repetirlo" ## Formas de resolver este tipo de problemas -1.) De arriba hacia abajo : Empezamos resolviendo el problema dado descomponiendolo. Si ves que el problema fue resuelto, entonces retorna la respuesta guardada. si no se ha resuelto, resuélvelo y guarda la respuesta. Esto suele ser fácil pensar y muy intuitivo. Esto se conoce como memorización. +1. *De arriba hacia abajo (Top-Down)* : Empezamos resolviendo el problema dado descomponiendolo. Si ves que el problema fue resuelto, entonces retorna la respuesta guardada. Si no se ha resuelto, resuélvelo y guarda la respuesta. Esto suele ser fácil de pensar y es muy intuitivo. A esto se le conoce como memoización. -2.) De abajo hacia arriba : Analiza el problema y mira el orden en que los subproblemas deben ser resueltos y empieza resolviendo el subproblema más trivial, hacia el problema dado.En este proceso, se garantiza que los subproblemas se resuelven antes de resolver el problema. Esto se conoce como programación dinámica. +2. *De abajo hacia arriba (Bottom-Up)* : Analiza el problema y ve el orden en que los subproblemas deben ser resueltos y empieza resolviendo el subproblema más trivial, hacia el problema dado. En este proceso, se garantiza que los subproblemas se resuelven antes de resolver el problema. Esto se conoce como Programación Dinámica. ## Ejemplo de Programación Dinámica -El problema de la subsecuencia creciente máxima consiste en encontrar la subsecuencia creciente máxima en una secuencia dada . Dada la secuencia S= {a1 , a2 , a3, a4, ............., an-1, an } tenemos que encontrar un subconjunto más largo tal que para todo j y i, j a[j] and LS[i] a[j] and LS[i] Date: Sat, 15 Jul 2017 12:41:50 -0700 Subject: famous problems formatting --- es-es/dynamic-programming-es.html.markdown | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) (limited to 'es-es') diff --git a/es-es/dynamic-programming-es.html.markdown b/es-es/dynamic-programming-es.html.markdown index fb49dd99..e613b722 100644 --- a/es-es/dynamic-programming-es.html.markdown +++ b/es-es/dynamic-programming-es.html.markdown @@ -44,13 +44,10 @@ for i=0 to n-1 ``` ### Algunos problemas famosos de Programación Dinámica (DP). -``` -Algoritmo Floyd Warshall(EN) - [Tutorial y código fuente del programa en C](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code) - -Problema de la Mochila(EN) - [Tutorial y código fuente del programa en C](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem) - -Problema de Subsecuencia Común mas Larga(EN) - [Tutorial y código fuente del programa en C](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence) +- Algoritmo Floyd Warshall(EN) - [Tutorial y código fuente del programa en C](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code) +- Problema de la Mochila(EN) - [Tutorial y código fuente del programa en C](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem) +- Problema de Subsecuencia Común mas Larga(EN) - [Tutorial y código fuente del programa en C](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence) ## Recursos en línea -- cgit v1.2.3 From a2b09ea735866a05b97e6998c360871e7baa295d Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:31:24 +0545 Subject: Add filename(#2832) --- es-es/bf-es.html.markdown | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/bf-es.html.markdown b/es-es/bf-es.html.markdown index c93b8c3a..90c6202f 100644 --- a/es-es/bf-es.html.markdown +++ b/es-es/bf-es.html.markdown @@ -1,5 +1,6 @@ --- -language: bf +language: Brainfuck +filename: brainfuck-es.bf contributors: - ["Prajit Ramachandran", "http://prajitr.github.io/"] - ["Mathias Bynens", "http://mathiasbynens.be/"] -- cgit v1.2.3 From 46876c650192d4095b67fcc855e946a6063af554 Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:32:44 +0545 Subject: Fix yaml-frontmatter(#2832) --- es-es/csharp-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown index ef26d8ce..79c12863 100644 --- a/es-es/csharp-es.html.markdown +++ b/es-es/csharp-es.html.markdown @@ -1,11 +1,11 @@ --- language: c# +filename: LearnCSharp-es.cs contributors: - ["Irfan Charania", "https://github.com/irfancharania"] - ["Max Yankov", "https://github.com/golergka"] translators: - ["Olfran Jiménez", "https://twitter.com/neslux"] -filename: LearnCSharp-es.cs lang: es-es --- -- cgit v1.2.3 From eb5cb39d96b7e8e18ddd9c434c26912cad5ea0aa Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:36:33 +0545 Subject: Fix yaml-frontmatter(#2832) --- es-es/csharp-es.html.markdown | 1 + 1 file changed, 1 insertion(+) (limited to 'es-es') diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown index 79c12863..88d5a5c0 100644 --- a/es-es/csharp-es.html.markdown +++ b/es-es/csharp-es.html.markdown @@ -7,6 +7,7 @@ contributors: translators: - ["Olfran Jiménez", "https://twitter.com/neslux"] lang: es-es + --- C# es un lenguaje orientado a objetos elegante y de tipado seguro que -- cgit v1.2.3 From 447f28e056dc98222aa78fb240a921ddce2fe90a Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:37:26 +0545 Subject: Add language code suffix(#2832) --- es-es/git-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown index 1a8e275a..749365d1 100644 --- a/es-es/git-es.html.markdown +++ b/es-es/git-es.html.markdown @@ -1,11 +1,11 @@ --- category: tool tool: git +filename: LearnGit-es.txt contributors: - ["Jake Prather", "http://github.com/JakeHP"] translator: - ["Raúl Ascencio", "http://rscnt.github.io"] -filename: LearnGit.txt lang: es-es --- -- cgit v1.2.3 From 2a637ca9e1551849468bad57cf36256fb2a30f6a Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:38:06 +0545 Subject: Add language code suffix(#2832) --- es-es/sass-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/sass-es.html.markdown b/es-es/sass-es.html.markdown index 89e56ba5..d130fe8c 100644 --- a/es-es/sass-es.html.markdown +++ b/es-es/sass-es.html.markdown @@ -1,6 +1,6 @@ --- language: sass -filename: learnsass.scss +filename: learnsass-es.scss contributors: - ["Laura Kyle", "https://github.com/LauraNK"] - ["Sean Corrales", "https://github.com/droidenator"] -- cgit v1.2.3 From f2ee5c25a939724afb04d1c2df172ef432bfa131 Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 13:38:52 +0545 Subject: Add language code suffix(#2832) --- es-es/xml-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/xml-es.html.markdown b/es-es/xml-es.html.markdown index 2e9326cf..23831f3b 100644 --- a/es-es/xml-es.html.markdown +++ b/es-es/xml-es.html.markdown @@ -1,6 +1,6 @@ --- language: xml -filename: learnxml.xml +filename: learnxml-es.xml contributors: - ["João Farias", "https://github.com/JoaoGFarias"] translators: -- cgit v1.2.3 From b799575f4443afd562eba82de4cd87bd8297e29f Mon Sep 17 00:00:00 2001 From: Pratik Karki Date: Fri, 25 Aug 2017 14:27:49 +0545 Subject: Fix yaml-frontmatter(#2832) --- es-es/csharp-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown index 88d5a5c0..5d730497 100644 --- a/es-es/csharp-es.html.markdown +++ b/es-es/csharp-es.html.markdown @@ -1,5 +1,5 @@ --- -language: c# +language: C#(C Sharp) filename: LearnCSharp-es.cs contributors: - ["Irfan Charania", "https://github.com/irfancharania"] -- cgit v1.2.3 From 12d0381cf0297d8d9c55b7f72c12fda02cca9b5d Mon Sep 17 00:00:00 2001 From: Abel Salgado Romero Date: Sun, 17 Sep 2017 17:21:51 +0200 Subject: [asciidoc/es-es] adds Spanish translation for AsciiDoc --- es-es/asciidoc-es.html.markdown | 138 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) create mode 100644 es-es/asciidoc-es.html.markdown (limited to 'es-es') diff --git a/es-es/asciidoc-es.html.markdown b/es-es/asciidoc-es.html.markdown new file mode 100644 index 00000000..7ca22172 --- /dev/null +++ b/es-es/asciidoc-es.html.markdown @@ -0,0 +1,138 @@ +--- +language: asciidoc +contributors: + - ["Ryan Mavilia", "http://unoriginality.rocks/"] + - ["Abel Salgado Romero", "https://twitter.com/abelsromero"] +lang: es-es +filename: asciidoc-es.md +--- + +AsciiDoc es un lenguaje de marcas similar a Markdown que puede ser usado para cualquier uso, desde libros a blogs. +Creado en 2002 por Stuart Rackham, el lenguaje es simple pero permite un gran nivel de personalización. + +Cabecera de documento + +La cabecera es opcional y no puede contener lineas vacías. Debe estar separada del contenido por al menos una línea en blanco. + +Solo título + +``` += Título de documento + +Primer contenido del documento. +``` + +Título y autor + +``` += Título del documento +Nombre Apellido(s) + +Inicio de este documento. +``` + +Múltiples autores + +``` += Título del documento +John Doe ; Jane Doe; Black Beard + +Inicio de un documento con múltiples autores. +``` + +Linea de versión (requiere línea de autor) + +``` += Titulo V1 +Potato Man +v1.0, 2016-01-13 + +Este artículo sobre patatas fritas será genial. +``` + +Párrafo + +``` +No necesitas nada especial para un párrafo. + +Inserta una línea vacía entre cada párrafo para separarlos. + +Para insertar un salto de línea, solo añade un + +y ya lo tienes! +``` + +Dando formato al texto + +``` +_guión bajo para cursiva_ +*asteriscos para negrita* +*_combinalos y verás_* +`usa comillas invertidas para monospace` +`*combina para negrita monospace*` +``` + +Títulos de sección + +``` += Nivel 0 (úsalo solo para el título del documento) + +== Nivel 1
+ +=== Nivel 2
+ +==== Nivel 3
+ +===== Nivel 4
+ +====== Nivel 5
+ +======= Nivel 6 + +``` + +Listas + +Para crear una lista sin orden usa asteriscos. + +``` +* foo +* bar +* baz +``` + +Para crear una lista numerada usa puntos. + +``` +. item 1 +. item 2 +. item 3 +``` + +Puedes crear hasta 5 subniveles en las listas añadiendo asteriscos o puntos. + +``` +* foo 1 +** foo 2 +*** foo 3 +**** foo 4 +***** foo 5 + +. foo 1 +.. foo 2 +... foo 3 +.... foo 4 +..... foo 5 +``` + +## Referencias + +Existen dos herramientas para procesar documentación en AsciiDoc: + +1. [AsciiDoc](http://asciidoc.org/): implementación original para Python, disponible en las principales distribuciones Linux. Versión estable actualmente en modo mantenimiento. +2. [Asciidoctor](http://asciidoctor.org/): implementación alternativa para Ruby, usable también desde Java y JavaScript. Implementación completa en evolución, su objetivo es ampliar AsciiDoc con nuevas funcionalidades y conversores de salida. + +Los siguientes enlaces pertenecen a `Asciidoctor` (documentación en inglés): + +* [Comparación de sintaxi Markdown - AsciiDoc](http://asciidoctor.org/docs/user-manual/#comparison-by-example): comparativa de elements comunes entre Markdown y AsciiDoc. +* [Primeros pasos](http://asciidoctor.org/docs/#get-started-with-asciidoctor): manuales de instalación e inicio para convertir documentos simples. +* [Manual de usuario de Asciidoctor](http://asciidoctor.org/docs/user-manual/): referencia completa en un único documento, contiene ejemplos, guías de herramientas, etc. -- cgit v1.2.3 From d88ae3b30dba1bd2f1319f8b00e5d8af9f838db4 Mon Sep 17 00:00:00 2001 From: Abel Salgado Romero Date: Tue, 19 Sep 2017 19:34:41 +0200 Subject: applied fixes from review --- es-es/asciidoc-es.html.markdown | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) (limited to 'es-es') diff --git a/es-es/asciidoc-es.html.markdown b/es-es/asciidoc-es.html.markdown index 7ca22172..6e357915 100644 --- a/es-es/asciidoc-es.html.markdown +++ b/es-es/asciidoc-es.html.markdown @@ -2,6 +2,7 @@ language: asciidoc contributors: - ["Ryan Mavilia", "http://unoriginality.rocks/"] +translators: - ["Abel Salgado Romero", "https://twitter.com/abelsromero"] lang: es-es filename: asciidoc-es.md @@ -43,7 +44,7 @@ Inicio de un documento con múltiples autores. Linea de versión (requiere línea de autor) ``` -= Titulo V1 += Título del documento V1 Potato Man v1.0, 2016-01-13 @@ -66,7 +67,7 @@ Dando formato al texto ``` _guión bajo para cursiva_ *asteriscos para negrita* -*_combinalos y verás_* +*_combínalos y verás_* `usa comillas invertidas para monospace` `*combina para negrita monospace*` ``` @@ -83,11 +84,6 @@ Títulos de sección ==== Nivel 3
===== Nivel 4
- -====== Nivel 5
- -======= Nivel 6 - ``` Listas @@ -133,6 +129,6 @@ Existen dos herramientas para procesar documentación en AsciiDoc: Los siguientes enlaces pertenecen a `Asciidoctor` (documentación en inglés): -* [Comparación de sintaxi Markdown - AsciiDoc](http://asciidoctor.org/docs/user-manual/#comparison-by-example): comparativa de elements comunes entre Markdown y AsciiDoc. +* [Comparación de sintaxis Markdown - AsciiDoc](http://asciidoctor.org/docs/user-manual/#comparison-by-example): comparativa de elements comunes entre Markdown y AsciiDoc. * [Primeros pasos](http://asciidoctor.org/docs/#get-started-with-asciidoctor): manuales de instalación e inicio para convertir documentos simples. * [Manual de usuario de Asciidoctor](http://asciidoctor.org/docs/user-manual/): referencia completa en un único documento, contiene ejemplos, guías de herramientas, etc. -- cgit v1.2.3 From 9afd4fd1bd7ea9fb32dd3957c07380d3879da753 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kamil=20=C5=81opusza=C5=84ski?= Date: Wed, 4 Oct 2017 16:15:38 +0200 Subject: [groovy] small fix in iteration over a map --- es-es/groovy-es.html.markdown | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'es-es') diff --git a/es-es/groovy-es.html.markdown b/es-es/groovy-es.html.markdown index 799fc609..262d5e6a 100644 --- a/es-es/groovy-es.html.markdown +++ b/es-es/groovy-es.html.markdown @@ -232,10 +232,12 @@ for (i in array) { // Iterando sobre un mapa def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy'] -x = 0 +x = "" for ( e in map ) { x += e.value + x += " " } +assert x.equals("Roberto Grails Groovy ") /* Operadores -- cgit v1.2.3 From 7d2dcc0df4b85861f7880fcd9299674a7040fff7 Mon Sep 17 00:00:00 2001 From: "J.Juan" <32603609+jjuanhdez@users.noreply.github.com> Date: Sun, 8 Oct 2017 01:05:48 +0200 Subject: Create learnsmallbasic-es.html.markdown --- es-es/learnsmallbasic-es.html.markdown | 132 +++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 es-es/learnsmallbasic-es.html.markdown (limited to 'es-es') diff --git a/es-es/learnsmallbasic-es.html.markdown b/es-es/learnsmallbasic-es.html.markdown new file mode 100644 index 00000000..21208792 --- /dev/null +++ b/es-es/learnsmallbasic-es.html.markdown @@ -0,0 +1,132 @@ +--- +language: SmallBASIC +filename: learnsmallbasic-es.bas +contributors: + - ["Chris Warren-Smith", "http://smallbasic.sourceforge.net"] +translators: + - ["José Juan Hernández García", "http://jjuanhdez.es"] +lang: es-es +--- + +## Acerca de + +SmallBASIC es un intérprete del lenguaje BASIC rápido y fácil de aprender, ideal para cálculos cotidianos, scripts y prototipos. SmallBASIC incluye funciones trigonométricas, matrices y álgebra, un IDE integrado, una potente librería de cadenas de texto, comandos de sistema, sonido y gráficos, junto con una sintaxis de programación estructurada. + +## Desarrollo + +SmallBASIC fue desarrollado originalmente por Nicholas Christopoulos a finales de 1999 para el Palm Pilot. El desarrollo del proyecto ha sido continuado por Chris Warren-Smith desde el año 2005. +Versiones de SmallBASIC se han hecho para una serie dispositivos de mano antiguos, incluyendo Franklin eBookman y el Nokia 770. También se han publicado varias versiones de escritorio basadas en una variedad de kits de herramientas GUI, algunas de las cuales han desaparecido. Las plataformas actualmente soportadas son Linux y Windows basadas en SDL2 y Android basadas en NDK. También está disponible una versión de línea de comandos de escritorio, aunque no suele publicarse en formato binario. +Alrededor de 2008 una gran corporación lanzó un entorno de programación BASIC con un nombre de similar. SmallBASIC no está relacionado con este otro proyecto. + +```SmallBASIC +REM Esto es un comentario +' y esto tambien es un comentario + +REM Imprimir texto +PRINT "hola" +? "? es la abreviatura de PRINT" + +REM Estructuras de control +FOR index = 0 TO 10 STEP 2 + ? "Este es el numero de linea "; index +NEXT +J = 0 +REPEAT + J++ +UNTIL J = 10 +WHILE J > 0 + J-- +WEND + +REM Estructura Select Case +SELECT CASE "Cool" + CASE "null", 1, 2, 3, 4, 5, 6, 7, 8, "Cool", "blah" + CASE "No Cool" + PRINT "Fallo epico" + CASE ELSE + PRINT "Fallo" +END SELECT + +REM Captura de errores con TRY/CATCH +TRY + fn = Freefile + OPEN filename FOR INPUT As #fn +CATCH err + PRINT "No se pudo abrir" +END TRY + +REM Procedimientos y funciones definidas por el usuario +FUNC add2(x, y) + ' variables pueden declararse como locales en el ambito de una SUB o FUNC + LOCAL k + k = "k dejara de existir cuando retorne FUNC" + add2 = x + y +END +PRINT add2(5, 5) + +SUB print_it(it) + PRINT it +END +print_it "IT...." + +REM Visualizacion de lineas y pixeles +At 0, ymax / 2 + txth ("Q") +COLOR 1: ? "sin(x)": +COLOR 8: ? "cos(x)": +COLOR 12: ? "tan(x)" +LINE 0, ymax / 2, xmax, ymax / 2 +FOR i = 0 TO xmax + PSET i, ymax / 2 - SIN(i * 2 * pi / ymax) * ymax / 4 COLOR 1 + PSET i, ymax / 2 - COS(i * 2 * pi / ymax) * ymax / 4 COLOR 8 + PSET i, ymax / 2 - TAN(i * 2 * pi / ymax) * ymax / 4 COLOR 12 +NEXT +SHOWPAGE + +REM SmallBASIC es ideal para experimentar con fractales y otros efectos interesantes +DELAY 3000 +RANDOMIZE +ff = 440.03 +FOR j = 0 TO 20 + r = RND * 1000 % 255 + b = RND * 1000 % 255 + g = RND * 1000 % 255 + c = RGB(r, b, g) + ff += 9.444 + FOR i = 0 TO 25000 + ff += ff + x = MIN(xmax, -x + COS(f * i)) + y = MIN(ymax, -y + SIN(f * i)) + PSET x, y COLOR c + IF (i % 1000 == 0) THEN + SHOWPAGE + fi + NEXT +NEXT j + +REM Para historiadores de computadoras, SmallBASIC puede ejecutar programas +REM encontrados en los primeros libros de computacion y revistas, por ejemplo: +10 LET A = 9 +20 LET B = 7 +30 PRINT A * B +40 PRINT A / B + +REM SmallBASIC también tiene soporte para algunos conceptos modernos como JSON +aa = ARRAY("{\"cat\":{\"name\":\"harry\"},\"pet\":\"true\"}") +IF (ismap(aa) == false) THEN + THROW "no es un mapa" +END IF +PRINT aa + +PAUSE + +``` +## Artículos + +* [Primeros pasos](http://smallbasic.sourceforge.net/?q=node/1573) +* [Bienvenido a SmallBASIC](http://smallbasic.sourceforge.net/?q=node/838) + +## GitHub + +* [Código fuente](https://github.com/smallbasic/SmallBASIC) +* [Reference snapshot](http://smallbasic.github.io/) + -- cgit v1.2.3 From d01e5242e16c522becc1b04f9692d2556f94c4f1 Mon Sep 17 00:00:00 2001 From: Damian Rzeszot Date: Mon, 9 Oct 2017 12:01:15 +0200 Subject: swift | fix style guidelines --- es-es/swift-es.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'es-es') diff --git a/es-es/swift-es.html.markdown b/es-es/swift-es.html.markdown index 8f63517a..ea892628 100644 --- a/es-es/swift-es.html.markdown +++ b/es-es/swift-es.html.markdown @@ -446,20 +446,20 @@ if let circle = myEmptyCircle { // Al igual que las clases, pueden contener métodos enum Suit { - case Spades, Hearts, Diamonds, Clubs + case spades, hearts, diamonds, clubs func getIcon() -> String { switch self { - case .Spades: return "♤" - case .Hearts: return "♡" - case .Diamonds: return "♢" - case .Clubs: return "♧" + case .spades: return "♤" + case .hearts: return "♡" + case .diamonds: return "♢" + case .clubs: return "♧" } } } // Los valores de enum permite la sintaxis corta, sin necesidad de poner // el tipo del enum cuando la variable es declarada de manera explícita -var suitValue: Suit = .Hearts +var suitValue: Suit = .hearts // Enums de tipo no-entero requiere asignaciones de valores crudas directas enum BookName: String { -- cgit v1.2.3 From 9a9e52b54bf9bc6ebeefc996452f5944a234557f Mon Sep 17 00:00:00 2001 From: Damian Rzeszot Date: Mon, 9 Oct 2017 12:02:29 +0200 Subject: swift | fix style guidelines --- es-es/swift-es.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'es-es') diff --git a/es-es/swift-es.html.markdown b/es-es/swift-es.html.markdown index ea892628..cd16d318 100644 --- a/es-es/swift-es.html.markdown +++ b/es-es/swift-es.html.markdown @@ -463,10 +463,10 @@ var suitValue: Suit = .hearts // Enums de tipo no-entero requiere asignaciones de valores crudas directas enum BookName: String { - case John = "John" - case Luke = "Luke" + case john = "John" + case luke = "Luke" } -print("Name: \(BookName.John.rawValue)") +print("Name: \(BookName.john.rawValue)") // Enum con valores asociados enum Furniture { -- cgit v1.2.3 From e8ee66c854b8833fcb0fd76b5e9ace6ae8379397 Mon Sep 17 00:00:00 2001 From: Damian Rzeszot Date: Mon, 9 Oct 2017 12:03:27 +0200 Subject: swift | fix style guidelines --- es-es/swift-es.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'es-es') diff --git a/es-es/swift-es.html.markdown b/es-es/swift-es.html.markdown index cd16d318..22e3c532 100644 --- a/es-es/swift-es.html.markdown +++ b/es-es/swift-es.html.markdown @@ -471,23 +471,23 @@ print("Name: \(BookName.john.rawValue)") // Enum con valores asociados enum Furniture { // Asociación con Int - case Desk(height: Int) + case desk(height: Int) // Asociación con String e Int - case Chair(String, Int) + case chair(String, Int) func description() -> String { switch self { - case .Desk(let height): + case .desk(let height): return "Desk with \(height) cm" - case .Chair(let brand, let height): + case .chair(let brand, let height): return "Chair of \(brand) with \(height) cm" } } } -var desk: Furniture = .Desk(height: 80) +var desk: Furniture = .desk(height: 80) print(desk.description()) // "Desk with 80 cm" -var chair = Furniture.Chair("Foo", 40) +var chair = Furniture.chair("Foo", 40) print(chair.description()) // "Chair of Foo with 40 cm" -- cgit v1.2.3