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

🧩 IF ELSE IF (Predefined) EXTENDED Logic

IF-ELSE-IF logic with predefined comparison operators (equals, contains, starts with, regex, numeric). Returns first match or default value.

Examples

Equals match

INPUT

Params Table: [
{
"Input Value": "hello",
"Condition": "eq",
"Reference Value": "hello",
"Output Value": "Match 1"
},
{
"Input Value": "world",
"Condition": "eq",
"Reference Value": "world",
"Output Value": "Match 2"
}
]

Default Output: No match

OUTPUT

Match 1

No match returns default

INPUT

Params Table: [
{
"Input Value": "hello",
"Condition": "eq",
"Reference Value": "goodbye",
"Output Value": "Match 1"
},
{
"Input Value": "world",
"Condition": "eq",
"Reference Value": "earth",
"Output Value": "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.

🧩 IF ELSE IF (Predefined)

IF ELSE ⬇

Params Table

💡 Tips:
• Order matters! Conditions are checked from top to bottom
• First match wins - remaining conditions are skipped
• Use specific conditions first, general conditions last
• Combine operators: starts with (case insensitive) for flexible matching

Input ValueConditionReference ValueOutput Value

⊖

ELSE ⬇

Default Output

📤 The value to return if none of the conditions match.

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

If left empty, returns undefined.

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

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 chaining transformations or ensuring consistent output format.

Params Table table

Input ValueConditionReference ValueOutput Value

Default Output string

🔗 Result Handling — Chain Variables

ifElseIf()

Related Variables

Same category: Logic

Under the Hood

📜 View Implementation Code

/**
 * Evaluates conditions sequentially using IF ELSE IF logic.
 * Returns the value of the first matching condition, or default if none match.
 *
 * @param {Array<Object>} ls1 - Array of condition objects with values to return.
 * @param {*} def - Default value to return if no conditions match.
 *
 * @returns {*} The value of the first matching condition, or default value.
 *
 * @framework ggLowCodeGTMKit
 */
const makeNumber = require('makeNumber');

const ifElseIf = function(ls1, def) {
    const toStr = function(val) {
        if (val === null) return 'null';
        if (val === undefined) return 'undefined';
        return typeof val === 'string' ? val : val.toString();
    };

    const toLower = function(str) { return str.toLowerCase(); };

    const convertToNumber = function(value) {
        if (typeof value === 'number') return value;
        if (typeof value !== 'string') return value;
        const num = makeNumber(value);
        return (typeof num === 'number' && num === num) ? num : value;
    };

    const ruleMethods = {
        eq: function(val, ref) { return val == ref; },
        ct: function(val, ref) { return val.indexOf(ref) > -1; },
        sw: function(val, ref) { return val.substring(0, ref.length) === ref; },
        ew: function(val, ref) { return val.substring(val.length - ref.length) === ref; },
        re: function(val, ref) { return val.search(ref) !== -1; },
        xlt: function(val, ref) { return val < ref; },
        xlte: function(val, ref) { return val <= ref; }
    };

    const evaluateCondition = function(cond) {
        if (!cond) return false;

        const condKey = cond.con || '';
        if (condKey.length === 0) return false;

        const firstChar = condKey[0];
        const lastChar = condKey[condKey.length - 1];

        const isNegated = firstChar === 'n' && condKey.length > 1;
        const isInsensitive = lastChar === 'i' && condKey.length > 1;

        const baseStart = isNegated ? 1 : 0;
        const baseEnd = isInsensitive ? condKey.length - 1 : condKey.length;
        const baseCondition = condKey.substring(baseStart, baseEnd);

        const ruleFn = ruleMethods[baseCondition];
        if (!ruleFn) return false;

        var val = cond.val;
        var ref = cond.ref;

        const isNumericRule = baseCondition[0] === 'x';

        if (isNumericRule) {
            val = convertToNumber(val);
            ref = convertToNumber(ref);
        } else {
            val = toStr(val);
            ref = toStr(ref);

            if (isInsensitive) {
                val = toLower(val);
                ref = toLower(ref);
            }
        }

        const result = ruleFn(val, ref);
        return isNegated ? !result : result;
    };

    // Sequential IF-ELSE-IF evaluation
    const rules = ls1 || [];
    for (var i = 0; i < rules.length; i++) {
        var rule = rules[i];
        if (!rule) continue;

        // Support both nested {condition: {val, con, ref}, res} and flat {val, con, ref

🧪 View Test Scenarios (27 tests)

✅ '[example] Equals match'
✅ Second condition matches (first fails)
✅ '[example] No match returns default'
✅ Case insensitive equals (eqi)
✅ Contains (ct)
✅ Not contains (nct)
✅ Starts with (sw)
✅ Ends with case insensitive (ewi)
✅ Regex match (re)
✅ Numeric less than (xlt)
✅ Numeric not less than (nxlt = greater than or equal)
✅ Multiple conditions with priority (first match wins)
✅ With output function
✅ Empty rules array returns default
✅ Invalid condition (missing operator) skips to next
✅ null is stringified for string comparison
✅ undefinedis stringified for string comparison
✅ boolean true is stringified for string comparison
✅ boolean false is stringified for string comparison
✅ number becomes string for string comparison
✅ null in contains operation
✅ String 10 vs number 10 in numeric comparison (both converted)
✅ Number in string operation (toString called)
✅ Boolean in contains (true → string true)
✅ Numeric comparison with non-numeric string (stays as is)
✅ Reference value stringification (ref with boolean)
✅ Both val and ref are null