mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-27 11:18:51 +00:00
340 lines
12 KiB
Markdown
340 lines
12 KiB
Markdown
---
|
|
language: LiveScript
|
|
filename: learnLivescript-es.ls
|
|
contributors:
|
|
- ["Christina Whyte", "http://github.com/kurisuwhyte/"]
|
|
translators:
|
|
- ["Daniel Zendejas", "http://github.com/DanielZendejas/"]
|
|
lang: es-es
|
|
---
|
|
|
|
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.
|