🧩 IF ELSE IF (Advanced) — GTM Variable Template for Logic

🧩 IF ELSE IF (Advanced) CORE Logic

Evaluates a set of conditions and returns a value based on the first matching rule.

Examples

First match wins

INPUT

Conditions: [{

condition: {
Input Value: 'hello',
Custom Function: (v, r) => v === r,
Reference: 'hello'
},
Result: 'Match 1'
},

{ condition: {
Input Value: 'world',
Custom Function: (v, r) => v === r,
Reference: 'world'
},
Result: 'Match 2'
}
]
Default Output: No match

OUTPUT

Match 1

No match returns default

INPUT

Conditions: [

{ condition: {
Input Value: 'hello',
Custom Function: (v, r) => v === r,
Reference: 'goodbye'
},
Result: 'Match 1'
},

{ condition: {
Input Value: 'world',
Custom Function: (v, r) => v === r,
Reference: 'xyz'
},
Result: 'Match 2'
}
]
Default Output: Default value

OUTPUT

Default value

GTM Configuration

This is what you'll see when you open this variable in Google Tag Manager. Hover the icons for details.

Read-only Preview

🧩 IF ELSE IF (Advanced)

IF ELSE ⬇

💡 Tips:
• Order matters! Conditions are checked from top to bottom
• First match wins - remaining conditions are skipped
• Use specific conditions first, general conditions last
• Your custom functions can contain any JavaScript logic
• Access GTM APIs like require('makeNumber') inside functions

Input ValueCustom FunctionReference ValueOutput Value

⊖

ELSE ⬇

Default Output

📤 The value to return if none of the conditions match (all custom functions return false).

This is the "ELSE" in the IF-ELSE-IF-ELSE logic.

If left empty, returns undefined.

Examples:
• Unknown
• 0
• {{Fallback Variable}}

Input Setup

Cast Function (optional)

⚙️ Optional function to transform both val and ref before passing them to your custom functions.

Applied consistently to all conditions for normalization.

Function signature: (value) => transformedValue

Examples:
• v => String(v).toLowerCase() → Convert to lowercase
• v => String(v).trim() → Remove whitespace
• v => { const makeNumber = require('makeNumber'); return makeNumber(v) || v; } → Convert to number
• v => v && v.price ? v.price : 0 → Extract object property
• v => JSON.parse(v) → Parse JSON string

💡 If not provided, values are passed to custom functions unchanged.

Result Handling

Output Function (optional)

⚙️ Optional function to transform the final output before returning it.

Applied to both matched condition outputs and the default output.

Examples:
• str => str.toUpperCase() → Convert to uppercase
• val => val + ' €' → Append currency
• val => parseInt(val) → Convert to integer
• val => val || 'N/A' → Fallback for empty values

Useful for ensuring consistent output format.

Related Variables

Same category: Logic

Under the Hood

📜 View Implementation Code

/**
 * Evaluates conditions sequentially using custom functions (IF ELSE IF logic).
 * Returns the value of the first matching condition, or default if none match.
 *
 * Direct-mode only
 * @param {Array<Object>} data.ls1 - Array of condition objects with values to return
 * @param {Object} data.ls1[].condition - Condition object for this rule
 * @param {*} data.ls1[].condition.val - Value to evaluate
 * @param {Function} data.ls1[].condition.fn - Custom function that receives (val, ref) and returns boolean
 * @param {*} data.ls1[].condition.ref - Reference value to compare against
 * @param {*} data.ls1[].res - Value to return if this condition matches
 * @param {*} data.def - Default value to return if no conditions match
 * @param {Function} [data.cast] - Optional cast function applied to both val and ref before passing to custom function
 * @param {Function} [data.out] - Optional function to transform the final result
 *
 * @returns {*} The value of the first matching condition, or default value.
 *
 * @note Custom Functions Version - Use for complex logic not covered by predefined operators
 *
 * @framework ggLowCodeGTMKit
 */
const safeFunction = fn => typeof fn === 'function' ? fn : x => x;
const castFn = safeFunction(data.cast);
const out = safeFunction(data.out);

const rules = data.ls1 || [];
const defaultValue = data.def;

const evaluateCondition = (cond) => {
    if (!cond) return false;
    
    const fn = cond.fn;
    if (typeof fn !== 'function') return false;
    
    const val = castFn(cond.val);
    const ref = castFn(cond.ref);
    
    return fn(val, ref);
};

for (let i = 0; i < rules.length; i++) {
    const rule = rules[i];
    if (!rule || !rule.condition) {
        continue;
    }
    
    if (evaluateCondition(rule.condition)) {
        return out(rule.res);
    }
}

return out(defaultValue);

🧪 View Test Scenarios (10 tests)

✅ '[example] First match wins'
✅ Second condition matches (first fails)
✅ '[example] No match returns default'
✅ Custom function with complex logic
✅ With cast function - lowercase normalization
✅ With cast function - numeric conversion
✅ Custom function with object property comparison
✅ With output function
✅ Invalid function (not a function) - skips to next
✅ Missing condition object - skips to next