ํฐ์คํ ๋ฆฌ ๋ทฐ
๊ฐ์
- go ์ธ์ด ์ฌ์ฉ๋ฒ์ ๋ํด์ ์์๋ณด์
- ๋ค์ ๋ชฉ์ฐจ๋ก ์งํ๋๋ฉฐ ๋ค๋ฅธ ์ธ์ด๋ก ํ๋ก๊ทธ๋๋ฐ์ ๊ฒฝํํด๋ณธ ์ฌ๋ ๋์์ผ๋ก ์์ฑํ๋ค
- ๊ฐ์
- ๋ณ์, ์์ ์ ์ธ(+์ถ์ฝํ ์ ์ธ)
- ํ์
- ํจ์ ์ ์ธ(ignore value(_), defer, export function)
- ์กฐ๊ฑด๋ฌธ(if, switch)
- ๋ฐ๋ณต๋ฌธ(for)
- pointer(*)
- ๋ฐฐ์ด(slice, array)
๋ณ์, ์์ ์ ์ธ
- ๊ธฐ๋ณธ์ ์ผ๋ก ์์๋
const
, ๋ณ์๋var
ํค์๋๋ฅผ ์ด์ฉํด ์ ์ธํ๋ค - ์ฌ๋ฌ ๋ฐฉ๋ฒ์ผ๋ก ๋ณ์, ์์ ์ ์ธ๋ ๊ฐ๋ฅํ๋ฐ, ์ด๋ ์๋ ์ฝ๋๋ก ์ดํด๋ณด์
// ๊ธฐ๋ณธ ์ ์ธ
var age = 23
var name string
name = "mokhs"
// ๋ณ์ ์ถ์ฝํ ์ ์ธ : ์๋์ ์์ธํ ์์๋ณด์
role := "Backend Engineer"
// ์์ ์ ์ธ
const minAge = 0
fmt.Println(age, name, role, minAge)
์ถ์ฝํ ์ ์ธ
- go ์์๋
name := "mokhs00"
์ ๊ฐ์ด ์ถ์ฝํ ์ ์ธ์ด ๊ฐ๋ฅํ๋ค - ๋์ ํ๋ ๊ฐ์ผ๋ก ํ์ ์ด ์ถ๋ก ๋์ด ์๋์ผ๋ก ์ ์ฉ๋๋ค.
- ์ด๋ ํจ์ ๋ด๋ถ์์๋ง ์ฌ์ฉํ ์ ์๊ณ , ํจ์ ์ธ๋ถ์์๋ ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ ์ฃผ์ํ์
// error
count := 1
func main() {
count := 1
fmt.Println(count)
}
ํ์
- go์๋ ํ์ ์ด ์กด์ฌํ๊ณ ๊ณต์๋ฌธ์์์๋ ํ์ธ ๊ฐ๋ฅํ๋ค
var Typ = []*Basic{
Invalid: {Invalid, 0, "invalid type"},
Bool: {Bool, IsBoolean, "bool"},
Int: {Int, IsInteger, "int"},
Int8: {Int8, IsInteger, "int8"},
Int16: {Int16, IsInteger, "int16"},
Int32: {Int32, IsInteger, "int32"},
Int64: {Int64, IsInteger, "int64"},
Uint: {Uint, IsInteger | IsUnsigned, "uint"},
Uint8: {Uint8, IsInteger | IsUnsigned, "uint8"},
Uint16: {Uint16, IsInteger | IsUnsigned, "uint16"},
Uint32: {Uint32, IsInteger | IsUnsigned, "uint32"},
Uint64: {Uint64, IsInteger | IsUnsigned, "uint64"},
Uintptr: {Uintptr, IsInteger | IsUnsigned, "uintptr"},
Float32: {Float32, IsFloat, "float32"},
Float64: {Float64, IsFloat, "float64"},
Complex64: {Complex64, IsComplex, "complex64"},
Complex128: {Complex128, IsComplex, "complex128"},
String: {String, IsString, "string"},
UnsafePointer: {UnsafePointer, 0, "Pointer"},
UntypedBool: {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
UntypedInt: {UntypedInt, IsInteger | IsUntyped, "untyped int"},
UntypedRune: {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
UntypedFloat: {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
UntypedString: {UntypedString, IsString | IsUntyped, "untyped string"},
UntypedNil: {UntypedNil, IsUntyped, "untyped nil"},
}
ํจ์ ์ ์ธ
- ํจ์ ์ ์ธ์
func
ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ธํ๋ค - ๊ฐ์ ์ฌ๋ฌ๊ฐ return ํ๊ฑฐ๋ ์ฌ๋ฌ๊ฐ ํ์ ์ ํ ๋ฒ์ ์ ์ธํ๋ ๋ฑ์ ๋ฐฉ์๋ ๊ฐ๋ฅํ๋ค ์ด๋ ์๋์ ์์๋ณด์
// ํจ์ ์ ์ธ๊ธฐ๋ณธ ํ์
/*
func ํจ์๋ช
(์ธ์) ๋ฐํํ์
{
return ๋ฐํํ์
๊ณผ ์ผ์นํ๋ ๋ฆฌํด๊ฐ
}
*/
func foo(value int) int {
return value
}
// ์ธ์ ์ฌ๋ฌ๊ฐ ๋ฐ๊ธฐ
func foo(value ...int) []int {
return value
}
// ์ฌ๋ฌ ๊ฐ return
func foo(value int) (int, string) {
return value, "SUCCESS"
}
// naked return : return ๊ฐ์ ๋ฏธ๋ฆฌ ์ ์ธํ ์ ์์
func foo() (value int, message string) {
value = 1
message = "SUCCESS"
return
}
ignore value(_)
- ๋ฐํ๊ฐ์ ๋ณ์๋ก ์ ์ธํด์ผ ํ์ง๋ง,
_
๋ฅผ ์ด์ฉ ํด๋น ๋ฐํ๊ฐ์ ๋ฌด์ํ ์ ์๋ค - ์ฐธ๊ณ ๋ก
_
๋ ํค์๋๋ก ์ทจ๊ธ๋์ด ๋ณ์์ฒ๋ผ ์ฌ์ฉํ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ค - ๋ค์ ์์๋ฅผ ํตํด ์์๋ณด์
func main() {
_, b := foo()
}
func foo() (int, int) {
return 1, 2
}
defer
defer
๋ฅผ ์ด์ฉํด ํจ์ ์ข ๋ฃ ์์ ์คํํ ๊ตฌ๋ฌธ์ ์ถ๊ฐํ ์ ์๋คdefer
๋ก ์ฌ๋ฌ ๊ฐ์ ๊ตฌ๋ฌธ์ ์ถ๊ฐ ์์ ์์์๋ถํฐ ์๋๋ก ํ์ ์ ์ถ(LIFO)๋ฐฉ์์ผ๋ก ์คํ๋๋ค
func foo() (int, int) {
defer fmt.Println("isFinished")
return 1, 2
}
export function
- ํจ์๋ฅผ export ํ๊ณ ์ถ๋ค๋ฉด ํจ์์ ์ฒซ ๊ธ์๋ ๋๋ฌธ์๋ก ์์ฑํด์ผํ๋ค
- go์ built-in package์ ํจ์๋ค์์ ์ฒซ ๊ธ์๊ฐ ๋๋ฌธ์์ธ ๊ฒ์ ๋ฐ๊ฒฌํ ์ ์๋๋ฐ ์ด๋ ๊ฐ์ ์ด์ ์ด๋ค
์กฐ๊ฑด๋ฌธ(if, switch)
if
,switch
ํค์๋๋ฅผ ์ด์ฉํ ์กฐ๊ฑด๋ฌธ ์์ฑ์ด ๊ฐ๋ฅํ๋ค- ๋ค๋ฅธ ์ธ์ด๋ค๊ณผ ์ ์ฌํ๋ฉฐ, ์ฐจ์ด์ ์ด ์๋ค๋ฉด ์กฐ๊ฑด๋ฌธ ์ ์ธ๊ณผ ๋์์ ํด๋น ์กฐ๊ฑด๋ฌธ ์์์๋ง ์ฌ์ฉํ ์ ์๋ ๋ณ์๋ฅผ ์ ์ธํ ์ ์๋ค
- ์๋ ์์๋ฅผ ํตํด ์์๋ณด์
// if
func canIView(age int) bool {
// if๋ฌธ ์์์ ์ฌ์ฉํ ๋ณ์(koreanAge) ์ ์ธ
if koreanAge := age + 2; koreanAge < 18 {
return false
}
return true
}
// switch
func canIView2(age int) bool {
switch koreanAge := age + 2; {
case koreanAge < 18:
return false
default:
return true
}
}
switch, fallthrough
- go์ switch๋ case๋ง๋ค break๋ฌธ์ ์ฌ๋ถ์ ๋ฐ๋ผ ์ฐ์ฐ์ด ์ข ๋ฃ๋๋ ๋ค๋ฅธ ์ธ์ด์๋ ๋ค๋ฅด๊ฒ break๋ฌธ์ด ์์ด๋ case์ ์กฐ๊ฑด๊ณผ ์ผ์นํ๋ค๋ฉด switch ์ฐ์ฐ์ ๋น ์ ธ๋์ค๊ฒ ๋๋ค
- ์ด๋ go ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก case๋ง๋ค break๋ฌธ์ ์ถ๊ฐํด์ฃผ๊ธฐ ๋๋ฌธ์ด๋ค
- breakํ๊ณ ์ถ์ง ์๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด fallthrough ํค์๋๋ฅผ ์ด์ฉํด breakํ์ง ์๊ณ ์๋ case๋ก ๋ด๋ ค์ค ์ ์๋ค
- ์ด ๋ ์ฃผ์ํ ์ ์ ์๋ case์ ์ผ์นํ๋์ง ์ฌ๋ถ์ ์๊ด์์ด case ์์ ์ฐ์ฐ์ ๋ชจ๋ ์ํํ๋ค๋ ์ ์ด๋ค
func main() {
v := 1
switch v {
case 1:
fmt.Println("1")
fallthrough
case 2: // 2์ ์ผ์นํ์ง ์์ง๋ง fallthrough์ ์ํด์ case ์ ์ผ์นํ ๋์ ๋์ผํ ์ฐ์ฐ ์ํ
fmt.Println("2")
fallthrough
default:
fmt.Println("default")
}
/* ์ถ๋ ฅ
1
2
default
*/
}
๋ฐ๋ณต๋ฌธ(for)
- ๋ค๋ฅธ ์ธ์ด์์ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ ๋
for
,while
์ ํค์๋๊ฐ ์กด์ฌํ์ง๋ง - go์์ ๋ฐ๋ณต๋ฌธ์
for
๋ง ์กด์ฌํ๊ณfor
๋ง์ผ๋กwhile
์ ๊ธฐ๋ฅ๋ ๊ฐ๋ฅํ๋ค - ๋ํ ์กฐ๊ฑด๋ฌธ์์์ ๋์ผํ๊ฒ ๋ฐ๋ณต๋ฌธ ์์์๋ง ์ฌ์ฉํ ๋ณ์๋ฅผ ์ ์ธํ ์ ์๋ค
range
๋ฅผ ์ด์ฉํ๋ฉด ์ฐ์์ ์ธ ๊ฐ์ ๊ฐ์ง๋ ๋ณ์๋ฅผ ์ํํ ์ ์๋ค- ์์ธํ ๊ฑด ์๋ ์์๋ฅผ ํตํด ์์๋ณด์
// ๊ธฐ๋ณธ for๋ฌธ
func main() {
for i:=0; i < 10; i++ {
// ...
}
}
// range๋ฅผ ์ด์ฉํ ๋ฐ๋ณต๋ฌธ
func addAll(numbers ...int) int {
total := 0
// range๋ฅผ ์ด์ฉํ numbers ์ํ numbers์ ํ์
์ []int
for _, v := range numbers {
total += v
}
return total
}
pointer
- C์ ๋์ผํ๊ฒ ํฌ์ธํฐ(pointer) ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค
- ํฌ์ธํฐ๋
ํด๋น ๋ณ์์ ์ฃผ์๊ฐ์ ๊ฐ๋ฆฌํค๋ ๊ฐ
์ ์๋ฏธํ๊ณ ์ฃผ์๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ์ฐธ์กฐ๋ฅผ ์ด์ฉํ์ฌ ํ์์ ๋ฐ๋ผ ๋ค์ํ ๋ก์ง์ ์ ์ฉํ ์ ์๋ค - ์ฃผ์๊ฐ์ ์๋ฏธํ๋
&
, ํด๋น ์ฃผ์์ ์๋ value๋ฅผ ์๋ฏธํ๋*
ํค์๋๋ฅผ ์ด์ฉํ๋ค - ์์ธํ ๊ฑด ์๋ ์์๋ฅผ ํตํด์ ์์๋ณด์
func main() {
a := 2
// b์ a์ ์ฃผ์๊ฐ์ ์ ์ฅ
b := &a
a = 10
// 0xc00006ef60 0xc00006ef60
println(&a, b)
// *ํค์๋๋ก ์ฃผ์์ ์ ์ฅ๋ value ์กฐํ
// 10 10
println(a, *b)
}
๋ฐฐ์ด(slice, array)
- go๋ ๋ฐฐ์ด์ ๋ํ๋ด๋ built-in ์๋ฃํ์ผ๋ก
slice
,array
๋ฅผ ์ ๊ณตํ๋ค slice
์array
์ ์ฐจ์ด์ ์ ์ฉ๋(๋ฐฐ์ด์ ํฌ๊ธฐ)๋ฅผ ์ง์ ํ๋ ๊ฒ์ธ๋ฐ, array๋ ๊ณ ์ ํฌ๊ธฐ, slice๋ ์ ๋์ ์ธ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ์ ์ธ๋ฐฉ๋ฒ๋ ๋ค๋ฅด๋ค
(+ slice๋ ๋ด๋ถ์ ์ผ๋ก ๋ฐฐ์ด pointer,length, capacity ๊ฐ์ ๊ฐ์ง๋ค)- ์ฌ๋ผ์ด์ฑ, ์์ ์ถ๊ฐ(append), ๋ณต์ฌ(copy)๊ธธ์ด ์ธก์ (length), ์ฉ๋ ์ธก์ (capacity) ๋ฑ์ด ๊ฐ๋ฅํ๋ค
- ์๋ ์์๋ฅผ ํตํด์ ์์ธํ ์์๋ณด์
func main() {
slice := []int{1, 2, 3}
array := [5]int{1, 2, 3}
// [1 2 3] [1 2 3 0 0]
fmt.Println(slice, array)
// built-in ํจ์์ธ append()๋ฅผ ์ด์ฉํ ์์ ์ถ๊ฐ, slice์๋ง ๊ฐ๋ฅํ๋ค
// [1 2 3 3 4 5]
fmt.Println(append(slice, 3, 4, 5))
// slice์ ๋ค๋ฅธ slice๋ฅผ appendํ๋ ๊ฒ๋ ๊ฐ๋ฅ
// [1 2 3 5 6 7]
fmt.Println(append(slice, []int{5, 6, 7}...))
target := []int{0, 0, 0}
// target := make([]int, len(slice), cap(slice))
// target ๊ณผ slice์ length๊ฐ ์ผ์นํ์ง ์์ผ๋ฉด ๋ณต์ฌ๋์ง ์์ผ๋ ์ฃผ์!!
// 3 [1 2 3] [1 2 3]
fmt.Println(copy(target, slice), target, slice)
// ๊ธฐ์กด slice๋ array๋ฅผ ์ฌ๋ผ์ด์ฑ (ํ์ด์ฌ ๋ฌธ๋ฒ๊ณผ ์ ์ฌํ๋ค)
sliceOfArray := array[:2]
// len : length ๊ธธ์ด, cap : capacity ์ฉ๋
// [1 2] 2 5
fmt.Println(sliceOfArray, len(sliceOfArray), cap(sliceOfArray))
}
slice ์ ์ธ with make()
- slice์ ๋ํด์ ์ข ๋ ์์๋ณด์
- slice๋ go์ built-in function์ธ make()๋ก๋ ์ ์ธ์ด ๊ฐ๋ฅํ๋ค
- make()๋ฅผ ์ด์ฉํ๋ฉด slice์
์ด๊ธฐํ ๊ธธ์ด
(length),์ฉ๋
(capacity)๋ฅผ ์ง์ ํ ์ ์๋ค length
๋ฅผ 0์๋ ๊ฐ์ผ๋ก ์ง์ ํ๋ฉด length ๊ฐ ๋งํผ ๊ธฐ๋ณธ ๊ฐ์ด ์ ์ฅ๋๋ฏ๋ก ์ฃผ์! (์๋ ์์ ํ์ธ)
func main() {
// make(type, length, capacity)
s := make([]int, 5, 10)
// 5 10 [0 0 0 0 0]
fmt.Println(len(s), cap(s), s)
}
slice capacity
- ๋ณดํต ๋๋ถ๋ถ์ ์ธ์ด์์ ๋์ ๋ฐฐ์ด(e.g.slice)์ ์์๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ์ฉ๋์ ๋์ ์ผ๋ก ์ฆ๊ฐ์ํจ๋ค
- go์์๋ ์ง์ ํ capacity๋ฅผ ์ด๊ณผํ์ ๋ ๊ธฐ์กด capacity๋ฅผ 2๋ฐฐ๋ก ๋๋ฆฐ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํด ๊ธฐ์กด ๋ฐฐ์ด์ ์์๋ค์ ๋ณต์ฌํ๋ค
- ์ฆ ์ ๊ณผ์ ์ผ๋ก ์ธํด์ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ slice์ ์ฉ๋์ ์ ์ ํ ์ ์ธํด์ผํ๋ค
map
- key, value ํ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์๋ map์ ์ ๊ณตํ๋ค
- ์ ์ธ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ๋ค
func main() {
// map[key type][value type]
fooMap := map[string]string{"key": "value"}
fmt.Println(fooMap)
}
structs
- go์์๋ c์ ๊ตฌ์กฐ์ฒด์ ์ ์ฌํ ํํ๋ฅผ ์ง์ํ๋ค
- ๊ตฌ์กฐ์ฒด๋ฅผ ์ ์ธํจ์ผ๋ก์จ ์๋ก์ด ์๋ฃํ์ ์ ์ธํ ์ ์๊ณ , type-safe์๋ ํจ๊ณผ๊ฐ ์๋ค
- ์๋ ์์๋ฅผ ํตํด ์์๋ณด์
type user struct {
name string
age int
}
func main() {
user := user{name: "mokhs00", age: 23}
fmt.Println(user)
}
๋ฐ์ํ
'Go' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Golang - Rate Limit (0) | 2023.09.16 |
---|---|
Go : ๊ณ ๋ฃจํด(goroutine), ์ฑ๋(channels) (0) | 2022.03.20 |
Go : struct, type, method (0) | 2022.03.20 |
๊ณต์ง์ฌํญ
์ต๊ทผ์ ์ฌ๋ผ์จ ๊ธ
์ต๊ทผ์ ๋ฌ๋ฆฐ ๋๊ธ
- Total
- Today
- Yesterday
TAG
- grpc client
- Go
- ํ๋ก๊ทธ๋๋จธ์ค
- ์๊ณ ๋ฆฌ์ฆ
- 2๋ ์ฐจ ์๋ฒ ๊ฐ๋ฐ์
- ํ(Heap)
- ์ข์ ์ฝ๋๋ ๋ฌด์์ธ๊ฐ?
- ๋ฑ ํฌ์๋ฌ๋ ๊ฐ๋ฐ์
- ์ฝ๋ฉํ ์คํธ
- ๊น์ด/๋๋น ์ฐ์ ํ์(DFS/BFS)
- Aws Reinvent 2023
- kotlin s3 upload
- ์คํ/ํ
- ํธ๋์ญ์ ๊ฒฉ๋ฆฌ ์์ค
- HTTP
- ์ข์ ๊ฐ๋ฐ์
- ์ข์ ๊ฐ๋ฐ์ ๋๊ธฐ
- ํด์
- mysql ์คํ ๊ณํ
- ๋ฐฑ์ค
- 2023 ๊ฐ๋ฐ์ ํ๊ณ
- golang oomkilled
- ์ถ์ ์ง๋
- 2023 ํ๊ณ
- mysql
- ์ฅ์ ํ๊ณ
- ์ข์ ์์ง๋์ด
- Golang
- AWS re:Invent 2023
- rate limit
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
๊ธ ๋ณด๊ดํจ