jQuery.extend和jQuery.fn.extend的区别，其实从这两个办法本身也就可以看出来。很多地方说的也不详细。这里详细说说之间的区别.

1. 我们先把jQuery看成了一个类，这样好理解一些。

jQuery.extend()，是扩展的jQuery这个类。

假设我们把jQuery这个类看成是人类，能吃饭能喝水能跑能跳，现在我们用jQuery.extend这个方法给这个类拓展一个能唱歌的技能。这样的话，不论是男人，女人，xx人…..等能继承这个技能（方法）了。

可以如下图这样写着：

2. 然后：$.liu();这样就能打印出来”liu“这个字符串

代码在下面：

3. 这说明啥啊，这说明.liu()变成了jQuery这个类本身的方法（object）嘛。他现在能”唱歌“了。但是吧，这个能力啊，只有代表全人类的 jQuery 这个类本身，才能用啊。你个人想用，你张三李四王五麻六，你个小草民能代表全人类嘛？

所以啊，这个扩展也就是所谓的静态方法。只跟这个 类 本身有关。跟你具体的实例化对象是没关系滴。

我们再看看jQuery.fn.extend()这个方法。

从字面理解嘛，这个拓展的是jQuery.fn的方法。

jQuery.fn是啥玩意呢？

源码如下

4. 哦，原来jQuery.fn=jQuery.prototype，就是原型啊。

那就一目了然了，jQuery.fn.extend拓展的是jQuery对象（原型的）的方法啊！

对象是啥？就是类的实例化嘛，例如

$(“#abc”)

这个玩意就是一个实例化的jQuery对象嘛。

那就是说，jQuery.fn.extend拓展的方法，你得用在jQuery对象上面才行啊！他得是张三李四王五痳六这些实例化的对象才能用啊。

说白了就是得这么用（假设xyz()是拓展的方法）：

$(‘selector’).xyz();

你要是这么用$.xyz()；是会出错误滴。

代码看下面图片：

转： http://jingyan.baidu.com/article/fec4bce259ef67f2608d8b10.html

提供给从svn转git的开发人员参考

Git与Subversion的命令对比表

※1. SVN的revert是用来取消修改，但Git的revert是用来消除提交。所以即使是同样的命令，在SVN和Git里的含义是不同的。

篇文章是对php中的foreach问题进行了详细的分析介绍，需要的朋友参考下

前言： php4中引入了foreach结构，这是一种遍历数组的简单方式。相比传统的for循环，foreach能够更加便捷的获取键值对。在php5之前，foreach仅能用于数组；php5之后，利用foreach还能遍历对象（详见：遍历对象）。本文中仅讨论遍历数组的情况。foreach虽然简单，不过它可能会出现一些意外的行为，特别是代码涉及引用的情况下。

下面列举了几种case，有助于我们进一步认清foreach的本质。

问题1：

$arr = array(1,2,3);
foreach($arr as $k => &$v) {
$v = $v * 2;
}
// now $arr is array(2, 4, 6)
foreach($arr as $k => $v) {
echo "$k", " => ", "$v";
}

先从简单的开始，如果我们尝试运行上述代码，就会发现最后输出为0=>2  1=>4  2=>4 。

为何不是0=>2  1=>4  2=>6 ？

其实，我们可以认为 foreach($arr as $k => $v) 结构隐含了如下操作，分别将数组当前的’键’和当前的’值’赋给变量$k和$v。具体展开形如：

foreach($arr as $k => $v){
//在用户代码执行之前隐含了2个赋值操作
$v = currentVal();
$k = currentKey();
//继续运行用户代码
……
}

根据上述理论，现在我们重新来分析下第一个foreach：

第1遍循环，由于$v是一个引用，因此$v = &$arr[0]，$v=$v*2相当于$arr[0]*2，因此$arr变成2,2,3

一、垃圾回收的必要性

下面这段话引自《JavaScript权威指南（第四版）》

_　　由于字符串、对象和数组没有固定大小，所有当他们的大小已知时，才能对他们进行动态的存储分配。JavaScript程序每次创建字符串、数组或对象时，解释器都必须分配内存来存储那个实体。只要像这样动态地分配了内存，最终都要释放这些内存以便他们能够被再用，否则，JavaScript的解释器将会消耗完系统中所有可用的内存，造成系统崩溃。_

这段话解释了为什么需要系统需要垃圾回收，JS不像C/C++，他有自己的一套垃圾回收机制（Garbage Collection）。JavaScript的解释器可以检测到何时程序不再使用一个对象了，当他确定了一个对象是无用的时候，他就知道不再需要这个对象，可以把它所占用的内存释放掉了。例如：

var a = "before";
var b = "override a";
var a = b; //重写a

这段代码运行之后，“before”这个字符串失去了引用（之前是被a引用），系统检测到这个事实之后，就会释放该字符串的存储空间以便这些空间可以被再利用。

二、垃圾回收原理浅析

现在各大浏览器通常用采用的垃圾回收有两种方法：标记清除、引用计数。

1、标记清除

这是javascript中最常用的垃圾回收方式。当变量进入执行环境是，就标记这个变量为“进入环境”。从逻辑上讲，永远不能释放进入环境的变量所占用的内存，因为只要执行流进入相应的环境，就可能会用到他们。当变量离开环境时，则将其标记为“离开环境”。 垃圾收集器在运行的时候会给存储在内存中的所有变量都加上标记。然后，它会去掉环境中的变量以及被环境中的变量引用的标记。而在此之后再被加上标记的变量将被视为准备删除的变量，原因是环境中的变量已经无法访问到这些变量了。最后。垃圾收集器完成内存清除工作，销毁那些带标记的值，并回收他们所占用的内存空间。

关于这一块，建议读读 Tom大叔的几篇文章，关于作用域链的一些知识详解，读完差不多就知道了，哪些变量会被做标记。

2、引用计数

另一种不太常见的垃圾回收策略是引用计数。引用计数的含义是跟踪记录每个值被引用的次数。当声明了一个变量并将一个引用类型赋值给该变量时，则这个值的引用次数就是1。相反，如果包含对这个值引用的变量又取得了另外一个值，则这个值的引用次数就减1。当这个引用次数变成0时，则说明没有办法再访问这个值了，因而就可以将其所占的内存空间给收回来。这样，垃圾收集器下次再运行时，它就会释放那些引用次数为0的值所占的内存。

但是用这种方法存在着一个问题，下面来看看代码：

function problem() {
    var objA = new Object();
    var objB = new Object();

    objA.someOtherObject = objB;
    objB.anotherObject = objA;
}

在这个例子中，objA和objB通过各自的属性相互引用；也就是说这两个对象的引用次数都是2。在采用引用计数的策略中，由于函数执行之后，这两个对象都离开了作用域，函数执行完成之后，objA和objB还将会继续存在，因为他们的引用次数永远不会是0。这样的相互引用如果说很大量的存在就会导致大量的内存泄露。

我们知道，IE中有一部分对象并不是原生JavaScript对象。例如，其BOM和DOM中的对象就是使用C++以COM（Component Object Model，组件对象）对象的形式实现的，而COM对象的垃圾回收器就是采用的引用计数的策略。因此，即使IE的Javascript引擎使用标记清除的策略来实现的，但JavaScript访问的COM对象依然是基于引用计数的策略的。说白了，只要IE中涉及COM对象，就会存在循环引用的问题。看看下面的这个简单的例子：

var element = document.getElementById("some_element");
var myObj =new Object();
myObj.element = element;
element.someObject = myObj;

上面这个例子中，在一个DOM元素(element)与一个原生JavaScript对象(myObj)之间建立了循环引用。其中，变量myObj有一个名为element的属性指向element；而变量element有一个名为someObject的属性回指到myObj。由于循环引用，即使将例子中的DOM从页面中移除，内存也永远不会回收。

不过上面的问题也不是不能解决，我们可以手动切断他们的循环引用。

myObj.element = null;
element.someObject =null;

这样写代码的话就可以解决循环引用的问题了，也就防止了内存泄露的问题。

使用 docker commit 来扩展一个镜像比较简单，但是不方便在一个团队中分享。我们可以使用 docker build 来创建一个新的镜像。为此，首先需要创建一个 Dockerfile，包含一些如何创建镜像的指令。

新建一个目录和一个 Dockerfile

 $ mkdir sinatra
 $ cd sinatra
 $ touch Dockerfile

Dockerfile 中每一条指令都创建镜像的一层，例如：

 # This is a comment
 FROM ubuntu:14.04
 MAINTAINER Docker Newbee
 RUN apt-get -qq update
 RUN apt-get -qqy install ruby ruby-dev
 RUN gem install sinatra

Dockerfile 基本的语法是

• 使用#来注释
• FROM 指令告诉 Docker 使用哪个镜像作为基础
• 接着是维护者 MAINTAINER 的信息
• RUN开头的指令会在创建中运行，比如安装一个软件包，在这里使用 apt-get 来安装了一些软件

编写完成 Dockerfile 后可以使用 docker build 来生成镜像。

 $ sudo docker build -t="ouruser/sinatra:v2" .
 Uploading context 2.56 kB
 Uploading context
 Step 0 : FROM ubuntu:14.04
 ---> 99ec81b80c55
 Step 1 : MAINTAINER Newbee
 ---> Running in 7c5664a8a0c1
 ---> 2fa8ca4e2a13
 Removing intermediate container 7c5664a8a0c1
 Step 2 : RUN apt-get -qq update
 ---> Running in b07cc3fb4256
 ---> 50d21070ec0c
 Removing intermediate container b07cc3fb4256
 Step 3 : RUN apt-get -qqy install ruby ruby-dev
 ---> Running in a5b038dd127e
 Selecting previously unselected package libasan0:amd64.
 (Reading database ... 11518 files and directories currently installed.)
 Preparing to unpack .../libasan0_4.8.2-19ubuntu1_amd64.deb ...
 Setting up ruby (1:1.9.3.4) ...
 Setting up ruby1.9.1 (1.9.3.484-2ubuntu1) ...
 Processing triggers for libc-bin (2.19-0ubuntu6) ...
 ---> 2acb20f17878
 Removing intermediate container a5b038dd127e
 Step 4 : RUN gem install sinatra
 ---> Running in 5e9d0065c1f7
 . . .
 Successfully installed rack-protection-1.5.3
 Successfully installed sinatra-1.4.5
 4 gems installed
 ---> 324104cde6ad
 Removing intermediate container 5e9d0065c1f7
 Successfully built 324104cde6ad

其中 -t 标记来添加 tag，指定新的镜像的用户信息。

一、下载镜像 image

可以使用 docker pull 命令来从仓库获取所需要的镜像。

下面的例子将从 Docker Hub 仓库下载一个 Ubuntu 12.04 操作系统的镜像。

 $ sudo docker pull ubuntu:12.04
 Pulling repository ubuntu
 ab8e2728644c: Pulling dependent layers
 511136ea3c5a: Download complete
 5f0ffaa9455e: Download complete
 a300658979be: Download complete
 904483ae0c30: Download complete
 ffdaafd1ca50: Download complete
 d047ae21eeaf: Download complete

下载过程中，会输出获取镜像的每一层信息。

该命令实际上相当于

$ sudo docker pull registry.hub.docker.com/ubuntu:12.04

命令，即从注册服务器registry.hub.docker.com 中的 ubuntu 仓库来下载标记为 12.04 的镜像。

有时候官方仓库注册服务器下载较慢，可以从其他仓库下载。 从其它仓库下载时需要指定完整的仓库注册服务器地址。例如

 $ sudo docker pull dl.dockerpool.com:5000/ubuntu:12.04
 Pulling dl.dockerpool.com:5000/ubuntu
 ab8e2728644c: Pulling dependent layers
 511136ea3c5a: Download complete
 5f0ffaa9455e: Download complete
 a300658979be: Download complete
 904483ae0c30: Download complete
 ffdaafd1ca50: Download complete
 d047ae21eeaf: Download complete

二、利用镜像image 创建容器

完成后，即可随时使用该镜像了，例如创建一个容器，让其中运行 bash 应用。

官方命令： https://docs.docker.com/reference/

1. 查看docker信息（version、info）

# 查看docker版本
$docker version

# 显示docker系统的信息
$docker info

2. 对image的操作（search、pull、images、rmi、history）

# 检索image(sudo docker pull ubuntu:12.04,该命令实际上相当于 $ sudo docker pull registry.hub.docker.com/ubuntu:12.04 命令，即从注册服务器 registry.hub.docker.com 中的 ubuntu 仓库来下载标记为 12.04 的镜像。)
$docker search image_name[:tag]

# 下载image
$docker pull image_name

# 列出镜像列表; -a, --all=false Show all images; --no-trunc=false Don't truncate output; -q, --quiet=false Only show numeric IDs
$docker images

# 镜像重命名
docker tag ImageID(镜像id) REPOSITORY:TAG（仓库：标签）

# 删除一个或者多个镜像; -f, --force=false Force; --no-prune=false Do not delete untagged parents （注意这里是 rmi 命令，不是 rm）
$docker rmi image_name

# 显示一个镜像的历史; --no-trunc=false Don't truncate output; -q, --quiet=false Only show numeric IDs
$docker history image_name

3. 启动容器（run）

docker容器可以理解为在沙盒中运行的进程。这个沙盒包含了该进程运行所必须的资源，包括文件系统、系统类库、shell 环境等等。但这个沙盒默认是不会运行任何程序的。你需要在沙盒中运行一个进程来启动某一个容器。这个进程是该容器的唯一进程，所以当该进程结束的时候，容器也会完全的停止。

5分钟弄懂Docker！ http://www.csdn.net/article/2014-07-02/2820497-what%27s-docker

Docker入门与实践： https://www.gitbook.com/book/yeasy/docker_practice

在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的容器就像操作一个快速轻量级的虚拟机一样简单。

下面的图片比较了 Docker 和传统虚拟化方式的不同之处，可见容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统方式则是在硬件层面实现。

Virtual Machines是由虚拟机管理程序来实现对 虚拟机 的管理，而docker是用docker Engine来实现对 应用 的管理。可以理解为一个套硬件的管理，一个是软件的管理。

 对比传统虚拟机总结

基本概念

Docker 包括三个基本概念

• 镜像（Image）
• 容器（Container）
• 仓库（Repository）

理解了这三个概念，就理解了 Docker 的整个生命周期。

Docker 镜像

Docker 镜像就是一个只读的模板。

例如：一个镜像可以包含一个完整的 ubuntu 操作系统环境，里面仅安装了 Apache 或用户需要的其它应用程序。

镜像可以用来创建 Docker 容器。

Docker 提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下载一个已经做好的镜像来直接使用。

Docker 容器

Docker 利用容器来运行应用。

容器是从镜像创建的运行实例。它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

可以把容器看做是一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

*注：镜像是只读的，容器在启动的时候创建一层可写层作为最上层。

Docker 仓库

仓库是集中存放镜像文件的场所。有时候会把仓库和仓库注册服务器（Registry）混为一谈，并不严格区分。实际上，仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub，存放了数量庞大的镜像供用户下载。 国内的公开仓库包括 Docker Pool 等，可以提供大陆用户更稳定快速的访问。

当然，用户也可以在本地网络内创建一个私有仓库。

当用户创建了自己的镜像之后就可以使用 push 命令将它上传到公有或者私有仓库，这样下次在另外一台机器上使用这个镜像时候，只需要从仓库上 pull 下来就可以了。

导读

在MySQL里，聚集索引和非聚集索引分别是什么意思，有什么区别？

在MySQL中，InnoDB引擎表是（聚集）索引组织表（clustered index organize table），而MyISAM引擎表则是堆组织表（heap organize table）。

也有人把聚集索引称为聚簇索引。

当然了，聚集索引的概念不是MySQL里特有的，其他数据库系统也同样有。

简言之，聚集索引是一种索引组织形式，索引的键值逻辑顺序决定了表数据行的物理存储顺序，而非聚集索引则就是普通索引了，仅仅只是对数据列创建相应的索引，不影响整个表的物理存储顺序。

我们先来看看两种存储形式的不同之处：

简单说，IOT表里数据物理存储顺序和主键索引的顺序一致，所以如果新增数据是离散的，会导致数据块趋于离散，而不是趋于顺序。而HOT表数据写入的顺序是按写入时间顺序存储的。 IOT表相比HOT表的优势是：

• 范围查询效率更高；

• 数据频繁更新（聚集索引本身不更新）时，更不容易产生碎片；

• 特别适合有一小部分热点数据频繁读写的场景；

• 通过主键访问数据时快速可达；

IOT表的不足则有：

• 数据变化如果是离散为主的话，那么效率会比HOT表差；

HOT表的不足有：

• 索引回表读开销很大；

• 大部分数据读取时随机的，无法保证被顺序读取，开销大；

每张InnoDB表只能创建一个聚集索引，聚集索引可以由一列或多列组成。

上面说过，InnoDB是聚集索引组织表，它的聚集索引选择规则是这样的：

1. 首先选择显式定义的主键索引做为聚集索引；
2. 如果没有，则选择第一个不允许NULL的唯一索引；
3. 还是没有的话，就采用InnoDB引擎内置的ROWID作为聚集索引；

我们来看看InnoDB主键索引的示意图： 图片来自高性能MySQL

可以看到，在这个索引结构的叶子节点中，节点key值是主键的值，而节点的value则存储其余列数据，以及额外的ROWID、rollback pointer、trx id等信息。

结合这个图，以及上面所述，我们可以知道：在InnoDB表中，其聚集索引相当于整张表，而整张表也是聚集索引。主键必然是聚集索引，而聚集索引则未必是主键。

MyISAM是堆组织表，它没有聚集索引的概念。

转： http://imysql.com/2015/10/29/mysql-faq-clustered-index.shtml

MySQL索引之主键索引： http://blog.haohtml.com/archives/16497

其实对于非专业的数据库操作人员来讲，例如软件开发人员，在很大程度上都搞不清楚数据库索引的一些基本知识，有些是知其一不知其二，或者是知其然不知其所以然。造成这种情况的主要原因我觉的是行业原因，有很多公司都有自己的DBA团队，他们会帮助你优化SQL，开发人员即使不懂优化问题也不大，所以开发人员对这方面也就不会下太多功夫去了解SQL优化，但如果公司没有这样的DBA呢，就只能靠程序员自己了。 最近突然想起前一阵和一朋友的聊天，当时他问我的问题是一个非常普通的问题：说说SQL聚集索引和非聚集索引的区别。

大家可能认为这个问题难度不大，认为太熟悉了，也许不会感兴趣，但你真能说清楚吗？其实要想说明白这两者的差别也不是三两句就说的清的，那天我也是觉的这问题太泛了，就随便说了其中的两个区别：

1. 聚集索引一个表只能有一个，而非聚集索引一个表可以存在多个，这个跟没问题没差别，一般人都知道。

2. 聚集索引存储记录是物理上连续存在，而非聚集索引是逻辑上的连续，物理存储并不连续，这个大家也都知道。

上面的两点从大的方面讲都是讲的通的，后面我们继续探讨，举一个实际点的例子，一个学生表student，里面是学生号id,学生姓名，学生所在城市ID，学生成绩(总分)。

• 问：如果想按姓名查询，如何做优化？

• 答：在姓名字段上建立索引。

• 问：建立什么类型的索引？

• 答：建立非聚集索引。

• 问：为什么？

• 答：一般有范围查询的需求，可以考虑在此字段上创建聚集索引。

• 问：学分有重复性，在学分字段上创建聚集索引能行吗？ ….沉思，不能创建吗？之前的项目好像真这样做过

• 答：应该可以吧。

• 问：聚集索引的约束是什么？

• 答：唯一性啊？

• 问：既然是唯一性，那么学分字段上还能创建聚集索引吗？….再次沉思，应该可以啊，但索引的约束又怎么说呢？

• 答：应该可以的，以前用过。

我自认为是对数据库索引知识有一定研究的，但可能是有两年没实际接触SQL的原因，一时还真想不出具有说服力的解释，朋友们看到这能解答我的问题吗？

其实上面的我们需要搞清楚以下几个问题：

第一：聚集索引的约束是唯一性，是否要求字段也是唯一的呢？

分析：如果认为是的朋友，可能是受系统默认设置的影响，一般我们指定一个表的主键，如果这个表之前没有聚集索引，同时建立主键时候没有强制指定使用非聚集索引,SQL会默认在此字段上创建一个聚集索引，而主键都是唯一的，所以理所当然的认为创建聚集索引的字段也需要唯一。

结论：聚集索引可以创建在任何一列你想创建的字段上，这是从理论上讲，实际情况并不能随便指定，否则在性能上会是恶梦。

第二：为什么聚集索引可以创建在任何一列上，如果此表没有主键约束，即有可能存在重复行数据呢？

粗一看，这还真是和聚集索引的约束相背，但实际情况真可以创建聚集索引，分析其原因是：如果未使用 UNIQUE 属性创建聚集索引，数据库引擎将向表自动添加一个四字节 uniqueifier 列。必要时，数据库引擎 将向行自动添加一个 uniqueifier 值，使每个键唯一。此列和列值供内部使用，用户不能查看或访问。

第三：是不是聚集索引就一定要比非聚集索引性能优呢？

如果想查询学分在60-90之间的学生的学分以及姓名，在学分上创建聚集索引是否是最优的呢？

答：否。既然只输出两列，我们可以在学分以及学生姓名上创建联合非聚集索引，此时的索引就形成了覆盖索引，即索引所存储的内容就是最终输出的数据，这种索引在比以学分为聚集索引做查询性能更好。

第四：在数据库中通过什么描述聚集索引与非聚集索引的？

索引是通过二叉树的形式进行描述的，我们可以这样区分聚集与非聚集索引的区别：聚集索引的叶节点就是最终的数据节点，而非聚集索引的叶节仍然是索引节点，但它有一个指向最终数据的指针。

第五：在主键是创建聚集索引的表在数据插入上为什么比主键上创建非聚集索引表速度要慢？

有了上面第四点的认识，我们分析这个问题就有把握了，在有主键的表中插入数据行，由于有主键唯一性的约束，所以需要保证插入的数据没有重复。我们来比较下主键为聚集索引和非聚集索引的查找情况:聚集索引由于索引叶节点就是数据页，所以如果想检查主键的唯一性，需要遍历所有数据节点才行，但非聚集索引不同，由于非聚集索引上已经包含了主键值，所以查找主键唯一性，只需要遍历所有的索引页就行，这比遍历所有数据行减少了不少IO消耗。这就是为什么主键上创建非聚集索引比主键上创建聚集索引在插入数据时要快的真正原因。

好了，讲这这些，不知道大家是否真的了解SQL的聚焦索引，我也是数据库新手(从使用时间上来讲也不算新了，哈哈)，不专业，有什么不对的地方，希望大家批评指正，下篇我会分析一些数据库访问索引的情况，有图的情况下，也许看的更加明白。

http://imysql.com/?s=%E8%81%9A%E9%9B%86%E7%B4%A2%E5%BC%95

http://www.cnblogs.com/mybluesky99/archive/2011/04/21/2023629.html

MySQL聚簇索引&聚集索引&索引组织表

http://www.cnblogs.com/hustcat/archive/2009/10/28/1591648.html

聚簇索引和聚集索引(Clustered Index)

说起索引，不能不说B+树。

引用： http://blog.codinglabs.org/articles/theory-of-mysql-index.html

MySQL官方对索引的定义为：索引（Index）是帮助MySQL高效获取数据的数据结构。提取句子主干，就可以得到索引的本质：索引是数据结构。

我们知道，数据库查询是数据库的最主要功能之一。我们都希望查询数据的速度能尽可能的快，因此数据库系统的设计者会从查询算法的角度进行优化。最基本的查询算法当然是顺序查找（linear search），这种复杂度为O(n)的算法在数据量很大时显然是糟糕的，好在计算机科学的发展提供了很多更优秀的查找算法，例如二分查找（binary search），二叉树查找（binary tree search）等。如果稍微分析一下会发现，每种查找算法都只能应用于特定的数据结构之上，例如二分查找要求被检索数据有序，而二叉树查找只能应用于二叉查找树上，但是数据本身的组织结构不可能完全满足各种数据结构（例如，理论上不可能同时将两列都按顺序进行组织），所以，在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法。这种数据结构，就是索引。

MySQL就普遍使用B+Tree实现其索引结构。

聚簇索引并不是一种单独的索引类型，而是一种数据存储方式。具体的细节依赖于其实现方式，但InnoDB的聚簇索引实际上在同一个结构中保存了B-Tree索引和数据行。

当表有聚簇索引时，他的数据行实际上存放在索引的叶子页（leaf page）中。术语 “聚簇”表示数据行和相邻的键值紧凑地存储在一起（这并非总成立）。

因为无法同时把数据行存放在两个不同的地方，索引一个表只能有一个聚簇索引。

注：叶子页面包含完整的元组，而内节点页面仅包含索引的列(索引的列为整型)。一些DBMS允许用户指定聚簇索引，但是MySQL的存储引擎到目前为止都不支持。InnoDB对主键建立聚簇索引。如果你不指定主键，InnoDB会用一个具有唯一且非空值的索引来代替。如果不存在这样的索引，InnoDB会定义一个隐藏的主键，然后对其建立聚簇索引。一般来说，DBMS都会以聚簇索引的形式来存储实际的数据，它是其它二级索引的基础。

索引组织表(Index Organized Table, IOT)

其实和聚簇索引说的是一个意思。

索引组织表（Index organized table, IOT）就是存储在一个索引结构中的表。与堆组织表无序存储不同的是，IOT中的数据按主键存储和排序。

相比堆组织表，索引组织表能够节省一部分空间，因为使用堆组织表时，我们必须为表和表的主键上的索引分别留出空间。而IOT则可以省去主键索引的开销，因为数据就是按顺序存储的，可以当做索引使。换句话说，如果你只会通过一个表的主键来访问这个表，这个表就适合创建成索引组织表。

举例：

1.一个客户有很多地址信息，客户是一个表，客户地址信息是另外一个表。读取一个客户地址信息的时候，如果这个客户的所有地址信息都存放在相邻的地方，读取速度就会快一些。这个时候，客户地址信息表适合创建成IOT。

2. 经常查看一支股票的最近几天的信息，股票信息一般是千万级别的数据，如果能够把最近几天的信息存放在一起就会快很多。

=======================END=======================

转： http://my.oschina.net/xinxingegeya/blog/474895

自动化能解放人类的双手，而且更重要的是，因为按照规定的流程来走，也减少了很多误操作的产生。不知道大家平时都是怎么样更新自己生产环境的代码的，FTP 覆盖旧文件、服务器定时任务去 build 最新的源码，还是有更高级的做法？

目前我在使用 Git Hook 来部署自己的项目。Git Hook 是 Git 提供的一个钩子，能被特定的事件触发后调用。其实，更通俗的讲，当你设置了 Git Hook 后，只要你的远程仓库收到一次 push 之后，Git Hook 就能帮你执行一次 bash 脚本。

Git的挂钩（Hook）主要包含：

• applypatch-msg
• post-update
• pre-rebase
• commit-msg
• pre-applypatch
• update
• post-commit
• pre-commit
• post-receive
• prepare-commit-msg

这里我们只需要使用 post-receive 这个 Hook：在接收 post(push)请求之后执行。

下面是我使用 Git Hook 进行简单的自动化部署，可能还有更高级的做法，大家自己去挖掘。

服务器上需要配置两个仓库，一个用于代码中转的远程仓库(testRepo)，一个用于用户访问的本地仓库(testDeploy)。这里的「远程仓库」并不等同于托管代码的「中央仓库」，这两个仓库都是为了自动同步代码并部署网站而存在。

一、在服务器初始化一个远程 Git 仓库(此仓库仅仅作为一个部署中转仓库，无其它用）

git init 和 git --bare init 初始化出来的仓库是完全不一样的，参考： http://blog.haohtml.com/archives/12265。

这里我们要通过 git --bare init 初始化一个远程仓库

$ cd ~
$ mkdir testRepo
$ cd testRepo
$ git --bare init

在服务器初始化一个本地 Git 仓库。

Git可以定制一些钩子，这些钩子可以在特定的情况下被执行，分为Client端的钩子和Server端的钩子。 Client 端钩子被operation触发，比如commit，merge等Server 端钩子被网络动作触发，比如pushed commits。

那么钩子是放在哪的呢？

在.git/hooks/文件夹下。当你init一个仓库的时候，下边会有一些钩子的例子，以.sample结尾。

那么钩子什么时候被执行，Git预定义了触发时机：

ClientSide hooks：

1 pre-commit，当执行commit动作时先执行此hook，可以用此hook做一些检查，比如代码风格检查，或者先跑测试。

2 prepare-commit-msg， 当commit时需要输入message前会触发此hook，可以用此hook来定制自己的default message信息。

3 commit-msg，当用户输入commit的message后被触发，可以用此hook校验message的信息，比如是否符合规定，有没有cr等。

4 post-commit, 当commit完成后被触发，可以用此hook发送 notification 等。

5 pre-rebase, rebase之前会被触发，可以用此hook来拒绝所有的已经push的commits进行rebase操作。

6 post-merge, 当merge成功后，会触发此hook。

7 pre-push, 当push时，remote refs被更新，但是在所有的objects传输前被触发。

8 pre-auto-gc, 当git gc –auto执行前被触发。在垃圾回收之前做一些验证或备份是挺不错的。

ServerSide hooks:

1 pre-receive, 当收到push动作之前会被执行。

2 update, 也是收到push动作之前被执行，但是有可能被执行多次，每个branch一次。

3 post-receive, 当push动作已经完成的时候会被触发，可以用此hook来 push notification等，比如发邮件，通知持续构建服务器等。

记住所有的hook都应该是可被执行的。

chmod u+x your_hook

所以你可以用shell脚本，perl，python等写钩子。

这样就避免了原始的在push文件以后总是需要到服务器上去git pull 才能更新网站内容的问题。

深入阅读： 使用 Git Hook 实现网站的自动部署

参考： http://git-scm.com/book/zh/v2/%E8%87%AA%E5%AE%9A%E4%B9%89-Git-Git-%E9%92%A9%E5%AD%90

http://flowtype.org/

对于flow的介绍可以参考： http://blog.jobbole.com/80364/

USR1亦通常被用来告知应用程序重载配置文件；例如，向Apache HTTP服务器发送一个

**USR1信号将导致以下步骤的发生： ** 停止接受新的连接，等待当前连接停止，重新载入配置文件，重新打开日志文件，重启服务器，从而实现相对平滑的不关机的更改。

以上摘自wiki：

呃，近日发现还有USR2，貌似这个USR1和2都可以用户自定义的，同样摘自上面的wiki：

在POSIX兼容的平台上，SIGUSR1和SIGUSR2是发送给一个进程的信号，它表示了用户定义的情况。它们的符号常量在头文件signal.h中定义。在不同的平台上，信号的编号可能发生变化，因此需要使用符号名称。kill -HUP pid 或者 killall -HUP pName： 其中pid是进程标识，pName是进程的名称 如果想要更改配置而不需停止并重新启动服务，可以使用上面两个命令。在对配置文件作必要的更改后，发出该命令以动态更新服务配置。 根据约定，当你发送一个挂起信号(信号1或HUP)时，大多数服务器进程(所有常用的进程)都会进行复位操作并重新加载它们的配置文件。