una - string[] c# ejemplos

La forma más rápida de verificar si la cadena contiene solo dígitos

Question

Conozco algunas formas de comprobar esto. regex, int.parse , tryparse , looping.

¿alguien me puede decir cuál es la forma más rápida de verificar?

la necesidad es solo CHECK no hay necesidad de analizar realmente.

esta no es la misma pregunta que: ¿Cómo identifico si una cadena es un número?

la pregunta no es solo acerca de cómo identificarse. pero sobre cuál es el método más rápido .

Answer 1

¿Qué pasa con char.IsDigit(myChar) ?

Answer 2

Aquí hay algunos puntos de referencia basados ​​en 1000000 análisis de la misma cadena:

Actualizado para las estadísticas de release :

IsDigitsOnly: 384588
TryParse:     639583
Regex:        1329571

Aquí está el código, parece que IsDigitsOnly es más rápido:

class Program
{
    private static Regex regex = new Regex("^[0-9]+$", RegexOptions.Compiled);

    static void Main(string[] args)
    {
        Stopwatch watch = new Stopwatch();
        string test = int.MaxValue.ToString();
        int value;

        watch.Start();
        for(int i=0; i< 1000000; i++)
        {
            int.TryParse(test, out value);
        }
        watch.Stop();
        Console.WriteLine("TryParse: "+watch.ElapsedTicks);

        watch.Reset();
        watch.Start();
        for (int i = 0; i < 1000000; i++)
        {
            IsDigitsOnly(test);
        }
        watch.Stop();
        Console.WriteLine("IsDigitsOnly: " + watch.ElapsedTicks);

        watch.Reset();
        watch.Start();
        for (int i = 0; i < 1000000; i++)
        {
            regex.IsMatch(test);
        }
        watch.Stop();
        Console.WriteLine("Regex: " + watch.ElapsedTicks);

        Console.ReadLine();
    }

    static bool IsDigitsOnly(string str)
    {
        foreach (char c in str)
        {
            if (c < ''0'' || c > ''9'')
                return false;
        }

        return true;
    }
}

Por supuesto, vale la pena señalar que TryParse permite espacios en blanco iniciales / finales, así como símbolos específicos de cultura. También está limitado en la longitud de la cuerda.

Answer 3

El char ya tiene un IsDigit (char c) que hace esto:

 public static bool IsDigit(char c)
    {
      if (!char.IsLatin1(c))
        return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.DecimalDigitNumber;
      if ((int) c >= 48)
        return (int) c <= 57;
      else
        return false;
    }

Simplemente puede hacer esto:

var theString = "839278";
bool digitsOnly = theString.All(char.IsDigit);

Answer 4

Esto debería funcionar:

Regex.IsMatch("124", "^[0-9]+$", RegexOptions.Compiled)

int.Parse o int.TryParse no siempre funcionará, porque la cadena puede contener más dígitos que un int puede contener.

Si va a hacer esta comprobación más de una vez, es útil utilizar una expresión regular compilada: tarda más tiempo la primera vez, pero es mucho más rápido después de eso.

Answer 5

Me gusta Linq y para hacerlo salir en el primer desajuste puedes hacer esto

string str = ''0129834X33'';
bool isAllDigits = !str.Any( ch=> ch < ''0'' || ch > ''9'' );

Answer 6

Muy inteligente y fácil de detectar su cadena contiene solo dígitos o no es así:

string s = "12fg";

if(s.All(char.IsDigit))
{
   return true; // contains only digits
}
else
{
   return false; // contains not only digits
}

Answer 7

Probablemente la manera más rápida es:

myString.All(c => char.IsDigit(c))

Nota: devolverá True en caso de que su cadena esté vacía, lo que es incorrecto (si no considera el número vacío como número / dígito válido)

Answer 8

Prueba este código:

bool isDigitsOnly(string str)
{
   try
   {
      int number = Convert.ToInt32(str);
      return true;
   }
   catch (Exception)
   {
      return false;
   }
}

Answer 9

Puede hacer esto en una declaración LINQ de una línea. De acuerdo, me doy cuenta de que esto no es necesariamente el más rápido, por lo que técnicamente no responde la pregunta, pero probablemente sea la más fácil de escribir:

str.All(c => c >= ''0'' && c <= ''9'')

Answer 10

Puede intentar usar Expresiones regulares probando la cadena de entrada para tener solo dígitos (0-9) usando el .IsMatch(string input, string pattern) en C #.

using System;
using System.Text.RegularExpression;

public namespace MyNS
{
    public class MyClass
    {
        public void static Main(string[] args)
        {
             string input = Console.ReadLine();
             bool containsNumber = ContainsOnlyDigits(input);
        }

        private bool ContainOnlyDigits (string input)
        {
            bool containsNumbers = true;
            if (!Regex.IsMatch(input, @"/d"))
            {
                containsNumbers = false;
            }
            return containsNumbers;
        }
    }
}

Saludos

Answer 11

Puede ser aproximadamente un 20% más rápido usando solo una comparación por char y for lugar de foreach :

bool isDigits(string s) 
{ 
    if (s == null || s == "") return false; 

    for (int i = 0; i < s.Length; i++) 
        if ((s[i] ^ ''0'') > 9) 
            return false; 

    return true; 
}

Código utilizado para las pruebas (siempre el perfil porque los resultados dependen del hardware, las versiones, el orden, etc.):

static bool isDigitsFr(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if (s[i] < ''0'' || s[i] > ''9'') return false; return true; }
static bool isDigitsFu(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if ((uint)(s[i] - ''0'') > 9) return false; return true; }
static bool isDigitsFx(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if ((s[i] ^ ''0'') > 9) return false; return true; }
static bool isDigitsEr(string s) { if (s == null || s == "") return false; foreach (char c in s) if (c < ''0'' || c > ''9'') return false; return true; }
static bool isDigitsEu(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((uint)(c - ''0'') > 9) return false; return true; }
static bool isDigitsEx(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((c ^ ''0'') > 9) return false; return true; }
static void test()
{
    var w = new Stopwatch(); bool b; var s = int.MaxValue + ""; int r = 12345678*2; var ss = new SortedSet<string>(); //s = string.Concat(Enumerable.Range(0, 127).Select(i => ((char)i ^ ''0'') < 10 ? 1 : 0));
    w.Restart(); for (int i = 0; i < r; i++) b = s.All(char.IsDigit); w.Stop(); ss.Add(w.Elapsed + ".All .IsDigit"); 
    w.Restart(); for (int i = 0; i < r; i++) b = s.All(c => c >= ''0'' && c <= ''9''); w.Stop(); ss.Add(w.Elapsed + ".All <>"); 
    w.Restart(); for (int i = 0; i < r; i++) b = s.All(c => (c ^ ''0'') < 10); w.Stop(); ss.Add(w.Elapsed + " .All ^"); 
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFr(s); w.Stop(); ss.Add(w.Elapsed + " for     <>");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFu(s); w.Stop(); ss.Add(w.Elapsed + " for     -");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFx(s); w.Stop(); ss.Add(w.Elapsed + " for     ^");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEr(s); w.Stop(); ss.Add(w.Elapsed + " foreach <>");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEu(s); w.Stop(); ss.Add(w.Elapsed + " foreach -");
    w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEx(s); w.Stop(); ss.Add(w.Elapsed + " foreach ^");
    MessageBox.Show(string.Join("/n", ss)); return;
}

Resultados en Intel i5-3470 @ 3.2GHz, VS 2015 .NET 4.6.1 Modo de lanzamiento y optimizaciones habilitadas:

time    method          ratio
0.7776  for     ^       1.0000 
0.7984  foreach -       1.0268 
0.8066  foreach ^       1.0372 
0.8940  for     -       1.1497 
0.8976  for     <>      1.1543 
0.9456  foreach <>      1.2160 
4.4559  .All <>         5.7303 
4.7791  .All ^          6.1458 
4.8539  .All. IsDigit   6.2421 

Para cualquier persona tentada de usar los métodos más cortos, tenga en cuenta que

• .All resultados son true para cadenas vacías y excepción para cadenas null
• char.IsDigit es verdadero para todos los caracteres Unicode en la categoría Nd
• int.TryParse también permite spase blanco y signos de caracteres

Answer 12

Si le preocupa el rendimiento, no use int.TryParse ni Regex : escriba su propia función (simple) ( DigitsOnly o DigitsOnly2 continuación, pero no DigitsOnly3 - LINQ parece incurrir en una sobrecarga significativa).

Además, tenga en cuenta que int.TryParse fallará si la cadena es demasiado larga para "ajustarse" en int .

Este punto de referencia simple ...

class Program {

    static bool DigitsOnly(string s) {
        int len = s.Length;
        for (int i = 0; i < len; ++i) {
            char c = s[i];
            if (c < ''0'' || c > ''9'')
                return false;
        }
        return true;
    }

    static bool DigitsOnly2(string s) {
        foreach (char c in s) {
            if (c < ''0'' || c > ''9'')
                return false;
        }
        return true;
    }

    static bool DigitsOnly3(string s) {
        return s.All(c => c >= ''0'' && c <= ''9'');
    }

    static void Main(string[] args) {

        const string s1 = "916734184";
        const string s2 = "916734a84";

        const int iterations = 1000000;
        var sw = new Stopwatch();

        sw.Restart();
        for (int i = 0 ; i < iterations; ++i) {
            bool success = DigitsOnly(s1);
            bool failure = DigitsOnly(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("DigitsOnly: {0}", sw.Elapsed));

        sw.Restart();
        for (int i = 0; i < iterations; ++i) {
            bool success = DigitsOnly2(s1);
            bool failure = DigitsOnly2(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("DigitsOnly2: {0}", sw.Elapsed));

        sw.Restart();
        for (int i = 0; i < iterations; ++i) {
            bool success = DigitsOnly3(s1);
            bool failure = DigitsOnly3(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("DigitsOnly3: {0}", sw.Elapsed));

        sw.Restart();
        for (int i = 0; i < iterations; ++i) {
            int dummy;
            bool success = int.TryParse(s1, out dummy);
            bool failure = int.TryParse(s2, out dummy);
        }
        sw.Stop();
        Console.WriteLine(string.Format("int.TryParse: {0}", sw.Elapsed));

        sw.Restart();
        var regex = new Regex("^[0-9]+$", RegexOptions.Compiled);
        for (int i = 0; i < iterations; ++i) {
            bool success = regex.IsMatch(s1);
            bool failure = regex.IsMatch(s2);
        }
        sw.Stop();
        Console.WriteLine(string.Format("Regex.IsMatch: {0}", sw.Elapsed));

    }

}

... produce el siguiente resultado ...

DigitsOnly: 00:00:00.0346094
DigitsOnly2: 00:00:00.0365220
DigitsOnly3: 00:00:00.2669425
int.TryParse: 00:00:00.3405548
Regex.IsMatch: 00:00:00.7017648

Answer 13

Simplemente puedes hacer esto usando LINQ

return str.All(char.IsDigit);

Answer 14

esto funcionará perfectamente, hay muchas otras formas pero esto funcionaría

bool IsDigitsOnly(string str)
    {
        if (str.Length > 0)//if contains characters
        {
            foreach (char c in str)//assign character to c
            {
                if (c < ''0'' || c > ''9'')//check if its outside digit range
                    return false;
            }
        }else//empty string
        {
            return false;//empty string 
        }

        return true;//only digits
    }

Answer 15

bool IsDigitsOnly(string str)
{
    foreach (char c in str)
    {
        if (c < ''0'' || c > ''9'')
            return false;
    }

    return true;
}

Probablemente sea la forma más rápida de hacerlo.

Answer 16

public bool CheckforDigits(string x)
{    
    int tr;  
    return x.All(r=> int.TryParse(r.ToString(), out tr));
}