Xác định nếu một chuỗi là một số

Nếu tôi có những chuỗi này:

1. "abc" = = false

2. "123" = = true

3. "ab2" = = false

Có một lệnh, như IsNumeric()hoặc một cái gì khác, có thể xác định nếu một chuỗi là một số hợp lệ?

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

Cập nhật kể từ C # 7:

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

hoặc nếu bạn không cần số bạn có thể loại bỏ tham số ra

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

Các var s có thể được thay thế bởi các loại tương ứng của họ!

Điều này sẽ trả về true nếu inputlà tất cả các số. Không biết nó có tốt hơn không TryParse, nhưng nó sẽ hoạt động.

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

Nếu bạn chỉ muốn biết nếu nó có một hoặc nhiều số được trộn lẫn với các ký tự, hãy bỏ qua ^ +và $.

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

Chỉnh sửa: Trên thực tế tôi nghĩ rằng nó tốt hơn so với TryPude vì một chuỗi rất dài có thể có khả năng tràn qua TryPude.

Bạn cũng có thể dùng:

stringTest.All(char.IsDigit);

Nó sẽ trả về truecho tất cả các chữ số (không float) và falsenếu chuỗi đầu vào là bất kỳ loại chữ và số nào.

Xin lưu ý : stringTestkhông nên là một chuỗi trống vì điều này sẽ vượt qua bài kiểm tra là số.

Tôi đã sử dụng chức năng này nhiều lần:

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

Nhưng bạn cũng có thể sử dụng;

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

Từ tùy chọn điểm chuẩn IsNumeric

_{(nguồn: aspalliance.com )}

_{(nguồn: aspalliance.com )}

Đây có lẽ là lựa chọn tốt nhất trong C #.

Nếu bạn muốn biết nếu chuỗi chứa toàn bộ số (số nguyên):

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

Phương thức TryPude sẽ cố gắng chuyển đổi chuỗi thành một số (số nguyên) và nếu thành công, nó sẽ trả về true và đặt số tương ứng trong myInt. Nếu không thể, nó trả về false.

Các giải pháp sử dụng int.Parse(someString)thay thế được hiển thị trong các phản hồi khác hoạt động, nhưng nó chậm hơn nhiều vì ném ngoại lệ rất tốn kém. TryParse(...)đã được thêm vào ngôn ngữ C # trong phiên bản 2 và cho đến lúc đó bạn không có lựa chọn nào khác. Bây giờ bạn làm: do đó bạn nên tránh sự Parse()thay thế.

Nếu bạn muốn chấp nhận số thập phân, lớp thập phân cũng có một .TryParse(...)phương thức. Thay int bằng số thập phân trong phần thảo luận ở trên và áp dụng các nguyên tắc tương tự.

Bạn luôn có thể sử dụng các phương thức TryPude tích hợp cho nhiều kiểu dữ liệu để xem chuỗi trong câu hỏi có vượt qua không.

Thí dụ.

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

Kết quả sau đó = True

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

Kết quả sau đó = Sai

Trong trường hợp bạn không muốn sử dụng int.Pude hoặc double.Pude, bạn có thể tự cuộn bằng thứ gì đó như thế này:

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

Nếu bạn muốn bắt một dải số rộng hơn, hãy gọi là is_numeric của PHP , bạn có thể sử dụng như sau:

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

Bài kiểm tra đơn vị:

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

Hãy nhớ rằng chỉ vì một giá trị là số không có nghĩa là nó có thể được chuyển đổi thành loại số. Ví dụ: "999999999999999999999999999999.9999999999"là một giá trị số hợp lệ hoàn hảo, nhưng nó sẽ không phù hợp với loại số .NET (không phải là một giá trị được xác định trong thư viện chuẩn).

Tôi biết đây là một chủ đề cũ, nhưng không có câu trả lời nào thực sự làm điều đó cho tôi - hoặc không hiệu quả, hoặc không được gói gọn để dễ sử dụng lại. Tôi cũng muốn đảm bảo nó trả về false nếu chuỗi rỗng hoặc null. TryPude trả về true trong trường hợp này (một chuỗi rỗng không gây ra lỗi khi phân tích cú pháp dưới dạng số). Vì vậy, đây là phương pháp mở rộng chuỗi của tôi:

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

Đơn giản để sử dụng:

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

Hoặc, nếu bạn muốn kiểm tra các loại số khác, bạn có thể chỉ định 'kiểu'. Vì vậy, để chuyển đổi một số có số mũ, bạn có thể sử dụng:

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

Hoặc để kiểm tra chuỗi Hex tiềm năng, bạn có thể sử dụng:

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

Tham số 'văn hóa' tùy chọn có thể được sử dụng theo nhiều cách giống nhau.

Nó bị hạn chế do không thể chuyển đổi các chuỗi quá lớn để được chứa trong một đôi, nhưng đó là một yêu cầu hạn chế và tôi nghĩ rằng nếu bạn đang làm việc với các số lớn hơn số này, thì có lẽ bạn sẽ cần xử lý số chuyên biệt bổ sung chức năng nào.

Bạn có thể sử dụng TryPude để xác định xem chuỗi có thể được phân tích thành một số nguyên hay không.

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

Boolean sẽ cho bạn biết nếu nó hoạt động hay không.

Nếu bạn muốn kiểm tra xem một chuỗi có phải là một số không (tôi giả sử đó là một chuỗi vì nếu đó là một số, duh, bạn biết đó là một chuỗi).

• Không có regex và
• sử dụng mã của Microsoft càng nhiều càng tốt

bạn cũng có thể làm:

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

Điều này sẽ chăm sóc các món ngon thông thường:

• Trừ (-) hoặc Plus (+) khi bắt đầu
• chứa ký tự thập phânBigIntegers sẽ không phân tích các số có dấu thập phân. (Vì vậy: BigInteger.Parse("3.3")sẽ đưa ra một ngoại lệ và TryParsetương tự sẽ trả về false)
• không có chữ số buồn cười
• bao gồm các trường hợp số lượng lớn hơn sử dụng thông thường của Double.TryParse

Bạn sẽ phải thêm một tài liệu tham khảo System.Numericsvà có using System.Numerics;trên đầu lớp của bạn (tốt, thứ hai là một phần thưởng tôi đoán :)

Tôi đoán câu trả lời này sẽ bị mất ở giữa tất cả những người khác, nhưng dù sao, ở đây đi.

Tôi đã kết thúc câu hỏi này thông qua Google vì tôi muốn kiểm tra xem có phải stringlà numericvì vậy tôi chỉ có thể sử dụng double.Parse("123")thay vì TryParse()phương pháp.

Tại sao? Bởi vì thật khó chịu khi phải khai báo một outbiến và kiểm tra kết quả TryParse()trước khi bạn biết liệu phân tích có thất bại hay không. Tôi muốn sử dụng ternary operatorđể kiểm tra nếu stringlà numericalvà sau đó chỉ phân tích nó trong biểu thức ternary đầu tiên hoặc cung cấp một giá trị mặc định trong biểu thức ternary thứ hai.

Như thế này:

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

Nó chỉ sạch sẽ hơn nhiều so với:

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

Tôi đã làm một vài extension methodscho những trường hợp này:

Phương pháp mở rộng một

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

Thí dụ:

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

Bởi vì IsParseableAs()cố gắng phân tích chuỗi là loại thích hợp thay vì chỉ kiểm tra xem chuỗi có "số" hay không, nên nó khá an toàn. Và bạn thậm chí có thể sử dụng nó cho các loại không có số có một TryParse()phương thức, như DateTime.

Phương thức này sử dụng sự phản chiếu và cuối cùng bạn gọi TryParse()phương thức đó hai lần, tất nhiên, không hiệu quả, nhưng không phải mọi thứ đều phải được tối ưu hóa hoàn toàn, đôi khi sự tiện lợi chỉ quan trọng hơn.

Phương pháp này cũng có thể được sử dụng để dễ dàng phân tích một danh sách các chuỗi số thành một danh sách doublehoặc một số loại khác có giá trị mặc định mà không phải bắt bất kỳ trường hợp ngoại lệ nào:

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

Phương pháp mở rộng hai

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

Phương thức tiện ích mở rộng này cho phép bạn phân tích cú pháp stringnhư bất kỳ phương thức nào typecó TryParse()phương thức và nó cũng cho phép bạn chỉ định giá trị mặc định để trả về nếu chuyển đổi không thành công.

Điều này tốt hơn so với việc sử dụng toán tử ternary với phương thức mở rộng ở trên vì nó chỉ thực hiện chuyển đổi một lần. Nó vẫn sử dụng sự phản chiếu mặc dù ...

Ví dụ:

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

Đầu ra:

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

Nếu bạn muốn biết nếu một chuỗi là một số, bạn luôn có thể thử phân tích cú pháp chuỗi đó:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Lưu ý rằng TryParsetrả về a bool, mà bạn có thể sử dụng để kiểm tra xem phân tích cú pháp của bạn có thành công hay không.

Double.TryPude

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

CẬP NHẬT Kunal Noel Trả lời

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

Nhưng, trong trường hợp này, chúng ta có các chuỗi trống sẽ vượt qua bài kiểm tra đó, vì vậy, bạn có thể:

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

Giải pháp linh hoạt tốt nhất với chức năng tích hợp .net được gọi là- char.IsDigit. Nó hoạt động với số lượng dài không giới hạn. Nó sẽ chỉ trả về true nếu mỗi ký tự là một số. Tôi đã sử dụng nó rất nhiều lần mà không có vấn đề gì và giải pháp dễ dàng sạch hơn tôi từng tìm thấy. Tôi đã thực hiện một phương thức ví dụ. Tôi đã sẵn sàng để sử dụng. Ngoài ra, tôi đã thêm xác nhận cho đầu vào null và trống. Vì vậy, phương pháp bây giờ là hoàn toàn chống đạn

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

Với c # 7, bạn có thể nội tuyến biến ra:

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

Sử dụng các phương thức mở rộng này để phân biệt rõ ràng giữa kiểm tra xem chuỗi có phải là số không và nếu chuỗi chỉ chứa 0-9 chữ số

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

Hi vọng điêu nay co ich

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

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

Kéo tham chiếu đến Visual Basic trong dự án của bạn và sử dụng phương thức Information.IsNumeric của nó như hiển thị bên dưới và có thể chụp các số float cũng như các số nguyên không giống như câu trả lời ở trên chỉ bắt được ints.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Hãy thử các chế độ dưới đây

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

Tất cả các câu trả lời là hữu ích. Nhưng trong khi tìm kiếm một giải pháp trong đó giá trị Số là 12 chữ số trở lên (trong trường hợp của tôi), sau đó trong khi gỡ lỗi, tôi thấy giải pháp sau hữu ích:

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

Biến kết quả sẽ cho bạn đúng hay sai.

Đây là phương pháp C #. Phương thức Int.TryPude (Chuỗi, 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;
}