javascript基本数据类型包括以及优缺点：

1.undefined：未定义的值（变量声明未赋值时的默认值）

/ 变量声明但未赋值时，默认值为 undefined

let a;

console.log(a); // undefined

// 函数无返回值时，默认返回 undefined

function fn() {}

console.log(fn()); // undefined

// 访问不存在的对象属性，返回 undefined

const obj = { name: 'Tom' };

console.log(obj.age); // undefined

// 函数参数未传值时，默认为 undefined

function greet(name) {

console.log(name); // undefined

}

greet();

优点：

· 明确标识变量”未初始化“的状态，避免逻辑错误

函数无返回值时的默认返回值，简化代码逻辑

缺点：

与null容易混肴（如 null 表示 “主动赋值为空”，而 undefined 表示 “未赋值”）

类型判断需用typeof或 ===undefined，例如：

typeof a === 'undefined'; // true

a === undefined; // true

2.null：表示空置（主动赋值为”空“的状态）

// 主动赋值为 null，表示“空值”

let user = null;

console.log(user); // null

// DOM 元素未找到时返回 null

const element = document.getElementById('non-existent');

console.log(element); // null

// 清空对象引用，帮助垃圾回收

const obj = { data: 'value' };

obj = null; // 释放内存

优点：

显示表示”无对象“或者”空值“，语义清晰（如 JSON.parse() 解析失败时返回 null）

可作为函数参数的默认值，表示”无输入“：

function processData(data = null) {

if (data === null) return;

// 处理数据...

}

缺点：

typeof null 返回”object“（历史设计缺陷）,需要===null判断：

typeof null; // "object"（错误！）

null === null; // true（正确）

3.Boolean:布尔值(true和false)

// 直接使用布尔值

const isActive = true;

const isValid = false;

// 条件判断中的隐式类型转换

console.log(Boolean(0)); // false

console.log(Boolean('')); // false

console.log(Boolean(null)); // false

console.log(Boolean(undefined)); // false

console.log(Boolean(NaN)); // false

console.log(Boolean('hello')); // true

console.log(Boolean({})); // true

console.log(Boolean([])); // true

// 短路逻辑（&& 和 ||）

const name = user && user.name; // 若 user 为 falsy 值，则返回 user（而非 undefined）

const fallback = value || 'default'; // 若 value 为 falsy 值，则返回 'default'

优点：

逻辑判断直观（true/false），适合条件分支(如if/else，三原运算符)

自动类型转换代码（如 if(value) 自动判断 value 是否为真值）

缺点：

隐式转换可能引发错误，例如：

if ('false') { // 字符串 'false' 是真值！

console.log('执行'); // 会执行！

}

// 正确写法：显式比较

if (str === 'false') {

console.log('执行'); // 条件为 true 时才执行

}

4.Number:数值(整数,浮点数，NaN等)

// 整数和浮点数

const integer = 42;

const float = 3.14;

// 科学计数法

const largeNum = 1e6; // 1000000

const smallNum = 1e-6; // 0.000001

// 特殊数值

const infinity = 1 / 0; // Infinity

const negativeInfinity = -1 / 0; // -Infinity

const notANumber = NaN; // 非数值

// 数值精度问题

console.log(0.1 + 0.2); // 0.30000000000000004

console.log(0.1 + 0.2 === 0.3); // false

// NaN 的特性

console.log(NaN === NaN); // false（NaN 与任何值都不相等，包括自身）

console.log(isNaN(NaN)); // true

console.log(isNaN('abc')); // true（字符串无法转为数值）

console.log(Number.isNaN(NaN)); // true（ES6 更严格的判断，仅 NaN 返回 true）

优点：

统一处理整数和浮点数，支持科学计数法（如 1e9 表示 10 亿）。

内置特殊值（Infinity、NaN）处理极端情况（如除以零、非法计算）。

缺点：

精度限制：浮点数运算不精确（如 0.1 + 0.2 ≠ 0.3），金融计算需用 BigInt 或第三方库（如 decimal.js）。

数值范围限制：Number.MAX_SAFE_INTEGER（9007199254740991）外的整数会丢失精度

const maxSafeInt = Number.MAX_SAFE_INTEGER; // 9007199254740991

console.log(maxSafeInt + 1 === maxSafeInt + 2); // true（错误！）

5.String:字符串（文本数据，用单/双/模板字符串包裹）

// 字符串字面量

const singleQuotes = 'Hello';

const doubleQuotes = "World";

const templateLiteral = `${singleQuotes} ${doubleQuotes}!`; // 模板字符串（ES6）

// 字符串不可变性

const str = 'hello';

const newStr = str.toUpperCase();

console.log(str); // 'hello'（原字符串不变）

console.log(newStr); // 'HELLO'

// 字符串方法

const text = ' JavaScript ';

console.log(text.trim()); // 'JavaScript'

console.log(text.includes('Script')); // true

console.log(text.charAt(0)); // 'J'

console.log(text.substring(0, 4)); // 'Java'

// 字符串拼接

const firstName = 'John';

const lastName = 'Doe';

const fullName = firstName + ' ' + lastName; // 传统拼接

const fullName2 = `${firstName} ${lastName}`; // 模板字符串（更简洁）

优点：

不可变性确保字符串操作不会修改原数据，避免副作用。

丰富的内置方法（如 trim、includes、substring）简化文本处理。

模板字符串（${}）支持表达式嵌入，提升动态字符串拼接的可读性。

缺点：

不可变性导致频繁拼接大字符串时性能较差（每次拼接都会创建新字符串），建议用数组 join 或 += 替代：

// 性能优化：用数组 join 替代字符串拼接

const parts = ['Hello', ' ', 'World'];

const result = parts.join(''); // 比 'Hello' + ' ' + 'World' 更高效

6.Symbol（ES6）：唯一的标识符

// 创建唯一的 Symbol

const sym1 = Symbol('key');

const sym2 = Symbol('key');

console.log(sym1 === sym2); // false（即使描述相同，Symbol 也唯一）

// 作为对象属性名（避免属性名冲突）

const obj = {

[sym1]: 'value1',

[sym2]: 'value2'

};

console.log(obj[sym1]); // 'value1'

// 内置 Symbol（如 Symbol.iterator）

const arr = [1, 2, 3];

const iterator = arr[Symbol.iterator]();

console.log(iterator.next()); // { value: 1, done: false }

// 全局注册的 Symbol（通过 Symbol.for）

const globalSym = Symbol.for('global-key');

const sameGlobalSym = Symbol.for('global-key');

console.log(globalSym === sameGlobalSym); // true

优点：

唯一性：创建的 Symbol 永不重复，适合作为对象的私有属性或常量（如状态机中的状态标识）。

避免命名冲突：在第三方库或框架中，可防止属性名被意外覆盖（如 Symbol.iterator 用于自定义迭代器）。

缺点：

调试困难：console.log 无法直观显示 Symbol 的值，需通过 description 获取：

console.log(sym1.description); // 'key'

7.BigInt（ES10）：大整数

// 创建 BigInt（两种方式）

const num1 = 9007199254740991n; // 数字后加 n 表示 BigInt

const num2 = BigInt(9007199254740991); // 或使用 BigInt() 构造函数

// 大整数运算

const result = num1 + 2n;

console.log(result); // 9007199254740993n

// 与普通 Number 不能直接运算

try {

const error = num1 + 2; // 报错！Cannot mix BigInt and other types

} catch (e) {

console.error(e.message);

}

// 安全处理极大整数

const maxSafeInt = Number.MAX_SAFE_INTEGER;

console.log(maxSafeInt + 1 === maxSafeInt + 2); // true（Number 精度丢失）

console.log(BigInt(maxSafeInt) + 1n === BigInt(maxSafeInt) + 2n); // false（BigInt 正确）

优点：

任意精度整数：处理超出 Number.MAX_SAFE_INTEGER 的大整数（如时间戳、ID 生成器）。

避免精度丢失：金融计算、密码学等场景的理想选择。

缺点：

兼容性差：IE/Edge 18 及以下版本不支持，需检测环境

if (typeof BigInt !== 'undefined') {

// 支持 BigInt

} else {

// 降级处理（如使用第三方库）

}

类型限制：不能与 Number 直接混合运算，需显式转换：

const mixed = num1 + BigInt(2); // 正确：显式转换

注意事项：

类型判断：优先用 === 而非 typeof（如 x === null 而非 typeof x === 'object'）。精度问题：金融计算避免用 Number，改用 BigInt 或第三方库。兼容性：使用 Symbol/BigInt 时需检测环境或添加 polyfill。不可变性：字符串和基本类型的不可变性可防止副作用，但需注意性能优化。