博客园_Cauma

Nodejs开发环境搭建

2012-03-16T18:37:00Z

由于还是习惯win7环境。所以搭建的环境是：

win7为开发环境。Vbox虚拟机+Ubuntu搭建nodejs编译环境。然后通过securecrt远程连接到虚拟机进行开发。

第一步：安装依赖包

1. 安装python 2.6版或者更高（ubuntu默认都已安装，可以在terminal中使用 python -v 命令查看python版本）。
2. 安装其他依赖包:
sudo apt-get install g++ curl libssl-dev apache2-utils
3. 安装git工具：

sudo apt-get install git

第二步：获取源码

git clone git://github.com/joyent/node.git

第三步：指定编译版本

1.先进入存放下载源码的文件夹：
cd node
2. 指定迁出版本：
git checkout v0.6.12 （版本的选择，遵循稳定原则）
3. 指定路径，编译执行:

mkdir ~/local
./configure –prefix=$HOME/local/node
make
make install
echo 'export PATH=$HOME/local/node/bin:$PATH' >> ~/.profile
echo 'export NODE_PATH=$HOME/local/node:$HOME/local/node/lib/node_modules' >> ~/.profile
source ~/.profile

第四步：设置环境变量

如果想重启后还能继续直接使用node命令,那么需要设置环境变量:
使用命令 sudo gedit /etc/profile 打开配置文件，在文件最后中添加如下两行：

export PATH="$HOME/local/node/bin:$PATH"
export NODE_PATH="$HOME/local/node:$HOME/local/node/lib/node_modules"

保存后重启系统使设置生效。

第五步：安装npm

curl http://npmjs.org/install.sh | sh
根据需要，安装相应的包，例如express：
npm install express -gd
-g代表安装到NODE_PATH的lib里面，而-d代表把相依性套件也一起安装。如果沒有-g的话会安装目前所在的目录(会建立一个node_modules的文件夹)

第六步：通过npm按需安装文件包

这里我们可以引用一个实例来说明。提供一个练习Demo https://github.com/cmarin/MongoDB-Node-Express-Blog

这个DEMO需要安装的依赖包已经标明，咱们按照命令操作即可

首先cd到自己的工作目录 git clone git://github.com/cmarin/MongoDB-Node-Express-Blog.git 获取源码。

然后首先安装数据库直接在命令行里输入sudo apt-get install mongodb(参考http://gnucto.blog.51cto.com/3391516/833535 )即可，安装完成后测试方法，终端命令行中输入：

mongo
db.foo.save({a:1})
db.foo.findOne()

然后

npm install express
npm install express-messages
npm install ejs npm install sass
npm install mongoose
Then cd into the directory and run: node app.js

此时会看到终端的log提示

You can debug your app with http://localhost:3000 表明已经安装成功。

此时通过ip就可以访问了。如http://192.168.1.106:3000/

Tips

1. 有时候由于异常关机会导致mongodb数据库被锁住。提示Error: couldn't connect to server 127.0.0.1} 。解决方案：

sudo rm /var/lib/mongodb/mongod.lock
sudo chown -R mongodb:mongodb /var/lib/mongodb/
sudo -u mongodb mongod -f /etc/mongodb.conf --repair
sudo service mongodb start

2. 在nodejs开发阶段如果用node xxx.js 来运行时不能时时检测js文件的变化，这样调试起来就很麻烦，所以需要安装一个开发调试脚本

npm install -g node-dev

使用
node-dev app.js 来调试

如果需要在nodeserver之前再搭建一层nginx，基础配置如下：

1 安装pcre
sudo apt-get install libpcre3-dev

2 安装zlib
$ tar xzf zlib-1.2.3.tar.gz
$ cd zlib-1.2.3/
$ ./configure
$ make
$ sudo make install

3
nginx-1.0.8$ ./configure --prefix=<所要安装的path 比如我的安装在/home/机器名/work/nginx>
nginx-1.0.8$ make
nginx-1.0.8$ sudo make install

4 检查配置是否正确
root@ubuntu:/home/# /usr/local/nginx/sbin/nginx -t [根据上面不同的--prefix需要找不同的路径。此处是默认安装不指定prefix的默认目录]
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

5 启动nginx
root@ubuntu:/home/# /usr/local/nginx/sbin/nginx
root@ubuntu:/home/# ps -ef | grep nginx
root      1436     1  0 04:58 ?        00:00:00 nginx: master process /usr/local/nginx/sbin/nginx
nobody    1437  1436  0 04:58 ?        00:00:00 nginx: worker process
root      1439  1413  0 04:58 pts/0    00:00:00 grep --color=auto nginx

6 测试
root@ubuntu:/home/# curl http://localhost
<html>
<head>
<title>Welcome to nginx!</title>
</head>
<body bgcolor="white" text="black">
<center><h1>Welcome to nginx!</h1></center>
</body>
</html>

或者

root@ubuntu:/home/xiong# ifconfig
eth0      Link encap:Ethernet  HWaddr 00:0c:29:7b:80:c2
          inet addr:192.168.130.131  Bcast:192.168.130.255  Mask:255.255.255.0

浏览器输入：
http://192.168.130.131/

关闭nginx：

nginx -s stop         快速关闭Nginx，可能不保存相关信息，并迅速终止web服务。（quick exit）
nginx -s quit          平稳关闭Nginx，保存相关信息，有安排的结束web服务。（graceful exit）

重启nginx：

nginx -s reload       因改变了Nginx相关配置，需要重新加载配置而重载。（changing configuration，start a new worker,quitting an old worker gracefully.)
nginx -s reopen       重新打开日志文件。(reopenging log files)

以上nginx基本配置完毕，可以启动了。简单放一个基础的nginx.conf文件

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

error_log  logs/error.log  debug; # 第一处修改开启日志
pid        logs/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    # 第二处开启日志格式化
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       9199; # 第三处修改修改默认80端口，不然启动nginx需要root权限
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location /xxx {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        location / {
            proxy_pass   http://127.0.0.1:3001;  # 第四处所有9199端口下直接proxy_pass到其他服务端
        }

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }

    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

    # HTTPS server
    #
    #server {
    #    listen       443;
    #    server_name  localhost;

    #    ssl                  on;
    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_timeout  5m;

    #    ssl_protocols  SSLv2 SSLv3 TLSv1;
    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers   on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

入门教程 http://www.nodebeginner.org/index-zh-cn.html 值得一看

本文链接

Underscore骨骼

2011-07-02T07:49:00Z

上次写过一篇QWrap骨骼的文章，个人认为，想要了解一个库或框架，首先从他的核心思想入手，理解其思想，那么剩余的就仅仅是方法的堆砌。近年比较火的一个jsMVC框架backbone他的核心强依赖库为underscore。

抽空提取了一下他的骨骼，其实主要就是他的链式操作的实现，别个剩下的就是具体函数的实现了，当然对于Underscore函数式也是它的最大亮点，可以好好看下函数的实现。

<!DOCTYPE html>
<html>
<head>
<title> Underscore骨骼 </title>
</head>
<body>
<script type="text/javascript">
// Underscore骨骼
(function () {
    var root = this;


    var breaker = {};

    var ArrayProto = Array.prototype, ObjProto = Object.prototype;

    var nativeForEach    = ArrayProto.forEach,
        nativeMap        = ArrayProto.map,
        nativeFilter    = ArrayProto.filter,
        nativeKeys        = Object.keys;

    var slice            = ArrayProto.slice,
        unshift            = ArrayProto.unshift,
        hasOwnProperty  = ObjProto.hasOwnProperty;

    // 构造函数
    var _ = function (obj) { return new wrapper(obj); };

    // 向全局暴露接口
    root._ = _;

    // 类型检测
    _.isNumber = function (obj) {
        return !!(obj === 0 || (obj && obj.toExponential && obj.toFixed));
    };
    _.isFunction = function (obj) {
        return !!(obj && obj.constructor && obj.call && obj.apply);
    };

    // 遍历扩展
    var each = _.each = _.forEach = function (obj, iterator, context) {
        if (obj === null) return;

        if (nativeForEach && obj.forEach === nativeForEach) {
            obj.forEach(iterator, context);
        } else if (_.isNumber(obj.length)) {
            for (var i = 0, l = obj.length; i < l; i++) {
                if (iterator.call(context, obj[i], i, obj) === breaker) return;
            }
        } else {
            for (var key in obj) {
                if (hasOwnProperty.call(obj, key)) {
                    if (iterator.call(context, obj[key], key, obj) === breaker) return;
                }
            }
        }
    };

    // 返回对象上面的函数名
    _.functions = _.methods = function (obj) {
        return _.filter(_.keys(obj), function (key) { return _.isFunction(obj[key])}).sort();
    };

    // 过滤数组
    _.filter = _.select = function (obj, iterator, context) {
        var results = [];
        if (obj == null) return results;
        if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);

        each(obj, function (value, index, list) {
            if (iterator.call(context, value, index, list)) results[results.length] = value;
        });
        return results;
    };

    // 获取key值
    _.keys = nativeKeys || function (obj) {
        if (obj !== Object(obj)) throw new TypeError('Invalid object');
        var keys = [];
        for (var key in obj) if (hasOwnProperty.call(obj, key)) keys[keys.length] = key;
        return keys;
    };

    // 用于实验的map方法
    _.map = function (obj, iterator, context) {
        var results = [];
        if (obj == null) return results;
        if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
        each(obj, function (value, index, list) {
            results[results.length] = iterator.call(context, value, index, list);
        });
        return results;
    };

    // 链式操作主要部分
    var wrapper = function (obj) { this._wrapped = obj; };

    _.prototype = wrapper.prototype;

    // 扩展自定义方法到Wrap包装器上
    _.mixin = function (obj) {
        each(_.functions(obj), function (name) {
            addToWrapper(name, _[name] = obj[name]);
        });
    };

    // 是否对结果进行链式包装返回
    var result = function (obj, chain) {
        return chain ? _(obj).chain() : obj;
    };

    // 将方法扩展到包装器的原型上
    var addToWrapper = function (name, func) {
        wrapper.prototype[name] = function () {
            var args = slice.call(arguments);
            unshift.call(args, this._wrapped);
            return result(func.apply(_, args), this._chain);
        };
    };

    // 将所有Underscore上的方法添加到Wrap包装器上
    _.mixin(_);

    // 扩展Array上的方法到wrap包装器上-包装原数组
    each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (name) {
        var method = ArrayProto[name];
        wrapper.prototype[name] = function () {
            method.apply(this._wrapped, arguments);
            return result(this._wrapped, this._chain);
        };
    });

    // 扩展Array上的方法到wrap包装器上-包装返回值
    each(['concat', 'join', 'slice'], function (name) {
        var method = ArrayProto[name];
        wrapper.prototype[name] = function () {
            return result(method.apply(this._wrapped, arguments), this._chain);
        };
    });

    // 添加链式方法的实现
    wrapper.prototype.chain = function () {
        this._chain = true;
        return this;
    };

    // 提取链式包装的内容
    wrapper.prototype.value = function () {
        return this._wrapped;
    };

})();

// 结果测试步骤：将数组[1,2,3]进行链式包装，然后将其用val * 2来map，紧接着用filter进行val < 5过滤,
// 然后pop,concat最后获取其值value
var re = _([1,2,3]).chain().map(function (val) {
    return val * 2;
}).filter(function (val) {
    return val < 5;
}).pop().concat(['5']).value();

alert(re);
</script>
</body>

< /html>

本文链接

【思维】中位数与顺序统计

2011-04-27T16:08:00Z

算法定义

在统计学中，中值（又称中位数）代表一个样本、种群或概率分布中的一个数值，其可将数值集合划分为相等的上下两部分。对于有限的数集，可以通过把所有观察值高低排序后找出正中间的一个作为中值。如果观察值有偶数个，则中值不唯一，通常取最中间的两个数值的平均数作为中值。

一个数集中最多有一半的数值小于中值，也最多有一半的数值大于中值。如果大于和小于中值的数值个数均少于一半，那麽数集中必有若干值等同于中值。

设连续随机变量X的分布函数为F(X)，那么满足条件P(X≤m)=F(m)=1/2的数称为X或分布F的中位数。

对于一组有限个数的数据来说，它们的中位数是这样的一种数：这群数据里的一半的数据比它大，而另外一半数据比它小。计算有限个数的数据的中位数的方法是：把所有的同类数据按照大小的顺序排列。如果数据的个数是奇数，则中间那个数据就是这群数据的中位数；如果数据的个数是偶数，则中间那2个数据的算术平均值就是这群数据的中位数。中位数统计学的函数符号为MEDIAN。

算法描述

针对中位数，我们可以抽象的定义一个选择问题，描述如下：

输入：一个包含n个不同数的集合A和一个数i, i <= i <= n

输出:恰大于A中i-1个元素的那个元素

白话描述: 写一个函数，输入一个数组和索引。返回第索引大的数字。如[1,5,6,3] 中第2(i=2)大的元素为3.

针对这个需求。最直观的想法是找一个比较好的排序算法如堆排序等，用n(lgn)的复杂度排好序然后用线性的复杂度选择元素。那么是否还有更优复杂度的算法呢？显然是有的。

这里的算法整个思路和前面讲的随机版快速排序的思路是一致的。平均复杂度为O(n)的线性复杂度

源码描述

本文链接

【思维】基数排序

2011-04-17T15:35:00Z

算法定义

基数排序(Radix sort)是一种排序算法，它是这样实现的：
将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零. 然后, 从最低位开始, 依次进行一次排序.这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列.
基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

算法描述

基数排序的简单描述就是将数字拆分为个位十位百位，每个位依次排序。因为这对算法稳定要求高。所以我们对数位排序用到上一个排序方法计数排序

因为基数排序要经过d (数据长度)次排序，每次使用计数排序，计数排序的复杂度为 ⊙(n), d 相当于常量，和N无关，所以基数排序也是 ⊙(n)

基数排序虽然是线性复杂度，即对n个数字处理了n次，但是每一次代价都比较高，而且使用计数排序的基数排序不能进行原地排序，需要更多的内存，并且快速排序可能更好地利用硬件的缓存， 所以比较起来，像快速排序这些原地排序算法更可取。

但是基数排序有个优点是：它是稳定的(PS: 归并排序也是稳定的）

源码描述

/* 计数排序包装 */
function stableSort(arr, k/*最多不超过4位*/) {
    var re = [];
    var C = [];

    for (var i = 0; i <= 9; i++) {
        C[i] = 0;
    }

    for (var i = 0, l = arr.length; i < l; i++) {
        var d = getIndex(arr[i], k);
        C[d]++;
    }

    for (var i = 1; i <= 9; i++) {
        C[i] = C[i] + C[i-1];
    }

    for (var i = arr.length-1; i >= 0; i--) {
        var d = getIndex(arr[i], k);
        re[C[d]-1] = arr[i];
        C[d]--;
    }
    return re;
}

/*截取指定位数的值*/
function getIndex(a, k) {
    while (a != 0 && k != 0) {
        a /= 10;
        k--;
    }
    return Math.floor(a % 10);
}

function radixSort(arr, d/*arr中的数字不会长于d位*/) {
    for (var i = 0; i < d; i++) {
        arr = stableSort(arr, i); /*依次对各位数字排序（直接用计数排序的变体）*/
    }
    return arr;
}

var arr  = [333, 956, 175, 345, 212, 542, 99, 87];

alert(radixSort(arr, 4))

本文链接

【思维】计数排序

2011-04-14T15:10:00Z

算法定义

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。

当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

算法描述

算法的步骤如下：

找出待排序的数组中最大和最小的元素
统计数组中每个值为i的元素出现的次数，存入数组C的第i项
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

分类	排序算法
数据结构	数组
最差时间复杂度	O(n + k)
最优时间复杂度	O(n + k)
平均时间复杂度	O(n + k)
最差空间复杂度	O(n + k)

源码描述

Main();

计数排序因为没有元素间的比较所以不是比较排序。那么他就可以突破nlgn的性能渐进下限。而且重要的是计数排序是算法稳定的。由于下一个排序算法<基数排序>会用到计数排序。所以稳定性很重要。

本文链接

【思维】快速排序

2011-04-13T16:34:00Z

算法定义

快速排序是一种排序算法，由C. A. R. Hoare所发展的，以平均效能来说，排序 n 个项目要Θ(n log n)次比较。然而，在最坏的效能下，它需要Θ(n²)次比较。一般来说，快速排序实际上明显地比其他Θ(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。

算法描述

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

步骤为：

从数列中挑出一个元素，称为 "基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

源码描述

})();

另一种实现

因为如果是已经排好序的话。那么用快速选择还需要O(n^2)的时间复杂度。这样是不优的。为了防止这种情况。所以在数据量大的时候可以使用随机化版本。随机化主元就避免最坏情况发生。

随机选择排序

alert(arr);

其余参考:

c#与算法--快速排序

快速排序

CSDN快速排序

http://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html?20110404221633

http://jsdo.it/norahiko/oxIy/fullscreen

本文链接

【思维】堆排序

2011-04-12T17:35:00Z

算法定义

堆排序（Heapsort）是指利用（堆）这种数据结构所设计的一种排序算法。堆积树是一个近似完全二叉树的结构，并同时满足堆属性：即子结点的键值或索引总是小于（或者大于）它的父节点。

最差时间复杂度	O(nlogn)
最优时间复杂度	O(nlogn)
平均时间复杂度	Θ(nlogn)

算法描述

在堆积树的数据结构中，堆积树中的最大值总是位于根节点。堆积树中定义以下几种操作：

最大堆积调整（Max_Heapify）：将堆积树的末端子结点作调整,使得子结点永远小于父结点
创建最大堆积（Build_Max_Heap）：将堆积树所有数据重新排序
堆积排序（HeapSort）：移除位在第一个数据的根结点,并做最大堆积调整的递归运算

源码描述

var HEAP_SIZE = 10;

// 获取父节点
function getParent(i) {
    return Math.floor(i/2);
}
// 获取左子节点
function getLeft(i) {
    return 2 * i;
}
// 获取右子节点
function getRight(i) {
    return (2 * i + 1);
}

// 对单一子节点维持最大堆
function Max_Heapify(A, i, heap_size) {
    var l = getLeft(i);
    var r = getRight(i);
    var largest;
    var temp;
    if (l < heap_size && A[l] > A[i]) {
        largest = l;
    } else {
        largest = i;
    }
    if (r < heap_size && A[r] > A[largest]) {
        largest = r;
    }

    if (largest != i) {
        temp = A[i];
        A[i] = A[largest];
        A[largest] = temp;
        Max_Heapify(A, largest, heap_size);
    }
}

// 建立最大堆树结构
function Buile_Max_Heap(A) {
    for (var i = Math.floor(HEAP_SIZE/2); i >= 0; i--) {
        Max_Heapify(A, i, HEAP_SIZE);
    }
}

// 打印最大堆二叉树
function printTree(A) {
    for (var i = 0; i < HEAP_SIZE; i++) {
        document.write(A[i] + '<br/>');
    }
}

// 堆排序
function HeapSort(A, heap_size) {
    var temp;
    Buile_Max_Heap(A);
    for (var i = heap_size-1; i >= 1; i--) {
        temp = A[0];
        A[0] = A[i];
        A[i] = temp;
        heap_size = heap_size - 1;
        Max_Heapify(A, 0, heap_size);
    }

    printTree(A);
}

// 测试堆排序
(function() {
    var A = [4,1,3,2,16,9,10,14,8,7];
    HeapSort(A, HEAP_SIZE);
})();

本文链接

【思维】插入排序

2011-04-09T04:23:00Z

算法定义

插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置中
重复步骤2

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找排序。

源码描述

本文链接

关于设计启发

2011-03-12T15:29:00Z

下面是对主要的设计中的启发式方法的总结：

寻找现实世界中的对象(object,物体)
形成一致的抽象
封装实现细节
在可能的情况下继承
藏住秘密(信息隐藏)
找出容易改变的区域
保持松散耦合
探寻通用的设计模式
高内聚性
构造分层结构
严格描述类契约
分配职责
为测试而设计
避免失误
有意识的选择绑定时间
创建中央控制点
考虑使用蛮力
画一个图
保持设计模块化

本文链接

如何向妻子解释OOD【转】

2011-01-25T15:46:00Z

译者原文地址：http://www.cnblogs.com/niyw/archive/2011/01/25/1940603.html

如何向妻子解释OOD

前言

此文译自CodeProject上<How I explained OOD to my wife>一文，该文章在Top Articles上排名第3，读了之后觉得非常好，就翻译出来，供不想读英文的同学参考学习。

作者(Shubho)的妻子(Farhana)打算重新做一名软件工程师(她本来是，后来因为他们孩子出生放弃了)，于是作者就试图根据自己在软件开发设计方面的经验帮助她学习面向对象设计(OOD)。

自作者从事软件开发开始，作者常常注意到不管技术问题看起来多复杂，如果从现实生活的角度解释并以对答的方式讨论，那么它将变得更简单。现在他们把在OOD方面有些富有成效的对话分享出来，你可能会发现那是一种学习OOD很有意思的方式。

下面就是他们的对话：

OOD简介

Shubho:亲爱的，让我们开始学习OOD吧。你了解面向对象原则吗？

Farhana:你是说封装，继承，多态对吗？我知道的。

Shubho:好，我希望你已了解如何使用类和对象。今天我们学习OOD。

Farhana:等一下。面向对象原则对面向对象编程(OOP)来说不够吗？我的意思是我会定义类，并封装属性和方法。我也能根据类的关系定义它们之间的层次。如果是，那么还有什么？

Shubho:问得好。面向对象原则和OOD实际上是两个不同的方面。让我给你举个实际生活中的例子帮你弄明白。

再你小时候你首先学会字母表，对吗？

Farhana:嗯

Shubho:好。你也学了单词，并学会如何根据字母表造词。后来你学会了一些造句的语法。例如时态，介词，连词和其他一些让你能造出语法正确的句子。例如：

"I" (代词) "want" (动词) "to" (介词) "learn" (动词) "OOD"(名词)。

看，你按照某些规则组合了单词，并且你选择了有某些意义的正确的单词结束了句子。

Farhana:OK，这意味着什么呢？

Shubho:面向对象原则与这类似。OOP指的是面向对象编程的基本原则和核心思路。在这里，OOP可以比作英语基础语法，这些语法教你如何用单词构造有意义且正确的句子，OOP教你在代码中构造类，并在类里封装属性和方法，同时构造他们之间的层次关系。

Farhana:嗯..我有点感觉了，这里有OOD吗？

Shubho:马上就有答案。现在假定你需要就某些主题写几篇文章或随笔。你也希望就几个你擅长主体写基本书。对写好文章/随笔或书来说，知道如何造句是不够的，对吗？为了使读者能更轻松的明白你讲的内容，你需要写更多的内容，学习以更好的方式解释它。

Farhana:看起来有点意思...继续。

Shubho:现在，如果你想就某个主题写一本书，如学习OOD，你知道如何把一个主题分为几个子主题。你需要为这些题目写几章内容，也需要在这些章节中写前言，简介，例子和其他段落。你需要为写个整体框架，并学习一些很好的写作技巧以便读者能更容易明白你要说的内容。这就是整体规划。

在软件开发中，OOD是整体思路。在某种程度上，设计软件时，你的类和代码需能达到模块化，可复用，且灵活，这些很不错的指导原则不用你重新发明创造。确实有些原则你已经在你的类和对象中已经用到了，对吗？

Farhana:嗯...有个大概的印象了，但需要继续深入。

Shubho:别担心，你马上就会学到。我们继续讨论下去。

为什么要OOD？
Shubho:这是一个非常重要的问题。当我们能很快地设计一些类，完成开发并发布时，为什么我们需要关心OOD？那样子还不够吗？
Farhana:嗯，我早先并不知道OOD，我一直就是开发并发布项目。那么关键是什么？
Shubho:好的，我先给你一句名言：
走在结冰的河边不会湿鞋，开发需求不变的项目畅通无阻(Walking on water and developing software from a specification are easy if both are frozen)
-Edward V. Berard
Farhana:你的意思是软件开发说明书会不断变化？
Shubho:非常正确！软件开发唯一的真理是“软件一定会变化”。为什么?
因为你的软件解决的是现实生活中的业务问题，而现实生活中得业务流程总是在不停的变化。
假设你的软件在今天工作的很好。但它能灵活的支持“变化”吗？如果不能，那么你就没有一个设计敏捷的软件。
Farhana:好，那么请解释一下“设计敏捷的软件”。
Shubho:"一个设计敏捷的软件能轻松应对变化，能被扩展，并且能被复用。"
并且应用好"面向对象设计"是做到敏捷设计的关键。那么，你什么时候能说你在代码中很好的应用了OOD？
Farhana:这正是我的问题。
Shubho:如果你代码能做到以下几点，那么你就正在OOD：
面向对象
复用
能以最小的代价满足变化
不用改变现有代码满足扩展
Farhana：还有？
Shubho:我们并不是孤立的。很多人在这个问题上思考了很多，也花费了很大努力，他们试图做好OOD，并为OOD指出几条基本的原则(那些灵感你能用之于你的OOD)。他们最终也确实总结出了一些通用的设计模式(基于基本的原则)。
Farhana:你能说几个吗？
Shubho:当然。这里有很多涉及原则，但最基本的是叫做SOLID的5原则(感谢Uncle Bob,伟大OOD导师)。

S = 单一职责原则 Single Responsibility Principle
O = 开放闭合原则 Opened Closed Principle
L = Liscov替换原则 Liscov Substitution Principle
I = 接口隔离原则 Interface Segregation Principle
D = 依赖倒置原则 Dependency Inversion Principle

接下去，我们会仔细探讨每一个原则。
单一职责原则
Shubho:我先给你展示一张海报。我们应当谢谢做这张海报的人，它非常有意思。
单一职责原则海报
它说："并不是因为你能，你就应该做"。为什么？因为长远来看它会带来很多管理问题。
从面向对象角度解释为："引起类变化的因素永远不要多于一个。"
或者说"一个类有且只有一个职责"。
Farhana：能解释一下吗？
Shubho:当然，这个原则是说，如果你的类有多于一个原因会导致它变化(或者多于一个职责)，你需要一句它们的职责把这个类拆分为多个类。
Farhana:嗯...这是不是意味着在一个类里不能有多个方法？
Shubho:不。你当然可以在一个类中包含多个方法。问题是，他们都是为了一个目的。如今为什么拆分是重要的？
那是因为：
每个职责是轴向变化的；
如果类包含多个职责，代码会变得耦合；
Farhana:能给我一个例子吗？
Shubho:当然，看一下下面的类层次。当然这个例子是从Uncle Bob那里得来，再谢谢他。
违反单一职责原则的类结构图
这里，Rectangle类做了下面两件事：
计算矩形面积；
在界面上绘制矩形；
并且，有两个应用使用了Rectangle类：
计算几何应用程序用这个类计算面积；
图形程序用这个类在界面上绘制矩形；
这违反了SRP(单一职责原则);
Farhana:如何违反的？
Shubho:你看，Rectangle类做了两件事。在一个方法里它计算了面积，在另外一个方法了它返回一个表示矩形的GUI。这会带来一些有趣的问题：
在计算几何应用程序中我们必须包含GUI。也就是在开发几何应用时，我们必须引用GUI库；
图形应用中Rectangle类的变化可能导致计算几何应用变化，编译和测试，反之亦然；
Farhana:有点意思。那么我猜我们应该依据职责拆分这个类，对吗？
Shubho:非常对，你猜我们应该做些什么？
Farhana:当然，我试试。下面是我们可能要做的：
拆分职责到两个不同的类中，如：
Rectangle:这个类应该定义Area()方法；
Rectangle:这个类应继承Rectangle类，并定义Draw()方法。
Shubho:非常好。在这里，Rectangle类被计算几何应用使用，而RectangleUI被图形应用使用。我们甚至可以分离这些类到两个独立的DLL中，那会允许我们在变化时不需要关心另一个就可以实现它。
Farhana:谢谢，我想我明白SRP了。SRP看起来是把事物分离成分子部分，以便于能被复用和集中管理。我们也不能把SRP用到方法级别吗？我的意思是，我们可以写一些方法，它们包含做很多事的代码。这些方法可能违反SRP，对吗？
Shubho:你理解了。你应当分解你的方法，让每个方法只做某一项工作。那样允许你复用方法，并且一旦出现变化，你能购以修改最少的代码满足变化。
开放闭合原则
Shubho:这里是开放闭合原则的海报
开放闭合原则海报
从面向对象设计角度看,它可以这么说:"软件实体(类,模块,函数等等)应当对扩展开放，对修改闭合。"
通俗来讲，它意味着你应当能在不修改类的前提下扩展一个类的行为。就好像我不需要改变我的身体而可以穿上衣服。
Farhana:有趣。你能够按照你意愿穿上不同的衣服来改变面貌，而从不用改造身体。你对扩展开放了，对不？
Shubho:是的。在OOD里，对扩展开发意味着类或模块的行为能够改变，在需求变化时我们能以新的，不同的方式让模块改变，或者在新的应用中满足需求。
Farhana:并且你的身体对修改是闭合的。我喜欢这个例子。当需要变化时，核心类或模块的源代码不应当改动。你能用些例子解释一下吗？
Shubho:当然，看下面这个例子。它不支持"开放闭合"原则。
违反开发闭合原则的类结构
你看，客户端和服务段都耦合在一起。那么，只要出现任何变化，服务端变化了，客户端一样需要改变。
Farhana:理解。如果一个浏览器以紧耦合的方式按照指定的服务器(比如IIS)实现，那么如果服务器因为某些原因被其他服务器(如Apache)替换了，那么浏览器也需要修改或替换。这确实很可怕！
Shubho:对的。下面是正确的设计。
遵循开放闭合原则的类结构
在这个例子中，添加了一个抽象的服务器类，客户端包含一个抽象类的引用，具体的服务类实现了抽象服务类。那么，因任何原因引起服务实现发生变化时，客户端都不需要任何改变。
这里抽象服务类对修改是闭合的，实体类的实现对扩展是开放的。
Farhana:我明白了，抽闲是关键，对吗？
Shubho:是的，基本上，你抽象的东西是你系统的核心内容，如果你抽象的好，很可能在扩展功能时它不需要任何修改(就像服务是一个抽象概念)。如果在实现里定义了抽象的东西(比如IIS服务器实现的服务)，代码要尽可能以抽象(服务)为依据。这会允许你扩展抽象事物，定义一个新的实现(如Apache服务器)而不需要修改任何客户端代码。
Liskov's 替换原则
Shubho:"Liskov's替换原则(LSP)"听起来很难，却是很有用的基本概念。看下这幅有趣的海报：
Liskov替换原则海报
这个原则意思是："子类型必须能够替换它们基类型。"
或者换个说法："使用基类引用的函数必须能使用继承类的对象而不必知道它。"
Farhana:不好意思，听起来有点困惑。我认为这个OOP的基本原则之一。也就是多态，对吗？为什么一个面向对象原则需要这么说呢？
Shubho:问的好。这就是你的答案：
在基本的面向对象原则里，"继承"通常是"is a"的关系。如果"Developer" 是一个"SoftwareProfessional",那么"Developer"类应当继承"SoftwareProfessional"类。在类设计中"Is a"关系非常重要，但它容易冲昏头脑，结果使用错误的继承造成错误设计。
"Liskov替换原则"正是保证继承能够被正确使用的方法。
Farhana:我明白了。有意思。
Shubho:是的，亲爱的，确实。我们看个例子：
Liskov替换原则类结构图
这里，KingFisher类扩展了Bird基类，并继承了Fly()方法，这看起来没问题。
现在看下面的例子：
违反Liskov替换原则类结构图
Ostrich(鸵鸟)是一种鸟(显然是),并从Bird类继承。它能飞吗？不能，这个设计就违反了LSP。
所以，即使在现实中看起来没问题，在类设计中，Ostrich不应该从Bird类继承，这里应该从Bird中分离一个不会飞的类，Ostrich应该继承与它。
Farhana:好，明白了。那么让我来试着指出为什么LSP这么重要：
如果没有LSP，类继承就会混乱；如果子类作为一个参数传递给方法，将会出现未知行为；
如果没有LSP，适用与基类的单元测试将不能成功用于测试子类；
对吗？
Shubho:非常正确。你能设计对象，使用LSP做为一个检查工作来测试继承是否正确。
接口分离原则
Shubho:今天我们学习"接口分离原则",这是海报：
接口分离原则海报
Farhana:这是什么意思？
Shubho:它的意思是："客户端不应该被迫依赖于它们不用的接口。"
Farhana:请解释一下。
Shubho:当然，这是解释：
假设你想买个电视机，你有两个选择。一个有很多开关和按钮，它们看起来很混乱，且好像对你来说没必要。另一个只有几个开关和按钮，它们很友好，且适合你使用。假定两个电视机提供同样的功能，你会选哪一个？
Farhana:当然是只有几个开关和按钮的第二个。
Shubho:对，但为什么？
Farhana:因为我不需要那些看起来混乱又对我没用的开关和按钮。

Shubho:以便外部能够指导这些类有哪些可用的功能,客户端代码也能根据接口来设计.现在,如果接口太大,包含很多暴露的方法,在外界看来会很混乱.接口包含太多的方法也使其可用性降低,像这种包含了无用方法的"胖接口"会增加类之间的耦合.你通过接口暴露类的功能,对.同样地,假设你有一些类,
这也引起了其他问题.如果一个类想实现该接口,那么它需要实现所有的方法,尽管有些对它来说可能完全没用.所以说这么做会在系统中引入不必要的复杂度,降低可维护性或鲁棒性.
接口隔离原则确保实现的接口有他们共同的职责,它们是明确的,易理解的,可复用的.
Farhana:你的意思是接口应该仅包含必要的方法,而不该包含其它的.我明白了.
Shubho:非常正确.一起看个例子.
下面是违反接口隔离原则的一个胖接口

注意到IBird接口包含很多鸟类的行为,包括Fly()行为.现在如果一个Bird类(如Ostrich)实现了这个接口，那么它需要实现不必要的Fly()行为(Ostrich不会飞).
Farhana:确实如此。那么这个接口必须拆分了？
Shubho:是的。这个"胖接口"应该拆分未两个不同的接口，IBird和IFlyingBird,IFlyingBird继承自IBird.

这里如果一种鸟不会飞(如Ostrich)，那它实现IBird接口。如果一种鸟会飞(如KingFisher)，那么它实现IFlyingBird.
Farhana:所以回头看包含了很多开关和按钮的电视机的例子，电视机制造商应该有一个电视机的图纸，开关和按钮都在这个方案里。不论任何时候，当他们向制造一种新款电视机时，如果他们想复用这个图纸，他们将需要在这个方案里添加更多的开关和按钮。那么他们将没法复用这个方案，对吗？
Shubho:对的。
Farhana:如果他们确实需要复用方案，它们应当把电视机的图纸份为更小部分，以便在任何需要造新款电视机的时候复用这点小部分。
Shubho:你理解了。
依赖倒置原则
Shubho:这是SOLID原则里最后一个原则。这是海报

它的意思是：高层模块不应该依赖底层模块，两者都应该依赖其抽象
Shubho:考虑一个现实中的例子。你的汽车是由很多如引擎，车轮，空调和其它等部件组成，对吗？
Farhana:是的
Shubho:好，它们没有一个是严格的构建在一个单一单元里；换句话说，它们都是可插拔的，因此当引擎或车轮出问题时，你可以修理它(而不需要修理其它部件),甚至可以换一个。
在替换时，你仅需要确保引擎或车轮符合汽车的设计(如汽车能使用任何1500CC的引擎或任何18寸的车轮)。
当然，汽车也可能允许你在1500CC引擎的地方安装一个2000CC的引擎，事实上对某些制造商(如丰田汽车)是一样的。
现在，如果你的汽车的零部件不具备可插拔性会有什么不同？
Farhana:那会很可怕！因为如果汽车的引擎出故障了，你可能修理整部车或者需要买一个新的。
Shubho:是的，那么该如何做到"可插拔性"呢？
Farhana:这里抽象是关键，对吗？
Shubho:是的，在现实中，汽车是高级模块或实体，它依赖于低级模块或实体，如引擎或车轮。
相比直接依赖于引擎或车轮，汽车应依赖于某些抽象的有规格的引擎或车轮，以便于如果任何引擎或车轮符合抽象，那么它们都能组合到汽车中，汽车也能跑动。
一起看下面的类图

Shubho:注意到上面Car类有两个属性，它们都是抽象类型(接口)。引擎和车轮是可插拔的，因为汽车能接受任何实现了声明接口的对象，并且Car类不需要做任何改动。
Farhana:所以，如果代码中不用依赖倒置，我们将面临如下风险：
使用低级类会破环高级代码；
当低级类变化时需要很多时间和代价来修改高级代码；
产生低复用的代码；
Shubho:你完全掌握了，亲爱的！
总结
Shubho：除SOLID原则外还有很多其它的面向对象原则。如：
"组合替代继承":这是说相对于继承，要更倾向于使用组合；
"笛米特法则"：这是说"你的类对其它类知道的越少越好"；
"共同封闭原则"：这是说"相关类应该打包在一起"；
"稳定抽象原则"：这是说"类越稳定，越应该由抽象类组成";
Farhana:我应该学习那些原则吗？
Shubho:当然可以。你可以从整个网上学习。仅仅需要Google一下那些原则，然后尝试理解它。当然如果有需要，尽管问我。
Farhana:在那些设计原则之上我听说过很多设计模式。
Shubho:对的。设计模式只是对一些经常出现的场景的一些通用设计建议。这些灵感主要来自于面向对象原则。你可以把设计模式看作"框架",把OOD原则看作"规范".
Farhana:那么接下去我将学习设计模式吗？
Shubho:是的，亲爱的。
Farhana:那会很有意思，对吗？
Shubho:是，那确实令人兴奋。

本文链接