I was looking at source code of Ext object in ExtJs docs here and I noticed this for loop:
for (j = enumerables.length; j--;) {
k = enumerables[j];
if (config.hasOwnProperty(k)) {
object[k] = config[k];
}
}
So, normally in a for loop, we have do initialization, specify condition and then increment/decrement the counter. I do see an initial condition and j-- which decrements the counter after each iteration. However, what I can't figure out is how is the loop going to be terminated? I neither see any condition nor a break keyword that will terminate the loop.
What am I missing here?
the j-- is the loop condition, that's how it will terminate. the trailing ;) is the missing increment/decrement.
The j-- construct both decrements j and tests the old un-decremented value for non-zero to decide whether to continue looping. The loop stops when j is zero; below the loop, the value of j will be -1.
The key parts of the for loop to look for are the semicolons -- for ( ; ; )
Any valid expression (or comma-separated expression list) can go in any of the three slots, before, between, and after the semicolons.
The loop initializers go after the ( and before the first ;. The loop condition is the value of the expression between the two ; ;. The post-loop update goes after the last ; and before the ).
Related
for (let counter = 3; counter >= 0 ; counter--){
console.log(counter);
}
I am still learning and I am making a simple for loop that logs the numbers 3 2 1 0 and I am having a difficulty understanding why do I have to set the stopping condition (counter >= 0) which comes after the initialization ( let counter = 3) and not ( counter > 0 ) to get the right answer.
isn’t the number 1 is bigger than 0 and when checked against the stopping condition should evaluate to true?
also why when I set the stopping condition to counter = 0 it doesn't log anything?
A for loop in the form
for (initialization; condition; increment) {
body
}
is roughly* equivalent to the while loop:
initialization;
while (condition) {
body;
increment;
}
If you change the condition to counter == 0 (I'm assuming = was a typo in the question, not the actual code), the while condition fails the first time, because 3 == 0 is not true. So the body is never executed and the loop stops immediately.
[*] I say "roughly" because there's a difference related to variable scope if let is used to declare the variable in the initialization clause.
Let's break down your code:
for (let counter = 3; counter >= 0 ; counter--){
console.log(counter);
}
We need a initiator for starting a loop. So we started with counter from 3. Then we gave it an iteration condition that if counter is less than or equals zero the loop will iterate and on each move it will decrease the counter number by one. The (--) means decrement.
Now come to your problem. (>=) will continue the loop on 0 and only using (>) will stop it before zero. This is the difference. You can change it and see what happens.
counter = 0 you can't set a condition like this. A condition must have two operators eg. (==)(!=)(>=)(<=). So the use is invalid. We use this format to declare a new value into variable.
Breaking it down into three parts:
First part:
counter=3
Second part:
counter>=0
Third part:
counter--
For the first part:
It is the initialisation, which sets the variable counter to 3.
For the second part:
It is the condition. It will stop the loop when the condition is false.
The condition consists of an operator.
For the operator, >= means bigger than or equal. == means equal
Note that = isn't a comparison operator. It means 'counter is 0'.
For the third part:
It is the operation.
It will run every iteration, or cycle.
-- means 'decrease by 1'
I am at a loss how best to approach for loops in JavaScript. Hopefully an understanding of for loops will help shed light on the other types of loops.
Sample code
for (var i=0; i < 10; i=i+1) {
document.write("This is number " + i);
}
My understanding is that when i has been initialized, it starts with the value of 0 which then evaluated against the condition < 10. If it is less than 10, it the executes the statement document.write("This is number + i); Once it has executed the preceding statement, only then does it increment the next value by 1.
Guides I have consulted:
http://www.functionx.com/javascript/Lesson11.htm
http://www.cs.brown.edu/courses/bridge/1998/res/javascript/javascript-tutorial.html#10.1
http://www.tizag.com/javascriptT/javascriptfor.php
Now the guide at http://www.functionx.com/javascript/Lesson11.htm seems to indicate otherwise i.e.
To execute this loop, the Start condition is checked. This is usually
the initial value where the counting should start. Next, the Condition
is tested; this test determines whether the loop should continue. If
the test renders a true result, then the Expression is used to modify
the loop and the Statement is executed. After the Statement has been
executed, the loop restarts.
The line that throws me is "If the test renders a true result, then the Expression is used to modify the loop and the Statement is executed". It seems to imply that because 0 is less than 10, increment expression is modified which would be 0 + 1 and THEN the statement, e.g. document.write is executed.
My problem
What is the correct way to interpret for loops? Is my own comprehension correct? Is the same comprehension applicable to other programming languages e.g. PHP, Perl, Python, etc?
Think of a for loop as the following
for(initializers; condition; postexec) {
execution
}
When the loop is first started the code var i = 0 is run. This initializes the variable that you will be testing for inside the loop
Next the loop evaluates the i < 10 expression. This returns a boolean value which will be true for the first 10 times it is run. While this expression keeps evaluating to true the code inside the loop is run.
document.write("This is number " + i);
Each time after this code is run the last part of the loop i++ is executed. This code in this example adds 1 to i after each execution.
After that code is executed the condition of the loop is check and steps 2 and 3 repeat until finally the condition is false in which case the loop is exited.
This the way loops work in the languages you mentioned.
Lets have a look at the corresponding section in the ECMAScript specification:
The production
IterationStatement : for ( var VariableDeclarationListNoIn ; Expressionopt ; Expressionopt) Statement
is evaluated as follows:
1. Evaluate VariableDeclarationListNoIn.
2. Let V = empty.
3. Repeat
a. If the first Expression is present, then
i. Let testExprRef be the result of evaluating the first Expression.
ii. If ToBoolean(GetValue(testExprRef)) is false,
return (normal, V, empty).
b. Let stmt be the result of evaluating Statement.
...
f. If the second Expression is present, then
i. Let incExprRef be the result of evaluating the second Expression.
ii. Call GetValue(incExprRef). (This value is not used.)
As you can see, in step 1, the variable assignment is evaluated. In step 3a, the condition is tested. In step 3b, the loop body is evaluated, and after that the third expression is evaluated in step 3f.
Therefore your understanding of the for loop is correct.
It is to assume that it works the same way in other languages, since the for loop is such a common statement in programming languages (note that Python does not have such a statement). But if you want to be absolutely certain, you better consult their specification as well.
Your quoted source is wrong, and we can prove it...
The basis of the for loop has four separate blocks which may be executed:
for(initialise; condition; finishediteration) { iteration }
Fortunately we can execute a function in each of these blocks. Therefore we can create four functions which log to the console when they execute like so:
var initialise = function () { console.log("initialising"); i=0; }
var condition = function () { console.log("conditioning"); return i<5; }
var finishediteration = function () { console.log("finished an iteration"); i++; }
var doingiteration = function () { console.log("doing iteration when `i` is equal", i); }
Then we can run the following, which places the above functions into each block:
for (initialise(); condition(); finishediteration()) {
doingiteration();
}
Kaboom. Works.
If you viewing this page using Safari on the Mac then you can AppleAlt + I and copy the above two snippets, in order, into the console and see the result.
EDIT, extra info....
Also... the finished iteration block is optional. For example:
for (var i=0; i<10;) {
console.log(i); i++;
};
does work.
The second reference is wrong. Your explanation is correct.
Another way to think about it, if this helps you:
var i = 0;
while (i < 10) {
document.write("This is number " + i);
i++;
}
This is for statement syntax:
for(initalize, condition, increment) {
Do_some_things();
}
initalize Will executed only one time when for begin then it execute Do_some_things(); statement, and while condition still true it will execute increment and then Do_some_things();. if co condition false, for would exit.
for (var i=0; i < 10; i=i+1) {
document.write("This is number " + i);
}
var i=0 will execute one time (initalize).
i < 10 condition was always checked after a loop.
i=i+1 will execute after check i < 10 and result is true.
Value of i is: 0, 1, 3, 4, 5, 6, 7, 8, 9 (10 times loop)
before you call me out for using wrong terms or sth, I am a newbie programmer.
So, this would be the correct form of the code I'm experimenting with:
for (var i = 0; i <= 10; i += 2) {
nums.push(i);
}
console.log(nums)
However, I don't get why I need to put the = sign after the +. I tried to research this but I couldn't find anything. When I removed the =, JS (Scrimba) crashed. Can anyone explain this to me please?
The third expression in the for loop is to indicate how the i variable increases. This expression is run after every loop iteration.
The second i<=10 is the condition that has to be true for the loop to continue.
Now in your loop starts with i=0, then i=2 is run after 1st iteration. And after every iteration i=2. So i<=10 is true, which is the condition. So this is an infinite loop, leading to the crash.
i+=2 is shorthand for i = i +2, so i is increasing everytime and at some point will exceed 10.
This assumes you have defined nums at top like:
var nums = []. Otherwise you get a different error.
i += 2 mean i = i + 2. In this context, for(A；B; C)，C part will run every time in every loop. If you only use "+", the i value will never changed, and loop will be non-stop considering your judgement to stop the loop i < 10 equal to 0 < 10, which is true forever.
Let's take a look at for loop before go to your problem:
for (statement 1; statement 2; statement 3) {
// code block to be executed
}
Statement 1 is executed (one time) before the execution of the code block.
Statement 2 defines the condition for executing the code block.
Statement 3 is executed (every time) after the code block has been executed.
If you want to end the loop, statement 2 should return a false value.
In your case:
statement 1 is i=1 -> Assign 1 to i variable.
statement 2 is i<=10 -> Execute the code inside brackets if and only if i is less than or equal to 10
statement 3 is i+=2 -> in crease i by 2 after every run.
the point is if you change statement 3 to i+2, it is not an assignment statement anymore, but an operator. So the value of i won't be changed after statement 3 execution.
=> The value of i will always be 1
=> the statement 2 always returns true
=> infinite loop
So your code crashes because of an infinite loop
i += 2 means your are incrementing the value of i by 2.
So, in your case, the loop will start from 0, and it will push in your array. It will keep increasing your i value by 2 and pushing them in the array till it (i) becomes more than 10
In JS I stumbled across a kind of for loop which is for(;;) that functions like a while(true) loop. What do the semicolons function in the brackets of this for loop?
for (statement 1; statement 2; statement 3) {
code block to be executed
}
Statement 1 is optional and is executed before the loop (the code block) starts.
var i = 0;
var length = 10
for (; i < length; i++) {
//The for loop run until i is less than length and you incerement i by 1 each time. javascript doesnt care what you do inside, it just check whether you have variable with name i and length
}
Statement 2 is again optional defines the condition for running the loop (the code block).
var i = 0;
var len = 100;
for (i = 5; ; i++) {
//Here you are just initializing i with 5 and increment it by 1 there is no break condition so this will lead to an infinite loop hence we should always have a break here somehwere.
}
Statement 3 is optional and is executed each time after the loop (the code block) has been executed.
var i = 0;
var length = 100;
for (; i < length; ) {
//Here you are just checking for i < length which is true. If you don't increment i or have an break it will turn into infinite loop
}
In nut shell when you have no conditions or initialization's it turns into an infinite loop.
Usually, a for loop header contains 3 parts:
for (var i = 0 ; i < 10 ; i++)
// ^^^^^^^^^ ^^^^^^ ^^^
You first initialise a variable, check the condition and if it is true, do whatever the loop body says, then increment i.
What you might not know is that any part of the for loop header can be omitted. If the first part is omitted then no variable is initialised. If the second part is omitted then there is no condition check. It will always assume the condition is true.
So for(;;) is basically an infinite loop because it omitted the condition part of the for loop header. Every time, the condition is true, so it continues on forever.
for ( init; condition; increment )
{
statement(s);
}
Here is the flow of control in a for loop:
The init step is executed first, and only once. This step allows you to declare and initialize any loop control variables. You are not required to put a statement here, as long as a semicolon appears.
Next, the condition is evaluated. If it is true, the body of the loop is executed. If it is false, the body of the loop does not execute and flow of control jumps to the next statement just after the for loop.
After the body of the for loop executes, the flow of control jumps back up to the increment statement. This statement allows you to update any loop control variables. This statement can be left blank, as long as a semicolon appears after the condition.
The condition is now evaluated again. If it is true, the loop executes and the process repeats itself (body of loop, then increment step, and then again testing for a condition). After the condition becomes false, the for loop terminates.
The for loop consists of three parts:
for (INITIALIZATION; CONDITION; AFTERTHOUGHT)
{
}
If you omit these parts the whole will be evaluated as:
for(; true ;)
{ }
The initialization and after thought are just ignored.
First semi semicolon ends initialization statement.
Second semi semicolon ends condition check statement.
In your case both statement are empty (no initializing and checking nothing every loop).
Well I'm just going to take a guess.
Typically a for loop might be like this:
for (i = 0; i < 10; i++)
so basically
for (;;)
is well forever, because loop condition is always met.
What I can still add is:
reference to the source,
This conditional test is optional. If omitted, the condition always evaluates to true.
we can leave any of these three blocks in the loop for,
information that this behavior of the loop for is similar like in in C language and others with syntax inspired by C, such as C++, Java etc.,
a practical example of using such a loop:
let i = 1;
for (;;) {
if (i === 4) {
break;
}
console.log(i++);
}
I will also add that the statment block after the for loop is also optional (we only need to put the ; at the end). To show this, here's the next example: equivalent to the above code, but without the block statmant in the for loop:
for(var i = 1; i < 4; console.log(i++));
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 8 years ago.
Improve this question
Potentially dangerous code below, line 2
Repeat: POTENTIALLY DANGEROUS CODE BELOW
var history = "";
for (start = 3; start = 1000; start += 1){
if(start % 5 == 0 || start % 3 == 0)
history += start + " "; }
Okay, this is the tenth time I've put JavaScript code in that's frozen my browser. It's putting my computer in shock. Are these panic attacks going to destroy her heart? Where can I learn about all the crap that might break my computer as I continue to learn and practice JavaScript? I'm looking for an exhaustive list, only.
Your loop: for (start = 3; start = 1000; start += 1){
The second part of a for( ; ; ) loop is the condition test. The loop will continue until the second part evaluates to false. To not create an infinite loop, change your code to:
for (var start = 3; start < 1000; start += 1){
Note: start+=1 is equal to start++. If you want a compact code, you can replace +=1 by ++.
An overview of the three-part for-loop, for(initialise; condition; increment):
initialise - Create variables (allowed to be empty)
condition - The loop will stop once this expression evaluates to false
increment - This expression is executed at the end of the loop
Always check against infinite loops: Make sure that the condition is able to evaluate to false.
Commonly made mistakes:
A negative incremental expression in conjunction with a is-lower-than comparison:
i-- decreases the counter, so i<100 will always be true (unless the variable i is initialized at 100)
A positive incremental expression in conjunction with a is-higher-than comparison.
A non-incrementing expression: for(var i=0,j=0; i<100; j++) (i doesn't increase)
A condition which is always true (such as in your case)
You just have to learn and read about it properly. Your loop condition start = 1000 will always evaluate to true, that's why the loop never terminates (an assignment returns the value which was assigned and any other number than 0 is evaluates to true).
The MDN JavaScript Guide is a great resource for learning JavaScript. Particular for this situation:
A for loop repeats until a specified condition evaluates to false. The JavaScript for loop is similar to the Java and C for loop. A for statement looks as follows:
for ([initialExpression]; [condition]; [incrementExpression])
statement
When a for loop executes, the following occurs:
The initializing expression initialExpression, if any, is executed. This expression usually initializes one or more loop counters, but the syntax allows an expression of any degree of complexity. This expression can also declare variables.
The condition expression is evaluated. If the value of condition is true, the loop statements execute. If the value of condition is false, the for loop terminates. If the condition expression is omitted entirely, the condition is assumed to be true.
The statement executes. To execute multiple statements, use a block statement ({ ... }) to group those statements.
The update expression incrementExpression, if there is one, executes, and control returns to step 2.
As the others said, it mostly comes down to try and error.... that is a good way of learning anyway.
your conditional statement start=1000 will always return true. You cant found such fool proof's list for this, you have to learn from these mistakes on your own.
Uh - what did you wanted here ?
for (start = 3; start = 1000; start += 1)
do you wanted this ? ( from 3 to 1000 )
for (start = 3; start <= 1000; start += 1)
in first case you will stuck on 1000