Jeśli mam te ciągi:
"abc"
=false
"123"
=true
"ab2"
=false
Czy istnieje polecenie, podobne IsNumeric()
lub coś innego, które może zidentyfikować, czy ciąg jest poprawną liczbą?
Jeśli mam te ciągi:
"abc"
= false
"123"
= true
"ab2"
= false
Czy istnieje polecenie, podobne IsNumeric()
lub coś innego, które może zidentyfikować, czy ciąg jest poprawną liczbą?
Odpowiedzi:
int n;
bool isNumeric = int.TryParse("123", out n);
Aktualizacja od C # 7:
var isNumeric = int.TryParse("123", out int n);
lub jeśli nie potrzebujesz numeru, możesz odrzucić parametr out
var isNumeric = int.TryParse("123", out _);
W var s mogą być zastąpione przez ich rodzajów!
public static bool IsNumeric(this string text) { double _out; return double.TryParse(text, out _out); }
Zwróci to prawda, jeśli input
wszystkie liczby. Nie wiem, czy jest coś lepszego niż TryParse
, ale zadziała.
Regex.IsMatch(input, @"^\d+$")
Jeśli chcesz tylko wiedzieć, czy ma jedną lub więcej cyfr pomieszanych ze znakami, odłóż ^
+
i $
.
Regex.IsMatch(input, @"\d")
Edycja: Właściwie myślę, że jest lepszy niż TryParse, ponieważ bardzo długi ciąg może potencjalnie przepełnić TryParse.
RegexOptions.Compiled
jako parametr, jeśli używasz ich tysiące w celu ewentualnego zwiększenia prędkościRegex.IsMatch(x.BinNumber, @"^\d+$", RegexOptions.Compiled)
.
Możesz także użyć:
stringTest.All(char.IsDigit);
Będzie to powrót true
do wszystkich numerycznej cyfry (nie float
) i false
jeżeli ciąg wejściowy jest każdy rodzaj alfanumerycznych.
Uwaga : stringTest
nie powinien być pustym ciągiem, ponieważ przejdzie test numeryczny.
..--..--
prawidłowy numer. Najwyraźniej nie.
Użyłem tej funkcji kilka razy:
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;
}
Ale możesz także użyć;
bool b1 = Microsoft.VisualBasic.Information.IsNumeric("1"); //true
bool b2 = Microsoft.VisualBasic.Information.IsNumeric("1aa"); // false
Z analizy porównawczej IsNumeric Options
(źródło: aspalliance.com )
(źródło: aspalliance.com )
Jest to prawdopodobnie najlepsza opcja w języku C #.
Jeśli chcesz wiedzieć, czy ciąg zawiera liczbę całkowitą (liczbę całkowitą):
string someString;
// ...
int myInt;
bool isNumerical = int.TryParse(someString, out myInt);
Metoda TryParse spróbuje przekonwertować ciąg na liczbę (liczbę całkowitą), a jeśli się powiedzie, zwróci true i umieści odpowiednią liczbę w myInt. Jeśli nie, zwraca false.
Rozwiązania wykorzystujące int.Parse(someString)
alternatywę pokazaną w innych odpowiedziach działają, ale jest znacznie wolniejsze, ponieważ zgłaszanie wyjątków jest bardzo kosztowne. TryParse(...)
został dodany do języka C # w wersji 2 i do tego czasu nie miałeś wyboru. Teraz to robisz: dlatego powinieneś unikać Parse()
alternatywy.
Jeśli chcesz akceptować liczby dziesiętne, klasa dziesiętna również ma .TryParse(...)
metodę. Zamień int na dziesiętny w powyższej dyskusji i obowiązują te same zasady.
Zawsze możesz użyć wbudowanych metod TryParse dla wielu typów danych, aby sprawdzić, czy dany ciąg przejdzie.
Przykład.
decimal myDec;
var Result = decimal.TryParse("123", out myDec);
Wynik będzie wtedy = Prawda
decimal myDec;
var Result = decimal.TryParse("abc", out myDec);
Wynik wtedy = Fałsz
Jeśli nie chcesz używać int.Parse lub double.Parse, możesz rzucić własny za pomocą czegoś takiego:
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;
}
}
Jeśli chcesz wyłapać szersze spektrum liczb, à_numeric PHP , możesz użyć następujących opcji:
// 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 );
}
Test jednostkowy:
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 );
}
Pamiętaj, że fakt, że wartość jest liczbą, nie oznacza, że można ją przekonwertować na typ liczbowy. Na przykład "999999999999999999999999999999.9999999999"
jest perfekcyjnie prawidłową wartością numeryczną, ale nie pasuje do typu liczbowego .NET (to znaczy nie zdefiniowanego w standardowej bibliotece).
Wiem, że to stary wątek, ale żadna z odpowiedzi tak naprawdę mi nie zrobiła - ani nieefektywna, ani nie zamknięta w sobie dla łatwego ponownego użycia. Chciałem również upewnić się, że zwróci wartość false, jeśli ciąg znaków był pusty lub zerowy. TryParse zwraca w tym przypadku wartość true (pusty ciąg nie powoduje błędu podczas analizowania jako liczby). Oto moja metoda rozszerzenia ciągu:
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);
}
}
Prosty w użyciu:
var mystring = "1234.56789";
var test = mystring.IsNumeric();
Lub, jeśli chcesz przetestować inne typy liczb, możesz określić „styl”. Aby więc przekonwertować liczbę za pomocą wykładnika, możesz użyć:
var mystring = "5.2453232E6";
var test = mystring.IsNumeric(style: NumberStyles.AllowExponent);
Lub, aby przetestować potencjalny ciąg szesnastkowy, możesz użyć:
var mystring = "0xF67AB2";
var test = mystring.IsNumeric(style: NumberStyles.HexNumber)
Opcjonalnego parametru „kultura” można używać w podobny sposób.
Ogranicza to to, że nie można konwertować ciągów, które są zbyt duże, aby mogły być zawarte w podwójnym, ale jest to ograniczony wymóg i myślę, że jeśli pracujesz z liczbami większymi niż to, prawdopodobnie będziesz potrzebować dodatkowej specjalistycznej obsługi liczb i tak działa.
Jeśli chcesz sprawdzić, czy ciąg jest liczbą (zakładam, że jest to ciąg, ponieważ jeśli jest to liczba, duh, wiesz, że to jeden).
możesz także:
public static bool IsNumber(this string aNumber)
{
BigInteger temp_big_int;
var is_number = BigInteger.TryParse(aNumber, out temp_big_int);
return is_number;
}
Zajmie się to zwykłymi nieprzyjemnościami:
BigInteger.Parse("3.3")
wyrzuci wyjątek i TryParse
dla tego samego zwróci false)Double.TryParse
Będziesz musiał dodać odniesienie do klasy System.Numerics
i mieć ją
using System.Numerics;
na szczycie (cóż, chyba druga to bonus :)
Myślę, że ta odpowiedź zostanie po prostu zagubiona między wszystkimi innymi, ale tak czy inaczej, proszę bardzo.
Skończyło się na tym pytaniu przez Google, ponieważ chciałem sprawdzić, czy string
było numeric
tak, że mogę po prostu użyć double.Parse("123")
zamiast TryParse()
metody.
Dlaczego? Ponieważ denerwujące jest zadeklarowanie out
zmiennej i sprawdzenie wyniku, TryParse()
zanim dowiesz się, czy parsowanie się nie powiodło. Chcę użyć polecenia, ternary operator
aby sprawdzić, czy string
jest, numerical
a następnie po prostu parsować je w pierwszym wyrażeniu trójskładnikowym lub podać wartość domyślną w drugim wyrażeniu trójskładnikowym.
Lubię to:
var doubleValue = IsNumeric(numberAsString) ? double.Parse(numberAsString) : 0;
Jest po prostu o wiele czystszy niż:
var doubleValue = 0;
if (double.TryParse(numberAsString, out doubleValue)) {
//whatever you want to do with doubleValue
}
Zrobiłem parę extension methods
dla tych przypadków:
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);
}
Przykład:
"123".IsParseableAs<double>() ? double.Parse(sNumber) : 0;
Ponieważ IsParseableAs()
próba przetworzenia łańcucha jako odpowiedniego typu zamiast tylko sprawdzenia, czy łańcuch jest „numeryczny”, powinna być całkiem bezpieczna. I możesz go nawet używać do typów nienumerycznych, które mają taką TryParse()
metodę DateTime
.
Metoda wykorzystuje refleksję i ostatecznie wywołujesz TryParse()
metodę dwukrotnie, co oczywiście nie jest tak wydajne, ale nie wszystko musi być w pełni zoptymalizowane, czasami wygoda jest po prostu ważniejsza.
Tej metody można także użyć do łatwego parsowania listy ciągów liczbowych na listę double
lub inny typ z wartością domyślną bez wychwytywania jakichkolwiek wyjątków:
var sNumbers = new[] {"10", "20", "30"};
var dValues = sNumbers.Select(s => s.IsParseableAs<double>() ? double.Parse(s) : 0);
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;
}
Ta metoda rozszerzenia pozwala przeanalizować string
jak każdy, type
który ma TryParse()
metodę, a także pozwala określić wartość domyślną, która ma zostać zwrócona, jeśli konwersja się nie powiedzie.
Jest to lepsze niż użycie operatora trójskładnikowego z powyższą metodą rozszerzenia, ponieważ dokonuje konwersji tylko raz. Nadal jednak używa refleksji ...
Przykłady:
"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);
Wyjścia:
123
25
123,78
107,4
28.10.2014 00:00:00
01.01.0001 00:00:00
var x = double.TryParse("2.2", new double()) ? double.Parse("2.2") : 0.0;
?
Argument 2 must be passed with the 'out' keyword
i jeśli określisz out
tak dobrze, jak new
dostaniesz A ref or out argument must be an assignable variable
.
Jeśli chcesz wiedzieć, czy ciąg jest liczbą, zawsze możesz spróbować go parsować:
var numberString = "123";
int number;
int.TryParse(numberString , out number);
Zauważ, że TryParse
zwraca a bool
, którego możesz użyć do sprawdzenia, czy parsowanie się powiodło.
bool Double.TryParse(string s, out double result)
AKTUALIZACJA Kunal Noel Answer
stringTest.All(char.IsDigit);
// This returns true if all characters of the string are digits.
Ale w tym przypadku mamy puste łańcuchy, które przejdą ten test, więc możesz:
if (!string.IsNullOrEmpty(stringTest) && stringTest.All(char.IsDigit)){
// Do your logic here
}
Najlepsze elastyczne rozwiązanie z wbudowaną funkcją .net o nazwie- char.IsDigit
. Działa z nieograniczoną liczbą długich. Zwróci prawdę tylko wtedy, gdy każdy znak jest liczbą. Używałem go wiele razy bez problemów i znacznie łatwiejsze rozwiązanie, jakie kiedykolwiek znalazłem. Zrobiłem przykładową metodę. Jest gotowy do użycia. Ponadto dodałem sprawdzanie poprawności dla pustych i pustych danych wejściowych. Ta metoda jest teraz całkowicie kuloodporna
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;
}
}
}
Za pomocą c # 7 można wstawić zmienną out:
if(int.TryParse(str, out int v))
{
}
Skorzystaj z tych metod rozszerzenia, aby wyraźnie rozróżnić między sprawdzaniem, czy łańcuch jest numeryczny i czy łańcuch zawiera tylko 0–9 cyfr
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;
}
}
Pobierz w swoim projekcie odniesienie do języka Visual Basic i użyj jego metody Information.IsNumeric, takiej jak pokazano poniżej, i możesz przechwytywać liczby zmiennoprzecinkowe, a także liczby całkowite, w przeciwieństwie do powyższej odpowiedzi, która wyłapuje tylko liczby całkowite.
// Using Microsoft.VisualBasic;
var txt = "ABCDEFG";
if (Information.IsNumeric(txt))
Console.WriteLine ("Numeric");
IsNumeric("12.3"); // true
IsNumeric("1"); // true
IsNumeric("abc"); // false
IsNumeric
analiza znaków w łańcuchu. Liczba taka 9999999999999999999999999999999999999999999999999999999999.99999999999
zarejestruje się jako True
, mimo że nie ma możliwości reprezentowania tej liczby przy użyciu standardowego typu numerycznego.
Wszystkie odpowiedzi są przydatne. Ale podczas szukania rozwiązania, w którym wartość liczbowa wynosi 12 cyfr lub więcej (w moim przypadku), a następnie podczas debugowania znalazłem przydatne rozwiązanie:
double tempInt = 0;
bool result = double.TryParse("Your_12_Digit_Or_more_StringValue", out tempInt);
Zmienna wynikowa da ci wartość prawda lub fałsz.
Oto metoda C #. Metoda 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;
}