JavaScript 数据类型

数据类型简介

JavaScript 是一种弱类型语言，变量可以存储不同类型的数据。JavaScript 有两种主要的数据类型：原始类型和引用类型。

原始类型

原始类型是不可变的数据类型，直接存储值。JavaScript 有 7 种原始类型：

1. Number（数字）

Number 类型表示整数和浮点数：

let integer = 42; // 整数
let float = 3.14; // 浮点数
let negative = -10; // 负数
let zero = 0; // 零

特殊的 Number 值：

let infinity = Infinity; // 无穷大
let negativeInfinity = -Infinity; // 负无穷大
let nan = NaN; // 非数字（Not a Number）

2. String（字符串）

String 类型表示文本数据，用单引号、双引号或反引号包围：

let singleQuote = 'Hello'; // 单引号
let doubleQuote = "Hello"; // 双引号
let backtick = `Hello`; // 反引号（模板字符串）

模板字符串可以嵌入表达式：

let name = 'John';
let greeting = `Hello, ${name}!`; // 输出: Hello, John!

3. Boolean（布尔值）

Boolean 类型表示 true 或 false：

let isTrue = true;
let isFalse = false;

布尔值通常用于条件语句：

if (isTrue) {
  console.log('Condition is true');
}

4. Null（空值）

Null 类型表示一个空值，只有一个值：null：

let emptyValue = null;

5. Undefined（未定义）

Undefined 类型表示一个未定义的值，只有一个值：undefined：

let undefinedValue;
console.log(undefinedValue); // 输出: undefined

6. Symbol（符号）

Symbol 类型表示唯一的标识符，是 ES6 新增的类型：

let sym1 = Symbol();
let sym2 = Symbol('description');

Symbol 值是唯一的：

let sym1 = Symbol('key');
let sym2 = Symbol('key');
console.log(sym1 === sym2); // 输出: false

7. BigInt（大整数）

BigInt 类型表示任意精度的整数，是 ES2020 新增的类型：

let bigInt = 9007199254740991n;
let anotherBigInt = BigInt(9007199254740991);

引用类型

引用类型是可变的数据类型，存储的是引用（内存地址）。JavaScript 的引用类型包括：

1. Object（对象）

Object 类型是 JavaScript 中最基本的引用类型：

const person = {
  name: 'John',
  age: 30,
  city: 'New York'
};

2. Array（数组）

Array 类型是一种特殊的对象，用于存储有序的集合：

const fruits = ['apple', 'banana', 'orange'];
const numbers = [1, 2, 3, 4, 5];

3. Function（函数）

Function 类型是一种特殊的对象，可以被调用：

function greet() {
  console.log('Hello!');
}

const add = function(a, b) {
  return a + b;
};

4. Date（日期）

Date 类型用于表示日期和时间：

const now = new Date();
const specificDate = new Date('2023-01-01');

5. RegExp（正则表达式）

RegExp 类型用于表示正则表达式：

const pattern = /\d+/;
const anotherPattern = new RegExp('\\d+');

6. Map（映射）

Map 类型是一种键值对集合，是 ES6 新增的类型：

const map = new Map();
map.set('name', 'John');
map.set('age', 30);

7. Set（集合）

Set 类型是一种唯一值的集合，是 ES6 新增的类型：

const set = new Set();
set.add('apple');
set.add('banana');
set.add('apple'); // 重复的值会被忽略

数据类型的检测

1. typeof 运算符

typeof 运算符返回变量的类型：

console.log(typeof 42); // 输出: number
console.log(typeof 'Hello'); // 输出: string
console.log(typeof true); // 输出: boolean
console.log(typeof null); // 输出: object（这是一个历史遗留问题）
console.log(typeof undefined); // 输出: undefined
console.log(typeof Symbol()); // 输出: symbol
console.log(typeof 1n); // 输出: bigint
console.log(typeof {}); // 输出: object
console.log(typeof []); // 输出: object
console.log(typeof function() {}); // 输出: function

2. instanceof 运算符

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

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

3. Array.isArray() 方法

Array.isArray() 方法检查值是否是数组：

console.log(Array.isArray([])); // 输出: true
console.log(Array.isArray({})); // 输出: false

4. Object.prototype.toString.call() 方法

Object.prototype.toString.call() 方法返回值的详细类型：

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(Symbol())); // 输出: [object Symbol]
console.log(Object.prototype.toString.call(1n)); // 输出: [object BigInt]
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]

数据类型的转换

1. 强制类型转换

转换为字符串

let num = 42;
let str = String(num); // 输出: "42"
let str2 = num.toString(); // 输出: "42"

转换为数字

let str = '42';
let num = Number(str); // 输出: 42
let num2 = parseInt(str); // 输出: 42
let num3 = parseFloat('3.14'); // 输出: 3.14

转换为布尔值

let value = 'Hello';
let bool = Boolean(value); // 输出: true
let bool2 = !!value; // 输出: true

2. 隐式类型转换

JavaScript 会在某些情况下自动进行类型转换：

字符串拼接

let num = 42;
let str = 'The answer is: ' + num; // 输出: "The answer is: 42"

算术运算

let str = '42';
let result = str * 2; // 输出: 84（字符串被转换为数字）
let result2 = '42' + 2; // 输出: "422"（数字被转换为字符串）

比较运算

console.log('42' == 42); // 输出: true（字符串被转换为数字）
console.log('42' === 42); // 输出: false（严格比较，不进行类型转换）

原始类型和引用类型的区别

1. 存储方式

• 原始类型：直接存储在栈内存中
• 引用类型：值存储在堆内存中，栈内存中存储的是引用（内存地址）

2. 赋值行为

• 原始类型：赋值时复制值
• 引用类型：赋值时复制引用

// 原始类型
let a = 5;
let b = a;
b = 10;
console.log(a); // 输出: 5（a 不受影响）

// 引用类型
let obj1 = {name: 'John'};
let obj2 = obj1;
obj2.name = 'Jane';
console.log(obj1.name); // 输出: Jane（obj1 受影响，因为它们引用同一个对象）

3. 比较行为

• 原始类型：比较值
• 引用类型：比较引用

// 原始类型
console.log(5 === 5); // 输出: true

// 引用类型
console.log({} === {}); // 输出: false（它们是不同的对象，引用不同的内存地址）

小结

JavaScript 有丰富的数据类型，包括 7 种原始类型和多种引用类型。理解不同数据类型的特点和使用场景，以及它们之间的转换规则，是编写正确、高效的 JavaScript 代码的基础。在实际开发中，应该根据需要选择合适的数据类型，并注意原始类型和引用类型的区别。