第01篇_操作系统

第01章_Shell脚本

1. 快速入门

1.1 什么是Shell?

Shell是在Linux内核的基础上编写的一个应用程序，它连接了用户和Linux内核，从而让用户能够更加便捷、高效、安全的使用Linux内核。

1.2 什么是Shell脚本?

Shell脚本就是由Shell命令组成的可执行文件，将一些命令整合到一个文件中，进行处理业务逻辑，脚本不用编译即可运行。

1.3 入门案例

一个简单的Shell脚本示例如下：

​x
1
#!/bin/bash
2
echo hello
3

可以使用./hello.sh(需要x权限)、. hello.sh、source hello.sh或sh hello.sh命令执行。

1.4 脚本调试

Shell 提供了一些用于调试脚本的选项，如：

这些选项有三种常见的使用方法：

17
1
# 1. 在命令行提供参数
2
sh -x ./script.sh
3

4
# 2. 在脚本开头提供参数
5
#! /bin/sh -x
6

7
# 3. 在脚本中用 set 命令启用或禁用参数，这样可以只对脚本中的某一段进行跟踪调试
8
#! /bin/sh
9
if [ -z "$1" ]; then
10
    # 启用-x参数
11
    set -x
12
    echo "ERROR: Insufficient Args."
13
    exit 1
14
    # 禁用-x参数
15
    set +x
16
fi
17

2. 变量与数据类型

2.1 变量类型

Shell中有三种类型的变量：

• 局部变量：在脚本或命令中定义的变量，仅在当前Shell实例中有效。
• 环境变量：可以在Shell实例之间共享的变量。
• Shell变量：由Shell程序设置的特殊变量，可以是局部变量，也可以是环境变量。

2.2 定义和使用变量

21
1
# 定义变量
2
# 注意：变量名必须以字母开头，中间没有空格(可以使用下划线)，且不能为bash的保留关键字！
3
name="hyx"
4

5
# 使用变量
6
echo $name
7
echo ${name}
8
echo ${var:-word}    # 如果变量 var 为空或已被删除(unset)，那么返回 word，但不改变var 的值
9
echo ${var:=word}    # 如果变量 var 为空或已被删除(unset)，那么返回 word，并将 var 的值设置为 word。
10
echo ${var:?message} # 如果变量 var 为空或已被删除(unset)，那么将消息 message 送到标准错误输出，可以用来检测变量 var 是否可以被正常赋值。若此替换出现在 Shell 脚本中，那么脚本将停止运行。
11
echo ${var:+word}    # 如果变量 var 被定义，那么返回 word，但不改变 var 的值。
12

13
# 变量只读
14
readonly name
15

16
# 删除变量(注意：不能删除只读变量)
17
unset name
18

19
# Local变量(只能在函数中定义和访问)
20
local name="hyx"
21

2.3 参数变量

15
1
#!/bin/bash
2
# $*演示,结果为：
3
# 1 2 3
4
for i in "$*"; do
5
    echo $i
6
done
7

8
# $@演示,结果为：
9
# 1 
10
# 2 
11
# 3
12
for i in "$@"; do
13
    echo $i
14
done
15

使用参数时一般需判断参数是否存在(注意$1需要加双引号)。

5
1
if [ -n "$1" ]; then
2
    echo "包含第一个参数"
3
else
4
    echo "没有包含第一参数"
5
fi

2.4 字符串

35
1
# 不支持转义的字符串变量(特殊的，可以跨行，即文本块)
2
str01='test'
3
echo 'abc
4
> cde'
5

6
# 支持转义的字符串变量(会解析${}变量和转义字符)
7
str02="str01 is ${str01}" 
8

9
# 转义字符
10
echo \$SHELL    # $SHELL
11
echo \\         # \
12
touch \$\ \$    # 创建一个文件名为“$ $”的文件（$间含有空格）
13
touch ./-hello  # 创建一个文件名以-号开头的文件
14
touch -- -hello # 创建一个文件名以-号开头的文件
15
ls \            # 续行
16
> -l
17

18
# 字符串拼接
19
str03="1"'2'"3"
20
str03=${str01}${str02}
21
str03="${str01}  ${str02}"
22
str03=`date`"."                 # date命令需要使用``来引用
23

24
# 获取字符串长度
25
echo ${#str02}
26

27
# 字符串截取
28
var=aabbccddaabbccdd.jpg
29
echo ${var#*bb}  # 截取第一个bb后的字符串
30
echo ${var##*bb} # 截取最后一个bb后的字符串
31
echo ${var:0:3}  # 截取第0-3位
32

33
# 查找子串
34
str="runoob is a great site"
35
echo `expr index "$str" is`  # 输出 8

2.5 数组

24
1
# 定义数组
2
arr=(1 2 3 4 5 6)
3
arr2=("abc" "def")
4

5
# 数组元素赋值
6
arr[0]=666
7
arr=(1=999 2=9999)
8

9
# 读取数组元素
10
echo ${arr[0]}
11

12
# 读取数组全部元素
13
echo ${arr[*]}
14
echo ${arr[@]}
15

16
# 数组长度
17
echo ${#arr[*]}
18

19
# 合并数组
20
echo "${arr[*]} ${arr2[*]}"
21

22
# 删除数组元素
23
unset arr[2]
24

3. 运算符

3.1 算数运算符 + - \* / % == !=

原生的bash并不支持简单的数学运算，通常要通过其它命令来实现。

27
1
a=10
2
b=20
3

4
val=`expr $a + $b`
5
echo "a + b : $val"
6

7
val=`expr $a - $b`
8
echo "a - b : $val"
9

10
val=`expr $a \* $b`
11
echo "a * b : $val"
12

13
val=`expr $b / $a`
14
echo "b / a : $val"
15

16
val=`expr $b % $a`
17
echo "b % a : $val"
18

19
if [ $a == $b ]
20
then
21
   echo "a 等于 b"
22
fi
23
if [ $a != $b ]
24
then
25
   echo "a 不等于 b"
26
fi
27

下面是其它一些可用的运算指令：

12
1
# $[]
2
echo $[$a+$b]
3

4
# $(())
5
$((var=$a+$b))
6

7
# let
8
let var=$a+$b
9

10
# bc(小数运算)
11
var=$(echo "(1.1+2.1)"|bc)
12

注意：

1. 左括号[也是一个命令，位于/usr/bin/[，在书写命令参数时注意使用空格分开。

3.2 关系运算符 -eq -gt -lt

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

39
1
a=10
2
b=20
3

4
if [ $a -eq $b ]
5
then
6
   echo "$a -eq $b : a 等于 b"
7
else
8
   echo "$a -eq $b: a 不等于 b"
9
fi
10
if [ $a -ne $b ]
11
then
12
   echo "$a -ne $b: a 不等于 b"
13
else
14
   echo "$a -ne $b : a 等于 b"
15
fi
16
if [ $a -gt $b ]
17
then
18
   echo "$a -gt $b: a 大于 b"
19
else
20
   echo "$a -gt $b: a 不大于 b"
21
fi
22
if [ $a -lt $b ]
23
then
24
   echo "$a -lt $b: a 小于 b"
25
else
26
   echo "$a -lt $b: a 不小于 b"
27
fi
28
if [ $a -ge $b ]
29
then
30
   echo "$a -ge $b: a 大于或等于 b"
31
else
32
   echo "$a -ge $b: a 小于 b"
33
fi
34
if [ $a -le $b ]
35
then
36
   echo "$a -le $b: a 小于或等于 b"
37
else
38
   echo "$a -le $b: a 大于 b"
39
fi

3.3 布尔运算符 ! -o -a

27
1
a=10
2
b=20
3

4
if [ $a != $b ]
5
then
6
   echo "$a != $b : a 不等于 b"
7
else
8
   echo "$a == $b: a 等于 b"
9
fi
10
if [ $a -lt 100 -a $b -gt 15 ]
11
then
12
   echo "$a 小于 100 且 $b 大于 15 : 返回 true"
13
else
14
   echo "$a 小于 100 且 $b 大于 15 : 返回 false"
15
fi
16
if [ $a -lt 100 -o $b -gt 100 ]
17
then
18
   echo "$a 小于 100 或 $b 大于 100 : 返回 true"
19
else
20
   echo "$a 小于 100 或 $b 大于 100 : 返回 false"
21
fi
22
if [ $a -lt 5 -o $b -gt 100 ]
23
then
24
   echo "$a 小于 5 或 $b 大于 100 : 返回 true"
25
else
26
   echo "$a 小于 5 或 $b 大于 100 : 返回 false"
27
fi

3.4 逻辑运算符 && ||

16
1
a=10
2
b=20
3

4
if [[ $a -lt 100 && $b -gt 100 ]]
5
then
6
   echo "返回 true"
7
else
8
   echo "返回 false"
9
fi
10

11
if [[ $a -lt 100 || $b -gt 100 ]]
12
then
13
   echo "返回 true"
14
else
15
   echo "返回 false"
16
fi

注意：逻辑运算具有特殊的短路功能！

3.5 字符串运算符 = != -z -n

45
1
a="abc"
2
b="efg"
3

4
if [ $a = $b ]
5
then
6
   echo "$a = $b : a 等于 b"
7
else
8
   echo "$a = $b: a 不等于 b"
9
fi
10

11
if [ $a != $b ]
12
then
13
   echo "$a != $b : a 不等于 b"
14
else
15
   echo "$a != $b: a 等于 b"
16
fi
17

18
if [ -z $a ]
19
then
20
   echo "-z $a : 字符串长度为 0"
21
else
22
   echo "-z $a : 字符串长度不为 0"
23
fi
24

25
if [ -n "$a" ]
26
then
27
   echo "-n $a : 字符串长度不为 0"
28
else
29
   echo "-n $a : 字符串长度为 0"
30
fi
31

32
if [ $a ]
33
then
34
   echo "$a : 字符串不为空"
35
else
36
   echo "$a : 字符串为空"
37
fi
38

39
a=""
40
if [ -n "$a" ]
41
then
42
   echo "-n $a : 字符串长度不为 0"
43
else
44
   echo "-n $a : 字符串长度为 0"
45
fi

3.6 文件测试运算符 -b -s -e

44
1
file="/var/www/runoob/test.sh"
2
if [ -r $file ]
3
then
4
   echo "文件可读"
5
else
6
   echo "文件不可读"
7
fi
8
if [ -w $file ]
9
then
10
   echo "文件可写"
11
else
12
   echo "文件不可写"
13
fi
14
if [ -x $file ]
15
then
16
   echo "文件可执行"
17
else
18
   echo "文件不可执行"
19
fi
20
if [ -f $file ]
21
then
22
   echo "文件为普通文件"
23
else
24
   echo "文件为特殊文件"
25
fi
26
if [ -d $file ]
27
then
28
   echo "文件是个目录"
29
else
30
   echo "文件不是个目录"
31
fi
32
if [ -s $file ]
33
then
34
   echo "文件不为空"
35
else
36
   echo "文件为空"
37
fi
38
if [ -e $file ]
39
then
40
   echo "文件存在"
41
else
42
   echo "文件不存在"
43
fi
44

扩展：文件名通配符

• *：匹配 0 个或多个任意字符，如：ls /dev/ttyS*。
• ?：匹配一个任意字符，如：ls ch0?.doc。
• [若干字符]：匹配方括号中任意一个字符的一次出现，如：ch[012] [0-9].doc。

3.7 命令执行符

6
1
# `命令`
2
echo `date`
3

4
# $(命令)
5
echo $(date)
6

4. 控制语句

4.1 if-fi

10
1
#!/bin/bash
2

3
a="check"
4

5
if [ $a == "check" ]
6
then
7
        echo "check..."
8
fi
9

10

4.2 if-else-fi

12
1
#!/bin/bash
2

3
a=10
4

5
if [ $a -eq 10 ]
6
then
7
        echo "相等"
8
else
9
        echo "不相等"
10
fi
11

12

4.3 if else-if else

15
1
#!/bin/bash
2

3
file="./t1.sh"
4

5
if [ -b $file ]
6
then
7
        echo "块设备"
8
elif [-c $file ]
9
then
10
        echo "字符设备"
11
else
12
        echo "其它文件"
13
fi
14

15

4.4 for循环

33
1
#!/bin/bash
2

3
# 遍历多个值
4
for item in 1 2 3 4 5
5
do
6
    echo "This value is $item"
7
done
8

9
# 显示主目录下以 .bash 开头的文件
10
for FILE in $HOME/.bash*
11
do
12
    echo $FILE
13
done
14

15
# 从文件中读取每行信息，并输出s
16
for Name in $(cat ./namefile)
17
do
18
    echo $Name
19
done
20

21
# 遍历数组
22
arr=("a" "b" "c" "d")
23
for item in ${arr[*]}
24
do
25
    echo $item
26
done
27

28
# 遍历数组
29
for((i=0; i<${#arr[*]}; i++))
30
do
31
    echo "arr[$i] = ${arr[$i]}"
32
done
33

4.5 while循环

8
1
#!/bin/bash
2
var=0
3
while(($var<5))
4
do
5
        echo $var
6
        let var=var+1
7
done
8

4.6 死循环

12
1
for (( ; ; ))
2

3
while :
4
do
5
    command
6
done
7

8
while true
9
do
10
    command
11
done
12

4.7 until循环

until 循环执行一系列命令直至条件为 true 时停止。

6
1
until condition
2
do
3
    command
4
done
5

6

4.8 跳出循环

30
1
#!/bin/bash
2

3
var=0
4

5
while(($var < 5))
6
do
7
        if [ $var == 3 ]
8
        then
9
                break
10
        fi
11

12
        echo $var
13
        let var=$var+1
14
done
15

16

17

18
var=0
19

20
while(($var < 5))
21
do
22
        let var=$var+1
23
        if [ $var == 3 ]
24
        then
25
                continue
26
        fi
27

28
        echo $var
29
done
30

4.9 case-esac多选择语句

32
1
var=$1
2
var=${1:-stop}
3
echo "\$1 is $var"
4

5
case $var in
6
start)
7
        echo "start..."
8
        ;;
9
stop)
10
        echo "stop..."
11
        ;;
12
*)
13
        echo "不支持的命令"
14
        ;;
15
esac
16

17
var2=${2:-10}
18
echo "\$2 is $var2"
19

20
case $var2 in
21
10)
22
        echo "this is first item."
23
        ;;
24
20)
25
        echo "this is second item."
26
        ;;
27
*)
28
        echo "other."
29
        ;;
30
esac
31

32

4.10 select-in语句

13
1
#!/bin/bash
2

3
echo "Please select..."
4

5
select var in "Linux" "Windwos" "Other"
6
do
7
        break;
8
done
9

10
echo "you have selected $var"
11

12

13

5. 函数

5.1 定义和调用函数

18
1
#!/bin/bash
2

3
# 函数定义时无需声明参数、无需声明返回值，function关键字也可以省略
4
function func01(){
5
        # 定义局部变量
6
        local var=10
7
        
8
        # 函数参数
9
        echo "参数1：$1"
10
        echo "参数2：$2"
11
        
12
        # 也可以使用echo进行返回
13
        echo "ret is $var"
14
}
15

16
result=$(func01 1 2)
17
echo $result
18

注意：

1. 当函数没有return时，默认返回最后一个命令的运行结果作为返回值。
2. $10不能返回第十个参数，当n>10的时候，需要使用$(n)来获取参数。
3. 函数内部的定义的变量在外部也可以访问，可以使用local关键字限制。

6. 重定向

6.1 重定向简介

一般情况下，每个Linux命令运行时都会打开三个文件：

• 标准输入文件(stdin)：文件描述符为0，程序默认从stdin读取数据。
• 标准输出文件(stdout)：文件描述符为1，程序默认向stdout输出数据。
• 标准错误文件(stderr)：文件描述符为2，程序会向stderr流中写入错误信息。

但有些时候我们可能需要将数据从其它文件读入或读出，这就需要我们重定向。

6.2 标准流重定向

15
1
# 输入流重定向到文件
2
command < file
3

4
# 输出流重定向到文件
5
command > file
6

7
# 错误流重定向到文件
8
command 2>file
9

10
# 输出和错误流重定向到文件
11
command > file 2>&1
12

13
# 重定向到null文件(即输出被丢弃)
14
command > /dev/null
15

7. 常用命令

7.1 echo

9
1
# 显式字符串
2
echo "It is a test"
3

4
# 换行
5
echo -e "OK! \n" # -e 开启转义
6

7
# 不换行
8
echo -e "OK! \c" # -e 开启转义 \c 不换行
9

7.2 read

read 命令用于获取键盘输入信息。

3
1
read -p "input a val:" a    #获取键盘输入的 a 变量数字
2
read -p "input b val:" b    #获取键盘输入的 b 变量数字
3
r=$[a+b]                    #计算a+b的结果 赋值给r  不能有空格

7.3 管道

可以通过 | 把一个命令的输出传递给另一个命令做输入。

3
1
cat myfile | more
2
ls -l | grep "myfile"
3
df -k | awk '{print $1}' | grep -v "文件系统"

第02章_Windows批处理

第一节基础语法

1. 什么是批处理？

批处理是使用批处理文件(Batch File，简称BAT文件)进行批量的命令处理的过程。批处理文件从内容上来看包含了大量的基本DOS命令，是一种可执行文件。批处理文件运行时会按照规则从逐一执行文件中的命令，本质上是一些命令的集合。

2. 基础DOS命令介绍

1) 文件与目录相关命令 dir...

2) 显示相关命令 echo...

3) 赋值命令 set

4) 取值命令 %%

有var=1234567890，有如下：

9
1
%var%　　　　1234567890　显示所有　　
2
%var:23=bc% 1bc4567890 替换23为bc
3
%var:~4%　　 567890　　　从第4个字符以后开始显示　　　　　　　　　
4
%var:~4,3%　 567　　　　 从第4个字符以后开始显示，并只显示前3个　　
5
%var:~-4%　　7890　　　　从倒数第4个字符开始显示　　　　　　　　　
6
%var:~-4,3%　789　　　　 从倒数第4个字符开始显示，并只显示前3个　　
7
%var:~4,-2%　5678　　　　从第4个字符以后开始显示，显示到还剩2个为止
8
%var:~0,3%　 123　　　　 从头开始显示，并只显示前3个字符　　　　　
9
%var:~0,-3%　1234567　　从头开始显示，显示到还剩3个字符为止　　　

5) 组合命令 & && ||

案例：

3
1
dir "D:\test" & echo Seems it does not exist。
2
dir "D:\test" && echo Seems it does not exist。
3
dir "D:\test" || echo Seems it does not exist.

6) 重定向命令 > >> |

>|将命令的输出进行重定向，并覆盖原有内容 >>|将命令的输出进行重定向，但不覆盖原有内容 | |将命令1的输出作为命令2的输入

管道命令还有 < 、<& 和 >& ，它们并不常见，在此暂时不讨论了。

7) 调用命令

标签的定义以:开头。批处理文件也有一些固定的标签。如:EOF

8) 其它命令

3. 参数传递

1) 输入参数

在命令行执行批处理文件时，可以传递一些参数。如：

1
1
test01.bat arg1 arg2

那么在批处理中可以通过%参数位置的方式来获取传入的参数。如：%1、%2等，值得注意的是，批处理文件最多只能传递9个参数。

test01的文件可以是如下所示：

5
1
set arg1=%1
2
set arg2=%2
3

4
echo %arg1%
5
echo %arg2%

通常的，批处理文件在头部定义一些变量，来接受外部传入的参数

2) 输出参数

输出参数一般不常用，但还是可以了解下它们。请看如下bat文件(num_add.bat)：

4
1
set /a arg1=%1
2
set /a arg2=%2
3

4
set /a %3=arg1+arg2

可以进行一个简单的加法操作，下面是一组用于测试的命令：

3
1
set /a num_val=0
2
num_add.bat 1 2 num_val
3
echo %num_val%

3) 在call/start时使用参数

有下面一个批处理文件：

13
1
@echo 开始测试...
2
call :lable1 abc
3

4
:lable2
5
echo 然后显示这句
6
pause
7

8
goto :EOF
9

10
:lable1
11
echo 首先显示这句，后面跟的参数为 %1
12
pause
13

goto命令是不可以携带参数的

第二节 流程控制

1. 条件语句 if-else

1) 基础if-else用法

if-else的基本语法格式如下：

9
1
if 条件表达式
2
(
3
    语句;
4
) 
5
else
6
(
7
    语句;
8
) 
9

再附加上一个案例，相信你一看就能明白：

7
1
if "%TIME:~0,2%" lss "12" 
2
(
3
    echo 现在是上午
4
) else 
5
(
6
    echo 现在是下午
7
)

变量 TIME 是动态环境变量之一，表示当前时间。 lss 是if命令扩展用法，表示小于的意思。更多信息可以在if/?中获得。

这里有一个小提示，为了防止出现某些意料之外的错误，请勿在if语句进行比较处加一些不必要的空格。

2) 延迟变量扩充

这是一个很有意思的特性。下面的例子可以很好的说明直接变量扩充与延迟变量扩充的区别。

15
1
@echo off
2
setlocal EnableDelayedExpansion
3

4
set /a num=5
5

6
if %num% == 5 (
7
    set /a num*=3
8

9
    echo 在 if 语句之前，变量 num 等于 %num%
10
    echo 但变量 num 在经过运算后，且由于延迟变量扩充被启用，变量 num 等于 !num!
11
)
12

13
echo 但最终变量 num 还是等于 %num%
14

15
pause

setlocal EnableDelayedExpansion 表示开启延迟变量扩充，此时的 !num! 才有意义。

3) if exist和if defined

if 还有其他的用法。其中if exist用于判断文件是否存在，就像下面这样：

5
1
if exist "D:\test my folder\a.txt" (
2
del "D:\test my folder\a.txt"
3
) else (
4
echo 您所要删除的文件不存在
5
)

在对文件进行操作之前进行判断其是否存在很有意义，这使得代码更加健壮。

而if defined也与之类似，只不过判断对象不是文件，而是变量，它用于判断环境变量是否被定义。

2. 循环语句 for-in

for-in大致有三种常用的用法，分别是作用于文件、数字、以及字符串。

1) for-in 之于文件

下面是一个批量修改文件名的批处理文件。

12
1
@echo off
2
setlocal EnableDelayedExpansion
3

4
set /p zpath=请输入目标文件所在的路径：
5
set /p prefix=请输入文件名前缀(不能包含以下字符\/:*?"<>|)：
6
set /p ext=请输入文件的扩展名(例如 .txt)：
7
set /a num=1
8

9
for %%i in (%zpath%\*%ext%) do (
10
    ren "%%i" "%prefix%!num!.%ext%"
11
    set /a num+=1
12
)

%%i表示迭代变量。值得注意的是，在批处理文件中(而不是命令行)，必须使用双%来标识。

2) for-in 之于数字

如果想对一系列有规律的数字进行循环，或是在一定的次数内对某个操作进行循环重复的执行，使用 for 也能够实现。下面是一个很好的例子：

14
1
@echo off
2
setlocal EnableDelayedExpansion
3

4
set var=￥
5
for /l %%i in (1,1,7) do set var=%var%!var!
6
rem 此时变量 var 已经变成一行连续的8个￥了
7

8
for /l %%i in (1,1,8) do (
9
    echo 这是第 %%i 份>输出结果%%i.txt
10
    for /l %%j in (1,1,8) do echo %var%>>输出结果%%i.txt
11
)
12

13
echo 8 X 8 的 ￥ 矩阵已经画好，并保存到8份文本文件里了
14
pause

/l 是可以跟在 for 后面的重要参数之一。用于标识作用于数字的for-in循环。in中的三个值分为为起始值、步长和结束值。

3) for-in 之于字符串

for 也可以对指定范围内的文字进行循。for 后面跟参数 /f ，/f 后面跟选项，所指定的范围 in 里可以是一个文件里的文字，可以是一个字符串，也可以是一条命令的输出结果。我们首先以一个文件里的文字作为循环对象，循环时，每一行将被循环一次。

29
1
@echo off
2
echo 测试 文字筛选.txt 里每一行的首单词
3
for /f %%i in (文字筛选.txt) do echo %%i
4
pause
5

6
echo.
7
echo skip=2 表示前两行被跳过
8
for /f "skip=2" %%i in (文字筛选.txt) do echo %%i
9
pause
10

11
echo.
12
echo tokens=2,4-6 表示提取每行的第2个、以及第4到6个单词
13
for /f "skip=2 tokens=2,4-6" %%i in (文字筛选.txt) do echo %%i, %%j, %%k, %%l.
14
pause
15

16
echo.
17
echo eol=N 表示当此行的首字母为 N 时，就忽略该行
18
for /f "eol=N skip=2 tokens=2,4-6" %%i in (文字筛选.txt) do echo %%i, %%j, %%k, %%l.
19
pause
20

21
echo.
22
echo delims=e 表示不再以空格区分每个词，而是以字母 e 作为间隔
23
for /f "eol=N skip=2 tokens=2,4-6 delims=e" %%i in (文字筛选.txt) do echo %%i, %%j, %%k, %%l.
24
pause
25

26
echo.
27
echo usebackq 表示双引号里的东西是文件名而不是字符串
28
for /f "usebackq eol=N skip=2 tokens=2,4-6 delims=e" %%i in ("文字筛选.txt") do echo %%i, %%j, %%k, %%l.
29
pause

作为测试，可以在上述批处理文件的同一路径下创建一个用于测试的文本文件 文字筛选.txt ，其内容为：

5
1
Hello there!
2
This text is an example of test for the batch file 文字筛选.bat.
3
Notice the first letter in this line, N.
4
If the eol charactor was set to be letter N.
5
The third line will not be considered by the batch.

3. 跳转语句 goto call

goto和call可以无条件的改变命令的执行顺序。下面是一个使用goto的案例

12
1
@echo off
2
goto :FirstLable
3

4
:SecondLable
5
echo 然后显示这句
6
pause
7
goto :EOF
8

9
:FirstLable
10
echo 首先显示这句
11
pause
12
goto :SecondLable

call与goto的使用方式类似，但call执行完后依然会回到call之前的位置继续执行剩下的代码，案例可以参考上章节。