c# - saber - ¿Cómo identifico si una cadena es un número?

tryparse c#

Question

Si tengo estas cuerdas:

1. "abc" = false

2. "123" = true

3. "ab2" = false

¿Hay un comando, como IsNumeric o algo más, que pueda identificar si una cadena es un número válido?

Answer 1

Aquí está el método C # Método Int.TryParse (String, Int32)

Answer 2

Con c # 7 puede alinear la variable de salida:

if(int.TryParse(str, out int v))
{
}

Answer 3

En caso de que no quieras usar int.Parse o double.Parse, puedes hacer tu propio rollo 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;
    }
}

Answer 4

Espero que esto ayude

string myString = "abc";
double num;
bool isNumber = double.TryParse(myString , out num);

if isNumber 
{
//string is number
}
else
{
//string is not a number
}

Answer 5

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

Si desea 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 en un número (entero) y, si tiene éxito, devolverá verdadero y colocará el número correspondiente en myInt. Si no puede, devuelve falso.

Las soluciones que usan la int.Parse(someString) mostrada en otras respuestas funcionan, 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 ese momento no tenía opción. Ahora sí, debes evitar la alternativa Parse() .

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

Answer 6

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

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

Si solo quiere saber si tiene uno o más números mezclados con caracteres, deje de + y $ .

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

Edición: en realidad creo que es mejor que TryParse porque una cadena muy larga podría potencialmente desbordar TryParse.

Answer 7

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

Desde Benchmarking IsNumeric Opciones

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

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

Answer 8

Obtenga una referencia a Visual Basic en su proyecto y use su método Information.IsNumeric como se muestra a continuación y sea capaz de capturar flotantes y enteros a diferencia de la respuesta anterior que solo detecta ints.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

    if (Information.IsNumeric(txt))
        Console.WriteLine ("Numeric");

IsNumeric("12.3"); // true
IsNumeric("1"); // true
IsNumeric("abc"); // false

Answer 9

Puede usar TryParse para determinar si la cadena se puede analizar en un entero.

int i;
bool bNum = int.TryParse(str, out i);

El booleano te dirá si funcionó o no.

Answer 10

Sé que este es un hilo viejo, pero ninguna de las respuestas lo hizo por mí, ya sea ineficiente o no encapsulada para una reutilización fácil. También quería asegurarme de que devolviera falso si la cadena estaba vacía o era nula. TryParse devuelve true 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, si desea probar otros tipos de números, puede especificar el ''estilo''. Entonces, para convertir un número con un Exponent, puedes usar:

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

O para probar una posible cadena Hex, puedes usar:

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

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

Está limitado por no poder convertir cadenas que son demasiado grandes para ser contenidas en un doble, pero ese es un requisito limitado y creo que si trabaja con números más grandes que esto, entonces probablemente necesitará un manejo de números especializado adicional. Funciona de todos modos.

Answer 11

Si desea capturar un espectro más amplio de números, a la PHP is_numeric , puede 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 solo porque 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 perfectamente, pero no encajará en un tipo numérico .NET (no uno definido en la biblioteca estándar, es decir).

Answer 12

Si desea comprobar si una cadena es un número (supongo que es una cadena, ya que si es un número, ya sabe, es uno).

• Sin expresiones regulares y
• usando el código de Microsoft tanto como sea posible

También podrías hacer:

public static bool IsNumber(this string aNumber)
{
     BigInteger temp_big_int;
     var is_number = BigInteger.TryParse(aNumber, out temp_big_int);
     return is_number;
}

Esto se hará cargo de los desagradables habituales:

• Menos (-) o más (+) al principio
• contiene caracteres decimales BigIntegers no analizará números con puntos decimales. (Entonces: BigInteger.Parse("3.3") lanzará una excepción, y TryParse para el mismo devolverá falso)
• no graciosos sin dígitos
• cubre los casos en que el número es más grande que el uso habitual de Double.TryParse

Tendrá que agregar una referencia a System.Numerics y using System.Numerics; en la parte superior de su clase (bueno, el segundo es un bono, supongo :)

Answer 13

Si desea saber si una cadena es un número, siempre puede intentar analizarla:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Tenga en cuenta que TryParse devuelve un bool , que puede usar para verificar si su análisis tuvo éxito.

Answer 14

Siempre puede usar los métodos TryParse incorporados 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 entonces = Verdadero

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

El resultado sería entonces = falso

Answer 15

Supongo que esta respuesta se perderá entre todas las demás, pero de todos modos, aquí va.

Terminé con esta pregunta a través de Google porque quería comprobar si una string era numeric para poder usar double.Parse("123") lugar del método TryParse() .

¿Por qué? Debido a que es molesto tener que declarar una variable de out y verificar el resultado de TryParse() antes que ahora, si el análisis falló o no. Quiero usar el ternary operator para verificar si la string es numerical y luego analizarla en la primera expresión ternaria o proporcionar un valor predeterminado en la segunda expresión ternaria.

Me gusta esto:

var doubleValue = IsNumeric(numberAsString) ? double.Parse(numberAsString) : 0;

Es mucho más limpio que:

var doubleValue = 0;
if (double.TryParse(numberAsString, out doubleValue)) {
    //whatever you want to do with doubleValue
}

Hice un par de extension methods para estos casos:

Método de extensión uno

public static bool IsParseableAs<TInput>(this string value) {
    var type = typeof(TInput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return false;

    var arguments = new[] { value, Activator.CreateInstance(type) };
    return (bool) tryParseMethod.Invoke(null, arguments);
}

Ejemplo:

"123".IsParseableAs<double>() ? double.Parse(sNumber) : 0;

Debido a que IsParseableAs() intenta analizar la cadena como el tipo apropiado en lugar de solo verificar si la cadena es "numérica" ​​debería ser bastante segura. E incluso puede usarlo para tipos no numéricos que tienen un método TryParse() , como DateTime .

El método usa la reflexión y terminas llamando al método TryParse() dos veces, lo que por supuesto no es tan eficiente, pero no todo tiene que estar completamente optimizado, a veces la conveniencia es más importante.

Este método también se puede usar para analizar fácilmente una lista de cadenas numéricas en una lista de double o algún otro tipo con un valor predeterminado sin tener que detectar ninguna excepción:

var sNumbers = new[] {"10", "20", "30"};
var dValues = sNumbers.Select(s => s.IsParseableAs<double>() ? double.Parse(s) : 0);

Método de extensión dos

public static TOutput ParseAs<TOutput>(this string value, TOutput defaultValue) {
    var type = typeof(TOutput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return defaultValue;

    var arguments = new object[] { value, null };
    return ((bool) tryParseMethod.Invoke(null, arguments)) ? (TOutput) arguments[1] : defaultValue;
}

Este método de extensión le permite analizar una string como cualquier type que tenga un método TryParse() y también le permite especificar un valor predeterminado para devolver si la conversión falla.

Esto es mejor que usar el operador ternario con el método de extensión anterior, ya que solo hace la conversión una vez, aunque aún usa reflexión ...

Ejemplos:

"123".ParseAs<int>(10);
"abc".ParseAs<int>(25);
"123,78".ParseAs<double>(10);
"abc".ParseAs<double>(107.4);
"2014-10-28".ParseAs<DateTime>(DateTime.MinValue);
"monday".ParseAs<DateTime>(DateTime.MinValue);

Salidas:

123
25
123,78
107,4
28.10.2014 00:00:00
01.01.0001 00:00:00

Answer 16

También puedes usar:

stringTest.All(char.IsDigit);

Devolverá 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 debe ser una cadena vacía, ya que esto pasaría la prueba de ser numérico.

Answer 17

Utilice estos métodos de extensión para distinguir claramente entre una verificación si la cadena es numérica y si la cadena solo contiene de 0 a 9 dígitos

public static class ExtensionMethods
{
    /// <summary>
    /// Returns true if string could represent a valid number, including decimals and local culture symbols
    /// </summary>
    public static bool IsNumeric(this string s)
    {
        decimal d;
        return decimal.TryParse(s, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out d);
    }

    /// <summary>
    /// Returns true only if string is wholy comprised of numerical digits
    /// </summary>
    public static bool IsNumbersOnly(this string s)
    {
        if (s == null || s == string.Empty)
            return false;

        foreach (char c in s)
        {
            if (c < ''0'' || c > ''9'') // Avoid using .IsDigit or .IsNumeric as they will return true for other characters
                return false;
        }

        return true;
    }
}

Answer 18

Double.TryParse

bool Double.TryParse(string s, out double result)

Answer 19

ACTUALIZACIÓN de Kunal Noel Respuesta

stringTest.All(char.IsDigit);
// This returns true if all characters of the string are digits.

Pero, para este caso, tenemos que las cadenas vacías pasarán esa prueba, entonces, usted puede:

if (!string.IsNullOrEmpty(stringTest) && stringTest.All(char.IsDigit)){
   // Do your logic here
}

Answer 20

//To my knowledge I did this in a simple way
static void Main(string[] args)
{
    string a, b;
    int f1, f2, x, y;
    Console.WriteLine("Enter two inputs");
    a = Convert.ToString(Console.ReadLine());
    b = Console.ReadLine();
    f1 = find(a);
    f2 = find(b);

    if (f1 == 0 && f2 == 0)
    {
        x = Convert.ToInt32(a);
        y = Convert.ToInt32(b);
        Console.WriteLine("Two inputs r number /n so that addition of these text box is= " + (x + y).ToString());
    }
    else
        Console.WriteLine("One or two inputs r string /n so that concatenation of these text box is = " + (a + b));
    Console.ReadKey();
}

static int find(string s)
{
    string s1 = "";
    int f;
    for (int i = 0; i < s.Length; i++)
       for (int j = 0; j <= 9; j++)
       {
           string c = j.ToString();
           if (c[0] == s[i])
           {
               s1 += c[0];
           }
       }

    if (s == s1)
        f = 0;
    else
        f = 1;

    return f;
}

Answer 21

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

Actualizar a partir de C # 7:

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

Las var s pueden ser reemplazadas por sus respectivos tipos!

Answer 22

public static bool IsNumeric(this string input)
{
    int n;
    if (!string.IsNullOrEmpty(input)) //.Replace(''.'',null).Replace('','',null)
    {
        foreach (var i in input)
        {
            if (!int.TryParse(i.ToString(), out n))
            {
                return false;
            }

        }
        return true;
    }
    return false;
}