Values and expressions To capabilities …

Values in programming languages are things like numbers, logical values, or text. Or more complex kinds of values made out of collections of those simpler values.
Every values has a “type” which determines what you can do with it.
Javascript supports several data types we’ll learn about: numbers, booleans (logcal values), strings (text), as well as composite types such as arrays and objects.

An expression is any part of a program that can be evaluated to produce a value.
Each expression has a "type" which is determined by the type of value it can produce which is determined in tern by the types of its sub-expressions and the operators involved.
Anywhere a value of a given type is needed we can use any expression that produces values of that type.
Operators operate on values (called the operands) to produce a new value.
Each operator works on specific types of values.
Compound expressions are made up of expressions and operators, e.g. x + 2, evaluates to a value determined by the operator and its operands.
Literal values, e.g. 10 or true or "foo" are expressions that evaluate to the value they denote.
Variables, e.g. x or Math.PI, are expressions evaluate to the current value of of the variable. (More on variables in the next standard).
Array access expressions, e.g xs[0], evaluate to the value stored at the given position in the array.
Field access expressions, e.g. foo.name or Math.PI evaluate to the value of the member variable of the given instance or class.
Function calls are expressions that evaluate to the value returned by the function. (More on functions in a later standard)

A type is a set of values (a domain) and a set of operations on them.
Some of the basic data types we will use in this course are numbers, booleans, and strings.
Numbers in Javascript are represented with what’s called a “floating point” number which is kind of like scientific notation. Limited precision but can represent both very small (close to zero) and very large (close to Infinity) values.
Logical values (true and false) are represented by the boolean data type. There are only two boolean values: written as true and false.
Strings are used to represent text.
All the other data types we will use are “reference” values where the values that are stored in variables and passed to and returned from functions are references to where the real value lives in memory.
Reference types not stored directly in variables but instead the actual value is stored somewhere in memory and what is stored in variables is a “reference” to that memory.
Many reference types (such as arrays and objects) are mutable meaning their value can be changed.
null is a special reference value that represents “no object”. It can be written as a literal value as null. It is the default value for uninitialized member variables and array elements with a reference type. A related value is undefined which is what we get when we try to use something that hasn’t been given a value or doesn’t produce a value as a value.

The primitive data types (number, boolean, and string) each have a syntax for writing literal values in Javascript programs, e.g. 1234, 9.876, true, and "foobar".

Arithmetic expressions are expressions that operate on numbers and produce numbers.
The arithmetic operators in Javascript are +, −, *, /, ‘**’, and %. (Note the ** operator is exponentiation. ^ actually is an operator in Javascript but it doesn’t do exponentiation, despite what you may be used to from Desmos or graphing calculators.)
During evaluation, operands are associated with operators according to operator precedence to determine how they are grouped. PEMDAS, basically.
There are a number of methods for doing mathematical functions on Math. Some handy ones are Math.floor, Math.abs, Math.sqrt, Math.min, and Math.max.

A boolean expression is any expression that results in a boolean value. The values used in the expression may be booleans or other kinds of values. For instance, x > 10 is a boolean expression even though x must be a number and a === b always evaluates to a boolean even though a and b could be any type of values.
There are a number of kinds of operators that produce boolean values: logical operators that operate on booleans, equality operators that operate on all kinds of values, and relational operators that operate on numeric values.

Logical operators operate on boolean values and produce a new boolean value. There are three logical operators in Java: ! (not), && (and), and || (or).
! is the highest precedence, followed by &&, followed by ||.\note{One way to remember the relative precedence is to note that if you think of booleans as a kind of numbers with false analogous to 0 and true analogous to 1, then ! is equivalent to a single negation as in -x, which flips the sign of its value, && is analogous to multiplication since true && x is x for all boolean x just like 1 * x is x for all numeric x and || is like addition since false || x is x for all boolean x, just like 0 + x is x for all numeric x.)}
When the result of a logical expression using && or || can be determined by evaluating only the first operand, the second is not evaluated. This is known as short-circuited evaluation.

Equality operators operate on two values of the same type and determine whether the two values are “the same”.
Both primitive and reference values can be compared for equality using the equality operators === and !==. (Note those operators are both three characters long. There are also operators == and != which is how those are written in most other programming languages but they were originially defined in a way that makes them very error prone so good modern style is to use the three-character versions.)
Reference values are only == when they both reference the same object or when they are both null. This may not, however, be the notion of “the same” that you care about when you are comparing two objects.

Relational operators operate on numeric values and produce a boolean value.
The relational operators are <, >, <=, and >= which evaluate to true if their left hand operand is less than, greater than, less than or equal to, or greater than or equal to the right hand operand. E.g. 10 < 20 evaluates to true. You can remeber the order of the two characters in <= and >= based on how you say them: in math ≤ is pronounced “less than or equals” and ≥ is “greater than or equals”.
You can’t chain relational operators in Javascript the way you can in math. So rather than writing 0 <= x < 10 you have to combine two relational expressions with the logical operator &&, writing instead 0 <= x && x < 10.