// typeof - 适合判断原始类型
typeof 'hello'      // 'string'
typeof 42           // 'number'
typeof true         // 'boolean'
typeof undefined    // 'undefined'
typeof Symbol()     // 'symbol'
typeof 10n          // 'bigint'

// instanceof - 判断对象类型
[] instanceof Array           // true
{} instanceof Object          // true
new Date() instanceof Date    // true

// Object.prototype.toString - 最准确的方法
Object.prototype.toString.call([])        // '[object Array]'
Object.prototype.toString.call(null)      // '[object Null]'
Object.prototype.toString.call(undefined) // '[object Undefined]'

// Array.isArray - 判断数组
Array.isArray([])    // true
Array.isArray({})    // false

// 以下值转为布尔值都是 false
false, 0, -0, 0n, '', null, undefined, NaN

// 箭头函数简写
const add = (a, b) => a + b;           // 单表达式，省略 return
const square = x => x * x;              // 单参数，省略括号
const getObj = () => ({ name: 'test' }); // 返回对象需要括号

function createCounter() {
    let count = 0;  // 私有变量
    return {
        increment: () => ++count,
        decrement: () => --count,
        getCount: () => count
    };
}

const counter = createCounter();
counter.increment();  // 1
counter.increment();  // 2
counter.getCount();   // 2

// 对象创建
const obj = { name: 'Node.js', version: 20 };

// 属性访问
obj.name          // 点语法
obj['name']       // 方括号语法（支持动态属性名）

// 属性操作
obj.author = 'Ryan Dahl';  // 添加属性
delete obj.version;         // 删除属性
'name' in obj;              // 检查属性存在

// 对象方法
Object.keys(obj)            // 获取所有键
Object.values(obj)          // 获取所有值
Object.entries(obj)         // 获取键值对数组
Object.assign({}, obj)      // 浅拷贝
Object.freeze(obj)          // 冻结对象
Object.seal(obj)            // 密封对象

const user = { name: 'John', age: 25, city: 'NYC' };

// 基本解构
const { name, age } = user;

// 重命名
const { name: userName } = user;

// 默认值
const { country = 'USA' } = user;

// 嵌套解构
const { address: { street } } = { address: { street: '123 Main' } };

// 剩余属性
const { name, ...rest } = user;  // rest = { age: 25, city: 'NYC' }

const numbers = [1, 2, 3, 4, 5];

// map - 映射
const doubled = numbers.map(n => n * 2);  // [2, 4, 6, 8, 10]

// filter - 过滤
const evens = numbers.filter(n => n % 2 === 0);  // [2, 4]

// reduce - 归约
const sum = numbers.reduce((acc, n) => acc + n, 0);  // 15

// find - 查找
const found = numbers.find(n => n > 3);  // 4

// some/every - 条件判断
numbers.some(n => n > 4);   // true
numbers.every(n => n > 0);  // true

// 链式调用
const result = numbers
    .filter(n => n % 2 === 0)
    .map(n => n * 2)
    .reduce((acc, n) => acc + n, 0);  // 12

const arr = [1, 2, 3, 4, 5];

// 基本解构
const [first, second] = arr;  // 1, 2

// 跳过元素
const [, , third] = arr;  // 3

// 剩余元素
const [head, ...tail] = arr;  // 1, [2, 3, 4, 5]

// 默认值
const [a, b, c = 0] = [1, 2];  // 1, 2, 0

// 交换变量
let x = 1, y = 2;
[x, y] = [y, x];  // x = 2, y = 1

const name = 'Node.js';
const version = 20;

// 字符串插值
const msg = `Welcome to ${name} v${version}`;

// 多行字符串
const html = `
    <div>
        <h1>${name}</h1>
        <p>Version: ${version}</p>
    </div>
`;

// 标签模板
function highlight(strings, ...values) {
    return strings.reduce((result, str, i) => 
        result + str + (values[i] ? `<mark>${values[i]}</mark>` : ''), '');
}
const highlighted = highlight`Hello ${name}!`;

// 数组展开
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5];  // [1, 2, 3, 4, 5]

// 对象展开
const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 };  // { a: 1, b: 2, c: 3 }

// 函数参数
const nums = [1, 2, 3];
Math.max(...nums);  // 3

// 复制数组/对象（浅拷贝）
const arrCopy = [...arr1];
const objCopy = { ...obj1 };

// 函数剩余参数
function sum(...numbers) {
    return numbers.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4);  // 10

// 解构中的剩余
const [first, ...rest] = [1, 2, 3, 4];
const { a, ...others } = { a: 1, b: 2, c: 3 };

const user = {
    name: 'John',
    address: {
        city: 'NYC'
    }
};

// 安全访问嵌套属性
user?.address?.city      // 'NYC'
user?.contact?.email     // undefined（不会报错）

// 安全调用方法
user.getName?.()         // undefined

// 安全访问数组
const arr = [1, 2, 3];
arr?.[0]                 // 1

// ?? 只在 null 或 undefined 时使用默认值
const value1 = null ?? 'default';      // 'default'
const value2 = undefined ?? 'default'; // 'default'
const value3 = 0 ?? 'default';         // 0（0 不是 nullish）
const value4 = '' ?? 'default';        // ''（空字符串不是 nullish）

// 与 || 的区别
0 || 'default'   // 'default'（0 是 falsy）
0 ?? 'default'   // 0（0 不是 nullish）

// Promise 创建
const promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve('done'), 1000);
});

// Promise 使用
promise
    .then(result => console.log(result))
    .catch(error => console.error(error))
    .finally(() => console.log('完成'));

// async/await
async function fetchData() {
    try {
        const response = await fetch('/api/data');
        const data = await response.json();
        return data;
    } catch (error) {
        console.error('请求失败:', error);
    }
}

// 并行执行
const [user, posts] = await Promise.all([
    fetchUser(),
    fetchPosts()
]);

// 生成器函数
function* numberGenerator() {
    yield 1;
    yield 2;
    yield 3;
}

const gen = numberGenerator();
gen.next();  // { value: 1, done: false }
gen.next();  // { value: 2, done: false }
gen.next();  // { value: 3, done: false }
gen.next();  // { value: undefined, done: true }

// 异步生成器
async function* asyncGenerator() {
    yield await fetchData1();
    yield await fetchData2();
}

// for await...of
for await (const data of asyncGenerator()) {
    console.log(data);
}

class Animal {
    // 私有字段（ES2022）
    #privateField = 'private';
    
    // 静态属性
    static kingdom = 'Animalia';
    
    // 构造函数
    constructor(name) {
        this.name = name;
    }
    
    // 实例方法
    speak() {
        console.log(`${this.name} makes a sound`);
    }
    
    // 静态方法
    static create(name) {
        return new Animal(name);
    }
    
    // Getter
    get info() {
        return `Animal: ${this.name}`;
    }
    
    // Setter
    set nickname(value) {
        this._nickname = value;
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        super(name);  // 调用父类构造函数
        this.breed = breed;
    }
    
    // 方法重写
    speak() {
        console.log(`${this.name} barks`);
    }
    
    // 调用父类方法
    parentSpeak() {
        super.speak();
    }
}

const dog = new Dog('Buddy', 'Golden Retriever');
dog.speak();  // 'Buddy barks'

// 定义 Mixin
const Flyable = {
    fly() {
        console.log(`${this.name} is flying`);
    }
};

const Swimmable = {
    swim() {
        console.log(`${this.name} is swimming`);
    }
};

// 应用 Mixin
class Duck extends Animal {}
Object.assign(Duck.prototype, Flyable, Swimmable);

const duck = new Duck('Donald');
duck.fly();   // 'Donald is flying'
duck.swim();  // 'Donald is swimming'

// 单例模式
class Database {
    static #instance;
    
    constructor() {
        if (Database.#instance) {
            return Database.#instance;
        }
        Database.#instance = this;
    }
    
    static getInstance() {
        if (!Database.#instance) {
            Database.#instance = new Database();
        }
        return Database.#instance;
    }
}

// 观察者模式
class EventEmitter {
    #events = {};
    
    on(event, listener) {
        if (!this.#events[event]) {
            this.#events[event] = [];
        }
        this.#events[event].push(listener);
    }
    
    emit(event, ...args) {
        if (this.#events[event]) {
            this.#events[event].forEach(listener => listener(...args));
        }
    }
}

console.log('1. 同步代码');

setTimeout(() => console.log('2. setTimeout'), 0);

setImmediate(() => console.log('3. setImmediate'));

Promise.resolve().then(() => console.log('4. Promise'));

process.nextTick(() => console.log('5. nextTick'));

console.log('6. 同步代码结束');

// 输出顺序：1 -> 6 -> 5 -> 4 -> 2 -> 3

# 设置线程池大小为 8
UV_THREADPOOL_SIZE=8 node app.js

// 1. 回调方式（传统）
fs.readFile('file.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

// 2. 同步方式（阻塞）
const data = fs.readFileSync('file.txt', 'utf8');

// 3. Promise 方式（推荐）
const data = await fs.promises.readFile('file.txt', 'utf8');

// 监听文件变化
fs.watch('file.txt', (eventType, filename) => {
    console.log(`${filename} 发生了 ${eventType} 事件`);
});

// 更精确的监听（轮询方式）
fs.watchFile('file.txt', { interval: 1000 }, (curr, prev) => {
    console.log('文件被修改');
});

// Windows 和 Unix 路径分隔符不同
path.sep  // Windows: '\\'  Unix: '/'

// 始终使用 path.join 而不是字符串拼接
// ❌ 错误
const filePath = dir + '/' + filename;

// ✅ 正确
const filePath = path.join(dir, filename);

// 发起 GET 请求
http.get('http://api.example.com/data', (res) => {
    let data = '';
    res.on('data', chunk => data += chunk);
    res.on('end', () => console.log(data));
});

// 发起 POST 请求
const req = http.request({
    hostname: 'api.example.com',
    method: 'POST',
    headers: { 'Content-Type': 'application/json' }
}, (res) => {
    // 处理响应
});
req.write(JSON.stringify({ key: 'value' }));
req.end();

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {
    doSomething() {
        this.emit('start');
        // 执行操作
        this.emit('end', { result: 'success' });
    }
}

const myEmitter = new MyEmitter();
myEmitter.on('start', () => console.log('开始'));
myEmitter.on('end', (data) => console.log('结束', data));

// 必须监听 error 事件，否则会抛出异常
emitter.on('error', (err) => {
    console.error('发生错误:', err);
});

// 文件复制（内存友好）
const readable = fs.createReadStream('source.txt');
const writable = fs.createWriteStream('dest.txt');
readable.pipe(writable);

// 链式管道
fs.createReadStream('file.txt')
    .pipe(zlib.createGzip())
    .pipe(fs.createWriteStream('file.txt.gz'));

const readable = fs.createReadStream('large-file.txt');
const writable = fs.createWriteStream('output.txt');

readable.on('data', (chunk) => {
    const canContinue = writable.write(chunk);
    if (!canContinue) {
        readable.pause();  // 暂停读取
    }
});

writable.on('drain', () => {
    readable.resume();  // 恢复读取
});

const buf = Buffer.from([1, 2, 3, 4]);
const arr = new Uint8Array(buf);  // 共享内存

// 从 ArrayBuffer 创建
const arrayBuffer = new ArrayBuffer(16);
const buffer = Buffer.from(arrayBuffer);

// 回调函数的第一个参数是错误对象
function callback(err, result) {
    if (err) {
        // 处理错误
        return;
    }
    // 处理结果
}

fetchUser(userId)
    .then(user => fetchOrders(user.id))
    .then(orders => processOrders(orders))
    .then(result => console.log(result))
    .catch(err => console.error(err))
    .finally(() => cleanup());

// Promise 方式
function getData() {
    return fetch('/api/data')
        .then(res => res.json())
        .then(data => processData(data));
}

// async/await 方式（推荐）
async function getData() {
    const res = await fetch('/api/data');
    const data = await res.json();
    return processData(data);
}

// 方式1：try-catch
async function getData() {
    try {
        const data = await fetchData();
        return data;
    } catch (err) {
        console.error('获取数据失败:', err);
        throw err;
    }
}

// 方式2：.catch()
async function getData() {
    const data = await fetchData().catch(err => {
        console.error(err);
        return null;
    });
    return data;
}

// 串行执行（一个接一个）
async function serial() {
    const a = await taskA();  // 等待完成
    const b = await taskB();  // 再执行
    return [a, b];
}

// 并行执行（同时进行）
async function parallel() {
    const [a, b] = await Promise.all([
        taskA(),
        taskB()
    ]);
    return [a, b];
}

// 设置最大监听器数量
emitter.setMaxListeners(20);

// 检查监听器数量
if (emitter.listenerCount('event') > 10) {
    console.warn('监听器过多');
}

// 捕获未处理的异常
process.on('uncaughtException', (err) => {
    console.error('未捕获的异常:', err);
    // 记录日志后退出
    process.exit(1);
});

// 捕获未处理的 Promise 拒绝
process.on('unhandledRejection', (reason, promise) => {
    console.error('未处理的 Promise 拒绝:', reason);
});

class AppError extends Error {
    constructor(message, statusCode, isOperational = true) {
        super(message);
        this.statusCode = statusCode;
        this.isOperational = isOperational;  // 区分操作错误和编程错误
        Error.captureStackTrace(this, this.constructor);
    }
}

// 使用
throw new AppError('用户不存在', 404);

# 初始化项目
npm init -y

# 安装所有依赖
npm install

# 清理缓存
npm cache clean --force

# 查看全局安装位置
npm root -g

# 查看过期的包
npm outdated

# 安全审计
npm audit

# 修复安全问题
npm audit fix

# 查看包的依赖树
npm ls

# 链接本地包（开发调试）
npm link

# 1. 初始化一个 Worker 项目
npx wrangler init my-worker
# 2. 本地开发调试（启动本地模拟环境）
npx wrangler dev
# 3. 部署到 Cloudflare 全球网络
npx wrangler deploy
# 4. 登录 Cloudflare 账号
npx wrangler login

// 方式1：module.exports 导出对象
module.exports = {
    add: (a, b) => a + b,
    subtract: (a, b) => a - b
};

// 方式2：module.exports 导出单个值
module.exports = function add(a, b) {
    return a + b;
};

// 方式3：exports 快捷方式
exports.add = (a, b) => a + b;
exports.subtract = (a, b) => a - b;

// 导入整个模块
const math = require('./math');
math.add(1, 2);

// 解构导入
const { add, subtract } = require('./math');
add(1, 2);

// 导入核心模块
const fs = require('fs');

// 导入 node_modules 中的包
const express = require('express');

// 模块只会加载一次，后续 require 返回缓存
const a = require('./module');
const b = require('./module');
console.log(a === b);  // true

// 查看缓存
console.log(require.cache);

// 清除缓存（谨慎使用）
delete require.cache[require.resolve('./module')];

// 命名导出
export const name = 'Node.js';
export function add(a, b) { return a + b; }

// 默认导出
export default class Calculator { }

// 混合导出
export { name, add };
export default Calculator;

// 重命名导出
export { add as sum };

// 命名导入
import { name, add } from './module.js';

// 默认导入
import Calculator from './module.js';

// 混合导入
import Calculator, { name, add } from './module.js';

// 重命名导入
import { add as sum } from './module.js';

// 导入所有
import * as math from './module.js';

// 动态导入
const module = await import('./module.js');

// ESM 中导入 CommonJS 模块
import pkg from 'commonjs-package';

// 使用 createRequire
import { createRequire } from 'module';
const require = createRequire(import.meta.url);
const pkg = require('commonjs-package');

// import.meta 元信息
console.log(import.meta.url);  // 当前模块的 URL

// 顶层 await（Node.js 14.8+）
const data = await fetch('/api/data');

{
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.cjs",
      "types": "./dist/index.d.ts"
    },
    "./utils": {
      "import": "./dist/utils.mjs",
      "require": "./dist/utils.cjs"
    }
  }
}

{
  "scripts": {
    "start": "node app.js",
    "dev": "nodemon app.js",
    "build": "tsc",
    "test": "jest",
    "lint": "eslint src/",
    "preinstall": "echo 安装前执行",
    "postinstall": "echo 安装后执行",
    "prepublishOnly": "npm run build"
  }
}

{
  "workspaces": [
    "packages/*"
  ]
}

// 基本路由
app.get('/users', (req, res) => { });
app.post('/users', (req, res) => { });
app.put('/users/:id', (req, res) => { });
app.delete('/users/:id', (req, res) => { });

// 路由参数
app.get('/users/:id', (req, res) => {
    const userId = req.params.id;
});

// 查询参数
app.get('/search', (req, res) => {
    const keyword = req.query.q;
});

// 路由分组
const userRouter = express.Router();
userRouter.get('/', listUsers);
userRouter.post('/', createUser);
app.use('/api/users', userRouter);

app.use(async (ctx, next) => {
    console.log('1. 进入中间件1');
    await next();
    console.log('6. 离开中间件1');
});

app.use(async (ctx, next) => {
    console.log('2. 进入中间件2');
    await next();
    console.log('5. 离开中间件2');
});

app.use(async (ctx) => {
    console.log('3. 处理请求');
    ctx.body = 'Hello';
    console.log('4. 处理完成');
});

// 输出顺序：1 -> 2 -> 3 -> 4 -> 5 -> 6

const mysql = require('mysql2/promise');

const pool = mysql.createPool({
    host: 'localhost',
    user: 'root',
    password: 'password',
    database: 'mydb',
    waitForConnections: true,
    connectionLimit: 10,      // 最大连接数
    queueLimit: 0,            // 等待队列限制
    enableKeepAlive: true,    // 保持连接
    keepAliveInitialDelay: 0
});

// 查询
const [rows] = await pool.query('SELECT * FROM users WHERE id = ?', [userId]);

// 插入
const [result] = await pool.query(
    'INSERT INTO users (name, email) VALUES (?, ?)',
    [name, email]
);
console.log('插入ID:', result.insertId);

// 更新
const [result] = await pool.query(
    'UPDATE users SET name = ? WHERE id = ?',
    [newName, userId]
);
console.log('影响行数:', result.affectedRows);

// 删除
const [result] = await pool.query('DELETE FROM users WHERE id = ?', [userId]);

const connection = await pool.getConnection();
try {
    await connection.beginTransaction();
    
    await connection.query('UPDATE accounts SET balance = balance - ? WHERE id = ?', [amount, fromId]);
    await connection.query('UPDATE accounts SET balance = balance + ? WHERE id = ?', [amount, toId]);
    
    await connection.commit();
} catch (err) {
    await connection.rollback();
    throw err;
} finally {
    connection.release();
}

const mongoose = require('mongoose');

// 连接数据库
await mongoose.connect('mongodb://localhost:27017/mydb');

// 定义 Schema
const userSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, unique: true },
    age: { type: Number, min: 0 },
    createdAt: { type: Date, default: Date.now }
});

// 创建 Model
const User = mongoose.model('User', userSchema);

// 创建
const user = await User.create({ name: 'John', email: '[email protected]' });

// 查询
const users = await User.find({ age: { $gte: 18 } });
const user = await User.findById(id);
const user = await User.findOne({ email: '[email protected]' });

// 更新
await User.updateOne({ _id: id }, { name: 'Jane' });
await User.findByIdAndUpdate(id, { name: 'Jane' }, { new: true });

// 删除
await User.deleteOne({ _id: id });
await User.findByIdAndDelete(id);

// 保存前中间件
userSchema.pre('save', async function(next) {
    if (this.isModified('password')) {
        this.password = await bcrypt.hash(this.password, 10);
    }
    next();
});

// 查询后中间件
userSchema.post('find', function(docs) {
    console.log('查询到', docs.length, '条记录');
});

const Redis = require('ioredis');
const redis = new Redis({
    host: 'localhost',
    port: 6379,
    password: 'password',
    db: 0
});

// 字符串操作
await redis.set('key', 'value');
await redis.set('key', 'value', 'EX', 3600);  // 设置过期时间
const value = await redis.get('key');

// 哈希操作
await redis.hset('user:1', 'name', 'John', 'age', '25');
const user = await redis.hgetall('user:1');

// 列表操作
await redis.lpush('queue', 'task1', 'task2');
const task = await redis.rpop('queue');

// 集合操作
await redis.sadd('tags', 'node', 'javascript');
const tags = await redis.smembers('tags');

// 有序集合
await redis.zadd('leaderboard', 100, 'player1', 200, 'player2');
const top = await redis.zrevrange('leaderboard', 0, 9, 'WITHSCORES');

// 获取锁
async function acquireLock(key, ttl = 10000) {
    const lockKey = `lock:${key}`;
    const lockValue = Date.now().toString();
    const result = await redis.set(lockKey, lockValue, 'PX', ttl, 'NX');
    return result === 'OK' ? lockValue : null;
}

// 释放锁（使用 Lua 脚本保证原子性）
async function releaseLock(key, lockValue) {
    const script = `
        if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
        else
            return 0
        end
    `;
    return await redis.eval(script, 1, `lock:${key}`, lockValue);
}

// 使用 Prisma Client
const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();

// 创建
const user = await prisma.user.create({
    data: { email: '[email protected]', name: 'John' }
});

// 查询（包含关联）
const userWithPosts = await prisma.user.findUnique({
    where: { id: 1 },
    include: { posts: true }
});

// 事务
await prisma.$transaction([
    prisma.user.update({ where: { id: 1 }, data: { name: 'Jane' } }),
    prisma.post.create({ data: { title: 'Hello', authorId: 1 } })
]);