问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
匿名闭包是很常用的代码隔离方式，声明匿名对象并立即执行。匿名函数中声明的变量和方法以及匿名函数本身不会污染到函数体外，同时匿名函数的调用形成一个闭包，使函数体内可以使用函数体外声明的变量和方法。
(function () {
// ... all vars and functions are in this scope only
// still maintains access to all globals
今天看了一个文章
这个立即执行函数 和闭包有什么关系呢
是立即执行函数中包含一个全局作用域中的一个函数的引用
所以就形成了闭包么？这么理解对么还是说文中的解释 是错误的？
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
匿名函数和闭包没有直接关系。能用匿名函数实现闭包的地方，一定也能用命名函数实现。
闭包的本质在于“闭”和“包”，即把一些变量封闭起来，使其它程序访问不到，同时把这个封闭的东西打成包甩出来，让大家可以直接用这个包（函数）。最典型的实现之一是对象（或类）的私有成员，如
function MyClass() {
// 这是一个封闭在 MyClass 中的局部变量
// 这是一个甩出来的“包”
this.getName = function() {
// 这是另一个甩出来的“包”
this.setName = function(name) {
// 这保证了 _name 的第一个字母和空格后的第一个字母是大写
// 而且因为闭包的原因，_name 不可能被 MyCLass() 外的程序访问到
// 也就保证了上述命名规则的无例外执行
_name = name.replace(/^.|\s./g, function(s) {
return s.toUpperCase();
var p = new MyClass();
p.setName("james fancy");
console.log(p.getName());
// James Fancy
匿名函数通常只是用于给成员赋值，比如上例中的 getName 和 setName；也有可能用于立即执行函数，比如你的那段代码，这会将全局变量局部化，避免全局污染。
闭包常常会和匿名函数一起使用，但他们之间并没有密不可分的关系。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
立即执行函数只是函数的一种调用方式，和闭包没有必然的联系
(function(){
可以拆解为
function a(){
闭包是对函数中变量作用域的构成方式的一种表述，具体表现为一个函数中可以访问不在其作用域范围内但在其外层函数作用域中存在的变量，这个外层函数作用域的顶层为全局作用域
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
需要注意的一点是：闭包不等于匿名函数。创建闭包的方式通常是在一个函数的内部创建另一个函数。创建闭包的目的是通过返回函数来扩大函数的作用域。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
IIFE主要目的是做的一些封装，防止污染，以及保证内部变量的安全
闭包严格来说，是一个函数执行之后，返回另外一个函数，返回的函数有前一个函数的内部变量的引用
可能会用在IIFE里面，通过返回的函数来提供内部变量的一些操作
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
匿名函数从字面理解就是没有命名的函数，如：
function() {
立即执行函数是指声明完之后便直接执行的函数，因此通常这类函数也不需要命名，如：
(function() {
闭包通常指在函数内部再定义一个函数，由于作用域的关系，外部函数无法访问内部函数的变量，而内部函数可以访问外部函数的变量，此时如果外部函数将内部函数返回，便形成了闭包，如：
function outer() {
var prop = 'outer';
function inner() {
console.log(prop); // outer
所以，也可以把任何函数理解为一个闭包，因为每个函数都可以访问外部函数或者全局的变量，但是外部函数或全局无法访问函数内部的变量，也就可以理解为是一个闭包。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
没什么关系，大多写库或框架的时候为了避免全局冲突会使用闭包，为了库或函数的功能加载后就可以使用就使用立即执行的方式将库注册到全局。
同步到新浪微博
分享到微博？
Hi，欢迎来到 SegmentFault 技术社区！⊙▽⊙ 在这里，你可以提出编程相关的疑惑，关注感兴趣的问题，对认可的回答投赞同票；大家会帮你解决编程的问题，和你探讨技术更新，为你的回答投上赞同票。
明天提醒我
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：人气：170752
访问用户量：130
笔记经验：
总积分：2667
级别：VIP1
搜索本笔记
ta的交流分类
ta的全部笔记
浏览(2849)|(0)
&&交流分类：|笔记分类:
匿名函数就是没有名字的函数，闭包是可访问一个函数作用域里变量的函数。一．匿名函数function box() {&&&&&&&& //普通函数函数名是box&&& return 'Lee';}function () {&&&&&&&&&&& //匿名函数，会报错&&& return 'Lee';}var box = function () {& //将匿名函数赋给变量&&& return 'Lee';};(function() {&&&&&&&&&&& //封装成表达式,通过表达式自我执行&&& alert('Lee');})();&&&&&&&&&&&&&&&&&&& //()表示执行函数，并且传参var b = function() {&&&&& &&&& alert('Lee');}(); function box () {&&& return function () { //函数里的匿名函数，产生闭包&&&&&&&& return 'Lee';&&& }}alert(box()());&&&&&&&&& //调用匿名函数var b = box();alert(b());二．闭包闭包是指有权访问另一个函数作用域中的变量的函数，创建闭包的常见的方式，就是在一个函数内部创建另一个函数，通过另一个函数访问这个函数的局部变量。//通过闭包可以返回局部变量function box() {&&& var user = 'Lee';&&& return function () { //通过匿名函数返回box()局部变量&&&&&&&&&& };}alert(box()()); //通过box()()来直接调用匿名函数返回值var b = box();alert(b());&&&& //另一种调用匿名函数返回值使用闭包有一个优点，也是它的缺点：就是可以把局部变量驻留在内存中，可以避免使用全局变量。(全局变量污染导致应用程序不可预测性，每个模块都可调用必将引来灾难，所以推荐使用私有的，封装的局部变量)。//通过全局变量来累加var age = 100;& //全局变量function box() {&&& age ++;&&&& //模块级可以调用全局变量，进行累加}box();&&&&&&&&& //执行函数，累加了alert(age);&&&& //输出全局变量//通过局部变量无法实现累加function box() {&&& var age = 100;&&& age ++;&&&& //累加&&&}alert(box()); //101alert(box()); //101，无法实现，因为又被初始化了//通过闭包可以实现局部变量的累加function box() {&&& var age = 100;&&& return function () {&&&&&& age ++;&&&&&&&&& }}var b = box();&& //获得函数alert(b());&&&&& //调用匿名函数alert(b());&&&&& //第二次调用匿名函数，实现累加PS：由于闭包里作用域返回的局部变量资源不会被立刻销毁回收，所以可能会占用更多的内存。过度使用闭包会导致性能下降，建议在非常有必要的时候才使用闭包。作用域链的机制导致一个问题，在循环中里的匿名函数取得的任何变量都是最后一个值。//循环里包含匿名函数function box() {&&& var arr = [];&&& for (var i = 0; i & 5; i++) {&&&&&&& arr[i] = function () {&&&&&&&&&&&&&&&&&& };&&& }&&&}var b = box();&&&&&& //得到函数数组alert(b.length);&&&& //得到函数集合长度for (var i = 0; i & b. i++) {&& alert(b[i]());&&& //输出每个函数的值，都是最后一个值}上面的例子输出的结果都是5，也就是循环后得到的最大的i值。因为b[i]调用的是匿名函数，匿名函数并没有自我执行，等到调用的时候，box()已执行完毕，i早已变成5，所以最终的结果就是5个5。//循环里包含匿名函数-改1，自我执行匿名函数function box() {&&& var arr = [];&&& for (var i = 0; i & 5; i++) {&&&&&& arr[i] = (function (num) { //自我执行&&&&&&&&&&&&&&&& })(i);&&&&&&&&&&&&&&&&&&&& //并且传参&&& }&&&}var b = box();for (var i = 0; i & b. i++) {&&& alert(b[i]);&&&&&&& //这里返回的是数组，直接打印即可}改1 中，我们让匿名函数进行自我执行，导致最终返回给a[i]的是数组而不是函数了。最终导致b[0]-b[4]中保留了0,1,2,3,4 的值。//循环里包含匿名函数-改2，匿名函数下再做个匿名函数function box() {&&& var arr = [];&&& for (var i = 0; i & 5; i++) {&&&&&&& arr[i] = (function (num) {&&&&&&&&&&&&&&&&&&&& //把num想象成在这&&&&&&&&&&&&&&&&&&&& return function () { //直接返回值，改2 变成返回函数&&&&&&&&&&&&&&&&&&&&&&&& //原理和改1 一样&&&&&&&&&&&&&&&&&&&& }})(i);&&& }&&&}var b = box();for (var i = 0; i & b. i++) {&&& alert(b[i]()); //这里通过b[i]()函数调用即可}改1 和改2 中，我们通过匿名函数自我执行，立即把结果赋值给a[i]。每一个i，是调用方通过按值传递的，所以最终返回的都是指定的递增的i。而不是box()函数里的i。关于this 对象在闭包中使用this 对象也可能会导致一些问题，this 对象是在运行时基于函数的执行环境绑定的，如果this 在全局范围就是window，如果在对象内部就指向这个对象。而闭包却在运行时指向window 的，因为闭包并不属于这个对象的属性或方法。var user = 'The Window';var obj = {&&& user : 'The Object',&&& getUserFunction : function () {&&&&&&&& return function () { //闭包不属于obj，里面的this 指向window&&&&&&&&&&&& return this.&&&&&&&& };&&& }};alert(obj.getUserFunction()());&&&&&&&& //The window//可以强制指向某个对象alert(obj.getUserFunction().call(obj)); //The Object//也可以从上一个作用域中得到对象getUserFunction : function () {&&& var that = //从对象的方法里得对象&&& return function () {&&&&&& return that.&&& };}内存泄漏由于IE 的JScript对象和DOM 对象使用不同的垃圾收集方式，因此闭包在IE 中会导致一些问题。就是内存泄漏的问题，也就是无法销毁驻留在内存中的元素。function box() {&&& var oDiv = document.getElementById('oDiv'); //oDiv 用完之后一直驻留在内存 &&& oDiv.onclick = function () {&&&&&&& alert(oDiv.innerHTML); //这里用oDiv 导致内存泄漏&&& };}box();那么在最后应该将oDiv 解除引用来避免内存泄漏。function box() {&&& var oDiv = document.getElementById('oDiv');&&& var text = oDiv.innerHTML;&&& oDiv.onclick = function () {&&&&&&& alert(text);&&& };&&& oDiv = //解除引用}PS：如果并没有使用解除引用，那么需要等到浏览器关闭才得以释放。模仿块级作用域JavaScript 没有块级作用域的概念。function box(count) {&&& for (var i=0; i& i++) {}&&& alert(i); //i 不会因为离开了for 块就失效}box(2);function box(count) {&&& for (var i=0; i& i++) {}&&& //就算重新声明，也不会前面的值&&& alert(i);}box(2);以上两个例子，说明JavaScript 没有块级语句的作用域，if () {} for () {}等没有作用域，如果有，出了这个范围i 就应该被销毁了。就算重新声明同一个变量也不会改变它的值。JavaScript 不会提醒你是否多次声明了同一个变量；遇到这种情况，它只会对后续的声明视而不见(如果初始化了，当然还会执行的)。使用模仿块级作用域可避免这个问题。//模仿块级作用域(私有作用域)(function () {//这里是块级作用域})();//使用块级作用域(私有作用域)改写function box(count) {&&& (function () {&&&&&&& for (var i = 0; i& i++) {}&&& })();&&& alert(i); //报错，无法访问}box(2);使用了块级作用域(私有作用域)后，匿名函数中定义的任何变量，都会在执行结束时被销毁。这种技术经常在全局作用域中被用在函数外部，从而限制向全局作用域中添加过多的变量和函数。一般来说，我们都应该尽可能少向全局作用域中添加变量和函数。在大型项目中，多人开发的时候，过多的全局变量和函数很容易导致命名冲突，引起灾难性的后果。如果采用块级作用域(私有作用域)，每个开发者既可以使用自己的变量，又不必担心搞乱全局作用域。(function () {&&& var box = [1,2,3,4];&&& alert(box); //box 出来就不认识了})();在全局作用域中使用块级作用域可以减少闭包占用的内存问题，因为没有指向匿名函数的引用。只要函数执行完毕，就可以立即销毁其作用域链了。私有变量JavaScript 没有私有属性的概念；所有的对象属性都是公有的。不过，却有一个私有变量的概念。任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。function box() {&&& var age = 100; //私有变量，外部无法访问}而通过函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量。而利用这一点，可以创建用于访问私有变量的公有方法。function Box() {&&& var age = 100;&&&&&&&&&& //私有变量&&& function run() {&&&&&&&& //私有函数&&&&&&& return '运行中...';&&& }&&& this.get = function () { //对外公共的特权方法&&&&&&& return age + run();&&& };}var box = new Box();alert(box.get());可以通过构造方法传参来访问私有变量。function Person(value) {&&& var user = //这句其实可以省略&&& this.getUser = function () {&&&&&&&&&& };&&& this.setUser = function (value) {&&&&&& user =&&& };}但是对象的方法，在多次调用的时候，会多次创建。可以使用静态私有变量来避免这个问题。静态私有变量通过块级作用域(私有作用域)中定义私有变量或函数，同样可以创建对外公共的特权方法。(function () {&&& var age = 100;&&& function run() {&&&&&&& return '运行中...';&&& }&&& Box = function () {};&&&&&&&&&&&&&& //构造方法&&& Box.prototype.go = function () {&&& //原型方法&&&&&&& return age + run();&&& };})();var box = new Box();alert(box.go());上面的对象声明，采用的是Box = function () {} 而不是function Box() {} 因为如果用后面这种，就变成私有函数了，无法在全局访问到了，所以使用了前面这种。(function () {&&& var user = '';&&& Person = function (value) {&&&&&&& user =&&& };&&& Person.prototype.getUser = function () {&&&&&&&&&& };&&& Person.prototype.setUser = function (value) {&&&&&& user =&&& }})();使用了prototype 导致方法共享了，而user 也就变成静态属性了。(所谓静态属性，即共享于不同对象中的属性)。模块模式之前采用的都是构造函数的方式来创建私有变量和特权方法。那么对象字面量方式就采用模块模式来创建。var box = {&&&&&&&&&&&&&& //字面量对象，也是单例对象&&& age : 100,&&&&&&&&&&& //这是公有属性，将要改成私有&&& run : function () {&& //这时公有函数，将要改成私有&&&&&&& return '运行中...';&&& };};私有化变量和函数：var box = function () {&&& var age = 100;&&& function run() {&&&&&& return '运行中...';&&& }&&& return { //直接返回对象&&&&&&& go : function () {&&&&&&&&&&& return age + run();&&&&&&& }&&& };}();上面的直接返回对象的例子，也可以这么写：var box = function () {&&& var age = 100;&&& function run() {&&&&&&& return '运行中...';&&& }&&& var obj = { //创建字面量对象&&&&&&& go : function () {&&&&&&&&&&& return age + run();&&&&&&& }&&& };&&& //返回这个对象}();字面量的对象声明，其实在设计模式中可以看作是一种单例模式，所谓单例模式，就是永远保持对象的一个实例。增强的模块模式，这种模式适合返回自定义对象，也就是构造函数。function Desk() {};&&& var box = function () {&&& var age = 100;&&& function run() {&&&&&& return '运行中...';&&& }&&& var desk = new Desk(); //可以实例化特定的对象&&& desk.go = function () {&&&&&&& return age + run();&&& };&&&}();alert(box.go());
相关笔记推荐
精品视频课程推荐
内容概述：Shiro是目前最热门、最易用、功能超强大的Java权限管理框架，强烈推荐，每个项目都必备的权限管理技术！通过本课程，你将从零开始直到彻底掌握Shiro的相关开发知识，达到可以进行实际项目开发的能力。包括：权限管理基础、Shiro入门、配置、身份认证、授权、Realms、Session管理、和Spring的集成、Web、Cache等众多开发细节技术
技术要点：源码级分析Shiro的授权过程、自定义开发Realm、多个Realms的开发配置、自定义开发AuthenticationStrategy、自定义开发自定义SessionDAO、和Struts2+Spring3的集成（包括修正struts2的bug）、Shiro和SpringMVC+Spring3的集成、包装使用其他的Cache框架、缓存数据同步更新的解决方案等等实际开发中常用的内容
本课程是《软件系统功能设计实战训练》网络班的全套学习视频，通过6个具体的设计案例，综合应用几乎全部的GoF设计模式，以及多种设计理念和方法。
每个设计案例都各有侧重点，训练的难度会逐步加大，以切实帮助各位学员快速的掌握软件系统设计的方法，提升自己的软件系统设计能力。
数据校验、Javascript模拟多线程、下拉列表联动、操作XML、AJAX结合JSON的操作、Json-lib的使用
创建规范的XML文档，DTD的作用，并且可以根据要求创建私用的DTD，通过JavaScript解析XML DOM
浏览(2849)|(0)
&&交流分类：|笔记分类:
版权所有 Copyright(C) 私塾在线学习网为什么javascript中匿名自执行函数可以算作闭包？ - 知乎1被浏览439分享邀请回答11 条评论分享收藏感谢收起0添加评论分享收藏感谢收起用户名：jch_zhao
文章数：96
访问量：11928
注册日期：
阅读量：1297
阅读量：3317
阅读量：580906
阅读量：464503
51CTO推荐博文
提到闭包总给人很高深的感觉，网上的例子也数不胜数。但是我发现相当一部分并不容易理解。根据我的观察，是因为这些例子把标题中提到的概念糅杂在了一起，往往越看越糊涂。所以我希望化整为零，拆成简单例子来解释。1.先看作用域：JavaScript作用域只有两种――全局作用域和函数内作用域，没有代码块作用域。示例：function loop(){for(var i=0;i&5;i++){//doS}alert(i);&}loop(); //执行函数结果为5。尽管变量i已经脱离了循环代码块，但因为JavaScript没有代码块级作用域，所以i的作用域是在整个函数内。循环结束后仍然保持为5。当然作为局部变量，函数执行完毕就释放了。全局作用域就好理解了。变量在整个页面的执行环境下都有效。定义的方法有两种：一是在所有函数外定义的变量即为全局变量；二是定义变量时不加var，此时被认为是全局变量。例如：&script&var i=10; //全局变量function f1(){times=3; //全局变量}&/script&2.上下文环境与"this"上下文环境说的是对象（函数）的“继承关系”，而非函数之间的调用关系。函数间的互调用并不改变上下文环境，体现函数间互调用有另外一个变量caller表示。示例：function a(){b();}function b(){alert(this);//被别的函数调用不改变上下文环境，仍然指向window。}a();体现函数互调用关系的是caller：function a(){b();}function b(){alert(b.caller);}a();通过this可以很好的观察某个对象（函数）的上下文环境，在传统语言里this不难理解，指的是对象本身。在JavaScript中，函数也是个对象。如果此函数是个独立执行的函数，那么this就意味着最外层的上下文环境，也即window；如果函数定义为某个对象的属性，那么它的上下文环境就指向了这个对象。示例：function a(){alert(this.name);}var obj1={name:"I am obj1",method:a &//属性是一个函数}obj1.method(); &//函数对象的上下文是obj1此外使用关键字call、apply可以显式改变函数的上下文环境例如：function a(){alert(this.name);}var obj1={name:"I am obj1",}a.call(obj1); &//函数的上下文是obj13.函数对象的定义和调用这个本来不值一提，定义是定义，调用是调用――――调用是加"()"。但是我经常看走眼，年纪大了老眼昏花。但也确实有不太好分辨的时候。比如这样：var foo=function outer(){return function inner(){alert(this);};}();foo();这个例子中，foo是outer的执行结果。outer的执行结果返回的还是一个函数，所以foo也还是一个函数（其实就是inner啦，但此时并没有执行inner）。那么再执行foo的时候，上下文其实是window，自然也返回window。4.匿名函数匿名函数因为没有被哪个变量“记住”，所以只能定义完立即执行，通常执行的上下文是window。比如这样：(function(){alert(this);})()更复杂一点的：(function outter(){return function inner(){alert(this);};})()(); &//此处和3小节的代码效果是一模一样的5.闭包指的是有权访问另一个函数作用域中的变量的函数。很多开发人员混淆闭包和匿名函数――书上说的。这是因为闭包时常是以匿名函数形式来实现的，但其实二者无关。匿名函数可以单独执行，如4小节示例；闭包也可以由非匿名函数实现，例如：function fout(){var n=123;return function fin(){alert(n); //123}}var f=fout();f(); &//fin访问了fout中的变量，所以尽管fout已执行完毕，但局部变量n仍被保留，从而形成闭包。当然改成匿名函数也并非难事：function fout(){var n=123;return function(){alert(n); //123}}var f=fout();f();总之，JavaScript是一门很有特色的语言。参考我的另一篇本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)学习javascript的闭包,原型,和匿名函数之旅
作者：bondage
字体：[ ] 类型：转载 时间：
Javascript中有几个非常重要的语言特性——对象、原型继承、闭包。其中闭包 对于那些使用传统静态语言C/C++的程序员来说是一个新的语言特性，本文给大家介绍js的闭包,原型,和匿名函数之旅，感兴趣的朋友一起学习吧
本文通过示例给大家介绍javascript的闭包,原型,和匿名函数，具体详情请看下文。
一 .&关于闭包
理解闭包 需要的知识
1.变量的作用域
var n =99; //建立函数外的全局变量
function readA(){
alert(n); //读取全局变量
readA(); //执行此函数
function readB(){
var c = 9;
function readC(){
console.log(c); //ok c可见
return readC;
alert(c); //error c is not defined.
&&& note:& 函数内部声明变量c时,一定要加上 var,否则 c会成为一个全局变量
所以函数内可见全局变量,函数内的局部变量却对外不可见
js的作用域是链式的,父对象里的变量总对子对象可见,子对象的对象却对父对象不可见
当我们要获取函数内的内部变量
于是有了例3:
function readB(){
var c = 9;
function readC(){
console.log(c);
return readC();
闭包很类似基于此做了一个变式
function readB(){
var c = 9;
function readC(){
console.log(c);
return readC;
var res = readB();
1.慎用闭包,注意内存占用,因为它会保存父函数的状态
2.不要随便改变父函数内部变量的值
&& note: this 指包含它的函数被执行时所属的对象
var name = "The Window";
var object = {
name : "My Object",
　　getNameFunc : function(){
//此时this (这个执行函数)是属于object对象的,是object对象下的一个属性的值
return function(){
//此时this (这个执行函数)是一个匿名函数,从根对象window生成,是属于window
return this.
　　　　};
console.log(object.getNameFunc()()); //the window
var name = "The Window";
var object = {
name : "My Object",
getNameFunc : function(){
var that =
　　return function(){
return that.
console.log(object.getNameFunc()());
//My Object
二 .&匿名函数
直接定义一个匿名函数 然后调用这个匿名函数,这种形式在jquery插件的定义时很常见
1.通过函数字母量的方式. 先声明一个匿名函数,然后执行它
( function(){
console.log('excute self');
2.通过优先表达式的方式 , 由于Javascript执行表达式是从圆括号里面到外面，所以可以用圆括号强制执行声明的函数
function () {
3.void操作符 用void操作符去执行一个没有用圆括号包围的一个单独操作数
void function(){ console.log('void') } ();
三 .&关于prototype
原型 prototype
理解js中的protitype首先需要明白js的面向对象设计
function People(name){
this.name =
console.log(this); //Window 或者 object { name: 'xxx' }
this.introduce = function(){
//实例对象方法
console.log(this.name);
new People('leon').introduce();
//这里有一个非常有趣的现象,结合前面的来看的话,
//首先function people里的this指向的默认是Window对象
//当 调用 People();时 this 输出为 Window对象
//但一旦调用new People('xx')时, this 输出为 {name:'xx'}
//其实也很好理解,一旦new ,便新建了一个对象
实例对象方法只能这样 new People('leon').introduce(); 调用 因为它使用前必须初始化
类的对象的静态方法
var People = {}; //等于一个对象 {} 或者 function 数组都可以 此时People需要是引用类型
People.sayhi = function(to_who){
console.log('hi '+ to_who);
People.sayhi('lee'); //调用时这样调用
var People = function(){};
// People 必须为一个 function(){} 即为一个类,不能是对象或值类型或其他引用类型
People.prototype.meet = function(meet_who) {
console.log('I am '+this.name + ',going to meet ' + meet_who);
new People('lee').meet('xx');
原型方法只能由该类的对象 调用
&A.prototype = new B();
原型看起来很像继承,但其实不是,它更像clone更准确
如果出现了父类和子类出现了重名的属性,采取就近原则,如果找不到一级一级向上找,如果要指定调用上级的属性,使用call方法
extendClass.prototype = new baseClass();
var instance = new extendClass();
var baseinstance = new baseClass();
baseinstance.showMsg.call(instance);
obj1.func.call(obj);
以上内容是小编给大家分享的学习javascript的闭包,原型,和匿名函数之旅，希望对大家有用。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具}