Come faccio a estrarre il testo che si trova tra parentesi (le parentesi tonde)?

Ho una stringa User name (sales) e voglio estrarre il testo tra le parentesi quadre, come posso fare questo?

Ho il sospetto che sotto-stringa, ma non riesco a capire come leggere fino a quando la staffa di chiusura, la lunghezza del testo può variare.

  • Ci mostrano quello che hai provato. Hai guardato l’uso di espressioni regolari?
InformationsquelleAutor | 2008-12-18



16 Replies
  1. 410

    Un modo molto semplice per farlo è tramite l’utilizzo di espressioni regolari:

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

    Come risposta (molto divertente) commento, ecco la stessa espressione regolare, con qualche spiegazione:

    \(             # 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"
    • Mi piace quando la gente dice “un modo semplice è quello di utilizzare le espressioni regolari” e, quindi, offrire ciò che equivale a una stringa di indecifrabili geroglifici (è particolarmente divertente quando diverse persone suggeriscono regex e ciascuna con un diverso set di geroglifici per lo stesso problema). 🙂
    • Non ci sono abbastanza risposte su stack che in realtà spiega che cosa sta succedendo. Grazie. per la splendida spiegazione.
    • Se Si utilizza la ‘@’ all’inizio penso che non c’È bisogno di fuggire parentesi?
    • si deve sfuggire la parentesi. Cosa @ offre qui è che non c’è bisogno di fuggire le barre rovesciate. Quindi, senza la @ sarebbe come “\\(([^)]*)\\)”.
    • Questo non gestisce i gruppi nidificati bene, però. Modificato var filterRegex = new Regex(Regex.Escape("(") + "([^()]*)" + Regex.Escape(")"));
    • Grazie per la (molto divertente) commenti che permettono di ottenere una grande spiegazione.. non mi piace regex, dopo questa spiegazione mi farà l’uso. grazie ad entrambi per le benefiche tipo di argomento. @Deltics
    • come circa parentesi nidificate
    • Mi fa rispetto matematico Stephen Cole Kleene come il ragazzo che è venuto con la regex concetto nel 1950

  2. 402

    Se si desidera stare lontano da espressioni regolari, il modo più semplice che posso pensare è:

    string input = "User name (sales)";
    string output = input.Split('(', ')')[1];
    • Onestamente, questo dovrebbe aver ricevuto la risposta.
    • Non è ulteriormente contratta in ingresso.Split(“()”.ToCharArray())[1]
    • e nel caso in cui vuoi usare la stessa logica per selezionare più: var input = "(fdw) User name (sales) safdsdf (again?)"; var output = input.Split('(', ')').Where((item, index) => index % 2 != 0).ToList();
  3. 92

    Supponendo che hai solo una coppia di parentesi.

    string s = "User name (sales)";
    int start = s.IndexOf("(") + 1;
    int end = s.IndexOf(")", start);
    string result = s.Substring(start, end - start);
    • start+1 nella sottostringa è più corretto se si desidera che le “vendite” invece di (vendita)
    • che cosa è successo s= “Utente ) nome (Vendite)”?
    • hai ragione dovrebbe essere int end = s.IndexOf(")", start);. Ho in coda una modifica…
    • “(“.Lunghezza; è di meglio di +1. Inviate una modifica. Ha anche aggiunto una funzione.
  4. 24

    Utilizzare questa funzione:

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

    e qui è l’utilizzo:

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

    e l’output sarà:

    sales
  5. 14
    string input = "User name (sales)";
    
    string output = input.Substring(input.IndexOf('(') + 1, input.IndexOf(')') - input.IndexOf('(') - 1);
    • Si dovrebbe, naturalmente, solo di calcolare la posizione della staffa prima volta.
    • Nel caso in cui si dispone interno di parentesi ad esempio input = "User name (sales(1)) puoi usare input.LastIndexOf(')') che funziona se ci sono interno di parentesi o non.
  6. 14

    Espressioni regolari potrebbe essere il miglior strumento di qui. Se non famililar con loro, mi consiglia di installare Expresso – un piccolo grande regex strumento.

    Qualcosa di simile:

    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;
    }
  7. 7
    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;
    }
  8. 4

    Utilizzare un’Espressione Regolare:

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

    Il regex metodo è superiore penso, ma se si desidera utilizzare l’umile 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);

    o

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

    Mi sto trovando che le espressioni regolari sono estremamente utili, ma molto difficile da scrivere. Così, ho fatto qualche ricerca e ho trovato questo strumento che rende la scrittura è così facile.

    Non rifuggire da loro, perché la sintassi è difficile da capire. Essi possono essere così potente.

    • Benvenuti a TANTO!!! Questo è un buon consiglio, ma non sono stato inviato come risposta. Consigli generali come questo dovrebbe essere pubblicato come commenti, se non del tutto. Una risposta deve affrontare il richiedente problema specifico. So che non hai abbastanza punti reputazione per inviare commenti ancora, ma questo è esattamente il motivo per cui la rep soglia esiste. Quando sei stato in giro un po ‘ di più, e vedrai che le persone sono sempre raccomandando strumenti come Rubular (nei commenti, ovviamente). In altre parole, questo consiglio può essere utile, ma non è urgente.
  11. 0

    Qui è generico e leggibile funzione che evita l’utilizzo di espressioni regolari:

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

    Chiamare nel tuo esempio si può fare:

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

    Mi sono imbattuto in questo mentre ero alla ricerca di una soluzione molto simile attuazione.

    Ecco un frammento del mio codice vero e proprio. Inizia sottostringa dal primo carattere (indice 0).

     string separator = "\n";     //line terminator
    
     string output;
     string input= "HowAreYou?\nLets go there!";
    
     output = input.Substring(0, input.IndexOf(separator)); 
    • Questo non rispondere a quello che l’OP ha chiesto.
  13. 0

    Questo codice è più veloce rispetto alla maggior parte delle soluzioni qui (se non tutti), imballato come String metodo di estensione, non ricorsiva di nidificazione:

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

    Questo è un po ‘ più a lungo e più lento, ma gestisce ricorsiva di nidificazione più bene:

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

Lascia un commento