intersystems-community/iris-agentic-dev/objectscript-loop-patterns

// Quit with a value inside a For/While block is not allowed. The class compiles, and the
// Quit fails at runtime with <COMMAND>. Inside Try/Catch the compiler rejects it:
// ERROR #1043 QUIT argument not allowed. (Both verified on IRIS 2026.2.)
 
// WRONG — Quit 0 inside For: <COMMAND> when a match is found:
ClassMethod IsUnique(name As %String, lst As %ListOfDataTypes) As %Boolean
{
    For i=1:1:lst.Count() {
        If (lst.GetAt(i) = name) {
            Quit 0    // <COMMAND> at runtime, not a return value
        }
    }
    Quit 1            // only reached after loop completes
}
 
// CORRECT — Return always exits the method:
ClassMethod IsUnique(name As %String, lst As %ListOfDataTypes) As %Boolean
{
    For i=1:1:lst.Count() {
        If (lst.GetAt(i) = name) {
            Return 0   // exits method immediately with 0
        }
    }
    Return 1
}

// Iterate all keys of a local array:
Set key = ""
For {
    Set key = $Order(arr(key))
    Quit:key=""          // ← postfix Quit, NO SPACES around =
    // process arr(key)
}
 
// WRONG — spaces in the postfix condition:
Quit:key = ""            // ← ERROR #1054 Invalid expression
 
// Fine — a postfix Quit can share a line (verified on IRIS 2026.2):
Set key = $Order(arr(key))  Quit:key=""

// Remove items during iteration — always go backwards:
For i=items.Count():-1:1 {
    If (items.GetAt(i) [ "DELETE") {
        Do items.RemoveAt(i)
    }
}
// items.Count():-1:1 means start=Count(), step=-1, end=1

// Forward iteration:
Set key = $Order(^MyGlobal(""))    // "" seed gives FIRST key
While key '= "" {
    // process ^MyGlobal(key)
    Set key = $Order(^MyGlobal(key))
}
 
// WRONG — no subscript:
Set key = $Order(^MyGlobal)        // ← <FUNCTION> error!
 
// Reverse iteration:
Set key = $Order(^MyGlobal(""), -1)   // last key first
While key '= "" {
    Set key = $Order(^MyGlobal(key), -1)
}

// Count up:
For i=1:1:10 { ... }           // 1,2,3,...,10
 
// Count down:
For i=10:-1:1 { ... }          // 10,9,8,...,1
 
// Infinite with explicit Quit:
For {
    // ...
    Quit:condition
}
 
// Over a comma-separated list (not common but valid):
For i=1,3,7 { write i,! }      // 1, 3, 7

// WRONG — & escaped last causes double-escaping:
// "<b>A & B</b>" → "&lt;b&gt;A & B&lt;/b&gt;" → "&lt;b&gt;A &amp; B&lt;/b&gt;" ← wrong
 
// CORRECT — & first:
Set safe = $REPLACE(message, "&", "&amp;")   // 1. ampersands first
Set safe = $REPLACE(safe,    "<", "&lt;")    // 2. then less-than
Set safe = $REPLACE(safe,    ">", "&gt;")    // 3. then greater-than
// optional: Set safe = $REPLACE(safe, """", "&quot;")

// WRONG — modifying i inside the loop causes skipped/repeated iterations:
For i=1:1:items.Count() {
    If condition { Set i = i + 1 }   // skips next item — DON'T DO THIS
}
 
// CORRECT — use a separate flag or backwards iteration:
Set i = 1
While i <= items.Count() {
    If condition {
        Do items.RemoveAt(i)         // don't increment — list shrunk
    } Else {
        Set i = i + 1
    }
}
 
// OR — backwards loop (simpler):
For i=items.Count():-1:1 {
    If condition { Do items.RemoveAt(i) }
}
 
## 8. Global Negative-Key Trick — Descending Sort Without a Sort Step
 
IRIS globals sort subscripts ascending by default. To iterate in descending order
by a numeric score, store the **negated** value as the subscript key. `$Order` then
visits higher scores first.
 

 
**Why it works**: IRIS collates numeric subscripts in numeric order. Negative numbers
sort before zero, so `-100 < -90 < 0`. Negating the score inverts the order.
No `$SortBegin` / array copy / post-sort needed — the global IS the sorted structure.
 
**Common uses**: leaderboards, top-N queries, priority queues, ranked results.