判断字符串类型的几种方法

1，如果是判断该字符串或者该字是不是中文的话，用以下代码：

String s1;
 if(s1.matches("[\\u4E00-\\u9FA5]+")){
  		System.out.print("s1是中文"); 
  }

2，如果是判断该字符串或者该字是不是所有的标点符号的话，用以下代码：

String s1;
    if(s1.matches("[\\pP\\p{Punct}]")){
        System.out.print("s1是标点符号");
    }

3，如果是判断该字符串或者该字是不是数字的话，用以下代码：

String s1;
    if(s1.matches("[0-9]+")){
        System.out.print("s1是数字");
    }

4，如果是判断该字符串或者该字是不是英文或英文字母的话，用以下代码：

String s1;
    if(s1.matches("[a-zA-Z]+")){
        System.out.print("s1是英文");
    }

喜欢博主的文章，欢迎关注、点赞👍、收藏⭐️、留言📝支持，谢谢大家

1. typeof、instanceof、Number.isNumber
2. parseInt、parseFloat
3. isNaN、isFinite
4. Number.isNaN、Number.isFinite
5. 正则表达式
6. 终极方案

我们逐一介绍，希望能帮到大家。

1. typeof、instanceof、Number.isInteger

typeof判断值是不是基本类型number，比如：

let num = 1;
typeof num === 'number'; // true

instanceof判断值是不是包装类Number，比如：

let num = new Number(1);
num instanceof Number; // true

Number.isInteger判断值是否是整数：

Number.isInteger(1);   // true
Number.isInteger('1'); // false
Number.isInteger(1.1); // false

这几种方式的缺点，都是只能基于类型判断，无法判断字符串是否是数值。

2. parseInt、parseFloat

这个方法的特点，一句话，返回字符串开头最长的有效数字。

我们可以用!isNaN(parseFloat(value))来判断字符串是否是数值。

let str1 = '123';
let str2 = 'abc';
!isNaN(parseFloat(str1)); // true，是数字
!isNaN(parseFloat(str2)); // false，不是数字

parseInt和parseFloat解析的时候遇到非法字符结束，返回解析到的数值。也就是说只要字符串头部是合法数值，那么就能解析出数值，哪怕整体不是数值。比如123abc，会被解析程123。

因此，上面的判断方式还不够严谨，下面的终极方案是比较严谨的方式。

3. isNaN、isFinite

在介绍这两个方法之前，先讲下NaN，它表示Not-a-Number。两个NaN无法直接比较相等，因为我们只知道它不是数值，是啥不确定，也就无法比较相等。

NaN === NaN;         // false
NaN == NaN;          // false
Object.is(NaN, NaN); // false

• isNaN(value)，如果ToNumber(value)的结果为NaN返回true，否则返回false。
• isFinite(value)，如果ToNumber(value)的结果为数值，且不等于Infinity或-Infinity返回true，否则返回false。

isNaN和isFinite都会先将传入的值转成数值，再进行判断。ToNumber的规则跟直接使用Number函数一样。一些非数值在类型转换的时候都能转成数值，比如：

Number(true);         // 1
Number(false);        // 0
Number(null);         // 0
Number('');           // 0

对null、true、false、''使用isNaN结果都是false，但是它们本身不是数值，因此不能单独使用isNaN。

4. Number.isNaN、Number.isFinite

这两个方法跟对应的全局方法是不一样的。

• Number.isNaN(value)，如果value为NaN返回true，否则返回false。
• Number.isFinite(value)，如果value为数值，且不等于Infinity或-Infinity返回true，否则返回false。

区别是全局方法会有强制类型转换，而这两个方法没有强制类型转换：

Number.isNaN(null);      // true
Number.isNaN(true);      // true
Number.isNaN(false);     // true
Number.isNaN('');        // true

可以看，由于没有类型转换，所以Number.isNaN判断null、true、false、''的结果都是true。

但是“副作用”是数字字符串也会得到true：

Number.isNaN('123');    // true

Number.isNaN等价与：

Number.isNaN = Number.isNaN || function(value) {
    return typeof value === "number" && isNaN(value);
}

而Number.isFinite等价于：

if (Number.isFinite === undefined) Number.isFinite = function(value) {
    return typeof value === 'number' && isFinite(value);
}

因此，这两个方法本质上也是基于类型的，没法判断一个字符串是否为数值。

5. 正则表达式

let exp = /^[+-]?\d*(\.\d*)?(e[+-]?\d+)?$/;
exp.test('+1.9');   // true
exp.test('-.1e11'); // true

这个正则可以判断整数、浮点数、正负数和科学计数法。

不过我觉得判断是否是数值用正则，有点小题大做了。

6. 终极方案（推荐）

我们先看方案：

!isNaN(parseFloat(value)) && isFinite(value);

这其实是jquery中$.isNumeric的源码，多么简洁且优雅。

接下来我们看看它的原理，我们以字符串123abc为例，我们应该得到false。

1. parseFloat('123abc')得到123；
2. !isNaN(123)得到true；
3. isFinite('123abc')得到false；
4. 最终结果为false。

单独使用!isNaN(parseFloat(value))会将123abc当成数值，所以用isFinite额外判断一次，isFinite的另一个作用是排除无穷数。

!isNaN(parseFloat(Infinity));  // true
!isNaN(parseFloat(Infinity)) && isFinite(Infinity); // false

而且，因为parseFloat的解析是纯字符串解析，没有类型转换，所以不会将null、true、false、''当成数值。

!isNaN(parseFloat(null)) && isFinite(null);   // false
!isNaN(parseFloat(true)) && isFinite(true);   // false
!isNaN(parseFloat(false)) && isFinite(false); // false
!isNaN(parseFloat('')) && isFinite('');       // false

妙，妙不可言。

7. 结语

对这几个方法的介绍并不全面，因为我们探讨的主题是“判断值是否为数值”。这几个方法任何一个单独拎出来，都能讲一篇，有时间再跟大家分享。

首先我们简单的说一下js中的几种数据类型

数据类型分为基本类型和引用类型：

基本类型：String、Number、Boolean、Null、Undefined

引用类型：Object、Array、Date、Function、Error、RegExp、Math、Number、String、Boolean、Globle。

然后判断数据类型的方法一般可以通过：typeof、instanceof、constructor、toString四种常用方法

1、typeof:（可以对基本类型做出准确的判断，但对于引用类型，用它就有点力不从心了）

typeof 返回一个表示数据类型的字符串，返回结果包括：number、boolean、string、object、undefined、function等6种数据类型。

typeof 可以对JS基本数据类型做出准确的判断（除了null），而对于引用类型返回的基本上都是object, 其实返回object也没有错，因为所有对象的原型链最终都指向了Object,Object是所有对象的`祖宗`。 但当我们需要知道某个对象的具体类型时，typeof 就显得有些力不从心了。

注意：typeof  null会返回object，因为特殊值null被认为是一个空的对象引用

function Aaa(){
}

var a1 = new Aaa();

//alert( a1 instanceof Aaa);  //true判断a1和Aaa是否在同一个原型链上，是的话返回真，否则返回假

var arr = [];

alert( arr instanceof Aaa);//false

    var str = 'hello';
    alert(str instanceof String);//false
    var bool = true;
    alert(bool instanceof Boolean);//false
    var num = 123;
    alert(num instanceof Number);//false
    var nul = null;
    alert(nul instanceof Object);//false
    var und = undefined;
    alert(und instanceof Object);//false
    var oDate = new Date();
    alert(oDate instanceof Date);//true
    var json = {};
    alert(json instanceof Object);//true
    var arr = [];
    alert(arr instanceof Array);//true
    var reg = /a/;
    alert(reg instanceof RegExp);//true
    var fun = function(){};
    alert(fun instanceof Function);//true
    var error = new Error();
    alert(error instanceof Error);//true

var num = new Number(123);
var str = new String('abcdef');
var boolean = new Boolean(true);

function Aaa(){
}
//Aaa.prototype.constructor = Aaa;   //每一个函数都会有的，都是自动生成的

//Aaa.prototype.constructor = Aaa;

    var str = 'hello';
    alert(str.constructor == String);//true
    var bool = true;
    alert(bool.constructor == Boolean);//true
    var num = 123;
    alert(num.constructor ==Number);//true
   // var nul = null;
   // alert(nul.constructor == Object);//报错
    //var und = undefined;
    //alert(und.constructor == Object);//报错
    var oDate = new Date();
    alert(oDate.constructor == Date);//true
    var json = {};
    alert(json.constructor == Object);//true
    var arr = [];
    alert(arr.constructor == Array);//true
    var reg = /a/;
    alert(reg.constructor == RegExp);//true
    var fun = function(){};
    alert(fun.constructor ==Function);//true
    var error = new Error();
    alert(error.constructor == Error);//true

function Aaa(){
}
Aaa.prototype.constructor = Aaa;//程序可以自动添加，当我们写个构造函数的时候，程序会自动添加这句代码
function BBB(){}
Aaa.prototype.constructor = BBB;//此时我们就修改了Aaa构造函数的指向问题
alert(Aaa.construtor==Aaa);//false

    var str = 'hello';
    console.log(Object.prototype.toString.call(str));//[object String]
    var bool = true;
    console.log(Object.prototype.toString.call(bool))//[object Boolean]
    var num = 123;
    console.log(Object.prototype.toString.call(num));//[object Number]
    var nul = null;
    console.log(Object.prototype.toString.call(nul));//[object Null]
    var und = undefined;
    console.log(Object.prototype.toString.call(und));//[object Undefined]
    var oDate = new Date();
    console.log(Object.prototype.toString.call(oDate));//[object Date]
    var json = {};
    console.log(Object.prototype.toString.call(json));//[object Object]
    var arr = [];
    console.log(Object.prototype.toString.call(arr));//[object Array]
    var reg = /a/;
    console.log(Object.prototype.toString.call(reg));//[object RegExp]
    var fun = function(){};
    console.log(Object.prototype.toString.call(fun));//[object Function]
    var error = new Error();
    console.log(Object.prototype.toString.call(error));//[object Error]

例：跨页面判断是否是数组

window.onload = function(){
	
	var oF = document.createElement('iframe');
	document.body.appendChild( oF );
	
	var ifArray = window.frames[0].Array;
	
	var arr = new ifArray();
	
	//alert( arr.constructor == Array );  //false
	
	//alert( arr instanceof Array );  //false
	
	alert( Object.prototype.toString.call(arr) == '[object Array]' );  //true
	
	
};

从结果中可以看出，constructor和instanceof都没有正确的判断出类型，只有object.prototype.toString.call()；正确判断出了

其实面试官也经常喜欢让说一种最简单的判断是数组的方法，记住喽是object.prototype.toString.call()哦！

好了，今天就分享这些了！