🧩 WEIGHTED (Predefined) — GTM Variable Template for Logic

🧩 WEIGHTED (Predefined) EXTENDED Logic

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.

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

GTM Configuration

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()

Related Variables

Same category: Logic

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