Jump To:

Arithmetic

Arithmetic can be used against any numeric data type. The following symbols are used:

Concatenation

Concatenation is only used on string variables to combine them. It does not perform any math.

Comparison

Comparison is used to compare the contents of two variables against each other.

Bitwise Operators

Bitwise operations are used to evaluate one or more expressions and return logical values.

AND - bitwise conjunction

As a comparison operator: Returns True only if Expression1 and Expression2 are true.

boolReturn = Expression1 AND Expression2
(y = 15) AND (x < 23) = [Boolean]

As a bitwise operator:  Compares the bits in both numeric expressions and returns a value based on the following:

Quick review of how binary values are read. Each number is a sequence of eight zeros or ones. A single zero or one is called a bit. A group of eight bits is a single byte. Within a byte, each bit is in a place-weighted position, assuming a decimal value as follows:

128| 64| 32| 16|  8|  4|  2|  1

The total value of the byte is determined by adding the value of the placeholder each bit occupies, where a bit value of 0 indicates that placeholder value is not included, and a value of 1 indicates that it is:

Byte:    10011010
Decimal: 128 + 0 + 0 + 16 + 8 + 0 + 2 + 0
or just: 128 + 16 + 8 + 2 = 154

So when using this bitwise operator, the numeric values are evaluated at the bit level using the above comparison chart to resolve each position within the byte:

(147) 10010011
( 58) 00111010
( 18) 00010010

So, with this example, 147 AND 58 = 18

OR - bitwise disjunction

As a comparison operator: Returns True if Expression1 or Expression2 are true, and if Expression1 and Expression2 are true.

boolReturn = Expression1 OR Expression2
(y = 15) OR (x < 23) = [Boolean]

As a bitwise operator:  Compares the bits in both numeric expressions and returns a value based on the following:

So when using a bitwise operator, the numeric values are evaluated at the bit level using the above comparison chart to resolve each position within the byte:

(147) 10010011
( 58) 00111010
(187) 10111011

So, with this example, 147 OR 58 = 187

XOR - bitwise exclusion

As a comparison operator: Returns True if Expression1 or Expression2 are true.

boolReturn = Expression1 XOR Expression2
(y = 15) XOR (x < 23) = [Boolean]

As a bitwise operator:  Compares the bits in both numeric expressions and returns a value based on the following:

Essentially, the numeric values are evaluated at a binary level:
(147) 10010011
(58)  00111010
(169) 10101001

So, with this example, 147 Xor 58 = 169

NOT - bitwise negation

As a comparison operator: Negates the Boolean value of Expression1

As a bitwise operator:  Compares the bits in both numeric expressions and returns a value based on the following:

Unfortunately, evaluation is not quite as straightforward as you might think.  If Not True is False, and Not bit 1 is bit 0, you would think that NOT byte 01010101 is byte 10101010 as this follows the same conversion as we've seen before - it isn't.  The key to understanding how to negate is to first discard the idea that NOT is the same thing as opposite.  To demonstrate this, look at the value outcome of a simple bitwise operation from a place-weighted perspective:

         128| 64| 32| 16|  8|  4|  2|  1
Value:                         1   1   0 = six
Negate:                        0   0   1 = one
or
Value:     0   0   0   0   0   1   1   0 = six
Negate:    1   1   1   1   1   0   0   1 = two hundred and fourth nine

Execute the following line in VBScript: WScript.Echo NOT 6 however, and you will get an answer of -7 . Similar if you execute the line WScript.Echo NOT False you will get an answer of -1. If you look back at our negation of 6, the straightforward reversal of the bits does not accurately return the negation of the number when compared against the truth of NOT 0 = -1. First thing to wonder is how do you represent a negative number in binary? There are a few accepted ways, but the one used for this method is called complementation.  For this application and overly simplified, this means that you evaluate the place-weighted position for the largest value, and then designate the next highest position as a "flag" position, where 0 indicates that the position is a positive number (but not included), and 1 a negative (and that position is included).  In our above example, the highest position that the value of six would take is the third from right.  As a positive number, we would then write the number as such:

         128| 64| 32| 16|  8|  4|  2|  1
Value:                     0   1   1   0 = six

Then using bit negation as defined within the table above, we have:

         128| 64| 32| 16|  8|  4|  2|  1
Value:                     0   1   1   0 = six        ( 0+4+2+0=  6)
Negate:                    1   0   0   1 = - seven    (-8+0+0+1= -7)

Getting further into inner workings of binary numbers is beyond the scope of this article, but there is an excellent explanation of negative binary numbers at All About Circuits

Operator Precedence

When evaluating a calculation line, the line is processed in the following operator order, and within each operator class, in the order listed.  When evaluating a line, multiple identical operators are processed from left to right.

If you need to override any given precedence, you place the single calculation element within parenthesis. 

As an example of how operator precedence works, copy/paste this code snippet into notepad, save it and run it to see how the totals differ:  Change the uncommented line to see the different calculations.

Dim dblRetVal

dblRetVal = 1 + 1 / 5
'dblRetVal = (1 + 1) / 5

WScript.Echo dblRetVal