Lua-퀵 가이드

Lua는 C로 작성된 확장 가능하고 가벼운 프로그래밍 언어입니다. 1993 년 Roberto Ierusalimschy, Luiz Henrique de Figueiredo 및 Waldemar Celes에 의해 사내 프로젝트로 시작되었습니다.

처음부터 C 및 기타 기존 언어로 작성된 코드와 통합 할 수있는 소프트웨어로 설계되었습니다. 이 통합은 많은 이점을 제공합니다. C가 이미 할 수있는 일을하려고하는 것이 아니라 C가 좋지 않은 것을 제공하는 것을 목표로합니다. 하드웨어로부터 좋은 거리, 동적 구조, 중복성 없음, 테스트 및 디버깅의 용이성. 이를 위해 Lua는 안전한 환경, 자동 메모리 관리 및 동적 크기의 문자열 및 기타 종류의 데이터를 처리 할 수있는 좋은 기능을 갖추고 있습니다.

풍모

Lua는 다른 언어와 구별되는 고유 한 기능 세트를 제공합니다. 여기에는-

  • Extensible
  • Simple
  • Efficient
  • Portable
  • 자유롭고 개방적

예제 코드

print("Hello World!")

Lua는 어떻게 구현됩니까?

Lua는 Lua 인터프리터 부분과 작동하는 소프트웨어 시스템의 두 부분으로 구성됩니다. 작동하는 소프트웨어 시스템은 Lua 프로그래밍 언어로 작성된 프로그램을 해석 할 수있는 실제 컴퓨터 응용 프로그램입니다. Lua 인터프리터는 ANSI C로 작성되었으므로 휴대 성이 뛰어나고 고급 네트워크 서버에서 소형 장치에 이르기까지 광범위한 장치에서 실행할 수 있습니다.

Lua의 언어와 통역사는 모두 성숙하고 작으며 빠릅니다. 다른 프로그래밍 언어와 최고의 소프트웨어 표준에서 발전했습니다. 크기가 작기 때문에 메모리가 적은 소형 장치에서 실행할 수 있습니다.

Lua 배우기

Lua를 배우는 동안 가장 중요한 점은 기술적 세부 사항을 잃지 않고 개념에 집중하는 것입니다.

프로그래밍 언어를 배우는 목적은 더 나은 프로그래머가되는 것입니다. 즉, 새로운 시스템을 설계 및 구현하고 기존 시스템을 유지하는 데 더 효과적입니다.

Lua의 일부 용도

  • 게임 프로그래밍

  • 독립 실행 형 응용 프로그램에서 스크립팅

  • 웹 스크립팅

  • MySQL Proxy 및 MySQL WorkBench와 같은 데이터베이스 용 확장 및 애드온

  • 침입 탐지 시스템과 같은 보안 시스템.

지역 환경 설정

여전히 Lua 프로그래밍 언어에 대한 환경을 설정하려면 컴퓨터에서 (a) 텍스트 편집기, (b) Lua 인터프리터 및 (c) Lua 컴파일러를 사용할 수있는 소프트웨어가 필요합니다.

텍스트 에디터

프로그램을 입력하려면 텍스트 편집기가 필요합니다. 몇 가지 편집기의 예로는 Windows 메모장, OS 편집 명령, Brief, Epsilon, EMACS 및 vim 또는 vi가 있습니다.

텍스트 편집기의 이름과 버전은 운영 체제에 따라 다를 수 있습니다. 예를 들어 메모장은 Windows에서 사용되며 vim 또는 vi는 Windows뿐만 아니라 Linux 또는 UNIX에서도 사용할 수 있습니다.

편집기로 만든 파일을 소스 파일이라고하며 이러한 파일에는 프로그램 소스 코드가 포함되어 있습니다. Lua 프로그램의 소스 파일은 일반적으로 확장자로 이름이 지정됩니다.".lua".

루아 통역사

Lua 명령을 입력하고 즉시 실행할 수있는 작은 프로그램입니다. 완전히 실행되는 컴파일러와 달리 오류가 발생하면 Lua 파일의 실행을 중지합니다.

Lua 컴파일러

Lua를 다른 언어 / 응용 프로그램으로 확장하려면 Lua 응용 프로그램 인터페이스와 호환되는 컴파일러가 포함 된 소프트웨어 개발 키트가 필요합니다.

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 -i 또는 lua 명령을 사용하여 쉘에서 호출 할 수 있습니다. 입력 후 엔터 키를 누르면 아래와 같이 대화 형 모드가 시작됩니다.

$ 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 문은 세 개의 토큰으로 구성됩니다.

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는 식별자 내에서 @, $ 및 %와 같은 구두점 문자를 허용하지 않습니다. 루아는case sensitive프로그래밍 언어. 따라서 인력인력 은 Lua에서 두 가지 다른 식별자입니다. 다음은 허용되는 식별자의 몇 가지 예입니다.

mohd         zara      abc     move_name    a_123
myname50     _temp     j       a23b9        retVal

키워드

다음 목록은 Lua의 예약어 중 일부를 보여줍니다. 이러한 예약어는 상수, 변수 또는 기타 식별자 이름으로 사용할 수 없습니다.

단절 하다 그밖에
elseif 종료 그릇된 ...에 대한
함수 만약 현지
아니 또는 반복
반환 그때 진실 ...까지
동안

Lua의 공백

공백 만 포함하고 주석이있는 줄을 빈 줄이라고하며 Lua 인터프리터는이를 완전히 무시합니다.

공백은 Lua에서 공백, 탭, 개행 문자 및 주석을 설명하는 데 사용되는 용어입니다. 공백은 명령문의 한 부분을 다른 부분과 분리하고 인터프리터가 int와 같은 명령문의 한 요소가 끝나고 다음 요소가 시작되는 위치를 식별 할 수 있도록합니다. 따라서 다음 진술에서-

local age

통역사가 구분할 수 있으려면 지역과 연령 사이에 적어도 하나의 공백 문자 (일반적으로 공백)가 있어야합니다. 한편, 다음 진술에서-

fruit = apples + oranges   --get the total fruit

과일과 = 사이 또는 =와 사과 사이에는 공백 문자가 필요하지 않지만 가독성을 위해 원하는 경우 일부를 포함 할 수 있습니다.

변수는 프로그램이 조작 할 수있는 저장 영역에 주어진 이름 일뿐입니다. 함수 및 테이블을 포함하여 다양한 유형의 값을 보유 할 수 있습니다.

변수 이름은 문자, 숫자 및 밑줄 문자로 구성 될 수 있습니다. 문자 또는 밑줄로 시작해야합니다. Lua는 대소 문자를 구분하므로 대문자와 소문자는 구별됩니다. Lua에는 8 가지 기본 유형의 값이 있습니다.

Lua에서는 변수 데이터 유형이 없지만 변수 범위에 따라 세 가지 유형이 있습니다.

  • Global variables − 모든 변수는 명시 적으로 로컬로 선언되지 않는 한 전역으로 간주됩니다.

  • Local variables − 유형이 변수에 대해 지역으로 지정되면 범위는 범위 내의 함수로 제한됩니다.

  • Table fields − 함수를 포함하여 nil을 제외한 모든 것을 담을 수있는 특별한 유형의 변수입니다.

Lua의 변수 정의

변수 정의는 인터프리터에게 변수 저장 공간을 생성 할 위치와 양을 알려주는 것을 의미합니다. 변수 정의는 선택적 유형을 가지며 다음과 같이 해당 유형의 하나 이상의 변수 목록을 포함합니다.

type variable_list;

여기, type 선택적으로 로컬이거나 유형이 지정되어 글로벌로 설정됩니다. variable_list쉼표로 구분 된 하나 이상의 식별자 이름으로 구성 될 수 있습니다. 몇 가지 유효한 선언이 여기에 표시됩니다.

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가 있고 값 목록에 5와 10이 있습니다.

Lua에서 할당되는 값은 variable_list의 첫 번째 변수와 같이 발생하며 value_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의 Lvalue와 Rvalue

Lua에는 두 종류의 표현이 있습니다.

  • lvalue− 메모리 위치를 참조하는 표현식을 "lvalue"표현식이라고합니다. lvalue는 할당의 왼쪽 또는 오른쪽으로 나타날 수 있습니다.

  • rvalue− rvalue라는 용어는 메모리의 일부 주소에 저장된 데이터 값을 의미합니다. rvalue는 할당 된 값을 가질 수없는 표현식입니다. 이는 rvalue가 할당의 왼쪽이 아니라 오른쪽에 나타날 수 있음을 의미합니다.

변수는 lvalue이므로 할당의 왼쪽에 나타날 수 있습니다. 숫자 리터럴은 r 값이므로 할당되지 않고 왼쪽에 표시 될 수 없습니다. 다음은 유효한 진술입니다-

g = 20

그러나 다음은 유효한 문이 아니며 빌드 시간 오류가 발생합니다.

10 = 20

Lua 프로그래밍 언어에서는 위의 할당 유형과 별도로 동일한 단일 문에 여러 lvalue와 rvalue를 가질 수 있습니다. 아래와 같습니다.

g,l = 20,30

위의 문장에서 20은 g에 할당되고 30은 l에 할당됩니다.

Lua는 동적으로 유형이 지정된 언어이므로 변수에는 유형이없고 값에만 유형이 있습니다. 값은 변수에 저장되고 매개 변수로 전달되고 결과로 반환 될 수 있습니다.

Lua에서는 변수 데이터 유형이 없지만 값에 대한 유형이 있습니다. 값의 데이터 유형 목록은 다음과 같습니다.

Sr. 아니요 값 유형 및 설명
1

nil

값을 일부 데이터가 있거나 데이터가없는 것과 구별하는 데 사용됩니다.

2

boolean

true 및 false를 값으로 포함합니다. 일반적으로 상태 확인에 사용됩니다.

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에서 조건 검사의 경우 0 및 빈 문자열이 참으로 간주됩니다. 따라서 부울 연산을 사용할 때주의해야합니다. 다음 장에서 이러한 유형을 사용하는 방법에 대해 자세히 알아볼 것입니다.

연산자는 인터프리터에게 특정 수학적 또는 논리적 조작을 수행하도록 지시하는 기호입니다. Lua 언어는 내장 연산자가 풍부하며 다음 유형의 연산자를 제공합니다.

  • 산술 연산자
  • 관계 연산자
  • 논리 연산자
  • 기타 연산자

이 자습서에서는 산술, 관계형, 논리 및 기타 기타 연산자를 하나씩 설명합니다.

산술 연산자

다음 표는 Lua 언어에서 지원하는 모든 산술 연산자를 보여줍니다. 변수 가정A 10 개와 가변 B 20을 보유하고-

예시보기

운영자 기술
+ 두 개의 피연산자를 더합니다. A + B는 30을 줄 것입니다
- 첫 번째에서 두 번째 피연산자를 뺍니다. A-B는 -10을 줄 것입니다.
* 두 피연산자 곱하기 A * B는 200을 줄 것입니다
/ 분자를 탈 분자로 나누기 B / A는 2를 줄 것입니다
% 계수 연산자 및 정수 나누기 후의 나머지 B % A는 0을 제공합니다.
^ 지수 연산자는 지수를 취합니다. A ^ 2는 100을 제공합니다.
- 단항-연산자가 부정 역할을 함 -A는 -10을 줄 것입니다

관계 연산자

다음 표는 Lua 언어에서 지원하는 모든 관계 연산자를 보여줍니다. 변수 가정A 10 개와 가변 B 20을 보유하고-

예시보기

운영자 기술
== 두 피연산자의 값이 같은지 확인합니다. 그렇다면 조건이 참이됩니다. (A == B)는 사실이 아닙니다.
~ = 두 피연산자의 값이 같은지 확인하고, 값이 같지 않으면 조건이 참이됩니다. (A ~ = B)는 사실입니다.
> 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 큰지 확인하고, 그렇다면 조건이 참이됩니다. (A> B)는 사실이 아닙니다.
< 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작은 지 확인하고, 그렇다면 조건이 참이됩니다. (A <B)는 사실입니다.
> = 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크거나 같은지 확인하고, 그렇다면 조건이 참이됩니다. (A> = B)는 사실이 아닙니다.
<= 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작거나 같은지 확인하고, 그렇다면 조건이 참이됩니다. (A <= B)는 참입니다.

논리 연산자

다음 표는 Lua 언어에서 지원하는 모든 논리 연산자를 보여줍니다. 변수 가정A 진실하고 가변적이다 B 거짓을 유지하고-

예시보기

운영자 기술
논리 AND 연산자라고합니다. 두 피연산자가 모두 0이 아니면 조건이 참이됩니다. (A와 B)는 거짓입니다.
또는 논리 OR 연산자라고합니다. 두 피연산자 중 하나가 0이 아니면 조건이 참이됩니다. (A 또는 B)가 참입니다.
아니 논리 NOT 연산자라고합니다. 피연산자의 논리 상태를 반전하는 데 사용합니다. 조건이 참이면 논리 NOT 연산자는 거짓으로 만듭니다. ! (A 및 B)는 참입니다.

기타 연산자

Lua 언어에서 지원하는 기타 연산자는 다음과 같습니다. concatenationlength.

예시보기

운영자 기술
.. 두 문자열을 연결합니다. a..b 여기서 a는 "Hello"이고 b는 "World"이면 "Hello World"를 반환합니다.
# 문자열 또는 테이블의 길이를 반환하는 단항 연산자입니다. # "Hello"는 5를 반환합니다.

Lua의 연산자 우선 순위

연산자 우선 순위는 식의 용어 그룹화를 결정합니다. 이는식이 평가되는 방식에 영향을줍니다. 특정 연산자는 다른 연산자보다 우선 순위가 높습니다. 예를 들어 곱셈 연산자는 더하기 연산자보다 우선 순위가 높습니다.

예를 들어, x = 7 + 3 * 2; 여기서 x는 20이 아니라 13이 할당됩니다. 연산자 *가 +보다 우선 순위가 높기 때문에 먼저 3 * 2를 곱한 다음 7에 더합니다.

여기에서 우선 순위가 가장 높은 연산자는 테이블 맨 위에 표시되고 가장 낮은 연산자는 맨 아래에 표시됩니다. 식 내에서 우선 순위가 높은 연산자가 먼저 평가됩니다.

예시보기

범주 운영자 연관성
단항 아니 #- 오른쪽에서 왼쪽으로
연쇄 .. 오른쪽에서 왼쪽으로
곱셈 * / % 좌에서 우로
첨가물 +- 좌에서 우로
관계형 <> <=> = == ~ =  좌에서 우로
평등 == ~ = 좌에서 우로
논리적 AND 좌에서 우로
논리적 OR 또는 좌에서 우로

코드 블록을 여러 번 실행해야하는 상황이있을 수 있습니다. 일반적으로 명령문은 순차적으로 실행됩니다. 함수의 첫 번째 명령문이 먼저 실행되고 두 번째 명령문이 실행되는 방식입니다.

프로그래밍 언어는보다 복잡한 실행 경로를 허용하는 다양한 제어 구조를 제공합니다.

루프 문을 사용하면 문 또는 문 그룹을 여러 번 실행할 수 있습니다. 다음은 대부분의 프로그래밍 언어에서 일반적인 형태의 루프 문입니다.

Lua는 루핑 요구 사항을 처리하기 위해 다음 유형의 루프를 제공합니다.

Sr. 아니. 루프 유형 및 설명
1 while 루프

주어진 조건이 참인 동안 명령문 또는 명령문 그룹을 반복합니다. 루프 본문을 실행하기 전에 조건을 테스트합니다.

2 for 루프

일련의 명령문을 여러 번 실행하고 루프 변수를 관리하는 코드를 축약합니다.

반복 ... 루프까지

until 조건이 충족 될 때까지 문 그룹의 작업을 반복합니다.

4 중첩 된 루프

while, for 또는 do..while 루프 내에서 하나 이상의 루프를 사용할 수 있습니다 .

루프 제어문

루프 제어문은 정상적인 순서에서 실행을 변경합니다. 실행이 범위를 벗어나면 해당 범위에서 생성 된 모든 자동 개체가 삭제됩니다.

Lua는 다음 제어문을 지원합니다.

Sr. 아니. 제어문 및 설명
1 break 문

종료 loop 루프 또는 스위치 바로 다음의 문으로 실행을 전송합니다.

무한 루프

조건이 거짓이되지 않으면 루프는 무한 루프가됩니다. 그만큼while이러한 목적으로 루프가 자주 사용됩니다. 우리가 조건에 대해 진실을 직접 제공하기 때문에 영원히 계속 실행됩니다. break 문을 사용하여이 루프를 끊을 수 있습니다.

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

의사 결정 구조를 위해서는 프로그래머가 조건이 참인 경우 실행할 명령문 또는 명령문과 함께 프로그램에서 평가하거나 테스트 할 하나 이상의 조건을 지정해야합니다. 조건은 거짓으로 결정됩니다.

다음은 대부분의 프로그래밍 언어에서 발견되는 일반적인 의사 결정 구조의 일반적인 형태입니다.

Lua 프로그래밍 언어는 부울 조합을 가정합니다. truenon-niltrue, 그리고 부울 인 경우 false 또는 nil이면 다음과 같이 가정합니다. false값. Lua에서는zero will be considered as true.

Lua 프로그래밍 언어는 다음과 같은 유형의 의사 결정 문을 제공합니다.

Sr. 아니. 성명 및 설명
1 if 문

경우 문은 하나 이상의 문 뒤에 부울 표현식으로 구성되어 있습니다.

2 if ... else 문

경우 문이 옵션 다음에 할 수있는 다른 부울 표현식이 거짓 일 때 실행 문.

중첩 된 if 문

if 또는 else if 문을 다른 if 또는 else if 문 안에 사용할 수 있습니다 .

함수는 함께 작업을 수행하는 문 그룹입니다. 코드를 별도의 함수로 나눌 수 있습니다. 코드를 여러 함수로 나누는 방법은 사용자에게 달려 있지만 논리적으로 구분은 일반적으로 고유하므로 각 함수가 특정 작업을 수행합니다.

Lua 언어는 프로그램이 호출 할 수있는 다양한 내장 메서드를 제공합니다. 예 : 방법print() 콘솔에서 입력으로 전달 된 인수를 인쇄합니다.

함수는 메소드, 서브 루틴, 프로 시저 등과 같은 다양한 이름으로 알려져 있습니다.

함수 정의

Lua 프로그래밍 언어에서 메서드 정의의 일반적인 형식은 다음과 같습니다.

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

Lua 프로그래밍 언어의 메서드 정의는 메서드 헤더메서드 본문으로 구성 됩니다. 다음은 방법의 모든 부분입니다.

  • Optional Function Scopelocal 키워드를 사용 하여 함수의 범위를 제한하거나 범위 섹션을 무시하여 전역 함수로 만들 수 있습니다.

  • Function Name− 이것은 함수의 실제 이름입니다. 함수 이름과 매개 변수 목록은 함께 함수 서명을 구성합니다.

  • Arguments− 인수는 자리 표시 자와 같습니다. 함수가 호출되면 인수에 값을 전달합니다. 이 값을 실제 매개 변수 또는 인수라고합니다. 매개 변수 목록은 메소드 인수의 유형, 순서 및 수를 참조합니다. 인수는 선택 사항입니다. 즉, 메서드에 인수가 없을 수 있습니다.

  • Function Body − 메소드 본문에는 메소드의 기능을 정의하는 명령문 모음이 포함되어 있습니다.

  • Return − Lua에서는 return 키워드 뒤에 쉼표로 구분 된 반환 값을 사용하여 여러 값을 반환 할 수 있습니다.

다음은 호출 된 함수의 소스 코드입니다. max(). 이 함수는 두 개의 매개 변수 num1과 num2를 취하고 둘 사이의 최대 값을 반환합니다.

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

문자열은 일련의 문자이자 양식 공급과 같은 제어 문자입니다. 문자열은 다음을 포함하는 세 가지 형식으로 초기화 될 수 있습니다.

  • 작은 따옴표 사이의 문자
  • 큰 따옴표 사이의 문자
  • [[와]] 사이의 문자

위의 세 가지 형식에 대한 예가 아래에 나와 있습니다.

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"

이스케이프 시퀀스 문자는 문자의 일반적인 해석을 변경하기 위해 문자열에서 사용됩니다. 예를 들어 이중 반전 쉼표 ( "")를 인쇄하기 위해 위의 예에서 \ "를 사용했습니다. 이스케이프 시퀀스와 그 사용법은 아래 표에 나열되어 있습니다.

탈출 시퀀스 사용하다
\ㅏ
\비 역행 키이
\에프 Formfeed
\엔 새로운 라인
\아르 자형 캐리지 리턴
\티
\V 수직 탭
\\ 백 슬래시
\ " 큰 따옴표
\ ' 작은 따옴표
\ [ 왼쪽 대괄호
\] 오른쪽 대괄호

문자열 조작

Lua는 문자열을 조작하기 위해 문자열을 지원합니다-

Sr. 아니. 방법 및 목적
1

string.upper(argument)

인수의 대문자 표현을 반환합니다.

2

string.lower(argument)

인수의 소문자 표현을 반환합니다.

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

..

따라서 연산자는 두 문자열을 연결합니다.

이제 이러한 문자열 조작 함수가 어떻게 작동하는지 정확히 확인하기 위해 몇 가지 예를 살펴 보겠습니다.

케이스 조작

문자열을 대문자와 소문자로 조작하는 샘플 코드는 다음과 같습니다.

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 차원 배열

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

다차원 배열

다차원 배열은 두 가지 방법으로 구현할 수 있습니다.

  • 배열 배열
  • 인덱스를 조작하여 1 차원 배열

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에서 특별한 기술 없이도 많은 메모리를 절약 할 수 있습니다.

Iterator는 소위 컬렉션 또는 컨테이너의 요소를 순회 할 수있는 구조입니다. Lua에서 이러한 컬렉션은 종종 배열과 같은 다양한 데이터 구조를 생성하는 데 사용되는 테이블을 참조합니다.

반복자를위한 일반

일반적인 대한 반복자는 컬렉션의 각 요소의 키 값 쌍을 제공합니다. 간단한 예가 아래에 나와 있습니다.

array = {"Lua", "Tutorial"}

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

위의 코드를 실행하면 다음과 같은 결과가 나옵니다.

1  Lua
2  Tutorial

위의 예는 Lua에서 제공 하는 기본 ipairs 반복기 함수 를 사용합니다 .

Lua에서는 함수를 사용하여 반복자를 나타냅니다. 이 반복기 함수의 상태 유지 관리를 기반으로 두 가지 주요 유형이 있습니다.

  • 상태 비 저장 반복기
  • 상태 저장 반복자

상태 비 저장 반복기

이름 자체로 우리는 이러한 유형의 반복기 함수가 어떤 상태도 유지하지 않는다는 것을 이해할 수 있습니다.

이제 제곱을 인쇄하는 간단한 함수를 사용하여 자체 반복기를 만드는 예를 살펴 보겠습니다. 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

위의 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

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

상태 저장 반복자

함수를 사용하는 반복의 이전 예는 상태를 유지하지 않습니다. 함수가 호출 될 때마다 함수에 전송 된 두 번째 변수를 기반으로 컬렉션의 다음 요소를 반환합니다. 현재 요소의 상태를 유지하기 위해 클로저가 사용됩니다. 클로저는 함수 호출에서 변수 값을 유지합니다. 새로운 클로저를 만들기 위해 클로저 자체와 팩토리, 클로저를 생성하는 함수를 포함하는 두 가지 함수를 만듭니다.

이제 클로저를 사용할 자체 반복자를 생성하는 예를 살펴 보겠습니다.

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는 연관 배열을 사용하며 숫자뿐만 아니라 nil을 제외한 문자열로도 인덱싱 할 수 있습니다. 테이블은 고정 된 크기가 없으며 필요에 따라 확장 할 수 있습니다.

Lua는 패키지 표현을 포함한 모든 표현에서 테이블을 사용합니다. 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, 둘 다 ab같은 메모리를 참조하십시오. 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. 아니. 방법 및 목적
1

table.concat (table [, sep [, i [, j]]])

주어진 매개 변수를 기반으로 테이블의 문자열을 연결합니다. 자세한 내용은 예를 참조하십시오.

2

table.insert (table, [pos,] value)

테이블의 지정된 위치에 값을 삽입합니다.

table.maxn (table)

가장 큰 숫자 인덱스를 반환합니다.

4

table.remove (table [, pos])

테이블에서 값을 제거합니다.

5

table.sort (table [, comp])

선택적 비교기 인수를 기반으로 테이블을 정렬합니다.

위 함수의 몇 가지 샘플을 살펴 보겠습니다.

테이블 연결

concat 함수를 사용하여 아래와 같이 두 테이블을 연결할 수 있습니다.

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 함수는 모듈을 실제로 함수 또는 함수를 포함하는 테이블 인 일부 값을 정의하는 코드 덩어리로 가정합니다.

하나의 함수에 수학 함수가있는 간단한 예를 고려해 보겠습니다. 이 모듈을 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)

이 코드를 실행하려면 두 개의 Lua 파일을 동일한 디렉토리에 배치하거나 또는 모듈 파일을 패키지 경로에 배치 할 수 있으며 추가 설정이 필요합니다. 위의 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

30
10
200
1.5

기억해야 할 사항

  • 모듈과 실행하는 파일을 모두 동일한 디렉토리에 배치하십시오.

  • 모듈 이름과 파일 이름은 동일해야합니다.

  • 필수 기능에 대한 모듈을 반환하는 것이 가장 좋은 방법이므로 다른 유형의 구현을 다른 곳에서 찾을 수 있지만 모듈은 위에 표시된대로 구현하는 것이 좋습니다.

모듈 구현의 오래된 방법

이제 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를 사용하여 테이블에서 키를 사용할 수없는 경우 메타 테이블을 조회합니다.

다음을 포함하는 메타 테이블을 처리하는 데 사용되는 두 가지 중요한 방법이 있습니다.

  • setmetatable(table,metatable) −이 방법은 테이블에 대한 메타 테이블을 설정하는 데 사용됩니다.

  • getmetatable(table) −이 방법은 테이블의 메타 테이블을 가져 오는 데 사용됩니다.

먼저 한 테이블을 다른 테이블의 메타 테이블로 설정하는 방법을 살펴 보겠습니다. 아래와 같습니다.

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

위 코드는 아래와 같이 한 줄로 표현할 수 있습니다.

mytable = setmetatable({},{})

_인덱스

아래는 테이블에서 사용할 수없는 메타 테이블을 조회하기위한 간단한 메타 테이블의 예입니다.

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이 있습니다.

테이블에 연산자 동작 추가

+ 연산자를 사용하여 두 테이블을 결합하는 간단한 예는 다음과 같습니다.

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 키는 연산자 +의 동작을 추가하기 위해 메타 테이블에 포함됩니다. 키 표와 해당 연산자는 다음과 같습니다.

Sr. 아니. 모드 및 설명
1

__add

연산자 '+'의 동작을 변경합니다.

2

__sub

연산자 '-'의 동작을 변경합니다.

__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

메타 테이블의 기능을 완전히 알고 있다면이를 사용하지 않고도 매우 복잡한 많은 작업을 수행 할 수 있습니다. 따라서 샘플에 설명 된대로 메타 테이블에서 사용할 수있는 다양한 옵션을 사용하여 메타 테이블을 사용하는 방법에 대해 더 많이 작업하고 자신 만의 샘플을 만드십시오.

소개

코 루틴은 본질적으로 협업 적이므로 둘 이상의 메서드를 제어 된 방식으로 실행할 수 있습니다. 코 루틴을 사용하면 주어진 시간에 하나의 코 루틴 만 실행되며이 실행중인 코 루틴은 명시 적으로 일시 중단을 요청할 때만 실행을 일시 중단합니다.

위의 정의는 모호하게 보일 수 있습니다. 메인 프로그램 방법과 코 루틴의 두 가지 방법이 있다고 가정 해 보겠습니다. resume 함수를 사용하여 코 루틴을 호출하면 실행이 시작되고 yield 함수를 호출하면 실행이 중단됩니다. 다시 동일한 코 루틴이 일시 중단 된 다른 재개 함수 호출로 계속 실행할 수 있습니다. 이 프로세스는 코 루틴 실행이 끝날 때까지 계속 될 수 있습니다.

코 루틴에서 사용 가능한 함수

다음 표는 Lua에서 코 루틴에 사용할 수있는 모든 함수와 해당 용도를 나열합니다.

Sr. 아니. 방법 및 목적
1

coroutine.create (f)

함수 f로 새로운 코 루틴을 만들고 "thread"유형의 객체를 반환합니다.

2

coroutine.resume (co [, val1, ...])

코 루틴 co를 재개하고 매개 변수가있는 경우 전달합니다. 작업 상태 및 선택적 기타 반환 값을 반환합니다.

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 기능을 사용하여 작업을 중지합니다. 또한 코 루틴의 resume 함수에 의해 수신 된 여러 반환 값이 있음을 알 수 있습니다.

  • 먼저 코 루틴을 만들어 변수 이름 co에 할당하면 코 루틴은 두 개의 변수를 매개 변수로받습니다.

  • 첫 번째 재개 함수를 호출 할 때 값 3과 2는 코 루틴이 끝날 때까지 임시 변수 value1과 value2에 유지됩니다.

  • 이를 이해하기 위해 처음에는 10 인 tempvar3을 사용했으며 코 루틴을 실행하는 동안 value1이 3으로 유지되기 때문에 코 루틴의 후속 호출에 의해 13 및 16으로 업데이트됩니다.

  • 첫 번째 coroutine.yield는 yield 문에서 입력 매개 변수 3과 2를 업데이트하여 얻는 두 값 4와 3을 resume 함수에 반환합니다. 또한 코 루틴 실행의 참 / 거짓 상태를받습니다.

  • 코 루틴에 대한 또 다른 점은 위의 예에서 resume call의 다음 매개 변수가 처리되는 방식입니다. coroutine.yield 변수가 기존 매개 변수 값을 유지하면서 새로운 작업을 수행하는 강력한 방법을 제공하는 다음 호출 매개 변수를받는 것을 볼 수 있습니다.

  • 마지막으로 코 루틴의 모든 명령문이 실행되면 후속 호출이 false로 반환되고 응답으로 "cannot resume dead coroutine"명령문이 반환됩니다.

또 다른 코 루틴 예제

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

코 루틴을 다중 프로그래밍 언어의 스레드와 비교하는 경우가 많지만 코 루틴은 스레드와 비슷한 기능을 가지고 있지만 한 번에 하나만 실행하고 동시에 실행하지 않는다는 것을 이해해야합니다.

우리는 특정 정보를 일시적으로 보유하는 제공으로 필요에 맞게 프로그램 실행 순서를 제어합니다. 코 루틴과 함께 전역 변수를 사용하면 코 루틴에 더 많은 유연성을 제공합니다.

I / O 라이브러리는 Lua에서 파일을 읽고 조작하는 데 사용됩니다. Lua에는 암시 적 파일 설명자와 명시 적 파일 설명 자라는 두 가지 종류의 파일 작업이 있습니다.

다음 예에서는 아래와 같이 test.lua 샘플 파일을 사용합니다.

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

간단한 파일 열기 작업은 다음 문을 사용합니다.

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

다음 표에는 다양한 파일 모드가 나열되어 있습니다.

Sr. 아니. 모드 및 설명
1

"r"

읽기 전용 모드이며 기존 파일이 열리는 기본 모드입니다.

2

"w"

기존 파일을 덮어 쓰거나 새 파일을 만드는 쓰기 가능 모드입니다.

"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 코드의 마지막 줄에 추가됩니다.

In the above example, you can see how the implicit descriptors work with file system using the io."x" methods. The above example uses io.read() without the optional parameter. The optional parameter can be any of the following.

Sr.No. Mode & Description
1

"*n"

Reads from the current file position and returns a number if exists at the file position or returns nil.

2

"*a"

Returns all the contents of file from the current file position.

3

"*l"

Reads the line from the current file position, and moves file position to next line.

4

number

Reads number of bytes specified in the function.

Other common I/O methods includes,

  • io.tmpfile() − Returns a temporary file for reading and writing that will be removed once the program quits.

  • io.type(file) − Returns whether file, closed file or nil based on the input file.

  • io.flush() − Clears the default output buffer.

  • io.lines(optional file name) − Provides a generic for loop iterator that loops through the file and closes the file in the end, in case the file name is provided or the default file is used and not closed in the end of the loop.

Explicit File Descriptors

We often use explicit file descriptor which allows us to manipulate multiple files at a time. These functions are quite similar to implicit file descriptors. Here, we use file:function_name instead of io.function_name. The following example of the file version of the same implicit file descriptors example is shown below.

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

When you run the program, you will get a similar output as the implicit descriptors example.

-- Sample test.lua

All the modes of file open and params for read for external descriptors is same as implicit file descriptors.

Other common file methods includes,

  • file:seek(optional whence, optional offset) − Whence parameter is "set", "cur" or "end". Sets the new file pointer with the updated file position from the beginning of the file. The offsets are zero-based in this function. The offset is measured from the beginning of the file if the first argument is "set"; from the current position in the file if it's "cur"; or from the end of the file if it's "end". The default argument values are "cur" and 0, so the current file position can be obtained by calling this function without arguments.

  • file:flush() − Clears the default output buffer.

  • io.lines(optional file name) − Provides a generic for loop iterator that loops through the file and closes the file in the end, in case the file name is provided or the default file is used and not closed in the end of the loop.

An example to use the seek method is shown below. It offsets the cursor from the 25 positions prior to the end of file. The read function prints remainder of the file from seek position.

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

You will get some output similar to the following.

sample2 test.lua
--test

You can play around all the different modes and parameters to know the full ability of the Lua file operations.

Need for Error Handling

Error handling is quite critical since real-world operations often require the use of complex operations, which includes file operations, database transactions and web service calls.

In any programming, there is always a requirement for error handling. Errors can be of two types which includes,

  • Syntax errors
  • Run time errors

Syntax Errors

Syntax errors occur due to improper use of various program components like operators and expressions. A simple example for syntax error is shown below.

a == 2

As you know, there is a difference between the use of a single "equal to" and double "equal to". Using one instead of the other can lead to an error. One "equal to" refers to assignment while a double "equal to" refers to comparison. Similarly, we have expressions and functions having their predefined ways of implementation.

Another example for syntax error is shown below −

for a= 1,10
   print(a)
end

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

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

Syntax errors are much easier to handle than run time errors since, the Lua interpreter locates the error more clearly than in case of runtime error. From the above error, we can know easily that adding a do statement before print statement is required as per the Lua structure.

Run Time Errors

In case of runtime errors, the program executes successfully, but it can result in runtime errors due to mistakes in input or mishandled functions. A simple example to show run time error is shown below.

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

add(10)

When we build the program, it will build successfully and run. Once it runs, shows a run time error.

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]: ?

This is a runtime error, which had occurred due to not passing two variables. The b parameter is expected and here it is nil and produces an error.

Assert and Error Functions

In order to handle errors, we often use two functions − assert and error. A simple example is shown below.

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)

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

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]: ?

The error (message [, level]) terminates the last protected function called and returns message as the error message. This function error never returns. Usually, error adds some information about the error position at the beginning of the message. The level argument specifies how to get the error position. With level 1 (the default), the error position is where the error function was called. Level 2 points the error to where the function that called error was called; and so on. Passing a level 0 avoids the addition of error position information to the message.

pcall and xpcall

In Lua programming, in order to avoid throwing these errors and handling errors, we need to use the functions pcall or xpcall.

The pcall (f, arg1, ...) function calls the requested function in protected mode. If some error occurs in function f, it does not throw an error. It just returns the status of error. A simple example using pcall is shown below.

function myfunction ()
   n = n/nil
end

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

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

Failure

The xpcall (f, err) function calls the requested function and also sets the error handler. Any error inside f is not propagated; instead, xpcall catches the error, calls the err function with the original error object, and returns a status code.

A simple example for xpcall is shown below.

function myfunction ()
   n = n/nil
end

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

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

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

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

As a programmer, it is most important to ensure that you take care of proper error handling in the programs you write. Using error handling can ensure that unexpected conditions beyond the boundary conditions are handled without disturbing the user of the program.

Lua provides a debug library, which provides all the primitive functions for us to create our own debugger. Even though, there is no in-built Lua debugger, we have many debuggers for Lua, created by various developers with many being open source.

The functions available in the Lua debug library are listed in the following table along with its uses.

Sr.No. Method & Purpose
1

debug()

Enters interactive mode for debugging, which remains active till we type in only cont in a line and press enter. User can inspect variables during this mode using other functions.

2

getfenv(object)

Returns the environment of object.

3

gethook(optional thread)

Returns the current hook settings of the thread, as three values − the current hook function, the current hook mask, and the current hook count.

4

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

Returns a table with info about a function. You can give the function directly, or you can give a number as the value of function, which means the function running at level function of the call stack of the given thread − level 0 is the current function (getinfo itself); level 1 is the function that called getinfo; and so on. If function is a number larger than the number of active functions, then getinfo returns nil.

5

getlocal(optional thread, stack level, local index)

Returns the name and the value of the local variable with index local of the function at level of the stack.Returns nil if there is no local variable with the given index, and raises an error when called with a level out of range.

6

getmetatable(value)

Returns the metatable of the given object or nil if it does not have a metatable.

7

getregistry()

Returns the registry table,a pre-defined table that can be used by any C code to store whatever Lua value it needs to store.

8

getupvalue(function, upvalue index)

This function returns the name and the value of the upvalue with index up of the function func. The function returns nil if there is no upvalue with the given index.

9

setfenv(function or thread or userdata, environment table)

Sets the environment of the given object to the given table. Returns object.

10

sethook(optional thread, hook function, hook mask string with "c" and/or "r" and/or "l", optional instruction count)

Sets the given function as a hook. The string mask and the number count describes when the hook will be called. Here, c, r and l are called every time Lua calls, returns, and enters every line of code in a function respectively.

11

setlocal(optional thread, stack level, local index, value)

Assigns the value to the local variable with index local of the function at level of the stack. The function returns nil if there is no local variable with the given index, and raises an error when called with a level out of range. Otherwise, it returns the name of the local variable.

12

setmetatable(value, metatable)

Sets the metatable for the given object to the given table (which can be nil).

13

setupvalue(function, upvalue index, value)

This function assigns the value to the upvalue with index up of the function func. The function returns nil if there is no upvalue with the given index. Otherwise, it returns the name of the upvalue.

14

traceback(optional thread, optional message string, optional level argument)

Builds an extended error message with a traceback.

The above list is the complete list of debug functions in Lua and we often use a library that uses the above functions and provides easier debugging. Using these functions and creating our own debugger is quite complicated and is not preferable. Anyway, we will see an example of simple use of debugging functions.

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

   return 10
end

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

When we run the above program, we will get the stack trace as shown below.

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

In the above sample program, the stack trace is printed by using the debug.trace function available in the debug library. The debug.getinfo gets the current table of the function.

Debugging - Example

We often need to know the local variables of a function for debugging. For that purpose, we can use getupvalue and to set these local variables, we use setupvalue. A simple example for this is shown below.

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

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

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

In this example, the counter updates by one each time it is called. We can see the current state of the local variable using the getupvalue function. We then set the local variable to a new value. Here, n is 2 before the set operation is called. Using setupvalue function, it is updated to 10. Now when we call the counter function, it will return 11 instead of 3.

Debugging Types

  • Command line debugging
  • Graphical debugging

Command Line Debugging

Command line debugging is the type of debugging that uses command line to debug with the help of commands and print statements. There are many command line debuggers available for Lua of which a few are listed below.

  • RemDebug − RemDebug is a remote debugger for Lua 5.0 and 5.1. It lets you control the execution of another Lua program remotely, setting breakpoints and inspecting the current state of the program. RemDebug can also debug CGILua scripts.

  • clidebugger − A simple command line interface debugger for Lua 5.1 written in pure Lua. It's not dependent on anything other than the standard Lua 5.1 libraries. It was inspired by RemDebug but does not have its remote facilities.

  • ctrace − A tool for tracing Lua API calls.

  • xdbLua − A simple Lua command line debugger for the Windows platform.

  • LuaInterface - Debugger − This project is a debugger extension for LuaInterface. It raises the built in Lua debug interface to a higher level. Interaction with the debugger is done by events and method calls.

  • Rldb − This is a remote Lua debugger via socket, available on both Windows and Linux. It can give you much more features than any existing one.

  • ModDebug − This allows in controlling the execution of another Lua program remotely, set breakpoints, and inspect the current state of the program.

Graphical Debugging

Graphical debugging is available with the help of IDE where you are provided with visual debugging of various states like variable values, stack trace and other related information. There is a visual representation and step by step control of execution with the help of breakpoints, step into, step over and other buttons in the IDE.

There are number of graphical debuggers for Lua and it includes the following.

  • SciTE − The default windows IDE for Lua provides multiple debugging facilities like breakpoints, step, step into, step over, watch variables and so on.

  • Decoda − This is a graphical debugger with remote debugging support.

  • ZeroBrane Studio − Lua IDE with integrated remote debugger, stack view, watch view, remote console, static analyzer, and more. Works with LuaJIT, Love2d, Moai, and other Lua engines; Windows, OSX, and Linux. Open source.

  • akdebugger − Debugger and editor Lua plugin for Eclipse.

  • luaedit − This features remote debugging, local debugging, syntax highlighting, completion proposal list, parameter proposition engine, advance breakpoint management (including condition system on breakpoints and hit count), function listing, global and local variables listing, watches, solution oriented management.

Lua uses automatic memory management that uses garbage collection based on certain algorithms that is in-built in Lua. As a result of automatic memory management, as a developer −

  • No need to worry about allocating memory for objects.
  • No need to free them when no longer needed except for setting it to nil.

Lua uses a garbage collector that runs from time to time to collect dead objects when they are no longer accessible from the Lua program.

All objects including tables, userdata, functions, thread, string and so on are subject to automatic memory management. Lua uses incremental mark and sweep collector that uses two numbers to control its garbage collection cycles namely garbage collector pause and garbage collector step multiplier. These values are in percentage and value of 100 is often equal to 1 internally.

Garbage Collector Pause

Garbage collector pause is used for controlling how long the garbage collector needs to wait, before; it is called again by the Lua's automatic memory management. Values less than 100 would mean that Lua will not wait for the next cycle. Similarly, higher values of this value would result in the garbage collector being slow and less aggressive in nature. A value of 200, means that the collector waits for the total memory in use to double before starting a new cycle. Hence, depending on the nature and speed of application, there may be a requirement to alter this value to get best performance in Lua applications.

Garbage Collector Step Multiplier

This step multiplier controls the relative speed of garbage collector to that of memory allocation in Lua program. Larger step values will lead to garbage collector to be more aggressive and it also increases the step size of each incremental step of garbage collection. Values less than 100 could often lead to avoid the garbage collector not to complete its cycle and its not generally preferred. The default value is 200, which means the garbage collector runs twice as the speed of memory allocation.

Garbage Collector Functions

As developers, we do have some control over the automatic memory management in Lua. For this, we have the following methods.

  • collectgarbage("collect") − Runs one complete cycle of garbage collection.

  • collectgarbage("count") − Returns the amount of memory currently used by the program in Kilobytes.

  • collectgarbage("restart") − If the garbage collector has been stopped, it restarts it.

  • collectgarbage("setpause") − Sets the value given as second parameter divided by 100 to the garbage collector pause variable. Its uses are as discussed a little above.

  • collectgarbage("setstepmul") − Sets the value given as second parameter divided by 100 to the garbage step multiplier variable. Its uses are as discussed a little above.

  • collectgarbage("step") − Runs one step of garbage collection. The larger the second argument is, the larger this step will be. The collectgarbage will return true if the triggered step was the last step of a garbage-collection cycle.

  • collectgarbage("stop") − Stops the garbage collector if its running.

A simple example using the garbage collector example is shown below.

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)은 현대 프로그래밍 시대에 가장 많이 사용되는 프로그래밍 기술 중 하나입니다. 다음을 포함하는 OOP를 지원하는 여러 프로그래밍 언어가 있습니다.

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

OOP의 특징

  • Class − 클래스는 객체를 생성하기위한 확장 가능한 템플릿으로 상태 (멤버 변수) 및 동작 구현에 대한 초기 값을 제공합니다.

  • Objects − 클래스의 인스턴스이며 자체적으로 할당 된 별도의 메모리가 있습니다.

  • Inheritance − 한 클래스의 변수와 함수가 다른 클래스에 상속되는 개념입니다.

  • Encapsulation− 클래스 내에서 데이터와 함수를 결합하는 과정입니다. 데이터는 함수를 사용하여 클래스 외부에서 액세스 할 수 있습니다. 데이터 추상화라고도합니다.

Lua의 OOP

Lua의 테이블과 일급 함수를 사용하여 Lua에서 객체 방향을 구현할 수 있습니다. 함수 및 관련 데이터를 테이블에 배치하면 개체가 형성됩니다. 상속은 메타 테이블의 도움으로 구현 될 수 있으며, 존재하지 않는 함수 (메서드) 및 부모 개체의 필드에 대한 조회 메커니즘을 제공합니다.

Lua의 테이블은 값과 무관 한 상태 및 정체성과 같은 객체의 기능을 가지고 있습니다. 동일한 값을 가진 두 개체 (테이블)는 다른 개체 인 반면 개체는 서로 다른 시간에 다른 값을 가질 수 있지만 항상 같은 개체입니다. 개체와 마찬가지로 테이블에는 만든 사람이나 만든 위치와는 독립적 인 수명주기가 있습니다.

실제 사례

개체 방향의 개념은 널리 사용되지만 적절하고 최대의 이점을 얻으려면 명확하게 이해해야합니다.

간단한 수학 예를 고려해 보겠습니다. 우리는 종종 원형, 직사각형 및 정사각형과 같은 다른 모양으로 작업하는 상황에 직면합니다.

셰이프는 공통 속성 영역을 가질 수 있습니다. 따라서 공통 속성 영역을 사용하여 기본 개체 모양에서 다른 모양을 확장 할 수 있습니다. 각 모양은 고유 한 속성을 가질 수 있으며 직사각형과 같은 기능은 속성으로 길이, 너비, 영역을 속성으로 가질 수 있고 기능으로 printArea 및 calculateArea를 가질 수 있습니다.

간단한 클래스 만들기

세 가지 속성 영역, 길이 및 너비가있는 사각형에 대한 간단한 클래스 구현이 아래에 나와 있습니다. 계산 된 영역을 인쇄하는 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를 만들었습니다. 파생 클래스에서 기본 클래스의 함수를 재정의 할 수 있습니다. 이 예제에서 파생 클래스는 printArea 함수를 재정의합니다.

Lua는 매우 유연한 언어이며 웹 애플리케이션을 포함한 여러 플랫폼에서 자주 사용됩니다. Lua에서 오픈 소스 웹 구성 요소를 제공하기 위해 2004 년에 형성된 Kepler 커뮤니티입니다.

비록 개발 된 Lua를 사용하는 다른 웹 프레임 워크가 있지만, 우리는 주로 Kepler 커뮤니티에서 제공하는 구성 요소에 초점을 맞출 것입니다.

애플리케이션 및 프레임 워크

  • Orbit WSAPI를 기반으로하는 Lua 용 MVC 웹 프레임 워크입니다.

  • WSAPI Lua 웹 애플리케이션에서 웹 호스트 서버를 추상화하는 API이며 많은 프로젝트의 기반입니다.

  • Xavante WSAPI 인터페이스를 제공하는 Lua 웹 서버입니다.

  • Sputnik 유머와 엔터테인먼트에 사용되는 Kepler 프로젝트에서 WSAPI를 통해 개발 된 wiki / CMS입니다.

  • CGILuaWSAPI를 기반으로하지만 더 이상 지원되지 않는 LuaPages 및 LuaScripts 웹 페이지 생성을 제공합니다. 대신 Orbit, Sputnik 또는 WSAPI를 사용하세요.

이 튜토리얼에서는 Lua가 무엇을 할 수 있는지 이해하고 설치 및 사용에 대해 더 많이 알기 위해 웹 사이트 kepler를 참조하십시오.

궤도

Orbit은 Lua를위한 MVC 웹 프레임 워크입니다. 각 Orbit 응용 프로그램이 단일 파일에 들어갈 수 있지만 원하는 경우 여러 파일로 분할 할 수있는 응용 프로그램을 위해 "스크립트"의 CGILua 모델을 완전히 포기합니다.

모든 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 /> 섹션 아래에 다음 섹션을 추가합니다. 이 섹션에 'AllowOverride None'이있는 경우 .htaccess 파일이 구성을 로컬로 재정의 할 수 있도록 'None'을 'All'로 변경해야합니다.

<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

이제 웹 브라우저를 시작할 수 있습니다. 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를 사용하여 웹 프로그래밍을 쉽게 할 수 있습니다. 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

Xavante는 URI 매핑 처리기를 기반으로 모듈 식 아키텍처를 사용하는 Lua HTTP 1.1 웹 서버입니다. 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 웹 구성 요소

  • Copas, TCP / IP 서버에서 사용할 수있는 코 루틴 기반 디스패처.

  • Cosmo, 템플릿의 임의 코드로부터 애플리케이션을 보호하는 "안전한 템플릿"엔진입니다.

  • Coxpcall 루아 네이티브 pcall과 xpcall을 코 루틴과 호환되는 것들로 캡슐화합니다.

  • LuaFileSystem, 기본 디렉토리 구조 및 파일 속성에 액세스하는 이식 가능한 방법입니다.

  • Rings, Lua 내에서 새로운 Lua 상태를 만드는 방법을 제공하는 라이브러리입니다.

엔딩 노트

우리가 사용할 수있는 Lua 기반 웹 프레임 워크와 구성 요소가 너무 많으며 필요에 따라 선택할 수 있습니다. 다음을 포함하는 다른 웹 프레임 워크가 있습니다.

  • MoonstalkLua 언어로 구축 된 동적 생성 웹 기반 프로젝트를 효율적으로 개발하고 호스팅 할 수 있습니다. 기본 페이지에서 복잡한 애플리케이션까지.

  • Lapis, OpenResty라는 Nginx의 사용자 정의 버전 내에서 실행되는 MoonScript (또는 Lua)를 사용하여 웹 애플리케이션을 빌드하기위한 프레임 워크입니다.

  • Lua Server Pages, 임베디드 웹 개발에 대한 다른 접근 방식을 날려 버리는 Lua 스크립팅 엔진 플러그인은 기존 C 서버 페이지에 대한 극적인 지름길을 제공합니다.

이러한 웹 프레임 워크는 웹 애플리케이션을 활용하고 강력한 작업을 수행하는 데 도움이됩니다.

간단한 데이터 작업의 경우 파일을 사용할 수 있지만 때로는 이러한 파일 작업이 효율적이고 확장 가능하며 강력하지 않을 수 있습니다. 이를 위해 우리는 종종 데이터베이스 사용으로 전환 할 수 있습니다. LuaSQL은 Lua에서 여러 데이터베이스 관리 시스템에 대한 간단한 인터페이스입니다. LuaSQL은 다양한 유형의 SQL을 지원하는 라이브러리입니다. 여기에는 다음이 포함됩니다.

  • SQLite
  • Mysql
  • ODBC

이 튜토리얼에서는 Lua에서 MySQL 및 SQLite의 데이터베이스 처리를 다룰 것입니다. 이것은 두 가지 모두에 대해 일반 인터페이스를 사용하며이 구현을 다른 유형의 데이터베이스에도 이식 할 수 있어야합니다. 먼저 MySQL에서 작업을 수행하는 방법을 살펴 보겠습니다.

MySQL db 설정

다음 예제를 사용하여 예상대로 작동하려면 초기 db 설정이 필요합니다. 가정은 다음과 같습니다.

  • 기본 사용자는 루트로, 암호는 '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 유형의 이름이있는 테이블을 작성합니다.

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 )

위 프로그램을 실행하면 id와 name이라는 두 개의 컬럼이있는 sample이라는 테이블이 생성됩니다.

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

Insert 문 예

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 문에 관한 한 각 행을 반복하고 필요한 데이터를 추출해야합니다. 간단한 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

거래 수행

트랜잭션은 데이터 일관성을 보장하는 메커니즘입니다. 거래는 다음 네 가지 속성을 가져야합니다-

  • Atomicity − 거래가 완료되거나 아무 일도 일어나지 않습니다.

  • Consistency − 트랜잭션은 일관된 상태에서 시작하고 시스템을 일관된 상태로 유지해야합니다.

  • Isolation − 거래의 중간 결과는 현재 거래 외부에서 볼 수 없습니다.

  • Durability − 트랜잭션이 커밋되면 시스템 장애 후에도 효과가 지속됩니다.

거래는 START TRANSACTION으로 시작됩니다. 커밋 또는 롤백 문으로 끝납니다.

거래 시작

트랜잭션을 시작하려면 conn이 열린 MySQL 연결이라고 가정하고 Lua에서 다음 문을 실행해야합니다.

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

롤백 트랜잭션

시작 트랜잭션이 실행 된 후 변경된 내용을 롤백하려면 다음 문을 실행해야합니다.

conn:execute([[ROLLBACK;]])

트랜잭션 커밋

시작 트랜잭션이 실행 된 후 변경된 내용을 커밋하려면 다음 문을 실행해야합니다.

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 유형의 이름이있는 테이블을 작성합니다.

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 )

위 프로그램을 실행하면 id와 name이라는 두 개의 컬럼이있는 sample이라는 테이블이 생성됩니다.

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

오류가 발생하면 nil 대신 오류 문이 반환됩니다. 다음은 간단한 오류 설명입니다.

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

Insert 문 예

SQLite에 대한 삽입 문은 아래와 같습니다.

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

Select 문 예

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 및 기타 지원되는 db에서 사용할 수있는 다양한 쿼리 문을 실험합니다.

Lua는 단순한 언어 구조와 구문으로 인해 많은 게임 엔진에서 사용됩니다. 가비지 컬렉션 기능은 사용되는 풍부한 그래픽으로 인해 많은 메모리를 소비하는 게임에서 종종 매우 유용합니다. Lua를 사용하는 일부 게임 엔진에는 다음이 포함됩니다.

  • 코로나 SDK
  • Gideros Mobile
  • ShiVa3D
  • Moai SDK
  • LOVE
  • CryEngine

이러한 각 게임 엔진은 Lua를 기반으로하며 각 엔진에서 사용할 수있는 풍부한 API 세트가 있습니다. 각각의 기능을 간략하게 살펴 보겠습니다.

코로나 SDK

Corona SDK는 iPhone, iPad 및 Android 플랫폼을 지원하는 크로스 플랫폼 모바일 게임 엔진입니다. 제한된 기능을 가진 작은 게임에 사용할 수있는 Corona SDK의 무료 버전이 있습니다. 필요한 경우 다른 버전으로 업그레이드 할 수 있습니다.

Corona SDK는 다음을 포함하는 여러 기능을 제공합니다.

  • 물리 및 충돌 처리 API
  • 웹 및 네트워크 API
  • 게임 네트워크 API
  • Ads API
  • 분석 API
  • 데이터베이스 및 파일 시스템 API
  • 암호화 및 수학 API
  • 오디오 및 미디어 API

iOS 및 Android 용으로 기본 API를 별도로 사용하는 것보다 위 API를 사용하여 애플리케이션을 개발하는 것이 더 쉽고 빠릅니다.

Gideros Mobile

Gideros는 iOS 및 Android 용 게임을 만들기위한 크로스 플랫폼 SDK를 제공합니다. Made with Gideros 스플래시와 함께 무료로 사용할 수 있습니다. Gideoros의 눈에 띄는 장점 중 일부는 다음과 같습니다.

  • Development IDE − Gideros 앱을 쉽게 개발할 수 있도록 자체 IDE를 제공합니다.

  • Instant testing− 게임을 개발하는 동안 Wi-Fi를 통해 단 1 초만에 실제 기기에서 테스트 할 수 있습니다. 내보내기 또는 배포 프로세스에 시간을 낭비 할 필요가 없습니다.

  • Plugins− 플러그인을 사용하여 쉽게 코어를 확장 할 수 있습니다. 기존 (C, C ++, Java 또는 Obj-C) 코드를 가져 와서 Lua에 바인딩하고 직접 해석하십시오. 수십 개의 오픈 소스 플러그인이 이미 개발되어 사용할 준비가되었습니다.

  • Clean OOP approach − Gideros는 모든 기본 OOP 표준을 갖춘 자체 클래스 시스템을 제공하므로 향후 게임에 대해 깨끗하고 재사용 가능한 코드를 작성할 수 있습니다.

  • Native speed − C / C ++ 및 OpenGL을 기반으로 개발 된 게임은 기본 속도로 실행되며 그 아래에있는 CPU 및 GPU의 성능을 완전히 활용합니다.

ShiVa3D

ShiVa3D는 웹, 콘솔 및 모바일 장치 용 애플리케이션 및 비디오 게임을 생성하도록 설계된 그래픽 편집기를 제공하는 3D 게임 엔진 중 하나입니다. Windows, Mac, Linux, iOS, Android, BlackBerry, Palm OS, Wii 및 WebOS를 포함한 여러 플랫폼을 지원합니다.

주요 기능 중 일부는 다음과 같습니다.

  • 표준 플러그인
  • 메시 수정 API
  • IDE
  • 내장 지형, 해양 및 애니메이션 편집기
  • ODE 물리 엔진 지원
  • 완전한 라이트 맵 제어
  • 재료, 입자, 트레일 및 HUD에 대한 실시간 미리보기
  • Collada 교환 형식 지원

Shiva3d의 웹 에디션은 완전 무료이며 구독중인 다른 에디션도 있습니다.

Moai SDK

Moai SDK는 iPhone, iPad 및 Android 플랫폼을 지원하는 크로스 플랫폼 모바일 게임 엔진입니다. Moai 플랫폼은 처음에 오픈 소스 게임 엔진 인 Moai SDK와 게임 서비스의 호스팅 및 배포를위한 클라우드 플랫폼 인 Moai Cloud로 구성되었습니다. 이제 Moai Cloud가 종료되고 게임 엔진 만 사용할 수 있습니다.

Moai SDK는 iOS, Android, Chrome, Windows, Mac 및 Linux를 포함한 여러 플랫폼에서 실행됩니다.

사랑

LOVE는 2D 게임을 만드는 데 사용할 수있는 프레임 워크입니다. 무료이며 오픈 소스입니다. Windows, Mac OS X 및 Linux 플랫폼을 지원합니다.

다음을 포함하는 여러 기능을 제공합니다.

  • 오디오 API
  • 파일 시스템 API
  • 키보드 및 조이스틱 API
  • 수학 API
  • 창 및 마우스 API
  • 물리 API
  • 시스템 및 타이머 API

크라이 엔진

CryEngine은 독일 게임 개발자 Crytek에서 개발 한 게임 엔진입니다. 1 세대에서 4 세대로 발전했으며 고급 개발 솔루션입니다. PC, Xbox 360, PlayStation3 및 WiiU 게임을 지원합니다.

다음을 포함하는 여러 기능을 제공합니다.

  • Natural Lighting & Dynamic Soft Shadows, Real-time Dynamic Global Illumination, Light Propagation Volume, Particle Shading, Tessellation 등과 같은 시각 효과.

  • 캐릭터 애니메이션 시스템 및 캐릭터 개별화 시스템.

  • 파라 메트릭 스켈 레탈 애니메이션 및 고유 한 전용 얼굴 애니메이션 편집기

  • Multi-Layer Navigation Mesh 및 Tactical Point System과 같은 AI 시스템. 디자이너 친화적 인 AI 편집 시스템도 제공합니다.

  • 게임 믹싱 및 프로파일 링, 데이터 기반 사운드 시스템 다이나믹 사운드 및 인터랙티브 음악 등.

  • Procedural Deformation 및 Advanced Rope Physics와 같은 물리 기능.

엔딩 노트

이러한 각 게임 SDK / 프레임 워크에는 고유 한 장점과 단점이 있습니다. 그들 사이의 적절한 선택은 당신의 작업을 더 쉽게 만들고 당신은 더 좋은 시간을 가질 수 있습니다. 따라서 사용하기 전에 게임의 요구 사항을 파악한 다음 모든 요구 사항을 충족하는 항목을 분석 한 다음 사용해야합니다.

Lua 표준 라이브러리는 C API로 직접 구현되고 Lua 프로그래밍 언어로 내장 된 풍부한 기능 세트를 제공합니다. 이러한 라이브러리는 Lua 프로그래밍 언어 내에서 서비스를 제공하며 파일 및 db 작업과 같은 외부 서비스도 제공합니다.

공식 C API에 내장 된 이러한 표준 라이브러리는 별도의 C 모듈로 제공됩니다. 그것은 다음을 포함합니다-

  • 코 루틴 하위 라이브러리를 포함하는 기본 라이브러리
  • 모듈 라이브러리
  • 문자열 조작
  • 테이블 조작
  • 수학 라이브러리
  • 파일 입력 및 출력
  • 운영 체제 시설
  • 디버그 기능

기본 라이브러리

다양한 주제로 튜토리얼 전체에서 기본 라이브러리를 사용했습니다. 다음 표는 관련 페이지의 링크를 제공하고이 Lua 튜토리얼의 다양한 부분에서 다루는 기능을 나열합니다.

Sr. 아니. 도서관 / 방법 및 목적
1

Error Handling

Lua-Error Handling에 설명 된대로 assert, error와 같은 오류 처리 기능을 포함합니다 .

2

Memory Management

Lua-Garbage Collection에 설명 된대로 가비지 수집과 관련된 자동 메모리 관리 기능을 포함합니다 .

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

로드와 유사하지만 파일 이름이 지정되지 않은 경우 파일 파일 이름 또는 표준 입력에서 청크를 가져옵니다.

10

loadstring (string [, chunkname])

load와 비슷하지만 주어진 문자열에서 청크를 가져옵니다.

11

next (table [, index])

프로그램이 테이블의 모든 필드를 순회 할 수 있도록합니다. 첫 번째 인수는 테이블이고 두 ​​번째 인수는이 테이블의 인덱스입니다. 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가 숫자이면 인수 번호 index 뒤의 모든 인수를 반환합니다. 그렇지 않으면 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

현재 인터프리터 버전을 포함하는 문자열을 보유하는 전역 변수 (함수 아님). 이 변수의 현재 내용은 "Lua 5.1"입니다.

25

Coroutines

루아- 코 루틴에 설명 된 코 루틴 조작 함수를 포함합니다 .

모듈 라이브러리

모듈 라이브러리는 Lua에서 모듈을로드하기위한 기본 기능을 제공합니다. 전역 환경에서 직접 하나의 기능을 내 보냅니다. require. 다른 모든 것은 테이블 패키지로 내보내집니다. 모듈 라이브러리에 대한 자세한 내용은 이전 장 Lua-모듈 자습서 에서 설명합니다 .

문자열 조작

Lua는 다양한 문자열 조작 기능을 제공합니다. 이전 Lua-Strings 튜토리얼에서 이에 대해 자세히 다룹니다.

테이블 조작

Lua는 거의 모든 작업에서 테이블에 의존합니다. 이전 Lua-Tables 자습서에서 이에 대해 자세히 설명합니다.

파일 입력 및 출력

우리는 종종 프로그래밍에 데이터 저장 시설이 필요하며 이것은 Lua의 파일 I / O를위한 표준 라이브러리 함수에 의해 제공됩니다. 이는 이전 Lua-파일 I / O 튜토리얼 에서 논의되었습니다 .

디버그 기능

Lua는 자체 디버거를 생성 할 수있는 모든 기본 기능을 제공하는 디버그 라이브러리를 제공합니다. 이는 이전 Lua-디버깅 튜토리얼 에서 논의되었습니다 .

우리는 종종 과학 및 공학 계산에서 수학 연산이 필요하며 표준 Lua 라이브러리 수학을 사용하여이를 활용할 수 있습니다. 수학 라이브러리에서 사용할 수있는 함수 목록은 다음 표에 나와 있습니다.

Sr. 아니. 도서관 / 방법 및 목적
1

math.abs (x)

x의 절대 값을 반환합니다.

2

math.acos (x)

x의 아크 코사인 (라디안)을 반환합니다.

math.asin (x)

x의 아크 사인 (라디안)을 반환합니다.

4

math.atan (x)

x의 아크 탄젠트 (라디안)를 반환합니다.

5

math.atan2 (y, x)

y / x의 아크 탄젠트 (라디안)를 반환하지만 두 매개 변수의 부호를 사용하여 결과의 ​​사분면을 찾습니다. (또한 x가 0 인 경우를 올바르게 처리합니다.)

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 제곱 x 값을 반환합니다.

11

math.floor (x)

x보다 작거나 같은 가장 큰 정수를 반환합니다.

12

math.fmod (x, y)

몫을 0으로 반올림하는 y로 x를 나눈 나머지를 반환합니다.

13

math.frexp (x)

x = m2e, e는 정수, m의 절대 값이 범위 [0.5, 1) (또는 x가 0 인 경우 0)가되도록 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의 분수 부분의 두 숫자를 반환합니다.

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] 범위의 균일 한 의사 난수 정수를 반환합니다. 두 개의 정수 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

위의 예제는 일반적인 예제 중 일부에 불과하며 필요에 따라 수학 라이브러리를 사용할 수 있으므로 모든 함수를 더 익숙하게 사용해보십시오.

모든 응용 프로그램에서 종종 운영 체제 수준 기능에 액세스해야하며 운영 체제 라이브러리에서 사용할 수 있습니다. 사용 가능한 기능 목록은 다음 표에 나열되어 있습니다.

Sr. 아니. 도서관 / 방법 및 목적
1

os.clock ()

프로그램에서 사용하는 CPU 시간의 근사치를 초 단위로 반환합니다.

2

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

주어진 문자열 형식에 따라 형식이 지정된 날짜 및 시간이 포함 된 문자열 또는 테이블을 반환합니다.

os.difftime (t2, t1)

시간 t1에서 시간 t2까지의 시간 (초)을 반환합니다. POSIX, Windows 및 일부 기타 시스템에서이 값은 정확히 t2-t1입니다.

4

os.execute ([command])

이 함수는 ANSI C 함수 시스템과 동일합니다. 운영 체제 셸에서 실행할 명령을 전달합니다. 첫 번째 결과는 명령이 성공적으로 종료되면 참이고 그렇지 않으면 nil입니다.

5

os.exit ([code [, close])

ANSI C 함수 종료를 호출하여 호스트 프로그램을 종료합니다. 코드가 참이면 반환 된 상태는 EXIT_SUCCESS입니다. 코드가 거짓이면 반환 된 상태는 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", "collate", "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 라이브러리를 사용할 수 있으므로 모든 기능을 더 익숙하게 사용해보십시오. 파일 제거에 도움이되는 remove, 위에서 설명한대로 OS 명령을 실행하는 데 도움이되는 실행 기능이 있습니다.