3、js基本语法
一、注释
多行注释：/* */
多行注释，注释中的内容不会被执行，但是可以在源代码中查看
要养成良好的编写注释的习惯，也可以通过注释来对代码进行一些简单的调试
单行注释：//
补充：
1.JS中严格区分大小写
2.JS中每一条语句以分号(;)结尾
- 如果不写分号，浏览器会自动添加，但是会消耗一些系统资源，而且有些时候，浏览器会加错分号，所以在开发中分号必须写
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>
四、基本数据类型
1、String类型
<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>
2、Number类型
<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>
3、Boolean类型
<script type="text/javascript">
/*
* Boolean 布尔值
* 布尔值只有两个，主要用来做逻辑判断
* true
* - 表示真
* false
* - 表示假
*
* 使用typeof检查一个布尔值时，会返回boolean
*/
var bool = false;
console.log(typeof bool); //boolean
console.log(bool); //false
</script>
4、Null类型和Undefined类型
<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>
五、类型转换
1、强制类型转换为String
<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>
2、强制类型转换为Number
<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>
3、其它进制的数字（了解）
<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>
4、强制类型转换为Boolean
<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>
十、输出指定Unicode的字符
<!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;">☠</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>
浙公网安备 33010602011771号