find . -name "*.md" -type f -exec grep -lE "Finished" {} + | while read file; do
  if ! grep -q "2025-05-31" "$file"; then
    number=$(awk '/^pages: [0-9]+/ {print $2}' "$file")
    if [ -n "$number" ]; then
      sed -i "/Finished/i\\- 2025-05-31: $number" "$file"
      echo "已处理: $file - 插入: - 2025-05-31: $number"
    else
      echo "跳过: $file (未找到pages数字或有效日期)"
    fi
  else
    echo "排除: $file (包含 2025-05-31)"
  fi
donecopy

# 创建备份和日志
backup_dir="backup_$(date +%Y%m%d)"
mkdir -p "$backup_dir"
log_file="replace_log.txt"

echo "开始替换操作 $(date)" > "$log_file"

find . -name "*.md" -type f | while read file; do
    # 检查文件是否包含目标字符串
    if grep -q "- 2025-06-01: Finished" "$file"; then
        # 创建备份
        cp "$file" "$backup_dir/$(basename "$file")"
        # 执行替换
        sed -i 's/- 2025-06-01: Finished/- 2025-05-31: Finished/g' "$file"
        # 记录日志
        echo "已修改: $file" >> "$log_file"
        # 显示变更
        echo "=== $file 修改内容 ==="
        diff "$backup_dir/$(basename "$file")" "$file" || true
    else
        echo "无修改: $file" >> "$log_file"
    fi
done

echo "操作完成，备份在 $backup_dir，日志见 $log_file"copy

find . -name "*.md" -type f -exec grep -l "lists: book" {} + | \
while read file; do
    if ! grep -q "Finished" "$file"; then
        # 确保文件末尾有空行（避免追加内容粘连）
        [ -n "$(tail -c 1 "$file")" ] && echo >> "$file"
        # 追加内容
        echo "- 2025-06-01: Finished" >> "$file"
        echo "已处理: $file"
    else
        echo "跳过: $file (已包含 Finished)"
    fi
donecopy

find . -name "*.md" -type f -exec grep -L "Finished" {} + | while read file; do
    awk 'BEGIN {done=0} /^---/ && !done {print; print "- 2025-06-01: Finished"; done=1; next} 1' "$file" > tmp && mv tmp "$file"
donecopy

num = 42  -- Numbers can be integer or floating point.

s = 'walternate'  -- Immutable strings like Python.
t = "double-quotes are also fine"
u = [[ Double brackets
       start and end
       multi-line strings.]]
t = nil  -- Undefines t; Lua has garbage collection.copy

if num > 40 then
  print('over 40')
elseif s ~= 'walternate' then  -- ~= is not equals.
  -- Equality check is == like Python; ok for strs.
  io.write('not over 40\n')  -- Defaults to stdout.
else
  -- Variables are global by default.
  thisIsGlobal = 5  -- Camel case is common.

  -- How to make a variable local:
  local line = io.read()  -- Reads next stdin line.

  -- String concatenation uses the .. operator:
  print('Winter is coming, ' .. line)
end

-- Undefined variables return nil.
-- This is not an error:
foo = anUnknownVariable  -- Now foo = nil.

aBoolValue = false

-- Only nil and false are falsy; 0 and '' are true!
if not aBoolValue then print('it was false') end

-- 'or' and 'and' are short-circuited.
-- This is similar to the a?b:c operator in C/js:
ans = aBoolValue and 'yes' or 'no'  --> 'no'

karlSum = 0
for i = 1, 100 do  -- The range includes both ends.
  karlSum = karlSum + i
end

-- Use "100, 1, -1" as the range to count down:
fredSum = 0
for j = 100, 1, -1 do fredSum = fredSum + j end

-- In general, the range is begin, end[, step].

-- Another loop construct:
repeat
  print('the way of the future')
  num = num - 1
until num == 0copy

for k, v in pairs(t) do
    print(k, v)
end

array = {"Google", "Runoob"}

for key,value in ipairs(array)
do
   print(key, value)
endcopy

function fib(n)
  if n < 2 then return 1 end
  return fib(n - 2) + fib(n - 1)
end

-- Closures and anonymous functions are ok:
function adder(x)
  -- The returned function is created when adder is
  -- called, and remembers the value of x:
  return function (y) return x + y end
end
a1 = adder(9)
a2 = adder(36)
print(a1(16))  --> 25
print(a2(64))  --> 100

-- Returns, func calls, and assignments all work
-- with lists that may be mismatched in length.
-- Unmatched receivers are nil;
-- unmatched senders are discarded.

x, y, z = 1, 2, 3, 4
-- Now x = 1, y = 2, z = 3, and 4 is thrown away.

function bar(a, b, c)
  print(a, b, c)
  return 4, 8, 15, 16, 23, 42
end

x, y = bar('zaphod')  --> prints "zaphod  nil nil"
-- Now x = 4, y = 8, values 15...42 are discarded.

-- Functions are first-class, may be local/global.
-- These are the same:
function f(x) return x * x end
f = function (x) return x * x end

-- And so are these:
local function g(x) return math.sin(x) end
local g; g  = function (x) return math.sin(x) end
-- the 'local g' decl makes g-self-references ok.

-- Calls with one string param don't need parens:
print 'hello'  -- Works fine.copy

--[[
local function 函数名(...)
    local args = {...} -- 转为表
    -- 处理args
end
]]

local function sum(...)
    local result = 0
    for _, num in ipairs({...}) do
        result = result + num
    end
    return result
end
print(sum(1, 2, 3)) -- 输出: 6copy

local greet = function(name)
    print("Hello, " .. name)
end
greet("World") -- 输出: Hello, Worldcopy

local person = {
    name = "Alice",
    sayHi = function(self)
        print("Hi, I'm " .. self.name)
    end
}
person:sayHi() -- 输出: Hi, I'm Alice
-- 等价于 person.sayHi(person)copy

-- Dict literals have string keys by default:
t = {key1 = 'value1', key2 = false}

-- String keys can use js-like dot notation:
print(t.key1)  -- Prints 'value1'.
t.newKey = {}  -- Adds a new key/value pair.
t.key2 = nil   -- Removes key2 from the table.

-- Literal notation for any (non-nil) value as key:
u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
print(u[6.28])  -- prints "tau"

-- Key matching is basically by value for numbers
-- and strings, but by identity for tables.
a = u['@!#']  -- Now a = 'qbert'.
b = u[{}]     -- We might expect 1729, but it's nil:
-- b = nil since the lookup fails. It fails
-- because the key we used is not the same object
-- as the one used to store the original value. So
-- strings & numbers are more portable keys.

-- A one-table-param function call needs no parens:
function h(x) print(x.key1) end
h{key1 = 'Sonmi~451'}  -- Prints 'Sonmi~451'.

for key, val in pairs(u) do  -- Table iteration.
  print(key, val)
end

-- _G is a special table of all globals.
print(_G['_G'] == _G)  -- Prints 'true'.

-- Using tables as lists / arrays:

-- List literals implicitly set up int keys:
v = {'value1', 'value2', 1.21, 'gigawatts'}
for i = 1, #v do  -- #v is the size of v for lists.
  print(v[i])  -- Indices start at 1 !! SO CRAZY!
end
-- A 'list' is not a real type. v is just a table
-- with consecutive integer keys, treated as a list.

-- 初始化表
mytable = {}

-- 指定值
mytable[1]= "Lua"

-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存copy

-- 简单的 table
mytable = {}
print("mytable 的类型是 ",type(mytable))

mytable[1]= "Lua"
mytable["wow"] = "修改前"
print("mytable 索引为 1 的元素是 ", mytable[1])
print("mytable 索引为 wow 的元素是 ", mytable["wow"])

-- alternatetable和mytable的是指同一个 table
alternatetable = mytable

print("alternatetable 索引为 1 的元素是 ", alternatetable[1])
print("alternatetable 索引为 wow 的元素是 ", alternatetable["wow"])

alternatetable["wow"] = "修改后"

print("mytable 索引为 wow 的元素是 ", mytable["wow"])

-- 释放变量
alternatetable = nil
print("alternatetable 是 ", alternatetable)

-- mytable 仍然可以访问
print("mytable 索引为 wow 的元素是 ", mytable["wow"])

mytable = nil
print("mytable 是 ", mytable)copy

mytable 的类型是        table
mytable 索引为 1 的元素是       Lua
mytable 索引为 wow 的元素是     修改前
alternatetable 索引为 1 的元素是        Lua
alternatetable 索引为 wow 的元素是      修改前
mytable 索引为 wow 的元素是     修改后
alternatetable 是       nil
mytable 索引为 wow 的元素是     修改后
mytable 是      nilcopy

-- Explanation for this example is below it.

Dog = {}                                   -- 1.

function Dog:new()                         -- 2.
  newObj = {sound = 'woof'}                -- 3.
  self.__index = self                      -- 4.
  return setmetatable(newObj, self)        -- 5.
end

function Dog:makeSound()                   -- 6.
  print('I say ' .. self.sound)
end

mrDog = Dog:new()                          -- 7.
mrDog:makeSound()  -- 'I say woof'         -- 8.

-- 1. Dog acts like a class; it's really a table.
-- 2. function tablename:fn(...) is the same as
--    function tablename.fn(self, ...)
--    The : just adds a first arg called self.
--    Read 7 & 8 below for how self gets its value.
-- 3. newObj will be an instance of class Dog.
-- 4. self = the class being instantiated. Often
--    self = Dog, but inheritance can change it.
--    newObj gets self's functions when we set both
--    newObj's metatable and self's __index to self.
-- 5. Reminder: setmetatable returns its first arg.
-- 6. The : works as in 2, but this time we expect
--    self to be an instance instead of a class.
-- 7. Same as Dog.new(Dog), so self = Dog in new().
-- 8. Same as mrDog.makeSound(mrDog); self = mrDog.

----------------------------------------------------

-- Inheritance example:

LoudDog = Dog:new()                           -- 1.

function LoudDog:makeSound()
  s = self.sound .. ' '                       -- 2.
  print(s .. s .. s)
end

seymour = LoudDog:new()                       -- 3.
seymour:makeSound()  -- 'woof woof woof'      -- 4.

-- 1. LoudDog gets Dog's methods and variables.
-- 2. self has a 'sound' key from new(), see 3.
-- 3. Same as LoudDog.new(LoudDog), and converted to
--    Dog.new(LoudDog) as LoudDog has no 'new' key,
--    but does have __index = Dog on its metatable.
--    Result: seymour's metatable is LoudDog, and
--    LoudDog.__index = LoudDog. So seymour.key will
--    = seymour.key, LoudDog.key, Dog.key, whichever
--    table is the first with the given key.
-- 4. The 'makeSound' key is found in LoudDog; this
--    is the same as LoudDog.makeSound(seymour).

-- If needed, a subclass's new() is like the base's:
function LoudDog:new()
  newObj = {}
  -- set up newObj
  self.__index = self
  return setmetatable(newObj, self)
endcopy

local M = {}

local function sayMyName()
  print('Hrunkner')
end

function M.sayHello()
  print('Why hello there')
  sayMyName()
end

return M

-- Another file can use mod.lua's functionality:
local mod = require('mod')  -- Run the file mod.lua.

-- require is the standard way to include modules.
-- require acts like:     (if not cached; see below)
local mod = (function ()
  <contents of mod.lua>
end)()
-- It's like mod.lua is a function body, so that
-- locals inside mod.lua are invisible outside it.

-- This works because mod here = M in mod.lua:
mod.sayHello() -- Prints: Why hello there Hrunkner

-- This is wrong; sayMyName only exists in mod.lua:
mod.sayMyName()  -- error

-- require's return values are cached so a file is
-- run at most once, even when require'd many times.

-- Suppose mod2.lua contains "print('Hi!')".
local a = require('mod2')  -- Prints Hi!
local b = require('mod2')  -- Doesn't print; a=b.

-- dofile is like require without caching:
dofile('mod2.lua')  --> Hi!
dofile('mod2.lua')  --> Hi! (runs it again)

-- loadfile loads a lua file but doesn't run it yet.
f = loadfile('mod2.lua')  -- Call f() to run it.

-- load is loadfile for strings.
-- (loadstring is deprecated, use load instead)
g = load('print(343)')  -- Returns a function.
g()  -- Prints out 343; nothing printed before now.copy

-- Two dashes start a one-line comment.

--[[
     Adding two ['s and ]'s makes it a
     multi-line comment.
--]]copy

----------------------------------------------------
-- 1. Variables and flow control.
----------------------------------------------------


-- Blocks are denoted with keywords like do/end:
while num < 50 do
  num = num + 1  -- No ++ or += type operators.
end

-- If clauses:



----------------------------------------------------
-- 2. Functions.
----------------------------------------------------



----------------------------------------------------
-- 3. Tables.
----------------------------------------------------

-- Tables = Lua's only compound data structure;
--          they are associative arrays.
-- Similar to php arrays or js objects, they are
-- hash-lookup dicts that can also be used as lists.

-- Using tables as dictionaries / maps:

-- Dict literals have string keys by default:
t = {key1 = 'value1', key2 = false}

-- String keys can use js-like dot notation:
print(t.key1)  -- Prints 'value1'.
t.newKey = {}  -- Adds a new key/value pair.
t.key2 = nil   -- Removes key2 from the table.

-- Literal notation for any (non-nil) value as key:
u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
print(u[6.28])  -- prints "tau"

-- Key matching is basically by value for numbers
-- and strings, but by identity for tables.
a = u['@!#']  -- Now a = 'qbert'.
b = u[{}]     -- We might expect 1729, but it's nil:
-- b = nil since the lookup fails. It fails
-- because the key we used is not the same object
-- as the one used to store the original value. So
-- strings & numbers are more portable keys.

-- A one-table-param function call needs no parens:
function h(x) print(x.key1) end
h{key1 = 'Sonmi~451'}  -- Prints 'Sonmi~451'.

for key, val in pairs(u) do  -- Table iteration.
  print(key, val)
end

-- _G is a special table of all globals.
print(_G['_G'] == _G)  -- Prints 'true'.

-- Using tables as lists / arrays:

-- List literals implicitly set up int keys:
v = {'value1', 'value2', 1.21, 'gigawatts'}
for i = 1, #v do  -- #v is the size of v for lists.
  print(v[i])  -- Indices start at 1 !! SO CRAZY!
end
-- A 'list' is not a real type. v is just a table
-- with consecutive integer keys, treated as a list.

----------------------------------------------------
-- 3.1 Metatables and metamethods.
----------------------------------------------------

-- A table can have a metatable that gives the table
-- operator-overloadish behavior. Later we'll see
-- how metatables support js-prototype behavior.

f1 = {a = 1, b = 2}  -- Represents the fraction a/b.
f2 = {a = 2, b = 3}

-- This would fail:
-- s = f1 + f2

metafraction = {}
function metafraction.__add(f1, f2)
  sum = {}
  sum.b = f1.b * f2.b
  sum.a = f1.a * f2.b + f2.a * f1.b
  return sum
end

setmetatable(f1, metafraction)
setmetatable(f2, metafraction)

s = f1 + f2  -- call __add(f1, f2) on f1's metatable

-- f1, f2 have no key for their metatable, unlike
-- prototypes in js, so you must retrieve it as in
-- getmetatable(f1). The metatable is a normal table
-- with keys that Lua knows about, like __add.

-- But the next line fails since s has no metatable:
-- t = s + s
-- Class-like patterns given below would fix this.

-- An __index on a metatable overloads dot lookups:
defaultFavs = {animal = 'gru', food = 'donuts'}
myFavs = {food = 'pizza'}
setmetatable(myFavs, {__index = defaultFavs})
eatenBy = myFavs.animal  -- works! thanks, metatable

-- Direct table lookups that fail will retry using
-- the metatable's __index value, and this recurses.

-- An __index value can also be a function(tbl, key)
-- for more customized lookups.

-- Values of __index,add, .. are called metamethods.
-- Full list. Here a is a table with the metamethod.

-- __add(a, b)                     for a + b
-- __sub(a, b)                     for a - b
-- __mul(a, b)                     for a * b
-- __div(a, b)                     for a / b
-- __mod(a, b)                     for a % b
-- __pow(a, b)                     for a ^ b
-- __unm(a)                        for -a
-- __concat(a, b)                  for a .. b
-- __len(a)                        for #a
-- __eq(a, b)                      for a == b
-- __lt(a, b)                      for a < b
-- __le(a, b)                      for a <= b
-- __index(a, b)  <fn or a table>  for a.b
-- __newindex(a, b, c)             for a.b = c
-- __call(a, ...)                  for a(...)

----------------------------------------------------
-- 3.2 Class-like tables and inheritance.
----------------------------------------------------

-- Classes aren't built in; there are different ways
-- to make them using tables and metatables.


----------------------------------------------------
-- 4. Modules.
----------------------------------------------------


--[[ I'm commenting out this section so the rest of
--   this script remains runnable.
-- Suppose the file mod.lua looks like this:
local M = {}

local function sayMyName()
  print('Hrunkner')
end

function M.sayHello()
  print('Why hello there')
  sayMyName()
end

return M

-- Another file can use mod.lua's functionality:
local mod = require('mod')  -- Run the file mod.lua.

-- require is the standard way to include modules.
-- require acts like:     (if not cached; see below)
local mod = (function ()
  <contents of mod.lua>
end)()
-- It's like mod.lua is a function body, so that
-- locals inside mod.lua are invisible outside it.

-- This works because mod here = M in mod.lua:
mod.sayHello() -- Prints: Why hello there Hrunkner

-- This is wrong; sayMyName only exists in mod.lua:
mod.sayMyName()  -- error

-- require's return values are cached so a file is
-- run at most once, even when require'd many times.

-- Suppose mod2.lua contains "print('Hi!')".
local a = require('mod2')  -- Prints Hi!
local b = require('mod2')  -- Doesn't print; a=b.

-- dofile is like require without caching:
dofile('mod2.lua')  --> Hi!
dofile('mod2.lua')  --> Hi! (runs it again)

-- loadfile loads a lua file but doesn't run it yet.
f = loadfile('mod2.lua')  -- Call f() to run it.

-- load is loadfile for strings.
-- (loadstring is deprecated, use load instead)
g = load('print(343)')  -- Returns a function.
g()  -- Prints out 343; nothing printed before now.

--]]copy

awk '{print $5}' path/to/filecopy

awk '/foo/ {print $2}' path/to/filecopy

awk -F ',' '{print $NF}' path/to/filecopy

awk '{s+=$1} END {print s}' path/to/filecopy

awk 'NR%3==1' path/to/filecopy

awk '{if ($1 == "foo") print "Exact match foo"; else if ($1 ~ "bar") print "Partial match bar"; else print "Baz"}' path/to/filecopy

awk '($10 >= min_value && $10 <= max_value)'copy

awk 'BEGIN {FS=":";printf "%-20s %6s %25s\n", "Name", "UID", "Shell"} $4 >= 1000 {printf "%-20s %6d %25s\n", $1, $4, $7}' /etc/passwdcopy

$ awk -F: '{print $1, $NF}' /etc/passwdcopy

BEGIN          {<initializations>}
   <pattern 1> {<program actions>}
   <pattern 2> {<program actions>}
   ...
END            {< final actions >}copy

awk '
    BEGIN { print "\n>>>Start" }
    !/(login|shutdown)/ { print NR, $0 }
    END { print "<<<END\n" }
' /etc/passwdcopy

          $1      $2/$(NF-1)    $3/$NF
           ▼          ▼           ▼
        ┌──────┬──────────────────┬───────┐
$0/NR ▶ │  ID  │  WEBSITE         │  URI  │
        ├──────┼──────────────────┼───────┤
$0/NR ▶ │  1   │  cheatsheets.zip │  awk  │
        ├──────┼──────────────────┼───────┤
$0/NR ▶ │  2   │  google.com      │  25   │
        └──────┴──────────────────┴───────┘copy

# First and last field
awk -F: '{print $1,$NF}' /etc/passwd

# With line number
awk -F: '{print NR, $0}' /etc/passwd

# Second last field
awk -F: '{print $(NF-1)}' /etc/passwd

# Custom string
awk -F: '{print $1 "=" $6}' /etc/passwdcopy

awk 'BEGIN {print "hello world"}'        # Prints "hello world"
awk -F: '{print $1}' /etc/passwd         # -F: Specify field separator

# /pattern/ Execute actions only for matched pattern
awk -F: '/root/ {print $1}' /etc/passwd

# BEGIN block is executed once at the start
awk -F: 'BEGIN { print "uid"} { print $1 }' /etc/passwd

# END block is executed once at the end
awk -F: '{print $1} END { print "-done-"}' /etc/passwdcopy

awk -F: '$3>30 {print $1}' /etc/passwdcopy

awk 'BEGIN{
    while (a++ < 1000)
        s=s " ";
    print s
}'copy

awk 'BEGIN {
   fruits["mango"] = "yellow";
   fruits["orange"] = "orange"
   for(fruit in fruits) {
     print "The color of " fruit " is " fruits[fruit]
   }
}'copy

# => 5
awk 'BEGIN{print length("hello")}'
# => HELLO
awk 'BEGIN{print toupper("hello")}'
# => hel
awk 'BEGIN{print substr("hello", 1, 3)}'copy

awk -F: '{sum += $3}
     END { print sum, sum/NR }
' /etc/passwdcopy

awk 'BEGIN {
    for (i = 1; i < ARGC; i++)
        print ARGV[i] }' a b ccopy

awk 'BEGIN { FS=":";OFS=","}
    {print $1,$2,$3,$4}' /etc/passwdcopy

awk 'BEGIN {
    if (match("One Two Three", "Tw"))
        print RSTART }'copy

awk 'BEGIN {
    if (match("One Two Three", "re"))
        print RLENGTH }'copy

awk -v var1="Hello" -v var2="Wold" '
    END {print var1, var2}
' </dev/nullcopy

awk -v varName="$PWD" '
    END {print varName}' </dev/nullcopy

awk 'BEGIN {
    if ("foo" ~ "^fo+$")
        print "Fooey!";
}'copy

awk 'BEGIN {
    if ("boo" !~ "^fo+$")
        print "Boo!";
}'copy

awk 'BEGIN {
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";
    if ("foo" in assoc)
        print "Fooey!";
}'copy

awk '
    # Returns minimum number
    function find_min(num1, num2){
       if (num1 < num2)
       return num1
       return num2
    }
    # Returns maximum number
    function find_max(num1, num2){
       if (num1 > num2)
       return num1
       return num2
    }
    # Main function
    function main(num1, num2){
       result = find_min(num1, num2)
       print "Minimum =", result

       result = find_max(num1, num2)
       print "Maximum =", result
    }
    # Script execution starts here
    BEGIN {
       main(10, 60)
    }
'copy

awk 'BEGIN {
    arr[0] = "foo";
    arr[1] = "bar";
    print(arr[0]); # => foo
    delete arr[0];
    print(arr[0]); # => ""
}'copy

awk 'BEGIN {
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";
    print("baz" in assoc); # => 0
    print("foo" in assoc); # => 1
}'copy

awk 'BEGIN {
    split("foo:bar:baz", arr, ":");
    for (key in arr)
        print arr[key];
}'copy

awk 'BEGIN {
    arr[0] = 3
    arr[1] = 2
    arr[2] = 4
    n = asort(arr)
    for (i = 1; i <= n ; i++)
        print(arr[i])
}'copy

awk 'BEGIN {
    multidim[0,0] = "foo";
    multidim[0,1] = "bar";
    multidim[1,0] = "baz";
    multidim[1,1] = "boo";
}'copy

awk 'BEGIN {
    array[1,2]=3;
    array[2,3]=5;
    for (comb in array) {
        split(comb,sep,SUBSEP);
        print sep[1], sep[2],
        array[sep[1],sep[2]]
    }
}'copy

awk -v count=2 'BEGIN {
    if (count == 1)
        print "Yes";
    else
        print "Huh?";
}'copy

awk -v count=2 'BEGIN {
    print (count==1) ? "Yes" : "Huh?";
}'copy

awk 'BEGIN {
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";
    if ("foo" in assoc)
        print "Fooey!";
}'copy

awk 'BEGIN {
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";
    if ("Huh" in assoc == 0 )
        print "Huh!";
}'copy

awk -F: '{
    switch (NR * 2 + 1) {
        case 3:
        case "11":
            print NR - 1
            break

        case /2[[:digit:]]+/:
            print NR

        default:
            print NR + 1

        case -1:
            print NR * -1
    }
}' /etc/passwdcopy

awk 'BEGIN {
    for (i = 0; i < 10; i++)
        print "i=" i;
}'copy

awk 'BEGIN {
    for (i = 1; i <= 100; i *= 2)
        print i
}'copy

awk 'BEGIN {
    assoc["key1"] = "val1"
    assoc["key2"] = "val2"
    for (key in assoc)
        print assoc[key];
}'copy

awk 'BEGIN {
    for (argnum in ARGV)
        print ARGV[argnum];
}' a b ccopy

awk -F: '{ x[NR] = $0 }
    END {
        for (i = NR; i > 0; i--)
        print x[i]
    }
' /etc/passwdcopy

awk -F: '{
    for (i = NF; i > 0; i--)
        printf("%s ",$i);
    print ""
}' /etc/passwdcopy

awk -F: '{
    s=0;
    for (i = 1; i <= NF; i++)
        s += $i;
    print s
}' /etc/passwdcopy

awk -F: '
    {for (i = 1; i <= NF; i++)
        s += $i;
    };
    END{print s}
' /etc/passwdcopy

awk 'BEGIN {
    while (a < 10) {
        print "- " " concatenation: " a
        a++;
    }
}'copy

awk '{
    i = 1
    do {
        print $0
        i++
    } while (i <= 5)
}' /etc/passwdcopy

awk 'BEGIN {
    break_num = 5
    for (i = 0; i < 10; i++) {
        print i
        if (i == break_num)
            break
    }
}'copy

awk 'BEGIN {
    for (x = 0; x <= 10; x++) {
        if (x == 5 || x == 6)
            continue
        printf "%d ", x
    }
    print ""
}'copy

awk 'BEGIN{printf "|%10s|\n", "hello"}'

|     hello|copy

awk 'BEGIN{printf "|%-10s|\n", "hello"}'

|hello     |copy

awk -F: '{
    printf "%-10s %s\n", $1, $(NF-1)
}' /etc/passwd | head -n 3copy

root       /root
bin        /bin
daemon     /sbincopy

awk -F: 'BEGIN {
    printf "%-10s %s\n", "User", "Home"
    printf "%-10s %s\n", "----","----"}
    { printf "%-10s %s\n", $1, $(NF-1) }
' /etc/passwd | head -n 5copy

User       Home
----       ----
root       /root
bin        /bin
daemon     /sbincopy

$ cat demo.awk
#!/usr/bin/awk -f
BEGIN { x = 23 }
      { x += 2 }
END   { print x }
$ awk -f demo.awk /etc/passwd
69copy

#!/bin/shcopy

#!/bin/bashcopy

:<<EOF
注释内容...
注释内容...
注释内容...
EOFcopy

: <<'COMMENT'
这是注释的部分。
可以有多行内容。
COMMENT

:<< '
注释内容...
注释内容...
注释内容...
'

:<<!
注释内容...
注释内容...
注释内容...
!copy

#!/bin/bash
# A simple variable example
greeting=Hello
name=Tux
echo $greeting $namecopy

my_string='Hello, World!my_string="Hello, World!"copy

RUNOOB="www.runoob.com"
LD_LIBRARY_PATH="/bin/"
_var="123"
var2="abc"copy

for file in \` ls / etc \`
for file in $ (ls / etc)copy

my_array=(1 2 3 4 5)copy

#!/bin/bash

myUrl="https://www.google.com"
readonly myUrl
myUrl="https://www.runoob.com"copy

unset variable_namecopy

my_string='Hello, World!'
my_string="Hello, World!"copy

your\_name = "runoob"
\# 使用双引号拼接
greeting = "hello, " $your\_name "!"
greeting\_1 = "hello, ${your\_name}!"
echo $greeting $greeting\_1

\# 使用单引号拼接
greeting\_2 = 'hello, ' $your\_name '!'
greeting\_3 = 'hello, ${your\_name}!'
echo $greeting\_2 $greeting\_3copy

hello, runoob ! hello, runoob !
hello, runoob ! hello, ${your_name} !copy

string = "abcd"
echo ${#string} \# 输出 4copy

数组名=(值1 值2 ... 值n)copy

array_name=(value0 value1 value2 value3)copy

array_name=(
value0
value1
value2
value3
)copy

array_name[0]=value0
array_name[1]=value1
array_name[n]=valuencopy

${数组名[下标]}copy

valuen=${array_name[n]}copy

echo ${array_name[@]}copy

\# 取得数组元素的个数
length = ${#array\_name\[@\]}
\# 或者
length = ${#array\_name\[\*\]}
\# 取得数组单个元素的长度
length = ${#array\_name\[n\]}copy

#!/bin/bash

for arg in "$*"; do
    echo "****:" $arg
done
echo --------------
for arg in "$@"; do
    echo "@@@@:" $arg
donecopy

$ ./testparams.sh This is a test
****: This is a test
--------------
@@@@: This
@@@@: is
@@@@: a
@@@@: testcopy

# ls {ex1,ex2}.sh
ex1.sh  ex2.sh
# ls {ex{1..3},ex4}.sh
ex1.sh  ex2.sh  ex3.sh  ex4.sh
# ls {ex[1-3],ex4}.sh
ex1.sh  ex2.sh  ex3.sh  ex4.shcopy

${var:-string}
${var:+string}
${var:=string}
${var:?string}copy

default_name="Guest"
unset name  # 确保 name 未定义

# 如果 name 为空，则使用 default_name 的值
echo "Hello, ${name:-$default_name}"  # 输出: Hello, Guestcopy

# 是去掉左边(在键盘上#在$之左边)
% 是去掉右边(在键盘上%在$之右边)copy

${var%pattern}
${var%%pattern
${var#pattern}
${var##pattern}copy

# var=testcase
# echo $var
testcase
# echo ${var%s*e}
testca
# echo $var
testcase
# echo ${var%%s*e}
te
# echo ${var#?e}
stcase
# echo ${var##?e}
stcase
# echo ${var##*e}

# echo ${var##*s}
e
# echo ${var##test}
casecopy

${var:num}
${var:num1:num2}
${var/pattern/pattern}
${var//pattern/pattern}copy

[root@centos ~]# var=/home/centos
[root@centos ~]# echo $var
/home/centos
[root@centos ~]# echo ${var:5}
/centos
[root@centos ~]# echo ${var: -6}
centos
[root@centos ~]# echo ${var:(-6)}
centos
[root@centos ~]# echo ${var:1:4}
home
[root@centos ~]# echo ${var/o/h}
/hhme/centos
[root@centos ~]# echo ${var//o/h}
/hhme/centhscopy

type [

[ is a shell builtincopy

if ($i<5)
if [ $i -lt 5 ]
if [ $a -ne 1 -a $a != 2 ]
if [ $a -ne 1] && [ $a != 2 ]
if [[ $a != 1 && $a != 2 ]]

for i in $(seq 0 4);do echo $i;done
for i in \`seq 0 4\`;do echo $i;done
for ((i=0;i<5;i++));do echo $i;done
for i in {0..4};do echo $i;donecopy

[[ "hello" =~ ^h ]]   # 正则匹配（返回 true）copy

# [ ] 必须加引号
[ "$name" = "Alice" ] && echo "Hello Alice"

# [[ ]] 更灵活
[[ $name == A* ]] && echo "Name starts with A"copy

# [ ] 和 [[ ]] 均可，但后者更安全
[ -f "/path/$file" ] && echo "File exists"
[[ -f /path/$file ]] && echo "File exists"copy

# [ ] 用 -a/-o
[ "$age" -gt 18 -a "$age" -lt 60 ] && echo "Valid age"

# [[ ]] 用 &&/||
[[ $age -gt 18 && $age -lt 60 ]] && echo "Valid age"copy

var=$((expression))copy

#!/bin/bash

var=\`df -h | grep tmpfs\`
echo $varcopy

repo=~"/projects/repo1"  # 或直接写 ~/projects/repo1（不加引号）
cd "$repo"               # 此时 $repo 已是展开后的绝对路径copy

#!/bin/bash

# 显式展开家目录
HOME_DIR=$(eval echo "~")  # 或直接写 HOME_DIR="$HOME"

repos=(
    "$HOME_DIR/projects/repo1"
    "$HOME_DIR/work/repo2"
)copy

name="Alice"

echo "Hello, $name"   # 输出: Hello, Alice
echo 'Hello, $name'   # 输出: Hello, $namecopy

echo "Today is $(date)"  # 输出: Today is Mon Jul 1 12:00:00 UTC 2024
echo 'Today is $(date)'  # 输出: Today is $(date)copy

echo "Path is \$HOME"    # 输出: Path is $HOME（\$ 被转义）
echo 'Path is \$HOME'    # 输出: Path is \$HOME（完全字面）copy

echo "She said: 'Hello!'"   # 输出: She said: 'Hello!'
echo 'He said: "Hi!"'       # 输出: He said: "Hi!"copy

alias rm='rm -i'          # 单引号内定义别名（避免变量提前展开）
echo "It's a sunny day."  # 双引号内嵌套单引号（无需转义）copy

echo "Line 1\nLine 2"     # 输出: Line 1\nLine 2（\n 未被转义为换行）
echo -e "Line 1\nLine 2"  # 输出两行（-e 启用转义）
echo 'Line 1\nLine 2'     # 输出: Line 1\nLine 2（完全字面）copy

echo "input a"
read a
echo "input b"
read b

read -n 3 -t 5 -s -p "input 3 charater, wait for 5 seconds, silent" c
echo "$c"

printf "a=%s,b=%s,sum is %s" $a $b $((a + b))copy

#!/bin/bash

for x in $@
do
    echo "Entered arg is $x"
donecopy

#!/bin/bash

LINE=1

while read -r CURRENT_LINE
    do
        echo "$LINE: $CURRENT_LINE"
    ((LINE++))
done < "sample_file.txt"copy

# 将标准错误重定向到文件描述符3，再重定向到文件
exec 3>&1  # 备份标准输出到3
cmd 2>&1 >output.log | tee -a error.log  # 错误流单独处理
exec 1>&3  # 恢复标准输出copy

# 静默执行命令（忽略所有输出）
cmd > /dev/null 2>&1copy

# 将 file.txt 的内容作为 wc 命令的输入
wc -l < file.txtcopy

command << DELIMITER
多行文本...
DELIMITERcopy

# 将多行文本传递给 cat 命令
cat << EOF
第一行
第二行
变量值: $HOME
EOFcopy

第一行
第二行
变量值: /home/usernamecopy

# 将字符串传递给 grep 命令
grep "hello" <<< "hello world"copy

# 从配置文件读取输入
while read line; do
    echo "配置行: $line"
done < config.txtcopy

# 生成多行配置文件
cat > app.conf << EOF
server_ip=192.168.1.1
port=8080
EOFcopy

# 快速检查字符串是否包含子串
grep "error" <<< "$log_content"copy

# 从input.txt读取，结果写入output.txt
command < input.txt > output.txtcopy

# 标准输出到out.log，错误到err.log
command > out.log 2> err.logcopy

# 方式1（推荐）
command &> combined.log

# 方式2（传统写法）
command > combined.log 2>&1copy

# 比较两个目录的文件列表差异
diff <(ls /path/to/dir1) <(ls /path/to/dir2)

# 将输出同时写入文件和压缩
echo "data" | tee >(gzip > output.gz) > original.txtcopy

#!/bin/bash
exec 3>&1  # 备份标准输出到描述符3
exec > >(tee -a stdout.log) 2> >(tee -a stderr.log >&2)  # 分离输出和错误

echo "正常消息"  # 写入stdout.log
ls /nonexistent  # 错误写入stderr.log

exec 1>&3  # 恢复标准输出
echo "回到终端显示"copy

{
    echo "标准输出1"
    echo "标准错误1" >&2
    echo "标准输出2"
    echo "标准错误2" >&2
} > >(grep "标准输出" > out.txt) 2> >(grep "标准错误" > err.txt)copy

if [ ... ]
then
  # if-code
else
  # else-code
ficopy

if [ ... ] ; then
  # if-code
else
  # else-code
ficopy

#!/bin/sh
if [ "$X" -lt "0" ]
then
  echo "X is less than zero"
fi
if [ "$X" -gt "0" ]; then
  echo "X is more than zero"
fi
[ "$X" -le "0" ] && \
      echo "X is less than or equal to  zero"
[ "$X" -ge "0" ] && \
      echo "X is more than or equal to zero"
[ "$X" = "0" ] && \
      echo "X is the string or number \"0\""
[ "$X" = "hello" ] && \
      echo "X matches the string \"hello\""
[ "$X" != "hello" ] && \
      echo "X is not the string \"hello\""
[ -n "$X" ] && \
      echo "X is of nonzero length"
[ -f "$X" ] && \
      echo "X is the path of a real file" || \
      echo "No such file: $X"
[ -x "$X" ] && \
      echo "X is the path of an executable file"
[ "$X" -nt "/etc/passwd" ] && \
      echo "X is a file which is newer than /etc/passwd"


read a
read b
read c

if [ $a == $b -a $b == $c -a $a == $c ] # -a means
then
echo EQUILATERAL

elif [ $a == $b -o $b == $c -o $a == $c ] # -o means or
then
echo ISOSCELES
else
echo SCALENE

ficopy

for i in {1..5}
do
    echo $i
done

for X in cyan magenta yellow
do
    echo $X
donecopy

i=1
while [[ $i -le 10 ]] ; do
   echo "$i"
  (( i += 1 ))
donecopy

# 定义数组（空格分隔元素，可含特殊字符）
fruits=("Apple" "Banana" "Orange" "Grape" "Watermelon")
for fruit in "${fruits[@]}"; do
    echo "Fruit: $fruit"
done
for i in "${!fruits[@]}"; do
    echo "Index $i: ${fruits[i]}"
donecopy

# 定义仓库目录列表（支持绝对路径或相对路径）
repos=(
    "/path/to/repo1"
    "/path/to/repo2"
    "/path/to/repo3"
    "/path/to/repo4"
)

# 遍历所有仓库
for i in "${repos[@]}"; do
    echo "Updating repo: $i"
    cd "$i" || { echo "Failed to enter $i"; continue; }

    # 执行 git pull
    git pull origin main  # 假设分支是 main，根据实际情况修改

    # 检查 git pull 是否成功
    if [ $? -eq 0 ]; then
        echo "Successfully updated: $i"
    else
        echo "Failed to update: $i"
    fi

    echo "----------------------------------"
done

echo "All repositories updated!"copy

#!/bin/sh
docs="Usage: \
\n\tbash $0 [options] \
\nOptions: \
\n\t-N NAME: your name, required\
\n\t-a AGE: your age, required\
\n\t-v: verbose mode, optional\
\nExample: \
\n\t bash $0 -N balabala -a 24 "

usage() {
    echo -e $docs >&2
    exit 1
}

if [ $# -eq 0 ] || [ $1 == -h ]; then usage; fi

## 设置变量的默认值
verbose=n

## 检查变量参数是否缺失
check() {
    opt=$1
    arg=$2

    if [[ $arg =~ ^- ]] || [ ! $arg ]
    then
        echo "ERROR: -$opt expects an corresponding argument" >&2
        usage
    fi
}

## 循环解析脚本的所有positional parameters
while getopts :vN:a: opt
do
    case $opt in
    v)
        verbose=y
        ;;
    N)
        check N $OPTARG
        name=$OPTARG
        ;;
    a)
        check a $OPTARG
        age=$OPTARG
        ;;
    :)
        echo "ERROR: -$OPTARG expects an corresponding argument" >&2
        usage
        ;;
    \?) # shell里'?'具有匹配一位任意字符的作用，因此需要转义为普通字符
        echo "ERROR: unkown option -$OPTARG" >&2
        usage
        ;;
    esac
done

## 如果用户没有提供-N选项
if [ ! $name ]
then
    echo ERROR: option -N is required >&2
    usage
fi

## 如果用户没有提供-a选项
if [ ! $age ]
then
    echo ERROR: option -a is required >&2
    usage
fi

if [ $verbose == n ]
then
    echo "Merry Christmas! $name"
else
    echo "Hello, your name is $name, you are $age years old!"
    echo "Merry Christmas!!"
ficopy

# Cron job example
* * * * * sh /path/to/script.shcopy