如何编写自动安装缺失依赖脚本

本文目录导读：

1. Python项目 (pip)
2. Node.js项目 (npm)
3. 通用Shell脚本
4. 智能检测脚本（Python全能版）
5. 使用建议

Python项目 (pip)

基础版本

#!/usr/bin/env python3
import subprocess
import sys
def install_missing_dependencies():
    """检查并安装缺失的Python包"""
    # 需要的依赖列表
    requirements = [
        'requests',
        'numpy',
        'pandas',
        'flask'
    ]
    for package in requirements:
        try:
            __import__(package.replace('-', '_'))
            print(f"✓ {package} 已安装")
        except ImportError:
            print(f"✗ {package} 未安装，正在安装...")
            subprocess.check_call(
                [sys.executable, '-m', 'pip', 'install', package]
            )
            print(f"✓ {package} 安装完成")
if __name__ == '__main__':
    install_missing_dependencies()

进阶版本（从requirements.txt读取）

#!/usr/bin/env python3
import subprocess
import sys
import os
def install_from_requirements():
    """从requirements.txt安装依赖"""
    req_file = 'requirements.txt'
    if not os.path.exists(req_file):
        print(f"错误：找不到 {req_file}")
        return False
    try:
        import pip
        print("正在检查并安装依赖...")
        # 使用pip自动处理
        subprocess.check_call([
            sys.executable, '-m', 'pip', 'install', 
            '-r', req_file
        ])
        print("所有依赖安装完成！")
        return True
    except subprocess.CalledProcessError as e:
        print(f"安装出错: {e}")
        return False
if __name__ == '__main__':
    install_from_requirements()

Node.js项目 (npm)

#!/usr/bin/env node
const { execSync } = require('child_process');
const fs = require('fs');
const path = require('path');
function checkAndInstallDependencies() {
    console.log('正在检查项目依赖...');
    // 读取package.json
    const packageJsonPath = path.join(process.cwd(), 'package.json');
    if (!fs.existsSync(packageJsonPath)) {
        console.error('错误：找不到package.json');
        process.exit(1);
    }
    const packageJson = require(packageJsonPath);
    const allDeps = {
        ...packageJson.dependencies,
        ...packageJson.devDependencies
    };
    let missingDeps = [];
    // 检查每个依赖
    for (const dep of Object.keys(allDeps)) {
        try {
            require.resolve(dep);
            console.log(`✓ ${dep} 已安装`);
        } catch (e) {
            console.log(`✗ ${dep} 未安装`);
            missingDeps.push(dep);
        }
    }
    // 安装缺失的依赖
    if (missingDeps.length > 0) {
        console.log('\n正在安装缺失的依赖...');
        try {
            execSync(`npm install ${missingDeps.join(' ')}`, {
                stdio: 'inherit'
            });
            console.log('所有依赖安装完成！');
        } catch (error) {
            console.error('安装失败:', error.message);
            process.exit(1);
        }
    } else {
        console.log('所有依赖已安装！');
    }
}
checkAndInstallDependencies();

通用Shell脚本

Linux/Mac版本

#!/bin/bash
# 自动安装缺失依赖脚本
# 支持多种包管理器
echo "检查系统依赖..."
# 定义需要的命令列表
REQUIRED_CMDS=("git" "curl" "wget" "python3" "node")
# 检测包管理器
if command -v apt-get &> /dev/null; then
    PKG_MANAGER="apt-get"
    INSTALL_CMD="sudo apt-get install -y"
elif command -v yum &> /dev/null; then
    PKG_MANAGER="yum"
    INSTALL_CMD="sudo yum install -y"
elif command -v brew &> /dev/null; then
    PKG_MANAGER="brew"
    INSTALL_CMD="brew install"
else
    echo "无法识别的包管理器"
    exit 1
fi
# 检查并安装缺失的命令
for cmd in "${REQUIRED_CMDS[@]}"; do
    if ! command -v $cmd &> /dev/null; then
        echo "✗ $cmd 未安装，正在安装..."
        $INSTALL_CMD $cmd
    else
        echo "✓ $cmd 已安装"
    fi
done
echo "所有依赖检查完成！"

Windows PowerShell版本

# check-dependencies.ps1
Write-Host "检查系统依赖..." -ForegroundColor Cyan
# 定义需要的命令
$requiredCommands = @("git", "node", "npm", "python")
foreach ($cmd in $requiredCommands) {
    try {
        $null = Get-Command $cmd -ErrorAction Stop
        Write-Host "✓ $cmd 已安装" -ForegroundColor Green
    } catch {
        Write-Host "✗ $cmd 未安装" -ForegroundColor Red
        # 使用chocolatey安装（需先安装choco）
        try {
            $null = Get-Command "choco" -ErrorAction Stop
            Write-Host "  正在使用Chocolatey安装 $cmd..." -ForegroundColor Yellow
            Start-Process "choco" -ArgumentList "install $cmd -y" -Wait -NoNewWindow
        } catch {
            Write-Host "  请手动安装 $cmd" -ForegroundColor Yellow
        }
    }
}
Write-Host "依赖检查完成！" -ForegroundColor Green

智能检测脚本（Python全能版）

#!/usr/bin/env python3
"""
智能依赖检测与安装脚本
支持多语言项目
"""
import subprocess
import sys
import json
import os
import platform
class DependencyChecker:
    def __init__(self):
        self.system = platform.system()
    def check_python_deps(self):
        """检查Python依赖"""
        req_file = 'requirements.txt'
        if not os.path.exists(req_file):
            return
        print("\n检查Python依赖...")
        try:
            import pkg_resources
            with open(req_file) as f:
                packages = [line.strip() for line in f if line.strip() and not line.startswith('#')]
            for package in packages:
                try:
                    pkg_resources.require(package.split('>=')[0].split('==')[0])
                    print(f"✓ {package}")
                except (pkg_resources.DistributionNotFound, 
                       pkg_resources.VersionConflict):
                    print(f"✗ {package}")
                    subprocess.check_call([
                        sys.executable, '-m', 'pip', 'install', package
                    ])
                    print(f"  → 已安装")
        except ImportError:
            print("正在安装pkg_resources...")
            subprocess.check_call([
                sys.executable, '-m', 'pip', 'install', 'setuptools'
            ])
            self.check_python_deps()
    def check_node_deps(self):
        """检查Node.js依赖"""
        if not os.path.exists('package.json'):
            return
        print("\n检查Node.js依赖...")
        if not os.path.exists('node_modules'):
            print("node_modules不存在，正在安装...")
            subprocess.check_call(['npm', 'install'])
        else:
            subprocess.check_call(['npm', 'check', '--production'])
    def run(self):
        """主运行函数"""
        print("=" * 50)
        print("智能依赖检查工具")
        print("=" * 50)
        # 检测项目类型
        if os.path.exists('requirements.txt'):
            self.check_python_deps()
        if os.path.exists('package.json'):
            self.check_node_deps()
        print("\n✓ 依赖检查完成！")
if __name__ == '__main__':
    checker = DependencyChecker()
    checker.run()

使用建议

选择合适的脚本

• Python项目：使用Python版本的脚本
• Node.js项目：使用JavaScript版本的脚本
• 混合项目：使用智能检测脚本

安全性考虑

# 添加安全检查
def safe_install():
    """安全安装依赖"""
    try:
        # 验证源的安全性
        trusted_sources = [
            'pypi.org',
            'npmjs.org',
        ]
        # 使用虚拟环境
        if not os.path.exists('venv'):
            subprocess.check_call([
                sys.executable, '-m', 'venv', 'venv'
            ])
        # 在虚拟环境中安装
        pip_path = os.path.join('venv', 'bin', 'pip')
        subprocess.check_call([
            pip_path, 'install', '-r', 'requirements.txt'
        ])
    except Exception as e:
        print(f"安全安装失败: {e}")
        return False

GitHub Actions自动检查

# .github/workflows/deps.yml
name: Check Dependencies
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
jobs:
  check-deps:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Setup Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    - name: Check Python deps
      run: |
        python -m pip install --upgrade pip
        python deps_check.py

选择适合您项目的方案,建议将脚本添加到项目的scripts/或tools/目录中，并在README中说明使用方法。