Spinning rod animation/Text

Task

An animation with the following frames in the following order must animate with a delay of 0.25 seconds between each frame, with the previous frame being cleared before the next frame appears:

|
/
-
\

A version that loops and/or a version that doesn't loop can be made.

AWK[edit]

 
# syntax: GAWK -f SPINNING_ROD_ANIMATION_TEXT.AWK
@load "time"
BEGIN {
    while (1) {
      printf(" %s\r",substr("|/-\\",x++%4+1,1))
      sleep(.25)
    }
    exit(0)
}

Bash[edit]

while : ; do 
  for rod in \| / - \\ ; do printf '  %s\r' $rod; sleep 0.25; done
done

(Added an indent in the printf to better see the spinning rod).

C[edit]

Translation of: Go

#include <stdio.h>
#include <time.h>
 
int main() {
    int i, j, ms = 250;    
    const char *a = "|/-\\";
    time_t start, now;
    struct timespec delay;
    delay.tv_sec = 0;
    delay.tv_nsec = ms * 1000000L;
    printf("\033[?25l");  // hide the cursor
    time(&start);
    while(1) {
        for (i = 0; i < 4; i++) {
            printf("\033[2J");          // clear terminal
            printf("\033[0;0H");        // place cursor at top left corner
            for (j = 0; j < 80; j++) {  // 80 character terminal width, say
                printf("%c", a[i]);
            }
            fflush(stdout);
            nanosleep(&delay, NULL);
        }
        // stop after 20 seconds, say
        time(&now);
        if (difftime(now, start) >= 20) break;
    }
    printf("\033[?25h"); // restore the cursor
    return 0;
}

C Shell[edit]

while 1
  foreach rod ('|' '/' '-' '\')
    printf '  %s\r' $rod; sleep 0.25
  end
end

(Added an indent in the printf to better see the spinning rod).

GlovePIE[edit]

Because GlovePIE is a looping programming language, which means the script is ran over and over again in a looping fashion, this code loops again and again until it's stopped.

debug="|"
wait 250 ms
debug="/"
wait 250 ms
debug="-"
wait 250 ms
debug="\"
wait 250 ms

Go[edit]

Works with: Ubuntu 16.04

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    a := `|/-\`
    fmt.Printf("\033[?25l")  // hide the cursor
    start := time.Now()
    for {
        for i := 0; i < 4; i++ {
            fmt.Print("\033[2J")       // clear terminal
            fmt.Printf("\033[0;0H")    // place cursor at top left corner
            for j := 0; j < 80; j++ {  // 80 character terminal width, say
                fmt.Printf("%c", a[i])
            }
            time.Sleep(250 * time.Millisecond)
        }
        if time.Since(start).Seconds() >= 20.0 { // stop after 20 seconds, say
            break
        }
    }
    fmt.Print("\033[?25h") // restore the cursor
}

Java[edit]

Translation of: Go

public class SpinningRod
{
    public static void main(String[] args) throws InterruptedException {
        String a = "|/-\\";
        System.out.print("\033[2J");   // hide the cursor
        long start = System.currentTimeMillis();
        while (true) {
            for (int i = 0; i < 4; i++) {
                System.out.print("\033[2J");     // clear terminal
                System.out.print("\033[0;0H");   // place cursor at top left corner
                for (int j = 0; j < 80; j++) {   // 80 character terminal width, say
                    System.out.print(a.charAt(i));
                }
                Thread.sleep(250);
            }
            long now = System.currentTimeMillis();
            // stop after 20 seconds, say
            if (now - start >= 20000) break;
        }
        System.out.print("\033[?25h"); // restore the cursor
    }
}

Julia[edit]

Translation of: Python

while true
  for rod in "\|/-" # this needs to be a string, a char literal cannot be iterated over
    print(rod,'\r')
    sleep(0.25)
  end
end

Kotlin[edit]

Translation of: Go

// Version 1.2.50
 
const val ESC = "\u001b"
 
fun main(args: Array<String>) {
    val a = "|/-\\"
    print("$ESC[?25l") // hide the cursor
    val start = System.currentTimeMillis()
    while (true) {
        for (i in 0..3) {
            print("$ESC[2J")       // clear terminal
            print("$ESC[0;0H")     // place cursor at top left corner
            for (j in 0..79) {     // 80 character terminal width, say
                print(a[i])
            }
            Thread.sleep(250)
        }
        val now = System.currentTimeMillis()
        // stop after 20 seconds, say
        if (now - start >= 20000) break
    }
    print("$ESC[?25h") // restore the cursor
}

M2000 Interpreter[edit]

 
Module Checkit {
      n$=lambda$ n=1, a$="|/-\" -> {
            =mid$(a$, n, 1)
            n++
            if n>4 then n=1
      }
      \\ 1000 is 1 second
      Every 250 {
      \\ Print Over: erase line before print. No new line append.
      Print Over  n$()
      }
}
CheckIt

 
Module Checkit {
      n=1
      a$="|/-\"
      Every 250 {
            Print Over mid$(a$, n, 1)
            n++
            if n>4 then n=1      
      }
}
CheckIt

Microsoft Small Basic[edit]

a[1]="|"
a[2]="/"
a[3]="-"
a[4]="\"
b=0
While b=0
  For c=1 To 4
    TextWindow.Clear()
    TextWindow.WriteLine(a[c])
    Program.Delay(250)
  EndFor
EndWhile

Perl[edit]

The statement $| =1 is required in order to disable output buffering.

$|= 1;
 
while () {
    for (qw[ | / - \ ]) {
        select undef, undef, undef, 0.25;
        printf "\r ($_)";
    }
}

Perl 6[edit]

Works with: Rakudo version 2018.05

Traditionally these are know as throbbers or progress indicators.

This implementation will accept an array of elements to use as its throbber frames, or as a scrolling marquee and optionally a delay before it returns the next element.

class throbber {
    has @.frames;
    has $.delay is rw = 0;
    has $!index = 0;
    has Bool $.marquee = False;
    method next {
        $!index = ($!index + 1) % +@.frames;
        sleep $.delay if $.delay;
        if $!marquee {
            ("\b" x @.frames) ~ @.frames.rotate($!index).join;
        }
        else {
            "\b" ~ @.frames[$!index];
        }
    }
}
 
my $rod = throbber.new( :frames(< | / - \ >), :delay(.25) );
print "\e[?25lLong running process...  ";
print $rod.next for ^20;
 
my $clock = throbber.new( :frames("🕐" .. "🕛") );
print "\b \nSomething else with a delay...  ";
until my $done {
    # do something in a loop;
    sleep 1/12;
    print $clock.next;
    $done = True if $++ >= 60;
}
 
my $scroll = throbber.new( :frames('PLEASE STAND BY...      '.comb), :delay(.1), :marquee );
print "\b \nEXPERIENCING TECHNICAL DIFFICULTIES: { $scroll.frames.join }";
print $scroll.next for ^95;
 
END { print "\e[?25h\n" } # clean up on exit

Phix[edit]

puts(1,"please_wait... ")
cursor(NO_CURSOR)
for i=1 to 10 do    -- (approx 10 seconds)
    for j=1 to 4 do
        printf(1," \b%c\b",`|/-\`[j])
        sleep(0.25)
    end for
end for
puts(1," \ndone") -- clear rod, "done" on next line

Python[edit]

from time import sleep
while True:
    for rod in r'\|/-':
        print(rod, end='\r')
        sleep(0.25)

REXX[edit]

This REXX program would work for all REXXes if there was a common way to sleep (suspend) execution for fractional seconds.

This REXX version will work for:

Personnal REXX
PC REXX

/*REXX program displays a  "spinning rod"  (AKA:  trobbers  or  progress indicators).   */
if 4=='f4'x  then bs= "16"x                      /*EBCDIC?  Then use this backspace chr.*/
             else bs= "08"x                      /* ASCII?    "   "    "      "      "  */
signal on halt                                   /*jump to   HALT   when user halts pgm.*/
$= '│/─\'                                        /*the throbbing characters for display.*/
                  do j=1                         /*perform  until  halted by the user.  */
                  call charout ,  bs  ||  substr($, 1 + j//length($), 1)
                  call delay .25                 /*delays a quarter of a second.        */
                  end   /*j*/
halt: say bs ' '                                 /*stick a fork in it,  we're all done. */

Ring[edit]

load "stdlib.ring"
rod = ["|", "/", "-", "\"]
for n = 1 to len(rod)  
     see rod[n] + nl
     sleep(0.25)
     system("cls")
next

Output:

|
/
-
\

Scala[edit]

object SpinningRod extends App {
  val start = System.currentTimeMillis
 
  def a = "|/-\\"
 
  print("\033[2J") // hide the cursor
 
  while (System.currentTimeMillis - start < 20000) {
    for (i <- 0 until 4) {
      print("\033[2J\033[0;0H") // clear terminal, place cursor at top left corner
      for (j <- 0 until 80) print(a(i)) // 80 character terminal width, say
      Thread.sleep(250)
    }
  }
  print("\033[?25h") // restore the cursor
 
}

zkl[edit]

Translation of: C Shell

foreach n,rod in ((1).MAX, T("|", "/", "-", "\\")){
   print("  %s\r".fmt(rod));
   Atomic.sleep(0.25);
}

A loop foreach a,b in (c,d) translates to foreach a in (c) foreach b in (d). n.MAX is a 64 bit int (9223372036854775807).

A more useful example would be a worker thread showing a "I'm working" display (in another thread) and turning it off when that work is done.

fcn spin{	// this will be a thread that displays spinner
   try{
      foreach n,rod in ((1).MAX, "\\|/-"){
         print("  ",rod,"\r");
	 Atomic.sleep(0.25);
      }
   }catch{}	// don't complain about uncaught exception that stops thread
}

// main body of code
spinner:=spin.launch();	 // start spinner thread, returns reference to thread
Atomic.sleep(10);	 // do stuff
vm.kick(spinner.value);  // stop thread by throwing exception at it

Spinning rod animation/Text

Contents

AWK[edit]

Bash[edit]

C[edit]

C Shell[edit]

GlovePIE[edit]

Go[edit]

Java[edit]

Julia[edit]

Kotlin[edit]

M2000 Interpreter[edit]

Microsoft Small Basic[edit]

Perl[edit]

Perl 6[edit]

Phix[edit]

Python[edit]

REXX[edit]

Ring[edit]

Scala[edit]

zkl[edit]