Tipado fuerte y débil. Tipado estático y dinámico.

Todo esto del tipado en los lenguajes de programación es algo que más o menos creía tener claro y que seguramente es lo más básico de cualquier carrera de informática actual, pero yo ya tengo mis añitos, no he estudiado estas cosas y al buscar lenguajes para aprender, he visto que hay una sutil diferencia entre tipado estático y dinámico así como tipado fuerte y débil. Vamos a ello.

Tipado Estático y Tipado Dinámico

En un lenguaje con tipado estático, las variables llevan asociado el tipo de dato y no se puede cambiar. En los lenguajes de tipado dinámico, el tipo va más bien asociado al valor de la variable y no a la variable en sí misma, por lo que una misma variable puede contener a lo largo de la ejecución distintos tipos de datos.

Con tipado estático, es el mismo compilador el que comprueba que se asignan valores correctos a las variables, ya que sabe de qué tipo son las variables y qué tipo de valores pueden admitir.

Con tipado dinámico, esta comprobación debe hacerse en tiempo de ejecución. Podemos meter en cualquier variable cualquier tipo de dato, por lo que hasta la ejecución no se sabe qué tipo de valor tiene una variable.

La ventaja del tipado estático es que se pueden evitar muchos errores en tiempo de compilación, sin necesidad de esperar a la ejecución para verlos. La ventaja del tipado dinámico es su flexibilidad.

Tipado Fuerte y Tipado Débil

No parece haber un consenso claro de lo que es fuertemente tipado y débilmente tipado, pero parece que la idea más general es si el lenguaje permite cambiar unos tipos por otros de forma más o menos automática, no lo permite o sólo si el programador lo hace de forma explícita. Veamos ejemplos de tipado fuerte y débil

En javascript podemos hacer esto sin problemas

var a=3;
var b=»4″;
var c=a+b;

es decir, guardamos un entero en a, una cadena en b y luego las sumamos. Javascript, sin consultar con nadie, hace una conversión del entero 3 en cadena «3» y suma las cadenas, dando como resultado en c la cadena «34».

En java, también podemos hacer algo parecido

int a = 3;
String b = «4»;
String c = a+b;

dando como resultado una cadena «34»

Vemos que ambos lenguajes son débilmente tipados (entre comillas), pero java es estáticamente tipado ya que es necesario declarar los tipos de las variables, y javascript es dinámicamente tipado, ya que no es necesario.

La afirmación de que ambos son «débilmente tipados«, hay que tomarla entre comillas. Javascript es más débilmente tipado porque siempre intenta hacer las conversiones necesarias para que el código se ejecute sin problemas, aunque a veces los resultados son sorprendentes.

Java en este caso de sumar entero y String es débilmente tipado, pero solo para cositas muy concretas. Convierte tipos a String cuando lo necesita, pero poco más. Por ejemplo, en javascript todo esto es válido

if («0″==0)  // es true
if («0»)  // es true
if (0) // es false
if («») // es false
if («3″==3) // es true

es decir, convierte String a integer para hacer las comparaciones, convierte 0 en false, convierte «» en false en el cuarto caso, etc, etc. Java daría error con cualquiera de estos if, por lo que no es tan débilmente tipado como javascript.

La ventaja de un lenguaje dinámicamente tipado es evidente, ahorra muchas conversiones explícitas que en algunos casos pueden ser muy tediosas. Sin embargo, la pega es que requiere un conocimiento profundo de cómo se hacen esas conversiones, o podemos encontrarnos con errores inesperados al realizarse alguna conversión que no esperamos.