系统内部函数

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

v1=5	0	0	0	0	0	1	0	1
v2= 5	0	0	0	1	0	1	0	0

var v2 = 5

 

按位左移运算：

符号： >>

         含义： 将一个二进制数的每一个位上的数字往右边移动指定的位数，并且右边“冒”出去的就不管了（不算了），左边空出来的位上填入原来的左边的数字，得到的结果就是该二进制数字所代表的值。

举例：

         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中，基本数据类型使用 “拷贝传值”——传值的时候直接就出现了一份新的数据（当然同时也是另一个变量所代表）

         复合数据类型（数组和对象）使用“引用传值”——传值的时候只是做了一个地址指向，数据仍然只有一份，两个变量就指向这同一份数据。

 

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语句其实是可以使用非常灵活的条件判断，比如  >  >= 

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