Mantieni solo un valore numerico da una stringa?

Question

devo alcune stringhe come questa

string phoneNumber = "(914) 395-1430"; 

desidero mettere a nudo i parethenses e il trattino, in altre parole solo a mantenere i valori numerici.

Così l'output potrebbe assomigliare a questo

9143951430 

Come faccio a ottenere l'output desiderato?

Answer 1

si effettua una delle seguenti operazioni:

• utilizzare le espressioni regolari. È possibile utilizzare un'espressione regolare sia con

  • Una classe di caratteri negativi che definisce i caratteri che sono ciò che non si vuole (quei caratteri diversi da cifre decimali):

    private static readonly Regex rxNonDigits = new Regex(@"[^\d]+"); 
    

    Nel qual caso , si può fare prendere uno di questi approcci:

    // simply replace the offending substrings with an empty string 
    private string CleanStringOfNonDigits_V1(string s) 
    { 
        if (string.IsNullOrEmpty(s)) return s ; 
        string cleaned = rxNonDigits.Replace(s, "") ; 
        return cleaned ; 
    } 
    
    // split the string into an array of good substrings 
    // using the bad substrings as the delimiter. Then use 
    // String.Join() to splice things back together. 
    private string CleanStringOfNonDigits_V2(string s) 
    { 
        if (string.IsNullOrEmpty(s)) return s; 
        string cleaned = String.Join(rxNonDigits.Split(s)); 
        return cleaned ; 
    } 
    

  • un set di caratteri positivo che definisce ciò che si desidera (cifre decimali):

    private static Regex rxDigits = new Regex(@"[\d]+") ; 
    

    In questo caso si può fare qualcosa di simile:

    private string CleanStringOfNonDigits_V3(string s) 
    { 
        if (string.IsNullOrEmpty(s)) return s ; 
        StringBuilder sb = new StringBuilder() ; 
        for (Match m = rxDigits.Match(s) ; m.Success ; m = m.NextMatch()) 
        { 
        sb.Append(m.Value) ; 
        } 
        string cleaned = sb.ToString() ; 
        return cleaned ; 
    } 
    

• Non siete tenuti a usare un'espressione regolare, sia.

  • Si potrebbe utilizzare LINQ direttamente, dal momento che una stringa è un IEnumerable<char>:

    private string CleanStringOfNonDigits_V4(string s) 
    { 
        if (string.IsNullOrEmpty(s)) return s; 
        string cleaned = new string(s.Where(char.IsDigit).ToArray()) ; 
        return cleaned; 
    } 
    

  • Se si sta solo trattare con alfabeti occidentali, dove le uniche cifre decimali che vedrete sono ASCII, saltando char.IsDigit probabilmente vi comprare un po 'di prestazione:

    private string CleanStringOfNonDigits_V5(string s) 
    { 
        if (string.IsNullOrEmpty(s)) return s; 
        string cleaned = new string(s.Where(c => c-'0' < 10).ToArray()) ; 
        return cleaned; 
    } 
    

• Infine, si può semplicemente iterare la stringa, serraggio le cifre che non si desidera, in questo modo:

  private string CleanStringOfNonDigits_V6(string s) 
  { 
      if (string.IsNullOrEmpty(s)) return s; 
      StringBuilder sb = new StringBuilder(s.Length) ; 
      for (int i = 0; i < s.Length; ++i) 
      { 
      char c = s[i]; 
      if (c < '0') continue ; 
      if (c > '9') continue ; 
      sb.Append(s[i]); 
      } 
      string cleaned = sb.ToString(); 
      return cleaned; 
  } 
  

  O questo:

  private string CleanStringOfNonDigits_V7(string s) 
  { 
      if (string.IsNullOrEmpty(s)) return s; 
      StringBuilder sb = new StringBuilder(s); 
      int j = 0 ; 
      int i = 0 ; 
      while (i < sb.Length) 
      { 
      bool isDigit = char.IsDigit(sb[i]) ; 
      if (isDigit) 
      { 
       sb[j++] = sb[i++]; 
      } 
      else 
      { 
       ++i ; 
      } 
      } 
      sb.Length = j; 
      string cleaned = sb.ToString(); 
      return cleaned; 
  } 
  

Dal punto di vista della chiarezza e pulizia del codice, la versione 1 è ciò che desideri. È difficile battere uno solo.

Se le prestazioni sono importanti, il mio sospetto è che la versione 7, l'ultima versione, sia la vincitrice. Crea uno spazio temporaneo — a StringBuilder() e esegue la trasformazione sul posto all'interno del buffer sul posto di StringBuilder.

Le altre opzioni fanno tutti più lavoro.

Answer 2

espressione uso reg

string result = Regex.Replace(phoneNumber, @"[^\d]", ""); 

Answer 3

string phoneNumber = "(914) 395-1430"; 
var numbers = String.Join("", phoneNumber.Where(char.IsDigit)); 

Answer 4

Egli vuol dire tutto @gleng

Regex rgx = new Regex(@"\D"); 
str = rgx.Replace(str, ""); 

Answer 5

provare qualcosa di simile

return new String(input.Where(Char.IsDigit).ToArray()); 

Answer 6

Invece di un'espressione regolare, è possibile utilizzare un Metodo LINQ:

phoneNumber = String.Concat(phoneNumber.Where(c => c >= '0' && c <= '9')); 

o:

phoneNumber = String.Concat(phoneNumber.Where(Char.IsDigit));