Operator Concepts

Operators

Operators are the foundation of all programming languages. These are constructs which behave generally like functions, but which differ sytactically or semantically from usual functions. Common simple examples include arithmetic (+,-,*, etc), comparison (>, ==, etc) and logical operations (such as || or OR, etc). There are different types of operators, such as Unary, Binary and Ternary.

These are the categories:

Unary Operators
Binary Operators (Arithmetic, Comparison, Logical, Bitwise, Assignment)
Ternary Operators

Unary Operators

A Unary Operation is an operation with only one operand (only one input). x++ is equal to x+1 for example. Incrementing and Decrementing are solid examples of Unary Operators.

An Example of how Unary Operatiors work in JavaScript - Here is the given code:


							x = 5;
x++;
console.log(x); // result is 6

y = 9;
y--;
console.log(y); // result is 8

As you can see above, the operands work with only one input. There are other different types of Increment and Decrement operands such as:


							x = 10;

console.log(++x); //Prefix result is 11
console.log(x++); //Postfix result is 11

console.log(x); // result is 12

Prefix evaluates the expression before the line break, while Postfix evaluates the expression after the line break.

Unary operators are important in programming because they make operations more efficient and quicker to analyze. x+=2 is better than x = x + 2 for example.

Binary Operations

A binary operation is a calculation that combines two operands to produce a result. There are many different kinds of binary operators, such as Arithmetic, Comparison / Relational, Logical, Bitwise, Assignment.

Examples of how the different Binary Operators work in JavaScript - Here is the given code:


							//Arithmetic

var x = 8;
var z = 2;
var y;

y = x * z;

console.log(y); // result is 16

The Arithmetic operator allows two operands to be added in an arithmetic way to produce a result, these operators usually consist of the following: +,-,*,/,%. Below is an example of the Comparison / Relational Operators:


							//Comparison / Relational

var x = 3;
var y = 4;

if(x <= y){
	
	console.log("true");

}

// result is "true"

if(x != y){
	
	console.log("true");

}

// result is "true"

The Comparison / Relational operator allows for two operands to be compared to produce a result, these operators consist of the following: ==, >=, <=, <, >, !=. Below is an example of the Logical Operators:


							//Logical

var x = 8;
var y = 3;

console.log((x > 0) && (y > 0));
// result is "true"

/* Operators:

AND - &&
OR - ||
NOT - !

*/

The Logical operator allows for two operands to be compared to produce a result using Boolean (true / false) values. These operators consist of the following: &&, ||, !. Below is an example of Bitwise Operators:


							var x = 4;
var y = 10;

console.log(x | y);

// Result is (0100 | 1010 = 1110 -> 14)

/* Operators:

AND & (returns a 1 in each bit position for which the corresponding bits of both operands are 1s)
OR | (returns a 1 in each bit position for which the corresponding bits of either or both operands are 1s)
XOR ^ (returns a 1 in each bit position for which the corresponding bits of either but not both operands are 1s)
NOT ~ (inverts the bits of its operand)
Left Shift << (shifts first operand in binary representation, in 2nd operand bits to the left, shifting in 0s from the right)
Sign-Propagating Right Shift >> (shifts first operand in binary representation, in 2nd operand bits to the right, discarding bits shifted off)
Zero-fill Right Shift >>> (shifts first operand in binary representation, in 2nd operand bits to the right, discarding bits shifted off, and shifting in 0s from the left)

*/

Bitwise operators allow for two operands to be compared to produce a result using Binary values. They are mainly used in binary representations. These operators include: &, |, ^, ~, <<, >>, >>>. Below is an example of Assignment Operators:


							var x = 2;
var y = x;
var z = y;

console.log(z);

// Result is 2, assign x to 2, y to x and z to y.

An Assignment Operator assigns a value to its left operand based on the value of its right operand. These operators include the equals sign (=) and can be combined with other operators to form complex calculations.

Binary Operators are very useful in many different operations in programming. They are the backbone of functions and calculations. Usually in any program you make, you will almost always include at least one operation, even if you dont know it.

Ternary Operators

Ternary Operations take three operands. This operator is frequently used as a shortcut for the "if" statement.

An Example of how the Ternary Operator works in JavaScript - Here is the given code:


							function getPrice(isMember){
	return (isMember ? "£5.00" : "£8.00");
}

console.log(getPrice(true));

// result: "£5.00"

The "?" is the "if" statement after the first value, asking if the first value is true or not. The second value shows that £5.00 is the result if the first value is true, and to the right of that is the colon, ":" which means the opposite side (or the separator), to the right of that is the third result which outputs if the first value is false.

The Ternary Operator is usually best uesd in shortcuts where you don't need to include complex "if" statements

These are the main sections of operations, there are many more operators, including new, delete and grouping operators (brackets), find out for yourself!