Garder seulement la valeur numérique d'une chaîne de caractères?

vous faites l'un des actes suivants:

• utiliser des expressions régulières. Vous pouvez utiliser une expression régulière avec

  • une classe de caractères négatifs qui définit les caractères qui sont ce que vous ne voulez pas (ces caractères autres que décimaux):

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

    dans ce cas, vous pouvez faire l'une de ces approches:

    // 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 jeu de caractères positif qui définit ce que vous voulez (chiffres décimaux):

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

    Dans ce cas, vous pouvez faire quelque chose comme ceci:

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

• vous n'êtes pas tenus d'utiliser une expression régulière, non plus.

  • vous pouvez utiliser LINQ directement, car une chaîne est 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;
    }
    

  • si vous ne traitez que des alphabets occidentaux où les seuls chiffres décimaux que vous verrez sont ASCII, sauter char.IsDigit vous achètera probablement une petite performance:

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

• enfin, vous pouvez simplement itérer sur la chaîne, en glissant les chiffres que vous ne voulez pas, comme ceci:

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

  ou ceci:

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

du point de vue de la clarté et de la propreté du code, la version 1 est ce que vous voulez. Il est difficile de battre une seule ligne.

si la performance compte, je soupçonne que la version 7, la dernière version, est la gagnante. Il crée un temporaire-un StringBuilder() et effectue la transformation en place dans le tampon en place du constructeur de liens.

les autres options font toutes plus de travail.