text:
Command-line interface
From Wikipedia, the free encyclopedia
Jump to: navigation, search
Not to be confused with Text-based user interface.
[hide]This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages)
This article includes a list of references, but its sources remain unclear because it has insufficient inline citations. Please help to improve this article by introducing more precise citations. (January 2016) (Learn how and when to remove this template message)
This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (January 2016) (Learn how and when to remove this template message)
(Learn how and when to remove this template message)
Screenshot of a sample bash session in GNOME Terminal 3, Fedora 15
Screenshot of Windows PowerShell 1.0, running on Windows Vista
A command-line interface or command language interpreter (CLI), also known as command-line user interface, console user interface[1] and character user interface (CUI), is a means of interacting with a computer program where the user (or client) issues commands to the program in the form of successive lines of text (command lines). A program which handles the interface is called a command language interpreter or shell.
The CLI was the primary means of interaction with most computer systems on computer terminals in the mid-1960s, and continued to be used throughout the 1970s and 1980s on OpenVMS, Unix systems and personal computer systems including MS-DOS, CP/M and Apple DOS. The interface is usually implemented with a command line shell, which is a program that accepts commands as text input and converts commands into appropriate operating system functions.
Command-line interfaces to computer operating systems are less widely used by casual computer users, who favor graphical user interfaces or menu-driven interaction.
Alternatives to the command line include, but are not limited to text user interface menus (see IBM AIX SMIT for example), keyboard shortcuts, and various other desktop metaphors centered on the pointer (usually controlled with a mouse). Examples of this include the Windows versions 1, 2, 3, 3.1, and 3.11 (an OS shell that runs in DOS), DosShell, and Mouse Systems PowerPanel.
Command-line interfaces are often preferred by more advanced computer users, as they often provide a more concise and powerful means to control a program or operating system.
Programs with command-line interfaces are generally easier to automate via scripting.
Command line interfaces for software other than operating systems include a number of programming languages such as Tcl/Tk, PHP and others, as well as utilities such as the compression utilities WinZip and UltimateZip, and some FTP and ssh/telnet clients.
Contents
[hide]
1 Comparison to graphical user interfaces
2 Operating system command-line interfaces
3 Application command-line interfaces
4 History
5 Usage
6 Anatomy of a shell CLI
6.1 CLI and resource protection
6.2 Command prompt
6.3 Arguments
6.3.1 Command-line option
6.3.1.1 Abbreviating commands
6.3.1.2 Option conventions in DOS, Windows, OS/2
6.3.1.3 Option conventions in Unix-like systems
6.3.1.4 Options conventions in other systems
6.4 Built-in usage help
6.5 Command description syntax
6.6 The space character
7 Command-line interpreter
7.1 Early history
7.2 Modern usage as an operating system shell
8 Scripting
9 Other command-line interfaces
10 See also
10.1 Concepts
10.2 Uses
10.3 Miscellaneous
11 References
12 External links
Comparison to graphical user interfaces[edit]
Screenshot of Apple Computer's CommandShell in A/UX 3.0.1
Compared with a graphical user interface,a command line requires fewer system resources to implement. Since options to commands are given in a few characters in each command line, an experienced user finds the options easier to access. Automation of repetitive tasks is simplified - most operating systems using a command line interface support some mechanism for storing frequently used sequences in a disk file, for re-use; this may extend to a scripting language that can take parameters and variable options. A command-line history can be kept, allowing review or repetition of commands.
A command-line system may require paper or on-line manuals for the user's reference, although often a "help" option provides a concise review of the options of a command. The command line environment may not provide the graphical enhancements such as different fonts or extended edit windows found in a GUI. It may be difficult for a new user to become familiar with all the commands and options available, compared with the drop-down menus of a graphical user interface, without repeated reference to manuals.
Operating system command-line interfaces[edit]
Operating system (OS) command line interfaces are usually distinct programs supplied with the operating system. A program that implements such a text interface is often called a command-line interpreter, command processor or shell.
Examples of command-line interpreters include DEC's DIGITAL Command Language (DCL) in OpenVMS and RSX-11, the various Unix shells (sh, ksh, csh, tcsh, bash, etc.), the historical CP/M CCP, and MS-DOS/IBM-DOS/DR-DOS's COMMAND.COM, as well as the OS/2 and the Windows CMD.EXE programs, the latter groups being based heavily on DEC's RSX-11 and RSTS CLIs. Under most operating systems, it is possible to replace the default shell program with alternatives; examples include 4DOS for DOS, 4OS2 for OS/2, and 4NT or Take Command for Windows.
Although the term 'shell' is often used to describe a command-line interpreter, strictly speaking a 'shell' can be any program that constitutes the user-interface, including fully graphically oriented ones. For example, the default Windows GUI is a shell program named EXPLORER.EXE, as defined in the SHELL=EXPLORER.EXE line in the WIN.INI configuration file. These programs are shells, but not CLIs.
Application command-line interfaces[edit]
Application programs (as opposed to operating systems) may also have command line interfaces.
An application program may support none, any, or all of these three major types of command line interface mechanisms:
Parameters: Most operating systems support a means to pass additional information to a program when it is launched. When a program is launched from an OS command line shell, additional text provided along with the program name is passed to the launched program.
Interactive command line sessions: After launch, a program may provide an operator with an independent means to enter commands in the form of text.
OS inter-process communication: Most operating systems support means of inter-process communication (for example; standard streams or named pipes). Command lines from client processes may be redirected to a CLI program by one of these methods.
Some applications support only a CLI, presenting a CLI prompt to the user and acting upon command lines as they are entered. Other programs support both a CLI and a GUI. In some cases, a GUI is simply a wrapper around a separate CLI executable file. In other cases, a program may provide a CLI as an optional alternative to its GUI. CLIs and GUIs often support different functionality. For example, all features of MATLAB, a numerical analysis computer program, are available via the CLI, whereas the MATLAB GUI exposes only a subset of features.
The early Sierra games, like the first three King's Quest games (1984–1986), used commands from an internal command line to move the character around in the graphic window.
History[edit]
The command-line interface evolved from a form of dialog once conducted by humans over teleprinter (TTY) machines, in which human operators remotely exchanged information, usually one line of text at a time. Early computer systems often used teleprinter machines as the means of interaction with a human operator. The computer became one end of the human-to-human teleprinter model. So instead of a human communicating with another human over a teleprinter, a human communicated with a computer.
The mechanical teleprinter was replaced by a "glass tty", a keyboard and screen emulating the teleprinter. "Smart" terminals permitted additional functions, such as cursor movement over the entire screen, or local editing of data on the terminal for transmission to the computer. As the microcomputer revolution replaced the traditional – minicomputer + terminals – time sharing architecture, hardware terminals were replaced by terminal emulators — PC software that interpreted terminal signals sent through the PC's serial ports. These were typically used to interface an organization's new PC's with their existing mini- or mainframe computers, or to connect PC to PC. Some of these PCs were running Bulletin Board System software.
Early operating system CLIs were implemented as part of resident monitor programs, and could not easily be replaced. The first implementation of the shell as a replaceable component was part of the Multics time-sharing operating system.[2]In 1964, MIT Computation Center staff member Louis Pouzin developed the RUNCOM tool for executing command scripts while allowing argument substitution.[3] Pouzin coined the term "shell" to describe the technique of using commands like a programming language, and wrote a paper about how to implement the idea in the Multics operating system.[4] Pouzin returned to his native France in 1965, and the first Multics shell was developed by Glenda Schroeder.[3]
The first Unix shell, the V6 shell, was developed by Ken Thompson in 1971 at Bell Labs and was modeled after Schroeder's Multics shell.[5][6] The Bourne shell was introduced in 1977 as a replacement for the V6 shell. Although it is used as an interactive command interpreter, it was also intended as a scripting language and contains most of the features that are commonly considered to produce structured programs. The Bourne shell led to the development of the Korn shell (ksh), Almquist shell (ash), and the popular Bourne-again shell (or Bash).[6]
Early microcomputers themselves were based on a command-line interface such as CP/M, MS-DOS or AppleSoft BASIC. Throughout the 1980s and 1990s—especially after the introduction of the Apple Macintosh and Microsoft Windows—command line interfaces were replaced in popular usage by the Graphical User Interface. The command line remains in use, however, by system administrators and other advanced users for system administration, computer programming, and batch processing.
In November 2006, Microsoft released version 1.0 of Windows PowerShell (formerly codenamed Monad), which combined features of traditional Unix shells with their proprietary object-oriented .NET Framework. MinGW and Cygwin are open-source packages for Windows that offer a Unix-like CLI. Microsoft provides MKS Inc.'s ksh implementation MKS Korn shell for Windows through their Services for UNIX add-on.
Since 2001, the Macintosh operating system is based on a variation of Unix called Darwin. On these computers, users can access a Unix-like command-line interface called Terminal found in the Applications Utilities folder. This terminal uses bash by default.
Screenshot of the MATLAB 7.4 command-line interface and GUI
Usage[edit]
This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (April 2015) (Learn how and when to remove this template message)
A CLI is used whenever a large vocabulary of commands or queries, coupled with a wide (or arbitrary) range of options, can be entered more rapidly as text than with a pure GUI. This is typically the case with operating system command shells. CLIs are also used by systems with insufficient resources to support a graphical user interface. Some computer language systems (such as Python, Forth, LISP, Rexx, and many dialects of BASIC) provide an interactive command-line mode to allow for rapid evaluation of code.
CLIs are often used by programmers and system administrators, in engineering and scientific environments, and by technically advanced personal computer users. CLIs are also popular among people with visual disability, since the commands and responses can be displayed using Refreshable Braille displays.
Anatomy of a shell CLI[edit]
This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (July 2015) (Learn how and when to remove this template message)
The general pattern of an OS command line interface[7][8] is:
Prompt command param1 param2 param3 ... paramN
Prompt - generated by the program to provide context for the client.
Command — provided by the client. Commands are usually one of three classes:
Internal — recognized and processed by the command line interpreter itself and not dependent upon any external executable file.
Included — A separate executable file generally considered part of the operating environment and always included with the OS.
External — External executable files not part of the basic OS, but added by other parties for specific purposes and applications.
param1 ...paramN — Optional parameters provided by the client. The format and meaning of the parameters depends upon the command issued. In the case of Included or External commands, the values of the parameters are delivered to the program (specified by the Command) as it is launched by the OS. Parameters may be either Arguments or Options.
In this example, the delimiters between command line elements are whitespace characters and the end-of-line delimiter is the newline delimiter. This is a widely used (but not universal) convention for command-line interfaces.
A CLI can generally be considered as consisting of syntax and semantics. The syntax is the grammar that all commands must follow. In the case of operating systems (OS), MS-DOS and Unix each define their own set of rules that all commands must follow. In the case of embedded systems, each vendor, such as Nortel, Juniper Networks or Cisco Systems, defines their own proprietary set of rules that all commands within their CLI conform to. These rules also dictate how a user navigates through the system of commands. The semantics define what sort of operations are possible, on what sort of data these operations can be performed, and how the grammar represents these operations and data—the symbolic meaning in the syntax.
Two different CLIs may agree on either syntax or semantics, but it is only when they agree on both that they can be considered sufficiently similar to allow users to use both CLIs without needing to learn anything, as well as to enable re-use of scripts.
A simple CLI will display a prompt, accept a "command line" typed by the user terminated by the Enter key, then execute the specified command and provide textual display of results or error messages. Advanced CLIs will validate, interpret and parameter-expand the command line before executing the specified command, and optionally capture or redirect its output.
Unlike a button or menu item in a GUI, a command line is typically self-documenting, stating exactly what the user wants done. In addition, command lines usually include many defaults that can be changed to customize the results. Useful command lines can be saved by assigning a character string or alias to represent the full command, or several commands can be grouped to perform a more complex sequence – for instance, compile the program, install it, and run it — creating a single entity, called a command procedure or script which itself can be treated as a command. These advantages mean that a user must figure out a complex command or series of commands only once, because they can be saved, to be used again.
The commands given to a CLI shell are often in one of the following forms:
doSomething how toFiles
doSomething how sourceFile destinationFile
doSomething how < inputFile > outputFile
doSomething how | doSomething how | doSomething how > outputFile
where doSomething is, in effect, a verb, how an adverb (for example, should the command be executed "verbosely" or "quietly") and toFiles an object or objects (typically one or more files) on which the command should act. The > in the third example is a redirection operator, telling the command-line interpreter to send the output of the command not to its own standard output (the screen) but to the named file. This will overwrite the file. Using >> will redirect the output and append it to the file. Another redirection operator is the vertical bar (|), which creates a pipeline where the output of one command becomes the input to the next command.
CLI and resource protection[edit]
One can modify the set of available commands by modifying which paths appear in the PATH environment variable. Under Unix, commands also need be marked as executable files. The directories in the path variable are searched in the order they are given. By re-ordering the path, one can run e.g. \OS2\MDOS\E.EXE instead of \OS2\E.EXE, when the default is the opposite. Renaming of the executables also works: people often rename their favourite editor to EDIT, for example.
The command line allows one to restrict available commands, such as access to advanced internal commands. The Windows CMD.EXE does this. Often, shareware programs will limit the range of commands, including printing a command 'your administrator has disabled running batch files' from the prompt.
Some CLIs, such as those in network routers, have a hierarchy of modes, with a different set of commands supported in each mode. The set of commands are grouped by association with security, system, interface, etc. In these systems the user might traverse through a series of sub-modes. For example, if the CLI had two modes called interface and system, the user might use the command interface to enter the interface mode. At this point, commands from the system mode may not be accessible and the user exits the interface mode and enters the system mode.
Command prompt[edit]
"Command prompt" redirects here. For the Windows component named Command Prompt, see cmd.exe.
A command prompt (or just prompt) is a sequence of (one or more) characters used in a command-line interface to indicate readiness to accept commands. It literally prompts the user to take action. A prompt usually ends with one of the characters $, %, #, :, > and often includes other information, such as the path of the current working directory and the hostname.
On many Unix and derivative systems, the prompt commonly ends in $ or % if the user is a normal user, but in # if the user is a superuser ("root" in Unix terminology).
End-users can often modify prompts. Depending on the environment, they may include colors, special characters, and other elements (like variables and functions for the current time, user, shell number or working directory) in order, for instance, to make the prompt more informative or visually pleasing, to distinguish sessions on various machines, or to indicate the current level of nesting of commands. On some systems, special tokens in the definition of the prompt can be used to cause external programs to be called by the command-line interpreter while displaying the prompt.
In DOS's COMMAND.COM and in Windows NT's cmd.exe users can modify the prompt by issuing a prompt command or by directly changing the value of the corresponding %PROMPT% environment variable. The default of most modern systems, the C:\> style is obtained, for instance, with prompt $P$G. The default of older DOS systems, C> is obtained by just prompt, although on some systems this produces the newer C:\> style, unless used on floppy drives A: or B:; on those systems prompt $N$G can be used to override the automatic default and explicitly switch to the older style.
Many Unix systems feature the $PS1 variable (Prompt String 1),[9] although other variables also may affect the prompt (depending on the shell used). In the bash shell, a prompt of the form:
[time] user@host: work_dir $
could be set by issuing the command
export PS1='[\t] \u@\H: \W $'
In zsh the $RPROMPT variable controls an optional "prompt" on the right-hand side of the display. It is not a real prompt in that the location of text entry does not change. It is used to display information on the same line as the prompt, but right-justified.
In RISC OS the command prompt is a * symbol, and thus (OS)CLI commands are often referred to as "star commands".[10] One can also access the same commands from other command lines (such as the BBC BASIC command line), by preceding the command with a *.
Arguments[edit]
An MS DOS command line, illustrating parsing into command and arguments
A command-line argument or parameter is an item of information provided to a program when it is started. A program can have many command-line arguments that identify sources or destinations of information, or that alter the operation of the program.
When a command processor is active a program is typically invoked by typing its name followed by command-line arguments (if any). For example, in Unix and Unix-like environments, an example of a command-line argument is:
rm file.s
"file.s" is a command-line argument which tells the program rm to remove the file "file.s".
Some programming languages, such as C, C++ and Java, allow a program to interpret the command-line arguments by handling them as string parameters in the main function. Other languages, such as Python, expose these arguments as global variables.
In Unix-like operating systems, a single hyphen-minus by itself is usually a special value specifying that a program should handle data coming from the standard input or send data to the standard output.
Command-line option[edit]
A command-line option or simply option (also known as a flag or switch) modifies the operation of a command; the effect is determined by the command's program. Options follow the command name on the command line, separated by spaces. A space before the first option is not always required, for example Dir/? and DIR /? have the same effect in DOS (list the DIR command's options) whereas dir --help (in many versions of Unix) does require the option to be preceded by at least one space (and is case-sensitive).
The format of options varies widely between operating systems. In most cases the syntax is by convention rather than an operating system requirement; the entire command line is simply a string passed to a program, which can process it in any way the programmer wants, so long as the interpreter can tell where the command name ends and its arguments and options begin.
A few representative samples of command-line options, all relating to listing files in a directory, to illustrate some conventions:
Operating system
Command
Valid alternative
Notes
OpenVMS directory/owner Dir /Owner instruct the directory command to also display the ownership of the files.
Note the Directory command name is not case sensitive, and can be abbreviated to as few letters as required to remain unique.
DOS dir/Q/O:S d* diR /q d* /o:s display ownership of files whose names begin with "D", sorted by size, smallest first.
Note spaces around argument d* are required.
Unix-like systems ls -lS D* ls -S -l D* display in long format files and directories beginning with "D" (but not "d"), sorted by size (largest first).
Note spaces are required around all arguments and options, but some can be run together, e.g. -lS is the same as -l -S.
Data General RDOS CLI list/e/s 04-26-80/b List /S/E 4-26-80/B list every attribute for files created before 26 April 1980.
Note the /B at the end of the date argument is a local switch, that modifies the meaning of that argument, while /S and /E are global switches, i.e. apply to the whole command.
Abbreviating commands[edit]
In Multics, command-line options and subsystem keywords may be abbreviated. This idea appears to derive from the PL/I programming language, with its shortened keywords (e.g., STRG for STRINGRANGE and DCL for DECLARE). For example, in the Multics "forum" subsystem, the -long_subject parameter can be abbreviated -lgsj. It is also common for Multics commands to be abbreviated, typically corresponding to the initial letters of the words that are strung together with underscores to form command names, such as the use of did for delete_iacl_dir.
In some other systems abbreviations are automatic, such as permitting enough of the first characters of a command name to uniquely identify it (such as SU as an abbreviation for SUPERUSER) while others may have some specific abbreviations pre-programmed (e.g. MD for MKDIR in COMMAND.COM) or user-defined via batch scripts and aliases (e.g. alias md mkdir in tcsh). See also: Tab completion.
Option conventions in DOS, Windows, OS/2[edit]
On DOS, OS/2 and Windows, different programs called from their COMMAND.COM or CMD.EXE (or internal their commands) may use different syntax within the same operating system. For example:
Options may be indicated by either of the "switch characters": -, /, or either may be allowed. See below.
They may or may not be case-sensitive.
Sometimes options and their arguments are run together, sometimes separated by whitespace, and sometimes by a character, typically : or =; thus Prog -fFilename, Prog -f Filename, Prog -f:Filename, Prog -f=Filename.
Some programs allow single-character options to be combined; others do not. The switch -fA may mean the same as -f -A, or it may be incorrect, or it may even be a valid but different parameter.
In DOS, OS/2 and Windows, the forward slash (/) is most prevalent, although the hyphen-minus is also sometimes used. In many versions of DOS (MS-DOS/PC DOS 2.xx and higher, all versions of DR-DOS since 5.0, as well as PTS-DOS, Embedded DOS, FreeDOS and RxDOS) the switch character (sometimes abbreviated switchar or switchchar) to be used is defined by a value returned from a system call (INT 21h/AH=37h). The default character returned by this API is /, but can be changed to a hyphen-minus on the above-mentioned systems, except for Datalight ROM-DOS and MS-DOS/PC DOS 5.0 and higher, which always return / from this call (unless one of many available TSRs to reenable the SwitChar feature is loaded). In some of these systems (MS-DOS/PC DOS 2.xx, DOS Plus 2.1, DR-DOS 7.02 and higher, PTS-DOS, Embedded DOS, FreeDOS and RxDOS), the setting can also be pre-configured by a SWITCHAR directive in CONFIG.SYS. Embedded DOS provides a SWITCH command for the same purpose, whereas 4DOS allows the setting to be changed via SETDOS /W:n. Under DR-DOS, if the setting has been changed from /, the first directory separator \ in the display of the PROMPT parameter $G will change to a forward slash / (which is also a valid directory separator in DOS, FlexOS, 4680 OS, 4690 OS, OS/2 and Windows) thereby serving as a visual clue to indicate the change. Some versions of DR-DOS COMMAND.COM also support a PROMPT token $/ to display the current setting. COMMAND.COM since DR-DOS 7.02 and 4DOS also provide a pseudo-environment variable named %/% to allow portable batchjobs to be written. Several external DR-DOS commands additionally support an environment variable %SWITCHAR% to override the system setting.
However, many programs are hardwired to use / only, rather than retrieving the switch setting before parsing command line arguments. A very small number, mainly ports from Unix-like systems, are programmed to accept "-" even if the switch character is not set to it (for example netstat and ping, supplied with Windows, will accept the /? option to list available options, and yet the list will specify the "-" convention).
Option conventions in Unix-like systems[edit]
This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (April 2015) (Learn how and when to remove this template message)
In Unix-like systems, the ASCII hyphen-minus begins options; the new (and GNU) convention is to use two hyphens then a word (e.g. --create) to identify the option's use while the old convention (and still available as an option for frequently-used options) is to use one hyphen then one letter (e.g. -c); if one hyphen is followed by two or more letters it may mean two options are being specified, or it may mean the second and subsequent letters are a parameter (such as filename or date) for the first option.
Two hyphen-minus characters without following letters (--) may indicate that the remaining arguments should not be treated as options, which is useful for example if a file name itself begins with a hyphen, or if further arguments are meant for an inner command (e.g. sudo). Double hyphen-minuses are also sometimes used to prefix "long options" where more descriptive option names are used. This is a common feature of GNU software. The getopt function and program, and the getopts command are usually used for parsing command-line options.
Unix command names, arguments and options are case-sensitive (except in a few examples, mainly where popular commands from other operating systems have been ported to Unix).
Options conventions in other systems[edit]
FlexOS, 4680 OS and 4690 OS use -.
CP/M typically used [.
Conversational Monitor System (CMS) uses a single left parenthesis to separate options at the end of the command from the other arguments. For example, in the following command the options indicate that the target file should be replaced if it exists, and the date and time of the source file should be retained on the copy: COPY source file a target file b (REPLACE OLDDATE
Data General's CLI under their RDOS, AOS, etc. operating systems, as well as the version of CLI that came with their Business Basic, uses only / as the switch character, is case-insensitive, and allows "local switches" on some arguments to control the way they are interpreted, such as MAC/U LIB/S A B C $LPT/L has the global option "U" to the macro assembler command to appemd user symbols, but two local switches, one to specify LIB should be skipped on pass 2 and the other to direct listing to the printer, $LPT.
Built-in usage help[edit]
This section does not cite any sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (April 2015) (Learn how and when to remove this template message)
See also: help (command)
One of the criticisms of a CLI is the lack of cues to the user as to the available actions.[citation needed] In contrast, GUIs usually inform the user of available actions with menus, icons, or other visual cues.[citation needed] To overcome this limitation, many CLI programs display a brief summary of its valid parameters, typically when invoked with no arguments or one of ?, -?, -h, -H, /?, /h, /H, -help, or --help.[citation needed]
However, entering a program name without parameters in the hope that it will display usage help can be hazardous, as some programs and scripts execute without further notice.[citation needed]
Although desirable at least for the help parameter, programs may not support all option lead-in characters exemplified above. Under DOS, where the default command line option character can be changed from / to -, programs may query the SwitChar API in order to determine the current setting. So, if a program is not hard-wired to support them all, a user may need to know the current setting even to be able to reliably request help. If the SwitChar has been changed to - and therefore the / character is accepted as alternative path delimiter also at the DOS command line, programs may misinterpret options like /h or /H as paths rather than help parameters. However, if given as first or only parameter, most DOS programs will, by convention, accept it as request for help regardless of the current SwitChar setting.
In some cases, different levels of help can be selected for a program. Some programs supporting this allow to give a verbosity level as an optional argument to the help parameter (as in /H:1, /H:2, etc.) or they give just a short help on help parameters with question mark and a longer help screen for the other help options.
Depending on the program, additional or more specific help on accepted parameters is sometimes available by either providing the parameter in question as an argument to the help parameter or vice versa (as in /H:W or in /W:? (assuming /W would be another parameter supported by the program)).
In a similar fashion to the help parameter, but much less common, some programs provide additional information about themselves (like mode, status, version, author, license or contact information) when invoked with an "about" parameter like -!, /!, -about, or --about.
Since the ? and ! characters typically also serve other purposes at the command line, they may not be available in all scenarios, therefore, they should not be the only options to access the corresponding help information.
If more detailed help is necessary than provided by a program's built-in internal help, many systems support a dedicated external "HELP command" command (or similar), which accepts a command name as calling parameter and will invoke an external help system.
In the DR-DOS family, typing /? or /H at the COMMAND.COM prompt instead of a command itself will display a dynamically generated list of available internal commands; 4DOS and NDOS support the same feature by typing ? at the prompt (which is also accepted by newer versions of DR-DOS COMMAND.COM); internal commands can be individually disabled or reenabled via SETDOS /I. In addition to this, some newer versions of DR-DOS COMMAND.COM also accept a ?% command to display a list of available built-in pseudo-environment variables. Besides their purpose as quick help reference this can be used in batchjobs to query the facilities of the underlying command line processor.
Command description syntax[edit]
Built-in usage help and man pages commonly employ a small syntax to describe the valid command form:[11][12]
angle brackets for required parameters: ping <hostname>
square brackets for optional parameters: mkdir [-p] <dirname>
ellipses for repeated items: cp <source1> [source2...] <dest>
vertical bars for choice of items: netstat {-t|-u}
Notice that these characters have different meanings than when used directly in the shell. Angle brackets may be omitted when confusing the parameter name with a literal string is not likely.
The space character[edit]
In many areas of computing, but particularly in the command line, the space character can cause problems as it has two distinct and incompatible functions: as part of a command or parameter, or as a parameter or name separator. Ambiguity can be prevented either by prohibiting embedded spaces in file and directory names in the first place (for example, by substituting them with underscores _), or by enclosing a name with embedded spaces between quote characters or using an escape character before the space, usually a backslash (\). For example
Long path/Long program name Parameter one Parameter two ...
is ambiguous (is "program name" part of the program name, or two parameters?); however
Long_path/Long_program_name Parameter_one Parameter_two ...,
LongPath/LongProgramName ParameterOne ParameterTwo ...,
"Long path/Long program name" "Parameter one" "Parameter two" ...
and
Long\ path/Long\ program\ name Parameter\ one Parameter\ two ...
are not ambiguous. Unix-based operating systems minimize the use of embedded spaces to minimize the need for quotes. In Microsoft Windows, one often has to use quotes because embedded spaces (such as in directory names) are common.
Command-line interpreter[edit]
See also: List of command-line interpreters
Although most users think of the shell as an interactive command interpreter, it is really a programming language in which each statement runs a command. Because it must satisfy both the interactive and programming aspects of command execution, it is a strange language, shaped as much by history as by design.
— Brian Kernighan & Rob Pike[13]
The terms command-line interpreter, command line shell, command language interpreter, or identical abbreviation CLI, are applied to computer programs designed to interpret a sequence of lines of text which may be entered by a user, read from a file or another kind of data stream. The context of interpretation is usually one of a given operating system or programming language.
Command-line interpreters allow users to issue various commands in a very efficient (and often terse) way. This requires the user to know the names of the commands and their parameters, and the syntax of the language that is interpreted.
The Unix #! mechanism and OS/2 EXTPROC command facilitate the passing of batch files to external processors. One can use these mechanisms to write specific command processors for dedicated uses, and process external data files which reside in batch files.
Many graphical interfaces, such as the OS/2 Presentation Manager and early versions of Microsoft Windows use command-lines to call helper programs to open documents and programs. The commands are stored in the graphical shell[clarification needed] or in files like the registry or the OS/2 os2user.ini file.
Early history[edit]
The earliest computers did not support interactive input/output devices, often relying on sense switches and lights to communicate with the computer operator. This was adequate for batch systems that ran one program at a time, often with the programmer acting as operator. This also had the advantage of low overhead, since lights and switches could be tested and set with one machine instruction. Later a single system console was added to allow the operator to communicate with the system.
From the 1960s onwards, user interaction with computers was primarily by means of command-line interfaces, initially on machines like the Teletype Model 33 ASR, but then on early CRT-based computer terminals such as the VT52.
All of these devices were purely text based, with no ability to display graphic or pictures.[14] For business application programs, text-based menus were used, but for more general interaction the command line was the interface.
Around 1964 Louis Pouzin introduced the concept and the name shell in Multics, building on earlier, simpler facilities in the Compatible Time-Sharing System (CTSS).[15][better source needed]
From the early 1970s the Unix operating system adapted the concept of a powerful command-line environment, and introduced the ability to pipe the output of one command in as input to another. Unix also had the capability to save and re-run strings of commands as "shell scripts" which acted like custom commands.
The command-line was also the main interface for the early home computers such as the Commodore PET, Apple II and BBC Micro – almost always in the form of a BASIC interpreter. When more powerful business oriented microcomputers arrived with CP/M and later MS-DOS computers such as the IBM PC, the command-line began to borrow some of the syntax and features of the Unix shells such as globbing and piping of output.
The command-line was first seriously challenged by the PARC GUI approach used in the 1983 Apple Lisa and the 1984 Apple Macintosh. A few computer users used GUIs such as GEOS and Windows 3.1 but the majority of IBM PC users did not replace their command.com shell with a GUI until Windows 95 was released in 1995.[16][17]
Modern usage as an operating system shell[edit]
While most non-expert computer users now use a GUI almost exclusively, more advanced users have access to powerful command-line environments:
The default VAX/VMS command shell, using the DCL language, has been ported to Windows systems at least three times, including PC-DCL and Acceler8 DCL Lite. MS-DOS 6.22 has been ported to Linux type systems, Unix command shells have been ported to VMS and MS-DOS/Windows 95 and Windows NT types of operating systems. Command.com and Windows NT cmd.exe have been ported to Windows CE and presumably works on Microsoft Windows NT Embedded 4.0
Windows Resource Kit and Windows Services for Unix include Korn and the Bourne shells along with a Perl interpreter (Services of Unix contains Active State ActivePerl in later versions and Interix for versions 1 and 2 and a shell compiled by Microsoft)
IBM OS/2 has the cmd.exe processor. This copies the command.com commands, with extensions to REXX.
Cmd.exe and Command.com are part of the Windows NT stream operating systems.
Yet another Cmd.exe is a stripped-down shell for Windows CE 3.0
An MS-DOS type interpreter called PocketDOS has been ported to Windows CE machines; the most recent release is almost identical to MS-DOS 6.22 and can also run Windows 1, 2, and 3.0, QBasic and other development tools, 4NT and 4DOS. The latest release includes several shells, namely MS-DOS 6.22, PC-DOS 7, DR DOS 3, and others
PocketConsole is a Windows NT 4.0 shell for Windows CE that is much like 4NT
Windows users have a CLI environment named Windows Command Prompt, which might use the CScript interface to alternate programs. PowerShell provides a command-line interface, but its applets are not written in Shell script. Implementations of the Unix shell are also available as part of the POSIX sub-system,[18] Cygwin, MKS Toolkit, UWIN, Hamilton C shell and other software packages. Available shells for these interoperability tools include csh, ksh, sh, bash, rsh, tclsh and less commonly zsh, ysh, psh
Command.com (4DOS), Windows NT cmd.exe (4NT, TCC), and OS/2 cmd.exe (4OS2) and others based on them are enhanced shells which can be a replacement for the native shell or a means of enhancement of the default shell
Implementations of PHP have a shell for interactive use called php-cli.
Standard Tcl/Tk has two interactive shells, Tclsh and Wish, the latter being the GUI version.
Python, Ruby, Lua, XLNT, and other interpreters also have command shells for interactive use.
FreeBSD uses tcsh as its default interactive shell for the superuser.
Apple macOS[19] and many Linux distributions have the Bash implementation of the Unix shell. Early versions of macOS used tcsh as the default shell.
Embedded Linux (and other embedded Unix-like) devices often use the Ash implementation of the Unix shell, as part of Busybox.
Android uses the mksh shell,[20][21] which replaces a shell derived from ash[22] that was used in older Android versions, supplemented with commands from the separate toolbox[23] binary.
Routers with Cisco IOS,[24] Junos[25] and many others are commonly configured from the command line.
Scripting[edit]
Most command-line interpreters support scripting, to various extents. (They are, after all, interpreters of an interpreted programming language, albeit in many cases the language is unique to the particular command-line interpreter.) They will interpret scripts (variously termed shell scripts or batch files) written in the language that they interpret. Some command-line interpreters also incorporate the interpreter engines of other languages, such as REXX, in addition to their own, allowing the executing of scripts, in those languages, directly within the command-line interpreter itself.
Conversely, scripting programming languages, in particular those with an eval function (such as REXX, Perl, Python, Ruby or Jython), can be used to implement command-line interpreters and filters. For a few operating systems, most notably DOS, such a command interpreter provides a more flexible command line interface than the one supplied. In other cases, such a command interpreter can present a highly customised user interface employing the user interface and input/output facilities of the language.
Other command-line interfaces[edit]
The command line provides an interface between programs as well as the user. In this sense, a command line is an alternative to a dialog box. Editors and data-bases present a command line, in which alternate command processors might run. On the other hand, one might have options on the command line which opens a dialog box. The latest version of 'Take Command' has this feature. DBase used a dialog box to construct command lines, which could be further edited before use.
Programs like Basic, Diskpart, Edlin, and QBasic all provide command-line interfaces, some of which use the system shell. Basic is modeled on the default interface for 8-bit Intel computers. Calculators can be run as command-line or dialog interfaces.
Emacs provides a command line interface in the form of its minibuffer. Commands and arguments can be entered using Emacs standard text editing support, and output is displayed in another buffer.
There are a number of pre-mouse games, like Adventure or King's Quest 1-3, which relied on the user typing commands at the bottom of the screen. One controls the character by typing commands like 'get ring' or 'look'. The program returns a text which describes how the character sees it, or makes the action happen. The text adventure The Hitchhiker's Guide to the Galaxy, a piece of interactive fiction based on Douglas Adam's book of the same name, is a teletype-style command-line game.
The most notable of these interfaces is the standard streams interface, which allows the output of one command to be passed to the input of another. Text files can serve either purpose as well. This provides the interfaces of piping, filters and redirection. Under Unix, devices are files too, so the normal type of file for the shell used for stdin,stdout and stderr is a tty device file.
Another command-line interface allows a shell program to launch helper programs, either to launch documents or start a program. The command is processed internally by the shell, and then passed on to another program to launch the document. The graphical interface of Windows and OS/2 rely heavily on command-lines passed through to other programs – console or graphical, which then usually process the command line without presenting a user-console.
Programs like the OS/2 E editor and some other IBM editors, can process command-lines normally meant for the shell, the output being placed directly in the document window.
A web browser's URL input field can be used as a command line. It can be used to "launch" web apps, access browser configuration, as well as perform a search. Google, which has been called "the command line of the internet" will perform a domain-specific search when it detects search parameters in a known format.[26] This functionality is present whether the search is triggered from a browser field or one on Google's web site.
See also[edit]
Comparison of command shells
List of command-line interpreters
Orthodox file manager, also known as command-based file manager[dubious – discuss]
Concepts[edit]
Batch processing
Batch file
Console application
Interpreter directive
Read-eval-print loop
Shell (computing)
Scripting language
Shell script
Uses[edit]
clig
Computer terminal
Terminal emulator
Run command
Miscellaneous[edit]
Graphical user interface § Comparison to other interfaces
In the Beginning... Was the Command Line
Natural user interface
References[edit]
Jump up ^ "Text mode programs (CUI: Console User Interface)". Wine User Guide. Retrieved Sep 22, 2013.
Jump up ^ "Unix Shells". the notion of having a replaceable "command shell" rather than a "monitor" tightly integrated with the OS kernel tends to be attributed to Multics.
^ Jump up to: a b "The Origin of the Shell". www.multicians.org. Retrieved 2017-04-12.
Jump up ^ Metz, Cade (3 January 2013). "Say Bonjour to the Internet’s Long-Lost French Uncle". WIRED. Retrieved 31 July 2017.
Jump up ^ Mazières, David (Fall 2004). "MULTICS - The First Seven Years". Advanced Operating Systems. Stanford Computer Science Department. Retrieved 1 August 2017.
^ Jump up to: a b Jones, M. (6 December 2011). "Evolution of shells in Linux". developerWorks. IBM. Retrieved 1 August 2017.
Jump up ^ "GNU BASH Reference".
Jump up ^ "Microsoft Windows Command Shell Overview".
Jump up ^ Parker, Steve (2011). "11: Choosing and using shells". Shell Scripting: Expert Recipes for Linux, Bash and more. Programmer to programmer. Indianapolis: John Wiley & Sons. p. 262. ISBN 9781118166321. Retrieved 2017-03-23. The shell has four different command prompts, called PS1, P52, P53, and PS4. PS stands for Prompt String.
Jump up ^ RISC OS 3 User Guide (PDF). Acorn Computers Limited. 1 March 1992. p. 125.
Jump up ^ Conventions for describing commands on Unix-like operating systems: "The Open Group Base Specifications Issue 7, Chapter 12.1 Utility Argument Syntax". The Open Group. 2008. Retrieved 2013-04-07. man-pages(7) – Linux Conventions and Miscellany Manual
Jump up ^ Conventions for describing commands on MS-DOS-like operating systems. Notable difference: The Windows Server 2003 R2 documentation uses italic letters for "Information that the user must supply", while the Server 2008 documentation uses angle brackets. Italics can not be displayed by the internal "help" command while there is no problem with angle brackets. "Command shell overview". Windows Server 2003 Product Help. Microsoft. 2005-01-21. Retrieved 2013-04-07. "Command-Line Syntax Key". Windows Server 2008 R2 TechNet Library. Microsoft. 2010-01-25. Retrieved 2013-04-07.
Jump up ^ Kernighan, Brian W.; Pike, Rob (1984). The UNIX Programming Environment. Englewood Cliffs: Prentice-Hall. ISBN 0-13-937699-2.
Jump up ^ With the exception of ASCII art
Jump up ^ Pouzin, Louis. "The Origin of the Shell". Multicians.org. Retrieved Sep 22, 2013.
Jump up ^ "Remembering Windows 95's launch 15 years later".
Jump up ^ "A history of Windows".
Jump up ^ "Windows POSIX shell compatibility".
Jump up ^ via Finder, Applications, Utilities, Terminal
Jump up ^ android/platform/external/mksh/
Jump up ^ https://stackoverflow.com/questions/11950131/android-adb-shell-ash-or-ksh
Jump up ^ "Android sh source".
Jump up ^ "Android toolbox source".
Jump up ^ "Cisco IOS Configuration Fundamentals Configuration Guide, Release 12.2". Cisco. October 30, 2013. Using the Command-Line Interface. The Cisco IOS command-line interface (CLI) is the primary user interface...
Jump up ^ "...the software that you use whenever you access the router..."
Jump up ^ "Google strange goodness".
External links[edit]
The Roots of DOS David Hunter, Softalk for the IBM Personal Computer March 1983. Archived at Patersontech.com since 2000.
[hide]
v
t
e
Operating systems
General
Advocacy
Comparison
Forensic engineering
History
Hobbyist development
List
Timeline
Usage share
Kernel
Architectures
Exokernel
Hybrid
Microkernel
Monolithic
Rump kernel
Unikernel
Components
Device driver
Loadable kernel module
Microkernel
User space
Process management
Concepts
Context switch
Interrupt
IPC
Process
Process control block
Real-time
Thread
Time-sharing
Scheduling
algorithms
Computer multitasking
Fixed-priority preemptive
Multilevel feedback queue
Preemptive
Round-robin
Shortest job next
Memory management and
resource protection
Bus error
General protection fault
Memory protection
Paging
Protection ring
Segmentation fault
Virtual memory
Storage access and
file systems
Boot loader
Defragmentation
Device file
File attribute
Inode
Journal
Partition
Virtual file system
Virtual tape library
List
AmigaOS
Android
BeOS
BSD
Chrome OS
CP/M
DOS
GNU
Haiku
illumos
iOS
Linux
Macintosh
Classic Mac OS
macOS
MINIX
MorphOS
MUSIC/SP
Nemesis
NOS
OpenVMS
ORVYL
OS/2
OSv
Pick
QNX
ReactOS
RISC OS
RSTS/E
RSX-11
RT-11
Solaris
TOPS-10/TOPS-20
TPF
Unix
Visi On
VM/CMS
VS/9
Windows
Xinu
z/OS
Miscellaneous concepts
API
Computer network
HAL
Live CD
Live USB
OS shell
CLI
GUI
TUI
VUI
PXE
Retrieved from "https://en.wikipedia.org/w/index.php?title=Command-line_interface&oldid=800959676"
Categories:
Computing commands
History of human–computer interaction
Software architecture
User interface techniques
User interfaces
Hidden categories:
Articles lacking in-text citations from January 2016
All articles lacking in-text citations
Articles needing additional references from January 2016
All articles needing additional references
Use dmy dates from August 2012
Articles needing additional references from April 2015
Articles needing additional references from July 2015
All articles with unsourced statements
Articles with unsourced statements from April 2015
Wikipedia articles needing clarification from May 2012
All articles lacking reliable references
Articles lacking reliable references from September 2013
All accuracy disputes
Articles with disputed statements from September 2013
Navigation menu
Personal tools
Not logged in
Talk
Contributions
Create account
Log in
Namespaces
Article
Talk
Variants
Views
Read
Edit
View history
More
Search
Navigation
Main page
Contents
Featured content
Current events
Random article
Donate to Wikipedia
Wikipedia store
Interaction
Help
About Wikipedia
Community portal
Recent changes
Contact page
Tools
What links here
Related changes
Upload file
Special pages
Permanent link
Page information
Wikidata item
Cite this page
Print/export
Create a book
Download as PDF
Printable version
Languages
Afrikaans
العربية
Azərbaycanca
Беларуская
Български
Català
Čeština
Dansk
Deutsch
Eesti
Español
فارسی
Français
Galego
한국어
Bahasa Indonesia
Íslenska
Italiano
עברית
Қазақша
Magyar
മലയാളം
Bahasa Melayu
Nederlands
日本語
Norsk
Polski
Português
Română
Русский
Slovenčina
Slovenščina
Српски / srpski
Suomi
Svenska
Türkçe
Українська
中文
Edit links
This page was last edited on 16 September 2017, at 20:05.
Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.
Privacy policy
About Wikipedia
Disclaimers
Contact Wikipedia
Developers
Cookie statement
Mobile view
Enable previews

values: mw-page-base noprint

values: mw-head-base noprint

attrs: id class style

values: firstHeading firstHeading en

values: siteSub noprint

values: jump-to-nav mw-jump

attrs: href title

values:
note
hatnote navigation-not-searchable

attrs: alt src width height srcset data-file-width data-file-height

value: td

value: span

attrs: class role tabindex

values: mw-collapsible-toggle button 0

attrs: class href

values: Wikipedia:WikiProject Fact and Reference Check

values: plainlinks metadata ambox ambox-style ambox-More_footnotes

values: Help:Introduction to referencing with Wiki Markup/1

values: plainlinks metadata ambox ambox-content ambox-Refimprove

values:
mw-collapsible
width:95%; margin: 0.2em 0;

values: plainlinks metadata ambox ambox-content ambox-multiple_issues compact-ambox

values:
/wiki/List_of_Fedora_releases#Fedora_15
mw-redirect
List of Fedora releases

values:
/wiki/Windows_PowerShell
mw-redirect
Windows PowerShell

values:
/wiki/Text_user_interface
mw-redirect
Text user interface

values:
/wiki/IBM_AIX_SMIT
mw-redirect
IBM AIX SMIT

values:
/wiki/Mouse_(computing)
mw-redirect
Mouse (computing)

values: Edit section: Comparison to graphical user interfaces

values:
/wiki/Apple_Computer
mw-redirect
Apple Computer

values: Edit section: Operating system command-line interfaces

values: Edit section: Application command-line interfaces

values:
/wiki/Executable_file
mw-redirect
Executable file

values:
/wiki/Dumb_terminal#Early_VDUs
mw-redirect
Dumb terminal

values:
/wiki/Time_sharing
mw-redirect
Time sharing

values:
/wiki/Bulletin_Board_System
mw-redirect
Bulletin Board System

values:
/wiki/Bourne-again_shell
mw-redirect
Bourne-again shell

values:
/wiki/AppleSoft_BASIC
mw-redirect
AppleSoft BASIC

values:
/wiki/Apple_Macintosh
mw-redirect
Apple Macintosh

values:
/wiki/Graphical_User_Interface
mw-redirect
Graphical User Interface

values:
/wiki/System_Administrator
mw-redirect
System Administrator

values:
/wiki/Open_source
mw-redirect
Open source

values:
/wiki/Terminal_(Mac_OS_X)
mw-redirect
Terminal (Mac OS X)

values: plainlinks metadata ambox ambox-content ambox-Unreferenced

values:
/wiki/Operating_system_shell
mw-redirect
Operating system shell

values:
/wiki/Refreshable_Braille_display
mw-redirect
Refreshable Braille display

values:
/wiki/Command-line_option
mw-redirect
Command-line option

values:
/wiki/Embedded_systems
mw-redirect
Embedded systems

values:
/wiki/Character_string
mw-redirect
Character string

values:
/wiki/Redirection_operator
mw-redirect
Redirection operator

values: Edit section: CLI and resource protection

values:
/wiki/Network_router
mw-redirect
Network router

values:
/wiki/Main_function_(programming)
mw-redirect
Main function (programming)

values:
/wiki/Unix-like_operating_system
mw-redirect
Unix-like operating system

values:
/wiki/Standard_input
mw-redirect
Standard input

values:
/wiki/Standard_output
mw-redirect
Standard output

values:
/wiki/PL/I_programming_language
mw-redirect
PL/I programming language

values:
/wiki/Tab_completion
mw-redirect
Tab completion

values: Edit section: Option conventions in DOS, Windows, OS/2

values:
/wiki/Embedded_DOS
mw-redirect
Embedded DOS

values:
/wiki/Terminate_%26_Stay_Resident
mw-redirect
Terminate & Stay Resident

values:
/wiki/SWITCHAR_(CONFIG.SYS_directive)
mw-redirect
SWITCHAR (CONFIG.SYS directive)

values:
/wiki/PROMPT_(DOS_command)
mw-redirect
PROMPT (DOS command)

values:
/wiki/Pseudo-environment_variable
mw-redirect
Pseudo-environment variable

values: Edit section: Option conventions in Unix-like systems

values: Edit section: Options conventions in other systems

values:
/wiki/IBM_4680_OS
mw-redirect
IBM 4680 OS

values:
/wiki/IBM_4690_OS
mw-redirect
IBM 4690 OS

values: This claim needs references to reliable sources. (April 2015)

values:
noprint Inline-Template Template-Fact
white-space:nowrap;

values:
/wiki/HELP_(command)
mw-redirect
HELP (command)

values: Edit section: Command description syntax

values:
/wiki/Space_character
mw-redirect
Space character

values: The text near this tag may need clarification or removal of jargon. (May 2012)

values:
noprint Inline-Template
margin-left:0.1em; white-space:nowrap;

values:
/wiki/Computer_terminals
mw-redirect
Computer terminals

values: This claim needs references to better sources. (September 2013)

values: noprint Inline-Template noprint Template-Fact

values:
/wiki/Shell_scripts
mw-redirect
Shell scripts

values:
/wiki/Windows_3.1
mw-redirect
Windows 3.1

values: Edit section: Modern usage as an operating system shell

values:
/wiki/Services_for_Unix
mw-redirect
Services for Unix

values:
/wiki/Windows_Command_Prompt
mw-redirect
Windows Command Prompt

values:
/wiki/Embedded_Linux
mw-redirect
Embedded Linux

values:
/wiki/Script_(computer_programming)
mw-redirect
Script (computer programming)

values:
/wiki/Interpreted_programming_language
mw-redirect
Interpreted programming language

values:
/wiki/Scripting_programming_language
mw-redirect
Scripting programming language

values:
/wiki/Function_(programming)
mw-redirect
Function (programming)

values: Edit section: Other command-line interfaces

values:
/wiki/Text_adventure
mw-redirect
Text adventure

values: The Hitchhiker's Guide to the Galaxy (video game)

values:
/wiki/Orthodox_file_manager
mw-redirect
Orthodox file manager

values: The material near this tag is possibly inaccurate or nonfactual. (September 2013)

values:
/wiki/Read-eval-print_loop
mw-redirect
Read-eval-print loop

values: div-col columns column-count column-count-2

values: -moz-column-count: 2; -webkit-column-count: 2; column-count: 2;

values: In the Beginning... Was the Command Line

values:
nofollow
external text
http://www.multicians.org/shell.html

values:
nofollow
external text
https://linux.die.net/man/7/man-pages

values: -moz-column-width: 30em; -webkit-column-width: 30em; column-width: 30em; list-style-type: decimal;

values: nowraplinks collapsible autocollapse navbox-inner

values: Category:History of human–computer interaction

values: Category:Articles lacking in-text citations from January 2016

values: Category:All articles lacking in-text citations

values: Category:Articles needing additional references from January 2016

values: Category:All articles needing additional references

values: Category:Articles needing additional references from April 2015

values: Category:Articles needing additional references from July 2015

values: Category:All articles with unsourced statements

values: Category:Articles with unsourced statements from April 2015

values: Category:Wikipedia articles needing clarification from May 2012

values: Category:All articles lacking reliable references

values: Category:Articles lacking reliable references from September 2013

values: Category:Articles with disputed statements from September 2013

values: Discussion about edits from this IP address [ctrl-alt-n]

values: A list of edits made from this IP address [ctrl-alt-y]

values: You are encouraged to create an account and log in; however, it is not mandatory

values: You're encouraged to log in; however, it's not mandatory. [ctrl-alt-o]

values:
/wiki/Command-line_interface
View the content page [ctrl-alt-c]
c

values: Discussion about the content page [ctrl-alt-t]

values: p-namespaces navigation vectorTabs p-namespaces-label

values:
p-variants
navigation
vectorMenu emptyPortlet
p-variants-label

values: Past revisions of this page [ctrl-alt-h]

values: p-views navigation vectorTabs p-views-label

values:
p-cactions
navigation
vectorMenu emptyPortlet
p-cactions-label

values:
mw-wiki-logo
/wiki/Main_Page
Visit the main page

values:
/wiki/Main_Page
Visit the main page [ctrl-alt-z]
z

values: Featured content – the best of Wikipedia

values: Find background information on current events

values:
/wiki/Special:Random
Load a random article [ctrl-alt-x]
x

values: portal navigation p-navigation p-navigation-label

values: Guidance on how to use and edit Wikipedia

values: About the project, what you can do, where to find things

values: A list of recent changes in the wiki [ctrl-alt-r]

values: portal navigation p-interaction p-interaction-label

values: List of all English Wikipedia pages containing links to this page [ctrl-alt-j]

values: Recent changes in pages linked from this page [ctrl-alt-k]

values:
/wiki/Wikipedia:File_Upload_Wizard
Upload files [ctrl-alt-u]
u

values: A list of all special pages [ctrl-alt-q]

values: Permanent link to this revision of the page

values: Link to connected data repository item [ctrl-alt-g]

values: Printable version of this page [ctrl-alt-p]

values:
uls-settings-trigger
Language settings
0
button
true

values:
https://af.wikipedia.org/wiki/Bevellyn
Bevellyn – Afrikaans
af
af
interlanguage-link-target

values: واجهة سطر الأوامر – Arabic

values: Інтэрфейс каманднага радка – Belarusian

values: Интерфейс с команден ред – Bulgarian

values: واسط خط فرمان – Persian

values: 명령 줄 인터페이스 – Korean

values: ממשק שורת פקודה – Hebrew

values: Командалық жол – Kazakh

values: Parancssoros felhasználói felület – Hungarian

values: കമാന്റ് ലൈൻ ഇന്റർഫേസ് – Malayalam

values: キャラクタユーザインタフェース – Japanese

values:
https://ro.wikipedia.org/wiki/CLI
CLI – Romanian
ro
ro
interlanguage-link-target

values: Интерфейс командной строки – Russian

values: Интерфејс командне линије – Serbian

values: Інтерфейс командного рядка – Ukrainian

values: /static/images/wikimedia-button-1.5x.png 1.5x, /static/images/wikimedia-button-2x.png 2x

values: /static/images/poweredby_mediawiki_132x47.png 1.5x, /static/images/poweredby_mediawiki_176x62.png 2x

values:
suggestions
display: none; font-size: 13px;

values: mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Command-line_interface rootpage-Command-line_interface skin-vector action-view