See Also
Referenced By
The man page hstr(1) is an alias of hh(1).
|
Home | Switchboard | Unix Administration | Red Hat | TCP/IP Networks | Neoliberalism | Toxic Managers |
(slightly skeptical) Educational society promoting "Back to basics" movement against IT overcomplexity and bastardization of classic Unix |
|
Bash is a standard shell on Linux and with version 3.2 or later available on all enterprise platform and installed on Solaris and AIX it make sense to make it standard interactive shell. The current version as of June 2017 is 4.2. Only HP-UX does not include bash by-default, but HP does provide a depot package for bash 4.00. Bash 3.2 and later has important enhancements that make it a better shell (see Annotated List of Bash Enhancements) although scripts should be generally limited to small to medium size as Perl represents much better scripting environment then bash and is installed by default on all platforms including HP-UX and AIX.
|
Bash can be called an accidental scripting language. If started very modestly more then 40 years ago with Borne shell (1977) and C shell (1978). And then gradually had grown into a scripting language. the first major enhancement were done in ksh88 and then ksh93, Then bash 30, and 4,0 introduced additional one (but generally in the framework of ksh93).
The key problem with bash is that it is "rarely used language" for most users. That means that while users might use bash as a command interpreter daily, they program more or less complex scripts rarely (say once a quarter on average). And from one time to another manage to forget most of the important staff related to this language. That makes programming in bash a real challenge.
Also your programming skills evaporate in several months or so, unless you carefully document your "achievements". You will forget them and go down again to the most basic level of usage of this language when you need to write another bash script.
And you might repeat the same mistakes or even blunders again and again. Logbooks is better then nothing but generally is not enough. You need a personal wiki. Frontage can serve as a surrogate Wiki on windows very well. One of the advantages is that you do not need to learn special wiki script. You can use HTML. The author uses it in this capacity for 20 year or so.
Bash is so called "glue" language and set of classic Unix utilities represent important part of bash functionality. So in addition to knowledge of bash you need to know at least several dozens of Unix utilities (and you better know them well ;-). That requirement alone often lead to 'stack overflow". So mental crutches in the form of your custom references are needed and creating them is a the necessary step because of complexity of the environment. Which now is beyond human understanding (the situation called Blind men and an elephant - Wikipedia).
At the current level of complexity the fact that bash has source code available changes absolutely nothing for 99% of Unix/linux sysadmins. It is a classic example of self-closing open source ;-).
At the beginning a good reference book might suffice too (see Best Shell Books for recommendations) but gradually you should create you own website or wiki and work on enhancing it. Even people with 20 year Unix experience often can't remember of the vital option of the most common utilities such as ls, grep and find.
Also blunders in bash can be very costly and lead to the lostt of data, crash of the OS or both. They are often connected iether with misunderstanding of bash behaviour or misunderstanding of behaviour or one of Unix utilities you use, or Unix itself, or make accidentally or out of exhaustion or under time pressure some nasty error yourself. See Sysadmin Horror Stories
The key problem with bash is that it is "rarely used language" for most users. That means that while users might use bash as a command interpreter daily, they program more or less complex scripts rarely (say once a quarter on average). And from one time to another manage to forget most of the important staff related to this language. That makes programming in bash a real challenge. |
While bash has a humble start and much weaker designer then ksh93 and was at times extremely buggy, the gap narrowed in version 3.2 to the extent that better command line user friendliness of bash make it more attractive, especially as an interactive shell then supplied with OS ksh and C-shell. Most ksh93 innovations are now present in some form in bash 3.2. As bash is standard shell on Linux and is installed by default in Solaris it status as an enterprise shell is almost as strong as ksh93 (which is mostly present in old, weaker versions. Current bash has the best debugger and from this point of view represents the best shell. But portable script still are probably better to be written for ksh88 or POSIX shell which is lowest common denominator available on all Unixes. To write scripts in Borne shell now is extremely stupid and wasteful.
Bash 3.2 and later is the one of the most portable advanced shell around (ksh93 and zsh are still a strong competition; ksh93 is definitely more reliable for scripts and does not contain such design blunders as the last stage of the pipe belonging to subshell instead of the invoking shell (actually fixed in lager version of bash).
Bash-related books dominates shell-related publications and as such the level of known-how for bash is higher then for other shells (see Best Shell Books). The advantage of bash for large enterprise environment is that it comes by default with linux, Solaris and AIX (unfortunately in pretty different versions). Only HP-UX does not have bash installed by default. Also it is the best portable interactive shell, much closer to tcsh then any competition.
Still you need some efforts to make the default shell. Unfortunately the default shell for Solaris is the "Bourne shell" or /usr/bin/sh
Bourne shell is a pretty weak outdated shell and attempt to base shell scripting portability on this outdated shell is a serious strategic error (bash probably should be used instead). It is still used as root shell in Solaris ,but that's due to Solaris legacy not because it gives anything but disadvantages; attempts to claim that this somehow increases the security of root due to the fact that it is static linked are weak and the argumentation is open for discussion. All-in-all usage of Bourne shell as a default root shell in Solaris might be considered to be a blunder: system administrators definitely need a better shell.
Usage of Borne shall as a default shell might slightly increase the chances of recovery in case /usr partition is damaged, but this is a pretty serious case and usually means serious troubles with other partitions on the disk anyway (unless this is the case when in Solaris link /bin -> usr/bin is destroyed, but such cases are simple to fight by refereeing shell as /usr/bin/ksh in /etc/passwd). If this is a serious trouble than booting from a CD a mounting the damaged volume is always a good idea and in this case it does not matter what shell root is using; you can change it anyway.
Bash 3.2 is reasonably easy to build from source. Get and unpack in your home directory the archive. This will create a directory called bash-3.2 in your home directory. If you do not have the gunzip utility, you can obtain it in the same way you obtained bash or simply use gzip -d instead. The archive contains all of the source code needed to compile bash and a large amount of documentation and examples. the latter have their own value.The bash archive contains a main directory and a set of files and subdirectories. Among the first files you should examine are:
CHANGES A comprehensive list of bug fixes and new features since the last version
COPYING The GNU Copyleft for bash
MANIFEST A list of all the files and directories in the archive
NEWS A list of new features since the last version
README A short introduction and instructions for compiling bash
doc Directory with information related to bash in various formats (please note that many syadmin never read those docs)
examples Directory with examples of startup files, scripts, and functions
The doc directory contains a few articles that are worth reading. You can print man page for reference with command nroff-man bash.1 | more It is convenient to have a hardcopy so you can write notes all over it. Also valuable, FAQ is a Frequently Asked Questions document with answers, readline.3 is the manual entry for the readline facility, and article.ms is an article about the shell that appeared in Linux Journal, and was written by the current bash maintainer Chet Ramey.
An examples directory is especially important and is well worth exploring (after you've finished reading this book, of course). It includes sample code, scripts, functions, and startup files. See Examples shipped with bash 3.2 and newer
An examples directory directory is especially important and is well worth exploring (after you've finished reading this book, of course). It includes sample code, scripts, functions, and startup files. See Examples shipped with bash 3.2 and newer |
Some interesting features of bash include:
<(list)
To substitute a command pipeline for
an input file >(list)
To substitute a command pipeline for
an output file In the case of the <
and >
forms, the shell will
run process list asynchronously, connected to a named pipe (FIFO).
The name of this pipe will become the argument to the command.
Please visit Heiner Steven SHELLdorado the best shell scripting site on the Internet |
<
is selected then result of execution of the
process list will serve as an input file. This, for allows you to use the output
of one or several commands as parameters to the utilities that accepts file.
For instance you can compare the contents of two directories by typing:diff <( ls dir1 ) <( ls dir2 )
That can be used for concatenating input in pipes:
cat <(echo hello) <(echo world) | echo
If <
is used, then the file passed as an argument will be a
named pipe connected to the output of the list process.
Another, more complex, example,
paste <(cut -f1 file1) < (cut -f3 file2) | tee >(process1) >(process2) >/dev/null
cuts fields 1 and 3 from the files file1 and file2 respectively, pastes the results together, and sends it to the processes process1 and process2. Note that the file, which is passed as an argument to the command, is a system pipe so programs that expect to lseek(2) on the file will not work. Also note that the previous example can be more compactly and efficiently written as:
paste <(cut -f1 file1) <(cut -f3 file2) >>(process1)
>>(process2)
The shell uses pipes instead of FIFOs to implement the latter two process substitutions in the above example.
See also the article in Linux Journal:
Bash
Process Substitution
Due to this bash shell is gradually gaining grounds as the preferred interactive shell for Solaris and other enterprise class Unixes.
Older version of bash (2.x series) are obsolete and should not be used. The recommended version is 3.2 patch level 3 or above. 4.x is recommended on RHEL 6.x and up.
Some pages that form kind of bash tuorial:
Dr. Nikolai Bezroukov
Jun 12, 2021 | anto.online
What if you needed to execute a specific command again, one which you used a while back? And you can't remember the first character, but you can remember you used the word "serve".
You can use the up key and keep on pressing up until you find your command. (That could take some time)
Or, you can enter CTRL + R and type few keywords you used in your last command. Linux will help locate your command, requiring you to press enter once you found your command. The example below shows how you can enter CTRL + R and then type "ser" to find the previously run "PHP artisan serve" command. For sure, this tip will help you speed up your command-line experience.
anto@odin:~$ (reverse-i-search)`ser': php artisan serveYou can also use the history command to output all the previously stored commands. The history command will give a list that is ordered in ascending relative to its execution.
Jun 10, 2021 | www.redhat.com
Exit status
In Bash scripting,
$?
prints the exit status. If it returns zero, it means there is no error. If it is non-zero, then you can conclude the earlier task has some issue.A basic example is as follows:
$ cat myscript.sh #!/bin/bash mkdir learning echo $?If you run the above script once, it will print
0
because the directory does not exist, therefore the script will create it. Naturally, you will get a non-zero value if you run the script a second time, as seen below:$ sh myscript.sh mkdir: cannot create directory 'learning': File exists 1In the cloudBest practices
- Understanding cloud computing
- Free course: Red Hat OpenStack Technical Overview
- Free e-book: Hybrid Cloud Strategy for Dummies
It is always recommended to enable the debug mode by adding the
-e
option to your shell script as below:$ cat test3.sh !/bin/bash set -x echo "hello World" mkdiir testing ./test3.sh + echo 'hello World' hello World + mkdiir testing ./test3.sh: line 4: mkdiir: command not foundYou can write a debug function as below, which helps to call it anytime, using the example below:
$ cat debug.sh #!/bin/bash _DEBUG="on" function DEBUG() { [ "$_DEBUG" == "on" ] && $@ } DEBUG echo 'Testing Debudding' DEBUG set -x a=2 b=3 c=$(( $a + $b )) DEBUG set +x echo "$a + $b = $c"Which prints:
$ ./debug.sh Testing Debudding + a=2 + b=3 + c=5 + DEBUG set +x + '[' on == on ']' + set +x 2 + 3 = 5Standard error redirectionYou can redirect all the system errors to a custom file using standard errors, which can be denoted by the number 2 . Execute it in normal Bash commands, as demonstrated below:
$ mkdir users 2> errors.txt $ cat errors.txt mkdir: cannot create directory "˜users': File existsMost of the time, it is difficult to find the exact line number in scripts. To print the line number with the error, use the PS4 option (supported with Bash 4.1 or later). Example below:
$ cat test3.sh #!/bin/bash PS4='LINENO:' set -x echo "hello World" mkdiir testingYou can easily see the line number while reading the errors:
$ /test3.sh 5: echo 'hello World' hello World 6: mkdiir testing ./test3.sh: line 6: mkdiir: command not found
Mar 10, 2021 | www.networkworld.com
... ... ...
Different ways to loopThere are a number of ways to loop within a script. Use for when you want to loop a preset number of times. For example:
#!/bin/bash for day in Sun Mon Tue Wed Thu Fri Sat do echo $day doneor
#!/bin/bash for letter in {a..z} do echo $letter doneUse while when you want to loop as long as some condition exists or doesn't exist.
#!/bin/bash n=1 while [ $n -le 4 ] do echo $n ((n++)) doneUsing case statementsCase statements allow your scripts to react differently depending on what values are being examined. In the script below, we use different commands to extract the contents of the file provided as an argument by identifying the file type.
#!/bin/bash if [ $# -eq 0 ]; then echo -n "filename> " read filename else filename=$1 fi if [ ! -f "$filename" ]; then echo "No such file: $filename" exit fi case $filename in *.tar) tar xf $filename;; *.tar.bz2) tar xjf $filename;; *.tbz) tar xjf $filename;; *.tbz2) tar xjf $filename;; *.tgz) tar xzf $filename;; *.tar.gz) tar xzf $filename;; *.gz) gunzip $filename;; *.bz2) bunzip2 $filename;; *.zip) unzip $filename;; *.Z) uncompress $filename;; *.rar) rar x $filename ;; *) echo "No extract option for $filename" esacNote that this script also prompts for a file name if none was provided and then checks to make sure that the file specified actually exists. Only after that does it bother with the extraction.
Reacting to errorsYou can detect and react to errors within scripts and, in doing so, avoid other errors. The trick is to check the exit codes after commands are run. If an exit code has a value other than zero, an error occurred. In this script, we look to see if Apache is running, but send the output from the check to /dev/null . We then check to see if the exit code isn't equal to zero as this would indicate that the ps command did not get a response. If the exit code is not zero, the script informs the user that Apache isn't running.
#!/bin/bash ps -ef | grep apache2 > /dev/null if [ $? != 0 ]; then echo Apache is not running exit fi
softpanorama.org
Those shortcuts belong to the class of commands known as bang commands . Internet search for this term provides a wealth of additional information (which probably you do not need ;-), I will concentrate on just most common and potentially useful in the current command line environment bang commands. Of them !$ is probably the most useful and definitely is the most widely used. For many sysadmins it is the only bang command that is regularly used.
!! is the bang command that re-executes the last command . This command is used mainly as a shortcut sudo !! -- elevation of privileges after your command failed on your user account. For example:
fgrep 'kernel' /var/log/messages # it will fail due to unsufficient privileges, as /var/log directory is not readable by ordinary user sudo !! # now we re-execute the command with elevated privileges!$ puts into the current command line the last argument from previous command . For example:
mkdir -p /tmp/Bezroun/Workdir cd !$In this example the last command is equivalent to the command cd /tmp/Bezroun/Workdir. Please try this example. It is a pretty neat trick.NOTE: You can also work with individual arguments using numbers.
For example:
- !:1 is the previous command and its options
- !:2 is the first argument of the previous command
- !:3 is the second
- And so on
cp !:2 !:3 # picks up the first and the second argument from the previous commandFor this and other bang command capabilities, copying fragments of the previous command line using mouse is much more convenient, and you do not need to remember extra staff. After all, band commands were created before mouse was available, and most of them reflect the realities and needs of this bygone era. Still I met sysadmins that use this and some additional capabilities like !!:s^<old>^<new> (which replaces the string 'old' with the string 'new" and re-executes previous command) even now.The same is true for !* -- all arguments of the last command. I do not use them and have had troubles writing this part of this post, correcting it several times to make it right 4/0
Nowadays CTRL+R activates reverse search, which provides an easier way to navigate through your history then capabilities in the past provided by band commands.
linuxiac.com
The The'!'
symbol or operator in Linux can be used as Logical Negation operator as well as to fetch commands from history with tweaks or to run previously run command with modification. All the commands below have been checked explicitly in bash Shell. Though I have not checked but a major of these won't run in other shell. Here we go into the amazing and mysterious uses of'!'
symbol or operator in Linux commands.4. How to handle two or more arguments using (!)
Let's say I created a text file 1.txt on the Desktop.
$ touch /home/avi/Desktop/1.txtand then copy it to "˜ /home/avi/Downloads "˜ using complete path on either side with cp command.
$ cp /home/avi/Desktop/1.txt /home/avi/downloadsNow we have passed two arguments with cp command. First is "˜ /home/avi/Desktop/1.txt "˜ and second is "˜ /home/avi/Downloads "˜, lets handle them differently, just execute
echo [arguments]
to print both arguments differently.$ echo "1st Argument is : !^" $ echo "2nd Argument is : !cp:2"Note 1st argument can be printed as
"!^"
and rest of the arguments can be printed by executing"![Name_of_Command]:[Number_of_argument]"
.In the above example the first command was "˜ cp "˜ and 2nd argument was needed to print. Hence
5. Execute last command on the basis of keywords"!cp:2"
, if any command say xyz is run with 5 arguments and you need to get 4th argument, you may use"!xyz:4"
, and use it as you like. All the arguments can be accessed by"!*"
.We can execute the last executed command on the basis of keywords. We can understand it as follows:
$ ls /home > /dev/null [Command 1] $ ls -l /home/avi/Desktop > /dev/null [Command 2] $ ls -la /home/avi/Downloads > /dev/null [Command 3] $ ls -lA /usr/bin > /dev/null [Command 4]Here we have used same command (ls) but with different switches and for different folders. Moreover we have sent to output of each command to "˜ /dev/null "˜ as we are not going to deal with the output of the command also the console remains clean.
Now Execute last run command on the basis of keywords.
$ ! ls [Command 1] $ ! ls -l [Command 2] $ ! ls -la [Command 3] $ ! ls -lA [Command 4]Check the output and you will be astonished that you are running already executed commands just by
ls
keywords.6. The power of !! Operator
You can run/alter your last run command using
(!!)
. It will call the last run command with alter/tweak in the current command. Lets show you the scenarioLast day I run a one-liner script to get my private IP so I run,
$ ip addr show | grep inet | grep -v 'inet6'| grep -v '127.0.0.1' | awk '{print $2}' | cut -f1 -d/Then suddenly I figured out that I need to redirect the output of the above script to a file ip.txt , so what should I do? Should I retype the whole command again and redirect the output to a file? Well an easy solution is to use
UP
navigation key and add'> ip.txt'
to redirect the output to a file as.$ ip addr show | grep inet | grep -v 'inet6'| grep -v '127.0.0.1' | awk '{print $2}' | cut -f1 -d/ > ip.txtThanks to the life Savior
UP
navigation key here. Now consider the below condition, the next time I run below one-liner script.$ ifconfig | grep "inet addr:" | awk '{print $2}' | grep -v '127.0.0.1' | cut -f2 -d:As soon as I run script, the bash prompt returned an error with the message
"bash: ifconfig: command not found"
, It was not difficult for me to guess I run this command as user where it should be run as root.So what's the solution? It is difficult to login to root and then type the whole command again! Also ( UP Navigation Key ) in last example didn't came to rescue here. So? We need to call
"!!"
without quotes, which will call the last command for that user.$ su -c "!!" rootHere su is switch user which is root,
-c
is to run the specific command as the user and the most important part!!
will be replaced by command and last run command will be substituted here. Yeah! You need to provide root password.I make use of
!!
mostly in following scenarios,1. When I run apt-get command as normal user, I usually get an error saying you don't have permission to execute.
$ apt-get upgrade && apt-get dist-upgradeOpps error"¦don't worry execute below command to get it successful..
$ su -c !!Same way I do for,
$ service apache2 start or $ /etc/init.d/apache2 start or $ systemctl start apache2OOPS User not authorized to carry such task, so I run..
$ su -c 'service apache2 start' or $ su -c '/etc/init.d/apache2 start' or $ su -c 'systemctl start apache2'7. Run a command that affects all the file except ![FILE_NAME]
The
!
( Logical NOT ) can be used to run the command on all the files/extension except that is behind'!'
.A. Remove all the files from a directory except the one the name of which is 2.txt .
$ rm !(2.txt)B. Remove all the file type from the folder except the one the extension of which is "˜ pdf "˜.
$ $ rm !(*.pdf)... ... ...
- Edgar Allen May 19, 2015 at 10:30 pm
You might also mention !? It finds the last command with its' string argument. For example, if"¦
1013 grep tornado /usr/share/dict/words 1014 grep hurricane /usr/share/dict/words 1015 wc -l /usr/share/dict/wordsare all in the history then !?torn will grep for tornado again where !torn would search in vain for a command starting with torn.
And `wc !?torn?:2` works to select argument two from the command containing tornado and run `wc` on it.
- Stephen May 19, 2015 at 6:07 pm
I didn't see a mention of historical context in the article, so I'll give some here in the comments. This form of history command substitution originated with the C Shell (csh), created by Bill Joy for the BSD flavor of UNIX back in the late 70's. It was later carried into tcsh, and bash (Bourne-Again SHell).
Personally, I've always preferred the C-shell history substitution mechanism, and never really took to the fc command (that I first encountered in the Korne shell).
- suzy May 16, 2015 at 11:45 am
4th command. You can access it much simpler. There are actually regular expressions:
- ^ -- is at the begging expression
- $ -- is at the end expression
- :number -- any number parameter
Examples:
touch a.txt b.txt c.txt echo !^ ""> display first parameter echo !:1 ""> also display first parameter echo !:2 ""> display second parameter echo !:3 ""> display third parameter echo !$ ""> display last (in our case 3th) parameter echo !* ""> display all parameters- Tomasz Wiszkowski May 16, 2015 at 10:50 am
I think (5) works differently than you pointed out, and redirection to devnull hides it, but ZSh still prints the command.
When you invoke "! ls"¦", it always picks the last ls command you executed, just appends your switches at the end (after /dev/null).
One extra cool thing is the !# operator, which picks arguments from current line. Particularly good if you need to retype long path names you already typed in current line. Just say, for example
cp /some/long/path/to/file.abc !#:1And press tab. It's going to replace last argument with entire path and file name.
- Avishek Kumar May 18, 2015 at 11:37 pm
Tomasz,
For your first part of feedback: It doesn't pick the last command executed and just to prove this we have used 4 different switches for same command. ($ ! ls $ ! ls -l $ ! ls -la $ ! ls -lA ). Now you may check it by entering the keywords in any order and in each case it will output the same result.
As far as it is not working in ZSH as expected, i have already mentioned that it i have tested it on BASH and most of these won't work in other shell.
For the second part, what you mentioned is a HASH TAG in Linux Command Line and we have included it in one of our article. You may like to read it here: https://www.tecmint.com/linux-commandline-chat-server-and-remove-unwanted-packages/
May 20, 2021 | www.redhat.com
You can achieve the same result by replacing the backticks with the
$
parens, like in the example below:⯠echo "There are $(ls | wc -l) files in this directory" There are 3 files in this directoryHere's another example, still very simple but a little more realistic. I need to troubleshoot something in my network connections, so I decide to show my total and waiting connections minute by minute.
⯠cat netinfo.sh #!/bin/bash while true do ss -an > netinfo.txt connections_total=$(cat netinfo.txt | wc -l) connections_waiting=$(grep WAIT netinfo.txt | wc -l) printf "$(date +%R) - Total=%6d Waiting=%6d\n" $connections_total $connections_waiting sleep 60 done ⯠./netinfo.sh 22:59 - Total= 2930 Waiting= 977 23:00 - Total= 2923 Waiting= 963 23:01 - Total= 2346 Waiting= 397 23:02 - Total= 2497 Waiting= 541It doesn't seem like a huge difference, right? I just had to adjust the syntax. Well, there are some implications involving the two approaches. If you are like me, who automatically uses the backticks without even blinking, keep reading.
Deprecation and recommendations
Deprecation sounds like a bad word, and in many cases, it might really be bad.
When I was researching the explanations for the backtick operator, I found some discussions about "are the backtick operators deprecated?"
The short answer is: Not in the sense of "on the verge of becoming unsupported and stop working." However, backticks should be avoided and replaced by the
$
parens syntax.The main reasons for that are (in no particular order):
1. Backticks operators can become messy if the internal commands also use backticks.
- You will need to escape the internal backticks, and if you have single quotes as part of the commands or part of the results, reading and troubleshooting the script can become difficult.
- If you start thinking about nesting backtick operators inside other backtick operators, things will not work as expected or not work at all. Don't bother.
2. The
$
parens operator is safer and more predictable.
- What you code inside the
$
parens operator is treated as a shell script. Syntactically it is the same thing as having that code in a text file, so you can expect that everything you would code in an isolated shell script would work here.Here are some examples of the behavioral differences between backticks and
$
parens:⯠echo '\$x' \$x ⯠echo `echo '\$x'` $x ⯠echo $(echo '\$x') \$xYou can find additional examples of the differences between backticks and
$
parens behavior here .[ Free cheat sheet: Get a list of Linux utilities and commands for managing servers and networks . ]
Wrapping upIf you compare the two approaches, it seems logical to think that you should always/only use the
$
parens approach. And you might think that the backtick operators are only used by sysadmins from an older era .Well, that might be true, as sometimes I use things that I learned long ago, and in simple situations, my "muscle memory" just codes it for me. For those ad-hoc commands that you know that do not contain any nasty characters, you might be OK using backticks. But for anything that is more perennial or more complex/sophisticated, please go with the
$
parens approach.
May 23, 2021 | www.redhat.com
Handling optionsThe ability for a Bash script to handle command line options such as
-h
to display help gives you some powerful capabilities to direct the program and modify what it does. In the case of your-h
option, you want the program to print the help text to the terminal session and then quit without running the rest of the program. The ability to process options entered at the command line can be added to the Bash script using thewhile
command in conjunction with thegetops
andcase
commands.The
getops
command reads any and all options specified at the command line and creates a list of those options. Thewhile
command loops through the list of options by setting the variable $options for each in the code below. Thecase
statement is used to evaluate each option in turn and execute the statements in the corresponding stanza. Thewhile
statement will continue to assess the list of options until they have all been processed or an exit statement is encountered, which terminates the program.Be sure to delete the help function call just before the echo "Hello world!" statement so that the main body of the program now looks like this.
############################################################ ############################################################ # Main program # ############################################################ ############################################################ ############################################################ # Process the input options. Add options as needed. # ############################################################ # Get the options while getopts ":h" option; do case $option in h) # display Help Help exit;; esac done echo "Hello world!"Notice the double semicolon at the end of the exit statement in the case option for
-h
. This is required for each option. Add to this case statement to delineate the end of each option.Testing is now a little more complex. You need to test your program with several different options -- and no options -- to see how it responds. First, check to ensure that with no options that it prints "Hello world!" as it should.
[student@testvm1 ~]$ hello.sh Hello world!That works, so now test the logic that displays the help text.
[student@testvm1 ~]$ hello.sh -h Add a description of the script functions here. Syntax: scriptTemplate [-g|h|t|v|V] options: g Print the GPL license notification. h Print this Help. v Verbose mode. V Print software version and exit.That works as expected, so now try some testing to see what happens when you enter some unexpected options.
[student@testvm1 ~]$ hello.sh -x Hello world![student@testvm1 ~]$ hello.sh -q Hello world![student@testvm1 ~]$ hello.sh -lkjsahdf Add a description of the script functions here. Syntax: scriptTemplate [-g|h|t|v|V] options: g Print the GPL license notification. h Print this Help. v Verbose mode. V Print software version and exit. [student@testvm1 ~]$Handling invalid optionsThe program just ignores the options for which you haven't created specific responses without generating any errors. Although in the last entry with the
-lkjsahdf
options, because there is an "h" in the list, the program did recognize it and print the help text. Testing has shown that one thing that is missing is the ability to handle incorrect input and terminate the program if any is detected.You can add another case stanza to the case statement that will match any option for which there is no explicit match. This general case will match anything you haven't provided a specific match for. The case statement now looks like this.
while getopts ":h" option; do case $option in h) # display Help Help exit;; \?) # Invalid option echo "Error: Invalid option" exit;; esac doneKubernetes and OpenShift
- Free cheatsheet: Kubernetes and Minikube
- Free ebook: Designing Cloud-Native Applications
- Interactive course: Getting Started with OpenShift
- Free ebook: Build Applications with Kubernetes and Openshift
This bit of code deserves an explanation about how it works. It seems complex but is fairly easy to understand. The while – done structure defines a loop that executes once for each option in the getopts – option structure. The ":h" string -- which requires the quotes -- lists the possible input options that will be evaluated by the case – esac structure. Each option listed must have a corresponding stanza in the case statement. In this case, there are two. One is the h) stanza which calls the Help procedure. After the Help procedure completes, execution returns to the next program statement, exit;; which exits from the program without executing any more code even if some exists. The option processing loop is also terminated, so no additional options would be checked.
Notice the catch-all match of \? as the last stanza in the case statement. If any options are entered that are not recognized, this stanza prints a short error message and exits from the program.
Any additional specific cases must precede the final catch-all. I like to place the case stanzas in alphabetical order, but there will be circumstances where you want to ensure that a particular case is processed before certain other ones. The case statement is sequence sensitive, so be aware of that when you construct yours.
The last statement of each stanza in the case construct must end with the double semicolon (
;;
), which is used to mark the end of each stanza explicitly. This allows those programmers who like to use explicit semicolons for the end of each statement instead of implicit ones to continue to do so for each statement within each case stanza.Test the program again using the same options as before and see how this works now.
The Bash script now looks like this.
#!/bin/bash ############################################################ # Help # ############################################################ Help() { # Display Help echo "Add description of the script functions here." echo echo "Syntax: scriptTemplate [-g|h|v|V]" echo "options:" echo "g Print the GPL license notification." echo "h Print this Help." echo "v Verbose mode." echo "V Print software version and exit." echo } ############################################################ ############################################################ # Main program # ############################################################ ############################################################ ############################################################ # Process the input options. Add options as needed. # ############################################################ # Get the options while getopts ":h" option; do case $option in h) # display Help Help exit;; \?) # Invalid option echo "Error: Invalid option" exit;; esac done echo "hello world!"Be sure to test this version of your program very thoroughly. Use random input and see what happens. You should also try testing valid and invalid options without using the dash (
-
) in front.Using options to enter dataFirst, add a variable and initialize it. Add the two lines shown in bold in the segment of the program shown below. This initializes the $Name variable to "world" as the default.
<snip> ############################################################ ############################################################ # Main program # ############################################################ ############################################################ # Set variables Name="world" ############################################################ # Process the input options. Add options as needed. # <snip>Change the last line of the program, the
echo
command, to this.echo "hello $Name!"Add the logic to input a name in a moment but first test the program again. The result should be exactly the same as before.
[dboth@david ~]$ hello.sh hello world! [dboth@david ~]$# Get the options while getopts ":hn:" option; do case $option in h) # display Help Help exit;; n) # Enter a name Name=$OPTARG;; \?) # Invalid option echo "Error: Invalid option" exit;; esac done$OPTARG is always the variable name used for each new option argument, no matter how many there are. You must assign the value in $OPTARG to a variable name that will be used in the rest of the program. This new stanza does not have an exit statement. This changes the program flow so that after processing all valid options in the case statement, execution moves on to the next statement after the case construct.
Test the revised program.
[dboth@david ~]$ hello.sh hello world![dboth@david ~]$ hello.sh -n LinuxGeek46 hello LinuxGeek46![dboth@david ~]$ hello.sh -n "David Both" hello David Both! [dboth@david ~]$The completed program looks like this.
#!/bin/bash ############################################################ # Help # ############################################################ Help() { # Display Help echo "Add description of the script functions here." echo echo "Syntax: scriptTemplate [-g|h|v|V]" echo "options:" echo "g Print the GPL license notification." echo "h Print this Help." echo "v Verbose mode." echo "V Print software version and exit." echo } ############################################################ ############################################################ # Main program # ############################################################ ############################################################ # Set variables Name="world" ############################################################ # Process the input options. Add options as needed. # ############################################################ # Get the options while getopts ":hn:" option; do case $option in h) # display Help Help exit;; n) # Enter a name Name=$OPTARG;; \?) # Invalid option echo "Error: Invalid option" exit;; esac done echo "hello $Name!"Be sure to test the help facility and how the program reacts to invalid input to verify that its ability to process those has not been compromised. If that all works as it should, then you have successfully learned how to use options and option arguments.
May 23, 2021 | sookocheff.com
The Bash String Operators Posted on December 11, 2014 | 3 minutes | Kevin Sookocheff
A common task in bash programming is to manipulate portions of a string and return the result. bash provides rich support for these manipulations via string operators. The syntax is not always intuitive so I wanted to use this blog post to serve as a permanent reminder of the operators.
The string operators are signified with the
Substring Extraction${}
notation. The operations can be grouped in to a few classes. Each heading in this article describes a class of operation.
Extract from a position1${string:position}Extraction returns a substring of
string
starting atposition
and ending at the end ofstring
.string
is treated as an array of characters starting at 0.1 2 3 4 5> string="hello world" > echo ${string:1} ello world > echo ${string:6} world
Extract from a position with a length${string:position:length}Adding a length returns a substring only as long as the
length
parameter.> string="hello world" > echo ${string:1:2} el > echo ${string:6:3} worSubstring Removal
Remove shortest starting match${variable#pattern}If
variable
starts withpattern
, delete the shortest part that matches the pattern.> string="hello world, hello jim" > echo ${string#*hello} world, hello jim
Remove longest starting match${variable##pattern}If
variable
starts withpattern
, delete the longest match fromvariable
and return the rest.> string="hello world, hello jim" > echo ${string##*hello} jim
Remove shortest ending match${variable%pattern}If
variable
ends withpattern
, delete the shortest match from the end ofvariable
and return the rest.> string="hello world, hello jim" > echo ${string%hello*} hello world,
Remove longest ending match${variable%%pattern}If
variable
ends withpattern
, delete the longest match from the end ofvariable
and return the rest.> string="hello world, hello jim" > echo ${string%%hello*}Substring Replacement
Replace first occurrence of word${variable/pattern/string}Find the first occurrence of
pattern
invariable
and replace it withstring
. Ifstring
is null,pattern
is deleted fromvariable
. Ifpattern
starts with#
, the match must occur at the beginning ofvariable
. Ifpattern
starts with%
, the match must occur at the end of thevariable
.> string="hello world, hello jim" > echo ${string/hello/goodbye} goodbye world, hello jim
Replace all occurrences of word${variable//pattern/string}Same as above but finds all occurrences of
pattern
invariable
and replace them withstring
. Ifstring
is null,pattern
is deleted fromvariable
.> string="hello world, hello jim" > echo ${string//hello/goodbye} goodbye world, goodbye jim
See alsobash
May 10, 2021 | www.xmodulo.com
When you need to split a string in bash, you can use bash's built-in
read
command. This command reads a single line of string from stdin, and splits the string on a delimiter. The split elements are then stored in either an array or separate variables supplied with theread
command. The default delimiter is whitespace characters (' ', '\t', '\r', '\n'). If you want to split a string on a custom delimiter, you can specify the delimiter inIFS
variable before callingread
.# strings to split var1="Harry Samantha Bart Amy" var2="green:orange:black:purple" # split a string by one or more whitespaces, and store the result in an array read -a my_array <<< $var1 # iterate the array to access individual split words for elem in "${my_array[@]}"; do echo $elem done echo "----------" # split a string by a custom delimter IFS=':' read -a my_array2 <<< $var2 for elem in "${my_array2[@]}"; do echo $elem doneHarry Samantha Bart Amy ---------- green orange black purple
May 10, 2021 | www.xmodulo.com
Remove a Trailing Newline Character from a String in Bash
If you want to remove a trailing newline or carriage return character from a string, you can use the bash's parameter expansion in the following form.
${string%$var}This expression implies that if the "string" contains a trailing character stored in "var", the result of the expression will become the "string" without the character. For example:
# input string with a trailing newline character input_line=$'This is my example line\n' # define a trailing character. For carriage return, replace it with $'\r' character=$'\n' echo -e "($input_line)" # remove a trailing newline character input_line=${input_line%$character} echo -e "($input_line)"(This is my example line ) (This is my example line)Trim Leading/Trailing Whitespaces from a String in BashIf you want to remove whitespaces at the beginning or at the end of a string (also known as leading/trailing whitespaces) from a string, you can use
sed
command.my_str=" This is my example string " # original string with leading/trailing whitespaces echo -e "($my_str)" # trim leading whitespaces in a string my_str=$(echo "$my_str" | sed -e "s/^[[:space:]]*//") echo -e "($my_str)" # trim trailing whitespaces in a string my_str=$(echo "$my_str" | sed -e "s/[[:space:]]*$//") echo -e "($my_str)"( This is my example string ) (This is my example string ) ← leading whitespaces removed (This is my example string) ← trailing whitespaces removedIf you want to stick with bash's built-in mechanisms, the following bash function can get the job done.
trim() { local var="$*" # remove leading whitespace characters var="${var#"${var%%[![:space:]]*}"}" # remove trailing whitespace characters var="${var%"${var##*[![:space:]]}"}" echo "$var" } my_str=" This is my example string " echo "($my_str)" my_str=$(trim $my_str) echo "($my_str)"
May 10, 2021 | www.oreilly.com
Table 4-1. Substitution Operators
Operator Substitution $ { varname :- word } If varname exists and isn't null, return its value; otherwise return word .
Purpose : Returning a default value if the variable is undefined.
Example : ${count:-0} evaluates to 0 if count is undefined.
$ { varname := word } If varname exists and isn't null, return its value; otherwise set it to word and then return its value. Positional and special parameters cannot be assigned this way.
Purpose : Setting a variable to a default value if it is undefined.
Example : $ {count := 0} sets count to 0 if it is undefined.
$ { varname :? message } If varname exists and isn't null, return its value; otherwise print varname : followed by message , and abort the current command or script (non-interactive shells only). Omitting message produces the default message parameter null or not set .
Purpose : Catching errors that result from variables being undefined.
Example : {count :?" undefined! " } prints "count: undefined!" and exits if count is undefined.
$ { varname : + word } If varname exists and isn't null, return word ; otherwise return null.
Purpose : Testing for the existence of a variable.
Example : $ {count :+ 1} returns 1 (which could mean "true") if count is defined.
$ { varname : offset } $ { varname : offset : length } Performs substring expansion. a It returns the substring of $ varname starting at offset and up to length characters. The first character in $ varname is position 0. If length is omitted, the substring starts at offset and continues to the end of $ varname . If offset is less than 0 then the position is taken from the end of $ varname . If varname is @ , the length is the number of positional parameters starting at parameter offset .
Purpose : Returning parts of a string (substrings or slices ).
Example : If count is set to frogfootman , $ {count :4} returns footman . $ {count :4:4} returns foot .
[ 52 ]
Table 4-2. Pattern-Matching Operators
Operator Meaning $ { variable # pattern } If the pattern matches the beginning of the variable's value, delete the shortest part that matches and return the rest.
$ { variable ## pattern } If the pattern matches the beginning of the variable's value, delete the longest part that matches and return the rest.
$ { variable % pattern } If the pattern matches the end of the variable's value, delete the shortest part that matches and return the rest.
$ { variable %% pattern } If the pattern matches the end of the variable's value, delete the longest part that matches and return the rest.
$ { variable / pattern / string } $ { variable // pattern / string } The longest match to pattern in variable is replaced by string . In the first form, only the first match is replaced. In the second form, all matches are replaced. If the pattern is begins with a # , it must match at the start of the variable. If it begins with a % , it must match with the end of the variable. If string is null, the matches are deleted. If variable is @ or * , the operation is applied to each positional parameter in turn and the expansion is the resultant list. a
May 10, 2021 | linuxize.com
Another way of concatenating strings in bash is by appending variables or literal strings to a variable using the
+=
operator:VAR1="Hello, " VAR1+=" World" echo "$VAR1"CopyHello, World CopyThe following example is using the
languages.sh+=
operator to concatenate strings in bash for loop :VAR="" for ELEMENT in 'Hydrogen' 'Helium' 'Lithium' 'Beryllium'; do VAR+="${ELEMENT} " done echo "$VAR"CopyHydrogen Helium Lithium Beryllium
May 10, 2021 | sites.google.com
The curly-bracket syntax allows for the shell's string operators . String operators allow you to manipulate values of variables in various useful ways without having to write full-blown programs or resort to external UNIX utilities. You can do a lot with string-handling operators even if you haven't yet mastered the programming features we'll see in later chapters.
In particular, string operators let you do the following:
4.3.1 Syntax of String Operators
- Ensure that variables exist (i.e., are defined and have non-null values)
- Set default values for variables
- Catch errors that result from variables not being set
- Remove portions of variables' values that match patterns
The basic idea behind the syntax of string operators is that special characters that denote operations are inserted between the variable's name and the right curly brackets. Any argument that the operator may need is inserted to the operator's right.
The first group of string-handling operators tests for the existence of variables and allows substitutions of default values under certain conditions. These are listed in Table 4.1 . [6]
[6] The colon (
:
) in each of these operators is actually optional. If the colon is omitted, then change "exists and isn't null" to "exists" in each definition, i.e., the operator tests for existence only.
Table 4.1: Substitution Operators Operator Substitution ${ varname :- word } If varname exists and isn't null, return its value; otherwise return word . Purpose : Returning a default value if the variable is undefined. Example : ${count:-0} evaluates to 0 if count is undefined. ${ varname := word} If varname exists and isn't null, return its value; otherwise set it to word and then return its value.[7] Purpose : Setting a variable to a default value if it is undefined. Example : $
{count:=0} sets count to 0 if it is undefined.${ varname :?
message }If varname exists and isn't null, return its value; otherwise print varname : followed by message , and abort the current command or script. Omitting message produces the default message parameter null or not set . Purpose : Catching errors that result from variables being undefined. Example : {count :?"
undefined!"
} prints "count: undefined!" and exits if count is undefined.${ varname :+
word }If varname exists and isn't null, return word ; otherwise return null. Purpose : Testing for the existence of a variable. Example : ${count:+1} returns 1 (which could mean "true") if count is defined. [7] Pascal, Modula, and Ada programmers may find it helpful to recognize the similarity of this to the assignment operators in those languages.
The first two of these operators are ideal for setting defaults for command-line arguments in case the user omits them. We'll use the first one in our first programming task.
Task 4.1You have a large album collection, and you want to write some software to keep track of it. Assume that you have a file of data on how many albums you have by each artist. Lines in the file look like this:
14 Bach, J.S. 1 Balachander, S. 21 Beatles 6 Blakey, ArtWrite a program that prints the N highest lines, i.e., the N artists by whom you have the most albums. The default for N should be 10. The program should take one argument for the name of the input file and an optional second argument for how many lines to print.
By far the best approach to this type of script is to use built-in UNIX utilities, combining them with I/O redirectors and pipes. This is the classic "building-block" philosophy of UNIX that is another reason for its great popularity with programmers. The building-block technique lets us write a first version of the script that is only one line long:
sort -nr $1 | head -${2:-10}Here is how this works: the sort (1) program sorts the data in the file whose name is given as the first argument ( $1 ). The -n option tells sort to interpret the first word on each line as a number (instead of as a character string); the -r tells it to reverse the comparisons, so as to sort in descending order.
The output of sort is piped into the head (1) utility, which, when given the argument - N , prints the first N lines of its input on the standard output. The expression -${2:-10} evaluates to a dash ( - ) followed by the second argument if it is given, or to -10 if it's not; notice that the variable in this expression is 2 , which is the second positional parameter.
Assume the script we want to write is called highest . Then if the user types highest myfile , the line that actually runs is:
sort -nr myfile | head -10Or if the user types highest myfile 22 , the line that runs is:
sort -nr myfile | head -22Make sure you understand how the :- string operator provides a default value.
This is a perfectly good, runnable script-but it has a few problems. First, its one line is a bit cryptic. While this isn't much of a problem for such a tiny script, it's not wise to write long, elaborate scripts in this manner. A few minor changes will make the code more readable.
First, we can add comments to the code; anything between # and the end of a line is a comment. At a minimum, the script should start with a few comment lines that indicate what the script does and what arguments it accepts. Second, we can improve the variable names by assigning the values of the positional parameters to regular variables with mnemonic names. Finally, we can add blank lines to space things out; blank lines, like comments, are ignored. Here is a more readable version:
# # highest filename [howmany] # # Print howmany highest-numbered lines in file filename. # The input file is assumed to have lines that start with # numbers. Default for howmany is 10. # filename=$1 howmany=${2:-10} sort -nr $filename | head -$howmanyThe square brackets around howmany in the comments adhere to the convention in UNIX documentation that square brackets denote optional arguments.
The changes we just made improve the code's readability but not how it runs. What if the user were to invoke the script without any arguments? Remember that positional parameters default to null if they aren't defined. If there are no arguments, then $1 and $2 are both null. The variable howmany ( $2 ) is set up to default to 10, but there is no default for filename ( $1 ). The result would be that this command runs:
sort -nr | head -10As it happens, if sort is called without a filename argument, it expects input to come from standard input, e.g., a pipe (|) or a user's terminal. Since it doesn't have the pipe, it will expect the terminal. This means that the script will appear to hang! Although you could always type [CTRL-D] or [CTRL-C] to get out of the script, a naive user might not know this.
Therefore we need to make sure that the user supplies at least one argument. There are a few ways of doing this; one of them involves another string operator. We'll replace the line:
filename=$1with:
filename=${1:?"filename missing."}This will cause two things to happen if a user invokes the script without any arguments: first the shell will print the somewhat unfortunate message:
highest: 1: filename missing.to the standard error output. Second, the script will exit without running the remaining code.
With a somewhat "kludgy" modification, we can get a slightly better error message. Consider this code:
filename=$1 filename=${filename:?"missing."}This results in the message:
highest: filename: missing.(Make sure you understand why.) Of course, there are ways of printing whatever message is desired; we'll find out how in Chapter 5 .
Before we move on, we'll look more closely at the two remaining operators in Table 4.1 and see how we can incorporate them into our task solution. The := operator does roughly the same thing as :- , except that it has the "side effect" of setting the value of the variable to the given word if the variable doesn't exist.
Therefore we would like to use := in our script in place of :- , but we can't; we'd be trying to set the value of a positional parameter, which is not allowed. But if we replaced:
howmany=${2:-10}with just:
howmany=$2and moved the substitution down to the actual command line (as we did at the start), then we could use the := operator:
sort -nr $filename | head -${howmany:=10}Using := has the added benefit of setting the value of howmany to 10 in case we need it afterwards in later versions of the script.
The final substitution operator is :+ . Here is how we can use it in our example: Let's say we want to give the user the option of adding a header line to the script's output. If he or she types the option -h , then the output will be preceded by the line:
ALBUMS ARTISTAssume further that this option ends up in the variable header , i.e., $header is -h if the option is set or null if not. (Later we will see how to do this without disturbing the other positional parameters.)
The expression:
${header:+"ALBUMS ARTIST\n"}yields null if the variable header is null, or ALBUMS══ARTIST\n if it is non-null. This means that we can put the line:
print -n ${header:+"ALBUMS ARTIST\n"}right before the command line that does the actual work. The -n option to print causes it not to print a LINEFEED after printing its arguments. Therefore this print statement will print nothing-not even a blank line-if header is null; otherwise it will print the header line and a LINEFEED (\n).
4.3.2 Patterns and Regular ExpressionsWe'll continue refining our solution to Task 4-1 later in this chapter. The next type of string operator is used to match portions of a variable's string value against patterns . Patterns, as we saw in Chapter 1 are strings that can contain wildcard characters (
*
,?
, and [] for character sets and ranges).Wildcards have been standard features of all UNIX shells going back (at least) to the Version 6 Bourne shell. But the Korn shell is the first shell to add to their capabilities. It adds a set of operators, called regular expression (or regexp for short) operators, that give it much of the string-matching power of advanced UNIX utilities like awk (1), egrep (1) (extended grep (1)) and the emacs editor, albeit with a different syntax. These capabilities go beyond those that you may be used to in other UNIX utilities like grep , sed (1) and vi (1).
Advanced UNIX users will find the Korn shell's regular expression capabilities occasionally useful for script writing, although they border on overkill. (Part of the problem is the inevitable syntactic clash with the shell's myriad other special characters.) Therefore we won't go into great detail about regular expressions here. For more comprehensive information, the "last word" on practical regular expressions in UNIX is sed & awk , an O'Reilly Nutshell Handbook by Dale Dougherty. If you are already comfortable with awk or egrep , you may want to skip the following introductory section and go to "Korn Shell Versus awk/egrep Regular Expressions" below, where we explain the shell's regular expression mechanism by comparing it with the syntax used in those two utilities. Otherwise, read on.
4.3.2.1 Regular expression basicsThink of regular expressions as strings that match patterns more powerfully than the standard shell wildcard schema. Regular expressions began as an idea in theoretical computer science, but they have found their way into many nooks and crannies of everyday, practical computing. The syntax used to represent them may vary, but the concepts are very much the same.
A shell regular expression can contain regular characters, standard wildcard characters, and additional operators that are more powerful than wildcards. Each such operator has the form x ( exp ) , where x is the particular operator and exp is any regular expression (often simply a regular string). The operator determines how many occurrences of exp a string that matches the pattern can contain. See Table 4.2 and Table 4.3 .
Table 4.2: Regular Expression Operators Operator Meaning *
( exp )0 or more occurrences of exp +
( exp )1 or more occurrences of exp ?
( exp )0 or 1 occurrences of exp @ ( exp1 | exp2 |...) exp1 or exp2 or... ! ( exp ) Anything that doesn't match exp [8] [8] Actually, !( exp ) is not a regular expression operator by the standard technical definition, though it is a handy extension.
Table 4.3: Regular Expression Operator Examples Expression Matches x x *
( x )Null string, x , xx , xxx , ... +
( x )x , xx , xxx , ... ?
( x )Null string, x !
( x )Any string except x @
( x )x (see below) Regular expressions are extremely useful when dealing with arbitrary text, as you already know if you have used grep or the regular-expression capabilities of any UNIX editor. They aren't nearly as useful for matching filenames and other simple types of information with which shell users typically work. Furthermore, most things you can do with the shell's regular expression operators can also be done (though possibly with more keystrokes and less efficiency) by piping the output of a shell command through grep or egrep .
Nevertheless, here are a few examples of how shell regular expressions can solve filename-listing problems. Some of these will come in handy in later chapters as pieces of solutions to larger tasks.
- The emacs editor supports customization files whose names end in .el (for Emacs LISP) or .elc (for Emacs LISP Compiled). List all emacs customization files in the current directory.
- In a directory of C source code, list all files that are not necessary. Assume that "necessary" files end in .c or .h , or are named Makefile or README .
- Filenames in the VAX/VMS operating system end in a semicolon followed by a version number, e.g., fred.bob;23 . List all VAX/VMS-style filenames in the current directory.
Here are the solutions:
- In the first of these, we are looking for files that end in .el with an optional c . The expression that matches this is
*
.el?
(c) .- The second example depends on the four standard subexpressions
*
.c ,*
.h , Makefile , and README . The entire expression is !(*
.c|*
.h|Makefile|README) , which matches anything that does not match any of the four possibilities.- The solution to the third example starts with
*
\;
: the shell wildcard*
followed by a backslash-escaped semicolon. Then, we could use the regular expression +([0-9]) , which matches one or more characters in the range [0-9] , i.e., one or more digits. This is almost correct (and probably close enough), but it doesn't take into account that the first digit cannot be 0. Therefore the correct expression is*
\;[1-9]*
([0-9]) , which matches anything that ends with a semicolon, a digit from 1 to 9, and zero or more digits from 0 to 9.Regular expression operators are an interesting addition to the Korn shell's features, but you can get along well without them-even if you intend to do a substantial amount of shell programming.
In our opinion, the shell's authors missed an opportunity to build into the wildcard mechanism the ability to match files by type (regular, directory, executable, etc., as in some of the conditional tests we will see in Chapter 5 ) as well as by name component. We feel that shell programmers would have found this more useful than arcane regular expression operators.
The following section compares Korn shell regular expressions to analogous features in awk and egrep . If you aren't familiar with these, skip to the section entitled "Pattern-matching Operators."
4.3.2.2 Korn shell versus awk/egrep regular expressionsTable 4.4 is an expansion of Table 4.2 : the middle column shows the equivalents in awk / egrep of the shell's regular expression operators.
Table 4.4: Shell Versus egrep/awk Regular Expression Operators Korn Shell egrep/awk Meaning *
( exp )exp *
0 or more occurrences of exp +( exp ) exp + 1 or more occurrences of exp ?
( exp )exp ?
0 or 1 occurrences of exp @( exp1 | exp2 |...) exp1 | exp2 |... exp1 or exp2 or... ! ( exp ) (none) Anything that doesn't match exp These equivalents are close but not quite exact. Actually, an exp within any of the Korn shell operators can be a series of exp1 | exp2 |... alternates. But because the shell would interpret an expression like dave|fred|bob as a pipeline of commands, you must use @(dave|fred|bob) for alternates by themselves.
For example:
- @(dave|fred|bob) matches dave , fred , or bob .
*
(dave|fred|bob) means, "0 or more occurrences of dave , fred , or bob ". This expression matches strings like the null string, dave , davedave , fred , bobfred , bobbobdavefredbobfred , etc.- +(dave|fred|bob) matches any of the above except the null string.
- ?(dave|fred|bob) matches the null string, dave , fred , or bob .
- !(dave|fred|bob) matches anything except dave , fred , or bob .
It is worth re-emphasizing that shell regular expressions can still contain standard shell wildcards. Thus, the shell wildcard ? (match any single character) is the equivalent to . in egrep or awk , and the shell's character set operator [ ... ] is the same as in those utilities. [9] For example, the expression +([0-9]) matches a number, i.e., one or more digits. The shell wildcard character
*
is equivalent to the shell regular expression*
(?)
.[9] And, for that matter, the same as in grep , sed , ed , vi , etc.
A few egrep and awk regexp operators do not have equivalents in the Korn shell. These include:
- The beginning- and end-of-line operators ^ and $ .
- The beginning- and end-of-word operators \< and \> .
- Repeat factors like \{ N \} and \{ M , N \} .
The first two pairs are hardly necessary, since the Korn shell doesn't normally operate on text files and does parse strings into words itself.
4.3.3 Pattern-matching OperatorsTable 4.5 lists the Korn shell's pattern-matching operators.
Table 4.5: Pattern-matching Operators Operator Meaning $ { variable # pattern } If the pattern matches the beginning of the variable's value, delete the shortest part that matches and return the rest. $ { variable ## pattern } If the pattern matches the beginning of the variable's value, delete the longest part that matches and return the rest. $ { variable % pattern } If the pattern matches the end of the variable's value, delete the shortest part that matches and return the rest. $ { variable %% pattern } If the pattern matches the end of the variable's value, delete the longest part that matches and return the rest. These can be hard to remember, so here's a handy mnemonic device: # matches the front because number signs precede numbers; % matches the rear because percent signs follow numbers.
The classic use for pattern-matching operators is in stripping off components of pathnames, such as directory prefixes and filename suffixes. With that in mind, here is an example that shows how all of the operators work. Assume that the variable path has the value /home /billr/mem/long.file.name ; then:
Expression Result ${path##/*/} long.file.name ${path#/*/} billr/mem/long.file.name $path /home/billr/mem/long.file.name ${path%.*} /home/billr/mem/long.file ${path%%.*} /home/billr/mem/longThe two patterns used here are
/*/
, which matches anything between two slashes, and .*
, which matches a dot followed by anything.We will incorporate one of these operators into our next programming task.
Task 4.2You are writing a C compiler, and you want to use the Korn shell for your front-end.[10]
[10] Don't laugh-many UNIX compilers have shell scripts as front-ends.
Think of a C compiler as a pipeline of data processing components. C source code is input to the beginning of the pipeline, and object code comes out of the end; there are several steps in between. The shell script's task, among many other things, is to control the flow of data through the components and to designate output files.
You need to write the part of the script that takes the name of the input C source file and creates from it the name of the output object code file. That is, you must take a filename ending in .c and create a filename that is similar except that it ends in .o .
The task at hand is to strip the .c off the filename and append .o . A single shell statement will do it:
objname=${filename%.c}.oThis tells the shell to look at the end of filename for .c . If there is a match, return $filename with the match deleted. So if filename had the value fred.c , the expression ${filename%.c} would return fred . The .o is appended to make the desired fred.o , which is stored in the variable objname .
If filename had an inappropriate value (without .c ) such as fred.a , the above expression would evaluate to fred.a.o : since there was no match, nothing is deleted from the value of filename , and .o is appended anyway. And, if filename contained more than one dot-e.g., if it were the y.tab.c that is so infamous among compiler writers-the expression would still produce the desired y.tab.o . Notice that this would not be true if we used %% in the expression instead of % . The former operator uses the longest match instead of the shortest, so it would match .tab.o and evaluate to y.o rather than y.tab.o . So the single % is correct in this case.
A longest-match deletion would be preferable, however, in the following task.
Task 4.3You are implementing a filter that prepares a text file for printer output. You want to put the file's name-without any directory prefix-on the "banner" page. Assume that, in your script, you have the pathname of the file to be printed stored in the variable pathname .
Clearly the objective is to remove the directory prefix from the pathname. The following line will do it:
bannername=${pathname##*/}This solution is similar to the first line in the examples shown before. If pathname were just a filename, the pattern
*
/ (anything followed by a slash) would not match and the value of the expression would be pathname untouched. If pathname were something like fred/bob , the prefix fred/ would match the pattern and be deleted, leaving just bob as the expression's value. The same thing would happen if pathname were something like /dave/pete/fred/bob : since the ## deletes the longest match, it deletes the entire /dave/pete/fred/ .If we used #
*
/ instead of ##*
/ , the expression would have the incorrect value dave/pete/fred/bob , because the shortest instance of "anything followed by a slash" at the beginning of the string is just a slash ( / ).The construct $ { variable ##
4.3.4 Length Operator*
/} is actually equivalent to the UNIX utility basename (1). basename takes a pathname as argument and returns the filename only; it is meant to be used with the shell's command substitution mechanism (see below). basename is less efficient than $ { variable ##/*
} because it runs in its own separate process rather than within the shell. Another utility, dirname (1), does essentially the opposite of basename : it returns the directory prefix only. It is equivalent to the Korn shell expression $ { variable %/*
} and is less efficient for the same reason.There are two remaining operators on variables. One is $ {# varname }, which returns the length of the value of the variable as a character string. (In Chapter 6 we will see how to treat this and similar values as actual numbers so they can be used in arithmetic expressions.) For example, if filename has the value fred.c , then ${#filename} would have the value 6 . The other operator ( $ {# array [
*
]} ) has to do with array variables, which are also discussed in Chapter 6 .
Mar 29, 2021 | www.xmodulo.com
When you are writing a bash script, there are situations where you need to generate a sequence of numbers or strings . One common use of such sequence data is for loop iteration. When you iterate over a range of numbers, the range may be defined in many different ways (e.g., [0, 1, 2,..., 99, 100], [50, 55, 60,..., 75, 80], [10, 9, 8,..., 1, 0], etc). Loop iteration may not be just over a range of numbers. You may need to iterate over a sequence of strings with particular patterns (e.g., incrementing filenames; img001.jpg, img002.jpg, img003.jpg). For this type of loop control, you need to be able to generate a sequence of numbers and/or strings flexibly.
While you can use a dedicated tool like
Brace Expansionseq
to generate a range of numbers, it is really not necessary to add such external dependency in your bash script when bash itself provides a powerful built-in range function called brace expansion . In this tutorial, let's find out how to generate a sequence of data in bash using brace expansion and what are useful brace expansion examples .Bash's built-in range function is realized by so-called brace expansion . In a nutshell, brace expansion allows you to generate a sequence of strings based on supplied string and numeric input data. The syntax of brace expansion is the following.
{<string1>,<string2>,...,<stringN>} {<start-number>..<end-number>} {<start-number>..<end-number>..<increment>} <prefix-string>{......} {......}<suffix-string> <prefix-string>{......}<suffix-string>All these sequence expressions are iterable, meaning you can use them for while/for loops . In the rest of the tutorial, let's go over each of these expressions to clarify their use cases.
https://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=5674857721&adk=3047986842&adf=3341013331&pi=t.ma~as.5674857721&w=1200&fwrn=4&lmt=1617109287&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Frange-sequence-expression-bash.html&flash=0&wgl=1&dt=1617311559984&bpp=49&bdt=419&idt=296&shv=r20210331&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280&correlator=486211930057&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617311560&ga_hid=1542200251&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=1350&biw=1519&bih=762&scr_x=0&scr_y=0&eid=42530672%2C44740079%2C44739537%2C44739387&oid=3&pvsid=2774697899597512&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C762&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&ifi=2&uci=a!2&btvi=1&fsb=1&xpc=Ug4rFEoUn3&p=https%3A//www.xmodulo.com&dtd=306
Use Case #1: List a Sequence of StringsThe first use case of brace expansion is a simple string list, which is a comma-separated list of string literals within the braces. Here we are not generating a sequence of data, but simply list a pre-defined sequence of string data.
{<string1>,<string2>,...,<stringN>}You can use this brace expansion to iterate over the string list as follows.
for fruit in {apple,orange,lemon}; do echo $fruit doneapple orange lemonThis expression is also useful to invoke a particular command multiple times with different parameters.
For example, you can create multiple subdirectories in one shot with:
$ mkdir -p /home/xmodulo/users/{dan,john,alex,michael,emma}To create multiple empty files:
$ touch /tmp/{1,2,3,4}.logUse Case #2: Define a Range of Numbershttps://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=1246960885&adk=2798017750&adf=1795540232&pi=t.ma~as.1246960885&w=1200&fwrn=4&lmt=1617109287&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Frange-sequence-expression-bash.html&flash=0&wgl=1&dt=1617311560086&bpp=3&bdt=522&idt=212&shv=r20210331&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280%2C1200x200&correlator=486211930057&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617311560&ga_hid=1542200251&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=2661&biw=1519&bih=762&scr_x=0&scr_y=0&eid=42530672%2C44740079%2C44739537%2C44739387&oid=3&pvsid=2774697899597512&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C762&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&ifi=3&uci=a!3&btvi=2&fsb=1&xpc=4Qr9I1IICq&p=https%3A//www.xmodulo.com&dtd=230
The most common use case of brace expansion is to define a range of numbers for loop iteration. For that, you can use the following expressions, where you specify the start/end of the range, as well as an optional increment value.
{<start-number>..<end-number>} {<start-number>..<end-number>..<increment>}To define a sequence of integers between 10 and 20:
echo {10..20} 10 11 12 13 14 15 16 17 18 19 20You can easily integrate this brace expansion in a loop:
for num in {10..20}; do echo $num doneTo generate a sequence of numbers with an increment of 2 between 0 and 20:
echo {0..20..2} 0 2 4 6 8 10 12 14 16 18 20You can generate a sequence of decrementing numbers as well:
echo {20..10} 20 19 18 17 16 15 14 13 12 11 10echo {20..10..-2} 20 18 16 14 12 10You can also pad the numbers with leading zeros, in case you need to use the same number of digits. For example:
echo {00..20..2} 00 02 04 06 08 10 12 14 16 18 20Use Case #3: Generate a Sequence of Charactershttps://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=1246960885&adk=2798017750&adf=2275625677&pi=t.ma~as.1246960885&w=1200&fwrn=4&lmt=1617109287&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Frange-sequence-expression-bash.html&flash=0&wgl=1&adsid=ChEI8N6VgwYQhfmhjs6mgZfVARIqAB-w9KHKYtk-pO1suXBsxL8W2AonVwnPmH2XuFwrRPO8MEEAXQpMrZaL&dt=1617311560089&bpp=13&bdt=524&idt=234&shv=r20210331&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280%2C1200x200%2C1200x200%2C0x0%2C1519x762&nras=2&correlator=486211930057&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617311560&ga_hid=1542200251&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=4285&biw=1519&bih=762&scr_x=0&scr_y=1242&eid=42530672%2C44740079%2C44739537%2C44739387&oid=3&psts=AGkb-H_lFqstnD2HWv6DycAKvGu9yoyyH3Im0lIwlWU9l6Uc-8KMKIFblasNhvUgGzV4BHfOo--XblJj_VswXA%2CAGkb-H9o5YtqjrXVMh6mfBSJzTIgoTV2500RL7u85T0dFqY9L2FCM8n5K3kCkE5gmmIGpZe6AF47pvNGmYctKA%2CAGkb-H-ww6bPiVlNqpc1PRrGrEXcujNuzAiKCh9dMztOCLvaTDy5GzZj2TpeUNENhbxuLuuOYYD5RgOfQA&pvsid=2774697899597512&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C762&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&jar=2021-04-01-17&ifi=4&uci=a!4&btvi=3&fsb=1&xpc=QImaZvyQly&p=https%3A//www.xmodulo.com&dtd=27097
Brace expansion can be used to generate not just a sequence of numbers, but also a sequence of characters.
{<start-character>..<end-character>}To generate a sequence of alphabet characters between 'd' and 'p':
echo {d..p} d e f g h i j k l m n o pYou can generate a sequence of upper-case alphabets as well.
for char1 in {A..B}; do for char2 in {A..B}; do echo "${char1}${char2}" done doneAA AB BA BBUse Case #4: Generate a Sequence of Strings with Prefix/SuffixIt's possible to add a prefix and/or a suffix to a given brace expression as follows.
<prefix-string>{......} {......}<suffix-string> <prefix-string>{......}<suffix-string>Using this feature, you can easily generate a list of sequentially numbered filenames:
# create incrementing filenames for filename in img_{00..5}.jpg; do echo $filename doneimg_00.jpg img_01.jpg img_02.jpg img_03.jpg img_04.jpg img_05.jpgUse Case #5: Combine Multiple Brace Expansionshttps://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=1246960885&adk=2798017750&adf=1069835252&pi=t.ma~as.1246960885&w=1200&fwrn=4&lmt=1617109287&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Frange-sequence-expression-bash.html&flash=0&wgl=1&adsid=ChEI8N6VgwYQhfmhjs6mgZfVARIqAB-w9KHKYtk-pO1suXBsxL8W2AonVwnPmH2XuFwrRPO8MEEAXQpMrZaL&dt=1617311560132&bpp=3&bdt=568&idt=193&shv=r20210331&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280%2C1200x200%2C1200x200%2C0x0%2C1519x762%2C1200x200&nras=2&correlator=486211930057&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617311560&ga_hid=1542200251&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=6156&biw=1519&bih=762&scr_x=0&scr_y=3151&eid=42530672%2C44740079%2C44739537%2C44739387&oid=3&psts=AGkb-H_lFqstnD2HWv6DycAKvGu9yoyyH3Im0lIwlWU9l6Uc-8KMKIFblasNhvUgGzV4BHfOo--XblJj_VswXA%2CAGkb-H9o5YtqjrXVMh6mfBSJzTIgoTV2500RL7u85T0dFqY9L2FCM8n5K3kCkE5gmmIGpZe6AF47pvNGmYctKA%2CAGkb-H-ww6bPiVlNqpc1PRrGrEXcujNuzAiKCh9dMztOCLvaTDy5GzZj2TpeUNENhbxuLuuOYYD5RgOfQA%2CAGkb-H_oWO6sMjx-sSACXECD6aXL8a7NcIP5miVIHjPj27ExAouRoqV1vRbD0UeQxrrlNTPAZbGg7YubopvUSA&pvsid=2774697899597512&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C762&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&jar=2021-04-01-17&ifi=5&uci=a!5&btvi=4&fsb=1&xpc=twNmeHYXl4&p=https%3A//www.xmodulo.com&dtd=41555
Finally, it's possible to combine multiple brace expansions, in which case the combined expressions will generate all possible combinations of sequence data produced by each expression.
For example, we have the following script that prints all possible combinations of two-character alphabet strings using double-loop iteration.
for char1 in {A..Z}; do for char2 in {A..Z}; do echo "${char1}${char2}" done doneBy combining two brace expansions, the following single loop can produce the same output as above.
for str in {A..Z}{A..Z}; do echo $str doneConclusionIn this tutorial, I described a bash's built-in mechanism called brace expansion, which allows you to easily generate a sequence of arbitrary strings in a single command line. Brace expansion is useful not just for a bash script, but also in your command line environment (e.g., when you need to run the same command multiple times with different arguments). If you know any useful brace expansion tips and use cases, feel free to share it in the comment.
If you find this tutorial helpful, I recommend you check out the series ofbash
shell scripting tutorials provided by Xmodulo.
Mar 30, 2021 | www.xmodulo.com
How to catch and handle errors in bash
Last updated on March 28, 2021 by Dan Nanni
https://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=280&slotname=6357311593&adk=3477157422&adf=3251077269&pi=t.ma~as.6357311593&w=1200&fwrn=4&fwrnh=100&lmt=1617039750&rafmt=1&psa=1&format=1200x280&url=https%3A%2F%2Fwww.xmodulo.com%2Fcatch-handle-errors-bash.html&flash=0&fwr=0&fwrattr=true&rpe=1&resp_fmts=3&wgl=1&dt=1617150500578&bpp=19&bdt=670&idt=289&shv=r20210322&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&correlator=2807789420329&frm=20&pv=2&ga_vid=288434327.1614570002&ga_sid=1617150501&ga_hid=294975347&ga_fc=0&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=31&ady=254&biw=1519&bih=714&scr_x=0&scr_y=0&eid=42530672%2C44740079%2C44739387&oid=3&pvsid=3816417963868055&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C714&vis=1&rsz=%7C%7CeE%7C&abl=CS&pfx=0&fu=8320&bc=31&ifi=1&uci=a!1&fsb=1&xpc=FeLkc0yKaB&p=https%3A//www.xmodulo.com&dtd=346
In an ideal world, things always work as expected, but you know that's hardly the case. The same goes in the world of bash scripting. Writing a robust, bug-free bash script is always challenging even for a seasoned system administrator. Even if you write a perfect bash script, the script may still go awry due to external factors such as invalid input or network problems. While you cannot prevent all errors in your bash script, at least you should try to handle possible error conditions in a more predictable and controlled fashion.
That is easier said than done, especially since error handling in bash is notoriously difficult. The bash shell does not have any fancy exception swallowing mechanism like try/catch constructs. Some bash errors may be silently ignored but may have consequences down the line. The bash shell does not even have a proper debugger.
In this tutorial, I'll introduce basic tips to catch and handle errors in bash . Although the presented error handling techniques are not as fancy as those available in other programming languages, hopefully by adopting the practice, you may be able to handle potential bash errors more gracefully.
Bash Error Handling Tip #1: Check the Exit Statushttps://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=5674857721&adk=3047986842&adf=3341013331&pi=t.ma~as.5674857721&w=1200&fwrn=4&lmt=1617039750&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Fcatch-handle-errors-bash.html&flash=0&wgl=1&dt=1617150500597&bpp=37&bdt=688&idt=355&shv=r20210322&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280&correlator=2807789420329&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617150501&ga_hid=294975347&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=1003&biw=1519&bih=714&scr_x=0&scr_y=0&eid=42530672%2C44740079%2C44739387&oid=3&pvsid=3816417963868055&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C714&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&ifi=2&uci=a!2&btvi=1&fsb=1&xpc=R4Jgtckaf2&p=https%3A//www.xmodulo.com&dtd=373
As the first line of defense, it is always recommended to check the exit status of a command, as a non-zero exit status typically indicates some type of error. For example:
if ! some_command; then echo "some_command returned an error" fiAnother (more compact) way to trigger error handling based on an exit status is to use an OR list:
<command1> || <command2>With this OR statement, <command2> is executed if and only if <command1> returns a non-zero exit status. So you can replace <command2> with your own error handling routine. For example:
error_exit() { echo "Error: $1" exit 1 } run-some-bad-command || error_exit "Some error occurred"Bash provides a built-in variable called
$?
, which tells you the exit status of the last executed command. Note that when a bash function is called,$?
reads the exit status of the last command called inside the function. Since some non-zero exit codes have special meanings , you can handle them selectively. For example:# run some command status=$? if [ $status -eq 1 ]; then echo "General error" elif [ $status -eq 2 ]; then echo "Misuse of shell builtins" elif [ $status -eq 126 ]; then echo "Command invoked cannot execute" elif [ $status -eq 128 ]; then echo "Invalid argument" fiBash Error Handling Tip #2: Exit on Errors in Bashhttps://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=1246960885&adk=2798017750&adf=1795540232&pi=t.ma~as.1246960885&w=1200&fwrn=4&lmt=1617039750&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Fcatch-handle-errors-bash.html&flash=0&wgl=1&dt=1617150500635&bpp=53&bdt=726&idt=346&shv=r20210322&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280%2C1200x200&correlator=2807789420329&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617150501&ga_hid=294975347&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=2621&biw=1519&bih=714&scr_x=0&scr_y=0&eid=42530672%2C44740079%2C44739387&oid=3&pvsid=3816417963868055&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C714&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&ifi=3&uci=a!3&btvi=2&fsb=1&xpc=xlM0hGwtiw&p=https%3A//www.xmodulo.com&dtd=367
When you encounter an error in a bash script, by default, it throws an error message to
stderr
, but continues its execution in the rest of the script. In fact you see the same behavior in a terminal window; even if you type a wrong command by accident, it will not kill your terminal. You will just see the "command not found" error, but you terminal/bash session will still remain.This default shell behavior may not be desirable for some bash script. For example, if your script contains a critical code block where no error is allowed, you want your script to exit immediately upon encountering any error inside that code block. To activate this "exit-on-error" behavior in bash, you can use the
set
command as follows.set -e # # some critical code block where no error is allowed # set +eOnce called with
-e
option, theset
command causes the bash shell to exit immediately if any subsequent command exits with a non-zero status (caused by an error condition). The+e
option turns the shell back to the default mode.set -e
is equivalent toset -o errexit
. Likewise,set +e
is a shorthand command forset +o errexit
.However, one special error condition not captured by
set -e
is when an error occurs somewhere inside a pipeline of commands. This is because a pipeline returns a non-zero status only if the last command in the pipeline fails. Any error produced by previous command(s) in the pipeline is not visible outside the pipeline, and so does not kill a bash script. For example:set -e true | false | true echo "This will be printed" # "false" inside the pipeline not detectedIf you want any failure in pipelines to also exit a bash script, you need to add
-o pipefail
option. For example:set -o pipefail -e true | false | true # "false" inside the pipeline detected correctly echo "This will not be printed"Therefore, to protect a critical code block against any type of command errors or pipeline errors, use the following pair of
set
commands.set -o pipefail -e # # some critical code block where no error or pipeline error is allowed # set +o pipefail +eBash Error Handling Tip #3: Try and Catch Statements in Bashhttps://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=1246960885&adk=2798017750&adf=2275625677&pi=t.ma~as.1246960885&w=1200&fwrn=4&lmt=1617039750&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Fcatch-handle-errors-bash.html&flash=0&wgl=1&adsid=ChAI8JiLgwYQkvKD_-vdud51EioAsc7QJfPbVjxhaA0k3D4cZGdWuanTHT1OnZFf-sYZ_FlsHeNm-m93y6g&dt=1617150500736&bpp=3&bdt=827&idt=284&shv=r20210322&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280%2C1200x200%2C1200x200%2C0x0%2C1519x714&nras=2&correlator=2807789420329&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617150501&ga_hid=294975347&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=4322&biw=1519&bih=714&scr_x=0&scr_y=1473&eid=42530672%2C44740079%2C44739387&oid=3&psts=AGkb-H9kB9XBPoFQr4Nvbpzi-IDFo1H7_NaIL8M18sGGWSqpMo6EvnCzj-Qorx0rQkLTtpYfrxcistXQ3NLI%2CAGkb-H9NblhEl8n-XjoXLiznZ70w5Gvz_2AR1xlm3w9htg9Uoc9EqNnh-BnrA3HlHfn539NkqfOg0pb4UgvAzA%2CAGkb-H_8XpQQ502aEe7wRqWV9odZAPWfUTDNYIPLyzG6DAnUhxH_sAn3FM_H-EjHMVFKcfuXC1svgR-pJ4tNKQ&pvsid=3816417963868055&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C714&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&jar=2021-03-30-23&ifi=4&uci=a!4&btvi=3&fsb=1&xpc=v8JM1LJbyF&p=https%3A//www.xmodulo.com&dtd=7982
Although the
set
command allows you to terminate a bash script upon any error that you deem critical, this mechanism is often not sufficient in more complex bash scripts where different types of errors could happen.To be able to detect and handle different types of errors/exceptions more flexibly, you will need try/catch statements, which however are missing in bash. At least we can mimic the behaviors of try/catch as shown in this
trycatch.sh
script:function try() { [[ $- = *e* ]]; SAVED_OPT_E=$? set +e } function throw() { exit $1 } function catch() { export exception_code=$? (( $SAVED_OPT_E )) && set +e return $exception_code }Here we define several custom bash functions to mimic the semantic of try and catch statements. The
throw()
function is supposed to raise a custom (non-zero) exception. We needset +e
, so that the non-zero returned bythrow()
will not terminate a bash script. Insidecatch()
, we store the value of exception raised bythrow()
in a bash variableexception_code
, so that we can handle the exception in a user-defined fashion.Perhaps an example bash script will make it clear how
trycatch.sh
works. See the example below that utilizestrycatch.sh
.# Include trybatch.sh as a library source ./trycatch.sh # Define custom exception types export ERR_BAD=100 export ERR_WORSE=101 export ERR_CRITICAL=102 try ( echo "Start of the try block" # When a command returns a non-zero, a custom exception is raised. run-command || throw $ERR_BAD run-command2 || throw $ERR_WORSE run-command3 || throw $ERR_CRITICAL # This statement is not reached if there is any exception raised # inside the try block. echo "End of the try block" ) catch || { case $exception_code in $ERR_BAD) echo "This error is bad" ;; $ERR_WORSE) echo "This error is worse" ;; $ERR_CRITICAL) echo "This error is critical" ;; *) echo "Unknown error: $exit_code" throw $exit_code # re-throw an unhandled exception ;; esac }In this example script, we define three types of custom exceptions. We can choose to raise any of these exceptions depending on a given error condition. The OR list
<command> || throw <exception>
allows us to invokethrow()
function with a chosen <exception> value as a parameter, if <command> returns a non-zero exit status. If <command> is completed successfully,throw()
function will be ignored. Once an exception is raised, the raised exception can be handled accordingly inside the subsequent catch block. As you can see, this provides a more flexible way of handling different types of error conditions.https://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-7245163904660683&output=html&h=200&slotname=1246960885&adk=2798017750&adf=1069835252&pi=t.ma~as.1246960885&w=1200&fwrn=4&lmt=1617039750&rafmt=11&psa=1&format=1200x200&url=https%3A%2F%2Fwww.xmodulo.com%2Fcatch-handle-errors-bash.html&flash=0&wgl=1&adsid=ChAI8JiLgwYQkvKD_-vdud51EioAsc7QJfPbVjxhaA0k3D4cZGdWuanTHT1OnZFf-sYZ_FlsHeNm-m93y6g&dt=1617150500740&bpp=33&bdt=832&idt=288&shv=r20210322&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Dc3dfa6581a6e36dd-22096420bac60000%3AT%3D1614570003%3ART%3D1614570003%3AS%3DALNI_MZbq_6NmD0W6EwR1pZiXu91X_Gmaw&prev_fmts=1200x280%2C1200x200%2C1200x200%2C0x0%2C1519x714%2C1200x200&nras=2&correlator=2807789420329&frm=20&pv=1&ga_vid=288434327.1614570002&ga_sid=1617150501&ga_hid=294975347&ga_fc=0&rplot=4&u_tz=-240&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=160&ady=6943&biw=1519&bih=714&scr_x=0&scr_y=4095&eid=42530672%2C44740079%2C44739387&oid=3&psts=AGkb-H9kB9XBPoFQr4Nvbpzi-IDFo1H7_NaIL8M18sGGWSqpMo6EvnCzj-Qorx0rQkLTtpYfrxcistXQ3NLI%2CAGkb-H9NblhEl8n-XjoXLiznZ70w5Gvz_2AR1xlm3w9htg9Uoc9EqNnh-BnrA3HlHfn539NkqfOg0pb4UgvAzA%2CAGkb-H_8XpQQ502aEe7wRqWV9odZAPWfUTDNYIPLyzG6DAnUhxH_sAn3FM_H-EjHMVFKcfuXC1svgR-pJ4tNKQ%2CAGkb-H_LZaKgZXHhi-mp793u920dtCBuBuOdBYfg8GxP5Yl69G1LrubEm-DNODFvz9VDpFX0r4wQgNJ9B_IZKQ&pvsid=3816417963868055&pem=502&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C714&vis=1&rsz=%7C%7CeEbr%7C&abl=CS&pfx=0&fu=8320&bc=31&jar=2021-03-30-23&ifi=5&uci=a!5&btvi=4&fsb=1&xpc=cNiz7hdTMs&p=https%3A//www.xmodulo.com&dtd=13575
Granted, this is not a full-blown try/catch constructs. One limitation of this approach is that the
Conclusiontry
block is executed in a sub-shell . As you may know, any variables defined in a sub-shell are not visible to its parent shell. Also, you cannot modify the variables that are defined in the parent shell inside thetry
block, as the parent shell and the sub-shell have separate scopes for variables.In this bash tutorial, I presented basic error handling tips that may come in handy when you want to write a more robust bash script. As expected these tips are not as sophisticated as the error handling constructs available in other programming language. If the bash script you are writing requires more advanced error handling than this, perhaps bash is not the right language for your task. You probably want to turn to other languages such as Python.
Let me conclude the tutorial by mentioning one essential tool that every shell script writer should be familiar with. ShellCheck is a static analysis tool for shell scripts. It can detect and point out syntax errors, bad coding practice and possible semantic issues in a shell script with much clarity. Definitely check it out if you haven't tried it.
If you find this tutorial helpful, I recommend you check out the series ofbash
shell scripting tutorials provided by Xmodulo.
Mar 24, 2021 | www.redhat.com
The idea was that sharing this would inspire others to improve their bashrc savviness. Take a look at what our Sudoers group shared and, please, borrow anything you like to make your sysadmin life easier.
[ You might also like: Parsing Bash history in Linux ]
Jonathan Roemer# Require confirmation before overwriting target files. This setting keeps me from deleting things I didn't expect to, etc alias cp='cp -i' alias mv='mv -i' alias rm='rm -i' # Add color, formatting, etc to ls without re-typing a bunch of options every time alias ll='ls -alhF' alias ls="ls --color" # So I don't need to remember the options to tar every time alias untar='tar xzvf' alias tarup='tar czvf' # Changing the default editor, I'm sure a bunch of people have this so they don't get dropped into vi instead of vim, etc. A lot of distributions have system default overrides for these, but I don't like relying on that being around alias vim='nvim' alias vi='nvim'Valentin BajramiHere are a few functions from my
~/.bashrc
file:# Easy copy the content of a file without using cat / selecting it etc. It requires xclip to be installed # Example: _cp /etc/dnsmasq.conf _cp() { local file="$1" local st=1 if [[ -f $file ]]; then cat "$file" | xclip -selection clipboard st=$? else printf '%s\n' "Make sure you are copying the content of a file" >&2 fi return $st } # This is the function to paste the content. The content is now in your buffer. # Example: _paste _paste() { xclip -selection cliboard -o } # Generate a random password without installing any external tooling genpw() { alphanum=( {a..z} {A..Z} {0..9} ); for((i=0;i<=${#alphanum[@]};i++)); do printf '%s' "${alphanum[@]:$((RANDOM%255)):1}"; done; echo } # See what command you are using the most (this parses the history command) cm() { history | awk ' { a[$4]++ } END { for ( i in a ) print a[i], i | "sort -rn | head -n10"}' | awk '$1 > max{ max=$1} { bar=""; i=s=10*$1/max;while(i-->0)bar=bar"#"; printf "%25s %15d %s %s", $2, $1,bar, "\n"; }' }Peter GervaseFor shutting down at night, I kill all SSH sessions and then kill any VPN connections:
#!/bin/bash /usr/bin/killall ssh /usr/bin/nmcli connection down "Raleigh (RDU2)" /usr/bin/nmcli connection down "Phoenix (PHX2)"Valentin Rothbergalias vim='nvim' alias l='ls -CF --color=always'' alias cd='cd -P' # follow symlinks alias gits='git status' alias gitu='git remote update' alias gitum='git reset --hard upstream/master'Steve Ovensalias nano='nano -wET 4' alias ls='ls --color=auto' PS1="\[\e[01;32m\]\u@\h \[\e[01;34m\]\w \[\e[01;34m\]$\[\e[00m\] " export EDITOR=nano export AURDEST=/var/cache/pacman/pkg PATH=$PATH:/home/stratus/.gem/ruby/2.7.0/bin alias mp3youtube='youtube-dl -x --audio-format mp3' alias grep='grep --color' alias best-youtube='youtube-dl -r 1M --yes-playlist -f 'bestvideo[ext=mp4]+bestaudio[ext=m4a]'' alias mv='mv -vv' shopt -s histappend HISTCONTROL=ignorebothJason HibbetsWhile my bashrc aliases aren't as sophisticated as the previous technologists, you can probably tell I really like shortcuts:
# User specific aliases and functions alias q='exit' alias h='cd ~/' alias c='clear' alias m='man' alias lsa='ls -al' alias s='sudo su -'More Linux resourcesBonus: Organizing bashrc files and cleaning up files
- Advanced Linux Commands Cheat Sheet for Developers
- Get Started with Red Hat Insights
- Download Now: Basic Linux Commands Cheat Sheet
- Linux System Administration Skills Assessment
We know many sysadmins like to script things to make their work more automated. Here are a few tips from our Sudoers that you might find useful.
Chris CollinsI don't know who I need to thank for this, some awesome woman on Twitter whose name I no longer remember, but it's changed the organization of my bash aliases and commands completely.
I have Ansible drop individual <something>.bashrc files into
~/.bashrc.d/
with any alias or command or shortcut I want, related to any particular technology or Ansible role, and can manage them all separately per host. It's been the best single trick I've learned for .bashrc files ever.Git stuff gets a
~/.bashrc.d/git.bashrc
, Kubernetes goes in~/.bashrc.d/kube.bashrc
.if [ -d ${HOME}/.bashrc.d ] then for file in ~/.bashrc.d/*.bashrc do source "${file}" done fiPeter GervaseThese aren't bashrc aliases, but I use them all the time. I wrote a little script named
clean
for getting rid of excess lines in files. For example, here'snsswitch.conf
with lots of comments and blank lines:[pgervase@pgervase etc]$ head authselect/nsswitch.conf # Generated by authselect on Sun Dec 6 22:12:26 2020 # Do not modify this file manually. # If you want to make changes to nsswitch.conf please modify # /etc/authselect/user-nsswitch.conf and run 'authselect apply-changes'. # # Note that your changes may not be applied as they may be # overwritten by selected profile. Maps set in the authselect # profile always take precedence and overwrites the same maps # set in the user file. Only maps that are not set by the profile [pgervase@pgervase etc]$ wc -l authselect/nsswitch.conf 80 authselect/nsswitch.conf [pgervase@pgervase etc]$ clean authselect/nsswitch.conf passwd: sss files systemd group: sss files systemd netgroup: sss files automount: sss files services: sss files shadow: files sss hosts: files dns myhostname bootparams: files ethers: files netmasks: files networks: files protocols: files rpc: files publickey: files aliases: files [pgervase@pgervase etc]$ cat `which clean` #! /bin/bash # /bin/cat $1 | /bin/sed 's/^[ \t]*//' | /bin/grep -v -e "^#" -e "^;" -e "^[[:space:]]*$" -e "^[ \t]+"[ Free online course: Red Hat Enterprise Linux technical overview . ]
Mar 24, 2021 | www.redhat.com
The following is the script I use to test the servers:
1 #!/bin/bash 2 3 input_file=hosts.csv 4 output_file=hosts_tested.csv 5 6 echo "ServerName,IP,PING,DNS,SSH" > "$output_file" 7 8 tail -n +2 "$input_file" | while IFS=, read -r host ip _ 9 do 10 if ping -c 3 "$ip" > /dev/null; then 11 ping_status="OK" 12 else 13 ping_status="FAIL" 14 fi 15 16 if nslookup "$host" > /dev/null; then 17 dns_status="OK" 18 else 19 dns_status="FAIL" 20 fi 21 22 if nc -z -w3 "$ip" 22 > /dev/null; then 23 ssh_status="OK" 24 else 25 ssh_status="FAIL" 26 fi 27 28 echo "Host = $host IP = $ip" PING_STATUS = $ping_status DNS_STATUS = $dns_status SSH_STATUS = $ssh_status 29 echo "$host,$ip,$ping_status,$dns_status,$ssh_status" >> $output_file 30 done
Mar 14, 2021 | www.redhat.com
while true do df -k | grep home sleep 1 doneIn this case, you're running the loop with a true condition, which means it will run forever or until you hit CTRL-C. Therefore, you need to keep an eye on it (otherwise, it will remain using the system's resources).
Note : If you use a loop like this, you need to include a command like
2. Waiting for a condition to become truesleep
to give the system some time to breathe between executions. Running anything non-stop could become a performance issue, especially if the commands inside the loop involve I/O operations.There are variations of this scenario. For example, you know that at some point, the process will create a directory, and you are just waiting for that moment to perform other validations.
You can have a
while
loop to keep checking for that directory's existence and only write a message while the directory does not exist.https://asciinema.org/a/BQN8CDagw6k8bSbGJPYi5kqpg/embed?
If you want to do something more elaborate, you could create a script and show a more clear indication that the loop condition became true:
#!/bin/bash while [ ! -d directory_expected ] do echo "`date` - Still waiting" sleep 1 done echo "DIRECTORY IS THERE!!!"More about automation3. Using a while loop to manipulate a file
- An introduction to Ansible
- 3 ways to try Ansible Tower free
- Free Ansible e-books
- Getting started with network automation
Another useful application of a
while
loop is to combine it with theread
command to have access to columns (or fields) quickly from a text file and perform some actions on them.In the following example, you are simply picking the columns from a text file with a predictable format and printing the values that you want to use to populate an
/etc/hosts
file.https://asciinema.org/a/2b1u28XqoC7j7Muhd5zXqHkYP/embed?
Here the assumption is that the file has columns delimited by spaces or tabs and that there are no spaces in the content of the columns. That could shift the content of the fields and not give you what you needed.
Notice that you're just doing a simple operation to extract and manipulate information and not concerned about the command's reusability. I would classify this as one of those "quick and dirty tricks."
Of course, if this was something that you would repeatedly do, you should run it from a script, use proper names for the variables, and all those good practices (including transforming the filename in an argument and defining where to send the output, but today, the topic is
while
loops).#!/bin/bash cat servers.txt | grep -v CPU | while read servername cpu ram ip do echo $ip $servername done
Jan 02, 2021 | www.redhat.com
In the Bash shell, file descriptors (FDs) are important in managing the input and output of commands. Many people have issues understanding file descriptors correctly. Each process has three default file descriptors, namely:
Code Meaning Location Description 0 Standard input /dev/stdin Keyboard, file, or some stream 1 Standard output /dev/stdout Monitor, terminal, display 2 Standard error /dev/stderr Non-zero exit codes are usually >FD2, display Now that you know what the default FDs do, let's see them in action. I start by creating a directory named
foo
, which containsfile1
.$> ls foo/ bar/ ls: cannot access 'bar/': No such file or directory foo/: file1The output No such file or directory goes to Standard Error (stderr) and is also displayed on the screen. I will run the same command, but this time use
2>
to omit stderr:$> ls foo/ bar/ 2>/dev/null foo/: file1It is possible to send the output of
foo
to Standard Output (stdout) and to a file simultaneously, and ignore stderr. For example:$> { ls foo bar | tee -a ls_out_file ;} 2>/dev/null foo: file1Then:
$> cat ls_out_file foo: file1The following command sends stdout to a file and stderr to
/dev/null
so that the error won't display on the screen:$> ls foo/ bar/ >to_stdout 2>/dev/null $> cat to_stdout foo/: file1The following command sends stdout and stderr to the same file:
$> ls foo/ bar/ >mixed_output 2>&1 $> cat mixed_output ls: cannot access 'bar/': No such file or directory foo/: file1This is what happened in the last example, where stdout and stderr were redirected to the same file:
ls foo/ bar/ >mixed_output 2>&1 | | | Redirect stderr to where stdout is sent | stdout is sent to mixed_outputAnother short trick (> Bash 4.4) to send both stdout and stderr to the same file uses the ampersand sign. For example:
$> ls foo/ bar/ &>mixed_outputHere is a more complex redirection:
exec 3>&1 >write_to_file; echo "Hello World"; exec 1>&3 3>&-This is what occurs:
- exec 3>&1 Copy stdout to file descriptor 3
- > write_to_file Make FD 1 to write to the file
- echo "Hello World" Go to file because FD 1 now points to the file
- exec 1>&3 Copy FD 3 back to 1 (swap)
- Three>&- Close file descriptor three (we don't need it anymore)
Often it is handy to group commands, and then send the Standard Output to a single file. For example:
$> { ls non_existing_dir; non_existing_command; echo "Hello world"; } 2> to_stderr Hello worldAs you can see, only "Hello world" is printed on the screen, but the output of the failed commands is written to the to_stderr file.
Dec 10, 2020 | linuxconfig.org
Bash allows two different subshell syntaxes, namely
$()
and back-tick surrounded statements. Let's look at some easy examples to start:$ echo '$(echo 'a')' $(echo a) $ echo "$(echo 'a')" a $ echo "a$(echo 'b')c" abc $ echo "a`echo 'b'`c" abc
SUBSCRIBE TO NEWSLETTER
Subscribe to Linux Career NEWSLETTER and receive latest Linux news, jobs, career advice and tutorials.
https://googleads.g.doubleclick.net/pagead/ads?guci=2.2.0.0.2.2.0.0&gdpr=0&us_privacy=1---&client=ca-pub-4906753266448300&output=html&h=189&slotname=5703296903&adk=1248373483&adf=1566064928&pi=t.ma~as.5703296903&w=754&fwrn=4&lmt=1606768699&rafmt=11&psa=1&format=754x189&url=https%3A%2F%2Flinuxconfig.org%2Flinux-subshells-for-beginners-with-examples&flash=0&wgl=1&tt_state=W3siaXNzdWVyT3JpZ2luIjoiaHR0cHM6Ly9hZHNlcnZpY2UuZ29vZ2xlLmNvbSIsInN0YXRlIjowfSx7Imlzc3Vlck9yaWdpbiI6Imh0dHBzOi8vYXR0ZXN0YXRpb24uYW5kcm9pZC5jb20iLCJzdGF0ZSI6MH1d&dt=1606768710648&bpp=17&bdt=1664&idt=-M&shv=r20201112&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Da3d6872c3b570d2f-2256edf9acc400fe%3AT%3D1604637667%3ART%3D1604637667%3AS%3DALNI_MboWqYGLjuR1MmbPrvzRe-G7T4AZw&correlator=5015138629854&frm=20&pv=2&ga_vid=1677892679.1604637667&ga_sid=1606768711&ga_hid=1690704763&ga_fc=0&iag=0&icsg=577243598424319&dssz=50&mdo=0&mso=0&rplot=4&u_tz=-300&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=185&ady=1663&biw=1519&bih=762&scr_x=0&scr_y=0&eid=42530671%2C21068083&oid=3&pvsid=3023641763965231&pem=477&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C762&vis=1&rsz=o%7Co%7CoEebr%7C&abl=NS&pfx=0&fu=8320&bc=31&ifi=1&uci=a!1&btvi=1&fsb=1&xpc=1Bdmecc8YW&p=https%3A//linuxconfig.org&dtd=634
In the first command, as an example, we used
'
single quotes. This resulted in our subshell command, inside the single quotes, to be interpreted as literal text instead of a command. This is standard Bash:'
indicates literal,"
indicates that the string will be parsed for subshells and variables.In the second command we swap the
'
to"
and thus the string is parsed for actual commands and variables. The result is that a subshell is being started, thanks to our subshell syntax ($()
), and the command inside the subshell (echo 'a'
) is being executed literally, and thus ana
is produced, which is then inserted in the overarching / top levelecho
. The command at that stage can be read asecho "a"
and thus the output isa
.In the third command, we further expand this to make it clearer how subshells work in-context. We echo the letter
b
inside the subshell, and this is joined on the left and the right by the lettersa
andc
yielding the overall output to beabc
in a similar fashion to the second command.In the fourth and last command, we exemplify the alternative Bash subshell syntax of using back-ticks instead of
Example 2: A little more complex$()
. It is important to know that$()
is the preferred syntax, and that in some remote cases the back-tick based syntax may yield some parsing errors where the$()
does not. I would thus strongly encourage you to always use the$()
syntax for subshells, and this is also what we will be using in the following examples.$ touch a $ echo "-$(ls [a-z])" -a $ echo "-=-||$(ls [a-z] | xargs ls -l)||-=-" -=-||-rw-rw-r-- 1 roel roel 0 Sep 5 09:26 a||-=-Here, we first create an empty file by using the
touch a
command. Subsequently, we useecho
to output something which our subshell$(ls [a-z])
will generate. Sure, we can execute thels
directly and yield more or less the same result, but note how we are adding-
to the output as a prefix.In the final command, we insert some characters at the front and end of the
Example 3: Double quotes inside subshells and sub-subshells!echo
command which makes the output look a bit nicer. We use a subshell to first find thea
file we created earlier (ls [a-z]
) and then - still inside the subshell - pass the results of this command (which would be onlya
literally - i.e. the file we created in the first command) to thels -l
using the pipe (|
) and thexargs
command. For more information on xargs, please see our articles xargs for beginners with examples and multi threaded xargs with examples .echo "$(echo "$(echo "it works")" | sed 's|it|it surely|')" it surely works
https://googleads.g.doubleclick.net/pagead/ads?guci=2.2.0.0.2.2.0.0&gdpr=0&us_privacy=1---&client=ca-pub-4906753266448300&output=html&h=189&slotname=5703296903&adk=1248373483&adf=2724449972&pi=t.ma~as.5703296903&w=754&fwrn=4&lmt=1606768699&rafmt=11&psa=1&format=754x189&url=https%3A%2F%2Flinuxconfig.org%2Flinux-subshells-for-beginners-with-examples&flash=0&wgl=1&adsid=ChEIgM2S_gUQzN_42M_QwuOnARIqAL1WgU0IPKMTPLYMrAFnUAY1w18hzIzNy0CGR82uXn3xCpt9jLaEISQY&tt_state=W3siaXNzdWVyT3JpZ2luIjoiaHR0cHM6Ly9hZHNlcnZpY2UuZ29vZ2xlLmNvbSIsInN0YXRlIjowfSx7Imlzc3Vlck9yaWdpbiI6Imh0dHBzOi8vYXR0ZXN0YXRpb24uYW5kcm9pZC5jb20iLCJzdGF0ZSI6MH1d&dt=1606768710249&bpp=9&bdt=1264&idt=211&shv=r20201112&cbv=r20190131&ptt=9&saldr=aa&abxe=1&cookie=ID%3Da3d6872c3b570d2f-2256edf9acc400fe%3AT%3D1604637667%3ART%3D1604637667%3AS%3DALNI_MboWqYGLjuR1MmbPrvzRe-G7T4AZw&prev_fmts=754x189%2C0x0&nras=1&correlator=5015138629854&frm=20&pv=1&ga_vid=1677892679.1604637667&ga_sid=1606768711&ga_hid=1690704763&ga_fc=0&iag=0&icsg=2308974393696511&dssz=50&mdo=0&mso=0&rplot=4&u_tz=-300&u_his=1&u_java=0&u_h=864&u_w=1536&u_ah=864&u_aw=1536&u_cd=24&u_nplug=3&u_nmime=4&adx=185&ady=3548&biw=1519&bih=762&scr_x=0&scr_y=513&eid=42530671%2C21068083&oid=3&psts=AGkb-H_kCAb-qHdw3GuwXq6RB3MJbClRq9VISu7n8l1rpQZCm8sfL6sdfh-BMTltKIaB0w&pvsid=3023641763965231&pem=477&ref=https%3A%2F%2Fwww.linuxtoday.com%2F&rx=0&eae=0&fc=896&brdim=1536%2C0%2C1536%2C0%2C1536%2C0%2C1536%2C864%2C1536%2C762&vis=1&rsz=o%7Co%7CoEebr%7C&abl=NS&pfx=0&fu=8320&bc=31&jar=2020-11-30-05&ifi=2&uci=a!2&btvi=2&fsb=1&xpc=0ozDx6KTCC&p=https%3A//linuxconfig.org&dtd=4517
Cool, no? Here we see that double quotes can be used inside the subshell without generating any parsing errors. We also see how a subshell can be nested inside another subshell. Are you able to parse the syntax? The easiest way is to start "in the middle or core of all subshells" which is in this case would be the simple
echo "it works"
.This command will output
it works
as a result of the subshell call$(echo "it works")
. Pictureit works
in place of the subshell, i.e.echo "$(echo "it works" | sed 's|it|it surely|')" it surely worksThis looks simpler already. Next it is helpful to know that the
sed
command will do a substitute (thanks to thes
command just before the|
command separator) of the textit
toit surely
. You can read thesed
command asreplace __it__ with __it surely__. The output of the subshell will thus be
it surely works`, i.e.echo "it surely works" it surely worksConclusionIn this article, we have seen that subshells surely work (pun intended), and that they can be used in wide variety of circumstances, due to their ability to be inserted inline and within the context of the overarching command. Subshells are very powerful and once you start using them, well, there will likely be no stopping. Very soon you will be writing something like:
$ VAR="goodbye"; echo "thank $(echo "${VAR}" | sed 's|^| and |')" | sed 's|k |k you|'This one is for you to try and play around with! Thank you and goodbye
Jul 07, 2020 | www.redhat.com
Assume I have a file with a lot of IP addresses and want to operate on those IP addresses. For example, I want to run
dig
to retrieve reverse-DNS information for the IP addresses listed in the file. I also want to skip IP addresses that start with a comment (# or hashtag).I'll use fileA as an example. Its contents are:
10.10.12.13 some ip in dc1 10.10.12.14 another ip in dc2 #10.10.12.15 not used IP 10.10.12.16 another IPI could copy and paste each IP address, and then run
dig
manually:$> dig +short -x 10.10.12.13Or I could do this:
$> while read -r ip _; do [[ $ip == \#* ]] && continue; dig +short -x "$ip"; done < ipfileWhat if I want to swap the columns in fileA? For example, I want to put IP addresses in the right-most column so that fileA looks like this:
some ip in dc1 10.10.12.13 another ip in dc2 10.10.12.14 not used IP #10.10.12.15 another IP 10.10.12.16I run:
$> while read -r ip rest; do printf '%s %s\n' "$rest" "$ip"; done < fileA
Apr 19, 2020 | www.cyberciti.biz
PayPal / Bitcoin , or become a supporter using Patreon . Advertisements
Sep 05, 2020 | unix.stackexchange.com
What exit code should I use?
- 1 - Catchall for general errors. The exit code is
1
as the operation was not successful.- 2 - Misuse of shell builtins (according to Bash documentation)
- 126 - Command invoked cannot execute.
- 127 - "command not found".
- 128 - Invalid argument to exit.
- 128+n - Fatal error signal "n".
- 130 - Script terminated by Control-C.
- 255\* - Exit status out of range.
There is no "recipe" to get the meanings of an exit status of a given terminal command.
My first attempt would be the manpage:
user@host:~# man ls Exit status: 0 if OK, 1 if minor problems (e.g., cannot access subdirectory), 2 if serious trouble (e.g., cannot access command-line argument).Second : Google . See wget as an example.
Third : The exit statuses of the shell, for example bash. Bash and it's builtins may use values above 125 specially. 127 for command not found, 126 for command not executable. For more information see the bash exit codes .
Some list of sysexits on both Linux and BSD/OS X with preferable exit codes for programs (64-78) can be found in
/usr/include/sysexits.h
(or:man sysexits
on BSD):0 /* successful termination */ 64 /* base value for error messages */ 64 /* command line usage error */ 65 /* data format error */ 66 /* cannot open input */ 67 /* addressee unknown */ 68 /* host name unknown */ 69 /* service unavailable */ 70 /* internal software error */ 71 /* system error (e.g., can't fork) */ 72 /* critical OS file missing */ 73 /* can't create (user) output file */ 74 /* input/output error */ 75 /* temp failure; user is invited to retry */ 76 /* remote error in protocol */ 77 /* permission denied */ 78 /* configuration error */ /* maximum listed value */The above list allocates previously unused exit codes from 64-78. The range of unallotted exit codes will be further restricted in the future.
However above values are mainly used in sendmail and used by pretty much nobody else, so they aren't anything remotely close to a standard (as pointed by @Gilles ).
In shell the exit status are as follow (based on Bash):
1
-125
- Command did not complete successfully. Check the command's man page for the meaning of the status, few examples below:
1
- Catchall for general errorsMiscellaneous errors, such as "divide by zero" and other impermissible operations.
Example:
$ let "var1 = 1/0"; echo $? -bash: let: var1 = 1/0: division by 0 (error token is "0") 1
2
- Misuse of shell builtins (according to Bash documentation)Missing keyword or command, or permission problem (and diff return code on a failed binary file comparison).
Example:
empty_function() {}
6
- No such device or addressExample:
$ curl foo; echo $? curl: (6) Could not resolve host: foo 6
124
- command times out125
- if a command itself fails see: coreutils
126
- if command is found but cannot be invoked (e.g. is not executable)Permission problem or command is not an executable.
Example:
$ /dev/null $ /etc/hosts; echo $? -bash: /etc/hosts: Permission denied 126
127
- if a command cannot be found, the child process created to execute it returns that statusPossible problem with
$PATH
or a typo.Example:
$ foo; echo $? -bash: foo: command not found 127
128
- Invalid argument toexit
exit takes only integer args in the range 0 - 255.
Example:
$ exit 3.14159 -bash: exit: 3.14159: numeric argument required
128
-254
- fatal error signal "n" - command died due to receiving a signal. The signal code is added to 128 (128 + SIGNAL) to get the status (Linux:man 7 signal
, BSD:man signal
), few examples below:
130
- command terminated due to Ctrl-C being pressed, 130-128=2 (SIGINT)Example:
$ cat ^C $ echo $? 130
137
- if command is sent theKILL(9)
signal (128+9), the exit status of command otherwise
kill -9 $PPID
of script.
141
-SIGPIPE
- write on a pipe with no readerExample:
$ hexdump -n100000 /dev/urandom | tee &>/dev/null >(cat > file1.txt) >(cat > file2.txt) >(cat > file3.txt) >(cat > file4.txt) >(cat > file5.txt) $ find . -name '*.txt' -print0 | xargs -r0 cat | tee &>/dev/null >(head /dev/stdin > head.out) >(tail /dev/stdin > tail.out) xargs: cat: terminated by signal 13 $ echo ${PIPESTATUS[@]} 0 125 141
143
- command terminated by signal code 15 (128+15=143)Example:
$ sleep 5 && killall sleep & [1] 19891 $ sleep 100; echo $? Terminated: 15 143
255
* - exit status out of range.exit takes only integer args in the range 0 - 255.
Example:
$ sh -c 'exit 3.14159'; echo $? sh: line 0: exit: 3.14159: numeric argument required 255According to the above table, exit codes 1 - 2, 126 - 165, and 255 have special meanings, and should therefore be avoided for user-specified exit parameters.
Please note that out of range exit values can result in unexpected exit codes (e.g. exit 3809 gives an exit code of 225, 3809 % 256 = 225).
See:
- Appendix E. Exit Codes With Special Meanings at Advanced Bash-Scripting Guide
- Writing Better Shell Scripts – Part 2 at Innovationsts
You will have to look into the code/documentation. However the thing that comes closest to a "standardization" is errno.h share improve this answer follow answered Jan 22 '14 at 7:35 Thorsten Staerk 2,885 1 1 gold badge 17 17 silver badges 25 25 bronze badges
PSkocik ,
thanks for pointing the header file.. tried looking into the documentation of a few utils.. hard time finding the exit codes, seems most will be the stderrs... – precise Jan 22 '14 at 9:13
Jul 10, 2020 | www.tecmint.com
direnv is a nifty open-source extension for your shell on a UNIX operating system such as Linux and macOS. It is compiled into a single static executable and supports shells such as bash , zsh , tcsh , and fish .
The main purpose of direnv is to allow for project-specific environment variables without cluttering
~/.profile
or related shell startup files. It implements a new way to load and unload environment variables depending on the current directory.It is used to load 12factor apps (a methodology for building software-as-a-service apps) environment variables, create per-project isolated development environments, and also load secrets for deployment. Additionally, it can be used to build multi-version installation and management solutions similar to rbenv , pyenv , and phpenv .
So How Does direnv Works?Before the shell loads a command prompt, direnv checks for the existence of a
.envrc
file in the current (which you can display using the pwd command ) and parent directory. The checking process is swift and can't be noticed on each prompt.Once it finds the
.envrc
file with the appropriate permissions, it loads it into a bash sub-shell and it captures all exported variables and makes them available to the current shell.... ... ...
How to Use direnv in Linux ShellTo demonstrate how direnv works, we will create a new directory called
tecmint_projects
and move into it.$ mkdir ~/tecmint_projects $ cd tecmint_projects/Next, let's create a new variable called
TEST_VARIABLE
on the command line and when it is echoed , the value should be empty:$ echo $TEST_VARIABLENow we will create a new
.envrc
file that contains Bash code that will be loaded by direnv . We also try to add the line " export the TEST_VARIABLE=tecmint " in it using the echo command and the output redirection character(>)
:$ echo export TEST_VARIABLE=tecmint > .envrcBy default, the security mechanism blocks the loading of the
.envrc
file. Since we know it a secure file, we need to approve its content by running the following command:$ direnv allow .Now that the content of
.envrc
file has been allowed to load, let's check the value ofTEST_VARIABLE
that we set before:$ echo $TEST_VARIABLEWhen we exit the
tecmint_project
directory, the direnv will be unloaded and if we check the value ofTEST_VARIABLE
once more, it should be empty:$ cd .. $ echo $TEST_VARIABLEEvery time you move into the tecmint_projects directory, the
.envrc
file will be loaded as shown in the following screenshot:$ cd tecmint_projects/To revoke the authorization of a given
.envrc
, use the deny command.$ direnv deny . #in current directory OR $ direnv deny /path/to/.envrcFor more information and usage instructions, see the direnv man page:
$ man direnvAdditionally, direnv also uses a stdlib ( direnv-stdlib ) comes with several functions that allow you to easily add new directories to your PATH and do so much more.
Dec 21, 2019 | opensource.com
Get the highlights in your inbox every week.
In the first article in this series, you created your first, very small, one-line Bash script and explored the reasons for creating shell scripts. In the second article , you began creating a fairly simple template that can be a starting point for other Bash programs and began testing it. In the third article , you created and used a simple Help function and learned about using functions and how to handle command-line options such as -h .
This fourth and final article in the series gets into variables and initializing them as well as how to do a bit of sanity testing to help ensure the program runs under the proper conditions. Remember, the objective of this series is to build working code that will be used for a template for future Bash programming projects. The idea is to make getting started on new programming projects easy by having common elements already available in the template.
VariablesThe Bash shell, like all programming languages, can deal with variables. A variable is a symbolic name that refers to a specific location in memory that contains a value of some sort. The value of a variable is changeable, i.e., it is variable. If you are not familiar with using variables, read my article How to program with Bash: Syntax and tools before you go further.
Done? Great! Let's now look at some good practices when using variables.
More on BashI always set initial values for every variable used in my scripts. You can find this in your template script immediately after the procedures as the first part of the main program body, before it processes the options. Initializing each variable with an appropriate value can prevent errors that might occur with uninitialized variables in comparison or math operations. Placing this list of variables in one place allows you to see all of the variables that are supposed to be in the script and their initial values.
- Bash cheat sheet
- An introduction to programming with Bash
- A sysadmin's guide to Bash scripting
- Latest Bash articles
Your little script has only a single variable, $option , so far. Set it by inserting the following lines as shown:
# Main program ## Initialize variables
option = ""# Process the input options. Add options as needed. #
Test this to ensure that everything works as it should and that nothing has broken as the result of this change.
ConstantsConstants are variables, too -- at least they should be. Use variables wherever possible in command-line interface (CLI) programs instead of hard-coded values. Even if you think you will use a particular value (such as a directory name, a file name, or a text string) just once, create a variable and use it where you would have placed the hard-coded name.
For example, the message printed as part of the main body of the program is a string literal, echo "Hello world!" . Change that to a variable. First, add the following statement to the variable initialization section:
Msg="Hello world!"And now change the last line of the program from:
echo "Hello world!"to:
echo "$Msg"Test the results.
Sanity checksSanity checks are simply tests for conditions that need to be true in order for the program to work correctly, such as: the program must be run as the root user, or it must run on a particular distribution and release of that distro. Add a check for root as the running user in your simple program template.
Testing that the root user is running the program is easy because a program runs as the user that launches it.
The id command can be used to determine the numeric user ID (UID) the program is running under. It provides several bits of information when it is used without any options:
[ student @ testvm1 ~ ] $ id
uid = 1001 ( student ) gid = 1001 ( student ) groups = 1001 ( student ) , 5000 ( dev )Using the -u option returns just the user's UID, which is easily usable in your Bash program:
[ student @ testvm1 ~ ] $ id -u
1001
[ student @ testvm1 ~ ] $Add the following function to the program. I added it after the Help procedure, but you can place it anywhere in the procedures section. The logic is that if the UID is not zero, which is always the root user's UID, the program exits:
################################################################################
# Check for root. #
################################################################################
CheckRoot ()
{
if [ ` id -u ` ! = 0 ]
then
echo "ERROR: You must be root user to run this program"
exit
fi
}Now, add a call to the CheckRoot procedure just before the variable's initialization. Test this, first running the program as the student user:
[ student @ testvm1 ~ ] $ . / hello
ERROR: You must be root user to run this program
[ student @ testvm1 ~ ] $then as the root user:
[ root @ testvm1 student ] # ./hello
Hello world !
[ root @ testvm1 student ] #You may not always need this particular sanity test, so comment out the call to CheckRoot but leave all the code in place in the template. This way, all you need to do to use that code in a future program is to uncomment the call.
The codeAfter making the changes outlined above, your code should look like this:
#!/usr/bin/bash
################################################################################
# scriptTemplate #
# #
# Use this template as the beginning of a new program. Place a short #
# description of the script here. #
# #
# Change History #
# 11/11/2019 David Both Original code. This is a template for creating #
# new Bash shell scripts. #
# Add new history entries as needed. #
# #
# #
################################################################################
################################################################################
################################################################################
# #
# Copyright (C) 2007, 2019 David Both #
# [email protected] #
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
# This program is distributed in the hope that it will be useful, #
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
# GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program; if not, write to the Free Software #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
# #
################################################################################
################################################################################
################################################################################################################################################################
# Help #
################################################################################
Help ()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}################################################################################
# Check for root. #
################################################################################
CheckRoot ()
{
# If we are not running as root we exit the program
if [ ` id -u ` ! = 0 ]
then
echo "ERROR: You must be root user to run this program"
exit
fi
}################################################################################
################################################################################
# Main program #
################################################################################
################################################################################################################################################################
# Sanity checks #
################################################################################
# Are we rnning as root?
# CheckRoot# Initialize variables
option = ""
Msg = "Hello world!"
################################################################################
# Process the input options. Add options as needed. #
################################################################################
# Get the options
while getopts ":h" option; do
case $option in
h ) # display Help
Help
exit ;;
\? ) # incorrect option
echo "Error: Invalid option"
exit ;;
esac
doneecho " $Msg " A final exercise
You probably noticed that the Help function in your code refers to features that are not in the code. As a final exercise, figure out how to add those functions to the code template you created.
SummaryIn this article, you created a couple of functions to perform a sanity test for whether your program is running as root. Your program is getting a little more complex, so testing is becoming more important and requires more test paths to be complete.
This series looked at a very minimal Bash program and how to build a script up a bit at a time. The result is a simple template that can be the starting point for other, more useful Bash scripts and that contains useful elements that make it easy to start new scripts.
By now, you get the idea: Compiled programs are necessary and fill a very important need. But for sysadmins, there is always a better way. Always use shell scripts to meet your job's automation needs. Shell scripts are open; their content and purpose are knowable. They can be readily modified to meet different requirements. I have never found anything that I need to do in my sysadmin role that cannot be accomplished with a shell script.
What you have created so far in this series is just the beginning. As you write more Bash programs, you will find more bits of code that you use frequently and should be included in your program template.
Resources
Dec 19, 2019 | opensource.com
In the first article in this series, you created a very small, one-line Bash script and explored the reasons for creating shell scripts and why they are the most efficient option for the system administrator, rather than compiled programs.
In this second article, you will begin creating a Bash script template that can be used as a starting point for other Bash scripts. The template will ultimately contain a Help facility, a licensing statement, a number of simple functions, and some logic to deal with those options and others that might be needed for the scripts that will be based on this template.
Why create a template? More on sysadminsLike automation in general, the idea behind creating a template is to be the " lazy sysadmin ." A template contains the basic components that you want in all of your scripts. It saves time compared to adding those components to every new script and makes it easy to start a new script.
- Enable Sysadmin blog
- The Automated Enterprise: a guide to managing IT with automation
- eBook: Ansible Automation for SysAdmins
- Latest sysadmin articles
Although it can be tempting to just throw a few command-line Bash statements together into a file and make it executable, that can be counterproductive in the long run. A well-written and well-commented Bash program with a Help facility and the capability to accept command-line options provides a good starting point for sysadmins who maintain the program, which includes the programs that you write and maintain.
The requirementsYou should always create a set of requirements for every project you do. This includes scripts, even if it is a simple list with only two or three items on it. I have been involved in many projects that either failed completely or failed to meet the customer's needs, usually due to the lack of a requirements statement or a poorly written one.
The requirements for this Bash template are pretty simple:
The basic structure
- Create a template that can be used as the starting point for future Bash programming projects.
- The template should follow standard Bash programming practices.
- It must include:
- A heading section that can be used to describe the function of the program and a changelog
- A licensing statement
- A section for functions
- A Help function
- A function to test whether the program user is root
- A method for evaluating command-line options
A basic Bash script has three sections. Bash has no way to delineate sections, but the boundaries between the sections are implicit.
- All scripts must begin with the shebang ( #! ), and this must be the first line in any Bash program.
- The functions section must begin after the shebang and before the body of the program. As part of my need to document everything, I place a comment before each function with a short description of what it is intended to do. I also include comments inside the functions to elaborate further. Short, simple programs may not need functions.
- The main part of the program comes after the function section. This can be a single Bash statement or thousands of lines of code. One of my programs has a little over 200 lines of code, not counting comments. That same program has more than 600 comment lines.
That is all there is -- just three sections in the structure of any Bash program.
Leading commentsI always add more than this for various reasons. First, I add a couple of sections of comments immediately after the shebang. These comment sections are optional, but I find them very helpful.
The first comment section is the program name and description and a change history. I learned this format while working at IBM, and it provides a method of documenting the long-term development of the program and any fixes applied to it. This is an important start in documenting your program.
The second comment section is a copyright and license statement. I use GPLv2, and this seems to be a standard statement for programs licensed under GPLv2. If you use a different open source license, that is fine, but I suggest adding an explicit statement to the code to eliminate any possible confusion about licensing. Scott Peterson's article The source code is the license helps explain the reasoning behind this.
So now the script looks like this:
#!/bin/bash
################################################################################
# scriptTemplate #
# #
# Use this template as the beginning of a new program. Place a short #
# description of the script here. #
# #
# Change History #
# 11/11/2019 David Both Original code. This is a template for creating #
# new Bash shell scripts. #
# Add new history entries as needed. #
# #
# #
################################################################################
################################################################################
################################################################################
# #
# Copyright (C) 2007, 2019 David Both #
# [email protected] #
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
# This program is distributed in the hope that it will be useful, #
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
# GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program; if not, write to the Free Software #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
# #
################################################################################
################################################################################
################################################################################echo "hello world!"
Run the revised program to verify that it still works as expected.
About testingNow is a good time to talk about testing.
" There is always one more bug."
-- Lubarsky's Law of Cybernetic EntomologyLubarsky -- whoever that might be -- is correct. You can never find all the bugs in your code. For every bug I find, there always seems to be another that crops up, usually at a very inopportune time.
Testing is not just about programs. It is also about verification that problems -- whether caused by hardware, software, or the seemingly endless ways users can find to break things -- that are supposed to be resolved actually are. Just as important, testing is also about ensuring that the code is easy to use and the interface makes sense to the user.
Following a well-defined process when writing and testing shell scripts can contribute to consistent and high-quality results. My process is simple:
The test plan
- Create a simple test plan.
- Start testing right at the beginning of development.
- Perform a final test when the code is complete.
- Move to production and test more.
There are lots of different formats for test plans. I have worked with the full range -- from having it all in my head; to a few notes jotted down on a sheet of paper; and all the way to a complex set of forms that require a full description of each test, which functional code it would test, what the test would accomplish, and what the inputs and results should be.
Speaking as a sysadmin who has been (but is not now) a tester, I try to take the middle ground. Having at least a short written test plan will ensure consistency from one test run to the next. How much detail you need depends upon how formal your development and test functions are.
The sample test plan documents I found using Google were complex and intended for large organizations with very formal development and test processes. Although those test plans would be good for people with "test" in their job title, they do not apply well to sysadmins' more chaotic and time-dependent working conditions. As in most other aspects of the job, sysadmins need to be creative. So here is a short list of things to consider including in your test plan. Modify it to suit your needs:
- The name and a short description of the software being tested
- A description of the software features to be tested
- The starting conditions for each test
- The functions to follow for each test
- A description of the desired outcome for each test
- Specific tests designed to test for negative outcomes
- Tests for how the program handles unexpected inputs
- A clear description of what constitutes pass or fail for each test
- Fuzzy testing, which is described below
This list should give you some ideas for creating your test plans. Most sysadmins should keep it simple and fairly informal.
Test early -- test oftenI always start testing my shell scripts as soon as I complete the first portion that is executable. This is true whether I am writing a short command-line program or a script that is an executable file.
I usually start creating new programs with the shell script template. I write the code for the Help function and test it. This is usually a trivial part of the process, but it helps me get started and ensures that things in the template are working properly at the outset. At this point, it is easy to fix problems with the template portions of the script or to modify it to meet needs that the standard template does not.
Once the template and Help function are working, I move on to creating the body of the program by adding comments to document the programming steps required to meet the program specifications. Now I start adding code to meet the requirements stated in each comment. This code will probably require adding variables that are initialized in that section of the template -- which is now becoming a shell script.
This is where testing is more than just entering data and verifying the results. It takes a bit of extra work. Sometimes I add a command that simply prints the intermediate result of the code I just wrote and verify that. For more complex scripts, I add a -t option for "test mode." In this case, the internal test code executes only when the -t option is entered on the command line.
Final testingAfter the code is complete, I go back to do a complete test of all the features and functions using known inputs to produce specific outputs. I also test some random inputs to see if the program can handle unexpected input.
Final testing is intended to verify that the program is functioning essentially as intended. A large part of the final test is to ensure that functions that worked earlier in the development cycle have not been broken by code that was added or changed later in the cycle.
If you have been testing the script as you add new code to it, you may think there should not be any surprises during the final test. Wrong! There are always surprises during final testing. Always. Expect those surprises, and be ready to spend time fixing them. If there were never any bugs discovered during final testing, there would be no point in doing a final test, would there?
Testing in productionHuh -- what?
"Not until a program has been in production for at least six months will the most harmful error be discovered."
-- Troutman's Programming PostulatesYes, testing in production is now considered normal and desirable. Having been a tester myself, this seems reasonable. "But wait! That's dangerous," you say. My experience is that it is no more dangerous than extensive and rigorous testing in a dedicated test environment. In some cases, there is no choice because there is no test environment -- only production.
Sysadmins are no strangers to the need to test new or revised scripts in production. Anytime a script is moved into production, that becomes the ultimate test. The production environment constitutes the most critical part of that test. Nothing that testers can dream up in a test environment can fully replicate the true production environment.
The allegedly new practice of testing in production is just the recognition of what sysadmins have known all along. The best test is production -- so long as it is not the only test.
Fuzzy testingThis is another of those buzzwords that initially caused me to roll my eyes. Its essential meaning is simple: have someone bang on the keys until something happens, and see how well the program handles it. But there really is more to it than that.
Fuzzy testing is a bit like the time my son broke the code for a game in less than a minute with random input. That pretty much ended my attempts to write games for him.
Most test plans utilize very specific input that generates a specific result or output. Regardless of whether the test defines a positive or negative outcome as a success, it is still controlled, and the inputs and results are specified and expected, such as a specific error message for a specific failure mode.
Fuzzy testing is about dealing with randomness in all aspects of the test, such as starting conditions, very random and unexpected input, random combinations of options selected, low memory, high levels of CPU contending with other programs, multiple instances of the program under test, and any other random conditions that you can think of to apply to the tests.
I try to do some fuzzy testing from the beginning. If the Bash script cannot deal with significant randomness in its very early stages, then it is unlikely to get better as you add more code. This is a good time to catch these problems and fix them while the code is relatively simple. A bit of fuzzy testing at each stage is also useful in locating problems before they get masked by even more code.
After the code is completed, I like to do some more extensive fuzzy testing. Always do some fuzzy testing. I have certainly been surprised by some of the results. It is easy to test for the expected things, but users do not usually do the expected things with a script.
Previews of coming attractionsThis article accomplished a little in the way of creating a template, but it mostly talked about testing. This is because testing is a critical part of creating any kind of program. In the next article in this series, you will add a basic Help function along with some code to detect and act on options, such as -h , to your Bash script template.
Resources
- How to program with Bash: Syntax and tools
- How to program with Bash: Logical operators and shell expansions
- How to program with Bash: Loops
This series of articles is partially based on Volume 2, Chapter 10 of David Both's three-part Linux self-study course, Using and Administering Linux -- Zero to SysAdmin .
Feb 21, 2019 | opensource.com
Software developers writing applications in languages such as Java, Ruby, and Python have sophisticated libraries to help them maintain their software's integrity over time. They create tests that run applications through a series of executions in structured environments to ensure all of their software's aspects work as expected.
These tests are even more powerful when they're automated in a continuous integration (CI) system, where every push to the source repository causes the tests to run, and developers are immediately notified when tests fail. This fast feedback increases developers' confidence in the functional integrity of their applications.
The Bash Automated Testing System ( BATS ) enables developers writing Bash scripts and libraries to apply the same practices used by Java, Ruby, Python, and other developers to their Bash code.
Installing BATSThe BATS GitHub page includes installation instructions. There are two BATS helper libraries that provide more powerful assertions or allow overrides to the Test Anything Protocol ( TAP ) output format used by BATS. These can be installed in a standard location and sourced by all scripts. It may be more convenient to include a complete version of BATS and its helper libraries in the Git repository for each set of scripts or libraries being tested. This can be accomplished using the git submodule system.
The following commands will install BATS and its helper libraries into the test directory in a Git repository.
git submodule init
git submodule add https: // github.com / sstephenson / bats test / libs / bats
git submodule add https: // github.com / ztombol / bats-assert test / libs / bats-assert
git submodule add https: // github.com / ztombol / bats-support test / libs / bats-support
git add .
git commit -m 'installed bats'To clone a Git repository and install its submodules at the same time, use the
--recurse-submodules flag to git clone .Each BATS test script must be executed by the bats executable. If you installed BATS into your source code repo's test/libs directory, you can invoke the test with:
./test/libs/bats/bin/bats <path to test script>Alternatively, add the following to the beginning of each of your BATS test scripts:
#!/usr/bin/env ./test/libs/bats/bin/bats
load 'libs/bats-support/load'
load 'libs/bats-assert/load'and chmod +x <path to test script> . This will a) make them executable with the BATS installed in ./test/libs/bats and b) include these helper libraries. BATS test scripts are typically stored in the test directory and named for the script being tested, but with the .bats extension. For example, a BATS script that tests bin/build should be called test/build.bats .
You can also run an entire set of BATS test files by passing a regular expression to BATS, e.g., ./test/lib/bats/bin/bats test/*.bats .
Organizing libraries and scripts for BATS coverageBash scripts and libraries must be organized in a way that efficiently exposes their inner workings to BATS. In general, library functions and shell scripts that run many commands when they are called or executed are not amenable to efficient BATS testing.
For example, build.sh is a typical script that many people write. It is essentially a big pile of code. Some might even put this pile of code in a function in a library. But it's impossible to run a big pile of code in a BATS test and cover all possible types of failures it can encounter in separate test cases. The only way to test this pile of code with sufficient coverage is to break it into many small, reusable, and, most importantly, independently testable functions.
It's straightforward to add more functions to a library. An added benefit is that some of these functions can become surprisingly useful in their own right. Once you have broken your library function into lots of smaller functions, you can source the library in your BATS test and run the functions as you would any other command to test them.
Bash scripts must also be broken down into multiple functions, which the main part of the script should call when the script is executed. In addition, there is a very useful trick to make it much easier to test Bash scripts with BATS: Take all the code that is executed in the main part of the script and move it into a function, called something like run_main . Then, add the following to the end of the script:
if [[ " ${BASH_SOURCE[0]} " == " ${0} " ]]
then
run_main
fiThis bit of extra code does something special. It makes the script behave differently when it is executed as a script than when it is brought into the environment with source . This trick enables the script to be tested the same way a library is tested, by sourcing it and testing the individual functions. For example, here is build.sh refactored for better BATS testability .
Writing and running testsAs mentioned above, BATS is a TAP-compliant testing framework with a syntax and output that will be familiar to those who have used other TAP-compliant testing suites, such as JUnit, RSpec, or Jest. Its tests are organized into individual test scripts. Test scripts are organized into one or more descriptive @test blocks that describe the unit of the application being tested. Each @test block will run a series of commands that prepares the test environment, runs the command to be tested, and makes assertions about the exit and output of the tested command. Many assertion functions are imported with the bats , bats-assert , and bats-support libraries, which are loaded into the environment at the beginning of the BATS test script. Here is a typical BATS test block:
@ test "requires CI_COMMIT_REF_SLUG environment variable" {
unset CI_COMMIT_REF_SLUG
assert_empty " ${CI_COMMIT_REF_SLUG} "
run some_command
assert_failure
assert_output --partial "CI_COMMIT_REF_SLUG"
}If a BATS script includes setup and/or teardown functions, they are automatically executed by BATS before and after each test block runs. This makes it possible to create environment variables, test files, and do other things needed by one or all tests, then tear them down after each test runs. Build.bats is a full BATS test of our newly formatted build.sh script. (The mock_docker command in this test will be explained below, in the section on mocking/stubbing.)
When the test script runs, BATS uses exec to run each @test block as a separate subprocess. This makes it possible to export environment variables and even functions in one @test without affecting other @test s or polluting your current shell session. The output of a test run is a standard format that can be understood by humans and parsed or manipulated programmatically by TAP consumers. Here is an example of the output for the CI_COMMIT_REF_SLUG test block when it fails:
✗ requires CI_COMMIT_REF_SLUG environment variable
( from function ` assert_output ' in file test/libs/bats-assert/src/assert.bash, line 231,
in test file test/ci_deploy.bats, line 26)
`assert_output --partial "CI_COMMIT_REF_SLUG"' failed-- output does not contain substring --
substring ( 1 lines ) :
CI_COMMIT_REF_SLUG
output ( 3 lines ) :
. / bin / deploy.sh: join_string_by: command not found
oc error
Could not login
--** Did not delete , as test failed **
1 test , 1 failure
Here is the output of a successful test:
✓ requires CI_COMMIT_REF_SLUG environment variableHelpersLike any shell script or library, BATS test scripts can include helper libraries to share common code across tests or enhance their capabilities. These helper libraries, such as bats-assert and bats-support , can even be tested with BATS.
Libraries can be placed in the same test directory as the BATS scripts or in the test/libs directory if the number of files in the test directory gets unwieldy. BATS provides the load function that takes a path to a Bash file relative to the script being tested (e.g., test , in our case) and sources that file. Files must end with the prefix .bash , but the path to the file passed to the load function can't include the prefix. build.bats loads the bats-assert and bats-support libraries, a small helpers.bash library, and a docker_mock.bash library (described below) with the following code placed at the beginning of the test script below the interpreter magic line:
load 'libs/bats-support/load'
load 'libs/bats-assert/load'
load 'helpers'
load 'docker_mock' Stubbing test input and mocking external callsThe majority of Bash scripts and libraries execute functions and/or executables when they run. Often they are programmed to behave in specific ways based on the exit status or output ( stdout , stderr ) of these functions or executables. To properly test these scripts, it is often necessary to make fake versions of these commands that are designed to behave in a specific way during a specific test, a process called "stubbing." It may also be necessary to spy on the program being tested to ensure it calls a specific command, or it calls a specific command with specific arguments, a process called "mocking." For more on this, check out this great discussion of mocking and stubbing in Ruby RSpec, which applies to any testing system.
The Bash shell provides tricks that can be used in your BATS test scripts to do mocking and stubbing. All require the use of the Bash export command with the -f flag to export a function that overrides the original function or executable. This must be done before the tested program is executed. Here is a simple example that overrides the cat executable:
function cat () { echo "THIS WOULD CAT ${*} " }
export -f catThis method overrides a function in the same manner. If a test needs to override a function within the script or library being tested, it is important to source the tested script or library before the function is stubbed or mocked. Otherwise, the stub/mock will be replaced with the actual function when the script is sourced. Also, make sure to stub/mock before you run the command you're testing. Here is an example from build.bats that mocks the raise function described in build.sh to ensure a specific error message is raised by the login fuction:
@ test ".login raises on oc error" {
source ${profile_script}
function raise () { echo " ${1} raised" ; }
export -f raise
run login
assert_failure
assert_output -p "Could not login raised"
}Normally, it is not necessary to unset a stub/mock function after the test, since export only affects the current subprocess during the exec of the current @test block. However, it is possible to mock/stub commands (e.g. cat , sed , etc.) that the BATS assert * functions use internally. These mock/stub functions must be unset before these assert commands are run, or they will not work properly. Here is an example from build.bats that mocks sed , runs the build_deployable function, and unsets sed before running any assertions:
@ test ".build_deployable prints information, runs docker build on a modified Dockerfile.production and publish_image when its not a dry_run" {
local expected_dockerfile = 'Dockerfile.production'
local application = 'application'
local environment = 'environment'
local expected_original_base_image = " ${application} "
local expected_candidate_image = " ${application} -candidate: ${environment} "
local expected_deployable_image = " ${application} : ${environment} "
source ${profile_script}
mock_docker build --build-arg OAUTH_CLIENT_ID --build-arg OAUTH_REDIRECT --build-arg DDS_API_BASE_URL -t " ${expected_deployable_image} " -
function publish_image () { echo "publish_image ${*} " ; }
export -f publish_image
function sed () {
echo "sed ${*} " >& 2 ;
echo "FROM application-candidate:environment" ;
}
export -f sed
run build_deployable " ${application} " " ${environment} "
assert_success
unset sed
assert_output --regexp "sed.* ${expected_dockerfile} "
assert_output -p "Building ${expected_original_base_image} deployable ${expected_deployable_image} FROM ${expected_candidate_image} "
assert_output -p "FROM ${expected_candidate_image} piped"
assert_output -p "build --build-arg OAUTH_CLIENT_ID --build-arg OAUTH_REDIRECT --build-arg DDS_API_BASE_URL -t ${expected_deployable_image} -"
assert_output -p "publish_image ${expected_deployable_image} "
}Sometimes the same command, e.g. foo, will be invoked multiple times, with different arguments, in the same function being tested. These situations require the creation of a set of functions:
- mock_foo: takes expected arguments as input, and persists these to a TMP file
- foo: the mocked version of the command, which processes each call with the persisted list of expected arguments. This must be exported with export -f.
- cleanup_foo: removes the TMP file, for use in teardown functions. This can test to ensure that a @test block was successful before removing.
Since this functionality is often reused in different tests, it makes sense to create a helper library that can be loaded like other libraries.
A good example is docker_mock.bash . It is loaded into build.bats and used in any test block that tests a function that calls the Docker executable. A typical test block using docker_mock looks like:
@ test ".publish_image fails if docker push fails" {
setup_publish
local expected_image = "image"
local expected_publishable_image = " ${CI_REGISTRY_IMAGE} / ${expected_image} "
source ${profile_script}
mock_docker tag " ${expected_image} " " ${expected_publishable_image} "
mock_docker push " ${expected_publishable_image} " and_fail
run publish_image " ${expected_image} "
assert_failure
assert_output -p "tagging ${expected_image} as ${expected_publishable_image} "
assert_output -p "tag ${expected_image} ${expected_publishable_image} "
assert_output -p "pushing image to gitlab registry"
assert_output -p "push ${expected_publishable_image} "
}This test sets up an expectation that Docker will be called twice with different arguments. With the second call to Docker failing, it runs the tested command, then tests the exit status and expected calls to Docker.
One aspect of BATS introduced by mock_docker.bash is the ${BATS_TMPDIR} environment variable, which BATS sets at the beginning to allow tests and helpers to create and destroy TMP files in a standard location. The mock_docker.bash library will not delete its persisted mocks file if a test fails, but it will print where it is located so it can be viewed and deleted. You may need to periodically clean old mock files out of this directory.
One note of caution regarding mocking/stubbing: The build.bats test consciously violates a dictum of testing that states: Don't mock what you don't own! This dictum demands that calls to commands that the test's developer didn't write, like docker , cat , sed , etc., should be wrapped in their own libraries, which should be mocked in tests of scripts that use them. The wrapper libraries should then be tested without mocking the external commands.
This is good advice and ignoring it comes with a cost. If the Docker CLI API changes, the test scripts will not detect this change, resulting in a false positive that won't manifest until the tested build.sh script runs in a production setting with the new version of Docker. Test developers must decide how stringently they want to adhere to this standard, but they should understand the tradeoffs involved with their decision.
ConclusionIntroducing a testing regime to any software development project creates a tradeoff between a) the increase in time and organization required to develop and maintain code and tests and b) the increased confidence developers have in the integrity of the application over its lifetime. Testing regimes may not be appropriate for all scripts and libraries.
In general, scripts and libraries that meet one or more of the following should be tested with BATS:
- They are worthy of being stored in source control
- They are used in critical processes and relied upon to run consistently for a long period of time
- They need to be modified periodically to add/remove/modify their function
- They are used by others
Once the decision is made to apply a testing discipline to one or more Bash scripts or libraries, BATS provides the comprehensive testing features that are available in other software development environments.
Acknowledgment: I am indebted to Darrin Mann for introducing me to BATS testing.
Jul 12, 2020 | opensource.com
How to add a Help facility to your Bash program In the third article in this series, learn about using functions as you create a simple Help facility for your Bash script. 20 Dec 2019 David Both (Correspondent) Feed 53 up Image by : Opensource.com x Subscribe now
Get the highlights in your inbox every week.
https://opensource.com/eloqua-embedded-email-capture-block.html?offer_id=70160000000QzXNAA0
In the first article in this series, you created a very small, one-line Bash script and explored the reasons for creating shell scripts and why they are the most efficient option for the system administrator, rather than compiled programs. In the second article , you began the task of creating a fairly simple template that you can use as a starting point for other Bash programs, then explored ways to test it.
This third of the four articles in this series explains how to create and use a simple Help function. While creating your Help facility, you will also learn about using functions and how to handle command-line options such as -h .
Why Help? More on BashEven fairly simple Bash programs should have some sort of Help facility, even if it is fairly rudimentary. Many of the Bash shell programs I write are used so infrequently that I forget the exact syntax of the command I need. Others are so complex that I need to review the options and arguments even when I use them frequently.
- Bash cheat sheet
- An introduction to programming with Bash
- A sysadmin's guide to Bash scripting
- Latest Bash articles
Having a built-in Help function allows you to view those things without having to inspect the code itself. A good and complete Help facility is also a part of program documentation.
About functionsShell functions are lists of Bash program statements that are stored in the shell's environment and can be executed, like any other command, by typing their name at the command line. Shell functions may also be known as procedures or subroutines, depending upon which other programming language you are using.
Functions are called in scripts or from the command-line interface (CLI) by using their names, just as you would for any other command. In a CLI program or a script, the commands in the function execute when they are called, then the program flow sequence returns to the calling entity, and the next series of program statements in that entity executes.
The syntax of a function is:
FunctionName(){program statements}Explore this by creating a simple function at the CLI. (The function is stored in the shell environment for the shell instance in which it is created.) You are going to create a function called hw , which stands for "hello world." Enter the following code at the CLI and press Enter . Then enter hw as you would any other shell command:
[ student @ testvm1 ~ ] $ hw (){ echo "Hi there kiddo" ; }
[ student @ testvm1 ~ ] $ hw
Hi there kiddo
[ student @ testvm1 ~ ] $OK, so I am a little tired of the standard "Hello world" starter. Now, list all of the currently defined functions. There are a lot of them, so I am showing just the new hw function. When it is called from the command line or within a program, a function performs its programmed task and then exits and returns control to the calling entity, the command line, or the next Bash program statement in a script after the calling statement:
[ student @ testvm1 ~ ] $ declare -f | less
< snip >
hw ()
{
echo "Hi there kiddo"
}
< snip >Remove that function because you do not need it anymore. You can do that with the unset command:
[ student @ testvm1 ~ ] $ unset -f hw ; hw
bash: hw: command not found
[ student @ testvm1 ~ ] $ Creating the Help functionOpen the hello program in an editor and add the Help function below to the hello program code after the copyright statement but before the echo "Hello world!" statement. This Help function will display a short description of the program, a syntax diagram, and short descriptions of the available options. Add a call to the Help function to test it and some comment lines that provide a visual demarcation between the functions and the main portion of the program:
################################################################################
# Help #
################################################################################
Help ()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}################################################################################
################################################################################
# Main program #
################################################################################
################################################################################Help
echo "Hello world!"The options described in this Help function are typical for the programs I write, although none are in the code yet. Run the program to test it:
[ student @ testvm1 ~ ] $ . / hello
Add description of the script functions here.Syntax: scriptTemplate [ -g | h | v | V ]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.Hello world !
[ student @ testvm1 ~ ] $Because you have not added any logic to display Help only when you need it, the program will always display the Help. Since the function is working correctly, read on to add some logic to display the Help only when the -h option is used when you invoke the program at the command line.
Handling optionsA Bash script's ability to handle command-line options such as -h gives some powerful capabilities to direct the program and modify what it does. In the case of the -h option, you want the program to print the Help text to the terminal session and then quit without running the rest of the program. The ability to process options entered at the command line can be added to the Bash script using the while command (see How to program with Bash: Loops to learn more about while ) in conjunction with the getops and case commands.
The getops command reads any and all options specified at the command line and creates a list of those options. In the code below, the while command loops through the list of options by setting the variable $options for each. The case statement is used to evaluate each option in turn and execute the statements in the corresponding stanza. The while statement will continue to evaluate the list of options until they have all been processed or it encounters an exit statement, which terminates the program.
Be sure to delete the Help function call just before the echo "Hello world!" statement so that the main body of the program now looks like this:
################################################################################
################################################################################
# Main program #
################################################################################
################################################################################
################################################################################
# Process the input options. Add options as needed. #
################################################################################
# Get the options
while getopts ":h" option; do
case $option in
h ) # display Help
Help
exit ;;
esac
doneecho "Hello world!"
Notice the double semicolon at the end of the exit statement in the case option for -h . This is required for each option added to this case statement to delineate the end of each option.
TestingTesting is now a little more complex. You need to test your program with a number of different options -- and no options -- to see how it responds. First, test with no options to ensure that it prints "Hello world!" as it should:
[ student @ testvm1 ~ ] $ . / hello
Hello world !That works, so now test the logic that displays the Help text:
[ student @ testvm1 ~ ] $ . / hello -h
Add description of the script functions here.Syntax: scriptTemplate [ -g | h | t | v | V ]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.That works as expected, so try some testing to see what happens when you enter some unexpected options:
[ student @ testvm1 ~ ] $ . / hello -x
Hello world !
[ student @ testvm1 ~ ] $ . / hello -q
Hello world !
[ student @ testvm1 ~ ] $ . / hello -lkjsahdf
Add description of the script functions here.Syntax: scriptTemplate [ -g | h | t | v | V ]
options:
g Print the GPL license notification.
h Print this Help.
v Verbose mode.
V Print software version and exit.[ student @ testvm1 ~ ] $
The program just ignores any options without specific responses without generating any errors. But notice the last entry (with -lkjsahdf for options): because there is an h in the list of options, the program recognizes it and prints the Help text. This testing has shown that the program doesn't have the ability to handle incorrect input and terminate the program if any is detected.
You can add another case stanza to the case statement to match any option that doesn't have an explicit match. This general case will match anything you have not provided a specific match for. The case statement now looks like this, with the catch-all match of \? as the last case. Any additional specific cases must precede this final one:
while getopts ":h" option; do
case $option in
h ) # display Help
Help
exit ;;
\? ) # incorrect option
echo "Error: Invalid option"
exit ;;
esac
doneTest the program again using the same options as before and see how it works now.
Where you areYou have accomplished a good amount in this article by adding the capability to process command-line options and a Help procedure. Your Bash script now looks like this:
#!/usr/bin/bash
################################################################################
# scriptTemplate #
# #
# Use this template as the beginning of a new program. Place a short #
# description of the script here. #
# #
# Change History #
# 11/11/2019 David Both Original code. This is a template for creating #
# new Bash shell scripts. #
# Add new history entries as needed. #
# #
# #
################################################################################
################################################################################
################################################################################
# #
# Copyright (C) 2007, 2019 David Both #
# [email protected] #
# #
# This program is free software; you can redistribute it and/or modify #
# it under the terms of the GNU General Public License as published by #
# the Free Software Foundation; either version 2 of the License, or #
# (at your option) any later version. #
# #
# This program is distributed in the hope that it will be useful, #
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
# GNU General Public License for more details. #
# #
# You should have received a copy of the GNU General Public License #
# along with this program; if not, write to the Free Software #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
# #
################################################################################
################################################################################
################################################################################################################################################################
# Help #
################################################################################
Help ()
{
# Display Help
echo "Add description of the script functions here."
echo
echo "Syntax: scriptTemplate [-g|h|t|v|V]"
echo "options:"
echo "g Print the GPL license notification."
echo "h Print this Help."
echo "v Verbose mode."
echo "V Print software version and exit."
echo
}################################################################################
################################################################################
# Main program #
################################################################################
################################################################################
################################################################################
# Process the input options. Add options as needed. #
################################################################################
# Get the options
while getopts ":h" option; do
case $option in
h ) # display Help
Help
exit ;;
\? ) # incorrect option
echo "Error: Invalid option"
exit ;;
esac
doneecho "Hello world!"
Be sure to test this version of the program very thoroughly. Use random inputs and see what happens. You should also try testing valid and invalid options without using the dash ( - ) in front.
Next timeIn this article, you added a Help function as well as the ability to process command-line options to display it selectively. The program is getting a little more complex, so testing is becoming more important and requires more test paths in order to be complete.
The next article will look at initializing variables and doing a bit of sanity checking to ensure that the program will run under the correct set of conditions.
Jul 12, 2020 | opensource.com
Navigating the Bash shell with pushd and popd Pushd and popd are the fastest navigational commands you've never heard of. 07 Aug 2019 Seth Kenlon (Red Hat) Feed 71 up 7 comments Image by : Opensource.com x Subscribe now
Get the highlights in your inbox every week.
https://opensource.com/eloqua-embedded-email-capture-block.html?offer_id=70160000000QzXNAA0
The pushd and popd commands are built-in features of the Bash shell to help you "bookmark" directories for quick navigation between locations on your hard drive. You might already feel that the terminal is an impossibly fast way to navigate your computer; in just a few key presses, you can go anywhere on your hard drive, attached storage, or network share. But that speed can break down when you find yourself going back and forth between directories, or when you get "lost" within your filesystem. Those are precisely the problems pushd and popd can help you solve.
pushdAt its most basic, pushd is a lot like cd . It takes you from one directory to another. Assume you have a directory called one , which contains a subdirectory called two , which contains a subdirectory called three , and so on. If your current working directory is one , then you can move to two or three or anywhere with the cd command:
$ pwd
one
$ cd two / three
$ pwd
threeYou can do the same with pushd :
$ pwd
one
$ pushd two / three
~ / one / two / three ~ / one
$ pwd
threeThe end result of pushd is the same as cd , but there's an additional intermediate result: pushd echos your destination directory and your point of origin. This is your directory stack , and it is what makes pushd unique.
StacksA stack, in computer terminology, refers to a collection of elements. In the context of this command, the elements are directories you have recently visited by using the pushd command. You can think of it as a history or a breadcrumb trail.
You can move all over your filesystem with pushd ; each time, your previous and new locations are added to the stack:
$ pushd four
~ / one / two / three / four ~ / one / two / three ~ / one
$ pushd five
~ / one / two / three / four / five ~ / one / two / three / four ~ / one / two / three ~ / one Navigating the stackOnce you've built up a stack, you can use it as a collection of bookmarks or fast-travel waypoints. For instance, assume that during a session you're doing a lot of work within the ~/one/two/three/four/five directory structure of this example. You know you've been to one recently, but you can't remember where it's located in your pushd stack. You can view your stack with the +0 (that's a plus sign followed by a zero) argument, which tells pushd not to change to any directory in your stack, but also prompts pushd to echo your current stack:
$ pushd + 0
~ / one / two / three / four ~ / one / two / three ~ / one ~ / one / two / three / four / fiveAlternatively, you can view the stack with the dirs command, and you can see the index number for each directory by using the -v option:
$ dirs -v
0 ~ / one / two / three / four
1 ~ / one / two / three
2 ~ / one
3 ~ / one / two / three / four / fiveThe first entry in your stack is your current location. You can confirm that with pwd as usual:
$ pwd
~ / one / two / three / fourStarting at 0 (your current location and the first entry of your stack), the second element in your stack is ~/one , which is your desired destination. You can move forward in your stack using the +2 option:
$ pushd + 2
~ / one ~ / one / two / three / four / five ~ / one / two / three / four ~ / one / two / three
$ pwd
~ / oneThis changes your working directory to ~/one and also has shifted the stack so that your new location is at the front.
You can also move backward in your stack. For instance, to quickly get to ~/one/two/three given the example output, you can move back by one, keeping in mind that pushd starts with 0:
$ pushd -0
~ / one / two / three ~ / one ~ / one / two / three / four / five ~ / one / two / three / four Adding to the stackYou can continue to navigate your stack in this way, and it will remain a static listing of your recently visited directories. If you want to add a directory, just provide the directory's path. If a directory is new to the stack, it's added to the list just as you'd expect:
$ pushd / tmp
/ tmp ~ / one / two / three ~ / one ~ / one / two / three / four / five ~ / one / two / three / fourBut if it already exists in the stack, it's added a second time:
$ pushd ~ / one
~ / one / tmp ~ / one / two / three ~ / one ~ / one / two / three / four / five ~ / one / two / three / fourWhile the stack is often used as a list of directories you want quick access to, it is really a true history of where you've been. If you don't want a directory added redundantly to the stack, you must use the +N and -N notation.
Removing directories from the stackYour stack is, obviously, not immutable. You can add to it with pushd or remove items from it with popd .
For instance, assume you have just used pushd to add ~/one to your stack, making ~/one your current working directory. To remove the first (or "zeroeth," if you prefer) element:
$ pwd
~ / one
$ popd + 0
/ tmp ~ / one / two / three ~ / one ~ / one / two / three / four / five ~ / one / two / three / four
$ pwd
~ / oneOf course, you can remove any element, starting your count at 0:
$ pwd ~ / one
$ popd + 2
/ tmp ~ / one / two / three ~ / one / two / three / four / five ~ / one / two / three / four
$ pwd ~ / oneYou can also use popd from the back of your stack, again starting with 0. For example, to remove the final directory from your stack:
$ popd -0
/ tmp ~ / one / two / three ~ / one / two / three / four / fiveWhen used like this, popd does not change your working directory. It only manipulates your stack.
Navigating with popdThe default behavior of popd , given no arguments, is to remove the first (zeroeth) item from your stack and make the next item your current working directory.
This is most useful as a quick-change command, when you are, for instance, working in two different directories and just need to duck away for a moment to some other location. You don't have to think about your directory stack if you don't need an elaborate history:
$ pwd
~ / one
$ pushd ~ / one / two / three / four / five
$ popd
$ pwd
~ / oneYou're also not required to use pushd and popd in rapid succession. If you use pushd to visit a different location, then get distracted for three hours chasing down a bug or doing research, you'll find your directory stack patiently waiting (unless you've ended your terminal session):
$ pwd ~ / one
$ pushd / tmp
$ cd { / etc, / var, / usr } ; sleep 2001
[ ... ]
$ popd
$ pwd
~ / one Pushd and popd in the real worldThe pushd and popd commands are surprisingly useful. Once you learn them, you'll find excuses to put them to good use, and you'll get familiar with the concept of the directory stack. Getting comfortable with pushd was what helped me understand git stash , which is entirely unrelated to pushd but similar in conceptual intangibility.
Using pushd and popd in shell scripts can be tempting, but generally, it's probably best to avoid them. They aren't portable outside of Bash and Zsh, and they can be obtuse when you're re-reading a script ( pushd +3 is less clear than cd $HOME/$DIR/$TMP or similar).
Aside from these warnings, if you're a regular Bash or Zsh user, then you can and should try pushd and popd . Bash prompt tips and tricks Here are a few hidden treasures you can use to customize your Bash prompt. Dave Neary (Red Hat) Topics Bash Linux Command line About the author Seth Kenlon - Seth Kenlon is an independent multimedia artist, free culture advocate, and UNIX geek. He has worked in the film and computing industry, often at the same time. He is one of the maintainers of the Slackware-based multimedia production project, http://slackermedia.info More about me Recommended reading
Add videos as wallpaper on your Linux desktop
Use systemd timers instead of cronjobs
Why I stick with xterm
Customizing my Linux terminal with tmux and Git
Back up your phone's storage with this Linux utility
Read and write data from anywhere with redirection in the Linux terminal 7 Comments
matt on 07 Aug 2019
Seth Kenlon on 07 Aug 2019Thank you for the write up for pushd and popd. I gotta remember to use these when I'm jumping around directories a lot. I got a hung up on a pushd example because my development work using arrays differentiates between the index and the count. In my experience, a zero-based array of A, B, C; C has an index of 2 and also is the third element. C would not be considered the second element cause that would be confusing it's index and it's count.
Greg Pittman on 07 Aug 2019Interesting point, Matt. The difference between count and index had not occurred to me, but I'll try to internalise it. It's a great distinction, so thanks for bringing it up!
Seth Kenlon on 07 Aug 2019This looks like a recipe for confusing myself.
Jake on 07 Aug 2019It can be, but start out simple: use pushd to change to one directory, and then use popd to go back to the original. Sort of a single-use bookmark system.
Then, once you're comfortable with pushd and popd, branch out and delve into the stack.
A tcsh shell I used at an old job didn't have pushd and popd, so I used to have functions in my .cshrc to mimic just the back-and-forth use.
Seth Kenlon on 07 Aug 2019"dirs" can be also used to view the stack. "dirs -v" helpfully numbers each directory with its index.
other_Stu on 11 Aug 2019Thanks for that tip, Jake. I arguably should have included that in the article, but I wanted to try to stay focused on just the two {push,pop}d commands. Didn't occur to me to casually mention one use of dirs as you have here, so I've added it for posterity.
There's so much in the Bash man and info pages to talk about!
I use "pushd ." (dot for current directory) quite often. Like a working directory bookmark when you are several subdirectories deep somewhere, and need to cd to couple of other places to do some work or check something.
And you can use the cd command with your DIRSTACK as well, thanks to tilde expansion.
cd ~+3 will take you to the same directory as pushd +3 would.
Jul 12, 2020 | opensource.com
An introduction to parameter expansion in Bash Get started with this quick how-to guide on expansion modifiers that transform Bash variables and other parameters into powerful tools beyond simple value stores. 13 Jun 2017 James Pannacciulli Feed 366 up 4 comments Image by : Opensource.com x Subscribe now
Get the highlights in your inbox every week.
https://opensource.com/eloqua-embedded-email-capture-block.html?offer_id=70160000000QzXNAA0
In Bash, entities that store values are known as parameters. Their values can be strings or arrays with regular syntax, or they can be integers or associative arrays when special attributes are set with the declare built-in. There are three types of parameters: positional parameters, special parameters, and variables.
More Linux resources
- Linux commands cheat sheet
- Advanced Linux commands cheat sheet
- Free online course: RHEL Technical Overview
- Linux networking cheat sheet
- SELinux cheat sheet
- Linux common commands cheat sheet
- What are Linux containers?
- Our latest Linux articles
For the sake of brevity, this article will focus on a few classes of expansion methods available for string variables, though these methods apply equally to other types of parameters.
Variable assignment and unadulterated expansionWhen assigning a variable, its name must be comprised solely of alphanumeric and underscore characters, and it may not begin with a numeral. There may be no spaces around the equal sign; the name must immediately precede it and the value immediately follow:
$ variable_1="my content"Storing a value in a variable is only useful if we recall that value later; in Bash, substituting a parameter reference with its value is called expansion. To expand a parameter, simply precede the name with the $ character, optionally enclosing the name in braces:
$ echo $variable_1 ${variable_1} my content my contentCrucially, as shown in the above example, expansion occurs before the command is called, so the command never sees the variable name, only the text passed to it as an argument that resulted from the expansion. Furthermore, parameter expansion occurs before word splitting; if the result of expansion contains spaces, the expansion should be quoted to preserve parameter integrity, if desired:
$ printf "%s\n" ${variable_1} my content $ printf "%s\n" "${variable_1}" my contentParameter expansion modifiersParameter expansion goes well beyond simple interpolation, however. Inside the braces of a parameter expansion, certain operators, along with their arguments, may be placed after the name, before the closing brace. These operators may invoke conditional, subset, substring, substitution, indirection, prefix listing, element counting, and case modification expansion methods, modifying the result of the expansion. With the exception of the reassignment operators ( = and := ), these operators only affect the expansion of the parameter without modifying the parameter's value for subsequent expansions.
About conditional, substring, and substitution parameter expansion operators Conditional parameter expansionConditional parameter expansion allows branching on whether the parameter is unset, empty, or has content. Based on these conditions, the parameter can be expanded to its value, a default value, or an alternate value; throw a customizable error; or reassign the parameter to a default value. The following table shows the conditional parameter expansions -- each row shows a parameter expansion using an operator to potentially modify the expansion, with the columns showing the result of that expansion given the parameter's status as indicated in the column headers. Operators with the ':' prefix treat parameters with empty values as if they were unset.
parameter expansion unset var var="" var="gnu" ${var-default} default -- gnu ${var:-default} default default gnu ${var+alternate} -- alternate alternate ${var:+alternate} -- -- alternate ${var?error} error -- gnu ${var:?error} error error gnu The = and := operators in the table function identically to - and :- , respectively, except that the = variants rebind the variable to the result of the expansion.
As an example, let's try opening a user's editor on a file specified by the OUT_FILE variable. If either the EDITOR environment variable or our OUT_FILE variable is not specified, we will have a problem. Using a conditional expansion, we can ensure that when the EDITOR variable is expanded, we get the specified value or at least a sane default:
$ echo ${EDITOR} /usr/bin/vi $ echo ${EDITOR:-$(which nano)} /usr/bin/vi $ unset EDITOR $ echo ${EDITOR:-$(which nano)} /usr/bin/nanoBuilding on the above, we can run the editor command and abort with a helpful error at runtime if there's no filename specified:
$ ${EDITOR:-$(which nano)} ${OUT_FILE:?Missing filename} bash: OUT_FILE: Missing filenameSubstring parameter expansionParameters can be expanded to just part of their contents, either by offset or by removing content matching a pattern. When specifying a substring offset, a length may optionally be specified. If running Bash version 4.2 or greater, negative numbers may be used as offsets from the end of the string. Note the parentheses used around the negative offset, which ensure that Bash does not parse the expansion as having the conditional default expansion operator from above:
$ location="CA 90095" $ echo "Zip Code: ${location:3}" Zip Code: 90095 $ echo "Zip Code: ${location:(-5)}" Zip Code: 90095 $ echo "State: ${location:0:2}" State: CAAnother way to take a substring is to remove characters from the string matching a pattern, either from the left edge with the # and ## operators or from the right edge with the % and % operators. A useful mnemonic is that # appears left of a comment and % appears right of a number. When the operator is doubled, it matches greedily, as opposed to the single version, which removes the most minimal set of characters matching the pattern.
var="open source" parameter expansion offset of 5
length of 4${var:offset} source ${var:offset:length} sour pattern of *o? ${var#pattern} en source ${var##pattern} rce pattern of ?e* ${var%pattern} open sour ${var%pattern} o The pattern-matching used is the same as with filename globbing: * matches zero or more of any character, ? matches exactly one of any character, [...] brackets introduce a character class match against a single character, supporting negation ( ^ ), as well as the posix character classes, e.g. [[:alnum:]] . By excising characters from our string in this manner, we can take a substring without first knowing the offset of the data we need:
$ echo $PATH /usr/local/bin:/usr/bin:/bin $ echo "Lowest priority in PATH: ${PATH##*:}" Lowest priority in PATH: /bin $ echo "Everything except lowest priority: ${PATH%:*}" Everything except lowest priority: /usr/local/bin:/usr/bin $ echo "Highest priority in PATH: ${PATH%:*}" Highest priority in PATH: /usr/local/binSubstitution in parameter expansionThe same types of patterns are used for substitution in parameter expansion. Substitution is introduced with the / or // operators, followed by two arguments separated by another / representing the pattern and the string to substitute. The pattern matching is always greedy, so the doubled version of the operator, in this case, causes all matches of the pattern to be replaced in the variable's expansion, while the singleton version replaces only the leftmost.
var="free and open" parameter expansion pattern of [[:space:]]
string of _${var/pattern/string} free_and open ${var//pattern/string} free_and_open The wealth of parameter expansion modifiers transforms Bash variables and other parameters into powerful tools beyond simple value stores. At the very least, it is important to understand how parameter expansion works when reading Bash scripts, but I suspect that not unlike myself, many of you will enjoy the conciseness and expressiveness that these expansion modifiers bring to your scripts as well as your interactive sessions. Topics Linux About the author James Pannacciulli - James Pannacciulli is an advocate for software freedom & user autonomy with an MA in Linguistics. Employed as a Systems Engineer in Los Angeles, in his free time he occasionally gives talks on bash usage at various conferences. James likes his beers sour and his nettles stinging. More from James may be found on his home page . He has presented at conferences including SCALE ,...
Jul 12, 2020 | opensource.com
Use aliases
... ... ...
Make your root prompt stand out... ... ...
Control your historyYou probably know that when you press the Up arrow key in Bash, you can see and reuse all (well, many) of your previous commands. That is because those commands have been saved to a file called .bash_history in your home directory. That history file comes with a bunch of settings and commands that can be very useful.
First, you can view your entire recent command history by typing
history
, or you can limit it to your last 30 commands by typinghistory 30
. But that's pretty vanilla. You have more control over what Bash saves and how it saves it.For example, if you add the following to your .bashrc, any commands that start with a space will not be saved to the history list:
HISTCONTROL=ignorespaceThis can be useful if you need to pass a password to a command in plaintext. (Yes, that is horrible, but it still happens.)
If you don't want a frequently executed command to show up in your history, use:
HISTCONTROL=ignorespace:erasedupsWith this, every time you use a command, all its previous occurrences are removed from the history file, and only the last invocation is saved to your history list.
A history setting I particularly like is the
HISTTIMEFORMAT
setting. This will prepend all entries in your history file with a timestamp. For example, I use:HISTTIMEFORMAT="%F %T "When I type
1009 2018 -06- 11 22 : 34 : 38 cat / etc / hostshistory 5
, I get nice, complete information, like this:
1010 2018 -06- 11 22 : 34 : 40 echo $foo
1011 2018 -06- 11 22 : 34 : 42 echo $bar
1012 2018 -06- 11 22 : 34 : 44 ssh myhost
1013 2018 -06- 11 22 : 34 : 55 vim .bashrcThat makes it a lot easier to browse my command history and find the one I used two days ago to set up an SSH tunnel to my home lab (which I forget again, and again, and again ).
Best Bash practicesI'll wrap this up with my top 11 list of the best (or good, at least; I don't claim omniscience) practices when writing Bash scripts.
Bash scripts can become complicated and comments are cheap. If you wonder whether to add a comment, add a comment. If you return after the weekend and have to spend time figuring out what you were trying to do last Friday, you forgot to add a comment.
- Wrap all your variable names in curly braces, like
${myvariable}
. Making this a habit makes things like${variable}_suffix
possible and improves consistency throughout your scripts.
- Do not use backticks when evaluating an expression; use the
$()
syntax instead. So use:for file in $(ls); donotfor file in `ls`; doThe former option is nestable, more easily readable, and keeps the general sysadmin population happy. Do not use backticks.
- Consistency is good. Pick one style of doing things and stick with it throughout your script. Obviously, I would prefer if people picked the
$()
syntax over backticks and wrapped their variables in curly braces. I would prefer it if people used two or four spaces -- not tabs -- to indent, but even if you choose to do it wrong, do it wrong consistently.
- Use the proper shebang for a Bash script. As I'm writing Bash scripts with the intention of only executing them with Bash, I most often use
#!/usr/bin/bash
as my shebang. Do not use#!/bin/sh
or#!/usr/bin/sh
. Your script will execute, but it'll run in compatibility mode -- potentially with lots of unintended side effects. (Unless, of course, compatibility mode is what you want.)
- When comparing strings, it's a good idea to quote your variables in if-statements, because if your variable is empty, Bash will throw an error for lines like these: if [ ${myvar} == "foo" ] ; then
echo "bar"
fi And will evaluate to false for a line like this: if [ " ${myvar} " == "foo" ] ; then
echo "bar"
fi Also, if you are unsure about the contents of a variable (e.g., when you are parsing user input), quote your variables to prevent interpretation of some special characters and make sure the variable is considered a single word, even if it contains whitespace.
- This is a matter of taste, I guess, but I prefer using the double equals sign (
==
) even when comparing strings in Bash. It's a matter of consistency, and even though -- for string comparisons only -- a single equals sign will work, my mind immediately goes "single equals is an assignment operator!"
- Use proper exit codes. Make sure that if your script fails to do something, you present the user with a written failure message (preferably with a way to fix the problem) and send a non-zero exit code: # we have failed
echo "Process has failed to complete, you need to manually restart the whatchamacallit"
exit 1 This makes it easier to programmatically call your script from yet another script and verify its successful completion.
- Use Bash's built-in mechanisms to provide sane defaults for your variables or throw errors if variables you expect to be defined are not defined: # this sets the value of $myvar to redhat, and prints 'redhat'
echo ${myvar:=redhat} # this throws an error reading 'The variable myvar is undefined, dear reader' if $myvar is undefined
${myvar:?The variable myvar is undefined, dear reader}
- Especially if you are writing a large script, and especially if you work on that large script with others, consider using the
local
keyword when defining variables inside functions. Thelocal
keyword will create a local variable, that is one that's visible only within that function. This limits the possibility of clashing variables.
- Every sysadmin must do it sometimes: debug something on a console, either a real one in a data center or a virtual one through a virtualization platform. If you have to debug a script that way, you will thank yourself for remembering this: Do not make the lines in your scripts too long!
On many systems, the default width of a console is still 80 characters. If you need to debug a script on a console and that script has very long lines, you'll be a sad panda. Besides, a script with shorter lines -- the default is still 80 characters -- is a lot easier to read and understand in a normal editor, too!
I truly love Bash. I can spend hours writing about it or exchanging nice tricks with fellow enthusiasts. Make sure you drop your favorites in the comments!
Jan 09, 2020 | opensource.com
Get the highlights in your inbox every week.
When you work with computers all day, it's fantastic to find repeatable commands and tag them for easy use later on. They all sit there, tucked away in ~/.bashrc (or ~/.zshrc for Zsh users ), waiting to help improve your day!
In this article, I share some of my favorite of these helper commands for things I forget a lot, in hopes that they will save you, too, some heartache over time.
Say when it's overWhen I'm using longer-running commands, I often multitask and then have to go back and check if the action has completed. But not anymore, with this helpful invocation of say (this is on MacOS; change for your local equivalent):
function looooooooong {
START=$(date +%s.%N)
$*
EXIT_CODE=$?
END=$(date +%s.%N)
DIFF=$(echo "$END - $START" | bc)
RES=$(python -c "diff = $DIFF; min = int(diff / 60); print('%s min' % min)")
result="$1 completed in $RES, exit code $EXIT_CODE."
echo -e "\n⏰ $result"
( say -r 250 $result 2>&1 > /dev/null & )
}This command marks the start and end time of a command, calculates the minutes it takes, and speaks the command invoked, the time taken, and the exit code. I find this super helpful when a simple console bell just won't do.
... ... ...
There are many Docker commands, but there are even more docker compose commands. I used to forget the --rm flags, but not anymore with these useful aliases:
alias dc = "docker-compose"
alias dcr = "docker-compose run --rm"
alias dcb = "docker-compose run --rm --build" gcurl helper for Google CloudThis one is relatively new to me, but it's heavily documented . gcurl is an alias to ensure you get all the correct flags when using local curl commands with authentication headers when working with Google Cloud APIs.
Git and ~/.gitignoreI work a lot in Git, so I have a special section dedicated to Git helpers.
One of my most useful helpers is one I use to clone GitHub repos. Instead of having to run:
git clone [email protected]:org/repo /Users/glasnt/git/org/repoI set up a clone function:
clone(){
echo Cloning $1 to ~/git/$1
cd ~/git
git clone [email protected]:$1 $1
cd $1
}... ... ...
Jul 09, 2020 | zwischenzugs.com
TL;DR
These commands can tell you what key bindings you have in your bash shell by default.
bind -P | grep 'can be' stty -a | grep ' = ..;'BackgroundI'd aways wondered what key strokes did what in bash – I'd picked up some well-known ones (CTRL-r, CTRL-v, CTRL-d etc) from bugging people when I saw them being used, but always wondered whether there was a list of these I could easily get and comprehend. I found some, but always forgot where it was when I needed them, and couldn't remember many of them anyway.
Then debugging a problem tab completion in 'here' documents, I stumbled across bind.
bind and stty'bind' is a bash builtin, which means it's not a program like awk or grep, but is picked up and handled by the bash program itself.
It manages the various key bindings in the bash shell, covering everything from autocomplete to transposing two characters on the command line. You can read all about it in the bash man page (in the builtins section, near the end).
Bind is not responsible for all the key bindings in your shell – running the stty will show the ones that apply to the terminal:
stty -a | grep ' = ..;'These take precedence and can be confusing if you've tried to bind the same thing in your shell! Further confusion is caused by the fact that '^D' means 'CTRL and d pressed together whereas in bind output, it would be 'C-d'.
edit: am indebted to joepvd from hackernews for this beauty
$ stty -a | awk 'BEGIN{RS="[;n]+ ?"}; /= ..$/' intr = ^C quit = ^ erase = ^? kill = ^U eof = ^D swtch = ^Z susp = ^Z rprnt = ^R werase = ^W lnext = ^V flush = ^OBreaking Down the Commandbind -P | grep canCan be considered (almost) equivalent to a more instructive command:
bind -l | sed 's/.*/bind -q /' | /bin/bash 2>&1 | grep -v warning: | grep can'bind -l' lists all the available keystroke functions. For example, 'complete' is the auto-complete function normally triggered by hitting 'tab' twice. The output of this is passed to a sed command which passes each function name to 'bind -q', which queries the bindings.
sed 's/.*/bind -q /'The output of this is passed for running into /bin/bash.
/bin/bash 2>&1 | grep -v warning: | grep 'can be'Note that this invocation of bash means that locally-set bindings will revert to the default bash ones for the output.
The '2>&1' puts the error output (the warnings) to the same output channel, filtering out warnings with a 'grep -v' and then filtering on output that describes how to trigger the function.
In the output of bind -q, 'C-' means 'the ctrl key and'. So 'C-c' is the normal. Similarly, 't' means 'escape', so 'tt' means 'autocomplete', and 'e' means escape:
$ bind -q complete complete can be invoked via "C-i", "ee".and is also bound to 'C-i' (though on my machine I appear to need to press it twice – not sure why).
Add to bashrcI added this alias as 'binds' in my bashrc so I could easily get hold of this list in the future.
alias binds="bind -P | grep 'can be'"Now whenever I forget a binding, I type 'binds', and have a read :)
[adinserter block="1″]
The ZingerBrowsing through the bash manual, I noticed that an option to bind enables binding to
-x keyseq:shell-commandSo now all I need to remember is one shortcut to get my list (CTRL-x, then CTRL-o):
bind -x '"C-xC-o":bind -P | grep can'Of course, you can bind to a single key if you want, and any command you want. You could also use this for practical jokes on your colleagues
Now I'm going to sort through my history to see what I type most often :)
This post is based on material from Docker in Practice , available on Manning's Early Access Program. Get 39% off with the code: 39miell
Jul 09, 2020 | zwischenzugs.com
Why
strace
?I'm often asked in my technical troubleshooting job to solve problems that development teams can't solve. Usually these do not involve knowledge of API calls or syntax, rather some kind of insight into what the right tool to use is, and why and how to use it. Probably because they're not taught in college, developers are often unaware that these tools exist, which is a shame, as playing with them can give a much deeper understanding of what's going on and ultimately lead to better code.
My favourite secret weapon in this path to understanding is strace.
strace
(or its Solaris equivalents,trussdtruss
is a tool that tells you which operating system (OS) calls your program is making.An OS call (or just "system call") is your program asking the OS to provide some service for it. Since this covers a lot of the things that cause problems not directly to do with the domain of your application development (I/O, finding files, permissions etc) its use has a very high hit rate in resolving problems out of developers' normal problem space.
Usage Patternsstrace is useful in all sorts of contexts. Here's a couple of examples garnered from my experience.
My Netcat Server Won't Start!Imagine you're trying to start an executable, but it's failing silently (no log file, no output at all). You don't have the source, and even if you did, the source code is neither readily available, nor ready to compile, nor readily comprehensible.
Simply running through strace will likely give you clues as to what's gone on.
$ nc -l localhost 80 nc: Permission deniedLet's say someone's trying to run this and doesn't understand why it's not working (let's assume manuals are unavailable).
Simply put
strace
at the front of your command. Note that the following output has been heavily edited for space reasons (deep breath):$ strace nc -l localhost 80 execve("/bin/nc", ["nc", "-l", "localhost", "80"], [/* 54 vars */]) = 0 brk(0) = 0x1e7a000 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory) mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f751c9c0000 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory) open("/usr/local/lib/tls/x86_64/libglib-2.0.so.0", O_RDONLY) = -1 ENOENT (No such file or directory) stat("/usr/local/lib/tls/x86_64", 0x7fff5686c240) = -1 ENOENT (No such file or directory) [...] open("libglib-2.0.so.0", O_RDONLY) = -1 ENOENT (No such file or directory) open("/etc/ld.so.cache", O_RDONLY) = 3 fstat(3, {st_mode=S_IFREG|0644, st_size=179820, ...}) = 0 mmap(NULL, 179820, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f751c994000 close(3) = 0 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory) open("/lib/x86_64-linux-gnu/libglib-2.0.so.0", O_RDONLY) = 3 read(3, "\177ELF\2\1\1\3>\1\320k\1"..., 832) = 832 fstat(3, {st_mode=S_IFREG|0644, st_size=975080, ...}) = 0 mmap(NULL, 3072520, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f751c4b3000 mprotect(0x7f751c5a0000, 2093056, PROT_NONE) = 0 mmap(0x7f751c79f000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0xec000) = 0x7f751c79f000 mmap(0x7f751c7a1000, 520, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f751c7a1000 close(3) = 0 open("/usr/local/lib/libc.so.6", O_RDONLY) = -1 ENOENT (No such file or directory) [...] mmap(NULL, 179820, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f751c994000 close(3) = 0 access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory) open("/lib/x86_64-linux-gnu/libnss_files.so.2", O_RDONLY) = 3 read(3, "\177ELF\2\1\1\3>\1\20\""..., 832) = 832 fstat(3, {st_mode=S_IFREG|0644, st_size=51728, ...}) = 0 mmap(NULL, 2148104, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f751b8b0000 mprotect(0x7f751b8bc000, 2093056, PROT_NONE) = 0 mmap(0x7f751babb000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0xb000) = 0x7f751babb000 close(3) = 0 mprotect(0x7f751babb000, 4096, PROT_READ) = 0 munmap(0x7f751c994000, 179820) = 0 open("/etc/hosts", O_RDONLY|O_CLOEXEC) = 3 fcntl(3, F_GETFD) = 0x1 (flags FD_CLOEXEC) fstat(3, {st_mode=S_IFREG|0644, st_size=315, ...}) = 0 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f751c9bf000 read(3, "127.0.0.1\tlocalhost\n127.0.1.1\tal"..., 4096) = 315 read(3, "", 4096) = 0 close(3) = 0 munmap(0x7f751c9bf000, 4096) = 0 open("/etc/gai.conf", O_RDONLY) = 3 fstat(3, {st_mode=S_IFREG|0644, st_size=3343, ...}) = 0 fstat(3, {st_mode=S_IFREG|0644, st_size=3343, ...}) = 0 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f751c9bf000 read(3, "# Configuration for getaddrinfo("..., 4096) = 3343 read(3, "", 4096) = 0 close(3) = 0 munmap(0x7f751c9bf000, 4096) = 0 futex(0x7f751c4af460, FUTEX_WAKE_PRIVATE, 2147483647) = 0 socket(PF_INET, SOCK_DGRAM, IPPROTO_IP) = 3 connect(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=inet_addr("127.0.0.1")}, 16) = 0 getsockname(3, {sa_family=AF_INET, sin_port=htons(58567), sin_addr=inet_addr("127.0.0.1")}, [16]) = 0 close(3) = 0 socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP) = 3 connect(3, {sa_family=AF_INET6, sin6_port=htons(80), inet_pton(AF_INET6, "::1", &sin6_addr), sin6_flowinfo=0, sin6_scope_id=0}, 28) = 0 getsockname(3, {sa_family=AF_INET6, sin6_port=htons(42803), inet_pton(AF_INET6, "::1", &sin6_addr), sin6_flowinfo=0, sin6_scope_id=0}, [28]) = 0 close(3) = 0 socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP) = 3 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0 bind(3, {sa_family=AF_INET6, sin6_port=htons(80), inet_pton(AF_INET6, "::1", &sin6_addr), sin6_flowinfo=0, sin6_scope_id=0}, 28) = -1 EACCES (Permission denied) close(3) = 0 socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 3 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0 bind(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EACCES (Permission denied) close(3) = 0 write(2, "nc: ", 4nc: ) = 4 write(2, "Permission denied\n", 18Permission denied ) = 18 exit_group(1) = ?To most people that see this flying up their terminal this initially looks like gobbledygook, but it's really quite easy to parse when a few things are explained.
For each line:
- the first entry on the left is the system call being performed
- the bit in the parentheses are the arguments to the system call
- the right side of the equals sign is the return value of the system call
open("/etc/gai.conf", O_RDONLY) = 3Therefore for this particular line, the system call is
open
, the arguments are the string/etc/gai.conf
and the constantO_RDONLY
, and the return value was3
.How to make sense of this?
Some of these system calls can be guessed or enough can be inferred from context. Most readers will figure out that the above line is the attempt to open a file with read-only permission.
In the case of the above failure, we can see that before the program calls exit_group, there is a couple of calls to bind that return "Permission denied":
bind(3, {sa_family=AF_INET6, sin6_port=htons(80), inet_pton(AF_INET6, "::1", &sin6_addr), sin6_flowinfo=0, sin6_scope_id=0}, 28) = -1 EACCES (Permission denied) close(3) = 0 socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 3 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0 bind(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EACCES (Permission denied) close(3) = 0 write(2, "nc: ", 4nc: ) = 4 write(2, "Permission denied\n", 18Permission denied ) = 18 exit_group(1) = ?We might therefore want to understand what "bind" is and why it might be failing.
You need to get a copy of the system call's documentation. On ubuntu and related distributions of linux, the documentation is in the
manpages-dev
package, and can be invoked by eg man 2 bind
(I just usedstrace
to determine which fileman 2 bind
opened and then did adpkg -S
to determine from which package it came!). You can also look up online if you have access, but if you can auto-install via a package manager you're more likely to get docs that match your installation.Right there in my
man 2 bind
page it says:ERRORS EACCES The address is protected, and the user is not the superuser.So there is the answer – we're trying to bind to a port that can only be bound to if you are the super-user.
My Library Is Not Loading!
Imagine a situation where developer A's perl script is working fine, but not on developer B's identical one is not (again, the output has been edited).
In this case, we strace the output on developer B's computer to see how it's working:$ strace perl a.pl execve("/usr/bin/perl", ["perl", "a.pl"], [/* 57 vars */]) = 0 brk(0) = 0xa8f000 [...]fcntl(3, F_SETFD, FD_CLOEXEC) = 0 fstat(3, {st_mode=S_IFREG|0664, st_size=14, ...}) = 0 rt_sigaction(SIGCHLD, NULL, {SIG_DFL, [], 0}, 8) = 0 brk(0xad1000) = 0xad1000 read(3, "use blahlib;\n\n", 4096) = 14 stat("/space/myperllib/blahlib.pmc", 0x7fffbaf7f3d0) = -1 ENOENT (No such file or directory) stat("/space/myperllib/blahlib.pm", {st_mode=S_IFREG|0644, st_size=7692, ...}) = 0 open("/space/myperllib/blahlib.pm", O_RDONLY) = 4 ioctl(4, SNDCTL_TMR_TIMEBASE or TCGETS, 0x7fffbaf7f090) = -1 ENOTTY (Inappropriate ioctl for device) [...]mmap(0x7f4c45ea8000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 5, 0x4000) = 0x7f4c45ea8000 close(5) = 0 mprotect(0x7f4c45ea8000, 4096, PROT_READ) = 0 brk(0xb55000) = 0xb55000 read(4, "swrite($_[0], $_[1], $_[2], $_[3"..., 4096) = 3596 brk(0xb77000) = 0xb77000 read(4, "", 4096) = 0 close(4) = 0 read(3, "", 4096) = 0 close(3) = 0 exit_group(0) = ?We observe that the file is found in what looks like an unusual place.
open("/space/myperllib/blahlib.pm", O_RDONLY) = 4Inspecting the environment, we see that:
$ env | grep myperl PERL5LIB=/space/myperllibSo the solution is to set the same env variable before running:
export PERL5LIB=/space/myperllibGet to know the internals bit by bitIf you do this a lot, or idly run
strace
on various commands and peruse the output, you can learn all sorts of things about the internals of your OS. If you're like me, this is a great way to learn how things work. For example, just now I've had a look at the file/etc/gai.conf
, which I'd never come across before writing this.Once your interest has been piqued, I recommend getting a copy of "Advanced Programming in the Unix Environment" by Stevens & Rago, and reading it cover to cover. Not all of it will go in, but as you use
Gotchasstrace
more and more, and (hopefully) browse C code more and more understanding will grow.If you're running a program that calls other programs, it's important to run with the -f flag, which "follows" child processes and straces them. -ff creates a separate file with the pid suffixed to the name.
If you're on solaris, this program doesn't exist – you need to use truss instead.
Many production environments will not have this program installed for security reasons. strace doesn't have many library dependencies (on my machine it has the same dependencies as 'echo'), so if you have permission, (or are feeling sneaky) you can just copy the executable up.
Other useful tidbitsYou can attach to running processes (can be handy if your program appears to hang or the issue is not readily reproducible) with
-p
.If you're looking at performance issues, then the time flags (
vasudevram February 11, 2018 at 5:29 pm-t
,-tt
,-ttt
, and-T
) can help significantly.Interesting post. One point: The errors start earlier than what you said.There is a call to access() near the top of the strace output, which fails:
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
vasudevram February 11, 2018 at 5:29 pm
I guess that could trigger the other errors.
Benji Wiebe February 11, 2018 at 7:30 pm
A failed access or open system call is not usually an error in the context of launching a program. Generally it is merely checking if a config file exists.
vasudevram February 11, 2018 at 8:24 pm
>A failed access or open system call is not usually an error in the context of launching a program.
Yes, good point, that could be so, if the programmer meant to ignore the error, and if it was not an issue to do so.
>Generally it is merely checking if a config file exists.
The file name being access'ed is "/etc/ld.so.nohwcap" – not sure if it is a config file or not.
Jul 08, 2020 | www.tldp.org
Appendix E. Exit Codes With Special Meanings Table E-1. Reserved Exit Codes
Exit Code Number Meaning Example Comments 1 Catchall for general errors let "var1 = 1/0" Miscellaneous errors, such as "divide by zero" and other impermissible operations 2 Misuse of shell builtins (according to Bash documentation) empty_function() {} Missing keyword or command, or permission problem (and diff return code on a failed binary file comparison ). 126 Command invoked cannot execute /dev/null Permission problem or command is not an executable 127 "command not found" illegal_command Possible problem with $PATH or a typo 128 Invalid argument to exit exit 3.14159 exit takes only integer args in the range 0 - 255 (see first footnote) 128+n Fatal error signal "n" kill -9 $PPID of script $? returns 137 (128 + 9) 130 Script terminated by Control-C Ctl-C Control-C is fatal error signal 2 , (130 = 128 + 2, see above) 255* Exit status out of range exit -1 exit takes only integer args in the range 0 - 255 According to the above table, exit codes 1 - 2, 126 - 165, and 255 [1] have special meanings, and should therefore be avoided for user-specified exit parameters. Ending a script with exit 127 would certainly cause confusion when troubleshooting (is the error code a "command not found" or a user-defined one?). However, many scripts use an exit 1 as a general bailout-upon-error. Since exit code 1 signifies so many possible errors, it is not particularly useful in debugging.
There has been an attempt to systematize exit status numbers (see /usr/include/sysexits.h ), but this is intended for C and C++ programmers. A similar standard for scripting might be appropriate. The author of this document proposes restricting user-defined exit codes to the range 64 - 113 (in addition to 0 , for success), to conform with the C/C++ standard. This would allot 50 valid codes, and make troubleshooting scripts more straightforward. [2] All user-defined exit codes in the accompanying examples to this document conform to this standard, except where overriding circumstances exist, as in Example 9-2 .
Notes
Issuing a $? from the command-line after a shell script exits gives results consistent with the table above only from the Bash or sh prompt. Running the C-shell or tcsh may give different values in some cases.
[1] Out of range exit values can result in unexpected exit codes. An exit value greater than 255 returns an exit code modulo 256 . For example, exit 3809 gives an exit code of 225 (3809 % 256 = 225). [2] An update of /usr/include/sysexits.h allocates previously unused exit codes from 64 - 78 . It may be anticipated that the range of unallotted exit codes will be further restricted in the future. The author of this document will not do fixups on the scripting examples to conform to the changing standard. This should not cause any problems, since there is no overlap or conflict in usage of exit codes between compiled C/C++ binaries and shell scripts.
Jul 08, 2020 | zwischenzugs.com
Not everyone knows that every time you run a shell command in bash, an 'exit code' is returned to bash.
Generally, if a command 'succeeds' you get an error code of
0
. If it doesn't succeed, you get a non-zero code.
1
is a 'general error', and others can give you more information (e.g. which signal killed it, for example). 255 is upper limit and is "internal error"grep joeuser /etc/passwd # in case of success returns 0, otherwise 1or
grep not_there /dev/null echo $?
$?
is a special bash variable that's set to the exit code of each command after it runs.Grep uses exit codes to indicate whether it matched or not. I have to look up every time which way round it goes: does finding a match or not return
0
?
Sep 11, 2009 | www.linuxjournal.com
Bash functions, unlike functions in most programming languages do not allow you to return a value to the caller. When a bash function ends its return value is its status: zero for success, non-zero for failure. To return values, you can set a global variable with the result, or use command substitution, or you can pass in the name of a variable to use as the result variable. The examples below describe these different mechanisms.
Although bash has a return statement, the only thing you can specify with it is the function's status, which is a numeric value like the value specified in an exit statement. The status value is stored in the $? variable. If a function does not contain a return statement, its status is set based on the status of the last statement executed in the function. To actually return arbitrary values to the caller you must use other mechanisms.
The simplest way to return a value from a bash function is to just set a global variable to the result. Since all variables in bash are global by default this is easy:
function myfunc() { myresult='some value' } myfunc echo $myresultThe code above sets the global variable myresult to the function result. Reasonably simple, but as we all know, using global variables, particularly in large programs, can lead to difficult to find bugs.
A better approach is to use local variables in your functions. The problem then becomes how do you get the result to the caller. One mechanism is to use command substitution:
function myfunc() { local myresult='some value' echo "$myresult" } result=$(myfunc) # or result=`myfunc` echo $resultHere the result is output to the stdout and the caller uses command substitution to capture the value in a variable. The variable can then be used as needed.
The other way to return a value is to write your function so that it accepts a variable name as part of its command line and then set that variable to the result of the function:
function myfunc() { local __resultvar=$1 local myresult='some value' eval $__resultvar="'$myresult'" } myfunc result echo $resultSince we have the name of the variable to set stored in a variable, we can't set the variable directly, we have to use eval to actually do the setting. The eval statement basically tells bash to interpret the line twice, the first interpretation above results in the string result='some value' which is then interpreted once more and ends up setting the caller's variable.
When you store the name of the variable passed on the command line, make sure you store it in a local variable with a name that won't be (unlikely to be) used by the caller (which is why I used __resultvar rather than just resultvar ). If you don't, and the caller happens to choose the same name for their result variable as you use for storing the name, the result variable will not get set. For example, the following does not work:
function myfunc() { local result=$1 local myresult='some value' eval $result="'$myresult'" } myfunc result echo $resultThe reason it doesn't work is because when eval does the second interpretation and evaluates result='some value' , result is now a local variable in the function, and so it gets set rather than setting the caller's result variable.
For more flexibility, you may want to write your functions so that they combine both result variables and command substitution:
function myfunc() { local __resultvar=$1 local myresult='some value' if [[ "$__resultvar" ]]; then eval $__resultvar="'$myresult'" else echo "$myresult" fi } myfunc result echo $result result2=$(myfunc) echo $result2Here, if no variable name is passed to the function, the value is output to the standard output.
Mitch Frazier is an embedded systems programmer at Emerson Electric Co. Mitch has been a contributor to and a friend of Linux Journal since the early 2000s.
David Krmpotic • 6 years ago • edited ,lxw David Krmpotic • 6 years ago ,This is the best way: http://stackoverflow.com/a/... return by reference:
function pass_back_a_string() {
eval "$1='foo bar rab oof'"
}return_var=''
pass_back_a_string return_var
echo $return_varphil • 6 years ago ,I agree. After reading this passage, the same idea with yours occurred to me.
lxw • 6 years ago ,Since this page is a top hit on google:
The only real issue I see with returning via echo is that forking the process means no longer allowing it access to set 'global' variables. They are still global in the sense that you can retrieve them and set them within the new forked process, but as soon as that process is done, you will not see any of those changes.
e.g.
#!/bin/bashmyGlobal="very global"
call1() {
myGlobal="not so global"
echo "${myGlobal}"
}tmp=$(call1) # keep in mind '$()' starts a new process
echo "${tmp}" # prints "not so global"
echo "${myGlobal}" # prints "very global"code_monk • 6 years ago • edited ,Hello everyone,
In the 3rd method, I don't think the local variable __resultvar is necessary to use. Any problems with the following code?
function myfunc()
{
local myresult='some value'
eval "$1"="'$myresult'"
}myfunc result
echo $resultEmil Vikström code_monk • 5 years ago ,i would caution against returning integers with "return $int". My code was working fine until it came across a -2 (negative two), and treated it as if it were 254, which tells me that bash functions return 8-bit unsigned ints that are not protected from overflow
A function behaves as any other Bash command, and indeed POSIX processes. That is, they can write to stdout, read from stdin and have a return code. The return code is, as you have already noticed, a value between 0 and 255. By convention 0 means success while any other return code means failure.
This is also why Bash "if" statements treat 0 as success and non+zero as failure (most other programming languages do the opposite).
Jul 07, 2020 | zwischenzugs.com
The Missing Readline Primer zwischenzugs Uncategorized April 23, 2019 7 Minutes
Readline is one of those technologies that is so commonly used many users don't realise it's there.
I went looking for a good primer on it so I could understand it better, but failed to find one. This is an attempt to write a primer that may help users get to grips with it, based on what I've managed to glean as I've tried to research and experiment with it over the years.
Bash Without ReadlineFirst you're going to see what bash looks like without readline.
In your 'normal' bash shell, hit the
TAB
key twice. You should see something like this:Display all 2335 possibilities? (y or n)That's because bash normally has an 'autocomplete' function that allows you to see what commands are available to you if you tap tab twice.
Hit
n
to get out of that autocomplete.Another useful function that's commonly used is that if you hit the up arrow key a few times, then the previously-run commands should be brought back to the command line.
Now type:
$ bash --noeditingThe
--noediting
flag starts up bash without the readline library enabled.If you hit
TAB
twice now you will see something different: the shell no longer 'sees' your tab and just sends a tab direct to the screen, moving your cursor along. Autocomplete has gone.Autocomplete is just one of the things that the readline library gives you in the terminal. You might want to try hitting the up or down arrows as you did above to see that that no longer works as well.
Hit return to get a fresh command line, and exit your non-readline-enabled bash shell:
$ exitOther ShortcutsThere are a great many shortcuts like autocomplete available to you if readline is enabled. I'll quickly outline four of the most commonly-used of these before explaining how you can find out more.
$ echo 'some command'There should not be many surprises there. Now if you hit the 'up' arrow, you will see you can get the last command back on your line. If you like, you can re-run the command, but there are other things you can do with readline before you hit return.
If you hold down the
ctrl
key and then hita
at the same time your cursor will return to the start of the line. Another way of representing this 'multi-key' way of inputting is to write it like this:\C-a
. This is one conventional way to represent this kind of input. The\C
represents the control key, and the-a
represents that thea
key is depressed at the same time.Now if you hit
\C-e
(ctrl
ande
) then your cursor has moved to the end of the line. I use these two dozens of times a day.Another frequently useful one is
\C-l
, which clears the screen, but leaves your command line intact.The last one I'll show you allows you to search your history to find matching commands while you type. Hit
\C-r
, and then typeec
. You should see theecho
command you just ran like this:(reverse-i-search)`ec': echo echoThen do it again, but keep hitting
\C-r
over and over. You should see all the commands that have `ec` in them that you've input before (if you've only got oneecho
command in your history then you will only see one). As you see them you are placed at that point in your history and you can move up and down from there or just hit return to re-run if you want.There are many more shortcuts that you can use that readline gives you. Next I'll show you how to view these. Using `bind` to Show Readline Shortcuts
If you type:
$ bind -pYou will see a list of bindings that readline is capable of. There's a lot of them!
Have a read through if you're interested, but don't worry about understanding them all yet.
If you type:
$ bind -p | grep C-ayou'll pick out the 'beginning-of-line' binding you used before, and see the
\C-a
notation I showed you before.As an exercise at this point, you might want to look for the
\C-e
and\C-r
bindings we used previously.If you want to look through the entirety of the
bind -p
output, then you will want to know that\M
refers to theMeta
key (which you might also know as theAlt
key), and\e
refers to theEsc
key on your keyboard. The 'escape' key bindings are different in that you don't hit it and another key at the same time, rather you hit it, and then hit another key afterwards. So, for example, typing theEsc
key, and then the?
key also tries to auto-complete the command you are typing. This is documented as:"\e?": possible-completionsin the
Readline and Terminal Optionsbind -p
output.If you've looked over the possibilities that readline offers you, you might have seen the
\C-r
binding we looked at earlier:"\C-r": reverse-search-historyYou might also have seen that there is another binding that allows you to search forward through your history too:
"\C-s": forward-search-historyWhat often happens to me is that I hit
\C-r
over and over again, and then go too fast through the history and fly past the command I was looking for. In these cases I might try to hit\C-s
to search forward and get to the one I missed.Watch out though! Hitting
\C-s
to search forward through the history might well not work for you.Why is this, if the binding is there and readline is switched on?
It's because something picked up the
\C-s
before it got to the readline library: the terminal settings.The terminal program you are running in may have standard settings that do other things on hitting some of these shortcuts before readline gets to see it.
If you type:
$ stty -eyou should get output similar to this:
speed 9600 baud; 47 rows; 202 columns; lflags: icanon isig iexten echo echoe -echok echoke -echonl echoctl -echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo -extproc iflags: -istrip icrnl -inlcr -igncr ixon -ixoff ixany imaxbel -iutf8 -ignbrk brkint -inpck -ignpar -parmrk oflags: opost onlcr -oxtabs -onocr -onlret cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow -dtrflow -mdmbuf discard dsusp eof eol eol2 erase intr kill lnext ^O ^Y ^D <undef> <undef> ^? ^C ^U ^V min quit reprint start status stop susp time werase 1 ^\ ^R ^Q ^T ^S ^Z 0 ^WYou can see on the last four lines (
discard dsusp [...]
) there is a table of key bindings that your terminal will pick up before readline sees them. The^
character (known as the 'caret') here represents thectrl
key that we previously represented with a\C
.If you think this is confusing I won't disagree. Unfortunately in the history of Unix and Linux documenters did not stick to one way of describing these key combinations.
If you encounter a problem where the terminal options seem to catch a shortcut key binding before it gets to readline, then you can use the
stty
program to unset that binding. In this case, we want to unset the 'stop' binding.If you are in the same situation, type:
$ stty stop undefNow, if you re-run
stty -e
, the last two lines might look like this:[...] min quit reprint start status stop susp time werase 1 ^\ ^R ^Q ^T <undef> ^Z 0 ^Wwhere the
stop
entry now has<undef>
underneath it.Strangely, for me
C-r
is also bound to 'reprint' above (^R
).But (on my terminals at least) that gets to readline without issue as I search up the history. Why this is the case I haven't been able to figure out. I suspect that reprint is ignored by modern terminals that don't need to 'reprint' the current line.
While we are looking at this table:
discard dsusp eof eol eol2 erase intr kill lnext ^O ^Y ^D <undef> <undef> ^? ^C ^U ^V min quit reprint start status stop susp time werase 1 ^\ ^R ^Q ^T <undef> ^Z 0 ^Wit's worth noting a few other key bindings that are used regularly.
First, one you may well already be familiar with is
\C-c
, which interrupts a program, terminating it:$ sleep 99 [[Hit \C-c]] ^C $Similarly,
\C-z
suspends a program, allowing you to 'foreground' it again and continue with thefg
builtin.$ sleep 10 [[ Hit \C-z]] ^Z [1]+ Stopped sleep 10 $ fg sleep 10
\C-d
sends an 'end of file' character. It's often used to indicate to a program that input is over. If you type it on a bash shell, the bash shell you are in will close.Finally,
\C-w
deletes the word before the cursorThese are the most commonly-used shortcuts that are picked up by the terminal before they get to the readline library.
Daz April 29, 2019 at 11:15 pm
Hi Ian,
What OS are you running because stty -e gives the following on Centos 6.x and Ubuntu 18.04.2
Leon May 14, 2019 at 5:12 amstty -e
stty: invalid argument '-e'
Try 'stty –help' for more information. Replyyachris May 16, 2019 at 4:40 pm`stty -a` works for me (Ubuntu 14)
AriSweedler May 17, 2019 at 4:50 amYou might want to check out the 'rlwrap' program. It allows you to have readline behavior on programs that don't natively support readline, but which have a 'type in a command' type interface. For instance, we use Oracle here (alas :-) ) and the 'sqlplus' program, that lets you type SQL commands to an Oracle instance does not have anything like readline built into it, so you can't go back to edit previous commands. But running 'rlwrap sqlplus' gives me readline behavior in sqlplus! It's fantastic to have.
I was told to use this in a class, and I didn't understand what I did. One rabbit hole later, I was shocked and amazed at how advanced the readline library is. One thing I'd like to add is that you can write a '~/.inputrc' file and have those readline commands sourced at startup!
I do not know exactly when or how the inputrc is read.
Most of what I learned about inputrc stuff is from https://www.topbug.net/blog/2017/07/31/inputrc-for-humans/ .
Here is my inputrc, if anyone wants: https://github.com/AriSweedler/dotfiles/blob/master/.inputrc .
Jul 02, 2020 | www.redhat.com
These tips and tricks will make your Linux command line experience easier and more efficient.More Linux resources
- Download Now: Linux Commands Cheat Sheet
- Advanced Linux Commands Cheat Sheet for Developers
- Download Red Hat Enterprise Linux Server 8 Trial
- Linux System Administration Skills Assessment
This blog post is the second of two covering some practical tips and tricks to get the most out of the Bash shell. In part one , I covered history, last argument, working with files and directories, reading files, and Bash functions. In this segment, I cover shell variables, find, file descriptors, and remote operations.
Use shell variablesThe Bash variables are set by the shell when invoked. Why would I use
hostname
when I can use $HOSTNAME, or why would I usewhoami
when I can use $USER? Bash variables are very fast and do not require external applications.These are a few frequently-used variables:
$PATH $HOME $USER $HOSTNAME $PS1 .. $PS4Use the
echo
command to expand variables. For example, the $PATH shell variable can be expanded by running:$> echo $PATH[ Download now: A sysadmin's guide to Bash scripting . ]
Use the find commandThe
find
command is probably one of the most used tools within the Linux operating system. It is extremely useful in interactive shells. It is also used in scripts. Withfind
I can list files older or newer than a specific date, delete them based on that date, change permissions of files or directories, and so on.Let's get more familiar with this command.
To list files older than 30 days, I simply run:
$> find /tmp -type f -mtime +30To delete files older than 30 days, run:
$> find /tmp -type f -mtime +30 -exec rm -rf {} \;or
$> find /tmp -type f -mtime +30 -exec rm -rf {} +While the above commands will delete files older than 30 days, as written, they fork the
rm
command each time they find a file. This search can be written more efficiently by usingxargs
:$> find /tmp -name '*.tmp' -exec printf '%s\0' {} \; | xargs -0 rmI can use
find
to listsha256sum
files only by running:$> find . -type f -exec sha256sum {} +And now to search for and get rid of duplicate .jpg files:
$> find . -type f -name '*.jpg' -exec sha256sum {} + | sort -uk1,1Reference file descriptorsIn the Bash shell, file descriptors (FDs) are important in managing the input and output of commands. Many people have issues understanding file descriptors correctly. Each process has three default file descriptors, namely:
Code Meaning Location Description 0 Standard input /dev/stdin Keyboard, file, or some stream 1 Standard output /dev/stdout Monitor, terminal, display 2 Standard error /dev/stderr Non-zero exit codes are usually >FD2, display Now that you know what the default FDs do, let's see them in action. I start by creating a directory named
foo
, which containsfile1
.$> ls foo/ bar/ ls: cannot access 'bar/': No such file or directory foo/: file1The output No such file or directory goes to Standard Error (stderr) and is also displayed on the screen. I will run the same command, but this time use
2>
to omit stderr:$> ls foo/ bar/ 2>/dev/null foo/: file1It is possible to send the output of
foo
to Standard Output (stdout) and to a file simultaneously, and ignore stderr. For example:$> { ls foo bar | tee -a ls_out_file ;} 2>/dev/null foo: file1Then:
$> cat ls_out_file foo: file1The following command sends stdout to a file and stderr to
/dev/null
so that the error won't display on the screen:$> ls foo/ bar/ >to_stdout 2>/dev/null $> cat to_stdout foo/: file1The following command sends stdout and stderr to the same file:
$> ls foo/ bar/ >mixed_output 2>&1 $> cat mixed_output ls: cannot access 'bar/': No such file or directory foo/: file1This is what happened in the last example, where stdout and stderr were redirected to the same file:
ls foo/ bar/ >mixed_output 2>&1 | | | Redirect stderr to where stdout is sent | stdout is sent to mixed_outputAnother short trick (> Bash 4.4) to send both stdout and stderr to the same file uses the ampersand sign. For example:
$> ls foo/ bar/ &>mixed_outputHere is a more complex redirection:
exec 3>&1 >write_to_file; echo "Hello World"; exec 1>&3 3>&-This is what occurs:
- exec 3>&1 Copy stdout to file descriptor 3
- > write_to_file Make FD 1 to write to the file
- echo "Hello World" Go to file because FD 1 now points to the file
- exec 1>&3 Copy FD 3 back to 1 (swap)
- Three>&- Close file descriptor three (we don't need it anymore)
Often it is handy to group commands, and then send the Standard Output to a single file. For example:
$> { ls non_existing_dir; non_existing_command; echo "Hello world"; } 2> to_stderr Hello worldAs you can see, only "Hello world" is printed on the screen, but the output of the failed commands is written to the to_stderr file.
Execute remote operationsI use Telnet, netcat, Nmap, and other tools to test whether a remote service is up and whether I can connect to it. These tools are handy, but they aren't installed by default on all systems.
Fortunately, there is a simple way to test a connection without using external tools. To see if a remote server is running a web, database, SSH, or any other service, run:
$> timeout 3 bash -c '</dev/tcp/remote_server/remote_port' || echo "Failed to connect"For example, to see if serverA is running the MariaDB service:
$> timeout 3 bash -c '</dev/tcp/serverA/3306' || echo "Failed to connect"If the connection fails, the Failed to connect message is displayed on your screen.
Assume serverA is behind a firewall/NAT. I want to see if the firewall is configured to allow a database connection to serverA , but I haven't installed a database server yet. To emulate a database port (or any other port), I can use the following:
[serverA ~]# nc -l 3306On clientA , run:
[clientA ~]# timeout 3 bash -c '</dev/tcp/serverA/3306' || echo "Failed"While I am discussing remote connections, what about running commands on a remote server over SSH? I can use the following command:
$> ssh remotehost <<EOF # Press the Enter key here > ls /etc EOFThis command runs
ls /etc
on the remote host.I can also execute a local script on the remote host without having to copy the script over to the remote server. One way is to enter:
$> ssh remote_host 'bash -s' < local_scriptAnother example is to pass environment variables locally to the remote server and terminate the session after execution.
$> exec ssh remote_host ARG1=FOO ARG2=BAR 'bash -s' <<'EOF' > printf %s\\n "$ARG1" "$ARG2" > EOF Password: FOO BAR Connection to remote_host closed.There are many other complex actions I can perform on the remote host.
Wrap upThere is certainly more to Bash than I was able to cover in this two-part blog post. I am sharing what I know and what I deal with daily. The idea is to familiarize you with a few techniques that could make your work less error-prone and more fun.
[ Want to test your sysadmin skills? Take a skills assessment today. ] Valentin Bajrami
Valentin is a system engineer with more than six years of experience in networking, storage, high-performing clusters, and automation. He is involved in different open source projects like bash, Fedora, Ceph, FreeBSD and is a member of Red Hat Accelerators. More about me
Jul 07, 2020 | www.redhat.com
Reference file descriptors
In the Bash shell, file descriptors (FDs) are important in managing the input and output of commands. Many people have issues understanding file descriptors correctly. Each process has three default file descriptors, namely:
Code Meaning Location Description 0 Standard input /dev/stdin Keyboard, file, or some stream 1 Standard output /dev/stdout Monitor, terminal, display 2 Standard error /dev/stderr Non-zero exit codes are usually >FD2, display Now that you know what the default FDs do, let's see them in action. I start by creating a directory named
foo
, which containsfile1
.$> ls foo/ bar/ ls: cannot access 'bar/': No such file or directory foo/: file1The output No such file or directory goes to Standard Error (stderr) and is also displayed on the screen. I will run the same command, but this time use
2>
to omit stderr:$> ls foo/ bar/ 2>/dev/null foo/: file1It is possible to send the output of
foo
to Standard Output (stdout) and to a file simultaneously, and ignore stderr. For example:$> { ls foo bar | tee -a ls_out_file ;} 2>/dev/null foo: file1Then:
$> cat ls_out_file foo: file1The following command sends stdout to a file and stderr to
/dev/null
so that the error won't display on the screen:$> ls foo/ bar/ >to_stdout 2>/dev/null $> cat to_stdout foo/: file1The following command sends stdout and stderr to the same file:
$> ls foo/ bar/ >mixed_output 2>&1 $> cat mixed_output ls: cannot access 'bar/': No such file or directory foo/: file1This is what happened in the last example, where stdout and stderr were redirected to the same file:
ls foo/ bar/ >mixed_output 2>&1 | | | Redirect stderr to where stdout is sent | stdout is sent to mixed_outputAnother short trick (> Bash 4.4) to send both stdout and stderr to the same file uses the ampersand sign. For example:
$> ls foo/ bar/ &>mixed_outputHere is a more complex redirection:
exec 3>&1 >write_to_file; echo "Hello World"; exec 1>&3 3>&-This is what occurs:
- exec 3>&1 Copy stdout to file descriptor 3
- > write_to_file Make FD 1 to write to the file
- echo "Hello World" Go to file because FD 1 now points to the file
- exec 1>&3 Copy FD 3 back to 1 (swap)
- Three>&- Close file descriptor three (we don't need it anymore)
Often it is handy to group commands, and then send the Standard Output to a single file. For example:
$> { ls non_existing_dir; non_existing_command; echo "Hello world"; } 2> to_stderr Hello worldAs you can see, only "Hello world" is printed on the screen, but the output of the failed commands is written to the to_stderr file.
Jun 06, 2020 | www.cyberciti.biz
... ... ...
Redirecting the standard error stream to a fileThe following will redirect program error message to a file called error.log:
$ program-name 2> error.log
$ command1 2> error.log
For example, use the grep command for recursive search in the $HOME directory and redirect all errors (stderr) to a file name grep-errors.txt as follows:
$ grep -R 'MASTER' $HOME 2> /tmp/grep-errors.txt
$ cat /tmp/grep-errors.txt
Sample outputs:grep: /home/vivek/.config/google-chrome/SingletonSocket: No such device or address grep: /home/vivek/.config/google-chrome/SingletonCookie: No such file or directory grep: /home/vivek/.config/google-chrome/SingletonLock: No such file or directory grep: /home/vivek/.byobu/.ssh-agent: No such device or addressRedirecting the standard error (stderr) and stdout to fileUse the following syntax:
Redirecting stderr to stdout to a file or another command
$ command-name &>file
We can als use the following syntax:
$ command > file-name 2>&1
We can write both stderr and stdout to two different files too. Let us try out our previous grep command example:
$ grep -R 'MASTER' $HOME 2> /tmp/grep-errors.txt 1> /tmp/grep-outputs.txt
$ cat /tmp/grep-outputs.txtHere is another useful example where both stderr and stdout sent to the more command instead of a file:
Redirect stderr to stdout
# find /usr/home -name .profile 2>&1 | more
Use the command as follows:
How to redirect stderr to stdout in Bash script
$ command-name 2>&1
$ command-name > file.txt 2>&1
## bash only ##
$ command2 &> filename
$ sudo find / -type f -iname ".env" &> /tmp/search.txt
Redirection takes from left to right. Hence, order matters. For example:
command-name 2>&1 > file.txt ## wrong ##
command-name > file.txt 2>&1 ## correct ##A sample shell script used to update VM when created in the AWS/Linode server:
#!/usr/bin/env bash # Author - nixCraft under GPL v2.x+ # Debian/Ubuntu Linux script for EC2 automation on first boot # ------------------------------------------------------------ # My log file - Save stdout to $LOGFILE LOGFILE="/root/logs.txt" # My error file - Save stderr to $ERRFILE ERRFILE="/root/errors.txt" # Start it printf "Starting update process ... \n" 1>"${LOGFILE}" # All errors should go to error file apt-get -y update 2>"${ERRFILE}" apt-get -y upgrade 2>>"${ERRFILE}" printf "Rebooting cloudserver ... \n" 1>>"${LOGFILE}" shutdown -r now 2>>"${ERRFILE}"Our last example uses the exec command and FDs along with trap and custom bash functions:
#!/bin/bash # Send both stdout/stderr to a /root/aws-ec2-debian.log file # Works with Ubuntu Linux too. # Use exec for FD and trap it using the trap # See bash man page for more info # Author: nixCraft under GPL v2.x+ # --------------------------------------------- exec 3>&1 4>&2 trap 'exec 2>&4 1>&3' 0 1 2 3 exec 1>/root/aws-ec2-debian.log 2>&1 # log message log(){ local m="$@" echo "" echo "*** ${m} ***" echo "" } log "$(date) @ $(hostname)" ## Install stuff ## log "Updating up all packages" export DEBIAN_FRONTEND=noninteractive apt-get -y clean apt-get -y update apt-get -y upgrade apt-get -y --purge autoremove ## Update sshd config ## log "Configuring sshd_config" sed -i'.BAK' -e 's/PermitRootLogin yes/PermitRootLogin no/g' -e 's/#PasswordAuthentication yes/PasswordAuthentication no/g' /etc/ssh/sshd_config ## Hide process from other users ## log "Update /proc/fstab to hide process from each other" echo 'proc /proc proc defaults,nosuid,nodev,noexec,relatime,hidepid=2 0 0' >> /etc/fstab ## Install LXD and stuff ## log "Installing LXD/wireguard/vnstat and other packages on this box" apt-get -y install lxd wireguard vnstat expect mariadb-server log "Configuring mysql with mysql_secure_installation" SECURE_MYSQL_EXEC=$(expect -c " set timeout 10 spawn mysql_secure_installation expect \"Enter current password for root (enter for none):\" send \"$MYSQL\r\" expect \"Change the root password?\" send \"n\r\" expect \"Remove anonymous users?\" send \"y\r\" expect \"Disallow root login remotely?\" send \"y\r\" expect \"Remove test database and access to it?\" send \"y\r\" expect \"Reload privilege tables now?\" send \"y\r\" expect eof ") # log to file # echo " $SECURE_MYSQL_EXEC " # We no longer need expect apt-get -y remove expect # Reboot the EC2 VM log "END: Rebooting requested @ $(date) by $(hostname)" rebootWANT BOTH STDERR AND STDOUT TO THE TERMINAL AND A LOG FILE TOO?Try the tee command as follows:
command1 2>&1 | tee filename
Here is how to use it insider shell script too:Conclusion
#!/usr/bin/env bash { command1 command2 | do_something } 2>&1 | tee /tmp/outputs.logIn this quick tutorial, you learned about three file descriptors, stdin, stdout, and stderr. We can use these Bash descriptors to redirect stdout/stderr to a file or vice versa. See bash man page here :
Operator Description Examples command>filename Redirect stdout to file "filename." date > output.txt command>>filename Redirect and append stdout to file "filename." ls -l >> dirs.txt command 2>filename Redirect stderr to file "filename." du -ch /snaps/ 2> space.txt command 2>>filename Redirect and append stderr to file "filename." awk '{ print $4}' input.txt 2>> data.txt command &>filename
command >filename 2>&1Redirect both stdout and stderr to file "filename." grep -R foo /etc/ &>out.txt command &>>filename
command >>filename 2>&1Redirect both stdout and stderr append to file "filename." whois domain &>>log.txt Vivek Gite is the creator of nixCraft and a seasoned sysadmin, DevOps engineer, and a trainer for the Linux operating system/Unix shell scripting. Get the latest tutorials on SysAdmin, Linux/Unix and open source topics via RSS/XML feed or weekly email newsletter . RELATED TUTORIALS
- Matt Kukowski says: January 29, 2014 at 6:33 pm
In pre-bash4 days you HAD to do it this way:
cat file > file.txt 2>&1
now with bash 4 and greater versions you can still do it the old way but
cat file &> file.txt
The above is bash4+ some OLD distros may use prebash4 but I think they are alllong gone by now. Just something to keep in mind.
- iamfrankenstein says: June 12, 2014 at 8:35 pm
I really love: " command2>&1 | tee logfile.txt "
because tee log's everything and prints to stdout . So you stil get to see everything! You can even combine sudo to downgrade to a log user account and add date's subject and store it in a default log directory :)
Jul 05, 2020 | leanpub.com
skeptic 5.0 out of 5 stars Reviewed in the United States on July 2, 2020A short (160 pages) book that covers some difficult aspects of bash needed to customize bash env.
Whether we want it or not, bash is the shell you face in Linux, and unfortunately, it is often misunderstood and misused. Issues related to creating your bash environment are not well addressed in existing books. This book fills the gap.
Few authors understand that bash is a complex, non-orthogonal language operating in a complex Linux environment. To make things worse, bash is an evolution of Unix shell and is a rather old language with warts and all. Using it properly as a programming language requires a serious study, not just an introduction to the basic concepts. Even issues related to customization of dotfiles are far from trivial, and you need to know quite a bit to do it properly.
At the same time, proper customization of bash environment does increase your productivity (or at least lessens the frustration of using Linux on the command line ;-)
The author covered the most important concepts related to this task, such as bash history, functions, variables, environment inheritance, etc. It is really sad to watch like the majorly of Linux users do not use these opportunities and forever remain on the "level zero" using default dotfiles with bare minimum customization.
This book contains some valuable tips even for a seasoned sysadmin (for example, the use of !& in pipes), and as such, is worth at least double of suggested price. It allows you intelligently customize your bash environment after reading just 160 pages and doing the suggested exercises.
Contents:
- Foreword
- Learn Bash the Hard Way
- Introduction
- Structure
- Part I - Core Bash
- What is Bash?
- Unpicking the Shell: Globbing and Quoting
- Variables in Bash
- Functions in Bash
- Pipes and redirects
- Scripts and Startups
- Part II - Scripting Bash
- Command Substitution and Evaluation
- Exit Codes
- Tests
- Loops
- The
set
Builtin- Process Substitution
- Subshells
- Internal Field Separator
- Part III - Bash Features
- Readline
- Terminal Codes and Non-Standard Characters
- The Prompt
- Here Documents
- History
- Bash in Practice
- Part IV - Advanced Bash
- Job Control
- Traps and Signals
- Advanced Variables
- String Manipulation
- Debugging Bash Scripts
- Autocomplete
- Example Bash Script
- Finished!
Jul 04, 2020 | zwischenzugs.com
Here are some tips that might help you be more productive with bash.
1) ^x^y^A gem I use all the time.
Ever typed anything like this?
$ grp somestring somefile -bash: grp: command not foundSigh. Hit 'up', 'left' until at the 'p' and type 'e' and return.
Or do this:
$ ^rp^rep^ grep 'somestring' somefile $One subtlety you may want to note though is:
$ grp rp somefile $ ^rp^rep^ $ grep rp somefileIf you wanted
rep
to be searched for, then you'll need to dig into the man page and use a more powerful history command:$ grp rp somefile $ !!:gs/rp/rep grep rep somefile $... ... ...
Material here based on material from my book
Learn Bash the Hard Way .
Free preview available here .
3)shopt
vsset
This one bothered me for a while.
What's the difference between
set
andshopt
?
set
s we saw before , butshopt
s look very similar. Just inputtingshopt
shows a bunch of options:$ shopt cdable_vars off cdspell on checkhash off checkwinsize on cmdhist on compat31 off dotglob offI found a set of answers here . Essentially, it looks like it's a consequence of bash (and other shells) being built on sh, and adding
4) Here Docs and Here Stringsshopt
as another way to set extra shell options. But I'm still unsure if you know the answer, let me know.'Here docs' are files created inline in the shell.
The 'trick' is simple. Define a closing word, and the lines between that word and when it appears alone on a line become a file.
Type this:
$ cat > afile << SOMEENDSTRING > here is a doc > it has three lines > SOMEENDSTRING alone on a line will save the doc > SOMEENDSTRING $ cat afile here is a doc it has three lines SOMEENDSTRING alone on a line will save the docNotice that:
- the string could be included in the file if it was not 'alone' on the line
- the string
SOMEENDSTRING
is more normallyEND
, but that is just conventionLesser known is the 'here string':
$ cat > asd <<< 'This file has one line'5) String Variable ManipulationYou may have written code like this before, where you use tools like
sed
to manipulate strings:$ VAR='HEADERMy voice is my passwordFOOTER' $ PASS="$(echo $VAR | sed 's/^HEADER(.*)FOOTER/1/')" $ echo $PASSBut you may not be aware that this is possible natively in bash .
This means that you can dispense with lots of sed and awk shenanigans.
One way to rewrite the above is:
$ VAR='HEADERMy voice is my passwordFOOTER' $ PASS="${VAR#HEADER}" $ PASS="${PASS%FOOTER}" $ echo $PASS
- The
#
means 'match and remove the following pattern from the start of the string'- The
%
means 'match and remove the following pattern from the end of the stringThe second method is twice as fast as the first on my machine. And (to my surprise), it was roughly the same speed as a similar python script .
If you want to use glob patterns that are greedy (see globbing here ) then you double up:
$ VAR='HEADERMy voice is my passwordFOOTER' $ echo ${VAR##HEADER*} $ echo ${VAR%%*FOOTER}6) Variable DefaultsThese are very handy when you're knocking up scripts quickly.
If you have a variable that's not set, you can 'default' them by using this. Create a file called
default.sh
with these contents#!/bin/bash FIRST_ARG="${1:-no_first_arg}" SECOND_ARG="${2:-no_second_arg}" THIRD_ARG="${3:-no_third_arg}" echo ${FIRST_ARG} echo ${SECOND_ARG} echo ${THIRD_ARG}Now run
chmod +x default.sh
and run the script with./default.sh first second
.Observer how the third argument's default has been assigned, but not the first two.
You can also assign directly with
7) Traps${VAR: = defaultval}
(equals sign, not dash) but note that this won't work with positional variables in scripts or functions. Try changing the above script to see how it fails.RANDOMThe
trap
built-in can be used to 'catch' when a signal is sent to your script.Here's an example I use in my own
cheapci
script:function cleanup() { rm -rf "${BUILD_DIR}" rm -f "${LOCK_FILE}" # get rid of /tmp detritus, leaving anything accessed 2 days ago+ find "${BUILD_DIR_BASE}"/* -type d -atime +1 | rm -rf echo "cleanup done" } trap cleanup TERM INT QUITAny attempt to
CTRL-C
,CTRL-
or terminate the program using theTERM
signal will result in cleanup being called first.Be aware:
- Trap logic can get very tricky (eg handling signal race conditions)
- The KILL signal can't be trapped in this way
But mostly I've used this for 'cleanups' like the above, which serve their purpose.
8) Shell VariablesIt's well worth getting to know the standard shell variables available to you . Here are some of my favourites:
Don't rely on this for your cryptography stack, but you can generate random numbers eg to create temporary files in scripts:
$ echo ${RANDOM} 16313 $ # Not enough digits? $ echo ${RANDOM}${RANDOM} 113610703 $ NEWFILE=/tmp/newfile_${RANDOM} $ touch $NEWFILEREPLYNo need to give a variable name for
read
$ read my input $ echo ${REPLY}LINENO and SECONDSHandy for debugging
$ echo ${LINENO} 115 $ echo ${SECONDS}; sleep 1; echo ${SECONDS}; echo $LINENO 174380 174381 116Note that there are two 'lines' above, even though you used
TMOUT;
to separate the commands.You can timeout reads, which can be really handy in some scripts
#!/bin/bash TMOUT=5 echo You have 5 seconds to respond... read echo ${REPLY:-noreply}... ... ...
10) Associative ArraysTalking of moving to other languages, a rule of thumb I use is that if I need arrays then I drop bash to go to python (I even created a Docker container for a tool to help with this here ).
What I didn't know until I read up on it was that you can have associative arrays in bash.
Type this out for a demo:
$ declare -A MYAA=([one]=1 [two]=2 [three]=3) $ MYAA[one]="1" $ MYAA[two]="2" $ echo $MYAA $ echo ${MYAA[one]} $ MYAA[one]="1" $ WANT=two $ echo ${MYAA[$WANT]}Note that this is only available in bashes 4.x+.
... ... ...
Jul 04, 2020 | zwischenzugs.com
... ... ... Managing Variables
Variables are a core part of most serious bash scripts (and even one-liners!), so managing them is another important way to reduce the possibility of your script breaking.
Change your script to add the 'set' line immediately after the first line and see what happens:
#!/bin/bash set -o nounset A="some value" echo "${A}" echo "${B}"...I always set
Tracing Variablesnounset
on my scripts as a habit. It can catch many problems before they become serious.If you are working with a particularly complex script, then you can get to the point where you are unsure what happened to a variable.
Try running this script and see what happens:
#!/bin/bash set -o nounset declare A="some value" function a { echo "${BASH_SOURCE}>A A=${A} LINENO:${1}" } trap "a $LINENO" DEBUG B=value echo "${A}" A="another value" echo "${A}" echo "${B}"There's a problem with this code. The output is slightly wrong. Can you work out what is going on? If so, try and fix it.
You may need to refer to the bash man page, and make sure you understand quoting in bash properly.
It's quite a tricky one to fix 'properly', so if you can't fix it, or work out what's wrong with it, then ask me directly and I will help.
Profiling Bash ScriptsReturning to the
xtrace
(orset -x
flag), we can exploit its use of aPS
variable to implement the profiling of a script:#!/bin/bash set -o nounset set -o xtrace declare A="some value" PS4='$(date "+%s%N => ")' B= echo "${A}" A="another value" echo "${A}" echo "${B}" ls pwd curl -q bbc.co.ukFrom this you should be able to tell what
PS4
does. Have a play with it, and read up and experiment with the otherPS
variables to get familiar with what they do.NOTE: If you are on a Mac, then you might only get second-level granularity on the date!
Linting with ShellcheckFinally, here is a very useful tip for understanding bash more deeply and improving any bash scripts you come across.
Shellcheck is a website and a package available on most platforms that gives you advice to help fix and improve your shell scripts. Very often, its advice has prompted me to research more deeply and understand bash better.
Here is some example output from a script I found on my laptop:
$ shellcheck shrinkpdf.sh In shrinkpdf.sh line 44: -dColorImageResolution=$3 \ ^-- SC2086: Double quote to prevent globbing and word splitting. In shrinkpdf.sh line 46: -dGrayImageResolution=$3 \ ^-- SC2086: Double quote to prevent globbing and word splitting. In shrinkpdf.sh line 48: -dMonoImageResolution=$3 \ ^-- SC2086: Double quote to prevent globbing and word splitting. In shrinkpdf.sh line 57: if [ ! -f "$1" -o ! -f "$2" ]; then ^-- SC2166: Prefer [ p ] || [ q ] as [ p -o q ] is not well defined. In shrinkpdf.sh line 60: ISIZE="$(echo $(wc -c "$1") | cut -f1 -d\ )" ^-- SC2046: Quote this to prevent word splitting. ^-- SC2005: Useless echo? Instead of 'echo $(cmd)', just use 'cmd'. In shrinkpdf.sh line 61: OSIZE="$(echo $(wc -c "$2") | cut -f1 -d\ )" ^-- SC2046: Quote this to prevent word splitting. ^-- SC2005: Useless echo? Instead of 'echo $(cmd)', just use 'cmd'.The most common reminders are regarding potential quoting issues, but you can see other useful tips in the above output, such as preferred arguments to the
Exercisetest
construct, and advice on "useless"echo
s.1) Find a large bash script on a social coding site such as GitHub, and run
shellcheck
over it. Contribute back any improvements you find.
Oct 02, 2019 | opensource.com
7 Bash history shortcuts you will actually use Save time on the command line with these essential Bash shortcuts. 02 Oct 2019 Ian 205 up 12 comments Image by : Opensource.com x Subscribe now
Most guides to Bash history shortcuts exhaustively list every single one available. The problem with that is I would use a shortcut once, then glaze over as I tried out all the possibilities. Then I'd move onto my working day and completely forget them, retaining only the well-known !! trick I learned when I first started using Bash.
So most of them were never committed to memory.
More on BashThis article outlines the shortcuts I actually use every day. It is based on some of the contents of my book, Learn Bash the hard way ; (you can read a preview of it to learn more).
- Bash cheat sheet
- An introduction to programming with Bash
- A sysadmin's guide to Bash scripting
- Latest Bash articles
When people see me use these shortcuts, they often ask me, "What did you do there!?" There's minimal effort or intelligence required, but to really learn them, I recommend using one each day for a week, then moving to the next one. It's worth taking your time to get them under your fingers, as the time you save will be significant in the long run.
1. The "last argument" one: !$2. The " n th argument" one: !:2If you only take one shortcut from this article, make it this one. It substitutes in the last argument of the last command into your line.
Consider this scenario:
$ mv / path / to / wrongfile / some / other / place
mv: cannot stat '/path/to/wrongfile' : No such file or directoryAch, I put the wrongfile filename in my command. I should have put rightfile instead.
You might decide to retype the last command and replace wrongfile with rightfile completely. Instead, you can type:
$ mv / path / to / rightfile ! $
mv / path / to / rightfile / some / other / placeand the command will work.
There are other ways to achieve the same thing in Bash with shortcuts, but this trick of reusing the last argument of the last command is one I use the most.
Ever done anything like this?
$ tar -cvf afolder afolder.tar
tar: failed to openLike many others, I get the arguments to tar (and ln ) wrong more often than I would like to admit.
tar_2x.pngWhen you mix up arguments like that, you can run:
$ ! : 0 ! : 1 ! : 3 ! : 2
tar -cvf afolder.tar afolderand your reputation will be saved.
The last command's items are zero-indexed and can be substituted in with the number after the !: .
Obviously, you can also use this to reuse specific arguments from the last command rather than all of them.
3. The "all the arguments": !*4. The "last but n " : !-2:$Imagine I run a command like:
$ grep '(ping|pong)' afileThe arguments are correct; however, I want to match ping or pong in a file, but I used grep rather than egrep .
I start typing egrep , but I don't want to retype the other arguments. So I can use the !:1$ shortcut to ask for all the arguments to the previous command from the second one (remember they're zero-indexed) to the last one (represented by the $ sign).
$ egrep ! : 1 -$
egrep '(ping|pong)' afile
pingYou don't need to pick 1-$ ; you can pick a subset like 1-2 or 3-9 (if you had that many arguments in the previous command).
The shortcuts above are great when I know immediately how to correct my last command, but often I run commands after the original one, which means that the last command is no longer the one I want to reference.
For example, using the mv example from before, if I follow up my mistake with an ls check of the folder's contents:
$ mv / path / to / wrongfile / some / other / place
mv: cannot stat '/path/to/wrongfile' : No such file or directory
$ ls / path / to /
rightfileI can no longer use the !$ shortcut.
In these cases, I can insert a - n : (where n is the number of commands to go back in the history) after the ! to grab the last argument from an older command:
$ mv / path / to / rightfile ! - 2 :$
mv / path / to / rightfile / some / other / placeAgain, once you learn it, you may be surprised at how often you need it.
5. The "get me the folder" one: !$:hThis one looks less promising on the face of it, but I use it dozens of times daily.
Imagine I run a command like this:
$ tar -cvf system.tar / etc / system
tar: / etc / system: Cannot stat: No such file or directory
tar: Error exit delayed from previous errors.The first thing I might want to do is go to the /etc folder to see what's in there and work out what I've done wrong.
I can do this at a stroke with:
$ cd ! $:h
cd / etcThis one says: "Get the last argument to the last command ( /etc/system ) and take off its last filename component, leaving only the /etc ."
6. The "the current line" one: !#:1For years, I occasionally wondered if I could reference an argument on the current line before finally looking it up and learning it. I wish I'd done so a long time ago. I most commonly use it to make backup files:
$ cp / path / to / some / file ! #:1.bak
cp / path / to / some / file / path / to / some / file.bakbut once under the fingers, it can be a very quick alternative to
7. The "search and replace" one: !!:gsThis one searches across the referenced command and replaces what's in the first two / characters with what's in the second two.
Say I want to tell the world that my s key does not work and outputs f instead:
$ echo my f key doef not work
my f key doef not workThen I realize that I was just hitting the f key by accident. To replace all the f s with s es, I can type:
$ !! :gs / f / s /
echo my s key does not work
my s key does not workIt doesn't work only on single characters; I can replace words or sentences, too:
$ !! :gs / does / did /
echo my s key did not work
my s key did not work Test them outJust to show you how these shortcuts can be combined, can you work out what these toenail clippings will output?
$ ping ! #:0:gs/i/o
$ vi / tmp /! : 0 .txt
$ ls ! $:h
$ cd ! - 2 :h
$ touch ! $! - 3 :$ !! ! $.txt
$ cat ! : 1 -$ ConclusionBash can be an elegant source of shortcuts for the day-to-day command-line user. While there are thousands of tips and tricks to learn, these are my favorites that I frequently put to use.
If you want to dive even deeper into all that Bash can teach you, pick up my book, Learn Bash the hard way or check out my online course, Master the Bash shell .
This article was originally posted on Ian's blog, Zwischenzugs.com , and is reused with permission.
Orr, August 25, 2019 at 10:39 pm
BTW – you inspired me to try and understand how to repeat the nth command entered on command line. For example I type 'ls' and then accidentally type 'clear'. !! will retype clear again but I wanted to retype ls instead using a shortcut.
Bash doesn't accept ':' so !:2 didn't work. !-2 did however, thank you!Dima August 26, 2019 at 7:40 am
Nice article! Just another one cool and often used command: i.e.: !vi opens the last vi command with their arguments.
cbarrick on 03 Oct 2019
Your "current line" example is too contrived. Your example is copying to a backup like this:
$ cp /path/to/some/file !#:1.bakBut a better way to write that is with filename generation:
$ cp /path/to/some/file{,.bak}That's not a history expansion though... I'm not sure I can come up with a good reason to use `!#:1`.
Darryl Martin August 26, 2019 at 4:41 pm
I seldom get anything out of these "bash commands you didn't know" articles, but you've got some great tips here. I'm writing several down and sticking them on my terminal for reference.
A couple additions I'm sure you know.
- I use "!*" for "all arguments". It doesn't have the flexibility of your approach but it's faster for my most common need.
- I recently started using Alt-. as a substitute for "!$" to get the last argument. It expands the argument on the line, allowing me to modify it if necessary.
Ricardo J. Barberis on 06 Oct 2019
The problem with bash's history shorcuts for me is... that I never had the need to learn them.
Provided that your shell is readline-enabled, I find it much easier to use the arrow keys and modifiers to navigate through history than type !:1 (or having to remeber what it means).
Examples:
Ctrl+R for a Reverse search
Ctrl+A to move to the begnining of the line (Home key also)
Ctrl+E to move to the End of the line (End key also)
Ctrl+K to Kill (delete) text from the cursor to the end of the line
Ctrl+U to kill text from the cursor to the beginning of the line
Alt+F to move Forward one word (Ctrl+Right arrow also)
Alt+B to move Backward one word (Ctrl+Left arrow also)
etc.YMMV of course.
Jul 02, 2020 | zwischenzugs.com
2)
|&
You may already be familiar with
2>&1
, which redirects standard error to standard output, but until I stumbled on it in the manual, I had no idea that you can pipe both standard output and standard error into the next stage of the pipeline like this:if doesnotexist |& grep 'command not found' >/dev/null then echo oops fi3)$''
This construct allows you to specify specific bytes in scripts without fear of triggering some kind of encoding problem. Here's a command that will
grep
through files looking for UK currency ('£') signs in hexadecimal recursively:grep -r $'\xc2\xa3' *You can also use octal:
grep -r $'\302\243' *4)HISTIGNORE
If you are concerned about security, and ever type in commands that might have sensitive data in them, then this one may be of use.
This environment variable does not put the commands specified in your history file if you type them in. The commands are separated by colons:
HISTIGNORE="ls *:man *:history:clear:AWS_KEY*"You have to specify the whole line, so a glob character may be needed if you want to exclude commands and their arguments or flags.
5)fc
If readline key bindings aren't under your fingers, then this one may come in handy.
It calls up the last command you ran, and places it into your preferred editor (specified by the EDITOR variable). Once edited, it re-runs the command.
6)((i++))
If you can't be bothered with faffing around with variables in bash with the
$[]
construct, you can use the C-style compound command.So, instead of:
A=1 A=$[$A+1] echo $Ayou can do:
A=1 ((A++)) echo $Awhich, especially with more complex calculations, might be easier on the eye.
7)caller
Another builtin bash command,
caller
gives context about the context of your shell's
SHLVL
is a related shell variable which gives the level of depth of the calling stack.This can be used to create stack traces for more complex bash scripts.
Here's a
die
function, adapted from the bash hackers' wiki that gives a stack trace up through the calling frames:#!/bin/bash die() { local frame=0 ((FRAMELEVEL=SHLVL - frame)) echo -n "${FRAMELEVEL}: " while caller $frame; do ((frame++)); ((FRAMELEVEL=SHLVL - frame)) if [[ ${FRAMELEVEL} -gt -1 ]] then echo -n "${FRAMELEVEL}: " fi done echo "$*" exit 1 }which outputs:
3: 17 f1 ./caller.sh 2: 18 f2 ./caller.sh 1: 19 f3 ./caller.sh 0: 20 main ./caller.sh *** an error occured ***8)/dev/tcp/host/port
This one can be particularly handy if you find yourself on a container running within a Kubernetes cluster service mesh without any network tools (a frustratingly common experience).
Bash provides you with some virtual files which, when referenced, can create socket connections to other servers.
This snippet, for example, makes a web request to a site and returns the output.
exec 9<>/dev/tcp/brvtsdflnxhkzcmw.neverssl.com/80 echo -e "GET /online HTTP/1.1\r\nHost: brvtsdflnxhkzcmw.neverssl.com\r\n\r\n" >&9 cat <&9The first line opens up file descriptor
9
to the hostbrvtsdflnxhkzcmw.neverssl.com
on port80
for reading and writing. Line two sends the raw HTTP request to that socket connection's file descriptor. The final line retrieves the response.Obviously, this doesn't handle SSL for you, so its use is limited now that pretty much everyone is running on https, but when running from application containers within a service mesh can still prove invaluable, as requests there are initiated using HTTP.
9) Co-processesSince version 4 of
bash
it has offered the capability to run named coprocesses.It seems to be particularly well-suited to managing the inputs and outputs to other processes in a fine-grained way. Here's an annotated and trivial example:
coproc testproc ( i=1 while true do echo "iteration:${i}" ((i++)) read -r aline echo "${aline}" done )This sets up the coprocess as a subshell with the name
testproc
.Within the subshell, there's a never-ending while loop that counts its own iterations with the
i
variable. It outputs two lines: the iteration number, and a line read in from standard input.After creating the coprocess, bash sets up an array with that name with the file descriptor numbers for the standard input and standard output. So this:
echo "${testproc[@]}"in my terminal outputs:
63 60Bash also sets up a variable with the process identifier for the coprocess, which you can see by echoing it:
echo "${testproc_PID}"You can now input data to the standard input of this coprocess at will like this:
echo input1 >&"${testproc[1]}"In this case, the command resolves to:
echo input1 >&60
, and the>&[INTEGER]
construct ensures the redirection goes to the coprocess's standard input.Now you can read the output of the coprocess's two lines in a similar way, like this:
read -r output1a <&"${testproc[0]}" read -r output1b <&"${testproc[0]}"You might use this to create an expect -like script if you were so inclined, but it could be generally useful if you want to manage inputs and outputs. Named pipes are another way to achieve a similar result.
Here's a complete listing for those who want to cut and paste:
!/bin/bash coproc testproc ( i=1 while true do echo "iteration:${i}" ((i++)) read -r aline echo "${aline}" done ) echo "${testproc[@]}" echo "${testproc_PID}" echo input1 >&"${testproc[1]}" read -r output1a <&"${testproc[0]}" read -r output1b <&"${testproc[0]}" echo "${output1a}" echo "${output1b}" echo input2 >&"${testproc[1]}" read -r output2a <&"${testproc[0]}" read -r output2b <&"${testproc[0]}" echo "${output2a}" echo "${output2b}"
Apr 02, 2020 | opensource.com
Originally from: Get started with Bash scripting for sysadmins - Opensource.com
Most shells offer the ability to create, manipulate, and query indexed arrays. In plain English, an indexed array is a list of things prefixed with a number. This list of things, along with their assigned number, is conveniently wrapped up in a single variable, which makes it easy to "carry" it around in your code.
Bash, however, includes the ability to create associative arrays and treats these arrays the same as any other array. An associative array lets you create lists of key and value pairs, instead of just numbered values.
The nice thing about associative arrays is that keys can be arbitrary:
$ declare -A userdata
$ userdata [ name ] =seth
$ userdata [ pass ] =8eab07eb620533b083f241ec4e6b9724
$ userdata [ login ] = ` date --utc + % s `Query any key:
$ echo " ${userdata[name]} "
seth
$ echo " ${userdata[login]} "
1583362192Most of the usual array operations you'd expect from an array are available.
Resources
- How to program with Bash: Syntax and tools
- How to program with Bash: Logical operators and shell expansions
- How to program with Bash: Loops
Jun 12, 2020 | opensource.com
Source is like a Python import or a Java include. Learn it to expand your Bash prowess. Seth Kenlon (Red Hat) Feed 25 up 2 comments Image by : Opensource.com x Subscribe nowWhen you log into a Linux shell, you inherit a specific working environment. An environment , in the context of a shell, means that there are certain variables already set for you, which ensures your commands work as intended. For instance, the PATH environment variable defines where your shell looks for commands. Without it, nearly everything you try to do in Bash would fail with a command not found error. Your environment, while mostly invisible to you as you go about your everyday tasks, is vitally important.
There are many ways to affect your shell environment. You can make modifications in configuration files, such as
Add to your environment with source~/.bashrc
and~/.profile
, you can run services at startup, and you can create your own custom commands or script your own Bash functions .Bash (along with some other shells) has a built-in command called
source
. And here's where it can get confusing:source
performs the same function as the command.
(yes, that's but a single dot), and it's not the samesource
as theTcl
command (which may come up on your screen if you typeman source
). The built-insource
command isn't in yourPATH
at all, in fact. It's a command that comes included as a part of Bash, and to get further information about it, you can typehelp source
.The
More on Bash.
command is POSIX -compliant. Thesource
command is not defined by POSIX but is interchangeable with the.
command.According to Bash
- Bash cheat sheet
- An introduction to programming with Bash
- A sysadmin's guide to Bash scripting
- Latest Bash articles
help
, thesource
command executes a file in your current shell. The clause "in your current shell" is significant, because it means it doesn't launch a sub-shell; therefore, whatever you execute withsource
happens within and affects your current environment.Before exploring how
#!/usr/bin/env bashsource
can affect your environment, trysource
on a test file to ensure that it executes code as expected. First, create a simple Bash script and save it as a file calledhello.sh
:
echo "hello world"Using
$ source hello.shsource
, you can run this script even without setting the executable bit:
hello worldYou can also use the built-in
$ . hello.sh.
command for the same results:
hello worldThe
Set variables and import functionssource
and.
commands successfully execute the contents of the test file.You can use
source
to "import" a file into your shell environment, just as you might use theinclude
keyword in C or C++ to reference a library or theimport
keyword in Python to bring in a module. This is one of the most common uses forsource
, and it's a common default inclusion in.bashrc
files tosource
a file called.bash_aliases
so that any custom aliases you define get imported into your environment when you log in.Here's an example of importing a Bash function. First, create a function in a file called
function myip () {myfunctions
. This prints your public IP address and your local IP address:
curl http: // icanhazip.comip addr | grep inet $IP | \
cut -d "/" -f 1 | \
grep -v 127 \.0 | \
grep -v \:\: 1 | \
awk '{$1=$1};1'
}Import the function into your shell:
$ source myfunctionsTest your new function:
$ myip
93.184.216.34
inet 192.168.0.23
inet6 fbd4:e85f:49c: 2121 :ce12:ef79:0e77:59d1
inet 10.8.42.38 Search for sourceWhen you use
source
in Bash, it searches your current directory for the file you reference. This doesn't happen in all shells, so check your documentation if you're not using Bash.If Bash can't find the file to execute, it searches your
PATH
instead. Again, this isn't the default for all shells, so check your documentation if you're not using Bash.These are both nice convenience features in Bash. This behavior is surprisingly powerful because it allows you to store common functions in a centralized location on your drive and then treat your environment like an integrated development environment (IDE). You don't have to worry about where your functions are stored, because you know they're in your local equivalent of
/usr/include
, so no matter where you are when you source them, Bash finds them.For instance, you could create a directory called
~/.local/include
as a storage area for common functions and then put this block of code into your.bashrc
file:for i in $HOME / .local / include /* ; do source $i
doneThis "imports" any file containing custom functions in
~/.local/include
into your shell environment.Bash is the only shell that searches both the current directory and your
Using source for open sourcePATH
when you use either thesource
or the.
command.Using
source
or.
to execute files can be a convenient way to affect your environment while keeping your alterations modular. The next time you're thinking of copying and pasting big blocks of code into your.bashrc
file, consider placing related functions or groups of aliases into dedicated files, and then usesource
to ingest them.Get started with Bash scripting for sysadmins Learn the commands and features that make Bash one of the most powerful shells available.
Seth Kenlon (Red Hat) Introduction to automation with Bash scripts In the first article in this four-part series, learn how to create a simple shell script and why they are the best way to automate tasks.
David Both (Correspondent) Bash cheat sheet: Key combos and special syntax Download our new cheat sheet for Bash commands and shortcuts you need to talk to your computer.
Jul 01, 2020 | www.redhat.com
See also Bash bang commands- A must-know trick for the Linux command line - Enable Sysadmin
Let's say I run the following command:
$> sudo systemctl status sshdBash tells me the sshd service is not running, so the next thing I want to do is start the service. I had checked its status with my previous command. That command was saved in
history
, so I can reference it. I simply run:$> !!:s/status/start/ sudo systemctl start sshdThe above expression has the following content:
- !! - repeat the last command from history
- :s/status/start/ - substitute status with start
The result is that the sshd service is started.
Next, I increase the default HISTSIZE value from 500 to 5000 by using the following command:
$> echo "HISTSIZE=5000" >> ~/.bashrc && source ~/.bashrcWhat if I want to display the last three commands in my history? I enter:
$> history 3 1002 ls 1003 tail audit.log 1004 history 3I run
tail
onaudit.log
by referring to the history line number. In this case, I use line 1003:$> !1003 tail audit.logReference the last argument of the previous commandWhen I want to list directory contents for different directories, I may change between directories quite often. There is a nice trick you can use to refer to the last argument of the previous command. For example:
$> pwd /home/username/$> ls some/very/long/path/to/some/directory foo-file bar-file baz-fileIn the above example,
/some/very/long/path/to/some/directory
is the last argument of the previous command.If I want to
cd
(change directory) to that location, I enter something like this:$> cd $_ $> pwd /home/username/some/very/long/path/to/some/directoryNow simply use a dash character to go back to where I was:
$> cd - $> pwd /home/username/
Jun 28, 2020 | itsfoss.com
Top Free Resources to Learn Shell Scripting
Don't have Linux installed on your system? No, worries. There are various ways of using Linux terminal on Windows . You may also use online Linux terminals in some cases to practice shell scripting.
1. Learn Shell [Interactive web portal]If you're looking for an interactive web portal to learn shell scripting and also try it online, Learn Shell is a great place to start.
It covers the basics and offers some advanced exercises as well. The content is usually brief and to the point – hence, I'd recommend you to check this out.
Learn Shell 2. Shell Scripting Tutorial [Web portal]Shell scripting tutorial is web resource that's completely dedicated for shell scripting. You can choose to read the resource for free or can opt to purchase the PDF, book, or the e-book to support it.
Of course, paying for the paperback edition or the e-book is optional. But, the resource should come in handy for free.
Shell Scripting Tutorial 3. Shell Scripting – Udemy (Free video course)Udemy is unquestionably one of the most popular platforms for online courses. And, in addition to the paid certified courses, it also offers some free stuff that does not include certifications.
Shell Scripting is one of the most recommended free course available on Udemy for free. You can enroll in it without spending anything.
Shell Scripting – Udemy 4. Bash Shell Scripting – Udemy (Free video course)Yet another interesting free course focused on bash shell scripting on Udemy. Compared to the previous one, this resource seems to be more popular. So, you can enroll in it and see what it has to offer.
Not to forget that the free Udemy course does not offer any certifications. But, it's indeed an impressive free shell scripting learning resource.
5. Bash Academy [online portal with interactive game]As the name suggests, the bash academy is completely focused on educating the users about bash shell.
It's suitable for both beginners and experienced users even though it does not offer a lot of content. Not just limited to the guide -- but it also used to offer an interactive game to practice which no longer works.
Hence, if this is interesting enough, you can also check out its GitHub page and fork it to improve the existing resources if you want.
Bash Academy 6. Bash Scripting LinkedIn Learning (Free video course)LinkedIn offers a number of free courses to help you improve your skills and get ready for more job opportunities. You will also find a couple of courses focused on shell scripting to brush up some basic skills or gain some advanced knowledge in the process.
Here, I've linked a course for bash scripting, you can find some other similar courses for free as well.
Bash Scripting (LinkedIn Learning) 7. Advanced Bash Scripting Guide [Free PDF book]An impressive advanced bash scripting guide available in the form of PDF for free. This PDF resource does not enforce any copyrights and is completely free in the public domain.
Even though the resource is focused on providing advanced insights. It's also suitable for beginners to refer this resource and start to learn shell scripting.
Advanced Bash Scripting Guide [PDF] 8. Bash Notes for Professionals [Free PDF book]This is good reference guide if you are already familiar with Bash Shell scripting or if you just want a quick summary.
This free downloadable book runs over 100 pages and covers a wide variety of scripting topics with the help of brief description and quick examples.
Download Bash Notes for Professional 9. Tutorialspoint [Web portal]Tutorialspoint is a quite popular web portal to learn a variety of programming languages . I would say this is quite good for starters to learn the fundamentals and the basics.
This may not be suitable as a detailed resource -- but it should be a useful one for free.
Tutorialspoint 10. City College of San Francisco Online Notes [Web portal]This may not be the best free resource there is -- but if you're ready to explore every type of resource to learn shell scripting, why not refer to the online notes of City College of San Francisco?
I came across this with a random search on the Internet about shell scripting resources.
Again, it's important to note that the online notes could be a bit dated. But, it should be an interesting resource to explore.
City College of San Francisco Notes Honorable mention: Linux Man PageNot to forget, the man page for bash should also be a fantastic free resource to explore more about the commands and how it works.
Even if it's not tailored as something that lets you master shell scripting, it is still an important web resource that you can use for free. You can either choose to visit the man page online or just head to the terminal and type the following command to get help:
man bashWrapping UpThere are also a lot of popular paid resources just like some of the best Linux books available out there. It's easy to start learning about shell scripting using some free resources available across the web.
In addition to the ones I've mentioned, I'm sure there must be numerous other resources available online to help you learn shell scripting.
Do you like the resources mentioned above? Also, if you're aware of a fantastic free resource that I possibly missed, feel free to tell me about it in the comments below.
Skip AdLike what you read? Please share it with others.
28SharesFiled Under: List Tagged With: resources , shell
<img alt='' src='https://secure.gravatar.com/avatar/d098097d2a43d2fc1f0d31327f8288a6?s=90&d=mm&r=g' srcset='https://secure.gravatar.com/avatar/d098097d2a43d2fc1f0d31327f8288a6?s=180&d=mm&r=g 2x' class='avatar avatar-90 photo' height='90' width='90' />About Ankush DasA passionate technophile who also happens to be a Computer Science graduate. You will usually see cats dancing to the beautiful tunes sung by him. comment_count comments Newest Newest Oldest Most Liked Comment as a guest:
Nov 24, 2008 | www.linux.com
Author: Ben Martin
The Bash Debugger Project (bashdb) lets you set breakpoints, inspect variables, perform a backtrace, and step through a bash script line by line. In other words, it provides the features you expect in a C/C++ debugger to anyone programming a bash script.To see if your standard bash executable has bashdb support, execute the command shown below; if you are not taken to a bashdb prompt then you'll have to install bashdb yourself.
$ bash --debugger -c "set|grep -i dbg" ... bashdbThe Ubuntu Intrepid repository contains a package for bashdb, but there is no special bashdb package in the openSUSE 11 or Fedora 9 repositories. I built from source using version 4.0-0.1 of bashdb on a 64-bit Fedora 9 machine, using the normal
./configure; make; sudo make install
commands.You can start the Bash Debugger using the
bash --debugger foo.sh
syntax or thebashdb foo.sh
command. The former method is recommended except in cases where I/O redirection might cause issues, and it's what I used. You can also use bashdb through ddd or from an Emacs buffer.The syntax for many of the commands in bashdb mimics that of gdb, the GNU debugger. You can
step
into functions, usenext
to execute the next line without stepping into any functions, generate a backtrace withbt
, exit bashdb withquit
or Ctrl-D, and examine a variable withprint $foo
. Aside from the prefixing of the variable with$
at the end of the last sentence, there are some other minor differences that you'll notice. For instance, pressing Enter on a blank line in bashdb executes the previous step or next command instead of whatever the previous command was.The print command forces you to prefix shell variables with the dollar sign (
$foo
). A slightly shorter way of inspecting variables and functions is to use thex foo
command, which usesdeclare
to print variables and functions.Both bashdb and your script run inside the same bash shell. Because bash lacks some namespace properties, bashdb will include some functions and symbols into the global namespace which your script can get at. bashdb prefixes its symbols with
_Dbg_
, so you should avoid that prefix in your scripts to avoid potential clashes. bashdb also uses some environment variables; it uses theDBG_
prefix for its own, and relies on some standard bash ones that begin withBASH_
.To illustrate the use of bashdb, I'll work on the small bash script below, which expects a numeric argument
#!/bin/bash version="0.01"; fibonacci() { n=${1:?If you want the nth fibonacci number, you must supply n as the first parameter.} if [ $n -le 1 ]; then echo $n else l=`fibonacci $((n-1))` r=`fibonacci $((n-2))` echo $((l + r)) fi } for i in `seq 1 10` do result=$(fibonacci $i) echo "i=$i result=$result" donen
and calculates the nth Fibonacci number .The below session shows bashdb in action, stepping over and then into the fibonacci function and inspecting variables. I've made my input text bold for ease of reading. An initial backtrace (
$ bash --debugger ./fibonacci.sh ... (/home/ben/testing/bashdb/fibonacci.sh:3): 3: version="0.01"; bashdb bt ->0 in file `./fibonacci.sh' at line 3 ##1 main() called from file `./fibonacci.sh' at line 0 bashdb next (/home/ben/testing/bashdb/fibonacci.sh:16): 16: for i in `seq 1 10` bashdb list 16:==>for i in `seq 1 10` 17: do 18: result=$(fibonacci $i) 19: echo "i=$i result=$result" 20: done bashdb next (/home/ben/testing/bashdb/fibonacci.sh:18): 18: result=$(fibonacci $i) bashdb (/home/ben/testing/bashdb/fibonacci.sh:19): 19: echo "i=$i result=$result" bashdb x i result declare -- i="1" declare -- result="" bashdb print $i $result 1 bashdb break fibonacci Breakpoint 1 set in file /home/ben/testing/bashdb/fibonacci.sh, line 5. bashdb continue Breakpoint 1 hit (1 times). (/home/ben/testing/bashdb/fibonacci.sh:5): 5: fibonacci() { bashdb next (/home/ben/testing/bashdb/fibonacci.sh:6): 6: n=${1:?If you want the nth fibonacci number, you must supply n as the first parameter.} bashdb next (/home/ben/testing/bashdb/fibonacci.sh:7): 7: if [ $n -le 1 ]; then bashdb x n declare -- n="2" bashdb quitbt
) shows that the script begins at line 3, which is where the version variable is written. Thenext
andlist
commands then progress to the next line of the script a few times and show the context of the current execution line. After one of thenext
commands I press Enter to executenext
again. I invoke theexamine
command through the single letter shortcutx
. Notice that the variables are printed out usingdeclare
as opposed to their display on the next line usingfibonacci
function andcontinue
the execution of the shell script. Thefibonacci
function is called and I move to thenext
line a few times and inspect a variable.Notice that the number in the bashdb prompt toward the end of the above example is enclosed in parentheses. Each set of parentheses indicates that you have entered a subshell. In this example this is due to being inside a shell function.
In the below example I use a watchpoint to see if and where the
(/home/ben/testing/bashdb/fibonacci.sh:3): 3: version="0.01"; bashdb<0> next (/home/ben/testing/bashdb/fibonacci.sh:16): 16: for i in `seq 1 10` bashdb<1> watch result 0: ($result)==0 arith: 0 bashdb<2> c Watchpoint 0: $result changed: old value: '' new value: '1' (/home/ben/testing/bashdb/fibonacci.sh:19): 19: echo "i=$i result=$result" bashdb<3> c i=1 result=1 i=2 result=1 Watchpoint 0: $result changed: old value: '1' new value: '2' (/home/ben/testing/bashdb/fibonacci.sh:19): 19: echo "i=$i result=$result"result
variable changes. Notice the initialnext
command. I found that if I didn't issue that next then my watch would fail to work. As you can see, after I issuec
to continue execution, execution is stopped whenever the result variable is about to change, and the new and old value are displayed.To get around the strange initial
$ bash --debugger ./fibonacci.sh (/home/ben/testing/bashdb/fibonacci.sh:3): 3: version="0.01"; bashdb<0> watche result > 4 0: (result > 4)==0 arith: 1 bashdb<1> continue i=1 result=1 i=2 result=1 i=3 result=2 i=4 result=3 Watchpoint 0: result > 4 changed: old value: '0' new value: '1' (/home/ben/testing/bashdb/fibonacci.sh:19): 19: echo "i=$i result=$result"next
requirement I used thewatche
command in the below session, which lets you stop whenever an expression becomes true. In this case I'm not overly interested in the first few Fibonacci numbers so I set a watch to have execution stop when the result is greater than 4. You can also use awatche
command without a condition; for example,watche result
would stop execution whenever the result variable changed.When a shell script goes wrong, many folks use the time-tested method of incrementally adding in
echo
orprintf
statements to look for invalid values or code paths that are never reached. With bashdb, you can save yourself time by just adding a few watches on variables or setting a few breakpoints.
Mar 05, 2020 | www.networkworld.com
One quick way to determine whether the command you are using is a bash built-in or not is to use the command "command". Yes, the command is called "command". Try it with a -V (capital V) option like this:
$ command -V command command is a shell builtin $ command -V echo echo is a shell builtin $ command -V date date is hashed (/bin/date)When you see a "command is hashed" message like the one above, that means that the command has been put into a hash table for quicker lookup.
... ... ... How to tell what shell you're currently usingIf you switch shells you can't depend on $SHELL to tell you what shell you're currently using because $SHELL is just an environment variable that is set when you log in and doesn't necessarily reflect your current shell. Try ps -p $$ instead as shown in these examples:
$ ps -p $$ PID TTY TIME CMD 18340 pts/0 00:00:00 bash <== $ /bin/dash $ ps -p $$ PID TTY TIME CMD 19517 pts/0 00:00:00 dash <==Built-ins are extremely useful and give each shell a lot of its character. If you use some particular shell all of the time, it's easy to lose track of which commands are part of your shell and which are not.
Differentiating a shell built-in from a Linux executable requires only a little extra effort.
Mar 05, 2020 | marketplace.visualstudio.com
Bash IDEVisual Studio Code extension utilizing the bash language server , that is based on Tree Sitter and its grammar for Bash and supports explainshell integration.
FeaturesConfiguration
- [x] Jump to declaration
- [x] Find references
- [x] Code Outline & Show Symbols
- [x] Highlight occurrences
- [x] Code completion
- [x] Simple diagnostics reporting
- [x] Documentation for flags on hover
- [ ] Rename symbol
To get documentation for flags on hover (thanks to explainshell), run the explainshell Docker container :
docker run --rm --name bash-explainshell -p 5000:5000 chrismwendt/codeintel-bash-with-explainshellAnd add this to your VS Code settings:
"bashIde.explainshellEndpoint": "http://localhost:5000",For security reasons, it defaults to
""
, which disables explainshell integration. When set, this extension will send requests to the endpoint and displays documentation for flags.Once https://github.com/idank/explainshell/pull/125 is merged, it would be possible to set this to
"https://explainshell.com"
, however doing this is not recommended as it will leak all your shell scripts to a third party -- do this at your own risk, or better always use a locally running Docker image.
Sep 30, 2010 | www.reddit.com
1 r/commandline • Posted by u/acksed 6 years ago
I had to use file recovery software when I accidentally formatted my backup. It worked, but I now have 37,000 text files with numbers where names used to be.
If I name each file with the first 20-30 characters, I can sort the text-wheat from the bit-chaff.
I have the vague idea of using whatever the equivalent of head is on Windows, but that's as far as I got. I'm not so hot on bash scripting either. 9 comments 54% Upvoted This thread is archived New comments cannot be posted and votes cannot be cast Sort by level 1
tatumc 6 points · 6 years ago
acksed 2 points · 6 years agoTo rename each file with the first line of the file, you can do:
for i in *; do mv $i "$(head -1 "$i")"; doneYou can use cp instead of mv or make a backup of the dir first to be sure you don't accidentally nuke anything. level 2
· edited 6 years agotatumc 1 point · 6 years agoThis is almost exactly what I wanted. Thanks! A quick tweak:
for i in *; do mv $i "$(head -c 30 "$i")"; done
Now, I know CygWin is a thing, wonder if it'll work for me. level 3
acksed 1 point · 6 years agoJust keep in mind that 'head -c' will include newlines which will garble the new file names. level 3
· edited 6 years agotatumc 1 point · 6 years agoAnswer: not really. The environment and script's working, but whenever there's a forward slash or non-escaping character in the text, it chokes when it tries to set up a new directory, and it deletes the file suffix. :-/ Good thing I used a copy of the data.
Need something to strip out the characters and spaces, and add the file suffix, before it tries to rename.
sed
? Also needsfile
to identify it as true text. I can do the suffix at least:for i in *; do mv $i "$(head -c 30 "$i").txt"; donelevel 4yeayoushookme 1 point · 6 years agoI recommend you use 'head -1', which will make the first line of the file the filename and you won't have to worry about newlines. Then you can change the spaces to underscores with:
for i in *; do mv -v "$i" `echo $i | tr ' ' '_' `level 1· edited 6 years agoacksed 1 point · 6 years agoThere's the
file
program on *nix that'll tell you, in a verbose manner, the type of the file you give it as an argument, irregardless of its file extension. Example:$ file test.mp3 test.mp3: , 48 kHz, JntStereo $ file mbr.bin mbr.bin: data $ file CalendarExport.ics CalendarExport.ics: HTML document, UTF-8 Unicode text, with very long lines, with CRLF, LF line terminators $ file jmk.doc jmk.doc: Composite Document File V2 Document, Little Endian, Os: Windows, Version 6.0, Code page: 1250, Title: xx, Author: xx, Template: Normal, Last Saved By: xx, Revision Number: 4, Name of Creating Application: Microsoft Office Word, Total Editing Time: 2d+03:32:00, Last Printed: Fri Feb 22 11:29:00 2008, Create Time/Date: Fri Jan 4 12:57:00 2013, Last Saved Time/Date: Sun Jan 6 16:30:00 2013, Number of Pages: 6, Number of Words: 1711, Number of Characters: 11808, Security: 0level 2· edited 6 years agoRonaldoNazario 1 point · 6 years agoThank you, but the software I used to recover (R-Undelete) sorted them already. I found another program, RenameMaestro, that renames according to metadata in zip, rar, pdf, doc and other files, but text files are too basic.
Edit: You were right, I did need it. level 1
pfp-disciple 1 point · 6 years agoNot command line, but you could probably do this pretty easily in python, using "glob" to get filenames, and os read and move/rename functions to get the text and change filenames. level 1
So far, you're not getting many windows command line ideas :(. I don't have any either, but here's an idea:
Use one of the live Linux distributions (Porteus is pretty cool, but there're a slew of others). In that Linux environment, you can mount your Windows hard drive, and use Linux tools, maybe something like /u/tatumc suggested. r/commandline
Jul 31, 2019 | opensource.com
Tired of typing the same long commands over and over? Do you feel inefficient working on the command line? Bash aliases can make a world of difference. 28 comments
A Bash alias is a method of supplementing or overriding Bash commands with new ones. Bash aliases make it easy for users to customize their experience in a POSIX terminal. They are often defined in $HOME/.bashrc or $HOME/bash_aliases (which must be loaded by $HOME/.bashrc ).
Most distributions add at least some popular aliases in the default .bashrc file of any new user account. These are simple ones to demonstrate the syntax of a Bash alias:
alias ls = 'ls -F'
alias ll = 'ls -lh'Not all distributions ship with pre-populated aliases, though. If you add aliases manually, then you must load them into your current Bash session:
$ source ~/.bashrcOtherwise, you can close your terminal and re-open it so that it reloads its configuration file.
With those aliases defined in your Bash initialization script, you can then type ll and get the results of ls -l , and when you type ls you get, instead of the output of plain old ls .
Those aliases are great to have, but they just scratch the surface of what's possible. Here are the top 10 Bash aliases that, once you try them, you won't be able to live without.
Set up firstBefore beginning, create a file called ~/.bash_aliases :
$ touch ~/.bash_aliasesThen, make sure that this code appears in your ~/.bashrc file:
if [ -e $HOME / .bash_aliases ] ; then
source $HOME / .bash_aliases
fiIf you want to try any of the aliases in this article for yourself, enter them into your .bash_aliases file, and then load them into your Bash session with the source ~/.bashrc command.
Sort by file sizeIf you started your computing life with GUI file managers like Nautilus in GNOME, the Finder in MacOS, or Explorer in Windows, then you're probably used to sorting a list of files by their size. You can do that in a terminal as well, but it's not exactly succinct.
Add this alias to your configuration on a GNU system:
alias lt = 'ls --human-readable --size -1 -S --classify'This alias replaces lt with an ls command that displays the size of each item, and then sorts it by size, in a single column, with a notation to indicate the kind of file. Load your new alias, and then try it out:
$ source ~ / .bashrc
$ lt
total 344K
140K configure *
44K aclocal.m4
36K LICENSE
32K config.status *
24K Makefile
24K Makefile.in
12K config.log
8.0K README.md
4.0K info.slackermedia.Git-portal.json
4.0K git-portal.spec
4.0K flatpak.path.patch
4.0K Makefile.am *
4.0K dot-gitlab.ci.yml
4.0K configure.ac *
0 autom4te.cache /
0 share /
0 bin /
0 install-sh @
0 compile @
0 missing @
0 COPYING @On MacOS or BSD, the ls command doesn't have the same options, so this alias works instead:
alias lt = 'du -sh * | sort -h'The results of this version are a little different:
$ du -sh * | sort -h
0 compile
0 COPYING
0 install-sh
0 missing
4.0K configure.ac
4.0K dot-gitlab.ci.yml
4.0K flatpak.path.patch
4.0K git-portal.spec
4.0K info.slackermedia.Git-portal.json
4.0K Makefile.am
8.0K README.md
12K config.log
16K bin
24K Makefile
24K Makefile.in
32K config.status
36K LICENSE
44K aclocal.m4
60K share
140K configure
476K autom4te.cacheIn fact, even on Linux, that command is useful, because using ls lists directories and symlinks as being 0 in size, which may not be the information you actually want. It's your choice.
Thanks to Brad Alexander for this alias idea.
View only mounted drivesThe mount command used to be so simple. With just one command, you could get a list of all the mounted filesystems on your computer, and it was frequently used for an overview of what drives were attached to a workstation. It used to be impressive to see more than three or four entries because most computers don't have many more USB ports than that, so the results were manageable.
Computers are a little more complicated now, and between LVM, physical drives, network storage, and virtual filesystems, the results of mount can be difficult to parse:
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime,seclabel)
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)
devtmpfs on /dev type devtmpfs (rw,nosuid,seclabel,size=8131024k,nr_inodes=2032756,mode=755)
securityfs on /sys/kernel/security type securityfs (rw,nosuid,nodev,noexec,relatime)
[...]
/dev/nvme0n1p2 on /boot type ext4 (rw,relatime,seclabel)
/dev/nvme0n1p1 on /boot/efi type vfat (rw,relatime,fmask=0077,dmask=0077,codepage=437,iocharset=ascii,shortname=winnt,errors=remount-ro)
[...]
gvfsd-fuse on /run/user/100977/gvfs type fuse.gvfsd-fuse (rw,nosuid,nodev,relatime,user_id=100977,group_id=100977)
/dev/sda1 on /run/media/seth/pocket type ext4 (rw,nosuid,nodev,relatime,seclabel,uhelper=udisks2)
/dev/sdc1 on /run/media/seth/trip type ext4 (rw,nosuid,nodev,relatime,seclabel,uhelper=udisks2)
binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,relatime)To solve that problem, try an alias like this:
alias mnt = "mount | awk -F' ' '{ printf \" %s \t %s \n\" , \$ 1, \$ 3; }' | column -t | egrep ^/dev/ | sort"This alias uses awk to parse the output of mount by column, reducing the output to what you probably looking for (what hard drives, and not file systems, are mounted):
$ mnt
/dev/mapper/fedora-root /
/dev/nvme0n1p1 /boot/efi
/dev/nvme0n1p2 /boot
/dev/sda1 /run/media/seth/pocket
/dev/sdc1 /run/media/seth/tripOn MacOS, the mount command doesn't provide terribly verbose output, so an alias may be overkill. However, if you prefer a succinct report, try this:
alias mnt = 'mount | grep -E ^/dev | column -t'The results:
$ mnt
/dev/disk1s1 on / (apfs, local, journaled)
/dev/disk1s4 on /private/var/vm (apfs, local, noexec, journaled, noatime, nobrowse) Find a command in your grep historySometimes you figure out how to do something in the terminal, and promise yourself that you'll never forget what you've just learned. Then an hour goes by, and you've completely forgotten what you did.
Searching through your Bash history is something everyone has to do from time to time. If you know exactly what you're searching for, you can use Ctrl+R to do a reverse search through your history, but sometimes you can't remember the exact command you want to find.
Here's an alias to make that task a little easier:
alias gh = 'history|grep'Here's an example of how to use it:
$ gh bash
482 cat ~/.bashrc | grep _alias
498 emacs ~/.bashrc
530 emacs ~/.bash_aliases
531 source ~/.bashrc Sort by modification timeIt happens every Monday: You get to work, you sit down at your computer, you open a terminal, and you find you've forgotten what you were doing last Friday. What you need is an alias to list the most recently modified files.
You can use the ls command to create an alias to help you find where you left off:
alias left = 'ls -t -1'The output is simple, although you can extend it with the -- long option if you prefer. The alias, as listed, displays this:
$ left
demo.jpeg
demo.xcf
design-proposal.md
rejects.txt
brainstorm.txt
query-letter.xml Count filesIf you need to know how many files you have in a directory, the solution is one of the most classic examples of UNIX command construction: You list files with the ls command, control its output to be only one column with the -1 option, and then pipe that output to the wc (word count) command to count how many lines of single files there are.
It's a brilliant demonstration of how the UNIX philosophy allows users to build their own solutions using small system components. This command combination is also a lot to type if you happen to do it several times a day, and it doesn't exactly work for a directory of directories without using the -R option, which introduces new lines to the output and renders the exercise useless.
Instead, this alias makes the process easy:
alias count = 'find . -type f | wc -l'This one counts files, ignoring directories, but not the contents of directories. If you have a project folder containing two directories, each of which contains two files, the alias returns four, because there are four files in the entire project.
$ ls
foo bar
$ count
4 Create a Python virtual environmentDo you code in Python?
Do you code in Python a lot?
If you do, then you know that creating a Python virtual environment requires, at the very least, 53 keystrokes.
alias ve = 'python3 -m venv ./venv'
That's 49 too many, but that's easily circumvented with two new aliases called ve and va :
alias va = 'source ./venv/bin/activate'Running ve creates a new directory, called venv , containing the usual virtual environment filesystem for Python3. The va alias activates the environment in your current shell:
$ cd my-project
$ ve
$ va
(venv) $ Add a copy progress barEverybody pokes fun at progress bars because they're infamously inaccurate. And yet, deep down, we all seem to want them. The UNIX cp command has no progress bar, but it does have a -v option for verbosity, meaning that it echoes the name of each file being copied to your terminal. That's a pretty good hack, but it doesn't work so well when you're copying one big file and want some indication of how much of the file has yet to be transferred.
The pv command provides a progress bar during copy, but it's not common as a default application. On the other hand, the rsync command is included in the default installation of nearly every POSIX system available, and it's widely recognized as one of the smartest ways to copy files both remotely and locally.
Better yet, it has a built-in progress bar.
alias cpv = 'rsync -ah --info=progress2'Using this alias is the same as using the cp command:
$ cpv bigfile.flac /run/media/seth/audio/
3.83M 6% 213.15MB/s 0:00:00 (xfr#4, to-chk=0/4)An interesting side effect of using this command is that rsync copies both files and directories without the -r flag that cp would otherwise require.
Protect yourself from file removal accidentsYou shouldn't use the rm command. The rm manual even says so:
Warning : If you use 'rm' to remove a file, it is usually possible to recover the contents of that file. If you want more assurance that the contents are truly unrecoverable, consider using 'shred'.
If you want to remove a file, you should move the file to your Trash, just as you do when using a desktop.
POSIX makes this easy, because the Trash is an accessible, actual location in your filesystem. That location may change, depending on your platform: On a FreeDesktop , the Trash is located at ~/.local/share/Trash , while on MacOS it's ~/.Trash , but either way, it's just a directory into which you place files that you want out of sight until you're ready to erase them forever.
This simple alias provides a way to toss files into the Trash bin from your terminal:
alias tcn = 'mv --force -t ~/.local/share/Trash 'This alias uses a little-known mv flag that enables you to provide the file you want to move as the final argument, ignoring the usual requirement for that file to be listed first. Now you can use your new command to move files and folders to your system Trash:
$ ls
foo bar
$ tcn foo
$ ls
barNow the file is "gone," but only until you realize in a cold sweat that you still need it. At that point, you can rescue the file from your system Trash; be sure to tip the Bash and mv developers on the way out.
Note: If you need a more robust Trash command with better FreeDesktop compliance, see Trashy .
Simplify your Git workflowEveryone has a unique workflow, but there are usually repetitive tasks no matter what. If you work with Git on a regular basis, then there's probably some sequence you find yourself repeating pretty frequently. Maybe you find yourself going back to the master branch and pulling the latest changes over and over again during the day, or maybe you find yourself creating tags and then pushing them to the remote, or maybe it's something else entirely.
No matter what Git incantation you've grown tired of typing, you may be able to alleviate some pain with a Bash alias. Largely thanks to its ability to pass arguments to hooks, Git has a rich set of introspective commands that save you from having to perform uncanny feats in Bash.
For instance, while you might struggle to locate, in Bash, a project's top-level directory (which, as far as Bash is concerned, is an entirely arbitrary designation, since the absolute top level to a computer is the root directory), Git knows its top level with a simple query. If you study up on Git hooks, you'll find yourself able to find out all kinds of information that Bash knows nothing about, but you can leverage that information with a Bash alias.
Here's an alias to find the top level of a Git project, no matter where in that project you are currently working, and then to change directory to it, change to the master branch, and perform a Git pull:
alias startgit = 'cd `git rev-parse --show-toplevel` && git checkout master && git pull'This kind of alias is by no means a universally useful alias, but it demonstrates how a relatively simple alias can eliminate a lot of laborious navigation, commands, and waiting for prompts.
A simpler, and probably more universal, alias returns you to the Git project's top level. This alias is useful because when you're working on a project, that project more or less becomes your "temporary home" directory. It should be as simple to go "home" as it is to go to your actual home, and here's an alias to do it:
alias cg = 'cd `git rev-parse --show-toplevel`'Now the command cg takes you to the top of your Git project, no matter how deep into its directory structure you have descended.
Change directories and view the contents at the same timeIt was once (allegedly) proposed by a leading scientist that we could solve many of the planet's energy problems by harnessing the energy expended by geeks typing cd followed by ls .
It's a common pattern, because generally when you change directories, you have the impulse or the need to see what's around.But "walking" your computer's directory tree doesn't have to be a start-and-stop process.
This one's cheating, because it's not an alias at all, but it's a great excuse to explore Bash functions. While aliases are great for quick substitutions, Bash allows you to add local functions in your .bashrc file (or a separate functions file that you load into .bashrc , just as you do your aliases file).
To keep things modular, create a new file called ~/.bash_functions and then have your .bashrc load it:
if [ -e $HOME / .bash_functions ] ; then
source $HOME / .bash_functions
fiIn the functions file, add this code:
function cl () {
DIR = "$*" ;
# if no DIR given, go home
if [ $# -lt 1 ] ; then
DIR = $HOME ;
fi ;
builtin cd " ${DIR} " && \
# use your preferred ls command
ls -F --color =auto
}Load the function into your Bash session and then try it out:
$ source ~ / .bash_functions
$ cl Documents
foo bar baz
$ pwd
/ home / seth / Documents
$ cl ..
Desktop Documents Downloads
[ ... ]
$ pwd
/ home / sethFunctions are much more flexible than aliases, but with that flexibility comes the responsibility for you to ensure that your code makes sense and does what you expect. Aliases are meant to be simple, so keep them easy, but useful. For serious modifications to how Bash behaves, use functions or custom shell scripts saved to a location in your PATH .
For the record, there are some clever hacks to implement the cd and ls sequence as an alias, so if you're patient enough, then the sky is the limit even using humble aliases.
Start aliasing and functioningCustomizing your environment is what makes Linux fun, and increasing your efficiency is what makes Linux life-changing. Get started with simple aliases, graduate to functions, and post your must-have aliases in the comments!
ACG on 31 Jul 2019 Permalink
Seth Kenlon on 31 Jul 2019 PermalinkOne function I like a lot is a function that diffs a file and its backup.
It goes something like#!/usr/bin/env bash
file="${1:?File not given}"if [[ ! -e "$file" || ! -e "$file"~ ]]; then
echo "File doesn't exist or has no backup" 1>&2
exit 1
fidiff --color=always "$file"{~,} | less -r
I may have gotten the if wrong, but you get the idea. I'm typing this on my phone, away from home.
CheersKevin Cole on 13 Aug 2019 PermalinkThat's pretty slick! I like it.
My backup tool of choice (rdiff-backup) handles these sorts of comparisons pretty well, so I tend to be confident in my backup files. That said, there's always the edge case, and this kind of function is a great solution for those. Thanks!
Seth Kenlon on 14 Aug 2019 PermalinkA few of my "cannot-live-withouts" are regex based:
Decomment removes full-line comments and blank lines. For example, when looking at a "stock" /etc/httpd/whatever.conf file that has a gazillion lines in it,
alias decomment='egrep -v "^[[:space:]]*((#|;|//).*)?$" '
will show you that only four lines in the file actually DO anything, and the gazillion minus four are comments. I use this ALL the time with config files, Python (and other languages) code, and god knows where else.
Then there's unprintables and expletives which are both very similar:
alias unprintable='grep --color="auto" -P -n "[\x00-\x1E]"'
alias expletives='grep --color="auto" -P -n "[^\x00-\x7E]" 'The first shows which lines (with line numbers) in a file contain control characters, and the second shows which lines in a file contain anything "above" a RUBOUT, er, excuse me, I mean above ASCII 127. (I feel old.) ;-) Handy when, for example, someone gives you a program that they edited or created with LibreOffice, and oops... half of the quoted strings have "real" curly opening and closing quote marks instead of ASCII 0x22 "straight" quote mark delimiters... But there's actually a few curlies you want to keep, so a "nuke 'em all in one swell foop" approach won't work.
Dan Jones on 13 Aug 2019 PermalinkThese are great!
Seth Kenlon on 14 Aug 2019 PermalinkYour `cl` function could be simplified, since `cd` without arguments already goes to home.
```
function cl() {
cd "$@" && \
ls -F --color=auto
}
```jkeener on 20 Aug 2019 PermalinkNice!
bhuvana on 04 Oct 2019 PermalinkThe first alias in my .bash_aliases file is always:
alias realias='vim ~/.bash_aliases; source ~/.bash_aliases'
replace vim with your favorite editor or $VISUAL
Thanks for this post! I have created a Github repo- https://github.com/bhuvana-guna/awesome-bash-shortcuts
with a motive to create an extended list of aliases/functions for various programs. As I am a newbie to terminal and linux, please do contribute to it with these and other super awesome utilities and help others easily access them.
Nov 08, 2019 | opensource.com
Your Linux terminal probably supports Unicode, so why not take advantage of that and add a seasonal touch to your prompt? 11 Dec 2018 Jason Baker (Red Hat) Feed 84 up 3 comments Image credits : Jason Baker x Subscribe now
Get the highlights in your inbox every week.
https://opensource.com/eloqua-embedded-email-capture-block.html?offer_id=70160000000QzXNAA0
- Top 7 terminal emulators for Linux
- 10 command-line tools for data analysis in Linux
- Download Now: SSH cheat sheet
- Advanced Linux commands cheat sheet
- Linux command line tutorials
Hello once again for another installment of the Linux command-line toys advent calendar. If this is your first visit to the series, you might be asking yourself what a command-line toy even is? Really, we're keeping it pretty open-ended: It's anything that's a fun diversion at the terminal, and we're giving bonus points for anything holiday-themed.
Maybe you've seen some of these before, maybe you haven't. Either way, we hope you have fun.
Today's toy is super-simple: It's your Bash prompt. Your Bash prompt? Yep! We've got a few more weeks of the holiday season left to stare at it, and even more weeks of winter here in the northern hemisphere, so why not have some fun with it.
Your Bash prompt currently might be a simple dollar sign ( $ ), or more likely, it's something a little longer. If you're not sure what makes up your Bash prompt right now, you can find it in an environment variable called $PS1. To see it, type:
echo $PS1For me, this returns:
[\u@\h \W]\$The \u , \h , and \W are special characters for username, hostname, and working directory. There are others you can use as well; for help building out your Bash prompt, you can use EzPrompt , an online generator of PS1 configurations that includes lots of options including date and time, Git status, and more.
You may have other variables that make up your Bash prompt set as well; $PS2 for me contains the closing brace of my command prompt. See this article for more information.
To change your prompt, simply set the environment variable in your terminal like this:
$ PS1 = '\u is cold: '
jehb is cold:To set it permanently, add the same code to your /etc/bashrc using your favorite text editor.
So what does this have to do with winterization? Well, chances are on a modern machine, your terminal support Unicode, so you're not limited to the standard ASCII character set. You can use any emoji that's a part of the Unicode specification, including a snowflake ❄, a snowman ☃, or a pair of skis 🎿. You've got plenty of wintery options to choose from.
🎄 Christmas Tree
🧥 Coat
🦌 Deer
🧤 Gloves
🤶 Mrs. Claus
🎅 Santa Claus
🧣 Scarf
🎿 Skis
🏂 Snowboarder
❄ Snowflake
☃ Snowman
⛄ Snowman Without Snow
🎁 Wrapped GiftPick your favorite, and enjoy some winter cheer. Fun fact: modern filesystems also support Unicode characters in their filenames, meaning you can technically name your next program "❄❄❄❄❄.py" . That said, please don't.
Do you have a favorite command-line toy that you think I ought to include? The calendar for this series is mostly filled out but I've got a few spots left. Let me know in the comments below, and I'll check it out. If there's space, I'll try to include it. If not, but I get some good submissions, I'll do a round-up of honorable mentions at the end.
Jun 29, 2014 | access.redhat.com
Raw
- The shell prompt is controlled via the PS environment variables.
**PS1** - The value of this parameter is expanded and used as the primary prompt string. The default value is \u@\h \W\\$ . **PS2** - The value of this parameter is expanded as with PS1 and used as the secondary prompt string. The default is ] **PS3** - The value of this parameter is used as the prompt for the select command **PS4** - The value of this parameter is expanded as with PS1 and the value is printed before each command bash displays during an execution trace. The first character of PS4 is replicated multiple times, as necessary, to indicate multiple levels of indirection. The default is +Raw
PS1
is a primary prompt variable which holds\u@\h \W\\$
special bash characters. This is the default structure of the bash prompt and is displayed every time a user logs in using a terminal. These default values are set in the/etc/bashrc
file.- The special characters in the default prompt are as follows:
\u = username \h = hostname \W = current working directoryRaw
- This command will show the current value.
# echo $PS1Raw
- This can be modified by changing the PS1 variable:
# PS1='[[prod]\u@\h \W]\$'Raw
- The modified shell prompt will look like:
[[prod]root@hostname ~]#
- In order to make these settings permanent, edit the
/etc/bashrc
file:Find this line:
Raw[ "$PS1" = "\\s-\\v\\\$ " ] && PS1="[\u@\h \W]\\$ "And change it as needed:
Raw[ "$PS1" = "\\s-\\v\\\$ " ] && PS1="[[prod]\u@\h \W]\\$ "
- Product(s)
- Red Hat Enterprise Linux
- Component
- bash
- Category
- Customize or extend
This solution is part of Red Hat's fast-track publication program, providing a huge library of solutions that Red Hat engineers have created while supporting our customers. To give you the knowledge you need the instant it becomes available, these articles may be presented in a raw and unedited form. 2 Comments Log in to comment
MW Community Member 48 points
6 October 2016 1:53 PM Mike Willis
27 March 2019 12:44 PM Mike ChanslorThis solution has simply "Red Hat Enterprise Linux" in the Environment section implying it applies to all versions of Red Hat Enterprise Linux.
Editing /etc/bashrc is against the advice of the comments in /etc/bashrc on Red Hat Enterprise Linux 7 which say
Raw# It's NOT a good idea to change this file unless you know what you # are doing. It's much better to create a custom.sh shell script in # /etc/profile.d/ to make custom changes to your environment, as this # will prevent the need for merging in future updates.On RHEL 7 instead of the solution suggested above create a /etc/profile.d/custom.sh which contains
RawPS1="[[prod]\u@\h \W]\\$ "Hello Red Hat community! I also found this useful: Raw
Special prompt variable characters: \d The date, in "Weekday Month Date" format (e.g., "Tue May 26"). \h The hostname, up to the first . (e.g. deckard) \H The hostname. (e.g. deckard.SS64.com) \j The number of jobs currently managed by the shell. \l The basename of the shell's terminal device name. \s The name of the shell, the basename of $0 (the portion following the final slash). \t The time, in 24-hour HH:MM:SS format. \T The time, in 12-hour HH:MM:SS format. \@ The time, in 12-hour am/pm format. \u The username of the current user. \v The version of Bash (e.g., 2.00) \V The release of Bash, version + patchlevel (e.g., 2.00.0) \w The current working directory. \W The basename of $PWD. \! The history number of this command. \# The command number of this command. \$ If you are not root, inserts a "$"; if you are root, you get a "#" (root uid = 0) \nnn The character whose ASCII code is the octal value nnn. \n A newline. \r A carriage return. \e An escape character (typically a color code). \a A bell character. \\ A backslash. \[ Begin a sequence of non-printing characters. (like color escape sequences). This allows bash to calculate word wrapping correctly. \] End a sequence of non-printing characters. Using single quotes instead of double quotes when exporting your PS variables is recommended, it makes the prompt a tiny bit faster to evaluate plus you can then do an echo $PS1 to see the current prompt settings.
Nov 08, 2019 | stackoverflow.com
How to escape unicode characters in bash prompt correctly Ask Question Asked 8 years, 2 months ago Active 9 months ago Viewed 6k times 7 2
Andy Ray ,Aug 18, 2011 at 19:08
I have a specific method for my bash prompt, let's say it looks like this:CHAR="༇ " my_function=" prompt=\" \[\$CHAR\]\" echo -e \$prompt" PS1="\$(${my_function}) \$ "To explain the above, I'm builidng my bash prompt by executing a function stored in a string, which was a decision made as the result of this question . Let's pretend like it works fine, because it does, except when unicode characters get involved
I am trying to find the proper way to escape a unicode character, because right now it messes with the bash line length. An easy way to test if it's broken is to type a long command, execute it, press CTRL-R and type to find it, and then pressing CTRL-A CTRL-E to jump to the beginning / end of the line. If the text gets garbled then it's not working.
I have tried several things to properly escape the unicode character in the function string, but nothing seems to be working.
Special characters like this work:
COLOR_BLUE=$(tput sgr0 && tput setaf 6) my_function=" prompt="\\[\$COLOR_BLUE\\] \" echo -e \$prompt"Which is the main reason I made the prompt a function string. That escape sequence does NOT mess with the line length, it's just the unicode character.
Andy Ray ,Aug 23, 2011 at 2:09
The\[...\]
sequence says to ignore this part of the string completely, which is useful when your prompt contains a zero-length sequence, such as a control sequence which changes the text color or the title bar, say. But in this case, you are printing a character, so the length of it is not zero. Perhaps you could work around this by, say, using a no-op escape sequence to fool Bash into calculating the correct line length, but it sounds like that way lies madness.The correct solution would be for the line length calculations in Bash to correctly grok UTF-8 (or whichever Unicode encoding it is that you are using). Uhm, have you tried without the
\[...\]
sequence?Edit: The following implements the solution I propose in the comments below. The cursor position is saved, then two spaces are printed, outside of
\[...\]
, then the cursor position is restored, and the Unicode character is printed on top of the two spaces. This assumes a fixed font width, with double width for the Unicode character.PS1='\['"`tput sc`"'\] \['"`tput rc`"'༇ \] \$ 'At least in the OSX Terminal, Bash 3.2.17(1)-release, this passes cursory [sic] testing.
In the interest of transparency and legibility, I have ignored the requirement to have the prompt's functionality inside a function, and the color coding; this just changes the prompt to the character, space, dollar prompt, space. Adapt to suit your somewhat more complex needs.
tripleee ,Aug 23, 2011 at 7:01
@tripleee wins it, posting the final solution here because it's a pain to post code in comments:CHAR="༇" my_function=" prompt=\" \\[`tput sc`\\] \\[`tput rc`\\]\\[\$CHAR\\] \" echo -e \$prompt" PS1="\$(${my_function}) \$ "The trick as pointed out in @tripleee's link is the use of the commands
tput sc
andtput rc
which save and then restore the cursor position. The code is effectively saving the cursor position, printing two spaces for width, restoring the cursor position to before the spaces, then printing the special character so that the width of the line is from the two spaces, not the character.> ,
(Not the answer to your problem, but some pointers and general experience related to your issue.)I see the behaviour you describe about cmd-line editing (Ctrl-R, ... Cntrl-A Ctrl-E ...) all the time, even without unicode chars.
At one work-site, I spent the time to figure out the diff between the terminals interpretation of the TERM setting VS the TERM definition used by the OS (well, stty I suppose).
NOW, when I have this problem, I escape out of my current attempt to edit the line, bring the line up again, and then immediately go to the 'vi' mode, which opens the vi editor. (press just the 'v' char, right?). All the ease of use of a full-fledged session of vi; why go with less ;-)?
Looking again at your problem description, when you say
my_function=" prompt=\" \[\$CHAR\]\" echo -e \$prompt"That is just a string definition, right? and I'm assuming your simplifying the problem definition by assuming this is the output of your
my_function
. It seems very likely in the steps of creating the function definition, calling the function AND using the values returned are a lot of opportunities for shell-quoting to not work the way you want it to.If you edit your question to include the
my_function
definition, and its complete use (reducing your function to just what is causing the problem), it may be easier for others to help with this too. Finally, do you useset -vx
regularly? It can help show how/wnen/what of variable expansions, you may find something there.Failing all of those, look at Orielly termcap & terminfo . You may need to look at the man page for your local systems
stty
and related cmds AND you may do well to look for user groups specific to you Linux system (I'm assuming you use a Linux variant).I hope this helps.
Oct 23, 2019 | www.ostechnix.com
Let us take the following one-liner Linux command as an example.
$ find . -size +10M -type f -print0 | xargs -0 ls -Ssh | sort -zFor those wondering, the above command will find and list files bigger than 10 MB in the current directory and sort them by size. I admit that I couldn't remember this command. I guess some of you can't remember this command either. This is why we are going to apply a tag to such kind of commands.
To apply a tag, just type the command and add the comment ( i.e. tag) at the end of the command as shown below.
$ find . -size +10M -type f -print0 | xargs -0 ls -Ssh | sort -z #ListFilesBiggerThanXSizeHere, #ListFilesBiggerThanXSize is the tag name to the above command. Make sure you have given a space between the command and tag name. Also, please use the tag name as simple, short and clear as possible to easily remember it later. Otherwise, you may need another tool to recall the tags.
To run it again, simply use the tag name like below.
$ !? #ListFilesBiggerThanXSizeHere, the ! (Exclamation mark) and ? (Question mark) operators are used to fetch and run the command which we tagged earlier from the BASH history.
Sep 11, 2019 | stackoverflow.com
Jeff ,May 8 at 18:30
Given a filename in the formsomeletters_12345_moreleters.ext
, I want to extract the 5 digits and put them into a variable.So to emphasize the point, I have a filename with x number of characters then a five digit sequence surrounded by a single underscore on either side then another set of x number of characters. I want to take the 5 digit number and put that into a variable.
I am very interested in the number of different ways that this can be accomplished.
Berek Bryan ,Jan 24, 2017 at 9:30
Use cut :echo 'someletters_12345_moreleters.ext' | cut -d'_' -f 2More generic:
INPUT='someletters_12345_moreleters.ext' SUBSTRING=$(echo $INPUT| cut -d'_' -f 2) echo $SUBSTRINGJB. ,Jan 6, 2015 at 10:13
If x is constant, the following parameter expansion performs substring extraction:b=${a:12:5}where 12 is the offset (zero-based) and 5 is the length
If the underscores around the digits are the only ones in the input, you can strip off the prefix and suffix (respectively) in two steps:
tmp=${a#*_} # remove prefix ending in "_" b=${tmp%_*} # remove suffix starting with "_"If there are other underscores, it's probably feasible anyway, albeit more tricky. If anyone knows how to perform both expansions in a single expression, I'd like to know too.
Both solutions presented are pure bash, with no process spawning involved, hence very fast.
A Sahra ,Mar 16, 2017 at 6:27
Generic solution where the number can be anywhere in the filename, using the first of such sequences:number=$(echo $filename | egrep -o '[[:digit:]]{5}' | head -n1)Another solution to extract exactly a part of a variable:
number=${filename:offset:length}If your filename always have the format
stuff_digits_...
you can use awk:number=$(echo $filename | awk -F _ '{ print $2 }')Yet another solution to remove everything except digits, use
number=$(echo $filename | tr -cd '[[:digit:]]')sshow ,Jul 27, 2017 at 17:22
In case someone wants more rigorous information, you can also search it in man bash like this$ man bash [press return key] /substring [press return key] [press "n" key] [press "n" key] [press "n" key] [press "n" key]Result:
${parameter:offset} ${parameter:offset:length} Substring Expansion. Expands to up to length characters of parameter starting at the character specified by offset. If length is omitted, expands to the substring of parameter start‐ ing at the character specified by offset. length and offset are arithmetic expressions (see ARITHMETIC EVALUATION below). If offset evaluates to a number less than zero, the value is used as an offset from the end of the value of parameter. Arithmetic expressions starting with a - must be separated by whitespace from the preceding : to be distinguished from the Use Default Values expansion. If length evaluates to a number less than zero, and parameter is not @ and not an indexed or associative array, it is interpreted as an offset from the end of the value of parameter rather than a number of characters, and the expan‐ sion is the characters between the two offsets. If parameter is @, the result is length positional parameters beginning at off‐ set. If parameter is an indexed array name subscripted by @ or *, the result is the length members of the array beginning with ${parameter[offset]}. A negative offset is taken relative to one greater than the maximum index of the specified array. Sub‐ string expansion applied to an associative array produces unde‐ fined results. Note that a negative offset must be separated from the colon by at least one space to avoid being confused with the :- expansion. Substring indexing is zero-based unless the positional parameters are used, in which case the indexing starts at 1 by default. If offset is 0, and the positional parameters are used, $0 is prefixed to the list.Aleksandr Levchuk ,Aug 29, 2011 at 5:51
Building on jor's answer (which doesn't work for me):substring=$(expr "$filename" : '.*_\([^_]*\)_.*')kayn ,Oct 5, 2015 at 8:48
I'm surprised this pure bash solution didn't come up:a="someletters_12345_moreleters.ext" IFS="_" set $a echo $2 # prints 12345You probably want to reset IFS to what value it was before, or
unset IFS
afterwards!zebediah49 ,Jun 4 at 17:31
Here's how i'd do it:FN=someletters_12345_moreleters.ext [[ ${FN} =~ _([[:digit:]]{5})_ ]] && NUM=${BASH_REMATCH[1]}Note: the above is a regular expression and is restricted to your specific scenario of five digits surrounded by underscores. Change the regular expression if you need different matching.
TranslucentCloud ,Jun 16, 2014 at 13:27
Following the requirementsI have a filename with x number of characters then a five digit sequence surrounded by a single underscore on either side then another set of x number of characters. I want to take the 5 digit number and put that into a variable.
I found some
grep
ways that may be useful:$ echo "someletters_12345_moreleters.ext" | grep -Eo "[[:digit:]]+" 12345or better
$ echo "someletters_12345_moreleters.ext" | grep -Eo "[[:digit:]]{5}" 12345And then with
-Po
syntax:$ echo "someletters_12345_moreleters.ext" | grep -Po '(?<=_)\d+' 12345Or if you want to make it fit exactly 5 characters:
$ echo "someletters_12345_moreleters.ext" | grep -Po '(?<=_)\d{5}' 12345Finally, to make it be stored in a variable it is just need to use the
var=$(command)
syntax.Darron ,Jan 9, 2009 at 16:13
Without any sub-processes you can:shopt -s extglob front=${input%%_+([a-zA-Z]).*} digits=${front##+([a-zA-Z])_}A very small variant of this will also work in ksh93.
user2350426
add a comment ,Aug 5, 2014 at 8:11
If we focus in the concept of:
"A run of (one or several) digits"We could use several external tools to extract the numbers.
We could quite easily erase all other characters, either sed or tr:
name='someletters_12345_moreleters.ext' echo $name | sed 's/[^0-9]*//g' # 12345 echo $name | tr -c -d 0-9 # 12345But if $name contains several runs of numbers, the above will fail:
If "name=someletters_12345_moreleters_323_end.ext", then:
echo $name | sed 's/[^0-9]*//g' # 12345323 echo $name | tr -c -d 0-9 # 12345323We need to use regular expresions (regex).
To select only the first run (12345 not 323) in sed and perl:echo $name | sed 's/[^0-9]*\([0-9]\{1,\}\).*$/\1/' perl -e 'my $name='$name';my ($num)=$name=~/(\d+)/;print "$num\n";'But we could as well do it directly in bash (1) :
regex=[^0-9]*([0-9]{1,}).*$; \ [[ $name =~ $regex ]] && echo ${BASH_REMATCH[1]}This allows us to extract the FIRST run of digits of any length
surrounded by any other text/characters.Note :
regex=[^0-9]*([0-9]{5,5}).*$;
will match only exactly 5 digit runs. :-)(1) : faster than calling an external tool for each short texts. Not faster than doing all processing inside sed or awk for large files.
codist ,May 6, 2011 at 12:50
Here's a prefix-suffix solution (similar to the solutions given by JB and Darron) that matches the first block of digits and does not depend on the surrounding underscores:str='someletters_12345_morele34ters.ext' s1="${str#"${str%%[[:digit:]]*}"}" # strip off non-digit prefix from str s2="${s1%%[^[:digit:]]*}" # strip off non-digit suffix from s1 echo "$s2" # 12345Campa ,Oct 21, 2016 at 8:12
I lovesed
's capability to deal with regex groups:> var="someletters_12345_moreletters.ext" > digits=$( echo $var | sed "s/.*_\([0-9]\+\).*/\1/p" -n ) > echo $digits 12345A slightly more general option would be not to assume that you have an underscore
_
marking the start of your digits sequence, hence for instance stripping off all non-numbers you get before your sequence:s/[^0-9]\+\([0-9]\+\).*/\1/p
.
> man sed | grep s/regexp/replacement -A 2 s/regexp/replacement/ Attempt to match regexp against the pattern space. If successful, replace that portion matched with replacement. The replacement may contain the special character & to refer to that portion of the pattern space which matched, and the special escapes \1 through \9 to refer to the corresponding matching sub-expressions in the regexp.
More on this, in case you're not too confident with regexps:
s
is for _s_ubstitute[0-9]+
matches 1+ digits\1
links to the group n.1 of the regex output (group 0 is the whole match, group 1 is the match within parentheses in this case)p
flag is for _p_rintingAll escapes
\
are there to makesed
's regexp processing work.Dan Dascalescu ,May 8 at 18:28
Given test.txt is a file containing "ABCDEFGHIJKLMNOPQRSTUVWXYZ"cut -b19-20 test.txt > test1.txt # This will extract chars 19 & 20 "ST" while read -r; do; > x=$REPLY > done < test1.txt echo $x STAlex Raj Kaliamoorthy ,Jul 29, 2016 at 7:41
My answer will have more control on what you want out of your string. Here is the code on how you can extract12345
out of your stringstr="someletters_12345_moreleters.ext" str=${str#*_} str=${str%_more*} echo $strThis will be more efficient if you want to extract something that has any chars like
abc
or any special characters like_
or-
. For example: If your string is like this and you want everything that is aftersomeletters_
and before_moreleters.ext
:str="someletters_123-45-24a&13b-1_moreleters.ext"With my code you can mention what exactly you want. Explanation:
#*
It will remove the preceding string including the matching key. Here the key we mentioned is_
%
It will remove the following string including the matching key. Here the key we mentioned is '_more*'Do some experiments yourself and you would find this interesting.
Dan Dascalescu ,May 8 at 18:27
similar to substr('abcdefg', 2-1, 3) in php:echo 'abcdefg'|tail -c +2|head -c 3olibre ,Nov 25, 2015 at 14:50
Ok, here goes pure Parameter Substitution with an empty string. Caveat is that I have defined someletters and moreletters as only characters. If they are alphanumeric, this will not work as it is.filename=someletters_12345_moreletters.ext substring=${filename//@(+([a-z])_|_+([a-z]).*)} echo $substring 12345gniourf_gniourf ,Jun 4 at 17:33
There's also the bash builtin 'expr' command:INPUT="someletters_12345_moreleters.ext" SUBSTRING=`expr match "$INPUT" '.*_\([[:digit:]]*\)_.*' ` echo $SUBSTRINGrussell ,Aug 1, 2013 at 8:12
A little late, but I just ran across this problem and found the following:host:/tmp$ asd=someletters_12345_moreleters.ext host:/tmp$ echo `expr $asd : '.*_\(.*\)_'` 12345 host:/tmp$I used it to get millisecond resolution on an embedded system that does not have %N for date:
set `grep "now at" /proc/timer_list` nano=$3 fraction=`expr $nano : '.*\(...\)......'` $debug nano is $nano, fraction is $fraction> ,Aug 5, 2018 at 17:13
A bash solution:IFS="_" read -r x digs x <<<'someletters_12345_moreleters.ext'This will clobber a variable called
x
. The varx
could be changed to the var_
.input='someletters_12345_moreleters.ext' IFS="_" read -r _ digs _ <<<"$input"
Sep 08, 2019 | stackoverflow.com
Ask Question Asked 9 years, 4 months ago Active 2 months ago Viewed 226k times 238 127
Mark Byers ,Apr 25, 2010 at 19:20
Can anyone recommend a safe solution to recursively replace spaces with underscores in file and directory names starting from a given root directory? For example:$ tree . |-- a dir | `-- file with spaces.txt `-- b dir |-- another file with spaces.txt `-- yet another file with spaces.pdfbecomes:
$ tree . |-- a_dir | `-- file_with_spaces.txt `-- b_dir |-- another_file_with_spaces.txt `-- yet_another_file_with_spaces.pdfJürgen Hötzel ,Nov 4, 2015 at 3:03
Userename
(akaprename
) which is a Perl script which may be on your system already. Do it in two steps:find -name "* *" -type d | rename 's/ /_/g' # do the directories first find -name "* *" -type f | rename 's/ /_/g'Based on Jürgen's answer and able to handle multiple layers of files and directories in a single bound using the "Revision 1.5 1998/12/18 16:16:31 rmb1" version of
/usr/bin/rename
(a Perl script):find /tmp/ -depth -name "* *" -execdir rename 's/ /_/g' "{}" \;oevna ,Jan 1, 2016 at 8:25
I use:for f in *\ *; do mv "$f" "${f// /_}"; doneThough it's not recursive, it's quite fast and simple. I'm sure someone here could update it to be recursive.
The
${f// /_}
part utilizes bash's parameter expansion mechanism to replace a pattern within a parameter with supplied string. The relevant syntax is${parameter/pattern/string}
. See: https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html or http://wiki.bash-hackers.org/syntax/pe .armandino ,Dec 3, 2013 at 20:51
find . -depth -name '* *' \ | while IFS= read -r f ; do mv -i "$f" "$(dirname "$f")/$(basename "$f"|tr ' ' _)" ; donefailed to get it right at first, because I didn't think of directories.
Edmund Elmer ,Jul 3 at 7:12
you can usedetox
by Doug Harpledetox -r <folder>Dennis Williamson ,Mar 22, 2012 at 20:33
A find/rename solution. rename is part of util-linux.You need to descend depth first, because a whitespace filename can be part of a whitespace directory:
find /tmp/ -depth -name "* *" -execdir rename " " "_" "{}" ";"armandino ,Apr 26, 2010 at 11:49
bash 4.0#!/bin/bash shopt -s globstar for file in **/*\ * do mv "$file" "${file// /_}" doneItamar ,Jan 31, 2013 at 21:27
you can use this:find . -name '* *' | while read fname do new_fname=`echo $fname | tr " " "_"` if [ -e $new_fname ] then echo "File $new_fname already exists. Not replacing $fname" else echo "Creating new file $new_fname to replace $fname" mv "$fname" $new_fname fi doneyabt ,Apr 26, 2010 at 14:54
Here's a (quite verbose) find -exec solution which writes "file already exists" warnings to stderr:function trspace() { declare dir name bname dname newname replace_char [ $# -lt 1 -o $# -gt 2 ] && { echo "usage: trspace dir char"; return 1; } dir="${1}" replace_char="${2:-_}" find "${dir}" -xdev -depth -name $'*[ \t\r\n\v\f]*' -exec bash -c ' for ((i=1; i<=$#; i++)); do name="${@:i:1}" dname="${name%/*}" bname="${name##*/}" newname="${dname}/${bname//[[:space:]]/${0}}" if [[ -e "${newname}" ]]; then echo "Warning: file already exists: ${newname}" 1>&2 else mv "${name}" "${newname}" fi done ' "${replace_char}" '{}' + } trspace rootdir _degi ,Aug 8, 2011 at 9:10
This one does a little bit more. I use it to rename my downloaded torrents (no special characters (non-ASCII), spaces, multiple dots, etc.).#!/usr/bin/perl &rena(`find . -type d`); &rena(`find . -type f`); sub rena { ($elems)=@_; @t=split /\n/,$elems; for $e (@t) { $_=$e; # remove ./ of find s/^\.\///; # non ascii transliterate tr [\200-\377][_]; tr [\000-\40][_]; # special characters we do not want in paths s/[ \-\,\;\?\+\'\"\!\[\]\(\)\@\#]/_/g; # multiple dots except for extension while (/\..*\./) { s/\./_/; } # only one _ consecutive s/_+/_/g; next if ($_ eq $e ) or ("./$_" eq $e); print "$e -> $_\n"; rename ($e,$_); } }Junyeop Lee ,Apr 10, 2018 at 9:44
Recursive version of Naidim's Answers.find . -name "* *" | awk '{ print length, $0 }' | sort -nr -s | cut -d" " -f2- | while read f; do base=$(basename "$f"); newbase="${base// /_}"; mv "$(dirname "$f")/$(basename "$f")" "$(dirname "$f")/$newbase"; doneghoti ,Dec 5, 2016 at 21:16
I found around this script, it may be interesting :)IFS=$'\n';for f in `find .`; do file=$(echo $f | tr [:blank:] '_'); [ -e $f ] && [ ! -e $file ] && mv "$f" $file;done;unset IFSghoti ,Dec 5, 2016 at 21:17
Here's a reasonably sized bash script solution#!/bin/bash ( IFS=$'\n' for y in $(ls $1) do mv $1/`echo $y | sed 's/ /\\ /g'` $1/`echo "$y" | sed 's/ /_/g'` done )user1060059 ,Nov 22, 2011 at 15:15
This only finds files inside the current directory and renames them . I have this aliased.
find ./ -name "* *" -type f -d 1 | perl -ple '$file = $_; $file =~ s/\s+/_/g; rename($_, $file);
Hongtao ,Sep 26, 2014 at 19:30
I just make one for my own purpose. You may can use it as reference.#!/bin/bash cd /vzwhome/c0cheh1/dev_source/UB_14_8 for file in * do echo $file cd "/vzwhome/c0cheh1/dev_source/UB_14_8/$file/Configuration/$file" echo "==> `pwd`" for subfile in *\ *; do [ -d "$subfile" ] && ( mv "$subfile" "$(echo $subfile | sed -e 's/ /_/g')" ); done ls cd /vzwhome/c0cheh1/dev_source/UB_14_8 doneMarcos Jean Sampaio ,Dec 5, 2016 at 20:56
For files in folder named /filesfor i in `IFS="";find /files -name *\ *` do echo $i done > /tmp/list while read line do mv "$line" `echo $line | sed 's/ /_/g'` done < /tmp/list rm /tmp/listMuhammad Annaqeeb ,Sep 4, 2017 at 11:03
For those struggling through this using macOS, first install all the tools:brew install tree findutils renameThen when needed to rename, make an alias for GNU find (gfind) as find. Then run the code of @Michel Krelin:
alias find=gfind find . -depth -name '* *' \ | while IFS= read -r f ; do mv -i "$f" "$(dirname "$f")/$(basename "$f"|tr ' ' _)" ; done
Sep 05, 2019 | linuxconfig.org
05 September 2019
... ... ... How to use other Bash optionsThe Bash options for debugging are turned off by default, but once they are turned on by using the set command, they stay on until explicitly turned off. If you are not sure which options are enabled, you can examine the
$-
variable to see the current state of all the variables.$ echo $- himBHs $ set -xv && echo $- himvxBHsThere is another useful switch we can use to help us find variables referenced without having any value set. This is the
<img src=https://linuxconfig.org/images/02-how-to-debug-bash-scripts.png alt="set u option at command line" width=1200 height=254 /> Setting-u
switch, and just like-x
and-v
it can also be used on the command line, as we see in the following example:u
option at the command lineWe mistakenly assigned a value of 7 to the variable called "level" then tried to echo a variable named "score" that simply resulted in printing nothing at all to the screen. Absolutely no debug information was given. Setting our
-u
switch allows us to see a specific error message, "score: unbound variable" that indicates exactly what went wrong.We can use those options in short Bash scripts to give us debug information to identify problems that do not otherwise trigger feedback from the Bash interpreter. Let's walk through a couple of examples.
#!/bin/bash read -p "Path to be added: " $path if [ "$path" = "/home/mike/bin" ]; then echo $path >> $PATH echo "new path: $PATH" else echo "did not modify PATH" fi<img src=https://linuxconfig.org/images/03-how-to-debug-bash-scripts.png alt="results from addpath script" width=1200 height=417 /> Usingx
option when running your Bash scriptIn the example above we run the addpath script normally and it simply does not modify our
PATH
. It does not give us any indication of why or clues to mistakes made. Running it again using the-x
option clearly shows us that the left side of our comparison is an empty string.$path
is an empty string because we accidentally put a dollar sign in front of "path" in our read statement. Sometimes we look right at a mistake like this and it doesn't look wrong until we get a clue and think, "Why is$path
evaluated to an empty string?"Looking this next example, we also get no indication of an error from the interpreter. We only get one value printed per line instead of two. This is not an error that will halt execution of the script, so we're left to simply wonder without being given any clues. Using the
-u
switch,we immediately get a notification that our variablej
is not bound to a value. So these are real time savers when we make mistakes that do not result in actual errors from the Bash interpreter's point of view.#!/bin/bash for i in 1 2 3 do echo $i $j done<img src=https://linuxconfig.org/images/04-how-to-debug-bash-scripts.png alt="results from count.sh script" width=1200 height=291 /> Usingu
option running your script from the command lineNow surely you are thinking that sounds fine, but we seldom need help debugging mistakes made in one-liners at the command line or in short scripts like these. We typically struggle with debugging when we deal with longer and more complicated scripts, and we rarely need to set these options and leave them set while we run multiple scripts. Setting
-xv
options and then running a more complex script will often add confusion by doubling or tripling the amount of output generated.Fortunately we can use these options in a more precise way by placing them inside our scripts. Instead of explicitly invoking a Bash shell with an option from the command line, we can set an option by adding it to the shebang line instead.
#!/bin/bash -xThis will set the
-x
option for the entire file or until it is unset during the script execution, allowing you to simply run the script by typing the filename instead of passing it to Bash as a parameter. A long script or one that has a lot of output will still become unwieldy using this technique however, so let's look at a more specific way to use options.
For a more targeted approach, surround only the suspicious blocks of code with the options you want. This approach is great for scripts that generate menus or detailed output, and it is accomplished by using the set keyword with plus or minus once again.
#!/bin/bash read -p "Path to be added: " $path set -xv if [ "$path" = "/home/mike/bin" ]; then echo $path >> $PATH echo "new path: $PATH" else echo "did not modify PATH" fi set +xv<img src=https://linuxconfig.org/images/05-how-to-debug-bash-scripts.png alt="results from addpath script" width=1200 height=469 /> Wrapping options around a block of code in your scriptWe surrounded only the blocks of code we suspect in order to reduce the output, making our task easier in the process. Notice we turn on our options only for the code block containing our if-then-else statement, then turn off the option(s) at the end of the suspect block. We can turn these options on and off multiple times in a single script if we can't narrow down the suspicious areas, or if we want to evaluate the state of variables at various points as we progress through the script. There is no need to turn off an option If we want it to continue for the remainder of the script execution.
For completeness sake we should mention also that there are debuggers written by third parties that will allow us to step through the code execution line by line. You might want to investigate these tools, but most people find that that they are not actually needed.
As seasoned programmers will suggest, if your code is too complex to isolate suspicious blocks with these options then the real problem is that the code should be refactored. Overly complex code means bugs can be difficult to detect and maintenance can be time consuming and costly.
One final thing to mention regarding Bash debugging options is that a file globbing option also exists and is set with
-f
. Setting this option will turn off globbing (expansion of wildcards to generate file names) while it is enabled. This-f
option can be a switch used at the command line with bash, after the shebang in a file or, as in this example to surround a block of code.#!/bin/bash echo "ignore fileglobbing option turned off" ls * echo "ignore file globbing option set" set -f ls * set +f<img src=https://linuxconfig.org/images/06-how-to-debug-bash-scripts.png alt="results from -f option" width=1200 height=314 /> Usingf
option to turn off file globbing How to use trap to help debugThere are more involved techniques worth considering if your scripts are complicated, including using an assert function as mentioned earlier. One such method to keep in mind is the use of trap. Shell scripts allow us to trap signals and do something at that point.
A simple but useful example you can use in your Bash scripts is to trap on
EXIT
.#!/bin/bash trap 'echo score is $score, status is $status' EXIT if [ -z ]; then status="default" else status= fi score=0 if [ ${USER} = 'superman' ]; then score=99 elif [ $# -gt 1 ]; then score= fi<img src=https://linuxconfig.org/images/07-how-to-debug-bash-scripts.png alt="results from using trap EXIT" width=1200 height=469 /> Using trapEXIT
to help debug your script
As you can see just dumping the current values of variables to the screen can be useful to show where your logic is failing. The
EXIT
signal obviously does not need an explicitexit
statement to be generated; in this case theecho
statement is executed when the end of the script is reached.Another useful trap to use with Bash scripts is
DEBUG
. This happens after every statement, so it can be used as a brute force way to show the values of variables at each step in the script execution.#!/bin/bash trap 'echo "line ${LINENO}: score is $score"' DEBUG score=0 if [ "${USER}" = "mike" ]; then let "score += 1" fi let "score += 1" if [ "" = "7" ]; then score=7 fi exit 0<img src=https://linuxconfig.org/images/08-how-to-debug-bash-scripts.png alt="results from using trap DEBUG" width=1200 height=469 /> Using trapDEBUG
to help debug your script ConclusionWhen you notice your Bash script not behaving as expected and the reason is not clear to you for whatever reason, consider what information would be useful to help you identify the cause then use the most comfortable tools available to help you pinpoint the issue. The xtrace option
-x
is easy to use and probably the most useful of the options presented here, so consider trying it out next time you're faced with a script that's not doing what you thought it would
Jun 30, 2019 | www.putorius.net
If you want to match the pattern regardless of it's case (Capital letters or lowercase letters) you can set the nocasematch shell option with the shopt builtin. You can do this as the first line of your script. Since the script will run in a subshell it won't effect your normal environment.
#!/bin/bash shopt -s nocasematch read -p "Name a Star Trek character: " CHAR case $CHAR in "Seven of Nine" | Neelix | Chokotay | Tuvok | Janeway ) echo "$CHAR was in Star Trek Voyager" ;;& Archer | Phlox | Tpol | Tucker ) echo "$CHAR was in Star Trek Enterprise" ;;& Odo | Sisko | Dax | Worf | Quark ) echo "$CHAR was in Star Trek Deep Space Nine" ;;& Worf | Data | Riker | Picard ) echo "$CHAR was in Star Trek The Next Generation" && echo "/etc/redhat-release" ;; *) echo "$CHAR is not in this script." ;; esac
Jul 29, 2017 | stackoverflow.com
getmizanur , asked Sep 10 '11 at 20:35
Is there any directory bookmarking utility for bash to allow move around faster on the command line?UPDATE
Thanks guys for the feedback however I created my own simple shell script (feel free to modify/expand it)
function cdb() { USAGE="Usage: cdb [-c|-g|-d|-l] [bookmark]" ; if [ ! -e ~/.cd_bookmarks ] ; then mkdir ~/.cd_bookmarks fi case $1 in # create bookmark -c) shift if [ ! -f ~/.cd_bookmarks/$1 ] ; then echo "cd `pwd`" > ~/.cd_bookmarks/"$1" ; else echo "Try again! Looks like there is already a bookmark '$1'" fi ;; # goto bookmark -g) shift if [ -f ~/.cd_bookmarks/$1 ] ; then source ~/.cd_bookmarks/"$1" else echo "Mmm...looks like your bookmark has spontaneously combusted. What I mean to say is that your bookmark does not exist." ; fi ;; # delete bookmark -d) shift if [ -f ~/.cd_bookmarks/$1 ] ; then rm ~/.cd_bookmarks/"$1" ; else echo "Oops, forgot to specify the bookmark" ; fi ;; # list bookmarks -l) shift ls -l ~/.cd_bookmarks/ ; ;; *) echo "$USAGE" ; ;; esac }INSTALL
1./ create a file ~/.cdb and copy the above script into it.
2./ in your ~/.bashrc add the following
if [ -f ~/.cdb ]; then source ~/.cdb fi3./ restart your bash session
USAGE
1./ to create a bookmark
$cd my_project $cdb -c project12./ to goto a bookmark
$cdb -g project13./ to list bookmarks
$cdb -l4./ to delete a bookmark
$cdb -d project15./ where are all my bookmarks stored?
$cd ~/.cd_bookmarksFredrik Pihl , answered Sep 10 '11 at 20:47
Also, have a look at CDPATHA colon-separated list of search paths available to the cd command, similar in function to the $PATH variable for binaries. The $CDPATH variable may be set in the local ~/.bashrc file.
ash$ cd bash-doc bash: cd: bash-doc: No such file or directory bash$ CDPATH=/usr/share/doc bash$ cd bash-doc /usr/share/doc/bash-doc bash$ echo $PWD /usr/share/doc/bash-docand
cd -It's the command-line equivalent of the back button (takes you to the previous directory you were in).
ajreal , answered Sep 10 '11 at 20:41
In bash script/command,
you can usepushd
andpopd
Save and then change the current directory. With no arguments, pushd exchanges the top two directories.
Usage
cd /abc pushd /xxx <-- save /abc to environment variables and cd to /xxx pushd /zzz pushd +1 <-- cd /xxxpopd is to remove the variable (reverse manner)
fgm , answered Sep 11 '11 at 8:28
bookmarks.sh provides a bookmark management system for the Bash version 4.0+. It can also use a Midnight Commander hotlist.Dmitry Frank , answered Jun 16 '15 at 10:22
Thanks for sharing your solution, and I'd like to share mine as well, which I find more useful than anything else I've came across before.The engine is a great, universal tool: command-line fuzzy finder by Junegunn.
It primarily allows you to "fuzzy-find" files in a number of ways, but it also allows to feed arbitrary text data to it and filter this data. So, the shortcuts idea is simple: all we need is to maintain a file with paths (which are shortcuts), and fuzzy-filter this file. Here's how it looks: we type
cdg
command (from "cd global", if you like), get a list of our bookmarks, pick the needed one in just a few keystrokes, and press Enter. Working directory is changed to the picked item:It is extremely fast and convenient: usually I just type 3-4 letters of the needed item, and all others are already filtered out. Additionally, of course we can move through list with arrow keys or with vim-like keybindings
Ctrl+j
/Ctrl+k
.Article with details: Fuzzy shortcuts for your shell .
It is possible to use it for GUI applications as well (via xterm): I use that for my GUI file manager Double Commander . I have plans to write an article about this use case, too.
return42 , answered Feb 6 '15 at 11:56
Inspired by the question and answers here, I added the lines below to my~/.bashrc
file.With this you have a
favdir
command (function) to manage your favorites and a autocompletion function to select an item from these favorites.# --------- # Favorites # --------- __favdirs_storage=~/.favdirs __favdirs=( "$HOME" ) containsElement () { local e for e in "${@:2}"; do [[ "$e" == "$1" ]] && return 0; done return 1 } function favdirs() { local cur local IFS local GLOBIGNORE case $1 in list) echo "favorite folders ..." printf -- ' - %s\n' "${__favdirs[@]}" ;; load) if [[ ! -e $__favdirs_storage ]] ; then favdirs save fi # mapfile requires bash 4 / my OS-X bash vers. is 3.2.53 (from 2007 !!?!). # mapfile -t __favdirs < $__favdirs_storage IFS=$'\r\n' GLOBIGNORE='*' __favdirs=($(< $__favdirs_storage)) ;; save) printf -- '%s\n' "${__favdirs[@]}" > $__favdirs_storage ;; add) cur=${2-$(pwd)} favdirs load if containsElement "$cur" "${__favdirs[@]}" ; then echo "'$cur' allready exists in favorites" else __favdirs+=( "$cur" ) favdirs save echo "'$cur' added to favorites" fi ;; del) cur=${2-$(pwd)} favdirs load local i=0 for fav in ${__favdirs[@]}; do if [ "$fav" = "$cur" ]; then echo "delete '$cur' from favorites" unset __favdirs[$i] favdirs save break fi let i++ done ;; *) echo "Manage favorite folders." echo "" echo "usage: favdirs [ list | load | save | add | del ]" echo "" echo " list : list favorite folders" echo " load : load favorite folders from $__favdirs_storage" echo " save : save favorite directories to $__favdirs_storage" echo " add : add directory to favorites [default pwd $(pwd)]." echo " del : delete directory from favorites [default pwd $(pwd)]." esac } && favdirs load function __favdirs_compl_command() { COMPREPLY=( $( compgen -W "list load save add del" -- ${COMP_WORDS[COMP_CWORD]})) } && complete -o default -F __favdirs_compl_command favdirs function __favdirs_compl() { local IFS=$'\n' COMPREPLY=( $( compgen -W "${__favdirs[*]}" -- ${COMP_WORDS[COMP_CWORD]})) } alias _cd='cd' complete -F __favdirs_compl _cdWithin the last two lines, an alias to change the current directory (with autocompletion) is created. With this alias (
_cd
) you are able to change to one of your favorite directories. May you wan't to change this alias to something which fits your needs .With the function
favdirs
you can manage your favorites (see usage).$ favdirs Manage favorite folders. usage: favdirs [ list | load | save | add | del ] list : list favorite folders load : load favorite folders from ~/.favdirs save : save favorite directories to ~/.favdirs add : add directory to favorites [default pwd /tmp ]. del : delete directory from favorites [default pwd /tmp ].Zied , answered Mar 12 '14 at 9:53
Yes there is DirB: Directory Bookmarks for Bash well explained in this Linux Journal articleAn example from the article:
% cd ~/Desktop % s d # save(bookmark) ~/Desktop as d % cd /tmp # go somewhere % pwd /tmp % g d # go to the desktop % pwd /home/DesktopAl Conrad , answered Sep 4 '15 at 16:10
@getmizanur I used your cdb script. I enhanced it slightly by adding bookmarks tab completion. Here's my version of your cdb script._cdb() { local _script_commands=$(ls -1 ~/.cd_bookmarks/) local cur=${COMP_WORDS[COMP_CWORD]} COMPREPLY=( $(compgen -W "${_script_commands}" -- $cur) ) } complete -F _cdb cdb function cdb() { local USAGE="Usage: cdb [-h|-c|-d|-g|-l|-s] [bookmark]\n \t[-h or no args] - prints usage help\n \t[-c bookmark] - create bookmark\n \t[-d bookmark] - delete bookmark\n \t[-g bookmark] - goto bookmark\n \t[-l] - list bookmarks\n \t[-s bookmark] - show bookmark location\n \t[bookmark] - same as [-g bookmark]\n Press tab for bookmark completion.\n" if [ ! -e ~/.cd_bookmarks ] ; then mkdir ~/.cd_bookmarks fi case $1 in # create bookmark -c) shift if [ ! -f ~/.cd_bookmarks/$1 ] ; then echo "cd `pwd`" > ~/.cd_bookmarks/"$1" complete -F _cdb cdb else echo "Try again! Looks like there is already a bookmark '$1'" fi ;; # goto bookmark -g) shift if [ -f ~/.cd_bookmarks/$1 ] ; then source ~/.cd_bookmarks/"$1" else echo "Mmm...looks like your bookmark has spontaneously combusted. What I mean to say is that your bookmark does not exist." ; fi ;; # show bookmark -s) shift if [ -f ~/.cd_bookmarks/$1 ] ; then cat ~/.cd_bookmarks/"$1" else echo "Mmm...looks like your bookmark has spontaneously combusted. What I mean to say is that your bookmark does not exist." ; fi ;; # delete bookmark -d) shift if [ -f ~/.cd_bookmarks/$1 ] ; then rm ~/.cd_bookmarks/"$1" ; else echo "Oops, forgot to specify the bookmark" ; fi ;; # list bookmarks -l) shift ls -1 ~/.cd_bookmarks/ ; ;; -h) echo -e $USAGE ; ;; # goto bookmark by default *) if [ -z "$1" ] ; then echo -e $USAGE elif [ -f ~/.cd_bookmarks/$1 ] ; then source ~/.cd_bookmarks/"$1" else echo "Mmm...looks like your bookmark has spontaneously combusted. What I mean to say is that your bookmark does not exist." ; fi ;; esac }tobimensch , answered Jun 5 '16 at 21:31
Yes, one that I have written, that is called anc.https://github.com/tobimensch/anc
Anc stands for anchor, but anc's anchors are really just bookmarks.
It's designed for ease of use and there're multiple ways of navigating, either by giving a text pattern, using numbers, interactively, by going back, or using [TAB] completion.
I'm actively working on it and open to input on how to make it better.
Allow me to paste the examples from anc's github page here:
# make the current directory the default anchor: $ anc s # go to /etc, then /, then /usr/local and then back to the default anchor: $ cd /etc; cd ..; cd usr/local; anc # go back to /usr/local : $ anc b # add another anchor: $ anc a $HOME/test # view the list of anchors (the default one has the asterisk): $ anc l (0) /path/to/first/anchor * (1) /home/usr/test # jump to the anchor we just added: # by using its anchor number $ anc 1 # or by jumping to the last anchor in the list $ anc -1 # add multiple anchors: $ anc a $HOME/projects/first $HOME/projects/second $HOME/documents/first # use text matching to jump to $HOME/projects/first $ anc pro fir # use text matching to jump to $HOME/documents/first $ anc doc fir # add anchor and jump to it using an absolute path $ anc /etc # is the same as $ anc a /etc; anc -1 # add anchor and jump to it using a relative path $ anc ./X11 #note that "./" is required for relative paths # is the same as $ anc a X11; anc -1 # using wildcards you can add many anchors at once $ anc a $HOME/projects/* # use shell completion to see a list of matching anchors # and select the one you want to jump to directly $ anc pro[TAB]Cảnh Toàn Nguyễn , answered Feb 20 at 5:41
Bashmarks is an amazingly simple and intuitive utility. In short, after installation, the usage is:s <bookmark_name> - Saves the current directory as "bookmark_name" g <bookmark_name> - Goes (cd) to the directory associated with "bookmark_name" p <bookmark_name> - Prints the directory associated with "bookmark_name" d <bookmark_name> - Deletes the bookmark l - Lists all available bookmarks,
For short term shortcuts, I have a the following in my respective init script (Sorry. I can't find the source right now and didn't bother then):function b() { alias $1="cd `pwd -P`" }Usage:
In any directory that you want to bookmark type
b THEDIR # <THEDIR> being the name of your 'bookmark'It will create an alias to cd (back) to here.
To return to a 'bookmarked' dir type
THEDIRIt will run the stored alias and cd back there.
Caution: Use only if you understand that this might override existing shell aliases and what that means.
Sep 02, 2019 | www.linuxquestions.org
Switch statement for bash script
<a rel='nofollow' target='_blank' href='//rev.linuxquestions.org/www/delivery/ck.php?n=a054b75'><img border='0' alt='' src='//rev.linuxquestions.org/www/delivery/avw.php?zoneid=10&n=a054b75' /></a>
[ Log in to get rid of this advertisement] Hello, i am currently trying out the switch statement using bash script.CODE:
showmenu () {
echo "1. Number1"
echo "2. Number2"
echo "3. Number3"
echo "4. All"
echo "5. Quit"
}while true
do
showmenu
read choice
echo "Enter a choice:"
case "$choice" in
"1")
echo "Number One"
;;
"2")
echo "Number Two"
;;
"3")
echo "Number Three"
;;
"4")
echo "Number One, Two, Three"
;;
"5")
echo "Program Exited"
exit 0
;;
*)
echo "Please enter number ONLY ranging from 1-5!"
;;
esac
doneOUTPUT:
1. Number1
2. Number2
3. Number3
4. All
5. Quit
Enter a choice:So, when the code is run, a menu with option 1-5 will be shown, then the user will be asked to enter a choice and finally an output is shown. But it is possible if the user want to enter multiple choices. For example, user enter choice "1" and "3", so the output will be "Number One" and "Number Three". Any idea?
Just something to get you started. Code:
#! /bin/bash showmenu () { typeset ii typeset -i jj=1 typeset -i kk typeset -i valid=0 # valid=1 if input is good while (( ! valid )) do for ii in "${options[@]}" do echo "$jj) $ii" let jj++ done read -e -p 'Select a list of actions : ' -a answer jj=0 valid=1 for kk in "${answer[@]}" do if (( kk < 1 || kk > "${#options[@]}" )) then echo "Error Item $jj is out of bounds" 1>&2 valid=0 break fi let jj++ done done } typeset -r c1=Number1 typeset -r c2=Number2 typeset -r c3=Number3 typeset -r c4=All typeset -r c5=Quit typeset -ra options=($c1 $c2 $c3 $c4 $c5) typeset -a answer typeset -i kk while true do showmenu for kk in "${answer[@]}" do case $kk in 1) echo 'Number One' ;; 2) echo 'Number Two' ;; 3) echo 'Number Three' ;; 4) echo 'Number One, Two, Three' ;; 5) echo 'Program Exit' exit 0 ;; esac done done
stevenworr View Public Profile View LQ Blog View Review Entries View HCL Entries Find More Posts by stevenworr
11-16-2009, 10:10 PM # 4 wjs1990 Member
Registered: Nov 2009 Posts: 30
Original Poster
Rep:Ok will try it out first. Thanks.
Last edited by wjs1990; 11-16-2009 at 10:13 PM .
wjs1990 View Public Profile View LQ Blog View Review Entries View HCL Entries Find More Posts by wjs1990
11-16-2009, 10:16 PM # 5 evo2 LQ Guru
Registered: Jan 2009 Location: Japan Distribution: Mostly Debian and CentOS Posts: 5,945
Rep:This can be done just by wrapping your case block in a for loop and changing one line. Code:
#!/bin/bash showmenu () { echo "1. Number1" echo "2. Number2" echo "3. Number3" echo "4. All" echo "5. Quit" } while true ; do showmenu read choices for choice in $choices ; do case "$choice" in 1) echo "Number One" ;; 2) echo "Number Two" ;; 3) echo "Number Three" ;; 4) echo "Numbers One, two, three" ;; 5) echo "Exit" exit 0 ;; *) echo "Please enter number ONLY ranging from 1-5!" ;; esac done doneYou can now enter any number of numbers seperated by white space.Cheers,
EVo2.
Mar 30, 2018 | sookocheff.com
Parsing bash script options with getopts Posted on January 4, 2015 | 5 minutes | Kevin Sookocheff A common task in shell scripting is to parse command line arguments to your script. Bash provides the
getopts
built-in function to do just that. This tutorial explains how to use thegetopts
built-in function to parse arguments and options to a bash script.The
getopts
function takes three parameters. The first is a specification of which options are valid, listed as a sequence of letters. For example, the string'ht'
signifies that the options-h
and-t
are valid.The second argument to
getopts
is a variable that will be populated with the option or argument to be processed next. In the following loop,opt
will hold the value of the current option that has been parsed bygetopts
.while getopts ":ht" opt; do case ${opt} in h ) # process option a ;; t ) # process option t ;; \? ) echo "Usage: cmd [-h] [-t]" ;; esac doneThis example shows a few additional features of
getopts
. First, if an invalid option is provided, the option variable is assigned the value?
. You can catch this case and provide an appropriate usage message to the user. Second, this behaviour is only true when you prepend the list of valid options with:
to disable the default error handling of invalid options. It is recommended to always disable the default error handling in your scripts.The third argument to
Shifting processed optionsgetopts
is the list of arguments and options to be processed. When not provided, this defaults to the arguments and options provided to the application ($@
). You can provide this third argument to usegetopts
to parse any list of arguments and options you provide.The variable
OPTIND
holds the number of options parsed by the last call togetopts
. It is common practice to call theshift
command at the end of your processing loop to remove options that have already been handled from$@
.shift $((OPTIND -1))Parsing options with argumentsOptions that themselves have arguments are signified with a
:
. The argument to an option is placed in the variableOPTARG
. In the following example, the optiont
takes an argument. When the argument is provided, we copy its value to the variabletarget
. If no argument is providedgetopts
will setopt
to:
. We can recognize this error condition by catching the:
case and printing an appropriate error message.while getopts ":t:" opt; do case ${opt} in t ) target=$OPTARG ;; \? ) echo "Invalid option: $OPTARG" 1>&2 ;; : ) echo "Invalid option: $OPTARG requires an argument" 1>&2 ;; esac done shift $((OPTIND -1))An extended example – parsing nested arguments and optionsLet's walk through an extended example of processing a command that takes options, has a sub-command, and whose sub-command takes an additional option that has an argument. This is a mouthful so let's break it down using an example. Let's say we are writing our own version of the
pip
command . In this version you can callpip
with the-h
option to display a help message.> pip -h Usage: pip -h Display this help message. pip install Install a Python package.We can use
getopts
to parse the-h
option with the followingwhile
loop. In it we catch invalid options with\?
andshift
all arguments that have been processed withshift $((OPTIND -1))
.while getopts ":h" opt; do case ${opt} in h ) echo "Usage:" echo " pip -h Display this help message." echo " pip install Install a Python package." exit 0 ;; \? ) echo "Invalid Option: -$OPTARG" 1>&2 exit 1 ;; esac done shift $((OPTIND -1))Now let's add the sub-command
install
to our script.install
takes as an argument the Python package to install.> pip install urllib3
install
also takes an option,-t
.-t
takes as an argument the location to install the package to relative to the current directory.> pip install urllib3 -t ./src/libTo process this line we must find the sub-command to execute. This value is the first argument to our script.
subcommand=$1 shift # Remove `pip` from the argument listNow we can process the sub-command
install
. In our example, the option-t
is actually an option that follows the package argument so we begin by removinginstall
from the argument list and processing the remainder of the line.case "$subcommand" in install) package=$1 shift # Remove `install` from the argument list ;; esacAfter shifting the argument list we can process the remaining arguments as if they are of the form
package -t src/lib
. The-t
option takes an argument itself. This argument will be stored in the variableOPTARG
and we save it to the variabletarget
for further work.case "$subcommand" in install) package=$1 shift # Remove `install` from the argument list while getopts ":t:" opt; do case ${opt} in t ) target=$OPTARG ;; \? ) echo "Invalid Option: -$OPTARG" 1>&2 exit 1 ;; : ) echo "Invalid Option: -$OPTARG requires an argument" 1>&2 exit 1 ;; esac done shift $((OPTIND -1)) ;; esacPutting this all together, we end up with the following script that parses arguments to our version of
pip
and its sub-commandinstall
.package="" # Default to empty package target="" # Default to empty target # Parse options to the `pip` command while getopts ":h" opt; do case ${opt} in h ) echo "Usage:" echo " pip -h Display this help message." echo " pip install <package> Install <package>." exit 0 ;; \? ) echo "Invalid Option: -$OPTARG" 1>&2 exit 1 ;; esac done shift $((OPTIND -1)) subcommand=$1; shift # Remove 'pip' from the argument list case "$subcommand" in # Parse options to the install sub command install) package=$1; shift # Remove 'install' from the argument list # Process package options while getopts ":t:" opt; do case ${opt} in t ) target=$OPTARG ;; \? ) echo "Invalid Option: -$OPTARG" 1>&2 exit 1 ;; : ) echo "Invalid Option: -$OPTARG requires an argument" 1>&2 exit 1 ;; esac done shift $((OPTIND -1)) ;; esacAfter processing the above sequence of commands, the variable
bash getoptspackage
will hold the package to install and the variabletarget
will hold the target to install the package to. You can use this as a template for processing any set of arguments and options to your scripts.
Jul 10, 2017 | stackoverflow.com
Livven, Jul 10, 2017 at 8:11
Update: It's been more than 5 years since I started this answer. Thank you for LOTS of great edits/comments/suggestions. In order save maintenance time, I've modified the code block to be 100% copy-paste ready. Please do not post comments like "What if you changed X to Y ". Instead, copy-paste the code block, see the output, make the change, rerun the script, and comment "I changed X to Y and " I don't have time to test your ideas and tell you if they work.
Method #1: Using bash without getopt[s]Two common ways to pass key-value-pair arguments are:
Bash Space-Separated (e.g.,--option argument
) (without getopt[s])Usage
demo-space-separated.sh -e conf -s /etc -l /usr/lib /etc/hosts
cat >/tmp/demo-space-separated.sh <<'EOF' #!/bin/bash POSITIONAL=() while [[ $# -gt 0 ]] do key="$1" case $key in -e|--extension) EXTENSION="$2" shift # past argument shift # past value ;; -s|--searchpath) SEARCHPATH="$2" shift # past argument shift # past value ;; -l|--lib) LIBPATH="$2" shift # past argument shift # past value ;; --default) DEFAULT=YES shift # past argument ;; *) # unknown option POSITIONAL+=("$1") # save it in an array for later shift # past argument ;; esac done set -- "${POSITIONAL[@]}" # restore positional parameters echo "FILE EXTENSION = ${EXTENSION}" echo "SEARCH PATH = ${SEARCHPATH}" echo "LIBRARY PATH = ${LIBPATH}" echo "DEFAULT = ${DEFAULT}" echo "Number files in SEARCH PATH with EXTENSION:" $(ls -1 "${SEARCHPATH}"/*."${EXTENSION}" | wc -l) if [[ -n $1 ]]; then echo "Last line of file specified as non-opt/last argument:" tail -1 "$1" fi EOF chmod +x /tmp/demo-space-separated.sh /tmp/demo-space-separated.sh -e conf -s /etc -l /usr/lib /etc/hostsoutput from copy-pasting the block above:
FILE EXTENSION = conf SEARCH PATH = /etc LIBRARY PATH = /usr/lib DEFAULT = Number files in SEARCH PATH with EXTENSION: 14 Last line of file specified as non-opt/last argument: #93.184.216.34 example.comBash Equals-Separated (e.g.,--option=argument
) (without getopt[s])Usage
demo-equals-separated.sh -e=conf -s=/etc -l=/usr/lib /etc/hosts
cat >/tmp/demo-equals-separated.sh <<'EOF' #!/bin/bash for i in "$@" do case $i in -e=*|--extension=*) EXTENSION="${i#*=}" shift # past argument=value ;; -s=*|--searchpath=*) SEARCHPATH="${i#*=}" shift # past argument=value ;; -l=*|--lib=*) LIBPATH="${i#*=}" shift # past argument=value ;; --default) DEFAULT=YES shift # past argument with no value ;; *) # unknown option ;; esac done echo "FILE EXTENSION = ${EXTENSION}" echo "SEARCH PATH = ${SEARCHPATH}" echo "LIBRARY PATH = ${LIBPATH}" echo "DEFAULT = ${DEFAULT}" echo "Number files in SEARCH PATH with EXTENSION:" $(ls -1 "${SEARCHPATH}"/*."${EXTENSION}" | wc -l) if [[ -n $1 ]]; then echo "Last line of file specified as non-opt/last argument:" tail -1 $1 fi EOF chmod +x /tmp/demo-equals-separated.sh /tmp/demo-equals-separated.sh -e=conf -s=/etc -l=/usr/lib /etc/hostsoutput from copy-pasting the block above:
FILE EXTENSION = conf SEARCH PATH = /etc LIBRARY PATH = /usr/lib DEFAULT = Number files in SEARCH PATH with EXTENSION: 14 Last line of file specified as non-opt/last argument: #93.184.216.34 example.comTo better understand
Method #2: Using bash with getopt[s]${i#*=}
search for "Substring Removal" in this guide . It is functionally equivalent to`sed 's/[^=]*=//' <<< "$i"`
which calls a needless subprocess or`echo "$i" | sed 's/[^=]*=//'`
which calls two needless subprocesses.from: http://mywiki.wooledge.org/BashFAQ/035#getopts
getopt(1) limitations (older, relatively-recent
getopt
versions):
- can't handle arguments that are empty strings
- can't handle arguments with embedded whitespace
More recent
getopt
versions don't have these limitations.Additionally, the POSIX shell (and others) offer
getopts
which doesn't have these limitations. I've included a simplisticgetopts
example.Usage
demo-getopts.sh -vf /etc/hosts foo bar
cat >/tmp/demo-getopts.sh <<'EOF' #!/bin/sh # A POSIX variable OPTIND=1 # Reset in case getopts has been used previously in the shell. # Initialize our own variables: output_file="" verbose=0 while getopts "h?vf:" opt; do case "$opt" in h|\?) show_help exit 0 ;; v) verbose=1 ;; f) output_file=$OPTARG ;; esac done shift $((OPTIND-1)) [ "${1:-}" = "--" ] && shift echo "verbose=$verbose, output_file='$output_file', Leftovers: $@" EOF chmod +x /tmp/demo-getopts.sh /tmp/demo-getopts.sh -vf /etc/hosts foo baroutput from copy-pasting the block above:
verbose=1, output_file='/etc/hosts', Leftovers: foo barThe advantages of
getopts
are:
- It's more portable, and will work in other shells like
dash
.- It can handle multiple single options like
-vf filename
in the typical Unix way, automatically.The disadvantage of
getopts
is that it can only handle short options (-h
, not--help
) without additional code.There is a getopts tutorial which explains what all of the syntax and variables mean. In bash, there is also
help getopts
, which might be informative.johncip ,Jul 23, 2018 at 15:15
No answer mentions enhanced getopt . And the top-voted answer is misleading: It either ignores-vfd
style short options (requested by the OP) or options after positional arguments (also requested by the OP); and it ignores parsing-errors. Instead:
- Use enhanced
getopt
from util-linux or formerly GNU glibc . 1- It works with
getopt_long()
the C function of GNU glibc.- Has all useful distinguishing features (the others don't have them):
- handles spaces, quoting characters and even binary in arguments 2 (non-enhanced
getopt
can't do this)- it can handle options at the end:
script.sh -o outFile file1 file2 -v
(getopts
doesn't do this)- allows
=
-style long options:script.sh --outfile=fileOut --infile fileIn
(allowing both is lengthy if self parsing)- allows combined short options, e.g.
-vfd
(real work if self parsing)- allows touching option-arguments, e.g.
-oOutfile
or-vfdoOutfile
- Is so old already 3 that no GNU system is missing this (e.g. any Linux has it).
- You can test for its existence with:
getopt --test
→ return value 4.- Other
getopt
or shell-builtingetopts
are of limited use.The following calls
myscript -vfd ./foo/bar/someFile -o /fizz/someOtherFile myscript -v -f -d -o/fizz/someOtherFile -- ./foo/bar/someFile myscript --verbose --force --debug ./foo/bar/someFile -o/fizz/someOtherFile myscript --output=/fizz/someOtherFile ./foo/bar/someFile -vfd myscript ./foo/bar/someFile -df -v --output /fizz/someOtherFileall return
verbose: y, force: y, debug: y, in: ./foo/bar/someFile, out: /fizz/someOtherFilewith the following
myscript
#!/bin/bash # saner programming env: these switches turn some bugs into errors set -o errexit -o pipefail -o noclobber -o nounset # -allow a command to fail with !'s side effect on errexit # -use return value from ${PIPESTATUS[0]}, because ! hosed $? ! getopt --test > /dev/null if [[ ${PIPESTATUS[0]} -ne 4 ]]; then echo 'I'm sorry, `getopt --test` failed in this environment.' exit 1 fi OPTIONS=dfo:v LONGOPTS=debug,force,output:,verbose # -regarding ! and PIPESTATUS see above # -temporarily store output to be able to check for errors # -activate quoting/enhanced mode (e.g. by writing out "--options") # -pass arguments only via -- "$@" to separate them correctly ! PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTS --name "$0" -- "$@") if [[ ${PIPESTATUS[0]} -ne 0 ]]; then # e.g. return value is 1 # then getopt has complained about wrong arguments to stdout exit 2 fi # read getopt's output this way to handle the quoting right: eval set -- "$PARSED" d=n f=n v=n outFile=- # now enjoy the options in order and nicely split until we see -- while true; do case "$1" in -d|--debug) d=y shift ;; -f|--force) f=y shift ;; -v|--verbose) v=y shift ;; -o|--output) outFile="$2" shift 2 ;; --) shift break ;; *) echo "Programming error" exit 3 ;; esac done # handle non-option arguments if [[ $# -ne 1 ]]; then echo "$0: A single input file is required." exit 4 fi echo "verbose: $v, force: $f, debug: $d, in: $1, out: $outFile"
1 enhanced getopt is available on most "bash-systems", including Cygwin; on OS X try brew install gnu-getopt or
sudo port install getopt
2 the POSIXexec()
conventions have no reliable way to pass binary NULL in command line arguments; those bytes prematurely end the argument
3 first version released in 1997 or before (I only tracked it back to 1997)Tobias Kienzler ,Mar 19, 2016 at 15:23
from : digitalpeer.com with minor modificationsUsage
myscript.sh -p=my_prefix -s=dirname -l=libname
#!/bin/bash for i in "$@" do case $i in -p=*|--prefix=*) PREFIX="${i#*=}" ;; -s=*|--searchpath=*) SEARCHPATH="${i#*=}" ;; -l=*|--lib=*) DIR="${i#*=}" ;; --default) DEFAULT=YES ;; *) # unknown option ;; esac done echo PREFIX = ${PREFIX} echo SEARCH PATH = ${SEARCHPATH} echo DIRS = ${DIR} echo DEFAULT = ${DEFAULT}To better understand
${i#*=}
search for "Substring Removal" in this guide . It is functionally equivalent to`sed 's/[^=]*=//' <<< "$i"`
which calls a needless subprocess or`echo "$i" | sed 's/[^=]*=//'`
which calls two needless subprocesses.Robert Siemer ,Jun 1, 2018 at 1:57
getopt()
/getopts()
is a good option. Stolen from here :The simple use of "getopt" is shown in this mini-script:
#!/bin/bash echo "Before getopt" for i do echo $i done args=`getopt abc:d $*` set -- $args echo "After getopt" for i do echo "-->$i" doneWhat we have said is that any of -a, -b, -c or -d will be allowed, but that -c is followed by an argument (the "c:" says that).
If we call this "g" and try it out:
bash-2.05a$ ./g -abc foo Before getopt -abc foo After getopt -->-a -->-b -->-c -->foo -->--We start with two arguments, and "getopt" breaks apart the options and puts each in its own argument. It also added "--".
hfossli ,Jan 31 at 20:05
More succinct wayscript.sh
#!/bin/bash while [[ "$#" -gt 0 ]]; do case $1 in -d|--deploy) deploy="$2"; shift;; -u|--uglify) uglify=1;; *) echo "Unknown parameter passed: $1"; exit 1;; esac; shift; done echo "Should deploy? $deploy" echo "Should uglify? $uglify"Usage:
./script.sh -d dev -u # OR: ./script.sh --deploy dev --uglifybronson ,Apr 27 at 23:22
At the risk of adding another example to ignore, here's my scheme.
- handles
-n arg
and--name=arg
- allows arguments at the end
- shows sane errors if anything is misspelled
- compatible, doesn't use bashisms
- readable, doesn't require maintaining state in a loop
Hope it's useful to someone.
while [ "$#" -gt 0 ]; do case "$1" in -n) name="$2"; shift 2;; -p) pidfile="$2"; shift 2;; -l) logfile="$2"; shift 2;; --name=*) name="${1#*=}"; shift 1;; --pidfile=*) pidfile="${1#*=}"; shift 1;; --logfile=*) logfile="${1#*=}"; shift 1;; --name|--pidfile|--logfile) echo "$1 requires an argument" >&2; exit 1;; -*) echo "unknown option: $1" >&2; exit 1;; *) handle_argument "$1"; shift 1;; esac doneRobert Siemer ,Jun 6, 2016 at 19:28
I'm about 4 years late to this question, but want to give back. I used the earlier answers as a starting point to tidy up my old adhoc param parsing. I then refactored out the following template code. It handles both long and short params, using = or space separated arguments, as well as multiple short params grouped together. Finally it re-inserts any non-param arguments back into the $1,$2.. variables. I hope it's useful.#!/usr/bin/env bash # NOTICE: Uncomment if your script depends on bashisms. #if [ -z "$BASH_VERSION" ]; then bash $0 $@ ; exit $? ; fi echo "Before" for i ; do echo - $i ; done # Code template for parsing command line parameters using only portable shell # code, while handling both long and short params, handling '-f file' and # '-f=file' style param data and also capturing non-parameters to be inserted # back into the shell positional parameters. while [ -n "$1" ]; do # Copy so we can modify it (can't modify $1) OPT="$1" # Detect argument termination if [ x"$OPT" = x"--" ]; then shift for OPT ; do REMAINS="$REMAINS \"$OPT\"" done break fi # Parse current opt while [ x"$OPT" != x"-" ] ; do case "$OPT" in # Handle --flag=value opts like this -c=* | --config=* ) CONFIGFILE="${OPT#*=}" shift ;; # and --flag value opts like this -c* | --config ) CONFIGFILE="$2" shift ;; -f* | --force ) FORCE=true ;; -r* | --retry ) RETRY=true ;; # Anything unknown is recorded for later * ) REMAINS="$REMAINS \"$OPT\"" break ;; esac # Check for multiple short options # NOTICE: be sure to update this pattern to match valid options NEXTOPT="${OPT#-[cfr]}" # try removing single short opt if [ x"$OPT" != x"$NEXTOPT" ] ; then OPT="-$NEXTOPT" # multiple short opts, keep going else break # long form, exit inner loop fi done # Done with that param. move to next shift done # Set the non-parameters back into the positional parameters ($1 $2 ..) eval set -- $REMAINS echo -e "After: \n configfile='$CONFIGFILE' \n force='$FORCE' \n retry='$RETRY' \n remains='$REMAINS'" for i ; do echo - $i ; done> ,
I have found the matter to write portable parsing in scripts so frustrating that I have written Argbash - a FOSS code generator that can generate the arguments-parsing code for your script plus it has some nice features:
May 10, 2013 | stackoverflow.com
An example of how to use getopts in bash Ask Question Asked 6 years, 3 months ago Active 10 months ago Viewed 419k times 288 132
chepner ,May 10, 2013 at 13:42
I want to callmyscript
file in this way:$ ./myscript -s 45 -p any_stringor
$ ./myscript -h >>> should display help $ ./myscript >>> should display helpMy requirements are:
getopt
here to get the input arguments- check that
-s
exists, if not return error- check that the value after the
-s
is 45 or 90- check that the
-p
exists and there is an input string after- if the user enters
./myscript -h
or just./myscript
then display helpI tried so far this code:
#!/bin/bash while getopts "h:s:" arg; do case $arg in h) echo "usage" ;; s) strength=$OPTARG echo $strength ;; esac doneBut with that code I get errors. How to do it with Bash and
getopt
?,
#!/bin/bash usage() { echo "Usage: $0 [-s <45|90>] [-p <string>]" 1>&2; exit 1; } while getopts ":s:p:" o; do case "${o}" in s) s=${OPTARG} ((s == 45 || s == 90)) || usage ;; p) p=${OPTARG} ;; *) usage ;; esac done shift $((OPTIND-1)) if [ -z "${s}" ] || [ -z "${p}" ]; then usage fi echo "s = ${s}" echo "p = ${p}"Example runs:
$ ./myscript.sh Usage: ./myscript.sh [-s <45|90>] [-p <string>] $ ./myscript.sh -h Usage: ./myscript.sh [-s <45|90>] [-p <string>] $ ./myscript.sh -s "" -p "" Usage: ./myscript.sh [-s <45|90>] [-p <string>] $ ./myscript.sh -s 10 -p foo Usage: ./myscript.sh [-s <45|90>] [-p <string>] $ ./myscript.sh -s 45 -p foo s = 45 p = foo $ ./myscript.sh -s 90 -p bar s = 90 p = bar
Aug 28, 2019 | linoxide.com
The -e parameter is used for the interpretation of backslashes
... ... ...
To create a new line after each word in a string use the -e operator with the \n option as shown$ echo -e "Linux \nis \nan \nopensource \noperating \nsystem"... ... ...
Omit echoing trailing newlineThe -n option is used for omitting trailing newline. This is shown in the example below
$ echo -n "Linux is an opensource operating system"Sample Output
Linux is an opensource operating systemjames@buster:/$
Aug 27, 2019 | bash.cyberciti.biz
BASH_LINENO
An array variable whose members are the line numbers in source files corresponding to each member of FUNCNAME .
${BASH_LINENO[$i]}
is the line number in the source file where${FUNCNAME[$i]}
was called. The corresponding source file name is${BASH_SOURCE[$i]}
. UseLINENO
to obtain the current line number.
Aug 27, 2019 | stackoverflow.com
How to show line number when executing bash script Ask Question Asked 6 years, 1 month ago Active 1 year, 4 months ago Viewed 47k times 68 31
dspjm ,Jul 23, 2013 at 7:31
I have a test script which has a lot of commands and will generate lots of output, I useset -x
orset -v
andset -e
, so the script would stop when error occurs. However, it's still rather difficult for me to locate which line did the execution stop in order to locate the problem. Is there a method which can output the line number of the script before each line is executed? Or output the line number before the command exhibition generated byset -x
? Or any method which can deal with my script line location problem would be a great help. Thanks.Suvarna Pattayil ,Jul 28, 2017 at 17:25
You mention that you're already using-x
. The variablePS4
denotes the value is the prompt printed before the command line is echoed when the-x
option is set and defaults to:
followed by space.You can change
PS4
to emit theLINENO
(The line number in the script or shell function currently executing).For example, if your script reads:
$ cat script foo=10 echo ${foo} echo $((2 + 2))Executing it thus would print line numbers:
$ PS4='Line ${LINENO}: ' bash -x script Line 1: foo=10 Line 2: echo 10 10 Line 3: echo 4 4http://wiki.bash-hackers.org/scripting/debuggingtips gives the ultimate
PS4
that would output everything you will possibly need for tracing:export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'Deqing ,Jul 23, 2013 at 8:16
In Bash,$LINENO
contains the line number where the script currently executing.If you need to know the line number where the function was called, try
$BASH_LINENO
. Note that this variable is an array.For example:
#!/bin/bash function log() { echo "LINENO: ${LINENO}" echo "BASH_LINENO: ${BASH_LINENO[*]}" } function foo() { log "$@" } foo "$@"See here for details of Bash variables.
Eliran Malka ,Apr 25, 2017 at 10:14
Simple (but powerful) solution: Placeecho
around the code you think that causes the problem and move theecho
line by line until the messages does not appear anymore on screen - because the script has stop because of an error before.Even more powerful solution: Install
bashdb
the bash debugger and debug the script line by linekklepper ,Apr 2, 2018 at 22:44
Workaround for shells without LINENOIn a fairly sophisticated script I wouldn't like to see all line numbers; rather I would like to be in control of the output.
Define a function
echo_line_no () { grep -n "$1" $0 | sed "s/echo_line_no//" # grep the line(s) containing input $1 with line numbers # replace the function name with nothing } # echo_line_noUse it with quotes like
echo_line_no "this is a simple comment with a line number"Output is
16 "this is a simple comment with a line number"if the number of this line in the source file is 16.
This basically answers the question How to show line number when executing bash script for users of ash or other shells without
LINENO
.Anything more to add?
Sure. Why do you need this? How do you work with this? What can you do with this? Is this simple approach really sufficient or useful? Why do you want to tinker with this at all?
Want to know more? Read reflections on debugging
Aug 27, 2019 | www.tecmint.com
~/.config/gogo/gogo.conf
file (which should be auto created if it doesn't exist) and has the following syntax.# Comments are lines that start from '#' character. default = ~/something alias = /desired/path alias2 = /desired/path with space alias3 = "/this/also/works" zażółć = "unicode/is/also/supported/zażółć gęślą jaźń"If you run gogo run without any arguments, it will go to the directory specified in default; this alias is always available, even if it's not in the configuration file, and points to $HOME directory.
To display the current aliases, use the
-l
switch. From the following screenshot, you can see that default points to~/home/tecmint
which is user tecmint's home directory on the system.$ gogo -l<img aria-describedby="caption-attachment-28848" src="https://www.tecmint.com/wp-content/uploads/2018/03/List-Gogo-Aliases.png" alt="List Gogo Aliases" width="664" height="150" />List Gogo Aliases
Below is an example of running gogo without any arguments.
$ cd Documents/Phone-Backup/Linux-Docs/ $ gogo $ pwd<img aria-describedby="caption-attachment-28849" src="https://www.tecmint.com/wp-content/uploads/2018/03/Gogo-Listing.png" alt="Running Gogo Without Options" width="661" height="105" />Running Gogo Without Options
To create a shortcut to a long path, move into the directory you want and use the
-a
flag to add an alias for that directory in gogo , as shown.$ cd Documents/Phone-Backup/Linux-Docs/Ubuntu/ $ gogo -a Ubuntu $ gogo $ gogo -l $ gogo -a Ubuntu $ pwd<img aria-describedby="caption-attachment-28850" src="https://www.tecmint.com/wp-content/uploads/2018/03/Create-Gogo-Shortcut.png" alt="Create Long Directory Shortcut " width="739" height="270" />Create Long Directory Shortcut
You can also create aliases for connecting directly into directories on a remote Linux servers. To do this, simple add the following lines to gogo configuration file, which can be accessed using -e flag, this will use the editor specified in the $EDITOR env variable.
$ gogo -eOne configuration file opens, add these following lines to it.
sshroot = ssh://[email protected]:/bin/bash /root/ sshtdocs = ssh://tecmint@server3 ~/tecmint/docs/
- sitaram says: August 25, 2019 at 7:46 am
The bulk of what this tool does can be replaced with a shell function that does `
cd $(grep -w ^$1 ~/.config/gogo.conf | cut -f2 -d' ')
`, where`$1`
is the argument supplied to the function.If you've already installed fzf (and you really should), then you can get a far better experience than even zsh's excellent "completion" facilities. I use something like `
cd $(fzf -1 +m -q "$1" < ~/.cache/to)
` (My equivalent of gogo.conf is `~/.cache/to
`).
Aug 07, 2016 | shapeshed.com
Tutorial on using exit codes from Linux or UNIX commands. Examples of how to get the exit code of a command, how to set the exit code and how to suppress exit codes.Estimated reading time: 3 minutes
Table of contentsWhat is an exit code in the UNIX or Linux shell?
An exit code, or sometimes known as a return code, is the code returned to a parent process by an executable. On POSIX systems the standard exit code is
0
for success and any number from1
to255
for anything else.Exit codes can be interpreted by machine scripts to adapt in the event of successes of failures. If exit codes are not set the exit code will be the exit code of the last run command.
How to get the exit code of a commandTo get the exit code of a command type
echo $?
at the command prompt. In the following example a file is printed to the terminal using the cat command.cat file.txt hello world echo $? 0The command was successful. The file exists and there are no errors in reading the file or writing it to the terminal. The exit code is therefore
0
.In the following example the file does not exist.
cat doesnotexist.txt cat: doesnotexist.txt: No such file or directory echo $? 1The exit code is
How to use exit codes in scripts1
as the operation was not successful.To use exit codes in scripts an
if
statement can be used to see if an operation was successful.#!/bin/bash cat file.txt if [ $? -eq 0 ] then echo "The script ran ok" exit 0 else echo "The script failed" >&2 exit 1 fiIf the command was unsuccessful the exit code will be
How to set an exit code0
and 'The script ran ok' will be printed to the terminal.To set an exit code in a script use
exit 0
where0
is the number you want to return. In the following example a shell script exits with a1
. This file is saved asexit.sh
.#!/bin/bash exit 1Executing this script shows that the exit code is correctly set.
bash exit.sh echo $? 1What exit code should I use?The Linux Documentation Project has a list of reserved codes that also offers advice on what code to use for specific scenarios. These are the standard error codes in Linux or UNIX.
How to suppress exit statuses
1
- Catchall for general errors2
- Misuse of shell builtins (according to Bash documentation)126
- Command invoked cannot execute127
- "command not found"128
- Invalid argument to exit128+n
- Fatal error signal "n"130
- Script terminated by Control-C255\*
- Exit status out of rangeSometimes there may be a requirement to suppress an exit status. It may be that a command is being run within another script and that anything other than a
0
status is undesirable.In the following example a file is printed to the terminal using cat . This file does not exist so will cause an exit status of
1
.To suppress the error message any output to standard error is sent to
/dev/null
using2>/dev/null
.If the cat command fails an
OR
operation can be used to provide a fallback -cat file.txt || exit 0
. In this case an exit code of0
is returned even if there is an error.Combining both the suppression of error output and the
OR
operation the following script returns a status code of0
with no output even though the file does not exist.#!/bin/bash cat 'doesnotexist.txt' 2>/dev/null || exit 0Further reading
Aug 26, 2019 | www.shellscript.sh
Exit codes are a number between 0 and 255, which is returned by any Unix command when it returns control to its parent process.
Other numbers can be used, but these are treated modulo 256, soexit -10
is equivalent toexit 246
, andexit 257
is equivalent toexit 1
.These can be used within a shell script to change the flow of execution depending on the success or failure of commands executed. This was briefly introduced in Variables - Part II . Here we shall look in more detail in the available interpretations of exit codes.
Success is traditionally represented with
exit 0
; failure is normally indicated with a non-zero exit-code. This value can indicate different reasons for failure.
For example, GNUgrep
returns0
on success,1
if no matches were found, and2
for other errors (syntax errors, non-existent input files, etc).We shall look at three different methods for checking error status, and discuss the pros and cons of each approach.
Firstly, the simple approach:
#!/bin/sh # First attempt at checking return codes USERNAME=`grep "^${1}:" /etc/passwd|cut -d":" -f1` if [ "$?" -ne "0" ]; then echo "Sorry, cannot find user ${1} in /etc/passwd" exit 1 fi NAME=`grep "^${1}:" /etc/passwd|cut -d":" -f5` HOMEDIR=`grep "^${1}:" /etc/passwd|cut -d":" -f6` echo "USERNAME: $USERNAME" echo "NAME: $NAME" echo "HOMEDIR: $HOMEDIR"
This script works fine if you supply a valid username in/etc/passwd
. However, if you enter an invalid code, it does not do what you might at first expect - it keeps running, and just shows:USERNAME: NAME: HOMEDIR:Why is this? As mentioned, the$?
variable is set to the return code of the last executed command . In this case, that iscut
.cut
had no problems which it feels like reporting - as far as I can tell from testing it, and reading the documentation,cut
returns zero whatever happens! It was fed an empty string, and did its job - returned the first field of its input, which just happened to be the empty string.So what do we do? If we have an error here,
grep
will report it, notcut
. Therefore, we have to testgrep
's return code, notcut
's.
#!/bin/sh # Second attempt at checking return codes grep "^${1}:" /etc/passwd > /dev/null 2>&1 if [ "$?" -ne "0" ]; then echo "Sorry, cannot find user ${1} in /etc/passwd" exit 1 fi USERNAME=`grep "^${1}:" /etc/passwd|cut -d":" -f1` NAME=`grep "^${1}:" /etc/passwd|cut -d":" -f5` HOMEDIR=`grep "^${1}:" /etc/passwd|cut -d":" -f6` echo "USERNAME: $USERNAME" echo "NAME: $NAME" echo "HOMEDIR: $HOMEDIR"
This fixes the problem for us, though at the expense of slightly longer code.
That is the basic way which textbooks might show you, but it is far from being all there is to know about error-checking in shell scripts. This method may not be the most suitable to your particular command-sequence, or may be unmaintainable. Below, we shall investigate two alternative approaches.As a second approach, we can tidy this somewhat by putting the test into a separate function, instead of littering the code with lots of 4-line tests:
#!/bin/sh # A Tidier approach check_errs() { # Function. Parameter 1 is the return code # Para. 2 is text to display on failure. if [ "${1}" -ne "0" ]; then echo "ERROR # ${1} : ${2}" # as a bonus, make our script exit with the right error code. exit ${1} fi } ### main script starts here ### grep "^${1}:" /etc/passwd > /dev/null 2>&1 check_errs $? "User ${1} not found in /etc/passwd" USERNAME=`grep "^${1}:" /etc/passwd|cut -d":" -f1` check_errs $? "Cut returned an error" echo "USERNAME: $USERNAME" check_errs $? "echo returned an error - very strange!"
This allows us to test for errors 3 times, with customised error messages, without having to write 3 individual tests. By writing the test routine once. we can call it as many times as we wish, creating a more intelligent script, at very little expense to the programmer. Perl programmers will recognise this as being similar to thedie
command in Perl.As a third approach, we shall look at a simpler and cruder method. I tend to use this for building Linux kernels - simple automations which, if they go well, should just get on with it, but when things go wrong, tend to require the operator to do something intelligent (ie, that which a script cannot do!):
#!/bin/sh cd /usr/src/linux && \ make dep && make bzImage && make modules && make modules_install && \ cp arch/i386/boot/bzImage /boot/my-new-kernel && cp System.map /boot && \ echo "Your new kernel awaits, m'lord."This script runs through the various tasks involved in building a Linux kernel (which can take quite a while), and uses the&&
operator to check for success. To do this withif
would involve:
#!/bin/sh cd /usr/src/linux if [ "$?" -eq "0" ]; then make dep if [ "$?" -eq "0" ]; then make bzImage if [ "$?" -eq "0" ]; then make modules if [ "$?" -eq "0" ]; then make modules_install if [ "$?" -eq "0" ]; then cp arch/i386/boot/bzImage /boot/my-new-kernel if [ "$?" -eq "0" ]; then cp System.map /boot/ if [ "$?" -eq "0" ]; then echo "Your new kernel awaits, m'lord." fi fi fi fi fi fi fi fi
... which I, personally, find pretty difficult to follow.
The&&
and||
operators are the shell's equivalent of AND and OR tests. These can be thrown together as above, or:
#!/bin/sh cp /foo /bar && echo Success || echo FailedThis code will either echo
Successor
Faileddepending on whether or not the
cp
command was successful. Look carefully at this; the construct iscommand && command-to-execute-on-success || command-to-execute-on-failureOnly one command can be in each part. This method is handy for simple success / fail scenarios, but if you want to check on the status of the
echo
commands themselves, it is easy to quickly become confused about which&&
and||
applies to which command. It is also very difficult to maintain. Therefore this construct is only recommended for simple sequencing of commands.In earlier versions, I had suggested that you can use a subshell to execute multiple commands depending on whether the
cp
command succeeded or failed:cp /foo /bar && ( echo Success ; echo Success part II; ) || ( echo Failed ; echo Failed part II )But in fact, Marcel found that this does not work properly. The syntax for a subshell is:
( command1 ; command2; command3 )The return code of the subshell is the return code of the final command (
command3
in this example). That return code will affect the overall command. So the output of this script:cp /foo /bar && ( echo Success ; echo Success part II; /bin/false ) || ( echo Failed ; echo Failed part II )Is that it runs the Success part (because
cp
succeeded, and then - because/bin/false
returns failure, it also executes the Failure part:Success Success part II Failed Failed part IISo if you need to execute multiple commands as a result of the status of some other condition, it is better (and much clearer) to use the standard
if
,then
,else
syntax.
Aug 22, 2019 | www.ostechnix.com
Method 2 – Using history commandWe can use the history command's write option to print the history without numbers like below.
$ history -w /dev/stdoutMethod 3 – Using history and cut commandsOne such way is to use history and cut commands like below.
$ history | cut -c 8-
Aug 14, 2019 | unix.stackexchange.com
PID background process Ask Question Asked 2 years, 8 months ago Active 2 years, 8 months ago Viewed 2k times 2
Raul ,Nov 27, 2016 at 18:21
As I understand pipes and commands, bash takes each command, spawns a process for each one and connects stdout of the previous one with the stdin of the next one.For example, in "ls -lsa | grep feb", bash will create two processes, and connect the output of "ls -lsa" to the input of "grep feb".
When you execute a background command like "sleep 30 &" in bash, you get the pid of the background process running your command. Surprisingly for me, when I wrote "ls -lsa | grep feb &" bash returned only one PID.
How should this be interpreted? A process runs both "ls -lsa" and "grep feb"? Several process are created but I only get the pid of one of them?
Raul ,Nov 27, 2016 at 19:21
Spawns 2 processes. The&
displays the PID of the second process. Example below.$ echo $$ 13358 $ sleep 100 | sleep 200 & [1] 13405 $ ps -ef|grep 13358 ec2-user 13358 13357 0 19:02 pts/0 00:00:00 -bash ec2-user 13404 13358 0 19:04 pts/0 00:00:00 sleep 100 ec2-user 13405 13358 0 19:04 pts/0 00:00:00 sleep 200 ec2-user 13406 13358 0 19:04 pts/0 00:00:00 ps -ef ec2-user 13407 13358 0 19:04 pts/0 00:00:00 grep --color=auto 13358 $> ,
When you run a job in the background, bash prints the process ID of its subprocess, the one that runs the command in that job. If that job happens to create more subprocesses, that's none of the parent shell's business.When the background job is a pipeline (i.e. the command is of the form
something1 | something2 &
, and not e.g.{ something1 | something2; } &
), there's an optimization which is strongly suggested by POSIX and performed by most shells including bash: each of the elements of the pipeline are executed directly as subprocesses of the original shell. What POSIX mandates is that the variable$!
is set to the last command in the pipeline in this case. In most shells, that last command is a subprocess of the original process, and so are the other commands in the pipeline.When you run
ls -lsa | grep feb
, there are three processes involved: the one that runs the left-hand side of the pipe (a subshell that finishes setting up the pipe then executesls
), the one that runs the right-hand side of the pipe (a subshell that finishes setting up the pipe then executesgrep
), and the original process that waits for the pipe to finish.You can watch what happens by tracing the processes:
$ strace -f -e clone,wait4,pipe,execve,setpgid bash --norc execve("/usr/local/bin/bash", ["bash", "--norc"], [/* 82 vars */]) = 0 setpgid(0, 24084) = 0 bash-4.3$ sleep 10 | sleep 20 &Note how the second
sleep
is reported and stored as$!
, but the process group ID is the firstsleep
. Dash has the same oddity, ksh and mksh don't.
Aug 14, 2019 | stackoverflow.com
Nidhi ,Nov 28, 2014 at 0:54
pids=$(pgrep <name>)will get you the pids of all processes with the given name. To kill them all, use
kill -9 $pidsTo refrain from using a variable and directly kill all processes with a given name issue
pkill -9 <name>panticz.de ,Nov 11, 2016 at 10:11
On a single line...pgrep -f process_name | xargs kill -9flazzarini ,Jun 13, 2014 at 9:54
Another possibility would be to usepidof
it usually comes with most distributions. It will return you the PID of a given process by using it's name.pidof process_nameThis way you could store that information in a variable and execute
kill -9
on it.#!/bin/bash pid=`pidof process_name` kill -9 $pidPawel K ,Dec 20, 2017 at 10:27
use grep [n]ame to remove that grep -v name this is first... Sec using xargs in the way how it is up there is wrong to rnu whatever it is piped you have to use -i ( interactive mode) otherwise you may have issues with the command.ps axf | grep | grep -v grep | awk '{print "kill -9 " $1}' ? ps aux |grep [n]ame | awk '{print "kill -9 " $2}' ? isnt that better ?
Aug 14, 2019 | stackoverflow.com
How to get PID of background process? Ask Question Asked 9 years, 8 months ago Active 7 months ago Viewed 238k times 336 64
pixelbeat ,Mar 20, 2013 at 9:11
I start a background process from my shell script, and I would like to kill this process when my script finishes.How to get the PID of this process from my shell script? As far as I can see variable
$!
contains the PID of the current script, not the background process.WiSaGaN ,Jun 2, 2015 at 14:40
You need to save the PID of the background process at the time you start it:foo & FOO_PID=$! # do other stuff kill $FOO_PIDYou cannot use job control, since that is an interactive feature and tied to a controlling terminal. A script will not necessarily have a terminal attached at all so job control will not necessarily be available.
Phil ,Dec 2, 2017 at 8:01
You can use thejobs -l
command to get to a particular jobL^Z [1]+ Stopped guard my_mac:workspace r$ jobs -l [1]+ 46841 Suspended: 18 guardIn this case, 46841 is the PID.
From
help jobs
:-l Report the process group ID and working directory of the jobs.
jobs -p
is another option which shows just the PIDs.Timo ,Dec 2, 2017 at 8:03
$$
is the current script's pid$!
is the pid of the last background processHere's a sample transcript from a bash session (
%1
refers to the ordinal number of background process as seen fromjobs
):$ echo $$ 3748 $ sleep 100 & [1] 192 $ echo $! 192 $ kill %1 [1]+ Terminated sleep 100lepe ,Dec 2, 2017 at 8:29
An even simpler way to kill all child process of a bash script:pkill -P $$The
-P
flag works the same way withpkill
andpgrep
- it gets child processes, only withpkill
the child processes get killed and withpgrep
child PIDs are printed to stdout.Luis Ramirez ,Feb 20, 2013 at 23:11
this is what I have done. Check it out, hope it can help.#!/bin/bash # # So something to show. echo "UNO" > UNO.txt echo "DOS" > DOS.txt # # Initialize Pid List dPidLst="" # # Generate background processes tail -f UNO.txt& dPidLst="$dPidLst $!" tail -f DOS.txt& dPidLst="$dPidLst $!" # # Report process IDs echo PID=$$ echo dPidLst=$dPidLst # # Show process on current shell ps -f # # Start killing background processes from list for dPid in $dPidLst do echo killing $dPid. Process is still there. ps | grep $dPid kill $dPid ps | grep $dPid echo Just ran "'"ps"'" command, $dPid must not show again. doneThen just run it as:
./bgkill.sh
with proper permissions of courseroot@umsstd22 [P]:~# ./bgkill.sh PID=23757 dPidLst= 23758 23759 UNO DOS UID PID PPID C STIME TTY TIME CMD root 3937 3935 0 11:07 pts/5 00:00:00 -bash root 23757 3937 0 11:55 pts/5 00:00:00 /bin/bash ./bgkill.sh root 23758 23757 0 11:55 pts/5 00:00:00 tail -f UNO.txt root 23759 23757 0 11:55 pts/5 00:00:00 tail -f DOS.txt root 23760 23757 0 11:55 pts/5 00:00:00 ps -f killing 23758. Process is still there. 23758 pts/5 00:00:00 tail ./bgkill.sh: line 24: 23758 Terminated tail -f UNO.txt Just ran 'ps' command, 23758 must not show again. killing 23759. Process is still there. 23759 pts/5 00:00:00 tail ./bgkill.sh: line 24: 23759 Terminated tail -f DOS.txt Just ran 'ps' command, 23759 must not show again. root@umsstd22 [P]:~# ps -f UID PID PPID C STIME TTY TIME CMD root 3937 3935 0 11:07 pts/5 00:00:00 -bash root 24200 3937 0 11:56 pts/5 00:00:00 ps -fPhil ,Oct 15, 2013 at 18:22
You might also be able to use pstree:pstree -p userThis typically gives a text representation of all the processes for the "user" and the -p option gives the process-id. It does not depend, as far as I understand, on having the processes be owned by the current shell. It also shows forks.
Phil ,Dec 4, 2018 at 9:46
pgrep
can get you all of the child PIDs of a parent process. As mentioned earlier$$
is the current scripts PID. So, if you want a script that cleans up after itself, this should do the trick:trap 'kill $( pgrep -P $$ | tr "\n" " " )' SIGINT SIGTERM EXIT
Aug 10, 2019 | www.cyberciti.biz
The stat command shows information about the file. The syntax is as follows to get the file size on GNU/Linux stat:
stat -c %s "/etc/passwd"
OR
stat --format=%s "/etc/passwd"
Aug 10, 2019 | stackoverflow.com
[ -n file.txt ]
doesn't check its size , it checks that the stringfile.txt
is non-zero length, so it will always succeed.If you want to say " size is non-zero", you need
[ -s file.txt ]
.To get a file's size , you can use
wc -c
to get the size ( file length) in bytes:file=file.txt minimumsize=90000 actualsize=$(wc -c <"$file") if [ $actualsize -ge $minimumsize ]; then echo size is over $minimumsize bytes else echo size is under $minimumsize bytes fiIn this case, it sounds like that's what you want.
But FYI, if you want to know how much disk space the file is using, you could use
du -k
to get the size (disk space used) in kilobytes:file=file.txt minimumsize=90 actualsize=$(du -k "$file" | cut -f 1) if [ $actualsize -ge $minimumsize ]; then echo size is over $minimumsize kilobytes else echo size is under $minimumsize kilobytes fiIf you need more control over the output format, you can also look at
stat
. On Linux, you'd start with something likestat -c '%s' file.txt
, and on BSD/Mac OS X, something likestat -f '%z' file.txt
.--Mikel
- 5 Why
du -b "$file" | cut -f 1
instead ofstat -c '%s' "$file"
? Orstat --printf="%s" "$file"
? – mivk Dec 14 '13 at 11:00- 1 Only because it's more portable. BSD and Linux
stat
have different flags. – Mikel Dec 16 '13 at 16:40- 2 Mac OS can't
du -b
– Nakilon Apr 13 '14 at 5:28On Linux, you'd start with something like
stat -c '%s' file.txt
, and on BSD/Mac OS X, something likestat -f '%z' file.txt
.Oz Solomon ,Jun 13, 2014 at 21:44
It surprises me that no one mentionedstat
to check file size. Some methods are definitely better: using-s
to find out whether the file is empty or not is easier than anything else if that's all you want. And if you want to find files of a size, thenfind
is certainly the way to go.I also like
du
a lot to get file size in kb, but, for bytes, I'd usestat
:size=$(stat -f%z $filename) # BSD stat size=$(stat -c%s $filename) # GNU stat?alternative solution with awk and double parenthesis:FILENAME=file.txt SIZE=$(du -sb $FILENAME | awk '{ print $1 }') if ((SIZE<90000)) ; then echo "less"; else echo "not less"; fi
Jul 26, 2019 | www.linuxuprising.com
While it does have its own cheat sheet repository too, the project is actually concentrated around the creation of a unified mechanism to access well developed and maintained cheat sheet repositories.
The tool is developed by Igor Chubin, also known for its console-oriented weather forecast service wttr.in , which can be used to retrieve the weather from the console using only cURL or Wget.
It's worth noting that cheat.sh is not new. In fact it had its initial commit around May, 2017, and is a very popular repository on GitHub. But I personally only came across it recently, and I found it very useful, so I figured there must be some Linux Uprising readers who are not aware of this cool gem.
cheat.sh features & more
cheat.sh major features:The command line client features a special shell mode with a persistent queries context and readline support. It also has a query history, it integrates with the clipboard, supports tab completion for shells like Bash, Fish and Zsh, and it includes the stealth mode I mentioned in the cheat.sh features.
- Supports 58 programming languages , several DBMSes, and more than 1000 most important UNIX/Linux commands
- Very fast, returns answers within 100ms
- Simple curl / browser interface
- An optional command line client (cht.sh) is available, which allows you to quickly search cheat sheets and easily copy snippets without leaving the terminal
- Can be used from code editors, allowing inserting code snippets without having to open a web browser, search for the code, copy it, then return to your code editor and paste it. It supports Vim, Emacs, Visual Studio Code, Sublime Text and IntelliJ Idea
- Comes with a special stealth mode in which any text you select (adding it into the selection buffer of X Window System or into the clipboard) is used as a search query by cht.sh, so you can get answers without touching any other keys
The web, curl and cht.sh (command line) interfaces all make use of https://cheat.sh/ but if you prefer, you can self-host it .
It should be noted that each editor plugin supports a different feature set (configurable server, multiple answers, toggle comments, and so on). You can view a feature comparison of each cheat.sh editor plugin on the Editors integration section of the project's GitHub page.
Want to contribute a cheat sheet? See the cheat.sh guide on editing or adding a new cheat sheet.
Interested in bookmarking commands instead? You may want to give Marker, a command bookmark manager for the console , a try.
cheat.sh curl / command line client usage examples
Examples of using cheat.sh using the curl interface (this requires having curl installed as you'd expect) from the command line:Show the
tar
command cheat sheet:curl cheat.sh/tar
Example with output:$ curl cheat.sh/tar # To extract an uncompressed archive: tar -xvf /path/to/foo.tar # To create an uncompressed archive: tar -cvf /path/to/foo.tar /path/to/foo/ # To extract a .gz archive: tar -xzvf /path/to/foo.tgz # To create a .gz archive: tar -czvf /path/to/foo.tgz /path/to/foo/ # To list the content of an .gz archive: tar -ztvf /path/to/foo.tgz # To extract a .bz2 archive: tar -xjvf /path/to/foo.tgz # To create a .bz2 archive: tar -cjvf /path/to/foo.tgz /path/to/foo/ # To extract a .tar in specified Directory: tar -xvf /path/to/foo.tar -C /path/to/destination/ # To list the content of an .bz2 archive: tar -jtvf /path/to/foo.tgz # To create a .gz archive and exclude all jpg,gif,... from the tgz tar czvf /path/to/foo.tgz --exclude=\*.{jpg,gif,png,wmv,flv,tar.gz,zip} /path/to/foo/ # To use parallel (multi-threaded) implementation of compression algorithms: tar -z ... -> tar -Ipigz ... tar -j ... -> tar -Ipbzip2 ... tar -J ... -> tar -Ipixz ...
cht.sh also works instead of cheat.sh:curl cht.sh/tar
Want to search for akeyword
in all cheat sheets? Use:curl cheat.sh/~keyword
List the Python programming language cheat sheet forrandom list
:curl cht.sh/python/random+list
Example with output:$ curl cht.sh/python/random+list # python - How to randomly select an item from a list? # # Use random.choice # (https://docs.python.org/2/library/random.htmlrandom.choice): import random foo = ['a', 'b', 'c', 'd', 'e'] print(random.choice(foo)) # For cryptographically secure random choices (e.g. for generating a # passphrase from a wordlist), use random.SystemRandom # (https://docs.python.org/2/library/random.htmlrandom.SystemRandom) # class: import random foo = ['battery', 'correct', 'horse', 'staple'] secure_random = random.SystemRandom() print(secure_random.choice(foo)) # [Pēteris Caune] [so/q/306400] [cc by-sa 3.0]
Replacepython
with some other programming language supported by cheat.sh, andrandom+list
with the cheat sheet you want to show.Want to eliminate the comments from your answer? Add
?Q
at the end of the query (below is an example using the same /python/random+list):$ curl cht.sh/python/random+list?Q import random foo = ['a', 'b', 'c', 'd', 'e'] print(random.choice(foo)) import random foo = ['battery', 'correct', 'horse', 'staple'] secure_random = random.SystemRandom() print(secure_random.choice(foo))
For more flexibility and tab completion you can use cht.sh, the command line cheat.sh client; you'll find instructions for how to install it further down this article. Examples of using the cht.sh command line client:Show the
tar
command cheat sheet:cht.sh tar
List the Python programming language cheat sheet forrandom list
:cht.sh python random list
There is no need to use quotes with multiple keywords.You can start the cht.sh client in a special shell mode using:
cht.sh --shell
And then you can start typing your queries. Example:$ cht.sh --shell cht.sh> bash loop
If all your queries are about the same programming language, you can start the client in the special shell mode, directly in that context. As an example, start it with the Bash context using:cht.sh --shell bash
Example with output:$ cht.sh --shell bash cht.sh/bash> loop ........... cht.sh/bash> switch case
Want to copy the previously listed answer to the clipboard? Typec
, then pressEnter
to copy the whole answer, or typeC
and pressEnter
to copy it without comments.Type
help
in the cht.sh interactive shell mode to see all available commands. Also look under the Usage section from the cheat.sh GitHub project page for more options and advanced usage.How to install cht.sh command line client
You can use cheat.sh in a web browser, from the command line with the help of curl and without having to install anything else, as explained above, as a code editor plugin, or using its command line client which has some extra features, which I already mentioned. The steps below are for installing this cht.sh command line client.If you'd rather install a code editor plugin for cheat.sh, see the Editors integration page.
1. Install dependencies.
To install the cht.sh command line client, the
curl
command line tool will be used, so this needs to be installed on your system. Another dependency isrlwrap
, which is required by the cht.sh special shell mode. Install these dependencies as follows.
- Debian, Ubuntu, Linux Mint, Pop!_OS, and any other Linux distribution based on Debian or Ubuntu:
sudo apt install curl rlwrap
- Fedora:
sudo dnf install curl rlwrap
- Arch Linux, Manjaro:
sudo pacman -S curl rlwrap
- openSUSE:
sudo zypper install curl rlwrap
The packages seem to be named the same on most (if not all) Linux distributions, so if your Linux distribution is not on this list, just install thecurl
andrlwrap
packages using your distro's package manager.2. Download and install the cht.sh command line interface.
You can install this either for your user only (so only you can run it), or for all users:
- Install it for your user only. The command below assumes you have a
~/.bin
folder added to yourPATH
(and the folder exists). If you have some other local folder in yourPATH
where you want to install cht.sh, change install path in the commands:curl https://cht.sh/:cht.sh > ~/.bin/cht.sh chmod +x ~/.bin/cht.sh
- Install it for all users (globally, in
/usr/local/bin
):curl https://cht.sh/:cht.sh | sudo tee /usr/local/bin/cht.sh sudo chmod +x /usr/local/bin/cht.sh
If the first command appears to have frozen displaying only the cURL output, press theEnter
key and you'll be prompted to enter your password in order to save the file to/usr/local/bin
.You may also download and install the cheat.sh command completion for Bash or Zsh:
- Bash:
mkdir ~/.bash.d curl https://cheat.sh/:bash_completion > ~/.bash.d/cht.sh echo ". ~/.bash.d/cht.sh" >> ~/.bashrc
- Zsh:
mkdir ~/.zsh.d curl https://cheat.sh/:zsh > ~/.zsh.d/_cht echo 'fpath=(~/.zsh.d/ $fpath)' >> ~/.zshrc
Opening a new shell / terminal and it will load the cheat.sh completion.
Jul 23, 2019 | www.maketecheasier.com
... ... ...In technical terms, "/dev/null" is a virtual device file. As far as programs are concerned, these are treated just like real files. Utilities can request data from this kind of source, and the operating system feeds them data. But, instead of reading from disk, the operating system generates this data dynamically. An example of such a file is "/dev/zero."
In this case, however, you will write to a device file. Whatever you write to "/dev/null" is discarded, forgotten, thrown into the void. To understand why this is useful, you must first have a basic understanding of standard output and standard error in Linux or *nix type operating systems.
Related : How to Use the Tee Command in Linux
stdout and stderA command-line utility can generate two types of output. Standard output is sent to stdout. Errors are sent to stderr.
By default, stdout and stderr are associated with your terminal window (or console). This means that anything sent to stdout and stderr is normally displayed on your screen. But through shell redirections, you can change this behavior. For example, you can redirect stdout to a file. This way, instead of displaying output on the screen, it will be saved to a file for you to read later – or you can redirect stdout to a physical device, say, a digital LED or LCD display.
A full article about pipes and redirections is available if you want to learn more.
- With
2>
you redirect standard error messages. Example:2>/dev/null
or2>/home/user/error.log
.- With
1>
you redirect standard output.- With
&>
you redirect both standard error and standard output.Related : 12 Useful Linux Commands for New User
Use /dev/null to Get Rid of Output You Don't NeedSince there are two types of output, standard output and standard error, the first use case is to filter out one type or the other. It's easier to understand through a practical example. Let's say you're looking for a string in "/sys" to find files that refer to power settings.
grep -r power /sys/There will be a lot of files that a regular, non-root user cannot read. This will result in many "Permission denied" errors.
These clutter the output and make it harder to spot the results that you're looking for. Since "Permission denied" errors are part of stderr, you can redirect them to "/dev/null."
grep -r power /sys/ 2>/dev/nullAs you can see, this is much easier to read.
In other cases, it might be useful to do the reverse: filter out standard output so you can only see errors.
ping google.com 1>/dev/nullThe screenshot above shows that, without redirecting, ping displays its normal output when it can reach the destination machine. In the second command, nothing is displayed while the network is online, but as soon as it gets disconnected, only error messages are displayed.
You can redirect both stdout and stderr to two different locations.
ping google.com 1>/dev/null 2>error.logIn this case, stdout messages won't be displayed at all, and error messages will be saved to the "error.log" file.
Redirect All Output to /dev/nullSometimes it's useful to get rid of all output. There are two ways to do this.
grep -r power /sys/ >/dev/null 2>&1The string
>/dev/null
means "send stdout to /dev/null," and the second part,2>&1
, means send stderr to stdout. In this case you have to refer to stdout as "&1" instead of simply "1." Writing "2>1" would just redirect stdout to a file named "1."What's important to note here is that the order is important. If you reverse the redirect parameters like this:
grep -r power /sys/ 2>&1 >/dev/nullit won't work as intended. That's because as soon as
2>&1
is interpreted, stderr is sent to stdout and displayed on screen. Next, stdout is supressed when sent to "/dev/null." The final result is that you will see errors on the screen instead of suppressing all output. If you can't remember the correct order, there's a simpler redirect that is much easier to type:grep -r power /sys/ &>/dev/nullIn this case,
Other Examples Where It Can Be Useful to Redirect to /dev/null&>/dev/null
is equivalent to saying "redirect both stdout and stderr to this location."Say you want to see how fast your disk can read sequential data. The test is not extremely accurate but accurate enough. You can use
dd
for this, but dd either outputs to stdout or can be instructed to write to a file. Withof=/dev/null
you can tell dd to write to this virtual file. You don't even have to use shell redirections here.if=
specifies the location of the input file to be read;of=
specifies the name of the output file, where to write.dd if=debian-disk.qcow2 of=/dev/null status=progress bs=1M iflag=directIn some scenarios, you may want to see how fast you can download from a server. But you don't want to write to your disk unnecessarily. Simply enough, don't write to a regular file, write to "/dev/null."
wget -O /dev/null http://ftp.halifax.rwth-aachen.de/ubuntu-releases/18.04/ubuntu-18.04.2-desktop-amd64.isoConclusionHopefully, the examples in this article can inspire you to find your own creative ways to use "/dev/null."
Know an interesting use-case for this special device file? Leave a comment below and share the knowledge!
Jun 18, 2019 | linuxconfig.org
Before proceeding further, let me give you one tip. In the example above the shell tried to expand a non-existing variable, producing a blank result. This can be very dangerous, especially when working with path names, therefore, when writing scripts, it's always recommended to use the
nounset
option which causes the shell to exit with error whenever a non existing variable is referenced:$ set -o nounset $ echo "You are reading this article on $site_!" bash: site_: unbound variableWorking with indirectionThe use of the
${!parameter}
syntax, adds a level of indirection to our parameter expansion. What does it mean? The parameter which the shell will try to expand is notparameter
; instead it will try to use the the value ofparameter
as the name of the variable to be expanded. Let's explain this with an example. We all know theHOME
variable expands in the path of the user home directory in the system, right?$ echo "${HOME}" /home/egdocVery well, if now we assign the string "HOME", to another variable, and use this type of expansion, we obtain:
$ variable_to_inspect="HOME" $ echo "${!variable_to_inspect}" /home/egdocAs you can see in the example above, instead of obtaining "HOME" as a result, as it would have happened if we performed a simple expansion, the shell used the value of
Case modification expansionvariable_to_inspect
as the name of the variable to expand, that's why we talk about a level of indirection.This parameter expansion syntax let us change the case of the alphabetic characters inside the string resulting from the expansion of the parameter. Say we have a variable called
name
; to capitalize the text returned by the expansion of the variable we would use the${parameter^}
syntax:$ name="egidio" $ echo "${name^}" EgidioWhat if we want to uppercase the entire string, instead of capitalize it? Easy! we use the
${parameter^^}
syntax:$ echo "${name^^}" EGIDIOSimilarly, to lowercase the first character of a string, we use the
${parameter,}
expansion syntax:$ name="EGIDIO" $ echo "${name,}" eGIDIOTo lowercase the entire string, instead, we use the
${parameter,,}
syntax:$ name="EGIDIO" $ echo "${name,,}" egidioIn all cases a
pattern
to match a single character can also be provided. When the pattern is provided the operation is applied only to the parts of the original string that matches it:$ name="EGIDIO" $ echo "${name,,[DIO]}" EGidio
In the example above we enclose the characters in square brackets: this causes anyone of them to be matched as a pattern.
When using the expansions we explained in this paragraph and the
parameter
is an array subscripted by@
or*
, the operation is applied to all the elements contained in it:$ my_array=(one two three) $ echo "${my_array[@]^^}" ONE TWO THREEWhen the index of a specific element in the array is referenced, instead, the operation is applied only to it:
$ my_array=(one two three) $ echo "${my_array[2]^^}" THREESubstring removalThe next syntax we will examine allows us to remove a
pattern
from the beginning or from the end of string resulting from the expansion of a parameter.Remove matching pattern from the beginning of the stringThe next syntax we will examine,
${parameter#pattern}
, allows us to remove apattern
from the beginning of the string resulting from theparameter
expansion:$ name="Egidio" $ echo "${name#Egi}" dioA similar result can be obtained by using the
"${parameter##pattern}"
syntax, but with one important difference: contrary to the one we used in the example above, which removes the shortest matching pattern from the beginning of the string, it removes the longest one. The difference is clearly visible when using the*
character in thepattern
:$ name="Egidio Docile" $ echo "${name#*i}" dio DocileIn the example above we used
*
as part of the pattern that should be removed from the string resulting by the expansion of thename
variable. Thiswildcard
matches any character, so the pattern itself translates in "'i' character and everything before it". As we already said, when we use the${parameter#pattern}
syntax, the shortest matching pattern is removed, in this case it is "Egi". Let's see what happens when we use the"${parameter##pattern}"
syntax instead:$ name="Egidio Docile" $ echo "${name##*i}" leThis time the longest matching pattern is removed ("Egidio Doci"): the longest possible match includes the third 'i' and everything before it. The result of the expansion is just "le".
Remove matching pattern from the end of the stringThe syntax we saw above remove the shortest or longest matching pattern from the beginning of the string. If we want the pattern to be removed from the end of the string, instead, we must use the
${parameter%pattern}
or${parameter%%pattern}
expansions, to remove, respectively, the shortest and longest match from the end of the string:$ name="Egidio Docile" $ echo "${name%i*}" Egidio DocIn this example the pattern we provided roughly translates in "'i' character and everything after it starting from the end of the string". The shortest match is "ile", so what is returned is "Egidio Doc". If we try the same example but we use the syntax which removes the longest match we obtain:
$ name="Egidio Docile" $ echo "${name%%i*}" EgIn this case the once the longest match is removed, what is returned is "Eg".
In all the expansions we saw above, if
parameter
is an array and it is subscripted with*
or@
, the removal of the matching pattern is applied to all its elements:$ my_array=(one two three) $ echo "${my_array[@]#*o}" ne three
Search and replace patternWe used the previous syntax to remove a matching pattern from the beginning or from the end of the string resulting from the expansion of a parameter. What if we want to replace
pattern
with something else? We can use the${parameter/pattern/string}
or${parameter//pattern/string}
syntax. The former replaces only the first occurrence of the pattern, the latter all the occurrences:$ phrase="yellow is the sun and yellow is the lemon" $ echo "${phrase/yellow/red}" red is the sun and yellow is the lemonThe
parameter
(phrase) is expanded, and the longest match of thepattern
(yellow) is matched against it. The match is then replaced by the providedstring
(red). As you can observe only the first occurrence is replaced, so the lemon remains yellow! If we want to change all the occurrences of the pattern, we must prefix it with the/
character:$ phrase="yellow is the sun and yellow is the lemon" $ echo "${phrase//yellow/red}" red is the sun and red is the lemonThis time all the occurrences of "yellow" has been replaced by "red". As you can see the pattern is matched wherever it is found in the string resulting from the expansion of
parameter
. If we want to specify that it must be matched only at the beginning or at the end of the string, we must prefix it respectively with the#
or%
character.Just like in the previous cases, if
parameter
is an array subscripted by either*
or@
, the substitution happens in each one of its elements:$ my_array=(one two three) $ echo "${my_array[@]/o/u}" une twu threeSubstring expansionThe
${parameter:offset}
and${parameter:offset:length}
expansions let us expand only a part of the parameter, returning a substring starting at the specifiedoffset
andlength
characters long. If the length is not specified the expansion proceeds until the end of the original string. This type of expansion is calledsubstring expansion
:$ name="Egidio Docile" $ echo "${name:3}" dio DocileIn the example above we provided just the
offset
, without specifying thelength
, therefore the result of the expansion was the substring obtained by starting at the character specified by the offset (3).If we specify a length, the substring will start at
offset
and will belength
characters long:$ echo "${name:3:3}" dioIf the
offset
is negative, it is calculated from the end of the string. In this case an additional space must be added after:
otherwise the shell will consider it as another type of expansion identified by:-
which is used to provide a default value if the parameter to be expanded doesn't exist (we talked about it in the article about managing the expansion of empty or unset bash variables ):$ echo "${name: -6}" DocileIf the provided
length
is negative, instead of being interpreted as the total number of characters the resulting string should be long, it is considered as an offset to be calculated from the end of the string. The result of the expansion will therefore be a substring starting atoffset
and ending atlength
characters from the end of the original string:$ echo "${name:7:-3}" DocWhen using this expansion and
parameter
is an indexed array subscribed by*
or@
, theoffset
is relative to the indexes of the array elements. For example:$ my_array=(one two three) $ echo "${my_array[@]:0:2}" one two $ echo "${my_array[@]: -2}" two three
Mar 25, 2019 | linuxize.com
https://acdn.adnxs.com/ib/static/usersync/v3/async_usersync.html
https://bh.contextweb.com/visitormatch
Concatenating Strings with the += OperatorAnother way of concatenating strings in bash is by appending variables or literal strings to a variable using the
+=
operator:VAR1="Hello, " VAR1+=" World" echo "$VAR1"Hello, WorldThe following example is using the
languages.sh+=
operator to concatenate strings in bash for loop :VAR="" for ELEMENT in 'Hydrogen' 'Helium' 'Lithium' 'Beryllium'; do VAR+="${ELEMENT} " done echo "$VAR"
Feb 21, 2019 | alvinalexander.com
By Alvin Alexander. Last updated: June 22 2017 Unix/Linux bash shell script FAQ: How do I prompt a user for input from a shell script (Bash shell script), and then read the input the user provides?
Answer: I usually use the shell script
read
function to read input from a shell script. Here are two slightly different versions of the same shell script. This first version prompts the user for input only once, and then dies if the user doesn't give a correct Y/N answer:# (1) prompt user, and read command line argument read -p "Run the cron script now? " answer # (2) handle the command line argument we were given while true do case $answer in [yY]* ) /usr/bin/wget -O - -q -t 1 http://www.example.com/cron.php echo "Okay, just ran the cron script." break;; [nN]* ) exit;; * ) echo "Dude, just enter Y or N, please."; break ;; esac doneThis second version stays in a loop until the user supplies a Y/N answer:
while true do # (1) prompt user, and read command line argument read -p "Run the cron script now? " answer # (2) handle the input we were given case $answer in [yY]* ) /usr/bin/wget -O - -q -t 1 http://www.example.com/cron.php echo "Okay, just ran the cron script." break;; [nN]* ) exit;; * ) echo "Dude, just enter Y or N, please.";; esac doneI prefer the second approach, but I thought I'd share both of them here. They are subtly different, so not the extra break in the first script.
This Linux Bash 'read' function is nice, because it does both things, prompting the user for input, and then reading the input. The other nice thing it does is leave the cursor at the end of your prompt, as shown here:
Run the cron script now? _(This is so much nicer than what I had to do years ago.)
Nov 17, 2018 | dvorka.github.io
Configuration
Get most of HSTR by configuring it with:
hstr --show-configuration >> ~/.bashrcRun
hstr --show-configuration
to determine what will be appended to your Bash profile. Don't forget to source~/.bashrc
to apply changes.
For more configuration options details please refer to:
- bind HSTR to a keyboard shortcut
- Bash Emacs keymap (default)
- Bash Vim keymap
- zsh Emacs keymap (default)
- create
hh
alias forhstr
- het more colors
- choose default history view
- set filtering preferences
- configure commands blacklist
- disable confirm on delete
- tune verbosity
- history settings:
Check also configuration examples .
Binding HSTR to Keyboard ShortcutBash uses Emacs style keyboard shortcuts by default. There is also Vi mode. Find out how to bind HSTR to a keyboard shortcut based on the style you prefer below.
Check your active Bash keymap with:
bind -v | grep editing-mode bind -v | grep keymapTo determine character sequence emitted by a pressed key in terminal, type Ctrl-v and then press the key. Check your current bindings using:
bind -SBash Emacs Keymap (default)Bind HSTR to a Bash key e.g. to Ctrl-r :
bind '"\C-r": "\C-ahstr -- \C-j"'or Ctrl-Altr :
bind '"\e\C-r":"\C-ahstr -- \C-j"'or Ctrl-F12 :
bind '"\e[24;5~":"\C-ahstr -- \C-j"'Bind HSTR to Ctrl-r only if it is interactive shell:
if [[ $- =~ .*i.* ]]; then bind '"\C-r": "\C-a hstr -- \C-j"'; fiYou can bind also other HSTR commands like
--kill-last-command
:if [[ $- =~ .*i.* ]]; then bind '"\C-xk": "\C-a hstr -k \C-j"'; fiBash Vim KeymapBind HSTR to a Bash key e.g. to Ctrlr :
bind '"\C-r": "\e0ihstr -- \C-j"'Zsh Emacs KeymapBind HSTR to a
zsh
key e.g. to Ctrlr :bindkey -s "\C-r" "\eqhstr --\n"AliasIf you want to make running of
hstr
from command line even easier, then define alias in your~/.bashrc
:alias hh=hstrDon't forget to source
Colors~/.bashrc
to be able to to usehh
command.Let HSTR to use colors:
export HSTR_CONFIG=hicoloror ensure black and white mode:
export HSTR_CONFIG=monochromaticDefault History ViewTo show normal history by default (instead of metrics-based view, which is default) use:
export HSTR_CONFIG=raw-history-viewTo show favorite commands as default view use:
export HSTR_CONFIG=favorites-viewFilteringTo use regular expressions based matching:
export HSTR_CONFIG=regexp-matchingTo use substring based matching:
export HSTR_CONFIG=substring-matchingTo use keywords (substrings whose order doesn't matter) search matching (default):
export HSTR_CONFIG=keywords-matching
Make search case sensitive (insensitive by default):
export HSTR_CONFIG=case-sensitiveKeep duplicates in
raw-history-view
(duplicate commands are discarded by default):export HSTR_CONFIG=duplicatesStatic favoritesLast selected favorite command is put the head of favorite commands list by default. If you want to disable this behavior and make favorite commands list static, then use the following configuration:
export HSTR_CONFIG=static-favoritesSkip favorites commentsIf you don't want to show lines starting with
#
(comments) among favorites, then use the following configuration:export HSTR_CONFIG=skip-favorites-commentsBlacklistSkip commands when processing history i.e. make sure that these commands will not be shown in any view:
export HSTR_CONFIG=blacklistCommands to be stored in
~/.hstr_blacklist
file with trailing empty line. For instance:cd my-private-command ls llConfirm on DeleteDo not prompt for confirmation when deleting history items:
export HSTR_CONFIG=no-confirmVerbosityShow a message when deleting the last command from history:
export HSTR_CONFIG=verbose-killShow warnings:
export HSTR_CONFIG=warningShow debug messages:
export HSTR_CONFIG=debugBash History SettingsUse the following Bash settings to get most out of HSTR.
Increase the size of history maintained by BASH - variables defined below increase the number of history items and history file size (default value is 500):
export HISTFILESIZE=10000 export HISTSIZE=${HISTFILESIZE}Ensure syncing (flushing and reloading) of
.bash_history
with in-memory history:export PROMPT_COMMAND="history -a; history -n; ${PROMPT_COMMAND}"Force appending of in-memory history to
.bash_history
(instead of overwriting):shopt -s histappendUse leading space to hide commands from history:
export HISTCONTROL=ignorespaceSuitable for a sensitive information like passwords.
zsh History SettingsIf you use
zsh
, setHISTFILE
environment variable in~/.zshrc
:export HISTFILE=~/.zsh_historyExamplesMore colors with case sensitive search of history:
export HSTR_CONFIG=hicolor,case-sensitiveFavorite commands view in black and white with prompt at the bottom of the screen:
export HSTR_CONFIG=favorites-view,prompt-bottomKeywords based search in colors with debug mode verbosity:
export HSTR_CONFIG=keywords-matching,hicolor,debug
May 14, 2012 | stackoverflow.com
Lgn ,May 14, 2012 at 15:15
In a Bash script I would like to split a line into pieces and store them in an array.The line:
Paris, France, EuropeI would like to have them in an array like this:
array[0] = Paris array[1] = France array[2] = EuropeI would like to use simple code, the command's speed doesn't matter. How can I do it?
antak ,Jun 18, 2018 at 9:22
This is #1 Google hit but there's controversy in the answer because the question unfortunately asks about delimiting on,
(comma-space) and not a single character such as comma. If you're only interested in the latter, answers here are easier to follow: stackoverflow.com/questions/918886/ – antak Jun 18 '18 at 9:22Dennis Williamson ,May 14, 2012 at 15:16
IFS=', ' read -r -a array <<< "$string"Note that the characters in
$IFS
are treated individually as separators so that in this case fields may be separated by either a comma or a space rather than the sequence of the two characters. Interestingly though, empty fields aren't created when comma-space appears in the input because the space is treated specially.To access an individual element:
echo "${array[0]}"To iterate over the elements:
for element in "${array[@]}" do echo "$element" doneTo get both the index and the value:
for index in "${!array[@]}" do echo "$index ${array[index]}" doneThe last example is useful because Bash arrays are sparse. In other words, you can delete an element or add an element and then the indices are not contiguous.
unset "array[1]" array[42]=EarthTo get the number of elements in an array:
echo "${#array[@]}"As mentioned above, arrays can be sparse so you shouldn't use the length to get the last element. Here's how you can in Bash 4.2 and later:
echo "${array[-1]}"in any version of Bash (from somewhere after 2.05b):
echo "${array[@]: -1:1}"Larger negative offsets select farther from the end of the array. Note the space before the minus sign in the older form. It is required.
l0b0 ,May 14, 2012 at 15:24
Just useIFS=', '
, then you don't have to remove the spaces separately. Test:IFS=', ' read -a array <<< "Paris, France, Europe"; echo "${array[@]}"
– l0b0 May 14 '12 at 15:24Dennis Williamson ,May 14, 2012 at 16:33
@l0b0: Thanks. I don't know what I was thinking. I like to usedeclare -p array
for test output, by the way. – Dennis Williamson May 14 '12 at 16:33Nathan Hyde ,Mar 16, 2013 at 21:09
@Dennis Williamson - Awesome, thorough answer. – Nathan Hyde Mar 16 '13 at 21:09dsummersl ,Aug 9, 2013 at 14:06
MUCH better than multiplecut -f
calls! – dsummersl Aug 9 '13 at 14:06caesarsol ,Oct 29, 2015 at 14:45
Warning: the IFS variable means split by one of these characters , so it's not a sequence of chars to split by.IFS=', ' read -a array <<< "a,d r s,w"
=>${array[*]} == a d r s w
– caesarsol Oct 29 '15 at 14:45Jim Ho ,Mar 14, 2013 at 2:20
Here is a way without setting IFS:string="1:2:3:4:5" set -f # avoid globbing (expansion of *). array=(${string//:/ }) for i in "${!array[@]}" do echo "$i=>${array[i]}" doneThe idea is using string replacement:
${string//substring/replacement}to replace all matches of $substring with white space and then using the substituted string to initialize a array:
(element1 element2 ... elementN)Note: this answer makes use of the split+glob operator . Thus, to prevent expansion of some characters (such as
*
) it is a good idea to pause globbing for this script.Werner Lehmann ,May 4, 2013 at 22:32
Used this approach... until I came across a long string to split. 100% CPU for more than a minute (then I killed it). It's a pity because this method allows to split by a string, not some character in IFS. – Werner Lehmann May 4 '13 at 22:32Dieter Gribnitz ,Sep 2, 2014 at 15:46
WARNING: Just ran into a problem with this approach. If you have an element named * you will get all the elements of your cwd as well. thus string="1:2:3:4:*" will give some unexpected and possibly dangerous results depending on your implementation. Did not get the same error with (IFS=', ' read -a array <<< "$string") and this one seems safe to use. – Dieter Gribnitz Sep 2 '14 at 15:46akostadinov ,Nov 6, 2014 at 14:31
not reliable for many kinds of values, use with care – akostadinov Nov 6 '14 at 14:31Andrew White ,Jun 1, 2016 at 11:44
quoting${string//:/ }
prevents shell expansion – Andrew White Jun 1 '16 at 11:44Mark Thomson ,Jun 5, 2016 at 20:44
I had to use the following on OSX:array=(${string//:/ })
– Mark Thomson Jun 5 '16 at 20:44bgoldst ,Jul 19, 2017 at 21:20
All of the answers to this question are wrong in one way or another.
IFS=', ' read -r -a array <<< "$string"1: This is a misuse of
$IFS
. The value of the$IFS
variable is not taken as a single variable-length string separator, rather it is taken as a set of single-character string separators, where each field thatread
splits off from the input line can be terminated by any character in the set (comma or space, in this example).Actually, for the real sticklers out there, the full meaning of
$IFS
is slightly more involved. From the bash manual :The shell treats each character of IFS as a delimiter, and splits the results of the other expansions into words using these characters as field terminators. If IFS is unset, or its value is exactly <space><tab><newline> , the default, then sequences of <space> , <tab> , and <newline> at the beginning and end of the results of the previous expansions are ignored, and any sequence of IFS characters not at the beginning or end serves to delimit words. If IFS has a value other than the default, then sequences of the whitespace characters <space> , <tab> , and <newline> are ignored at the beginning and end of the word, as long as the whitespace character is in the value of IFS (an IFS whitespace character). Any character in IFS that is not IFS whitespace, along with any adjacent IFS whitespace characters, delimits a field. A sequence of IFS whitespace characters is also treated as a delimiter. If the value of IFS is null, no word splitting occurs.
Basically, for non-default non-null values of
$IFS
, fields can be separated with either (1) a sequence of one or more characters that are all from the set of "IFS whitespace characters" (that is, whichever of <space> , <tab> , and <newline> ("newline" meaning line feed (LF) ) are present anywhere in$IFS
), or (2) any non-"IFS whitespace character" that's present in$IFS
along with whatever "IFS whitespace characters" surround it in the input line.For the OP, it's possible that the second separation mode I described in the previous paragraph is exactly what he wants for his input string, but we can be pretty confident that the first separation mode I described is not correct at all. For example, what if his input string was
'Los Angeles, United States, North America'
?IFS=', ' read -ra a <<<'Los Angeles, United States, North America'; declare -p a; ## declare -a a=([0]="Los" [1]="Angeles" [2]="United" [3]="States" [4]="North" [5]="America")2: Even if you were to use this solution with a single-character separator (such as a comma by itself, that is, with no following space or other baggage), if the value of the
$string
variable happens to contain any LFs, thenread
will stop processing once it encounters the first LF. Theread
builtin only processes one line per invocation. This is true even if you are piping or redirecting input only to theread
statement, as we are doing in this example with the here-string mechanism, and thus unprocessed input is guaranteed to be lost. The code that powers theread
builtin has no knowledge of the data flow within its containing command structure.You could argue that this is unlikely to cause a problem, but still, it's a subtle hazard that should be avoided if possible. It is caused by the fact that the
read
builtin actually does two levels of input splitting: first into lines, then into fields. Since the OP only wants one level of splitting, this usage of theread
builtin is not appropriate, and we should avoid it.3: A non-obvious potential issue with this solution is that
read
always drops the trailing field if it is empty, although it preserves empty fields otherwise. Here's a demo:string=', , a, , b, c, , , '; IFS=', ' read -ra a <<<"$string"; declare -p a; ## declare -a a=([0]="" [1]="" [2]="a" [3]="" [4]="b" [5]="c" [6]="" [7]="")Maybe the OP wouldn't care about this, but it's still a limitation worth knowing about. It reduces the robustness and generality of the solution.
This problem can be solved by appending a dummy trailing delimiter to the input string just prior to feeding it to
read
, as I will demonstrate later.
string="1:2:3:4:5" set -f # avoid globbing (expansion of *). array=(${string//:/ })t="one,two,three" a=($(echo $t | tr ',' "\n"))(Note: I added the missing parentheses around the command substitution which the answerer seems to have omitted.)
string="1,2,3,4" array=(`echo $string | sed 's/,/\n/g'`)These solutions leverage word splitting in an array assignment to split the string into fields. Funnily enough, just like
read
, general word splitting also uses the$IFS
special variable, although in this case it is implied that it is set to its default value of <space><tab><newline> , and therefore any sequence of one or more IFS characters (which are all whitespace characters now) is considered to be a field delimiter.This solves the problem of two levels of splitting committed by
read
, since word splitting by itself constitutes only one level of splitting. But just as before, the problem here is that the individual fields in the input string can already contain$IFS
characters, and thus they would be improperly split during the word splitting operation. This happens to not be the case for any of the sample input strings provided by these answerers (how convenient...), but of course that doesn't change the fact that any code base that used this idiom would then run the risk of blowing up if this assumption were ever violated at some point down the line. Once again, consider my counterexample of'Los Angeles, United States, North America'
(or'Los Angeles:United States:North America'
).Also, word splitting is normally followed by filename expansion ( aka pathname expansion aka globbing), which, if done, would potentially corrupt words containing the characters
*
,?
, or[
followed by]
(and, ifextglob
is set, parenthesized fragments preceded by?
,*
,+
,@
, or!
) by matching them against file system objects and expanding the words ("globs") accordingly. The first of these three answerers has cleverly undercut this problem by runningset -f
beforehand to disable globbing. Technically this works (although you should probably addset +f
afterward to reenable globbing for subsequent code which may depend on it), but it's undesirable to have to mess with global shell settings in order to hack a basic string-to-array parsing operation in local code.Another issue with this answer is that all empty fields will be lost. This may or may not be a problem, depending on the application.
Note: If you're going to use this solution, it's better to use the
${string//:/ }
"pattern substitution" form of parameter expansion , rather than going to the trouble of invoking a command substitution (which forks the shell), starting up a pipeline, and running an external executable (tr
orsed
), since parameter expansion is purely a shell-internal operation. (Also, for thetr
andsed
solutions, the input variable should be double-quoted inside the command substitution; otherwise word splitting would take effect in theecho
command and potentially mess with the field values. Also, the$(...)
form of command substitution is preferable to the old`...`
form since it simplifies nesting of command substitutions and allows for better syntax highlighting by text editors.)
str="a, b, c, d" # assuming there is a space after ',' as in Q arr=(${str//,/}) # delete all occurrences of ','This answer is almost the same as #2 . The difference is that the answerer has made the assumption that the fields are delimited by two characters, one of which being represented in the default
$IFS
, and the other not. He has solved this rather specific case by removing the non-IFS-represented character using a pattern substitution expansion and then using word splitting to split the fields on the surviving IFS-represented delimiter character.This is not a very generic solution. Furthermore, it can be argued that the comma is really the "primary" delimiter character here, and that stripping it and then depending on the space character for field splitting is simply wrong. Once again, consider my counterexample:
'Los Angeles, United States, North America'
.Also, again, filename expansion could corrupt the expanded words, but this can be prevented by temporarily disabling globbing for the assignment with
set -f
and thenset +f
.Also, again, all empty fields will be lost, which may or may not be a problem depending on the application.
string='first line second line third line' oldIFS="$IFS" IFS=' ' IFS=${IFS:0:1} # this is useful to format your code with tabs lines=( $string ) IFS="$oldIFS"This is similar to #2 and #3 in that it uses word splitting to get the job done, only now the code explicitly sets
$IFS
to contain only the single-character field delimiter present in the input string. It should be repeated that this cannot work for multicharacter field delimiters such as the OP's comma-space delimiter. But for a single-character delimiter like the LF used in this example, it actually comes close to being perfect. The fields cannot be unintentionally split in the middle as we saw with previous wrong answers, and there is only one level of splitting, as required.One problem is that filename expansion will corrupt affected words as described earlier, although once again this can be solved by wrapping the critical statement in
set -f
andset +f
.Another potential problem is that, since LF qualifies as an "IFS whitespace character" as defined earlier, all empty fields will be lost, just as in #2 and #3 . This would of course not be a problem if the delimiter happens to be a non-"IFS whitespace character", and depending on the application it may not matter anyway, but it does vitiate the generality of the solution.
So, to sum up, assuming you have a one-character delimiter, and it is either a non-"IFS whitespace character" or you don't care about empty fields, and you wrap the critical statement in
set -f
andset +f
, then this solution works, but otherwise not.(Also, for information's sake, assigning a LF to a variable in bash can be done more easily with the
$'...'
syntax, e.g.IFS=$'\n';
.)
countries='Paris, France, Europe' OIFS="$IFS" IFS=', ' array=($countries) IFS="$OIFS"IFS=', ' eval 'array=($string)'This solution is effectively a cross between #1 (in that it sets
$IFS
to comma-space) and #2-4 (in that it uses word splitting to split the string into fields). Because of this, it suffers from most of the problems that afflict all of the above wrong answers, sort of like the worst of all worlds.Also, regarding the second variant, it may seem like the
eval
call is completely unnecessary, since its argument is a single-quoted string literal, and therefore is statically known. But there's actually a very non-obvious benefit to usingeval
in this way. Normally, when you run a simple command which consists of a variable assignment only , meaning without an actual command word following it, the assignment takes effect in the shell environment:IFS=', '; ## changes $IFS in the shell environmentThis is true even if the simple command involves multiple variable assignments; again, as long as there's no command word, all variable assignments affect the shell environment:
IFS=', ' array=($countries); ## changes both $IFS and $array in the shell environmentBut, if the variable assignment is attached to a command name (I like to call this a "prefix assignment") then it does not affect the shell environment, and instead only affects the environment of the executed command, regardless whether it is a builtin or external:
IFS=', ' :; ## : is a builtin command, the $IFS assignment does not outlive it IFS=', ' env; ## env is an external command, the $IFS assignment does not outlive itRelevant quote from the bash manual :
If no command name results, the variable assignments affect the current shell environment. Otherwise, the variables are added to the environment of the executed command and do not affect the current shell environment.
It is possible to exploit this feature of variable assignment to change
$IFS
only temporarily, which allows us to avoid the whole save-and-restore gambit like that which is being done with the$OIFS
variable in the first variant. But the challenge we face here is that the command we need to run is itself a mere variable assignment, and hence it would not involve a command word to make the$IFS
assignment temporary. You might think to yourself, well why not just add a no-op command word to the statement like the: builtin
to make the$IFS
assignment temporary? This does not work because it would then make the$array
assignment temporary as well:IFS=', ' array=($countries) :; ## fails; new $array value never escapes the : commandSo, we're effectively at an impasse, a bit of a catch-22. But, when
eval
runs its code, it runs it in the shell environment, as if it was normal, static source code, and therefore we can run the$array
assignment inside theeval
argument to have it take effect in the shell environment, while the$IFS
prefix assignment that is prefixed to theeval
command will not outlive theeval
command. This is exactly the trick that is being used in the second variant of this solution:IFS=', ' eval 'array=($string)'; ## $IFS does not outlive the eval command, but $array doesSo, as you can see, it's actually quite a clever trick, and accomplishes exactly what is required (at least with respect to assignment effectation) in a rather non-obvious way. I'm actually not against this trick in general, despite the involvement of
eval
; just be careful to single-quote the argument string to guard against security threats.But again, because of the "worst of all worlds" agglomeration of problems, this is still a wrong answer to the OP's requirement.
IFS=', '; array=(Paris, France, Europe) IFS=' ';declare -a array=(Paris France Europe)Um... what? The OP has a string variable that needs to be parsed into an array. This "answer" starts with the verbatim contents of the input string pasted into an array literal. I guess that's one way to do it.
It looks like the answerer may have assumed that the
$IFS
variable affects all bash parsing in all contexts, which is not true. From the bash manual:IFS The Internal Field Separator that is used for word splitting after expansion and to split lines into words with the read builtin command. The default value is <space><tab><newline> .
So the
$IFS
special variable is actually only used in two contexts: (1) word splitting that is performed after expansion (meaning not when parsing bash source code) and (2) for splitting input lines into words by theread
builtin.Let me try to make this clearer. I think it might be good to draw a distinction between parsing and execution . Bash must first parse the source code, which obviously is a parsing event, and then later it executes the code, which is when expansion comes into the picture. Expansion is really an execution event. Furthermore, I take issue with the description of the
$IFS
variable that I just quoted above; rather than saying that word splitting is performed after expansion , I would say that word splitting is performed during expansion, or, perhaps even more precisely, word splitting is part of the expansion process. The phrase "word splitting" refers only to this step of expansion; it should never be used to refer to the parsing of bash source code, although unfortunately the docs do seem to throw around the words "split" and "words" a lot. Here's a relevant excerpt from the linux.die.net version of the bash manual:Expansion is performed on the command line after it has been split into words. There are seven kinds of expansion performed: brace expansion , tilde expansion , parameter and variable expansion , command substitution , arithmetic expansion , word splitting , and pathname expansion .
The order of expansions is: brace expansion; tilde expansion, parameter and variable expansion, arithmetic expansion, and command substitution (done in a left-to-right fashion); word splitting; and pathname expansion.
You could argue the GNU version of the manual does slightly better, since it opts for the word "tokens" instead of "words" in the first sentence of the Expansion section:
Expansion is performed on the command line after it has been split into tokens.
The important point is,
$IFS
does not change the way bash parses source code. Parsing of bash source code is actually a very complex process that involves recognition of the various elements of shell grammar, such as command sequences, command lists, pipelines, parameter expansions, arithmetic substitutions, and command substitutions. For the most part, the bash parsing process cannot be altered by user-level actions like variable assignments (actually, there are some minor exceptions to this rule; for example, see the variouscompatxx
shell settings , which can change certain aspects of parsing behavior on-the-fly). The upstream "words"/"tokens" that result from this complex parsing process are then expanded according to the general process of "expansion" as broken down in the above documentation excerpts, where word splitting of the expanded (expanding?) text into downstream words is simply one step of that process. Word splitting only touches text that has been spit out of a preceding expansion step; it does not affect literal text that was parsed right off the source bytestream.
string='first line second line third line' while read -r line; do lines+=("$line"); done <<<"$string"This is one of the best solutions. Notice that we're back to using
read
. Didn't I say earlier thatread
is inappropriate because it performs two levels of splitting, when we only need one? The trick here is that you can callread
in such a way that it effectively only does one level of splitting, specifically by splitting off only one field per invocation, which necessitates the cost of having to call it repeatedly in a loop. It's a bit of a sleight of hand, but it works.But there are problems. First: When you provide at least one NAME argument to
read
, it automatically ignores leading and trailing whitespace in each field that is split off from the input string. This occurs whether$IFS
is set to its default value or not, as described earlier in this post. Now, the OP may not care about this for his specific use-case, and in fact, it may be a desirable feature of the parsing behavior. But not everyone who wants to parse a string into fields will want this. There is a solution, however: A somewhat non-obvious usage ofread
is to pass zero NAME arguments. In this case,read
will store the entire input line that it gets from the input stream in a variable named$REPLY
, and, as a bonus, it does not strip leading and trailing whitespace from the value. This is a very robust usage ofread
which I've exploited frequently in my shell programming career. Here's a demonstration of the difference in behavior:string=$' a b \n c d \n e f '; ## input string a=(); while read -r line; do a+=("$line"); done <<<"$string"; declare -p a; ## declare -a a=([0]="a b" [1]="c d" [2]="e f") ## read trimmed surrounding whitespace a=(); while read -r; do a+=("$REPLY"); done <<<"$string"; declare -p a; ## declare -a a=([0]=" a b " [1]=" c d " [2]=" e f ") ## no trimmingThe second issue with this solution is that it does not actually address the case of a custom field separator, such as the OP's comma-space. As before, multicharacter separators are not supported, which is an unfortunate limitation of this solution. We could try to at least split on comma by specifying the separator to the
-d
option, but look what happens:string='Paris, France, Europe'; a=(); while read -rd,; do a+=("$REPLY"); done <<<"$string"; declare -p a; ## declare -a a=([0]="Paris" [1]=" France")Predictably, the unaccounted surrounding whitespace got pulled into the field values, and hence this would have to be corrected subsequently through trimming operations (this could also be done directly in the while-loop). But there's another obvious error: Europe is missing! What happened to it? The answer is that
read
returns a failing return code if it hits end-of-file (in this case we can call it end-of-string) without encountering a final field terminator on the final field. This causes the while-loop to break prematurely and we lose the final field.Technically this same error afflicted the previous examples as well; the difference there is that the field separator was taken to be LF, which is the default when you don't specify the
-d
option, and the<<<
("here-string") mechanism automatically appends a LF to the string just before it feeds it as input to the command. Hence, in those cases, we sort of accidentally solved the problem of a dropped final field by unwittingly appending an additional dummy terminator to the input. Let's call this solution the "dummy-terminator" solution. We can apply the dummy-terminator solution manually for any custom delimiter by concatenating it against the input string ourselves when instantiating it in the here-string:a=(); while read -rd,; do a+=("$REPLY"); done <<<"$string,"; declare -p a; declare -a a=([0]="Paris" [1]=" France" [2]=" Europe")There, problem solved. Another solution is to only break the while-loop if both (1)
read
returned failure and (2)$REPLY
is empty, meaningread
was not able to read any characters prior to hitting end-of-file. Demo:a=(); while read -rd,|| [[ -n "$REPLY" ]]; do a+=("$REPLY"); done <<<"$string"; declare -p a; ## declare -a a=([0]="Paris" [1]=" France" [2]=$' Europe\n')This approach also reveals the secretive LF that automatically gets appended to the here-string by the
<<<
redirection operator. It could of course be stripped off separately through an explicit trimming operation as described a moment ago, but obviously the manual dummy-terminator approach solves it directly, so we could just go with that. The manual dummy-terminator solution is actually quite convenient in that it solves both of these two problems (the dropped-final-field problem and the appended-LF problem) in one go.So, overall, this is quite a powerful solution. It's only remaining weakness is a lack of support for multicharacter delimiters, which I will address later.
string='first line second line third line' readarray -t lines <<<"$string"(This is actually from the same post as #7 ; the answerer provided two solutions in the same post.)
The
readarray
builtin, which is a synonym formapfile
, is ideal. It's a builtin command which parses a bytestream into an array variable in one shot; no messing with loops, conditionals, substitutions, or anything else. And it doesn't surreptitiously strip any whitespace from the input string. And (if-O
is not given) it conveniently clears the target array before assigning to it. But it's still not perfect, hence my criticism of it as a "wrong answer".First, just to get this out of the way, note that, just like the behavior of
read
when doing field-parsing,readarray
drops the trailing field if it is empty. Again, this is probably not a concern for the OP, but it could be for some use-cases. I'll come back to this in a moment.Second, as before, it does not support multicharacter delimiters. I'll give a fix for this in a moment as well.
Third, the solution as written does not parse the OP's input string, and in fact, it cannot be used as-is to parse it. I'll expand on this momentarily as well.
For the above reasons, I still consider this to be a "wrong answer" to the OP's question. Below I'll give what I consider to be the right answer.
Right answer
Here's a naïve attempt to make #8 work by just specifying the
-d
option:string='Paris, France, Europe'; readarray -td, a <<<"$string"; declare -p a; ## declare -a a=([0]="Paris" [1]=" France" [2]=$' Europe\n')We see the result is identical to the result we got from the double-conditional approach of the looping
read
solution discussed in #7 . We can almost solve this with the manual dummy-terminator trick:readarray -td, a <<<"$string,"; declare -p a; ## declare -a a=([0]="Paris" [1]=" France" [2]=" Europe" [3]=$'\n')The problem here is that
readarray
preserved the trailing field, since the<<<
redirection operator appended the LF to the input string, and therefore the trailing field was not empty (otherwise it would've been dropped). We can take care of this by explicitly unsetting the final array element after-the-fact:readarray -td, a <<<"$string,"; unset 'a[-1]'; declare -p a; ## declare -a a=([0]="Paris" [1]=" France" [2]=" Europe")The only two problems that remain, which are actually related, are (1) the extraneous whitespace that needs to be trimmed, and (2) the lack of support for multicharacter delimiters.
The whitespace could of course be trimmed afterward (for example, see How to trim whitespace from a Bash variable? ). But if we can hack a multicharacter delimiter, then that would solve both problems in one shot.
Unfortunately, there's no direct way to get a multicharacter delimiter to work. The best solution I've thought of is to preprocess the input string to replace the multicharacter delimiter with a single-character delimiter that will be guaranteed not to collide with the contents of the input string. The only character that has this guarantee is the NUL byte . This is because, in bash (though not in zsh, incidentally), variables cannot contain the NUL byte. This preprocessing step can be done inline in a process substitution. Here's how to do it using awk :
readarray -td '' a < <(awk '{ gsub(/, /,"\0"); print; }' <<<"$string, "); unset 'a[-1]'; declare -p a; ## declare -a a=([0]="Paris" [1]="France" [2]="Europe")There, finally! This solution will not erroneously split fields in the middle, will not cut out prematurely, will not drop empty fields, will not corrupt itself on filename expansions, will not automatically strip leading and trailing whitespace, will not leave a stowaway LF on the end, does not require loops, and does not settle for a single-character delimiter.
Trimming solution
Lastly, I wanted to demonstrate my own fairly intricate trimming solution using the obscure
-C callback
option ofreadarray
. Unfortunately, I've run out of room against Stack Overflow's draconian 30,000 character post limit, so I won't be able to explain it. I'll leave that as an exercise for the reader.function mfcb { local val="$4"; "$1"; eval "$2[$3]=\$val;"; }; function val_ltrim { if [[ "$val" =~ ^[[:space:]]+ ]]; then val="${val:${#BASH_REMATCH[0]}}"; fi; }; function val_rtrim { if [[ "$val" =~ [[:space:]]+$ ]]; then val="${val:0:${#val}-${#BASH_REMATCH[0]}}"; fi; }; function val_trim { val_ltrim; val_rtrim; }; readarray -c1 -C 'mfcb val_trim a' -td, <<<"$string,"; unset 'a[-1]'; declare -p a; ## declare -a a=([0]="Paris" [1]="France" [2]="Europe")fbicknel ,Aug 18, 2017 at 15:57
It may also be helpful to note (though understandably you had no room to do so) that the-d
option toreadarray
first appears in Bash 4.4. – fbicknel Aug 18 '17 at 15:57Cyril Duchon-Doris ,Nov 3, 2017 at 9:16
You should add a "TL;DR : scroll 3 pages to see the right solution at the end of my answer" – Cyril Duchon-Doris Nov 3 '17 at 9:16dawg ,Nov 26, 2017 at 22:28
Great answer (+1). If you change your awk toawk '{ gsub(/,[ ]+|$/,"\0"); print }'
and eliminate that concatenation of the final", "
then you don't have to go through the gymnastics on eliminating the final record. So:readarray -td '' a < <(awk '{ gsub(/,[ ]+/,"\0"); print; }' <<<"$string")
on Bash that supportsreadarray
. Note your method is Bash 4.4+ I think because of the-d
inreadarray
– dawg Nov 26 '17 at 22:28datUser ,Feb 22, 2018 at 14:54
Looks likereadarray
is not an available builtin on OSX. – datUser Feb 22 '18 at 14:54bgoldst ,Feb 23, 2018 at 3:37
@datUser That's unfortunate. Your version of bash must be too old forreadarray
. In this case, you can use the second-best solution built onread
. I'm referring to this:a=(); while read -rd,; do a+=("$REPLY"); done <<<"$string,";
(with theawk
substitution if you need multicharacter delimiter support). Let me know if you run into any problems; I'm pretty sure this solution should work on fairly old versions of bash, back to version 2-something, released like two decades ago. – bgoldst Feb 23 '18 at 3:37Jmoney38 ,Jul 14, 2015 at 11:54
t="one,two,three" a=($(echo "$t" | tr ',' '\n')) echo "${a[2]}"Prints three
shrimpwagon ,Oct 16, 2015 at 20:04
I actually prefer this approach. Simple. – shrimpwagon Oct 16 '15 at 20:04Ben ,Oct 31, 2015 at 3:11
I copied and pasted this and it did did not work with echo, but did work when I used it in a for loop. – Ben Oct 31 '15 at 3:11Pinaki Mukherjee ,Nov 9, 2015 at 20:22
This is the simplest approach. thanks – Pinaki Mukherjee Nov 9 '15 at 20:22abalter ,Aug 30, 2016 at 5:13
This does not work as stated. @Jmoney38 or shrimpwagon if you can paste this in a terminal and get the desired output, please paste the result here. – abalter Aug 30 '16 at 5:13leaf ,Jul 17, 2017 at 16:28
@abalter Works for me witha=($(echo $t | tr ',' "\n"))
. Same result witha=($(echo $t | tr ',' ' '))
. – leaf Jul 17 '17 at 16:28Luca Borrione ,Nov 2, 2012 at 13:44
Sometimes it happened to me that the method described in the accepted answer didn't work, especially if the separator is a carriage return.
In those cases I solved in this way:string='first line second line third line' oldIFS="$IFS" IFS=' ' IFS=${IFS:0:1} # this is useful to format your code with tabs lines=( $string ) IFS="$oldIFS" for line in "${lines[@]}" do echo "--> $line" doneStefan van den Akker ,Feb 9, 2015 at 16:52
+1 This completely worked for me. I needed to put multiple strings, divided by a newline, into an array, andread -a arr <<< "$strings"
did not work withIFS=$'\n'
. – Stefan van den Akker Feb 9 '15 at 16:52Stefan van den Akker ,Feb 10, 2015 at 13:49
Here is the answer to make the accepted answer work when the delimiter is a newline . – Stefan van den Akker Feb 10 '15 at 13:49,Jul 24, 2015 at 21:24
The accepted answer works for values in one line.
If the variable has several lines:string='first line second line third line'We need a very different command to get all lines:
while read -r line; do lines+=("$line"); done <<<"$string"
Or the much simpler bash readarray :
readarray -t lines <<<"$string"Printing all lines is very easy taking advantage of a printf feature:
printf ">[%s]\n" "${lines[@]}" >[first line] >[ second line] >[ third line]Mayhem ,Dec 31, 2015 at 3:13
While not every solution works for every situation, your mention of readarray... replaced my last two hours with 5 minutes... you got my vote – Mayhem Dec 31 '15 at 3:13Derek 朕會功夫 ,Mar 23, 2018 at 19:14
readarray
is the right answer. – Derek 朕會功夫 Mar 23 '18 at 19:14ssanch ,Jun 3, 2016 at 15:24
This is similar to the approach by Jmoney38, but using sed:string="1,2,3,4" array=(`echo $string | sed 's/,/\n/g'`) echo ${array[0]}Prints 1
dawg ,Nov 26, 2017 at 19:59
The key to splitting your string into an array is the multi character delimiter of", "
. Any solution usingIFS
for multi character delimiters is inherently wrong since IFS is a set of those characters, not a string.If you assign
IFS=", "
then the string will break on EITHER","
OR" "
or any combination of them which is not an accurate representation of the two character delimiter of", "
.You can use
awk
orsed
to split the string, with process substitution:#!/bin/bash str="Paris, France, Europe" array=() while read -r -d $'\0' each; do # use a NUL terminated field separator array+=("$each") done < <(printf "%s" "$str" | awk '{ gsub(/,[ ]+|$/,"\0"); print }') declare -p array # declare -a array=([0]="Paris" [1]="France" [2]="Europe") outputIt is more efficient to use a regex you directly in Bash:
#!/bin/bash str="Paris, France, Europe" array=() while [[ $str =~ ([^,]+)(,[ ]+|$) ]]; do array+=("${BASH_REMATCH[1]}") # capture the field i=${#BASH_REMATCH} # length of field + delimiter str=${str:i} # advance the string by that length done # the loop deletes $str, so make a copy if needed declare -p array # declare -a array=([0]="Paris" [1]="France" [2]="Europe") output...With the second form, there is no sub shell and it will be inherently faster.
Edit by bgoldst: Here are some benchmarks comparing my
readarray
solution to dawg's regex solution, and I also included theread
solution for the heck of it (note: I slightly modified the regex solution for greater harmony with my solution) (also see my comments below the post):## competitors function c_readarray { readarray -td '' a < <(awk '{ gsub(/, /,"\0"); print; };' <<<"$1, "); unset 'a[-1]'; }; function c_read { a=(); local REPLY=''; while read -r -d ''; do a+=("$REPLY"); done < <(awk '{ gsub(/, /,"\0"); print; };' <<<"$1, "); }; function c_regex { a=(); local s="$1, "; while [[ $s =~ ([^,]+),\ ]]; do a+=("${BASH_REMATCH[1]}"); s=${s:${#BASH_REMATCH}}; done; }; ## helper functions function rep { local -i i=-1; for ((i = 0; i<$1; ++i)); do printf %s "$2"; done; }; ## end rep() function testAll { local funcs=(); local args=(); local func=''; local -i rc=-1; while [[ "$1" != ':' ]]; do func="$1"; if [[ ! "$func" =~ ^[_a-zA-Z][_a-zA-Z0-9]*$ ]]; then echo "bad function name: $func" >&2; return 2; fi; funcs+=("$func"); shift; done; shift; args=("$@"); for func in "${funcs[@]}"; do echo -n "$func "; { time $func "${args[@]}" >/dev/null 2>&1; } 2>&1| tr '\n' '/'; rc=${PIPESTATUS[0]}; if [[ $rc -ne 0 ]]; then echo "[$rc]"; else echo; fi; done| column -ts/; }; ## end testAll() function makeStringToSplit { local -i n=$1; ## number of fields if [[ $n -lt 0 ]]; then echo "bad field count: $n" >&2; return 2; fi; if [[ $n -eq 0 ]]; then echo; elif [[ $n -eq 1 ]]; then echo 'first field'; elif [[ "$n" -eq 2 ]]; then echo 'first field, last field'; else echo "first field, $(rep $[$1-2] 'mid field, ')last field"; fi; }; ## end makeStringToSplit() function testAll_splitIntoArray { local -i n=$1; ## number of fields in input string local s=''; echo "===== $n field$(if [[ $n -ne 1 ]]; then echo 's'; fi;) ====="; s="$(makeStringToSplit "$n")"; testAll c_readarray c_read c_regex : "$s"; }; ## end testAll_splitIntoArray() ## results testAll_splitIntoArray 1; ## ===== 1 field ===== ## c_readarray real 0m0.067s user 0m0.000s sys 0m0.000s ## c_read real 0m0.064s user 0m0.000s sys 0m0.000s ## c_regex real 0m0.000s user 0m0.000s sys 0m0.000s ## testAll_splitIntoArray 10; ## ===== 10 fields ===== ## c_readarray real 0m0.067s user 0m0.000s sys 0m0.000s ## c_read real 0m0.064s user 0m0.000s sys 0m0.000s ## c_regex real 0m0.001s user 0m0.000s sys 0m0.000s ## testAll_splitIntoArray 100; ## ===== 100 fields ===== ## c_readarray real 0m0.069s user 0m0.000s sys 0m0.062s ## c_read real 0m0.065s user 0m0.000s sys 0m0.046s ## c_regex real 0m0.005s user 0m0.000s sys 0m0.000s ## testAll_splitIntoArray 1000; ## ===== 1000 fields ===== ## c_readarray real 0m0.084s user 0m0.031s sys 0m0.077s ## c_read real 0m0.092s user 0m0.031s sys 0m0.046s ## c_regex real 0m0.125s user 0m0.125s sys 0m0.000s ## testAll_splitIntoArray 10000; ## ===== 10000 fields ===== ## c_readarray real 0m0.209s user 0m0.093s sys 0m0.108s ## c_read real 0m0.333s user 0m0.234s sys 0m0.109s ## c_regex real 0m9.095s user 0m9.078s sys 0m0.000s ## testAll_splitIntoArray 100000; ## ===== 100000 fields ===== ## c_readarray real 0m1.460s user 0m0.326s sys 0m1.124s ## c_read real 0m2.780s user 0m1.686s sys 0m1.092s ## c_regex real 17m38.208s user 15m16.359s sys 2m19.375s ##bgoldst ,Nov 27, 2017 at 4:28
Very cool solution! I never thought of using a loop on a regex match, nifty use of$BASH_REMATCH
. It works, and does indeed avoid spawning subshells. +1 from me. However, by way of criticism, the regex itself is a little non-ideal, in that it appears you were forced to duplicate part of the delimiter token (specifically the comma) so as to work around the lack of support for non-greedy multipliers (also lookarounds) in ERE ("extended" regex flavor built into bash). This makes it a little less generic and robust. – bgoldst Nov 27 '17 at 4:28bgoldst ,Nov 27, 2017 at 4:28
Secondly, I did some benchmarking, and although the performance is better than the other solutions for smallish strings, it worsens exponentially due to the repeated string-rebuilding, becoming catastrophic for very large strings. See my edit to your answer. – bgoldst Nov 27 '17 at 4:28dawg ,Nov 27, 2017 at 4:46
@bgoldst: What a cool benchmark! In defense of the regex, for 10's or 100's of thousands of fields (what the regex is splitting) there would probably be some form of record (like\n
delimited text lines) comprising those fields so the catastrophic slow-down would likely not occur. If you have a string with 100,000 fields -- maybe Bash is not ideal ;-) Thanks for the benchmark. I learned a thing or two. – dawg Nov 27 '17 at 4:46Geoff Lee ,Mar 4, 2016 at 6:02
Try thisIFS=', '; array=(Paris, France, Europe) for item in ${array[@]}; do echo $item; doneIt's simple. If you want, you can also add a declare (and also remove the commas):
IFS=' ';declare -a array=(Paris France Europe)The IFS is added to undo the above but it works without it in a fresh bash instance
MrPotatoHead ,Nov 13, 2018 at 13:19
Pure bash multi-character delimiter solution.As others have pointed out in this thread, the OP's question gave an example of a comma delimited string to be parsed into an array, but did not indicate if he/she was only interested in comma delimiters, single character delimiters, or multi-character delimiters.
Since Google tends to rank this answer at or near the top of search results, I wanted to provide readers with a strong answer to the question of multiple character delimiters, since that is also mentioned in at least one response.
If you're in search of a solution to a multi-character delimiter problem, I suggest reviewing Mallikarjun M 's post, in particular the response from gniourf_gniourf who provides this elegant pure BASH solution using parameter expansion:
#!/bin/bash str="LearnABCtoABCSplitABCaABCString" delimiter=ABC s=$str$delimiter array=(); while [[ $s ]]; do array+=( "${s%%"$delimiter"*}" ); s=${s#*"$delimiter"}; done; declare -p arrayLink to cited comment/referenced post
Link to cited question: Howto split a string on a multi-character delimiter in bash?
Eduardo Cuomo ,Dec 19, 2016 at 15:27
Use this:countries='Paris, France, Europe' OIFS="$IFS" IFS=', ' array=($countries) IFS="$OIFS" #${array[1]} == Paris #${array[2]} == France #${array[3]} == Europegniourf_gniourf ,Dec 19, 2016 at 17:22
Bad: subject to word splitting and pathname expansion. Please don't revive old questions with good answers to give bad answers. – gniourf_gniourf Dec 19 '16 at 17:22Scott Weldon ,Dec 19, 2016 at 18:12
This may be a bad answer, but it is still a valid answer. Flaggers / reviewers: For incorrect answers such as this one, downvote, don't delete! – Scott Weldon Dec 19 '16 at 18:12George Sovetov ,Dec 26, 2016 at 17:31
@gniourf_gniourf Could you please explain why it is a bad answer? I really don't understand when it fails. – George Sovetov Dec 26 '16 at 17:31gniourf_gniourf ,Dec 26, 2016 at 18:07
@GeorgeSovetov: As I said, it's subject to word splitting and pathname expansion. More generally, splitting a string into an array asarray=( $string )
is a (sadly very common) antipattern: word splitting occurs:string='Prague, Czech Republic, Europe'
; Pathname expansion occurs:string='foo[abcd],bar[efgh]'
will fail if you have a file named, e.g.,food
orbarf
in your directory. The only valid usage of such a construct is whenstring
is a glob. – gniourf_gniourf Dec 26 '16 at 18:07user1009908 ,Jun 9, 2015 at 23:28
UPDATE: Don't do this, due to problems with eval.With slightly less ceremony:
IFS=', ' eval 'array=($string)'e.g.
string="foo, bar,baz" IFS=', ' eval 'array=($string)' echo ${array[1]} # -> barcaesarsol ,Oct 29, 2015 at 14:42
eval is evil! don't do this. – caesarsol Oct 29 '15 at 14:42user1009908 ,Oct 30, 2015 at 4:05
Pfft. No. If you're writing scripts large enough for this to matter, you're doing it wrong. In application code, eval is evil. In shell scripting, it's common, necessary, and inconsequential. – user1009908 Oct 30 '15 at 4:05caesarsol ,Nov 2, 2015 at 18:19
put a$
in your variable and you'll see... I write many scripts and I never ever had to use a singleeval
– caesarsol Nov 2 '15 at 18:19Dennis Williamson ,Dec 2, 2015 at 17:00
Eval command and security issues – Dennis Williamson Dec 2 '15 at 17:00user1009908 ,Dec 22, 2015 at 23:04
You're right, this is only usable when the input is known to be clean. Not a robust solution. – user1009908 Dec 22 '15 at 23:04Eduardo Lucio ,Jan 31, 2018 at 20:45
Here's my hack!Splitting strings by strings is a pretty boring thing to do using bash. What happens is that we have limited approaches that only work in a few cases (split by ";", "/", "." and so on) or we have a variety of side effects in the outputs.
The approach below has required a number of maneuvers, but I believe it will work for most of our needs!
#!/bin/bash # -------------------------------------- # SPLIT FUNCTION # ---------------- F_SPLIT_R=() f_split() { : 'It does a "split" into a given string and returns an array. Args: TARGET_P (str): Target string to "split". DELIMITER_P (Optional[str]): Delimiter used to "split". If not informed the split will be done by spaces. Returns: F_SPLIT_R (array): Array with the provided string separated by the informed delimiter. ' F_SPLIT_R=() TARGET_P=$1 DELIMITER_P=$2 if [ -z "$DELIMITER_P" ] ; then DELIMITER_P=" " fi REMOVE_N=1 if [ "$DELIMITER_P" == "\n" ] ; then REMOVE_N=0 fi # NOTE: This was the only parameter that has been a problem so far! # By Questor # [Ref.: https://unix.stackexchange.com/a/390732/61742] if [ "$DELIMITER_P" == "./" ] ; then DELIMITER_P="[.]/" fi if [ ${REMOVE_N} -eq 1 ] ; then # NOTE: Due to bash limitations we have some problems getting the # output of a split by awk inside an array and so we need to use # "line break" (\n) to succeed. Seen this, we remove the line breaks # momentarily afterwards we reintegrate them. The problem is that if # there is a line break in the "string" informed, this line break will # be lost, that is, it is erroneously removed in the output! # By Questor TARGET_P=$(awk 'BEGIN {RS="dn"} {gsub("\n", "3F2C417D448C46918289218B7337FCAF"); printf $0}' <<< "${TARGET_P}") fi # NOTE: The replace of "\n" by "3F2C417D448C46918289218B7337FCAF" results # in more occurrences of "3F2C417D448C46918289218B7337FCAF" than the # amount of "\n" that there was originally in the string (one more # occurrence at the end of the string)! We can not explain the reason for # this side effect. The line below corrects this problem! By Questor TARGET_P=${TARGET_P%????????????????????????????????} SPLIT_NOW=$(awk -F"$DELIMITER_P" '{for(i=1; i<=NF; i++){printf "%s\n", $i}}' <<< "${TARGET_P}") while IFS= read -r LINE_NOW ; do if [ ${REMOVE_N} -eq 1 ] ; then # NOTE: We use "'" to prevent blank lines with no other characters # in the sequence being erroneously removed! We do not know the # reason for this side effect! By Questor LN_NOW_WITH_N=$(awk 'BEGIN {RS="dn"} {gsub("3F2C417D448C46918289218B7337FCAF", "\n"); printf $0}' <<< "'${LINE_NOW}'") # NOTE: We use the commands below to revert the intervention made # immediately above! By Questor LN_NOW_WITH_N=${LN_NOW_WITH_N%?} LN_NOW_WITH_N=${LN_NOW_WITH_N#?} F_SPLIT_R+=("$LN_NOW_WITH_N") else F_SPLIT_R+=("$LINE_NOW") fi done <<< "$SPLIT_NOW" } # -------------------------------------- # HOW TO USE # ---------------- STRING_TO_SPLIT=" * How do I list all databases and tables using psql? \" sudo -u postgres /usr/pgsql-9.4/bin/psql -c \"\l\" sudo -u postgres /usr/pgsql-9.4/bin/psql <DB_NAME> -c \"\dt\" \" \" \list or \l: list all databases \dt: list all tables in the current database \" [Ref.: https://dba.stackexchange.com/questions/1285/how-do-i-list-all-databases-and-tables-using-psql] " f_split "$STRING_TO_SPLIT" "bin/psql -c" # -------------------------------------- # OUTPUT AND TEST # ---------------- ARR_LENGTH=${#F_SPLIT_R[*]} for (( i=0; i<=$(( $ARR_LENGTH -1 )); i++ )) ; do echo " > -----------------------------------------" echo "${F_SPLIT_R[$i]}" echo " < -----------------------------------------" done if [ "$STRING_TO_SPLIT" == "${F_SPLIT_R[0]}bin/psql -c${F_SPLIT_R[1]}" ] ; then echo " > -----------------------------------------" echo "The strings are the same!" echo " < -----------------------------------------" fisel-en-ium ,May 31, 2018 at 5:56
Another way to do it without modifying IFS:read -r -a myarray <<< "${string//, /$IFS}"Rather than changing IFS to match our desired delimiter, we can replace all occurrences of our desired delimiter
", "
with contents of$IFS
via"${string//, /$IFS}"
.Maybe this will be slow for very large strings though?
This is based on Dennis Williamson's answer.
rsjethani ,Sep 13, 2016 at 16:21
Another approach can be:str="a, b, c, d" # assuming there is a space after ',' as in Q arr=(${str//,/}) # delete all occurrences of ','After this 'arr' is an array with four strings. This doesn't require dealing IFS or read or any other special stuff hence much simpler and direct.
gniourf_gniourf ,Dec 26, 2016 at 18:12
Same (sadly common) antipattern as other answers: subject to word splitting and filename expansion. – gniourf_gniourf Dec 26 '16 at 18:12Safter Arslan ,Aug 9, 2017 at 3:21
Another way would be:string="Paris, France, Europe" IFS=', ' arr=(${string})Now your elements are stored in "arr" array. To iterate through the elements:
for i in ${arr[@]}; do echo $i; donebgoldst ,Aug 13, 2017 at 22:38
I cover this idea in my answer ; see Wrong answer #5 (you might be especially interested in my discussion of theeval
trick). Your solution leaves$IFS
set to the comma-space value after-the-fact. – bgoldst Aug 13 '17 at 22:38
flowblok's blog
that diagram shows what happens according to the man page, and not what happens when you actually try it out in real life. This second diagram more accurately captures the insanity of bash:See how remote interactive login shells read /etc/bash.bashrc, but normal interactive login shells don't? Sigh.
Finally, here's a repository containing my implementation and the graphviz files for the above diagram. If your POSIX-compliant shell isn't listed here, or if I've made a horrible mistake (or just a tiny one), please send me a pull request or make a comment below, and I'll update this post accordingly.
[1]and since I'm writing this, I can make you say whatever I want for the purposes of narrative.
Jan 26, 2019 | flowblok.id.au
Adrian • a month ago ,
6 years late, but...
In my experience, if your bash sources /etc/bash.bashrc, odds are good it also sources /etc/bash.bash_logout or something similar on logout (after ~/.bash_logout, of course).
From bash-4.4/config-top.h:
/* System-wide .bashrc file for interactive shells. */ /* #define SYS_BASHRC "/etc/bash.bashrc" */ /* System-wide .bash_logout for login shells. */ /* #define SYS_BASH_LOGOUT "/etc/bash.bash_logout" */(Yes, they're disabled by default.)
Check the FILES section of your system's bash man page for details.
Jan 06, 2018 | zwischenzugs.com
IntroRecently I wanted to deepen my understanding of bash by researching as much of it as possible. Because I felt bash is an often-used (and under-understood) technology, I ended up writing a book on it .
A preview is available here .
You don't have to look hard on the internet to find plenty of useful one-liners in bash, or scripts. And there are guides to bash that seem somewhat intimidating through either their thoroughness or their focus on esoteric detail.
Here I've focussed on the things that either confused me or increased my power and productivity in bash significantly, and tried to communicate them (as in my book) in a way that emphasises getting the understanding right.
Enjoy!
1)``
vs$()
These two operators do the same thing. Compare these two lines:
$ echo `ls` $ echo $(ls)Why these two forms existed confused me for a long time.
If you don't know, both forms substitute the output of the command contained within it into the command.
The principal difference is that nesting is simpler.
Which of these is easier to read (and write)?
$ echo `echo \`echo \\\`echo inside\\\`\``or:
$ echo $(echo $(echo $(echo inside)))If you're interested in going deeper, see here or here .
2) globbing vs regexpsAnother one that can confuse if never thought about or researched.
While globs and regexps can look similar, they are not the same.
Consider this command:
$ rename -n 's/(.*)/new$1/' *The two asterisks are interpreted in different ways.
The first is ignored by the shell (because it is in quotes), and is interpreted as '0 or more characters' by the rename application. So it's interpreted as a regular expression.
The second is interpreted by the shell (because it is not in quotes), and gets replaced by a list of all the files in the current working folder. It is interpreted as a glob.
So by looking at
man bash
can you figure out why these two commands produce different output?$ ls * $ ls .*The second looks even more like a regular expression. But it isn't!
3) Exit CodesNot everyone knows that every time you run a shell command in bash, an 'exit code' is returned to bash.
Generally, if a command 'succeeds' you get an error code of
0
. If it doesn't succeed, you get a non-zero code.1
is a 'general error', and others can give you more information (eg which signal killed it, for example).But these rules don't always hold:
$ grep not_there /dev/null $ echo $?
$?
is a special bash variable that's set to the exit code of each command after it runs.Grep uses exit codes to indicate whether it matched or not. I have to look up every time which way round it goes: does finding a match or not return
0
?Grok this and a lot will click into place in what follows.
4)if
statements,[
and[[
Here's another 'spot the difference' similar to the backticks one above.
What will this output?
if grep not_there /dev/null then echo hi else echo lo figrep's return code makes code like this work more intuitively as a side effect of its use of exit codes.
Now what will this output?
a)
hihi
b)lolo
c) something elseif [ $(grep not_there /dev/null) = '' ] then echo -n hi else echo -n lo fi if [[ $(grep not_there /dev/null) = '' ]] then echo -n hi else echo -n lo fiThe difference between
[
and[[
was another thing I never really understood.[
is the original form for tests, and then[[
was introduced, which is more flexible and intuitive. In the firstif
block above, the if statement barfs because the$(grep not_there /dev/null)
is evaluated to nothing, resulting in this comparison:
[ = '' ]
which makes no sense. The double bracket form handles this for you.
This is why you occasionally see comparisons like this in bash scripts:
if [ x$(grep not_there /dev/null) = 'x' ]
so that if the command returns nothing it still runs. There's no need for it, but that's why it exists.
5)set
sBash has configurable options which can be set on the fly. I use two of these all the time:
set -eexits from a script if any command returned a non-zero exit code (see above).
This outputs the commands that get run as they run:
set -xSo a script might start like this:
#!/bin/bash set -e set -x grep not_there /dev/null echo $?What would that script output?
6) <()
This is my favourite. It's so under-used, perhaps because it can be initially baffling, but I use it all the time.
It's similar to
$()
in that the output of the command inside is re-used.In this case, though, the output is treated as a file. This file can be used as an argument to commands that take files as an argument.
Confused? Here's an example.
Have you ever done something like this?
$ grep somestring file1 > /tmp/a $ grep somestring file2 > /tmp/b $ diff /tmp/a /tmp/bThat works, but instead you can write:
diff <(grep somestring file1) <(grep somestring file2)Isn't that neater?
7) QuotingQuoting's a knotty subject in bash, as it is in many software contexts.
Firstly, variables in quotes:
A='123' echo "$A" echo '$A'Pretty simple – double quotes dereference variables, while single quotes go literal.
So what will this output?
mkdir -p tmp cd tmp touch a echo "*" echo '*'Surprised? I was.
8) Top three shortcutsThere are plenty of shortcuts listed in
man bash
, and it's not hard to find comprehensive lists. This list consists of the ones I use most often, in order of how often I use them.Rather than trying to memorize them all, I recommend picking one, and trying to remember to use it until it becomes unconscious. Then take the next one. I'll skip over the most obvious ones (eg
!!
– repeat last command, and~
– your home directory).
!$
I use this dozens of times a day. It repeats the last argument of the last command. If you're working on a file, and can't be bothered to re-type it command after command it can save a lot of work:
grep somestring /long/path/to/some/file/or/other.txt vi !$
!:1-$
This bit of magic takes this further. It takes all the arguments to the previous command and drops them in. So:
grep isthere /long/path/to/some/file/or/other.txt egrep !:1-$ fgrep !:1-$The
!
means 'look at the previous command', the:
is a separator, and the1
means 'take the first word', the-
means 'until' and the$
means 'the last word'.Note: you can achieve the same thing with
!*
. Knowing the above gives you the control to limit to a specific contiguous subset of arguments, eg with!:2-3
.
:h
I use this one a lot too. If you put it after a filename, it will change that filename to remove everything up to the folder. Like this:
grep isthere /long/path/to/some/file/or/other.txt cd !$:hwhich can save a lot of work in the course of the day.
9) startup orderThe order in which bash runs startup scripts can cause a lot of head-scratching. I keep this diagram handy (from this great page):
It shows which scripts bash decides to run from the top, based on decisions made about the context bash is running in (which decides the colour to follow).
So if you are in a local (non-remote), non-login, interactive shell (eg when you run bash itself from the command line), you are on the 'green' line, and these are the order of files read:
/etc/bash.bashrc ~/.bashrc [bash runs, then terminates] ~/.bash_logoutThis can save you a hell of a lot of time debugging.
10) getopts (cheapci)If you go deep with bash, you might end up writing chunky utilities in it. If you do, then getting to grips with
getopts
can pay large dividends.For fun, I once wrote a script called
cheapci
which I used to work like a Jenkins job.The code here implements the reading of the two required, and 14 non-required arguments . Better to learn this than to build up a bunch of bespoke code that can get very messy pretty quickly as your utility grows.
This is based on some of the contents of my book Learn Bash the Hard Way , available at $7 :
Dec 20, 2018 | forums.debian.net
pawRoot " 2018-10-15 17:13
Just spent some time editing .bashrc to make my life easier, and wondering if anyone has some cool "tricks" for bash as well.Here is mine:
- Code: Select all
# changing shell appearance
PS1='\[\033[0;32m\]\[\033[0m\033[0;32m\]\u\[\033[0;36m\] @ \[\033[0;36m\]\h \w\[\033[0;32m\]$(__git_ps1)\n\[\033[0;32m\]└─\[\033[0m\033[0;32m\] \$\[\033[0m\033[0;32m\] ▶\[\033[0m\] '
# aliases
alias la="ls -la --group-directories-first --color"
# clear terminal
alias cls="clear"
#
alias sup="sudo apt update && sudo apt upgrade"
# search for package
alias apts='apt-cache search'
# start x session
alias x="startx"
# download mp3 in best quality from YouTube
# usage: ytmp3 https://www.youtube.com/watch?v=LINK
alias ytmp3="youtube-dl -f bestaudio --extract-audio --audio-format mp3 --audio-quality 0"
# perform 'la' after 'cd'
alias cd="listDir"
listDir() {
builtin cd "$*"
RESULT=$?
if [ "$RESULT" -eq 0 ]; then
la
fi
}
# type "extract filename" to extract the file
extract () {
if [ -f $1 ] ; then
case $1 in
*.tar.bz2) tar xvjf $1 ;;
*.tar.gz) tar xvzf $1 ;;
*.bz2) bunzip2 $1 ;;
*.rar) unrar x $1 ;;
*.gz) gunzip $1 ;;
*.tar) tar xvf $1 ;;
*.tbz2) tar xvjf $1 ;;
*.tgz) tar xvzf $1 ;;
*.zip) unzip $1 ;;
*.Z) uncompress $1 ;;
*.7z) 7z x $1 ;;
*) echo "don't know how to extract '$1'..." ;;
esac
else
echo "'$1' is not a valid file!"
fi
}
# obvious one
alias ..="cd .."
alias ...="cd ../.."
alias ....="cd ../../.."
alias .....="cd ../../../.."
# tail all logs in /var/log
alias logs="find /var/log -type f -exec file {} \; | grep 'text' | cut -d' ' -f1 | sed -e's/:$//g' | grep -v '[0-9]$' | xargs tail -f"
Head_on_a_Stick " 2018-10-15 18:11
pawRoot wrote:Erm, did you know that `tar` autoextracts these days? This will work for pretty much anything:
- Code: Select all
extract () {
if [ -f $1 ] ; then
case $1 in
*.tar.bz2) tar xvjf $1 ;;
*.tar.gz) tar xvzf $1 ;;
*.bz2) bunzip2 $1 ;;
*.rar) unrar x $1 ;;
*.gz) gunzip $1 ;;
*.tar) tar xvf $1 ;;
*.tbz2) tar xvjf $1 ;;
*.tgz) tar xvzf $1 ;;
*.zip) unzip $1 ;;
*.Z) uncompress $1 ;;
*.7z) 7z x $1 ;;
*) echo "don't know how to extract '$1'..." ;;
esac
else
echo "'$1' is not a valid file!"
fi
}
I have these functions in my .mkshrc (bash is bloat!):
- Code: Select all
tar xf whatever.tar.whatever
The mnt function acts like a poor person's arch-chroot and will bind mount /proc /sys & /dev before chrooting then tear it down afterwards.
- Code: Select all
function mnt {
for i in proc sys dev dev/pts; do sudo mount --bind /$i "$1"$i; done &
sudo chroot "$1" /bin/bash
sudo umount -R "$1"{proc,sys,dev}
}
function mkiso {
xorriso -as mkisofs \
-iso-level 3 \
-full-iso9660-filenames \
-volid SharpBang-stretch \
-eltorito-boot isolinux/isolinux.bin \
-eltorito-catalog isolinux/boot.cat \
-no-emul-boot -boot-load-size 4 -boot-info-table \
-isohybrid-mbr isolinux/isohdpfx.bin \
-eltorito-alt-boot \
-e boot/grub/efi.img \
-no-emul-boot -isohybrid-gpt-basdat \
-output ../"$1" ./
}The mkiso function builds a UEFI-capable Debian live system (with the name of the image given as the first argument).
The only other stuff I have are aliases, not really worth posting.
dbruce wrote: Ubuntu forums try to be like a coffee shop in Seattle. Debian forums strive for the charm and ambience of a skinhead bar in Bacau. We intend to keep it that way.pawRoot " 2018-10-15 18:23
Head_on_a_Stick wrote: Erm, did you know that `tar` autoextracts these days? This will work for pretty much anything:But it won't work for zip or rar right ?
None1975 " 2018-10-16 13:02
Here is compilation of cool "tricks" for bash. This is similar to oh-my-zsh. OS: Debian Stretch / WM : Fluxbox
Debian Wiki | DontBreakDebian , My config files in github
debiman " 2018-10-21 14:38
i have a LOT of stuff in my /etc/bash.bashrc, because i want it to be available for the root user too.
i won't post everything, but here's a "best of" from both /etc/bash.bashrc and ~/.bashrc:
- Code: Select all
case ${TERM} in
xterm*|rxvt*|Eterm|aterm|kterm|gnome*)
PROMPT_COMMAND=${PROMPT_COMMAND:+$PROMPT_COMMAND; }'printf "\033]0;%s: %s\007" "${SHELL##*/}" "${PWD/#$HOME/\~}"'
;;
screen)
PROMPT_COMMAND=${PROMPT_COMMAND:+$PROMPT_COMMAND; }'printf "\033_%s@%s:%s\033\\" "${USER}" "${HOSTNAME%%.*}" "${PWD/#$HOME/\~}"'
;;
linux)
setterm --blength 0
setterm --blank 4
setterm --powerdown 8
;;
esac
PS2='cont> '
PS3='Choice: '
PS4='DEBUG: '
# Bash won't get SIGWINCH if another process is in the foreground.
# Enable checkwinsize so that bash will check the terminal size when
# it regains control.
# http://cnswww.cns.cwru.edu/~chet/bash/FAQ (E11)
shopt -s checkwinsize
# forums.bunsenlabs.org/viewtopic.php?pid=27494#p27494
# also see aliases '...' and '....'
shopt -s autocd
# opensource.com/article/18/5/bash-tricks
shopt -s cdspell
# as big as possible!!!
HISTSIZE=500000
HISTFILESIZE=2000000
# unix.stackexchange.com/a/18443
# history: erase duplicates...
HISTCONTROL=ignoredups:erasedups
shopt -s histappend
# next: enables usage of CTRL-S (backward search) with CTRL-R (forward search)
# digitalocean.com/community/tutorials/how-to-use-bash-history-commands-and-expansions-on-a-linux-vps#searching-through-bash-history
stty -ixon
if [[ ${EUID} == 0 ]] ; then
# root = color=1 # red
if [ "$TERM" != "linux" ]; then
PS1="\[$(tput setaf 1)\]\[$(tput rev)\] \[$(tput sgr0)\]\[$(tput setaf 5)\]\${?#0}\[$(tput setaf 1)\] \u@\h \w\[$(tput sgr0)\]\n\[$(tput rev)\] \[$(tput sgr0)\] "
else
# adding \t = time to tty prompt
PS1="\[$(tput setaf 1)\]\[$(tput rev)\] \[$(tput sgr0)\]\[$(tput setaf 5)\]\${?#0}\[$(tput setaf 1)\] \t \u@\h \w\[$(tput sgr0)\]\n\[$(tput rev)\] \[$(tput sgr0)\] "
fi
else
if [ "$TERM" != "linux" ]; then
PS1="\[$(tput setaf 2)\]\[$(tput rev)\] \[$(tput sgr0)\]\[$(tput setaf 5)\]\${?#0}\[$(tput setaf 2)\] \u@\h \w\[$(tput sgr0)\]\n\[$(tput rev)\] \[$(tput sgr0)\] "
else
# adding \t = time to tty prompt
PS1="\[$(tput setaf 2)\]\[$(tput rev)\] \[$(tput sgr0)\]\[$(tput setaf 5)\]\${?#0}\[$(tput setaf 2)\] \t \u@\h \w\[$(tput sgr0)\]\n\[$(tput rev)\] \[$(tput sgr0)\] "
fi
fi
[ -r /usr/share/bash-completion/bash_completion ] && . /usr/share/bash-completion/bash_completion || true
export EDITOR="nano"
man() {
env LESS_TERMCAP_mb=$(printf "\e[1;31m") \
LESS_TERMCAP_md=$(printf "\e[1;31m") \
LESS_TERMCAP_me=$(printf "\e[0m") \
LESS_TERMCAP_se=$(printf "\e[0m") \
LESS_TERMCAP_so=$(printf "\e[7m") \
LESS_TERMCAP_ue=$(printf "\e[0m") \
LESS_TERMCAP_us=$(printf "\e[1;32m") \
man "$@"
}
#LESS_TERMCAP_so=$(printf "\e[1;44;33m")
# that used to be in the man function for less's annoyingly over-colorful status line.
# changed it to simple reverse video (tput rev)
alias ls='ls --group-directories-first -hF --color=auto'
alias ll='ls --group-directories-first -hF --color=auto -la'
alias mpf='/usr/bin/ls -1 | mpv --playlist=-'
alias ruler='slop -o -c 1,0.3,0'
alias xmeasure='slop -o -c 1,0.3,0'
alias obxprop='obxprop | grep -v _NET_WM_ICON'
alias sx='exec startx > ~/.local/share/xorg/xlog 2>&1'
alias pngq='pngquant --nofs --speed 1 --skip-if-larger --strip '
alias screencap='ffmpeg -r 15 -s 1680x1050 -f x11grab -i :0.0 -vcodec msmpeg4v2 -qscale 2'
alias su='su -'
alias fblc='fluxbox -list-commands | column'
alias torrench='torrench -t -k -s -x -r -l -i -b --sorted'
alias F5='while sleep 60; do notify-send -u low "Pressed F5 on:" "$(xdotool getwindowname $(xdotool getwindowfocus))"; xdotool key F5; done'
alias aurs='aurman --sort_by_name -Ss'
alias cal3='cal -3 -m -w --color'
alias mkdir='mkdir -p -v'
alias ping='ping -c 5'
alias cd..='cd ..'
alias off='systemctl poweroff'
alias xg='xgamma -gamma'
alias find='find 2>/dev/null'
alias stressme='stress --cpu 8 --io 4 --vm 2 --vm-bytes 128M --timeout'
alias hf='history|grep'
alias du1='du -m --max-depth=1|sort -g|sed "s/\t./M\t/g ; s/\///g"'
alias zipcat='gunzip -c'
mkcd() {
mkdir -p "$1"
echo cd "$1"
cd "$1"
}
Nov 17, 2018 | www.mankier.com
hh -- easily view, navigate, sort and use your command history with shell history suggest box.
SynopsisDescription
hh [option] [arg1] [arg2]...
hstr [option] [arg1] [arg2]...hh uses shell history to provide suggest box like functionality for commands used in the past. By default it parses .bash-history file that is filtered as you type a command substring. Commands are not just filtered, but also ordered by a ranking algorithm that considers number of occurrences, length and timestamp. Favorite and frequently used commands can be bookmarked . In addition hh allows removal of commands from history - for instance with a typo or with a sensitive content.
OptionsKeys
- -h --help
- Show help
- -n --non-interactive
- Print filtered history on standard output and exit
- -f --favorites
- Show favorites view immediately
- -s --show-configuration
- Show configuration that can be added to ~/.bashrc
- -b --show-blacklist
- Show blacklist of commands to be filtered out before history processing
- -V --version
- Show version information
Environment Variables
- pattern
- Type to filter shell history.
- Ctrl-e
- Toggle regular expression and substring search.
- Ctrl-t
- Toggle case sensitive search.
- Ctrl-/ , Ctrl-7
- Rotate view of history as provided by Bash, ranked history ordered by the number of occurences/length/timestamp and favorites.
- Ctrl-f
- Add currently selected command to favorites.
- Ctrl-l
- Make search pattern lowercase or uppercase.
- Ctrl-r , UP arrow, DOWN arrow, Ctrl-n , Ctrl-p
- Navigate in the history list.
- TAB , RIGHT arrow
- Choose currently selected item for completion and let user to edit it on the command prompt.
- LEFT arrow
- Choose currently selected item for completion and let user to edit it in editor (fix command).
- ENTER
- Choose currently selected item for completion and execute it.
- DEL
- Remove currently selected item from the shell history.
- BACSKSPACE , Ctrl-h
- Delete last pattern character.
- Ctrl-u , Ctrl-w
- Delete pattern and search again.
- Ctrl-x
- Write changes to shell history and exit.
- Ctrl-g
- Exit with empty prompt.
hh defines the following environment variables:
Files
- HH_CONFIG
- Configuration options:
hicolor
Get more colors with this option (default is monochromatic).monochromatic
Ensure black and white view.prompt-bottom
Show prompt at the bottom of the screen (default is prompt at the top).regexp
Filter command history using regular expressions (substring match is default)substring
Filter command history using substring.keywords
Filter command history using keywords - item matches if contains all keywords in pattern in any order.casesensitive
Make history filtering case sensitive (it's case insensitive by default).rawhistory
Show normal history as a default view (metric-based view is shown otherwise).favorites
Show favorites as a default view (metric-based view is shown otherwise).duplicates
Show duplicates in rawhistory (duplicates are discarded by default).blacklist
Load list of commands to skip when processing history from ~/.hh_blacklist (built-in blacklist used otherwise).big-keys-skip
Skip big history entries i.e. very long lines (default).big-keys-floor
Use different sorting slot for big keys when building metrics-based view (big keys are skipped by default).big-keys-exit
Exit (fail) on presence of a big key in history (big keys are skipped by default).warning
Show warning.debug
Show debug information.Example:
export HH_CONFIG=hicolor,regexp,rawhistory- HH_PROMPT
- Change prompt string which is user@host$ by default.
Example:
export HH_PROMPT="$ "Bash Configuration
- ~/.hh_favorites
- Bookmarked favorite commands.
- ~/.hh_blacklist
- Command blacklist.
Optionally add the following lines to ~/.bashrc:
export HH_CONFIG=hicolor # get more colors shopt -s histappend # append new history items to .bash_history export HISTCONTROL=ignorespace # leading space hides commands from history export HISTFILESIZE=10000 # increase history file size (default is 500) export HISTSIZE=${HISTFILESIZE} # increase history size (default is 500) export PROMPT_COMMAND="history -a; history -n; ${PROMPT_COMMAND}" # if this is interactive shell, then bind hh to Ctrl-r (for Vi mode check doc) if [[ $- =~ .*i.* ]]; then bind '"\C-r": "\C-a hh -- \C-j"'; fiThe prompt command ensures synchronization of the history between BASH memory and history file.
ZSH ConfigurationOptionally add the following lines to ~/.zshrc:
export HISTFILE=~/.zsh_history # ensure history file visibility export HH_CONFIG=hicolor # get more colors bindkey -s "\C-r" "\eqhh\n" # bind hh to Ctrl-r (for Vi mode check doc, experiment with --)ExamplesAuthor
- hh git
- Start `hh` and show only history items containing 'git'.
- hh --non-interactive git
- Print history items containing 'git' to standard output and exit.
- hh --show-configuration >> ~/.bashrc
- Append default hh configuration to your Bash profile.
- hh --show-blacklist
- Show blacklist configured for history processing.
Written by Martin Dvorak <[email protected]>
BugsReport bugs to https://github.com/dvorka/hstr/issues
See Also
Referenced By
The man page hstr(1) is an alias of hh(1).
Nov 08, 2018 | stackoverflow.com
This question already has an answer here:Rob I , May 9, 2012 at 19:22
For your second question, see @mkb's comment to my answer below - that's definitely the way to go! – Rob I May 9 '12 at 19:22Dennis Williamson , Jul 4, 2012 at 16:14
See my edited answer for one way to read individual characters into an array. – Dennis Williamson Jul 4 '12 at 16:14Nick Weedon , Dec 31, 2015 at 11:04
Here is the same thing in a more concise form: var1=$(cut -f1 -d- <<<$STR) – Nick Weedon Dec 31 '15 at 11:04Rob I , May 9, 2012 at 17:00
If your solution doesn't have to be general, i.e. only needs to work for strings like your example, you could do:var1=$(echo $STR | cut -f1 -d-) var2=$(echo $STR | cut -f2 -d-)I chose
cut
here because you could simply extend the code for a few more variables...crunchybutternut , May 9, 2012 at 17:40
Can you look at my post again and see if you have a solution for the followup question? thanks! – crunchybutternut May 9 '12 at 17:40mkb , May 9, 2012 at 17:59
You can usecut
to cut characters too!cut -c1
for example. – mkb May 9 '12 at 17:59FSp , Nov 27, 2012 at 10:26
Although this is very simple to read and write, is a very slow solution because forces you to read twice the same data ($STR) ... if you care of your script performace, the @anubhava solution is much better – FSp Nov 27 '12 at 10:26tripleee , Jan 25, 2016 at 6:47
Apart from being an ugly last-resort solution, this has a bug: You should absolutely use double quotes inecho "$STR"
unless you specifically want the shell to expand any wildcards in the string as a side effect. See also stackoverflow.com/questions/10067266/ – tripleee Jan 25 '16 at 6:47Rob I , Feb 10, 2016 at 13:57
You're right about double quotes of course, though I did point out this solution wasn't general. However I think your assessment is a bit unfair - for some people this solution may be more readable (and hence extensible etc) than some others, and doesn't completely rely on arcane bash feature that wouldn't translate to other shells. I suspect that's why my solution, though less elegant, continues to get votes periodically... – Rob I Feb 10 '16 at 13:57Dennis Williamson , May 10, 2012 at 3:14
read
withIFS
are perfect for this:$ IFS=- read var1 var2 <<< ABCDE-123456 $ echo "$var1" ABCDE $ echo "$var2" 123456Edit:
Here is how you can read each individual character into array elements:
$ read -a foo <<<"$(echo "ABCDE-123456" | sed 's/./& /g')"Dump the array:
$ declare -p foo declare -a foo='([0]="A" [1]="B" [2]="C" [3]="D" [4]="E" [5]="-" [6]="1" [7]="2" [8]="3" [9]="4" [10]="5" [11]="6")'If there are spaces in the string:
$ IFS=$'\v' read -a foo <<<"$(echo "ABCDE 123456" | sed 's/./&\v/g')" $ declare -p foo declare -a foo='([0]="A" [1]="B" [2]="C" [3]="D" [4]="E" [5]=" " [6]="1" [7]="2" [8]="3" [9]="4" [10]="5" [11]="6")'insecure , Apr 30, 2014 at 7:51
Great, the elegant bash-only way, without unnecessary forks. – insecure Apr 30 '14 at 7:51Martin Serrano , Jan 11 at 4:34
this solution also has the benefit that if delimiter is not present, thevar2
will be empty – Martin Serrano Jan 11 at 4:34mkb , May 9, 2012 at 17:02
If you know it's going to be just two fields, you can skip the extra subprocesses like this:var1=${STR%-*} var2=${STR#*-}What does this do?
${STR%-*}
deletes the shortest substring of$STR
that matches the pattern-*
starting from the end of the string.${STR#*-}
does the same, but with the*-
pattern and starting from the beginning of the string. They each have counterparts%%
and##
which find the longest anchored pattern match. If anyone has a helpful mnemonic to remember which does which, let me know! I always have to try both to remember.Jens , Jan 30, 2015 at 15:17
Plus 1 For knowing your POSIX shell features, avoiding expensive forks and pipes, and the absence of bashisms. – Jens Jan 30 '15 at 15:17Steven Lu , May 1, 2015 at 20:19
Dunno about "absence of bashisms" considering that this is already moderately cryptic .... if your delimiter is a newline instead of a hyphen, then it becomes even more cryptic. On the other hand, it works with newlines , so there's that. – Steven Lu May 1 '15 at 20:19