Làm cách nào để trích xuất văn bản nằm giữa dấu ngoặc đơn (dấu ngoặc tròn)?

Tôi có một chuỗi User name (sales)và tôi muốn trích xuất văn bản giữa các dấu ngoặc, tôi sẽ làm điều này như thế nào?

Tôi nghi ngờ chuỗi con nhưng tôi không thể tìm ra cách đọc cho đến khi khung đóng, độ dài của văn bản sẽ thay đổi.

Nếu bạn muốn tránh xa các biểu thức thông thường, cách đơn giản nhất tôi có thể nghĩ đến là:

string input = "User name (sales)";
string output = input.Split('(', ')')[1];

Một cách rất đơn giản để làm điều đó là sử dụng các biểu thức thông thường:

Regex.Match("User name (sales)", @"\(([^)]*)\)").Groups[1].Value

Để trả lời cho nhận xét (rất buồn cười), đây là Regex tương tự với một số giải thích:

\(             # Escaped parenthesis, means "starts with a '(' character"
    (          # Parentheses in a regex mean "put (capture) the stuff 
               #     in between into the Groups array" 
       [^)]    # Any character that is not a ')' character
       *       # Zero or more occurrences of the aforementioned "non ')' char"
    )          # Close the capturing group
\)             # "Ends with a ')' character"

Giả sử rằng bạn chỉ có một cặp dấu ngoặc đơn.

string s = "User name (sales)";
int start = s.IndexOf("(") + 1;
int end = s.IndexOf(")", start);
string result = s.Substring(start, end - start);

Sử dụng chức năng này:

public string GetSubstringByString(string a, string b, string c)
    {
        return c.Substring((c.IndexOf(a) + a.Length), (c.IndexOf(b) - c.IndexOf(a) - a.Length));
    }

và đây là cách sử dụng:

GetSubstringByString("(", ")", "User name (sales)")

và đầu ra sẽ là:

sales

Biểu thức chính quy có thể là công cụ tốt nhất ở đây. Nếu bạn không quen thuộc với họ, tôi khuyên bạn nên cài đặt Expresso - một công cụ regex nhỏ tuyệt vời.

Cái gì đó như:

Regex regex = new Regex("\\((?<TextInsideBrackets>\\w+)\\)");
string incomingValue = "Username (sales)";
string insideBrackets = null;
Match match = regex.Match(incomingValue);
if(match.Success)
{
    insideBrackets = match.Groups["TextInsideBrackets"].Value;
}

string input = "User name (sales)";

string output = input.Substring(input.IndexOf('(') + 1, input.IndexOf(')') - input.IndexOf('(') - 1);

Một regex có thể? Tôi nghĩ rằng điều này sẽ làm việc ...

\(([a-z]+?)\)

using System;
using System.Text.RegularExpressions;

private IEnumerable<string> GetSubStrings(string input, string start, string end)
{
    Regex r = new Regex(Regex.Escape(start) +`"(.*?)"`  + Regex.Escape(end));
    MatchCollection matches = r.Matches(input);
    foreach (Match match in matches)
    yield return match.Groups[1].Value;
}

Sử dụng biểu thức chính quy:

string test = "(test)"; 
string word = Regex.Match(test, @"\((\w+)\)").Groups[1].Value;
Console.WriteLine(word);

int start = input.IndexOf("(") + 1;
int length = input.IndexOf(")") - start;
output = input.Substring(start, length);

input.Remove(input.IndexOf(')')).Substring(input.IndexOf('(') + 1);

Các regexphương pháp ưu việt hơn tôi nghĩ, nhưng nếu bạn muốn sử dụng khiêm tốnsubstring

string input= "my name is (Jayne C)";
int start = input.IndexOf("(");
int stop = input.IndexOf(")");
string output = input.Substring(start+1, stop - start - 1);

hoặc là

string input = "my name is (Jayne C)";
string output  = input.Substring(input.IndexOf("(") +1, input.IndexOf(")")- input.IndexOf("(")- 1);

Đây là một chức năng có thể đọc được nhằm mục đích chung tránh sử dụng regex:

// Returns the text between 'start' and 'end'.
string ExtractBetween(string text, string start, string end)
{
  int iStart = text.IndexOf(start);
  iStart = (iStart == -1) ? 0 : iStart + start.Length;
  int iEnd = text.LastIndexOf(end);
  if(iEnd == -1)
  {
    iEnd = text.Length;
  }
  int len = iEnd - iStart;

  return text.Substring(iStart, len);
}

Để gọi nó trong ví dụ cụ thể của bạn, bạn có thể làm:

string result = ExtractBetween("User name (sales)", "(", ")");

Tôi thấy rằng các biểu thức chính quy cực kỳ hữu ích nhưng rất khó viết. Vì vậy, tôi đã làm một số nghiên cứu và tìm thấy công cụ này làm cho việc viết chúng trở nên dễ dàng.

Đừng né tránh chúng vì cú pháp rất khó để tìm ra. Họ có thể rất mạnh mẽ.

Tôi đã bắt gặp điều này trong khi tôi đang tìm kiếm một giải pháp cho việc thực hiện rất giống nhau.

Đây là một đoạn từ mã thực tế của tôi. Bắt đầu chuỗi con từ char đầu tiên (chỉ số 0).

 string separator = "\n";     //line terminator

 string output;
 string input= "HowAreYou?\nLets go there!";

 output = input.Substring(0, input.IndexOf(separator)); 

Mã này nhanh hơn hầu hết các giải pháp ở đây (nếu không phải tất cả), được đóng gói như phương thức mở rộng Chuỗi , nó không hỗ trợ lồng nhau đệ quy:

public static string GetNestedString(this string str, char start, char end)
{
    int s = -1;
    int i = -1;
    while (++i < str.Length)
        if (str[i] == start)
        {
            s = i;
            break;
        }
    int e = -1;
    while(++i < str.Length)
        if (str[i] == end)
        {
            e = i;
            break;
        }
    if (e > s)
        return str.Substring(s + 1, e - s - 1);
    return null;
}

Cái này dài hơn một chút và chậm hơn, nhưng nó xử lý việc lồng đệ quy độc đáo hơn:

public static string GetNestedString(this string str, char start, char end)
{
    int s = -1;
    int i = -1;
    while (++i < str.Length)
        if (str[i] == start)
        {
            s = i;
            break;
        }
    int e = -1;
    int depth = 0;
    while (++i < str.Length)
        if (str[i] == end)
        {
            e = i;
            if (depth == 0)
                break;
            else
                --depth;
        }
        else if (str[i] == start)
            ++depth;
    if (e > s)
        return str.Substring(s + 1, e - s - 1);
    return null;
}