🧩 WEIGHTED (Predefined) — GTM Variable Template for Number

🧩 WEIGHTED (Predefined) EXTENDED Number

Each condition contributes a score when its rule evaluates to true. The final result is true if the total score meets or exceeds the threshold.

When to Use This

Number Operations

Arithmetic, rounding, clamping, and mathematical transformations on numeric values.

GA4 Ecommerce

Build and transform ecommerce data structures for GA4 event tracking.

Examples

Single condition score

INPUT

Conditions: [
{
"Input Value": "hello",
"Condition": "eq",
"Reference Value": "hello",
"Points": "10"
}
]

Threshold Score: undefined

OUTPUT

Below threshold returns 0

INPUT

Conditions: [
{
"Input Value": "hello",
"Condition": "eq",
"Reference Value": "goodbye",
"Points": "10"
},
{
"Input Value": "world",
"Condition": "eq",
"Reference Value": "world",
"Points": "5"
}
]
Threshold Score: 10

OUTPUT

false

Live Sandbox

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

🧩 WEIGHTED (Predefined)

SUM OUT ⬇

Input ValueConditionReference ValuePoints

⊖

Threshold Settings

Define Threshold Score

Enable to return true/false based on whether the total score meets the threshold. If disabled, returns the raw total score as a number.

Threshold Score

Minimum total score required to return true. If total score is below this value, returns false.

Example:
• Threshold: 50
• Total Score: 65 → Returns true
• Total Score: 30 → Returns false

Result Handling

Output Function (optional)

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

Applied to the boolean (if threshold set) or numeric score (if no threshold).

Examples:
• score => score * 2 → Double the score
• bool => bool ? 'Pass' : 'Fail' → Convert to text
• val => Math.round(val) → Round score

table

Input ValueConditionReference ValuePoints

Threshold Score (Optional) string

🔗 Result Handling — Chain Variables

weighted()

Under the Hood

📜 View Implementation Code

/**
 * Evaluates conditions using weighted point scoring system with predefined operators.
 * Each condition has a point value, returns true if total score meets threshold.
 *
 * @param {Array<Object>} ls1 - List of condition objects with points.
 * @param {number} thr - Minimum score required to return true.
 * @param {boolean} eth - Whether threshold is enabled.
 *
 * @returns {boolean|number} True/false if threshold provided, or total score if no threshold.
 *
 * @framework ggLowCodeGTMKit
 */
const makeNumber = require('makeNumber');

const weighted = function(ls1, thr, eth) {
    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;
    };

    // Weighted scoring evaluation
    const conditions = ls1 || [];
    const threshold = makeNumber(thr);
    var totalScore = 0;

    for (var i = 0; i < conditions.l

🧪 View Test Scenarios (28 tests)

✅ '[example] Single condition score'
✅ With threshold - score meets threshold
✅ '[example] Below threshold returns 0'
✅ Points as strings
✅ Negative points
✅ Contains operator
✅ Case insensitive equals
✅ Negation - not contains
✅ Starts with case insensitive
✅ Ends with
✅ Regex match
✅ Numeric less than
✅ Numeric not less than (greater or equal)
✅ Numeric less than or equal
✅ All conditions fail - zero score
✅ null becomes string null for string comparison
✅ undefined becomes string undefined
✅ boolean true becomes string true
✅ boolean false becomes string false
✅ number becomes string
✅ Invalid points (non-numeric string) defaults to 0
✅ Invalid condition (empty operator) skipped
✅ With output function (double the score)
✅ With output function and threshold
✅ Threshold exactly equals score
✅ Complex scenario - mix of operators and conversions
✅ Negative total score with threshold
✅ Reference value stringification

🧩 WEIGHTED (Predefined) — GTM Variable Template for Number

When to Use This

Examples

Live Sandbox

Related Variables

Under the Hood