Identifikasi apakah string adalah angka

Jika saya memiliki string ini:

1. "abc" = false

2. "123" = true

3. "ab2" = false

Apakah ada perintah, seperti IsNumeric()atau sesuatu yang lain, yang dapat mengidentifikasi apakah string adalah angka yang valid?

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

Perbarui pada C # 7:

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

atau jika Anda tidak membutuhkan nomor tersebut, Anda dapat membuang parameter keluar

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

The var s dapat diganti dengan jenis masing-masing!

Ini akan mengembalikan true jika inputsemua nomor. Tidak tahu apakah ini lebih baik daripada TryParse, tetapi itu akan berhasil.

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

Jika Anda hanya ingin tahu apakah ada satu atau lebih angka yang dicampur dengan karakter, tinggalkan ^ +dan $.

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

Sunting: Sebenarnya saya pikir ini lebih baik daripada TryParse karena string yang sangat panjang berpotensi meluap TryParse.

Anda juga bisa menggunakan:

stringTest.All(char.IsDigit);

Ini akan kembali trueuntuk semua Digit Angka (tidak float) dan falsejika string input adalah jenis alfanumerik.

Harap dicatat : stringTesttidak boleh berupa string kosong karena ini akan lulus uji menjadi numerik.

Saya telah menggunakan fungsi ini beberapa kali:

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

Tetapi Anda juga bisa menggunakan;

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

Dari Benchmarking Opsi IsNumeric

_{(sumber: aspalliance.com )}

_{(sumber: aspalliance.com )}

Ini mungkin opsi terbaik di C #.

Jika Anda ingin tahu apakah string berisi bilangan bulat (integer):

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

Metode TryParse akan mencoba untuk mengubah string ke angka (integer) dan jika berhasil akan mengembalikan nilai true dan menempatkan nomor yang sesuai di myInt. Jika tidak bisa, ia mengembalikan false.

Solusi menggunakan int.Parse(someString)alternatif yang ditunjukkan dalam respons lain berfungsi, tetapi jauh lebih lambat karena melempar pengecualian sangat mahal. TryParse(...)telah ditambahkan ke bahasa C # di versi 2, dan sampai saat itu Anda tidak punya pilihan. Sekarang Anda lakukan: karena itu Anda harus menghindari Parse()alternatif.

Jika Anda ingin menerima angka desimal, kelas desimal juga memiliki .TryParse(...)metode. Ganti int dengan desimal dalam diskusi di atas, dan prinsip yang sama berlaku.

Anda selalu dapat menggunakan metode TryParse bawaan untuk banyak tipe data untuk melihat apakah string yang dimaksud akan lulus.

Contoh.

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

Hasilnya kemudian = Benar

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

Hasilnya kemudian = Salah

Jika Anda tidak ingin menggunakan int.Parse atau double.Parse, Anda bisa menggulung sendiri dengan sesuatu seperti ini:

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

Jika Anda ingin menangkap spektrum angka yang lebih luas, à la PHP is_numeric , Anda dapat menggunakan yang berikut ini:

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

Tes Unit:

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

Perlu diingat bahwa hanya karena nilai numerik tidak berarti itu dapat dikonversi ke tipe numerik. Sebagai contoh, "999999999999999999999999999999.9999999999"adalah nilai numerik yang valid perfeclty, tetapi itu tidak akan cocok dengan tipe .NET numerik (bukan yang didefinisikan dalam perpustakaan standar, yaitu).

Saya tahu ini adalah utas lama, tetapi tidak ada jawaban yang benar-benar melakukannya untuk saya - baik tidak efisien, atau tidak dienkapsulasi agar mudah digunakan kembali. Saya juga ingin memastikan itu kembali salah jika string kosong atau nol. TryParse mengembalikan true dalam kasus ini (string kosong tidak menyebabkan kesalahan saat parsing sebagai angka). Jadi, inilah metode ekstensi string saya:

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

Mudah digunakan:

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

Atau, jika Anda ingin menguji jenis angka lainnya, Anda dapat menentukan 'gaya'. Jadi, untuk mengonversi angka dengan Eksponen, Anda dapat menggunakan:

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

Atau untuk menguji string Hex potensial, Anda dapat menggunakan:

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

Parameter 'kultur' opsional dapat digunakan dengan cara yang sama.

Ini dibatasi dengan tidak dapat mengkonversi string yang terlalu besar untuk dikandung dalam double, tetapi itu adalah persyaratan yang terbatas dan saya pikir jika Anda bekerja dengan angka yang lebih besar dari ini, maka Anda mungkin akan memerlukan penanganan nomor khusus tambahan tetap berfungsi.

Anda bisa menggunakan TryParse untuk menentukan apakah string dapat diurai menjadi integer.

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

Boolean akan memberi tahu Anda apakah itu berfungsi atau tidak.

Jika Anda ingin memeriksa apakah sebuah string adalah angka (saya berasumsi itu adalah string karena jika itu angka, ya, Anda tahu itu satu).

• Tanpa regex dan
• menggunakan kode Microsoft sebanyak mungkin

Anda juga bisa melakukan:

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

Ini akan menangani nasties yang biasa:

• Minus (-) atau Plus (+) di awal
• mengandung karakter desimalBigIntegers tidak akan mem-parsing angka dengan titik desimal. (Jadi: BigInteger.Parse("3.3")akan melempar pengecualian, danTryParse untuk hal yang sama akan mengembalikan false)
• tidak ada angka yang lucu
• mencakup kasus - kasus di mana angkanya lebih besar dari penggunaan biasa Double.TryParse

Anda harus menambahkan referensi System.Numericsdan memiliki using System.Numerics;di atas kelas Anda (well, yang kedua adalah bonus kurasa :)

Saya kira jawaban ini hanya akan hilang di antara semua yang lain, tapi bagaimanapun, begini saja.

Saya akhirnya pada pertanyaan ini melalui Google karena saya ingin memeriksa apakah stringitu numericsehingga saya bisa menggunakan double.Parse("123")bukanTryParse() metode.

Mengapa? Karena itu menjengkelkan harus mendeklarasikan outvariabel dan memeriksa hasil TryParse()sebelum Anda tahu apakah parse gagal atau tidak. Saya ingin menggunakan ternary operatoruntuk memeriksa apakah stringitunumerical dan kemudian hanya menguraikannya dalam ekspresi ternary pertama atau memberikan nilai default dalam ekspresi ternary kedua.

Seperti ini:

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

Ini jauh lebih bersih daripada:

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

Saya membuat pasangan extension methodsuntuk kasus-kasus ini:

Metode penyuluhan satu

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

Contoh:

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

Karena IsParseableAs()mencoba mem-parsing string sebagai tipe yang tepat alih-alih hanya memeriksa apakah string "numerik" itu harus cukup aman. Dan Anda bahkan dapat menggunakannya untuk tipe non numerik yang memiliki TryParse()metode, sepertiDateTime .

Metode ini menggunakan refleksi dan Anda akhirnya memanggil TryParse()metode dua kali yang, tentu saja, tidak seefisien itu, tetapi tidak semuanya harus dioptimalkan sepenuhnya, terkadang kenyamanan hanya lebih penting.

Metode ini juga dapat digunakan untuk dengan mudah mem-parsing daftar string numerik ke daftar doubleatau tipe lain dengan nilai default tanpa harus menangkap pengecualian:

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

Metode penyuluhan dua

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

Metode ekstensi ini memungkinkan Anda mem-parsing stringsemua typeyang memilikiTryParse() metode dan juga memungkinkan Anda menentukan nilai default untuk kembali jika konversi gagal.

Ini lebih baik daripada menggunakan operator ternary dengan metode ekstensi di atas karena hanya melakukan konversi satu kali. Masih menggunakan refleksi ...

Contoh:

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

Output:

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

Jika Anda ingin tahu apakah sebuah string adalah angka, Anda selalu dapat mencoba menguraikannya:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Perhatikan bahwa TryParsemengembalikan a bool, yang dapat Anda gunakan untuk memeriksa apakah parsing Anda berhasil.

Double.TryParse

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

PEMBARUAN Kunal Noel Answer

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

Tetapi, untuk kasus ini kami memiliki string kosong akan lulus tes itu, jadi, Anda dapat:

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

Solusi fleksibel terbaik dengan fungsi .net built-in disebut- char.IsDigit. Ia bekerja dengan angka panjang tak terbatas. Ini hanya akan mengembalikan true jika setiap karakter adalah angka numerik. Saya sering menggunakannya tanpa masalah dan solusi yang jauh lebih mudah bersih yang pernah saya temukan. Saya membuat contoh metode. Siap digunakan. Selain itu saya menambahkan validasi untuk input nol dan kosong. Jadi metode ini sekarang benar-benar anti peluru

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

Dengan c # 7 itu Anda dapat menguraikan variabel keluar:

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

Gunakan metode ekstensi ini untuk membedakan dengan jelas antara tanda centang apakah string tersebut numerik dan jika string hanya berisi 0-9 digit

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

Semoga ini membantu

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

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

Tarik referensi ke Visual Basic di proyek Anda dan gunakan informasinya. Metode numerik seperti yang ditunjukkan di bawah ini dan dapat menangkap pelampung serta bilangan bulat tidak seperti jawaban di atas yang hanya menangkap int.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Coba rege di bawah ini

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

Semua Jawabannya Berguna. Tetapi ketika mencari solusi di mana nilai Numeric adalah 12 digit atau lebih (dalam kasus saya), kemudian saat debugging, saya menemukan solusi berikut berguna:

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

Variabel hasil th akan memberi Anda benar atau salah.

Berikut adalah metode C #. Metode 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;
}