javascript 学习笔记一(2009-09-18) ECMAScript 基础

javascript学习笔记:
2009-09-18:
--------------------
第二章 ECMAScript 基础
原始类型
ECMAScript有5种原始类型：
Undefined,Null,Boolean,Number,String
typeof运算符
typeof运算符有一个参数，即要检查的变量或值。
var sTemp="test string";
alert(typeof sTemp); //output "string"
类型有: undefined,boolean,number,string,object
var oTemp;
alert(typeof oTemp); //outputs "undefined"
注意，值undefined并不同于未定义的值.
var oTemp;
alert(typeof oTemp); //outputs "undefined"
alert(typeof oTemp2);//outputs "undefined"

alert(oTemp2==undefined);//causes error
注意，当函数无明确返回值时，返回的也是值undefined,如
function testFunc(){

}

alert(testFunc()==undefined); //outputs "true"
Null 类型
alert(null==undefined);//outputs "true"
尽管这连个值相等，但它们的含义不同。undefined是声名了变量但未对其初始化时赋予该变量的值，null则
用于表示尚未存在的对象.
Number类型
var iNum=55; 十进制
var iNum=070; 把进制
var iNum=0x1f; 十六进制
var fNum=3.125e7; //3.125*10的7次方
var fNum=3.125-e7;//3.125除上10的7次方
特殊值:
Number.MAX_VALUE和Number.MIN_VALUE,定义了Number值集合的外边界.
当计算生成的结果大于Number.MAX_VALUE时,它将被赋予值Number.POSITIVE_INFINITY,意味着不再有数字值.
同样，当生成的数值小于Number.MIN_VALUE的计算也会被赋予值Number.NEGATIVE_INTINITY,意味着不再有数字值。
无穷大:
可以对任何数调用isFinite()方法，以确保该数不是无穷大。
var iResult=iNum*some_really_large_numer;
if(isFinite(iResult)){
alert("Number is finite.");
}else{
alert("Number is infinite");
}
NaN:
NaN,表示非数(Not a NumberS);
alert(isNaN("blue"));//outputs "true"
alert(isNaN("123"));//outputs "false"
String类型:
ECMAScript的字符字面量:
------------------------------------------------
字面量 含义
------------------------------------------------
\n 换行
\t 制表符
\b 空格
\r 回车
\f 换页符
\\ 反斜杠
\' 单引号
\" 双引号
\0nnn 八进制代码nnn(0-7)
\xnn 十六进制代码nn(0-F)表示的字符
\unnnn 十六进制代码nnnn(0-F)表示的Unicode字符
转换
Boolean型的toString()
var bFound=false;
alert(bFound.toString());//outputs "false"
Number类型的toString()方法比较特殊，它有两种模式，即默认模式和基模式。
默认模式:
var iNum1=10;
var fNum2=10.0;
alert(iNum1.toString());
alert(fNum2.toString());
基模式:
var iNum1=10;
alert(iNum1.toString(2));//outputs "1010"
alert(iNum1.toString(8));//outputs "12"
alert(iNum1.toString(16));//outputs "A"
转换成数字:
var iNum1=parseInt("1234blue");//returns 1234
var iNum2=parseInt(0xA);//returns 10
var iNum3=parseInt(22.5);//returns 22
var iNum4=parseInt("blue");//returns NaN

var iNum1=parseInt("010");//returns 8
var iNum1=parseInt("010",8);//returns 8
var iNum1=parseInt("010",10);returns 10
parseFloat(): 字符串必须以十进制形式表示浮点数，而不能用八进制形式或十六进制形式。
var fNum1=parseFloat("1234blue");//returns 1234.0
var fNum2=parseFloat("0xA"); //returns NaN
var fNum3=parseFloat("22.5"); //returns 22.5
var fNum4=parseFloat("22.34.5");//returns 22.34
var fNum5=parseFloat("0908"); //returns 908
var fNum6=parseFloat("blue"); //returns NaN
强制类型转换:
Boolean(value)---把给定的值转换成Boolean型
Number(value)---把给定的值转换成数字(可以是整数或浮点数)
String(value)---把给定的值转换成字符串
------------------------------------------
var b1=Boolean("");//false
var b2=Boolean("hi");//true
var b3=Boolean(100);//true
var b4=Boolean(null);//false
var b5=Boolean(0);//false
var b6=Boolean(new Object());//true
------------------------------------
用法 结果
---------------------------------
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("5.5") 5.5
Number("56") 56
Number("5.6.7") NaN
Number(new Object()) NaN
Number(100) 100
-------------------------------
String():
var s1=String(null);//"null"
var oNull=null;
var s2=oNull.toString();//won't work,causes an error
引用类型：
var o=new Object(); // or var o=new Object;

Object类:
Object类的属性：
Constructor-对创建对像的函数的引用(指针).对于Object类,该指针指向原始的object()函数
Prototype-对该对像的对象原型的引用。
Object类还有几个方法:
HasOwnProperty(property)--判断对象是否有某个特定的属性。必须用字符串指定该属性(例如:o.hasOwnProperty("nmae"))
IsPrototypeOf(object)--判断该对象是否为另一对象的原型。
PropertyIsEnumerable(property)--判断给定的属性是否可以用for..in语句进行枚举。
ToString()--返回对象的原始字符串表示。对于Object类，ECMA-262没有定义这个值，所以不同的ECMAScript实现具有不同的值。
ValueOf()--返回最适合该对象的原始值。对于许多类，该方法返回的值都与toString()的返回值相同。
Boolean类:
var oBooleanObject=new Boolean(true);
Boolean对象将覆盖object类的valueOf()方法,返回原始值,即true或false.
Number类:
var oNumberObject=new Number(55);
方法:
toFixed()方法返回的是具有指定位数小数的数字的字符串表示.
例如:
var oNumberObject=new Number(99);
alert(oNumberObject.toFixed(2));//outputs "99.00"
toExponential()方法返回的是用科学计数法表示的数字的字符串形式。
例如:
var oNumberObject=new Number(99);
alert(oNumberObject.toExponential(1));//outputs "9.9e+1"
toPrecision()方法根据最有意义的形式来返回数字的预定形式或指数形式。它有一个参数，即用于表示数的数字总数(不包括指数)。
例如:
var oNumberObject=new Number(99);
alert(oNumberObject.toPrecision(1));//outputs "1e+2"
alert(oNumberObject.toPrecision(2));//outputs "99"
alert(oNumberObject.toPrecision(3));//outputs "99.0" 等价于toFixed(1)
String类:
var oStringObject=new String("hello world");
alert(oStringObject.length);//outputs "11"
charAt()返回包含指定位置处的字符的字符串.第一个字符位置为0
alert(oStringObject.charAt(1));//outputs "e"
alert(oStringObject.charCodeAt(1));//outputs "101"

concat()方法，用于把一个或多个字符连接到String对象的原始值上.
var oStringObject=new String("hello ");
var sResult=oStringObject.concat("world");
alert(sResult);

indexOf()和lastIndexOf()方法返回的都是指定的字串在另一个字符串的位置,indexOf()方法从字符串的开头开始检索。
lastIndexOf()从字符串的结尾开始检索字串。
var oStringObject=new String("hello world");
alert(oStringObject.indexOf("o"));//outputs "4"
alert(oStringObject.lastIndexOf("o"));//outputs "7"
----------------------------------------------------------------------------
2009-09-21:
localeCompare()对字符串值进行排序。
如果String对象按照字符顺序排在参数中的字符串数之前，返回负数(最常见-1)
如果String对象等于参数中的字符串，返回0.
如果String对象按照字母顺序排在参数中的字符串后，返回正数(最常见1)
例:
var oStringObject=new String("yellow");
alert(oStringObject.localeCompare("brick"));
alert(oStringObject.localeCompare("yellow"));
alert(oStringObject.localeCompare("zoo"));
最好的使用localCompare()的方式:
var oStringObject1=new String("yellow");
var oStringObject2=new String("brike");
var isResult=oStringObject1.localeCompare(oStringObject2);
if(isResult<0){
alert(oStringObject1+"  comes befefore  "+oStringObject2);
}else if(isResult>0){
alert(oStringObject1+"  comes after  "+oStringObject2);
}else{
alert("The two strings are equal");
}
slice()和substring()方法实现从子串创建字符串值.
var oStringObject=new String("hello world");
alert(oStringObject.slice(3));//outputs " lo world"
alert(oStringObject.substring(3));//outputs "lo world"
alert(oStringObject.slice(3,7));//outputs "lo w"
alert(oStringObject.substring(3,7));//outputs "lo w"
slice()和substring()当参数为负数的时候处理方式不同。
对于负数参数,slice()方法会用字符串的长度加上参数，substring()方法则将其作为0处理。
var oStringObject=new String("hello world");
alert(oStringObject.slice(-3));// outputs "rld"
alert(oStringObject.substring(-3));//outputs "hello world"
alert(oStringObject.slice(3,-4));//outputs "lo w"
alert(oStringObject.substring(3,-4));//outputs "hel"
toLowerCase(),toLocaleLowerCase(),toUpperCase(),toLocaleUpperCase()
toLocaleLowerCase()和toLocaseUpperCase()方法是基于特定的区域实现方法为原型的。
toLowerCase()和toUpperCase()方法是原始的，是以java.lang.String中的相同方法为原型实现的。
例子：
var oStringObject=new String("Hello World");
alert(oStringObject.toLocaleUpperCase());//outputs "HELLO WORLD"
alert(oStringObject.toUpperCse()); //outputs "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase()); //outputs "hello world"
alert(oStringObject.toLowerCase());//outputs "hello world"
instanceof运算符:
instanceof方法要求开发者明确确认对象为某特定类型。
var oStringObject=new String("hello world");
alert(oStringObject instanceof String); //outputs "true"

运算符:
一元运算符:
1.delete运算符删除对以前定义的对象属性或方法的应用。
var o=new Object;
o.name="Nicholas";
alert(o.name); //outputs "Nicholas"
delete o.name;
alert(o.name);//outputs "undefined"
delete运算符不能删除开发者未定义的属性或方法。
delete o.toString;将引发错误，应为toString()方法是原始的ECMAScript方法。
2.void 运算符对任何值都返回undefined.该运算符通常用于避免输出不应该输出的值。
<a href="javascript:window.open('about:blank');">Click Me</a>
应改为: <a href="javascript:void(window.open('about:blank'));">Click Me</a>
3.前增量/前减量运算符
var iNum=10; ++iNum;
var iNum=10; --iNum;
iNum++,iNum--
4.一元加法和一元减法
var iNum=25;
iNum=+iNum;
alert(iNum);//outputs "25"
一元加法对数字无作用，但对字符串却有有趣的效果，会把字符串转会成为数字。
var sNum="25";
alert(typeof sNum);//outputs "string"
var iNum=+sNum;
alert(typeof iNum);//outpus "number"
这段代码把字符串"25"转换成真正的数字，当一元加法对字符串进行操作时，它计算字符串的方式与parseInt()相似，
主要不同时只有对"0x"开头的字符串，一元运算符才把它转换成十进制的值。因此，用一元加法转换"010",得到的总是10,而
"0xB"将被转换成11.

一元减法元素符也会把字符串转换成近似的数字，此外还会对该值求负.
var sNum="25";
alert(typeof sNum);
var iNum=-sNum;
alert(iNum);
alert(typeof iNum);
5.位运算符
位运算符NOT由否定号(~)表示.
位运算符NOT是三步的处理过程:
1.把运算数转换成32为数字。
2.把二进制形式转换成它的二进制反码。
3.把二进制反码转换成浮点数。
var iNum1=25;
var iNum2=~iNum1;
alert(iNum2);//outputs "-26"
位运算符ADN由和好(&)表示
var iResult=25&3;
alert(iResult); //outputs "1"
OR由符号(|) 表示
var iResult=25|3;
alert(iResult);//outputs "27"
XOR由符号(^)表示.
var iResult=25^3;
alert(iResult);
左移运算由两个小于号表示(<<)
var iold=2;
var iNew=iold<<5;//64
alert(iNew);
有符号右移运算右两个大于号(>>)表示.
无符号右移由三个大于号(>>>)表示。
Boolean运算符 NOT(!),ADN(&&),OR(||)

乘法运算符(*)
如果结果太大或太小，那么生成的结果就是Infinity或-Infinity
如果某个运算数是NaN,结果为NaN.
Infinity乘以0，结果为NaN.
Infinity乘以0以外的任务数字，结果为Infinity或-Infinity,由第二个运算数的符号决定。
Infinity乘以Infinity,结果为Infinity.
除法运算符(/)
加法运算符(+)
加法运算符(-)
关系运算符(<,>,<=,>=)
等性运算符
-------------------------------------------
表达式 值
-------------------------------------------
null==undefined true
"NaN"==NaN false
5==NaN false
NaN==NaN false
NaN!=NaN true
false==0 true
true==1 true
true==2 false
undefined==0 false
null==0 false
"5"==5 true
全等号和非全等号
var sNum="55";
var iNum=55;
alert(sNum==iNum); //outputs "true"
alert(sNum===iNum); //outputs "false"

var sNum="55";
var iNum=55;
alert(sNum!=iNum);//outputs "false"
alert(sNum!==iNum);//outputs "true"
条件运算符  ?   :
赋值运算符(=,*=,/=,%=,+=,-=,<<=,>>=)
逗号运算符(,) var iNum1=1;iNum2=2,iNum3=3;

if语句
if(condition) statement1 else statement2

迭代语句
do{
statement
}while(expression);

while(expression) statement

for语句
for(var i=0;i<iCount;i++){
alert(i);
}

for-in 语句是严格的迭代语句，用于枚举对象的属性。
for(sProp in window){
alert(sProp);
}

有标签的语句
lable:statement
例如: start: var iCount=10;标签start可被后来的break语句或continue语句引用。

break语句和continue语句
var iNum=0;
for(var i=1;i<10;i++){
if(i%5==0){
break;
}
iNum++;
}

alert(iNum); //outputs "4"

var iNum=0;
for(var i=1;i<10;i++){
if(i%5==0){
continue;
}
iNum++;
}

alert(iNum);//outputs "8"
break语句和continue语句可以与有标签的语句联合使用，返回代码中的特定位置。

var iNum=0;
outermost:
for(var i=0;i<10;i++){
for(var j=0;j<10;j++){
if(i==5 && j==5){
break outermost; //退出循环
}
iNum++;
}

}

alert(iNum); //outputs "55"

var iNum=0;

outermost:
for(var i=0;i<10;i++){
for(var j=0;j<10;j++){
if(i==5 && j==5){
continue outermost; //退出循环
}
iNum++;
}

}

alert(iNum); //outputs "95"

with语句用于设置代码在特定对象中的作用域。
with(expression) statement;
例如:
var sMessage="hello world";
with(sMessage){
alert(toUpperCase());//outputs "HELLO WORLD"
}
警告:with语句是运行缓慢的代码段，尤其是在已设置了属性值的时候。大多数情况下，如果可能，最好避免使用它。

switch语句,switch语句可以用于字符串，而且能用不是常量的值说明情况。
switch(expression){
case value:statement break;
case value:statement break;
default:statement
}

var BLUE="blue",RED="red",GREEN="green";
switch(sColor){
case BLUE:alert("Blue"); break;
case RED:alert("Red");break;
default:alert("Other");
}

函数
function sayHi(sMessage){
if(sMessage=="bye"){
return;
}
alert(sMessage);
}
注意:如果函数无明确的返回值，或调用了没有参数的return语句，那么它真正返回的值是undefined.
无重载 ECMAScript中的函数不能重载.
function doAdd(iNum){
alert(iNum+100);
}
function doAdd(iNum){
alert(iNum+10);
}

doAdd(10);
第二个doAdd()函数的定义覆盖了第一个定义。
arguments对象
在函数代码中，使用特殊对象arguments,开发者无需明确指出参数名，就能访问它们。例如,在
函数sayHi()中，第一个参数是message.用arguments[0]也可以访问这个值，即第一个参数的值.
因此，不需明确命名参数，就可以重写函数:
function sayHi(){
if(arguments[0]=="bye"){
return;
}
alert(arguments[0]);
}
还可用arguments对象检测传递给函数的参数的个数,引用属性arguments.length即可。
function howManyArgs(){
alert(arguments.length);
}

howManyArgs("String",45); //outputs "2"
howManyArgs(); //outputs "0"
howManyArgs(12); //outputs "1"
有了arguments对象，开发者就要检查传递给函数的参数的个数。
ECMAScript不会验证传递给函数参数的个数是否等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数。
(根据Netcape的文档，最多能接受25个)，而不会引发任何错误。任何遗漏的参数都会以undefined传递给函数，多余的参数
将忽略。

用arguments对象判断传递给函数的参数个数，即可模拟函数重载：
function doAdd(){
if(arguments.length==1){
alert(arguments[0]+10);
}else if(arguments.length==2){
alert(arguments[0]+arguments[1]);
}
}

doAdd(10);//outputs "20"
doAdd(30,20);//outputs "50"

Function 类
用Function类直接创建函数的语法如下:
var function_name=new Function(argument1,argument2,...,argumentN,function_body);
在这种形式中，每个argument都是一个参数，最后一个参数是函数主题(要执行的代码).
这些参数必须是字符串。
function sayHi(sName,sMessage){
alert("Hello"+sName+","+sMessage);
}
还可以如下定义:
var sayHi=new Function("sName","sMessage","alert(\"Helo\"+sName+\",\"+sMessage);");
doAdd=new Function("iNum","alert(iNum+100);");
doAdd=new Function("iNum","alert(iNum+10);");
doAdd(10);
Function 对象也有所有对象共享的标准valueOf()方法和toString()方法。这个两个方法返回的都是函数的源代码。
例如:
function doAdd(iNum){
alert(iNum+10);
}
alert(doAdd.toString());

闭包
ECMAScript最容易让人误解的一点是它支持闭包(closure).所谓闭包，是指词法表示包括不必计算的变量的函数，也就是说，
改函数能使用函数外定义的变量。在ECMAScript中使用全局变量是一个简单的闭包实例。
var sMessage="Hello World!";
function sayHelloWorld(){
alert(sMessage);
}

sayHelloWorld();
在一个函数中定义另一个函数会使闭包变得更复杂。
例如:
var iBaseNnm=10;
function addNumbers(iNum1,iNum2){
function doAddition(){
return iNum1+iNum2+iBaseNnm;
}
return doAddition();
}

alert(addNumbers(1,2));//outputs "13"
这里要掌握的重要概念是doAddition()函数根本不接受参数，它使用的值是从执行环境中获取的。
小结:
这一章介绍了ECMAScript的基础
一般语法
用关键字var定义变量
原始值和应用值
基础的原始类型(Undefined,Null,Boolean,Number,String)
基础的引用类型(Object,Boolean,Number,String)
运算符和语句
函数