脚本怎样检测插件版本更新

本文目录导读：

1. HTTP请求比对版本号（最常用）
2. GitHub Releases API（开源插件适用）
3. 本地缓存机制（避免频繁请求）
4. 自动更新脚本（JavaScript/Node.js示例）
5. 最佳实践建议

要检测插件版本更新,通常有以下几种主流方法，我按实现难度从低到高为你介绍：

HTTP请求比对版本号（最常用）

原理

• 插件本地保存当前版本号
• 向远程服务器请求最新版本号
• 比对后决定是否更新

示例代码（Python）

import requests
import json
def check_update(current_version):
    try:
        # 请求远程版本信息（可以是JSON文件）
        url = "https://your-domain.com/plugin/version.json"
        response = requests.get(url, timeout=5)
        if response.status_code == 200:
            remote_info = response.json()
            remote_version = remote_info.get("version")
            # 版本号比较
            if compare_versions(remote_version, current_version) > 0:
                print(f"发现新版本: v{remote_version}")
                print(f"更新日志: {remote_info.get('changelog', '无')}")
                return True
            else:
                print("已是最新版本")
                return False
    except Exception as e:
        print(f"检查更新失败: {e}")
        return False
def compare_versions(v1, v2):
    """比较两个版本号，v1 > v2 返回正数"""
    parts1 = [int(x) for x in v1.split('.')]
    parts2 = [int(x) for x in v2.split('.')]
    # 补齐长度
    max_len = max(len(parts1), len(parts2))
    parts1 += [0] * (max_len - len(parts1))
    parts2 += [0] * (max_len - len(parts2))
    for a, b in zip(parts1, parts2):
        if a != b:
            return a - b
    return 0

GitHub Releases API（开源插件适用）

示例代码

import requests
def check_github_update(current_version, repo="owner/repo"):
    url = f"https://api.github.com/repos/{repo}/releases/latest"
    try:
        response = requests.get(url, headers={"Accept": "application/vnd.github.v3+json"})
        if response.status_code == 200:
            release = response.json()
            latest_version = release["tag_name"].lstrip("v")
            if latest_version != current_version:
                print(f"新版本: {latest_version}")
                print(f"下载地址: {release['html_url']}")
                return True
    except:
        print("无法连接到GitHub")
    return False

本地缓存机制（避免频繁请求）

import time
import json
import os
class UpdateChecker:
    def __init__(self, cache_file="update_cache.json"):
        self.cache_file = cache_file
        self.cache_duration = 86400  # 24小时缓存
    def _load_cache(self):
        if os.path.exists(self.cache_file):
            with open(self.cache_file, 'r') as f:
                return json.load(f)
        return {}
    def _save_cache(self, data):
        with open(self.cache_file, 'w') as f:
            json.dump(data, f)
    def should_check(self):
        cache = self._load_cache()
        last_check = cache.get("last_check", 0)
        return time.time() - last_check > self.cache_duration
    def check_update(self, current_version):
        if not self.should_check():
            print("缓存有效，跳过检查")
            return None
        # 执行实际的版本检查
        result = self._do_check(current_version)
        # 更新缓存
        self._save_cache({
            "last_check": time.time(),
            "latest_version": result
        })
        return result

自动更新脚本（JavaScript/Node.js示例）

const https = require('https');
const { version } = require('./package.json');
function checkUpdate() {
    const options = {
        hostname: 'registry.npmjs.org',
        path: '/your-plugin-name/latest',
        method: 'GET'
    };
    return new Promise((resolve, reject) => {
        const req = https.request(options, (res) => {
            let data = '';
            res.on('data', chunk => data += chunk);
            res.on('end', () => {
                const latest = JSON.parse(data).version;
                const hasUpdate = compareVersions(latest, version) > 0;
                resolve({ hasUpdate, current: version, latest });
            });
        });
        req.on('error', reject);
        req.end();
    });
}
function compareVersions(v1, v2) {
    const parts1 = v1.split('.').map(Number);
    const parts2 = v2.split('.').map(Number);
    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
        const p1 = parts1[i] || 0;
        const p2 = parts2[i] || 0;
        if (p1 !== p2) return p1 - p2;
    }
    return 0;
}

最佳实践建议

版本文件格式（version.json）

{
    "version": "2.3.1",
    "min_supported_version": "2.0.0",
    "changelog": "修复了XXX Bug\n新增了XXX功能",
    "download_url": "https://example.com/plugin-v2.3.1.zip",
    "release_date": "2024-01-15",
    "checksum": "sha256:abcdef123456..."
}

安全考虑

1. HTTPS请求：始终使用HTTPS
2. 签名验证：对版本信息进行数字签名
3. 降级保护：防止中间人攻击返回旧版本

import hmac
import hashlib
def verify_signature(data, signature, secret_key):
    expected = hmac.new(
        secret_key.encode(), 
        data.encode(), 
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

更新频率控制

• 普通插件：每天检查1次
• 安全插件：每次启动检查
• 避免：每次操作都检查

选择哪种方法取决于你的插件分发方式和平台,最简单的是直接请求JSON文件，最可靠的是使用GitHub API，你也可以结合多种方式，先检查本地缓存，再决定是否发起远程请求。