La deducción de tipo de variable por contexto es una característica moderna de varios lenguajes de programación que permite a los compiladores o intérpretes inferir automáticamente el tipo de una variable basado en el contexto en el que se declara.
La elección entre lenguajes tipados y no tipados ha sido un tema de debate constante en el ámbito de la programación (y ya aburre más que llevar un camello en brazos 🐫).
Una de las ventajas innegables de los lenguajes con tipado dinámico como JavaScript o Python es que la sintaxis es más concisa y sencilla, al evitar tener que especificar el tipo de las variables que creamos.
Sin embargo, a medida que los lenguajes de programación evolucionan, también han surgido mecanismos que buscan simplificar la verbosidad de los lenguajes tipados, sin sacrificar la seguridad y robustez que proporciona el tipado.
Así, lenguajes como C# y C++, se utiliza la palabra reservada var
o auto
, respectivamente, para indicarle al compilador que queremos que deduzca el tipo de la variable durante la compilación.
La deducción de tipo por contexto permite declarar variables en lenguajes tipados casi tan cómodo como en lenguajes no tipados.
De hecho, los lenguajes “no tipados” internamente sí están tipados. Simplemente hacen uso muy intensivo de estos mecanismos.
Ejemplos de deducción de tipo en distintos lenguajes
Veamos unos ejemplos de deducción de tipo por contexto en diferentes lenguajes de programación.
En C#, la palabra clave var
se utiliza para deducir el tipo de una variable en función de la expresión de inicialización.
var numero = 42; // El compilador deduce que 'numero' es de tipo int
var texto = "Hola, mundo"; // El compilador deduce que 'texto' es de tipo string
var lista = new List<string> { "uno", "dos", "tres" }; // El compilador deduce que 'lista' es de tipo List<string>
En C++, la palabra clave auto
se usa para indicar que el tipo de la variable debe deducirse del valor de inicialización. Esto es especialmente útil para tipos largos o complicados.
auto numero = 42; // El compilador deduce que 'numero' es de tipo int
auto texto = std::string("Hola, mundo"); // El compilador deduce que 'texto' es de tipo std::string
auto lista = std::vector<std::string>{"uno", "dos", "tres"}; // El compilador deduce que 'lista' es de tipo std::vector<std::string>
En JavaScript, la deducción de tipos es implícita y no requiere palabras clave especiales. El tipo de una variable se infiere automáticamente basado en el valor asignado.
let numero = 42; // El intérprete deduce que 'numero' es de tipo Number
let texto = "Hola, mundo"; // El intérprete deduce que 'texto' es de tipo String
let lista = ["uno", "dos", "tres"]; // El intérprete deduce que 'lista' es de tipo Array
En Python, los tipos de variables se infieren automáticamente en el momento de la asignación. No es necesario especificar el tipo, ya que Python es un lenguaje de tipado dinámico.
numero = 42 # Python deduce que 'numero' es de tipo int
texto = "Hola, mundo" # Python deduce que 'texto' es de tipo str
lista = ["uno", "dos", "tres"] # Python deduce que 'lista' es de tipo list
Buenas prácticas Consejos
La deducción de tipo por contexto reduce el código repetitivo, y evita la redundancia de tener que el tipo explícitamente, cuando ya es evidente por la asignación.
Además, mejora la legibilidad del código. Por ejemplo, consideremos el siguiente caso en C#.
// es más sencillo de leer
var lista = new List<string> { "uno", "dos", "tres" };
// que esto
List<string> lista = new List<string> { "uno", "dos", "tres" };
Por otro lado, también facilita el mantenimiento. Al no depender de una declaración explícita, los cambios en los tipos de datos propagados automáticamente si la asignación inicial cambia.
Por ejemplo, si tenemos una función que devuelve un tipo,
// método que devuelve un objeto de tipo miClase
miClase DoSomething()
{
// ... contenido de la función
}
// muchas línas más abajo, crear un objeto con el método
var miObjeto = DoSomething();
Si en algún momento alguien cambia DoSomething
para que devuelva otra cosa (por ejemplo, ImiInterface
, no es necesario cambiar var miObjeto = DoSomething();
, los cambios se “propagan” automáticamente.
Sin embargo, también hay muchos detractores de la deducción de tipo por contexto. Sobre todo la gente que está muy acostumbrada a la programación con lenguajes fuertemente tipados tradicional.
Así, se suele aconsejar que no se emplee en situaciones donde el tipo no es obvio. Por ejemplo,
// aqui es obvio el tipo
var miLista = new List<string>();
// aqui no es obvio el tipo
List<string> miLista = miMetodo();
Al final la decisión es vuestra. Personalmente, recomiendo usar la deducción de tipo por contexto hasta en la sopa. Pero no es una verdad absoluta. Lo mejor es que hagáis vuestro propio criterio.