3、js基本语法

<script type="text/javascript">               
            /*
             * 字面量，都是一些不可改变的值
             *        比如 ：1 2 3 4 5 ，字面量都是可以直接使用，但是我们一般都不会直接使用字面量
             * 
             * 变量   变量可以用来保存字面量，而且变量的值是可以任意改变的
             *        变量更加方便我们使用，所以在开发中都是通过变量去保存一个字面量，而很少直接使用字面量，可以通过变量对字面量进行描述
             */
            
            //声明变量
            //在js中使用var关键字来声明一个变量
            var a;
            
            //为变量赋值
            a = 123;
            a = 456;
            a = 123124223423424;
            
            //声明和赋值同时进行
            var b = 789;
            var c = 0;
            
            var age = 80;
            
            console.log(age);
            

</script>

<script type="text/javascript">
            
            /*
             * 标识符
             *     - 在JS中所有的可以由我们自主命名的都可以称为是标识符
             *     - 例如：变量名、函数名、属性名都属于标识符
             *     - 命名一个标识符时需要遵守如下的规则：
             *         1.标识符中可以含有字母 、数字 、下划线_ 、$符号
             *         2.标识符不能以数字开头
             *         3.标识符不能是ES中的关键字或保留字
             *         4.标识符一般都采用驼峰命名法
             *             - 首字母小写，每个单词的开头字母大写，其余字母小写
             *             helloWorld  xxxYyyZzz
             * 
             *     - JS底层保存标识符时实际上是采用的Unicode编码，
             *         所以理论上讲，所有的utf-8中含有的内容都可以作为标识符
             */
            /*
               var if = 123;
            
               console.log(if); if是关键字，报错："Uncaught SyntaxError: Unexpected token if"
            
            */
            
            
            //千万不要这么用
            var 锄禾日当午 = 789;
            console.log(锄禾日当午);//789，能用，但不规范
            
            
</script>

<script type="text/javascript">
            
            /*
             * 数据类型指的就是字面量的类型
             *  在JS中一共有六种数据类型
             *         String    字符串
             *         Number    数值
             *         Boolean   布尔值
             *         Null      空值
             *         Undefined 未定义
             *         Object    对象
             * 
             * 其中String Number Boolean Null Undefined属于基本数据类型
             * 而Object属于引用数据类型
             */
            
            
            /*
             * String字符串
             *     - 在JS中字符串需要使用引号引起来
             *     - 使用双引号或单引号都可以，但是不要混着用
             *     - 引号不能嵌套，双引号不能放双引号，单引号不能放单引号
             */
            var str = ‘hello‘;
            str = ‘我说:"今天天气真不错！"‘;
            console.log(str);//我说:"今天天气真不错！"
            
            
            /*
                 在字符串中我们可以使用\作为转义字符，
                     当表示一些特殊符号时可以使用\进行转义
                     
                     \"  表示 "
                     \‘  表示 ‘
                     \n  表示换行
                     \t  制表符
                     \\  表示             * */
            str = "我说:\"今天\t天气真不错！\"";
            console.log(str);//我说:"今天    天气真不错！"
            
            
            //修改了变量的值,最后那次有效
            var str2 = "hello";
            str2 = "你好";
            str2 = 3;
            console.log(str2);//3
            
</script>

 <script type="text/javascript">
            
            /*
             * 在JS中所有的数值都是Number类型，
             *     包括整数和浮点数（小数）
             * 
             * JS中可以表示的数字的最大值
             *     Number.MAX_VALUE
             *         1.7976931348623157e+308
             * 
             *     Number.MIN_VALUE 大于0的最小值
             *         5e-324
             * 
             *  如果使用Number表示的数字超过了最大值，则会返回一个
             *         Infinity 表示正无穷
             *         -Infinity 表示负无穷
             *         使用typeof检查Infinity也会返回number
             * 
             *  NaN 是一个特殊的数字，表示Not A Number
             *         使用typeof检查一个NaN也会返回number
             */
            
            //数字123
            var a = 123;
            //字符串123
            var b = "123";
            
            /*
                 可以使用一个运算符 typeof来检查一个变量的类型
                 语法：typeof 变量    
                 检查字符串时，会返回string
                 检查数值时，会返回number
             * */
            console.log(typeof b); //string
            //-----------------------------------------------
            
            a = -Number.MAX_VALUE * Number.MAX_VALUE;
            console.log(a); //-Infinity
            //-----------------------------------------------
            
            a = "abc" * "bcd";
            console.log(a); //NaN
            //-----------------------------------------------
            
            a = NaN;
            console.log(typeof a); //number
            //-----------------------------------------------
            
            a = Number.MIN_VALUE;
            console.log(a); //5e-324
            //-----------------------------------------------
            
            /*
             * 在JS中整数的运算基本可以保证精确
             */
            var c = 1865789 + 7654321;
            console.log(c); //9520110
            //-----------------------------------------------
            
            /*
             * 如果使用JS进行浮点运算，可能得到一个不精确的结果
             *     所以千万不要使用JS进行对精确度要求比较高的运算    
             */
            var c = 0.1 + 0.2;
            console.log(c); //0.30000000000000004
            
            
 </script>

       <script type="text/javascript"> 
            /*
             * Boolean 布尔值
             *     布尔值只有两个，主要用来做逻辑判断
             *     true
             *         - 表示真
             *     false
             *         - 表示假
             * 
             * 使用typeof检查一个布尔值时，会返回boolean
             */
            
            var bool = false;
            
            console.log(typeof bool); //boolean
            console.log(bool); //false         
        </script>

        <script type="text/javascript">
            
            /*
             * Null（空值）类型的值只有一个，就是null
             *     null这个值专门用来表示一个为空的对象
             *     使用typeof检查一个null值时，会返回object
             * 
             * Undefined（未定义）类型的值只有一个，就undefind
             *     当声明一个变量，但是并不给变量赋值时，它的值就是undefined
             *     使用typeof检查一个undefined时也会返回undefined
             */
            var a = null;
            console.log(typeof a); //object
            
            var b;
            console.log(typeof b); //undefined
            
        </script>

<script type="text/javascript">
            
            /*
             * 强制类型转换
             *     - 指将一个数据类型强制转换为其他的数据类型
             *     - 类型转换主要指，将其他的数据类型，转换为String 、Number 、Boolean
             *         
             */
            
            /*
             * 将其他的数据类型转换为String
             *  方式一：
             *         - 调用被转换数据类型的toString()方法
             *         - 该方法不会影响到原变量，它会将转换的结果返回
             *         - 但是注意：null和undefined这两个值没有toString()方法，如果调用他们的方法，会报错
             * 
             *  方式二：
             *         - 调用String()函数，并将被转换的数据作为参数传递给函数
             *         - 使用String()函数做强制类型转换时，
             *             对于Number和Boolean实际上就是调用的toString()方法
             *             但是对于null和undefined，就不会调用toString()方法
             *                 它会将 null 直接转换为 "null"
             *                 将 undefined 直接转换为 "undefined"
             * 
             */
            
            //1.调用被转换数据类型的toString()方法
            var a = 123;
            a = a.toString();
            console.log(typeof a); //string
            
            
            a = true;
            a = a.toString();
            console.log(typeof a); //string
            
            a = null;
            a = a.toString(); 
            console.log(typeof a); //报错，Uncaught TypeError: Cannot read property ‘toString‘ of null
            
            a = undefined;
            a = a.toString(); 
            console.log(typeof a); //报错，Uncaught TypeError: Cannot read property ‘toString‘ of undefined
            
            //---------------------------------------------------------------------------------------------
            
            //2.调用String()函数，并将被转换的数据作为参数传递给函数
            a = 123;
            a = String(a);
            console.log(typeof a); //string
            
            a = null;
            a = String(a);
            console.log(typeof a); //string
            
            a = undefined;
            a = String(a);
            console.log(typeof a); //string
            
            //3.我用Java中的方法，发现也是可以的
            var b = 123;
            b = "" + b;
            console.log(typeof b); //string
       
        </script>

 <script type="text/javascript">
        
            /*
             * 将其他的数据类型转换为Number
             *      转换方式一：
             *         使用Number()函数
             *             - 字符串 --> 数字
             *                 1.如果是纯数字的字符串，则直接将其转换为数字
             *                 2.如果字符串中有非数字的内容，则转换为NaN
             *                 3.如果字符串是一个空串或者是一个全是空格的字符串，则转换为0
             *             
             *             - 布尔 --> 数字
             *                 true  转成 1
             *                 false 转成 0
             * 
             *             - null --> 数字     0
             * 
             *             - undefined --> 数字 NaN
             * 
             *  转换方式二：
             *         - 这种方式专门用来对付字符串
             *         - parseInt()   把一个字符串转换为一个整数
             *         - parseFloat() 把一个字符串转换为一个浮点数
             */
            
            //1.使用Number()函数
            var a = "123";
            a = Number(a);
            console.log(typeof a); //number
            
            a = "ABGFFF";
            a = Number(a);
            console.log(a); //NaN
            console.log(typeof a); //number,使用typeof检查一个NaN也会返回number
            
            a = "";
            a = Number(a);
            console.log(a); //0
            console.log(typeof a); //number
            
            a = false;
            a = Number(a);
            console.log(a); //0
            console.log(typeof a); //number
            
            a = null;
            a = Number(a);
            console.log(a); //0
            console.log(typeof a); //number
            
            a = undefined;
            a = Number(a);
            console.log(a); //NaN
            console.log(typeof a); //number
            
            //--------------------------------------------------------------------------------------------------
            
            //2.调用parseInt()函数、parseFloat()函数
            /*
             * parseInt()可以将一个字符串中的有效的整数内容取出来，
             *     然后转换为Number
             */
            a = "123567a567px";
            
            a = parseInt(a);
            console.log(a); //123567
            console.log(typeof a); //number
            
            
            /*
             * parseFloat()作用和parseInt()类似，不同的是它可以获得有效的小数
             */
            a = "123.456.789px";
            a = parseFloat(a);
            console.log(a); //123.456
            console.log(typeof a); //number
            
            
            /*
             * 如果对非String使用parseInt()或parseFloat()
             *     它会先将其转换为String然后再操作
             */
            a = true;
            a = parseInt(a);
            console.log(a); //NaN
            console.log(typeof a); //number
            
            
            a = 198.23;
            a = parseInt(a);
            console.log(a); //198
            console.log(typeof a); //number
            
        
            
        </script>

        <script type="text/javascript">
            
            
            /*
             * 在js中，如果需要表示16进制的数字，则需要以0x开头
             *        如果需要表示8进制的数字，则需要以0开头
             *        如果要要表示2进制的数字，则需要以0b开头，但是不是所有的浏览器都支持
             *     
             */
            
            //十六进制
            var a = 0x10;
            console.log(a);//16
            
            a = 0xff;
            console.log(a);//255
            
            a = 0xCafe;
            console.log(a);//51966
            
            //八进制数字
            a = 070;
            console.log(a);//56
            
            //二进制数字，则需要以0b开头
            //a = 0b10;
            //console.log(a);//报错，这个内置浏览器不支持 Uncaught SyntaxError: Unexpected token ILLEGAL，火狐 谷歌是支持的
            
            //-----------------------------------------------------------------------------------------------------------
            
            //向"070"这种字符串，有些浏览器会当成8进制解析，有些会当成10进制解析
            a = "070";
            //可以在parseInt()中传递一个第二个参数，来指定数字的进制
            a = parseInt(a,10);
            console.log(typeof a);//number
            console.log(a);//70
            
        </script>

        <script type="text/javascript">
            
            /*
             * 将其他的数据类型转换为Boolean
             *     - 使用Boolean()函数
             *         - 数字 ---> 布尔
             *             - 除了0和NaN，其余的都是true
             * 
             *         - 字符串 ---> 布尔
             *             - 除了空串，其余的都是true
             * 
             *         - null和undefined都会转换为false
             * 
             *         - 对象也会转换为true
             *         
             */
            
            //除了0和NaN，其余的都是true
            
            var a = 123;  
            a = Boolean(a);
            console.log(a);//true
            console.log(typeof a);//boolean
            
            
            a = -123;     
            a = Boolean(a);
            console.log(a);//true
            console.log(typeof a);//boolean
            
            
            a = Infinity;
            a = Boolean(a);
            console.log(a);//true
            console.log(typeof a);//boolean
            
            a = 0;        
            a = Boolean(a);
            console.log(a);//false
            console.log(typeof a);//boolean
            
            
            a = NaN;     
            a = Boolean(a);
            console.log(a);//false
            console.log(typeof a);//boolean
            
            //---------------------------------------------------------------------------------------------------
            
            //除了空串，其余的都是true
            
            a = "";
            a = Boolean(a);
            console.log(a); //false
            console.log(typeof a); //boolean
            
            a = "abc";
            a = Boolean(a);
            console.log(a); //true
            console.log(typeof a); //boolean
            
            //-------------------------------------------------------------------------------------
            
            //null和undefined都会转换为false
            
            a = null;
            a = Boolean(a); 
            console.log(a); //false
            console.log(typeof a); //boolean
            
            a = undefined; 
            a = Boolean(a);
            console.log(a); //false
            console.log(typeof a); //boolean
            
        </script>

<script type="text/javascript">
            
            /*
             * 运算符也叫操作符
             *     通过运算符可以对一个或多个值进行运算,并获取运算结果
             *     比如：typeof就是运算符，可以来获得一个值的类型，它会将该值的类型以字符串的形式返回 number string boolean undefined object
             * 
             *     算数运算符
             *         当对非Number类型的值进行运算时，会将这些值转换为Number然后再运算，任何值和NaN做运算都是NaN
             * 
             *         
             *         +    +可以对两个值进行加法运算，并将结果返回
             *              如果对两个字符串进行加法运算，则会做拼串，会将两个字符串拼接为一个字符串，并返回
             *             任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作
             *         
             *         -    - 可以对两个值进行减法运算，并将结果返回
             * 
             *         
             *         *    * 可以对两个值进行乘法运算
             *         
             *         /    / 可以对两个值进行除法运算
             *         
             *         %    % 取模运算（取余数）
             */
            
            var a = 123;
            var result = typeof a;
            console.log(result);//number
            console.log(typeof result); //string
            
            
            result = a + 1;
            console.log(result);//124
            
            
            result = 456 + 789;
            console.log(result);//1245
            
            
            result = true + 1;
            console.log(result);//2
            
            
            //任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作
            result = true + false;
            console.log(result);//1
            
            
            //任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作
            result = 2 + null;
            console.log(result);//2
            
            
            //任何值和NaN做运算都得NaN
            result = 2 + NaN;
            console.log(result);//NaN
            
            
            //如果对两个字符串进行加法运算，则会做拼串，会将两个字符串拼接为一个字符串，并返回
            result  = "123" + "456";
            console.log(result);//123456
            
            
            result = "你好" + "大帅哥";
            console.log(result);//你好大帅哥
            
            
            var str = "锄禾日当午，" +
                      "汗滴禾下土，" +
                      "谁知盘中餐，" +
                      "粒粒皆辛苦";
            console.log(str);//锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦          
            
            //-----------------------------------------------------------------------------------
            
            //任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作
            result = 123 + "1";
            console.log(result);//1231
            
            
            //任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作
            result = true + "hello";
            console.log(result);//truehello
            
            
            /*
             * 我们可以利用这一特点，来将一个任意的数据类型转换为String
             *     我们只需要为任意的数据类型 + 一个 "" 即可将其转换为String
             *     这是一种隐式的类型转换，由浏览器自动完成，实际上它也是调用String()函数
             */
            var c = 123;
            c = c + ""; //和c = String(c)本质上是一样的
            console.log(typeof c);//string
            
            
            result = 1 + 2 + "3"; 
            console.log(result); //33
            
            result = "1" + 2 + 3; 
            console.log(result); //123
            
            //-----------------------------------------------------------------------------------
            
            result = 100 - 5;
            console.log(result); //95
            
            result = 100 - true; 
            console.log(result); //99
            
            result = 100 - "1";
            console.log(result); //99
            
            result = 2 * 2;
            console.log(result); //4
            
            result = 2 * "8"; 
            console.log(result); //16
            
            result = 2 * undefined;
            console.log(result); //NaN
            
            result = 2 * null;
            console.log(result); //0
            
            result = 4 / 2;
            console.log(result); //2
            
            result = 3 / 2;
            console.log(result); //1.5
            
            //-----------------------------------------------------------------------------------
            
            /*
             * 任何值做  -  *  / 运算时都会自动转换为Number
             *     我们可以利用这一特点做隐式的类型转换
             *         可以通过为一个值 -0  、*1 、 /1来将其转换为Number，原理和Number()函数一样，使用起来更加简单
             */
            
            var d = "123";
            d = d - 0;
            console.log(d); //123
            console.log(typeof d);//number
            
            
            result = 9 % 3;
            console.log(result); //0
            
            result = 9 % 4;
            console.log(result); //1
            
            result = 9 % 5;
            console.log(result); //4
            
            
        </script>

        <script type="text/javascript">
            
            //前置递增
            var age = 29;
            ++age;
            console.log(age); //30
            //等同于
            var age = 29;
            age = age + 1;
            console.log(age); //30
            
            //前置递减和这个类似
            var age = 29;
            --age;
            console.log(age); //28
            
            //执行前置递减和递增操作时，变量的值都是在语句被求值以前改变的
            var age = 29;
            var anotherAge = --age + 2;
            console.log(age); //28
            console.log(anotherAge); 30
            
            //由于前置递减和递增操作与执行语句的优先级相等，因此整个语句会从左至右被求值
            var num1 = 2;
            var num2 = 20;
            var num3 = --num1 + num2;
            var num4 = num1 + num2;
            console.log(num3); //21
            console.log(num4); //21
            
            //zhou：通俗地说，前置就是先对自己加或减，把自己搞好了再去做其他的
            
            //----------------------------------------------------------------------------------------------------
            
            //后置递增和递减与前置递增和递减有一个非常重要的区别，即递增和递减操作是在包含它们的语句被求值之后才执行的
            //这个区别在某些情况下不是什么问题，例如：
            var age = 29;
            age++;
            console.log(age); //30
            
            //把递增操作符放在变量后面并不会改变语句的结果，因为递增是这条语句的唯一操作。
            //但是，当语句中还包含其他操作时，上述区别就会非常明显了，例如：
            var num1 = 2;
            var num2 = 20;
            var num3 = num1-- + num2;
            var num4 = num1 + num2;
            console.log(num3); //22
            console.log(num1); //1
            console.log(num4); //21
            
            //zhou：通俗地说，后置就是先去做其他的，等其他的搞好了，再对自己加或减
            
            var num1 = 2;
            var num2 = 20;
            var num3 = num1++ + num2;
            var num4 = num1 + num2;
            console.log(num3); //22
            console.log(num1); //3
            console.log(num4); //23
            
        </script>

        <script type="text/javascript">
        
            var n1=10;
            var n2=20;
            
            var n = n1++;     //后置，先赋值，即n=10，再n1自增1为11
            
            console.log(n);   //10
            console.log(n1);  //11
            
            n = ++n1          //前置，n1先自增1为12，再赋值给n，即n为12
            console.log(n);   //12
            console.log(n1);  //12
            
            n = n2--;         //后置，先把n2赋值给n，即n为20，再自减1，则n2为19
            console.log(n);   //20
            console.log(n2);  //19
            
            n = --n2;         //前置，n2先自减1，即n2为18，再赋值给n，即n为18
            console.log(n);   //18
            console.log(n2);  //18      
            
        </script>

<script type="text/javascript">
            
            /*
             * JS中为我们提供了三种逻辑运算符
             * ! 非
             *     - !可以用来对一个值进行非运算
             *     - 所谓非运算就是指对一个布尔值进行取反操作，
             *         true变false，false变true
             *     - 如果对一个值进行两次取反，它不会变化
             *     - 如果对非布尔值进行运算，则会将其转换为布尔值，然后再取反
             *         所以我们可以利用该特点，来将一个其他的数据类型转换为布尔值
             *         可以为一个任意数据类型取两次反，来将其转换为布尔值，原理和Boolean()函数一样
             * 
             * && 与
             *     - &&可以对符号两侧的值进行与运算并返回结果
             *     - 运算规则
             *         - 两个值中只要有一个值为false就返回false，
             *             只有两个值都为true时，才会返回true
             *         - JS中的“与”属于短路的与，
             *             如果第一个值为false，则不会看第二个值
             * 
             * || 或
             *     - ||可以对符号两侧的值进行或运算并返回结果
             *     - 运算规则：
             *         - 两个值中只要有一个true，就返回true
             *             如果两个值都为false，才返回false
             *        - JS中的“或”属于短路的或
             *             如果第一个值为true，则不会检查第二个值
             */
            
            var a = false;
            //对a进行非运算
            a = !a;
            console.log(a);//true
            
            
            //如果对非布尔值进行运算，则会将其转换为布尔值，然后再取反
            var b = 10;
            b = !!b; 
            console.log(b); //true
            console.log(typeof b); //boolean
            
            //------------------------------------------------------------------------
            
            //如果两个值都是true则返回true
            var result = true && true;
            console.log(result); //true
            
            //只要有一个false，就返回false
            result = true && false;
            result = false && true;
            result = false && false;
            console.log(result); //false
            
            //第一个值为true，会检查第二个值
            true && alert("看我出不出来！！");//可以弹窗
            
            //第一个值为false，不会检查第二个值
            false && alert("看我出不出来！！");//没有出现弹窗
            
            //--------------------------------------------------------------------
            
            //两个都是false，则返回false
            result = false || false;
            console.log("result = "+result);//false
            
            //只有有一个true，就返回true
            result = true || false;
            result = false || true ;
            result = true || true ;
            console.log("result = "+result);//true
            
            
            //第一个值为false，则会检查第二个值
            false || alert("123"); //可以弹窗
            
            //第一个值为true，则不再检查第二个值
            true || alert("123"); //没有出现弹窗
            
        </script>

　　　　<script type="text/javascript">
            
            /*
             * && || 非布尔值的情况
             *     
             *  - 对于非布尔值进行与或运算时，会先将其转换为布尔值，然后再运算，并且返回原值
             *     
             *  - 与运算：
             *         - 如果第一个值为true，则必然返回第二个值
             *         - 如果第一个值为false，则直接返回第一个值
             * 
             *     - 或运算
             *         - 如果第一个值为true，则直接返回第一个值
             *         - 如果第一个值为false，则返回第二个值
             * 
             */
            
            //true && true
            //与运算：如果两个值都为true，则返回后边的，谁在后边返回谁
            var result = 5 && 6;
            console.log("result = "+result); //6 
            
            
            //与运算：如果两个值中有false，则返回靠前的false
            //false && true
            result = 0 && 2;
            console.log("result = "+result); //0
            
            result = 2 && 0;
            console.log("result = "+result); //0
            
            
            //false &&　false
            result = NaN && 0;
            result = 0 && NaN;
            console.log("result = "+result); //0
            
            //-----------------------------------------------------------------------------
            
            //true || true
            //如果第一个值为true，则直接返回第一个值
            result = 2 || 1;
            console.log("result = "+result); //2
            
            result = 2 || NaN;
            console.log("result = "+result); //2
            
            result = 2 || 0;
            console.log("result = "+result); //2
            
            
            //如果第一个值为false，则直接返回第二个值
            result = NaN || 1;
            console.log("result = "+result); //1
            
            result = NaN || 0;
            console.log("result = "+result); //0
            
            result = "" || "hello";
            console.log("result = "+result); //hello
            
            result = -1 || "你好";
            console.log("result = "+result); //-1
            
            
        </script>
        

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <script type="text/javascript">
            
            /*
             * 在字符串中使用转义字符输入Unicode编码
             *     \u四位编码
             */
            console.log("\u2620"); //?
            
        </script>
    </head>
    <body>
        
        <!--
            在网页中使用Unicode编码
            &#编码; 这里的编码需要的是10进制
            十六进制2620用程序员计算器转成10进制，转成9760
        -->
        <h1 style="font-size: 200px;">&#9760;</h1>
    
        
    </body>
</html>

<script type="text/javascript">
            
            /*
             * 相等运算符用来比较两个值是否相等，
             *     如果相等会返回true，否则返回false
             * 
             * 使用 == 来做相等运算
             *     - 当使用==来比较两个值时，如果值的类型不同，
             *         则会自动进行类型转换，将其转换为相同的类型，然后再比较
             * 
             * 不相等
             *      不相等用来判断两个值是否不相等，如果不相等返回true，否则返回false
             *     - 使用 != 来做不相等运算
             *     - 不相等也会对变量进行自动的类型转换，如果转换后相等它也会返回false
             * 
             *         
             *  ===
             *         全等
             *         - 用来判断两个值是否全等，它和相等类似，不同的是它不会做自动的类型转换
             *             如果两个值的类型不同，直接返回false
             *     !==
             *         不全等
             *         - 用来判断两个值是否不全等，和不等类似，不同的是它不会做自动的类型转换
             *             如果两个值的类型不同，直接返回true
             */
            
            console.log(1 == 1); //true
            
            
            var a = 10;
            console.log(a == 4); //false
            
            
            //自动进行类型转换，将其转换为相同的类型，然后再比较
            console.log("1" == 1); //true
            
            
            //大部分情况会转成number类型
            console.log(true == "1"); //true
            
            
            //没转成number类型
            console.log(null == 0); //false
            
            
            /*
             * undefined 衍生自 null
             *     所以这两个值做相等判断时，会返回true
             */
            console.log(undefined == null); //true
            
            
            /*
             * NaN不和任何值相等，包括他本身
             */
            console.log(NaN == NaN); //false
            
            
            var b = NaN;
            //判断b的值是否是NaN，那没法判断b是不是NaN？我们可以用isNaN()函数
            console.log(b == NaN); //false
            
            
            /*
             * 可以通过isNaN()函数来判断一个值是否是NaN
             *     如果该值是NaN则返回true，否则返回false
             */
            console.log(isNaN(b));//true
            
            
            //----------------------------------------------------------------------
            
            //如果不相等返回true，否则返回false
            console.log(10 != 5);  //true
            
            console.log(10 != 10); //false
            
            console.log("abcd" != "abcd"); //false
            
            //不相等也会对变量进行自动的类型转换，如果转换后相等它也会返回false
            console.log("1" != 1); //false
            
            
            //----------------------------------------------------------------------
            
            //不会做自动的类型转换，如果两个值的类型不同，直接返回false
            console.log("123" === 123); //false
            
            console.log(null === undefined); //false
            
            
            //不会做自动的类型转换，如果两个值的类型不同，直接返回true
            console.log(1 !== "1"); //true
            
            
        </script>

　　　　<script type="text/javascript">
            /*
             * 条件运算符也叫三元运算符
             *     语法：
             *         条件表达式?语句1:语句2;
             *     
             * - 执行的流程：
             *         
             *         条件运算符在执行时，首先对条件表达式进行求值，
             *             如果该值为true，则执行语句1，并返回执行结果
             *             如果该值为false，则执行语句2，并返回执行结果
             *         
             *         如果条件的表达式的求值结果是一个非布尔值，会将其转换为布尔值然后再运算
             */
            
            false?alert("语句1"):alert("语句2");
            
            
            var a = 300;
            var b = 143;
            var c = 50;
            a > b ? alert("a大"):alert("b大");
            
            //------------------------------------------------------------------------
            
            //获取a和b中的最大值
            var max = a > b ? a : b;
            
            //获取a b c 中的大值
            max = max > c ? max : c;
            
            //这种写法不推荐使用，不方便阅读
            var max = a > b ? (a > c ? a :c) : (b > c ? b : c);
            
            console.log("max = "+max);//300
            
            //如果条件的表达式的求值结果是一个非布尔值，会将其转换为布尔值然后再运算
            "hello"?alert("语句1"):alert("语句2");//弹出语句1
            
            ""?alert("语句1"):alert("语句2");//弹出语句2
            
            
        </script>

        <script type="text/javascript">
            
            /*
             * 1、if语句

             * 2、条件分支语句也叫switch语句
             *     语法：
             *         switch(条件表达式){
             *             case 表达式:
             *                 语句...
             *                 break;
             *             case 表达式:
             *                 语句...
             *                 break;
             *             default:
             *                 语句...
             *                 break;
             *         }           
             */
            
        </script> 

        <script type="text/javascript">
            
            /*
             *1、 while循环
             *     - 语法：
             *         while(条件表达式){
             *             语句...
             *         }

             * 2、do...while循环
             *     - 语法：
             *         do{
             *             语句...
             *         }while(条件表达式) 

             * 3、for语句，也是一个循环语句，也称为for循环
             *     在for循环中，为我们提供了专门的位置用来放三个表达式：
             *         1.初始化表达式
             *         2.条件表达式
             *         3.更新表达式
             * 
             *  for循环的语法：
             *         for(①初始化表达式;②条件表达式;④更新表达式){
             *             ③语句...
             *         }
             * 
             *         for循环的执行流程：
             *             ①执行初始化表达式，初始化变量（初始化表达式只会执行一次）
             *             ②执行条件表达式，判断是否执行循环。
             *                 如果为true，则执行循环③
             *                 如果为false，终止循环
             *             ④执行更新表达式，更新表达式执行完毕继续重复②
             */


            /*
             * for循环中的三个部分都可以省略，也可以写在外部
             *     如果在for循环中不写任何的表达式，只写两个;
             *     此时循环是一个死循环会一直执行下去，慎用
             *     for(;;){
                    alert("hello");
                }
             */
            
        </script>