Lua-クイックガイド

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

それは最初から、Cや他の従来の言語で書かれたコードと統合できるソフトウェアとして設計されました。この統合には多くの利点があります。Cがすでに実行できることを実行しようとはしませんが、Cが得意ではないこと、つまりハードウェアからの十分な距離、動的構造、冗長性なし、テストとデバッグの容易さを提供することを目的としています。このため、Luaは安全な環境、自動メモリ管理、および動的サイズの文字列やその他の種類のデータを処理するための優れた機能を備えています。

特徴

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

  • Extensible
  • Simple
  • Efficient
  • Portable
  • 無料でオープン

サンプルコード

print("Hello World!")

Luaはどのように実装されていますか？

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

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

Luaを学ぶ

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

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

Luaのいくつかの使用法

  • ゲームプログラミング

  • スタンドアロンアプリケーションでのスクリプト

  • Webでのスクリプト

  • MySQLProxyやMySQLWorkBenchなどのデータベースの拡張機能とアドオン

  • 侵入検知システムなどのセキュリティシステム。

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

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

テキストエディタ

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

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

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

Lua通訳

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

Luaコンパイラ

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

Windowsへのインストール

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

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

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

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

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 OSXへのインストール

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 AppStoreからXcodeをインストールします。次に、[Xcodeの設定]に移動し、[ダウンロード]に切り替えて、「コマンドラインツール」という名前のコンポーネントをインストールします。プロセスが完了すると、makeコマンドを使用できるようになります。

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

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

print("Hello World!")

これで、cdを使用してファイルを含むフォルダーに切り替え、次のコマンドを使用して、helloWorld.luaなどのLuaファイルをビルドして実行できます。

$ lua helloWorld

次の出力を見ることができます-

Hello World!

Lua IDE

前述のように、Windows SciTEの場合、LuaIDEはLuaクリエーターチームによって提供されるデフォルトのIDEです。利用可能な代替IDEは、Windows、Mac、Linuxなどの複数のプラットフォームで利用可能なZeroBraneStudioからのものです。

Lua開発を可能にするEclipse用のプラグインもあります。IDEを使用すると、コード補完などの機能を使用した開発が容易になるため、強くお勧めします。IDEは、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")

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

$ 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からZ」または「aからz」またはアンダースコア「_」で始まり、その後に0個以上の文字、アンダースコア、および数字（0から9）が続きます。

Luaでは、識別子内に@、$、％などの句読文字を使用できません。Luaはcase sensitiveプログラミング言語。したがって、ManpowerとmanpowerはLuaの2つの異なる識別子です。受け入れ可能な識別子の例を次に示します-

mohd         zara      abc     move_name    a_123
myname50     _temp     j       a23b9        retVal

キーワード

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

そして ブレーク 行う そうしないと
elseif 終わり false にとって
関数 もし に 地元
なし ない または 繰り返す
戻る その後 true まで
一方

Luaの空白

おそらくコメント付きの空白のみを含む行は空白行と呼ばれ、Luaインタープリターはそれを完全に無視します。

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

local age

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

fruit = apples + oranges   --get the total fruit

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

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

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

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

  • Global variables −ローカルとして明示的に宣言されていない限り、すべての変数はグローバルと見なされます。

  • Local variables −型が変数のローカルとして指定されている場合、そのスコープはスコープ内の関数で制限されます。

  • Table fields −これは、関数を含む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での値の割り当ては、variable_listの最初の変数と、value_listの最初の値のように行われます。したがって、dの値は5で、fの値は10です。

例

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

-- 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−メモリ位置を参照する式は「左辺値」式と呼ばれます。左辺値は、割り当ての左側または右側のいずれかとして表示される場合があります。

  • rvalue−右辺値という用語は、メモリ内のあるアドレスに格納されているデータ値を指します。右辺値は、値を割り当てることができない式です。つまり、右辺値は割り当ての左側には表示されませんが、右側には表示されます。

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

g = 20

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

10 = 20

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

g,l = 20,30

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

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

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

シニア番号 値のタイプと説明
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には、変数のタイプを知ることができる「type」という関数があります。次のコードにいくつかの例を示します。

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では、条件チェックの場合、ゼロおよび空の文字列が真であると見なされます。したがって、ブール演算を使用する場合は注意が必要です。これらのタイプの使用については、次の章で詳しく説明します。

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

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

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

算術演算子

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

例を表示

オペレーター 説明 例
+ 2つのオペランドを追加します A + Bは30を与えます
- 最初のオペランドから2番目のオペランドを減算します A-Bは-10を与えます
* 両方のオペランドを乗算します A * Bは200を与えます
/ 分子を分子で割る B / Aは2を与えます
％ モジュラス演算子と整数除算後の余り B％Aは0を与えます
^ 指数演算子は指数を取ります A ^ 2は100を与えます
- 単項-演算子は否定として機能します -Aは-10を与えます

関係演算子

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

例を表示

オペレーター 説明 例
== 2つのオペランドの値が等しいかどうかをチェックし、等しい場合は条件が真になります。 （A == B）は真ではありません。
〜= 2つのオペランドの値が等しいかどうかをチェックし、値が等しくない場合は条件が真になります。 （A〜 = B）は真です。
>> 左のオペランドの値が右のオペランドの値より大きいかどうかを確認します。大きい場合は、条件が真になります。 （A> B）は正しくありません。
< 左のオペランドの値が右のオペランドの値よりも小さいかどうかを確認します。小さい場合は、条件が真になります。 （A <B）は真です。
> = 左のオペランドの値が右のオペランドの値以上であるかどうかをチェックします。はいの場合、条件は真になります。 （A> = B）は正しくありません。
<= 左のオペランドの値が右のオペランドの値以下であるかどうかをチェックします。はいの場合、条件は真になります。 （A <= B）は真です。

論理演算子

次の表は、Lua言語でサポートされているすべての論理演算子を示しています。変数を想定A 真で可変である B 偽を保持します-

例を表示

オペレーター 説明 例
そして 論理AND演算子と呼ばれます。両方のオペランドがゼロ以外の場合、条件は真になります。 （AとB）は誤りです。
または 論理OR演算子と呼ばれます。2つのオペランドのいずれかがゼロ以外の場合、条件は真になります。 （AまたはB）は真です。
ない 論理NOT演算子と呼ばれます。オペランドの論理状態を逆にするために使用します。条件がtrueの場合、LogicalNOT演算子はfalseになります。 ！（AおよびB）は真です。

その他の演算子

Lua言語でサポートされているその他の演算子には次のものがあります concatenation そして length。

例を表示

オペレーター 説明 例
.. 2つの文字列を連結します。 a..bが「Hello」でbが「World」の場合、「HelloWorld」が返されます。
＃ 文字列またはテーブルの長さを返す単項演算子。 ＃「こんにちは」は5を返します

Luaでのオペレーターの優先順位

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

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

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

例を表示

カテゴリー オペレーター 結合性
単項 ＃-ではありません 右から左へ
連結 .. 右から左へ
乗法 * /％ 左から右へ
添加剤 +- 左から右へ
関連した <> <=> = ==〜=  左から右へ
平等 ==〜= 左から右へ
論理積 そして 左から右へ
論理OR または 左から右へ

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

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

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

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

シニア番号 ループの種類と説明
1 whileループ

指定された条件が真である間、ステートメントまたはステートメントのグループを繰り返します。ループ本体を実行する前に条件をテストします。
2 forループ

一連のステートメントを複数回実行し、ループ変数を管理するコードを省略します。
3 繰り返す...ループするまで

条件が満たされるまで、ステートメントのグループの操作を繰り返します。
4 ネストされたループ

1つ以上のループを別のwhile、for、またはdo..whileループ内で使用できます。

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

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

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

シニア番号 制御ステートメントと説明
1 breakステートメント

を終了します loop ループまたはスイッチの直後のステートメントに実行を転送します。

無限ループ

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

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

意思決定構造では、プログラマーは、プログラムによって評価またはテストされる1つ以上の条件と、条件が真であると判断された場合に実行される1つまたは複数のステートメント、およびオプションで、条件はfalseと判断されます。

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

Luaプログラミング言語はブール値の任意の組み合わせを想定しています true そして non-nil としての値 true、およびそれがブール値の場合 false または nil、それからそれはとして仮定されます false値。Luaでは、zero will be considered as true.

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

シニア番号 ステートメントと説明
1 ifステートメント

もしステートメントが1つ以上の文が続くブール式で構成されています。
2 if ... elseステートメント

もし文は、オプションを続けることができ、他のブール式が偽のときに実行される文。
3 ネストされたifステートメント

1つのifまたはelseifステートメントを別のifまたはelseifステートメント内で使用できます。

関数は、一緒にタスクを実行するステートメントのグループです。コードを個別の関数に分割できます。コードをさまざまな関数にどのように分割するかはあなた次第ですが、論理的には通常は一意であるため、各関数は特定のタスクを実行します。

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

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

関数の定義

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

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

Luaプログラミング言語のメソッド定義は、メソッドヘッダーとメソッド本体で構成されます。これがメソッドのすべての部分です-

  • Optional Function Scope−キーワードlocalを使用して、関数のスコープを制限するか、スコープセクションを無視して、グローバル関数にすることができます。

  • Function Name−これは関数の実際の名前です。関数名とパラメータリストが一緒になって関数シグネチャを構成します。

  • Arguments−引数はプレースホルダーのようなものです。関数が呼び出されると、引数に値を渡します。この値は、実際のパラメーターまたは引数と呼ばれます。パラメータリストは、メソッドの引数のタイプ、順序、および数を参照します。引数はオプションです。つまり、メソッドに引数を含めることはできません。

  • Function Body −メソッド本体には、メソッドの機能を定義するステートメントのコレクションが含まれています。

  • 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

関数の引数

関数が引数を使用する場合は、引数の値を受け入れる変数を宣言する必要があります。これらの変数は、formal parameters 関数の。

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

関数の呼び出し

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"

文字列では、文字の通常の解釈を変更するためにエスケープシーケンス文字が使用されます。たとえば、二重引用符（ ""）を出力するために、上記の例では\ "を使用しました。エスケープシーケンスとその使用法を以下の表に示します。

エスケープシーケンス 使用する
\ a ベル
\ b バックスペース
\ f フォームフィード
\ n 改行
\ r キャリッジリターン
\ t タブ
\ v 垂直タブ
\\ バックスラッシュ
\ " 二重引用符
\ ' 一重引用符
\ [ 左角括弧
\] 右角括弧

文字列操作

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

シニア番号 方法と目的
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

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

Luaでは、配列は整数のインデックステーブルを使用して実装されます。配列のサイズは固定されておらず、メモリの制約に応じて、要件に基づいて大きくなる可能性があります。

一次元配列

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

array = {"Lua", "Tutorial"}

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

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

nil
Lua
Tutorial

上記のコードでわかるように、配列にないインデックスの要素にアクセスしようとすると、nilが返されます。Luaでは、インデックス作成は通常インデックス1から始まりますが、インデックス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つの方法で実装できます。

  • 配列の配列
  • インデックスを操作することによる一次元配列

配列の配列を使用した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では、これらのコレクションは、配列などのさまざまなデータ構造を作成するために使用されるテーブルを参照することがよくあります。

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

ジェネリックのためのイテレータはコレクションの各要素のキーと値のペアを提供します。簡単な例を以下に示します。

array = {"Lua", "Tutorial"}

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

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

1  Lua
2  Tutorial

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

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

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

ステートレスイテレータ

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

ここで、の二乗を出力する単純な関数を使用して独自のイテレータを作成する例を見てみましょう。 n 数字。

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

When we run the above program, we will get the following output.

1	1
2	4
3	9

The above code can be modified slightly to mimic the way ipairs function of iterators work. It is shown below.

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

When we run the above program, we will get the following output.

1	1
2	4
3	9

Stateful Iterators

The previous example of iteration using function does not retain the state. Each time the function is called, it returns the next element of the collection based on a second variable sent to the function. To hold the state of the current element, closures are used. Closure retain variables values across functions calls. To create a new closure, we create two functions including the closure itself and a factory, the function that creates the closure.

Let us now see an example of creating our own iterator in which we will be using closures.

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

When we run the above program, we will get the following output.

Lua
Tutorial

In the above example, we can see that elementIterator has another method inside that uses the local external variables index and count to return each of the element in the collection by incrementing the index each time the function is called.

We can create our own function iterators using closure as shown above and it can return multiple elements for each of the time we iterate through the collection.

Introduction

Tables are the only data structure available in Lua that helps us create different types like arrays and dictionaries. Lua uses associative arrays and which can be indexed with not only numbers but also with strings except nil. Tables have no fixed size and can grow based on our need.

Lua uses tables in all representations including representation of packages. When we access a method string.format, it means, we are accessing the format function available in the string package.

Representation and Usage

Tables are called objects and they are neither values nor variables. Lua uses a constructor expression {} to create an empty table. It is to be known that there is no fixed relationship between a variable that holds reference of table and the table itself.

--sample table initialization
mytable = {}

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

--removing reference
mytable = nil

-- lua garbage collection will take care of releasing memory

When we have a table a with set of elements and if we assign it to b, both a and b refer to the same memory. No separate memory is allocated separately for b. When a is set to nil, table will be still accessible to b. When there are no reference to a table, then garbage collection in Lua takes care of cleaning up process to make these unreferenced memory to be reused again.

An example is shown below for explaining the above mentioned features of tables.

-- 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

テーブル操作

テーブル操作用の組み込み関数があり、それらを次の表に示します。

シニア番号 方法と目的
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

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

モジュールは、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でのプログラミングがいかに柔軟であるかを確認できます。

必要な関数

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機能です。

  • テーブルの演算子への機能の変更/追加。

  • メタテーブルの__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に設定されます。

  • metamethodは、インデックス「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があります。

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

+演算子を使用して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

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

シニア番号 モードと説明
1

__add

演算子「+」の動作を変更します。
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のコルーチンで使用可能なすべての関数とそれに対応する使用法を示します。

シニア番号 方法と目的
1

coroutine.create (f)

関数fを使用して新しいコルーチンを作成し、「thread」タイプのオブジェクトを返します。
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 (...)

実行中のコルーチンを一時停止します。このメソッドに渡されるパラメーターは、resume関数への追加の戻り値として機能します。

例

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

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をresume関数に返します。これは、yieldステートメントの入力パラメーター3と2を更新することで取得します。また、コルーチン実行の真/偽のステータスを受け取ります。

  • コルーチンに関するもう1つの点は、上記の例では、再開呼び出しの次のパラメーターがどのように処理されるかです。変数coroutine.yieldが次の呼び出しparamsを受け取ることがわかります。これは、既存のparam値を保持して新しい操作を実行する強力な方法を提供します。

  • 最後に、コルーチン内のすべてのステートメントが実行されると、後続の呼び出しはfalseで返され、応答として「デッドコルーチンを再開できません」ステートメントが返されます。

別のコルーチンの例

イールド関数とレジューム関数を使用して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つしか実行されず、同時に実行されることはないことを理解する必要があります。

特定の情報を一時的に保持することで、ニーズに合わせてプログラムの実行順序を制御します。コルーチンでグローバル変数を使用すると、コルーチンにさらに柔軟性が加わります。

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

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

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

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

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

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

シニア番号 モードと説明
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（）を使用しています。オプションのパラメータは、次のいずれかになります。

シニア番号 モードと説明
1

"*n"

現在のファイル位置から読み取り、ファイル位置に存在する場合は数値を返すか、nilを返します。
2

"*a"

現在のファイル位置からファイルのすべての内容を返します。
3

"*l"

現在のファイル位置から行を読み取り、ファイル位置を次の行に移動します。
4

number

関数で指定されたバイト数を読み取ります。

その他の一般的なI / O方法には、次のものがあります。

  • io.tmpfile() −プログラムが終了すると削除される読み取りおよび書き込み用の一時ファイルを返します。

  • io.type(file) −入力ファイルに基づいて、ファイル、閉じたファイル、またはnilのいずれかを返します。

  • io.flush() −デフォルトの出力バッファをクリアします。

  • io.lines(optional file name)−ファイル名が指定されている場合、またはデフォルトファイルが使用され、ループの最後で閉じられていない場合に、ファイルをループして最後にファイルを閉じる汎用の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(optional whence, optional offset)−パラメータが「set」、「cur」、または「end」の場合。ファイルの先頭から更新されたファイル位置で新しいファイルポインタを設定します。この関数では、オフセットはゼロベースです。最初の引数が「設定」されている場合、オフセットはファイルの先頭から測定されます。「cur」の場合、ファイル内の現在の位置から。または、「end」の場合はファイルの終わりから。デフォルトの引数値は「cur」と0であるため、引数なしでこの関数を呼び出すことにより、現在のファイル位置を取得できます。

  • file:flush() −デフォルトの出力バッファをクリアします。

  • io.lines(optional file name)−ファイル名が指定されている場合、またはデフォルトファイルが使用され、ループの最後で閉じられていない場合に、ファイルをループして最後にファイルを閉じる汎用の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ファイル操作の全機能を知ることができます。

エラー処理の必要性

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

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

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

構文エラー

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

a == 2

ご存知のように、シングル「等しい」とダブル「等しい」の使用には違いがあります。一方を他方の代わりに使用すると、エラーが発生する可能性があります。1つの「等しい」は割り当てを示し、2つの「等しい」は比較を示します。同様に、事前定義された実装方法を持つ式と関数があります。

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

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であり、エラーが発生します。

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

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

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デバッグライブラリで使用可能な関数を、その使用法とともに次の表に示します。

シニア番号 方法と目的
1

debug()

デバッグのためにインタラクティブモードに入ります。このモードは、1行にcontのみを入力して、Enterキーを押すまでアクティブのままです。ユーザーは、他の関数を使用して、このモード中に変数を検査できます。
2

getfenv(object)

オブジェクトの環境を返します。
3

gethook(optional thread)

スレッドの現在のフック設定を、現在のフック関数、現在のフックマスク、および現在のフックカウントの3つの値として返します。
4

getinfo(optional thread, function or stack level, optional flag)

関数に関する情報を含むテーブルを返します。関数を直接指定することも、関数の値として数値を指定することもできます。つまり、指定されたスレッドの呼び出しスタックのレベル関数で実行されている関数は、現在の関数（getinfo自体）です。レベル1は、getinfoを呼び出した関数です。等々。関数がアクティブな関数の数よりも大きい場合、getinfoはnilを返します。
5

getlocal(optional thread, stack level, local index)

スタックのレベルで関数のローカルインデックスを持つローカル変数の名前と値を返します。指定されたインデックスを持つローカル変数がない場合はnilを返し、範囲外のレベルで呼び出されるとエラーを発生させます。
6

getmetatable(value)

指定されたオブジェクトのメタテーブルを返します。メタテーブルがない場合はnilを返します。
7

getregistry()

レジストリテーブルを返します。これは、格納する必要のあるLua値を格納するために任意のCコードで使用できる事前定義されたテーブルです。
8

getupvalue(function, upvalue index)

この関数は、関数funcのインデックスアップを使用してupvalueの名前と値を返します。指定されたインデックスにアップバリューがない場合、関数は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)

スタックのレベルで関数のローカルインデックスを持つローカル変数に値を割り当てます。指定されたインデックスを持つローカル変数がない場合、関数はnilを返し、範囲外のレベルで呼び出されるとエラーを発生させます。それ以外の場合は、ローカル変数の名前を返します。
12

setmetatable(value, metatable)

指定されたオブジェクトのメタテーブルを指定されたテーブル（nilの場合もあります）に設定します。
13

setupvalue(function, upvalue index, value)

この関数は、関数funcのインデックスアップを使用して値を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が返されます。

デバッグタイプ

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

コマンドラインデバッグ

コマンドラインデバッグは、コマンドラインを使用してコマンドとprintステートメントを使用してデバッグするタイプのデバッグです。Luaで利用できるコマンドラインデバッガーはたくさんありますが、そのうちのいくつかを以下に示します。

  • RemDebug− RemDebugは、Lua5.0および5.1用のリモートデバッガーです。これにより、別のLuaプログラムの実行をリモートで制御し、ブレークポイントを設定して、プログラムの現在の状態を検査できます。RemDebugは、CGILuaスクリプトをデバッグすることもできます。

  • clidebugger−純粋なLuaで記述されたLua5.1用のシンプルなコマンドラインインターフェイスデバッガー。標準のLua5.1ライブラリ以外には依存していません。RemDebugに触発されましたが、リモート機能はありません。

  • ctrace − LuaAPI呼び出しをトレースするためのツール。

  • xdbLua −Windowsプラットフォーム用のシンプルなLuaコマンドラインデバッガー。

  • LuaInterface - Debugger−このプロジェクトは、LuaInterfaceのデバッガー拡張機能です。組み込みのLuaデバッグインターフェースをより高いレベルに引き上げます。デバッガーとの対話は、イベントとメソッド呼び出しによって行われます。

  • Rldb−これはソケットを介したリモートLuaデバッガーであり、WindowsとLinuxの両方で使用できます。それはあなたに既存のものよりはるかに多くの機能を与えることができます。

  • ModDebug −これにより、別のLuaプログラムの実行をリモートで制御し、ブレークポイントを設定し、プログラムの現在の状態を検査できます。

グラフィカルなデバッグ

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

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

  • SciTE −LuaのデフォルトのWindowsIDEは、ブレークポイント、ステップ、ステップイン、ステップオーバー、変数の監視などの複数のデバッグ機能を提供します。

  • Decoda −これはリモートデバッグをサポートするグラフィカルデバッガです。

  • ZeroBrane Studio−リモートデバッガー、スタックビュー、ウォッチビュー、リモートコンソール、静的アナライザーなどが統合されたLuaIDE。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インタープリターによって後の段階で自動的に実行されます。

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

OOPの紹介

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

  • C++
  • Java
  • Objective-C
  • Smalltalk
  • C#
  • Ruby

OOPの特徴

  • Class −クラスは、オブジェクトを作成するための拡張可能なテンプレートであり、状態（メンバー変数）の初期値と動作の実装を提供します。

  • Objects −これはクラスのインスタンスであり、それ自体に個別のメモリが割り当てられています。

  • Inheritance −これは、あるクラスの変数と関数が別のクラスに継承されるという概念です。

  • Encapsulation−クラス内でデータと関数を組み合わせるプロセスです。関数を使用して、クラスの外部からデータにアクセスできます。これは、データ抽象化とも呼ばれます。

LuaでのOOP

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

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

実際の例

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

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

シェイプは、共通のプロパティAreaを持つことができます。したがって、共通のプロパティ領域を使用して、ベースオブジェクトの形状から他の形状を拡張できます。各形状は独自のプロパティを持つことができ、長方形のような関数は、プロパティとして長さ、幅、面積、関数としてprintAreaとcalculateAreaを持つことができます。

単純なクラスの作成

面積、長さ、幅の3つのプロパティを持つ長方形の簡単なクラス実装を以下に示します。また、計算された面積を印刷するための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コンポーネントを提供するために2004年に形成されたKeplerコミュニティ。

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

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

  • Orbit は、WSAPIに基づくLua用のMVCWebフレームワークです。

  • WSAPI Lua WebアプリケーションからWebホストサーバーを抽象化するAPIであり、多くのプロジェクトのベースです。

  • Xavante WSAPIインターフェースを提供するLuaWebサーバーです。

  • Sputnik は、ユーモアと娯楽に使用されるケプラープロジェクトのWSAPI上で開発されたwiki / CMSです。

  • CGILuaWSAPIに基づいたLuaPagesおよびLuaScriptsWebページの作成を提供しますが、サポートされなくなりました。代わりに、Orbit、Sputnik、またはWSAPIを使用してください。

このチュートリアルでは、Luaで何ができるかを理解し、そのインストールと使用法について詳しく知るために、ウェブサイトのケプラーを参照してください。

軌道

Orbitは、Lua用のMVCWebフレームワークです。「スクリプト」のCGILuaモデルを完全に廃止し、各Orbitアプリケーションを1つのファイルに収めることができるアプリケーションを優先しますが、必要に応じて複数のファイルに分割することもできます。

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

Orbitをインストールする最も簡単な方法は、LuaRocksを使用することです。Luarocks install orbitは、インストールするためのコマンドです。このためには、最初に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 />セクションの下に追加します。このセクションに「AllowOverrideNone」がある場合は、「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

orbit.htmlify(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

orbit.htmlify(wrap,test)

print(test())

WSAPI

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

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

WSAPIでサポートされているサーバーとインターフェイスには、次のものが含まれます。

  • CGI
  • FastCGI
  • Xavante

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

  • リクエスト処理
  • 出力バッファリング
  • Authentication
  • ファイルのアップロード
  • 分離を要求する
  • Multiplexing

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>")
      coroutine.yield("<p&gtHello Wsapi!</p>")
      coroutine.yield("<p&gtPATH_INFO: " .. wsapi_env.PATH_INFO .. "</p>")
      coroutine.yield("<p&gtSCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p>")
      coroutine.yield("</body></html>")
   end

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

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

シャバンテ

Xavanteは、URIマップハンドラーに基づくモジュラーアーキテクチャを使用するLua HTTP 1.1Webサーバーです。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
   }
}

LuaWebコンポーネント

  • Copas、TCP / IPサーバーで使用できるコルーチンに基づくディスパッチャー。

  • Cosmo、テンプレート内の任意のコードからアプリケーションを保護する「安全なテンプレート」エンジン。

  • Coxpcall Luaネイティブpcallとxpcallをコルーチン互換のものでカプセル化します。

  • LuaFileSystem、基になるディレクトリ構造とファイル属性にアクセスするためのポータブルな方法。

  • Rings、Lua内から新しいLua状態を作成する方法を提供するライブラリ。

エンディングノート

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

  • MoonstalkLua言語で構築された動的に生成されたWebベースのプロジェクトの効率的な開発とホスティングを可能にします。基本的なページから複雑なアプリケーションまで。

  • Lapis、OpenRestyと呼ばれるNginxのカスタマイズされたバージョンの内部で実行されるMoonScript（またはLua）を使用してWebアプリケーションを構築するためのフレームワーク。

  • Lua Server Pages、組み込みWeb開発への他のアプローチを吹き飛ばすLuaスクリプトエンジンプラグインは、従来のCサーバーページへの劇的なショートカットを提供します。

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

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

  • SQLite
  • Mysql
  • ODBC

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

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

次の例を使用して期待どおりに機能させるには、データベースの初期設定が必要です。前提条件を以下に示します。

  • デフォルトのユーザーをroot、パスワードを「123456」としてMySQLをインストールおよびセットアップしました。

  • データベーステストを作成しました。

  • MySQLの基本を理解するためにMySQLチュートリアルを完了しました。

MySQLのインポート

シンプルなものが使えます require Luaの実装が正しく行われたと仮定して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」を正しいステートメントに置き換える必要があります。

テーブルの作成例

簡単なテーブル作成の例を以下に示します。整数型の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 )

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

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接続です。executeステートメントによって返されるカーソルを使用して、テーブルの応答をループし、必要な選択データをフェッチできます。

完全な例

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

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 −トランザクションが完了するか、まったく何も起こりません。

  • Consistency −トランザクションは一貫性のある状態で開始し、システムを一貫性のある状態のままにする必要があります。

  • Isolation −トランザクションの中間結果は、現在のトランザクションの外部には表示されません。

  • Durability −トランザクションがコミットされると、システム障害が発生した後でも、影響は持続します。

トランザクションはSTARTTRANSACTIONで始まります。そして、commitまたはrollbackステートメントで終了します。

トランザクションを開始します

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

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

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

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

conn:execute([[ROLLBACK;]])

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

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

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」を正しいステートメントに置き換える必要があります。

テーブルの作成例

簡単なテーブル作成の例を以下に示します。整数型の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 )

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

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接続です。executeステートメントによって返されるカーソルを使用して、テーブルの応答をループし、必要な選択データをフェッチできます。

完全な例

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

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

Luaは、その単純な言語構造と構文により、多くのゲームエンジンで使用されています。ガベージコレクション機能は、使用される豊富なグラフィックスのために大量のメモリを消費するゲームで非常に役立つことがよくあります。Luaを使用するいくつかのゲームエンジンには以下が含まれます-

  • Corona SDK
  • ギデロスモバイル
  • ShiVa3D
  • Moai SDK
  • LOVE
  • CryEngine

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

Corona SDK

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

Corona SDKは、次のような多くの機能を提供します。

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

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

ギデロスモバイル

Giderosは、iOSおよびAndroid用のゲームを作成するためのクロスプラットフォームSDKを提供します。ギデロススプラッシュ製で無料でご利用いただけます。ギデオロスの顕著な利点には、次のようなものがあります。

  • Development IDE −Giderosアプリの開発を容易にする独自のIDEを提供します。

  • Instant testing−ゲームの開発中、Wifiを介して実際のデバイスでわずか1秒でテストできます。エクスポートまたはデプロイプロセスで時間を無駄にする必要はありません。

  • Plugins−プラグインを使用してコアを簡単に拡張できます。既存の（C、C ++、Java、またはObj-C）コードをインポートし、Luaにバインドして、それらを直接解釈します。数十のオープンソースプラグインがすでに開発されており、すぐに使用できます。

  • Clean OOP approach − Giderosは、すべての基本的なOOP標準を備えた独自のクラスシステムを提供し、将来のゲームのためにクリーンで再利用可能なコードを記述できるようにします。

  • Native speed − 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版は完全に無料で、他の版は購読しています。

Moai SDK

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

Moai SDKは、iOS、Android、Chrome、Windows、Mac、Linuxなどの複数のプラットフォームで動作します。

愛

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

それは含む複数の機能を提供します、

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

泣くエンジン

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

それは含む複数の機能を提供します、

  • 自然光と動的ソフトシャドウ、リアルタイムの動的グローバルイルミネーション、光の伝播ボリューム、パーティクルシェーディング、テッセレーションなどの視覚効果。

  • キャラクターアニメーションシステムとキャラクター個別化システム。

  • パラメトリックスケルタルアニメーションとユニークな専用フェイシャルアニメーションエディター

  • マルチレイヤーナビゲーションメッシュやタクティカルポイントシステムなどのAIシステム。デザイナーフレンドリーなAI編集システムも提供します。

  • ゲームのミキシングとプロファイリング、データ駆動型サウンドシステムのダイナミックサウンドとインタラクティブミュージックなど。

  • ProceduralDeformationやAdvancedRopePhysicsなどの物理機能。

エンディングノート

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

Lua標準ライブラリは、C APIで直接実装され、Luaプログラミング言語で組み込まれている豊富な関数セットを提供します。これらのライブラリは、Luaプログラミング言語内だけでなく、ファイルやデータベース操作などの外部サービスも提供します。

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

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

基本ライブラリ

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

シニア番号 ライブラリ/方法と目的
1

Error Handling

で説明したようにエラー処理のassertのような機能、エラーが含まれていますエラー処理-ルア。
2

Memory Management

で説明したように、ガベージコレクションに関連した自動メモリ管理機能が含まれていますルア-ガベージコレクション。
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)

実行中のコルーチンを一時停止します。このメソッドに渡されるパラメーターは、resume関数への追加の戻り値として機能します。
13

print (...)

実行中のコルーチンを一時停止します。このメソッドに渡されるパラメーターは、resume関数への追加の戻り値として機能します。
14

rawequal (v1, v2)

メタメソッドを呼び出さずに、v1がv2と等しいかどうかを確認します。ブール値を返します。
15

rawget (table, index)

メタメソッドを呼び出さずに、table [index]の実際の値を取得します。テーブルはテーブルでなければなりません。indexは任意の値にすることができます。
16

rawset (table, index, value)

メタメソッドを呼び出さずに、table [index]の実際の値をvalueに設定します。tableはテーブルであり、nilとは異なる値にインデックスを付け、Lua値を評価する必要があります。この関数はテーブルを返します。
17

select (index, ...)

indexが数値の場合、引数numberindexの後のすべての引数を返します。それ以外の場合、indexは文字列 "＃"である必要があり、selectは受け取った追加の引数の総数を返します。
18

setfenv (f, table)

指定された関数で使用される環境を設定します。fは、Lua関数、またはそのスタックレベルで関数を指定する数値にすることができます。レベル1は、setfenvを呼び出す関数です。setfenvは指定された関数を返します。特別な場合として、fが0の場合、setfenvは実行中のスレッドの環境を変更します。この場合、setfenvは値を返しません。
19

setmetatable (table, metatable)

指定されたテーブルのメタテーブルを設定します。（他のタイプのメタテーブルをLuaから変更することはできません。Cからのみ変更できます。）メタテーブルが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

現在のインタプリタバージョンを含む文字列を保持するグローバル変数（関数ではありません）。この変数の現在の内容は「Lua5.1」です。
25

Coroutines

Lua-Coroutinesで説明されているコルーチン操作関数が含まれています。

モジュールライブラリ

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

文字列操作

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

テーブル操作

Luaは、操作のほぼすべてのビットでテーブルに依存しています。以前のLua-Tablesチュートリアルでは、これについて詳しく説明しています。

ファイルの入力と出力

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

デバッグ機能

Luaは、独自のデバッガーを作成するためのすべてのプリミティブ関数を提供するデバッグライブラリを提供します。これについては、以前のLua-デバッグチュートリアルで説明しています。

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

シニア番号 ライブラリ/方法と目的
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)

値epowerxを返します。
11

math.floor (x)

x以下の最大の整数を返します。
12

math.fmod (x, y)

商をゼロに丸めるyによるxの除算の余りを返します。
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

円周率の値。
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]の範囲の均一な疑似乱数整数を返します。math.randomは、2つの整数mとnで呼び出されると、[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

上記の例は一般的な例のほんの一部です。必要に応じて数学ライブラリを使用できるので、すべての関数を使用して理解を深めてください。

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

シニア番号 ライブラリ/方法と目的
1

os.clock ()

プログラムが使用したCPU時間の概算を秒単位で返します。
2

os.date ([format [, time]])

指定された文字列形式に従ってフォーマットされた、日付と時刻を含む文字列またはテーブルを返します。
3

os.difftime (t2, t1)

時間t1から時間t2までの秒数を返します。POSIX、Windows、およびその他の一部のシステムでは、この値は正確にt2-t1です。
4

os.execute ([command])

この関数は、ANSIC関数システムと同等です。オペレーティングシステムシェルによって実行されるコマンドを渡します。最初の結果は、コマンドが正常に終了した場合はtrue、それ以外の場合はnilです。
5

os.exit ([code [, close])

ANSI C関数exitを呼び出して、ホストプログラムを終了します。コードが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])

引数なしで呼び出された場合の現在の時刻、または指定されたテーブルで指定された日付と時刻を表す時刻を返します。このテーブルには、フィールドyear、month、dayが必要であり、フィールドhour（デフォルトは12）、min（デフォルトは0）、sec（デフォルトは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ライブラリを使用できるため、すべての関数を使用して理解を深めてください。上で説明したように、ファイルの削除に役立つremove、OSコマンドの実行に役立つexecuteなどの関数があります。

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved