如何定位替换命令行-from参数大括号内子串？求栈外替代方案

Great question! Since you already have a stack-based solution in your toolkit, let’s explore a few alternative approaches to modify that command-line string—even when parameters like -from, -to, -thru are in any random order.

1. Balanced Parenthesis Regex (PCRE-Compatible) #

If your programming language or tool supports PCRE (Perl Compatible Regular Expressions) (which handles recursive/balanced structures), you can craft a regex that precisely targets the content inside -from’s outer braces, regardless of nested inner braces.

Here’s a Python example (using the standard re module, available in Python 3.11+; for older versions, use the third-party regex library):

import re

original_cmd = "command_a -abc -from { {A} {B} {C} {D} } -to { {A} {B} {C} {D} }"

# Regex pattern to match `-from { ... }` with balanced inner braces
pattern = r'(-from\s+\{)\s*((?:[^{}]|(?R))*)\s*(})'
modified_cmd = re.sub(pattern, r'\1 <other_string> \3', original_cmd)

print(modified_cmd)
# Output: command_a -abc -from { <other_string> } -to { {A} {B} {C} {D} }

How it works:

• The regex captures the -from { prefix (\1) and closing } suffix (\3)
• The middle group matches any balanced brace content inside, which we replace with <other_string>

2. Tokenization + State Tracking #

Break the command string into discrete "tokens" (like parameter names, braces, and values), then track your state to identify when you’re inside the -from block. This avoids regex limitations and gives you fine-grained control.

Here’s a Python implementation:

def replace_from_block(cmd_str):
    # Step 1: Split the command into tokens (handles braces as separate tokens)
    tokens = []
    current_token = []
    for char in cmd_str:
        if char == ' ':
            if current_token:
                tokens.append(''.join(current_token))
                current_token = []
        elif char in '{}':
            if current_token:
                tokens.append(''.join(current_token))
                current_token = []
            tokens.append(char)
        else:
            current_token.append(char)
    if current_token:
        tokens.append(''.join(current_token))

    # Step 2: Traverse tokens to modify the `-from` block
    result = []
    in_from_context = False
    brace_depth = 0

    for token in tokens:
        if token == '-from':
            result.append(token)
            in_from_context = True
        elif in_from_context and token == '{':
            result.append(token)
            result.append(' <other_string> ')
            brace_depth = 1
            in_from_context = False
        elif brace_depth > 0:
            # Skip all inner content until we reach the closing outer brace
            if token == '{':
                brace_depth += 1
            elif token == '}':
                brace_depth -= 1
                if brace_depth == 0:
                    result.append(token)
        else:
            result.append(token)
    
    return ' '.join(result)

original_cmd = "command_a -abc -from { {A} {B} {C} {D} } -to { {A} {B} {C} {D} }"
print(replace_from_block(original_cmd))

How it works:

• We first split the command into tokens like -from, {, {A}, etc.
• We track when we’re entering the -from block, then skip all inner tokens until we hit the closing outer brace, replacing the inner content with <other_string>

3. Use a Command-Line Parsing Library #

Leverage existing CLI parsing tools to handle parameter ordering automatically. Parse the command into structured data, modify the -from value, then regenerate the command string.

Here’s a Python example using argparse:

import argparse

# Custom type to parse brace-enclosed values
def parse_brace_content(s):
    stripped = s.strip().strip('{}')
    return [part.strip() for part in stripped.split() if part.strip()]

def rebuild_command(args):
    cmd_parts = ['command_a']
    # Add back flags/parameters in any order
    if args.abc:
        cmd_parts.append('-abc')
    # Modify the `-from` parameter
    cmd_parts.extend(['-from', '{ <other_string> }'])
    # Add back `-to` with original content
    if args.to:
        to_content = ' '.join(args.to)
        cmd_parts.extend(['-to', f'{{ {to_content} }}'])
    # Add other parameters like `-thru` if present
    if args.thru:
        cmd_parts.extend(['-thru', args.thru])
    return ' '.join(cmd_parts)

# Set up parser
parser = argparse.ArgumentParser()
parser.add_argument('-abc', action='store_true')
parser.add_argument('-from', type=parse_brace_content)
parser.add_argument('-to', type=parse_brace_content)
parser.add_argument('-thru')

original_cmd = "command_a -abc -from { {A} {B} {C} {D} } -to { {A} {B} {C} {D} }"
# Convert command string to argument list
cmd_args = original_cmd.split()
# Parse arguments (skip the command name "command_a")
parsed_args = parser.parse_args(cmd_args[1:])

# Generate modified command
modified_cmd = rebuild_command(parsed_args)
print(modified_cmd)

How it works:

• The parser handles parameter order automatically, so you don’t have to worry about -from being in any position
• We parse the original -from content, then replace it when rebuilding the command string

内容的提问来源于stack exchange，提问作者Hemant Bhargava