The Command Line Crash Course

I think there are several valid definitions for "advanced" in this context. While basic awk/sed knowledge is certainly useful -- if you can do the same thing in python/ruby/perl that might be fine.

Knowing a little bit about writing valid ksh/bash shell scripts (being at least aware of bash-isms) would certainly be useful for sys adm work.

My opinion is that the full gnu (and/or bsd) userland has grown so large over the years, that saying that you should know it all is probably overkill -- but knowing how to look things up (man, info) is a must.

As Zed's implied -- GNU documentation could stand to be improved vs bsd man pages -- although the info manuals can be quite useful.

After these commands I don't think learning a ton of more commands makes you better at working a computer. After this, sitting down to actually setup a working Unix box and then hardening it will teach you a crazy number of commands and things. More importantly it'll teach what all those little processes and services do on the computer.

However, I will say that learning how to effectively use grep and sed are probably the only big omissions from my list. But, those are outside the scope of this little book given those commands have whole books devoted to them.

Shloka:

http://en.wikipedia.org/wiki/Shloka

Well, if you "want" that, you could also have a look at busybox -- which does cp,ls,mv and more -- in a single binary (optionally statically linked).

I actually tend to do a switch on the first argument for certain shell scripts, such as this little thing for switching between single display on a couple of laptops/netbooks:

    #!/usr/bin/env sh
    INTERNAL=LVDS
    EXTERNAL=VGA-0

    for monitor in `xrandr|grep connected|awk '{ print $1 }'`
    do
      case "${monitor}" in
        "LVDS")
          INTERNAL="LVDS"
          ;;
        "DFP1")
          EXTERNAL="DFP1"
          ;;
        "CRT1")
          EXTERNAL="CRT1"
          ;;
        "VGA-0")
          EXTERNAL="VGA-0"
          ;;
      esac
    done

    twoscreen()
    { 
      xrandr --output ${EXTERNAL} --auto --rotate normal --pos 0x0 \
             --output ${INTERNAL} --auto --rotate normal --pos 768x1152
    }

    vgaonly()
    { 
      xrandr --output ${EXTERNAL} --auto --rotate normal --pos 0x0 \
             --output ${INTERNAL} --off
    }

    laptoponly()
    { 
      xrandr --output ${INTERNAL} --auto --rotate normal --pos 0x0 --output ${EXTERNAL} --off
    }

    fn=`basename "$0"`

    case $fn in
      "twoscreens")
        twoscreen
      ;;
      "onescreen")
        laptoponly
      ;;
      "vgaonly")
        vgaonly
      ;;
      *)
        echo "Usage: vgaonly|onescreen|twoscreen"
        echo "called as: $0 ($fn)"
      ;;
    esac
         

As a side note, for those running Debian (or Ubunut, I think) there's a couple of utilities to help search for binaries/files -- namely apt-file and dlocate. Eg:

    apt-file search -F bin/cp #returns coreutils
    # -F does a fixed string search, otherwise you'll
    # get a list of all packages which contains files
    # that *contain* bin/cp in their name such as:
    #   passwd: /usr/sbin/cpgr

Dlocate works with regular expressions and an index, so it's much faster and you can do:

    $ dlocate bin/cp\$
    coreutils: /bin/cp

    pushd /var/log
    pushd  /etc/ssh
    pushd /home/samstave/Downloads

    popd;
    !! (takes me back to /var/log/)

You could alias cd to pushd and cd- to popd...

I use pushd/popd/dirs for multiples. I have aliases like p1 for "pushd +1" and so on.

cf. pushd and popd

You could have scripted it faster than doing that comment ...

Or, you could just

    bash$ mkdir -p /some/dir/to/make
    bash$ cd !$

Bang (!) is a history lookup with lots of variation in use. It probably works in other *nix shells too.

Look under "event designators" in "man bash" for more info.

function take_dir { mkdir -p "$1"; cd "$1" ; }; alias take="take_dir"

I typically use:

    $ mkdir foo
    $ cd !$

Not quite what you're asking for but it can certainly save some keystrokes -- especially if you're doing something like:

    $ mkdir -p foo/bar/baz/whatever

I use the version at http://onethingwell.org/post/586977440/mkcd-improved, called `mkcd`.

  # mkdir, cd into it
  mkcd () {
      mkdir -p "$*"
      cd "$*"
  }

Just copy and paste that at the end of your `.bashrc` or `.zshrc` file. You may also want to include this comment above it so you know why it’s written like that:

  # from http://onethingwell.org/post/586977440/mkcd-improved

$_ in bash means the last argument of the previous command. So:

mkdir some/long/path/to/a/dir cd $_

mv foo some/long/path/bar cd $_

both work for what you want, and the extra keystrokes are so few that it hardly matters. The $_ is not specific to those two commands, so works for others as well, and is typically very useful because command sequences often tend to need the last argument of the previous command in the next command; un-tar-ing a .tar file and then going to the extracted directory is another example.

I'm on my phone at the moment, but I did something similar except avoided the counting. I have a shell function called `ct` for "climb tree" where you specify the name of the directory you want to climb to; calling it will place you in the first directory above cwd whose name matches the argument and in addition I wrote a bash completion module for it so I only have to type minimal characters. I'll post the source for both shortly.

I like this concept. My solution has been to use '..' '...' and '....' to go up 1,2,and 3 directories.

Your function called "up" reminds me of long-ago-used Novell Netware version, in which, IIRC, you could do:

cd .. # to go one level up

cd ... # to go two levels up (note: 3 dots, not 4, makes sense when you think of "cd ." and "cd ..")

# and so on.