20241230

스택 (Stack), 큐 (Queue) 에 대하여 - golang

스택 (Stack), 큐 (Queue) 에 대하여

-Stack 과 Queue 는 데이터를 저장하고 다루는 방식을 정하는 - 자료구조 입니다.

스택 (Stack)

- 방식: 마지막에 들어간 것이, 먼저 나옵니다.(LIFO: Last ln, First Out)

함수 호출 관리 및 역순 처리가 필요한 경우

- 추가 및 삭제는 한쪽 끝에서만.[데이터 복원등, Undo 등에 주로 사용]

- 접시에 음식을 쌓아 올리면, 맨 위에 맨 마지막에 올린것 먼저 먹게 되는 원리

- 스택에 1, 2, 3을 순서대로 넣으면 꺼낼 때는 3, 2, 1 순서로 나옵니다.

    stack := []int{} // 빈 스택, 빈 슬라이스를 생성해 스택처럼 사용

// 슬라이스는 동적 배열로 크기가 유동적으로 변할 수 있어요.

    // 값 넣기 (Push) append를 사용하여 값을 추가함.

    // 계속 추가하면, 스택의 마지막 부분에 값이 쌓이는 형태가 됨.

    stack = append(stack, 1)  // 1을 스택에 추가, 기존 stack에 1을 추가한 새로운 슬라이스를 반환

    stack = append(stack, 2)  // 2를 스택에 추가

    stack = append(stack, 3)  // 3을 스택에 추가

    fmt.Println("스택 상태:", stack) // [1, 2, 3]

    // 값 꺼내기 (Pop)

    for len(stack) > 0 {

        n := stack[len(stack)-1] // 가장 위에 있는 값, 스택의 마지막 요소(값)를 가져옴

// len 함수는 슬라이스, 배열, 문자열, 맵, 채널 등의 길이나 크기를 반환 // 내장 함수이며- 길이나 개수를 알고 싶을 때 사용함.

        stack = stack[:len(stack)-1] // 마지막 값(요소) 제거

                                     // 마지막 요소를 제외한 슬라이스를 반환해 값을 꺼내는 효과

        fmt.Println("꺼낸 값:", n)
        fmt.Println("현재 스택:", stack)

}

큐 (Queue)

- 방식: 먼저 들어간것이 먼저 나옵니다.(FIFO: First in, First Out)

데이터를 순서대로 사용(처리)이 필요한 경우

- 추가는 뒤에서, 삭제는 앞에서. [CPU 및 대기열 및 이벤트 관리등에 사용]

- 그물방 채반안에, 과일을 씻기 위해, 물을 뿌리면, 먼저 들어간 물이 먼저 떨어지는 원리.

- 큐에 1, 2, 3을 넣으면 꺼낼 때는 1, 2, 3 순서로 나옵니다.

    queue := []int{} // 빈 큐, 빈 슬라이스를 생성하여 큐로 사용

    // 값 넣기 (Enqueue), append를 사용해 값을 추가, 추가된 값은 항상 큐의 맨 뒤에 위치
    queue = append(queue, 1)  // 1을 큐에 추가
    queue = append(queue, 2)  // 2를 큐에 추가
    queue = append(queue, 3)  // 3을 큐에 추가
    fmt.Println("큐 상태:", queue) // [1, 2, 3]

    // 값 꺼내기 (Dequeue)
    for len(queue) > 0 {
        n := queue[0] // 가장 앞에 있는 값, 큐의 첫 번째 값을 가져옴
        queue = queue[1:] // 첫 번째 요소를 제외한 슬라이스를 반환해 값을 꺼내는 효과를 냄.
        fmt.Println("꺼낸 값:", n)
        fmt.Println("현재 큐:", queue)
    }

append 함수

-Go언에서 append는 슬라이스에 새 요소를 추가하는 내장 함수임.

- append는 슬라이스에 값을 추가하는 간단한 방법

- 큰 슬라이스에서 빈번히 append를 사용하면 성능에 영향을 줌(슬라이스의 용량이 부족하면 새 메모리 공간을 할당하고 데이터를 복사 하기에)

- 스택에서는 append로 값을 쌓고, 슬라이스의 마지막 요소를 꺼내 삭제.

- 큐에서는 append로 값을 줄 세우고, 슬라이스의 첫 번째 요소를 꺼내 삭제.

append 기본 사용법

slice := []int{1, 2}
slice = append(slice, 3) // [1, 2, 3]
                   // 기존 슬라이스 slice에 3을 추가한 새로운 슬라이스를 반환
                   // 기존 슬라이스는 변경되지 않고, 새로운 슬라이스가 생성되므로 반드시 대입해야 함.

append 다중 요소 추가- 여러 값을 한 번에 추가

slice = append(slice, 4, 5, 6) // [1, 2, 3, 4, 5, 6]

append 슬라이스 병합 - ...을 사용하면 다른 슬라이스의 모든 요소를 추가

otherSlice := []int{7, 8}
slice = append(slice, otherSlice...) // [1, 2, 3, 4, 5, 6, 7, 8]

20241227

Go언어의 IF 문, FOR 문

if문 - 조건이 맞으면 {} 블럭안 실행.( if는 특정 조건만 검사하는 경우에 적합함)

단, '{' 시작하는 블럭이 if 문과 같은 라인에 있어야 함.

c언어에서 사용하는 삼항 연산자(? :)를 사용할수 없슴(가독성을 위해서 지원하지 않음).

조건식 ()가 필요없슴.- if문에는 소괄호가 필요가 없슴.

Boolean 식으로만 표현 - 참(True) 또는 거짓(False)

Boolean식은 논리 연산(&&, ||, !)이나 비교 연산(==, !=, <, >, <=, >=)에서 사용함.

Boolean식은 조건문 if, for, switch 에서 주로 사용함.

논리 판단: 특정 조건을 만족하는지 판단할 때 사용(크냐,작냐,같냐,다르냐,참이냐..)

if문에 조건식 이전에, if문 안에서만 사용할수 있는 문장을 추가할수도 있슴.

        for i := 0; i < 10; i++ {            // for문: 0~9까지의 숫자안에서 루프해라.
            if i%2 == 0 {                    // if문: 짝수만 출력해라
                          fmt.Println(i)     // 출력: 2, 4, 6, 8
            }
        }

for문: i가 0일때 부터, i가 10보다 작을때 까지, i를 +1 하며, 루프

숫자 0 부터, 9까지 루프로 체크 하고

if문: i를 2로 나눈 나머지값이 0과 같으려면, 짝수여야 하기에,

2,4,6,8 이 출력됩니다.

if true { // 참일때만 실행하는 if문

}

if false { // 거짓일때만 실행하는 if문

}

if a == 1 { // a 가 1과 같으면, 참이면

println("일")

} else if a == 2 { // 1은 아니고, 만일 2와 같다면

println("이") // fmt 없이, println 소문자로 사용은, go의 기본 내장함수라서

} else { // else - 1도 2도 아닌 기타면

fmt.Println("몰라") // fmt없는 경우는, 디버깅 및 간단한 출력테스트만 권장함.

} // fmt를 이용해서 출력시, Println함수에서 P는 대문자여야 함.

// fmt의 함수를 이용한 출력을 go언어는 권장합니다.

    if ok1 := i * 3; ok1 < ok2 {
        fmt.Println(ok1)
    }

// if문에 조건식 이전에, if문 안에서만 사용할수 있는 문장을 추가할수도 있슴.

// 위의 예제에서 ok1 은, if문을 벗어난 경우 에러가 발생됩니다. if문 안에서만 사용함.

FOR 문- Go언어에서 for 로 루프를 사용합니다.

for문은 반복작업을 표현하는데 주로 사용합니다. 반복과 조건을 사용하려면, for문을 사용함.

- 반복을 실행하며, 반복하는 중간에 조건을 평가할수도 있슴.(조건 평가는 if 문을 사용)

        for i := 0; i < 10; i++ {      //  for 초기값; 조건식; 후처리문(증감식) {} 블럭
        }

for { // 무한루프

}

for x := 1; true; x++ { // 무한루프

}

for a < 50 { //조건식

}

for 루프의 range 문은 슬라이스(slice), 맵(map), 배열(array), 문자열(string), 채널(channel) 등의 데이터를 순회(iterate)할 때 사용됩니다.

for index, value := range collection {
    // 반복할 코드
}

index: 현재 반복의 인덱스 (또는 키).
value: 현재 반복의 값.
collection: 순회하려는 데이터 구조.

슬라이스 순회

    nums := []int{10, 20, 30, 40}
    for index, value := range nums {
        fmt.Printf("인덱스: %d, 값: %d\n", index, value)
    }

결과: 인덱스: 0, 값: 10

인덱스: 1, 값: 20

인덱스: 2, 값: 30

인덱스: 3, 값: 40

맵순회

fruits := map[string]string{"a": "apple", "b": "banana", "c": "cherry"}
for key, value := range fruits {
    fmt.Printf("키: %s, 값: %s\n", key, value)
}

결과: 키: a, 값: apple

키: b, 값: banana

키: c, 값: cherry

문자열 순회

str := "안녕"
for index, char := range str {
    fmt.Printf("인덱스: %d, 문자: %c\n", index, char)
}

인덱스는 바이트 기준입니다. 한글처럼 UTF-8로 인코딩된 문자는 바이트 단위로 계산됩니다

결과: 인덱스: 0, 문자: 안

인덱스: 3, 문자: 녕

값만 사용하기 (_를 활용)

nums := []int{10, 20, 30, 40}
for _, value := range nums {
    fmt.Println(value)
}

결과: 10

인덱스만 사용하기

값이 필요 없으면 _를 사용해 생략할 수 있습니다.

    nums := []int{10, 20, 30, 40}
    for index := range nums {
        fmt.Println(index)
    }

결과: 0

range는 슬라이스, 맵, 문자열, 배열 등을 순회할 때 사용합니다.

필요하지 않은 값이나 인덱스는 _를 사용해 생략할 수 있습니다.

range는 Go 코드에서 데이터를 반복 처리할 때 가장 직관적이고 간단한 방법입니다.

For 문을 if 문처럼 사용하는 경우

for condition { // if와 비슷하게 동작
    fmt.Println("조건이 참입니다!")
    break // 조건이 참이더라도 반복하지 않도록 종료
}

For 문으로 조건 처리 하는 방법

a, b, c := 5, 5, 1

for a == b && c == 1 { // 조건이 참일 때만 실행
    fmt.Println("조건이 만족됩니다!")
    break // 무한 루프를 방지하기 위해 추가
}

a, b, c := 5, 5, 1

for a == b && c <= 3 {
    if c == 2 {
        fmt.Println("조건 c == 2: 다음 반복으로 넘어갑니다.")
        c++
        continue // c == 2일 때 아래 코드 실행을 안하고, 다시 조건을 체크하로 감.
    }

    fmt.Printf("현재 c의 값: %d\n", c)
    c++
}

fmt.Println("반복 종료")

continue와 break의 차이

continue: 현재 반복을 건너뛰고 다음 반복으로 이동.

continue 가 실행되면, 반복을 다시 시작 체크함.

continue 다음의 내용은 적용 안되고, 다시 반복을 체크하로 감.

break: 반복문을 완전히 종료.

break 가 실행되면, 그 조건문(if. for)을 빠져 나감.

a, b, c := 5, 5, 1

for a == b && c <= 5 {
    if c == 3 {
        fmt.Println("c == 3: 반복을 완전히 종료합니다.")
        break // 반복문 종료- 조건문을 완전히 빠져 나감 
    }

    if c == 2 {
        fmt.Println("c == 2: 다음 반복으로 넘어갑니다.")
        c++
        continue // 다음 반복으로 건너뜀-아래 조건은 실행 안하고, 다시 조건 체크로 이동
    }

    fmt.Printf("현재 c의 값: %d\n", c)
    c++

c++ 과 ++c 차이점

c++ = (후위 증가 연산자), 변수 c의 값을 먼저 사용하고, 그 다음에 1을 증가시킴

int c = 5;
int result = c++; // result에 5가 저장되고, c는 6이 됩니다.

먼저 사용한 다음에 증가를 합니다.

++c = (전위 증가 연산자), 변수 c의 값을 먼저 1 증가시키고, 그 증가된 값을 사용함.

int c = 5;
int result = ++c; // c는 6이 되고, result에 6이 저장됩니다.

먼저 증가를 시키고, 사용을 합니다.

c = c + 1

int c = 5;
c = c + 1; // c는 6이 됩니다.

값에 1을 더하고, 다시 할당합니다. 증가만 시킵니다.

20241226

Go언어의 연산자 관련- Golang

Go언어의 연산자

- 산술연산자, 관계연산자, 논리연산자, Bitwise연산자, 복합할당연산자, 포인터연산자

산술연산자:

-사칙연산자: 더하기, 빼기,곱하기, 나누기, 나머지 등 숫자 계산에 사용됩니다.

+ 더하기

- 빼기

* 곱하기

/ 나누기(몫)

% 나누기(나머지)

-증감연산자:

++ : 변수에 1 증가 개념. i++ // (i = i + 1) 복합할당연산자로 표시시 (i += 1)

-- : 변수에 1 감소 개념. i-- // (i = i -1) 복합할당연산자로 표시시 (i -= 1)

관계연산자: 값을 비교할때 사용합니다. 같다, 크다, 작다, 다르다

== 같다

!= 다르다

< 작다

> 크다

>= 크거나 같다

<= 작거나 같다

논리연산자: 참(true),거짓(false) 계산에 사용함.

AND, && = 둘다 참이면 참(그리고 개념)

OR, || = 둘중에 하나만 참이어도 참(또는 개념)

NOT, ! = 다르면 참(부정 개념, 참이면 거짓이고, 거짓이면 참)

Bitwise연산자: 비트를 조작할때 사용합니다.

& : AND 개념( 둘다 1이면 1)

| : OR 개념( 둘중에 하나만 1이면 1)

^ : XOR 개념(둘이 다르면 1)

<< : 왼쪽으로 비트 이동 ( 2의 제곱 곱하기)

비트를 왼쪽으로 밀고, 빈자리를 0으로 채웁니다.

숫자를 2의 제곱으로 곱하는 것과 같음 ( *2, *4, *6, *8...)

2진수는 8개 자리로 00000000~11111111 이며, 8비트 2진수의 표시입니다.

8비트의 2진수는 0과 1로 이루어진 8자리 숫자입니다.

a := 2 // 2를 2진수로 나타내면 00000010

b := a << 1 // 왼쪽으로 1칸 이동: 00000100 (10진수로 4) = 2 * 2 = 4

c := a << 2 // 왼쪽으로 2칸 이동: 00001000 (10진수로 8) = 2 * 2 * 2 = 8

fmt.Println(b) // 출력: 4

fmt.Println(c) // 출력: 8

>> : 오른쪽으로 비트 이동 (2의 제곱 나누기)

비트를 오른쪽으로 밀고, 빈자리를 0으로 채웁니다.(양수일때)

숫자를 2의 제곱으로 나누는 것과 같음. ( /2, /4, /6, /8...)

a := 8 // 8을 2진수로 나타내면 00001000

b := a >> 1 // 오른쪽으로 1칸 이동: 00000100 (10진수로 4) = 8 / 2 = 4

c := a >> 2 // 오른쪽으로 2칸 이동: 00000010 (10진수로 2) = 8 / 2 / 2 = 2

fmt.Println(b) // 출력: 4

fmt.Println(c) // 출력: 2

복합 할당연산자

= : 값을 대입하는 것

+= : 값을 더해서 대입하는 것

-= : 값을 빼서 대입하는 것

*= : 값을 곱해서 대입하는 것

/= : 값을 나눠서 대입하는 것

%= 값을 나눈 나머지를 대입하는 것

포인터연산자: 포인터와 관련된 연산자 입니다.

& : 변수의 메모리 주소를 할당(가져오기)

* : 메모리 주소의 값을 가져오기(가리키는 주소에 실제 값 사용)

- 포인터에 더하고,빼는 기능이 없습니다.(안정성 강화 및 코드 가독성을 위하여- 기능 없슴)

- 만일, 포인터에 더하고, 빼는 기능이 필요하다면(슬라이스, 정수인덱스로 대체할수 있슴)

20241224

Log 체크 방법으로, 에러 위치 체크 방법- Fatalf

- 프로그래밍 하다 보면, 가끔 어디서 오류가 났나, 데이타가 잘 전달 되었나, 체크하고 싶을때, 메시지 팝업이나, Log 체크를 할 경우, Fatalf 를 사용시 편리할거 같아서 기록합니다.

- 에러를 보고하고, 프로그램을 종료합니다.

- log.Fatalf는 포맷 문자열을 지원하는 log 함수입니다.

- 여러 변수를 추가하고, 출력할수 있습니다.

- log.Fatal은 에러만 보고합니다.

- import "log" // log 패키지가 필요합니다.

 %v  기본 형식 출력    log.Fatalf("%v", err)

 %s  문자열 출력  log.Fatalf("%s", fname)

 %d  정수 출력   log.Fatalf("%d", Number)

 %f  실수 출력   log.Fatalf("%f", pi)

 %t  Boolean 출력  log.Fatalf("%t", isErr)

 %+v 상세한 구조체 출력  log.Fatalf("%+v", myStruct)

log.Fatalf("%v: 이런 문제로 여기쯤 에러 발생", aaa변수)

log.Fatal(fmt.Sprintf("%v: 여기쯤 값이 이러네", err))

 Sprintf- 문자열 출력말고, 포맷팅을 위해 사용되는 Go의 내장 함수- 포맷팅된 문자열을 반환
 예제]  result := fmt.Sprintf("이름: %s, 나이: %d", name, age)

 %s  문자열 "Hello" → "Hello"

 %d  10진수 정수 42 → "42"

 %f  부동소수점 실수    3.14 → "3.140000"

 %.nf    n 자리까지 소수점 제한   3.14159 → "3.14" (%.2f)

 %t  불리언 값   true → "true"

 %v  기본 형식 (기본값 출력)  123 → "123"

 %+v 필드 이름 포함 (구조체 등)    

 %#v Go 구문으로 값 표현    

 %T  값의 타입 출력    "Hello" → "string"

 %%  퍼센트 기호 출력 (%)   "%%" → "%"

log.Fatal(err) //에러 보고하고 프로그램 종료함.

exit status 1 // 항상 종료 코드로 1을 반환 합니다.

os.Exit

-일반적으로 비정상 종료 exit status 1 (Error)상태를 나타냅니다.

- 0 은 정상 종료를 의미합니다.

- 1 은 비정상 종료를 의미합니다.

- 종료 상태 코드는 프로그램이 실행 마치고, 운영 체제에 반환하는 숫자 값입니다.

- 프로그램의 성공/실패 여부를 확인하는대도 사용됩니다.

- exit status 1은 프로그램 실행 중에 오류가 발생하거나, 프로그램이 예상치 못한 상황에서 종료되었음을 나타냅니다.

- log.Fatal은 에러 메시지를 출력한 후 os.Exit(1)을 호출하여 프로그램을 종료합니다.

- os.Exit(1) 직접 호출시: os.Exit 함수는 프로그램을 종료하고 지정된 상태 코드를 반환합니다.

- Go에서 종료 상태 코드를 제어하려면 os.Exit 함수를 사용합니다.

반환 값이 2개 인경우 무시하기 : _

input, _ := reader.ReadString('\n')

반환 값이 2개 인 경우 err 반환값을 변수로 저장하기

input, err := reader.ReadString('\n')

함수나 메서드는 - 문제가 없으면 에러값으로 nil을 반환합니다.

- err 값이 nil 이면, 문제가 없는것이고,

- err 값이 nil 아니면, 에러가 발생된 것임.

if err != nil { // 에러가 nil 이 아니면(에러가 발생했으면)

log.Fatal(err) //에러 보고후, 프로그램 종료함.

}

20241223

상수(const) 관련 -golang

상수(const)는

- 값이 변경되지 않는(값 변경불가), 이름을 가진, 고정된 값을 정의할 때 사용.

- 코드의 가독성을 높임.

- const 키워드를 사용하여 상수를 선언합니다.

- 의도치 않은 값 변경을 방지.

- 컴파일 시간에 값을 고정시키는 데 유용함.

상수 선언 방법: const 상수이름 = 값

const키워드 상수이름 타입 = 값

const okok int = 2

const okok = 2 // 정수를 할당하고 있기에, 자동으로 상수는 int가 됨.

// 이것을 자동 타입 추론이라고 합니다.

여러 상수들을 묶어서 선언 방법:

const (

aaaa = "okok"

bbbb = "okbari"

)

상수값을 0 부터 순차적으로 자동 부여 방법: iota 사용

const (

aaaa = iota // 0

bbbb // 1

cccc // 2

)

상수는 선언 후 값을 변경할 수 없다.

const Pi = 3.14

Pi = 3.14159 // 오류 발생- 값을 변경하여 오류가 발생함.

상수는 명시적으로 타입을 지정하거나 생략할 수 있다.

const A int = 10 // const키워드 상수이름 타입 = 값, 타입 지정

const B = 20 // const 상수이름 = 값, 타입 생략 (컴파일러가 타입 추론)

상수의 값은 반드시 컴파일 시간에 결정되어야 합니다.

const A = 1 + 2 // 가능 (컴파일 시간에 계산됨)

// 상수는 컴파일 시간에 값을 계산하고 고정해야 함.

var B = 3 //var로 선언된 변수는 런타임에 값을 할당받거나 계산

// 컴파일러는 var 변수의 값을 실행 전에 알 수 없습니다.

const C = A + B // 오류 (B는 런타임에 결정됨)

// const는 반드시 타입과 값이 컴파일러가 알 수 있는 상태여야 하며,

// 런타임 값과 연관될 수 없습

슬라이스, 맵, 구조체 같은 복합 데이터 타입은 상수로 선언할 수 없음.

const Array = []int{1, 2, 3} // 오류 발생

문자열도 상수로 선언할 수 있음.

const hiing = "Hello, World!"

숫자 상수는 명시적 변환 등을 통해 유형이 지정되기 전까지는 유형이 없슴.

const num = 42 // 타입이 없는 숫자 상수

var a int = num // int로 변환

iota는 상수 블록에서 각 상수에 대해 순차적으로 증가하는 정수를 제공하기에,

열거형이나 비트 마스크를 쉽게 정의할 수 있어요.

const (

Read = 1 << iota // 1 (2^0)

Write // 2 (2^1)

Execute // 4 (2^2)

)

fmt.Println(Read, Write, Execute) // 출력: 1 2 4

Go 명령어

bug start a bug report

Go 언어의 문제를 보고하기 위한 명령어.

Go 프로젝트의 공식 GitHub 저장소에 버그 리포트를 시작할 수 있는 템플릿 웹페이지를 엽니다.

사용방법: go bug

웹페이지가 열리고, 버그리포트 할수 있슴.

build compile packages and dependencies

패키지와 그 의존성을 컴파일하여 실행 파일을 생성.

현재 디렉토리에, 실행파일(바이너리) 생성됨.

사용방법: go build [패키지]

go build main.go

clean remove object files and cached files

컴파일된 객체 파일 및 캐시 파일을 삭제

-cache: 빌드 캐시 삭제.

-testcache: 테스트 캐시 삭제.

사용방법: go clean

doc show documentation for package or symbol

패키지나 심볼에 대한 문서를 표시(궁금하면 도움말을 검색할수 있는 기능)

사용방법: go doc [패키지 또는 심볼]

go doc fmt.Println //fmt.Println 관련 설명 도움말이 표시됩니다.

env print Go environment information

현재 Go 환경 변수 값을 출력

- 여러 환경 변수 리스트가 출력됨.

사용방법: go env

fix update packages to use new APIs

코드를 최신 API로 업데이트

사용방법: go fix [패키지]

fmt gofmt (reformat) package sources

Go 코드를 포맷. 코드 스타일을 일관되게 유지할 때 사용

- 들여쓰기 및 공백 정리

- 불필요한 괄호 제거

- 코드 스타일 일관성 유지

사용방법: go fmt [패키지]

go fmt hello.go 컴파일 전에 한번 실행해주면, 코드가 정리되서 아주 좋음.

go fmt ./... 현재 디렉토리의 모든 Go 파일을 포맷팅 방법

generate generate Go files by processing source

주석에 포함된 명령을 처리하여 Go 소스 파일을 생성

사용방법: go generate [패키지]

주석 //go:generate를 포함한 명령을 실행

get add dependencies to current module and install them

현재 모듈에 의존성을 추가하거나, 외부 패키지를 다운로드

사용방법: go get [패키지]

go get github.com/aaaa/bbbb

install compile and install packages and dependencies

패키지를 컴파일하고, 실행 파일을 설치 경로에 복사

설치버젼 만드는 방법임.

사용방법: go install [패키지]

list list packages or modules

패키지 또는 모듈 목록을 표시

사용방법: go list [패키지]

mod module maintenance

Go 모듈 관리 명령어. 모듈 초기화, 정리 등을 수행

사용예제: go mod init [모듈 이름]

go mod tidy

work workspace maintenance

워크스페이스(workspace)를 관리하기 위한 명령어

워크스페이스는 여러 모듈을 한꺼번에 관리하고 개발 환경에서 함께 작업할 수 있도록 설정을 제공

-워크스페이스를 사용하면 모듈을 통합 관리할 수 있슴.

-여러 모듈을 별도의 리포지토리로 관리하지 않고, 하나의 워크스페이스에서 개발 가능

-워크스페이스 내에서 모듈 간 변경사항을 실시간으로 반영 가능

-모든 모듈을 한 번에 테스트 가능

여러 모듈을 동시에 개발하거나, 모듈 간 의존성을 더 쉽게 처리하려는 경우에 유용

워크스페이스는 go.work 파일로 정의되며, 워크스페이스에 포함된 모듈 경로와 Go 환경을 정의함.

워크스페이스는 주로 로컬 개발 환경에서 사용되며, 배포 시에는 각 모듈을 독립적으로 관리해야함.

사용방법:

go work init [모듈 경로...]

go work init ./module1 ./module2

./module1과 ./module2가 포함된 워크스페이스가 생성됨.

새로운 워크스페이스를 초기화하고, 현재 디렉토리에 go.work 파일을 생성

go work use [모듈 경로...]

go work use ./module3

./module3이 워크스페이스에 추가됨.

기존 워크스페이스에 새로운 모듈을 추가됨.

go work drop [모듈 경로...]

워크스페이스에서 특정 모듈을 제거함.

go work drop ./module2

./module2이 워크스페이스에서 제거됨.

go work edit [옵션]

go work edit -fmt

go.work 파일의 포맷이 자동으로 정리

go.work 파일을 수동으로 편집하지 않고 명령어를 통해 수정할 수 있슴.

go work sync

워크스페이스 내 모듈의 상태를 동기화함.

워크스페이스 내 모든 모듈이 올바르게 동작하도록 의존성을 조정함.

run compile and run Go program

Go 코드를 컴파일하고 실행

주로 테스트에 사용함. 임시로 컴파일하고 실행되고, 종료시 지워짐.

사용방법: go run main.go

test test packages

Go 테스트 파일(*_test.go)을 실행

사용방법: go test [패키지]

tool run specified go tool

Go에서 제공하는 특정 도구를 실행

사용방법: go tool [도구 이름]

version print Go version

현재 설치된 Go의 버전을 출력

사용방법: go version

vet report likely mistakes in packages

코드를 분석하여 잠재적인 문제를 보고함

사용방법: go vet [패키지]

추가 도움말:

buildconstraint build constraints

특정 조건에서만 파일을 빌드하도록 제어하는 주석 구문

실행 예제: // +build windows

buildmode build modes

Go 프로그램 빌드 시 사용할 빌드 모드를 지정

c calling between Go and C

C와 Go 간의 호출(cgo)에 대한 설명

cache build and test caching

빌드 및 테스트 캐싱 동작에 대한 설명

environment environment variables

Go와 관련된 환경 변수 정보

filetype file types

Go 파일의 유형에 대한 설명

go.mod the go.mod file

Go 모듈 정의 파일의 역할과 사용법

gopath GOPATH environment variable

GOPATH의 구조와 사용법

goproxy module proxy protocol

모듈 프록시 설정에 대한 정보

importpath import path syntax

패키지를 임포트하는 경로 구문

modules modules, module versions, and more

Go 모듈의 구조와 사용법

module-auth module authentication using go.sum

go.sum 파일을 통한 모듈 인증 방법

packages package lists and patterns

패키지 목록과 패턴

private configuration for downloading non-public code

비공개 코드를 다운로드하는 설정

testflag testing flags

테스트 시 사용할 플래그 설명

testfunc testing functions

테스트 함수 작성법

vcs controlling version control with GOVCS

GOVCS로 버전 제어 관리

Go 언어의 타입 과 변수 변수선언 관련

- 어쩌면, 프로그래밍 서적 대부분이, 개념 설명 보다가, 설치하고, 변수관련 설명쯤 볼때즘, 우선 책을 잠시 덥어두는듯 합니다. 그래서, 책은 매우 얇은, 아주 아주 액기스 같은 기본골격만 있는 책이, 가장 좋은책 같아요. 악세사리가 많은 책은, 공부에 방해가 된다고 생각합니다. 그러나, 저는 액기스가 뭔지를 모릅니다. ^^

기본타입: 정수, 부동소수점, 문자열, 불리언

복합타입: 배열, 슬라이스, 맵, 구조체, 인터페이스

reflect.TypeOf(알고자 하는 숫자나 문자 값)

package main

import (

"fmt"

"reflect"

)

-------------------------------------------------------

int - 정수(기본 정수 타입)

int8 1바이트 -128 ~ 127

int16 2바이트 -32,768 ~ 32,767

int32 4바이트 -2,147,483,648 ~ 2,147,483,647

int64 8바이트 -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

uint 플랫폼 종속 부호 없는 기본 정수

uint8 1바이트 0 ~ 255

uint16 2바이트 0 ~ 65,535

uint32 4바이트 0 ~ 4,294,967,295

uint64 8바이트 0 ~ 18,446,744,073,709,551,615

float64 - 부동 소숫점, 숫자, 소숫점 있는 숫자

float32 4바이트 단정밀도 부동소수점

float64 8바이트 배정밀도 부동소수점

bool - 참, 거짓 둘중에 하나만 가짐

string - 문자, 글짜, 문자열

string: UTF-8 문자열을 저장.

byte: uint8의 별칭. ASCII나 바이트 데이터를 저장.

rune: int32의 별칭. UTF-8 인코딩의 문자를 저장.

배열 (Array)- 고정 크기를 가지며, 동일한 타입의 데이터를 저장.

문법: `[크기]타입`

var arr [3]int = [3]int{1, 2, 3}

슬라이스 (Slice)- 배열의 가변 크기 버전으로, 길이가 동적으로 변경 가능. 
문법: []타입
var slice []int = []int{1, 2, 3}


맵 (Map)- 키-값 쌍을 저장하는 해시 테이블.
문법: map[키_타입]값_타입
var m map[string]int = map[string]int{"a": 1, "b": 2}


구조체 (Struct)- 여러 필드를 묶어서 정의.
문법: type 이름 struct
type Person struct { 
     Name string 
     Age  int
} 
var p Person = Person{Name: "Alice", Age: 25}
fmt.Println(p)

포인터 (Pointer)- 값의 메모리 주소를 저장.
문법: *타입
var x int = 42  //명시적 선언
var p *int = &x 
fmt.Println(*p)


타입 변환- Go에서는 명시적 타입 변환만 허용됩니다. 암시적 변환은 허용되지 않습니다.
var a int = 10  // 명시적 선언
var b float64 = float64(a) // int -> float64
fmt.Println(b) 


타입 추론- var 키워드나 :=를 사용하면 Go가 자동으로 타입을 추론합니다.
var a = 10       // int로 추론, 타입 추론
b := "Hello"     // 짧은선언, string으로 추론 var 키워드 없이, 함수안에서만 사용함.
fmt.Println(a, b) 

인터페이스 타입- Go는 빈 인터페이스 (interface{})를 통해 모든 타입을 받을 수 있습니다.커스텀 인터페이스를 정의하면 특정 메서드를 구현하는 타입에 제한을 걸 수 있습니다.

reflect 패키지의 TypeOf() 함수로 - 타입을 알아볼수도 있습니다.

type Speaker interface {

Speak() string

}

type Dog struct{}

func (d Dog) Speak() string {

return "Woof"

}

func main() {

var s Speaker = Dog{}

fmt.Println(s.Speak()) // Woof

}

사용자 정의 타입- `type` 키워드를 사용해 새로운 타입을 정의할 수 있습니다.

type MyInt int

var x MyInt = 10

fmt.Println(x) // 10

변수(varible) = 값이 있는 저장소

변수는 var로 선언하고, 변수이름, 변수 타입순서로 작성 합니다.변수는 문자로 시작하며, 첫글짜가 대문자면[외부 패키지에서 접근 가능], 첫글짜가 소문자면[동일한 패키지에서만 접근 가능]하고, 변수는 공백이 없어야 하고, 타입이 같아야 하며,타입 변환이 가능함.

선언된 변수가 사용되지 않으면, 에러가 발생되기에, 프로그램에서 삭제합니다.

변수 선언 = 변수에 이름을 부여하는것

var = 키워드로 변수를 선언할때 사용함.

명시적선언: 초기값 지정

초기값 없으면: 기본값 사용됨.

[변수 선언]

var name int // var 변수선언 키워드, 변수 이름, 변수 타입 지정

var count1, count2 float64 // 동일한 타입은 끝에 한번만 입력으로 선언도 가능

[변수에 값 할당]

count1, count2 = 1.1, 1.2 // 여러 변수를 한꺼번에 할당 가능

// 변수와 값의 갯수가 일치해야 됨.

[변수 선언과 값 할당]

var count int = 2

var count1, count2 float64 = 1.1, 1.2

[단축 변수 선언]

count := 2 //변수를 선언과 동시에 값을 할당, 짧은 선언(타입 자동 추론).

// var를 생략하고 사용하며, 함수내에서만 사용할수 있습니다.

// 함수(func) 밖에서는, var를 사용해야 합니다.

count = 2 // 변수를 선언한것이 아니라, 값만 할당한것임. 문제됨.

[표준 라이브러리의 기능적인 타입]

    var now time.Time = time.Now()
    fmt.Println(now)

time.Time 는 now 변수의 타입입니다. 없어도 자동 추론 됩니다.

Go 언어의 표준 라이브러리인 time 패키지에서 제공하는 구조체 타입입니다.

time.Time, http.Request 는, 표준 라이브러리의 기능적인 타입이라고 합니다.

int, float64, bool, string 는, 기본 데이타 타입(Primitive Type)이라고 합니다.

Go언어는, Golang 이라고도 합니다.

C언어 같은, 빠른 컴파일 속도

매우 간결한 코드

메모리 자동 해제(가비지 컬렉션)

편리한 동시성 및 멀티코어 프로세서 지원

구글의 로버트 그리시머, 롭 파이크, 켄톰슨이 방대해지는 코드를 좀던 간단하고 관리하기 쉽게 하기 위하여, 만들고, 2009년에 오픈소스로 전환 공개한 언어입니다. 모든 OS(윈또우,리눅스,맥,안드로이드,ios)에서 실행 가능한 프로그램을, 하나의 소스 코드로 생성가능하며, 동시성과 유지보수에 초점을 맞춘 프로그래밍 언어입니다. c언어의 쉬운버젼이라고도 합니다. c언어와 문법은 비슷하고, 복잡한것은 제거한 언어라고 말합니다.

정적타입 언어로, 컴파일시 타입체크를 수행하여, 안정성과 성능을 보장합니다.

타입추론을 지원하여, 코드가 매우 간결합니다.

여러 장점과 단점이 있고, 참 좋은 예기들도 많지만, 개인적으론, 좀 불편하거나, 단순해도,

그냥 go언어 하나만 배우면, GPT등과 연계하여, 원하는 프로그램을 만들수 있다는 점 때문입니다.

취미로, 하나의 프로그래밍 언어만 알면 되고, 문법도 간단하고, 성능도 빠르고, GPT 와 연계하면,

수 많은 프로그래밍 언어와 성능등 여러가지를 생각하는 회사의 개발자가 아니라면, 그냥 golang 하나면, 빠른 컴파일 언어를 쉽게 얻는것입니다. 파이썬이나 flutter c언어 lua... 여러 언어와 비교하며,

고민좀 해본 결과, 어딘가는 부족해도, 그냥 하나만 배울수 있고, 간단한대, 컴파일 언어라 go언어가 좋은거 같아요.

20241220

해외 여행시 - 스마트폰 충전 준비물

해외 여행시, 스마트폰 충전 관련 준비물은

국내(충전기,돼지코 플러그)만 있으면 됩니다.

- 국내 충전기 자체에, 설명을 보면 AC100 ~ 230V 를 5V 로 출력한다고 대부분 써있습니다.

(스마트폰과 상관이 없습니다. 충전기 자체에 설명을 보면 됩니다.)

100 볼트~ 230볼트 사이에 전원에 연결만 한다면, 무조건 5볼트로 출력이 된다는 뜻입니다.

- 돼지코 플러그(변환 콘센트)는, 오래전 한국에서도 사용하던 100v 용 일자 모양 플러그로, 플러그의 모양만 바꿔주는 것이며, 몇천원에 쇼핑몰에도 구매할수 있습니다.

- 로밍관련도, sk텔레콤은 자동으로 로밍되고, 장기간 해외에 있을것이 아니라면, 하루 최대 몇천원에 데이타도 사용가능하며, 문자는 건당 몇백원, 통화는 대략 몇분이 무료급이고, 통화가 30분 정도 넘어가면, 초당 얼마로, 매우 비싼걸로 알고 있습니다.( 몇일 이하에, 전화통화 할거 아니면, 로밍신청을 안해도 됩니다. 단, 국제전화 차단이 되어 있으면 안됩니다.)

돼지코 플러그를 사용하는 나라: 일본, 미국, 캐나다, 멕시코,파나마,쿠바,필리핀..

전압과 플러그의 모양이 약간씩 다를수도 있슴.

기타 언어 관련: 스마트폰의 기능 중에, 화면(카메라) 원터치 자동 번역 기능을 이용하면 편합니다.

안드로이드폰의 기본 기능입니다.(스마트폰에 뒤로가기 말고, 가운대에 네모난 버튼을 몇초 누르면 실행됩니다.)

20241219

Golang 언어 - Hello world 출력하기

Go 언어에서, hello world 출력하는 방법

취미로 golang 언어를 공부하지만, 열심히 하지 않기에, 메모지급으로 기록하며, 틈틈히 공부하기 위하여, 블로그를 이용하는 개인적인 노트의 시작이 hello world 입니다.

import 는 ""를 사용함.

package main //현재 파일의 코드가 main 패키지에 속한다고 알림
             //패키지의 이름은 소문자만 사용합니다.

import "fmt" // Println 함수를 사용하기 위하여, fmt 패키지를 가져오라는 뜻
             // 여러 패키지를 가져올 경우 () 소괄호를 사용합니다.
             // 표준 입출력 라이브러리.

/*
주석 입니다. 여러줄 주석. 주석은 컴파일할때 무시됩니다.
여러 줄에 걸쳐 표현하는 주석을, 블록주석(block comment)라고 합니다.
*/

// 한줄 주석 처리 방법

// main()함수는 어느 위치에 있던, 가장 먼저 실행되는 함수입니다. 꼭 하나는 있어야 함.
// 실행 가능한 Go 프로그램은 항상 main 패키지에 있어야 합니다.
func main() {
    fmt.Println("hello world. 헬로 헬로") //fmt는 format의 약자로, fmt 패키지의 Println 함수를
                                         //사용하는 방법을 알려주고 있습니다.
                                         //함수는 첫문자가 대문자가 아니면, 로컬에서만 사용됨.
                                         //세미콜론을 사용하지 않아도 됩니다.
                                         //영어단어 외우기 싫으면, 직접 함수를 만들어 사용하세요.
                   // \n 줄바꿈, \t 탭, \" 따옴표, \\ 역슬래쉬, \b 백스페이스, \a 경고음
                   // %d 10진수 정수, %f 부동소숫점 숫자, %s 문자열, %t 불리언값, %T 데이터타입
                   // %v 모든 데이터 타입 기본형식, %q 따옴표 감싼 문자열
}

'안녕하세요' 작은따옴표로 둘러싸인 문자열은,Raw String LIteral 이라 하고,

- 문자열 안에 \n 을 그대로 문자로만 출력하고, 줄바꿈이 없고, 여러 라인으로 표현됩니다.

"안녕하세요" 큰따옴표로 둘러 싸인 문자열은, Interpreted String Literal 이라 하고,

- 문자열 안에 \n 을 줄바꿈으로 인식, 복수라인 안됨, + 사용 결합합니다.

출력시 에러발생하면:

첫번째(파일이름),두번째(에러발생 라인),세번째(그 라인에서 발생지점),네번째(에러 내용)

go언어가 정적타입 언어라, 프로그램 실행 전에 에러 발생시 - 경고 출력함.

공부할때는 main.go 파일로 저장 보단, 해당 목적 암시용 파일 이름(helloworld.go)가

같은 폴더에서 여러 파일을 만들고 실행할수 있어서, 편한듯 싶음.

실행 명령1: go mod init

- go 모듈을 초기화하고 관리하는 명령임.

- 현재 패키지의 종속성 정보를 담고 있는 go.mod 파일이 생성됨.

- go.mod 파일은 모듈의 이름, Go 버전, 종속성 정보를 포함함.

- go.mod 파일은 모듈이 호환되는 Go 언어의 버전을 명시함.

실행 명령2: go mod tidy

- 사용하지 않는 종속성을 제거하고 go.mod 파일을 정리함.

- 컴파일 전에 한번씩 기본적으로 실행해줌.

실행 명령3> go run main.go

- 소스 코드를 컴파일하고, 생성된 바이너리 파일을 즉시 실행함.

- 임시로 컴파일된 파일은 실행 후 자동으로 삭제됨.

- 스크립트 처럼, 빠르게 테스트할때 사용함.

go run helloworld.go

실행 명령4> go build .

- 해당 프로젝트(폴더 이름)으로 파일이 생성됨.

go build main.go

go build helloworld.go

- 소스 코드를 컴파일하여 실행 가능한 바이너리 파일을 생성함.

- 독립적으로 실행할 수 있어, Go 런타임이나 소스 코드 없이도 프로그램을 실행함.

출력> hello world. 헬로 헬로

20241209

화장실 타일 실금- 보수 방법 [기록]

화장실, 또는 베란다에 타일에 금이간것을 보수하는 방법

1. 가장 좋은 방법은: 글라인더로 타일 1장만 짤라내고, 새롭게 붙이는 방법이지만,

2. 타일에 실금이 간경우, 대부분 유광쪽에만 금이 간경우가 많기에, 그거 관련 외관 보수 방법 기록함.

타일[화장실] 실금이 간곳에, 락스를 뿌리고, 랩으로 덮어두고,

- 락스의 물기에 랩을 펼쳐 붙이면, 락스가 잘 흘러내리지 않는 효과]

- 곰팡이 제거가 목적임.

몇시간 지나고, 깨끗하게 닦고, 타일을 건조 시킨후,

- 바짝 마른상태에서 유광페인트 작업함[드라이기로 빨리 건조 가능]

차량용 투명 유광[락카형] 페인트를, 해당 부위에 뿌린다.

[페인트 가게의, 투명 유광 페인트는, 붓으로 발라야 되고, 차량용이 거친 환경에서도 잘 버틸듯]

- 또는 손톱에 바르는 매니큐어[투명,흰색....]으로 칠해줍니다.

- 랩과 테이프로, 페인트가 묻으면 안되는곳에 붙여 두고 작업함.

- 다이소에 보면, 투명 유광페인트 비슷한, 본드처럼 바르는 것도 판매 되는거 보았슴.

- 페인트 가게에, 투명 유광 페인트는 가격이 1만원 초반대이고, 양이 너무 많고, 붓으로 발라야 함.

자동차용 투명 유광이, 자동차는 외부용 이기에, 좀더 내구성이 좋을거라 생각됨.

- 만일 타일 조각까지 떨어진 상태라면- 다이소에 보면[퍼티- 목재, 도자기용]비슷한 색을 구매해서,

먼저 매꿔주고 작업하거나, 페인트가게에 보면[색조 빨강,파랑,노랑,검정..] 으로 조색해서 작업하고,

투명 유광, 광이 나는 투명한 페인트로 마무리 합니다.

페이지

20241230

스택 (Stack), 큐 (Queue) 에 대하여

20241227

Go언어의 IF 문, FOR 문

20241226

20241224

Log 체크 방법으로, 에러 위치 체크 방법- Fatalf

20241223

상수(const) 관련 -golang

Go 명령어

Go 언어의 타입 과 변수 변수선언 관련

배열 (Array)- 고정 크기를 가지며, 동일한 타입의 데이터를 저장.

문법: [크기]타입

슬라이스 (Slice)- 배열의 가변 크기 버전으로, 길이가 동적으로 변경 가능.

문법: []타입

맵 (Map)- 키-값 쌍을 저장하는 해시 테이블.

문법: map[키_타입]값_타입

구조체 (Struct)- 여러 필드를 묶어서 정의.

문법: type 이름 struct

포인터 (Pointer)- 값의 메모리 주소를 저장.

문법: *타입

타입 변환- Go에서는 명시적 타입 변환만 허용됩니다. 암시적 변환은 허용되지 않습니다.

타입 추론- var 키워드나 :=를 사용하면 Go가 자동으로 타입을 추론합니다.

인터페이스 타입- Go는 빈 인터페이스 (interface{})를 통해 모든 타입을 받을 수 있습니다.커스텀 인터페이스를 정의하면 특정 메서드를 구현하는 타입에 제한을 걸 수 있습니다.

사용자 정의 타입- type 키워드를 사용해 새로운 타입을 정의할 수 있습니다.

Go언어는, Golang 이라고도 합니다.

20241220

해외 여행시, 스마트폰 충전 관련 준비물은

20241219

20241209

문법: `[크기]타입`

문법: `[]타입`

문법: `map[키_타입]값_타입`

문법: `type 이름 struct`

문법: `*타입`

타입 추론- `var` 키워드나 `:=`를 사용하면 Go가 자동으로 타입을 추론합니다.

인터페이스 타입- Go는 빈 인터페이스 (`interface{}`)를 통해 모든 타입을 받을 수 있습니다.커스텀 인터페이스를 정의하면 특정 메서드를 구현하는 타입에 제한을 걸 수 있습니다.

사용자 정의 타입- `type` 키워드를 사용해 새로운 타입을 정의할 수 있습니다.