Run bash script mac os x


  1. How to make a simple bash script (Mac)
  2. Running Processes In Background – Terminal / BASH (Mac OS X / Raspberry Pi)
  3. macos - How do I run a .sh or .command file in Terminal - Ask Different
  4. Make the Script Executable and then Run It

For example, suppose we want to delete the file file. We can delete it using the common Unix utility rm "remove" , and recreate it using the common Unix utility touch ; so, we might write this:. But really, if rm fails, we don't want to run touch : we don't want to recreate the file if we failed to delete it to begin with. So, we can write this instead:. This is the same as before, except that it won't try to run touch unless rm has succeeded. A third Boolean-like operator,!

This is not usually useful when exit statuses are used as actual exit statuses, indicating success or failure, but we will soon see some extended uses of exit statuses where a "not" operation is more useful. This can be useful when it is necessary to distinguish between multiple different failure statuses; for example, the grep command which searches for lines in a file that match a specified pattern returns 0 if it finds a match, 1 if it finds no matches, and 2 if a genuine error occurs. Very often, we want to run a certain command only if a certain condition is met.

For example, we might want to run the command cp source. We can do that like this:. In general, Bash treats a successful exit status zero as meaning "true" and a failed exit status nonzero as meaning "false", and vice versa. For example, the built-in command true always "succeeds" returns zero , and the built-in command false always "fails" returns one. In many commonly-used programming languages, zero is considered "false" and nonzero values are considered "true". Even in Bash, this is true within arithmetic expressions which we'll see later on. But at the level of commands, the reverse is true: an exit status of zero means "successful" or "true" and a nonzero exit status means "failure" or "false".

Be sure to include spaces before and after [[ and ]] so that Bash recognizes them as separate words. Something like if[[ or [[-e will not work properly. The commands can even include other if statements; that is, one if statement can be "nested" inside another. In this example, an if statement is nested inside another if statement's else clause:. This particular pattern — an else clause that contains exactly one if statement, representing a fallback-test — is so common that Bash provides a convenient shorthand notation for it, using elif "else-if" clauses.

The above example can be written this way:. A single if statement can have any number of elif clauses, representing any number of fallback conditions. Lastly, sometimes we want to run a command if a condition is false, without there being any corresponding command to run if the condition is true. For this we can use the built-in!

How to Run a Python Script on your MAC

For example, the following statement will copy source. All those examples above are examples using the test expressions. Actually if just runs everything in then when the command in the statement returns Always notice that misuse of those logical operands may lead to errors. In the case above, everything was fine because plain echo is almost always successful. In addition to the -e file condition used above, which is true if file exists, there are quite a few kinds of conditions supported by Bash's [[ … ]] notation.

Five of the most commonly used are:. The above conditions just scratch the surface; there are many more conditions that examine files, a few more conditions that examine strings, several conditions for examining integer values, and a few other conditions that don't belong to any of these groups. For example, consider our if statement above that tries to copy source1.

The above version is very "verbose": it generates a lot of output. Usually we don't want a script to generate quite so much output; but we may want users to be able to request the output, for example by passing in --verbose as the first argument. The following script is equivalent to the above if statements, but it only prints output if the first argument is --verbose :. Later, when we learn about shell functions, we will find a more compact way to express this. However, that approach might be more confusing than is really worthwhile for such a simple purpose.

To combine multiple conditions with "and" or "or", or to invert a condition with "not", we can use the general Bash notations we've already seen. Consider this example:. The test-command [[ -e source. The end result is that [[ -e source. The construction [[ … ]] actually has built-in internal support for these operators, such that we can also write the above this way:. The if statements in the above examples are formatted to make them easy for humans to read and understand.

This is important, not only for examples in a book, but also for scripts in the real world. Specifically, the above examples follow these conventions:. These exact conventions are not particularly important, but it is good to follow consistent and readable conventions for formatting your code. When a fellow programmer looks at your code — or when you look at your code two months after writing it — inconsistent or illogical formatting can make it very difficult to understand what is going on.

Often we want to run the same sequence of commands, over and over again, with slight differences. There's no obvious command containing, say, 'foo. What we need is a for loop:. Each time, it runs the body of the loop. In other words, it is equivalent to the following:. There is nothing special here about filename expansion; we can use the same approach to iterate over any other argument-list, such as the integers 1 through 20 using brace expansion :. But it's probably better to use the explicit form anyway. Another kind of loop is the while loop. It is similar to an if statement, except that it loops repeatedly as long as its test-command continues to be successful.

For example, suppose that we need to wait until the file wait. One approach is to "sleep" for a few seconds, then "wake up" and see if it still exists. We can loop repeatedly in this fashion:. Conversely, we can use an until loop to loop until a given command is successful; for example, the reverse of the above might be:.

Of course, this is the same as combining while with! A shell function is a special type of variable that is essentially a script-within-a-script. This feature allows us to group a sequence of commands into a single named command, which is particularly useful if the sequence of commands needs to be run from many places within the script. A shell function can even consist of just a single command; this may be useful if the command is particularly complicated, or if its significance would not immediately be obvious to a reader.

That is, shell functions can serve two purposes: they can save typing, and they can allow for more readable code by creating intuitively-named commands.

How to make a simple bash script (Mac)

Consider the following script:. The function invokes the built-in command read which reads a line of user input and saves it in one or more variables with several options that most Bash programmers will not be familiar with. The -r option disables a special meaning for the backslash character; the -p option causes a specified prompt, in this case Password: , to be displayed at the head of the line; and the -s option prevents the password from being displayed as the user types it in. Since the -s option also prevents the user's newline from being displayed, the echo command supplies a newline.

Additionally, the function uses the conditional expression -t 0 to make sure that the script's input is coming from a terminal a console , and not from a file or from another program that wouldn't know that a password is being requested. This last feature is debatable; depending on the general functionality of the script, it may be better to accept a password from standard input regardless of its source, under the assumption that the source was designed with the script in mind.

Even then, shift and set will only affect the positional parameters within the function, not those of the caller. A function call returns an exit status, just like a script or almost any command.

Making a script available everywhere

To explicitly specify an exit status, use the return command, which terminates the function call and returns the specified exit status. The exit command cannot be used for this, because it would terminate the entire script, just as if it were called from outside a function. If no exit status is specified, either because no argument is given to the return command or because the end of the function is reached without having run a return command, then the function returns the exit status of the last command that was run. Incidentally, either function or may be omitted from a function declaration, but at least one must be present.

Take your time with this section. These concepts are relatively straightforward once you understand them, but they are different in important ways from analogous concepts in other programming languages. Many programmers and systems administrators, including some who are experienced in Bash, find them counter-intuitive at first. In Bash, one or more commands can be wrapped in parentheses, causing those commands to be executed in a "subshell".

There are also a few ways that subshells can be created implicitly; we will see those later. A subshell receives a copy of the surrounding context's "execution environment", which includes any variables, among other things; but any changes that the subshell makes to the execution environment are not copied back when the subshell completes.

Running Processes In Background – Terminal / BASH (Mac OS X / Raspberry Pi)

So, for example, this script:. If you need to call a function that modifies one or more variables, but you don't actually want those variables to be modified, you can wrap the function call in parentheses, so it takes place in a subshell. This will "isolate" the modifications and prevent them from affecting the surrounding execution environment.

That said: when possible, it's better to write functions in such a way that this problem doesn't arise to begin with. As we'll see soon, the local keyword can help with this. The same is true of function definitions; just like a regular variable, a function defined within a subshell is not visible outside the subshell.

A subshell also delimits changes to other aspects of the execution environment; in particular, the cd "change directory" command only affects the subshell. If your script needs to change the working directory before running a given command, it's a good idea to use a subshell if possible. Otherwise it can become hard to keep track of the working directory when reading a script.

Alternatively, the pushd and popd built-in commands can be used to similar effect. An exit statement within a subshell terminates only that subshell. Like in a script as a whole, exit defaults to returning the exit status of the last-run command, and a subshell that does not have an explicit exit statement will return the exit status of the last-run command.

We have already seen that, when a program is called, it receives a list of arguments that are explicitly listed on the command line. What we haven't mentioned is that it also receives a list of name-value pairs called "environment variables". In Bash, environment variables are simply made into regular Bash variables. So, for example, the following script prints out the value of the HOME environment variable:.

The reverse, however, is not true: regular Bash variables are not automatically made into environment variables. To turn a regular Bash variable into an environment variable, we have to "export" it into the environment. The following script does print bar :. Note that export doesn't just create an environment variable; it actually marks the Bash variable as an exported variable, and later assignments to the Bash variable will affect the environment variable as well. That effect is illustrated by this script:.

The export command can also be used to remove a variable from an environment, by including the -n option; for example, export -n foo undoes the effect of export foo. And multiple variables can be exported or unexported in a single command, such as export foo bar or export -n foo bar. It's important to note that environment variables are only ever passed into a command; they are never received back from a command.

In this respect, they are similar to regular Bash variables and subshells. So, for example, this command:. However, it would affect any scripts that were called in turn by that script. Note that, despite using the syntax of a variable assignment, this is very different from a normal Bash variable assignment, in that the variable is automatically exported into the environment, and in that it only exists for the one command.

If you want avoid the confusion of similar syntax doing dissimilar things, you can use the common Unix utility env for the same effect. That utility also makes it possible to remove an environment variable for one command — or even to remove all environment variables for one command. An aside: sometimes it's useful to put variable definitions — or function definitions — in one Bash script say, header. We can see that simply invoking that other Bash script, as. This is a common point of confusion: export exports variables into the environment so that other processes can see them, but they're still only seen by child processes, not by parents.

However, we can use the Bash built-in command. If header. We have now seen some of the vagaries of variable scope in Bash. To summarize what we've seen so far:. In effect, using local to localize a variable to a function-call is like putting the function-call in a subshell, except that it only affects the one variable; other variables can still be left non-"local".

A variable that is set inside a function either via assignment, or via a for-loop or other built-in command should be marked as "local" using the built-in command local , so as to avoid accidentally affecting code outside the function, unless it is specifically desired that the caller see the new value. It's important to note that, although local variables in Bash are very useful, they are not quite as local as local variables in most other programming languages, in that they're seen by child function-calls. When a function exits, variables regain the values they had before their local declarations or they simply become unset, if they had previously been unset.

Interestingly, this means that a script such as this one:.

  • asterisk password viewer for mac os x;
  • mysqldb mac image not found.
  • how do you transfer music from ipod to mac free!
  • mac dock download for windows xp!
  • phu nu mac ho henh?

And since local is simply an executable command, a function can decide at execution-time whether to localize a given variable, so this script:. As we have seen, a command's return value, taken strictly, is just a small non-negative integer intended to indicate success or failure.

macos - How do I run a .sh or .command file in Terminal - Ask Different

Its real output is what it writes to the standard output stream. By default, text written to the standard output stream is printed to the terminal, but there are a few ways that it can be "captured" and used as the command's true return value. When a sequence of commands are linked together in a pipeline, the output of each command is passed as input to the next. This is a very powerful technique, since it lets us combine a number of small utility programs to create something complex.

Command substitution is a bit like variable expansion, but it runs a command and captures its output, rather than simply retrieving the value of a variable. There is really no reason that the caller should have to save the password in a variable. It runs the command c , using its output as an argument to b , and using the output of that as an argument to a. A command substitution can actually contain a sequence of commands, rather than just one command.

The output of all of these commands is captured. In most contexts in bash, a glob pattern automatically expands to an array of all matching filenames:. It is possible to create a "bash bomb": a pattern that grows exponentially in size under expansion:. Like most languages, bash supports control structures for conditionals, iteration and subroutines. However, in bash the condition is a command, and an exit status of success 0 is "true," while an exit status of fail non-zero is "false.

There is an alternate notation for test args using square brackets: [ args ]. The while command ; do commands ; done form executes commands until the test command completes with non-zero exit status:. It's possible to iterate over the elements in an array with a for var in array ; do commands ; done loop:. One major different is that functions can see and modify variables defined in the outer script:. Shell programming with bash: by example, by counter-example [ article index ] [] [ mattmight ] [ rss ].

What is bash? So there's no way to convert something like! You'll have to put set -exu after the hashbang instead. When you use the env approach which does a PATH search, you take the user's preference into account and use his preferred bash over the one his system shipped with.

If you want the script to run in the current shell e. The file extension. Double-clicking on any. Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site the association bonus does not count. Would you like to answer one of these unanswered questions instead?

Learn more about Teams. How to run a shell script on a Unix console or Mac terminal?

Make the Script Executable and then Run It

Ask Question. Asked 10 years, 4 months ago. Active 1 year, 5 months ago. Viewed k times. I know it, forget it and relearn it again.

Time to write it down. P-A P-A 5, 7 7 gold badges 22 22 silver badges 19 19 bronze badges. It should contain a hashbang :! Sadly, you cannot just do this:!