DRY bei Zuweisung eines neuen Wertes für jede Schleife

Question

Betrachtet wird eine Funktion query_item, die entweder ein zu bearbeitendes Objekt zurückgibt oder null, wenn nichts mehr verarbeitet werden soll.

let item = query_item(); 
while(item !== null){ 
    process(item); 
    item = query_item(); 
} 

Offensichtlich ist dies eine kleine Verletzung von DRY (Do wiederholt sie nicht), meist durch query_item() als dedizierte Funktion abgeschwächt.

Ich bin mir bewusst, dass in diesem einfachen Fall die Klarheit viel wichtiger ist als die Vermeidung von Wiederholungen.

Gibt es dennoch eine Möglichkeit, eine Schleife wie diese zu schreiben, ohne die Zuweisung zu wiederholen?

Das einzige, was mir einfiel, war ein For-Loop-Ansatz, aber das hat die gleiche Wiederholung und ist - zumindest in meinen Augen - etwas schwieriger zu lesen.

for(let item = query_item(); 
    item !== null; 
    item = query_item() 
){ 
    process(item); 
}; 

Answer 1

Dies ist das Standard-Szenario, in dem man einen Auftrag in der while Bedingung verwenden würde:

let item; 
while (item = query_item()) { 
    process(item); 
} 

oder möglicherweise, wenn Sie explizit sein wollen:

let item; 
while ((item = query_item()) !== null) { 
    process(item); 
} 

Sie können auch Verwenden Sie eine Schleife for mit dem gleichen Ansatz, der Ihnen auch Blockbereich für let:

bietet

for (let item; item = query_item();) { 
    process(item); 
} 

Answer 2

Kleiner hübscher?

let item; 
do { 
    item = query_item(); 
    if (item) process(item); 
} while (item !== null) 

Answer 3

der Javascript glaube ich, Sie schreiben konnte:

while(let item = query_item() && item){ 
    process(item); 
} 

Answer 4

Wenn Sie diese Zuordnung Seltsamkeit vollständig vermeiden wollen und die klarsten möglich Schleife Syntax zu erhalten, man bedenkt, könnte eine ES6 iterator mit:

function query_items() { 
    return { 
     [Symbol.iterator]() { 
      return this; 
     }, 
     next() { 
      return { 
       value: query_item(), 
       get done() { return this.value === null } 
      }; 
     } 
    }; 
} 

for (let item of query_items()) { 
    process(item); 
} 

Oder noch besser implementieren query_items als generator function sofort.

Answer 5

Eine Alternative zu assignment within the loop condition ...

let item; 
while (item = query_item()) { 
    process(item); 
} 

... ist ein generator function, die nach der Begegnung eines null Wert endet:

function* iterate(cb) { 
    let next = cb(); 
    if (next === null) return; 
    yield next, yield* iterate(cb); 
} 

for (let item of iterate(query_item)) { 
    process(item); 
}