怎样用脚本批量还原短链接？

本文目录导读：

1. 方法1：使用Python脚本（推荐）
2. 方法2：使用Bash脚本（Linux/Mac）
3. 方法3：使用Node.js脚本
4. 使用建议

方法1：使用Python脚本（推荐）

安装依赖

pip install requests pandas

基础版脚本

import requests
import pandas as pd
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
def unshorten_url(url, timeout=5):
    """
    还原单个短链接
    """
    try:
        response = requests.head(url, allow_redirects=True, timeout=timeout)
        return response.url
    except requests.exceptions.RequestException as e:
        return f"Error: {str(e)}"
def batch_unshorten(url_list, max_workers=10):
    """
    批量还原短链接（使用线程池加速）
    """
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_url = {executor.submit(unshorten_url, url): url for url in url_list}
        for future in as_completed(future_to_url):
            original_url = future_to_url[future]
            try:
                result = future.result()
                results.append({
                    'original_short_url': original_url,
                    'expanded_url': result
                })
            except Exception as e:
                results.append({
                    'original_short_url': original_url,
                    'expanded_url': f"Error: {str(e)}"
                })
    return results
# 使用示例
if __name__ == "__main__":
    # 从文件读取短链接
    with open('short_urls.txt', 'r', encoding='utf-8') as f:
        urls = [line.strip() for line in f if line.strip()]
    # 执行批量还原
    print(f"开始还原 {len(urls)} 个短链接...")
    results = batch_unshorten(urls, max_workers=10)
    # 保存结果到CSV文件
    df = pd.DataFrame(results)
    df.to_csv('expanded_urls.csv', index=False, encoding='utf-8-sig')
    print(f"结果已保存到 expanded_urls.csv")
    # 显示部分结果
    print("\n前10条结果预览:")
    for i, result in enumerate(results[:10]):
        print(f"{i+1}. {result['original_short_url']} -> {result['expanded_url']}")

增强版脚本（支持多种短链接服务）

import requests
import re
import json
from urllib.parse import urlparse
class URLUnshortener:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update({
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        })
    def unshorten(self, url, max_redirects=5):
        """
        追踪重定向链，支持多层重定向
        """
        try:
            response = self.session.head(
                url, 
                allow_redirects=True,
                timeout=5,
                max_redirects=max_redirects
            )
            # 获取最终URL
            final_url = response.url
            # 获取重定向历史
            redirect_chain = [r.url for r in response.history] + [final_url]
            return {
                'original': url,
                'final': final_url,
                'redirect_count': len(response.history),
                'redirect_chain': redirect_chain,
                'status_code': response.status_code
            }
        except requests.exceptions.TooManyRedirects:
            return {
                'original': url,
                'final': 'Too many redirects',
                'redirect_count': -1,
                'redirect_chain': [],
                'status_code': None
            }
        except Exception as e:
            return {
                'original': url,
                'final': f'Error: {str(e)}',
                'redirect_count': -1,
                'redirect_chain': [],
                'status_code': None
            }
def batch_unshorten_enhanced(urls):
    """
    增强版批量还原函数
    """
    unshortener = URLUnshortener()
    results = []
    for url in urls:
        result = unshortener.unshorten(url)
        results.append(result)
        print(f"处理: {url} -> {result['final']}")
        time.sleep(0.1)  # 避免请求过快
    return results

方法2：使用Bash脚本（Linux/Mac）

#!/bin/bash
# 批量还原短链接的bash脚本
# 使用方法: ./unshorten.sh short_urls.txt
INPUT_FILE="$1"
OUTPUT_FILE="expanded_urls.txt"
if [ -z "$INPUT_FILE" ]; then
    echo "请指定包含短链接的文件路径"
    echo "使用: $0 <urls_file>"
    exit 1
fi
echo "开始还原短链接..."
echo "原链接 | 还原后链接" > "$OUTPUT_FILE"
echo "-----------------------------------" >> "$OUTPUT_FILE"
while IFS= read -r url; do
    if [ -n "$url" ]; then
        # 使用curl获取重定向后的URL
        expanded=$(curl -s -L -o /dev/null -w "%{url_effective}" "$url" 2>/dev/null)
        echo "$url -> $expanded"
        echo "$url | $expanded" >> "$OUTPUT_FILE"
        # 添加延迟避免请求过快
        sleep 0.5
    fi
done < "$INPUT_FILE"
echo "完成！结果已保存到 $OUTPUT_FILE"

方法3：使用Node.js脚本

// unshorten.js
const axios = require('axios');
const fs = require('fs').promises;
const path = require('path');
async function unshortenURL(url) {
    try {
        const response = await axios.head(url, {
            maxRedirects: 10,
            timeout: 5000,
            headers: {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
            }
        });
        return {
            original: url,
            final: response.request.res.responseUrl || response.config.url,
            success: true
        };
    } catch (error) {
        return {
            original: url,
            final: `Error: ${error.message}`,
            success: false
        };
    }
}
async function batchUnshorten(inputFile) {
    try {
        // 读取URL列表
        const content = await fs.readFile(inputFile, 'utf8');
        const urls = content.split('\n').filter(url => url.trim());
        console.log(`开始处理 ${urls.length} 个短链接...`);
        // 批量处理（使用Promise控制并发）
        const results = [];
        const concurrency = 5;
        for (let i = 0; i < urls.length; i += concurrency) {
            const batch = urls.slice(i, i + concurrency);
            const batchResults = await Promise.all(
                batch.map(url => unshortenURL(url.trim()))
            );
            results.push(...batchResults);
            // 显示进度
            console.log(`处理进度: ${i + batch.length}/${urls.length}`);
        }
        // 保存结果
        const outputPath = 'expanded_urls.json';
        await fs.writeFile(outputPath, JSON.stringify(results, null, 2));
        console.log(`结果已保存到 ${outputPath}`);
        // 输出摘要
        results.forEach(result => {
            console.log(`${result.original} -> ${result.final}`);
        });
    } catch (error) {
        console.error('处理失败:', error);
    }
}
// 运行脚本
const inputFile = process.argv[2];
if (!inputFile) {
    console.log('请指定输入文件路径');
    console.log('使用: node unshorten.js <urls_file>');
    process.exit(1);
}
batchUnshorten(inputFile);

使用建议

1. 输入文件格式：每行一个短链接

   https://bit.ly/xxxx
   https://t.cn/xxxx
   https://url.cn/xxxx

2. 性能优化：

   • 使用线程池/并发控制提高速度
   • 添加适当的延迟避免被限流
   • 设置合理的超时时间

3. 注意事项：

   • 部分短链接服务可能有API限制
   • 某些短链接可能已过期或失效
   • HTTPS证书问题可能需要特殊处理

4. 安装Python依赖（如果使用Python脚本）：

   pip install requests pandas

选择适合你技术栈的方法,建议使用Python版本，因为它功能最完整且易于定制。