系統內建函式

php基礎學習筆記（3）

變數：

變數的含義：就是用於表示一個資料的代號——我們自己定義的一個名字。

變數的定義：var v1; var v2 = 2; var v3, v4, v5; var v6, v7=7, v8, v9=”abc”;

變數的使用:

賦值：v1 = 1; v1 = 1+2+3; v1 = v2 + “abc”; v1 = v1 + 5; v1 = v1 + v1;

取值：m1 = v1; //將v1的值取到，再賦值給m1

m2 = v1 + 5; //將v1的值取到，再跟5相加，然後賦值給m2

alert( v1 ); //將v1的值取到，並交給alert去“彈出”

document.write( v1 ); //將v1的值取到，並交給document.write去“輸出”

alert( “v1=” + v1); //取到v1的值，並和字串“v1=”進行串連運算，然後結果被alert。

document.write( “v1=” + v1);

資料類型：

基本類型：

布爾類型： boolean; 這種類型只有兩個值可用： true, false

字串類型： string; 可以用單引號或雙引號表示，含義相同；

數字類型： number

複合類型：

數組： Array,

對象： Object

特殊類型：

null：空類型——可以給一個變數明確賦值為“null”，這就是空值，也是空類型，只是表示一個“含義”：該變數沒有給有效值。

undefined: 未定義：此類型通常就是對應“根本就還沒有給值”這種狀態。

算術運算子：　＋　　－　　　＊　　　／　　　％

注意點：

1， 除法（/）就是數學上的自然除，而不是C語言的除法含義。

2， ++ 和 -- 稱為一元運算子，即只針對一個變數進行運算

3， 但 ++ 和 – 可以在運算式（比如指派陳述式）中使用，則類似同時進行了2件事：自加（或自減）和運算式本身的計算，此時他們放在變數的前面和後面有不同含義。

a) var i = 1; var s1 = i++; //結果是：s1為1，i為2

b) var i = 1; var s2 = ++i; //結果是：s2為2，i為2

比較子：> >= < <= == != === !==

比較子用於資料的大小比較，通常是數字。其中值得注意的是：

==被稱為“模糊相等”，即資料的內容或經過轉換後的內容相等，就認為是相等。

===稱為“嚴格相等”，只有資料的類型和資料的內容都相等的時候才算是相等。

——從電腦的角度來說，一個資料具有兩個方面：資料類型和資料值（資料內容）

邏輯運算子：只用於對bool值進行運算。

邏輯與( && )：兩個資料只有都是true的時候，結果才是true

邏輯或( || )：兩個資料只要有一個是true，結果就是true

邏輯非( ! )：擷取一個bool值的“相反值”

字串運算子：

只有一個串連運算子（ + ）: 含義是“串連兩個字串”

辨析算術運算子的加法（ + ）:

此加號( + )兩個的資料只要有一個是字串，則都會按字串的“串連”含義進行運算，另一如果不是字串，則會自動轉換為字串後再進行串連運算。

位元運算符：

位元運算符只針對數位二進位形式進行。

var v1 = 5; //這是10進位，二進位其實是：101,在電腦內部其實類似這樣： 00000101

var v2 = 6； //這是10進位，二進位其實是：110,在電腦內部其實類似這樣： 00000110

按位與：

符號： &

含義：將兩個位元字的對應位上的數字進行“與運算”，結果還是這些位元運算的結果組成的位元所代表的值。

解釋：位元字進行“與運算”的規則是：

1 & 1 è 1

1 & 0 è 0

0 & 1 è 0

0 & 0 è 0

舉例：

var v1 = 5, v2 = 6，運算圖示為：

v1=5	0	0	0	0	0	1	0	1
v2=6	0	0	0	0	0	1	1	0
v1 & v2	0	0	0	0	0	1	0	0

var v3 = v1 & v2 = 00000100(2) = 4(10)

按位或：

符號： |

含義：將兩個位元字的對應位上的數字進行“或運算”，結果是這些位元運算的結果組成的位元所代表的值。

解釋：位元字進行“或運算”的規則是：

1 | 1 è 1

1 | 0 è 1

0 | 1 è 1

0 | 0 è 0

按位非：

符號： ~ //這是一個“單目運算子”

含義：將一個位元字的對應位上的數字進行“非運算”，結果是這些位元字所代表的值。

解釋：位元字進行“非運算”的規則是：

~1 è 0

~0 è 1

按位左移運算：

符號： <<

含義： 將一個位元的每一個位上的數字往左邊移動指定的位元，並且左邊“冒”出去的就不管了（不算了），右邊空出來的位上填入“0”，得到的結果就是該位元字所代表的值。

舉例：

var v1 = 5；var v2 = 5 << 2; 運算圖示為：

v1=5	0	0	0	0	0	1	0	1
v2= 5 << 2	0	0	0	1	0	1	0	0

var v2 = 5 << 2 = 00010100(2) = 1 * 24 + 1*22 = 16+4 = 20(10)

按位左移運算：

符號： >>

含義： 將一個位元的每一個位上的數字往右邊移動指定的位元，並且右邊“冒”出去的就不管了（不算了），左邊空出來的位上填入原來的左邊的數字，得到的結果就是該位元字所代表的值。

舉例：

var v1 = 5；var v2 = 5 >> 2; 運算圖示為：

v1=5	0	0	0	0	0	1	0	1
v2= 5 >> 2	0	0	0	0	0	0	0	1

var v2 = 5 >> 2 = 00000001(2) = 1(10)

運算子其他內容：

賦值運算子：其實就一個基本的賦值運算子： = ,其含義是將等號右邊的資料放到等號左邊的變數中去。

錯誤的文法：

var v1 = 1, v2 = 2, v3 = 5, v4 = -2;

v1 + v2 = v3 + v4; //錯，大錯，大錯特錯

複合賦值運算子： += -= *= /= %=

運算子的優先順序 —— 太多，較為複雜，記不住，但請記住一下幾條規則：

1， 要心如明鏡：運算子有優先順序（先後順序）問題。

2， 括弧最優先，等號（賦值）最落後。

3， 先乘除後加減

4， 想不清楚或用不明白的，使用括弧來解決

5， 括弧只有小括弧，可以一層層嵌套。

舉例：

var year = 2013;

//判斷閏年：一個年份能被4整除並且不能被100整除是閏年，或者能被400整除，也是閏年。

if ( ( (year % 4 == 0) && (year % 100 != 0) ) || (year % 400 == 0) )

{ documment.write( year + “是閏年”) ;}

資料的傳值方式：

var v1 = 10;

var v2 = v1; //將v1中值拷貝一份，放到v2這個變數中去了——此時也可以說成“將v1的值傳遞給v2”

var v1 = v1 + v1; //v1的值改變了，但並不影響v2——因為v2本身也是一個獨立的變數。

document.write("
v1=" + v1); //20

document.write("
v2=" + v2); //10, 不會，40，

上述“v2 = v1”就稱為“拷貝傳值”——取得v1的值並拷貝一份，然後賦值給v2

var v3 = {name:"小花", age:18, edu:"大學" }; //這是一個所謂“對象”類型——其中包括了3個資料。

//操作其中的資料類似這樣：

document.write("
v3這個對象的年齡為：" + v3.age);

v3.age = 19; //v3這個對象的age這項資料的值重複賦了一個新值，類似前面v1 = 20;

var v4 = v3; //此時，是將v3這個變數的“記憶體位址”傳遞給v4這個變數，而v3這個對象的資料本身其實只是由該地址來擷取。——這就叫做引用傳值——此時，其實這兩個變數是一樣的資料內容，類似一個人的多個名字：真名，藝名，網名，小名

document.write("
v4這個對象的年齡為：" + v4.age);

v3.age = 20; //

document.write("
此時，v4這個對象的年齡為：" + v4.age);

總結：

在js中，基礎資料型別 (Elementary Data Type)使用 “拷貝傳值”——傳值的時候直接就出現了一份新的資料（當然同時也是另一個變數所代表）

複合資料型別（數組和對象）使用“引用傳值”——傳值的時候只是做了一個地址指向，資料仍然只有一份，兩個變數就指向這同一份資料。

if分支結構：

控制結構：就是使用一定的文法來控制我們程式執行的流程——也可以叫“流程式控制制結構”

分支就是“多條路徑，走一條”。

最簡形式：

//如果此條件滿足（即條件判斷的結果是true），則會執行其中的語句塊，否則什麼也不做。

if( 條件判斷語句 )

{

//要執行的語句塊——語句塊其實就是一種表示“n條語句”泛泛說法。

}

二選一分支形式：含義是兩條路，必走一條。

if( 條件判斷語句 )

{

//要執行的語句塊1——前麵條件成立時執行

}

else

{

//要執行的語句塊2——前麵條件不成立時執行

}

多選一分支結構：多條路根據條件的滿足情況走其中一條，但也可能一條都不走：

if( 條件判斷1 ) //如果此條件滿足，則執行語句塊1，然後if就結束了

{

//語句塊1

}

else if ( 條件判斷2 ) //如果條件1不滿足，則判斷條件2：如果滿足，則執行語句塊2，並結束if

{

//語句塊2

}

else if ( 條件判斷3 ) //如果條件2不滿足，則判斷條件3：如果滿足，則執行語句塊3，並結束if

{

//語句塊3

}

…………………… //依此類推。。。。。。如果沒有一個條件滿足，則其實到最後什麼也不會執行，if結束。

綜合型式：

if( 條件判斷1 ) //如果此條件滿足，則執行語句塊1，然後if就結束了

{

//語句塊1

}

else if ( 條件判斷2 ) //如果條件1不滿足，則判斷條件2：如果滿足，則執行語句塊2，並結束if

{

//語句塊2

}

else if ( 條件判斷3 ) //如果條件2不滿足，則判斷條件3：如果滿足，則執行語句塊3，並結束if

{

//語句塊3

}

……………. //依此類推。。。。。。

else

{

//最後的else語句塊。 //此語句塊會在前麵條件都不滿足的時候去執行。

}

注意：綜合型式中是必有一條分支（語句塊）會得到執行。

switch分支結構：

switch的分支結構整體含義跟if類似，也是表示“多條路走一條”，其使用形式：

switch ( 一個變數或運算式 ) //不管是變數還是運算式，最終都代表一個“值”，我們用v1來說話

{

case 固定值1： //如果v1等於本值1，則會執行語句塊1

//語句塊1；

break； //退出此switch結構

case 固定值2： 如果v1不等於前面值1，則繼續判斷是否等於這裡的值2，如果相等，執行語句2

//語句塊2；

break； //退出此switch結構

case ………………………………

。。。。。。。。。。。。。。。。。

default: //如果前面各個判斷都不成立（也就是不相等），則會執行此語句塊。

//注意：switch中此default語句塊可以沒有。

//預設語句塊

}

特別注意：if語句其實是可以使用非常靈活的條件判斷，比如 > >= < <= == != === ，但，switch這裡case的判斷，只能有一種判斷：相等判斷。

while迴圈結構：

迴圈的基本觀念：

1， 迴圈就是讓某些程式（語句塊）反覆執行

2， 迴圈必須能夠有辦法停止——電腦沒有自己的判斷能力去決定“累了，不做了”

while迴圈的基本文法形式：

while ( 條件判斷 ) //如果條件判斷滿足了，則會執行其中的語句塊，否則while結束。

{

//要執行的語句塊

} //如果此語句塊執行完了，會立即回到前面while的位置繼續判斷。

上述形式只是文法上的基本要求，但，在“實用”中，通常會需要遵照如下模式：

【迴圈變數初始化】

while ( 【迴圈變數作為條件判斷】 )

{

//迴圈體，就是要反覆執行的語句塊

【迴圈變數值的改變】

}

do while迴圈結構：

do while迴圈是一種會先執行一次，然後再根據判斷條件來決定是否繼續執行並迴圈的一種迴圈結構。

do while的實用形式如下：

【迴圈變數初始化】

do

{

//迴圈體，就是要反覆執行的語句塊

【迴圈變數值的改變】

} while ( 【迴圈變數作為條件判斷】 ) ;

描述： 先執行do後面打括弧中的語句塊，然後再進行while語句中的條件判斷，如果判斷成立（true），則繼續回到上面do後面的大括弧中執行語句塊，否則就結束。

for迴圈結構——推薦使用：

for迴圈基本形式：

for( 【迴圈變數初始化A】； 【迴圈變數作為條件判斷B】； 【迴圈變數值的改變C】 )

{

//迴圈體D，也就是要反覆執行的語句塊

}

for迴圈的執行邏輯（順序）：

A è Bètrue è D è C è Bètrue è D è C è Bè

┗èfalseèfor迴圈結束 ┗èfalseèfor迴圈結束

函數

函數不是數。

函數只是一種文法結構。

函數是一種將若干行代碼“封裝”起來作為一個整體而使用的一種文法結構。

函數可以說是一種需要去定義並使用的文法——類似變數：需要定義，並使用之。

函數是為了完成某種特定功能且通常是“需要反覆執行的功能”——函數的目的就是執行其中包起來的那些代碼塊（語句塊）

函數是一個獨立的執行空間，即其內容的代碼跟函數外部的代碼可以認為是“分離”的。

函數的定義形式：

function 函數名( 形式參數1， 形式參數2， …… )

{

//其中要執行的語句塊——函數體

}

var s1 = parseInt(3.5); //3

var s2 = parseInt(3.8); //3

var s3 = parseInt(3.1); //3

var s4 = parseInt(3.0); //3

var s5 = parseInt(3); //3

——parseInt其實就是一個函數——系統內建函式。此函數具有一種“神奇的能力”：將給他的一個數字轉變成一個相應的整數，該整數是不大於該給定數位最大整數。

提出需求：

我想要求3和4兩個直角邊對應的斜邊。

還還想要球5和6對應的斜邊，還有，7和8，還有。。。。。。。。

函數到底是什嗎？函數只是模組化編程思想的文法體現——所謂模組化編程思想就是將各種“反覆要執行的任務”做出一個獨立的“模組”，用的時候就“直接調用”，這樣就節省了反覆要寫的那些代碼。

函數的調用形式：

函數名( 實際參數1， 實際參數2， ….. );

函數調用過程：

1， 首先將調用函數處的實際參數值一一對應傳遞給函數定義處的形式參數。

a) 形式參數一定只能是一個“變數名”，它代表一定的實際含義——根據函數功能而定。

b) 實際參數一定只能是一個“資料”（可能為直接資料或變數資料）

c) 注意：形式參數中的變數名不能使用var，也不能在其他地方定義。

2， 接著程式的執行流程進入到函數內部，按應該的流程執行函數中的“所有語句”

3， 函數內部程式執行完畢，則程式的執行流程會回到函數調用的位置。

a) 如果函數執行的任務需要有傳回值，則必須使用return語句將該值返回。此時函數也自然結束了。

b) 如果一個函數不需要傳回值，也是可以使用return語句的，則此時只是表明函數立即在此結束（可能並沒有完全執行完所有語句）

函數的傳回值2種情況：

有傳回值：表示函數經過一定的“計算”（執行），會得出一個資料，並且會將該資料返回到調用位置（調用者）。此時就必須使用“return 某值；”來實現。——比如：老闆拿一定的錢吩咐某員工買火車票，則該員工需要將該購得的火車票交回給老闆。

特別注意：有傳回值的時候，要把函數的調用當作一個值來看待。

一個函數有沒有傳回值並不是文法所決定的，而是實際需求所決定——文法只是據實際需求而變。

無傳回值：表示一個函數只是單純地去執行裡面的代碼，執行完就算結束，並不需要返回一個資料給“調用者”。

函數的參數：完全沒有文法上的規定，而是要根據應用的需求本身來決定有沒有參數或有幾個參數——即完成該函數的功能，應該提供哪些必要的資料，此資料也就反應為函數的形式參數，每個形式參數各代表一定的含義（資料）。

變數的範圍

所謂範圍就是指“有效可用的範圍”

範圍分兩種：

全域範圍：在所有程式範圍內都可以使用（有效）的範圍。

局部範圍：只在特定範圍內（通常是函數內部）可以使用（有效）的範圍。

變數從範圍角度分兩種：

全域變數：指一個變數可以在全域範圍內使用（有效）。在函數外部定義的變數就是全域變數。全域變數可以在函數外部和函數內部都能使用。

局部變數：指一個變數只能在特定範圍（通常就是函數）內部有效——通常就是定義該變數的函數內部

系統內建函式

parseInt(xxx): 將參數xxx轉換為一個整數——取整操作。

parseInt( 3 ); è 3

parseInt( 3.8 ); è 3

parseInt( 3.1 ); è 3

parseInt( “3” ); è 3

parseInt( “3.8” ); è 3

parseInt( “3.1” ); è 3

parseInt( “3abc” ); è 3

parseInt( “3.8abc” );è 3

parseInt( “3.1abc” );è 3

parseInt( “abc3” ); è NaN

parseInt( “abc 3.8” );è NaN

parseInt( “abc3.1” );è NaN

parseInt( “abc” ); è NaN

NaN——它是一個特殊的數字（類型為number），其含義是：Not a Number（即非數字）——此情形其實通常是指需要一個數字但提供的資料不是一個數字或不能轉成一個數位時候。——NaN這個數字跟任何數都不相等，包括它本身。

parseFloat(xxx): 將參數xxx轉換為一個小數。

parseFloat ( 3 ); è 3

parseFloat ( 3.8 ); è 3.8

parseFloat ( 3.1 ); è 3.1

parseFloat ( “3” ); è 3

parseFloat ( “3.8” ); è 3.8

parseFloat ( “3.1” ); è 3.1

parseFloat ( “3abc” ); è 3

parseFloat ( “3.8abc” ); è 3.8

parseFloat ( “3.1abc” ); è 3.1

parseFloat ( “abc3” ); è NaN

parseFloat ( “abc 3.8” ); è NaN

parseFloat ( “abc3.1” ); è NaN

parseFloat ( “abc” ); è NaN

Number( xxx ): 將參數xxx轉換為一個“數字”——注意跟parseFloat對比。

Number ( 3 ); è 3

Number ( 3.8 ); è 3.8

Number ( 3.1 ); è 3.1

Number ( “3” ); è 3

Number ( “3.8” ); è 3.8

Number ( “3.1” ); è 3.1

Number ( “3abc” ); è NaN

Number ( “3.8abc” ); è NaN

Number ( “3.1abc” ); è NaN

Number ( “abc3” ); è NaN

Number ( “abc 3.8” ); è NaN

Number ( “abc3.1” ); è NaN

Number ( “abc” ); è NaN

isNaN（xxx）： 判斷參數xxx是否是一個“非數字”——如果是一個非數字，結果是true，否則如果是數字，結果是false

isNaN ( 3 ); è false

isNaN ( 3.8 ); è false

isNaN ( 3.1 ); è false

isNaN ( “3” ); è false

isNaN ( “3.8” ); è false

isNaN ( “3.1” ); è false

isNaN ( “3abc” ); è true

isNaN ( “3.8abc” ); è true

isNaN ( “3.1abc” ); è true

isNaN ( “abc3” ); è true

isNaN ( “abc 3.8” ); è true

isNaN ( “abc3.1” ); è true

isNaN ( “abc” ); è true

