it-swarm.com.de

Nur numerischen Wert aus einer Zeichenfolge behalten?

Ich habe einige solche Zeichenfolgen

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

Ich möchte die Parethenen und den Bindestrich streifen, in anderen Worten nur die numerischen Werte behalten.

Die Ausgabe könnte also so aussehen

9143951430

Wie erhalte ich die gewünschte Ausgabe?

14
meda

Sie haben folgende Möglichkeiten:

  • Verwenden Sie reguläre Ausdrücke. Sie können mit beiden einen regulären Ausdruck verwenden

    • Eine negative Zeichenklasse, die die Zeichen definiert, die Sie nicht möchten (andere Zeichen als Dezimalstellen):

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

      In diesem Fall können Sie einen der folgenden Ansätze wählen:

      // 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 ;
      }
      
    • ein positiver Zeichensatz, der definiert, was Sie wollen (Dezimalstellen):

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

      In diesem Fall können Sie Folgendes tun:

      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 ;
      }
      
  • Sie müssen auch keinen regulären Ausdruck verwenden.

    • Sie können LINQ direkt verwenden, da eine Zeichenfolge ein IEnumerable<char> ist:

      private string CleanStringOfNonDigits_V4( string s )
      {
        if ( string.IsNullOrEmpty(s) ) return s;
        string cleaned = new string( s.Where( char.IsDigit ).ToArray() ) ;
        return cleaned;
      }
      
    • Wenn Sie sich nur mit westlichen Alphabeten beschäftigen, bei denen die einzigen Dezimalstellen ASCII sind, können Sie durch Überspringen von char.IsDigit wahrscheinlich etwas Leistung erzielen:

      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;
      }
      
  • Schließlich können Sie einfach über die Zeichenfolge iterieren und die nicht gewünschten Ziffern wie folgt eingeben:

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

    Oder dieses:

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

Vom Standpunkt der Klarheit und Sauberkeit des Codes ist die Version 1 genau das, was Sie wollen. Es ist schwer, einen Einzeiler zu schlagen.

Wenn es auf die Leistung ankommt, ist mein Verdacht, dass die Version 7, die letzte Version, der Gewinner ist. Es erstellt eine temporäre Funktion - eine StringBuilder() und führt die Umwandlung direkt im internen Puffer des StringBuilder durch.

Die anderen Optionen erledigen alle mehr Arbeit.

32
Nicholas Carey

verwenden Sie reg Ausdruck

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

versuche so etwas

  return new String(input.Where(Char.IsDigit).ToArray());
11
BRAHIM Kamel
string phoneNumber = "(914) 395-1430";
var numbers = String.Join("", phoneNumber.Where(char.IsDigit));
9
L.B

Er meint alles @gleng

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

Anstelle eines regulären Ausdrucks können Sie eine LINQ-Methode verwenden:

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

oder:

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