🧩 WEIGHTED (Advanced) — GTM Variable Template for Logic

🧩 WEIGHTED (Advanced) CORE 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

Score without threshold

INPUT

Conditions: [

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

Points: 10
},

{condition: {
Input Value: 'world',
Custom Function: (v, r) => v === r,
Reference: 'world'
},

Points: 5
},

{condition: {
Input Value: 'test',
Custom Function: (v, r) => v === r,
Reference: 'fail'
},

Points: 3
}
]

Threshold Score: undefined

OUTPUT

Below threshold returns 0

INPUT

Conditions: [

{condition: {
Input Value: 'test',
Custom Function: (v, r) => v === r,
Reference: 'fail'
},

Points: 10
},

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

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.

Read-only Preview

🧩 WEIGHTED (Advanced)

SUM OUT ⬇

💡 Tips:
• All conditions are evaluated (unlike IF-ELSE-IF)
• Your custom functions can contain any JavaScript logic
• Use positive points for desired matches, negative for penalties
• Access GTM APIs like require('makeNumber') inside functions

Input ValueCustom FunctionReference 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

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 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
• score => score + ' points' → Add label

Related Variables

Same category: Logic

Under the Hood

📜 View Implementation Code

/**
 * Evaluates conditions using weighted point scoring with custom functions.
 * Each condition has a point value, returns true if total score meets threshold.
 *
 * Direct-mode only
 * @param {Array<Object>} data.ls1 - List of condition objects with points
 * @param {Object} data.ls1[].condition - Condition object for this item
 * @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 {number} data.ls1[].pts - Points awarded if this condition passes
 * @param {number} data.thr - Minimum score required to return true
 * @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 {boolean|number} True/false if threshold provided, or total score if no threshold.
 *
 * @note Custom Functions Version - Use for complex scoring logic not covered by predefined operators
 *
 * @framework ggLowCodeGTMKit
 */
const makeNumber = require('makeNumber');

const safeFunction = fn => typeof fn === 'function' ? fn : x => x;
const castFn = safeFunction(data.cast);
const out = safeFunction(data.out);

const conditions = data.ls1 || [];
const threshold = makeNumber(data.thr);

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);
};

let totalScore = 0;

for (let i = 0; i < conditions.length; i++) {
    const item = conditions[i];
    if (!item || !item.condition) {
        continue;
    }
    
    const pointsValue = makeNumber(item.pts);
    const points = (typeof pointsValue === 'number' && pointsValue === pointsValue) ? pointsValue : 0;
    
    if (evaluateCondition(item.condition)) {
        totalScore += points;
    }
}

const result = (typeof threshold === 'number' && threshold === threshold) ? totalScore >= threshold : totalScore;

return out(result);

🧪 View Test Scenarios (20 tests)

✅ '[example] Score without threshold'
✅ With threshold - score meets threshold
✅ '[example] Below threshold returns 0'
✅ Points as strings
✅ Negative points
✅ With cast function - lowercase normalization
✅ With cast function - numeric conversion
✅ Custom function with object property comparison
✅ Complex custom logic
✅ With output function (double the score)
✅ With output function and threshold
✅ All conditions fail - zero score
✅ Invalid function (not a function) - skipped
✅ Missing condition object - skipped
✅ Invalid points (non-numeric string) defaults to 0
✅ Empty conditions array
✅ Threshold exactly equals score
✅ Negative total score with threshold
✅ Cast with property extraction
✅ omplex scenario - mix of conditions and cast