Constantes en Kotlin: ¿cuál es la forma recomendada de crearlas?
¿Cómo se recomienda crear constantes en Kotlin? ¿Y cuál es la convención de nomenclatura? No encontré eso en la documentación.
companion object {
//1
val MY_CONST = "something"
//2
const val MY_CONST = "something"
//3
val myConst = "something"
}
O ...?
Evite el uso de objetos complementarios. Debajo del capó, se crean métodos de instancia getter y setter para que los campos sean accesibles. Llamar a métodos de instancia es técnicamente más caro que llamar a métodos estáticos.
public class DbConstants {
companion object {
val TABLE_USER_ATTRIBUTE_EMPID = "_id"
val TABLE_USER_ATTRIBUTE_DATA = "data"
}
En su lugar, defina las constantes en object.
Práctica recomendada :
object DbConstants {
const val TABLE_USER_ATTRIBUTE_EMPID = "_id"
const val TABLE_USER_ATTRIBUTE_DATA = "data"
}
y acceder a ellos globalmente así:
DbConstants.TABLE_USER_ATTRIBUTE_EMPID
En Kotlin, si desea crear constantes locales que se supone que deben usarse dentro de la clase, puede crearlas como se muestra a continuación:
val MY_CONSTANT = "Constants"
Y si desea crear una constante pública en Kotlin como public static final en Java, puede crearla de la siguiente manera:
companion object {
const val MY_CONSTANT = "Constants"
}
En primer lugar , la convención de nomenclatura en Kotlin para las constantes es la misma que en Java (por ejemplo: MY_CONST_IN_UPPERCASE).
¿Cómo debo crearlo?
1. Como valor de nivel superior (recomendado)
Sólo tienes que poner tu constante fuera de tu declaración de clase.
Dos posibilidades : declara tu constante en tu archivo de clase (tu constante tiene una relación clara con tu clase)
private const val CONST_USED_BY_MY_CLASS = 1
class MyClass {
// I can use my const in my class body
}
Cree un archivo constantes.kt dedicado donde almacenar esas constantes globales (aquí desea utilizar su constante ampliamente en todo su proyecto):
package com.project.constants
const val URL_PATH = "https:/"
Luego sólo tienes que importarlo donde lo necesites:
import com.project.constants
MyClass {
private fun foo() {
val url = URL_PATH
System.out.print(url) // https://
}
}
2. Declararlo en un objeto complementario (o una declaración de objeto)
Esto es mucho menos limpio porque bajo el capó, cuando se genera el código de bytes, se crea un objeto inútil:
MyClass {
companion object {
private const val URL_PATH = "https://"
const val PUBLIC_URL_PATH = "https://public" // Accessible in other project files via MyClass.PUBLIC_URL_PATH
}
}
Peor aún si lo declaras como val en lugar de constante (el compilador generará un objeto inútil + una función inútil):
MyClass {
companion object {
val URL_PATH = "https://"
}
}
Nota :
En Kotlin, const solo puede contener tipos primitivos. Si desea asignarle el resultado de llamar a una función, debe agregar la anotación @JvmField. En el momento de la compilación, se transformará en una variable final estática pública. Pero es más lento que con un tipo primitivo. Intenta evitarlo.
@JvmField val foo = Foo()
Los valores conocidos en el momento de la compilación pueden (y en mi opinión deberían) marcarse como constantes.
Las convenciones de nomenclatura deben seguir las de Java y deben ser visibles correctamente cuando se usan desde código Java (de alguna manera es difícil lograrlo con objetos complementarios, pero de todos modos).
Las declaraciones constantes adecuadas son:
const val MY_CONST = "something"
const val MY_INT = 1
No necesitas una clase, un objeto o un objeto complementario para declarar constantes en Kotlin. Puede simplemente declarar un archivo que contenga todas las constantes (por ejemplo, Constants.kt o también puede colocarlos dentro de cualquier archivo Kotlin existente) y declarar directamente las constantes dentro del archivo. Las constantes conocidas en tiempo de compilación deben estar marcadas con const.
Entonces, en este caso debería ser:
const val MY_CONST = "something"
y luego puedes importar la constante usando:
import package_name.MY_CONST
Puedes consultar este enlace .
