JavaScript一点总结

1.类型

ECMAScript的原始类型：

undefined、null、boolean、string

2.typeof 运算符

对变量或值调用type of运算符将返回下列值之一：

"undefined"，如果变量是undefined型的；

"boolean"，如果变量是boolean型的；

"number"，如果变量是number型的；

"string"，如果变量是string型的；

"object"，如果变量是引用类型或null类型的；

var temp = "test string"；

alert(typeof temp)；  //outputs "string"

alert(typeof 95)；      //outputs "number"

3.转换

parseInt()、parseFloat()，只有对String类型调用这些方法，它们才能正确运行，对其他类型调用则返回的都是NaN。

parseInt()：

var num1 = parseInt("1234blue")； //returns 1234

var num2 = parseInt("0xA")；          //returns 10

var num3 = parseInt("22.5")；         //returns 22

var num4 = parseInt("blue")；         //return NaN

parseInt()方法的基模式：

var num1 = parseInt("10",2)；        //return 2

var num2 = parseInt("10",8)；        //return 8

var num3 = parseInt("10",10)；      //return 10

var num4 = parseInt("AF",16)；      //return 175

如果十进制数字符串包含前导0，那么最好采用基数形式的parseInt()方法转换，这样才不会意外地得到八进制的值。例如：

var num1 = parseInt("010")；          //return 8

var num2 = parseInt("010",8)；       //return 8

var num3 = parseInt("010",10)；     //return 10

parseFloat()：

使用parseFloat()的不同之处在于，字符串必须以十进制形式表示浮点数。另外该方法会忽略前导0，所以八进制010将被解析为10.0。对于十六进制数0xA，则返回NaN，因为在浮点数中，x不是有效字符。parseFloat()也没有基模式。

var num1 = parseFloat("1234blue")； //returns 1234.0

var num2 = parseFloat("0xA")；          //returns NaN

var num3 = parseFloat("22.5")；         //returns 22.5

var num4 = parseFloat("22.34.5")；    //return 22.34

var num5 = parseFloat("0908")；        //returns 908.0

var num6 = parseFloat("blue")；         //return NaN

4.本地对象-Object类：

属性：

constructor：对创建对象的函数的引用。对于Object类，该指针指向原始的object()函数；

prototype：对该对象原型的引用；

方法：

hasOwnProperty(property)：判断该对象是否具有某个特定的属性，必须用字符串指定该属性；

isPrototypeOf(object)：判断该对象是否为另外一个对象的原型；

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

5.本地对象-Number类：

toFixed()：返回具有指定位数小数的数字的字符串表示。例如：

var numberObject = new Number(99)；

alert(numberObject.toFixed(2))；    //outputs "99.00"

6.本地对象-String类：

charAt()、charCodeAt()：

var stringObject = new String("hello world")；

alert(stringObject.charAt(1))；    //outputs "e"

var stringObject = new String("hello world")；

alert(stringObject.charCodeAt(1))；    //outputs "101"

concat()：把一个或多个字符串连接到String对象的原始值上。原始的String对象的值不变。

var stringObject = new String("hello ")；

var result = stringObject.concat("world");

alert(result)；    //outputs "hello world"

alert(stringObject)；  //outputs "hello "

indexOf()、lastIndexOf()：

var stringObject = new String("hello world")；

alert(stringObject.indexOf("o"))；    //outputs "4"

alert(stringObject.lastIndexOf("o"))   //outputs "7" 

substring()：返回要处理的字符串的子串，接受一个或两个参数。第一个参数是子串的起始位置，第二个参数是子串的截止位置（不包含此位置）。

toLowerCase()、otUpperCase()：大小写转换。

记住，String类的所有属性和方法都可应用于String原始值，因为它们是伪对象。

7.instanceof运算符

在type of方法返回"object"的情况下，instanceof()方法还是很有用的

var stringObject = new String("hello world")；

alert(stringObject instanceof String)； //outputs "true"

8.ECMAScript中的函数不能重载

9.arguments对象

在函数代码中，使用特殊对象arguments，开发者无需明确指出参数名，就能访问它们。与其他程序设计语言不同，ECMAScript不会验证传递给函数的参数个数是否等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数，而不会引发任何错误。任何遗漏的参数都会以 undefined传递给函数。

用arguments对象判断传递给函数的参数个数，即可模拟函数重载：

function doAdd(){

    if (arguments.length == 1){

        alert(argumets[0] + 10);

    } else if (arguments.length == 2) {

        alert(arguments[0] + arguments[1]);

    }

}

doAdd(10);  //outputs "20"

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

10.本地对象-Array类

与Java不同的是，在ECMAScript中有真正的Array类。可以如下创建Array对象：

var values = new Array();

如果预先知道数组中项的个数，可以用：

var values = new Array(20);

如果预先知道数组中的项，可以用：

var colors = new Array("red","green","blue");

或

var colors = ["red","green","blue"];

ECMAScript的Arrayl可以动态的调整长度：

var colors = new Array();

colors[0] = "red";

colors[1] = "green";

colors[2] = "blue";

每增加一个数组项，数组大小就动态地增长。

toString()：

var colors = ["red","green","blue"];

alert(colors.toString());  //outputs "red,green,blue"

join()方法：

var colors = ["red","green","blue"];

alert(colors.join("-"));  //outputs "red-green-blue"

split()方法，String转数组：

var colorsStr = "red,green,blue";

var colorsArr = colorsStr.split(",");

如果把空字符串声明为分隔符：

var colorsStr = "green";

var colorsArr = colorsStr.split("");

alert(colorsArr.toString);  //outputs "g,r,e,e,n"

concat()方法：

var colors = ["red","green","blue"];

var colors2 = colors.concat("yellow","purple");

alert(colors2.toString());  //outputs "red,green,blue,yellow,purple"

alert(colors.toString());    //outputs "red,green,blue"

slice()方法：

类似String的substring()方法，只是在这里它返回的是数组

push()和pop()方法，可模拟栈操作：

var stack = new Array();

stack.push("red");

stack.push("green");

stack.push("yellow");

alert(stack.toString);  //outputs "red,green,yellow"

var item = stack.pop();

alert(item);  //outputs "yellow"

alert(stack.toString());  //outputs "red,green"

shift()和unshift()方法：分别删除数组的第一项，插入到第一项

var colors = ["red","green","yellow"];

var item = colors.shift();

alert(item);  //outputs "red"

alert(colors);  //outputs "green,yellow"

colors.unshift("black");

alert(colors.toString());  //outputs "black,green,yellow"

通过shift()和push()方法可模拟队列操作

var queue = ["red","green","yellow"];

var out = queue.shift();

alert(out);  //outputs "red"

alert(queue.toString()); //outputs  "green,yellow"

queue.push(black);

alert(queue.toString());  //outputs "green,yellow,black"

reverse()：将数组逆排

sort()：按数组项首字符排序，慎用

var colors = [3,32,2,5];

colors.sort();

alert(colors.toString());  //outputs  "2,3,32,5"

splice()方法：

arr.splice(0,2) 将删除数组中的前两项

arr.splice(2,0,"red","green") 将在位置2处插入"red"和"green"

arr.splice(2,1,"red","green") 删除位置2处的1项，再在位置2处插入"red"和"green"

11.本地对象-Date对象：略

内置对象-Global对象：Global对象实际上它根本不存在，isNan()、isFinite()、parseInt()、parseFloat()实际上都是Global对象的方法

encodeURI()和encodeURIComponent()方法：用以编码URI

var uri = http://www.rox.com/illegal value.htm#start;

alert(encodeURI(uri));  //outputs  "http://www.wrox.com/illegal%20value.htm#start"

alert(encodeURIComponent(uri));  //outputs "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"

decodeURI()和decodeURIComponent()方法用以解码URI

12.内置对象-Math对象

min(),max(),abs(),ceil(),floor(),round()

random()：返回0-1之间的数，不包括0和1.

如果你想选择一个1-10之间的数，则

var num = Math.floor(Math.random() * 10 + 1);

如果想选择2-10之间的数，则

var num = Math.floor(Math.random() * 9 + 2);

13.创建对象（混合构造函数与原型方法）

function Car(color,doors,mpg){

    this.color = color;

    this.doors = doors;

    this.mpg = mpg;

    this.drivers = new Array("Mike","Sue");

}

Car.prototype.showColor = function () {

    alert(this.color);

};

var car1 = new Car("red",4,23);

var car2 = new Car("blue",3,25);

car1.drivers.push("Matt");

alert(car1.drivers);  //outpus "Mike,Sue,Matt"

alert(car2.drivers);  //outputs "Mike,Sue"

14.继承（对象冒充继承构造函数的属性，用原型链继承prototype对象的方法）

function ClassA(color){

    this.color = color;

}

ClassA.prototype.sayColor = function () {

    alert(this.color);

};

function ClassB(color,name){

    ClassA.call(this,color);

    this.name = name;

}

ClassB.prototype = new ClassA();

ClassB.prototype.sayName = function () {

    alert(this.name);

}

15.待续