Terminal control/Clear the screen

From Rosetta Code
< Terminal control
Revision as of 15:56, 31 May 2015 by rosettacode>Byaruhaf (Modified Erlang)
Task
Terminal control/Clear the screen
You are encouraged to solve this task according to the task description, using any language you may know.

Clear the terminal window.

Ada

For systems with ANSI terminal handling:

<lang Ada>with Ada.Text_IO; procedure CLS is begin 

  Ada.Text_IO.Put(ASCII.ESC & "[2J");

end CLS;</lang>

AutoHotkey

Reference: http://www.autohotkey.com/forum/topic76532.html <lang AHK>RunWait %comspec% /c cls</lang>

AWK

<lang awk>system("clear")</lang>

BASIC

Works with: QBasic
Works with: Locomotive Basic
Works with: ZX Spectrum Basic
Works with: BBC BASIC

<lang qbasic>CLS</lang>

Applesoft BASIC

<lang ApplesoftBasic>HOME</lang>

BBC BASIC

<lang bbcbasic> CLS</lang> or <lang bbcbasic> VDU 12</lang> or <lang bbcbasic> PRINT CHR$(12);</lang>

GW-BASIC

<lang qbasic>10 CLS</lang>

PureBasic

Clears the whole console content using the current background color. <lang PureBasic>ClearConsole()</lang>

Batch File

<lang command>CLS</lang>

Blast

<lang blast>clear</lang>

Bracmat

<lang bracmat>sys$cls&</lang>

C

The C version of the Minesweeper game uses curses.

If perhaps clear screen isn't used, call the function cls to do the trick.

<lang C>void cls(void) { 

 int printf(char*,...);
 printf("%c[2J",27);

}</lang>

Here is the cheaty way no one likes only works on windows <lang C>

  1. include <stdio.h>
  2. include <stdlib.h>

void main() { 

printf ("clearing screen");
getchar();
System("cls");

} </lang>

C#

<lang csharp>System.Console.Clear();</lang>

COBOL

<lang cobol> PROGRAM-ID. blank-terminal. 

      DATA DIVISION.
      SCREEN SECTION.
      01  blank-screen BLANK SCREEN.
      
      PROCEDURE DIVISION.
          DISPLAY blank-screen

          GOBACK
          .</lang>

D

<lang d>extern (C) nothrow { 

   void disp_open();
   void disp_move(int, int);
   void disp_eeop();
   void disp_close();

}

void main() { 

   disp_open();
   disp_move(0, 0);
   disp_eeop();
   disp_close();

}</lang>

Erlang

<lang Erlang> clear()->io:format(os:cmd("clear")). </lang>

Euphoria

<lang Euphoria>clear_screen()</lang>

F#

<lang fsharp>open System

Console.Clear()</lang>

Forth

<lang forth>page</lang>

Fortran

Fortran 2008: <lang forth>call execute_command_line('clear')</lang>

Go

External command

Probably most reliable way to clear the screen. <lang go>package main

import ( 

   "os"
   "os/exec"

)

func main() { 

   c := exec.Command("clear")
   c.Stdout = os.Stdout
   c.Run()

}</lang>

ANSI escape code

Simplest, if your terminal supports the ANSI code you want. <lang go>package main

import "fmt"

func main() { 

   fmt.Print("\033[2J")

}</lang>

Ncurses

More complex, but works across multiple terminal types.

Library: curses

<lang go>package main

import ( 

   "log"
   "time"

   "code.google.com/p/goncurses"

)

func main() { 

   s, err := goncurses.Init()
   if err != nil {
       log.Fatal("goncurses:", err)
   }
   defer goncurses.End()
   s.Println("Clearing screen...")
   s.Refresh()
   time.Sleep(1 * time.Second)

   s.Clear() // clear screen

   // Goncurses saves the screen on Init and restores it on End.  This
   // GetChar() allows you to see the effect of the program before it exits.
   s.GetChar() // press any key to continue

}</lang>

GUISS

This will only work if the terminal is sitting at a prompt. <lang guiss>Window:Terminal,Type:clear[enter]</lang>

Haskell

<lang Haskell> import System.Console.ANSI

main = clearScreen </lang>

Icon and Unicon

Example works for both Icon and Unicon. Determine which system command to call by querying &features at run time. Alternately, the related preprocessor symbols can be used to select the operating system. <lang Icon>procedure main () 

 if &features == "MS Windows" then system("cls")  # Windows
 else if &features == "UNIX" then system("clear") # Unix

end</lang>

J

Note: this is specific the java+gdi based J ide. <lang j>smwrite_jijs_ </lang>

Java

Using the ANSI escape sequence: <lang java>public class Clear { 

   public static void main (String[] args)
   {
       System.out.print("\033[2J");
   }

}</lang> An alternative sequence: <lang java>public class Clear { 

   public static void main (String[] args)
   {
       System.out.print("\033\143");
   }

}</lang>

Lasso

<lang Lasso>local( esc = decode_base64('Gw==') )

stdout(#esc + '[2J')</lang>

<lang logo>cleartext</lang> There is a separate command to reset the turtle graphics window. <lang logo>clearscreen cs  ; abbreviation for clearscreen clean  ; like cs, but doesn't reset turtle position</lang>

Lua

<lang lua>os.execute( "clear" )</lang> will not work because "clear" is not a command although you can use <lang lua>os.execute( "cls" )</lang>

Mathematica

Delegating to clear on terminal enabled OS(Mac Os, Linux) <lang Mathematica>Run["clear"];</lang>

Nemerle

Exactly as C#. Because of possible (probable) ambiguity, this is one time it may be prudent to use: <lang Nemerle>Console.Clear();</lang> rather than importing the Console class with using System.Console; and calling as: <lang Nemerle>Clear();</lang>

Nim

<lang nim>import osproc discard execCmd "clear"</lang>

OCaml

Using the library ANSITerminal:

<lang ocaml>#load "unix.cma"

  1. directory "+ANSITerminal"
  2. load "ANSITerminal.cma"

open ANSITerminal

let () = 

 erase Screen</lang>

Octave

<lang Octave> system clear;</lang> <lang Octave> system('clear');</lang>

Pascal

<lang Pascal>clrscr;</lang>

Perl

Assuming some ANSI terminal, easiest way is call your system's clear command: <lang perl>system('clear')</lang>

If it's needed often: <lang perl>$clear = `clear`; # clear simply prints some escape sequence, cache it

  1. ... later:

print $clear;</lang>

We can also obtain the sequence using the Term::Cap module:

<lang perl>use Term::Cap;

$terminal = Term::Cap->Tgetent(); $clear = $terminal->Tputs('cl'); print $clear;</lang>

Perl 6

<lang perl6>sub clear { print state $ = qx[clear] } clear;</lang>

PicoLisp

<lang PicoLisp>(call 'clear)</lang>

PowerShell

<lang powershell>Clear-Host</lang>

ProDOS

<lang ProDOS>clearscurrentscreentext</lang>

Python

Works with: Python version 2.6
Works with: Ubuntu version 10.10

To clear the screen on windows, replace 'clear' with 'cls'

<lang python> import os os.system('clear') </lang>

or similar to C example

<lang python> print "%c[2J" % (27) </lang>

Racket

<lang racket>

  1. lang racket

(require (planet neil/charterm:3:0)) (with-charterm 

(void (charterm-clear-screen)))

</lang>

Retro

<lang Retro>clear</lang>

REXX

generic

The REXX programming language does not include a facility to clear the screen natively.

However, it is possile to execute an external system command to achieve this task.

Below is some generic-type boilerplate (REXX) code which (possibly) determines:

  • which REXX is being used
  • which operating system is being used
  • which (external) program to clear the screen


Also, not germane to this Rosetta Code task, the boilerplate code also possibly determines (among other things):

  • if a particular documentation is to be shown
  • which system pool name is to be used for system environmental variables
  • which version of REXX is being used
  • if the program is being invoked as a function, command, or subroutine


The following code works for:

  • PC/REXX
  • Personal REXX
  • CMS REXX
  • TSO REXX
  • R4 REXX
  • ROO REXX
  • KEXX
  • REXX compiler
  • Regina REXX


The intent of the program's boilerplate code is to be able to be executed under most REXXes under most operating systems without changing the boilerplate REXX code. <lang rexx>/*REXX boilerplate determines how to clear screen (under various REXXes)*/ trace off; parse arg ! /*turn off tracing; get C.L. args*/ if !all(arg()) then exit /*Doc request? Show, then exit.*/ if !cms then address /*Is this CMS? Use this address.*/

!cls /*clear the (terminal) screen. */ /* ◄═══ this is where "it" happens.*/

exit /*stick a fork in it, we're done.*/ /*═════════════════════════════general 1-line subs══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════*/ !all:  !!=!;!=space(!);upper !;call !fid;!nt=right(!var('OS'),2)=='NT';!cls=word('CLS VMFCLEAR CLRSCREEN',1+!cms+!tso*2);if arg(1)\==1 then return 0;if wordpos(!,'? ?SAMPLES ?AUTHOR ?FLOW')==0 then return 0;!call=']$H';call '$H' !fn !;!call=;return 1 !cal: if symbol('!CALL')\=="VAR" then !call=; return !call !env: !env='ENVIRONMENT'; if !sys=='MSDOS'|!brexx|!r4|!roo then !env='SYSTEM'; if !os2 then !env='OS2'!env; !ebcdic=1=='f0'x; if !crx then !env='DOS'; return !fid: parse upper source !sys !fun !fid . 1 . . !fn !ft !fm .; call !sys; if !dos then do; _=lastpos('\',!fn); !fm=left(!fn,_); !fn=substr(!fn,_+1); parse var !fn !fn '.' !ft; end; return word(0 !fn !ft !fm,1+('0'arg(1))) !rex: parse upper version !ver !vernum !verdate .; !brexx='BY'==!vernum; !kexx='KEXX'==!ver; !pcrexx='REXX/PERSONAL'==!ver|'REXX/PC'==!ver; !r4='REXX-R4'==!ver; !regina='REXX-REGINA'==left(!ver,11); !roo='REXX-ROO'==!ver; call !env; return !sys: !cms=!sys=='CMS'; !os2=!sys=='OS2'; !tso=!sys=='TSO'|!sys=='MVS'; !vse=!sys=='VSE'; !dos=pos('DOS',!sys)\==0|pos('WIN',!sys)\==0|!sys=='CMD'; !crx=left(!sys,6)=='DOSCRX'; call !rex; return !var: call !fid; if !kexx then return space(dosenv(arg(1))); return space(value(arg(1),,!env))</lang>

Regina

The regina interpreter supports the rexxcurses plugin, which provides a facility to clear the screen (not shown here).

Scala

Library: Scala

<lang Scala>object Cls extends App {print("\033[2J")}</lang>

Ruby

<lang Ruby>system 'clear'</lang>

Or, without reliance on the command line: (equivalent to `clear`) <lang Ruby>puts "\e[H\e[2J"</lang>

Seed7

The function clear is portable and clears the console window. Clear is based on terminfo respectively the Windows console API. A portable function to clear cannot rely on shell respectively cmd.exe commands, because Windows uses CLS and Unix shells use CLEAR, to clear a screen. ANSI terminal escape sequences are also not 100% portable, since not all terminals accept them.

<lang seed7>$ include "seed7_05.s7i"; 

 include "console.s7i";

const proc: main is func 

 local
   var text: console is STD_NULL;
 begin
   console := open(CONSOLE);
   clear(console);
   # Terminal windows often restore the previous
   # content, when a program is terminated. Therefore
   # the program waits until Return/Enter is pressed.
   readln;
 end func;</lang>

Smalltalk

<lang smalltalk>Transcript clear.</lang>

Tcl

This only works on systems with ANSI terminal handling, i.e., Unix platforms. <lang tcl>puts -nonewline "\033\[2J" flush stdout</lang>

UNIX Shell

The clear command can be used to clear the terminal screen:

Works with: Bourne Shell

<lang bash>clear

  1. Alternative method using tput

tput clear</lang>

XPL0

<lang XPL0>code Clear=40; Clear;</lang>

zkl

<lang zkl>System.cmd(System.isWindows and "cls" or "clear"); // or, for ANSI terminals: print("\e[2J")</lang>

Retrieved from "https://rosettacode.org/wiki/Terminal_control/Clear_the_screen?oldid=159313"