How can I/Should I default flags when running a command?

Question

For context, I'm using zsh. Every time I use locate, I want to pass the -i and -A flags.

Usually, if I can get away with it, I create an alias with the same name as the existing command to do this. But according to this question, aliases can't accept arguments, so I have to use a function instead. Usually I stop there because the idea of a function with the same name as a command feels wrong to me, though I can't say why.

I was about to finally create such a function when I had this thought: this is a common pattern for me, wanting to default flags for command; is there an easier way of going about it? Perhaps zsh provides a better solution to this problem?

That brought me to another thought: is it an anti-pattern to override an existing command? I've always done it because it allows me to skip an association in my head: e.g., "Why doesn't ll have a man page? Oh yeah: ll really means ls -la. I need to do man ls, not man ll. Etc."

To summarize:

1. Is it alright/idiomatic to override an existing command with an alias/function?
2. Does zsh or some other tool provide a more direct way to default flags for a specific command?

Answer 1

I am really surprised by that other post you mentioned, as it can be very misleading. Just because an alias doesn't use parameters doesn't mean that aliases cannot set parameters. Of course you can put options in an alias, but it is just restricted, meaning, the alias is replaced in one place.

$ alias ls='ls -l'
$ ls 
# will run: ls -l
$ ls foo
# will run: ls -l foo

The problem that other question poses is if you want to add options to a alias that has a argument.

so if you had an alias:

$ alias movetotrash='mv  ~/Trash'
# no way to use inject anything inside 'mv' and '~/Trash'

So in your case

$ alias locate='locate -i -A'
# will expand to 'locate -i -A' and then whatever else you type.

As for your specific questions:

It is quite common for linux distributions to ship with default "options" via aliases, for example, ls frequently has a alias ls 'ls --color=auto' or for root login you might see alias mv 'mv -i'. So it can be considered a standard way of providing better defaults to users and uses the same name of the underlying binary. If a user doesn't want to use an alias and it is set in the standard environment, they can use unalias to unset the alias permanently, or when running a command using a backslash, such as \mv a b will prevent alias expansion for that execution (as does using the full path, like /usr/bin/mv a b)

I don't believe that zsh provides any extra capabilities in this area, and certainly nothing that would be a "standard". People often write wrapper shell scripts and sometimes shell functions. But for trivial software, alias is often the solution people use. If the program is complicated enough, it will usually gain an rc file for common user preferences.

I think one tool that tried to make options a bit easier was the popt library, which allowed users to create their own options to software, but the popt library isn't widely used, and I don't think it had the ability to set the default.

Answer 2

Aliases that use the same name are almost the entire point of aliases.

An alias definition provides a string value that shall replace a command name when it is encountered

alias grep='grep --ignore-case --color=auto' works perfectly as a drop in replacement for grep.

Creating a function or a ~/bin/ script to replace a command will need you to reference the command directly.

function grep {
    grep --ignore-case --color=auto "${@}"
}

or

~/bin/grep:

grep --ignore-case --color=auto "${@}"

...will lock up in a recursive loop where the function or script calls itself endlessly while...

function grep {
    /bin/grep --ignore-case --color=auto "${@}"
}

or

~/bin/grep:

/bin/grep --ignore-case --color=auto "${@}"

...will not die the recursive death because they don't call themselves.

The only issue with aliases is that you can't insert arguments internally between 'default' arguments. You can with function and scripts...

function grep {
    /bin/grep ${1} --ignore-case --color=auto ${2} 
}

or

~/bin/grep:

/bin/grep ${1} --ignore-case --color=auto ${2}

...but it would get messy fast if you try to use the new version of the command expecting normal argument sequences.