Pregunta ¿Cómo identifico si una cadena es un número?


Si tengo estas cadenas:

  1. "abc"  = false

  2. "123"  = true

  3. "ab2"  = false

¿Hay algún comando, como IsNumeric u otra cosa, que pueda identificar si una cadena es un número válido?


550
2018-05-21 18:06


origen


Respuestas:


int n;
bool isNumeric = int.TryParse("123", out n);

Actualizar A partir de C # 7:

var isNumeric = int.TryParse("123", out int n);

los var s pueden ser reemplazados por sus respectivos tipos!


863
2018-05-21 18:08



Esto volverá verdadero si input son todos los números No sé si es mejor que TryParse, pero funcionará.

Regex.IsMatch(input, @"^\d+$")

Si solo quieres saber si tiene uno o más números mezclados con los personajes, deja el ^  + y $.

Regex.IsMatch(input, @"\d")

Editar: En realidad, creo que es mejor que TryParse porque una cadena muy larga podría desbordar a TryParse.


313
2018-05-21 19:08



También puedes usar:

stringTest.All(char.IsDigit);

Regresará true para todos los dígitos numéricos (no float) y false si la cadena de entrada es cualquier tipo de alfanumérico.

tenga en cuenta: stringTest no debería ser una cadena vacía ya que pasaría la prueba de ser numérico.


120
2017-10-20 12:06



He usado esta función varias veces:

public static bool IsNumeric(object Expression)
{
    double retNum;

    bool isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
    return isNum;
}

Pero también puedes usar;

bool b1 = Microsoft.VisualBasic.Information.IsNumeric("1"); //true
bool b2 = Microsoft.VisualBasic.Information.IsNumeric("1aa"); // false

De Benchmarking IsNumeric Opciones

texto alternativo http://aspalliance.com/images/articleimages/80/Figure1.gif

texto alternativo http://aspalliance.com/images/articleimages/80/Figure2.gif


111
2018-05-21 18:20



Esta es probablemente la mejor opción en C #.

Si quieres saber si la cadena contiene un número entero (entero):

string someString;
// ...
int myInt;
bool isNumerical = int.TryParse(someString, out myInt);

El método TryParse intentará convertir la cadena a un número (entero) y si tiene éxito, devolverá verdadero y colocará el número correspondiente en myInt. Si no puede, devuelve falso.

Soluciones usando el int.Parse(someString) La alternativa mostrada en otras respuestas funciona, pero es mucho más lenta porque lanzar excepciones es muy costoso. TryParse(...) se agregó al lenguaje C # en la versión 2, y hasta entonces no tenía otra opción. Ahora lo hace: por lo tanto, debe evitar el Parse() alternativa.

Si quiere aceptar números decimales, la clase decimal también tiene un .TryParse(...) método. Reemplace int con decimal en la discusión anterior, y se aplican los mismos principios.


31
2018-05-21 18:16



Siempre puede usar los métodos integrados de TryParse para muchos tipos de datos para ver si la cadena en cuestión pasará.

Ejemplo.

decimal myDec;
var Result = decimal.TryParse("123", out myDec);

El resultado sería = Verdadero

decimal myDec;
var Result = decimal.TryParse("abc", out myDec);

El resultado sería entonces = Falso


23
2018-05-21 18:09



En caso de que no quiera usar int.Parse o double.Parse, puede hacer rodar el suyo con algo como esto:

public static class Extensions
{
    public static bool IsNumeric(this string s)
    {
        foreach (char c in s)
        {
            if (!char.IsDigit(c) && c != '.')
            {
                return false;
            }
        }

        return true;
    }
}

17
2018-05-21 18:13



Sé que este es un hilo viejo, pero ninguna de las respuestas realmente lo hizo por mí, ya sea ineficiente o no encapsulado para una fácil reutilización. También quería asegurarme de que devolviera false si la cadena estaba vacía o nula. TryParse devuelve verdadero en este caso (una cadena vacía no causa un error al analizar como un número). Entonces, aquí está mi método de extensión de cadena:

public static class Extensions
{
    /// <summary>
    /// Returns true if string is numeric and not empty or null or whitespace.
    /// Determines if string is numeric by parsing as Double
    /// </summary>
    /// <param name="str"></param>
    /// <param name="style">Optional style - defaults to NumberStyles.Number (leading and trailing whitespace, leading and trailing sign, decimal point and thousands separator) </param>
    /// <param name="culture">Optional CultureInfo - defaults to InvariantCulture</param>
    /// <returns></returns>
    public static bool IsNumeric(this string str, NumberStyles style = NumberStyles.Number,
        CultureInfo culture = null)
    {
        double num;
        if (culture == null) culture = CultureInfo.InvariantCulture;
        return Double.TryParse(str, style, culture, out num) && !String.IsNullOrWhiteSpace(str);
    }
}

Fácil de usar:

var mystring = "1234.56789";
var test = mystring.IsNumeric();

O bien, si desea probar otros tipos de número, puede especificar el 'estilo'. Entonces, para convertir un número con un exponente, podrías usar:

var mystring = "5.2453232E6";
var test = mystring.IsNumeric(style: NumberStyles.AllowExponent);

O para probar una posible cadena hexadecimal, podrías usar:

var mystring = "0xF67AB2";
var test = mystring.IsNumeric(style: NumberStyles.HexNumber)

El parámetro opcional 'cultura' se puede usar de la misma manera.

Está limitado al no poder convertir cadenas que son demasiado grandes para contenerlas en un doble, pero ese es un requisito limitado y creo que si trabajas con números más grandes que este, entonces probablemente necesitarás un manejo de número especializado adicional. funciones de todos modos.


13
2017-09-29 09:44



Si desea capturar un espectro más amplio de números, a la PHP is_numeric, puedes usar lo siguiente:

// From PHP documentation for is_numeric
// (http://php.net/manual/en/function.is-numeric.php)

// Finds whether the given variable is numeric.

// Numeric strings consist of optional sign, any number of digits, optional decimal part and optional
// exponential part. Thus +0123.45e6 is a valid numeric value.

// Hexadecimal (e.g. 0xf4c3b00c), Binary (e.g. 0b10100111001), Octal (e.g. 0777) notation is allowed too but
// only without sign, decimal and exponential part.
static readonly Regex _isNumericRegex =
    new Regex(  "^(" +
                /*Hex*/ @"0x[0-9a-f]+"  + "|" +
                /*Bin*/ @"0b[01]+"      + "|" + 
                /*Oct*/ @"0[0-7]*"      + "|" +
                /*Dec*/ @"((?!0)|[-+]|(?=0+\.))(\d*\.)?\d+(e\d+)?" + 
                ")$" );
static bool IsNumeric( string value )
{
    return _isNumericRegex.IsMatch( value );
}

Prueba de unidad:

static void IsNumericTest()
{
    string[] l_unitTests = new string[] { 
        "123",      /* TRUE */
        "abc",      /* FALSE */
        "12.3",     /* TRUE */
        "+12.3",    /* TRUE */
        "-12.3",    /* TRUE */
        "1.23e2",   /* TRUE */
        "-1e23",    /* TRUE */
        "1.2ef",    /* FALSE */
        "0x0",      /* TRUE */
        "0xfff",    /* TRUE */
        "0xf1f",    /* TRUE */
        "0xf1g",    /* FALSE */
        "0123",     /* TRUE */
        "0999",     /* FALSE (not octal) */
        "+0999",    /* TRUE (forced decimal) */
        "0b0101",   /* TRUE */
        "0b0102"    /* FALSE */
    };

    foreach ( string l_unitTest in l_unitTests )
        Console.WriteLine( l_unitTest + " => " + IsNumeric( l_unitTest ).ToString() );

    Console.ReadKey( true );
}

Tenga en cuenta que el hecho de que un valor sea numérico no significa que se pueda convertir a un tipo numérico. Por ejemplo, "999999999999999999999999999999.9999999999" es un valor numérico válido perfecto, pero no encajará en un tipo numérico .NET (no definido en la biblioteca estándar, eso es).


9
2018-04-30 15:04