Làm cách nào để xóa văn bản trong dấu ngoặc đơn bằng regex?

Tôi đang cố gắng xử lý một loạt tệp và sau đó tôi cần phải thay đổi để xóa thông tin không liên quan trong tên tệp; đáng chú ý, tôi đang cố gắng xóa văn bản bên trong dấu ngoặc đơn. Ví dụ:

filename = "Example_file_(extra_descriptor).ext"

và tôi muốn regex toàn bộ các tệp trong đó biểu thức dấu ngoặc đơn có thể nằm ở giữa hoặc ở cuối và có độ dài thay đổi.

Regex sẽ trông như thế nào? Cú pháp Perl hoặc Python sẽ được ưu tiên hơn.

s/\([^)]*\)//

Vì vậy, trong Python, bạn sẽ làm:

re.sub(r'\([^)]*\)', '', filename)

Mẫu khớp với các chuỗi con trong ngoặc đơn không có() chuỗi nào khác và các ký tự ở giữa (như (xyz 123)in Text (abc(xyz 123)) là

\([^()]*\)

Chi tiết :

• \(- một dấu ngoặc tròn mở (lưu ý rằng trong POSIX BRE, (nên được sử dụng, xem sedví dụ bên dưới)
• [^()]*- không hoặc nhiều hơn (do bộ * định lượng sao Kleene ) các ký tự khác với ký tự được xác định trong biểu thức dấu ngoặc nhọn / lớp ký tự phủ định POSIX , nghĩa là, bất kỳ ký tự nào khác (và)
• \) - dấu ngoặc tròn đóng (không cho phép thoát trong POSIX BRE)

Xóa các đoạn mã:

• JavaScript :string.replace(/\([^()]*\)/g, '')
• PHP :preg_replace('~\([^()]*\)~', '', $string)
• Perl :$s =~ s/\([^()]*\)//g
• Python :re.sub(r'\([^()]*\)', '', s)
• C # :Regex.Replace(str, @"\([^()]*\)", string.Empty)
• VB.NET :Regex.Replace(str, "\([^()]*\)", "")
• Java :s.replaceAll("\\([^()]*\\)", "")
• Ruby :s.gsub(/\([^()]*\)/, '')
• R :gsub("\\([^()]*\\)", "", x)
• Lua :string.gsub(s, "%([^()]*%)", "")
• Bash / sed :sed 's/([^()]*)//g'
• Tcl :regsub -all {\([^()]*\)} $s "" result
• C ++std::regex :std::regex_replace(s, std::regex(R"(\([^()]*\))"), "")
• Mục tiêu-C :
  NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"\\([^()]*\\)" options:NSRegularExpressionCaseInsensitive error:&error]; NSString *modifiedString = [regex stringByReplacingMatchesInString:string options:0 range:NSMakeRange(0, [string length]) withTemplate:@""];
• Swift :s.replacingOccurrences(of: "\\([^()]*\\)", with: "", options: [.regularExpression])

Tôi sẽ dùng:

\([^)]*\)

Nếu bạn không hoàn toàn cần phải sử dụng một regex, sử dụng xem xét sử dụng Perl của chữ :: Balanced để loại bỏ các dấu ngoặc đơn.

use Text::Balanced qw(extract_bracketed);

my ($extracted, $remainder, $prefix) = extract_bracketed( $filename, '()', '[^(]*' );

{   no warnings 'uninitialized';

    $filename = (defined $prefix or defined $remainder)
                ? $prefix . $remainder
                : $extracted;
}

Bạn có thể đang nghĩ, "Tại sao lại làm tất cả những điều này khi regex thực hiện thủ thuật trong một dòng?"

$filename =~ s/\([^}]*\)//;

Văn bản :: Điều khiển cân bằng dấu ngoặc đơn lồng nhau. Vì vậy $filename = 'foo_(bar(baz)buz)).foo'sẽ được giải nén đúng cách. Các giải pháp dựa trên regex được cung cấp ở đây sẽ không thành công trên chuỗi này. Người nào sẽ dừng lại ở dấu ngoặc đóng đầu tiên, và người kia sẽ ăn hết chúng.

   $filename =~ s/\([^}]*\)//;
   # returns 'foo_buz)).foo'

   $filename =~ s/\(.*\)//;
   # returns 'foo_.foo'

   # text balanced example returns 'foo_).foo'

Nếu một trong hai hành vi regex có thể chấp nhận được, hãy sử dụng regex - nhưng ghi lại các giới hạn và các giả định đang được thực hiện.

Nếu một đường dẫn có thể chứa dấu ngoặc đơn thì r'\(.*?\)'regex là không đủ:

import os, re

def remove_parenthesized_chunks(path, safeext=True, safedir=True):
    dirpath, basename = os.path.split(path) if safedir else ('', path)
    name, ext = os.path.splitext(basename) if safeext else (basename, '')
    name = re.sub(r'\(.*?\)', '', name)
    return os.path.join(dirpath, name+ext)

Theo mặc định, hàm bảo tồn các phần có dấu ngoặc đơn trong các phần thư mục và phần mở rộng của đường dẫn.

Thí dụ:

>>> f = remove_parenthesized_chunks
>>> f("Example_file_(extra_descriptor).ext")
'Example_file_.ext'
>>> path = r"c:\dir_(important)\example(extra).ext(untouchable)"
>>> f(path)
'c:\\dir_(important)\\example.ext(untouchable)'
>>> f(path, safeext=False)
'c:\\dir_(important)\\example.ext'
>>> f(path, safedir=False)
'c:\\dir_\\example.ext(untouchable)'
>>> f(path, False, False)
'c:\\dir_\\example.ext'
>>> f(r"c:\(extra)\example(extra).ext", safedir=False)
'c:\\\\example.ext'

Đối với những người muốn sử dụng Python, đây là một quy trình đơn giản giúp loại bỏ các chuỗi con có dấu ngoặc đơn, kể cả những chuỗi có dấu ngoặc đơn lồng nhau. Được rồi, nó không phải là regex, nhưng nó sẽ làm được việc!

def remove_nested_parens(input_str):
    """Returns a copy of 'input_str' with any parenthesized text removed. Nested parentheses are handled."""
    result = ''
    paren_level = 0
    for ch in input_str:
        if ch == '(':
            paren_level += 1
        elif (ch == ')') and paren_level:
            paren_level -= 1
        elif not paren_level:
            result += ch
    return result

remove_nested_parens('example_(extra(qualifier)_text)_test(more_parens).ext')

Nếu bạn có thể sẵn sàng sử dụng sed(có thể thực thi từ bên trong chương trình của bạn, nó sẽ đơn giản như:

sed 's/(.*)//g'

>>> import re
>>> filename = "Example_file_(extra_descriptor).ext"
>>> p = re.compile(r'\([^)]*\)')
>>> re.sub(p, '', filename)
'Example_file_.ext'

Mã Java:

Pattern pattern1 = Pattern.compile("(\\_\\(.*?\\))");
System.out.println(fileName.replace(matcher1.group(1), ""));