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

判断NaN和无穷大

• 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