Rosetta Code

Terminal control/Clear the screen

< Terminal control
Revision as of 03:08, 31 October 2015 by Petelomax (talk | contribs) (→‎{{header|Phix}})

Clear the terminal window.

Task
Terminal control/Clear the screen
You are encouraged to solve this task according to the task description, using any language you may know.

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

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>

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) { 

 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>

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 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>

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>

<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"

  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>

Phix

<lang Phix>clear_screen()</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>

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:

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=159320"