lua字符串操作示例

时间：2025-02-21 20:26:20

(str, pattern)

该方法用于在一个字符串中查找与给定模式匹配的所有子字符串，并返回一个迭代器。每次迭代器被调用时，它都会返回下一个匹配子字符串。

示例代码：

local str = "Hello, Lua World!"
for word in string.gmatch(str, "%a+") do
  print(word)
end

输出结果：

Copy code
Hello
Lua
World

在这个示例中，方法被用来查找字符串str中所有由一个或多个字母组成的单词，并将它们依次打印出来。

(str, pattern, init)

该方法用于在一个字符串中查找与给定模式匹配的子字符串，并返回第一个匹配的子字符串以及匹配到的所有捕获子串。如果没有找到匹配的子字符串，则返回nil。

示例代码：

local str = "Lua is a powerful language"
local match_str = string.match(str, "Lua.+language")
print(match_str)

输出结果：

Lua is a powerful language

在这个示例中，方法被用来查找字符串str中第一个以Lua开头、以language结尾的子字符串。因为整个字符串都符合这个模式，所以返回整个字符串。

(str, pattern)

示例1：统计字符串中所有的数字个数

local str = "hello123world456"
local count = 0
for digit in string.gmatch(str, "%d") do
  count = count + 1
end
print("The number of digits in the string is " .. count)

输出结果：

The number of digits in the string is 6

在这个示例中，方法被用来查找字符串str中所有的数字，并统计它们的个数。

示例2：将字符串中的所有单词反转

local str = "Lua is a powerful language"
local reversed_str = ""
for word in string.gmatch(str, "%S+") do
  reversed_str = word .. " " .. reversed_str
end
print(reversed_str)

输出结果：

language powerful a is Lua

在这个示例中，方法被用来查找字符串str中所有的单词，并将它们反转，最终得到一个新的字符串reversed_str。

  1. (str, pattern, init)

示例1：从一个URL中提取出其中的域名部分

local url = "/manual/5.4/"
local domain = string.match(url, "^https?://([^/]+)")
print("The domain of the URL is " .. domain)

输出结果：

The domain of the URL is www.lua.org

在这个示例中，方法被用来从URL中提取出其中的域名部分。通过使用模式^https?://([^/]+)，我们可以匹配出以http://或https://开头的URL，并提取出第一个/之前的部分作为域名。

示例2：从一个XML文件中提取出其中的所有属性名和属性值

local xml = "<person name=\"Alice\" age=\"30\" gender=\"female\" />"
for name, value in string.gmatch(xml, "(%w+)%s*=%s*\"([^\"]*)\"") do
  print(name .. " = " .. value)
end

输出结果：

name = Alice
age = 30
gender = female

在这个示例中，方法被用来从XML文件中提取出其中的所有属性名和属性值。通过使用模式(%w+)%s*=%s*\"([^\"]*)\"，我们可以匹配出所有以字母、数字或下划线开头的属性名，并将它们与对应的属性值一起输出。

(str, pattern)

示例3：将一个CSV文件转换成Lua中的表格

local csv = "name,age,gender\nAlice,30,female\nBob,25,male\n"
local rows = {}
for row in string.gmatch(csv, "([^\n]+)\n") do
  local fields = {}
  for field in string.gmatch(row, "[^,]+") do
    table.insert(fields, field)
  end
  table.insert(rows, fields)
end
print(rows[1][2]) -- output: age
print(rows[2][3]) -- output: male

输出结果：

Copy code
age
male

在这个示例中，方法被用来将一个CSV文件转换成Lua中的表格。通过使用模式([^\n]+)\n，我们可以匹配出CSV文件中的每一行数据，并使用模式[^,]+匹配出每一行数据中的每一个字段，并将它们添加到对应的表格中。

  1. (str, pattern, init)

示例3：从一个JSON字符串中提取出其中的所有键值对

local json = '{"name": "Alice", "age": 30, "gender": "female"}'
for key, value in string.gmatch(json, "\"(%w+)\":%s*\"([^\"]+)\"") do
  print(key .. " = " .. value)
end

输出结果：

name = Alice
age = 30
gender = female

在这个示例中，方法被用来从一个JSON字符串中提取出其中的所有键值对。通过使用模式\"(%w+)\":%s*\"([^\"]+)\"，我们可以匹配出所有的键值对，并将它们输出。其中，%w+表示匹配一个或多个字母、数字或下划线，[^\"]+表示匹配一个或多个非双引号字符。

(str, pattern)

示例4：替换字符串中的所有空格为下划线

local str = "Lua is a powerful language"
local new_str = string.gsub(str, "%s+", "_")
print(new_str)

输出结果：

Copy code
Lua_is_a_powerful_language

在这个示例中，方法被用来将字符串str中的所有空格替换为下划线。通过使用模式%s+，我们可以匹配出一个或多个连续的空格，并将它们替换为一个下划线。

示例5：判断一个字符串是否为回文字符串

local str = "racecar"
local reversed_str = ""
for word in string.gmatch(str, "%a") do
  reversed_str = word .. reversed_str
end
if str == reversed_str then
  print("The string is a palindrome")
else
  print("The string is not a palindrome")
end

输出结果：

The string is a palindrome

在这个示例中，方法被用来将字符串str中的所有字母反转，并存储在新的字符串reversed_str中。如果字符串str与reversed_str相等，则说明字符串是回文字符串。

  1. (str, pattern, init)

示例4：从一个HTML页面中提取出其中的所有链接

local html = [[
<html>
  <head>
    <title>Example</title>
  </head>
  <body>
    <a href="">Lua</a>
    <a href="">Python</a>
    <a href="">Ruby</a>
  </body>
</html>
]]
for link in string.gmatch(html, "<a%s+href=\"([^\"]+)\"") do
  print(link)
end

输出结果：

https://www.lua.org
https://www.python.org
https://www.ruby-lang.org

在这个示例中，方法被用来从HTML页面中提取出其中的所有链接。通过使用模式<a%s+href=\"([^\"]+)\"，我们可以匹配出所有的链接，并将它们输出。其中，\s+表示匹配一个或多个空白字符，[^\"]+表示匹配一个或多个非双引号字符。

    1. (str, pattern)

示例6：将一个16进制字符串转换为对应的数字

local hex_str = "1A2B3C4D"
local num = 0
for digit in string.gmatch(hex_str, "%x") do
  num = num * 16 + tonumber(digit, 16)
end
print(num)

输出结果：

Copy code
448378203

在这个示例中，方法被用来将一个16进制字符串转换为对应的数字。通过使用模式%x，我们可以匹配出字符串中的每一个16进制数字，并使用tonumber函数将其转换为10进制数字，并将它们按位相加得到最终结果。

示例7：从一个文本文件中提取出所有的邮件地址

local file = io.open("", "r")
for line in file:lines() do
  for email in string.gmatch(line, "%w+@[%w_]+%.[%w_]+") do
    print(email)
  end
end
file:close()

在这个示例中，方法被用来从一个文本文件中提取出所有的邮件地址。通过使用模式%w+@[%w_]+%.[%w_]+，我们可以匹配出所有的邮件地址，并将它们输出。其中，%w+表示匹配一个或多个字母、数字或下划线，[%w_]+表示匹配一个或多个字母、数字、下划线或点号，\.表示匹配一个点号。

(str, pattern, init)

示例5：从一个字符串中提取出其中的第一个整数

local str = "Lua 5.4 was released on January 28, 2021"
local num = tonumber(string.match(str, "%d+"))
print(num)

输出结果：

Copy code
5

在这个示例中，方法被用来从一个字符串中提取出其中的第一个整数。通过使用模式%d+，我们可以匹配出字符串中的一个或多个数字，并使用tonumber函数将其转换为数字。

  • 示例8：检查一个字符串是否符合一个模式
local str = "Hello, World!"
if string.match(str, "%a+, %a+!") then
  print("Match!")
else
  print("No match.")
end

输出结果：

Match!

在这个示例中，方法被用来检查一个字符串是否符合一个模式。通过使用模式%a+, %a+!，我们可以匹配出以一个或多个字母组成的字符串，后面跟着一个逗号、一个空格，再后面是以一个或多个字母组成的字符串，最后以一个感叹号结尾的字符串。如果字符串符合这个模式，就输出"Match!“，否则输出"No match.”。

示例9：从一个URL中提取出其中的协议、主机和路径

local url = "/manual/5.4/"
local protocol, host, path = string.match(url, "(%a+)://([^/]+)(.*)")
print(protocol, host, path)

输出结果：

https        /manual/5.4/

在这个示例中，方法被用来从一个URL中提取出其中的协议、主机和路径。通过使用模式(%a+)://([^/]+)(.*)，我们可以匹配出以一个或多个字母组成的字符串，后面跟着一个冒号和两个斜杠，再后面是不包含斜杠的任意字符串，最后是剩余的部分。我们将这三个部分分别赋值给protocol、host和path，并将它们输出。

  • 示例10：从一个HTML文件中提取出所有的链接
local file = io.open("", "r")
local html = file:read("*all")
file:close()

for href in string.gmatch(html, 'href="([^"]+)"') do
  print(href)
end

在这个示例中，方法被用来从一个HTML文件中提取出其中的所有链接。通过使用模式href="([^"]+)"，我们可以匹配出所有的href属性，并将它们输出。其中，[^"]+表示匹配一个或多个非引号的字符。注意到我们使用了单引号来包含模式字符串，这是因为模式中包含了双引号，如果使用双引号来包含模式字符串，就需要在双引号前面加上转义字符\，如"href=\\"([^\\"]+)\\""。

示例11：从一个JSON字符串中提取出其中的某个属性值

local json_str = '{"name": "John", "age": 30, "city": "New York"}'
local age = tonumber(string.match(json_str, '"age":%s*(%d+)'))
print(age)

输出结果：

Copy code
30

在这个示例中，方法被用来从一个JSON字符串中提取出其中的某个属性值。通过使用模式'"age":%s*(%d+)'，我们可以匹配出"age"属性对应的值，并使用tonumber函数将其转换为数字。其中，%s*表示匹配零个或多个空格，%d+表示匹配一个或多个数字。

以上示例展示了如何使用Lua中的字符串匹配方法和来处理字符串，它们是非常强大的工具，在文本处理和数据解析中有着广泛的应用。

  • 示例12：将一个字符串按照指定的分隔符分割成多个子串
local str = "apple,banana,orange"
for s in string.gmatch(str, "([^,]+)") do
  print(s)
end

输出结果：

Copy code
apple
banana
orange

在这个示例中，我们使用方法将一个字符串按照逗号分隔符分割成多个子串，并使用一个for循环将这些子串依次输出。通过使用模式"([^,]+)"，我们可以匹配出所有不包含逗号的子串，其中[^,]表示匹配除逗号以外的任意字符，+表示匹配一个或多个字符。注意到我们使用了圆括号来将模式中的子串捕获起来，这样在for循环中可以直接访问到这些子串。

示例13：在一个字符串中查找指定的子串

local str = "hello, world"
local sub = "world"
local i, j = string.find(str, sub)
if i then
  print(string.format("'%s' found at position %d to %d.", sub, i, j))
else
  print(string.format("'%s' not found.", sub))
end

输出结果：

'world' found at position 8 to 12.

在这个示例中，方法被用来在一个字符串中查找指定的子串。如果找到了该子串，方法会返回子串的起始位置和结束位置，否则返回nil。在这个示例中，我们将查找的子串设置为"world"，并将其存储在变量sub中，然后调用方法来查找这个子串。如果找到了该子串，就输出子串的起始位置和结束位置，否则输出一个提示信息。

  • 示例18：将一个字符串按照指定的分隔符拆分为多个子串
local str = "Lua,is,a,powerful,programming,language"
local pattern = ","
for sub_str in string.gmatch(str, "[^" .. pattern .. "]+") do
  print(sub_str)
end

输出结果：

Lua
is
a
powerful
programming
language

在这个示例中，我们使用方法按照指定的分隔符将一个字符串拆分为多个子串。在这个示例中，我们将要拆分的字符串设置为"Lua,is,a,powerful,programming,language"，并且将分隔符设置为","。然后，我们使用模式"[^" .. pattern .. "]+"来匹配任意不包含分隔符的子串。其中，[^]表示匹配不包含括号中字符的任意字符，..表示字符串连接符。最终输出的结果是拆分后的多个子串。

示例19：在一个字符串中查找指定的子串并返回其位置

local str = "Lua is a powerful programming language"
local sub_str = "powerful"
local index = string.find(str, sub_str)
print(index)

输出结果：

Copy code
10

在这个示例中，我们使用方法在一个字符串中查找指定的子串，并返回其位置。在这个示例中，我们将要查找的字符串设置为"powerful"，然后使用(str, sub_str)来查找其在字符串中的位置。最终输出的结果是子串"powerful"在原字符串中的起始位置，即第10个字符。

示例20：将一个字符串中的所有字母转换为小写字母

local str = "Lua is a POWERFUL Programming Language"
local new_str = string.lower(str)
print(new_str)

输出结果：

lua is a powerful programming language

在这个示例中，我们使用方法将一个字符串中的所有字母转换为小写字母。在这个示例中，我们将要转换的字符串设置为"Lua is a POWERFUL Programming Language"，然后使用(str)将其转换为小写字母。最终输出的结果是所有字母都被转换为小写字母的字符串。

  • 示例21：将一个字符串中的所有字母转换为大写字母
local str = "Lua is a powerful programming language"
local new_str = string.upper(str)
print(new_str)

输出结果：

LUA IS A POWERFUL PROGRAMMING LANGUAGE

在这个示例中，我们使用方法将一个字符串中的所有字母转换为大写字母。在这个示例中，我们将要转换的字符串设置为"Lua is a powerful programming language"，然后使用(str)将其转换为大写字母。最终输出的结果是所有字母都被转换为大写字母的字符串。

示例22：将一个字符串中指定的子串替换为另一个字符串

local str = "Lua is a powerful programming language"
local old_sub_str = "powerful"
local new_sub_str = "easy-to-learn"
local new_str = string.gsub(str, old_sub_str, new_sub_str)
print(new_str)

输出结果：

Lua is a easy-to-learn programming language

在这个示例中，我们使用方法将一个字符串中指定的子串替换为另一个字符串。在这个示例中，我们将要替换的字符串设置为"Lua is a powerful programming language"，将要替换的子串设置为"powerful"，将要替换为的新子串设置为"easy-to-learn"。然后使用(str, old_sub_str, new_sub_str)来进行替换操作。最终输出的结果是将原字符串中所有的"powerful"子串替换为"easy-to-learn"子串后得到的新字符串。

示例23：将一个字符串中指定的子串全部删除

local str = "Lua is a powerful programming language"
local sub_str = "powerful"
local new_str = string.gsub(str, sub_str, "")
print(new_str)

输出结果：

Lua is a  programming language

在这个示例中，我们使用方法将一个字符串中指定的子串全部删除。在这个示例中，我们将要删除的字符串设置为"powerful"，然后使用(str, sub_str, "")来进行删除操作。最终输出的结果是将原字符串中所有的"powerful"子串全部删除后得到的新字符串。

示例24：将一个字符串中的指定字符全部删除

local str = "Lua is a powerful programming language"
local pattern = "[aeiou]"
local new_str = string.gsub(str, pattern, "")
print(new_str)

输出结果：

Copy code
L s  pwrfl prgrmmng lngg

在这个示例中，我们使用方法将一个字符串中的指定字符全部删除。在这个示例中，我们将要删除的字符设置为"[aeiou]"，表示匹配所有的元音字母。然后使用(str, pattern, "")来进行删除操作。最终输出的结果是将原字符串中所有的元音字母全部删除后得到的新字符串。

  • 示例25：将一个字符串按指定分隔符分割成多个子串
local str = "Lua,is,a,powerful,programming,language"
local pattern = ","
for sub_str in string.gmatch(str, "([^"..pattern.."]+)") do
    print(sub_str)
end

输出结果：

Lua
is
a
powerful
programming
language

在这个示例中，我们使用方法将一个字符串按指定分隔符分割成多个子串。在这个示例中，我们将要分割的字符串设置为"Lua,is,a,powerful,programming,language"，将要使用的分隔符设置为,。然后使用for循环和方法来逐个输出被分割出的子串。在方法中，我们使用正则表达式"([^"..pattern.."]+)"来表示所有不包含分隔符的字符串。最终输出的结果是将原字符串按,分割成多个子串后逐个输出。

示例26：将一个字符串中的所有空格替换为指定字符

local str = "Lua is a powerful programming language"
local new_str = string.gsub(str, " ", "-")
print(new_str)

输出结果：

Lua-is-a-powerful-programming-language

在这个示例中，我们使用方法将一个字符串中的所有空格替换为指定字符。在这个示例中，我们将要替换的字符串设置为" "，将要替换为的新字符设置为"-"。然后使用(str, " ", "-")来进行替换操作。最终输出的结果是将原字符串中所有的空格全部替换为"-"字符后得到的新字符串。

示例27：从一个URL中提取出文件名

local url = "/path/to/"
local filename = url:match("[^/]+$")
print(filename)

输出结果：

Copy code

在这个示例中，我们使用方法从一个URL中提取出文件名。在这个示例中，我们将要提取文件名的URL设置为"/path/to/"，然后使用url:match("[^/]+$")来进行匹配操作。在这个匹配模式中，我们使用正则表达式"[^/]+$"来表示匹配所有不包含/字符的字符串，也就是最后一个/后面的所有字符串，即文件名。最终输出的结果是提取出的文件名""。

示例28：将一个字符串按指定分隔符分割成多个子串并转换为数字类型

local str = "10,20,30,40,50"
local pattern = ","
local numbers = {}
for sub_str in string.gmatch(str, "([^"..pattern.."]+)") do
    table.insert(numbers, tonumber(sub_str))
end
print(table.concat(numbers, ","))

输出结果：

10,20,30,40,50
``

示例29：使用正则表达式从HTML文档中提取所有链接

local html = [[
<html>
<body>
<a href="/">Page 1</a>
<a href="/">Page 2</a>
<a href="/">Page 3</a>
</body>
</html>
]]

local links = {}
for link in html:gmatch('<a%s+href="([^"]+)"') do
    (links, link)
end

for i, link in ipairs(links) do
    print(link)
end

输出结果：

http://www.example.com/page1.html
http://www.example.com/page2.html
http://www.example.com/page3.html

在这个示例中，我们使用方法和正则表达式从HTML文档中提取所有链接。在这个示例中，我们将要提取链接的HTML文档设置为一个多行字符串，并使用html:gmatch('<a%s+href="([^"]+)"')来进行匹配操作。在这个匹配模式中，我们使用正则表达式'<a%s+href="([^"]+)"'来表示匹配所有的<a>标签，并从中提取出href属性的值，即链接地址。最终输出的结果是提取出的所有链接地址。

示例30：使用模式匹配从一个CSV文件中读取数据

local file = io.open("", "r")
local pattern = "(.-),"
local data = {}

for line in file:lines() do
    local values = {}
    for value in line:gmatch(pattern) do
        table.insert(values, value)
    end
    table.insert(data, values)
end

file:close()

-- 输出读取到的数据
for i, values in ipairs(data) do
    print(table.concat(values, ","))
end

在这个示例中，我们使用方法和模式匹配从一个CSV文件中读取数据。在这个示例中，我们打开了一个CSV文件并设置了一个模式匹配模式，即每个字段之间的逗号分隔符。然后使用for循环和file:lines()方法逐行读取文件内容，并使用line:gmatch(pattern)方法从每行数据中匹配出所有的字段值。最终输出的结果是读取到的所有数据。

这些示例展示了和方法在Lua中的一些强大的应用，包括文本匹配、分割、替换、提取等操作。这些方法使得在处理字符串时更加方便快捷，尤其是在需要处理大量文本数据时，可以大大提高效率。

  • 示例33：使用模式匹配和捕获组对HTML标签进行过滤
local str = "<h1>Hello, Lua!</h1>"
local pattern = "<[^>]+>"

local new_str = str:gsub(pattern, "")

print(new_str)

在这个示例中，我们使用方法和模式匹配对HTML标签进行过滤。在这个示例中，我们使用正则表达式"<[^>]+>"来表示匹配任意HTML标签，并将这些标签删除。使用str:gsub(pattern, "")方法对字符串进行替换操作，并将替换后的结果赋值给new_str变量。最终输出的结果是删除HTML标签后的新字符串。

示例34：使用模式匹配和捕获组对URL进行解析

local url = "/manual/5.3/#3.1"

local protocol, domain, path, anchor = url:match("^([%a]+)://([^/]+)(/.+)(#.*)$")

print("Protocol:", protocol)
print("Domain:", domain)
print("Path:", path)
print("Anchor:", anchor)

在这个示例中，我们使用方法和模式匹配对URL进行解析。在这个示例中，我们使用正则表达式"^([%%a]+)://([^/]+)(/.+)(#.*)$" 来表示匹配URL的协议、域名、路径和锚点。使用url:match(pattern)方法从URL中匹配出需要的字段值，并将这些值打印出来。最终输出的结果是URL的协议、域名、路径和锚点。

这些示例展示了和方法在Lua中的一些强大的应用，包括对HTML标签进行过滤、对URL进行解析等操作。这些方法使得在处理字符串时更加方便快捷，尤其是在需要处理大量文本数据时，可以大大提高效率。

相关文章