来源：reliveIT的专栏
一、概述
环境变量：bash shell用一个称作“环境变量（environment variables）”的特性来存储有关shell会话和工作环境的信息，它允许你在内存中存储数据，以便运行在shell上的程序和脚本访问，这些数据可以用来识别用户、账户、系统、shell特性以及任何其他你需要存储的数据。
shell中的环境变量有全局环境变量和局部环境变量，通过KV（variable=value）的形式声明一个局部变量，export这个局部变量，则升级成为全局环境变量。既然shell分开来用，显然两者有区别，下面分开来讨论。
1. 全局环境变量
特性：声明一个全局环境变量，在当前shell进程以及子shell进程中可用，父shell进程中不可用，这里的“可用”可以理解成父shell进程全局环境变量的一个copy，而不是继承父类的全局环境变量两者共用一份，因此子shell进程中对父shell进程的全局环境变量进行增、删、该、查均无影响。
证明一：1）全局变量在当前shell可用、子shell可用，但是父shell进程不可用；2）子shell copy了父shell进程的全局环境变量的副本，因此子shell对变量的操作对父类透明
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/bin/bash
#父shell进程
#
1
. 声明一个全局环境变量
#
2
. fork一个子shell进程
# 在子shell进程中可以访问父类定义的全局变量
# 在子shell中修改或删除（unset）父类定义的全局环境变量，对父进程没有影响
# 在子shell中增加一个全局环境变量，父类中是访问不到的
#
3
. 父shell进程中访问被子shell进程修改或删除的全局环境变量，该变量值未改变
#
4
. 父shell进程访问子类增加的子类全局环境变量：结果是访问不到
export testing=
"zhangsan"
echo
"father定义了一个全局变量，初始值为：testing=zhangsan"
sh son.sh
echo
"father访问被子类修改的全局变量：$testing"
echo
"father访问子类增加的全局变量：$sonTest"
|
|
1
2
3
4
5
6
7
8
|
#!/bin/bash
#子shell进程
echo
"son访问父类shell进程中定义的全局变量：$testing"
testing=
"son zhangsan"
echo
"son修改了父类的全局变量：testing=$testing"
export sonTest=
"son lizi"
echo
"son增加了子类全局变量：$sonTest"
|
|
1
2
3
4
5
6
7
|
[work
@localhost
global]$ sh father.sh
father定义了一个全局变量，初始值为：testing=zhangsan
son访问父类shell进程中定义的全局变量：zhangsan
son修改了父类的全局变量：testing=son zhangsan
son增加了子类全局变量：son lizi
father访问被子类修改的全局变量：zhangsan
father访问子类增加的全局变量：
|
证明二：登录shell fork一个子shell进程，该子shell进程export一个全局环境变量，执行完成后在登录shell中没有该变量
|
1
2
3
4
5
6
7
|
#!/bin/bash
#登录shell fork一个子shell进程
# 子shell进程声明一个全局环境变量
# 子shell执行完成之后，退出到登录shell
# 登录shell访问不到该变量
export userName=
"zhangsan"
|
|
1
2
3
4
|
[work
@localhost
global]$ sh var.sh
[work
@localhost
global]$ echo $userName
[work
@localhost
global]$
|
2. 局部环境变量
特性：当前shell进程可用，父、子shell进程不可用
证明：父进程定义局部变量，子进程访问不到；子进程定义局部变量，父进程访问不到
|
1
2
3
4
5
6
|
#!/bin/bash
fatherVar=
"father var"
echo
"father定义的局部变量：$fatherVar"
sh son.sh
echo
"son定义的局部变量：$sonVar"
|
|
1
2
3
4
5
|
#!/bin/bash
echo
"son访问fanther定义的局部变量：$fatherVar"
sonVar=
"son var"
echo
"son定义的局部变量：$sonVar"
|
|
1
2
3
4
5
|
[work
@localhost
local]$ sh father.sh
father定义的局部变量：father var
son访问fanther定义的局部变量：
son定义的局部变量：son var
son定义的局部变量：
|
3. 总结
1. 全局环境变量：当前shell进程及子进程可用，父shell进程不可用，子进程对变量的修改对当前shell来说透明无影响；
2. 局部环境变量：当前shell进程可用，父进程、子进程均不可用；
3. 环境变量存在内存当中，断电后消失，如果想要在下一次系统加电后还可以访问：
a. 如果这个变量是系统级别的（所有用户共享），则可以在/etc/profile中export；
b. 如果这个变量只对当前用户有效，则可以在~/.bash_profile（或者~./bash_login，或者~./profile，或者~./bashrc，或者/etc/bashrc）中export；
补充：本节讨论主要是fork进程方式，不包括source和exec，三种方式的差异在后面进行讨论；
二、启动shell
环境变量存放在内存当中，断电后消失。但是你会发现类似USER、PATH、LOGNAME、HOSTNAME这些环境变量，只要系统一启动就存在了。这是为什么？
操作系统因该具备至少5个功能：内存管理、文件系统管理、进程管理、设备管理（硬件）和用户接口管理，这里的用户接口不能理解成init 5启动界面功能或类似windows的界面，而是用户和系统内核交互的接口，即内核提供给外界的一组访问接口，所以在系统启动的时候，启动shell就是为此而生，他向用户提供了一组和Linux kernel交互的接口。
启动shell随着系统的启动而启动，根据表现可以将其理解成后续登录shell、交互shell、非交互shell的顶级父shell环境，因此在启动shell中声明的全局环境变量，后续的所有shell都可以访问到，毫无疑问，局部变量例外。
启动shell启动之后，他首先会到/etc/profile中读取命令并执行，读取执行该文件，主要做了两件事：
1. 定义并 声明全局的环境变量，export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL，所有的shell进程都可以访问到这些变量；
2. 到/etc/profile.d目录中执行该目录下的应用启动文件，这个目录集中存放了一些应用的启动文件，这些应用随着系统启动而启动，譬如vim、less等，类似于windows中的启动项中定义的一些开机自运行的软件；
/etc/profile.d目录下的内容和/etc/profile的内容如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
# /etc/profile
# System wide environment and startup programs,
for
login setup
# Functions and aliases go in /etc/bashrc
# It's NOT a good idea to change
this
file unless you know what you
# are doing. It's much better to create a custom.sh shell script in
# /etc/profile.d/ to make custom changes to your environment, as
this
# will prevent the need
for
merging in future updates.
pathmunge () {
case
":${PATH}:"
in
*:
"$1"
:*)
;;
*)
if
[
"$2"
=
"after"
] ; then
PATH=$PATH:$
1
else
PATH=$
1
:$PATH
fi
esac
}
if
[ -x /usr/bin/id ]; then
if
[ -z
"$EUID"
]; then
# ksh workaround
EUID=`id -u`
UID=`id -ru`
fi
USER=
"`id -un`"
LOGNAME=$USER
MAIL=
"/var/spool/mail/$USER"
fi
# Path manipulation
if
[
"$EUID"
=
"0"
]; then
pathmunge /sbin
pathmunge /usr/sbin
pathmunge /usr/local/sbin
else
pathmunge /usr/local/sbin after
pathmunge /usr/sbin after
pathmunge /sbin after
fi
HOSTNAME=`/bin/hostname
2
>/dev/
null
`
HISTSIZE=
1000
if
[
"$HISTCONTROL"
=
"ignorespace"
] ; then
export HISTCONTROL=ignoreboth
else
export HISTCONTROL=ignoredups
fi
JAVA_HOME=/usr/java/jdk1.
7
.0_75
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
PATH=$PATH:$JAVA_HOME/bin
export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL
# By
default
, we want umask to get set. This sets it
for
login shell
# Current threshold
for
system reserved uid/gids is
200
# You could check uidgid reservation validity in
# /usr/share/doc/setup-*/uidgid file
if
[ $UID -gt
199
] && [
"`id -gn`"
=
"`id -un`"
]; then
umask
002
else
umask
022
fi
for
i in /etc/profile.d/*.sh ;
do
if
[ -r
"$i"
]; then
if
[
"${-#*i}"
!=
"$-"
]; then
.
"$i"
else
.
"$i"
>/dev/
null
2
>&
1
fi
fi
done
unset i
unset -f pathmunge
|
三、登录shell
无论是哪一个用户登录系统，printenv打印的全局环境变量都是一样的，因为这些值在启动shell中定义完成。但是你会发现，实际上存在不一样，这会给人造成错觉，进而无法理解登录shell的真正含义。
1. 区别启动shell和登录shell
系统启动完成之后，紧接着就是用户登录访问了。不同的用户登录系统，printenv的结果是不一样的，也就是说不同的用户有不同的的shell进程环境，这也间接说明登录shell和启动shell是不一样，登录shell是顶级环境。先来验证一下，再来进行说明。
验证一：不同用户登录，其全局环境变量不一样，此处选择root和work用户，测试全局环境变量PATH
步骤一：work账户登录，echo $PATH > /home/work/var.path
步骤二：切换用户以及环境到root，su - root，echo $PATH >> /home/work/var.path
步骤三：cat /home/work/var.path，比较两行值，执行结果如下所示
|
1
2
3
4
5
6
7
|
[work
@localhost
~]$ echo $PATH > /home/work/xx.path
[work
@localhost
~]$ su - root
Password:
[root
@localhost
~]# echo $PATH >> /home/work/xx.path
[root
@localhost
~]# cat /home/work/xx.path
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/usr/java/jdk1.
7
.0_75/bin:/home/work/bin
/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/usr/java/jdk1.
7
.0_75/bin:/root/bin
|
2. 登录shell详解
登录shell在启动shell之上又加入了个性化，不同用户获得的登录环境是不一样的。除root用户之外，Linux上其他用户的主目录是/home/xxx，要进行个性化，必然在此做文章。
登录shell的入口，~/.bash_profile文件。
a. .bash_profile文件
当你输入用户名和密码登录系统的时候，启动shell进程会fork一个登录shell进程，这个登录shell进程会到当前登录用户的主目录下顺序读取（如果存在）文件~/.bash_profile、~/.bash_login、~/.profile 中的指令并执行，需要注意的是这三个文件不一定都存在（我的系统centos 2.6.32中就只存在.bash_profile），如果存在多个，则按照列出顺序进行读取指令并执行。
读取到.bash_profile主要做了两件事情，一件是source（最后一节会有source的详解）~/.bashrc这个文件，另一件是重新export PATH，详细内容如下。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# .bash_profile
# Get the aliases and functions
if
[ -f ~/.bashrc ]; then
. ~/.bashrc
fi
# User specific environment and startup programs
PATH=$PATH:$HOME/bin
export PATH
|
b. .bashrc文件
由此，可知不同用户的环境变量PATH不一致的原因。但是source ~/.bashrc这个文件又做了什么事情？
.bashrc文件也做了两件事，一件是定义一些别名（定义别名，你可以在当前shell中任意使用，类似定义局部环境变量），另一件事是source了/etc/bashrc文件。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# .bashrc
# User specific aliases and functions
alias rm=
'rm -i'
alias cp=
'cp -i'
alias mv=
'mv -i'
# Source global definitions
if
[ -f /etc/bashrc ]; then
. /etc/bashrc
fi
|
c. /etc/bashrc文件
/etc/bashrc又TM的做了什么事情？在/etc/bashrc文件中也做了两件事情，一件事情是定义了一些局部变量（没有export，登录shell可用，其fork的子shell均不能访问），还根据UID设置了umask的权限；另一件事情是又读取并执行了一次/etc/profile.d目录下的文件，这一步和启动shell有重复，虽然看似重复但实际上是有必要的原因，这里了需要和交互shell（下一节讲解）结合。
至此，用户登录环境初始化完成，所有用户公共的全局变量有了，不同用户个性化的全局变量也准备好了，和自己有关系的局部变量也准备好了，万事俱备，用户可以进行系统操作了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
# /etc/bashrc
# System wide functions and aliases
# Environment stuff goes in /etc/profile
# It's NOT a good idea to change
this
file unless you know what you
# are doing. It's much better to create a custom.sh shell script in
# /etc/profile.d/ to make custom changes to your environment, as
this
# will prevent the need
for
merging in future updates.
# are we an interactive shell?
if
[
"$PS1"
]; then
if
[ -z
"$PROMPT_COMMAND"
]; then
case
$TERM in
xterm*)
if
[ -e /etc/sysconfig/bash-prompt-xterm ]; then
PROMPT_COMMAND=/etc/sysconfig/bash-prompt-xterm
else
PROMPT_COMMAND=
'printf "\033]0;%s@%s:%s\007" "${USER}" "${HOSTNAME%%.*}" "${PWD/#$HOME/~}"'
fi
;;
screen)
if
[ -e /etc/sysconfig/bash-prompt-screen ]; then
PROMPT_COMMAND=/etc/sysconfig/bash-prompt-screen
else
PROMPT_COMMAND=
'printf "\033]0;%s@%s:%s\033\\" "${USER}" "${HOSTNAME%%.*}" "${PWD/#$HOME/~}"'
fi
;;
*)
[ -e /etc/sysconfig/bash-prompt-
default
] && PROMPT_COMMAND=/etc/sysconfig/bash-prompt-
default
;;
esac
fi
# Turn on checkwinsize
shopt -s checkwinsize
[
"$PS1"
=
"\\s-\\v\\\$ "
] && PS1=
"[\u@\h \W]\\$ "
# You might want to have e.g. tty in prompt (e.g. more virtual machines)
# and console windows
# If you want to
do
so, just add e.g.
#
if
[
"$PS1"
]; then
# PS1=
"[\u@\h:\l \W]\\$ "
# fi
# to your custom modification shell script in /etc/profile.d/ directory
fi
if
! shopt -q login_shell ; then # We're not a login shell
# Need to redefine pathmunge, it get's undefined at the end of /etc/profile
pathmunge () {
case
":${PATH}:"
in
*:
"$1"
:*)
;;
*)
if
[
"$2"
=
"after"
] ; then
PATH=$PATH:$
1
else
PATH=$
1
:$PATH
fi
esac
}
# By
default
, we want umask to get set. This sets it
for
non-login shell.
# Current threshold
for
system reserved uid/gids is
200
# You could check uidgid reservation validity in
# /usr/share/doc/setup-*/uidgid file
if
[ $UID -gt
199
] && [
"`id -gn`"
=
"`id -un`"
]; then
umask
002
else
umask
022
fi
# Only display echos from profile.d scripts
if
we are no login shell
# and interactive - otherwise just process them to set envvars
for
i in /etc/profile.d/*.sh;
do
if
[ -r
"$i"
]; then
if
[
"$PS1"
]; then
.
"$i"
else
.
"$i"
>/dev/
null
2
>&
1
fi
fi
done
unset i
unset pathmunge
fi
|
四、交互shell
init 3登录系统之后，你在命令行界面输入的指令实际上都是在登录shell的环境中执行，你可以访问登录shell中声明的任意局部变量。但是当你输入bash显式启动一个交互shell的时候（命令行界面给你的感觉是敲了一下回车，剩下的好像什么也没发生），你会发现粗大事了，还是在一模一样的界面，但是你发现访问不了刚才可以访问到的局部变量了。这是因为登录shell fork了一个子shell的环境，而子shell环境是不能访问父shell环境的局部变量的。
1. 区别登录shell和交互shell
证明一：交互shell不是登录shell，而是登录shell fork的一个子shell进程
步骤一：登录系统后，定义一个局部变量testing="zhangsan"，命令行输入echo $testing，测试可以访问得到；
步骤二：命令行输入bash启动一个交互shell，访问刚才定义的局部变量，echo $testing，测试不可以访问；
步骤三：命令行输入exit指令，退出交互式shell，再次访问echo $testing，发现可以访问；
|
1
2
3
4
5
6
7
8
9
10
11
|
[work
@localhost
~]$ testing=
"zhangsan"
[work
@localhost
~]$ echo $testing
zhangsan
[work
@localhost
~]$ bash
[work
@localhost
~]$ echo $testing
[work
@localhost
~]$ exit
exit
[work
@localhost
~]$ echo $testing
zhangsan
[work
@localhost
~]$
|
2. 交互shell详解
当你在命令行输入bash指令显式进入交互式shell环境的时候，系统发生了什么？不像启动shell和登录shell，交互式shell没有发生在系统启动的时候，也没有发生在用户登录的时候，这时候系统已经启动，用户已经登录，之前的读取的文件执行的指令和结果都已经在内存中存在了，那么交互式shell做了那些事情呢？
交互shell是登录shell的子进程，因此他拥有了登录shell声明的所有全局环境变量（当然也拥有启动shell声明的全局环境变量），但是他没有登录shell声明的局部变量，也没有登录shell声明的一些个性化例如umask、alias等，那么当前用户没有任何理由开启一个交互式shell，个性化丢失，每次开启都要重新搞一遍个性化，太TM麻烦了，这种功能你用吗？有毛用啊？
请不要激动，存在即合理。
交互式shell启动第一步，就是检查当前用户的主目录下是否有.bashrc文件（这个文件上一节有详细的描述），存在则读取并执行文件中的指令。这个文件的作用不就是声明局部变量和个性化配置的的吗？他第一步就是定义别名等，然后source /etc/bashrc文件，/etc/bashrc文件一开始定义了用户的局部变量，接着又加载并执行了/etc/profile.d目录下的应用启动文件。
你会惊奇的发现，开启一个交互shell，和一个刚刚登录的登录shell环境一模一样！干净、纯粹、原始，就像少女一样啊！激动吧？！还有更激动的事情，不要忘了，子shell可以访问父shell的全局环境变量，但是父shell不能访问子shell的环境，也就意味着你在交互式shell中所做的坏事永远不会影响到父shell环境（当然你不要手贱去改配置文件，改了配置文件就是持久化了操作内容，而不是更改内存内容，系统断电后再启动加载文件还是会还原出来的），当然如果想父shell环境也能感受到，则需要修改文件了。
实际上你也能感受到，登录shell其实就是第一个交互shell，一问一答，用户问系统答，很友好啊，有求必应！
五、非交互shell
非交互shell就没有那么友好了，这也正是非交互shell存在的核心价值，不需要用户来干预，自动完成脚本中规定的指令。
因此，简单来说，非交互shell，即是执行shell脚本。
当然，非交互式shell作为交互shell fork出来的子进程，拥有父进程所有的全局环境变量（再次申明：不拥有父进程的局部环境变量，你在脚本中是访问不到的），他不会再像交互shell那样到用户主目录下去读取执行.bashrc文件给自己做个性化，最简单直接的例子就是ls的alias指令ll，你在脚本中使用该指令，就会收到”run.sh: line 3: ll: command not found“的错误提示，如以下代码示例。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
[work
@localhost
env]$ alias -p |grep ll
alias ll=
'ls -l --color=auto'
[work
@localhost
env]$ cat run.sh
#!/bin/bash
ll
[work
@localhost
env]$ sh run.sh
run.sh: line
3
: ll: command not found
[work
@localhost
env]$ echo $?
127
[work
@localhost
env]$ ll
total
16
drwxrwxr-x.
2
work work
4096
Apr
23
06
:
56
alias
drwxrwxr-x.
2
work work
4096
Apr
23
05
:
43
global
drwxrwxr-x.
2
work work
4096
Apr
23
05
:
59
local
-rw-rw-r--.
1
work work
16
Apr
23
07
:
59
run.sh
|
要想对非交互是shell进行个性化，系统也提供了”接口“，就是环境变量BASH_ENV，当启动一个非交互式shell的时候，系统会检查这个环境变量来查看要加载执行的启动文件，因此你可以自定义一个文件路径然后export BASH_ENV，从而达到你想要的目的和结果，这也是传说中的BASH_ENV漏洞，但是这个漏洞在2014.09月被修复了，在此就不再进行赘述了。
1）BASH_ENV漏洞简单利用：点击打开链接
2）BASH_ENV漏洞修复介绍：点击打开链接
六、fork、source和exec
shell编程的时候，往往不会把所有功能都写在一个脚本中，这样太不好维护了，需要多个脚本文件协同工作。那么问题来了，在一个脚本中怎么调用其他的脚本呢？有三种方式，分别是fork、source和exec。
1. fork
fork其实最麻烦，他是从当前shell进程中fork一个子shell进程来完成调用，上文所述的所有情况都是fork调用形式，简单总结，就是父shell进程的全局环境变量copy一份给子shell进程，因为是拷贝，所以子shell进程对这一份变量的所有操对父shell进程无影响，父进程的局部变量不会被子shell进程访问到；子shell的全局环境变量自对自己和自己的子shell进程有用，对父shell进程屏蔽，子shell的局部变量也只对当前shell进程有效。
另外，fork调用其实就是在一个脚本中调用另一个脚本，被调用脚本执行完成之后返回给父shell进程，父shell进程继续执行剩下的指令，其中所涉及的庆幸上文已经基本全部覆盖，此处演示一下fork调用的示例代码。
|
1
2
3
4
5
|
#!/bin/bash
echo
"父shell进程开始执行"
sh son.sh #父shell fork子shell环境执行另一个脚本
echo
"父shell进程执行完毕"
|
|
1
2
3
|
#!/bin/bash
echo
"子shell被调用"
|
|
1
2
3
4
|
[work
@localhost
fork]$ sh father.sh
父shell进程开始执行
子shell被调用
父shell进程执行完毕
|
2. source
source调用，是把被调用脚本加载到当前的shell环境中来执行，就好像是在一个脚本里面运行一样，他们的定义的局部变量共享，在同一个进程中，如以下示例。
|
1
2
3
4
5
|
#!/bin/bash
. ./son.sh #通过source方式将son.sh加载到当前shell环境中
echo
"father访问son中定义的局部变量：$sonVar"
|
|
1
2
3
4
|
#!/bin/bash
sonVar=
"son var"
echo
"son定义了一个变量：sonVar=$sonVar"
|
|
1
2
3
|
[work
@localhost
source]$ sh father.sh
son定义了一个变量：sonVar=son var
father访问son中定义的局部变量：son var
|
3. exec
exec调用，也是fork一个子shell环境来执行被调用脚本，但是父shell环境的执行权会被剥夺，也就是执行权被交给了被调用脚本，父shell环境不再拥有执行权，无论父shell脚本中的指令是否执行完成，都不在被执行，随着子shell进程的结束而结束。
|
1
2
3
4
5
|
#!/bin/bash
echo
"父shell开始执行"
exec sh son.sh
echo
"父shell完成执行，但是这句话不会被执行"
|
|
1
2
3
|
#!/bin/bash
echo
"子shell被父shell exec调用，执行权已经被抢占过来了，不会在交回给父shell进程"
|
|
1
2
3
|
[work
@localhost
exec]$ sh father.sh
父shell开始执行
子shell被父shell exec调用，执行权已经被抢占过来了，不会在交回给父shell进程
|
关于fork、source和exec网上已经有很多介绍了，要是这里没有看明白，可以搜索“fork、source和exec”。
七、环境变量PATH
什么是环境变量PATH？这个环境变量，在调用shell脚本的时候很有用，麻烦和问题也主要集中在这里，PATH环境变量定义了各种shell环境搜索执行指令的路径，就像windows上的path环境变量一样。执行自己写的脚本，如果你不想进入到脚本目录或者输入全路径，那么你直接把你的脚本拷贝到PATH下面的任意一个目录即可，但是这样太侵入了，不优雅，下面简单介绍一种比较优雅的开发技巧。
开发技巧：便捷执行指令
通过软连接和别名alias来让自定义脚本可以在当前shell环境中任意被调用。
第一步：查看PATH环境变量，随便选一个当前用户有操作权限的一个出来，本处选择/home/work/bin
第二步：写一个测试脚本run.sh，放在/home/work/shell/myCodes目录下，里面只有一句指令”echo $0"打印当前执行脚本名称，然后做一个软连接ln -s /home/work/shell/myCodes/run.sh /home/work/bin/run
第三步：定义别名，先alias -p看一下，不要定义重复了，然后定义别名alias run="sh run"，完成
结果：你不用在进入到脚本所在的目录执行脚本，在任意目录执行run指令就可以调用/home/work/shell/myCodes/run.sh脚本，而且支持tab键补全，是不是很NB！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
[work
@localhost
myCodes]$ ls
run.sh
[work
@localhost
myCodes]$ cat run.sh
#!/bin/bash
echo $
0
[work
@localhost
myCodes]$ pwd
/home/work/shell/myCodes
[work
@localhost
myCodes]$ cat run.sh
#!/bin/bash
echo $
0
[work
@localhost
myCodes]$ ll /home/work/bin/run
lrwxrwxrwx.
1
work work
31
Apr
23
09
:
57
/home/work/bin/run -> /home/work/shell/myCodes/run.sh
[work
@localhost
myCodes]$ alias -p |grep run
alias run=
'run'
[work
@localhost
myCodes]$ cd /home/work/
[work
@localhost
~]$ run
i'm bash_env
/home/work/bin/run
|
166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
