- HTML嵌入JavaScript
- JavaScript注釋
- JavaScript標(biāo)識符
- JavaScript保留關(guān)鍵字
- JavaScript內(nèi)置類型
- JavaScript變量
- JavaScript函數(shù)
- JavaScript數(shù)據(jù)類型
- JavaScript的typeof運算符
- JavaScript創(chuàng)建對象
- JavaScript Void
- JavaScript中 null、NaN和undefined的區(qū)別
- JavaScript流程控制語句
JavaScript數(shù)據(jù)類型
JavaScript中有5種數(shù)據(jù)類型：4種原始類型（基本數(shù)據(jù)類型）Undefined、Boolean、Number、String。1種引用數(shù)據(jù)類型—Object，自定義的函數(shù)也是一種引用數(shù)據(jù)類型，可以看做Object類型的子類型。ES6規(guī)范中又添加了一種新的類型：Symbol。
JavaScript是松散類型的，因此需要有一種手段來檢測給定變量的數(shù)據(jù)類型，typeof運算符就是負(fù)責(zé)提供這方面信息的操作符。對一個值使用typeof操作符可能返回下列某個字符串：
● "undefined"——如果這個值未定義；
● "boolean"——如果這個值是布爾值；
● "string"——如果這個值是字符串；
● "number"——如果這個值是數(shù)值；
● "object"——如果這個值是對象或null；
● "function"——如果這個值是函數(shù)；
語法有三種寫法：
● typeof 變量名
● typeof(變量名)
● typeof 函數(shù)名
示例：
<html>
<head>
<title>js中的數(shù)據(jù)類型</title>
<script language="javascript">
/*
回顧java語言中的數(shù)據(jù)類型：
基本數(shù)據(jù)類型：byte,short,int,long,float,double,boolean,char
引用數(shù)據(jù)類型：Object...
Javascript中的數(shù)據(jù)類型：
原始數(shù)據(jù)類型：Undefined,Boolean,Number,String
引用數(shù)據(jù)類型：Object
注意：自定義的函數(shù)，其實也是一種類型，
這個類默認(rèn)繼承Object類型。所以Function
也屬于引用數(shù)據(jù)類型。
JS中的數(shù)據(jù)類型的類型名就是一個擺設(shè)，沒用：
String s = "abc"; //Error
//js中變量的聲明不需要指定數(shù)據(jù)類型，是一種弱類型的語言
//JS程序因為是不需要編譯的，直接運行，所有變量的數(shù)據(jù)類型
//在程序運行階段確定。
var s = "abc";
s = false;
關(guān)于 typeof 運算符：
語法有三種寫法：
1.typeof 變量名
2.typeof(變量名)
3.typeof 函數(shù)名
typeof運算符的運算結(jié)果一定是“String”類型，并且只有以下6種結(jié)果：
"undefined"
"boolean"
"string"
"number"
"object"
"function"
typeof運算符主要存在的意義是判斷變量的數(shù)據(jù)類型。
*/
var i; //系統(tǒng)會默認(rèn)賦值 undefined, undefined是一個值，屬于Undefined類型。
alert(typeof(i) == "undefined"); //true
alert(typeof(i) == undefined); //false
if(typeof i == "undefined"){
i = 100;
alert(i);
}
var v = '中國';
if(typeof v == "number"){
alert(v + 10);
}else{
alert("它不是一個數(shù)字！");
}
//Object類是一種引用數(shù)據(jù)類型
//Object是JS中內(nèi)置的。
//Object既是一個函數(shù)的名字，也是一個類名。
var o = new Object();
alert(typeof(o)); //"object"
//User類中有一個屬性username
User = function(a){
this.username = a;
}
o = new User("SMITH");
alert(typeof(o)); //"object"
alert(typeof(User)); //"function"
</script>
</head>
<body>
</body>
</html>
Undefined類型
Undefined類型只有一個值，即特殊的undefined。在使用var聲明變量但未對其加以初始化時，這個變量的值就是undefined。
例如：
var message;
alert(message == undefined) //true
示例：
<html>
<head>
<title>Undefined類型</title>
<script language="javascript">
/*
Undefined類型只有1個值，這個值就是undefined
如果一個變量只聲明，沒有手動賦值，則系統(tǒng)默認(rèn)賦值undefined
*/
var i;
var i1 = undefined;
alert(i); //alert方法會使用()中的非字符串類型轉(zhuǎn)換成字符串類型。
alert(i1);//"undefined"
alert( i == i1); //true
</script>
</head>
</html>
Boolean類型
該類型只有兩個字面值：true和false。這兩個值與數(shù)字值不是一回事，因此true不一定等于1，而false也不一定等于0。
雖然Boolean類型的字面值只有兩個，但JavaScript中所有類型的值都有與這兩個Boolean值等價的值。要將一個值轉(zhuǎn)換為其對應(yīng)的Boolean值，可以調(diào)用類型轉(zhuǎn)換函數(shù)Boolean()，例如：
var message = 'Hello World';
var messageAsBoolean = Boolean(message);
在這個例子中，字符串message被轉(zhuǎn)換成了一個Boolean值，該值被保存在messageAsBoolean變量中?？梢詫θ魏螖?shù)據(jù)類型的值調(diào)用Boolean()函數(shù)，而且總會返回一個Boolean值。至于返回的這個值是true還是false，取決于要轉(zhuǎn)換值的數(shù)據(jù)類型及其實際值。下表給出了各種數(shù)據(jù)類型及其對象的轉(zhuǎn)換規(guī)則。
這些轉(zhuǎn)換規(guī)則對理解流控制語句（如if語句）自動執(zhí)行相應(yīng)的Boolean轉(zhuǎn)換非常重要，例如：
?var message = 'Hello World';
????if(message)
????{
????????alert("Value is true");
????}
運行這個示例，就會顯示一個警告框，因為字符串message被自動轉(zhuǎn)換成了對應(yīng)的Boolean值（true）。由于存在這種自動執(zhí)行的Boolean轉(zhuǎn)換，因此確切地知道在流控制語句中使用的是什么變量至關(guān)重要。
示例：
<html>
<head>
<title>Boolean類型</title>
<script language="javascript">
/*
Boolean類型只有兩個值：true、false
Boolean類型提供一個Boolean(數(shù)據(jù))函數(shù).
Boolean(數(shù)據(jù)) 函數(shù)：
1.該函數(shù)的作用是：將非Boolean類型轉(zhuǎn)換成Boolean類型。
2.該函數(shù)的運算結(jié)果一定是：true、false
3.轉(zhuǎn)換規(guī)則：
3.1 所有的“非""字符串”都被轉(zhuǎn)換成true
所有的 "" 被轉(zhuǎn)換成 false
3.2 任何非0的數(shù)字包括無窮大(Infinity)都被轉(zhuǎn)換成true
0和 NaN 都被轉(zhuǎn)換成false
3.3 任何“非null”對象都被轉(zhuǎn)換成 true
null 被轉(zhuǎn)換成false
3.4 undefined 是一個值，被轉(zhuǎn)換成 false
*/
var v1; //undefined
alert(Boolean(v1)); //false
v1 = "abc"; //非"" 字符串
alert(Boolean(v1)); //true
v1 = ""; //""字符串
alert(Boolean(v1)); //false
v1 = 0; //0
alert(Boolean(v1)); //false
v1 = NaN;
alert(Boolean(v1)); //false
v1 = Infinity; //無窮大
alert(Boolean(v1)); //true
v1 = null;
alert(Boolean(v1)); //false
v1 = new Object();
alert(Boolean(v1)); //true
//關(guān)于if語句 和java語法結(jié)果相同。區(qū)別在于if(這里的數(shù)據(jù)如果不是Boolean
//類型，系統(tǒng)會自動調(diào)用Boolean函數(shù)進(jìn)行類型的轉(zhuǎn)換)
var a = "ABCDEF";
if(a){
alert(a);
}else{
alert("空字符串");
}
</script>
</head>
</html>
Number類型
這種類型用來表示整數(shù)和浮點數(shù)值，還有一種特殊的數(shù)值，即NaN（非數(shù)值 Not a Number）。這個數(shù)值用于表示一個本來要返回數(shù)值的操作數(shù)未返回數(shù)值的情況。
NaN本身有兩個非同尋常的特點。首先，任何涉及NaN的操作（例如NaN/10）都會返回NaN，這個特點在多步計算中有可能導(dǎo)致問題。其次，NaN與任何值都不相等，包括NaN本身。例如，下面的代碼會返回false。
alert(NaN == NaN); //false
JavaScript中有一個isNaN()函數(shù)，這個函數(shù)接受一個參數(shù)，該參數(shù)可以使任何類型，而函數(shù)會幫我們確定這個參數(shù)是否“不是數(shù)值”。isNaN()在接收一個值之后，會嘗試將這個值轉(zhuǎn)換為數(shù)值。某些不是數(shù)值的值會直接轉(zhuǎn)換為數(shù)值，例如字符串”10“或Boolean值。而任何不能被轉(zhuǎn)換為數(shù)值的值都會導(dǎo)致這個函數(shù)返回true。例如：
alert(isNaN(NaN)); ???//true
alert(isNaN(10)); ???//false(10是一個數(shù)值)
alert(isNaN("10")); ???//false(可能被轉(zhuǎn)換為數(shù)值10)
alert(isNaN("blue")); ???//true(不能被轉(zhuǎn)換為數(shù)值)
alert(isNaN(true)); ???//false(可能被轉(zhuǎn)換為數(shù)值1)
示例：
<html>
<head>
<title>Number類型</title>
<script language="javascript">
/*
Number類型包括以下值：
整數(shù)(0,1,2,3.....)
浮點數(shù)(1.0,2.0,3.0.....)
NaN (這就是一個值，屬于Number類型，表示“不是一個數(shù)字”，Not a Number)
Infinity (這就是一個值，屬于Number類型，表示無窮大)
*/
//整數(shù)
var v1 = 0;
var v2 = 100;
alert(v2);
alert(typeof v2);
//浮點數(shù)
var v3 = 3.1;
alert(v3);
alert(typeof v3);
//Not a Number
var v4 = NaN;
alert(v4);
alert(typeof v4);
var v5 = 100/"中國"; //運算結(jié)果本該是數(shù)字卻沒有返回數(shù)字的，則返回NaN
alert(v5);
alert(typeof v5);
//Infinity
var v6 = 10/0; //除數(shù)是0的時候運算結(jié)果是無窮大Infinity。
alert(v6);
alert(typeof v6);
//js中是：3.333333
alert(10/3); //在java中是 3
/*
重點：isNaN函數(shù)
語法：isNaN(變量) 判斷該變量是否是一個數(shù)字。
“is not a number”
isNaN的運算結(jié)果是true、false
true：不是一個數(shù)字
false：是一個數(shù)字
*/
var ename = "JACK";
if(isNaN(ename)){
alert(ename + "不是一個數(shù)字");
}
var x = NaN;
var y = NaN;
//NaN和任何數(shù)據(jù)都不相等，和自己也不相等。
alert(NaN==NaN); //false
alert(isNaN(NaN)); //true
</script>
</head>
</html>
示例：
<html>
<head>
<title>Number類型</title>
<script language="javascript">
//isNaN
function checkAge(age){
var ageError = document.getElementById("ageError");
// 通過isNaN()判斷用戶輸入的數(shù)據(jù)是否是一個數(shù)值
if(isNaN(age)){
//alert("年齡必須是數(shù)字");
ageError.innerHTML = "<font color='red'>年齡必須是數(shù)字</font>";
return;
}
if(age<18 || age>50){
//alert("年齡不在指定范圍中");
ageError.innerHTML = "年齡不在指定范圍中";
return;
}
ageError.innerHTML = "";
}
function clearError(){
var ageError = document.getElementById("ageError");
ageError.innerHTML = "";
}
</script>
</head>
<body>
<!--
blur是失去焦點 onblur是失去焦點句柄
-->
<input
type="text"
name="userage"
onblur="checkAge(this.value);"
onfocus="clearError();"/>
<!--該圖層負(fù)責(zé)顯示錯誤信息,span不是獨占行的-->
<span id="ageError"></span>
</body>
</html>
有3個函數(shù)可以把非數(shù)值轉(zhuǎn)換為數(shù)值：Number()、parseInt()和parseFloat()。第一個函數(shù)，即轉(zhuǎn)型函數(shù)Number()可以用于任何數(shù)據(jù)類型，而另外兩個函數(shù)則專門用于把字符串轉(zhuǎn)換成數(shù)值。這3個函數(shù)對于同樣的輸入會返回不同的結(jié)果。
Number()函數(shù)的轉(zhuǎn)換規(guī)則如下：
1.如果是Boolean值，true和false將分別被替換為1和0
2. 如果是數(shù)字值，只是簡單的傳入和返回
3.如果是null值，返回0
4.如果是undefined，返回NaN
5.如果是字符串，遵循下列規(guī)則：
● 如果字符串中只包含數(shù)字，則將其轉(zhuǎn)換為十進(jìn)制數(shù)值，即”1“會變成1，”123“會變成123，而”011“會變成11（前導(dǎo)的0被忽略）
● 如果字符串中包含有效的浮點格式，如”1.1“，則將其轉(zhuǎn)換為對應(yīng)的浮點數(shù)（同樣，也會忽略前導(dǎo)0）
● 如果字符串中包含有效的十六進(jìn)制格式，例如”0xf“，則將其轉(zhuǎn)換為相同大小的十進(jìn)制整數(shù)值
● 如果字符串是空的，則將其轉(zhuǎn)換為0
● 如果字符串中包含除了上述格式之外的字符，則將其轉(zhuǎn)換為NaN
5.如果是對象，則調(diào)用對象的valueOf()方法，然后依照前面的規(guī)則轉(zhuǎn)換返回的值。
如果轉(zhuǎn)換的結(jié)果是NaN，則調(diào)用對象的toString()方法，然后再依次按照前面的規(guī)則轉(zhuǎn)換返回的字符串值。
var num1 = Number("Hello World"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number(true); //1
由于Number()函數(shù)在轉(zhuǎn)換字符串時比較復(fù)雜而且不夠合理，因此在處理整數(shù)的時候更常用的是parseInt()函數(shù)。parseInt()函數(shù)在轉(zhuǎn)換字符串時，更多的是看其是否符合數(shù)值模式。它會忽略字符串前面的空格，直至找到第一個非空格字符。如果第一個字符串不是數(shù)字字符或者負(fù)號，parseInt()會返回NaN；也就是說，用parseInt()轉(zhuǎn)換空字符串會返回NaN。如果第一個字符是數(shù)字字符，praseInt()會繼續(xù)解析第二個字符，直到解析完所有后續(xù)字符或者遇到了一個非數(shù)字字符。例如，"1234blue"會被轉(zhuǎn)換為1234，”22.5“會被轉(zhuǎn)換為22，因為小數(shù)點并不是有效的數(shù)字字符。
如果字符串中的第一個字符是數(shù)字字符，parseInt()也能夠識別出各種整數(shù)格式（即十進(jìn)制、八進(jìn)制、十六進(jìn)制）。為了更好的理解parseInt()函數(shù)的轉(zhuǎn)換規(guī)則，下面給出一些例子：
var num1 = parseInt("1234blue"); //1234
var num2 = parseInt(""); //NaN
var num3 = parseInt("0xA"); //10（十六進(jìn)制）
var num4 = parseInt("22.5"); //22
var num5 = parseInt(""070); //56（八進(jìn)制）
var num6 = parseInt("70"); //70
parsInt()可以把一個string按照同進(jìn)制進(jìn)行解析
var num7 = parseInt("10",”2”); //2（按二進(jìn)制解析） 2也可以使用”2”
var num8 = parseInt("10",8); //8(按八進(jìn)制解析)
var num9 = parseInt("10",10); //10（按十進(jìn)制解析）
var num10 = parseInt("10",16); //16（按十六進(jìn)制解析）
var num12 = parseInt("AF",16); //175
與parseInt()函數(shù)類似，parseFloat()也是從第一個字符（位置0）開始解析每個字符。而且也是一直解析到字符串末尾，或者解析到遇見一個無效的浮點數(shù)字字符為止。也就是說，字符串中的第一個小數(shù)點是有效的，而第二個小數(shù)點就是無效的了，因此它后面的字符串將被忽略。例如，”22.34.5“將會被轉(zhuǎn)換成22.34。
parseFloat()和parseInt()的第二個區(qū)別在于parseFloat始終都會忽略前導(dǎo)的零。由于parseFloat()只能解析十進(jìn)制值，因此它沒有用第二個參數(shù)指定基數(shù)的用法。
var num1 = parseFloat("1234blue"); //1234
var num2 = parseFloat("0xA"); //0
var num3 = parseFloat("22.5"); //22.5
var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5
String類型
String類型用于表示由零或多個16位Unicode字符組成的字符序列，即字符串。字符串可以由單引號(')或雙引號(")表示。
var str1 = "Hello";
var str2 = 'Hello';
任何字符串的長度都可以通過訪問其length屬性取得
alert(str1.length); //輸出5
要把一個值轉(zhuǎn)換為一個字符串有兩種方式。第一種是使用幾乎每個值都有的toString()方法。
var age = 11;
var ageAsString = age.toString(); //字符串"11"
var found = true;
var foundAsString = found.toString(); //字符串"true"
數(shù)值、布爾值、對象和字符串值都有toString()方法。但null和undefined值沒有這個方法。
多數(shù)情況下，調(diào)用toString()方法不必傳遞參數(shù)。但是，在調(diào)用數(shù)值的toString()方法時，可以傳遞一個參數(shù)：輸出數(shù)值的基數(shù)。
var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010" ; 2 可以是數(shù)值,也可以是sring格式的”2”
alert(num.toString(8)); //"12"
alert(num.toString(10)); //"10"
alert(num.toString(16)); //"a"
通過這個例子可以看出，通過指定基數(shù)，toString()方法會改變輸出的值。而數(shù)值10根據(jù)基數(shù)的不同，可以在輸出時被轉(zhuǎn)換為不同的數(shù)值格式。
在不知道要轉(zhuǎn)換的值是不是null或undefined的情況下，還可以使用轉(zhuǎn)型函數(shù)String()，這個函數(shù)能夠?qū)⑷魏晤愋偷闹缔D(zhuǎn)換為字符串。String()函數(shù)遵循下列轉(zhuǎn)換規(guī)則：
1.如果值有toString()方法，則調(diào)用該方法（沒有參數(shù)）并返回相應(yīng)的結(jié)果
2.如果值是null，則返回"null"
3.如果值是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"
示例：
<html>
<head>
<title>String類型</title>
<script language="javascript">
/*
1.js中的字符串可以使用
'' ; "" 都可以。
2. js中的字符串有l(wèi)ength屬性用來獲取字符串的長度
3. js 中的字符串有 prototype屬性，用來給字符串類型動態(tài)擴展屬性和方法
*/
var s1 = 'ABC';
alert(s1.length);
s1 = "AAAA";
alert(s1.length);
//Error:這里不能執(zhí)行。
//s1.trim();
//給字符串類多態(tài)擴展屬性和方法，該屬性和方法可以作用到所有字符串對象上。
String.prototype.trim = function(){
return this.replace(/^\s+/,"").replace(/\s+$/,"");
}
//調(diào)用
var s1 = " hello "
s1 =s1.trim();
alert(s1 + " ,長度:" + s1.length);
</script>
</head>
<body>
</body>
</html>
Object類型
對象其實就是一組數(shù)據(jù)和功能的集合。對象可以通過執(zhí)行new操作符后跟要創(chuàng)建的對象類型的名稱來創(chuàng)建。而創(chuàng)建Object類型的實例并為其添加屬性和（或）方法，就可以創(chuàng)建自定義對象。
var o = new Object();
Object的每個實例都具有下列屬性和方法：
constructor——保存著用于創(chuàng)建當(dāng)前對象的函數(shù)
prototype--------給類型動態(tài)擴展屬性（類級別），將作用到所有對象上。（類名.）方式訪問
hasOwnProperty(propertyName)——用于檢查給定的屬性在當(dāng)前對象實例中（而不是在實例的原型中）是否存在。其中，作為參數(shù)的屬性名(propertyName)必須以字符串形式指定（例如：o.hasOwnProperty("name")）
isPrototypeOf(object)——用于檢查傳入的對象是否是另一個對象的原型
propertyIsEnumerable(propertyName)——用于檢查給定的屬性是否能夠使用for-in語句來枚舉
toString()——返回對象的字符串表示
valueOf()——返回對象的字符串、數(shù)值或布爾值表示。通常與toString()方法的返回值相同。
示例：
<html>
<head>
<title>Object類型</title>
<script language="javascript">
/*
Object類型是JS中引用數(shù)據(jù)類型的頂層類型（根類型）。
自定義的函數(shù)也是一種類型，默認(rèn)繼承Object類。
Object類是JS中內(nèi)置的。
*/
//創(chuàng)建Object對象
var o1 = new Object();
//JS中的對象都有toString方法
alert(o1);
alert(o1.toString());
//關(guān)于constructor屬性，用來獲取創(chuàng)建該對象的構(gòu)造函數(shù)
alert(o1.constructor);
//關(guān)于prototype屬性，用來給類型動態(tài)擴展屬性以及方法
Emp = function(ename,sal){
this.ename = ename;
this.sal = sal;
/**/
this.toString = function(){
return this.ename + "--->" + this.sal;
}
}
var e1 = new Emp("KING",5000);
//Error
//e1.printInfo();
//動態(tài)擴展
Emp.prototype.printInfo = function(){
document.write(this.ename + "," + this.sal);
}
//調(diào)用方法
e1.printInfo();
alert(e1);
alert(e1.toString());
alert(e1.constructor);
</script>
</head>
<body>
</body>
</html>
