personalizar - zsh themes linux

¿Cómo puedo leer la documentación sobre los comandos integrados en zsh?

Question

Es frustrante cuando hago algo como man bindkey y me sale:

BUILTIN(1) BSD General Commands Manual BUILTIN(1) NAME builtin, !, %, ., :, @, {, }, alias, alloc, bg, bind, bindkey, break, breaksw, builtins, case, cd, chdir, command, complete, continue, default, dirs, do, done, echo, echotc, elif, else, end, endif, endsw, esac, eval, exec, exit, export, false, fc, fg, filetest, fi, for, foreach, getopts, glob, goto, hash, hashstat, history, hup, if, jobid, jobs, kill, limit, local, log, login, logout, ls-F, nice, nohup, notify, onintr, popd, printenv, pushd, pwd, read, readonly, rehash, repeat, return, sched, set, setenv, settc, setty, setvar, shift, source, stop, suspend, switch, telltc, test, then, time, times, trap, true, type, ulimit, umask, unalias, uncomplete, unhash, unlimit, unset, unsetenv, until, wait, where, which, while -- shell built-in commands SYNOPSIS builtin [-options] [args ...] DESCRIPTION Shell builtin commands are commands that can be executed within the running shell''s process. Note that, in the

¿Hay una manera fácil de acceder a la documentación para tales comandos?

Answer 1

Aunque esto fue más complicado en el pasado, a partir de 2017 (Zsh v5.4), obtener una tecla rápida de ayuda muy rápida y conveniente con los dedos es tan simple como poner lo siguiente en su .zshrc (o archivos de configuración equivalentes):

unalias run-help
autoload run-help
bindkey "^[h" run-help

Ahora puede comenzar a escribir el comando completo que está intentando invocar (se ignoran los siguientes opts / args, por ejemplo, "hola"):

print hello«Alt-h»

y verás la lista de run-help .

print [ -abcDilmnNoOpPrsSz ] [ -u n ] [ -f format ] [ -C cols ]
  [ -v name ] [ -xX tabstop ] [ -R [ -en ]] [ arg ... ]
   With the `-f'' option the arguments are printed as  described  by
   printf...

Una lista corta está disponible para la mayoría de los comandos, extraídos de zshbuiltins(1) . Veo 109 comandos documentados en mi sistema en /usr/share/zsh/5.4.2/help/ . Me encanta esta característica de Zsh!

Tenga en cuenta que no todo está integrado en run-help y que a veces necesitará extraer zshall(1) para encontrar lo que está buscando:

% run-help zargs
zargs is an autoload shell function
No manual entry for zargs

También es genial que este patrón Alt-h (o Mh si lo prefieres) haya reemplazado esencialmente cualquier llamada que harías normalmente al man , para comandos Zsh o cualquier otra cosa. En lugar de:

% foo - # oh wait, how does this work
% foo -^C
% ^p^a  # recall, go to beginning of line
% man foo

ahora es solo:

% foo -«Alt-h»

Answer 2

Finalmente me cansé de cazar páginas man y búsquedas en línea cada vez que necesitaba obtener información de Zsh. Revisé todas las páginas man de Zsh y armé una buena función de "ayuda" bastante expansiva.

Para usar esto, crearía un archivo llamado "help" en algún lugar de tu fpath y agregaría la autoload -Uz help a tu zshrc.

# better help function than zsh''s crappy run-help
local ZSHPAGE=zshall LESSQUERY
LESS="-RM~gIsw"
LESS_TERMCAP_mb=$''/E[01;31m''
LESS_TERMCAP_md=$''/E[01;31m''
LESS_TERMCAP_me=$''/E[0m''
LESS_TERMCAP_se=$''/E[0m''
LESS_TERMCAP_so=$''/E[01;44;33m''
LESS_TERMCAP_ue=$''/E[0m''
LESS_TERMCAP_us=$''/E[01;32m''

case "$@" in
    ""|--help|-h)
        local cmds=''
RESERVED WORDS
do done esac then elif else fi for case if while function  repeat  time until  select  coproc nocorrect foreach end ! [[ { } declare export float integer local readonly typeset

BUILTIN COMMANDS
- . : [ [[ alias autoload bg bindkey break builtin bye cap cd chdir clone command comparguments compcall compctl compdescribe compfiles compgroups compquote comptags comptry compvalues continue declare dirs disable disown echo echotc echoti emulate enable eval exec exit export false fc fg float functions getcap getln getopts hash history integer jobs kill lets limit local log logout noglob popd print printf pushd pushln pwd r read readonly rehash return sched set setcap setopt shift source stat suspend test times trap true ttyctl type typeset ulimit umask unalias unfunction unhash unlimit unset unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof zpty zregexparse zsocket zstyle ztcp
        ''
        if whence -p fold >/dev/null; then
            fold -sw$COLUMNS <<< $cmds
        else
            print -- $cmds
        fi
        return;;
    ''-- ''*)
        shift
        LESSQUERY="$@";;
    loop*|while|do|done|if|then|elif|else|fi|until)
        LESSQUERY=''^COMPLEX COMMANDS$''
        ZSHPAGE=zshmisc;;
    for)
        LESSQUERY=''^       for name /././. ''
        ZSHPAGE=zshmisc;;
    foreach|end)
        LESSQUERY=''^       foreach name /././.''
        ZSHPAGE=zshmisc;;
    case|esac)
        LESSQUERY=''^       case word''
        ZSHPAGE=zshmisc;;
    coproc)
        LESSQUERY=''coproc''
        ZSHPAGE=zshmisc;;
    repeat)
        LESSQUERY=''^       repeat word do''
        ZSHPAGE=zshmisc;;
    select)
        LESSQUERY=''^       select name /[ in word''
        ZSHPAGE=zshmisc;;
    time)
        LESSQUERY=''^       time /[ pipeline /]''
        ZSHPAGE=zshmisc;;
    list|''(''*|''{''*|subshell)
        LESSQUERY=''^       time /[ pipeline /]''
        ZSHPAGE=zshmisc;;
    ''!''|not)
        LESSQUERY=''^       /! exp  true if exp is false/.''
        ZSHPAGE=zshmisc;;
    .)
        LESSQUERY=''^       /. file /[ arg /././. /]''
        ZSHPAGE=zshbuiltins;;
    :)
        LESSQUERY=''^       : /[''
        ZSHPAGE=zshbuiltins;;
    alias)
        LESSQUERY=''^       alias /[''
        ZSHPAGE=zshbuiltins;;
    autoload)
        LESSQUERY=''^       autoload /[''
        ZSHPAGE=zshbuiltins;;
    *autoload*)
        LESSQUERY=''^AUTOLOADING FUNCTIONS$''
        ZSHPAGE=zshmisc;;
    bg)
        LESSQUERY=''^       bg /[''
        ZSHPAGE=zshbuiltins;;
    bindkey)
        LESSQUERY=''^ZLE BUILTINS$''
        ZSHPAGE=zshzle;;
    break)
        LESSQUERY=''^       break /[ n /]''
        ZSHPAGE=zshbuiltins;;
    -|exec|command|noglob|nocorrect|builtin|precommand*)
        LESSQUERY=''^PRECOMMAND MODIFIERS$''
        ZSHPAGE=zshmisc;;
    bye)
        LESSQUERY=''^       bye    Same as exit/.''
        ZSHPAGE=zshbuiltins;;
    cap)
        LESSQUERY=''^The zsh/cap Module$''
        ZSHPAGE=zshmodules;;
    cd)
        LESSQUERY=''^       cd /[ -qsLP /] /[ arg /]''
        ZSHPAGE=zshbuiltins;;
    chdir)
        LESSQUERY=''^       chdir  Same as cd/.''
        ZSHPAGE=zshbuiltins;;
    clone)
        LESSQUERY=''^The zsh/clone Module''
        ZSHPAGE=zshmodules;;
    compargu*)
        LESSQUERY=''^       comparguments$''
        ZSHPAGE=zshmodules;;
    compcall)
        LESSQUERY=''^       compcall /[ -TD''
        ZSHPAGE=zshcompwid;;
    compctl)
        LESSQUERY=''^       compctl /[ -CDT''
        ZSHPAGE=zshcompctl;;
    compdes*)
        LESSQUERY=''^       compdescribe$''
        ZSHPAGE=zshmodules;;
    compfiles)
        LESSQUERY=''^       compfiles$''
        ZSHPAGE=zshmodules;;
    compgroups)
        LESSQUERY=''^       compgroups$''
        ZSHPAGE=zshmodules;;
    compquote)
        LESSQUERY=''^       compquote$''
        ZSHPAGE=zshmodules;;
    comptags)
        LESSQUERY=''^       comptags$''
        ZSHPAGE=zshmodules;;
    comptry)
        LESSQUERY=''^       comptry$''
        ZSHPAGE=zshmodules;;
    compvalues)
        LESSQUERY=''^       compvalues$''
        ZSHPAGE=zshmodules;;
    continue)
        LESSQUERY=''^       continue /[ n /]''
        ZSHPAGE=zshbuiltins;;
    dirs)
        LESSQUERY=''^       dirs /[ -c /]''
        ZSHPAGE=zshbuiltins;;
    disable)
        LESSQUERY=''^       disable /[ -afmprs /]''
        ZSHPAGE=zshbuiltins;;
    disown)
        LESSQUERY=''^       disown /[ job /././. /]''
        ZSHPAGE=zshbuiltins;;
    echo)
        LESSQUERY=''^       echo /[ -neE /]''
        ZSHPAGE=zshbuiltins;;
    echotc)
        LESSQUERY=''^The zsh/termcap Module$''
        ZSHPAGE=zshmodules;;
    echoti)
        LESSQUERY=''^The zsh/terminfo Module$''
        ZSHPAGE=zshmodules;;
    emulate)
        LESSQUERY=''^       emulate /[ -LR /]''
        ZSHPAGE=zshbuiltins;;
    enable)
        LESSQUERY=''^       enable /[ -afmprs /]''
        ZSHPAGE=zshbuiltins;;
    eval)
        LESSQUERY=''^       eval /[ arg /././. /]''
        ZSHPAGE=zshbuiltins;;
    exit)
        LESSQUERY=''^       exit /[ n /]''
        ZSHPAGE=zshbuiltins;;
    export)
        LESSQUERY=''^       export /[ name''
        ZSHPAGE=zshbuiltins;;
    fc)
        LESSQUERY=''^       fc /[ -e ename /] /[ -LI /]''
        ZSHPAGE=zshbuiltins;;
    fg)
        LESSQUERY=''^       fg /[ job /././. /]S''
        ZSHPAGE=zshbuiltins;;
    functions)
        LESSQUERY=''^       functions /[ /{/+/|-/}UkmtTuz''
        ZSHPAGE=zshbuiltins;;
    getcap)
        LESSQUERY=''^The zsh/cap Module$''
        ZSHPAGE=zshmodules;;
    getln)
        LESSQUERY=''^       getln /[ -AclneE /]''
        ZSHPAGE=zshbuiltins;;
    getopts)
        LESSQUERY=''^       getopts optstring name''
        ZSHPAGE=zshbuiltins;;
    hash)
        LESSQUERY=''^       hash /[ -Ldfmrv /]''
        ZSHPAGE=zshbuiltins;;
    history)
        LESSQUERY=''^HISTORY EXPANSION$'';;
    integer)
        LESSQUERY=''^       integer /[ /{/+/|-/}Hghlprtux''
        ZSHPAGE=zshbuiltins;;
    jobs)
        LESSQUERY=''^       jobs /[ -dlprs /]''
        ZSHPAGE=zshbuiltins;;
    kill)
        LESSQUERY=''^       kill /[ -s signal_name''
        ZSHPAGE=zshbuiltins;;
    limit)
        LESSQUERY=''^       limit /[ -hs /]''
        ZSHPAGE=zshbuiltins;;
    local)
        LESSQUERY=''^       local /[ /{/+/|-/}AHUahlprtux ''
        ZSHPAGE=zshbuiltins;;
    log)
        LESSQUERY=''^       log    List all''
        ZSHPAGE=zshbuiltins;;
    logout)
        LESSQUERY=''^       logout /[ n /]''
        ZSHPAGE=zshbuiltins;;
    popd)
        LESSQUERY=''^       popd /[ -q /]''
        ZSHPAGE=zshbuiltins;;
    print)
        LESSQUERY=''^       print /[ -abcDilmnNoOpPrsSz /]''
        ZSHPAGE=zshbuiltins;;
    printf)
        LESSQUERY=''^       printf format /[ arg /././. /]''
        ZSHPAGE=zshbuiltins;;
    pushd)
        LESSQUERY=''^       pushd /[ -qsLP /]''
        ZSHPAGE=zshbuiltins;;
    pushln)
        LESSQUERY=''^       pushln /[ arg /././. /]''
        ZSHPAGE=zshbuiltins;;
    pwd)
        LESSQUERY=''^       pwd /[ -rLP /]''
        ZSHPAGE=zshbuiltins;;
    r)
        LESSQUERY=''^       r      Same as fc -e -/.''
        ZSHPAGE=zshbuiltins;;
    read)
        LESSQUERY=''^       read /[ -rszpqAclneE /]''
        ZSHPAGE=zshbuiltins;;
    readonly)
        LESSQUERY=''^       readonly$''
        ZSHPAGE=zshbuiltins;;
    rehash)
        LESSQUERY=''^       rehash Same as hash -r/.''
        ZSHPAGE=zshbuiltins;;
    return)
        LESSQUERY=''^       return /[ n /]''
        ZSHPAGE=zshbuiltins;;
    sched|''sched module'')
        LESSQUERY=''^THE ZSH/SCHED MODULE$''
        ZSHPAGE=zshmodules;;
    set)
        LESSQUERY=''^       set /[ /{/+/|-/}options''
        ZSHPAGE=zshbuiltins;;
    setcap)
        LESSQUERY=''^The zsh/cap Module$''
        ZSHPAGE=zshmodules;;
    setopt)
        LESSQUERY=''^       setopt /[ /{/+/|-/}options''
        ZSHPAGE=zshbuiltins;;
    shift)
        LESSQUERY=''^       shift /[ -p /]''
        ZSHPAGE=zshbuiltins;;
    source)
        LESSQUERY=''^       source file /[ arg''
        ZSHPAGE=zshbuiltins;;
    stat|zstat|''stat module'')
        LESSQUERY=''^The zsh/stat Module$''
        ZSHPAGE=zshmodules;;
    times)
        LESSQUERY=''^       times  Print''
        ZSHPAGE=zshbuiltins;;
    test|''[[''*|''[''*)
        LESSQUERY=''^CONDITIONAL EXPRESSIONS$''
        ZSHPAGE=zshmisc;;
    trap)
        LESSQUERY=''^       trap /[ arg /] /[ sig /././. /]''
        ZSHPAGE=zshbuiltins;;
    true)
        LESSQUERY=''^       true /[ arg /././. /]''
        ZSHPAGE=zshbuiltins;;
    ttyctl)
        LESSQUERY=''^       ttyctl /[ -fu /]''
        ZSHPAGE=zshbuiltins;;
    type)
        LESSQUERY=''^       type /[ -wfpamsS /]''
        ZSHPAGE=zshbuiltins;;
    typeset|declare)
        LESSQUERY=''^       typeset /[ /{/+/|-/}AHUaghlmprtux /]''
        ZSHPAGE=zshbuiltins;;
    ulimit)
        LESSQUERY=''^       ulimit /[ -HSa /] /[''
        ZSHPAGE=zshbuiltins;;
    umask)
        LESSQUERY=''^       umask /[ -S /] /[ mask /]''
        ZSHPAGE=zshbuiltins;;
    unalias)
        LESSQUERY=''^       unalias /[ -ams /]''
        ZSHPAGE=zshbuiltins;;
    unfunction)
        LESSQUERY=''^       unfunction$''
        ZSHPAGE=zshbuiltins;;
    unhash)
        LESSQUERY=''^       unhash /[ -adfms /]''
        ZSHPAGE=zshbuiltins;;
    unset)
        LESSQUERY=''^       unset /[ -fmv /]''
        ZSHPAGE=zshbuiltins;;
    unsetopt)
        LESSQUERY=''^       unsetopt /[ /{/+/|-/}options''
        ZSHPAGE=zshbuiltins;;
    vared)
        LESSQUERY=''^       vared /[ -Aache /]''
        ZSHPAGE=zshzle;;
    wait)
        LESSQUERY=''^       wait /[ job /././. /]''
        ZSHPAGE=zshbuiltins;;
    whence)
        LESSQUERY=''^       whence /[ -vcwfpamsS /]''
        ZSHPAGE=zshbuiltins;;
    where)
        LESSQUERY=''^       where /[ -wpmsS /]''
        ZSHPAGE=zshbuiltins;;
    which)
        LESSQUERY=''^       which /[ -wpamsS /]''
        ZSHPAGE=zshbuiltins;;
    zcompile)
        LESSQUERY=''^       zcompile /[ -U /] /[ -z /|''
        ZSHPAGE=zshbuiltins;;
    zformat)
        LESSQUERY=''^       zformat -f param format''
        ZSHPAGE=zshmodules;;
    zftp|''ftp module'')
        LESSQUERY=''^The zsh/zftp Module$''
        ZSHPAGE=zshmodules;;
    zle)
        LESSQUERY=''^       zle -l /[ -L /| -a /] /[ string /././. /]''
        ZSHPAGE=zshzle;;
    widget)
        LESSQUERY=''^              widget /[ -n num /] /[ -Nw /]''
        ZSHPAGE=zshzle;;
    zmodload)
        LESSQUERY=''^       zmodload /[ -dL /] /[ /././. /]''
        ZSHPAGE=zshbuiltins;;
    zparseopts)
        LESSQUERY=''^       zparseopts /[ -DKME /]''
        ZSHPAGE=zshmodules;;
    zprof|''zprof module'')
        LESSQUERY=''^THE ZSH/ZPROF MODULE$''
        ZSHPAGE=zshmodules;;
    zpty|''zpty module'')
        LESSQUERY=''^THE ZSH/ZPTY MODULE$''
        ZSHPAGE=zshmodules;;
    zregexparse)
        LESSQUERY=''^       zregexparse$''
        ZSHPAGE=zshmodules;;
    zsocket|(net|socket)'' module'')
        LESSQUERY=''^THE ZSH/NET/SOCKET MODULE$''
        ZSHPAGE=zshmodules;;
    zstyle|''zutil module'')
        LESSQUERY=''^The zsh/zutil Module$''
        ZSHPAGE=zshmodules;;
    ztcp|''tcp module'')
        LESSQUERY=''^THE ZSH/NET/TCP MODULE$''
        ZSHPAGE=zshmodules;;
    attr*mod*|zgetattr|zsetattr|zdelattr|zlistattr)
        LESSQUERY=''^THE ZSH/ATTR MODULE$''
        ZSHPAGE=zshmodules;;
    complist*mod*)
        LESSQUERY=''^THE ZSH/COMPLIST MODULE''
        ZSHPAGE=zshmodules;;
    computil*mod*)
        LESSQUERY=''^THE ZSH/COMPUTIL MODULE''
        ZSHPAGE=zshmodules;;
    curses*|zcurses)
        LESSQUERY=''^THE ZSH/CURSES MODULE''
        ZSHPAGE=zshmodules;;
    datetime*|strftime)
        LESSQUERY=''^THE ZSH/DATETIME MODULE''
        ZSHPAGE=zshmodules;;
    (db|gdbm)*|ztie|zuntie)
        LESSQUERY=''^THE ZSH/DB/GDBM MODULE''
        ZSHPAGE=zshmodules;;
    delto*|delete-to-char|zap-to-char)
        LESSQUERY=''^THE ZSH/DELTOCHAR MODULE''
        ZSHPAGE=zshmodules;;
    example*)
        LESSQUERY=''^THE ZSH/EXAMPLE MODULE''
        ZSHPAGE=zshmodules;;
    files*mod*|chgrp|chown|ln|mkdir|mv|rm|rmdir|sync)
        LESSQUERY=''^THE ZSH/FILES MODULE''
        ZSHPAGE=zshmodules;;
    langinfo*)
        LESSQUERY=''^THE ZSH/LANGINFO MODULE''
        ZSHPAGE=zshmodules;;
    mapfile*)
        LESSQUERY=''^THE ZSH/MAPFILE MODULE''
        ZSHPAGE=zshmodules;;
    mathfunc*mod*)
        LESSQUERY=''^THE ZSH/MATHFUNC MODULE''
        ZSHPAGE=zshmodules;;
    param*mod*)
        LESSQUERY=''^THE ZSH/PARAMETER MODULE''
        ZSHPAGE=zshmodules;;
    pcre*)
        LESSQUERY=''^THE ZSH/PCRE MODULE''
        ZSHPAGE=zshmodules;;
    regex*mod*)
        LESSQUERY=''^THE ZSH/REGEX MODULE''
        ZSHPAGE=zshmodules;;
    system*mod*|syserror|sysopen|sysread|sysseek|syswrite|zsystem*)
        LESSQUERY=''^THE ZSH/SYSTEM MODULE''
        ZSHPAGE=zshmodules;;
    zselect*)
        LESSQUERY=''^THE ZSH/ZSELECT MODULE''
        ZSHPAGE=zshmodules;;
    start*flag*|invok*|initial*)
        LESSQUERY=''^INVOCATION$''
        ZSHPAGE=zsh;;
    (start|shut)*file*|*zshenv|*zshrc|*zprofile|*zlogin|*zlogout|*zdotdir*|*ZDOTDIR*)
        LESSQUERY=''^STARTUP/SHUTDOWN FILES$''
        ZSHPAGE=zsh;;
    subscript*)
        LESSQUERY=''^   Subscript Flags''
        ZSHPAGE=zshparam;;
    simple*|pipe*)
        LESSQUERY=''^SIMPLE COMMANDS & PIPELINES''
        ZSHPAGE=zshmisc;;
    function*)
        LESSQUERY=''^       function word''
        ZSHPAGE=zshmisc;;
    alt*)
        LESSQUERY=''^ALTERNATE FORMS$''
        ZSHPAGE=zshmisc;;
    reserv*)
        LESSQUERY=''^RESERVED WORDS$''
        ZSHPAGE=zshmisc;;
    error*)
        LESSQUERY=''^ERRORS$''
        ZSHPAGE=zshmisc;;
    alias*)
        LESSQUERY=''^ALIASING$''
        ZSHPAGE=zshmisc;;
    quot*)
        LESSQUERY=''^QUOTING$''
        ZSHPAGE=zshmisc;;
    redirect*|*''>''*|*''<''*|*''&>''*|*''2>''*|*''>>''*|*''<<''*)
        LESSQUERY=''^REDIRECTION$''
        ZSHPAGE=zshmisc;;
    file*desc*)
        LESSQUERY=''^OPENING FILE DESCRIPTORS USING PARAMETERS$''
        ZSHPAGE=zshmisc;;
    multios)
        LESSQUERY=''^MULTIOS$''
        ZSHPAGE=zshmisc;;
    anon*func*)
        LESSQUERY=''^ANONYMOUS FUNCTIONS$''
        ZSHPAGE=zshmisc;;
    hook*)
        LESSQUERY=''^   Hook Functions$''
        ZSHPAGE=zshmisc;;
    trap*)
        LESSQUERY=''^   Trap Functions$''
        ZSHPAGE=zshmisc;;
    job*)
        LESSQUERY=''^JOBS$''
        ZSHPAGE=zshmisc;;
    math*|''((''*|''$((''|let*|arith*)
        LESSQUERY=''^ARITHMETIC EVALUATION$''
        ZSHPAGE=zshmisc;;
    prompt|promptinit|prompt*theme*)
        LESSQUERY=''^       prompt /[ -c /| -l /]''
        ZSHPAGE=zshcontrib;;
    PS1|prompt*|PROMPT*)
        LESSQUERY=''^SIMPLE PROMPT ESCAPES$''
        ZSHPAGE=zshmisc;;
    history*)
        LESSQUERY=''^HISTORY EXPANSION$''
        ZSHPAGE=zshexpn;;
    proc*sub*|*''<(''*|*'')>''*)
        LESSQUERY=''^PROCESS SUBSTITUTION$''
        ZSHPAGE=zshexpn;;
    param*flag*)
        LESSQUERY=''^   Parameter Expansion Flags$''
        ZSHPAGE=zshexpn;;
    param*rule*|nested*sub*)
        LESSQUERY=''^   Rules$''
        ZSHPAGE=zshexpn;;
    param*ex*)
        LESSQUERY=''^   Examples$''
        ZSHPAGE=zshexpn;;
    param*|''${'')
        LESSQUERY=''^PARAMETER EXPANSION$''
        ZSHPAGE=zshexpn;;
    brace*expan*)
        LESSQUERY=''^BRACE EXPANSION$''
        ZSHPAGE=zshexpn;;
    filename*expan*)
        LESSQUERY=''^FILENAME EXPANSION$''
        ZSHPAGE=zshexpn;;
    expan*|subst*)
        LESSQUERY=''^       zshexpn - zsh expansion and substitution$''
        ZSHPAGE=zshexpn;;
    dyn*dir*)
        LESSQUERY=''^   Dynamic named directories$''
        ZSHPAGE=zshexpn;;
    static*dir*)
        LESSQUERY=''^   Static named directories$''
        ZSHPAGE=zshexpn;;
    approx*match*)
        LESSQUERY=''^   Approximate Matching$''
        ZSHPAGE=zshexpn;;
    recurs*glob*)
        LESSQUERY=''^   Recursive Globbing$''
        ZSHPAGE=zshexpn;;
    glob*qual*)
        LESSQUERY=''^   Glob Qualifiers$''
        ZSHPAGE=zshexpn;;
    glob*flag*)
        LESSQUERY=''^   Globbing Flags$''
        ZSHPAGE=zshexpn;;
    glob*)
        LESSQUERY=''^   Glob Operators$''
        ZSHPAGE=zshexpn;;
    ksh*glob*)
        LESSQUERY=''^   ksh-like Glob Operators''
        ZSHPAGE=zshexpn;;
    array*sub*)
        LESSQUERY=''^   Array Subscripts$''
        ZSHPAGE=zshparam;;
    array*)
        LESSQUERY=''^ARRAY PARAMETERS$''
        ZSHPAGE=zshparam;;
    positional*)
        LESSQUERY=''^POSITIONAL PARAMETERS$''
        ZSHPAGE=zshparam;;
    shell*(param*|var*)|env*)
        LESSQUERY=''^PARAMETERS SET BY THE SHELL$''
        ZSHPAGE=zshparam;;
    watchfmt*)
        LESSQUERY=''^       WATCHFMT$''
        ZSHPAGE=zshparam;;
    set*|(shell|spec)*op*)
        LESSQUERY=''^SPECIFYING OPTIONS$''
        ZSHPAGE=zshoptions;;
    single*opt*|short*flag*|single*letter*)
        LESSQUERY=''^SINGLE LETTER OPTIONS$''
        ZSHPAGE=zshoptions;;
    (shell|zsh)*builtin*)
        LESSQUERY=''^SHELL BUILTIN COMMANDS$''
        ZSHPAGE=zshbuiltins;;
    key*)
        LESSQUERY=''^KEYMAPS$''
        ZSHPAGE=zshzle;;
    widget*)
        LESSQUERY=''^USER-DEFINED WIDGETS$''
        ZSHPAGE=zshzle;;
    highlight*)
        LESSQUERY=''^CHARACTER HIGHLIGHTING$''
        ZSHPAGE=zshzle;;
    comp*wid*)
        LESSQUERY=''^       zshcompwid - zsh completion widgets''
        ZSHPAGE=zshcompwid;;
    complet*param*|*PREFIX*|*CURRENT*|*SUFFIX*)
        LESSQUERY=''^COMPLETION SPECIAL PARAMETERS$''
        ZSHPAGE=zshcompwid;;
    compstate)
        LESSQUERY=''^       compstate$''
        ZSHPAGE=zshcompwid;;
    compadd)
        LESSQUERY=''^       compadd /[ -akqQfenUlo12C ''
        ZSHPAGE=zshcompwid;;
    compset)
        LESSQUERY=''^       compset -p number''
        ZSHPAGE=zshcompwid;;
    compcall)
        LESSQUERY=''^       compcall /[ -TD''
        ZSHPAGE=zshcompwid;;
    *match*)
        LESSQUERY=''^COMPLETION MATCHING CONTROL$''
        ZSHPAGE=zshcompwid;;
    *compsys*)
        LESSQUERY=''^       zshcompsys - zsh completion system''
        ZSHPAGE=zshcompsys;;
    compdef*)
        LESSQUERY=''^       compdef /[ -ane /]''
        ZSHPAGE=zshcompsys;;
    ''#''compdef*)
        LESSQUERY=''^       #compdef name''
        ZSHPAGE=zshcompsys;;
    *completer*)
        LESSQUERY=''^       completer$''
        ZSHPAGE=zshcompsys;;
    *complet*|*''zstyle ''*)
        LESSQUERY=''^COMPLETION SYSTEM CONFIGURATION$''
        ZSHPAGE=zshcompsys;;
    utility*func*|_argu*|_descr*)
        LESSQUERY=''^UTILITY FUNCTIONS$''
        ZSHPAGE=zshcompsys;;
    control*func*|_func*)
        LESSQUERY=''^CONTROL FUNCTIONS$''
        ZSHPAGE=zshcompsys;;
    calendar*)
        LESSQUERY=''^       calendar /[ -abdDsv''
        ZSHPAGE=zshcalsys;;
    calsys*)
        LESSQUERY=''^       zshcalsys - zsh calendar system''
        ZSHPAGE=zshcalsys;;
    tcp*)
        LESSQUERY=''^       zshtcpsys - zsh tcp system''
        ZSHPAGE=zshtcpsys;;
    ftp*|zftp*)
        LESSQUERY=''^       zshzftpsys - zftp function front-end''
        ZSHPAGE=zshzftpsys;;
    contrib*)
        LESSQUERY=''^       zshcontrib - user contributions to zsh''
        ZSHPAGE=zshcontrib;;
    special*func*)
        LESSQUERY=''^SPECIAL FUNCTIONS''
        ZSHPAGE=zshmisc;;
    color*comp*)
        LESSQUERY=''^   Colored completion listings''
        ZSHPAGE=zshmodules;;
    colors)
        LESSQUERY=''^       colors This  function''
        ZSHPAGE=zshcontrib;;
    vcs*|version*control*)
        LESSQUERY=''^GATHERING INFORMATION FROM VERSION CONTROL SYSTEMS$''
        ZSHPAGE=zshcontrib;;
    zle*)
        LESSQUERY=''^ZLE FUNCTIONS$''
        ZSHPAGE=zshzle;;
    mime*)
        LESSQUERY=''^MIME FUNCTIONS$''
        ZSHPAGE=zshcontrib;;
    zcalc*)
        LESSQUERY=''^       zcalc /[ -ef''
        ZSHPAGE=zshcontrib;;
    zmathfuncdef)
        LESSQUERY=''^       zmathfuncdef /[''
        ZSHPAGE=zshcontrib;;
    other*func*)
        LESSQUERY=''^OTHER FUNCTIONS''
        ZSHPAGE=zshcontrib;;
    zargs)
        LESSQUERY=''       zargs /[ option''
        ZSHPAGE=zshcontrib;;
    tetris*)
        LESSQUERY=''^       tetris Zsh''
        ZSHPAGE=zshcontrib;;
    zed)
        LESSQUERY=''^       zed /[ -f''
        ZSHPAGE=zshcontrib;;
    zmv|zcp|zln|zkbd)
        LESSQUERY=''^       zmv /[ -finq''
        ZSHPAGE=zshcontrib;;
    zstyle+)
        LESSQUERY=''^       zstyle/+ context''
        ZSHPAGE=zshcontrib;;
    file*)
        LESSQUERY=''^FILES$''
        ZSHPAGE=zsh;;
    except*|throw|catch|always)
        LESSQUERY=''^EXCEPTION HANDLING$''
        ZSHPAGE=zshcontrib;;
    *)
        LESSQUERY="$@";;
esac
man --pager="less -p''$LESSQUERY''" "$ZSHPAGE"

Usa menos como buscapersonas y habilita menos soporte de termcap para las páginas man de color. Ejecutando help sin parámetros o --help o -h enumera palabras reservadas y comandos incorporados. Escribir help con una de esas palabras lo lleva directamente a la entrada en la página del manual correspondiente. man ... zshall las entradas en páginas de manual específicas para optimizar la velocidad / eficiencia, en lugar de solo usar man ... zshall . Esta función de ayuda encuentra mucho más que palabras reservadas y comandos integrados. Localizará entradas para módulos, comandos de módulo, ciertos comandos importantes de finalización como compadd, compset, etc.

Muchas secciones sobre cosas como aritmética, terminación, globbing, matrices, variables de entorno, manejo de excepciones se muestran escribiendo help math , help complet , help glob , help arrays , help env , help except . Hay comodines y términos de coincidencia múltiple para que la función de ayuda sea más amigable. Es una declaración de caso bastante simple con un poco más de 210 condiciones coincidentes. Si no hay coincidencia, se establece de manera predeterminada en una búsqueda de zshall. Si las condiciones de coincidencia no muestran lo que está buscando o parece interponerse en su camino, escriba help -- siguiendo sus términos de búsqueda para eludir todas las coincidencias.

Incluí mucho de lo que cubren las páginas man de Zsh, pero podría hacerse más inteligente o más completo incluyendo cosas como las funciones de finalización con guion bajo.

edit: hice una función bindkey para ^[h (esc / alt + h). run-help está vinculado allí por defecto, y esto lo reemplaza.

_helpprefix(){
    OLDBUFFER="$BUFFER"
    zle backward-kill-word
    BUFFER="help $CUTBUFFER"
    zle accept-line
    zle -U "$OLDBUFFER"
}
zle -N _helpprefix _helpprefix
bindkey ''^[h'' _helpprefix

Lo que hace es cortar la última palabra escrita, ejecutar la help con esa palabra y luego retroceder en la línea original. Entonces puede usarlo para ejecutar ayuda en read en un comando como este:

find /usr -print0 | while IFS= read

Seguirá estando justo al final de su comando después de ver la entrada para read .

También algo digno de mención, si alguna vez necesita ayuda con indicadores para un determinado builtin, siempre puede agregar un - después del comando y presionar la pestaña para ver descripciones breves de cada indicador, por ejemplo, read - pestaña imprime esto:

-A  -- first name is taken as an array
-E  -- input read is echoed
-d  -- specify delimiter to terminate input instead of newline
-e  -- input read is echoed and not assigned
-k  -- specify number of characters to read
-q  -- read y or n character from terminal
-r  -- raw mode
-s  -- suppress terminal echoing
-t  -- test if input is available before reading
-u  -- specify file descriptor to read from
-z  -- read entry from editor buffer stack

Answer 3

La información clave para obtener una utilidad de ayuda más útil en realidad se incluye con Zsh, solo se trata de encontrar la página del manual crítica y escasamente descubierta: man zshcontrib ( aquí en la web ), que describe el widget de run-help :

De forma predeterminada, run-help es un alias para el comando man , por lo que a menudo falla cuando la palabra de comando es un shell incorporado o una función definida por el usuario. Al redefinir el alias run-help , uno puede mejorar la ayuda en línea proporcionada por el shell.

Además explica cómo reemplazarlo con una mejora incorporada.

Después de configurar esto, al llamar a run-help para nombres de edificios, funciones de finalización, etc., ahora intentaremos mostrarle la documentación extraída, o mostrarle la página de manual que contiene el nombre correcto, etc. Por ejemplo run-help bindkey salidas de run-help bindkey :

bindkey
   See the section `Zle Builtins'' in zshzle(1).

que podría ser mejor Para un mejor ejemplo, el run-help history muestra la sección de la página de manual de Zsh para fc , que es el comando que subyace a la history .

También es útil tener en cuenta: ESC-h llamará a run-help para el comando en la línea de entrada actual.

Supongo que esta configuración no es la predeterminada porque extraer los datos de ayuda granulares y configurar HELPDIR para apuntar a ellos podría ser una decisión de empaquetado que queda en las distribuciones del sistema operativo. También hay una opción para el usuario: la utilidad autoload run-help es útil sin configurar HELPDIR en absoluto. Parece que es bueno llevarte a la página de manual correcta, incluso si no puede pasar a la sección exacta de un elemento. Algunos pueden preferir que esto se ejecute en casos como el ejemplo de bindkey anterior que solo desperdicia tiempo. (Por qué dan el valor predeterminado a alias run-help=man entonces, no puedo entender).

Para Zsh versión 5.0.3 o posterior

Las extracciones de archivos de ayuda probablemente se incluyan en la distribución de Zsh. Solo es cuestión de encontrarlos en su sistema para configurar HELPDIR si lo desea; los posibles candidatos están en /usr/share/zsh o /usr/local/share/zsh , busque un subdirectorio de help .

Para versiones de Zsh anteriores a 5.0.3

Es probable que deba seguir el procedimiento detallado en man zshcontrib para generar los archivos de ayuda. Es un poco molesto tener que hacer esto, pero por lo demás es rápido e indoloro.

Encuentre su versión instalada con zsh --version y obtenga el tarball fuente correspondiente del archivo sourceforge . A continuación, ejecute el script helpfiles como se muestra en la página man y establezca el destino como HELPDIR en su ~/.zshrc .

Answer 4

La página de manual de tu caparazón probablemente te lo diga.

Utilice la función de búsqueda de su buscapersonas si lee en el intérprete de comandos (o la función de búsqueda de su navegador). Por less eso es /search string para iniciar la búsqueda y n para pasar a la siguiente coincidencia.

Answer 5

Pasé de bash a zsh, y me perdí el builtin de "ayuda". Entonces escribí un alias que lo llamó. Luego descubrí algo mejor. Aunque a veces tengo que presionar "n" una o más veces para llegar a la línea en el manual que necesito.

help(){
    #This function used to call the "bash" builtin.
    #bash -c "help $@"

    #Better way: look it up in the man pages. I often look up "test" which doesn''t give a usefull result,
    #so I added that as a special case.
    if [[ $1 == "test" ]]; then
        man --pager="less -p''^CONDITIONAL EXPRESSIONS$''" zshall
    else
        man --pager="less -p''^ *$@ ''" zshall
    fi
}

Answer 6

Pruebe cualquiera de estos:

man zshbuiltins

o

man zshall

Las páginas man para zsh están divididas por tema, man zsh es principalmente una tabla de contenido e introducción, mientras que man zshall es todo (24628 líneas en mi sistema en comparación con 5242 para man bash ).

En cuanto a bindkey , man zshbuiltins lo referirá al man zshzle .

Answer 7

Puede agregar esas líneas a su perfil .zshrc :

unalias run-help 2>/dev/null
autoload run-help
HELPDIR=/path/to/zsh_help_directory
alias help=run-help

donde /path/to/zsh_help_directory debe ser sustituido por su carpeta de ayuda de zsh. Si está en OS X con zsh instalado a través de Homebrew, esta carpeta es /usr/local/share/zsh/help

Esto habilitará la ayuda tipo bash para zsh.

Cabe señalar que si la ruta de instalación predeterminada de los archivos de ayuda del shell de inicio de zsh existe y contiene los archivos deseados, no será necesaria la tercera línea HELPDIR=/path/to/zsh_help_directory .

Fuente su .zshrc ( $ source .zshrc ) y compruebe que todo funciona bien, por ejemplo (recoger cualquier zsh incorporado que desee, aquí elegí autoload ):

$ help autoload

Observe que la parte 2>/dev/null es necesaria porque sin ella, std error ''unalias: ningún elemento de la tabla hash: run-help'' ocurriría cada vez que obtenga su archivo .zshrc mientras run-help ya no está sesgada.

Answer 8

con Bash, "ayuda" funciona:

jcomeau@intrepid:~/etc/apache2$ help until until: until COMMANDS; do COMMANDS; done Execute commands as long as a test does not succeed. Expand and execute COMMANDS as long as the final command in the `until'' COMMANDS has an exit status which is not zero. Exit Status: Returns the status of the last command executed.