# Operators

© 2017 Morgan C. Benton code4your.life

## What is an operator?

Um, no, not this kind

In programming, an operator is something that takes one or more values or expressions and returns another value.

For example, in the expression:

5 + 7

The "+" (plus sign) is the operator.

© 2017 Morgan C. Benton code4your.life

## Terminology

• operand: expression that the operator operates on
• unary operator: has only one operand
• binary operator: has two operands
• ternary operator: has three operands

© 2017 Morgan C. Benton code4your.life

## Types of Operators

• Arithmetic: for adding, subtracting, multiplying, etc.
• Assignment: for assigning a value to a symbol
• Comparison: for comparing two values
• Logical: for reaching true or false determinations

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in Javascript

``````// unary operators
+x           // unary plus; identity; converts value to numeric
+"3"   === 3 // true
+true  === 1 // true
+false === 0 // true
-x           // unary minus; negation; converts to numeric and inverts

// basic arithmetic
x - y  // subtraction
x * y  // multiplication
x / y  // division
x % y  // remainder/modulo; e.g. 5 % 2 == 1

// increment/decrement; very common but DO NOT USE
// Douglas Crockford considers them dangerous
x = 3; y = x++; // postfix; x == 4, y == 3
x = 3; y = ++x; // prefix;  x == 4, y == 4
x = 3; y = x--; // postfix; x == 2, y == 3
x = 3; y = --x; // prefix;  x == 2, y == 2

// experimental: use with CAUTION
x ** y // exponentiation; 2 ** 3 == 2 to the 3rd power
``````

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in Python

``````-x # unary minus; negation; inverts the value

# basic arithmetic
x - y  # subtraction
x * y  # multiplication
x / y  # division
x % y  # remainder/modulo; e.g. 5 % 2 == 1

x ** y # exponentiation; 2 ** 3 == 2 to the 3rd power
x // y # floor division; divides then rounds down to next
# lowest integer; 5 // 4 == 1.0, -5 // 4 = -2.0
``````

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in R

``````+x # unary plus; only works on values with a
# base type of numeric or logical; converts
# logical to numeric
> x <- TRUE
> +x
[1] 1
> x <- c(TRUE, FALSE, TRUE)
> +x
[1] 1 0 1

-x # unary minus; negation; inverts the value
# note: for logical values, converts to numeric
# BEFORE inverting: -TRUE == -1, -TRUE != 0

# basic arithmetic
x - y  # subtraction
x * y  # multiplication
x / y  # division
x %% y # remainder/modulo; e.g. 5 %% 2 == 1

x ** y  # exponentiation; 2 ** 3 == 2 to the 3rd power
x ^ y   # exponentiation; 2 ^  3 == 2 to the 3rd power
x %/% y # integer division; divides then discards part
# after decimal; 5 %/% 4 == 1
``````

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in Ruby

``````# unary operators defined ONLY for numeric types
+x # unary plus; identity; returns the value
-x # unary minus; negation; inverts the value

# basic arithmetic
x - y  # subtraction
x * y  # multiplication
x / y  # division
x % y  # remainder/modulo; e.g. 5 % 2 == 1
x ** y # exponentiation; 2 ** 3 == 2 to the 3rd power
``````

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in PHP

``````// unary operators
+\$x           // unary plus; identity; converts value to numeric
+"3"   === 3  // true
+true  === 1  // true
+false === 0  // true
-\$x           // unary minus; negation; converts to numeric and inverts
-true  === -1 // true

// basic arithmetic
\$x - \$y  // subtraction
\$x * \$y  // multiplication
\$x / \$y  // division
\$x % \$y  // remainder/modulo; e.g. 5 % 2 == 1

// increment/decrement
\$x = 3; \$y = \$x++; // postfix; \$x == 4, \$y == 3
\$x = 3; \$y = ++\$x; // prefix;  \$x == 4, \$y == 4
\$x = 3; \$y = \$x--; // postfix; \$x == 2, \$y == 3
\$x = 3; \$y = --\$x; // prefix;  \$x == 2, \$y == 2

\$x ** \$y // exponentiation; 2 ** 3 == 2 to the 3rd power
``````

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in Java

``````// Java operators ONLY work with numeric operands
int x = 5, y = 2;

// unary operators
+x           // unary plus; identity
-x           // unary minus; negation

// basic arithmetic
x - y  // subtraction
x * y  // multiplication
x / y  // division
x % y  // remainder/modulo; e.g. 5 % 2 == 1

// increment/decrement
x = 3; y = x++; // postfix; x == 4, y == 3
x = 3; y = ++x; // prefix;  x == 4, y == 4
x = 3; y = x--; // postfix; x == 2, y == 3
x = 3; y = --x; // prefix;  x == 2, y == 2
``````

© 2017 Morgan C. Benton code4your.life

## Arithmetic Operators in Go

``````// Go operators ONLY work with numeric operands
x, y := 5, 2

// unary operators
+x  // unary plus; identity
-x  // unary minus; negation

// basic arithmetic
x - y  // subtraction
x * y  // multiplication
x / y  // division
x % y  // remainder/modulo; e.g. 5 % 2 == 1

// increment/decrement
x = 3; y = x++; // postfix; x == 4, y == 3
x = 3; y = ++x; // prefix;  x == 4, y == 4
x = 3; y = x--; // postfix; x == 2, y == 3
x = 3; y = --x; // prefix;  x == 2, y == 2
``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in Javascript

``````// primarily a single "=" sign
x = 3;

// shorthand for arithmetic assignments
x += 3; // same as x = x + 3;
x -= 3; // x = x - 3;
x *= 3; // x = x * 3;
x /= 3; // x = x / 3;
x %= 3; // x = x % 3;

// experimental; use with care
x **= 3; // x = x ** 3;

// NOTE: increment/decrement can (and should) be
// written as follows
x += 1; // equivalent to ++x (but NOT x++)
x -= 1; // equivalent to --x (but NOT x--)

// You should ALWAYS opt for x+=1 instead of ++x
// even though you'll see ++ frequently, it can
// hacked``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in Python

``````# primarily a single "=" sign
x = 3

# shorthand for arithmetic assignments
x += 3  # same as x = x + 3
x -= 3  # x = x - 3
x *= 3  # x = x * 3
x /= 3  # x = x / 3
x %= 3  # x = x % 3
x **= 3 # x = x ** 3
x //= 3 # x = x // 3

# NOTE: increment/decrement can (and should) be
# written as follows
x += 1 # equivalent to ++x (but NOT x++)
x -= 1 # equivalent to --x (but NOT x--)

# You should ALWAYS opt for x+=1 instead of ++x
# even though you'll see ++ frequently, it can
# hacked``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in R

``````# R uses different assignment operators than most
# every other language

# the following statements all have the same result,
# i.e. they assign the value 5 to the variable x
> x = 5
> x <- 5
> x <<- 5  # in practice, almost never used
> 5 -> x   # in practice, almost never used
> 5 ->> x  # in practice, almost never used

# this form is MOST common for statements on their own
> x <- 5

# "=" is most commonly use when assigning parameter values
# in a function call, and does
> x <- median(y = 1:10)
> y

# if <- is used, modifies global scope
> x <- median(y <- 1:10)
> y
## [1]  1  2  3  4  5  6  7  8  9 10``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in Ruby

``````# primarily a single "=" sign
x = 3

# shorthand for arithmetic assignments
x += 3  # same as x = x + 3
x -= 3  # x = x - 3
x *= 3  # x = x * 3
x /= 3  # x = x / 3
x %= 3  # x = x % 3
x **= 3 # x = x ** 3

# operators particular to ruby
x ||= 3 # assigns 3 to x only if x is nil or false
# behaves like: x || x = 3
x &&= 3 # assigns 3 to x only if x is NOT nil or false
# behaves like: x && x = 3``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in PHP

``````// primarily a single "=" sign
\$x = 3;

// shorthand for arithmetic assignments
\$x += 3;  // same as \$x = \$x + 3;
\$x -= 3;  // \$x = \$x - 3;
\$x *= 3;  // \$x = \$x * 3;
\$x /= 3;  // \$x = \$x / 3;
\$x %= 3;  // \$x = \$x % 3;
\$x **= 3; // \$x = \$x ** 3;
``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in Java

``````// primarily a single "=" sign
x = 3;

// shorthand for arithmetic assignments
x += 3; // same as x = x + 3;
x -= 3; // x = x - 3;
x *= 3; // x = x * 3;
x /= 3; // x = x / 3;
x %= 3; // x = x % 3;
``````

© 2017 Morgan C. Benton code4your.life

## Assignment Operators in Go

``````// primarily a single "=" sign
x = 3

// Go is statically typed, so requires variable declaration, i.e.
var x int
x = 3

// := is a shorthand for declaration and assignment and is
// equivalent to the above code
// Note: this method gives the programmer less precise
// control over the actual data type of the variable
x := 3

// shorthand for arithmetic assignments
x += 3 // same as x = x + 3
x -= 3 // x = x - 3
x *= 3 // x = x * 3
x /= 3 // x = x / 3
x %= 3 // x = x % 3
``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in Javascript

``````// variables for use in the below examples
var x = 3;
var y = "3";
var z = 4;

// equality
x == y // x "equals" y; true
x != y // x "not equal to" y; false

// strict equality (checks value AND data type)
x === y // x has the same data type and value as y; false
x !== y // x has either a different value OR data type as y; true

// greater/less than
x < y  // false
x < z  // true
x <= y // true
x <= z // true
x > y  // false
x >= y // true

// there is no strict version of greater/less than
// programmers must be careful of data types``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in Python

``````# variables for use in the below examples
x = 3
y = "3"
z = 4

# equality (includes type checking)
x == y # x "equals" y; false
x != y # x "not equal to" y; true

# greater/less than
x < y  # ERROR; variables are different types
x < z  # true
x <= y # ERROR
x <= z # true
x > y  # ERROR
x > z  # false
x >= y # ERROR
x >= z # false
``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in R

``````# variables for use in the below examples
> x = 3
> y = "3"

# equality (does NOT include type checking)
> x == y # x "equals" y
[1] TRUE
> x != y # x "not equal to" y
[1] FALSE

# there is NOT an equality operator that checks both
# value AND data type like === in JavaScript

# greater/less than
> x < y
[1] FALSE
> x <= y
[1] TRUE
> x > y
[1] FALSE
> x >= y
[1] TRUE
``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in Ruby

``````# variables for use in the below examples
x = 3
y = "3"
z = 3.0

# equality: pay careful attention to data type!
x == y    # false; x is numeric, y is string
x == z    # true; x and z are both numeric
x.eql?(y) # false
x.eql?(z) # false; x is integer, z is float
x != y    # true
x != z    # false

# greater/less than
x < z  # false
x <= z # true
x > z  # false
x >= z # true

# x === y means "does y belong to set x"
(1..5) === 3 # true
(1..5) === 6 # false

# combined comparison (aka "spaceship") operator
x <=> 3 # returns  0 if operands are equal
x <=> 2 # returns  1 if first operand > second
x <=> 4 # returns -1 if second operand > first
``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in PHP

``````// variables for use in the below examples
\$x = 3;
\$y = "3";
\$z = 4;

// equality
\$x == \$y // \$x "equals" \$y; true
\$x != \$y // \$x "not equal to" \$y; false
\$x <> \$y // same as \$x != \$y

// strict equality (checks value AND data type)
\$x === \$y // \$x has the same data type and value as \$y; false
\$x !== \$y // \$x has either a different value OR data type as \$y; true

// greater/less than
\$x < \$y  // false
\$x < \$z  // true
\$x <= \$y // true
\$x <= \$z // true
\$x > \$y  // false
\$x >= \$y // true

// combined comparison (aka "spaceship") operator; as of PHP 7.0
\$x <=> 2 // returns  1 if first operand > second
\$x <=> 3 // returns  0 if operands are equal
\$x <=> 4 // returns -1 if second operand > first
``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in Java

``````// variables for use in the below examples
int x = 3;
String y = "3";
int z = 4;

// equality (checks for type)
x == y // x "equals" y; false
x != y // x "not equal to" y; true

// greater/less than
x < y  // Error: incomparable types
x < z  // true
x <= y // Error
x <= z // true
x > y  // Error
x >= y // Error
x > z  // false
x >= z // false``````

© 2017 Morgan C. Benton code4your.life

## Comparison Operators in Go

``````// variables for use in the below examples
var x int = 3
var y rune = "3"
var z int = 4
var a float32 = 3.0

// equality (checks for type)
x == y // Error: incomparable types
x == z // false
x == a // Error: incomparable types (CAUTION!)
x != y // Error
x != z // true

// greater/less than
x < y  // Error: incomparable types
x < z  // true
x <= y // Error
x <= z // true
x > y  // Error
x >= y // Error
x > z  // false
x >= z // false``````

© 2017 Morgan C. Benton code4your.life

## Logical Operators

© 2017 Morgan C. Benton code4your.life

## Logical Operators in Javascript

``````// AND
if (x && y) {
// ...
} else {
// ...
}

// OR
if (x || y) {
// ...
} else {
// ...
}

// NOT
if (!x) {
// ...
} else {
// ...
}
``````

© 2017 Morgan C. Benton code4your.life

## Logical Operators in Python

``````# AND
if x and y:
# ...
else:
# ...

# OR
if x or y:
# ...
else:
# ...

# NOT
if not x:
# ...
else:
# ...
``````

© 2017 Morgan C. Benton code4your.life

## Logical Operators in R

``````# Element-wise AND returns vector
# of comparisons between x and y
if (x & y) {
# ...
} else {
# ...
}

# Element-wise OR
if (x | y) {
# ...
} else {
# ...
}

# NOT
if (!x) {
# ...
} else {
# ...
}
``````

© 2017 Morgan C. Benton code4your.life

``````# AND returns the result of AND
# of just first element in vectors
# x and y
if (x && y) {
# ...
} else {
# ...
}

# OR
if (x || y) {
# ...
} else {
# ...
}

# NOTE: using control structures
# (like if/else) is generally
# discouraged in R in favor of
# using built-in functions``````

## Logical Operators in Ruby

``````# AND
if x and y
# ...
else
# ...
end

# OR
if x or y
# ...
else
# ...
end

# NOT
if not x
# ...
else
# ...
end``````

© 2017 Morgan C. Benton code4your.life

``````# AND
if x && y
# ...
else
# ...
end

# OR
if x || y
# ...
else
# ...
end

# NOT
if !x
# ...
else
# ...
end``````

## Logical Operators in PHP

``````// AND
if (\$x and \$y) {
// ...
} else {
// ...
}

// OR
if (\$x or \$y) {
// ...
} else {
// ...
}

// XOR
if (\$x xor \$y) {
// ...
} else {
// ...
}

``````

© 2017 Morgan C. Benton code4your.life

``````// AND
if (\$x && \$y) {
// ...
} else {
// ...
}

// OR
if (\$x || \$y) {
// ...
} else {
// ...
}

// NOT
if (!\$x) {
// ...
} else {
// ...
}
``````

## Logical Operators in Java

``````// AND
if (x && y) {
// ...
} else {
// ...
}

// OR
if (x || y) {
// ...
} else {
// ...
}

// NOT
if (!x) {
// ...
} else {
// ...
}
``````

© 2017 Morgan C. Benton code4your.life

## Logical Operators in Go

``````// AND
if (x && y) {
// ...
} else {
// ...
}

// OR
if (x || y) {
// ...
} else {
// ...
}

// NOT
if (!x) {
// ...
} else {
// ...
}
``````

© 2017 Morgan C. Benton code4your.life

## Things to Watch Out For

• Unexpected results based on types of operands
• Improper use of increment/decrement operator

© 2017 Morgan C. Benton code4your.life

## Summary

• Operators are a fundamental part of programming
• The four primary types of operators are arithmetic, assignment, comparison, and logical
• There is a lot of similarity among different programming languages; you should be careful of subtle differences if switching between languages

© 2017 Morgan C. Benton code4your.life

By Morgan Benton

# Operators

Introduction to the concept of operators in computer programming. Example code in a variety of languages is provided to demonstrate the major operator categories: arithmetic, comparison, logical, and assignment.

• 1,442