Script Programming(스크립트 프로그래밍)

아래의 소스 코드는 Groovy로도 실행되는 Java 용 소스파일 TestWhileLoop.java를 Groovy 용으로 Groovy 언어 답게 고친 것이다.

소스 파일명: testWhile.groovy

1. /*
2.  *  Filename: testWhile.groovy
3.  *
4.  *  Purpose:  Example using the while loop syntax
5.  *                while ....
6.  *
7.  *  Execute: groovy testWhile.groovy -200 300
8.  *
9.  */
11. // java.lang.Math 클래스를 명시적으로 import하는 구문이 없어도
12. // Groovy는 이 클래스를 자동으로 import한다.
14. // 사용법 표시
15. def printUsage() {
16.     println 'Using: groovy testWhile.groovy [integer1] [integer2]'
17.     println 'This finds the greatest common divisor of the given two integers.'
18. }
20. if (args.length != 2) {
21.     printUsage()
22.     System.exit(1)
23. }
25. def val1 = args[0].toLong()
26. def val2 = args[1].toLong()
27. def a, b, q, r, gcd
29. ////////////////////////////////////////////////
30. // 명령행 인자의 두 스트링을 가져와서
31. // 긴정수(long) 타입으로 변환하여
32. // 변수 val1과 val2에 저장한다.
33. a = val1.abs()
34. b = val2.abs()
36. // a는 |val1|, |val2| 중 큰 값
37. if (a < b) {
38.     a = val2.abs()
39.     b = val1.abs()
40. }
42. if (b == 0L) {
43.     println "GCD($val1, $val2) = $a"
44.     System.exit(0)
45. }
47. ////////////////////////////////////////
48. // Euclidean 알고리즘의 시작
49. //
50. // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
51. q = a / b
52. r = a % b
54. ////////////////////////////////////////
55. // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
56. while (r != 0L) {
57.     a = b
58.     b = r
59.     q = a / b
60.     r = a % b
61. }
63. // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
64. gcd = b
66. // 최대공약수(GCD)를 출력한다.
67. println "GCD($val1, $val2) = $gcd"

실행> groovy testWhile.groovy
Using: groovy testWhile.groovy [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> groovy testWhile.groovy -50, 200
GCD(-50, 200) = 50

실행> groovy testWhile.groovy 50, -30
GCD(50, -30) = 10

실행> groovy testWhile.groovy 0. 30
GCD(0, 30) = 30





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: TestWhileLoop.java

1. /*
2.  *  Filename: TestWhileLoop.java
3.  *
4.  *  Purpose:  Example using the while loop syntax
5.  *                while ....
6.  *
7.  *  Compile: javac -d . TestWhileLoop.java
8.  *  Execute: java TestWhileLoop -200 300
9.  *
10.  */
12. import java.lang.Math;
13. public class TestWhileLoop {
15.     // 사용법 표시
16.     public static void printUsage() {
17.          System.out.println("Using: java TestWhileLoop [integer1] [integer2]");
18.          System.out.println("This finds the greatest common divisor of the given two integers.");
19.     }
21.     // Java 애플리케이션의 실행 시작 시점 main 메소드
22.     // (C 언어의 main 함수에 해당)
23.     public static void main(String[] args) {
24.         if (args.length != 2) {
25.             printUsage();
26.             System.exit(1);
27.         }
29.         ////////////////////////////////////////////////
30.         // 명령행 인자의 두 스트링을 가져와서
31.         // 긴정수(long) 타입으로 변환하여
32.         // 변수 val1과 val2에 저장한다.
33.         long val1 = Long.parseLong(args[0]);
34.         long val2 = Long.parseLong(args[1]);
35.         long a, b, q, r, gcd;    // r은 나머지, q는 몫
37.         // a는 |val1|, |val2| 중 큰 값
38.         a = Math.abs(val1);
39.         b = Math.abs(val2);
40.         if (a < b) {
41.             a = Math.abs(val2);
42.             b = Math.abs(val1);
43.         }
45.         if (b == 0L) {
46.             System.out.println("GCD(" + val1 + ", " + val2 + ") = " + a);
47.             System.exit(0);
48.         }
50.         ////////////////////////////////////////
51.         // Euclidean 알고리즘의 시작
52.         //
53.         // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
54.         q = a / b;
55.         r = a % b;
56.         ////////////////////////////////////////
57.         // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
58.         while (r != 0L) {
59.             a = b;
60.             b = r;
61.             q = a / b;
62.             r = a % b;
63.         }
65.         // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
66.         gcd = b;
67.         // 최대공약수(GCD)를 출력한다.
68.         System.out.println("GCD(" + val1 + ", " + val2 + ") = " + gcd);
69.     }
70. }
    

컴파일> javac -d . TestWhileLoop.java

실행> java TestWhileLoop
Using: java TestWhileLoop [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> java TestWhileLoop 200 300
GCD(200, 300) = 100

실행> java TestWhileLoop 50, -20
GCD(50, -20) = 10

실행> java TestWhileLoop -30, 0
GCD(-30, 0) = 30



Groovy를 사용하면 위의 소스를 (컴파일 과정 없이) 그대로 실행시킬 수 있다. 그대신 파일 확장자명을 groovy로 하여 저장하여야 한다. 아래는 파일명을 TestWhileLoop.groovy로 저장하여 실행시칸 경우이다.


실행> groovy TestWhileLoop.groovy
Using: java TestWhileLoop [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

실행> groovy TestWhileLoop.groovy -200 500
GCD(-200, 500) = 100

실행> groovy TestWhileLoop.groovy 108, 180
GCD(108, 180) = 36

실행> groovy TestArguments.groovy -30, 0
GCD(-30, 0) = 30





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: testIf.lua

1. --[[
2.    Filename: testIf.lua
4.    Purpose:  Example using the conditional control structure syntax
5.                  if .... else ...
7.    Execute: lua testIf.lua [number]
8. --]]
10. -- 사용법을 보여주는 함수
11. function printUsing()
12.    print("Using: ruby testIf.rb [number]")
13.    print("This determines whether the number is positive or not.")
14. end
16. -- 명령행 인자의 개수가 1이 아니면 사용법을 보여준다.
17. if #arg ~= 1 then
18.     printUsing()
19.     os.exit(1)
20. end
22. -- 명령행 인자의 스트링을 가져와서
23. -- 배정밀도 부동소수점수로 변환하여
24. -- 변수 val에 저장한다.
25. val = tonumber(arg[1])
27. -- 변수 val에 저장된 값이 양수인지 음수인지 0인지를
28. -- 판단하는 if...else... 조건문
29. if (val > 0.0) then
30.     print(val .. " is a positive number.")
31. elseif (val < 0.0) then
32.     print(val .. " is a negative number.")
33. else
34.     print(val .. " is zero.")
35. end
    

실행> lua testIf.lua
Using: lua testIf.lua [number]
This determines whether the number is positive or not.

실행> lua testIf.lua 1.21
1.21 is a positive number.

실행> lua testIf.lua -1.21
-1.21 is a negative number.

실행> lua testIf.lua 0
0 is zero.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: testIfCPP.cpp

1. #include <iostream>
2. #include <cmath>        // atof() 함수 사용을 위해
4. using namespace std;    // cout 사용을 위해
6. // 사용법 표시 함수
7. void printUsing() {
8.     cout << "Using: testIfCPP [number]\n";
9.     cout << "This determines whether the number is positive or not.\n";
10. }
12. // main 함수
13. int main(int argc, char *argv[]) {
14.     float val;
15.     if (argc != 2) {
16.         printUsing();
17.         exit(1);
18.         return 1;
19.     }
21.     // 명령행 인자의 스트링을 가져와서
22.     // 배정밀도 부동소수점수로 변환하여
23.     // 변수 val에 저장한다.
24.     val = atof(argv[1]);
26.     // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
27.     // 판단하는 if...else... 조건문
28.     if (val > 0.0)
29.         cout << val << " is a positive number.\n";
30.     else if (val < 0.0)
31.         cout << val << " is a negative number.\n";
32.     else
33.         cout << val << " is zero.\n";
34.     return 0;
35. }
    

컴파일> cl /GX testIfCPP.cpp

실행> testIfCPP
Using: testIfCPP [number]
This determines whether the number is positive or not.

실행> testIfCPP 1.234
1.234 is a positive number.

실행> testIfCPP 1.234
-1.234 is a negative number.

실행> testIfCPP 0
0 is zero.



※ Ch 5.5를 사용하여 컴피일 과정 없이 소스를 실행시키려면 인클루드문

        #incldue <cmath>

을

        #incldue <math.h>

로 고치면 된다. 그대신 부동소수점수의 출력이 다소 다르다.



실행> ch testIfCPP.cpp
Using: testIfCPP [number]
This determines whether the number is positive or not.

실행> ch testCPP.cpp 2.7
2.7000 is a positive number.

실행> ch testCPP.cpp -2.7
-2.7000 is a negative number.

실행> ch testCPP.cpp 0
0 is zero.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: testIf.c

1. #include <stdio.h>
2. #include <stdlib.h>
4. // 사용법 표시 함수
5. void printUsing() {
6.     printf("Using: testIf [number]\n");
7.     printf("This determines whether the number is positive or not.\n");
8. }
10. // main 함수
11. int main(int argc, char *argv[]) {
12.     float val;
13.     if (argc != 2) {
14.         printUsing();
15.         exit(1);
16.         return 1;
17.     }
19.     // 명령행 인자의 스트링을 가져와서
20.     // 배정밀도 부동소수점수로 변환하여
21.     // 변수 val에 저장한다.
22.     val = atof(argv[1]);
24.     // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
25.     // 판단하는 if...else... 조건문
26.     if (val > 0.0)
27.         printf("%g is a positive number.\n", val);
28.     else if (val < 0.0)
29.         printf("%g is a negative number.\n", val);
30.     else
31.         printf("%g is zero.\n", val);
32.     return 0;
33. }
    

컴파일> cl testIf.c

실행> testIf
Using: testIf [number]
This determines whether the number is positive or not.

실행> testIf 1.234
1.234 is a positive number.

실행> testIf -1.234
-1.234 is a negative number.

실행> testIf 0
0 is zero.


※ Ch를 사용하면 위의 소스 코드를 (컴파일 과정 없이) 그대로 실행시킬 수 있다.

실행> ch testIf.c
Using: testIf [number]
This determines whether the number is positive or not.

실행> ch testIf.c 1.01
1.01 is a positive number.

실행> ch testIf.c -1.01
-1.01 is a negative number.

실행> ch testIf.c 0
0 is zero.

소스 파일명: testIf.py

1. # coding=euc-kr
2. """
3.    Filename: testIf.py
5.    Purpose:  Example using the conditional control structure syntax
6.                  if .... else ...
8.    Execute: python testIf.py [number]
9. """
11. import sys    # sys.argv를 위한 수입(import) 구문
13. # 사용법을 보여주는 함수
14. def printUsing():
15.    print("Using: python testIf.py [number]")
16.    print("This determines whether the number is positive or not.")
18. # 명령행 인자의 개수가 1이 아니면 사용법을 보여준다.
19. if len(sys.argv) != 2:
20.     printUsing()
21.     sys.exit(1)
23. # 명령행 인자의 스트링을 가져와서
24. # 배정밀도 부동소수점수로 변환하여
25. # 변수 val에 저장한다.
26. val = float(sys.argv[1])
28. # 변수 val에 저장된 값이 양수인지 음수인지 0인지를
29. # 판단하는 if...else... 조건문
30. if val > 0.0:
31.     print("%g is a positive number." % val)
32. elif val < 0.0:
33.     print("%g is a negative number." % val)
34. else:
35.     print("%g is zero." % val)
    

실행> python testIf.py
Using: python testIf.py [number]
This determines whether the number is positive or not.

실행> python testIf.py 6.25
6.25 is a positive number.

실행> python testIf.py -6.25
-6.25 is a negative number.

실행> python testIf.py 0
0 is zero.


※ 위의 소스 코드는 Jython으로도 수정 없이 그대로 실행된다.

실행> jython testIf.py
Using: python testIf.py [number]
This determines whether the number is positive or not.

실행> jython testIf.py 1.02
1.02 is a positive number.

실행> jython testIf.py -1.02
-1.02 is a negative number.

실행> jython testIf.py 0
0 is zero.


위의 소스 코드는 ipy 명령에 의하여 IronPython에서도 수정 없이 그대로 실행된다.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: testIf.rb

1. =begin
2.    Filename: testIf.rb
4.    Purpose:  Example using the conditional control structure syntax
5.                  if .... else ...
7.    Execute: ruby testIf.rb [number]
8. =end
10. # 사용법을 보여주는 함수
11. def printUsing()
12.    print("Using: ruby testIf.rb [number]\n")
13.    print("This determines whether the number is positive or not.\n")
14. end
16. # 명령행 인자의 개수가 1이 아니면 사용법을 보여준다.
17. if (ARGV.length != 1)
18.     printUsing()
19.     exit(1)
20. end
22. # 명령행 인자의 스트링을 가져와서
23. # 배정밀도 부동소수점수로 변환하여
24. # 변수 val에 저장한다.
25. val = ARGV[0].to_f
27. # 변수 val에 저장된 값이 양수인지 음수인지 0인지를
28. # 판단하는 if...else... 조건문
29. if (val > 0.0)
30.     print("#{val} is a positive number.\n")
31. elsif (val < 0.0)
32.     print("#{val} is a negative number.\n")
33. else
34.     print("#{val} is zero.\n")
35. end
    

실행> ruby testIf.rb
Using: ruby testIf.rb [number]
This determines whether the number is positive or not.

실행> ruby testIf.rb 1.2
1.2 is a positive number.

실행> ruby testIf.rb -1.2
-1.2 is a negative number.

실행> ruby testIf.rb 0
0.0 is zero.



※ 위의 소스 코드는 JRuby로도 (수정 없이) 그대로 실행된다.

실행> jruby testIf.rb
Using: ruby testIf.rb [number]
This determines whether the number is positive or not.

실행> jruby testIf.rb 3.14
3.14 is a positive number.

실행> jruby testIf.rb -3.14
-3.14 is a negative number.

실행> jruby testIf.rb 0
0.0 is zero.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: testIf.groovy

1. /*
2.  *  Filename: testIf.groovy
3.  *
4.  *  Purpose:  Example using the conditional control structure syntax
5.  *                if .... else ...
6.  *
7.  *  Execute: groovy testIf.groovy [number]
8.  */
10. def printUsing() {
11.    println("Using: groovy testIf.groovy [number]")
12.    println("This determines whether the number is positive or not.")
13. }
15. if (args.length != 1) {
16.     printUsing()
17.     System.exit(1)
18. }
20. ////////////////////////////////////////////////
21. // 명령행 인자의 스트링을 가져와서
22. // 배정밀도 부동소수점수로 변환하여
23. // 변수 val에 저장한다.
24. def val = args[0].toDouble()
26. // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
27. // 판단하는 if...else... 조건문
28. if (val > 0.0)
29.     println("$val is a positive number.")
30. else if (val < 0.0)
31.     println("$val is a negative number.")
32. else
33.     println("$val is zero.")

실행> groovy testIf.groovy
Using: groovy testIf.groovy [number]
This determines whether the number is positive or not.

실행> groovy testIf.groovy 5
5 is a positive number.

실행> groovy testIf.groovy -5
-5 is a negative number.

실행> groovy testIf.groovy 0
0.0 is zero.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

소스 파일명: TestIfThen.java

1. public class TestIfThen {
3.     public static void printUsing() {
4.         System.out.println("Using: java TestIfThen [number]");
5.         System.out.println("This determines whether the number is positive or not.");
6.     }
8.     // C 언어의 main 함수에 준하는 Java 언어의 main 메소드
9.     public static void main(String[] args) {
10.         if (args.length != 1) {
11.             printUsing();
12.             System.exit(1);
13.         }
14.         ////////////////////////////////////////////////
15.         // 명령행 인자의 스트링을 가져와서
16.         // 배정밀도 부동소수점수로 변환하여
17.         // 변수 val에 저장한다.
18.         double val = Double.parseDouble(args[0]);
20.         // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
21.         // 판단하는 if...else... 조건문
22.         if (val > 0.0)
23.             System.out.println(val + " is a positive number.");
24.         else if (val < 0.0)
25.             System.out.println(val + " is a negative number.");
26.         else
27.             System.out.println(val + " is zero.");
28.     }
29. }
    

컴파일> javac -d . TestIfThen.java

실행> java TestIfThen
Using: java TestIfThen [number]
This determines whether the number is positive or not.

실행> java TestIfThen 2.1
2.1 is a positive number.

실행> java TestIfThen -2.1
-2.1 is a negative number.

실행> java TestIfThen 0
0.0 is zero.



Groovy를 사용하면 위의 소스를 (컴파일 과정 없이) 그대로 실행시킬 수 있다. 그대신 파일 확장자명을 groovy로 하여 저장하여야 한다. 아래는 파일명을 TestIfThen.groovy로 저장하여 실행시칸 경우이다.


실행> groovy TestIfThen.groovy
Using: java TestIfThen [number]
This determines whether the number is positive or not.

실행> groovy TestIfThen.groovy 2.1
2.1 is a positive number.

실행> groovy TestIfThen.groovy -2.1
-2.1 is a negative number.

실행> groovy TestIfThen.groovy 0
0.0 is zero.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

1. -- 명령행 인자(command-line argument) 개수 출력
2. print( "Count of arguments: " .. #arg )
4. sum = 0.0
5. for i = 1, #arg do
6.     -- 스트링을 부동소수점수로 변환하여 누적
7.     sum = sum + tonumber(arg[i])
8. end
10. -- 누적된 값을 출력
11. print( "The sum of arguments is " .. sum)
    

실행> lua testArguments.lua 1 2 3 4
Count of arguments: 4
The sum of arguments is 10

실행> lua testArguments.lua 1 2 3 4.5
Count of arguments: 4
The sum of arguments is 10.5






이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.