十年踪迹

function perms(list){
if(list.length)
return Array.concat.apply(
[],
[
[O.concat(T) for each(T in I)]
for each([O,I] in list.map(function(o,i) [[o],perms(list.slice(0,i).concat(list.slice(i+1)))]))
]
);
else
return [[]];
}
alert(perms([1,2,3,4]).join("\n"));

JavaScript语法写Functional还是繁琐，上面的这个，用erlang来写的话只要两行——

perms([]) -> [[]];
perms(L) -> [[H|T] || H<-L, T<-perms(L--[H])].

admin Uncategorized

函数式编程

February 23rd, 2010

1 comment

快速排序

//纯算法，仅供研究，其实在浏览器下不快，js递归效率很差
function qsort(arr){
if(!arr.length) return [];
var c = arr.shift();
return qsort(arr.filter(function(o){return o<=c?o:null}))
.concat([c])
.concat(qsort(arr.filter(function(o){return o>c?o:null})));
}
var a = [1,4,3,2,5,1,-1,3,2,4.5];
alert(qsort(a));

admin Uncategorized

trac插件的bug

January 14th, 2010

1 comment

1、account-mgr 的bug: 找回密码后不能登陆
修改acct_mgr/web_ui.py
if req.path_info != redirect_url: -> if req.href(req.path_info) != redirect_url:
http://trac-hacks.org/attachment/ticket/3233/redirect-fix.patch

2、codereview的bug: 插件设置出错后没有正确的出错信息
http://trac-hacks.org/attachment/ticket/6032/codereview.model.diff

admin Python

函数的可靠性

December 21st, 2009

1 comment

http://bbs.51js.com/viewthread.php?tid=86342&pid=602059&page=1&extra=page%3D1#pid602059

要设计一个优秀的函数，基本的原则之一是这个函数的表现要可靠，有时候我们不经意间为了实现一个特性而违背了函数的可靠性，给使用者留下了“坑”，这是不应该的

function test(){
var x = 1;
test = function(){
return x++;
}
return test();
}

这个函数之所以这么写，作者是想在函数中利用闭包特性定义一个局部静态变量，但是，这个函数是有问题的

function test(){
var x = 1;
test = function(){
return x++;
}
return test();
}
var test2 = test; //中招
alert(test2());alert(test2());alert(test2()); //错了

所以，必须要消除这种“坑“，改用下面的写法：

var test = (function(){
var x = 1;
return function() {
alert(x);
x ++;
}
})();

最后，总结一下定义带有局部静态作用域的函数范式

var myFunc = (function(){
var localVariable = "someValue";
return function(args...){
//function body
}
})();

admin 前端技术 javascript

一个看似简单的问题

November 22nd, 2009

2 comments

JavaScript求不大于且最接近于一个整数的偶数：

function f(n){
return n & -2;
}

admin Uncategorized

神奇的“连续”

August 31st, 2009

1 comment

先看一段代码：

Function.prototype.$continuous = function(fn){
var me = this;
return function(){
var currentArgs = Array.prototype.slice.call(arguments, 0, me.length);
var moreArgs = Array.prototype.slice.call(arguments, me.length);
ret = me.apply(this, currentArgs);
if(moreArgs.length > 0){
ret = fn.call(this, arguments.callee, ret, moreArgs);
}
return ret;
}
}

这个函数并不复杂，它的作用是包装一个函数，判断它实际调用的参数个数和形参个数，当实际调用的参数个数大于形参个数时，再用一个闭包进行后续操作，这个闭包有3个参数，分别是包装的函数自身、前次调用的返回值，以及多余的参数。

这个简单的函数其实比想象得有用：

var add = function(x,y){
return x+y;
}

add显然只是一个简单的两个数相加的程序，如果想让它支持多个数相加呢？

function reducer(target, returnValue, moreArgs){
return target.apply(this, [returnValue].concat(moreArgs));
}
add = add.$continuous(reducer);
var a = add(1,2,3,4,5); //a = 1+2+3+4+5=15

同样的：

var max = function(x,y){
return x>y?x:y;
}
max = max.$continuous(reducer);
var a = max(1,2,3,2,1); //a=3

还有别的作用：

function processor(target, returnValue, moreArgs){
return [returnValue].concat(target.apply(this, moreArgs));
}
var $ = function(id){
return document.getElementById(id);
}.$continuous(processor);
var els = $("a","b","c"); //得到3个elements（返回数组）

最后总结一下：
$continuous本身很简单，但是它可以被reducer或processor作用，也就是说，返回结果可以被push，也可以被reduce，上面的reducer实际上是先push再reduce，后面的processor我改了一个次序，先reduce再push，就能获得截然不同的用途。

不知道通过上面的叙述，大家对脚本库核心的基本设计和函数式(functional)编程的思想方法有没有新的认识。不管怎样，JavaScript灵活多变的特性，总能让前端开发充满乐趣。