Identificar si una cadena es un número


731

Si tengo estas cadenas:

  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?


79
de sus ejemplos se puede ver que querían decir si toda la cadena representa un número.
Lucas

47
return str.All (Char.IsDigit);
Mohsen

13
str.All (Char.IsDigit) declarará "3.14" falso, así como "-2" y "3E14". Por no hablar de: "0x10"
Harald Coppoolse

44
Depende del tipo de número que intente verificar. Para números enteros sin separador (es decir, cadenas de dígitos decimales) esta verificación funciona, y es la misma de la respuesta aceptada y la implicada en OP.
Alex Mazzariol

1
@Lucas gracias por tu comentario, no tienes idea de cuánto tiempo he estado tratando de analizar una cadena doble como int y me pregunto por qué estaba fallando ...
Novastorm

Respuestas:


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

Actualización a partir de C # 7:

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

o si no necesita el número, puede descartar el parámetro de salida

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

¡Las var s pueden ser reemplazadas por sus respectivos tipos!


126
Sin embargo, usaría double. TryParse, ya que queremos saber si representa un número en absoluto.
John Gietzen

55
La función devolverá verdadero si paso cadena como "-123" o "+123". Entiendo que el entero tiene valores positivos y negativos. Pero si esta cadena proviene del cuadro de texto ingresado por el usuario, entonces debería devolver falso.
user2323308

99
Esta es una buena solución, hasta que un usuario ingrese un valor más allá de -2,147,483,648 a 2,147,483,647, y luego esto silenciosamente falla
BlackTigerX

intente analizar 0,60 (¡eso es una coma!) ¡Es un número no válido pero se analizará como 60!
Paul Zahra

2
Prefiero tener un método de extensión para esta verificación: public static bool IsNumeric(this string text) { double _out; return double.TryParse(text, out _out); }
Hamid Naeemi

350

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

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

Si solo desea saber si tiene uno o más números mezclados con caracteres, omita el ^ +y $.

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

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


2
Sin embargo, construir la expresión regular de una vez por todas sería mucho más eficiente.
Clément

2
@CFP +1 ... RegEx siempre son mejores que las funciones habituales, cuando corresponde.
MAXE

19
@MAXE: No estaría de acuerdo. Las comprobaciones de expresiones regulares son bastante lentas, por lo que a menudo hay mejores soluciones si se considera el rendimiento.
Michal B.

77
editar: puede agregar RegexOptions.Compiledcomo parámetro si está ejecutando miles de estos para un posible aumento de velocidadRegex.IsMatch(x.BinNumber, @"^\d+$", RegexOptions.Compiled)
Simon_Weaver

99
también fallará en negativos y cosas con.
Noctis

199

También puedes usar:

stringTest.All(char.IsDigit);

Volverá truepara todos los dígitos numéricos (no float) y falsesi la cadena de entrada es algún tipo de alfanumérico.

Tenga en cuenta : stringTestno debe ser una cadena vacía, ya que esto pasaría la prueba de ser numérico.


20
Eso es genial. Sin embargo, una cosa a tener en cuenta: una cadena vacía pasará esa prueba como numérica.
dan-gph

2
@ dan-gph: Me alegro, te gusta. Sí, estás en lo correcto. He actualizado la nota anterior. ¡Gracias!
Kunal Goel

1
Esto tampoco funciona para los casos decimales. La prueba correcta será stringTest.All (l => char.IsDigit (l) || '.' == l || '-' == l);
Salman Hasrat Khan

Gracias por su aporte Salman, para verificar específicamente el decimal de una cadena, puede ir a - if (Decimal. TryParse (stringTest2, out value)) {/ * Yes, Decimal /} else {/ No, Not a Decimal * / }
Kunal Goel

66
Salman, no es tan simple, esto pasaría ..--..--como un número válido. Claramente no.
Flynn1179

133

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 Options

texto alternativo
(fuente: aspalliance.com )

texto alternativo
(fuente: aspalliance.com )


80
haciendo referencia a Microsoft.VisualBasic.dll desde la aplicación C #? eww: P
Lucas

No tengo ningún problema para usar "IsNumeric", funciona bien. También puede ver que hay poca diferencia de eficiencia entre TryParse e IsNumeric. Recuerde que TryParse es nuevo en 2.0 y antes era mejor usar IsNumeric que cualquier otra estrategia.
Nelson Miranda

10
Bueno, IsNumeric () de VB.NET usa internamente double. TryParse (), después de una serie de giros necesarios (entre otras cosas) para la compatibilidad con VB6. Si no necesita compatibilidad, double. TryParse () es igual de fácil de usar y le ahorra el desperdicio de memoria al cargar Microsoft.VisualBasic.dll en su proceso.
Euro Micelli

44
Nota rápida: el uso de una expresión regular será mucho más rápido si logra tener la máquina de estado finito subyacente construida de una vez por todas. Generalmente, la construcción de la máquina de estados toma O (2 ^ n) donde n es la longitud de la expresión regular, mientras que la lectura es O (k) donde k es la longitud de la cadena que se busca. Así que reconstruir la expresión regular cada vez introduce un sesgo.
Clément

2
@Lucas En realidad, hay algunas cosas realmente buenas allí, como un analizador de csv completo. No hay razón para no usarlo si existe allí.
Nyerguds

32

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)alternativa que se muestra en otras respuestas funcionan, pero es mucho más lenta porque arrojar excepciones es muy costoso. TryParse(...)fue agregado al lenguaje C # en la versión 2, y hasta entonces no tenía elección. Ahora lo haces: por lo tanto, debes evitarParse() alternativa.

Si desea 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.


¿Por qué es TryParse mejor que comparar todos los caracteres con caracteres enteros?
jimjim

25

Siempre puede usar los métodos integrados 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 entonces = verdadero

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

El resultado sería entonces = falso


Creo que podría haberlo hecho más en la sintaxis de estilo VB que en C #, pero se aplican las mismas reglas.
TheTXI

22

En caso de que no quiera usar int.Parse o double.Parse, puede 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;
    }
}

77
¿Y si se referían solo a enteros? ¿Qué pasa con los locales donde '.' ¿Es el separador de grupo, no la coma (por ejemplo, pt-Br)? ¿Qué pasa con los números negativos? separadores de grupo (comas en inglés)? símbolos de moneda? TryParse () puede administrar todo esto según sea necesario usando NumberStyles e IFormatProvider.
Lucas

Ooh sí, me gusta más la versión All. Nunca he usado ese método de extensión, buena decisión. Aunque debería ser s.ToCharArray (). Todos (..). En cuanto a tu segundo punto, te escucho, por eso prefiero si no quieres usar int.Parse ... (que supongo que tiene más gastos generales ...)
BFree

11
Sin embargo, 1.3.3.8.5 no es realmente un número, mientras que 1.23E5 sí lo es.
Clément

44
La lógica es defectuosa. -1
Russel Yang

1
@Lucas Estoy de acuerdo en que TryParse maneja más, pero a veces eso no es necesario. Solo necesito validar mis casillas de número de tarjeta de crédito (que solo pueden tener dígitos). Esta solución es casi definitivamente más rápida que intentar analizar.
Millie Smith

14

Si desea capturar un espectro más amplio de números, al igual que is_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 (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 perfecto, pero no cabe en un tipo numérico .NET (no está definido en la biblioteca estándar, es decir).


No estoy tratando de ser un alec inteligente aquí, pero esto parece fallar para la cadena "0". Mi Regex es inexistente. ¿Hay un simple ajuste para eso? Obtengo "0" y posiblemente "0.0" e incluso "-0.0" como posibles números válidos.
Steve Hibbert

@SteveHibbert - ¡Todos saben que "0" no es un número! En serio, aunque ...
ajusté

Hmmm, ¿soy yo o "0" todavía no se reconoce como numérico?
Steve Hibbert

1
Siendo perezoso e ignorante de expresiones regulares, corté y pegué el código anterior, que parece que incluye el cambio de tipo "0.0". Ejecuté una prueba para verificar que se ejecuta una cadena "0" .IsNumeric (), y que devuelve falso. Estoy pensando que la prueba Octal devolverá verdadero para cualquier cosa que tenga dos caracteres numéricos donde el primero es cero (y el segundo es cero a siete), pero devolverá falso solo para un gran cero solitario solo. Si prueba "0", con el código anterior, ¿obtiene falso? Disculpas, si supiera más expresiones regulares sería capaz de dar mejores comentarios. Debe leer
Steve Hibbert

1
! Doh! Simplemente vuelva a leer su comentario anterior, me había perdido el asterisco adicional, solo actualicé la línea decimal. Con eso en su lugar, tiene razón, "0" es numérico. Disculpas por las fallas, y muchas gracias por la actualización, espero que también ayude a otros. Muy agradecido.
Steve Hibbert

14

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 devuelve falso 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, si desea probar otros tipos de números, puede especificar el 'estilo'. Entonces, para convertir un número con un exponente, podría usar:

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

O para probar una posible cadena hexadecimal, puede 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 por no poder convertir cadenas que son demasiado grandes para contener un doble, pero eso es un requisito limitado y creo que si está trabajando con números más grandes que esto, probablemente necesitará un manejo de números especializado adicional funciona de todos modos.


2
Funciona muy bien, excepto que Double. TryParse no admite NumberStyles.HexNumber. Ver MSDN Double. TryParse. ¿Alguna razón por la que prueba TryParse antes de verificar IsNullOrWhiteSpace? TryParse devuelve falso si IsNullOrWhiteSpace no lo hace?
Harald Coppoolse

10

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.


9

Si desea verificar si una cadena es un número (supongo que es una cadena ya que si es un número, duh, ya sabe 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 las molestias habituales:

  • Menos (-) o Más (+) al principio
  • contiene caracteres decimalesBigIntegers no analizará números con puntos decimales. (Entonces: BigInteger.Parse("3.3")arrojará una excepción, y TryParsepor lo mismo devolverá falso)
  • no divertidos sin dígitos
  • cubre casos donde el número es mayor que el uso habitual de Double.TryParse

Tendrás que agregar una referencia System.Numericsy tener la using System.Numerics;cima de tu clase (bueno, el segundo es un bono, supongo :)


8

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 stringera numericasí para poder usar en double.Parse("123")lugar del TryParse()método.

¿Por qué? Porque es molesto tener que declarar una outvariable y verificar el resultado TryParse()antes de saber si el análisis falló o no. Quiero usar el ternary operatorpara verificar si stringes numericaly luego simplemente analizarlo 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 extension methodspara 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 simplemente verificar si la cadena es "numérica", debería ser bastante segura. E incluso puede usarlo para tipos no numéricos que tienen un TryParse()método, comoDateTime .

El método usa la reflexión y terminas llamando al TryParse()método 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 utilizar para analizar fácilmente una lista de cadenas numéricas en una lista de doublealgú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 un stringcomo cualquiera typeque tenga unTryParse() método 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 realiza la conversión una vez. Sin embargo, todavía usa la 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

44
Creo que puede haber inventado uno de los enfoques más ineficientes que he visto hasta ahora. No solo está analizando la cadena dos veces (en el caso de que sea analizable), también está llamando a las funciones de reflexión varias veces para hacerlo. Y, al final, ni siquiera guarda las pulsaciones de teclas utilizando el método de extensión.
JDB todavía recuerda a Mónica

Gracias por repetir lo que escribí en el penúltimo párrafo. Además, si tiene en cuenta mi último ejemplo, definitivamente guardará las pulsaciones de teclas utilizando este método de extensión. Esta respuesta no pretende ser algún tipo de solución mágica a ningún problema, es simplemente un ejemplo de código. Úselo o no lo use. Creo que es conveniente cuando se usa correctamente. E incluye ejemplos de métodos de extensión y reflexión, tal vez alguien pueda aprender de él.
Hein Andre Grønnestad

55
¿Lo has intentado var x = double.TryParse("2.2", new double()) ? double.Parse("2.2") : 0.0;?
JDB todavía recuerda a Mónica el

2
Sí, y no funciona. Argument 2 must be passed with the 'out' keywordy si especificas outtan bien como newobtienes A ref or out argument must be an assignable variable.
Hein Andre Grønnestad

1
Rendimiento TryParse es mejor que todo lo expuesto aquí. Resultados: TryParse 8 Regex 20 PHP IsNumeric 30 Reflexiones TryParse 31 Código de prueba dotnetfiddle.net/x8GjAF
prampe

7

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 TryParsedevuelve un bool, que puede usar para verificar si su análisis se realizó correctamente.



4

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, por lo que puede:

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

4

La mejor solución flexible con la función incorporada .net llamada- char.IsDigit. Funciona con números largos ilimitados. Solo devolverá verdadero si cada carácter es un número numérico. Lo usé muchas veces sin problemas y con una solución mucho más limpia que encontré. Hice un método de ejemplo. Está listo para usar. Además, agregué validación para entradas nulas y vacías. Entonces el método ahora es totalmente a prueba de balas

public static bool IsNumeric(string strNumber)
    {
        if (string.IsNullOrEmpty(strNumber))
        {
            return false;
        }
        else
        {
            int numberOfChar = strNumber.Count();
            if (numberOfChar > 0)
            {
                bool r = strNumber.All(char.IsDigit);
                return r;
            }
            else
            {
                return false;
            }
        }
    }

2

Con c # 7 puedes alinear la variable out:

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

2

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

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

1

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
}

0

Agregue una referencia a Visual Basic en su proyecto y use su método Information.IsNumeric, como se muestra a continuación, y pueda capturar flotantes y enteros, a diferencia de la respuesta anterior, que solo captura entradas.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Un problema potencial con este enfoque es que IsNumerichace un análisis de caracteres de la cadena. Por lo tanto, un número como 9999999999999999999999999999999999999999999999999999999999.99999999999se registrará como True, a pesar de que no hay forma de representar este número utilizando un tipo numérico estándar.
JDB todavía recuerda a Mónica

0

Prueba los reges a continuación

new Regex(@"^\d{4}").IsMatch("6")    // false
new Regex(@"^\d{4}").IsMatch("68ab") // false
new Regex(@"^\d{4}").IsMatch("1111abcdefg") ```

0

Todas las respuestas son útiles. Pero mientras buscaba una solución donde el valor numérico es de 12 dígitos o más (en mi caso), luego, mientras depuraba, encontré la siguiente solución útil:

double tempInt = 0;
bool result = double.TryParse("Your_12_Digit_Or_more_StringValue", out tempInt);

La variable de resultado le dará verdadero o falso.



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

1
Cuatro votos negativos, pero nadie ha dicho por qué. Supongo que es porque TryParse / Parse sería una mejor opción, pero no todos los que vengan aquí lo sabrán.
njplumridge

2
Lo hiciste tan complicado que incluso el programador de C diría "Dios, tiene que haber una manera más fácil de escribir eso"
Ch3shire

1. No hay razón para leer DOS números desde la consola y agregarlos. De todos modos, el origen de la cadena es irrelevante, por lo que no hay razón para leer nada de la consola.
Algoman

2. La variable para f es innecesaria, puede devolver 0 o 1 directamente; si desea un solo retorno, puede usar el operador ternario para eso. int también es el tipo de retorno incorrecto para find, debería ser bool y podría devolver s == s1
Algoman

3. copia los dígitos de s en s1 y luego compara s con s1. Esto es mucho más lento de lo necesario. Además, ¿por qué continúa el ciclo interno incluso si c [0] == s [i] ha sucedido? ¿Espera que s [i] también sea igual a otros dígitos?
Algoman
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.