diff --git a/_es/tour/basics.md b/_es/tour/basics.md index bd86428a9b..80977f061b 100644 --- a/_es/tour/basics.md +++ b/_es/tour/basics.md @@ -6,4 +6,319 @@ discourse: false partof: scala-tour language: es + +num: 2 +next-page: unified-types +previous-page: tour-of-scala --- + +En esta página, practicaremos conceptos básicos de Scala. + +## Probando Scala en el navegador + +Puedes ejecutar Scala en tu navegador con ScalaFiddle. + +1. Ve a [https://scalafiddle.io](https://scalafiddle.io). +2. Escribe `println("Hello, world!")` en el panel a la izquierda. +3. Presiona el botón "Run". En el panel de la derecha aparecerá el resultado. + +Así, de manera fácil y sin preparación, puedes probar fragmentos de código Scala. + +Muchos ejemplos de código en esta documentación están integrados con ScalaFiddle, y así puedes probarlos directamente solo con pulsar el botón "Run". + +## Expresiones + +Las expresiones son sentencias computables. + +```tut +1 + 1 +``` + +Se puede ver el resultado de evaluar expresiones usando `println`. + +{% scalafiddle %} +```tut +println(1) // 1 +println(1 + 1) // 2 +println("Hello!") // Hello! +println("Hello," + " world!") // Hello, world! +``` +{% endscalafiddle %} + +## Valores + +Se puede dar un nombre al resultado de una expresión usando la palabra reservada `val`. + +```tut +val x = 1 + 1 +println(x) // 2 +``` + +Los resultados con nombre, como `x` en el ejemplo, son llamados valores. Referenciar un valor no lo vuelve a computar. + +Los valores no pueden ser reasignados. + +```tut:fail +x = 3 // This does not compile. +``` + +Scala es capaz de inferir el tipo de un valor. Aun así, también se puede indicar el tipo usando una anotación: + +```tut +val x: Int = 1 + 1 +``` + +Nótese que la anotación del tipo `Int` sigue al identificador `x` de la variable, separado por dos puntos `:`. + +## Variables + +Una variable es como un valor, excepto que a una variable se le puede re-asignar un valor después de declararla. Una variable se declara con la palabra reservada `var`. + +```tut +var x = 1 + 1 +x = 3 // This compiles because "x" is declared with the "var" keyword. +println(x * x) // 9 +``` + +Como con los valores, si se quiere se puede especificar el tipo de una variable mutable: + +```tut +var x: Int = 1 + 1 +``` + +## Bloques + +Se pueden combinar expresiones rodeándolas con `{}` . A esto le llamamos un bloque. + +El resultado de la última expresión del bloque es también el resultado total del bloque. + +```tut +println({ + val x = 1 + 1 + x + 1 +}) // 3 +``` + +## Funciones + +Una función es una expresión que acepta parámetros. + +Una función se puede declarar anónima, sin nombre. Por ejemplo, ésta es una función que acepta un número entero `x`, y devuelve el resultado de incrementarlo: + +```tut +(x: Int) => x + 1 +``` + +La lista de parámetros de la función está a la izquierda de la flecha `=>`, y a su derecha está el cuerpo de la función. + +También podemos asignarle un nombre a la función. + +{% scalafiddle %} +```tut +val addOne = (x: Int) => x + 1 +println(addOne(1)) // 2 +``` +{% endscalafiddle %} + +Las funciones pueden tomar varios parámetros. + +{% scalafiddle %} +```tut +val add = (x: Int, y: Int) => x + y +println(add(1, 2)) // 3 +``` +{% endscalafiddle %} + +O ninguno. + +```tut +val getTheAnswer = () => 42 +println(getTheAnswer()) // 42 +``` + +## Métodos + +Los métodos se parecen y comportan casi como a las funciones, pero se diferencian en dos aspectos clave: + +Un método se define con la palabra reservada `def`, seguida por el nombre del método, la lista de parámetros, el tipo de valores que el método devuelve, y el cuerpo del método. + +{% scalafiddle %} +```tut +def add(x: Int, y: Int): Int = x + y +println(add(1, 2)) // 3 +``` +{% endscalafiddle %} + +Observe que el tipo de retorno se declara _después_ de la lista de parámetros, y separado con dos puntos, p.ej. `: Int`. + +Un método puede tener varias listas de parámetros. + +{% scalafiddle %} +```tut +def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier +println(addThenMultiply(1, 2)(3)) // 9 +``` +{% endscalafiddle %} + +O ninguna lista de parámetros. + +```tut +def name: String = System.getProperty("user.name") +println("Hello, " + name + "!") +``` + +Hay otras diferencias, pero para simplificar, podemos pensar que son similares a las funciones. + +Los métodos también pueden tener expresiones de varias lineas. + +```tut +def getSquareString(input: Double): String = { + val square = input * input + square.toString +} +``` + +La ultima expresión en el cuerpo del método es el valor de retorno del mismo. +(Scala tiene una palabra reservada `return`, pero se usa raramente y no se aconseja usarla) + +## Clases + +Una clase se define con la palabra reservada `class`, seguida del nombre, y la lista de parámetros del constructor. + +```tut +class Greeter(prefix: String, suffix: String) { + def greet(name: String): Unit = + println(prefix + name + suffix) +} +``` + +El método `greet` tiene un tipo de retorno `Unit`, que indica que el método no tiene nada significativo que devolver. Esto es similar al tipo `void` en C, C++, o Java. La diferencia con estos lenguajes es que en Scala toda expresión debe devolver un valor. Por ello, se usa un tipo `Unit` que tiene con un solo valor que se escribe `()` y no lleva información. + +Se puede crear una instancia de una clase con la palabra reservada *new*. + +```tut +val greeter = new Greeter("Hello, ", "!") +greeter.greet("Scala developer") // Hello, Scala developer! +``` + +Las clases se tratan en profundidad [más adelante](classes.html). + +## Case Classes + +Hay un tipo especial de clases en Scala, las llamadas "case" classes. Por defecto, las instancias de una case class son inmutables, y se comparan con otras solo por los valores que contienen en cada campo. +Una case class se define con las palabras reservadas `case class`: + +```tut +case class Point(x: Int, y: Int) +``` + +Se puede crear una instancia de una `case class`, sin usar la palabra reservada `new`. + +```tut +val point = Point(1, 2) +val anotherPoint = Point(1, 2) +val yetAnotherPoint = Point(2, 2) +``` + +Y son comparadas por valor. + +```tut +if (point == anotherPoint) { + println(point + " and " + anotherPoint + " are the same.") +} else { + println(point + " and " + anotherPoint + " are different.") +} // Point(1,2) and Point(1,2) are the same. + +if (point == yetAnotherPoint) { + println(point + " and " + yetAnotherPoint + " are the same.") +} else { + println(point + " and " + yetAnotherPoint + " are different.") +} // Point(1,2) and Point(2,2) are different. +``` + +Hay mucho más sobre las case classes que queremos presentar, y estamos convencidos de que te vas a enamorar de ellas. Se tratan con más detalle [mas adelante](case-classes.html). + +## Objetos + +Los objetos son instancias de una sola clase de su propia definición. Puedes pensar en ellos como _singleton_ de sus propias clases. + +Un objeto se define usando la palabra reservada `object`. + +```tut +object IdFactory { + private var counter = 0 + def create(): Int = { + counter += 1 + counter + } +} +``` + +Para acceder al objeto, lo referencias por su nombre. + +```tut +val newId: Int = IdFactory.create() +println(newId) // 1 +val newerId: Int = IdFactory.create() +println(newerId) // 2 +``` + +Cubriremos los objetos en profundidad [más adelante](singleton-objects.html). + +## Traits + +Los traits son tipos que contienen campos y métodos. Se pueden combinar múltiples traits. + +Un trait se define usando la palabra reservada `trait`. + +```tut +trait Greeter { + def greet(name: String): Unit +} +``` + +Un `trait` también puede definir un método, o un valor, con una implementación por defecto. + +{% scalafiddle %} +```tut +trait Greeter { + def greet(name: String): Unit = + println("Hello, " + name + "!") +} +``` + +Un `trait` también puede extender otros traits, usando la palabra clave `extends`. Asimismo, en un `trait` se puede redefinir la implementación de un método heredado, usando la palabra reservada `override`. + +```tut +class DefaultGreeter extends Greeter + +class CustomizableGreeter(prefix: String, postfix: String) extends Greeter { + override def greet(name: String): Unit = { + println(prefix + name + postfix) + } +} + +val greeter = new DefaultGreeter() +greeter.greet("Scala developer") // Hello, Scala developer! + +val customGreeter = new CustomizableGreeter("How are you, ", "?") +customGreeter.greet("Scala developer") // How are you, Scala developer? +``` +{% endscalafiddle %} + +Aquí, `DefaultGreeter` extiende un solo trait, pero puede extender múltiples traits. + +Los `traits` se tratan con detalle [en otra página](traits.html). + +## Método principal (Main Method) + +El método principal (main) es el punto donde comienza la ejecución de un programa en Scala. La máquina virtual de java (_Java Virtual Machine_ or JVM) requiere, para ejecutar un código Scala, que éste tenga un método principal llamado `main` cuyo único parámetro sea un arrray de Strings. + +Usando un objeto, puedes definir el método principal de la siguiente forma: + +```tut +object Main { + def main(args: Array[String]): Unit = + println("Hello, Scala developer!") +} +```