With builtin, you can be sure that you are running a bash builtin instead of some external command or function that just happens to be floating around in your environment waiting to be called by a bash programmer. However, if someone overrides builtin as a function, then you may want to have it unset.

Similar to the way you would want to change the default behavior of an external command like curl in bash, builtin allows you to work around the case that you have declared a function with the same name as declare.

In addition to allowing you to run builtin commands directly, it can be used to test if a name is a builtin.

Builtin is a builtin. Great! How about this?

As you might have guessed, the above builtin command line returns a non-zero exit status, something bad happened.

Okay, builtinf is not a builtin. Maybe in a future version of bash when it has a builtin called builtinf.

If you are still not sure how to use builtin or want to see how the help page looks, this is for you.

Builtin help

Glancing through the help page for builtin is a good place to start if you are interested in learning how builtin works or need review.

You should have a basic understanding of how builtin may be used in a bash script by now. Let’s dive into some examples.

Examples using builtin

Before we start any examples let’s decide if we need builtin with a quick checklist. That is, if any of the following statements are true you may need builtin.

1. You’ve defined a function with the same name as a builtin listed in the list of bash builtins in an attempt to extend the default builtin behavior
2. You want to explicitly call a builtin by name to prevent calling a function with the same name unintentionally
3. You want to check if a name is a builtin to avoid naming a function with the same name as a builtin

Examples using builtin to extend the default behavior of any builtin follows.

Builtin example: 1 unalias to rule them all (unalias)

At the very bottom of the lists of bash builtins there is a builtin named unalias, which is like unset for aliases. Suppose that you want unalias to ignore any arguments and simply throw away any alias in the environment, rule them all. It turns out unalias has that option. Also, it would become redundant if you had to type it every time so let’s through it all into a function. Here’s how.

Commands

Test

Output

You may argue that we could get away with using an alias instead of a function. You could but the result would be a once-function, i.e. unalias would revert to its default behavior after one call.

Builtin example: 2 echo with or without color (echo)

Somewhere close to the middle of the list of bash builtins, there is a builtin named echo. Maybe you have heard of it. I have a hunch that you have. However, you may not have heard of cecho.sh, a script that I wrote to echo with color. No worries. We’re going to do something similar in this example using builtin to call echo.

Commands

Test

Output

Based on cecho.sh. You may add other colors in the echo-color function. You may modify the last builtin echo line to fit your desired default behavior or option handling scheme for echo.

Builtin example: 3 just a command (command)

command is a builtin. Like builtin it, allows us to control whether a function, external command, or builtin is called in the case that more than one shares the same name. Unlike builtin, command executes external commands and builtins, which is the same as anything that isn’t a function. What if we want to remove builtins from command? That is where builtin comes into play.

Note that builtins have higher precedence than external commands. That is, the interpreter will check for a builtin before looking for an external command.

It is both a builtin and an external command. However, when we run

The echo builtin will be used. How do we know?

If you run which echo, you would see something like /usr/bin/echo. Furthermore, /usr/bin/echo –help displays a man page, where the builtin echo doesn’t. So we run

Thanks for the help echo. At least now we know that builtins run before external commands.

Now let’s see how we can use builtin to modify command to only run external commands for fun.

Commands

Test

Here we showed how to modify the command builtin to only try external commands. Next, let’s try fun like make it hard unset variable and functions.

Builtin example: 4 disable unset (unset, builtin)

To disable unset we need to override unset and builtin using a function. In this example, we will show you how.

Commands

Now that we have the function we need to override unset and builtin, it is time to test that our solution works. Here we go!

Note that in addition to overriding unset with a function we need to override builtin as well to prevent a command to bypass our unset function.

Bash example: 5 source with include path (source)

Source is a bash builtin that lets you include another file in your script and run with arguments. What if we want to change the source directory to some location other than our working directory. It can be done. Here’s how!

Commands

Output

Here we showed that you can roll your own source command. I recommend you put something like it in your boilerplate if want a customize source to reduce keystrokes in your bash scripts.

Builtin example 6: builtin -p to list bash builtins

Hey, maybe you are sick and tired of having to look up bash builtins. As you know other commands allow you to list options using the -p option. Unfortunately, builtin doesn’t provide that option yet.

Source test-builtins.sh

Commands

Output

Here we showed how you can disable all builtins using functions. For the output of our proposed builtin -p command, just run builtins from test-builtins.sh. Full implementation will be left to the reader as an exercise.

Commands

Output

Builtin example: 7 disable listing of aliases

Suppose in a restricted shell somewhere out there in the bash universe, the listing of aliases is disabled. Here may be how you could disable the listing of aliases using functions.

Commands

Output

Builtin example: 8 using enabled

As you recall, we disabled builtins using functions above. It turns out that you can get the same work down using the enable builtin. Here’s how.

Commands

Output

Here we showed you how to disable (most) builtins using the enable builtin. You may opt to disable the rest at the end of the loop.

Bottom line

Builtin helps modify the shell behavior in bash. Here we showed a few ways that buitlin may be used such as to disable builtin command features or the commands entirely. Still, there are untouched topics such as loading new builtin commands through dynamic loading that may be covered at a later date.