JavaScript 之 核心语法 [ 运算符 ]

摘要：算数运算符算数运算符表示对数据值进行计算加法运算符写法加号类型的数据值，会正常进行计算类型的数据值，会先将类型转换成类型，然后在进行计算类型的数据值，无法进行计算，他会将其他类型都转换成类型，在进行字符串的拼接定义变量哦吼吼吼加法运算类

算数运算符 - 表示对数据值进行计算

加法运算符 - 写法：加号 +

number类型的数据值，会正常进行计算

boolean类型的数据值，会先将类型转换成number类型，然后在进行计算

string类型的数据值，无法进行计算，他会将其他类型都转换成string类型，在进行字符串的拼接

/* 定义变量 */
var num = 10;
var str1 = "哦吼吼吼";
var str2 = "20";
var boo = true;

/* 加法运算 */
/* number类型进行计算 */
console.log( num + 100 );// 110
/* string类型进行计算 */
console.log( str1 + 100 );// 哦吼吼吼100
console.log( str2 + 100 );// 20100
/* 会将数据类型都转换成string类型 */
console.log( typeof str1, typeof str2);// string
/* boolean类型进行计算 */
console.log( true + 100 );// 101

减法运算符 - 写法：减号 -

所有类型的运算都是与数学计算相同

所有类型在计算中遇到NaN时，结果都是NaN

/* 定义变量 */
var num = 10;
var str1 = "哦吼吼吼";
var str2 = "20";
var boo = true;
/* 减法运算 */
console.log( num - 100 );// -90
console.log( str1 - 100 );// NaN
console.log( str2 - 100 );// -80
console.log( boo - 100 );// -99

乘法运算符 - 写法：星号 *

所有类型的运算都是与数学计算相同

所有类型在计算中遇到NaN时，结果都是NaN

/* 定义变量 */
var num = 10;
var str1 = "哦吼吼吼";
var str2 = "20";
var boo = true;
/* 乘法运算 */
console.log( num * 100 );// 1000
console.log( str1 * 100 );// NaN
console.log( str2 * 100 );// 2000
console.log( boo * 100 );// 100

除法运算符 - 写法：斜杠 /

所有类型的运算都是与数学计算相同

所有类型在计算中遇到NaN时，结果都是NaN

在除法运算时，如果被除数为0，会得到无穷大（Infinity）

/* 定义变量 */
var num = 10;
var str1 = "哦吼吼吼";
var str2 = "20";
var boo = true;
/* 除法运算 */
console.log( num / 100 );// 0.1
console.log( str1 / 100 );// NaN
console.log( str2 / 100 );// 0.2
console.log( boo / 100 );// 0.01
/* 被除数是 0 时，会得到无穷大 */
console.log( 100/0 );// 无穷大 Infinity

求余运算符 - 写法：百分号 %

表示获取在除法计算后得到的余数

余数的正、负，与操作的第一个数值有关

/* 求余运算 */
console.log(100 % 3);// 1
console.log(8 % 4);// 0
/* 余数的正负 */
console.log(-100 % 3);// -1
console.log(8 % -4);// 0

自增运算符 - 写法：两个加号 ++

表示当前的变量数值加1

自增运算符可以加在变量前面（++变量），定义方式：先增加，后赋值

自增运算符也可以加在变量后面（变量++），定义方式：先赋值，后增加

/* 定义变量 */
var num = 10;
var str1 = "哦吼吼吼";
var str2 = "20";
var boo = true;
/* 自增运算 */
/* 先自增，在赋值 */
var zizeng1 = ++num;
console.log( zizeng1 );// 11
console.log( num );// 11
/* 先赋值，在自增 */
var zizeng2 = num++;
console.log( zizeng2 );// 10
console.log( num );// 11

自减运算符 - 写法：两个减号 --

表示当前的变量数值减1

自增运算符可以加在变量前面（--变量），定义方式：先自减，后赋值

自增运算符也可以加在变量后面（变量--），定义方式：先赋值，后自减

/* 定义变量 */
var num = 10;
var str1 = "哦吼吼吼";
var str2 = "20";
var boo = true;
/* 自减运算 */
/* 先自减，在赋值 */
var zijian1 = --num;
console.log( zijian1 );// 9
console.log( num );// 9
/* 先赋值，在自减 */
var zijian2 = num--;
console.log( zijian2 );// 10
console.log( num );// 9

比较运算符 - 表示可以对两个数据值进行比较

大于和小于

大于 - 用法 （ > 、>= ）

小于 - 用法 （ < 、<= ）

/* number类型 - 直接进行比较 */
console.log( 10 > 100 );// 显示 false
console.log( 10 <= 10 );// 显示 true
console.log( 10 < 100 );// 显示 true
/* boolean类型 - 先将boolean类型转换为number类型，在进行比较 */
console.log( true > false );// 显示 true
console.log( true < 0 );// false
/*
    string类型
     * 字符串中的数值是数字
      * 先将string类型转换为number类型，在进行比较
     * 字符串中的数值是字母或汉字
      * 字母或汉字 - 先将文本转换成 Unicode码，在通过 Unicode码 所对应数字值来进行比较
      * 英文单词 - 从左至右的依次比较字母 Unicode码
 */
/* 字符串中的数值是数字 */
console.log( "100" > 10 );// 显示 true
/* 字符串中的数值是字母 */
console.log("a" < "b");// true
console.log("a" > "A");// true
/* 字符串中的数值是单词 */
console.log("abc" > "cba");// false
console.log("abc" < "acd");// true

相等和不等

相等 - 用法 （ == ）

不等 - 用法 （ != ）

只比较数值，不比较类型

/* numbe类型与string类型 */
console.log( 10 == "10" );// true
/* number类型与boolean类型 */
console.log( 1 == true );// true
/* string类型与boolean类型 */
console.log( "1" != true );// false
console.log( 10 != "10" );// false

全等和不全等

全等 - 用法 （ === ）

不全等 - 用法 （ !== ）

不仅比较数值，也比较类型

/* numbe类型与string类型 */
console.log(10 === "10");// false
/* numbe类型与number类型 */
console.log(10 === 10);// true
/* numbe类型与string类型 */
console.log(10 !== "10");// true
/* numbe类型与number类型 */
console.log(10 !== 10);// false

逻辑与运算符 - 用法 （ && ）

如果两个变量数值都不是boolean值，需要先将类型转换成boolean类型，在进行计算

如果两个变量的布尔值都为false的话，结果为左边变量的值

如果两个变量的布尔值，一个是true一个是false的话，结果为false的变量值

如果两个变量的布尔值都为true的话，结果为右边变量的值

console.log( false && false );// 结果 false
console.log( true && false );// 结果 false
console.log( false && true );// 结果 false
console.log( true && true );// 结果 true

逻辑或运算符 - 用法 （ || ）

如果两个变量数值都不是boolean值，需要先将类型转换成boolean类型，在进行计算

如果两个变量的布尔值都为false的话，结果为右边变量的值

如果两个变量的布尔值，一个是true，一个是false，结果为true的变量值

如果两个变量的布尔值都为true的话，结果为左边变量的值

console.log( false || false );// 结果 false
console.log( true || false );// 结果 true
console.log( false || true );// 结果 true
console.log( true || true );// 结果 true

逻辑非运算符 - 用法 （ ! ）

表示获取数据值的相反值

console.log( !true );// 结果 false
console.log( !0 );// 结果 true
console.log( !"哦吼吼吼" );// 结果 false

语法 条件表达式 ? 为true的结果 : 为false的结果

对一个表达式进行判断

true - 表示真

false - 表示假

条件运算符可以在其中在嵌套一个条件运算符

var s1 = 10;
/* 进行条件判断 */
var n1 = s1 > 5 ? true : false;
console.log( n1 );// 结果 true
var s2 = 4;
/* 进行条件判断 */
var n2 = s2 > 5 ? true : false;
console.log( n2 );// 结果 false

/* 条件运算符的嵌套 */
var s = 3;
var n = s > 7 ? true :( s > 5 ? true : false );
console.log( n );// 结果 false

isNaN()函数 - 判断当前值是否为 NaN

true - 表示当前值是 NaN

false - 表示当前值不是 NaN

console.log( isNaN( 100 ) );// 显示结果 false
console.log( isNaN( Number( "啊哈哈" ) ) );// 显示结果 true

isFinite()函数 - 判断当前值是否为无穷大

true - 表示当前值是有限数值（不是无穷大）

false - 表示当前值是无穷大

var num = 100/0;
console.log( num );// 显示 Infinity - 无穷大
console.log( isFinite( result ) );// 显示结果 false