Go 구조체, 인터페이스 써보기
2019-02-17 23:46:18 # Go

구조체

변수들의 집합, JS에는 업지만 솔리디티에서 좀 써봣다.

Go는 클래스가 업기 때문에 구조체를 클래스처럼 쓰므로 잘 기억해두자.

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
32
33
34
35
36
37
package main

import "fmt"

// Go 구조체 선언 방법.
type user struct {
	id       string
	name     string
	password string
}

func main() {

	/*
		구조체 호출 방법
		쓰고 보니 뭔가 자바스크립트 Object 스럽다.
	*/
	a := user{}
	a.id = "emma"
	a.name = "엠마"
	a.password = "neverland"

	fmt.Println(a) // {emma 엠마 neverland}

	fmt.Println(a.id) // emma

	// 구조체 호출 방법 new 연산자를 붙여서 쓸수 있다.
	b := new(user)

	b.id = "luffy"
	b.name = "루피"
	b.password = "onepiece"

	fmt.Println(b) // &{luffy 루피 onepiece} 포인터를 리턴 한다.

	fmt.Println(b.id) // luffy
}

생성자

구조체를 사용전에 초기화 할 필요가 있을 시 생성자 함수로 만들어서 사용을 할 수 있다고 한다.

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
32
33
34
35
36
37
38
package main
import "fmt"

// map이 있는 구조체
type con struct {
	data map[string]string
}

/*
	생성자 함수 생성
	포인터로 해야 된다.
*/
func newCon() *con {
	c := con{}
	c.data = make(map[string]string)
	return &c
}

func main() {
	c := newCon() // 생성자 호출
	c.data["a"] = "A"

	fmt.Println(c) // &{map[a:A]}

	fmt.Println(*c) // {map[a:A]}

	fmt.Println(c.data["a"]) // A

	// fmt.Println(*c.data["a"]) // err

	d := newCon()

	d.data["b"] = "B"

	fmt.Println(d.data) // map[b:B]

	fmt.Println(d.data["b"]) // B
}

메소드

위에서도 썻지만 Go는 클래스가 업기 때문에 구조체, 메소드로 OOP ㄱㄱ

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
32
33
34
35
36
37
package main
import "fmt"

// 유저 구조체 정의
type User struct {
	id   string
	name string
	age  uint8
}

/*
    메소드 정의
    일반 함수랑 같음 파라미터만 구조체일뿐..
*/
func (u User) getId() string {
	return u.id
}

func (u User) getName() string {
	return u.name
}

func (u User) getAge() uint8 {
	return u.age
}

func main() {
	user := User{"oneforall", "allforone", 99}

	id := user.getId() // 메소드 호출

	name := user.getName()

	age := user.getAge()

	fmt.Println(id, name, age) // oneforall allforone 99
}

포인터

메소드 함수를 만들 때 구조체를 포인터로 받을 수 있다.

포인터니깐.. 구조체의 원본이 당연히 달라진다.

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package main
import "fmt"

type Cal struct {
	first  int
	second int
}

// 구조체의 데이터를 copy
func (c Cal) plus() int {
	c.first = c.first + c.second
	return c.first + c.second
}

func (c Cal) multiply() int {
	return c.first * c.second
}

// 포인터로 쓸 경우.
func (c *Cal) plus2() int {
	c.first = c.first + c.second
	return c.first + c.second
}

func (c *Cal) multiply2() int {
	return c.first * c.second
}

func main() {
	cal := Cal{1, 5}

	plus := cal.plus()

	fmt.Println("plus", plus) // plus 11

	multi := cal.multiply()

	fmt.Println("multi_1", multi) // multi_1 5

	cal2 := Cal{1, 5}

	plus2 := cal2.plus2()

	fmt.Println("plus2", plus2) // plus2 11

	multi2 := cal2.multiply2()

	fmt.Println("multi2", multi2) // multi2 30 {구조체 원본 first가 바뀌엇기 때문.}
}

인터페이스

구조체가 변수들의 집합이라면 인터페이스는 메소드들의 집합이다.

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package main
import "fmt"

/*
	인터페이스
	메서드의 집합.
*/
type cal interface {
	plus() int
	multiply() int
}

type one struct {
	first  int
	second int
}

type two struct {
	first  int
	second int
}

func (a one) plus() int {
	return a.first + a.second
}

func (a one) multiply() int {
	return a.first * a.second
}

func (b two) plus() int {
	return b.first + b.second
}

func (b two) multiply() int {
	return b.first * b.second
}

/*
	구조체의 메소드를 다 정의하면
	이런 식으로 메소드를 호출을 할 수 있다.
*/
func showArea(cal ...cal) {
	for _, s := range cal {
		a := s.plus()  //인터페이스 메서드 호출
		fmt.Println(a) // 6 \n 60
	}
}

func main() {
	a := one{1, 5}
	b := two{10, 50}

	showArea(a, b)
}

데이터 타입

인터페이스를 다이나믹 타입이라 해서 데이터 타입으로 쓸 수 잇다.

JS Object랑 비슷해보임, 위보단 이 쪽으로 마니 쓸 거 같은 느낌 아닌 느낌..?

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
32
33
34
35
36
37
package main
import "fmt"

func main() {
	/*
		인터페이스 타입으로 하면 Dynamic Type
		선언 방법은 데이터 타입interface{} {}
	*/

	v := []interface{}{
		1,
		true,
		"hi",
		"golang",
	}

	for _, item := range v {
		fmt.Println("val:", item) // 1, true, hi, golang
	}

	m := map[string]interface{}{
		"a": "hi",
		"b": true,
		"c": 33,
		"d": []interface{}{
			"array1",
			"array2",
		},
		"e": map[string]interface{}{
			"x": "x",
			"y": "y",
			"z": "z",
		},
	}

	fmt.Println(m) // map[c:33 d:[array1 array2] e:map[x:x y:y z:z] a:hi b:true]
}

다음에 이어서 ㄱ

Prev
2019-02-17 23:46:18 # Go
Next