精华内容
下载资源
问答
  • JavaScript专题(七)类型转换

    万次阅读 多人点赞 2020-09-23 18:43:46
    类型转换常常为人诟病,但实际上很多时候它们是非常有用的,有些强制类型转换可以明确告诉我们哪里发生了类型转换,有助于提高代码可读性和可维护性。但有些却发生在我们看不见的地方,所以我们今天来讨论一下平时...
    
    

    JavaScript专题之最让人头疼的类型转换

    目录

    前言

    在了解类型转换之前,如果你对 Js 的基本类型仍存在疑惑,不妨看看JavaScript 中的基本数据类型这篇文章哦~

    类型转换常常为人诟病,但实际上很多时候它们是非常有用的,有些强制类型转换可以明确告诉我们哪里发生了类型转换,有助于提高代码可读性和可维护性。但有些却发生在我们看不见的地方,所以我们今天来讨论一下平时常见的类型转换运算和操作~

    一、类型转换是什么?

    我们都知道变量的类型由它存储的值的类型来决定,所以将值从一种类型转换为另一种类型通常称为类型转换(type-casting),而它也可以根据某些特点分成两类

    • 显式类型转换
    • 隐式类型转换。

    显式类型转换

    显式类型转换主要是指通过 String、Number、Boolean 等构造方法转换相应的字符串、数字、布尔值

    const str = String(1);
    const num = Number("123.3"); //number:123.3
    

    这是显式的情况——类型的转换的动作是由我们主动发起的。

    1.2 隐式类型转换
    const newStr1 = 1 + "str"; // '1str'
    const newStr2 = "hello" + [89, 150.156, "mike"]; // 'hello89,150.156,mike'
    

    如果是做 C++、Java 以及其他强类型语言的同学写到类似的组合,应该就会报错了,但在 Js 中不会。

    既然隐式类型转换会一直存在下去,我们就要接受它并去了解它的优缺点!

    二、转换的基本规则

    有些数据类型之间的转换,会经历“多道工序”,我们尽量先介绍“工序”少的~

    2.1 原始值转字符串

    我们使用 String 函数将类型转换成字符串类型,如果 String 函数不传参数,返回空字符串,如果有参数,调用 ToString(value),而 ToString 也给了一个对应的结果表。表如下:

    规则:

    参数类型 返回
    Undefined “undefined”
    Null “null”
    Boolean 如果参数是 true,返回 “true”。参数为 false,返回 “false”
    Number 结果有很多种,例如 NaN 和 Infinity
    String 返回与之相等的值

    举例:

    console.log(String()); // 空字符串
    console.log(String(undefined)); // undefined
    console.log(String(null)); // null
    console.log(String(false)); // false
    console.log(String(true)); // true
    
    // Number
    console.log(String(0)); // 0
    console.log(String(-0)); // 0
    console.log(String(NaN)); // NaN
    console.log(String(Infinity)); // Infinity
    console.log(String(-Infinity)); // -Infinity
    console.log(String(1)); // 1
    
    2.2 原始值转数字

    有时我们需要将非数字值当作数字来使用,比如数学运算。为此 ES5 规范在 9.3 节定义了抽象操作ToNumber,类似 ToString,它也有一定的转换规则:

    参数类型 返回
    true 1
    false 0
    undefined NaN
    null 0
    String 返回与之相等的值,但如果处理失败则返回 NaN
    console.log(Number(true)); // 1
    console.log(Number(false)); // 0
    console.log(Number(undefined)); // NaN
    console.log(Number("余光")); // NaN
    console.log(Number("1")); // 1
    
    2.3 原始值转布尔

    我们使用 Boolean 函数将类型转换成布尔类型,在 JavaScript 中,只有 6 种 值可以被转换成false,其他都会被转换成true

    console.log(Boolean()); // false
    console.log(Boolean(false)); // false
    console.log(Boolean(undefined)); // false
    console.log(Boolean(null)); // false
    console.log(Boolean(+0)); // false
    console.log(Boolean(-0)); // false
    console.log(Boolean(NaN)); // false
    console.log(Boolean("")); // false
    
    2.4 原始值转对象

    原始值到对象的转换非常简单,原始值通过调用 String()、Number() 或者 Boolean() 构造函数,转换为它们各自的包装对象

    nullundefined 属于例外,当将它们用在期望是一个对象的地方都会造成一个类型错误 (TypeError) 异常,而不会执行正常的转换。

    var a = 1;
    console.log(typeof a); // number
    var b = new Number(a);
    console.log(typeof b); // object
    

    三、对象转字符串和数字

    3.0 对象转布尔值

    3.0 这一小节是我认为值得一提,但篇幅较少的一点:

    对象到布尔值的转换非常简单:所有对象(包括数组和函数)都转换为 true。对于包装对象也是这样,举个例子:

    console.log(Boolean(new Boolean(false))); // true
    
    3.1 对象的 toString 和 valueOf

    这是一个不太常见的操作,或者说现象,但我们也不能忽略它。

    1. 对象=>字符串
    2. 对象=>数字

    转换都是通过调用待转换对象的一个方法来完成的,在 Js 中,一般待转换对象拥有两个方法:

    1. toString
    2. valueOf

    toString

    所有的对象除了nullundefined之外的任何值都具有toString方法,通常情况下,它和使用String方法返回的结果一致。

    JavaSciprt 专题之类型检测中我们提到过Object.prototype.toString 方法会根据这个对象的[[class]]内部属性,返回由 "[object " 和 class 和 “]” 三个部分组成的字符串。举个例子:

    const obj = { name: "余光" };
    obj.toString(); // "[object Object]"
    
    obj.toString === Object.prototype.toString; // true
    

    我们已经验证了 => 对象调用 toString 方法是调用其构造函数原型上的方法

    其他数据类型的 toString 方法也都有自己的特点:

    • 数组:将每个数组元素转换成一个字符串,并在元素之间添加逗号后合并成结果字符串。
    • 函数:返回源代码字符串。
    [1, 2, 3, 4].toString(); // "1,2,3,4"
    [].toString(); // ""
    
    function func() {
      console.log();
    }
    func.toString(); // "function func () { console.log() }"
    

    valueOf

    valueOf 方法返回这个对象本身,数组、函数、正则简单的继承了这个默认方法,也会返回对象本身。日期是一个例外,它会返回它的一个内容表示: 1970 年 1 月 1 日以来的毫秒数。

    var date = new Date(2017, 4, 21);
    console.log(date.valueOf()); // 1495296000000
    
    3.2 对象转字符串和数字的基本规则

    在我们知道了 toString()和 valueOf()这两个方法后,来看看转换的规则,即什么时候用:ES5 规范 9.8

    参数类型 结果
    Object 1. primValue = ToPrimitive(input, String)
    2. 返回 ToString(primValue)

    所谓的 ToPrimitive 方法,其实就是输入一个值,然后返回一个一定是基本类型的值。

    我们总结一下,当我们用 String 方法转化一个值的时候:

    1. 基本类型:参照 “原始值转字符” 的对应表
    2. 引用类型:调用一个ToPrimitive方法,将其转为基本类型,然后再参照 “原始值转字符” 的对应表进行转换。

    其实,从对象到数字的转换也是一样:

    参数类型 结果
    Object 1. primValue = ToPrimitive(input, Number)
    2. 返回 ToNumber(primValue)

    注意:转字符和数字的时候处理略有不同~

    3.3 ToPrimitive

    那接下来就要看看 ToPrimitive 了,ES5 规范 9.1

    这个返回原始值的方法接受一个输入参数 和一个可选的参数来表示转换类型:

    1. input,表示要处理的输入值
      • 如果传入的 input 是 Undefined、Null、Boolean、Number、String 类型,直接返回该值。
    2. PreferredType,非必填,表示希望转换成的类型,有两个值可以选,Number 或者 String。
      • 当不传入 PreferredType 时,如果 input 是日期类型,相当于传入 String,否则,都相当于传入 Number。
    如果是 ToPrimitive(obj, Number),处理步骤如下:
    • 如果 obj 为 基本类型,直接返回
    • 否则,调用 valueOf 方法,如果返回一个原始值,则 JavaScript 将其返回。
    • 否则,调用 toString 方法,如果返回一个原始值,则 JavaScript 将其返回。
    • 否则,JavaScript 抛出一个类型错误异常。
    如果是 ToPrimitive(obj, String),处理步骤如下:
    • 如果 obj 为 基本类型,直接返回
    • 否则,调用 toString 方法,如果返回一个原始值,则 JavaScript 将其返回。
    • 否则,调用 valueOf 方法,如果返回一个原始值,则 JavaScript 将其返回。
    • 否则,JavaScript 抛出一个类型错误异常。

    所以总结下,对象转字符串(就是 Number() 函数)可以概括为:

    举个例子:

    console.log(Number({})); // NaN
    console.log(Number({ a: 1 })); // NaN
    
    console.log(Number([])); // 0
    console.log(Number([0])); // 0
    console.log(Number([1, 2, 3])); // NaN
    console.log(
      Number(function() {
        var a = 1;
      })
    ); // NaN
    console.log(Number(/\d+/g)); // NaN
    console.log(Number(new Date(2010, 0, 1))); // 1262275200000
    console.log(Number(new Error("a"))); // NaN
    

    注意:

    • 转换对象时,你会发现它变成了 NaN,所以

    • 在这个例子中,[][0]都返回了 0

      • 当我们 Number([]) 的时候,先调用 []valueOf 方法,此时返回 []
      • 因为返回了一个对象,所以又调用了 toString 方法;
      • 此时返回一个空字符串,接下来调用 ToNumber 这个规范上的方法;
      • 等价于 Number([].valueOf().toString()),结果为 0;
    • [1, 2, 3] 却返回了一个 NaN:

      • 当我们 Number([]) 的时候,先调用 [1,2,3]valueOf 方法,此时返回 [1,2,3];
      • 因为返回了一个对象,所以又调用了 toString 方法;
      • 此时为1,2,3,接下来调用 ToNumber 这个规范上的方法;
      • 等价于 Number([1,2,3].valueOf().toString()),结果为 NaN;

    四、涉及到类型转换的运算符

    读到这里我们对类型转换有了一定的概念,现在我们再来看看在运算中常见的类型转换问题。

    4.1 一元操作符 +

    +a 运算符显式地将后面的变量 a 保存的数据转换为数字,不是字符串拼接。
    查看 ES5 规范 11.4.6,会调用 ToNumber 处理该值,相当于 Number(‘1’),最终结果返回数字 1。

    const a = "1.1";
    const b = 5 + +a;
    console.log(b); // 6.6
    

    上面的代码应该是我们经常用到的,当我们知道一个字段是字符串但希望它是数字时,一般会这么做~

    我们一起验证下下面这些类型

    console.log(+[]); // 0
    console.log(+["1"]); // 1
    console.log(+["1", "2", "3"]); // NaN
    console.log(+{}); // NaN
    

    既然是调用 ToNumber 方法我们在之前的小节中提到过

    • 如果 obj 为基本类型,直接返回
    • 否则,调用 valueOf 方法,如果返回一个原始值,则 JavaScript 将其返回。
    • 否则,调用 toString 方法,如果返回一个原始值,则 JavaScript 将其返回。
    • 否则,JavaScript 抛出一个类型错误异常。
    • +[] 为例,[] 调用 valueOf 方法,返回一个空数组,因为不是原始值,调用 toString 方法,返回 ""
    • 得到返回值后,然后再调用 ToNumber 方法,"" 对应的返回值是 0,所以最终返回 0。
    4.2 一元操作符 !

    一元运算符!显式地将值强制类型转换为布尔值。但是它同时还将真值反转为假值(或者将假值反转为真值)。

    const a = 1;
    const b = "str";
    const c = [1, 2, 3];
    
    console.log(!a); // false
    console.log(!b); // false
    console.log(!c); // false
    
    console.log(!0); // true
    console.log(!""); // true
    console.log(![]); //false
    
    console.log(![]); //false
    console.log(!undefined); // true
    console.log(!null); // true
    

    同样的 !! 会讲其他类型转成对应的 bool 值

    !和 + 运算符是我们最常用的两种显式类型转换运算符,之后我们再看看那些不经意间就被转换类型的操作~

    五、常见的类型转换操作

    5.1 字符串和数字之间
    const num = 1;
    const str = "200";
    
    console.log(num + str); // '1200'
    

    这段代码大家应该都知道结果,但是其中的原理是否和大家想的一样呢?

    const arr1 = [1, 2];
    const arr2 = [3, 4];
    
    console.log(arr1 + arr2); // 1,23,4
    

    两个数组的结果为什么也是个字符串?

    原因

    ES5 规范 11.6.1 中提到,如果某个操作数是字符串或者能通过以下步骤转换为字符串,+将进行拼接操作

    如果其中的一个操作数是引用类型,则首先对其进行ToPrimitive操作(第三小节有提)

    总结

    简单来说就是,如果+的其中一个操作数是字符串(或者通过以上步骤可以得到字符串),则执行字符串拼接;否则执行数字加法。

    5.2 被转换成布尔值的操作

    现在我们来看看到布尔值的隐式强制类型转换,它最为常见也最容易搞错。相对布尔值,数字和字符串操作中的隐式强制类型转换还算比较明显。

    下面的情况会发生布尔值隐式强制类型转换。

    • if (…)语句
      • 括号内的条件为true时执行操作;
    • for ( let i = 0; i < 10; i++ )
      • 语句中的条件判断表达式即 i < 10 为true
    • while (…)和 do…while(…)
      • 循环中的条件判断表达式为true;
    • 三目运算 ? :
    • 逻辑运算符 ||(逻辑或)和 &&(逻辑与)左边的操作数;
    5.3 == 和 ===

    谈到类型转换,一定绕不开 =====

    ==用于比较两个值是否相等,当要比较的两个值类型不一样的时候,就会发生类型的转换。

    ES5 规范 11.9.5 中简述了它的规则:

    当执行 x == y 时:

    • 如果 x 与 y 是同一类型:
      • x 是 Undefined,返回 true
      • x 是 Null,返回 true
      • x 是数字:
        • x 是 NaN,返回 false
        • y 是 NaN,返回 false
        • x 与 y 相等,返回 true
        • x 是+0,y 是-0,返回 true
        • x 是-0,y 是+0,返回 true
      • x 是字符串,完全相等返回 true,否则返回 false
      • x 是布尔值,x 和 y 都是 true 或者 false,返回 true,否则返回 false
      • x 和 y 指向同一个对象,返回 true,否则返回 false
    • x 是 null 并且 y 是 undefined,返回 true
    • x 是 undefined 并且 y 是 null,返回 true
    • x 是数字,y 是字符串,判断 x == ToNumber(y)
    • x 是字符串,y 是数字,判断 ToNumber(x) == y
    • x 是布尔值,判断 ToNumber(x) == y
    • y 是布尔值,判断 x ==ToNumber(y)
    • x 不是字符串或者数字,y 是对象,判断 x == ToPrimitive(y)
    • x 是对象,y 不是字符串或者数字,判断 ToPrimitive(x) == y
    参考

    在这里插入图片描述

    写在最后

    JavaScript 系列:

    1. 《JavaScript 内功进阶系列》(已完结)
    2. 《JavaScript 专项系列》(持续更新)

    关于我

    • 花名:余光(沉迷 JS,虚心学习中)
    • WX:j565017805

    其他沉淀

    如果您看到了最后,对文章有任何建议,都可以在评论区留言

    这是文章所在 GitHub 仓库的传送门,如果真的对您有所帮助,希望可以点个 star,这是对我最大的鼓励 ~

    展开全文
  • java中long类型转换为int类型 由int类型转换为long类型是向上转换,可以直接进行隐式转换,但由long类型转换为int类型是向下转换,可能会出现数据溢出情况: 主要以下几种转换方法,供参考: 一、强制类型转换 ...

    java中long类型转换为int类型

          由int类型转换为long类型是向上转换,可以直接进行隐式转换,但由long类型转换为int类型是向下转换,可能会出现数据溢出情况:

          主要以下几种转换方法,供参考:

    一、强制类型转换

    [java]  

    long ll = 300000;  

    int ii = (int)ll;  

    二、调用intValue()方法

    [java]  

    long ll = 300000;  

    int ii= new Long(ll).intValue();  

    三、先把long转换成字符串String,然后在转行成Integer

    [java]  

    long ll = 300000;  

    int ii = Integer.parseInt(String.valueOf(ll)); 

    这三种方法都比较简单明了。

    美文美图

     

    展开全文
  • 类型转换类型转换函数

    千次阅读 2018-02-03 21:31:05
    所以类型转换,就是为了告诉编译器这部分内存,应该用什么方式去解释它,如何组织这段内存。 1、C风格类型转换 c语言比较熟悉,指针类型的转换很常见。通过圆括号和标识符组成(type) expression。允许任何类型...

    所以类型转换,就是为了告诉编译器这部分内存,应该用什么方式去解释它,如何组织这段内存。

    1、C风格类型转换

    c语言比较熟悉,指针类型的转换很常见。通过圆括号和标识符组成(type) expression。允许任何类型之间的转换过于粗鲁并且在程序语句中难以识别(主要是人工阅读代码可能难以分辨而已,因为C++语法复杂)。所以c++定义了四种类型转换,解决上述缺点。

    2、C++风格类型转换

    使用格式cast-name<type>(expression)
    1、 static_cast
      功能上基本和C风格类型转换一样,含义也相同,但是不能从表达式中去除const属性。

    voidf *p;
    double *dp = static_cast<double *>(p); 

    2、const_cast
      类型转换掉表达式的const属性,将常量对象转换成非常量对象的行为,此时编译器不会阻止用户对该对象写操作。

    const  char *p;
    char *q = const_cast<char *>(p);//正确
    char *pq = static_cast<char *>(p);//错误,只可通过const_cast转换

    3、dynamic_cast
      运行时类型识别,被用于安全地沿着类的继承关系向下进行类型转换。这就是说,你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用,而且你能知道转换是否成功。失败的转换将返回空指针(当对指针进行类型转换时)或者抛出异常(当对引用进行类型转换时)。它不能被用于缺乏虚函数的类型上,也不能用它来转换掉常量属性。

    class Widget{};//内部含有虚函数
    class SpecialWidget:public Widget{};
    Widget *pw = new SpecialWidget;
    SpecialWidget *psw = dynamic_cast<SpecialWidget *>(pw);//成立
    

    4、reinterpret_cast
      通常用于函数指针之间的转换,这种转换代码移植性很差,最好不使用。

    typedef void (*FUNPTR)();//函数指针类型
    int doSometing();
    FUNPTR funcptr = reinterpret_cast<FUNPTR>(doSometing);//这种转换可以通过编译器,但是我们为什么需要这种垃圾转换了,除非非常理解底层结构。

    2、类型转换函数

    当类型不匹配的时候,C++编译器通常会进行相应的类型转换。

    1. 内置类型隐式转换
      如c++支持char隐式转换成int,short隐式转换double等,这些都是语言特性造成,不受我们控制无法改变。
    2. 自定义类
      当类型不匹配时,编译器也会首先考虑隐式转换但是需要调用对应的转换函数。C++规定两种函数可以作为隐式的类型转换函数:单参数构造函数和隐式类型转换运算符。

    单参数构造函数:是指只用一个参数即可以调用的构造函数。该函数可以是只定义了一个参数,也可以是虽然定义了多个参数但第一个参数以后的所有参数都有缺省值。总之,编译器需要调用对应的函数。

    class Name {
    public:
        Name(const string& s); 
    };
    void Display(Name a);
    string s("Hello Name");
    Display(s);//这里会进行隐式转换,通过Name构造函数生成临时对象,传递进去。

    隐式类型转换运算符:也是一个函数。operator type()

    class Rational {
    public:
    operator double() const; //类型转换运算符,转换Rational类成double
    };
    Rational r(1,2);
    double d = 0.5*r;//编译器自动调用使r转换成double

    3、避免定义类型转换函数

    可能当你在不需要使用转换函数时,这些的函数却会被编译器调用运行。结果这些不正确的程序会出现问题而又无法判断出原因。

    1、首先解决类型转换运算符
      用不使用语法关键字的等同的函数来替代转换运算符,明确调用对应的函数,而避免编译器自动调用。库函数中的string类型没有包括隐式地从string转换成C风格的char*的功能,而是定义了一个成员函数c_str用来完成这个转换。
    2、解决通过单参数构造函数进行隐式类型转换
      C++编译器支持explicit关键字,禁止编译器自动调用相应的构造函数进行隐式转换。暂时理解这个方法即可,其他其淫无比的技巧放放吧。

    template<class T>//模板数组
    class Array {
    public:
        Array(int lowBound, int highBound);//不可做隐式转换函数
        Array(int size);//数组维度,可做隐式转换函数
        T& operator[](int index);
        bool operator==( const Array<int>& lhs,const Array<int>& rhs);
    };
    
    Array<int> a(10),b(10);
    
    if(a == b[i])
    {
    
    }
    /*
    因为隐式转换,出现大问题。b[i]是int类型,a是Array<int>类型。然后调用operator==函数。于是编译器通过构造函数将int转换成Array<int>临时对象,产生错误,致命bug。
    通过explicit关键字声明构造函数,那么这里编译器就会报错,而不会通过。
    */
    展开全文
  • 自动类型转换

    万次阅读 2019-02-01 19:51:57
     在java 程序中,不同的基本类型的值经常需要进行相互类型转换类型转换分为自动类型转换和强制类型转换。布尔类型boolean占有一个字节,由于其本身所代码的特殊含义,boolean类型与其他基本类型不能进行类型的...

    (一)自动类型转换

         在java 程序中,不同的基本类型的值经常需要进行相互类型转换,类型转换分为自动类型转换和强制类型转换。布尔类型boolean占有一个字节,由于其本身所代码的特殊含义,boolean类型与其他基本类型不能进行类型的转换(既不能进行自动类型的提升,也不能强制类型转换), 否则,将编译出错。

        java的所有数值型变量可以进行相互转换,如果系统支持把某种基本类型的值直接赋值给另一种基本类型的变量,则这种方式成为自动类型转换。

         当把一个表数范围较小的数值或变量直接赋给另外一个表数范围比较大的变量时,系统将可以自动类型转换,否则需要强制转换。

        图中箭头左边的数值可以自动转换为右边的数值。

           (2)byte型可以转换为short、int、、long、float和double; 
      (3)short可转换为int、long、float和double; 
      (4)char可转换为int、long、float和double; 
      (5)int可转换为long、float和double; 
      (6)long可转换为float和double; 
      (7)float可转换为double; 

     

    (二)基本类型转换为字符串

    不仅如此,把任何基本类型的值和字符串进行连接运算时,基本类型的值将自动转换成为字符串类型,虽然字符串类型不是基本类型,而是引用类型。因此,如果想将基本类型的值转换为对应的字符串,可以把基本类型的值和一个空字符串进行连接。

     

       (三)强制类型转换

         强制类型转换,即强制显示的把一个数据类型转换为另外一种数据类型。

        如果希望图中箭头右边的类型转换为左边的类型,则必须进行强制类型转换,强制类型转换的格式:

      (targetValuevalue

        强制类型转换的运算符是圆括号,当进行强制类型转换的时候,类似把一个大瓶里的水倒入一个小瓶子,如果大瓶子里的水不多还好,如果大瓶子了的水很多,将会引起溢出,从而造成数据丢失这种转换也被称为缩小转换。

    (四)表达式的自动提升

       当一个算数表达式中包含多个基本类型的值的时候 ,整个算数表达式的数据类型将发生自动提升。java定义了如下的自动提升规则:     1 所有的byte类型,short类型和char类型将被提升到int类型。     2 整个算数表达式的数据类型自动提升到与表达式中最高等级操作数同样的类

    (五)总结

    1    java中整数类型默认是int类型,小数类型默认是double类型。

    2    char可以当做一种特殊的整数类型

    3    int无法转换为boolean

    4    小数类型转为整数类型,小数可能被舍弃,出现精度损失,所以需要强制转换。

    5    boolean 类型不能转换为其它数据类型。

     

     

    展开全文
  •  在问题类型转换中,short a = 1;把int类型转为short类型推翻了转换类型中的,大转小的理论,其实不然。与float f = 3.4 中double float转为float 大转小报错,展开深入研究。 2.基本1.Java类型转换 Java类型...
  • C++ 类型转换

    千次阅读 2017-08-17 19:03:25
    隐式类型转换 1 数值类型转换 2 指针类型转换 显式类型转换 1 explicit关键字 1 强制类型转换 11 static_cast 12 dynamic_cast 13 const_cast 14 reinterpret_cast 参考资料 C++类型转换大体上包括隐式类型转换和...
  • JS数据类型转换

    万次阅读 2019-06-23 14:48:41
    首先我们要知道,在 JS 中类型转换只有三种情况,分别是: 转换为布尔值 转换为数字 转换为字符串 我们先来看一个类型转换表格,然后再进入正题 转Boolean 在条件判断时,除了 undefined, null, false, NaN, ...
  • Java 类型转换

    万次阅读 2019-05-17 08:11:26
    一、自动类型转换(隐式类型转换) 整型、实型(常量)、字符型数据可以混合运算。不同类型的数据先转化为同类型再进行运算 自动转换按从低级到高级顺序: char ↓ Byte→short→int→long---›float→double ...
  • JAVA中显式类型转换和隐式类型转换

    千次阅读 2018-07-27 16:00:05
    自动类型转换(隐式类型转换),由系统自动完成的类型转换。从存储范围小的类型到存储范围大的类型。由于实际开发中这样的类型转换很多,所以Java语言在设计时,没有为该操作设计语法,而是由JVM自动完成。 转换...
  • C++ 强制类型转换和赋值中的类型转换

    万次阅读 多人点赞 2017-02-02 12:11:45
    强制类型转换原C语言的形式:(类型名)(表达式)比如:(double)a //把a转换为double类型 (int)(a+b) //把a+b的值转换为整型需要注意的是:如果强制类型转换的对象是一个变量,那么该变量不需要用括号括起来;但是如果...
  • 【python】str与json类型转换

    万次阅读 2017-07-13 21:21:24
    避免不了数据类型转换,比如强制转换string类型,比如转json类型str转jsonpython字符串转json对象,需要使用json模块的loads函数import json str = '{"accessToken": "521de21161b23988173e6f7f48f9ee96e28", ...
  • 在我们学习c语言的时候,就知道强制类型转换和隐式类型的转换,但是在类型转换的过程中,很有可能一个不注意,容易出问题,这无疑是加大了,程序员的工作量,而且还检查很不好检查。 所以在c++ 中就对类型的转换做...
  • java 类型转换

    千次阅读 2019-01-10 14:35:03
    自动类型转换:小的转换大的 如long s = 20; double d=12.0f 强制类型转换:可以把大的数据转换小的float f=(float)12.0;int a=(int)200L 对java对象的强制类型转换称为造型: 从子类到父类的类型转换可以自动...
  • c++类型转换

    千次阅读 2019-05-29 19:45:08
    类型转换有 c 风格的,当然还有 c++风格的。c 风格的转换的格式很简单(TYPE) EXPRESSION,但是 c 风格的类型转换有不少的缺点,有的时候用 c 风格的转换是不合 适的,因为它可以在任意类型之间转换,比如你可以把一...
  • 类型转换 JS 数据类型 通过函数进行类型转换 String Number 之间的想换转换 自动类型转换 目录导航 类型判断 typeof JS 中可以使用关键字 typeof 判断 demo typeof "hello" typeof ...
  • C++中如何将char类型转换为String 类型。。。
  • JS类型转换

    千次阅读 2018-09-25 17:38:57
    1.强制类型转换 强制类型转换指将一个数据类型强制转换成另一种数据类型。类型转换主要指将其他的数据类型转换成String Number Boolean。 (1)将其他数据类型转换成String类型 方法一:调用被转换类型的toString()...
  • 1.背景 在Java中,之所以需要强制类型转换是为了防止程序员在不知情的情况下把A类型数据错当成B类型的数据。将一种类型的值赋给另一个类型的变量是很常见的,如果这两种是兼容的,那么Java将执行自动转换,例如int...
  • 1、基础类型转换(string转number类型,number转string类型) class TypeChange { constructor() { this.print(); } age: number = 20; ageStr: string = "20"; ageNull: string; public print...
  • mysql数据类型转换

    千次阅读 2018-09-28 09:23:36
    mysql数据类型转换 数字类型转换字符串类型 1、将Int 转为varchar经常用 concat函数,concat(xxx,类型) 比如: concat(8,’0′) 得到字符串 ’80′ 比如将123转换为char类型 SELECT CAST(123 AS CHAR); ...
  • C#的隐式类型转换和显式类型转换

    千次阅读 2016-03-27 11:54:15
    C#的隐式类型转换和显式类型转换 C#的隐式类型转换  在C#语言中,一些预定义的数据类型之间存在着预定义的转换。比如,从int类型转换到long类型。C#语言中数据类型的转换可以用分为两 类:隐式转换(implicit ...
  • 在JavaScript中声明变量不需指定类型, 对变量赋值也没有类型检查,同时JavaScript允许隐式类型转换。这些特征说明JavaScript属于弱类型的语言。 (1).转换为字符串 转换为字符串是应用程序中的常见操作,...
  • 隐式类型转换

    千次阅读 2019-03-07 20:55:57
    隐式类型转换 定义: C++ 的基本类型中并非是完全的对立,部分数据类型之间是可以进行隐式转换的。隐式转换指的是不需要用户干预,编译器私下进行的类型转换行为。很多时候用户可能都不知道发生了哪些转换。 为何要...
  • java自动类型转换与强制类型转换

    千次阅读 2018-02-03 16:41:40
    自动类型转换就是自发的进行,你可以从输出的结果看出,外表是看不出来的。我们知道数据类型有很多种,大小也不一样,就像水桶似的,有1升的,2升的,4升的,自动类型转换就相当于把小的水桶里面的水装到大的里面去...
  • Java基本数据类型转换与java基本类型转换优先级转换类型1. 自动类型转换: 编译器自动完成类型转换,不需要再程序中编写代码转换规则: 从存储范围小的类型到存储范围大的类型具体规则 : byteàcharàshortàintàlong...
  • 自动类型转换规则: 强制类型转换: 代码示例: package com.jredu.ch02; public class Ch04 { public static void main(String[]args){ //自动类型转换 //基本数据的自动类型转换只有7种...
  • C#中自定义类型转换

    千次阅读 2018-01-19 18:55:58
    类型转换
  • 本文谈谈JavaScript的类型转换,我们知道在JavaScript中声明变量不需指定类型, 对变量赋值也没有类型检查,同时JavaScript允许隐式类型转换。这些特征说明JavaScript属于弱类型的语言。 在强类型的C++中,多数情况...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 195,642
精华内容 78,256
关键字:

类型转换