There are three types of operators that can be used in programs: Operators are special keywords or characters that either return a value or perform some action using one or more input expressions.

Unlike regular functions, operators are called without using parentheses. Operators are usually called in one of three ways:

Prefix: <operator> <expression 1>. Example: typeof A
Midfix: <expression 1> <operator> <expression 2>. Example: A + B
Postfix: <expression> <operator>. Example: A++

JavaScript operators include common mathematical functions like + and *, Boolean logic functions like && (AND) and || (OR), and other miscellaneous functions.

Note that JavaScript ES5 does not allow you to create your own operators, nor can you change the behavior of existing operators for specific objects.

Table of Contents

Mathematical Operators

Mathematical operators work on take two numbers as input and return a single number as output.

In For these examples, assume A is 3 and B is 4.

Operator	Function	Example	Description
`+`	Addition	`A + B`	Variable `A` and `B` are added. The result is 7.
`-`	Subtraction	`A - B`	Variable `B` is subtracted from `A`. The result is -1.
`*`	Multiplication	`A * B`	Variable `A` and `B` are multiplied. The result is 12.
`/`	Division	`A / B`	Variable `A` is divided by `B`. The result is 0.75.
`%`	Remainder	`A % B`	Indicates the remainder from the division of `A` with `B`. The result is 3.

...

JavaScript ES5 does not have an operator for exponentiation. Instead, use the Math.pow function. For example, Math.pow(2, 3) returns 8 (2 raised to the power of 3).

Logical Operators

Logical Operators take in Boolean values and output another Boolean value.

Operator	Function	Example	Description
`&&`	Logical AND	`A && B`	If value in variables `A` and `B` are true, the result is 1. In other cases, the result is 0.
`\|\|`	Logical OR	`A \|\| B`	If value in variables `A` or `B` are true, the result is 1. In other cases, the result is 0.
`!`	Logical NOT	`!A`	Returns the logical inverse. If A evaluates to `true`, the result is `false`. If A evaluates to `false`, the result is `true`.

Note: If the input expressions are not Boolean, they will be converted automatically coerced into a Boolean value. In JavaScript, there are only 6 values that are evaluated as evaluate to false:

false
undefined
null
Nan (Not a Number)
0
"" (empty string)

All other values are evaluated as evaluate to true.

Comparison Operators

Comparison operators compare two expressions and return true if the comparison is true, and return false otherwise.

there is an instance of A 7 in [1, 3, 5, 7]

Operator	Function	Example	Description
`<`	Less than	`A < B`	If `A` is less than `B`, the result is 1. In other cases, the result is 0.
`>`	Greater than	`A > B`	If `A` is greater than `B`, the result is 1. In other cases, the result is 0.
`<=` or `=<`	Less than or equal to	`A <= B`	If `A` is smaller less than or equal to `B`, the result is 1. In other cases, the result is 0.
`>=` or `=>`	Greater than or equal to	`A >= B`	If `A` is greater than or equal to `B`, the result is 1. In other cases, the result is 0.
`==`	Equal to	`A == B`	If `A` is equal to `B`, the result is 1. In other cases, the result is 0. Note that types are not checked, so for example `1 == "1"` evaluates to `true`. Note: the comparison operator `==` will not assign a value, unlike the assignment operator `=`.
`===`	Instance of	`A === B`	If `A` is equal to `B`, and both expressions have the same type, the result is 1. Otherwise, the result is 0. `1 === "1"` evaluates to `false`.
`!=`	Is not equal to	`A != B`	If `A` is not equal to `B`, the result is 1. In other cases, the result is 0.
`in`	In	`A in B`	If	the specified property `A` is in `B`, returns `true`, otherwise `false`. Example:	`"a" in {"a": 1, "b": 2}` returns `true`.

Assignment Operators

assignment

Operator

Function

Example

Description

=

Assignment

A = B

Stores the value in variable expression B to variable A.

Returns the value of B.

Note: the assignment operator = cannot be used to compare two values. Instead, use the comparison operator ==.

Example:

Code Block
var A = 1; // Sets A to 1 A == 2; // Returns false A = 2; // Sets A to 2 and returns 2 A == 2; // Returns true

+=

Addition

Assignment

A += 10

Stores the value A + 10 to variable A. Equivalent to A = A + 10.

Returns the value of A after incrementing.

-=

Subtraction assignmentAssignment

A -= 10

Stores the value A - 10 to A. Equivalent to A = A - 10.

Returns the value of A after decrementing.

*=

Multiplication Assignment

A *= 10

Stores the value A * 10 to A. Equivalent to A = A * 10.

Returns the value of A after multiplying.

/=

Division Assignment

A /= 10

Stores the value A / 10 to A. Equivalent to A = A / 10.

Returns the value of A after dividing.

++

Increment Operator

A++

Adds 1 to the value of the variable A and stores the value to A. Equivalent to A = A + 1.

Returns the value of A before incrementing.

--

Decrement Operator

A--

Subtracts 1 from the value of the variable A and stores the value to A. Equivalent to A = A - 1.

Returns the value of A before decrementing.

The assignment operator = can be used consecutively, as shown below:

...

In this case, the value of A and B will be set to the value of C. In other words, the value on the rightmost side of the operator will be used to set the value of the variables on the left. The example mentioned above will be processed internally in the program as shown below:

B←C

A←B

Bitwise Operators

A bitwise operator acts on the bit bitwise representation of a variable.

All Bitwise operators are performed by converting the inputs into 32-bit signed integerintegers. The 32-bit integer result will be converted back into a 64-bit floating-point number.

In the table below, the calculation result assumes that variable A is 3 (0000 0000 0000 0011), and that variable B is 4 (0000 0000 0000 0100).

The bitwise representation of a tag value may not reflect how the tag is stored on a PLC. In most cases, bitwise operations should be performed by a PLC.

Operator	Function	Example	Description
`~`	Bitwise invert	`~ A`	Each bit of `A` (0000 0000 0000 0011) is inverted. The result is (1111 1111 1111 1100).
`%`	Remainder	`A % B`	Indicates the remainder from the division of `A` with `B`. The result is 3.
`&`	Bitwise AND	`A & B`	Bitwise logical AND calculation of `A` and `B`. The result is 0.
`\|`	Bitwise OR	`A \| B`	Bitwise logical OR calculation of `A` and `B`. The result is 0111 (7).
`^`	Bitwise XOR	`A ^ B`	Bitwise logical XOR calculation of `A` and `B`. The result is 0111 (7).
`<<`	Bitwise Shift Left	`A << B`	Shifts the bits of `A` to the left by `B` bits. Fills using 0.
`>>`	Bitwise Shift Right (Signed)	`A >> B`	Shifts the bits of `A` to the right by `B` bits. Fills using a copy of the leftmost bit.
`>>>`	Bitwise Shift Right (Zero Filling)	`A >>> B`	Shifts the bits of `A` to the by `B` bits. Fills using 0.

Special Operators

There are a few operators that do not fit clearly into the above categories.

uses as the value Thus, if Comparison where each case has a value associated with it

Operator

Function

Example

Description

typeof

Check Type

typeof A

Returns a string indicating the type of the specified variable or expression. Possible return values include “string”, “number”, “boolean”, “object”, “function”, “null”, and “undefined”.

void

Void

void A

Evaluates the specified expression but

always returns undefined

. This can be used for anonymous function calls, or more generally when an expression is used to perform some action without the need for a return value.

For example:

Code Block
void function foo() { notification.send("in foo"); }();

This will execute the function foo without adding foo to the namespace.

If you try to use foo after line 3, an error will be thrown.

new

New Instance

new Date()

Used to get a new instance of a user-defined object or one of the built-in object types like Date or Array. In JavaScript ES5, this can be used to create user-defined classes without using the class keyword.

In the example below, we define a class Student using a constructor function. Then we create an instance of this the class and store it to the variable jim.

Code Block
function Student(name, id, age) { this.name = name; this.id = id; this.age = age; } var jim = new Student("Jim", 123456, 18); notification.send(JSON.stringify(jim));

new is often used with the built-in Date type to get the current day, year, etc.

Code Block
var currentTimeoldTime = new Date("Dec 31 1999"); oldTime.getFullYear(); // 1999 var yearcurrentTime = new Date(); currentTime.getFullYear(); // returns the current year

delete

Delete Property

delete object.property

Deletes a property from an object.

In the example below, we delete the firstName property from the object employee.

Code Block

var employee = {
  firstName: 'John',
  lastName: 'Doe'
};

notification.send(JSON.stringify(employee));
// {"firstName":"John","lastName":"Doe"}

delete employee.firstName;

notification.send(JSON.stringify(employee));
// {"lastName":"Doe"}

,

Comma Operator

(a, b)

The comma operator takes in two expressions, evaluates them in order, and returns the expresion on the right. In pracicepractice, this can be used to perform multiple actions at the end of a for loop.

The example below contains a for loop with two variables i and j. i increases by 1 each loop, while j decreases by 1.

Code Block
var s = ""; for (var i = 1, j = -1; i <= 3; i++, j--) { s += "i: " + String(i) + ", "; s += "j: " + String(j); s += "\n"; } notification.send(s); // i: 1, j: -1 // i: 2, j: -2 // i: 3, j: -3

?…:

Conditional Ternary

a ? b : c

Checks whether the statement a is true or false. If true, returns expression b. If false, returns expression c. This is essentially a more compact way of writing an if…else statement

.

Code Block
var isOn = tag.read("motorOn"); var s = isOn ? "Motor is on." : "Motor is off."; notification.send(s);

This is equivalent to the script below.

Code Block
var isOn = tag.read("motorOn"); if (isOn) { var s = "Motor is on."; } else { var s = "Motor is off."; } notification.send(s);

Version	Old Version 17	New Version Current
Changes made by	Scott Fredericks	Scott Fredericks
Saved on	Mar 14, 2023	Mar 21, 2023

Versions Compared

Key

Mathematical Operators

Logical Operators

Comparison Operators

Assignment Operators

Bitwise Operators

Special Operators

Page Comparison

Versions Compared

Key

Mathematical Operators

Logical Operators

Comparison Operators

Assignment Operators

Bitwise Operators

Special Operators