全球彩票平台_全球彩票注册平台|官网下载地址

热门关键词: 全球彩票平台,全球彩票注册平台,全球彩官网下载地址

【全球彩官网下载地址】JavaScript中的一些隐式转

对存在JavaScript隐式类型转换的四种情况的总结(必看篇),javascript必看

一般存在四种情况,JavaScript会对变量的数据类型进行转换。

目录

* if中的条件会被自动转为Boolean类型
 * 会被转为false的数据
 * 会被转为true的数据
* 参与 运算都会被隐式的转为字符串
 * 会被转为空字符串的数据
 * 会被转为字符串的数据
 * 会被转为数据类型标记的数据
* 参与*运算都会被隐式的转为数字
 * 会被转为0的数据
 * 会被转为1的数据
 * 会被转为NaN的数据
* == 运算符
 * 为true的时候
 * 为false的时候

if中的条件会被自动转为Boolean类型

会被转为false的数据

if(false) console.log(2333)
if('') console.log(2333)
if(null) console.log(2333)
if(undefined) console.log(2333)
if(NaN) console.log(2333)

会被转为true的数据

if(true) console.log(2333) // 2333
if('test') console.log(2333) // 2333
if([]) console.log(2333) // 2333
if({}) console.log(2333) // 2333

参与 运算都会被隐式的转为字符串

会被转为空字符串的数据

'str-'   '' // str-
'str-'   []

会被转为字符串的数据

'str-'   '1' // "str-1"
'str-'   1 // "str-1"
'str-'   false // "str-false"
'str-'   true // "str-true"
'str-'   null // "str-null"
'str-'   undefined // "str-undefined"
'str-'   NaN // "str-NaN"

会被转为数据类型标记的数据

'str-'   {} // "str-[object Object]"
'str-'   {a:1} // "str-[object Object]"

参与*运算都会被隐式的转为数字

会被转为0的数据

2 * '' // 0
2 * [] // 0
2 * false // 0

会被转为1的数据

2 * '1' // 2
2 * [1] // 2
2 * true // 2

会被转为NaN的数据

2 * {} // NaN
2 * {a:1} // NaN

== 运算符

为true的时候

0 == false // true
0 == '' // true
0 == '0' // true
0 == [] // true
0 == [0] // true

1 == true // true
1 == '1' // true
1 == [1] // true

[1] == true // true
[] == false // true

为false的时候

0 == {} // false
0 == null // false
0 == undefined // false
0 == NaN // false

1 == {} // false
1 == null // false
1 == undefined // false
1 == NaN // false

[] == [] // false
[1] == [1] // false
[1] == {} // false
[1] == {a:1} // false
[1] == false // false
[1] == null // false
[1] == undefined // false
[1] == NaN // false

{} == {} // false
{a:1} == {a:1} // false

注:空数组[],在 运算符下是转为空字符串'',在*运算符下是转为数字0。但在if语句中,则转为true。

以上这篇对存在JavaScript隐式类型转换的四种情况的总结(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持帮客之家。

一般存在四种情况,JavaScript会对变量的数据类型进行转换。 目录 *...

2 * '1' // 2
2 * [1] // 2
2 * true // 2

会被转为0的数据

2 * ''  // 0
2 * []  // 0
2 * false  // 0

总结

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

JavaScript的数据类型是非常弱的(不然不会叫它做弱类型语言了)!在使用算术运算符时,运算符两边的数据类型可以是任意的,比如,一个字符串可以和数字相加。之所以不同的数据类型之间可以做运算,是因为JavaScript引擎在运算之前会悄悄的把他们进行了隐式类型转换的,如下是数值类型和布尔类型的相加:

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

结果是一个数值型!如果是在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"

字符串和数字相加结果是字符串,字符串和数字相加结果是字符串,字符串和数字相加结果是字符串,重要的事情说三遍!!!!!!

此外,需要注意的是,“ ”的运算方向是从左到右的,如下:

复制代码 代码如下:
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表示的值相同(尽管类型可以不同)。

最后一种强制类型转换,我们常常称之为“真值运算”,比如,if, ||, &&,他们的操作数不一定是布尔型的额。JavaScript会通过简单的转换规则,将一些非布尔类型的值转换成布尔型的。大多数的值都会转换成true,只有少数的是false,他们分别是:false, 0, -0, ”", NaN, null, undefined,因为存在数字和字符串以及对象的值为false,所以,直接用真值转换来判断一个函数的参数是否传进来了,这是不不太安全的。比如,有一个可以具有默认值得可选参数的函数,如下:

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. 类型错误有可能会被类型转换所隐藏。

2. “ ”既可以表示字符串连接,又可以表示算术加,这取决于它的操作数,如果有一个为字符串的,那么,就是字符串连接了。

3. 对象通过valueOf方法,把自己转换成数字,通过toString方法,把自己转换成字符串。

4.具有valueOf方法的对象,应该定义一个相应的toString方法,用来返回相等的数字的字符串形式。

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

关于JavaScript隐式类型转换就给大家介绍到这里,希望对大家有所帮助!

会被转为false的数据

为true的时候

0 == false  // true
0 == ''  // true
0 == '0'  // true
0 == []  // true
0 == [0]  // true

1 == true  // true
1 == '1'  // true
1 == [1]  // true

[1] == true  // true
[] == false  // true

MDN 这样介绍Javascript: JavaScript 是一种弱类型或者说动态语言。这意味着你不用提前声明变量的类型,在程序运行过程中,类型会被自动确定。这也意味着你可以使用同一个变量保存不同类型的数据

您可能感兴趣的文章:

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

JavaScript的数据类型是非常弱的(不然不会叫它做弱类型语言了)!在使用算术运算符时,运算符两边...

if(false) console.log(2333)
if('') console.log(2333)
if(null) console.log(2333)
if(undefined) console.log(2333)
if(NaN) console.log(2333)

为false的时候

0 == {}  // false
0 == null  // false
0 == undefined  // false
0 == NaN  // false

1 == {}  // false
1 == null  // false
1 == undefined  // false
1 == NaN  // false

[] == []  // false
[1] == [1]  // false
[1] == {}  // false
[1] == {a:1}  // false
[1] == false  // false
[1] == null  // false
[1] == undefined  // false
[1] == NaN  // false

{} == {}  // false
{a:1} == {a:1}  // false

注:空数组[],在 运算符下是转为空字符串'',在*运算符下是转为数字0。但在if语句中,则转为true。

欢迎关注前端进阶指南微信公众号:

全球彩官网下载地址 1

另外我也创了一个对应的QQ群:660112451,欢迎一起交流。

6. 布尔值和数字比较

一般存在四种情况,JavaScript会对变量的数据类型进行转换。

会被转为空字符串的数据

'str-'   ''  // str-
'str-'   []
var obj = {
  toString: function(){
    return 6;
  },
  valueOf: function(){
    return 5;
  }
};
var obj1 = {
  valueOf: function(){
    return 'a';
  },
  toString: function(){
    return 'b';
  }
};

会被转为字符串的数据

目录

* if中的条件会被自动转为Boolean类型
    * 会被转为false的数据
    * 会被转为true的数据
* 参与 运算都会被隐式的转为字符串
    * 会被转为空字符串的数据
    * 会被转为字符串的数据
    * 会被转为数据类型标记的数据
* 参与*运算都会被隐式的转为数字
    * 会被转为0的数据
    * 会被转为1的数据
    * 会被转为NaN的数据
* == 运算符
    * 为true的时候
    * 为false的时候

全球彩官网下载地址 2

'str-'   '1' // "str-1"
'str-'   1 // "str-1"
'str-'   false // "str-false"
'str-'   true // "str-true"
'str-'   null // "str-null"
'str-'   undefined // "str-undefined"
'str-'   NaN // "str-NaN"

一般存在四种情况,JavaScript会对变量的数据类型进行转换。

    当object与基本类型运算时:

会被转为NaN的数据

会被转为NaN的数据

2 * {}  // NaN
2 * {a:1}  // NaN

全球彩官网下载地址 3  

以上这篇对存在JavaScript隐式类型转换的四种情况的总结(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

参与 运算都会被隐式的转为字符串

以上所述是小编给大家介绍的JavaScript中的一些隐式转换和总结(推荐),希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对脚本之家的支持!

会被转为true的数据

会被转为1的数据

2 * '1'  // 2
2 * [1]  // 2
2 * true  // 2
[] == true; //false []转换为字符串'',然后转换为数字0,true转换为数字1,所以为false

会被转为数据类型标记的数据

会被转为数据类型标记的数据

'str-'   {}  // "str-[object Object]"
'str-'   {a:1}  // "str-[object Object]"

曾经看到过这样一个代码:  (!(~ []) {})[--[~ ""][ []]*[~ []] ~~! []] ({} [])[[~! []*~ []]] = sb, 你敢相信, 当时就吓了 宝宝一跳。

2 * '' // 0
2 * [] // 0
2 * false // 0

if中的条件会被自动转为Boolean类型

  基本类型:

会被转为1的数据

会被转为字符串的数据

'str-'   '1'  // "str-1"
'str-'   1  // "str-1"
'str-'   false  // "str-false"
'str-'   true  // "str-true"
'str-'   null  // "str-null"
'str-'   undefined  // "str-undefined"
'str-'   NaN  // "str-NaN"

如图,任意两种类型比较时,如果不是同一个类型比较的话,则按如图方式进行相应类型转换,如对象和布尔比较的话,对象 => 字符串 => 数值 布尔值 => 数值。
另外,我们来看下一些需要"特别照顾"的。

* if中的条件会被自动转为Boolean类型
 * 会被转为false的数据
 * 会被转为true的数据
* 参与 运算都会被隐式的转为字符串
 * 会被转为空字符串的数据
 * 会被转为字符串的数据
 * 会被转为数据类型标记的数据
* 参与*运算都会被隐式的转为数字
 * 会被转为0的数据
 * 会被转为1的数据
 * 会被转为NaN的数据
* == 运算符
 * 为true的时候
 * 为false的时候

参与*运算都会被隐式的转为数字

3. 对象和数字比较

为false的时候

== 运算符

        全球彩官网下载地址 4全球彩官网下载地址 5            

本文由全球彩票平台发布于全球彩官网下载地址Web前端,转载请注明出处:【全球彩官网下载地址】JavaScript中的一些隐式转

TAG标签: 全球彩票平台
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。