/*
* Complex.js:
* This file defines a Complex class to represent complex numbers.
* Recall that a complex number is the sum of a real number and and
* imaginary number and that the imaginary number i is the
* square root of -1.
*
*/
/*
* The first step in defining a class is defining the constructor
* function of the class. This constructor should initialize any
* instance properties of the object. These are the essential
* "state variables" that make each instance of the class diffent.
*/
function Complex(real, imaginary){
	this.x = real;
	this.y = imaginary;
}
/*
* The second step in defining a class is defining its instance
* methods (and possibly other properties) in the prototype object
* of the constructor. Any properties defined in this object will
* be inherited by all instances of the class. Note that instance
* methods operate on the this keyword. For many methods,
* no other arguments are needed.
*/
//Return the magnitude of a complex number. This is defined
//as its distance from the origin (0,0) of the complex plane
Complex.prototype.magnitude = function() {
	return Math.sqrt(this.x*this.x + this.y*this*y);
};
//Return a complex number that is the negative of this one.
Complex.prototype.negative = function() {
	return new Complex(-this.x,-this.y);
};
//Add a complex number to this one and return the sum in a new object.
Complex.prototype.add = function(that) {
	return new Complex(this.x + that.x, this.y + that.y);
};
//Multiply this complex number by anther and return the product as a
//new Complex object.
Complex.prototype.multiply = function(that) {
	return new Complex(this.x * that.x - this.y * that.y, this.x * that.y + this.y * that.x);
};
//Convert a Complex object to a string in a useful way.
//This is invoked when a Complex object is used as a string.
Complex.prototype.toString = function() {
	return "{" + this.x + "," + this.y +"}";
};
//Test whether this Complex object has the same value as another.
Complex.prototype.equals = function(that) {
	return this.x == that.x && this.y == that.y;
};
//Return the real portion of a complex number. This function
//is invoked when a Complex object is treated as a primitive value
Complex.prototype.valueOf = function() {
	return this.x;
};
/*
* The third step in defining a class is to define class methods,
* constants, and any needed class properties as properties of the
* constructor function itself (instead of as properties of properties of the
* prototype object of the constructor).Note that class methods
* do not use this keyword: they operate only on their arguments.
*/
Complex.sum = function(a,b) {
	return new Complex(a.x + b.x, a.y + b.y);
};
Complex.product = function(a,b) {
	return new Complex(a.x * b.x - a.y * b.y, a.x * b.x + a.y * b.y);
};
// Here are some useful predefined complex numbers
// They are defined as class properties, and their names are in uppercase
// to indicate that they are instended to be constants (although it is not
// possible to make JavaScript properties read-only).
Complex.ZERO = new Complex(0,0);
Complex.ONE = new Complex(1,0);
Complex.I = new Complex(0,1);
var a = new Complex(1,1);
var b = new Complex(1,2);
console.log(Complex.sum(a,b));//return Complex(2,3)
console.log(a.equals(b));//return false

用于对表格的排序。

（忽略HTML吧）

function TableSort(id){
 this.tbl = document.getElementById(id);
 this.lastSortedTh = null;
 if(this.tbl && this.tbl.nodeName == "TABLE"){//判断是否存在且为表格
 var headings = this.tbl.tHead.rows[0].cells;//获取表头成员
 for(var i=0;headings[i];i++){
 if(headings[i].className.match(/asc|dsc/)){//
 this.lastSortedTh = headings[i];
 }
 }
 this.makeSortable();//让他排序
 }
}
TableSort.prototype.makeSortable = function(){
 var headings = this.tbl.tHead.rows[0].cells;//获取表头成员数组
 for(var i=0;headings[i];i++){
 headings[i].cIdx = i;//解决Safari2.0.4的bug导致对cellIndex的返回值永远为0
 //接下来为每个th元素外包一个a，让用户可以通过tab键激活表头，回车触发onclick事件
 var a = document.createElement("a");
 a.href = "#";
 a.innerHTML = headings[i].innerHTML;
 a.onclick = function(that){
 return function(){
 that.sortCol(this);
 return false;
 }
 }(this);//使用闭包指向TableSort实例
 headings[i].innerHTML = "";
 headings[i].appendChild(a);
 }
}
TableSort.prototype.sortCol = function(el){
 var rows = this.tbl.rows;//所有行
 var alpha = [],numeric = [];//该列所有格子的文字型内容和数值型内容分开存放于这两个数组中
 var aIdx = 0,nIdx = 0;//用于索引上面两个数组
 var th = el.parentNode;//这是被点击钩子的父节点引用，即th.钩子的引用是el，作为函数的参数传进来
 var cellIndex = th.cIdx;//这个变量存放th元素在其所在行的索引。通过它，可以直接跳到当前列在每行对应的格子，从而高效地遍历一列的所有格子
 for(var i=1;rows[i];i++){
 var cell = rows[i].cells[cellIndex];
 var content = cell.textContent ? cell.textContent : cell.innerText;//FF只支持textContent，IE只支持innerText
 var num = content.replace(/(\$|\,|\s)/g, "");//去除美元，逗号和空格等
 if(parseFloat(num) == num){//判断省下的是否是数值
 numeric[nIdx++] = {
 value:Number(num),
 row:rows[i]
 }
 }else{
 alpha[aIdx++] = {
 value:content,
 row:rows[i]
 }
 }
 }
//按方向进行排序
 var col = [],top,bottom;
 if(th.className.match("asc")){
 top = bubbleSort(alpha,-1);
 bottom = bubbleSort(numeric,-1);
 th.className = th.className.replace(/asc/,"dsc");
 }else{
 top = bubbleSort(numeric,1);
 bottom = bubbleSort(alpha,1);
 if(th.className.match("dsc")){
 th.className = th.className.replace(/dsc/,"asc");
 }else{
 th.className +="asc";
 }
 }
 //如果最近一次排序的表格列的th和被点击的不一样，就清楚他的asc/dsc类名
 if(this.lastSortedTh && th != this.lastSortedTh){
 this.lastSortedTh.className = this.lastSortedTh.className.replace(/dsc|asc/g,"");
 }
 this.lastSortedTh = th;
 col = top.concat(bottom);
 var tBody = this.tbl.tBodies[0];
 for(var i=0;col[i];i++){
 tBody.appendChild(col[i].row)
 }
}
function bubbleSort(arr,dir){
 var start,end;
 if(dir === 1){//dir的两个值，1和-1，分别代表升序和降序
 start = 0;
 end = arr.length;
 }else if(dir === -1){
 start = arr.length-1;
 end = -1;
 }
 var unsorted = true;
 while(unsorted){//冒泡排序
 unsorted = false;
 for(var i=start;i!=end;i=i+dir){
 if(arr[i+dir] && arr[i].value > arr[i+dir].value){
 var a = arr[i];
 var b = arr[i+dir];
 var c = a;
 arr[i] = b;
 arr[i+dir] = c;
 unsorted = true;
 }
 }
 }
 return arr;
}

就不详细说了，注释都写了

感想是对闭包的概念还不是很了解QAQ

demo地址：http://fakefish.me/test/js/tablesort.html

来自The Art & Science Of Javascript

官方地址：http://www.sitepoint.com/books/jsdesign1/