dogfootman.com

privacy

dogfootman — Thu, 27 Jun 2024 20:35:53 +0900

Privacy Policy

Last updated: June 27, 2024

Introduction

Welcome to dogfootman.com ("we," "our," or "us"). We are committed to protecting your personal information and your right to privacy. If you have any questions or concerns about this privacy notice or our practices with regard to your personal information, please contact us at contact@dogfootman.com.

Information We Collect

We do not collect any personal information from you.

Contact Us

If you have questions or comments about this notice, you may contact us at contact@dogfootman.com.

[Go] Benchmark 사용법 (How to Use Benchmarks)

dogfootman — Tue, 25 Jun 2024 23:18:37 +0900

개요

Benchmark의 사용법

1. 기본 사용법

func BenchmarkXxx(*testing.B)

의 형태를 가지고 있으면 벤치마크로 간주되며

-bench 의 플러그가 있으면 go test 의 명령에 의해서 실행된다

샘플코드

package main

...

func BenchmarkDeepCopyManual(b *testing.B) {
	original := Student{
		Name:    "Alice",
		Age:     21,
		Hobbies: []string{"Reading", "Cycling", "Swimming"},
		Address: Address{
			City:  "San Francisco",
			State: "CA",
		},
	}

	for i := 0; i < b.N; i++ {
		_ = deepCopyManual(original)
	}
}

func BenchmarkDeepCopyJSON(b *testing.B) {
	original := Student{
		Name:    "Alice",
		Age:     21,
		Hobbies: []string{"Reading", "Cycling", "Swimming"},
		Address: Address{
			City:  "San Francisco",
			State: "CA",
		},
	}

	for i := 0; i < b.N; i++ {
		_, err := deepCopyJSON(original)
		if err != nil {
			b.Fatalf("Error: %v", err)
		}
	}
}

func BenchmarkDeepCopyGob(b *testing.B) {
	original := Student{
		Name:    "Alice",
		Age:     21,
		Hobbies: []string{"Reading", "Cycling", "Swimming"},
		Address: Address{
			City:  "San Francisco",
			State: "CA",
		},
	}

	for i := 0; i < b.N; i++ {
		_, err := deepCopyGob(original)
		if err != nil {
			b.Fatalf("Error: %v", err)
		}
	}
}

func BenchmarkDeepCopyReflect(b *testing.B) {
	original := Student{
		Name:    "Alice",
		Age:     21,
		Hobbies: []string{"Reading", "Cycling", "Swimming"},
		Address: Address{
			City:  "San Francisco",
			State: "CA",
		},
	}

	for i := 0; i < b.N; i++ {
		var copyStudent Student
		deepCopyReflect(&copyStudent, original)
	}
}

와 같이 작성해 xxx_test.go 의 형태로 저장

b.N: 테스트가 반복되는 횟수이며, 자동적으로 계산 된다

실행 커맨드 예)

-bench regexp

'-bench .' or '-bench=.'

ex) 모든 벤치마크 함수를 실행한다

go test -bench .

참고 윈도우? 환경에선 -bench=. 의 형태로 사용 할 땐 ""로 감싸주어야 실행이 되는듯 하다

go test -bench="."

ex) *JSON형태의 함수를 실행한다

 go test -bench ".*JSON"
 go test -bench=".*JSON"

2. 결과 값

PS D:\Study\golang\project\deepcopy\deepcopybench> go test -bench .                      
goos: windows
goarch: amd64
pkg: project/deepcopy/deepcopybench
cpu: AMD Ryzen 7 5800X3D 8-Core Processor
BenchmarkDeepCopyManual-16      32283057                33.78 ns/op
BenchmarkDeepCopyJSON-16          561468              2260 ns/op
BenchmarkDeepCopyGob-16            69405             17542 ns/op
BenchmarkDeepCopyReflect-16      4331769               273.4 ns/op
PASS
ok      project/deepcopy/deepcopybench  5.565s

결과 값 표시 내용

BenchmarkDeepCopyManual-16
- BenchmarkDeepCopyManual: 실행된 메서드
- -16: 병렬로 실행 된 고루틴의 수 (= CPU 수)
32283057: 실행 수
33.78 ns/op: 평균 실행 속도 ns 단위

3. 실행 시간 지정 (-benchtime t)

ex) 10초 동안 실행

go test -bench . -benchtime 10s

기본값은 1s

PS D:\Study\golang\project\deepcopy\deepcopybench> go test -bench . -benchtime 10s
goos: windows
goarch: amd64
pkg: project/deepcopy/deepcopybench
cpu: AMD Ryzen 7 5800X3D 8-Core Processor
BenchmarkDeepCopyManual-16      365221957               33.65 ns/op
BenchmarkDeepCopyJSON-16         5229326              2264 ns/op
BenchmarkDeepCopyGob-16           674312             17697 ns/op
BenchmarkDeepCopyReflect-16     44499788               276.3 ns/op
PASS
ok      project/deepcopy/deepcopybench  54.713s

대략 10배의 시간이 걸린 것을 알수있다

4. 반복 횟수 지정 (-count n)

ex) 3회 반복

go test -bench . -count 3

기본값은 1

PS D:\Study\golang\project\deepcopy\deepcopybench> go test -bench . -count 3     
goos: windows
goarch: amd64
pkg: project/deepcopy/deepcopybench
cpu: AMD Ryzen 7 5800X3D 8-Core Processor
BenchmarkDeepCopyManual-16      36163094                33.08 ns/op
BenchmarkDeepCopyManual-16      36837273                33.15 ns/op
BenchmarkDeepCopyManual-16      36041664                34.14 ns/op
BenchmarkDeepCopyJSON-16          541074              2209 ns/op
BenchmarkDeepCopyJSON-16          509419              2241 ns/op
BenchmarkDeepCopyJSON-16          526886              2216 ns/op
BenchmarkDeepCopyGob-16            68505             17692 ns/op
BenchmarkDeepCopyGob-16            68971             17452 ns/op
BenchmarkDeepCopyGob-16            67466             17293 ns/op
BenchmarkDeepCopyReflect-16      4377800               276.3 ns/op
BenchmarkDeepCopyReflect-16      4317730               273.9 ns/op
BenchmarkDeepCopyReflect-16      4263261               270.8 ns/op
PASS
ok      project/deepcopy/deepcopybench  16.097s

1초씩 3회 반복 된다

5. 메모리 할당량 측정 (-benchmem)

go test -bench . -benchmem

PS D:\Study\golang\project\deepcopy\deepcopybench> go test -bench . -benchmem
goos: windows
goarch: amd64
pkg: project/deepcopy/deepcopybench
cpu: AMD Ryzen 7 5800X3D 8-Core Processor
BenchmarkDeepCopyManual-16      34451178                33.11 ns/op           48 B/op          1 allocs/op
BenchmarkDeepCopyJSON-16          485587              2297 ns/op             720 B/op         18 allocs/op
BenchmarkDeepCopyGob-16            65107             17625 ns/op           10284 B/op        261 allocs/op
BenchmarkDeepCopyReflect-16      4331397               270.4 ns/op           232 B/op          4 allocs/op
PASS
ok      project/deepcopy/deepcopybench  5.385s

추가 된 결과 값의 의미

48 B/op: 각 실행에서 평균적으로 48바이트의 메모리가 할당
1 allocs/op: 각 실행에서 평균적으로 1번의 메모리가 할당

6. CPU 코어 수 지정 (-cpu n,n,n...)

go test -bench . -cpu 1,4

각각 CPU의 코어를 1개 4개씩 사용하여 실행한다

PS D:\Study\golang\project\deepcopy\deepcopybench> go test -bench . -cpu 1,4 
goos: windows
goarch: amd64
pkg: project/deepcopy/deepcopybench
cpu: AMD Ryzen 7 5800X3D 8-Core Processor
BenchmarkDeepCopyManual         35368495                32.29 ns/op
BenchmarkDeepCopyManual-4       36784426                33.96 ns/op
BenchmarkDeepCopyJSON             520654              2265 ns/op
BenchmarkDeepCopyJSON-4           556598              2231 ns/op
BenchmarkDeepCopyGob               68617             17370 ns/op
BenchmarkDeepCopyGob-4             67000             17880 ns/op
BenchmarkDeepCopyReflect         4287910               270.8 ns/op
BenchmarkDeepCopyReflect-4       4495464               277.1 ns/op
PASS
ok      project/deepcopy/deepcopybench  10.904s

7. 기타 옵션의 확인

go help testflag 명령어나

아래의 참조 사이트를 통해서 확인 가능

참조: https://pkg.go.dev/testing#hdr-Benchmarks

testing package - testing - Go Packages

Discover Packages Standard library testing Version: go1.22.4 Opens a new window with list of versions in this module. Published: Jun 4, 2024 License: BSD-3-Clause Opens a new window with license information. Imports: 24 Opens a new window with list of impo

pkg.go.dev

참조: https://pkg.go.dev/cmd/go#hdr-Testing_flags

go command - cmd/go - Go Packages

Discover Packages Standard library cmd go Version: go1.22.4 Opens a new window with list of versions in this module. Published: Jun 4, 2024 License: BSD-3-Clause Opens a new window with license information. Imports: 34 Opens a new window with list of impor

pkg.go.dev

[Go] 구조체를 여러가지 방법으로 깊은 복사 하는 방법 + 성능비교 (How to deep copy a struct in various ways + Performance comparison)

dogfootman — Tue, 25 Jun 2024 22:02:44 +0900

개요

구조체를 여러가지 방법으로 깊은 복사

각 복사 방법의 성능 비교 (Benchmark)

벤치마크 참고: https://dogfootman.com/14

[Go] Benchmark 사용법 (How to Use Benchmarks)

개요Benchmark의 사용법 1. 기본 사용법func BenchmarkXxx(*testing.B) 의 형태를 가지고 있으면 벤치마크로 간주되며-bench 의 플러그가 있으면 go test 의 명령에 의해서 실행된다 샘플코드package main...f

dogfootman.com

1. 수동으로 깊은 복사

package main

import "fmt"

type Address struct {
    City  string
    State string
}

type Student struct {
    Name    string
    Age     int
    Hobbies []string
    Address Address
}

func deepCopyStudent(original Student) Student {
    hobbiesCopy := make([]string, len(original.Hobbies))
    copy(hobbiesCopy, original.Hobbies)

    return Student{
       Name:    original.Name,
       Age:     original.Age,
       Hobbies: hobbiesCopy,
       Address: Address{
          City:  original.Address.City,
          State: original.Address.State,
       },
    }
}

func main() {
    original := Student{
       Name:    "Alice",
       Age:     21,
       Hobbies: []string{"Reading", "Cycling", "Swimming"},
       Address: Address{
          City:  "San Francisco",
          State: "CA",
       },
    }

    // deep copy
    copyStudent := deepCopyStudent(original)

    // update original
    original.Name = "Bob"
    original.Hobbies[0] = "Running"
    original.Address.City = "Los Angeles"

    fmt.Println("Original:", original)
    fmt.Println("Copy:", copyStudent)
}

result:

Original: {Bob 21 [Running Cycling Swimming] {Los Angeles CA}}
Copy: {Alice 21 [Reading Cycling Swimming] {San Francisco CA}}

2. Json을 이용한 깊은 복사

package main

import (
    "encoding/json"
    "fmt"
)

type Address struct {
    City  string
    State string
}

type Student struct {
    Name    string
    Age     int
    Hobbies []string
    Address Address
}

func deepCopyStudent(original Student) (Student, error) {
    var copyStudent Student
    data, err := json.Marshal(original)
    if err != nil {
       return copyStudent, err
    }
    err = json.Unmarshal(data, &copyStudent)
    return copyStudent, err
}

func main() {
    original := Student{
       Name:    "Alice",
       Age:     21,
       Hobbies: []string{"Reading", "Cycling", "Swimming"},
       Address: Address{
          City:  "San Francisco",
          State: "CA",
       },
    }

    // deep copy
    copyStudent, err := deepCopyStudent(original)
    if err != nil {
       fmt.Println("Error:", err)
       return
    }

    // update original
    original.Name = "Bob"
    original.Hobbies[0] = "Running"
    original.Address.City = "Los Angeles"

    fmt.Println("Original:", original)
    fmt.Println("Copy:", copyStudent)
}

result:

Original: {Bob 21 [Running Cycling Swimming] {Los Angeles CA}}
Copy: {Alice 21 [Reading Cycling Swimming] {San Francisco CA}}

3. 리플렉션을 이용한 깊은 복사

package main

import (
    "fmt"
    "reflect"
)

type Address struct {
    City  string
    State string
}

type Student struct {
    Name    string
    Age     int
    Hobbies []string
    Address Address
}

func deepCopy(dst, src interface{}) {
    srcVal := reflect.ValueOf(src)
    dstVal := reflect.ValueOf(dst).Elem()
    deepCopyValue(dstVal, srcVal)
}

func deepCopyValue(dst, src reflect.Value) {
    switch src.Kind() {
    case reflect.Ptr:
       if !src.IsNil() {
          dst.Set(reflect.New(src.Elem().Type()))
          deepCopyValue(dst.Elem(), src.Elem())
       }
    case reflect.Struct:
       for i := 0; i < src.NumField(); i++ {
          deepCopyValue(dst.Field(i), src.Field(i))
       }
    case reflect.Slice:
       if !src.IsNil() {
          dst.Set(reflect.MakeSlice(src.Type(), src.Len(), src.Cap()))
          for i := 0; i < src.Len(); i++ {
             deepCopyValue(dst.Index(i), src.Index(i))
          }
       }
    default:
       dst.Set(src)
    }
}

func main() {
    original := Student{
       Name:    "Alice",
       Age:     21,
       Hobbies: []string{"Reading", "Cycling", "Swimming"},
       Address: Address{
          City:  "San Francisco",
          State: "CA",
       },
    }

    // deep copy
    var copyStudent Student
    deepCopy(&copyStudent, original)

    // update original
    original.Name = "Bob"
    original.Hobbies[0] = "Running"
    original.Address.City = "Los Angeles"

    fmt.Println("Original:", original)
    fmt.Println("Copy:", copyStudent)
}

result:

Original: {Bob 21 [Running Cycling Swimming] {Los Angeles CA}}
Copy: {Alice 21 [Reading Cycling Swimming] {San Francisco CA}}

4. Gob을 이용한 깊은 복사

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
)

type Address struct {
    City  string
    State string
}

type Student struct {
    Name    string
    Age     int
    Hobbies []string
    Address Address
}

func deepCopyStudent(original Student) (Student, error) {
    var copyStudent Student
    buf := new(bytes.Buffer)
    enc := gob.NewEncoder(buf)
    dec := gob.NewDecoder(buf)
    if err := enc.Encode(original); err != nil {
       return copyStudent, err
    }
    if err := dec.Decode(&copyStudent); err != nil {
       return copyStudent, err
    }
    return copyStudent, nil
}

func main() {
    original := Student{
       Name:    "Alice",
       Age:     21,
       Hobbies: []string{"Reading", "Cycling", "Swimming"},
       Address: Address{
          City:  "San Francisco",
          State: "CA",
       },
    }

    // deep copy
    copyStudent, err := deepCopyStudent(original)
    if err != nil {
       fmt.Println("Error:", err)
       return
    }

    // update original
    original.Name = "Bob"
    original.Hobbies[0] = "Running"
    original.Address.City = "Los Angeles"

    fmt.Println("Original:", original)
    fmt.Println("Copy:", copyStudent)
}

result:

Original: {Bob 21 [Running Cycling Swimming] {Los Angeles CA}}
Copy: {Alice 21 [Reading Cycling Swimming] {San Francisco CA}}

5. 성능 비교

실행 커맨드

go test -bench="." -benchmem

실행 코드

main_test.go

0.00MB

방법	실행 횟수 (1초)	평균 실행 속도	평균 메모리 사용량	메모리 할당 수
수동	35818543	32.92 ns/op	48 B/op	1 allocs/op
리플렉션	4314712	272.6 ns/op	232 B/op	4 allocs/op
JSON	518389	2220 ns/op	720 B/op	18 allocs/op
Gob	71022	17085 ns/op	10284 B/op	261 allocs/op

해당 테스트 코드에서의 속도는

수동 > 리플렉션 > JSON > Gob

의 순서로 빠르고 메모리 사용량도 적다

[Go] 제네릭 사용 예 (Example of using generics)

dogfootman — Sun, 23 Jun 2024 00:58:07 +0900

개요

go 1.18에서 추가 된 제네릭의 사용 예

1. 함수에서의 사용

package main

import "fmt"

func Filter[T any](list []T, predicate func(T) bool) []T {
	var result []T
	for _, v := range list {
		if predicate(v) {
			result = append(result, v)
		}
	}
	return result
}

func main() {
	
	// 짝수만 필터
	nums := []int{1, 2, 3, 4, 5, 6}
	evens := Filter(nums, func(n int) bool {
		return n%2 == 0
	})
	fmt.Println(evens) // [2 4 6]

	// 길이가 5가 넘는 문자열만 필터
	strings := []string{"apple", "banana", "cherry", "date"}
	filteredStrings := Filter(strings, func(s string) bool {
		return len(s) > 5
	})
	fmt.Println(filteredStrings) // ["banana", "cherry"]
}

T는 타입 매개변수
any

2. 구조체에서의 사용

package main

import "fmt"

type Stack[T any] struct {
	elements []T
}

func (s *Stack[T]) Push(element T) {
	s.elements = append(s.elements, element)
}

func (s *Stack[T]) Pop() T {
	if len(s.elements) == 0 {
		var zero T
		return zero
	}
	element := s.elements[len(s.elements)-1]
	s.elements = s.elements[:len(s.elements)-1]
	return element
}

func main() {
	intStack := Stack[int]{}
	intStack.Push(1)
	intStack.Push(2)
	fmt.Println(intStack.Pop()) // 2

	stringStack := Stack[string]{}
	stringStack.Push("hello")
	stringStack.Push("world")
	fmt.Println(stringStack.Pop()) // world
}

package main

import "fmt"

type Pair[T any] struct {
	first, second T
}

func (p Pair[T]) Swap() Pair[T] {
	return Pair[T]{p.second, p.first}
}

func main() {
	intPair := Pair[int]{1, 2}
	fmt.Println(intPair.Swap()) // {2 1}

	stringPair := Pair[string]{"hello", "world"}
	fmt.Println(stringPair.Swap()) // {world hello}
}

3. 인터페이스를 통한 타입 제한

package main

import "fmt"

type Adder interface {
	Add() int
}

// Calculator1 Add 함수만 가지는 구조체
type Calculator1 struct {
	a int
	b int
}

func (c Calculator1) Add() int {
	return c.a + c.b
}

// Calculator2 Minus 함수만 가지는 구조체
type Calculator2 struct {
	a int
	b int
}

func (c Calculator2) Minus() int {
	return c.a - c.b
}

func AddValues[T Adder](adder T) int {
	return adder.Add()
}

func main() {
	// Calculator 인스턴스를 생성
	calc := Calculator1{2, 3}

	// AddValues 함수를 호출하여 두 값의 합을 계산
	result := AddValues(calc)
	fmt.Println(result) // 5

	// Calculator2 인스턴스를 생성
	//calc2 := Calculator2{5, 3}
	//result2 := AddValues(calc2) // T (type Calculator2) does not satisfy Adder (missing method Add) 에러 발생
	//fmt.Println(result2)
}

Calculator1 구조체는 Adder 인터페이스를 구현하므로 AddValues 함수에 전달 가능
Calculator2 구조체는 Adder 인터페이스를 구현하지 않으므로 AddValues 함수에 전달 불가

package main

import "fmt"

type Number interface {
	int | float64
}

func Average[T Number](values []T) T {
	var sum T
	for _, v := range values {
		sum += v
	}
	return sum / T(len(values))
}

func main() {
	fmt.Println(Average([]int{1, 2, 3, 4, 5}))        // 3 (int)
	fmt.Println(Average([]float64{1.1, 2.2, 3.3}))    // 2.2 (float64)
	//fmt.Println(Average([]string{"apple", "banana"})) // string does not satisfy Number (string missing in int | float64) 에러 발생
}

참고:

https://go.dev/blog/intro-generics

[Go] 고랭에서의 예외처리 (exception handling in golang)

dogfootman — Sat, 22 Jun 2024 00:38:49 +0900

개요

예외 처리:

많은 언어에서 예외는 프로그램 실행 중에 발생하는 비정상적인 상황을 처리하기 위한 메커니즘

예외는 try-catch 블록을 사용하여 처리

패닉 처리:

Go 언어에서는 패닉은 프로그램이 정상적으로 계속 실행될 수 없는 심각한 오류가 발생했을 때 사용

패닉이 발생하면 현재 고루틴은 즉시 중단되고, defer로 등록된 함수들이 호출된 후 프로그램이 종료

recover를 사용하여 패닉을 복구할 수 있지만, 일반적인 오류 처리 메커니즘으로 사용되지는 않음

1. panic이 발생하는 프로그램

package main

import "fmt"

func main() {
    fmt.Println("Start!!")
    divide(10, 0)
    fmt.Println("End")
}

func divide(x, y int) int {
    return x / y
}

0으로 나누어 패닉을 발생 시킨다.

main 함수에서 시작 메세지를 출력
divide 함수를 호출
y에 0을 전달 했기때문에 panic이 발생
종료메세지는 실행 되지 않는다.

실행 결과:

Start!!
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.divide(...)
	D:/Study/golang/project/panic/main.go:12
main.main()
	D:/Study/golang/project/panic/main.go:7 +0x52

2. recovery를 추가한 프로그램

package main

import "fmt"

func main() {
    fmt.Println("Start!!")
    divide(10, 0)
    fmt.Println("End!!")
}

func divide(x, y int) {
    defer func() {
       if r := recover(); r != nil {
          fmt.Println("Recovery: ", r)
       }
    }()

    fmt.Println("Start divide: ", x, y)
    result := x / y
    fmt.Println("Result: ", result)
}

divide의 첫줄에 defer func을 추가

main 함수에서 시작 메세지를 출력
divide 함수를 호출
y에 0을 전달 했기때문에 panic이 발생
func 실행이 종료되었으므로 defer의 func이 실행
recovery가 nil이 아니므로 리커버리의 메세지를 출력
Result는 출력되지 않는다.
main 함수에서 종료 메세지가 출력

실행 결과:

Start!!
Start divide:  10 0
Recovery:  runtime error: integer divide by zero
End!!

3. error를 반환하여 처리한 프로그램

package main

import (
    "errors"
    "fmt"
)

func main() {
    fmt.Println("Start!!")
    result, err := divide(10, 0)
    if err != nil {
       fmt.Println("Error:", err)
    } else {
       fmt.Println("Result:", result)
    }
    fmt.Println("End!!")
}

func divide(x, y int) (int, error) {
    if y == 0 {
       return 0, errors.New("cannot divide by zero")
    }
    return x / y, nil
}

y이 0이 전달 될 경우 panic이 발생 할 것이 예측 가능하므로 명시적으로 error를 반환

main 함수에서 시작 메세지를 출력
divide 함수를 호출
y에 0을 전달 되었기 때문에 error를 명시적으로 반환
main 함수에서 err가 있으면 에러 메세지를 출력, 없으면 결과 값을 출력
main 함수에서 종료 메세지가 출력

실행 결과:

Start!!
Error: cannot divide by zero
End

4. panic recovery나 return error를 사용 할 때 고려 해야 할 사항

패닉을 사용할 때:

심각한 오류: 패닉은 복구할 수 없는 심각한 오류 상황에서만 사용해야 함
즉시 중단: 프로그램을 즉시 중단시키므로, recovery를 통해 적절한 처리가 필요
디버깅: 패닉이 발생한 위치와 원인을 파악하기 쉽도록 패닉 메세지에 대한 정보를 출력

에러를 반환할 때:

예측 가능한 오류: 예상할 수 있는 오류 상황에서는 에러를 반환하는 것을 우선적으로 고려
오류 처리: 호출자에게 오류를 알려, 호출자에서 적절한 조치를 취할 수 있도록 함

참고:

https://go.dev/blog/defer-panic-and-recover

[Go] import cycle not allowed - 해결 방안1: interface를 활용한 해결 방안

dogfootman — Tue, 18 Jun 2024 02:05:06 +0900

개요

이전 import cycle not allowed 에러를 인터페이스를 활용해 해결

https://dogfootman.com/9

[Go] import cycle not allowed - 예제

개요import cycle not allowed가 발생하는 경우+---------------------+ +----------------------+| user 패키지 | | board 패키지 || | | || +-----------------+ | | +------------------+ || | User Struct | | | | Post Struct | || +-----------------+ |

dogfootman.com

1. 프로젝트 구조

/dependency2
│
├── main.go
├── user
│   └── user.go
└── board
│   └── board.go
└── interfaces
    └── interfaces.go

의존 관계를 없애기 위한 intefaces 패키지를 추가

2. 코드

interfaces.go

package interfaces

type Board interface {
    GetLastPostByUserID(userID int) string
}

type User interface {
    GetUserNameByID(userID int) string
}

board.go

package board

import (
    "dependency2/interfaces"
)

type Post struct {
    ID      int
    UserID  int
    Title   string
    Content string
}

var posts = []*Post{
    {ID: 1, UserID: 1, Title: "First Post", Content: "This is Alice's first post"},
    {ID: 2, UserID: 2, Title: "Hello World", Content: "This is Bob's first post"},
}

type PostInfo struct {
    *Post
    UserName string
}

type Impl struct {
    User interfaces.User
}

func (b *Impl) GetPostList() []*PostInfo {

    var postList []*PostInfo
    for _, post := range posts {
       // 각 게시글 작성자의 이름을 가져옴
       userName := b.User.GetUserNameByID(post.UserID)
       info := &PostInfo{Post: post, UserName: userName}
       postList = append(postList, info)
    }

    return postList
}

func (b *Impl) GetLastPostByUserID(userID int) string {
    for i := len(posts) - 1; i >= 0; i-- {
       if posts[i].UserID == userID {
          return posts[i].Title
       }
    }
    return "No posts found"
}

user.go

package user

import (
    "dependency2/interfaces"
)

type User struct {
    ID        int
    Name      string
    FriendIDs []int
}

var users = []*User{
    {ID: 1, Name: "Alice", FriendIDs: []int{2}},
    {ID: 2, Name: "Bob", FriendIDs: []int{1}},
}

type FriendInfo struct {
    *User
    LastPost string
}

type Impl struct {
    Board interfaces.Board
}

func (u *Impl) GetFriendList(userID int) []*FriendInfo {

    user := u.GetUserByID(userID)
    if user == nil || len(user.FriendIDs) == 0 {
       return nil
    }

    var infoList []*FriendInfo
    for _, friendID := range user.FriendIDs {
       friendUser := u.GetUserByID(friendID)
       // 유저의 마지막 글을 취득
       lastPost := u.Board.GetLastPostByUserID(friendUser.ID)
       info := &FriendInfo{User: friendUser, LastPost: lastPost}
       infoList = append(infoList, info)
    }
    return infoList
}

func (u *Impl) GetUserByID(userID int) *User {
    for _, user := range users {
       if user.ID == userID {
          return user
       }
    }
    return nil
}

func (u *Impl) GetUserNameByID(userID int) string {
    user := u.GetUserByID(userID)
    if user == nil {
       return ""
    }
    return u.GetUserByID(userID).Name
}

main.go

package main

import (
    "dependency2/board"
    "dependency2/user"
    "encoding/json"
    "fmt"
)

func main() {

    boardService := &board.Impl{}
    userService := &user.Impl{}

    boardService.User = userService
    userService.Board = boardService

    friendList := userService.GetFriendList(1)
    friendListJsonData, _ := json.Marshal(friendList)
    fmt.Println("Friend List:", string(friendListJsonData))

    postList := boardService.GetPostList()
    postListJsonData, _ := json.Marshal(postList)
    fmt.Println("Post List:", string(postListJsonData))
}

생성한 서비스를 각각의 서비스의 인터페이스를 통해 주입

boardService.User = userService
userService.Board = boardService

3. 실행 결과

Friend List: [{"ID":2,"Name":"Bob","FriendIDs":[1],"LastPost":"Hello World"}]
Post List: [{"ID":1,"UserID":1,"Title":"First Post","Content":"This is Alice's first post","UserName":"Alice"},{"ID":2,"UserID":2,"Title":"Hello World","Content":"This is Bob's first post","UserName":"Bob"}]

에러 없이 실행이 가능한 것을 확인

[Go] import cycle not allowed - 예제

dogfootman — Tue, 18 Jun 2024 00:53:47 +0900

개요

import cycle not allowed가 발생하는 경우

+---------------------+       +----------------------+
|      user 패키지    |       |      board 패키지     |
|                     |       |                      |
| +-----------------+ |       | +------------------+ |
| |   User Struct   | |       | |    Post Struct   | |
| +-----------------+ |       | +------------------+ |
|                     |       |                      |
| +-----------------+ |       | +------------------+ |
| | GetFriendList() | <-------+ | GetLastPostByUserID() |
| +-----------------+ |       | +------------------+ |
|                     |       |                      |
| +-----------------+ |       | +------------------+ |
| | GetUserNameByID() +-------> | GetPostList()    | |
| +-----------------+ |       | +------------------+ |
|                     |       |                      |
+---------------------+       +----------------------+

user패키지에는 친구 리스트를 반환하는 func가 존재하고 <- board패키지로 부터 마지막 작성한 게시글을 취득
board패키지에서는 게시판 글 리스트 반환하는 func이 존재 -> user패키지로 부터 유저의 이름을 취득

1. 프로젝트 구조

/dependency1
│
├── main.go
├── user
│   └── user.go
└── board
    └── board.go

2. 코드

main.go

package main

import (
	"dependency1/board"
	"dependency1/user"
	"fmt"
)

func main() {
	friendList := user.GetFriendList(1)
	fmt.Println("Friend List:", friendList)

	postList := board.GetPostList()
	fmt.Println("Post List:", postList)
}

board.go

package board

import (
	"dependency1/user"
)

type Post struct {
	ID      int
	UserID  int
	Title   string
	Content string
}

var posts = []*Post{
	{ID: 1, UserID: 1, Title: "First Post", Content: "This is Alice's first post"},
	{ID: 2, UserID: 2, Title: "Hello World", Content: "This is Bob's first post"},
}

type PostInfo struct {
	*Post
	UserName string
}

func GetPostList() []*PostInfo {

	var postList []*PostInfo
	for _, post := range posts {
		// 각 게시글 작성자의 이름을 가져옴
		userName := user.GetUserNameByID(post.UserID)
		info := &PostInfo{Post: post, UserName: userName}
		postList = append(postList, info)
	}

	return postList
}

func GetLastPostByUserID(userID int) string {
	// 주어진 userID의 마지막 게시글 반환
	for i := len(posts) - 1; i >= 0; i-- {
		if posts[i].UserID == userID {
			return posts[i].Title
		}
	}
	return "No posts found"
}

user.go

package user

import (
	"dependency1/board"
)

type User struct {
	ID        int
	Name      string
	FriendIDs []int
}

var users = []*User{
	{ID: 1, Name: "Alice", FriendIDs: []int{2}},
	{ID: 2, Name: "Bob", FriendIDs: []int{1}},
}

type FriendInfo struct {
	*User
	LastPost string
}

func GetFriendList(userID int) []*FriendInfo {

	user := GetUserByID(userID)
	if user == nil || len(user.FriendIDs) == 0 {
		return nil
	}

	var infoList []*FriendInfo
	for _, friendID := range user.FriendIDs {
		friendUser := GetUserByID(friendID)
		// 유저의 마지막 글을 취득
		lastPost := board.GetLastPostByUserID(friendUser.ID)
		info := &FriendInfo{User: friendUser, LastPost: lastPost}
		infoList = append(infoList, info)
	}
	return infoList
}

func GetUserByID(userID int) *User {
	for _, user := range users {
		if user.ID == userID {
			return user
		}
	}
	return nil
}

func GetUserNameByID(userID int) string {
	user := GetUserByID(userID)
	if user == nil {
		return ""
	}
	return GetUserByID(userID).Name
}

3. 실행결과

package dependency1
	imports dependency1/board
	imports dependency1/user
	imports dependency1/board: import cycle not allowed

import cycle not allowed 에러가 발생하는걸 확인 할 수 있다

[Go] 슬라이스의 얕은 복사와 깊은 복사 (Shallow Copy and Deep Copy of Slices)

dogfootman — Thu, 3 Aug 2023 23:43:41 +0900

개요

슬라이스의 얕은 복사와 깊은 복사에 대해서

1. 얕은 복사

package main

import (
	"fmt"
	"sort"
)

type obj struct {
	Name string
	Age  int32
}

func main() {

	list1 := []*obj{
		{Name: "A", Age: 1},
		{Name: "B", Age: 2},
		{Name: "C", Age: 3},
	}
	list2 := list1

	sort.Slice(list2, func(i, j int) bool {
		return list2[i].Age < list2[j].Age
	})

	fmt.Printf("List1 [%p]\n", list1)
	for _, item := range list1 {
		fmt.Printf("Name: %s, Age: %d [%p]\n", item.Name, item.Age, item)
	}

	fmt.Printf("List2 [%p]\n", list2)
	for _, item := range list2 {
		fmt.Printf("Name: %s, Age: %d [%p]\n", item.Name, item.Age, item)
	}
}

결과값:

List1 [0xc0000a8060]
Name: A, Age: 1 [0xc0000a8078]
Name: B, Age: 2 [0xc0000a8090]
Name: C, Age: 3 [0xc0000a80a8]
List2 [0xc0000a8060]
Name: A, Age: 1 [0xc0000a8078]
Name: B, Age: 2 [0xc0000a8090]
Name: C, Age: 3 [0xc0000a80a8]

슬라이스가 같은 주소값(0xc0000a8060)을 가지며 원본도 같이 정렬 된 것을 확인

2. 깊은 복사 (copy)

package main

import (
	"fmt"
	"sort"
)

type obj struct {
	Name string
	Age  int32
}

func main() {

	list1 := []*obj{
		{Name: "C", Age: 3},
		{Name: "B", Age: 2},
		{Name: "A", Age: 1},
	}

	list2 := make([]*obj, len(list1))

	copy(list2, list1)

	sort.Slice(list2, func(i, j int) bool {
		return list2[i].Age < list2[j].Age
	})

	fmt.Printf("List1 [%p]\n", list1)
	for _, item := range list1 {
		fmt.Printf("Name: %s, Age: %d [%p]\n", item.Name, item.Age, item)
	}

	fmt.Printf("List2 [%p]\n", list2)
	for _, item := range list2 {
		fmt.Printf("Name: %s, Age: %d [%p]\n", item.Name, item.Age, item)
	}
}

결과값:

List1 [0xc00009c060]
Name: C, Age: 3 [0xc00009c078]
Name: B, Age: 2 [0xc00009c090]
Name: A, Age: 1 [0xc00009c0a8]
List2 [0xc00009c0c0]
Name: A, Age: 1 [0xc00009c0a8]
Name: B, Age: 2 [0xc00009c090]
Name: C, Age: 3 [0xc00009c078]

원본 슬라이스(0xc00009c060)와 다른 주소값(0xc00009c0c0)을 가진 것을 확인

https://pkg.go.dev/builtin#copy

builtin package - builtin - Go Packages

Package builtin provides documentation for Go's predeclared identifiers. The items documented here are not actually in package builtin but their descriptions here allow godoc to present documentation for the language's special identifiers. View Source cons

pkg.go.dev

3. 깊은 복사 (append)

package main

import (
	"fmt"
	"sort"
)

type obj struct {
	Name string
	Age  int32
}

func main() {

	list1 := []*obj{
		{Name: "C", Age: 3},
		{Name: "B", Age: 2},
		{Name: "A", Age: 1},
	}

	var list2 []*obj
	list2 = append(list2, list1...)

	sort.Slice(list2, func(i, j int) bool {
		return list2[i].Age < list2[j].Age
	})

	fmt.Printf("List1 [%p]\n", list1)
	for _, item := range list1 {
		fmt.Printf("Name: %s, Age: %d [%p]\n", item.Name, item.Age, item)
	}

	fmt.Printf("List2 [%p]\n", list2)
	for _, item := range list2 {
		fmt.Printf("Name: %s, Age: %d [%p]\n", item.Name, item.Age, item)
	}
}

결과값:

List1 [0xc000116060]
Name: C, Age: 3 [0xc000116078]
Name: B, Age: 2 [0xc000116090]
Name: A, Age: 1 [0xc0001160a8]
List2 [0xc0001160c0]
Name: A, Age: 1 [0xc0001160a8]
Name: B, Age: 2 [0xc000116090]
Name: C, Age: 3 [0xc000116078]

원본 슬라이스(0xc000116060)와 다른 주소값(0xc0001160c0)을 가진 것을 확인

https://pkg.go.dev/builtin#append

builtin package - builtin - Go Packages

pkg.go.dev

[Go] golang sort.Slice를 사용할때의 주의점 sort.SliceStable와의 차이점 (Important Considerations When Using golang sort.Slice and Differences from sort.SliceStable)

dogfootman — Thu, 27 Jul 2023 23:56:16 +0900

개요

sort.Slice를 사용했을때와 sort.SliceStable를 사용했을때의 결과를 비교

1. sort.Slice

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	people := []Person{
		{"Alice", 30},
		{"Bob", 30},
		{"Charlie", 30},
		{"David", 30},
		{"Eve", 30},
		{"Alice", 10},
		{"Bob", 10},
		{"Charlie", 10},
		{"David", 10},
		{"Eve", 10},
		{"Alice", 20},
		{"Bob", 20},
		{"Charlie", 20},
		{"David", 20},
		{"Eve", 20},
	}

	// 이름으로 정렬
	sort.Slice(people, func(i, j int) bool {
		return people[i].Name < people[j].Name
	})
	fmt.Println("이름으로 정렬 sort.Slice:")
	for _, p := range people {
		fmt.Printf("%s - Age: %d\n", p.Name, p.Age)
	}

	fmt.Printf("\n")

	// 나이로 정렬
	sort.SliceStable(people, func(i, j int) bool {
		return people[i].Age < people[j].Age
	})
	fmt.Println("나이로 정렬 sort.Slice:")
	for _, p := range people {
		fmt.Printf("%s - Age: %d\n", p.Name, p.Age)
	}
}

결과값:

이름으로 정렬 sort.Slice:
Alice - Age: 20        
Alice - Age: 30        
Alice - Age: 10        
Bob - Age: 30
Bob - Age: 10
Bob - Age: 20
Charlie - Age: 30      
Charlie - Age: 20      
Charlie - Age: 10      
David - Age: 30        
David - Age: 10        
David - Age: 20        
Eve - Age: 10
Eve - Age: 30
Eve - Age: 20

나이로 정렬 sort.Slice:
David - Age: 10        
Alice - Age: 10        
Eve - Age: 10
Bob - Age: 10
Charlie - Age: 10
Eve - Age: 20
Bob - Age: 20
Alice - Age: 20
Charlie - Age: 20
David - Age: 20
Charlie - Age: 30
David - Age: 30
Bob - Age: 30
Eve - Age: 30
Alice - Age: 30

퀵소트를 베이스로 하는 정렬로 슬라이스의 원래의 순서가 보장 되지않는다

2. sort.SliceStable

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	people := []Person{
		{"Alice", 30},
		{"Bob", 30},
		{"Charlie", 30},
		{"David", 30},
		{"Eve", 30},
		{"Alice", 10},
		{"Bob", 10},
		{"Charlie", 10},
		{"David", 10},
		{"Eve", 10},
		{"Alice", 20},
		{"Bob", 20},
		{"Charlie", 20},
		{"David", 20},
		{"Eve", 20},
	}

	// 이름으로 정렬
	sort.SliceStable(people, func(i, j int) bool {
		return people[i].Name < people[j].Name
	})
	fmt.Println("이름으로 정렬 sort.SliceStable:")
	for _, p := range people {
		fmt.Printf("%s - Age: %d\n", p.Name, p.Age)
	}

	fmt.Printf("\n")

	// 나이로 정렬
	sort.SliceStable(people, func(i, j int) bool {
		return people[i].Age < people[j].Age
	})
	fmt.Println("나이로 정렬 sort.SliceStable:")
	for _, p := range people {
		fmt.Printf("%s - Age: %d\n", p.Name, p.Age)
	}
}

결과값:

이름으로 정렬 sort.SliceStable:
Alice - Age: 30              
Alice - Age: 10              
Alice - Age: 20              
Bob - Age: 30                
Bob - Age: 10                
Bob - Age: 20                
Charlie - Age: 30            
Charlie - Age: 10            
Charlie - Age: 20            
David - Age: 30              
David - Age: 10              
David - Age: 20              
Eve - Age: 30                
Eve - Age: 10                
Eve - Age: 20                
                             
나이로 정렬 sort.SliceStable:
Alice - Age: 10              
Bob - Age: 10                
Charlie - Age: 10            
David - Age: 10              
Eve - Age: 10                
Alice - Age: 20              
Bob - Age: 20                
Charlie - Age: 20
David - Age: 20
Eve - Age: 20
Alice - Age: 30
Bob - Age: 30
Charlie - Age: 30
David - Age: 30
Eve - Age: 30

원래의 순서가 보장되는것을 알수있다

참고:

https://pkg.go.dev/sort

sort package - sort - Go Packages

ExampleMultiKeys demonstrates a technique for sorting a struct type using different sets of multiple fields in the comparison. We chain together "Less" functions, each of which compares a single field. package main import ( "fmt" "sort" ) // A Change is a

pkg.go.dev

https://cs.opensource.google/go/go/+/refs/tags/go1.20.6:src/sort/slice.go

cs.opensource.google

https://go.dev/src/sort/zsortfunc.go

- The Go Programming Language

go.dev

[ETC] Postman API호출에서 앞의 처리에서 취득한 정보를 포함 하고 싶을때 (When you want to include the information obtained in the previous process in the Postman API call)

dogfootman — Sun, 23 Jul 2023 23:54:38 +0900

개요

호출 하고 싶은 API가 이전 처리의 결과값을 필요로 할때

ex) 인증 정보등

Pre-request Script를 사용해서 데이터를 포함

처리 순서

인증 API 호출

-> 인증 API의 response의 token취득

-> 호출 하고싶은 API의 해더값에 token 설정

-> 호출 하고싶은 API의 호출

0. 테스트용 API로 이전 Golang으로 작성 서버 사용

https://dogfootman.com/5

[Go] 고랭으로 간단한 HTTP Server 작성 (Writing a simple HTTP Server with Golang)

개요 고랭으로 HTTP 서버 작성 1. Hello World func main() { http.HandleFunc("/", handler) fmt.Println("Start Http Server: http://localhost:8080") err := http.ListenAndServe(":8080", nil) if err != nil { fmt.Println("Error:", err) } } http.DefaultSe

dogfootman.com

1. 순서

http://localhost:8080/login

-> response의 token취득

-> http://localhost:8080/shoplist 의 해더값으로 설정

-> http://localhost:8080/shoplist 호출

2. Pre-request Script 작성

// Pre-request Script
var loginParams = {
    username: 'user1',
    password: '1234'
};
 
var requestConfig = {
    url: 'http://localhost:8080/login',
    method: 'POST',
    header: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(loginParams)
};
 
pm.sendRequest(requestConfig, function(err, response) {
    if (err) {
        console.error(err);
    } else {
        console.log(response);
        var token = response.json().token;
        pm.request.headers.add('Bearer ' + token, 'Authorization');
    }
});

공식 도큐먼트 참조:

https://learning.postman.com/docs/writing-scripts/pre-request-scripts/#pre-request-scripting-example

Writing pre-request scripts | Postman Learning Center

Writing pre-request scripts: documentation for Postman, the collaboration platform for API development. Create better APIs—faster.

learning.postman.com

3. 결과 값 확인

포스트맨: https://www.postman.com/