Skip to content
You Don't Know GA

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

VARIABLES › LOGIC
🧩 IF ELSE IF (Advanced) CORE Logic
Direct (.tpl)

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

Examples

Section titled “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

Section titled “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.
Section titled “Related Variables”

Same category: Logic

→ isArray → isDefined → isEmpty → isEmptyString → isEqualTo → isFalsy → isFunction → isGreaterThan → isGreaterThanOrEqualTo → isInRange → isInfinity → isInteger → isJSON → isLessThan → isLessThanOrEqualTo → isNaN → isNotArray → isNotEmptyString → isNotFunction → isNotJSON → isNotNaN → isNotNull → isNotNumber → isNotObject → isNotString → isNotURL → isNull → isNumber → isObject → isPrimitive → isSHA256 → isString → isStringifiedNumber → isTruthy → isURL → isUndefined → isUnixTimestamp → isUnixTimestampMilliseconds → isUnixTimestampSeconds → isValidNumber → 🧩 AND → 🧩 IF (else) → 🧩 IF AND_OR → 🧩 IF ELSE IF (Predefined) → 🧩 NOT → 🧩 OR → 🧩 XOR

Under the Hood

Section titled “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