Hacker News Reader

Comment by chasil | Hacker News Reader

Bash actually has more warts than competing shells because of its historic stance.

My bugbear is that "alias p=printf" works well in any POSIX shell script, including bash when it is invoked as #!/bin/sh - but when called as #!/bin/bash, the alias (used in a script) fails with an error.

While the Korn shell managed to evolve and comply with the POSIX standard, bash decided to split the personality, so one solution to the above alias failure is to toggle POSIX mode.

Bash was forced to do this, to keep a decade of shell scrips that were written for it working. Pity.

The standard for the POSIX shell looked very hard at Korn, and credits it. Bash is not mentioned.

View on HN

Huh, why wouldn't that alias work?

Good question. Something to do with interactive mode?

  $ cat l.sh
  alias l=ls
  l
  $ sh l.sh
  file1  file2  l.sh
  $ bash l.sh
  l.sh: line 2: l: command not found
  $ bash -i l.sh
  file1  file2  l.sh

Edit: Ah yes, the man page says so.

> Aliases are not expanded when the shell is not interactive, unless the expand_aliases shell option is set using shopt

Thanks, I had no idea. I guess I've never used aliases in scripts, but I would've assumed that they'd just work the same as in interactive mode. Good to know.

Why use an alias in a script? Or in general? Functions work everywhere.

I suppose aliases predated functions. Can't find a reference to support that, though. Just a possible reason.

BTW aliases come from csh, and there they support arguments, which makes them similar to functions.

Aliases are like C macros

    $ alias foo='seq 3 | '
    $ foo cat
    1
    2
    3

Functions are functions

So then use $variables for evil syntactic tricks? That works everywhere. Functions where hygiene counts? Aliases never?

>use $variables for evil syntactic tricks

Can't do that without eval, which is another can of worms. Aliases are fine

Functions don't work everywhere. Bash functions only work in the current shell context unless exported via an `export -f myfun' statement in between the function declaration and downstream sub-shell usage.

Working example:

  pzoppin() {
      printf 'echo is for torrent scene n00bs from %s\n' "$*"
      trap "printf '%s\n' <<< \"$*\"" RETURN EXIT SIGINT SIGTERM
  }
  export -f pzoppin

  echo -e 'irc\0mamas donuts\0starseeds' \
      | xargs -0 -n 1 -I {} /usr/bin/env bash -c '
  echo hi
  pzoppin "$*"
  echo byee
  ' _ {}

The above will fail miserably without the magic incantation:

  `export -f pzoppin'

Why'd they design an otherwise perfectly usable, mapless language without default c-style global functions? :)

Indeed, here are two lines atop my "util.sh" to regularize some strange non-conformant behaviours:

  [ "${BASH:-}" ] && shopt -s expand_aliases
  [ "${ZSH_VERSION:-}" ] && setopt SH_WORD_SPLIT

I typically just give up on weird corners of shell when I find an working version of the same.

For instance -- why would you use "alias" when you can make a function? The syntax is a little weird with functions, but it's a lot more clear what's going on.

The same goes for "test" vs the seeming magic of [ where it seems like [ is language syntax (it's a single character!) when in fact ... it's just another executable that communicates with logic evaluation like anything else (like grep or false).

There are many reasons.

1. Aliases can work with the callee scope.

    alias MY_VAR_MODIFIER='local foo=bar'

    MY_VAR_MODIFIER () { local foo=bar; }

Calling the alias by the name will set the callee's variable foo, while calling the function does nothing (local foo is local to the function and never leaves scope).

It also works similarly for working with the set ($@). You can do `set --` stuff and it works on the scope of the callee.]

Aliases on most shells also don't need to be fully valid _before_ expansion. You can alias a compound command:

    alias foreach='for EACH'

    foreach in $MYVAR #perfectly valid for most shells.

Only ksh93 will complain about it, it requires aliases to be complete valid shell programs.

Finally, alias calls don't appear in xtrace (set -x). Only the final expansion will appear.

TL;DR aliases in scripts work a lot like macros.

Reply on news.ycombinator.com