工作中经常要对window.location进行相关的操作，在这里列出它的属性和方法，方便查找。现以链接http://julabs.me:8080/blog/front/javascript-window-location.html?author=julabs#comment为例来讲解window.location的属性：

下表列出的是window.location的方法：

function isIdCardNo(arg){
	return /(^\d{15}$)|(^\d{17}(?:\d|x|X)$)/.test(arg);
}

当然这个函数非常简单，不过能用就可以了。

YUICompressor

YUICompressor是建立在rhino interpreter基础上的，所以它的特点就是安全。YUICompressor是用Java编写的，要运行它首先要配置好Java环境。YUICompressor的压缩内容如下：

• 移除注释
• 移除额外的空格
• 细微优化
• 标识符替换（Identifier Replacement）

使用YUICompressor的命令行代码如下：

java -jar yuicompressor-x.y.z.jar myfile.js -o myfile-min.js --charset utf-8

YUICompressor在压缩时还能够自动检查JS代码是否有错误，如果有错误它会列出错误的行数和原因。更难得的是，它也可以压缩CSS文件，对于前端人员简直就是一把多功能的瑞士军刀。

淘宝UED部把YUICompressor封装成了TBCompressor，这里有篇《TBCompressor介绍》，使用TBCompressor更加简单快捷。

Closure Compiler

Closure Compiler是Google公司公布的一款JS压缩工具，和YUICompressor相比，它的压缩率稍微高点，只是稍微，但对代码的准确率要求更高点。这里有一篇LifeSinger整理的《Closure Compiler vs YUICompressor》，讲述了两者的异同，可以做为选择的一个参考。

Closure Compiler使用的命令行代码如下：

java -jar compiler.jar --js hello.js --js_output_file hello-compiled.js

Closure Compiler还不仅提供了一个网络版可以直接在网页上压缩，而且还开放了API，你可以用HTML、Python或者其它语言文件调用这个API来压缩JS文件。

Packer

Packer是目前压缩率最高的JavaScript压缩工具，由Dean Edwards创建的。压缩后的JavaScript文件相当于一个ZIP文件，在执行的时候能够自动解压。不过带来的副作用就是对于编写不严格的代码，压缩时会出错，可以在压缩前用JSMin检查下。虽然Packer压缩后的代码在执行时先要自解压下，会降低执行效率，但对于大型文件来说，Packer的压缩率通常能达到50%，因而能加快下载速度。

Packer不仅有网页版，还有.NET、perl和PHP版。

动态载入JavaScript非常简单，代码演示如下：

var head= document.getElementsByTagName('head')[0];
var script= document.createElement('script');
script.type= 'text/javascript';
script.src= 'test.js';
head.appendChild(script);

侦测JavaScript是否载入

我们常常用JavaScript来给其它元素添加load事件，但如果给一个script自身添加load事件还真不是一件容易的事。对于非IE的高级浏览器来说和一般元素添加事件方法是一样的，代码演示如下：

script.onload=function(){
	// do something
};

但对于IE来说则要复杂一点，不能直使用onload，而要使用onreadystatechange事件，通过onreadystatechange事件来判断script元素的readyState属性是否等于complete或者loaded，从而来确认script元素是否已经载入。代码演示如下：

script.onreadystatechange=function(){
	if(this.readyState == 'loaded' || this.readyState == 'complete'){
		// do something
	}
};

readyState具有以下几个状态值：

1. 0 : uninitialized
2. 1 : loading
3. 2 : loaded
4. 3 : interactive
5. 4 : complete

注意：在IE中complete或者loaded值是不会一起出现的，IE中会忽略一些状态，所以只需要判断它俩中的一个就可以了。

对于JavaScript不存在的处理

如果动态载入的JavaScript文件不存在的话，非IE浏览器会一直请求。在IE6、IE7中，script的属性值readyState会返回一个loading值，但有时候延迟久了会返回一个loaded值。而在IE8中，script的属性值readyState仍然会返回一个complete，这个很奇怪。

最终方案

这里根据jQuery里面的代码修改了下，增加了载入错误的回调功能。代码演示如下：

/**
 * 动态载入 javascript 脚本
 * @author <a href="mailto:jon.ju@msn.com">Jon</a>
 * @param {Object} options 选项
 * @param {String} options.url 脚本的 url 地址
 * @param {Function} options.callback 脚本完成载入后回调的函数
 * @param {Function} options.error 脚本没有按时载入时回调的函数
 * @param {Number} options.time 请求超时时间,默认为 5 秒
 * @param {String} options.charset 脚本的编码
 */
function insertScript(options){
	var head = document.getElementsByTagName("head")[0] || document.documentElement,
	script = document.createElement("script");
	script.src = options.url;
	var done=false, // 是否完成脚本载入的标识
	timer; // 超时时间
	if (options.charset) {
		script.charset = options.charset;
	}

	script.onload = script.onreadystatechange = function() {

		if ( !done && (!this.readyState ||
				this.readyState === "loaded" || this.readyState === "complete") ) {
			done = true;
			// 如果有计时器，去除
			if(timer)clearTimeout(timer);
			if(options.callback)options.callback.call();

			// 防止 IE 下的内存泄漏
			script.onload = script.onreadystatechange = null;
			if ( head && script.parentNode ) {
				head.removeChild( script );
			}

		}
	};

	// 如果有错误回调函数，则超过一定时间就去除 script 的相关设置
	if(options.error){
		timer = setTimeout(function(){
			// 如果还没有完成
			if(!done){
				script.onload = script.onreadystatechange = null;
				if ( head && script.parentNode ) {
					head.removeChild( script );
				}
				if(options.error){
					options.error.call();
				}
			}
		},options.time || 5000);
	}

	head.appendChild(script);

}

假设有个在动态载入的test.js文件，里面的代码是这样的：

var myVar = 'OK';

载入代码为：

insertScript({
	'url':'test.js',
	'callback':function(){
		// IE 在文件不存在时也会触发 callback 函数，
		// 所以在这里要加个判断
		try{
			alert(myVar);
		}catch(e){
			alert('error');
		}
	},
	'error':function(){
		alert('error');
	},
	'time':1000
});

如果test.js存在，则会alert出“OK”，如果文件不存在IE8会立即alert出“error”，而其它常用浏览器过1秒后会alert出“error”。

私有属性和方法

var Book = function(newName){
    // 私有属性
    var name;

    // 私有方法
    function checkName(name){
        // ...
    }

    // 特权方法
    this.getName = function(){
        return name;
    };

    // 特权方法
    this.setName = function(newName){
        name = newName || 'No Name';
    };

    // 构造代码
    this.setName(newName);

};

var book01 = new Book('name01');
console.log(book01.getName()); // 输出 'name01'
book01.setName('newName01');
console.log(book01.getName()); // 输出 'newName01'

在本例中用var声明私有变量，这意味着它们只存在于Book构造器，checkName函数也是用同样的方法声明的，因此成了一个私有属性。

要想访问这些私有属性和方法的函数只需声明在Book中即可，这些方法称为特权方法(privileged method)，它们是公有方法，为了能够在对象外部访问这些特权函数，它们的前面都要加上关键字this。其它任何不需要直接访问私有属性的方法都可以放在像Book.prototype中声明。

静态属性和方法

var Book = (function(){
    // 私有静态属性
    var numOfBook = 0;

    // 构造函数
    var cotr = function(argument){
        // 私有属性
        var name;

        // 私有方法
        function checkName(name){
            // ...
        }

        // 特权方法
        this.getName = function(){
            return name;
        };

        numOfBook++;
    };

    // 特权静态方法
    cotr.getNumOfBook = function(){
        return numOfBook;
    };

    // 返回构造函数
    return cotr;

})();

// 公有静态方法
Book.display = function(){
    // ...
};

var book01 = new Book();
var book02 = new Book();
console.log(Book.getNumOfBook()); // 输出 2

在这里私有成员和特权成员仍然被声明在构造函数中，但原来的那个构造函数却从一个普通的函数变成了一个内嵌函数，并且被作为包含它的函数的返回值赋给变量Book。这就创建了一个闭包，可以把静态的私有成员声明在里面。位于外层函数声明之后的一对空括号很重要，其作用是代码一载入就立即执行这个函数。这个函数的返回值是另一个函数，它被赋给Book变量，Book因此成了一个构造函数。在实例化Book时，所调用的是这个内层函数，外层那个函数只是用于创建一个可以用来存放静态私有成员的闭包。

首先创建一个函数，用于判断一个节点是否只含有文本内容：

/**
 * 判断该节点是否只包含文本节点
 * @param {Object} node 用于判断的 节点
 * @return {Boolean} 如果只包含文本内容为 true
 */
var nodeHasValue = function(node){
	if(node){
		var child = node.firstChild;
		if (child && child.nextSibling === null && (child.nodeType === 3 /* Node.TEXT_NODE */ || child.nodeType === 4 /* CDATA_SECTION_NODE */))
			return true;
	}
	return false;
}

下面是nodeToObject函数，是整个功能模块的核心，它的功能是把节点（node）转换成JSON格式：

/**
 * 把 Node 转换成 JSON 格式
 * @param {Object} node 用于转换的 节点
 * @requires EYoo.XML.nodeHasValue 判断该节点是否只包含文本节点
 * @return {Object} obj JSON 格式的信息
*/
var nodeToObject = function(node){
	if (!node)
		return null;
	var obj = {};
	// Add all attributes as properties of the object.
	for (var i = 0; i < node.attributes.length; i++){
		var attr = node.attributes[i];
		var attrName = "@" + attr.name;
		obj[attrName] = attr.value;
	}

	var child;
	// 判断该节点是否只包含文本节点
	if(nodeHasValue(node)){
		try{
			child = node.firstChild;
			if (child.nodeType == 3 /* TEXT_NODE */){
				obj[child.nodeName] = child.data;
			}else if (child.nodeType == 4 /* CDATA_SECTION_NODE */){
				obj[child.nodeName] = child.data;
			}
		}catch(e){
			throw("nodeToObject() exception caught: " + e + "\n");
		}

	}else{
		// 如果不是文本节点
		child = node.firstChild;
		while(child){
			if (child.nodeType == 1 /* Node.ELEMENT_NODE */){
				var isArray = false;
				var tagName = child.nodeName;

				// 如果已经存在该节点信息了，则转换成 Array 类型
				if(obj[tagName]){
					if(obj[tagName].constructor != Array){
						var curValue = obj[tagName];
						obj[tagName] = new Array;
						obj[tagName].push(curValue);
					}
					isArray = true;
				}
				var childObj = nodeToObject(child);

				if (isArray)
					obj[tagName].push(childObj);
				else
					obj[tagName] = childObj;
			}
			child = child.nextSibling;
		}
	}
	return obj;
}

最后就是documentToObject函数，它的功能是把整个XML文档转换成JSON格式：

var documentToObject = function(xmlDoc){
	var obj = null;
	if(xmlDoc && xmlDoc.firstChild){
		var child = xmlDoc.firstChild;
		while(child){
			if(child.nodeType == 1 /* Node.ELEMENT_NODE */){
				obj = {};
				obj[child.nodeName] = nodeToObject(child);
				break;
			}
			child = child.nextSibling;
		}
	}
	return obj;
}

另外还有一个encodeEntities函数，它的功能是对文本内容进行转义，防止在使用innerHTML方法时会出现错误：

var encodeEntities = function(str){
	if (str && str.search(/[&<>"]/) != -1){
		str = str.replace(/&/g, "&amp;");
		str = str.replace(/</g, "&lt;");
		str = str.replace(/>/g, "&gt;");
		str = str.replace(/"/g, "&quot;");
	}
	return str;
}

下面是使用typeof来判断对象类型的用法，它返回一个字符串：

var obj = "I'm string!";
alert(typeof obj === 'string');

而constructor方法会返回一个构造函数：

alert(obj.constructor == String);

下面这个表展示了用上述的两种方法对不同类型对象进行类型检查的结果。

从这个表看来，把变量的构造函数作为对象类型引用是最不容易犯错的合法类型检查，通过name属性就可以获得对象类型的名称。

console.log(obj.constructor.name);