// 最簡單的 Node.js 程式
console.log('Hello, Node.js!');

// 查看 Node.js 環境變數與版本
console.log(`Node.js 版本: ${process.version}`);
console.log(`平台: ${process.platform}`);
console.log(`架構: ${process.arch}`);

# 驗證 Node.js 安裝
node -v
# v20.11.0

# 驗證 npm 安裝
npm -v
# 10.2.4

# 執行 Node.js 互動式 REPL
node

# 使用 nvm 管理多版本 (macOS/Linux)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# 安裝特定版本
nvm install 20
nvm use 20
nvm list

// hello.js - 第一個 Node.js 程式
const name = 'World';
console.log(`Hello, ${name}!`);

// 執行命令
// node hello.js

// 📁 server.js - 基本 HTTP 伺服器
const http = require('http');

const server = http.createServer((req, res) => {
    const { method, url } = req;
    
    console.log(`${method} ${url}`);
    
    // 設定回應標頭
    res.writeHead(200, {
        'Content-Type': 'text/html; charset=utf-8',
        'X-Powered-By': 'Node.js'
    });
    
    res.end(`
        
Hello from Node.js!
        
方法: ${method}
        
路徑: ${url}
    `);
});

server.listen(3000, '127.0.0.1', () => {
    console.log('✅ 伺服器啟動於 http://127.0.0.1:3000');
});

// 📁 router.js - 路由處理
const http = require('http');
const url = require('url');

const routes = {
    'GET /': (res) => {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ message: '首頁', status: 'ok' }));
    },
    'GET /users': (res) => {
        const users = [
            { id: 1, name: '陳小明', email: '[email protected]' },
            { id: 2, name: '王小美', email: '[email protected]' }
        ];
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(users));
    },
    'GET /about': (res) => {
        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
        res.end('
關於我們
Node.js 教學網站
');
    }
};

const server = http.createServer((req, res) => {
    const parsedUrl = url.parse(req.url, true);
    const routeKey = `${req.method} ${parsedUrl.pathname}`;
    
    if (routes[routeKey]) {
        routes[routeKey](res, parsedUrl.query);
    } else {
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: '找不到頁面', code: 404 }));
    }
});

server.listen(3000);
console.log('伺服器已啟動');

# 初始化新專案 (產生 package.json)
npm init
npm init -y  # 使用預設值跳過問答

# 安裝套件
npm install express          # 安裝到 dependencies (生產環境需要)
npm install -D nodemon       # 安裝到 devDependencies (僅開發需要)
npm install -g pm2           # 全域安裝 (通常用於命令列工具)

# 更新套件
npm update                   # 更新所有套件
npm update express           # 更新特定套件

# 移除套件
npm uninstall express

# 查看過期套件
npm outdated

# 執行腳本 (對應 package.json 內的 scripts)
npm start
npm run dev
npm test

{
  "name": "my-node-app",
  "version": "1.0.0",
  "description": "我的 Node.js 應用程式",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "jest",
    "build": "npm run lint && npm run test"
  },
  "keywords": ["nodejs", "express", "api"],
  "author": "陳小明 ",
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2",
    "mongoose": "^8.0.0",
    "jsonwebtoken": "^9.0.0",
    "bcryptjs": "^2.4.3",
    "dotenv": "^16.3.1"
  },
  "devDependencies": {
    "nodemon": "^3.0.0",
    "jest": "^29.0.0",
    "eslint": "^8.0.0"
  }
}

// 📁 app.js - Express 基本設定
const express = require('express');
const app = express();

// 中介軟體 (Middleware)
app.use(express.json());                        // 解析 JSON
app.use(express.urlencoded({ extended: true })); // 解析表單
app.use(express.static('public'));              // 靜態檔案伺服

// 路由宣告
app.get('/', (req, res) => {
    res.json({ message: '歡迎使用 Node.js API！', version: '1.0.0' });
});

// 擷取網址參數 (Params) 與查詢字串 (Query)
app.get('/users/:id', (req, res) => {
    const { id } = req.params;     // 網址如 /users/123 -> id = 123
    const { fields } = req.query;  // 網址如 ?fields=name -> fields = name
    res.json({ userId: id, fields });
});

// 404 處理 (放置在所有路由之後)
app.use((req, res) => {
    res.status(404).json({ error: '找不到路由', path: req.path });
});

// 全域錯誤處理中介軟體
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({ error: '伺服器內部錯誤' });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`🚀 Express 伺服器啟動於 port ${PORT}`);
});

// 📁 routes/users.js - 使用者路由模組
const express = require('express');
const router = express.Router();

// 模擬資料庫
let users = [
    { id: 1, name: '陳小明', email: '[email protected]', role: 'admin' },
    { id: 2, name: '王小美', email: '[email protected]', role: 'user' },
];

// GET /users - 取得所有使用者
router.get('/', (req, res) => {
    const { role, page = 1, limit = 10 } = req.query;
    let result = role ? users.filter(u => u.role === role) : users;
    const start = (page - 1) * limit;
    result = result.slice(start, start + parseInt(limit));
    res.json({ data: result, total: users.length, page: parseInt(page) });
});

// POST /users - 新增使用者
router.post('/', (req, res) => {
    const { name, email, role = 'user' } = req.body;
    if (!name || !email) return res.status(400).json({ error: '姓名和電子郵件為必填' });
    const newUser = { id: users.length + 1, name, email, role };
    users.push(newUser);
    res.status(201).json(newUser);
});

module.exports = router;

// 📁 middleware/auth.js - 認證中介軟體
const jwt = require('jsonwebtoken');

// 請求記錄中介軟體
function requestLogger(req, res, next) {
    const start = Date.now();
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
    res.on('finish', () => {
        const duration = Date.now() - start;
        console.log(`  → ${res.statusCode} (${duration}ms)`);
    });
    next(); // 必須呼叫 next() 繼續執行
}

// JWT 驗證中介軟體
function authenticate(req, res, next) {
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ error: '需要提供認證令牌' });
    }
    const token = authHeader.substring(7);
    try {
        const decoded = jwt.verify(token, process.env.JWT_SECRET || 'secret');
        req.user = decoded;
        next();
    } catch (err) {
        res.status(403).json({ error: '無效的認證令牌' });
    }
}

// 使用中介軟體
app.use(requestLogger);
app.use('/api/protected', authenticate);

module.exports = { requestLogger, authenticate };

// Promise 工具方法比較

// Promise.all - 全部成功才繼續，任一失敗即中止
const [users, posts] = await Promise.all([
    fetchUsers(),   // 同時開始
    fetchPosts()    // 同時開始
]);

// Promise.allSettled - 不管成功失敗，等全部完成
const results = await Promise.allSettled([
    fetch('https://api1.example.com'),
    fetch('https://api2.example.com'),
    fetch('https://api3.example.com')  // 即使這個失敗
]);
const succeeded = results.filter(r => r.status === 'fulfilled');

// Promise.race - 只取最快完成的那個
const fastest = await Promise.race([
    fetchFromServer1(),
    fetchFromServer2(),
    new Promise((_, reject) => setTimeout(() => reject(new Error('逾時')), 5000))
]);

// Promise.any - 只取第一個成功的 (Node.js 15+)
const firstSuccess = await Promise.any([
    tryServer1(),
    tryServer2(),
    tryServer3()
]);

// 📁 index.js - 完整 REST API
const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const app = express();

app.use(express.json());

const db = { users: [], nextId: 1 };
const JWT_SECRET = process.env.JWT_SECRET || 'change-this-in-production';

// POST /api/auth/register - 使用者註冊
app.post('/api/auth/register', async (req, res) => {
    try {
        const { name, email, password } = req.body;
        if (!name || !email || !password)
            return res.status(400).json({ success: false, message: '請填寫所有欄位' });
        if (password.length < 8)
            return res.status(400).json({ success: false, message: '密碼至少 8 個字元' });
        if (db.users.find(u => u.email === email))
            return res.status(409).json({ success: false, message: 'Email 已被使用' });

        const hashedPassword = await bcrypt.hash(password, 12);
        const user = { id: db.nextId++, name, email, password: hashedPassword, role: 'user' };
        db.users.push(user);

        const token = jwt.sign({ id: user.id, role: user.role }, JWT_SECRET, { expiresIn: '7d' });
        const { password: _, ...safeUser } = user;
        res.status(201).json({ success: true, data: { user: safeUser, token } });
    } catch (err) {
        res.status(500).json({ success: false, message: '伺服器錯誤' });
    }
});

// POST /api/auth/login - 使用者登入
app.post('/api/auth/login', async (req, res) => {
    const { email, password } = req.body;
    const user = db.users.find(u => u.email === email);
    if (!user || !(await bcrypt.compare(password, user.password)))
        return res.status(401).json({ success: false, message: '帳號或密碼錯誤' });

    const token = jwt.sign({ id: user.id, role: user.role }, JWT_SECRET, { expiresIn: '7d' });
    const { password: _, ...safeUser } = user;
    res.json({ success: true, data: { user: safeUser, token } });
});

// 認證中介軟體
function auth(req, res, next) {
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) return res.status(401).json({ error: '請先登入' });
    try {
        req.user = jwt.verify(token, JWT_SECRET);
        next();
    } catch {
        res.status(403).json({ error: '令牌無效或已過期' });
    }
}

// GET /api/me - 取得目前登入使用者資訊
app.get('/api/me', auth, (req, res) => {
    const user = db.users.find(u => u.id === req.user.id);
    const { password: _, ...safeUser } = user;
    res.json({ success: true, data: safeUser });
});

app.listen(3000, () => console.log('🚀 API 啟動於 http://localhost:3000'));

# 1. 註冊
curl -X POST http://localhost:3000/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"name":"陳小明","email":"[email protected]","password":"pass1234"}'

# 2. 登入並取得 token
curl -X POST http://localhost:3000/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"pass1234"}'

# 3. 使用 token 取得個人資訊
curl http://localhost:3000/api/me \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

// 📁 chat-server.js - WebSocket 聊天室伺服器
const http = require('http');
const WebSocket = require('ws');

const server = http.createServer();
const wss = new WebSocket.Server({ server });

const clients = new Map(); // ws => { id, username }

wss.on('connection', (ws, req) => {
    const clientId = Date.now().toString(36);
    clients.set(ws, { id: clientId, username: null });
    console.log(`✅ 新連線: ${clientId}`);

    ws.send(JSON.stringify({ type: 'welcome', id: clientId, message: '歡迎進入聊天室！' }));

    ws.on('message', (rawData) => {
        try {
            const msg = JSON.parse(rawData.toString());
            const client = clients.get(ws);

            if (msg.type === 'join') {
                client.username = msg.username;
                broadcast({ type: 'system', text: `👋 ${msg.username} 加入了聊天室`, count: clients.size }, ws);

            } else if (msg.type === 'chat') {
                broadcast({
                    type: 'chat',
                    id: client.id,
                    username: client.username || '匿名',
                    text: msg.text,
                    time: new Date().toLocaleTimeString('zh-TW')
                });
            }
        } catch (e) { console.error('訊息解析錯誤', e); }
    });

    ws.on('close', () => {
        const client = clients.get(ws);
        if (client?.username) broadcast({ type: 'system', text: `${client.username} 已離開` });
        clients.delete(ws);
        console.log(`❌ 連線關閉: ${client?.id}`);
    });

    ws.on('error', (err) => console.error('連線錯誤:', err));
});

function broadcast(data, exclude = null) {
    const msg = JSON.stringify(data);
    for (const [ws] of clients) {
        if (ws !== exclude && ws.readyState === WebSocket.OPEN) ws.send(msg);
    }
}

server.listen(8080, () => console.log('💬 WebSocket 伺服器啟動於 ws://localhost:8080'));

// 瀏覽器端 WebSocket 客戶端
const ws = new WebSocket('ws://localhost:8080');

ws.onopen = () => {
    console.log('✅ 已連接到伺服器');
    // 加入聊天室
    ws.send(JSON.stringify({ type: 'join', username: '陳小明' }));
};

ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    if (data.type === 'chat') {
        console.log(`${data.username}: ${data.text}`);
    } else if (data.type === 'system') {
        console.log(`[系統] ${data.text}`);
    }
};

ws.onclose = () => console.log('❌ 連線已中斷');
ws.onerror = (err) => console.error('WebSocket 錯誤:', err);

// 傳送訊息
function sendMessage(text) {
    if (ws.readyState === WebSocket.OPEN) {
        ws.send(JSON.stringify({ type: 'chat', text }));
    }
}

// 📁 .env
PORT=3000
NODE_ENV=production
MONGODB_URI=mongodb+srv://user:[email protected]/myapp
JWT_SECRET=your-super-secret-jwt-key-here-min-32-chars
REDIS_URL=redis://localhost:6379

// 📁 config/env.js
require('dotenv').config();

module.exports = {
    port: parseInt(process.env.PORT) || 3000,
    nodeEnv: process.env.NODE_ENV || 'development',
    mongoUri: process.env.MONGODB_URI,
    jwtSecret: process.env.JWT_SECRET || (() => {
        if (process.env.NODE_ENV === 'production')
            throw new Error('❌ 生產環境必須設定 JWT_SECRET');
        return 'dev-secret-only';
    })(),
    isProduction: process.env.NODE_ENV === 'production'
};

# 安裝 PM2
npm install -g pm2

# 啟動應用程式 (叢集模式，充分利用多核心 CPU)
pm2 start index.js --name "my-app" -i max

# 常用指令
pm2 list              # 查看所有程序
pm2 logs my-app       # 查看日誌
pm2 monit             # 即時監控 CPU/記憶體
pm2 restart my-app    # 重啟
pm2 stop my-app       # 停止
pm2 delete my-app     # 刪除

# 儲存程序清單 (系統重啟後自動還原)
pm2 save
pm2 startup

# 📁 Dockerfile - 多階段建構
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:20-alpine
WORKDIR /app

# 建立非 root 使用者 (安全)
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

COPY --from=builder /app/node_modules ./node_modules
COPY . .

USER appuser
EXPOSE 3000

# 健康檢查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget -qO- http://localhost:3000/health || exit 1

CMD ["node", "index.js"]

// 1. 使用壓縮中介軟體
const compression = require('compression');
app.use(compression());

// 2. 啟用 cluster 模式 (充分利用多核心)
const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
    const cpuCount = os.cpus().length;
    console.log(`啟動 ${cpuCount} 個 Worker 程序`);
    for (let i = 0; i < cpuCount; i++) cluster.fork();
    cluster.on('exit', (worker) => {
        console.log(`Worker ${worker.id} 已退出，重新啟動...`);
        cluster.fork();
    });
} else {
    require('./app'); // 啟動 Express 應用
}

// 3. 適當使用快取
const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 600 }); // 10 分鐘

app.get('/api/config', (req, res) => {
    const cached = cache.get('app-config');
    if (cached) return res.json(cached);
    const config = loadConfigFromDB();
    cache.set('app-config', config);
    res.json(config);
});