titulo seo

indice

Tipos y tipado dinamico
Tipado debil
Coercion de tipos
Evitar la coercion de tipos

Tipos y tipado dinamico

string number object undefined function

El tipado de javascript es dinamico porque no se establecen tipos en tiempo de compilacion sino de ejecucion, es decir una variable en javascript puede almacenar cualquier valor y su tipo sera una inferencia sobre dicho valor

Esto puede ser un peligo para programadores que vengan con lenguajes de tipado estatico como java

tipado debil

No solo es de tipado dinamico sino tambien debil , es decir cuando declaramos las variables no es necesario asociarles un tipo de dato, ni inicialmente un valor.

las variables son declaradas su ningun tipo, y este depende exclusivamente del tipo del valor que almacene alli.

Hay que tener en cuenta que los valores pueden modificarse e incluso operar entre ellos sin necesidad de realizar una conversion previa, es decir siendo de tipos distintos, esto se debe a la coercion de tipos en javascript

var suma = 32 + '32'
suma // 64

Coercion de tipos

es un proceso implicito de convertir un tipo de dato a otro tipo diferente, es decir se pasa de number a string sin que nosotros de manera implicita hayamos echo un casting del string.

existe dos clases de coercion de tipos, la coercion explicita(o casting) y la coercion implicita que realiza javascript por tener un tipado debil o dinamico, en el que ninguna variable tiene de entrada un tipo de dato asociado.

Por defecto en javascript se realizan solo 3 conversiones: a string, a number o a boleans

Coercion de tipos a string

La conversion explicita se realiza mediante la funcion String()

String(123) // '123'
String(-123) // '-123'
String(null) // 'null'
String(undefined) // 'undefined'
String(false) // 'false'

En cuanto a los objetos y los tipo Number tienen un metodo llamado toString() para coercion explicita

let numero = 123
num.toString(numero) // '123'

const object = {
  id: 33243,
  name: 'Markos',
  image: "avatar.png"
}
object.toString() // [object Object]

La coercon implicita ocurre siempre que usemos el operador suma(+), con un string y otro tipo

123 + 'string' // '123string'
'123' + 123  // '123123'

Javascript entiende por dentro que debe hacer una concatenacion, que es el proceso mas probable de un string con otro tipo.

Coercion de tipos: Boolean

La coercion explicita se realiza mediante la funcion Boolean()

Es mejor recordar los valores que devuelven false:

Boolean(); // false
Boolean(0); // false
Boolean(-0); // false
Boolean(''); // false
Boolean(NaN); // false
Boolean(null); // false
Boolean(false); // false
Boolean(undefined); // false

ya que todos los otros valores corresponderian a true:

Boolean([]); // true
Boolean({}); // true
Boolean(true); // true
Boolean('true'); // true
Boolean('false'); // true
Boolean('Su Lin'); // true

en cuanto a la coercion implicita depende del contexto o del operador, el operador negacion(!) siempre forzara el casting al valor booleano opuesto

if(2) {....} // se evalua true
!!2 // true
2 || 'false' // true, devuelve 2

Mi blog