转自：https://www.cnblogs.com/MakeView660/p/6077371.html

C++ 判断字符串是否全是数字

　　在实际的工作中，需要提取程序中的字符串信息，但是程序中经常将一些数字当做字符串来进行处理，例如表盘的刻度信息，这时候就需要判断字符串是否全为数字，来进行真正意义上的字符串提取。下面介绍了判断字符串是否全为数字的方法，仅供参考。

　　方法一：判断字符的ASCII范围（数字的范围为48~57）

　　



 1 #include <iostream>
 2 using namespace std;  
 3 
 4 bool AllisNum(string str); 
 5  
 6 int main( void )  
 7 {  
 8 
 9     string str1 = "wolaiqiao23";  
10     string str2 = "1990";  
11 
12     if (AllisNum(str1))
13     {
14         cout<<"str1 is a num"<<endl;  
15     }
16     else
17     {
18         cout<<"str1 is not a num"<<endl;  
19     }
20 
21     if (AllisNum(str2))
22     {
23         cout<<"str2 is a num"<<endl;  
24     }
25     else
26     {
27         cout<<"str2 is not a num"<<endl;  
28     }
29 
30     cin.get();
31     return 0;  
32 }  
33  
34 bool AllisNum(string str)  
35 {  
36     for (int i = 0; i < str.size(); i++)
37     {
38         int tmp = (int)str[i];
39         if (tmp >= 48 && tmp <= 57)
40         {
41             continue;
42         }
43         else
44         {
45             return false;
46         }
47     } 
48     return true;
49 }  



　　方法二：使用C++提供的stringstream对象　



 1 #include <iostream>
 2 #include <sstream>  
 3 using namespace std;  
 4 
 5 bool isNum(string str);  
 6 
 7 int main( void )  
 8 {
 9     string str1 = "wolaiqiao23r";  
10     string str2 = "1990";  
11     if(isNum(str1))  
12     {  
13         cout << "str1 is a num" << endl;  
14     }  
15     else
16     {  
17         cout << "str1 is not a num" << endl;  
18 
19     }  
20     if(isNum(str2))  
21     {  
22         cout<<"str2 is a num"<<endl;  
23     }  
24     else
25     {  
26         cout<<"str2 is not a num"<<endl;  
27 
28     }  
29 
30     cin.get();
31     return 0;  
32 }  
33 
34 bool isNum(string str)  
35 {  
36     stringstream sin(str);  
37     double d;  
38     char c;  
39     if(!(sin >> d))  
40     {
41         return false;
42     }
43     if (sin >> c) 
44     {
45         return false;
46     }  
47     return true;  
48 } 



　　运行结果：

　　

1.可能也有小数点

var test = ['123.12', '.123', '123.', '123a'];
var reg = /^[\d|\.]*$/;
test.forEach((v) => {
  console.log(v, reg.test(v));
});

2. 除了正则，isNaN或许更好

var test = ['123.12', '.123', '123.', '123a', '1e+43'];

test.forEach((v) => {
  console.log(v, !isNaN(v));
});

 不要直接使用 isNaN()

function isNumber(value) {
  return !Number.isNaN(Number(value))
}

 3.对于给定的的各种类型的数字表示（主要包含整数、小数、科学计数以及对应的正负数表示）

var numbers = [
    123, +123, -123,
    '123', '+123', '-123',
    123.4, +123.4, -123.4,
    '123.4', '+123.4', '-123.4',
    123., +123., -123.,
    '123.', '+123.', '-123.',
    .123,, +.123, -.123,
    '.123', '+.123', '-.123',
    1.23e+20, +1.23e+20, -1.23e+20,
    '1.23e+20', '+1.23e+20', '-1.23e+20',
    '123.4.5',
    '123abc456',
    undefined
];

 3.1、使用!isNaN来进行判定。

numbers.forEach((v) => {
  console.log(typeof(v), "\t", v, "\t", !isNaN(v));
});

 结果：

number      123      true
number      123      true
number      -123      true
string      123      true
string      +123      true
string      -123      true
number      123.4      true
number      123.4      true
number      -123.4      true
string      123.4      true
string      +123.4      true
string      -123.4      true
number      123      true
number      123      true
number      -123      true
string      123.      true
string      +123.      true
string      -123.      true
number      0.123      true
number      0.123      true
number      -0.123      true
string      .123      true
string      +.123      true
string      -.123      true
number      123000000000000000000      true
number      123000000000000000000      true
number      -123000000000000000000      true
string      1.23e+20      true
string      +1.23e+20      true
string      -1.23e+20      true
string      123.4.5      false
string      123abc456      false
undefined      undefined      false

3.2、使用正则表达式来进行判定：整数，不带符号

var reg = /^[\d]+$/;
numbers.forEach((v) => {
  console.log(typeof(v), "\t", v, "\t", reg.test(v));
});

结果如下:

number      123      true
number      123      true
number      -123      false
string      123      true
string      +123      false
string      -123      false
number      123.4      false
number      123.4      false
number      -123.4      false
string      123.4      false
string      +123.4      false
string      -123.4      false
number      123      true
number      123      true
number      -123      false
string      123.      false
string      +123.      false
string      -123.      false
number      0.123      false
number      0.123      false
number      -0.123      false
string      .123      false
string      +.123      false
string      -.123      false
number      123000000000000000000      true
number      123000000000000000000      true
number      -123000000000000000000      false
string      1.23e+20      false
string      +1.23e+20      false
string      -1.23e+20      false
string      123.4.5      false
string      123abc456      false
undefined      undefined      false

3.3、使用正则表达式来进行判定：整数 + 小数 + 科学计数，带符号

var reg = /^[\+-]?(\d+\.?\d*|\.\d+|\d\.\d+e\+\d+)$/;
numbers.forEach((v) => {
  console.log(typeof(v), "\t", v, "\t", reg.test(v));
});

结果如下：

number      123      true
number      123      true
number      -123      true
string      123      true
string      +123      true
string      -123      true
number      123.4      true
number      123.4      true
number      -123.4      true
string      123.4      true
string      +123.4      true
string      -123.4      true
number      123      true
number      123      true
number      -123      true
string      123.      true
string      +123.      true
string      -123.      true
number      0.123      true
number      0.123      true
number      -0.123      true
string      .123      true
string      +.123      true
string      -.123      true
number      123000000000000000000      true
number      123000000000000000000      true
number      -123000000000000000000      true
string      1.23e+20      true
string      +1.23e+20      true
string      -1.23e+20      true
string      123.4.5      false
string      123abc456      false
undefined      undefined      false

 

 

 

 

 

 

public boolean isNumeric(String str){ 
   Pattern pattern = Pattern.compile("[0-9]*"); 
   Matcher isNum = pattern.matcher(str);
   if( !isNum.matches() ){
       return false; 
   } 
   return true; 
}

可以通过修改正则表达式实现校验负数，将正则表达式修改为“^-?[0-9]+”即可，修改为“-?[0-9]+.?[0-9]+”即可匹配所有数字。

今天在写代码时突然想起测试经常用Microsoft.VisualBasic.Information.IsNumeric判断 url参数是否为数字时的这个方法的效率 

因为数字是字符串是直接使用的，所以不需要转型，也就没有用tryparse 

结果一测试吓一跳，这个方法的效率是如此的低，再测试了下tryparse还不错，正则的也比较差， 

没什么技术含量，看结果吧：
 
先拓展下字符串：


public static class Common
    {
        //isDigit
        public static bool isNumberic1(this string _string)
        {
            if (string.IsNullOrEmpty(_string))
                return false;
            foreach (char c in _string)
            {
                if (!char.IsDigit(c))
                    return false;
            }
            return true;
        }

        //vb isnumberic
        public static bool isNumberic2(this string _string)
        {
            return !string.IsNullOrEmpty(_string) && Microsoft.VisualBasic.Information.IsNumeric(_string);
        }
        //try parese
        public static bool isNumberic3(this string _string)
        {
            if (string.IsNullOrEmpty(_string))
                return false;
            int i = 0;
            return int.TryParse(_string, out i);
        }

        //try catch
        public static bool isNumberic4(this string _string)
        {
            if (string.IsNullOrEmpty(_string))
                return false;
            int i = 0;
            try { int.Parse(_string); }
            catch { return false; }
            return true;
        }
        //regex
        public static bool isNumberic5(this string _string)
        {
            return !string.IsNullOrEmpty(_string) && Regex.IsMatch(_string, "^//d+$");
        }
    } 
 
 
 
测试的代码：
 
 class Program
    {
        static void Main(string[] args)
        {

            Test("1234");
            Test("1234a");
            Test("a1234");
            Test("");
            Test(null);
            
        }

        static void Test(string str)
        {
            bool res1 = false, res2 = false, res3 = false, res4 = false, res5 = false;
            Stopwatch wat = new Stopwatch();
            wat.Start(); 
            for (int i = 1; i < 100000; i++)
            {
                res1 = str.isNumberic1();
            }
            wat.Stop();
            Console.WriteLine("isDigit      {0}:{1},{2}", str, wat.ElapsedMilliseconds, res1);

            wat.Reset();
            wat.Start();
            for (int i = 1; i < 100000; i++)
            {
                res2= str.isNumberic2();
            }
            wat.Stop();
            Console.WriteLine("isNumberic   {0}:{1},{2}", str, wat.ElapsedMilliseconds, res2);

            wat.Reset();
            wat.Start();
            for (int i = 1; i < 100000; i++)
            {
                res3 = str.isNumberic3();
            }
            wat.Stop();
            Console.WriteLine("try parse    {0}:{1},{2}", str, wat.ElapsedMilliseconds, res3);

            wat.Reset();
            wat.Start();
            for (int i = 1; i < 100000; i++)
            {
                res4 = str.isNumberic4();
            }
            wat.Stop();
            Console.WriteLine("try catch    {0}:{1},{2}", str, wat.ElapsedMilliseconds, res4);

            wat.Reset();
            wat.Start();
            for (int i = 1; i < 100000; i++)
            {
                res5 = str.isNumberic5();
            }
            wat.Stop();
            Console.WriteLine("regex        {0}:{1},{2}", str, wat.ElapsedMilliseconds, res5);
            Console.WriteLine();
        }
    } 
 
下面是我本机的测试结果 



isDigit      1234:0,True 
isNumberic  1234:173,True 
try parse    1234:21,True 
try catch    1234:23,True 
regex        1234:138,True 

isDigit      1234a:0,False 
isNumberic  1234a:204,False 
try parse    1234a:20,False 
try catch    1234a:5309,False 
regex        1234a:151,False 

isDigit      a1234:0,False 
isNumberic  a1234:191,False 
try parse    a1234:16,False 
try catch    a1234:5229,False 
regex        a1234:109,False 

isDigit      :0,False 
isNumberic  :0,False 
try parse    :0,False 
try catch    :1,False 
regex        :0,False 

isDigit      :0,False 
isNumberic  :1,False 
try parse    :0,False 
try catch    :1,False 
regex        :0,False 

结果：循环判断是否是数字字符效率是最高的 

而vbscript的方法效率比较低了 

顺便测试了下vbscript里的left和right方法效率也一样的低，还不及substring的十分之一 

所以vbscript里虽然有几个方法从名字看来比较好用，实际却比较杯具。