JS一些 基础

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;都可以

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函数实际上是功能完整的对象

１，Function对象的length属性,声明了函数期望的参数个数

２，Function的arguments对象:（能很好的模仿函数重载。）

第一个参数是 可以用arguments[0] 访问（第一个参数位于位置 0，第二个参数位于位置 1，依此类推）

function howManyArgs() {
  alert(arguments.length);
}
howManyArgs("string", 45);
howManyArgs();
howManyArgs(12);

３，闭包（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。[也或说，内置对象是本地对象]]

宿主对象：所有ＢＯＭ和ＤＯＭ对象都是宿主对象。

１、定义类/对象

/*
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

１、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;}这么定义函数

２、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

３、命名空间：两种方式

//定义一个匿名函数，在匿名函数声明和实现内部函数，然后将内部函数注册到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