JavaScript隐式类型转变,逻辑不通

By admin in 4858美高梅 on 2019年4月28日
  1. 项目检测

    • 花色检验优用 typeof。对象类型检查评定选择 instanceofnull
      undefined 的检验选用 == null

    // string
    typeof variable === 'string'
    // number
    typeof variable === 'number'
    // boolean
    typeof variable === 'boolean'
    // Function
    typeof variable === 'function'
    // Object
    typeof variable === 'object'
    // RegExp
    variable instanceof RegExp
    // Array
    variable instanceof Array
    // null
    variable === null
    // null or undefined
    variable == null
    // undefined
    typeof variable === 'undefined'
    
  2. 类型调换

    • 转换成 string 时,使用 + ''

    num + '';
    
    • 转换成 number 时,日常采纳 +

    +str;
    
    • string 转换成
      number,要改变的字符串结尾包罗非数字并期望忽略时,使用
      parseInt

    var width = '200px';
    parseInt(width, 10);
    
    • 使用 parseInt 时,必须钦定进制。

    parseInt(str, 10);
    
    • 转换成 boolean 时,使用 !!

    var num = 3.14;
    !!num;
    
    • number 去除小数点,使用 Math.floor / Math.round /
      Math.ceil,不使用 parseInt

    var num = 3.14;
    Math.ceil(num);
    
  3. 其它

    • for in 遍历对象时, 使用 hasOwnProperty 过滤掉原型中的属性。

    var newInfo = {};
    for (var key in info) {
        if (info.hasOwnProperty(key)) {
           newInfo[key] = info[key];
        }
    }
    
    • 数组排序使用 sort

    function sortNumber(a,b) {
        return a - b
    }
    // 声明数组建议 var arr = []
    // 声明指定长度数组使用下面的方式
    var arr = new Array(6)
    arr[0] = "10"
    arr[1] = "5"
    arr[2] = "40"
    arr[3] = "25"
    arr[4] = "1000"
    arr[5] = "1"
    console.log(arr);    // (6) ["10", "5", "40", "25", "1000", "1"]
    console.log(arr.sort(sortNumber)); // ["1", "5", "10", "25", "40", "1000"]
    
    • 类的后续方案,完毕时索要纠正 constructor

    /**
     *构建类之间的继承关系
     *@param {Function} subClass 子类函数
     *@param {Function} superClass 父类函数
     */
    var extend = function (subClass, superClass) {
        var F = function() {};
        F.prototype = superClass.prototype;
        subClass.prototype = new F();
        subClass.prototype.constructor = subClass;
        subClass.uber = C.prototype; // uber 是在模拟 class 时用来表示 super 的(因为super是关键字所以不能直接用)
     }
    
  1. 花色检验

    • 类别检验优先利用 typeof。对象类型检查评定接纳 instanceofnull
      undefined 的检查实验选择 == null

      // string
      typeof variable === 'string'
      // number
      typeof variable === 'number'
      // boolean
      typeof variable === 'boolean'
      // Function
      typeof variable === 'function'
      // Object
      typeof variable === 'object'
      // RegExp
      variable instanceof RegExp
      // Array
      variable instanceof Array
      // null
      variable === null
      // null or undefined
      variable == null
      // undefined
      typeof variable === 'undefined'
      
  2. 类型调换

    • 转换成 string 时,使用 + ''

      num + '';
      
    • 转换成 number 时,平时采纳 +

      +str;
      
    • string 转换成
      number,要调换的字符串结尾包罗非数字并期待忽略时,使用
      parseInt

      var width = '200px';
      parseInt(width, 10);
      
    • 使用 parseInt 时,必须钦定进制。

      parseInt(str, 10);
      
    • 转换成 boolean 时,使用 !!

      var num = 3.14;
      !!num;
      
    • numberJavaScript隐式类型转变,逻辑不通。 去除小数点,使用 Math.floor / Math.round /
      Math.ceil,不使用 parseInt

      var num = 3.14;
      Math.ceil(num);
      
  3. 其它

    • for in 遍历对象时, 使用 hasOwnProperty 过滤掉原型中的属性。

      var newInfo = {};
      for (var key in info) {
      if (info.hasOwnProperty(key)) {
         newInfo[key] = info[key];
      }
      }
      
    • 数组排序使用 sort

      function sortNumber(a,b) {
      return a - b
      }
      // 声明数组建议 var arr = []
      // 声明指定长度数组使用下面的方式
      var arr = new Array(6)
      arr[0] = "10"
      arr[1] = "5"
      arr[2] = "40"
      arr[3] = "25"
      arr[4] = "1000"
      arr[5] = "1"
      console.log(arr);    // (6) ["10", "5", "40", "25", "1000", "1"]
      console.log(arr.sort(sortNumber)); // ["1", "5", "10", "25", "40", "1000"]
      
    • 类的承袭方案,达成时须求校正 constructor

      /**
       *构建类之间的继承关系
       *@param {Function} subClass 子类函数
       *@param {Function} superClass 父类函数
       */
      var extend = function (subClass, superClass) {
      var F = function() {};
      F.prototype = superClass.prototype;
      subClass.prototype = new F();
      subClass.prototype.constructor = subClass;
      subClass.uber = C.prototype; // uber 是在模拟 class 时用来表示 super 的(因为super是关键字所以不能直接用)
       }
      

1、js组成:

JavaScript隐式类型转变,javascript隐转换

JavaScript的数据类型是那三个弱的(不然不会叫它做弱类型语言了)!在利用算术运算符时,运算符两边的数据类型能够是轻巧的,例如,一个字符串能够和数字相加。之所以分裂的数据类型之间能够做运算,是因为JavaScript引擎在运算在此之前会鬼鬼祟祟的把他们开始展览了隐式类型转变的,如下是数值类型和布尔类型的相加:

复制代码 代码如下:
3 + true; // 4

结果是1个数值型!假设是在C大概Java意况的话,上边的运算分明会因为运算符两边的数据类型不雷同而招致报错的!不过,在JavaScript中,只有少数情况下,错误类型才会变成出错,举个例子调用非函数,或许读取null恐怕undefined的习性时,如下:

复制代码 代码如下:
“hello”(1); // error: not a function
null.x; // error: cannot read property ‘x’ of null

当先四分之二景观下,JavaScript都不会出错的,而是自行的展开对应的类型调换。举个例子-,
*,
/,和%等算术运算符都会把操作数调换到数字的,不过“+”号就有点不雷同了,有些情状下,它是算术加号,有个别景况下,是字符串连接符号,具体的要看它的操作数,如下:

复制代码 代码如下:
2 + 3; // 5
“hello” + ” world”; // “hello world”

只是,如若字符串和数字相加,会是哪些的结果吗?JavaScript会活动把数字转换到字符的,不管数字在前照旧字符串在前,如下:

复制代码 代码如下:
“2” + 3; // “23”
2 + “3”; // “23”

字符串和数字相加结果是字符串,字符串和数字相加结果是字符串,字符串和数字相加结果是字符串,首要的事情说2次!!!!!!

其余,需求专注的是,“+”的演算方向是从左到右的,如下:

复制代码 代码如下:
1 + 2 + “3”; // “33”

那与下部是等价的:

复制代码 代码如下:
(1 + 2) + “3”; // “33”

对照,上边包车型客车结果是不一致的:

复制代码 代码如下:
1 + “2” + 3; // “123”

只是,隐式类型调换,有时候,会隐藏一些荒唐的,比方,null会转变来0,undefined会转变来NaN。须求专注的是,NaN和NaN是不对等的(那是由于浮点数的精度决定的),如下:

复制代码 代码如下:
var x = NaN;
x === NaN; // false

固然如此,JavaScript提供了isNaN来检查实验有个别值是还是不是为NaN,不过,那也不太标准的,因为,在调用isNaN函数在此以前,本身就存在了一个隐式转变的历程,它会把那么些原本不是NaN的值转变到NaN的,如下:

复制代码 代码如下:
isNaN(“foo”); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN({ valueOf: “foo” }); // true

地点代码,我们运用isNaN来测试后,开掘字符串,undefined,以至对象,结果都回到真!!!可是,大家总不能够说他们也是NaN吧?简单来讲,得出的定论是:isNaN检查实验NaN并不保障!!!

碰巧的是,有壹种保障的还要正确的主意能够检验NaN。我们都清楚,唯有NaN是温馨不等投机的,那么,我们就以应用不对等号(!==)来判定二个数是还是不是等于我,从而,能够检验到NaN了,如下:

var a = NaN;
a !== a; // true
var b = "foo";
b !== b; // false
var c = undefined;
c !== c; // false
var d = {};
d !== d; // false
var e = { valueOf: "foo" };
e !== e; // false

咱俩也能够把那种方式定义成二个函数,如下:

function isReallyNaN(x) {
return x !== x;
}

OK,NaN的检查实验方法就是那般轻便,我们下边继续切磋对象的隐式转变!

对象是足以转变来原始值的,最常见的艺术正是把它调换到字符串,如下:

"the Math object: " + Math; // "the Math object: [object Math]"
"the JSON object: " + JSON; // "the JSON object: [object JSON]"

对象调换来字符串是调用了他的toSting函数的,你能够手动的调用它来检测一下:

Math.toString(); // "[object Math]"
JSON.toString(); // "[object JSON]"

就像的,对象也是足以转变到数字的,他是通过valueOf函数的,当然,你也是足以自定义这几个valueOf函数的,如下:

"J" + { toString: function() { return "S"; } }; // "JS"
2 * { valueOf: function() { return 3; } }; // 6

即便,三个对象同时设有valueOf方法和toString方法,那么,valueOf方法总是会被优先调用的,如下:

var obj = {
toString: function() {
return "[object MyObject]";
},
valueOf: function() {
return 17;
}
};
"object: " + obj; // "object: 17"

可是,诸多景况下,这都不是大家想要的,一般的,尽可能使valueOf和toString表示的值一样(尽管类型能够不一样)。

说到底1种强制类型转变,大家日常称之为“真值运算”,比方,if, ||,
&&,他们的操作数不断定是布尔型的额。JavaScript会通过轻巧的转换规则,将一部分非布尔类型的值转换来布尔型的。大繁多的值都会转换到true,唯有少数的是false,他们分别是:false,
0, -0, ””, NaN, null,
undefined,因为存在数字和字符串以及对象的值为false,所以,直接用真值转变到判别3个函数的参数是不是传进来了,那是不不太安全的。比方,有三个得以有所暗中同意值得可选参数的函数,如下:

function point(x, y) {
if (!x) {
x = 320;
}
if (!y) {
y = 240;
}
return { x: x, y: y };
}

以此函数会忽略任何的真值为假的参数的,包蕴0,-0;

复制代码 代码如下:
point(0, 0); // { x: 320, y: 240 }

检查实验undefined的特别正确的办法是用typeof操作:

function point(x, y) {
if (typeof x === "undefined") {
x = 320;
}
if (typeof y === "undefined") {
y = 240;
}
return { x: x, y: y };
}

那种写法,可以分别开0和undefined的:

point(); // { x: 320, y: 240 }
point(0, 0); // { x: 0, y: 0 }

除此以外一种办法是接纳参数跟undefined作比较,如下:

if (x === undefined) { ... }

总结:

  1. 类型错误有相当的大希望会被类型转换所隐藏。

二.
“+”既能够象征字符串连接,又足以象征算术加,那取决于它的操作数,要是有八个为字符串的,那么,正是字符串连接了。

三.
对象通过valueOf方法,把自个儿转变到数字,通过toString方法,把自己调换到字符串。

四.有所valueOf方法的靶子,应该定义三个照猫画虎的toString方法,用来回到相等的数字的字符串格局。

5.检测一些未定义的变量时,应该使用typeOf或许与undefined作相比较,而不应有一贯用真值运算。

至于JavaScript隐式类型调换就给我们介绍到那边,希望对我们持有扶助!

参考链接

参考链接

    ECMAscript(基础语法)、Dom(文书档案对象模型)、Bom(浏览器对象模型)

你大概感兴趣的篇章:

  • 浅析JavaScript中的隐式类型调换
  • 简轻易单介绍JavaScript数据类型之隐式类型调换

JavaScript的数据类型是可怜弱的(不然不会叫它做弱类型语言了)!在动用算术运算符时,运算符两边…


二、数据类型:

    基本项目:string number boolean  underfined  null

4858美高梅 ,    复杂类型:Array  function  object  Date  Math  RegExp(正则表明式)


三、检查实验数据类型

    typeof:可以检验中央数据类型(除了null),还是能检查实验函数

    instanceof:推断数据类型,但不临深履薄

   
对象的toString方法:Object.prototype.toString.call(供给质量评定项目标数码),轻巧等级次序都能够检查实验

    NaN永久不等于其余的值,包蕴她本身。

    隐式的调换到布尔类型!!

    能够转变来布尔类型的false:false undefined null NaN 0 -0 ”

    除了上边的都调换到布尔类型的true


4、in关键字的行使

    for in  遍历对象和数组

    推断目的中是还是不是可以访问有个别属性大概措施

    推断数组中是还是不是有有些下标

   
假若要一口咬住不放一个数组中是还是不是有有个别元素,用indexof。借使存在那些因素就回到那几个因素的下标,不存在就重返-一。


5、delete关键字的运用

    删除未有采纳var证明的变量

    删除对象的本性和方法:  delete 对象.属性名

    (普通的对象未有removeAttribute那么些措施,这么些艺术是dom对象的)

    删除数组中的成分: delete 数组[下标]

    删除后下标并不会打开往前挪动


陆、逻辑中断(逻辑不通)

    逻辑与表达式:要是到场逻辑与表明式运算的第二个姿态 
能够转换成布尔类型的false的话,那么一切逻辑与表达式的值正是首先个姿态的值;假如第二个姿态无法转变来布尔类型的false的话,那么整个逻辑与表明式的值正是第三个姿态的值

    逻辑或表明式:纵然加入逻辑与表明式运算的首先个姿态 
可以转变来布尔类型true的话,那么1切逻辑与表达式的值正是第三个姿态的值;假若第3个姿态不可能转变到布尔类型true的话,那么整个逻辑与说明式的值正是第四个姿态的值


7、原型:其实是二个目标,放四构造函数在被制造,系统都会帮我们机关的扭转贰个一拍即合的原型对象。

    如何访问原型:构造函数.prototype

    给原型增多属性和方法:构造函数.prototype.方法名或属性名

    原型中的属性只怕措施只好是其1原型对应的构造函数成立出来的目的

   
注意:假如和煦内有这么些主意名或属性名,就走访自个儿的;若是未有再去拜访原型的。


8、__proto__属性
:对象.__proto__:获取的是开创该对象的构造函数对应的原型

   
__proto__不是正规的性质,所今后来开垦(真实或生育)意况不要选拔,自身调节和测试程序,也许评释某种关联,能够动用。


9、constructor属性:原型中的属性,指向原型对应的构造函数

   
构造函数创立的对象中平昔不constructor属性,就去他的原型中检索那本本性,找到了,正是创设这些目的的构造函数。

发表评论

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

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