How, on Bash, do we test a name string is an executable, as tried it won't work:
$ [[ -x cp ]] &&echo YES
$
$ [[ -x ls ]] &&echo YES
as tried it hard won't be correct way:
$ >/dev/null type ls && echo YES
YES
$ >/dev/null type -fat && echo YES
YES
This the very falling failure thanks for help before
The question is not quite clear:
The -x test is useful in the second case because it tests whether a given file is executable, i.e., if the executable bit is set.
It requires you to provide a valid file name. Unless you provide a full file path, the current directory is searched. Thus your command will typically fail for e.g. cp, unless you first make the directory of the executable current, i.e. cd /usr/bin.
To retrieve the full file path of an executable, you can use the shell build-in type with the options -P so only a matching executable in the search PATH is retrieved (ignoring aliases, hashed commands and functions). Note that that may not be what is executed on the system by default.
You could also add an action to execute if the test fails. Then your statement becomes:
[[ -x $(type -P cp) ]] && echo YES || echo NO
which can also be written as
test -x $(type -P cp) && echo YES || echo NO
If your question aimed to ask how to test if something is an executable command on your system, just use type:
type ls &>/dev/null && echo YES || echo NO
Type will return an error code if the string does not correspond with something executable, so the second command will not be executed.
You can use the command -v command to test this:
command -v cp >/dev/null 2>&1 && echo "YES"
Will return:
YES
While:
command -v fhdjskfsfs >/dev/null 2>&1 && echo "YES"
Will most likely return nothing (unless you have an executable in path named fhdjskfsfs).
How, on Bash, do we test a name string is an executable?
Your logic with the type shell builtin command should work (excluding shell builtin commands and functions as you seem to want that), if you use it like so:
&>/dev/null type -afPt -- ls && echo yes
... and that would work as long as the provided string argument is not empty or otherwise it will return 0(success) on an empty string ... Therefore, if you are using this in a script and passing names/strings in a variable e.g. var, then you might want to use it like this: ${var:-empty} which if var is empty, then Bash will expand that variable to the word empty ... Double quoting the variable expansion should work as well.
Examples:
$ &>/dev/null type -afPt -- ls && echo yes || echo no
yes
$
$ &>/dev/null type -afPt -- notcommand && echo yes || echo no
no
$
$ &>/dev/null type -afPt -- set && echo yes || echo no
no
$
$ &>/dev/null type -afPt -- ./myscript.sh && echo yes || echo no
yes
$
$ &>/dev/null type -afPt -- echo && echo yes || echo no
yes
Notice: if you are going to discard off all the output, then you might not need all those options as only -P should be enough to exclude both shell builtins and functions because it forces a path search for each word in the passed string and this will exclude those two by default.
If you want to test not only if a command is an executable, but generally what kind of command it is, you can use the following shellscript, which you might give the name what-about and make it executable.
#!/bin/bash
LANG=C
inversvid="\0033[7m"
resetvid="\0033[0m"
if [ $# -ne 1 ]
then
echo "Usage: ${0##*/} <program-name>"
echo "Will try to find corresponding package"
echo "and tell what kind of program it is"
exit 1
fi
command="$1"
str=;for ((i=1;i<=$(tput cols);i++)) do str="-$str";done
tmp="$command"
first=true
curdir="$(pwd)"
tmq=$(which "$command")
tdr="${tmq%/}"
tex="${tmq##/}"
if test -d "$tdr"; then cd "$tdr"; fi
#echo "cwd='$(pwd)' ################# d"
while $first || [ "${tmp:0:1}" == "l" ]
do
first=false
#echo "tmp=$tmp########################################## d 1.0"
tmp=${tmp##->\ }
tmq="$tmp"
#echo "tmp=$tmp########################################## d 1.1"
tmp="$(ls -l "$(which "$tmp")" 2>/dev/null)"
#echo "tmp=$tmp########################################## d 1.2"
tdr="${tmq%/}"
tex="${tmq##*/}"
if test -d "$tdr"; then cd "$tdr"; fi
echo "cwd='$(pwd)' ################# d"
if [ "$tmp" == "" ]
then
tmp=$(ls -l "$tex" 2>/dev/null)
#echo "tmp=$tmp########################################## d 2.1"
tmp=${tmp##*\ }
#echo "tmp=$tmp########################################## d 2.2"
if [ "$tmp" == "" ]
then
echo "$command is not in PATH"
package=$(bash -ic "$command -v 2>&1")
echo "package=$package XXXXX 0"
bash -ic "alias '$command' > /dev/null 2>&1" > /dev/null 2>&1
if [ $? -ne 0 ]
then
echo 'looking for package ...'
package=$(bash -ic "$command -v 2>&1"| sed -e '0,/with:/d'| grep -v '^$')
else
echo 'alias, hence not looking for package'
fi
echo "package=$package XXXXX 1"
if [ "$package" != "" ]
then
echo "$str"
echo "package: [to get command '$1']"
echo -e "${inversvid}${package}${resetvid}"
fi
else
echo "$tmp"
fi
else
echo "$tmp"
fi
done
tmp=${tmp##*\ }
if [ "$tmp" != "" ]
then
echo "$str"
program="$tex"
program="$(pwd)/$tex"
file "$program"
if [ "$program" == "/usr/bin/snap" ]
then
echo "$str"
echo "/usr/bin/snap run $command # run $command "
sprog=$(find /snap/"$command" -type f -iname "$command"
-exec file {} ; 2>/dev/null | sort | tail -n1)
echo -e "${inversvid}file: $sprog$resetvid"
echo "/usr/bin/snap list $command # list $command"
slist="$(/usr/bin/snap list "$command")"
echo -e "${inversvid}$slist$resetvid"
else
package=$(dpkg -S "$program")
if [ "$package" == "" ]
then
package=$(dpkg -S "$tex" | grep -e " /bin/$tex$" -e " /sbin/$tex$")
if [ "$package" != "" ]
then
ls -l /bin /sbin
fi
fi
if [ "$package" != "" ]
then
echo "$str"
echo " package: /path/program [for command '$1']"
echo -e "${inversvid} $package ${resetvid}"
fi
fi
fi
echo "$str"
alias=$(bash -ic "alias '$command' 2>/dev/null"| grep "$command")
if [ "$alias" != "" ]
then
echo "$alias"
else
type=$(bash -ic "type "$command" 2>/dev/null")
if [ "$type" != "" ]
then
echo "type: $type"
elif [ "$alias" == "" ]
then
echo "type: $command: not found"
fi
fi
cd "$curdir"
