मैं कोष्ठक (गोल कोष्ठक) के बीच स्थित पाठ को कैसे निकालूं?

Question

मेरे पास एक स्ट्रिंग है User name (sales)और मैं कोष्ठक के बीच पाठ निकालना चाहता हूं, मैं यह कैसे करूंगा?

मुझे उप-स्ट्रिंग पर संदेह है लेकिन मैं यह नहीं बता सकता कि समापन ब्रैकेट तक कैसे पढ़ा जाए, पाठ की लंबाई अलग-अलग होगी।

Comments

हमें दिखाओ कि तुमने क्या प्रयास किया है। क्या आपने नियमित अभिव्यक्ति का उपयोग करते हुए देखा है?

— जॉर्ज स्टॉकर

Answer 1

यदि आप नियमित अभिव्यक्तियों से दूर रहना चाहते हैं, तो सबसे आसान तरीका मैं सोच सकता हूं:

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

Comments

ईमानदारी से, इसे उत्तर के रूप में चुना जाना चाहिए था।

— 1848 में पैट लिंडले

इसे आगे input.Split में अनुबंधित नहीं किया जा रहा है ( "()" ToCharArray ()।) [1]

— प्रभाकरण

और यदि आप एक ही तर्क का उपयोग करना चाहते हैं तो एकाधिक का चयन करें:var input = "(fdw) User name (sales) safdsdf (again?)"; var output = input.Split('(', ')').Where((item, index) => index % 2 != 0).ToList();

— WtFudgE

sales)sales((sales(

— खबर है

Answer 2

इसे करने का एक बहुत ही सरल तरीका है नियमित भावों का उपयोग करना:

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

---

(बहुत ही मजेदार) टिप्पणी की प्रतिक्रिया के रूप में, यहाँ कुछ स्पष्टीकरण के साथ एक ही रेगेक्स है:

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

Comments

मुझे यह पसंद है जब लोग कहते हैं "एक सरल तरीका है नियमित अभिव्यक्ति का उपयोग करने के लिए" और फिर अशोभनीय चित्रलिपि की एक मात्रा के लिए क्या मात्रा प्रदान करते हैं (यह विशेष रूप से मजेदार है जब अलग-अलग लोग regex का सुझाव देते हैं और प्रत्येक एक ही समस्या के लिए एक अलग सेट अप के साथ आता है। )। :)

— डेल्टिक्स

स्टैक पर लगभग पर्याप्त उत्तर नहीं हैं जो वास्तव में समझाते हैं कि क्या चल रहा है। अद्भुत व्याख्या के लिए धन्यवाद ।

— सैंडी जिफर्ड

यदि आप भीख मांगने पर '@' का उपयोग कर रहे हैं, तो मुझे लगता है कि आपको कोष्ठक से बचने की आवश्यकता नहीं है?

— रैंक 1

@ रैंक 1 आपको कोष्ठक से बचना चाहिए। यहाँ @ क्या प्रस्ताव है कि आपको बैकस्लैश से बचने की आवश्यकता नहीं है। तो @ के बिना यह "\\ ((^ ^)] *) \\) जैसा होगा।"

— डायडिस्टिस

हालांकि यह नेस्टेड समूहों को अच्छी तरह से संभालता नहीं है। करने के लिए बदलvar filterRegex = new Regex(Regex.Escape("(") + "([^()]*)" + Regex.Escape(")"));

— der Haegen जनवरी वैन

Answer 3

यह मानते हुए कि आपके पास केवल एक जोड़ी कोष्ठक है।

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

Comments

यदि आप "बिक्री" के बजाय "बिक्री" चाहते हैं तो सबस्ट्रिंग में स्टार्ट + 1 अधिक सही है

— जोज

क्या ख़ुशी होगी s = "उपयोगकर्ता) नाम (बिक्री)"?

— डॉटनेटस्टेप

@dotnetstep तुम सही हो int end = s.IndexOf(")", start);। मैंने एक संपादन कतारबद्ध किया है ...

— क्रिस

"@" .Length; +1 से बेहतर है। एक संपादन को भेजा। इसके अलावा एक फंक्शन जोड़ा गया।

— Ave

Answer 4

इस फ़ंक्शन का उपयोग करें:

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

Answer 5

नियमित अभिव्यक्ति यहां सबसे अच्छा उपकरण हो सकता है। यदि आप उनके साथ पारिवारिक नहीं हैं, तो मैं आपको एक्सप्रेसो - एक महान रेगेक्स टूल स्थापित करने की सलाह देता हूं ।

कुछ इस तरह:

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

Answer 6

string input = "User name (sales)";

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

Comments

आपको निश्चित रूप से केवल एक बार पहले ब्रैकेट के स्थान की गणना करनी चाहिए।

— मार्टिन ब्राउन

उस स्थिति में जहां आपके पास आंतरिक कोष्ठक है जैसे input = "User name (sales(1))आप उपयोग करना चाह सकते हैं input.LastIndexOf(')')जो आंतरिक कोष्ठक या नहीं होने पर काम करेगा।

— बेन

Answer 7

एक regex शायद? मुझे लगता है कि यह काम करेगा ...

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

Answer 8

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

Answer 9

एक नियमित अभिव्यक्ति का उपयोग करें:

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

Answer 10

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

Answer 11

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

Answer 12

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

Answer 13

यहाँ एक सामान्य उद्देश्य पठनीय कार्य है जो रेगेक्स का उपयोग करने से बचता है:

// 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)", "(", ")");

Answer 14

मुझे लग रहा है कि नियमित अभिव्यक्ति बेहद उपयोगी है लेकिन लिखना बहुत मुश्किल है। इसलिए, मैंने कुछ शोध किए और इस उपकरण को पाया जो उन्हें लिखना इतना आसान बनाता है।

उनसे दूर न करें क्योंकि वाक्य रचना का पता लगाना मुश्किल है। वे इतने शक्तिशाली हो सकते हैं।

Comments

एसओ में आपका स्वागत है! यह अच्छी सलाह है, लेकिन इसे उत्तर के रूप में पोस्ट नहीं किया जाना चाहिए। इस तरह की सामान्य सलाह को टिप्पणी के रूप में पोस्ट किया जाना चाहिए, यदि बिल्कुल भी। एक उत्तर को प्रश्नकर्ता की विशिष्ट समस्या का समाधान करना चाहिए। मुझे पता है कि आपके पास अभी तक टिप्पणी पोस्ट करने के लिए पर्याप्त प्रतिष्ठा बिंदु नहीं हैं, लेकिन यह ठीक उसी कारण है कि प्रतिनिधि सीमा मौजूद है। जब आप थोड़ी देर के आस-पास रहे, तो आप देखेंगे कि लोग हमेशा रूबुलर (टिप्पणियों में, निश्चित रूप से) जैसे उपकरणों की सिफारिश कर रहे हैं। दूसरे शब्दों में, यह सलाह उपयोगी हो सकती है, लेकिन यह जरूरी नहीं है।

— एलन मूर

Answer 15

मैं इस पार आया था जब मैं एक बहुत ही इसी तरह के कार्यान्वयन के लिए एक समाधान के लिए देख रहा था।

यहाँ मेरे वास्तविक कोड से एक स्निपेट है। पहले चार (इंडेक्स 0) से सबस्ट्रिंग शुरू करता है।

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

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

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

Comments

यह जवाब नहीं देता है कि ओपी ने क्या पूछा है।

— डाइकास्टर

Answer 16

यह कोड यहां अधिकांश समाधानों की तुलना में तेज़ है (यदि सभी नहीं), स्ट्रिंग एक्सटेंशन विधि के रूप में पैक किया गया है , यह पुनरावर्ती घोंसले का समर्थन नहीं करता है:

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