Objetos de envoltura en JavaScript (Wrapper objects)

Por Darío Rivera

Publicado el 2020-08-15 en Javascript

Las objetos de envoltura o wrapper objects, son objetos que representan un tipo primitivo de dato. Es decir, son un tipo de referencia que envuelve un tipo primitivo. Cada tipo de dato primitivo tiene un tipo de referencia (excepto null y undefined) que lo envuelve. Veamos a continuación la siguiente tabla.

Data type	Wrapper class
Boolean	Boolean
Number	Number
BigInt	BigInt
String	String
Symbol	Symbol

Cada uno de estos objetos nos ayudará a convertir un valor a ese tipo específico. Esto también es conocido como coerción explícita (explicit coercion). Veamos cada una en detalle.

Boolean

Para convertir un dator a número basta utilizar el objeto Boolean y pasarle como parámetro el valor a convertir.

let b = 1;
let c = Boolean(b);  // true
typeof c;            // boolean

A continuación verás la conversión aplicada con este objeto a algunos valores de referencia.

Valor o Tipo	Conversión
`undefined`	`false`
`null`	`false`
`1`	`true`
`0`	`false`
`''`	`false`
`[]`	`true`
`{}`	`true`

Cualquier string distinto de vacío será interpretado como true, incluso un string con espacios. Este wrapper object es muy importante ya que nos ayuda a entender cómo funciona la coerción dentro de una condición if, para efectos de JavaScript, podemos simular el comportamiento de un if con este wrapper object. Para ver un poco más a detalle la coerción en JavaScript, te invito a ver nuestro artículo Coerción o conversión de valores comunes a Booleano en JavaScript.

Number

Para convertir un dato a número basta utilizar el objeto Number y pasarle como parámetro el valor a convertir.

let c = '4';
let num = Number(c);  // 4
typeof num;           // number

A continuación verás la conversión aplicada con este objeto a algunos valores de referencia.

Valor o Tipo	Conversión
`undefined`	`NaN`
`null`	`0`
`true`	`1`
`false`	`0`
`''`	`0`
`[]`	`0`
`{}`	`0`

Para cualquier string el wrapper object eliminará los espacios vacío antes y después del string e intentará interpretar el número resultante. Si no es posible leer el número se retornará NaN.

BigInt

Para convertir un dato a bigint basta utilizar el objeto BigInt y pasarle como parámetro el valor a convertir.

let n = '4';
let big = BigInt(n);  // 4n
typeof big;           // bigint

A continuación verás la conversión aplicada con este objeto a algunos valores de referencia.

Valor o Tipo	Conversión
`undefined`	Syntax error
`null`	Syntax error
`true`	`1n`
`false`	`0n`
`''`	`0n`
`[]`	`0n`
`{}`	Syntax error

Como puedes darte cuenta no en todos los casos es posible convertir a bigint. Por otro lado, Cualquier string que pueda ser interpretado como entero será convertido a BigInt.

String

Para convetir un dato a string basta utilizar el objeto Number y pasarle como parámetro el valor a convertir.

let n = 4;
let s = String(n);  // '4'
typeof n;           // string

A continuación verás la conversión aplicada con este objeto a algunos valores de referencia.

Valor o Tipo	Conversión
`undefined`	`'undefined'`
`null`	`'null'`
`1`	`'1'`
`0`	`'0'`
`true`	`'true'`
`false`	`'false'`
`[]`	`''`
`{}`	`'[Object Object]'`

Como ves resulta casi intuitivo saber cómo se convetirá un valor determinado a string.

Symbol

Para convetir un dato a symbol basta utilizar el objeto Symbol y pasarle como parámetro el valor a convertir.

let num = '4';
let sym = Symbol(num);  // Symbol(4)
typeof sym;             // symbol

A continuación verás la conversión aplicada con este objeto a algunos valores de referencia.

Valor o Tipo	Conversión
`undefined`	`Symbol()`
`null`	`Symbol(null)`
`1`	`Symbol(1)`
`0`	`Symbol(0)`
`true`	`Symbol(true)`
`false`	`Symbol(false)`
`[]`	`Symbol()`
`{}`	`Symbol([Object Object])`