Lua-quick-guide

ルア-概要

Luaは、Cで書かれた拡張可能な軽量のプログラミング言語です。 1993年にRoberto Ierusalimschy、Luiz Henrique de Figueiredo、およびWaldemar Celesによる社内プロジェクトとして開始されました。

Cおよび他の従来の言語で記述されたコードと統合できるソフトウェアになるように最初から設計されました。 この統合には多くの利点があります。 Cがすでにできることをしようとはしませんが、Cが得意ではないものを提供することを目的としています。 このため、Luaには安全な環境、自動メモリ管理、文字列やその他の種類のデータを動的なサイズで処理するための優れた機能があります。

特徴

Luaは、他の言語とは異なる独自の機能セットを提供します。 これらには-

• 拡張可能
• 単純な
• 効率的
• ポータブル
• 無料でオープン

コード例

print("Hello World!")

Luaの実装方法

Luaは、Luaインタープリター部分と機能しているソフトウェアシステムの2つの部分で構成されています。 機能するソフトウェアシステムは、Luaプログラミング言語で書かれたプログラムを解釈できる実際のコンピューターアプリケーションです。 LuaインタープリターはANSI Cで記述されているため、移植性が高く、ハイエンドネットワークサーバーから小型デバイスまで、幅広いデバイスで実行できます。

Luaの言語とそのインタープリターはどちらも、成熟し、小さく、高速です。 他のプログラミング言語と最高のソフトウェア標準から進化しました。 サイズが小さいため、メモリの少ない小さなデバイスで実行できます。

Luaの学習

Luaを学習する際の最も重要な点は、技術的な詳細に迷うことなく概念に集中することです。

プログラミング言語を学習する目的は、優れたプログラマーになることです。つまり、新しいシステムの設計と実装、および古いシステムの保守においてより効果的になることです。

Luaの用途

• ゲームプログラミング
• スタンドアロンアプリケーションでのスクリプト作成
• Webでのスクリプト作成
• MySQL ProxyやMySQL WorkBenchなどのデータベースの拡張機能とアドオン
• 侵入検知システムなどのセキュリティシステム。

Lua-環境

ローカル環境のセットアップ

Luaプログラミング言語用に環境を設定する場合は、コンピューターで使用可能な次のソフトウェアが必要です-（a）テキストエディター、（b）Luaインタープリター、および（c）Luaコンパイラー。

テキストエディタ

プログラムを入力するには、テキストエディターが必要です。 いくつかのエディターの例には、Windows Notepad、OS Editコマンド、Brief、Epsilon、EMACS、vimまたはviが含まれます。

テキストエディタの名前とバージョンは、オペレーティングシステムによって異なる場合があります。 たとえば、Windowsではメモ帳が使用され、LinuxまたはUNIXと同様にWindowsでもvimまたはviを使用できます。

エディターで作成するファイルはソースファイルと呼ばれ、これらのファイルにはプログラムのソースコードが含まれています。 Luaプログラムのソースファイルには、通常、拡張子「* .lua」*が付いています。

ルア通訳

これは、Luaコマンドを入力してすぐに実行できるようにする小さなプログラムです。 完全に実行するコンパイラとは異なり、エラーが発生した場合にLuaファイルの実行を停止します。

Luaコンパイラ

Luaを他の言語/アプリケーションに拡張する場合、Lua Application Program Interfaceと互換性のあるコンパイラーを備えたソフトウェア開発キットが必要です。

Windowsへのインストール

Windows環境用に開発された「SciTE」という名前の別のIDEがあり、https://code.google.com/p/luaforwindows/ダウンロードセクションからダウンロードできます。

ダウンロードした実行可能ファイルを実行して、Lua IDEをインストールします。

IDEであるため、同じものを使用してLuaコードを作成およびビルドできます。

コマンドラインモードでLuaをインストールする場合は、MinGWまたはCygwinをインストールしてから、WindowsでLuaをコンパイルしてインストールする必要があります。

Linuxへのインストール

Luaをダウンロードしてビルドするには、次のコマンドを使用します-

$ wget http://www.lua.org/ftp/lua-5.2.3.tar.gz
$ tar zxf lua-5.2.3.tar.gz
$ cd lua-5.2.3
$ make linux test

make LinuxでLinuxを置き換えることにより、aix、ansi、bsd、generic linux、mingw、posix、solarisなどの他のプラットフォームにインストールするには、対応するプラットフォーム名でテストします。

次のように、LuaにhelloWorld.luaがあります-

print("Hello World!")

今、私たちはcdを使用してファイルを含むフォルダに切り替えて、次のコマンドを使用して、helloWorld.luaなどのLuaファイルを構築して実行することができます-

$ lua helloWorld

次の出力を確認できます。

Hello World!

Mac OS Xでのインストール

Mac OS XでLuaをビルド/テストするには、次のコマンドを使用します-

$ curl -R -O http://www.lua.org/ftp/lua-5.2.3.tar.gz
$ tar zxf lua-5.2.3.tar.gz
$ cd lua-5.2.3
$ make macosx test

場合によっては、Xcodeとコマンドラインツールをインストールしていない可能性があります。 そのような場合、makeコマンドを使用することはできません。 MacアプリストアからXcodeをインストールします。 次に、Xcodeの設定に移動し、ダウンロードに切り替えて、「コマンドラインツール」という名前のコンポーネントをインストールします。 プロセスが完了すると、makeコマンドが使用可能になります。

「make macosx test」ステートメントを実行することは必須ではありません。 このコマンドを実行しなくても、Mac OS XでLuaを使用できます。

次のように、LuaにhelloWorld.luaがあります-

print("Hello World!")

今、私たちはcdを使用してファイルを含むフォルダに切り替えてから次のコマンドを使用して、helloWorld.luaなどのLuaファイルを構築して実行することができます-

$ lua helloWorld

私たちは次の出力を見ることができます-

Hello World!

Lua IDE

前述のように、Windows SciTEの場合、Lua IDEはLua作成チームが提供するデフォルトのIDEです。 利用可能な代替IDEは、Windows、Mac、Linuxなどの複数のプラットフォームで利用可能なZeroBrane Studioから入手できます。

Lua開発を可能にするEclipse用のプラグインもあります。 IDEを使用すると、コード補完などの機能により開発が容易になるため、強くお勧めします。 IDEは、コマンドラインバージョンのLuaに似たインタラクティブモードプログラミングも提供します。

Lua-基本構文

最初のLuaプログラムの作成を始めましょう！

最初のLuaプログラム

インタラクティブモードプログラミング

Luaは、インタラクティブモードと呼ばれるモードを提供します。 このモードでは、指示を次々に入力して、すぐに結果を得ることができます。 これは、lua -iまたは単にluaコマンドを使用して、シェルで呼び出すことができます。 これを入力したら、Enterを押すと、以下に示すように対話モードが開始されます。

$ lua -i
$ Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio
quit to end; cd, dir and edit also available

あなたは次の文を使用して何かを印刷することができます-

print("test")

Enterキーを押すと、次の出力が表示されます-

test

デフォルトモードプログラミング

Luaファイル名パラメーターでインタープリターを呼び出すと、ファイルの実行が開始され、スクリプトが終了するまで続行されます。 スクリプトが終了すると、インタープリターはアクティブではなくなります。

簡単なLuaプログラムを作成しましょう。 すべてのLuaファイルの拡張子は.luaになります。 したがって、test.luaファイルに次のソースコードを配置します。

print("test")

lua環境が正しく設定されていると仮定して、次のコードを使用してプログラムを実行しましょう-

$ lua test.lua

私たちは次の出力を取得します-

test

Luaプログラムを実行する別の方法を試してみましょう。 以下は、変更されたtest.luaファイルです-

#!/usr/local/bin/lua

print("test")

ここでは、/usr/local/binディレクトリーでLuaインタープリターが使用可能であると想定しています。 ＃記号で始まる場合、最初の行はインタープリターによって無視されます。 今、次のようにこのプログラムを実行してみてください-

$ chmod a+rx test.lua
$./test.lua

次の出力が得られます。

test

Luaプログラムの基本構造を見てみましょう。これにより、Luaプログラミング言語の基本的な構成要素を理解しやすくなります。

Luaのトークン

Luaプログラムはさまざまなトークンで構成され、トークンはキーワード、識別子、定数、文字列リテラル、またはシンボルのいずれかです。 たとえば、次のLuaステートメントは3つのトークンで構成されています-

io.write("Hello world, from ",_VERSION,"!\n")

個々のトークンは-

io.write
(
   "Hello world, from ",_VERSION,"!\n"
)

コメント

コメントは、Luaプログラムのテキストを支援するようなもので、インタープリターによって無視されます。 以下に示すように、それらは-で終わり、文字-で終わります-

--[[my first program in Lua --]]

識別子

Lua識別子は、変数、関数、またはその他のユーザー定義アイテムを識別するために使用される名前です。 識別子は、文字「A to Z」または「a to z」またはアンダースコア「_」で始まり、その後に0個以上の文字、アンダースコア、および数字（0〜9）が続きます。

Luaでは、識別子内で@、$、％などの句読点文字を使用できません。 Luaは「大文字と小文字を区別する」プログラミング言語です。 したがって、_Manpower_と_manpower_はLuaの2つの異なる識別子です。 ここに許容可能な識別子のいくつかの例があります-

mohd         zara      abc     move_name    a_123
myname50     _temp     j       a23b9        retVal

キーワード

次のリストは、Luaの予約語のいくつかを示しています。 これらの予約語は、定数、変数、またはその他の識別子名として使用できません。

and	break	do	else
elseif	end	false	for
function	if	in	local
nil	not	or	repeat
return	then	true	until
while

Luaの空白

コメントが含まれている可能性がある空白のみを含む行は空白行と呼ばれ、Luaインタープリターは完全に無視します。

空白は、空白、タブ、改行文字、コメントを説明するためにLuaで使用される用語です。 空白はステートメントの一部を別の部分から分離し、インタープリターがステートメントの1つの要素（intなど）がどこで終わり、次の要素が始まるかを識別できるようにします。 したがって、次のステートメントで-

local age

インタープリターがそれらを区別できるようにするには、ローカルと年齢の間に少なくとも1つの空白文字（通常はスペース）が必要です。 一方、次の文で-

fruit = apples + oranges   --get the total fruit

果物と=、または=とリンゴの間には空白文字は必要ありませんが、読みやすくするために空白文字を自由に含めることができます。

Lua-変数

変数は、プログラムが操作できるストレージ領域に付けられた名前に他なりません。 関数やテーブルなど、さまざまなタイプの値を保持できます。

変数の名前は、文字、数字、およびアンダースコア文字で構成できます。 文字またはアンダースコアで始まる必要があります。 Luaでは大文字と小文字が区別されるため、大文字と小文字は区別されます。 Luaの値の8つの基本的なタイプがあります-

Luaでは、変数のデータ型はありませんが、変数のスコープに基づいて3つの型があります。

• グローバル変数-ローカルとして明示的に宣言されていない限り、すべての変数はグローバルと見なされます。
• ローカル変数-型が変数のローカルとして指定されている場合、スコープはスコープ内の関数で制限されます。
• テーブルフィールド-これは、関数を含むnil以外のすべてを保持できる特別なタイプの変数です。

Luaの変数定義

変数定義とは、変数のストレージを作成する場所と量をインタープリターに伝えることです。 変数定義にはオプションのタイプがあり、次のようにそのタイプの1つ以上の変数のリストが含まれています-

type variable_list;

ここで、 type はオプションでローカルまたは指定されたタイプでグローバルになり、 variable_list はコンマで区切られた1つ以上の識別子名で構成されます。 いくつかの有効な宣言がここに示されています-

local    i, j
local    i
local    a,c

行 local i、j は、変数iとjを宣言および定義します。これは、インタープリターにi、jという名前の変数を作成するように指示し、スコープをローカルに制限します。

変数は、宣言で初期化（初期値を割り当て）できます。 初期化子は、等号とそれに続く定数式で構成されます-

type variable_list = value_list;

いくつかの例は-

local d , f = 5 ,10     --declaration of d and f as local variables.
d , f = 5, 10;          --declaration of d and f as global variables.
d, f = 10               --[[declaration of d and f as global variables.
                           Here value of f is nil --]]

初期化子なしの定義の場合：静的ストレージ期間を持つ変数は、nilで暗黙的に初期化されます。

Luaの変数宣言

上記の例でわかるように、複数変数の割り当ては、variable_listおよびvalue_listの形式に従います。 上記の例 local d、f = 5,10 では、variable_listにdとfがあり、valuesリストに5と10があります。

Luaでの値の割り当ては、value_listの最初の値を持つvariable_listの最初の変数のように行われます。 したがって、dの値は5で、fの値は10です。

例

次の例を試してください。変数は上部で宣言されていますが、メイン関数内で定義および初期化されています-

-- Variable definition:
local a, b

-- Initialization
a = 10
b = 30

print("value of a:", a)

print("value of b:", b)

-- Swapping of variables
b, a = a, b

print("value of a:", a)

print("value of b:", b)

f = 70.0/3.0
print("value of f", f)

上記のコードをビルドして実行すると、次の結果が生成されます-

value of a: 10
value of b: 30
value of a: 30
value of b: 10
value of f  23.333333333333

Luaの左辺値と右辺値

Luaには2種類の式があります-

• lvalue -メモリ位置を参照する式は「lvalue」式と呼ばれます。 左辺値は、割り当ての左辺または右辺として表示される場合があります。
• rvalue -rvalueという用語は、メモリ内のあるアドレスに格納されているデータ値を指します。 右辺値は値を割り当てることができない式です。つまり、右辺には右辺が表示されますが、左辺には表示されない場合があります。

変数は左辺値であるため、割り当ての左側に表示される場合があります。 数値リテラルは右辺値であるため、割り当てられず、左側に表示されることはありません。 以下は有効なステートメントです-

g = 20

しかし、次は有効なステートメントではなく、ビルド時エラーを生成します-

10 = 20

Luaプログラミング言語では、上記のタイプの割り当てとは別に、同じ単一のステートメントに複数の左辺値と右辺値を含めることができます。 以下に示します。

g,l = 20,30

上記のステートメントでは、gに20が割り当てられ、lに30が割り当てられています。

Lua-データ型

Luaは動的に型指定された言語であるため、変数には型がなく、値のみに型があります。 値は変数に保存され、パラメーターとして渡され、結果として返されます。

Luaでは、変数のデータ型はありませんが、値の型はあります。 値のデータ型のリストを以下に示します。

Sr.No	Value Type & Description
1	nil 一部のデータまたはno（nil）データを持つことと値を区別するために使用されます。
2	boolean 値としてtrueとfalseが含まれます。 通常、条件チェックに使用されます。
3	number 実数（倍精度浮動小数点数）を表します。
4	string 文字の配列を表します。
5	function CまたはLuaで記述されたメソッドを表します。
6	userdata 任意のCデータを表します。
7	thread 独立した実行スレッドを表し、コルーチンの実装に使用されます。
8	table 通常の配列、シンボルテーブル、セット、レコード、グラフ、ツリーなどを表し、連想配列を実装します。 任意の値を保持できます（nilを除く）。

タイプ機能

Luaには、変数の型を知ることができる「型」と呼ばれる関数があります。 次のコードにいくつかの例を示します。

print(type("What is my type"))   --> string
t = 10

print(type(5.8*t))               --> number
print(type(true))                --> boolean
print(type(print))               --> function
print(type(nil))                 --> nil
print(type(type(ABC)))           --> string

上記のプログラムをビルドして実行すると、Linuxで次の結果が生成されます-

string
number
boolean
function
nil
string

デフォルトでは、値が割り当てられるか初期化されるまで、すべての変数はnilを指します。 Luaでは、条件チェックの場合、ゼロおよび空の文字列はtrueと見なされます。 したがって、ブール演算を使用する場合は注意が必要です。 次の章では、これらのタイプの使用について詳しく説明します。

Lua-オペレーター

演算子は、特定の数学的または論理的な操作を実行するようにインタープリターに指示する記号です。 Lua言語は組み込み演算子が豊富であり、次のタイプの演算子を提供します-

• 算術演算子
• 関係演算子
• 論理演算子
• その他の演算子

このチュートリアルでは、算術演算子、関係演算子、論理演算子、およびその他のさまざまな演算子を1つずつ説明します。

算術演算子

次の表は、Lua言語でサポートされているすべての算術演算子を示しています。 変数 A が10を保持し、変数 B が20を保持すると仮定します-

link：/lua/lua_arithmetic_operators [例を表示]

Operator	Description	Example
+	Adds two operands	A + B will give 30
-	Subtracts second operand from the first	A - B will give -10
*	Multiply both operands	A* B will give 200
/	Divide numerator by de-numerator	B/A will give 2
%	Modulus Operator and remainder of after an integer division	B % A will give 0
^	Exponent Operator takes the exponents	A^2 will give 100
-	Unary - operator acts as negation	-A will give -10

関係演算子

次の表は、Lua言語でサポートされているすべての関係演算子を示しています。 変数 A が10を保持し、変数 B が20を保持すると仮定します-

リンク：/lua/lua_relational_operators [例を表示]

Operator	Description	Example
==	Checks if the value of two operands are equal or not, if yes then condition becomes true.	(A == B) is not true.
~=	Checks if the value of two operands are equal or not, if values are not equal then condition becomes true.	(A ~= B) is true.
>	Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.	(A >= B) is not true.
⇐	Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.	(A ⇐ B) is true.

論理演算子

次の表は、Lua言語でサポートされているすべての論理演算子を示しています。 変数 A がtrueを保持し、変数 B がfalseを保持すると仮定します-

link：/lua/lua_logical_operators [例を表示]

Operator	Description	Example
and	Called Logical AND operator. If both the operands are non zero then condition becomes true.	(A and B) is false.
or	Called Logical OR Operator. If any of the two operands is non zero then condition becomes true.	(A or B) is true.
not	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	!(A and B) is true.

その他の演算子

Lua言語でサポートされるその他の演算子には、*連結*および*長さ*が含まれます。

リンク：/lua/lua_miscellaneous_operator [例を表示]

Operator	Description	Example
..	Concatenates two strings.	a..b where a is "Hello " and b is "World", will return "Hello World".
#	An unary operator that return the length of the a string or a table.	#"Hello" will return 5

Luaでの演算子の優先順位

演算子の優先順位は、式内の用語のグループ化を決定します。 これは、式の評価方法に影響します。 特定の演算子は、他の演算子よりも優先順位が高くなっています。たとえば、乗算演算子は加算演算子よりも優先順位が高い-

たとえば、x = 7 + 3 * 2;ここで、演算子*の優先順位は＆plus;よりも高いため、xには20ではなく13が割り当てられます。したがって、最初に3 * 2で乗算され、7に加算されます。

ここでは、優先順位が最も高い演算子が表の上部に表示され、優先順位が最も低い演算子が下部に表示されます。 式内では、優先順位の高い演算子が最初に評価されます。

リンク：/lua/operators_precedence_in_Lua [例を表示]

Category	Operator	Associativity
Unary	not # -	Right to left
Concatenation	..	Right to left
Multiplicative	*/%	Left to right
Additive	+ -	Left to right
Relational	< > ⇐ >= == ~=	Left to right
Equality	== ~=	Left to right
Logical AND	and	Left to right
Logical OR	or	Left to right

ルア-ループ

コードのブロックを数回実行する必要がある場合があります。 一般に、ステートメントは順番に実行されます。関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。

プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。

ループステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。 以下は、ほとんどのプログラミング言語での一般的なループ文の形式です-

ループアーキテクチャ

Luaは、ループ要件を処理するために次のタイプのループを提供します。

Sr.No.	Loop Type & Description
1	while loop 特定の条件が真の間、ステートメントまたはステートメントのグループを繰り返します。 ループ本体を実行する前に条件をテストします。
2	for loop 一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。
3	repeat…​until loop until条件が満たされるまで、ステートメントのグループの操作を繰り返します。
4	nested loops 別の_while、forまたはdo..while_ループ内で1つ以上のループを使用できます。

ループ制御ステートメント

ループ制御ステートメントは、通常のシーケンスから実行を変更します。 実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトが破棄されます。

Luaは次の制御ステートメントをサポートしています。

Sr.No.	Control Statement & Description
1	break statement ループ*を終了し、ループまたはスイッチの直後のステートメントに実行を転送します。

無限ループ

条件が決して偽にならない場合、ループは無限ループになります。 この目的のために、 while ループがよく使用されます。 条件に直接trueを指定するため、永久に実行され続けます。 breakステートメントを使用して、このループを中断できます。

while( true )
do
   print("This loop will run forever.")
end

ルア-意思決定

意思決定構造では、プログラマーは、プログラムが評価またはテストする1つ以上の条件を、条件が真であると判断された場合に実行されるステートメントとともに指定する必要があります。条件は偽と判断されます。

以下は、ほとんどのプログラミング言語で見られる典型的な意思決定構造の一般的な形式です-

Luaの意思決定ステートメント

Luaプログラミング言語は、ブール値 true および non-nil 値の任意の組み合わせを true と見なし、ブール値 false または nil の場合、 false 値と見なされます。 Luaでは、* zeroはtrueと見なされることに注意してください。*

Luaプログラミング言語は、以下のタイプの意思決定ステートメントを提供します。

Sr.No.	Statement & Description
1	if statement _if_ステートメントは、ブール式とそれに続く1つ以上のステートメントで構成されます。
2	if…​else statement _if_ステートメントの後にオプションの_else_ステートメントを続けることができます。これは、ブール式が偽の場合に実行されます。
3	nested if statements 1つの_if_または_else if_ステートメントを別の_if_または_else if_ステートメント内で使用できます。

Lua-関数

関数は、一緒にタスクを実行するステートメントのグループです。 コードを別々の機能に分割できます。 コードを異なる関数に分割する方法はユーザー次第ですが、論理的には通常、その分割は一意であるため、各関数は特定のタスクを実行します。

Lua言語は、プログラムが呼び出すことができる多数の組み込みメソッドを提供します。 たとえば、コンソールで入力として渡された引数を印刷するメソッド* print（）*。

関数は、メソッド、サブルーチン、またはプロシージャなどのさまざまな名前で知られています。

関数を定義する

Luaプログラミング言語のメソッド定義の一般的な形式は次のとおりです-

optional_function_scope function function_name( argument1, argument2, argument3........,
argumentn)
function_body
return result_params_comma_separated
end

Luaプログラミング言語のメソッド定義は、_method header_と_method body_で構成されています。 ここにメソッドのすべての部分があります-

• オプションの関数スコープ-キーワード_local_を使用して関数のスコープを制限したり、スコープセクションを無視してグローバル関数にすることができます。
• 関数名-これは関数の実際の名前です。 関数名とパラメーターリストは一緒に関数シグネチャを構成します。
• 引数-引数はプレースホルダーのようなものです。 関数が呼び出されると、引数に値を渡します。 この値は、実際のパラメーターまたは引数と呼ばれます。 パラメータリストは、メソッドの引数のタイプ、順序、および数を参照します。 引数はオプションです。つまり、メソッドには引数が含まれない場合があります。
• 関数本体-メソッド本体には、メソッドの動作を定義するステートメントのコレクションが含まれます。
• Return -Luaでは、returnキーワードにコンマ区切りの戻り値を続けることにより、複数の値を返すことができます。

例

以下は、* max（）*という関数のソースコードです。 この関数は2つのパラメータnum1とnum2を取り、2つの間の最大値を返します-

--[[function returning the max between two numbers --]]
function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end

関数の引数

関数が引数を使用する場合、引数の値を受け入れる変数を宣言する必要があります。 これらの変数は、関数の*仮パラメータ*と呼ばれます。

仮パラメータは、関数内の他のローカル変数のように動作し、関数に入ると作成され、終了すると破棄されます。

関数を呼び出す

Lua関数を作成するときに、関数が何をする必要があるかを定義します。 メソッドを使用するには、その関数を呼び出して定義済みのタスクを実行する必要があります。

プログラムが関数を呼び出すと、プログラム制御は呼び出された関数に転送されます。 呼び出された関数は、定義されたタスクを実行し、そのreturnステートメントが実行されるか、関数の終わりに達すると、プログラム制御をメインプログラムに戻します。

メソッドを呼び出すには、必要なパラメーターとメソッド名を渡すだけでよく、メソッドが値を返す場合は、戻り値を保存できます。 たとえば-

function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end

-- calling a function
print("The maximum of the two numbers is ",max(10,4))
print("The maximum of the two numbers is ",max(5,6))

上記のコードを実行すると、次の出力が得られます。

The maximum of the two numbers is   10
The maximum of the two numbers is   6

関数の割り当てと受け渡し

Luaでは、関数を変数に割り当てたり、変数を別の関数のパラメーターとして渡すこともできます。 Luaで関数をパラメーターとして割り当てて渡す簡単な例を次に示します。

myprint = function(param)
   print("This is my print function -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   functionPrint(result)
end

myprint(10)
add(2,5,myprint)

上記のコードを実行すると、次の出力が得られます。

This is my print function -   ##    10  ##
This is my print function -   ##    7   ##

可変引数を持つ関数

'…​'をパラメーターとして使用して、Luaで可変引数を持つ関数を作成することができます。 関数が平均を返し、変数の引数を取ることができる例を見ると、これを把握できます。

function average(...)
   result = 0
   local arg = {...}
   for i,v in ipairs(arg) do
      result = result + v
   end
   return result/#arg
end

print("The average is",average(10,5,3,4,5,6))

上記のコードを実行すると、次の出力が得られます。

The average is  5.5

ルア-文字列

文字列は、一連の文字とフォームフィードのような制御文字です。 文字列は、次の3つの形式で初期化できます-

• 単一引用符の間の文字
• 二重引用符の間の文字 *の間の文字

上記の3つのフォームの例を以下に示します。

string1 = "Lua"
print("\"String 1 is\"",string1)

string2 = 'Tutorial'
print("String 2 is",string2)

string3 = [[Lua Tutorial"]]
print("String 3 is",string3)

上記のプログラムを実行すると、次の出力が得られます。

"String 1 is"   Lua
String 2 is Tutorial
String 3 is "Lua Tutorial"

文字列のエスケープシーケンス文字は、文字の通常の解釈を変更するために使用されます。 たとえば、二重反転コンマ（ ""）を印刷するには、上記の例で\ "を使用しました。 エスケープシーケンスとその使用法を以下の表にリストします。

Escape Sequence	Use
\a	Bell
\b	Backspace
\f	Formfeed
\n	New line
\r	Carriage return
\t	Tab
\v	Vertical tab
\\	Backslash
\"	Double quotes
\'	Single quotes
\[	Left square bracket
\]	Right square bracket

文字列操作

Luaは文字列を操作する文字列をサポートしています-

Sr.No.	Method & Purpose
1	string.upper(argument)* 引数の大文字表記を返します。
2	string.lower(argument) 引数の小文字表現を返します。
3	string.gsub(mainString,findString,replaceString) findStringの出現箇所をreplaceStringに置き換えて文字列を返します。
4	string.find(mainString,findString, optionalStartIndex、optionalEndIndex） * メイン文字列のfindStringの開始インデックスと終了インデックスを返し、見つからない場合はnilを返します。
5	string.reverse(arg)* 渡された文字列の文字を逆にして文字列を返します。
6	string.format(…​) フォーマットされた文字列を返します。
7	string.char(arg) and string.byte(arg) 入力引数の内部数値および文字表現を返します。
8	string.len(arg) 渡された文字列の長さを返します。
9	string.rep(string, n)) 同じ文字列をn回繰り返して文字列を返します。
10	.. .. したがって、演算子は2つの文字列を連結します。

それでは、これらの文字列操作関数の動作を正確に確認するために、いくつかの例を見てみましょう。

ケース操作

文字列を大文字と小文字に変換するためのサンプルコードを以下に示します。

string1 = "Lua";

print(string.upper(string1))
print(string.lower(string1))

上記のプログラムを実行すると、次の出力が得られます。

LUA
lua

部分文字列の置換

ある文字列の出現を別の文字列で置換するためのサンプルコードを以下に示します。

string = "Lua Tutorial"

-- replacing strings
newstring = string.gsub(string,"Tutorial","Language")
print("The new string is "..newstring)

上記のプログラムを実行すると、次の出力が得られます。

The new string is Lua Language

検索と反転

サブストリングのインデックスを検索し、ストリングを反転するためのサンプルコードを以下に示します。

string = "Lua Tutorial"

-- replacing strings
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("The new string is",reversedString)

上記のプログラムを実行すると、次の出力が得られます。

5   12
The new string is   lairotuT auL

文字列のフォーマット

私たちのプログラミングでは何度も、フォーマットされた方法で文字列を印刷する必要があります。 string.format関数を使用して、以下に示すように出力をフォーマットできます。

string1 = "Lua"
string2 = "Tutorial"

number1 = 10
number2 = 20

-- Basic string formatting
print(string.format("Basic formatting %s %s",string1,string2))

-- Date formatting
date = 2; month = 1; year = 2014
print(string.format("Date formatting %02d/%02d/%03d", date, month, year))

-- Decimal formatting
print(string.format("%.4f",1/3))

上記のプログラムを実行すると、次の出力が得られます。

Basic formatting Lua Tutorial
Date formatting 02/01/2014
0.3333

文字とバイトの表現

文字列から内部表現へ、またはその逆への変換に使用される文字およびバイト表現のサンプルコード。

-- Byte conversion

-- First character
print(string.byte("Lua"))

-- Third character
print(string.byte("Lua",3))

-- first character from last
print(string.byte("Lua",-1))

-- Second character
print(string.byte("Lua",2))

-- Second character from last
print(string.byte("Lua",-2))

-- Internal Numeric ASCII Conversion
print(string.char(97))

上記のプログラムを実行すると、次の出力が得られます。

76
97
97
117
117
a

その他の一般的な機能

一般的な文字列操作には、文字列の連結、文字列の長さの検索、および同じ文字列を複数回繰り返すことが含まれます。 これらの操作の例を以下に示します。

string1 = "Lua"
string2 = "Tutorial"

-- String Concatenations using ..
print("Concatenated string",string1..string2)

-- Length of string
print("Length of string1 is ",string.len(string1))

-- Repeating strings
repeatedString = string.rep(string1,3)
print(repeatedString)

上記のプログラムを実行すると、次の出力が得られます。

Concatenated string LuaTutorial
Length of string1 is    3
LuaLuaLua

Lua-配列

配列は、オブジェクトの順序付けられた配列です。これは、行のコレクションを含む1次元配列、または複数の行と列を含む多次元配列です。

Luaでは、整数を持つインデックステーブルを使用して配列が実装されます。 配列のサイズは固定されておらず、メモリの制約を条件として、要件に基づいて拡大できます。

一次元配列

1次元配列は、単純なテーブル構造を使用して表現でき、単純な for ループを使用して初期化して読み取ることができます。 例を以下に示します。

array = {"Lua", "Tutorial"}

for i = 0, 2 do
   print(array[i])
end

上記のコードを実行すると、次の出力が得られます。

nil
Lua
Tutorial

上記のコードでわかるように、配列内にないインデックス内の要素にアクセスしようとすると、nilが返されます。 Luaでは、インデックス作成は通常インデックス1から始まります。 ただし、インデックス0および0未満でオブジェクトを作成することもできます。 負のインデックスを使用した配列を以下に示します。ここでは、_for_ループを使用して配列を初期化します。

array = {}

for i= -2, 2 do
   array[i] = i *2
end

for i = -2,2 do
   print(array[i])
end

上記のコードを実行すると、次の出力が得られます。

-4
-2
0
2
4

多次元配列

多次元配列は2つの方法で実装できます。

• 配列の配列
• インデックスの操作による1次元配列

3の多次元配列の例。 3は配列の配列を使用して以下に示されています。

-- Initializing the array
array = {}

for i=1,3 do
   array[i] = {}

   for j=1,3 do
      array[i][j] = i*j
   end

end

-- Accessing the array

for i=1,3 do

   for j=1,3 do
      print(array[i][j])
   end

end

上記のコードを実行すると、次の出力が得られます。

1
2
3
2
4
6
3
6
9

多次元配列の例を、インデックスの操作を使用して以下に示します。

-- Initializing the array

array = {}

maxRows = 3
maxColumns = 3

for row=1,maxRows do

   for col=1,maxColumns do
      array[row*maxColumns +col] = row*col
   end

end

-- Accessing the array

for row=1,maxRows do

   for col=1,maxColumns do
      print(array[row*maxColumns +col])
   end

end

上記のコードを実行すると、次の出力が得られます。

1
2
3
2
4
6
3
6
9

上記の例でわかるように、データはインデックスに基づいて保存されます。 スパースな方法で要素を配置することが可能であり、これはマトリックスのLua実装が機能する方法です。 Luaにはnil値を格納しないため、他のプログラミング言語で使用される特別な手法と比較して、Luaで特別な手法を使用しなくても多くのメモリを節約できます。

Lua-イテレーター

イテレータは、いわゆるコレクションまたはコンテナの要素をトラバースできる構造です。 Luaでは、これらのコレクションはしばしばテーブルを参照します。テーブルは配列などのさまざまなデータ構造を作成するために使用されます。

イテレータのジェネリック

汎用の_for_イテレータは、コレクション内の各要素のキーと値のペアを提供します。 以下に簡単な例を示します。

array = {"Lua", "Tutorial"}

for key,value in ipairs(array)
do
   print(key, value)
end

上記のコードを実行すると、次の出力が得られます-

1  Lua
2  Tutorial

上記の例では、Luaが提供するデフォルトの_ipairs_イテレータ関数を使用しています。

Luaでは、関数を使用して反復子を表します。 これらのイテレータ関数の状態の維持に基づいて、2つの主なタイプがあります-

• ステートレスイテレーター
• ステートフルイテレーター

ステートレスイテレーター

名前自体から、このタイプの反復関数は状態を保持しないことがわかります。

ここで、 n 数の2乗を出力する単純な関数を使用して独自の反復子を作成する例を見てみましょう。

function square(iteratorMaxCount,currentNumber)

   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
      return currentNumber, currentNumber*currentNumber
   end

end

for i,n in square,3,0
do
   print(i,n)
end

上記のプログラムを実行すると、次の出力が得られます。

1   1
2   4
3   9

上記のコードは、イテレーターの_ipairs_関数の動作を模倣するためにわずかに変更できます。 以下に示します。

function square(iteratorMaxCount,currentNumber)

   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
      return currentNumber, currentNumber*currentNumber
   end

end

function squares(iteratorMaxCount)
   return square,iteratorMaxCount,0
end

for i,n in squares(3)
do
   print(i,n)
end

上記のプログラムを実行すると、次の出力が得られます。

1   1
2   4
3   9

ステートフルイテレーター

関数を使用した反復の前の例は、状態を保持しません。 関数が呼び出されるたびに、関数に送信された2番目の変数に基づいて、コレクションの次の要素を返します。 現在の要素の状態を保持するために、クロージャーが使用されます。 クロージャーは、関数呼び出し間で変数値を保持します。 新しいクロージャーを作成するには、クロージャー自体とファクトリーを含む2つの関数、クロージャーを作成する関数を作成します。

ここで、クロージャーを使用する独自のイテレーターを作成する例を見てみましょう。

array = {"Lua", "Tutorial"}

function elementIterator (collection)

   local index = 0
   local count = #collection

   -- The closure function is returned

   return function ()
      index = index + 1

      if index <= count
      then
         -- return the current element of the iterator
         return collection[index]
      end

   end

end

for element in elementIterator(array)
do
   print(element)
end

上記のプログラムを実行すると、次の出力が得られます。

Lua
Tutorial

上記の例では、elementIteratorには、ローカル外部変数indexおよびcountを使用して、関数が呼び出されるたびにインデックスをインクリメントすることでコレクション内の各要素を返す別のメソッドが含まれていることがわかります。

上記のようにクロージャを使用して独自の関数イテレータを作成し、コレクションを反復するたびに複数の要素を返すことができます。

Lua-テーブル

前書き

テーブルはLuaで使用できる唯一のデータ構造であり、配列や辞書などのさまざまなタイプの作成に役立ちます。 Luaは連想配列を使用し、数値だけでなく、nil以外の文字列でもインデックスを作成できます。 テーブルのサイズは固定されておらず、必要に応じて拡大できます。

Luaは、パッケージの表現を含むすべての表現でテーブルを使用します。 メソッドstring.formatにアクセスすると、stringパッケージで利用可能なformat関数にアクセスしていることを意味します。

表現と使用

テーブルはオブジェクトと呼ばれ、値でも変数でもありません。 Luaは、コンストラクタ式\ {}を使用して空のテーブルを作成します。 テーブルの参照を保持する変数とテーブル自体の間に固定された関係はないことが知られています。

--sample table initialization
mytable = {}

--simple table value assignment
mytable[1]= "Lua"

--removing reference
mytable = nil

-- lua garbage collection will take care of releasing memory

要素のセットを持つテーブル a があり、それを b に割り当てると、 a と b の両方が同じメモリを参照します。 bに個別に割り当てられるメモリはありません。 aがnilに設定されている場合、テーブルは引き続きbにアクセスできます。 テーブルへの参照がない場合、Luaのガベージコレクションはクリーンアッププロセスを処理し、これらの参照されていないメモリを再利用できるようにします。

上記のテーブルの機能を説明するための例を以下に示します。

-- Simple empty table
mytable = {}
print("Type of mytable is ",type(mytable))

mytable[1]= "Lua"
mytable["wow"] = "Tutorial"

print("mytable Element at index 1 is ", mytable[1])
print("mytable Element at index wow is ", mytable["wow"])

-- alternatetable and mytable refers to same table
alternatetable = mytable

print("alternatetable Element at index 1 is ", alternatetable[1])
print("alternatetable Element at index wow is ", alternatetable["wow"])

alternatetable["wow"] = "I changed it"

print("mytable Element at index wow is ", mytable["wow"])

-- only variable released and and not table
alternatetable = nil
print("alternatetable is ", alternatetable)

-- mytable is still accessible
print("mytable Element at index wow is ", mytable["wow"])

mytable = nil
print("mytable is ", mytable)

上記のプログラムを実行すると、次の出力が得られます-

Type of mytable is  table
mytable Element at index 1 is   Lua
mytable Element at index wow is     Tutorial
alternatetable Element at index 1 is    Lua
alternatetable Element at index wow is  Tutorial
mytable Element at index wow is     I changed it
alternatetable is   nil
mytable Element at index wow is     I changed it
mytable is  nil

テーブル操作

テーブル操作用の組み込み関数があり、それらは次の表にリストされています。

Sr.No.	Method & Purpose
1	table.concat (table [, sep [, i [, j]]]) 指定されたパラメーターに基づいてテーブル内の文字列を連結します。 詳細については例を参照してください。
2	table.insert (table, [pos,] value) テーブルの指定された位置に値を挿入します。
3	table.maxn (table) 最大の数値インデックスを返します。
4	table.remove (table [, pos]) テーブルから値を削除します。
5	table.sort (table [, comp]) オプションのコンパレータ引数に基づいてテーブルをソートします。

上記の関数のサンプルを見てみましょう。

テーブル連結

以下に示すように、concat関数を使用して2つのテーブルを連結できます-

fruits = {"banana","orange","apple"}

-- returns concatenated string of table
print("Concatenated string ",table.concat(fruits))

--concatenate with a character
print("Concatenated string ",table.concat(fruits,", "))

--concatenate fruits based on index
print("Concatenated string ",table.concat(fruits,", ", 2,3))

上記のプログラムを実行すると、次の出力が得られます-

Concatenated string     bananaorangeapple
Concatenated string     banana, orange, apple
Concatenated string     orange, apple

挿入と削除

テーブルへのアイテムの挿入と削除は、テーブル操作で最も一般的です。 以下で説明します。

fruits = {"banana","orange","apple"}

-- insert a fruit at the end
table.insert(fruits,"mango")
print("Fruit at index 4 is ",fruits[4])

--insert fruit at index 2
table.insert(fruits,2,"grapes")
print("Fruit at index 2 is ",fruits[2])

print("The maximum elements in table is",table.maxn(fruits))

print("The last element is",fruits[5])

table.remove(fruits)
print("The previous last element is",fruits[5])

上記のプログラムを実行すると、次の出力が得られます-

Fruit at index 4 is     mango
Fruit at index 2 is     grapes
The maximum elements in table is    5
The last element is mango
The previous last element is    nil

テーブルの並べ替え

多くの場合、特定の順序でテーブルをソートする必要があります。 ソート関数は、テーブル内の要素をアルファベット順にソートします。 このサンプルを以下に示します。

fruits = {"banana","orange","apple","grapes"}

for k,v in ipairs(fruits) do
   print(k,v)
end

table.sort(fruits)
print("sorted table")

for k,v in ipairs(fruits) do
   print(k,v)
end

上記のプログラムを実行すると、次の出力が得られます-

1   banana
2   orange
3   apple
4   grapes
sorted table
1   apple
2   banana
3   grapes
4   orange

Lua-モジュール

モジュールとは何ですか？

モジュールは、_require_を使用してロードできるライブラリに似ており、テーブルを含む単一のグローバル名を持っています。 このモジュールは、多数の関数と変数で構成できます。 これらの関数と変数はすべて、名前空間として機能するテーブルにラップされています。 また、適切に動作するモジュールには、必要に応じてこのテーブルを返すために必要な準備があります。

Luaモジュールの専門

モジュールでテーブルを使用すると、さまざまな方法で役立ち、他のLuaテーブルを操作するのと同じ方法でモジュールを操作できます。 モジュールを操作する機能の結果として、他の言語が特別なメカニズムを必要とする追加機能を提供します。 Luaのモジュールのこの無料のメカニズムにより、ユーザーは複数の方法でLuaの関数を呼び出すことができます。 それらのいくつかを以下に示します。

-- Assuming we have a module printFormatter
-- Also printFormatter has a funtion simpleFormat(arg)
-- Method 1
require "printFormatter"
printFormatter.simpleFormat("test")

-- Method 2
local formatter = require "printFormatter"
formatter.simpleFormat("test")

-- Method 3
require "printFormatter"
local formatterFunction = printFormatter.simpleFormat
formatterFunction("test")

上記のサンプルコードでは、特別なコードを追加しなくても、Luaのプログラミングがどれほど柔軟であるかを確認できます。

require関数

Luaは、必要なすべてのモジュールをロードするために_require_と呼ばれる高レベル関数を提供しています。 モジュール上にロードする情報が多すぎるのを避けるため、可能な限りシンプルに保たれます。 require関数は、いくつかの値を定義するコードの塊としてモジュールを想定しています。実際には、関数または関数を含むテーブルです。

例

1つの関数に数学関数がある単純な例を考えてみましょう。 このモジュールをmymathと呼び、ファイル名をmymath.luaとします。 ファイルの内容は次のとおりです-

local mymath =  {}

function mymath.add(a,b)
   print(a+b)
end

function mymath.sub(a,b)
   print(a-b)
end

function mymath.mul(a,b)
   print(a*b)
end

function mymath.div(a,b)
   print(a/b)
end

return mymath

ここで、別のファイル（moduletutorial.luaなど）でこのLuaモジュールにアクセスするには、次のコードセグメントを使用する必要があります。

mymathmodule = require("mymath")
mymathmodule.add(10,20)
mymathmodule.sub(30,20)
mymathmodule.mul(10,20)
mymathmodule.div(30,20)

このコードを実行するには、2つのLuaファイルを同じディレクトリに配置する必要があります。または、パッケージパスにモジュールファイルを配置して、追加のセットアップが必要な場合もあります。 上記のプログラムを実行すると、次の出力が得られます。

30
10
200
1.5

覚えておくべきこと

• モジュールと実行するファイルの両方を同じディレクトリに配置します。
• モジュール名とそのファイル名は同じでなければなりません。
• require関数のモジュールを返すことはベストプラクティスです。したがって、他のタイプの実装を他の場所で見つけることもできますが、モジュールは上記のように実装することが望ましいです。

モジュールを実装する古い方法

package.seeallタイプの実装を使用する古い方法で同じ例を書き換えましょう。 これは、Luaバージョン5.1および5.0で使用されていました。 mymathモジュールを以下に示します。

module("mymath", package.seeall)

function mymath.add(a,b)
   print(a+b)
end

function mymath.sub(a,b)
   print(a-b)
end

function mymath.mul(a,b)
   print(a*b)
end

function mymath.div(a,b)
   print(a/b)
end

moduletutorial.luaのモジュールの使用法を以下に示します。

require("mymath")
mymath.add(10,20)
mymath.sub(30,20)
mymath.mul(10,20)
mymath.div(30,20)

上記を実行すると、同じ出力が得られます。 ただし、古いバージョンのコードを使用することをお勧めします。安全性が低いと想定されます。 Corona SDKのようなプログラミングにLuaを使用する多くのSDKは、これの使用を非推奨にしています。

Lua-メタテーブル

メタテーブルは、キーセットおよび関連するメタメソッドの助けを借りて、アタッチされているテーブルの動作を変更するのに役立つテーブルです。 これらのメタメソッドは、次のような機能を有効にする強力なLua機能です-

• テーブルの演算子への機能の変更/追加。
• メタテーブルで__indexを使用して、キーがテーブルで使用できないときにメタテーブルを検索します。

以下を含むメタテーブルの処理に使用される2つの重要な方法があります-

• * setmetatable（table、metatable）*-このメソッドは、テーブルのメタテーブルを設定するために使用されます。
• * getmetatable（table）*-このメソッドは、テーブルのメタテーブルを取得するために使用されます。

最初に、あるテーブルを別のテーブルのメタテーブルとして設定する方法を見てみましょう。 以下に示します。

mytable = {}
mymetatable = {}
setmetatable(mytable,mymetatable)

上記のコードは、次のように1行で表すことができます。

mytable = setmetatable({},{})

_index

メタテーブルがテーブルで利用できない場合にメタテーブルを検索するためのメタテーブルの簡単な例を以下に示します。

mytable = setmetatable({key1 = "value1"}, {
   __index = function(mytable, key)

      if key == "key2" then
         return "metatablevalue"
      else
         return mytable[key]
      end
   end
})

print(mytable.key1,mytable.key2)

上記のプログラムを実行すると、次の出力が得られます。

value1 metatablevalue

上記の例で何が起こったのかを段階的に説明しましょう。

• ここのテーブルmytableは \ {key1 = "value1"} です。
• メタテーブルは、メタメソッドとして呼び出す__indexの関数を含むmytableに設定されます。 *メタメソッドは、インデックス "key2"を検索するという単純な作業を行い、見つかった場合は "metatablevalue"を返し、そうでない場合は対応するインデックスのmytableの値を返します。

以下に示すように、上記のプログラムの簡易バージョンを作成できます。

mytable = setmetatable({key1 = "value1"},
   { __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)

__newindex

__newindexをメタテーブルに追加するときに、テーブルでキーが使用できない場合、新しいキーの動作はメタメソッドによって定義されます。 メインテーブルでインデックスが使用できない場合にメタテーブルのインデックスが設定される簡単な例を以下に示します。

mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })

print(mytable.key1)

mytable.newkey = "new value 2"
print(mytable.newkey,mymetatable.newkey)

mytable.key1 = "new  value 1"
print(mytable.key1,mymetatable.newkey1)

上記のプログラムを実行すると、次の出力が得られます。

value1
nil new value 2
new  value 1    nil

上記のプログラムを見るとわかるように、メインテーブルにキーが存在する場合は更新されます。 キーがメインテーブルで使用できない場合、そのキーをメタテーブルに追加します。

rawset関数を使用して同じテーブルを更新する別の例を以下に示します。

mytable = setmetatable({key1 = "value1"}, {

   __newindex = function(mytable, key, value)
      rawset(mytable, key, "\""..value.."\"")
   end
})

mytable.key1 = "new value"
mytable.key2 = 4

print(mytable.key1,mytable.key2)

上記のプログラムを実行すると、次の出力が得られます。

new value   "4"

rawsetは、メタテーブルのnewindexを使用せずに値を設定します。 同様に、 indexを使用せずに値を取得するrawgetがあります。

テーブルへのオペレーターの動作の追加

＆plus;を使用して2つのテーブルを結合する簡単な例演算子は以下に示されています-

mytable = setmetatable({ 1, 2, 3 }, {
   __add = function(mytable, newtable)

      for i = 1, table.maxn(newtable) do
         table.insert(mytable, table.maxn(mytable)+1,newtable[i])
      end
      return mytable
   end
})

secondtable = {4,5,6}

mytable = mytable + secondtable

for k,v in ipairs(mytable) do
   print(k,v)
end

上記のプログラムを実行すると、次の出力が得られます。

1   1
2   2
3   3
4   4
5   5
6   6

演算子＆plus;の動作を追加するために、__ addキーがメタテーブルに含まれています。 キーと対応する演算子の表を以下に示します。

Sr.No.	Mode & Description
1	__add* 演算子「＆plus;」の動作を変更します。
2	__sub 演算子「-」の動作を変更します。
3	__mul 演算子「*」の動作を変更します。
4	__div 演算子「/」の動作を変更します。
5	__mod 演算子 '％'の動作を変更します。
6	__unm 演算子「-」の動作を変更します。
7	__concat 演算子「..」の動作を変更します。
8	__eq 演算子「==」の動作を変更します。
9	__lt 演算子「<」の動作を変更します。
10	__le 演算子「⇐」の動作を変更します。

__コール

メソッド呼び出しの動作を追加するには、__ callステートメントを使用します。 メインテーブルの値の合計と、渡されたテーブルを返す簡単な例。

mytable = setmetatable({10}, {
   __call = function(mytable, newtable)
   sum = 0

      for i = 1, table.maxn(mytable) do
         sum = sum + mytable[i]
      end

      for i = 1, table.maxn(newtable) do
         sum = sum + newtable[i]
      end

      return sum
   end
})

newtable = {10,20,30}
print(mytable(newtable))

上記のプログラムを実行すると、次の出力が得られます。

70

__tostring

printステートメントの動作を変更するには、__ tostringメタメソッドを使用できます。 以下に簡単な例を示します。

mytable = setmetatable({ 10, 20, 30 }, {
   __tostring = function(mytable)
   sum = 0

      for k, v in pairs(mytable) do
         sum = sum + v
      end

      return "The sum of values in the table is " .. sum
   end
})
print(mytable)

上記のプログラムを実行すると、次の出力が得られます。

The sum of values in the table is 60

メタテーブルの機能を完全に理解している場合は、使用しなくても非常に複雑な多くの操作を実際に実行できます。 そのため、サンプルで説明されているように、メタテーブルで使用可能なさまざまなオプションを使用してメタテーブルを使用し、独自のサンプルを作成してください。

ルア-コルーチン

前書き

コルーチンは本質的に共同作業であり、2つ以上のメソッドを制御された方法で実行できます。 コルーチンを使用すると、常に1つのコルーチンのみが実行され、この実行中のコルーチンは明示的に中断を要求した場合にのみ実行を中断します。

上記の定義はあいまいに見えるかもしれません。 メインプログラムメソッドとコルーチンの2つのメソッドがあると仮定しましょう。 resume関数を使用してコルーチンを呼び出すと、実行が開始され、yield関数を呼び出すと、実行が中断されます。 繰り返しますが、同じコルーチンは、中断された場所から別の再開関数呼び出しで実行を継続できます。 このプロセスは、コルーチンの実行が終了するまで継続できます。

コルーチンで利用可能な機能

次の表は、Luaのコルーチンで使用可能なすべての関数と、それらに対応する使用を示しています。

Sr.No.	Method & Purpose
1	coroutine.create (f) 関数fで新しいコルーチンを作成し、タイプ「スレッド」のオブジェクトを返します。
2	coroutine.resume (co [, val1, …​]) コルーチンcoを再開し、パラメーターがある場合は渡します。 操作のステータスと、その他のオプションの戻り値を返します。
3	coroutine.running () メインスレッドで呼び出された場合、実行中のコルーチンまたはnilを返します。
4	coroutine.status (co) コルーチンの状態に基づいて、実行中、通常、一時停止、または停止のいずれかの値を返します。
5	coroutine.wrap (f) coroutine.createと同様に、coroutine.wrap関数もコルーチンを作成しますが、コルーチン自体を返す代わりに、呼び出されたときにコルーチンを再開する関数を返します。
6	coroutine.yield (…​) 実行中のコルーチンを一時停止します。 このメソッドに渡されるパラメーターは、再開関数への追加の戻り値として機能します。

例

コルーチンの概念を理解するための例を見てみましょう。

co = coroutine.create(function (value1,value2)
   local tempvar3 = 10
   print("coroutine section 1", value1, value2, tempvar3)

   local tempvar1 = coroutine.yield(value1+1,value2+1)
   tempvar3 = tempvar3 + value1
   print("coroutine section 2",tempvar1 ,tempvar2, tempvar3)

   local tempvar1, tempvar2= coroutine.yield(value1+value2, value1-value2)
   tempvar3 = tempvar3 + value1
   print("coroutine section 3",tempvar1,tempvar2, tempvar3)
   return value2, "end"

end)

print("main", coroutine.resume(co, 3, 2))
print("main", coroutine.resume(co, 12,14))
print("main", coroutine.resume(co, 5, 6))
print("main", coroutine.resume(co, 10, 20))

上記のプログラムを実行すると、次の出力が得られます。

coroutine section 1 3   2   10
main    true    4   3
coroutine section 2 12  nil 13
main    true    5   1
coroutine section 3 5   6   16
main    true    2   end
main    false   cannot resume dead coroutine

上記の例は何をしますか？

前述のように、再開機能を使用して操作を開始し、yield関数を使用して操作を停止します。 また、コルーチンの再開機能によって受信された複数の戻り値があることがわかります。

• まず、コルーチンを作成し、変数名coに割り当てます。コルーチンはパラメーターとして2つの変数を受け取ります。
• 最初の再開関数を呼び出すと、コルーチンの終了まで、値3と2が一時変数value1とvalue2に保持されます。
• これを理解するために、最初は10であるtempvar3を使用しました。これは、コルーチンの実行中はvalue1が3として保持されるため、コルーチンの後続の呼び出しによって13と16に更新されます。
• 最初のcoroutine.yieldは、2つの値4と3を再開関数に返します。これは、yieldステートメントの入力パラメーター3と2を更新することで取得できます。 また、コルーチン実行の真/偽ステータスを受け取ります。
• 上記の例では、コルーチンに関するもう1つのことは、再開呼び出しの次のパラメーターがどのように処理されるかです。変数coroutine.yieldが次の呼び出しparamsを受け取ることがわかります。これは、既存のparam値の保持で新しい操作を実行する強力な方法を提供します。
• 最後に、コルーチン内のすべてのステートメントが実行されると、後続の呼び出しはfalseを返し、応答として「デッドコルーチンを再開できません」ステートメントを返します。

別のコルーチンの例

yield関数とresume関数を使用して、1から5までの数を返す単純なコルーチンを見てみましょう。 利用できない場合はコルーチンを作成するか、既存のコルーチンを再開します。

function getNumber()
   local function getNumberHelper()
      co = coroutine.create(function ()
      coroutine.yield(1)
      coroutine.yield(2)
      coroutine.yield(3)
      coroutine.yield(4)
      coroutine.yield(5)
      end)
      return co
   end

   if(numberHelper) then
      status, number = coroutine.resume(numberHelper);

      if coroutine.status(numberHelper) == "dead" then
         numberHelper = getNumberHelper()
         status, number = coroutine.resume(numberHelper);
      end

      return number
   else
      numberHelper = getNumberHelper()
      status, number = coroutine.resume(numberHelper);
      return number
   end

end

for index = 1, 10 do
   print(index, getNumber())
end

上記のプログラムを実行すると、次の出力が得られます。

1   1
2   2
3   3
4   4
5   5
6   1
7   2
8   3
9   4
10  5

多くの場合、コルーチンとマルチプログラミング言語のスレッドとの比較がありますが、コルーチンはスレッドの同様の機能を備えていますが、一度に1つしか実行されず、同時に実行されないことを理解する必要があります。

特定の情報を一時的に保持することで、ニーズを満たすようにプログラム実行シーケンスを制御します。 コルーチンでグローバル変数を使用すると、コルーチンの柔軟性がさらに高まります。

Lua-ファイルI/O

I/Oライブラリは、Luaのファイルの読み取りと操作に使用されます。 Luaには、暗黙的なファイル記述子と明示的なファイル記述子の2種類のファイル操作があります。

次の例では、サンプルファイルtest.luaを以下に示すように使用します。

-- sample test.lua
-- sample2 test.lua

単純なファイルを開く操作では、次のステートメントを使用します。

file = io.open (filename [, mode])

次の表に、さまざまなファイルモードを示します。

Sr.No.	Mode & Description
1	"r" 読み取り専用モード。既存のファイルが開かれるデフォルトのモードです。
2	"w" 既存のファイルを上書きするか、新しいファイルを作成する書き込み可能モード。
3	"a" 既存のファイルを開く、または追加用の新しいファイルを作成する追加モード。
4	"r+" 既存のファイルの読み取りおよび書き込みモード。
5	"w+" ファイルが存在する場合、または読み取り/書き込み権限で新しいファイルが作成される場合、既存のデータはすべて削除されます。
6	"a+" 既存のファイルを開く、または新しいファイルを作成する読み取りモードを有効にした追加モード。

暗黙的なファイル記述子

暗黙的なファイル記述子は、標準の入力/出力モードを使用するか、単一の入力および単一の出力ファイルを使用します。 暗黙的なファイル記述子の使用例を以下に示します。

-- Opens a file in read
file = io.open("test.lua", "r")

-- sets the default input file as test.lua
io.input(file)

-- prints the first line of the file
print(io.read())

-- closes the open file
io.close(file)

-- Opens a file in append mode
file = io.open("test.lua", "a")

-- sets the default output file as test.lua
io.output(file)

-- appends a word test to the last line of the file
io.write("-- End of the test.lua file")

-- closes the open file
io.close(file)

プログラムを実行すると、test.luaファイルの最初の行の出力が得られます。 このプログラムでは、次の出力が得られました。

-- Sample test.lua

これは、test.luaファイルのステートメントの最初の行でした。 また、「-test.luaファイルの終わり」という行がtest.luaコードの最後の行に追加されます。

上記の例では、io。 "x"メソッドを使用して、暗黙的な記述子がファイルシステムでどのように機能するかを確認できます。 上記の例では、オプションのパラメーターなしでio.read（）を使用しています。 オプションのパラメーターは次のいずれかです。

Sr.No.	Mode & Description
1	"*n" 現在のファイル位置から読み取り、ファイル位置に存在する場合は数値を返し、nilを返します。
2	"*a" 現在のファイル位置からファイルのすべての内容を返します。
3	"*l" 現在のファイル位置から行を読み取り、ファイル位置を次の行に移動します。
4	number 関数で指定されたバイト数を読み取ります。

他の一般的なI/Oメソッドには、

• * io.tmpfile（）*-プログラムが終了すると削除される読み取りおよび書き込み用の一時ファイルを返します。
• * io.type（file）*-入力ファイルに基づいて、ファイル、閉じたファイル、またはnilを返します。
• * io.flush（）*-デフォルトの出力バッファをクリアします。
• * io.lines（オプションのファイル名）*-ファイル名が指定されているか、デフォルトのファイルが使用され、最後に閉じられていない場合に、ファイルをループして最後にファイルを閉じる汎用の_for_ループ反復子を提供しますループ。

明示的なファイル記述子

多くの場合、一度に複数のファイルを操作できる明示的なファイル記述子を使用します。 これらの関数は、暗黙的なファイル記述子に非常に似ています。 ここでは、io.function_nameの代わりにfile：function_nameを使用します。 同じ暗黙的なファイル記述子の例のファイルバージョンの次の例を次に示します。

-- Opens a file in read mode
file = io.open("test.lua", "r")

-- prints the first line of the file
print(file:read())

-- closes the opened file
file:close()

-- Opens a file in append mode
file = io.open("test.lua", "a")

-- appends a word test to the last line of the file
file:write("--test")

-- closes the open file
file:close()

プログラムを実行すると、暗黙的な記述子の例と同様の出力が得られます。

-- Sample test.lua

ファイルを開くモードと外部記述子の読み取りパラメータはすべて、暗黙的なファイル記述子と同じです。

他の一般的なファイル方式には、

• * file：seek（オプションのwhence、オプションのオフセット）*-Whenceパラメーターは「set」、「cur」、または「end」です。 ファイルの先頭から更新されたファイル位置で新しいファイルポインタを設定します。 この関数では、オフセットはゼロベースです。 最初の引数が「設定」されている場合、オフセットはファイルの先頭から測定されます。 「cur」の場合、ファイル内の現在の位置から。または、「終了」の場合はファイルの最後から。 デフォルトの引数値は「cur」と0であるため、現在のファイル位置は引数なしでこの関数を呼び出すことで取得できます。
• * file：flush（）*-デフォルトの出力バッファをクリアします。
• * io.lines（オプションのファイル名）*-ファイル名が指定されているか、デフォルトのファイルが使用され、最後に閉じられていない場合に、ファイルをループして最後にファイルを閉じる汎用の_for_ループ反復子を提供しますループ。

シークメソッドを使用する例を以下に示します。 ファイルの終わりの前の25の位置からカーソルをオフセットします。 読み取り関数は、ファイルの残りをシーク位置から出力します。

-- Opens a file in read
file = io.open("test.lua", "r")

file:seek("end",-25)
print(file:read("*a"))

-- closes the opened file
file:close()

次のような出力が得られます。

sample2 test.lua
--test

Luaファイル操作のすべての機能を知るために、さまざまなモードとパラメーターをすべて試すことができます。

Lua-エラー処理

エラー処理の必要性

実際の操作では、ファイル操作、データベーストランザクション、Webサービス呼び出しなどの複雑な操作が必要になることが多いため、エラー処理は非常に重要です。

どのプログラミングでも、エラー処理には常に要件があります。 エラーには次の2種類があります。

• 構文エラー *実行時エラー

構文エラー

演算子や式などのさまざまなプログラムコンポーネントの不適切な使用により、構文エラーが発生します。 構文エラーの簡単な例を以下に示します。

a == 2

ご存知のように、単一の「等しい」と二重の「等しい」の使用には違いがあります。 他の代わりに一方を使用すると、エラーが発生する可能性があります。 1つの「等しい」は割り当てを指し、二重の「等しい」は比較を指します。 同様に、定義済みの実装方法を持つ式と関数があります。

構文エラーの別の例を以下に示します-

for a= 1,10
   print(a)
end

上記のプログラムを実行すると、次の出力が得られます-

lua: test2.lua:2: 'do' expected near 'print'

Luaインタープリターはランタイムエラーの場合よりも明確にエラーを特定するため、構文エラーはランタイムエラーよりもはるかに簡単に処理できます。 上記のエラーから、Luaの構造に従って、printステートメントの前に_do_ステートメントを追加する必要があることが簡単にわかります。

実行時エラー

実行時エラーが発生した場合、プログラムは正常に実行されますが、入力の誤りや誤った機能の処理により実行時エラーが発生する可能性があります。 実行時エラーを示す簡単な例を以下に示します。

function add(a,b)
   return a+b
end

add(10)

プログラムをビルドすると、正常にビルドされて実行されます。 実行すると、実行時エラーが表示されます。

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
    test2.lua:2: in function 'add'
    test2.lua:5: in main chunk
    [C]: ?

これは、2つの変数を渡さないために発生したランタイムエラーです。* b *パラメータが必要ですが、ここではnilであり、エラーを生成します。

アサートおよびエラー関数

エラーを処理するために、 assert と error の2つの関数をよく使用します。 以下に簡単な例を示します。

local function add(a,b)
   assert(type(a) == "number", "a is not a number")
   assert(type(b) == "number", "b is not a number")
   return a+b
end

add(10)

上記のプログラムを実行すると、次のエラー出力が表示されます。

lua: test2.lua:3: b is not a number
stack traceback:
    [C]: in function 'assert'
    test2.lua:3: in function 'add'
    test2.lua:6: in main chunk
    [C]: ?

• error（message [、level]）*は、最後に呼び出された保護された関数を終了し、エラーメッセージとしてメッセージを返します。 この関数エラーは戻りません。 通常、errorは、メッセージの先頭にエラー位置に関する情報を追加します。 level引数は、エラー位置を取得する方法を指定します。 レベル1（デフォルト）では、エラー位置はエラー関数が呼び出された場所です。 レベル2は、エラーを呼び出した関数が呼び出された場所をエラーに示します。等々。 レベル0を渡すと、エラー位置情報がメッセージに追加されなくなります。

pcallおよびxpcall

Luaプログラミングでは、これらのエラーのスローおよびエラー処理を回避するために、関数pcallまたはxpcallを使用する必要があります。

• pcall（f、arg1、…​）*関数は、保護モードで要求された関数を呼び出します。 関数fでエラーが発生した場合、エラーはスローされません。 エラーのステータスを返すだけです。 pcallを使用した簡単な例を以下に示します。

function myfunction ()
   n = n/nil
end

if pcall(myfunction) then
   print("Success")
else
    print("Failure")
end

上記のプログラムを実行すると、次の出力が得られます。

Failure

• xpcall（f、err）*関数は、要求された関数を呼び出し、エラーハンドラーを設定します。 f内のエラーは伝播されません。代わりに、xpcallはエラーをキャッチし、元のエラーオブジェクトを使用してerr関数を呼び出し、ステータスコードを返します。

xpcallの簡単な例を以下に示します。

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

上記のプログラムを実行すると、次の出力が得られます。

ERROR:  test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

プログラマーとしては、作成するプログラムの適切なエラー処理を確実に行うことが最も重要です。 エラー処理を使用すると、プログラムのユーザーに影響を与えることなく、境界条件を超える予期しない条件を確実に処理できます。

Lua-デバッグ

Luaは、独自のデバッガーを作成するためのすべてのプリミティブ関数を提供するデバッグライブラリを提供します。 組み込みのLuaデバッガーはありませんが、多くのオープンソースの開発者によって作成されたLua用のデバッガーが多数あります。

Luaデバッグライブラリで使用可能な関数は、その使用法とともに次の表にリストされています。

Sr.No.	Method & Purpose
1	debug() デバッグ用のインタラクティブモードに入ります。このモードは、1行にcontのみを入力してEnterキーを押すまでアクティブのままです。 ユーザーは、このモード中に他の機能を使用して変数を検査できます。
2	getfenv(object) オブジェクトの環境を返します。
3	gethook(optional thread) 現在のフック関数、現在のフックマスク、現在のフックカウントの3つの値として、スレッドの現在のフック設定を返します。
4	getinfo(optional thread, function or stack level, optional flag) 関数に関する情報を含むテーブルを返します。 関数を直接指定することも、関数の値として数値を指定することもできます。これは、指定されたスレッドの呼び出しスタックのレベル関数で実行される関数を意味します。レベル0は現在の関数です（getinfo自体）。レベル1は、getinfoを呼び出した関数です。等々。 functionがアクティブな関数の数よりも大きい場合、getinfoはnilを返します。
5	getlocal(optional thread, stack level, local index) スタックのレベルで関数のインデックスlocalを持つローカル変数の名前と値を返します。指定されたインデックスを持つローカル変数がない場合はnilを返し、範囲外のレベルで呼び出されるとエラーを発生させます。
6	getmetatable(value) 指定されたオブジェクトのメタテーブルを返します。メタテーブルがない場合はnilを返します。
7	getregistry() レジストリテーブルを返します。レジストリテーブルは、Cコードで使用して、保存する必要のあるLua値を保存できる事前定義されたテーブルです。
8	getupvalue(function, upvalue index) この関数は、関数funcのインデックスupを持つアップバリューの名前と値を返します。 指定されたインデックスにアップバリューがない場合、関数はnilを返します。
9	setfenv(function or thread or userdata, environment table) 指定されたオブジェクトの環境を指定されたテーブルに設定します。 オブジェクトを返します。
10	sethook(optional thread, hook function, hook mask string with "c" and/or "r" and/or "l", optional instruction count) 指定された関数をフックとして設定します。 文字列マスクと数値カウントは、フックがいつ呼び出されるかを示します。 ここで、c、r、およびlは、Luaが関数内のコードの各行を呼び出し、返す、入力するたびに呼び出されます。
11	setlocal(optional thread, stack level, local index, value) スタックのレベルで関数のインデックスlocalを使用して、値をローカル変数に割り当てます。 この関数は、指定されたインデックスを持つローカル変数が存在しない場合はnilを返し、範囲外のレベルで呼び出されるとエラーを発生させます。 それ以外の場合は、ローカル変数の名前を返します。
12	setmetatable(value, metatable) 指定されたオブジェクトのメタテーブルを指定されたテーブルに設定します（nilの場合もあります）。
13	setupvalue(function, upvalue index, value) この関数は、関数funcのインデックスupを使用して値をupvalueに割り当てます。 指定されたインデックスにアップバリューがない場合、関数はnilを返します。 それ以外の場合、上位値の名前を返します。
14	traceback(optional thread, optional message string, optional level argument) トレースバック付きの拡張エラーメッセージを作成します。

上記のリストはLuaのデバッグ関数の完全なリストであり、多くの場合、上記の関数を使用し、デバッグを容易にするライブラリを使用します。 これらの関数を使用して独自のデバッガを作成することは非常に複雑であり、好ましくありません。 とにかく、デバッグ機能の簡単な使用例が表示されます。

function myfunction ()
   print(debug.traceback("Stack trace"))
   print(debug.getinfo(1))
   print("Stack trace end")

   return 10
end

myfunction ()
print(debug.getinfo(1))

上記のプログラムを実行すると、次のようにスタックトレースが取得されます。

Stack trace
stack traceback:
    test2.lua:2: in function 'myfunction'
    test2.lua:8: in main chunk
    [C]: ?
table: 0054C6C8
Stack trace end

上記のサンプルプログラムでは、デバッグライブラリで使用可能なdebug.trace関数を使用してスタックトレースが出力されます。 debug.getinfoは、関数の現在のテーブルを取得します。

デバッグ-例

多くの場合、デバッグのために関数のローカル変数を知る必要があります。 そのために、getupvalueを使用できます。これらのローカル変数を設定するには、setupvalueを使用します。 この簡単な例を以下に示します。

function newCounter ()
   local n = 0
   local k = 0

   return function ()
      k = n
      n = n + 1
      return n
   end

end

counter = newCounter ()

print(counter())
print(counter())

local i = 1

repeat
   name, val = debug.getupvalue(counter, i)

   if name then
      print ("index", i, name, "=", val)

      if(name == "n") then
         debug.setupvalue (counter,2,10)
      end

      i = i + 1
   end -- if

until not name

print(counter())

上記のプログラムを実行すると、次の出力が得られます。

1
2
index   1   k   =   1
index   2   n   =   2
11

この例では、カウンターは呼び出されるたびに1つずつ更新されます。 getupvalue関数を使用して、ローカル変数の現在の状態を確認できます。 次に、ローカル変数を新しい値に設定します。 ここで、集合演算が呼び出される前のnは2です。 setupvalue関数を使用して、10に更新されます。 これで、counter関数を呼び出すと、3ではなく11が返されます。

デバッグの種類

• コマンドラインデバッグ
• グラフィカルなデバッグ

コマンドラインのデバッグ

コマンドラインデバッグは、コマンドラインとコマンドの出力を使用してデバッグするためにコマンドラインを使用するデバッグの一種です。 Luaで使用できるコマンドラインデバッガは多数ありますが、そのうちのいくつかを以下に示します。

• RemDebug -RemDebugは、Lua 5.0および5.1用のリモートデバッガーです。 別のLuaプログラムの実行をリモートで制御して、ブレークポイントを設定し、プログラムの現在の状態を検査できます。 RemDebugは、CGILuaスクリプトもデバッグできます。
• clidebugger -純粋なLuaで書かれたLua 5.1用のシンプルなコマンドラインインターフェイスデバッガー。 標準のLua 5.1ライブラリ以外には依存していません。 RemDebugに触発されましたが、リモート機能はありません。
• ctrace -Lua API呼び出しをトレースするためのツール。
• xdbLua -Windowsプラットフォーム用のシンプルなLuaコマンドラインデバッガー。
• * LuaInterface-デバッガ*-このプロジェクトは、LuaInterfaceのデバッガ拡張機能です。 組み込みのLuaデバッグインターフェイスをより高いレベルに引き上げます。 デバッガーとの対話は、イベントとメソッド呼び出しによって行われます。
• Rldb -これはソケット経由のリモートLuaデバッガーで、WindowsとLinuxの両方で使用できます。 既存の機能よりもはるかに多くの機能を提供できます。
• ModDebug -これにより、別のLuaプログラムの実行をリモートで制御し、ブレークポイントを設定し、プログラムの現在の状態を検査できます。

グラフィカルなデバッグ

グラフィカルなデバッグは、変数値、スタックトレース、その他の関連情報など、さまざまな状態の視覚的なデバッグを提供するIDEの助けを借りて利用できます。 IDEには、ブレークポイント、ステップイン、ステップオーバー、およびその他のボタンを使用して、視覚的な表現とステップごとの実行制御があります。

Luaには多くのグラフィカルデバッガがあり、次のものが含まれています。

• * SciTE-LuaのデフォルトのWindows IDEは、ブレークポイント、ステップ、ステップイン、ステップオーバー、変数の監視などの複数のデバッグ機能を提供します。
• Decoda -これは、リモートデバッグをサポートするグラフィカルデバッガーです。
• ZeroBrane Studio -リモートデバッガー、スタックビュー、ウォッチビュー、リモートコンソール、静的アナライザーなどが統合されたLua IDE。 LuaJIT、Love2d、Moai、およびその他のLuaエンジンで動作します。 Windows、OSX、およびLinux。 オープンソース。
• akdebugger -Eclipse用のデバッガーおよびエディターLuaプラグイン。
• luaedit -リモートデバッグ、ローカルデバッグ、構文の強調表示、完了提案リスト、パラメーター提案エンジン、高度なブレークポイント管理（ブレークポイントとヒットカウントの条件システムを含む）、関数リスト、グローバルおよびローカル変数リスト、ウォッチ、ソリューション指向管理。

ルア-ガベージコレクション

Luaは、Luaに組み込まれている特定のアルゴリズムに基づいてガベージコレクションを使用する自動メモリ管理を使用します。 開発者として、自動メモリ管理の結果として-

• オブジェクトにメモリを割り当てることを心配する必要はありません。
• nilに設定する以外は、不要になったときに解放する必要はありません。

Luaは、時々実行されるガベージコレクターを使用して、Luaプログラムからアクセスできなくなったデッドオブジェクトを収集します。

テーブル、ユーザーデータ、関数、スレッド、文字列などを含むすべてのオブジェクトは、自動メモリ管理の対象です。 Luaは、2つの数値を使用して、ガベージコレクションサイクルを制御する増分マークアンドスイープコレクタを使用します。つまり、 garbage collector pause および garbage collector step multiplier です。 これらの値はパーセンテージであり、100の値は内部的に1に等しいことがよくあります。

ガベージコレクターの一時停止

ガベージコレクタの一時停止は、ガベージコレクタが待機する時間を制御するために使用されます。 Luaの自動メモリ管理によって再び呼び出されます。 100未満の値は、Luaが次のサイクルを待たないことを意味します。 同様に、この値を大きくすると、ガベージコレクターの速度が遅くなり、攻撃性が低下します。 値200は、コレクターが、使用中の合計メモリーが2倍になるのを待ってから、新しいサイクルを開始することを意味します。 したがって、アプリケーションの性質と速度によっては、Luaアプリケーションで最高のパフォーマンスを得るためにこの値を変更する必要がある場合があります。

ガベージコレクターのステップ乗算器

このステップ乗数は、ガベージコレクターとLuaプログラムのメモリ割り当ての相対速度を制御します。 ステップ値を大きくすると、ガベージコレクタがより積極的になり、ガベージコレクションの各増分ステップのステップサイズも大きくなります。 100未満の値は、多くの場合、ガベージコレクターがそのサイクルを完了しないことを回避する可能性があり、一般的には優先されません。 デフォルト値は200です。これは、ガベージコレクタがメモリ割り当ての2倍の速度で実行されることを意味します。

ガベージコレクター関数

開発者として、Luaの自動メモリ管理をある程度制御できます。 このために、次のメソッドがあります。

• * collectgarbage（ "collect"）*-ガベージコレクションの完全な1サイクルを実行します。
• * collectgarbage（ "count"）*-プログラムが現在使用しているメモリ量をキロバイト単位で返します。
• * collectgarbage（ "restart"）*-ガベージコレクターが停止している場合は、再起動します。
• * collectgarbage（ "setpause"）*-2番目のパラメーターを100で割った値をガベージコレクターのポーズ変数に設定します。 その使用法は、上記で少し説明したとおりです。
• * collectgarbage（ "setstepmul"）*-2番目のパラメーターを100で割った値をガベージステップ乗数変数に設定します。 その使用法は、上記で少し説明したとおりです。
• * collectgarbage（ "step"）*-ガベージコレクションの1ステップを実行します。 2番目の引数が大きいほど、このステップは大きくなります。 トリガーされたステップがガベージコレクションサイクルの最後のステップであった場合、collectgarbageはtrueを返します。
• * collectgarbage（ "stop"）*-ガベージコレクターが実行中の場合は停止します。

ガベージコレクターの例を使用した簡単な例を以下に示します。

mytable = {"apple", "orange", "banana"}

print(collectgarbage("count"))

mytable = nil

print(collectgarbage("count"))

print(collectgarbage("collect"))

print(collectgarbage("count"))

上記のプログラムを実行すると、次の出力が得られます。 この結果は、オペレーティングシステムのタイプの違いとLuaの自動メモリ管理機能により異なることに注意してください。

23.1455078125   149
23.2880859375   295
0
22.37109375     380

上記のプログラムを見るとわかるように、ガベージコレクションが完了すると、使用されるメモリが削減されます。 しかし、これを呼び出すことは必須ではありません。 それらを呼び出さなくても、事前定義された期間の後、Luaインタープリターによって後の段階で自動的に実行されます。

明らかに、必要に応じてこれらの関数を使用してガベージコレクターの動作を変更できます。 これらの関数は、開発者が複雑な状況を処理するための少しの追加機能を提供します。 プログラムに必要なメモリのタイプに応じて、この機能を使用する場合と使用しない場合があります。 ただし、アプリケーションのメモリ使用量を把握し、プログラミング中に確認して展開後の望ましくない結果を回避することは非常に役立ちます。

Lua-オブジェクト指向

OOPの概要

オブジェクト指向プログラミング（OOP）は、現代のプログラミング時代に使用される最も使用されているプログラミング手法の1つです。 OOPをサポートする多くのプログラミング言語があります。

• C++
• Java
• Objective-C
• スモールトーク
• C#
• Ruby

OOPの機能

• クラス-クラスは、オブジェクトを作成するための拡張可能なテンプレートであり、状態の初期値（メンバー変数）と動作の実装を提供します。
• オブジェクト-それはクラスのインスタンスであり、それ自体に割り当てられた個別のメモリを持っています。
• 継承-それは、あるクラスの変数と関数が別のクラスに継承される概念です。
• *カプセル化-それはクラス内のデータと機能を組み合わせるプロセスです。 関数の助けを借りて、クラスの外部でデータにアクセスできます。 データ抽象化とも呼ばれます。

LuaのOOP

Luaのテーブルとファーストクラス関数を使用して、Luaにオブジェクト指向を実装できます。 関数と関連データをテーブルに配置することにより、オブジェクトが形成されます。 継承はメタテーブルの助けを借りて実装でき、存在しない関数（メソッド）および親オブジェクトのフィールドのルックアップメカニズムを提供します。

Luaのテーブルには、その値に依存しない状態やアイデンティティなどのオブジェクトの機能があります。 同じ値を持つ2つのオブジェクト（テーブル）は異なるオブジェクトです。一方、オブジェクトは異なる時間に異なる値を持つことができますが、常に同じオブジェクトです。 オブジェクトと同様に、テーブルには、誰が作成したか、どこで作成されたかに依存しないライフサイクルがあります。

実世界の例

オブジェクト指向の概念は広く使用されていますが、適切かつ最大の利益を得るためには明確に理解する必要があります。

簡単な数学の例を考えてみましょう。 多くの場合、円、長方形、正方形などのさまざまな形状で作業する状況に遭遇します。

シェイプには、共通のプロパティエリアを含めることができます。 そのため、共通プロパティエリアを使用して、ベースオブジェクトシェイプから他のシェイプを拡張できます。 各図形には独自のプロパティと関数を設定できます。たとえば、長方形はプロパティとして長さ、幅、面積、および関数としてprintAreaとCalculateAreaを設定できます。

単純なクラスを作成する

3つのプロパティarea、length、およびwidthを持つ長方形の単純なクラス実装を以下に示します。 また、計算された面積を印刷するprintArea関数もあります。

-- Meta class
Rectangle = {area = 0, length = 0, breadth = 0}

-- Derived class method new

function Rectangle:new (o,length,breadth)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   self.length = length or 0
   self.breadth = breadth or 0
   self.area = length*breadth;
   return o
end

-- Derived class method printArea

function Rectangle:printArea ()
   print("The area of Rectangle is ",self.area)
end

オブジェクトを作成する

オブジェクトの作成は、クラスインスタンスにメモリを割り当てるプロセスです。 各オブジェクトには独自のメモリがあり、共通のクラスデータを共有します。

r = Rectangle:new(nil,10,20)

プロパティへのアクセス

以下に示すように、ドット演算子を使用してクラスのプロパティにアクセスできます-

print(r.length)

メンバー関数へのアクセス

以下に示すように、オブジェクトでコロン演算子を使用してメンバー関数にアクセスできます-

r:printArea()

メモリが割り当てられ、初期値が設定されます。 初期化プロセスは、他のオブジェクト指向言語のコンストラクターと比較できます。 上記のように値を設定できる機能に他なりません。

完全な例

Luaでオブジェクトの向きを使用した完全な例を見てみましょう。

-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

-- Creating an object
myshape = Shape:new(nil,10)

myshape:printArea()

上記のプログラムを実行すると、次の出力が得られます。

The area is     100

Luaの継承

継承とは、形状のような単純な基本オブジェクトを長方形や正方形などに拡張するプロセスです。 現実の世界では、基本的なプロパティと機能を共有および拡張するためによく使用されます。

簡単なクラス拡張を見てみましょう。 以下に示すクラスがあります。

-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

以下に示すように、形状を正方形のクラスに拡張できます。

Square = Shape:new()

-- Derived class method new

function Square:new (o,side)
   o = o or Shape:new(o,side)
   setmetatable(o, self)
   self.__index = self
   return o
end

基本関数のオーバーライド

基本クラスの関数を使用する代わりに、基本クラスの関数をオーバーライドできます。派生クラスは、以下に示すように独自の実装を持つことができます-

-- Derived class method printArea

function Square:printArea ()
   print("The area of square is ",self.area)
end

継承の完全な例

上記のように、メタテーブルの助けを借りた別の新しいメソッドの助けを借りて、Luaの単純なクラス実装を拡張できます。 基本クラスのすべてのメンバー変数と関数は、派生クラスに保持されます。

-- Meta class
Shape = {area = 0}

-- Base class method new

function Shape:new (o,side)
   o = o or {}
   setmetatable(o, self)
   self.__index = self
   side = side or 0
   self.area = side*side;
   return o
end

-- Base class method printArea

function Shape:printArea ()
   print("The area is ",self.area)
end

-- Creating an object
myshape = Shape:new(nil,10)
myshape:printArea()

Square = Shape:new()

-- Derived class method new

function Square:new (o,side)
   o = o or Shape:new(o,side)
   setmetatable(o, self)
   self.__index = self
   return o
end

-- Derived class method printArea

function Square:printArea ()
   print("The area of square is ",self.area)
end

-- Creating an object
mysquare = Square:new(nil,10)
mysquare:printArea()

Rectangle = Shape:new()

-- Derived class method new

function Rectangle:new (o,length,breadth)
   o = o or Shape:new(o)
   setmetatable(o, self)
   self.__index = self
   self.area = length * breadth
   return o
end

-- Derived class method printArea

function Rectangle:printArea ()
    print("The area of Rectangle is ",self.area)
end

-- Creating an object

myrectangle = Rectangle:new(nil,10,20)
myrectangle:printArea()

上記のプログラムを実行すると、次の出力が得られます-

The area is     100
The area of square is   100
The area of Rectangle is    200

上記の例では、基本クラスSquareからRectangleとSquareの2つの派生クラスを作成しました。 派生クラスで基本クラスの機能をオーバーライドできます。 この例では、派生クラスは関数printAreaをオーバーライドします。

Lua-Webプログラミング

Luaは柔軟性の高い言語であり、多くの場合、Webアプリケーションを含む複数のプラットフォームで使用されます。 LuaでオープンソースWebコンポーネントを提供するために2004年に形成されたKeplerコミュニティ。

Luaを使用して開発されたWebフレームワークは他にもありますが、主にKeplerコミュニティが提供するコンポーネントに焦点を当てます。

アプリケーションとフレームワーク

• Orbit は、WSAPIに基づいたLua用のMVC Webフレームワークです。
• WSAPI は、Lua WebアプリケーションからWebホストサーバーを抽象化するAPIであり、多くのプロジェクトのベースです。
• Xavante は、WSAPIインターフェースを提供するLua Webサーバーです。
• Sputnik は、ユーモアとエンターテイメントに使用されるKeplerプロジェクトでWSAPIを使用して開発されたwiki/CMSです。
• CGILua は、WSAPIに基づいたLuaPagesおよびLuaScriptsのWebページ作成を提供しますが、サポートされなくなりました。 代わりに、Orbit、Sputnik、またはWSAPIを使用してください。

このチュートリアルでは、Luaでできることを理解し、そのインストールと使用方法について詳しく知るために、ウェブサイトのkeplerを参照します。

軌道

Orbitは、Lua用のMVC Webフレームワークです。 各スクリプトは単一のファイルに収めることができますが、必要に応じて複数のファイルに分割できます。

すべてのOrbitアプリケーションはWSAPIプロトコルに準拠しているため、現在はXavante、CGI、およびFastcgiで動作します。 開発用にXavanteインスタンスを簡単に起動できるランチャーが含まれています。

Orbitをインストールする最も簡単な方法は、LuaRocksを使用することです。 Luarocks install orbitは、インストール用のコマンドです。 このためには、最初にhttp://luarocks.org/en/Download[LuaRocks]をインストールする必要があります。

すべての依存関係をインストールしていない場合は、Unix/Linux環境でOrbitをセットアップする手順を以下に示します。

Apacheのインストール

サーバーに接続します。 Apache2をインストールし、そのサポートモジュールを使用して、必要なApache2モジュールを有効にします-

$ sudo apt-get install apache2 libapache2-mod-fcgid libfcgi-dev build-essential
$ sudo a2enmod rewrite
$ sudo a2enmod fcgid
$ sudo/etc/init.d/apache2 force-reload

LuaRocksをインストールする

$ sudo apt-get install luarocks

WSAPI、FCGI、Orbit、およびXavanteをインストールします

$ sudo luarocks install orbit
$ sudo luarocks install wsapi-xavante
$ sudo luarocks install wsapi-fcgi

Apache2のセットアップ

$ sudo raj/etc/apache2/sites-available/default

構成ファイルの<Directory/var/www/>セクションの下に、この次のセクションを追加します。 このセクションに「AllowOverride None」がある場合は、「None」を「All」に変更して、.htaccessファイルが構成をローカルでオーバーライドできるようにする必要があります。

<IfModule mod_fcgid.c>

   AddHandler fcgid-script .lua
   AddHandler fcgid-script .ws
   AddHandler fcgid-script .op

   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .ws
   FCGIWrapper "/usr/local/bin/wsapi.fcgi" .lua
   FCGIWrapper "/usr/local/bin/op.fcgi" .op

   #FCGIServer "/usr/local/bin/wsapi.fcgi" -idle-timeout 60 -processes 1
   #IdleTimeout 60
   #ProcessLifeTime 60

</IfModule>

サーバーを再起動して、変更を有効にします。

アプリケーションを有効にするには、Orbitアプリケーションのルートにある.htaccessファイル（この場合は/var/www）に+ ExecCGIを追加する必要があります。

Options +ExecCGI
DirectoryIndex index.ws

簡単な例-軌道

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

-- declaration
module("myorbit", package.seeall, orbit.new)

-- handler

function index(web)
   return my_home_page()
end

-- dispatch
myorbit:dispatch_get(index, "/", "/index")

-- Sample page

function my_home_page()

   return [[head></head>
      <html>
         <h2>First Page</h2>
      </html>
   ]]

end

これで、Webブラウザを起動できるはずです。 http：//localhost：8080/にアクセスすると、次の出力が表示されます-

First Page

Orbitは別のオプションを提供します。つまり、Luaコードでhtmlを生成できます。

#!/usr/bin/env index.lua

-- index.lua
require"orbit"

function generate()
   return html {
      head{title "HTML Example"},

      body{
         h2{"Here we go again!"}
      }
   }
end

orbitlify(generate)

print(generate())

フォームを作成する

簡単なフォームの例を以下に示します-

#!/usr/bin/env index.lua
require"orbit"

function wrap (inner)
   return html{ head(), body(inner) }
end

function test ()
   return wrap(form (H'table' {
      tr{td"First name",td( input{type = 'text', name='first'})},
      tr{td"Second name",td(input{type = 'text', name='second'})},
      tr{ td(input{type = 'submit', value = 'Submit!'}),
         td(input{type = 'submit',value = 'Cancel'})
      },
   }))
end

orbitlify(wrap,test)

print(test())

WSAPI

前述のように、WSAPIは多くのプロジェクトのベースとして機能し、複数の機能が組み込まれています。 WSAPIを使用して、次のプラットフォームをサポートできます。

• Windows
• UNIXベースのシステム

WSAPIがサポートするサーバーとインターフェースには、

• CGI
• FastCGI
• ザバンテ

WSAPIは多くのライブラリを提供します。これにより、Luaを使用したWebプログラミングが容易になります。 Luaでサポートされている機能の一部には、

• リクエスト処理
• 出力バッファリング
• 認証
• ファイルのアップロード
• リクエストの分離
• 多重化

WSAPIの簡単な例を以下に示します-

#!/usr/bin/env wsapi.cgi

module(..., package.seeall)
function run(wsapi_env)
   local headers = { ["Content-type"] = "text/html" }

   local function hello_text()
      coroutine.yield("<html><body&gt")
      coroutine.yield("<p&gtHello Wsapi!</p&gt")
      coroutine.yield("<p&gtPATH_INFO: " .. wsapi_env.PATH_INFO .. "</p&gt")
      coroutine.yield("<p&gtSCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p&gt")
      coroutine.yield("</body&gt</html&gt")
   end

   return 200, headers, coroutine.wrap(hello_text)
end

上記のコードでは、単純なhtmlページが形成されて返されています。 コルーチンの使用法を見ると、ステートメントごとに呼び出し関数にステートメントを返すことができます。 最後に、htmlステータスコード（200）、ヘッダー、およびhtmlページが返されます。

ザバンテ

Xavanteは、URIマッピングハンドラーに基づくモジュラーアーキテクチャを使用するLua HTTP 1.1 Webサーバーです。 Xavanteは現在、

• ファイルハンドラー
• リダイレクトハンドラー
• WSAPIハンドラー

ファイルハンドラは一般的なファイルに使用されます。 リダイレクトハンドラにより、WSAPIアプリケーションを処理するためのURI再マッピングとWSAPIハンドラが有効になります。

以下に簡単な例を示します。

require "xavante.filehandler"
require "xavante.cgiluahandler"
require "xavante.redirecthandler"

-- Define here where Xavante HTTP documents scripts are located
local webDir = XAVANTE_WEB

local simplerules = {

   { -- URI remapping example
      match = "^[^%./]*/$",
      with = xavante.redirecthandler,
      params = {"index.lp"}
   },

   { -- cgiluahandler example
      match = {"%.lp$", "%.lp/.*$", "%.lua$", "%.lua/.*$" },
      with = xavante.cgiluahandler.makeHandler (webDir)
   },

   { -- filehandler example
      match = ".",
      with = xavante.filehandler,
      params = {baseDir = webDir}
   },
}

xavante.HTTP{
   server = {host = "*", port = 8080},

   defaultHost = {
      rules = simplerules
   },
}

Xavanteで仮想ホストを使用するには、xavante.HTTPの呼び出しを次のように変更します-

xavante.HTTP{
   server = {host = "*", port = 8080},

   defaultHost = {},

   virtualhosts = {
      ["www.sitename.com"] = simplerules
   }
}

Lua Webコンポーネント

• Copas 、TCP/IPサーバーで使用できるコルーチンに基づくディスパッチャー。
• Cosmo 、テンプレート内の任意のコードからアプリケーションを保護する「安全なテンプレート」エンジン。
• Coxpcall は、Luaネイティブのpcallとxpcallをコルーチンと互換性のあるものでカプセル化します。
• LuaFileSystem 、基礎となるディレクトリ構造とファイル属性にアクセスするためのポータブルな方法。
• リング、Lua内から新しいLua状態を作成する方法を提供するライブラリ。

エンディングノート

非常に多くのLuaベースのWebフレームワークとコンポーネントが利用可能であり、必要に応じて選択できます。 以下を含む利用可能な他のWebフレームワークがあります-

• Moonstalk は、Lua言語で構築された動的に生成されたWebベースのプロジェクトの効率的な開発とホスティングを可能にします。基本的なページから複雑なアプリケーションまで。
• Lapis 、MoonScript（またはLua）を使用してWebアプリケーションを構築するためのフレームワーク。OpenRestyと呼ばれるNginxのカスタマイズバージョン内で実行されます。
• Lua Server Pages は、組み込みWeb開発への他のアプローチを吹き飛ばすLuaスクリプトエンジンプラグインで、従来のCサーバーページに劇的なショートカットを提供します。

これらのWebフレームワークは、Webアプリケーションを活用して、強力な操作を行うのに役立ちます。

Lua-データベースアクセス

単純なデータ操作の場合、ファイルを使用できますが、これらのファイル操作は効率的で、スケーラブルで、強力ではない場合があります。 この目的のために、データベースの使用に切り替えることがよくあります。 LuaSQLは、Luaから多数のデータベース管理システムへのシンプルなインターフェイスです。 LuaSQLは、さまざまなタイプのSQLのサポートを提供するライブラリです。 これには、

• SQLite
• MySQL
• ODBC

このチュートリアルでは、LuaでのMySQLとSQLiteのデータベース処理について説明します。 これは両方に汎用インターフェースを使用し、この実装を他のタイプのデータベースにも移植できるはずです。 まず、MySQLで操作を実行する方法を見てみましょう。

MySQLデータベースのセットアップ

次の例を使用して期待どおりに動作させるには、dbの初期セットアップが必要です。 前提は以下のとおりです。

• デフォルトのユーザーをルートとして、パスワードを「123456」としてMySQLをインストールしてセットアップしました。
• データベーステストを作成しました。
• リンクを理解するためにMySQLチュートリアルを完了しました：/mysql/index [MySQL Basics。]

MySQLのインポート

Luaの実装が正しく行われていると仮定して、単純な require ステートメントを使用してsqliteライブラリをインポートできます。

mysql = require "luasql.mysql"

変数mysqlは、メインmysqlテーブルを参照することにより、関数へのアクセスを提供します。

接続のセットアップ

MySQL環境を開始し、その環境の接続を作成することにより、接続をセットアップできます。 以下に示します。

local env  = mysql.mysql()
local conn = env:connect('test','root','123456')

上記の接続は既存のMySQLファイルに接続し、新しく作成されたファイルとの接続を確立します。

関数を実行する

接続には、作成、挿入、削除、更新などのすべてのdb操作を実行するのに役立つ単純な実行関数があります。 構文は次のとおりです-

conn:execute([[MySQLSTATEMENT' ]])

上記の構文では、connが開いていることと既存のMySQL接続を確認し、「MySQLSTATEMENT」を正しいステートメントに置き換える必要があります。

テーブル作成の例

簡単なテーブル作成の例を以下に示します。 タイプintegerのidとタイプvarcharの2つのパラメーターを持つテーブルを作成します。

mysql = require "luasql.mysql"

local env  = mysql.mysql()
local conn = env:connect('test','root','123456')

print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample2 (id INTEGER, name TEXT);]])
print(status,errorString )

上記のプログラムを実行すると、sampleという名前のテーブルが作成され、idとnameという2つの列が作成されます。

MySQL environment (004BB178)    MySQL connection (004BE3C8)
0   nil

エラーが発生した場合、nilの代わりにエラーステートメントが返されます。 簡単なエラーステートメントを以下に示します。

LuaSQL: Error executing query. MySQL: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"id INTEGER, name TEXT)' at line 1

ステートメントの挿入の例

MySQLの挿入ステートメントを以下に示します。

conn:execute([[INSERT INTO sample values('11','Raj')]])

更新ステートメントの例

MySQLの更新ステートメントを以下に示します。

conn:execute([[UPDATE sample3 SET name='John' where id ='12']])

ステートメントの削除の例

MySQLの削除ステートメントを以下に示します。

conn:execute([[DELETE from sample3 where id ='12']])

Selectステートメントの例

selectステートメントに関する限り、各行をループして必要なデータを抽出する必要があります。 簡単な選択ステートメントを以下に示します。

cursor,errorString = conn:execute([[select *from sample]])
row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   -- reusing the table of results
   row = cursor:fetch (row, "a")
end

上記のコードでは、connはオープンなMySQL接続です。 実行ステートメントによって返されるカーソルの助けを借りて、テーブル応答をループし、必要な選択データをフェッチできます。

完全な例

上記のすべてのステートメントを含む完全な例を以下に示します。

mysql = require "luasql.mysql"

local env  = mysql.mysql()
local conn = env:connect('test','root','123456')
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample3 (id INTEGER, name TEXT)]])
print(status,errorString )

status,errorString = conn:execute([[INSERT INTO sample3 values('12','Raj')]])
print(status,errorString )

cursor,errorString = conn:execute([[select* from sample3]])
print(cursor,errorString)

row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   row = cursor:fetch (row, "a")
end

-- close everything
cursor:close()
conn:close()
env:close()

上記のプログラムを実行すると、次の出力が得られます。

MySQL environment (0037B178)    MySQL connection (0037EBA8)
0   nil
1   nil
MySQL cursor (003778A8) nil
Id: 12, Name: Raj

トランザクションの実行

トランザクションは、データの一貫性を保証するメカニズムです。 トランザクションには、次の4つのプロパティが必要です-

• Atomicity -トランザクションが完了するか、まったく何も起こりません。
• 一貫性-トランザクションは一貫した状態で開始し、システムを一貫した状態のままにする必要があります。
• 分離-トランザクションの中間結果は、現在のトランザクションの外部では見えません。
• 耐久性-トランザクションがコミットされると、システム障害が発生した後でも効果は持続します。

トランザクションはSTART TRANSACTIONで始まります。コミットまたはロールバックステートメントで終了します。

トランザクション開始

トランザクションを開始するには、connが開いているMySQL接続であると仮定して、Luaで次のステートメントを実行する必要があります。

conn:execute([[START TRANSACTION;]])

ロールバックトランザクション

start transactionの実行後に行われた変更をロールバックするには、次のステートメントを実行する必要があります。

conn:execute([[ROLLBACK;]])

トランザクションのコミット

start transactionの実行後に行われた変更をコミットするには、次のステートメントを実行する必要があります。

conn:execute([[COMMIT;]])

上記でMySQLについて知っており、次のセクションでは基本的なSQL操作について説明します。 トランザクションを覚えてください。ただし、SQLite3については再度説明しませんが、SQLite3でも同じステートメントが機能するはずです。

SQLiteのインポート

Luaの実装が正しく行われていると仮定して、単純なrequireステートメントを使用してSQLiteライブラリをインポートできます。 インストール中に、データベース関連ファイルを含むフォルダーlibsql。

sqlite3 = require "luasql.sqlite3"

変数sqlite3は、メインのsqlite3テーブルを参照することにより、関数へのアクセスを提供します。

接続のセットアップ

SQLite環境を開始し、その環境の接続を作成することにより、接続をセットアップできます。 以下に示します。

local env  = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')

上記の接続は、既存のSQLiteファイルに接続するか、新しいSQLiteファイルを作成し、新しく作成されたファイルとの接続を確立します。

関数を実行する

接続には、作成、挿入、削除、更新などのすべてのdb操作を実行するのに役立つ単純な実行関数があります。 構文は次のとおりです-

conn:execute([[SQLite3STATEMENT' ]])

上記の構文では、connが開いていることと既存のsqlite3接続を確認し、「SQLite3STATEMENT」を正しいステートメントに置き換える必要があります。

テーブル作成の例

簡単なテーブル作成の例を以下に示します。 タイプintegerのidとタイプvarcharの2つのパラメーターを持つテーブルを作成します。

sqlite3 = require "luasql.sqlite3"

local env  = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample ('id' INTEGER, 'name' TEXT)]])
print(status,errorString )

上記のプログラムを実行すると、sampleという名前のテーブルが作成され、idとnameという2つの列が作成されます。

SQLite3 environment (003EC918)  SQLite3 connection (00421F08)
0   nil

エラーが発生した場合、nilの代わりにエラーステートメントが返されます。 簡単なエラーステートメントを以下に示します。

LuaSQL: unrecognized token: ""'id' INTEGER, 'name' TEXT)"

ステートメントの挿入の例

SQLiteの挿入ステートメントを以下に示します。

 conn:execute([[INSERT INTO sample values('11','Raj')]])

Selectステートメントの例

selectステートメントに関する限り、各行をループして必要なデータを抽出する必要があります。 簡単な選択ステートメントを以下に示します。

cursor,errorString = conn:execute([[select *from sample]])
row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   -- reusing the table of results
   row = cursor:fetch (row, "a")
end

上記のコードでは、connはオープンなsqlite3接続です。 実行ステートメントによって返されるカーソルの助けを借りて、テーブル応答をループし、必要な選択データをフェッチできます。

完全な例

上記のすべてのステートメントを含む完全な例を以下に示します。

sqlite3 = require "luasql.sqlite3"

local env  = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
print(env,conn)

status,errorString = conn:execute([[CREATE TABLE sample ('id' INTEGER, 'name' TEXT)]])
print(status,errorString )

status,errorString = conn:execute([[INSERT INTO sample values('1','Raj')]])
print(status,errorString )

cursor,errorString = conn:execute([[select* from sample]])
print(cursor,errorString)

row = cursor:fetch ({}, "a")

while row do
   print(string.format("Id: %s, Name: %s", row.id, row.name))
   row = cursor:fetch (row, "a")
end

-- close everything
cursor:close()
conn:close()
env:close()

上記のプログラムを実行すると、次の出力が得られます。

SQLite3 environment (005EC918)  SQLite3 connection (005E77B0)
0   nil
1   nil
SQLite3 cursor (005E9200)   nil
Id: 1, Name: Raj

このlibsqlライブラリを使用して、利用可能なすべてのクエリを実行できます。 したがって、これらの例にとどまらないでください。 それぞれのMySQL、SQLite3、およびLuaでサポートされている他のデータベースで利用可能なさまざまなクエリステートメントを実験します。

Lua-ゲームプログラミング

Luaは、その単純な言語構造と構文のため、多くのゲームエンジンで使用されています。 ガベージコレクション機能は、リッチグラフィックスが使用されているために多くのメモリを消費するゲームで非常に便利です。 Luaを使用するゲームエンジンには次のものが含まれます-

• Corona SDK
• Gideros Mobile
• ShiVa3D
• モアイSDK
• LOVE
• 泣くエンジン

これらの各ゲームエンジンはLuaに基づいており、これらの各エンジンには豊富なAPIセットが用意されています。 それぞれの機能について簡単に説明します。

Corona SDK

Corona SDKは、iPhone、iPad、およびAndroidプラットフォームをサポートするクロスプラットフォームモバイルゲームエンジンです。 機能が制限されている小さなゲームに使用できるCorona SDKの無料バージョンがあります。 必要に応じて、他のバージョンにアップグレードできます。

Corona SDKは、以下を含む多くの機能を提供します-

• 物理学および衝突処理API
• WebおよびネットワークAPI
• ゲームネットワークAPI
• Ads API
• 分析API
• データベースおよびファイルシステムAPI
• 暗号および数学API
• オーディオおよびメディアAPI

iOSとAndroidでネイティブAPIを別々に使用するよりも、上記のAPIを使用してアプリケーションを開発する方が簡単で高速です。

Gideros Mobile

Giderosは、iOSおよびAndroid向けのゲームを作成するためのクロスプラットフォームSDKを提供します。 Giderosスプラッシュで作られたもので自由に使用できます。 ジデオロスの顕著な利点には、次のものが含まれます-

• *開発IDE *-Giderosアプリの開発を容易にする独自のIDEを提供します。
• インスタントテスト-ゲームの開発中、Wifiを介して実際のデバイスでわずか1秒でテストできます。 エクスポートまたは展開プロセスで時間を無駄にする必要はありません。
• プラグイン-プラグインでコアを簡単に拡張できます。 既存の（C、C ++、JavaまたはObj-C）コードをインポートし、Luaにバインドして直接解釈します。 多数のオープンソースプラグインがすでに開発されており、すぐに使用できます。
• クリーンOOPアプローチ-Giderosは独自のクラスシステムにすべての基本的なOOP標準を提供し、将来のゲームでクリーンで再利用可能なコードを記述できるようにします。
• ネイティブスピード-C/C ++およびOpenGL上で開発されたゲームは、ネイティブスピードで実行され、CPUとGPUのパワーを完全に活用します。

ShiVa3D

ShiVa3Dは、Web、コンソール、モバイルデバイス向けのアプリケーションやビデオゲームを作成するために設計されたグラフィカルエディターを提供する3Dゲームエンジンの1つです。 Windows、Mac、Linux、iOS、Android、BlackBerry、Palm OS、Wii、WebOSを含む複数のプラットフォームをサポートしています。

主な機能のいくつかが含まれます

• 標準プラグイン
• メッシュ修正API
• IDE
• 組み込みの地形、海洋、アニメーションエディター
• ODE物理エンジンのサポート
• 完全なライトマップ制御
• マテリアル、パーティクル、トレイル、HUDのライブプレビュー
• Collada交換フォーマットのサポート

Shiva3dのWebエディションは完全に無料で、他のエディションも購読しています。

モアイSDK

Moai SDKは、iPhone、iPad、およびAndroidプラットフォームをサポートするクロスプラットフォームモバイルゲームエンジンです。 Moaiプラットフォームは当初、オープンソースのゲームエンジンであるMoai SDKと、ゲームサービスのホスティングおよび展開のためのサービスとしてのクラウドプラットフォームであるMoai Cloudで構成されていました。 これで、Moai Cloudがシャットダウンされ、ゲームエンジンのみが使用可能になりました。

Moai SDKは、iOS、Android、Chrome、Windows、Mac、Linuxなどの複数のプラットフォームで実行されます。

LOVE

LOVEは、2Dゲームを作成するために使用できるフレームワークです。 それは無料でオープンソースです。 Windows、Mac OS X、Linuxプラットフォームをサポートしています。

以下を含む複数の機能を提供します。

• オーディオAPI
• ファイルシステムAPI
• キーボードおよびジョイスティックAPI
• 数学API
• ウィンドウおよびマウスAPI
• 物理API
• システムおよびタイマーAPI

泣くエンジン

CryEngineは、ドイツのゲーム開発者Crytekによって開発されたゲームエンジンです。 第1世代から第4世代に進化し、高度な開発ソリューションです。 PC、Xbox 360、PlayStation3、WiiUゲームをサポートしています。

以下を含む複数の機能を提供します。

• ナチュラルライティングとダイナミックソフトシャドウ、リアルタイムダイナミックグローバルイルミネーション、光伝搬ボリューム、パーティクルシェーディング、テッセレーションなどの視覚効果。
• キャラクターアニメーションシステムとキャラクター個別化システム。
• パラメトリック骨格アニメーションとユニークな専用フェイシャルアニメーションエディター
• 多層ナビゲーションメッシュや戦術ポイントシステムなどのAIシステム。 デザイナーに優しいAI編集システムも提供します。
• ゲームのミキシングとプロファイリング、データ駆動型サウンドシステムのダイナミックサウンドとインタラクティブミュージックなど。
• 手続き型変形や高度なロープ物理などの物理機能。

終わりのメモ

これらのGame SDK/frameworksには、それぞれ長所と短所があります。 それらを適切に選択すると、タスクが簡単になり、より良い時間を過ごすことができます。 そのため、使用する前に、ゲームの要件を把握してから、どれがすべてのニーズを満たしているかを分析してから使用する必要があります。

Lua-標準ライブラリ

Lua標準ライブラリは、C APIで直接実装され、Luaプログラミング言語で組み込まれた豊富な機能セットを提供します。 これらのライブラリは、Luaプログラミング言語内でサービスを提供し、ファイルやdb操作などの外部サービスも提供します。

公式C APIに組み込まれたこれらの標準ライブラリは、個別のCモジュールとして提供されます。 以下が含まれます-

• コルーチンサブライブラリを含む基本ライブラリ
• モジュールライブラリ
• 文字列操作
• テーブル操作
• 数学ライブラリ
• ファイルの入出力
• オペレーティングシステム設備 *デバッグ機能

基本ライブラリ

チュートリアル全体を通して、さまざまなトピックの下で基本ライブラリを使用しました。 次の表は、関連するページのリンクを提供し、このLuaチュートリアルのさまざまな部分で説明されている機能をリストしています。

Sr.No.	Library/Method & Purpose
1	Error Handling* link：/lua/lua_error_handling [Lua-エラー処理]で説明されているアサート、エラーなどのエラー処理関数が含まれています。
2	Memory Management link：/lua/lua_garbage_collection [Lua-ガベージコレクション]で説明されている、ガベージコレクションに関連する自動メモリ管理機能が含まれています。
3	dofile ([filename]) ファイルを開き、ファイルの内容をチャンクとして実行します。 パラメータが渡されない場合、この関数は標準入力の内容を実行します。 エラーは呼び出し元に伝播されます。
4	_G したがって、グローバル環境を保持するグローバル変数です（つまり、_G._G = _G）。 Lua自体はこの変数を使用しません。
5	getfenv ([f]) 関数が使用している現在の環境を返します。 fはLua関数またはそのスタックレベルで関数を指定する数値です。レベル1はgetfenvを呼び出す関数です。 指定された関数がLua関数でない場合、またはfが0の場合、getfenvはグローバル環境を返します。 fのデフォルトは1です。
6	getmetatable (object) オブジェクトにメタテーブルがない場合、nilを返します。 それ以外の場合、オブジェクトのメタテーブルに「__metatable」フィールドがある場合、関連する値を返します。 それ以外の場合、指定されたオブジェクトのメタテーブルを返します。
7	ipairs (t) この関数は、テーブルのインデックスと値を取得します。
8	load (func [, chunkname]) 関数funcを使用してチャンクをロードし、断片を取得します。 funcを呼び出すたびに、以前の結果と連結する文字列を返す必要があります。
9	loadfile ([filename])) loadと似ていますが、ファイル名が指定されていない場合は、ファイルfilenameまたは標準入力からチャンクを取得します。
10	loadstring (string [, chunkname]) loadと似ていますが、指定された文字列からチャンクを取得します。
11	next (table [, index]) プログラムがテーブルのすべてのフィールドを走査できるようにします。 最初の引数はテーブルで、2番目の引数はこのテーブルのインデックスです。 nextは、テーブルの次のインデックスとそれに関連付けられた値を返します。
12	pairs (t) 実行中のコルーチンを一時停止します。 このメソッドに渡されるパラメーターは、再開関数への追加の戻り値として機能します。
13	print (…​) 実行中のコルーチンを一時停止します。 このメソッドに渡されるパラメーターは、再開関数への追加の戻り値として機能します。
14	rawequal (v1, v2) メタメソッドを呼び出さずに、v1がv2と等しいかどうかを確認します。 ブール値を返します。
15	rawget (table, index) メタメソッドを呼び出さずに、table [index]の実際の値を取得します。 テーブルはテーブルでなければなりません。インデックスは任意の値です。
16	rawset (table, index, value) メタメソッドを呼び出さずに、table [index]の実際の値をvalueに設定します。 tableはテーブルであり、nilとは異なる値にインデックスを付け、Lua値を評価する必要があります。 この関数はテーブルを返します。
17	select (index, …​) indexが数値の場合、引数番号indexの後のすべての引数を返します。 それ以外の場合、indexは文字列「＃」である必要があり、selectは受け取った追加の引数の総数を返します。
18	setfenv (f, table) 指定された関数が使用する環境を設定します。 fはLua関数またはそのスタックレベルで関数を指定する数値です。レベル1はsetfenvを呼び出す関数です。 setfenvは、指定された関数を返します。 特別な場合として、fが0の場合、setfenvは実行中のスレッドの環境を変更します。 この場合、setfenvは値を返しません。
19	setmetatable (table, metatable) 指定されたテーブルのメタテーブルを設定します。 （Cからのみ、Luaから他のタイプのメタテーブルを変更することはできません。）metatableがnilの場合、指定されたテーブルのメタテーブルを削除します。 元のメタテーブルに「__metatable」フィールドがある場合、エラーが発生します。 この関数はテーブルを返します。
20	tonumber (e [, base]) 引数を数値に変換しようとします。 引数がすでに数値または数値に変換可能な文字列である場合、tonumberはこの数値を返します。それ以外の場合は、nilを返します。
21	tostring (e) 任意の型の引数を受け取り、適切な形式の文字列に変換します。 数値の変換方法を完全に制御するには、string.formatを使用します。
22	type (v) 文字列としてコード化された唯一の引数の型を返します。 この関数の可能な結果は、「nil」（値nilではなく文字列）、「number」、「string」、「boolean」、「table」、「function」、「thread」、および「userdata」です。
23	unpack (list [, i [, j]]) 指定されたテーブルから要素を返します。
24	_VERSION 現在のインタープリターバージョンを含む文字列を保持するグローバル変数（関数ではない）。 この変数の現在の内容は「Lua 5.1」です。
25	Coroutines link：/lua/lua_coroutines [Lua-コルーチン]で説明されているコルーチン操作関数が含まれています。

モジュールライブラリ

モジュールライブラリは、Luaにモジュールをロードするための基本機能を提供します。 グローバル環境にある1つの関数、requireを直接エクスポートします。 それ以外はすべてテーブルパッケージにエクスポートされます。 モジュールライブラリの詳細は、前の章のリンク：/lua/lua_modules [Lua-Modules]チュートリアルで説明されています。

文字列操作

Luaは、文字列操作関数の豊富なセットを提供します。 以前のリンク：/lua/lua_strings [Lua-Strings]チュートリアルでは、これについて詳しく説明しています。

テーブル操作

Luaは、ほとんどすべての操作でテーブルに依存しています。 以前のリンク：/lua/lua_tables [Lua-Tables]チュートリアルでは、これについて詳しく説明しています。

ファイルの入出力

プログラミングにはデータストレージ機能が必要になることが多く、これはLuaのファイルI/Oの標準ライブラリ関数によって提供されます。 以前のリンク：/lua/lua_file_io [Lua-File I/O]チュートリアルで説明されています。

デバッグ機能

Luaは、独自のデバッガを作成するためのすべてのプリミティブ関数を提供するデバッグライブラリを提供します。 以前のリンク：/lua/lua_debugging [Lua-Debugging]チュートリアルで説明されています。

Lua-数学ライブラリ

科学計算や工学計算では数学演算が必要になることが多く、標準のLuaライブラリ数学を使用してこれを利用できます。 数学ライブラリで使用可能な関数のリストを次の表に示します。

Sr.No.	Library/Method & Purpose
1	math.abs (x) xの絶対値を返します。
2	math.acos (x) xの逆余弦を返します（ラジアン単位）。
3	math.asin (x) xの逆正弦（ラジアン単位）を返します。
4	math.atan (x) xのアークタンジェントを返します（ラジアン単位）。
5	math.atan2 (y, x) y/xの逆正接（ラジアン単位）を返しますが、両方のパラメーターの符号を使用して結果の象限を見つけます。 （xがゼロの場合も正しく処理します。）
6	math.ceil (x) x以上の最小の整数を返します。
7	math.cos (x) xのコサインを返します（ラジアン単位と仮定）。
8	math.cosh (x) xの双曲線余弦を返します。
9	math.deg (x) 度単位の角度x（ラジアン単位）を返します。
10	math.exp (x) 値e power xを返します。
11	math.floor (x) x以下の最大の整数を返します。
12	math.fmod (x, y) 商をゼロに丸めるxをyで割った余りを返します。
13	math.frexp (x) x = m2e、eが整数で、mの絶対値が範囲[0.5、1）（またはxがゼロの場合はゼロ）になるようなmとeを返します。
14	math.huge 値HUGE_VAL、他の数値以上の値。
15	math.ldexp (m, e) m2eを返します（eは整数でなければなりません）。
16	math.log (x) xの自然対数を返します。
17	math.log10 (x) xの10を底とする対数を返します。
18	math.max (x, …​) 引数の中の最大値を返します。
19	math.min (x, …​) 引数の中で最小値を返します。
20	math.modf (x) xの整数部とxの小数部の2つの数値を返します。
21	math.pi piの値。
22	math.pow (x, y) xyを返します。 （式x ^ yを使用してこの値を計算することもできます。）
23	math.rad (x) ラジアン単位の角度x（度単位）を返します。
24	math.random ([m [, n]]) この関数は、ANSI Cが提供する単純な擬似乱数ジェネレーター関数randへのインターフェイスです。引数なしで呼び出されると、範囲[0,1）の一様な擬似乱数実数を返します。 整数mで呼び出されると、math.randomは[1、m]の範囲の一様な擬似乱数整数を返します。 2つの整数mとnで呼び出されると、math.randomは[m、n]の範囲の一様な擬似乱数整数を返します。
25	math.randomseed (x) xを擬似乱数生成器の「シード」として設定します。等しいシードは、等しい数のシーケンスを生成します。
26	math.sin (x) xのサインを返します（ラジアン単位であると仮定）。
27	math.sinh (x) xの双曲線正弦を返します。
28	math.sqrt (x) xの平方根を返します。 （式x ^ 0.5を使用してこの値を計算することもできます。）
29	math.tan (x) xのタンジェントを返します（ラジアン単位であると想定）。
30	math.tanh (x) xの双曲線正接を返します。

三角関数

三角関数を使用した簡単な例を以下に示します。

radianVal = math.rad(math.pi/2)

io.write(radianVal,"\n")

-- Sin value of 90(math.pi/2) degrees
io.write(string.format("%.1f ", math.sin(radianVal)),"\n")

-- Cos value of 90(math.pi/2) degrees
io.write(string.format("%.1f ", math.cos(radianVal)),"\n")

-- Tan value of 90(math.pi/2) degrees
io.write(string.format("%.1f ", math.tan(radianVal)),"\n")

-- Cosh value of 90(math.pi/2) degrees
io.write(string.format("%.1f ", math.cosh(radianVal)),"\n")

-- Pi Value in degrees
io.write(math.deg(math.pi),"\n")

上記のプログラムを実行すると、次の出力が得られます。

0.027415567780804
0.0
1.0
0.0
1.0
180

その他の一般的な数学関数

一般的な数学関数を使用した簡単な例を以下に示します。

-- Floor
io.write("Floor of 10.5055 is ", math.floor(10.5055),"\n")

-- Ceil
io.write("Ceil of 10.5055 is ", math.ceil(10.5055),"\n")

-- Square root
io.write("Square root of 16 is ",math.sqrt(16),"\n")

-- Power
io.write("10 power 2 is ",math.pow(10,2),"\n")
io.write("100 power 0.5 is ",math.pow(100,0.5),"\n")

-- Absolute
io.write("Absolute value of -10 is ",math.abs(-10),"\n")

--Random
math.randomseed(os.time())
io.write("Random number between 1 and 100 is ",math.random(),"\n")

--Random between 1 to 100
io.write("Random number between 1 and 100 is ",math.random(1,100),"\n")

--Max
io.write("Maximum in the input array is ",math.max(1,100,101,99,999),"\n")

--Min
io.write("Minimum in the input array is ",math.min(1,100,101,99,999),"\n")

上記のプログラムを実行すると、次の出力が得られます。

Floor of 10.5055 is 10
Ceil of 10.5055 is 11
Square root of 16 is 4
10 power 2 is 100
100 power 0.5 is 10
Absolute value of -10 is 10
Random number between 1 and 100 is 0.22876674703207
Random number between 1 and 100 is 7
Maximum in the input array is 999
Minimum in the input array is 1

上記の例は一般的な例のほんの一部です。必要に応じて数学ライブラリを使用できます。すべての関数を使用して、より慣れてください。

Lua-オペレーティングシステム設備

どのアプリケーションでも、多くの場合、オペレーティングシステムレベルの機能にアクセスする必要があり、オペレーティングシステムライブラリで利用できます。 使用可能な機能のリストを次の表に示します。

Sr.No.	Library/Method & Purpose
1	os.clock () プログラムが使用するCPU時間の秒単位の概算値を返します。
2	os.date ([format [, time]]) 指定された文字列形式に従って書式設定された、日付と時刻を含む文字列またはテーブルを返します。
3	os.difftime (t2, t1) 時刻t1から時刻t2までの秒数を返します。 POSIX、Windows、および他の一部のシステムでは、この値は正確にt2-t1です。
4	os.execute ([command]) この関数は、ANSI C関数システムと同等です。 オペレーティングシステムシェルによって実行されるコマンドを渡します。 最初の結果は、コマンドが正常に終了した場合はtrue、それ以外の場合はnilです。
5	os.exit ([code [, close]) ANSI C関数出口を呼び出して、ホストプログラムを終了します。 コードがtrueの場合、返されるステータスはEXIT_SUCCESSです。コードがfalseの場合、返されるステータスはEXIT_FAILUREです。コードが数字の場合、返されるステータスはこの数字です。
6	os.getenv (varname) プロセス環境変数varnameの値を返します。変数が定義されていない場合はnilを返します。
7	os.remove (filename) 指定された名前のファイル（またはPOSIXシステムでは空のディレクトリ）を削除します。 この関数が失敗すると、nilに加えて、エラーとエラーコードを説明する文字列が返されます。
8	os.rename (oldname, newname) oldnameという名前のファイルまたはディレクトリの名前をnewnameに変更します。 この関数が失敗すると、nilに加えて、エラーとエラーコードを説明する文字列が返されます。
9	os.setlocale (locale [, category]) プログラムの現在のロケールを設定します。 localeは、ロケールを指定するシステム依存の文字列です。 categoryは、変更するカテゴリを説明するオプションの文字列です。「all」、「collat​​e」、「ctype」、「monetary」、「numeric」、または「time」。デフォルトのカテゴリは「すべて」です。 この関数は、新しいロケールの名前を返します。リクエストを処理できない場合はnilを返します。
10	os.time ([table]) 引数なしで呼び出された場合、現在の時刻、または指定されたテーブルで指定された日付と時刻を表す時刻を返します。 このテーブルには、年、月、日のフィールドが必要です。また、フィールドは時間（デフォルトは12）、最小（デフォルトは0）、秒（デフォルトは0）、およびisdst（デフォルトはnil）です。 これらのフィールドの説明については、os.date関数を参照してください。
11	os.tmpname () 一時ファイルに使用できるファイル名の文字列を返します。 ファイルは、使用する前に明示的に開いて、不要になったら明示的に削除する必要があります。

一般的なOS機能

一般的な数学関数を使用した簡単な例を以下に示します。

-- Date with format
io.write("The date is ", os.date("%m/%d/%Y"),"\n")

-- Date and time
io.write("The date and time is ", os.date(),"\n")

-- Time
io.write("The OS time is ", os.time(),"\n")

-- Wait for some time
for i=1,1000000 do
end

-- Time since Lua started
io.write("Lua started before ", os.clock(),"\n")

上記のプログラムを実行すると、次のような出力が得られます。

The date is 01/25/2014
The date and time is 01/25/14 07:38:40
The OS time is 1390615720
Lua started before 0.013

上記の例は一般的な例のほんの一部です。必要に応じてOSライブラリを使用できます。すべての関数を使用して、より慣れてください。 前述のように、OSコマンドを実行するのに役立つファイルの削除に役立つremoveなどの関数があります。