androidlua股票數據結構

① 小白求助，安卓上怎麼運行lua腳本

在Android手機上編寫並運行Lua腳本
利用開源項目SL4A ( Scripting Layer for Android 項目地址：可以快速在Android手機上搭建各種腳本運行環境。目前SL4A支持 Python, Perl, JRuby, Lua, BeanShell, JavaScript, Tcl, shell 等腳本語言 。
1、下載並安裝SL4A運行環境
​這個應用提供了各種腳本的運行環境，通過拆APK可以看到應用內嵌了兩個.so動態鏈接庫。其中一個是ConnectBot的庫，另一個是7.9K大小的腳本執行庫，但顯然不是腳本語言解析庫。具體關於SL4A的原理，可以參考博文：《SL4A 之實現原理解析》
2、下載 Lua for android 支持lua_for_android_r1.apk
3、運行Lua for android ，它將從網路下載一些Lua腳本Demo。這些例子在SL4A中運行。

使用SL4A可以在Android手機上直接運行Lua等腳本。

② 想去網龍做lua腳本程序員可是c++主要是演算法和數據結構不好目前通過自學學會了基礎的lua，請問筆試能過嗎

lua是腳本語言，不需要你掌握c++的演算法和數據結構的，它有成熟的常用演算法和數據結構的處理，只要調用一個函數就行了。話說回來，就算你去做c++開發，也不一定非得精通演算法和數據結構。知道鏈表就足夠了。

③ Lua是什麼編程語言

Lua 是一個小巧的腳本語言。作者是巴西人。該語言的設計目的是為了嵌入應用程序中，從而為應用程序提供靈活的擴展和定製功能。它的主頁是 www.lua.org。
Lua最著名的應用是在暴雪公司的網路游戲WOW中。
Lua腳本可以很容易的被C/C++代碼調用，也可以反過來調用C/C++的函數，這使得Lua在應用程序中可以被廣泛應用。不僅僅作為擴展腳本，也可以作為普通的配置文件，代替XML,Ini等文件格式，並且更容易理解和維護。
Lua由標准C編寫而成，代碼簡潔優美，幾乎在所有操作系統和平台上都可以編譯，運行。
一個完整的Lua解釋器不過200k，在目前所有腳本引擎中，Lua的速度是最快的。這一切都決定了Lua是作為嵌入式腳本的最佳選擇。
Lua 有一個同時進行的JIT項目，提供在特定平台上的即時編譯功能，這將給Lua帶來更加優秀的性能。請訪問 http://luajit.org/來了解這個項目。
和Python等腳本不同，Lua並沒有提供強大的庫，這是由它的定位決定的。所以Lua不適合作為開發獨立應用程序的語言。不過Lua還是具備了比如數學運算和字元串處理等基本的功能。
Lua 目前的最新版本是 5.1.
1 目標
LUA的目標是成為一個很容易嵌入其它語言中使用的語言。大多數程序員也認為它的確做到了這一點。
很多應用程序使用LUA作為自己的嵌入式腳本語言，以此來實現可配置性、可擴展性。這其中包括魔獸世界、博德之門等。
2 特性
LUA有如下特性：
輕量級 LUA語言的官方版本只包括一個精簡的核心和最基本的庫。這使得LUA體積小、啟動速度快，從而適合嵌入在別的程序里。
可擴展 LUA並不象其它許多"大而全"的語言那樣，包括很多功能，比如網路通訊、圖形界面等。但是LUA可以很容易地被擴展：由宿主語言(通常是C或C++)提供這些功能，LUA可以使用它們，就像是本來就內置的功能一樣。
其它特性 LUA還具有其它一些特性：同時支持面向過程編程和面向對象編程；自動內存管理；提供一系列數據結構，包括數組、鏈表、集合、字典、散列表等；語言內置正則表達式匹配；閉包(closure)；函數也可以看做一個值；提供多線程支持；等等。

④ LUA語言入門

LUA腳本語言入門（純粹轉帖，僅供參考）
Lua 程序設計初步

作者： 沐楓 （第二人生成員）
版權所有轉載請註明原出處

在這篇文章中，我想向大家介紹如何進行Lua程序設計。我假設大家都學過至少一門編程語言，比如Basic或C，特別是C。因為Lua的最大用途是在宿主程序中作為腳本使用的。
Lua 的語法比較簡單，學習起來也比較省力，但功能卻並不弱。
在Lua中，一切都是變數，除了關鍵字。請記住這句話。

I. 首先是注釋
寫一個程序，總是少不了注釋的。
在Lua中，你可以使用單行注釋和多行注釋。
單行注釋中，連續兩個減號"--"表示注釋的開始，一直延續到行末為止。相當於C++語言中的"//"。
多行注釋中，由"--[["表示注釋開始，並且一直延續到"]]"為止。這種注釋相當於C語言中的"/*…*/"。在注釋當中，"[["和"]]"是可以嵌套的。
II. Lua編程
經典的"Hello world"的程序總是被用來開始介紹一種語言。在Lua中，寫一個這樣的程序很簡單：
print("Hello world")
在Lua中，語句之間可以用分號"；"隔開，也可以用空白隔開。一般來說，如果多個語句寫在同一行的話，建議總是用分號隔開。
Lua 有好幾種程序控制語句，如：

條件控制：if 條件 then … elseif 條件 then … else … end
While循環：while 條件 do … end
Repeat循環：repeat … until 條件
For循環：for 變數 = 初值，終點值，步進 do … end
For循環：for 變數1，變數2，… ，變數N in表或枚舉函數 do … end

注意一下，for的循環變數總是只作用於for的局部變數，你也可以省略步進值，這時候，for循環會使用1作為步進值。
你可以用break來中止一個循環。
如果你有程序設計的基礎，比如你學過Basic，C之類的，你會覺得Lua也不難。但Lua有幾個地方是明顯不同於這些程序設計語言的，所以請特別注意。

．語句塊
語句塊在C++中是用"{"和"}"括起來的，在Lua中，它是用do 和 end 括起來的。比如：
do print("Hello") end
你可以在 函數 中和 語句塊 中定局部變數。

．賦值語句
賦值語句在Lua被強化了。它可以同時給多個變數賦值。
例如：
a,b,c,d=1,2,3,4
甚至是：
a,b=b,a -- 多麼方便的交換變數功能啊。
在默認情況下，變數總是認為是全局的。假如你要定義局部變數，則在第一次賦值的時候，需要用local說明。比如：
local a,b,c = 1,2,3 -- a,b,c都是局部變數

．數值運算
和C語言一樣，支持 +, -, *, /。但Lua還多了一個"^"。這表示指數乘方運算。比如2^3 結果為8, 2^4結果為16。
連接兩個字元串，可以用".."運處符。如：
"This a " .. "string." -- 等於 "this a string"

．比較運算
< > <= >= == ~=
分別表示 小於，大於，不大於，不小於，相等，不相等
所有這些操作符總是返回true或false。
對於Table，Function和Userdata類型的數據，只有 == 和 ~=可以用。相等表示兩個變數引用的是同一個數據。比如：
a={1,2}
b=a
print(a==b, a~=b) -- true, false
a={1,2}
b={1,2}
print(a==b, a~=b) -- false, true

．邏輯運算
and, or, not
其中，and 和 or 與C語言區別特別大。
在這里，請先記住，在Lua中，只有false和nil才計算為false，其它任何數據都計算為true，0也是true！
and 和 or的運算結果不是true和false，而是和它的兩個操作數相關。
a and b：如果a為false，則返回a；否則返回b
a or b：如果 a 為true，則返回a；否則返回b

舉幾個例子：
print(4 and 5) --> 5
print(nil and 13) --> nil
print(false and 13) --> false
print(4 or 5) --> 4
print(false or 5) --> 5

在Lua中這是很有用的特性，也是比較令人混洧的特性。
我們可以模擬C語言中的語句：x = a? b : c，在Lua中，可以寫成：x = a and b or c。
最有用的語句是： x = x or v，它相當於：if not x then x = v end 。

．運算符優先順序，從高到低順序如下：
^
not - （一元運算）
* / + -
..（字元串連接）
< > <= >= ~= ==
and
or

III. 關鍵字
關鍵字是不能做為變數的。Lua的關鍵字不多，就以下幾個：
and break do else elseif
end false for function if
in local nil not or
repeat return then true until while

IV. 變數類型
怎麼確定一個變數是什麼類型的呢？大家可以用type()函數來檢查。Lua支持的類型有以下幾種：

Nil 空值，所有沒有使用過的變數，都是nil。nil既是值，又是類型。
Boolean 布爾值
Number 數值，在Lua里，數值相當於C語言的double
String 字元串，如果你願意的話，字元串是可以包含'\0'字元的
Table 關系表類型，這個類型功能比較強大，我們在後面慢慢說。
Function 函數類型，不要懷疑，函數也是一種類型，也就是說，所有的函數，它本身就是一個變數。
Userdata 嗯，這個類型專門用來和Lua的宿主打交道的。宿主通常是用C和C++來編寫的，在這種情況下，Userdata可以是宿主的任意數據類型，常用的有Struct和指針。
Thread 線程類型，在Lua中沒有真正的線程。Lua中可以將一個函數分成幾部份運行。如果感興趣的話，可以去看看Lua的文檔。

V. 變數的定義
所有的語言，都要用到變數。在Lua中，不管你在什麼地方使用變數，都不需要聲明，並且所有的這些變數總是全局變數，除非，你在前面加上"local"。
這一點要特別注意，因為你可能想在函數里使用局部變數，卻忘了用local來說明。
至於變數名字，它是大小寫相關的。也就是說，A和a是兩個不同的變數。
定義一個變數的方法就是賦值。"＝"操作就是用來賦值的
我們一起來定義幾種常用類型的變數吧。
A. Nil
正如前面所說的，沒有使用過的變數的值，都是Nil。有時候我們也需要將一個變數清除，這時候，我們可以直接給變數賦以nil值。如：
var1=nil -- 請注意 nil 一定要小寫

B. Boolean
布爾值通常是用在進行條件判斷的時候。布爾值有兩種：true 和 false。在Lua中，只有false和nil才被計算為false，而所有任何其它類型的值，都是true。比如0，空串等等，都是true。不要被 C語言的習慣所誤導，0在Lua中的的確確是true。你也可以直接給一個變數賦以Boolean類型的值，如：
varboolean = true

C. Number
在Lua中，是沒有整數類型的，也不需要。一般情況下，只要數值不是很大（比如不超過100,000,000,000,000），是不會產生舍入誤差的。在很多CPU上，實數的運算並不比整數慢。
實數的表示方法，同C語言類似，如：
4 0.4 4.57e-3 0.3e12 5e+20

D. String
字元串，總是一種非常常用的高級類型。在Lua中，你可以非常方便的定義很長很長的字元串。
字元串在Lua中有幾種方法來表示，最通用的方法，是用雙引號或單引號來括起一個字元串的，如：
"This is a string."
和C語言相同的，它支持一些轉義字元，列表如下：
\a bell
\b back space
\f form feed
\n newline
\r carriage return
\t horizontal tab
\v vertical tab
\\ backslash
\" double quote
\' single quote
\[ left square bracket
\] right square bracket

由於這種字元串只能寫在一行中，因此，不可避免的要用到轉義字元。加入了轉義字元的串，看起來實在是不敢恭維，比如：
"one line\nnext line\n\"in quotes\", 'in quotes'"
一大堆的"\"符號讓人看起來很倒胃口。如果你與我有同感，那麼，我們在Lua中，可以用另一種表示方法：用"[["和"]]"將多行的字元串括起來，如：
page = [[
<HTML>
<HEAD>
<TITLE>An HTML Page</TITLE>
</HEAD>
<BODY>
<A HREF="http://www.lua.org">Lua</A>
[[a text between double brackets]]
</BODY>
</HTML>
]]

值得注意的是，在這種字元串中，如果含有單獨使用的"[["或"]]"就仍然得用"\["或"\]"來避免歧義。當然，這種情況是極少會發生的。

E. Table
關系表類型，這是一個很強大的類型。我們可以把這個類型看作是一個數組。只是C語言的數組，只能用正整數來作索引；在Lua中，你可以用任意類型來作數組的索引，除了nil。同樣，在C語言中，數組的內容只允許一種類型；在Lua中，你也可以用任意類型的值來作數組的內容，除了nil。
Table的定義很簡單，它的主要特徵是用"{"和"}"來括起一系列數據元素的。比如：

T1 = {} -- 定義一個空表
T1[1]=10 -- 然後我們就可以象C語言一樣來使用它了。
T1["John"]={Age=27, Gender="Male"}
這一句相當於：
T1["John"]={} -- 必須先定義成一個表，還記得未定義的變數是nil類型嗎
T1["John"]["Age"]=27
T1["John"]["Gender"]="Male"
當表的索引是字元串的時候，我們可以簡寫成：
T1.John={}
T1.John.Age=27
T1.John.Gender="Male"
或
T1.John{Age=27, Gender="Male"}
這是一個很強的特性。

在定義表的時候，我們可以把所有的數據內容一起寫在"{"和"}"之間，這樣子是非常方便，而且很好看。比如，前面的T1的定義，我們可以這么寫：

T1=
{
10, -- 相當於 [1] = 10
[100] = 40,
John= -- 如果你原意，你還可以寫成：["John"] =
{
Age=27, -- 如果你原意，你還可以寫成：["Age"] =27
Gender=Male -- 如果你原意，你還可以寫成：["Gender"] =Male
},
20 -- 相當於 [2] = 20
}

看起來很漂亮，不是嗎？我們在寫的時候，需要注意三點：
第一，所有元素之間，總是用逗號"，"隔開；
第二，所有索引值都需要用"["和"]"括起來；如果是字元串，還可以去掉引號和中括弧；
第三，如果不寫索引，則索引就會被認為是數字，並按順序自動從1往後編；

表類型的構造是如此的方便，以致於常常被人用來代替配置文件。是的，不用懷疑，它比ini文件要漂亮，並且強大的多。

F. Function
函數，在Lua中，函數的定義也很簡單。典型的定義如下：
function add(a,b) -- add 是函數名字，a和b是參數名字
return a+b -- return 用來返回函數的運行結果
end

請注意，return語言一定要寫在end之前。假如你非要在中間放上一句return，那麼請寫成：do return end。
還記得前面說過，函數也是變數類型嗎？上面的函數定義，其實相當於：
add = function (a,b) return a+b end
當你重新給add賦值時，它就不再表示這個函數了。你甚至可以賦給add任意數據，包括nil （這樣，你就清除了add變數）。Function是不是很象C語言的函數指針呢？

和C語言一樣，Lua的函數可以接受可變參數個數，它同樣是用"…"來定義的，比如：
function sum (a,b,…)
如果想取得…所代表的參數，可以在函數中訪問arg局部變數（表類型）得到。
如 sum(1,2,3,4)
則，在函數中，a = 1, b = 2, arg = {3, 4}
更可貴的是，它可以同時返回多個結果，比如：
function s()
return 1,2,3,4
end
a,b,c,d = s() -- 此時，a = 1, b = 2, c = 3, d = 4
前面說過，表類型可以擁有任意類型的值，包括函數！因此，有一個很強大的特性是，擁有函數的表，哦，我想更恰當的應該說是對象吧。Lua可以使用面向對象編程了。不信？那我舉例如下：

t =
{
Age = 27
add = function(self, n) self.Age = self.Age+n end
}
print(t.Age) -- 27
t.add(t, 10)
print(t.Age) -- 37

不過，t.add(t,10) 這一句實在是有點土對吧？沒關系，在Lua中，你可以簡寫成：
t:add(10) -- 相當於 t.add(t,10)

G. Userdata 和 Thread
這兩個類型的話題，超出了本文的內容，就不打算細說了。

VI. 結束語
就這么結束了嗎？當然不是，接下來，需要用Lua解釋器，來幫助你理解和實踐了。這篇小文只是幫助你大體了解Lua的語法。如果你有編程基礎，相信會很快對Lua上手了。
就象C語言一樣，Lua提供了相當多的標准函數來增強語言的功能。使用這些標准函數，你可以很方便的操作各種數據類型，並處理輸入輸出。有關這方面的信息，你可以參考《Programming in Lua 》一書，你可以在網路上直接觀看電子版，網址為：http://www.lua.org/pil/index.html

使用常式
1. 函數的使用
以下程序演示了如何在Lua中使用函數, 及局部變數
例e02.lua
-- functions
function pythagorean(a, b)
local c2 = a^2 + b^2
return sqrt(c2)
end
print(pythagorean(3,4))

運行結果
5

程序說明
在Lua中函數的定義格式為:
function 函數名(參數)
...
end
與Pascal語言不同, end不需要與begin配對, 只需要在函數結束後打個end就可以了.
本例函數的作用是已知直角三角形直角邊, 求斜邊長度. 參數a,b分別表示直角邊長,
在函數內定義了local形變數用於存儲斜邊的平方. 與C語言相同, 定義在函數內的代
碼不會被直接執行, 只有主程序調用時才會被執行.
local表示定義一個局部變數, 如果不加local剛表示c2為一個全局變數, local的作用域
是在最里層的end和其配對的關鍵字之間, 如if ... end, while ... end等。全局變數的
作用域是整個程序。

2. 循環語句
例e03.lua
-- Loops
for i=1,5 do
print("i is now " .. i)
end

運行結果
i is now 1
i is now 2
i is now 3
i is now 4
i is now 5

程序說明
這里偶們用到了for語句
for 變數 = 參數1, 參數2, 參數3 do
循環體
end
變數將以參數3為步長, 由參數1變化到參數2
例如:
for i=1,f(x) do print(i) end
for i=10,1,-1 do print(i) end

這里print("i is now " .. i)中，偶們用到了..，這是用來連接兩個字元串的，
偶在(1)的試試看中提到的，不知道你們答對了沒有。
雖然這里i是一個整型量，Lua在處理的時候會自動轉成字元串型，不需偶們費心。

3. 條件分支語句
例e04.lua
-- Loops and conditionals
for i=1,5 do
print(「i is now 「 .. i)
if i < 2 then
print(「small」)
elseif i < 4 then
print(「medium」)
else
print(「big」)
end
end

運行結果
i is now 1
small
i is now 2
medium
i is now 3
medium
i is now 4
big
i is now 5
big

程序說明
if else用法比較簡單, 類似於C語言, 不過此處需要注意的是整個if只需要一個end,
哪怕用了多個elseif, 也是一個end.
例如
if op == "+" then
r = a + b
elseif op == "-" then
r = a - b
elseif op == "*" then
r = a*b
elseif op == "/" then
r = a/b
else
error("invalid operation")
end

數組的使用
1.簡介
Lua語言只有一種基本數據結構, 那就是table, 所有其他數據結構如數組啦,
類啦, 都可以由table實現.

2.table的下標
例e05.lua
-- Arrays
myData = {}
myData[0] = 「foo」
myData[1] = 42

-- Hash tables
myData[「bar」] = 「baz」

-- Iterate through the
-- structure
for key, value in myData do
print(key .. 「=「 .. value)
end

輸出結果
0=foo
1=42
bar=baz

程序說明
首先定義了一個table myData={}, 然後用數字作為下標賦了兩個值給它. 這種
定義方法類似於C中的數組, 但與數組不同的是, 每個數組元素不需要為相同類型,
就像本例中一個為整型, 一個為字元串.

程序第二部分, 以字元串做為下標, 又向table內增加了一個元素. 這種table非常
像STL裡面的map. table下標可以為Lua所支持的任意基本類型, 除了nil值以外.

Lua對Table佔用內存的處理是自動的, 如下面這段代碼
a = {}
a["x"] = 10
b = a -- `b' refers to the same table as `a'
print(b["x"]) --> 10
b["x"] = 20
print(a["x"]) --> 20
a = nil -- now only `b' still refers to the table
b = nil -- now there are no references left to the table
b和a都指向相同的table, 只佔用一塊內存, 當執行到a = nil時, b仍然指向table,
而當執行到b=nil時, 因為沒有指向table的變數了, 所以Lua會自動釋放table所佔內存

3.Table的嵌套
Table的使用還可以嵌套，如下例
例e06.lua
-- Table 『constructor』
myPolygon = {
color=「blue」,
thickness=2,
npoints=4;
{x=0, y=0},
{x=-10, y=0},
{x=-5, y=4},
{x=0, y=4}
}

-- Print the color
print(myPolygon[「color」])

-- Print it again using dot
-- notation
print(myPolygon.color)

-- The points are accessible
-- in myPolygon[1] to myPolygon[4]

-- Print the second point』s x
-- coordinate
print(myPolygon[2].x)

程序說明
首先建立一個table, 與上一例不同的是，在table的constructor裡面有{x=0,y=0},
這是什麼意思呢？ 這其實就是一個小table, 定義在了大table之內, 小table的
table名省略了.
最後一行myPolygon[2].x，就是大table裡面小table的訪問方式.

⑤ android lua 可以做什麼

這是沒辦法的 lua只是腳本,涉及到的東西太多 一般lua只負責一些功能的實現 實際的流程是在宿主語言中實現 所以光有lua腳本其實還是無法打包的

⑥ Lua 是怎樣一門語言

Lua是一個簡潔、輕量、可擴展的腳本語言。Lua有著相對簡單的CAPI而很容易嵌入應用中。很多應用程序使用Lua作為自己的嵌入式腳本語言，以此來實現可配置性、可擴展性。

Lua是一種輕量語言，它的官方版本只包括一個精簡的核心和最基本的庫。這使得Lua體積小、啟動速度快。

它用ANSI C語言編寫，並以源代碼形式開放，編譯後的完整參考解釋器只有大約247kB，到5.4.3版本，該體積變成283kB（Linux,amd64），依然非常小巧，可以很方便的嵌入別的程序里。和許多「大而全」的語言不一樣，網路通信、圖形界面等都沒有默認提供。

但是Lua可以很容易地被擴展：由宿主語言（通常是C或C++）提供這些功能，Lua可以使用它們，就像是本來就內置的功能一樣。事實上，現在已經有很多成熟的擴展模塊可供選用。

Lua是一個動態類型語言，支持增量式垃圾收集策略。有內建的，與操作系統無關的協作式多線程支持。Lua原生支持的數據類型很少，只提供了數值（默認是雙精度浮點數，可配置）、布爾量、字元串、表格、函數、線程以及用戶自定義數據這幾種。

但是其處理表和字元串的效率非常之高，加上元表的支持，開發者可以高效的模擬出需要的復雜數據類型（比如集合、數組等）。

Lua是一種多重編程范型的程序設計語言：它只提供了很小的一個特性集合來滿足不同編程范型的需要，而不是為某種特定的編程范型提供繁雜的特性支持。

例如，Lua並不提供繼承這個特性，但是你可以用元表格來模擬它。諸如名字空間、類這些概念都沒有在語言基本特性中實現，但是我們可以用表格結構（Lua唯一提供的復雜數據結構）輕易模擬。正是提供了這些基本的元特性，我們可以任意的對語言進行自需的改造。

Lua實現了少量的高級特徵比如頭等函數、垃圾回收、閉包、正當尾調用、強制（於運行時間在字元串和數值之間自動轉換）、協程（協作多任務）和動態模塊裝載。

實現

Lua程序不是從文本式的Lua文件直接解釋的，而是編譯成位元組碼，接著把它運行在Lua虛擬機上。編譯過程典型的對於用戶是不可見並且是在運行時間進行的，但是它可以離線完成用來增加裝載性能或通過排除編譯器來減少對宿主環境的內存佔用。

Lua位元組碼還可以在Lua之內產生和執行，使用來自字元串庫的mp函數和load/loadstring/loadfile函數。Lua版本5.3.4是用大約24,000行C代碼實現的。

像大多數CPU，而不像多數虛擬機（它們是基於堆棧的），Lua VM是基於寄存器的，因此更加類似真實的硬體設計。寄存器架構既避免了過多的值復制又減少了每函數的指令的總數。Lua 5的虛擬機是第一個廣泛使用的基於寄存器的純VM。

Parrot和Android的Dalvik是另外兩個周知的基於寄存器的VM。PCScheme的VM也是基於寄存器的。

⑦ Lua能夠用來定義數據結構嘛

lua 內用 table

Monster={
name=nil,
hp=nil
}

Monster.name='怪物名稱'
Monster.hp=10000

如果是定義類的話，也是table，只是方法有些不一樣
TMonster={
name=nil,
hp=nil
}
TMonster.__index=TMonster
--創建類
TMonster.new=function()
localself={}
setmetatable(self,TMonster)
self.name=nil
self.hp=nil
returnself
end
--類函數
TMonster.setSetting=function(self,szName,nHp)
self.name=szName
self.hp=nHp
end

------------------------------
這樣就可以使用了
Monster=TMonster.new()
Monster:setSetting('怪物名稱',10000)

⑧ 有人搞過安卓下lua的擴展庫嗎成功了嗎

很久之前，我寫了一個小教程，可以順利地在android里使用lua~
但是，有個問題，就是，如果用LdoFile函數來讀取lua腳本，就會一直找不到路徑。
目前，我找到了一個可解燃眉之急的辦法，當然喇，網上已經有這種方法了，我稍微整理一下。
首先，請確認你已經能夠成功地在android上使用lua腳本，否則，你可以看看這篇文章：
[小教程]解決android中加入Lua腳本後安裝APK報錯的問題。 （置頂的日誌）
好，開始。
1.創建android項目，在asset資源文件夾下創建一個lua文件夾
2.新建一個lua文件，放到 asset\lua目錄下，如asset\lua\hello.lua。注意咯，我們要把lua文件放到asset目錄，很重要~
--文件名：hello.lua
--一個簡單的函數，計算兩個數相加
function plus(a, b)
return a b;
end
--一個稍微不太簡單的簡單的函數，參數是一個Java對象，函數內容是調用Java對象value的函數
function heihei(value)
value:inc();
value:inc();
return value;
end 3.理論上，使用L.LdoFile("asset/lua/hello.lua");就可以載入lua文件了，但是實際上載入不成功（為什麼？我暫時還不知道，要麼等我變強，要麼你去變強，然後告訴我，嘻嘻~）
4.吶，凡事呢，都有解決的辦法，咱們用L.LdoString()函數來代替LdoFile()好不好？~好~！
5.怎麼代替呢？對了~聰明的你猜對了~把hello.lua文件用IO流讀取出來，然後保存到字元串里，然後就可以調用LdoString()函數了~
6.Java代碼如下：
public class HelloLuaActivity extends Activity {
private final String TAG ="HelloLuaActivity";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
TextV

⑨ 請問BARSLAST函數是怎麼定義的

barslast
代表上一次條件成立到當前的周期數
自身不是未來函數。
{如果回答滿意，請記得給採納}

⑩ Lua 中怎麼變換數據類型

LUA數據轉換問題:

在LUA裡面所以的數據類型都會內部轉化為double型，如果需要顯示一個double型可以這樣做:

LUA:

local num=3.14;

printf(totring num)。

當Lua通過call或 pcall函數執行Redis命令的時候，命令的返回值會被轉換成Lua數據結構。 同樣地，當Lua腳本在Redis內置的解釋器里運行時，Lua 腳本的返回值也會被轉換成Redis協議(protocol)，然後由EVAL將值返回給客戶端。

數據類型之間轉換遵循這樣一個設計原則：如果將一個Redis值轉換成Lua值，之後再將轉換所得的Lua值轉換回Redis值，那麼這個轉換所得的Redis值應該和最初時的Redis值一樣。

換句話說，Lua類型和Redis類型之間存在著一一對應的轉換關系。

lua中整數和浮點數之間沒有什麼區別。因此，我們始終Lua的數字轉換成整數的回復，這樣將捨去小數部分。如果你想從Lua返回一個浮點數，你應該將它作為一個字元串（見比如ZSCORE命令）。

There is no simple way to have nils inside Lua arrays, this is a result of Lua table semantics, so when Redis converts a Lua array into Redis protocol the conversion is stopped if a nil is encountered.

Lua是動態類型語言，所以變數沒有類型，僅值有類型。值可以被存儲在變數中，作為參數傳遞，並作為結果返回。

在Lua中雖然沒有變數的數據類型，但有類型的值。