Printing only the file name after searching a pattern in the first line (using grep and head)

Question

So I'm a beginner and i have a project due next week. I have to print only the filename of the files that contain #!/bin/bash on the first line. So far I tried this

head -n 1 $filename | grep -l "pattern"

but when I execute it instead of the name of the files I receive

(standard input)

Like I said, I'm a beginner and so far I'm familiar with simple commands. So I would like to know where I f****** up and if there is a way of acheiving what I want without using harder commands like awk.

for fis in  find -perm -a+x -name "*.sh" -type f
do
head -n 1 $fis | grep -l "#!/bin/bash"
done

Answer 1

In GNU grep you can use the --label option to set the label/filename if the input comes from stdin.

Instead of using an outer loop with a command substitution, you could use the -exec action to start a small script to loop over the filenames and execute the commands.

find -perm -a+x -name "*.sh" -type f -exec sh -c '
  for fis; do
    head -n1 "$fis" | grep --label="$fis" -Fl "#!/bin/bash"
  done
' sh {} +

I added the -F option to grep since we're looking for a fixed string.

Answer 2

I know you have blacklisted awk, but for other people seeking help who come across your question, this is a quite efficient way to print the names of the executable .sh files that contain #!/bin/bash in their first line:

find . -perm -a+x -name '*.sh' -type f -exec \
    awk 'NR == 1{ if ($0 == "#!/bin/bash") print FILENAME; exit }' {} \;

Or, to print the name of files that have #!/bin/bash in their first line without further restrictions, drop the -perm and -name options:

find . -type f -exec awk ...

Answer 3

find . -perm -a+x -name '*.sh' -type f |
    while IFS= read -r file; do
        test -f "$file" || continue
        if head -n 1 "$file" | grep -qFx '#!/bin/bash'; then
            echo "$file"
        fi
    done

Answer 4

with -n and passing multiple files the output will be in this format:

file_name:line_number:matched_text

-x matches the whole line

grep '#!/bin/bash' -nx *.sh |cut -d ':' -f 1,2 | grep ":1$" | cut -d ':' -f 1

Answer 5

I realise this is very late to the party, but I've been doing exactly the same thing, and have had good results with this:

find . -perm -a+x -name "*.sh" -exec \
    bash -c 'grep -q "pattern" < <(head -n 1 "$1")' _ {} \; -printf '%p\n'

As understand it, the -q flag prevents writing to standard output, allowing you to print the filename (%p from find -printf).

Answer 6

In zsh:

set -o extendedglob
zmodload zsh/system
bash_shebang_pattern=$'\\#! #(/usr/bin/env ##|(/usr(/local|)|/opt/gnu|)/bin/)bash[ \n]*'
improperly_named_bash_scripts=(
  **/*.sh(ND.L+11f[a+x]e['
    sysread -s80 shebang < $REPLY &&
      [[ $shebang = $~bash_shebang_pattern ]]
  '])
)
print -rl -- "These executable files have a .sh extension even though they're bash scripts:" $improperly_named_bash_scripts

That's widening a bit the possibilities of bash shebang, but note that possibilities are infinite if you want to consider BSD/GNU's env -S like:

#! /usr/bin/env --split-str=-u\_BASH_ENV\_-u\_ENV\_-u\_POSIXLY_CORRECT\_-u\_LC_ALL\_PATH=/opt/gnu/bin:${PATH}\_LC_CTYPE=C\_LC_COLLATE=C\_bash\_-o\_errexit\_-o\_nounset\_-o\_pipefail\_--

Which some might prefer over:

#! /bin/bash -

(let alone #!/bin/bash which strictly speaking is incorrect) to sanitize the environment a bit.

Details:

• **/ any level of subdirectories.
• *.sh files whose name ends in .sh (note: that includes the hidden file whose name is .sh).
• (ND.L+11f[a+x]e['code']): glob qualifiers:
  • N: nullglob
  • D: dotglob (include hidden files)
  • .: regular files only (no directory, symlink, fifo, device...)
  • L+11: Length greater than 11 bytes (the size of #!/bin/bash)
  • f[a+x]: for which the permissions include x for all.
  • e['code']: runs the code to decide whether the file (in $REPLY) should be selected.
• sysread -s80 only read the first 80 bytes. Should be enough even for a #! /usr/bin/env bash one. Not one line, as those could be huge for binary files which are not guaranteed to contain newline characters.