Using Caché ObjectScript - InterSystems Documentation

Introduction to Operators and Expressions
5.1.1.1 Unary Negative Operators
Caché ObjectScript gives the unary negative operator precedence over the binary arithmetic operators. Caché ObjectScript
first scans a numeric expression and performs any unary negative operations. Then, Caché ObjectScript evaluates the
expression and produces a result.
WRITE -123 - 3,! // returns -126
WRITE -123 + -3,! // returns -126
WRITE -(123 - 3),! // returns -120
5.1.1.2 Parentheses and Precedence
You can change the order of evaluation by nesting expressions within each other with matching parentheses. The parentheses
group the enclosed expressions (both arithmetic and relational) and control the order in which Caché ObjectScript performs
operations on the expressions. Consider the following expression:
Set TorF = ((4 + 7) > (6 + 6)) // False (0)
Write TorF
Here, because of the parentheses, four and seven are added, as are six and six; this results in the logical expression 11 >
12, which is false. Compare this to:
Set Value = (4 + 7 > 6 + 6) // 7
Write Value
In this case, precedence proceeds from left to right, so four and seven are added. Their sum, eleven, is compared to six;
since eleven is greater than six, the result of this logical operation is one (TRUE). One is then added to six, and the result
is seven.
Note that the precedence even determines the result type, since the first expression’s final operation results in a boolean
and the second expression’s final operation results in a numeric.
The following example shows multiple levels of nesting:
WRITE 1+2*3-4*5,! // returns 25
WRITE 1+(2*3)-4*5,! // returns 15
WRITE 1+(2*(3-4))*5,! // returns -5
WRITE 1+(((2*3)-4)*5),! // returns 11
Precedence from the innermost nested expression and proceeds out level by level, evaluating left to right at each level.
Tip:
For all but the simplest ObjectScript expressions, it is good practice to fully parenthesize expressions. This is to
eliminate any ambiguity about the order of evaluation and to also eliminate any future questions about the original
intention of the code.
For example, because the “&&” operator, like all operators, is subject to left-to-right precedence, the final statement in
the following code fragment evaluates to 0:
Set x = 3
Set y = 2
If x && y = 2 {
Write "True",! } Else {
Write "False",! }
This is because the evaluation occurs as follows:
1. The first action is to check if x is defined and has a non-zero value. Since x equals 3, evaluation continues.
2. Next, there is a check if y is defined and has a non-zero value. Since y equals 2, evaluation continues.
3. Next, the value of 3 && 2 is evaluated. Since neither 3 nor 2 equal 0, this expression is true and evaluates to 1.
4. The next action is to compare the returned value to 2. Since 1 does not equal 2, this evaluation returns 0.
Using Caché ObjectScript 33