Funciones
## Objetivos de Aprendizaje
- Declarar y llamar funciones
- Comprender parámetros y tipos de retorno
- Usar argumentos por defecto
- Trabajar con argumentos nombrados
- Comprender funciones infix
- Aprender sobre recursión de cola
## Funciones Básicas
### Declaración de Función
```kotlin
fun greet() {
println("Hello!")
}
fun main() {
greet() // Call the function
}
```
### Función con Tipo de Retorno
```kotlin
fun add(a: Int, b: Int): Int {
return a + b
}
fun main() {
val result = add(5, 3)
println("5 + 3 = $result") // 8
}
```
### Funciones de Expresión Única
```kotlin
fun double(x: Int): Int = x * 2
fun main() {
println(double(5)) // 10
}
```
## Parámetros
### Múltiples Parámetros
```kotlin
fun printMessage(message: String, count: Int) {
for (i in 1..count) {
println("$i: $message")
}
}
fun main() {
printMessage("Hello", 3)
}
```
### Los Tipos de Parámetros son Requeridos
A diferencia de los tipos de retorno, los tipos de parámetros siempre son requeridos:
```kotlin
// This is valid - return type inferred
fun double(x: Int) = x * 2
// This is INVALID - parameter type is required
// fun double(x) = x * 2
```
## Argumentos por Defecto
```kotlin
fun greet(name: String, greeting: String = "Hello") {
println("$greeting, $name!")
}
fun main() {
greet("Alice") // Hello, Alice!
greet("Bob", "Hi") // Hi, Bob!
greet(name = "Charlie", greeting = "Hey") // Hey, Charlie!
}
```
### Valores de Argumento por Defecto
```kotlin
fun createUser(
name: String,
age: Int = 18,
email: String = "unknown@example.com"
) {
println("User: $name, Age: $age, Email: $email")
}
fun main() {
createUser("Alice")
createUser("Bob", 25)
createUser("Charlie", email = "charlie@test.com")
}
```
## Argumentos Nombrados
```kotlin
fun configure(
name: String,
debug: Boolean = false,
verbose: Boolean = false
) {
println("Name: $name, Debug: $debug, Verbose: $verbose")
}
fun main() {
configure("MyApp")
configure("MyApp", debug = true)
configure("MyApp", verbose = true, debug = true)
}
```
## Tipo de Retorno Unit
Si una función no retorna nada, el tipo de retorno es `Unit` (es opcional declararlo):
```kotlin
fun printSum(a: Int, b: Int): Unit {
println("Sum: ${a + b}")
}
fun main() {
printSum(3, 4)
}
```
## Cuerpo de Expresión Única
Para funciones simples, usa la sintaxis de cuerpo de expresión:
```kotlin
fun max(a: Int, b: Int): Int = if (a > b) a else b
fun main() {
println(max(10, 5)) // 10
}
```
## Parámetros Vararg
```kotlin
fun printAll(vararg items: String) {
for (item in items) {
println(item)
}
}
fun main() {
printAll("apple", "banana", "cherry")
}
```
Operador spread con arreglos:
```kotlin
fun main() {
val fruits = arrayOf("mango", "grape")
printAll("apple", *fruits, "orange")
}
```
## Funciones Infix
Las funciones pueden ser llamadas usando notación infix cuando:
1. Son funciones de miembro o funciones de extensión
2. Tienen exactamente un parámetro
```kotlin
infix fun Int.times(str: String): String = str.repeat(this)
fun main() {
val result = 3 times "Hi "
println(result) // Hi Hi Hi
}
```
### Ejemplo Personalizado de Creación de Pares
```kotlin
fun main() {
val pair = "key" to "value"
println(pair) // (key, value)
// to is actually an infix function
val map = mapOf("a" to 1, "b" to 2)
println(map)
}
```
## Funciones Locales (Anidadas)
```kotlin
fun outerFunction() {
fun nestedFunction() {
println("Nested!")
}
nestedFunction()
}
fun main() {
outerFunction()
}
```
Las funciones locales pueden acceder a variables del ámbito externo:
```kotlin
fun findMax(a: Int, b: Int, c: Int): Int {
fun max(x: Int, y: Int) = if (x > y) x else y
return max(max(a, b), c)
}
fun main() {
println(findMax(10, 5, 8)) // 10
}
```
## Funciones Genéricas
```kotlin
fun printItem(item: T) {
println(item)
}
fun main() {
printItem("String")
printItem(42)
printItem(3.14)
}
```
## Recursión de Cola
Usa el modificador `tailrec` para optimización del compilador:
```kotlin
tailrec fun factorial(n: Int, acc: Long = 1): Long {
return if (n <= 1) acc else factorial(n - 1, n * acc)
}
fun main() {
println(factorial(10)) // 3628800
}
```
Sin `tailrec`, una recursión grande causaría stack overflow. La palabra clave `tailrec` permite al compilador optimizar a un bucle iterativo.
## Funciones de Extensión
Declaradas más adelante en detalle, pero aquí hay una vista previa:
```kotlin
fun String.addExclamation(): String = this + "!"
fun main() {
val greeting = "Hello".addExclamation()
println(greeting) // Hello!
}
```
## Resumen
- Las funciones se declaran con la palabra clave `fun`
- Los parámetros requieren anotaciones de tipo
- El tipo de retorno es opcional si se infiere o retorna Unit
- Las funciones de expresión única usan sintaxis `= expresión`
- Los argumentos por defecto reducen la necesidad de sobrecargas
- Los argumentos nombrados mejoran la legibilidad
- `vararg` permite número variable de argumentos
- Las funciones infix se llaman sin paréntesis
- `tailrec` habilita la optimización de recursión de cola
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →