Javascript教程

Appearance

JavaScript typeof ​

typeof 运算符的概念 ​

typeof 运算符用于返回变量或表达式的类型。它是一个一元运算符，只需要一个操作数。

typeof 运算符的语法 ​

javascript
typeof operand

或者

javascript
typeof(operand)

其中 operand 是要检查类型的变量或表达式。

typeof 运算符的返回值 ​

操作数类型typeof 返回值示例
数字"number"typeof 42
字符串"string"typeof "Hello"
布尔值"boolean"typeof true
对象"object"typeof {}
数组"object"typeof []
null"object"typeof null
undefined"undefined"typeof undefined
函数"function"typeof function() {}
Symbol"symbol"typeof Symbol()
BigInt"bigint"typeof 1n

typeof 运算符的示例 ​

1. 基本类型 ​

javascript
console.log(typeof 42); // 输出: number
console.log(typeof 3.14); // 输出: number
console.log(typeof NaN); // 输出: number
console.log(typeof Infinity); // 输出: number

console.log(typeof "Hello"); // 输出: string
console.log(typeof 'World'); // 输出: string
console.log(typeof ``); // 输出: string

console.log(typeof true); // 输出: boolean
console.log(typeof false); // 输出: boolean

console.log(typeof undefined); // 输出: undefined

console.log(typeof Symbol()); // 输出: symbol
console.log(typeof Symbol('description')); // 输出: symbol

console.log(typeof 1n); // 输出: bigint
console.log(typeof 9007199254740991n); // 输出: bigint

2. 对象类型 ​

javascript
console.log(typeof {}); // 输出: object
console.log(typeof []); // 输出: object
console.log(typeof new Object()); // 输出: object
console.log(typeof new Array()); // 输出: object
console.log(typeof new Date()); // 输出: object
console.log(typeof /regex/); // 输出: object

console.log(typeof null); // 输出: object（这是一个历史遗留问题）

console.log(typeof function() {}); // 输出: function
console.log(typeof class {}); // 输出: function

3. 表达式 ​

javascript
console.log(typeof (1 + 2)); // 输出: number
console.log(typeof ("Hello" + " World")); // 输出: string
console.log(typeof (true && false)); // 输出: boolean
console.log(typeof ({})); // 输出: object
console.log(typeof (function() {})); // 输出: function

4. 变量 ​

javascript
let num = 42;
let str = "Hello";
let bool = true;
let obj = {};
let arr = [];
let func = function() {};
let undef;
let nul = null;
let sym = Symbol();
let big = 1n;

console.log(typeof num); // 输出: number
console.log(typeof str); // 输出: string
console.log(typeof bool); // 输出: boolean
console.log(typeof obj); // 输出: object
console.log(typeof arr); // 输出: object
console.log(typeof func); // 输出: function
console.log(typeof undef); // 输出: undefined
console.log(typeof nul); // 输出: object
console.log(typeof sym); // 输出: symbol
console.log(typeof big); // 输出: bigint

typeof 运算符的特殊情况 ​

1. null 的类型 ​

typeof null 返回 "object"，这是一个历史遗留问题。在 JavaScript 最初的实现中，null 被认为是一个空对象指针，因此 typeof null 返回 "object"。

javascript
console.log(typeof null); // 输出: object

// 正确检查 null 的方法
console.log(null === null); // 输出: true
console.log(obj === null); // 检查对象是否为 null

2. 数组的类型 ​

typeof [] 返回 "object"，因为数组在 JavaScript 中是对象的一种特殊类型。

javascript
console.log(typeof []); // 输出: object

// 正确检查数组的方法
console.log(Array.isArray([])); // 输出: true
console.log(Array.isArray({})); // 输出: false

3. 日期对象的类型 ​

typeof new Date() 返回 "object"。

javascript
console.log(typeof new Date()); // 输出: object

// 检查日期对象的方法
console.log(new Date() instanceof Date); // 输出: true

4. 正则表达式的类型 ​

typeof /regex/ 返回 "object"。

javascript
console.log(typeof /regex/); // 输出: object

// 检查正则表达式的方法
console.log(/regex/ instanceof RegExp); // 输出: true

typeof 运算符的最佳实践 ​

1. 检查变量是否已定义 ​

javascript
// 好的做法
if (typeof variable !== 'undefined') {
  console.log('Variable is defined');
} else {
  console.log('Variable is not defined');
}

// 不好的做法（如果变量未定义，会抛出 ReferenceError）
if (variable) {
  console.log('Variable is defined');
} else {
  console.log('Variable is not defined');
}

2. 检查变量是否为函数 ​

javascript
// 好的做法
if (typeof func === 'function') {
  func();
} else {
  console.log('Not a function');
}

// 不好的做法（如果变量不是函数，会抛出 TypeError）
func();

3. 检查变量是否为对象 ​

javascript
// 好的做法
if (typeof obj === 'object' && obj !== null) {
  console.log('Is an object');
} else {
  console.log('Not an object');
}

// 不好的做法（null 会被认为是对象）
if (typeof obj === 'object') {
  console.log('Is an object');
} else {
  console.log('Not an object');
}

4. 检查变量是否为字符串 ​

javascript
// 好的做法
if (typeof str === 'string') {
  console.log('Is a string');
} else {
  console.log('Not a string');
}

// 或者使用 instanceof
if (str instanceof String) {
  console.log('Is a string object');
} else {
  console.log('Not a string object');
}

5. 检查变量是否为数字 ​

javascript
// 好的做法
if (typeof num === 'number') {
  // 进一步检查是否为有效数字（排除 NaN）
  if (!isNaN(num)) {
    console.log('Is a valid number');
  } else {
    console.log('Is NaN');
  }
} else {
  console.log('Not a number');
}

// 或者使用 Number.isFinite()
if (Number.isFinite(num)) {
  console.log('Is a finite number');
} else {
  console.log('Not a finite number');
}

typeof 运算符的局限性 ​

  1. null 的类型：typeof null 返回 "object"，这是一个历史遗留问题。

  2. 数组的类型：typeof [] 返回 "object"，无法区分普通对象和数组。

  3. 对象的具体类型：typeof 无法区分不同类型的对象，如日期、正则表达式等。

  4. 自定义对象的类型：typeof 无法区分自定义对象的类型。

替代方案 ​

1. Object.prototype.toString.call() ​

Object.prototype.toString.call() 方法可以返回更详细的类型信息：

javascript
console.log(Object.prototype.toString.call(42)); // 输出: [object Number]
console.log(Object.prototype.toString.call("Hello")); // 输出: [object String]
console.log(Object.prototype.toString.call(true)); // 输出: [object Boolean]
console.log(Object.prototype.toString.call(null)); // 输出: [object Null]
console.log(Object.prototype.toString.call(undefined)); // 输出: [object Undefined]
console.log(Object.prototype.toString.call({})); // 输出: [object Object]
console.log(Object.prototype.toString.call([])); // 输出: [object Array]
console.log(Object.prototype.toString.call(function() {})); // 输出: [object Function]
console.log(Object.prototype.toString.call(new Date())); // 输出: [object Date]
console.log(Object.prototype.toString.call(/regex/)); // 输出: [object RegExp]
console.log(Object.prototype.toString.call(Symbol())); // 输出: [object Symbol]
console.log(Object.prototype.toString.call(1n)); // 输出: [object BigInt]

2. instanceof 运算符 ​

instanceof 运算符可以检查对象是否是指定构造函数的实例：

javascript
console.log([] instanceof Array); // 输出: true
console.log({} instanceof Object); // 输出: true
console.log(function() {} instanceof Function); // 输出: true
console.log(new Date() instanceof Date); // 输出: true
console.log(/regex/ instanceof RegExp); // 输出: true

3. 特定类型的检查方法 ​

  • 数组：Array.isArray()
  • 数字：Number.isFinite(), Number.isInteger(), Number.isNaN()
  • 字符串：typeof str === 'string' 或 str instanceof String
  • 布尔值：typeof bool === 'boolean' 或 bool instanceof Boolean
  • 函数：typeof func === 'function' 或 func instanceof Function

小结 ​

typeof 运算符是 JavaScript 中用于检查变量或表达式类型的基本工具。它返回一个字符串，表示操作数的类型。虽然 typeof 有一些局限性（如无法区分 null 和对象，无法区分数组和普通对象），但它仍然是检查基本类型的有效方法。对于更复杂的类型检查，可以使用 Object.prototype.toString.call()、instanceof 运算符或特定类型的检查方法。

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1