【js實例】js中的5種基本數據類型和9種操做符

時間 2019-11-18

原文原文鏈接

js中的5中基本數據類型

js標識符

第一個字符必須爲字母,下劃線,或美圓符
其餘字符能夠是字母,下劃線,美圓符,數字
js標識符區分大小寫
標識符不能使關鍵字和保留字

關鍵字:express

break	do	instanceof	typeof
case	else	new	var
catch	finally	return	void
continue	for	switch	while
debugger	function	this	with
default	if	throw
delete	in	try

保留字:瀏覽器

abstract	enum	int	short
boolean	export	interface	static
byte	extends	long	super
char	final	native	synchronized
class	float	package	throws
const	goto	private	transient
debugger	implement	protected	volatile
double	import	public

js註釋

//單行註釋

/*

多行註釋

*/

js模式

嚴格模式:使用 use strict 函數

混雜模式:不加 use strict this

js數據類型

js中有5中簡單數據類型,也成爲基本數據類型:Undefined, Null, Boolean, Number, String編碼

/*
=======================================================
Undefined類型只有一個值：undefined，表示未定義這個量
爲初始化的變量會自動賦予undefined值
*/

var message;
alert(typeof message);    //undefined
alert(age);                //出錯，不執行這條語句

var message2;
alert(typeof message2);    //undefined
alert(typeof age);        //undefined


/*
Null類型也只有一個值：null
*/

alert(typeof null);    //返回object，從邏輯角度來看，null值表示一個空對象指針
                        其實是瀏覽器的bug一直延續至今
alert(undefined == null);    //返回true，undefined派生自null值


/*
Boolean類型只有兩個值：true和false。注意：TRUE，True，FALSE，False不是Boolean類型，而是標識符
能夠對任何數據類型調用Boolean函數，總會返回一個Boolean值
數據類型            轉換爲true的值                            轉換爲fasle的值
Boolean             true                                     false
String             任何非空字符串                            ""(空字符串)
Number            任何非零數值(包括無窮大)                    0和NaN
Object            任何對象                                    null
Undefined         不適用                                    undefined
*/

alert(Boolean(true));        //true
alert(Boolean(false));        //false

alert(Boolean("s"));        //true
alert(Boolean(""));            //false

alert(Boolean(2));            //true
alert(Boolean(Infinity));    //true
alert(Boolean(0));            //false
alert(Boolean(NaN));        //false

alert(Boolean(new Object()));//true
alert(Boolean(null));        //false

alert(Boolean(undefined));    //false


/*
Number類型
進行算數運算時，全部的八進制和十六進制會轉化爲十進制數值
*/

//十進制
alert(23);         //23
alert(23.3);    //23.3
alert(2.3e4);    //23000

//若數字爲0開頭則視爲八進制，注意：八進制在嚴格模式下無效
alert(070);        //56

//十六進制的前兩位爲0x
alert(0x33);    //51

alert(Number.MAX_VALUE);//1.7976931348623157e+308
alert(Number.MIN_VALUE);//5e-324

/*
若數值不在MIN_VALUE和Number.MAX_VALUE之間，
1.num < 0, 返回-Infinity
2.num > 0, 返回Infinity
*/

var num = Number.MAX_VALUE + 1;
alert(num);        //Infinity
num = Number.MIN_VALUE - Number.MAX_VALUE;
alert(num);        //-Infinity


/*
NaN：非數值，not a number。表示一個原本返回數值的操做數未返回數值的狀況
1.任何涉及NaN的操做都會返回NaN
2.NaN和任何值都不相等
*/
alert(NaN - 10);    //NaN
alert(NaN == NaN);    //false

/*
isNaN()接受一個參數x，若x不是數值則返回true，反之返回false
isNaN()接受參數x時會嘗試將x轉化爲數值
*/
alert(isNaN(NaN));        //true
alert(isNaN(10));        //false
alert(isNaN("10"));        //false "10"能夠轉化爲數值10
alert(isNaN("blue"));    //true     "blue"不能夠轉化爲數值
alert(isNaN(false));    //false true可轉爲1，fasle可轉爲0


/*
數值轉換：Number(), parseInt()和parseFloat()
*/

//1.若是是Boolean值，則true返回1，false返回0
alert(Number(true));    //1
alert(Number(false));    //0

//2.若是是數值，則只是簡單的傳入和返回
alert(Number(23));    //23

//3.若是是null則返回0
alert(Number(null));    //0

//4.若是是undefined則返回NaN
alert(Number(undefined));    //NaN

//5.若是是NaN則返回NaN
alert(Number(NaN));    //NaN


//6.字符串
//6.1：若字符串中包含數字則將其轉換爲十進制數便可；忽略前導0
alert(Number("23"));    //23
alert(Number("23.3"));    //23.3
alert(Number("023"));    //23
alert(Number("023.3"));    //23.3
alert(Number("0xA"));    //10
//6.2：如果空字符串，則轉換爲0
alert(Number(""));        //0
//6.3：若字符串包含上述格式以外的字符則將其轉換爲NaN
alert(Number("23#"));    //NaN

//7.如果對象，則調用valueOf()方法，按上述方法轉換；若轉換爲NaN則調用toString()方法再次按上述方法轉換
var a = new Object();
alert(Number(a));        //NaN
a = "23";
alert(Number(a));        //23


//parseInt在解析字符串時和Number有點區別
//1.忽略空格，若第一個字符爲數字字符，則解析到非數字字符爲止
alert(parseInt("   123 4blue"));    //123，4前面的空格符是非數字字符
//2.空字符串返回NaN，沒法識別字符串也返回NaN
alert(parseInt(""));            //NaN
alert(parseInt("AF"));            //NaN
//3.能解析各類格式整數
alert(parseInt("0xA"));            //10
alert(parseInt("70"));            //70
alert(parseInt("070"));            //56，ECMAScript3認爲是56，ECMAScript5認爲是70
alert(parseInt("0xf"));            //15
//4.解析浮點數時，正數向下取整，負數向上取整
alert(parseInt(22.9));            //22
alert(parseInt(-22.9));            //-22


//能夠給parseInt傳遞第二個參數，指定轉換的進制
alert(parseInt("A", 16));    //10
alert(parseInt(110, 2));    //6
alert(parseInt(110, 8));    //72
alert(parseInt(110, 10));    //110
alert(parseInt(110, 16));    //272


/*
parseFloat()與parseInt相似；不過parseFloat()只解析十進制；若parseFloat()解析的是整數(也可沒有小數點，或者小數點後全爲0)，
則返回整數
*/
alert(parseFloat("0xA"));    //10
alert(parseFloat("2.000"));    //2
alert(parseFloat(2.000));    //2

/*
String類型
EMCAScript中的字符串是不可變的，字符串一旦建立它們的值就不能改變。
要改變某個變量保存的字符串，首先要銷燬原來的字符串，而後再用一個包含新值得字符串填充該變量
*/

var lang = "Java";
lang = lang + "Script";    //先建立一個字符串用"JavaScipt填充"，再銷燬原來的Java和Script字符串

//Boolean，Number，String，Object類型都有toString()方法，可是null和undefined沒有
var t = true;    
alert(t.toString());//true

var num = 16;
alert(num.toString());        //16
alert(num.toString(2));        //10000
alert(num.toString(8));        //20
alert(num.toString(10));    //16
alert(num.toString(16));    //10
num = 10;
alert(num.toString(16));    //a

var str = "23";
alert(str.toString());        //23

var a = new Object("2#");    //2#
alert(a.toString());

/*
String()方法：若是值有toString()方法，則調用該方法；若是值是null則返回null；若是值是undefined則返回undefined
*/
var value1 = 10;
var value2 = true;
var value3 = null;
var value4;

alert(String(value1));    //10
alert(String(value2));    //true
alert(String(value3));    //null
alert(String(value4));    //undefined


/*
Obejct類型
Object的每一個實例都有下列屬性和方法
constructor:保存着用於建立當前對象的函數
hasOwnProperty(propertyName):用於檢查給定的屬性當前對象實例中(不是實例的原型)是否存在
isPrototypeOf(object):用於檢查傳入的對象是不是當前對象的原型
proPertyIsEnumerable(propertyName):用於檢查給定的屬性是否能使用for-in語句來枚舉
toLocaleString():返回對象的字符串表示
toString():返回對象的字符串表示
valueOf():返回對象的字符串,數值或布爾值表示
*/
var o = new Object();    //建立對象
var o = {
    "age" : 13
}

//給對象添加屬性
o.name = "libra";
o.money = "100";

//訪問屬性
alert(o.age);        //13
alert(o.name);        //libra
alert(o["name"]);    //100


//檢測類型
var str = "Nicholas";
var bool = true;
var int = 22;
var undi;
var nul = null;
var ob = new Object();
var arr = new Array();

//typeof經常使用來檢測基本類型值,也可用來檢測引用類型值
alert(typeof str);        //string
alert(typeof bool);        //boolean
alert(typeof int);        //number
alert(typeof undi);        //undifined
alert(typeof nul);        //null
alert(typeof ob);        //object
alert(typeof arr);        //object

/*
instanceof 經常使用來檢測引用類型值
*/
//注意:全部引用類型值爲Object實例,因此始終會返回true,可是基本類型不是對象,則返回false;
alert(ob instanceof Object);        //true
alert(str instanceof Object);        //false
alert(arr instanceof Object);        //true
alert(arr instanceof Array);        //true

js操做符

js有9種操做符:一元操做符,位操做符,布爾操做符,乘性操做符,加性操做符,關係操做符,相等操做符,條件操做符,賦值操做符spa

/*
一元操做符：+, -, ++, --
+, -, ++, --能夠做用於任何值
*/
var age = 10;
alert(age++);    //10,下一個age是11
alert(++age);    //執行++後爲12
alert(age--);    //12，下一個age是11
alert(age);        //11
alert(--age);    //執行--後爲10
alert(age + 10);    //20
alert(age - 10);    //0

//鏈接符
alert("我有" + age + "歲了！");    //我有10歲了!


/*
位操做符：~, &, |, ^, <<, >>, >>>
若對非數值應用位操做符，會先使用Number()函數將該值轉換爲一個數值(自動完成),而後再應用位操做。
*/

//按位非~：操做數的負數減一
alert(~1);            //-2
alert(~"1");        //-2
//按位與&：對應的二進制數進行邏輯與操做，返回1或0
alert(25 & 3);        //1
//按位與|：對應的二進制數進行邏輯或操做，返回1或0
alert(25 | 35);        //59
//按位與^：對應的二進制數進行邏輯異或操做，返回1或0
alert(25^3);        //26
//左移：二進制數左移n位，空位用0填充；a << n = a * 2^n;
alert(2 << 3);        //16
//有符號右移：二進制數右移n位，空位用符號位填充
alert(25 >> 3);        //3
//無符號右移對於正數，和有符號右移同樣
alert(64 >>> 5);    //2
//無符號右移對於負數，二進制數右移n位，空位用0填充
alert(-64 >>> 5);    //134217726


/*
布爾操做符：！, &&, ||
&&, || 爲短操做，即如果第一個操做數能決定結果則不會對第二個操做數求值
能夠應用於任何類型的操做數，返回布爾值true或false或操做數
*/
//1.若操做數是一個對象則返回false
alert(!new Object(2));    //false
//2.若操做數是空字符串則返回true
alert(!"");                //true
//3.若操做數是任何非空字符串則返回false
alert(!"@#4");            //false
//4.若操做數是數值0則返回true
alert(!0);                //true
//5.若操做數是任何非零數值(包括無窮)則返回false
alert(!12);                //false
alert(!Infinity);        //false
//6.若操做數是null，NaN，undefined則返回true
alert(!null);            //true
alert(!NaN);            //true
alert(!undefined);        //true

//對於邏輯與操做，若第一個操做數爲false則結果爲false
//1.若第一個操做數爲對象則返回第二個操做數
alert(new Object("23") && "34");//34
//2.若第二個操做數爲對象，則當第一個操做數爲true時返回該對象
alert(true && new Object(2));    //2
alert(false && new Object(2));    //false
//3.//若兩個操做數都爲對象則返回第二個操做數
alert(new Object("23") && new Object(2));    //2
//4.如有一個操做數是null則返回null
alert(null && 2);                //null
alert(2 && null);                //null
//5.如有一個操做數是NaN則返回NaN
alert(NaN && 2);                //NaN
alert(2 && NaN);                //NaN
//6.如有一個操做數是undefined則返回undefined
alert(undefined && 2);            //undefined
alert(2 && undefined);            //undefined
//7.任何數值(包括Infinity)爲true
alert(0 && 3);

//對於邏輯或操做，若第一個操做數爲true則結果爲true
//1.若第一個操做數是對象則返回該對象
alert(new Object(2) || false);    //2
//2.若第二個操做數是對象,則當第一個操做數爲false時返回該對象
alert(false || new Object(2));    //2
//3.若兩個操做數是對象,則返回第一個操做數
alert(new Object(33) || new Object(3));//33
//4.若兩個操做數是null, NaN, Undefined，當操做數同樣時則返回它們自己，不同是返回第二個操做數
alert(null || null);            //null
alert(NaN || NaN);                //NaN
alert(undefined || undefined);    //undefined
alert(NaN || undefined);        //undefined


/*
乘性操做符:*, /, %
*/
//乘法：*
//1.若操做數都是數值則返回數值,若數值範圍超過了ECMAScript的表示範圍則返回Infinity和-Infinity
alert(2 * 3.3);            //6.6
alert(2 * Number.MAX_VALUE);//Infinity
//2.任何NaN的操做返回NaN
alert(2 * NaN);            //NaN
//3.Infinity * 0 返回NaN
alert(Infinity * 0);    //NaN
//4.Infinity乘以非零數值則返回Infinity或者-Infinity
alert(Infinity * 2);    //Infinity
alert(Infinity * -2);    //-Infinity
alert(Infinity * Infinity);        //Infinity
alert(Infinity * -Infinity);    //-Infinity
//5.如有操做數不是數值，則後臺調用Number()方法轉換，在應用上述規則
alert(2 * "2");            //4
alert(2 * "2#");        //NaN, 應爲"2#"用Number()轉換後爲NaN


//除法：/
//1.若操做數都是數值則返回數值，若數值範圍超過了ECMAScript的表示範圍則返回Infinity和-Infinity
alert(2 / 2);            //1
alert(2 / Number.MIN_VALUE);//Infinity
//2.任何NaN操做都返回NaN
alert(2 / NaN);            //NaN
//3.Infinity / Infinity返回NaN
alert(Infinity / Infinity);    //NaN
//4. 0 / 0 返回NaN
alert(0 / 0);            //NaN
//5.非零有限數被零除則返回Infinity或-Infinity
alert(0 / 23);            //0
alert(23 / 0);            //Infinity
//6.Infinity被任何非零數值除，則返回Infinity或-Infinity
alert(Infinity / 4);    //Infinity
alert(4 / Infinity);    //0
//7.如有操做數不是數值，則後臺調用Number()方法轉換，在應用上述規則
alert(2 / "2");            //1
alert(2 / "2#");        //NaN, 應爲"2#"用Number()轉換後爲NaN



//求模：%
//1.若操做數是數值則按常規計算
alert(5 % 12);            //2
//2.被除數是無窮,除數是有限數值則返回NaN
alert(Infinity % 2);    //NaN
alert(-Infinity % 2);    //NaN
//3.若被除數是有限數值, 除數是無窮則返回被除數
alert(2 % Infinity);    //2
//4.若被除數是有限數值,除數是零則返回NaN
alert(2 % 0);            //NaN
//5.若被除數和除數都是Infinity則返回NaN
alert(Infinity % Infinity);    //NaN
//6.若被除數是0則結果是0
alert(0 % 32);            //0
//7.如有操做數不是數值，則後臺調用Number()方法轉換，在應用上述規則
alert(2 % "2");            //0
alert(2 % "2#");        //NaN, 應爲"2#"用Number()轉換後爲NaN


/*
加性操做符：+, -
*/
//加法+
//1.任何NaN操做返回NaN
alert(1 + NaN);                //NaN
//2.Infinity + Infinity = Infinitu；Infinity - Infinity = NaN；
alert(Infinity + Infinity);    //Infinity
alert(Infinity + -Infinity);    //NaN
alert(-Infinity + -Infinity);    //-Infinity, -(Infinity + Infinity)
//3. 0 + 0 = 0； 0 - 0 = 0；
alert((+0) + (+0));            //+0, +(0 + 0)
alert((+0) + (-0));            //+0, +(0 - 0)
alert((-0) + (-0));            //-0, -(0 + 0)
//4.若操做數中有字符串，則+就是鏈接符，則調用toString()， 或String()方法將操做數變成字符串再進行拼接
alert("##" + 23);            //"##23"
alert(null + "3");            //"null3"


//減法-
//1.任何NaN操做返回NaN
alert(1 - NaN);                    //NaN
//2.Infinity + Infinity = Infinitu；Infinity - Infinity = NaN；
alert(Infinity - Infinity);        //NaN
alert(Infinity - -Infinity);    //Infinity, Infinity + Infinity
alert(-Infinity - Infinity);    //-Infinity, -(Infinity + Infinity)
//3. 0 + 0 = 0； 0 - 0 = 0；
alert((+0) - (+0));                //+0, +(0 - 0)
alert((+0) - (-0));                //+0, +(0 + 0)
alert((-0) - (-0));                //-0, -(0 - 0)
//4.若操做數中有字符串，則+就是鏈接符，則調用toString()， 或String()方等法將操做數變成字符串再進行拼接
alert("##" - 23);                //NaN, "##"轉換後爲NaN
alert(null - "3");                //-3,
alert(3 - null);                //3
alert(undefined - "3");            //NaN
alert(3 - undefined);            //NaN


/*
關係操做符：>, <, <=, >= 返回true或false
*/
//若兩個操做數是數值,則執行數值比較
alert(2 >= 3);//false
//若是兩個操做數是字符串,則比較兩個字符串對應的字符編碼值
alert("a" > "3");//true
//如有操做數不是數值,則將其轉換爲字符串進行比較
alert(2 < "3");//true
//若操做數是對象則調用valueOf()，toString()等方法轉換後進行比較
alert(new Object("2") >= 3);//false
//若操做數是布爾值則先將其轉換爲數值再執行比較
alert(true >= false);//true


/*
相等操做符：==, !=, ===, !==
==, !=:先轉換再比較
===, !==:僅比較不轉換
*/
alert(true == 1);                //true
alert(false == 0);                //true
alert(true == 2);                //false
alert(false == -1);                //false
alert("23" == "23");            //true
alert(new Object(2) == "2");    //true
alert(null == undefined);    //true
alert(null == 0);            //false
alert(undefined == 0);        //false
alert(NaN != NaN);            //true

alert("2" == 2);    //true, 先將"2"轉換爲數值2在比較
alert("2" === 2);    //false，直接進行比較
alert("2" !== 2);    //true


/*
條件操做符： expression ? result1 : result2;
*/
var num = 1 > 2 ? 3 : 4;
alert(num);            //4, 1 > 2 爲假
num = 1 < 2 ? 3 : 4;
alert(num);            //3, 1 < 2 爲真



/*
賦值和計算
*/
var num1, num2;
num1 = num2 = 2;
alert(num1 *= num2);//4
num1 = num2 = 2;
alert(num1 /= num2);//1
num1 = num2 = 2;
alert(num1 %= num2);//0
num1 = num2 = 2;
alert(num1 += num2);//4
num1 = num2 = 2;
alert(num1 -= num2);//0
num1 = num2 = 2;
alert(num1 <<= num2);//8
num1 = num2 = 2;
alert(num1 >>= num2);//0
num1 = num2 = 2;
alert(num1 >>>=num2);//0

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。