JavaScript学习笔记2

BlackWolf
153 阅读22分钟

Two

一：常见错误报警

语法错误: 所有正确的语句也将不执行；
console.log(1);
console.log(2)； //全角分号，报错
console.log(3);
console.log(4);

image-20231025035929469.png

通用错误: 中断错误之后的语句，之前正常的语句可以顺利执行
console.log(1);
console.log(2); 
console.log(3);
console.log(a); //中断
console.log(4);

image-20231025161149239.png

多个脚本块报错,但不会互相影响
<script>
    console.log(a);
</script>

<script>
    console.log(1);
</script>

<script>
    console.log(b);
</script>

image-20231025162104191.pngimage-20231025162023587.png

二： 运算符

运算符也叫操作符，是一种符号。通过运算符可以对一个或多个值进行运算，并获取运算结果。 加(+) 减(-) 乘(*) 除(/) 取余% 小括号()

代码演示：正常的数学运算,例子中包含了常规的 加减乘除()
var a = 10,
    b = 4,
    c = 5;
var d = a + (b * c);
var e = a - (d / c);  
console.log(d,e);

image-20231026164246843.png

代码演示：任何数据类型的值 + 字符串都是字符串
//数值类型(number)
var num = 12,		//数值类型(number)
    str = '11';		//字符串(string)
var a = num + str;	//数值类型与字符串相加
console.log(typeof(a), a);
//打印结果：string 1211

//布尔类型(boolean)
var bool = true,	//布尔类型(boolean)
    str = '11';		//字符串(string)
var a = bool + str;	//布尔类型与字符串相加
console.log(typeof(a), a);
//打印结果：string true11

//undefined
var str = '11';
var a = str + undefined;
console.log(typeof a, a);
//打印结果：string 11undefined

//null
var str = '11';
var a = str + null;
console.log(typeof a, a);
//打印结果：string 11null
代码演示：加号的另一种用法 字符串拼接符
//最简单的拼接
var num1 = 11,
    str1 = '11';
var b = num1 + str1;
console.log(b + '|' + str1);
//打印结果：1111|11
代码演示：+ -，将其它类型转换为 number【重要的小技巧】。
var a = true;
a = +a; // 注意这行代码的一元运算符操作
console.log(typeof a + '|' + 'a：' + a);
//打印结果：number|a：1

var a = true;
a = -a; // 注意这行代码的一元运算符操作
console.log(typeof a + '|' + 'a：' + a);
//打印结果：number|a：-1

var b = '18';
b = +b; // 注意这行代码的一元运算符操作
console.log(typeof b + '|' + 'b：' + b);
//打印结果：number|b：18
代码演示：0/0现象，引出NaN

NaN：是一个特殊的数字，表示 Not a Number，非数值。在进行数值运算时，如果得不到正常结果，就会返回 NaN。

NaN---> Not a Number ---> 中文 非数 ---> 数值类型

//现象一 0/0 0除以0
var num = 0,
    num2 = 0;
var n = num / num2;
console.log(typeof n, n);
//打印结果：number NaN

//现象二 'abc'/18 字符串除以数值
var str = 'abc',
    num = 18,
    n = str / num;
console.log(typeof n, n); 
//打印结果是：number NaN

//现象三 'abc' * 'abcd' 字符串乘以字符串
var str1 = 'abc',
    str2 = 'abcd',
    n = str1 * str2;
console.log(typeof n, n);
//打印结果是：number NaN
代码演示：1/0现象，引出Infinity

如果使用 Number 表示的变量超过了最大/小值，则会返回 Infinity/-Infinity。

Infinity/-Infinity---> 中文 正无穷/负无穷 ---> 数值类型

  • 最大值：Number.MAX_VALUE，这个值为： 1.7976931348623157e+308
  • 最小值：Number.MIN_VALUE，这个值为： 5e-324
//现象一 1/0 1除以0
var num = 1,
    num2 = 0;
var n = num / num2;
console.log(typeof n, n);
//打印结果：number Infinity

//现象二 -1/0 -1除以0
var num = -1,
    num2 = 0;
var n = num / num2;
console.log(typeof n, n);
//打印结果：number -Infinity
代码演示：%，获取余数（取余、取模）

余数是指在整数除法中，被除数不能被除数整除时，被除数中剩余的部分。例如，7 除以 3 的商是 2，余数是 1。

在 JavaScript 中，可以使用 % 运算符来获取余数。

格式：余数 = m % n;

计算结果注意：

  • 取余运算结果的正负性，取决于 m，而不是 n。比如：10 % -3的运算结果是 1。-10 % 3的运算结果是-1。

  • 如果 n < 0，那就先把 n 取绝对值后，再计算。等价于 m % (-n)。

  • 如果 n 是 0，那么结果是 NaN。

  • 在 n > 0 的情况下：

    • 如果 m>=n，那就正常取余。

    • 如果 m<n，那结果就是 m。

var num = 5,
    num2 = 2,
	n = num % num2;
console.log(n);
//打印结果：1
交换值

需求：已知 数值 5 赋值给 num1 变量，数值 9 赋值给 num2 变量。现在需要将两个变量的值交换。 解决方案：中间容器法

代码演示：

var numA = 5,
	numB = 9,
	numC;
	numC = numA;
	numA = numB;
	numB = numC;
	console.log('The value of numA is' + numA  + ',' +'The value of numB is' + numB + '.');
	//打印结果： The value of numA is 9,The value of numB is 5.
自增 自减

前置型递增 ++a 是先自增1，再参与运算，即参与运算的值是变化后的值；

后置型递增 a++ 是先参运算，再自增1，即参与运算的值是变化前的值；

递减同理。

代码演示：

  • 首先，明确一点，当变量递增或递减后，无论它在 = 前后，其值已经发生了变化；
var num1 = 42;
console.log(++num1,--num1,num1++,num1--,num1);
//打印结果：43 42 42 43 42
解释：第一个值为43，因为是前置型递增，所以由原来值为42进行加1动作，变为43；
     第二个值为42，因为是前置型递减，新值43进行减1动作，变为42；
	 第三个值为42，因为是后置型递增，由于后置型递增或递减特性，先参与计算，在进行自增或自减，所以此时结果维持不变还是42，但其值已经发生变化，将在下一次活动中发生变化；
	 第四个值为43，还是因为是后置型递减，其值已经在上一次活动中发生了变化，并在此次活动中体现出来；
	 第五个值为42，因为上一次是后置型递减，其值已经发生变化，43减1后值为42，并这次的动作只是打印该变量的值，无任何动作。所以，才显示42。
  • 在简单运算中的顺序；
var num1 = 6,
	num2 = 20,
    num3 = --num1 + num2,
    num4 = num1 + num2;
console.log(num3 + ',' + num4);
//打印结果：25,25
解释：num3的结果为25，是因为前置型递减，num1的值就是6减1得5，并立即参与加法运算，5加20得25；
	 num4的结果为25，是因为num1其值由原来的6经过递减运算得到的结果为5，并参与现在的加法运算，5加20得25。

var num1 = 6,
	num2 = 20,
    num3 = num1-- + num2,
    num4 = num1 + num2;
console.log(num3 + ',' + num4);
//打印结果：26，25
解释：num3得到的结果为26，是因为后置型递减，先参与运算，后递减本身。所以其计算方式为 num3 = 6 + 20，结果为26，但num1得值其实已经发生了变化，其值为5，需要在下一次该变量出现得位置反应出来；
	 num4得到的结果为25，如上解释，在进行加法运算，num4 = 5 + 20,结果为25。
  • 最后，在来稍微有点难度的运算实例。
var i = 0,
    j = i++ + i++;
console.log(i + ',' + j);
//打印结果：2,1
解释：后置型自增规则，先参与运算，后自增本身，第一次出现为原始值，第二次出现为原始值自增或自减，依此类推。所以计算公式为，j = 0 + 1 结果为1； i 的计算公式为，i = 0 + 1 + 1。

var i = 7,
    j = --i - i--;
console.log(i + ',' + j);
//打印结果：5,0
解释：原理如上，不废话了。

var	k = i-- + ++i;
console.log(i + ',' + j);
//打印结果：5,10
解释：原理如上，不废话了。

三：赋值运算符

赋值：将等号右侧的值赋给符号左侧的变量。

赋值运算符包括有下列

  • = 直接赋值。例如 var a = 5; 意思是，把5这个值，向a中存一份。简称：把5赋值给a。

  • += : 例如 a += 5 等价于 a = a + 5

  • -= : 例如 a -= 5 等价于 a = a - 5

  • *= : 例如 a *= 5 等价于 a = a * 5

  • /= : 例如 a /= 5 等价于 a = a / 5

  • %= : 例如 a %= 5 等价于 a = a % 5

特别注意：运算符号，一定一定一定不要在等号前空格！重要的说三遍！！！

四：比较运算

比较运算符，比较两个或两个以上值之间的关系，得到的结果是布尔值(boolean)，如果关系成立它会返回 true，如果关系不成立则返回 false。

> (大于) < (小于) >= (大于等于) <= (小于等于) == (相等) != (不相等) === (严格相等) !==(严格不相等)

代码演示：数值类型相互比较

按照数学知识进行比较；

let bool = 1 > 2;
console.log(bool);
//打印结果：false
解释：按照数学知识进行比较。
数值类型与其它类型比较

对于非数值进行比较时，会将其转换为数值类型（内部是调用Number()方法），再进行比较。

字符串类型(string)

纯数字符串 如：var str = '123'; ，转换数值类型,Number(str),值为123；

非纯数字符串 如：var str = '1a24'; var str = 'a14d2';，转换数值类型，Number(str),值为NaN；

NaN与任何类型，包括本身进行任何比较，一律为false；

空字符串 如：var str = ''; ，转换数值类型，Number(str),值为0。

var num = 12,
    str = '14',
    bool = num > str;
console.log(bool);
//打印结果：false
解释:数值与纯数字符串比较时，需先转换为数值，然后在与数值类型进行比较。所以12 > 14 ,其结果为false。

var num = 12,
    str = '1a4f',
    bool = num > str;
console.log(Number(str));
//打印结果：NaN
console.log(bool);
//打印结果：false
解释：
	1、非纯数字字符串，使用Number()方法后一律为NaN；
    2、任何数据类型与NaN进行比较，一律为false。

var num = 12,
    str = '',
    bool = num > str;
console.log(bool);
//Print result：true
Explanation：空字符串，使用Number(str),值为0。所以12 > 0,条件成立，结果为true。
布尔类型(boolean)

布尔类型，true 转换数值类型，其值为 1，false转换数值类型，其值为0。

var num = 12,
    tBool = true,
    bool = num > tBool;
console.log(bool);
//Print result:true
Explanation：布尔值true，转换数值为1。所以12 > 1,条件成立，结果为true。

var num = 12,
    fBool = false,
    bool = fBool > num;
console.log(bool);
//Print result:false
Explanation：布尔值false，转换数值为0。所以0 > 12,条件不成立，结果为false。
Undefined

Undefined ,转换数值类型，其值为0。

var num = 12,
    fBool = false,
    bool = fBool > num;
console.log(bool);
//Print result:false
Explanation：布尔值false，转换数值为0。所以0 > 12,条件不成立，结果为false。
Null

Null ,转换数值类型，其值为0。

var num = 12,
    fBool = false,
    bool = fBool > num;
console.log(bool);
//Print result:false
Explanation：布尔值false，转换数值为0。所以0 > 12,条件不成立，结果为false。
字符串类型相互比较

字符串之间比较，也就是需要比较的字符串中的字符，按照从左到右、逐个比较它们的Unicode 编码。

charCodeAt() 是 JavaScript 中的一个方法，用于返回字符串中指定索引处的 Unicode 编码。Unicode 编码是一个唯一标识字符的数字。

其中，索引从0开始。

//演示charCodeAt()方法的最基本使用
var str = '1a3f6d',
    strToUnicode_0 = str.charCodeAt(0),
    strToUnicode_1 = str.charCodeAt(1),
    strToUnicode_2 = str.charCodeAt(2),
    strToUnicode_3 = str.charCodeAt(3),
    strToUnicode_4 = str.charCodeAt(4),
    strToUnicode_5 = str.charCodeAt(5);
    console.log(
      '变量str字符串中第一位字符的Unicode编码:' +  ' ' + '1 =' + ' ' + strToUnicode_0 + '\n'
    + '变量str字符串中第二位字符的Unicode编码:' +  ' ' + 'a =' + ' ' + strToUnicode_1 + '\n'
    + '变量str字符串中第三位字符的Unicode编码:' +  ' ' + '3 =' + ' ' + strToUnicode_2 + '\n'
    + '变量str字符串中第四位字符的Unicode编码:' +  ' ' + 'f =' + ' ' + strToUnicode_3 + '\n'
    + '变量str字符串中第五位字符的Unicode编码:' +  ' ' + '6 =' + ' ' + strToUnicode_4 + '\n'
    + '变量str字符串中第六位字符的Unicode编码:' +  ' ' + 'd =' + ' ' + strToUnicode_5 + '\n'
    );
//Print result：
//变量str字符串中第一位字符的Unicode码: 1 = 49
//变量str字符串中第二位字符的Unicode码: a = 97
//变量str字符串中第三位字符的Unicode码: 3 = 51
//变量str字符串中第四位字符的Unicode码: f = 102
//变量str字符串中第五位字符的Unicode码: 6 = 54
//变量str字符串中第六位字符的Unicode码: d = 100
Explanation：返回字符串中每个字符的Unicode编码。

//演示字符串相互比较一
var str1 = '56',
    str2 = '120',
    bool = str1 > str2;
console.log(bool);
//Print result：true
Explanation：按照正常逻辑来说，56肯定是比120小，但是这段代码中的比较数据，是字符串类型，应用的规则是逐个并按照从左到右的顺序，比较每个字符的Unicode编码，所以结果位true。

//演示字符串相互比较二
var str1 = 'abc',
    str2 = 'ABC',
    bool = str1 > str2;
console.log(bool);
//Print result：false
Explanation：如上解释。
等于比较运算符

一共有四种等于方式，两两对应

== (相等) 与 != (不相等)

=== (严格相等) 与 !==(严格不相等)

代码演示：相等与不相等

== 这个符号并不严谨，会做隐式转换，将不同的数据类型，转为相同类型进行比较。

!= 就是 == 符号的值取反，等价于 !(1 == 1)。

//Number type
console.log(1 == 2); 	
//Print result:false 
Explanation：判断当前表达式是否成立，条件不成立，布尔值为false。

console.log(1 != 2);
//Print result:true
Explanation:判断当前表达式是否成立，条件成立，布尔值为true。
-----------------------------------------------------------------------------------------------------------------------------
//String type   
console.log('abc' == 'fdc');
//Print result:false 
Explanation：判断当前表达式是否成立，条件不成立，布尔值为false。

console.log('abc' != 'abc');
//Print result:true
Explanation：判断当前表达式是否成立，条件成立，布尔值为true。
-----------------------------------------------------------------------------------------------------------------------------
//Boolean type
console.log(1 == true);
//Print result:true
Explanation:判断当前表达式是否成立，条件成立，因为true转换数值 Number(true) 结果为1，则布尔值为true。

console.log(0 != false);
//Print result:false
Explanation:判断当前表达式是否成立，条件不成立，因为false转换数值 Number(false) 结果为0，则布尔值为fasle。
-----------------------------------------------------------------------------------------------------------------------------
//Number and String
console.log(5 == '5');
//Print result:true
Explanation:判断当前表达式是否成立，条件成立，因为字符串5 转换数值 Number('5') 结果为数值5，则布尔值为true。

console.log(8 != '8');
//Print result:false
Explanation:判断当前表达式是否成立，条件不成立，因为字符串5 转换数值 Number('5') 结果为数值5，则布尔值为false。
-----------------------------------------------------------------------------------------------------------------------------
//特殊情况(JavaScript陷阱)
console.log(0 == -0);
//Print result:true
Explanation:在数值类型进行比较时，只有0这个特殊的数值，不管是否正负，相等与严格相等的结果都为true。

console.log(null == 0);
//Print result:false
Explanation：因为Null类型在设计的时候，对比等于不会转换类型 Number(null)，所以结果为false。

console.log(undefined == 0);
//Print result:false
Explanation:两种情况，第一种情况是个人理解，第二种情况是在网上查找的，个人倾向与第一种情况。
			1、undefined转换数值类型 Number(undefined),结果为NaN，所以根据NaN的特性，一律为false；
			2、说是undefined是从null衍生下来的，所以为false；
            
console.log(undefined == null);
//Print result:true
Expplanation:官方手册解释
如果其中一个操作数为 null 或 undefined，另一个操作数也必须为 null 或 undefined 返回 true。否则返回 false。

console.log(NaN == NaN);
//Print result:false
NaN 类型就是个奇葩，进行比较运算，则全部为false。因为它连自身进行比较都不能相等。
代码演示：严格相等与严格不相等

=== 先进行数据类型比较，如果相同，则进入值得比较，如果还是相同，就为true，反之为false。

!== 就是 === 符号的值取反，等价于 !(1 === 1)。

console.log(1 === '1');				//Print result:false
console.log(0 === -0);				//print result:true
console.log(1 === true);			//print result:false
console.log(0 === false);			//print result:false
console.log(null === undefined);	//print result:false
Explanation:如上规则，不在重复解释。

五：if与switch判断分支语句(条件分支语句)

JavaScript提供了 if 与 switch结构，完成条件判断，即只有满足预设的条件，才会执行相应的语句。

如果是对区间进行判断，则建议用 if。如果是对几个固定的值进行判断，那么，数量少的话用 if，数量多的话用switch。

if语句的三种形式

形式一

if(condition){ //判断条件(condition)是否成立，条件成立为true，条件不成立为false。
    code block; //如:条件成立(true)，则立即执行语句(代码块 code block);条件不成立(false)，什么也不做。
}

代码演示：

let testIf = 'javascript'; 
if(testIf){
  console.log('学习'+ testIf +'使我快乐!');  
}
//Print result：学习javascript使我快乐！
Explanation：在本例中，条件表达式中的字符串是一个有效的值，且不为空，则认为布尔值为true，立即执行代码块中的内容，反之亦然。

let testIf = ''; 
if(testIf){
  console.log('学习'+ testIf +'使我快乐!');  
}
//Print result：打印为空。
Explanation：在本例中，条件表达式中的字符串为空，则认为布尔值为false，也就什么也不执行。

形式二

if(condition){			//判断条件(condition)是否成立，条件成立为true，条件不成立为false，
     code block1;		//条件(condition)为true,执行代码块1，且终止后面的代码运行，并跳出if语句。
}else{					//否则，条件(condition)为false时，则要执行大括号{}内的代码块，
    code block2;		//条件(condition)false,执行代码块2，结束if语句。
}

代码演示：

var number =prompt('请输入一个数字：');
if(number % 2 == 0){
    alert('你当前输入的数字为偶数。');
}else{
    alert('你当前输入的数字为奇数。');
}
//Print result：假设输入的数字为3，则结果为"你当前输入的数字为奇数"。
Explanation：在本例中，当前代码功能为：判断用户输入的数字是偶数还是奇数。
首先，使用prompt()函数从用户处获取一个数字，然后它使用 %(除法) 运算符计算该数字与2的余数。
如果，余数为0，则为偶数，反之为奇数，最后使用alert()函数显示相应的提示。

形式三

if(condition1){			//判断条件(condition1)是否成立，条件成立为true，条件不成立为false，
    code block1; 		//条件1(condition1)为true,则执行语句1，且终止后面的代码运行，并跳出if语句。
}else if(condition2){	//如果条件2(condition2)为true，执行大括号{}内的代码块2，否则继续检查下一个条件，
    code block2; 		//执行完毕后，且终止后面的代码运行，并跳出if语句。
}else if(condition3){	//如果条件3(condition3)为true，执行大括号{}内的代码块3，
    code block3; 		//执行完毕后，且终止后面的代码运行，并跳出if语句。
}else{					//当所有条件(condition)为false，执行大括号{}内的代码块，
    code block; 		//执行完毕，结束if语句。
}

实例说明

let score = prompt('请输入分数');
if(score >= 90 && score <= 100){
    document.write('成绩为A');
}else if(score >= 80 && score <=89){
    document.write('成绩为B');
}else if(score >=70 && score <=79){
    document.write('成绩为C');
}else if(score >=60 && score <=69){
    document.write('成绩为D');
}else if(score >=0 && score <=59){
    document.write('成绩为E');
}else{
    document.write('成绩异常');
}
//Print result：假设输入的数字为101，则结果为"成绩异常"。
Explanation：在本例中，当前代码功能为：当用户输入分数后并判断及输出成绩等级。
首先，它使用prompt()函数从用户处获取一个分数，然后它使用 比较运算符 和逻辑运算符且 && ，进行判断当前输入的分数及输出成绩等级，同时如果超出分数界限，则提示成绩异常。
switch两种形式

使用switch语句时，需要注意以下几点：

  • switch小括号里面可以是变量、常量、表达式；

  • case 后面的值可以是变量，常量，表达式；

  • case的判断逻辑是严格相等 ===,而不是相等==。

  • break,跳出整个代码块。

switch小括号中为表达式求值或变量值或常量值时：

switch(value){			//传入的值(value)
    case a:				//传入的值(value)与case a中的值进行严格相等运算，如果匹配则进入a代码块中，否则进入下一个case中比对
        a code block; 	//执行当前的代码块后，
        break;			//遇到break，即终止后面的代码运行并跳出整个switch语句。
    case b:				//case a 没有匹配成功，进入b代码块中，
        b code block;	//执行当前的代码块后，
        break;			//遇到break，即终止后面的代码运行并跳出整个switch语句。
    case c:				//case b 没有匹配成功，进入c代码块中，
        c code block;	//执行当前的代码块后，
        break;			//遇到break，即终止后面的代码运行并跳出整个switch语句。
    default:			//当所有case的值没有匹配成功，则进入默认代码块中，
        code block;		//执行默认代码块完毕后，并跳出switch语句。
}

代码演示：

var msg = 'error';
switch(msg){
    case 'notice':
        console.log('提示');
        break;
    case 'warning':
        console.log('警告');
        break;
    case 'error':
        console.log('错误');
        break;
    default:
        console.log('无异常');
        break;
}
//Print result：错误
Explanation：在本例中，字符串 `error` 赋值给msg变量，程序向下执行，进入switch判断分支语句，将msg的值与每个case中的值按照顺序进行严格相等比较，当执行到第一个case比较，不匹配，即跳过，在进入第二个case比较，发现还是不匹配，在跳过，当执行到第三个case，发现匹配，则执行这个case下的代码块中的内容后，在走到下一行，遇到break后，立即跳出整个switch语句。
如果所有case的值与msg的值都不匹配，则执行默认语句，即default块，然后跳出switch判断分支语句。

switch语句中，case为表达式时：

var testValue = value;		//获取的值，可以是多中形式下获取的值
switch(true){ 				//为了能够直接运行switch语句，直接填写true
    case A expression:		//获取的值参于A表达式中计算，得出的结果为true时，执行A代码块，否则进入下一个case,
        code block A; 		//执行当前的代码块后，
        break;				//遇到break，即终止后面的代码运行并跳出整个switch语句。
    case B expression:		//获取的值参于B表达式中计算，得出的结果为true时，执行B代码块，否则进入下一个case,
        code block;			//执行当前的代码块后，
        break;				//遇到break，即终止后面的代码运行并跳出整个switch语句。
    case C expression;		//获取的值参于C表达式中计算，得出的结果为true时，执行C代码块，否则进入下一个case,
        code block;			//执行当前的代码块后，
        break;				//遇到break，即终止后面的代码运行并跳出整个switch语句。
    default:				//当所有case中的表达式计算的结果为false，则进入默认代码块中，
        code block;			//执行默认代码块完毕后，并跳出switch语句。
}

代码演示：

let age = prompt("请输入年龄"); //假设输入18
switch(true){
    case age >= 0 && age <=12:
        console.log('当前生理年龄为儿童期');
        break;
    case age >= 13 && age <=20:
        console.log('当前生理年龄为青春期');
        break;
    case age >= 21 && age <=59:
        console.log('当前生理年龄为成年期');
        break;
    case age >= 60 && age <=100:
        console.log('当前生理年龄为老年期');
        break;
    case age >100:
        console.log('我擦，真鸡儿长寿');
        break;
    default:
        console.log('异常');
        break;   
}
//Print resule：当前生理年龄为青春期
Explanation：当前程序功能为：用户输入年龄后，判断当前的生理年龄，并通过console内置函数打印出来。
通过prompt内置函数功能(获取用户输入)，返回一个字符串，并赋值给age变量，当前age的值为18。程序进入switch判断分支语句，小括号内为true(真)，则直接进入第一个case，并执行当前运算，age的值大于或等于0且不小于等与12，不符合当前运算规则，跳出当前case并进入下一条case语句中，age值18，大于或等于13且小于或等于20，符合当前运算规则，进入下一行代码块，并打印字符串 '当前生理年龄为青春期' ，在进入下一行，遇到break，则立即跳出整个switch语句。程序运行结束。

五、逻辑运算 && 、||、 !

逻辑与运算符 && ：与（且）。两个都为真，结果才为真。特点：一假则假。

逻辑或运算符 ||：或。只要有一个是真，结果就是真。特点：特点: 一真则真。

逻辑非运算符 ! ： 非。对一个布尔值进行取反。特点: 真变假, 假变真。

逻辑运算返回的值为 布尔值。

Undefined、Null、NaN、""、''、0、false。都是假，除上述以外都是真。

代码演示：

let a = 1 && 2 && undefined && 10;
console.log(a);
//Print result：undefined
Explanation：遇到真就往后走，遇到假或走到最后就返回当前值
characteristic：两个都为真，结果才为真。特点：一假则假。
//1 && 1 返回1 真
//1 && 0 返回0 假
//0 && 1 返回0 假
//0 && 0 返回0 假
//if(... && ... && ...){...}
//if判断分支语句中，小括号内进行多个 &&(逻辑与运算) 需要 && 左右两边都为真，才会进入大括号中去执行其中得语句

let a = 0 || null || 1 || 0;
console.log(a);
//Print result：1
Explanation：遇到假就往后走，遇到真或走到最后就返回当前值
characteristic：只要有一个是真，结果就是真。特点：特点: 一真则真。
//1 || 1 返回1 真
//1 || 0 返回1 真
//0 || 1 返回1 真
//0 || 0 返回0 假
//if(... || ... || ...){...}
//if判断分支语句中，小括号内进行多个 ||(逻辑或运算) 需要 || 左右两边任意一边为真，才会进入大括号中去执行其中得语句

let a = !1;
console.log(a);
//Print result：false
Explanation：取反，!1为flase，!!1为true。
characteristic：对一个布尔值进行取反。特点: 真变假, 假变真。

六：注释

 // 行注释
 
/*
 * 推荐写法
 * 块注释
 */

/**
 * 自动增加注释 (我喜欢用这种写多行注释)
 */

/*
   不推荐写法     
*/
avatar
文章
阅读
粉丝