javascript闭包2

Js闭包简介
Javascript变量作用范围
<script> var property1; function function1() { var property2; this.function2=function() { var property3; } } <script> window对象 function1对象 function2对象 property3 property2 function2()
function Child(name,age) { Parent.call(this, name); call方法的第一个参数的值赋值给类(即方法)中出现的this call方法的第二个参数开始依次赋值给类(即方法)所接受的参数 this.Cmethod = function () { console.log(name + "年龄" + age); } }
//实例化 var parent = new Parent(); var child = new Child(20); parent.Pmethod("父亲"); child.Pmethod("孩子"); child.Cmethod();
面向对象-多态
向对象语言的多态一般都由方法重载和虚方法来实现多态。由于Javascript是弱类型的语言， 解释器无法通过参数类型和参数个数来区分不同的重载方法。
javascript闭包
胡龙
目录
1. js闭包简介
2. 闭包与javascript模块编程
3. 面向对象 4. Js闭包优缺点
Js闭包简介
闭包：是指有权访问另一个函数作用域中的变量的函数，创建闭包的最 常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这 个函数的局部变量。
<script> function function1() { var property; this.function2=function() {} } <script>
JS闭包占用内存问题
闭包的缺点就是常驻内存，会增大内存使用量，使用不当很容易造成内存泄露。 解决方法：手动释放内存
function classA() { this.method = function () { console.log("this is the method of classA."); } } //占用内存 var ca = new classA(); var cb = new classA(); var cc = new classA(); //释放内存 ca = null; cb = null; cc = null;
this.mathed=function() { console.log(name + "今年" + agParent(Pname) { this.Pmathed = function () { console.log(Pname); } }
function Child(name,age) { this.method = Parent; //第一步：this.method是作为一个临时的属性，并且指向Parent所指向的对象， this.method(name); //第二步：执行this.method方法，即执行Parent所指向的对象函数 delete this.mnethod; //第三步：销毁this.method属性，即此时Child就已经拥有了Parent的所有属性和方法 this.Cmethod = function () { console.log(name + "年龄" + age); } }
Javascript只能模拟多态。
1. 参数类型判断 2. 参数个数判断
多态：参数类型
var MyClass = function () { var AddNum = function (a, b) { return a + b; } var AddString = function (a, b) { return a + "年龄是" + b; } this.Add = function (a, b) { //根据参数类型判断 if (typeof (a) == "number") return AddNum(a, b); else return AddString(a, b); } }
继承：call()方法
function Parent(Pname) { this.Pmethod=function() { console.log(Pname); } }
//实例化 var parent = new Parent("父亲"); var child = new Child("孩子",20); parent.Pmathed(); child.Pmathed(); child.Cmathed();
面向对象
面向对象-封装
function classA()//定义classA类 { var name = "小明"; var age = 20; var getstring = new classA(); //使用mathed方法 getstring.mathed(); //使用name属性 if () { console.log(name); } else { console.log("name is undifine"); } //使用age属性 if (getstring.age) { console.log(age) } else { console.log("age is undifine");}
1. 对象冒充 2. call()方法方式
3. 原型链方式
4. apply()方法方式
继承：对象冒充
function Parent(Pname) { this.Pmethod=function() { console.log(Pname); } } //实例化 var pmethod = new Parent("父亲"); pmathed.Pmethod(); var mymethod = new Child("孩子",20); mymathed.Pmethod(); mymathed.Cmethod();
property1 function1()
闭包与js模块化编程
① 安全性：JavaScript 被模块化只留下供外界调用的接口。
② 效率高：各模块耦合性低，结构清晰，可读性强，提高开发效率。
③ 易维护：需求变动时，只需修改局部模块，降低维护难度及维护成本。 ④ 易扩展：高内聚、低耦合的系统结构，使系统更灵活、更容易扩展。
//实例化 var MyObj = new MyClass(); console.log(MyObj.Add(5, 6)); console.log(MyObj.Add("小明", 20));
多态：参数个数
function add() { var sum = 0; //判断参数个数 var num= arguments.length； for (var i = 0 ; i <num; i++) { sum += arguments[i]; } return sum; } //实例化 console.log(add(1)); console.log(add(1, 2)); console.log(add(1, 2, 3));
继承：原型链方法
function Parent() { this.Pmethod = function (Pname) { console.log(Pname); } } function Child( age) { this.Cmethod = function () { console.log(name + "年龄" + age); } } Child.prototype = new Parent(); //子类通过prototype将所有在父类中通过 prototype追加的属性和方法都追加到Child， 从而实现了继承