tipo de JavaScript
En JavaScript hay 5 tipos de datos diferentes que pueden contener valores:
string
number
boolean
object
function
Hay 6 tipos de objetos:
Object
Date
Array
String
Number
Boolean
Y 2 tipos de datos que no pueden contener valores:
null
undefined
El tipo de Operador
Puede usar el typeof
operador para encontrar el tipo de datos de una variable de JavaScript.
Ejemplo
typeof "John"
// Returns "string"
typeof 3.14
// Returns "number"
typeof NaN
// Returns "number"
typeof false
// Returns "boolean"
typeof [1,2,3,4] // Returns
"object"
typeof {name:'John', age:34}
// Returns "object"
typeof new Date()
// Returns "object"
typeof function () {} // Returns
"function"
typeof myCar
// Returns "undefined" *
typeof null
// Returns "object"
Por favor observe:
- El tipo de datos de NaN es número
- El tipo de datos de una matriz es objeto
- El tipo de datos de una fecha es objeto.
- El tipo de datos de nulo es objeto
- El tipo de datos de una variable indefinida es indefinido *
- El tipo de datos de una variable a la que no se le ha asignado un valor tampoco está definido *
No puede usar typeof
para determinar si un objeto de JavaScript es una matriz (o una fecha).
Datos primitivos
Un valor de datos primitivo es un único valor de datos simple sin propiedades ni métodos adicionales.
El typeof
operador puede devolver uno de estos tipos primitivos:
string
number
boolean
undefined
Ejemplo
typeof "John" // Returns
"string"
typeof 3.14 // Returns
"number"
typeof true // Returns
"boolean"
typeof false // Returns
"boolean"
typeof x
// Returns "undefined" (if x has no value)
Datos complejos
El typeof
operador puede devolver uno de dos tipos complejos:
function
object
El typeof
operador devuelve "objeto" para objetos, matrices y nulo.
El typeof
operador no devuelve "objeto" para funciones.
Ejemplo
typeof {name:'John', age:34} // Returns "object"
typeof [1,2,3,4]
// Returns "object" (not "array", see note below)
typeof null // Returns
"object"
typeof function myFunc(){} // Returns "function"
El typeof
operador devuelve " object
" para matrices porque en JavaScript las matrices son objetos.
El tipo de datos de typeof
El typeof
operador no es una variable. es un operador. Los operadores ( + - * / ) no tienen ningún tipo de datos.
Pero, el typeof
operador siempre devuelve una cadena (que contiene el tipo del operando).
La propiedad del constructor
La constructor
propiedad devuelve la función constructora para todas las variables de JavaScript.
Ejemplo
"John".constructor
// Returns function String() {[native code]}
(3.14).constructor
// Returns function Number() {[native code]}
false.constructor // Returns
function Boolean() {[native code]}
[1,2,3,4].constructor
// Returns function Array() {[native code]}
{name:'John',age:34}.constructor
// Returns function Object() {[native code]}
new Date().constructor
// Returns function Date() {[native code]}
function () {}.constructor // Returns
function Function(){[native code]}
Puede verificar la propiedad del constructor para averiguar si un objeto es un Array
(contiene la palabra "Array"):
Ejemplo
function isArray(myArray) {
return myArray.constructor.toString().indexOf("Array") > -1;
}
O incluso más simple, puede verificar si el objeto es una función de matriz :
Ejemplo
function isArray(myArray) {
return myArray.constructor
=== Array;
}
Puede verificar la propiedad del constructor para averiguar si un objeto es un
Date
(contiene la palabra "Fecha"):
Ejemplo
function isDate(myDate) {
return myDate.constructor.toString().indexOf("Date") > -1;
}
O incluso más simple, puede verificar si el objeto es una función de fecha :
Ejemplo
function isDate(myDate) {
return myDate.constructor === Date;
}
Indefinido
En JavaScript, una variable sin valor, tiene el valor undefined
. El tipo también lo es undefined
.
Ejemplo
let car; // Value is undefined,
type is undefined
Cualquier variable se puede vaciar, estableciendo el valor en undefined
. El tipo también será undefined
.
Ejemplo
car = undefined; // Value is undefined,
type is undefined
Valores vacíos
Un valor vacío no tiene nada que ver con undefined
.
Una cadena vacía tiene tanto un valor legal como un tipo.
Ejemplo
let car = ""; //
The value is
"", the typeof is "string"
Nulo
En JavaScript null
es "nada". Se supone que es algo que no existe.
Desafortunadamente, en JavaScript, el tipo de datos de null
es un objeto.
Puede considerarlo un error en JavaScript que typeof null
es un objeto. debería null
ser
Puede vaciar un objeto configurándolo en null
:
Ejemplo
let person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = null; //
Now value is null,
but type is still an object
También puede vaciar un objeto configurándolo en undefined
:
Ejemplo
let person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = undefined; //
Now both value and type is undefined
Diferencia entre indefinido y nulo
undefined
y null
son iguales en valor pero diferentes en tipo:
typeof undefined
// undefined
typeof null
// object
null === undefined
// false
null == undefined
// true