js高级语法

/**引用概念**/
function cite(){
  //多个变量可以引用同一个对象
  var obj   =new Object();
  var newObj=obj;
      //obj.oneproperty="true";
      newObj.oneproperty="true";
      alert("多个变量可以引用同一个对象:"+(newObj.oneproperty == obj.oneproperty));
  //修改对象，数据保持完整
  var array   =new Array("one","two");
  var newArray=array;
      array.push("three");
      newArray.push("four");
      alert("修改对象，数据保持完整:"+(array.length==newArray.length));
  //修改对象的引用,数据保持完整
  var arr   =new Array("one","two","three");
  var newArr=arr;
      newArr.push("four");
      alert("修改对象的引用,数据保持完整: "+(arr.length == newArr.length)); 
  //修改对象生成新的对象
  var str   ="test";
  var newStr=str;
      str  +="newtest";
      alert("修改对象生成新的对象: "+(str != newStr));     
}

/**作用域概念**/
var str="scope";

//全局范围下修改
if(true){
    str="update scope.";
}
//alert("全局范围下做修改，改变全局范围下的值: "+str);
//局部范围下修改
function  scope(){
    str="new scope.";
    alert("局部范围下做修改，改变全局范围下的值: "+window.str);
}

/**匿名函数**/
//创建匿名函数，则必须给出一个函数表达式而非函数的显式声明
//(function(){})();最常见到的;自执行的;
//(function(){}());自执行的;
//void function(){}(); 自执行的;
//!!function(){alert('yo');}()自执行的;
//+function(){alert('yo');}()自执行的;
(function (){
  var string="thanking for visiting.";
   window.οnlοad=function(){
       document.getElementById('bt2').οnclick=function(){
         alert(string);
       }
   };
})();

/**闭包概念**/
//函数内部的一个变量能够在函数外面被引用时，我们就称创建了一个闭包。
function closuer1(){
function  Person() {  
    var  id;  
    this .getId =  function () {  
        return  id;  
    }  
    this .setId =  function (newId) {  
        id = newId;  
    }  
}  
var  p =  new  Person();  
p.setId(1000);  
alert(p.getId()); // 1000   
alert(p.id); // undefined
}

function closuer2(){
 function a(){
      var i=0;
      function b(){
        alert(++i);
       }
      return b;
    }
    var c = a();
        c();
        c();
}

/**上下文对象**/
function context(){
   var obj={
          yes:function(){this.val=true;},
          no :function(){this.val=false;}
       };
   alert(obj.val);
   
   obj.yes();
   alert("obj val:"+obj.val);
   
   window.no=obj.no;
   window.no();
   alert("window val:"+window.val);
}

/**对象概念**/
function object(){
   //object 构建对象
   var obj=new Object();
       obj.name="obj";
       obj.click=function(){alert(this.name);}
       
       obj.click();    
   //{}/key-value构建对象
   var newObj={
         name:"new obj",
         click:function(){
           alert(this.name);
         }
       }
       newObj.click();
   //function构建对象
   function User(name){
      this.name=name;
      this.run =function(){alert(this.name+":run.");}
      //add privileged method
      this.sleep=function (){alert('privileged method----.'+age);}//privileged method      
      //添加私有方法、属性
      var age=112;
      function say(){alert("private method.----"+age);}//private method
      say();
   }
   //prototype添加公共方法、属性
   User.prototype.walk=function(){alert(this.name+":walk.");}
   User.prototype.sex ="man";
   
   //添加静态方法与属性
   User.sex='man';
   User.staticmethod=function(name){
      return new User(name);
   }
   
   //测试
   var me=new User("me");
       me.age=22;
       
       me.run();
       me.walk();
       me.say();
       alert(me.constructor==User);
   //基于已知对象的constructor构建对象
   var you=new me.constructor("you");
       you.walk();
       you.run();
       you.say();//未定义
}

/**重载、多态概念**/
function sendMessage(msg,obj){
 var arr=[];
 if(arguments.length!=0){//参数检查
   for(var i=0;i   alert(arr.length);
 }else if(typeof obj!="undefined"){//typeof类型检查
   alert("typeof类型检查:"+obj);
 }else if(obj.constructor==Object){ //constructor类型检查
   alert("constructor类型检查:"+obj);
 }else {
   alert("input error.");
 }
}
//sendMessage("hello world",{handleMsg:function(msg){alert(msg);}});

/**原型（单）式继承**/
function singleExtend(){
   function Person(){}
   Person.prototype={
     name:'wang',
     getName:function(){return this.name;}
   }
   
   function Man(name){
     this.name=name;
   }
   
   Man.prototype=new Person();//修改构造器原型对象指向另一个对象，但继承链的隐藏属性没有随之修改
   Man.prototype.constructor =Man;  
   
   var man=new Man();
       man.name='hang';
       alert(man.getName());
}

/**类式继承**/
function classExtend(){
    //辅助函数 定义
    Function.prototype.method = function( name,func ){
        this.prototype[name] = func;
         return this;    
    }
    
    //实现函数
    Function.method('inherits', function(parent){
        //记录我们目前所在父层次的级数
        var depth = 0;
        //继承父对象的方法
        var proto = this.prototype = new parent();
        
        //特权函数
        this.method('uber', function uber(name){
            var func;
            var ret;
            var v = parent.prototype;
            //如果我们已经在某个 'uber' 函数之内
            if(depth){
                for (var i=d; i>0;i+=1) {
                    v = v.constructor.prototype;
                };
                //从该prototype中或得函数
                func = v[name];
            }
            else{
                //从prototype获得要执行的函数
                func = prototype[name];
                
                //如果此函数属于当前的prototype
                if( func == this[name]){
                    //则改为调用父对象的prototype
                    func = v[name];
                }
            }
            //记录我们在继承堆栈中所在位置的级数
            depth += 1;
            
            //
            ret = func.apply(this,Array.prototype.slice.apply(arguments,[1]));
            
            //恢复继承堆栈
            depth -= 1;
            
            return ret;
        });
        return this;
    })
    //只继承父对象特定函数的函数
    Function.method('swiss',function(parent){
        for (var i=1; i            var name = arguments[i];
            //将此方法导入this对象的prototype
            this.prototype[name] = parent.prototype[name];
        };
        return this;
    })
        function Person( name ){
        this.name = name;
    }
    
    //实现的例子
    Person.method('getName', function(){
        return this.name;
    })
    
    function  User( name, password ){
        this.name = name;
        this.password = password; 
    }
    User.inherits( Person );
    
    //test
    var user=new User('hao');
        alert(user.getName());
}

/**apply 或 all 继承**/
function allOrapplyExtend(){
  function objCreator(name,val){
  this.iname=name;
  this.ival=val;
  this.getIval=function(){return this.ival;}
  }
  
  function B(name,val)
  {
  objCreator.apply(this, arguments);  
  // objCreator.call(this, name,val)
  this.pro=1;
  this.method=function(){}
  }
  
  var myobj=new B('myname',100);  //myobj继承了objCreator 和 B 函数内定义的属性和方法
      alert(myobj.getIval());
}

/**命名空间**/
function namespace(){
  var YAHOO={};
      YAHOO.util={};
      YAHOO.util.Event={
          addEventListener:function(){alert('use namespace add event success');}
      }
      YAHOO.util.Event.addEventListener();
}