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

Go 언어에는 while 반복문이 없으므로 for 반복문을 (while 반복문 처럼) 쓰면 된다.

소스 파일명: testWhile.go

1. // Filename: testWhile.go
2. //
3. // Execute: go run testWhile.go 625 1000
4. // or
5. // Compile: go build testWhile.go
6. // Execute: ./testWhile 625 1000
8. package main
10. import (
11.     "fmt"
12.     "os"
13.     "strconv"
14. )
16. // 사용법 표시 함수
17. func printUsing() {
18.     fmt.Printf("Using: testWhile [integer1] [integer2]\n");
19.     fmt.Printf("This finds the greatest common divisor of the given two integers.\n");
20. }
22. // main 함수
23. func main() {
24.     var val1 int64
25.     var val2 int64
26.     var a int64
27.     var b int64
28.     var gcd int64
30.     if len(os.Args) != 3 {
31.         printUsing();
32.         return
33.     }
35.     // 명령행 인자의 스트링을 가져와서
36.     // 64비트 정수로 변환하여
37.     // 변수 val1과 val2에 저장한다.
38.     val1, _ = strconv.ParseInt(os.Args[1], 10, 64);
39.     val2, _ = strconv.ParseInt(os.Args[2], 10, 64);
41.     a = val1
42.     if a < 0 {
43.         a = -a
44.     }
46.     b = val2;
47.     if b < 0 {
48.         b = -b
49.     }
51.     if a < b { 
52.         a, b = b, a
53.     }
55.     if b == 0 {
56.         fmt.Printf("GCD(%d, %d) = %d\n", val1, val2, a);
57.         return
58.     }
60.     // -------------------------------------------
61.     // Euclidean 알고리즘의 시작 
62.     // *  Go 언어에는 while 반복문이 없으므로 for 문을 사용한다.
63.     for a != 0 {
64.         b, a = a, b % a
65.     }
67.     // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
68.     gcd = b
70.     // 최대공약수(GCD)를 출력한다.
71.     fmt.Printf("GCD(%d, %d) = %d\n", val1, val2, gcd);
72. }

실행:

Command> go run testWhile.go
Using: testWhile [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

Command> go run testWhile 200 -300
GCD(200, -300) = 100

Command>go run  testWhile 0 -300
GCD(0, -300) = 300

Command> go run testWhile 20 -125
GCD(20, -125) = 5

Command> go run testWhile 121 66
GCD(121, 66) = 11

Command> testWhile -111 -37
GCD(-111, -37) = 37


컴파일:

Command> go build testWhile.go


실행:

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

Command> testWhile 200 -300
GCD(200, -300) = 100

Command> testWhile 0 -300
GCD(0, -300) = 300

Command> testWhile 20 -125
GCD(20, -125) = 5

Command> testWhile 121 66
GCD(121, 66) = 11

Command> testWhile -111 -37
GCD(-111, -37) = 37

소스 파일명: testIf.go

1. // Filename: testIf.go
2. //
3. // Execute: go run testIf.go -1.5
4. // or
5. // Compile: go build testIf.go
6. // Execute: ./testIf -1.5
8. package main
10. import (
11.     "fmt"
12.     "os"
13.     "strconv"
14. )
16. // 사용법 표시 함수
17. func printUsing() {
18.     fmt.Printf("Using: testIf [number]\n");
19.     fmt.Printf("This determines whether the number is positive or not.\n");
20. }
22. // main 함수
23. func main() {
24.     var val = 0.0
25.     if (len(os.Args) != 2) {
26.         printUsing();
27.         return
28.     }
30.     // 명령행 인자의 스트링을 가져와서
31.     // 배정밀도 부동소수점수로 변환하여
32.     // 변수 val에 저장한다.
33.     val, _ = strconv.ParseFloat(os.Args[1], 64);
35.     // 변수 val에 저장된 값이 양수인지 음수인지 0인지를
36.     // 판단하는 if...else... 조건문
37.     if val > 0.0 {
38.         fmt.Printf("%g is a positive number.\n", val);
39.     } else if val < 0.0 {
40.         fmt.Printf("%g is a negative number.\n", val);
41.     } else  {
42.         fmt.Printf("%g is zero.\n", val);
43.     }
44. }

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

실행> go run testIf.go 1.234
1.234 is a positive number.

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

실행> go run testIf.go 0
0 is zero.

또는

컴파일> go build testIf.go

실행> 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.

Go 소스 파일에 한글이 포함되어 있으면  UTF8 인코딩으로 저장해야 한다.

     소스 파일명: testArguments.go

1. // Filename: testArguments.go
2. //
3. // Execute: go run testArguments.go 1 2 3
4. // or
5. // Compile: go build testArguments.go
6. // Execute: ./testArguments 1 2 3
8. package main
10. import (
11.     "fmt"             // fmt.Printf 함수 사용을 위해
12.     "os"             // os.Args 사용을 위해
13.     "strconv"      // strconv.ParseFloat 함수 사용을 위해
14. )
16. func main() {
17.     var sum = 0.0;
18.     var y = 0.0
19.     for i, x := range os.Args {
20.         if i > 0 {
21.             // 스트링을 배정밀도 부동소수점수로 변환하여 변수 sum에 누적
22.             y, _ = strconv.ParseFloat(x, 64)
23.             // fmt.Printf("y = %f\n", y)
24.             sum += y
25.         }
26.     }
28.     // 명령행 인자(command-line argument) 개수 출력
29.     fmt.Printf("Count of arguments: %d\n", len(os.Args));
30.     // 부동소수점수 값을 %g로 출력
31.     fmt.Printf("The sum of arguments is %g\n", sum);
32. }
    

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

실행> go run testArguments.go 1 2 3 4.2
Count of arguments: 5
The sum of arguments is 10.2

또는

컴파일> go build testArguments.go

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

실행> testArguments 1 2 3 4.2
Count of arguments: 5
The sum of arguments is 10.2