【JavaScript】学习第二天（类型转换、运算符）

判断数据类型

• 既然已经把数据分开了类型，那么我们就要知道我们存储的数据是一个什么类型的数据
• 使用 typeof 关键字来进行判断

// 第一种使用方式
var n1 = 100;
console.log(typeof n1);

//第二种使用方式
var s1 = 'abcdefg';
console.log(typeof(s1));

判断一个变量是不是数字

• 可以使用 isNaN 这个方法来判断一个变量是不是数字
• isNaN ：is not a number

//如果变量是一个数字
var n1 = 100;
console.log(isNaN(n1));//=> false

//如果变量不是一个数字
var s1 = 'jack'
console.log(isNaN(s1));//=> true

数据类型转换

• 数据类型之间的转换，比如数字转成字符串，字符串转成布尔，布尔转成数字等

其他数据类型转成数值

1.Number(变量)

• 可以把一个变量强制转换成数值类型
• 可以转换小数，会保留小数
• 可以转换布尔值
• 遇到不可转换的都会返回 NaN

2.parseInt(变量)

• 从第一位开始检查，是数字就转换，知道一个不是数字的内容
• 开头就不是数字，那么直接返回 NaN
• 不认识小数点，只能保留整数

3.parseFloat(变量)

• 从第一位开始检查，是数字就转换，知道一个不是数字的内容
• 开头就不是数字，那么直接返回 NaN
• 认识一次小数点

4.除了加法以外的数学运算

• 运算符两边都是可运算数字才行
• 如果运算符任何一遍不是一个可运算数字，那么就会返回 NaN
• 加法不可以用

其他数据类型转成字符串

1.变量.toString()

• 有一些数据类型不能使用 toString() 方法，比如 undefined 和 null

2.String(变量)

• 所有数据类型都可以

3.使用加法运算

• 在 JS 里面， + 由两个含义
• 字符串拼接：只要 + 任意一边是字符串，就会进行字符串拼接
• 加法运算：只有 + 两边都是数字的时候，才会进项数学运算

其他数据类型转成布尔

1.boolean（变量）

• 在js中，只有 ‘’ 、 0 、 null 、 undefined 、 NaN ，这些是 false，其余都是 true

运算符

• 就是在代码里面进行运算的时候使用的符号，不光只是数学运算，我们在 js 里面还有很多的运算方
  式

数学运算符

1.+

• 只有符号两边都是数字的时候才会进行加法运算
• 只要符号任意一边是字符串类型，就会进行字符串拼接

2.-

• 会执行减法运算
• 会自动把两边都转换成数字进行运算

3.*

• 会执行乘法运算
• 会自动把两边都转换成数字进行运算

4./

• 会执行除法运算
• 会自动把两边都转换成数字进行运算

5.%

• 会执行取余运算
• 会自动把两边都转换成数字进行运算

赋值运算符

1.=

• 就是把 = 右边的赋值给等号左边的变量名
• var num = 100
• 就是把 100 赋值给 num 变量
• 那么 num 变量的值就是 100

2.+=

var a = 10; 
a += 10; 
console.log(a); //=> 20

• a += 10 等价于 a = a + 10

3.-=

var a = 10; 
a -= 10; 
console.log(a); //=> 0

• a -= 10 等价于 a = a - 10

4.*=

var a = 10; 
a *= 10; 
console.log(a); //=> 100

• a *= 10 等价于 a = a * 10

5./+

var a = 10; 
a /= 10;
 console.log(a); //=> 1

• a /= 10 等价于 a = a / 10

6.%=

var a = 10;
 a %= 10;
 console.log(a); //=> 0

• a %= 10 等价于 a = a % 10

比较运算符

1.==

• 比较符号两边的值是否相等，不管数据类型
• 1 == ‘1’
• 两个的值是一样的，所以得到 true

2.===

• 比较符号两边的值和数据类型是否都相等
• 1 === ‘1’
• 两个值虽然一样，但是因为数据类型不一样，所以得到 false

3.！=

• 比较符号两边的值是否不等
• 1 != ‘1’
• 因为两边的值是相等的，所以比较他们不等的时候得到 false

4.！==

• 比较符号两边的数据类型和值是否不等
• 1 !== ‘1’
• 因为两边的数据类型确实不一样，所以得到 true

5.>=

• 比较左边的值是否 大于或等于 右边的值
• 1 >= 1 true
• 1 >= 0 true
• 1 >= 2 false

6.<=

• 比较左边的值是否 小于或等于 右边的值
• 1 <= 2 true
• 1 <= 1 true
• 1 <= 0 false

7.>

• 比较左边的值是否 大于 右边的值
• 1 > 0 true
• 1 > 1 false
• 1 > 2 false

8.<

• 比较左边的值是否 小于 右边的值
• 1 < 2 true
• 1 < 1 false
• 1 < 0 false

逻辑运算符

1.&&

• 进行 且 的运算
• 符号左边必须为 true 并且右边也是 true，才会返回 true
• 只要有一边不是 true，那么就会返回 false
• true && true true
• true && false false
• false && true false
• false && false false

2.||

• 进行 或 的运算
• 符号的左边为 true 或者右边为 true，都会返回 true
• 只有两边都是 false 的时候才会返回 false
• true || true true
• true || false true
• false || true true
• false || false false

3.!

• 进行 取反 运算
• 本身是 true 的，会变成 false
• 本身是 false 的，会变成 true
• !true false
• !false true

自增自减运算符（一元运算符）

1.++

• 进行自增运算
• 分成两种，前置++ 和 后置++
• 前置++，会先把值自动 +1，在返回

var a = 10; 
console.log(++a);
 // 会返回 11，并且把 a 的值变成 11

• 后置++，会先把值返回，在自动+1

var a = 10;
 console.log(a++);
  // 会返回 10，然后把 a 的值变成 11

2.–

• 进行自减运算
• 分成两种，前置-- 和 后置–
• 和 ++ 运算符道理一样

分支结构

• 我们的 js 代码都是顺序执行的（从上到下）
• 逻辑分支就是根据我们设定好的条件来决定要不要执行某些代码

IF 条件分支结构

if 语句

• 通过一个 if 语句来决定代码执行与否
• 语法： if (条件) { 要执行的代码 }
• 通过 () 里面的条件是否成立来决定 {} 里面的代码是否执行

// 条件为 true 的时候执行 {} 里面的代码 
if (true) {
    
    
 alert('因为条件是 true，我会执行')
  }
// 条件为 false 的时候不执行 {} 里面的代码 
if (false) {
    
    
 alert('因为条件是 false，我不会执行') 
 }

if else 语句

• 通过 if 条件来决定，执行哪一个 {} 里面的代码
• 语法： if (条件) { 条件为 true 的时候执行 } else { 条件为 false 的时候执行 }
• 两个 {} 内的代码一定有一个会执行

// 条件为 true 的时候，会执行 if 后面的 {}
 if (true) {
    
    
  alert('因为条件是 true，我会执行') 
  } else {
    
     
  alert('因为条件是 true，我不会执行') 
  }

// 条件为 false 的时候，会执行 else 后面的 {} if (false) {
    
    
 alert('因为条件为 false，我不会执行') 
 } else {
    
     
 alert('因为条件为 false，我会执行') 
 }

if else if … 语句

• 可以通过 if 和 else if 来设置多个条件进行判断
• 语法： if (条件1) { 条件1为 true 的时候执行 } else if (条件2) { 条件2为 true 的时候执行 }
• 会从头开始依次判断条件

•  1.如果第一个条件为true了，那么就会执行后面的 {} 里面的内容
  

•   2.如果第一个条件为 false，那么就会判断第二个条件，依次类推
  

// 第一个条件为 true，第二个条件为 false，最终会打印 “我是代码段1” 
if (true) {
    
    
 alert('我是代码段1')
  } else if (false) {
    
    
   alert('我是代码段2') 
  }
// 第一个条件为 true，第二个条件为 true，最终会打印 “我是代码段1”
// 因为只要前面有一个条件满足了，就不会继续判断了
 if (true) {
    
     
  alert('我是代码段1') 
  } else if (true) {
    
    
  alert('我是代码段2') 
  }
// 第一个条件为 false，第二个条件为 true，最终会打印 “我是代码段2” 
// 只有前一个条件为 false 的时候才会继续向后判断
 if (false) {
    
    
  alert('我是代码段1') 
  } else if (true) {
    
    
  alert('我是代码段2') 
  }
// 第一个条件为 false，第二个条件为 false，最终什么也不会发生 
// 因为当所有条件都为 false 的时候，两个 {} 里面的代码都不会执行 
if (false) {
    
    
 alert('我是代码段1') 
 } else if (false) {
    
    
  alert('我是代码段2') 
  }

if else if … else 语句

• 和之前的 if else if … 基本一致，只不过是在所有条件都不满足的时候，执行最后 else 后面的 { }

// 第一个条件为 false，第二个条件为 false，最终会打印 “我是代码段3”
// 只有前面所有的条件都不满足的时候会执行 else 后面的 {} 里面的代码 
// 只要前面有一个条件满足了，那么后面的就都不会执行了
 if (false) {
    
    
    alert('我是代码段1') 
  } else if (false) {
    
    
    alert('我是代码段2') 
  } else {
    
    
    alert('我是代码段3') 
    }

SWITCH 条件分支结构

• 也是条件判断语句的一种
• 是对于某一个变量的判断
• 语法：

switch (要判断的变量) {
    
    
   case 情况1:
     情况1要执行的代码 
     break 
   case 情况2:
     情况2要执行的代码
     break
   case 情况3:
     情况3要执行的代码
     break 
   default: 上述情况都不满足的时候执行的代码 
       }

• 要判断某一个变量 等于 某一个值得时候使用

例子：根据变量给出的数字显示是星期几

var week = 1 
switch (week) {
    
    
  case 1:
    alert('星期一') 
    break
  case 2:
    alert('星期二') 
    break
  case 3:
    alert('星期三')
    break 
  case 4:
    alert('星期四')
    break
  case 5:
    alert('星期五') 
    break 
  case 6: 
    alert('星期六') 
    break 
  case 7:
    alert('星期日')
    break
  default:
    alert('请输入一个 1 ～ 7 之间的数字') 
               }

三元运算

• 三元运算，就是用 两个符号 组成一个语句
• 三元运算只是对 if else 语句的一个简写形式
• 语法： 条件 ? 条件为 true 的时候执行 : 条件为 false 的时候执行

var age = 18; 
age >= 18 ? alert('已经成年') : alert('没有成年')