函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
#这里不再应用file变量
if [ $? -eq 0 ];then
echo "
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
exists."
else
echo "
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
doesn"t exist."
fi
function check(){
if [ -e
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
j=
let "tmp=i+j"
return $tmp
}
add
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here $$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
is 1
Here is 2
Here is 3
Here is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now $1 is:
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
..$n:第n个参数，当n大于10时，要将n用()括起来
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
"
until [ $# -eq 0 ]
do
echo "Now $1 is:
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
];then
echo "File:
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
exists"
else
echo "File:
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist
函数
定义：
1、无返回值
#function为症结字，FUNCTION_NAME为函数名
function FUNCTION_NAME(){
command1
command2
...
}
省略症结字function，后果一样
FUNCTION_NAME(){
command
....
}
例：
1、简略函数声明和调用
#!/bin/bash
function sayHello(){
echo "Hello World!"
}
sayHello
注意：
1、sayHello调用的时候没有(),sayHello()这样的调用会出错。
2、如果先调用再声明，则调用和声明之间不能有其他语句
2、盘算文件的行数
#!/bin/bash
if [[ $# -lt 1 ]];then
echo "Please input a filename."
return
fi
file=$1
countLine
function countLine(){
local line=0
while read
do
let "line++";
done < $file
echo "$file has $line lines."
}
2、函数的返回值
return
获得返回值的重要方法是$?
例：
#检测文件是不是存在
#!/bin/bash
file=$1
check
if [ $? -eq 0 ];then
echo "$file exists."
else
echo "$file doesn"t exist."
fi
function check(){
if [ -e $file ];then
return 0
else
return 1
fi
}
3、带参数的函数
1、地位参数
这个和高等语言不一样，在函数声明里没有指定参数，而是直接在函数体里应用，调用的时候直接传入参数便可
例：
1、检测文件是不是存在
#!/bin/bash
check $1 #这里不再应用file变量
if [ $? -eq 0 ];then
echo "$1 exists."
else
echo "$1 doesn"t exist."
fi
function check(){
if [ -e $1 ];then #函数体里的参数
return 0
else
return 1
fi
}
2、盘算两数之和
#!/bin/bash
function add(){
local tmp=0
i=$1
j=$2
let "tmp=i+j"
return $tmp
}
add $1 $2
echo "$?"
2、指定地位参数值
应用set内置命令给脚本指定地位参数的值（又叫重置）。一旦应用set设置了传入参数的值，脚本将疏忽运行时传入的地位参数（实际上是被set
重置了地位参数的值）
例：
#!/bin/bash
set 1 2 3 4
count=1
for var in $@
do
echo "Here \$$count is $var"
let "count++"
done
注意：输入时不管有多少参数都重置为四个参数。
如：
. ./function03.sh a b c d e f
成果：
Here $1 is 1
Here $2 is 2
Here $3 is 3
Here $4 is 4
注意：有甚么意义？
3、移动地位参数
回想：
shift，在不加任何参数的情形下，这个命令可以将地位参数向左移动一名。
例：
#!/bin/bash
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift
done
注意：活用地位参数，
$@/$*:所有参数
$1..$n:第n个参数，当n大于10时，要将n用()括起来
$0:脚本本身
当用‘.’履行脚本时为bash
当用bash履行脚本时返回的文件名
当用./scriptname履行时返回./scriptname
$#:所有参数
扩大
指定左移的位数，shift n
例：
#!/bin/bash
echo "$0"
until [ $# -eq 0 ]
do
echo "Now \$1 is:$1,total paramert is:$#"
shift 2
done
注意：如果输入命令时指定了奇数个参数，则脚本会堕入逝世重复。
4、函数库
为了和普通函数区分，在实践中，建议库函数应用下划线(_)开头
加载库函数：
1、应用"点"(.)命令
2、应用source命令
例：
1、树立函数库
实际上就是写一个都是函数的脚本篇文章件
例：树立库lib01.sh
function _checkFileExist(){
if [ -e $1 ];then
echo "File:$1 exists"
else
echo "File:$1 doesn"t exists"
fi
}
2、应用
#!/bin/bash
#source ./lib01.sh
. ./lib01.sh
_checkFileExist $1
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
体系函数库：
/etc/init.d/functions（我的体系是ubuntu，没看到这个文件）
一个27个函数
函数
定义：
1、无返回值
#function为症结
阅读背景：
shell学习笔记之八（函数）
来源：互联网
分享到：
