程序猿指南
Search K

Appearance

Node.js URL处理和路由2024：Web开发者构建RESTful API完整指南 ​

📊 SEO元描述：2024年最新Node.js URL处理和路由教程，详解URL模块使用、查询参数解析、路由实现。包含完整RESTful API设计示例，适合Web开发者快速掌握路由开发。

核心关键词：Node.js URL处理2024、Node.js路由实现、RESTful API设计、查询参数解析、Node.js Web路由

长尾关键词：Node.js怎么处理URL、URL模块使用方法、Node.js路由系统、RESTful API开发教程、Node.js查询参数解析

📚 URL处理和路由学习目标与核心收获 ​

通过本节Node.js URL处理和路由教程，你将系统性掌握：

  • ✅ URL模块核心功能：深入理解Node.js内置URL模块的使用方法和应用场景
  • ✅ 查询参数解析：掌握URL查询字符串的解析和处理技巧
  • ✅ 路径参数处理：学会提取和处理URL路径中的动态参数
  • ✅ 简单路由实现：从零开始构建基础的路由系统
  • ✅ RESTful API设计：掌握RESTful架构风格的API设计原则和实现
  • ✅ 路由中间件概念：理解中间件模式在路由处理中的应用

🎯 适合人群 ​

  • Node.js进阶学习者的Web开发技能提升
  • 后端开发工程师的API设计能力培养
  • 全栈开发者的服务端路由系统理解
  • 计算机专业学生的Web架构设计学习

🌟 URL处理是什么？为什么路由对Web应用如此重要？ ​

URL处理是什么？这是Web开发中的核心概念。URL处理是指解析、分析和响应不同URL请求的过程，也是Web应用架构的重要组成部分。

URL处理的核心特性 ​

  • 🎯 路径解析：将URL分解为协议、主机、路径、查询参数等组件
  • 🔧 参数提取：从URL中提取查询参数和路径参数
  • 💡 路由匹配：根据URL路径匹配对应的处理函数
  • 📚 RESTful支持：支持REST架构风格的资源定位
  • 🚀 动态路由：支持带参数的动态路由匹配

💡 设计理念：良好的URL设计应该直观、语义化，便于用户理解和搜索引擎索引

Node.js URL模块基础使用 ​

让我们从URL模块的基本用法开始，理解URL解析的核心功能：

javascript
// 🎉 URL模块基础使用示例
const http = require('http');
const url = require('url');
const querystring = require('querystring');

const server = http.createServer((req, res) => {
    // 解析URL的不同方法
    console.log('=== URL解析示例 ===');
    console.log('原始URL:', req.url);
    
    // 方法1：使用url.parse()（传统方法）
    const parsedUrl = url.parse(req.url, true);
    console.log('解析结果:', {
        protocol: parsedUrl.protocol,
        host: parsedUrl.host,
        pathname: parsedUrl.pathname,
        search: parsedUrl.search,
        query: parsedUrl.query,
        hash: parsedUrl.hash
    });
    
    // 方法2：使用URL构造函数（现代方法）
    try {
        const urlObj = new URL(req.url, `http://${req.headers.host}`);
        console.log('URL对象:', {
            origin: urlObj.origin,
            pathname: urlObj.pathname,
            search: urlObj.search,
            searchParams: Object.fromEntries(urlObj.searchParams)
        });
    } catch (error) {
        console.log('URL解析错误:', error.message);
    }
    
    // 响应解析结果
    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
    res.end(JSON.stringify({
        originalUrl: req.url,
        pathname: parsedUrl.pathname,
        query: parsedUrl.query,
        method: req.method,
        timestamp: new Date().toISOString()
    }, null, 2));
});

server.listen(3000, () => {
    console.log('URL解析服务器启动：http://localhost:3000');
    console.log('测试URL示例：');
    console.log('- http://localhost:3000/users?page=1&limit=10');
    console.log('- http://localhost:3000/api/products?category=electronics&sort=price');
});

URL解析核心概念 ​

  • pathname：URL的路径部分，不包含查询参数
  • search：完整的查询字符串，包含问号
  • query：解析后的查询参数对象
  • searchParams：现代URL API的查询参数处理接口

查询参数处理详解 ​

高级查询参数处理 ​

javascript
// 🔍 查询参数处理详解
const http = require('http');
const url = require('url');

// 查询参数处理工具函数
function parseQueryParams(queryString) {
    const params = new URLSearchParams(queryString);
    const result = {};
    
    for (const [key, value] of params.entries()) {
        // 处理数组参数（如：tags=js&tags=node）
        if (result[key]) {
            if (Array.isArray(result[key])) {
                result[key].push(value);
            } else {
                result[key] = [result[key], value];
            }
        } else {
            result[key] = value;
        }
    }
    
    return result;
}

// 参数验证函数
function validateParams(params, rules) {
    const errors = [];
    
    for (const [field, rule] of Object.entries(rules)) {
        const value = params[field];
        
        if (rule.required && !value) {
            errors.push(`${field} 是必需参数`);
            continue;
        }
        
        if (value && rule.type === 'number' && isNaN(Number(value))) {
            errors.push(`${field} 必须是数字`);
        }
        
        if (value && rule.min && Number(value) < rule.min) {
            errors.push(`${field} 不能小于 ${rule.min}`);
        }
        
        if (value && rule.max && Number(value) > rule.max) {
            errors.push(`${field} 不能大于 ${rule.max}`);
        }
    }
    
    return errors;
}

const server = http.createServer((req, res) => {
    const parsedUrl = url.parse(req.url, true);
    const pathname = parsedUrl.pathname;
    const query = parsedUrl.query;
    
    // 设置响应头
    res.setHeader('Content-Type', 'application/json; charset=utf-8');
    
    if (pathname === '/api/users') {
        // 用户列表API - 支持分页和筛选
        const paramRules = {
            page: { type: 'number', min: 1, max: 1000 },
            limit: { type: 'number', min: 1, max: 100 },
            sort: { type: 'string' },
            order: { type: 'string' }
        };
        
        const errors = validateParams(query, paramRules);
        
        if (errors.length > 0) {
            res.writeHead(400);
            res.end(JSON.stringify({
                error: 'Parameter validation failed',
                details: errors
            }));
            return;
        }
        
        // 处理查询参数
        const page = parseInt(query.page) || 1;
        const limit = parseInt(query.limit) || 10;
        const sort = query.sort || 'id';
        const order = query.order || 'asc';
        
        // 模拟用户数据
        const users = Array.from({ length: 50 }, (_, i) => ({
            id: i + 1,
            name: `User ${i + 1}`,
            email: `user${i + 1}@example.com`,
            age: 20 + (i % 50)
        }));
        
        // 分页处理
        const startIndex = (page - 1) * limit;
        const endIndex = startIndex + limit;
        const paginatedUsers = users.slice(startIndex, endIndex);
        
        res.writeHead(200);
        res.end(JSON.stringify({
            data: paginatedUsers,
            pagination: {
                page,
                limit,
                total: users.length,
                totalPages: Math.ceil(users.length / limit)
            },
            sort: { field: sort, order }
        }, null, 2));
        
    } else if (pathname === '/api/search') {
        // 搜索API - 支持多种查询参数
        const searchParams = parseQueryParams(parsedUrl.search);
        
        res.writeHead(200);
        res.end(JSON.stringify({
            query: searchParams,
            message: '搜索功能演示',
            examples: {
                basic: '/api/search?q=nodejs',
                advanced: '/api/search?q=nodejs&category=tutorial&tags=backend&tags=javascript',
                filters: '/api/search?q=nodejs&minPrice=10&maxPrice=100&inStock=true'
            }
        }, null, 2));
        
    } else {
        res.writeHead(404);
        res.end(JSON.stringify({
            error: 'Not Found',
            message: '请求的资源不存在'
        }));
    }
});

server.listen(3000, () => {
    console.log('查询参数处理服务器启动：http://localhost:3000');
    console.log('测试API：');
    console.log('- http://localhost:3000/api/users?page=2&limit=5&sort=name&order=desc');
    console.log('- http://localhost:3000/api/search?q=nodejs&tags=backend&tags=javascript');
});

查询参数处理要点：

  • 🎯 参数解析：正确处理单值和多值参数
  • 🎯 类型转换：将字符串参数转换为适当的数据类型
  • 🎯 参数验证：验证必需参数和参数格式
  • 🎯 默认值处理：为可选参数提供合理的默认值

路径参数处理和动态路由 ​

路径参数提取实现 ​

javascript
// 🚀 路径参数处理和动态路由
const http = require('http');
const url = require('url');

// 路由匹配工具类
class Router {
    constructor() {
        this.routes = [];
    }

    // 添加路由
    addRoute(method, pattern, handler) {
        // 将路由模式转换为正则表达式
        const paramNames = [];
        const regexPattern = pattern.replace(/:([^/]+)/g, (match, paramName) => {
            paramNames.push(paramName);
            return '([^/]+)';
        });

        this.routes.push({
            method,
            pattern,
            regex: new RegExp(`^${regexPattern}$`),
            paramNames,
            handler
        });
    }

    // 匹配路由
    match(method, pathname) {
        for (const route of this.routes) {
            if (route.method !== method && route.method !== 'ALL') {
                continue;
            }

            const match = pathname.match(route.regex);
            if (match) {
                const params = {};
                route.paramNames.forEach((name, index) => {
                    params[name] = match[index + 1];
                });

                return {
                    handler: route.handler,
                    params,
                    route: route.pattern
                };
            }
        }

        return null;
    }

    // 便捷方法
    get(pattern, handler) {
        this.addRoute('GET', pattern, handler);
    }

    post(pattern, handler) {
        this.addRoute('POST', pattern, handler);
    }

    put(pattern, handler) {
        this.addRoute('PUT', pattern, handler);
    }

    delete(pattern, handler) {
        this.addRoute('DELETE', pattern, handler);
    }
}

// 创建路由实例
const router = new Router();

// 定义路由处理函数
router.get('/users', (req, res, params, query) => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
        message: '获取用户列表',
        query,
        data: [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' }
        ]
    }));
});

router.get('/users/:id', (req, res, params, query) => {
    const userId = parseInt(params.id);

    if (isNaN(userId)) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            error: 'Invalid user ID',
            message: '用户ID必须是数字'
        }));
        return;
    }

    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
        message: '获取单个用户',
        params,
        data: {
            id: userId,
            name: `User ${userId}`,
            email: `user${userId}@example.com`
        }
    }));
});

router.get('/users/:id/posts', (req, res, params, query) => {
    const userId = parseInt(params.id);

    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
        message: '获取用户文章',
        params,
        query,
        data: [
            { id: 1, title: `Post 1 by User ${userId}`, userId },
            { id: 2, title: `Post 2 by User ${userId}`, userId }
        ]
    }));
});

router.get('/posts/:postId/comments/:commentId', (req, res, params, query) => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
        message: '获取文章评论',
        params,
        data: {
            postId: parseInt(params.postId),
            commentId: parseInt(params.commentId),
            content: '这是一条评论',
            author: 'Anonymous'
        }
    }));
});

// 创建HTTP服务器
const server = http.createServer((req, res) => {
    const parsedUrl = url.parse(req.url, true);
    const pathname = parsedUrl.pathname;
    const query = parsedUrl.query;
    const method = req.method;

    console.log(`${method} ${pathname}`);

    // 匹配路由
    const matchResult = router.match(method, pathname);

    if (matchResult) {
        try {
            matchResult.handler(req, res, matchResult.params, query);
        } catch (error) {
            console.error('路由处理错误:', error);
            res.writeHead(500, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({
                error: 'Internal Server Error',
                message: '服务器内部错误'
            }));
        }
    } else {
        // 404 处理
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            error: 'Not Found',
            message: `路由 ${method} ${pathname} 不存在`,
            availableRoutes: [
                'GET /users',
                'GET /users/:id',
                'GET /users/:id/posts',
                'GET /posts/:postId/comments/:commentId'
            ]
        }));
    }
});

server.listen(3000, () => {
    console.log('动态路由服务器启动：http://localhost:3000');
    console.log('测试路由：');
    console.log('- GET http://localhost:3000/users');
    console.log('- GET http://localhost:3000/users/123');
    console.log('- GET http://localhost:3000/users/123/posts');
    console.log('- GET http://localhost:3000/posts/456/comments/789');
});

路径参数处理要点 ​

  • 参数提取：使用正则表达式从URL路径中提取参数
  • 类型转换：将字符串参数转换为适当的数据类型
  • 参数验证：验证路径参数的有效性
  • 嵌套路由：支持多级路径参数的处理

RESTful API设计实战 ​

完整的RESTful API实现 ​

javascript
// 🎯 RESTful API设计实战
const http = require('http');
const url = require('url');

// 模拟数据存储
let users = [
    { id: 1, name: 'Alice', email: 'alice@example.com', age: 25 },
    { id: 2, name: 'Bob', email: 'bob@example.com', age: 30 },
    { id: 3, name: 'Charlie', email: 'charlie@example.com', age: 35 }
];

let nextUserId = 4;

// RESTful API路由处理器
class RESTfulAPI {
    constructor() {
        this.routes = new Map();
        this.setupRoutes();
    }

    setupRoutes() {
        // 用户资源的CRUD操作
        this.routes.set('GET /api/users', this.getUsers.bind(this));
        this.routes.set('GET /api/users/:id', this.getUser.bind(this));
        this.routes.set('POST /api/users', this.createUser.bind(this));
        this.routes.set('PUT /api/users/:id', this.updateUser.bind(this));
        this.routes.set('DELETE /api/users/:id', this.deleteUser.bind(this));

        // API文档路由
        this.routes.set('GET /api', this.getAPIDoc.bind(this));
    }

    // 获取用户列表
    async getUsers(req, res, params, query) {
        const page = parseInt(query.page) || 1;
        const limit = parseInt(query.limit) || 10;
        const search = query.search || '';

        // 搜索过滤
        let filteredUsers = users;
        if (search) {
            filteredUsers = users.filter(user =>
                user.name.toLowerCase().includes(search.toLowerCase()) ||
                user.email.toLowerCase().includes(search.toLowerCase())
            );
        }

        // 分页处理
        const startIndex = (page - 1) * limit;
        const endIndex = startIndex + limit;
        const paginatedUsers = filteredUsers.slice(startIndex, endIndex);

        this.sendJSON(res, 200, {
            data: paginatedUsers,
            pagination: {
                page,
                limit,
                total: filteredUsers.length,
                totalPages: Math.ceil(filteredUsers.length / limit)
            },
            search
        });
    }

    // 获取单个用户
    async getUser(req, res, params, query) {
        const userId = parseInt(params.id);
        const user = users.find(u => u.id === userId);

        if (!user) {
            this.sendJSON(res, 404, {
                error: 'User not found',
                message: `用户 ID ${userId} 不存在`
            });
            return;
        }

        this.sendJSON(res, 200, { data: user });
    }

    // 创建用户
    async createUser(req, res, params, query) {
        try {
            const body = await this.parseRequestBody(req);
            const userData = JSON.parse(body);

            // 验证必需字段
            if (!userData.name || !userData.email) {
                this.sendJSON(res, 400, {
                    error: 'Validation failed',
                    message: 'name 和 email 是必需字段'
                });
                return;
            }

            // 检查邮箱是否已存在
            if (users.some(u => u.email === userData.email)) {
                this.sendJSON(res, 409, {
                    error: 'Conflict',
                    message: '邮箱已存在'
                });
                return;
            }

            // 创建新用户
            const newUser = {
                id: nextUserId++,
                name: userData.name,
                email: userData.email,
                age: userData.age || null
            };

            users.push(newUser);

            this.sendJSON(res, 201, {
                message: '用户创建成功',
                data: newUser
            });

        } catch (error) {
            this.sendJSON(res, 400, {
                error: 'Bad Request',
                message: '请求数据格式错误'
            });
        }
    }

    // 更新用户
    async updateUser(req, res, params, query) {
        const userId = parseInt(params.id);
        const userIndex = users.findIndex(u => u.id === userId);

        if (userIndex === -1) {
            this.sendJSON(res, 404, {
                error: 'User not found',
                message: `用户 ID ${userId} 不存在`
            });
            return;
        }

        try {
            const body = await this.parseRequestBody(req);
            const updateData = JSON.parse(body);

            // 更新用户数据
            const updatedUser = { ...users[userIndex], ...updateData };
            users[userIndex] = updatedUser;

            this.sendJSON(res, 200, {
                message: '用户更新成功',
                data: updatedUser
            });

        } catch (error) {
            this.sendJSON(res, 400, {
                error: 'Bad Request',
                message: '请求数据格式错误'
            });
        }
    }

    // 删除用户
    async deleteUser(req, res, params, query) {
        const userId = parseInt(params.id);
        const userIndex = users.findIndex(u => u.id === userId);

        if (userIndex === -1) {
            this.sendJSON(res, 404, {
                error: 'User not found',
                message: `用户 ID ${userId} 不存在`
            });
            return;
        }

        const deletedUser = users.splice(userIndex, 1)[0];

        this.sendJSON(res, 200, {
            message: '用户删除成功',
            data: deletedUser
        });
    }

    // API文档
    async getAPIDoc(req, res, params, query) {
        this.sendJSON(res, 200, {
            title: 'User Management API',
            version: '1.0.0',
            endpoints: {
                'GET /api/users': '获取用户列表（支持分页和搜索）',
                'GET /api/users/:id': '获取单个用户',
                'POST /api/users': '创建新用户',
                'PUT /api/users/:id': '更新用户',
                'DELETE /api/users/:id': '删除用户'
            },
            examples: {
                'GET /api/users?page=1&limit=5&search=alice': '搜索用户',
                'POST /api/users': '创建用户（需要JSON body）',
                'PUT /api/users/1': '更新用户（需要JSON body）'
            }
        });
    }

    // 工具方法：解析请求体
    parseRequestBody(req) {
        return new Promise((resolve, reject) => {
            let body = '';
            req.on('data', chunk => {
                body += chunk.toString();
            });
            req.on('end', () => {
                resolve(body);
            });
            req.on('error', reject);
        });
    }

    // 工具方法：发送JSON响应
    sendJSON(res, statusCode, data) {
        res.writeHead(statusCode, {
            'Content-Type': 'application/json; charset=utf-8',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type'
        });
        res.end(JSON.stringify(data, null, 2));
    }
}

// 路由匹配函数
function matchRoute(method, pathname) {
    const api = new RESTfulAPI();

    for (const [routePattern, handler] of api.routes) {
        const [routeMethod, routePath] = routePattern.split(' ');

        if (routeMethod !== method) continue;

        // 处理路径参数
        const paramNames = [];
        const regexPattern = routePath.replace(/:([^/]+)/g, (match, paramName) => {
            paramNames.push(paramName);
            return '([^/]+)';
        });

        const regex = new RegExp(`^${regexPattern}$`);
        const match = pathname.match(regex);

        if (match) {
            const params = {};
            paramNames.forEach((name, index) => {
                params[name] = match[index + 1];
            });

            return { handler, params };
        }
    }

    return null;
}

// 创建HTTP服务器
const server = http.createServer(async (req, res) => {
    const parsedUrl = url.parse(req.url, true);
    const pathname = parsedUrl.pathname;
    const query = parsedUrl.query;
    const method = req.method;

    console.log(`${method} ${pathname}`);

    // 处理CORS预检请求
    if (method === 'OPTIONS') {
        res.writeHead(200, {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type'
        });
        res.end();
        return;
    }

    // 匹配路由
    const matchResult = matchRoute(method, pathname);

    if (matchResult) {
        try {
            await matchResult.handler(req, res, matchResult.params, query);
        } catch (error) {
            console.error('API处理错误:', error);
            res.writeHead(500, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({
                error: 'Internal Server Error',
                message: '服务器内部错误'
            }));
        }
    } else {
        // 404 处理
        res.writeHead(404, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({
            error: 'Not Found',
            message: `API端点 ${method} ${pathname} 不存在`,
            documentation: 'GET /api'
        }));
    }
});

server.listen(3000, () => {
    console.log('RESTful API服务器启动：http://localhost:3000');
    console.log('API文档：http://localhost:3000/api');
    console.log('测试API：');
    console.log('- GET http://localhost:3000/api/users');
    console.log('- POST http://localhost:3000/api/users');
    console.log('- GET http://localhost:3000/api/users/1');
});

RESTful API设计原则：

  • 🎯 资源导向：URL表示资源，HTTP方法表示操作
  • 🎯 统一接口：使用标准HTTP方法（GET、POST、PUT、DELETE）
  • 🎯 无状态：每个请求包含处理所需的所有信息
  • 🎯 分层系统：支持缓存、负载均衡等中间层

📚 URL处理和路由学习总结与下一步规划 ​

✅ 本节核心收获回顾 ​

通过本节Node.js URL处理和路由教程的学习，你已经掌握：

  1. URL模块核心功能：深入理解了Node.js URL模块的解析方法和现代URL API的使用
  2. 查询参数解析：掌握了复杂查询参数的处理、验证和类型转换技巧
  3. 路径参数处理：学会了动态路由的实现和路径参数的提取方法
  4. 简单路由系统：从零开始构建了基础的路由匹配和处理系统
  5. RESTful API设计：掌握了REST架构风格的API设计原则和完整实现
  6. 错误处理机制：学会了API开发中的错误处理和状态码使用

🎯 URL处理和路由下一步 ​

  1. 学习Express框架：基于路由基础，学习更强大的Express路由系统
  2. 中间件模式深入：理解和实现路由中间件的概念和应用
  3. API文档生成：学习使用Swagger等工具自动生成API文档
  4. 路由性能优化：学习路由匹配的性能优化和缓存策略

🔗 相关学习资源 ​

💪 实践练习建议 ​

  1. 构建博客API：实现文章、评论、标签的完整CRUD操作
  2. 添加身份验证：为API添加JWT认证和权限控制
  3. 实现API版本控制：支持多版本API的路由设计
  4. 性能测试：使用工具测试API的并发处理能力

🔍 常见问题FAQ ​

Q1: URL模块的parse方法和URL构造函数有什么区别？ ​

A: url.parse()是传统的解析方法，返回的对象属性较多但性能较低。URL构造函数是现代标准，性能更好，提供了searchParams等便捷API，建议在新项目中使用URL构造函数。

Q2: 如何处理URL中的中文字符和特殊字符？ ​

A: 使用encodeURIComponent()和decodeURIComponent()进行编码和解码。Node.js的URL模块会自动处理大部分编码问题，但在手动构建URL时需要注意字符编码。

Q3: 路由参数和查询参数应该如何选择使用？ ​

A: 路由参数用于标识资源（如/users/123中的123），查询参数用于过滤、排序、分页等操作（如?page=1&sort=name）。路由参数是URL路径的一部分，查询参数是可选的。

Q4: RESTful API中PUT和PATCH方法有什么区别？ ​

A: PUT用于完整替换资源，需要提供资源的所有字段。PATCH用于部分更新，只需要提供要修改的字段。在实际应用中，PATCH更常用于更新操作。

Q5: 如何实现API的版本控制？ ​

A: 常见方法有：1）URL路径版本（/api/v1/users）；2）请求头版本（Accept: application/vnd.api+json;version=1）；3）查询参数版本（/api/users?version=1）。推荐使用URL路径版本，简单直观。

🛠️ 故障排除指南 ​

常见问题解决方案 ​

URL解析错误 ​

javascript
// 问题：URL解析失败或返回undefined
// 解决：正确处理URL解析异常

function safeParseURL(urlString, base) {
    try {
        return new URL(urlString, base);
    } catch (error) {
        console.error('URL解析错误:', error.message);
        return null;
    }
}

// 使用示例
const parsedUrl = safeParseURL(req.url, `http://${req.headers.host}`);
if (!parsedUrl) {
    res.writeHead(400, { 'Content-Type': 'text/plain' });
    res.end('Invalid URL');
    return;
}

路由参数类型转换 ​

javascript
// 问题：路径参数始终是字符串类型
// 解决：实现类型转换和验证

function convertParam(value, type) {
    switch (type) {
        case 'number':
            const num = Number(value);
            return isNaN(num) ? null : num;
        case 'boolean':
            return value === 'true';
        case 'date':
            const date = new Date(value);
            return isNaN(date.getTime()) ? null : date;
        default:
            return value;
    }
}

// 使用示例
const userId = convertParam(params.id, 'number');
if (userId === null) {
    res.writeHead(400, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: 'Invalid user ID' }));
    return;
}

查询参数数组处理 ​

javascript
// 问题：查询参数数组处理不正确
// 解决：正确处理单值和多值参数

function normalizeQueryParam(value) {
    if (Array.isArray(value)) {
        return value;
    }
    return value ? [value] : [];
}

// 使用示例
const tags = normalizeQueryParam(query.tags);
console.log('标签数组:', tags); // 始终是数组

路由冲突处理 ​

javascript
// 问题：路由模式冲突导致匹配错误
// 解决：按特定性排序路由，优先匹配具体路由

class Router {
    constructor() {
        this.routes = [];
    }

    addRoute(method, pattern, handler) {
        // 计算路由特定性（参数越少越具体）
        const specificity = (pattern.match(/:/g) || []).length;

        this.routes.push({
            method,
            pattern,
            handler,
            specificity
        });

        // 按特定性排序，具体路由优先
        this.routes.sort((a, b) => a.specificity - b.specificity);
    }
}

"掌握URL处理和路由是构建Web应用的关键技能。从基础的URL解析到复杂的RESTful API设计，每一步都为你的全栈开发之路奠定坚实基础。继续探索，向更高级的Web开发技术迈进！"