function set(){
	this.values = {};				//集合数据保存在对象的属性里
	this.n = 0;						//集合中值得个数
	this.add.apply(this,arguments);	//将所有参数都添加进这个集合里
}
//在函数原型对象中定义将所有参数添加进集合的函数
set.prototype.add = function(){
	for(var i = 0 ; i < arguments.length; i++){
		var val = arguments[i];
		var str = Set.v2s(val);
		if(!this.values.hasOwnProperty(str)){
		this.values[str] = val;
			this.n++;
		}
	}
	return this;
};
//如何集合包含这个值，则返回true，否则，返回false
Set.prototype.contains = function(value){
	return this.values.hasOwnProperty(Set.v2s(value));
};
//返回集合的大小
Set.prototype.size=function(){
	return this.n;
}
//遍历集合中的所有元素，在指定的上下文调用f
Set.prototype.foreach = function(f, context){
	for(var s in this.values){
		if(this.values.hasOwnProperty(s)){
			f.call(context, this.values[s])
		}
	}
};
//这是一个内部函数，用以将任意JavaScript值和唯一的字符串对应起来
set._v2s = function(val){
	switch(val){
		case undefined:
			return 'u';
		case null:
			return 'n';
		case true:
			return 't';
		case false:
			return 'f';
		default: switch(typeof val){
			case 'number': return '#' + val;
			case 'string': return '"' + val;
				default:return '@' + obejctId(val);
		}
	}
	//对任意对象来说，都会返回一个字符串
	//针对不同的对象，这个函数会返回不同的字符串
	//对于同一个对象多次调用，总是返回相同的字符串
	//为了做到这一点，它给o创建了一个属性，在ES5中，这个属性是不可枚举且是只读的
	function objectId(o){
		var prop = "|**obejctId**|";
		if(!o.hasOwnProperty(prop))
			o[prop] = Set._v2s.next++;
		return o[prop];
	}
}
Set._v2s.next = 100;

//inherit()函数返回了一个继承自原型对象p的属性的新对象
//这里使用ECMAScript5中的Object.create()函数（如果存在的话）
//如果不存在Obejct.create()，则退化使用ECMAScript3支持的方式
function inherit(p){
	if(p == null){
		throw TypeError();
	}
	//如果支持ECMAScript5的Obejct.create语法
	//则直接用Obejct.create()生成一个对象并将其原型属性设置为
	if(Object.create){				
		return Object.create(p);
	}
	//进一步检查传入参数p的类型
	var t = typeof p;						
	if(t !== "object" && t != "function"){
		throw TypeError();
	}
	//声明一个空构造函数f
	function f(){};
	//将f的原型属性设置为p			
	f.prototype = p;			
	return new f();
}
                                                                    
function range(from, to){
	var r = inherit(range.methods);
	r.from = from;
	r.to = to;
	return r;
}
range.methods = {
	//此函数用于判断参数x是否在范围内，如果在范围内则返回true；否则返回false
	//这个方法可以比较数字范围，也可以比较字符串和日期范围
	includes:function(x){
		return this.from <= x && x <= this.to;
	},
	//对于范围内的每个整数都调用一次f
	//这个方法只可用于数字范围确定
	foreach: function(f){
		for(var x = Math.ceil(this.from); x <= this.to; x++){
			f(x)
		}		
	},
	toString: function(){
	}
}
var f = range(1, 3);
r.includes(2) //=> true 2在这个范围内
r.foreach(console.log)	//输出1, 2, 3

var data = [1,1,3,5,5];
//求平均数就是将所有的元素累加后的值除以元素的个数
var total = 0;
for(var i = 0; i<data.length; i++){
	total += data[i];
}
var mean = total/data.length;
//求标准差就是每个元素减去平均数之后偏差的平方然后求和
total = 0;
for(var i = 0; i< data.length; i++){
	var deviation = data[i]-mean;
	total += deviation * deviation;
}
var stddev = Math.sqrt(total/(data.length -1))

var sum = function(x,y){
	return x+y;
}
var squre = function(x, y){
	return x*y;
}
var data = [1, 2, 3, 4, 5, 6];
//求平均数
var mean = data.reduce(sum)/data.length;
//将数组中的每个元素减去平均值然后返回新的数组
var deviations = data.map(function(x){return x-mean;});
//将返回的新数组调用map函数使求得每个元素的平方然后再返回一个新的数组
//然后再将重新返回的数组调用reduce函数使各元素值相加
var stddev = Math.sqrt(deviations.map(squre).reduce(sum)/(data.length -1));

//这个高阶函数返回一个新的函数，这个新函数将他的实参传入f()
//并返回f的返回值的逻辑非
function not(f){
	return function(){
		var result = f.apply(this,arguments);
		return result;
	}
}
//判断x是否为偶数的函数
var even = function(x){
	return x % 2 === 0;
};
//一个新函数，所做的事情和even()相反
var odd = not(even);
[1, 1, 3, 5, 5].every(odd); // => true:每个元素都是奇数;

var array = [1, 2, 3, 4];

new Array(5);