博客园_Andy Ge

jQuery设计思想

2011-12-23T07:09:00Z

日期： 2011年7月26日

jQuery是目前使用最广泛的javascript函数库。

据统计，全世界排名前100万的网站，有46%使用jQuery，远远超过其他库。微软公司甚至把jQuery作为他们的官方库。

对于网页开发者来说，学会jQuery是必要的。因为它让你了解业界最通用的技术，为将来学习更高级的库打下基础，并且确实可以很轻松地做出许多复杂的效果。

虽然jQuery上手简单，比其他库容易学会，但是要全面掌握，却不轻松。因为它涉及到网页开发的方方面面，提供的各种方法和内部变化有上千种之多。初学者常常感到，入门很方便，提高很困难。

目前，互联网上最好的jQuery入门教材，是Rebecca Murphey写的《jQuery基础》（jQuery Fundamentals）。在Google里搜索"jQuery 培训"，此书排在第一位。jQuery官方团队已经同意，把此书作为官方教程的基础。

这本书虽然是入门教材，但也足足有100多页。我对它做了一个详细的笔记，试图理清jQuery的设计思想，找出学习的脉络。我的目标是全面掌握jQuery，遇到问题的时候，心里有底，基本知道使用它的哪一个功能，然后可以迅速从手册中找到具体的写法。

下面就是我的笔记，它应该是目前网上不多的jQuery中文教程之一。你只需要一点javascript语言的基本知识，就能看懂它，在最短的时间里，掌握jQuery的所有主要方面（除了ajax和插件开发）。

===========================================

jQuery设计思想

原文网址：http://jqfundamentals.com/book/

阮一峰翻译整理

【目录】

一、选择网页元素

二、改变结果集

三、链式操作

四、元素的操作：取值和赋值

五、元素的操作：移动

六、元素的操作：复制、删除和创建

七、工具方法

八、事件操作

九、特殊效果

【正文】

一、选择网页元素

jQuery的基本设计思想和主要用法，就是"选择某个网页元素，然后对其进行某种操作"。这是它区别于其他Javascript库的根本特点。

使用jQuery的第一步，往往就是将一个选择表达式，放进构造函数jQuery()（简写为$），然后得到被选中的元素。

选择表达式可以是CSS选择器：

$(document) //选择整个文档对象
$('#myId') //选择ID为myId的网页元素
$('div.myClass') // 选择class为myClass的div元素
$('input[name=first]') // 选择name属性等于first的input元素

也可以是jQuery特有的表达式：

$('a:first') //选择网页中第一个a元素
$('tr:odd') //选择表格的奇数行
$('#myForm :input') // 选择表单中的input元素
$('div:visible') //选择可见的div元素
$('div:gt(2)') // 选择所有的div元素，除了前三个
$('div:animated') // 选择当前处于动画状态的div元素

二、改变结果集

jQuery设计思想之二，就是提供各种强大的过滤器，对结果集进行筛选，缩小选择结果。

$('div').has('p'); // 选择包含p元素的div元素

$('div').not('.myClass'); //选择class不等于myClass的div元素

$('div').filter('.myClass'); //选择class等于myClass的div元素

$('div').first(); //选择第1个div元素

$('div').eq(5); //选择第6个div元素

有时候，我们需要从结果集出发，移动到附近的相关元素，jQuery也提供了在DOM树上的移动方法：

$('div').next('p'); //选择div元素后面的第一个p元素

$('div').parent(); //选择div元素的父元素

$('div').closest('form'); //选择离div最近的那个form父元素

$('div').children(); //选择div的所有子元素

$('div').siblings(); //选择div的同级元素

三、链式操作

jQuery设计思想之三，就是最终选中网页元素以后，可以对它进行一系列操作，并且所有操作可以连接在一起，以链条的形式写出来，比如：

$('div').find('h3').eq(2).html('Hello');

分解开来，就是下面这样：

$('div') //找到div元素

.find('h3') //选择其中的h3元素

.eq(2) //选择第3个h3元素

.html('Hello'); //将它的内容改为Hello

这是jQuery最令人称道、最方便的特点。它的原理在于每一步的jQuery操作，返回的都是一个jQuery对象，所以不同操作可以连在一起。

jQuery还提供了.end()方法，使得结果集可以后退一步：

$('div')

.find('h3')

.eq(2)

.html('Hello')

.end() //退回到选中所有的h3元素的那一步

.eq(0) //选中第一个h3元素

.html('World'); //将它的内容改为World

四、元素的操作：取值和赋值

操作网页元素，最常见的需求是取得它们的值，或者对它们进行赋值。

jQuery设计思想之四，就是使用同一个函数，来完成取值（getter）和赋值（setter），即"取值器"与"赋值器"合一。到底是取值还是赋值，由函数的参数决定。

$('h1').html(); //html()没有参数，表示取出h1的值

$('h1').html('Hello'); //html()有参数Hello，表示对h1进行赋值

常见的取值和赋值函数如下：

.html() 取出或设置html内容

.text() 取出或设置text内容

.attr() 取出或设置某个属性的值

.width() 取出或设置某个元素的宽度

.height() 取出或设置某个元素的高度

.val() 取出某个表单元素的值

需要注意的是，如果结果集包含多个元素，那么赋值的时候，将对其中所有的元素赋值；取值的时候，则是只取出第一个元素的值（.text()例外，它取出所有元素的text内容）。

五、元素的操作：移动

jQuery设计思想之五，就是提供两组方法，来操作元素在网页中的位置移动。一组方法是直接移动该元素，另一组方法是移动其他元素，使得目标元素达到我们想要的位置。

假定我们选中了一个div元素，需要把它移动到p元素后面。

第一种方法是使用.insertAfter()，把div元素移动p元素后面：

$('div').insertAfter('p');

第二种方法是使用.after()，把p元素加到div元素前面：

$('p').after('div');

表面上看，这两种方法的效果是一样的，唯一的不同似乎只是操作视角的不同。但是实际上，它们有一个重大差别，那就是返回的元素不一样。第一种方法返回div元素，第二种方法返回p元素。你可以根据需要，选择到底使用哪一种方法。

使用这种模式的操作方法，一共有四对：

.insertAfter()和.after()：在现存元素的外部，从后面插入元素

.insertBefore()和.before()：在现存元素的外部，从前面插入元素

.appendTo()和.append()：在现存元素的内部，从后面插入元素

.prependTo()和.prepend()：在现存元素的内部，从前面插入元素

六、元素的操作：复制、删除和创建

除了元素的位置移动之外，jQuery还提供其他几种操作元素的重要方法。

复制元素使用.clone()。

删除元素使用.remove()和.detach()。两者的区别在于，前者不保留被删除元素的事件，后者保留，有利于重新插入文档时使用。

清空元素内容（但是不删除该元素）使用.empty()。

创建新元素的方法非常简单，只要把新元素直接传入jQuery的构造函数就行了：

$('<p>Hello</p>');

$('<li class="new">new list item</li>');

$('ul').append('<li>list item</li>');

七、工具方法

jQuery设计思想之六：除了对选中的元素进行操作以外，还提供一些与元素无关的工具方法（utility）。不必选中元素，就可以直接使用这些方法。

如果你懂得Javascript语言的继承原理，那么就能理解工具方法的实质。它是定义在jQuery构造函数上的方法，即jQuery.method()，所以可以直接使用。而那些操作元素的方法，是定义在构造函数的prototype对象上的方法，即jQuery.prototype.method()，所以必须生成实例（即选中元素）后使用。如果不理解这种区别，问题也不大，只要把工具方法理解成，是像javascript原生函数那样，可以直接使用的方法就行了。

常用的工具方法有以下几种：

$.trim() 去除字符串两端的空格。

$.each() 遍历一个数组或对象。

$.inArray() 返回一个值在数组中的索引位置。如果该值不在数组中，则返回-1。

$.grep() 返回数组中符合某种标准的元素。

$.extend() 将多个对象，合并到第一个对象。

$.makeArray() 将对象转化为数组。

$.type() 判断对象的类别（函数对象、日期对象、数组对象、正则对象等等）。

$.isArray() 判断某个参数是否为数组。

$.isEmptyObject() 判断某个对象是否为空（不含有任何属性）。

$.isFunction() 判断某个参数是否为函数。

$.isPlainObject() 判断某个参数是否为用"{}"或"new Object"建立的对象。

$.support() 判断浏览器是否支持某个特性。

八、事件操作

jQuery设计思想之七，就是把事件直接绑定在网页元素之上。

$('p').click(function(){

alert('Hello');

});

目前，jQuery主要支持以下事件：

.blur() 表单元素失去焦点。

.change() 表单元素的值发生变化

.click() 鼠标单击

.dblclick() 鼠标双击

.focus() 表单元素获得焦点

.focusin() 子元素获得焦点

.focusout() 子元素失去焦点

.hover() 同时为mouseenter和mouseleave事件指定处理函数

.keydown() 按下键盘（长时间按键，只返回一个事件）

.keypress() 按下键盘（长时间按键，将返回多个事件）

.keyup() 松开键盘

.load() 元素加载完毕

.mousedown() 按下鼠标

.mouseenter() 鼠标进入（进入子元素不触发）

.mouseleave() 鼠标离开（离开子元素不触发）

.mousemove() 鼠标在元素内部移动

.mouseout() 鼠标离开（离开子元素也触发）

.mouseover() 鼠标进入（进入子元素也触发）

.mouseup() 松开鼠标

.ready() DOM加载完成

.resize() 浏览器窗口的大小发生改变

.scroll() 滚动条的位置发生变化

.select() 用户选中文本框中的内容

.submit() 用户递交表单

.toggle() 根据鼠标点击的次数，依次运行多个函数

.unload() 用户离开页面

以上这些事件在jQuery内部，都是.bind()的便捷方式。使用.bind()可以更灵活地控制事件，比如为多个事件绑定同一个函数：

$('input').bind(

'click change', //同时绑定click和change事件

function() {

alert('Hello');

}

);

有时，你只想让事件运行一次，这时可以使用.one()方法。

$("p").one("click", function() {

alert("Hello"); //只运行一次，以后的点击不会运行

});

.unbind()用来解除事件绑定。

$('p').unbind('click');

所有的事件处理函数，都可以接受一个事件对象（event object）作为参数，比如下面例子中的e：

$("p").click(function(e) {

alert(e.type); // "click"

});

这个事件对象有一些很有用的属性和方法：

event.pageX 事件发生时，鼠标距离网页左上角的水平距离

event.pageY 事件发生时，鼠标距离网页左上角的垂直距离

event.type 事件的类型（比如click）

event.which 按下了哪一个键

event.data 在事件对象上绑定数据，然后传入事件处理函数

event.target 事件针对的网页元素

event.preventDefault() 阻止事件的默认行为（比如点击链接，会自动打开新页面）

event.stopPropagation() 停止事件向上层元素冒泡

在事件处理函数中，可以用this关键字，返回事件针对的DOM元素：

$('a').click(function(e) {
if ($(this).attr('href').match('evil')) { //如果确认为有害链接

e.preventDefault(); //阻止打开

$(this).addClass('evil'); //加上表示有害的class

}

});

有两种方法，可以自动触发一个事件。一种是直接使用事件函数，另一种是使用.trigger()或.triggerHandler()。

$('a').click();

$('a').trigger('click');

九、特殊效果

最后，jQuery允许对象呈现某些特殊效果。

$('h1').show(); //展现一个h1标题

常用的特殊效果如下：

.fadeIn() 淡入

.fadeOut() 淡出

.fadeTo() 调整透明度

.hide() 隐藏元素

.show() 显示元素

.slideDown() 向下展开

.slideUp() 向上卷起

.slideToggle() 依次展开或卷起某个元素

.toggle() 依次展示或隐藏某个元素

除了.show()和.hide()，所有其他特效的默认执行时间都是400ms（毫秒），但是你可以改变这个设置。

$('h1').fadeIn(300); // 300毫秒内淡入

$('h1').fadeOut('slow'); // 缓慢地淡出

在特效结束后，可以指定执行某个函数。

$('p').fadeOut(300, function() { $(this).remove(); });

更复杂的特效，可以用.animate()自定义。

$('div').animate(

{

left : "+=50", //不断右移

opacity : 0.25 //指定透明度

},

300, // 持续时间

function() { alert('done!'); } //回调函数

);

.stop()和.delay()用来停止或延缓特效的执行。

$.fx.off如果设置为true，则关闭所有网页特效。

本文链接

jQuery最佳实践

2011-12-23T07:05:00Z

那篇文章是一篇入门教程，从设计思想的角度，讲解"怎么使用jQuery"。今天的文章则是更进一步，讲解"如何用好jQuery"。

我主要参考了Addy Osmani的PPT《提高jQuery性能的诀窍》（jQuery Proven Performance Tips And Tricks）。他是jQuery开发团队的成员，具有一定的权威性，提出的结论都有测试数据支持，非常有价值。

==============================================

jQuery最佳实践

阮一峰整理

1. 使用最新版本的jQuery

jQuery的版本更新很快，你应该总是使用最新的版本。因为新版本会改进性能，还有很多新功能。

下面就来看看，不同版本的jQuery性能差异有多大。这里是三条最常见的jQuery选择语句：

$('.elem')

$('.elem', context)

context.find('.elem')

我们用1.4.2、1.4.4、1.6.2三个版本的jQuery测试，看看浏览器在1秒内能够执行多少次。结果如下：

可以看到，1.6.2版本的运行次数，远远超过两个老版本。尤其是第一条语句，性能有数倍的提高。

其他语句的测试，比如.attr("value")和.val()，也是新版本的jQuery表现好于老版本。

2. 用对选择器

在jQuery中，你可以用多种选择器，选择同一个网页元素。每种选择器的性能是不一样的，你应该了解它们的性能差异。

（1）最快的选择器：id选择器和元素标签选择器

举例来说，下面的语句性能最佳：

$('#id')

$('form')

$('input')

遇到这些选择器的时候，jQuery内部会自动调用浏览器的原生方法（比如getElementById()），所以它们的执行速度快。

（2）较慢的选择器：class选择器

$('.className')的性能，取决于不同的浏览器。

Firefox、Safari、Chrome、Opera浏览器，都有原生方法getElementByClassName()，所以速度并不慢。但是，IE5-IE8都没有部署这个方法，所以这个选择器在IE中会相当慢。

（3）最慢的选择器：伪类选择器和属性选择器

先来看例子。找出网页中所有的隐藏元素，就要用到伪类选择器：

$(':hidden')

属性选择器的例子则是：

$('[attribute=value]')

这两种语句是最慢的，因为浏览器没有针对它们的原生方法。但是，一些浏览器的新版本，增加了querySelector()和querySelectorAll()方法，因此会使这类选择器的性能有大幅提高。

最后是不同选择器的性能比较图。

可以看到，ID选择器遥遥领先，然后是标签选择器，第三是Class选择器，其他选择器都非常慢。

3. 理解子元素和父元素的关系

下面六个选择器，都是从父元素中选择子元素。你知道哪个速度最快，哪个速度最慢吗？

$('.child', $parent)

$parent.find('.child')

$parent.children('.child')

$('#parent > .child')

$('#parent .child')

$('.child', $('#parent'))

我们一句句来看。

(1) $('.child', $parent)

这条语句的意思是，给定一个DOM对象，然后从中选择一个子元素。jQuery会自动把这条语句转成$.parent.find('child')，这会导致一定的性能损失。它比最快的形式慢了5%-10%。

(2) $parent.find('.child')

这条是最快的语句。.find()方法会调用浏览器的原生方法（getElementById，getElementByName，getElementByTagName等等），所以速度较快。

(3) $parent.children('.child')

这条语句在jQuery内部，会使用$.sibling()和javascript的nextSibling()方法，一个个遍历节点。它比最快的形式大约慢50%。

(4) $('#parent > .child')

jQuery内部使用Sizzle引擎，处理各种选择器。Sizzle引擎的选择顺序是从右到左，所以这条语句是先选.child，然后再一个个过滤出父元素#parent，这导致它比最快的形式大约慢70%。

(5) $('#parent .child')

这条语句与上一条是同样的情况。但是，上一条只选择直接的子元素，这一条可以于选择多级子元素，所以它的速度更慢，大概比最快的形式慢了77%。

(6) $('.child', $('#parent'))

jQuery内部会将这条语句转成$('#parent').find('.child')，比最快的形式慢了23%。

所以，最佳选择是$parent.find('.child')。而且，由于$parent往往在前面的操作已经生成，jQuery会进行缓存，所以进一步加快了执行速度。

具体的例子和比较结果，请看这里。

4. 不要过度使用jQuery

jQuery速度再快，也无法与原生的javascript方法相比。所以有原生方法可以使用的场合，尽量避免使用jQuery。

请看下面的例子，为a元素绑定一个处理点击事件的函数：

$('a').click(function(){

alert($(this).attr('id'));

});

这段代码的意思是，点击a元素后，弹出该元素的id属性。为了获取这个属性，必须连续两次调用jQuery，第一次是$(this)，第二次是attr('id')。

事实上，这种处理完全不必要。更正确的写法是，直接采用javascript原生方法，调用this.id：

$('a').click(function(){

alert(this.id);

});

根据测试，this.id的速度比$(this).attr('id')快了20多倍。

5. 做好缓存

选中某一个网页元素，是开销很大的步骤。所以，使用选择器的次数应该越少越好，并且尽可能缓存选中的结果，便于以后反复使用。

比如，下面这样的写法就是糟糕的写法：

jQuery('#top').find('p.classA');

jQuery('#top').find('p.classB');

更好的写法是：

var cached = jQuery('#top');

cached.find('p.classA');

cached.find('p.classB');

根据测试，缓存比不缓存，快了2-3倍。

6. 使用链式写法

jQuery的一大特点，就是允许使用链式写法。

$('div').find('h3').eq(2).html('Hello');

采用链式写法时，jQuery自动缓存每一步的结果，因此比非链式写法要快。根据测试，链式写法比（不使用缓存的）非链式写法，大约快了25%。

7. 事件的委托处理（Event Delegation）

javascript的事件模型，采用"冒泡"模式，也就是说，子元素的事件会逐级向上"冒泡"，成为父元素的事件。

利用这一点，可以大大简化事件的绑定。比如，有一个表格（table元素），里面有100个格子（td元素），现在要求在每个格子上面绑定一个点击事件（click），请问是否需要将下面的命令执行100次？

$("td").bind("click", function(){

$(this).toggleClass("click");

});

回答是不需要，我们只要把这个事件绑定在table元素上面就可以了，因为td元素发生点击事件之后，这个事件会"冒泡"到父元素table上面，从而被监听到。

因此，这个事件只需要在父元素绑定1次即可，而不需要在子元素上绑定100次，从而大大提高性能。这就叫事件的"委托处理"，也就是子元素"委托"父元素处理这个事件。

具体的写法有两种。第一种是采用.delegate()方法：

$("table").delegate("td", "click", function(){

$(this).toggleClass("click");

});

第二种是采用.live()方法：

$("table").each(function(){

$("td", this).live("click", function(){

$(this).toggleClass("click");
});
});

这两种写法基本等价。唯一的区别在于，.delegate()是当事件冒泡到指定的父元素时触发，.live()则是当事件冒泡到文档的根元素后触发，因此.delegate()比.live()稍快一点。此外，这两种方法相比传统的.bind()方法还有一个好处，那就是对动态插入的元素也有效，.bind()只对已经存在的DOM元素有效，对动态插入的元素无效。

根据测试，委托处理比不委托处理，快了几十倍。在委托处理的情况下，.delegate()又比.live()大约快26%。

8. 少改动DOM结构

（1）改动DOM结构开销很大，因此不要频繁使用.append()、.insertBefore()和.insetAfter()这样的方法。

如果要插入多个元素，就先把它们合并，然后再一次性插入。根据测试，合并插入比不合并插入，快了将近10倍。

（2）如果你要对一个DOM元素进行大量处理，应该先用.detach()方法，把这个元素从DOM中取出来，处理完毕以后，再重新插回文档。根据测试，使用.detach()方法比不使用时，快了60%。

（3）如果你要在DOM元素上储存数据，不要写成下面这样：

var elem = $('#elem');

elem.data(key,value);

而要写成

var elem = $('#elem');

$.data(elem,key,value);

根据测试，后一种写法要比前一种写法，快了将近10倍。因为elem.data()方法是定义在jQuery函数的prototype对象上面的，而$.data()方法是定义jQuery函数上面的，调用的时候不从复杂的jQuery对象上调用，所以速度快得多。（此处可以参阅下面第10点。）

9. 正确处理循环

循环总是一种比较耗时的操作，如果可以使用复杂的选择器直接选中元素，就不要使用循环，去一个个辨认元素。

javascript原生循环方法for和while，要比jQuery的.each()方法快，应该优先使用原生方法。

10. 尽量少生成jQuery对象

每当你使用一次选择器（比如$('#id')），就会生成一个jQuery对象。jQuery对象是一个很庞大的对象，带有很多属性和方法，会占用不少资源。所以，尽量少生成jQuery对象。

举例来说，许多jQuery方法都有两个版本，一个是供jQuery对象使用的版本，另一个是供jQuery函数使用的版本。下面两个例子，都是取出一个元素的文本，使用的都是text()方法。你既可以使用针对jQuery对象的版本：

var $text = $("#text");

var $ts = $text.text();

也可以使用针对jQuery函数的版本：

var $text = $("#text");

var $ts = $.text($text);

由于后一种针对jQuery函数的版本不通过jQuery对象操作，所以相对开销较小，速度比较快。

本文链接

关于jQuery性能优化

2011-12-23T06:32:00Z

之前，我们减少字节数和请求次数以及加载顺序以使页面加载的更快。如今，我们越来越多的注意到另一个影响网站性能的部分--CPU利用率。使用 jQuery和其他JavaScript框架，使节点选择和DOM操作变得越来越容易，如果使用不当，有可能影响整个网页的响应速度，下面列举11个更有效的使用jQuery库：

1、总是使用#id去寻找element.

在jQuery中最快的选择器是ID选择器 ($('#someid')). 这是因为它直接映射为JavaScript的getElementById()方法。
选择单个元素

<div id="content">
    <form method="post" action="/">
        <h2>Traffic Light</h2>
        <ul id="traffic_light">
            <li><input type="radio" class="on" name="light" value="red" /> Red</li>
            <li><input type="radio" class="off" name="light" value="yellow" /> Yellow</li>
            <li><input type="radio" class="off" name="light" value="green" /> Green</li>
        </ul>
        <input class="button" id="traffic_button" type="submit" value="Go" />
    </form>
</div>

选择button的性能不好的一种方式：

var traffic_button = $('#content .button');

取而代之的是直接选择button:

var traffic_button = $('#traffic_button');

选择多个元素
在我们讨论选择多个元素的时候，我们真正需要知道的是DOM的遍历和循环才是性能低下的原因。为了尽量减少性能损失，总是使用最近的父ID去寻找。

var traffic_lights = $('#traffic_light input');

2、在Classes前面使用Tags
在jQuery中第二快的选择器就是Tag选择器 ($('head')). 而这是因为它直接映射到JavaScript的getElementsByTagName()方法。

<div id="content">
    <form method="post" action="/">
        <h2>Traffic Light</h2>
        <ul id="traffic_light">
            <li><input type="radio" class="on" name="light" value="red" /> Red</li>
            <li><input type="radio" class="off" name="light" value="yellow" /> Yellow</li>
            <li><input type="radio" class="off" name="light" value="green" /> Green</li>
        </ul>
        <input class="button" id="traffic_button" type="submit" value="Go" />
    </form>
</div>

总是在一个Class前面加上一个tag名字（记得从一个ID传下来）

var active_light = $('#traffic_light input.on');

注意：在jQuery里Class选择器是最慢的一个选择器;在IE中它循环整个DOM。可能的话尽量避免使用它。不要在ID前面加Tags。例如，它会因为去循环所有的<div>元素去寻找ID为content的<div>，而导致很慢。

var content = $('div#content');

按照同样的思路，从多个ID传下来是冗余的。

var traffic_light = $('#content #traffic_light');

3、缓存jQuery对象
养成保存jQuery对象到一个变量上（就像上面的例子）的习惯。例如，不要这样做：

$('#traffic_light input.on).bind('click', function(){...});
$('#traffic_light input.on).css('border', '3px dashed yellow');
$('#traffic_light input.on).css('background-color', 'orange');
$('#traffic_light input.on).fadeIn('slow');

取而代之，首现保存jQuery变量到一个本地变量后，再继续你的操作。

var $active_light = $('#traffic_light input.on');
$active_light.bind('click', function(){...});
$active_light.css('border', '3px dashed yellow');
$active_light.css('background-color', 'orange');
$active_light.fadeIn('slow');

提示：使用$前辍表示我们的本地变量是一个jQuery包集。记住，不要在你的应该程序里出现一次以上的jQuery重复的选择操作。额外提示：延迟存储jQuery对象结果。
如果你想在你的程序的其它地方使用jQuery结果对象（result object(s)），或者你的函数要执行多次，要把它缓存在一个全局范围的对象里。通过定义一个全局容器保存jQuery结果对象，就可以在其它的函数里引用它。

// Define an object in the global scope (i.e. the window object)
window.$my =
{
    // Initialize all the queries you want to use more than once
    head : $('head'),
    traffic_light : $('#traffic_light'),
    traffic_button : $('#traffic_button')
};

function do_something()
{
    // Now you can reference the stored results and manipulate them
    var script = document.createElement('script');
    $my.head.append(script);

    // When working inside functions, continue to save jQuery results
    // to your global container.
    $my.cool_results = $('#some_ul li');
    $my.other_results = $('#some_table td');

    // Use the global functions as you would a normal jQuery result
    $my.other_results.css('border-color', 'red');
    $my.traffic_light.css('border-color', 'green');
}

4、更好的利用链
前面的例子也可以这样写：

var $active_light = $('#traffic_light input.on');$active_light.bind('click', function(){...})
    .css('border', '3px dashed yellow')
    .css('background-color', 'orange')
    .fadeIn('slow');

这样可以让我们写更少的代码，使JavaScript更轻量。

5、使用子查询
jQuery允许我们在一个包集上附加其它的选择器。因为我们已经在本地变量里保存了父对象这样会减少以后在选择器上的性能开销。

<div id="content">
    <form method="post" action="/">
        <h2>Traffic Light</h2>
        <ul id="traffic_light">
            <li><input type="radio" class="on" name="light" value="red" /> Red</li>
            <li><input type="radio" class="off" name="light" value="yellow" /> Yellow</li>
            <li><input type="radio" class="off" name="light" value="green" /> Green</li>
        </ul>
        <input class="button" id="traffic_button" type="submit" value="Go" />
    </form>
</div>

例如，我们可以利用子查询缓存active和inactive lights以便后面的操作。

var $traffic_light = $('#traffic_light'),
    $active_light = $traffic_light.find('input.on'),
    $inactive_lights = $traffic_light.find('input.off');

提示：可以用逗号隔开一次定义多个本地变量，这样可以节省一些字节。

6、限制直接对DOM操作
DOM操作的基本做法是在内存中创建DOM结构，然后再更新DOM结构。这不是jQuery最好的做法，但对JavaScript来讲是高效的。直接操作DOM结构性能是低下的。例如，如果你需要动态创建一列元素，不要这样做：

var top_100_list = [...], // assume this has 100 unique strings
    $mylist = $('#mylist'); // jQuery selects our <ul> element

for (var i=0, l=top_100_list.length; i<l; i++)
{
    $mylist.append('<li>' + top_100_list[i] + '</li>');
}

取而代之，我们希望在插入DOM结构之前先在一个字符串里创建一套元素。
代码

var top_100_list = [...], // assume this has 100 unique strings
    $mylist = $('#mylist'), // jQuery selects our <ul> element
    top_100_li = ""; // This will store our list items

for (var i=0, l=top_100_list.length; i<l; i++)
{
    top_100_li += '<li>' + top_100_list[i] + '</li>';
}
$mylist.html(top_100_li);

更快的做法，在插入DOM结构之前我们应该总是在一个父节点里包含许多元素

var top_100_list = [...], // assume this has 100 unique strings
    $mylist = $('#mylist'), // jQuery selects our <ul> element
    top_100_ul = '<ul id="#mylist">'; // This will store our entire unordered list

for (var i=0, l=top_100_list.length; i<l; i++)
{
    top_100_ul += '<li>' + top_100_list[i] + '</li>';
}
top_100_ul += '</ul>'; // Close our unordered list

$mylist.replaceWith(top_100_ul);

如是你照着上面的做了还是对性能有些迷惑的话，可以参考以下内容：
* 试一下jQuery提供的Clone()方法。Clone()方法创建节点数的拷贝，随后你可以在这个副本中进行操作。
* 使用DOM DocumentFragments. As the creator of jQuery points out, 比直接操作DOM性能上更好. 先创建你需要的结构(就像我们上面用一个字符串做的一样), 然后使用jQuery的 insert or replace methods.
7、事件委托（又名：冒泡事件）
除非特别说明，每一个JavaScript事件（如click, mouseover 等）在DOM结构树上都会冒泡到它的父元素上。如果我们想让很多elements(nodes)调用同一个function这是非常有用的。取而代之的是你可以只对它们的父级绑定一次，而且可以计算出是哪一个节点触发了事件，而不是绑定一个事件监听器到很多节点上这种效率低下的方式。例如，假如我们要开发一个包含很多input的大型form，当input被选择的时候我们想绑定一个class name。像这样的帮定是效率低下的：

$('#myList li).bind('click', function(){
    $(this).addClass('clicked');
    // do stuff
});

反而，我们应该在父级侦听click事件。

$('#myList).bind('click', function(e){
    var target = e.target, // e.target grabs the node that triggered the event.
        $target = $(target);  // wraps the node in a jQuery object
    if (target.nodeName === 'LI') {
        $target.addClass('clicked');
        // do stuff
    }
});

父节点担当着发报机的工作，可以在触发了事件的目标element上做一些工作。如果你发现自己把一个event listener帮定到很多个element上，那么你这种做法是不正确的。
8、消除查询浪费
虽然jQuery对没有找到任何匹配的elements处理的很好，但是它还是需要花费时间去查找的。如果你的站点有一个全局的JavaScript，你可能会把每个jQuery function都放在 $(document).ready(function(){ // all my glorious code })里。不要这样做。只去放一些页面上适合用到的function。这样做最有效的方式是你的模板可以完全控制任何时候或者地方执行JavaScript以内联脚本的方式初始化function。例如，在你的“article”页面模板里，你可能在body标签关闭之前包含以下代码

<script type="text/javascript>
mylib.article.init();
</script>
</body>

如果你的页面模板包含多种有可能在页面或者不在页面上的模块，或者为了可视化效果你需要它们稍后再初如化，你应该在这些模块之后立即放置初如化函数。

<ul id="traffic_light">
    <li><input type="radio" class="on" name="light" value="red" /> Red</li>
    <li><input type="radio" class="off" name="light" value="yellow" /> Yellow</li>
    <li><input type="radio" class="off" name="light" value="green" /> Green</li>
</ul>
<script type="text/javascript>
mylib.traffic_light.init();
</script>

你的全局JavaScript库看起来应该是这样的：

var mylib =
{
    article_page :
    {
        init : function()
        {
            // Article page specific jQuery functions.
        }
    },
    traffic_light :
    {
        init : function()
        {
            // Traffic light specific jQuery functions.
        }
    }
}

9、遵从$(windows).load
有一种诱惑会使jQuery开发者hook所有事情到 $(document).ready 这个虚伪的事件里。毕竟在大多数例子里都可以看到这样使用。虽然$(document).ready 非常有用，它在页面呈现时发生，虽然其它对象还在下载中。如果你发现你的页面在下载中停顿，就有可能是$(document).ready 引起的。你可以通过把jQuery functions帮定到$(window).load事件来减少下面下载时的CPU使用率，它是在所有HTML（包括iframe内容）都下载完以后才去调用所有对象的。

$(window).load(function(){
    // jQuery functions to initialize after the page has loaded.
});

多余的功能，如拖拽、帮定可视化效果和动画、预读取图片等，使用这种方法比较好。

10、压缩JS

虽然和jQuery无关，但在这里也要提一下。使JavaScript函数和变量变得可读是一个趋势，这对开发者来讲是必不可少的，但对普通用户来讲没有任何关系。不用什么借口，是时候把JS压缩纳入我们的工作流程中来了。注释你的代码，在投放到生产环境之前找一个压缩工具进行压缩。使用 YUICompressor 压缩你代码中多余的浪费的字节。根据我们的经验，它可以安全的把JavaScript压缩的尽可能小，而不会多占用CPU。小提示：为了在 YUICompressor里最大化压缩，应该这样这样定义变量（例如：var my_long_variable_name;）

11、学习jQuery API库文档

学习和最有效的使用jQuery，最好的方法就是去查jQuery的文档了，可以当作手册来用。

本文链接

Facebook怎样开发软件：工程师驱动的文化（转）

2011-06-13T00:22:00Z

我对Facebook的运作方式一直着迷。这是一个很独特的环境，不容易被复制（他们的体系并不适合所有的公司，虽然他们努力尝试过）。下面是我和Facebook的许多朋友们关于他们如何开发和发布软件所做交流的记录。

然而，Facebook对自己的内部流程说得很少。他们的工程团队经常发布笔记介绍各种新的功能和内部系统，但对如何开发却不怎么讲。因此对于外部人员而言，了解Facebook是怎样远比其他公司高效地对服务进行创新和优化并不容易。为了更多地了解Facebook的运作，我花费数月时间收集了下面这些文字。为了尊重隐私，删去了所有人名和具体功能与产品的名字。另外又等过了6个多月才对外公开，所以它们可能会有点过时。我希望发表这些记录有助于大家了解Facebook是怎样致力于将决策下放而同时又不至于陷入混乱的。无论Facebook的结果怎样，产品是否成体系，我认为并希望许多面向消费者的互联网公司能从中有所裨益。

非常感谢那些帮助我整理这篇文章的Facebook的朋友们。同时也感谢提出指正的Reddit网友。

记录：

截止到2010年6月，Facebook有将近2000名员工，10个月前只有1100名，一年之间差不多翻了一番。
两个最大的部门是工程和运维，每个部门大概都是400～500人。这两个部门人数大约占了公司的一半。
产品经理与工程师的比例大约为1:7到1:10。
每个工程师入职时，都要接收4～6周的培训，通过修补bug和听高级开发工程师的课程来熟悉Facebook。约10%的受训者无法通过，并被请出公司。
培训结束后，每个工程师都可以接触线上的数据库（更大的权力意味着更大的责任，也有一份"勿做清单"，写明那些行为会导致被开除，比如共享用户的隐私数据）。
根据网友fryfrog意见修改：有非常牢靠的防范体系，以免内部人员做恶。如果应要求需要替人行事，必须将原因记录，并接受严格审查，此外都绝对禁止。
每个工程师可以修改Facebook的任何代码，随时可以签入（check-in）。
浓厚的工程师驱动文化。"产品经理基本可以被忽略"，这是Facebook一名员工的原话。工程师可以修改流程的细节，重新安排工作任务，随时植入自己的想法。（作者原注：我就是产品经理，当然对这一点特别关注。其实从下文可以看出，Facebook的文化其实全面吸收了产品管理实践，他们不是忽视产品管理，而是创造了一种人人对产品负责的文化。）
在每月的跨部门会议上，由工程师来汇报工作进度，市场部和产品经理会出席会议，也可以做些简短的发言，但如果说得太多，很可能就会被打小报告。他们确实想让工程师来主导产品的开发，对自己的产品负责。
项目需要的资源都是绝对自愿的
- 产品经理游说工程师，让他们对自己的想法产生兴趣。
- 工程师们决定开发那些让他们感兴趣的特性。
- 工程师跟他们的经理说："我下周想开发这5个新特性"。
- 经理通常会尊重工程师的选择，可能有时会让他优先完成一些特性。
- 工程师负责所有的特性——前端JavaScript/后端数据库代码以及之间所有部分。如果需要得到设计人员（公司内部设计团队很小）的帮助，需要先让设计人员对你的想法产生兴趣。架构师之类的也是一样。总体来说，工程师要完成所有的任务。
对于某个特性是否值得开发的争论，通常是这么解决的：花一个星期的时间完成，并在小部分人群中（如1%的内华达用户）进行测试。（刘江注：蒋长浩介绍，实际操作时通常会选择某些服务器上的用户进行测试。）
工程师总是希望解决基础设施、可扩展性以及其他难题，这能获得声望和尊敬。他们很难对前端项目或UI设计产生太大的兴趣。这与其他公司工程师喜欢做前端并向用户吹嘘“看，这是我做的”的情况，可能正好相反。在Facebook，后端任务，比如新的feed算法，广告投放算法，memcache优化等等，是工程师真正感兴趣的。
所有的代码修改必须经过审查（通过一个或多个工程师），但News Feed是个例外，因为太重要了，Zuckerberg会亲自审查所有改动。（根据网友epriest意见更正）
所有的修改至少要被一个人审核，而且系统可以让任何人很方便地审查其他人的代码，即使没有得到邀请。签入未经审查的代码将被视为恶意行为。（根据fryfrog）
工程师负责测试，代码修复，和维护自己的项目。有一些单元测试和集成测试框架，但只是偶尔使用。
每个办公室或通过VPN连接的员工会使用下一版的Facebook，这个版本的Facebook会经常更新，通常比公开的早1-12小时。所有的员工被强烈建议提交bugs，而且通常会很快被修复。
很奇怪只有很少的QA或自动测试——"大部分工程师都能写出基本没有bug的代码，只是在其他公司他们不需要这么做。如果有QA部门，他们只要把代码写完，扔给他们就行了"
[针对上一条]我们有自动测试，代码发布前必须要通过测试。我们不相信"所有的工程师都能写出没有bug的代码"，毕竟这是一个商业公司。
很奇怪，缺少产品经理的影响和控制——产品经理是很独立的和自由的。产生影响力的关键是与工程师和工程师的领导们们搞好关系。需要大致了解技术，不要提一些愚蠢的想法。
所有提交的代码每周二打包一次。
只要多一分努力，终于一天会发生改变。
星期二的代码发布，需要所有的提交过代码的工程师在场。
代码打包前，工程师必须在一个特殊的IRC channel上。
运维执行打包过程
- Facebook有大约60000台服务器
- 有9个代码发布级别
- 最小的级别只有6台服务器
- 星期二的代码发布会先发布到6台服务器上，运维组会检测这6台服务器的反应，保证代码正常工作，然后再提交到下一级
- 如果发布出现了一些问题（如报错等等），那么就停止下一级的部署，提交出错代码的工程师负责修复问题，然后从头继续发布。
- 所以一次发布可能会经历几次重复：1-2-3-fix. 回到1. 1-2-3-4-5-fix. 回到1. 1-2-3-4-5-6-7-8-9
运维组是受过严格训练，倍受尊敬，而且有商业意识的。他们的工作包括分析错误日志，负载和内存状态等等。还包括用户行为。
代码发布期间，运维组使用IRC-based页面系统，可以通过Facebook/email/irc/im/sms ping每一个工程师，如果需要他们注意的话。对运维组不做回应是一件很羞愧的事。
代码一旦发布到第9级，并且稳定运行，就算发布成功了。
如果一个特性没有按时完成，也没什么大不了的，下次完成时一并发布即可。
如果被svn-blamed,public shamed或工作经常疏忽就很可能被开除。"这是一个高效的文化"。不够高效或者不够聪明的员工会被剔除。管理层会在6个月的时间里观察你表现，如果不合格，只能说再见。每一级都是这个待遇，即使是C级别和VP级别，如果不够高效，也会被开除。
被责骂不会导致解雇。我们特别尊重别人，原谅别人。大部分高级工程师都或多或少犯过一些严重的错误，包括我。但没有人因此被解雇。
我也没有遇到过因为上面提到过的犯错误而被解雇。有些人犯了错，他们会非常努力地去修复，也让其他人得到了学习。

本文链接

xp_cmdshell (Transact-SQL)

2011-04-26T08:55:00Z

SQL Server 2008 R2

生成 Windows 命令 shell 并以字符串的形式传递以便执行。任何输出都作为文本的行返回。

Transact-SQL 语法约定

语法

xp_cmdshell { 'command_string' } [ , no_output ]

参数

' command_string ': 包含要传递到操作系统的命令的字符串。command_string 的数据类型为 varchar(8000) 或 nvarchar(4000)，无默认值。command_string 不能包含一对以上的双引号。如果 command_string 中引用的文件路径或程序名中存在空格，则需要使用一对引号。如果不方便使用内含的空格，则可考虑使用 FAT 8.3 文件名作为解决方法。
no_output: 可选参数，指定不应向客户端返回任何输出。

返回代码值

0（成功）或 1（失败）

结果集

执行以下 xp_cmdshell 语句将返回当前目录的目录列表。

EXEC xp_cmdshell 'dir *.exe';
GO

行以 nvarchar(255) 列的形式返回。如果使用 no_output 选项，则仅返回以下内容：

The command(s) completed successfully.

注释

xp_cmdshell 生成的 Windows 进程与 SQL Server 服务帐户具有相同的安全权限。

xp_cmdshell 以同步方式操作。在命令 shell 命令执行完毕之前，不会将控制权返回给调用方。

可以使用基于策略的管理或通过执行 sp_configure 来启用和禁用 xp_cmdshell。有关详细信息，请参阅了解外围应用配置器和 xp_cmdshell 选项。

重要提示
如果 xp_cmdshell 在批处理中执行并返回错误，则该批处理将失败。这是行为的更改。在 MicrosoftSQL Server 的早期版本中，批处理将会继续执行。

xp_cmdshell 代理帐户

当不属于 sysadmin 固定服务器角色成员的用户调用 xp_cmdshell 时，xp_cmdshell 会使用名为 ##xp_cmdshell_proxy_account## 的凭据中存储的帐户名和密码连接到 Windows。如果该代理凭据不存在，则 xp_cmdshell 将失败。

代理帐户凭据可以通过执行 sp_xp_cmdshell_proxy_account 来创建。此存储过程将 Windows 用户名和密码作为参数使用。例如，以下命令为具有 Windows 密码 sdfh%dkc93vcMt0 的 Windows 域用户 SHIPPING\KobeR 创建代理凭据。

EXEC sp_xp_cmdshell_proxy_account 'SHIPPING\KobeR','sdfh%dkc93vcMt0'

有关详细信息，请参阅 sp_xp_cmdshell_proxy_account (Transact-SQL)。

权限

因为恶意用户有时试图使用 xp_cmdshell 提升其特权，所以，默认情况下禁用 xp_cmdshell。使用 sp_configure 或基于策略的管理以启用它。有关详细信息，请参阅 xp_cmdshell 选项。

首次启用时，xp_cmdshell 要求 CONTROL SERVER 权限以执行进程，而 xp_cmdshell 创建的 Windows 进程与 SQL Server 服务帐户具有相同的安全上下文。SQL Server 服务帐户通常具有的权限要高于由 xp_cmdshell 创建的进程所执行的工作所需的权限。为了提高安全性，对于 xp_cmdshell 的访问应限制为具有高特权的用户。

若要允许非管理员使用 xp_cmdshell 并允许 SQL Server 使用较低特权帐户的安全标记创建子进程，请遵循以下步骤：

使用进程要求的最小特权创建并自定义一个 Windows 本地用户帐户或一个域帐户。

使用 sp_xp_cmdshell_proxy_account 系统过程配置 xp_cmdshell 以使用最小特权帐户。

注意
可以通过在对象资源管理器中右键单击服务器名称的属性，并在安全选项卡上查找服务器代理帐户部分，使用 SQL Server Management Studio 来配置此代理帐户。

在 Management Studio 中，使用 master 数据库，执行 GRANT exec ON xp_cmdshell TO '<somelogin>' 语句以向特定的非 sysadmin 用户授予执行 xp_cmdshell 的能力。指定的登录名必须映射到 master 数据库中的用户。

现在，非管理员可以使用 xp_cmdshell 启动操作系统进程以及使用您已配置的代理帐户的权限运行的那些进程。对于由 xp_cmdshell 启动的子进程，具有 CONTROL SERVER 权限（sysadmin 固定服务器角色的成员）的用户将继续获得 SQL Server 服务帐户的权限。

为了确定在启动操作系统进程时 xp_cmdshell 正在使用的 Windows 帐户，应执行以下语句：

xp_cmdshell 'whoami.exe'

若要确定其他登录名的安全上下文，请执行以下语句：

EXECUTE AS LOGIN = '<other_login>' ;
GO
xp_cmdshell 'whoami.exe' ;
REVERT ;

示例

A. 返回可执行文件列表

以下示例显示执行目录命令的 xp_cmdshell 扩展存储过程。

EXEC master..xp_cmdshell 'dir *.exe'

B. 使用 Windows net 命令

以下示例显示 xp_cmdshell 在存储过程中的使用。本例使用 net send 通知用户将要关闭 SQL Server 实例，使用 net pause 暂停服务器，然后使用 net stop 关闭服务器。

CREATE PROC shutdown10
AS
    EXEC xp_cmdshell 'net send /domain:SQL_USERS ''SQL Server 
        shutting down in 10 minutes. No more connections 
        allowed.', no_output
    EXEC xp_cmdshell 'net pause sqlserver'
    WAITFOR DELAY '00:05:00'
    EXEC xp_cmdshell 'net send /domain: SQL_USERS ''SQL Server 
        shutting down in 5 minutes.', no_output
    WAITFOR DELAY '00:04:00'
    EXEC xp_cmdshell 'net send /domain:SQL_USERS ''SQL Server 
        shutting down in 1 minute. Log off now.', no_output
    WAITFOR DELAY '00:01:00'
    EXEC xp_cmdshell 'net stop sqlserver', no_output

C. 不返回任何输出

以下示例使用 xp_cmdshell 执行命令字符串，且不向客户端返回输出。

USE master;
EXEC xp_cmdshell 'copy c:\SQLbcks\AdvWorks.bck
    \\server2\backups\SQLbcks, NO_OUTPUT';
GO

D. 使用返回状态

在以下示例中，xp_cmdshell 扩展存储过程也给出了返回状态。返回代码值存储在变量 @result 中。

DECLARE @result int
EXEC @result = xp_cmdshell 'dir *.exe'
IF (@result = 0)
   PRINT 'Success'
ELSE
   PRINT 'Failure'

E. 将变量内容写入文件中

以下示例将 @var 变量的内容写入当前服务器目录下名为 var_out.txt 的文件中。

DECLARE @cmd sysname, @var sysname
SET @var = 'Hello world'
SET @cmd = 'echo ' + @var + ' > var_out.txt'
EXEC master..xp_cmdshell @cmd

F. 将命令的结果捕获到文件中

以下示例将当前目录的内容写入当前服务器目录下名为 dir_out.txt 的文件中。

DECLARE @cmd sysname, @var sysname
SET @var = 'dir/p'
SET @cmd = @var + ' > dir_out.txt'
EXEC master..xp_cmdshell @cmd

请参阅

参考

常规扩展存储过程 (Transact-SQL)

sp_xp_cmdshell_proxy_account (Transact-SQL)

概念

xp_cmdshell 选项

了解外围应用配置器

本文链接

SQL Server 表变量陷阱

2011-04-17T09:09:00Z

declare @i int = 0

while (@i < 5)
begin
    declare @dt table(id int)

    insert into @dt
    select @i

    select * from @dt

    set @i += 1
end

上述语句并不是每次输出一条，而是累积上面的所有的记录

如下：

(1 行受影响)
id
-----------
0

(1 行受影响)

id
-----------
0
1

(2 行受影响)

(1 行受影响)

id
-----------
0
1
2

(3 行受影响)

(1 行受影响)

id
-----------
0
1
2
3

(4 行受影响)

(1 行受影响)

id
-----------
0
1
2
3
4

(5 行受影响)

也就是说在sQL循环中，重新声明相同名称的表变量，其原来内容并不会清空。

本文链接

曹重英：技术人员也要打造人脉竞争力（转）

2011-04-02T01:25:00Z

技术人员是最不擅长交际的一群人，很多技术人员认为人际关系比机器更复杂，因此非常排斥与人打交道。但是作为技术管理者，必须要迈过这一关。闪联工程中心研发部平台经理曹重英有着广泛的人脉关系。他认为，技术人员同样需要注意拓展自己的人脉。

记者：你如何扩展自己的人脉关系？

曹重英：人脉关系扩大的方法很多。原来在中国科学院计算技术研究所读书时，我就十分喜欢和外界人进行交流。

工作之后，我主要结合自己的特点扩展人脉。我对技术研究一直有很深的兴趣，经常参加一些学术性会议，加入了普适计算专委会、YOCSEF、嵌入式联谊会等组织。在这些学术性组织里，自然就会认识很多人，慢慢地在学术这个圈子里的人脉就打开了。

同时，在企业一线从事软件开发工作时，我对《程序员》杂志、CSDN等技术媒体组织的活动也很积极参与。而且我经常代表公司在外面做各种技术报告，就这样逐渐将技术人员圈子的人脉建立起来。

其实，扩大人脉并不难，大家都渴望交流，重要的是你要主动地和别人交流。这对于很多技术人员来说，是需要突破原有习惯的。

记者：人脉建立后，如何维系呢？

曹重英：人和人之间的关系是需要维护的，长时间不联系，关系自然就淡了。保持联系的方法很多，经常打打电话、写写信、组织活动等都可以。比如，我参加CTO俱乐部活动，经常见到一些朋友，随着时间的增加，这些人脉关系也在不断地巩固。其实，从另外一个层面看，人际关系中包含着重要的一环，那就是信任。有了交流和信任，就可以在工作中带来便利。我与一位长城公司的工程师只见过一次面，有一次我们部门需要开发数码相框上的软件，问他是否可以借一个数码相框。很快，他就把长城数码相框的产品快递给我了，这也是人际关系中的信任。

记者：您怎么看待人脉关系带给个人的价值？

曹重英：职场中有个词叫人脉竞争力。相对于专业知识上的竞争力而言，一个人在人脉网上的优势就是人脉竞争力。在任何一个行业中打拼，最终都要靠很多朋友的协助，尤其是商业上。

我从事技术开发及管理工作多年，发现人脉竞争力对技术人员发展的促进作用还是很大的。人脉包括公司里的人缘和公司外的人缘。部分技术人员不太愿意与人交流，总是抱怨没人重视。其实在大多数公司，人脉好的，领导总是要重视一些。另外，经常和公司外面的人员交流，不仅更了解外面的世界，好的人脉还可以给你带来新的机会，包括工作计划、技术交流的机会等等。

人脉竞争力实际上是个人的品牌竞争力，将在很大程度上促进技术人员的个人发展。

曹重英：闪联工程中心研发部平台经理

本文链接

动态分段统计SQL

2011-03-02T06:17:00Z

--1.准备数据
--1.1创建表结构，按照每所学校1000人，共30所学校，满分760分计算
if (object_id('tempdb..#baseT') > 0)
drop table #baseT

create table #baseT
(
name varchar(20),
code varchar(20),
studentId uniqueidentifier,
totalScore decimal(4,1)
)

if (object_id('tempdb..#schoolT') > 0)
drop table #schoolT

create table #schoolT
(
id int identity(1,1),
name varchar(20),
code varchar(20)
)
go

--1.2生成数据
insert into #schoolT
select '清华大学','bj0001'
union all
select '北京大学','bj0002'
union all
select '人民大学','bj0003'

declare @index int = 1,@iIndex int = 0, @sCount int
declare
@fullScore decimal(4,1) = 760.0,
@tScore decimal(4,1)

declare @name varchar(20),@code varchar(20)
while @index < 4
begin
    select @name = name ,@code = code from #schoolT where id=@index
    set @iIndex = 0;
    set @sCount = 5000 * @index
    while(@iIndex < @sCount)
    begin
        set @tScore = RAND() * @fullScore
        insert into #baseT
        select @name,@code,NEWID(),@tScore
        set @iIndex += 1
    end
    set @index += 1
end
select * from #baseT

--2.运算结果
declare @fScore decimal(4,1) = 760.0    --满分同上面创建时一样
declare @colCount int = CEILING(@fScore/50.0)
declare
@sql varchar(max) = '',
@fStr varchar(max) = '',
@sStr varchar(max) = '',
@colName varchar(20)

declare @i int = 0,@start varchar(10),@end varchar(10)
--2.1分段生成动态部分
while(@i<@colCount)
begin
    set @start = ltrim(50 * @i)
    set @end = LTRIM(50 * (@i+1))
    if(@i = @colCount-1)
    begin
        set @colName = '[' + LTRIM(@start) +'分以上]'
    end
    else
    begin
        set @colName = '[' + LTRIM(@start) + '-' + LTRIM(@end-1) + '分]'
    end

    set @fStr =  ',COUNT(nullif(case when totalScore >=' + @start + ' and totalScore < ' + @end + ' then 0 else 1 end,1)) as ' + @colName + @fStr
    set @sStr = ',ltrim(' + @colName + ') + ''|'' + ltrim(convert(decimal(4,1),' + @colName + '*100.0/人数)) + ''%'' + ''|'' + ltrim(convert(decimal(4,1),' + @colName + '*100.0/@allCount)) + ''%'' as ' + @colName + @sStr
    set @i += 1
end

--2.2构造整个SQL语句并执行结果
set @sql = '
declare @allCount int
select @allCount = COUNT(*) from #baseT
;with tempR as
(
select name as 学校名称 ,code as 学校代码, COUNT(*) as 人数' + @fStr + '
from #baseT
group by name,code
)
--select * from tempR
select 学校名称,学校代码,人数' + @sStr + '
from tempR'

exec(@sql)

本文链接

SQL优化34条（转）

2010-11-23T02:19:00Z

我们要做到不但会写SQL,还要做到写出性能优良的SQL,以下为笔者学习、摘录、并汇总部分资料与大家分享！
（1）选择最有效率的表名顺序(只在基于规则的优化器中有效)：
ORACLE 的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最先处理，在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表.
（2） WHERE子句中的连接顺序．：

ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.
（3） SELECT子句中避免使用 ‘ * ‘：
ORACLE在解析的过程中, 会将'*' 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间
（4）减少访问数据库的次数：
ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等；
（5）在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200
（6）使用DECODE函数来减少处理时间：
使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.
（7）整合简单,无关联的数据库访问：
如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)
（8）删除重复记录：
最高效的删除重复记录方法 ( 因为使用了ROWID)例子：

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID) 
FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

（9）用TRUNCATE替代DELETE：
当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短. (译者按: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)
（10）尽量多使用COMMIT：
只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:
COMMIT所释放的资源:
a. 回滚段上用于恢复数据的信息.
b. 被程序语句获得的锁
c. redo log buffer 中的空间
d. ORACLE为管理上述3种资源中的内部花费
（11）用Where子句替换HAVING子句：
避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销. (非oracle中)on、where、having这三个都可以加条件的子句中，on是最先执行，where次之，having最后，因为on是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，where也应该比having快点的，因为它过滤数据后才进行sum，在两个表联接时才用on的，所以在一个表的时候，就剩下where跟having比较了。在这单表查询统计的情况下，如果要过滤的条件没有涉及到要计算字段，那它们的结果是一样的，只是where可以使用rushmore技术，而having就不能，在速度上后者要慢如果要涉及到计算的字段，就表示在没计算之前，这个字段的值是不确定的，根据上篇写的工作流程，where的作用时间是在计算之前就完成的，而having就是在计算后才起作用的，所以在这种情况下，两者的结果会不同。在多表联接查询时，on比where更早起作用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表后，再由where进行过滤，然后再计算，计算完后再由having进行过滤。由此可见，要想过滤条件起到正确的作用，首先要明白这个条件应该在什么时候起作用，然后再决定放在那里
（12）减少对表的查询：
在含有子查询的SQL语句中,要特别注意减少对表的查询.例子：

SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT 
TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)

（13）通过内部函数提高SQL效率.：
复杂的SQL往往牺牲了执行效率. 能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的
（14）使用表的别名(Alias)：
当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.
（15）用EXISTS替代IN、用NOT EXISTS替代NOT IN：
在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率. 在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.
例子：

（高效）SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X' FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB') 
(低效)SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')

（16）识别'低效执行'的SQL语句：
虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法：

SELECT EXECUTIONS , DISK_READS, BUFFER_GETS, 
ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio, 
ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run, 
SQL_TEXT 
FROM V$SQLAREA 
WHERE EXECUTIONS>0 
AND BUFFER_GETS > 0 
AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8 
ORDER BY 4 DESC;

（17）用索引提高效率：
索引是表的一个概念部分,用来提高检索数据的效率，ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率. 另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证.。那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列. 通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率. 虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.。定期的重构索引是有必要的.：
ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>
18）用EXISTS替换DISTINCT：
当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换, EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果. 例子：

 (低效): 
SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E 
WHERE D.DEPT_NO = E.DEPT_NO 
(高效): 
SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X' 
FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);

（19） sql语句用大写的；因为oracle总是先解析sql语句，把小写的字母转换成大写的再执行
（20）在java代码中尽量少用连接符“＋”连接字符串！

（21）避免在索引列上使用NOT 通常，　
我们要避免在索引列上使用NOT, NOT会产生在和在索引列上使用函数相同的影响. 当ORACLE”遇到”NOT,他就会停止使用索引转而执行全表扫描.
（22）避免在索引列上使用计算．
WHERE子句中，如果索引列是函数的一部分．优化器将不使用索引而使用全表扫描．
举例:

低效： 
SELECT … FROM DEPT WHERE SAL * 12 > 25000; 
高效: 
SELECT … FROM DEPT WHERE SAL > 25000/12;

（23）用>=替代>

高效: 
SELECT * FROM EMP WHERE DEPTNO >=4 
低效: 
SELECT * FROM EMP WHERE DEPTNO >3

两者的区别在于, 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录.
（24）用UNION替换OR (适用于索引列)
通常情况下, 用UNION替换WHERE子句中的OR将会起到较好的效果. 对索引列使用OR将造成全表扫描. 注意, 以上规则只针对多个索引列有效. 如果有column没有被索引, 查询效率可能会因为你没有选择OR而降低. 在下面的例子中, LOC_ID 和REGION上都建有索引.

高效: 
SELECT LOC_ID , LOC_DESC , REGION 
FROM LOCATION 
WHERE LOC_ID = 10 
UNION 
SELECT LOC_ID , LOC_DESC , REGION 
FROM LOCATION 
WHERE REGION = “MELBOURNE” 
低效: 
SELECT LOC_ID , LOC_DESC , REGION 
FROM LOCATION 
WHERE LOC_ID = 10 OR REGION = “MELBOURNE”

如果你坚持要用OR, 那就需要返回记录最少的索引列写在最前面.
（25）用IN来替换OR
这是一条简单易记的规则，但是实际的执行效果还须检验，在ORACLE8i下，两者的执行路径似乎是相同的．

低效: 
SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID = 30 
高效 
SELECT… FROM LOCATION WHERE LOC_IN IN (10,20,30);

（26）避免在索引列上使用IS NULL和IS NOT NULL
避免在索引中使用任何可以为空的列，ORACLE将无法使用该索引．对于单列索引，如果列包含空值，索引中将不存在此记录. 对于复合索引，如果每个列都为空，索引中同样不存在此记录.　如果至少有一个列不为空，则记录存在于索引中．举例: 如果唯一性索引建立在表的A列和B列上, 并且表中存在一条记录的A,B值为(123,null) , ORACLE将不接受下一条具有相同A,B值（123,null）的记录(插入). 然而如果所有的索引列都为空，ORACLE将认为整个键值为空而空不等于空. 因此你可以插入1000 条具有相同键值的记录,当然它们都是空! 因为空值不存在于索引列中,所以WHERE子句中对索引列进行空值比较将使ORACLE停用该索引.

低效: (索引失效) 
SELECT … FROM DEPARTMENT WHERE DEPT_CODE IS NOT NULL; 
高效: (索引有效) 
SELECT … FROM DEPARTMENT WHERE DEPT_CODE >=0;

（27）总是使用索引的第一个列：
如果索引是建立在多个列上, 只有在它的第一个列(leading column)被where子句引用时,优化器才会选择使用该索引. 这也是一条简单而重要的规则，当仅引用索引的第二个列时,优化器使用了全表扫描而忽略了索引
28）用UNION-ALL 替换UNION ( 如果有可能的话)：
当SQL 语句需要UNION两个查询结果集合时,这两个结果集合会以UNION-ALL的方式被合并, 然后在输出最终结果前进行排序. 如果用UNION ALL替代UNION, 这样排序就不是必要了. 效率就会因此得到提高. 需要注意的是，UNION ALL 将重复输出两个结果集合中相同记录. 因此各位还是要从业务需求分析使用UNION ALL的可行性. UNION 将对结果集合排序,这个操作会使用到SORT_AREA_SIZE这块内存. 对于这块内存的优化也是相当重要的. 下面的SQL可以用来查询排序的消耗量

低效： 
SELECT ACCT_NUM, BALANCE_AMT 
FROM DEBIT_TRANSACTIONS 
WHERE TRAN_DATE = '31-DEC-95' 
UNION 
SELECT ACCT_NUM, BALANCE_AMT 
FROM DEBIT_TRANSACTIONS 
WHERE TRAN_DATE = '31-DEC-95' 
高效: 
SELECT ACCT_NUM, BALANCE_AMT 
FROM DEBIT_TRANSACTIONS 
WHERE TRAN_DATE = '31-DEC-95' 
UNION ALL 
SELECT ACCT_NUM, BALANCE_AMT 
FROM DEBIT_TRANSACTIONS 
WHERE TRAN_DATE = '31-DEC-95'

（29）用WHERE替代ORDER BY：
ORDER BY 子句只在两种严格的条件下使用索引.
ORDER BY中所有的列必须包含在相同的索引中并保持在索引中的排列顺序.
ORDER BY中所有的列必须定义为非空.
WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.
例如:

表DEPT包含以下列: 
DEPT_CODE PK NOT NULL 
DEPT_DESC NOT NULL 
DEPT_TYPE NULL 
低效: (索引不被使用) 
SELECT DEPT_CODE FROM DEPT ORDER BY DEPT_TYPE 
高效: (使用索引) 
SELECT DEPT_CODE FROM DEPT WHERE DEPT_TYPE > 0

（30）避免改变索引列的类型.:
当比较不同数据类型的数据时, ORACLE自动对列进行简单的类型转换.
假设 EMPNO是一个数值类型的索引列.
SELECT … FROM EMP WHERE EMPNO = ‘123'
实际上,经过ORACLE类型转换, 语句转化为:
SELECT … FROM EMP WHERE EMPNO = TO_NUMBER(‘123')
幸运的是,类型转换没有发生在索引列上,索引的用途没有被改变.
现在,假设EMP_TYPE是一个字符类型的索引列.
SELECT … FROM EMP WHERE EMP_TYPE = 123
这个语句被ORACLE转换为:
SELECT … FROM EMP WHERETO_NUMBER(EMP_TYPE)=123
因为内部发生的类型转换, 这个索引将不会被用到! 为了避免ORACLE对你的SQL进行隐式的类型转换, 最好把类型转换用显式表现出来. 注意当字符和数值比较时, ORACLE会优先转换数值类型到字符类型
（31）需要当心的WHERE子句:
某些SELECT 语句中的WHERE子句不使用索引. 这里有一些例子.
在下面的例子里, (1)‘!=' 将不使用索引. 记住, 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中. (2) ‘||'是字符连接函数. 就象其他函数那样, 停用了索引. (3) ‘+'是数学函数. 就象其他数学函数那样, 停用了索引. (4)相同的索引列不能互相比较,这将会启用全表扫描.
（32） a. 如果检索数据量超过30%的表中记录数.使用索引将没有显著的效率提高.
b. 在特定情况下, 使用索引也许会比全表扫描慢, 但这是同一个数量级上的区别. 而通常情况下,使用索引比全表扫描要块几倍乃至几千倍!
（33）避免使用耗费资源的操作:
带有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL语句会启动SQL引擎
执行耗费资源的排序(SORT)功能. DISTINCT需要一次排序操作, 而其他的至少需要执行两次排序. 通常, 带有UNION, MINUS , INTERSECT的SQL语句都可以用其他方式重写. 如果你的数据库的SORT_AREA_SIZE调配得好, 使用UNION , MINUS, INTERSECT也是可以考虑的, 毕竟它们的可读性很强
（34）优化GROUP BY:
提高GROUP BY 语句的效率, 可以通过将不需要的记录在GROUP BY 之前过滤掉.下面两个查询返回相同结果但第二个明显就快了许多.

低效: 
SELECT JOB , AVG(SAL) 
FROM EMP 
GROUP by JOB 
HAVING JOB = ‘PRESIDENT' 
OR JOB = ‘MANAGER' 
高效: 
SELECT JOB , AVG(SAL) 
FROM EMP 
WHERE JOB = ‘PRESIDENT' 
OR JOB = ‘MANAGER' 
GROUP by JOB

本文链接

如何管理“人”

2010-09-16T07:44:00Z

from:http://blog.csdn.net/kthq/archive/2010/09/07/5869433.aspx

我们常说工作中应该“对事不对人”，但事都是人做的，不同的人做相同的事效果可能相去甚远，再好的业务如果用错了人也会全盘皆输。正所谓“事在人为”嘛，识人、用人、聚人是一个团队管理者获得成功的基础。

　　先说怎么认识人

　　人格矩阵法。即所谓的Topk技术，Topk就是由：tiger、owl、peacock 与 koala 4个英文单词的第一个字母组成，即把人的人格类型总结为老虎、猫头鹰、孔雀与考拉这4种动物的行为智慧：

老虎-此类人表现为：做事结果导向明显（不在乎过程），野心勃勃，自信，喜欢指挥他人，有紧迫感。抗压能力强，也喜欢给他人压力。意志坚强，为达成目标不惜代价。对此类人适合以命令的方式下达任务。其对任务的执行力也较强。此类人看重结果和效率。老板、老总一般属于此类。对老虎型下属应该：直接命令，压效率。给予明确且较高的目标、授权。但是需要帮助其协调人际关系。对老虎型上司应该：开门见山的汇报，先讲结果，注意效率。
猫头鹰-喜欢思考，谨慎细心。表现稳定，拘谨犹豫，追求完美，行动力稍差。感情不外露，内心可能斤斤计较。扛压力的能力较差。对此类人应该以商量的方式下达任务。其对具体任务的执行比较严谨细致。此类人注重细节和过程。工程师、技术员一般属于此类。对猫头鹰型下属应该：倾听和欣赏其思路，鼓励其行动。可以分配之一些需要分析和计划的工作做。对猫头鹰型上司应该：解释思路，列举事例、数据说服之。做好执行工作，并认真汇报过程。
孔雀-此类人表现为：活泼，爱自我表现，善于自我推销。喜欢新鲜有趣的事物。外向且任性。能承担适度的压力。对此类人经常不得不以命令的方式沟通。此类人较为适合做人事（宣传、推广）相关的工作。此类人喜欢创新和刺激。策划、销售一般属于此类。对孔雀型下属应该：多赞扬，给予其表现的机会。让其做“有趣”的事情，但是要追踪其任务完成的过程。对孔雀型上司应该：多喝采，聊“有趣”的事情，多沟通。
考拉-对人敏感注重他人感受，富有同情心。进取心不足但富有耐心。温和脾气好，逆来顺受。像“棉花糖”一样抗“击打”能力强。对此类人应该以商量的方式沟通。此类人较为适合做人事（沟通、协调）相关工作。此类人注重关系和忠诚。行政、客服一般属于此类。对考拉型下属应该：时刻关注对方感受，可以建立个人友谊。使用建设性意见，给予明确的目标。对考拉型上司应该：发展个人友谊，多多分享感受。

事实上，大部分人都会同时具有上面2种动物的人格特征，而由于所处的环境压力所致，又会显性的表现出一组特征，而内心隐性则是另一组特征。但这完全不妨碍使用“人格矩阵”法识人。有些很有意思的观点分享：据说考拉型的人格会让老虎型的人格无从下手；而所谓的人中龙凤（比如国家领导人）则完全是变色龙型的人格，即可以随环境、形式的需要变成任意一种类型的人格。

认知（或者说是价值观）象限法。

　　此法把人分成4个维度，每个维度中有2个明显相互矛盾的类型。你所要做的就是先在以下4个维度中为目标人各选取一个适用的字母。

内倾型（I）和外倾型（E）

内倾型（I）通过思考的方法想出主意。喜欢独处，自我克制。倾向于在内部世界里沉思，偏好内省，理解先于行动，从精神世界获得心理能量，采用持久稳固的工作方式。外倾型（E）通过“说出来”的方法想出主意。社交广泛，善于表达。倾向于对外部世界的客体作出反应，积极活动，经验先于理解，从外界获得心理能量，采用“尝试-错误”的工作方式。

实感型（S）和直觉型（N）

实感型（S）关注目前的事实，小心深入逐步迈向结论，着眼于现实，重视现实性和常情，关注具体性和特殊性，善于细节描述，循序渐进的工作方式。看重常规，相信确定有形的事物。倾向于观察具体事件，偏好已知事物。直觉型（N）关注将来的将来的可能性，根据预感很快作出结论，着眼于未来，重视想象力和独创力。关注普遍性和象征性，使用隐喻和类比。跳跃性的工作方式。不拘常规，相信灵感和推断。倾向于把握事件的全局图面，偏好新的思想观念。

思考型（T）和情感型（F）

思考型（T）讲道理，追求客观真理标准。退后思考，对问题进行非个人因素的分析。公正，坚定，怀疑。倾向于分析性和逻辑性的工作方式。行为简洁、经济、带有批判性。奉行清晰一致的客观原则。情感型（F）有同情心，追求和谐共处和积极互动。超前思考，考虑行为对他人的影响。温和，同情，体贴。倾向于和自己的情感一致的工作方式，行为期望他人认同，奉行清晰一致的主观价值观。

判断型（J）和认知型（P）

判断型（J）有计划，避免燃眉之急的压力，行为有组织性和系统性。时间观念严谨，认真对待最后期限。看重工作结果，倾向于解决问题，认真完成预设目标。认知型（P）即兴发挥，从最后关头得到动力，行为保持开放性。时间观念宽松，经常变动最后期限。看重工作过程。倾向于使问题带有弹性，在获取新信息的过程中不断改变目标。

OK，到此你已经可以得到一个4字母的组合。下图将所有的组合类型（4×4=16）划分成4个象限，你可以大致的判断目标人属于哪一种认知类型

注意：互为对角的人，认知差别越大，也就是说价值观不同。因此互为对角的两种人在合作时尤其要多为对方“换位思考”，避免爆发冲突。
而下图，则具体的指出了每种认知类型的人的主要性格特征，我个人认为未必完全准确，仅供参考：

　　相面法。

这可以说是最古老、最直接、最简单的识人办法了。我认为这是有一定道理的，所以简单列举几条，并附上一些解释。左右脸型对称的人，表里如一；反之，此人内心矛盾越大。想想是不是这样，内心经常处于矛盾状态的人，内心和面部表情都会经常“扭曲”，久而久之……眼角周围皱纹多者乐观。遇事常乐者，一般二十多岁眼角就有皱纹了，我们身边有很多这样的人。眉心有皱纹者（与年龄不符）属于完美主义者，多疑，注重细节与计划。典型的猫头鹰型人格。经常紧锁眉头，当然眉心有皱纹。交谈中亮鼻孔者内心高傲。很明显，趾高气昂也就是这个样子。嘴唇薄者，自制力强，但对别人要求也高。这个自己体会是不是这样。

　　再说怎么用人

其实在上面认识人的时候，你就应该知道如何用人。发挥人的长处，无论何种人格、认知的人一般都有用处，只看你的组织需不需要了。
　　下面简单介绍一些日常管理中常用的套路，这些套路具有广泛的适用性，一般不会错。
　　如何委派工作？

记住6个步骤：解释为什么要做（强调重要性）说明要求和结果（强调目的）告知职责范围（防止出问题）协商最后期限（结果把控）聆听反馈（确保达成协议）设置关键点并监控（过程把控）

和下属进行绩效沟通要“踩”的3个点（无顺序）：激励，指导，约束

管理一个新人（下属），一般需要经历如下4个阶段：

命令式-能力低、意愿高。新人驾到，万事开头难，为了站稳脚跟，一般执行力会好，命令之即可，不用太多解释。但由于不熟悉业务，技能表现不会太好。教练式-能力中、意愿低。业务掌握了，在组织内部做成了一些事，往往会有所散漫、懈怠。这时候就需要管理者带着、指导，使之更上一层楼。支持式-能力较高、意愿波动。业务摸熟了，在组织内部小有成就了，这时候最关键也最危险，其内心波动也越大。要么留下来和组织一起发展，要么按耐不住跳槽。职场上所谓的2年之痒一般就是这个时候。这时候，管理者应给予其充分的发展空间和支持力度，确保其在组织中有成就感、事业感，关键是要干的开心。授权式-能力高、意愿高。如果你的下属到达了这个阶段，恭喜，此时此人的工作能力、工作意愿、对本组织文化的认同都处在了一个高的水平，是其对组织贡献的黄金阶段。此时可以对其充分“授权”，让其承担更不同、更大的责任，发挥更为广泛的能力。此时可以把此人变成组织中的“自己人”，然后对其施加更大的工作压力。

　　最后要说说如何“聚合”人

这要先从管理者的层次谈起，常言道：三流管理者管下级——靠职权。二流管理者管同事——非正式领导，靠个人影响力。一流管理者管上级——准确定位，抓对方需求，靠领导艺术。超一流管理者管自己！因为：最高境界的管理者必须依靠个人魅力才能在宏观的范围影响人群，体现个人价值。个人魅力从何而来？根据冰山理论：个人魅力是水面上可以看见的一小部分山尖，个人品格则是水底下的冰山大部。而个人魅力和个人品格都来自于严格的自我管理。管好自己是最困难的，因为人有太多的欲望、外界有太多的诱惑。善于自我管理的人需要：

拉长刺激与回应之间的距离。即所谓的三思而后行，避免仓促、片面的快速做出决定和承诺。为自己的行为负责。即俗话说的“靠谱”。重点放在影响范围之内。刘德华娶了几个老婆你是否会去关注？关你屁事！朝鲜进行核试验你是否会关注？关注了有个屁用！这些事都不在你的影响范围内，你关注了也不能施加影响。所以，请把注意力放在你所能影响的事物上（少看点八卦），这样你才不会白白浪费精力，你的影响力才有可能越来越大。做好时间管理。时间是最宝贵的不可再生资源。搞清楚事物的“重要”和“紧急”吧，这方面的资料很多，我不必废话。从“技术上”掌握沟通。例如：先处理心情，再处理事情；立场要坚定，态度要热情……最后总结一下，与其管理莫如领导，与其领导莫如折服，正所谓：力服为下，才服为中，德服为上。

本文链接

博客园_Andy Ge

jQuery设计思想

jQuery最佳实践

关于jQuery性能优化

Facebook怎样开发软件：工程师驱动的文化（转）

xp_cmdshell (Transact-SQL)

A. 返回可执行文件列表

以下示例显示执行目录命令的 xp_cmdshell 扩展存储过程。

EXEC master..xp_cmdshell 'dir *.exe'

C. 不返回任何输出

以下示例使用 xp_cmdshell 执行命令字符串，且不向客户端返回输出。

USE master; EXEC xp_cmdshell 'copy c:\SQLbcks\AdvWorks.bck \\server2\backups\SQLbcks, NO_OUTPUT'; GO

D. 使用返回状态

在以下示例中，xp_cmdshell 扩展存储过程也给出了返回状态。返回代码值存储在变量 @result 中。

DECLARE @result int EXEC @result = xp_cmdshell 'dir *.exe' IF (@result = 0) PRINT 'Success' ELSE PRINT 'Failure'

E. 将变量内容写入文件中

以下示例将 @var 变量的内容写入当前服务器目录下名为 var_out.txt 的文件中。

DECLARE @cmd sysname, @var sysname SET @var = 'Hello world' SET @cmd = 'echo ' + @var + ' > var_out.txt' EXEC master..xp_cmdshell @cmd

F. 将命令的结果捕获到文件中

以下示例将当前目录的内容写入当前服务器目录下名为 dir_out.txt 的文件中。

DECLARE @cmd sysname, @var sysname SET @var = 'dir/p' SET @cmd = @var + ' > dir_out.txt' EXEC master..xp_cmdshell @cmd

参考

常规扩展存储过程 (Transact-SQL)

sp_xp_cmdshell_proxy_account (Transact-SQL)

概念

xp_cmdshell 选项

了解外围应用配置器

SQL Server 表变量陷阱

曹重英：技术人员也要打造人脉竞争力（转）

动态分段统计SQL

SQL优化34条（转）

如何管理“人”

博客园_Andy Ge

jQuery设计思想

jQuery最佳实践

关于jQuery性能优化

Facebook怎样开发软件：工程师驱动的文化（转）

xp_cmdshell (Transact-SQL)

A. 返回可执行文件列表 以下示例显示执行目录命令的 xp_cmdshell 扩展存储过程。 EXEC master..xp_cmdshell 'dir *.exe'

C. 不返回任何输出 以下示例使用 xp_cmdshell 执行命令字符串，且不向客户端返回输出。 USE master; EXEC xp_cmdshell 'copy c:\SQLbcks\AdvWorks.bck \\server2\backups\SQLbcks, NO_OUTPUT'; GO

D. 使用返回状态 在以下示例中，xp_cmdshell 扩展存储过程也给出了返回状态。返回代码值存储在变量 @result 中。 DECLARE @result int EXEC @result = xp_cmdshell 'dir *.exe' IF (@result = 0) PRINT 'Success' ELSE PRINT 'Failure'

E. 将变量内容写入文件中 以下示例将 @var 变量的内容写入当前服务器目录下名为 var_out.txt 的文件中。 DECLARE @cmd sysname, @var sysname SET @var = 'Hello world' SET @cmd = 'echo ' + @var + ' > var_out.txt' EXEC master..xp_cmdshell @cmd

F. 将命令的结果捕获到文件中 以下示例将当前目录的内容写入当前服务器目录下名为 dir_out.txt 的文件中。 DECLARE @cmd sysname, @var sysname SET @var = 'dir/p' SET @cmd = @var + ' > dir_out.txt' EXEC master..xp_cmdshell @cmd

参考 常规扩展存储过程 (Transact-SQL) sp_xp_cmdshell_proxy_account (Transact-SQL)

概念 xp_cmdshell 选项 了解外围应用配置器

SQL Server 表变量陷阱

曹重英：技术人员也要打造人脉竞争力（转）

动态分段统计SQL

SQL优化34条（转）

如何管理“人”

A. 返回可执行文件列表

以下示例显示执行目录命令的 xp_cmdshell 扩展存储过程。

EXEC master..xp_cmdshell 'dir *.exe'

C. 不返回任何输出

以下示例使用 xp_cmdshell 执行命令字符串，且不向客户端返回输出。

USE master; EXEC xp_cmdshell 'copy c:\SQLbcks\AdvWorks.bck \\server2\backups\SQLbcks, NO_OUTPUT'; GO

D. 使用返回状态

在以下示例中，xp_cmdshell 扩展存储过程也给出了返回状态。返回代码值存储在变量 @result 中。

DECLARE @result int EXEC @result = xp_cmdshell 'dir *.exe' IF (@result = 0) PRINT 'Success' ELSE PRINT 'Failure'

E. 将变量内容写入文件中

以下示例将 @var 变量的内容写入当前服务器目录下名为 var_out.txt 的文件中。

DECLARE @cmd sysname, @var sysname SET @var = 'Hello world' SET @cmd = 'echo ' + @var + ' > var_out.txt' EXEC master..xp_cmdshell @cmd

F. 将命令的结果捕获到文件中

以下示例将当前目录的内容写入当前服务器目录下名为 dir_out.txt 的文件中。

DECLARE @cmd sysname, @var sysname SET @var = 'dir/p' SET @cmd = @var + ' > dir_out.txt' EXEC master..xp_cmdshell @cmd

参考

常规扩展存储过程 (Transact-SQL)

sp_xp_cmdshell_proxy_account (Transact-SQL)

概念

xp_cmdshell 选项

了解外围应用配置器