JavaScript高程学习笔记（三）

三
ECMAScript中的一切都区分大小写
标识符：指变量，函数，属性的名字或函数的参数。第一个字符必须是一个字母，下划线（-）或一个美元符号
注释：//
     /*
      *
      */
严格模式
  ”use strict“//整个脚本中启用严格模式，在顶部添加
   指定函数在严格模式下运行。
function doSomething(){
 "use strict"
//函数体
}
语句：
代码块
以{开头以}结尾；
例 if（）{}
变量
松散类型：即可以用来保存任何类型的数据，需用var操作符定义变量
var message;

数据类型
6种数据类型：5种简单数据类型（Undefined,NUll,Boolean,number,string)
                     1种复杂数据类型（object）;
typeof操作符检测给定变量的数据类型
例
  var message="some";
alert(typeof(message));//string;
alert(typeof message);//string;
alert(typeof 95);        //"number";

Underfined类型只有一个值即特殊的underfind.在使用var声明变量但未对其加以
加以初始化时，这个变量就是underfined;
var  message;
alert(message==underfined);//true

null
null值表示一个空对象指针。
并且有alert(typeof car)//"object"
undefined的值是派生自null值的，故
alert(null==undefined);//true;

boolean
boolean类型有两个字面值 true和false;
boolean true  false
String    非空字符串  空字符串
Number 非零数字值（包括无穷大）0和NaN
Object    任何对象                         null
Underfined    n/a                        underfined

Null
var intNum=55;//整数
var octalNum1=070//八进制的56；
var octalNum2=079//无效的八进制 解析为79；
var hexNum1=0xA//十六进制的10；
var floatNum1=1.//小数点后没有字--解析为1；
var floatNum2=10.0//整数，解析为10；

数值的范围
5e-324~1.797693134e+308;
超出用Infinty和-Infinty表示(无穷)
使用isFinite()函数确定一个数值是不是有穷的。

NaN
任何数值除以0会返回NaN;
NaN与NaN不相等。与任何值都不相等。
isNAN（）函数确定一个参数是否“不是数值”；

数值转换
var num1=Number("Hello world");//NaN
var num2=Number("")//0
var num3=Number("000011")//11
var num4=Number(true);//1
var num5=Number("0xA");//10

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
var  num6=parseInt("70");//70
更加严谨的表达式
var num=parseInt("0xAF",16);//175
基于16进制的AF的值。

var num1=parseInt("1234blue");//1234
var num2=parseInt("22.5");//22.5
var num3=parseInt("22.34.5")//22.34
var num4=parseInt("0908.5")//908.5
var num5=parseInt("3.125e7")//31250000
parseFloat()只解析十进制；
var  num6=parseInt("0xA")//0

String类型；
var firstName="Nicholas";
var secendName='ZAK';//单双引号都可以
访问其length属性获得其字符串的长度。
alert（text.length）;

toString()方法//把值转换为字符串；
var age=11;
var ageAs=age.toString()//字符串“11”；
var found=true;
var foundAs=found.toString();//字符串“true"；
null与undefined无toString()方法；
var value=null;
var value1;
alert(String(value));//"null";
alert(String(value1))//"undefined";
//无toSting方法将其转换为这两个值的字面量。
object类；

操作符：
var num3=--num1+num2//等于21；
var num4=num1+num2//等于21；
自减
var num3=num1--+num2//等于22；
var num4=num1+num2//等于21；
一元加减操作符
var s1="01";
var s2="1.1";
var s3="z";
var f=1.1
var 0={
valueOf: function(){
 return -1;
}
}
s1=+s1;//值变为数值1；
s2=+s2//值变为数值1.1；
s3=+s3;//值变为NaN
b=+b;//值变为数值0；
f=+f；//值未变，仍是1.1；
o=+c；//值变成数值-1；

位操作符
在以二进制字符串形式输出一个负数时；我们看到的只是这个负数绝对值的二进制码前面加上一个负号。
例：
var num=-18;
alert(num.toString(2))//"-10010";
按位非(NOT）；
其本质操作时，操作数的负值减一
var num1=25;
var num2=~num1;
alert(num2);//-26;
按位与(AND)
即：只有在两个数值的对应位都是1时才返回1；
任何一位是0，结果都是0；
var result=25&3;
alert((result));//1
按位或（or）
即：只有在两个数值的对应位都是0时才返回0；
任何一位是1，结果都是1；
var result=25|3;
alert(result);//27
按位异或(xor);
两数相同返回0；两数不同返回1；
例
var result=25^3;
alert(result);//26;

左移（<<）
例如
var oldValue=2;//等于二进制的10
var newValue=oldValue<<5;//等于二进制的1000000，十进制的64；
右移(>>)（保留符号位）
var oldValue=64; //等于二进制的100000；
var newValue=oldValue>>5;//等于二进制的10；即十进制的2；
无符号右移（>>>）
负数以0来填充空位；
正数无符号与有符号右移的结果相同；
例如
var oldValue=64; //等于二进制的1000000
var newValue=oldValue>>>5;//等于二进制的10，即十进制的2；
//负数时
var oldValue=-64;//等于二进制的111111111111111111111000000
var newValue=oldValue>>>5;//等于十进制的1342177726

布尔操作符
逻辑非（ ！）
alert(!false)//true;
alert(!"blue");//false;
alert(!0);//true;
alert(!NaN);//true
alert(!"");'//true;
alert(!12345);//false;
同时使用两个逻辑非操作符会模拟Boolean()转型函数的行为。
alert(!!"blue");//true;
逻辑与（&&）
var found=true;
var result={found&&someUnderfinedVariable);//发生错误，因为someUndefinedVariable没有初始化；
alert(result);//不会执行
 var found=false；
var result={found&&some)//不会发生错误，因为found 为false则result注定为false;
alert(result);//会执行("false")

逻辑或（||）
var found=true;
var result={found||someUnderfinedVariable);//不会发生错误，因为found 为true则result注定为true;
alert(result);//会显示("true")
 var found=false；
var result={found&&some)//发生错误，因为some没有初始化；
alert(result);//不会执行

乘兴操作符
1.乘法
var result=34*56;
1.若一个操作数为NaN则结果为NaN;
2.若一个操作数不是数值，则在后台调用Number将其转换为数值；
2.除法
var result=66/11;
1.若一个操作数为NaN则结果为NaN;
2.若0被0除结果是NaN;
3若非零被零除，则结果是Infinity或-Infinity;
4.若一个操作数不是数值，则在后台调用Number将其转换为数值；
3.求模（余数）
var result=26%5;//等于1；
1.若一个操作数不是数值，则在后台调用Number将其转换为数值；

加性操作符
1.加法；
var result=1+2;
若两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来；
若只有一个操作数是字符串，则将另一个操作数转换为字符串，然后两个字符串拼接起来。
例子
var result=5+5；//相加
alert(result);//10

var num1=5;
var num2=10;
var message=“The sum of 5 and 10 is”+num1+num2;
alert(message)// "The sum of 5 and 10 is 510"

例2
var num1=5;
var num2=10;
var message=“The sum of 5 and 10 +（num1+num2);
alert(message)// "The sum of 5 and 10 is 15"

减法
var result=2-1;
var result1=5-true;//4,true被转换为1；
var result2=NaN-1;//NaN
var result3=5-"";//5,"'被转换为0；
var result4=5-"2";//3.因为“2”“2”被转换为2
var result5=5-null;//5,null被转换为0；

关系操作符
< > <= >=
var result="Brick"<"alphabet";//true,B的字符编码为66；a为97；
var result="23"<="3"//true 2字符编码为50，3的字符编码为51；
var result="23"<3//false   " 23"被转换为23；
注
var result=NaN<3//false;
var result=NaN>=3//false;

相等操作符；
相等和不相等
==      ！=
注NaN不等于NaN;
全等与不全等
var result1=("55"==55)//ture,因为转换后相等；
var result2=("5500"===55)//false 数据类型不等
null==undefined//true 类似
null===undefined//false 数据类型不同
条件操作符：
var max=(num1>num2)?num1:num2;
赋值操作符：
var num=10;
num+=10;
逗号操作符
var num=(5,1,4,8,0);//num的值为0；

语句
if
if()
{
//语句
}else{//语句
}

do-while
do{
//语句
}while()
//语句

while 语句
while(){}

for语句
for(;;){}

for-in
例
for(var propName in window){
 document.write(propName);
}
label语句
可在代码中添加标签；
/*
*暂不理解
*
*/

break与continue
break立即退出循环，执行循环后面的语句
例
var num=0;
outermoset:
for(var i=0;i<10;i++){
 for(var j=0;j<10;j++){
    if(i==5&&j==5){
break outermost;
}
num++
}
}
alert(num);//55

continue 也会退出循环但退出循环后会从循环的顶部继续执行
var num=0;
outermoset:
for(var i=0;i<10;i++){
 for(var j=0;j<10;j++){
    if(i==5&&j==5){
continue outermost;
}
num++
}
}
alert(num);//55

with 语句作用是将代码的作用域设置在一个特定的对象中
var qs=location.search.substring(1);
var hon=location.hostname;
可改写为
with(location){
var qs=search.substring(1);
var hon=hostname;
}
switch语句
例
switch(i){
    case 25;
         alert("25");
        break;
     case 35;
         alert("35");
        break;
   default:
      alert("Other");
}

函数
function functionName(arg0,arg1,arg2......argN){
   statments;
}
例 function sum(num1,num2){
return num1+num2;
alert("Hello world");//永远不会执行；
}
即在同一个函数中，return之后的代码永远不会执行
函数名，参数名都不能命名为eval或arguments;
不能出现两个命名参数同名的情况；

1.函数doAdd()会在只有一个参数的情况下给该参数加10；
如果只有两个参数，则将那个参数相加并返回结果。
function doAdd(num1,num2){
   if(arguments.length==1){
alert(argument[0]+10);
}else if(argument[0]+argument[1]);
}
}
doAdd(10);//20
doAdd(30,20);//50
2.argument对象可以与命名参数一起使用
function doAdd(num1,num2){
if(arguments.length==1){
 alert(num1+10);
}else if(arguments.length==2){
   alert(arguments[0])+num2);
}
}

注 function daAdd(num1,num2){
argument[1]=10;
alert(aeguments[0]+num2);
}
//在执行时，这个doAdd()函数都会重写第二个参数；
将第二个参数的值修改为10；即；修改num2;
在没有传递值的命名将被自动赋予underfined值。
例如，如果只给doAdd（）函数传递一个参数，则
num2中会保存underfined值；
没有重载
例如function addsomeNumber(num){
  return num+100;
}
function addSomeNumber)(num){
 return num+200;
}
var result=addSomeNumber(100);//300
//在此函数中addSomeNumber()被定义了两次；第一个版本给参数
加100，第二个版本给参数加200.由于后定义的函数覆盖了先定义的函数。
故 返回的结果是300；