JavaScript学习笔记第二天

变量

var test=“hi”;

变量名的命名规则

1.第一个字符必须是字母、下划线（_）或美元符号($)

2.余下的字符可以是下划线、美元符号或任何字母或数字字符

camel 驼峰标记法

首字母是小写，接下来的单词都是以大写字母开头，

var myTestValue = 0,mySecondTestValue = "hi"；

Pascal 标记法   

首字母是大写，接下来的单词都以大写字母开头.

var MyTestValue = 0;

匈牙利类型标记法

在以Pascal标记法命名的变量前附加一个小写字母（或小写字母序列）,说明该变量的类型，例如，i表示整数，s表示字符串,如下所示:

var iMyTestValue = 0,sMySecondTestValue = "hi";

alert(sTest2);

类型                                             前缀                                                          实例

数组                                             a                                                                 aValues

布尔型                                          b                                                                bFound

浮点型                                          f                                                                  fValue

函数                                             fn                                                                 fnMethod

整型                                             i                                                                    iValue

对象                                            o                                                                   oType

正则表达式                                re                                                                    rePattern

字符串                                        s                                                                      sValue

变型                                             v                                                                      vValue

ECMAScript 另一个有趣的方面是 使用变量之前不需要声明

var sTest = "hello";

sTest2=sTest+"world"；//连接上 hello+world不需要声明sTest2
ECMAScript的解释程序遇到未声明过的标识符，用该变量名创建一个全局变量 ，并将其初始化为指定的值，这是该语言便利之处，不过如果不能紧密跟踪变量，这样做很危险，最好的习惯还是应该声明所有的变量

E
4000
CMAScript 关键字

break              else                   new                         var

case               finally                 return                      void

catch              for                    switch                    while

continue            function            this                with

defalut                if                        throw

delete                in                       try

do                      instanceof           typeof

如果把关键字用作变量名或函数名，可能得到诸如“Indentifier expected”(应该有标识符)这样的错误信息

保留字   ECMAScript 还定义一套保留字

abstract                 enum                   int                   short

boolean                export                     interface           static

byte                      extends                     long                    super

char                     final                          native                   synchronized

class                  float                      package                 throws

const                  goto                      private                    transient

debugger           implements          protected            volatile

double                    import                public

保留字是为将来的关键字保留的单词 因此保留字不能用作变量名或函数，如果使用保留字，除非将来浏览器实现了保留字，否则很可能收不到任何错误消息，当浏览器实现时，出现关键字错误

  ECMAScript的原始值 和引用值

变量可以存储两种类型的值，即原始值和引用值

原始值 primitive value 是存储在栈中(stack)中的简单数据段，也就是说，他们的值直接存储在变量访问的位置

引用值 reference value 是存储在堆（head）中的对象，也就是说，存储在变量处的值是一个指针，指向存储对象的内存处

为变量赋值时，ECMAScript 的解释程序必须判断该值是原始类型，还是引用类型，要实现这一点，解释程序需尝试判断该值是否为ECMAScript的原始类型之一

即Undefined、Null、Boolean、String型 由于这些原始数据占据的空间是固定的，所以可以将他们存储在较小的内存区域 栈中，便于迅速查找变量的值

如果一个值是引用类型，那么存储空间将从堆中分配。由于引用值大小会改变，所以不能放在栈中，否则会降低变量的查询速度

相反放在变量的栈空间的值是该对象存储在堆中的地址，地址的大小是固定的，所以把它存储在栈中对变量性能无任何负面影响。

栈                                               堆

地址-------------------------------->（对象）

原始类型

ECMAScript是有5中原始类型 primitive type 即 Undefined、Null、 Boolean、Number和String

ECMAScript通过typeof运算符来判断一个值是否在某种类型的范围内

var sTemp = "test String"；

alert(typeof sTemp);//outputs "string"

alert(typeof 95)//outputs "number"

对变量或值调用typeof运算符将返回值为

“undefined ”--------------------->如果变量是Undefined型的

"boolean"----------------------->如果变量是Boolean型

“number”------------------------>如果变量是Number型

"string"--------------------------->如果变量是String型

"object"------------------------>如果变量是一种引用类型或Null类型的。

从技术上来说  null虽然被认为是对象的占位符，但从技术上说，它依然是原始值

Undefined 类型

var oTemp          当声明的变量未初始化时，该变量的默认值是undefined.

var oTemp

alert(oTemp == undefined );

这段代码将显示“true”

注意 值 undefined 并不同于未定义的值，但是typeof运算符并不真正区分这两种值。

考虑下面的代码

var oTemp;

alert(typeof oTemp);                 //output “undefined”

alert(typeof oTemp2);            //outputs "undefined"

alert （oTemp2==undefined）// cause error因为oTemp2未被声明过

当函数无明确的返回值时，返回的值是undefined

function testfunc(){

}

alert(testFunc()==undefined);//outputs "true"

Null类型

另一种只有一个值的类型是Null，它只有一个专用值null,即它的字面值，值undefined实际是从null派生来的，因此ECMAScript是他们定义为相等

alert(null==undefined); //outputs "true"

尽管这两个值相等，但是它们之间的含义不同，undefined是声明了变量但未对其初始化时赋予该变量的值，null则用于表示尚未存在的对象（在讨论typeof运算符时，简单地介绍这一点）如果函数或方法要返回的是对象，那么找不到该对象时，通常返回的是null

Boolean类型

Boolean类型是ECMAScript中最常用的类型之一，他有两个值true和false(即两个Boolean字面量),即使false不等于0，0也可以在必要时转换成false,这样在Boolean语句中使用两者都是安全的。

var bFound =true;

var bLost = false;

Number类型

ECMA-262中定义的最特殊的类型是Number型，这种类型既可以是32位的整数，还可以表示64位的浮点数。

直接输入的（而不是从另一个变量访问的）任何数字都被看作Number型的字面量

var iNum = 55;

整数也可以表示为八进制，或者十六进制

var iNum = 070;

var iNum = 0x1f；

尽管所有的整数都可表示为八进制或十六进制的字面量，但所有数字运算返回的都是十进制结果。

要定义浮点值，必须包括小数点和小数点后的一位数字（例如，用1.0而不是1）。这被看作浮点数字面值，例如

var fNum = 5.0;

浮点字面量的有趣之处在于，用它进行计算前，真正存储的是字符串。

对于非常大或非常小的数，可以用科学记数法表示浮点数 ，可以把一个数表示为数字加e,后面乘以10的倍数

var fNum =3.125e7

表示的数是31250000

Number.MAX_VALUE和Number.MIN_VALUE,他们定义了Number值集合的外边界。所有ECMAScript数都必须在这两个值之间。

不过生成的数值结果可以不落在这两个数之间

当计算生成的数大于Number.MAX_VALUE时，它将被赋予值Number.POSITIVE_INFINITY,意味着不再有数字值，同样，生成的数值小于Number.MIN_VALUE的计算也被赋予值

Number.NEGATIVE_INFINITY,也意味着不再有数字值，如果计算返回的是无穷大值，那么生成的结果不能用于其他计算。

事实上，有专门表示无穷大的值 Infinity。Number.POSITIVE_INFINITY的值为Infinity,Number.NEGATIVE_INFINITY的值为-Infinity

由于无穷大数可以是正数也可以是负数，所以可用一个方法判断一个数是否是有穷的，（而不是单独测试每个无穷数）可以对任何数调用isFinit()方法，以确保该数不是无穷大

var iResult = iNum*some_really_large_number;

if(isFinite(iResult)){

alert("Number is finite");

}

else {

alert("Number is infinite");//Infinity

}

最后一个特殊值是NaN，表示非数（Not a Number） NaN是个奇怪的特殊值，一般说来，这种情况发生在类型（String、Boolean）转换失败时

例如 把单词 blue 转换成 数值 就会失败，因为没有与之等价的数值，与无穷大值一样，NaN也不能用于算术运算，NaN的另一个奇特之处在于

他与自身不相等，

alert(NaN==NaN) //outputs false;

出于这种原因，方法 isNaN()会做得很好

alert(isNaN("blue"))；//outputs "true"；

alert(isNaN("123")); //outputs "false";

String类型

String类型是唯一没有固定大小的原始类型，可以用字符串存储0或更多Unicode字符，由16位整数表示（Unicode 是一种国际字符集）

字符串每个字符都有特定的位置，首字符从位置0开始，第二个字符在位置1，依次类推，这意味这最后一个字符一定是字符串的长度减1

字符串的字面量是由单引号或双引号声明的，而Java则是用双引号声明的字符串，用单引号声明字符，但是由于ECMAScript没有字符类型，所以可以使用

这两种表示法中的任何一种，例如下面的代码均有效

var sColor ="blue"';

var sColor2='blue'';

String类型还包括几种字符字面量

\n                                     换行

\t                                  制表符

\b                                  空格

\r                                   回车

\f                                    换页符

\\                                    反斜杠

\'                                     单引号

\"                                      双引号

\0nnn                               八进制代码nnn

\xnn                                 十六进制代码nn

\unnnn                                十六进制代码nnnn

转换

所有程序语言都具有自动类型转换的能力，ECMAScript给开发者提供了大量简单的转换方法，

1.转换成字符串

ECMAScript 的Boolean值、数字和字符串的原始值的有趣之处，在于他们是伪对象，这意味着他们实际上具有属性和方法。例如，要获得字符串的长度，可以采用以下代码

var sColor="blue";

alert(sColor.length);//outputs "4"

尽管blue是原始类型的字符串，它依然是具有属性length用来存放该字符串的大小。总而言之，3种主要的原始值Boolean值、数字和字符串都有toString()方法，可以把他们的值转换成字符串。

Boolean型的toString()方法，输出方法只是输出“true”或者"false"，结果由变量的值决定。

var bFound = false;

alert(bFound.toString());//outputs "false";

Number类型的toString()方法比较特殊，它有两种模式，即默认模式和基模式。采用默认模式，toString()方法只是用相应的字符串输出数字值（无论是整数，浮点数还是科学记数法）如下所示：

var iNum1 = 10;

var fNum2 = 10.0;

alert(iNum1.toString());//outputs "10"

alert(fNum2.toString());//outputs  “10”

在默认模式下，无论最初采用什么表示法声明数字，Number类型的toString()方法返回的都是数字的十进制表示。因此 以八进制或十六进制字面量形式声明的数字输出时都是十进制形式的。

采用Number类型的toString()基模式，可以用不同的基输出数字，例如二进制的基是2，八进制的基是8，十六进制的基是16.。基 只是要转换成的基数的另一种说法而已它是toString()方法的参数；

var iNum = 10;

alert(iNum1.toString(2));//outputs "1010"

alert(iNum1.toString(8));//outputs 12

alert(iNum1.toString(16));//outputs A

alert(iNum1.toString());//outputs 10

在前面的示例中，以3种不同的形式输出了，数字10，即二进制形式、八进制形式和十六进制形式。HTML采用十六进制表现每种颜色，

HTML中处理数字时这种功能非常有用。

对数字调用toString(10)与调用toString()相同，他们返回的都是该数的十进制形式。

转换成数字

ECMAScript提供了两种把非数字的原始值转换成数字的方法，即parseInt()和parseFloat()都会仔细分析该字符串。parseInt()方法会首先查看位置0处的字符，判断它是否是个有效数字。如果不是那么方法会返回NaN,不再继续执行其他操作但如果该字符是有效数字，该方法将查看位置1处的字符，进行同样的测试。这一过程将持续到发现非有效数字为止，比如“1234blue”转换成整数，那么parseInt()将把该字符之前的字符串转换成数字。例如，因此字符"0xA"会被正确转换成数字10,不过字符串"22.5"会被转换成22

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

parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的。所以要解析十六进制的值

需要如下方法

var iNum1 = parseInt("AF"，16);//returns 175

var iNum2 = parseInt("10",2);//returns 2

var iNum2=parseInt("10",8);//return 8;

var iNum2 = parseInt("10",10);//returns 10

如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值，例如

var iNum1=parseInt("010");//returns 80

var iNum2=  parseInt("010",8);//returns 8

var iNum3 = parseInt("010",10);//returns 10

在这段代码中，两行代码都把字符串“010”解析成了一个数字，第一行代码把这个字符串看作八进制的值，解析它的方式与第二行代码（声明基数为8）相同，最后一行代码声明基数为10，所以iNum3最后等于10

parseFloat()方法与parseInt()方法的处理方式相似，从位置0开始查看每个字符，直到找到第一个非有效的字符为止，然后把该字符之前的字符串转换成数字。不过对于这个方法来说，第一个出现的小数点是有效数字，如果有两个小数点，那么第二个小数点被看作无效，parseFloat()方法会把这个小数点之前的字符串转换成数字。这意味着字符串“22.34.5”将被解析为22.34

与parseInt()不同，parseFloat()字符串必须以十进制方式表示浮点数，所以该方法会忽略前导0,所以0908会被解析成908，

0xA 会返回NaN

parseFloat（“1234blue”）//returns 1234.0

parseFloat("0xA")//returns NaN

parseFloat("22.5");//returns 22.5

parseFloat("0908");//returns 908.0

parseFloat("blue");//returns NaN

强制类型转换（type casting）

Boolean(value)-------把给定的值转换成Boolean型。

Number(value)-------把给定的值转换成数字（可以是整数或浮点数）

String(value)-------把给定的值转换成字符串.

用这三个函数之一转换值，将创建一个新值，存放由原始值，直接转换成的值，这会造成意想不到的后果。

当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()返回的是true,如果该值是空字符串，数字0，undefined
b565
或null 那么将返回false.可以用下面的代码段测试Boolean的类型转换

var b1 = Boolean(" ");// returns false;

var b2 = Boolean("hi");//returns true;

var b3 = Boolean(100);//returns  true；

var b4 = Boolean(null);//returns false;

var b5 = Boolean(0);//returns false;

var b6 =  Boolean(new Object());//returns true;

Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值，还记得吗。parseInt()和parseFloat()方法只转换第一个无效字符之前的字符串，因此"4.5.6"。用Number()进行强制类型转换，“4.5.6”将返回NaN，因为整个字符串值不能转换成数字。如果字符串值能被完整地转换，Number()将判断是调用 pareseInt()方法，还是调用，parseFloat()方法，下表说明了对不同的值调用Number()方法会发生情况。

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()是最简单，因为它可把任何值转换成字符串，要执行这种强制类型转换，只需要调用作为参数传递进来的值的toString()方法，即把1转换成1

把true转换成true,把false转换成false,以此类推，强制转换成字符串和调用toString()方法的唯一不同之处在于，对null或undefined值强制类型转换可以生成字符串而不引发错误。

var s1 = String(null);//“null”

var oNull  = null;

var s2 = oNull.toSrring();//won't work，causes an error

在处理ECMAScript这样的弱类型语言时，强制类型转换非常有用，不过应该确保使用值的正确。

引用类型

引用类型 通常叫做类 class 也就是说 遇到引用值时，所处理的就是对象，

从传统意义上来说，ECMAScript并不真正具有类，事实上，除了说明不存在类，在ECMA-262中根本没有出现"类"这个词，ECMAScript定义了“对象定义”

逻辑上等价于类，

对象是由new 运算符加上要实例化的类的名字创建的，例如，下面代码创建了Object类的实例

var o = new Object();

这种语法与java相似，不过当有不止一个参数，ECMAScript要求使用括号,如果没有参数，如前面代码所示，括号可以忽略

var o = new Object;

尽管括号不是必须，但是为了避免混乱，最好使用括号

Object类

Object类自身用处不大，不过在了解其他类之前，还是应该先了解它，因为ECMAScript中的object类与Java的object相似，ECMAScript中所有的类都是由这个类继承而来，

object类的所有属性和方法都会出现在其他类中，所以理解了object类，就可以更好的理解其他类。

object类具有下列属性：

Constructor -----对创建对象的函数引用（指针）。对于object类，该指针指向原始的object()函数。

Prototype-------对该对象的对象原型的引用，对于所有的类，它默认返回object对象的一个实例。

object类还有几个方法，

HasOwnProperty(property)-----判断对象是否有某个特定的属性，必须用字符串指定该属性（例如，o.hasOwnProperty("name")）;

IsPrototypeOf（object）------判断该对象是否为另一个对象的原型

PropertyIsEnumerable(property)------------------判断给定的属性是否可以用for......in语句进行枚举

ToString()----------返回对象的原始字符串表示，对于Object类，ECMA-262没有定义这个值，所以不同的ECMAScript实现具有不同的值。

ValueOf()-----------返回最适合该对象的原始值。对于许多类，该方法返回的值都与toString()的返回值相同

上面列出的每种属性和方法，都会被其他类覆盖

Boolean类

Boolean类是Boolean原始类型的引用类型，要创建Boolean对象，只需要传递Boolean值作为参数

var oBooleanObject = new Boolean(true)；

Boolean对象将覆盖object类的valueOf()方法，返回原始值，即true或false

ToString()方法也会被覆盖，返回字符串“true”或“false”。

遗憾的是 在ECMAScript中很少使用Boolean对象，即使使用，也不易理解。

问题通常出现在Boolean表达式中使用Boolean对象时，例如

var oFalseObject = new Boolean(false);

var bResult = oFalseObject && true;      //outputs true

这段代码中，用false的值创建了Boolean对象oFalseObject。然后用这个值与原始值true进行AND操作，在Boolean运算中，false和true进行AND操作的结果是false,不过，在这行代码中，计算的是oFalseObject，而不是它的值false,正如前面讨论过的，在Boolean表达式中，所有对象都会被自动转换为true,所以oFalseObject的值是true，然后true再与true进行AND操作，结果为true.

虽然你应该了解Boolean对象的可用性，不过最好还是使用Boolean原始值，避免发生这上面的问题，

Number类

Number类是Number原始类型的引用类型。要创建Number对象，采用下面的代码

var oNumberObject = new Number(55);

Number.MAX_VALUE时提到的Number类，所有的特殊值都是Number类的静态属性。

要得到数字对象的Number原始值，只需要使用valueOf()方法；

var iNumber = oNumberObject.valueOf();

当然，Number类也有toString()方法。

除了从object类中继承的标准方法外，Number类还有几个处理数值的专用方法。

toFixed()方法返回是具有指定位数小数的数字的字符串显示。

var oNumberObject = new Number(99);

alert(oNumberObject.toFixed(2)); //Outputs 99.00；

处理货币的应用程序，该方法非常有用。

toFixed()方法的参数是2.说明了应该显示几位小数，该方法将返回99.00空的小数位由0补充，

toFixed()方法能表示具有0到20位小数的数字，超出这个范围的值会发生错误

与格式化数字相关的另一种方法是toExponential()它返回的是用科学记数法表示的数字的字符串形式，

与toFixed()相似，toExponential()方法也有一个参数，指定要输出的小数位数，例如

var oNumberObject = new Number(99);

alert(oNumberObject.toExponential(1));//outputs “9.9e+1”;

这段代码的结果输出9.9e+1，

问题是如果不知道要用哪种星矢（预定形式或指数形式）表示数字那么可以使用，toPrecision()方法

toPrecision()方法根据最有意义的形式来返回数字的预定形式或指数形式，它有一个参数，即用于表示数的数字总和（不包括指数）

如

var oNumberObject = new Numer(99);

alert(oNumberObject.toPrecision(1));//outputs 1e+2

这段代码的任务是用一位数字表示数99，结果为1e+2，以另外的形式表示100,的确，toPrecision()方法会对数进行舎入。由于用两位以下数字不能表示99

所以必须这样舎入，不过如果想用2位数字表示99那就容易多了

var oNumberObject = new Number(99);

alert(oNumberObject.toPrecision(2));//outputs "99"

如果输入的数字大于需要的位数,

var oNumberObject = new Number(99);

alert(oNumberObject.toPrecision(3));//outputs "99.0"

与Boolean对象相似，Number对象也很重要，不过应该少用这种对象。以避免发生潜在的问题，只要可能，都是用数字的原始表示法
String 类

String类是String原始类型的对象表示法，它是以下列方式创建的

var oStringObject = new String("hello world");

String对象的valueOf()方法和toString()方法，都会返回String型的原始数据。

var oStringObject = new String("hello world");

alert(oStringObject.valueOf()==oStringObject.toString()); //outputs "true"；