Lua Strings

A string is a sequence of characters composed of digits, letters, and underscores.

In Lua, strings are a basic data type used to store text data.

Strings in Lua can contain any character, including letters, digits, symbols, spaces, and other special characters.

In Lua, strings can be expressed in the following three ways:

• A sequence of characters between single quotes.

  local str1 = 'This is a string.'
  local str2 = "This is also a string."

• A sequence of characters between double quotes.

  local str = "Hello, "
  str = str .. "World!"  -- 创建一个新的字符串并将其赋值给str
  print(str)  -- 输出 "Hello, World!"

• [[and]]A sequence of characters between [[ and ]].

  local multilineString = [[
  This is a multiline string.
  It can contain multiple lines of text.
  No need for escape characters.
  ]]
  
  print(multilineString)

Examples of strings using the above three ways are as follows:

The output of the above code execution is:

"字符串 1 是"    Lua
字符串 2 是    example.com
字符串 3 是    "Lua 教程"

String Length Calculation

In Lua, to calculate the length of a string (i.e., the number of characters in the string), you can usestring.lenfunction orutf8.lenfunction, and for strings containing Chinese, generally useutf8.len，string.lenThe function is used to calculate the length of strings containing only ASCII characters.

In the above example, the myString string contains only ASCII characters, sostring.lenthe function can accurately return the length of the string.

For strings containing Chinese, useutf8.lenfunction:

The output result is:

10
14

Escape characters are used to represent characters that cannot be displayed directly, such as the backspace key, carriage return, etc. For example, to include double quotes in a string, you can use\。

All escape characters and their corresponding meanings:

String Operations

Lua provides many methods to support string operations:

> string.gsub("aaaa","a","z",3);
zzza    3

> string.find("Hello Lua user", "Lua", 1) 
7    9

> string.reverse("Lua")
auL

> string.format("the value is:%d",4)
the value is:4

> string.char(97,98,99,100)
abcd
> string.byte("ABCD",4)
68
> string.byte("ABCD")
65
>

string.len("abc")
3

> string.rep("abcd",2)
abcdabcd

> print("www.example.".."com")
www.example.com

> for word in string.gmatch("Hello Lua user", "%a+") do print(word) end
Hello
Lua
user

> = string.match("I have 2 questions for you.", "%d+ %a+")
2 questions

> = string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)"))
2, "questions"

String Substring

String extraction uses the sub() method.

string.sub() is used to extract a substring. Its prototype is:

string.sub(s, i [, j])

Parameter description:

• s: the string to be extracted.
• i: the starting position for extraction.
• j: the ending position for extraction, defaulting to -1, the last character.

The output of the above code execution is:

原始字符串    "prefix--examplegoogletaobao--suffix"

第一次截取    "fix--exampleg"

第二次截取    "prefix--"

第三次截取    "ao--suffix"

第四次截取    "prefix--examplegoogletaobao--suffix"

String Case Conversion

The following example demonstrates how to convert the case of strings:

The output of the above code execution is:

LUA
lua

String Search and Reverse

The following example demonstrates how to perform search and reverse operations on strings:

The output of the above code execution is:

5    12
新字符串为    lairotuT auL

String Formatting

Lua providesstring.format()a function to generate strings with a specific format. The first parameter of the function is the format, followed by various data corresponding to each code in the format.

Due to the existence of the format string, the readability of the resulting long strings is greatly improved. The format of this function is very similar to printf() in C.

The following example demonstrates how to perform formatting operations on strings:

The format string may contain the following escape codes:

• %c - accepts a number and converts it to the corresponding character in the ASCII table
• %d, %i - accept a number and convert it to a signed integer format
• %o - accepts a number and converts it to an octal format
• %u - accepts a number and converts it to an unsigned integer format
• %x - accepts a number and converts it to a hexadecimal format, using lowercase letters
• %X - accepts a number and converts it to a hexadecimal format, using uppercase letters
• %e - accepts a number and converts it to scientific notation format, using lowercase e
• %E - accepts a number and converts it to scientific notation format, using uppercase E
• %f - accepts a number and converts it to floating-point format
• %g(%G) - accepts a number and converts it to the shorter format of %e (%E, corresponding to %G) and %f
• %q - accepts a string and converts it to a format that can be safely read by the Lua compiler
• %s - Accepts a string and formats it according to the given parameters.

To further refine the format, parameters can be added after the % sign. The parameters are read in the following order:

• (1) Sign: A + sign indicates that the following numeric escape will make positive numbers display a positive sign. By default, only negative numbers show a sign.
• (2) Placeholder: A 0, used for padding when a string width is specified afterwards. If not filled, the default placeholder is a space.
• (3) Alignment flag: When a string width is specified, the default is right alignment; adding a - sign changes it to left alignment.
• (4) Width value
• (5) Decimal places / string truncation: The fractional part n added after the width value. If followed by f (floating-point escape, e.g., %6.3f), it sets the float to keep only n decimal places; if followed by s (string escape, e.g., %5.3s), it sets the string to display only the first n characters.

The result of executing the above code is:

基本格式化 Lua Tutorial
日期格式化 02/01/2014
0.3333

Other examples:

Character and Integer Conversion

The following example demonstrates converting between characters and integers:

The result of executing the above code is:

76
97
97
117
117
a

Other Common Functions

The following example demonstrates other string operations, such as calculating string length, string concatenation, string replication, etc.:

The result of executing the above code is:

连接字符串    www.example.com
字符串长度     6
exampleexample

Matching Patterns

Match patterns in Lua are described directly with regular strings. They are used in pattern-matching functionsstring.find, string.gmatch, string.gsub, string.match。

You can also use character classes in pattern strings.

A character class refers to a pattern item that can match any character in a specific character set. For example, the character class%dmatches any digit. So you can use the pattern string%d%d/%d%d/%d%d%d%dto searchdd/mm/yyyydates in the format:

The following table lists all character classes supported by Lua:

A single character (except^$()%.[]*+-?): matches the character itself

• . (dot): matches any character
• %a: matches any letter
• %c: matches any control character (e.g., \n)
• %d: matches any digit
• %l: matches any lowercase letter
• %p: matches any punctuation
• %s: matches any whitespace character
• %u: matches any uppercase letter
• %w: matches any alphanumeric character
• %x: matches any hexadecimal digit
• %z: matches any character representing 0
• %x (where x is a non-alphanumeric character): matches the character x. Mainly used to handle matching of characters with special functions in expressions (^$()%.[]*+-?), e.g., %% matches %
• [several character classes]: matches any character class contained in []. For example, [%w_] matches any letter/digit or the underscore symbol (_)
• [^several character classes]: matches any character class not contained in []. For example, [^%s] matches any non-whitespace character

When the above character classes are written in uppercase, they match any character not in that character class. For example, %S matches any non-whitespace character. For example, '%A' matches non-letter characters:

> print(string.gsub("hello, up-down!", "%A", "."))
hello..up.down.    4

The number 4 is not part of the string result; it is the second result returned by gsub, representing the number of substitutions that occurred.

In pattern matching, there are some special characters that have special meanings. The special characters in Lua are as follows:

( ) . % + - * ? [ ^ $

'%' is used as the escape character for special characters, so '%.' matches a dot; '%%' matches the character '%'. The escape character '%' can be used not only to escape special characters, but also for all non-alphabetic characters.

Pattern items can be:

• A single character class matches any single character in that class;
• A single character class followed by a '*', matches zero or more characters of that class. This entry always matches the longest possible string;
• A single character class followed by a '+', matches one or more characters of that class. This entry always matches the longest possible string;
• A single character class followed by a '-', matches zero or more characters of that class. Unlike '*', this entry always matches the shortest possible string;
• A single character class followed by a '?', matches zero or one character of that class. If possible, it will match one;
• %n, wherencan be from 1 to 9; this entry matches a substring equal to thennumbered capture (described below).
• %bxy, wherexandyare two explicit characters; this entry matches a string that starts withxand ends withy, and in whichxandyremainsbalancedstring.xJust+1This means, if you read this string from left to right, for each time you read ayJust-1, and read ay,ythe one at the final end%b().
• %f[set]can match an expression with balanced parentheses., refers tofrontier patternset; this entry matches an empty string locatedsetbefore a character in [set],set.\0has the same meaning as described earlier.

' as if.

Pattern:Pattern^refers to a sequence of pattern items.$' will anchor the match at the beginning of the string.^' will anchor the matching process at the end of the string.$' and '

' appear in other positions, they have no special meaning and represent themselves.

Captures:A pattern can enclose a sub-pattern with parentheses;captures.captures"(a*(.)%w(%s*))"The substrings in the matched string are saved for future use."a*(.)%w(%s*)",.the part is stored in the first capture%s*the matched character is capture 2,

the part matched is capture 3.()As a special case, an empty capture"()aa()"captures the current position in the string (which is a number)."flaaap"applied to the string