Wie extrahiere ich Text, der zwischen Klammern steht (runde Klammern)?

Ich habe eine Zeichenfolge User name (sales)und möchte den Text zwischen den Klammern extrahieren. Wie würde ich das tun?

Ich vermute eine Teilzeichenfolge, kann aber erst in der schließenden Klammer herausfinden, wie sie gelesen werden soll. Die Textlänge variiert.

Wenn Sie sich von regulären Ausdrücken fernhalten möchten, ist der einfachste Weg, den ich mir vorstellen kann:

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

Eine sehr einfache Möglichkeit ist die Verwendung regulärer Ausdrücke:

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

Als Antwort auf den (sehr lustigen) Kommentar hier derselbe Regex mit einigen Erklärungen:

\(             # 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"

Angenommen, Sie haben nur ein Klammerpaar.

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

Verwenden Sie diese Funktion:

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));
    }

und hier ist die Verwendung:

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

und die Ausgabe wäre:

sales

Reguläre Ausdrücke könnten hier das beste Werkzeug sein. Wenn Sie mit ihnen nicht vertraut sind, empfehle ich Ihnen, Expresso zu installieren - ein großartiges kleines Regex-Tool.

Etwas wie:

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);

Ein Regex vielleicht? Ich denke das würde funktionieren ...

\(([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;
}

Verwenden Sie einen regulären Ausdruck:

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);

Die regexMethode ist meiner Meinung nach überlegen, aber wenn Sie die bescheidenen verwenden wolltensubstring

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

oder

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

Hier ist eine allgemein lesbare Funktion, die die Verwendung von Regex vermeidet:

// 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);
}

Um es in Ihrem speziellen Beispiel zu nennen, können Sie Folgendes tun:

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

Ich finde, dass reguläre Ausdrücke äußerst nützlich, aber sehr schwer zu schreiben sind. Also habe ich einige Nachforschungen angestellt und dieses Tool gefunden , das das Schreiben so einfach macht.

Scheuen Sie sich nicht vor ihnen, denn die Syntax ist schwer herauszufinden. Sie können so mächtig sein.

Ich bin darauf gestoßen, als ich nach einer Lösung für eine sehr ähnliche Implementierung gesucht habe.

Hier ist ein Ausschnitt aus meinem aktuellen Code. Startet die Teilzeichenfolge ab dem ersten Zeichen (Index 0).

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

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

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

Dieser Code ist schneller als die meisten Lösungen hier (wenn nicht alle) und als String- Erweiterungsmethode gepackt. Er unterstützt keine rekursive Verschachtelung:

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;
}

Dieser ist etwas länger und langsamer, aber er handhabt rekursives Verschachteln besser:

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;
}