function _equals(per_number , next_number, operation){
	switch (operation){
		case '+':
			per_number += next_number;
			break;
		case '-':
			per_number -= next_number;
			break;
		case '*':
			per_number *= next_number;
			break;
		case '/':
			if(next_number ==0 ){
				per_number = null;
			}else{
				per_number /= next_number;
			}
			break;
	}
	if(per_number == null){
		return NaN;
	}else{
		return per_number;
	}
}

function indexofFn(str,font){
	var i = 0 ;
	var sum = 0;
	while (str.indexOf(font,i) > -1) {
			//在找到的时候循环
			sum ++;//找到后+1
			i=str.indexOf(font,i) + 1;
			//在位置之后再开始查找
		}
		return sum;
}

//方法1
function max(){
	var max = arguments[0];//记录第一个值，假装它是最大的
	for (var i=1; i<arguments.length;i++) {
		//记录了第一个，就从第二个开始比较
		if(max<arguments[i]){
		//判断它是否真的最大，一个一个去比较
			max = arguments[i];//比它大就替换
		}
	}
	return max;//比较结束后返回最大值
}

//方法2
function max(){
	for (var i=0; i<arguments.length;i++) {
		//从第一个开始
		if(arguments[i]>arguments[i+1]){
		//第一个和第二个比较
			arguments[i+1] = arguments[i];
			//第二个小于第一个，替换第二个，再与第三个比较
		}
	}
	return arguments[i-1];//比较结束后返回最大值
}
//调用
alert(max(5,8,6,9,1,3,7,2,4));

/*myrandom(min,max) min到max范围的随机数*/

function myrandom(min,max){
	var rnd = Math.round(Math.random()*(max-min)+min);
	return rnd;
}
//调用
alert(myrandom(1,2));

function getTimeFn(year,month,day){
	setInterval(function(){
		var  oDate = new Date();
		//默认当前时间
		var d = new Date(year+"/"+month+"/"+day);
		var time = parseInt((d-oDate)/1000);
		var day = parseInt(time/86400);
		var h =  parseInt(time%86400/3600);
		var m = parseInt(time%3600/60);
		var s = parseInt(time%60);
		return [day,h,m,s];
	},1000);
}

function sort(arr){
	for (var i=0; i<arr.length;i++) {
		//遍历每一个
		for (var j=i+1; j<arr.length;j++) {
		//比较每一个
			if(arr[i]-arr[j]>0){
			//判断大小
				//调转位置
				var a = arr[i];
				arr[i] = arr[j];
				arr[j] = a;
			}
		}
	}
	return arr;//结束返回数组
	
}
var arr = [18,5,9,6,4,19,3,2,7,1,8,0];
document.write(sort(arr));

var arr=[5,2,1,1,1,1,3,5,6,6,6,6,2,8,3,5,9,9,9,9,9,9,9];
	// 0  arr[0]==arr[5] 如果是重复 删掉arr[5]
	//splice(5,1)
	
	function noRepeat(arr1) {
		for (var i = 0; i < arr1.length; i++) {
			//每个遍历一次
			for (var j = i+1; j < arr1.length; j++) {
			//与后面每个比较
				if (arr1[i]==arr1[j]) {
					arr1.splice(j,1);
					//相同清除
					j--;
					//清除后，位置变化，j就要返回上一个
				}
			}					
		}
		return arr1;//结束返回数组
	}
	var arr1 = noRepeat(arr);
	alert(arr1);

var arr=[5,2,1,1,1,1,3,5,6,6,6,6,2,8,3,5,9,9,9,9,9,9,9];

	function noRepeat(arr1) {
		var newArr = [];//定义存放数组中不相同的值
		newArr.push(arr1[0])//初始化
		for (var i = 1; i < arr1.length; i++) {
		//每个遍历一次
			for (var j = 0; j < newArr.length; j++) {
			//与后面每个比较
				if (newArr[j]==arr1[i]) {
				/*判断新数组的值是否与数组当前值相等，是就退出当前循环*/
					break;
				}
			}	
			/*判断新数组是否完全遍历，如果不是说明新数组的值与数组当前值相等，则不添加入新数组，否则反之*/
			if (j==newArr.length) {
				newArr.push(arr1[i]);
				// newArr[newArr.length] = arr[i]
			}			
		}
		return newArr;//结束返回数组
	}
	var arr1 = noRepeat(arr);
	alert(arr1);

function timerFn(n){
	var timer = setInterval(function(){
		n-=0.02;//每20毫秒-0.02
		if(n <= 0){
			clearInterval(timer);
			n=0;//有偏差，强制为0
		}
		return n.toFixed(2);//取小数点后两位
	},20)//20毫秒每次，五次就获得一秒，减少偏差
}

function sortFn(arr){
	arr.sort(function(){return Math.random()-0.5});
	return arr;
}

function moveFn(){
		move_bol = true;
		//记录动画开始
		var start = parseInt(inner.style.left) || 0;
		//初始位置
		var change = -(inner.children[0].offsetWidth)*index-start;
		//移动的距离
		var t = 0;//第几步开始
		var endT = 30;//执行步数
		
		var timer = setInterval(function(){
			t++;//每30毫秒加一步
			if(t >= endT){
				clearInterval(timer);//endT步后清除计时器
				move_bol = false;//记录动画结束
			}
			//调用了贝塞尔曲线，详情请看图片切换案例
			var l = Tween.Bounce.easeOut(t, start, change, endT);//计算每30毫秒移动的距离
			inner.style.left = l+'px';//移动
		},30)
	}



function moveFn(){
			move_bol = true;//记录动画开始
			var start = parseInt(inner.style.left) || 0;//初始位置
			var change = -(inner.children[0].offsetWidth)*index - start;//移动的距离
			var t = 0;//第几步开始
			var endT = 30;//执行步数
			
			var timer = setInterval(function(){
				t+=1;
				//每30毫秒加一步
				if(t>=endT){
					clearInterval(timer);//endT步后清除计时器
					move_bol = false;//记录动画结束
				}
				var l = start + (change*t/endT);
				inner.style.left = l+'px';//移动
			},30)
		}

function showFn(before){
	move_bol = true;//记录动画开始
	var t = 0;
	for(var i=0; i< img.length; i++){
		img[i].style.zIndex = 0;
		if(before!=i){
			img[i].style.opacity = 0;
		}
	}
	img[index].style.zIndex = 1;
	var timer = setInterval(function(){
		t++;
		if(t >= 50){
			clearInterval(timer);
			move_bol = false;//记录动画结束
		}
		img[index].style.opacity = t/50 ;
	},30)
}

/*获取标签最终top和left obj 需要获取的标签对象 返回json{top:xxx,left:xxxxx}*/

function offsetFn(obj) {
	var t = 0;
	var l = 0;
	while(obj){
	/*询问对象是否存在，存在才执行代码块 边框默认不添加进去，需要自己遍历添加*/
		var bT = parseInt(getStyle(obj,"borderTopWidth"));
		//borderTop的宽度
		var bL = parseInt(getStyle(obj,"borderLeftWidth"));
		//borderLeft的宽度

		t += obj.offsetTop + bT ;
		l += obj.offsetLeft + bL;
		obj = obj.offsetParent;//父级替换子级
	}
	return {"top":t,"left":l};//返回json
}

/*获取标签计算后的样式 参数obj：标签元素   attr：样式属性currentStyle：IE可标识,非IE不可标识 getComputedStyle：IE不可标识,非IE可标识*/

function getStyle(obj,attr){
	return obj.currentStyle?obj.currentStyle[attr]:getComputedStyle(obj,null)[attr];
}

/*findUl 找到孙子并隐藏孙子及孙子下所有的子级 obj 孙子的爷爷利用递归 逐级找到孙子以及孙子下所有的子级，并隐藏所有找到的子级*/
function findUl(obj){
	var lis = obj.children;//获取元素儿子
	for (var i=0; i < lis.length; i ++) {
		if(lis[i].children[0]){
			findUl(lis[i].children[0]);//递归
			lis[i].children[0].style.display = 'none';//找完后，隐藏元素儿子
		}
	}
}

//查找下一个节点函数 obj参数为当前标签元素

function nextFn (obj) {
	return obj.nextElementSibling?obj.nextElementSibling:obj.nextSibling;
}
//调用
nextFn(li[1]).style.background = 'burlywood';
	
	
//查找上一个节点函数 obj参数为当前标签元素
function previousFn(obj){
	return obj.previousElementSibling?obj.previousElementSibling:obj.previousSibling;
}
//调用
previousFn(li[4]).style.background = 'skyblue';
	
//查找第一个子节点函数 obj参数为第一个子节点的父级标签元素

function firstFn(obj){
	return obj.firstElementChild?obj.firstElementChild:obj.firstChild;
}
//调用
firstFn(ul).style.background = 'palegreen';
	
	
//查找最后一个子节点函数 obj参数为最后一个子节点的父级标签元素

function lastFn(obj){
	return obj.lastElementChild?obj.lastElementChild:obj.lastChild;
}
//调用
lastFn(ul).style.background = 'coral';

//自定义封装一个通过标签名的函数 tag参数为大写标签名 范围是全文的标签 返回一个数组

function TagName (tag) {
	var childs = wrap.childNodes;
	var arr = [];
	for (var i=0;i<childs.length;i++) {
		//nodeType：节点类型   nodeName：节点名
		if (childs[i].nodeType == 1 && childs[i].nodeName == tag) {
			arr.push(childs[i]);
		}
	}
	return arr;
}

// 函数注释 改变元素滚动条高度动画函数 end参数是最终高度，不可为空 fn参数是计时器结束后执行的回调函数，可为空
function myFn(end,fn){
	var start = document.body.scrollTop || document.documentElement.scrollTop ;//初始高度
	var change = end - start;//改变的高度值
	var t = 0;//第几步开始
	var endT = 30;//执行步数
	var timer = setInterval(function(){
	//设置计时器
		t++;//每30毫秒加一步
		if(t >= endT){
		//当到达第30步时执行if里的代码块
			clearInterval(timer);//endT步后清除计时器
			//如果fn是一个函数则执行fn()，否则不执行
			fn && fn();
		}
		var sTop = Tween.Bounce.easeOut(t, start, change, endT);//计算每30毫秒移动的距离
		document.body.scrollTop = sTop;
		document.documentElement.scrollTop = sTop;
	},30);
}

/* loadImageFn 预加载图片函数 arr参数是图片数组 fn是过程回调函数 over是结束回调函数 IE6判断不了 */

function loadImageFn (arr,fn,over) {
	var index = 0;//加载第几张
	for (var i=0; i < arr.length; i++) {
		var img = new Image();//定义一个图片的对象
		img.src = 'img/'+ arr[i];//设置路径
		img.onload = function(){
			index ++; //加载
			if (index == arr.length) {
			//图片加载完成后
				alert('加载完成!')
				over && over();//结束回调函数
			}
			fn && fn(index);//过程回调函数
		}
	}
}

// function show() {
// 	alert("函数");
// }
// show() 只有函数被调用，才会被之执行


var show = function () {
	alert("函数");
	return 1;//函数结束后的返回值，如果没有就是undefined
	alert("内容");//return 后面的内容不会再执行
}
alert(show())
//return 语句还有一个功能就是退出当前函数，注意和break 的区别。PS：break 用在循环和switch 分支语句里。

//传参
var show = function (a,b) {
	var a = 7;//模拟
	var b = 9;//模拟
	var sum = a + b;
	return sum;
}

// alert(show(7,9))
alert(show(15,38))

//利用arguments写一个找最大值的变量
function max() {
	var max = arguments[0];
	// alert(arguments.length);
	for (var i = 1; i < arguments.length; i++) {
		if (max<arguments[i]) {
			max = arguments[i];
		}
	}
	return max;		
}	
alert(max(1,2,3,35,4,5,6,7,8))

//匿名函数
var num = (
	function(a,b){
	//alert(a+b);
	return a+b;
	}
)(3,4);
alert(num);

var a = 5;//全局变量

/*函数里面的变量定义了就是局部变量，只能在当前函数里面使用*/

function show() {
	var a = 10;
	alert(a);
}
show();//弹10
alert(a);//弹5

var a = 15;
function show1() {
	a = 10;
	function show2() {
		alert(a)//第一次弹undefined
		var a = 5;
		alert(a);//第二次弹5
	}
	show2();
	alert(a);//第三次弹10
}
show1()
alert(a)//第四次弹15

var a = 6;
setTimeout(function () {
    alert(a);//66
    a = 666;
 }, 1000);

 a = 66;

var a = 6; //a=6
	(function(){
		(function () {
		    alert(a);
		    a = 666;//a = 666
		})();
	})();
	a = 66; 
	alert(a)//a =66

//匿名函数
	var num = (function (a,b) {
		// alert(a+b);
		return a+b;
	})(3,4)
	
	alert(num)//弹7

	function show(a,b) {
		alert(a+b)//弹7
	}
	show(3,4);

/*什么闭包：function函数就是一个闭包，闭包里面的变量是封闭的，函数外面不可以获取。主要功能：function里面再嵌套一个函数，把这个函数返回出去 赋给外面的变量，函数外面就可以获取到函数里面的内容 注意的问题：闭包要注意内存溢出的问题，不可以乱用，需要用得才用*/

function a() {
	var i = 5; // a_i;
	function b(n) {
		i += n;//a_i
		return i;
	}
	return b;
}	
var c = a();
c(5)
alert(c(5))//15

// alert(c(1));6
// alert(c(5));11

var arr = [5,2,1,1,1,1,3,5,6,6,6,6,2,8,3,5,9,9,9,9,9,9,9];
	// 0  arr[0]==arr[5] 如果是重复 删掉arr[5]
	//splice(5,1)
	
	function noRepeat() {
		for (var i = 0; i < arr.length; i++) {
		//每个遍历一次
			for (var j = i+1; j < arr.length; j++) {
			//与后面每个比较
				if (arr[i]==arr[j]) {
					arr.splice(j,1)//相同清除
					j--;//清除后，位置变化，j就要返回上一个
				}
			}					
		}
		return arr;//结束返回数组
	}
	var arr = noRepeat();
	alert(arr);

var arr = [5,2,1,1,1,1,3,5,6,6,6,6,2,8,3,5,9,9,9,9,9,9,9];
	// 0  arr[0]==arr[5] 如果是重复 删掉arr[5]
	//splice(5,1)	
	function noRepeat() {
		var newArr = [];//定义存放数组中不相同的值
		newArr.push(arr[0])//初始化
		for (var i = 1; i < arr.length; i++) {
		//每个遍历一次
			for (var j = 0; j < newArr.length; j++) {
			//与后面每个比较
				if (newArr[j]==arr[i]) {
				//判断新数组的值是否与数组当前值相等，是就退出当前循环
					break;
				}
			}	
			/*判断新数组是否完全遍历，如果不是说明新数组的值与数组当前值相等，则不添加入新数组，否则反之*/
			if (j==newArr.length) {
				newArr.push(arr[i]);
				// newArr[newArr.length] = arr[i]
			}			
		}
		return newArr;//结束返回数组
	}
	var arr = noRepeat();
	alert(arr);

var arr = [5,3,2,4,8,1,7,6];

	function px() {
		document.write("i="+0+";j="+0+"-"+arr+"<br>");
		for (var i = 0; i < arr.length; i++) {
			for (var j = i+1; j < arr.length; j++) {
				if (arr[i]>arr[j]) {
					var num = arr[i];
					arr[i]=arr[j];
					arr[j]=num;					
				}
				document.write("i="+i+";j="+j+"-"+arr+"<br>");
			}
			document.write("<br>");
		}
		return arr;
		
	}

	var arr = px();
	alert(arr);

// var oDate = new Date(2015,5,30);
// var oDate = new Date('2015-6-29');
var oDate = new Date()//当前时间


var year = oDate.getFullYear();//获取年份
var month = oDate.getMonth();//获取月份 0-11
var day = oDate.getDate();//获取多少号
var week = oDate.getDay();
//返回星期几，0 表示星期日，6 表示星期六
var hour = oDate.getHours();//获取时
var minutes = oDate.getMinutes()//获取份
var second = oDate.getSeconds();//获取秒
var time = oDate.getTime();//获取时间戳
document.body.innerHTML = '';
document.write("年份:"+year+"<br>")
document.write("月份:"+month+"<br>")
document.write("日:"+day+"<br>")
document.write("星期:"+week+"<br>")
document.write("时:"+hour+"<br>")
document.write("分:"+minutes+"<br>")
document.write("秒:"+second+"<br>")
document.write("时间戳:"+time+"<br>")

/*一次性定时器 setTimeout（a,b）; a:函数 b:时间-每隔多少毫秒执行一次a的这个函数*/

setTimeout(function(){
	alert('一次性定时器');
},1000)

/*循环性定时器 setInterval（a,b）; a:函数 b:时间-每隔多少毫秒执行一次a的这个函数*/

// setInterval(function(){
// alert('循环性定时器');
// },1000)
var i = 0;
var  timer = setInterval(function(){
	i++;
	if (i>5) {
		clearInterval(timer);
	} else {					
		//alert('循环性定时器');
	}
},1000)

setInterval(function () {
	var oDate = new Date()//当前时间
	var d = new Date("2016-6-9");
	//计算当前时间到端午节的时间戳 秒数
	var time = parseInt((d-oDate)/1000);
	//剩余天数 = 秒/（24*60*60）
	var day = parseInt(time/86400);
	//剩余小时数 = 秒%（24*60*60）/(60*60)
	var h = parseInt(time%86400/3600);
	//剩余分钟数 = 秒%(60*60)/60
	var m = parseInt(time%3600/60);
	//剩余秒数 = 秒%60
	var s = parseInt(time%60);

	document.body.innerHTML = "距离端午节放假还有："+day+"天-"+h+"小时-"+m+"分"+s+"秒";
},1000)

//画出时钟
document.write('<div class="wrap">');
for (var i = 0; i < 60; i ++) {
//画出刻度
document.write("<span class='seconds' style='transform: rotate("+i*6+"deg) translate(190px)'></span>")
}
document.write("<div class='time'>")
document.write("<div class='h'></div>");//时针
document.write("<div class='m'></div>");//分针
document.write("<div class='s'></div>");//秒针
document.write("</div>");//类time结束
document.write('</div>');//类wrap结束
//通过类获取时分秒针
var s = document.getElementsByClassName('s')[0];
var m = document.getElementsByClassName('m')[0];
var h = document.getElementsByClassName('h')[0];
timer();//初始分秒的旋转角度
setInterval(function(){
//循坏计时，每秒刷新一次达到时钟效果
	timer();
},1000)
function timer(){
//获取当前时分秒的旋转角度
	var oDate = new Date();
	//秒针一圈60刻度，每秒6度，所以得出每秒旋转6度
	s.style.transform = 'rotate('+(oDate.getSeconds()*6)+'deg) translateY(-80px)';
	//分针一圈60刻度，每分6度，每秒旋转 秒/360*6*6所以得出每秒旋转oDate.getMinutes()*6+oDate.getSeconds()*0.1度
	m.style.transform = 'rotate('+(oDate.getMinutes()*6+oDate.getSeconds()*0.1)+'deg) translateY(-70px)';
	//时针一圈12刻度，每时30度，每分旋转 分/360*30*6所以得出每分旋转oDate.getHours()*30+oDate.getMinutes()*0.5度
	h.style.transform = 'rotate('+(oDate.getHours()*30+oDate.getMinutes()*0.5)+'deg) translateY(-60px)';
}

var a = window.navigator.userAgent;
//获取浏览器信息
//查找字符判断浏览器类型
if(a.indexOf('OPR')>-1){
	alert('欧朋')
}else if(a.indexOf('Chrome')>-1){
	alert('谷歌')
}else if (a.indexOf('Firefox')>-1){
	alert('火狐')
}else if('Safari'){
	alert('苹果')
}else if('IE 8'){
	alert('IE 8')
}