Tipos de datos básicos: boolean, number y string

En la vida todo es cuestión de letras, números, verdades y mentiras. En JavaScript también.

En este capítulo vamos a ver los tres tipos básicos que soporta JS: Boolean, Number y String.

Veremos también cómo consultar el tipo de una variable, constante o valor literal así como los diferentes modos de convertir unos valores en otros. Los operadores y comparadores quedan fuera de este capítulo y se verán en capítulos próximos dentro de esta unidad temática.

Conversión a string
Conversión a number

El valor especial NaN

Conversión a boolean

Objetivos conseguidos
Próximos pasos

Cómo considerar los tipos básicos

Los valores de tipo Boolean, Number y String son considerados en JS objetos inmutables: Pueden crearse, algunos tienen propiedades y métodos, pero...

ninguna propiedad o método permite cambiar el valor del objeto
y no se puede agregar propiedades o métodos a estos objetos

De momento ni caso a lo anterior, lo vamos a ver en detalle tal como avance el capítulo.

El operador `typeof`

Antes de meternos en harina es necesario presentar al operador typeof, que devuelve una cadena indicando el tipo de una variable, constante o valor literal:

// Imprime la cadena "boolean"
console.log(typeof true)

// Imprime la cadena "number"
const zero = 0
console.log(typeof zero)

// Imprime la cadena "string"
const helloWorld = "Hola, mundo!"
console.log(typeof helloWorld)

// Imprime la cadena "object"
console.log(typeof console)

// Imprime la cadena "function"
console.log(typeof console.log)

`Boolean`

Los objetos Boolean nos permiten manejar valores lógicos true y false:

// Crea una constante de tipo Boolean 
// y le asigna el valor literal true
const booleanConstant = true

// Crea una variable de tipo Boolean con valor false
// invocando al constructor de la clase Boolean
let booleanVariable = Boolean(false)

// Imprime cuatro veces "boolean" en la salida estándar
console.log(typeof Boolean(true))
console.log(typeof false)
console.log(typeof booleanConstant)
console.log(typeof booleanVariable)

// Imprime "true" y "false"
console.log(booleanConstant)
console.log(booleanVariable)

Puede que, en el ejemplo anterior, te parezca extraño que se crée un booleano invocando al constructor de la clase (Boolean(false)). En realidad es absurdo crearlo de ese modo cuando se podía haber usado el literal false.

El uso del constructor se expone solamente para que sepas que exista, pero realmente su uso cobra sentido cuando queremos crear valores booleanos a partir de valores de otro tipo. Veremos más sobre esto en la sección "Conversión entre tipos básicos".

`Number`

Los objetos Number nos permiten manejar valores enteros y reales. Hay distintos modos de definir valores númericos, como muestra el siguiente ejemplo:

// Distintas formas de definir valores numéricos
// Enteros
const one = 1
const minusOne = -1

// Coma flotante
const threeDotOne = 3.1
const threeDotTwo = 32e-1

// A partir de literales hexadecimales o binarios
const ten = 0xA
const four = 0b100

// A partir del constructor de la clase
const two = Number(2)

Como es de esperar, el operador typeof devolverá "number" para cualquiera de las constantes arriba creadas.

Y como es de esperar, no tiene sentido alguno en este contexto definir un número a partir del constructor de la clase (Number(2)) y solamente se expone por motivos pedagógicos. Como en el caso de Boolean(), el uso del constructor Number() cobra pleno sentido cuando queremos crear valores numéricos a partir de valores de otro tipo.

`String`

Los objetos String nos permiten manejar cadenas de texto. Como en el caso de Number, podemos crear objetos de tipo String de distintos modos:

// Distintas formas de definir cadenas
// Con literales entre comillas
// dobles o simples
const fooStr = "foo"
const barStr = 'bar'

// A partir de literales de plantilla
const fooAndBar = `${fooStr} and ${barStr}`
// Imprime "foo and bar"
console.log(fooAndBar)

// Incluyendo caracteres especiales
const fooTabBar = "foo\tbar"
// Imprime "foo	bar" (con una tabulación)
console.log(fooTabBar)

// Incluyendo literales en unicode
const thisIsAnA = "This is an \u0041"
// Imprime "This is an A"
console.log(thisIsAnA)

// A partir de constructor de la clase
const helloWorld = String("Hola, mundo!")
// Imprime "Hola, mundo!"
console.log(helloWorld)

Algunas cosas a aclarar de los ejemplos anteriores:

No hay ninguna diferencia entre usar comillas simples o dobles. Lo anterior no aplica a la comilla simple invertida o backtick (símbolo `), que se utiliza para definir literales de plantilla
Los códigos unicode siempre se expresan como valores hexadecimales de 16 bits (en el ejemplo anterior 0041)
Como en los casos de los anteriores constructores, el uso del constructor (String()) cobra sentido al crear una cadena a partir de un valor de otro tipo

Todas las expresiones typeof con las constantes anteriormente definidas devolverán una cadena con el valor "string":

// Imprime "string"
const fooStr = "foo"
console.log(typeof fooStr)

Conversión entre tipos básicos

En esta sección vamos a analizar cómo definir los tipos anteriormente presentados a partir de literales, variables o constantes de otros tipos

Conversión a `string`

Podemos convertir cualquier de los tipos boolean o number a un valor de tipo string utilizando o bien el constructor de la clase String o bien un literal de plantilla, tal como se muestra en los siguientes ejemplos:

// Convertir un boolean en string
const trueString = String(true)
console.log(typeof trueString)	// Imprime "string"
console.log(trueString)		// Imprime "true"

const falseString = `${false}`
console.log(typeof falseString)	// Imprime "string"
console.log(falseString)	// Imprime "false"

// Convertir un number en string
const threeDotOne = 3.1
const threeDotOneStr = String(threeDotOne)
console.log(typeof threeDotOneStr) // Imprime "string"
console.log(threeDotOneStr)	   // Imprime "3.1"

const five = 5
const fiveStr = `${five}`
console.log(typeof fiveStr)	// Imprime "string"
console.log(fiveStr)		// Imprime "5"

Sin embargo, estos dos no son los únicos métodos de conversión. Si recuerdas, dijimos que JS considera los tipos básicos como clases, y como tales son susceptibles de tener propiedades y métodos.

Efectivamente, tanto la clase Boolean como la clase Number definen el método toString() que permite convertir su valor en su representación de texto:

// Convertir un boolean en string
// usando el método toString()
const trueString = true.toString()
console.log(typeof trueString)	// Imprime "string"
console.log(trueString)		// Imprime "true"

const falseBool = false
const falseString = falseBool.toString()
console.log(typeof falseString)	// Imprime "string"
console.log(falseString)	// Imprime "false"

// Convertir un number en string
// usando el método toString()
const threeDotOneStr = (3.1).toString()
console.log(typeof threeDotOneStr) // Imprime "string"
console.log(threeDotOneStr)	   // Imprime "3.1"

const five = 5
const fiveStr = five.toString()
console.log(typeof fiveStr)	// Imprime "string"
console.log(fiveStr)		// Imprime "5"

Conversión a `number`

La conversión de un valor a su representación numérica puede realizarse mediante el constructor de la clase Number y mediante el operador unario +, tal como muestran los siguientes ejemplos:

// Convertir un boolean en number
const zero = Number(false)
console.log(typeof zero)	// Imprime "number"
console.log(zero)		// Imprime "0"

const one = +true
console.log(typeof one)	// Imprime "number"
console.log(one)		// Imprime "1"

// Convertir un string en number
const anotherZero = Number("")
console.log(typeof zero)	// Imprime "number"
console.log(zero)		// Imprime "0"

const threeDotOne = +"3.1"
console.log(typeof one)	// Imprime "number"
console.log(one)		// Imprime "3.1"

JS define además dos funciones para la conversión de cadenas en números, parseInt() y parseFloat(), que convierten en números expresiones enteras y en coma flotante respectivamente:

// parseInt
const zero = parseInt("0")
console.log(typeof zero)	// Imprime "number"
console.log(zero)		// Imprime "0"

// Trunca la parte decimal
const four = parseInt("4.3")
console.log(typeof four)	// Imprime "number"
console.log(four)		// Imprime "4"

// Convierte hasta encontrar
// caracteres no numéricos
const ten = parseInt("10 Hola, mundo!")
console.log(typeof ten)	// Imprime "number"
console.log(four)	// Imprime "10"

// Convierte desde representaciones
// binarias (base 2) o hexadecimales (base 16)
const five = parseInt("100", 2)
console.log(five)		// Imprime "5"
const fifteen = parseInt("F", 16)
console.log(fifteen)		// Imprime "15"
const thirty = parseInt("0x1E", 16)
console.log(thirty)		// Imprime "30"

// parseFloat
// Todas estas líneas imprimen "3.14"
console.log(parseFloat("3.14"))
console.log(parseFloat(" 3.14"))
console.log(parseFloat("314e-2"))
console.log(parseFloat("0.0314E+2"))
console.log(parseFloat("3.14Hola, mundo!"))

Te invito a que juegues con node en modo REPL tal como explicamos en el capítulo Node.JS y pruebes a convertir en número distintas cadenas, como una conteniendo espacios u otra conteniendo números en coma flotante separados por el símbolo "," en lugar del símbolo "."

Tarde o pronto obtendrás un extraño valor NaN, que se presenta en la siguiente sección.

El valor especial `NaN`

El valor especial NaN responde a la necesidad de tener un valor que represente el valor de conversiones no factibles a number, como por ejemplo la conversión de la cadena Hola, mundo! a un número.

// El valor especial NaN
const notANumber = Number("Hola, mundo!")
console.log(typeof notANumber)	// Imprime "number"
console.log(notANumber)		// Imprime "NaN"

Paradójicamente, como muestra el ejemplo anterior el valor NaN (del inglés Not a Number) es considerado por JS como de tipo number.

Suficiente por ahora sobre NaN, volveremos a este valor especial en el capítulo dedicado a los operadores de comparación.

Conversión a `boolean`

Podemos convertir un valor numérico o de tipo cadena en un boolean utilizando el constructor de la clase Boolean o el operador unario !!:

// Conversión de number en boolean
const trueValue = Boolean(1)
const falseValue = !!0
console.log(typeOf trueValue)	// Imprime "boolean"
console.log(falseValue)		// Imprime "false"

// Conversión de string en boolean
const truthy = !!"Cualquier cadena no vacía"
const falsy = Boolean("")
console.log(typeOf truthy)	// Imprime "boolean"
console.log(falsy)		// Imprime "false"

Los ejemplos anteriores ilustran bastante bien las reglas de conversión de números y cadenas a valores booleanos, pero por si acaso vamos a definirlas:

Un valor numérico 0 se considera false, cualquier otro valor numérico se considera true
Una cadena vacía se considera false, cualquier otra cadena (ncluyendo la cadena "false") se considera true

Objetivos conseguidos

En este extenso capítulo hemos presentado los tipos datos básicos de JS, boolean, number y string y has aprendido a definirlos como literales, constantes y variables.

Has aprendido también a consultar el tipo de una variable mediante el uso del operador typeof

Finalmente has aprendido a fondo cómo convertir literales, variables y constantes entre tipos básicos.

Próximos pasos

En el próximo capítulo cubriremos algunos tipos y valores especiales de JS que no hemos abordado en este capítulo por falta de espacio o que hemos tratado de modo incompleto.

Aprendiendo JavaScript

Buscar este blog