Solución:
Todas estas funciones se utilizan para cambiar el alcance de la función actual / la variable. Se utilizan para mantener las cosas que pertenecen juntas en un solo lugar (principalmente inicializaciones).
Aquí hay unos ejemplos:
run – devuelve todo lo que desee y cambia el alcance de la variable en la que se usa this
val password: Password = PasswordGenerator().run {
seed = "someString"
hash = {s -> someHash(s)}
hashRepetitions = 1000
generate()
}
El generador de contraseñas ahora se reescribe como this y por lo tanto podemos establecer seed, hash y hashRepetitions sin usar una variable.
generate() devolverá una instancia de Password.
apply es similar, pero volverá this:
val generator = PasswordGenerator().apply {
seed = "someString"
hash = {s -> someHash(s)}
hashRepetitions = 1000
}
val pasword = generator.generate()
Eso es particularmente útil como reemplazo del patrón Builder y si desea reutilizar ciertas configuraciones.
let – se utiliza principalmente para evitar comprobaciones nulas, pero también se puede utilizar como sustituto de run. La diferencia es que this seguirá siendo el mismo que antes y accederá a la variable rediseñada utilizando it:
val fruitBasket = ...
apple?.let {
println("adding a ${it.color} apple!")
fruitBasket.add(it)
}
El código anterior agregará la manzana a la canasta solo si no es nulo. También note que it es ahora ya no es opcional para que no se encuentre con una NullPointerException aquí (también conocido como no necesita usar ?. para acceder a sus atributos)
also – úsalo cuando quieras usarlo apply, pero no quiero ensombrecer this
class FruitBasket {
private var weight = 0
fun addFrom(appleTree: AppleTree) {
val apple = appleTree.pick().also { apple ->
this.weight += apple.weight
add(apple)
}
...
}
...
fun add(fruit: Fruit) = ...
}
Utilizando apply aquí la sombra this, así que eso this.weight se referiría a la manzana, y no a la canasta de frutas.
Nota: tomé descaradamente los ejemplos de mi blog.
Hay algunos artículos más como este y aquí que vale la pena echarle un vistazo.
Creo que se debe a cuando necesite una más corta, más concisa dentro de unas pocas líneas, y para evitar la verificación de declaraciones condicional o bifurcadas (por ejemplo, si no es nula, entonces haga esto).
Me encanta este gráfico simple, así que lo vinculé aquí. Puedes verlo en esto escrito por Sebastiano Gottardo.
Consulte también el cuadro que acompaña a mi explicación a continuación.
Concepto
Creo que es una forma de juego de roles dentro de su bloque de código cuando llama a esas funciones + si desea volver (para encadenar funciones de llamada, o establecer como variable de resultado, etc.).
Arriba está lo que pienso.
Ejemplo de concepto
Veamos ejemplos de todos ellos aquí.
1.) myComputer.apply { } significa que quiere actuar como actor principal (quiere pensar que es una computadora), y quiere volver a usted mismo (computadora) para poder hacerlo
var crashedComputer = myComputer.apply {
// you're the computer, you yourself install the apps
// note: installFancyApps is one of methods of computer
installFancyApps()
}.crash()
Sí, usted mismo solo instala las aplicaciones, se bloquea y se guarda como referencia para permitir que otros lo vean y hagan algo con él.
2.) myComputer.also {} significa que estás completamente seguro de que no son computadora, usted es un extraño que quiere hacer algo con ella, y también la quiere computadora como resultado devuelto.
var crashedComputer = myComputer.also {
// now your grandpa does something with it
myGrandpa.installVirusOn(it)
}.crash()
3.) with(myComputer) { } significa que eres el actor principal (computadora) y tú no desearte a ti mismo como resultado de vuelta.
with(myComputer) {
// you're the computer, you yourself install the apps
installFancyApps()
}
4.) myComputer.run { } significa que eres el actor principal (computadora) y tú no desearte a ti mismo como resultado de vuelta.
myComputer.run {
// you're the computer, you yourself install the apps
installFancyApps()
}
pero es diferente de with { } en un sentido muy sutil que puede llamar en cadena run { } como el siguiente
myComputer.run {
installFancyApps()
}.run {
// computer object isn't passed through here. So you cannot call installFancyApps() here again.
println("woop!")
}
Esto es debido a run {} es una función de extensión, pero with { } no es. Entonces tu llamas run { } y this dentro del bloque de código se reflejará en el tipo de objeto de la persona que llama. Puede ver esto para obtener una excelente explicación de la diferencia entre run {} y with {}.
5.) myComputer.let { } significa que usted es un extraño que mira la computadora y quiere hacer algo al respecto sin preocuparse de que la instancia de la computadora le sea devuelta nuevamente.
myComputer.let {
myGrandpa.installVirusOn(it)
}
La forma de verlo
Tiendo a mirar also y let como algo externo, externo. Cada vez que dices estas dos palabras, es como si intentaras actuar mal. let instalar virus en esta computadora, y also estrellarlo. Así que esto aclara la parte de si eres actor o no.
Para la parte de resultados, claramente está ahí. also expresa que también es otra cosa, por lo que aún conserva la disponibilidad del objeto en sí. Por lo tanto, lo devuelve como resultado.
Todo lo demás se asocia con this. Adicionalmente run/with claramente no le interesa devolver el yo-objeto. Ahora puedes diferenciarlos todos.
Creo que a veces, cuando nos alejamos del 100% de programación / ejemplos basados en la lógica, estamos en una mejor posición para conceptualizar las cosas. Pero eso depende bien 🙂
dejar, también, aplicar, tomar si, tomar a menos que son funciones de extensión en Kotlin.
Para entender estas funciones tienes que entender Funciones de extensión y Funciones lambda en Kotlin.
Función de extensión:
Mediante el uso de la función de extensión, podemos crear una función para una clase sin heredar una clase.
Kotlin, similar a C # y Gosu, brinda la capacidad de extender una clase con nueva funcionalidad sin tener que heredar de la clase o usar ningún tipo de patrón de diseño como Decorator. Esto se hace mediante declaraciones especiales llamadas extensiones. Kotlin admite funciones de extensión y propiedades de extensión.
Entonces, para encontrar si solo los números en el String, puede crear un método como el siguiente sin heredar String clase.
fun String.isNumber(): Boolean = this.matches("[0-9]+".toRegex())
puedes usar lo anterior función de extensión como esto,
val phoneNumber = "8899665544"
println(phoneNumber.isNumber)
que es impresiones true.
Funciones Lambda:
Las funciones de Lambda son como la interfaz en Java. Pero en Kotlin, las funciones lambda se pueden pasar como un parámetro en funciones.
Ejemplo:
fun String.isNumber(block: () -> Unit): Boolean {
return if (this.matches("[0-9]+".toRegex())) {
block()
true
} else false
}
Como puede ver, el bloque es una función lambda y se pasa como parámetro. Puede usar la función anterior de esta manera,
val phoneNumber = "8899665544"
println(phoneNumber.isNumber {
println("Block executed")
})
La función anterior se imprimirá así,
Block executed
true
Espero que ahora tengas una idea sobre las funciones de extensión y las funciones de Lambda. Ahora podemos ir a las funciones de extensión una por una.
dejar
public inline fun <T, R> T.let(block: (T) -> R): R = block(this)
Se utilizan dos tipos T y R en la función anterior.
T.let
T podría ser cualquier objeto como la clase String. para que pueda invocar esta función con cualquier objeto.
block: (T) -> R
En el parámetro de let, puede ver la función lambda anterior. Además, el objeto que invoca se pasa como parámetro de la función. Entonces puede usar el objeto de clase que invoca dentro de la función. luego devuelve el R (otro objeto).
Ejemplo:
val phoneNumber = "8899665544"
val numberAndCount: Pair<Int, Int> = phoneNumber.let { it.toInt() to it.count() }
En el ejemplo anterior, tomemos Cuerda como parámetro de su función lambda y devuelve Par en cambio.
De la misma manera, funciona otra función de extensión.
además
public inline fun <T> T.also(block: (T) -> Unit): T { block(this); return this }
función de extensión also toma la clase de invocación como parámetro de función lambda y no devuelve nada.
Ejemplo:
val phoneNumber = "8899665544"
phoneNumber.also { number ->
println(number.contains("8"))
println(number.length)
}
solicitar
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }
Igual que también pero el mismo objeto de invocación pasado como la función para que pueda usar las funciones y otras propiedades sin llamarlo o el nombre del parámetro.
Ejemplo:
val phoneNumber = "8899665544"
phoneNumber.apply {
println(contains("8"))
println(length)
}
Puede ver en el ejemplo anterior las funciones de la clase String invocadas directamente dentro de la función lambda.
tomar si
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? = if (predicate(this)) this else null
Ejemplo:
val phoneNumber = "8899665544"
val number = phoneNumber.takeIf { it.matches("[0-9]+".toRegex()) }
En el ejemplo anterior number tendrá una cadena de phoneNumber solo coincide con el regex. De lo contrario, será null.
tomar a menos que
public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? = if (!predicate(this)) this else null
Es lo contrario de takeIf.
Ejemplo:
val phoneNumber = "8899665544"
val number = phoneNumber.takeUnless { it.matches("[0-9]+".toRegex()) }
number tendrá una cadena de phoneNumber solo si no coincide con el regex. De lo contrario, será null.
Puede ver respuestas similares, lo cual es útil aquí, la diferencia entre kotlin también, aplicar, dejar, usar, tomarIf y tomar a menos que en Kotlin