Javascript----第三章（JS基本概念）

笔记：

一，JS语法：

1. 区分大小写（变量名test与Test表示完全不同的两个变量）。

2. 标识符（变量，函数，属性的名字）：

要求：1）第一个字符必须是一个字母，下划线（_）或一个美元符号（$);

           2）其他字符可以是字母，下划线，美元符号和数字。

不能把关键字，保留字，ture，false和null用作标识符。

3. 注释：

1）单行注释：//

2）块级注释：/*。。。。。。*/

4. 严格模式：（代码：“use strict”）

加入不同的位置可以使脚本或者函数在严格模式下进行。

5. 语句：

必须以一个分号（；）结束语句；也可以采用c语言风格把多条语句组合到一个代码块中（{......}）

二.变量：

1.ECMAScript的变量是松散类型的，可以用来保存任何类型的数据。即每个变量仅仅是一个用于保存值的占位符而已。定义变量时要使用var操作符。

如： var  message；

这行代码定义了名为message的变量，该变量可以用来保存任何值。

注：用var操作符定义的变量将成为定义该变量的作用域中的局部变量。而省略var操作符后message就成了全局变量（但不推荐，因为很难维护）

三.数据类型：

1.其有五种简单数据类型（Undefined，Null，Boolean，Number，String）和一种复杂数据类型（Object）。

2.typeof操作符（检测给定变量的数据类型）：

“undefined”——如果这个值未定义；

“boolean”——如果这个值是布尔值；

“string”——如果这个值是字符串；

“number”——如果这个值是数值；

“object”——如果这个值是对象或null；

“function”——如果这个值是函数。

var message="some string";
alert(typeof message);    //"string"
alert(typeof (message));   //"string"
alert(typeof 95);     //"number"

3.Undefined类型：

Undefined类型只有一个值，即特殊的undefined。在使用var声明变量但未对其加以初始化时，这个变量的值就是undefined，

var message；
alert （messagae ==undefined);    //ture 
var age    //这个变量没有声明
alert(age);     //产生错误
alert（message）；  //“undefined”

4.Null类型：

其也只有一个值（null）。null值从逻辑角度讲表示一个空对象指针，这也正是使用typeof操作符检测null值时会返回“object”的原因。

var car=null;
alert(typeof car);   //"object"
alert(null==undefined)   //ture   尽管null和undefined有这样的关系，但用途完全不同。

意在保存对象的变量还没有真正，就应该明确地让该变量保存null值。

5.boolean类型：

该类型只有两个字面值（ture和false），但这两个值与数字值不是一回事，因此ture不一定等于1，而false也不一定等于0。而将一个值转换成为其对应的boolean值，可以调用转型函数Boolean（）。

var found=ture;
var lost=false;
var message="hello world!";
var messageAsBoolean=Boolean(message); //字符串message被转换成对应的Boolean值，

数据类型	转换为ture的值	转换成false的值
Boolean	ture	false
String	任何非空字符串	空字符串
Number	任何非0数字值	0和NaN
Object	任何对象	null
Undefined		undefined

6.Number类型:

1）整数：十进制（直接输入）

                八进制（第一位为0，后面数字不能超过7）

               十六进制（前两位为0x，后跟0~9及A~F,A~F可以大写和小写）

在进行算术运算时，八进制和十六进制最终被转换成十进制数值。

2）浮点数：该数值必须包含一个小数点，且小数点后面至少有一位数字。

科学计数法：3.15e7（即为3.15*10的7次方）。

3）NaN（即非数值），用于表示一个本来要返回数值的操作数未返回数值的情况。

在ECMAScript中，任何数值除以非数值会返回NaN，因此不会影响其他代码的执行。

NaN的两个特点：

1）任何涉及NaN的操作都会返回NaN；

2）NaN与任何值都不相等，包括NaN本身。

确定一个参数是否“不是数值”可用isNaN（）函数，其任何不能被转换为数值的值都会导致这个函数返回true。

alert(isNaN(NaN));    //ture
alert(isNaN(10));    //false(10是一个数值）
alert(isNaN("10"));    //false（可以被转换成数值10）
alert(isNaN("blue"));    //ture(不能转换成数值）
alert(isNaN(ture));    //false（可以转换成数值1）

4）数值转换：

将非数值转换成数值的三个函数：Number（），parseInt（）和parseFloat（）。

第一个可以用于任何数据类型，另两个专门用于把字符串转换成数值。

Number（）函数的转换规则：

1）Boolean值——ture转换成1，false转换成0；

2）数字值——简单的传入和返回；

3）null值——返回0；

4）undefined值——返回NaN；

5）字符串规则：

    1〉只包含数字转换成十进制数值，八进制和十六进制转换成对应大小的十进制数值

     2〉包含浮点的转换成浮点数值。

    3〉空字符串转换成0；

    4〉包含除上述格式之外字符的转换为NaN。

var num1=Number("Hello world!");    //NaN
var num2=Number("");                //0
var num3=Number("000011");          //11
var num4=Number(ture);             //1

因为Number（）函数在转换字符串时比较复杂而且不够合理，因此处理整数时更常用的是parseInt（）函数。

parseInt()函数的转换规则：

1）如果第一个非空格字符不是数字字符或者负号，parseInt（）就会返回NaN；

2）也会识别整数格式来转换成十进制输出。

var num1=parseInt("1234blue");      //1234
var num2=parseInt("");              //NaN
var num3=parseInt("0xA");           //10
var num4=parseInt("22.5");          //22
var num5=parseInt("070")；         //56   其在ECMAScript3和5中结果不同
var num6=parseInt("70")；         //70
var num7=parseInt("0xf")；         //15
//为了消除5中的困惑，可以为这个函数提供第二个参数，如下：
var num5=parseInt("70",8)     //56

parseFloat()也是从第一个字符开始解析到字符串末尾或者遇到一个无效的浮点数字字符为止。

var num1=parseFloat("1234blue");  //1234  如果字符串包含一个可解析为整数的数，则返回整数。
var num2=parseFloat("0xA")；     //0   只能解析十进制值，其他进制数返回值为0。
var num3=parseFloat("22.5")；    //22.5
var num4=parseFloat("22.34.5")；  //22.34  只有第一个小数点有效，后面的小数点则无效
var num5=parseFloat("0908.5")；   //908.5
var num6=parseFloat("3.125e7")；  //31250000

7.String类型：

1）String类型用于表示由0或多个16位Unicode字符组成的字符序列，即字符串。字符串可以由双引号（“）和单引号（‘）表示，完全相同，但要注意左右引号匹配。

var firstName="Nicholas";
var lastName='Zakas'；
var firstName='Nicholas"；  //语法错误（左右引号必须匹配）

2）字符字面量（转义序列）：

可以出现在字符串中的任意位置，而且也将被作为一个字符来解析。

\n    换行

\t    制表

\b    退格

\r    回车

\f    进纸

\\    斜杠

\'    单引号

\"    双引号

\xnn     十六进制代码nn表示一个字符（其中n为0~F）例如：\x41表示“A”

\unnnn    十六进制代码nnnn表示一个Unicode字符（其中n为（0~F）），例如：\u03a3表示希腊字母。

var text="This is the letter sigma: \u03a3.";
alert(text.length);    //输出28

3）字符串的特点：字符串一旦创建，它们的值就不能改变。要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量。

var lang="Java";
lang=lang+"Script";

4）转换为字符串：

第一种方法：toString（）函数；例子：

var found=ture;
var foundAsString=found.toString();    //字符串“ture”
var num=10;
alert(num.toString());  //"10"
alert(num.toString(2));  //"1010"
alert(num.toString(8));  //"12"
alert(num.toString(10));  //"10"
alert(num.toString(16));  //"a"

第二种方法：String（）函数；

在不知道要转换的值是不是null或undefined的情况下使用。

转换规则：

如果值有toString（）方法，则调用该方法并返回相应的结果；

如果值是null，则返回“null“；

如果值是undefined，则返回”undefined“。

var v1=10;
var v2=true;
var v3=null;
var v4;
alert(String(v1));  //"10"
alert(String(v2));  //"true"
alert(String(v3));  //"null"
alert(String(v4));  //"undefined"

8.Object类型：

1）对象可以通过执行new操作符后跟要创建的对象类型的名称来创建。而创建Object类型的实例并为其添加属性和方法，就可以创建自定义对象，如下：

var o =new Object()；

2）Object类型所具有的任何属性和方法也同样存在于更具体的对象中。

Object类型的每个实例都具有下列属性和方法：

constructor:保存着用于创建当前对象的函数。前面例子而言，构造函数（constructor）就是Object（）。

hasOwnProperty(propertyName):用于检查给定的属性在当前对象实例中是否存在。作为参数的属性名必须以字符串的形式指定。

isPrototypeof（object）：用于检查传入的对象是否是当前对象的原型。

propertyIsEnumerable（propertyName）：用于检查给定的属性是否能够使用for-in语句

toLocaleString（）：返回对象的字符串表示，该字符串与执行环境的地区对应。

toString（）：返回对象的字符串表示。

valueOf（）：返回对象的字符串、数值或布尔值表示。通常与toString（）方法的返回值相同。

四、操作符：

1.一元操作符：（只能操作一个值的操作符）

1）递增递减操作符：（直接借鉴于c语言）分前置型和后置型，具体在例子中进行说明。

var age=29;
++age;  //值就变成了30，相当于age=age+1；

var age=29;
var anotherAge=--age+2;   //因为自减号在变量前，所以先减再进行下一步操作。
                          //所以age=28,anotherAge=30而不是31.

var age=29;               
var anotherAge=age--+2;   //自减号在后面所以先进行下一步操作，变量再减1
                          //所以age=28，anotherAge=31.

用于不是整数的值时，递增递减操作符遵循的规则：

1.在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量。

2.在应用于一个不包含有效数字字符的字符串时，将变量的值设置为NaN。字符串变量变为数字变量。

3.在应用于布尔值false（ture）时先将其转换为0（1）再执行加减1的操作。布尔值变量变为数字变量。

4.在应用于浮点数值时执行加减1的操作。

5.在应用于对象时先调用对象的valueOf（）方法以取得一个可供操作的值然后对该值应用前述规则。如果结果是NaN，则在调用toString（）方法后再应用前述规则。对象变量变成数值变量

var s1="2";
var s2="z";
var b=false;
var f=1.1;
var o={
   valueOf: function(){return -1;}
};
s1++;  //s1=3
s2++;  //s2=NaN
b++;   //b=1
f--;   //f=0.100000000
o--;    //值为-2

2）一元加减操作符：其主要用于基本的算术运算，也可以用于转换数据类型。具体看例子。

 

var s1="01";
var s2="1.1";
var s3="z";
var b=false;
var f=1.1;
var o={
   valueOf: function(){return -1;}
};

//类似Number（）转型函数一样进行转换；
s1=+s1;  //1
s2=+s2;  //1.1
s3=+s3;  //NaN
b=+b;  //0
f=+f;  //1.1
o=+o;  //-1

//一元减操作符在此基础上再转换成负数；
s1=-s1;  //-1
s2=-s2;  //-1.1
s3=-s3;  //NaN
b=-b;  //0
f=-f;  //-1.1
o=-o;  //1

2.位操作符：

1）按位非（~）——返回数值的反码，本质：操作数的负值减1；

var num1=25;
var num2=~num1;   //值为-26
var num3=-num1-1;  //值为-26

2）按位与（&）——二进制码对应位都是1时才返回1.

var r=25 & 3;
alert(r);  //r=1
/*25=11001;
   3=00011;
   r=00001;  竖着看来计算结果，最后结果为1.*/

3）按位或（|）——二进制码有一位是1就返回1.

var r=25|3;
alert(r);  //r=27
/*25=11001;
   3=00011;
   r=11011;  所以r=27*/

4)按位异或（^）——二进制码对应位不同返回1，相同返回0.

var r=25^3;
alert(r);
/*25=11001;
   3=00011;
   r=11010;  所以r=26；*/

5)左移（<<）——二进制码向左移指定位数，用0填充，不影响符号位。

var r=2;
var newr=r<<5;
/*r=...010;
newr=...010 00000;
所以newr=64；若r=-2，newr=-64；*/

6)有符号右移（>>）——二进制码向右移指定位数，但保留符号位。

var r=64;
var newr=r>>5;  //newr=2

7）无符号右移(>>>)——数值的所有32位都要向右移动，包括符号位。

var r=64;
var newr=r>>>5;
//r=00...001000000;newr=2;

var r=-64;
var newr=r>>>5;  //newr=134217726;值非常大是因为会把负数的二进制码当做正数的二进制码处理。

3.布尔操作符;

1)逻辑非（!）——先将其转换为布尔值，再求反即可。

alert(!false);  //ture
alert(!"blue");  //false
alert(!0);  //ture
alert(!NaN);  //ture
alert(!"");  //ture
alert(!12345)  //false

2)逻辑与（&&）——其判断与c语言相同。

补充：在有一个操作数不是布尔值时，逻辑操作不一定返回布尔值，遵循以下规则：

1.如果第一个操作数是对象，则返回第二个操作数；

2如果第二个操作数是对象，则只有第一个操作数求值结果为ture才返回该对象。

3.如果两个操作数都是对象，则返回第二个操作数。

4.如果第一个操作数是null，则返回null；

5.如果第一个操作数是NaN，则返回NaN；

6.如果第一个操作数是undefined，则返回undefined。

逻辑或（||）——其判断与c语言相同

补充：在有一个操作数不是布尔值时，逻辑操作不一定返回布尔值，遵循以下规则：

1.如果第一个操作数是对象，则返回第一个操作数；

2如果第一个操作数的求值结果为false，则返回第二个操作数。

3.如果两个操作数都是对象，则返回第一个操作数。

4.如果两个操作数都是null，则返回null；

5.如果两个操作数都是NaN，则返回NaN；

6.如果两个操作数都是undefined，则返回undefined。

4.乘性操作符：（乘法，除法和求模），用途与c相似，只不过在操作数为非数值的情况下会执行自动的类型转换（Number（）函数）

1）乘法（*）——用于计算两数值的乘积（var result=34*56；）

处理特殊值时遵循的规则：

1.都是数值按常规计算，超过数值表示范围则返回Infinity或-Infinity；

2.如果有一个操作数是NaN，则结果是NaN；

3.如果是Infinity与0相乘，则为NaN，与非0数值相乘则为Infinity或-Infinity；

4.如果是Infinity与Infinity相乘，则结果是Infinity；

2）除法（/）——var result=66/11；

处理特殊值时遵循的规则：

1.都是数值按常规计算，超过数值表示范围则返回Infinity或-Infinity；

2.如果有一个操作数是NaN，则结果是NaN；

3.如果是0 / 0则为NaN，Infinity / 任何非0数则为Infinity或-Infinity，非0有限数 / 0,则结果是Infinity或-Infinity；

4.如果是Infinity / Infinity，则结果是Infinity；

3）求模（%）——var result=26%5  //即求余，结果为1

特殊值的处理方法大致相同。

5.加性操作符：

1）加法（+）——下举几个特殊的，其余处理方法都大致相同。

1.+0++0=+0；-0=-0=-0;+0+-0=+0；

2.如果两个操作数都是字符串，则将两个拼接起来；如果只有一个是字符串，则将另一个转换成字符串再拼接起来。

3.如果有一个操作数是对象，数值，布尔值，undefined或null，则用toString()和String（）方法取得相应的字符串值后再用字符串规则。

var result1=5+5;
alert(result1);  //10
var result2=5+"5";
alert(result2);  //"55"

2）减法（-）——var result=2-1；

1.+0 - +0 =+0， -0 - +0 =-0, -0 - -0=+0;

2.如果有一个操作数是对象，数值，布尔值，undefined或null,则用Number（）函数转换为数值再进行计算

var result1=5-ture;  //4
var result2=NaN-1;  //NaN
var result3=5-3;  //2
var result4=5-"";  //5
var result5=5-"2";  //3
var result6=5-null;  //5

6.关系操作符：（大于（>）,小于（<），小于等于（<=）,大于等于（>=）)这几个操作符通过比较都会返回一个布尔值。

比较的规则：

1.数值比较大小；

2.字符串比较其对应的ASCII码值，

3.如果有一个是数值，则将另一个转换为数值，再进行数值比较；

var result="Brick"<"alphabet";  //因为B<a,所以为ture
var result="23"<"3";  //2<3,所以为ture
var result="a"<3;   //因为"a"转换成NaN，所以为false；
var result=NaN>=3;   //只要有NaN，则结果返回为false
var result=NaN<3;

7.相等操作符：

1)相等（==）和不相等（!=）——其前者在相等时返回ture，后者在不相等时返回ture。

两个操作数若不同类型，会先强制转型后再比较相等性。转换规则如下;

1)如果一个操作数是布尔值，则其转换为数值，ture为1，false为0；

2）如果一个操作数是字符串，另一个是数值，则字符串变为数值后再比较；

3）null与undefined是相等的；

4）比较前，null和undefined不能转换为其他值；

5)NaN不等于任何一个数，包括它本身。

例：
null==undefined;  //ture;
"NaN"==NaN;       //false;
5==NaN;           //false;
NaN==NaN;        //false;
NaN!=NaN;       //ture;
false==0;       //ture;
ture==1;       //ture;
ture==2;       //false;
undefined==0;  //false;
null==0;       //false;
"5"==5;        //ture.

2).全等（===）和不全等（！==）——前者在不转换的情况下就相等则返回ture，后者在不转换的情况下不相等则返回ture。

var  result=（“55”==55）；  //ture;

var  result=("55"===55) ;   //false;,这就是区别。

8.条件操作符：

var  a=A？B：C；  （即判断A的真假，若A为真，a=B，若A为假则a=C）；

9.赋值操作符（=）——就是把右侧的值赋给左边的变量。还有一些复合赋值操作（+=，-=，*=）这些的处理方法与c大致相同。

10.逗号操作符：——即可以在一条语句中执行多个操作。

var num1=1,num2=2,num3=3;  //其用于声明多个变量；

var num=(5,1,4,8,0)        //多次赋值，返回表达式最后一项。所以num=0；

五、语句：

1、if语句：

语法：if (condition) statement1   

          else  statement2
其中condition为任意表达式，若不是布尔值则用Boolean（）函数，ture执行1，false执行2。
 
例：
if(i>25)
   alert("Greater than 25.");
else
{
  alert("Less than or equal to 25.");
}

2、do——while语句：

语法：do{
    statement}
while（expression）；先执行再判断。

例：
var i=0;
do{
i+=2;
}while(i<10);
alert(i);

3、while语句：

语法：while（expression）  statement  先判断再循环
例：
var i=0;
while (i<10){
i+=2;
}

4、for语句：

语法： for（初始化；expression;post-loop-expression） statement

例：
var count=10;
for (var i=0;i<count;i++)
{ alert(i);}

5、for——in语句：（可以用来枚举对象的属性）

语法：  for（property in expression） statement
例：
for(var propName in window)
{
document.write(propName);
}

解释：其中window为一个对象，propName为变量。每次循环会将window对象存在的一个属性赋值给变量propName。持续到对象的所有属性都被枚举一遍为止。

6、label语句：（可以在代码中添加标签）

语法：
label :statement
例：
start：for （var i=0;i<count;i++）
{alert(i);}

这个定义的start标签可以在将来由break和continue语句引用。加标签的语句一般都要与for语句等循环语句配合使用。

7、break和continue语句：（在循环中精确地控制代码的执行，break结束本次循环，continue结束本层循环）

例：
var num=0;

for(var i=1;i<10;i++)
{
  if(i%5==0)
  {
    break;(continue;)
  }
   num++;
}
alert(num);   //4,若为括号里的则为8

break和continue可以与label语句联合使用，从而返回代码中特定的位置。多发生在循环嵌套的情况下

var num=0;
outermost:
for(var i=1;i<10;i++)
{
  for(var j=0;j<10;j++)
  {
  if(i==5&&j==5)
  {
    break(continue) outermost;
  }
   num++;
  }
}
alert(num);   //55(95)

解释：添加这个标签后将导致break语句不仅会退出内部循环，也会退出外部循环，continue语句会退出本层内部循环，执行外部循环。

8、with语句：（将代码的作用域设置到一个特定的对象中）

语法：
with （expression） statement；
目的主要是为了简化多次编写同一个对象的工作。
例：
var qs=location.search.substring(1);
var hostName=location.hostname;
var url=location.href;

上面几行代码都包含location对象，可用with改写：

with(location)
{
    var qs=search.substring(1);
    var hostName=hostname;
    var url=href;
}

严格模式下不允许使用with语句，否则视为语法错误。

9、switch语句：（与c语言的使用方法类似），额外特色：switch语句中可使用任何数据类型，其次，每个case值不一定是常量，也可以是变量和表达式。

例：
switch（i）
{
 case 25:
 alert("25");
 break;
 case 35；
 alert("35");
 break;
 case 45:
 alert("45");
 break;
 default:
 alert("other");
}
每个case后都加一个break语句，是为了避免同时执行多个case代码的情况，若需要混合几种情形，也可有意省略break。

六、函数：

1、ECMAScript中的函数使用function关键字声明，后跟一组参数以及函数体。

语法：
function functionName（arg0，arg1，……argN）
{
    statements
}
例1：
function sayHi(name,message)
{
alert("Hello"+name+","+message);
}
例2：
function sum(num1,num2)
{
return num1+num2;    //返回两数之和；
alert("Hello!");     //位于return语句之后的任何代码都永远不会执行。
}

另外严格模式对函数有一些限制：

1）不能把函数命名为eval或arguments；

2）不能把参数命名为eval或arguments；

3）不能出现两个参数同名的情况。

2、理解参数：

ECMAScript函数的参数在内部是用一个数组来表示的，所以不在乎传递参数的个数与数据类型。，其可以通过arguments对象来访问这个参数数组。具体内容从例子中看出：

function sayHi()
{
alert("Hello"+arguments[0]+","+arguments[1]);
}     // 其和上一个代码块的例1功能相同.

//通过访问arguments对象的length属性可以获知有多少个参数传递给了函数。如下：
function howManyArgs()
{ alert(arguments.length); }
howManyArgs("string",45);  //2
howManyArgs();  //0
howManyArgs(12);  //1

//由上，开发人员可以利用这一点让函数能够接收任意个参数并分别实现适当的功能。
function doadd()
{
 if(arguments.length==1)
 {
   alert(arguments[0]+10);
 }
 else if(arguments.length==2)
 {
 alert(arguments[0]+arguments[1]);
 }
}
doadd(10);  //20
doadd(30,20);  //50

//另一个与参数相关的重要方面就是arguments对象可以与命名参数一起使用
function doadd(num1,num2)
{
 if(arguments.length==1)
 {
   alert(num1+10);
 }
 else if(arguments.length==2)
 {
 alert(arguments[0]+num2);
 }
}

//关于arguments的行为，还有一点就是它的值永远与对应命名参数的值保持同步。

最后还有一点：没有传递值的命名参数将自动赋予undefined值，就跟定义了变量但又没初始化一样。例如只给doadd（）函数传递了一个参数，则num2中就会保存undefined值。

3、没有重载：

ECMAScript函数不能像传统意义上那样实现重载，如果在ECMAScript中定义了两个名字相同的·函数，则该名字只属于后定义的函数，如下例：

function addSomeNumber(num)
{return num+100;}
function addSomeNumber(num)
{return num+200;}
var result=addSomeNumber(100);  //300