Lua的模塊編寫與module函數



1.編寫一個簡單的模塊

Lua的模塊是什麼東西呢？通常我們可以理解爲是一個table，這個table裏有一些變量、一些函數…

等等，這不就是我們所熟悉的類嗎？

沒錯，和類很像（實際上我說不出它們的區別）。

 

我們來看看一個簡單的模塊，新建一個文件，命名爲game.lua，代碼如下：

1. game = {}
3. function game.play()
4.     print("那麼，開始吧");
5. end
7. function game.quit()
8.     print("你走吧，我保證你不會出事的，呵，呵呵");
9. end
11. return game;

我們定義了一個table，並且給這個table加了兩個字段，只不過這兩個字段的值是函數而已。

至於如何使用模塊，那就要用到我們之前介紹過的require了。

 

我們在main函數裏這麼使用：

1. local function main()
2.     cc.FileUtils:getInstance():addSearchPath("src")
4.     game = require("game");
5.    
6.     game.play();
8. end

注意，我們要require其他文件的時候，要把文件路徑給設置好，否則會找不到文件。

因爲我使用的是Cocos Code IDE，直接調用addSearchPath函數就可以了，我的game.lua文件是在src目錄下的。

 

好了，運行代碼，結果如下：

[LUA-print] 那麼，開始吧

 

OK，這就是一個很簡單的模塊，如果我們習慣了Java、C++等面嚮對象語言，那也可以簡單地把模塊理解爲類。

 

2.爲以後的自己偷懶——避免修改每個函數中的模塊名

假設我們想把剛剛的game模塊改個名字，改成eatDaddyGame，那麼，我們需要做以下兩件事情：

1).修改game.lua的文件名

2).修改game.lua的內容，把所有的game改成eatDaddyGame

 

目前的game.lua函數還算少，就兩個，實際上一個模塊的函數肯定不會少的，那麼，要這麼去改這些函數，太煩了。

如果批量修改，又怕有哪個地方改錯。

於是，我們可以這麼偷懶：

1. game = {}
3. local M = game;
5. function M.play()
6.     print("那麼，開始吧");
7. end
9. function M.quit()
10.     print("你走吧，我保證你不會出事的，呵，呵呵");
11. end
13. return M;

我們用一個局部變量M來代替了game，於是，以後我們只需要修改前面兩個的game就可以了，函數部分的內容完全不需要去修改。

這個偷懶其實蠻有用的，某些情況下，修改越少，越安全~

 

3.更進一步的偷懶——模塊名參數

實際上，我們可以更加得偷懶，以後修改模塊名，只需要修改模塊的文件名就可以了，文件內容可以不管，具體怎麼實現？

看代碼：

1. local M = {};
3. local modelName = ...;
4. _G[modelName] = M;
6. function M.play()
7.     print("那麼，開始吧");
8. end
10. function M.quit()
11.     print("你走吧，我保證你不會出事的，呵，呵呵");
12. end
14. return M;

留意一下，這裏有一個 local modelName = …

“…”就是傳遞給模塊的模塊名，在這裏其實就是“game”這個字符串。

 

接着，有點微妙了，還記得之前介紹的全局環境_G嗎？我們以”game”作爲字段名，添加到_G這個table裏。

於是，當我們直接調用game的時候，其實就是在調用_G[“game”]的內容了，而這個內容就是這裏的M。

 

能邏輯過來嗎？就是這麼簡單，在你沒有忘記_G的前提下~

 

4.利用非全局環境製作更簡潔和安全的模塊

如果說，剛剛已經達到了我們作爲高(ai)智(zhe)商(teng)人羣的巔峯，那，你就太天真了。

巔峯就是要拿來超越的，還記得我們的非全局環境嗎？就是那個setfenv函數。

 

我們來看看下面的代碼：

1. local M = {};
3. local modelName = ...;
4. _G[modelName] = M;
6. setfenv(1, M);
8. function play()
9.     print("那麼，開始吧");
10. end
12. function quit()
13.     print("你走吧，我保證你不會出事的，呵，呵呵");
14. end
16. return M;

我們把game.lua這個模塊裏的全局環境設置爲M，於是，我們直接定義函數的時候，不需要再帶M前綴。

因爲此時的全局環境就是M，不帶前綴去定義變量，就是全局變量，這時的全局變量是保存在M裏。

所以，實際上，play和quit函數仍然是在M這個table裏。

 

於是，我們連前綴都不用寫了，這真是懶到了一個極致，簡直就是藝術~

另外，由於當前的全局環境是M，所以， 在這裏不需要擔心重新定義了已存在的函數名，因爲外部的全局變量與這裏無關了。

 

當然，如果大家現在就運行代碼，肯定會報錯了。

因爲我們的全局環境改變了，所以print函數也找不到了。

爲了解決這個問題，我們看看第5條內容吧~

 

5.解決原全局變量的無法找到的問題——方案1

第一個方法，就是我們之前介紹過的，使用繼承，如下代碼：

1. local M = {};
3. local modelName = ...;
4. _G[modelName] = M;
6. -- 方法1：使用繼承
7. setmetatable(M, {__index = _G});
9. setfenv(1, M);
11. function play()
12.     print("那麼，開始吧");
13. end
15. function quit()
16.     print("你走吧，我保證你不會出事的，呵，呵呵");
17. end
19. return M;

沒錯，使用__index元方法就能解決這個問題了，當找不到print等函數時，就會去原來的_G裏查找。

 

6.解決原全局變量的無法找到的問題——方案2

第二個方法更簡單，使用一個局部變量把原來的_G保存起來，如下代碼：

1. local M = {};
3. local modelName = ...;
4. _G[modelName] = M;
6. -- 方法2：使用局部變量保存_G
7. local _G = _G;
9. setfenv(1, M);
11. function play()
12.     _G.print("那麼，開始吧");
13. end
15. function quit()
16.     _G.print("你走吧，我保證你不會出事的，呵，呵呵");
17. end
19. return M;

這種方法的缺點比較明顯，那就是，每次調用print等函數時，都要使用_G前綴。

 

7.解決原全局變量的無法找到的問題——方案3

第三個方法比較繁瑣，使用局部變量把需要用到的其他模塊保存起來，如下代碼：

1. local M = {};
3. local modelName = ...;
4. _G[modelName] = M;
6. -- 方法3：保存需要使用到的模塊
7. local print = print;
9. setfenv(1, M);
11. function play()
12.     print("那麼，開始吧");
13. end
15. function quit()
16.     print("你走吧，我保證你不會出事的，呵，呵呵");
17. end
19. return M;

這種方法的缺點更明顯了，所有用到的模塊都要用局部變量聲明一次，煩人。

 

但，就速度而言，第三種方案比第二種方案快，第二種方法又比第一種快。

但至於快多少，我也不知道，只是理論上~我也沒測試。

 

8.你就笑吧，但，我還想更加偷懶——module函數

本以爲剛剛介紹的那些技巧已經夠偷懶的吧？

但Lua似乎知道我們有多懶似的，它竟然把我們把這一切都自動完成了。

再來回憶我們剛剛爲了偷懶而寫的幾句代碼：

1. local M = {};
3. local modelName = ...;
4. _G[modelName] = M;
5. setmetatable(M, {__index = _G});
6. setfenv(1, M);

就這幾句代碼，其實我們可以忽略不寫，因爲，我們有module函數，它的功能就相當於寫了這些代碼。

我們修改一下game.lua的內容，如下代碼：

1. module(..., package.seeall);
3. function play()
4.     print("那麼，開始吧");
5. end
7. function quit()
8.     print("你走吧，我保證你不會出事的，呵，呵呵");
9. end

注意，前面的幾行代碼都沒了，只留下了一個module函數的調用。

module函數的調用已經相當於之前的那些代碼了。

而package.seeall參數的作用就是讓原來的_G依然生效，相當於調用了：setmetatable(M, {__index = _G});

 

再次留意一下，代碼末尾的return M也不見了，因爲module函數的存在，已經不需要我們主動去返回這個模塊的table