{"id":501,"date":"2019-08-05T22:00:53","date_gmt":"2019-08-06T02:00:53","guid":{"rendered":"http:\/\/richrijnders.com\/?p=501"},"modified":"2020-12-12T15:32:38","modified_gmt":"2020-12-12T20:32:38","slug":"shell-script-trim-args","status":"publish","type":"post","link":"https:\/\/richrijnders.com\/shell-script-trim-args\/","title":{"rendered":"BASH 01: Trim Your Args!"},"content":{"rendered":"

[et_pb_section fb_built=”1″ _builder_version=”3.26.6″][et_pb_row _builder_version=”3.26.6″ custom_padding=”||16px|||”][et_pb_column type=”4_4″ _builder_version=”3.26.6″][et_pb_image src=”https:\/\/richrijnders.com\/file\/2019\/08\/kbd_banner_21189847.jpg” align=”center” force_fullwidth=”on” _builder_version=”4.7.6″ hover_enabled=”0″ title_text=”kbd_banner_21189847″ sticky_enabled=”0″][\/et_pb_image][et_pb_text _builder_version=”3.27.4″ text_orientation=”justify” text_text_align=”justify”]<\/p>\n

Ideally I wanted to put this article in a category called “Stuff we all need to know but never get around to master”<\/em>\u00a0because, for me, that is squarely where the subject of shell scripting (BASH, SH, et. al.) firmly lived for way too long. As software developers, \u00a0we are experts in our respective platforms. Whether that be mobile apps, cloud API’s, or MRP \/ ERP back-end behemoths, we know the interplay of our code and interfaces to our cores. But every so often we all end up in a situation that requires us do some dreaded shell scripting to solve a specific problem. When this happens we can be seen floundering about; confounded by this thing that seems to be a simple coding language but never seems to work the way we think it should. So we search the internets for some piece of script that appears to do something close to what we need. Then we tweak this strange bunch of back-ticks, curly braces, and escape characters until we get the desired outcome (maybe). But we never\u00a0really<\/em> understand what it’s doing. I never liked this, so when I needed to develop more sophisticated HLL-type utilities in BASH that were to become a fixed part of a major application, I made it a point to\u00a0really dig in, develop, and\u00a0understand<\/em> SH and BASH scripting.<\/p>\n

In this series of articles, I thought it might be useful to discuss shell scripting in terms of small\u00a0Code Snippets –\u00a0<\/em>imparting some shell scripting knowledge and demystification through the dissection of actual working, useful, and re-usable<\/em> code. In this first article we will discuss a simple trim()<\/em>\u00a0function. It does the same thing as similarly named built in functions (BIF’s) of high level languages (HLL’s). It will strip any leading or trailing whitespace characters from a string variable passed to it. We all know our applications should not trust data that originates from external, untrusted, sources. Any data passed in to our shell scripts as a string argument should be devoid of leading or trailing whitespace (CR\/LF, TAB, etc). Such whitespace can cause havoc in our code if that string is blindly used in downstream operations so, we must trim() them.\u00a0<\/p>\n

Below is our sample script containing the\u00a0trim()<\/em> function. It might be helpful if you right-click and open the image in a separate browser window so you can follow along with the discussion. Alternately, you can\u00a0

Download Source File<\/a><\/div><\/div> and open it in your favorite text editor to follow along.\u00a0<\/p>\n

[\/et_pb_text][et_pb_image src=”https:\/\/richrijnders.com\/file\/2019\/08\/TrimYourArgs_AnnotatedCode.jpg” force_fullwidth=”on” _builder_version=”4.7.6″ hover_enabled=”0″ box_shadow_style=”preset4″ title_text=”TrimYourArgs_AnnotatedCode” sticky_enabled=”0″][\/et_pb_image][et_pb_text _builder_version=”3.27.4″ text_orientation=”justify” text_text_align=”justify”]<\/p>\n

Some Basics<\/h2>\n

The first thing you will notice is that I like to structure my scripts the same way I do any other application or program. We start with the “Shabang” line which points to where our BASH interpreter resides. Following that is a basic documentation box with the typical attributions and revision information.<\/p>\n

The next section <\/span>(a)<\/strong> <\/span>is something I put at the top of my BASH scripts. It retrieves variables that I find I often need in my scripts for one reason or another.<\/span><\/p>\n

LINE 22: Determines the absolute path in the systems file directory where the running instance of the script was loaded from and saves that information in a variable named SCRIPTPATH. This variable is defined as READONLY since there is no reason for it to be changed. Why might you need this information? \u00a0Within your script you may need to access other resources that are expected to be in the same location as this script or else you may need to write messages to a log that need to identify the location of the running script. Also, you may need to pass this information to other commands or utilities that don’t work with relative paths. \u00a0How this odd string of characters accomplishes this is a discussion perhaps for another article. Suffice it to say that you may see some shorter code that purports to accomplish the same thing, but those have issues when the script was executed using a relative reference (ie: “..\/myscript”) and the above is thus far the only reliable way I have found to always get the full, absolute path.<\/p>\n

LINE 25: Retrieves the name of the running script. You might think this odd since your script should have a fixed name, no? No. Script files are often renamed when used or cloned and modified for similar application implementations. If the name of the script is needed for instance, to load a configuration file with the same file name prefix as the script, then retrieving it dynamically avoids pitfalls when the script is renamed and avoids having to do scan-and-replace operations on the code whenever it is renamed.<\/p>\n

LINE 28: Retrieves the PID (process ID) of this instance of the running script. AKA the\u00a0thread<\/em>. This is useful for logging when there might be multiple instances of this script running concurrently on the system or when spawning an error recovery operation to clean up (kill) this running process if an unrecoverable error occurs.<\/p>\n

 <\/p>\n

[\/et_pb_text][et_pb_text _builder_version=”3.27.4″ header_4_font=”Roboto Mono||||||||” header_4_text_color=”#0c71c3″ header_4_font_size=”14px” header_6_font=”Roboto Mono||||||||” header_6_text_color=”#0c71c3″ header_6_font_size=”12px” text_orientation=”justify” text_text_align=”justify” inline_fonts=”Roboto Mono”]<\/p>\n

The Trim() Function<\/h2>\n

LINE 37: (b)<\/span><\/strong> is where the meat of our discussion takes place. This is where we difine our re-usable trim() function. \u00a0In shell scripting, a function is simply defined by its name followed by open and close parenthesis and delimited by an opening curly brace and closed curly brace.\u00a0Script functions do not require arguments to the function to be defined. Just like arguments passed to the script itself, arguments passed to the function are referenced within the function simply as the variables $1, $2, etc. You can see the argument being passed into the function being referenced as $1 on LINE 39.<\/p>\n

Our goal is that our function should behave as much like a function in an HLL as possible. Ideally we want to simply pass a variable to the function and have it trimmed.\u00a0<\/span>But script functions do not have the capability to return a value to the caller. For example:<\/span>\u00a0<\/span><\/p>\n

myTrimmedString=trim ${myString}\u00a0 \/\/ not valid in a shell script<\/span><\/p>\n

Is not valid because trim() can not return a value.\u00a0Without the ability for a function to return a value, our only option is to set the result to a global variable that can be accessed after the function call. Yet if that result variable is set inside the function, then it must be hard-coded and will be the same for each call to the function, resulting in code like so:<\/span><\/p>\n

trim ${myString}<\/span><\/p>\n

myString=${trimResultVar}<\/span><\/p>\n

In the above example, the defined trim function would take the input argument as a string, trim the leading and trailing whitespace, and then assign that trimmed value to a hard-coded global variable named <\/span>trimResultVar<\/span>. Not only is this messy code, but it requires that the code outside the function have knowledge of the result variable name used inside the function. There is also no obvious connection between the two lines of code above which makes the code hard to follow.<\/span><\/p>\n

But we have a better solution.\u00a0<\/span><\/p>\n

You will note in our sample program on LINE 55 that when we invoke\u00a0<\/span>our trim() function, we pass<\/span>\u00a0<\/span>myArg<\/span>\u00a0as a literal to the function and not<\/span>\u00a0<\/span>${myArg}<\/span>\u00a0the variable. This is because we are passing the variable\u00a0<\/span>name<\/em>\u00a0to the function, <\/span>not<\/strong><\/em> the actual string of text that we want trimmed. LINE 39 in our trim() function takes the name of the variable (that contains the text to be trimmed) and assigns that to a local variable named _varName<\/span>. The local<\/span> qualifier limits the scope of the variable to only the local function block and the leading underscore in the variable name is a commonly accepted convention for localized variables. \u00a0Then, LINE 40\u00a0dereferences\u00a0<\/em>that variable name to get its value (the string to be trimmed) and assigns that string to another local variable _str<\/span>.\u00a0The exclamation point in the dereference statement causes the string of characters following it to be treated as a variable that contains another variable name (a “varvar”), expands it to its contents, and then retrieves the value of the variable having that<\/em> name. \u00a0<\/span><\/p>\n

Example:<\/span><\/p>\n

myVar=’abcdef’<\/span><\/p>\n

myVarName=’myVar’<\/span><\/p>\n

echo ${myVar} \u00a0\/\/ prints ‘abcdef’<\/span><\/p>\n

echo ${myVarName} \/\/ prints ‘myVar’<\/span><\/p>\n

echo ${!myVarName} \u00a0\/\/ prints ‘abcdef’<\/span><\/p>\n

Now that we have both the name of the variable to be trimmed (<\/span>_varName<\/span>) and its value (<\/span>_str<\/span>) we can trim any leading and trailing whitespace from the value on LINE 42 <\/span>(c)<\/span><\/strong>. This looks like one of those cases of scripting “voodoo” where some of us would just be tempted to copy\/paste and then tweak until we get the desired result. But if you don’t understand what is happening there then you have no clear concept of either the long term stability of your application or the security implications for your system. Besides, it’s not all that complex to understand, so let’s break it down.<\/span><\/p>\n

The first part of the line is the assignment:<\/span><\/p>\n

_str=”$(<\/span> … <\/span>)”<\/span><\/p>\n

If you are not familiar with this method of assigning a value to a variable, it is called\u00a0<\/span>command substitution<\/em>. It just takes the results of any command you put between the parens and assigns that result to the variable. The command we put inside the parens is what is removing the whitespace. So let us look more closely at that command.<\/span><\/p>\n

<\/span><\/p>\n

The first part of the command is pretty straight forward and we all probably get it:<\/span><\/p>\n

echo -e “$_str”<\/span><\/p>\n

On its face, this statement simply outputs the value of the variable <\/span>_str<\/span>. More accurately, it outputs the contents of <\/span>_str<\/span>\u00a0to <\/span>stdout<\/em> (the standard output). The <\/span>-e<\/span> option is there just to enable backslash escaped characters if they happen to be in the string variable. The next part of our command is the pipe character <\/span>|.<\/span> This operator simply sends the results of whatever command is in front of it (in this case, our echo command) to the\u00a0<\/span>stdin<\/em> of whatever command follows it.\u00a0<\/span><\/p>\n

What follows it is an invocation of the <\/span>sed<\/a> utility. sed is a *nix utility that performs basic stream editing on an input stream or file. In this case, we are asking sed to perform two operations on the stream of characters we are sending to its\u00a0<\/span>stdin<\/em> via our pipe symbol. The first operation:<\/span><\/p>\n

s\/^[[:space:]]*\/\/<\/span><\/p>\n

is a\u00a0<\/span>regular expression<\/em> that will remove any leading whitespace from the string\/stream. The second operation:<\/span><\/p>\n

s\/[[:space:]]*$\/\/<\/span><\/p>\n

is another <\/span>regular expression<\/em> that will remove any trailing whitespace from the string\/stream.\u00a0If you are unfamiliar with how regular expressions work, there are many very good tutorials out there that are easily found with an internet search. The <\/span>-e<\/span> option is different for sed than for the echo command. For sed, the -e option is a way to stack a number of operations to be performed on the same string\/stream. So in this case, the -e options allow us to stack the two regular expressions described above so that they are both performed on our string in a single pass.\u00a0<\/span><\/p>\n

So much for the “voodoo” line. Breaking it down into its constituent parts, we can see and understand what is really happening. We have passed the contents of the <\/span>_str<\/span> variable to the <\/span>sed<\/span> utility that uses regular expressions to strip leading and trailing whitespace, and we assign the results right back into the <\/span>_str<\/span> variable.<\/span><\/p>\n

The last line of our function (d)<\/span><\/strong> takes the trimmed results currently stored in the local _str variable and moves that result back into the variable whose name was passed into our function as an argument. Here we have another shell limitation to get around. The dereferencing directive (the exclamation point) we used on LINE 40 is only valid on the right side of an assignment. The left side of an assignment must be an actual variable name – not a varvar. To avoid having to assign the results to a hard-coded global variable, we need a way to assign our results back to the original variable name held in our varvar,\u00a0<\/span>_varName<\/span>.\u00a0<\/span><\/p>\n

The solution is to use the <\/span>eval<\/span> command. The eval command basically takes the string you pass to it and executes it as if you had typed it on a command line. This allows us to use our varvar on the left side of an assignment because the shell interpreter will\u00a0expand<\/em> the varvar to its contents (as it does all variables) and so allows us to assign the results to the original variable. To better understand this, let’s say our function was invoked by passing in the variable named scriptArg01<\/span> that has a value of ” Hello World ” (note the leading and trailing spaces). \u00a0When our function gets down to LINE 44, the eval<\/span> command results in<\/span><\/p>\n

$_varName=”‘${_str}'”<\/span>\u00a0 being expanded to actually execute scriptArg01=’Hello World’<\/span><\/p>\n

Thus, our goal of a reusable function to trim leading and trailing whitespace is realized. Anywhere in our scripts, we can ensure arguments or data that originates outside of our application’s control is clean of any carriage returns, line feeds, or tabs with a single, simple line of code:<\/p>\n

trim scriptArg01<\/span><\/p>\n

That’s it! \u00a0Before invoking the function, scriptArg01<\/span> might contain ” hello world “<\/span> but after invoking that one line of code, it now contains “hello world”<\/span>. \u00a0In our sample program, we output the result with an echo statement (e)<\/span><\/strong>. We sandwich the value between two pipe symbols just so that it is easier to see that there is no leading or trailing whitespace in the result.<\/p>\n

<\/span><\/p>\n

<\/span><\/p>\n

[\/et_pb_text][et_pb_text _builder_version=”3.27.4″ text_orientation=”justify” text_text_align=”justify”]<\/p>\n

Conclusion<\/h2>\n

In this article, we dissected a very simple program function called\u00a0trim()<\/em>. Though the function seems simple and small, we covered some crucial scripting concepts such as:\u00a0<\/p>\n

    \n
  • local<\/em> variables to limit function variables to the local scope<\/em><\/li>\n
  • creating and dereferencing varvar’s<\/em> to allow passing any variable to our function without hardcoding<\/li>\n
  • command substitution<\/em> in order to assign the results of calling external system utilities like\u00a0sed<\/em> to a variable<\/li>\n
  • using\u00a0echo<\/em> and\u00a0pipe<\/em> to send the contents of a variable to an external command line utility<\/li>\n
  • using\u00a0eval<\/em> to enable us to assign values to the contents of a varvar<\/em>\u00a0<\/li>\n<\/ul>\n

    In future articles covering other reusable code snippets, we will undoubtedly see these same concepts again in slightly different implementations, but this should just solidify your understanding of them even more. My hope is that just a few such articles will be enough to make you more comfortable with shell scripting and give you the confidence to apply HLL structure and best practices to ensure they are a solid part of your application.<\/p>\n

    \u00a0<\/em><\/p>\n

    [\/et_pb_text][\/et_pb_column][\/et_pb_row][\/et_pb_section]<\/p>\n","protected":false},"excerpt":{"rendered":"

    Learn about the basics and quirks of shell scripting as we dissect a simple but useful bash function for trimming whitespace from arguments passed into your scripts. <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"on","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[28],"tags":[31,33,32,34,30,35],"class_list":["post-501","post","type-post","status-publish","format-standard","hentry","category-rich-rijnders-code-snippets","tag-bash","tag-code","tag-script","tag-sh","tag-shell","tag-trim"],"yoast_head":"\nBASH 01: Trim Your Args! - Rich Rijnders<\/title>\n<meta name=\"description\" content=\"You should always trim your arguments or any variable coming from an external source.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/richrijnders.com\/shell-script-trim-args\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"BASH 01: Trim Your Args! - Rich Rijnders\" \/>\n<meta property=\"og:description\" content=\"You should always trim your arguments or any variable coming from an external source.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/richrijnders.com\/shell-script-trim-args\/\" \/>\n<meta property=\"og:site_name\" content=\"Rich Rijnders\" \/>\n<meta property=\"article:published_time\" content=\"2019-08-06T02:00:53+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2020-12-12T20:32:38+00:00\" \/>\n<meta name=\"author\" content=\"rich\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"rich\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/\"},\"author\":{\"name\":\"rich\",\"@id\":\"https:\\\/\\\/richrijnders.com\\\/#\\\/schema\\\/person\\\/186c2ab9e139d2ed4065ce4a70046eff\"},\"headline\":\"BASH 01: Trim Your Args!\",\"datePublished\":\"2019-08-06T02:00:53+00:00\",\"dateModified\":\"2020-12-12T20:32:38+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/\"},\"wordCount\":2577,\"commentCount\":0,\"keywords\":[\"bash\",\"code\",\"script\",\"sh\",\"shell\",\"trim\"],\"articleSection\":[\"Code Snippets\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/\",\"url\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/\",\"name\":\"BASH 01: Trim Your Args! - Rich Rijnders\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/richrijnders.com\\\/#website\"},\"datePublished\":\"2019-08-06T02:00:53+00:00\",\"dateModified\":\"2020-12-12T20:32:38+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/richrijnders.com\\\/#\\\/schema\\\/person\\\/186c2ab9e139d2ed4065ce4a70046eff\"},\"description\":\"You should always trim your arguments or any variable coming from an external source.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/richrijnders.com\\\/shell-script-trim-args\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/richrijnders.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"BASH 01: Trim Your Args!\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/richrijnders.com\\\/#website\",\"url\":\"https:\\\/\\\/richrijnders.com\\\/\",\"name\":\"Rich Rijnders\",\"description\":\"Cloud and SOA Integration Architect\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/richrijnders.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/richrijnders.com\\\/#\\\/schema\\\/person\\\/186c2ab9e139d2ed4065ce4a70046eff\",\"name\":\"rich\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/6bb4ab7390db5599ceab3677366582dcfc4110c702347142e2a71510ad6f2877?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/6bb4ab7390db5599ceab3677366582dcfc4110c702347142e2a71510ad6f2877?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/6bb4ab7390db5599ceab3677366582dcfc4110c702347142e2a71510ad6f2877?s=96&d=mm&r=g\",\"caption\":\"rich\"},\"url\":\"https:\\\/\\\/richrijnders.com\\\/profile\\\/rich\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"BASH 01: Trim Your Args! - Rich Rijnders","description":"You should always trim your arguments or any variable coming from an external source.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/richrijnders.com\/shell-script-trim-args\/","og_locale":"en_US","og_type":"article","og_title":"BASH 01: Trim Your Args! - Rich Rijnders","og_description":"You should always trim your arguments or any variable coming from an external source.","og_url":"https:\/\/richrijnders.com\/shell-script-trim-args\/","og_site_name":"Rich Rijnders","article_published_time":"2019-08-06T02:00:53+00:00","article_modified_time":"2020-12-12T20:32:38+00:00","author":"rich","twitter_card":"summary_large_image","twitter_misc":{"Written by":"rich","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/richrijnders.com\/shell-script-trim-args\/#article","isPartOf":{"@id":"https:\/\/richrijnders.com\/shell-script-trim-args\/"},"author":{"name":"rich","@id":"https:\/\/richrijnders.com\/#\/schema\/person\/186c2ab9e139d2ed4065ce4a70046eff"},"headline":"BASH 01: Trim Your Args!","datePublished":"2019-08-06T02:00:53+00:00","dateModified":"2020-12-12T20:32:38+00:00","mainEntityOfPage":{"@id":"https:\/\/richrijnders.com\/shell-script-trim-args\/"},"wordCount":2577,"commentCount":0,"keywords":["bash","code","script","sh","shell","trim"],"articleSection":["Code Snippets"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/richrijnders.com\/shell-script-trim-args\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/richrijnders.com\/shell-script-trim-args\/","url":"https:\/\/richrijnders.com\/shell-script-trim-args\/","name":"BASH 01: Trim Your Args! - Rich Rijnders","isPartOf":{"@id":"https:\/\/richrijnders.com\/#website"},"datePublished":"2019-08-06T02:00:53+00:00","dateModified":"2020-12-12T20:32:38+00:00","author":{"@id":"https:\/\/richrijnders.com\/#\/schema\/person\/186c2ab9e139d2ed4065ce4a70046eff"},"description":"You should always trim your arguments or any variable coming from an external source.","breadcrumb":{"@id":"https:\/\/richrijnders.com\/shell-script-trim-args\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/richrijnders.com\/shell-script-trim-args\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/richrijnders.com\/shell-script-trim-args\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/richrijnders.com\/"},{"@type":"ListItem","position":2,"name":"BASH 01: Trim Your Args!"}]},{"@type":"WebSite","@id":"https:\/\/richrijnders.com\/#website","url":"https:\/\/richrijnders.com\/","name":"Rich Rijnders","description":"Cloud and SOA Integration Architect","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/richrijnders.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/richrijnders.com\/#\/schema\/person\/186c2ab9e139d2ed4065ce4a70046eff","name":"rich","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/6bb4ab7390db5599ceab3677366582dcfc4110c702347142e2a71510ad6f2877?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/6bb4ab7390db5599ceab3677366582dcfc4110c702347142e2a71510ad6f2877?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/6bb4ab7390db5599ceab3677366582dcfc4110c702347142e2a71510ad6f2877?s=96&d=mm&r=g","caption":"rich"},"url":"https:\/\/richrijnders.com\/profile\/rich\/"}]}},"_links":{"self":[{"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/posts\/501","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/comments?post=501"}],"version-history":[{"count":3,"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/posts\/501\/revisions"}],"predecessor-version":[{"id":782,"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/posts\/501\/revisions\/782"}],"wp:attachment":[{"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/media?parent=501"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/categories?post=501"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/richrijnders.com\/rest\/wp\/v2\/tags?post=501"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}