如何批量替换文件夹及子文件夹HTML文件中的含斜杠特定子串？

Got it, let's work through this string replacement challenge—those slash edge cases are definitely annoying, but we’ve got solid solutions to handle them cleanly. Here are a few tested approaches tailored to your exact need:

1. Sed Command (Linux/macOS) #

If you’re on a Unix-like system, sed is a fast, terminal-based way to batch modify files recursively. This command will target only localhost:8000/ (with the trailing slash) and replace it without creating double slashes:

find /path/to/your/target/folder -name "*.html" -exec sed -i.bak 's/localhost:8000\//https:\/\/www.begueradj.com\//g' {} +

• The -i.bak flag creates a backup of each original file (you can omit .bak to modify files directly, but backups are safer for testing).
• We escape slashes with \ to avoid conflicts with sed’s syntax, ensuring we only match the exact substring localhost:8000/.
• find recursively scans all subfolders for .html files, so you don’t have to process directories manually.

2. Python Script (Cross-Platform) #

For more control (and to work across Windows, macOS, and Linux), a Python script is ideal. It handles encoding properly and lets you adjust matching logic easily:

import os
import re

# Set your target folder and replacement values
root_directory = "/path/to/your/folder"
old_pattern = r"localhost:8000/"
new_url = r"https://www.begueradj.com/"

# Recursively walk through all folders
for dirpath, _, filenames in os.walk(root_directory):
    for file in filenames:
        if file.endswith(".html"):
            file_path = os.path.join(dirpath, file)
            # Read and update the file content
            with open(file_path, "r", encoding="utf-8") as f:
                content = f.read()
            # Use re.escape to safely match the exact substring
            updated_content = re.sub(re.escape(old_pattern), new_url, content)
            # Write the updated content back
            with open(file_path, "w", encoding="utf-8") as f:
                f.write(updated_content)

• re.escape() ensures special characters like slashes are treated literally, so we don’t accidentally match partial strings.
• Specifying encoding="utf-8" prevents garbled text in files with non-ASCII characters.
• This script is easy to tweak—if you need to handle cases where localhost:8000 has multiple trailing slashes (like localhost:8000//), change the pattern to r"localhost:8000/+" to match one or more slashes and replace with a single slash in the target URL.

3. PowerShell (Windows) #

If you’re on Windows, PowerShell can handle the recursive replacement natively:

Get-ChildItem -Path "C:\path\to\your\folder" -Filter "*.html" -Recurse | ForEach-Object {
    $content = Get-Content $_.FullName -Raw -Encoding UTF8
    $updatedContent = $content -replace 'localhost:8000/', 'https://www.begueradj.com/'
    Set-Content $_.FullName -Value $updatedContent -Encoding UTF8
}

• -Recurse scans all subfolders, and -Filter targets only .html files.
• -Raw reads the entire file at once, avoiding issues with line breaks.
• Like the other methods, this replaces the exact substring localhost:8000/—no double slashes are created because the target URL already ends with a single slash, matching the original pattern.

Bonus: Handling Edge Cases #

If you encounter instances where localhost:8000 is followed by multiple slashes (e.g., localhost:8000//assets), adjust the matching logic to collapse those slashes:

• For sed: s/localhost:8000\/+/https:\/\/www.begueradj.com\//g
• For Python: updated_content = re.sub(r"localhost:8000/+", new_url, content)
• For PowerShell: $updatedContent = $content -replace 'localhost:8000/+', 'https://www.begueradj.com/'

This ensures any number of trailing slashes after localhost:8000 get replaced with a single slash in your target URL.

内容的提问来源于stack exchange，提问作者Billal BEGUERADJ