awk [选项] '程序' [文件...]

/pattern/ { action }

BEGIN { action }
/pattern/ { action }
END { action }

# 创建基本的测试文件
cat > awk_test.txt << 'EOF'
Alice 85 90 95
Bob 75 80 85
Charlie 90 95 100
David 60 65 70
EOF

# 创建CSV格式文件
cat > data.csv << 'EOF'
name,age,city,salary
Alice,28,New York,80000
Bob,32,Boston,95000
Charlie,45,Chicago,120000
David,36,San Francisco,110000
EOF

# 创建日志文件示例
cat > app.log << 'EOF'
2024-02-01 10:05:23 INFO User login: alice
2024-02-01 10:07:34 ERROR Database connection failed
2024-02-01 10:10:12 INFO User logout: alice
2024-02-01 11:15:45 INFO User login: bob
2024-02-01 14:30:22 WARNING Disk usage high (85%)
EOF

# 示例1：使用程序分析器
# 创建一个简单的awk程序文件
cat > analyze_program.awk << 'EOF'
BEGIN { print "Starting analysis" }
{ 
    sum += $2 
    if ($2 > max) max = $2
    if ($2 < min || NR == 1) min = $2
}
END { 
    print "Sum:", sum
    print "Avg:", sum/NR
    print "Max:", max
    print "Min:", min
}
EOF

# 使用分析器运行程序
awk --profile -f analyze_program.awk awk_test.txt

# 查看生成的分析报告
# cat awkprof.out

# 示例2：命名空间的使用
cat > namespace_example.awk << 'EOF'
@namespace "math";

function add(a, b) {
    return a + b
}

function multiply(a, b) {
    return a * b
}

@namespace "string";

function add(a, b) {
    return a b  # 字符串连接
}

@namespace "";

{ 
    # 访问不同命名空间的函数
    print "Math sum:", math::add($2, $3)
    print "String concat:", string::add($1, ": ")
}
EOF

# 运行命名空间示例
# awk -f namespace_example.awk awk_test.txt

# 示例3：使用调试器（交互式，这里仅展示命令）
# awk --debug -f analyze_program.awk awk_test.txt
# 调试命令示例:
# break BEGIN  # 在BEGIN块设置断点
# run          # 运行程序
# print sum    # 打印变量值
# next         # 执行下一条语句
# quit         # 退出调试器

# 示例4：沙箱模式的使用
# 创建一个包含潜在危险操作的脚本
cat > sandbox_test.awk << 'EOF'
{ 
    print "Processing:", $0
    # 尝试执行系统命令（在沙箱模式下会被禁止）
    # system("echo \\"This could be dangerous\\"")
    # 尝试读取其他文件（在沙箱模式下会被禁止）
    # getline < "/etc/passwd"
}
EOF

# 使用沙箱模式运行
# awk -S -f sandbox_test.awk awk_test.txt

# 示例5：使用lint选项检查程序问题
cat > lint_test.awk << 'EOF'
{ 
    # 可疑的构造：使用未初始化变量
    print "Total:", total + $2
    # 使用gawk扩展功能
    if (match($0, /[0-9]{2,3}/, arr)) {
        print "Found number:", arr[0]
    }
}
EOF

# 使用lint选项检查
# awk --lint -f lint_test.awk awk_test.txt
# 使用lint=fatal使警告成为错误
# awk --lint=fatal -f lint_test.awk awk_test.txt

# 示例6：使用--dump-variables检查变量
# 创建一个使用多个变量的程序
cat > var_dump_test.awk << 'EOF'
BEGIN {
    counter = 0
    threshold = 85
}
{ 
    counter++
    if ($2 > threshold) {
        high_scores++
    }
    total += $2
}
END {
    avg = total / counter
    print "Results calculated"
}
EOF

# 运行并导出变量信息
# awk --dump-variables=vars.out -f var_dump_test.awk awk_test.txt
# 查看变量信息
# cat vars.out

# 示例7：处理非十进制数据
cat > hex_oct_test.txt << 'EOF'
Decimal: 100
Hex: 0x64
Octal: 0144
EOF

# 启用非十进制数据识别
# awk -n '{ print $1, "value:", $2 + 0 }' hex_oct_test.txt

# 示例8：使用pretty-print格式化程序
# 创建一个格式混乱的程序
cat > messy_program.awk << 'EOF'
BEGIN{print "Start"} {if($2>80){print $1" passed"}else{print $1" failed"}} END{print "Done"}
EOF

# 格式化程序
# awk --pretty-print=formatted.awk -f messy_program.awk
# 查看格式化后的程序
# cat formatted.awk

# 示例9：生成国际化模板文件
cat > i18n_program.awk << 'EOF'
BEGIN {
    print "欢迎使用awk程序"
    print "This is an awk program"
}
{ 
    printf "处理第%d行: %s\n", NR, $0
}
END {
    print "程序执行完毕"
    print "Program completed"
}
EOF

# 生成.pot文件
# awk --gen-pot -f i18n_program.awk > program.pot
# 查看生成的模板文件
# cat program.pot


## 3. 基本使用方法

### 3.1 打印整个文件

最简单的`awk`命令是打印整个文件的内容：

```bash
# 打印整个文件内容
awk '{ print }' awk_test.txt

# 等价于
awk '{ print $0 }' awk_test.txt

# 打印每行的第一个字段
awk '{ print $1 }' awk_test.txt

# 打印每行的第一个和第三个字段
awk '{ print $1, $3 }' awk_test.txt

# 使用不同的输出分隔符
awk '{ print $1 " - " $3 }' awk_test.txt

# 使用逗号作为分隔符
awk -F, '{ print $1, $4 }' data.csv

# 使用多个字符作为分隔符（使用正则表达式）
awk -F'[, ]' '{ print $1, $3 }' data.csv

# 使用多个可能的分隔符
awk -F'[:; ]' '{ print $1 }' /etc/passwd

# 使用BEGIN块设置标题，END块计算总数
awk 'BEGIN { print "Name\tTotal" } { total = $2 + $3 + $4; print $1 "\t" total } END { print "-----------------\nDone processing" }' awk_test.txt

# 计算文件中的行数
awk 'END { print "Total lines: " NR }' awk_test.txt

# 匹配包含"Bob"的行
awk '/Bob/ { print }' awk_test.txt

# 匹配以"A"开头的行
awk '/^A/ { print }' awk_test.txt

# 匹配以数字结尾的行
awk '/[0-9]$/ { print }' awk_test.txt

# 打印第二个字段大于80的行
awk '$2 > 80 { print }' awk_test.txt

# 打印第一个字段等于"Alice"的行
awk '$1 == "Alice" { print }' awk_test.txt

# 打印第三个字段不等于90的行
awk '$3 != 90 { print }' awk_test.txt

# 逻辑与：打印第二个字段大于80且第三个字段小于95的行
awk '$2 > 80 && $3 < 95 { print }' awk_test.txt

# 逻辑或：打印第一个字段是"Alice"或"Bob"的行
awk '$1 == "Alice" || $1 == "Bob" { print }' awk_test.txt

# 逻辑非：打印第一个字段不是"David"的行
awk '$1 != "David" { print }' awk_test.txt

# 匹配从包含"Alice"的行到包含"Charlie"的行
awk '/Alice/,/Charlie/ { print }' awk_test.txt

# 匹配从第1行到第3行
awk 'NR >= 1 && NR <= 3 { print }' awk_test.txt

# 变量类型转换示例
awk 'BEGIN {
    # 未初始化变量
    print "Uninitialized variable:"  
    print "Numeric value:", uninitialized + 0  # 输出0
    print "String value:", uninitialized ""   # 输出空字符串
    
    # 强制类型转换
    num = "123.45"
    str = 678.90
    
    print "\nType conversion:"
    print "Force numeric:", num + 0      # 输出123.45
    print "Force string:", str ""       # 输出678.9
    
    # CONVFMT控制数字到字符串的转换
    print "\nCONVFMT effect:"
    CONVFMT = "%.2f"
    a = 12
    b = a ""  # 即使CONVFMT设置为%.2f，整数仍会转换为整数形式
    print "Integer conversion:", b  # 输出12
    
    c = 12.345
    d = c ""  # 使用CONVFMT格式
    print "Float conversion:", d  # 输出12.35
}'

# 示例1：未初始化变量的布尔值
awk 'BEGIN{print i}'             # 输出空字符串（未初始化变量）
awk 'BEGIN{print !i}'            # 输出1（!空字符串 = 真）

# 示例2：数字的布尔值
awk -v i=3 'BEGIN{print i}'      # 输出3（非零数字）
awk -v i=3 'BEGIN{print !i}'     # 输出0（!非零数字 = 假）
awk -v i=-3 'BEGIN{print !i}'    # 输出0（!负数 = 假，因为负数是非零数字）

# 示例3：字符串的布尔值
awk -v i="abc" 'BEGIN{print i}'  # 输出abc（非空字符串）
awk -v i="abc" 'BEGIN{print !i}' # 输出0（!非空字符串 = 假）

# 示例4：空格字符串的特殊处理
awk -v 'i=" "' 'BEGIN{print !i}' # 输出0（!空格字符串 = 假，因为空格字符串是非空的）
awk -v i=' ' 'BEGIN{print !i}'    # 输出0（同上，单引号中的空格字符串也是非空的）

# 示例5：空字符串的布尔值
awk -v i='' 'BEGIN{print !i}'     # 输出1（!空字符串 = 真）

# 示例6：未定义变量与字符串字面量的区别
# 以下命令不输出任何内容，因为'aaa'被视为未定义变量（值为空字符串，布尔值为假）
awk 'aaa{print $1,$3}' awk.txt  

# 以下命令正常输出，因为"aaa"是字符串字面量（非空字符串，布尔值为真）
awk '"aaa"{print $1,$3}' awk.txt

# 更多对比示例
awk '""{print $1,$3}' awk.txt    # 空字符串字面量为假，无输出
awk '" "{print $1,$3}' awk.txt   # 空格字符串字面量为真，有输出
awk '0{print $1,$3}' awk.txt      # 数字0为假，无输出
awk -v n=8 'n{print $1,$3}' awk.txt # 变量n=8（非零数字）为真，有输出

# 命名空间示例
awk 'BEGIN {
    # 使用默认命名空间（awk）
    var1 = "global variable"
    
    # 定义带命名空间的变量
    myns::var2 = "in my namespace"
    
    # 访问命名空间变量
    print "Default namespace variable:", var1
    print "myns namespace variable:", myns::var2
    
    # 切换当前命名空间
    @namespace "myns"
    
    # 现在直接定义的变量属于myns命名空间
    var3 = "in current namespace"
    
    # 访问不同命名空间的变量
    print "Current namespace variable:", var3
    print "Default namespace variable:", awk::var1
    
    # 大写变量始终属于awk命名空间
    UPPERCASE = "uppercase in awk namespace"
    print "UPPERCASE in awk namespace:", awk::UPPERCASE
}'

# 八进制和十六进制常量示例
awk 'BEGIN {
    # 八进制常量
    octal = 011  # 十进制9
    # 十六进制常量
    hex = 0x11   # 十进制17
    
    print "Octal 011 = decimal", octal
    print "Hex 0x11 = decimal", hex
    print "Sum =", octal + hex
}'

# 字符串转义序列示例
awk 'BEGIN {
    # 基本转义序列
    print "Newline:\nTab:\tBackslash:\\"
    print "Alert(beep):\a"
    print "Backspace:\b"
    print "Form-feed:\f"
    print "Carriage return:\r"
    print "Vertical tab:\v"
    
    # 打印包含引号的字符串
    print "String with \"quotes\""
    
    # 十六进制转义序列（最多两位十六进制数字）
    print "\nHex escape sequence:"
    print "ESC character (\x1B):", "\x1B"
    print "ASCII 65 (A):", "\x41"
    
    # 八进制转义序列（1-3位八进制数字）
    print "\nOctal escape sequence:"
    print "ESC character (\033):", "\033"
    print "ASCII 65 (A):", "\101"
    
    # 字面字符转义
    print "\nLiteral character escape:"
    print "Backslash: \\c where c is any character"
}'

# 正则表达式常量示例
awk 'BEGIN {
    # 基本正则表达式匹配
    print "Basic regex matching:"
    text = "Hello, World!"
    if (text ~ /World/) {
        print "Text contains 'World'"
    }
    
    # 正则表达式中的转义序列
    print "\nRegex with escape sequences:"
    whitespace = "Line1\nLine2\tLine3"
    gsub(/[ \t\f\n\r\v]+/, ", ", whitespace)
    print "Normalized whitespace:", whitespace
    
    # gawk强类型正则表达式常量（使用@前缀）
    print "\ngawk strongly typed regex constants:"
    
    # 创建强类型正则表达式变量
    number_regex = @/[0-9]+/
    word_regex = @/[a-zA-Z]+/
    
    # 使用强类型正则表达式
    test_text = "abc123def"
    
    if (test_text ~ number_regex) {
        print "Text contains numbers"
    }
    
    if (test_text ~ word_regex) {
        print "Text contains words"
    }
    
    # 将正则表达式作为参数传递给函数
    function check_pattern(str, pattern) {
        if (str ~ pattern) {
            return "Match found"
        } else {
            return "No match"
        }
    }
    
    print "Check with number pattern:", check_pattern("42 is the answer", number_regex)
    print "Check with word pattern:", check_pattern("Only words here", word_regex)
}'

# 基本模式-动作结构
# 模式缺失：对每一行执行动作
awk '{ print $1 }' awk_test.txt

# 动作缺失：等同于 { print }
awk '/Alice/' awk_test.txt

# 完整的模式-动作
awk '$2 > 80 { print $1 " passed" }' awk_test.txt

# 语句分隔符和行继续符
awk 'BEGIN { print "Start"; count=0 } { count++ } END { print "Total:", count }' awk_test.txt

# 使用反斜杠进行行继续
awk 'BEGIN { \
    print "Multi-line\nstatement" \
}'

# BEGIN和END模式示例
awk 'BEGIN {
    print "Student Grades Report"
    print "====================="
    sum = 0
    count = 0
} {
    # 处理每一行
    sum += $2
    count++
    print $1 ": " $2
} END {
    print "====================="
    print "Average: " sum / count
}' awk_test.txt

# BEGINFILE和ENDFILE模式示例
cat > file1.txt << 'EOF'
Line 1 in file1
Line 2 in file1
EOF

cat > file2.txt << 'EOF'
Line 1 in file2
Line 2 in file2
EOF

# 使用BEGINFILE和ENDFILE处理多个文件
awk 'BEGINFILE {
    print "\nProcessing file: " FILENAME
    # 检查文件是否成功打开
    if (ERRNO) {
        print "Error opening file: " ERRNO
        nextfile  # 跳过无法打开的文件
    }
    file_count++
} {
    line_count++
} ENDFILE {
    print "Lines in " FILENAME ": " FNR
} END {
    print "\nTotal files processed: " file_count
    print "Total lines processed: " line_count
}' file1.txt file2.txt nonexistent.txt

# 正则表达式模式示例
awk '/^A/' awk_test.txt  # 匹配以A开头的行
awk '/9$/' awk_test.txt  # 匹配以9结尾的行
awk '/[0-9]{2,3}/' awk_test.txt  # 匹配包含2-3位数字的行

# 使用变量作为正则表达式
awk 'BEGIN { pattern = "Bob"; } $0 ~ pattern { print }' awk_test.txt

# 实际应用示例：处理系统文件/etc/passwd
# 示例1：匹配用户名以"ro"开头的用户，并显示用户名和登录shell
awk -F: '$1~"^ro"{print $1,$7}' /etc/passwd
# 输出示例：
# root /bin/bash

# 示例2：匹配用户名包含"ftp"的用户，并显示整行信息
awk -F":" '$1~"ftp"{print $0}' /etc/passwd
# 输出示例：
# ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin

# 示例3：匹配用户名包含非小写字母字符的用户（如数字、连字符等）
awk -F":" '$1~"[^a-z]"{print $0}' /etc/passwd
# 输出示例（包含系统用户和带数字的用户）：
# systemd-coredump:x:999:999:systemd Core Dumper:/:/sbin/nologin
# test1:x:1001:1001:test1 user for testing:/home/test1:/bin/bash

# 重要区别：!~ 操作符 vs [^...] 字符类否定
# !~ 操作符：表示整个字符串不匹配正则表达式
awk -F: '$1!~"[a-r]"{print $0}' /etc/passwd
# 输出示例：
# tss:x:59:59:Account used for TPM access:/:/usr/sbin/nologin
# 说明：只有当用户名中完全不包含a到r之间的任何字符时才匹配

# [^...] 字符类否定：表示字符串中包含至少一个不在字符类中的字符
awk -F: '$1~"[^a-r]"{print $0}' /etc/passwd
# 输出示例：
# root:x:0:0:root:/root:/bin/bash
# sync:x:5:0:sync:/sbin:/bin/sync
# shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
# 说明：只要用户名中包含至少一个不在a到r之间的字符（如s、t、u等）就匹配

# 核心区别总结：
# - $1!~"[a-r]"：要求整个用户名中没有a-r之间的任何字符
# - $1~"[^a-r]"：只要求用户名中至少有一个字符不是a-r之间的字符

# 关系表达式模式示例
awk '$2 > 80' awk_test.txt  # 第二个字段大于80
awk '$1 == "Alice"' awk_test.txt  # 第一个字段等于Alice
awk 'NF >= 3' awk_test.txt  # 字段数大于等于3
awk '$0 !~ /error/i' app.log  # 不包含error（忽略大小写）

# 逻辑运算符组合模式
awk '$2 > 80 && $3 > 85' awk_test.txt  # 逻辑与：第二个字段>80且第三个字段>85
awk '$1 == "Alice" || $1 == "Bob"' awk_test.txt  # 逻辑或：名字是Alice或Bob
awk '!($1 ~ /^D/)' awk_test.txt  # 逻辑非：不以D开头

# 使用括号改变优先级
awk '$2 > 80 && ($3 > 85 || $4 > 90)' awk_test.txt

# 三元运算符作为模式示例
awk 'NF > 2 ? NR > 1 : NR < 3 { print }' awk_test.txt
# 说明：如果字段数>2，则打印行号>1的行；否则打印行号<3的行

# 创建测试文件
cat > awk.txt << 'EOF'
nihao awk1 awk2 awk3 
nihao awk4 awk5 awk6 
nihao awk7 awk8 awk9 
EOF

# 测试1：n初始值为0，使用n作为模式（假值，不执行默认打印）
awk -v n=0 'n' awk.txt 
# 输出：（无输出）

# 测试2：n初始值为0，使用++n作为模式（前缀自增）
awk -v n=0 '++n' awk.txt 
# 输出：
# nihao awk1 awk2 awk3 
# nihao awk4 awk5 awk6 
# nihao awk7 awk8 awk9 

# 测试3：n初始值为0，使用n++作为模式（后缀自增）
awk -v n=0 'n++' awk.txt 
# 输出：
# nihao awk4 awk5 awk6 
# nihao awk7 awk8 awk9 

# 范围模式示例
# 匹配从包含Alice的行到包含Charlie的行
awk '/Alice/,/Charlie/' awk_test.txt

# 使用数值范围
awk 'NR >= 2 && NR <= 4' awk_test.txt

# 注意：范围模式不能与其他模式组合
# 下面的写法是错误的：awk '/Alice/,/Charlie/ && $2 > 80' awk_test.txt

# 可以使用变量来模拟复杂的范围条件
awk 'BEGIN { in_range = 0 } 
     /Alice/ { in_range = 1 }
     in_range && $2 > 80 { print }
     /Charlie/ { in_range = 0 }' awk_test.txt

# 创建一个包含空白字符行的文件示例
cat > zhengli.txt << 'EOF'
 	`http://www.sswang.org/index.html`
   	`http://www.sswang.org/1.html`
  	`http://api.sswang.org/index.html`
asdfasdfsd
 	adfsdf
EOF

# 执行以下命令会得到意外的结果
awk '/^[ \t]*/{print NR"----->"$1}' zhengli.txt

# 示例文件内容
cat awk.txt
# 输出:
# nihao awk1 awk2 awk3 
# nihao awk4 awk5 awk6 
# nihao awk7 awk8 awk9 

# 命令1：使用多个分号
awk 'i=1;j=1;{print $1,$3}' awk.txt
# 输出:
# nihao awk1 awk2 awk3 
# nihao awk1 awk2 awk3 
# nihao awk2 
# nihao awk4 awk5 awk6 
# nihao awk4 awk5 awk6 
# nihao awk5 
# nihao awk7 awk8 awk9 
# nihao awk7 awk8 awk9 
# nihao awk8 

# 命令2：减少一个分号
awk 'i=1;j=1{print $1,$3}' awk.txt
# 输出:
# nihao awk1 awk2 awk3 
# nihao awk2 
# nihao awk4 awk5 awk6 
# nihao awk5 
# nihao awk7 awk8 awk9 
# nihao awk8 

# 方法1：使用BEGIN块设置变量
awk 'BEGIN{i=1;j=1}{print $1,$3}' awk.txt

# 方法2：在动作块内设置变量
awk '{i=1;j=1;print $1,$3}' awk.txt

# 方法3：如果确实需要模式和动作，使用正确的分隔方式
awk 'i=1 && j=1 {print $1,$3}' awk.txt

# 方法1：修改FS为空字符串，这样每个字符都成为一个字段
awk 'BEGIN{FS=""}/^[ \t]*/{print NR"----->"$0}' zhengli.txt

# 方法2：直接使用$0获取整行内容（推荐）
awk '/^[ \t]*/{print NR"----->"$0}' zhengli.txt

# 方法3：使用gensub函数保留原始格式
awk '/^[ \t]*/{print NR"----->"$0}' zhengli.txt

# 打印行号和字段数
awk '{ print "Line", NR, ":", NF, "fields" }' awk_test.txt

# 使用FS和OFS变量
awk 'BEGIN { FS=","; OFS=" - " } { print $1, $2, $3 }' data.csv

# 使用FIELDWIDTHS处理固定宽度字段
# 创建一个固定宽度格式的测试文件
cat > fixed_width.txt << 'EOF'
John    28   Engineer
Alice   32   Designer
Bob     45   Manager
EOF

# 使用FIELDWIDTHS分隔固定宽度字段
awk 'BEGIN { FIELDWIDTHS="10 5 10" } { print "Name:", $1, "Age:", $2, "Job:", $3 }' fixed_width.txt

# 使用FPAT处理复杂格式（匹配字段而不是分隔符）
# 创建一个复杂格式的测试文件
cat > complex_data.txt << 'EOF'
{name:"John", age:28, role:"Engineer"}
{name:"Alice", age:32, role:"Designer"}
{name:"Bob", age:45, role:"Manager"}
EOF

# 使用FPAT提取字段内容
awk 'BEGIN { FPAT="[a-zA-Z]+" } { print "Name:", $2, "Role:", $6 }' complex_data.txt

# 使用ENVIRON数组访问环境变量
awk 'BEGIN {
    # 访问HOME环境变量
    print "Home directory:", ENVIRON["HOME"]
    # 访问PATH环境变量
    print "PATH:", ENVIRON["PATH"]
    # 访问当前用户环境变量（根据不同系统可能有所不同）
    print "Current user:", ENVIRON["USER"] || ENVIRON["USERNAME"]
}'

# 创建测试文件
cat > awk.txt << 'EOF'
nihao awk1 awk2 awk3 
nihao awk4 awk5 awk6 
nihao awk7 awk8 awk9 
EOF

# 测试NR==0的情况（不会执行）
awk 'NR==0{print ARGV[0],ARGV[1]}' awk.txt

# 测试NR==2的情况（第2行执行）
awk 'NR==2{print ARGV[0],ARGV[1]}' awk.txt
# 输出: awk awk.txt

# 测试NR==3的情况（第3行执行）
awk 'NR==3{print ARGV[0],ARGV[1]}' awk.txt
# 输出: awk awk.txt

# 测试NR==4的情况（空行，不会执行）
awk 'NR==4{print ARGV[0],ARGV[1]}' awk.txt

# 查看ARGC的值
awk 'NR==1{print ARGC}' awk.txt
# 输出: 2

# 直接在程序中定义变量
awk 'BEGIN { count=0 } { count++ } END { print "Total lines:", count }' awk_test.txt

# 使用-v参数在命令行定义变量
awk -v threshold=85 '$2 > threshold { print $1 " scored above threshold" }' awk_test.txt

# 正确：字符串值使用双引号
awk 'BEGIN{name="soveran";print name}'
# 输出: soveran

# 错误：字符串值未使用引号（会被当作未定义变量）
awk 'BEGIN{name=soveran;print name}'
# 输出: (空)

# 正确：直接使用变量名
awk 'BEGIN{name="soveran";print name}'
# 输出: soveran

# 错误：使用$引用变量（$name会被解释为字段引用）
awk 'BEGIN{name="soveran";print $name}'
# 输出: (空)

# 在命令行使用-v定义变量
awk -v "name=soveran" 'BEGIN{print name}'
# 输出: soveran

# 主程序块中也可使用
awk -v "name=soveran" '{print name}' input.txt
# 每行都会输出: soveran

# 正确：使用多个-v选项定义多个变量
awk -v "name=soveran" -v "address=shanghai" 'BEGIN{print name,address}'
# 输出: soveran shanghai

# 错误：尝试在一个-v选项中使用分号分隔多个变量
awk -v "name=soveran;address=shanghai" 'BEGIN{print name,address}'
# 输出: soveran;address=shanghai  (整个字符串被当作一个变量值)

# 错误：没有为第二个变量使用-v选项
awk -v "name=soveran" "address=shanghai" 'BEGIN{print name,address}'
# 错误: cannot open file `BEGIN{print name,address}' for reading

# 在BEGIN块中使用分号定义多个变量
awk 'BEGIN{name="soveran";address="shanghai";print name, address;}'
# 输出: soveran shanghai

# 没有输入数据，主程序块不会执行
awk '{i=10;print i++,i}'
# 没有输出

# 提供输入数据后，主程序块会执行
# echo提供一行空输入
 echo | awk '{i=10;print i++,i}'
# 输出: 10 11

# 后缀递增：先使用变量值，再递增
 echo | awk '{i=10;print i++,i}'
# 输出: 10 11

# 前缀递增：先递增变量值，再使用
 echo | awk '{i=10;print ++i,i}'
# 输出: 11 11

# 后缀递减：先使用变量值，再递减
 echo | awk '{i=10;print i--,i}'
# 输出: 10 9

# 前缀递减：先递减变量值，再使用
 echo | awk '{i=10;print --i,i}'
# 输出: 9 9

# BEGIN块不需要输入即可执行
awk 'BEGIN{i=0;print i++,i}'
# 输出: 0 1

awk 'BEGIN{i=0;print ++i,i}'
# 输出: 1 1

# 错误示例：在BEGIN块中尝试访问字段引用会导致语法错误
awk -F: 'BEGIN{length($1)==4{i++;print $1}}' /etc/passwd
# 报错: awk: 命令行:1: BEGIN{length($1)==4{i++;print $1}}
# 报错: awk: 命令行:1:                    ^ syntax error

# 正确示例：在主程序块中访问字段引用
awk -F: '{if(length($1)==4){i++;print $1}}' /etc/passwd

# 正确示例：在BEGIN块初始化变量，在主程序块处理数据
awk -F: 'BEGIN{i=0}{if(length($1)==4){i++;print $1}}' /etc/passwd

# 首先查看awk.txt文件内容
cat awk.txt
# 输出:
# nihao awk1 awk2 awk3
# nihao awk4 awk5 awk6
# nihao awk7 awk8 awk9

awk -v n=0 'n++' awk.txt
# 输出:
# nihao awk4 awk5 awk6
# nihao awk7 awk8 awk9

awk -v n=0 '!n++' awk.txt
# 输出:
# nihao awk1 awk2 awk3

# 数值到字符串的转换
awk 'BEGIN{num=123; print "The number is " num}'
# 输出: The number is 123

# 字符串到数值的转换（如果可能）
awk 'BEGIN{str="456"; print str + 100}'
# 输出: 556

# 使用变量间接访问字段
awk 'BEGIN{i=2} {print $(i)}' input.txt
# 输出每行的第2个字段

# 在BEGIN块中定义和访问数组
awk 'BEGIN{array[0]=100;print array[0]}'
# 输出: 100

# 使用字符串作为索引
awk 'BEGIN{array["name"]="soveran";print array["name"]}'
# 输出: soveran

# 常见的数组创建误区 - 以下不会创建数组
# 错误1: 括号语法在awk中不是数组定义方式
# awk 'BEGIN{v=("aa","bb",12,34); print isarray(v)}'  # 语法错误

# 错误2: 字符串连接不会创建数组
awk 'BEGIN{v="aa" "bb" 12 34; print isarray(v)}'  # 返回0，v是字符串"aabb1234"

# 正确: 通过索引逐个赋值创建数组
awk 'BEGIN{arr[1]="aa"; arr[2]="bb"; arr[3]=12; arr[4]=34; print isarray(arr)}'  # 返回1

# 初始化多个数组元素
awk 'BEGIN{
    array[0]=100;
    array[1]=200;
    array["two"]=300;
    array["three"]=400;
    # 访问并打印数组元素
    print array[0], array[1], array["two"], array["three"];
}'
# 输出: 100 200 300 400

# 遍历数组中的所有元素
awk 'BEGIN{
    array["name"]="soveran";
    array["age"]=30;
    array["city"]="shanghai";
    # 使用for循环遍历
    for(i in array){
        print i ": " array[i];
    }
}'
# 输出类似:
# name: soveran
# age: 30
# city: shanghai
# (注意：遍历顺序可能因awk实现而异)

# 统计字段出现的次数
echo -e "apple\norange\napple\nbanana\napple" | awk '{count[$1]++} END {for(fruit in count) print fruit ": " count[fruit]}'"
# 输出:
# apple: 3
# orange: 1
# banana: 1

# 存储唯一值
echo -e "a\nb\na\nc\nb" | awk '{seen[$1]=1} END {for(item in seen) print item}'
# 输出:
# a
# b
# c

# 删除数组元素
awk 'BEGIN{
    array["a"]=1;
    array["b"]=2;
    delete array["a"];  # 删除特定元素
    print "a:" array["a"], "b:" array["b"];  # 删除的元素值为空
}'
# 输出: a: b: 2

# 删除整个数组
awk 'BEGIN{
    array["a"]=1;
    array["b"]=2;
    delete array;  # 删除整个数组
    print "a:" array["a"], "b:" array["b"];  # 所有元素都为空
}'
# 输出: a: b: 

# 基本用法：输出字段和自定义变量
awk -F: '{age=36;address="shanghai"; print $1,age,address}' passwd.txt
# 输出类似: root 36 shanghai

# 修改OFS改变字段分隔符
awk -F: 'BEGIN{OFS=":"} {age=36;address="shanghai"; print $1,age,address}' passwd.txt
# 输出类似: root:36:shanghai

# 组合字符串和变量
awk -F: '{age=36;address="shanghai"; print "User:", $1, "is", age, "years old, from", address}' passwd.txt
# 输出类似: User: root is 36 years old, from shanghai

# 基本格式化输出
awk -F: '{age=36;address="shanghai"; printf "%-10s %3d %s\n", $1, age, address}' passwd.txt
# 输出类似: root         36 shanghai

# 更复杂的格式化
awk -F: '{age=36;address="shanghai"; printf "User %s is %d years old and lives in %s\n", $1, age, address}' passwd.txt
# 输出类似: User root is 36 years old and lives in shanghai

# 表格形式输出
awk -F: 'BEGIN {printf "%-15s %-8s %-20s\n", "USERNAME", "AGE", "ADDRESS"; printf "------------------------------------------\n"} {age=36;address="shanghai"; printf "%-15s %-8d %-20s\n", $1, age, address}' passwd.txt
# 输出格式化表格

# 使用修饰符的示例
awk 'BEGIN {printf "%10s | %-10s | %05d | %.2f\n", "right", "left", 123, 45.6789}'
# 输出:      right | left       | 00123 | 45.68

# 根据字段值改变格式
awk -F: '{age=36;address="shanghai"; if ($3 < 1000) {printf "[SYSTEM] %s\n", $1} else {printf "[USER] %s\n", $1}}' passwd.txt

# 交替行格式
awk -F: '{age=36;address="shanghai"; if (NR % 2 == 0) {printf "%s\t%s\t%s\n", $1, age, address} else {printf "%s|%s|%s\n", $1, age, address}}' passwd.txt

# 添加标题和统计信息
awk -F: 'BEGIN {printf "%-15s %-8s %-20s\n", "USERNAME", "AGE", "ADDRESS"; printf "------------------------------------------\n"} {age=36;address="shanghai"; printf "%-15s %-8d %-20s\n", $1, age, address; count++} END {printf "------------------------------------------\n"; printf "Total users: %d\n", count}' passwd.txt

# 彩色输出示例
awk -F: 'BEGIN {printf "\033[1;34m%-15s %-8s %-20s\033[0m\n", "USERNAME", "AGE", "ADDRESS"} {age=36;address="shanghai"; if (NR % 2 == 0) {printf "\033[32m%-15s %-8d %-20s\033[0m\n", $1, age, address} else {printf "%-15s %-8d %-20s\n", $1, age, address}}' passwd.txt

awk -F "[ ]+" 'BEGIN{printf "---------------------------\n|%-3s|%2s|%2s|%2s|%2s|\n---------------------------\n","姓名","语文","数学","历史","总分"}NR>=1{yu+=$2;shu+=$3;li+=$4;total+=$2+$3+$4;printf "|%-3s|%4d|%4d|%4d|%4d|\n",$1,$2,$3,$4,$2+$3+$4}END{printf "---------------------------\n|合计 |%4d|%4d|%4d|%4d|\n学生总数: %2d\n",yu,shu,li,total,NR}' course_score.txt

awk -F "[ ]+" 'NR>=1{
    # 累加计算每个班级的各科总分
    class_yu[$1] += $3
    class_shu[$1] += $4
    class_li[$1] += $5
    class_total[$1] += $3+$4+$5
    # 记录每个班级的学生数
    class_count[$1]++
}
END{
    # 输出每个班级的统计信息
    printf "班级成绩统计:\n"
    printf "------------------------------------------\n"
    printf "%-8s | %4s | %4s | %4s | %4s | %2s\n", "班级", "语文", "数学", "历史", "总分", "人数"
    printf "------------------------------------------\n"
    for(class in class_yu){
        printf "%-8s | %4d | %4d | %4d | %4d | %2d\n", \
               class, class_yu[class], class_shu[class], \
               class_li[class], class_total[class], class_count[class]
    }
}' course_score_class.txt

# 使用数学函数
awk 'BEGIN { print "Square root of 25:", sqrt(25) }'
awk 'BEGIN { print "Sine of 90 degrees:", sin(3.14159/2) }'
awk 'BEGIN { print "Random number:", rand() }'

# 计算平均值
awk '{ sum += $2 } END { print "Average:", sum/NR }' awk_test.txt

# 字符串长度
awk '{ print $1, "length:", length($1) }' awk_test.txt

# 字符串匹配
awk 'BEGIN { if (match("Hello World", "World")) print "Found at position:", RSTART }'

# 字符串截取
awk 'BEGIN { print substr("Hello World", 7, 5) }'  # 输出"World"

# 字符串替换
awk 'BEGIN { print gensub("World", "Linux", "g", "Hello World") }'

# 基本数组操作
awk 'BEGIN {
    # 创建数组
    fruits["apple"] = "red"
    fruits["banana"] = "yellow"
    fruits["grape"] = "purple"
    
    # 访问数组元素
    print "Apple is", fruits["apple"]
    
    # 遍历数组
    for (fruit in fruits) {
        print fruit, "is", fruits[fruit]
    }
}

# 数组的简单定义和直接访问
# 定义一个包含三个科目的成绩数组并访问每个元素
awk 'BEGIN{array["yuwen"]=78;array["shuxue"]=89;array["lishi"]=99;print array["yuwen"],array["shuxue"],array["lishi"]}'
# 执行结果: 78 89 99

# 使用for...in循环遍历数组
# 遍历数组并依次打印每个元素的值
awk 'BEGIN{array["yuwen"]=78;array["shuxue"]=89;array["lishi"]=99;for(i in array){print array[i]}}'
# 执行结果:
# 78
# 89
# 99

# 从文件读取数据到数组
# 读取passwd.txt文件的前6个字段到数组
awk -F:'{for(i=1;i<NF;i++){array[i]=$i};for(j in array){print array[j]}}' passwd.txt
# 执行结果类似:
# root
# x
# 0
# 0
# root
# /root

# 数组去重原理
# awk数组去重是利用关联数组的特性，将数据作为数组的键，出现次数作为值

# 假设array.txt文件内容为:
#  a 
#  b 
#  a 
#  cc 

# 示例1: 只输出重复行的最后一次出现
awk 'array[$0]++' array.txt
# 执行结果: a
# 详细工作原理（基于实际文件内容分析）:
# 1. 处理第一行" a "时：
#    - array[" a "]初始值为0（awk中未定义的数组元素默认值为0）
#    - 表达式array[$0]++的值是0（后置递增，先返回原值再自增）
#    - 0在awk中被视为假，所以不打印该行
#    - array[" a "]变为1
#
# 2. 处理第二行" b "时：
#    - array[" b "]初始值为0
#    - 表达式array[$0]++的值是0，被视为假，不打印该行
#    - array[" b "]变为1
#
# 3. 处理第三行" a "时：
#    - array[" a "]当前值为1
#    - 表达式array[$0]++的值是1，被视为真，所以打印该行
#    - array[" a "]变为2
#
# 4. 处理第四行" cc "时：
#    - array[" cc "]初始值为0
#    - 表达式array[$0]++的值是0，被视为假，不打印该行
#    - array[" cc "]变为1
#
# 所以最终只打印了重复出现的" a "行（第三行）

# 示例2: 输出所有不重复的行（真正的去重）
awk '!array[$0]++' array.txt
# 执行结果:
#  a 
#  b 
#  cc 
# 详细工作原理（基于实际文件内容分析）:
# 1. 处理第一行" a "时：
#    - array[" a "]初始值为0
#    - !array[$0]的值是!0=1（真），所以打印该行
#    - 然后执行++操作，array[" a "]变为1
#
# 2. 处理第二行" b "时：
#    - array[" b "]初始值为0
#    - !array[$0]的值是!0=1（真），所以打印该行
#    - 然后执行++操作，array[" b "]变为1
#
# 3. 处理第三行" a "时：
#    - array[" a "]当前值为1
#    - !array[$0]的值是!1=0（假），所以不打印该行
#    - 然后执行++操作，array[" a "]变为2
#
# 4. 处理第四行" cc "时：
#    - array[" cc "]初始值为0
#    - !array[$0]的值是!0=1（真），所以打印该行
#    - 然后执行++操作，array[" cc "]变为1
#
# 所以最终打印了所有首次出现的行，实现了去重效果

# 数组统计计数示例
# 使用awk多字符分隔符和数组统计字符出现次数
awk -F'[.,]' '{for(i=1;i<=NF;i++)a[$i]++}END{for(v in a)print v,a[v]}'

# 详细工作原理（以输入"a.b.c,c.d"为例）：
# 1. 分隔符设置：-F'[.,]' 指定以点(.)和逗号(,)作为分隔符
#    - 输入字符串"a.b.c,c.d"会被分隔为："a", "b", "c", "c", "d"
#
# 2. 主处理块中的循环：{for(i=1;i<=NF;i++)a[$i]++}
#    - NF表示当前记录的字段数（这里为5个字段）
#    - 遍历每个字段（$1到$5）
#    - 以字段内容作为数组a的索引，将对应的值加1
#    - 处理过程：
#      * 第一次迭代：a["a"] = 1
#      * 第二次迭代：a["b"] = 1
#      * 第三次迭代：a["c"] = 1
#      * 第四次迭代：a["c"] = 2
#      * 第五次迭代：a["d"] = 1
#
# 3. END块中的循环：{for(v in a)print v,a[v]}
#    - 遍历数组a的所有索引v
#    - 打印索引和对应的值（出现次数）
#    - 输出结果：
#      a 1
#      b 1
#      c 2
#      d 1
#
# 这个示例展示了awk如何高效地进行数据统计，尤其适用于日志分析、文本处理中的频率统计场景

# 使用in运算符检查数组索引
awk 'BEGIN {
    arr["key"] = "value"
    if ("key" in arr) {
        print "Key exists: ", arr["key"]
    }
    # 删除数组元素
    delete arr["key"]
    if (! ("key" in arr)) {
        print "Key no longer exists"
    }
}

### 6.3 多维数组

#### 6.3.1 模拟多维数组

传统的awk通过SUBSEP分隔符模拟多维数组，SUBSEP默认为ASCII控制字符\034（^\）：

```bash
# 模拟多维数组（使用SUBSEP）
awk 'BEGIN {
    # 创建多维数组
    i = "A"; j = "B"; k = "C"
    x[i, j, k] = "hello, world\n"
    
    # 直接访问
    print x[i, j, k]
    
    # 检查多维索引是否存在
    if ((i, j, k) in x) {
        print "Multidimensional index exists"
    }
    
    # 使用SUBSEP构建键
    key = i SUBSEP j SUBSEP k
    print "Using constructed key:", x[key]
    
    # 显示SUBSEP的值
    print "SUBSEP value is a control character (^\\034)"
}'

#### 6.3.2 GAWK真正的多维数组

gawk支持真正的多维数组（数组的数组），不需要矩形结构：

```bash
# gawk真正的多维数组示例
awk 'BEGIN {
    # 创建真正的多维数组
    a[1] = 5
    a[2][1] = 6
    a[2][2] = 7
    
    # 访问多维数组元素
    print "a[1]:", a[1]
    print "a[2][1]:", a[2][1]
    print "a[2][2]:", a[2][2]
    
    # 遍历多维数组
    print "\nTraversing a[2]:"
    for (i in a[2]) {
        print "a[2][" i "]:", a[2][i]
    }
}'

# 演示数组的数组作为函数参数
awk 'BEGIN {
    # 创建子数组
    subarr[1] = "one"
    subarr[2] = "two"
    
    # 将子数组赋值给父数组
    parent[1] = subarr
    
    # 注意：需要先创建子数组元素再删除以确保正确类型
    delete parent[2][1]  # 确保parent[2]是数组类型
    
    # 在父数组中添加新的子数组元素
    parent[2][3] = "three"
    
    print "parent[1][1]:", parent[1][1]
    print "parent[2][3]:", parent[2][3]
}

# 统计单词出现次数
cat > words.txt << 'EOF'
apple banana apple orange banana apple
orange mango apple banana
EOF

awk '{ 
    for (i=1; i<=NF; i++) {
        count[$i]++
    }
} 
END { 
    print "Word counts:"
    for (word in count) {
        print word ":", count[word]
    }
}' words.txt

# 统计日志中每个级别的消息数量
awk '{
    level = $3
    count[level]++
} 
END {
    print "Log level counts:"
    for (l in count) {
        print l ":", count[l]
    }
}' app.log

# 使用--re-interval选项启用区间表达式
awk --re-interval '/[0-9]{2,3}/' file.txt

(...)       分组

$           字段引用

++ --       递增和递减，前缀和后缀

^           幂运算（也可以使用**，以及**=作为赋值运算符）

+ - !       一元加号、一元减号和逻辑非

* / %       乘法、除法和取模

+ -         加法和减法

空格        字符串连接

|   |&      getline、print和printf的管道I/O

< > <= >= == !=
            常规关系运算符

~ !~        正则表达式匹配、否定匹配。注意：不要在~或!~的左侧使用常量正则表达式(/foo/)。只在右侧使用。表达式/foo/ ~ exp与((($0 ~ /foo/) ~ exp))具有相同的含义。这通常不是您想要的。

in          数组成员资格

&&          逻辑与

||          逻辑或

**重要说明：比较运算符与逻辑运算符结合使用时的语法规则**

在awk中，当使用逻辑运算符（如`&&`、`||`）连接比较表达式时，需要特别注意语法规则。不同的awk实现（如GNU awk、mawk）在处理运算符优先级时可能存在差异，导致某些表达式在一种实现中正常工作，而在另一种实现中报错。

### 不同awk实现的语法差异

**案例1：mawk 1.3.4（Ubuntu 24.10）中的行为：**
```bash
# 使用>=运算符时，即使没有括号也可能报错
awk 'BEGIN{print 100>=2 && 100>=3 }'
# 报错: awk: line 1: syntax error at or near =

# 添加括号后正常工作
awk 'BEGIN{print (100>=2) && (100>=3) }'
# 输出: 1

# 使用>运算符时，没有括号会报错
awk 'BEGIN{ print 100 > 2 && 3 < 9 }'
# 报错: awk: 命令行:1:                      ^ syntax error

# 添加括号后正常工作
awk 'BEGIN{ print (100 > 2) && (3 < 9) }'
# 输出: 1

# 示例1：查找UID为0（root）或UID>=1000的普通用户，并显示用户名和登录shell
awk -F":" '$3==0 || $3>=1000{print $1,$7}' /etc/passwd
# 输出示例：
# root /bin/bash
# nobody /sbin/nologin
# soveran /bin/bash
# ...

# 示例2：使用逻辑非查找UID不小于1000的用户（与示例1的后半部分等效）
awk -F: '!($3<1000){print $1}' /etc/passwd
# 输出示例：
# nobody
# soveran
# test1
# ...

# 示例3：使用逻辑与查找特定行范围的记录
awk -F: 'NR>=1&&NR<=2{print NR,$0}' /etc/passwd
# 输出示例：
# 1 root:x:0:0:root:/root:/bin/bash
# 2 bin:x:1:1:bin:/bin:/sbin/nologin

if (condition) statement [ else statement ]

# 错误示例：if语句没有被大括号包围
awk -F":" 'if(length($1)==4){i++;print $1} END{print "count is " i}' /etc/passwd
# 报错: awk: 命令行:1: if(length($1)==4){i++;print $1} END{print "count is " i}
# 报错: awk: 命令行:1: ^ syntax error

# 正确示例：if语句被大括号包围
awk -F: '{if(length($1)==4){i++;print $1}} END {print "count is " i}' /etc/passwd
# 正确输出用户名长度为4的用户列表和计数

# 条件表达式作为模式，后面直接跟动作代码
awk -F":" 'length($1)==4{i++;print $1} END{print "count is "i}' /etc/passwd
# 正确输出用户名长度为4的用户列表和计数

# 此命令被awk解释为：
# - 模式：length($1)==4
# - 动作：{i++;print $1}

# 示例1：查找登录shell为/bin/bash的用户
awk -F: '{if($0 ~ "/bin/bash")print$1}' /etc/passwd
# 输出示例：
# root
# soveran
# test1
# ...

# 示例2：使用NF（最后一个字段）查找shell为/bin/bash的用户
awk -F: '{if($NF=="/bin/bash")print$1}' /etc/passwd
# 输出示例与上例相同

# 示例3：使用NR变量打印大于第9行的记录
# NR>9表示打印第10行及以后的数据
awk -F' ' '{if(NR>9)print $1}' /etc/fstab
# 输出示例：
# #
# /dev/mapper/rl-root
# UUID=4e0fed15-9f25-41c0-8a61-fd528964dd3f
# /dev/mapper/rl-home
# /dev/mapper/rl-swap

# 正确方式：使用-F选项指定分隔符，处理带%符号的百分比字段
df -h | awk -F '%| ' '{if($(NF-2)>10)print $NF":"$(NF-2)"%"}'
# 输出示例：
# 挂载点:已用%
# /boot:51%

# 单语句情况下，大括号可以省略
awk -F '%| ' '{if($(NF-2)>10)print $NF":"$(NF-2)"%"}'

# 错误示例：多语句没有用大括号包围，所有语句都会被执行
awk -F '%| ' '{if($(NF-2)>10)print $NF":"$(NF-2)"%";print "---"}'
# 输出：每个输入行都会打印"---"，无论条件是否满足

# 正确示例：多语句用大括号包围，只有条件满足时才会执行所有语句
awk -F '%| ' '{if($(NF-2)>10){print $NF":"$(NF-2)"%";print "---"}}'
# 输出：只有条件满足的行才会打印挂载点信息和"---"

# 示例：使用free命令和awk双分支if语句监控内存使用状态
free -m | awk '/^Mem/{if($3 / $2 * 100 >= 80){print "内存使用率警告: " int($3/$2*100)"%"} else{print "内存使用率正常: " int($3/$2*100)"%"}}'

# 当内存使用率较低时（如30%）
free -m | awk '/^Mem/{if($3 / $2 * 100 >= 80){print "内存使用率警告: " int($3/$2*100)"%"} else{print "内存使用率正常: " int($3/$2*100)"%"}}'
# 输出：内存使用率正常: 30%

# 当内存使用率较高时（如85%）
free -m | awk '/^Mem/{if($3 / $2 * 100 >= 80){print "内存使用率警告: " int($3/$2*100)"%"} else{print "内存使用率正常: " int($3/$2*100)"%"}}'
# 输出：内存使用率警告: 85%

# 使用不同阈值测试
free -m | awk '/^Mem/{if($3 / $2 * 100 >= 50){print "内存使用率中等: " int($3/$2*100)"%"} else{print "内存使用率较低: " int($3/$2*100)"%"}}'

              total        used        free      shared  buff/cache   available
Mem:           7822        3145        2134          10        2542        4389
Swap:          2047           0        2047

if (condition1) {
    action1
} else if (condition2) {
    action2
} else if (condition3) {
    action3
} else {
    default_action
}

# 示例：根据分数范围进行评级
awk ' 
BEGIN{ 
  score = 99 
  if (score >=0 && score <60) { 
    print "不及格" 
  } else if (score >=60 && score < 90) { 
    print "优秀" 
  } else if (score >=90 && score <= 100) { 
    print "你还是人么" 
  } else { 
    print "你觉得我信吗?" 
  } 
}'
# 输出：你还是人么

# 场景1：低分（不及格）
awk ' 
BEGIN{ 
  score = 9 
  if (score >=0 && score <60) { 
    print "不及格" 
  } else if (score >=60 && score < 90) { 
    print "优秀" 
  } else if (score >=90 && score <= 100) { 
    print "你还是人么" 
  } else { 
    print "你觉得我信吗?" 
  } 
}'
# 输出：不及格

# 场景2：中等分数（优秀）
awk ' 
BEGIN{ 
  score = 88 
  if (score >=0 && score <60) { 
    print "不及格" 
  } else if (score >=60 && score < 90) { 
    print "优秀" 
  } else if (score >=90 && score <= 100) { 
    print "你还是人么" 
  } else { 
    print "你觉得我信吗?" 
  } 
}'
# 输出：优秀

# 场景3：超出范围的分数
awk ' 
BEGIN{ 
  score = 188 
  if (score >=0 && score <60) { 
    print "不及格" 
  } else if (score >=60 && score < 90) { 
    print "优秀" 
  } else if (score >=90 && score <= 100) { 
    print "你还是人么" 
  } else { 
    print "你觉得我信吗?" 
  } 
}'
# 输出：你觉得我信吗?

# 判断输入字符串并输出对应的性别描述
# 案例1：输入"nan"（男性）
echo "nan" | awk '{if ($1=="nan") print "你是男性"; else if($1=="nv") print "你是女性"; else print "你的性别未知"}'
# 输出：你是男性

# 案例2：输入"nv"（女性）
echo "nv" | awk '{if ($1=="nan") print "你是男性"; else if($1=="nv") print "你是女性"; else print "你的性别未知"}'
# 输出：你是女性

# 案例3：输入其他值（未知性别）
echo "女" | awk '{if ($1=="nan") print "你是男性"; else if($1=="nv") print "你是女性"; else print "你的性别未知"}'
# 输出：你的性别未知

# 示例1：正确的初始化位置（在BEGIN块中）
awk -F: 'BEGIN{i=0;j=0}{if($3<=500){i++}else{j++}}END{print "uid小于500:"i,"uid大于500:"j}' /etc/passwd
# 输出：uid小于500:19 uid大于500:31

# 示例2：错误的初始化位置（在主处理块中）
awk -F: '{i=0;j=0;if($3<=500){i++}else{j++}}END{print "uid小于500:"i,"uid大于500:"j}' /etc/passwd
# 输出：uid小于500:0 uid大于500:1

condition ? value_if_true : value_if_false

# 根据uid判断用户类型（uid>=1000为普通用户，否则为系统用户）
awk -F":" '{$3>=1000?usertype="普通用户":usertype="系统用户";printf "%-6s:%6s\n",$1,usertype}' /etc/passwd | head -n 4
# 输出：
# root  :  系统用户
# bin   :  系统用户
# daemon:  系统用户
# adm   :  系统用户

# 监控磁盘空间，使用率超过10%标记为full
# 注意：实际使用中可根据需要调整阈值
# 注意：不同系统的df输出格式可能略有不同，$(NF-1)表示倒数第二列（使用率）
df -h | awk '/^\/dev\/sd/{$(NF-1)>10?disk="full":disk="OK";print $1,$(NF-1),disk}'
# 输出：
# /dev/sda1 51% full

# 使用方法：将三元表达式作为模式部分，后跟动作块
awk -v total=0 'NR>=2, $2+$3+$4>=240?type="优秀":type="良好" {total=$2+$3+$4; printf "姓名: %s, 总分: %4d, 状态: %s\n",$1,$2+$3+$4,type}' course_score.txt

# 使用方法：在动作块内使用三元表达式进行赋值
awk -v total=0 'NR>=2{total=$2+$3+$4; total>=240?type="优秀":type="良好";printf "姓名: %s, 总分: %4d, 状态: %s\n", $1,total,type}' course_score.txt

while (condition) statement
do statement while (condition)
for (expr1; expr2; expr3) statement
for (var in array) statement
break

# break语句实践

## 在特定条件下终止循环
# 在循环中当i等于5时终止循环
awk ' 
BEGIN{ 
    for(i=0;i<10;i++){ 
         if(i==5){ 
              break 
         } 
         print(i) 
    } 
}'
# 执行结果:
# 0
# 1
# 2
# 3
# 4

## 计算部分和
# 计算1到65的和（当i等于66时终止循环）
awk 'BEGIN{sum=0;for(i=1;i<=100;i++){if(i==66)break;sum+=i}print sum}'
# 执行结果: 2145

continue

# continue语句实践

## 跳过特定值
# 在循环中跳过值为5的情况
awk ' 
BEGIN{ 
    for(i=0;i<10;i++){ 
        if(i==5)continue 
        print(i) 
    } 
}'
# 执行结果:
# 0
# 1
# 2
# 3
# 4
# 6
# 7
# 8
# 9

## 计算奇数和
# 计算1到100之间的奇数和
awk 'BEGIN{sum=0;for(i=1;i<=100;i++){if(i%2==0)continue;sum+=i}print sum}'
# 执行结果: 2500

## 计算偶数和
# 计算1到100之间的偶数和
awk 'BEGIN{sum=0;for(i=1;i<=100;i++){if(i%2!=0)continue;sum+=i}print sum}'
# 执行结果: 2550
delete array[index]
delete array
exit [ expression ]

# exit语句实践

## 打印第一个记录的特定字段后退出
# 打印awk.txt文件第一行的第二个字段后立即退出程序
awk '{print $2; exit}' awk.txt
# 执行结果: awk1

## 查找满足条件的前N条记录后退出
# 打印/etc/passwd文件中包含"nologin"的前3行记录后退出
awk '/nologin/{i++;if(i<=3){print $0}else{exit;}}' /etc/passwd
# 执行结果:
# bin:x:1:1:bin:/bin:/sbin/nologin
# daemon:x:2:2:daemon:/sbin:/sbin/nologin
# adm:x:3:4:adm:/var/adm:/sbin/nologin

## 多阶段exit行为说明

### BEGIN和END块中的exit优先级
# BEGIN设置flag=1并尝试exit 2，但END块中的exit 1会覆盖之前的值
awk 'BEGIN{flag=1;exit 2}{}END{if(flag){exit 1}}'
# 执行结果: 退出码为1（END块的exit覆盖了BEGIN块的exit）

# BEGIN块中直接exit 2，由于flag未定义，END块中的条件不满足，保留BEGIN块的退出码
awk 'BEGIN{exit 2}{}END{if(flag){exit 1}}'
# 执行结果: 退出码为2

### 主代码块中的exit优先级
# 主代码块中的exit 111会覆盖END块中可能的exit值
awk 'BEGIN{}{exit 111}END{if(flag){exit 1}}' <<< "input"
# 执行结果: 退出码为111

### 无参数exit的默认值
# END块中使用无参数exit，默认返回成功状态码0
awk 'BEGIN{}{}END{if(flag){exit}}' <<< "input"
# 执行结果: 退出码为0

### exit语句的主要用途
1. **错误处理**：在检测到错误条件时立即终止执行并返回特定错误码
2. **条件退出**：根据处理结果返回不同的状态码，便于脚本后续流程判断
3. **资源优化**：在完成必要处理后提前退出，避免不必要的计算
4. **流程控制**：在多阶段处理中，通过不同位置的exit控制最终的退出状态
{ statements }
switch (expression) {
case value|regex : statement
...
[ default: statement ]
}

close(file [, how])   关闭文件、管道或协同进程。可选的how参数只应在关闭到协同进程的双向管道的一端时使用。它必须是字符串值，"to"或"from"。

getline               从下一个输入记录设置$0；设置NF、NR、FNR、RT。

getline <file         从文件的下一个记录设置$0；设置NF、RT。

getline var           从下一个输入记录设置var；设置NR、FNR、RT。

getline var <file     从文件的下一个记录设置var；设置RT。

command | getline [var]
                      运行命令，将输出通过管道传输到$0或var，并设置RT。

command |& getline [var]
                      运行命令作为协同进程，将输出通过管道传输到$0或var，并设置RT。协同进程是gawk的扩展。（命令也可以是套接字。）

next                  停止处理当前输入记录。读取下一个输入记录，并从AWK程序的第一个模式开始重新处理。到达输入数据末尾时，执行任何END规则。

### next语句实践

```bash
# 跳过第3行，打印其他所有行
awk 'NR==3{next}{print}' awk.txt
# 执行结果:
# nihao awk1 awk2 awk3
# nihao awk4 awk5 awk6

# 跳过第2行，打印其他所有行
awk 'NR==2{next}{print}' awk.txt
# 执行结果:
# nihao awk1 awk2 awk3
# nihao awk7 awk8 awk9

# 处理多个文件，当每个文件的FNR等于3时，跳过当前文件
awk 'FNR==3{nextfile}{print}' awk.txt awk.txt
# 执行结果:
# nihao awk1 awk2 awk3
# nihao awk4 awk5 awk6
# nihao awk1 awk2 awk3
# nihao awk4 awk5 awk6

print "You blew it!" > "/dev/stderr"

print "You blew it!" | "cat 1>&2"

# 使用if-else语句
awk '{
    total = $2 + $3 + $4
    if (total >= 270) {
        grade = "A"
    } else if (total >= 240) {
        grade = "B"
    } else if (total >= 210) {
        grade = "C"
    } else {
        grade = "F"
    }
    print $1, "Total:", total, "Grade:", grade
}' awk_test.txt

# for循环
awk 'BEGIN { 
    for (i=1; i<=5; i++) {
        print "Count:", i
    }
}'

# 使用for循环计算1到100的和（多行写法）
awk 'BEGIN { 
     sum=0 
     for (i=1;i<=100;i++) { 
          sum+=i 
     } 
     print sum 
 }' 

# 使用for循环计算1到100的和（单行写法）
awk 'BEGIN{ sum=0; for(i=1;i<=100;i++) {sum+=i}; print sum}'

# 使用for循环遍历字段并求和
# 首先创建测试文件：seq 10 | paste -s | tr -s "\t" " " > num.txt
# 命令解析：
# - seq 10: 生成1到10的数字序列，每个数字占一行
# - paste -s: 将多行数据合并为单行，用制表符分隔
# - tr -s "\t" " ": 将制表符替换为空格，并压缩连续的空白字符
# - > num.txt: 将结果保存到num.txt文件

# 查看生成的文件
# cat num.txt  # 输出: 1 2 3 4 5 6 7 8 9 10

# 使用awk遍历所有字段并求和
awk '{for(i=1;i<=NF;i++){sum+=$i};print sum}' num.txt

# 使用for循环计算学生成绩总分
# 假设course_score.txt文件包含学生姓名和多门课程成绩，格式如下：
# 姓名 课程1 课程2 课程3
# 张三 85 88 82
# 李四 80 85 82
# 王五 65 68 62
# 赵六 90 92 86

# 计算每个学生的总分（从第2个字段到最后一个字段）
awk 'NR>=2 { 
     total=0 
     for (i=2;i<=NF;i++) { 
          total+=$i 
     } 
     print "学生姓名: "$1", 课程总分: "total 
 }' course_score.txt
# 执行结果示例：
# 学生姓名: 张三, 课程总分: 255
# 学生姓名: 李四, 课程总分: 247
# 学生姓名: 王五, 课程总分: 195
# 学生姓名: 赵六, 课程总分: 268

# while循环
awk 'BEGIN { 
    i=1
    while (i<=5) {
        print "Count:", i
        i++
    }
}'

# 使用while循环计算1到100的和（多行写法）
awk 'BEGIN { 
     i=1;sum=0 
     while(i<=100) { 
          sum+=i 
          i++ 
     } 
     print sum 
 }' 
# 执行结果: 5050

# 使用while循环计算1到100的和（单行写法）
awk 'BEGIN{i=1;sum=0;while(i<=100){sum+=i;i++};print "sum="sum}'
# 执行结果: sum=5050

# 交互式指定数字范围求和（使用命令行参数）
# 通过read命令获取用户输入，并使用awk的-v选项传递变量
read -p "请输入一个数字 : " NUM;awk -v num=$NUM 'BEGIN{i=1;sum=0;while(i<=num){sum+=i;i++};print "1~"num"的和为="sum}'
# 执行示例：
# 请输入一个数字 : 43
# 1~43的和为=946

# 另一个执行示例：
# 请输入一个数字 : 4
# 1~4的和为=10

# 使用while循环查找最大值和最小值
# 首先创建测试文件
# echo '0 234 252 3246 2245 2345 4536 3754 32 345 323 234 3 1' > num.txt

# 使用awk查找一行中所有数字的最大值和最小值
awk '{min=$1;max=$1;while(i<=NF){if(max<$i)max=$i;if(min>$i)min=$i;i++};print "max:"max,"min:"min}' num.txt
# 执行结果: max:4536 min:0

# 说明：
# 1. 初始化min和max为第一个字段的值
# 2. 使用while循环遍历所有字段
# 3. 通过比较更新最大值和最小值
# 4. 最后输出结果

# 标准求和（使用while循环计算所有字段的和）
# 对num.txt文件中的所有数字字段求和
awk '{ 
 sum=0 
 i=1 
 while (i<=NF) { 
     sum+=$i 
     i++ 
 } 
 print sum 
 }'  num.txt
# 执行结果: 17550

# do-while循环
awk 'BEGIN { 
    i=1
    do {
        print "Count:", i
        i++
    } while (i<=5)
}'

# do-while循环实践 - 打印0-4
awk 'BEGIN{i=0;do {print i;i++} while(i<5)}'
# 执行结果:
# 0
# 1
# 2
# 3
# 4

# do-while循环实践 - 计算1到100之和
awk 'BEGIN{ total=0;i=1;do{ total+=i;i++;}while(i<=100);print total}'
# 执行结果: 5050

# switch语句
awk '{
    switch ($1) {
        case "Alice":
            print "Hello Alice"
            break
        case "Bob":
            print "Hello Bob"
            break
        default:
            print "Hello Stranger"
    }
}' awk_test.txt

# 没有break的switch语句
seq 2 | awk '{
    switch ($1 % 2) {
        case "1":
            print "奇数: ", $1
        case "0":
            print "偶数: ", $1
        default:
            print "嘿嘿"
    }
}'

# 有break的switch语句
seq 5 | awk '{
    switch ($1 % 2) {
        case "1":
            print "奇数: ", $1
            break
        case "0":
            print "偶数: ", $1
            break
        default:
            print "嘿嘿"
            break
    }
}'

# 使用switch语句判断奇数行和偶数行
awk '{switch (NR % 2) { 
     case "1": 
          print "奇数行: ", $0 
          break 
     case "0": 
          print "偶数行: ", $0 
          break 
 }}' awk.txt

# 使用switch语句统计学生成绩状态
awk -v total=0 ' 
BEGIN{ 
    printf "\t学生成绩信息统计\n" 
    printf "-----------------------------------\n" 
}
NR>=2 {switch ($2+$3+$4 >= 240) { 
    case 0: 
         type="优秀";break 
    case 1: 
         type="良好";break 
}
total=$2+$3+$4 
printf "姓名: %-3s 总分: %4d,状态: %-2s\n",$1,$2+$3+$4,type 
}' course_score.txt

# 示例1：演示rand()函数每次运行返回相同结果的问题
awk 'BEGIN{print rand()}'  # 输出: 0.924046（或其他固定值）
awk 'BEGIN{print rand()}'  # 输出: 0.924046（与上面相同）

# 示例2：使用srand()设置随机种子，生成不同的随机数
awk 'BEGIN{srand(); print rand()}'  # 使用当前时间作为种子
awk 'BEGIN{srand(); print rand()}'  # 由于时间不同，返回不同的值

# 示例3：使用固定种子，生成可重现的随机序列
awk 'BEGIN{srand(12345); print rand(), rand(), rand()}'  # 固定种子生成固定序列

# 示例4：生成指定范围内的随机整数
# 生成1-100之间的随机整数
awk 'BEGIN{srand(); print int(rand() * 100) + 1}'

# 生成0-24之间的随机整数（包含0和24）
awk 'BEGIN{srand(); print int(25*rand())}'

# 生成0-21之间的随机整数（包含0和21）
awk 'BEGIN{srand(); print int(22*rand())}'

# 示例5：srand带固定参数时的行为特点
# 使用固定种子2时，每次运行都会得到相同的随机数
awk 'BEGIN{srand(2); print rand()}'  # 输出: 0.893104
awk 'BEGIN{srand(2); print rand()}'  # 输出: 0.893104（与上面相同）

# 使用固定种子时，生成的随机序列也是固定的
awk 'BEGIN{srand(2); print rand(), rand(), rand()}'

# 使用无参数srand()时，每次运行使用当前时间作为种子，得到不同结果
awk 'BEGIN{srand(); print rand()}'  # 输出随机值
awk 'BEGIN{srand(); print rand()}'  # 输出不同的随机值

# 示例5：int()函数处理非数字参数的行为
awk 'BEGIN{print int(123.456)}'    # 输出: 123
awk 'BEGIN{print int(123.abc)}'    # 输出: 123（解析到字母时停止）
awk 'BEGIN{print int(abc123)}'     # 输出: 0（以非数字开头，解析为0）

# 基本格式化示例
awk 'BEGIN{a=sprintf("%s-%d-%s","abc",26,"edf");print a}'  # 输出: abc-26-edf

# 数字格式化
awk 'BEGIN{print sprintf("%04d", 42)}'  # 输出: 0042
awk 'BEGIN{print sprintf("%.2f", 3.14159)}'  # 输出: 3.14

# 获取字符串长度
awk 'BEGIN{v="abcdefetgf";print length(v)}'  # 输出: 10

# 不指定参数时返回$0的长度
awk '{print length}' <<< "Hello World"  # 输出: 11

# 转换为小写
awk 'BEGIN{v="ABDCDef";print tolower(v)}'  # 输出: abdcdef

# 转换为大写
awk 'BEGIN{v="nscfed";print toupper(v)}'  # 输出: NSCFED

# 查找子字符串位置
awk 'BEGIN{str="wedfefer"; print index(str,"fe")}'  # 输出: 4

# 子字符串不存在
awk 'BEGIN{print index("Hello", "xyz")}'  # 输出: 0

# 从第3个字符开始截取到字符串末尾
awk 'BEGIN{v="abcdefghijk";print substr(v,3)}'  # 输出: cdefghijk

# 从第3个字符开始，截取3个字符
awk 'BEGIN{v="abcedfghijk";print substr(v,3,3)}'  # 输出: ced

# 从第一个字符开始截取
awk 'BEGIN{print substr("Hello", 1, 3)}'  # 输出: Hel

# 截取超出字符串长度的部分
awk 'BEGIN{print substr("Hello", 3, 10)}'  # 输出: llo（不会报错，只返回可用部分）

# 基本分割示例（错误示例和正确示例对比）
# 错误：使用圆括号访问数组元素
awk 'BEGIN{split("abc-edf-ghi-jkl",arr,"-",sep);print length(arr),arr(3),sep[1]}'  # 错误: 试图把非函数"arr"当函数来调用

# 正确：使用方括号访问数组元素
awk 'BEGIN{split("abc-def-gho-pq",arr,"-",seps); print length(arr), arr[3], seps[1]}'  # 输出: 4 gho -

# 基本分割，不保存分隔符
awk 'BEGIN{split("apple,banana,orange", fruits, ","); for(i=1; i<=length(fruits); i++) print fruits[i]}'  # 输出三个水果名称

# 使用默认分隔符（空格）
awk 'BEGIN{split("hello world awk", words); print words[2]}'  # 输出: world

# 使用正则表达式作为分隔符
awk 'BEGIN{split("abc123def456ghi", parts, /[0-9]+/, delims); print "Parts:", parts[1], parts[2], "Delimiters:", delims[1]}'  # 输出: Parts: abc def Delimiters: 123

# 正常分割示例
awk 'BEGIN{split("abc-def-gho-pge",arr,"-"); print arr[2]}'  # 输出: def

# 分隔符不存在时的行为 - 整个字符串作为第一个元素
awk 'BEGIN{split("abcdef", arr, "-"); print arr[1]}'  # 输出: abcdef (整个字符串作为数组第一个元素)

# BEGIN块无法访问输入数据的示例
awk 'BEGIN{split($0,a,":");print a[0],a[1],a[2]}'  # 无输出，因为BEGIN块执行时$0未定义

# 主程序块可以访问输入数据的示例
# 示例1: 使用索引0访问（无输出）
echo "12:34:56" | awk '{split($0,a,":");print a[0],a[1],a[2]}'  # 输出: 12 34 (注意a[0]不存在)

# 示例2: 使用正确的索引访问（从1开始）
echo "12:34:56" | awk '{split($0,a,":");print a[1],a[2],a[3]}'  # 输出: 12 34 56

awk 'BEGIN{print mktime("2032 3 31 13 33 22") | "xargs -i date -d@{} +\"%F %T\""}'

# 示例1：获取当前系统时间戳
echo "当前时间戳:"; awk 'BEGIN{print systime()}'

# 示例2：将日期字符串转换为时间戳
echo "指定日期的时间戳:"; awk 'BEGIN{print mktime("2032 3 31 13 33 22")}'

# 示例3：使用strftime直接格式化当前时间
echo "格式化的当前时间:"; awk 'BEGIN{print strftime("%Y-%m-%d %H:%M:%S")}'

# 示例4：使用xargs和date转换时间戳格式
awk 'BEGIN{print mktime("2032 3 31 13 33 22") | "xargs -i date -d@{} +\"%F %T\""}'

# 示例1：正常时间（无调整）
awk 'BEGIN{print mktime("2032 3 31 13 33 22") | "xargs -i date -d@{} +\"%F %T\""}'
# 输出: 2032-03-31 13:33:22

# 示例2：小时减1（-1）
awk 'BEGIN{print mktime("2032 3 31 13 -1 22") | "xargs -i date -d@{} +\"%F %T\""}'
# 输出: 2032-03-31 12:59:22

# 示例3：小时加1且分钟减1（跨天调整）
awk 'BEGIN{print mktime("2032 3 31 +1 -1 22") | "xargs -i date -d@{} +\"%F %T\""}'
# 输出: 2032-03-31 00:59:22

# 示例4：天数加1（自动处理月末）
awk 'BEGIN{print mktime("2032 3 +1 13 -1 22") | "xargs -i date -d@{} +\"%F %T\""}'
# 输出: 2032-03-01 12:59:22 （注意：3月有31天，加1天后是4月1日）

# 示例5：小时加1（自动处理跨天）
awk 'BEGIN{print mktime("2032 3 31 +1 33 22") | "xargs -i date -d@{} +\"%F %T\""}'
# 输出: 2032-03-31 01:33:22

# 示例：使用strftime直接格式化指定时间（含时区）
awk 'BEGIN{print strftime("%F %T %z", mktime("2013 3 18 11 32 12"))}'
# 输出: 2013-03-18 11:32:12 +0800

# 示例：自定义格式输出
awk 'BEGIN{print strftime("%Y年%m月%d日 %H时%M分%S秒", mktime("2013 3 18 11 32 12"))}'
# 输出: 2013年03月18日 11时32分12秒

awk ' 
 function add_func(num1, num2) 
 { 
     return num1 + num2 
 } 
 function sub_func(num1, num2) 
 { 
     if (num1 > num2) 
          return num1 - num2 
     return num2 - num1 
 } 
 BEGIN { 
     sum_result=add_func(10, 20) 
     print "两值之和为: "sum_result 
     sub_result=sub_func(10, 20) 
     print "两值之差为: "sub_result 
 }'

awk ' 
 function head_func() { 
     printf "---------------------------\n|%-3s|%2s|%2s|%2s|%2s|\n---------------------------\n","姓名","语文","数学","历史","总分" 
 } 
 function body_func(arg1, arg2, arg3, arg4,arg5){ 
     printf "|%-3s|%4d|%4d|%4d|%4d|\n",arg1,arg2,arg3,arg4,arg5 
 } 
 function tail_func(arg1, arg2, arg3, arg4,arg5){ 
     printf "---------------------------\n|%-3s|%4d|%4d|%4d|%4d|\n---------------------------\n学生总数总: %2d\n","合计",arg1,arg2,arg3,arg4,arg5 
 } 
 BEGIN {head_func() 
     yu=0;shu=0;li=0;total
 }{ 
     yu=$2+yu;shu=$3+shu;li=$4+li;total=$2+$3+$4 
     body_func($1,$2,$3,$4,$2+$3+$4) 
 }END{ 
     tail_func(yu,shu,li,total,NR) 
 }' course_score.txt

#!/bin/bash
# **************************************
# *  站点访问测试脚本
# *  作者：钟翼翔
# *  联系：clockwingsoar@outlook.com
# *  版本：2025-11-10
# **************************************

# 模拟外网访问网站

while true
do
        cat ip.txt | while read ip
  do
                NUM=$(echo $ip | cut -d "." -f 4)
                for i in $(seq $NUM)
                do
                        curl `http://10.0.0.12/`  -s -I -H "X-Forwarded-For: $ip" >> /dev/null
                        curl `http://10.0.0.12/$NUM/`  -s >> /dev/null
                done
                sleep 1
        done
done

#!/bin/bash
# **************************************
# *  站点访问测试脚本（优化版）
# *  作者：钟翼翔
# *  联系：clockwingsoar@outlook.com
# *  版本：2025-11-10
# **************************************

# 配置参数
BASE_URL="http://10.0.0.12"
IP_FILE="ip.txt"
MAX_ITERATIONS=10         # 控制总循环次数
MAX_REQUESTS_PER_IP=5     # 每IP最大请求数（替代原来基于IP第四段的动态值）
CONCURRENCY_LIMIT=3       # 并发请求限制
SLEEP_TIME=0.5            # 请求间隔（秒）
LOG_FILE="access_test.log"

# 日志函数
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}

# 检查必要文件
if [ ! -f "$IP_FILE" ]; then
    echo "错误: IP文件 $IP_FILE 不存在！"
    exit 1
fi

# 清空日志
> "$LOG_FILE"
log "测试开始"

# 主测试函数
run_test() {
    local ip=$1
    local num=$2
    local count=0
    
    # 限制每IP的请求数
    local requests=$((num > MAX_REQUESTS_PER_IP ? MAX_REQUESTS_PER_IP : num))
    
    log "处理IP: $ip, 生成 $requests 个请求"
    
    # 执行请求
    for ((i=1; i<=requests; i++)); do
        # HEAD请求 - 检查状态
        curl -s -I -H "X-Forwarded-For: $ip" "$BASE_URL/" > /dev/null
        local head_status=$?
        
        # GET请求 - 获取内容
        curl -s -H "X-Forwarded-For: $ip" "$BASE_URL/$num/" > /dev/null
        local get_status=$?
        
        # 记录请求状态
        if [ $head_status -eq 0 ] && [ $get_status -eq 0 ]; then
            ((count++))
        else
            log "警告: IP $ip 请求 $i 失败 (HEAD: $head_status, GET: $get_status)"
        fi
        
        # 避免过快请求
        sleep $SLEEP_TIME
    done
    
    log "IP $ip 成功完成 $count 个请求"
    return 0
}

# 主循环 - 有限次数
log "总测试循环次数: $MAX_ITERATIONS"

for ((iteration=1; iteration<=MAX_ITERATIONS; iteration++)); do
    log "===== 迭代 $iteration/$MAX_ITERATIONS ====="
    
    # 读取IP文件（避免多余的cat命令）
    while read -r ip; do
        # 跳过空行
        [[ -z "$ip" ]] && continue
        
        # 提取IP第四段
        num=$(echo "$ip" | cut -d "." -f 4)
        
        # 运行测试并控制并发
        if [ $(jobs -r | wc -l) -lt $CONCURRENCY_LIMIT ]; then
            run_test "$ip" "$num" &
        else
            # 等待直到有空闲槽位
            wait -n
            run_test "$ip" "$num" &
        fi
    done < "$IP_FILE"
    
    # 等待当前迭代的所有任务完成
    wait
    log "迭代 $iteration 完成"
    
    # 迭代间隔
    if [ $iteration -lt $MAX_ITERATIONS ]; then
        log "等待下一次迭代..."
        sleep 5
    fi
done

log "测试完成"
echo "测试已完成，详细日志请查看 $LOG_FILE"

# 正确的命令 - 统计当前主机的所有连接状态
ss -ant | awk '!/State/{state[$1]++}END{for(i in state){print i,state[i]}}'

ss -ant | awk '/!State/{state[$1]++}END{for(i in state){print i,state[i]}}'

# 统计所有连接状态，并按数量排序
ss -ant | awk '!/State/{state[$1]++}END{for(i in state){print i,state[i]}}' | sort -k2 -nr

# 统计80端口的连接数量
ss -ant | awk '!/State/ && $4 ~ /:80$/{count++}END{print "80端口连接数:", count}'

# 统计来自10.0.0.1的连接数量
ss -ant | awk '!/State/ && $5 ~ /^10\.0\.0\.1:/{count++}END{print "来自10.0.0.1的连接数:", count}'

ss -nt | awk -F "[ :]+" '!/State/{ip[$(NF-2)]++}END{for(i in ip){print i, ip[i]}}' | while read line; do ip=$(echo $line | awk '{if($2>1)print $1}');[ -z "$ip" ] || echo "iptables -A INPUT -s $ip -j REJECT"; done

ss -nt | awk -F "[ :]+" '!/State/{ip[$(NF-3)]++}END{for(i in ip){print i, ip[i]}}' | while read line; do ip=$(echo $line | awk '{if($2>1)print $1}');[ -z "$ip" ] || echo "iptables -A INPUT -s $ip -j REJECT"; done

# 正确的命令 - 统计远程IP地址并生成iptables规则
ss -nt | awk -F "[ :]+" '!/State/{ip[$(NF-2)]++}END{for(i in ip){print i, ip[i]}}' | while read line; do 
  ip=$(echo $line | awk '{if($2>3)print $1}'); # 这里可以调整阈值，例如>3表示连接数超过3
  [ -z "$ip" ] || echo "iptables -A INPUT -s $ip -j REJECT"; 
done

# 优化版本：统计远程IP连接数并生成iptables规则，排除本地IP范围
ss -nt | awk -F "[ :]+" '!/State/{remote_ip=$(NF-2); if(remote_ip !~ /^127\.|^10\.|^192\.168\./){ip[remote_ip]++}}END{for(i in ip){print i, ip[i]}}' | sort -k2 -nr | while read line; do 
  ip=$(echo $line | awk '{if($2>10)print $1}'); # 阈值设置为10
  [ -z "$ip" ] || echo "iptables -A INPUT -s $ip -j REJECT"; 
done

awk -F '"' 'NR==403{print $(NF-1)}' /var/log/nginx/access.log

awk -F '"' '{ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' /var/log/nginx/access.log

awk -F '"' '{ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' /var/log/nginx/access.log | sort -nr -k2

awk -F '"'

{ip[$(NF-1)]++}

END{for(i in ip){print i, ip[i]}}

| sort -nr -k2

awk -F '"' '{if($(NF-1) != "-") ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' /var/log/nginx/access.log | sort -nr -k2

# 统计返回404错误的IP地址及其访问次数
awk -F '"' '/" 404 / {ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' /var/log/nginx/access.log | sort -nr -k2

# 统计22:13时段的访问IP
awk -F '"' '/\[10\/Nov\/2025:22:13:/ {ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' /var/log/nginx/access.log

awk -F '"' '{ip[$(NF-1)]++; if($3 ~ / 200 /) success[$(NF-1)]++}END{for(i in ip){print i, ip[i], success[i]?int(success[i]/ip[i]*100):0, "%"}}' /var/log/nginx/access.log | sort -nr -k2

#!/bin/bash
# Nginx访问日志分析脚本

LOG_FILE="/var/log/nginx/access.log"
REPORT_DIR="/var/log/nginx/reports"
DATE=$(date +"%Y%m%d_%H%M%S")

# 创建报告目录
mkdir -p $REPORT_DIR

# 生成TOP 10访问IP报告
echo "=== TOP 10 访问IP地址 ===" > $REPORT_DIR/top_ips_$DATE.txt
awk -F '"' '{if($(NF-1) != "-") ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' $LOG_FILE | sort -nr -k2 | head -n 10 >> $REPORT_DIR/top_ips_$DATE.txt

# 生成404错误报告
echo -e "\n=== TOP 10 404错误IP ===" >> $REPORT_DIR/top_ips_$DATE.txt
awk -F '"' '/" 404 / {if($(NF-1) != "-") ip[$(NF-1)]++}END{for(i in ip){print i, ip[i]}}' $LOG_FILE | sort -nr -k2 | head -n 10 >> $REPORT_DIR/top_ips_$DATE.txt

echo "报告已生成：$REPORT_DIR/top_ips_$DATE.txt"

awk '{a[$7]++}END{for(v in a)print v,a[v]|"sort -k1 -nr|head -n10"}' /var/log/nginx/access.log

# 按访问次数降序排列并显示前20个页面
awk '{a[$7]++}END{for(v in a)print a[v],v|"sort -nr|head -n20"}' /var/log/nginx/access.log

# 统计以.php结尾的页面访问次数
awk '$7 ~ /\.php$/{a[$7]++}END{for(v in a)print v,a[v]|"sort -nr -k2"}' /var/log/nginx/access.log

# 统计返回404错误的页面及其访问次数
awk '$9 == 404{a[$7]++}END{for(v in a)print v,a[v]|"sort -nr -k2"}' /var/log/nginx/access.log

# 按小时统计首页访问次数
awk '$7 == "/" {hour = substr($4, 14, 2); a[hour]++} END {for(h in a) print h":00", a[h]}' /var/log/nginx/access.log | sort -n

#!/bin/bash
# Nginx页面访问分析脚本

LOG_FILE="/var/log/nginx/access.log"
REPORT_FILE="nginx_page_analysis_$(date +%Y%m%d).txt"

# 清空或创建报告文件
> $REPORT_FILE

# 添加报告标题
echo "===== Nginx页面访问分析报告 =====" >> $REPORT_FILE
echo "生成时间: $(date)" >> $REPORT_FILE
echo "=====================================" >> $REPORT_FILE

# 1. TOP 20 页面访问统计
echo -e "\n[ TOP 20 页面访问统计 ]" >> $REPORT_FILE
awk '{a[$7]++}END{for(v in a)print a[v],v|"sort -nr|head -n20"}' $LOG_FILE >> $REPORT_FILE

# 2. 404错误页面统计
echo -e "\n[ 404错误页面统计 ]" >> $REPORT_FILE
awk '$9 == 404{a[$7]++}END{for(v in a)print a[v],v|"sort -nr|head -n20"}' $LOG_FILE >> $REPORT_FILE

# 3. 静态资源访问统计
echo -e "\n[ 静态资源访问统计 ]" >> $REPORT_FILE
awk '$7 ~ /\.(jpg|jpeg|png|gif|css|js|ico|svg|woff|woff2|ttf|eot)$/{ext=gensub(/.*\.(\w+)$/, "\\1", "1", $7); a[ext]++}END{for(e in a)print a[e],e|"sort -nr"}' $LOG_FILE >> $REPORT_FILE

# 4. 大文件下载统计
echo -e "\n[ 大文件下载统计 (>1MB) ]" >> $REPORT_FILE
awk '$10 > 1048576{a[$7] += $10}END{for(v in a)print a[v]/1048576,v|"sort -nr|head -n10"}' $LOG_FILE >> $REPORT_FILE

echo -e "\n分析报告已生成: $REPORT_FILE"

#!/bin/bash
#.**************************************
#.*..统计主机网络信息
#.*..作者：钟翼翔
#.*..联系：clockwingsoar@outlook.com
#.*..版本：2025-11-11
#.**************************************

#.TCP连接数量
TCP_Total=$(ss -s | awk '$1=="TCP"{print $2}')
#.UDP连接数量
UDP_Total=$(ss -s | awk '$1=="UDP"{print $2}')
#.Listen监听状态的TCP端口数量
Listen_Total=$(ss -antlpH | awk 'BEGIN{count=0}{count++}END{print count}')
#.ESTABLlSHED状态的TCP连接数量
Estab_Total=$(ss -antpH | awk 'BEGIN{count=0}/^ESTAB/{count++}END{print count}')
#.TIME-WAIT状态的TCP连接数量
TIME_WAIT_Total=$(ss -antpH | awk 'BEGIN{count=0}/^TIME-WAIT/{count++}END{print count}')
#显示主机连接相关信息
echo "TCP连接总数：$TCP_Total"
echo "UDP连接总数：$UDP_Total"
echo "LISTEN状态的TCP端口数量：$Listen_Total"
echo "ESTAB状态的TCP连接数量：$Estab_Total"
echo "TIME-WAIT状态的TCP连接数量：$TIME_WAIT_Total"

# 统计所有TCP连接状态的分布
echo -e "\nTCP连接状态分布："
ss -antpH | awk '{if($1!="State"){state[$1]++}}END{for(s in state){print s, state[s]}}' | sort -rn -k2

# 统计连接到SSH端口(22)的数量
SSH_Conn=$(ss -antpH | awk '$5~/:22$/ {count++}END{print count}')
echo "SSH连接数量：$SSH_Conn"

#!/bin/bash
LOG_FILE="network_monitor_$(date +%Y%m%d).log"

while true; do
  echo "===== $(date '+%Y-%m-%d %H:%M:%S') ====" >> $LOG_FILE
  ss -s | grep -E 'TCP|UDP' >> $LOG_FILE
  ss -antpH | awk '{if($1!="State"){state[$1]++}}END{for(s in state){print s, state[s]}}' >> $LOG_FILE
  sleep 60  # 每分钟执行一次
done

# 使用双引号或空格作为分隔符
awk -F '"| "' 'NR==40336 {print NF,$NF, $(NF-13)}' /var/log/nginx/access.log
# 输出：
21  /130/

# 更好的方法 - 使用空格分隔并通过字段索引定位IP
awk '{print $(NF-1)}' /var/log/nginx/access.log

# 检查最后一个字段是否为空，如果为空则使用倒数第二个字段
awk -F '"| "' '{ip = ($NF == "") ? $(NF-1) : $NF; print ip}' /var/log/nginx/access.log

# 使用正则表达式分隔符，并确保分隔符不会在行尾创建空字段
awk -F '[" ]+' '{print $(NF-1)}' /var/log/nginx/access.log

# 显示指定行的所有字段及其索引
awk -F '"| "' 'NR==1{for(i=1;i<=NF;i++) print "Field",i,":",$i}' /var/log/nginx/access.log

awk -F '"| "' ' 
     BEGIN{ 
     printf "--------------------------------------------\n|%-14s|%-4s|%-4s|%-4s|\n--------------------------------------------\n","ip地址","访问次数","访问url","访问 次数" 
     } 
     {a[$(NF-1)][$(NF-13)]++} 
     END{ 
     # 遍历数组，统计每个ip的访问总数 
     for(ip in a){ 
          for(uri in a[ip]){ 
          b[ip] += a[ip][uri] 
          } 
     } 
     # 再次遍历 
         for(ip in a){ 
                 for(uri in a[ip]){ 
                         printf "|%16s|%8d|%7s|%8d|\n", ip, b[ip], uri, a[ip][uri] 
                 } 
          } 
          printf "--------------------------------------------\n" 
     } 
' /var/log/nginx/access.log

#!/bin/bash

LOG_FILE="/var/log/nginx/access.log"

awk -F '[" ]+' ' 
     BEGIN { 
         # 使用更清晰的表头
         printf "%s\n", "+------------------+----------+---------+----------+"
         printf "| %-16s | %-8s | %-7s | %-8s |\n", "IP地址", "总访问次数", "访问URL", "URL访问次数"
         printf "%s\n", "+------------------+----------+---------+----------+"
     } 
     { 
         # 更安全的字段访问方式，处理可能的空字段
         ip = ($NF == "") ? $(NF-1) : $(NF-1) 
         uri = $(NF-13) 
         
         # 跳过无效行
         if (ip != "-" && uri != "") { 
             a[ip][uri]++ 
         }
     } 
     END { 
         # 计算每个IP的总访问次数
         for (ip in a) { 
             total = 0
             for (uri in a[ip]) { 
                 total += a[ip][uri] 
             } 
             b[ip] = total
         } 
         
         # 按总访问次数降序排序输出
         # 将结果存储在临时数组中用于排序
         n = 0
         for (ip in b) { 
             ips[n++] = ip
         } 
         
         # 简单冒泡排序（实际应用中数据量大时可改用外部排序）
         for (i = 0; i < n-1; i++) { 
             for (j = i+1; j < n; j++) { 
                 if (b[ips[i]] < b[ips[j]]) { 
                     tmp = ips[i]
                     ips[i] = ips[j]
                     ips[j] = tmp
                 } 
             } 
         } 
         
         # 按排序后的顺序输出结果
         for (i = 0; i < n; i++) { 
             ip = ips[i]
             for (uri in a[ip]) { 
                 printf "| %-16s | %-8d | %-7s | %-8d |\n", ip, b[ip], uri, a[ip][uri] 
             } 
         } 
         
         printf "%s\n", "+------------------+----------+---------+----------+"
         printf "总记录数: %d 个IP地址\n", n
     } 
' "$LOG_FILE"

# 二维数组赋值
array["index1"]["index2"] = value

# 内部实际存储为
array["index1index2"] = value  # 索引间有一个内置的分隔符

awk ' 
  function print_tags(){ 
       printf "---------------------------------------\n" 
  } 
  function print_head(){ 
       printf "|%-4s|%24s|%15s|\n","序号","工作节点","节点类型" 
  } 
  function print_body(arg1,arg2,arg3){ 
       printf "|%-4s|%20s|%15s|\n",arg1,arg2,arg3 
  } 
  BEGIN{ 
       print_tags(); 
       print_head(); 
       print_tags(); 
       seq_num=0; 
  } 
  NR>=2 { 
       type = $1~"master"?"控制节点":"工作节点"; 
       seq_num+=1; 
       print_body(seq_num,$1,type) 
  } 
  END{ 
       print_tags(); 
       printf "|%-20s: %-20d|\n","K8s集群节点数量",seq_num; 
       print_tags(); 
  } 
' nodes.txt

awk ' 
  # 使用常量定义表格宽度，便于统一修改
  BEGIN { 
      # 定义表格样式常量
      BORDER="+---------------------------------------+"
      DIVIDER="|---------------------------------------|"
      
      # 打印表格头部
      print BORDER
      printf "| %-4s | %-20s | %-15s |\n", "序号", "工作节点", "节点类型"
      print DIVIDER
      
      # 初始化计数器
      seq_num=0
  } 
  
  # 跳过标题行
  NR == 1 { next }
  
  # 处理数据行
  { 
      # 更精确的节点类型判断，支持更复杂的角色标识
      type = ($1 ~ "master" || $3 ~ "control-plane") ? "控制节点" : "工作节点"
      
      # 处理节点名称，移除可能的多余空格
      gsub(/[[:space:]]+$/, "", $1)
      
      seq_num++
      # 使用更一致的格式化输出
      printf "| %-4d | %-20s | %-15s |\n", seq_num, $1, type
  } 
  
  # 总结输出
  END { 
      print DIVIDER
      printf "| %-42s |\n", "K8s集群节点数量: " seq_num
      print BORDER
  } 
' nodes.txt

gawk 'BEGIN { print "hello, world" }'

gawk 'BEGIN { print _"hello, world" }'

# 打印CSV文件中特定列
awk -F, '{ print $1, "lives in", $3, "and earns", $4 }' data.csv

# 过滤CSV文件中符合条件的行
awk -F, '$4 > 100000 { print $1, "has a high salary" }' data.csv

# 计算CSV文件中数值列的总和
awk -F, 'NR>1 { sum += $4 } END { print "Total salary:", sum }' data.csv

# 提取日志中的错误信息
awk '/ERROR/ { print }' app.log

# 统计每种日志级别的出现次数
awk '{ level[$3]++ } END { for (l in level) print l ":" level[l] }' app.log

# 提取特定时间段的日志
awk '$1 " " $2 >= "2024-02-01 11:00:00" && $1 " " $2 <= "2024-02-01 15:00:00" { print }' app.log

# 将空格分隔的文件转换为CSV格式
awk 'BEGIN { OFS="," } { print $1, $2, $3, $4 }' awk_test.txt

# 格式化输出（对齐列）
awk '{ printf "%-10s %5d %5d %5d\n", $1, $2, $3, $4 }' awk_test.txt

# 将文本转换为大写
awk '{ print toupper($0) }' awk_test.txt

# 计算第二列的总和、平均值、最大值和最小值
awk '{
    sum += $2
    if (NR == 1 || $2 > max) max = $2
    if (NR == 1 || $2 < min) min = $2
} 
END {
    print "Sum:", sum
    print "Average:", sum/NR
    print "Max:", max
    print "Min:", min
}' awk_test.txt

# 计算每行的总和和平均值
awk '{
    sum = 0
    for (i=2; i<=NF; i++) sum += $i
    avg = sum / (NF-1)
    print $1, "Total:", sum, "Average:", avg
}' awk_test.txt

# 创建awk脚本文件
cat > analyze.awk << 'EOF'
BEGIN {
    print "Student Analysis Report"
    print "====================="
    print "Name\tTotal\tAverage"
    print "---------------------"
}
{
    total = $2 + $3 + $4
    avg = total / 3
    print $1 "\t" total "\t" avg
    all_total += total
    count++
}
END {
    print "---------------------"
    print "Class Average:\t" all_total/count
}
EOF

# 运行awk脚本
awk -f analyze.awk awk_test.txt

# 处理多个文件
awk '{
    print FILENAME ":" NR ":" $0
}' awk_test.txt data.csv

# 在多文件处理中使用FNR（每个文件的行号）
awk '{
    print FILENAME ":" FNR ":" $0
}' awk_test.txt data.csv

# 与sort命令结合
awk '{ print $2, $1 }' awk_test.txt | sort -nr

# 与grep命令结合
ps aux | grep awk | awk '{ print $1, $2, $11 }'

# 读取find命令的输出
find /etc -name "*.conf" -type f -size +1k | xargs ls -lh | awk '{ print $5, $9 }'

# 定义和使用自定义函数
awk 'function calculate_average(num1, num2, num3) {
    return (num1 + num2 + num3) / 3
}
{
    avg = calculate_average($2, $3, $4)
    print $1 "\'s average:", avg
}' awk_test.txt

# 处理包含多个空格或制表符的文件
awk -F'[[:space:]]+' '{ print $1, $2 }' file.txt

# 处理混合分隔符
awk -F'[,;\t ]+' '{ print $1, $2 }' mixed_separators.txt

# 正确处理单引号
awk '\''{ print "It\'s a test" }'\'' file.txt

# 或者使用变量
awk -v quote="'" '{ print "It" quote "s a test" }' file.txt

# 正确处理制表符
awk '{print $1"\t"$3}' file.txt

# 先过滤再处理，提高性能
grep "ERROR" large.log | awk '{ print $1, $2 }'

# 使用next跳过不需要处理的行
awk '$1 == "skip" { next } { print }' large_file.txt

# 错误示例1：使用双引号
$ awk "{print $1, $3}" awk.txt 
awk: 命令行:1: {print , }
awk: 命令行:1:        ^ syntax error
awk: 命令行:1: {print , }
awk: 命令行:1:          ^ syntax error

# 错误示例2：不使用引号
$ awk {print $1, $3} awk.txt 
awk: 命令行:1: {print
awk: 命令行:1:       ^ 未预期的新行或字符串结束

# 正确示例：使用单引号
$ awk '{print $1, $3}' awk.txt 
nihao awk2
nihao awk5
nihao awk8

BEGIN     { FS = ":" }
     { print $1 | "sort" }

     { nlines++ }
END  { print nlines }

# 使用NR变量打印全局行号
awk '{print NR, $0}' awk.txt
# 输出示例：
# 1 nihao awk1 awk2 awk3
# 2 nihao awk4 awk5 awk6
# 3 nihao awk7 awk8 awk9

# 使用FNR变量打印每个文件的行号（多文件处理时有用）
awk '{print FNR, $0}' awk.txt

# 打印第1行的第1个和第3个字段
awk 'NR==1{print $1,$3}' awk.txt
# 输出示例：nihao awk2

# 打印第2行的行号和前两个字段（注意行号和$1之间没有空格）
awk 'NR==2{print NR $1,$2}' awk.txt
# 输出示例：2nihao awk4

# 打印第3行的行号和前两个字段
awk 'NR==3{print NR,$1,$2}' awk.txt
# 输出示例：3 nihao awk7

# 默认使用空格分隔，整个行作为$1
awk '{print $1}' passwd.txt  # passwd.txt内容: root:x:0:0:root:/root:/bin/bash
# 输出示例：root:x:0:0:root:/root:/bin/bash

# 使用-F选项设置冒号为分隔符
awk -F: '{print $2}' passwd.txt
# 输出示例：x

# -F选项后可以有空格
awk -F : '{print $2}' passwd.txt
# 输出示例：x

# -F选项可以使用引号包围分隔符
awk -F ":" '{print $2}' passwd.txt
# 输出示例：x

# 使用-v FS选项设置字段分隔符（更灵活的方式）
awk -v FS=":" '{print $1,$7}' passwd.txt
# 输出示例：root /bin/bash

# 在输出中使用分隔符变量
awk -v FS=":" '{print $1 FS $7}' passwd.txt
# 输出示例：root:/bin/bash

# 字段连接（无分隔符）
awk -v FS=":" '{print $1 $7}' passwd.txt
# 输出示例：root/bin/bash

# 当同时使用-F和-v FS选项时，-F选项的优先级更高
awk -v FS="/" -F ":" '{print $1,$2}' passwd.txt
# 输出示例：root x （使用了冒号作为分隔符）

# 单独使用-v FS选项
awk -v FS="/" '{print $1,$2}' passwd.txt
# 输出示例：root:x:0:0:root: root: （使用了斜杠作为分隔符）

# 使用-v选项设置OFS（输出字段分隔符）
awk -F ":" -v OFS="~~" '{print $1,$7}' passwd.txt
# 输出示例：root~~/bin/bash

# 在BEGIN块中设置OFS和FS（注意：OFS值需要加引号）
awk -F ':' 'BEGIN{OFS="~~~";FS=":"}{print $1,$3,$7}' passwd.txt
# 输出示例：root~~~0~~~/bin/bash

# 错误示例：OFS值没有加引号会导致语法错误
# awk -F ':' 'BEGIN{OFS=~~~;FS=":"}{print $1,$3,$7}' passwd.txt
# 错误：syntax error

# 错误示例：Begin不是大写会导致设置无效
awk -F: 'Begin{OFS=",";FS=":"}{print $1,$3,$7}' passwd.txt
# 输出示例：root 0 /bin/bash （OFS设置无效，使用默认空格）

# 正确示例：BEGIN必须大写
awk -F: 'BEGIN{OFS=",";FS=":"}{print $1,$3,$7}' passwd.txt
# 输出示例：root,0,/bin/bash

# 可以只设置OFS，使用-F设置的FS
awk -F: 'BEGIN{OFS=","}{print $1,$3,$7}' passwd.txt
# 输出示例：root,0,/bin/bash

# 在BEGIN块中同时设置FS和OFS，不使用-F选项
awk 'BEGIN{OFS=",";FS=":"}{print $1,$3,$7}' passwd.txt
# 输出示例：root,0,/bin/bash

# 重要提示：FS必须是源文件中存在的字符，否则无法正确分割
# 下面示例使用空格作为分隔符，但passwd.txt实际使用冒号分隔
awk 'BEGIN{OFS=",";FS=" "}{print $1,$3,$7}' passwd.txt
# 输出示例：root:x:0:0:root:/root:/bin/bash,, （只识别到第一个字段）

# 生成1到7的序列，每个数字占一行
seq 7
# 输出示例：
# 1
# 2
# 3
# 4
# 5
# 6
# 7

# 设置RS为空字符串，将所有行作为一个记录处理
seq 7 | awk 'BEGIN{RS=""}{print $1,$2,$3,$4,$5,$6,$7}'
# 输出示例：1 2 3 4 5 6 7

# 创建测试文件awk.txt
cat awk.txt
# 输出示例：
# nihao awk1 awk2 awk3 
# nihao awk4 awk5 awk6 
# nihao awk7 awk8 awk9 

# 使用-F":"（冒号作为输入分隔符，但文件中没有冒号），OFS="|"（管道作为输出分隔符）
# 打印行号和整行内容
awk -F ":" -v OFS="|" '{print NR,$0}' awk.txt
# 输出：
# 1|nihao awk1 awk2 awk3 
# 2|nihao awk4 awk5 awk6 
# 3|nihao awk7 awk8 awk9 

# 打印行号和$1（由于没有冒号，整行被视为$1）
awk -F ":" -v OFS="|" '{print NR,$1}' awk.txt
# 输出与上面相同，因为$1就是整行内容

# 打印行号和$2（由于没有冒号分隔，$2为空）
awk -F ":" -v OFS="|" '{print NR,$2}' awk.txt
# 输出：
# 1| 
# 2| 
# 3| 

# 使用空格作为分隔符（默认也是空格）
awk -F " " -v OFS="|" '{print NR,$1,$2,$3,$4}' awk.txt
# 输出：
# 1|nihao|awk1|awk2|awk3 
# 2|nihao|awk4|awk5|awk6 
# 3|nihao|awk7|awk8|awk9 

# 使用printf打印单个字段（字符串格式）
awk '{printf "%s\n",$1}' awk.txt
# 输出：
# nihao 
# nihao 
# nihao 

# 打印第二个字段（字符串格式）
awk '{printf "%s\n",$2}' awk.txt
# 输出：
# awk1 
# awk4 
# awk7 

# 注意：printf需要明确指定格式说明符和转义序列
# 下面的例子只有一个格式说明符%s，但提供了两个参数$1和$2
# 此时只有第一个参数$1被使用
awk '{printf "%s\n",$1,$2}' awk.txt
# 输出与第一个例子相同，只有$1被打印