View source for Loops/For with a specified step

{{task|Iteration}}
[[Category:Simple]]


;Task:
Demonstrate a &nbsp; ''for-loop'' &nbsp; where the step-value is greater than one.


;Related tasks:
* &nbsp; [[Loop over multiple arrays simultaneously]]
* &nbsp; [[Loops/Break]]
* &nbsp; [[Loops/Continue]]
* &nbsp; [[Loops/Do-while]]
* &nbsp; [[Loops/Downward for]]
* &nbsp; [[Loops/For]]
* &nbsp; [[Loops/For with a specified step]]
* &nbsp; [[Loops/Foreach]]
* &nbsp; [[Loops/Increment loop index within loop body]]
* &nbsp; [[Loops/Infinite]]
* &nbsp; [[Loops/N plus one half]]
* &nbsp; [[Loops/Nested]]
* &nbsp; [[Loops/While]]
* &nbsp; [[Loops/with multiple ranges]]
* &nbsp; [[Loops/Wrong ranges]]
<br><br>

=={{header|11l}}==
<syntaxhighlight lang="11l">L(i) (1..9).step(2)
   print(i)</syntaxhighlight>

{{out}}
<pre>
1
3
5
7
9
</pre>

=={{header|360 Assembly}}==
;Basic - Algol style
The opcode BXH uses 3 registers, one for index one for step and one for limit.
<syntaxhighlight lang="360asm">*        Loops/For with a specified step     12/08/2015
LOOPFORS CSECT
         USING  LOOPFORS,R12
         LR     R12,R15
*     == Algol style ================ test at the beginning
         LA     R3,BUF             idx=0
         LA     R5,0               from 5 (from-step=0)
         LA     R6,5               step 5
         LA     R7,25              to 25
LOOPI    BXH    R5,R6,ELOOPI       for i=5 to 25 step 5
         XDECO  R5,XDEC              edit i
         MVC    0(4,R3),XDEC+8       output i
         LA     R3,4(R3)             idx=idx+4
         B      LOOPI              next i
ELOOPI   XPRNT  BUF,80             print buffer
         BR     R14
BUF      DC     CL80' '            buffer
XDEC     DS     CL12               temp for edit
         YREGS  
         END    LOOPFORS</syntaxhighlight>
{{out}}
<pre>
   5  10  15  20  25
</pre>
;Basic - Fortran style
The opcode BXLE uses 3 registers, one for index one for step and one for limit.
<syntaxhighlight lang="360asm">*     == Fortran style ============== test at the end
         LA     R3,BUF             idx=0
         LA     R5,5               from 5
         LA     R6,5               step 5
         LA     R7,25              to 25
LOOPJ    XDECO  R5,XDEC            for j=5 to 25 step 5;  edit j
         MVC    0(4,R3),XDEC+8       output j
         LA     R3,4(R3)             idx=idx+4
         BXLE   R5,R6,LOOPJ        next j
         XPRNT  BUF,80             print buffer</syntaxhighlight>
;Structured Macros
<syntaxhighlight lang="360asm">*     == Algol style ================ test at the beginning
         LA     R3,BUF             idx=0
         LA     R5,5               from 5 
         LA     R6,5               step 5
         LA     R7,25              to 25
         DO WHILE=(CR,R5,LE,R7)    for i=5 to 25 step 5
           XDECO  R5,XDEC            edit i 
           MVC    0(4,R3),XDEC+8     output i
           LA     R3,4(R3)           idx=idx+4
           AR     R5,R6              i=i+step
         ENDDO  ,                  next i
         XPRNT  BUF,80             print buffer</syntaxhighlight>
;Structured Macros HLASM
<syntaxhighlight lang="360asm">*     == Fortran style ============== test at the end
         LA     R3,BUF             idx=0
         DO FROM=(R5,5),TO=(R7,25),BY=(R6,5)  for i=5 to 25 step 5
           XDECO  R5,XDEC            edit i 
           MVC    0(4,R3),XDEC+8     output i
           LA     R3,4(R3)           idx=idx+4
         ENDDO  ,                  next i
         XPRNT  BUF,80             print buffer</syntaxhighlight>
=={{header|6502 Assembly}}==
This loop loads from an array and writes each element to memory addresses $D000, $D002, $D004, $D006, $D008, $D00A, $D00C, $D00E, in ascending order.

<syntaxhighlight lang="6502asm">define ArrayPointerLo $00   ;define some helpful labels.
define ArrayPointerHi $01
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
setArray:      ;Easy6502 doesn't let us define arbitrary bytes so the best option is to fill the range at runtime.
lda #$10
ldx #0
loop_setArray:
sta $1200,x
clc
adc #$10
inx
cpx #$08
bcc loop_setArray
; stores this sequence of hex values starting at $1200: $10 $20 $30 $40 $50 $60 $70 $80

ClearMem:      ;clear $D000-$D0FF
lda #0
ldx #0
loop_clearMem:
sta $D000,x
inx
bne loop_clearMem
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; end of prep work, the real code begins here.

lda #$12              ;high byte of array address
sta ArrayPointerHi
lda #$00              ;low byte of array address
sta ArrayPointerLo    ;these are used to look up the array rather than hard-code it in.



ldx #$0E              ;the loop counter, gets decremented twice per iteration to skip the odd addresses.
ldy #7                ;the index into the source array.

;on the 6502 looping backwards is almost always faster.

loop_fill:
lda (ArrayPointerLo),y ;loads from the array's base address, plus Y
sta $D000,x            ;store at $D000+X
dey                    ;decrement array index
dex 
dex                    ;decrement destination index twice
bpl loop_fill          ;if destination index equals #$FF, we are done.

brk                    ;end of program</syntaxhighlight>

{{out}}
<pre>
d000: 10 00 20 00 30 00 40 00 50 00 60 00 70 00 80 00
</pre>

=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program loopstep64.s   */
 
/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"

.equ MAXI,   20
/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:  .asciz "Counter =  @ \n"      // message result

/*********************************/
/* UnInitialized data            */
/*********************************/
.bss 
sZoneConv:             .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                           // entry of program 
    mov x4,0                    // init counter
1:                              // begin loop 
    mov x0,x4
    ldr x1,qAdrsZoneConv        // display value
    bl conversion10             // call function with 2 parameter (x0,x1)
    ldr x0,qAdrszMessResult
    ldr x1,qAdrsZoneConv   
    bl strInsertAtCharInc       // insert result at first @ character
    bl affichageMess            // display message
    add x4,x4,2                 // increment counter by 2
    cmp x4,MAXI                 //
    ble 1b                      // loop
 
100:                            // standard end of the program 
    mov x0,0                    // return code
    mov x8,EXIT                 // request to exit program
    svc 0                       // perform the system call
 
qAdrsZoneConv:            .quad sZoneConv
qAdrszMessResult:         .quad szMessResult
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>

=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Main()
  BYTE i

  FOR i=0 TO 70 STEP 7
  DO
    PrintF("%B ",i)
  OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/For_with_a_specified_step.png Screenshot from Atari 8-bit computer]
<pre>
0 7 14 21 28 35 42 49 56 63 70
</pre>

=={{header|Ada}}==
The FOR loop construct in Ada does not give the programmer the ability to directly modify the loop control variable during the execution of the loop.  
Instead, a valid range must always be provided before entering a loop. 
Because exact adherence to the task is impossible, we have three versions to approximate a solution. Looper_1 goes through a range of values which are even. 
Looper_2 multiples each value by two. 
Looper_3 most closely adheres to the requirements of this task, and achieves this by using a second range for the indices.

<syntaxhighlight lang="ada">with Loopers;
use Loopers;


procedure For_Main is
begin
        Looper_1;
        Looper_2;
        Looper_3;
end For_Main;


package Loopers is
        procedure Looper_1;
        procedure Looper_2;
        procedure Looper_3;
end Loopers;

with Ada.Text_IO, Ada.Integer_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO;

package body Loopers is
        procedure Looper_1 is
                Values : array(1..5) of Integer := (2,4,6,8,10);
        begin
                for I in Values'Range loop
                        Put(Values(I),0);
                        if I = Values'Last then
                                Put_Line(".");
                        else
                                Put(",");
                        end if;
                end loop;
        end Looper_1;

        procedure Looper_2 is
                E : Integer := 5;
        begin
                for I in 1..E loop
                        Put(I*2,0);
                        if I = E then
                                Put_Line(".");
                        else
                                Put(",");
                        end if;
                end loop;
        end Looper_2;

        procedure Looper_3 is
                Values : array(1..10) of Integer := (1,2,3,4,5,6,7,8,9,10);
                Indices : array(1..5) of Integer := (2,4,6,8,10);
        begin
                for I in Indices'Range loop
                        Put(Values(Indices(I)),0);
                        if I = Indices'Last then
                                Put_Line(".");
                        else
                                Put(",");
                        end if;
                end loop;
        end Looper_3;

end Loopers;

</syntaxhighlight>

=={{header|Agena}}==
Tested with Agena 2.9.5 Win32
<syntaxhighlight lang="agena">for i from 2 to 8 by 2 do
    print( i )
od</syntaxhighlight>

=={{header|Aime}}==
<syntaxhighlight lang="aime">integer i;

i = 0;
while (i < 10) {
    o_winteger(2, i);
    i += 2;
}

o_newline();</syntaxhighlight>

=={{header|ALGOL 60}}==
 '''for''' i:=5 '''step''' 5 '''until''' 25 '''do'''
   OUTINTEGER(i)

=={{header|ALGOL 68}}==
The ALGOL 68 "''universal''" '''for'''/'''while''' loop:
  [ '''for''' index ] [ '''from''' first ] [ '''by''' increment ] [ '''to''' last ] [ '''while''' condition ] '''do''' statements '''od'''
  The minimum form of a "loop clause" is thus: '''do''' statements '''od''' # an infinite loop #

The formal specification of ALGOL 68 states:
 '''for''' i '''from''' u1 '''by''' u2 '''to''' u3 '''while''' condition '''do''' action '''od'''
"is thus equivalent to the following void-closed-clause:"
 '''begin''' '''int''' f:= u1, '''int''' b = u2, t = u3;
    step2:
      '''if''' (b > 0 &and; f &le; t) &or; (b < 0 &and; f &ge; t) &or; b = 0
      '''then''' '''int''' i = f;
          '''if''' condition
          '''then''' action; f +:= b; '''go''' '''to''' step2
          '''fi'''
      '''fi'''
 '''end'''
Note: Highlighting is as per the formal specification, 
c.f. [[:Category:ALGOL 68#Example of different program representations]].

There are several unusual aspects of the construct:
** only the ''''''do''' ~ '''od'''''' portion was compulsory, in which case the loop will iterate indefinitely.
** thus the clause ''''''to''' 100 '''do''' ~ '''od'''''', will iterate only 100 times.
** the '''while''' "syntactic element" allowed a programmer to break from a '''for''' loop early. eg
 '''int''' sum sq:=0;
 '''for''' i '''while'''
   sum sq &ne; 70 &times; 70
 '''do'''
   sum sq +:= i &uarr; 2
 '''od''' 

Subsequent "extensions" to the standard Algol68 allowed the '''to''' syntactic element to be replaced with '''upto''' and '''downto''' to achieve a small optimisation.  
The same compilers also incorporated:
* '''until'''<sup>(C)</sup> - for late loop termination.
* '''foreach'''<sup>(S)</sup> - for working on arrays in [[wp:Parallel computing|parallel]].

=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">begin
    for i := 3 step 2 until 9 do write( i )
end.</syntaxhighlight>

=={{header|ALGOL-M}}==
<syntaxhighlight lang="algol">BEGIN
    INTEGER I;
    FOR I := 1 STEP 3 UNTIL 19 DO
        WRITE( I );
END</syntaxhighlight>

=={{header|AppleScript}}==

<syntaxhighlight lang="applescript">repeat with i from 2 to 10 by 2
	log i
end repeat</syntaxhighlight>

=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">

/* ARM assembly Raspberry PI  */
/*  program loopstep2.s   */

/* Constantes    */
.equ STDOUT, 1     @ Linux output console
.equ EXIT,   1     @ Linux syscall
.equ WRITE,  4     @ Linux syscall
.equ MAXI,   20
/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:  .ascii "Counter = "      @ message result
sMessValeur:   .fill 12, 1, ' '
                   .asciz "\n"
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss 
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                @ entry of program 
    push {fp,lr}      @ saves 2 registers 
    mov r4,#0
1:    @ begin loop 
    mov r0,r4
    ldr r1,iAdrsMessValeur     @ display value
    bl conversion10             @ call function with 2 parameter (r0,r1)
    ldr r0,iAdrszMessResult
    bl affichageMess            @ display message
    add r4,#2                   @ increment counter by 2
    cmp r4,#MAXI              @
    ble 1b                @ loop

100:   @ standard end of the program 
    mov r0, #0                  @ return code
    pop {fp,lr}                 @restaur 2 registers
    mov r7, #EXIT              @ request to exit program
    svc #0                       @ perform the system call

iAdrsMessValeur:          .int sMessValeur
iAdrszMessResult:         .int szMessResult
/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {r0,r1,r2,r7,lr}      @ save  registres
    mov r2,#0                  @ counter length 
1:      @ loop length calculation 
    ldrb r1,[r0,r2]           @ read octet start position + index 
    cmp r1,#0                  @ if 0 its over 
    addne r2,r2,#1            @ else add 1 in the length 
    bne 1b                    @ and loop 
                                @ so here r2 contains the length of the message 
    mov r1,r0        			@ address message in r1 
    mov r0,#STDOUT      		@ code to write to the standard output Linux 
    mov r7, #WRITE             @ code call system "write" 
    svc #0                      @ call systeme 
    pop {r0,r1,r2,r7,lr}        @ restaur des  2 registres */ 
    bx lr                       @ return  
/******************************************************************/
/*     Converting a register to a decimal                                 */ 
/******************************************************************/
/* r0 contains value and r1 address area   */
conversion10:
    push {r1-r4,lr}    @ save registers 
    mov r3,r1
    mov r2,#10

1:	   @ start loop
    bl divisionpar10 @ r0 <- dividende. quotient ->r0 reste -> r1
    add r1,#48        @ digit	
    strb r1,[r3,r2]  @ store digit on area
    sub r2,#1         @ previous position
    cmp r0,#0         @ stop if quotient = 0 */
    bne 1b	          @ else loop
    @ and move spaces in first on area
    mov r1,#' '   @ space	
2:	
    strb r1,[r3,r2]  @ store space in area
    subs r2,#1       @ @ previous position
    bge 2b           @ loop if r2 >= zéro 

100:	
    pop {r1-r4,lr}    @ restaur registres 
    bx lr	          @return
/***************************************************/
/*   division par 10   signé                       */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*  
/* and   http://www.hackersdelight.org/            */
/***************************************************/
/* r0 dividende   */
/* r0 quotient */	
/* r1 remainder  */
divisionpar10:	
  /* r0 contains the argument to be divided by 10 */
    push {r2-r4}   /* save registers  */
    mov r4,r0 
    mov r3,#0x6667   @ r3 <- magic_number  lower
    movt r3,#0x6666  @ r3 <- magic_number  upper
    smull r1, r2, r3, r0   @ r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) 
    mov r2, r2, ASR #2     /* r2 <- r2 >> 2 */
    mov r1, r0, LSR #31    /* r1 <- r0 >> 31 */
    add r0, r2, r1         /* r0 <- r2 + r1 */
    add r2,r0,r0, lsl #2   /* r2 <- r0 * 5 */
    sub r1,r4,r2, lsl #1   /* r1 <- r4 - (r2 * 2)  = r4 - (r0 * 10) */
    pop {r2-r4}
    bx lr                  /* leave function */
/***************************************************/
/* integer division unsigned                       */
/***************************************************/
division:
    /* r0 contains dividend */
    /* r1 contains divisor */
    /* r2 returns quotient */
    /* r3 returns remainder */
    push {r4, lr}
    mov r2, #0                @ init quotient
    mov r3, #0                @ init remainder
    mov r4, #32               @ init counter bits
    b 2f
1:          @ loop 
    movs r0, r0, LSL #1     @ r0 <- r0 << 1 updating cpsr (sets C if 31st bit of r0 was 1)
    adc r3, r3, r3           @ r3 <- r3 + r3 + C. This is equivalent to r3 ? (r3 << 1) + C 
    cmp r3, r1               @ compute r3 - r1 and update cpsr 
    subhs r3, r3, r1        @ if r3 >= r1 (C=1) then r3 ? r3 - r1 
    adc r2, r2, r2           @ r2 <- r2 + r2 + C. This is equivalent to r2 <- (r2 << 1) + C 
2:
    subs r4, r4, #1          @ r4 <- r4 - 1 
    bpl 1b                  @ if r4 >= 0 (N=0) then loop
    pop {r4, lr}
    bx lr


</syntaxhighlight>

=={{header|Arturo}}==
<syntaxhighlight lang="rebol">loop 0..10 .step:2 'i [
	print i
]</syntaxhighlight>
{{out}}
<pre>0
2
4
6
8
10</pre>

=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">SetBatchLines, -1
iterations := 5
step := 10
iterations *= step
Loop,  % iterations
{
   If Mod(A_Index, step)
      Continue
   MsgBox, % A_Index
}
ExitApp</syntaxhighlight>

=={{header|Avail}}==
<syntaxhighlight lang="avail">For each i from 0 to 100 by 7 do [Print: “i” ++ " is a multiple of 7!\n";];</syntaxhighlight>
Note the <code>0 to 100 by 7</code> segment isn't a fixed part of the loop syntax, but a call to the <code>_to_by_</code> method, which returns a tuple of integers in a range separated by a particular step size.

=={{header|AWK}}==

<syntaxhighlight lang="awk">BEGIN {
  for (i= 2; i <= 8; i = i + 2) {
    print i
  }
  print "Ain't never too late!"
}</syntaxhighlight>

−	
=={{header|Axe}}==
Axe does not support a step size other than 1. However, one can modify the increment variable inside the loop to accomplish the same task.

This example increments by 2:
<syntaxhighlight lang="axe">For(I,0,10)
 Disp I▶Dec,i
 I++
End</syntaxhighlight>

=={{header|Bait}}==
<syntaxhighlight lang="bait">
fun main() {
	// Print all single digit odd numbers
	for i := 1; i < 10; i += 2 {
		println(i)
	}
}
</syntaxhighlight>

=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="qbasic">FOR I = 2 TO 8 STEP 2 : PRINT I; ", "; : NEXT I : PRINT "WHO DO WE APPRECIATE?"</syntaxhighlight>

==={{header|BaCon}}===
This prints all odd digits:
<syntaxhighlight lang="freebasic">
FOR i = 1 TO 10 STEP 2
    PRINT i
NEXT</syntaxhighlight>

==={{header|Basic|QuickBasic}}===
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">for i = 2 to 8 step 2
   print i; ", ";
next i
print "who do we appreciate?"</syntaxhighlight>

==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">for i = 1 to 21 step 2
	print i; " ";
next i
end</syntaxhighlight>

==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic">      FOR n = 2 TO 8 STEP 1.5
        PRINT n
      NEXT</syntaxhighlight>
{{out}}
<pre>
         2
       3.5
         5
       6.5
         8
</pre>

==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">10 for i = 1 to 21 step 2
20   print i;
30 next i</syntaxhighlight>

==={{header|Commodore BASIC}}===
<syntaxhighlight lang="qbasic">10 FOR I = 1 TO 10 STEP 2
20 PRINT I
30 NEXT</syntaxhighlight>

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

For i As Integer = 1 To 21 Step 2
  Print i; " ";
Next
Print
Sleep</syntaxhighlight>

==={{header|Gambas}}===
'''[https://gambas-playground.proko.eu/?gist=cdd9b10b64ac4d78b75c364061f25641 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim siCount As Short

For siCount = 1 To 50 Step 5
  Print "Gambas is great!"
Next

End</syntaxhighlight>
<pre>Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!
Gambas is great!</pre>

==={{header|GW-BASIC}}===
{{works with|BASICA}}
{{works with|PC-BASIC|any}}
<syntaxhighlight lang="qbasic">10 FOR I = 1 TO 21 STEP 2
20   PRINT I;
30 NEXT I</syntaxhighlight>

==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 FOR I=1 TO 10 STEP 2
110   PRINT I
120 NEXT</syntaxhighlight>

==={{header|Liberty BASIC}}===
<syntaxhighlight lang="lb">for i = 2 to 8 step 2
   print i; ", ";
next i
print "who do we appreciate?"
end</syntaxhighlight>

==={{header|Microsoft Small Basic}}===
<syntaxhighlight lang="microsoftsmallbasic">For i = 0 To 100 Step 2
  TextWindow.WriteLine(i)
EndFor</syntaxhighlight>

==={{header|Minimal BASIC}}===
{{works with|QBasic}}
{{works with|QuickBasic}}
{{works with|Applesoft BASIC}}
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
{{works with|MSX BASIC}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Run BASIC}}
{{works with|Yabasic}}
<syntaxhighlight lang="qbasic">10 FOR I = 1 TO 21 STEP 2
20   PRINT I; " ";
30 NEXT I
40 END</syntaxhighlight>

==={{header|MSX Basic}}===
<syntaxhighlight lang="qbasic">10 FOR I = 1 TO 21 STEP 2
20   PRINT I;
30 NEXT I</syntaxhighlight>

==={{header|NS-HUBASIC}}===
<syntaxhighlight lang="ns-hubasic">10 FOR I=1 TO 10 STEP 2
20 PRINT I
30 NEXT</syntaxhighlight>
{{out}}
<pre> 1  3  5  7  9  11  13  15  17  19  21</pre>

==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">For i = -15 To 25 Step 5
  Debug i
Next i</syntaxhighlight>
{{out}}
<pre>-15
-10
-5
0
5
10
15
20
25</pre>

Decrementing with step 
<syntaxhighlight lang="purebasic">For i = 10 To 0 Step -2
  Debug i
Next ; i is optional</syntaxhighlight>
{{out}}
<pre>10
8
6
4
2
0</pre>

==={{header|QB64}}===
<syntaxhighlight lang="qbasic">For i% = 0 to 10 Step 2 
     Print i%
Next            'To be more explicit use "Next i%"
</syntaxhighlight>
{{out}}
A newline is inserted automatically after the Print statement
<pre>0
2
4
6
8
10</pre>

We can also decrement with stepping
<syntaxhighlight lang="qbasic">For i% = 10 to 0 Step -2 
     Print i%
Next i </syntaxhighlight>
{{out}}
<pre>10
8
6
4
2
9</pre>

==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FOR i = 1 TO 21 STEP 2
  PRINT i;
NEXT i</syntaxhighlight>

==={{header|Quite BASIC}}===
<syntaxhighlight lang="qbasic">10 FOR I = 1 TO 21 STEP 2
20   PRINT I; " ";
30 NEXT I</syntaxhighlight>

==={{header|Run BASIC}}===
<syntaxhighlight lang="runbasic">for i = 2 to 8 step 2
   print i; ", ";
next i
print "who do we appreciate?"</syntaxhighlight>
{{out}}
<pre>2, 4, 6, 8, who do we appreciate?</pre>

==={{header|smart BASIC}}===
Notice how the ampersand (&) is used to concatenate the variable with the text instead of a semicolon.

<syntaxhighlight lang="qbasic">FOR n = 2 TO 8 STEP 2
   PRINT n & "..";
NEXT n
PRINT "who do we appreciate?"
END</syntaxhighlight>

==={{header|TI-83 BASIC}}===
Prints numbers from 0 to 100 stepping by 5.
<syntaxhighlight lang="ti83b">:For(I,0,100,5
:Disp I
:End</syntaxhighlight>

==={{header|TI-89 BASIC}}===
<syntaxhighlight lang="ti89b">Local i
For i, 0, 100, 5
    Disp i
EndFor</syntaxhighlight>

==={{Header|Tiny BASIC}}===
<syntaxhighlight lang="qbasic">    REM TinyBasic does not have a for-loop construct.
    REM Equivalent using conditional jump:

    LET i = 1
10  IF i > 21 THEN GOTO 20
    PRINT i
	LET i = i + 2
	GOTO 10
20  END</syntaxhighlight>

==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">
FOR i = 1 TO 21 STEP 2
    PRINT i; " ";
NEXT i
END
</syntaxhighlight>
{{out}}
<pre>1 3 5 7 9 11 13 15 17 19 21</pre>
Since TrueBasic does not distinguish between integer or real values, we can increment using decimal values as well

<syntaxhighlight lang="qbasic">FOR i = 1 TO 5 STEP .5
    PRINT i
NEXT i
END</syntaxhighlight>
{{out}}
<pre>1
1.5
2
2.5
3
3.5
4
4.5
5</pre>

==={{header|Visual Basic}}===
{{works with|Visual Basic|VB6 Standard}}
<syntaxhighlight lang="vb">Sub MyLoop()
    For i = 2 To 8 Step 2
        Debug.Print i;
    Next i
    Debug.Print
End Sub</syntaxhighlight>
{{out}}
<pre> 2  4  6  8 </pre>

==={{header|Visual Basic .NET}}===
{{works with|Visual Basic .NET|.NET Core 3.0}}
<syntaxhighlight lang="vbnet">Imports System.Console
Module Program
    Sub Main()
        For i = 2 To 8 Step 2
            Write($"{i}, ")
        Next
        WriteLine("who do we appreciate?")
    End Sub
End Module</syntaxhighlight>
{{out}}
<pre>2, 4, 6, 8, who do we appreciate?</pre>

{{works with|Visual Basic .NET|2011}}
<syntaxhighlight lang="vbnet">Public Class FormPG
    Private Sub FormPG_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Dim i As Integer, buffer As String
        buffer = ""
        For i = 2 To 8 Step 2
            buffer = buffer & i & " "
        Next i
        Debug.Print(buffer)
    End Sub
End Class</syntaxhighlight>
{{out}}
<pre>2 4 6 8 </pre>

==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">PROGRAM "forby"

DECLARE FUNCTION Entry()

FUNCTION Entry()
  FOR i% = 0 TO 100 STEP 2
    PRINT FORMAT$("###", i%)
  NEXT i%
END FUNCTION
END PROGRAM</syntaxhighlight>

==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">for i = 1 to 21 step 2
    print i, " ";
next i
print
end</syntaxhighlight>

==={{header|ZX Spectrum Basic}}===
<syntaxhighlight lang="basic">10 FOR l = 2 TO 8 STEP 2
20 PRINT l; ", ";
30 NEXT l
40 PRINT "Who do we appreciate?"</syntaxhighlight>

=={{header|Batch File}}==
<syntaxhighlight lang="dos">@echo off
for /l %%A in (1,2,10) do (
     echo %%A
)</syntaxhighlight>
{{Out}}
<pre>>Sample.BAT
1
3
5
7
9

></pre>

=={{header|bc}}==
<syntaxhighlight lang="bc">for (i = 2; i <= 10; i += 2) {
    i
}</syntaxhighlight>

=={{header|Befunge}}==
{{trans|C}}
<syntaxhighlight lang="befunge">1 >:.55+,v
@_^#`9:+2<</syntaxhighlight>

=={{header|C}}==
This prints all odd digits:
<syntaxhighlight lang="c">int i;
for(i = 1; i < 10; i += 2)
  printf("%d\n", i);</syntaxhighlight>

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

<syntaxhighlight lang="csharp">using System;
 
class Program {
    static void Main(string[] args) {    
        for (int i = 2; i <= 8; i+= 2) {        
            Console.Write("{0}, ", i);
        }

        Console.WriteLine("who do we appreciate?");
    }
}</syntaxhighlight>

=={{header|C++}}==
This prints all odd digits:
<syntaxhighlight lang="cpp">for (int i = 1; i < 10; i += 2)
  std::cout << i << std::endl;</syntaxhighlight>

=={{header|C3}}==
Print all odd digits:
<syntaxhighlight lang="c3">for (int i = 1; i < 10; i += 2) io::printfn("%d", i);</syntaxhighlight>

=={{header|Ceylon}}==
<syntaxhighlight lang="ceylon">shared void run() {
	
	for(i in (2..8).by(2)) {
		process.write("``i`` ");
	}
	print("who do we appreciate?");
}</syntaxhighlight>

=={{header|Chapel}}==
<syntaxhighlight lang="chapel">
// Can be set on commandline via --N=x
config const N = 3; 

for i in 1 .. 10 by N {
  writeln(i);
}
</syntaxhighlight>
{{out}}
<pre>
$ ./loopby
1
4
7
10

$ ./loopby --N=4
1
5
9
</pre>

=={{header|ChucK}}==
Chuck style
<syntaxhighlight lang="c">
SinOsc s => dac;

for (0 => int i; i < 2000; 5 +=> i )
{
    i => s.freq;
    100::ms => now;
}
</syntaxhighlight>
General purpose style:
<syntaxhighlight lang="c">
for (0 => int i; i < 2000; 5 +=> i )
{
    <<< i >>>;
}
</syntaxhighlight>

=={{header|Clojure}}==
The first example here is following the literal specification, but is not idiomatic Clojure code. 
The second example achieves the same effect without explicit looping, and would (I think) be viewed as better code by the Clojure community.
<syntaxhighlight lang="clojure">(loop [i 0]
  (println i)
  (when (< i 10)
    (recur (+ 2 i))))

(doseq [i (range 0 12 2)] 
  (println i))</syntaxhighlight>

=={{header|CLU}}==
<syntaxhighlight lang="clu">% This prints all odd digits

start_up = proc ()
    po: stream := stream$primary_output()
    
    for i: int in int$from_to_by(1, 10, 2) do
        stream$putl(po, int$unparse(i))
    end
end start_up</syntaxhighlight>

=={{header|COBOL}}==
<syntaxhighlight lang="cobol">       IDENTIFICATION DIVISION.
       PROGRAM-ID. Display-Odd-Nums.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  I PIC 99.

       PROCEDURE DIVISION.
           PERFORM VARYING I FROM 1 BY 2 UNTIL 10 < I
               DISPLAY I
           END-PERFORM

           GOBACK
           .</syntaxhighlight>

=={{header|ColdFusion}}==
<syntaxhighlight lang="cfm">
<cfloop from="0" to="99" step="3" index="i">
  <Cfoutput>#i#</Cfoutput>
</cfloop>
</syntaxhighlight>

=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(format t "~{~S, ~}who do we appreciate?~%" (loop for i from 2 to 8 by 2 collect i))
</syntaxhighlight>

{{out}}
<pre>
2, 4, 6, 8, who do we appreciate?
</pre>

=== Using DO ===
<syntaxhighlight lang="lisp">
(do ((n 0 (incf n (+ (random 3) 2))))	; Initialize to 0 and set random step-value 2, 3 or 4
    ((> n 20))				; Break condition
  (print n))				; On every loop print value
</syntaxhighlight>

{{out}}
<pre>
0 
2 
4 
8 
10 
13 
15 
17 
20 
</pre>

=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio, std.range;

void main() {
    // Print odd numbers up to 9.
    for (int i = 1; i < 10; i += 2)
        writeln(i);

    // Alternative way.
    foreach (i; iota(1, 10, 2))
        writeln(i);
}</syntaxhighlight>
{{out}}
<pre>1
3
5
7
9
1
3
5
7
9</pre>

=={{header|Dao}}==
<syntaxhighlight lang="dao"># first value: 1
# max value: 9
# step: 2
for( i = 1 : 2 : 9 ) io.writeln( i )</syntaxhighlight>

=={{header|Dart}}==
<syntaxhighlight lang="dart">main() {
  for (int i = 1; i <= 21; i += 2) print(i);
}</syntaxhighlight>

=={{header|Delphi}}==
Delphi's For loop doesn't support a step value.  
It would have to be simulated using something like a While loop.

<syntaxhighlight lang="delphi">program LoopWithStep;
 
{$APPTYPE CONSOLE}
 
var
  i: Integer;
begin
  i:=2;
  while i <= 8 do begin
    WriteLn(i);
    Inc(i, 2);
  end;
end.</syntaxhighlight>
{{out}}
<pre>2
4
6
8</pre>

=={{header|Dragon}}==
<syntaxhighlight lang="dragon">for(i = 2, i <= 8,i += 2){
   show ", " + i 
}
showln "who do we appreciate?"</syntaxhighlight>

=={{header|DWScript}}==
<syntaxhighlight lang="delphi">var i : Integer;

for i := 2 to 8 step 2 do
   PrintLn(i);</syntaxhighlight>

{{out}}
<pre>2
4
6
8</pre>

=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">//Prints odd numbers from 1 to 10
for i in 1^2..10 {
    print(i)
}</syntaxhighlight>

=={{header|E}}==
There is no step in the standard numeric range object (a..b and a..!b) in E, which is typically used for numeric iteration. 
An ordinary while loop can of course be used:
<syntaxhighlight lang="e">var i := 2
while (i <= 8) {
    print(`$i, `)
    i += 2
}
println("who do we appreciate?")</syntaxhighlight>

A programmer frequently in need of iteration with an arbitrary step should define an appropriate range object:

<syntaxhighlight lang="e">def stepRange(low, high, step) {
    def range {
        to iterate(f) {
            var i := low
            while (i <= high) {
                f(null, i)
                i += step
            }
        }
    }
    return range
}

for i in stepRange(2, 9, 2) {
  print(`$i, `)
}
println("who do we appreciate?")</syntaxhighlight>

The least efficient, but perhaps convenient, solution is to iterate over successive integers and discard undesired ones:

<syntaxhighlight lang="e">for i ? (i %% 2 <=> 0) in 2..8 {
    print(`$i, `)
}
println("who do we appreciate?")</syntaxhighlight>

=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
# Prints even numbers from 0 to 100
for i = 0 step 2 to 100
   print i
.
</syntaxhighlight>

=={{header|EchoLisp}}==
Steps may be integers, float, rationals.
<syntaxhighlight lang="lisp">
(for ((i (in-range 0 15 2))) (write i))
    0 2 4 6 8 10 12 14

(for ((q (in-range 0 15 14/8))) (write q))
    0 7/4 7/2 21/4 7 35/4 21/2 49/4 14 

(for ((x (in-range 0 15 PI))) (write x))
    0 3.141592653589793 6.283185307179586 9.42477796076938 12.566370614359172 
</syntaxhighlight>

=={{header|Ela}}==

<syntaxhighlight lang="ela">open monad io
 
for m s n | n > m = do return ()
          | else = do
              putStrLn (show n) 
              for m s (n+s)
 
_  = for 10 2 0 ::: IO</syntaxhighlight>

{{out}}
<pre>0
2
4
6
8
10</pre>

=={{header|Elena}}==
ELENA 6.x
<syntaxhighlight lang="elena">public program()
{
    for(int i := 2; i <= 8; i += 2  )
    {
        console.writeLine(i)
    }
}</syntaxhighlight>

=={{header|Elixir}}==
<syntaxhighlight lang="elixir">defmodule Loops do
  def for_step(n, step) do
    IO.inspect Enum.take_every(1..n, step)
  end
end

Loops.for_step(20, 3)</syntaxhighlight>

{{out}}
<pre>
[1, 4, 7, 10, 13, 16, 19]
</pre>
or
<syntaxhighlight lang="elixir">iex(1)> Stream.iterate(1, &(&1+2)) |> Enum.take(10)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]</syntaxhighlight>

=={{header|EMal}}==
<syntaxhighlight lang="emal">
for int i = 2; i <= 8; i+= 2 do write(i + ", ") end
writeLine("who do we appreciate?")
</syntaxhighlight>
{{out}}
<pre>
2, 4, 6, 8, who do we appreciate?
</pre>

=={{header|Erlang}}==
<syntaxhighlight lang="erlang">%% Implemented by Arjun Sunel
%% for_loop/4 by Bengt Kleberg.
-module(loop_step).
-export([main/0, for_loop/1, for_loop/4]).
 
 % This Erlang code for "For Loop" is equivalent to: " for (i=start;  i<end ; i=i+2){ printf("* ");} " in C language. 
 
main() ->
	for_loop(1).    
  
 for_loop( N ) ->
	for_loop( N, 4, 2, fun() -> io:fwrite("* ") end ).

for_loop( I, End, Step, Do ) when N < End ->
    Do(),
    for_loop( I+Step, End, Step, Do );
for_loop( _I, _End, _Step, _Do ) -> ok.
</syntaxhighlight>

{{out}}
<pre>
* * ok
</pre>

=={{header|ERRE}}==
<syntaxhighlight lang="erre">
      FOR N=2 TO 8 STEP 1.5 DO
        PRINT(N)
      END FOR
</syntaxhighlight>
{{out}}
<pre>
         2
       3.5
         5
       6.5
         8
</pre>

=={{header|Euphoria}}==

<syntaxhighlight lang="euphoria">
for i = 1 to 10 by 2 do
    ? i
end for
</syntaxhighlight>
As a note, <code>? something</code> is shorthand for:
<syntaxhighlight lang="euphoria">
print(1, something)
puts(1, "\n")
</syntaxhighlight>

<code>print()</code> differs from <code>puts()</code> in that <code>print()</code> will print out the actual <code>sequence</code> it is given.  
If it is given an <code>integer</code>, or an <code>atom</code> 
(Any number that is not an <code>integer</code>), it will print those out as-is.

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">for i in 2..2..8 do
   printf "%d, " i
printfn "done"</syntaxhighlight>

{{out}}
<pre>2, 4, 6, 8, done
</pre>

=={{header|Factor}}==
Prints odd digits.
<syntaxhighlight lang="factor">1 10 2 <range> [ . ] each</syntaxhighlight>

=={{header|FALSE}}==
<syntaxhighlight lang="false">2[$9\>][$.", "2+]#"who do we appreciate!"</syntaxhighlight>

=={{header|Fantom}}==

<syntaxhighlight lang="fantom">
class Main
{
  public static Void main ()
  {
    Int step := 5
    for (Int i := 0; i < 100; i += step)
    {
      echo (i)
    }
  }
}
</syntaxhighlight>

=={{header|FBSL}}==
<syntaxhighlight lang="qbasic">#APPTYPE CONSOLE

DIM n AS INTEGER
FOR n = 2 TO 8 STEP 2
    PRINT n;
    IF n < 8 THEN PRINT " ";
NEXT
PRINT ", who will we obliterate?"
PAUSE
</syntaxhighlight>

=={{header|Fermat}}==
<syntaxhighlight lang="fermat">for i = 1 to 100 by 13 do !i;!' '; od</syntaxhighlight>
{{out}}<pre>1 14 27 40 53 66 79 92</pre>

=={{header|FOCAL}}==
If a <tt>FOR</tt> statement has three parameters, they are (in order) the start, the step, and the end; if only two parameters are supplied, they are taken to be the start and the end. The step is then set to 1.
<syntaxhighlight lang="focal">FOR I = 1,3,10; TYPE I, !</syntaxhighlight>

=={{header|Forth}}==
<syntaxhighlight lang="forth">: test
  9 2 do
    i .
  2 +loop
  ." who do we appreciate?" cr ;</syntaxhighlight>

=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<syntaxhighlight lang="fortran">do i = 1,10,2
   print *, i
end do</syntaxhighlight>

{{works with|Fortran|77 and later}}
<syntaxhighlight lang="fortran">      PROGRAM STEPFOR
        INTEGER I

C       This will print all even numbers from -10 to +10, inclusive.
        DO 10 I = -10, 10, 2
          WRITE (*,*) I
   10   CONTINUE

        STOP
      END</syntaxhighlight>

=={{header|Frink}}==
<syntaxhighlight lang="frink">
for a = 1 to 100 step 5
   println[a]
</syntaxhighlight>

All values may have units of measure, in which case a specified step is required:
<syntaxhighlight lang="frink">
for a = 1 km to 3 km step 1 meter
   println[a]
</syntaxhighlight>

=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
Str15 s(11)
long i

s(0) = "Somewhere"
s(2) = " over"
s(4) = " the"
s(6) = " rainbow" + chr$(13)
s(8) = "Bluebirds"
s(10) = " fly."

for i = 0 to 10 step 2
print s(i);
next

HandleEvents
</syntaxhighlight>
{{out}}
<pre>Somewhere over the rainbow
Bluebirds fly.</pre>

=={{header|GML}}==
<syntaxhighlight lang="gml">for(i = 0; i < 10; i += 2)
    show_message(string(i))</syntaxhighlight>

=={{header|GAP}}==
# Use a range [a, b .. c], where the step is b-a (b is the value following a), and c-a must be a multiple of the step.
<syntaxhighlight lang="gap">for i in [1, 3 .. 11] do
    Print(i, "\n");
od;

1
3
5
7
9
11
</syntaxhighlight>

=={{header|Go}}==
This prints all odd digits:
<syntaxhighlight lang="go">for i := 1; i < 10; i += 2 {
  fmt.Printf("%d\n", i)
}</syntaxhighlight>

=={{header|Groovy}}==
"for" loop:
<syntaxhighlight lang="groovy">for(i in (2..9).step(2)) {
    print "${i} "
}
println "Who do we appreciate?"</syntaxhighlight>

"each() method:
Though technically not a loop, most Groovy programmers would use the slightly more terse "each()" method on the collection itself, instead of a "for" loop.
<syntaxhighlight lang="groovy">(2..9).step(2).each {
    print "${it} "
}
println "Who do we appreciate?"</syntaxhighlight>

{{out}}
<pre>2 4 6 8 Who do we appreciate?</pre>
Go Team!

=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Control.Monad (forM_)
main = do forM_ [2,4..8] (\x -> putStr (show x ++ ", "))
          putStrLn "who do we appreciate?"</syntaxhighlight>

=={{header|Haxe}}==
While Haxe's for-loop does not allow you to directly specify the step size, it is easy to create an iterator that allows you to do that.

<syntaxhighlight lang="haxe">class Step {
  var end:Int;
  var step:Int;
  var index:Int;

  public inline function new(start:Int, end:Int, step:Int) {
    this.index = start;
    this.end = end;
    this.step = step;
  }

  public inline function hasNext() return step > 0 ? end >= index : index >= end;
  public inline function next() return (index += step) - step;
}

class Main {
  static function main() {
    for (i in new Step(2, 8, 2)) {
      Sys.print('$i ');
    }
    Sys.println('WHOM do we appreciate? GRAMMAR! GRAMMAR! GRAMMAR!');
  }
}</syntaxhighlight>

{{out}}
<pre>2 4 6 8 WHOM do we appreciate? GRAMMAR! GRAMMAR! GRAMMAR!</pre>

=={{header|hexiscript}}==
<syntaxhighlight lang="hexiscript">for let i 0; i <= 50; let i (i + 5)
  println i
endfor</syntaxhighlight>

=={{header|HicEst}}==
<syntaxhighlight lang="hicest">DO i = 1, 6, 1.25 ! from 1 to 6 step 1.25
   WRITE() i
ENDDO</syntaxhighlight>

=={{header|HolyC}}==
This prints all odd digits:
<syntaxhighlight lang="holyc">U8 i;
for (i = 1; i < 10; i += 2)
  Print("%d\n", i);</syntaxhighlight>

=={{header|Hy}}==
<syntaxhighlight lang="clojure">(for [i (range 1 10 2)] (print i))</syntaxhighlight>

=={{header|Icon}} and {{header|Unicon}}==
Icon and Unicon accomplish loop stepping through the use of a generator, the ternary operator to-by, and the every clause which forces a generator to consume all of its results.  
Because to-by is an operator it has precedence (just higher than assignments) and associativity (left) and can be combined with other operators.
<syntaxhighlight lang="python">
   every 1 to 10 by 2                       # the simplest case that satisfies the task, step by 2

   every 1 to 10                            # no by, step is 1 by default
   every EXPR1 to EXPR2 by EXPR3 do EXPR4   # general case - EXPRn can be complete expressions including other generators such as to-by, every's do is optional
   steps := [2,3,5,7]                       # a list
   every i := 1 to 100 by !steps            # . more complex, several passes with each step in the list steps, also we might want to know what value we are at
   every L[1 to 100 by 2]                   # as a list index
   every i := 1 to 100 by (k := !steps)     # . need () otherwise := generates an error
   every 1 to 5 to 10                       # simple case of combined to-by - 1,..,10, 2,..10, ..., 5,..,10
   every 1 to 15 by 2 to 5                  # combined to-by
   every (1 to 15 by 2) to 5                # . made explicit

   every writes( (TO_BY_EXPR) | "\n", " " ) # if you want to see how any of these work
</syntaxhighlight>
The ability to combine to-by arbitrarily is quite powerful.  
Yet it can lead to unexpected results.  In cases of combined to-by operators the left associativity seems natural where the by is omitted.  
In cases where the by is used it might seem more natural to be right associative.  
If in doubt parenthesize.

=={{Header|Insitux}}==

<syntaxhighlight lang="insitux">
(for i (range 0 10 2)
  (print i)
  (continue))

;or
(loop 5 i
  (print (* i 2)))
</syntaxhighlight>

=={{header|Io}}==
<syntaxhighlight lang="io">for(i,2,8,2,
    write(i,", ")
)
write("who do we appreciate?")</syntaxhighlight>

=={{header|J}}==
<syntaxhighlight lang="j">    ' who do we appreciate?' ,~ ":  2 * >: i.4
2 4 6 8 who do we appreciate?</syntaxhighlight>

Note that an expression of the form <code>(start, step) (p. i.) count</code> will generate the specified numbers (<code>p.</code> is J's polynomial primitive, <code>i.</code> is J's index generator). So, to generate the above sequence of integers we could have used:

<syntaxhighlight lang=J>   0 2 (p. i.) 5
0 2 4 6 8</syntaxhighlight>

Or, using an "actual" for loop:

<syntaxhighlight lang="j">   3 :0''
  r=.$0
  for_n. 2 * >: i.4 do.
    r=.r,n
  end.
  ' who do we appreciate?' ,~ ":n
)
2 4 6 8 who do we appreciate?</syntaxhighlight>

That said, note also that J's '''steps''' verb lets us specify how many steps to take:

<syntaxhighlight lang="j">   i:8
_8 _7 _6 _5 _4 _3 _2 _1 0 1 2 3 4 5 6 7 8
   i:8j8
_8 _6 _4 _2 0 2 4 6 8</syntaxhighlight>

Or, if we prefer, we could borrow the definition of <code>thru</code> from the [[Loops/Downward_for#J|Downward for]] task and then filter for the desired values:

<syntaxhighlight lang="j">   thru=: <./ + i.@(+*)@-~</syntaxhighlight>

Example use:

<syntaxhighlight lang="j">   (#~ 0 = 2&|) 1 thru 20
2 4 6 8 10 12 14 16 18 20
   (#~ 0 = 3&|) 1 thru 20
3 6 9 12 15 18
   (#~ 1 = 3&|) 1 thru 20
1 4 7 10 13 16 19</syntaxhighlight>

And, of course, like filtering in any language, this approach supports non-constant step sizes, either by applying a function to each argument individually:

<syntaxhighlight lang="j">   (#~ 1&p:) 1 thru 20
2 3 5 7 11 13 17 19</syntaxhighlight>

Or, by inserting a combining function between each value:

<syntaxhighlight lang="j">   (-&{.,])/ 1 thru 20
_10 11 _9 12 _8 13 _7 14 _6 15 _5 16 _4 17 _3 18 _2 19 _1 20</syntaxhighlight>

Other structural approaches can also be viable...

=={{header|Java}}==
<syntaxhighlight lang="java">for(int i = 2; i <= 8;i += 2){
   System.out.print(i + ", ");
}
System.out.println("who do we appreciate?");</syntaxhighlight>

=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">var output = '',
    i;
for (i = 2; i <= 8; i += 2) {
   output += i + ', ';
}
output += 'who do we appreciate?';
document.write(output);</syntaxhighlight>

In a functional idiom of JavaScript, however, we will only be able to compose this computation within the superordinate expressions of our program if it has the the form of an expression returning a value, rather than that of a statement which fires off side-effects but returns no value.

Following the example of languages like Haskell and J on this page, we can begin by generating the stepped series as an expression. In functional JavaScript we will typically replace a state-changing loop with a non-mutating map or fold, writing, for example, something like:

<syntaxhighlight lang="javascript">// range(iMax)
// range(iMin, iMax)
// range(iMin, iMax, dI)
function range() {
  var lngArgs = arguments.length,
    lngMore = lngArgs - 1;

  iMin = lngMore ? arguments[0] : 1;
  iMax = arguments[lngMore ? 1 : 0];
  dI = lngMore > 1 ? arguments[2] : 1;

  return lngArgs ? Array.apply(null, Array(
    Math.floor((iMax - iMin) / dI) + 1
  )).map(function (_, i) {
    return iMin + (dI * i);
  }) : [];
}

console.log(
  range(2, 8, 2).join(', ') + ', who do we appreciate ?'
);</syntaxhighlight>

Output:
<pre>2, 4, 6, 8, who do we appreciate ?</pre>

=={{header|jq}}==
To generate the stream: 2,4,6,8:<syntaxhighlight lang="jq"># If your version of jq does not have range/3, use this:
def range(m;n;step): range(0; ((n-m)/step) ) | m + (. * step);

range(2;9;2)</syntaxhighlight>
'''Example''':
<syntaxhighlight lang="jq">reduce range(2;9;2) as $i
   (""; . + "\($i), ") +
   "whom do we appreciate?"</syntaxhighlight>

=={{header|Julia}}==
<syntaxhighlight lang="julia">for i in 2:2:8
    print(i, ", ")
end
println("whom do we appreciate?")</syntaxhighlight>

=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6

fun main(args: Array<String>) {
    for (i in 1 .. 21 step 2) print("$i ")
}</syntaxhighlight>

{{out}}
<pre>
1 3 5 7 9 11 13 15 17 19 21
</pre>

=={{header|LabVIEW}}==
{{VI solution|LabVIEW_Loops_For_with_a_specified_step.png}}

=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def loops_for_with_a_specified_step
 {lambda {:a :b :step}
  {if {>= :a :b}
   then (end of loop)
   else :a {loops_for_with_a_specified_step {+ :a :step} :b :step}}}}  
-> loops_for_with_a_specified_step  

{loops_for_with_a_specified_step 0 10 2}
-> 0 2 4 6 8 (end of loop)

a more simple way:

{S.map {lambda {:i} :i} {S.serie 0 9 2}}
-> 0 2 4 6 8
</syntaxhighlight>

=={{header|Lang5}}==
<syntaxhighlight lang="lang5">: <range>  over iota swap * rot + tuck swap <= select ; : tuck  swap over ;
: >>say.(*)  . ;
1 10 2 <range> >>say.</syntaxhighlight>

=={{header|langur}}==
<syntaxhighlight lang="langur">for .i = 1; .i < 10; .i += 2 {
    writeln .i
}</syntaxhighlight>

{{out}}
<pre>1
3
5
7
9</pre>

=={{header|Lasso}}==
<syntaxhighlight lang="lasso">loop(-to=100, -from=1, -by=2) => {^
    loop_count
    '\r' // for formatting
^}</syntaxhighlight>

=={{header|LDPL}}==
<syntaxhighlight lang="ldpl"># Display the even numbers up to twenty.

data:
i is number

procedure:
for i from 0 to 21 step 2 do
    display i lf
repeat</syntaxhighlight>
{{out}}
<pre>
0
2
4
6
8
10
12
14
16
18
20
</pre>

=={{header|LIL}}==
The '''inc''' command accepts a value to add to the variable, 1 if not specified.
<syntaxhighlight lang="tcl">for {set i 1} {$i < 15} {inc i 3} {print $i}</syntaxhighlight>
{{out}}
<pre># for {set i 1} {$i < 15} {inc i 3} {print $i}
1
4
7
10
13
#</pre>

=={{header|Lingo}}==
Lingo loops don't support a "step" parameter, so it has to be implemented manually:
<syntaxhighlight lang="lingo">step = 3
repeat with i = 0 to 10
  put i
  i = i + (step-1)
end repeat</syntaxhighlight>
{{out}}
<pre>
-- 0
-- 3
-- 6
-- 9
</pre>

=={{header|Lisaac}}==
<syntaxhighlight lang="lisaac">1.to 9 by 2 do { i : INTEGER;
  i.print;
  '\n'.print;
};</syntaxhighlight>

=={{header|LiveCode}}==
<syntaxhighlight lang="livecode">repeat with n = 0 to 10 step 2
    put n after loopn
    if n is not 10 then put comma after loopn
end repeat
put loopn</syntaxhighlight>
Output<syntaxhighlight lang="livecode">0,2,4,6,8,10</syntaxhighlight>

=={{header|Logo}}==
<syntaxhighlight lang="logo">for [i 2 8 2] [type :i type "|, |] print [who do we appreciate?]</syntaxhighlight>

=={{header|Lua}}==
<syntaxhighlight lang="lua">
for i=2,9,2 do
  print(i)
end
</syntaxhighlight>

{{out}}
<pre>
2
4
6
8
</pre>

=={{header|M2000 Interpreter}}==
===A for loop===
Str$(i) always return decimal separator as "." 
format$() use same as Locale number specify. So here we use "," from Locale 1036. Str$() place a space before number if it is positive. We can use str$(i, "") to trim lead space. Here we use a space in format$ before number (and for negative numbers)

For this task we use single float numbers, and we make the loop one time from lower to higher value, and one time form higher to lower value.

<syntaxhighlight lang="m2000 interpreter">
Module LoopFor {
      Locale 1036
      Document doc$
      \\ define i as a single
      def single i
      for i=1 to 21 step 5/3
            Print i
            doc$=format$(" {0}", i)
      next i
      doc$={
      }
      \\ make i as a single
      for i=21 to 1 step 5/3
            Print i
            doc$=format$(" {0}", i)
      next i
      clipboard doc$
      report doc$
}
LoopFor
</syntaxhighlight>
{{Out}}
<pre>
 1 2,66667 4,33333 6 7,66667 9,33333 11 12,66667 14,33333 16 17,66667 19,33333 21
 21 19,33333 17,66667 16 14,33334 12,66667 11 9,33333 7,66667 6 4,33333 2,66667 1
</pre>
===Iterator step 2===
<syntaxhighlight lang="m2000 interpreter">
a=("A", "B", "C", "D", "E", "F", "Z")
k=Each(a)
While k {
      Print Array$(k),
      k=Each(a, k^+2)   ' set start again
}
Print
\\ a list of keys (unique keys allowed)
Inventory b="A", "B", "C", "D", "E", "F", "Z"
k=Each(b)
While k {
      Print Eval$(k), ' return keys as values, because no value exist yet for each key.
      k=Each(b, k^+2)
}
Print
</syntaxhighlight>
{{out}}
<pre>
A   C   E   Z
A   C   E   Z
</pre>

=={{header|M4}}==
<syntaxhighlight lang="m4">define(`for',
   `ifelse($#,0,``$0'',
   `ifelse(eval($2<=$3),1,
   `pushdef(`$1',$2)$5`'popdef(`$1')$0(`$1',eval($2+$4),$3,$4,`$5')')')')dnl

for(`x',`1',`5',`3',`x
')
</syntaxhighlight>

{{out}}
<pre>
1
4
</pre>

=={{header|Maple}}==
<syntaxhighlight lang="maple">for i from 2 to 8 by 2 do
  i;
end do;</syntaxhighlight>
{{out}}
<pre>
                               2
                               4
                               6
                               8
</pre>

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Do[
 Print[i],
 {i, 1, 20, 4}]</syntaxhighlight>
{{out}}
<pre>1
5
9
13
17</pre>

=={{header|MATLAB}} / {{header|Octave}}==

<syntaxhighlight lang="matlab">    for k = 0:10:100,
        printf('%d\n',k)
    end; </syntaxhighlight>

A vectorized version of the code is

<syntaxhighlight lang="matlab">  printf('%d\n',0:10:100);  </syntaxhighlight>

=={{header|Maxima}}==
<syntaxhighlight lang="maxima">for i: 1 step 2 thru 10 do print(i);
/* 1
   3
   5
   7 */</syntaxhighlight>

=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">for i = 0 to 10 by 2 do format "%\n" i</syntaxhighlight>
Output:
<syntaxhighlight lang="maxscript"> 
0
2
4
6
8
10
OK
</syntaxhighlight>

=={{header|min}}==
Printing the even numbers in <tt>[0,10)</tt>:
{{works with|min|0.19.6}}
<syntaxhighlight lang="min">0 (dup 10 >=) 'pop (puts 2 +) () linrec</syntaxhighlight>

=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">for i in range(1,20,4)
    print i
end for</syntaxhighlight>

{{out}}
<pre>1
5
9
13
17</pre>

=={{header|МК-61/52}}==
<syntaxhighlight lang="text">1	П0	ИП0	3	+	П0	1	0	-	x#0
02	С/П</syntaxhighlight>

In this example, the step is 3, the lowest value is 1 and the upper limit is 10.

=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE ForBy;
  IMPORT InOut;

  VAR
    i: INTEGER;

BEGIN
  FOR i := 0 TO 100 BY 2 DO
    InOut.WriteInt(i, 3);
    InOut.WriteLn
  END
END ForBy.</syntaxhighlight>

=={{header|Modula-3}}==
<syntaxhighlight lang="modula3">FOR i := 1 TO 100 BY 2 DO
  IO.Put(Fmt.Int(i) & " ");
END;</syntaxhighlight>

=={{header|MUMPS}}==
<syntaxhighlight lang="mumps">FOR I=65:3:122 DO
 .WRITE $CHAR(I)," "</syntaxhighlight>
{{out}}
<pre>A D G J M P S V Y \ _ b e h k n q t w z</pre>

=={{header|Nemerle}}==
<syntaxhighlight lang="nemerle">for (i = 2; i <= 8; i +=2)</syntaxhighlight>
<syntaxhighlight lang="nemerle">foreach (i in [2, 4 .. 8])</syntaxhighlight>

=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref savelog symbols nobinary

say
  say 'Loops/For with a specified step'

  loop i_ = -1.4 to 10.6 by 1.7
    say i_.format(3, 1) || '\0'
    end i_
  say</syntaxhighlight>
{{out}}
<pre>D:\>java lst

Loops/For with a specified step
 -1.4  0.3  2.0  3.7  5.4  7.1  8.8 10.5</pre>

=={{header|Never}}==

The increment step of the Never ''for'' expression can be simple or complex and need not be contiguous.

<syntaxhighlight lang="fsharp">for (i = 0; i < 10; i += 3)</syntaxhighlight>

=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">(for (i 0 10 2)
  (println i))</syntaxhighlight>

=={{header|Nim}}==
<syntaxhighlight lang="nim">

for n in 5 .. 9:                 # 5 to 9 (9-inclusive)
  echo n

echo "" # spacer 

for n in 5 ..< 9:                # 5 to 9 (9-exclusive)
  echo n

echo "" # spacer 

for n in countup(0, 16, 4):      # 0 to 16 step 4
  echo n 

echo "" # spacer

for n in countdown(16, 0, 4):    # 16 to 0 step -4
  echo n

</syntaxhighlight>
{{out}}
<pre>
5
6
7
8
9

5
6
7
8

0
4
8
12
16

16
12
8
4
0
</pre>

=={{header|N/t/roff}}==
Works with gnu nroff. Example from groff manual, with minimal modifications.
<syntaxhighlight lang="nroff">
.nr a 0 3
.while (\na < 19) \{\
\n+a
.\}
</syntaxhighlight>
{{out}}
<pre>3 6 9 12 15 18 21
</pre>

=={{header|Nu}}==
Here <code>each {}</code> is used to convert from a range to a list, so that it can be consumed by <code>every</code>
<syntaxhighlight lang="nu">
for i in (0..10 | each {} | every 2) {print $i}
</syntaxhighlight>
{{out}}
<pre>
0
2
4
6
8
10
</pre>

=={{header|Oberon-2}}==
Works with oo2c Version 2
<syntaxhighlight lang="oberon2">
MODULE LoopForStep;
IMPORT 
  Out;
VAR
  i: INTEGER;
 
BEGIN
  FOR i := 0 TO 10 BY 3 DO
    Out.LongInt(i,0);Out.Ln
  END;
  FOR i := 10 TO 0 BY -3 DO
    Out.LongInt(i,0);Out.Ln
  END
END LoopForStep.
</syntaxhighlight>
Output:
<pre>
0
3
6
9
10
7
4
1
</pre>

=={{header|Objeck}}==
<syntaxhighlight lang="objeck">
for(i := 0; i < 10; i += 2;) {
  i->PrintLine();
};
</syntaxhighlight>

=={{header|OCaml}}==
<syntaxhighlight lang="ocaml"># let for_step a b step fn =
    let rec aux i =
      if i <= b then begin
        fn i;
        aux (i+step)
      end
    in
    aux a
  ;;
val for_step : int -> int -> int -> (int -> 'a) -> unit = <fun>

# for_step 0 8 2  (fun i -> Printf.printf " %d\n" i) ;;
 0
 2
 4
 6
 8
- : unit = ()</syntaxhighlight>

=={{header|Octave}}==
<syntaxhighlight lang="octave">for i = 1:2:10
  disp(i)
endfor</syntaxhighlight>

=={{header|Oforth}}==

<syntaxhighlight lang="oforth"> 1 100 2 step: i [ i println ]</syntaxhighlight>

=={{header|Openscad}}==

<syntaxhighlight lang="openscad">/* Loop from 3 to 9 in steps of 2 */

for ( l = [3:2:9] )  {
  echo (l);
}
echo ("on a double white line.");</syntaxhighlight>

=={{header|Oz}}==
<syntaxhighlight lang="oz">for I in 2..8;2 do
   {System.show I}
end
{System.show done}
</syntaxhighlight>

=={{header|Panda}}==
Panda doesn't natively have a number generator with steps, so let's add it.
<syntaxhighlight lang="panda">fun for(from,to,step) type integer,integer,integer->integer
  t=to.minus(from).divide(step)
  0..t.times(step).plus(from)
  /test it for(1 6 2) -> 1 3 5

for(1 3 5)</syntaxhighlight>

=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">forstep(n=1,10,2,print(n))</syntaxhighlight>

The <code>forstep</code> construct is actually more powerful.  
For example, to print numbers with last digit relatively prime to 10:
<syntaxhighlight lang="parigp">forstep(n=1,100,[2,4,2,2],print(n))</syntaxhighlight>

=={{header|Pascal}}==
See [[Loops/For_with_a_specified_step#Delphi | Delphi]]

=={{header|Perl}}==
<syntaxhighlight lang="perl">for($i=2; $i <= 8; $i += 2) {
  print "$i, ";
}
print "who do we appreciate?\n";</syntaxhighlight>

=={{header|Phix}}==
{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
 <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">8</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d, "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"who do we appreciate?\n"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->

=={{header|Phixmonti}}==
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: https://rosettacode.org/wiki/Loops/For_with_a_specified_step
by Galileo, 11/2022 #/

include ..\Utilitys.pmt

( 2 8 2 ) for print ", " print endfor
"who do we appreciate?" print</syntaxhighlight>
{{out}}
<pre>2, 4, 6, 8, who do we appreciate?
=== Press any key to exit ===</pre>

=={{header|PHP}}==
<syntaxhighlight lang="php"><?php
foreach (range(2, 8, 2) as $i)
    echo "$i, ";
echo "who do we appreciate?\n";
?></syntaxhighlight>
{{out}}
<pre>2, 4, 6, 8, who do we appreciate?</pre>

=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">(for (N 1 (> 10 N) (+ N 2))
   (printsp N) )</syntaxhighlight>

=={{header|Pike}}==
<syntaxhighlight lang="pike">int main() {
   for(int i = 2; i <= 16; i=i+2) {
      write(i + "\n");
   }
}</syntaxhighlight>

=={{header|PILOT}}==
One of the advantages of needing to create loops manually by using conditional jumps is that a step of any integer is just as easy as a step of one.
<syntaxhighlight lang="pilot">R  : Prints the odd numbers less than 10.
C  :i = 1
*Loop
T  :#i
C  :i = i + 2
J ( i < 10 )  :*Loop
END:</syntaxhighlight>

=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
declare (n, i) fixed binary;

get list (n);
do i = 1 to n by 4;
   put skip list (i);
end;
</syntaxhighlight>

=={{header|Plain English}}==
Plain English has only one type of loop: an infinite loop that can be given a conditional break or exit. So there is nothing particularly special about this.
<syntaxhighlight lang="plainenglish">
To run:
Start up.
Put 0 into a number.
Loop.
If the number is greater than 50, break.
Convert the number to a string.
Write the string to the console.
Add 5 to the number.
Repeat.
Wait for the escape key.
Shut down.</syntaxhighlight>

=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">for ($i = 0; $i -lt 10; $i += 2) {
    $i
}</syntaxhighlight>

=={{header|Prolog}}==
If you need a stepping iterator, write one:
<syntaxhighlight lang="prolog">for(Lo,Hi,Step,Lo)  :- Step>0, Lo=<Hi.
for(Lo,Hi,Step,Val) :- Step>0, plus(Lo,Step,V), V=<Hi, !, for(V,Hi,Step,Val).

example :- 
  for(0,10,2,Val), write(Val), write(' '), fail.
example.</syntaxhighlight>
<pre>?- example.
0 2 4 6 8 10 
true.</pre>
Adding the following two rules lets you go backwards too:
<syntaxhighlight lang="prolog">for(Hi,Lo,Step,Hi)  :- Step<0, Lo=<Hi.
for(Hi,Lo,Step,Val) :- Step<0, plus(Hi,Step,V), Lo=<V, !, for(V,Lo,Step,Val).</syntaxhighlight>

=={{header|Python}}==
{{works with|Python|2.x}}
<syntaxhighlight lang="python">for i in xrange(2, 9, 2):
    print "%d," % i,
print "who do we appreciate?"</syntaxhighlight>

{{works with|Python|3.x}}
<syntaxhighlight lang="python">for i in range(2, 9, 2):
    print("%d, " % i, end="")
print("who do we appreciate?")</syntaxhighlight>

{{out}}
<pre>2, 4, 6, 8, who do we appreciate?</pre>

=={{header|Quackery}}==

The step size is specified within the loop, giving many possibilities.

<syntaxhighlight lang="quackery">
20 times [ i^ echo sp 
           2 step ]
cr
1024 times [ i^ 1+ echo sp
             i^ 1+ step ]
cr
1 56 times [ i^ echo sp 
             i^ swap step ] 
cr</syntaxhighlight>

{{Out}}

<pre>0 2 4 6 8 10 12 14 16 18 
1 2 4 8 16 32 64 128 256 512 1024 
0 1 1 2 3 5 8 13 21 34 55 
</pre>

=={{header|R}}==
<syntaxhighlight lang="r">for(a in seq(2,8,2)) {
  cat(a, ", ")
}
cat("who do we appreciate?\n")</syntaxhighlight>

Here the loop may be done implicitly by first concatenating the string and then printing:

<syntaxhighlight lang="r">cat(paste(c(seq(2, 8, by=2), "who do we appreciate?\n"), collapse=", "))</syntaxhighlight>

=={{header|Racket}}==

<syntaxhighlight lang="racket">
#lang racket

(for ([i (in-range 2 9 2)])
  (printf "~a, " i))
(printf "who do we appreciate?~n")
</syntaxhighlight>

=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2010.07}}

Depending on how you define your terms, this task is either trivial or impossible in Raku. <code>for</code> in Raku doesn't have a step value, it's an iteration operator. It iterates through any iterable object passed to it and sets the topic variable to each iterated value in turn. If you close one eye and squint, I guess you could say it has a step value of 1 (or more accurately, Next) and that isn't really changeable. Whatever iterable you pass to it though can have pretty much any value in pretty much any order you desire, so effectively the "step" value is completely unconstrained.

Examples of iterables (not exhaustive):
* Things that do a positional role:
:* Array
:* List
:* Range
:* Sequence
* Things that do an associative role:
:* Bag
:* BagHash
:* Hash
:* Map
:* Mix
:* MixHash
:* QuantHash
:* Set
:* SetHash


Probably the most straightforward way to do this is with a sequence. With at least two values on the left-hand side, the sequence operator (<code>...</code>) can infer an arithmetic series. (With at least three values, it can infer a geometric sequence, too.)

<syntaxhighlight lang="raku" line>for 2, 4 ... 8 {
    print "$_, ";
}
 
say 'whom do we appreciate?';</syntaxhighlight><!-- "Whom" is infinitely more amusing. -->

But there is nothing constraining the sequence to a constant step. Here's one with a ''random'' step.

<syntaxhighlight lang="raku" line>.say for rand, *+rand-.5 ... *.abs>2</syntaxhighlight>

{{out|Sample output}}
<pre>0.1594860240843563
-0.11336537297314198
-0.04195945218519992
-0.024844489074366427
-0.20616093727620433
-0.17589258387167517
-0.40547336592612593
0.04561929494516015
0.4886003890463373
0.7843094215547495
0.6413619589945883
1.0694380727281951
1.472290164849169
1.8310404939418325
2.326272380988639
</pre>

For that matter, the iterated object doesn't need to contain numbers.

<syntaxhighlight lang="raku" line>.say for <17/32 π banana 👀 :d(7) 🦋>;</syntaxhighlight>

=={{header|Raven}}==
List of numbers:
<syntaxhighlight lang="raven">[ 2 4 6 8 ] each "%d, " print
"who do we appreciate?\n" print</syntaxhighlight>

Range:
<syntaxhighlight lang="raven">2 10 2 range each "%d, " print
"who do we appreciate?\n" print</syntaxhighlight>
{{out}}
<pre>2, 4, 6, 8, who do we appreciate?
</pre>

=={{header|REBOL}}==
<syntaxhighlight lang="rebol">for i 2 8 2 [
	prin rejoin [i ", "]]
print "who do we appreciate?"</syntaxhighlight>

{{out}}
<pre>2, 4, 6, 8, who do we appreciate?</pre>

=={{header|REXX}}==
===version 1===
<syntaxhighlight lang="rexx">  do x=1  to 10  by 1.5
  say x
  end</syntaxhighlight>
{{out}}
<pre>
1
2.5
4.0
5.5
7.0
8.5
10.0
</pre>

===version 2===
<syntaxhighlight lang="rexx">  do thing=1  by  3/2  to 10 
  say  thing
  end</syntaxhighlight>
'''output''' is the same as above.
<br><br>

===version 3===
<syntaxhighlight lang="rexx">Do v=1  by  3/2  While v**2<30 
  Say  v
  End
Say '('v'**2) is greater than 30 (30.25)'</syntaxhighlight>
{{output}}
<pre>1
2.5
4.0
(5.5**2) is greater than 30 (30.25)</pre>

=={{header|Ring}}==
we use step keyword to define step length
in this example we print Even numbers between 0 and 10
<syntaxhighlight lang="ring">
for i = 0 to 10 step 2 see i + nl next
</syntaxhighlight>

{{out}}
<pre>
2
4
6
8
10
</pre>

we can use step with double values as well:
<syntaxhighlight lang="ring">
for i = 0 to 10 step 0.5 see i + nl next
</syntaxhighlight>
{{out}}
<pre>
0
0.50
1
1.50
2
2.50
3
3.50
4
4.50
5
5.50
6
6.50
7
7.50
8
8.50
9
9.50
10
</pre>

=={{header|RPL}}==
Specific increment is given as an argument to the <code>STEP</code> instruction at the end of each loop. Usually, it is a constant value, but it could be a variable if it makes sense.
 ≪ 1 10 '''FOR''' j
       j
    2 '''STEP'''
 ≫ 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">2.step(8,2) {|n| print "#{n}, "}
puts "who do we appreciate?"</syntaxhighlight>
or:
<syntaxhighlight lang="ruby">(2..8).step(2) {|n| print "#{n}, "}
puts "who do we appreciate?"</syntaxhighlight>
or:
<syntaxhighlight lang="ruby">for n in (2..8).step(2)
  print "#{n}, "
end
puts "who do we appreciate?"</syntaxhighlight>
or:
<syntaxhighlight lang="ruby">for n in 2.step(by: 2, to: 8)
  print "#{n}, "
end
puts "who do we appreciate?"</syntaxhighlight>
{{out}}
<pre>
2, 4, 6, 8, who do we appreciate?
</pre>

=={{header|Rust}}==

For Rust 1.28 and later:
<syntaxhighlight lang="rust">fn main() {
  for i in (2..=8).step_by(2) {
    print!("{}", i);
  }
  println!("who do we appreciate?!");
}</syntaxhighlight>

An alternative which also works in earlier versions of Rust:
<syntaxhighlight lang="rust">fn main() {
    let mut i = 2;
    while i <= 8 {
        print!("{}, ", i);
        i += 2;
    }
    println!("who do we appreciate?!");
}</syntaxhighlight>

=={{header|Salmon}}==
<syntaxhighlight lang="salmon">for (x; 2; x <= 8; 2)
    print(x, ", ");;
print("who do we appreciate?\n");</syntaxhighlight>

=={{header|SAS}}==
<syntaxhighlight lang="sas">data _null_;
do i=1 to 10 by 2;
put i;
end;
run;</syntaxhighlight>

=={{header|Sather}}==
See [[Loops/For#Sather]]: the implementation for <code>for!</code> allows to specify a step, even though the built-in <code>stepto!</code> can be used; an example of usage could be simply:
<syntaxhighlight lang="sather">    i :INT;
    loop
      i := for!(1, 50, 2);
      -- OR
      -- i := 1.stepto!(50, 2);
      #OUT + i + "\n";
    end;</syntaxhighlight>

(Print all odd numbers from 1 to 50)

=={{header|Scala}}==
<syntaxhighlight lang="scala">for (i <- 2 to 8 by 2) println(i)</syntaxhighlight>

Alternatively:
<syntaxhighlight lang="scala">(2 to 8 by 2) foreach println</syntaxhighlight>

=={{header|Scheme}}==
The built-in ''for''-like form in Scheme is the ''do'' form:

<syntaxhighlight lang="scheme">(do ((i 2 (+ i 2)))  ; list of variables, initials and steps -- you can iterate over several at once
  ((>= i 9))         ; exit condition
  (display i)        ; body
  (newline))</syntaxhighlight>

Some people prefer to use the recursive-style and more flexible _named let_ form:

<syntaxhighlight lang="scheme">(let loop ((i 2))            ; function name, parameters and starting values
  (cond ((< i 9)
         (display i)
         (newline)
         (loop (+ i 2))))))  ; tail-recursive call, won't create a new stack frame</syntaxhighlight>

You can add to the language by wrapping the loop in a function:

<syntaxhighlight lang="scheme">(define (for-loop start end step func)
  (let loop ((i start))
    (cond ((< i end)
	   (func i)
	   (loop (+ i step))))))

(for-loop 2 9 2
  (lambda (i)
    (display i)
    (newline)))</syntaxhighlight>

... or in a macro, which allows for making the <code>(lambda)</code> implicit:

<syntaxhighlight lang="scheme">(define-syntax for-loop
  (syntax-rules () 
    ((for-loop index start end step body ...)
     (let ((evaluated-end end) (evaluated-step step))
       (let loop ((i start))
         (if (< i evaluated-end)
           ((lambda (index) body ... (loop (+ i evaluated-step))) i)))))))

(for-loop i 2 9 2
  (display i)
  (newline))</syntaxhighlight>

{{out}}
<pre>2
4
6
8</pre>

=={{header|Scilab}}==
{{works with|Scilab|5.5.1}}
<syntaxhighlight lang="text">for i=1:2:10
    printf("%d\n",i)
end</syntaxhighlight>
{{out}}
<pre>1
3
5
7
8</pre>

=={{header|Seed7}}==
<syntaxhighlight lang="python">
$ include "seed7_05.s7i";

const proc: main is func
  local
    var integer: number is 0;
  begin
    for number range 0 to 10 step 2 do        #  10 is inclusive
      writeln(number);
    end for;

    writeln; # spacer
    
    for number range 10 downto 0 step 2 do
      writeln(number);
    end for;
    
  end func;

</syntaxhighlight>
{{out}}
<pre>
0
2
4
6
8
10

10
8
6
4
2
0
</pre>

=={{header|Sidef}}==

'''for(;;)''' loop:
<syntaxhighlight lang="ruby">for (var i = 2; i <= 8; i += 2) {
    say i
}</syntaxhighlight>

'''for-in''' loop:
<syntaxhighlight lang="ruby">for i in (2 .. (8, 2)) {
    say i
}</syntaxhighlight>

'''.each''' method:
<syntaxhighlight lang="ruby">2.to(8).by(2).each { |i|
    say i
}</syntaxhighlight>

=={{header|Simula}}==
<syntaxhighlight lang="simula">begin
    integer i;
    for i:=5 step 5 until 25 do outint(i, 5)
end</syntaxhighlight>

=={{header|Slate}}==
<syntaxhighlight lang="slate">2 to: 8 by: 2 do: [| :i | Console ; i printString ; ', '].
inform: 'enough with the cheering already!'.</syntaxhighlight>

=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">2 to: 8 by: 2 do: [ :i |
  Transcript show: i; show ', '
].
Transcript showCr: 'enough with the cheering already!'</syntaxhighlight>

=={{header|Spin}}==
{{works with|BST/BSTC}}
{{works with|FastSpin/FlexSpin}}
{{works with|HomeSpun}}
{{works with|OpenSpin}}
<syntaxhighlight lang="spin">con
  _clkmode = xtal1 + pll16x
  _clkfreq = 80_000_000

obj
  ser : "FullDuplexSerial.spin"

pub main | n
  ser.start(31, 30, 0, 115200)

  repeat n from 0 to 19 step 3
    ser.dec(n)
    ser.tx(32)

  waitcnt(_clkfreq + cnt)
  ser.stop
  cogstop(0)</syntaxhighlight>
{{out}}
<pre>
0 3 6 9 12 15 18
</pre>

=={{header|SPL}}==
<syntaxhighlight lang="spl">> n, 1..10,2
  #.output(n)
<</syntaxhighlight>

=={{header|SSEM}}==
Implementing loops with a step other than one is precisely as easy (or as fiddly) as implementing loops with a step equal to one. This example program uses a loop to perform integer division. It should be run with the dividend in storage location 21 and the divisor in storage location 22. To show that it works, we shall ask the machine to count from 387 in steps of -5 and to halt with the accumulator showing the number of times it has done so before producing a negative result.
<syntaxhighlight lang="ssem">10101000000000100000000000000000   0. -21 to c
00101000000001100000000000000000   1. c to 20
00101000000000100000000000000000   2. -20 to c
01101000000000010000000000000000   3. Sub. 22
10101000000001100000000000000000   4. c to 21
00000000000000110000000000000000   5. Test
01001000000001000000000000000000   6. Add 18 to CI
00011000000000000000000000000000   7. 24 to CI
11101000000000100000000000000000   8. -23 to CI
01001000000000010000000000000000   9. Sub. 18
00101000000001100000000000000000  10. c to 20
00101000000000100000000000000000  11. -20 to c
11101000000001100000000000000000  12. c to 23
11001000000000000000000000000000  13. 19 to CI
11101000000000100000000000000000  14. -23 to c
00101000000001100000000000000000  15. c to 20
00101000000000100000000000000000  16. -20 to c
00000000000001110000000000000000  17. Stop
10000000000000000000000000000000  18. 1
11111111111111111111111111111111  19. -1
00000000000000000000000000000000  20. 0
11000001100000000000000000000000  21. 387
10100000000000000000000000000000  22. 5
00000000000000000000000000000000  23. 0
10110000000000000000000000000000  24. 13</syntaxhighlight>
After executing 1,012 instructions, the computer halts with the correct quotient—77—in the accumulator.

=={{header|Stata}}==
<syntaxhighlight lang="stata">forvalues i=1(2)10 {
	display "`i'"
}

1
3
5
7
9</syntaxhighlight>

=={{header|Swift}}==
This prints all odd digits:
<syntaxhighlight lang="swift">for i in stride(from: 1, to: 10, by: 2) {
  print(i)
}</syntaxhighlight>
Alternately (removed in Swift 3):
<syntaxhighlight lang="swift">for var i = 1; i < 10; i += 2 {
  print(i)
}</syntaxhighlight>

=={{header|Tailspin}}==
Tailspin uses streams not loops
<syntaxhighlight lang="tailspin">
1..9:3 -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
147
</pre>

=={{header|Tcl}}==
<syntaxhighlight lang="tcl">for {set i 2} {$i <= 8} {incr i 2} {
    puts -nonewline "$i, "
}
puts "enough with the cheering already!"</syntaxhighlight>

=={{header|TorqueScript}}==

<syntaxhighlight lang="torquescript">for(%i = 0; %i < 201; %i += 2)
{
	echo(%i);
}</syntaxhighlight>

=={{header|TUSCRIPT}}==
<syntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
LOOP i=2,9,2
PRINT i
ENDLOOP
</syntaxhighlight>
{{out}}
<pre>
2
4
6
8
</pre>

=={{header|UNIX Shell}}==
All these loops iterate 2, 4, 6, 8.
==={{header|Bourne Shell}}===
{{works with|Bourne Shell}}
<syntaxhighlight lang="bash">x=2
while test $x -le 8; do
        echo $x
        x=`expr $x + 2` || exit $?
done</syntaxhighlight>
{{works with|Bourne Shell}}
{{libheader|jot}}
<syntaxhighlight lang="bash">for x in `jot - 2 8 2`; do echo $x; done</syntaxhighlight>

==={{header|ksh}}===
<syntaxhighlight lang="ksh">x=0
while (((x += 2) <= 8))
do
	print -r "$x"
done</syntaxhighlight>
{{works with|ksh93}}
<syntaxhighlight lang="ksh">for x in {2..8..2}
do
	print -r "$x"
done</syntaxhighlight>

===Bourne Again Shell===
{{works with|Bourne Again SHell|3}}
<syntaxhighlight lang="bash">for (( x=2; $x<=8; x=$x+2 )); do
  printf "%d, " $x
done</syntaxhighlight>

{{works with|Bourne Again SHell|4}}
Bash v4.0+ has inbuilt support for setting up a step value
<syntaxhighlight lang="bash">for x in {2..8..2} 
do
  echo $x
done</syntaxhighlight>

==={{header|C Shell}}===
{{libheader|jot}}
<syntaxhighlight lang="csh">foreach x (`jot - 2 8 2`)
	echo $x
end</syntaxhighlight>

=={{header|Ursa}}==
{{trans|Python}}
<syntaxhighlight lang="ursa">decl int i
for (set i 2) (< i 9) (set i (int (+ i 2)))
	out i ", " console
end for
out "who do we appreciate?" endl console</syntaxhighlight>

=={{header|Vala}}==
<syntaxhighlight lang="vala">for (int i = 1; i < 10; i += 2)
  stdout.printf("%d\n", i);</syntaxhighlight>

=={{header|VAX Assembly}}==
<syntaxhighlight lang="vax assembly">                               0000  0000     1 .entry	main,0
                            50   D4  0002     2 	clrf	r0				;init to 0.0
                                     0004     3 loop:
                                 01  0004     4 	nop					;do nothing
             FFF9 50   0A   3E   4F  0005     5 	acbf	#112.0, #1.25, r0, loop		;limit, step
                                     000B     6 
                                 04  000B     7 	ret
                                     000C     8 .end	main</syntaxhighlight>

=={{header|VBA}}==
<syntaxhighlight lang="vb">Sub MyLoop()
    For i = 2 To 8 Step 2
        Debug.Print i;
    Next i
    Debug.Print
End Sub</syntaxhighlight>
{{out}}
<pre>
 2  4  6  8 
</pre>

=={{header|VBScript}}==
<syntaxhighlight lang="vb">buffer = ""
For i = 2 To 8 Step 2
    buffer = buffer & i & " "
Next
WScript.Echo buffer</syntaxhighlight>
{{out}}
<pre>2 4 6 8</pre>

=={{header|Vedit macro language}}==
This prints all odd digits in range 1 to 9: 
<syntaxhighlight lang="vedit">for (#1 = 1; #1 < 10; #1 += 2) {
    Num_Type(#1)
}</syntaxhighlight>


=={{header|Verilog}}==
Imprime todos los números impares
<syntaxhighlight lang="verilog">
module main;
  integer  i;
  
  initial begin

    for(i = 1; i <= 21; i = i + 2)  $write(i);
  $finish ;
  end
endmodule
</syntaxhighlight>


=={{header|Vim Script}}==
<syntaxhighlight lang="vim">for i in range(2, 10, 2)
    echo i
endfor</syntaxhighlight>

{{Out}}
<pre>2                                                                                                                 
4                                                                                                                 
6                                                                                                                 
8                                                                                                                 
10</pre>

=={{header|V (Vlang)}}==
This prints all odd digits:
<syntaxhighlight lang="v (vlang)">for i := 1; i<10; i+=2 {
    println(i)
}</syntaxhighlight>

=={{header|Vorpal}}==
<syntaxhighlight lang="vorpal">for(i = 2, i <= 8, i = i + 2){
   i.print()
}</syntaxhighlight>

=={{header|Wart}}==
<syntaxhighlight lang="wart">for i 2 (i <= 8) (i <- i+2)
  prn i</syntaxhighlight>

=={{header|Wren}}==
There is currently no direct way to incorporate a step into a ''for'' loop but we can simulate it by declaring a second variable at the start of the loop which maps the loop variable to the value we want or we can simply use a ''while'' loop instead.
<syntaxhighlight lang="wren">// Print odd numbers under 20.
for (i in 1..10) {
    var j = 2*i - 1
    System.write("%(j) ")
}

System.print("\n")

// Do the same using a 'while' loop.
var k = 1
while (k < 20) {
    System.write("%(k) ")
    k = k + 2
}
System.print()</syntaxhighlight>
{{out}}
<pre>
1 3 5 7 9 11 13 15 17 19 

1 3 5 7 9 11 13 15 17 19 
</pre>
<br>
{{libheader|Wren-iterate}}
A further and more general approach is to use a wrapper class (such as the one in the above module) which can iterate over any sequence in a stepped fashion using Wren's ''iterator protocol''. 
<syntaxhighlight lang="wren">import "./iterate" for Stepped

// Print odd numbers under 20.
for (i in Stepped.new(1..20, 2)) System.write("%(i) ")
System.print()

// Print first plus every third element thereafter.
for (i in Stepped.new(1..20, 3)) System.write("%(i) ")
System.print()</syntaxhighlight>

{{out}}
<pre>
1 3 5 7 9 11 13 15 17 19 
1 4 7 10 13 16 19 
</pre>

=={{header|XPL0}}==
The 'for' loop always steps by 1 (or -1 for 'downto'). However there is
no restriction on how the control variable can be used or manipulated,
thus a step by 2 can be implemented like this:

<syntaxhighlight lang="xpl0">include c:\cxpl\codes;
int I;
[for I:= 2 to 8 do
        [IntOut(0, I);  Text(0, ", ");
        I:= I+1;
        ];
Text(0, "who do we appreciate?");
]</syntaxhighlight>

{{out}}
<pre>
2, 4, 6, 8, who do we appreciate?
</pre>

=={{header|zkl}}==
<syntaxhighlight lang="zkl">foreach n in ([1..10,4]) {println(n)}
[1..10,3].pump(Console.println)</syntaxhighlight>
{{out}}
<pre>
1
5
9

1
4
7
10
</pre>
A few others:
<syntaxhighlight lang="zkl">fcn loop(i=0){println(i); if(i<10)return(self.fcn(i+2))}
(0).pump(10,Console.println,fcn(n){if(n%2)return(Void.Skip); n})</syntaxhighlight>

=={{header|Zig}}==
<syntaxhighlight lang="zig">
const std = @import("std");

pub fn main() !void {
    const stdout_wr = std.io.getStdOut().writer();
    var i: u8 = 1;
    while (i < 10) : (i += 2)
        try stdout_wr.print("{d}\n", .{i});
}
</syntaxhighlight>

===With for-loop===
<syntaxhighlight lang="zig">
const std = @import("std");
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    for (1..10) |n| {
        if (n % 2 == 0) continue;
        try stdout.print("{d}\n", .{n});
    }
}
</syntaxhighlight>
{{out}}
<pre>
1
3
5
7
9
</pre>