我知道一些检查字符串是否只包含数字的方法：
正则表达式、
int.parsetryparse谁能告诉我最快的检查方法是什么？
我只需要检查该值，不需要实际解析它。
我所说的“数字”特指 ASCII 数字：
0 1 2 3 4 5 6 7 8 9这与识别字符串是否为数字不是同一个问题，因为这个问题不仅涉及如何识别，还涉及最快的方法是什么。
bool IsDigitsOnly(string str)
{
foreach (char c in str)
{
if (c < '0' || c > '9')
return false;
}
return true;
}
可能是最快的方法。
您可以简单地使用 LINQ 来完成此操作：
return str.All(char.IsDigit);.Allchar.IsDigit以下是基于对同一字符串进行 1000000 次解析的一些基准测试：
更新了
releaseIsDigitsOnly: 384588
TryParse: 639583
Regex: 1329571
这是代码，看起来 IsDigitsOnly 更快：
class Program
{
private static Regex regex = new Regex("^[0-9]+$", RegexOptions.Compiled);
static void Main(string[] args)
{
Stopwatch watch = new Stopwatch();
string test = int.MaxValue.ToString();
int value;
watch.Start();
for(int i=0; i< 1000000; i++)
{
int.TryParse(test, out value);
}
watch.Stop();
Console.WriteLine("TryParse: "+watch.ElapsedTicks);
watch.Reset();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
IsDigitsOnly(test);
}
watch.Stop();
Console.WriteLine("IsDigitsOnly: " + watch.ElapsedTicks);
watch.Reset();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
regex.IsMatch(test);
}
watch.Stop();
Console.WriteLine("Regex: " + watch.ElapsedTicks);
Console.ReadLine();
}
static bool IsDigitsOnly(string str)
{
foreach (char c in str)
{
if (c < '0' || c > '9')
return false;
}
return true;
}
}
当然值得注意的是，TryParse 确实允许前导/尾随空格以及特定于文化的符号。它也受到字符串长度的限制。
该 char 已经有一个 IsDigit(char c) 来执行此操作：
public static bool IsDigit(char c)
{
if (!char.IsLatin1(c))
return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.DecimalDigitNumber;
if ((int) c >= 48)
return (int) c <= 57;
else
return false;
}
您可以简单地这样做：
var theString = "839278";
bool digitsOnly = theString.All(char.IsDigit);
只需对
charforforeachbool isDigits(string s)
{
if (s == null || s == "") return false;
for (int i = 0; i < s.Length; i++)
if ((s[i] ^ '0') > 9)
return false;
return true;
}
用于测试的代码（始终进行分析，因为结果取决于硬件、版本、顺序等）：
static bool isDigitsFr(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if (s[i] < '0' || s[i] > '9') return false; return true; }
static bool isDigitsFu(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if ((uint)(s[i] - '0') > 9) return false; return true; }
static bool isDigitsFx(string s) { if (s == null || s == "") return false; for (int i = 0; i < s.Length; i++) if ((s[i] ^ '0') > 9) return false; return true; }
static bool isDigitsEr(string s) { if (s == null || s == "") return false; foreach (char c in s) if (c < '0' || c > '9') return false; return true; }
static bool isDigitsEu(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((uint)(c - '0') > 9) return false; return true; }
static bool isDigitsEx(string s) { if (s == null || s == "") return false; foreach (char c in s) if ((c ^ '0') > 9) return false; return true; }
static void test()
{
var w = new Stopwatch(); bool b; var s = int.MaxValue + ""; int r = 12345678*2; var ss = new SortedSet<string>(); //s = string.Concat(Enumerable.Range(0, 127).Select(i => ((char)i ^ '0') < 10 ? 1 : 0));
w.Restart(); for (int i = 0; i < r; i++) b = s.All(char.IsDigit); w.Stop(); ss.Add(w.Elapsed + ".All .IsDigit");
w.Restart(); for (int i = 0; i < r; i++) b = s.All(c => c >= '0' && c <= '9'); w.Stop(); ss.Add(w.Elapsed + ".All <>");
w.Restart(); for (int i = 0; i < r; i++) b = s.All(c => (c ^ '0') < 10); w.Stop(); ss.Add(w.Elapsed + " .All ^");
w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFr(s); w.Stop(); ss.Add(w.Elapsed + " for <>");
w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFu(s); w.Stop(); ss.Add(w.Elapsed + " for -");
w.Restart(); for (int i = 0; i < r; i++) b = isDigitsFx(s); w.Stop(); ss.Add(w.Elapsed + " for ^");
w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEr(s); w.Stop(); ss.Add(w.Elapsed + " foreach <>");
w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEu(s); w.Stop(); ss.Add(w.Elapsed + " foreach -");
w.Restart(); for (int i = 0; i < r; i++) b = isDigitsEx(s); w.Stop(); ss.Add(w.Elapsed + " foreach ^");
MessageBox.Show(string.Join("\n", ss)); return;
}
Intel i5-3470 @ 3.2GHz、VS 2015 .NET 4.6.1 发布模式和启用优化的结果：
time method ratio
0.7776 for ^ 1.0000
0.7984 foreach - 1.0268
0.8066 foreach ^ 1.0372
0.8940 for - 1.1497
0.8976 for <> 1.1543
0.9456 foreach <> 1.2160
4.4559 .All <> 5.7303
4.7791 .All ^ 6.1458
4.8539 .All. IsDigit 6.2421
对于任何想要使用较短方法的人，请注意
.Alltruenullchar.IsDigitint.TryParse如果您担心性能，请不要使用
int.TryParseRegexDigitsOnlyDigitsOnly2DigitsOnly3另外，请注意，如果字符串太长而无法“适合”到
int.TryParseint这个简单的基准...
class Program {
static bool DigitsOnly(string s) {
int len = s.Length;
for (int i = 0; i < len; ++i) {
char c = s[i];
if (c < '0' || c > '9')
return false;
}
return true;
}
static bool DigitsOnly2(string s) {
foreach (char c in s) {
if (c < '0' || c > '9')
return false;
}
return true;
}
static bool DigitsOnly3(string s) {
return s.All(c => c >= '0' && c <= '9');
}
static void Main(string[] args) {
const string s1 = "916734184";
const string s2 = "916734a84";
const int iterations = 1000000;
var sw = new Stopwatch();
sw.Restart();
for (int i = 0 ; i < iterations; ++i) {
bool success = DigitsOnly(s1);
bool failure = DigitsOnly(s2);
}
sw.Stop();
Console.WriteLine(string.Format("DigitsOnly: {0}", sw.Elapsed));
sw.Restart();
for (int i = 0; i < iterations; ++i) {
bool success = DigitsOnly2(s1);
bool failure = DigitsOnly2(s2);
}
sw.Stop();
Console.WriteLine(string.Format("DigitsOnly2: {0}", sw.Elapsed));
sw.Restart();
for (int i = 0; i < iterations; ++i) {
bool success = DigitsOnly3(s1);
bool failure = DigitsOnly3(s2);
}
sw.Stop();
Console.WriteLine(string.Format("DigitsOnly3: {0}", sw.Elapsed));
sw.Restart();
for (int i = 0; i < iterations; ++i) {
int dummy;
bool success = int.TryParse(s1, out dummy);
bool failure = int.TryParse(s2, out dummy);
}
sw.Stop();
Console.WriteLine(string.Format("int.TryParse: {0}", sw.Elapsed));
sw.Restart();
var regex = new Regex("^[0-9]+$", RegexOptions.Compiled);
for (int i = 0; i < iterations; ++i) {
bool success = regex.IsMatch(s1);
bool failure = regex.IsMatch(s2);
}
sw.Stop();
Console.WriteLine(string.Format("Regex.IsMatch: {0}", sw.Elapsed));
}
}
...产生以下结果...
DigitsOnly: 00:00:00.0346094
DigitsOnly2: 00:00:00.0365220
DigitsOnly3: 00:00:00.2669425
int.TryParse: 00:00:00.3405548
Regex.IsMatch: 00:00:00.7017648
空验证功能：
public static bool IsDigitsOnly(string str)
{
return !string.IsNullOrEmpty(str) && str.All(char.IsDigit);
}
我喜欢 Linq，要让它在第一次不匹配时退出，你可以这样做
string str = '0129834X33';
bool isAllDigits = !str.Any( ch=> ch < '0' || ch > '9' );
如果它是单个字符串：
if (str.All(Char.IsDigit))
{
// string contains only digits
}
如果它是字符串列表：
if (lstStr.All(s => s.All(Char.IsDigit)))
{
// List of strings contains only digits
}
您可以在一行 LINQ 语句中完成此操作。好吧，我意识到这不一定是最快的，所以从技术上讲并不能回答这个问题，但它可能是最容易写的：
str.All(c => c >= '0' && c <= '9')
可能最快的方法是：
myString.All(c => char.IsDigit(c))
注意：如果您的字符串为空，这是不正确的，它将返回True（如果您不认为空是有效的数字/数字）
这应该有效：
Regex.IsMatch("124", "^[0-9]+$", RegexOptions.Compiled)
int.Parseint.TryParse如果您要多次执行此检查，则使用已编译的正则表达式很有用 - 第一次需要更多时间，但之后会快得多。
这可能来得太晚了！但我相信它会对某人有所帮助，就像它对我有帮助一样。
private static bool IsDigitsOnly(string str)
{
return str.All(c => c >= '0' && c <= '9');
}
您可以尝试使用正则表达式，方法是使用 C# 中的
.IsMatch(string input, string pattern)using System;
using System.Text.RegularExpression;
public namespace MyNS
{
public class MyClass
{
public void static Main(string[] args)
{
string input = Console.ReadLine();
bool containsNumber = ContainsOnlyDigits(input);
}
private bool ContainOnlyDigits (string input)
{
bool containsNumbers = true;
if (!Regex.IsMatch(input, @"/d"))
{
containsNumbers = false;
}
return containsNumbers;
}
}
}
问候
这将完美地工作，还有很多其他方法，但这个可以工作
bool IsDigitsOnly(string str)
{
if (str.Length > 0)//if contains characters
{
foreach (char c in str)//assign character to c
{
if (c < '0' || c > '9')//check if its outside digit range
return false;
}
}else//empty string
{
return false;//empty string
}
return true;//only digits
}
我对@TheCodeKing的答案做了一些小改动。
看来；
对于int类型最快的方法是TryParse
对于长类型，最快的方法是正则表达式。
下面是我的结果（打勾）
For int:
TryParse Max: 355788
IsDigitsOnly Max: 787013
Regex Max: 1297691
TryParse Avg: 186007
IsDigitsOnly Avg: 430963
Regex Avg: 464657,79
TryParse Min: 162742
IsDigitsOnly Min: 335646
Regex Min: 452121
For float :
TryParse Max : 3151995
IsDigitsOnly Max: 1392740
Regex Max : 1283451
TryParse Avg: 1391636
IsDigitsOnly Avg: 824029
Regex Avg: 501176
TryParse Min: 1187410
IsDigitsOnly Min: 706646
Regex Min: 476204
长代码：
using System.Diagnostics;
using System.Text.RegularExpressions;
class Program
{
private static Regex regex = new Regex("^[0-9]+$", RegexOptions.Compiled);
static void Main(string[] args)
{
Stopwatch watch = new Stopwatch();
watch.Start();
watch.Stop();
watch.Reset();
List<TimeSpan> tryparse = new List<TimeSpan>();
List<TimeSpan> isdigitsonly = new List<TimeSpan>();
List<TimeSpan> regexss = new List<TimeSpan>();
for (int say = 0; say < 1000; say++)
{
float value;
string test = Random.Shared.NextInt64(1000,long.MaxValue).ToString();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
float.TryParse(test, out value);
}
watch.Stop();
//Console.WriteLine("TryParse: " + watch.Elapsed);
tryparse.Add(watch.Elapsed);
watch.Reset();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
IsDigitsOnly(test);
}
watch.Stop();
//Console.WriteLine("IsDigitsOnly: " + watch.Elapsed);
isdigitsonly.Add(watch.Elapsed);
watch.Reset();
watch.Start();
for (int i = 0; i < 1000000; i++)
{
regex.IsMatch(test);
}
watch.Stop();
regexss.Add(watch.Elapsed);
watch.Reset();
// Console.WriteLine("Regex: " + watch.Elapsed);
Console.Write("---------------------% " + (Convert.ToDecimal( say)/ 999 * 100).ToString("N2") + "---------------------------");
Console.CursorLeft = 0;
}
Console.WriteLine();
Console.WriteLine($"TryParse: {tryparse.Max(t => t.Ticks)}");
Console.WriteLine($"IsDigitsOnly: {isdigitsonly.Max(t => t.Ticks)}");
Console.WriteLine($"Regex: {regexss.Max(t => t.Ticks)}");
Console.WriteLine();
Console.WriteLine($"TryParse Avg: {tryparse.Average(t => t.Ticks)}");
Console.WriteLine($"IsDigitsOnly Avg: {isdigitsonly.Average(t => t.Ticks)}");
Console.WriteLine($"Regex Avg: {regexss.Average(t => t.Ticks)}");
Console.WriteLine();
Console.WriteLine($"TryParse Min: {tryparse.Min(t => t.Ticks)}");
Console.WriteLine($"IsDigitsOnly Min: {isdigitsonly.Min(t => t.Ticks)}");
Console.WriteLine($"Regex Min: {regexss.Min(t => t.Ticks)}");
Console.ReadLine();
}
static bool IsDigitsOnly(string str)
{
foreach (char c in str)
{
if (c < '0' || c > '9')
return false;
}
return true;
}
}
另一种方法！
string str = "12345";
bool containsOnlyDigits = true;
try { if(Convert.ToInt32(str) < 0){ containsOnlyDigits = false; } }
catch { containsOnlyDigits = false; }
这里，如果语句
Convert.ToInt32(str)"-12345"-12345自 .NET 7 以来，我们现在专门为此目的创建了
char.IsAsciiDigit()https://learn.microsoft.com/en-us/dotnet/api/system.char.isasciidigit?view=net-8.0
试试这个代码：
bool isDigitsOnly(string str)
{
try
{
int number = Convert.ToInt32(str);
return true;
}
catch (Exception)
{
return false;
}
}
那
char.IsDigit(myChar)非常聪明且简单的方法来检测您的字符串是否只包含数字，方法如下：
string s = "12fg";
if(s.All(char.IsDigit))
{
return true; // contains only digits
}
else
{
return false; // contains not only digits
}
public bool CheckforDigits(string x)
{
int tr;
return x.All(r=> int.TryParse(r.ToString(), out tr));
}