In GNU programs generally, a command line option may have a short form, a long form, or both.

The short form is a single character, usually a letter, and preceded by a single hyphen, such as f in rm -f. Multiple short options may be combined, so that rm -rf is equivalent to rm -r -f. A short option may take an argument, which goes after the option either with or without intervening whitespace, so that for example gcc foo.c -o foo is equivalent to gcc foo.c -ofoo. If multiple short options are combined, only the last is allowed to take an argument.

The long form may be one or more characters, and starts with two hyphens. Generally these are considered a GNUism. For example, every GNU program accepts the arguments --help and --version (yes, that includes GNU dd). Long options cannot be combined. If a long option takes an argument, it must be set off by either whitespace or an equals sign, so that, for example, grep --context=1 is equivalent to grep --context 1, but grep --context1 is invalid.

Almost all short options have a corresponding long option; rm -f is equivalent to rm --force. Many long options, though, have no corresponding short option. For programs like gcc with hundreds of options, this is clearly a mathematical necessity.

Two dashes alone indicate the end of options. If you have a file called -f, you can remove it with rm -- -f. (However, note that rm ./-f will also work, and is more portable.)

A single dash alone is usually interpreted to mean "standard input". For example, cat foo - bar will print the contents of file foo, followed by a copy of whatever you type into the terminal (followed by Ctrl-D to signal end of file), followed by the contents of file bar.

So to answer your question, an argument prefixed with two hyphens is simply a long option, and will likely not be recognized by non-GNU programs.

Depends on the application…

But this is sometimes used to indicate that there are no options for the application that follow.

For a terminal application it is used to separate options that are for the TERMINAL emulation from the command and options for the application that is to be run under the terminal emulation.

In other cases, it is used to indicate “long option name” follows.

This is because the default option names (or most commonly used) are single letters, such as that for gnome-terminal:

gnome-terminal [-e, --command=STRING] [-x, --execute ] [--window-with-profile=PROFILENAME] [--tab-with-profile=PROFILENAME] [--window-with-profile-internal-id=PROFILEID] [--tab-with-profile-internal-id=PROFILEID] [--role=ROLE] [--show-menubar] [--hide-menubar] [--geometry=GEOMETRY] [--disable-factory] [-t, --title=TITLE] [--working-directory=DIRNAME] [--usage] [-?, --help]

The options with the [] show both the short form and long form identity for the option. For quick typing… the classic “-e” (which is to be followed by the string to execute); but where some self documentation is intended (like some scripts) the long form “—command=…” can be used instead.

In some cases “—” by iteself is used to indicate “no more input”.

How it is interpreted is up to each application.

The short answer is it's up to the person who wrote the software to decide how many hyphens to use and how to format options.

However there are some conventions:

1. Generally a single letter option will be prefixed by a single hyphen (e.g. -a -l -t )
   
2. Generally an option which is a word (like "amend" in your example) will have 2 hyphens (e.g. --size --type ).
3. Often the single letter option with the single hyphen will be a short cut for a longer version (e.g. in ls --all and -a are equivalent).
4. Sometimes the longer version will use "=" e.g.:
   myapp --user=bob
   whereas the short version won't
   myapp -u bob
5. Generally, but again not always, single letter options with a single hyphen can be strung together whereas longer versions can't, such as "ls -lart" is the same as "ls -l -a -r -t"
   
   

However there are some notable exceptions, and in some cases (like tar or ps) the "-" isn't required at all.

By “the terminal” I take it that you mean the common shells for Unix/Linux (or Mac Terminal…which is Unix-based).

The Unix programming environment has, for the most part, “evolved” rather than being “intelligently designed”. This aspect is well-illustrated by the manner in which named options to shell commands are specified.

The original model was for one-character flags which would be indicated as such by prefixing a “-” to them. For convenience, multiple such options could be concatenated after an initial “-” (they were one-character, after all).

Now not all early commands followed this scheme. For example, the tar command (short for “tape archive” but subsequently used for general packaging) dispensed with the “-” in front of its flags. (The “-” can now be used but it is safest to omit it.).

There is also the find command which uses wordy (non-single-character) commands each prefixed by a single “-”. As the number and complexity of the command sets of Unix shells increased, a better way of specifying such wordy commands was devised: they were each prefixed by “--” … so that is one use

However the use of a leading “-” as (in effect) a keyword prevented it from being used as the initial character of an ordinary argument. Now since the shell was responsible for denying this capability to the user it was the shell’s responsibility to address it. This was done by recognizing the special argument “--” as an indicator that there are no more manifestly optional arguments on that particular command invocation … and that is the other use

As a side note, one might wonder why a singe, stand-alone “-” was not given that responsibilty. That was because that construct was already defined to mean “take standard input (stdin) from the terminal”.

./ Here . represent current directory and / is for the file or directory.

The Common use of this command is for .sh file which are executable files and .sh is specific for shell executable.

Alternative for this command /path/to/script/script_name

As . Refer to current position you can also use ./

For example

Here you see there is an executable file called File_permission and it is present inside /Users/mukulgautam/, to execute this script we have two ways.

• Run directly using full path of file like this

• Or use ./ command but to this first navigate to script file location and then run as shown in image.

There is no specific meaning for -s in Linux commands, it is entirely up to the author of the program to assign. You can always find out by reviewing the man command for the terminal program you want to know about:

$man ls

In this case, the part of the man page for ls talking about the -s option is:

-s Display the number of file system blocks actually used by each

file, in units of 512 bytes, where partial units are rounded up

to the next integer value. If the output is to a terminal, a

total sum for all the file sizes is output on a line before the

listing. The environment variable BLOCKSIZE overrides the unit

size of 512 bytes.

Whenever you want or need to know something about linux commands (more properly, shell commands) or *NIX programs, like ls in this case (yes, it is a separate “system” program, not a shell (sh, bsh, bash, csh, zsh… you name it) internal command), one must recall that MANY has a manual entry, so, if you type

$ man ls 

you will get the “instruction manual” for the command/program ls. Something like this:

As you can see, the -a option instructs ls to not ignore entries starting with . and, as you may know, “current directory” is the . “file”, while “previous directory” is the .. “file”. And, more interestingly, hidden files begin with . because, as you see, ls does not show files beginning by . per se. So, technically, they are not hidden files, simply “ignored by the file listing program” files. :-D

As stated in other answer, configuration files are usually “hidden” files, like .profile .bashrc .zshrc .vimrc etc, etc, etc… And it is useful to use the -a option to show them. As you can also see in the image above, you can use the -A to show the directories and files “hidden” (yes! directories beginning with . are hidden! . and .. are directories :-) ), as this option show all of them except, precisely, the “this” and “previous” directories entries.

Depends on the context. It can mean practically anything.

The best example I can think of is where it means Stdin or Stdout, when used in place of a file to be read from or written to respectively.

Eg

print_tar_to_stdout | tar -zxf -  
tar -zcf - . /stuff | process_tar_file 

Other uses would telling the command that there is a lot to be flags.

ls -lrt 
ls --long 

In the first example the single - indicates that there are going to be flags, specifically the l, r, and t flags respectively. The second - in the latter shows that this is going to be a long firm option. This however is just one particular convention; the thing about conventions is there are many to choose from.

Dot character and $ character depends on your usage.

Can you modify your question to exact query.

Dot character at windows:

a) Change directory to current directory

C:\Windows\System32> CD .

b) Change directory to parent directory

C:\Windows\System32> CD ..

c) Executing a binary at command prompt:

Using dot backslash character

C:\Program Files (x86)\Microsoft\Edge\Application> .\msedge.exe

d) echo PATH environment variable:

C:> ECHO %PATH%

C:> ECHO %CD% current directory

C:> ECHO %COMPUTERNAME%

C:> echo testing | C:\Windows\System32\find.exe “murugesan openssl”

C:> echo %ERRORLEVEL%

1

e)

bash.exe and simulating Linux oriented commands at windows:

$ cd /usr/bin

$ ./ls

$# or based on your OS

$ ./ls.exe

$ echo $PWD like %CD% at windows

$ echo $? result of previous command zero or non zero like %ERRORLEVEL% at windows.

$ echo export search=\"murugesan openssl\" > delete.txt

$ chmod u+x ./delete.txt

$ ./delete.txt

$ echo "search : $search : not set"

search : : not set

$ . ./delete.txt

$ #execute above script to current shell

$ echo "search : $search : set"

search : murugesan openssl : set

$$ represent the previous process executed at background process.

Example at bash.exe on windows:

C:> bash.exe

$ a.out >/dev/null 2>&1 &

$ echo $$

“.” represents the current working directory. For example, if you wish to run a program from the current directory, rather than an installed one in the execution path, you might write “./ls” rather than just “ls”. If you wish to copy something to the current directory you might write “cp /tmp/foo.txt .”.

“$” is used to introduce an environment variable. For instance, $HOME is the user’s home directory, $HISTSIZE is the number of previous commands saved in the shell history. Numeric variables are those passed to a shell script on the command line; $1 is the first argument, $2 the second etc.. Other single-character variables have special meaning, for instance $$ is the process ID of the shell, $? is the exit status of the most recent foreground pipeline (most recent command, basically, indicating if it failed).

There are a couple of reasons you might place a “./” at the beginning of a command:

1. To specifically run a command in the CURRENT directory with the same name as something else that is in your path. Say your current working directory is /home/alex/bin and you want to run the script /home/alex/bin/cat. If you type command “cat” it would normally run “/bin/cat”, but if you type “./cat” it will run the script you want.
2. To run a command in the current directory if the current directory is not in your path. Say you created /home/alex/bin/myscript but that is not in your path. You could run it with “cd /home/alex/bin; ./myscript”.

In the middle of a command or filename, though, it does nothing. For instance, “/bin/ls” and “/bin/./ls” are the same command.

It’s the name of a directory (followed by a slash, to make it very clear it’s a directory). Not only in a Linux command, but also in Unix, and also in any programming context or system call, when a certain directory is to be accessed or named.

That particular directory is the “current directory”.

For example, if you want to list all files in the current directory, you could use the command

ls ./

or just

ls .

since the slash is there only to explicitly mention it’s a directory

Or even just

ls

since, coincidently, the default argument for ls is “the current directory”.

Most other commands don’t have “.” as a default argument, so you’ll need to use that “.” often explicitly.

E.g., to copy some file(s) to your current directory, you need to do something like

cp /some/file1 /some/file2 ./

or (of course) also

cp /some/file1 /some/file2 .

The UNIX shell displays a command prompt when the system is ready to accept commands on the command line. The default command prompt is a single character (typically $ or # for Bash and ksh). “$” is displayed when you log in as a normal user and “#” is displayed when you log in as a root user.

An example is given below:

In the example it can be seen that apart from the “$” and “#” symbol the shell also displays the username and host-name. This is configured by a prompt string PS1 in Bash.

The prompt string PS1 can be configured to display useful information on shell.

Here:

\u -- Username 
\h -- Host name 
\W -- Basename of the current working directory  

“Why do we use -i in Linux commands?”

I am sorry but, which programs do you mean?

Many programs have different flags (a flag is a dash followed by a letter [called a short-flag] or another dash which then is followed by a word).

And each developer can decide what flags their application has, and how they effect the application. As there are only so many lowercase letters, you will find many same short flags but with different meanings in a collection of applications.

To know what the -i flag does in for example sed, you can check it's description with 'sed --help' or 'man sed'. (As you can see, the sed program supports the --help flag, and it print a help dialogue)

This is the man output for sed regarding the -i flag:

-i[SUFFIX], --in-place[=SUFFIX]

edit files in place (makes backup if

SUFFIX supplied)

And as you can read it directly modifies the file you use sed on, but you can make a backup of the file by adding something to the flag, for example: -ibak1

I hope that this short info allows you to find out what -i does in the programs you where thinking about when you write this question.

(I refer to “commands” as programs because 90% of what you execute in any shell is a standalone program and not a shell command. This is true for Linux, *nix, macOS and even Windows)

When you use ‘ls’ , it simply lists all files, directories.

when you use -r option, it lists in reverse order i.e

when you -d option, it lists only directories (with */ option)

as you see test.txt file is not shown when we use -d.

In my experience and varied research, it is a negative sign if it is

1. preceded by a different operator. For example, in 5+-1. You can pretty well assume that that (+) sign has no other reason to be there other than as an operator, so it must mean plus. Equations can not have addition and subtraction happening at the same time, so that (-) sign must be a negative symbol.
2. If the number and the (-) sign are in parentheses together. This is the correct way to write equations if the negative sign is preceded by an operator. For example, 5+(-1). The 1 is quite obviously negative.

If the (-) sign is by itself, as with 5–1, then you can probably make the assumption that the (-) represents subtraction.

Q: What does -i mean in Linux terminal?

I want to delete a folder in my /home directory with rm-r apples

A: -i stands for “interactive.”

It basically instructs the command (rm) to ask “are you sure?” for every item which is slated to be removed. You enter “y” or “yes” each time you agree a file can go away.

In this example the directory to remove is named “test” containing three files, and the rm command and its output will look like this (it stopped each time to wait for me to type “y” and answer the question):

rm -ri test 
rm: descend into directory ‘test’? y 
rm: remove regular empty file ‘test/text1.txt’? y 
rm: remove regular empty file ‘test/text2.txt’? y 
rm: remove regular empty file ‘test/test3.txt’? y 
rm: remove directory ‘test’? y 

The opposite of -i is -f (force), and it’ll remove everything without asking once. By the way the -r means recursive, which is required to descend into a directory. Without it you many only remove files.

-i has the same effect on many commands, but not all. Read the man page to learn more about any of them.

UPDATE:

Your sample command directory is “apples.” Is this a homework question? Don’t ask those here. Don’t ask them on Stack Exchange. Or LinuxQuestions.

If you have questions that can’t be answered with “man rm” or your course documentation then ask your instructor; that’s why you are taking a class—TO LEARN. Study with classmates,

I realize it sounds funny to discourage asking questions on a Q&A site—and I admit Quora is a wonderful resource—but in asking here, you’re requesting that other people do your work for you.

Not only is that cheating, it robs you of your chance to truly LEARN the course material, and again…that’s why you’re taking a class. What happens when you get a job and don’t know how to do it without constantly keeping browser tabs open to Quora? Someone else will have your job before long, that’s what.

If it’s not a homework question, please ignore the above rant. If it *is*, then Jakob’s answer is far better, and don’t read mine.

As another poster said, there are two use cases:

1. When you have a script performing installations or configuration changes, and you want to make sure a directory exists. Without -p you’ll get an error if it already exists. With -p you will only get an error if the directory did not exist, and mkdir was unable to create it.
2. When you need to create several levels of directory tree at once. By default mkdir will only create one level, so if you want to have /var/something/somethingelse, you need to issue two mkdir commands; with -p, you can issue one command to create /var/something/somethingelse and it will create both directory levels.

Sometimes I’ve needed to do both - make sure several levels of directory tree exist when one or more of the levels might already exist. mkdir -p handles that very well.

Assuming this is not quoted, it is one of the file wildcard notations. It defines a character range. [0–9] matches any single digit. [a-d] would match a, b, c, or d. So if a directory contains abu.tmp, ace.tmp and any.tmp:

$ls a[b-c][c-g].tmp

ace.tmp

Instead of defining a range with two characters separated by a dash, you can also list the characters you want to match inside the brackets. For example [afh] matches a, f or h.

In -[0–9], the first - is just a normal character, matches only itself.

Several utility programs in Linux, such as grep and sed, take a regular expression as an argument (which usually must be quoted, otherwise the shell may try to use it as a file wildcard). Regular expressions differ a bit from file wildcards, but the simple forms of the bracket notation work the same way in both.