JS复习03 类型转换/流程控制语句（分支/循环）

1.6.三目运算符

JavaScript中的三目运算符用作判断时

基本语法为: expression ? sentence1 : sentence2

当expression的值为真时执行sentence1，否则执行 sentence2

var age = 19;
var result = age > 16 ? "成年人":"未成年人";
// 当age大于16岁时，条件为真，执行sentence1，其次反之

2.类型转换

2.1.* => 字符串类型

其他类型转换为String

toString()函数

​ 除了null，undefined，其他三种基本数据类型的变量均有一个toString()函数，该函数可以获取该变量指定值的字符串表示。

var a = true;
var b = 123;
console.log(a.toString(), b.toString());// 'true'  '123'
console.log(typeof a.toString(), typeof b.toString());//string string

​ 如果变量为number类型，默认情况下toString()是以十进制格式返回数值的字符串表示，通过传递参数，可以输入以二进制，八进制，十六进制乃至任意有效进制格式的字符串值

var num = 10;
console.log(num.toString());  //"10"
console.log(num.toString(2))	//"1010"
console.log(num.toString(8))	//"12"
console.log(num.toString(16))	//"a"

​ 任意其他数据与字符串相加都会转化为字符串

console.log(typeof (true + ''));  //string

2.2.* => 布尔类型

其他数据类型转换为Boolean

Boolean()包装器

Boolean('hello') //true

使用!!转换任意其他数据类型都可以转换为布尔类型。

!!'hello' //true

2.3.* => 数字类型

其他数据类型转换为Number

Number()包装器

如果转换的值是null,undefined,boolean,number

Number(true); //1
Number(false); //0
Number(null); //0
Number(undefined); //NaN
Number(10); //10 如果是数字值,原样输出

如果转换的值是string

Number("123"); //123  如果仅包含数值，转换为对应的数值
Number("234.1"); //234.1 解析为对应的小数 
Number("+12.1"); //12.1 首位为符号位，其余为为数值，转换为对应的数值 
Number("1+2.3"); // NaN 符号位出现在其他位置，解析为NaN 
Number("0xa"); //10 如果仅包含十六进制格式，转为为对应的十进制的值
Number("010"); //10【注意】不会当做八进制被解析，结果为10。 
Number(""); // 0 空字符串被转换为0 
Number("123ac"); // NaN 包含其他字符： NaN 
Number(12); //12

parseInt()函数

如果转换的值是null,undefined,boolean，均转换为NaN

如果转换的值是Number

parseInt(10); //10 如果是整数值，原样输出 parseInt(10.3); //10 如果是小数，舍去小数点一级后面的内容

如果转换的值是string

parseInt("123"); //123；如果仅包含数值，转换为对应的数值
parseInt("234.1"); //234；小数点后面的数值省略 
parseInt("+12.1"); //12； 首位为符号位，其余为为数值，转换为整数 
parseInt("1+2.7"); //1； 符号位出现在其他位置，保留符号位前面的数值 
parseInt("0xa"); //10； 如果仅包含十六进制格式，转为为对应的十进制的值
parseInt("010"); //10； 【注意】不会当做八进制被解析，结果为10
parseInt(""); //NaN；空字符串被转换为NaN
parseInt("1+2.3"); //1;如果首位为数值，依次向后解析，找到连续的数值，直到遇到第一个非数值的，将之前获取的数值转换为Number返回 parseInt("123ac"); //123;

parseFloat()函数

如果转换的值是null,undefined,boolean，均转换为NaN

如果转换的值是Number

parseFloat(10); //10 如果是整数值，原样输出 parseFloat(10.1); //10.1 如果是小数，保留小数点，但是如果是10.0结果为10

如果转换的值是string

parseFloat("123"); //123；如果仅包含数值，转换为对应的数值
parseFloat("234.1"); //234.1；保留小数点后面的数值 
parseFloat("+12.1"); //12.1； 首位为符号位，其余为为数值，转换为整数 
parseFloat("1+2.6"); //1；符号位出现在其他位置，保留符号位前的数值 
parseFloat("0xa"); //0； 【注意】不会当做十六进制来解析。
parseFloat("010"); //10； 【注意】不会当做八进制被解析，结果为10
parseFloat(""); //NaN；空字符串被转换为NaN
parseFloat("1+2.3"); //1;如果首位为数值，依次向后解析，找到连续的数值，直到遇到第一个非数值的，将之前获取的数值转换为Number返回 parseFloat("123.3ac");//123.3;

+

+"23"                    //23
+null                    //0
+undefined               //NaN

3.流程控制语句

流程控制：分支（条件）、循环

分支语句

3.1if…Else 语句

---

条件语句用于基于不同的条件来执行不同的动作。

---

条件语句

通常在写代码时，总是需要为不同的决定来执行不同的动作。可以在代码中使用条件语句来完成该任务。

在 JavaScript 中，我们可使用以下条件语句：

• if 语句 - 只有当指定条件为 true 时，使用该语句来执行代码
• if…else 语句 - 当条件为 true 时执行代码，当条件为 false 时执行其他代码
• if…else if…else 语句- 使用该语句来选择多个代码块之一来执行
• switch 语句 - 使用该语句来选择多个代码块之一来执行

if 语句

只有当指定条件为 true 时，该语句才会执行代码。

if (condition)
{
    当条件为 true 时执行的代码
}

condition表示任意表达式，该表达式求值的结果不一定是布尔类型，如果不是布尔类型，ECMAScript会调用Boolean() 转换函数将这个表达式结果转换为一个布尔类型 ，当该值为true时，执行if代码块中的内容。

if…else 语句

使用 if…else 语句在条件为 true 时执行代码，在条件为 false 时执行其他代码。

if (condition)
{
    当条件为 true 时执行的代码
}
else
{
    当条件不为 true 时执行的代码
}

当condition为true时，执行if代码块中的内容，否则，执行else代码块中的内容，一般情况下，如果代码块中代码只有一行，可以省略大括号。

if…else if…else 语句

使用 if…else if…else 语句来选择多个代码块之一来执行。

if (condition1)
{
		statement1
    当条件 1 为 true 时执行的代码
}
else if (condition2)
{
		statement2
    当条件 2 为 true 时执行的代码
}
else
{
		statement3
  	当条件 1 和 条件 2 都不为 true 时执行的代码
}

多条件分支，当condition1为true时，执行statement1,否则当condition2为true时执行statement2，当condition1,condition2都为false的时候执行statement3。

综合案列：

function exchange(num) {
  if (num && typeof num == 'number') {
    //typeof num=='number' && 0<num and num<=10
    if (num > 0 && num <= 10) {
      if (num == 1) {
        result = "壹";
      } else if (num == 2) {
        result = "贰";
      } else if (num == 3) {
        result = "叁";
      } else if (num == 4) {
        result = "肆";
      } else if (num == 5) {
        result = "伍";
      } else if (num == 6) {
        result = "陆";
      } else if (num == 7) {
        result = "柒";
      } else if (num == 8) {
        result = "捌";
      } else if (num == 9) {
        result = "玖";
      } else {
        result = "拾";
      }
    } else if(num > 10) {
      result = "请输入不大于10的数字";
    } else{
      result = "请输入不小于0的数字";
    }
  } else if (num == 0) {
    result = "零";
  } else {
    result = "请输入数字";
  }
  console.log(result);
}
exchange(0);
exchange(-120);
exchange(100);
exchange('as');
exchange();

3.2.switch 语句

---

switch 语句用于基于不同的条件来执行不同的动作。

---

使用 switch 语句来选择要执行的多个代码块之一。

switch(n)
{
    case 1:
        执行代码块 1
        break;
    case 2:
        执行代码块 2
        break;
    default:
        与 case 1 和 case 2 不同时执行的代码
}

工作原理：首先设置表达式 n（通常是一个变量）。随后表达式的值会与结构中的每个 case 的值做比较。如果存在匹配，则与该 case 关联的代码块会被执行。请使用 break 来阻止代码自动地向下一个 case 运行。

案例:

var d=new Date().getDay(); 
switch (d) 
{ 
  case 0:
    console.log('周日');
  break; 
  case 1:
    console.log('周一');
  break; 
  case 2:
    console.log('周二'); 
  break; 
  case 3:
    console.log('周三'); 
  break; 
  case 4:
    console.log('周四'); 
  break; 
  case 5:
    console.log('周五');
        
        
  break; 
  case 6:
    console.log('周六'); 
  break; 
}

default 关键词

请使用 default 关键词来规定匹配不存在时做的事情：

var d = new Date().getDay();
switch (d) {
  case 4:
    console.log('周四');
    break;
  case 5:
    console.log('周五');
    break;
  default:
    console.log('期待周末');
}

注意：

1. case代码块中break不能省略

2. default可以放到代码任意位置，break不能省略，最后位置可以省略break;

3. 变量与常量对比使用”===“

建议：

做等值比较的分支控制建议使用switch，非等值的判断建议使用If

循环语句

---

循环可以将代码块执行指定的次数。

---

如果希望一遍又一遍地运行相同的代码，并且每次的值都不同，那么使用循环是很方便的。

我们可以这样输出数组的值：

var arr = [1,2,3,4,5]
for (var i=0;i<arr.length;i++)
{ 
    console.log(i)
}

不同类型的循环

JavaScript 支持不同类型的循环：

• for - 循环代码块一定的次数
• for/in - 循环遍历对象的属性
• while - 当指定的条件为 true 时循环指定的代码块
• do/while - 同样当指定的条件为 true 时循环指定的代码块

3.3.For 循环

for 循环是您在希望创建循环时常会用到的工具。

下面是 for 循环的语法：

for (*语句 1*; *语句 2*; *语句 3*)
{
  *被执行的代码块*
}
for (var i=0; i<5; i++)
{
    console.log(i);
}

从上面的例子中，您可以看到：

Statement 1 在循环开始之前设置变量 (var i=0)。

Statement 2 定义循环运行的条件（i 必须小于 5）。

Statement 3 在每次代码块已被执行后增加一个值 (i++)。

语句 1 （代码块）开始前执行

通常我们会使用语句 1 初始化循环中所用的变量 (var i=0)。

语句 1 是可选的，也就是说不使用语句 1 也可以。

您可以在语句 1 中初始化任意（或者多个）值。

语句 2 定义运行循环（代码块）的条件

通常语句 2 用于评估初始变量的条件。

语句 2 同样是可选的。

如果语句 2 返回 true，则循环再次开始，如果返回 false，则循环将结束。

语句 3 在循环（代码块）已被执行之后执行

通常语句 3 会增加初始变量的值。

语句 3 也是可选的。

语句 3 有多种用法。增量可以是负数 (i–)，或者更大 (i=i+15)。

语句 3 也可以省略（比如当循环内部有相应的代码时）。

// 1-100偶数和
var result = 0;
for(var i=0;i<=100;i++){
  if(i%2==0){
  	result += i;
  }
} 
console.log(result);

// 冒泡排序
//1、比较相邻的两个元素，如果前一个比后一个大，则交换位置。
//2、比较完第一轮的时候，最后一个元素是最大的元素。
//3、这时候最后一个元素是最大的，所以最后一个元素就不需要参与比较大小。
function bubbleSort(arr) {
  var len = arr.length;
  //外层控制循环多少趟
  for (var i = 0; i < len-1; i++) {
    //内层控制每一趟的循环次数
    for (var j = 0; j < len - 1 - i; j++) {
         // 相邻元素两两对比，元素交换，大的元素交换到后面
        if (arr[j] > arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
  }
  return arr;
}
//举个数组
var arr = [20,18,27,19,35];
//使用函数
bubbleSort(arr)

关键字 break

如果想在所有迭代前退出，即可使用break。当执行break后，会立即跳出循环体。

关键字 continue与break不同的是，continue不会跳出循环。而是立即结束当前循环，进入下一次循环。

for(var i=0;;i++){
  console.log(i);
  if(i==5){
    break;
  }
}

增强版for循环

for…in用于遍历数组或者对象的属性

for(自定义变量名 in 数组/对象){

​ 执行代码

}

“自定义变量名”用来指定是数组的元素索引，也可以是对象的属性

//循环数组
var arr=[10,'aa',20,30,40];
for(var i=0;i<arr.length;i++){
  console.log(i+"--"+arr[i]);
}
for(var key in arr){
  console.log(key+"--"+arr[key]);
}
//循环对象属性：
var obj = {
  name:"briup",
  age:12,
  salary:10000
};
/*
两种方式访问属性：
objectName.propertyName
或者
objectName["propertyName"]
*/
console.log(obj.name);
console.log(obj["age"]);
console.log(obj.salary);
for(var key in obj){
  console.log(key+"--"+obj[key]);
}

3.4.while 循环

---

只要指定条件为 true，循环就可以一直执行代码块。

---

while 循环会在指定条件为真时循环执行代码块。

语法

while (*条件*)
{
  *需要执行的代码*
}
while (i<5)
{
    console.log(i);
    i++;
}

// 求1-100的和
var result = 0;
var i = 1;
while(i<=100){
	result += i;
	i++;
}
console.log(result);

3.5.do/while 循环

do/while 循环是 while 循环的变体。该循环会在检查条件是否为真之前执行一次代码块，然后如果条件为真的话，就会重复这个循环。

do
{
    需要执行的代码
}
while (条件);

下面的例子使用 do/while 循环。该循环至少会执行一次，即使条件为 false 它也会执行一次，因为代码块会在条件被测试前执行：

do
{
    console.log(i);
    i++;
}
while (i<5);

// 求1-100的和
var result = 0;
var i = 1;
do{
	result += i;
	i++;
} while(i<=100);
console.log(result);

3.6.递归

一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

使用递归实现阶乘

// 递归 通俗理解
// 函数自己调用自己 停不下来
// 需要有 跳出的条件
/*
    使用递归 求n的阶乘
    假设 写好了一个函数 factorial
    1 => 1
    2 => 1*2 ->factorial(1)*2
    3 => 1*2*3 ->factorial(2)*3
    4 => 1*2*3*4 ->factorial(3)*4
    ...
    n => 1*2*3...*n ->factorial(n-1)*n
*/
function factorial(n) {
  // 跳出条件
  if (n == 1) {
    return 1;
  }
  return factorial(n - 1) * n;
}
var result = factorial(4);
console.log(result);