Supported JavaScript Syntax

Below is a concise, product‑safe summary of the JavaScript syntax supported in the iX Hello Customer v2 Expression Engine.

Literals:

Literals are the fixed, constant values written directly in an expression. They represent actual data, not variables or logic.

    42                             // Number    
    3.14                           // Float    
    'hello'                        // String (single quotes)    
    "hello"                        // String (double quotes)    
    `hello ${name}`                // Template literals    
    true / false                   // Boolean    
    null                           // Null    
    [1, 2, 3]                      // Array literal    
    { name: 'John', age: 30 }     // Object literal    

Operators:

Operators are symbols that tell the engine what operation to perform on values (literals or variables).

    // Arithmetic    
    a + b    a - b    a * b    a / b    a % b    a ** b    
         
    // Comparison    
    a === b    a !== b    a == b    a != b    
    a > b      a >= b     a < b    a <= b    
         
    // Logical    
    a && b    a || b    !a    a ?? b    
         
    // Ternary    
    condition ? valueIfTrue : valueIfFalse    
         
    // Member access    
    obj.property    obj['property']    arr[0]    arr[arr.length - 1]    
         
    // Safe navigation (built-in — no ?. syntax needed)    
    // Accessing a property on null/undefined returns undefined instead of throwing    
    obj.property    obj.nested.deep    arr[0]    
         
    // Spread    
    [...arr1, ...arr2]    { ...obj1, ...obj2 }    
         
    // typeof    
    typeof value === 'string'    

Arrow Functions (Concise Only)

Arrow functions are supported only in concise form and only when used as callbacks to array methods. This is an intentional design choice to keep expressions safe, readable, and side‑effect free.

// Supported: concise arrow (expression body)    
    items.filter((x) => x.active);    
    items.map((x) => x.name.toUpperCase());    
    items.reduce((sum, x) => sum + x.price, 0);    
    items.sort((a, b) => a.name.localeCompare(b.name));    
         
    // NOT supported: block-body arrow    
    items.filter((x) => {    
      return x.active;    
    }); // REJECTED    
    items.map((x) => {    
      const n = x.name;    
      return n;    
    }); // REJECTED    

Block-body arrow functions are explicitly not supported. The parser only accepts expression-body arrows. Since expressions are read-only (no variable declarations, no assignments), block bodies provide no additional capability over concise Form.

Not Supported

         
    // Assignments (expressions are read-only)    
    x = 5                          // REJECTED    
    x += 1                         // REJECTED    
    x++                            // REJECTED    
         
    // Statements    
    if (x) { ... }                // REJECTED — use ternary instead    
    for (...)                      // REJECTED — use array methods instead    
    while (...)                    // REJECTED    
    var / let / const              // REJECTED    
         
    // Block-body arrows    
    x => { return x.active }      // REJECTED — use x => x.active    
         
    // Dangerous globals    
    eval('...')                    // REJECTED    
    new Function('...')            // REJECTED    
    require('...')                 // REJECTED    
         
    // Optional chaining syntax    
    obj?.property                  // REJECTED — not needed (see below)    
    arr?.[0]                       // REJECTED    
    obj?.method()                  // REJECTED    
         
    // Prototype access    
    obj.__proto__                  // REJECTED    
    obj.constructor                // REJECTED    
    obj.prototype                  // REJECTED  

Safe Navigation (Built-in) : In standard JavaScript, trying to read a property from a null or missing value will crash your code with a TypeError. This engine handles that automatically — if any value in a chain like 'obj.nested.deep' turns out to be null or undefined, it simply returns 'undefined' instead of throwing an error. This protection applies to all property lookups by default, so there's no need to use the '?.' operator syntax here.

"If you need examples to know how these expressions are applied, please use our new and improved iX Hello Employee"