segmentfault 看到一篇文章,讲 API 设计美学的文章,看到一点觉得很不错,虽然也知道应该这么做,但是一个例子胜千言啊,所以将这个内容搬过来,也加深自己的理解。感谢。

这一点就是函数的可扩展性

可扩展性,就是建议遵守开放-封闭原则。对扩展开放,对修改关闭。比如jQuery的$.fn和$.fn.extend()。

说一个简单的例子-计算加薪额度

var addMoney = (function () {
    //定义策略类
    var strategies = {
        A:function(money){
            return money + 2000;
        },
        B:function(money){
            return money + 1000;
        }
    };
    //暴露接口
    return {
        //根据等级和现工资,输入加薪后的工资
        compute:function(lv,money){
            return strategies[lv](money)
        }
    };
})();

//比如:等级为A,5000+2000
console.log(addMoney.compute('A',5000))//7000
//比如:等级为B,20000+1000
console.log(addMoney.compute('B',20000))//21000
代码看着没有问题,但是如果以后需求要增加C等级呢?这就不得不修改strategies。在里面增加方法。
如下

var strategies = {
    A:function(money){
        return money + 2000;
    },
    B:function(money){
        return money + 1000;
    },
    C:function(money){
        return money + 500;
    }
};

这样实现也简单,如果以后要增加S等级呢?又得改strategies。这里还有一个问题就是,如果增加的C等级只有在A模块需要用到,在B模块不会出现,那么在B模块引用addMoney的时候,又会把C等级的计算方式也引入进去,造成不必要的资源浪费。
建议的方式是,设置一个接口,扩展strategies。

var addMoney = (function () {
    //定义策略类
    let strategies = {
        A:function(money){
            return money + 2000;
        },
        B:function(money){
            return money + 1000;
        }
    };
    //暴露接口
    return {
        //根据等级和现工资,输入加薪后的工资
        compute:function(lv,money){
            return strategies[lv](money)
        },
        //扩展等级
        addRule:function(lv,fn){
            strategies[lv]=fn;
        }
    };
})();

//增加C等级的调用

addMoney.addRule('C',function(money){
    return money + 500;
});
console.log(addMoney.compute('C',20000))//20500

今天看到一个问题,问一个怎么实现

a(3)(4)(4)
// 48

这样子的问题。
那看到这个问题的第一反应应该就是函数的柯里化。
维基百科中对函数柯里化的解释是这样的:

柯里化(英语:Currying),又译为卡瑞化或加里化,是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数,并且返回接受余下的参数而且返回结果的新函数的技术。

函数柯里化有什么作用呢,为什么要柯里化呢。其实也没有什么作用,一般编程中,基本不会用到柯里化,但是假如在函数式编程中,还是很有用的。另一方面,就是面试的时候很多面试官会问。
那么我们看看下面实现的几种例子:

1. 如果固定函数的调用次数

const a = function(x) {
    return function(y) {
      return function(z) {
          return x * y * z;
      };
    };
};

改成 ES6 的写法会更简单

const result = x => y => z => x * y * z;

那这种方式只能实现固定三次调用,如果想有更通用的方法呢?那就看方法二:

2. 通用方法

function curry(fn) {
    const len = fn.length;
    return function curried() {
        const args = Array.prototype.slice.call(arguments);
        if (args.length >= len) {
            return fn.apply(this, args);
        }            
        return function () {
            return curried.apply(this, args.concat(Array.prototype.slice.call(arguments)));
        };
    };
}

如果使用 ES6 的写法,可以简化为(使用了 ES6 的剩余参数(Rest Parameters)):

function curry(fn, ...args){
    return args.length === fn.length ? fn(...args) : (...next_args) => curry(fn, ...args, ...next_args); 
}

然后将需要柯里化的函数传入,即可得到一个柯里化的函数。

const result = curry(function (a, b, c) {
    return a * b * c;
});

那同样的,可以得到

const result2 = curry(function (a, b, c) {
    return a + b + c;
});

可是,如果我想得到

let x = a(3)(4)
let y = x(4);
console.log(x); // 12
console.log(y); // 48

又该怎么办呢?有些人想既然 x 输出为 12 了,那就肯定不能再被调用了,所以 x(4) 肯定会报错。
但是假如 数字12, 并不是一个真正的数字呢?来看例子:

3. 特殊的柯里化

 function currying(x){
  var sum = x
  var curried = function(y){
    sum = sum * y
    return curried
  }
  curried.toString=function(){
    return sum 
  }
  return curried
}

调用

console.log(currying(1))   //1
console.log(currying(1)(2))  //2
console.log(currying(1)(2)(3))  //6
console.log(currying(1)(2)(3)(4))  //24

就是可以得到的,那是为什么呢?主要是利用了函数的 toString 方法。实现了障眼法,在控制台中调用的时候,因为返回的是函数,所以会调用函数的 toString 方法,故而就会显示出来数字。但是在实际代码调用过程中,其实返回的还是函数。所以,这种不算严格的柯里化。只是形式上类似而已。并且还会存在单例的问题,也即此函数任何时候调用,都是同一个值累积。
对于此函数还是好理解的,但是对于第二种通用柯里化其实比较难以理解。那么就大概解释下吧。

先解释两个概念,可能很多人会弄混乱。
1. 函数 a 执行之后返回一个函数 b,函数 b 中 的 arguments 是 调用函数 b 时候传入的参数。
2. Array.prototype.slice.call 是在类数组上调用数组的 slice 方法,将类数组变为真正的数组,例如调用函数是传入的 arguments 就是一个类数组,他是没有 slice 等数组的方法的,所以使用 Array.prototype.slice.call 来将其变为真正的数组。
给 1 举个例子,2 的例子上面的通用函数里面已经有了。

function a(){
    return function (){
        console.log(arguments);
    }
}
var b = a();

此时,b 应该是一个函数.

function (){
    console.log(arguments);
}

那么这个时候再调用b(1,2,3,4,5);
那 在刚才定义的那个函数中 arguments 应该是 ≈[1,2,3,4,5];这个是很重要的一点,很多人这里会被弄混。
那接下来继续看通用柯里化函数。

当调用

const a = function (a, b, c) {
    return a + b + c;
}
const result2 = curry(a);

时。此时 result2 应该是一个函数。

result2 = function curried() {
        const args = Array.prototype.slice.call(arguments);
        if (args.length >= len) {
            return fn.apply(this, args);
        }            
        return function () {
            return curried.apply(this, args.concat(Array.prototype.slice.call(arguments)));
        };
    };
});

但是在这个函数中,却使用了闭包保留了函数 a 的参数,对于此例子来说,就是 a,b,c, 它的长度是 3.即,我调用 result2(3) 的时候,是能够访问到调用 curry(a) 时,a 传的参数(的个数)的。

那,当调用 result2(3)(4)(4);时,是个什么情况呢?

先看第一步let result3 = result2(3);此时会执行 curried() 这个函数。而执行此函数的时候,

const args = Array.prototype.slice.call(arguments);

中的 arguments 就是 3.所以 [3] 的长度小于刚才 a 的长度 3.那么就会继续返回一个函数。此时

result3 = function () {
    return curried.apply(this, args.concat(Array.prototype.slice.call(arguments)));
}

在调用let result4 = result3(4); 和调用 result2(3) 是一样的结果,但是 由于每次都是通过 curried.apply 来调用 curried,并且每次调用 curried 的时候,都会

args.concat(Array.prototype.slice.call(arguments))

所以每次调用,curried 的参数都会增加。上面的例子,

const args = Array.prototype.slice.call(arguments);

中的 arguments 就应该是[3, 4]了。
所以当最后一次调用的时候 args.length >= len 的条件为真。所以就调用了 fn.apply(this, args) 等同于 fn(3,4,4) 最终就会返回相应的结果了。

此文章主要的灵感来自于:segmentfault,使用了其中的函数代码并做修改,特此感谢。

在 Angular 1 中,自定义 Filter 可以这么做。

angular
  .module('app')
  .filter('leftPad', function(value, anotherValue){
    // do something with `value` and `anotherValue`
    // and return a value
});

然后用的时候可以这么用

<p>{{ num | leftPad:searchValue }}</p>

然后 controller 中可以这么用

controller($filter) {
    var numbers = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
    this.numbers = numbers.map(number => $filter('leftPad')(number, searchValue));
  }

那么在 Angular 2 中怎么做呢?
首先一点,在 Angular 2 中已经没有 filter 的概念了,取而代之的是 Pipe 的概念。但是其本质和 filter 是一样的。我们来看看具体怎么使用。
当然了,首先还是先定义。主要的内容就是要实现一个 PipeTransform 的 transform 方法。

// leftPad.pipe.ts

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({name: 'leftPad'})
export class LeftPad implements PipeTransform {
  transform(value: number, anotherValue: number): string {
        // do something with `value` and `anotherValue`
        // and return a value
    }
}

然后在模板中使用的方法就是:

<p>{{ num | leftPad:searchValue }}</p>

那如果想在 component 中使用,怎么用呢?其实也很简单

export class App {
  constructor(private leftPad: LeftPad) {
    let numbers = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20];
    this.numbers = numbers.map(number => this.leftPad.transform(number, searchValue));
  }
}

调用通过 ID 注入进来的 LeftPad 的 实例的 transform 方法即可。
那如果只需要一个参数怎么办呢?
一种就是直接删掉后面的一个参数,例如删掉 searchValue 这个参数。另一种就是兼容两种参数调用,定义 pipe 的时候给不是必须的参数增加一个可选的 ? 标志即可。

最后,在使用的时候,不要忘记添加 providers 哦。

NPM 现在变得越来越流行了,但是很多人可能只是用了其中一小部分的功能,但是 NPM 其实有一大票功能可以用,不信你试试 npm -help 看看。

而本文的主要目的就是介绍 npm version 命令,此命令用来更改项目的版本号。这个版本好就是项目中 package.json 文件中的 version 字段。
一般情况下,都类似于这样一段 json。

{
    "name"           : "npm-version",
    "description"    : "npm version command",
    "version"        : "1.1.1611"
}

怎么用呢?
例如,
你修复了一个 bug,要增加一个最小的版本号,那么

npm version patch

如果想要更新次要版本号的话,那么

npm version minor

更或者,你要更新主版本号的话,那么

npm version major

哈哈哈,是不是不用手动更新这个文件了?

还有一点点

如果你正好用 git 来管理你的项目,那么 npm version 也可以顺便创建一个版本 commit 和 tag 。

钩子

最神奇的事情就是给了我们 pre 和 post 这两个钩子。

即:
在 npm version 执行之前,pre 这个钩子,就会被执行,而在 npm version 执行之后,post 这个钩子也会被执行。
所以呢,如果你想在更新版本号之后在执行一些操作,那么就应该这样写。

"scripts" : {
	"postversion" : "git push && git push --tags"
}

这样子,在更改了版本号之后,就会自动执行这些 git 命令了。
那么想在更新版本号之前呢?咋办啊?

"scripts" : {
	"start" : "node app.js",
	"pretest":"rm -Rf build && gulp build && cd build && npm install --production",
	"test":"./test/run.sh",
	"preversion":"npm test",
	"postversion" : "git push && git push --tags"
}

看,完成了,一个还算基本完成了的 package.json 文件,在改变版本号之前,先测试一下嘛。

如果想看更多的 npm version 的信息,请访问:https://docs.npmjs.com/cli/version

来源:http://blog.js-republic.com/npm-version-is-cool-you-should-use-it/

需求是这样子的,就是想在家里弄个服务器,然后开发,将各种中间代码都推送到这个服务器上,当然了,肯定是使用版本管理中的 Git 嘛。但是当开发到一定程度的时候,也是需要将这个代码推送到公开的代码管理网站,例如 coding 或者 github。

那么怎么做呢?

本地的开发和版本管理就按照正常的 Git 的那一套走。
然后想要推送到 Github 上的话,就按照下面的步骤来。
1. 现在 Github 上新建一个 repository,然后获得一个可以推送的地址,例如 https://github.com/a/a.git;
2. 然后将这个 git 地址添加到本地的 git 中。

git remote add A https://github.com/a/a.git; # A 是这个 remote 的名称

然后使用

git remote -v

就可以查看本地的推送地址列表了。
例如:

a   https://github.com/a/a.git (fetch)
a   https://github.com/a/a.git (push)
origin  https://git.net/b/b.git (fetch)
origin  https://git.net/b/b.git (push)

3. 然后就可以使用命令将这个代码推送到 GitHub 了。

git push a master

当然这个是完全一样的代码的情况下,
如果还需要在两个不同环境有差异的话,那么最好新建一个分支。

git checkout -b GitHubBranch

然后在这个分支下面修改差异,这个时候就要将这个代码推送到 GitHub 的 GitHubBranch 分支了。

git push a GitHubBranch

然后再在 GitHub 合并 GitHub 上的 master 和 GitHubBranch 两个分支就可以了。
这时候,GitHub 上面的 master 分支就可以是最新的代码了。
当然了合并到哪个分支按照自己的需求来。

合并分支我用的是 pull request 合并的,(因为貌似我用了两个不同的账户?)。

完了。

主要是给自己记录用的,其实。

尊敬的刘总,各位领导及各位同事:

  大家好,很荣幸自己可以代表员工在华泰商学院的开学典礼上发言,感谢公司各位领导一直以来的关心及指导。

  作为一名普通的物业管理员,与所有员工一样,正在亲历着公司因为互联网化所带来的全新变化,在这个变化中,我们不断的尝试、创新、形成属于我们华泰物业自己的文化,这是一次全新挑战,同时也是我们员工们一次难得的成长机会。

  公司成立华泰商学院的目的,我觉得是想我们在公司转型成长的过程中能够跟的上脚步,让我们用知识来武装自己,用知识提升我们的能力,用能力更好的服务于业主。用更加专业化的服务来赢得业主的信任,从而获得业主对我们自身对华泰物业的认可。

  在工作中我相信每个人都有自己所要实现的梦想和想要达到的目标,可是空谈梦想和目标只会让我们离它越来越远。

  目标的实现需要公司领导的带领,但也需要我们自己的努力。设定目标,做好计划,主动思考,加强自身学习,不断尝试,坚持到底。公司为我们每一个人提供了同等的平台 ,商学院的成立正是我们起航的码头,在这个平台中,我们学习他人之长,补自己之短,我们可以把自己懂得会的拿出来分享与他人,在这个大家庭中一起进步,一起成长。

  古人曾说,三日不读书,便觉语言无味,面目可憎,现在我们有了一个这样的学习平台,再不读书,不充实自己,面部的表情都可憎起来了,谈何对业主热情服务呢。

  在公司大目标的前提下,建立自己所要实现的小目标,只有我们小目标的实现,最后才能完成公司大目标的实现。因此学习的过程,充实自己的过程虽是自己人生价值实现的过程,但也更是为公司成长和蜕变付出自己努力的过程。

  最后预祝我们自己的商学院越办越好,也希望我们可以成长为比今天更好的自己。

  谢谢大家。

1. 在Windows中添加一个HOME环境变量,值为%USERPROFILE%,如下图:
environment variable
2. 在 "开始>运行" 中打开 %Home%,新建一个名为 _netrc 的文件。

3. 用文本编辑器打开 _netrc 文件,输入 Git 服务器名、用户名、密码,并保存。示例如下:

machine git.xxx.com
login git_user
password git_pwd

OK, 试试吧,还需要不需要用户名密码了。

在 Windows 下创建 MongoDB 服务命令,记录下。

    sc create MongoDB binPath= "\"D:\Program Files\mongodb\server\3.0\bin\mongod.exe\" 
    --service --config=\"D:\mongodb\mongod.cfg\"" DisplayName= "MongoDB" start= "auto"