JavaScript 数据类型

JavaScript 数据类型定义了值的种类以及可以对这些值执行的操作。理解 JavaScript 的数据类型对于编写有效的代码至关重要。JavaScript 中的数据类型可以分为两大类：原始类型（Primitive Types）和引用类型（Reference Types）。

原始数据类型（Primitive Types）

原始数据类型是最基本的数据类型，它们是不可变的，直接存储在栈内存中。JavaScript 有 7 种原始数据类型：

1. 数字类型（Number）

数字类型用于表示整数和浮点数。

let integer = 42;           // 整数
let float = 3.14159;        // 浮点数
let negative = -10;         // 负数
let scientific = 1.23e5;    // 科学计数法

// 特殊数字值
let infinity = Infinity;    // 正无穷
let negativeInfinity = -Infinity; // 负无穷
let notANumber = NaN;       // 非数字（Not a Number）

console.log(1 / 0);         // Infinity
console.log("not a number" / 2); // NaN

2. 大整数类型（BigInt）

BigInt 是一种数字类型，可以表示任意大的整数。

let bigNumber = 1234567890123456789012345678901234567890n;
let anotherBigNumber = BigInt("1234567890123456789012345678901234567890");

console.log(bigNumber + 1n); // 可以进行运算

3. 字符串类型（String）

字符串类型用于表示文本数据，用单引号、双引号或反引号包围。

let singleQuote = '单引号字符串';
let doubleQuote = "双引号字符串";
let backtick = `反引号字符串`;

// 字符串可以包含引号
let message = "他说：'你好！'";
let anotherMessage = '她说："再见！"';

// 模板字符串（使用反引号）
let name = "张三";
let greeting = `你好，${name}！`; // 使用 ${} 插入变量
console.log(greeting); // 输出：你好，张三！

4. 布尔类型（Boolean）

布尔类型只有两个值：true 和 false。

let isTrue = true;
let isFalse = false;

// 布尔值通常来自比较操作
let isGreater = 5 > 3;  // true
let isEqual = 5 === 3;  // false

// 在条件语句中使用
if (isGreater) {
    console.log("5 大于 3");
}

5. 未定义类型（Undefined）

Undefined 类型只有一个值：undefined。当变量被声明但未赋值时，默认值为 undefined。

let emptyVariable;
console.log(emptyVariable); // undefined

let explicitUndefined = undefined;
console.log(explicitUndefined); // undefined

6. 空值类型（Null）

Null 类型也只有一个值：null。它表示"无值"或"空值"。

let emptyValue = null;
console.log(emptyValue); // null

// null 通常用于初始化变量，表示该变量还没有值
let user = null; // 表示还没有用户数据

7. 符号类型（Symbol）

Symbol 是一种唯一的、不可变的数据类型，通常用作对象属性的键。

let sym1 = Symbol("描述");
let sym2 = Symbol("描述");

console.log(sym1 === sym2); // false，每个 Symbol 都是唯一的

// Symbol 常用于对象属性键，避免命名冲突
let id = Symbol("id");
let user = {
    name: "张三",
    [id]: 123
};

引用数据类型（Reference Types）

引用类型存储在堆内存中，变量存储的是指向实际数据的引用（地址）。JavaScript 中的引用类型主要是对象（Object）。

对象类型（Object）

对象是键值对的集合，可以包含多种数据类型和函数。

let person = {
    name: "张三",
    age: 25,
    isStudent: true,
    hobbies: ["阅读", "游泳", "编程"],
    address: {
        city: "北京",
        street: "长安街"
    },
    greet: function() {
        return "你好，我是" + this.name;
    }
};

console.log(person.name); // 访问属性
console.log(person["age"]); // 另一种访问属性的方式
console.log(person.greet()); // 调用方法

数组类型（Array）

数组是一种特殊的对象，用于存储有序的数据集合。

let fruits = ["苹果", "香蕉", "橙子"];
let numbers = [1, 2, 3, 4, 5];
let mixed = [1, "字符串", true, {name: "张三"}];

console.log(fruits[0]); // 访问数组元素
console.log(fruits.length); // 获取数组长度

// 数组方法
fruits.push("葡萄"); // 添加元素
fruits.pop(); // 删除最后一个元素

函数类型（Function）

函数也是对象，在 JavaScript 中，函数是一等公民。

// 函数声明
function add(a, b) {
    return a + b;
}

// 函数表达式
let multiply = function(a, b) {
    return a * b;
};

// 箭头函数
let subtract = (a, b) => a - b;

console.log(add(5, 3)); // 8
console.log(multiply(4, 2)); // 8
console.log(subtract(10, 3)); // 7

日期类型（Date）

Date 对象用于处理日期和时间。

let now = new Date(); // 当前日期和时间
let specificDate = new Date("2024-01-01"); // 特定日期
let customDate = new Date(2024, 0, 1, 12, 0, 0); // 年,月,日,时,分,秒

console.log(now.getFullYear()); // 获取年份
console.log(now.getMonth()); // 获取月份（0-11）
console.log(now.getDate()); // 获取日期

类型检测

JavaScript 提供了多种检测数据类型的方法：

typeof 操作符

console.log(typeof 42); // "number"
console.log(typeof "hello"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object"（这是 JavaScript 的一个历史错误）
console.log(typeof Symbol("id")); // "symbol"
console.log(typeof BigInt(123)); // "bigint"
console.log(typeof {}); // "object"
console.log(typeof []); // "object"
console.log(typeof function(){}); // "function"

Array.isArray() 方法

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

instanceof 操作符

let arr = [];
let obj = {};

console.log(arr instanceof Array); // true
console.log(obj instanceof Object); // true
console.log(arr instanceof Object); // true（数组也是对象）

类型转换

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

隐式转换

console.log("5" + 3); // "53"（字符串连接）
console.log("5" - 3); // 2（数值运算）
console.log(true + 1); // 2（true 转换为 1）
console.log(false + 1); // 1（false 转换为 0）

显式转换

// 转换为字符串
let num = 123;
let str = String(num); // "123"
let str2 = num.toString(); // "123"

// 转换为数字
let strNum = "123";
let num1 = Number(strNum); // 123
let num2 = parseInt("123.45"); // 123
let num3 = parseFloat("123.45"); // 123.45

// 转换为布尔值
let truthy = Boolean("hello"); // true
let falsy = Boolean(""); // false
let falsy2 = Boolean(0); // false
let falsy3 = Boolean(null); // false

数据类型的特点

原始类型的不可变性

let str = "hello";
str[0] = "H"; // 这不会改变字符串
console.log(str); // 仍然是 "hello"

// 要改变字符串，需要重新赋值
str = "Hello";
console.log(str); // "Hello"

引用类型的可变性

let arr = [1, 2, 3];
arr[0] = 10; // 可以直接修改数组元素
console.log(arr); // [10, 2, 3]

let obj = {name: "张三"};
obj.name = "李四"; // 可以直接修改对象属性
console.log(obj); // {name: "李四"}

值传递 vs 引用传递

// 原始类型按值传递
let a = 10;
let b = a;
b = 20;
console.log(a); // 10（a 没有改变）

// 引用类型按引用传递
let arr1 = [1, 2, 3];
let arr2 = arr1;
arr2[0] = 10;
console.log(arr1); // [10, 2, 3]（arr1 也改变了）

总结

JavaScript 的数据类型包括：

原始类型（7种）：
- Number（数字）
- BigInt（大整数）
- String（字符串）
- Boolean（布尔值）
- Undefined（未定义）
- Null（空值）
- Symbol（符号）
引用类型（主要是 Object）：
- Object（对象）
- Array（数组）
- Function（函数）
- Date（日期）
- RegExp（正则表达式）等

理解这些数据类型及其特点对于编写高质量的 JavaScript 代码非常重要。在下一章节中，我们将学习 JavaScript 的基本结构。

#JavaScript 数据类型

#原始数据类型（Primitive Types）

#1. 数字类型（Number）

#2. 大整数类型（BigInt）

#3. 字符串类型（String）

#4. 布尔类型（Boolean）

#5. 未定义类型（Undefined）

#6. 空值类型（Null）

#7. 符号类型（Symbol）

#引用数据类型（Reference Types）

#对象类型（Object）

#数组类型（Array）

#函数类型（Function）

#日期类型（Date）

#类型检测

#typeof 操作符

#Array.isArray() 方法

#instanceof 操作符

#类型转换

#隐式转换

#显式转换

#数据类型的特点

#原始类型的不可变性

#引用类型的可变性

#值传递 vs 引用传递

#总结