Executing a background job

Appending an ampersand ( & ) to the command runs the job in the background.

For example, when you execute a find command that might take a lot time to execute, you can put it in the background as shown below. Following example finds all the files under root file system that changed within the last 24 hours.

find / -ctime -1 > /tmp/changed-file-list.txt &

Sending the current foreground job to the background using CTRL-Z and bg command

You can send an already running foreground job to background as explained below:

Press CTRL+Z which will suspend the current foreground job. Execute bg to make that command to execute in background. For example, if you’ve forgot to execute a job in a background, you don’t need to kill the current job and start a new background job. Instead, suspend the current job and put it in the background as shown below.

find / -ctime -1 > /tmp/changed-file-list.txt

[CTRL-Z]
[2]+  Stopped                 find / -ctime -1 > /tmp/changed-file-list.txt

bg

View all the background jobs using jobs command

You can list out the background jobs with the command jobs. Sample output of jobs command is

jobs
[1]   Running                 bash download-file.sh &
[2]-  Running                 evolution &
[3]+  Done                    nautilus .

Taking a job from the background to the foreground using fg command

You can bring a background job to the foreground using fg command. When executed without arguments, it will take the most recent background job to the foreground.

fg

If you have multiple background jobs, and would want to bring a certain job to the foreground, execute jobs command which will show the job id and command.

In the following example, fg %1 will bring the job#1 (i.e download-file.sh) to the foreground.

jobs
[1]   Running                 bash download-file.sh &
[2]-  Running                 evolution &
[3]+  Done                    nautilus .

# fg %1

Kill a specific background job using kill %

If you want to kill a specific background job use, kill %job-number. For example, to kill the job 2 use

kill %2

All the above contents are taken from this link.

1) Your code is not correct, you missed one ] bracket somewhere. Probably after [ -z "$2" block.

2) if statement executes following command(s) and then executes block of code enclosed in then .. fi or then .. else keywords if the return value of the command(s) is true (their exit code is 0)

3) [ is just an alias for the test command (try man test). This command takes several parameters and evaluates them. For example, used with -z "$something" flags would return true (0) if $something is not set or is an empty string. Try it:

if [ -z "$variable" ]; then
    echo Variable is not set or is an empty string
fi

4) || statement is an OR. Next command would be executed if the previous one returned false statement. So in the statement

if [ -z "$variable" ] || [ -z "$variable2" ]; then
    echo Variable 1 or variable 2 is not set or is an empty string
fi

command [ -z "$variable2" ] would be executed only if variable was empty. The same could be achieved with different syntax:

if [ -z "$variable" -o -z "$variable2" ]; then
    echo Variable 1 or variable 2 is not set or is an empty string
fi

which should be faster, because it requires only one instance of the test program to be run. Flag -o means OR, so you could read it as: If variable is not set/empty OR variable2 is not set/EMPTY...

5) Statement "[ ${3:-} ]" means return true if $3 (the third argument of the script) is set.

6) >&2 is a stream redirection. Every process has two outputs: standard output and error output. These are independent and could be redirected (for example) to be written to two different files. >&2 means "redirect standard output to the same location as standard error".

So to sum up: commands between then .. fi will be executed IF the script is run with $1 empty or $2 empty or $3 NOT empty That means that the script should be run with exactly two parameters. And if not, the echo message will be printed to standard error output.

A "background job" is just one that is not interacting with the user—it doesn't control the tty and it just does its thing (generally silently). A foreground job is the reverse, it holds control of the tty to interact with the user.

Ctrl + Z suspends the most recent foreground process (the last process to interact with the tty) (unless that process takes steps to ignore suspension, like shells normally do). This will generally bring you back to your shell, from which you can generally enter the command bg to move the just-suspended process to the background (letting it continue to run) or fg to bring it back to the foreground.

The line

test -z $LOGNAME || echo Logname is not defined

is an OR list, and can be translated as:

DO echo Logname is not defined IF test -z $LOGNAME FAILS

As you mention in your question, test -z $LOGNAME tests whether $LOGNAME is zero length ... and since it isn't, the test fails. Replacing || with && as follows will give you the behaviour you want:

test -z $LOGNAME && echo Logname is not defined

EDIT: As per William Pursell's comment below, test -n (test for a non-zero-length string) and || might make more conceptual sense, but you need to quote $LOGNAME in this case (and in fact it's a good idea to get into the habit of quoting variables in general):

test -n "$LOGNAME" || echo Logname is not defined

In the z readme, after line 50, it says:

Installation:

Put something like this in your $HOME/.bashrc or $HOME/.zshrc:

. /path/to/z.sh

cd around for a while to build up the db.

You need to download the z.sh file to a directory of your choosing, then tell your .bashrc where it is, so your terminal can find it. (The same applies for z-shell, which is just another shell system.) Then, after you use bash for a while, z will know your favorite locations.