javascript的面向对象 函数 闭包 构造函数 继承

<script>
//------------函数的创建方式------------
function f1() {
alert('我是一个兵');
}

var a = function () {
alert("我是两个兵");
}

f1();
a();           //其实也可以这样写(a)();

(function () {                 //这个其实就是有a演变过来的   后面括号表示立即执行  可以存放参数  为了后面闭包
alert("我是三个兵");
})();

(function (p) {
alert(p);
})(123);

//-------------arguments对象-----------------
function arg(a,b,c) {
//在函数执行时有个arguments对象，保存所有的参数
//arguments对象，类似数组，可以用下标访问，并且有length属性
//            alert(arguments);
alert(arguments[3]);
alert(arguments.length);
alert(a+"\n"+b+"\n"+c);
}
arg(1,2,3,4);

//--------------闭包------------------------------------------
//闭包，指的是词法表示包括不被计算的变量的函数，也就是说，函数可以使用函数之外定义的变量
var g = "全局变量！！！";                   //这里讲的还是函数的嵌套使用
function fnA() {
var a = "A";
//alert(g);
fnB();        //注意这里还是要执行的
function  fnB() {
var b = "B";
alert(g);    //全局变量，在任何函数的任何位置都可以访问得到
alert(a);    //可以访问到a
alert(c);    //但不可以访问c
function fnC() {
var c = "C";
alert(a+"\n"+b);     //只要遵循从里向外看的原则  看到的变量都可以访问到最终值
}                         //在函数声明处向函数外部看到的声明的所有变量，在 函数内部都能访问到他们的最终值
fnC();
}
}

//fnB()        在这里是不能访问到的  因为函数换种方式写就是变量了  这个函数就相当于局部变量 外面是访问不到的  上面提示也有把锁  表示访问不到

//-----------闭包详解-----------------
function outer() {
var a = 1212,b = 1234;
function inner() {
return a;
}
inner.function_closure= {a:1212,b:1234};          //这边是自定义的  其实是不存在的
return inner;              //这里的返回值为函数类型   要想使用就必须调用（）
}
var inner = outer();
alert(inner());

function each() {
var i = 0,innner,a = [];
for(; i<10;i++){
cache(i);            //如果直接把函数cache放在这里面的话 就只能访问到i的最终值10
// 这样写的话就可以访问到全部的变量了  闭包的一部分
}

function cache(i) {
a.push(function () {
alert(i);
})
}
}

//--------------构造函数------------------
function Demo(name,age) {
this.name = name;       //这里的this很关键
this.age  = age;
//            return [123,456];         //这是错误的   因为构造函数不能有返回值 他
}
var  d = new Demo("cj",18);
alert(d.name);
alert(d.age);

var c = Demo("VJ",19);            //不用new的时候 this指向的是window对象
alert(widows.name+"\n"+window.age);

//-------------继承------------------
//------------这里是无参数继承--------------
function DemoA() {
this.name = "CJ";
}
function DemoB() {  //要让DemoB继承DemoA
//构造函数A的prototype属性是一个对象
//这个对象具有的所有属性，A的实例也具有

}
DemoB.prototype = new DemoA;     //new DemoA  就相当于返回 {name:CJ}对象
// 这句代码一定要在下句代码的前面 不然就会出错  变成undefined
//这里千万不能写为new DemoA（），更加不能传参数 在特殊情况下可以  但是只能执行一次 也就是说只会实例一次
//就是只会传递参数给第一个DemoB   后面如果创建新的DemoB对象是不传递参数的
var d = new DemoB();
alert(d.name);

//---------------这里是有参数继承---------------
function DemoA(name,age) {
this.name = name;
this.age = age;
}
function DemoB(name,age) {  //要让DemoB继承DemoA
/*this.DemoA = DemoA;
this.DeemoA(name,age);*/
DemoA.call(this,name,age);     //简写的方式   就是为了可以参数继承
}
DemoB.prototype = new DemoA;
var d = new DemoB("cj",18);
alert(d.name);

var d2 = new DemoB("dghk",19);
alert(d2.name);

//------这里是为引出call的例子------
function fn(a,b) {
this.ver = 123;
}
var o = {};
fn.apply(o,[12,"b"])    //功能一样  只不过这里的参数是以数组传递的
fn.call(o,12,"b");        //call函数的一个方法，call（第一个参数为this指向的对象，。。。函数的参数）
//其实call的作用就是改变函数内this的指针
alert(o.ver);
</script>