闭包

发表于 | 更新于 | 分类于 | 评论数：

闭包

函数A返回了函数B,并且函数B使用了函数A的变量，函数B就成为闭包。

1
2
3
4
5
6
7
function A(){
    let a = 1;
    function B(){
        console.log(a);
    }
    return B();
}

为什么函数A已经调用出栈了，为什么函数B还能引用到函数A中的变量。是否和我有相同的疑问？因为函数A中的变量这时候是存储在堆上的，现在的js引擎可以通过逃逸分析辨别出那些变量需要存储在堆上，哪些需要存储在栈上。

经典面试题：

用栈实现队列

发表于 | 更新于 | 分类于 | 评论数：

先上代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function Quene() {
  var stack1 = [],
    stack2 = []
  this.push = function(node) {
    stack1.push(node)
  }

  this.pop = function() {
    if (stack2.length == 0) {
      if (stack1.length == 0) {
        return null
      } else {
        var len = stack1.length
        for (var i = 0; i < len; i++) {
          stack2.push(stack1.pop())
        }
        return stack2.pop()
      }
    } else {
      return stack2.pop()
    }
  }
}

栈有入栈和出栈，实现队列就是将两个栈，通过栈顶和另一个的栈底相连，然后一个栈一直执行入栈，另一个一直执行出栈就可以了。

使用js实现单例模式

发表于 | 更新于 | 评论数：

先上代码：惰性单例的精髓！！！

1
2
3
4
5
6
7
8
9
//单例模式抽象，分离创建对象的函数和判断对象是否已经创建
// func 构造函数
// arguments 参数
var getSingle = function(func,arguments){
    var result;
    return function(arguments){
        return result || (result = func.apply(this, arguments));
    }
}

形参fn是我们的构造函数，我们只要传入任何自己需要的构造函数，就能生成一个新的惰性单例。
比如说传入创建一个女朋友的构造函数，并且调用getSingle(),就能生成一个新的女朋友。如果以后再调getSingle(),也只会返回刚才创建的那个女朋友。至于新女朋友——不存在的。