diff options
Diffstat (limited to 'es-es/livescript-es.html.markdown')
| -rw-r--r-- | es-es/livescript-es.html.markdown | 338 |
1 files changed, 338 insertions, 0 deletions
diff --git a/es-es/livescript-es.html.markdown b/es-es/livescript-es.html.markdown new file mode 100644 index 00000000..538c0a2a --- /dev/null +++ b/es-es/livescript-es.html.markdown @@ -0,0 +1,338 @@ +--- +language: LiveScript +filename: learnLivescript-es.ls +contributors: + - ["Christina Whyte", "http://github.com/kurisuwhyte/"] +translators: + - ["Daniel Zendejas", "http://github.com/DanielZendejas/"] +--- + +LiveScript es un lenguaje funcional compilado sobre Javascript. Comparte +la mayoría de la semántica con este mismo lenguaje. Composición de funciones, +comparación de patrones y muchas otras cosas son las adiciones que hace +LiveScript. Está inspirado en lenguajes como Haskell, F# y Scala. + +Livescript es un bifurcación de [Coco][], que en sí mismo es una bifurcación +de [CoffeeScript][]. El lenguaje es estable, y una nueva versión está en +desarrollo activo para traer aún más funciones. + +[Coco]: http://satyr.github.io/coco/ +[CoffeeScript]: http://coffeescript.org/ + +La retroalimentación siempre es bienvenida, así que sientete libre de +contactarme en [@kurisuwhyte](https://twitter.com/kurisuwhyte) :) + +```coffeescript +# Justo como su primo CoffeeScript, LiveScript usa símbolos de gato para +# comentarios de una sola línea + +/* + Comentarios multi-línea son escritos con estilo de C. Usa este estilo si quieres + que los comentarios se preserven en el output de Javascript + */ +``` +```coffeescript +# En lo que a la sintaxis se refiere, LiveScript usa indentación para delimitar +# bloques en lugar de llaves {} y espacios para aplicar funciones, en lugar de +# paréntesis. + +######################################################################## +## 1. Valores básicos +######################################################################## + +# La carencia de valor se define con la palabra `void` en lugar de `undefined` +void # igual que `undefined` pero más seguro (no puede ser sobre escrito) + +# Ningún valor válido se representa con Null. +null + +# El valor básico más pequeño es de tipo lógico: +true +false + +# Y tiene múltiples alias que significan lo mismo: +on; off +yes; no + +# Luego vienen los números. Estos número con punto flotante tienen la misma +# precisión que los de JS: +10 +0.4 # Note que el `0` al inicio es requerido + +# Para fines de fácil lectura, puedes usar guiones bajos y sufijos en un +# número, y estos serán ignorados por el compilador. +12_344km + +# Los Strings son secuencias de caracteres inmutables, como en JS: +"Christina" # ¡Los apóstrofes están bien! +"""Strings + de muchas + líneas + están + bien + también.""" + +# A veces quieres codificar un palabra clave, la diagonal invertida sirve para esto: +\keyword # => 'keyword' + + +# Los arreglos son colecciones ordenadas de datos: +frutas = + * \manzana + * \naranja + * \pera + +# Una forma más concisa de representarlos son con corchetes: +frutas = [ \manzana, \naranja, \pera ] + +# Esta es una conveniente de crear listas de Strings, usando +# espacio en blanco para delimitar los items: +frutas = <[ manzana naranja pera ]> + +# Puedes recuperar un item usando su índice (empezando en 0): +frutas[0] # => "manzana" + +# Los objetos son colecciones de pares llave/valor sin ordenar, entre otras cosas, +# (detallaremos más al respecto en un momento): +persona = + nombre: "Christina" + gusta: + * "gatitos" + * "otras cosas" + +# Otra vez, puedes expresar el objeto con más consistencia con llaves {}: +persona = {nombre: "Christina", gusta: ["gatitos", "otras cosas"]} + +# Puedes conseguir un valor por medio de su llave: +persona.nombre # => "Christina" +persona["nombre"] # => "Christina" + + +# Las expresiones regulares tienen la misma sintaxis que en JavaScript: +expresion-regular = /\s$/ + +# A excepción de que puedes hacer expresiones de múltiples líneas +# (los comentarios y espacios se ignoran): +expresion-regular = // + function\s+(.+) # nombre + \s* \((.*)\) \s* # argumentos + { (.*) } # cuerpo + // + + +######################################################################## +## 2. Operaciones básicas +######################################################################## + +# Los operadores aritméticos son los mismos que en JavaScript: +1 + 2 # => 3 +2 - 1 # => 1 +2 * 3 # => 6 +4 / 2 # => 2 +3 % 2 # => 1 + + +# Las comparaciones son casi las mismas, excepto `==` que es igual +# a `===` en. El operador `==` de JS en LiveScript es `~=`, y `===` +# permite comparaciones entre objetos y arreglos, y también +# comparasiones más estrictas: +2 == 2 # => true +2 == "2" # => false +2 ~= "2" # => true +2 === "2" # => false + +[1,2,3] == [1,2,3] # => false +[1,2,3] === [1,2,3] # => true + ++0 == -0 # => true ++0 === -0 # => false + +# Otros operadores relacionales incluyen <, <=, > and >= + +# Los valores lógicos pueden ser combinados mediante los operadores +# lógicos `or`, `and` and `not`: +true and false # => false +false or true # => true +not false # => true + +# Las colecciones también tienen algunos operadores adicionales: +[1, 2] ++ [3, 4] # => [1, 2, 3, 4] +'a' in <[ a b c ]> # => true +'nombre' of { nombre: 'Chris' } # => true + + +######################################################################## +## 3. Funciones +######################################################################## + +# Como LiveScript es funcional, uno esperaría que las funciones recibirían +# un buen tratamiento. En LiveScript es más que aparente que las funciones +# son de primera clase: +suma = (primerElemento, segundoElemento) -> primerElemento + segundoElemento +add 1, 2 # => 3 + +# Las funciones que no reciben argumentos son llamadas rápidamente +dos = -> 2 +dos! + +# LiveScript, al igual que JS, aplica ámbitos (alcance) a sus variables y +# tiene cierres (closures) también. A diferencia de JavaScript, el operador +# `=` sirve como declaración y siempre declarará la variable en lado izquierdo. + +# El operador `:=` está disponible para *reusar* un nombre del ámbito del padre. + +# Puedes acceder a los argumentos de una función para conseguir +# los datos internos de una estructura de datos rápidamente: +cola = ([cabeza, ...resto]) -> resto +cola [1, 2, 3] # => [2, 3] + +# También puedes transformar argumentos usando operadores binarios o unarios. +# Argumentos por defecto también son posibles +foo = (a = 1, b = 2) -> a + b +foo! # => 3 + +# También puedes usarlo para clonar un argumento en particular para evitar efectos +# secundarios, por ejemplo: +copiar = (^^objetivo, fuente) -> + for k,v of fuente => objetivo[k] = v + objetivo +a = { a: 1 } +copiar a, { b: 2 } # => { a: 1, b: 2 } +a # => { a: 1 } + +# Una función puede ser abreviada usando una flecha larga en lugar de una corta: +suma = (primerElemento, segundoElemento) --> primerElemento + segundoElemento +sumaAbreviada = suma 1 +sumaAbreviada 2 # => 3 + +# Las funciones obtienen un argumento `it` implícito, incluso si no declaras +# ningún argument +identidad = -> it +identidad 1 # => 1 + +# Los operadores no son funciones en LiveScript. ¡Pero se pueden convertir fácilmente +# en una! Presentamos el seccionamiento de operadores: +dividir-entre-2 = (/ 2) +[2, 4, 8, 16].map(dividir-entre-2) .reduce (+) + +# LiveScript vive de otras cosas aparte de las funciones. Como en cualquier lenguaje +# funcional obtienes medios para componer (juntar) funciones: +doble-menos-uno = (- 1) . (* 2) + +# A parte de la clásica fórmula matemática `f . g`, también cuentas co los operadores +# `>>` y `<<`, que describen el flujo de los valores dentro de las funciones: +double-minus-one = (* 2) >> (- 1) +double-minus-one = (- 1) << (* 2) + +# Hablando del flujo de los valores, LiveScript también tiene los operadores `|>` y `<|` +# que aplican un valor a una función: +map = (f, xs) --> xs.map f +[1 2 3] |> map (* 2) # => [2 4 6] + +# También puedes escoger dónde quieres que el valor se posicione, sólo márcalo con un +# guíon bajo: +reducir = (f, xs, initial) --> xs.reducir f, initial +[1 2 3] |> reducir (+), _, 0 # => 6 + +# El guíon bajo también se usa para apartar lugares para tus argumentos, por ejemplo: +division = (dividendo,divisor) -> dividendo / divisor +dividir-entre-2 = division _, 2 +dividir-entre-2 4 # => 2 + +# Por último, LiveScript tiene back-calls (útiles mecanismos para hacer +# callbacks.). A pesar de esto deberías intentar formas más funcionales de hacerlo, +# como Promises: +leerArchivo = (nombre, f) -> f name +a <- leerArchivo 'foo' +b <- leerArchivo 'bar' +console.log a + b + +# Igual a: +leerArchivo 'foo', (a) -> leerArchivo 'bar', (b) -> console.log a + b + + +######################################################################## +## 4. Patrones, guardias y control de flujo +######################################################################## + +# Puedes bifurcar cálculos con la expresión `if...else`: +x = if n > 0 then \positive else \negative + +# En lugar de `then`, puedes usar `=>` +x = if n > 0 => \positivo + else \negativo + +# A pesar de esto, a las condiciones complejas es mejor expresarlas con el `switch`: +y = {} +x = switch + | (typeof y) is \number => \numero + | (typeof y) is \string => \string + | 'length' of y => \arreglo + | otherwise => \objeto # `otherwise` y `_` son lo mismo. + +# Los cuerpos de las funciones, declaraciones y asignaciones tienen un `switch` por defecto, +# así que no necesitas escribirlo nuevamente: + +take = (n, [x, ...xs]) --> + | n == 0 => [] + | _ => [x] ++ take (n - 1), xs + + +######################################################################## +## 5. Comprehensions (Auxiliares) +######################################################################## + +# Mientras que los auxiliares funcionales (para lidiar con listas y objetos) +# están en la librería estándar de JavaScript (y complementada con prelude-ls, +# que es una "librería estándar" de LiveScipt) los "comprehensions" (Auxiliares) +# usualemente te permiten hacer lo mismo pero más rápido y con una sintaxis más +# comprehensible (de ahí su nombre en inglés): +unoAVeinte = [1 to 20] +pares = [x for x in oneToTwenty when x % 2 == 0] + +# `when` y `unless` pueden ser usados como filtros en el auxiliar. + +# Los auxiliares para objetos funcionan de la misma forma, excepto que regresa un +# objeto en lugar de un arreglo: +copiar = { [k, v] for k, v of source } + + +######################################################################## +## 4. PROGRAMACIÓN ORIENTADA A OBJETOS +######################################################################## + +# Mientras que LiveScript es un lenguaje funcional en la mayoría de los +# aspectos, también brinda ayudas para la programación orientada a objetos. +# Algunas de estas ayudas son la sintaxis para las clases y un poco de "azucar" +# para las clases heredada de CoffeeScript: +class Animal + (@nombre, tipo) -> + @tipo = tipo + action: (accion) -> "*#{@nombre} (un #{@tipo}) #{accion}*" + +class Gato extends Animal + (@nombre) -> super @nombre, 'gato' + ronronear: -> @action 'ronronea' + +gatito = new Gato 'Mei' +gatito.purr! # => "*Mei (un gato) ronronea*" + +# A parte del clásico patrón de herencia simple, también puedes proveer +# cuantas mezclas quieras para una clase. Las mezclas sólo son objetos: +Abrazable = + abrazar: -> @action 'es abrazado' + +class GatoAbrazable extends Gato implements Abrazable + +gatito = new GatoAbrazable 'Ronroneo' +gatito.abrazar! # => "*Mei (un gato) es abrazado*" +``` + +## Más recursos + +Existe mucho más sobre LiveScript, pero esto debe bastar para que empieces. +El [sitio oficial](http://livescript.net/) tiene mucha información sobre el +lenguaje, y un compilador en linea para que pruebes cosas inmediatamente. + +También querras probar un poco de [prelude.ls](http://gkz.github.io/prelude-ls/), +y probar el canal `#livescript` en la red Freenode. |