문자열이 숫자인지 식별

이 문자열이 있으면 :

1. "abc" = false

2. "123" = true

3. "ab2" = false

IsNumeric()문자열이 유효한 숫자인지 식별 ​​할 수 있는 명령 이 있습니까?

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

C # 7부터 업데이트 :

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

또는 숫자가 필요하지 않으면 out 매개 변수를 버릴 수 있습니다

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

var에 들 각각의 유형에 의해 대체 될 수 있습니다!

input모든 숫자 이면 true를 반환합니다 . 보다 나은지 TryParse모르지만 작동합니다.

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

하나 이상의 숫자가 문자와 혼합되어 있는지 알고 싶다면 ^ +및을 그대로 두십시오 $.

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

편집 : 실제로 매우 긴 문자열이 잠재적으로 TryParse를 오버플로 할 수 있기 때문에 TryParse보다 낫다고 생각합니다.

다음을 사용할 수도 있습니다.

stringTest.All(char.IsDigit);

그것은 반환 true모든 자리 숫자 (하지 않는 float) 및 false입력 문자열은 숫자의 어떤 종류 인 경우.

참고 : stringTest숫자 테스트를 통과하므로 빈 문자열이 아니어야합니다.

이 기능을 여러 번 사용했습니다.

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

그러나 당신은 또한 사용할 수 있습니다;

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

에서 벤치마킹 ISNUMERIC 옵션

_{(출처 : aspalliance.com )}

_{(출처 : aspalliance.com )}

아마도 C #에서 가장 좋은 옵션 일 것입니다.

문자열에 정수 (정수)가 포함되어 있는지 알고 싶은 경우 :

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

TryParse 메소드는 문자열을 숫자 (정수)로 변환하려고 시도하며 성공하면 true를 리턴하고 해당 숫자를 myInt에 배치합니다. 그렇지 않으면 false를 반환합니다.

int.Parse(someString)다른 응답에 표시된 대안을 사용하는 솔루션 은 효과가 있지만 예외를 던지면 비용이 많이 들기 때문에 훨씬 느립니다. TryParse(...)버전 2의 C # 언어에 추가되었으며 그때까지는 선택의 여지가 없었습니다. 이제 당신은 : Parse()대안을 피해야합니다 .

소수를 허용하려면 소수 클래스에도 .TryParse(...)메소드가 있습니다. 위의 설명에서 int를 10 진수로 바꾸면 동일한 원칙이 적용됩니다.

많은 데이터 유형에 대해 항상 내장 된 TryParse 메소드를 사용하여 해당 문자열이 전달되는지 확인할 수 있습니다.

예.

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

결과는 다음과 같습니다 = True

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

결과는 다음과 같습니다 = False

int.Parse 또는 double.Parse를 사용하지 않으려는 경우 다음과 같이 자신의 롤을 만들 수 있습니다.

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

더 넓은 범위의 숫자, 즉 PHP의 is_numeric 을 잡으려면 다음을 사용할 수 있습니다.

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

단위 테스트 :

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

값이 숫자라고해서 값이 숫자 유형으로 변환 될 수있는 것은 아닙니다. 예를 들어, "999999999999999999999999999999.9999999999"완전한 유효한 숫자 값이지만 .NET 숫자 유형 (표준 라이브러리에 정의 된 값이 아님)에는 맞지 않습니다.

나는 이것이 오래된 스레드라는 것을 알고 있지만 비효율적이거나 쉽게 재사용 할 수 있도록 캡슐화되지 않은 대답은 실제로 나에게 도움이되지 못했습니다. 또한 문자열이 비어 있거나 null 인 경우 false를 반환했는지 확인하고 싶었습니다. 이 경우 TryParse는 true를 반환합니다 (빈 문자열은 숫자로 구문 분석 할 때 오류가 발생하지 않습니다). 자, 여기 내 문자열 확장 방법이 있습니다 :

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

사용하기 쉬운 :

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

또는 다른 유형의 숫자를 테스트하려는 경우 '스타일'을 지정할 수 있습니다. 따라서 지수로 숫자를 변환하려면 다음을 사용할 수 있습니다.

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

또는 잠재적 16 진수 문자열을 테스트하려면 다음을 사용할 수 있습니다.

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

선택적 'culture'매개 변수는 거의 같은 방식으로 사용할 수 있습니다.

더블에 포함하기에는 너무 큰 문자열을 변환 할 수 없기 때문에 제한적이지만 요구 사항이 제한되어 있으며 이보다 큰 숫자로 작업하는 경우 추가 특수 숫자 처리가 필요할 것입니다 어쨌든 기능.

TryParse를 사용하여 문자열을 정수로 구문 분석 할 수 있는지 판별 할 수 있습니다.

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

부울이 작동하는지 여부를 알려줍니다.

문자열이 숫자인지 확인하려면 (문자열이 숫자라고 가정하므로 문자열이라고 가정합니다.

• 정규 표현식없이
• Microsoft 코드를 가능한 많이 사용

당신은 또한 할 수 있습니다 :

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

이것은 일반적인 nasties를 돌볼 것입니다 :

• 처음에 마이너스 (-) 또는 플러스 (+)
• 십진 문자를 포함BigInteger는 소수점으로 숫자를 구문 분석하지 않습니다. (그래서 : BigInteger.Parse("3.3")예외를 던질 것이고 TryParse, 같은 경우 거짓을 반환 할 것입니다)
• 숫자가 아닌 재미있는 숫자가 없습니다.
• 숫자가 일반적인 용도보다 큰 경우를 포함합니다. Double.TryParse

클래스에 대한 참조를 추가하고 클래스 위에 System.Numerics있어야 using System.Numerics;합니다 (두 번째는 보너스라고 생각합니다 :)

나는이 대답이 다른 모든 것 사이에서 잃어 버릴 것이라고 생각하지만 어쨌든 여기에 간다.

나는이 있는지 확인하고 싶었 기 때문에 나는 구글을 통해이 질문에 결국 string있었다 numeric난 그냥 사용할 수 있도록 double.Parse("123")의 대신 TryParse()하는 방법.

왜? out변수 를 선언 TryParse()하고 구문 분석이 실패했는지 여부를 알기 전에 결과를 확인 해야하는 것이 성가시다 . 를 사용하여 is ternary operator인지 확인한 다음 첫 번째 삼항 식에서 구문 분석하거나 두 번째 삼항 식에서 기본값을 제공하고 싶습니다 .stringnumerical

이처럼 :

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

다음보다 훨씬 깨끗합니다.

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

나는 extension methods이 경우를 위해 몇 가지 를 만들었습니다 .

확장 방법 1

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

예:

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

IsParseableAs()문자열이 "숫자"인지 확인하는 대신 문자열을 적절한 유형으로 구문 분석하려고하기 때문에 꽤 안전해야합니다. 그리고 TryParse()방법 이있는 숫자가 아닌 유형에도 사용할 수 있습니다.DateTime .

이 방법은 리플렉션을 사용하고 결과적 TryParse()으로 효율적이지 않지만 모든 것을 완전히 최적화해야 할 필요는 없지만 때로는 편의성이 더 중요한 방법을 두 번 호출합니다 .

이 방법을 사용 double하면 예외를 잡을 필요없이 숫자 문자열 목록을 기본값 또는 다른 유형 의 목록으로 쉽게 구문 분석 할 수 있습니다 .

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

확장 방법 2

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

이 확장 방법은 당신이 구문을 분석 할 수 string있는대로 typeA가 들어 그TryParse() 방법을 그리고 그것은 또한 당신이 변환이 실패 할 경우 반환 할 기본값을 지정할 수 있습니다.

이것은 변환 방법을 한 번만 수행하므로 위의 확장 방법으로 삼항 연산자를 사용하는 것보다 낫습니다. 그래도 여전히 반사를 사용합니다 ...

예 :

"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);

출력 :

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

문자열이 숫자인지 알고 싶다면 항상 구문 분석을 시도 할 수 있습니다.

var numberString = "123";
int number;

int.TryParse(numberString , out number);

참고 TryParse리턴한다 bool파싱가 성공했을 경우 사용할 수있는, 확인.

Double.TryParse

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

Kunal Noel 답변 업데이트

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

그러나이 경우 빈 문자열이 해당 테스트를 통과하므로 다음을 수행 할 수 있습니다.

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

.net 내장 기능을 갖춘 최고의 유연한 솔루션- char.IsDigit. 무제한 긴 숫자로 작동합니다. 각 문자가 숫자 인 경우에만 true를 리턴합니다. 나는 문제없이 많은 시간을 사용했고 내가 찾은 훨씬 더 깨끗한 솔루션을 찾았습니다. 예제 방법을 만들었습니다. 사용할 준비가되었습니다. 또한 null 및 빈 입력에 대한 유효성 검사를 추가했습니다. 그래서이 방법은 이제 완전히 방탄입니다

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

c # 7을 사용하면 out 변수를 인라인 할 수 있습니다.

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

문자열이 숫자 인지, 문자열 에 0-9 자리 만 포함되어 있는지 확인하려면 이러한 확장 방법을 사용하십시오.

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

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

도움이 되었기를 바랍니다

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

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

프로젝트에서 Visual Basic에 대한 참조를 가져 와서 아래에 표시된 것과 같은 Information.IsNumeric 메서드를 사용하고 위의 정수만 잡는 위의 답변과 달리 부동 소수점뿐만 아니라 정수를 캡처 할 수 있습니다.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

아래의 리지를 사용해보십시오

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

모든 답변이 유용합니다. 그러나 Numeric 값이 12 자리 이상인 솔루션을 검색하는 동안 (필자의 경우) 디버깅하는 동안 다음 솔루션이 유용하다는 것을 알았습니다.

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

이 결과 변수는 true 또는 false를 제공합니다.

다음은 C # 방법입니다. Int.TryParse 메서드 (String, Int32)

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