definieren Variable innerhalb while-Schleife

Question

Wie ist

while (
    stack.peek() in ops && 
    p(stack.peek()) >= 10 
) { 
    str += stack.pop(); 
} 

neu geschrieben, so nenne ich .peek() jedes Mal, wenn die Schleife läuft, aber es nur einmal definieren?

habe ich darüber nachgedacht,

const peek = stack.peek(); 
while (
    peek in ops && 
    p(peek) >= 10 
) { 
    str += stack.pop(); 
} 

aber da ich stack mit stack.pop() innerhalb der while-Schleife ändern, ich denke, der Wert von stack.peek() jedes Mal verändert, so dass ich denke, ich habe die Variable innerhalb der Schleife neu zu definieren , aber

let peek = stack.peek(); 
while (
    peek in ops && 
    p(peek) >= 10 
) { 
    str += stack.pop(); 
    peek = stack.peek(); 
} 

scheint auch ein bisschen falsch, so sollte es so etwas wie

sein

oder

for (
    let peek = stack.peek(); 
    peek in ops && p(peek) >= 10; 
    peek = stack.peek() 
) { 
    str += stack.pop(); 
} 

Answer 1

Betrachten while (true) mit einem break mit:

while (true) { 
    const peek = stack.peek(); 
    if (!(peek in ops) || p(peek) < 10) break; 
    str += stack.pop(); 
} 

Theoretisch könnten Sie auch tun:

while (
    (peek => peek in ops && p(peek) >= 10)(stack.peek()) 
) { 
    str += stack.pop(); 
} 

aber das ist ziemlich hässlich. Es ist so ähnlich

function pop(stack) { 
    const peek = stack.peek(); 
    return peek in ops && p(peek) >= 10; 
} 

while(pop(stack)) str += stack.pop(); 

A for Schleife ist keine schlechte Idee, entweder zu schreiben, und könnte wie folgt geschrieben werden:

for (let peek; peek = stack.peek(), peek in ops && p(peek) >= 10;) { 
    str += stack.pop(); 
} 

, die den Aufruf von stack.peek() vermeiden wieder zu duplizieren.

Answer 2

Zumindest sollte diese Arbeit.

var peek = stack.peek(); //Declaration (once) and initialization 

while ((peek in ops) && (p(peek) >= 10)) 
{ 
    str += stack.pop(); 
    peek = stack.peek() //Re-assignment after modifying stack. 
} 

Definieren Sie eine Variable vor der Schleifenbedingung und aktualisieren Sie dann die Variable als letzte Anweisung in der Schleife. Ich bin sicher, dass Sie zu dieser Lösung irgendwann gekommen wären. :-)

Answer 3

Wie ist

while (
    stack.peek() in ops && 
    p(stack.peek()) >= 10 
) { 
    str += stack.pop(); 
} 

umschrieben, so nenne ich .peek() jedes Mal, wenn die Schleife läuft, aber nur es einmal definieren?

Entschuldigung für den Verbrauch. Ich habe Array.prototype.peek =() => this [this.length - 1] erstellt. Ist es eine schlechte Übung, sich mit Array.prototype zu messen?

Hinweis,

var stack = [1,2,3]; 
stack.peek(); 

zurück 3, hier function Schlüsselwort.

Array.prototype.peek = function() { return this[this.length - 1]} 

Pfeil Funktion zurück undefined

Array.prototype.peek =() => this[this.length - 1]; stack.peek() 

mit

---

Sie alternativ Ausdruck stack.length -1 als Bedingung innerhalb while Schleife verwenden könnte; z.B.;

var stack = [-2, -1, 0, 1, 2, 3, 4, 5], 
 
    n = 0; 
 

 
while (stack.length - 1 && (peek = stack.pop())) { 
 
    // do stuff 
 
    n += (curr = peek * 10) >= 10 ? curr : n; 
 
    delete curr; 
 
    console.log(`peek:${peek}`); 
 
} 
 

 
console.log(`n:${n}, peek:${peek}`);