syxdevcode博客

1
2
3
4
5
6
7
8

# 安装
yum -y install lsof

# 使用
lsof -i:3306

# 查看当前打开文件数
lsof | wc -l

参考：

CentOS Linux 7 提示 lsof: 未找到命令

lsof命令

安装依赖

如果虚机没有联网，需要挂载系统镜像安装。

1

yum install gcc kernel-devel kernel-headers dkms make bzip2

设置VirtualBox

挂载VBoxGuestAdditons镜像

在安装目录下：C:\Program Files\Oracle\VirtualBox，找到 VBoxGuestAdditons.iso 镜像，并挂载。

虚机设置

启动虚机，执行 lsscsi 查看 IDE , /dev/sr0 就是 VBoxGuestAdditons 镜像挂载之后的路径。

1
2
3
4
5
6
7
8
9
10
11
12

# 创建文件夹
mkdir /media/cdrom

# 挂载
mount /dev/sr0 /media/cdrom

cd /media/cdrom

ls

# 安装
sh ./VBoxLinuxAdditons.run

进入 /media 目录出现 sf_share，前面出现的 sf 代表成功。

还可以通过 mount 命令把 Centos7 的目录下文件夹变成共享文件夹。

1

mount -t vboxsf share  /home/share

参考：

VirtualBox使用Centos7与主机共享文件夹

在VirtualBox挂载镜像

在CentOS7挂载镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 创建文件
mkdir /media/cdrom

# 挂载
mount -o loop /dev/cdrom /media/cdrom

##查看挂载状态
df -hT

# 重新挂载系统分区
mount -a

# 卸载
umount /media/cdrom

EVAL 命令

Redis Eval 命令使用 Lua 解释器执行脚本。

1

redis 127.0.0.1:6379> EVAL script numkeys key [key ...] arg [arg ...] 

• EVAL 命令的关键字。
• luascript Lua 脚本。
• numkeys 指定的 Lua 脚本需要处理键的数量，其实就是 key数组的长度。
• key 传递给 Lua 脚本零到多个键，空格隔开，在 Lua 脚本中通过 KEYS[INDEX]来获取对应的值，其中1 <= INDEX <= numkeys。
• arg是传递给脚本的零到多个附加参数，空格隔开，在 Lua 脚本中通过ARGV[INDEX]来获取对应的值，其中1 <= INDEX <= numkeys。

注意：numkeys无论什么情况下都是必须的命令参数。

1
2
3
4
5
6
7
8

127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> EVAL "return redis.call('GET',KEYS[1])" 1 hello
"world"
127.0.0.1:6379> EVAL "return redis.call('GET','hello')" 0
"world"

call 函数和 pcall 函数

区别：
call 执行命令错误时会向调用者直接返回一个错误；
pcall 则会将错误包装为一个我们上面讲的 table 表。

1
2
3
4
5

127.0.0.1:6379> EVAL "return redis.call('no_command')" 0
(error) ERR Error running script (call to f_1e6efd00ab50dd564a9f13e5775e27b966c2141e): @user_script:1: @user_script: 1: Unknown Redis command called from Lua script 
127.0.0.1:6379>  EVAL "return redis.pcall('no_command')" 0
(error) @user_script: 1: Unknown Redis command called from Lua script
127.0.0.1:6379> 

值转换

Lua 脚本向 Redis 返回小数，那么会损失小数精度,转换为字符串则是安全的。

1
2
3
4
5

127.0.0.1:6379> EVAL "return 3.14" 0
(integer) 3
127.0.0.1:6379> EVAL "return tostring(3.14)" 0
"3.14"
127.0.0.1:6379> 

原子执行

Lua 脚本在 Redis 中是以原子方式执行的，在 Redis 服务器执行EVAL命令时，在命令执行完毕并向调用者返回结果之前，只会执行当前命令指定的 Lua 脚本包含的所有逻辑，其它客户端发送的命令将被阻塞，直到EVAL命令执行完毕为止。因此 LUA 脚本不宜编写一些过于复杂了逻辑，必须尽量保证 Lua 脚本的效率，否则会影响其它客户端。

脚本管理

SCRIPT LOAD

加载脚本到缓存以达到重复使用，避免多次加载浪费带宽，每一个脚本都会通过 SHA 校验返回唯一字符串标识。需要配合 EVALSHA 命令来执行缓存后的脚本。

1
2
3
4

127.0.0.1:6379> SCRIPT LOAD "return 'hello'"
"1b936e3fe509bcbc9cd0664897bbe8fd0cac101b"
127.0.0.1:6379> EVALSHA 1b936e3fe509bcbc9cd0664897bbe8fd0cac101b 0
"hello"

SCRIPT FLUSH

清除所有的脚本缓存。Redis并没有根据 SHA 来删除脚本缓存,所以在生产中一般不会再生产过程中使用该命令。

SCRIPT EXISTS

以 SHA 标识为参数检查一个或者多个缓存是否存在。

1
2
3

127.0.0.1:6379> SCRIPT EXISTS 1b936e3fe509bcbc9cd0664897bbe8fd0cac101b
1) (integer) 1
127.0.0.1:6379> 

SCRIPT KILL

终止正在执行的脚本。但是为了数据的完整性此命令并不能保证一定能终止成功。如果当一个脚本执行了一部分写的逻辑而需要被终止时，该命令是不凑效的。需要执行SHUTDOWN nosave在不对数据执行持久化的情况下终止服务器来完成终止脚本。

总结

• 务必对 Lua 脚本进行全面测试以保证其逻辑的健壮性，当 Lua 脚本遇到异常时，已经执行过的逻辑是不会回滚的。
• 尽量不使用 Lua 提供的具有随机性的函数，参见相关官方文档。
• 在 Lua 脚本中不要编写 function 函数,整个脚本作为一个函数的函数体。
• 在脚本编写中声明的变量全部使用 local 关键字。
• 在集群中使用 Lua 脚本要确保逻辑中所有的 key分 到相同机器，也就是同一个插槽 (slot) 中，可采用 Redis Hash Tag 技术。
• Lua 脚本一定不要包含过于耗时、过于复杂的逻辑。

参考：

一网打尽Redis Lua脚本并发原子组合操作

EVAL Script

Redis Eval 命令

简介

Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。

Lua 特性

• 轻量级: 它用标准C语言编写并以源代码形式开放，编译后仅仅一百余K，可以很方便的嵌入别的程序里。
• 可扩展: Lua提供了非常易于使用的扩展接口和机制：由宿主语言(通常是C或C++)提供这些功能，Lua可以使用它们，就像是本来就内置的功能一样。
• 其它特性:
  支持面向过程(procedure-oriented)编程和函数式编程(functional programming)；
  自动内存管理；只提供了一种通用类型的表（table），用它可以实现数组，哈希表，集合，对象；
  语言内置模式匹配；闭包(closure)；函数也可以看做一个值；提供多线程（协同进程，并非操作系统所支持的线程）支持；
  通过闭包和table可以很方便地支持面向对象编程所需要的一些关键机制，比如数据抽象，虚函数，继承和重载等。

Lua 应用场景

• 游戏开发
• 独立应用脚本
• Web 应用脚本
• 扩展和数据库插件如：MySQL Proxy 和 MySQL WorkBench
• 安全系统，如入侵检测系统

Lua 环境安装

参考：

Lua 环境安装

Lua 基本语法

交互式编程

1
2
3
4
5
6

# 启用
lua -i 或 lua

#命令行输入命令
print("Hello World！")
Hello World！# 输出

脚本式编程

将 Lua 程序代码保存到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程

hello.lua

1
2

print("Hello World！")
print("test1")

执行：

1

$ lua hello.lua

也可以将代码修改为如下形式来执行脚本（在开头添加：#!/usr/local/bin/lua）,指定了 Lua 的解释器 /usr/local/bin directory。加上 # 号标记解释器会忽略它。接下来我们为脚本添加可执行权限，并执行：

1
2
3
4

#!/usr/local/bin/lua

print("Hello World！")
print("www.runoob.com")

执行：

1

./hello.lua

注释

单行注释:

两个减号是单行注释: –

多行注释:

1
2
3
4

--[[
 多行注释
 多行注释
 --]]

多行注释推荐使用 –[=[注释内容]=]，这样可以避免遇到 table[table[idx]] 时就将多行注释结束了。

注意：多行注释加 - 取消注释中间代码可以继续运行，单行注释没有此功能。

标示符

标示符以一个字母 A 到 Z 或 a 到 z 或下划线 _ 开头后加上 0 个或多个字母，下划线，数字（0 到 9）。

最好不要使用下划线加大写字母的标示符，因为Lua的保留字也是这样的。

Lua 不允许使用特殊字符如 @, $, 和 % 来定义标示符。 Lua 是一个区分大小写的编程语言。

关键词

1
2
3
4
5
6

and	break	do	else
elseif	end	false	for
function	if	in	local
nil	not	or	repeat
return	then	true	until
while	goto

一般约定，以下划线开头连接一串大写字母的名字（比如 _VERSION）被保留用于 Lua 内部全局变量。

全局变量

在默认情况下，变量总是认为是全局的。

全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。

如果你想删除一个全局变量，只需要将变量赋值为nil。当且仅当一个变量不等于nil时，这个变量即存在。

1
2
3
4
5

print(b)
nil
> b=10
> print(b)
10

数据类型

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。

Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

1
2
3
4
5
6
7

print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string

nil（空）

1
2

> print(type(a))
nil

nil 作比较时应该加上双引号 “：

1
2
3
4
5
6
7
8
9
10

> type(X)
nil
> type(X)==nil
false
> type(X)=="nil"
true

-- 没有使用type(变量)这个形式，就不需要加引号
print(x == nil) --结果为true
print(x == "nil")--结果为false

type(X)==nil 结果为 false 的原因是因为 type(type(X))==string。

boolean（布尔）

boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true:

number（数字）

Lua 默认只有一种 number 类型 – double（双精度）类型（默认类型可以修改 luaconf.h 里的定义），以下几种写法都被看作是 number 类型：

1
2
3
4
5
6

print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))

string（字符串）

字符串由一对双引号或单引号来表示。

1
2

string1 = "this is string1"
string2 = 'this is string2'

也可以用 2 个方括号 “[[]]” 来表示”一块”字符串。

1
2
3
4
5
6
7
8
9

html = [[
<html>
<head></head>
<body>
    <a href="http://www.runoob.com/">菜鸟教程</a>
</body>
</html>
]]
print(html)

对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:

1
2
3
4
5
6
7
8

> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0

使用 # 来计算字符串的长度，放在字符串前面，如下实例：

1
2
3
4
5

> len = "www.runoob.com"
> print(#len)
14
> print(#"www.runoob.com")
14

运行时，Lua会自动在string和numbers之间自动进行类型转换，当一个字符串使用算术操作符时， string 就会被转成数字。反过来，当 Lua 期望一个 string 而碰到数字时，会将数字转成 string。

table（表）

在 Lua 里，table 的创建是通过”构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表:

1
2
3
4
5

-- 创建一个空的 table
local tbl1 = {}
 
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}

Lua 中的表（table）其实是一个”关联数组”（associative arrays），数组的索引可以是数字或者是字符串。

1
2
3
4
5
6
7
8
9

-- table_test.lua 脚本文件
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

脚本执行结果为：

1
2
3

$ lua table_test.lua 
key : value
10 : 33

不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。

1
2
3
4
5

-- table_test2.lua 脚本文件
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
    print("Key", key)
end

脚本执行结果为：

1
2
3
4
5

$ lua table_test2.lua 
Key    1
Key    2
Key    3
Key    4

table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。

1
2
3
4
5
6
7
8

-- table_test3.lua 脚本文件
a3 = {}
for i = 1, 10 do
    a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

脚本执行结果为：

1
2
3

$ lua table_test3.lua 
val
nil

function（函数）

在 Lua 中，函数是被看作是”第一类值（First-Class Value）”，函数可以存在变量里:

1
2
3
4
5
6
7
8
9
10
11

-- function_test.lua 脚本文件
function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

脚本执行结果为：

1
2
3

$ lua function_test.lua 
120
120

function 可以以匿名函数（anonymous function）的方式通过参数传递:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

-- function_test2.lua 脚本文件
function testFun(tab,fun)
        for k ,v in pairs(tab) do
                print(fun(k,v));
        end
end


tab={key1="val1",key2="val2"};
testFun(tab,
function(key,val)--匿名函数
        return key.."="..val;
end
);

脚本执行结果为：

1
2
3

$ lua function_test2.lua 
key1 = val1
key2 = val2

thread（线程）

在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。

线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。

userdata（自定义类型）

userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。

Lua 变量

变量在使用前，需要在代码中进行声明，即创建该变量。

编译程序执行代码之前编译器需要知道如何给语句变量开辟存储区，用于存储变量的值。

Lua 变量有三种类型：全局变量、局部变量、表中的域。

Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。

局部变量的作用域为从声明位置开始到所在语句块结束。

变量的默认值均为 nil。

尽可能的使用局部变量，有两个好处：

• 避免命名冲突。
• 访问局部变量的速度比全局变量更快。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

-- test.lua 文件脚本
a = 5               -- 全局变量
local b = 5         -- 局部变量

function joke()
    c = 5           -- 全局变量
    local d = 6     -- 局部变量
end

joke()
print(c,d)          --> 5 nil

do
    local a = 6     -- 局部变量
    b = 6           -- 对局部变量重新赋值
    print(a,b);     --> 6 6
end

print(a,b)      --> 5 6

赋值语句

1
2

a = "hello" .. "world"
t.n = t.n + 1

Lua 可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。

1

a, b = 10, 2*x       <-->       a=10; b=2*x

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：

1
2

x, y = y, x                     -- swap 'x' for 'y'
a[i], a[j] = a[j], a[i]         -- swap 'a[i]' for 'a[j]'

当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：

1
2

a. 变量个数 > 值的个数             按变量个数补足nil
b. 变量个数 < 值的个数             多余的值会被忽略

1
2
3
4
5
6
7
8

a, b, c = 0, 1
print(a,b,c)             --> 0   1   nil
 
a, b = a+1, b+1, b+2     -- value of b+2 is ignored
print(a,b)               --> 1   2
 
a, b, c = 0
print(a,b,c)             --> 0   nil   nil

Lua 对多个变量同时赋值，不会进行变量传递，仅做值传递：

1
2
3
4
5
6
7
8
9
10

a, b = 0, 1
a, b = a+1, a+1
print(a,b)               --> 1   1
a, b = 0, 1
a, b = b+1, b+1
print(a,b)               --> 2   2
a, b = 0, 1
a = a+1
b = a+1
print(a,b)               --> 1   2

索引

对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

1
2
3

t[i]
t.i                 -- 当索引为字符串类型时的一种简化写法
gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

1
2
3
4
5
6

> site = {}
> site["key"] = "www.runoob.com"
> print(site["key"])
www.runoob.com
> print(site.key)
www.runoob.com

循环

while 循环

while 循环语法：

1
2
3
4

while(condition)
do
   statements
end

for 循环

for语句有两大类：：

数值for循环

泛型for循环

数值for循环

1
2
3

for var=exp1,exp2,exp3 do  
    <执行体>  
end  

var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次 “执行体”。exp3 是可选的，如果不指定，默认为1。

for的三个表达式在循环开始前一次性求值，以后不再进行求值。比如上面的f(x)只会在循环开始前执行一次，其结果用在后面的循环中。

1
2
3
4
5
6
7

#!/usr/local/bin/lua  
function f(x)  
    print("function")  
    return x*2  
end  
for i=1,f(5) do print(i)  
end

输出：

1
2
3
4
5
6
7
8
9
10
11

function
1
2
3
4
5
6
7
8
9
10

泛型for循环

泛型 for 循环通过一个迭代器函数来遍历所有值，类似 java 中的 foreach 语句。迭代的下标是从1开始。

Lua 编程语言中泛型 for 循环语法格式:

1
2
3
4
5

--打印数组a的所有值  
a = {"one", "two", "three"}
for i, v in ipairs(a) do
    print(i, v)
end

i是数组索引值，v是对应索引的数组元素值。ipairs是Lua提供的一个迭代器函数，用来迭代数组。

for 循环中，循环的索引 i 为外部索引，修改循环语句中的内部索引 i，不会影响循环次数:

1
2
3
4

for i=1,10 do
    i = 10
    print("one time,i:"..i)
end

仍然循环 10 次，只是 i 的值被修改了。

在 lua 中 pairs 与 ipairs 两个迭代器的用法相近，但有一点是不一样的：

pairs 能迭代所有键值对。

ipairs 可以想象成 int+pairs，只会迭代键为数字的键值对，只能遍历所有数组下标的值。
如果 ipairs 在迭代过程中是会直接跳过所有手动设定key值的变量。

pairs 可以遍历表中所有的 key，并且除了迭代器本身以及遍历表本身还可以返回 nil;

但是 ipairs 则不能返回nil,只能返回数字0，如果遇到nil则退出。它只能遍历到表中出现的第一个不是整数的key。

例如：

1
2
3
4

tab = {1,2,a= nil,"d"}
for i,v in ipairs(tab) do
    print(i,v)
end

输出结果为：

1
2
3

1  1
2  2
3  d

这里是直接跳过了 a=nil 这个变量

第二，ipairs 在迭代过程中如果遇到nil时会直接停止。

1
2
3
4

tab = {1,2,a= nil,nil,"d"}
for i,v in ipairs(tab) do
    print(i,v)
end

输出结果为：

1
2

1  1
2  2

这里会在遇到 nil 的时候直接跳出循环。

repeat…until 循环

repeat…until 循环的条件语句在当前循环结束后判断。

1
2
3

repeat
   statements
until( condition )

1
2
3
4
5
6
7

--[ 变量定义 --]
a = 10
--[ 执行循环 --]
repeat
   print("a的值为:", a)
   a = a + 1
until( a > 15 )

输出：

1
2
3
4
5
6

a的值为:    10
a的值为:    11
a的值为:    12
a的值为:    13
a的值为:    14
a的值为:    15

循环控制语句

break 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14

--[ 定义变量 --]
a = 10

--[ while 循环 --]
while( a < 20 )
do
   print("a 的值为:", a)
   a=a+1
   if( a > 15)
   then
      --[ 使用 break 语句终止循环 --]
      break
   end
end

goto 语句

Lua 语言中的 goto 语句允许将控制流程无条件地转到被标记的语句处。

语法格式如下所示：

1

goto Label

Label 的格式为：

1

:: Label ::

以下实例在判断语句中使用 goto：

1
2
3
4
5
6
7

local a = 1
::label:: print("--- goto label ---")

a = a+1
if a < 3 then
    goto label   -- a 小于 3 的时候跳转到标签 label
end

输出结果为：

1
2

--- goto label ---
--- goto label ---

从输出结果可以看出，多输出了一次 — goto label —。

以下实例演示了可以在 lable 中设置多个语句：

1
2
3
4
5
6
7
8
9

i = 0
::s1:: do
  print(i)
  i = i+1
end
if i>3 then
  os.exit()   -- i 大于 3 时退出
end
goto s1

输出结果为：

1
2
3
4

0
1
2
3

continue功能

1
2
3
4
5
6
7
8
9

for i=1, 3 do
    if i <= 2 then
        print(i, "yes continue")
        goto continue
    end
    print(i, " no continue")
    ::continue::
    print([[i'm end]])
end

输出：

1
2
3
4
5
6

1   yes continue
i'm end
2   yes continue
i'm end
3    no continue
i'm end

流程控制

if 语句

1
2
3
4
5
6
7
8
9
10

--[ 定义变量 --]
a = 10;

--[ 使用 if 语句 --]
if( a < 20 )
then
   --[ if 条件为 true 时打印以下信息 --]
   print("a 小于 20" );
end
print("a 的值为:", a);

if…else 语句

1
2
3
4
5
6
7
8
9
10
11
12

--[ 定义变量 --]
a = 100;
--[ 检查条件 --]
if( a < 20 )
then
   --[ if 条件为 true 时执行该语句块 --]
   print("a 小于 20" )
else
   --[ if 条件为 false 时执行该语句块 --]
   print("a 大于 20" )
end
print("a 的值为 :", a)

if…elseif…else 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

--[ 定义变量 --]
a = 100

--[ 检查布尔条件 --]
if( a == 10 )
then
   --[ 如果条件为 true 打印以下信息 --]
   print("a 的值为 10" )
elseif( a == 20 )
then  
   --[ if else if 条件为 true 时打印以下信息 --]
   print("a 的值为 20" )
elseif( a == 30 )
then
   --[ if else if condition 条件为 true 时打印以下信息 --]
   print("a 的值为 30" )
else
   --[ 以上条件语句没有一个为 true 时打印以下信息 --]
   print("没有匹配 a 的值" )
end
print("a 的真实值为: ", a )

函数

在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。

Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如 print() 函数可以将传入的参数打印在控制台上。

Lua 函数主要有两种用途：

• 1.完成指定的任务，这种情况下函数作为调用语句使用；
• 2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。

函数定义

1
2
3
4

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end

解析：

• optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。

• function_name: 指定函数名称。

• argument1, argument2, argument3…, argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。

• function_body: 函数体，函数中需要执行的代码语句块。

• result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

将函数作为参数传递给函数，如下实例：

1
2
3
4
5
6
7
8
9
10
11
12

myprint = function(param)
   print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

以上代码执行结果为：

1
2

这是打印函数 -   ##    10    ##
这是打印函数 -   ##    7    ##

多返回值

Lua函数可以返回多个结果值，比如string.find，其返回匹配串”开始和结束的下标”（如果不存在匹配串返回nil）。

1
2
3

> s, e = string.find("www.runoob.com", "runoob") 
> print(s, e)
5    10

Lua函数中，在return后列出要返回的值的列表即可返回多值，如：

1
2
3
4
5
6
7
8
9
10
11
12
13

function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
       if val > m then
           mi = i
           m = val
       end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

以上代码执行结果为：

1

23    3

可变参数

Lua 函数可以接受可变数目的参数，和 C 语言类似，在函数参数列表中使用三点 … 表示函数有可变的参数。

1
2
3
4
5
6
7
8

function add(...)  
local s = 0  
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组  
    s = s + v  
  end  
  return s  
end  
print(add(3,4,5,6,7))  --->25

通过 select("#",...) 来获取可变参数的数量:

1
2
3
4
5
6
7
8
9
10
11

function average(...)
   result = 0
   local arg={...}
   for i,v in ipairs(arg) do
      result = result + v
   end
   print("总共传入 " .. select("#",...) .. " 个数")
   return result/select("#",...)
end

print("平均值为",average(10,5,3,4,5,6))

以上代码执行结果为：

1
2

总共传入 6 个数
平均值为    5.5

如果是几个固定参数加上可变参数，固定参数必须放在变长参数之前

1
2
3
4
5
6

function fwrite(fmt, ...)  ---> 固定的参数fmt
    return io.write(string.format(fmt, ...))    
end

fwrite("runoob\n")       --->fmt = "runoob", 没有变长参数。  
fwrite("%d%d\n", 1, 2)   --->fmt = "%d%d", 变长参数为 1 和 2

通常在遍历变长参数的时候只需要使用 {…}，然而变长参数可能会包含一些 nil，那么就可以用 select 函数来访问变长参数了：select(‘#’, …) 或者 select(n, …)

• select(‘#’, …) 返回可变参数的长度
• select(n, …) 用于返回 n 到 select(‘#’,…) 的参数

调用 select 时，必须传入一个固定实参 selector(选择开关)和一系列变长参数。如果selector 为数字n,那么 select 返回它的第n个可变实参，否则只能为字符串”#”,这样 select 会返回变长参数的总数。例子代码：

1
2
3
4
5
6
7
8
9
10

do  
    function foo(...)  
        for i = 1, select('#', ...) do  -->获取参数总数
            local arg = select(i, ...); -->读取参数
            print("arg", arg);  
        end  
    end  
 
    foo(1, 2, 3, 4);  
end

输出结果为：

1
2
3
4

arg    1
arg    2
arg    3
arg    4

1
2
3
4
5
6
7
8

select(n,...) --> 返回的是多个参数，而不是一个table
arg = select(n,...) --> 只是接收了第一个参数，参考<多返回值>部分

-- 验证代码
arg = select(2, 1, 6, 8, 8, 9) --> 相当于arg = 6, 8, 8, 9
print(arg)  --> 输出为：6
print(type(arg)) --> 输出为：number（验证了是多返回值的第一个number，而不是打印arg第一个参数的类型table）
print(select(2, 1, 6, 8, 8, 9))  --> 输出为：6    8    8    9

注意：多返回值的函数在赋值时的情况，仅仅只有放在所有逗号之后的那个函数会把返回值展开。

这里列举一个典型情况：

1
2
3
4
5
6
7
8
9
10

function add()
    return 1,0
end

local b,c,d,e = add(),add()

print(b) -- 1
print(c) -- 1
print(d) -- 0
print(e) -- nil

运算符

算术运算符

关系运算符

逻辑运算符

其他运算符

1
2
3
4
5
6
7
8
9
10

a = "Hello "
b = "World"

print("连接字符串 a 和 b ", a..b )

print("b 字符串长度 ",#b )

print("字符串 Test 长度 ",#"Test" )

print("菜鸟教程网址长度 ",#"www.runoob.com" )

输出：

1
2
3
4

连接字符串 a 和 b     Hello World
b 字符串长度     5
字符串 Test 长度     4
菜鸟教程网址长度     14

# 获取表的最大索引的值。

1
2
3
4
5
6
7
8
9

tab1 = {"1","2"}
print("tab1长度"..#tab1)
tab2 = {key1="1","2"}
print("tab2长度"..#tab2)
tab3 = {}
tab3[1]="1"
tab3[2]="2"
tab3[4]="4"
print("tab3长度"..#tab3)

输出:

1
2
3

tab1长度2
tab2长度1
tab3长度4

下标越过 1 位以上，长度还是为 2：

1
2
3
4
5

tab3={}
tab3[1]="1"
tab3[2]="2"
tab3[5]="5"
print("tab3的长度",#tab3)

输出：

1

tab3的长度    2

三元表达式

利用 and 和 or 的特性，若(A and B) A 为 false 返回 A，(A or B）A 为 false 返回 B，以及除 nil 外其他数据类型被当做 true。

可以非常简单的完成:

1
2

local isAppel = false
print(isAppel and "苹果" or "梨")

运算符优先级

从高到低的顺序：

1
2
3
4
5
6
7
8

^
not    - (unary)
*      /       %
+      -
..
<      >      <=     >=     ~=     ==
and
or

除了 ^ 和 .. 外所有的二元运算符都是左连接的。

1
2
3
4
5

a+i < b/2+1          <-->       (a+i) < ((b/2)+1)
5+x^2*8              <-->       5+((x^2)*8)
a < y and y <= z     <-->       (a < y) and (y <= z)
-x^2                 <-->       -(x^2)
x^y^z                <-->       x^(y^z)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

a = 20
b = 10
c = 15
d = 5

e = (a + b) * c / d;-- ( 30 * 15 ) / 5
print("(a + b) * c / d 运算值为  :",e )

e = ((a + b) * c) / d; -- (30 * 15 ) / 5
print("((a + b) * c) / d 运算值为 :",e )

e = (a + b) * (c / d);-- (30) * (15/5)
print("(a + b) * (c / d) 运算值为 :",e )

e = a + (b * c) / d;  -- 20 + (150/5)
print("a + (b * c) / d 运算值为   :",e )

输出：

1
2
3
4

(a + b) * c / d 运算值为  :    90.0
((a + b) * c) / d 运算值为 :    90.0
(a + b) * (c / d) 运算值为 :    90.0
a + (b * c) / d 运算值为   :    50.0

字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

Lua 语言中字符串可以使用以下三种方式来表示：

• 单引号间的一串字符。
• 双引号间的一串字符。
• [[ 与 ]] 间的一串字符。

转义字符用于表示不能直接显示的字符，比如后退键，回车键，等。如在字符串转换双引号可以使用 “"“。

字符串操作

1
2

string.upper(argument) -- 字符串全部转为大写字母。
string.lower(argument) -- 字符串全部转为小写字母。

字符串截取

字符串截取使用 sub() 方法。

1
2

string.sub() 用于截取字符串，原型为：
string.sub(s, i [, j])

参数说明：

• s：要截取的字符串。
• i：截取开始位置。
• j：截取结束位置，默认为 -1，最后一个字符。

字符串大小写转换

1
2
3

string1 = "Lua";
print(string.upper(string1))
print(string.lower(string1))

字符串查找与反转

1
2
3
4
5

string = "Lua Tutorial"
-- 查找字符串
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("新字符串为",reversedString)

字符串格式化

string.format() 函数来生成具有特定格式的字符串

字符与整数相互转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14

-- 字符转换
-- 转换第一个字符
print(string.byte("Lua"))
-- 转换第三个字符
print(string.byte("Lua",3))
-- 转换末尾第一个字符
print(string.byte("Lua",-1))
-- 第二个字符
print(string.byte("Lua",2))
-- 转换末尾第二个字符
print(string.byte("Lua",-2))

-- 整数 ASCII 码转换为字符
print(string.char(97))

输出：

1
2
3
4
5
6

76
97
97
117
117
a

其他常用函数

1
2
3
4
5
6

- 字符串长度
print("字符串长度 ",string.len(string2))

-- 字符串复制 2 次
repeatedString = string.rep(string2,2)
print(repeatedString)

匹配模式

Lua 中的匹配模式直接用常规的字符串来描述。 它用于模式匹配函数 string.find, string.gmatch, string.gsub, string.match。

table(表)

1
2
3
4
5
6
7
8
9

-- 初始化表
mytable = {}

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

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

参考：

https://www.runoob.com/lua/lua-tables.html

基本命令

1

vimtutor // vim 教程

移动光标

1
2
3
4
5
6
7
8
9
10

# hjkl
# 2w 向前移动两个单词
# 3e 向前移动到第 3 个单词的末尾
# 0 移动到行首
# $ 当前行的末尾
# gg 文件第一行
# G 文件最后一行
# 行号+G 指定行
# <ctrl>+o 跳转回之前的位置
# <ctrl>+i 返回跳转之前的位置

退出

1
2
3

# <esc> 进入正常模式
# :q! 不保存退出
# :wq 保存后退出

删除

1
2
3
4
5
6

# x 删除当前字符
# dw 删除至当前单词末尾
# de 删除至当前单词末尾，包括当前字符
# d$ 删除至当前行尾
# dd 删除整行
# 2dd 删除两行

修改

1
2
3
4

# i 插入文本
# A 当前行末尾添加
# r 替换当前字符
# o 打开新的一行并进入插入模式

撤销

1
2
3
4
5
6
7
8

# u 撤销
# <ctrl>+r 取消撤销
复制粘贴剪切
# v 进入可视模式
# y 复制
# p 粘贴
# yy 复制当前行
# dd 剪切当前行

状态

1
2
3
4
5
6
7
8
9

#<ctrl>+g 显示当前行以及文件信息
查找
# / 正向查找（n：继续查找，N：相反方向继续查找）
# ？ 逆向查找
# % 查找配对的 {，[，(
# :set ic 忽略大小写
# :set noic 取消忽略大小写
# :set hls 匹配项高亮显示
# :set is 显示部分匹配

替换

1
2
3

# :s/old/new 替换该行第一个匹配串
# :s/old/new/g 替换全行的匹配串
# :%s/old/new/g 替换整个文件的匹配串

折叠

1
2
3
4

# zc 折叠
# zC 折叠所有嵌套
# zo 展开折叠
# zO 展开所有折叠嵌套

执行外部命令

1

# :!shell 执行外部命令

.vimrc

.vimrc 是 Vim 的配置文件，需要我们自己创建：

1
2
3
4
5
6
7
8
9
10
11

cd Home               // 进入 Home 目录
touch .vimrc          // 配置文件

# Unix
# vim-plug
# Vim
curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim
# Neovim
curl -fLo ~/.local/share/nvim/site/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

https://github.com/junegunn/vim-plug

https://github.com/FengShangWuQi/to-vim/blob/master/.vimrc

基本配置

取消备份

1
2

set nobackup
set noswapfile

文件编码

1

setencoding=utf-8

显示行号

setnumber

取消换行

setnowrap

显示光标当前位置

setruler

设置缩进

1
2
3

set cindent
set tabstop=2
set shiftwidth=2

突出显示当前行

setcursorline

查找

1
2
3

set ic
set hls
set is

左下角显示当前vim模式

setshowmode

代码折叠

1
2

#启动 vim 时关闭折叠代码
set nofoldenable

主题

1
2
3

syntax enable
set background=dark
colorscheme solarized

https://github.com/altercation/vim-colors-solarized
https://github.com/Anthony25/gnome-terminal-colors-solarized

插件配置

树形目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

Plug 'scrooloose/nerdtree'
Plug 'jistr/vim-nerdtree-tabs'
Plug 'Xuyuanp/nerdtree-git-plugin'

autocmd vimenter * NERDTree
map <C-n> :NERDTreeToggle<CR>
let NERDTreeShowHidden=1
let g:NERDTreeShowIgnoredStatus = 1
let g:nerdtree_tabs_open_on_console_startup=1
let g:NERDTreeIndicatorMapCustom = {
    \ "Modified"  : "✹",
    \ "Staged"    : "✚",
    \ "Untracked" : "✭",
    \ "Renamed"   : "➜",
    \ "Unmerged"  : "═",
    \ "Deleted"   : "✖",
    \ "Dirty"     : "✗",
    \ "Clean"     : "✔︎",
    \ 'Ignored'   : '☒',
    \ "Unknown"   : "?"
    \ }

# o 打开关闭文件或目录
# e 以文件管理的方式打开选中的目录
# t 在标签页中打开
# T 在标签页中打开，但光标仍然留在 NERDTree
# r 刷新光标所在的目录
# R 刷新当前根路径
# X 收起所有目录
# p 小写，跳转到光标所在的上一级路径
# P 大写，跳转到当前根路径
# J 到第一个节点
# K 到最后一个节点
# I 显示隐藏文件
# m 显示文件操作菜单
# C 将根路径设置为光标所在的目录
# u 设置上级目录为根路径
# ctrl + w + w 光标自动在左右侧窗口切换
# ctrl + w + r 移动当前窗口的布局位置
# :tabc 关闭当前的 tab
# :tabo   关闭所有其他的 tab
# :tabp   前一个 tab
# :tabn   后一个 tab
# gT      前一个 tab
# gt      后一个 tab

https://github.com/scrooloose/nerdtree
https://github.com/jistr/vim-nerdtree-tabs
https://github.com/Xuyuanp/nerdtree-git-plugin

代码，引号，路径补全

1
2
3

Plug 'Valloric/YouCompleteMe'
Plug 'Raimondi/delimitMate'
Plug 'Shougo/deoplete.nvim', { 'do': ':UpdateRemotePlugins' }

https://github.com/Valloric/YouCompleteMe
https://github.com/Raimondi/delimitMate
https://github.com/Shougo/deoplete.nvim

语法高亮，检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Plug 'sheerun/vim-polyglot'
Plug 'w0rp/ale'

let g:ale_linters = {
\    'javascript': ['eslint'],
\    'css': ['stylelint'],
\}
let g:ale_fixers = {
\    'javascript': ['eslint'],
\    'css': ['stylelint'],
\}
let g:ale_fix_on_save = 1

let g:ale_sign_column_always = 1
let g:ale_sign_error = '●'
let g:ale_sign_warning = '▶'

nmap <silent> <C-k> <Plug>(ale_previous_wrap)
nmap <silent> <C-j> <Plug>(ale_next_wrap)

https://github.com/w0rp/ale
https://github.com/sheerun/vim-polyglot

文件，代码搜索

1
2

Plug 'rking/ag.vim'
Plug 'kien/ctrlp.vim'

https://github.com/kien/ctrlp.vim
https://github.com/ggreer/the_silver_searcher
https://github.com/rking/ag.vim

加强版状态栏

1
2
3
4

Plug 'vim-airline/vim-airline'
Plug 'vim-airline/vim-airline-themes'

let g:airline_theme='papercolor'

https://github.com/vim-airline/vim-airline
https://github.com/vim-airline/vim-airline-themes

代码注释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Plug 'scrooloose/nerdcommenter'

# <leader>cc // 注释
# <leader>cm 只用一组符号注释
# <leader>cA 在行尾添加注释
# <leader>c$ /* 注释 */
# <leader>cs /* 块注释 */
# <leader>cy 注释并复制
# <leader>c<space> 注释/取消注释
# <leader>ca 切换　// 和 /* */
# <leader>cu 取消注释

let g:NERDSpaceDelims = 1
let g:NERDDefaultAlign = 'left'
let g:NERDCustomDelimiters = {
            \ 'javascript': { 'left': '//', 'leftAlt': '/**', 'rightAlt': '*/' },
            \ 'less': { 'left': '/**', 'right': '*/' }
        \ }

https://github.com/scrooloose/nerdcommenter

git

1
2

Plug 'airblade/vim-gitgutter'
Plug 'tpope/vim-fugitive'

https://github.com/airblade/vim-gitgutter
https://github.com/tpope/vim-fugitive

Markdown

1
2
3
4
5

Plug 'suan/vim-instant-markdown'

let g:instant_markdown_slow = 1
let g:instant_markdown_autostart = 0
# :InstantMarkdownPreview

https://github.com/suan/vim-instant-markdown

Emmet

1
2
3
4
5
6
7
8

Plug 'mattn/emmet-vim'

let g:user_emmet_leader_key='<Tab>'
let g:user_emmet_settings = {
         \ 'javascript.jsx' : {
            \ 'extends' : 'jsx',
         \ },
      \ }

https://github.com/mattn/emmet-vim

html 5

1

Plug'othree/html5.vim'

https://github.com/othree/html5.vim

css 3

1
2
3
4
5
6
7
8

Plug 'hail2u/vim-css3-syntax'
Plug 'ap/vim-css-color'

augroup VimCSS3Syntax
  autocmd!

  autocmd FileType css setlocal iskeyword+=-
augroup END

https://github.com/hail2u/vim-css3-syntax
https://github.com/ap/vim-css-color

JavaScipt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Plug 'pangloss/vim-javascript'
let g:javascript_plugin_jsdoc = 1
let g:javascript_plugin_ngdoc = 1
let g:javascript_plugin_flow = 1
set foldmethod=syntax
let g:javascript_conceal_function             = "ƒ"
let g:javascript_conceal_null                 = "ø"
let g:javascript_conceal_this                 = "@"
let g:javascript_conceal_return               = "⇚"
let g:javascript_conceal_undefined            = "¿"
let g:javascript_conceal_NaN                  = "ℕ"
let g:javascript_conceal_prototype            = "¶"
let g:javascript_conceal_static               = "•"
let g:javascript_conceal_super                = "Ω"
let g:javascript_conceal_arrow_function       = "⇒"
let g:javascript_conceal_noarg_arrow_function = " "
let g:javascript_conceal_underscore_arrow_function = " "
set conceallevel=1

https://github.com/pangloss/vim-javascript
（注：上述脚本中存在特殊字符，有的情况下显示不正确，请直接用上述链接的内容。）

React

1
2

Plug 'mxw/vim-jsx'
let g:jsx_ext_required = 0

https://github.com/mxw/vim-jsx

Prettier

1
2
3
4
5
6
7
8

Plug 'prettier/vim-prettier', {
  \ 'do': 'yarn install',
  \ 'for': ['javascript', 'typescript', 'css', 'less', 'scss', 'json', 'graphql'] }
let g:prettier#config#bracket_spacing = 'true'
let g:prettier#config#jsx_bracket_same_line = 'false'
let g:prettier#autoformat = 0
autocmd BufWritePre *.js,*.jsx,*.mjs,*.ts,*.tsx,*.css,*.less,*.scss,*.json,*.graphql PrettierAsync
# :Prettier

https://github.com/prettier/vim-prettier

转载：

如何让 vim 成为我们的神器

托管类型

托管类型包括 引用类型 以及 包含有引用类型或托管类型成员的结构。

• 引用类型
• 含引用类型或托管类型成员（字段、自动实现 get 访问器的属性）的结构（managed structure）

非托管类型

如果某个类型是以下类型之一，则它是非托管类型 ：

• sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal 或 bool
• 任何枚举类型
• 任何指针类型
• 任何用户定义的 struct 类型，只包含非托管类型的字段，并且在 C# 7.3 及更早版本中，不是构造类型（包含至少一个类型参数的类型）

参考：

非托管类型（C# 参考）

“.NET Core 3.x”和“.NET Standard 2.1”支持 C# 8.0 。有关详细信息，请参阅C# 语言版本控制

Readonly 成员

可将 readonly 修饰符应用于结构的成员。 它指示该成员不会修改状态。 这比将 readonly 修饰符应用于 struct 声明更精细。

1
2
3
4
5
6
7
8
9

public struct Point
{
    public double X { get; set; }
    public double Y { get; set; }
    public readonly  double Distance => Math.Sqrt(X * X + Y * Y);

    public readonly override string ToString() =>
        $"({X}, {Y}) is {Distance} from the origin";
}

readonly 修饰符对于只读属性是必需的。 编译器会假设 get 访问器可以修改状态；必须显式声明 readonly。 自动实现的属性是一个例外；编译器会将所有自动实现的 Getter 视为 readonly，因此，此处无需向 X 和 Y 属性添加 readonly 修饰符。

默认接口方法

现在可以将成员添加到接口，并为这些成员提供实现。 借助此语言功能，API 作者可以将方法添加到以后版本的接口中，而不会破坏与该接口当前实现的源或二进制文件兼容性。 现有的实现继承默认实现。

参考：

https://github.com/dotnet/samples/tree/master/csharp/tutorials/default-interface-members-versions/starter/customer-relationship

[教程：在 C# 8.0 中使用默认接口方法更新接口](https://docs.microsoft.com/zh-cn/dotnet/csharp/tutorials/default-interface-methods-versions

switch 表达式

1
2
3
4
5
6
7
8
9
10
11
12

public static RGBColor FromRainbow(Rainbow colorBand) =>
    colorBand switch
    {
        Rainbow.Red    => new RGBColor(0xFF, 0x00, 0x00),
        Rainbow.Orange => new RGBColor(0xFF, 0x7F, 0x00),
        Rainbow.Yellow => new RGBColor(0xFF, 0xFF, 0x00),
        Rainbow.Green  => new RGBColor(0x00, 0xFF, 0x00),
        Rainbow.Blue   => new RGBColor(0x00, 0x00, 0xFF),
        Rainbow.Indigo => new RGBColor(0x4B, 0x00, 0x82),
        Rainbow.Violet => new RGBColor(0x94, 0x00, 0xD3),
        _              => throw new ArgumentException(message: "invalid enum value", paramName: nameof(colorBand)),
    };

• 变量位于 switch 关键字之前。 不同的顺序使得在视觉上可以很轻松地区分 switch 表达式和 switch 语句。
• 将 case 和 : 元素替换为 =>。 它更简洁，更直观。
• 将 default 事例替换为 _ 弃元。
• 正文是表达式，不是语句。

属性模式

1
2
3
4
5
6
7
8
9

public static decimal ComputeSalesTax(Address location, decimal salePrice) =>
    location switch
    {
        { State: "WA" } => salePrice * 0.06M,
        { State: "MN" } => salePrice * 0.075M,
        { State: "MI" } => salePrice * 0.05M,
        // other cases removed for brevity...
        _ => 0M
    };

元组模式

1
2
3
4
5
6
7
8
9
10
11

public static string RockPaperScissors(string first, string second)
    => (first, second) switch
    {
        ("rock", "paper") => "rock is covered by paper. Paper wins.",
        ("rock", "scissors") => "rock breaks scissors. Rock wins.",
        ("paper", "rock") => "paper covers rock. Paper wins.",
        ("paper", "scissors") => "paper is cut by scissors. Scissors wins.",
        ("scissors", "rock") => "scissors is broken by rock. Rock wins.",
        ("scissors", "paper") => "scissors cuts paper. Scissors wins.",
        (_, _) => "tie"
    };

位置模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y) => (X, Y) = (x, y);

    public void Deconstruct(out int x, out int y) =>
        (x, y) = (X, Y);
}

public enum Quadrant
{
    Unknown,
    Origin,
    One,
    Two,
    Three,
    Four,
    OnBorder
}

static Quadrant GetQuadrant(Point point) => point switch
{
    (0, 0) => Quadrant.Origin,
    var (x, y) when x > 0 && y > 0 => Quadrant.One,
    var (x, y) when x < 0 && y > 0 => Quadrant.Two,
    var (x, y) when x < 0 && y < 0 => Quadrant.Three,
    var (x, y) when x > 0 && y < 0 => Quadrant.Four,
    var (_, _) => Quadrant.OnBorder,
    _ => Quadrant.Unknown
};

using 声明

using 声明是前面带 using 关键字的变量声明。它指示编译器声明的变量应在封闭范围的末尾进行处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

static int WriteLinesToFile(IEnumerable<string> lines)
{
    // 当到达方法的右括号时，将对该文件进行处理。
    using var file = new System.IO.StreamWriter("WriteLines2.txt");
    // Notice how we declare skippedLines after the using statement.
    int skippedLines = 0;
    foreach (string line in lines)
    {
        if (!line.Contains("Second"))
        {
            file.WriteLine(line);
        }
        else
        {
            skippedLines++;
        }
    }
    // Notice how skippedLines is in scope here.
    return skippedLines;
    // file is disposed here
}

静态本地函数

1
2
3
4
5
6
7
8

int M()
{
    int y = 5;
    int x = 7;
    return Add(x, y);

    static int Add(int left, int right) => left + right;
}

可处置的 ref 结构

用 ref 修饰符声明的 struct 可能无法实现任何接口，因此无法实现 IDisposable。 因此，要能够处理 ref struct，它必须有一个可访问的 void Dispose() 方法。 此功能同样适用于 readonly ref struct 声明。

可为空引用类型

异步流

从 C# 8.0 开始，可以创建并以异步方式使用流。 返回异步流的方法有三个属性：

• 它是用 async 修饰符声明的。
• 它将返回 IAsyncEnumerable。
• 该方法包含用于在异步流中返回连续元素的 yield return 语句。

使用异步流需要在枚举流元素时在 foreach 关键字前面添加 await 关键字。 添加 await 关键字需要枚举异步流的方法，以使用 async 修饰符进行声明并返回 async 方法允许的类型。 通常这意味着返回 Task 或 Task。 也可以为 ValueTask 或 ValueTask。 方法既可以使用异步流，也可以生成异步流，这意味着它将返回 IAsyncEnumerable。

1
2
3
4

await foreach (var number in GenerateSequence())
{
    Console.WriteLine(number);
}

异步可释放

从 C# 8.0 开始，语言支持实现 System.IAsyncDisposable 接口的异步可释放类型。 可使用 await using 语句来处理异步可释放对象。

索引和范围

索引和范围为访问序列中的单个元素或范围提供了简洁的语法。

此语言支持依赖于两个新类型和两个新运算符：

• System.Index 表示一个序列索引。
• 来自末尾运算符 ^ 的索引，指定一个索引与序列末尾相关。
• System.Range 表示序列的子范围。
• 范围运算符 ..，用于指定范围的开始和末尾，就像操作数一样。

0 索引与 sequence[0] 相同。 ^0 索引与 sequence[sequence.Length] 相同。 请注意，sequence[^0] 不会引发异常，就像 sequence[sequence.Length] 一样。 对于任何数字 n，索引 ^n 与 sequence.Length - n 相同。

范围指定范围的开始和末尾 。 包括此范围的开始，但不包括此范围的末尾，这表示此范围包含开始但不包含末尾 。 范围 [0..^0] 表示整个范围，就像 [0..sequence.Length] 表示整个范围。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

var words = new string[]
{
                // index from start    index from end
    "The",      // 0                   ^9
    "quick",    // 1                   ^8
    "brown",    // 2                   ^7
    "fox",      // 3                   ^6
    "jumped",   // 4                   ^5
    "over",     // 5                   ^4
    "the",      // 6                   ^3
    "lazy",     // 7                   ^2
    "dog"       // 8                   ^1
};              // 9 (or words.Length) ^0

// 使用 ^1 索引检索最后一个词
Console.WriteLine($"The last word is {words[^1]}");
// writes "dog"

// 包括 words[1] 到 words[3]
var quickBrownFox = words[1..4];

// 包括 words[^2] 和 words[^1]
var lazyDog = words[^2..^0];

var allWords = words[..]; // contains "The" through "dog".
var firstPhrase = words[..4]; // contains "The" through "fox"
var lastPhrase = words[6..]; // contains "the", "lazy" and "dog"

Range phrase = 1..4;
var text = words[phrase];

Null 合并赋值

C# 8.0 引入了 null 合并赋值运算符 ??=。 仅当左操作数计算为 null 时，才能使用运算符 ??= 将其右操作数的值分配给左操作数。

1
2
3
4
5
6
7
8
9

List<int> numbers = null;
int? i = null;

numbers ??= new List<int>();
numbers.Add(i ??= 17);
numbers.Add(i ??= 20);

Console.WriteLine(string.Join(" ", numbers));  // output: 17 17
Console.WriteLine(i);  // output: 17

非托管构造类型

在 C# 7.3 及更低版本中，构造类型（包含至少一个类型参数的类型）不能为非托管类型。 从 C# 8.0 开始，如果构造的值类型仅包含非托管类型的字段，则该类型不受管理。

1
2
3
4
5

public struct Coords<T>
{
    public T X;
    public T Y;
}

Coords 类型为 C# 8.0 及更高版本中的非托管类型。 与任何非托管类型一样，可以创建指向此类型的变量的指针，或针对此类型的实例在堆栈上分配内存块：

1
2
3
4
5
6

Span<Coords<int>> coordinates = stackalloc[]
{
    new Coords<int> { X = 0, Y = 0 },
    new Coords<int> { X = 0, Y = 3 },
    new Coords<int> { X = 4, Y = 0 }
};

嵌套表达式中的 stackalloc

stackalloc 表达式在堆栈上分配内存块。该方法返回时，将自动丢弃在方法执行期间创建的堆栈中分配的内存块。 不能显式释放使用 stackalloc 分配的内存。 堆栈中分配的内存块不受垃圾回收的影响，也不必通过 fixed 语句固定。

1
2
3

Span<int> numbers = stackalloc[] { 1, 2, 3, 4, 5, 6 };
var ind = numbers.IndexOfAny(stackalloc[] { 2, 4, 6, 8 });
Console.WriteLine(ind);  // output: 1

stackalloc 表达式（C# 参考）

内插逐字字符串的增强功能

内插逐字字符串中 $ 和 @ 标记的顺序可以任意安排：$@”…” 和 @$”…” 均为有效的内插逐字字符串。 在早期 C# 版本中，$ 标记必须出现在 @ 标记之前。

参考：

C# 8.0 中的新增功能

out 变量

可以将 out 值内联作为参数声明到使用这些参数的方法中。

无需分配初始值

1
2
3
4

if (int.TryParse(input, out var answer))
    Console.WriteLine(answer);
else
    Console.WriteLine("Could not parse input");

元组

低于 C# 7.0 的版本中也提供元组，但它们效率低下且不具有语言支持。 这意味着元组元素只能作为 Item1 和 Item2 等引用。 C# 7.0 引入了对元组的语言支持，可利用更有效的新元组类型向元组字段赋予语义名称。这些名称仅存在于编译时且不保留，例如在运行时使用反射来检查元组时。

1
2
3
4
5
6
7
8
9
10
11

// 第一种写法
(string Alpha, string Beta) namedLetters = ("a", "b");

//  第二种写法
var alphabetStart = (Alpha: "a", Beta: "b");
Console.WriteLine($"{namedLetters.Alpha}, {namedLetters.Beta}");

//  第三种写法
(int max, int min) = Range(numbers);
Console.WriteLine(max);
Console.WriteLine(min);

从 C# 7.3 开始，元组类型支持 == 和 != 运算符。这些运算符按照元组元素的顺序将左侧操作数的成员与相应的右侧操作数的成员进行比较。

参考：

元组类型（C# 参考）

弃元

弃元是一个名为 _（下划线字符）的只写变量，可向单个变量赋予要放弃的所有值。 弃元类似于未赋值的变量；不可在代码中使用弃元（赋值语句除外）。

在以下方案中支持弃元：

• 在对元组或用户定义的类型进行解构时。
• 在使用 out 参数调用方法时。
• 在使用 is 和 switch 语句匹配操作的模式中。
• 在要将某赋值的值显式标识为弃元时用作独立标识符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        var (_, _, _, pop1, _, pop2) = QueryCityDataForYears("New York City", 1960, 2010);

        Console.WriteLine($"Population change, 1960 to 2010: {pop2 - pop1:N0}");
    }

    private static (string, double, int, int, int, int) QueryCityDataForYears(string name, int year1, int year2)
    {
        int population1 = 0, population2 = 0;
        double area = 0;

        if (name == "New York City")
        {
            area = 468.48;
            if (year1 == 1960)
            {
                population1 = 7781984;
            }
            if (year2 == 2010)
            {
                population2 = 8175133;
            }
            return (name, area, year1, population1, year2, population2);
        }

        return ("", 0, 0, 0, 0, 0);
    }
}
// The example displays the following output:
//      Population change, 1960 to 2010: 393,149

模式匹配

模式匹配支持 is 表达式和 switch 表达式。 每个表达式都允许检查对象及其属性以确定该对象是否满足所寻求的模式。 使用 when 关键字来指定模式的其他规则。

1
2

if (input is int count)
    sum += count;