Node.js与浏览器JavaScript的差异 ​

// 浏览器中
console.log(window);        // Window对象
console.log(document);      // DOM树
console.log(location);      // URL信息
console.log(navigator);     // 浏览器信息
console.log(localStorage);  // 本地存储

// Node.js中
console.log(global);        // 全局命名空间
console.log(process);       // 进程信息
console.log(Buffer);        // 二进制数据
console.log(__dirname);     // 当前模块目录
console.log(__filename);    // 当前模块文件路径
console.log(module);        // 当前模块
console.log(require);       // 模块加载函数

// 浏览器和Node.js都可用
console.log(globalThis);

// 在浏览器中：globalThis === window
// 在Node.js中：globalThis === global

// CommonJS（传统方式）
const fs = require('fs');
const { readFile } = require('fs');
module.exports = { myFunction };

// ES Modules（现代方式）
import fs from 'fs';
import { readFile } from 'fs';
export { myFunction };

// 浏览器ESM（必须完整路径）
import { util } from './utils.js';

// Node.js（可省略）
import { util } from './utils';

// Node.js内置模块
import fs from 'node:fs';  // 推荐的node:前缀
import fs from 'fs';       // 也可以

// DOM操作
document.getElementById('app');
document.querySelector('.item');

// 事件监听
element.addEventListener('click', handler);

// 网络请求
fetch('/api/data');
new XMLHttpRequest();

// 存储
localStorage.setItem('key', 'value');
sessionStorage.getItem('key');
indexedDB.open('database');

// Web API
new WebSocket('ws://example.com');
new Worker('worker.js');
navigator.geolocation.getCurrentPosition();

// 文件系统
const fs = require('fs');
fs.readFile('data.txt', callback);

// 操作系统
const os = require('os');
os.cpus();
os.freemem();

// 路径处理
const path = require('path');
path.join(__dirname, 'file.txt');

// 子进程
const { spawn } = require('child_process');
spawn('ls', ['-la']);

// 网络服务器
const http = require('http');
http.createServer(handler).listen(3000);

// 加密
const crypto = require('crypto');
crypto.createHash('sha256');

// 这些API现在Node.js也支持

// Fetch API（Node.js 18+）
const response = await fetch('https://api.example.com');

// Web Crypto（Node.js 15+）
crypto.subtle.digest('SHA-256', data);

// URL API（一直支持）
const url = new URL('https://example.com/path?query=1');

// AbortController（Node.js 15+）
const controller = new AbortController();
fetch(url, { signal: controller.signal });

// TextEncoder/TextDecoder（一直支持）
const encoder = new TextEncoder();
const decoder = new TextDecoder();

// Blob（Node.js 18+）
const blob = new Blob(['hello']);

// FormData（Node.js 18+）
const formData = new FormData();

// WebSocket客户端（Node.js 22+）
const ws = new WebSocket('ws://example.com');

// setImmediate只在Node.js中存在
setImmediate(() => console.log('immediate'));

// requestAnimationFrame只在浏览器中存在
requestAnimationFrame(() => console.log('frame'));

// process.nextTick只在Node.js中存在
process.nextTick(() => console.log('nextTick'));

// queueMicrotask在两者都支持
queueMicrotask(() => console.log('microtask'));

// 全局错误捕获
window.onerror = (msg, url, line, col, error) => {
  console.log('Error:', msg);
};

// Promise拒绝捕获
window.onunhandledrejection = (event) => {
  console.log('Unhandled rejection:', event.reason);
};

// 全局错误捕获
process.on('uncaughtException', (err) => {
  console.log('Uncaught exception:', err);
  process.exit(1);  // 建议退出
});

// Promise拒绝捕获
process.on('unhandledRejection', (reason, promise) => {
  console.log('Unhandled rejection:', reason);
});

// 警告
process.on('warning', (warning) => {
  console.warn(warning.name, warning.message);
});

// 同源策略限制跨域请求
fetch('https://other-domain.com/api');  // 可能被CORS阻止

// 沙箱环境：无法访问本地文件
// 用户必须主动选择文件
input.addEventListener('change', (e) => {
  const file = e.target.files[0];
});

// CSP限制脚本来源
// <meta http-equiv="Content-Security-Policy" content="script-src 'self'">

// 完全的文件系统访问
const fs = require('fs');
fs.readFile('/etc/passwd', (err, data) => {
  console.log(data.toString());  // 可以读取任何文件
});

// 完全的网络访问
// 没有同源策略限制
await fetch('https://any-domain.com/api');

// 可以执行系统命令
const { exec } = require('child_process');
exec('ls -la', (err, stdout) => {
  console.log(stdout);
});

// Node.js 20+权限模型（实验性）
// node --experimental-permission --allow-fs-read=./data app.js

// Web Worker（真正的多线程）
const worker = new Worker('worker.js');
worker.postMessage({ data: 'hello' });
worker.onmessage = (e) => console.log(e.data);

// 主线程与Worker线程完全隔离
// 通过消息传递通信

// Worker Threads
const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename);
  worker.postMessage({ data: 'hello' });
  worker.on('message', (msg) => console.log(msg));
} else {
  parentPort.on('message', (msg) => {
    parentPort.postMessage({ result: msg.data.toUpperCase() });
  });
}

// Cluster（多进程）
const cluster = require('cluster');
if (cluster.isPrimary) {
  for (let i = 0; i < 4; i++) {
    cluster.fork();
  }
} else {
  // 工作进程
}

// 用户交互驱动
button.addEventListener('click', async () => {
  const data = await fetch('/api/data');
  updateUI(data);
});

// 关注用户体验
// - 页面加载速度
// - 交互响应性
// - 视觉反馈

// 请求驱动
app.get('/api/data', async (req, res) => {
  const data = await database.query('SELECT ...');
  res.json(data);
});

// 关注服务器性能
// - 吞吐量（QPS）
// - 内存使用
// - CPU使用
// - 错误处理

// 浏览器：页面刷新就重置
let cache = {};  // 每次刷新都是新的

// Node.js：进程持续运行
let cache = {};  // 会一直累积，可能内存泄漏

// 浏览器：只服务一个用户
const user = getCurrentUser();

// Node.js：同时服务多个用户
app.get('/profile', (req, res) => {
  // req代表不同用户的请求
  const user = req.user;
});

// 浏览器：API有限，相对安全
// Node.js：完全权限，需要谨慎

// 不要直接使用用户输入
const path = require('path');
const userInput = '../../../etc/passwd';
const safePath = path.join('/safe/dir', path.basename(userInput));