Arrays 从数组中弹出第一个元素

我在Lua中有一个数组

x

。我想设置

head=x[1]

和

rest=

数组的其余部分，以便

rest[1]=x[2]

，

rest[2]=x[3]

，等等

我该怎么做

（注意：我不在乎原始数组是否发生了变异。在Javascript中，我将执行

head=x.shift（）

，而

x

将包含剩余的元素。）

“Pop”有点用词不当，因为它意味着一种廉价的操作，删除表的第一个元素需要重新定位其余内容——因此在JavaScript和其他一些语言中称为“shift”。

您想要：

---

正如@daurnimator所指出的，这需要在Lua运行时中底层实现数组，从而转移所有表元素。如果可以相反地向后表示数组，调用数组

头中的最后一项
，则调用
表.remove（）
将是一个廉价的弹出：

local t = {4,3,2,1}
local head = table.remove(t)
print(head)
--> 1
print( #t )
--> 3
print( t[#t] )
--> 2

或者，您可以选择将元素序列表示为。在这种情况下，从列表的开头弹出一个项目也是一种廉价的操作（但将一个项目推到末尾则不是，除非您跟踪列表中的“尾部”）：

特别注意

local head,rest = numbers.val, numbers.rest

不修改任何数据结构，只在链中的特定链接上为您提供一个
rest
句柄。
通常在Lua中，将元素x插入序列中的操作

例如：S={a，b，c，d，e，f}到S={a，b，c，x，d，e，f}

…非常耗时，因为d必须移动到索引5，e必须移动到索引6等

是否有其他形式的序列，其中S[a]=b，
S[b]=c，S[c]=d，S[d]=e和S[e]=f？这样，您只需键入：

S[c]=x
S[x]=d

在两次操作中，boom，x在c之后，在d之前。
注意，对于任何合理大小的阵列，这是一个非常缓慢的操作；尝试并重新考虑你为什么要这么做……Durnimimor你指的是“任何不合理的大小的数组”B），而不是重新考虑这一动机，而是考虑使用数组以外的数据结构。一个链表（很容易在Lua中创建）使得这是一个廉价的操作，而每个节点需要更多的存储空间。最近发现我所说的被称为“链表”。
local setm,getm = setmetatable,getmetatable
local linkedlist=setm({__index={
  tail = function(l) while l.rest do l=l.rest end return l end, -- N.B. O(n)!
  push = function(l,v,t) t=l:tail() t.rest=setm({val=v},getm(l)) return t end,
  cram = function(l,v) return setm({val=v,rest=l},getm(l)) end,
  each = function(l,v)
    return function() if l then v,l=l.val,l.rest return v end end
  end
}},{ __call=function(lmeta,v,...)
  local head,tail=setm({val=v},lmeta) tail=head
  for i,v in ipairs{...} do tail=tail:push(v) end
  return head
end })

local numbers = linkedlist(1,2,3,4)
for n in numbers:each() do print(n) end
--> 1
--> 2
--> 3
--> 4

local head,rest = numbers.val, numbers.rest
print(head)
--> 1

for n in rest:each() do print(n) end
--> 2
--> 3
--> 4

local unrest = rest:cram('99')
for n in unrest:each() do print(n) end
--> 99
--> 2
--> 3
--> 4

local head,rest = numbers.val, numbers.rest