Lua编程指南：开源授权与资源集成

Lua

Programming

需积分: 9 42 浏览量更新于2024-07-20 收藏 1.24MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

资源详情

资源推荐

Expressions

consist of two things: an escape character, which will always be a backslash (’\’) in Lua,

and an identiﬁer that identiﬁes the character to be escaped.

Escape sequences in Lua

Escape se-

quence

Description

\n A new line

\” A double quote

\’ A single quote (or apostrophe)

\\ A backslash

\t A horizontal tab

\### ### must be a number from 0 to 255. The result will be the

corresponding ASCII

character.

Escape sequences are used when putting the character directly in the string would cause a

problem. For example, if you have a string of text that is enclosed in double quotes and

must contain double quotes, then you need to enclose the string in diﬀerent characters or

to escape the double quotes. Escaping characters in strings delimited by long brackets is

not necessary, and this is true for all characters. All characters in a string delimited with

long brackets will be taken as-is. The % character is used in string patterns to escape magic

characters, but the term escaping is then used in another context.

"This is a valid string."

'This is also a valid string.'

"This is a valid \" string 'that contains unescaped single quotes and escaped

double quotes."

[[

This is a line that can continue

on more than one line.

It can contain single quotes, double quotes and everything else (-- including

comments). It ignores everything (including escape characters) except closing

long brackets of the same level as the opening long bracket.

]]

"This is a valid string that contains tabs \t, double quotes \" and backlashes

\\"

"This is " not a valid string because there is an unescaped double quote in the

middle of it."

For convenience, if an opening long string bracket is immediately followed by a new line,

that new line will be ignored. Therefore, the two following strings are equivalent:

[[This is a string

that can continue on many lines.]]

[[

This is a string

that can continue on many lines.]]

https://en.wikipedia.org/wiki/ASCII

Literals

-- Since the opening long bracket of the second string is immediately followed

by a new line, that new line is ignored.

It is possible to get the length of a string, as a number, by using the unary length operator

(’#’):

print(#("This is a string")) --> 16

Concatenation

In formal language theory

and computer programming

, string concatenation is the

operation of joining two character strings

end-to-end. For example, the concatenation

of ”snow” and ”ball” is ”snowball”.

https://en.wikipedia.org/wiki/formal%20language

https://en.wikipedia.org/wiki/computer%20programming

https://en.wikipedia.org/wiki/character%20string%20%28computer%20science%29

The string concatenation operator in Lua is denoted by two dots (’..’). Here is an example

of concatenation that concatenates ”snow” and ”ball” and prints the result:

print("snow" .. "ball") --> snowball

This code will concatenate ”snow” and ”ball” and will print the result.

2.1.5 Other types

The four basic types in Lua (numbers, booleans, nil and strings) have been described in

the previous sections, but four types are missing: functions, tables, userdata and threads.

Functions are pieces of code that can be called, receive values and return values back.

Tables are data structures that can be used for data manipulation. Userdata are used inter-

nally by applications Lua is embedded in to allow Lua to communicate with that program

through objects controlled by the application. Finally, threads are used by coroutines, which

allow many functions to run at the same time. These will all be described later, so you only

need to keep in mind that there are other data types.

2.2 Literals

Literals are notations for representing ﬁxed values in source code. All values can be repre-

sented as literals in Lua except threads and userdata. String literals (literals that evaluate

to strings), for example, consist of the text that the string must represent enclosed into

single quotes, double quotes or long brackets. Number literals, on the other hand, consist

the number they represent expressed using decimal notation (ex: 12.43), scientiﬁc notation

(ex: 3.1416e-2 and 0.31416E1) or hexadecimal notation (ex: 0xff).

Expressions

2.3 Coercion

Coercion is the conversion of a value of one data type to a value of another data type. Lua

provides automatic coercion between string and number values. Any arithmetic operation

applied to a string will attempt to convert this string to a number. Conversely, whenever a

string is expected and a number is used instead, the number will be converted to a string.

This applies both to Lua operators and to default functions (functions that are provided

with the language).

print("122" + 1) --> 123

print("The number is " .. 5 .. ".") --> The number is 5.

Coercion of numbers to strings and strings to numbers can also be done manually with

the tostring and tonumber functions. The former accepts a number as an argument and

converts it to a string, while the second accepts a string as an argument and converts it

to a number (a diﬀerent base than the default decimal one can optionally be given in the

second argument).

2.4 Bitwise operations

Since Lua 5.3, bitwise operators are provided to operate on binary numerals (bit patterns).

These operators are not used as frequently as the others, so you may skip this section if you

do not need them.

The bitwise operators in Lua always operate on integers, converting their operands if this

is necessary. They also give integers.

The bitwise AND operation (with operator &) performs logical conjunction on each pair of

bits of two binary representations of equal length. For example, 5 & 3 evaluates to 1. We

can explain this by looking at the binary representation of these numbers (the subscripts

are used to denote the base):

(5)

= (0101)

(3)

= (0011)

(1)

= (0001)

If the bits in a given position in the binary representation of both 5 and 3 are 1 (as is the

case for the last bit), then the bit at that position will be 1 in the result; in all other cases,

it will be 0.

The bitwise OR operation (with operator |) works in the same way as the bitwise AND,

performing logical disjunction instead where it performs logical conjunction. Thus, 5 |

3 will evaluate to 7:

(5)

= (0101)

(3)

= (0011)

(7)

= (0111)

剩余75页未读，继续阅读

wlh550

粉丝: 0
资源: 6

Lua编程指南：开源授权与资源集成

LUA编程(programming+in+lua).pdf

Programming in Lua 4th.pdf

Lua Programming Gems 高清书签

lua5.3 luaL_register

5. 编写一个程序，完成N(N=10)个字符串的升序排列(要求使用string类型及字符串处理的相关操作或函数)。

openresty ngx.say

nmap script

《programming in lua》第四版

programming in lua fourth edition

import torch

import torch标黄线

vlc,lua解析器

Lua有没有现成的学习资料推荐？

lua语言冒泡排序的代码

帮我找个博主，学习lua

lua闭包的作用和问题

nvim lsp配置怎么写

redis aop文件解析

string.format

输出20行helloworld

最新资源