精华内容
下载资源
问答
  • 形式说明${var}变量本来的值${var:-word}如果变量 var 为空或已被删除(unset),那么返回 word,但不改变 var 的值。${var:=word}如果变量 var 为空或已被删除(unset),那么返回 word,并将 var 的值设置为 word。$...

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

    特殊替换——${var:-string},${var:+string},${var:=string},${var:?string}

          ①${var:-string}和${var:=string}:若变量var为空,则用在命令行中用string来替换${var:-string},否则变量var不为空时,则用变量var的值来替换${var:-string};不同之处是${var:=string}常用于判断var是否赋值,没有的话则给var赋上一个默认值

          ② ${var:+string}:替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的) 

          ③${var:?string}:替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。

    注意:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。

    模式匹配替换——${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

    # 是去掉左边(在键盘上#在$之左边);% 是去掉右边(在键盘上%在$之右边);#和%中的单一符号是最小匹配,两个相同符号是最大匹配。

    第一种模式:${variable%pattern}。shell在variable中查找,看它是否一给的模式pattern结尾,如果是,把variable去掉右边最短的匹配模式

     第二种模式: ${variable%%pattern},这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,把variable中去掉右边最长的匹配模式

    第三种模式:${variable#pattern} 这种模式时,shell在variable中查找,看它是否一给的模式pattern开始,如果是,把variable中去掉左边最短的匹配模式

     第四种模式: ${variable##pattern} 这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,把variable中去掉左边最长的匹配模式

     这四种模式中都不会改变variable的值,其中,只有在pattern中使用了*匹配符号时,%和%%,#和##才有区别。结构中的pattern支持通配符,*表示零个或多个任意字符,?表示仅与一个任意字符匹配,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符。

    [plain] view plain copy
    1. # var=testcase      
    2. # echo $var      
    3. testcase      
    4. # echo ${var%s*e}     
    5. testca      
    6. # echo $var      
    7. testcase     
    8. # echo ${var%%s*e}     
    9. te    
    10. # echo ${var#?e}      
    11. stcase    
    12. # echo ${var##?e}      
    13. stcase    
    14. # echo ${var##*e}      
    15.     
    16. # echo ${var##*s}      
    17. e      
    18. # echo ${var##test}      
    19. case     
    字符串提取和替换——${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern}

    第一种模式:${var:num},shell在var中提取第num个字符到末尾的所有字符。若num为正数,从左边0处开始;若num为负数,从右边开始提取字串,但必须使用在冒号后面加空格或一个数字或整个num加上括号,如${var: -2}、${var:1-3}或${var:(-2)}。         

    第二种模式:${var:num1:num2},num1是位置,num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数

    第三种模式:${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。

    第四种模式:${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。

    [plain] view plain copy
    1. [root@centos ~]# var=/home/centos    
    2. [root@centos ~]# echo $var    
    3. /home/centos    
    4. [root@centos ~]# echo ${var:5}    
    5. /centos    
    6. [root@centos ~]# echo ${var: -6}    
    7. centos    
    8. [root@centos ~]# echo ${var:(-6)}    
    9. centos    
    10. [root@centos ~]# echo ${var:1:4}    
    11. home    
    12. [root@centos ~]# echo ${var/o/h}    
    13. /hhme/centos    
    14. [root@centos ~]# echo ${var//o/h}    
    15. /hhme/cenths    
    对{}和()而言, 括号中的重定向符只影响该条命令, 而括号外的重定向符影响到括号中的所有命令。
    展开全文
  • Lua中模式匹配

    千次阅读 2016-03-25 01:45:21
    Preface本篇主要讲的是Lua中的模式匹配,大多数资料没有讲得特别详细~这里就将《Lua程序设计》中的内容搬下来。 参考: (1) Lua官方的参考文档 (2) Lua字符串处理模式匹配可以用不同的匹配模式与任意字符串相...

    Preface

    本篇主要讲的是Lua中的模式匹配,大多数资料没有讲得特别详细~这里就将《Lua程序设计》中的内容搬下来。
    参考:
    (1) Lua官方的参考文档
    (2) Lua字符串处理


    模式匹配

    可以用不同的匹配模式与任意字符串相匹配。例如,分类%d可匹配任意数字。如下例可以用模式%d%d/%d%d/%d%d%d%d搜索dd/mm/yyyy格式的日期:

    s = "Deadline is 30/05/1999, firm"
    date = "%d%d/%d%d/%d%d%d%d"
    print(string.sub(s, string.find(s, date)))      --> 30/05/1999

    分类

    下表列出了所有的字符分类:

    . 所有字符
    %a 任何字母
    %c 控制字符
    %d 任何数字
    %g 任何除空白符意外的可大淫字符
    %l 所有小写字母
    %p 所有标点符号
    %s 所有空白字符
    %u 所有大写字母
    %w 字母和数字字符
    %x 十六进制数字
    %x(这里 x 是任何非字母/数字的字符) 表示字符 x。如 %% 表示百分号%,%. 表示点号.,%/ 表示斜杠/
    %z 内部表示为0的字符
    [set] 表示 set 中所有字符的联合,找到其中任一字符即表示匹配。可以用 - 连接,如[0-9] 表示 0 到 9 这十个数字。
    [^set] 表示 set 的补集

    PS:这些分类的大写形式表示它们的补集,例如,%A表示所有非字母字符:

    -- 此处对string.gsub()结果再加一个括号:表示只取第一个值,第二个值为替换的次数
    print((string.gsub("hello, up-down!", "%A", ".")))     --> hello..up.down.

    魔法字符(特殊意义的字符)

    在模式中还有一些字符被成为“魔法字符”, 它们具有特殊的含义。包括以下:

    ( ) . % + - * ? [ ] ^ $

    %作为转义字符。因此,%.表示.(一个点), %%表示%


    字符集

    在一对方括号内将不同的字符分类或者单个字符组合起来,即可创建出属于用户自己的字符分类,这种新的字符分类叫做“字符集(char-set)”。

    例如:
    1. [%w_]:表示同时匹配字符、数字和下画线
    2. [01]:表示匹配二进制数字
    3. [%[%]]:表示匹配方括号本身
    4. nvow = select(2, string.gsub(text, "[AEIOUaeiou]", “ ”)):统计一段文本中元音的数量

    在字符集中包含一段字符范围的做法是写出字符范围的第一个字符和最后一个字符,并用横线连接它们。这个方法用的很少,因为大多数常用的字符范围都已预定义好了,例如[0-7],而不是[01234567]。在一个字符集前加一个^,就可以得到这个字符集的补集。像上例模式[^0-7]表示所有非八进制数字的字符,二模式[^\n]则表示除了换行符意外的其他字符。对于简单的分类,使用其他写形式也可以得到其补集,%S显然要比[^%s]要简单很多。


    修饰符

    Lua中提供4中修饰符:

    + 重复1次或多次,匹配尽可能长的串
    * 重复0次或多次,匹配尽可能长的串
    - 也是重复0次或多次,匹配尽可能短的串
    ? 将匹配零个或一个该类字符
    %n 这里 n 可以从 1 到 9,匹配捕获的第 n 个子串
    %bxy 这里的 x 和 y 是两个明确的字符,匹配以 x 开始 y 结束。如 %b() 匹配包括小括号在内括起来的字符串
    %f[set] 边境模式。匹配位于 set 内某个字符之前的一个空串,且这个位置的前一个字符不属于 set

    示例:

    -- “%a+”表示一个或多个字母,即单词
    print(string.gsub("one, and two; and three", "%a+", "word"))
    --> word, word word; word word
    
    
    -- “%d+”表示匹配一个或多个数字(一个整数)
    print(string.match("the number 1298 is even", "%d+"))    --> 1298

    修饰符*类似于+,但它还接受出现0次的情况。一种典型的用途是匹配一个模式不同部分之间的空格。例如,匹配像()( )这样的一对空圆括号,可以使用模式%(%s*%)其中%s*可匹配0个或者多个空格。另一个示例是用模式[_%a][_%w]*匹配Lua程序中的标识符,标识符是一个由字母或者下画线开始,并伴随0个和多个字符的。

    [_%a][_%w]*[_%a][_%w]-表现的结果是截然不同的。例如,[_%a][_%w]-来查找一个标识符时,只会找到第一个字母,因为[_%w]-总是匹配空串。

    展开全文
  • 模式匹配函数

    2018-01-30 15:00:29
    模式匹配函数 在string库中功能最强大的函数是: string.find(字符串查找) string.gsub(全局字符串替换) string.gfind(全局字符串查找) string.gmatch(返回查找到字符串的迭代器) 这些函数都是...

    模式匹配函数

    在string库中功能最强大的函数是:

    string.find(字符串查找)
    string.gsub(全局字符串替换)
    string.gfind(全局字符串查找)
    string.gmatch(返回查找到字符串的迭代器)

    这些函数都是基于模式匹配的。
    与其他脚本语言不同的是,Lua并不使用POSIX规范的正则表达式[4](也写作regexp)来进行模式匹配。主要的原因出于程序大小方面的考虑:实现一个典型的符合POSIX标准的regexp大概需要4000行代码,这比整个Lua标准库加在一起都大。权衡之下,Lua中的模式匹配的实现只用了500行代码,当然这意味着不可能实现POSIX所规范的所有更能。然而,Lua中的模式匹配功能是很强大的,并且包含了一些使用标准POSIX模式匹配不容易实现的功能。

    string.gmatch(str, pattern)      

    这是一个返回迭代器的函数. 实际的用例如下:

    s = "hello world from Lua"
    for w in string.gmatch(s, "%a+") do
     print(w)
    end

    这里是一个捕获并将配对字符分别存到不同变量的例子:

    t = {}
    s = "from=world, to=Lua"
    for k, v in string.gmatch(s, "(%w+)=(%w+)") do
     t[k]=v
    end
    for k, v in pairs(t) do
     print(k, v)
    end

    string.gsub(str, pattern, repl, n)

    string.gsub()函数根据给定的配对表达式对源字符串str进行配对, 同时返回源字符串的一个副本, 该副本中成功配对的所有子字符串都将被替换. 函数还将返回成功配对的次数.实际的替换行为由repl参数的类型决定:

    当repl为字符串时, 所有成功配对的子字符串均会被替换成指定的repl字串.
    当repl为table时, 对每个成功配对的子字符串, 函数均会试图寻找以其为key值的table中的元素, 并返回该元素. 如果该配对包含任何捕获信息, 则以编号为1号的捕获作为key值进行查找.
    当repl为函数时, 每个成功配对的子字符串均会作为参数被传入到该函数中去.
    在repl是table或函数时, 如果该table或函数返回了字串或数字的值, 这个值依然会被用于替换副本字串中的配对子字串. 如果该table/函数返回的值为空, 将不发生替换.

    n参数可选, 当它被指定时, string.gsub()函数只对源字符串中的前n个成功配对的成员进行操作.

    以下是几个例子:

    > print(string.gsub("hello world", "(%w+)", "%1 %1"))
    hello hello world world 2

    > print(string.gsub("hello Lua", "(%w+)%s*(%w+)", "%2 %1"))
    Lua hello 1

    > string.gsub("hello world", "%w+", print)
    hello world 2

    > lookupTable = {["hello"] = "hola", ["world"] = "mundo"}
    > print(string.gsub("hello world", "(%w+)", lookupTable))
    hola mundo 2


    string.match(str, pattern, init)

    string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1.

    在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil.


    string.match("abcdaef", "a")
    -> a

    string.reverse(str)
    返回一个字符串的倒序排列
    string.reverse("abcde")
    ->edcba

    string.dump(function)
    返回指定函数的二进制代码(函数必须是一个Lua函数,并且没有上值)


    string.find(str, pattern, init, plain) 
    string.find的基本应用就是用来在目标串(subject string)内搜索匹配指定的模式的串。函数如果找到匹配的串返回他的位置,否则返回nil.最简单的模式就是一个单词,仅仅匹配单词本身。比如,模式'hello'仅仅匹配目标串中的"hello"。当查找到模式的时候,函数返回两个值:匹配串开始索引和结束索引。
    s = "hello world"
    string.find(s, "hello")    --> 1    5
    string.find(s, "world")    --> 7    11
    string.find(s, "l")        --> 3    3
    string.find(s, "lll")
          --> nil
    string.find函数第三个参数是可选的:标示目标串中搜索的起始位置。当我们想查找目标串中所有匹配的子串的时候,这个选项非常有用。我们可以不断的循环搜索,每一次从前一次匹配的结束位置开始。下面看一个例子,下面的代码用一个字符串中所有的新行构造一个表:
    local t = {}      -- 存放回车符的位置
    local i = 0
    while true do
        i = string.find(s, "\n", i+1)  -- 查找下一行
        if i == nil then break end
        table.insert(t, i)
    end


    string.sub(str,sPos,ePos)
    string.gsub的功能是截取字符串,他从指定起始位置截取一个字符串。string.sub可以利用string.find返回的值截取匹配的子串。
    对简单模式而言,匹配的就是其本身
    s = "hello world"
    local i, j = string.find(s, "hello")    --> 1    5
    string.sub(s, i, j)        --> hello


    string.gsub(str, sourcestr, desstr)
    string.gsub的基本作用是用来查找匹配模式的串,并将使用替换串其替换掉:
    string.gsub函数有三个参数:目标串,模式串,替换串。
    s = string.gsub("Lua is cute", "cute", "great")
    print(s)      --> Lua is great
    s = string.gsub("all lii", "l", "x")
    print(s)      --> axx xii
    s = string.gsub("Lua is great", "perl", "tcl")
    print(s)      --> Lua is great

    第四个参数是可选的,用来限制替换的范围:
    s = string.gsub("all lii", "l", "x", 1)
    print(s)          --> axl lii
    s = string.gsub("all lii", "l", "x", 2)
    print(s)          --> axx lii

    string.gsub的第二个返回值表示他进行替换操作的次数。例如,下面代码涌来计算一个字符串中空格出现的次数:
    _, count = string.gsub(str, " ", " ")
    (注意,_ 只是一个哑元变量)


    模式

    你还可以在模式串中使用字符类。字符类指可以匹配一个特定字符集合内任何字符的模式项。比如,字符类%d匹配任意数字。所以你可以使用模式串'%d%d/%d%d/%d%d%d%d'搜索dd/mm/yyyy格式的日期:
    s = "Deadline is 30/05/1999, firm"
    date = "%d%d/%d%d/%d%d%d%d"
    print(string.sub(s, string.find(s, date)))    --> 30/05/1999
    下面的表列出了Lua支持的所有字符类:

    单个字符(除^$()%.[]*+-?外): 与该字符自身配对
    .(点): 与任何字符配对
    %a: 与任何字母配对
    %c: 与任何控制符配对(例如\n)
    %d: 与任何数字配对
    %l: 与任何小写字母配对
    %p: 与任何标点(punctuation)配对
    %s: 与空白字符配对
    %u: 与任何大写字母配对
    %w: 与任何字母/数字配对
    %x: 与任何十六进制数配对
    %z: 与任何代表0的字符配对
    %x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对
    [数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
    [^数个字符类]: 与任何包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对

    当上述的字符类用大写书写时, 表示与此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如,'%A'非字母的字符
    print(string.gsub("hello, up-down!", "%A", "."))
        
    --> hello..up.down. 4

    (数字4不是字符串结果的一部分,他是gsub返回的第二个结果,代表发生替换的次数。下面其他的关于打印gsub结果的例子中将会忽略这个数值。)在模式匹配中有一些特殊字符,他们有特殊的意义,Lua中的特殊字符如下:
    ( ) . % + - * ? [ ^ $
    '%' 用作特殊字符的转义字符,因此 '%.' 匹配点;'%%' 匹配字符 '%'。转义字符 '%'不仅可以用来转义特殊字符,还可以用于所有的非字母的字符。当对一个字符有疑问的时候,为安全起见请使用转义字符转义他。
    对Lua而言,模式串就是普通的字符串。他们和其他的字符串没有区别,也不会受到特殊对待。只有他们被用作模式串用于函数的时候,'%' 才作为转义字符。所以,如果你需要在一个模式串内放置引号的话,你必须使用在其他的字符串中放置引号的方法来处理,使用 '\' 转义引号,'\' 是Lua的转义符。你可以使用方括号将字符类或者字符括起来创建自己的字符类(译者:Lua称之为char-set,就是指传统正则表达式概念中的括号表达式)。比如,'[%w_]' 将匹配字母数字和下划线,'[01]' 匹配二进制数字,'[%[%]]' 匹配一对方括号。下面的例子统计文本中元音字母出现的次数:

    _, nvow = string.gsub(text, "[AEIOUaeiou]", "")

    在char-set中可以使用范围表示字符的集合,第一个字符和最后一个字符之间用连字符连接表示这两个字符之间范围内的字符集合。大部分的常用字符范围都已经预定义好了,所以一般你不需要自己定义字符的集合。比如,'%d' 表示 '[0-9]';'%x' 表示 '[0-9a-fA-F]'。然而,如果你想查找八进制数,你可能更喜欢使用 '[0-7]' 而不是 '[01234567]'。你可以在字符集(char-set)的开始处使用 '^' 表示其补集:'[^0-7]' 匹配任何不是八进制数字的字符;'[^\n]' 匹配任何非换行符户的字符。记住,可以使用大写的字符类表示其补集:'%S' 比 '[^%s]' 要简短些。
    Lua的字符类依赖于本地环境,所以 '[a-z]' 可能与 '%l' 表示的字符集不同。在一般情况下,后者包括 'ç' 和 'ã',而前者没有。应该尽可能的使用后者来表示字母,除非出于某些特殊考虑,因为后者更简单、方便、更高效。
    可以使用修饰符来修饰模式增强模式的表达能力,Lua中的模式修饰符有四个:

    +      匹配前一字符1次或多次
    *      匹配前一字符0次或多次
    -      匹配前一字符0次或多次
    ?      匹配前一字符0次或1次

    '+',匹配一个或多个字符,总是进行最长的匹配。比如,模式串 '%a+' 匹配一个或多个字母或者一个单词:


    print(string.gsub("one, and two; and three", "%a+", "word"))
        
    --> word, word word; word word


    '%d+' 匹配一个或多个数字(整数):

    i, j = string.find("the number 1298 is even", "%d+")
    print(i,j)    --> 12  15


    '*' 与 '+' 类似,但是他匹配一个字符0次或多次出现.一个典型的应用是匹配空白。比如,为了匹配一对圆括号()或者括号之间的空白,可以使用 '%(%s*%)'。( '%s*' 用来匹配0个或多个空白。由于圆括号在模式中有特殊的含义,所以我们必须使用 '%' 转义他。)再看一个例子,'[_%a][_%w]*' 匹配Lua程序中的标示符:字母或者下划线开头的字母下划线数字序列。
    '-' 与 '*' 一样,都匹配一个字符的0次或多次出现,但是他进行的是最短匹配。某些时候这两个用起来没有区别,但有些时候结果将截然不同。比如,如果你使用模式 '[_%a][_%w]-' 来查找标示符,你将只能找到第一个字母,因为 '[_%w]-' 永远匹配空。另一方面,假定你想查找C程序中的注释,很多人可能使用 '/%*.*%*/'(也就是说 "/*" 后面跟着任意多个字符,然后跟着 "*/" )。然而,由于 '.*' 进行的是最长匹配,这个模式将匹配程序中第一个 "/*" 和最后一个 "*/" 之间所有部分:

    test = "int x; /* x */ int y; /* y */"
    print(string.gsub(test, "/%*.*%*/", "<COMMENT>"))
     
       --> int x; <COMMENT>


    然而模式 '.-' 进行的是最短匹配她会匹配 "/*" 开始到第一个 "*/" 之前的部分:

    test = "int x; /* x */ int y; /* y */"
    print(string.gsub(test, "/%*.-%*/", "<COMMENT>"))
        --> int x; <COMMENT> int y; <COMMENT>


    '?' 匹配一个字符0次或1次。举个例子,假定我们想在一段文本内查找一个整数,整数可能带有正负号。模式 '[+-]?%d+' 符合我们的要求,它可以匹配像 "-12"、"23" 和 "+1009" 等数字。'[+-]' 是一个匹配 '+' 或者 '-' 的字符类;接下来的 '?' 意思是匹配前面的字符类0次或者1次。
    与其他系统的模式不同的是,Lua中的修饰符不能用字符类;不能将模式分组然后使用修饰符作用这个分组。比如,没有一个模式可以匹配一个可选的单词(除非这个单词只有一个字母)。下面我将看到,通常你可以使用一些高级技术绕开这个限制。
    以 '^' 开头的模式只匹配目标串的开始部分,相似的,以 '$' 结尾的模式只匹配目标串的结尾部分。这不仅可以用来限制你要查找的模式,还可以定位(anchor)模式。比如:

    if string.find(s, "^%d") then ...

    检查字符串s是否以数字开头,而

    if string.find(s, "^[+-]?%d+$") then ...

    检查字符串s是否是一个整数。
    '%b' 用来匹配对称的字符。常写为 '%bxy' ,x和y是任意两个不同的字符;x作为匹配的开始,y作为匹配的结束。比如,'%b()' 匹配以 '(' 开始,以 ')' 结束的字符串:

    print(string.gsub("a (enclosed (in) parentheses) line", "%b()", ""))
    --> a line


    常用的这种模式有:'%b()' ,'%b[]','%b%{%}' 和 '%b<>'。你也可以使用任何字符作为分隔符。


    转自:http://www.cnblogs.com/whiteyun/archive/2009/09/02/1541043.html

    展开全文
  • Lua模式匹配

    2014-11-12 13:34:25
    模式匹配函数 在string库中功能最强大的函数是: string.find(字符串查找) string.gsub(全局字符串替换) string.gfind(全局字符串查找) string.gmatch(返回查找到字符串的迭代器) 这些函数都是基于模式匹配...

    模式匹配函数

    在string库中功能最强大的函数是:

    string.find(字符串查找)
    string.gsub(全局字符串替换)
    string.gfind(全局字符串查找)
    string.gmatch(返回查找到字符串的迭代器)

    这些函数都是基于模式匹配的。
    与其他脚本语言不同的是,Lua并不使用POSIX规范的正则表达式[4](也写作regexp)来进行模式匹配。主要的原因出于程序大小方面的考虑:实现一个典型的符合POSIX标准的regexp大概需要4000行代码,这比整个Lua标准库加在一起都大。权衡之下,Lua中的模式匹配的实现只用了500行代码,当然这意味着不可能实现POSIX所规范的所有更能。然而,Lua中的模式匹配功能是很强大的,并且包含了一些使用标准POSIX模式匹配不容易实现的功能。

    string.gmatch(str, pattern)      

    这是一个返回迭代器的函数. 实际的用例如下:

    s = "hello world from Lua"
    for w in string.gmatch(s, "%a+") do
     print(w)
    end

    这里是一个捕获并将配对字符分别存到不同变量的例子:

    t = {}
    s = "from=world, to=Lua"
    for k, v in string.gmatch(s, "(%w+)=(%w+)") do
     t[k]=v
    end
    for k, v in pairs(t) do
     print(k, v)
    end

    string.gsub(str, pattern, repl, n)

    string.gsub()函数根据给定的配对表达式对源字符串str进行配对, 同时返回源字符串的一个副本, 该副本中成功配对的所有子字符串都将被替换. 函数还将返回成功配对的次数.实际的替换行为由repl参数的类型决定:

    当repl为字符串时, 所有成功配对的子字符串均会被替换成指定的repl字串.
    当repl为table时, 对每个成功配对的子字符串, 函数均会试图寻找以其为key值的table中的元素, 并返回该元素. 如果该配对包含任何捕获信息, 则以编号为1号的捕获作为key值进行查找.
    当repl为函数时, 每个成功配对的子字符串均会作为参数被传入到该函数中去.
    在repl是table或函数时, 如果该table或函数返回了字串或数字的值, 这个值依然会被用于替换副本字串中的配对子字串. 如果该table/函数返回的值为空, 将不发生替换.

    n参数可选, 当它被指定时, string.gsub()函数只对源字符串中的前n个成功配对的成员进行操作.

    以下是几个例子:

    > print(string.gsub("hello world", "(%w+)", "%1 %1"))
    hello hello world world 2

    > print(string.gsub("hello Lua", "(%w+)%s*(%w+)", "%2 %1"))
    Lua hello 1

    > string.gsub("hello world", "%w+", print)
    hello world 2

    > lookupTable = {["hello"] = "hola", ["world"] = "mundo"}
    > print(string.gsub("hello world", "(%w+)", lookupTable))
    hola mundo 2


    string.match(str, pattern, init)

    string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1.

    在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil.


    string.match("abcdaef", "a")
    -> a

    string.reverse(str)
    返回一个字符串的倒序排列
    string.reverse("abcde")
    ->edcba

    string.dump(function)
    返回指定函数的二进制代码(函数必须是一个Lua函数,并且没有上值)


    string.find(str, pattern, init, plain) 
    string.find的基本应用就是用来在目标串(subject string)内搜索匹配指定的模式的串。函数如果找到匹配的串返回他的位置,否则返回nil.最简单的模式就是一个单词,仅仅匹配单词本身。比如,模式'hello'仅仅匹配目标串中的"hello"。当查找到模式的时候,函数返回两个值:匹配串开始索引和结束索引。
    s = "hello world"
    string.find(s, "hello")    --> 1    5
    string.find(s, "world")    --> 7    11
    string.find(s, "l")        --> 3    3
    string.find(s, "lll")      --> nil
    string.find函数第三个参数是可选的:标示目标串中搜索的起始位置。当我们想查找目标串中所有匹配的子串的时候,这个选项非常有用。我们可以不断的循环搜索,每一次从前一次匹配的结束位置开始。下面看一个例子,下面的代码用一个字符串中所有的新行构造一个表:
    local t = {}      -- 存放回车符的位置
    local i = 0
    while true do
        i = string.find(s, "\n", i+1)  -- 查找下一行
        if i == nil then break end
        table.insert(t, i)
    end

    string.sub(str,sPos,ePos)
    string.gsub的功能是截取字符串,他从指定起始位置截取一个字符串。string.sub可以利用string.find返回的值截取匹配的子串。
    对简单模式而言,匹配的就是其本身
    s = "hello world"
    local i, j = string.find(s, "hello")    --> 1    5
    string.sub(s, i, j)        --> hello

    string.gsub(str, sourcestr, desstr)
    string.gsub的基本作用是用来查找匹配模式的串,并将使用替换串其替换掉:
    string.gsub函数有三个参数:目标串,模式串,替换串。
    s = string.gsub("Lua is cute", "cute", "great")
    print(s)      --> Lua is great
    s = string.gsub("all lii", "l", "x")
    print(s)      --> axx xii
    s = string.gsub("Lua is great", "perl", "tcl")
    print(s)      --> Lua is great
    第四个参数是可选的,用来限制替换的范围:
    s = string.gsub("all lii", "l", "x", 1)
    print(s)          --> axl lii
    s = string.gsub("all lii", "l", "x", 2)
    print(s)          --> axx lii
    string.gsub的第二个返回值表示他进行替换操作的次数。例如,下面代码涌来计算一个字符串中空格出现的次数:
    _, count = string.gsub(str, " ", " ")
    (注意,_ 只是一个哑元变量)


    模式

    你还可以在模式串中使用字符类。字符类指可以匹配一个特定字符集合内任何字符的模式项。比如,字符类%d匹配任意数字。所以你可以使用模式串'%d%d/%d%d/%d%d%d%d'搜索dd/mm/yyyy格式的日期:
    s = "Deadline is 30/05/1999, firm"
    date = "%d%d/%d%d/%d%d%d%d"
    print(string.sub(s, string.find(s, date)))    --> 30/05/1999
    下面的表列出了Lua支持的所有字符类:

    单个字符(除^$()%.[]*+-?外): 与该字符自身配对
    .(点): 与任何字符配对
    %a: 与任何字母配对
    %c: 与任何控制符配对(例如\n)
    %d: 与任何数字配对
    %l: 与任何小写字母配对
    %p: 与任何标点(punctuation)配对
    %s: 与空白字符配对
    %u: 与任何大写字母配对
    %w: 与任何字母/数字配对
    %x: 与任何十六进制数配对
    %z: 与任何代表0的字符配对
    %x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对
    [数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
    [^数个字符类]: 与任何包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对

    当上述的字符类用大写书写时, 表示与此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如,'%A'非字母的字符
    print(string.gsub("hello, up-down!", "%A", "."))
        
    --> hello..up.down. 4
    (数字4不是字符串结果的一部分,他是gsub返回的第二个结果,代表发生替换的次数。下面其他的关于打印gsub结果的例子中将会忽略这个数值。)在模式匹配中有一些特殊字符,他们有特殊的意义,Lua中的特殊字符如下:
    ( ) . % + - * ? [ ^ $
    '%' 用作特殊字符的转义字符,因此 '%.' 匹配点;'%%' 匹配字符 '%'。转义字符 '%'不仅可以用来转义特殊字符,还可以用于所有的非字母的字符。当对一个字符有疑问的时候,为安全起见请使用转义字符转义他。
    对Lua而言,模式串就是普通的字符串。他们和其他的字符串没有区别,也不会受到特殊对待。只有他们被用作模式串用于函数的时候,'%' 才作为转义字符。所以,如果你需要在一个模式串内放置引号的话,你必须使用在其他的字符串中放置引号的方法来处理,使用 '\' 转义引号,'\' 是Lua的转义符。你可以使用方括号将字符类或者字符括起来创建自己的字符类(译者:Lua称之为char-set,就是指传统正则表达式概念中的括号表达式)。比如,'[%w_]' 将匹配字母数字和下划线,'[01]' 匹配二进制数字,'[%[%]]' 匹配一对方括号。下面的例子统计文本中元音字母出现的次数:

    _, nvow = string.gsub(text, "[AEIOUaeiou]", "")

    在char-set中可以使用范围表示字符的集合,第一个字符和最后一个字符之间用连字符连接表示这两个字符之间范围内的字符集合。大部分的常用字符范围都已经预定义好了,所以一般你不需要自己定义字符的集合。比如,'%d' 表示 '[0-9]';'%x' 表示 '[0-9a-fA-F]'。然而,如果你想查找八进制数,你可能更喜欢使用 '[0-7]' 而不是 '[01234567]'。你可以在字符集(char-set)的开始处使用 '^' 表示其补集:'[^0-7]' 匹配任何不是八进制数字的字符;'[^\n]' 匹配任何非换行符户的字符。记住,可以使用大写的字符类表示其补集:'%S' 比 '[^%s]' 要简短些。
    Lua的字符类依赖于本地环境,所以 '[a-z]' 可能与 '%l' 表示的字符集不同。在一般情况下,后者包括 'ç' 和 'ã',而前者没有。应该尽可能的使用后者来表示字母,除非出于某些特殊考虑,因为后者更简单、方便、更高效。
    可以使用修饰符来修饰模式增强模式的表达能力,Lua中的模式修饰符有四个:

    +      匹配前一字符1次或多次
    *      匹配前一字符0次或多次
    -      匹配前一字符0次或多次
    ?      匹配前一字符0次或1次

    '+',匹配一个或多个字符,总是进行最长的匹配。比如,模式串 '%a+' 匹配一个或多个字母或者一个单词:

    print(string.gsub("one, and two; and three", "%a+", "word"))
        
    --> word, word word; word word

    '%d+' 匹配一个或多个数字(整数):

    i, j = string.find("the number 1298 is even", "%d+")
    print(i,j)    --> 12  15

    '*' 与 '+' 类似,但是他匹配一个字符0次或多次出现.一个典型的应用是匹配空白。比如,为了匹配一对圆括号()或者括号之间的空白,可以使用 '%(%s*%)'。( '%s*' 用来匹配0个或多个空白。由于圆括号在模式中有特殊的含义,所以我们必须使用 '%' 转义他。)再看一个例子,'[_%a][_%w]*' 匹配Lua程序中的标示符:字母或者下划线开头的字母下划线数字序列。
    '-' 与 '*' 一样,都匹配一个字符的0次或多次出现,但是他进行的是最短匹配。某些时候这两个用起来没有区别,但有些时候结果将截然不同。比如,如果你使用模式 '[_%a][_%w]-' 来查找标示符,你将只能找到第一个字母,因为 '[_%w]-' 永远匹配空。另一方面,假定你想查找C程序中的注释,很多人可能使用 '/%*.*%*/'(也就是说 "/*" 后面跟着任意多个字符,然后跟着 "*/" )。然而,由于 '.*' 进行的是最长匹配,这个模式将匹配程序中第一个 "/*" 和最后一个 "*/" 之间所有部分:

    test = "int x; /* x */ int y; /* y */"
    print(string.gsub(test, "/%*.*%*/", "<COMMENT>"))
     
       --> int x; <COMMENT>

    然而模式 '.-' 进行的是最短匹配,她会匹配 "/*" 开始到第一个 "*/" 之前的部分:

    test = "int x; /* x */ int y; /* y */"
    print(string.gsub(test, "/%*.-%*/", "<COMMENT>"))
        --> int x; <COMMENT> int y; <COMMENT>

    '?' 匹配一个字符0次或1次。举个例子,假定我们想在一段文本内查找一个整数,整数可能带有正负号。模式 '[+-]?%d+' 符合我们的要求,它可以匹配像 "-12"、"23" 和 "+1009" 等数字。'[+-]' 是一个匹配 '+' 或者 '-' 的字符类;接下来的 '?' 意思是匹配前面的字符类0次或者1次。
    与其他系统的模式不同的是,Lua中的修饰符不能用字符类;不能将模式分组然后使用修饰符作用这个分组。比如,没有一个模式可以匹配一个可选的单词(除非这个单词只有一个字母)。下面我将看到,通常你可以使用一些高级技术绕开这个限制。
    以 '^' 开头的模式只匹配目标串的开始部分,相似的,以 '$' 结尾的模式只匹配目标串的结尾部分。这不仅可以用来限制你要查找的模式,还可以定位(anchor)模式。比如:

    if string.find(s, "^%d") then ...

    检查字符串s是否以数字开头,而

    if string.find(s, "^[+-]?%d+$") then ...

    检查字符串s是否是一个整数。
    '%b' 用来匹配对称的字符。常写为 '%bxy' ,x和y是任意两个不同的字符;x作为匹配的开始,y作为匹配的结束。比如,'%b()' 匹配以 '(' 开始,以 ')' 结束的字符串:

    print(string.gsub("a (enclosed (in) parentheses) line", "%b()", ""))
    --> a line

    常用的这种模式有:'%b()' ,'%b[]','%b%{%}' 和 '%b<>'。你也可以使用任何字符作为分隔符。


    转自:http://www.cnblogs.com/whiteyun/archive/2009/09/02/1541043.html

    展开全文
  • 快速模式匹配算法

    千次阅读 2017-07-11 10:55:30
    这个功能主要来完成“查找”,“替换”和“全部替换”功能的,其实这就是典型的模式匹配的应用,即在文本文件中查找串。1.模式匹配 模式匹配的模型大概是这样的:给定两个字符串变量S和P,其中S成为目标串,其中包含...
  • Lua 模式匹配

    2010-06-08 09:53:00
    与其他脚本语言不同的是,Lua并不使用POSIX规范的正则表达式[4](也写作regexp)来进行模式匹配。主要的原因出于程序大小方面的考虑:实现一个典型的符合POSIX标准的regexp大概需要4000行代码,这比整个Lua标准库加...
  • Lua 的模式匹配

    2015-09-06 13:56:46
    Lua 的模式匹配不使用Posix规范的正则表达式(也写做regexp)来进行模式匹配。主要的原因出于程序大小方面的考虑:实现一个典型的符合POSIX标准的regexp大概需要4000行代码,这比整个Lua标准库加在一起都大。权衡之...
  • 模式匹配和文本处理

    千次阅读 2017-11-16 14:44:14
    模式匹配和文本处理 字符串的处理主要包括寻找字符中的模式(模式匹配),以及通过称为正则表达式的特殊语言来执行 正则表达式: 正则表达式是一种用于描述字符串格式的语言,它提供了对应于重复字符、替换字符...
  • lua string模式匹配

    千次阅读 2017-04-25 20:25:47
    模式匹配函数 在string库中功能最强大的函数是: string.find(字符串查找) string.gsub(全局字符串替换) string.gfind(全局字符串查找) string.gmatch(返回查找到字符串的迭代器)
  • shell中参数的模式匹配

    千次阅读 2010-06-12 10:19:00
    Shell 扩展模式匹配扩展目的${PARAMETER#WORD}shell 像文件名扩展中那样扩展 WORD,并从 PARAMETER 扩展后的值的开头删除最短的匹配模式(若存在匹配模式的话)。使用 ‘@’ 或 ‘$’ 即可删除列表中每个参数的模式...
  • 本文以替换为例,讲解一下如何使用Python在word中使用“通配符模式”(类似于正则表达式)替换文本内容。 #!/usr/bin/env python # -*- coding:utf-8 -*- import os import win32com from win32com.client...
  • lua之字符串模式匹配

    千次阅读 2017-09-27 17:48:15
    在string库中功能最强大的函数是: 复制代码代码如下: string.find(字符串查找) ...这些函数都是基于模式匹配的。与其他脚本语言不同的是,Lua并不使用POSIX规范的正则表达式[4](也写作regexp)来进
  • Word文档用通配符批量替换日期格式

    千次阅读 2017-12-18 13:05:38
    = =搬砖的过程中要做一件很痛苦的事情就是把word上的任务转到团队任务管理的软件上去.....这里我们可以用word自带的批量替换功能,用通配符去匹配然后批量替换开始菜单栏 -> 替换或者使用快捷键’Ctrl+H’第一种格式的
  • 模式匹配函数 在string库中功能最强大的函数是: 复制代码代码如下: string.find(字符串查找) string.gsub(全局字符串替换) string.gfind(全局字符串查找) string.gmatch
  • 正则匹配模式

    千次阅读 2016-08-13 22:31:21
    匹配模式指得是正则表达式引擎将以何种模式匹配字符串。 模式名称 启用,禁用 缺省启用 说明 UNIX_LINES (?d)启用,(?-d)禁用 是 启用Unix行模式。 在此模式下,只有 '\n'被认为是行结束符。它...
  • Python 正则表达式(模式匹配

    千次阅读 2017-07-31 18:22:30
    1. Python正则式的基本用法 1.1基本规则 ...1.2.1最小匹配与精确匹配 1.3前向界定与后向界定 1.4组的基本知识 2. re模块的基本函数 2.1使用compile加速 2.2 match和search 2.3 findi
  • word中的正则表达式匹配

    千次阅读 2019-04-01 22:25:12
    ()用英文括号括起来的是一个表达式, 表达式内部匹配到的结果可以用 \1 其中1代表是第一个表达式,第二个表达式内容表示匹配0 9 , - 这几个字符的任意组合(避免某些括号中是别的东西)。 替换为输入: [/2] ...
  • 你有一个单词列表 words 和一个模式 pattern,你想知道 words 中的哪些单词与模式匹配。 如果存在字母的排列 p ,使得将模式中的每个字母 x 替换为 p(x) 之后,我们就得到了所需的单词,那么单词与模式是匹配的。 ...
  • 匹配模式:大大小小 --> 1122 def wordpattern(wordpattern, input): word = input.split(' ') # 目标字符串的单词以空格隔开 if len(word) != len(wordpattern): # 判断目标字符串和 模式字符串的长度...
  • 处理时,把当前处理的行存储在临时缓冲区中,称为『模式空间』(pattern space),接着用sed命令处理缓冲区中的内容,处理完成后,把缓冲区的内容送往屏幕。接着处理下一行,这样不断重复,直到文件末尾。文件内容并...
  • QRegExp也可以用于更简单的通配符模式,类似于命令shell中的功能。 可以使用setPatternSyntax()更改QRegExp使用的语法规则。 特别是,模式语法可以设置为QRegExp :: FixedString,这意味着要...
  • 在vi中使用模式匹配

    千次阅读 2012-04-09 08:37:09
    如果没有g只替换一行中第一个匹配的字符. (7) [:digit:] 是0-9的另一种表达式,要使用这个类就必须把它放在方括号内,使得它成为可以识别的正则表达式.0-9本身并不是正则表达式,但是[0-9]就是; 同样[:digit:]只有被...
  • 你有一个单词列表 words 和一个模式 pattern,你想知道 words 中的哪些单词与模式匹配。 如果存在字母的排列 p ,使得将模式中的每个字母 x 替换为 p(x) 之后,我们就得到了所需的单词,那么单词与模式是匹配的。 ...
  • Lua中如何使用模式匹配

    千次阅读 2010-04-01 15:36:00
     $ -- 若一个模式以$结束,那么结果一定与字符串的尾部相匹配。When at the end of a pattern, it forces the pattern to match the end of a string  如果^和$没有出现在上述位置,则不起这个作用。  模式...
  • 一、word批量批量合并 1、把多个文档放在一个文件夹内; 2、打开WPS Office,新建空白文档后,依次点击插入—对象—文件中的文字: 3、批量选择自己需要合并的文档后,点击打开。即完成文档的合并。 注意:各...
  • 适用于: Word 2016, Word 2013, Word 2010, Word Online, Word Starter, Word Starter 2010 重要: 本文是由机器翻译的,请参阅免责声明。...您可以搜索和替换文本、 图像、 标题、 书签、 或某些类型的格式,如段落

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,275
精华内容 15,710
关键字:

word模式匹配替换