lua學習之類型與值篇

時間 2020-02-12

標籤 lua 學習類型欄目 Lua 简体版

原文原文鏈接

類型與值

lua 是動態類型的語言

在語言中沒有類型定義的語法
每一個值都攜帶有它的類型信息

8種基礎類型

用 type 能夠返回這個值的類型的名稱
將一個變量用於不一樣類型，一般會致使混亂的代碼
但合理使用，如異常狀況下返回 nil ，以區別正常狀況下的其餘類型的返回值
變量沒有預約義的類型，任何變量均可以包含任何類型的值

print(type("Hello")) --string
print(type(666)) --number
a = print
print(type(a)) --function
a = 111
print(type(a)) --number
print(type(b)) --nil
print(type(string))  -- table 不太懂爲何
print(type(type(X))) -- string

最後一行將永遠返回將永遠返回 "string" , 而無關乎 X 這個值的內容。這是由於 type 函數老是返回一個字符串

nil （空）

nil 類型只有一個值，表示空
主要功能是區別其餘任何值
一個全局變量在它第一次賦值以前它的默認值就是 nil
將 nil 賦給一個全局變量等同於刪除這個變量
lua 將 nil 用於表示一種 "無效值"的狀況，即沒有任何有效值的狀況

boolean （布爾）

布爾類型有兩個可選值，html
1. 一個是 true，一個是 false
2. true 表示真， false 表示假
boolean 不是條件值的惟一表達方式
在 lua 中任何值均可以用來表示條件
lua 將值 false , nil 視爲假。將除此以外的其餘值視爲真
lua 在條件測試中數字 0 和空字符串都視爲真

number （數字）

lua 中用於表示實數，即雙精度浮點數
lua 沒有整數類型
能夠從新編譯 lua ，使用其餘類型來表示數字
如使用長整型 long 表示數字，或單精度浮點數 float 表示數字
書寫一個數值常量，可使用普通寫法或科學計數法

科學計數法

在計算機中用 e 或 E 表示 ,表示10的幾回方
能夠簡單理解爲e 後面是多少就挪幾個0

a = 3.2e2
print(a) --320

string （字符串）

lua 中的字符串一般表示爲一個字符序列
lua 採用8位編碼
lua 字符串中的字符能夠具備任何數值編碼包括數值0
這種特性：可讓咱們將任意進制(如二進制)，存儲到字符串中
lua 中的字符串是不可變的值，不能像 C 語言那樣能夠直接修改一個字符串中的某個字符
而是應該根據修改要求創建一個新的字符串

修改子串

a = "one string"
b = string.gsub(a, "one", "another")  -- 字符串替換函數
print(b) -- another string
print(a) -- one string

lua 中的字符串和其餘的 lua 對象如 table, function 同樣都是自動內存管理機制所保存的對象
這意味着咱們無需擔憂字符串的分配和釋放
字符串能夠是一個字母也能夠是一本書的全部字符
lua 能夠高效處理長字符串，如100k ，1M容量的字符串

字面字符串

須要用一對匹配的單引號或者雙引號來包裹
若是字符串自己包含兩種引號中的一種，咱們可使用另外一種引號來包裹
也可使用來進行轉義

a = 'Hello'
b = "World"
c = "I'm a student"
d = "I\'m a student'"

轉義序列

a 響鈴
b 退格
f 提供表格
n 換行
\' 單引號
\" 雙引號
t 水平tab
v 垂直 tab
\ 反斜槓
r 回車

print("one line\nnext line\"in quotes\",'in quotes'")
--[[
one line
next line
"in quotes",'in quotes'
--]]

能夠經過數值指定字符串中的字符

數值轉義序列 \<XXX>
<xxx>是一個至多三個十進制數字組成的序列

print('a' == '\97') -- true

用一對方括號 [[]] 能夠包裹多行字符串數組
1. lua 就不會解釋其中的轉義序列
2. 如輸入 html 代碼

page = [[
    <html>
        <head>
            <title>Lua Study</title>
        </head>
        <body>
            <a href="http://www.lua.org">Lua 學習 </a>
        </body>
    </html>
]]

lua 提供了運行時數字和字符串的自動轉換

print("10" + 1)  --字符串10會被自動轉換爲數字10，結果打印爲11
print("Hello" + 1) -- 會報錯

字符串鏈接符 ..

可在多個字符串之間使用 .. 用以鏈接字符串
當在一個數字後輸入它時，必須使用一個空格分割，否則 lua 會誤解第一個點爲小數點

print("A".."=".."B") -- A=B
print(10..24) -- 會報錯
print(10 .. 24) -- 1024

長度操做符 #

可在字符串前放置 # 用以獲取這個字符串的長度

print(#"Hello") -- 5

tonumber

將字符串顯式地轉換爲數字

line = io.read() -- 讀取一行
n = tonumber(line)
if n = nil then
    error(line .. " is not a valid number")
else
    print(n * 2)    
end

tostring

將一個數字轉換成字符串
也可將數字與一個空字符串用字符串鏈接符 .. 鏈接

a  = 2333
print(tostring(2333) == "2333") -- true
print(a .. "" == "2333") -- true

table （表）

lua 中的 table 類型實現了關聯數組安全
1. 關聯數組就是具備特殊索引方式的數組
可使用整數、字符串或其餘類型的值(除了 nil)來作爲索引
table 沒有固定大小，能夠動態的添加元素到一個 table 中
table 是 lua 中主要的也是僅有的數據結構機制
基於 table 能夠簡單、統一和高效的方式表示普通數組、符號表、集合、記錄、隊列和其餘數據結構
lua 經過 table 來表示模塊、包和對象的

舉例: io.read

io 模塊中的 read 函數
使用字符串 read 做爲 key 來索引 table io

在 lua 中 table 既不是值也不是變量，而是對象
可將 table 想象爲一個動態分配的對象
程序僅持有對他們的一個引用（或指針）
lua 不會暗中產生 table 的副本，或者建立新的 table

在 lua 中不須要聲明一個 table

table 的建立是經過構造表達式來完成的
{} 一對這樣的大括號就稱之爲 table 的構造表達式

a = {} -- 建立了一個 Table 把它的引用存儲到 a 這個變量裏，那麼 a 就是一個 table 類型的變量了
k = "x"  
a[k] = 10 -- 新條目， key = x, value = 10  在 a 這個 table 添加了一個元素，這個 table 的索引是字符串索引，這個新生成的條目的值就是 10，它的索引是 x
a[20] = "great" -- 新條目， key = 20, value = "great"
print(a["x"]) -- 10
k = 20 
print(a[k]) -- great
a["x"] = a["x"] + 1
print(a["x"]) -- 11

table 永遠是匿名的

一個只有 table 的變量和 table 自身之間沒有固定的關係

a = {}
a["x"] = 10
b = a -- b 與 a 引用了一樣一個 table 
print(b["x"]) -- 10
a = nil
print(a["x"]) --報錯
print(b["x"]) --10  由於如今只有 b 在引用 table ，而 a 已經清除了對 table 的引用
b = nil -- 如今 a 和 b 都沒有對 table 引用了

在 lua 中當一個程序在沒有對 table 進行引用的時候，這個 table 就會被垃圾回收器給刪除掉，而且釋放它的內存

全部 table 均可以經過不一樣類型的索引來訪問它的值

當須要添加新的元素的時候，table 會自動的增加
若是 table 中的某個值未被初始化的時候，那它就是 nil
能夠經過給 table 中的某個元素賦值 nil 來刪除它
由於 lua 將全局變量存儲在一個普通的 table 種

-- for 循環 ,索引從1開始，與C或其餘語言從0開始不一樣, do 裏面的代碼塊是循環體
t = {}
for i = 1, 1000 do 
    t[i] = 2 * i  -- 值是索引的兩倍
end
print(t[8]) -- 16
t["x"] = 10 
print(t["x"]) --10
print(t["y"]) -- nil
t["x"] = nil -- 刪除了 table 中索引爲 x 的元素

lua table 訪問的兩種寫法(語法糖)

a["name"]
a.name
這兩種寫法是等效的
a.name 的寫法可能暗示了代碼讀者將 table 當作了一條記錄使用數據結構
1. 每一個記錄都有一組固定的預約義的鍵 key
a["name"]的寫法可能暗示了代碼讀者該 table 能夠以任何字符串做爲 key函數
1. 而如今出於某些緣由是須要訪問某個特定的 key

a.x  --  表示爲 a["x"] 以字符串 x 爲索引 table
a[x] -- 以變量 x 的 值 爲索引 table

a = {}
x = "y"    -- x 已經被賦值爲"y" 因此變量 x 的值爲字符串 y ，索引 x 變量就是索引字符串 y
a[x] = 10
print(a.x)  -- 索引爲字符串 x --> nil
print(a["x"]) -- 索引爲字符串 x --> nil
print(a[x])  -- 索引爲變量 x --> 10
print("\n")
print(a.y) -- 索引爲字符串 y --> 10
print(a["y"]) -- 索引爲字符串 y --> 10
print(a[y])  -- 索引爲變量 y --> nil

表示傳統的數組或線性表

只須要 key 爲整數便可
並不須要聲明一個大小值，直接初始化元素就能夠
數組一般以 1 做爲索引的起始值

長度操做符 # 對於 table 的做用

用於返回一個數組或一個線性表的最後一個的索引值(或者稱爲大小)

t = {}
for i = 1, i = 666 do
    t[i] = i * 2
end
print(#t) -- 666, 至關於這個 table 有 666 個元素(或者稱這個 table 的大小爲 666)
for i = 1, #t do
    print(t[i])
end
print(t[#t]) -- 打印 table 最後一個值
t[#t] = nil -- 刪除 table 的最後一個值
print(#t) -- 如今 table 的長度就是 665 個
t[#t + 1] = 8888 -- 給 table 再加一個元素
print(#t) -- 如今 table 的長度是 666 個
print(t[#t]) -- 如今 table 的最後一個元素就是 8888 了

數組的實際大小

對於全部未初始化的元素的索引結果都是 nil
lua 將 nil 做爲判斷數組結尾的標誌
當一個數組有空隙即中間含有 nil 時，長度操做符會認爲這些 nil 元素就是結尾標記
注意：避免對含有空隙的使用長度操做符，可使用 table.maxn，它返回一個 table 的最大正索引數

a = {}
a[10000] = 1
print(#a) -- 0
print(a[10000]) -- 1
print(table.maxn(a)) --> 10000

對於索引類型不明確時進行顯式轉換

使用 tonumber() 函數能夠顯式的轉換爲整數格式

i = 10
j = "10"
k = "+10"
t = {}
t[i] = "one value"
t[j] = "another value"
t[k] = "yet another value"
print(t[i]) -- one value
print(t[j]) -- another value
print(tonumber(t[k])) -- one value
print(tonumber[t[j]]) -- one value
print(t[tonumber(k)])
print(t[tonumber(j)])

函數

lua 中函數是做爲第一類值來看待的
函數能夠存儲在變量中
咱們能夠經過參數傳遞給其餘函數，還能夠做爲其餘函數的返回值
基於這種機制，當咱們給一個函數添加新的功能的時候，程序能夠從新定義這個函數
在運行一些不受信任的代碼的時候，可先刪除某些函數，從而建立一個安全的運行環境
lua 既能夠調用自身編寫的函數，還能夠調用 C 語言編寫的函數
lua 全部的標準庫都是用 C 語言編寫的學習
1. 如：對字符串的操做
2. 對 table 的操做
3. 輸入輸出
4. 操做系統的功能調用
5. 數學函數
6. 調試函數
應用程序也可使用 C 語言來定義的其餘函數