JavaScript系列（85）--包管理工具详解

JavaScript 包管理工具详解 📦

包管理工具是现代前端开发的重要基础设施，它帮助我们管理项目依赖、版本控制和包发布。让我们深入了解主流的包管理工具及其最佳实践。

包管理工具概述 🌟

💡 小知识：npm（Node Package Manager）是最早也是最广泛使用的JavaScript包管理工具，而yarn和pnpm则是后来出现的替代方案，它们都致力于提供更好的性能、安全性和用户体验。

npm 详解 📊

// 1. npm配置管理
class NPMConfig {
    static getDefaultConfig() {
        return {
            registry: 'https://registry.npmjs.org/',
            scope: '',
            access: 'public',
            proxy: null,
            'package-lock': true,
            'save-exact': false
        };
    }
    
    static generateNPMRC() {
        return `
            registry=https://registry.npmjs.org/
            save-exact=true
            package-lock=true
            engine-strict=true
        `;
    }
    
    static generateConfig(options) {
        return {
            name: options.name,
            version: options.version,
            description: options.description,
            main: 'index.js',
            scripts: {
                test: 'echo "Error: no test specified" && exit 1'
            },
            keywords: [],
            author: '',
            license: 'ISC',
            dependencies: {},
            devDependencies: {}
        };
    }
}

// 2. 依赖管理
class DependencyManager {
    constructor(packageJson) {
        this.packageJson = packageJson;
    }
    
    addDependency(name, version, isDev = false) {
        const target = isDev ? 'devDependencies' : 'dependencies';
        this.packageJson[target] = this.packageJson[target] || {};
        this.packageJson[target][name] = version;
    }
    
    removeDependency(name, isDev = false) {
        const target = isDev ? 'devDependencies' : 'dependencies';
        if (this.packageJson[target]) {
            delete this.packageJson[target][name];
        }
    }
    
    updateDependency(name, version, isDev = false) {
        this.addDependency(name, version, isDev);
    }
    
    getDependencyVersion(name, isDev = false) {
        const target = isDev ? 'devDependencies' : 'dependencies';
        return this.packageJson[target]?.[name];
    }
}

// 3. 脚本管理
class ScriptManager {
    constructor(packageJson) {
        this.packageJson = packageJson;
        this.scripts = this.packageJson.scripts || {};
    }
    
    addScript(name, command) {
        this.scripts[name] = command;
    }
    
    removeScript(name) {
        delete this.scripts[name];
    }
    
    getScript(name) {
        return this.scripts[name];
    }
    
    getAllScripts() {
        return { ...this.scripts };
    }
}

yarn 特性与应用 🧶

// 1. yarn配置
class YarnConfig {
    static getDefaultConfig() {
        return {
            nodeLinker: 'node-modules',
            plugins: [],
            yarnPath: '.yarn/releases/yarn-3.x.x.cjs',
            enableGlobalCache: true
        };
    }
    
    static generateRcFile() {
        return `
            nodeLinker: node-modules
            enableGlobalCache: true
            
            packageExtensions:
              'react-dom@*':
                peerDependencies:
                  react: '*'
            
            plugins:
              - path: .yarn/plugins/@yarnpkg/plugin-typescript.cjs
                spec: "@yarnpkg/plugin-typescript"
        `;
    }
    
    static generateIgnoreFile() {
        return `
            .yarn/*
            !.yarn/patches
            !.yarn/plugins
            !.yarn/releases
            !.yarn/sdks
            !.yarn/versions
        `;
    }
}

// 2. 工作区管理
class WorkspaceManager {
    constructor(root) {
        this.root = root;
        this.workspaces = new Map();
    }
    
    addWorkspace(name, location) {
        this.workspaces.set(name, {
            location,
            dependencies: new Set(),
            devDependencies: new Set()
        });
    }
    
    linkWorkspaces() {
        for (const [name, workspace] of this.workspaces) {
            this.updateWorkspaceDependencies(name);
        }
    }
    
    updateWorkspaceDependencies(name) {
        const workspace = this.workspaces.get(name);
        if (!workspace) return;
        
        // 更新工作区依赖
        const packageJson = require(`${workspace.location}/package.json`);
        
        for (const dep of Object.keys(packageJson.dependencies || {})) {
            if (this.workspaces.has(dep)) {
                workspace.dependencies.add(dep);
            }
        }
    }
}

// 3. 缓存管理
class CacheManager {
    static getCachePath() {
        return process.platform === 'win32'
            ? '%LocalAppData%/Yarn/Cache'
            : '~/.cache/yarn';
    }
    
    static clearCache() {
        return new Promise((resolve, reject) => {
            const cachePath = this.getCachePath();
            // 清理缓存目录
            fs.rm(cachePath, { recursive: true }, (err) => {
                if (err) reject(err);
                else resolve();
            });
        });
    }
    
    static getCacheInfo() {
        const cachePath = this.getCachePath();
        return new Promise((resolve, reject) => {
            fs.readdir(cachePath, (err, files) => {
                if (err) reject(err);
                else {
                    resolve({
                        totalFiles: files.length,
                        size: this.calculateSize(cachePath)
                    });
                }
            });
        });
    }
}

pnpm 创新特性 🚀

// 1. 硬链接管理
class HardLinkManager {
    static getStoreLocation() {
        return process.platform === 'win32'
            ? '%LocalAppData%/pnpm/store'
            : '~/.pnpm-store';
    }
    
    static async createHardLink(source, target) {
        try {
            await fs.promises.link(source, target);
            return true;
        } catch (error) {
            console.error('Failed to create hard link:', error);
            return false;
        }
    }
    
    static async verifyHardLink(file1, file2) {
        try {
            const stat1 = await fs.promises.stat(file1);
            const stat2 = await fs.promises.stat(file2);
            
            return stat1.ino === stat2.ino;
        } catch (error) {
            return false;
        }
    }
}

// 2. 依赖解析
class DependencyResolver {
    constructor() {
        this.dependencies = new Map();
        this.virtualStore = new Map();
    }
    
    addDependency(name, version, dependencies = {}) {
        const key = `${name}@${version}`;
        this.dependencies.set(key, {
            name,
            version,
            dependencies
        });
    }
    
    resolveDependencies(packageName, version) {
        const resolved = new Set();
        this.resolveRecursive(packageName, version, resolved);
        return Array.from(resolved);
    }
    
    resolveRecursive(name, version, resolved) {
        const key = `${name}@${version}`;
        if (resolved.has(key)) return;
        
        resolved.add(key);
        const pkg = this.dependencies.get(key);
        
        if (pkg) {
            for (const [depName, depVersion] of Object.entries(pkg.dependencies)) {
                this.resolveRecursive(depName, depVersion, resolved);
            }
        }
    }
}

// 3. 虚拟存储
class VirtualStore {
    constructor(root) {
        this.root = root;
        this.store = new Map();
    }
    
    addPackage(name, version, content) {
        const key = `${name}@${version}`;
        this.store.set(key, {
            content,
            references: new Set()
        });
    }
    
    getPackage(name, version) {
        return this.store.get(`${name}@${version}`);
    }
    
    addReference(name, version, reference) {
        const pkg = this.getPackage(name, version);
        if (pkg) {
            pkg.references.add(reference);
        }
    }
    
    removeReference(name, version, reference) {
        const pkg = this.getPackage(name, version);
        if (pkg) {
            pkg.references.delete(reference);
            
            // 如果没有引用了，考虑清理
            if (pkg.references.size === 0) {
                this.store.delete(`${name}@${version}`);
            }
        }
    }
}

版本管理与发布 📈

// 1. 版本控制
class VersionManager {
    static validateVersion(version) {
        return /^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version);
    }
    
    static incrementVersion(version, type = 'patch') {
        const [major, minor, patch] = version.split('.');
        
        switch (type) {
            case 'major':
                return `${Number(major) + 1}.0.0`;
            case 'minor':
                return `${major}.${Number(minor) + 1}.0`;
            case 'patch':
                return `${major}.${minor}.${Number(patch) + 1}`;
            default:
                throw new Error('Invalid version increment type');
        }
    }
    
    static compareVersions(v1, v2) {
        const normalize = v => v.split('.').map(Number);
        const [maj1, min1, pat1] = normalize(v1);
        const [maj2, min2, pat2] = normalize(v2);
        
        if (maj1 !== maj2) return maj1 - maj2;
        if (min1 !== min2) return min1 - min2;
        return pat1 - pat2;
    }
}

// 2. 发布管理
class PublishManager {
    constructor(packageJson) {
        this.packageJson = packageJson;
    }
    
    async prepareRelease() {
        // 验证package.json
        this.validatePackageJson();
        
        // 生成构建文件
        await this.buildPackage();
        
        // 生成文档
        await this.generateDocs();
        
        // 更新版本号
        this.updateVersion();
    }
    
    validatePackageJson() {
        const required = ['name', 'version', 'main', 'license'];
        
        for (const field of required) {
            if (!this.packageJson[field]) {
                throw new Error(`Missing required field: ${field}`);
            }
        }
    }
    
    async buildPackage() {
        // 实现构建逻辑
    }
    
    async generateDocs() {
        // 实现文档生成逻辑
    }
    
    updateVersion() {
        const currentVersion = this.packageJson.version;
        this.packageJson.version = VersionManager.incrementVersion(currentVersion);
    }
}

// 3. 发布钩子
class PublishHooks {
    static getDefaultHooks() {
        return {
            prepublish: 'npm test',
            prepare: 'npm run build',
            prepublishOnly: 'npm run lint',
            preversion: 'npm run lint',
            version: 'npm run format && git add -A src',
            postversion: 'git push && git push --tags'
        };
    }
    
    static generateHooksScript() {
        const hooks = this.getDefaultHooks();
        return Object.entries(hooks)
            .map(([hook, script]) => `"${hook}": "${script}"`)
            .join(',\n');
    }
}

安全最佳实践 🔒

// 1. 依赖审查
class SecurityAuditor {
    static async auditDependencies() {
        return new Promise((resolve, reject) => {
            exec('npm audit', (error, stdout, stderr) => {
                if (error) {
                    reject(new Error(`Audit failed: ${stderr}`));
                    return;
                }
                resolve(this.parseAuditResult(stdout));
            });
        });
    }
    
    static parseAuditResult(output) {
        // 解析审计结果
        const results = {
            low: 0,
            moderate: 0,
            high: 0,
            critical: 0
        };
        
        // 实现解析逻辑
        
        return results;
    }
    
    static generateReport(results) {
        return {
            summary: `Found ${
                Object.values(results).reduce((a, b) => a + b, 0)
            } vulnerabilities`,
            details: results,
            timestamp: new Date().toISOString()
        };
    }
}

// 2. 完整性检查
class IntegrityChecker {
    static async verifyIntegrity() {
        return new Promise((resolve, reject) => {
            exec('npm verify-integrity', (error, stdout) => {
                if (error) {
                    reject(new Error('Integrity check failed'));
                    return;
                }
                resolve(true);
            });
        });
    }
    
    static generateIntegrityFile() {
        return new Promise((resolve, reject) => {
            exec('npm shrinkwrap', (error) => {
                if (error) {
                    reject(new Error('Failed to generate integrity file'));
                    return;
                }
                resolve(true);
            });
        });
    }
}

// 3. 许可证检查
class LicenseChecker {
    static allowedLicenses = new Set([
        'MIT',
        'ISC',
        'Apache-2.0',
        'BSD-3-Clause'
    ]);
    
    static async checkLicenses() {
        return new Promise((resolve, reject) => {
            exec('npm ls --json', (error, stdout) => {
                if (error) {
                    reject(new Error('License check failed'));
                    return;
                }
                
                const dependencies = JSON.parse(stdout);
                const issues = this.findLicenseIssues(dependencies);
                resolve(issues);
            });
        });
    }
    
    static findLicenseIssues(dependencies) {
        const issues = [];
        
        const check = (dep, path = []) => {
            if (dep.license && !this.allowedLicenses.has(dep.license)) {
                issues.push({
                    name: dep.name,
                    version: dep.version,
                    license: dep.license,
                    path: path.join(' -> ')
                });
            }
            
            if (dep.dependencies) {
                for (const [name, child] of Object.entries(dep.dependencies)) {
                    check(child, [...path, name]);
                }
            }
        };
        
        check(dependencies);
        return issues;
    }
}