Identifikasi apakah string adalah angka

731

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?

Emas
sumber
79
dari contoh mereka, Anda dapat melihat maksud mereka jika seluruh string mewakili angka.
Lucas
47
return str.All (Char.IsDigit);
Mohsen
13
str.All (Char.IsDigit) akan menyatakan "3.14" false serta "-2" dan "3E14". Belum lagi: "0x10"
Harald Coppoolse
4
Tergantung pada jenis nomor apa yang ingin Anda periksa. Untuk bilangan bulat tanpa pemisah (yaitu string angka desimal) pemeriksaan ini berfungsi, dan sama dengan jawaban yang diterima dan yang tersirat dalam OP.
Alex Mazzariol
1
@Lucas terima kasih atas komentar Anda, Anda TIDAK tahu berapa lama saya telah mencoba untuk menguraikan string ganda sebagai int dan bertanya-tanya mengapa itu gagal ...
Novastorm

Jawaban:

1160
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!

mqp
sumber
126
Padahal, saya akan menggunakan double.TryParse, karena kami ingin tahu apakah itu mewakili angka sama sekali.
John Gietzen
5
Fungsi akan mengembalikan true jika saya meneruskan string sebagai "-123" atau "+123". Saya Memahami bahwa integer memiliki nilai positif dan negatif. Tetapi jika string ini berasal dari kotak teks yang dimasukkan pengguna maka itu harus mengembalikan false.
user2323308
9
Ini adalah solusi yang baik, sampai pengguna memasukkan nilai di luar -2.147.483.648 hingga 2.147.483.647, dan kemudian ini gagal gagal
BlackTigerX
coba parsing 0,60 (itu adalah koma!) itu adalah angka yang tidak valid tetapi akan diuraikan sebagai 60!
Paul Zahra
2
Saya lebih suka memiliki metode perpanjangan untuk pemeriksaan ini: public static bool IsNumeric(this string text) { double _out; return double.TryParse(text, out _out); }
Hamid Naeemi
350

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.

John M Gant
sumber
2
Membangun regex sekali dan untuk selamanya akan jauh lebih efisien.
Clément
2
@CFP +1 ... RegEx selalu lebih baik daripada fungsi biasa, jika ada!
MAXE
19
@MAXE: Saya tidak akan setuju. Pemeriksaan ekspresi reguler cukup lambat, sehingga seringkali ada solusi yang lebih baik jika kinerja sedang dipertimbangkan.
Michal B.
7
sunting: Anda dapat menambahkan RegexOptions.Compiledsebagai parameter jika Anda menjalankan ribuan ini untuk kemungkinan peningkatan kecepatanRegex.IsMatch(x.BinNumber, @"^\d+$", RegexOptions.Compiled)
Simon_Weaver
9
juga akan gagal pada hal-hal negatif dan hal-hal dengan.
Noctis
199

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.

Kunal Goel
sumber
20
Itu sangat keren. Satu hal yang perlu diperhatikan: string kosong akan lulus tes itu sebagai numerik.
dan-gph
2
@ dan-gph: Saya senang, Anda menyukainya. Ya kamu benar. Saya telah memperbarui catatan di atas. Terima kasih!
Kunal Goel
1
ini juga tidak berfungsi untuk kasus desimal. Tes yang tepat adalah stringTest.All (l => char.IsDigit (l) || '.' == l || '-' == l);
Salman Hasrat Khan
Terima kasih atas masukan Anda Salman, Untuk secara khusus memeriksa desimal dari sebuah string, Anda dapat memilih - if (Decimal.TryParse (stringTest2, nilai out)) {/ * Ya, Desimal /} else {/ Tidak, Bukan desimal * / }
Kunal Goel
6
Salman, itu tidak sesederhana ini akan berlalu ..--..-- sebagai angka yang valid. Jelas tidak.
Flynn1179
133

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

teks alternatif
(sumber: aspalliance.com )

teks alternatif
(sumber: aspalliance.com )

Nelson Miranda
sumber
80
referensi Microsoft.VisualBasic.dll dari aplikasi C #? eww: P
Lucas
Saya tidak punya masalah untuk menggunakan "IsNumeric" itu berfungsi dengan baik. Anda juga dapat melihat bahwa ada sedikit perbedaan efisiensi antara TryParse dan IsNumeric. Ingat bahwa TryParse adalah baru di 2.0 dan sebelum itu lebih baik menggunakan IsNumeric daripada strategi lainnya.
Nelson Miranda
10
Nah, IsNumeric () VB.NET secara internal menggunakan double.TryParse (), setelah sejumlah rotasi yang diperlukan (antara lain) untuk kompatibilitas VB6. Jika Anda tidak memerlukan kompatibilitas, double.TryParse () sama mudahnya untuk digunakan, dan itu menyelamatkan Anda dari pemborosan memori dengan memuat Microsoft.VisualBasic.dll dalam proses Anda.
Euro Micelli
4
Catatan cepat: menggunakan ekspresi reguler akan jauh lebih cepat jika Anda berhasil membuat mesin negara-terbatas yang mendasari dibangun sekali dan untuk semua. Secara umum, membangun mesin negara membutuhkan O (2 ^ n) di mana n adalah panjang regex, sedangkan bacaan adalah O (k) di mana k adalah panjang dari string yang dicari. Jadi membangun kembali regex setiap kali menimbulkan bias.
Clément
2
@Lucas Sebenarnya, ada beberapa hal yang sangat bagus di sana, seperti parser csv penuh. Tidak ada alasan untuk tidak menggunakannya jika ada di sana.
Nyerguds
32

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.

Euro Micelli
sumber
Mengapa TryParse lebih baik daripada membandingkan semua karakter dengan karakter integer?
Jimmim
25

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

TheTXI
sumber
Saya pikir saya mungkin telah melakukan itu lebih dalam sintaks gaya VB daripada C #, tetapi aturan yang sama berlaku.
TheTXI
22

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;
    }
}
BFree
sumber
7
Bagaimana jika itu hanya bilangan bulat? Bagaimana dengan lokal tempat '.' Apakah pemisah grup, bukan koma (mis. pt-Br)? bagaimana dengan angka negatif? pemisah grup (koma dalam bahasa Inggris)? simbol mata uang? TryParse () dapat mengatur semua ini seperti yang diperlukan menggunakan NumberStyles dan IFormatProvider.
Lucas
Ooh ya, saya lebih suka versi All. Saya tidak pernah menggunakan metode ekstensi itu, panggilan yang bagus. Meskipun harus s.ToCharArray (). Semua (..). Adapun poin kedua Anda, saya dengar ya, itulah sebabnya saya memilih dengan jika Anda tidak ingin menggunakan int.Parse .... (yang saya asumsikan memiliki lebih banyak overhead ...)
BFree
11
1.3.3.8.5 sebenarnya bukan angka, sedangkan 1.23E5.
Clément
4
Logikanya cacat. -1
Russel Yang
1
@ Lucas Saya setuju bahwa TryParse menangani lebih banyak, tetapi terkadang itu tidak diperlukan. Saya hanya perlu memvalidasi kotak nomor kartu kredit saya (yang hanya dapat memiliki digit). Solusi ini hampir pasti lebih cepat daripada mencoba parse.
Millie Smith
14

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).

JDB masih ingat Monica
sumber
Tidak mencoba menjadi smart alec di sini, tetapi ini tampaknya gagal untuk string "0". Regex saya tidak ada. Apakah ada perubahan sederhana untuk itu? Saya mendapatkan "0" dan mungkin "0,0" dan bahkan "-0,0" sebagai angka yang valid.
Steve Hibbert
@SteveHibbert - Semua orang tahu bahwa "0" bukan angka! Serius meskipun ... menyesuaikan regex agar sesuai dengan 0.
JDB masih mengingat Monica
Hmmm, apakah ini saya, atau "0" masih belum dikenali sebagai angka?
Steve Hibbert
1
Menjadi malas, dan regex-ignorant, saya cut'n'pasted kode di atas, yang sepertinya termasuk "0,0" jenis perubahan. Saya menjalankan tes untuk memeriksa bahwa string "0" berjalan .IsNumeric (), dan itu mengembalikan false. Saya berpikir bahwa tes Octal akan mengembalikan nilai true untuk apa pun yang memiliki dua karakter numerik di mana yang pertama adalah nol (dan yang kedua adalah nol hingga tujuh), tetapi akan mengembalikan false hanya untuk lemak besar yang kesepian nol sendirian. Jika Anda menguji "0", dengan kode di atas, apakah Anda salah? Permintaan maaf, jika saya tahu lebih banyak regex saya akan bisa memberikan umpan balik yang lebih baik. Harus membaca.
Steve Hibbert
1
! Doh! Baca kembali komentar Anda di atas, saya telah melewatkan tanda bintang tambahan, saya hanya memperbarui garis desimal. Dengan itu, Anda benar, "0" IsNumeric. Permintaan maaf untuk faffing tentang, dan terima kasih banyak atas pembaruannya, semoga membantu orang lain juga. Terima kasih banyak.
Steve Hibbert
14

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.

cyberspy
sumber
2
Berfungsi bagus, kecuali Double.TryParse tidak mendukung NumberStyles.HexNumber. Lihat MSDN Double.TryParse. Adakah alasan mengapa Anda TryParse sebelum memeriksa IsNullOrWhiteSpace? TryParse mengembalikan false jika IsNullOrWhiteSpace bukan?
Harald Coppoolse
10

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.

Craig
sumber
9

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 :)

Noctis
sumber
8

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
Hein Andre Grønnestad
sumber
4
Saya percaya Anda mungkin telah menemukan salah satu pendekatan yang paling tidak efisien yang pernah saya lihat. Anda tidak hanya mengurai string dua kali (dalam kasus ini dapat diuraikan), Anda juga memanggil fungsi refleksi beberapa kali untuk melakukannya. Dan, pada akhirnya, Anda bahkan tidak menyimpan penekanan tombol menggunakan metode ekstensi.
JDB masih mengingat Monica
Terima kasih telah mengulangi apa yang saya tulis sendiri di paragraf kedua hingga terakhir. Juga jika Anda mengambil contoh terakhir saya ke akun Anda pasti menyimpan penekanan tombol menggunakan metode ekstensi ini. Jawaban ini tidak mengklaim sebagai semacam solusi ajaib untuk masalah apa pun, itu hanya contoh kode. Gunakan itu, atau jangan gunakan itu. Saya pikir itu nyaman ketika digunakan dengan benar. Dan itu termasuk contoh metode ekstensi dan refleksi, mungkin seseorang dapat belajar darinya.
Hein Andre Grønnestad
5
Sudahkah Anda mencoba var x = double.TryParse("2.2", new double()) ? double.Parse("2.2") : 0.0;?
JDB masih ingat Monica
2
Ya, dan itu tidak berhasil. Argument 2 must be passed with the 'out' keyworddan jika Anda menentukan outserta newAnda dapatkan A ref or out argument must be an assignable variable.
Hein Andre Grønnestad
1
Kinerja TryParse lebih baik daripada semua yang ditampilkan di sini. Hasil: TryParse 8 Regex 20 PHP IsNumeric 30 Refleksi TryParse 31 Kode uji dotnetfiddle.net/x8GjAF
prampe
7

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.

Gabriel Florit
sumber
7

Double.TryParse

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

sumber
4

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
}
dayanrr91
sumber
4

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

Dengan c # 7 itu Anda dapat menguraikan variabel keluar:

if(int.TryParse(str, out int v))
{
}
Chad Kuehn
sumber
2

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;
    }
}
userSteve
sumber
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;
}
OMANSAK
sumber
1

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
}
Arun
sumber
0

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
GamegaMan
sumber
Masalah potensial dengan pendekatan ini adalah IsNumericmelakukan analisis karakter dari string. Jadi angka seperti 9999999999999999999999999999999999999999999999999999999999.99999999999akan mendaftar True, meskipun tidak ada cara untuk mewakili angka ini menggunakan tipe numerik standar.
JDB masih ingat Monica
0

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") ```
Tahir
sumber
0

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.

Nayan_07
sumber
-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;
}
Vino
sumber
1
Empat downvotes, tetapi tidak ada yang mengatakan mengapa? Saya kira itu karena TryParse / Parse akan menjadi pilihan yang lebih baik, tetapi tidak semua orang yang datang ke sini akan tahu itu.
njplumridge
2
Anda membuatnya sangat rumit sehingga bahkan programmer C akan berkata "ya ampun, harus ada cara yang lebih mudah untuk menulis itu"
Ch3shire
1. Tidak ada alasan untuk membaca DUA angka dari konsol dan menambahkannya. Bagaimanapun, asal string tidak relevan, jadi tidak ada alasan untuk membaca apa pun dari konsol sama sekali.
Algoman
2. Variabel untuk f tidak perlu, Anda dapat mengembalikan 0 atau 1 secara langsung - jika Anda menginginkan pengembalian tunggal, Anda dapat menggunakan operator ternary untuk itu. int juga merupakan tipe pengembalian salah untuk menemukan, itu harus bool dan Anda bisa mengembalikan s == s1
Algoman
3. Anda menyalin digit s ke s1 dan kemudian membandingkan s dengan s1. Ini jauh lebih lambat dari yang seharusnya. Juga mengapa Anda melanjutkan loop batin bahkan jika c [0] == s [i] telah terjadi? Apakah Anda berharap [i] juga sama dengan digit lainnya?
Algoman