¿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?

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

Actualización a partir de C # 7:

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

¡Las var s se pueden reemplazar por sus respectivos tipos!

Esto volverá 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") 

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

También puedes usar:

 stringTest.All(char.IsDigit); 

Volverá 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 pasaría la prueba de ser numérico.

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://sofes.miximages.com/c%23/Figure1.gif

texto alternativo http://sofes.miximages.com/c%23/Figure2.gif

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.

Las soluciones que usan la int.Parse(someString) muestra 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 entonces no tenía otra opción. Ahora lo haces: por lo tanto, debes evitar la alternativa de 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.

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

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; } } 

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 { ///  /// Returns true if string is numeric and not empty or null or whitespace. /// Determines if string is numeric by parsing as Double ///  ///  /// Optional style - defaults to NumberStyles.Number (leading and trailing whitespace, leading and trailing sign, decimal point and thousands separator)  /// Optional CultureInfo - defaults to InvariantCulture ///  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.

Si desea capturar un espectro más amplio de números, a la_s_numeric de PHP, 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 (eg 0xf4c3b00c), Binary (eg 0b10100111001), Octal (eg 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, es decir).

Si quieres comprobar si una cadena es un número (supongo que es una cadena, ya que si es un número, duh, sabes que 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 encargará de los desagradables habituales:

  • Menos (-) o más (+) en el comienzo
  • contiene caracteres decimales BigIntegers no analizará números con decimales. (Entonces: BigInteger.Parse("3.3") arrojará una excepción, y TryParse para el mismo devolverá false)
  • no graciosos no dígitos
  • cubre casos donde el número es mayor que el uso habitual de Double.TryParse

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

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 le dirá si funcionó o no.

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

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

¿Por qué? Porque es molesto tener que declarar una variable de out y comprobar 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 simplemente 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(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.Parse(sNumber) : 0; 

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

El método utiliza la reflexión y terminas llamando al método TryParse() dos veces, lo que por supuesto no es tan eficiente, pero no todo debe ser optimizado por completo, 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 tipo double o de otro tipo con un valor predeterminado sin tener que atrapar ninguna excepción:

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

Método de extensión dos

 public static TOutput ParseAs(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 sigue usando la reflexión …

Ejemplos:

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

Productos:

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

Double.TryParse

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

Si quieres saber si una cadena es un número, siempre puedes intentar analizarlo:

 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.

Con c # 7 puedes alinear la variable de salida:

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

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

 public static class ExtensionMethods { ///  /// Returns true if string could represent a valid number, including decimals and local culture symbols ///  public static bool IsNumeric(this string s) { decimal d; return decimal.TryParse(s, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out d); } ///  /// Returns true only if string is wholy comprised of numerical digits ///  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; } } 
 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; } 

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 } 

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

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

  // Using Microsoft.VisualBasic; var txt = "ABCDEFG"; if (Information.IsNumeric(txt)) Console.WriteLine ("Numeric"); IsNumeric("12.3"); // true IsNumeric("1"); // true IsNumeric("abc"); // false 
 //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; }