文章目录

一、数据类型的转换
二、程序的结构
三、分支语句
四、分支的嵌套
五、三目运算符和逻辑短路
六、分支语句的应用

一、数据类型的转换

在编程中，可能会遇到一些数据类符合程序要求的情况，如：程序需要数值型数据，但是却得到一个字符型数据。这个时候就需要用到数据类型的转换。

隐式类型转换 - 运算过程中，自动转
- 转换时机：运算过程中转换，不会影响原数据
- 场景：
  1. 某些运算符两边
    - +：只要有一个是字符，另一个也转成字符
    - - * / %：转数值
    - || && !：转布尔
    - > >= < <= == !=：只要有一个是数值，另一个也转成数值
  2. alert 和 document.write 的小括号内：转字符
  3. isNaN 的小括号：转数值
  4. if 语句的小括号内：转布尔
显示（强制）类型转换 - 主动转
- 主动使用某些转换方法强行转换，转换只是发生在执行方法的位置，没有影响原数据
- 其他转数值
  1. 转整数：parseInt(要转换的数据或变量)
    - 非严格转换
    - 不能识别小数点
  2. 转小数：parseFloat(要转换的数据或变量)
    - 非严格转换
    - 能识别小数点
  3. 四舍五入取最近的整数：Math.round(要转换的数据或变量)
    - 严格转换
  4. 其他转数值：Number(要转换的数据或变量)
    - 严格转换
    - 其他非字符类型的转换规则
- 其他转字符
  1. 其他转字符：要转换的数据或变量.toString()
    - 注意转字符的规则
  2. 保留n为小数转字符：数值变量.toFixed(n)
    - 一般用来处理数值，可以保留n位小数
  3. 其他转字符：String(要转换的数据或变量)
    - 注意转字符的规则
- 其他转布尔
  1. 其他转布尔：Boolean(要转换的数据或变量)
    - 注意转布尔的规则

转换规则：

其他转数值

非严格：从左向右一次检测字符，能转则转，不能转停止，返回已经转换的数值，如果第一位就不能转，直接NaN

console.log( parseInt("365.789") );			// 365
console.log( parseInt("36a5.7b89") );		// 36
console.log( parseInt("a36a5.7b89") );		// NaN
console.log( parseInt("hello") );			// NaN

严格：只要出现一个非数字的内容，就是NaN

console.log( Number("365.789") );			// 365.789
console.log( Number("36a5.7b89") );			// NaN
console.log( Number("a36a5.7b89") );		// NaN
console.log( Number("hello") );				// NaN

其他非字符的转换

对象，函数，undefind都是NaN

console.log( Number( {
            
            } ) );			// NaN
console.log( Number( undefined ) );		// NaN
console.log( Number( function(){
            
            } ) );	// NaN

空数组转为0
```
console.log( Number( [] ) );		// 0
```

数组内，有且只有一个能严格转成数值的数据，为当前数值

console.log( Number( ["hello"] ) );		// NaN
console.log( Number( [2] ) );			// 2
console.log( Number( [2, 3] ) );		// NaN
console.log( Number( ["2"] ) );			// 2
console.log( Number( [true] ) );		// NaN

true为1，false0

console.log( Number( true ) );			// 1
console.log( Number( false ) );			// 0

null为0
```
console.log( Number( null ) );			// 0
```

其他转字符

对象转成："[object Object]"

console.log( String( {
          
          } ) );				// "[object Object]"
console.log( String( {
          
          name:"admin"} ) );	// "[object Object]"

数组相当于将中括号替换成引号

console.log( String( [] ) );			// ""
console.log( String( [123] ) );			// "123"
console.log( String( [123,456] ) );			// "123,456"

其他都相当于直接给数据添加引号

console.log( String( true ) );			// "true"
console.log( String( function(){
          
          } ) );	// "function(){}"
console.log( String( undefined ) );		// "undefined"
console.log( String( null ) );			// "null"

注意：undefined和null不能直接使用任何方法，但可以被String方法转换

其他转布尔

字符：非空为true，空为false

console.log(Boolean( "hello" ));        // true
console.log(Boolean( "false" ));        // true
console.log(Boolean( "" ));             // false

数值：非0为true，0为false

console.log(Boolean( 23 ))              // true
console.log(Boolean( 23.45 ))           // true
console.log(Boolean( -23.45 ))          // true
console.log(Boolean( 0 ))               // false

undefined，null，NaN都是false

console.log(Boolean( undefined ))       // false
console.log(Boolean( null ))            // false
console.log(Boolean( NaN ))             // false

对象，数组，函数都是true

console.log(Boolean( {
          
          } ))              // true
console.log(Boolean( {
          
          name:"Admin"} ))  // true
console.log(Boolean( [] ))              // true
console.log(Boolean( [""] ))            // true
console.log(Boolean( [0] ))             // true
console.log(Boolean( function(){
          
          } ))    // true

二、程序的结构

顺序结构：默认结构，代码自上而下顺序执行
分支（选择）结构：根据不同的条件，执行不同的分支
循环结构：重复执行某个或某段代码，当遇到特定的条件时结束

三、分支语句

单分支 if(){} ：只有一个功能可供选择，执行或不执行

// if(){}
//     if          关键字，表示语句名
//     ()          判断条件
//     {}          当条件为true时，要执行的语句
console.log(1);
if(true){
      
      
    console.log("hello");
}
console.log(2)
// 控制台显示：
// 1
// hello
// 2

双分支 if(){}else{} ：根据条件的不同结果（ true 或 false ），选择不同的语句执行

// if(){}else{}
//     if          关键字，表示语句名1
//     ()          判断条件
//     {}          当条件为true时，要执行的语句
//     else        关键字，表示语句名2
//     {}          当条件为false时，要执行的语句

if(false){
      
      
    console.log("hello");
}else{
      
      
    console.log("world");
}
// 控制台显示：
// world

if 的逻辑点：if 小括号内的判断条件，我们通常也叫逻辑点。逻辑点内的数据会被计算为 true 或 false，如果最终得到的不是布尔值，那么逻辑点内会隐式类型转换成布尔值后，再进行判断

多分支 switch(){} ：根据条件的不同结果（多个不同结果），选择不同的语句执行

// switch(){}
//     switch      关键字，语句名
//     ()          要判断的值
//     {}          分支体
switch(要判断的值){
      
      
    case 可能的值1:
        // 执行语句1;
    case 可能的值2:
        // 执行语句2;
    case 可能的值3:
        // 执行语句3;
    ...
    default:
        // 当以上case都不符合时，要执行的语句
}
// 案例：根据数字转换大写
// 0，1，2，3
// 零，壹，贰，叁
var n = 1;
switch(n){
      
      
    case 0:
        console.log("零"); break;
    case 1:
        console.log("壹"); break;
    case 2:
        console.log("贰"); break;
    case 3:
        console.log("叁"); break;
    default:
        console.log("超出数字的范围，要求：0~3");
}
// 控制台显示：
// 壹

注意：

case 的穿透特性：在一个 switch 中，只要有一个 case 判断成功了，那么后面的 case 都不再判断，直接执行。可以使用关键字 break 阻止 case 的穿透。

var n = 1;
switch(n){
        
        
    case 0:
        console.log("零");
    case 1:
        console.log("壹");
    case 2:
        console.log("贰");
    case 3:
        console.log("叁");
    default:
        console.log("超出数字的范围，要求：0~3");
}
// 控制台显示：
// 壹
// 贰
// 叁
// 超出数字的范围，要求：0~3

switch 的小括号内，不会做判断，也不能做判断，也不会发生隐式类型转换
switch 语句会在 case 后，判断这个值是否符合

default 相当于 if 语句中的 else ，当以上条件都不满足的时候，执行 default

var n = "1";
switch(n){
        
        
    case 0:
        console.log("零"); break;
    case 1:
        console.log("壹"); break;
    case 2:
        console.log("贰"); break;
    case 3:
        console.log("叁"); break;
    default:
        console.log("超出数字的范围，要求：0~3");
}
// 控制台显示：
// 超出数字的范围，要求：0~3

四、分支的嵌套

单双分支的嵌套

var n = -5
if(n > 0){
      
      
	console.log(n + "为正数");
}else{
      
      
	if(n < 0){
      
      
		console.log(n + "为负数");
	}else{
      
      
		console.log(n + "为零");
	}
}
// 简写为
if(n > 0){
      
      
	console.log(n + "为正数");
}else if(n < 0){
      
      
	console.log(n + "为负数");
}else{
      
      
	console.log(n + "为零");
}

多分支的嵌套

var y = 2021;
var m = 2;
switch(m){
      
      
    case 1:
    	console.log("1月有31天"); break;
    case 2:
        if(y%4 === 0 && y%100 !== 0 || y%400 ===0){
      
      
        	console.log("2月有29天")
        }else{
      
      
        	console.log("2月有28天");
        }
        break;
    case 3:
    	console.log("3月有31天");
}

if-else 嵌套模拟多分支和 switch 多分支语句的区别：
- if 的小括号为逻辑点，一般用于放置范围判断条件，更适合做范围判断
- switch 会严格比较数据是否相等，更适合对具体的值进行判断

五、三目运算符和逻辑短路

三目运算符
三目运算符，又称条件运算符，是计算机语言的重要组成部分。因为它有3个操作数，又称为三元运算符。

语法为：条件表达式 ? 结果表达式1 : 结果表达式2

? 表示等待条件结果，如果条件表达式的值为真，则执行并得到结果表达式1；如果条件表达式为假，则执行并得到结果表达式2。

可以理解为：条件 ? 结果1 : 结果2
```
var a = 6;
console.log(a<10 ? "0"+a : a);	// "06"
```
逻辑短路
逻辑短路：就是利用逻辑运算符自身的一些特性进行数据运算。

如，|| 运算符，如果左边的值为true或可以转成true，那么 || 运算符就不会再执行右侧的表达式
```
console.log(0 || 1);		// 1
console.log(1 || 2);		// 1
console.log(2 || 1);		// 2
```
如，&& 运算符，如果左边的值为false或可以转成false，那么 && 运算符就不会再执行右侧的表达式
```
console.log(false && 1);	// false
console.log(false && 0);	// false
console.log(0 && false);	// 0
```

六、分支语句的应用

计算两个变量的加减乘除。要求：
1. 使用parseInt方法类型转换
2. 计算结果是用Math.round方法四舍五入
判断用户输入的数字是否为闰年
判断星期几；判断成绩；
假设0就是周日
假设1就是周一
判断一个整数属于哪个范围：大于0；小于0；等于0
判断一个整数是偶数还是奇数，并输出判断结果
有公式 (身高-108)*2=体重，左右可有10斤左右的浮动。来观察设定的用户的身高和体重是否合适
根据设定年份，计算某一年是否为闰年
能被4整除且不能被100整除，或者能被400整除
根据设定成绩分数，判定成绩等级(if和switch两种写法)
根据设定月份，显示当月的天数
要求：利用case穿透简化代码
小贺刚上班，按工作时间小时制领取周工资，工资标准是，每小时rate元RMB。每周工作时间40小时，如果要加班，超出部分按正常工资的1.5倍计（老板还算不错）。这周小贺上班的时间为hour小时，请编程序，输入rate和hour，输出小贺本周的薪水。
根据一个数字日期，判断这个日期是这一年的第几天例如： 2016和02和11，计算后结果为42
制作一个表单，有两个输入框，类型都是text：一个用来收集手机号，一个用来收集用户名；还有一个按钮，类型为button
要求1：点击按钮时，使用JS判断手机号是否为纯数字，如果用户输入有错误，使用alert()弹框警告
要求2：点击按钮时，使用JS判断用户名是否填写，如果没有填写用户名，使用alert弹框警告

二、JavaScript逻辑分支