java学习——GetType和typeof的区别
 
区别：
 1、Typeof()是运算符而GetType是方法；
 2、GetType()是基类System.Object的方法，因此只有建立一个实例之后才能被调用（初始化以后）；
 3、Typeof()的参数只能是int，String，自定义类型，且不能是实例
 4、Typeof()：得到一个Class的Type; GetType()：得到一个Class的实例的Type

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
 版权声明：本文为博主原创文章，转载请附上博文链接！

 
java里 jvm在运行时采用类型擦拭的做法，类型已经不能单纯的用class来区分了，比如 List 和 List 的class 都是 Class，然而两者类型(type)却是不同的。
 
在Scala里，类型系统又比java复杂很多，它自己提供了一个scala.reflect.runtime.universe.Type
 
在scala用typeOf获取类型信息：
 
scala> import scala.reflect.runtime.universe._
 
scala> class A
 
scala> typeOf[A]
 
res44: reflect.runtime.universe.Type = A
 
同样scala里获取类(Class)信息也很便捷:
 
scala> classOf[A]
 
另外，因为 java 的Object里提供了getClass方法，对于scala 对象来说，也可以用
 
scala> val a = new A
 
scala> a.getClass
 
res53: Class[_ <: a class>
 
注意，typeOf 和 classOf 方法接收的都是类型符号，并不是对象实例
 
scala> object O
 
scala> classOf[O] // 这里O是一个单例对象，是一个实例
 
:14: error: not found: type O
 
对于实例，要获取他的 Class 信息，只有通过 getClass 方法
 
scala> O.getClass
 
res60: Class[_ <: o.type class o>
 
注意到了，上面的 单例对象O 对应的class是 O$ ，你通过 :javap O 也能看到这个单例反编译后是一个名为O$的 java class
 
看上面的返回类型里 用：O.type 表示其类型；实际上 .type之前的都可以看做是一种类型路径，每个实例都可以通过.type方式表达它的单例类型
 
再举一个例子：
 
scala> class A { class B }  // 嵌套类
 
scala> val a1 = new A
 
scala> val a2 = new A
 
scala> val b1 = new a1.B
 
scala> val b2 = new a2.B
 
对于内部类B的实例，它们的class都是相同的: A$B(表示B是A的内部类)
 
scala> b1.getClass
 
res8: Class[_ <: a1.b class a>
 
scala> b1.getClass == b2.getClass
 
res7: Boolean = true
 
而它们的类型却是不同的：
 
scala> typeOf[a1.B] == typeOf[a2.B]
 
res10: Boolean = false
 
这是因为内部类型依赖外部实例(路径依赖类型)，外部实例不同，它们也不同。
 
但还可以对这种类型再抽象
 
scala> typeOf[a1.B] <: typeof>
 
res11: Boolean = true
 
scala> typeOf[a2.B] <: typeof>
 
res12: Boolean = true
 
这里A#B涉及到类型投影的概念，如前所讲。
 
简单的说，类(class)与类型(type)是两个不一样的概念 (在java里因为早期一直使用class表达type，并且现在也延续这样的习惯)；类型(type)比类(class)更”具体”，任何数据都有类型。类是面向对象系统里对同一类数据的抽象，在没有泛型之前，类型系统不存在高阶概念，直接与类一一映射，而泛型出现之后，就不在一一映射了。比如定义class List[T] {}, 可以有List[Int] 和 List[String]等具体类型，它们的类是同一个List，但类型则根据不同的构造参数类型而不同。
 
scala> classOf[List[Int]] == classOf[List[String]](类型擦除)
 
res16: Boolean = true
 
scala> typeOf[List[Int]] == typeOf[List[String]]
 
res17: Boolean = false
 
在jvm里，类的实例都是引用形式，而类型没有这个约束，基础类型int,byte,char等就是非引用的。类型比类更“具体”，更“细”一些。

if (variable1 !== null || variable1 !== undefined || variable1 !== '') { 
var variable2 = variable1; 
} 
 
意思是说如果variable1不是一个空对象，或者未定义，或者不等于空字符串，那么声明一个variable2变量，将variable1赋给variable2。也就是说如果variable1存在那么就将variable1的值赋给variable2，若不存在则为空字符串
 typeof 变量 得到的就是一个变量的类型