Just use:

echo > ${WHATEVER}/fileName

I think it is superior to use a here doc to create a new file in a script. It is cleaner looking, which I believe encourages readability.

For example:

cat > filename <<- "EOF"
file contents
more contents
EOF

The "-" in <<- is optional, allowing for tabbed indents which will be stripped when the file is created. The quotes around the "EOF" prevent the "here doc" from doing any substitutions.

If you want a surprise, instead of hardcoding the name you could use a technique to generate a random string, for example

NEW_DIR=$(tr -cd '[:alnum:]' < /dev/urandom | fold -w8 | head -n1)

This sets NEW_DIR to a string of eight alphanumeric characters. Every time you run the script, the new directory will have a different random name...

Or to get a random word, pick a dictionary from /usr/share/dict/ and use shuf, for example:

$ shuf -n1 /usr/share/dict/british-english
soupier
$ shuf -n1 /usr/share/dict/british-english
penguins

So

NEW_DIR=$(shuf -n1 /usr/share/dict/british-english)
mkdir "$NEW_DIR"
...

If you're wanting this as a script, the following Bash script should do what you want (plus tell you when the file already exists):

#!/bin/bash
if [ -e $1 ]; then
  echo "File $1 already exists!"
else
  echo >> $1
fi

If you don't want the "already exists" message, you can use:

#!/bin/bash
if [ ! -e $1 ]; then
  echo >> $1
fi

Edit about using:

Save whichever version with a name you like, let's say "create_file" (quotes mine, you don't want them in the file name). Then, to make the file executatble, at a command prompt do:

chmod u+x create_file

Put the file in a directory in your path, then use it with:

create_file NAME_OF_NEW_FILE

The $1 is a special shell variable which takes the first argument on the command line after the program name; i.e. $1 will pick up NAME_OF_NEW_FILE in the above usage example.

You are getting the error because there is no space between [ and ! however there are also some flaws in your code. First you are checking if the file does not exist, and if not you are doing nothing. If the file DOES exist you are making a directory (but not doing anything to create the file).

You also don't need the null operation, you should be able to simply do:

#! /bin/bash -
if [[ ! -e /Scripts/file.txt ]]; then
    mkdir -p /Scripts
    touch /Scripts/file.txt
fi

[command2]

This is checking if /Scripts/file.txt does not exist it will create the /Scripts directory and then the file.txt file. You could also check for the existence of the directory separately if you wanted. Additionally notice I am using -e instead of -f as you asked simply to check for the existence of a file which is what -e will do where -f checks that it is a "regular file" http://tldp.org/LDP/abs/html/fto.html

I imagine that you have files in a place (/path/to/originals) and want to copy them to a target location (/path/to/destination) and modify them afterwards. Your current script looks like:

mkdir /path/to/destination
cp /originals/this-file /path/to/destination
cp /originals/this-other-file /path/to/destination
modify-somehow /path/to/destination/this-file
modify-somehow /path/to/destination/this-other-file

but you don't like to have to hardcode /path/to/destination everywhere. So you can ask to use "the value of the first positional parameter" instead of hardcoding /path/to/destination. As others mentioned, the value of the first positional parameter is $1.

So your script should be:

mkdir $1
cp /originals/this-file $1
cp /originals/this-other-file $1
modify-somehow $1/this-file
modify-somehow $1/this-other-file

And you should invoke this by adding the destination path as an argument:

my-script /path/to/destination

I tried to keep the script simple, but you could improve it, like using a single cp command to copy several files. You can also use a variable for your /originals path (but instead of an argument, this one sounds like a constant declaration at the beginning of your script)

Lastly, consider that if your filenames have spaces, you'll need to surround your $1 in double quotes.

Here's a shell function:

mkfileP() { mkdir -p "$(dirname "$1")" || return; touch "$1"; }

# Sample call
mkfileP "./newSubDir/test.txt" && echo 'created or touched' || echo 'failure'

You can place it in your shell profile, for instance.

Alternatively, implement it as a script (add error handling and command-line help as needed):

#!/usr/bin/env bash

mkdir -p "$(dirname "$1")" || exit
touch "$1"

For this purpose, you can create your own function. For example:

$ echo 'mkfile() { mkdir -p "$(dirname "$1")" && touch "$1" ;  }' >> ~/.bashrc
$ source ~/.bashrc
$ mkfile ./fldr1/fldr2/file.txt

Explanation:

• Insert the function to the end of ~/.bashrc file using the echo command
• The -p flag is for creating the nested folders, such as fldr2
• Update the ~/.bashrc file with the source command
• Use the mkfile function to create the file

mkdir -p parent/child && touch "$_"/file.txt

From the BASH man page under Shell Variables:

_ … expands to the last argument to the previous simple command executed in the foreground, after expansion.