Ich weiß, dass einige Leute Startskripte haben und einige Leute die Eingabeaufforderung personalisieren. Ein Entwickler verwendet kurze Aliase für den langen Pfad, den er häufig besucht, und die häufigen Befehle, die er ausführt.

Welche effektiven Anpassungen haben Sie an Ihrem UNIX-Profil vorgenommen, um die Produktivität zu steigern und die Bedienung zu vereinfachen?

.vimrc

cmap w!! w !sudo tee % > /dev/null

alias grep='grep --color=auto --binary-files=without-match --devices=skip'

alias webshare='curl -F "sprunge=<-" http://sprunge.us | xclip'

Es gibt eine kurze URL in Ihrer Zwischenablage zurück; Sie können an die zurückgegebene URL anhängen, ?whatever-langum die Syntax hervorzuheben und die Zeilen zu nummerieren.

.inputrc

set editing-mode vi
set keymap vi

Erstellen Sie ein Verzeichnis und eine CD in einem Befehl

Meistens mkdirist mein nächster Befehl cd <that dir>.

Dies erspart einige Eingaben:

# make a directory and cd to it
mcd()
{
    test -d "$1" || mkdir "$1" && cd "$1"
}

beispielsweise:

/home/mikel$ mcd somedir
/home/mikel/somedir$ 

Eine andere Sache, die ich nützlich finde, ist eine einfache Möglichkeit, ein Wegwerfverzeichnis zu erstellen. zB wenn ich ein Programm kompiliere oder sogar versuche, ein Problem auf dieser Seite zu reproduzieren. Manchmal vergesse ich vielleicht, das Verzeichnis aufzuräumen.

# make a temporary directory and cd to it
mtd()
{
    local dir
    dir=$(mktemp -d)
    if test -n "$dir"
    then
        if test -d "$dir"
        then
            echo "$dir"
            cd "$dir"
        else
            echo "mktemp directory $dir does not exist"
        fi
    else
        echo "mktemp didn't work"
    fi
}

es funktioniert zeigen:

/home/mikel$ mtd
/tmp/tmp.wsnZjJ2KN6
/tmp/tmp.wsnZjJ2KN6$ 

Ich verlasse mich darauf, dass das System /tmpnach einem Neustart bereinigt, aber es wäre möglich, dies zu verbessern, z. B. das temporäre Verzeichnis nach dem Beenden der Shell zu löschen.

Ich möchte, dass meine Bash-Eingabeaufforderung den Exit-Code des vorherigen Befehls anzeigt, wenn er nicht Null ist. Ich mag es auch, wenn meine Muschel mich aufheitert, wenn ich sie benutze, also fügte ich ein bisschen Albernheit hinzu:

smiley() {
    RC=$?
    [[ ${RC} == 0 ]] && echo ':)' || echo ":( ${RC}"
}

export PS1="\$(smiley) \h [\A] [\W] \$ "

Wenn ich also Befehle ausführe, erhalte ich ein nettes visuelles Feedback:

:) mycomputer [23:03] [~] $ sh -c 'exit 0'
:) mycomputer [23:03] [~] $ sh -c 'exit 11'
:( 11 mycomputer [23:03] [~] $ 

edit : das ist etwas, was ich in mein ~ / .bashrc geschrieben habe

bis N

N Verzeichnisse im Verzeichnisbaum nach oben springen

Anstatt zu tippen

cd ../../../..

du tippst einfach

up 4

und ein

cd -    

bringt dich zurück

Fügen Sie die Funktion in Ihr .bashrc ein, um sie zu verwenden.

# (c) 2007 stefan w. GPLv3          
function up {
ups=""
for i in $(seq 1 $1)
do
        ups=$ups"../"
done
cd $ups
}

.zshrc:

alias l='ls -CF'
alias ll='ls -ClhF'
alias la='ls -CaF'
alias lla='ls -CalhF'
alias l.='ls -CAF --ignore=\*'
alias ll.='ls -CAlhF --ignore=\*'
alias t='tree -C'

PS1=$'%{\e[0;33m%}%m %{\e[32;1m%}%~ %{\e[0;31m%}%#%{\e[m%} '

bindkey '^[[3~' delete-char

export GREP_OPTIONS="--color"

.xmodmaprc:

clear lock
keycode 9 = Caps_Lock ISO_Next_Group Caps_Lock ISO_Next_Group
keycode 66 = Escape NoSymbol Escape
add lock = Caps_Lock

(Vertauscht die Escape- und die Feststelltaste).

Ich vermassle meinen bashrc, da ich das Terminal oft benutze (dadurch lerne ich schnell und lerne interessante Dinge sowie interessante Werkzeuge). Normalerweise definiere ich viele Funktionen in meinem bashrc. Beispiele:

Archive extrahieren:

extract () {
libextract () {
if [ -f "$1" ] ; then
  case "$1" in
    *.tar.bz2) tar xjf "$1" ;;
    *.tar.gz)  tar xzf "$1" ;;
    *.bz2) bunzip2 "$1" ;;
    *.rar) rar x "$1" ;;
    *.gz) gunzip "$1" ;;
    *.tar) tar xf "$1" ;;
    *.tbz2) tar xjf "$1" ;;
    *.tgz) tar xzf "$1" ;;
    *.zip) unzip "$1" ;;
    *.Z) uncompress "$1" ;;
    *.7z) 7z x "$1" ;;
    *) echo "$1 ne moze biti raspakovan!" ;;
  esac
else
  echo "$1 nije validan fajl"
fi
}
 echo "Unesite putanju do direktorijuma u kome se nalaze arhive: " && read dir && dirprovera && cd $dir
  for f in *
    do
      mkdir ./$f-raspakovano && cd ./$f-raspakovano
      libextract ./../$f
      cd ./../
    done
  tipka
}

Dateien und Ordner umbenennen:

frename () {
if [ $# -gt 0 ]
then
 dir="$(echo $1)"
  dirprovera
  cd $dir
  for f in *
    do
      mv "$f" "`echo "$f" | tr -s " " "_" | tr "A-Z" "a-z"`" 2>/dev/null &
    done
  tipka
else
 echo "Upotreba: frename [direktorijum]" >&2
fi
}

und so zum Teilen großer Dateien in mehrere kleine:

fsplit () {
if [ $# -gt 1 ]
then
 file="$(echo $1)"
 SIZE="$(echo $2)"
 PREFIX="$(echo $3)"
 if [ -z "$PREFIX" ]; then PREFIX="fsplit"; fi
  fileprovera
  split -d -a 3 -b $SIZE $file "$PREFIX-part-" || echo "Doslo je do greske!"
  tipka
else
 echo "Upotreba: fsplit [fajl] [velicina] [prefix]
Za velicinu se koriste m (MB), g (GB) ili k (KB) (15m, 650kb, 4.7g...)

Prefiks moze sadrzati brojeve, slova, i crtice (primer: moj_pre-fiks)
Ukoliko ne unesete prefiks isti ce biti dodeljen automatski u sledecem formatu:
  fsplit-part-XXX
gde XXX predstavlja broj dela fajla (001, 005, 189...)" >&2
fi
}

Außerdem habe ich viele Aliase editiert, da ich finde, dass es in manchen Fällen viel einfacher ist, einen Befehl mit Argumenten als Standard zu verwenden (wie in ls, grep und kleinen Befehlen), als all das jedes Mal einzugeben.

(Community-Wiki, daher gehört jeder Trick in eine separate Antwort.)

Sichere Abmeldung

Ctrl+ Dist die einfachste Möglichkeit, die Shell zu beenden. Wenn jedoch noch Jobs ausgeführt werden, wird die Shell trotzdem problemlos beendet. Standardmäßig bedeutet dies, dass alle Programme, die Sie in dieser Shell ausgeführt haben, beendet werden.

Bei einigen Shells können Sie sich erst nach zweimaligem Drücken von Ctrl+ Dabmelden, aber es ist immer noch zu einfach, dies versehentlich zu tun.

Fügen Sie dies stattdessen zu .bashrcoder zu der von .zshrcIhnen bevorzugten Konfigurationsdatei hinzu.

alias x='_exit'

# prevent running "exit" if the user is still running jobs in the background
# the user is expected to close the jobs or disown them
_exit()
{
    case $- in *m*)
        # this way works in bash and zsh
        jobs | wc -l | grep -q '^ *0 *$'
        if test $? -eq 0
        then
            command exit "$@"
        else
            jobs
        fi
        ;;
    *)
        command exit "$@"
        ;;
    esac
}

(Community-Wiki, daher gehört jeder Trick in eine separate Antwort.)

Durchsuchen Sie Ihren Verlauf nach allen Methoden, mit denen Sie einen Befehl ausgeführt haben

Sie wissen vielleicht bereits über Ctrl+ R, aber dieser Weg ist meiner Meinung nach viel reibungsloser.

Richten Sie Alt+ ein P, um im Verlauf nach Befehlen zu suchen, die mit dem beginnen, was Sie bereits eingegeben haben.

zB ls Alt+ P, Alt+ P, Alt+P durchsucht alle lsBefehle rückwärts .

Sie müssen dies in Ihre /etc/inputrcoder .inputrcfür bash:

$if mode=emacs
"\ep": history-search-backward
"\en": history-search-forward
$endif

und das in deinem .zshrcfür zsh:

bindkey -M emacs '^[p' history-beginning-search-backward
bindkey -M emacs '^[n' history-beginning-search-forward

Sie können sogar noch einen Schritt weiter gehen und den Aufwärtspfeil dazu bringen.

einfacher Rechner

Sie können $(( ... ))oder verwenden expr ..., um sehr einfache Berechnungen durchzuführen, aber es wird eine Ganzzahldivision durchgeführt, z

$ expr 3 / 2
1

$ expr 1.5 \* 2
expr: non-integer argument

Ein besserer Weg ist zu verwenden bc.

# do some floating point arithmetic
calc()
{
    echo "scale=3; $*" | bc
}

dann:

$ calc 3 / 2
1.500
$ calc 1.5 \* 2
3.0

bessere Tab-Vervollständigung

Ich glaube nicht, dass jemand Customizing erwähnt hat Tab Fertigstellung des .

Hier ist was ich habe.

Die beiden wichtigsten Dinge, die es tut, sind:

• jeder Befehl Registerkarte vollständige je nachdem , was der Befehl erwartet
  zBcd <Tab> werden nur Verzeichnisse vorgeschlagen
• Groß- / Kleinschreibung ignorieren
  zB d<Tab>wird noch erledigt DesktopundDownloads

Für die Bash:

# custom tab completions
if type complete >/dev/null 2>&1
then
    if complete -o >/dev/null 2>&1
    then
        COMPDEF="-o complete"
    else
        COMPDEF="-o default"
    fi
    complete -a alias unalias
    complete -d cd pushd popd pd po
    complete $COMPDEF -g chgrp 2>/dev/null
    complete $COMPDEF -u chown
    complete -j fg
    complete -j kill
    complete $COMPDEF -c command
    complete $COMPDEF -c exec
    complete $COMPDEF -c man
    complete -e printenv
    complete -G "*.java" javac
    complete -F complete_runner -o nospace -o default nohup 2>/dev/null
    complete -F complete_runner -o nospace -o default sudo 2>/dev/null
    complete -F complete_services service
    # completion function for commands such as sudo that take a
    # command as the first argument but should complete the second
    # argument as if it was the first
    complete_runner()
    {
        # completing the command name
        # $1 = sudo
        # $3 = sudo
        # $2 = partial command (or complete command but no space was typed)
        if test "$1" = "$3"
        then
            set -- `compgen -c "$2"`
        # completing other arguments
        else
            # $1 = sudo
            # $3 = command after sudo (i.e. second word)
            # $2 = arguments to command
            # use the custom completion as printed by complete -p,
            # fall back to filename/bashdefault
            local comps
            comps=`complete -p "$3" 2>/dev/null`
            # "complete -o default -c man" => "-o default -c"
            # "" => "-o bashdefault -f"
            comps=${comps#complete }
            comps=${comps% *}
            comps=${comps:--o bashdefault -f}
            set -- `compgen $comps "$2"`
        fi
        COMPREPLY=("$@")
    }

    # completion function for Red Hat service command
    complete_services()
    {
        OIFS="$IFS"
        IFS='
        '
        local i=0
        for file in $(find /etc/init.d/ -type f -name "$2*" -perm -u+rx)
        do
            file=${file##*/}
            COMPREPLY[$i]=$file
            i=$(($i + 1))
        done
        IFS="$OIFS"
    }
fi

Für zsh:

# set command completions
compctl -a {,un}alias
compctl -b bindkey
compctl -c command
compctl -/ {c,push,pop}d
compctl -E {print,set,unset}env
#compctl -c exec
compctl -f -x "c[-1,exec]" -c -- exec
compctl -j fg
# no -g according to zshcompctl
#compctl -g {ch}grp
compctl -j kill
compctl -c man
compctl -c nohup
compctl -u {ch}own
compctl -o {set,unset}opt
compctl -f -x "c[-1,sudo]" -c -- sudo
compctl -c {whence,where,which}
compctl -M '' 'm:{a-zA-Z}={A-Za-z}'

# make file name completion case-insensitive
zstyle ':completion:*' matcher-list '' 'm:{a-zA-Z}={A-Za-z}'

Sichere Komprimierung

Komprimierungsprogramme löschen standardmäßig die Originaldatei. Das gefällt mir nicht

alias gzip='gzip --keep'
alias bzip2='bzip2 --keep'
alias xz='xz --keep'
alias lzma='lzma --keep'

Mehrzeilige Abfrage

tag() {
    TAG="${TAG} [$1]" exec zsh
}

reset_tags() {
    TAG='' exec zsh
}

color='green'
if [ "${USER}" = 'root' ]; then
    color='red'
fi

export PS1="${TAG} %B%F{yellow} *** %F{blue}%~\

%F{yellow}%(1j.[%j] .)%F{red}%(?..(%?%) )%F{${color}}%n@%m %F{blue}%# %f%b"
export RPS1='%B%F{blue}%D{%Y-%m-%d} %F{green}%D{%H:%M:%S}'
export PS2='%B%F{red}%n@%m%k %B%F{blue}%_> %b%f%k'
unset color

• Zeigt das aktuelle Verzeichnis in einer separaten Zeile an. Nützlich bei der Verarbeitung eines tiefen Verzeichnisbaums auf einem Terminal mit 80 Spalten.
• Wenn Sie eine grafische Umgebung verwenden, ist es eine großartige Sache, eine Uhr in der Ecke zu haben. Diese Eingabeaufforderung zeigt die Uhrzeit an. Leider müssen Sie die Eingabetaste drücken, um es zu aktualisieren.

• Sie können "Tags" mit Umgebungsvariablen anzeigen. Beispiel:

  tag 'DONT SHTUDOWN!!'
  reset_tags

• Der Code ist zumindest auf teilweise auf Basis dieses .

Verlaufseinstellungen

dont_log() {
    HISTFILE="/dev/null" TAG="${TAG} %B%F{red}[LOGGING DISABLED]" zsh
}

if [ "${HISTFILE}" != '/dev/null' ]; then
    # history
    export HISTFILE="${HOME}/.zsh/history"
    export HISTSIZE="4096"
    export SAVEHIST="4096"

    # Don't overwrite, append!
    setopt APPEND_HISTORY

    # Write after each command
    # setopt INC_APPEND_HISTORY

    # Killer: share history between multiple shells
    setopt SHARE_HISTORY

    # If I type cd and then cd again, only save the last one
    setopt HIST_IGNORE_DUPS

    # Even if there are commands inbetween commands that are the same, still only save the last one
    setopt HIST_IGNORE_ALL_DUPS

    # Pretty    Obvious.  Right?
    setopt HIST_REDUCE_BLANKS

    # If a line starts with a space, don't save it.
    setopt HIST_IGNORE_SPACE
    setopt HIST_NO_STORE

    # When using a hist thing, make a newline show the change before executing it.
    setopt HIST_VERIFY

    # Save the time and how long a command ran
    setopt EXTENDED_HISTORY

    setopt HIST_SAVE_NO_DUPS
    setopt HIST_EXPIRE_DUPS_FIRST
    setopt HIST_FIND_NO_DUPS
fi

• Schamlos von hier gestohlen .
• Ich habe die Unterstützung für das explizite Deaktivieren der Protokollierung hinzugefügt. Nützlich, wenn Sie mit Programmen arbeiten, die Kennwörter als CLI-Argument erwarten.

• bashrc : Ich bin ein zsh-Benutzer, daher habe ich ein paar Zeilen in meinem bashrc, die zsh starten, wenn es auf einem System verfügbar ist.
• zshrc : Anstatt mein zshrc von so etwas wie grml zu kopieren (obwohl zshrc ziemlich gut ist, also wenn du dein eigenes nicht rollen willst, ist es wahrscheinlich eines der besten), schreibe ich mein eigenes zshrc.
  • Ich habe eine benutzerdefinierte Eingabeaufforderung. Unter anderem wird der Rückkehrcode des letzten Befehls angezeigt, wenn dieser ungleich 0 war.
  • Ich habe einige Aliase. Da ich Konten auf einer ganzen Reihe von Servern habe, muss ich manchmal überprüfen, welche Version eines Befehls auf einem System verfügbar ist, und den Alias ​​entsprechend festlegen.
  • Ich habe meine PATH-Variable gesetzt.
  • Ich habe einige andere Umgebungsvariablen gesetzt (zum Beispiel $ EDITOR)
• vimrc : Ich bin ein vim-Benutzer, daher habe ich ein benutzerdefiniertes und ein benutzerdefiniertes Farbschema.
• screenrc : Ich verwende den GNU-Bildschirm, um zu vermeiden, dass mehrere Terminals geöffnet werden müssen, und um den Verlauf beizubehalten, wenn ich nicht angemeldet bin. Daher habe ich meinen eigenen screenrc.

Wenn Sie die Rechtschreibkorrektur für Autovervollständigen und Dateinamen einschalten können! Das sind wahrscheinlich die beiden Dinge, die Ihnen die meiste Zeit ersparen. Dann lerne sie zu benutzen - Bash und Zsh haben Tab-Vervollständigung. Ksh hat einen ineffizienten Escape-Backslash, daher würde ich Ksh empfehlen.

Ich benutze Zsh, aber Aliase wie dieses funktionieren in fast jeder Shell außer Csh:

alias l='ls -FC --color=tty'
alias ls='ls -FC --color=tty'
alias h=history
alias m=more
alias vi=vim
alias cx='chmod +x'

Es scheint, als ob ein Alias ​​für "ps" vorhanden sein sollte, aber ich benutze "ps" auf vielfältige Weise, und ich habe bisher nichts gefunden.

Richten Sie in Zsh Ihre Variable RPROMPT (kein Tippfehler!) Ein:

RPROMPT='%d'

Das gesamte Verzeichnis wird rechts angezeigt Seite der Befehlszeile und kann nun zum Ausschneiden und Einfügen verwendet werden. Dazu später mehr.

Sie sollten ein ordnungsgemäß kompiliertes modernes Vim verwenden, da mehrere Vim-Fenster in einer Datei und mehrere Puffer vorhanden sein können. In Ihrer .vimrc-Datei könnte Folgendes enthalten sein:

set mouse=c
set ml
set mls=5
set nowrap
set nobackup
set nonu
set showmatch
set tabstop=4
set shiftwidth=4
set showmode
set showcmd
set ruler
set notextauto
set laststatus=2
set mps=(:),{:},[:],<:>
set modelines=0

Viele davon sind persönliche Vorlieben, aber ich glaube, dass 8-stellige Tabulatoren den Code weniger lesbar machen, und es gibt eine Studie, die das beweist.

Auch das "mouse = c" ist wichtig. Sie sollten Ihre Maus nicht verwenden, um sich in einer Datei zu bewegen. Nehmen Sie Ihre Hände von der Tastatur, berühren Sie die Maus und sie bewegen sie langsam zurück. Verwenden Sie die Cursorbewegung "hjkl" und andere Tasten für Tastatur-Paging und Cursorbewegung.

Wenn Sie X11 verwenden, sollten Sie einige Dinge an Ihrer Xterm-Konfiguration vornehmen. Dies kommt aus meiner .Xresources-Datei:

XTerm*VT100.scrollBar: true
XTerm*VT100.saveLines: 1000
XTerm*VT100.cutNewLine: false 
XTerm*VT100.cutToBeginningOfLine: false
XTerm*VT100.charClass: 33:48,35:48,37:48,42:48,45-47:48,64:48,95:48,126:48
XTerm*VT100*translations: #override \n\
    <Key>F2: insert-selection(PRIMARY,CUT_BUFFER0)

Gib Xterm standardmäßig eine Bildlaufleiste, speichere 1000 Zeilen Text im Puffer, das ist ziemlich normal.

Die charClass-Direktive lässt ein "Wort" Dinge wie ".", "/" Und "*" enthalten. Doppelklicken Sie auf einen beliebigen Teil eines durch '/' getrennten Dateinamens, und Sie erhalten das Ganze abzüglich der Zeichen ':'.

cutToBeginningOfLine funktioniert mit dem obigen Zsh RPROMPT. Klicken Sie dreimal auf den Pfad des aktuellen Arbeitsverzeichnisses, das auf der rechten Seite Ihrer Befehlszeile angezeigt wird, und Sie nehmen nur den Pfad auf: Die Kopie stoppt am Wortanfang. Sehr effizient, wenn Sie es gewohnt sind.

Die obigen X-Ressourcen machen das auch zu einem Einfüge-Schlüssel. Auf diese Weise können Sie nach dem Kopieren (wahrscheinlich mit der Maus) einfügen, ohne Ihre Hand zum Klicken zurück zur Maus zu bewegen.

Das Hinzufügen des Rückgabewerts ungleich Null des letzten Befehls ist eine gute Idee. Ich glaube, das Original-Poster hat speziell nach .profile / .cshrc / .bashrc gefragt. Es lohnt sich, die Liste anderer häufig angepasster RC-Dateien zu erwähnen, aber ich würde mich bei dieser Frage nur an Shell-Anpassungen halten.

Ich habe kürzlich ein Flag in meiner Eingabeaufforderung hinzugefügt, das angezeigt wird, wenn die Shell unter dem Bildschirm ausgeführt wird. Es verwendet den Solaris-Befehl "ptree", um Vorgängerprozesse zu durchsuchen, aber Sie können den Befehl "pstree" unter Linux verwenden, um dasselbe zu tun.

SCREEN=""
if [ -f /usr/bin/ptree ]; then
   if ptree $$ | grep -v grep | grep -w screen > /dev/null 2>&1; then
       SCREEN="SCREEN "
   fi
fi

Ich habe ein paar Minuten gebraucht, um herauszufinden, wie der Rückkehrcode des letzten Befehls eingebettet werden kann. Deshalb werde ich ihn hier veröffentlichen.

PROMPT_COMMAND='if [ "$?" = 0 ]; \
        then RC=""; \
        else RC="RV=$? "; fi; PS1="% ${SCREEN}\h $RC\w\n% "'

Ich bin sicher, das könnte schöner gemacht werden. :-)

Zukünftiger Tipp, seien Sie vorsichtig beim Lesen von $? nach der Verwendung von "if [". Wenn die linke Klammer eine eingebaute Klammer ist, wird der Wert von $? Nicht überschrieben. Wenn Sie jedoch eine Shell verwenden, in der [nicht integriert ist, wird der Wert von $? nach dem Testen. Es ist sicherer, $ zuzuweisen? in eine temporäre Variable sofort und dann testen Sie diese Variable.

Zeigt die zuletzt geänderte Datei an

Oft möchte ich mir die aktuellste Datei ansehen. ZB bin ich möglicherweise im Protokollverzeichnis und möchte sehen, welche Datei aktuell ist, da dies der erste Ort ist, an dem Sie nach dem Grund suchen können, warum etwas nicht funktioniert.

ls -lt | head ist eine aber umständliche Eingabe, daher hier eine Alternative:

# show the most recently changed file
latest()
{
    if test $# -ne 0
    then
        /bin/ls -t -1 -d "$@" | head -n 1
    else
        /bin/ls -t -1 -d * | head -n 1
    fi
}

Es kann auch ein Platzhalter oder eine Liste von Dateien verwendet werden, z

$ latest mail* syslog*
syslog

Dies ist besonders praktisch, wenn alle Ihre Protokolldateien einen Zeitstempel im Namen haben. Sie können das neueste Protokoll für dieses Programm finden, ohne sich Gedanken darüber zu machen, in welchem ​​Format sich der Zeitstempel befindet.

$ touch -d 'Feb 1' mylog.20110201
$ touch -d 'Feb 2' mylog.20110202
$ touch -d 'Feb 3' mylog.20110203
$ latest mylog*
mylog.20110203

Und hier ist eine erweiterte Version, die eine -<number>Option zum Drucken von <number>Zeilen anstelle von einer unterstützt.

# show the most recently changed file
latest()
{
    local count=1               # how many files to print
    local promptlines=5         # how many lines to leave for the prompt
                                # when printing a screenful with -s
    local usage="Usage: latest [-n <number>] [-s] [--] [pattern]"
    while test $# -gt 0
    do
        case $1 in
        # -- = stop processing options
        --)
            shift
            break
            ;;
        # -n <number> = <number> files
        -n)
            if test -n "$2"
            then
                count=$2
                shift 2
            else
                echo "$usage" 1>&2
                return 1
            fi
            ;;
        # -s = one screenful
        -s)
            count=$((LINES - promptlines))
            shift
            ;;
        # -<number> = <number> files
        -[0-9]*)
            count=${1#-}
            shift
            ;;
        # anything else starting with a minus is a usage error
        -*)
            echo "$usage" 1>&2
            return 1
            ;;
        *)
            break
            ;;
        esac
    done

    if test $# -ne 0
    then
        /bin/ls -t -1 -d "$@" | head -n $count
    else
        /bin/ls -t -1 -d * | head -n $count
    fi
}