Bash is a common scripting language that has evolved much over the years. It provides developers with a toolset to complete quick-and-dirty automation to help streamline productivity. Among its many features is the read tool which helps get input from the command line, prompting the user, or even via redirection and piping.<\/p>\n
Bash’s read tool can be used in a number of common ways as well as with a number of common options enabled (i.e. flags). By the end of this article the following applications of bash’s This article is by no means an exhaustive display of the The most basic example of the read tool is to prompt a user to enter some input. This can be accomplished via the following approach:<\/p>\n This script executes the following three instructions:<\/p>\n The full sequence appears as such in the terminal window:<\/p>\n Quick and dirty, but gets the job done. Before we move on to the next example using the read command let us pick this one apart first. You might notice the input To keep the user-entered input on the same line as the prompt, one can pass the This results in the following output provided the name This keeps the output a bit tighter and arguably makes things easier to debug in many cases. Getting back on track, let’s consider an edge case quickly where slash characters might be entered.<\/p>\n If you are developing bash scripts using an IntelliJ-based IDE you may have already noticed a warning that “read without -r will mangle backslashes.” This message urges users to use the -r flag that, according to the man page, instructs Here we define the variable The output of this code is as follows:<\/p>\n This is particularly useful in cases where input may contain characters using the Bash scripts are meant to be quick-and-dirty ways to automate tasks. At some point, using the The output of this code is as follows:<\/p>\n This approach demonstrates the Here we introduce a second variable Bash allows developers to read command line arguments with ease. While not diving too deeply into the use-cases, edge-cases, or finer points of command line arguments in bash \u2014 the following example shows how the Here’s where things get a little …\u00a0bashy<\/em>. Let’s consider the output while entering 3 command line arguments: Here we see each command line argument assigned to a variable, as expected, and printed out such that each of the three brackets in the The output here is similar except that, for the last bracketed variable in the Every value beyond the first two (1 and 2) are assigned to the third variable This behavior isn’t strictly related to the The In this script, the following actions and options are taken\/specified:<\/p>\n The output from this script displays the contents of the The output is exactly as expected! This demonstrates very basic, somewhat opinionated, usage of the What is the best way to use the Bash is a common scripting language that has evolved much over the years. It provides developers with a toolset to complete quick-and-dirty automation to help streamline productivity. Among its many features is the read tool which helps get input from the command line, prompting the user, or even via redirection and piping. Highlights Bash’s read […]<\/p>\n","protected":false},"author":2,"featured_media":3339,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[10],"tags":[736,12,738],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3326"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=3326"}],"version-history":[{"count":8,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3326\/revisions"}],"predecessor-version":[{"id":3344,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3326\/revisions\/3344"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/3339"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=3326"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=3326"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=3326"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}read<\/code> tool will be covered:<\/p>\n\n
echo<\/code> and read<\/code>.<\/li>\nread<\/code> tool.<\/li>\nread<\/code> to save the input to multiple variables.<\/li>\nread<\/code> to get input from a file, line-by-line.<\/li>\nread<\/code> tool’s full gamut of functionality. However, most common cases are addressed here such that anyone should feel comfortable using the read<\/code> tool in bash scripting afterward.<\/p>\nRead User Input<\/h2>\n
#!\/bin\/bash\r\n\r\n# prompt a user to enter a username.\r\necho \"Enter your username: \"\r\n\r\n# use read command to store input to\r\n# the <username> variable.\r\nread username\r\n\r\n# print the username to the console\r\n# as a confirmation of success.\r\necho \"Hello, $username\"<\/pre>\n
\n
username<\/code>.<\/li>\nusername<\/code> variable to confirm.<\/li>\n<\/ol>\nEnter your username: \r\nZack\r\nHello, Zack\r\n<\/pre>\n
Zack<\/code> typed is on the line following the prompt to the user.<\/p>\nKeeping User Input on the Same Line<\/h3>\n
-n<\/code> flag to the echo<\/code> tool which will, according to the man pages, instruct the echo<\/code> tool: “do not output the trailing newline.” We just need to change the first line to the following:<\/p>\necho -n \"Enter your username: \"<\/pre>\n
Zack<\/code> is entered:<\/p>\nEnter your username: Zack\r\nHello, Zack\r\n<\/pre>\n
Aside: Dealing with Escaped Characters<\/h3>\n
read<\/code> to “… not allow backslashes to escape any characters.” Let’s consider an example of when this would cause an issue:<\/p>\n# defines a string variable\r\nbase=\"alpha\\rithms\";\r\n\r\n# read in base variable without\r\n# disabling escape feature\r\nread var1 <<< \"$base\"\r\necho \"$var1\";\r\n\r\n# read in base variable with\r\n# escaping disabled\r\nread -r var2 <<< \"$base\";\r\necho \"$var2\"<\/pre>\n
base<\/code> as a string with an escaping backslash in the midst of the characters alpha\\rithms<\/code>. We then use the <<<<\/code> (here string) operator to explicitly pass this variable into the read<\/code> command in two ways:<\/p>\n\n
-r<\/code> flag, allowing escaping characters to be present as typed.<\/li>\n-r<\/code> flag, removing escaping slashes from the text.<\/li>\n<\/ol>\nalpharithms\r\nalpha\\rithms\r\n<\/pre>\n
\\<\/code> character for line continuations.<\/p>\nPrompt & Read User Input<\/h2>\n
echo<\/code> command to facilitate gathering user input was deemed too tedious and the read<\/code> tool was given a prompting feature. By passing the p<\/code> flag, the read<\/code> tool will both prompt and read user input. Consider the following:<\/p>\n# prompt user for name and\r\n# store as variable\r\nread -p \"Enter a username: \" username\r\n\r\n# print the username to the console\r\n# as a confirmation of success.\r\necho \"Hello, $username\"<\/pre>\n
Enter a username: Zack\r\nHello, Zack\r\n<\/pre>\n
-p<\/code> option’s ability to remove the dependency of echo<\/code> when gathering user input. Let’s now consider extending this use-case to prompt a user for their username\u00a0and<\/em> password. In the above example, we note that the username Zack<\/code> was visible in the console — not a secure approach for gathering passwords. Using the -s<\/code> flag, the read<\/code> tool will “silence” the input such that it is not visible on the console. Consider the following:<\/p>\n# prompt user for name and\r\n# store as variable\r\nread -p \"Enter a username: \" username\r\nread -sp \"Enter a password: \" password\r\n\r\n\r\n# print the username to the console\r\n# as a confirmation of success.\r\necho \"Hello, $username. The length of your password is ${#password}.\"<\/pre>\npassword<\/code> that prompts the user for input much like the prompting for username<\/code>. The difference is the introduction of the -s<\/code> flag to ensure the value of password<\/code> is not displayed in the terminal as the user types. The final statement echos the length of the password (not secure) for demonstration here to validate that input was, in fact, received. The output of the above script is as follows:<\/p>\nEnter a username: Zack\r\nEnter a password: Hello, Zack. The length of your password is 8.\r\n<\/pre>\n
Read Multiple Variables<\/h2>\n
read<\/code> tool handles them.<\/p>\n#!\/bin\/bash\r\n\r\n# prompt user for some integers\r\n# and store to three variables a, b, c\r\nread -p \"enter some integers 0-9: \" a b c\r\n\r\n# print the three variables back to stdout\r\necho \"Your integers are [$a] [$b] [$c]\"<\/pre>\n
1<\/code>, 2<\/code>, and 3<\/code>:<\/p>\nenter 4 integers 0-9: 1 2 3\r\nYour integers are [1] [2] [3]\r\n<\/pre>\n
echo<\/code> string receives a single value. Now let’s consider the case where more<\/em> than 3 command line arguments are given:<\/p>\nenter 4 integers 0-9: 1 2 3 4\r\nYour integers are [1] [2] [3 4]\r\n<\/pre>\n
echo<\/code> string \u2014 the [$3]<\/code> \u2014 the last\u00a0two<\/em> command line arguments are assigned. This is expected behavior due to how bash handles command line arguments. Essentially, bash will assign the values of all command line arguments beyond the number of available variables for assignment, to the last variable. Consider one more case as an example:<\/p>\nenter some integers 0-9: 1 2 3 4 5 6 7 8 9\r\nYour integers are [1] [2] [3 4 5 6 7 8 9]\r\n<\/pre>\n
c<\/code>. This is true for string values as well:<\/p>\nenter some integers 0-9: 1 2 3 4 5 6 cat dog fish horse\r\nYour integers are [1] [2] [3 4 5 6 cat dog fish horse]\r\n<\/pre>\n
read<\/code> command but useful given how the tool is commonly used. Check out this article by Redhat<\/a> for a more detailed discussion on handling command line arguments in bash. Bash’s handling of command line args is somewhat strange when compared to other languages like Python<\/a>, which shadows how other C-based languages handle them.<\/p>\nRead From a File Line-by-Line<\/h2>\n
read<\/code> tool can be used to read data linewise in from an external file. Assuming the file exists, is readable, and contains valid data the following approach will leverage the read<\/code> command to read a file line-by-line:<\/p>\n#!\/bin\/bash\r\n\r\n# iterate over word boundaries\r\nwhile IFS= read -r line; do\r\n\r\n # print the line to the console\r\n echo \"$line\"\r\n\r\n# redirect file contents\r\ndone < \"..\/data\/names.txt\"<\/pre>\n
\n
<<\/code> redirection operator is used to indicate the data source.<\/li>\n-r<\/code> flag is used to avoid issues with slashes.<\/li>\n<\/ol>\nnames.txt<\/code> file which has a series of names listed as first, last<\/code> separated by newlines:<\/p>\nbob, foo \r\nalice, delaney\r\ngarth, smith \r\nwayne, nebo \r\nbill, jones \r\nted, jackson \r\nmidge, marley<\/pre>\n
while<\/code> loop in which the read<\/code> tool can be leveraged to read line-by-line from a file.<\/p>\nFinal Thoughts<\/h2>\n
read<\/code> tool? There is no easy answer here and like many things in the world of computer science and software engineering: it depends on what one is trying to do! The read<\/code> command can be used along with the -p<\/code> option to prompt and read user input which is a great time-saver as well as incredibly useful. Knowing the nuances of bash’s command line argument interpretations can ensure multiple variables can be accurately handled via the read<\/code> tool as well.<\/p>\n","protected":false},"excerpt":{"rendered":"