𝕏
0%

发表于 更新于 分类于

Define an interface for creating an object, but let subclasses decide which class to instantiate. The Factory method lets a class defer instantiation it uses to subclasses.

(Gang Of Four)

“工厂模式”：通过接口的方式__间接__调用（那些）类来创建对象；该接口通常用函数、类或类的静态方法来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
'''
Python示例代码，来自网络
'''
from abc import ABCMeta, abstractmethod
from enum import Enum

class Person:
    __metaclass__ = ABCMeta

    @abstractmethod
    def get_name(self):
        raise NotImplementedError("You should implement this!")

class Villager(Person):
    def get_name(self):
        return "Village Person"

class CityPerson(Person):
    def get_name(self):
        return "City Person"

class PersonType(Enum):
    RURAL = 1
    URBAN = 2

class Factory(object):
    def get_person(self, person_type):
        if person_type == PersonType.RURAL:
            return Villager()
        elif person_type == PersonType.URBAN:
            return CityPerson()
        else:
            raise NotImplementedError("Unknown person type.")

factory = Factory()
person = factory.get_person(PersonType.URBAN)
print(person.get_name())

发表于 更新于 分类于 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
function Klass(Parent, props) {
  var Child, F, i;

  // 新构造函数
  Child = function(){
    if (Child.uber && Child.uber.hasOwnProperty('__construct')) {
      Child.uber.__construct.apply(this, arguments);
    }

    if (Child.prototype.hasOwnProperty('__construct')) {
      Child.prototype.__construct.apply(this, arguments);
    }
  };

  // 继承
  Parent = Parent || Object;
  F = function(){};
  F.prototype = Parent.prototype;
  Child.prototype = new F();
  Child.uber = Parent.Prototype;
  Child.prototype.constructor = Child;

  // 添加实现方法
  for (i in props) {
    if (props.hasOwnProperty(i)){
      Child.prototype[i] = props[i];
    }
  }

  return Child;
}

发表于 更新于 分类于

什么是闭包？

多么犀利的一个问题呀，不知秒杀了多少FEers。对于这个问题的回答是仁者见仁智者见智，这主要取决于每个人的知识层面。下面列举了一些比较权威的解答：

在计算机科学中，闭包（Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。运行时，一旦外部的函数被执行，一个闭包就形成了，闭包中包含了内部函数的代码，以及所需外部函数中的变量的引用。其中所引用的变量称作上值(upvalue)。

阅读全文 »

发表于 更新于 分类于

shell是与liunx内核交互的工具，它可以类比成node、python…，就是一个解释器。它提供了两种使用方式。REPL：即直接在终端中运行命令并输出命令运行的结果，命令可以理解成函数，函数会有参数所以命令也有参数；脚本文件：即写成脚本文件，用解释器直接执行脚本中的代码，这个脚本就是常说的shell脚本。

发表于 更新于 分类于

Python字符串格式化有两种实现方式：字符串格式化表达式，字符串格式化方法（函数）。
1、字符串格式化表达式
%[(name)][flag][width][.precision]typecode
2、字符串格式化方法
{filename!conversionflag:formatspec}
formatspec格式:[[fill]align][sign][#][0][width][.precision][typecode]

发表于 更新于 分类于

定义

程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

概括来讲就是函数直接或间接的调用自身的编程方式称为递归；同时递归的构成需要有边界条件、递归前进段和递归返回段。

阅读全文 »

发表于 更新于 分类于 
1
2
3
4
5
6
7
8
9
Array.prototype.unique = function() {
  var a = [], l = this.length;
  for(var i=0; i<l; i++) {
    for(var j=i+1; j<l; j++)
          if (this[i] === this[j]) j = ++i;
    a.push(this[i]);
  }
  return a;
};

以上代码引自国外博文，阅读起来甚是烧脑；需注意的是我们平时运用for循环多是引用下标值而很少去修改它，上述代码修改了下标值改变了循环流程。