JavaScript 包含三部分
1.ECMAScript 語言的核心 常用的是ECMA 3
2. 文檔對象模型 DOM
3. 瀏覽器對象模型 BOM\
基本數據類型
數字
字符串
布爾值
undefined
null
undefined 和 null 的區別是一個是未定義，一個是定義了但是沒有值
非基本類型（即對象）
查看類型操作符 typeof
number
string
boolean
undefined
object
function
number 類型的變量
如果以數字0開始，那代表着是八進制數。
如果以0x開始，那代表着是十六進制數。
2e+3 是指數表示法，代表2後面加3個0 ，即2000
Infinity 是一個特殊值，表示超越了JS處理的最大數
NaN 是一個數字，比如拿數字和字母相操作就會得到NaN，而且據有傳染性。
任何數據轉字符串類型
var a = “” + anyVar
typeof a
->String
特殊字符串
\ 代表 \
\’ 代表 ’
\” 代表 “
\n 換行符
\r 回車符
\t 製表符
\u Unicode碼
邏輯運算符
！
&&
||
比較運算符
== 相等運算（兩邊的變量會自動轉換爲相同的類型後進行比較）
===嚴格相等運算，幕後不存在任何轉換
!= 同上
!== 同上
>
=
<
<=
NaN==NaN 會返回false
數組
var a=[]
var a=[‘1’, ‘2’, ‘3’]
var a=[‘b’, ‘a’, 3] //可以是不同的數據的類型
數組裏也可以套數組
a[0]=[1,2,3]
另外字符串也是數組
var a=”abc”
a[2] 的值爲c
if 表達式
if(a>2) {
var result = a;
} else {
var result = b;
}
代碼塊
{
// 任意行代碼
}
三目運算符
var a=1
var b=a==1?’1’:’2’
b
“1”
switch 語句
var a=1
var result=”
switch (a) {
case 1:
result="number1";
break;
case 2:
result='number2 ';
break;
default:
result="default";
break;
}
變量的複製
數組及對象類型複製是引用傳遞
var a=[1,2,3]
undefined
var b=a
undefined
b
[1, 2, 3]
b[0]=9
9
b
[9, 2, 3]
a
[9, 2, 3]
基本類型複製應該是值傳遞（只試驗了數值類型和字符類型）
var a="abc"
undefined
var b=a
undefined
b="def"
"def"
b
"def"
a
"abc"
循環
while
var i=0;
while(i<10){
i++;
}
do while
var i=0;
do{
i++;
}while(i<10)
for
for (var i=0;i<10;i++) {
//any code
}
可以把循環體中的內容挪上去，如下
for (var i=0;i<10;i++,//any code) {
}
死循環
for(;;) { }
for-in
var a = [1,2,3];
var result;
for ( var tmp in a )
{
result = result + tmp; //此處的tmp是數組下標
result = result + a[tmp]; //此處取的是相應的值
}
函數
組成部分
function 函數名稱 (參數1，參數2，參數3，) {
// 代碼塊
return 語句
}
調用時
參數傳少了會返回NaN
參數傳多了，多的參數會被忽略
arguments 爲內建變量，它能返回函數所接收的所有參數
function sum() {
var i, res = 0,
num = arguments.length;
for (i = 0; i < num; i++) {
res += arguments[i];
}
return res;
}
sum(1,2,3,4,5)
15
sum(1,2)
3
預定義函數
parseInt()
parseFloat()
isNaN()
isFinite()
encodeURI()
decodeURI()
encodeURIComponent()
decodeURIComponent()
eval()
parseInt(param) // 默認爲十進制 也就是radix=10
parseInt(param,radix)
parseInt("1000",2)
8
parseInt("1000",10)
1000
parseInt("1000",16)
4096
parseInt("1000",17)
4913
encodeURI()
encodeURI("http://www.baidu.com?key=魯")
"http://www.baidu.com?key=%E9%B2%81"
encodeURIComponent("http://www.baidu.com?key=魯")
"http%3A%2F%2Fwww.baidu.com%3Fkey%3D%E9%B2%81"
encodeURI() 用於編碼整個URI,因爲URI中的合法字符都不會被編碼轉換。
encodeURIComponent方法在編碼單個URIComponent（指請求參 數）應當是最常用的，它可以講參數中的中文、特殊字符進行轉義，而不會影響整個URL。
eval() 會把其輸入的字符串當做JS代碼來執行 (比較危險)
eval('var ii=2');
ii;
2
這也就意味着，可以動態的執行未知的代碼。
作用域
function f () { local=1; }
undefined
local
ReferenceError: local is not defined
f()
undefined
local
1
以上代碼說明了，在變量名如果不加var會被當作全局變量的，在函數被加載過一次以後纔可以訪問。
函數也是數據
使用函數標識記法（function literal notation）
var f = function () { return 1; }
f
function () { return 1; }
f()
1
typeof f
"function"
函數與變量一樣，命名規則爲除數字開頭以外的任何數據都可以（字母，數字，下劃線，美元符號）
匿名函數
var f = function (a) { return a; }
f(9)
9
用法：
作爲參數傳遞給其它函數
執行某些一次性任務
函數回調
function add(a, b) {
return a() + b();
}
調用時可使用匿名函數
add (
function () { return 1; },
function () { return 2; },
);
執行結果爲： 3
當我們將函數A傳遞給函數B，並且由B來執行A時，A就成了一個回調函數（callback functions）。
應用：
不做命名的情況下傳遞函數
將一個函數的操作委託給另一個函數
有助於提高性能
例：第一步使用第二步的值
本來要定義兩個函數，現在定義一個。
function multi(a,b,c,callback) {
var i,ar=[];
for (int i=0;i<3;i++) {
ar[i]=callback(arguments[i] * 2);
}
}
下面是如何調用
multi(1,2,3, function(a) { return a+2 } )
即時函數
(
function() {
alert(‘boo’);
}
)();
定義 ：函數定義之後馬上執行
帶參數的如下：
(
function(name) {
alert(name);
}
)(‘boo’);
另外一種寫法：
(
function() {
alert(‘boo’);
}()
);
內部（私有）函數
其實就是函數裏套函數（作用域跟函數一樣）
function outer(param) {
function inner(theinput) {
return theinput * 2; //這裏邊的東西對外不可見
}
return inner(param)
}
函數返回函數
function a() {
alert(‘A!’)
return function() {
alert(‘B!’)
};
}
var test = a()
test()
B!
閉包
作用：可以利用閉包突破作用域鏈
e.g(1):
var a=’global’
var F=function(){
var b=’local’
var N=function () {var c=’inner’; return b;};
return N;
};
var inner = F();
inner();//此處調用時可以訪問F裏的局部變量
//輸出：local
e.g(2):
var inner; var F=function () {
var b=’local’
var N=function() { return b };
inner=N;
};
undefined
F()
undefined
inner()
“local”
e.g(3):
function F() {
var arr = [],
i;
for (i = 0; i < 3; i++) {
arr[i] = function() {
return i;
}
}
return arr;
}
undefined
var arr=F()
undefined
arr0
3
arr1
3
// 事實證明返回來的只是一個函數結構體，具體執行時纔去真正取相應的數值 ，那時候 i 已經執行完成，所以都是3
對象
一個簡單的對象
var hero={
breed:’Turtle’,
occupation:’NinJia’
};
一個空對象
var hero={};
undefined
typeof hero
“object”
屬性的訪問方式：
hero.breed //第一種 適合知道明確的變量名
“Turtle”
hero[breed]
ReferenceError: breed is not defined
hero[‘breed’] //第二種適合動態的變量名，運行時才能確定 ‘breed’ 可以換成變量
“Turtle”
添加和刪除屬性
hero={}
Object {}
hero
Object {}
hero.a=1
1
hero.b=2
2
hero
Object {a: 1, b: 2}
delete hero.a
true
hero
Object {b: 2}
返回對象的函數
function fact(name) {
return {name:name};
}
var o = fact(‘one’);
構造器函數
function Hero() {
this.occupation=’NinJia’;
}
undefined
var hero=new Hero()
undefined
hero.occupation
“NinJia”
通過構造器的好處之一是它可以在創建對象時接收一些參數。一般構造器函數首字母都大寫。
如果 var hero = Hero(); //沒有new 關鍵字。那this.occupation將會變爲全局變量。
通過構造器函數克隆對象
function Hero() {
this.occupation=’NinJia’;
}
var hero2=new hero.constructor();// new 關鍵字不可少
undefined
hero2
hero {occupation: “NinJia”}
hero.occupation=”Reporter”
“Reporter”
hero
hero {occupation: “Reporter”}
hero2
hero {occupation: “NinJia”}
對象比較時，比較的是地址 ，所以即使內容相同的對象==時也爲false
控制檯
console.log()/console.error()
Array 數組對象
var a=[]
a.length //長度
typeof a.length
undefined
var abc=[]
undefined
abc.length=6 //此處可以手動設置length
6
abc
[undefined × 6]
abc[0]==undefined //比較的時候，是沒有引號的
true
abc[0]==”undefined”
false
eval 相同的作用(Function 內建構造器)
var sum=new Function(‘a’,’b’,’return a+b’);
undefined
sum(1,2)
3
函數也是對象(基類是Object，跟Java一樣)
例如我創建了一個函數
function fun(a,b){return a+b;}
undefined
fun.toString //可以調用這個對象的基類方法toString 來返回這個方法的源碼
“function fun(a,b){return a+b;}” //自定義方法的話，會返回全部代碼
parseInt.toString()
“function parseInt() { [native code] }”//本地方法的話，會返回native code
call() 函數
作用：代碼重用
var some = { name:’ninjia’, say:function(who){ return ‘hi,’+who+’,i am a’ + this.name; } }
undefined
some.say(‘kobe’)
“hi,kobe,i am aninjia”
var lu={name:’luxiaoshuai’};
undefined
some.say.call(lu,’kobe’) //此處使用call函數將新對象傳入，say方法裏的this將會指向新對象。
“hi,kobe,i am aluxiaoshuai”
apply() 函數
使用方法同call()函數一樣，不同的是調用時傳入的參數
some.say.apply(lu,[‘kobe’])
“hi,kobe,i am aluxiaoshuai”
如果有多個參數，[‘kobe’, ‘Jodan’, ‘Elfson’] 這樣寫即可
推斷對象類型
Object.prototype.toString.call({})
“[object Object]”
Object.prototype.toString.call([])
“[object Array]”
number 的基本類型是 Number ，可以使用new 關鍵字來創建, typeof 爲 object
轉換某個數字爲二進制時，可以使用
(8).toString(2) //十進制轉2進制
“1000”
parseInt(‘1000’,2) //二進制轉10進制
8
String 類型
內置方法
toUpperCase()
toLowerCase()
str.charAt(0)
str[0] 效果同上
indexOf
lastIndexOf
工具類
Math
Date
正則表達式
以下是兩種寫法
var re=new RegExp(“j.*t”);
var re=/j.*t/;
正則的屬性：
g 默認爲false，找到第一行就會停止
i 忽略大小寫，默認爲false
m 跨行搜索 ，默認爲 false，不跨行
使用屬性時：
var re=new RegExp(“j.*t”, “img”);
var re=/j.*t/img;
正則的方法
test() 返回匹配結果
exec() 返回匹配上的字符
/j.*t/.test(“JavaScript”)
false
/j.*t/i.test(“JavaScript”)
true
/j.*s/i.exec(“JavaScript”)
[“JavaS”]
match() 返回匹配對象
search() 返回所找到的第一個匹配的索引位置
“JavaScriptjerryshi”.match(/j/ig)
[“J”, “j”]
“JavaScriptjerryshi”.search(/j/ig)
0
“aJavaScriptjerryshi”.search(/j/ig)
1
“aavaScriptjerryshi”.search(/j/ig)
10
replace()
split()
“JavaScriptjerryshi”.replace(/j/ig,’z’) //將全部j替換成z
“zavaScriptzerryshi”
“JavaScriptjerryshi”.replace(/j/ig,”) //將全部j刪除掉
“avaScripterryshi”
回調式替換
找到字符串時，如果還想進一步處理怎麼辦，不要着急，看下面就知道了。
“JavaScriptjerryshi”.replace(/j/ig,’z’) //將全部j替換成z，並且加上引號
如下：
function replaceC(match) { return “’”+match+”’” ;} // 定義一個函數用來處理
undefined
“JavaScriptjerryshi”.replace(/j/ig,replaceC) // 第二個參數傳自定義的回調函數
“‘J’avaScript’j’erryshi”
‘one, two, three,for’.split(“,”)
[“one”, ” two”, ” three”, “for”]
‘one, two, three,for’.split(/\s*,\s*/)
[“one”, “two”, “three”, “for”]
異常處理
try {
notEx()
} catch (e) {
console.log(“error”)
} finally {
console.log(“alway run this”)
}
error VM1479:2
undefined
這種異常的處理方式跟Java很像了，不知道誰抄的誰的。
方法的length屬性就是參數的個數
function abc(a,b,c){}
undefined
abc.length
3
function abc(a){}
undefined
abc.length
1
原型
prototype 是函數的屬性
function normal(name,color) { this.name=name; this.color=color; }
undefined
normal.prototype={price:100,count:3} //定義原型
Object {price: 100, count: 3}
var a = new normal(‘lu’,’red’);//第一個對象
undefined
a.price
100
var a2 = new normal(‘tom’,’blue’);//第二個對象
undefined
a2.price
100
a.price = 50 //修改第一個對象的原型值
50
a2.price //第二個對象沒有跟着變
100
normal.prototype.pri
undefined
normal.prototype.price=10 //修改原型的值
10
a2.price // 第二個對象變了，根原型保持一致（此時第二個對象沒修改過這個值）
10
a.price // 第一個對象沒變
50
a2.price=40//修改第一個對象的原型值
40
normal.prototype.price=12 //修改原型的值
12
a2.price// 第二個對象沒變
40
a.price// 第一個對象沒變
50
當所有對象的原型值沒有發生過改變時，此時修改函數的原型值，所有通過構造器生成的對象都會跟着發生改變。
如果對象的原型值已經發生改變了，那麼此時不會跟着函數的原型值改變而改變。
自身屬性和原型屬性重名時，自身屬性優先。