Ne conserver que la valeur numérique d'une chaîne?

Question

J'ai des ficelles comme ça

string phoneNumber = "[phone]";

Je voudrais dépouiller les parethenses et le tiret, dans l'autre Word gardent juste les valeurs numériques.

Donc, la sortie pourrait ressembler à ceci

9143951430

Comment puis-je obtenir la sortie souhaitée?

Answer 1

Vous effectuez l'une des opérations suivantes:

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

  • Une classe de caractères négative qui définit les caractères que vous ne voulez pas (ces caractères autres que des chiffres décimaux):

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

    Dans ce cas, vous pouvez utiliser 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 obligé 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 travaillez qu'avec des alphabets occidentaux où les seuls chiffres décimaux que vous verrez sont des caractères ASCII, le fait d'ignorer char.IsDigit vous rapportera probablement un petit rendement

    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 parcourir la chaîne en écrasant 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 ca:

  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 pureté du code, la version 1 est ce que vous voulez. Il est difficile de battre un one-liner.

Si les performances comptent, je soupçonne que la version 7, la dernière version, est gagnante. Il crée une temporaire - une StringBuilder() et effectue la transformation sur place dans la mémoire tampon sur place de StringBuilder.

Les autres options font toutes plus de travail.

Answer 2

utiliser l'expression reg 

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

Answer 3

essayez quelque chose comme ça 

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

Answer 4

string phoneNumber = "[phone]";
var numbers = String.Join("", phoneNumber.Where(char.IsDigit));

Answer 5

Il veut tout dire @gleng

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

Answer 6

Au lieu d'une expression régulière, vous pouvez utiliser une méthode LINQ:

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

ou:

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