alias增加自动补全功能

最新推荐文章于 2024-05-04 10:23:59 发布
最新推荐文章于 2024-05-04 10:23:59 发布
阅读量539 收藏
点赞数
文章标签： 操作系统 python awk
原文链接：https://my.oschina.net/u/4038454/blog/3009919
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

https://github.com/cykerway/complete-alias

#!/bin/bash

##  ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
##  programmable completion function for shell aliases;
##  ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

##  ============================================================================
##  Copyright (C) 2016-2018 Cyker Way
##
##  This program is free software: you can redistribute it and/or modify it
##  under the terms of the GNU General Public License as published by the Free
##  Software Foundation, either version 3 of the License, or (at your option)
##  any later version.
##
##  This program is distributed in the hope that it will be useful, but WITHOUT
##  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
##  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
##  more details.
##
##  You should have received a copy of the GNU General Public License along with
##  this program.  If not, see <http://www.gnu.org/licenses/>.
##  ============================================================================

##  ============================================================================
##  variable;
##  ============================================================================

##  register for keeping function return value;
_retval=

##  refcnt for alias expansion; expand aliases iff `_refcnt == 0`;
_refcnt=0

##  ============================================================================
##  function;
##  ============================================================================

##  debug;
_debug() {
    echo
    echo "#COMP_WORDS=${#COMP_WORDS[@]}"
    echo "COMP_WORDS=("
    for x in "${COMP_WORDS[@]}"; do
        echo "'$x'"
    done
    echo ")"
    echo "COMP_CWORD=${COMP_CWORD}"
    echo "COMP_LINE='${COMP_LINE}'"
    echo "COMP_POINT=${COMP_POINT}"
    echo
}

##  test whether element is in array;
##
##  $@
##  :   ( elem arr[0] arr[1] ... )
_inarr() {
    for e in "${@:2}"; do
        [[ "$e" == "$1" ]] && return 0
    done
    return 1
}

##  split command line into words;
##
##  $1
##  :   command line string;
_split_cmd_line() {
    ##  command line string;
    local str="$1"

    ##  an array that will contain words after split;
    local words=()

    ##  alloc a temp stack to track open and close chars when splitting;
    local sta=()

    ##  examine each char of `str`;
    local i=0 j=0
    for (( ; j < ${#str}; j++ )); do
        if (( ${#sta[@]} == 0 )); then
            if [[ '$(' == "${str:j:2}" ]]; then
                sta+=( ')' )
                (( j++ ))
            elif [[ '`' == "${str:j:1}" ]]; then
                sta+=( '`' )
            elif [[ '(' == "${str:j:1}" ]]; then
                sta+=( ')' )
            elif [[ '{' == "${str:j:1}" ]]; then
                sta+=( '}' )
            elif [[ '"' == "${str:j:1}" ]]; then
                sta+=( '"' )
            elif [[ "'" == "${str:j:1}" ]]; then
                sta+=( "'" )
            elif [[ '\$' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\`' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\"' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\\' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ "\'" == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ $' \t\n' == *"${str:j:1}"* ]]; then
                (( i < j )) && words+=( "${str:i:j-i}" )
                (( i = j + 1 ))
            elif [[ "><=;|&:" == *"${str:j:1}"* ]]; then
                (( i < j )) && words+=( "${str:i:j-i}" )
                words+=( "${str:j:1}" )
                (( i = j + 1 ))
            fi
        elif [[ "${sta[-1]}" == ')' ]]; then
            if [[ ')' == "${str:j:1}" ]]; then
                unset sta[-1]
            elif [[ '$(' == "${str:j:2}" ]]; then
                sta+=( ')' )
                (( j++ ))
            elif [[ '`' == "${str:j:1}" ]]; then
                sta+=( '`' )
            elif [[ '(' == "${str:j:1}" ]]; then
                sta+=( ')' )
            elif [[ '{' == "${str:j:1}" ]]; then
                sta+=( '}' )
            elif [[ '"' == "${str:j:1}" ]]; then
                sta+=( '"' )
            elif [[ "'" == "${str:j:1}" ]]; then
                sta+=( "'" )
            elif [[ '\$' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\`' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\"' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\\' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ "\'" == "${str:j:2}" ]]; then
                (( j++ ))
            fi
        elif [[ "${sta[-1]}" == '}' ]]; then
            if [[ '}' == "${str:j:1}" ]]; then
                unset sta[-1]
            elif [[ '$(' == "${str:j:2}" ]]; then
                sta+=( ')' )
                (( j++ ))
            elif [[ '`' == "${str:j:1}" ]]; then
                sta+=( '`' )
            elif [[ '(' == "${str:j:1}" ]]; then
                sta+=( ')' )
            elif [[ '{' == "${str:j:1}" ]]; then
                sta+=( '}' )
            elif [[ '"' == "${str:j:1}" ]]; then
                sta+=( '"' )
            elif [[ "'" == "${str:j:1}" ]]; then
                sta+=( "'" )
            elif [[ '\$' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\`' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\"' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\\' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ "\'" == "${str:j:2}" ]]; then
                (( j++ ))
            fi
        elif [[ "${sta[-1]}" == '`' ]]; then
            if [[ '`' == "${str:j:1}" ]]; then
                unset sta[-1]
            elif [[ '$(' == "${str:j:2}" ]]; then
                sta+=( ')' )
                (( j++ ))
            elif [[ '(' == "${str:j:1}" ]]; then
                sta+=( ')' )
            elif [[ '{' == "${str:j:1}" ]]; then
                sta+=( '}' )
            elif [[ '"' == "${str:j:1}" ]]; then
                sta+=( '"' )
            elif [[ "'" == "${str:j:1}" ]]; then
                sta+=( "'" )
            elif [[ '\$' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\`' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\"' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\\' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ "\'" == "${str:j:2}" ]]; then
                (( j++ ))
            fi
        elif [[ "${sta[-1]}" == "'" ]]; then
            if [[ "'" == "${str:j:1}" ]]; then
                unset sta[-1]
            fi
        elif [[ "${sta[-1]}" == '"' ]]; then
            if [[ '"' == "${str:j:1}" ]]; then
                unset sta[-1]
            elif [[ '$(' == "${str:j:2}" ]]; then
                sta+=( ')' )
                (( j++ ))
            elif [[ '`' == "${str:j:1}" ]]; then
                sta+=( '`' )
            elif [[ '\$' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\`' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\"' == "${str:j:2}" ]]; then
                (( j++ ))
            elif [[ '\\' == "${str:j:2}" ]]; then
                (( j++ ))
            fi
        fi
    done

    ##  append the last word;
    (( i < j )) && words+=( "${str:i:j-i}" )

    ##  unset the temp stack;
    unset sta

    ##  return value;
    _retval=( "${words[@]}" )
}

##  expand aliases in command line;
##
##  $1
##  :   beg word index;
##  $2
##  :   end word index;
##  $3
##  :   ignored word index (can be null);
##  $4
##  :   number of used aliases;
##  ${@:4}
##  :   used aliases;
##  $?
##  :   difference of `${#COMP_WORDS}` before and after expansion;
_expand_alias() {
    local beg="$1" end="$2" ignore="$3" n_used="$4"; shift 4
    local used=( "${@:1:$n_used}" ); shift "$n_used"

    if (( $beg == $end )) ; then
        ##  case 1: range is empty;
        _retval=0
    elif [[ -n "$ignore" ]] && (( $beg == $ignore )); then
        ##  case 2: beg index is ignored; pass it;
        _expand_alias \
            "$(( $beg + 1 ))" \
            "$end" \
            "$ignore" \
            "${#used[@]}" \
            "${used[@]}"
    elif ! alias "${COMP_WORDS[$beg]}" &>/dev/null; then
        ##  case 3: command is not an alias;
        _retval=0
    elif ( _inarr "${COMP_WORDS[$beg]}" "${used[@]}" ); then
        ##  case 4: command is an used alias;
        _retval=0
    else
        ##  case 5: command is an unused alias;

        ##  get alias name;
        local cmd="${COMP_WORDS[$beg]}"

        ##  get alias body;
        local str0="$( alias "$cmd" | sed -E 's/[^=]*=//' | xargs )"

        ##  split alias body into words;
        _split_cmd_line "$str0"
        local words0=( "${_retval[@]}" )

        ##  find index range of word `$COMP_WORDS[$beg]` in string `$COMP_LINE`;
        local i=0 j=0
        for (( i = 0; i <= $beg; i++ )); do
            for (( ; j <= ${#COMP_LINE}; j++ )); do
                [[ "${COMP_LINE:j}" == "${COMP_WORDS[i]}"* ]] && break
            done
            (( i == $beg )) && break
            (( j += ${#COMP_WORDS[i]} ))
        done

        ##  now `j` is at the beginning of word `$COMP_WORDS[$beg]`; and we know
        ##  the index range is `[j, j+${#cmd})`; update `$COMP_LINE` and
        ##  `$COMP_POINT`;
        COMP_LINE="${COMP_LINE:0:j}${str0}${COMP_LINE:j+${#cmd}}"
        if (( $COMP_POINT < j )); then
            :
        elif (( $COMP_POINT < j + ${#cmd} )); then
            ##  set current cursor position to the end of replacement string;
            (( COMP_POINT = j + ${#str0} ))
        else
            (( COMP_POINT += ${#str0} - ${#cmd} ))
        fi

        ##  update `$COMP_WORDS` and `$COMP_CWORD`;
        COMP_WORDS=(
            "${COMP_WORDS[@]:0:beg}"
            "${words0[@]}"
            "${COMP_WORDS[@]:beg+1}"
        )
        if (( $COMP_CWORD < $beg )); then
            :
        elif (( $COMP_CWORD < $beg + 1 )); then
            ##  set current word index to the last of replacement words;
            (( COMP_CWORD = $beg + ${#words0[@]} - 1 ))
        else
            (( COMP_CWORD += ${#words0[@]} - 1 ))
        fi

        ##  update `$ignore` if it is not empty; if `$ignore` is not empty, then
        ##  we know it is not equal to `$beg` because we checked that in case 2;
        if [[ -n "$ignore" ]] && (( $ignore > $beg )); then
            (( ignore += ${#words0[@]} - 1 ))
        fi

        ##  recursively expand part 0;
        local used0=( "${used[@]}" "$cmd" )
        _expand_alias \
            "$beg" \
            "$(( $beg + ${#words0[@]} ))" \
            "$ignore" \
            "${#used0[@]}" \
            "${used0[@]}"
        local diff0="$_retval"

        ##  recursively expand part 1;
        if [[ -n "$str0" ]] && [[ "${str0: -1}" == ' ' ]]; then
            local used1=( "${used[@]}" )
            _expand_alias \
                "$(( $beg + ${#words0[@]} + $diff0 ))" \
                "$(( $end + ${#words0[@]} - 1 + $diff0 ))" \
                "$ignore" \
                "${#used1[@]}" \
                "${used1[@]}"
            local diff1="$_retval"
        else
            local diff1=0
        fi

        ##  return value;
        _retval=$(( ${#words0[@]} - 1 + diff0 + diff1 ))
    fi
}

##  set a command completion function to the default one; users may edit this
##  function to fit their own needs;
_set_default_completion() {
    local cmd="$1"

    case "$cmd" in
        bind)
            complete -A binding "$cmd"
            ;;
        help)
            complete -A helptopic "$cmd"
            ;;
        set)
            complete -A setopt "$cmd"
            ;;
        shopt)
            complete -A shopt "$cmd"
            ;;
        bg)
            complete -A stopped -P '"%' -S '"' "$cmd"
            ;;
        service)
            complete -F _service "$cmd"
            ;;
        unalias)
            complete -a "$cmd"
            ;;
        builtin)
            complete -b "$cmd"
            ;;
        command|type|which)
            complete -c "$cmd"
            ;;
        fg|jobs|disown)
            complete -j -P '"%' -S '"' "$cmd"
            ;;
        groups|slay|w|sux)
            complete -u "$cmd"
            ;;
        readonly|unset)
            complete -v "$cmd"
            ;;
        traceroute|traceroute6|tracepath|tracepath6|fping|fping6|telnet|rsh|\
            rlogin|ftp|dig|mtr|ssh-installkeys|showmount)
            complete -F _known_hosts "$cmd"
            ;;
        aoss|command|do|else|eval|exec|ltrace|nice|nohup|padsp|then|time|\
            tsocks|vsound|xargs)
            complete -F _command "$cmd"
            ;;
        fakeroot|gksu|gksudo|kdesudo|really)
            complete -F _root_command "$cmd"
            ;;
        a2ps|awk|base64|bash|bc|bison|cat|chroot|colordiff|cp|csplit|cut|date|\
            df|diff|dir|du|enscript|env|expand|fmt|fold|gperf|grep|grub|head|\
            irb|ld|ldd|less|ln|ls|m4|md5sum|mkdir|mkfifo|mknod|mv|netstat|nl|\
            nm|objcopy|objdump|od|paste|pr|ptx|readelf|rm|rmdir|sed|seq|\
            sha{,1,224,256,384,512}sum|shar|sort|split|strip|sum|tac|tail|tee|\
            texindex|touch|tr|uname|unexpand|uniq|units|vdir|wc|who)
            complete -F _longopt "$cmd"
            ;;
        *)
            _completion_loader "$cmd"
            ;;
    esac
}

##  programmable completion function for aliases; this is the function to be set
##  with `complete -F`;
_complete_alias() {
    ##  get command;
    local cmd="${COMP_WORDS[0]}"

    ##  we expand aliases only for the original command line (ie: the command
    ##  line after which user pressed `<tab>`); this means we expand aliases
    ##  only in the outmost call of this function; we ensure this by using a
    ##  refcnt and expand aliases iff the refcnt is equal to 0;
    if (( _refcnt == 0 )); then

        ##  find index range of word `$COMP_WORDS[$COMP_CWORD]` in string
        ##  `$COMP_LINE`; dont expand this word if `$COMP_POINT` (cursor
        ##  position) lies in this range because the word may be incomplete;
        local i=0 j=0
        for (( ; i <= $COMP_CWORD; i++ )); do
            for (( ; j <= ${#COMP_LINE}; j++ )); do
                [[ "${COMP_LINE:j}" == "${COMP_WORDS[i]}"* ]] && break
            done
            (( i == $COMP_CWORD )) && break
            (( j += ${#COMP_WORDS[i]} ))
        done

        ##  now `j` is at the beginning of word `$COMP_WORDS[$COMP_CWORD]`; and
        ##  we know the index range is `[j, j+${#COMP_WORDS[$COMP_CWORD]}]`; we
        ##  include the right endpoint to cover the case where cursor is at the
        ##  exact end of the word; compare the index range with `$COMP_POINT`;
        if (( j <= $COMP_POINT )) && \
            (( $COMP_POINT <= j + ${#COMP_WORDS[$COMP_CWORD]} )); then
            local ignore="$COMP_CWORD"
        else
            local ignore=""
        fi

        ##  expand aliases;
        _expand_alias 0 "${#COMP_WORDS[@]}" "$ignore" 0
    fi

    ##  increase refcnt;
    (( _refcnt++ ))

    ##  since aliases have been fully expanded, we no longer need to consider
    ##  aliases in the resulting command line; so we now set this command
    ##  completion function to the default one (which is alias-agnostic); this
    ##  avoids infinite recursion when a command is aliased to itself (ie:
    ##  `alias ls='ls -a'`);
    _set_default_completion "$cmd"

    ##  do actual completion;
    _command_offset 0

    ##  reset this command completion function to `_complete_alias`;
    complete -F _complete_alias "$cmd"

    ##  decrease refcnt;
    (( _refcnt-- ))
}

##  ============================================================================
##  complete user-defined aliases;
##
##  uncomment and edit these lines to complete your aliases;
##  ============================================================================

#complete -F _complete_alias myalias1
#complete -F _complete_alias myalias2
#complete -F _complete_alias myalias3
source <(kubeadm completion bash) 
source <(kubectl completion bash) 
alias kl='kubectl'
alias km='kubeadm'
alias kminit='kubeadm init --apiserver-advertise-address=192.168.175.143 --kubernetes-version=v1.13.0 && mkdir -p $HOME/.kube && sudo cp  /etc/kubernetes/admin.conf $HOME/.kube/config && sudo chown $(id -u):$(id -g) $HOME/.kube/config'
alias kmreset='echo y | kubeadm reset'
complete -F _complete_alias kl
complete -F _complete_alias km

 

转载于:https://my.oschina.net/u/4038454/blog/3009919

weixin_34236869
关注
[ES] es 搜索的高级功能：搜索并按照不同字段sore权重计算得分排序
MachineLP的专栏
08-03 2603
电商搜索中一个通用搜索语句： GET /_search { "query": { "function_score": { "query": { "bool": { "should": [ { "match_phrase": { "title": { ...
ClickHouse:A Fast OpenSource OLAP Database
AI天才研究院
07-28 1016
2019年9月1日，ClickHouse作为开源分布式列存数据库首次亮相，它极大的推动了云计算、大数据分析等领域的发展。ClickHouse作为一款真正意义上的企业级的开源OLAP（OnLine Analytical Processing）数据库，在功能性上具有巨大的优势。但由于其快速的实时响应、高性能、稳定性、易用性、易于扩展等特性，也吸引到许多公司、组织和个人对其进行尝试和使用。
bash-alias-completion:Bash完成别名
05-10
bash-alias-completion Bash完成别名 问题及其解决方案 假设您有一个这样的别名： alias gc= ' git clone ' 如果您键入gc --后面接[TAB] ，则可用选项将不会完成任何bash补全。 要解决此问题，您可以在文件alias_completion.sh使用脚本。 不应正常调用此脚本，而应在定义别名后使用source alias_completion.sh （使用source alias_completion.sh或. alias_completion.sh ）。 恕我直言，最好的方法是将其放在文件~/.bashrc末尾。
命令补全和别名alias
乐猿
11-15 920
命令补全和别名alias
巧用alias提高效率
GodLaughing
12-18 1551
概述 利用alias可以把很长的命令变成任意我们喜欢的简短的命令,在输入时只需要输入短命令。 例子 系统自带 #alias alias cp='cp -i' alias l.='ls -d .* --color=tty' alias ll='ls -l --color=tty' alias ls='ls --color=tty' alias mv='mv -i' alias rm=
complete-alias:自动神奇的shell别名完成;
05-13
完全别名 自动神奇的shell别名完成; 适用于所有常见的别名，甚至是自别名； 一项完成功能，适用于所有别名； 别名完成就像键入和制表符一样容易； 安装 安装依赖项 ; Linux： 使用系统软件包管理器安装bash-completion ： dnf install bash-completion ## fedora apt install bash-completion ## debian 有关其他Linux发行版，请参见常见问题解答。 macos（实验性）： 安装bash-completion自酿公式版本2： brew install bash-completion@2 Windows（实验性）： 见常见问题； 源complete_alias在~/.bash_completion ： . {complete_alias} 其中{comp
8.3-命令补全和alias别名
Evan's运维笔记
09-19 297
按 tab 键可以帮我们补全一个命令、一个路径或者一个文件名。连续按两次 tab 键，系统则会把所有的命令或者文件名都列出来 命令补全 输入ls后按两下 tab，会把 ls 开头的都列出来 [root@evan-01 ~]# ls ls lsattr lsblk lscpu lsinitrd lsipc lslocks lslogins lsm...
ubuntu各种实践笔记
静心净气的博客
07-09 1407
一、快捷键启动 Ctrl+Alt+T：运行终端 Ctrl+Shift+C/V：在终端上复制/粘贴 Ctrl+L：显示当前文件夹的地址栏，按ESC恢复 Tab：终端上自动补全命令名或文件名 Ctrl+H：单次显示当前隐藏文件。永久显示，则需 参考 pwd：查看当前路径命令 F2：重命名。 top：查看内存、cpu等使用情况。 按住win键（即super键）：显示ubuntu的全体快...
2024年最新RHCE——十三、Shell自动化运维编程基础，写给互联网大厂员工的真心话
最新发布
2301_77116622的博客
05-04 935
最全的Linux教程，Linux从入门到精通第一份《Linux从入门到精通》466页内容简介====本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。
【IPython.Shell深度解析】：解锁高级功能与定制技巧，成为Python开发专家
IPython.Shell是一个强大的交互式Python环境，它扩展了标准Python Shell的功能，提供了更多高级特性，如自动补全、历史记录、内省和调试等。它不仅适用于日常的Python代码执行，而且在数据分析、机器学习和科学计算...
ubuntu下alias使用详解(有许多需要注意的细节)
04-25 5584
由于主机上装了scureCRT这个远程登录软件，但是在linux环境下找不到破解版，只能使用30天试用版。针对这个版本，也是有无限使用的方法的，详细我就不讲了，请参考下面的这篇文章：http://linfengdu.blog.163.com/blog/static/117710732011101011243454/         在文章中可以看到～/.vandyke/Config这个目
linux alias常用功能记录
u012642670的博客
10-30 838
linux alias 常用功能记录alias定义alias别名删除alias别名alias外部传参使alias在每次shell连接都可用1.vim ~/.bashrc2.vim ~/.bash_profile传入参数$1位置参数${1:-} ${1:+} 指令替换 alias Linux用户经常需要反复使用一个命令。 一次又一次地键入或复制相同的命令会降低您的工作效率，并分散您的实际操作。 您可以通过为最常用的命令创建别名来节省一些时间。 定义alias别名 alias ll=‘ls -l --color
linux小技巧： 可以补全命令 别名永久有效
wyq2070857323的博客
12-27 388
有的命令很长，我们设置别名永久有效，简化我们操作想永久有效必须写入文件比如说 echo "- - -" > /sys/class/scsi_host/host0/scan;此命令用于给服务器加硬盘后，生产环境不能关机重启，所以我们用此命令刷新连接硬盘的三个接口1，输入 vim ~/.bashrc2,输入别名 格式为 alias 新单词=“旧的很长的内容”3，alias 查看有无生效。
bash的按TAB键自动补全（自动完成）的原理与扩展
snow168rain的专栏
12-28 8672
最近在用源码安装ceph，发现命令不能自动补全，然后找到了下面这篇文章，写的很好~转载一下~ 源码安装ceph命令没法自动补全的解决方法：把ceph-deploy安装的可以自动补全的系统里/etc/bash_completion.d下ceph的文件scp到源码安装对应的位置，然后“. /etc/bash_completion”就可以了~（注意点 . 号） 下面是正片环节~ 用过b
linux-使用基础-自动补全-快捷键-历史命令-别名
pyhui的技术博客
06-18 4170
shell简介 在计算机科学中，Shell俗称壳(用来区别于核)，是指"为使用者提供操作界面"的软件(命令解析器)。它类似于DOS下的command.com和后来的cmd.exe。它接收用户命令，然后调用相应的应用程序。 自动补全 快捷键 历史命令 安装一个小火车的命令 命令别名 定义与取消别名 通过alias查看别名的信息 ll实际上是ls -l 的别名 查看一个命令的本质 ...
bash 命令行补全
hjjdebug的专栏
02-03 1882
bash 命令行的标准补全(5种) bash_completion: bash 的高级完成功能
使用Bash中Complete自动补全命令
kobejayandy的专栏
03-10 3886
大家在Linux下都用shell的TAB自动补全功能，非常方便，但是有时自己开发程序，可能需要自定义实现TAB自动补全功能，这时可能就会用到complete命令来实现对命令的自定义补全，本文主要介绍complete的用法 complete参数详解 1 complete [-abcdefgjksuv] [-o comp-option] [-A actio
alias 整合多个命令
【欢迎关注公众号：冬瓜白】
04-07 5344
根据网上资料爬坑整理： alias java8='java8(){ export JAVA_HOME=$JAVA_8_HOME;source ~/.bash_profile;};java8' java8 是我自己定义的命令，后面多个命令用 ; 分割（有资料说 ; 是执行失败了也可以继续执行，使用 && 是必须要执行成功了才能继续执行，具体没试过）；要注意 { 后面要有空格。 ...
Linux命令之alias
DoubleJing的博客
12-12 350
alias 用来设置指令的别名 补充说明 alias命令 用来设置指令的别名。我们可以使用该命令可以将一些较长的命令进行简化。使用alias时，用户必须使用单引号‘’将原来的命令引起来，防止特殊字符导致错误。 alias命令的作用只局限于该次登入的操作。若要每次登入都能够使用这些命令别名，则可将相应的alias命令存放到bash的初始化文件/etc/bashrc中。 语法 alias(选项)(参数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值