封装是面向对象的基础，今天所要学习的匿名函数与闭包就是为了实现JS的面向对象封装。封装实现、封装变量，提高数据、系统安全性，封装正是面向对象的基础。

匿名函数

        即没有名字的函数，其创建方式为

                 function(){...}

        单独存在的匿名函数，无法运行，可通过赋值给变量调用或通过表达式自我执行来实现运行。

                  1.赋值给变量为一般的函数使用方式

                          var run = function(){

                                   return ‘方法运行中‘;

                          };

                          alert(run());

                  2.通过表达式自我执行

                          (function(arguments可选)

                          {

                                   alert(‘方法运行中‘);

                           })(arguments);

闭包

        在一个普通函数的内部，创建一个匿名函数，匿名函数可访问普通函数中的变量，进而实现类似于面向对象中封装的特性，这个匿名函数就叫做对应普通函数的闭包。闭包就是对外创建的接口，通过接口达到访问函数内部变量的效果。

        function run() {

                 var username = ‘Forrest‘;

                 return function () { //通过匿名函数返回 box()局部变量

                          return username;

                 };

        }

         //alert(username);                  //错误username is not defined

        alert(run()());

       特点：闭包中使用的局部变量会驻留在内存中，避免了使用全局变量造成的命名冲突等情况的发生。值得注意的是闭包中使用this关键字，指向的是window对象。

封装

        为了更好的安全性、数据保护，则需要对数据进行私有化的封装，而JS中没有块级作用域的概念（即出了{}的范围，仍可以访问声明的变量），但有了前面的基础，我们就可以达到像其他正规面向对象语言的封装效果。

         function user(){
             (function(){
                 for(i = 0; i<5; i++){
                     alert(i);
                 }
             })();
             alert(i);                          //此处无法访问变量i
         }
         //私有作用域代替全局变量
         (function(){
             var username= 'Forrest';
             alert(username);
        })();                                  //匿名函数执行完毕后，变量立即销毁

         //访问私有变量
         function User(){
             var username= Forrest;            //私有变量
	     function learn(){                 //私有函数
                 return '学习中';
             };

             //对外提供接口，间接访问内部成员
             this.userlearn = function(){
                 return username + learn();
             };
         }  
         var user = new User()
         alert(user.userlearn());

         //实现get()、set()
         function User(value){
             var user = value;
             this.getUser = function(){
                 return user;
             }
             this.setUser = function(value){
                 user = value;
             }
         }
         var user = new User('Forrest');
         alert(user.getUser());
         user.setUser('Li');
         alert(user.getUser());

         //静态私有变量
         (function(){
             var user = '';
             User = function(value){
                 user = value;
             };
             Box.prototype.getUser = function(){
                 return user;
             };
             Box.prototype.setUser = function(value){
                 user = valu;
             };
         })();

         
         //字面量方式的私有化
         function NormalUser(){}
         var user = function(){
             var user = 'Forrest';
             function learn(){
                 return user + '学习中...';
             };
             var nu = new NormalUser();
             nu.userlearn = function(){
                 return learn();
             };
             return nu;
         }();
         alert(user.userlearn());

中结：

         JS虽不是一门正统的面向对象的语言，但用它也能达到面向对象的封装、继承、多态等的效果，学习起来还是需要好好理解的，特别是对于使用JS不是特别多的人来说，只能等到以后的逐步应用来解决这一系列的问题，更进一步体会它在面向对象方面的应用。

JS学习笔记-OO疑问之封装,古老的榕树,5-wow.com