Terminal control/Clear the screen
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
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>
Axe
<lang axe>ClrHome</lang>
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>
beeswax
Using the ANSI escape sequence Esc[2J
.
<lang beeswax>_3F..}`[2J`</lang>
Befunge
Assuming a terminal with support for ANSI escape sequences. <lang befunge>"J2["39*,,,,@</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) {
printf("\33[2J");
}</lang>
Here is the cheaty way no one likes, only works on Windows.
<lang C>#include <stdio.h>
- 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>
Comal
<lang Comal>PAGE</lang>
Common Lisp
<lang lisp> (format t "~C[2J" #\Esc) </lang> or it could be done passing the 'clear' command to the shell <lang lisp> (defun sh (cmd)
"A multi-implementation function equivalent for the C function system" #+clisp (shell cmd) #+ecl (si:system cmd) #+sbcl (sb-ext:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*) #+clozure (ccl:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*))
(sh "clear") </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 fortran>program clear
character(len=:), allocatable :: clear_command clear_command = "clear" !"cls" on Windows, "clear" on Linux and alike call execute_command_line(clear_command)
end program</lang>
Intel Fortran on Windows
Using console functions, one can also clear the screen without using a system command. See also Clearing the Screen on MSDN.
<lang fortran>program clear
use kernel32 implicit none integer(HANDLE) :: hStdout hStdout = GetStdHandle(STD_OUTPUT_HANDLE) call clear_console(hStdout)
contains
subroutine clear_console(hConsole) integer(HANDLE) :: hConsole type(T_COORD) :: coordScreen = T_COORD(0, 0) integer(DWORD) :: cCharsWritten type(T_CONSOLE_SCREEN_BUFFER_INFO) :: csbi integer(DWORD) :: dwConSize if (GetConsoleScreenBufferInfo(hConsole, csbi) == 0) return dwConSize = csbi%dwSize%X * csbi%dwSize%Y if (FillConsoleOutputCharacter(hConsole, SCHAR_" ", dwConSize, & coordScreen, loc(cCharsWritten)) == 0) return
if (GetConsoleScreenBufferInfo(hConsole, csbi) == 0) return if (FillConsoleOutputAttribute(hConsole, csbi%wAttributes, & dwConSize, coordScreen, loc(cCharsWritten)) == 0) return if (SetConsoleCursorPosition(hConsole, coordScreen) == 0) return end subroutine
end program</lang>
GNU Fortran on Windows
The preceding program can be compiled with GNU Fortran, with the following interface module for Windows API.
<lang fortran>module kernel32
use iso_c_binding implicit none integer, parameter :: HANDLE = C_INTPTR_T integer, parameter :: PVOID = C_INTPTR_T integer, parameter :: LPDWORD = C_INTPTR_T integer, parameter :: BOOL = C_INT integer, parameter :: SHORT = C_INT16_T integer, parameter :: WORD = C_INT16_T integer, parameter :: DWORD = C_INT32_T integer, parameter :: SCHAR = C_CHAR integer(DWORD), parameter :: STD_INPUT_HANDLE = -10 integer(DWORD), parameter :: STD_OUTPUT_HANDLE = -11 integer(DWORD), parameter :: STD_ERROR_HANDLE = -12
type, bind(C) :: T_COORD integer(SHORT) :: X, Y end type type, bind(C) :: T_SMALL_RECT integer(SHORT) :: Left integer(SHORT) :: Top integer(SHORT) :: Right integer(SHORT) :: Bottom end type
type, bind(C) :: T_CONSOLE_SCREEN_BUFFER_INFO type(T_COORD) :: dwSize type(T_COORD) :: dwCursorPosition integer(WORD) :: wAttributes type(T_SMALL_RECT) :: srWindow type(T_COORD) :: dwMaximumWindowSize end type
interface function FillConsoleOutputCharacter(hConsoleOutput, cCharacter, & nLength, dwWriteCoord, lpNumberOfCharsWritten) & bind(C, name="FillConsoleOutputCharacterA") import BOOL, C_CHAR, SCHAR, HANDLE, DWORD, T_COORD, LPDWORD !GCC$ ATTRIBUTES STDCALL :: FillConsoleOutputCharacter integer(BOOL) :: FillConsoleOutputCharacter integer(HANDLE), value :: hConsoleOutput character(kind=SCHAR), value :: cCharacter integer(DWORD), value :: nLength type(T_COORD), value :: dwWriteCoord integer(LPDWORD), value :: lpNumberOfCharsWritten end function end interface
interface function FillConsoleOutputAttribute(hConsoleOutput, wAttribute, & nLength, dwWriteCoord, lpNumberOfAttrsWritten) & bind(C, name="FillConsoleOutputAttribute") import BOOL, HANDLE, WORD, DWORD, T_COORD, LPDWORD !GCC$ ATTRIBUTES STDCALL :: FillConsoleOutputAttribute integer(BOOL) :: FillConsoleOutputAttribute integer(HANDLE), value :: hConsoleOutput integer(WORD), value :: wAttribute integer(DWORD), value :: nLength type(T_COORD), value :: dwWriteCoord integer(LPDWORD), value :: lpNumberOfAttrsWritten end function end interface interface function GetConsoleScreenBufferInfo(hConsoleOutput, & lpConsoleScreenBufferInfo) & bind(C, name="GetConsoleScreenBufferInfo") import BOOL, HANDLE, T_CONSOLE_SCREEN_BUFFER_INFO !GCC$ ATTRIBUTES STDCALL :: GetConsoleScreenBufferInfo integer(BOOL) :: GetConsoleScreenBufferInfo integer(HANDLE), value :: hConsoleOutput type(T_CONSOLE_SCREEN_BUFFER_INFO) :: lpConsoleScreenBufferInfo end function end interface interface function SetConsoleCursorPosition(hConsoleOutput, dwCursorPosition) & bind(C, name="SetConsoleCursorPosition") import BOOL, HANDLE, T_COORD !GCC$ ATTRIBUTES STDCALL :: SetConsoleCursorPosition integer(BOOL) :: SetConsoleCursorPosition integer(HANDLE), value :: hConsoleOutput type(T_COORD), value :: dwCursorPosition end function end interface interface function GetStdHandle(nStdHandle) bind(C, name="GetStdHandle") import HANDLE, DWORD !GCC$ ATTRIBUTES STDCALL :: GetStdHandle integer(HANDLE) :: GetStdHandle integer(DWORD), value :: nStdHandle end function end interface
end module </lang>
FreeBASIC
<lang freebasic>' FB 1.05.0 Win64
' FreeBASIC has a built in Cls command which clears the console on Windows ' but it may still be possible to scroll the console to view its ' previous contents. The following command prevents this.
Shell("Cls") Sleep</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.
<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>
jq
<lang jq>"\u001B[2J"</lang> Example: <lang sh>$ jq -n '"\u001B[2J"'</lang>
Lasso
<lang Lasso>local( esc = decode_base64('Gw==') )
stdout(#esc + '[2J')</lang>
Logo
<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>
NewLISP
<lang NewLISP> (! "clear") </lang> In the newLISP command shell, this syntax is also proper: <lang NewLISP> !clear </lang>
Nim
<lang nim>import osproc discard execCmd "clear"</lang>
OCaml
Using the library ANSITerminal:
<lang ocaml>#load "unix.cma"
- directory "+ANSITerminal"
- 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
- ... 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>
Phix
<lang Phix>clear_screen()</lang>
PicoLisp
<lang PicoLisp>(call 'clear)</lang>
PowerShell
<lang powershell>Clear-Host</lang>
ProDOS
<lang ProDOS>clearscurrentscreentext</lang>
Python
To clear the screen on Windows, replace 'clear' with 'cls'
<lang python>import os os.system("clear")</lang>
Or similar to C example (won't work in Winsows console, since it does not recognize ANSI sequences):
<lang python>print "\33[2J"</lang>
On Windows, using functions from the kernel32 DLL:
<lang python>from ctypes import *
STD_OUTPUT_HANDLE = -11
class COORD(Structure):
pass
COORD._fields_ = [("X", c_short), ("Y", c_short)]
class SMALL_RECT(Structure):
pass
SMALL_RECT._fields_ = [("Left", c_short), ("Top", c_short), ("Right", c_short), ("Bottom", c_short)]
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
pass
CONSOLE_SCREEN_BUFFER_INFO._fields_ = [
("dwSize", COORD), ("dwCursorPosition", COORD), ("wAttributes", c_ushort), ("srWindow", SMALL_RECT), ("dwMaximumWindowSize", COORD)
]
def clear_console():
h = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
csbi = CONSOLE_SCREEN_BUFFER_INFO() windll.kernel32.GetConsoleScreenBufferInfo(h, pointer(csbi)) dwConSize = csbi.dwSize.X * csbi.dwSize.Y
scr = COORD(0, 0) windll.kernel32.FillConsoleOutputCharacterA(h, c_char(b" "), dwConSize, scr, pointer(c_ulong())) windll.kernel32.FillConsoleOutputAttribute(h, csbi.wAttributes, dwConSize, scr, pointer(c_ulong())) windll.kernel32.SetConsoleCursorPosition(h, scr)
clear_console()</lang>
Racket
<lang racket>
- 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
<lang Scala>object Cls extends App {print("\033[2J")}</lang>
Ring
<lang Ring>system('clear')</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>
Sidef
Using a cached-function: <lang ruby>func clear { print(static x = `clear`) }; clear();</lang>
Directly invoking the `clear` command: <lang ruby>Sys.run('clear');</lang>
Alternatively, without reliance on the command line: <lang ruby>print "\e[3J\e[H\e[2J";</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:
<lang bash>clear
- 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>
- Programming Tasks
- Terminal control
- Initialization
- Ada
- AutoHotkey
- AWK
- Axe
- BASIC
- Applesoft BASIC
- BBC BASIC
- GW-BASIC
- PureBasic
- Batch File
- Beeswax
- Befunge
- Blast
- Bracmat
- C
- C sharp
- COBOL
- Comal
- Common Lisp
- D
- Erlang
- Euphoria
- F Sharp
- Forth
- Fortran
- FreeBASIC
- Go
- Curses
- GUISS
- Haskell
- Icon
- Unicon
- J
- Java
- Jq
- Lasso
- Logo
- Lua
- Mathematica
- Nemerle
- NewLISP
- Nim
- OCaml
- Octave
- Pascal
- Perl
- Perl 6
- Phix
- PicoLisp
- PowerShell
- ProDOS
- Python
- Racket
- Retro
- REXX
- Scala
- Ring
- Ruby
- Seed7
- Sidef
- Smalltalk
- Tcl
- UNIX Shell
- XPL0
- Zkl
- ACL2/Omit
- Maxima/Omit
- PARI/GP/Omit
- Inform 7/Omit