JavaScript基础----全方位的基础篇（一），前方高能哦

╰+攻爆jí腚メ 2022-05-13 00:50 133阅读 0赞

\--------------------------------------------JavaScript:简介----------------------------------------------------

JavaScript:简称：js  
     js分为三部分：  
         1.ECMAScript 标准------js的基本语法  
         2.DOM---------Document Object Model 文档对象模型  
         3.BOM----------Browser Object Model 浏览器对象模型

JavaScript是什么？  
             是一门脚本语言  
             是一门解释性语言  
             是一门动态类型的语言  
             是一门基于对象的语言  
            是一门弱类型语言  
            运行在客户端

编译语言：需要把代码 翻译成计算机所认知的二进制语言，才能够执行  
         脚本语言：不需要编译，直接可以运行的  
         常见的脚本语言：t-sql ，cmd

电脑的硬件---->系统---->客户端的程序----->代码  
         电脑的硬件---->系统---->浏览器---->js代码  
         js原名不是JavaScript，是 liveScript

js的作用？解决用户个浏览器之间的交互的问题

js现在可以做什么？  
             1.网页特效  
             2.服务端开发（node.js）  
             3.命令行工具（node.js）  
             4.桌面程序（electron）  
             5.App（cordova）  
             6.控制硬件-物联网（Ruff）  
             7.游戏开发（coco2d-js）

HTML：是标记语言，展示数据的  
         css：美化页面的  
         JavaScript：用户和浏览器交互

js代码可以分为三个部分：  
             1.在html的文件中，script的标签中写js代码  
             2.js代码可以在html的标签中写  
             3.在js文件中可以写js代码，但是需要在html的页面中引入

在 webstorm工具中打开页面：（Window）  
             1.右上角有浏览器图标，直接点击即可  
             2.快捷键：alt + f2 回车或者上下键选择

1.在一对script的标签中有错误的js代码，那么该错误的代码后面的js代码不会执行  
          2.如果第一对的script标签中有错误的，不会影响后面的script标签中的js代码执行  
          3.script的标签中可以可以写任何内容type=“text/JavaScript”是标准写法或者写language=“JavaScript”都是可以的  
              (但是，目前在我们的html页面中，type和language都是可以省略的，原因：html是遵循H5的标准的)  
                  4.有可能会出现这种情况：script标签中可能同时出现type和language写法  
          5.script标签在页面中可以多次成对出现  
          6.script标签一般是body的标签的最后的， 有的时候需要开头就要用到的就放在head标签中，我现在一般都是放在body后面里面的。  
          7.如果script标签是引入外部js文件的作用，那么这对标签中不写任何的js代码，如果要写，重新写一对script标签，里面写代码。

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

操作的数据都是内存中操作  
          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; //变量的声明，此时是没有赋值的,    -->返回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 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;

//声明多个变量然后一个一个的赋值  
               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);

案例：变量的交换（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 = 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);

console.log(Number.MAX\_VALUE);  
        console.log(Number.MIN\_VALUE);

无穷大：Infinity  
        无穷小：-Infinity

//不要用小数去验证小数
            var x = 0.1;
            var y = 0.2;
            var sum = x + y;
            console.log(sum);//0.30000000000000004
            console.log(sum == 0.3);//false
    
            //不要用NaN验证是不是NaN
            var num;
            console.log(num + 10 == NaN);

//不要用小数去验证小数  
        var x = 0.1;  
        var y = 0.2;  
        var sum = x + y;  
        console.log(sum);//0.30000000000000004  
        console.log(sum == 0.3);//false

//不要用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 = "您好";  
             var str2 = "我好";  
             console.log(st1 + str2);

// 只要只有一个字符串，其他的是数字，那么结果也是拼接，不是计算
                 var str1 = "20";
                 var str2 = 40;
                 console.log(str1 + str2);

// 只要只有一个字符串，其他的是数字，那么结果也是拼接，不是计算  
             var str1 = "20";  
             var str2 = 40;  
             console.log(str1 + str2);

// （如果有一个是字符串，另一个不是字符串，使用-号，此时会发生计算）
                 var str1 = "30";
                 var str2 = 10;
                 // 浏览器帮助我们自动的吧字符串类型转成数字类型，这种方式叫做：隐式转换
                 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;

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"));

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"));

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(num.toString());//无意义的  
                 var num = null;  
                 console.log(num.toString());//无意义

var num;
                     console.log(String(num));//undefined
                     var num = null;
                     console.log(String(num));//null

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

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 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 = 10;  
                num += 10;//num = num + 10  
                console.log(num);//20

var num = 20;
                    num -= 3; //num = num -3
                    console.log(num);//17

var num = 20;  
                num -= 3; //num = num -3  
                console.log(num);//17  
            复合运算符表达式：由复合运算符连接起来的表达式  
        关系运算符：>    <     >=   <=     ==(不严格等于)        ===(严格等于)   !=(不严格不等于)    !==(严格不等于)  
            不严格等于：var str = "5";

var num = 5;
                              console.log(str == num);//true

var num = 5;  
                          console.log(str == num);//true

严格等于：(类型也是要相等的)

var str = "5";
                        var  num = 5;
                        console.log(str === num);//false

var str = "5";  
                    var  num = 5;  
                    console.log(str === num);//false  
               关系运算表达式：由关系运算符连接起来的表达式  
               关系运算表达式的结果是布尔类型  
        逻辑运算符：&&----逻辑与---并且  
                      ||------逻辑或---或者  
                      ！-----逻辑非---取反---取非  
                      逻辑运算表达式：由逻辑运算符连接起来的表达式

var num1 = 10;
                               var num2 = 20;
                               console.log(num1 == num2 && 5 > 6);//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);//60

var num = 10;
                    var sum = (num + 10)* 5
                    console.log(sum);//100

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 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 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;
        ++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

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

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);//20  
    console.log(num);//9

var num = 10;
        var sum = --num +10;
        console.log(sum);//19
        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)
                            }

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("可以看电影了，哈哈");
                            }

var age = 19;  
                        if (age >= 18) \{  
                            console.log("可以看电影了，哈哈");  
                        \}

3.如果小样比小汪帅，则输出帅

var str = "帅";
                            if (str == "帅") {
                                console.log("您真的好帅");
                            }

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 = 10;  
                    if(age >= 18)\{  
                        console.log("可以看电影");  
                    \}else\{  
                        console.log("回家写作业去");  
                    \}

提示用户输入年龄

var age =  parseInt(prompt("请您输入您的年龄")) ;//这个是字符串类型,要装换为数字类型
                    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 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 = 9;  
                if(number % 2 == 0)\{  
                    console.log("偶数");  
                \}else\{  
                    console.log("奇数");  
                \}

var  number = prompt("请您输入数字");
                    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;  
                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 x = 10;  
                var y = 20;  
                var result = x > y ? x : y;  
                console.log(result);

显示成年还是未成年

var age = 20;
                    var result = age >= 18 ? "成年了" : "未成年";
                    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 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 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");
                                 }

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("您的输入有误，重新输入");
                 }

//根据月份显示对应的天数  
             // 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("您的输入有误，重新输入");  
             \}

3.循环结构：while循环；do-while ，for ，for-in

现总结到这里，最近比较忙，下周再去总结。请您们敬请期待。。。