One crucial aspect of TypeScript is its operators, which are used to manipulate values in code. This article will cover TypeScript operators, including arithmetic, assignment, comparison, logical, and bitwise operators.<\/p>\n
Understanding TypeScript operators is essential for writing efficient and effective code. With TypeScript operators, developers can perform complex operations on data types, manipulate data, and make decisions based on certain conditions. In this way, operators are an essential part of the programming language, and learning how to use them effectively can help developers write better, more robust code. This article will explore the types of TypeScript operators and how to use them in your code.<\/p>\n
In TypeScript, arithmetic operators employ and execute mathematical operations on numeric values. In TypeScript, the following operators are available:<\/p>\n
a. Addition (+):<\/strong> Adds two numeric values together.<\/p>\n b. Subtraction (-):<\/strong> Subtracts one numeric value from another.<\/p>\n c. Multiplication (*):<\/strong> Multiplies two numeric values together.<\/p>\n d. Division (\/):<\/strong> Division of two numerical values.<\/p>\n e. Modulus (%):<\/strong> Returns the remainder after division.<\/p>\n Here is an example of using arithmetic operators in TypeScript:<\/p>\n Output<\/strong> –<\/p>\n Assignment operators are used to assigning values to variables in TypeScript. The following operators are available in TypeScript:<\/p>\n a. Assignment (=):<\/strong> Assigns a value to a variable.<\/p>\n b. Addition assignment (+=):<\/strong> Adds a value to a variable and assigns the result to the same variable.<\/p>\n c. Subtraction assignment (-=):<\/strong> Subtracts a value from a variable and assigns the result to the same variable.<\/p>\n d. Multiplication assignment (*=):<\/strong> Multiplies a variable by a value and assigns the result to the same variable.<\/p>\n e. Division assignment (\/=):<\/strong> Divides a variable by a value and assigns the result to the same variable.<\/p>\n f. Modulus assignment (%=):<\/strong> Performs modulus operation on a variable and a value and assigns the result to the same variable.<\/p>\n Here is an example of using assignment operators in TypeScript:<\/p>\n Output<\/strong> –<\/p>\n Comparison operators are used to comparing two values in TypeScript. The following operators are available in TypeScript:<\/p>\n a. Equal to (==):<\/strong> Compares two values for equality, but does not compare the data types of the values.<\/p>\n b. Not equal to (!=):<\/strong> Compares two values for inequality, but does not compare the data types of the values.<\/p>\n c. Strict equal to (===):<\/strong> Compares two values for equality, and compares the data types of the values.<\/p>\n d. Strict not equal to (!==):<\/strong> Compares two values for inequality and compares the data types of the values.<\/p>\n e. Greater than (>):<\/strong> Determines whether one value exceeds another.<\/p>\n f. Less than (<):<\/strong> Checks if one value is less than another.<\/p>\n g. Greater than or equal to (>=):<\/strong> Check if one value is greater than or equal to another.<\/p>\n h. Less than or equal to (<=):<\/strong> Checks if one value is less than or equal to another.<\/p>\n Here is an example of using comparison operators in TypeScript:<\/p>\n Output –<\/strong><\/p>\n Logical operators are used to performing logical operations on Boolean values in TypeScript. The following operators are available in TypeScript:<\/p>\n a. Logical AND (&&):<\/strong> Returns true if both operands are true.<\/p>\n b. Logical OR (||):<\/strong> Returns true if either operand is true.<\/p>\n c. Logical NOT (!):<\/strong> Returns the opposite of the Boolean value.<\/p>\n Here is an example of using logical operators in TypeScript:<\/p>\n Output –<\/strong><\/p>\n Bitwise operators are used to performing bitwise operations on numeric values in TypeScript. The following operators are available in TypeScript:<\/p>\n a. Bitwise AND (&):<\/strong> Performs a bitwise AND operation on two values.<\/p>\n b. Bitwise OR (|):<\/strong> Performs a bitwise OR operation on two values.<\/p>\n c. Bitwise XOR (^):<\/strong> Performs a bitwise XOR operation on two values.<\/p>\n d. Bitwise NOT (~):<\/strong> Performs a bitwise NOT operation on a value.<\/p>\n e. Left shift (<<):<\/strong> Shifts the bits of a value to the left by a specified number of positions.<\/p>\n f. Signed right shift (>>):<\/strong> Shifts the bits of a value to the right by a specified number of positions, preserving the sign of the value.<\/p>\n g. Unsigned right shift (>>>):<\/strong> Shifts the bits of a value to the right by a specified number of positions but always fills the empty bits with zeros.<\/p>\n Here is an example of using bitwise operators in TypeScript:<\/p>\n Output<\/strong> –<\/p>\n In TypeScript, several miscellaneous operators need to fit into a specific category. These operators are generally used for particular purposes and may not be as commonly used as others.<\/p>\n One such operator is the conditional operator<\/strong> (also known as the ternary operator), which is used to evaluate a condition and return one value if the condition is true, and another value if the state is false. The syntax for the conditional operator is condition ? valueIfTrue : valueIfFalse.<\/p>\n Another miscellaneous operator is the comma operator<\/strong>, which allows multiple expressions to be evaluated in a single statement. The comma operator evaluates each expression in order, from left to right, and returns the value of the last expression. This operator is primarily used for its side effects, such as updating multiple variables or executing numerous functions in a single line of code.<\/p>\n The void operator<\/strong> is also considered a miscellaneous operator in TypeScript. This operator evaluates an expression and returns undefined. It is often used to indicate that a function does not explicitly return a value or prevent the browser from following a link when used with an HTML anchor tag.<\/p>\n While these operators may not be as commonly used as others in TypeScript, they can be helpful in certain situations. They can help improve the readability and efficiency of your code. Understanding how these operators work and when to use them appropriately is essential.<\/p>\n In TypeScript, the concatenation operator is represented by the plus sign (+) and combines two or more strings or values into a single string. When the plus sign combines two values, TypeScript automatically converts non-string values to strings before concatenating them.<\/p>\n For example, if we have two strings, “Hello” and “World,” we can concatenate them using the plus sign as follows:<\/p>\n Output –<\/strong><\/p>\n TypeScript also has a type operator called the typeof operator, which is used to get the type of a variable or expression at compile time. The typeof operator returns a string that represents the data type of the operand.<\/p>\n For example, if we have a variable DataFlair_x of type number, we can use the typeof operator to get its type as follows:<\/p>\n Output<\/strong> –<\/p>\n The typeof operator can also be used with expressions, functions, and classes to get their types. This is useful when you need to check the type of a variable or parameter at runtime.<\/p>\n The string operator is represented by the plus sign (+) and is used to concatenate strings or string-like objects together. The string operator can also be used to convert non-string values to strings.<\/p>\n For example, if we have two strings “Hello” and “World”, we can concatenate them using the plus sign as follows:<\/p>\n Output<\/strong> –<\/p>\n The string operator can also be used to convert other data types to strings. For example:<\/p>\n Output<\/strong>–<\/p>\n In this example, the number 42 is implicitly converted to a string using the string operator.<\/p>\n It’s worth noting that there is also a template literal syntax in TypeScript which uses backticks (`) instead of quotes to define a string. Template literals can contain placeholders which are surrounded by ${} and can contain expressions. Template literals are also used for multiline strings. Here’s an example:<\/p>\n Output<\/strong> –<\/p>\n Template literals are often preferred over the string operator when building complex or multiline strings because they are easier to read and maintain.<\/p>\n In TypeScript, operators can be classified into three categories based on the number of operands they take: unary, binary, and ternary operators.<\/p>\n Unary operators are operators that take a single operand. Some examples of unary operators in TypeScript are the negation operator (-), the logical not operator (!), and the typeof operator.<\/p>\n Binary operators are operators that take two operands. Some examples of binary operators in TypeScript are the addition operator (+), the subtraction operator (-), the multiplication operator (*), and the logical and operator (&&).<\/p>\n The ternary operator is the only operator in TypeScript that takes three operands. It is represented by the ? and : symbols and is used as a shorthand for if-else statements.<\/p>\n In conclusion, TypeScript operators are a key component of the language and enable developers to manipulate values in code. The different types of operators available in TypeScript include arithmetic, assignment, comparison, logical, and bitwise operators. This allows developers to perform a wide range of operations in their code. Developers need to understand the syntax and functionality of these operators to write efficient and effective code.<\/p>\n","protected":false},"excerpt":{"rendered":" One crucial aspect of TypeScript is its operators, which are used to manipulate values in code. This article will cover TypeScript operators, including arithmetic, assignment, comparison, logical, and bitwise operators. Understanding TypeScript operators is...<\/p>\n","protected":false},"author":581,"featured_media":112966,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[27319],"tags":[27344],"class_list":["post-112684","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-typescript-tutorials","tag-operators-in-typescript"],"yoast_head":"\nlet DataFlair_x = 10;\r\nlet DataFlair_y = 5;\r\nconsole.log(DataFlair_x + DataFlair_y);\r\nconsole.log(DataFlair_x - DataFlair_y);\r\nconsole.log(DataFlair_x * DataFlair_y);\r\nconsole.log(DataFlair_x \/ DataFlair_y);\r\nconsole.log(DataFlair_x % DataFlair_y);\r\n<\/pre>\n
\n5
\n50
\n2
\n0<\/div>\n2. Assignment Operators<\/h4>\n
let DataFlair_x = 10;\r\nDataFlair_x += 5;\r\nconsole.log(DataFlair_x);\r\n\r\n\r\nlet DataFlair_y = 10;\r\nDataFlair_y -= 5;\r\nconsole.log(DataFlair_y);\r\n\r\n\r\nlet DataFlair_z = 10;\r\nDataFlair_z *= 5;\r\nconsole.log(DataFlair_z);\r\n\r\n\r\nlet DataFlair_a = 10;\r\nDataFlair_a \/= 5;\r\nconsole.log(DataFlair_a);\r\n\r\n\r\nlet DataFlair_b = 10;\r\nDataFlair_b %= 5;\r\nconsole.log(DataFlair_b);\r\n<\/pre>\n
\n5
\n50
\n2
\n0<\/div>\n3. Comparison Operators in TypeScript<\/h4>\n
let DataFlair_x = 10;\r\nlet DataFlair_y = 10;\r\nlet DataFlair_z = '10';\r\n\r\n\r\nconsole.log(DataFlair_x == DataFlair_y);\r\nconsole.log(DataFlair_x != DataFlair_y);\r\nconsole.log(DataFlair_x === DataFlair_y);\r\nconsole.log(DataFlair_x !== DataFlair_y);\r\n\r\n\r\nconsole.log(DataFlair_x > DataFlair_y);\r\nconsole.log(DataFlair_x < DataFlair_y);\r\nconsole.log(DataFlair_x >= DataFlair_y);\r\nconsole.log(DataFlair_x <= DataFlair_y);\r\n\r\n\r\nconsole.log(DataFlair_x == DataFlair_z);\r\nconsole.log(DataFlair_x === DataFlair_z);\r\n<\/pre>\n
\nfalse
\ntrue
\nfalse
\nfalse
\nfalse
\ntrue
\ntrue
\ntrue
\nfalse<\/div>\n4. Logical Operators in TypeScript<\/h4>\n
let DataFlair_x = true;\r\nlet DataFlair_y = false;\r\n\r\n\r\nconsole.log(DataFlair_x && DataFlair_y);\r\nconsole.log(DataFlair_x || DataFlair_y);\r\nconsole.log(!DataFlair_x);\r\nconsole.log(!DataFlair_y);\r\n<\/pre>\n
\ntrue
\nfalse
\ntrue<\/div>\n5. TypeScript Bitwise Operators<\/h3>\n
let DataFlair_x = 5;\r\nlet DataFlair_y = 3;\r\n\r\n\r\nconsole.log(DataFlair_x & DataFlair_y);\r\nconsole.log(DataFlair_x | DataFlair_y);\r\nconsole.log(DataFlair_x ^ DataFlair_y);\r\nconsole.log(~DataFlair_x);\r\nconsole.log(DataFlair_x << 1);\r\nconsole.log(DataFlair_x >> 1);\r\nconsole.log(DataFlair_x >>> 1);\r\n<\/pre>\n
\n7
\n6
\n-6
\n10
\n2
\n2<\/div>\nMisc Operators in TypeScript<\/h4>\n
Concatenation Operator<\/h4>\n
let DataFlair_greeting: string = 'Hello';\r\nlet DataFlair_name: string = 'World';\r\nlet message: string = DataFlair_greeting + ' ' + name;\r\nconsole.log(message); \/\/ outputs \"Hello World\"\r\n<\/pre>\n
Type Operator in TypeScript<\/h4>\n
let DataFlair_x: number = 10;\r\nconsole.log(typeof DataFlair_x);\r\n<\/pre>\n
String Operator in TypeScript<\/h4>\n
let DataFlair_greeting: string = 'Hello';\r\nlet DataFlair_name: string = 'World';\r\nlet message: string = DataFlair_greeting + ' ' + DataFlair_name;\r\nconsole.log(message); \/\/ outputs \"Hello World\"\r\n<\/pre>\n
let DataFlair_num: number = 42;\r\nlet str: string = 'The answer is ' + DataFlair_num;\r\nconsole.log(str); \/\/ outputs \"The answer is 42\"\r\n<\/pre>\n
let DataFlair_name: string = 'John';\r\nlet age: number = 30;\r\nlet str: string = `My name is ${DataFlair_name} and I am ${age} years old.`;\r\nconsole.log(str); \/\/ outputs \"My name is John and I am 30 years old.\"\r\n<\/pre>\nTypes of Operator in TypeScript:<\/h3>\n
1. Unary Operator<\/h4>\n
let DataFlair_x: number = -10;\r\nlet DataFlair_y: boolean = !true;\r\nlet DataFlair_z: string = typeof 'hello';\r\n<\/pre>\n
2. Binary Operator<\/h4>\n
let DataFlair_a: number = 5 + 3;\r\nlet DataFlair_b: number = 10 - 5;\r\nlet DataFlair_c: number = 3 * 4;\r\nlet DataFlair_d: boolean = true && false;\r\n<\/pre>\n
3. Ternary Operator<\/h4>\n
let DataFlair_age: number = 25;\r\nlet DataFlair_message: string = DataFlair_age >= 18 ? 'You are an adult' : 'You are not an adult';\r\n<\/pre>\n
Conclusion<\/h3>\n