¿Qué es el Dynamic Typing en Javascript? - El Mundo de Angular

¿Qué es el Dynamic Typing en Javascript?

En muchos lados se etiqueta a Javascript como un lenguaje de programación que «te deja hacer cualquier cosa». Uno de los motivos por el que la gente dice eso es precisamente por la característica de ser Dynamic Typing que, resumiendo, es la posibilidad de asignación dinámica (en el mismo momento en que se ejecuta nuestro código) del valor y del tipo que será contenido en una variable.

Pero… ¿qué es un tipo?

El tipo hace referencia al tipo de dato que se guardará en una variable. Como sabrás, una variable es una cajita donde se guardan cosas y una de las propiedades de esa cajita es el tipo de cosas que se pueden guardar, por ejemplo, números, palabras, booleanos, etc. Conocer el tipo de una variable es muy importante cuando desarrollamos nuestras aplicaciones ya que, dependiendo del tipo que tenga una variable, nosotros podremos hacer determinadas acciones. Por ejemplo, si una variable a fuera del tipo string (un conjunto de caracteres), una acción que podemos hacer es contar la cantidad de caracteres que tiene la misma, no así si esa variable fuera numérica, ya que no tendría sentido hacer esa misma acción.

Dynamic Typing

Volviendo al Dynamic Typing o Tipo Dinámico, en nuestro código Javascript no es necesario indicar el tipo de dato que se guardará en una variable, es más, el tipo de una variable puede ir cambiando a lo largo de nuestro programa, pudiendo la misma variable ser numérica y luego string un par de líneas mas adelante. Esto es perfectamente normal en Javascript.

El permitir este cambio de tipo todo el tiempo hace que nuestro código sea muy dinámico, pero nos puede llevar a cometer errores si no somos cuidadosos y no chequeamos el tipo de dato de nuestras variables.

Dynamic Typing vs Static Typing

Así como existe Dynamic Typing, existe su contraparte, Static Typing. Static Typing es exactamente lo opuesto, aquí uno tiene que decirle explícitamente a cada variable el tipo de dato que se va a guardar antes de usarlo.  Por ejemplo, en el lenguaje Java, para definir una cadena de caracteres, sí o sí tenemos que indicar el tipo:

String miVariable;

Otra forma de decirlo es: un lenguaje de programación es Static Typing cuando el tipo de dato de la variable que creamos es chequeado en tiempo de compilación (y por consiguiente antes de que nuestro código se ejecute). Ante cualquier intento de asignar a una variable un valor que no corresponda -por ejemplo asignarle un string a una variable de tipo numérica- el compilador nos arrojará un error para que lo corrijamos.

 

Coerción (castigando al Dynamic Typing)

Hay un concepto asociado con Dynamic Typing  que es el de coerción. Coerción hace referencia a convertir el valor de una variable de un tipo a otro, y ésto se hace muuuuuy seguido en Javascript (más de lo que imaginás).

Coerción: convertir el valor de una variable de un tipo a otro

Vos te podés estar preguntando, ¿ y para qué me sirve convertir un tipo de dato a otro? ¿para qué quiero convertir un número a un string, o viceversa?

Bueno, una de las cosas que hace que tu código no explote por los aires cuando querés hacer operaciones con dos variables de diferente tipo, es la coerción. Imagináte que tenés una variable a que vale 1 (de tipo numérico) y tenés una variable b que vale 2 (de tipo string), si sumamos a + b ¿sabés cuál es el resultado?

var a = 1;
var b = '2'
console.log(a + b); // ???

 

El resultado es «12», pero… ¡¡¡es un string!!! Sí, correcto, un string, una cadena de caracteres… y no la suma de los dos, o sea 3 (de tipo numérico) como se podría suponer.

Volvamos un paso mas atrás: cuando el motor de Javascript encuentra esta línea:

a + b

… y ve que a es de tipo numérico, y b es de tipo string, lo que hace es «convertir» (usando corción) a «algo» que tenga sentido. En este caso, es convertir la variable a al tipo string, así que convierte el número 1 al string ‘1’. Una vez que se hizo esa conversión, como ambas variables son string, lo que hace el operador «+» es concatenar ambas variables, dando como resultado «12».

Cabe aclarar que esta coerción la hace el motor de Javascript, pero en ningún momento la variable a que es numérica se convierte a string, sino que hace todo en memoria, y es el motor de Javascript el que se encarga de esto, pero para nosotros es transparente.

Cosas raras que aparecen con la coerción

Como podrás imaginar, la coerción puede hacer que pasen cosas muy raras en nuestro código, ya que hay una «transformación» de datos que se hace automáticamente por el motor de Javascript, sin siquiera preguntarnos. Y si no me creés, mirá estos ejemplos.

Para vos, ¿qué  se imprime en la consola?




var a = 1;
if (a) {
    console.log('es verdadero')
} else {
    console.log('es falso')
}


Esto imprime en consola ‘es verdadero’, pero…  ¿por qué?, porque cuando se convierte el valor 1 (numérico) a un tipo boolean, se convierte a true.
Y ahora, este código ¿qué imprime? (fijáte que a no tiene valor, así que se crea con el valor undefined)

var a;
if (a) {
    console.log('es verdadero')
} else {
    console.log('es falso')
}

En este caso, a es undefined; y por coerción, al convertir undefined a tipo boolean, esto da falso, y se termina imprimiendo en consola ‘es falso’.
Un ejemplo mas, ¿qué pasa si la variable a vale » (una string vacío)?

var a = '';
if (a) {
    console.log('es verdadero')
} else {
    console.log('es falso')
}
Esto también imprime ‘es falso’, porque convertir un string vacío al tipo boolean por coerción, da como resultado «falso».

Mini tabla resumen

Acá les dejo una pequeña tabla con algunas conversiones que hace Javascript para que se den una idea:

string boolean número
0 (cero numérico) ‘0’ false LO MISMO
» (string vacio) LO MISMO false 0
false (boolean falso) ‘false’ LO MISMO 0
true (boolean true) ‘true’ LO MISMO 1
1 (uno numérico) ‘1’ true LO MISMO
‘a’ (un string con un valor no vacío) LO MISMO true NaN (not a number)
‘1’ (un string con un valor numérico) LO MISMO true 1 (o el valor numérico que represente)

 

Una de las cosas «raras» que podemos ver en la tabla es que si convertimos una cadena vacía (»), o el  número 0 a boolean, esto da falso.

Si convertimos un número 1 (de hecho un número distinto de cero) o un string distinto de vacío, a boolean, éste se convierte a true.

También vemos que si convertimos un string (que representa un valor NO numérico) a un número, éste se convierte en NaN. Este valor significa No Numérico y es una palabra reservada en Javascript.

Por el contrario, si convertimos un string (que representa un valor numérico) a un número, éste se convierte en su representación numérica.

Por último, vemos que true a valor numérico se convierte en 1, y false a valor numérico se convierte en 0.

Conclusión

Como podés ver, algunas transformaciones de un tipo a otro son muy raras y poco intuitivas. Es necesario conocer estas transformaciones, o sea, qué hace Javascript por atrás, para evitar bugs, o comportamientos no deseados.
Te animo a abrir la consola de desarrollo de tu browser y a seguir haciendo pruebas de coerción por tu cuenta, vas a ver que no todo lo que creías que es convertir de un tipo a otro, es lo que esperabas. ¡Suerte!

About the Author

Mi nombre es Gustavo Hernán Dohara, soy Ingeniero en Sistemas y, sobre todas las cosas, soy un apasionado por la tecnología; tengo más de 10 años de experiencia en diferentes tecnologías y he decidido compartir mis conocimientos y experiencias con cualquiera que desee aprender: alumnos, empleados, freelancers y vos. Al ritmo que cada uno pueda, en el horario en que cada uno pueda y en el lugar que cada uno elija.