The expressive power of the class of functions that we can define at this point is very limited, because we have no way to make tests and to perform different operations depending on the result of a test.

For instance, we cannot declare a function that computes the absolute value of a number by testing whether the number is nonnegative and taking different actions in each case according to the rule

This construct is a case analysis and can be written in JavaScript using a conditional expression as

function abs(x) {
    return x >= 0 ? x : - x;
}

which could be expressed in English as If $x$ is greater than or equal to zero, return $x$; otherwise return $- x$. The general form of a conditional expression is

Conditional expressions begin with a $predicate$—that is, an expression whose value is either true or false, two distinguished boolean values in JavaScript. The primitive boolean expressions true and false trivially evaluate to the boolean values true and false, respectively. The $predicate$ is followed by a question mark, the $consequent$-$expression$, a colon, and finally the $alternative$-$expression$.

To evaluate a conditional expression, the interpreter starts by evaluating the $predicate$ of the expression. If the $predicate$ evaluates to true, the interpreter evaluates the $consequent$-$expression$ and returns its value as the value of the conditional. If the $predicate$ evaluates to false, it evaluates the $alternative$-$expression$ and returns its value as the value of the conditional.

The word predicate is used for operators and functions that return true or false, as well as for expressions that evaluate to true or false. The absolute-value function abs makes use of the primitive predicate >=, an operator that takes two numbers as arguments and tests whether the first number is greater than or equal to the second number, returning true or false accordingly.

If we prefer to handle the zero case separately, we can specify the function that computes the absolute value of a number by writing

In JavaScript, we express a case analysis with multiple cases by nesting conditional expressions as alternative expressions inside other conditional expressions:

function abs(x) {
    return x > 0
           ? x
           : x === 0
           ? 0
           : - x;
}

Parentheses are not needed around the alternative expression x === 0 ? 0 : - x, because the conditional-expression syntactic form is right-associative. The interpreter ignores spaces and line breaks, here inserted for readability to align the ?'s and :'s under the first predicate of the case analysis. The general form of a case analysis is

We call a predicate $p_i$ together with its consequent expression $e_i$ a clause. A case analysis can be seen as a sequence of clauses, followed by a final alternative expression. According to the evaluation of conditional expressions, a case analysis is evaluated by first evaluating the predicate $p$$_1$. If its value is false, then $p$$_2$ is evaluated. If $p$$_2$'s value is also false, then $p$$_3$ is evaluated. This process continues until a predicate is found whose value is true, in which case the interpreter returns the value of the corresponding consequent expression $e$ of the clause as the value of the case analysis. If none of the $p$'s is found to be true, the value of the case analysis is the value of the final alternative expression.

In addition to primitive predicates such as >=, >, <, <=, ===, and !== that are applied to numbers, there are logical composition operations, which enable us to construct compound predicates. The three most frequently used are these:

• $expression$$_1$ && $expression$$_2$
  This operation expresses logical conjunction, meaning roughly the same as the English word and. We assume this syntactic form to be syntactic sugar for
  $expression$$_1$ ? $expression$$_2$ : false.
• $expression$$_1$ || $expression$$_2$
  This operation expresses logical disjunction, meaning roughly the same as the English word or. We assume this syntactic form to be syntactic sugar for
  $expression$$_1$ ? true : $expression$$_2$.
• ! $expression$
  This operation expresses logical negation, meaning roughly the same as the English word not. The value of the expression is true when $expression$ evaluates to false, and false when $expression$ evaluates to true.

Notice that && and || are syntactic forms, not operators; their right-hand expression is not always evaluated. The operator !, on the other hand, follows the evaluation rule of section 1.1.3. It is a unary operator, which means that it takes only one argument, whereas the arithmetic operators and primitive predicates discussed so far are binary, taking two arguments. The operator ! precedes its argument; we call it a prefix operator. Another prefix operator is the numeric negation operator, an example of which is the expression - x in the abs functions above.

As an example of how these predicates are used, the condition that a number $x$ be in the range $5 < x < 10$ may be expressed as

x > 5 && x < 10

The syntactic form && has lower precedence than the comparison operators > and <, and the conditional-expression syntactic form $\cdots$?$\cdots$:$\cdots$ has lower precedence than any other operator we have encountered so far, a property we used in the abs functions above.

As another example, we can declare a predicate to test whether one number is greater than or equal to another as

function greater_or_equal(x, y) {
    return x > y || x === y;
}

or alternatively as

function greater_or_equal(x, y) {
    return ! (x < y);
}

The function greater_or_equal, when applied to two numbers, behaves the same as the operator >=. Unary operators have higher precedence than binary operators, which makes the parentheses in this example necessary.