괄호(원괄호) 사이에 있는 텍스트를 추출하려면 어떻게 해야 합니까?

괄호(원괄호) 사이에 있는 텍스트를 추출하려면 어떻게 해야 합니까?

끈이 있어요.User name (sales)괄호 사이에 있는 텍스트를 추출하고 싶은데 어떻게 해야 하나요?

하위 문자열이 의심되지만 닫는 괄호까지 읽는 방법을 알 수 없습니다, 텍스트 길이가 달라질 것입니다.

정규 표현을 피하고 싶다면, 제가 생각할 수 있는 가장 간단한 방법은 다음과 같습니다.

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

매우 간단한 방법은 정규식을 사용하는 것입니다.

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

---

(매우 재미있는) 댓글에 대한 응답으로, 다음과 같은 Regex와 몇 가지 설명이 있습니다.

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

괄호 한 쌍만 있다고 가정합니다.

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

다음 기능을 사용합니다.

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

사용법은 다음과 같습니다.

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

출력은 다음과 같습니다.

sales

정규식이 여기서 가장 좋은 도구일 수 있습니다.만약 당신이 그것들에 익숙하지 않다면, 나는 당신이 훌륭한 작은 정규식 도구인 Expressso를 설치하는 것을 추천합니다.

다음과 같은 것:

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

레식스?이게 효과가 있을 것 같은데요...

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

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

정규식 사용:

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

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

그regex방법이 더 우수하다고 생각하지만, 만약 당신이 겸손한 사람들을 사용하고 싶다면.substring

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

또는

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

 var input = "12(34)1(12)(14)234";
 var output = "";
 for (int i = 0; i < input.Length; i++)
 {
     if (input[i] == '(')
     {
         var start = i + 1;
         var end = input.IndexOf(')', i + 1);
         output += input.Substring(start, end - start) + ",";
     }
 }

 if (output.Length > 0) // remove last comma
  output = output.Remove(output.Length - 1);

출력 : "34,12,14"

정규식 사용을 피하는 범용 읽기 기능은 다음과 같습니다.

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

예를 들어 다음과 같은 작업을 수행할 수 있습니다.

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

정규 표현은 매우 유용하지만 쓰기가 매우 어렵다는 것을 알게 되었습니다.그래서, 저는 조사를 해보았고 그것들을 쓰는 것을 매우 쉽게 만드는 이 도구를 발견했습니다.

구문이 이해하기 어렵기 때문에 그들을 피하지 마세요.그들은 매우 강력할 수 있습니다.

이 코드는 String 확장 메서드로 패킹된 대부분의 솔루션(전부가 아닌 경우)보다 빠르며 재귀 중첩을 지원하지 않습니다.

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

이것은 조금 더 길고 느리지만 재귀적 중첩을 더 잘 처리합니다.

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

저는 최근에 C#9를 사용하고 남용하고 있는데 의심스러운 시나리오에서도 스팬을 포기하지 않을 수 없습니다...재미있게도 위의 답변에 대한 변형이 있습니다.

var input = "User name (sales)";
var txtSpan = input.AsSpan();
var startPoint = txtSpan.IndexOf('(') + 1;
var length = txtSpan.LastIndexOf(')') - startPoint;
var output = txtSpan.Slice(startPoint, length);

OP의 특정 시나리오의 경우, 적절한 출력을 생성합니다. (개인적으로는 다른 사람들이 게시한 것처럼 RegEx를 사용합니다.)위의 솔루션이 무너지는 더 까다로운 시나리오를 피하는 것이 더 쉽습니다.

내 프로젝트를 위해 만든 더 나은 버전(확장 방법):

//Note: This only captures the first occurrence, but 
//can be easily modified to scan across the text (I'd prefer Slicing a Span)  
public static string ExtractFromBetweenChars(this string txt, char openChar, char closeChar)
{
    ReadOnlySpan<char> span = txt.AsSpan();
    int firstCharPos = span.IndexOf(openChar);
    int lastCharPos = -1;

    if (firstCharPos != -1) 
    { 
        for (int n = firstCharPos + 1; n < span.Length; n++)
        {
            if (span[n] == openChar) firstCharPos = n; //This allows the opening char position to change
            if (span[n] == closeChar) lastCharPos = n;
            if (lastCharPos > firstCharPos) break;
            //This would correctly extract "sales" from this [contrived]
            //example: "just (a (name (sales) )))(test"
        }
        return span.Slice(firstCharPos + 1, lastCharPos - firstCharPos - 1).ToString();
    }
    return "";
}

@Gustavo Baiocchi Costa와 매우 유사하지만 오프셋은 다른 중간체로 계산되고 있습니다.Substring.

int innerTextStart = input.IndexOf("(") + 1;
int innerTextLength = input.Substring(start).IndexOf(")");
string output = input.Substring(innerTextStart, innerTextLength);

매우 유사한 구현에 대한 솔루션을 찾던 중 이 문제를 발견했습니다.

여기 제 실제 코드의 일부가 있습니다.첫 번째 문자(색인 0)부터 하위 문자열을 시작합니다.

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

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

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

언급URL : https://stackoverflow.com/questions/378415/how-do-i-extract-text-that-lies-between-parentheses-round-brackets