Course Overview: Automate Daily Development Tasks with Bash

Navigate the Filesystem in Bash

View Files and Folders in Bash

Create and Delete Files and Folders in Bash

Move and Copy Files and Folders with Bash

Find Files and Folders with `find` in Bash

Search for Text with `grep`

Make HTTP Requests in Bash with `curl`

Create and Run Bash Scripts with Command Line Arguments

Store and Use Values with Bash Variables

Understand and Use Functions in Bash

Understand Exit Statuses in Bash

Use Conditional Statements in Bash

Chain Commands with Pipes and Redirect Output in Bash

Automate Daily Development Tasks with Bash

In this lesson, we'll go over how bash functions work. Bash functions work like mini bash scripts--you can pass parameters and invoke them just like a bash command. You can also define local variables within a bash function using the `local` keyword. Local variables follow similar scope rules present in most programming languages. 

https://app.egghead.io/api/v1/lessons/bash-understand-and-use-functions-in-bash/subtitles

Instructor: [00:00] I've already created a script file called functions.sh and I've given that execute permissions using the chmod commands.

[00:08] Defining a function in Bash is somewhat similar to other programing languages. We give it a name. We'll create a greet function, and we give it two parentheses and an opening and closing curly brace. In the function's block is where we define commands that we want to run.

[00:24] We'll do an echo "Hello, World!" here. Then to invoke that function, we invoke it just like we invoke any Bash command. Let's run this. Cool, we can see that's working. Let's see how we pass arguments to a function.

[00:41] This works just like passing arguments to a script from the command line. In fact, you can think of functions as mini scripts. If I wanted to pass a different greeting here, we'll say "Howdie" instead of "Hello, World!" Replace hello with the 1 variable. Just like a script, this 1 is set to the first parameter that is passed to the command or the function in this case.

[01:07] Let's run that. We can see that it works as expected. It might be tempting to want to name the parameters between these parentheses, but the parentheses don't serve any purpose other than to indicate to the Bash compiler that it's a function definition, not a command invocation.

[01:23] To store the value that is outputted from the function, we can use the command substitution syntax. If I wanted to save this "Howdie, World!" as string in the variable, we'll give the variable a name, and then I'll use the command substitution syntax here, which is the dollar sign with the two parentheses.

[01:43] To verify it works, I'll echo, "The greeting is" greeting. Let's run that now. Cool, we see that it's working.

[01:55] Note that anything that's echoed in this function will be captured in this variable when you use the command substitution syntax. If you echoed something else up here, write that "Hey," we run that again, we can see that it's going to do "Hey," new line, "Howdie, World!"

[02:14] Something to keep in mind when you're trying to return values from a function. You want to be careful with how you use your echo. Let's clear everything.

[02:25] Functions can access variables from the outer scope, as well as to clear variables that are local to their inner scope. For example, let's create a variable that's at the top level here. This will be accessible to everything within this script.

[02:38] Let's call it global. We'll give it the value of 123. Let's create a function here. We'll call it test. In here, let's access that global. We'll say global is equal to, and then let's do clear a local variable. We'll use the local keyword for that, and I'll call my local variable local var. I'll make this a string. Let's echo that out as well.

[03:02] Now let's run our test function. To verify that the scoping rules work as expected, let's run this again, which should work. Let's try echoing out our local var again, which should not work. This should be an empty value right here.

[03:20] Let's run the function start.sh. We can see our global is working. The local variable is working as expected in the test function. Outside of it, we echoed out the global, which this still has access to. The local variable there is empty, like we expect.

Understand and Use Functions in Bash

Share this video with your friends

Course

Automate Daily Development Tasks with Bash