ECMAScript:并不与任何具体浏览器相绑定。Web 浏览器对于 ECMAScript 来说是一个宿主环境,但它并不是唯一的宿主环境。
DOM:是 HTML 和 XML 的应用程序接口(API)。DOM 将把整个页面规划成由节点层级构成的文档。
BOM:IE 3.0 和 Netscape Navigator 3.0 提供了一种特性 - BOM(浏览器对象模型),可以对浏览器窗口进行访问和操作。
=================
ECMAScript类型
在ECMAScript中,变量可以存在两种类型的值,即原始值和引用值。
原始值:存储在栈(stack)中的简单数据段,也就是说,它们的值直接存储在变量访问的位置。
引用值:存储在堆(heap)中的对象,也就是,存储在变量处的一个指针(point),指向存储对象的内存处。引用类型通常叫做类(class),也就是说,遇到引用值,所处理的就是对象。
/其中的boolean number string同时又是伪对象,也即可以说是JS中大部分变量类型都是对象了,像使用对象那么使用了。(除了undefined null当然不好当成对象)
原始类型有5种,即undefined null boolean number string
typeof运算符可以检查变量类型:如alert (typeof 86); //输出 "number"
引用值(类)
var o = new Object();
var o = new Object;都可以
hasOwnProperty(property)
判断对象是否有某个特定的属性。必须用字符串指定该属性。(例如.o.hasOwnProperty("name"))
IsPrototype(object)
判断该对象是否为另一个对象的原型。
PropertyIsEnumerable
判断给定的属性是否可以用for...in语句进行枚举。
ToString()
返回对象的原始字符串表示。对于Object对象,ECMA-262没有这个值,所以不同的ECMAScript实现具有不同的值。
ValueOf()
返回最适合该对象的原始值。对于许多对象,该国。法返回的值都与ToString()的返回值相同。
注:上面列的这些属性和方法都会被其他对象覆盖。
Boolean 对象是 Boolean 原始类型的引用类型。其他原始类型也都类似.
========================
ECMAScript运算符
delete
删除以前定义的对象属性或方法的引用。注:不能删除开发者未定义的属性和方法。
var o = new Object;
o.name = "David";
alert(o.name); //输出 "David"
delete o.name;
alert(o.name); //输出 "undefined"
========================
ECMAScript函数
ECMAScript函数实际上是功能完整的对象
1,Function对象的length属性,声明了函数期望的参数个数
2,Function的arguments对象:(能很好的模仿函数重载。)
第一个参数是 可以用arguments[0] 访问(第一个参数位于位置 0,第二个参数位于位置 1,依此类推)
function howManyArgs() {
alert(arguments.length);
}
howManyArgs("string", 45);
howManyArgs();
howManyArgs(12);
3,闭包(closure)
var iBaseNum = 10;
function addNum(iNum1, iNum2) {
function doAdd() {
return iNum1 + iNum2 + iBaseNum;
}
return doAdd();
}
================
再说对象
ECMA-262 把对象(object)定义为“属性的无序集合,每个属性存放一个原始值、对象或函数”。严格来说,这意味着对象是无特定顺序的值的数组。
尽管 ECMAScript 如此定义对象,但它更通用的定义是基于代码的名词(人、地点或事物)的表示。
本地对象(native object):[个人觉得也应属性于内置对象,是是ECMA-262定义的对象(引用类型)]
内置对象:CMA-262 只定义了两个内置对象,即 Global 和 Math。[也或说,内置对象是本地对象]]
宿主对象:所有BOM和DOM对象都是宿主对象。
1、定义类/对象
/*
var oCar = new Object;
oCar.color = "blue";
oCar.doors = "2";
oCar.showColor = function(){
alert(this.color);
}
alert(oCar.color);
oCar.showColor();
*/
/*
function creatCar(){
var oCart = new Object;
this.color = 'blue';
this.doors = "4";
this.showCar = function(){
alert(this.color);
}
}
var cart1 = new creatCar();
var cart2 = new creatCar();
cart1.showCar();
cart2.showCar();*/
/*
function Car(){
this.showDoors = function(){
alert(this.doors);
}
}
Car.prototype.color = 'blue';
Car.prototype.doors = '4';
Car.prototype.showColor = function(){
alert(this.color);
}
var car1 = new Car();
var car2 = new Car();
car1.color = 'red';
car1.showColor();
car2.showColor();
*/
/*
function Car() {
}
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showDrivers = function() {
alert(this.drivers);alert(1);
};
var oCar1 = new Car();
//oCar1.drivers.push("Bill");
//oCar1.drivers = 'abc';
delete oCar1.drivers;
alert(oCar1.drivers);alert(0);
alert(oCar1.showDrivers()); //输出 "Mike,John,Bill"*/
/*
function Car() {
}
Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showColor = function() {
alert(this.color);
};
var oCar1 = new Car();
var oCar2 = new Car();
oCar1.drivers.push("Bill");
alert(oCar1.showColor()); //输出 "Mike,John,Bill"
alert('after oCar1');
alert(oCar2.showColor()); //输出 "Mike,John,Bill"*/
============================
一些小点:http://hmking.blog.51cto.com/3135992/669507
1、ECMAScript 不会验证传递给函数的参数个数是否等于函数定义的参数个数;也就是说函数的定义和使用时参数个数可以不一致,但函数定义时不能赋默认值,即:
function fun(a,b,c){} fun(); function fun(a,b,c){} fun(1,2,3,4);都不可以,不报错。
function fun(a,b=0){} fun(1,2);//这么写就报错,不能这么给参数赋初值(看来就PHP比较牛叉)
但想给参数赋初值有个变通方式,即function fun(a,b){b=0;}这么定义函数
2、ECMAScript的函数中有个特殊的arguments对象,用于函数被调用的所传的参数。
function fun(a,b){
b=5;
alert('in fun---'+a+b+'+++'+arguments.length+'***'+arguments[1]);
}
fun(1,2);//in fun--15+++2***'5
fun(1);//in fun--15+++1***'undefined
3、命名空间:两种方式
//定义一个匿名函数,在匿名函数声明和实现内部函数,然后将内部函数注册到window对象中;比较直观
(function() {
function fun(){
var _var = 1;
alert('in namespace '+_var);
}
window['namespace'] = {};
window['namespace']['fun'] = fun;
})();
function fun(){alert('global fun');};
//namespace.fun();
//fun();
//下面这种方式是个比较常见的方式,更像传统的类定义;其实也即是用了Object()对象,及prototype属性进行封装使用。
mynamespace = new Object();
mynamespace.register = function(fullname){
var nsArray = fullname.split('.');
var strNs = '';
var strEval = '';
for(var i=0; i<nsArray.length; i++){
if(strNs.length>0){strNs += '.';}
strNs += nsArray[i];
strEval = 'if(typeof('+ strNs + ')=="undefined")'+ strNs +'=new Object;';
}
if(strNs !=''){eval(strEval);}
}
mynamespace.register('myNs');
myNs.control = function(v1,v2){
this.var1 = v1;
this.var2 = v2;
}
myNs.control.prototype.alertV1 = function(){
alert(this.var1);
}
var myN = new myNs.control('abc', 'def');
myN.alertV1();
4、继承
对象冒充:
function classA(color){
this.colorj = color;
this.syaColor = function(){
alert(this.color);
}
}
function classB(color, name){
this.newMethod = classA;
this.newMethod(color);
delete this.newMethod();
this.name = name;
this.sayName = function(){
alert(this.name);
}
}
classA赋给了方法newMethod(函数名只是指向它的指针),然后调用该方法,传递给它的是classB