国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

進(jìn)擊的 JavaScript(一) 之 類型轉(zhuǎn)換

Scholer / 1916人閱讀

摘要:實(shí)際上,我們通常認(rèn)為是自有類型的唯一成員。比較運(yùn)算符的操作數(shù)可能是任意類型。結(jié)果只有,例得到操作值等價(jià)的布爾值真值為,假值為等同于,經(jīng)常稱為強(qiáng)制轉(zhuǎn)換。結(jié)果返回布爾值的用法是中唯一一個(gè)不等于任何值的包括它自己。

說(shuō)起 js 類型轉(zhuǎn)換,都是頭疼吧,暈暈的,但是不行啊,這東西很重要滴! 基礎(chǔ)知識(shí)

JavaScript的數(shù)據(jù)類型分為六種,分別為null, undefined, boolean, string, number, object。

object是引用類型,包含數(shù)組,其它的五種是基本類型或者是原始類型(原始值)。

我們可以用typeof方法打印來(lái)某個(gè)是屬于哪個(gè)類型的。不同類型的變量比較或者運(yùn)算,要先轉(zhuǎn)類型,叫做類型轉(zhuǎn)換。

注意,typeof null 返回 "object",它是一個(gè)特殊的對(duì)象值,含義是“非對(duì)象”。實(shí)際上,我們通常認(rèn)為null是自有類型的唯一成員。

一、顯式轉(zhuǎn)換

parseInt()和parseFloat() 字符串轉(zhuǎn)數(shù)字

js提供了parseInt()parseFloat()兩個(gè)轉(zhuǎn)換函數(shù)。前者把值轉(zhuǎn)換成整數(shù),后者把值轉(zhuǎn)換成浮點(diǎn)數(shù)。只有對(duì)String類型調(diào)用這些方法,這兩個(gè)函數(shù)才能正確運(yùn)行;對(duì)其他類型返回的都是NaN(Not a Number)

parseInt()

parseInt("1234blue");   //1234 
parseInt("0xA");   //10 
parseInt("22.5");   //22 
parseInt("blue");   //NaN

parseInt()方法還有第二個(gè)參數(shù),可以把二進(jìn)制、八進(jìn)制、十六進(jìn)制或其他任何進(jìn)制的字符串轉(zhuǎn)換成整數(shù)。所以要解析十六進(jìn)制的值,需如下調(diào)用parseInt()方法:

parseInt("AF",   16);   //175 

當(dāng)然,對(duì)二進(jìn)制、八進(jìn)制,甚至十進(jìn)制(默認(rèn)模式),都可以這樣調(diào)用parseInt()方法:

parseInt("10",   2);    //2 
parseInt("66",   8);    //54 
parseInt("10",   10);   //10 

parseFloat字符串轉(zhuǎn)浮點(diǎn)數(shù)字,沒(méi)有第二個(gè)參數(shù)
下面是使用parseFloat()方法的示例:

parseFloat("1234blue");  //1234.0 
parseFloat("0xA");       //NaN 
parseFloat("22.5");      //22.5 
parseFloat("22.34.5");   //22.34 
parseFloat("0908");      //908 
parseFloat("blue");      //NaN

toFixed() 數(shù)字轉(zhuǎn)成字符串

根據(jù)參數(shù)保留小數(shù)點(diǎn)后幾位 會(huì)四舍五入,如果無(wú)參,默認(rèn)為0;
例:

(66.55).toFixed();    //"67"
(66.64).toFixed(1);   //"66.6"

toExponenttial() 數(shù)字轉(zhuǎn)成字符串

根據(jù)參數(shù)保留小數(shù)點(diǎn)后幾位 指數(shù)形式 會(huì)四舍五入
這個(gè)我不就不舉例了,感興趣的,自己百度下把。

Number對(duì)象的 toString() 方法, 數(shù)字轉(zhuǎn)字符串

根據(jù)2 8 16 (范圍2 - 36)分別轉(zhuǎn)為二進(jìn)制 八進(jìn)制 十六進(jìn)制字符串,,
不帶參,就默認(rèn)為10, 轉(zhuǎn)十進(jìn)制。
例:

(6).toString(2);     //"110"
(66).toString(8);    //"102"
(66).toString(16);   //"42"

下面三個(gè)構(gòu)造函數(shù),當(dāng)沒(méi)有使用 new 時(shí),表示類型轉(zhuǎn)換函數(shù),使用new 時(shí),表示轉(zhuǎn)對(duì)象(創(chuàng)建一個(gè)對(duì)應(yīng)對(duì)象),即轉(zhuǎn)換得到的值 創(chuàng)建一個(gè)對(duì)應(yīng)的對(duì)象。

Boolean()

它會(huì)把 “真值” 轉(zhuǎn)為 true , “假值” 轉(zhuǎn)為 false

Boolean()方法的示例:

Boolean("");               //false   “假值”
Boolean("zdx");            //true    “真值” 
Boolean(66);               //true    “真值” 
Boolean(null);             //false   “假值”
Boolean(0);                //false   “假值”
Boolean(new Object());     //true    “真值” 

Number()

有以下規(guī)律:

falsenull""[],轉(zhuǎn)為0

true , 轉(zhuǎn)1

數(shù)字轉(zhuǎn)數(shù)字

全是數(shù)字的字符串轉(zhuǎn)數(shù)字

數(shù)組內(nèi)全是數(shù)字(不能有逗號(hào))轉(zhuǎn)數(shù)字

數(shù)組內(nèi)字符串全是數(shù)字(不能有逗號(hào))轉(zhuǎn)數(shù)字

其他都是 NaN

大栗子:

Number(false);            //0 
Number(null);             //0 
Number("");               //0 
Number([]);               //0
Number(true);             //1 
Number("66");             //66 
Number("66f");            //NaN 
Number(new Object());     //NaN 
Number([66]);             //66
Number(["66"]);           //66       
Number([6,6]);            //NaN
Number(["6f6"]);          //NaN

String()

String()可把任何值轉(zhuǎn)換成字符串。它就是調(diào)用傳進(jìn)參數(shù)toString()方法。使用String()轉(zhuǎn)換成字符串和調(diào)用toString()方法的唯一不同之處在于,對(duì)nullundefined值轉(zhuǎn)換可以生成字符串而不引 發(fā)錯(cuò)誤:

String()方法的示例:

String(null);            //"null" 

var   null   =   null; 
null.toString();        //報(bào)錯(cuò)

Object()

這個(gè)函數(shù),使用 和 不使用 new 是一樣的。

它會(huì)把原始值,根據(jù)它的類型,使用對(duì)應(yīng)的構(gòu)造函數(shù),創(chuàng)建一個(gè)對(duì)象。nullundefined 和創(chuàng)建一個(gè)空對(duì)象。

Object(66);           //數(shù)字對(duì)象,等于  new Number(66)
Object("66");         //字符串對(duì)象,等于  new String("666")
Object(true);         //布爾對(duì)象, 等于  new Boolean(true)
Object(null);         //空對(duì)象,等于 new Object()
Object(undefined);    //空對(duì)象,等于 new Object()
二、隱式轉(zhuǎn)換 (一)、所有類型 轉(zhuǎn)為 布爾

JavaScript 的基礎(chǔ)類型中 有布爾類型,這個(gè)類型的值,只有兩個(gè)值---- true 和 false

任意的JavaScript 的值都可以轉(zhuǎn)換為布爾值。但只有下面這六個(gè)值會(huì)轉(zhuǎn)為false:

""
0
-0
null
undefined
NaN

其他所有值,包括所有對(duì)象(數(shù)組)都會(huì)轉(zhuǎn)換為 true。布爾值 false,和上面6個(gè)能轉(zhuǎn)為false 的值,我們一般稱為“假值”,其他值稱為“真值”。(“真值”等價(jià)true,“假值”等價(jià)false)

注意!!!在JavaScript 中 ,任何希望使用布爾值的地方,都會(huì)將操作數(shù)當(dāng)作 “真假” 或 “假值” 對(duì)待(即把“真值”當(dāng)true,“假值”當(dāng)false)。這句話你現(xiàn)在不懂沒(méi)事,看完下面的,或許你就懂了,哈哈。

(二)、原始值 轉(zhuǎn)為 數(shù)字

字符串 轉(zhuǎn) 數(shù)字

當(dāng)字符串里,全為數(shù)字時(shí),轉(zhuǎn)數(shù)字,其他都為NaN。空字符串就轉(zhuǎn)0

+ "666";    //666
+ "66f";    //NaN
+ "";       //0

布爾轉(zhuǎn)數(shù)字

這個(gè)比較簡(jiǎn)單了。
true 轉(zhuǎn) 1;false 轉(zhuǎn) 0;

+ true;   //1
+ false;  //

null 轉(zhuǎn)數(shù)字

null 轉(zhuǎn) 0。

+ null;        //0

undefined 和 NaN 轉(zhuǎn)數(shù)字

undefined 和 NaN 都轉(zhuǎn) NaN。

+ undefined;   //NaN
+ NaN;         //NaN
(三)、原始值 轉(zhuǎn)為 字符串

這個(gè)也比較簡(jiǎn)單,原始值 到 字符串,就原封不動(dòng)的轉(zhuǎn)(加個(gè)雙引號(hào))。

"zdx" + true;    //"zdxtrue"
(四)、 引用類型( 對(duì)象 )轉(zhuǎn)為 原始值

對(duì)象 轉(zhuǎn) 布爾

對(duì)象 轉(zhuǎn) 布爾 都為 true;等同于 Boolean()

![];     //false    這里取反了,注意,取反會(huì)把操作值轉(zhuǎn)布爾
!{};     //false

對(duì)象 轉(zhuǎn) 數(shù)字

對(duì)象 轉(zhuǎn) 數(shù)字 ,首先調(diào)用 valueOf(),如果返回的是原始值,再轉(zhuǎn)數(shù)字(需要的話),并返回;否則調(diào)用 toString(), 如果返回的是原始值,再轉(zhuǎn)數(shù)字,并返回;否則 拋出一個(gè)類型錯(cuò)誤。

+ [];    //0
//[].valueOf();   返回?cái)?shù)組本身[],所以調(diào)用 [].toString(); 返回 空字符串"",""再轉(zhuǎn)數(shù)字 0;
+ (new Date());   //1526008864094
//調(diào)用  (new Date()).valueOf(); 返回1526008864094

對(duì)象 轉(zhuǎn) 字符串

對(duì)象 轉(zhuǎn) 字符串 ,跟轉(zhuǎn)數(shù)字的規(guī)則一樣。只不過(guò)是轉(zhuǎn)字符串。
首先調(diào)用 valueOf(),如果返回的是原始值,再轉(zhuǎn)字符串(需要的話),并返回;否則調(diào)用 toString(), 如果返回的是原始值,再轉(zhuǎn)字符串,并返回;否則 拋出一個(gè)類型錯(cuò)誤。

"66" + [];    //"66"
"66" + {};    //"66[object Object]"

總結(jié):對(duì)象對(duì)原始值,除了布爾類型,其他都是先調(diào)用valueOf,然后根據(jù)需要調(diào)用toString。

想知道,js 每個(gè)內(nèi)置對(duì)象的valueOf()toString()方法,可以翻到最下面,附錄

三、隱式轉(zhuǎn)換 發(fā)生的地方

隱式轉(zhuǎn)換通常發(fā)生在表達(dá)式 和 運(yùn)算符 。

(1)加減乘除: 加號(hào) +
二元運(yùn)算符用法(兩個(gè)操作數(shù))

可以對(duì)數(shù)字做加法, 也可以做字符串連接操作。
當(dāng)兩個(gè)操作數(shù) 都是 數(shù)字 或 字符串時(shí),計(jì)算是顯然的。其他情況下,有如下規(guī)則

對(duì)象轉(zhuǎn)原始值,除了Date 對(duì)象 直接調(diào)用toString,其他對(duì)象,調(diào)用自身的valueOf 方法,但有的對(duì)象自身沒(méi)有valueOf,或者得到的不是原始值,此時(shí)調(diào)用toString

第一步轉(zhuǎn)換后,如果其中一個(gè)是字符串的話,另一個(gè)操作數(shù)也轉(zhuǎn)字符串,進(jìn)行字符串連接。

否則,都轉(zhuǎn)為數(shù)字(或者NaN),進(jìn)行加法。

栗子來(lái)了:

1 + new Date();     //"1Fri May 11 2018 14:20:50 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)"

1 + new Number(2);    //3  (new Number).valueOf(); 返回2, 和1 做加法

"66" + 6;       //666    6 轉(zhuǎn) "6"

1 + {};         //"1[object Object]"   ({}).toString()

true + false;   //1    都轉(zhuǎn)數(shù)字

1 + null;       //1    null 轉(zhuǎn)數(shù)字

1 + undefined;  //NaN   undefined 轉(zhuǎn) NaN

實(shí)際代碼中,經(jīng)常這樣

var x = 66;
x + "";     //"66"    等價(jià)于 String(x)

注意:兩點(diǎn)!

不要把對(duì)象字面量形式的值放在前面。

從左到右的進(jìn)行 + 運(yùn)算。

//對(duì)象字面量形式放在前面的結(jié)果比較復(fù)雜,不建議使用。(下面的結(jié)果不是唯一的)
{} + 1;     //1
{} + "1";   //1
{} + {};    //"[object Object][object Object]"
{x:1} + {};  //NaN

//從左到右,逐個(gè)做 + 運(yùn)算
1 + 2 + "";    //"3"
1 + "" + 2;    //"12"
一元運(yùn)算符用法(一個(gè)操作數(shù))

把操作數(shù)轉(zhuǎn)換為 數(shù)字(或者NaN),并返回它。

+ "666";       //666   等價(jià)于 Number("666")
+ undefined;   //NaN
減號(hào) -

都是轉(zhuǎn)數(shù)字。

- "666";    //-666
- "66f";    //NaN
1 - null;   //1
乘號(hào) *

都是轉(zhuǎn)數(shù)字

1 * "666";     //666
1 * null;      //0
除號(hào) /

都是轉(zhuǎn)數(shù)字

"666" / 1;     //666
1 / true;      //1
(2)比較運(yùn)算符 (> < >= <=)

比較運(yùn)算符用來(lái)檢測(cè)兩個(gè)操作數(shù)(數(shù)字或字符串)的大小關(guān)系(數(shù)值大小或者字符串首個(gè)字符的16位Unicode的大小 )。

比較運(yùn)算符的操作數(shù)可能是任意類型。但只有數(shù)字和字符串才能比較。因此,它會(huì)把別的操作數(shù)進(jìn)行類型轉(zhuǎn)換,規(guī)則如下:

對(duì)象轉(zhuǎn)原始值,如果valueOf()返回原始值,直接比較,否則,調(diào)用toString()進(jìn)行轉(zhuǎn)換。

轉(zhuǎn)原始值后,如果兩個(gè)操作數(shù)都是字符串,那么將按字符串首個(gè)字符的16位Unicode的大小 進(jìn)行比較。

否則都轉(zhuǎn)數(shù)字比較。Infinity比任何數(shù)字都大(除了自身),-Infinity 相反。如果一個(gè)操作數(shù)是NaN(或轉(zhuǎn)NaN),結(jié)果返回false。

11 < 3;

"11" < "3";   //true    "11" 首個(gè)字符串 "1" 的16位Unicode 值比 "3"的16位Unicode 小

//"11".charCodeAt(0).toString(16) 31

//"3".charCodeAt(0).toString(16)  33

"11" < 3;     //false   "11" 轉(zhuǎn) 11,false

{} < 3;       //false   {}轉(zhuǎn)原始值字符串,字符串轉(zhuǎn)NaN, false

null < 3;     //true    null 轉(zhuǎn)數(shù)字

最后要注意的是,<= 和 >= 比較時(shí),并不根據(jù) == 和 === 的規(guī)則(在下方)比較,它就僅僅表示 數(shù)值 或 字符串 之間的比較。

 null >= undefined    //false
(3)in運(yùn)算符

把左操作數(shù)轉(zhuǎn) 字符串

in 運(yùn)算符希望它的左操作數(shù)是一個(gè)字符串或可以轉(zhuǎn)換為字符串,右操作數(shù)是一個(gè)對(duì)象。如果,右側(cè)的對(duì)象擁有一個(gè)名為左側(cè)操作數(shù)值的屬性名,那么表達(dá)式返回true。

var point = { x:1, y:2};
"x" in point;    //true  point 有一個(gè) x 的屬性名

var arr = [a,b,c];
1 in arr;        //true   數(shù)組的索引就相當(dāng)于 屬性名
(4)! 和 !!

! 它會(huì)把操作值 轉(zhuǎn)為 布爾值(“真值”為true,“假值”為false),對(duì)布爾值求反。(結(jié)果只有true,false)

例:

console.log(!"");           //true
console.log(!0);            //true
console.log(!-0);           //true
console.log(!null);         //true
console.log(!undefined);    //true
console.log(!NaN);          //true
console.log(!false);        //true

!! 得到操作值 等價(jià)的 布爾值(“真值”為true,“假值”為false)
等同于 Boolean(),經(jīng)常稱!! 為強(qiáng)制轉(zhuǎn)換。
例:

console.log(!!"");           //false
console.log(!!0);            //false
console.log(!!-0);           //false
console.log(!!null);         //false
console.log(!!undefined);    //false
console.log(!!NaN);          //false
console.log(!!false);        //false

總結(jié):“假值” 取反都是true, “真值”取反為false;“假值” 強(qiáng)制轉(zhuǎn)換 都是 false, “真值”強(qiáng)制轉(zhuǎn)換為 true

(5)== 和 ===

都知道 == 是判斷 左右值 是否想等的。而 === 不僅判斷 右右值是否想等,還要判斷,類型是否一樣。結(jié)果返回布爾值

== 的用法
NaN是JavaScript中唯一一個(gè)不等于任何值的(包括它自己)。(NaN == NaN) // false

一般對(duì)NaN的判斷:

function isNaN(num){
    return typeof num === "number" && num !== num;
}

注意,跟js 自帶的 isNaN 方法 不一樣。

左右兩邊類型相同

1、原始值的比較

它們的比較,就是值的直接比較。
比如:

console.log(null == null);               //true
console.log(undefined == undefined);     //true
console.log(666 == 666);                 //true
console.log(666 == 1);                   //false
console.log("周大俠啊" == "周大俠啊");      //true
console.log("周大俠啊" == "大佬");         //false
console.log(true == true);               //true
console.log(true == false);              //false

2、對(duì)象的比較

對(duì)象和原始值不同,首先,它們是可變的-----它們的值是可修改的:

var o = { x:1 };   //定義一個(gè)對(duì)象
o.x = 2;           //修改x的值

var a = [1,2,3];   //數(shù)組也是可修改的
a[0] = 0;          //修改數(shù)組第一個(gè)元素

對(duì)象的比較并非值的比較,而是引用(內(nèi)存地址)的比較。

var o1 = { x:1 };
var o2 = { x:1 };
console.log( o1 == o2 );    //false
//即使 對(duì)像的屬性,值完全相同, 也不相等

var o3 = o1;
console.log( o1 == o3 );    //true
//o3 和  o1 引用的是同一對(duì)象。(即指向的是同一塊儲(chǔ)存地址)

//數(shù)組同上
左右兩邊類型不同

如果 == 兩邊的 類型不同,則比較時(shí),有以下兩個(gè)個(gè)規(guī)則:

undefined等于null

其他都轉(zhuǎn)數(shù)字比較

對(duì)象通過(guò)valueOf 或 toString 轉(zhuǎn)換為原始值,原始值在對(duì)應(yīng)轉(zhuǎn)數(shù)字。

總結(jié):左右兩邊類型不同, == 在比較時(shí),除了(null == undefined),NaN,其他都是轉(zhuǎn)為數(shù)字比較, 從來(lái)不會(huì)轉(zhuǎn)為布爾值!

舉個(gè)大栗子:

//1. undefined等于null
undefined == null; //ture

//2. 字符串和數(shù)字比較時(shí),字符串轉(zhuǎn)數(shù)字
"0" == 0;  //true
"f" == 0;  //false
//字符串轉(zhuǎn)數(shù)字時(shí),只有在字符串是純數(shù)字時(shí),轉(zhuǎn)對(duì)應(yīng)數(shù)字,其他都轉(zhuǎn)為 NaN。

// 3. 字符串和布爾比較時(shí),都轉(zhuǎn)為數(shù)字
"0" == false;   //true
"1" == true;    //true

//4. 數(shù)字和布爾比較時(shí),布爾轉(zhuǎn)數(shù)字
1 == true;    //true
0 == false;   //true
//true 轉(zhuǎn) 1, false 轉(zhuǎn)0;

//5.對(duì)象 和 字符串,數(shù)字比較, 都轉(zhuǎn)數(shù)字。
new String("66") == "66";      //true
new String("zdx") == "zdx";    //false
new String("66") == 66;        //true
=== 的用法

這個(gè)比較,首先,看兩邊類型是否一致,不一致, 直接false,一致的話,再根據(jù) == 的使用規(guī)則, 進(jìn)行比較。

(6)!= 和 !==

這兩個(gè) 運(yùn)算 跟 取反(!) 操作是 不一樣 的!,注意區(qū)分。

這兩個(gè)運(yùn)算,是在 == 和 === 比較過(guò)后的結(jié)果,進(jìn)行取反(就是對(duì) true 和 false 取反,因?yàn)椋?= 和 === 的返回值 只有 true 和 false)。

簡(jiǎn)單栗子:

"0" == 0;  //true
"f" === 0;  //false

"0" != 0;  //false
"f" !== 0;  //true
(7)&&、||

&& 邏輯與

如果兩側(cè)都是布爾值, 進(jìn)行布爾(AND)運(yùn)算。

否則它會(huì)先計(jì)算左側(cè)表達(dá)式,如果為 “假值”,返回這個(gè)值,如果是“真值”,計(jì)算右側(cè)表達(dá)式,并返回計(jì)算結(jié)果。

看:

true && false;       //false
1 && 2;              //2
null && 2;           //null
1-1 && 2;            //0
2-1 && 0;            //0

所以,有時(shí)候就會(huì)這樣寫代碼:

if( a==b ) start();
a == b && start();    //效果同上

|| 邏輯或

它跟 && 的行為是一樣的,只是它的做的是布爾(OR)運(yùn)算,返回的情況相反

如果兩側(cè)都是布爾值, 進(jìn)行布爾(OR)運(yùn)算。

否則它會(huì)先計(jì)算左側(cè)表達(dá)式,如果為 “真值”,返回這個(gè)值,如果是“假值”,計(jì)算右側(cè)表達(dá)式,并返回計(jì)算結(jié)果。

true || false;       //true
1 || 2;              //1
null || 2;           //2
1-1 || 2;            //2
2-1 || 0;            //1
(8)if 語(yǔ)句

它會(huì)計(jì)算操作數(shù)的值,“真值” 表現(xiàn)為true , “假值” 表現(xiàn)為false。

附錄 一、Object

1、valueOf
返回對(duì)象本身。

({x:1,y:2}).valueOf();    //{x: 1, y: 2},返回的是對(duì)象!

2、toString
返回 "[object type]",其中type是對(duì)象的類型。

//這里使用函數(shù)的call方法,指定 this的指向
var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(Math); // [object Math]

toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]
二、Boolean

1、valueOf
返回布爾值。

(true).valueOf();    //true , 返回的是原始值,Boolean類型

2、toString
返回該對(duì)象的字符串形式。

(true).toString();     //"true",返回的是原始值,string類型
三、Date

1、valueOf
返回存儲(chǔ)的時(shí)間是從 1970 年 1 月 1 日午夜開(kāi)始計(jì)的毫秒數(shù) UTC。

(new Date()).valueOf();    //1525943413141  一串?dāng)?shù)字

2、toString
返回一個(gè)美式英語(yǔ)日期格式的字符串.

(new Date()).toString();    //"Fri May 11 2018 10:26:16 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)"  原始值,string類型
四、Number

1、valueOf
返回?cái)?shù)字值。

(66).valueOf();    //66   返回的是原始值,Number類型

2、toString
返回的是原始值,String類型
根據(jù)2 8 16 (范圍2 - 36)分別轉(zhuǎn)為二進(jìn)制 八進(jìn)制 十六進(jìn)制字符串,,
不帶參,就默認(rèn)為10, 轉(zhuǎn)十進(jìn)制。
例:

(66).toString(2);    //"1000010"
(66).toString(8);    //"102"
(66).toString(16);   //"42"
五、String

1、valueOf
返回字符串值。

("666").valueOf();    //"666"   返回的是原始值,String類型
("zdx").valueOf();    //"zdx"   返回的是原始值,String類型

2、toString
和valueOf 效果一樣,返回字符串值。

("666").toString();    //"666"   返回的是原始值,String類型
("zdx").toString();    //"zdx"   返回的是原始值,String類型
六、Array

1、valueOf
自身沒(méi)有該方法,繼承Object.prototype.valueOf。返回的是數(shù)組對(duì)象!

([1,2,3]).valueOf();     //(3) [1, 2, 3],

2、toString
返回表示該數(shù)組的字符串,跟使用 Array.prototype.join(","),效果等同

([1,2,3]).toString();     //"1,2,3",    原始值,string類型
([1,2,3]).join(",");      //"1,2,3",
七、Function

1、valueOf
自身沒(méi)有該方法,繼承Object.prototype.valueOf。
返回的是函數(shù),使用typeof 返回 function,但注意原始值沒(méi)有function類型

function a(){ console.log(666) };
a.valueOf();    //? a(){ console.log(666) };  

2、toString
返回當(dāng)前函數(shù)源代碼的字符串。

function a(){ console.log(666) };
a.toString();    //"function a(){ console.log(666) }";返回的是原始值,string類型
八、Error

1、valueOf
自身沒(méi)有該方法,繼承Object.prototype.valueOf。
返回Error 對(duì)象本身

(new Error("fatal error")).valueOf();   //Error: fatal error

2、toString
返回一個(gè)指定的錯(cuò)誤對(duì)象(Error object)的字符串表示。

var e = new Error("fatal error");
print(e.toString()); // "Error: fatal error"
九、Math

它是全局對(duì)象, 不屬于函數(shù)。
1、valueOf
自身沒(méi)有該方法,繼承Object.prototype.valueOf。

Math.valueOf();     //返回Math 對(duì)象本身

2、toString
自身沒(méi)有該方法,繼承Object.prototype.toString。

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

文章版權(quán)歸作者所有,未經(jīng)允許請(qǐng)勿轉(zhuǎn)載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請(qǐng)注明本文地址:http://specialneedsforspecialkids.com/yun/94965.html

相關(guān)文章

  • 進(jìn)擊JavaScript)變量聲明提升

    摘要:如下代碼輸出的結(jié)果是代碼執(zhí)行分為兩個(gè)大步預(yù)解析的過(guò)程代碼的執(zhí)行過(guò)程預(yù)解析與變量聲明提升程序在執(zhí)行過(guò)程中,會(huì)先將代碼讀取到內(nèi)存中檢查,會(huì)將所有的聲明在此進(jìn)行標(biāo)記,所謂的標(biāo)記就是讓解析器知道有這個(gè)名字,后面在使用名字的時(shí)候不會(huì)出現(xiàn)未定義的錯(cuò)誤。 showImg(https://segmentfault.com/img/remote/1460000012922850); 如下代碼輸出的結(jié)果是...

    LeexMuller 評(píng)論0 收藏0
  • 進(jìn)擊JavaScript(四)原型與原型鏈

    摘要:每一個(gè)由構(gòu)造函數(shù)創(chuàng)建的對(duì)象都會(huì)默認(rèn)的連接到該神秘對(duì)象上。在構(gòu)造方法中也具有類似的功能,因此也稱其為類實(shí)例與對(duì)象實(shí)例一般是指某一個(gè)構(gòu)造函數(shù)創(chuàng)建出來(lái)的對(duì)象,我們稱為構(gòu)造函數(shù)的實(shí)例實(shí)例就是對(duì)象。表示該原型是與什么構(gòu)造函數(shù)聯(lián)系起來(lái)的。 本文您將看到以下內(nèi)容: 傳統(tǒng)構(gòu)造函數(shù)的問(wèn)題 一些相關(guān)概念 認(rèn)識(shí)原型 構(gòu)造、原型、實(shí)例三角結(jié)構(gòu)圖 對(duì)象的原型鏈 函數(shù)的構(gòu)造函數(shù)Function 一句話說(shuō)明什么...

    XBaron 評(píng)論0 收藏0
  • 進(jìn)擊 JavaScript(二) 數(shù)據(jù)結(jié)構(gòu)

    摘要:的垃圾回收器,進(jìn)行回收。它們的數(shù)據(jù)就存放在堆內(nèi)存中,大小不一定,動(dòng)態(tài)分配內(nèi)存,可隨時(shí)修改。引用類型的變量存的是其在堆內(nèi)存中的地址,值的讀取,就是讀取這個(gè)內(nèi)存地址中儲(chǔ)存的內(nèi)容。 這東西還是很重要的,你要是搞懂了,就會(huì)去除很多困惑,比如不知道大家在學(xué)習(xí)js 的時(shí)候,有沒(méi)有對(duì) 基礎(chǔ)類型 和 引用類型 感到困惑過(guò),兩者之間 表現(xiàn)的不同之處。 js 不同其他編程語(yǔ)言,它是腳本語(yǔ)言。所以,它的數(shù)...

    BlackFlagBin 評(píng)論0 收藏0
  • 進(jìn)擊 JavaScript(四) 閉包

    摘要:此時(shí)產(chǎn)生了閉包。導(dǎo)致,函數(shù)的活動(dòng)對(duì)象沒(méi)有被銷毀。是不是跟你想的不一樣其實(shí),這個(gè)例子重點(diǎn)就在函數(shù)上,這個(gè)函數(shù)的第一個(gè)參數(shù)接受一個(gè)函數(shù)作為回調(diào)函數(shù),這個(gè)回調(diào)函數(shù)并不會(huì)立即執(zhí)行,它會(huì)在當(dāng)前代碼執(zhí)行完,并在給定的時(shí)間后執(zhí)行。 上一節(jié)說(shuō)了執(zhí)行上下文,這節(jié)咱們就乘勝追擊來(lái)搞搞閉包!頭疼的東西讓你不再頭疼! 一、函數(shù)也是引用類型的。 function f(){ console.log(not cha...

    Anleb 評(píng)論0 收藏0
  • 進(jìn)擊JavaScript(二)詞法作用域與作用域鏈

    摘要:一作用域域表示的就是范圍,即作用域,就是一個(gè)名字在什么地方可以使用,什么時(shí)候不能使用。概括的說(shuō)作用域就是一套設(shè)計(jì)良好的規(guī)則來(lái)存儲(chǔ)變量,并且之后可以方便地找到這些變量。 一、作用域 域表示的就是范圍,即作用域,就是一個(gè)名字在什么地方可以使用,什么時(shí)候不能使用。想了解更多關(guān)于作用域的問(wèn)題推薦閱讀《你不知道的JavaScript上卷》第一章(或第一部分),從編譯原理的角度說(shuō)明什么是作用域。概...

    denson 評(píng)論0 收藏0

發(fā)表評(píng)論

0條評(píng)論

最新活動(dòng)
閱讀需要支付1元查看
<