新文章 - Lua中的ipair 和 pair的区别 / table

2024-09-04 10:32
文章标签 文章 区别 table lua pair ipair

本文主要是介绍新文章 - Lua中的ipair 和 pair的区别 / table，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 参考博客:  https://blog.csdn.net/W_han__/article/details/51376615 (https://blog.csdn.net/heyuchang666/article/details/51003492)

 参考博客:  https://www.jianshu.com/p/4db84cf0d61a(初探 lua 的唯一数据结构 table)

----------------------------------------------------------------------------------------------------

原来，pairs会遍历table的所有键值对。table是键值对的数据结构。

而ipairs就是固定地从key值1开始，下次key累加1进行遍历，如果key对应的value不存在，就停止遍历。顺便说下，记忆也很简单，带i的就是根据integer key值从1开始遍历的。

请看个例子：
tb = {"oh", [3] = "god", "my", [5] = "hello", [6] = "world"}

for k,v in ipairs(tb) do
     print(k, v)
end
输出结果就是：
1       oh
2       my
3       god
因为tb不存在tb[4]，所以遍历到此为止了。

for k,v in pairs(tb) do
     print(k, v)
end
输出结果：
1       oh
2       my
3       god
6       world
5       hello
我们都能猜到，将输出所有的内容。然而你发现输出的顺序跟你tb中的顺序不同。
如果我们要按顺序输出怎么办？办法之一是：
for i = 1, #tb do
     if tb[i] then
          print(tb[i])
     else
end
当然，仅仅是个数组的话，ipairs也没问题。
———————————————————————————————————————————————————————— 
 

在lua的世界中是只有一种数据结构的，那就是table。
而 table 做了在其他语言中，高级特性该做的所有事情。

table 中的数组和hash

这个是比较诡异的一种操作。没错，hash和数组在一起。举个例子

 

local color = {first="red","blue",third="green","yellow"}
print(color["first"])   -- red
print(color[1])         -- blue
print(color[2])         -- yellow
print(color)            -- table: 0x41d99d48

当取下标时，只取出数组部分，当取键时，就是去取hash部分。
而table本身如果打印的话，他只是一个地址。

lua 的数组下标是从1开始的，这点需要注意了。

而遍历他们，lua又提供了两个方法，就是ipair和pair。

 

local color = {first="red","blue",third="green","yellow"}
for k,v in ipairs(color) do print(k,v)
end
-- 1       blue
-- 2       yellowfor k,v in pairs(color) do print(k,v)
end-- 1       blue
-- 2       yellow
-- third   green
-- first   red

table 的库函数

  • table.getn 获得table的长度
    对于一个序列，其元素个数是getn或者一元操作符 # 。其取的长度都是数组的。
    且其操作是O(N)的，所以尽量在长度很长的情况下避免使用。

 

local color = {first="red","blue",third="green","yellow","black"}
print(table.getn(color))  -- 3
print(#color)             -- 3
  • table.remove 删除指定元素
    删除元素，只是说删除 数组部分，也就是使用下标去删除的。

 

local color = {first="red","blue",third="green","yellow","black"}
table.remove(color,1)
for k,v in pairs(color) do print(k,v)
end
-- 1       yellow
-- 2       black
-- third   green
-- first   red

如果是删除 hash 部分的话就是 将指定的 元素设置成nil。同时，这样也是对内存的释放。

 

local color = {first="red","blue",third="green","yellow","black"}
table.remove(color,1)
color.first = nil
for k,v in pairs(color) do print(k,v)
end
-- 1       yellow
-- 2       black
-- third   green
  • table.concat 元素拼接
    按照此方式，把table中的元素拼接起来，同样的，还是针对的是一个table中的数组部分。

 

local color = {first="red","blue",third="green","yellow","black"}
print(table.concat(color,","))
-- blue,yellow,black
print(table.concat(color,",",2))
-- yellow,black

中间的“，”是指将 数组中的元素以什么为分割符分割。如果最后还跟着数字，则指的是取该数字以后的元素。

  • table.insert 插入一个元素
    同样，这是对数组操作的了。但是insert的插入性能不乐观，如果不是指定下标去插入元素的话，那么每次需要调用Luajit的 lj_table_len 来获取数组的长度。以便插入队尾。
    所以在热代码处减少对insert的使用

 

local color = {first="red","blue",third="green","yellow","black"}
table.insert(color,1,"orange")
for k,v in pairs(color) doprint(k,v)
end
  • table.new 新建一个table
    这是luajit的table扩展函数。用来新建table。这个函数会预先分配好指定数组和hash的空间大小。而不是在插入元素时自增长
    table.new(narray,nhash) 正是这个含义。
    因为自增长是一个代价非常高的操作。，会涉及到空间分配，resize和rehash等。
    因为是扩展出来的，所以使用的时候需要require一下。

 

local new_tab = require "table.new" -- 需要luajit-2.1.0-beta3local t = new_tab(10,5)
for i = 1,10 dot[i] = i
end
  • table.clear 清空table
    这个同样是函数 table.clear() 里面的函数，用来清空某个table里面的所有数据。但并不会释放数组和hash所占用的内存。
    所以，在循环利用lua table时比较有效。可以避免反复的创建和销毁。

 

local clear_tab = require "table.clear" -- 需要luajit-2.1.0-beta3local color = {first = "red", "blue", third = "green", "yellow"}
clear_tab(color)
for k,v in pairs(color) do print(k,v)
end

元表

元表（metatable）。元表是Lua中独有的概念，在实际的项目中，就是靠元表来对lua作面向对象编程的，在几乎所有的lua-resty-* 库中，都有他的身影。
最重要的函数辅助元表的处理。

  • setmetatable(table,metatable): 对指定表设置元表，如果元表中存在 _metatable 键值，setmetatable会失败。
  • getmetatable(table)，用于获取table的元素。

类似python中的魔术方法，lua在这方面也有类似的做法。

  • __index 元方法
    __index 是元表中最常用的键值。当通过键访问表时，如果这个键没有值，则会寻找该元表的__index值。

 

local v = { bar = 1 }
t = setmetatable({}, { __index = v})
print(t.bar)
-- 1
  • __newindex 元方法
    该方法对表进行更新，_index 用来对表访问，当给表一个不存在的索引的时候，解释器会查找__newindex 元方法。

 

local t = {}
myt = setmetatable({k1 = "v1"}, {__newindex = t})print(myt.k1)
-- v1myt.k2 = "v2"
print(myt.k2,t.k2)
-- nil v2myt.k1 = "new_v1"
print(myt.k1,t.k1)
-- new_v1 nil
  • __tostring 元方法
    __tostring 元方法是用来改变一个表的输出行为。
    比如

 

local t = { major = 5,minor = 3,patch = 102
}
myt = setmetatable(t, {__index = { name = "lua" },__tostring = function (t)return string.format( "%s version is %d.%d.%d",t.name,t.major,t.minor,t.patch )end
})print(tostring(myt))
- lua version is 5.3.102
  • __call 元方法
    可以让表像方法一样被调用。

 

local version = { name = "lua",major = 5,minor = 3,patch = 102
}local function print_version(t)print(string.format( "%s version is %d.%d.%d",t.name,t.major,t.minor,t.patch ))
endversion  = setmetatable( version, { __call = print_version })version()

面向对象

面向对象是众多编程语言的所支持的。
其主要特点有：

  1. 封装：能把一个实体的信息，功能装入一个变量或对象里。
  2. 继承：在不改动原有方法的基础上，对其进行扩充。
  3. 多态：在同一操作作用于不同的对象时。可以有不同的解释。
  4. 抽象： 简化复杂现实问题的解决。

 

-- Meta class
Rectangle = {area    = 0,length  = 0,breadth = 0,
}function Rectangle:new ( o,length,breadth )o = o or {}setmetatable(o, self)self.__index = selfself.length  = length or 0self.breadth = breadth or 0self.area    = length * breadthreturn o
endfunction Rectangle:printArea()print("矩形面积为 ",self.area)
end-- 创建对象
r = Rectangle:new(nil,10,20)-- 访问属性
print("矩形的长为",r.length)
-- 矩形的长为      10-- 访问成员函数
r:printArea()    -- 或者写成 r.printArea(r)  用 ：号表示是一个语法糖
-- 矩形面积为      200



 

这篇关于新文章 - Lua中的ipair 和 pair的区别 / table的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1135774。

相关文章

一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
MySQL中VARCHAR和TEXT的区别小结

MySQL中VARCHAR和TEXT的区别小结

《MySQL中VARCHAR和TEXT的区别小结》MySQL中VARCHAR和TEXT用于存储字符串,VARCHAR可变长度存储在行内,适合短文本；TEXT存储在溢出页,适合大文本,下面就来具体的了解... 目录一、VARCHAR 和 TEXT 基本介绍1. VARCHAR2. TEXT二、VARCHAR
阅读更多...
python中getsizeof和asizeof的区别小结

python中getsizeof和asizeof的区别小结

《python中getsizeof和asizeof的区别小结》本文详细的介绍了getsizeof和asizeof的区别,这两个函数都用于获取对象的内存占用大小,它们来自不同的库,下面就来详细的介绍一下... 目录sys.getsizeof (python 内置)pympler.asizeof.asizeof
阅读更多...
Vue和React受控组件的区别小结

Vue和React受控组件的区别小结

《Vue和React受控组件的区别小结》本文主要介绍了Vue和React受控组件的区别小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学... 目录背景React 的实现vue3 的实现写法一：直接修改事件参数写法二：通过ref引用 DOMVu
阅读更多...
Go之errors.New和fmt.Errorf 的区别小结

Go之errors.New和fmt.Errorf 的区别小结

《Go之errors.New和fmt.Errorf的区别小结》本文主要介绍了Go之errors.New和fmt.Errorf的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考... 目录error的基本用法1. 获取错误信息2. 在条件判断中使用基本区别1.函数签名2.使用场景详细对
阅读更多...
Redis中哨兵机制和集群的区别及说明

Redis中哨兵机制和集群的区别及说明

《Redis中哨兵机制和集群的区别及说明》Redis哨兵通过主从复制实现高可用,适用于中小规模数据；集群采用分布式分片,支持动态扩展,适合大规模数据,哨兵管理简单但扩展性弱,集群性能更强但架构复杂,根... 目录一、架构设计与节点角色1. 哨兵机制（Sentinel）2. 集群（Cluster）二、数据分片
阅读更多...
一文带你迅速搞懂路由器/交换机/光猫三者概念区别

一文带你迅速搞懂路由器/交换机/光猫三者概念区别

《一文带你迅速搞懂路由器/交换机/光猫三者概念区别》讨论网络设备时，常提及路由器、交换机及光猫等词汇，日常生活、工作中，这些设备至关重要，居家上网、企业内部沟通乃至互联网冲浪皆无法脱离其影响力，本文将... 当谈论网络设备时，我们常常会听到路由器、交换机和光猫这几个名词。它们是构建现代网络基础设施的关键组成
阅读更多...
redis和redission分布式锁原理及区别说明

redis和redission分布式锁原理及区别说明

《redis和redission分布式锁原理及区别说明》文章对比了synchronized、乐观锁、Redis分布式锁及Redission锁的原理与区别,指出在集群环境下synchronized失效,... 目录Redis和redission分布式锁原理及区别1、有的同伴想到了synchronized关键字
阅读更多...
MySQL CTE (Common Table Expressions)示例全解析

MySQL CTE (Common Table Expressions)示例全解析

《MySQLCTE(CommonTableExpressions)示例全解析》MySQL8.0引入CTE,支持递归查询,可创建临时命名结果集,提升复杂查询的可读性与维护性,适用于层次结构数据处... 目录基本语法CTE 主要特点非递归 CTE简单 CTE 示例多 CTE 示例递归 CTE基本递归 CTE 结
阅读更多...
MySQL 8 中的一个强大功能 JSON_TABLE示例详解

MySQL 8 中的一个强大功能 JSON_TABLE示例详解

《MySQL8中的一个强大功能JSON_TABLE示例详解》JSON_TABLE是MySQL8中引入的一个强大功能,它允许用户将JSON数据转换为关系表格式,从而可以更方便地在SQL查询中处理J... 目录基本语法示例示例查询解释应用场景不适用场景1. ‌jsON 数据结构过于复杂或动态变化‌2. ‌性能要
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2