lab golang study tutorials 02

Go tutorials

• 📔📝본 내용은 tour.golang.org 에 있는 내용을 정리한 글입니다.
• method 부터 concurrency 전까지

Go method!

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v Vertex) AbsMethod() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func AbsFunc(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}


type MyFloat float64 
// 메소드 만들때 주의사항, 일반 타입 안되고 custom 타입만 가능함. 같은 패키지 내에 선언되어 있어야함. ~~(싫어하는 이유가 계속 늘어난다!)~~

func (f MyFloat) Abs() float64 {
	if f < 0 {
		return float64(-f)
	}
	return float64(f)
}

func (v *Vertex) AbsPointer(n float64) float64 {
	v.X = v.X * n
	v.Y = v.Y * n
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func (v Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}


func main() {
	v := Vertex{3, 4}
	fmt.Println(v.Abs())
  fmt.Println(Abs(v))
  f := MyFloat(-math.Sqrt2)
	fmt.Println(f.Abs())

  v := Vertex{3, 4}
	fmt.Println(v.AbsPointer(2)) 
  // 포인터를 안쓰면 각각 다른 객체(복사된 값 사용)
  // 포인터를 쓰면 같은 레퍼런스를 참조하니까 같은 객체

	v.Scale(10)
	fmt.Println(v.AbsPointer(2)) 
}

노트

1. 메소드 주의사항

   1. 함수는 인자 넣을때 포인터 구분함(&붙여야됨) 메소드는 인자 넣을때 포인터 알아서 판단함 진짜 참 일관적으로 속편한 언어… 언어는 속이 편한데 개발자가 불편… v.Scale(5) == (&v).Scale(5)

      다행히 참조와 역참조 둘다 같은 특징을 가짐 p.Abs() 라는 메서드는 (*p).Abs() 로도 사용가능 그니까 value receiver이든 reference receiver 이든 메소드는 아무 신경안씀 대신 반드시 주의할점은, 레퍼런스 리시버는 값을 바꾸고, 값 리시버는 복사본을 만듬

      일반적으로 특정 유형의 모든 방법에는 값이나 포인터 리시버가 있어야 하지만 둘 다 혼합되어서는 안됩니다.

      
      
      type Abser interface {
        Abs() float64
      }
      
      func main() {
        var a Abser
        f := MyFloat(-math.Sqrt2)
        v := Vertex{3, 4}
      
        a = f  // a MyFloat implements Abser
      
        fmt.Println(a.Abs()) //1.4142135623730951
      
        a = &v // a *Vertex implements Abser
      
        // In the following line, v is a Vertex (not *Vertex)
        // and does NOT implement Abser.
        // a = v
      
        fmt.Println(a.Abs()) // 5
      
      }
      
      type MyFloat float64
      
      func (f MyFloat) Abs() float64 {
        if f < 0 {
          return float64(-f)
        }
        return float64(f)
      }
      
      type Vertex struct {
        X, Y float64
      }
      
      func (v *Vertex) Abs() float64 {
        return math.Sqrt(v.X*v.X + v.Y*v.Y)
      }
      

      여기서 또 애매한 사실은,

      func (v Vertex) Abs() float64 {
        return math.Sqrt(v.X*v.X + v.Y*v.Y)
      }
            func (v *Vertex) Abs() float64 {
        return math.Sqrt(v.X*v.X + v.Y*v.Y)
      }
      

      이렇게 하면 redeclared 라고 하면서, 아까 예제의 상황에서는

      func main() {
        a = &v // a *Vertex implements Abser
        fmt.Println(a.Abs())
      
        // In the following line, v is a Vertex (not *Vertex)
        // and does NOT implement Abser.
        a = v
      
        fmt.Println(a.Abs())
      }
      
      func (v Vertex) Abs() float64 {
        return math.Sqrt(v.X*v.X + v.Y*v.Y)
      }
      

      이건 또 잘 실행 된다… 값 리시버에서는 주소 넣어도 되고, 값 넣어도 되는데, 주소 리시버에서는 꼭 주소만 넣어야 된다. 이게 뭐야?

2. 자바를 잘몰라서… 무슨 뜻이지?

   • 인터페이스의 암시적 구현
     • type implements는 메소드를 실행함으로써 인터페이스를 구현합니다.
       명시적 intent의 선언도, “implementation"의 키워드도 없습니다.
       암시적 인터페이스는 인터페이스의 정의를 구현으로부터 분리하며,
       이는 사전 정렬 없이 어떠한 패키지에 등장할 수 있습니다.
       ?

3. 아래 나온 main 은 패키지 이름일듯? ({Hello}, main.T) Hello (3.141592653589793, main.F)

4. 영어공부

   • Under the hood : 내부
   • concrete type? 구체적인 타입 이름을 말하는 거겠지? 추상 타입도 있나? auto 같은거? 튜플이라고 하니까 (value, type) 직관적으로는 무슨 말을 하려고 하는지 의도는 알겠는데, 말은 모르겠다. 아무튼 이름 같아도 타입 다르면 다른거라는 거지.

5. nil receiver 가 좋다고 하던데

   type I interface {
     M()
   }
   
   type T struct {
     S string
   }
   
   func (t *T) M() {
     // if t == nil {
     // 	fmt.Println("this is",t)
     // 	return
     // }
     fmt.Println(t)
   }
   /*
     주석 처리 하면
     (<nil>, *main.T)
     <nil>
     (&{hello}, *main.T)
     &{hello}
   
     주석 풀면
     (<nil>, *main.T)
     this is <nil>
     (&{hello}, *main.T)
     &{hello}
   
     t 를 *t 로 하면 t.S 와 같은 에러 발생
     panic: runtime error: invalid memory address or nil pointer dereference
     니 멋대로 해라...
   
     아래는 실행 잘됨.
       func (t *T) M() {
         if t == nil {
             fmt.Println("this is",t)
             return
           }
         fmt.Println(*t)
       }
   */
   
   
   func main() {
     var i I
   
     var t *T
     i = t
     describe(i)
     i.M()
   
     i = &T{"hello"}
     describe(i)
     i.M()
   }
   
   func describe(i I) {
     fmt.Printf("(%v, %T)\n", i, i)
   }
   

6. type assertion

   var i interface{} = "hello"
   
    s := i.(string)
    fmt.Println(s)
   
    s, ok := i.(string)
    fmt.Println(s, ok)
   
    f, ok := i.(float64)
    fmt.Println(f, ok)
   
    f = i.(float64) // panic
    fmt.Println(f)
   

7. type switch

   
    func do(i interface{}) {
      switch v := i.(type) {
      case int:
        fmt.Printf("Twice %v(%T) is %v\n", v,v, v*2)
      case string:
        fmt.Printf("%q(%T) is %v bytes long\n", v,v, len(v))
      default:
        fmt.Printf("I don't know about type %T!\n", v)
      }
    }
   
    func main() {
      do(21)
      do("hello")
      do(true)
    }
   
   

8. Stringers 함수를 만들어놓으면 print할때 설정한것 처럼 나옴 함수 주석처리하면 그냥 객체만 나옴(아래 설정한 문장이 아니라)

   type Person struct {
      Name string
      Age  int
    }
   
    func (p Person) String() string {
      return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
    }
   
    func main() {
      a := Person{"Arthur Dent", 42}
      z := Person{"Zaphod Beeblebrox", 9001}
      fmt.Println(a, z)
    }
   

io.Reader 의 타입? 아마 다른 인터페이스 (*strings.Reader)
error, io.EOF 의 타입은 (*errors.errorString)

// 진도는 strings까지 했음 image 까지 하긴 했는데,
image 라이브러리는 나중에 사용하게 되면 다시 보는게 나을듯