2020-web前端-自己的比较JavaScript-基础

水深无声 2022-12-13 01:21 134阅读 0赞

\*/

=变量==========>

操作的数据都是内存中操作
          js中存储数据使用变量的方式（名字，值------>数据）
          js中声明变量都是var------->存储数据，数据应该有对应的数据类型
          js中的字符串类型的值都是用双引号后者单引号
    
          存储一个数字10
          变量的声明以及赋值
          var num = 10
    
          存储一个名字
          var name = "小汪"
    
    
          变量-------作用，存储数据的或者是操作数据
          变量声明  （有var 有变量名字，没有值）
          变量初始化（有var，有变量名，有值）
    
          变量声明的方式：
            var 变量名字;
    
            var number; //变量的声明，此时是没有赋值的,    -->返回undefined
            var x,y,z,k,j;//一次性声明多个变量            -->返回undefined
    
            变量的初始化（变量声明的同时并且赋值）
    
             = 的意义：赋值的含义
    
            var number = 10;//存储一个数字10
            console.log(number);
    
            //存储一个名字
            var name = "小汪";
    
            //存储一个真（true）
            var flag = true;
    
            //存储一个null   ------>相当于是空
            var nul = null;
    
            //存储一个对象
            var obj = new object();
    
    
    
    
            -------------------------------------变量的作用：
            	    用来操作数据的（可以存储，可以读取）
    
            -------------------------------------变量的声明：
            	    没有赋值的   ： var 变量名;
    
            --------------------------------------变量的初始化：
             	     有赋值的：  var 变量名 = 值；
    
            注意的基本的代码的规范：
    	        js中声明变量都是用var
    	        js中的每一行代码结束都是应该有分号的;(写代码有分号的习惯)
    	        js中的大小写是区分的： var N = 10;  != var n = 10
    	        js中的字符串可以使用单引号，也可以使用双引号。（目前我们现在暂时用到双引号）
    
           变量名的注意的问题------变量名的命名规范，要遵循驼峰命名法：
           	1.变量名字要有意义     var number = 10；
           	2.变量名有一定的规范：一般都以字母，$符号，下划线开头，中间后者后面是可以有$符号，字母，数字
           	3.变量名一般都是小写的
           	4.变量名如果是多个单词，第一个单词的首字母是小写的，后面所有的首字母都是大写的 （驼峰命名法）var bigNumber = 10;
           	5.不能使用关键字  :   for  var 
           	6.即使不会用英语单词，就用拼音，拼音也要遵循驼峰命名法
    
    
    	//声明变量并且初始化---变量的初始化---声明变量赋值
    	//声明了一个num的变量存储了一个值100，打开浏览器中的JavaScript引擎解析这行代码，就会在内存中开辟一块空间存储一个数字100，这个空间的名字就是num
           	var num = 100;
           	alter(num);   //弹窗
           	//浏览器的控制台，一般都是在浏览器的开发人员工具中（Window的快捷键就F12）的console选项中
           	console.log(num);//把内容输出在浏览器的控制台上
    
    
    
    
           	//声明多个变量然后一个一个的赋值
           	var num1,num2,num3;//声明
           	//依次赋值
           	num1 = 10;
           	num2 = 20;
           	num3 = 30;
    
           	//声明多个变量并且赋值
           	var num1 = 10, num2 = 20, num3 = 30;

\*/

\---------------------------------------------------案例：变量的交换（3种交换）---------------------------------------------

案例：变量的交换（3种交换）
    
           	//变量的交换的第一个思路：借助第三方的变量
           	var num1 = 10；
           	var num2 = 20;
           	//把num1这个变量的值取出来放在temp变量中
           	var temp = num1;  //num1 = 10   ===> temp =10
           	//把num2这个变量的值取出来放在num1变量中
           	num1 = num2;  
           	//吧temp变量的值取出来放在num2变量中
           	num2 = temp;
           	console.log(num1);  //20
           	console.log(num2);  //10
    
    
    		//第二种方式交换：一般使用于数字的交换
    		var num1 = 10;
    		var num2 = 20;
    		//把num1 的变量中的值和num2 变量中的值，取出来相加，重新赋值给num1这个变量
    		num1 = num1 + num2; //10+20=30
    		//num1变量的值和num2变量的值取出来，相减的结果重新赋值给num2
    		num2 = num1 - num2; //30-20=10
    		//num1变量的值和num2变量的值取出来，相减的结果重新赋值给num1
    		num1 = num1 - num2; //30 - 10 = 20
    		console.log(num1,num2);
    
    
    	//ctrl + alt + L-------->格式化代码的（设置代码很好看的格式，如果代码是错误的，这个快捷键是没有用的） 
    
    	//注意：变量的名字是不能重名的
    		比如：var num1 = 10；
    			var num2 = 20;
    			console.logo(num1);
    
    
    	//(第三种)扩展的变量的交换：只需要看代码，不需要理解------位运算
    	var num1 = 10;
    	var  num2 = 20;
    	num1 = num1^num2;
    	num2 = num1^num2;
    	num1 = num1^num2;
    	console.log(num1,num2);

\*/

\------------------------------------------------------------------注释------------------------------------------------------------------

注释：是解释代码的含义，是给其他程序员看的

注释的方法：  
1.单行注释：//  
\-----一般都是用在一行代码上面

2.多行注释：
                  ----一般是用在函数后者是一段代码上面
    
    注释的代码是不执行的。
    
    代码中如果没有注释，不规范，天天会被骂的

\*/

\-----------------------------------------------------------数据类型--------------------------------------------------------------  
//声明变量并且赋值  
var num = 10;

//js中的数据类型有哪些

js中的原始数据类型：number，string，boolean，null，undefined，object
    
    number ：数字类型（整数和小数）
    string：     字符串类型（值一般都是用单引号后者双引号括起来的）"34"
    boolean:   布尔类型（值只有两个：true（真1） false（假0））
    		var sex1 = true;//男
    		var sex2 = false;//女
    null:           一个对象指向为空了，此时可以赋值为null
    undefined: 未定义，值只有一个undefined
    		什么情况下的结果为undefined:
    			1.变量声明了，但是没有赋值；结果还是undefined
    				var num;
    				console.log(num);
    
    			2.函数没有明确返回值，如果接收了，结果也是undefined
    
    			3.如果一个变量的结果是undefined和一个数字进行计算，结果是：NaN不是一个数字，也是没有意义的
    				var num;
    				console.log(num + 10);//NaN ---not an number ---->不是一个数字
    object：    对象----->

=====>如何获取这个变量的类型的数据类型是什么？使用typeof来获取  
//typeof 的使用的语法  
typeof 变量名  
typeof (变量名)

var num = 10;
    var str = "小汪";
    var flag = true;
    var nll = null;
    var undef;
    var obj = new Object();
    console.log(typeof num); //number
    console.log(typeof str); //string
    console.log(typeof flag);//boolean
    console.log(typeof nll);//object  不是null的类型
    	console.log(String (nll));
    console.log(typeof undef);//undefined
    console.log(typeof obj);//object
    
    console.log("10"); //字符串类型
    console.log(10);  //数字类型

=========================>数字类型  
var num = 12;  
数字类型：整数和小数  
num = 20; //整数：  
num = 98.76;//小数：（其他语言中，浮点型—单精度，双精度浮点）  
js中所有的数字都是属于number类型  
其他的语言：  
整数类型：int  
单精度浮点型：float  
双精度浮点型：double

数字：(计算机占8个位)
    	二进制：遇见2进一   
    			00000001-----1
    			00000010-----2
    			00000011-----3
    			00000100-----4
    			00000101-----5
    			00000111-----6
    			00001000-----8
    	八进制：遇见8进一
    			00000001
    			00000002
    			00000003
    			00000004
    			00000005
    			00000006
    			00000007
    			00000010  -----8
    			00000011  -----9
    			00000012  -----12
    
    	十进制：遇见10进一
    			1
    			2
    			3
    			4
    			5
    			6
    			7
    			8
    			9
    			10
    	十六进制：遇见f进一
    			00000001
    			00000002
    			00000003
    			00000004
    			00000005
    			00000006
    			00000007
    			00000008
    			00000009
    			0000000a ---10
    			0000000b ---11
    			0000000c ---12
    			0000000d  ---13
    			0000000e  --14
    			0000000f   --15
    			00000010  ---16
    			00000011 ---17
    			00000012 ---18
    
    
    	js中可以表示那些进制
    	var num = 10;//十进制
    	var num2 = 012;//八进制
    	var num3 = 0x123;//十六进制
    	console.log(num,num2,num3);
    
    
    ----------->数字类型有范围的：（最小值和最大值）
    	console.log(Number.MAX_VALUE);
    	console.log(Number.MIN_VALUE);
    
    	无穷大：Infinity
    	无穷小：-Infinity
    
    
    	//不要用小数去验证小数 (256)
    	var x = 0.1;
    	var y = 0.2;
    	var sum = x + y;
    	console.log(sum);//0.30000000000000004
    	console.log(sum == 0.3);//false
    console.log(0.1+0.2!=0.3) // true
    
    	//不要用NaN验证是不是NaN
    	var num;
    	console.log(num + 10 == NaN);
    
    	//如果验证这个结果是不是NaN,应该使用isNaN() ----->不是数字为true，是数字为false
    	var num;//变量声明了，没有赋值，结果是：undefined
    		//是不是不是一个数字---->不是一个数字吗？NaN--->不是一个数字
    	console.log(isNaN(num));//true
    	// 判断一个是不是数字，可以用isNaN()
    
    ------------ >总结：
    	数字类型：number类型
    	无论是整数还是小数都是数字类型
    	不要用小数去验证小数
    	不要用NaN验证是不是NaN，应该是使用isNanN(值或者变量)
    	想要表示十进制：就是我们现在生活中正常的数字
    	想要表示八进制：以0开头
    	想要表示十六进制：以0x开头

=========================>字符串类型  
var str = “10”; //字符串  
var str2 = ‘10’; //字符串

//字符串可以使用双引号，也可以使用单引号
    //字符串的长度如何获取？  变量名.length
    
    var str = "Who are you?";
    //字符串的个数是多少呢？
     console.log(str.length);
    
    
     //html中的转义符：<  &lt ;    >  &gt ;     空格：&nbsp；
     //js中的字符串里面也有转移符: 
     	1.tab键 -------水平制表符
     	console.log("水平\t制表符")
    
     	2.字符串的拼接：(使用+可以把多个字符串放在一起形成一个字符串)
     			    (只要只有一个字符串，其他的是数字相加，那么结果也是拼接，不是相加)
     			    （如果有一个是字符串，另一个不是字符串，使用-号，此时会发生计算）
     		var str1 = "您好";
     		var str2 = "我好";
     		console.log(st1 + str2);
    
    
     		// 只要只有一个字符串，其他的是数字，那么结果也是拼接，不是计算
     		var str1 = "20";
     		var str2 = 40;
     		console.log(str1 + str2);
    
     		// （如果有一个是字符串，另一个不是字符串，使用-号，此时会发生计算）
     		var str1 = "30";
     		var str2 = 10;
     		// 浏览器帮助我们自动的吧字符串类型转成数字类型，这种方式叫做：隐式转换
     		console.log(str1 - str2);

=========================>布尔类型  
布尔类型：的值有两个：一个是true(真)，一个是false(假)  
var flag = 1;  
console.log(flag);

var fdf = null;
    var  num = 10 - 10;

=========================>类型转换  
//类型转换

//其他类型转数字类型：3种
    	1.parseInt();//转整数
    		1.基本用法（只接受一个参数，可以当做第二个参数默认是10）：parseInt的返回值只有两种可能，不是一个十进制整数，就是NaN。
    
    			a.将字符串转为整数。parseInt('123') // 123
    
    			b.如果字符串头部有空格，空格会被自动去除。parseInt('   81') // 81
    
    			c.如果parseInt的参数不是字符串，则会先转为字符串再转换。这个很重要
    
    			d.字符串转为整数的时候，是一个个字符依次转换，如果遇到不能转为数字的字符，就不再进行下去，返回已经转好的部分。
    
    			e.如果字符串的第一个字符不能转化为数字（后面跟着数字的正负号除外），返回NaN。
    
    			f.如果字符串以0x或0X开头，parseInt会将其按照十六进制数解析。parseInt('0x10') // 16
    
    			g.如果字符串以0开头，将其按照10进制解析。parseInt('011') // 11
    
    			h.如果参数以0开头，但不是字符串，则会先将数值转成字符串，然后解析，见规则c  parseInt(011) // 9
    
    			i.对于那些会自动转为科学计数法的数字，parseInt会将科学计数法的表示方法视为字符串，因此导致一些奇怪的结果。
    
    			parseInt(1000000000000000000000.5) // 1
    			// 等同于
    			parseInt('1e+21') // 1
    
    			parseInt(0.0000008) // 8
    			// 等同于
    			parseInt('8e-7') // 8
    
    			2.进制转换（接收两个参数）：parseInt方法还可以接受第二个参数（2到36之间），表示被解析的值的进制，返回该值对应的十进制数。默认情况下，parseInt的第二个参数为10，即默认是十进制转十进制。
    
    			a.第一个参数解析规则参照第一条基本用法
    
    			b.如果第二个参数不是数值，会被自动转为一个整数。这个整数只有在2到36之间，才能得到有意义的结果，超出这个范围，则返回NaN。如果第二个参数是0、undefined和null，则直接忽略。
    					console.log(parseInt("10"));
    					console.log(parseInt("10greg"));
    					console.log(parseInt("10.9"));
    					console.log(parseInt("w10"));//NaN
    					console.log(parseInt("10.9h"));
    
    		2.parseFloat()//转小数
    		console.log(parseFloat("10"));
    		console.log(parseFloat("10greg"));
    		console.log(parseFloat("10.9"));
    		console.log(parseFloat("w10"));//NaN
    		console.log(parseFloat("10.9h"));
    
    	
    
    
    
    //其他类型转换字符串类型
    		
    
    	总结：想要转型整数用parseInt(); 想要转小数用parseFloat();
    		想要转数字类型: Number();要比上面的两种方式严格
    
    	3.   a.   toString()
    		var num = 10;
    		console.log(num.toString());//字符串类型
    
    	     b.    String()
    	     	var num = 10;
    	     	console.log(String(num));//字符串类型
    
    	     	如果变量有意义调用.toString()使用转换
    	     	如果变量没有意义使用String()转换
    
    	     	var num;
    	     	console.log(num.toString());//无意义的
    	     	var num = null;
    	     	console.log(num.toString());//无意义
    
    
    	     	var num;
    	     	console.log(String(num));//undefined
    	     	var num = null;
    	     	console.log(String(num));//null
    
    
    //其他类型转换布尔类型
    	Boolean(值);
    	console.log(Boolean(null));//false
    	console.log(Boolean(1));//true
    	console.log(Boolean("2"));//true
    	console.log(Boolean("哈哈"));//true
    	console.log(Boolean(""));//false
    	console.log(Boolean(undefined));//false
    	console.log(Boolean(0));//false

=========================>整数和负数

var str = 10;
    console.log(-str);//-10
    
    
    var str = 10;
    console.log(+str);//10

=========================>操作符

操作符：一些符号------用来计算
    
        算数运算符：+ - * / %
             算数运算表达式：由算数运算符连接起来的表达式
        	var num = 10;
        	var result = num % 3;//num变量与3，-----10/3的余数
        	console.log(result);//1
    
        	一元运算符：这个操作符只需要一个操作数就可以进行运算的符号 ++  --
        			var num = 10;
        			var sum = num + 10;
    
        	二元运算符：这个操作符需要两个操作数就可以进行运算的符号
        	三元运算符：这个操作符需要三个操作数就可以进行运算的符号
    	复合运算符：+= -=  *=  /=  %=
    			var num = 10;
    			num += 10;//num = num + 10
    			console.log(num);//20
    
    
    			var num = 20;
    			num -= 3; //num = num -3
    			console.log(num);//17
    	    复合运算符表达式：由复合运算符连接起来的表达式
    	关系运算符：>    <     >=   <=     ==(不严格等于)        ===(严格等于)   !=(不严格不等于)    !==(严格不等于)
    		不严格等于：var str = "5";
    			          var num = 5;
    			          console.log(str == num);//true
    
    		严格等于：(类型也是要相等的)
    			            var str = "5";
    				var  num = 5;
    				console.log(str === num);//false
    	       关系运算表达式：由关系运算符连接起来的表达式
    	       关系运算表达式的结果是布尔类型
    	逻辑运算符：&&----逻辑与---并且
    		          ||------逻辑或---或者
    		          ！-----逻辑非---取反---取非
    		          逻辑运算表达式：由逻辑运算符连接起来的表达式
    		               var num1 = 10;
    		               var num2 = 20;
    		               console.log(num1 == num2 && 5 > 6);//false
    
    		           表达式1 && 表达式2
    		           如果一个为false,整个的结果就是false
    
    		           表达式1 || 表达式2
    		           如果有一个为true,整个的结果为true
    
    		           !表达式1
    		           表达式1的结果是true，整个的结果是false
    		           表达式1的结果是false，整个结果为true
    		           var num = 20；
    		           console.log(num > 10 || 5 < 0);//true
    
    		算数运算：是有优先级的
    			var num = 10;
    			var sum = num + 10 * 5;
    			console.log(sum);//60
    
    			var num = 10;
    			var sum = (num + 10)* 5
    			console.log(sum);//100
    
    			经典例子：
    			    var result = (4 >= 6 || '人' != '狗' && !(12 * 2 == 144) && true);
    			    console.log(result);//true
    
    
    			    var num = 10;
    			    var result = 5 == num / 2 && (2 + 2 * num).toString() === '22');
    			    console.log(result);
    
    	//自变量：把一个值直接赋值给一个变量
    	//声明变量并且初始化
    	var num = 10;
    	var flag = true; 
    	
    	var  y = 10;

\--------------------------------一元运算符、流程控制、分支结构、循环结构-----------------------------------------

一元运算符：++，–  
流程控制：  
分支结构：if ； if-else ；if else-if else ； 三元表达式  
循环结构：while;do-while;for; for-in

===================>一元运算符

++  --  都是运算符
    ++  和  -- 可以分为：前+ 和 后+          and         前-    和     后-
    
    var num = 10;
    num++;//自身加1----自加
    console.log(num);//11
    
    var num = 10;
    ++num;//自身加1----自加
    console.log(num);//11
    
    var num = 10;
    var sum = num++ +10;
    console.log(sum);//20
    console.log(num);//11
    如果++在后面：如：num++ +10参与运算，先参与运算，运算结束后自身再加1
    
    
    var num = 10;
    var sum = ++num +10;
    console.log(sum);//21
    console.log(num);//11
    如果++在前面，如：++num + 10；参与运算，先自身+1，然后再参与运算
    
    var num = 10;
    var sum = num-- +10;
    console.log(sum);//20
    console.log(num);//9
    
    var num = 10;
    var sum = --num +10;
    console.log(sum);//19
    console.log(num);//9

===================>流程控制（代码的执行过程）  
流程控制：有事三种方式  
1.顺序结构：从上到下，从左到右执行的顺序  
var num = 10;  
console.log(num);  
2.分支结构：if语句 ， if-else语句 ；switch-case语句；三元表达式

------------------------->if语句：主要指判断
    
    		语法：
    			if(表达式){
    			    块
    			}
    
    
    			执行过程：先判断表达式的结果：true 就执行，false就大括号里面的代码不执行
    
    			例子：
    				1.如果8大于6；请你输出8,如果一个数字大于另一个数字则输出大的数字
    					if(8 > 6 ){
    						console.log(8);
    					}
    
    					var num1 = 10;
    					var  num2 = 100;
    					if (num1 > num2) {
    						console.log(num1)
    					}
    					console.log("我执行了");
    				2.小汪的年龄是否大于18岁，如果是成功，则提示，可以看电影了
    					var age = 19;
    					if (age >= 18) {
    						console.log("可以看电影了，哈哈");
    					}
    
    				3.如果小样比小汪帅，则输出帅
    					var str = "帅";
    					if (str == "帅") {
    						console.log("您真的好帅");
    					}
    
    		------------------------->if - else 语句
    
    			if-slse语句：两个分支：只能执行一个分支
    			if-else语法：
    				if(表达式){
    				    代码1
    				}else{
    				    代码2
    				}
    			执行过程：如果表达式的结果是true，则执行代码1,如果表达式的结果是false，则执行代码2
    
    			小苏的年龄是否是成年人，如果是，就看电影，否则就看电影
    				var age = 10;
    				if(age >= 18){
    					console.log("可以看电影");
    				}else{
    					console.log("回家写作业去");
    				}
    
    			提示用户输入年龄
    			var age =  parseInt(prompt("请您输入您的年龄")) ;//这个是字符串类型,要装换为数字类型
    			if(age >= 18){
    				console.log("可以看电影");
    			}else{
    				console.log("回家写作业去");
    			}
    
    
    			找到两个数字终端饿最大值
    			var num = 10;
    			var num2 = 20;
    			if(num > num2){
    				console.log(num);
    			}else{
    				console.log(num2);
    			}
    
    			判断这个数字是奇数还是偶数
    			var  number = 9;
    			if(number % 2 == 0){
    				console.log("偶数");
    			}else{
    				console.log("奇数");
    			}
    
    			var  number = prompt("请您输入数字");
    			if(number % 2 == 0){
    				console.log("偶数");
    			}else{
    				console.log("奇数");
    			}
    
    
    	------------------------->三元表达式
    
    		两个分支：最终结果是两个分支中的一个，可以三元表达式
    		三元表达式：运算符号   ？：
    		语法：
    			var 变量 = 表达式1 ？ 表达式2：表达式3；
    		执行过程：表达式1的结果是true还是false，如果表达式是true，则执行表达式2，
    				然后把结果给变量
    			      如果表达式1的结果是false，则执行表达式3，把结果给变量
    
    		例题：
    			两个数字中的最大值
    			var x = 10;
    			var y = 20;
    			if(x > y){
    			     console.log(x);
    			}else{
    				console.log(y);
    			}
    
    			var x = 10;
    			var y = 20;
    			var result = x > y ? x : y;
    			console.log(result);
    
    			显示成年还是未成年
    			var age = 20;
    			var result = age >= 18 ? "成年了" : "未成年";
    			console.log(result);
    			总结：大多数情况：使用if-else的语言都可以用三元表达式
    
    	------------------------->if-else      if -else  if-else      if-else  if...else  多分支，最终也执行一个
    
    		if-else if语句
    		语法：
    			if (表达式1) {
    			    代码1
    			}else if (表达式2) {
    			     代码2
    			}else if (表达式3) {
    			     代码3
    			}else{
    			     代码4
    			}
    
    		else if ------这种结构可以写多个，具体多少个看需求
    		else---------结构是可以不用写的，具体还是要看需求的
    
    		执行过程：
    			先执行表达式1的结果；如果为true则执行代码1，如果false执行表达式2，
    			如果表达式2为true，那就执行代码2；如果false执行表达式3，如果表达式3为true，那就执行代码3；如果错误执行代码4
    		例子：
    		     1.成绩在90-100之间，成绩为A；
    		        成绩在80-90之间，成绩为B；
    		        成绩在70-80之间，成绩为C；
    		        成绩在60-70之间，成绩为D；
    		        成绩在60分以下，成绩就显示不及格；
    		       
    		        var score =parseInt(prompt("您的成绩是多少呢")) ;
    		        //清除为空的或者是成绩高于100 的
    		        if (score > 100 || score.trim() == "") {
    		        	console.log("您的输入有误，请您重新输入");
    		        }else if ( score > 90 && score <= 100) {
    		        	console.log("A");
    		        }else if (score > 80) {
    		        	console.log("B");
    		        }else if(score > 70){
    		        	console.log("C");
    		        }else if (score >= 60) {
    		        	console.log("D");
    		        }else if (score > 0 && score < 60) {
    		        	console.log("不及格");
    		        }
    
    
    
    		       
    		        var score =Number(prompt("您的成绩是多少呢")) ;
    		        //清除为空的或者是成绩高于100 的
    		        if (!isNaN(score)) {
    			        if (score > 100 || score.trim() == "") {
    			        	console.log("您的输入有误，请您重新输入");
    			        }else if ( score > 90 && score <= 100) {
    			        	console.log("A");
    			        }else if (score > 80) {
    			        	console.log("B");
    			        }else if(score > 70){
    			        	console.log("C");
    			        }else if (score >= 60) {
    			        	console.log("D");
    			        }else if (score > 0 && score < 60) {
    			        	console.log("不及格");
    			        }
    
    		        }
    
    		        //判断一个年份是不是闰年
    		        //定义一个变量存储一个年份
    		        var year = prompt("请您输入年份，看看是闰年还是平年");
    		        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
    		        	console.log("闰年");
    		        }else{
    		        	console.log("平年");
    		        }
    
    
    
    	------------------------->分支语句：switch-case
    
    		switch-case语句------分支语句-------多分支语句
    		语法：
    		         switch(表达式){
    		         	case 值1：代码1;break;
    		         	case 值2：代码2;break;
    		         	case 值3：代码3;break;
    		         	case 值4：代码4;break;
    		         	case 值5：代码5;break;
    		         	...多个case
    
    		         	default：代码5;
    		         }
    		         注意问题：
    		         default:后面的break是可以省略的；
    		         default:也是可以省略的；
    		         switch-case  语句中和case后面的值比较的时候使用的是严格等于模式（===）
    		         break 是可以省略的,省略只会
    
    		         执行过程：
    		                获取表达式的值，和值1比较，如果一样，则执行代码1，遇见break，
    		                则跳出整个语句，后面的代码则不执行；
    		                如果表达式1的值，不一样，则和值2进行比较，
    		               如果遇见相同的就执行，跳出语句，否则就与值3比较。。。。
    		               否则就直接执行default语句
    
    		         //例子：获取一个人的成绩的级别，如果是A级则，显示90到100直接的分数
    		         		如果是B级则显示80-90；如果是C级则显示70-80分
    		         		如果是D级则显示60-70之间；
    		         		否则显示0-59之间
    
    		         		var jiBie = "C";
    		         		switch (jiBie){
    		         			case "A":console.log("90-100");break;
    		         			case "B":console.log("80-90");break;
    		         			case "C":console.log("70-80");break;
    		         			case "D":console.log("60-70");break
    		         			default :console.log("0-59");
    		         		}
    
    		         		注意问题：
    		         		var num = "10";//字符串
    		         		console.log("10" == 10);//true
    		         		console.log("10" === 10);//false 
    		         		switch (num){
    		         			case 10 : console.log("数字的10");
    		         			case "10" : console.log("字符串10");
    		         		}
    
    		 //根据月份显示对应的天数
    		 // 1，3，5，7，8，10，12 ------31天
    		 //2 ----28天
    		 //4，6，9，11-----30
    		 var month = parseInt(prompt("请您输入月份"));
    		 if (month > 0  && month <= 12) {
    		      switch(month){
    		 	case 1:
    		 	case 3:
    		 	case 5:
    		 	case 7:
    		 	case 8:
    		 	case 10:
    		 	case 12:console.log("31天");break;
    		 	case 2:console.log("28天");break;
    		 	case 4:
    		 	case 6:
    		 	case 9:
    		 	case 11:console.log("30天");break;
    		      }
    		 }else{
    		 	console.log("您的输入有误，重新输入");
    		 }
    
    		 //练习：根据数字显示对应的星期
    		 var num = parseInt(prompt("请您输入数字"));
    		 	switch(num){
    			 	case 1:console.log("星期一");break;
    			 	case 2:console.log("星期二");break;
    			 	case 3:console.log("星期三");break;
    			 	case 4:console.log("星期四");break;
    			 	case 5:console.log("星期五");break;
    			 	case 6:console.log("星期六");break;
    			 	case 7:console.log("星期日");break;
    			 	default:console.log("您输入的数字有误，请您输入1-7");
    		 	}
    		 
    		
    		总结：
    		        分支语句：
    		        if语句：一个分支
    		        if-else语句：两个分支，最终值执行一个
    		        if-else if , if -else if -else if ...语句：多个分支，最终还是会执行一个
    		        switch-case语句：多分支语句，最终也会执行一个
    		        三元表达式：？ ：和if-else语句是一样的
    
    		        什么时候使用：if-else if ...--------一般是对范围的判断
    		        什么时候使用：switch-case-------一般是对具体值的判断
    		        如果是有多个分支，是针对范围的判断一般选择if-else if语句
    		        如果有多个分支，是针对具体的值的判断，一般都是用switch-case
    
    	3.循环结构：while循环；do-while ，for ，for-in 
    		循环：一件事不停的或者是重复的做的
    		       循环要有结束的条件的循环还应该有计算器（记录循环的次数）
    
    	    --------------------------> while 循环
    	       while循环语法：
    	           计算器
    	           var 变量 = 0;
    	           while (循环的条件){
    	           	循环体;
    	           	计数器++;
    	           }
    
    	           执行过程：
    	              先判断条件是否成立：（条件的结果true还是false）
    	              如果是false，那么循环的代码（while的大括号中的代码都不执行）
    	              如果是true，那么先执行循环体，然后执行计算器，然后，直接去----》循环的条件，再次判断是成立，成立就执行循环体，否则就不执行，跳出循环，执行循环体之后，计算器加1，然后再去循环的条件，成立就循环，否则就跳出循环
    
    	              var i = 0;
    	              while(i < 10){
    	              	循环体
    	              	i++;
    	              }
    
    
    
    	              请您输出10次的：哈哈
    	              var i = 0;
    	              while(i < 10){
    	              	console.log("哈哈" + (i+1));
    	              	i++;
    	              }
    
    
    
    	              var i = 0;
    	              while(i < 100){
    	              	console.log("哈哈" + (i+1));
    	              	i++;
    	              }
    	              console.log(i);
    
    
    	              //练习：计算1-100之间所有的数字的和
    	              var sum = 0;//存储最终的和
    	              var i = 0;//计算器
    	              while (i <= 100){
    	              	sum = sum + i;//简写：sum+ = j;
    	              	i++;
    	              	console.log(sum);
    	              }
    
    
    	              //求6的阶乘：
    	                 var ji = 1;//存储最终的阶乘的结果
    	                 var  i = 1;//开始的数字
    	                 while(i <= 6){
    	                 	//ji = ji * i;
    	                 	ji*= i;
    	                 	i++;
    	                 }
    	                 console.log(ji);
    
    
    	                 //求1-100之间所有的偶数的和
    	                 var i = 1;//计数器
    	                 var  sum = 0;//存储所有的数字的和
    	                 while(i <= 100){
    	                 	if(i % 2 == 0){
    	                 	//判断这个数字是不是偶数，如果是偶数则相加，
    	                 	//如果不是偶数把结果存放在sum中
    	                 		sum += i;
    	                 	}
    	                 	i++;	
    	                 }
    	                 console.log(sum);
    
    	                 //求1-100之间所有的奇数的和
    	                 var i = 1;
    	                 var sum = 0;
    	                 while(i <= 100){
    	                 	if (i % 2 != 0) {
    	                 		sum += i;
    	                 	}
    	                 	i++;
    	                 }
    	                 console.log(sum);
    
    
    	                  var i = 1;
    	                 var sum = 0;
    	                 while(i <= 100){
    	                 	if (i % 2 == 1) {
    	                 		sum += i;
    	                 	}
    	                 	i++;
    	                 }
    	                 console.log(sum);
    
    
    
    	                 //请输入1-100直接所有的能够被7整除的数字
    	                 var i = 1;
    	                 while(i <= 100){
    	                 	if (i % 7 == 0) {
    
    	                 		console.log(i);
    	                 	}
    	                 	i++;
    	                 }
    
    
    
    
    	                 //求账号和密码是否一致，登录的效果实现
    	                 //提示用户输入账号
    	                 //提示用户输入密码
    	                 //如果账号和密码不对，则一直都提示用户输入账号和密码
    	                 //这里账号-----admin
    	                 //密码-----123-----字符串类型
    	                 var userName = prompt("请您输入账号!");
    	                 var userPwd = prompt("请您输入密码!");
    	                 while(userName != "admin" || userPwd != "123"){
    	                 	//变量的重新赋值
    	                 	userName = prompt("请您输入账号");
    	                 	userPwd = prompt("请您输入密码")
    	                 }
    	                 console.log("登录成功");
    
    
    	                 //变量是可以重新赋值的
    	                 var num = 10;
    	                 console.log(num);//10
    	                 num = 100;//变量的重新赋值
    	                 console.log(num);//100
    
    
    	-----------------------> do-while
    		do-while循环
    		语法：
    			do{
    			     循环体
    			}while(条件);
    
    		执行过程：
    			先执行一次循环体，然后判断条件是否成立，不成立，则跳出循环；成立则执行循环体，然后再判断条件是否成立，成立就执行，不成立就跳出来。
    			//例子：
    			//输出：哈哈，我有变帅了----10次
    			var  i = 0;//计数器
    			do{
    			     console.log("哈哈，我有变帅了");
    			     i++;
    			}while(i < 10);
    
    
    			//问用户，您觉得我帅吗？提示用户请您输入y/n，如果是n，就一直提示，如果是y，则结束。你真有眼光
    			do{
    			     //把用户输入的结果存放到result变量中
    			     var  result = prompt("您觉得我帅吗？y / n");
    			}while(result != "y");
    			console.log("您真有眼光");
    
    
    			//练习：求100以内所有3的倍数之和
    			var i = 1;
    			var  sum = 0;
    			while(i <= 100){
    				if (i % 3 == 0) {
    					sum += i;
    				}
    				i++;
    			}
    			console.log(sum);
    
    			var i = 1;
    			var sum = 0;
    			do{
    				if(i % 3 == 0){
    					sum += i;
    				}
    			      i++;
    			}while(i <= 100);
    			console.log(sum);
    
    
    			总结：while循环特点：先判断，后循环，有可能一次循环体都不会执行，
    			 	var i = 5;
    			           while(i < 4){
    			           	console.log("我好帅哦");
    			           	i++;
    			           }
    			           console.log("嘻嘻");
    
    			           do-while循环特点:先循环，后判断，至少执行一次
    			           var i = 0;
    			           do{
    			           	console.log("say hello");
    			           	i++;
    			           }while(i < 0);
    
    	--------------------->for循环
    		语法：
    		for(表达式1;表达式2;表达式3){
    			循环体;
    		}
    
    		执行过程：
    			先执行一次表达式1，然后判断表达式2；如果不成立
    		      则直接跳出循环；如果表达式2成立，直接执行循环体里面的代码，
    		      结束后直接跳到表达式3执行；然后跳到表达式2执行，判断表达式2，
    		      是否成立，如果不成立就跳出循环，如果成立，
    		      就直接在跳到表达式3中。。。。
    
    		//例子：打印10次我变帅了
    			for (var i = 0; i < 10; i++){
    				console.log("我变帅了");
    			}
    
    
    			var i = 0;
    			for (; i < 10; i++){
    				console.log("我变帅了");
    			}
    
    
    		//求1-100之间的所有数字的和
    		var sum = 0;
    		for (var i = 1 ; i <= 100; i++) {
    			sum += i;
    		}
    		console.log(sum);
    
    		//求1-100直接所有偶数的和
    		var sum = 0;
    		for  (var i = 1; i <= 100; i++){
    			if(i % 2 == 0){
    				sum += i;
    			}
    		}
    		console.log(sum);
    
    		//求1-100直接所有奇数的和
    		var  sum = 0;
    		for (var i = 1; i <= 100;i++){
    			if (i % 2 ==1) {
    				sum += i;
    			}
    		}
    		console.log(sum);
    
    		var sum = 0;
    		for(var i = 1; i <= 100; i++){
    			if (i % 2 != 0) {
    				sum += i;
    			}
    		}
    		console.log(sum);
    
    		//求1-100直接所有能被3整除的和
    		var sum = 0;
    		for(var i = 1; i <= 100; i++){
    			if (i % 3 == 0) {
    				sum += i;
    			}
    		}
    		console.log(sum);
    
    		//求1-100直接所有能被7整除的和
    		var sum = 0;
    		for(var i = 1; i <= 100; i++){
    			if (i % 7 == 0) {
    				sum += i;
    			}
    		}
    		console.log(sum);
    
    
    		//画星星
    		//document.write("haha");
    		document.write("☆");
    		document.write("☆");
    
    		//控制行数
    		for (var i = 0 ; i < 5 ; i++){
    			//控制每一行的星星
    		      for (var j = 0 ; j < 5 ;j++){
    		      document.write("☆");
    			}
    		      document.write("<br/>");
    		}
    
    
    		//画三角形的星星
    		//document.write("❤️");
    
    		for(var i = 0 ; i < 10 ; i++){
    		     document.write("❤️");
    		
    		    //控制每一行的星星
    		     for(var j = 0; j < i ; j++){
    		        document.write("❤️");
    			}
    		        document.write("<br/>");
    		}
    
    
    		//乘法口诀表
    
    		//控制行数
    		for(var i = 1 ; i <= 9 ; i++){
    			//控制每一行有多少个表达式
    			for(var j = 1 ; j <= i ; j++){
    				document.write(i + "*" +  j + "=" + i * j + " ");
    			}
    				document.write("<br/>");
    		}
    
    
    		//控制行数
    		for(var i = 1 ; i <= 9 ; i++){
    			//控制每一行有多少个表达式
    			for(var j = 1 ; j <= i ; j++){
    				document.write(j + "*" +  i + "=" + i * j + "   ");
    			}
    				document.write("<br/>");
    		}
    
    		//表格版本的乘法口诀
    		document.write("<table border='1' cellpading='0' cellspacing='0'>");
    		for (var i = 1; i <= 9 ; i ++){
    			document.write("<tr>");
    			   for(var j = 1; j <= i ; j ++){
    			   	document.write("<td>");
    			   	document.write( " "+j + "x" +  i + "=" + i * j + " ");
    
    			   	document.write("</td>");
    			   }
    			document.write("</tr>");
    		}
    		document.write("</table>");
    
    
    		//调式代码---高级程序员都是从调试过来的
    		  调试代码:写代码----打开浏览器-----F12(开发者工具)-----Sources-------双击文件----在某一行代码前面点击一下（出现的东西就是断点）
    
    		  var sum = 0;
    		  for(var  i = 0 ; i < 5 ; i++){
    		  	sum += i;//观察一下这一行代码
    		  }
    		  console.log(sum);

// 本金10000元存入银行，年利率是千分之三，每过1年，将本金和利息相加作为新的本金。计算5年后，获得的本金是多少？  
var money = 10000;//本金  
var rate = 0.003;  
for(var i = 0 ; i < 5; i++)\{  
money = money + money \* rate;//money += money \* rate  
\}  
console.log(money);

// 有个人想知道，一年之内一对兔子能繁殖多少对？于是就筑了一道围墙把一对兔子关在里面。已知一对兔子每个月可以生一对小兔子，而一对兔子从出生后第3个月起每月生一对小兔子。假如一年内没有发生死亡现象，那么，一对兔子一年内（12个月）能繁殖成多少对？（兔子的规律为数列，1，1，2，3，5，8，13，21）  
var num1 = 1;//1  
var num2 = 1;//2  
var sum = num1 + num2;//3

var num1 =num2;//2
    	var num2 = sum;//3
    	sum = num1 + num2;//4
    
    	var num1 = num2;//3
    	var num2 = sum;//4
    	sum = num1 + num2;
    
    
    	var num1 = 1;//第一月
    	var num2 = 1;//第三个月
    	var sum = 0;
    	// i = 3是从第三个月开始
    	for (var i = 3; i <= 12 ; i ++ ){
    		sum = num1 + num2;
    		num1 = num2;
    		num2 = sum;
    	}
    	console.log(sum);

\----------------------------------------------break,continue, 数组，函数，冒泡排序-----------------------------

\----------------> break关键字；  
如果在循环中使用，遇见了break，则立即跳出当前所有的循环

while(true){
    		console.log("哈哈");
    		break;
    	}
    	console.log("哈哈，我又变帅了");
    
    
    	for (var i = 0 ; i < 10 ; i++){
    	     while(true){
    		console.log("哈哈");
    		break;
    	      }
    	}
    	console.log("哈哈，我又变帅了");
    
    	//找到100-200之间第一个能被7整除的数字
    	var sum = 0;
    	for (var i = 100 ; i <= 200; i++){
    		if(i % 7 == 0){
    			sum += i;
    			console.log(i);
    			break;
    		}
    	}
    	console.log(sum);

\---------------->continue:在循环中如果遇到continue关键字，直接开始下一次循环  
var i = 0;  
while(i < 10)\{  
console.log(“哈哈”);  
continue;  
i++;  
\}

//案例：求100-200之间所有的奇数的和（用continue）
    var sum = 0;
    var  i = 100;
    while(i <= 200){
    	if (i % 2 !=0) {
    		sum += i;
    	}
    		i++;
    }
    console.log(sum);
    
    var sum = 0;
    var  i = 100;
    while(i <= 200){
    	//判断是不是偶数
    	if (i % 2 == 0) {
    		//如果是偶数---->跳出这个数字
    	     i++;
    	     continue;
    	}
    	    sum += i;
    	    i++;
    }
    console.log(sum);
    
    //案例：求整数100-200的累加值，但是要求跳过所有的个位是3的数字
    //console.log(103 % 10 == 3);//true
    var sum = 0;
    var i = 100;
    while(i <= 200){
    	if(i % 10 == 3){
    		i++;
    		continue;
    	}
    	sum += i;
    	i++;
    }
    console.log(sum);

\----------------------------------->数组  
数组：一位数组，有序的数据  
数组的作用：可以一次性存储多个数据  
数组的定义：  
1.通过构造函数创建数组  
语法：  
var 变量名 = new Array();  
var array = new Array();定义了一个数组  
数组的名字如果直接输出，那么直接就可以把数组中的数据显示出来，如果没有数据是看不到的  
var 数组名 = new Array(长度);  
如果数组中没有数据，但是有长度，数组中的每个值就是undefined  
构造函数的方式创建数组的时候，如果在Array(一个数字)----->数字的长度（数组元素的个数），如果在Array(多个值);这个数组中就有数据了，数组的长度就是这些数据的个数

2.通过字面连的方式创建数组
    		var 数组名 = [];//空数组
    		var array = [];
    		/*
    		无论是构造函数的方式还是字面量的方式，定义的数组，那么有长度，么默认是undefined
    		数组：一组有序的数据
    		数组元素：数组中存储的每个数据，都可以叫数组的元素，比如说：存储了3个数据，数组中3个元素
    		数组长度：就是数组的元素的个数，比如说：有3个元素，就说，这个数组的长度是3
    		数组索引（下标）：用来存储或者访问数组中的数据的
    					每个数组的元素都是有自己的编号的，编号都是从0 开始的，到长度减1结束
    
    					数组的索引和数组的长度的关系：长度-1=就是最大的索引值
    
    		如何设置数组中某个位置的值
    		数组名[下标] = 值;
    		arr[3] = 100;
    
    		如何获取数组中某个位置的值
    		var result = 数组名[下标];
    		console.log(result);
    		*/
    
      //通过构造函数的方式定义一个数组
      var array = new Array(5); //没有数据，空数组
      //console.log(变量名);
      console.log(array);
    
      //就是一个数组------>字面量的方式
      var arr = [];
      console.log(arr);
    
      var arr1 = new Array(); //构造函数的方式---空数组
      var arr2 = new Array(5); //构造函数的方式定义了一个数组，数组中有5个元素，数组的长度是5，每个数学都undefined
      var arr3 = new Array(10, 20, 30, 40, 50);
      console.log(arr3);
    
      var arr = new Array(10, 20, 30, 40, 100);
      // console.log(数组名[下标]);
      console.log(arr[4]); //100   获取
      //设置
      arr[3] = 1000;
      console.log(arr);
    
      //字面量的方式更简单那
      var arr = []; //空数组
      console.log(arr);
    
      var arr = [10, 20, 30, 40];
      console.log(arr);
    
      //获取字符串的长度
      var arr = [10, 30, 40, 2, 40, 30, 29];
      console.log(arr.length);
    
      var arr = [10, 30, 4, 2, 23];
      //长度：5
      //索引：0-4
      console.log(arr);
    
      //数组中存储的数据类型一定是一样的吗？类型可以不一样
      var arr = [10, "哈哈", true, null, undefined, new Object()];
      console, log(arr);
    
      //数组的长度是不是可以改变呢？
      var arr = [];
      //通过索引来设置数组中的元素值
      arr[0] = 10;
      arr[1] = 20;
      console.log(arr.length); //0
      //获取元素的值，通过索引的方式
      console.log(arr[2]); //undefined
      console.log(arr[1]); //20
    
      /*
    //总结数组：
    	数组：存储一组有序的数据
    	数组的作用:一次性存储多个数据
    	数组的定义方式：
    		1.构造函数定义方式：var 数组名 = new Array();
    		2.字面量方式定义数组 var 数组名 = [];
    
    	var 数组名 = new Array();//空数组
    	var 数组名 = new Array(值);//数组定义了，有长度
    	var 数组名 = new Array(值1,值2,值3....);//定义数组并且有多个数据
    	var 数组名 = [];//空数组
    	var 数组名 = [值1,值2,值3];//有三个数据
    
    	数组元素：就是数组中存储的数据
    	数组长度：就是数组中元素的个数
    	数组索引：从0开始，到数组的长度减1结束
    	通过下标设置数组的元素值：数组名[索引]=值;
    	通过下标访问数组的元素值：数组名[索引];
    
    	var arr1 = new Array();//空数组
    	var arr2 = new Array(5);//长度为5的数组，每个数据的值是undefined
    	var arr3 = new Array(1,2,3,4,5);//长度为5分数组
    	var arr4 = [];//空数组
    	var arr5 = [1,2,3];//长度为3的数组
    	var arr6 = ["red","blue","green",1,true];//数组中元素的值类型可以不一样
    	var arr7 = [];
    	arr7[0] = 10;
    	arr7[1] = 20;

\*/

// ----------------------------------->for循环遍历数组
      var arr = [10, 20, 30, 40, 50];
      //显示数组中的每个数据
      console.log(arr[0]);
      console.log(arr[1]);
      console.log(arr[2]);
      console.log(arr[3]);
      console.log(arr[4]);
    
      var arr = [10, 20, 30, 40, 50];
      //小于的是数组的长度---个数
      for (var i = 0; i < arr.length; i++) {
        console.log(arr[i]);
      }
    
      //案例1：求数组中所有元素的和
      var arr = [10, 30, 40, 30, 20];
      sum = 0;
      for (var i = 0; i < arr.length; i++) {
        sum += arr[i];
      }
      console.log(sum);
    
      //案例2：求数组中所有元素的平均值
      var arr = [10, 30, 40, 30, 20];
      sum = 0;
      for (var i = 0; i < arr.length; i++) {
        sum += arr[i];
      }
      console.log(sum / arr.length);
    
      //案例3：求数组中所有元素中最大值
      var arr = [10, 30, 40, 30, 20];
      var maxNum = arr[0];
      for (var i = 0; i < arr.length; i++) {
        //判断这个变量的值和数组中每个元素的值是不是最大值
        if (maxNum < arr[i]) {
          maxNum = arr[i];
        }
      }
      console.log(maxNum);
    
      var arr = [10, 30, 40, 30, 20];
      var maxNum = Number.MIN_VALUE; //假设变量是最大的，三十实际上存储的是最小的值
      for (var i = 0; i < arr.length; i++) {
        //判断这个变量的值和数组中每个元素的值是不是最大值
        if (maxNum < arr[i]) {
          maxNum = arr[i];
        }
      }
      console.log(maxNum);
    
      var arr = [10, -20, -10, 30, 0];
      var maxNum = arr[1];
      for (var i = 0; i < arr.length; i++) {
        //判断这个变量的值和数组中每个元素的值是不是最大值
        if (maxNum < arr[i]) {
          maxNum = arr[i];
        }
      }
      console.log(maxNum);
    
      //案例4：求数组中所有元素的最小值
      var arr = [10, -20, -10, 30, 0];
      var minNum = arr[0];
      for (var i = 0; i < arr.length; i++) {
        //判断这个变量的值和数组中每个元素的值是不是最小值
        if (minNum > arr[i]) {
          minNum = arr[i];
        }
      }
      console.log(minNum);
    
      //案例5：到循环遍历数组
      var arr = [10, -20, -10, 30, 0];
      //正常顺序
      for (var i = 0; i < arr.length; i++) {
        console.log(arr[i]);
      }
    
      //倒序
      for (var i = arr.length - 1; i >= 0; i--) {
        console.log(arr[i]);
      }
    
      //案例6：把数组中的每一个元素拼接到一起产生一个字符串并输出
      var names = ["你菜单鼠标", "bcis", "比都是不错", "比较类似笔记"];
      var str = "";
      for (var i = 0; i < names.length - 1; i++) {
        str += names[i] + "|";
      }
      console.log(str + names[names.length - 1]);
    
      var names = ["你菜单鼠标", "bcis", "比都是不错", "比较类似笔记"];
      var str = "";
      for (var i = 1; i < names.length; i++) {
        str += "|" + names[i];
      }
      console.log(names[0] + str);
    
      //案例7： 去掉数组中的重复0,把其他的数据放在一个新的数组中
      var arr = [10, 0, 20, 20, 30, 90];
      var newArr = []; //新数组，用来存放第一个 数组中所有非0的数字
      for (var i = 0; i < arr.length; i++) {
        if (arr[i] != 0) {
          newArr[newArr.length] = arr[i];
        }
      }
      //把新的数组的长度作为下标使用，数组的长度是可以改变的
      console.log(newArr);
    
      //案例8：反转数组--把数组中的数据位置调换
      var arr = [20, 30, 2, 30, 0, 2, 0, 32, 3, 4]; //
      //循环的目的是控制交换的次数
      for (var i = 0; i < arr.length / 2; i++) {
        //先把第一个元素值放在第三方变量中
        var temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
      }
      console.log(arr);
    
      //案例9：请您输入班级人数，根据班级人数，输入每个学生的数学成绩，求总成绩，求平均成绩求最高分，求最低分。
      //提示yoghurt输入人数，并 转成数字类型
      var perCount = parseInt(prompt("请您输入班级人数"));
      //定义数组存储班级的每个人的成绩
      var perScores = [];
      //循环的方式录入每个人的成绩
      for (var i = 0; i < perCount; i++) {
        perScores[perScores.length] = parseInt(
          prompt("请你输入第" + (i + 1) + " 一个人成绩：")
        );
      }
      console.log(perScores);
      //求总成绩
      var sum = 0;
      var avg = 0; //求平均数
      var max = perScores[0]; //最大值
      var min = perScores[0]; //最小值
      for (var i = 0; i < perScores.length; i++) {
        sum += perScores[i]; //求和
        //求最大值
        if (max < perScores[i]) {
          max = perScores[i];
        }
        //求最小值
        if (min > perScores[i]) {
          min = perScores[i];
        }
      }
      avg = sum / perScores.length;
      //avg = sum / perCount;
    
      console.log("和为:" + sum);
      console.log("平均值:" + avg);
      console.log("最大值:" + max);
      console.log("最小值:" + min);
    
      /*
    //求和
    var arr = [10,20,30];
    var sum = 0;
    for (var i = 0; i < arr.length; i++ ){
    	sum += arr[i];
    }
    console.log(sum);
    
    //求平均数
    var sum = 0;
    var avgNum = 0;
    for (var i = 0; i < perScores.length; i++) {
    	sum += perScores[i];
    }
    console.log(sum/perScores.length);
    */
    
      //案例10：冒泡排序
      // 	把所有的数据安装一定的顺序进行一定的排列（要么从小到大，要么就是从大到小排列）
      var arr = [10, 20, 10, 2, 30, 40, 4];
      //循环控制比较的轮数
      for (var i = 0; i < arr.length; i++) {
        //控制每一轮的比较次数
        for (var j = 0; j < arr.length - 1 - i; j++) {
          //从大到小
          //arr[j]第一个数，arr[j+1]第二数，temp第三方变量进行交换
          if (arr[j] < arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
          }
        }
      }
      console.log(arr);
    
      /*

\--------------------------------------->函数  
函数：把一堆重复的代码封装，在需要的时候拿来调用就可以了  
函数的作用：代码的重用  
函数的定义：  
语法：  
//argument 是一个作为函数输入的值（原始数据或对象）。arguments 是一个对应于传递给函数的参数的类数组对象。

//函数需要先定义，然后才能使用
          //函数名字：要遵循驼峰命名法，函数名是不能一样的
          //函数一旦重名，后面的会把前面的函数覆盖
          //ctr  + 鼠标左键---->转到定义
          //一个函数最好一个功能
          //下面所有的函数代码都要放在外部的js中
    
    
          	function 函数名(argument) {
          	       函数体-----一堆代码
          	}
    
          	函数的调用：
    
          	函数名();
    
    
          	//函数定义
          	function cook(){
          		console.log("切菜");
          		console.log("放油");
          		console.log("炒菜");
          		console.log("放盐");
          		console.log("装盘");
          	}
          	//函数调用
          	console.log("早上");
          	cook();
          	console.log("中午");
          	cook();
          	console.log("晚上");
          	cook();
    
    
          	//通过函数做
    
          	//求两个数字的和
          	var num1 = 10;
          	var num2 = 20;
          	var sum = num1 + num2;
          	console.log(sum);
    
          	function consoleSum(){//函数定义
          	      var num1 = 10;
          	      var num2 = 20;
          	      var sum = num1 + num2;
          	      console.log(sum);
          	}
          	//调用
          	consoleSum();
    
          	//求三个数字的和
          	function consoleSum(){
          		var num1 = 10;
          		var num2 = 20;
          		var num3 = 30;
          		var sum = num1 + num2 + num3;
          		console.log(sum);
          	}
          	consoleSum();
    
          	//求两个数字的最大值
          	function consoleSum(){
          		var sum1 = 10;
          		var sum2 = 20;
          		console.log(sum1 > sum2 ? sum1 : sum2);
          	}
          	consoleSum();
    
          	//求三个数字的最大值
          	function consoleSum(){
          		var x = 0;
          		var y = 120;
          		var z = 30;
          		var max = x > y ? (z > x ? z : x) : (y > z ? y : z);//嵌套三元表达式
          		console.log(max);
          	}
          	consoleSum();
    
    
    
          	//求1-100之间所有的数字的和
          	function everySum(){
          		var sum = 0;
          		for (var i = 1; i <= 100; i++) {
          			sum += i;
          		}
          		console.log(sum);
          	}
          	everySum();
    
          	//求1-100之间所有偶数的和
          	function everyEvenSum(){
          		var sum = 0;
          		for (var i = 1; i <= 100; i++) {
          			if ( i % 2 == 0 ) {
          				sum += i;
          			}
          		}
          		console.log(sum);
          	}
          	everyEvenSum();
    
          	//求一个数组的和
          	function cosoleArraySum(){
          		var sum = 0;
          		var arr = [10,30,20,30,40,30];
          		for (var i = 0; i < arr.length; i++) {
          			sum += arr[i];
          		}
          		console.log(sum);
          	}
          	cosoleArraySum();

\------------------------------->函数的参数  
/\*  
函数参数：  
在函数定义的时候，函数名字后面的小括号里的变量就是参数，目的是函数在调用的时候，用户传值进来的值操作  
此时函数定义的时候后面的小括号里的变量叫参数；写了两个变量，就是两个参数  
在函数调用的时候，按照提示的方式，给变量赋值----->就叫传值，把这个值传到参数中  
形参：函数在定义的时候小括号的里面的变量叫形参  
实参：函数在调用的时候小括号里面传入的值就是叫实参，实参可以是变量也可以是值

\*/

//函数定义
      function consoleSum(x, y) {
        var sum = x + y; //----计算和的功能
        console.log(sum); //----输出和的功能
      }
      //函数调用
      consoleSum(90, 20);
    
      function consoleSum(x, y) {
        var sum = x + y; //计算和的功能
        console.log(sum); //输出和的功能
      }
      //函数调用
      var num1 = parseInt(prompt("请您输入第一个数字"));
      var num2 = parseInt(prompt("请您输入第二数字"));
      consoleSum(num1, num2);
    
      // -------------------->函数的返回值
      //set:设置
      //get:获取
      //函数的返回值：在函数内部有return关键字，并且在关键字后面有内容，这个内容被返回了
      //当函数调用之后，需要这个返回值，那么定义变量接收，即可
    
      /*
       如果一个函数中有return，那么这个函数就有返回值
       如果一个函数中没有return，那么这个函数就没有返回值
       如果一个函数没有参数，没有参数的函数
       形参的个数，与实参的个数可以不一致
       函数没有返回值，但是在调用的时候接受了，那么结果就是undefined，变量声明了，但是没有赋值，结果也是undefined
       如果一个函数中没有return，那么这个函数就没有返回值，结果就是undefined（没有明确的返回值：1.函数中没有return,函数中有return，但是return后面没有任何内容）
       retrun 下面的代码是不会执行的
    */
    
      function getSum(x, y) {
        var sum = x + y;
        return sum;
        //console.log(sum);
      }
      getSum(10, 30);
    
      function getSum(x, y) {
        var sum = x + y;
        return sum;
        //console.log(sum);
      }
      //函数调用
      var result = getSum(10, 30);
      console.log(result + 10);
    
      //函数定义：有参数有返回值的函数
      function getSum(x, y) {
        return x + y; //把和返回
        //console.log(sum);
      }
      //函数调用
      var result = getSum(10, 30);
      console.log(result + 10);
    
      //有参数，有返回值的函数
      function f1(x, y) {
        return x + y;
      }
      f1(10, 20, 30, 40, 50); //30
      f1(10); //NaN
    
      //有参数，无返回值的函数
      function f2(x, y) {
        console.log(x);
      }
    
      //无参数，有返回值的函数
      function f3(x, y) {
        return 100;
      }
    
      //无参数无返回值的函数
      function f4(x, y) {
        console.log("帅");
      }
    
      function f1(x, y) {
        var sum = x + y;
        return sum;
        console.log("我就是帅");
      }
      var result = f1(10, 20);
      console.log(result);
    
      //函数案例
      function f1() {
        console.log("我很帅");
        return 100;
      }
      console.log(f1());
    
      function f1() {
        console.log("我很帅");
        return 100;
      }
      console.log(f1); //输出的f1括号里面的代码
    
      //求两个数字之和（获取任意的两个数字的和）
      function getSum(x, y) {
        return x + y;
      }
      console.log(getSum(10, 20));
    
      //1-100和
      function getSum() {
        var sum = 0;
        for (var i = 0; i <= 100; i++) {
          sum += i;
        }
        return sum;
      }
      getSum(getSum());
    
      //求1-n之间的所有数字的和
      function getSum(n) {
        var sum = 0;
        for (var i = 0; i <= n; i++) {
          sum += i;
        }
        return sum;
      }
      console.log(getSum(n));
    
      //求n-m之间所有数的和
      function getSum(n, m) {
        var sum = 0;
        for (var i = n; i <= m; i++) {
          sum += i;
        }
        return sum;
      }
      console.log(getSum(10, 30));
    
      //求园的面积
      //π r²
      function getSum(r) {
        return Math.PI * r * r;
      }
      console.log(getSum(5));
    
      //求两个数的最大值
      function getMax(num1, num2) {
        return num1 > num2 ? num1 : num2;
      }
      console.log(getMax(10, 20));
    
      function getMax(num1, num2) {
        return num1 > num2 ? num1 : num2;
      }
      var x = 10;
      var y = 20;
      var result = getMax(x, y); //把x变量的值去出来，复制一份给num1，所有num1的变量存储10，有两块空间，一块是x的空间，一块是num1的空间
      console.log(result);
    
      function getMax(num1, num2) {
        return num1 > num2 ? num1 : num2;
      }
      var num1 = 10;
      var num2 = 20;
      //函数外面的num1，和函数形参num1不是用一个变量，只是名字一样而已（就比如说同班同学名字一样，而人不一样）
      var result = getMax(num1, num2);
      console.log(result);
    
      //求三个数中的最大值
      function getThreeMax(x, y, z) {
        return x > y ? (z > x ? z : x) : y > z ? y : z;
      }
      console.log(getThreeMax(20, 40, 9));
    
      //判断一个数是否是素数（质数：就是能被1或者本身整除）(质数是从2开始的)；
      //思路：用这个数字和这个数字前面的所有的数字整除一遍（里面是没有1的，和没有本身的）
      function isPrimeNumber(num) {
        for (var i = 2; i < num; i++) {
          if (num % i == 0) {
            //说明有一个数字被整除了，就没有必要继续去整除了，说明就不是质数了
            return false; //后面就不用执行了
            //break;
          }
        }
        return true;
      }
      var result = isPrimeNumber(
        parseInt(prompt("请您输入数字看看是不是质数"))
      );
      console.log(result);
      if (result) {
        console.log("是质数");
      } else {
        console.log("不是质数");
      }
    
      var arr = [
        2,
        30,
        40,
        3,
        20,
        30,
        40,
        20,
        40,
        30,
        40,
        3,
        05,
        50,
        60,
        3,
        04,
        5,
      ];
      for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr.length - 1 - i; j++) {
          if (arr[j] < arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
          }
        }
      }
      console.log(arr);
    
      // ------------------------>函数----案例  <------------------------------------------------------------------------------------
      // 		       函数的注意问题
      // 		       作用域
      // 		       预解析
      // 		       对象
    
      //求两个数字的差
      function getSub(x, y) {
        return x - y;
      }
      console.log(getSub(10, 20));
    
      function getSub(x, y) {
        return x - y;
      }
      console.log(
        getSub(
          parseInt(prompt("请您输入第一个数字")),
          parseInt(prompt("请您输入第二个数字"))
        )
      );
    
      //求一组数字中的最大值
      function getArrMax(array) {
        //定义变量假设这个变量中存储的是最大值
        var max = array[0];
        for (var i = 0; i < array.length; i++) {
          if (max < array[i]) {
            max = array[i];
          }
        }
        return max;
      }
      var arr = [10, 30, 20, 30, 2, 30, 100, 2];
      console.log(getArrMax(arr));
    
      //求一组数字中的最小值
      function getArrMin(array) {
        var min = array[0];
        for (var i = 0; i < array.length; i++) {
          if (min > array[i]) {
            min = array[i]; //如果是，就把min的数拿出来了
          }
        }
        return min;
      }
      var arr = [20, 30, 40, 2, 20, 10, -10, 20, 2];
      console.log(getArrMin(arr));
    
      //求一组数字的和
      function getArraySum(array) {
        var sum = 0;
        for (var i = 0; i < array.length; i++) {
          sum += array[i];
        }
        return sum;
      }
      console.log(getArraySum([20, 10, 20, 30]));
    
      //求一个数组中的最大值和最小值还有和
      /**
       *	给我一个数组，我返回一个数组（最大值，最小值，和）
       * @param array  参数是一个数组
       * @returns {*[]}  返回值是一个数组，第一元素是最大值，第二元素是最小值，第三个元素是和
       */
      function getArrayMaxAndMinAndSum(array) {
        var min = array[0]; //最小值
        var max = array[0]; //最大值
        var sum = 0;
        for (var i = 0; i < array.length; i++) {
          sum += array[i];
          //最小值
          if (min < array[i]) {
            min = array[i];
          } //end min if
    
          //最大值
          if (max > array[i]) {
            max = array[i];
          } //end max if
        } // end for
        var arr = [max, min, sum];
        return arr;
      }
    
      //测试
      var resultArray = getArrayMaxAndMinAndSum([
        1,
        29,
        30,
        20000,
        30,
        20,
        2,
        3,
      ]);
      console.log(resultArray);
    
      //通过函数实现数组反转
      function reverseArray(arr) {
        for (var i = 0; i < arr.length / 2; i++) {
          var temp = arr[i];
          arr[i] = arr[arr.length - 1 - i];
          arr[arr.length - 1 - i] = temp;
        } //end for
        return arr;
      }
      console.log(reverseArray([29, 30, 2, 19, 20, 30, 3]));
    
      //通过函数实现冒泡
      function sortArray() {
        //控制比较的轮数
        for (var i = 0; i < arr.length - 1; i++) {
          //控制每一轮的次数
          for (var j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] < arr[j + 1]) {
              var temp = arr[j];
              arr[j] = arr[j + 1];
              arr[j + 1] = temp;
            } //end if
          } //end for
        } //end for
        return arr;
      }
      var arr = [20, 20, 21, 23, 44, 33, 22, 44, 55, 66, 77, 77, 1000, 20];
      console.log(sortArray(arr));
    
      //求一个数字的阶乘
      function getJieCheng(num) {
        var result = 1;
        for (var i = 1; i <= num; i++) {
          result *= i;
        } //end for
        return result;
      }
      console.log(getJieCheng(5));
    
      function factorial(num) {
        var result = num;
        if (num < 0) {
          return -1;
        } else if (num === 0 || num === 1) {
          return 1;
        } else {
          while (num > 1) {
            num--;
            result *= num;
          }
        }
        return result;
      }
      console.log(factorial(5));
    
      //求斐波那数列，12-----144
      //1  1   2   3   5   8   13.。。。
      function getFib(num) {
        var num1 = 1;
        var num2 = 1;
        var sum = 0;
        for (var i = 3; i <= num; i++) {
          sum = num1 + num2;
          num1 = num2;
          num2 = sum;
        } //end for
        return sum;
      }
      console.log(getFib(4));
    
      //输入年月日，获取这个日期是这一年的第几天
      //判断这个年份是不是闰年
      function isLeapYear(year) {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
      }
    
      function getDays(year, month, day) {
        //定义变量存储对应的天数
        var days = day;
        //如果用户输入是一月份，没必要向后算天数，直接返回天数
        if (month == 1) {
          return days;
        } //end if
    
        //代码执行到这里-----说明用户输入的不是1月份
        //用户输入的是4月份23日------1，2，3 +23天
        //定义一个数组，存储每个月的天数
        //var months = [1月份天数，2月份天数。。。。。]
        var months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
        //小于的是输入的月份-1
        for (var i = 0; i < month - 1; i++) {
          days += months[i];
        }
        //需要判断这个年份是不是瑞年
        if (isLeapYear(year) && month > 2) {
          days++;
        }
        return days;
      }
      //console.log(getDays(2018,2,3));
      console.log(
        getDays(
          parseInt(prompt("请您输入年份")),
          parseInt(prompt("请您输入月份")),
          parseInt(prompt("请您输入天数"))
        )
      );
    
      //函数里面可以调用其他函数
      function f1() {
        console.log("我是一个函数");
        f2();
      }
    
      function f2() {
        console.log("我也是一个函数");
      }
      f1();
    
      //求一个数字的阶乘和          比如是5的阶乘和   5的阶乘+4的阶乘+3的阶乘+2的阶乘+1的阶乘
    
      function getJieCheng(num) {
        var result = 1;
        for (var i = 1; i <= num; i++) {
          result *= i;
        } //end for
        return result;
      }
      console.log(getJieCheng(5));
    
      function getJieChengSum(num) {
        var sum = 0; //和
        for (var i = 0; i <= num; i++) {
          sum += getJieCheng(i);
        }
        return sum;
      }
      console.log(getJieChengSum(5));
      //函数内部可以调用其他的函数
    
      //计算两个数字的和
      function f1(x, y) {
        return x + y;
      }
      f1(20, 30);
    
      //计算三个数字的和
      function f2(x, y, z) {
        return x + y + z;
      }
      f2(2, 3, 7);
    
      //计算四个数字的和
      function f3(x, y, z, k) {
        return x + y + z + k;
      }
      f3(1, 2, 3, 4);
    
      //计算五个数字的和
      function f4(a, b, c, d, e) {
        return a + b + c + d + e;
      }
      f4(1, 2, 3, 4, 10);
    
      //计算6位数字的和
      function f5(a, b, c, d, e, f) {
        return a + b + c + d + e + f;
      }
      f5(1, 2, 3, 4, 5, 6);
    
      //计算n各数字的和
      //定义一个函数没如果不确定用户是否传入了参数，或者说不知道用户传了几个参数，没办法，如果没有办法计算，但是如果在函数中知道了参数的个数，也知道了，每个参数的值，可以
    
      //定义
      function f1() {
        //获取的是函数在调用的时候，传入了几个参数
        //console.log(arguments.length);
        //使用arguments对象可以获取传入的每个参数的值
        console.log(arguments);
      }
      f1(10, 20); //调用
    
      function f1() {
        //arguments------>数组使用------伪数组
        var sum = 0;
        for (var i = 0; i < arguments.length; i++) {
          sum += arguments[i];
        } //end for
        return sum;
      }
      console.log(f1(20, 20, 30, 40));
    
      /**
       命名函数：函数如果有名字，就是命名函数
       匿名函数：函数如果没有明确的名字，那么就是匿名函数
       函数的另一种定义方式
               函数表达式：
                       把一个函数给一个变量，此时形成了函数表达式
                       如果是函数表达式,那么此时前面的变量中存储的就是一个函数，而这个变量就是相当于这个函数，就可以直接加小括号调用了
                       var 变量 = 匿名函数;
                          例子：
                          var f1 = function(){
    		console.log("我很好");
                          };
                          f1();
                          注意：函数表达式后面赋值结束后，一定要加分号
    
    
    
       函数的定义：
          1.函数声明---函数定义
          function 函数名(){
    	函数体
          }
    */
    
      function f1() {
        console.log("哈哈，我又变帅了");
      }
      f1(); //函数调用
      //如果一个函数能够调用：函数的代码();
    
      //函数表达式
      var f2 = function () {
        console.log("我好帅");
      };
      //匿名函数不能直接调用
      f2();
    
      var f4 = function () {
        console.log("我是一个函数");
      };
      f4();
    
      //函数声明
      function f1() {
        console.log("我好帅");
      }
      f1();
    
      function f1() {
        console.log("你也很漂亮");
      }
      f1();
      //只要重名了，就能把前面的覆盖上去了
    
      //函数表达式
      var f2 = function () {
        console.log("我穷啊");
      };
      f2(); //我穷啊
    
      f2 = function () {
        console.log("我没钱");
      };
      f2(); //我没钱
    
      var num = 10;
      console.log(num);
      num = 100;
      console.log(num);
    
      //函数自调用，没有名字，调用----声明的同时，直接调用
      //一次性的-------
      (function () {
        console.log("我好帅");
      })();
    
      (function () {
        console.log("hahah");
      })(); //这个代码是一次性的，并且立即执行
    
      function f1() {
        console.log("哦帅");
      }
      //如何获取函数的数据类型？ typeof
      console.log(typeof f1);
      //函数是有数据类型的，数据类型是：function类型的
    
      function f1(x, y) {
        console.log(x + y);
      }
      f1(10, 20);
    
      //函数声明，fn是变量，fn是参数
      function f1(fn) {
        fn(); //函数调用----说明fn这个变量中存储的是一个函数
      }
    
      function f2() {
        console.log("哦,这是可以的哦");
      }
      f1(f2);
    
      //函数是可以作为参数使用，如果一个函数作为参数，那么我们说这个参数（函数），可以叫做回调函数
      //只要看见一个函数作为参数使用的话，那么就是回调函数
      function sayHi(fn) {
        console.log("您好呀");
        fn(); //此时是一个函数，是函数才能调用
      }
    
      function wangSay() {
        console.log("我很帅");
      }
    
      sayHi(wangSay);
    
      //函数作为返回值使用
      function f1() {
        return function () {
          console.log("这是一个函数");
        };
      }
      var ff = f1(); //调用
      console.log(ff); //ff是一个函数
      ff(); //函数是可以作为返回值使用的
    
      // ----------------------------------->作用域：
      //使用的范围
      /*
       全局变量：声明的变量是使用var声明的，那就说明是全局变量，全局变量可以在页面任何 地方位置使用
              全局变量，如果页面不关闭，那么就不会释放，就会占空间，消耗内存
    
       局部变量：在函数内部定义的变量是局部变量，外面不能使用，除了函数外，其他任何位置定义的都是全局变量。
    
    
       全局作用域：全局变量的使用范围
       局部作用域：局部变量的使用范围
    
    
       块级作用域：一对大括号就可以看成是一块，在这对大括号里面使用的变量，变量使用范围,在这个局域中定义的变量，只能在这个区域中使用，但是在js中在这个会计作用域中定义的变量，外面也是可以使用的，js是没有块级作用域的
    
       隐式全局变量：声明的变量没有var
        	//全局变量是不能被删除的，隐式全局变量是可以删除的
        	  定义变量使用var，是不会被删除的。没有定义var，是不能删除的
    
    */
    
      var num = 10;
      console.log(num); //10
      console.log(num);
    
      {
        var num = 10;
        console.log(num);
      }
      console.log(num);
    
      if (true) {
        var num = 10;
      }
      console.log(num); //可以使用这个变量
    
      for (var i = 0; i < 5; i++) {
        var number = 20;
      }
      console.log(number);
    
      var i = 0;
      while (i < 5) {
        var num = 100;
        i++;
      }
      console.log(num); //100,没有块级作用域
    
      //局部变量，外部是不可以调用的
      function f1() {
        var num = 10;
      }
      f1();
      console.log(num);
    
      function f1() {
        var num = 100;
        num += 10;
      }
      f1(); //这个函数结束过后才执行
    
      //隐式全局变量
      function f1() {
        number = 1000; //隐式全局变量
      }
      f1(); //占了空间，没有释放
      console.log(number);
    
      //全局变量是不能被删除的，隐式全局变量是可以删除的
      var num1 = 10;
      num2 = 20;
      delete num1; //把num1删除了
      delete num2; //把num2删除了
      console.log(typeof num1);
      console.log(typeof num2);
      console.log(num1);
      console.log(num2);
    
      // ------>作用域链：
      var num = 10;
    
      function f1() {
        var num = 20;
    
        function f2() {
          var num = 30;
    
          function f3() {
            var num = 50;
            console.log(num);
          }
          f3();
        }
        f2();
      }
      f1();
    
      // ------>预解析：提前解析代码
      /* 预解析：就是在解析代码之前
      	   预解析做什么事情？
      	   把变量的声明提前了----提前到当前所在的作用域的最上面了
      	   函数的声明也会被提前-----提前到当前所在的所有作用域的最上面
      	*/
      var num;
      console, log(num); //报错
    
      var num = 10;
      console.log(num); //10
    
      console.log(num); //undefined
      var num = 10;
    
      var sum;
      console.log(num); //undefined
      num = 10;
    
      f1();
    
      function f1() {
        console.log(num); //undefined
        var num = 10;
      }
    
      f1();
      var num = 20;
    
      function f1() {
        console.log(num); //undefined
        var num = 10;
      }
      //console.log(num)这里面的num ，首先是要在f1函数进行搜索的，
    
      f1(); //调用，函数的声明提前了，变量的声明也提前了：var num;
      var num = 20; //这个变量的声明会提升到变量使用之前
      function f1() {
        console.log(num); //undefined
      }
    
      var num;
    
      function f1() {
        console.log(num); //undefined
      }
      f1(); //调用
      num = 20;
    
      var num = 20;
    
      function f1() {
        console.log(num); //20
      }
      f1();
    
      // ------>预解析分段作用
      // 	预解析中，变量的提升，只能在作用域里面提升，提升到当前的作用域最前面
      //      	函数中的变量，只会提前到函数的作用域中的最前面，不会出去
      //      	预解析会分段的（多对的script标签中函数重名，预解析是不会冲突的）
      //
      function f1() {
        console.log(num); //undefined
        var num = 10;
      }
      f1();
      console.log(num); //报错，num函数里面声明，是没办法在里面接收的
    
      function f1() {
        console.log("haha");
      }
    
      var a = 25;
    
      function abc() {
        var a = 10;
      }
      abc();
      console.log(a); //25
    
      console.log(a); //函数  相当于var a;
      //function a(){
      //console.log('aaaa');
      //}
      function a() {
        console.log("aaaa");
      }
      var a = 1;
      console.log(a); //1
    
      var a = 18;
      f1();
    
      function f1() {
        var b = 9;
        console.log(a); //undefined
        console.log(b); //9
        var a = "123";
      }
    
      f1();
      console.log(c); //9
      console.log(b); //9
      console.log(a); //报错
      function f1() {
        var a = (b = c = 9);
        console.log(a); //9
        console.log(b); //9
        console.log(c); //9
      } //------>解析这端代码1
      function f1() {
        var a = (b = c = 9);
        console.log(a); //9
        console.log(b); //9
        console.log(c); //9
      }
      f1();
      console.log(c); //9
      console.log(b); //9
      console.log(a); //报错
      //------>解析这端代码2
      function f1() {
        var a;
        a = 9;
        b = 9;
        c = 9;
        console.log(a); //9
        console.log(b); //9
        console.log(c); //9
      }
      f1();
      console.log(c); //9  函数前面没有var,是隐式全局变量 可以在函数外部使用
      console.log(b); //9   函数前面没有var,是隐式全局变量 可以在函数外部使用
      console.log(a); //报错  在里面声明，var a = 9; 是局部代码
    
      f1(); //不能被调用----报错
      var f1 = function () {
        console.log(a);
        var a = 10;
      }; //------>解析这端代码
    
      /*var f1();
      	     	f1();
      	     	f1=function (){
      	     		console.log(a);
      	     		var a =10;
      	     	};*/
    
      // ==============================对象===================================
    
      /*
    
    面向对象：
    面向过程：
    对象（☆重点）
        创建对象的不用方式
    
     自定义对象（☆重点）
        数据类型深入
        	简单的类型和复杂的类型：
            内置对象

\*/

/*
    编程思想：把一些生活中做事的经验融入到程序中
    面向过程：凡是都要亲力亲为，每件事的具体过程都要知道，注重的是过程
    面向对象：只需要根据需求找对象，所有的事情都用对象来做，注重的是结果
    面向对象的特性：封装、继承、多态(抽象性)
    js不是面向对象的语言，但是可以模拟面向对象的思想
    js是一门基于对象的语言：
    万物皆对象：-------->程序猿 程序媛
    
    
    什么是对象？（看的见，摸得到，具体特指的某个东西）
    找对象（描述找对象）
      文字描述找对象
         小明牵着小黄去逛街
         一台电视机正在播放影片
    
    分析对象有什么特点：特征和行为
       对象
    
    总结什么是对象
    没有对象
    创建对象

\*/

/*
    创建对象三种方式：
       1.调用系统的构造函数创建对象
       var 变量名 = new Object()
       2.自定义构造函数创建对象（结合第一种和需求通过工厂模式创建对象）
       3.字面量的方式创建对象

\*/

// 第一种创建对象的方式
      // 例子：
      //实例化一个对象
      var obj = new Object();
      // 对象有特征--属性和行为---方法
    
      // 增加属性
      obj.name = "小汪";
      obj.age = 19;
      obj.sex = "男";
    
      // 增加方法-----如何增加方法？对象.名字 = 函数
      obj.eat = function () {
        console.log("我喜欢吃肉");
      };
      obj.play = function () {
        console.log("我喜欢玩无人飞机");
      };
      obj.cook = function () {
        console.log("我喜欢煮饭");
      };
    
      //获取输出
      console.log(obj.name);
      console.log(obj.age);
      console.log(obj.sex);
      // 方法的调用
      obj.eat();
      obj.play();
      obj.cook();
    
      // ===================创建对象类型
      // 练习：有一个黄色的额小狗，叫大黄，今年已经 3岁了，250斤的重量每次走路都是很慢的额，喜欢吃骨头
      // 创建对象
      var smallDog = new Object();
      smallDog.name = "大黄";
      smallDog.age = 3;
      smallDog.color = "黄色";
      smallDog.weight = "250";
      smallDog.eat = function () {
        console.log("我要吃大骨头");
      };
      smallDog.walk = function () {
        console.log("走一步摇尾巴");
      };
    
      smallDog.eat();
      smallDog.walk();
    
      //============================工厂模式
      /*
    如何获取该变量（对象）是不是属于什么类型
    语法：
    	变量instanceof类型的名字-------->布尔类型，true就是这种类型，false就不是这个类型
    在当前的对象的方法中，可以使用this关键字代表当前的对象

\*/  
// 人的对象  
var person = new Object();  
person.name = “小白”;  
person.age = 10;  
person.sayHi = function () \{  
console.log("您好，吃饭了吗，我叫: " + this.name);  
\};

// 学生的对象
      var stu = new Object();
      stu.name = "小汪";
      stu.age = 18;
      stu.study = function () {
        console.log("学习，敲代码:今年" + stu.age);
      };
    
      // 小狗的对象
      var dog = new Object();
      dog.name = "哮天犬";
      dog.say = function () {
        console.log("我是哮天犬");
      };
    
      // instanceof 测试是否在prototype构造函数的性质在对象的原型链中的任何地方出现。
      console.log(person instanceof Object);
      person.sayHi();
      stu.study();
      // 对象不能分辨出到底是属于什么类型的？
      // 如何一次性创建多个对象？吧创建的代码，封装在一个函数里面
    
      // 工厂模式创建对象
      function createObject(name, age) {
        var obj = new Object(); //创建对象
        //添加属性
        obj.name = name;
        obj.age = age;
        //添加方法
        obj.sayHi = function () {
          console.log("我叫:" + this.name + "我今年:" + this.age);
        };
        return obj;
      }
      //创人的对象
      var per1 = createObject("小芳", 20);
      per1.sayHi();
      var per2 = createObject("小汪", 30);
      per2.sayHi();
    
      // 自定义构造函数创建对象,我要自己定义一个构造函数，自定义构造函数，创建对象
      // 函数和构造函数的区别：名字是不是大写（首字母是不是大写）
      function Person() {
        this.name = "小明";
        this.age = 10;
        this.sayHi = function () {
          console.log("我叫:" + this.name + "今年:" + this.age);
        };
      }
      //自定义构造函数创建对象:先自定义一个构造函数，创建对象
      var obj = new Person();
      console.log(obj.name);
      console.log(obj.age);
      obj.sayHi();
    
      function Person(name, age) {
        this.name = name;
        this.age = age;
        this.sayHi = function () {
          console.log("我叫:" + this.name + "今年:" + this.age);
        };
      }
      var obj = new Person("小明", 20);
      console.log(obj.name);
      console.log(obj.age);
      obj.sayHi();
    
      var obj1 = new Person("小红", 18);
      console.log(obj1.name);
      console.log(obj1.age);
      obj1.sayHi();
    
      console.log(obj instanceof Person);
      console.log(obj1 instanceof Person);
    
      // 自定义狗的构造函数，创建对象
      function Dog(name, age, sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
      }
      var dog = new Dog("大黄", 20, "男");
      console.log(dog instanceof Person); //false
      console.log(dog instanceof Dog); //true
    
      /* 1.在内存中开辟(申请一块空闲的空间)空间，存储创建新的对象
    2.把this设置为当前的对象
    3.设置对象的属性和方法的值
    4.把this这个对象返回

\*/

\*/

\*/

// 重新改值（缺席一次性的对象）
      var obj = {
        name: "晨光",
        age: 20,
        sex: "女",
      };
      obj.name = "小女子";
      console.log(obj.name);
    
      // 点语法：=======    对象.名字 = 值.名字 = 函数;
    
      var obj = {}; //空对象
      obj.name = "我爱你";
      obj.age = 10;
      obj.fly = function () {
        console.log("飞吧");
      };
      obj.fly();
    
      // 找出两个数字最大的值
      console.log(10 > 20 ? 10 : 20);
    
      /*=
    设置和获取属性的另一种写法

=\*/  
function Person(name, age) \{  
this.name = name;  
this.age = age;  
\}  
var obj = new Person(“您”, 20);  
console.log(obj.name);  
console.log(obj.age);

1.内置对象----js系统自带的对象  
2.自定义对象----自己定义的构造函数创建对象  
3.浏览器对象-----DOM

内置对象：  
Math  
Date  
String  
Array  
Object  
\*/  
// 如何验证变量是不是对象？  
console.log(Array instanceof Object); //true  
var obj = \{\};  
console.log(obj instanceof Object);

// Math:内置对象，它具有数学常数和函数的属性和方法，不是一个函数对象
      // 实例对象：通过构造函数创建出来；实例化的对象
      // 静态对象：不需要创建，直接就是一个对象，方法（静态方法）直接通过这个对象名字调用
      // 实例方法必须通过实例来调用对象
      // 静态方法必须通过大写的对象来调用
      // Math.PI --------π
      // Math.E---------常数的底数
      // Math.abs(值)--------绝对值
      // Math.ceil就是向上取整
    
      // Math()  不是构造器
      var arr = [];
      // arr.forEach();
      Math.abs(); //这是一个方法  Math.abs = function(){}
    
      console.log(Math.PI);
      var arr = new Array();
    
      console.log(Math.abs("-1")); //1
      console.log(Math.abs(-2)); //2
      Math.abs(null); // 0
      Math.abs(""); // 0
      Math.abs([]); // 0
      Math.abs([2]); // 2
      Math.abs([1, 2]); // NaN
      Math.abs({}); // NaN
      Math.abs("string"); // NaN
      Math.abs(); // NaN
    
      console.log(Math.ceil(12.3)); //13    ceil就是向上取整
      console.log(Math.floor(12.3)); //12   floor向下取整
    
      // 找一坨数字中最大的值
      console.log(Math.max(10, 1, 20, 30, 30, 40, 50, 200, 10000));
    
      // 找一坨数字中最小的值
      console.log(Math.min(10, 1, 20, 30, 30, 40, 50, 200, 10000));
    
      // 次方，就是幂
      console.log(Math.pow(2, 4)); //2的四次方
    
      // Math.random  随机数（0，1）
      console.log(parseInt(Math.random() * 5) + 1); //1-5
    
      /*
    
    内置对象
    Math----->对象案例

\*/

\*/

// <div id="div"></div>
    
      function getColor() {
        var str = "#";
        // 一个十六进制的值的数组
        var arr = [
          "0",
          "1",
          "2",
          "3",
          "4",
          "5",
          "6",
          "7",
          "8",
          "9",
          "a",
          "b",
          "c",
          "e",
          "f",
        ];
        // console.log(parseInt(Math.random()*5)+1);
        for (var i = 0; i < 6; i++) {
          // 产生的每个随机数都是一个索引，根据索引找到数组中对应的值，拼接到一起
          var num = parseInt(Math.random() * 16);
          str += arr[num];
        }
        return str;
      }
    
      // 页面加载的事件
      window.onload = function () {
        // 在文档中通过id属性的值查找这个元素（标签）;设置改标签的背景颜色
        document.getElementById("div").style.backgroundColor = getColor();
      };
      console.log(getColor());
    
      /*========================Date======================*/
      // 创建实例对象
      var dt = new Date();
      // 当前时间-----当前的服务器的时间
      console.log(dt);
    
      var dt = new Date("2018-10-20");
      console.log(dt);
    
      var dt = new Date("2018,10,21");
      console.log(dt);
    
      var dt = new Date("2018/10/29");
      console.log(dt);
    
      var dt = Date.now();
      console.log(dt); //毫秒
    
      // 例子
      var dt = new Date();
      // 获取年份
      console.log(dt.getFullYear());
      // 获取月份
      console.log(dt.getMonth() + 1); //从0开始的
      // 获取日期
      console.log(dt.getDate());
      // 获取小时
      console.log(dt.getHours());
      // 获取分钟
      console.log(dt.getMinutes());
      // 获取秒
      console.log(dt.getSeconds());
    
      // 获取星期
      console.log(dt.getDay()); //星期是从0开始的，星期日是0
    
      var dt = new Date();
      // 转成字符串类型
      console.log(dt.toString()); //Wed Oct 17 2018 09:19:32 GMT+0800 (中国标准时间)
      console.log(dt.toDateString()); // Wed Oct 17 2018   英文的日期
      console.log(dt.toLocaleDateString()); //2018/10/17   数字格式的日期
    
      console.log(dt.toTimeString()); //小时分钟
      console.log(dt.toLocaleTimeString()); //下午8:13:53
      console.log(dt.valueOf()); //毫秒
    
      /*

总结Date对象

\*/

/*这是一种特殊写法，不支持H5用这个*/
      var dt = +new Date();
      console.log(dt);
    
      var dt = new Date();
      dt.getFullYear(); //年
      dt.getMonth(); //月---从0开始
      dt.getDate(); //日
      dt.getHours(); //小时
      dt.getMinutes(); //分钟
      dt.getSeconds(); //秒
      dt.getDay(); //星期---从0开始
      dt.toDateString(); //日期
      dt.toLocaleDateString(); //日期
      dt.toTimeString(); //时间
      dt.toLocaleTimeString(); //时间
      dt.value0f(); //毫利
    
      // 格式化日期和时间
      // 格式化后的指定格式的日期----封装一个函数
      function getDate(dt) {
        var dt = new Date(); //创建日期的对象
        // 获取年
        var year = dt.getFullYear();
        // 获取月
        var month = dt.getMonth() + 1;
        // 获取日
        var day = dt.getDate();
        // 获取小时
        var hour = dt.getHours();
        // 获取分钟
        var minute = dt.getMinutes();
        // 获取秒
        var second = dt.getSeconds();
        // 获取星期
        // var week = dt.getDay();
    
        month = month < 10 ? "0" + month : month;
        day = day < 10 ? "0" + day : day;
        hour = hour < 10 ? "0" + hour : hour;
        minute = minute < 10 ? "0" + minute : minute;
        second = second < 10 ? "0" + second : second;
    
        return (
          year +
          "年" +
          month +
          "月" +
          day +
          "日" +
          "  " +
          hour +
          "时" +
          minute +
          "分" +
          second +
          "秒"
        );
      }
      var dt = new Date();
      console.log(getDate(dt));
    
      // String 对象
      // string ----->字符串类型----->基本类型
      // String----->字符串类型----->引用类型
    
      // 字符串对象------String类型
      var str = "90";
      var str = "哈哈";
    
      var str = "我有变帅了";
      /*
    js中没有字符串了类型
    字符串类型
    字符类型

\*/

/*
    整数类型
    int num = 10;
    小数类型
    float = num = 90.9；
    字符串
    string str = "hello";//字符串必须用双引号
    字符
    char ch = 'h';//字符必须用单引号----值--只有一个
    
    'h'+'e'+'l'+'l'+'o';======hello
    
    字符串是可以看成是多个字符组合成的数组的
    
    js中无论是单引号还是双引号都是字符串

var str = “hello”;//可有knack是一个字符串  
for(var i = 0;i < str.length;i++)\{  
console.log(str\[i\]);  
\}

\*/

var str = "hello"; //可有knack是一个字符串
      for (var i = 0; i < str.length; i++) {
        console.log(str[i]);
      }
    
      /*
    String----->是一个对象
    字符串可以看成是一个字符组成的数组，但是js中没有字符类型
    字符是一个一个的，在别的语言中字符用一对单引号=括起来的
    在js中字符串课一使用单引号也可以使用双引号的
    因为字符串可以看成是数组，可以通过for循环进行遍历的
    
    
    字符串的特征：不可变性,字符串的值是不能改变的
    var str = "你好";//这个是栈，
    var str = new String("您好");//开辟一个空间，应用类型
    
    
    字符串的值之所以看起来改变了，那是因为指向改变了，并不是真的值改变了

\*/

// 对象的方式来看待的
    
      var str = "我好帅";
      str = "我不帅"; //重新赋值,开辟一个新的空间
      console.log(str);
    
      var str = "hello";
      for (var i = 0; i < str.length; i++) {
        console.log(str[i]);
        // document.write(str[i]);
      }
    
      var str = "hello";
      str[1] = "w"; //字符串可以通过索引访问字符串中的某个值，但是，是可以访问----读取---只读；设置：就是可以改变的
      console.log(str);
    
      var str = "123";
      str = "456";
      console.log(str);
    
      /*

实例方法：必须要通过new的方式创建的对象(实例对象)来调用的方法  
静态方法：直接通过大写的构造函数的名字调用的方法-------（也就是说直接通过大写的对象的名字去调用的）

\*/

/*
    字符串的方法
    
    
    字符串的常用属性
    .length----------->字符串的长度
    .charAt(索引)---------->返回值是指定索引的字符串，超出索引是空字符串
    .fromCharCode(数字值,可以传入多个的参数);返回的是ASCII码对应的值
    .concat(字符串1,字符串2...);字符串的拼接，返回新的字符串
    .indexOf(要找的字符串，从某个位置就开始的索引);返回的是这个字符串的索引值，没有找到就是返回-1
    .lastIndexOf(要找的字符串);从后向前找，但是索引任然也是从左往右查找
    .replace("旧的值字符串","新的值字符串");就是替换旧的值
    .slice(开始的，结束的);//截取中间的想要的值，从索引5的位置开始提取，到索引为10的位置前一个结束，没有10，并返回提出后的字符串
    .split("要干掉的字符串”,切割后留下的个数);//切割字符串
    .substring(开始的索引，结束的索引);//截取截取后面的个数，返回截取后的额字符串（不包含结束的）
    .toLocaleLowerCase();//大写转小写   或者是    .toLowerCase();
    .toLocaleUpperCase();//小写转大写    或者是    .toUpperCase();//小写转大写
    .trim();//干掉字符串左右两端的空格

\*/

1.alert() 方法用于带有一条指定消息和一个【确定】按钮的警示框 （中文是：确认；英文是：ok）

ep: <script type="text/javascript">alert("我在这里")

2.confirm() 弹出两个按钮对话框 【确认】【取消】；单击【确认】返回真，否则为假  
ep:

function test() {
    		var res = confirm('今天你开心吗？')
    		if (res) {
    			alert('相当开心');
    		}else{
    			alert('不开心');
    		}*/
      // 		}
    
      /*<!-- 3.prompt()   用于可以显示可以提示用户输入的对话框  (如果用户点击取消的话，则返回null)
    语法：prompt(text,defaultText)      text:可选，是要在对话框中显示纯文本     defaultText :可选，是默认的输入框
    ep:
          <input type="button" onclick="disp_prompt()" value="prompt" />
          
    	function disp_prompt(){
    	         var name=prompt("请你输入：")
    	         if (name!=null && name!=""){
    	 	   document.write("Hello " + name + "!")
    	              }
    	  }

\*/