精华内容
下载资源
问答
  • java学习——GetType和typeof的区别

    万次阅读 2018-11-26 22:40:07
    java学习——GetType和typeof的区别 区别: 1、Typeof()是运算符而GetType是方法; 2、GetType()是基类System.Object的方法,因此只有建立一个实例之后才能被调用(初始化以后); 3、Typeof()的参数只能是int,...

    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 表示一个类或者一个...

    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 就是判断一个实例是否属于某种类型。例如:

    . e x t e n d ( .extend( .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在运行时采用类型擦拭的做法,类型已经不能单纯的用...在Scala里,类型系统又比java复杂很多,它自己提供了一个scala.reflect.runtime.universe.Type在scala用typeOf获取类型信息:scala> import scala...

    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等就是非引用的。类型比类更“具体”,更“细”一些。

    展开全文
  • Java语言里怎么实现sizeof idof typeof methodof 和 instanceof 这几个方法呢
  • if (variable1 !== null || variable1 !== undefined || variable1 !== '') { var variable2 = variable1; } 意思是说如果variable1不是一个空对象,或者未定义,或者...typeof 变量 得到的就是一个变量的类型
    if (variable1 !== null || variable1 !== undefined || variable1 !== '') { 
    var variable2 = variable1; 
    } 
    

    意思是说如果variable1不是一个空对象,或者未定义,或者不等于空字符串,那么声明一个variable2变量,将variable1赋给variable2。也就是说如果variable1存在那么就将variable1的值赋给variable2,若不存在则为空字符串
    typeof 变量 得到的就是一个变量的类型

    展开全文
  • 高分悬赏:Java语言中的typeid、typeof分别有什么作用,实际开发的运用如何
  • 经常会在js里用到数组,比如 多个名字相同的input, 若是动态生成的, 提交时就需要判断其是否是数组. if(document.mylist.length !... 运算数为数字 typeof(x) = “number” 字符串 typeof(x) = “string” 布尔值
  • 类型转换 typeof

    2020-03-22 13:54:30
    typeof(***)返回内部的类型,返回的值的类型是string typeof(undefine) --> "undefine" typeof(typeof(undefine)) -->"string" parseInt() 截断 转number 10px -> 10 tofix() 科学计数法保留几位 四舍五入 ...
  • javascript中typeof的使用</title> [removed] //1、基本类型 var x = 123; var y = “abc”; var z = true; //alert(typeof x);//number //alert(typeof y);//string //alert(typeof z&#...
  • typeof和instanceof

    2018-12-06 17:39:22
    在 JavaScript 中,判断一个变量的类型尝尝会用 typeof ...ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。instanceof 运算符与 typeof 运算符相似,用于识别正在处理的对象的类型。与 typeof 方...
  • typeof与instanceof

    2018-10-09 17:49:45
    在 JavaScript 中,判断一个变量的类型尝尝会用 typeof ...ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。instanceof 运算符与 typeof 运算符相似,用于识别正在处理的对象的类型。与 typeof 方...
  • typeof用以获取一个变量的类型,typeof一般只能返回如下几个结果:number,boolean,string,function,object,undefined。我们可以使用typeof来获取一个变量是否存在,如 if(typeof a != “undefined”){},而不要去...
  • typeof 与 instanceof

    2010-06-07 14:40:04
    typeof 用于区分原始...java"] var s = “Nicholas”; var b = true; var i = 22; var u; var n = null; var o = new Object(); alert(typeof s); //string alert(typeof i); //number alert(typeo...
  • typeof返回的类型

    千次阅读 2018-03-19 19:43:25
    返回有六种类型:number, boolean, string, ...typeof(10); typeof(NaN); //NaN在JavaScript中代表的是特殊非数字值,它本身是一个数字类型。 typeof(Infinity); 2.boolean typeof(true); typeof(false); 3....
  • 14typeof

    2019-01-13 22:15:24
    <!... ...console.log(typeof name);...console.log(typeof age);...console.log(typeof bool);...console.log(typeof arr);...typeof {name:'jhk',age:34}// 返回对象object类型 */  <!-- --> </html>
  • 对于instanceof和typeof,以前偶尔的用到过,特别是typeof用到的相对更多一些,今日研究ext源码,很多地方都用到了instanceof,突然觉得他们两个有些相似但也应该有他们区别,网上看了一些文章,对它们之间的关系有...
  • typeof用法总结

    2020-03-23 12:44:43
    1 .typeof 参数是变量或表达式 #define min(x, y) ({ \ typeof(x) _min1 = (x); \ typeof(y) _min2 = (y); \ (void) (&_min1 == &_min2); \ _min1 < _min2 ? _min1 : _min2; }) 当x的类型为是...
  • typeof和instanceof用法

    2016-08-22 14:25:43
    一、typeof用法 typeof 是一个一元运算,放在一个运算数之前,运算数可以是任意类型。 它返回值是一个字符串,该字符串说明运算数的类型。typeof 一般只能返回如下几个结果: number,boolean,string,function...
  • js属性typeof详解

    2018-12-06 11:39:56
    js中一切(引用类型)都是对象,值类型不是对象。 引用类型:函数、数组、对象、null、new Number(5) 值类型:undefined, ...typeof属性 function showType() { console.log(typeof x); // undefined ...
  • typeof的用法汇总

    千次阅读 2014-11-18 09:42:14
    JavaScript中的typeof其实非常复杂,它可以用来做很多事情,但同时也有很多怪异的表现.本文列举出了它的多个用法,而且还指出了存在的问题以及解决办法. > typeof undefined 'undefined' > typeof null // well-...
  • typeof与instanceof的区别

    2018-10-23 21:27:40
    typeof与instanceof的区别 一、typeof typeof是一个一元运算,放在一个运算数之前,运算数可以是任意类型。 它返回值是一个字符串,该字符串说明运算数的类型。(typeof 运算符返回一个用来表示表达式的数据类型的...
  • typeof aColors[0]); //output “string” alert(aColors[0] instanceof String); //output “false”; [removed] 你要区分string 与 String的区别 aColors[0] 是 string值类型, 当然不是String的实例...
  • typeof用来检测给定变量的数据类型(也可叫做基本类型,基本数据类型。包含undefined、boolean、string、number、object、function)var message = “so easy”;alert(typeof message); //”string”alert(...
  • typeof ECMAScript 有 5 种原始类型(primitive type),即 Undefined、Null、Boolean、Number 和 String。我们都知道可以使用typeof运算符求得一个变量的类型,但是对引用类型变量却只会返回object,也就是说typeof...
  • typeof关键字简介

    2012-10-09 13:06:57
    typeof关键字是C语言中的一个新扩展。只要可以接受typedef名称,Sun Studio C 编译器就可以接受带有typeof的结构,包括以下语法类别: 声明 函数声明符中的参数类型链表和返回类型 类型定义 类型操作符s sizeof...
  • c# typeof This post is so I can search my blog for it later. For whatever reason I always forget this and find myself trying to remember what... 这篇文章是为了以后可以在我的博客中搜索。 无论出于什么...
  • 在 javascript 中,判断一个变量的类型可以用 typeof 1、数字类型、typeof 返回的值是 number。比如说:typeof(1),返回值是 number 2、字符串类型,typeof 返回的值是 string。比如 typeof(“123”返回值时 ...
  • 写javascirpt代码时,typeof和instanceof这两个操作符时不时就会用到,堪称必用。但是!使用它们总是不能直接的得到想要的结果,非常纠结,普遍的说法认为“这两个操作符或许是javascript中最大的设计缺陷,因为几乎...
  • typeof :由于js是弱类型的语言,在程序执行中,很容易就出现很多隐性的数据类型的变换,在有些时候,这些隐性的变换很容易就会造成一些不必要的困扰(比如在数据判断的时候使用 “===” 如果数据类型不匹配就是false...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,402
精华内容 18,160
关键字:

java的typeof

java 订阅