Ne garder que la valeur numérique d'une chaîne de caractères?

Vous effectuez l'une des opérations suivantes:

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

  • Un caractère négatif de la classe qui définit les caractères qui sont que vous ne voulez pas (ceux des caractères autres que des chiffres décimaux):

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

    Dans ce cas, vous pouvez ne prendre aucune 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 ;
    }

  • positif du jeu de caractères 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 obligé d'utiliser une expression régulière, soit.

  • Vous pouvez utiliser LINQ directement, depuis une chaîne de caractères 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 êtes seulement à faire avec les alphabets occidentaux, où les seuls chiffres après la virgule que vous verrez ASCII, sauter char.IsDigit seront susceptibles de vous acheter un peu de 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 effectuer une itération sur la chaîne, jetant 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;
  }

À partir d'un 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 est importante, ce que je soupçonne, c'est que la version 7, la dernière version, est le gagnant. Il crée un temporaire — une StringBuilder() et la transformation sur place au sein de la classe StringBuilder en place de tampon.

Les autres options à faire plus de travail.

OriginalL'auteur Nicholas Carey

essayer quelque chose comme cela

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

OriginalL'auteur BRAHIM Kamel

Il signifie tout @gleng

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

OriginalL'auteur Darka