How to Run a Shell Script on Mac: A Beginner‘s Guide

If you‘re new to the world of command line and shell scripting, learning how to write and run your own scripts may seem daunting at first. But fear not! With this beginner-friendly guide, you‘ll be automating repetitive tasks and impressing your developer friends in no time.

In this article, we‘ll cover everything you need to know to get started with shell scripting on macOS, including:

• What shell scripts are and why they‘re useful
• The basics of writing your first script
• Step-by-step instructions for running scripts in the Terminal
• Tips, best practices, and resources for leveling up your scripting skills

Whether you‘re an aspiring programmer or just looking to be more productive on your Mac, read on to unlock the power of shell scripting!

What is a Shell Script?

Put simply, a shell script is a plain text file containing a series of commands that are executed sequentially by the command line interpreter, or "shell." The default shell in macOS is zsh (Z shell) as of Catalina, but it also includes other popular Unix shells like Bash.

Shell scripts serve as a way to automate repetitive tasks, define custom commands and functions, control program flow with conditionals and loops, and pipe data between processes. Essentially, anything you can do in the Terminal by typing out commands one at a time, you can put into a script to be executed with a single command.

For example, let‘s say you have a folder full of images that you need to resize and convert to a different format. Rather than opening each file in an image editor and exporting it manually, you could write a simple shell script to batch process them all instantly with a tool like ImageMagick.

Writing Your First Shell Script

To create a new shell script, all you need is a plain text editor. While you could use the built-in TextEdit app, it‘s recommended to use a more advanced code editor like Visual Studio Code, Atom, or Sublime Text, which offer helpful features like syntax highlighting and auto-indentation.

Let‘s write a basic "Hello, World!" script to demonstrate the key components:

#!/bin/sh

# This is a comment
echo "Hello, World!"

The first line, known as the "shebang," tells the operating system which interpreter to use to run the script. In this case, we‘re using the basic Bourne shell (sh). If we wanted to use Bash instead, we‘d change it to #!/bin/bash.

Comments are preceded by a pound sign (#) and are used to describe what the code does. They are ignored by the interpreter.

The echo command simply prints out the string that follows it to the console.

Save this script to a file with a .sh extension, like hello.sh. You can save it anywhere, but for this example let‘s put it on the Desktop.

Running a Shell Script in Terminal

Now that we have our script ready, let‘s run it! Open the Terminal app (you can find it in Applications > Utilities or by using Spotlight search).

First, we need to navigate to the directory containing our script. Since it‘s on the Desktop, we can get there by typing:

cd ~/Desktop

Next, before we can run a script, we need to set its permissions to allow execution. We can do this with the chmod command:

chmod +x hello.sh 

This adds execute permissions for the owner of the file. If you get a "Permission denied" error, you may need to use sudo before the chmod command to run it as an administrator.

Finally, we can run our script in one of two ways. The most common is to use the sh command:

sh hello.sh

Alternatively, you can execute it directly by preceding the script name with a dot and a slash:

./hello.sh

If all goes well, you should see "Hello, World!" printed to the console. Congratulations, you just ran your first shell script!

Additional Options for Running Scripts

There are a few additional options and techniques to be aware of when running shell scripts:

• If your script requires administrator privileges, you can use sudo before the script name:

  sudo ./myscript.sh

• To run a script in debug mode and see a trace of the commands being executed, use the -x flag with sh:

  sh -x myscript.sh

• For verbosed output showing each command before it‘s run, use the -v flag instead:

  sh -v myscript.sh

• If you just want to check the syntax of your script without actually running it, use the -n option:

  sh -n myscript.sh

Using the Script Editor GUI App

For those who prefer a graphical user interface over the command line, macOS includes a built-in app called Script Editor (located in Applications > Utilities) for writing and running scripts.

Script Editor supports AppleScript by default, but you can change the language to shell script in the preferences. The app provides a text editor for writing your script, plus buttons to compile, run, and save it.

However, Script Editor has some limitations compared to running scripts directly in Terminal, so it‘s mainly recommended for simpler one-off tasks rather than complex development.

Understanding the Different Shells

As we touched on earlier, macOS comes with multiple command line shells, each with its own syntax, features, and quirks. The three you‘re most likely to encounter are:

• sh – The basic Bourne shell, which all other shells are based on. It is the most compatible but lacks many modern features.

• bash – The "Bourne-again shell," which was the default in macOS prior to Catalina. It introduces helpful improvements over sh like command auto-completion and arithmetic expressions.

• zsh – The "Z shell," which has been the new default since Catalina. It builds on top of Bash with additional plugins, themes, and configuration options. While it isn‘t strictly POSIX-compliant, its advantages make it a popular choice among advanced users.

For simple scripts, the choice of shell likely won‘t matter. But as you start to utilize more advanced capabilities, it‘s good to be aware of the differences. When in doubt, the bash shebang (#!/bin/bash) is usually a safe bet for compatibility.

Real-World Examples

To give you a taste of what‘s possible with shell scripting, here are a few examples of real-world use cases:

• Backup script: A script that automatically backs up important files and directories to an external drive or cloud storage service on a regular schedule.

• Build script: A script that automates the process of compiling and packaging source code into an executable program or library.

• Deployment script: A script that deploys a web application or service to a remote server, handling tasks like copying files, restarting services, and running database migrations.

• System maintenance script: A script that performs routine maintenance tasks like freeing up disk space, updating software packages, and cleaning temporary files.

Of course, these are just scratching the surface of what‘s possible. With a solid grasp of shell scripting fundamentals, you‘ll be able to automate almost any task you can imagine!

Tips for Writing Robust Shell Scripts

As you start to write more complex scripts, keep these best practices in mind to ensure they are reliable and maintainable:

• Use comments liberally: Describe what the code does and why, so that you or others can understand it later. Also consider adding a comment header with usage instructions, author, creation date, etc.

• Use variables for readability: Assign frequently-used or user-defined values to variables with descriptive names to make the code more readable and maintainable. Always quote variable references (e.g. "$var") to avoid word splitting/globbing issues.

• Check for errors: Use conditional statements like if and test to check for error conditions and handle them gracefully. Exit the script with a non-zero status code to indicate failure.

• Use functions to organize code: If your script performs multiple distinct tasks, consider breaking them out into separate functions for better organization and reusability.

• Set a shebang: Always include a shebang line (#!/bin/sh or #!/bin/bash) at the top of your script to ensure it runs with the correct interpreter.

• Make scripts executable: Remember to set the execute permission on your script file before trying to run it (chmod +x myscript.sh).

• Test, test, test!: Make sure to thoroughly test your script with different inputs and edge cases before putting it into production use. Automated testing tools like Bats can help with this.

Resources for Further Learning

Hungry for more? Here are some resources to continue your shell scripting journey:

• Shell Scripting Tutorial – A free online book that covers beginner to advanced topics with examples
• Bash Reference Manual – The official Bash documentation, including built-in commands and syntax
• Awesome Bash – A curated list of helpful Bash scripts, tools, frameworks, and resources
• Command Line Crash Course – A quick introduction to using the command line, which is a prerequisite for shell scripting
• ShellCheck – A static analysis tool for finding bugs and style issues in shell scripts

With practice and determination, you‘ll be well on your way to shell scripting mastery!