TypeScript 运算符

运算符是对值或数据进行操作的符号。它表示在处理数据时的特定操作。运算符操作的数据被称为操作数。它可以与一个或多个值一起使用以产生单个值。所有标准JavaScript运算符都可用于TypeScript程序。

示例

10 + 10 = 20;

在上面的示例中，值’10’和’20’被称为操作数，而’+’和’=’被称为运算符。

在TypeScript中的运算符

在TypeScript中，运算符可以分为以下几种：

• 算术运算符
• 比较（关系）运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 三元/条件运算符
• 拼接运算符
• 类型运算符

算术运算符

算术运算符以数字值作为操作数，执行操作，然后返回一个单一的数字值。最常见的算术运算符是加法（+），减法（-），乘法（*）和除法（/）。

+运算符：它返回两个值的相加。

let a = 20;
let b = 30;
let c = a + b;
console.log( c ); //Output 30

-运算符：它返回两个值之差。

let a = 30;
let b = 20;
let c = a - b;
console.log( c ); //Output 10

*运算符：它返回两个值的乘积。

let a = 30;
let b = 20;
let c = a * b;
console.log( c ); //Output 600

/运算符：它执行除法运算，并返回商。

let a = 100;
let b = 20;
let c = a / b;
console.log( c ); //Output 5

%运算符：它执行除法操作并返回余数。

let a = 95;
let b = 20;
let c = a % b;
console.log( c ); //Output 15

++运算符：它用于将变量的值加1。

let a = 55;
a++;
console.log( a ); //Output 56

--运算符：它用于将变量的值减1。

let a = 55;
a--;
console.log( a ); //Output 54

比较（关系）运算符

比较运算符用于比较两个操作数。这些运算符返回一个布尔值true或false。下面是重要的比较运算符。

==运算符：它检查两个操作数的值是否相等。

let a = 10;
let b = 20;
console.log(a==b);     //false
console.log(a==10);    //true
console.log(10=='10'); //true

===运算符：它检查两个操作数的类型和值是否相等。

let a = 10;
let b = 20;
console.log(a===b);    //false
console.log(a===10);   //true
console.log(10==='10'); //false

!=运算符：它检查两个操作数的值是否相等。

let a = 10;
let b = 20;
console.log(a!=b);     //true
console.log(a!=10);    //false
console.log(10!='10'); //false

!==运算符：它检查两个操作数的类型和值是否相等。

let a = 10;
let b = 20;
console.log(a!==b);     //true
console.log(a!==10);    /false
console.log(10!=='10'); //true

>运算符：它检查左操作数的值是否大于右操作数的值。

let a = 30;
let b = 20;
console.log(a>b);     //true
console.log(a>30);    //false
console.log(20> 20'); //false

>=运算符：它检查左操作数的值是否大于或等于右操作数的值。

let a = 20;
let b = 20;
console.log(a>=b);     //true
console.log(a>=30);    //false
console.log(20>='20'); //true

<运算符：它检查左操作数的值是否小于右操作数的值。

let a = 10;
let b = 20;
console.log(a<b);      //true
console.log(a<10);     //false
console.log(10<'10');  //false

<=运算符：它检查左操作数的值是否小于或等于右操作数的值。

let a = 10;
let b = 20;
console.log(a<=b);     //true
console.log(a<=10);    //true
console.log(10<='10'); //true

逻辑运算符

逻辑运算符用于将两个或多个条件组合成单个表达式，并返回布尔值结果 true 或 false。以下是逻辑运算符：

&&运算符：如果两个操作数(表达式)都为true，则返回true，否则返回false。

let a = false;
let b = true;
console.log(a&&b);      /false
console.log(b&&true);   //true
console.log(b&&10);     //10 which is also 'true'
console.log(a&&'10');  //false

||运算符：如果有一个操作数(表达式)为true，则返回true，否则返回false。

let a = false;
let b = true;
console.log(a||b);      //true
console.log(b||true);   //true
console.log(b||10);     //true
console.log(a||'10');   //'10' which is also 'true'

!运算符：它返回一个操作数(表达式)的逆结果。

let a = 20;
let b = 30;
console.log(!true);    //false
console.log(!false);   //true
console.log(!a);       //false
console.log(!b);       /false
console.log(!null);    //true

位运算符

位运算符对操作数执行位运算操作。位运算符如下：

&运算符：它返回对整数参数的每一位进行布尔与操作的结果。

let a = 2;
let b = 3;
let c = a & b;
console.log(c);   // Output 2

|运算符：它返回对整数参数的每一位进行布尔或操作的结果。

let a = 2;
let b = 3;
let c = a | b;
console.log(c);   // Output 3

^运算符：它返回对其整数参数的每一位进行布尔互斥或操作的结果。

let a = 2;
let b = 3;
let c = a ^ b;
console.log(c);   //Output 1

~运算符：它反转操作数中的每一位。

let a = 2;
let c = ~ a;
console.log(c);   //Output -3

>>运算符：左操作数的值向右移动指定的位数。

let a = 2;
let b = 3;
let c = a >> b;
console.log(c);   //Output 0

<<运算符：左操作数的值向左移动右操作数指定的位数。新的比特位在右侧填充0。

let a = 2;
let b = 3;
let c = a << b;
console.log(c);   // Output 16

>>>运算符：将左操作数的值向右移动指定的位数，并在左操作数上加上0。

let a = 3;
let b = 4;
let c = a >>> b;
console.log(c);   // Output 0

赋值运算符

赋值运算符用于给变量赋值。赋值运算符的左边被称为变量，右边被称为值。变量和值的数据类型必须相同，否则编译器会报错。以下是常见的赋值运算符。

=运算符：它从右边给左边的操作数赋值。

let a = 10;
let b = 5;
console.log("a=b:" +a);   //Output 10

+=运算符：它将左操作数和右操作数相加，并将结果赋给左边的操作数。

let a = 10;
let b = 5;
let c = a += b;
console.log(c);   //Output 15

-=运算符：它从左侧操作数减去右侧操作数，并将结果赋给左侧操作数。

let a = 10;
let b = 5;
let c = a -= b;
console.log(c);   //Output 5

*=运算符：它将左侧操作数与右侧操作数相乘，并将结果赋给左侧操作数。

let a = 10;
let b = 5;
let c = a *= b;
console.log(c);   //Output 50

/=运算符：它将左操作数和右操作数相除，并将结果赋给左边的操作数。

let a = 10;
let b = 5;
let c = a /= b;
console.log(c);   //Output 2

%=运算符：它将左操作数和右操作数相除，并将结果赋给左边的操作数。

let a = 16;
let b = 5;
let c = a %= b;
console.log(c);   //Output 1

三元/条件运算符

条件运算符接受三个操作数，并根据条件返回一个布尔值，无论它是true还是false。它的工作方式类似于if-else语句。条件运算符具有从右到左的结合性。条件运算符的语法如下所示。

expression ? expression-1 : expression-2;

• expression: 它指的是条件表达式。
• expression-1: 如果条件为真，将返回表达式-1。
• expression-2: 如果条件为假，将返回表达式-2。

示例

let num = 16;
let result = (num > 0) ? "True":"False" 
console.log(result);

输出：

True

连接运算符

连接运算符（+）是一种用于追加两个字符串的运算符。在连接操作中，我们不能在字符串之间添加空格。我们可以在单个语句中连接多个字符串。以下示例帮助我们理解TypeScript中的连接运算符。

示例

let message = "Welcome to " + "JavaTpoint";
console.log("Result of String Operator: " +message);

输出:

Result of String Operator: Welcome to JavaTpoint

类型运算符

TypeScript 中有一系列可用的运算符，可在处理对象时提供帮助。typeof、instanceof、in和delete都是类型运算符的示例。下面详细解释了这些运算符。

in运算符：它用于检查对象上的属性是否存在。

let Bike = {make: 'Honda', model: 'CLIQ', year: 2018};
console.log('make' in Bike);   // Output: true

delete运算符：它用于从对象中删除属性。

let Bike = { Company1: 'Honda',
             Company2: 'Hero',
             Company3: 'Royal Enfield'
           };
delete Bike.Company1;
console.log(Bike);   // Output: { Company2: 'Hero', Company3: 'Royal Enfield' }

typeof运算符：它返回操作数的数据类型。

let message = "Welcome to " + "JavaTpoint";
console.log(typeof message);  //Output: String

instanceof运算符：它用于检查对象是否属于指定类型。

let arr = [1, 2, 3];
console.log( arr instanceof Array ); // true
console.log( arr instanceof String ); // false