js typeof 运算符
typeof 是一个一元运算，放在一个运算数之前，运算数可以是任意类型。它返回值是一个字符串，该字符串说明运算数的类型。
说明
typeof 运算符把类型信息当作字符串返回。typeof 返回值有六种可能： "number," "string," "boolean," "object," "function," 和 "undefined."。typeof 语法中的圆括号是可选项。
typeof是一个一元运算符，它返回的结果始终是一个字符串，对不同的操作数，它返回不同的结果。
具体的规则如下：
一、对于数字类型的操作数而言， typeof 返回的值是 number。比如说：typeof(1)，返回的值就是number。
上面是举的常规数字，对于非常规的数字类型而言，其结果返回的也是number。比如typeof(NaN)，NaN在
JavaScript中代表的是特殊非数字值，虽然它本身是一个数字类型。
在JavaScript中，特殊的数字类型还有几种：Infinity表示无穷大特殊值
NaN特殊的非数字值
Number.MAX_VALUE可表示的最大数字
Number.MIN_VALUE可表示的最小数字(与零最接近)
Number.NaN特殊的非数字值
Number.POSITIVE_INFINITY表示正无穷大的特殊值
Number.NEGATIVE_INFINITY表示负无穷大的特殊值
以上特殊类型，在用typeof进行运算进，其结果都将是number。
二、对于字符串类型， typeof 返回的值是 string。比如typeof("123")返回的值是string。
三、对于布尔类型， typeof 返回的值是 boolean 。比如typeof(true)返回的值是boolean。
四、对于对象、数组、null 返回的值是 object 。比如typeof(window)，typeof(document)，typeof(null)返回的值都是object。
五、对于函数类型，返回的值是 function。比如：typeof(eval)，typeof(Date)返回的值都是function。
六、如果运算数是没有定义的(比如说不存在的变量、函数或者undefined)，将返回undefined。比如：typeof(sss)、typeof(undefined)都返回undefined。

java学习——GetType和typeof的区别
区别：

1、Typeof()是运算符而GetType是方法；

2、GetType()是基类System.Object的方法，因此只有建立一个实例之后才能被调用（初始化以后）；

3、Typeof()的参数只能是int，String，自定义类型，且不能是实例

4、Typeof()：得到一个Class的Type; GetType()：得到一个Class的实例的Type

JSON.parse(jsonstr); //可以将json字符串转换成json对象
JSON.stringify(jsonobj); //可以将json对象转换成json对符串
在js使用中的一个函数typeof用法, typeof 运算符把类型信息当作字符串返回，包括有大家常有变量类型。
typeof 运算符把类型信息当作字符串返回。typeof 返回值有六种可能： “number,” “string,” “boolean,” “object,” “function,” 和 “undefined.”我们可以使用typeof来获取一个变量是否存在，如if(typeof a!=”undefined”){}，而不要去使用if(a)因为如果a不存在(未声明)则会出错，对于Array,Null等特殊对象使用typeof一律返回object，这正是typeof的局限性。
typeof 语法中的圆括号是可选项。
if(document.mylist.length != “undefined” ) {} 这个用法有误.
正确的是 if( typeof(document.mylist.length) != “undefined” ) {}
或 if( !isNaN(document.mylist.length) ) {}
typeof的运算数未定义,返回的就是 “undefined”.
运算数为数字 typeof(x) = “number”
字符串 typeof(x) = “string”
布尔值 typeof(x) = “boolean”
对象,数组和null typeof(x) = “object”
函数 typeof(x) = “function”
typeof 运算符返回一个用来表示表达式的数据类型的字符串。
可能的字符串有：”number”、”string”、”boolean”、”object”、”function” 和 “undefined”。
如：
代码如下 复制代码
alert(typeof (123));//typeof(123)返回”number”
alert(typeof (“123″));//typeof(“123″)返回”string”
对于Array,Null等特殊对象使用typeof一律返回object，这正是typeof的局限性。
如果我们希望获取一个对象是否是数组，或判断某个变量是否是某个对象的实例则要选择使用instanceof。
instanceof用于判断一个变量是否某个对象的实例，如var a=new Array();alert(a instanceof Array);会返回true，同时alert(a instanceof Object)也会返回true;这是因为Array是object的子类。
再如：function test(){};var a=new test();alert(a instanceof test)会返回true。
友情提示
a instanceof Object 得到true并不是因为 Array是Object的子对象，而是因为 Array的prototype属性构造于Object，Array的父级是Function
NaN、 null 及 undefined 的区别
标签： it 分类： js
NaN：保留字(表明数据类型不是数字)
undefined：对象属性或方法不存在，或声明了变量但从未赋值。
即当你使用了对象未定的属性或者未定义的方法时或当你声明一个变量，但你确从未对其进行赋值，便对
其进行操作(当然赋值除外)，会有”undefined”提示null 值指出一个变量中没有包含有效的数据。
产生 null 的原因是：对一个变量显式地赋值为 null。 包含 null 的表达式之间的任何操作。
Boolean 表达式
一个值为 true 或者 false 的表达式。
如果需要，非 Boolean 表达式也可以被转换为 Boolean 值，但是要遵循下列规则：所有的对象都被当作 true。 当且仅当字符串为空时，该字符串被当作 false。
null 和 undefined 被当作 false。
当且仅当数字为零时，该数字被当作 false。
字符串比较
两个字符序列之间的比较。
除非在进行比较操作的函数中指出，所有的字符串比较操作都是二进制的。
在英语中，二进制比较区分大小写；而文本比较则不区分。
数值表达式
数值表达式指的是任何值为数字的表达式。这种表达式的元素可以包括关键字、变量、文字和运算
符的任意组合，只要此组合能够生成一个数字。在特定的情况下，如果可以的话，字符串也可以被
转换为数字。
构造函数
一种 JScript 函数，具有两个特殊的性质：由 new 运算符来调用此函数。 通过 this 关键字将新
创建对象的地址传递到此函数。 强列建议使用构造函数来初始化新的对象。
ASCII 字符集
美国标准信息交换编码 (ASCII) 的 7 位字符集，它被广泛地用来表示标准的美国键盘上的字母和符号。
ASCII 字符集与 ANSI 字符集中的头 128 个字符 (0–127) 完全相同。Automation 对象通过
Automation 接口可以被其他应用程序或编程工具使用的对象。
全球标准时间 (UTC)
全球标准时间指的是由世界时间标准设定的时间。原先也被称为格林威治标准
时间或者 GMT。
Jscript 有三种主要数据类型、两种复合数据类型和两种特殊数据类型。
主要(基本)数据类型是：字符串 数值 布尔
复合(引用)数据类型是：对象 数组
特殊数据类型是：Null Undefined
null = = undefined
true
“NaN” = = NaN
false
5 = = NaN
false
NaN = = NaN
false
NaN != NaN
true
false = =0
true
true = =1
true
true = = 2
false
undefined = = 0
false
null = = 0
false
“5” = = 5
true
1.类型分析：
js中的数据类型有undefined,boolean,number,string,object等5种，前4种为原始类型，第5种为引用类型。
var a1;
var a2 = true;
var a3 = 1;
var a4 = “Hello”;
var a5 = new Object();
var a6 = null;
var a7 = NaN;
var a8 = undefined;
alert(typeof a); //显示”undefined”
alert(typeof a1); //显示”undefined”
alert(typeof a2); //显示”boolean”
alert(typeof a3); //显示”number”
alert(typeof a4); //显示”string”
alert(typeof a5); //显示”object”
alert(typeof a6); //显示”object”
alert(typeof a7); //显示”number”
alert(typeof a8); //显示”undefined”
从上面的代码中可以看出未定义的值和定义未赋值的为undefined，null是一种特殊的object,NaN是一种特殊的number。
2.比较运算
var a1; //a1的值为undefined
var a2 = null;
var a3 = NaN;
alert(a1 == a2); //显示”true”
alert(a1 != a2); //显示”false”
alert(a1 == a3); //显示”false”
alert(a1 != a3); //显示”true”
alert(a2 == a3); //显示”false”
alert(a2 != a3); //显示”true”
alert(a3 == a3); //显示”false”
alert(a3 != a3); //显示”true”
从上面的代码可以得出结论：(1)undefined与null是相等；(2)NaN与任何值都不相等，与自己也不相等。Null 数据类型
在 Jscript 中数据类型 null 只有一个值：null。关键字 null 不能用作函数或变量的名称。
包含 null 的变量包含“无值”或“无对象”。换句话说，该变量没有保存有效的数、字符串、boolean、数组或对象。可以通过给一个变量赋 null 值来清除变量的内容。
请注意，在 Jscript 中，null 与 0 不相等(与在 C 和 C++ 中不同)。同时应该指出的是，Jscript中 typeof 运算符将报告 null 值为 Object 类型，而非类型 null。这点潜在的混淆是为了向下兼容。
Undefined 数据类型
如下情况使返回 undefined 值：
对象属性不存在，
声明了变量但从未赋值。
注意不能通过与 undefined 做比较来测试一个变量是否存在，虽然可以检查它的类型是否为“undefined”。在以下的代码范例中，假设程序员想测试是否已经声明变量 x ：
// 这种方法不起作用
if (x == undefined)
// 作某些操作
// 这个方法同样不起作用- 必须检查
// 字符串 “undefined”
if (typeof(x) == undefined)
// 作某些操作
// 这个方法有效
if (typeof(x) == “undefined”)
// 作某些操作
考虑将 undefined 值与null做比较。
针对上面的判断，如果变量 x 没有定义的话 if (x == undefined) {…}会抛出exception：变量x未定义，这句判断不会执行，可用try{…}catch(ex){…} 捕获。
不管x是否已经定义，使用 if (typeof(x) == undefined) 都会判断为 false。
someObject.prop == null;
如下情况时，比较的结果为 true，
如果属性 someObject.prop 包含 null 值，
如果属性 someObject.prop 不存在。
要检查一个对象属性是否存在，可以使用新的 in 运算符：
if (“prop” in someObject)
// someObject 有属性 ‘prop’
在JavaScript中，null与undefined一度使人迷惑。下面的分析，有利于你更清晰的认知它(或者让你更迷惑)：
- null是关键字；undefined是Global对象的一个属性
- null是对象(空对象, 没有任何属性和方法)；undefined是undefined类型的值。试试下面的代码：
document.writeln(typeof null); //return object
document.writeln(typeof undefined); //return undefined
- 对象模型中，所有的对象都是Object或其子类的实例，但null对象例外：
document.writeln(null instanceof Object); //return false
- null“等值(==)”于undefined，但不“全等值(===)”于undefined：
document.writeln(null == undefined); //return true
document.writeln(null === undefined); //return false
- 运算时null与undefined都可以被类型转换为false，但不等值于false：
document.writeln(!null, !undefined); //return true,true
document.writeln(null==false); //return false
document.writeln(undefined==false); //return false

java与js的instanceof与typeof的使用
instanceof 用来测试一个对象是否为一个类的实例，能不能转为某个类的对象。用法为：
boolean result = obj instanceof Class

其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。
注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。
obj 必须为引用类型，不能是基本类型
int i = 0;

System.out.println(i instanceof Integer);//编译不通过

System.out.println(i instanceof Object);//编译不通过

instanceof 运算符只能用作对象的判断。
obj 为 class 类的直接或间接子类
public class Person {
}

public class Man extends Person{
}

Person p1 = new Person();

Person p2 = new Man();

Man m1 = new Man();

System.out.println(p1 instanceof Man);//false

System.out.println(p2 instanceof Man);//true

System.out.println(m1 instanceof Man);//true
注意第一种情况， p1 instanceof Man ，Man 是 Person 的子类，Person 不是 Man 的子类，所以返回结果为 false。
String 类中的重写的 equals 方法
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

js的typeof和instanceof方法
jsonof是一个一元运算，放在一个运算数之前，运算数可以是任意类型。它会返回一个字符串，该字符串说明运算数的类型。
typeof 返回值有六种可能： “number”， “string”，“boolean” ，“object”， “function” 和 "undefined "
typeof(1);
typeof(NaN);
typeof(Number.MIN_VALUE);
typeof(Infinity);
typeof(“123”);
typeof(true);
typeof(window);
typeof(document);
typeof(null);
typeof(eval);
typeof(Date);
typeof(sss);
typeof(undefined);
在 JavaScript 中，判断一个变量的类型尝尝会用 typeof 运算符，在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 “object”。ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。instanceof 运算符与 typeof 运算符相似，用于识别正在处理的对象的类型。与 typeof 方法不同的是，instanceof 方法要求开发者明确地确认对象为某特定类型。例如：
//  判断对象是否为 “未定义” 值(即 undefined)。

coreUtil.isUndefined = function (obj) { return obj === undefined || typeof obj === “undefined”; };

var oStringObject = new String(“hello world”);

console.log(oStringObject instanceof String);   // 输出 “true”

这段代码问的是“变量 oStringObject 是否为 String 对象的实例？”oStringObject 的确是 String 对象的实例，因此结果是"true"。尽管不像 typeof 方法那样灵活，但是在 typeof 方法返回 “object” 的情况下，instanceof 方法还是很有用的。
通常来讲，使用 instanceof 就是判断一个实例是否属于某种类型。例如：
$.extend($.fn.datagrid.methods, {

addEditor : function(jq, param) {

if (param instanceof Array) {

$.each(param, function(index, item) {

var e = $(jq).datagrid(‘getColumnOption’, item.field);

e.editor = item.editor;

});

} else {

//获取datagrid字段的属性

var e = $(jq).datagrid(‘getColumnOption’, param.field);

//给编辑器赋值

e.editor = param.editor;

}

},

removeEditor : function(jq, param) {

if (param instanceof Array) {

$.each(param, function(index, item) {

var e = $(jq).datagrid(‘getColumnOption’, item);

e.editor = {};

});

} else {

var e = $(jq).datagrid(‘getColumnOption’, param);

e.editor = {};

}

}

});

另外，更重的一点是 instanceof 可以在继承关系中用来判断一个实例是否属于它的父类型。例如：
// 判断 foo 是否是 Foo 类的实例 , 并且是否是其父类型的实例

function Aoo(){}

function Foo(){}

Foo.prototype = new Aoo();//JavaScript 原型继承
var foo = new Foo();

console.log(foo instanceof Foo)//true

console.log(foo instanceof Aoo)//true

上面的代码中是判断了一层继承关系中的父类，在多层继承关系中，instanceof 运算符同样适用。
console.log(Object instanceof Object);//true

console.log(Function instanceof Function);//true

console.log(Number instanceof Number);//false

console.log(String instanceof String);//false
console.log(Function instanceof Object);//true
console.log(Foo instanceof Function);//true

console.log(Foo instanceof Foo);//false

JavaScript instanceof 运算符代码
function instance_of(L, R) {//L 表示左表达式，R 表示右表达式

var O = R.prototype;// 取 R 的显示原型

L = L.proto;// 取 L 的隐式原型

while (true) {

if (L === null)

return false;

if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true

return true;

L = L.proto;

}

}

Object instanceof Object，Function instanceof Function 和 Foo instanceof Foo 三个示例
Object instanceof Object
// 为了方便表述，首先区分左侧表达式和右侧表达式

ObjectL = Object, ObjectR = Object;

// 下面根据规范逐步推演

O = ObjectR.prototype = Object.prototype

L = ObjectL.proto = Function.prototype

// 第一次判断

O != L

// 循环查找 L 是否还有 proto

L = Function.prototype.proto = Object.prototype

// 第二次判断

O == L

// 返回 true

Function instanceof Function
// 为了方便表述，首先区分左侧表达式和右侧表达式

FunctionL = Function, FunctionR = Function;

// 下面根据规范逐步推演

O = FunctionR.prototype = Function.prototype

L = FunctionL.proto = Function.prototype

// 第一次判断

O == L

// 返回 true

Foo instanceof Foo
// 为了方便表述，首先区分左侧表达式和右侧表达式

FooL = Foo, FooR = Foo;

// 下面根据规范逐步推演

O = FooR.prototype = Foo.prototype

L = FooL.proto = Function.prototype

// 第一次判断

O != L

// 循环再次查找 L 是否还有 proto

L = Function.prototype.proto = Object.prototype

// 第二次判断

O != L

// 再次循环查找 L 是否还有 proto

L = Object.prototype.proto = null

// 第三次判断

L == null

// 返回 false

作者：wespten

来源：CSDN

原文：https://blog.csdn.net/qq_35029061/article/details/83988428

版权声明：本文为博主原创文章，转载请附上博文链接！