Loops/Continue: Difference between revisions

 

=={{header|Aikido}}==

print (i)

if ((i % 5) == 0) {

}

print (", ")

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

[[ALGOL 68]] has no continue reserved word, nor does it need one. The continue reserved word is only syntactic sugar for operations that can be achieved without it as in the following example:

<lang algol68>FOR i FROM 1 TO 10 DO

 

=={{header|AWK}}==

<lang awk>BEGIN {

for(i=1; i <= 10; i++) {

=={{header|C sharp|C#}}==

{{trans|Java}}

<lang csharp>using System;

 

=={{header|Clojure}}==

Clojure doesn't have a continue keyword. It has a recur keyword, although I prefer to work with ranges in this case.

[n (range 1 11)]

(do

(print n)

 

=={{header|ColdFusion}}==

 

=={{header|Common Lisp}}==

Common Lisp doesn't have a continue keyword, but the <code>do</code> iteration construct does use an implicit <code>tagbody</code>, so it's easy to <code>go</code> to any label. Four solutions follow. The first pushes the conditional (whether to print a comma and a space or a newline) into the format string. The second uses the implicit <code>tagbody</code> and <code>go</code>. The third is a do loop with conditionals outside of the output functions.

<lang lisp>(do ((i 1 (1+ i))) ((> i 10))

 

These use the <code>loop</code> iteration form, which does not contain an implicit tagbody (though one could be explicitly included). The first uses an explicit condition to omit the rest of the loop; the second uses <code>block</code>/<code>return-from</code> to obtain the effect of skipping the rest of the code in the <code>block</code> which makes up the entire loop body.

 

<lang lisp>(loop for i from 1 to 10

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

<lang fortran>do i = 1, 10

write(*, '(I0)', advance='no') i

ENDDO </lang>

 

The following code demonstrates the use of 'next':

<lang Icon>procedure main()

every writes(x := 1 to 10) do {

end</lang>

However, the output sequence can be written without 'next' and far more succinctly as:

 

=={{header|J}}==

J is array-oriented, so there is very little need for loops. For example, one could satisfy this task this way:

 

 

J does support loops for those times they can't be avoided (just like many languages support gotos for those time they can't be avoided).

(i % 5 = 0).if { '\n'.print; } else { ','.print; };

};</lang>

=={{header|Lua}}==

<lang Lua>for i = 1, 10 do

 

=={{header|Metafont}}==

Metafont has no a <tt>continue</tt> (or similar) keyword. As the [[Loop/Continue#Ada|Ada solution]], we can complete the task just with conditional.

 

 

=={{header|PARI/GP}}==

print1(n);

if(n%5 == 0, print();continue);

=={{header|Perl 6}}==

{{trans|Perl}}

{{works with|Rakudo Star|2010.08}}

<lang perl6>for 1 .. 10 {

.print;

 

=={{header|PL/I}}==

do i = 1 to 10;

put edit (i) (f(3));

if mod(i,5) = 0 then do; put skip; iterate loop; end;

put edit (', ') (a);

 

=={{header|Pop11}}==

 

=={{header|R}}==

<lang R>for(i in 1:10)

{

 

Output:

<lang Suneido>1,2,3,4,5

6,7,8,9,10

ok</lang>

 

=={{header|Tcl}}==

puts -nonewline ", "

}</lang>

 

=={{header|TI-89 BASIC}}==

<lang ti-89>

count()

=={{header|UnixPipes}}==

<lang bash>yes \ | cat -n | head -n 10 | xargs -n 5 echo | tr ' ' ,</lang>

=={{header|UNIX Shell}}==

<lang bash>Z=1