JavaScript之隐式类型调换,js基本数据类型的七拾二变

By admin in 4858美高梅 on 2019年5月5日

js +

布尔操作符(!、&&、||)

当使用 规范推断语句(if…else) 以及 布尔操作符(!、&&、||)
时,会调用Boolean()进行隐式类型转变

  • 转换为false的有:0, null, undefined, NaN, ”, false
  • 此外都为true([], {}为true)

    ![]; // !Boolean([]); ————> false
    !2; // false

    !null; // !Boolean(null); ————> true
    !undefined; // true
    !0; // true

    if([]) consolo.log(‘true’); // if(Boolean([])) … ———–> true

js中数据类型分为三种,第1种为主的数据类型:Number,String,Boolean,Null,Undefiend;

[0]5种数据类型:

比如表明最实惠了…

 

其次种是良莠不齐的数据类型,统称object(引用类型)。

    [0.1]中央数据类型:Undefined、Null、Boolean、Number、String

“11”+1=’111′

乘/除法操作符(*、/)

  • 若有三个操作数为NaN,则结果为NaN
  • 若里面1个操作数不为数字,则调用Number()将其更改为数值

    2 ‘5’; // 10
    2
    ‘5a’; // 2 Number(‘5a’) ——–> 2 NaN ————> NaN


       
[0.1.1]基本类型值是指轻松的数据段,5种为主类型是按值访问的,因为能够操作保存在变量中的实际值

“11”+’1’=”111″

 

大约说一下主干数据类型,不详细介绍了

       
[0.1.2]基本项目标值在内部存款和储蓄器中攻陷一定大小的空中,被封存在栈内部存款和储蓄器中。从多个变量向另3个变量复制基本项目的值,会创立这几个值的三个别本。

11+1=12

加法操作符(+)

  • 若有二个操作数为NaN,结果为NaN
  • 若有3个操作数为字符串,则将另一个数转变为字符串然后拼接
  • 若有1个操作数为目的,则调用对象的toString方法再举办上一步

    // num: 数值操作数 str: 字符串 obj: 对象
    num + 非字符串操作数(NaN/undefined/null/false/true) = num + Number(非字符串操作数)
    num + str = ‘numstr’; // 1 + 二 + ‘3’ = ’33’

    str + NaN = ‘strNaN’; // ‘1’ + NaN = ‘1NaN’
    str + null = ‘strnull’; // ‘1’ + null = ‘1null’
    str + true = ‘strture’;

    obj + num = obj.toString() + num; // Math + 123 = ‘[object Math]123’
    obj + str = obj.toString() + str; // Math + ‘123’ = ‘[object Math]123’


        [0.1.3]不能够给宗旨项目标值加多属性

粗粗的感觉正是+操作符会优先输入String

 

js中的number

JavaScript不区分整数和浮点数,统1用Number表示,举例:

1  //整数1

3.1415926  //小数

-12312 //负数

一.237玖八e1贰  //科学计数法

特殊的number类型

NaN //NaN表示Not a Number,当无法测算结果时用NaN表示

Infinity  //
Infinity表示无比大,当数值超过了JavaScript的Number所能表示的最大值时,就表示为Infinity

    [0.2]引用数据类型:Object

 +new date()===new
date().getTime()

减法操作符(-)

  • 若3个操作数为字符串、null、undefined、布尔值,就调用Number()将其转移为数值再运算
  • 若1个操作数为对象则调用该目的valueOf(),未有valueOf()则调用toString()

    1 – ‘2’ = -1;
    1 – ‘123a’ = NaN; // 1 – Numer(‘123a’)
    1 – Math = NaN; // 1 – Math.valueOf()
    1 – true = 0;

js中的string

“sdadasd” //字符串sdadasfd,用单引号恐怕双引号包裹起来

       
[0.2.1]引用类型值是指这么些能够由几个值构成的指标。js不容许直接待上访问内部存款和储蓄器中的职位,也正是无法平昔访问操作对象的内部存款和储蓄器空间。在操作对象时,实际上是在操作对象的引用而不是实际上的靶子。

 

 

js中的boolean

true //true,正确

false  //false , 错误

       
[0.2.2]引用类型的值是目标,保存在堆内部存款和储蓄器中,包罗引用类型值的变量实际上包括的并不是指标自己,而是一个针对该对象的指针。从三个变量向另3个变量复制引用类型的值,复制的实际是指针,由此八个变量最后都针对同多个目标。

js –

涉嫌操作符(>、<、>=、<=)

  • 与NaN比较都会回到false
  • 若五个操作数都为字符串,则比较字符串的编码值
  • 若有1个操作数为数值,则对另2个操作数用Number()转变
  • 若有二个操作数为对象,则调用该对象valueOf(),未有valueOf()则调用toString()

    4 > ‘2’; // true
    4 > ‘2a’; // false
    4 > Math; // false
    4 > true; // true

    ‘ab’ > ‘a’ // true

 

js中的null和undifined

null  //空值

undifined  //未定义

       
[0.2.3]对于引用类型的值,可认为其增添属性和方式,也足以更动和删除其个性和方法

“11”-1=10

相当于操作符(==、!=)

  • 字符串、布尔类型和数值相比,现将前者用Number()转变为数值
  • 若3个操作数是目的另一个不是,则调用该目的valueOf(),未有valueOf()则调用toString()
  • 若七个操作数都以目的,则比较它们是否同2个目标(地址是不是一样)
  • null和undefined是相等的
  • null和undefined不会转变到任何值
  • 其他数都不对等NaN,包罗NaN自身

    // true
    123 == ‘123’;
    1 == true;
    ‘123’ == new String(123);
    123 == new String(123);
    null == undefined;

    // false
    null == 0;
    2 == true;
    new String(123) == new String(123);

 

下边介绍一下威胁类型转变

Number(obj)  //
把obj转化为number,假诺不可能转为number,则赶回NaN,parseInt()和parseFloat()也是如此,下文有详尽介绍

toString(obj)  // 把obj转化为字符串

Boolean(obj)  //把obj转化为布尔值

[1]Undefined

null-1=-1

全等操作符(===、!==)

全等操作符不会转移操作数

123 ===  '123';  // false
null === undefined; // false

 

转变规则

Boolean(undefined):false

Number(undefined):NaN

String(undefined):’undefined’

Boolean(null):false

Number(null):0

String(null):’null’

Number(true): 1 || Number(false) : 0

String(true):’true’ || String(false):’false’

Boolean(undefined):false

Boolean(null):false

Boolean(非空对象包涵空数组[]和空对象{}):true

Boolean(非0): true || Boolean(0和NaN):false

JavaScript之隐式类型调换,js基本数据类型的七拾二变。Boolean(非空包涵空格字符串):true || Boolean(”):false

Number(true):1 || Number(false):0

Number(各样进制的数字):运算后的10进制的数字,如一.0或一.或01会以一出口

Number(undefined):NaN

Number(null):0

Number(字符串):

Number(只含有数字的拾进制和十6进制的字符串):运算后的10进制的数字

[注意]字符串中不识别8进制,根据10进制数字管理

Number(”和’ ‘):0

Number(其余情况的字符串):NaN

Number(对象):

Number([]和[0]和[-0]):0

Number([数字]):运算后的数字

Number([1,2]和{}和其余对象):NaN

    [1.1]Undefined类型唯有一个值,便是undefined

undefined-1=NaN

总结

你能说说下边结果是何许以及原因呢?

[] == 0;  // 1.??
{} == 0;  // 2.??
0 == {};  // 3.??
[] == {};  // 4.??
  1. true
  2. true
  3. error: Uncaught SyntaxError: Unexpected token ==
  4. false

据书上说对等操作符的规定,当四个操作数为目的另二个不是时,会调用对象的valueOf()

[] == 0;  --------->  [].valueOf()  ----->  ''  -----> Number('')  ----> 0

当多少个操作数都为对象则会比较它们是还是不是对准同一块区域,而[]和{}是四个独立的对象,所以为false。

下边看一些说明式总计结果

3>2  //false

‘2’!==2  //false

‘2’!===2  //true

Infinity==Infinity //true

NaN==NaN  //false

null==undefined  //true

null===undefined  //false

1==true  //true

1===true //false

‘1’==true  //true

‘1’===true  //false

    [1.2]var a <=> var a = undefined;   

粗粗正是-操作符的话正是会把参数调换来Number

js中的运算

4858美高梅 1

算术运算符

4858美高梅 2

赋值运算符

   
[1.3]对于从未注解过的变量,只可以实施1项操作,就是应用typeof操作符检验其数据类型【但在从严方式下会形成错误】

Number(null)=0

js中的运算符优先级

运算符                                                                
说明

.[ ] ( )                                      
字段访问、数组索引、函数调用和表明式分组

++ — – ~ !              delete new typeof
void一元运算符、重回数据类型、对象成立、未定义的值

* / %                                                
相乘、相除、求余数

+ – +                                              
 相加、相减、字符串串联

<< >> >>>                                        
                 移位

< <= > >= instanceof    
小于、小于或等于、大于、大于或等于、是不是为特定类的实例

4858美高梅,== != === !==                                  
 相等、不相等、全等,不全等

&                                                                    
  按位“与”

^                                                                    
 按位“异或”

|                                                                    
   按位“或”

&&                                                                    
逻辑“与”

||                                                                    
   逻辑“或”

?:                                                                    
 条件运算

= OP=                                            赋值、赋值运算(如 +=
和 &=)

,                                                                    
   七个总计

    [1.4]并发情况:

Number(undefined)=NaN

js中的隐式转换

console.log(“——-以下乘法———“);

console.log(5*”5″);//25

console.log(5*”a”);//nan

console.log(5*NaN);//nan

console.log(5*null);//0

console.log(5*undefined);//nan

console.log(5*5);//25

console.log(“——-以上乘法———“);

//
一、假如二个数值都是数字,那么直接开始展览乘法运算,(相信大家都会的,和小学数学同样,同时要小心数字的标识),假使乘积数值超过了ECMAscript的数值表示范围,则赶回Infinity(正无穷)或许-Infinity(负无穷)

//  2、假设3个数是NaN,那么结果正是NaN

// 3、如果Infinity与0相乘,结果是NaN

//
四、若是1个操作符是数字,别的一个不是数值,那么先用Number()函数,将其开始展览转向,将转向出来的值与数字举办相乘。假设调换出来的结果出现NaN,那么结果正是NaN。

//除法

console.log(“——-以下除法———“);

console.log(5/”5″);//1

console.log(5/”a”);//nan

console.log(5/NaN);//nan

console.log(5/null);//in

console.log(null/5);//0

console.log(5/undefined);//nan

console.log(5/5);//1

console.log(5/0);//in

console.log(0/5);//0

console.log(0/0);//nan

console.log(“——-以三巳法———“);

// 和乘法类似,唯一多的一条正是0/0结实是NaN

//取余、求模

console.log(“——-以下取余、求模——–“);

console.log(16%”5″);//1

console.log(5%”a”);//nan

console.log(5%NaN);//nan

console.log(5%null);//nan

console.log(null%5);//0

console.log(5%undefined);//nan

console.log(5%5);//0

console.log(5%0);//nan

console.log(0%5);//0

console.log(0%0);//nan

console.log(“——-以上取余、求模———“);

// 一、被除数是无穷大,除数是有限大的值,那么结果是NaN

// 二、被除数是个别大的值,除数是0,那么结果是NaN

// 3、Infinity%Infinity结果是NaN

// 四、被除数是少数大的值,除数是无穷大的值,结果是被除数。

// 伍、被除数是0,结果是0

//加法

console.log(“——-以下加法——–“);

console.log(16+”5″);//165

console.log(5+”a”);//5a

console.log(5+NaN);//nan

console.log(“5″+null);//

console.log(5+undefined);//nan

console.log(5+5);//10

console.log(“四个数的和是”+5+伍);//5伍

console.log(“多个数的和是”+(五+5));//拾

console.log(“——-以上加法——–“);

// 
一、有多个是字符串,那么别的贰个也会调换为字符串实行拼接。假使三个是字符串,其余一个是null大概undefined,那么相加,null可能undefined就能够调用String()方法,得到字符串“null”或许“undefined”,然后实行拼接。

//
2、倘使二个数字加null恐怕undefined,那么照旧把null可能undefined举行Number()调换之后再相加。

// 三、剩下的准绳和其余的几近,就不多说了。

//减法

console.log(“——-以下减法——–“);

console.log(16-“5”);//11

console.log(typeof 16-“5”);

console.log(5-“a”);//nan

console.log(5-NaN);//nan

console.log(5-null);//5

console.log(5-undefined);//nan

console.log(5-5);//0

console.log(5-true);//4

console.log(5-“true”);//nan

console.log(5-“”);//5

//alert(Number(‘sds’));nan

// alert(Number(”));//0

console.log(“多少个数的差是”+伍-⑤);//nan

console.log(“三个数的差是”+(5-伍));//shi0

console.log(“——-以上减法——–“);

// 1、Infinity-Infinity结果是NaN

// 2、-Infinity-Infinity结果是-Infinity

// 三、3个数字减Infinity结果是-Infinity

// 4、Infinity-(-Infinity)结果是Infinity

//
伍、假若操作数是目标,则调用对象valueOf方法,假如结果是NaN那么结果正是NaN。若是未有valueOf方法,那么调用toString()方法,并将获得的字符串转换为数值。

        [1.4.1]已扬言未赋值的变量

 

总结

js隐式转化有许多坑,尽量用===代替==

        [1.4.2]获得对象不设有的品质

        [1.4.3]无重回值的函数的施行结果

        [1.4.4]函数的参数未有传来

        [1.4.5]void(expression)

    [1.5]类型转变

        Boolean(undefined):false

        Number(undefined):NaN

        String(undefined):’undefined’

[2]Null

   
[2.1]Null类型唯有贰个值,便是null,逻辑角度看,null值表示3个空对象指针

    [2.2]一旦定义的变量将用以保存对象,最佳将该变量伊始化为null

    [2.3]实则undefined值是派生自null值的,所以undefined == null

    [2.4]出现气象:对象不存在时

    [2.5]类型调换

        Boolean(null):false

        Number(null):0

        String(null):’null’       

    [注意1]null是空对象指针,而[]是空数组,{}是空对象,叁者不一样样

    [注意2]null不能够加多自定义属性

[3]Boolean

    [3.1]Boolean类型只有多个值:true 和 false

    [3.2]出现气象:

        [3.2.1]规则语句导致系统实践的隐士类型调换

        [3.2.2]字面量或变量定义

    [3.3]类型调换

        Number(true): 1 || Number(false) : 0

        String(true):’true’ || String(false):’false’

    [3.4]Boolean()

        Boolean(undefined):false

        Boolean(null):false

        Boolean(非空对象蕴含空数组[]和空对象{}):true

        Boolean(非0): true || Boolean(0和NaN):false

        Boolean(非空包蕴空格字符串):true || Boolean(”):false

    [注意]true不一定等于一,false也不肯定等于0

 [4]Number

    [4.1]Number类型使用IEEE75四格式来代表整数和浮点数值

    [注意]能够用2个值-0来将其调换来二个数字

    [4.2]二种字面量格式是拾进制、8进制、十陆进制

       
[4.2.1]八进制字面值的第叁个人必须是0,然后是八进制数字种类(0-7),尽管字面值中的数值高于了限制,那么前导0将被忽略,后边的数值被看做拾进制数解析

        [4.2.2]8进制字面量在严俊形式下是无效的,会促成js抛出错误

       
[4.2.3]十6进制字面值的前两位必须是0x,后跟十六进制数字类别,字母可大写可小写

        [4.2.4]十6进制中字面值中的数值走出范围,如出现g,h等会报错

       
[4.2.5]在开始展览算术计算时,全体以八进制和十6进制表示的数值最后都将被调换来10进制数值

    [4.3]数值表示:

        [4.3.1]js中能够保存正0和负0,且被以为非凡

       
[4.3.2]浮点数值:该数值中必须含有三个小数点,并且小数点前边总得至少有壹位数字。

           
[4.3.2.1]是因为浮点型数值须求的内部存储器空间是保存整数值的两倍,由此js会不失时机地将浮点数值转换来整数值,若小数点后不曾跟其他数字只怕浮点值本人代表的就是贰个平头,那几个数值会作为整数值来保存。

            [4.3.2.2]浮点数值的万丈精度是1陆个人小数

           
[4.3.2.3]对此一点都不小大概非常的小的数,能够用科学计数法e来表示的浮点数值来代表

           
[4.3.2.4]默许意况下,js会将小数点后边带有6个0以上的浮点数值转变为以e表示法表示的数值

           
[4.3.2.5]基于IEEE75四数值的浮点总括的弱点是舍入基值误差的主题材料。如:0.1+0.2=== 0.三(一多少个0)4

        [4.3.3]js中的数值范围是Number.MIN_VALUE(5e-324) ——
Number.MAX_VALUE(1.7976931348623157e+308)

           
[4.3.3.1]一经超(Jing Chao)过正数范围,输出Infinity(正无穷大),高出负数范围,输出-Infinity(负无穷大)

            [4.3.3.2]+-Infinity不可能参与数值总计

            [4.3.3.3]Number.MAX_VALUE+1 !=
Infinity,因为计算机最多保留5四人尾数位,保存不了一千多位,早就失去精度,即小数位全为0,所以相加不改变

            [4.3.3.4]Number.MIN_VALUE – 1 !=
-Infinity,也是千篇壹律的原由,所以结果为-1

           
[4.3.3.5]能够用isFinite()来规定二个数值是否东周的,包括着隐式类型转换Number()

            [4.3.3.6]isFinite(NaN) //false

        [4.3.4]NaN

            [4.3.4.1]NaN与别的值都不对等,包罗NaN本身

            [4.3.4.2]任何涉及NaN的操作都会回到NaN

           
[4.3.4.3]isNaN()来剖断这几个数字是否NaN,蕴含着隐式类型调换Number()

   
[4.4]数值转变:Number()可用来其余类型,parseInt()和parseFloat专门用于把字符串转换到数值

   
[注意1]Number()、parseInt()、parseFloat()还不错各类进制的数字,但对此含数字的字符串并不适用

    [注意2]Number()、parseInt()、parseFloat()中数字为壹.贰.
会报错,但字符串为’①.二.’则不会报错

        [4.4.1]Number()

            Number(true):1 || Number(false):0

           
Number(各类进制的数字):运算后的十进制的数字,如一.0或1.或01会以壹出口

            Number(undefined):NaN

            Number(null):0

            Number(字符串):

               
Number(只包蕴数字的10进制和十陆进制的字符串):运算后的10进制的数字

                [注意]字符串中不识别8进制,根据拾进制数字管理

                Number(”和’ ‘):0

                Number(其余景况的字符串):NaN

            Number(对象):

                Number([]和[0]和[-0]):0

                Number([数字]):运算后的数字

                Number([1,2]和{}和其它对象):NaN

       
[4.4.2]parseInt():在转移字符串时,会忽略字符串前边的空格,直到找到第三个非空格字符。假诺第三个字符不是数字字符或许负号,parseInt()就能回去NaN。如若是,则持续分析,直到解析实现或许碰到非数字字符。

           
[4.4.2.1]parseInt()能够辨认出各样进制的平头,但在解析八进制字面量的字符串,ECMAScript三会分析八进制,但ECMAScript5未有解析八进制的力量

           
[4.4.2.2]parseInt()函数提供第四个参数,表示有点进制,如:parseInt(’12三’,16或10或二)

           
[4.4.2.3]parseInt(各个进制的数字):运算后的10进制的数字,如一.0或1.或0一会以一出口

           
[4.4.2.4]因为parseInt()是专门用来拍卖字符串转变数字的,所以parseInt(别的类型包罗”)//NaN

       
[4.4.3]parseFloat():类似于parseInt(),会忽视字符串前边的空格,直到找到第3个非空格字符

            [4.4.3.1]parseFloat()只好解析10进制字符串

           
[4.4.3.2]parseFloat(各样进制的数字):运算后的10进制的数字,如一.0或一.或0一会以壹输出

 [5]String:由单引号或双引号括起来的字符连串,任何字符串的尺寸都足以透过走访length属性获得

    [5.1]字符字面量,也叫转义连串

        \n 换行

        \t 制表

        \b 空格

        \r 回车

        \f 进纸

        \\ 斜杠

        \’ 单引号

        \” 双引号

        \xnn 以十6进制nn表示贰个字符(n为0-f),如\x41表示’A’

        \unnnn
以十6进制nnnn表示1个Unicode字符(n为0-f),如\u0三a三意味着希腊共和国(Ελληνική Δημοκρατία)字符ε

    [5.2]ECMAScript中的字符串是不可变的   

   
[5.3]字符串连接要求先创设七个新字符串,然后在新字符串中填充八个需求拼接的字符串,最后再销毁原来的字符串。这几个历程在后台发生,也是在一些旧版本浏览器(IE陆)拼接字符串速度慢的从头到尾的经过,但新兴1度缓慢解决了那么些低功能难题

    [5.4]字符串调换

        [5.4.1]toString()

            Null和Undefined未有该方法

            Boolean、Object、String有该方式

            Number使用该措施能够传递基数2、八、10、16,如var num =
十;num.toString(二);//拾10

            但拾.toString(二)会报错,因为数字背后不可能跟标识符

        [5.4.2]String()

            有toString()方法,使用toString()方法

            String(null);//’null’

            String(undefined);//’undefined’   

       
[5.4.3]要把某部值转变为字符串,能够利用加号操作符把它与贰个空字符串”加在一齐

   [5.4.4]要是数组中的某壹项的值是null或许undefined,那么该值在join()、toLocaleString()、toString()和valueOf()方法再次来到的结果中以空字符串代表

说起底给大家几个简便的例子表达下那七种基本项目的差别

var testString = "Hello"; 
var testBoobean = true; 
var testUndefined = undefined; 
var testUndefined1; 
var testNull = null; 
var testObject = {a:1}; 
var testFunction = function(){return;}; 

alert(testString);//"string" 
alert(testBoobean);//"boolean" 
alert(testUndefined);//"undefined" 
alert(testUndefined1);//"undefined" 
alert(testUndefined2);//"undefined" 
alert(testNull);//"object" 
alert(testObject);//"object" 
alert(testFunction);//"function"

  

三大引用类型

1.Object类型

我们看来的多数类型值都是Object类型的实例,创立Object实例的措施有二种。

率先种是使用new操作符后跟Object构造函数,如下所示

var person = new Object();

person.name = “Micheal”;

person.age = 24;

第1种方法是接纳对象字面量表示法,如下所示

var person = {

  name : “Micheal”,

  age : 24

};

2.Array类型

数组的各样能够用来保存任何项目的数目,也正是说,能够用数组的率先个岗位来保存字符串,首个职责保存数值,第捌个职位保存对象….其它,数组的分寸是足以动态调治的。

成立数组的中坚方法有三种

第3种是选用Array构造函数,如下所示

var colors = new Array(“red”,”blue”,”yellow”);

第两种是选拔数组字面量表示法,如下所示

var colors = [“red”,”blue”,”yellow”];

3 Function类型

种种函数都以Function类型的实例,而且都与其他引用类型同样具有属性和章程。函数平日是运用函数注解语法定义的,如下所示

function sum(num1,num2){

  return num1 + num2;

};

 

js剖断目的依然数组

壹.对此Javascript 壹.捌.伍(ECMAScript 五),变量名字.isArray(
)能够实现这一个目标

1 var a=[];
2 var b={};
3 Array.isArray(a);//true
4 Array.isArray(b)//false

  

二.借令你只是用typeof来检查该变量,不论是array依旧object,都将赶回‘objec’。 此难题的1个实用的答案是是反省该变量是或不是object,

再者检查该变量是不是有数字长度(当为空array时间长度度也说不定为0,object的长短为undefined)。

var a=[];
var b={};
typeof a === 'object' && !isNaN(a.length)//true
typeof b === 'object' && !isNaN(b.length)//false

三.调用toString( )方法试着将该变量转化为表示其种类的string。 

var a=[];
var b={};
Object.prototype.toString.call(a)  === '[object Array]'//true
Object.prototype.toString.call(b)  === '[object Array]'//false

4  object.constructor === Array

var test=new Array();

if (test.constructor==Array)
{
document.write("This is an Array");
}

  

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有