You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
2 Hrs
0 Min
15 Seg

Funciones y funciones de extensión

26/37
Resources

How to create a basic function in Kotlin?

Getting familiar with creating functions in Kotlin is the first step to mastering this language. Creating a function in Kotlin is an essential skill for any developer looking to write efficient and well-structured code.

To create your first function in Kotlin, follow the steps below:

  • Declare the function outside of main to ensure its global accessibility.
  • Use the reserved word fun followed by the function name and the necessary parameters.
  • Define the return type of the function using : Type.

Basic example of function in Kotlin

Let's see a simple example in Kotlin, where we create a function that converts a phrase to uppercase or lowercase depending on a random number:

fun randomCase(phrase: String): String { val randomResult = (0..99).random() return if (randomResult.rem(2) == 0) { phrase.toUpperCase() } else { phrase.toLowerCase() }}
fun main() { val phrase = "At Platzi we never stop learning" println(randomCase(phrase))} }

What is a Unit return function and how do we use it?

In Kotlin, a function that does not return any specific value returns the type Unit, similar to void in other programming languages. Although you can omit Unit in the function declaration, mentioning it may clarify your intentions when writing code.

fun printFrase(phrase: String): Unit { println("Your phrase is: $phrase")}

How do extension functions work in Kotlin?

Extension functions in Kotlin allow you to add functionality to an existing type without having to inherit from it or modify its original code. Imagine being able to add custom methods to standard types, making your code cleaner and easier to manage.

Creating an extension function

To create an extension function, you use the same syntax as a normal function, but preceded by the type to which you want to add the extension:

String.randomCase()fun:String { val randomResult = (0..99).random() return if (randomResult.rem(2) == 0) { this.toUpperCase() } else { this.toLowerCase() }}

Testing and executing the functions

Now, let's test how this extension function works by calling it from a String object:

{ fun main() { val phrase = "Always learn something new" println(phrase.randomCase())} }

These handy functions improve code readability and make it more intuitive to use methods specific to existing classes. Adopting extension functions and understanding the basics of functions in Kotlin is a valuable step towards mastering software development. Be encouraged to implement these techniques in your future projects and you will see a noticeable improvement in the organization and efficiency of your code.

Keep exploring and learning new practices to become a better developer! Robustness and clarity in code are aspects that your colleagues and future employers will greatly appreciate.

Contributions 28

Questions 4

Sort by:

Want to see more contributions, questions and answers from the community?

Unit = void

toUpperCase() y toLowerCase() han sido marcadas como obsoletas. En su lugar recomienda usar: uppercase() y lowercase()

Funciones de extensión en Kotlin
Las funciones de extensión (o extension functions en inglés) son funciones que, como su propio nombre indica, nos ayudan a extender la funcionalidad de clases sin necesidad de tocar su código. Ahora vamos a ver cómo se definen estas funciones, y algunos ejemplos que a mí personalmente me resultan muy útiles.

¿Cómo se define una función de extensión?
Tan solo hay que escribir una función como lo harías normalmente, y ponerle delante el nombre de la clase separado por un punto.

Ejemplo muy sencillo: queremos hacer que una vista tenga la función visible(), que la hace visible. Escribiríamos algo como esto:

fun View.visible() {
    this.visibility = View.VISIBLE
}
El this  lo he puesto para que veas que podemos usar las funciones y propiedades de esa clase como si estuviéramos dentro de  la propia clase, pero lo puedes omitir:

fun View.visible() {
    visibility = View.VISIBLE
}

Algunos ejemplos interesantes
Hay un par de ejemplos que me gusta poner, porque resumen muy bien la potencialidad de esto.

El primero es cuando estás inflando una vista dentro de un adapter. Normalmente utilizarías algo así:

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
    val v = LayoutInflater.from(parent.context).inflate(R.layout.view_item, parent, false)
    return ViewHolder(v)
}
La línea que infla la vista y usa el parent es demasiado compleja, y el 99% de las veces suele ser igual en cualquier adapter. ¿Por qué no hacer que los ViewGroup  puedan inflar vistas?

fun ViewGroup.inflate(layoutRes: Int): View {
    return LayoutInflater.from(context).inflate(layoutRes, this, false)
}

Ahora ya puedes utilizarlo en el código de arriba:

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
    val v = parent.inflate(R.layout.view_item)
    return ViewHolder(v)
}

Un ejemplo muy parecido se puede hacer con las imágenes. Si utilizas por ejemplo la librería de Picasso, necesitas andar haciendo el típico ritual:

Picasso.with(imageView.context).load(url).into(imageView)

¿Qué te parecería poder decirle a ImageView que cargue una url directamente?

fun ImageView.loadUrl(url: String) {
    Picasso.with(context).load(url).into(this)
}

imageView.loadUrl(url)

Propiedades de extensión
Igual que puedes hacer funciones de extensión, lo mismo puedes hacer con properties. Lo único que no podrán guardar un estado propio, sino valerse de las funciones ya existentes para modificar el estado:

val ViewGroup.children: List
    get() = (0..childCount -1).map { getChildAt(it) }

Esta property recupera los hijos de un ViewGroup

Ahora podrías iterar sobre ellos directamente:

parent.children.forEach { it.visible() }
Nota: it es una palabra reservada que se utiliza para acceder al valor de entrada de la función, cuando solo hay uno. Como ya hemos visto en otros artículos, se pueden nombrar esos valores de entrada, y asignar más cuando hay más de uno.

Conclusión
Con las funciones y las propiedades de extensión puedes extender cualquier librería a la que no tengas acceso y luego utilizar esas funciones y propiedades como si fueran propias de la clase. Lo único que verás es un import extra en el archivo en el que se use.

Si de verdad vas en serio con Kotlin y, como yo, piensas que es el lenguaje del futuro en Android, te recomiendo que le eches un vistazo al training gratuito, donde te contaré todo lo que necesitas para aprender a crear tus Apps Android en Kotlin desde cero.

fuente:https://devexperto.com/funciones-extension-kotlin-android/




Genial !!!..Lo de la función extendida me encantó, kotlin es como un java con superpoderes

Hoy en dia kotlin ya no usa toUpperCase() sino que se reemplazo por uppercase()

Mi aporte:

import java.util.*

fun main(args: Array<String>) {
    val fraseAleatoria = "En Platzi nunca paramos de aprender".randomCase()
    imprimirFrase(fraseAleatoria)
}

fun imprimirFrase(frase : String){
    println("Tu frase es: $frase")
}

fun String.randomCase() : String{
    val numeroAleatorio = 0..99
    val resultadoAleatorio = numeroAleatorio.random()
    return if (resultadoAleatorio.rem(2) == 0) {
        this.uppercase()
    } else {
        this.lowercase()
    }
}

Podemos reducir la linea de código del random a una sola de esta manera.

fun main(args: Array<String>) {
    val wordRandom = readLine() ?: "Nunca pares de aprender"
    println(randomCase(wordRandom))
}

fun randomCase(word: String): String {
    val random = (0..99).random()
    return if (random.rem(2) != 0) {
        word.lowercase()
    } else word.uppercase()
}

Sería más sencillo generar un número aleatorio 0…1 y dependiendo del que salga se usa una u otra condición sin necesidad de estar dividiendo

Las funciones de extensión es añadir métodos a las clases sin tocar la clase.

fun callMyFunction() {
    println("Nunca Pares de aprender".convertToAsterisk())
}

fun String.convertToAsterisk() : String {
    return "*".repeat(this.length)
}

Código de la clase 😃

fun main( ){
    val fraseAleatoria = "Hola".randomCase()
    imprimirFrase(fraseAleatoria)
}

fun imprimirFrase(fraseAleatoria: String){
    println(fraseAleatoria)
}

fun String.randomCase() : String {
    val numAleatorio = 0..99
    val resAleatorio = numAleatorio.random()
    //modulo es rem
    return if(resAleatorio.rem(2)==0){
        this.toUpperCase()
    }else{
        this.toLowerCase()
    }
}
un main( ){
    val fraseAleatoria = "Hola".randomCase()
    imprimirFrase(fraseAleatoria)
}

fun imprimirFrase(fraseAleatoria: String){
    println(fraseAleatoria)
}

fun String.randomCase() : String {
    val numAleatorio = 0..99
    val resAleatorio = numAleatorio.random()
  
    return if(resAleatorio.rem(2)==0){
        this.toUpperCase()
    }else{
        this.toLowerCase()
    }
}

Me encanto la función extendida, Kotlin si que facilita el trabajo muchas veces y deja el codigo bien presentado y optimizado

```js fun main() { val phrase = "I want to learn Kotlin".randomCase() printPhrase(phrase) } fun printPhrase(phrase: String) { println("Your phrase is: $phrase") } fun String.randomCase(): String { val randomNumber = 0..99 val randomResult = randomNumber.random() return if (randomResult.rem(2) == 0) { this.uppercase() } else { this.lowercase() } } ```fun main() { val phrase = "I want to learn Kotlin".*randomCase*() *printPhrase*(phrase) } fun printPhrase(phrase: String) { *println*("Your phrase is: $phrase") } fun String.randomCase(): String { val randomNumber = 0..99 val randomResult = randomNumber.*random*() return if (randomResult.rem(2) == 0) { this.*uppercase*() } else { this.*lowercase*() } }
No conocía ell uso de las funciones de extensión, genial!
fun main (args: <u>Array</u><<u>String</u>>) { saludo ( "Miguel") } fun saludo (nombre: <u>String</u>){ val mensaje = "hola $nombre" println(mensaje) }
Tambien se pueden crear funciones de manera mas corta, sin usar { } Ej: fun nombreCompleto (nombre: String, apellido:String): String = nombre + apellido
Me encantaron las funciones de extencion. Kotlin va subiendo en mi ranking personal xD
fun main(args: Array\<String>) { *imprimirNombre*("pedro","luis") } fun imprimirNombre(nom:String,ape:String){ *println*("ejecuto mi funcion $nom $ape") }

¿Qué son las funciones?
Una función es un código que se ejecuta cada vez que lo llamamos.

Sintaxis de una función

Las funciones más básicas se componen de 4 partes.

Palabra reservada fun.
Nombre de la función.
Parámetros: Son las variables que le damos a la función para que las use en el código que ejecuta internamente.
Tipo de retorno: Puede tener o no un valor de retorno.
Código: Son las instrucciones que se van a ejecutar al llamar a la función.
Ejemplo de función:

https://static.platzi.com/media/user_upload/ejemplo-funcion-c53ba9d2-3278-47e4-91c7-85894fb98cc5.jpg

Cuando queremos devolver algo de nuestra función usamos la keyword return.Caso contrario cuando no queremos devolver nada de nuestra función, Kotlin regresaría Unit.

Ejemplo de función que no devuelve nada, no tiene ningún tipo de retorno.

https://static.platzi.com/media/user_upload/funcion sin retorno-f8b5644b-410b-48ca-927c-43c66a1a4971.jpg

Funciones de extension

Extiende funcionalidades de una clase
tiene un nuevo parámetro : recibidor
Se declara tal que asi

fun String.randomCase() :String {
val numeroAleatorio = 0…99
val resultadoAleatorio = numeroAleatorio.random()
return if(resultadoAleatorio.rem(2)==0){
this.toUpperCase()
} else{
return this.toLowerCase()
}
}
En otras palabras, una funcion de extensión es una función que puede ser llamada como miembro de una clase, pero esta definida por fuera de ella

Si te familiarizas con JAVA, UNIT = VOID

Estos ejemplos sencillos me ayudaron a entender las funciones de extensión:
Si queremos que la clase Int tenga un método multiplicar para que multiplique el número sobre el que se hace la operación por el que le pasemos como parámetro solo tenemos que definir la función como hacemos normalmente pero indicando delante el nombre de la clase.

fun Int.multiplicar(numero: Int): Int {
    return this * numero;
}

Dentro de la función tenemos acceso al objeto de la clase para el que creamos la función de extensión mediante this, y por lo tanto también podemos acceder a sus propiedades y métodos porque a efectos prácticos es como si estuviésemos creando la función dentro de la clase.

Y ya podemos utilizarla como cualquier otra función de la clase, como por ejemplo Int.times() que es el método que ya tiene esta clase para multiplicar

fun main(args: Array<String>) {
    var multiplicacion = 20.multiplicar(5)
    println("El resultado de la multiplicacion es $multiplicacion == ${20.times(5)}")
    // El resultado de la multiplicacion es 100 == 100
}

También podemos crear funciones de extensión sobre listas. Otro ejemplo muy sencillo de una función sobre MutableList<Int> que sume el número pasado como parámetro a cada uno de los elementos de la lista.

fun MutableList<Int>.sumar(numero: Int): MutableList {
    var numeros = mutableListOf<Int>()
    for (i in this) {
        numeros.add(i + numero)
    }

    return numeros
}

fun main(args: Array<String>) {
    var numeros: MutableList<Int> = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    var resultado = numeros.sumar(2)

    println("La lista resultante es $resultado")
    // La lista resultante es [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
}

https://programandoointentandolo.com/2018/03/funciones-extension-kotlin.html

fun main(args: Array<String>) {
	val fraseAleatoria = "En Platzi nunca paramos de aprender"
	imprimirFrase(randomCase(fraseAleatoria))
	
}

fun

fun imprimirFrase(frase : String) : Unit {
	println("Tu frase es: $frase")
}

fun randomCase(frase : String) : String {
	// obtener numero aleatorio
	val numeroAleatorio = 0..99
	val resultadoAleatorio = numeroAleatorio.random()
	

	/*if(resultadoAleatorio.ren(2) == 0) {
		return frase.toUpperCase()
	} else {
		return frase.toLowerCase()
	}*/
	
	return if (resultadoAleatorio.ren(2) == 0) {
		frase.toUpperCase()
	} else {
		frase.toLowerCase()
	}

}

Podemos tener funciones en una sola línea

fun printWord(word: String) = println("Word is: $word")

rewriting pow function:

fun Double.pow(pot : Int) : Double {
    var r = this
    var t = r
    var p = pot
    return if (p == 0) {
        if (r == 0.0) Double.NaN else 1.0
    } else {
        if (p < 0) {
            r = 1.0 / r
            t = r
            p = -p
        }
        p -= 1
        while (p > 0) {
            r *= t
            p -= 1
        }
        r
    }
}

println((-0.5).pow(-3))

-8.0

😄

Omg las funciones de extension!, estan geniales

Si bien para programar cada quien configura su IDE de forma personal; entre ello un Dark Theme; considero que para efectos explicativos sería mejor usar temas claros; o temas que resalten el texto y código para dark mode. No solo en este curso, sino en muchos otros cursos aquí en platzi. Es mi opinión.