Learn Golang

### USE ABOVE PACKAGES ###
# mkdir simplego && cd simplego
# cat > main.go
package main

import "github.com/jnuho/jnuho.github.io/goproject/calculator/operations"

func main() {
}

package main
import (
  "fmt"
  "reflect"
)
func main() {
  // int
  fmt.Println(reflect.TypeOf(10))

  // float64
  fmt.Println(reflect.TypeOf(3.1415))

  // string
  fmt.Println(reflect.TypeOf("LaLaLalla"))

  // bool
  fmt.Println(reflect.TypeOf(true))

  // int32: (rune타입 : 4-byte int32 타입과 별칭)
  fmt.Println(reflect.TypeOf('A'))
}

package main

import "fmt"

func main() {
  var a int = 3
  var b int // 타입별 기본값으로 대체 (초깃값 생략)
  var c = 4 // 우변값의 타입으로 대체 (타입생략)
  d := 5    // 우변값의 타입으로 대체 (var 키워드와 타입 생략)

  fmt.Println(a, b, c ,d)
}

package main

import (
  "fmt"
)

func main(){
  var x int32 = 7
  //var y float32 = 3.14

  fmt.Println(x + 1)
  fmt.Println(x - 1)
  fmt.Println(x * 1)
  fmt.Println(x / 1)
  fmt.Println(x % 1)

  fmt.Println(x & 1)
  fmt.Println(x | 1)
  fmt.Println(x ^ 1)
  fmt.Println(x &^ 1)

  fmt.Println(x << 1)
  fmt.Println(x >> 1)
}

package main

import (
  "fmt"
)

func main(){
  var x int32 = 7
  var y float32 = 3.14

  fmt.Println(x == y)
  fmt.Println(x != y)
  fmt.Println(x * y)
  fmt.Println(x < y)
  fmt.Println(x > y)
  fmt.Println(x <= y)
  fmt.Println(x >= y)

}

package main

import (
  "fmt"
  "math"
)

const epsilon = 0.000001

func equal(a, b float64) bool {
  diff := math.Abs(a-b)

  if diff <= epsilon {
    return true
  } else {
    return false
  }

}

func main() {
  var a float64 = 0.1
  var b float64 = 0.2
  var c float64 = 0.3

  fmt.Printf("%0.18f + %0.18f = %0.18f\n", a, b, a+b)
  fmt.Printf("%0.18f == %0.18f : %v\n", c, a+b, equal(a+b,c))

  a= 0.0000000000004
  b= 0.0000000000002
  c= 0.0000000000007

  fmt.Printf("%g == %g : %v\n", c, a+b, equal(a+b,c))

}

package main

import (
  "fmt"
  "math"
)

func equal(a, b float64) bool {
  return math.Nextafter(a,b) == b
}

func main() {
  var a float64 = 0.1
  var b float64 = 0.2
  var c float64 = 0.3

  fmt.Printf("%0.18f + %0.18f = %0.18f\n", a, b, a+b)
  fmt.Printf("%0.18f == %0.18f : %v\n", c, a+b, equal(a+b,c))

  a= 0.0000000000004
  b= 0.0000000000002
  c= 0.0000000000007

  fmt.Printf("%g == %g : %v\n", c, a+b, equal(a+b,c))
}

package main

import (
  "fmt"
  "math/big"
)

func main() {
  a, _ :=  new(big.Float).SetString("0.1") // a
  b, _ :=  new(big.Float).SetString("0.2") // b
  c, _ :=  new(big.Float).SetString("0.3") // c

  d := new(big.Float).Add(a,b) // a+b
  fmt.Println(a, b, c, d)
  fmt.Println(c.Cmp(d)) // 0: equals (정밀도 높음)
}

package main
import "fmt"

func factorial(n int) int {

  if n <= 1  {
    return 1
  } else {
    return n * factorial(n-1)
  }
}

func main() {

  fmt.Println(factorial(5))
}

const Pig int = 0
const Cow int = 1
const Chicken int = 2

const PI = 3.14
const PI2 float64 = 3.14

// iota로 간편하게 열거값 사용 하기
// 1씩증가. 소괄호 벗어나면 다시 초기화 됨
const (
  Red   int = iota // 0
  Blue  int = iota // 1
  Green int = iota // 2
)

// const를 소괄호()로 묶고 iota 사용하면
// 0부터 1씩 차례로 증가하며 값이 초기화 됨
const (
  C1 uint = iota + 1 // 1 = 0 + 1
  C2                 // 2 = 1 + 1
  C3                 // 3 = 2 + 1
)

const (
  BitFlag1 uint = iota + 1 // 1 = 1 << 0
  BitFlag2                 // 2 = 1 << 1
  BitFlag3                 // 4 = 1 << 2
  BitFlag4                 // 8 = 1 << 3
)

func PrintAnimal(animal int) {
  if animal == Pig {
    fmt.Println("꿀")
  } else if animal == Cow {
    fmt.Println("음메")
  } else if animal == Chicken {
    fmt.Println("꼬끼오")
  }

}

func main() {
  PrintAnimal(Pig)
  PrintAnimal(Cow)
  PrintAnimal(Chicken)

  var a int = PI * 100
  // var b int = PI2 * 100 // ERROR!
  fmt.Println(a)
  // fmt.Println(b)

  fmt.Println(C1)
  fmt.Println(C2)
  fmt.Println(C3)

  fmt.Println(BitFlag1)
  fmt.Println(BitFlag2)
  fmt.Println(BitFlag3)
}

  // 초기문을 실행하고 그 결과를 확인할때 조건문 사용
  if 초기문; 조건문 {
    // 초기문의 결과를 확인하는 목적으로 활용가능
  }

package main

import "fmt"


type ColorType int

const (
  Red ColorType = iota // 1
  Blue                 // 2
  Yellow                 // 3
  Green                 // 4
)

func SelectColor(color ColorType) {
  switch color {
    case Red:
      fmt.Println("Red!!!rrrr")
    case Blue:
      fmt.Println("Blue!!!bbb")
    case Yellow:
      fmt.Println("Yellow!!!")
    case Green:
      fmt.Println("Greeen!!!ggg")
  }
}

func main() {
  mycolor := Red
  fmt.Println(mycolor)

}

// label사용은 지양 - 혼동 올 수 있음
func find45(a int) (int, bool) {
  for b := 1; b < 10; b++ {
    if b*a == 45 {
      return b, true
    }
  }
  return 0, false
}

func main() {
  a := 1
  b := 0
  found := false

  for ; a <= 9; a++ {
    // Like for, the if statement can start with a short statement to execute before the condition.
    if b, found = find45(a); found {
      break
    }
  }

  fmt.Printf("%d * %d = %d\n", a, b, a*b)
}

package main

import (
  "fmt"
  "math"
)

func pow(x, n, lim float64) float64 {
  // Like for, the if statement can start with a short statement to execute before the condition.
  if v := math.Pow(x, n); v < lim {
    return v
  }
  return lim
}

func main() {
  fmt.Println(
    pow(3, 2, 10),
    pow(3, 3, 20),
  )
}

package main

import (
  "bufio"
  "fmt"
  "os"
)

func main() {
  stdin := bufio.NewReader(os.Stdin)

  for {
    // 입력 된 값이 변수에 저장되기 전에 버퍼에 저장
    // 숫자는 number에 저장되고 
    // 숫자 + 
    fmt.Print("숫자를 입력하세요: [-1로 종료]")
    var number int
    _, err := fmt.Scanln(&number)

    if err != nil {
      fmt.Println("숫자가 아닙니다!")

      //키보드 버퍼 비움
      stdin.ReadString('\n')
      continue
    }

    fmt.Printf("입력 하신 숫자는 %d 입니다.", number)

    if number%2 == 0 {
      fmt.Printf("입력 하신 숫자는 짝수, %d, 입니다.\n", number)
    } else if number%2 == 1 {
      fmt.Printf("입력 하신 숫자는 홀수, %d, 입니다.\n", number)
    } else if number == -1 {
      fmt.Printf("for문 종료\n")
      break
    }
  }
}

package main

import (
  "fmt"
)

func main() {
  a := [5]int{1,2,3,4,5}
  b := [5]int{500,400,300,200,100}

  // a
  for i,v := range a {
    fmt.Printf("a[%d] = %d\n", i, v)
  }

  // b
  fmt.Println()
  for i, v := range b {
    fmt.Printf("b[%d] = %d\n", i, v)
  }

  b = a

  // a가 복사된 b
  fmt.Println()
  for i,v := range b {
    fmt.Printf("b[%d] = %d\n", i, v)
  }
}

package main

import (
  "fmt"
)

func main() {
  a := [2][5] int {
    {1,2,3,4,5},
    {6,7,8,9,10},
    // 행바뀜 있을때는 마지막에 , 필요
    // 행바뀜없는 inline 일때는 필요 없음 e.g. { {...},{.., 9,10} }
  }

  for _, arr := range a {
    for _, v := range arr {
      fmt.Print(v, "")
    }
    fmt.Println()
  }
}

package main

import (
  "fmt"
  "unsafe"
)


type User struct {
  A int32 // 4바이트
  B float64 // 8바이트
}

type User2 struct {
  A int8    // 1바이트
  B int     // 8바이트
  C int8    // 1바이트
  D int     // 8바이트
  E int8    // 1바이트
}

type User3 struct {
  A int8    // 1바이트
  C int8    // 1바이트
  E int8    // 1바이트
  B int     // 8바이트
  D int     // 8바이트
}

func main() {
  user := User {34, 97.5}
  // 12바이트가 아닌 16바이트 출력 : 메모리정렬
  // 변수시작주소를 변구크기의 배수로 맞춤
  fmt.Println("user size : ", unsafe.Sizeof(user))

  user2 := User2{1,2,3,4,5}
  fmt.Println("user2 size : ", unsafe.Sizeof(user2))

  user3 := User3{1,2,3,4,5}
  fmt.Println("user3 size : ", unsafe.Sizeof(user3))

}

func main() {
  var a int = 500
  var p *int

  p = &a

  fmt.Printf("p의 값: %p\n", p) // 메모리 주솟값
  fmt.Printf("p가 가리키는 메모리의 값: %d\n", *p) // p가 가리키는 메모리의 값 *p == a

  *p = 100 // p가 가리키는 메모리의 값 변경
  fmt.Printf("===p가 가리키는 메모리의 값 변경->100===\n")
  fmt.Printf("a의 값: %d\n", a) // a값 변화 확인 *p == a

  var p2 *int = &a
  fmt.Printf("p2도 a를 가리키는 *int 포인터 입니다: \n\tp2= %p, *p2=%d, &a=%p\n", p2,*p2, &a)
}

func main() {
  var a int = 10
  var b int = 20

  var p1 *int = &a
  var p2 *int = &a
  var p3 *int = &b

  fmt.Printf("p1 == p2 : %v\n", p1==p2)
  fmt.Printf("p2 == p3 : %v\n", p2==p3)


  // 포인터의 기본값 nil
  var p *int
  if p != nil {
    fmt.Println("포인터 p는 유효한 메모리 공간을 가리킴")
  } else {
    fmt.Println("포인터 p == nil 어떤 메모리 공간도 가리키고 있지 않음")
  }

  // 포인터는 변수대입 또는 함수 인수전달 시 메모리 공간을 적게 사용하면서 사용 가능
}

package main

import (
  "fmt"
)

type Data struct {
  value int
  data [200]int
}

// 호출할때마다 Data 구조체 크기만큼의 메모리 복사되고 그 값을 변경함
// 전달받은 변수의 값은 변경 안됨.
// 메모리를 매번 복사하기 때문에 많이 호출 시 성능저하
func ChangeDataNotWorking(arg Data) {
  // 매개'변수' arg 데이터 변경 안됨...
  arg.value = 999
  arg.data[100] = 999
}

func ChangeData(arg *Data) {
  // 매개'변수' arg 데이터 변경
  arg.value = 999
  arg.data[100] = 999
}

func main() {
  // 인스턴스: 메모리에 할당된 '데이터의 실체'
  // 포인터를 이용하여 인스턴스에 접근

  // 인스턴스는 언제사라지나?
  // 메모리에 데이터 할당되고 사라지지 않으면 메모리고갈-> 메모리 해제 Gc가 담당
  // Garbage Collector에 의해 일정 간격으로 메모리에서 쓸모없는 데이터 청소 (인스턴스 등)
  // 생성된 변수 (인스턴스) 메모리는 함수 종료시 사라짐
  // 1.인스턴스는 메모리에 생성된 데이터의 실체
  // 2.포인터를 이용해서 인스턴스를 가리키게 할 수 있음
  // 3.함수 호출 시 포인터 인수를 통해서 인스턴스를 입력받고, 그값을 변경할 수 있게 됨
  // 4.쓸모 없어진 인스턴스는 가비지 컬렉터가 자동으로 지워줌

  // Data 인스턴스 생성
  var data Data
  
  // p: 새로운 Data인스턴스가 생성된 것이 아닌, 기존에 있던 data 인스턴스를 가리키는 포인터 변수
  var p *Data = &data

  fmt.Printf("p.value = %d\n", p.value)
  fmt.Printf("data.value = %d\n", data.value)

  ChangeData(&data)

  // 0->999 확인
  fmt.Printf("p.value = %d\n", p.value)
  fmt.Printf("data.value = %d\n", data.value)

  // 인스턴스 하나만 생성하고 포인터 3개가 하나의 인스턴스 가리킴
  var p1 *Data = &Data{}
  var p2 *Data = p1
  var p3 *Data = p1

  // initial value
  fmt.Println(*p1)

  fmt.Printf("주솟값1 = %p\n", p1)
  fmt.Printf("주솟값2 = %p\n", p2)
  fmt.Printf("주솟값3 = %p\n", p3)

  // 포인터 초기화 방법
  // & 사용한 초기화 방법:
  //    포인터 값을 별도의 변수로 선언하지 않고 초기화 하는 방법
  // new  사용한 초기화 방법
  //    new 초기화 방법은 내부 필드값 초기화는 안됨
  //    & 사용한 초기화 방법과 동일 &Data{} == new(Data)
  //    & 사용한 초기화 방법은 내부 필드값도 초기화 가능 p1 := &Data{3,4}
  p4 := &Data{}
  ChangeData(p4)
  p5 := new(Data)
  ChangeData(p5)

  // var p6 Data
  p6 := Data{}
  ChangeData(&p6)

  fmt.Printf("주솟값4 = %p\n", p4)
  fmt.Printf("p4.value = %d\n", p4.value)
  fmt.Printf("p4.value = %d\n", p4.value)

  fmt.Printf("주솟값5 = %p\n", p5)
  fmt.Printf("p5.value = %d\n", p5.value)
  fmt.Printf("p5.value = %d\n", p5.value)

  fmt.Printf("주솟값6 = %p\n", &p6)
  fmt.Printf("p6.value = %d\n", p6.value)
  fmt.Printf("p6.value = %d\n", p6.value)
}

package main

import "fmt"

type User struct{
  Name string
  Age int
}

func NewUser(name string, age int) *User{
  var u = User{name, age}
  return &u
}

func main() {
  userPointer := NewUser("AAA", 23)
  fmt.Println(userPointer)
  fmt.Printf("userPointer: %v has an address: %p\n", userPointer, userPointer)
}

s1 := "Hello string variable!"
s2 := `Special \t characters \t\t \n inside backticks are ignored\n
  backticks also ignores new lines
  line3
  line4
  line5`

fmt.Println(s1)
fmt.Println(s2)

  // 문자 하나를 표현하는데 rune 타입 사용
  // UTF-8은 1~3바이트
  // 알파벳 문자열크기 =1, 한글 문자열 크기 = 3
  var c rune = '한'

  fmt.Printf("%T\n", c) // 타입 출력 : int32
  fmt.Println(c)        // int32(rune) 형식 값 출력
  fmt.Printf("%c\n", c) // 문자출력

  // 12 = (1*3) +  (3*3)
  a := "abc가나다"
  fmt.Println(len(a))


  // string <-> []rune 타입 변환
  //     []rune(str)
  //     string([]rune{...})
  str := "Hello World!"
  // []rune{72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100}
  runes := []rune(str)

  fmt.Println(str)
  fmt.Println(runes)
  fmt.Println(string(runes))
  fmt.Println(len(runes))

  for _,v := range runes {
    fmt.Printf("타입: %T, 값: %d, 문자열: %c\n", v,v,v)
  }

  d := []byte(c)
  e := []rune(c)
  // [65 66 67 235 172 184 236 158 144 236 151 180]
  fmt.Println(d)
  // [65 66 67 47928 51088 50676]
  fmt.Println(e)

  // []byte and []rune are immutable, contrary to string
  d[5] = 23
  fmt.Println(string(d))
  e[3] = 244
  fmt.Println(string(e))

  // strng <-> []byte 변환
  // 모든 문자열은 1바이트 배열로 변환 가능

  s1 := "Hello"
  s2 := "Hell"
  s3 := "Hello"

  fmt.Printf("%s == %s, %v\n", s1, s2, s1 == s2)
  fmt.Printf("%s == %s, %v\n", s1, s3, s1 == s3)

  str1 := "BBB"
  str2 := "aaaaAAA"
  str3 := "BBAD"
  str4 := "ZZZ"

  fmt.Printf("%s > %s, %v\n", str1, str2, str1 > str1)
  fmt.Printf("%s <= %s, %v\n", str3, str4, str3 <= str4)

import (
  "fmt"
  "unsafe"
  "reflect"
)

func main() {
  str1 := "Hello World"
  str2 := str1


  // string -> unsafe.Pointer -> *reflect.StringHeader
  stringHeader1 := (*reflect.StringHeader) (unsafe.Pointer(&str1))
  stringHeader2 := (*reflect.StringHeader) (unsafe.Pointer(&str2))
  
  // 두 값이 같음
  fmt.Println(stringHeader1)
  fmt.Println(stringHeader2)
}

func main() {
  
  var str string = "Hello World"
  str= "How are you"
  // ERROR: string is immutable
  // str[2] = 'a'

  fmt.Println(str)

  var slice []byte = []byte(str)
  slice[2] = 'a'
  fmt.Printf("%s\n", slice)

  // str = string(slice)
  // fmt.Printf("%s\n", str)
}

package main

import (
  "fmt"
  "math/rand"

  // 겹치는 패키지 이름 별칭으로 묶기
  "text/template"
  htemplate "html/template"

  // 패키지를 사용하지는 않지만 부과효과 떄문에 import 하는 경우
  "database/sql"

  // 밑줄 _을 이용해서 init() 함수 호출
  // 밑줄 _ 이용하여 unused 에러 방지
  _ "github.com/mattn/go-sqlite3"
)

type Service struct {
  db *sql.DB
}

func main() {

  template.New("foo").Parse(`Hello`)
  htemplate.New("foo").Parse(`Hello`)

  fmt.Println(rand.Int())
}

package custompkg

import "fmt"

func PrintCustom() {
  fmt.Println("This is custom package!")
}

package main

import (
  "fmt"
  "16-package/usepkg/custompkg" // 모듈 내 패키지
  "github.com/guptarohit/asciigraph" // 외부 저장소 패키지
  "github.com/tuckersGo/musthaveGo/16-package/expkg"
)

func main() {
  custompkg.PrintCustom()
  expkg.PrintSample()

  data := []float64{3,4,5,6,9,7,5,8,5,10,2,7,2,5,6}
  graph := asciigraph.Plot(data)
  fmt.Println(graph)
}

cd 16-package/ex16.2/publicpkg
cat publicpkg.go
  package publicpkg

  import "fmt"

  const (
    PI = 3.1415
    pi = 3.1415 // 외부에 공개되지 않음
  )

  var ScreenSize int = 1080 
  var screenHeight int // 외부에 공개되지 않음

  func PublicFunc() {
    const MyConst = 100 // 외부에 공개되지 않음 (대분자 변수라해도, 함수 내부에서 선언되었기 때문에 외부에 공개되지 않음)
    fmt.Println("This is a public function", MyConst)
  }

  func privateFunc() { // 외부에 공개되지 않음
    fmt.Println("This is a private function")
  }

  type MyInt int
  type myString string // 외부에 공개되지 않음

  type MyStruct struct {
    Age int
    name string // 외부에 공개되지 않음
  }

  func (m MyStruct) PublicMethod() {
    fmt.Println("This is a public method")
  }

  func (m MyStruct) privateMethod() { // 외부에 공개되지 않음
    fmt.Println("This is a private method")
  }

  type myPrivateStruct struct { // 외부에 공개되지 않음
    Age int
    name string
  }

  func (m myPrivateStruct) PrivateMethod() { // 외부에 공개되지 않음
    fmt.Println("This is a private method")
  }

package main

import (
	"bufio"
	"fmt"
	"math/rand"
	"os"
	"time"
)

func Print(o ...interface{}) {
	fmt.Println(o...)
}

func InputIntValue(stdin *bufio.Reader) (int, error) {
	var n int
	fmt.Printf("Guess number (1~100): ")
	_, err := fmt.Scanln(&n)
	if err != nil {
		stdin.ReadString('\n')
	}
	return n, err
}

// Scanln reads a small piece of input (like a number or a word) until the first Enter key press (newline).
// stdin.ReadString reads the entire line of input (including spaces) until the Enter key press (newline).
// Remember, buffered streams help manage data flow,
// and Scanln and ReadString are like different ways of listening to your friend’s answers
// —either short and quick or long and detailed!
// => stdin is more explicit about handling buffering

// Both methods involve buffering, but Scanln abstracts it away for you.
// ReadString gives you more control over the buffering process.
func main() {
	// Seed random
	rand.New(rand.NewSource(time.Now().UnixNano()))

	stdin := bufio.NewReader(os.Stdin)
	guess := rand.Intn(100) + 1
	cnt := 1

	for {
		n, err := InputIntValue(stdin)
		if err != nil {
			fmt.Println("Only numbers are allowed")
		} else {
			if n == guess {
				fmt.Printf("\nYou're correct! %d was guessed in %d attempts!\n", guess, cnt)
				break
			} else if n < guess {
				fmt.Printf("it is bigger than %d\n", n)
			} else if n > guess {
				fmt.Printf("it is smaller than %d\n", n)
			}
			cnt++
		}
	}
}

// 초기화 방법
var slice1 = []int{1,2,3} //len:3 cap: 3
var slice2 = []int{1, 5:2, 10:3} // [1 0 0 0 0 2 0 0 0 0 3]
var slice3 = make([]int, 3, 5) // len: 3 cap: 5

for i := 0; i<len(slice1); i++ {
  fmt.Print(slice1[i], " ")
}
for i,v := range slice1 {
  slice[i] = v*2
}

// Preallocate a slice with capacity 100
myData := make([]int, 0, 100)

// Append elements to myData
// ...
// No reallocation needed as long as len(myData) < 100

package main

import "fmt"

/**
Length: 1, Capacity: 1
Length: 2, Capacity: 2
Length: 3, Capacity: 4
Length: 4, Capacity: 4
Length: 5, Capacity: 8
Length: 6, Capacity: 8
Length: 7, Capacity: 8
Length: 8, Capacity: 8
Length: 9, Capacity: 16
Length: 10, Capacity: 16
*/
func main() {
    var s []int // Create an empty slice (capacity 0)
    for i := 0; i < 10; i++ {
        s = append(s, i)
        fmt.Printf("Length: %d, Capacity: %d\n", len(s), cap(s))
    }
}

type SliceHeader struct {
  Data uintptr  // 실제 배열을 가리키는 포인터
  Len int       // 요소개수
  Cap int       // 실제 배열의 길이
}

package main
import "fmt"

func main() {
  slice1 := make([]int, 3, 5)
  slice2 := append(slice1, 4, 5)
	slice3 := append(slice2, 6)

  // len() cap()
  // slice1:  [0 0 0] 3 5
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
  // slice2:  [0 0 0 4 5] 5 5
  fmt.Println("slice2: ", slice2, len(slice2), cap(slice2))
  // slice3:  [0 0 0 4 5 6] 6 10
	fmt.Println("slice3: ", slice3, len(slice3), cap(slice3))

  // 문제1: slice1변경 시 둘다 바뀜
  slice1[1] = 100
  fmt.Println("After slice1[1]=100")
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2: ", slice2, len(slice2), cap(slice2))
  fmt.Println("slice3: ", slice3, len(slice3), cap(slice3))

  // 문제2: slice1 append()하면 1,2 둘다 바뀌는데,
  // len에 따라 append 위치가 다름
  slice1 = append(slice1, 500)
  fmt.Println("After append(slice1, 500)")
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2: ", slice2, len(slice2), cap(slice2))
}

// slice1:  [0 0 0] 3 5
// slice2:  [0 0 0 4 5] 5 5
// After slice1[1]=100
// slice1:  [0 100 0] 3 5
// slice2:  [0 100 0 4 5] 5 5
// After slice1 = append(slice1, 500)
// slice1:  [0 100 0 500] 4 5
// slice2:  [0 100 0 500 5] 5 5

// cap이 다 찼을때, append() 하면
// 2배만큼 len 증가
package main
import "fmt"

func main() {
  // len=3 cap=3
  slice1 := []int{1,2,3}

  // cap=len으로 슬라이스 용량이 다 찬 상태에서
  //  append() 실행 시 cap*2만큼 용량(capacity) 증가
  //  cap: 3-> 6
  //  새로운 용량 (6)의 배열이 생성되면서,
  //  slice1과 slice2는 다른배열을 가리키게됨
  slice2 := append(slice1, 4, 5)
  fmt.Println("After slice2 := append(slice1, 4, 5) ")
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2: ", slice2, len(slice2), cap(slice2))

  slice1[1] = 100
  fmt.Println("After slice1[1] = 100")
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2: ", slice2, len(slice2), cap(slice2))

  slice1 = append(slice1, 500)
  fmt.Println("After slice1 = append(slice1, 500)")
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2: ", slice2, len(slice2), cap(slice2))
}

// After slice2 := append(slice1, 4, 5) 
// slice1:  [1 2 3] 3 3
// slice2:  [1 2 3 4 5] 5 6
// After slice1[1] = 100
// slice1:  [1 100 3] 3 3
// slice2:  [1 2 3 4 5] 5 6
// After slice1 = append(slice1, 500)
// slice1:  [1 100 3 500] 4 6
// slice2:  [1 2 3 4 5] 5 6

package main

import "fmt"

func main() {
  array := [5]int{1,2,3,4,5}
  slice := array[1:2]


  // 슬라이싱 cap길이 = 시작인덱스 ~끝인덱스 까지의 길이
  //   여기에서는 cap = 시작인덱스 1부터 끝까지 길이 = 4
  fmt.Println("After slice := array[1:2]")
  fmt.Println("array: ", array)
  fmt.Println("slice: ", slice, len(slice), cap(slice))

  array[1] = 100
  fmt.Println("After array[1] = 100")
  fmt.Println("array: ", array)
  fmt.Println("slice: ", slice, len(slice), cap(slice))

  slice = append(slice, 500)
  fmt.Println("After slice = append(slice, 500)")
  fmt.Println("array: ", array)
  fmt.Println("slice: ", slice, len(slice), cap(slice))


  // IF 슬라이스 append를 배열 길이 5이상으로 실행하면
  // array는 그대로, slice는 동적으로 크기 증가: cap*2 용량 증가 및 len 증가
}


// After slice := array[1:2]
// array:  [1 2 3 4 5]
// slice:  [2] 1 4
// After array[1] = 100
// array:  [1 100 3 4 5]
// slice:  [100] 1 4
// After slice = append(slice, 500)
// array:  [1 100 500 4 5]
// slice:  [100 500] 2 4

package main

import "fmt"

func main() {
  slice1 := []int{1,2,3,4,5}
  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))

  // 중간
  slice2 := slice1[1:3]
  fmt.Println("slice1[1:3]: ", slice2, len(slice2), cap(slice2))

  // 처음부터 i까지
  slice3 := slice1[:3]
  fmt.Println("slice1[:3]: ", slice3, len(slice3), cap(slice3))

  // i부터 끝까지
  slice4 := slice1[1:]
  fmt.Println("slice1[1:]: ", slice4, len(slice4), cap(slice4))

  // 전체
  slice5 := slice1[:]
  fmt.Println("slice1[:]", slice5, len(slice5), cap(slice5))
}
// slice1:  [1 2 3 4 5] 5 5
// slice1[1:3]:  [2 3] 2 4
// slice1[:3]:  [1 2 3] 3 5
// slice1[1:]:  [2 3 4 5] 4 4
// slice1[:] [1 2 3 4 5] 5 5

package main
import "fmt"

func main() {
  slice1 := []int{1,2,3,4,5}

  // 복제
  slice2 := make([]int, len(slice1))
  for i,v := range slice1 {
    slice2[i] = v
  }
  fmt.Println("After slice1-> slice2 복제(for문)")
  fmt.Println("slice1", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2", slice2, len(slice2), cap(slice2))

  // slice1,2는 서로 다른 배열 가리키므로 slice1의 배열만 반영
  slice1[1] = 100
  fmt.Println("After slice1[1] = 100")
  fmt.Println("slice1", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2", slice2, len(slice2), cap(slice2))
}

// After slice1-> slice2 복제(for문)
// slice1 [1 2 3 4 5] 5 5
// slice2 [1 2 3 4 5] 5 5
// After slice1[1] = 100
// slice1 [1 100 3 4 5] 5 5
// slice2 [1 2 3 4 5] 5 5

package main
import "fmt"

func main() {
  slice1 := []int{1,2,3,4,5}
  slice2 := append([]int{}, slice1...)
  fmt.Println("After slice2 := append([]int{}, slice1...)")
  fmt.Println("slice1", slice1, len(slice1), cap(slice1))
  fmt.Println("slice2", slice2, len(slice2), cap(slice2))
}

package main
import "fmt"

func main() {
  slice1 := []int{1,2,3,4,5}
  slice2 := make([]int, 3, 10) // len:3, cap:10
  slice3 := make([]int, 10) // len:10, cap:10

  // 3개만 복사됨
  cnt1 := copy(slice2, slice1)
  // 5개 복사됨
  cnt2 := copy(slice3, slice1)

  fmt.Println("slice2: ", cnt1, slice2)
  fmt.Println("slice3: ", cnt2, slice3)


  // 같은 cap, len으로 복제하려면:
  // for문으로 실행 하거나
  // copy이용
  slice2 = make([]int, len(slice1))
  copy(slice2, slice1)
  fmt.Println("slice2: ", slice2)
}

// slice2:  3 [1 2 3]
// slice3:  5 [1 2 3 4 5 0 0 0 0 0]

package main
import "fmt"

func main() {
  slice1 := []int{1,2,3,4,5}
  del := 2

  for i:=del; i<len(slice1)-1; i++ {
    slice1[i] = slice1[i+1]
  }
  slice1 = slice1[:len(slice1)-1]

  fmt.Printf("After slice1[%d] is deleted: %v  %d %d\n", del, slice1, len(slice1), cap(slice1))

package main
import "fmt"

func main() {
  slice1 := []int{1,2,3,4,5}
  del := 2
  
  slice1 = append(slice1[:del], slice1[del+1:]...)

  fmt.Println("slice1: ", slice1, len(slice1), cap(slice1))
}

package main
import "fmt"
func main() {
  slice1 := []int{1,2,3,4,5}
  add := 2
  slice1 = append(slice1, 0)


  for i:= len(slice1)-1 ; i > add; i-- {
    slice1[i] = slice1[i-1]
  }
  slice1[add] = 100
  slice1 = slice1[:len(slice1)]

  // slice1 [1 2 100 3 4 5] 6 10
  fmt.Println("slice1", slice1, len(slice1), cap(slice1))
}

package main
import "fmt"
func main() {
  slice1 := []int{1,2,3,4,5}
  add := 2
  slice1 = append(slice1[:add], append([]int{100}, slice1[add:]...)...)

  // slice1 [1 2 100 3 4 5] 6 10
  fmt.Println("slice1", slice1, len(slice1), cap(slice1))
}

package main
import (
  "fmt"
  "sort"
)
func main() {
  slice := []int{5, 1, 2, 3, 4}

  sort.Ints(slice)
  fmt.Println(slice)
}

package main
import (
  "fmt"
  "sort"
)

type Student struct {
  Name string
  Age int
}

type Students []Student

func (s Students) Len() int {
  return len(s)
}

func (s Students) Less(i, j int) bool {
  return s[i].Age < s[j].Age
}

func (s Students) Swap(i, j int) {
  s[i], s[j] = s[j], s[i]
}

// 구조체 정렬 시 필요한 정의 메소드
// Len(), Less(), Swap()
func main() {
  // 슬라이스안에 {"A", 1} 선언시
  // 구조체 type 명 생략
  slice := []Student {
    {"B", 2},
    {"C", 9},
    {"A", 1},
    {"D", 5},
  }

  sort.Sort(Students(slice))
  fmt.Println(slice)
}

package main
import "fmt"

type account struct {
  balance int
}

func withdrawFunc(a* account, amount int) { // 일반함수 표현
  a.balance -= amount
}

func (a *account) withdrawMethod(amount int) { // 메소드 표현
  a.balance -= amount
}

func main() {
  a := &account{100}

  withdrawFunc(a, 30)
  a.withdrawMethod(30)

  fmt.Printf("%d \n", a.balance)
}

package main
import "fmt"

// 사용자 정의 별칭 타입
type myInt int

func (a myInt) add(b int) int {
  return int(a) + b
}

func main() {
  var a myInt = 10 // myInt타입변수
  res := a.add(30)
  fmt.Println("myInt + 30 = ", res)

  var b int = 20
  myInt(b)
}

type Student struct {
  FirstName string
  LastName string
  Age int
}

// Student 구조체에 속하는 메소드들
func (s *Student) EnrollClass(c *Subject) {
  // ...
}

func (s *Student) SendReport(p *Professor, r *Report) {
  // ...
}

package main
import "fmt"

type account struct {
  balance int
  firstName string
  lastName string
}

// 1. 포인터타입 메소드
func (a1 *account) withdrawPointer(amount int) {
  a1.balance -= amount
}

// 2. 값타입 메소드
func (a2 account) withdrawValue(amount int) {
  a2.balance -= amount
}

// 3. 변경된 값을 반환하는 값 타입 메소드
//  값타입 메소드를 보완하지만, 메모리의 복사가 여러번 일어나 메모리 비효율적
func (a3 account) withdrawReturnValue(amount int) account {
  a3.balance -= amount
  return a3
}

func main() {
  var mainA *account = &account{100, "Joe", "Park"}

  mainA.withdrawPointer(30)
  fmt.Println(mainA)

  // 고언어에서는 (*mainA).withdrawValue(30) 와 같음
  // 복사가 일어나므로 mainA에 변경값 반영안됨
  mainA.withdrawValue(30)
  fmt.Println(mainA)

  mainB := mainA.withdrawReturnValue(30)
  fmt.Println(mainB)
}

package main

import "fmt"

type Stringer interface {
	String() string
}

type Student struct {
	Name string
	Age  int
}

func (s *Student) String() string {
	return fmt.Sprintf("안녕, 나는 %d살, %s라고 해", s.Age, s.Name)
}

func main() {
	student := &Student{"Jake", 9}
  // 인터페이스를 이용하면 메서드 구현을 포함한 구체적인 객체(concrete object)가 아닌,
  // 추상화된 객체(e.g. stringer 변수)로 상호작용 할 수 있습니다.
  // Student타입 객체는 String()메서드를 포함하기 때문에,
  // stringer에 student를 대입 할 수 있다. (abstract away)
	var stringer Stringer // 인터페이스의 기본값은 nil (e.g. stringer == nil)
  stringer = student

	fmt.Printf("%s\n", stringer.String())
}

// github.com/tuckersGo/musthaveGo/ch20/fedex
package fedex
import "fmt"

type FedexSender struct {
}

func (f *FedexSender) Send(parcel string) {
  fmt.Printf("Fedex에서 %s를 보냅니다.\n", parcel)
}

// github.com/tuckersGo/musthaveGo/ch20/koreaPost
package koreaPost
import "fmt"

type PostSender struct{
}

func (p *PostSender) Send(parcel string) {
  fmt.Printf("Post우편에서 %s를 보냅니다.\n", parcel)
}

package main

import (
  "fmt"
  "github.com/tuckersGo/musthaveGo/ch20/fedex"
  "github.com/tuckersGo/musthaveGo/ch20/koreaPost"
)

func SendFedexParcel(parcel string, f *fedex.FedexSender) {
  f.Send(parcel)
}

func SendKoreaPostParcel(parcel string, p *koreaPost.PostSender) {
  p.Send(parcel)
}

func main() {
  f := &fedex.FedexSender{}
  p := &koreaPost.PostSender{}

  // f.Send("fedex parcel")
  // p.Send("koreaPost parcel")
  SendFedexParcel("fedex parcel", f)
  SendKoreaPostParcel("koreaPost parcel", p)
}

package main
import (
  "fmt"
  "github.com/tuckersGo/musthaveGo/ch20/fedex"
  "github.com/tuckersGo/musthaveGo/ch20/koreaPost"
)

type Sender interface {
  Send(parcel string)
}

// In Go, interfaces are already reference types.
// When you pass an interface as an argument, you’re effectively passing a reference\
// to the underlying concrete type that implements the interface.
// Even if you pass an interface by value (without a pointer),
// it behaves like a reference because it points to the actual implementation.
func SendBook(parcel string, sender Sender) {
  sender.Send(parcel)
}

func main() {
  f := &fedex.FedexSender{}
  p := &koreaPost.PostSender{}

  SendBook("fedex소포", f)
  SendBook("koreaPost소포", p)
}


- 덕타이핑
  - FedexSender, PostSender에 implements Sender라는 명시를 하지 않아도
  - Sender인터페이스 의 Send() 메소드만 정의했다면 자동으로 duckTyping 됨

- 서비스 사용자 중심 코딩
  - Sender 인터페이스를 서비스 제공자인 Fedex나 Post가 아닌 패키지를 이용하는 쪽에서 만듦
  - 덕타이핑에서는 인터페이스 구현 여부를 타입선언에서 하는게 아니라, 인터페이스가
  - 사용될 때, 해당 타입이 인터페이스에 정의된 메서드를 포함했는지 여부로 결정
  - 서비스 제공자가 인터페이스를 정의할 필요없이, 구체적인 객체만 제공하고,
  - 서비스 이용자가 필요에 따라 그때그떄 인터페이스를 정의해서 사용할 수 있음

// A회사: B,C회사의 제품 성능 비교하고자 함
//    A회사가 직접 Database 인터페이스 정의하여
//    TotalTime 함수 사용하도록 구현
// 구조체 BDatabase, CDatabase가 달라서
// 한 함수의 인수로 쓸수 없기때문에, Database 인터페이스 정의
//    Database 인터페이스를 매개변수로 사용 (reference to address)
//    (In Go, interfaces are already reference types!)
func TotalTime(db Database) int {
  db.Get()
  db.Set()
  return ?
}

func Compare() {
  BDB := &BDatabase{}
  CDB := &CDatabase{}

  if TotalTime(BDB) < TotalTime(CDB) {
    fmt.Println("B회사 제품이 더 빠름")
  } else {
    fmt.Println("C회사 제품이 더 빠름")
  }
}

// 덕타이핑을 지원하지 않는다면
//    B 인터페이스 정의, C 인터페이스 정의하여
//    고객에게 알려줘야하는 불편함
//    또한, C에게 B인터페이스를 지원하도록 요청 해야함
//  덕타이핑을 활용하면, 인터페이스 지원여부를 사용하는 쪽에서 판단

package main

type Reader interface {
  Read()(n int, err error)
  Close() error
}

type Writer interface {
  Write()(n int, err error)
  Close() error
}

type ReadWriter interface {
  Reader
  Writer
}
// 1 Read() Write() Close() 포함 타입
//    => Reader, Writer, ReadWriter 모두 사용가능
// 2 Read() Close() 포함 타입
//    => Reader만 사용 가능
// 3 Write Close() 포함 타입
//    => Writer만 사용 가능
// 4 Read() Write() 포함 타입
//    => Close()없기 떄문에 3개 interface 모두 사용 불가능

package main
import "fmt"


type Student struct{
  Age int
}

func PrintVal(v interface{}) {

  switch t:= v.(type) {
    case int:
      fmt.Printf("v is int %d\n", int(t))
    case float64:
      fmt.Printf("v is float64 %f\n", float64(t))
    case string:
      fmt.Printf("v is string %s\n", string(t))
    case []int:
      fmt.Printf("v is []int Slice %T:%v", t, t)
    case [5]int:
      fmt.Printf("v is [5]int Array %T:%v", t, t)
    default:
      fmt.Printf("Not supported type %T:%v\n", t, t)
  }
}

func main() {
  PrintVal(10)
  PrintVal(3.14)
  PrintVal("Hello")
  PrintVal(Student{15})

  arr := [5]int{1,2,3,4,5}
  slice := arr[2:]
  PrintVal(arr)
  PrintVal(slice)
}

package main

type Attacker interface {
  Attack()
}

func main() {
  var att Attacker // 인터페이스 기본값은 nil입니다.
  att.Attack()     // att가 nil이기 때문에 런타임 에러가 발생합니다.
}

var a Interface
t := a.(ConcreteType)

package main
import "fmt"

type Stringer interface {
  String() string
}

// Student 구조체가  Stringer 인터페이스 구현
//    String()메소드 정의되어 있기 때문
type Student struct {
  Age int
}

func (s *Student) String() string {
  return fmt.Sprintf("학생 나이는: %d\n", s.Age)
}

// 인터페이스 -> 구현체 타입으로 변환
// Stringer -> *Student
func PrintAge(stringer Stringer) {
  // 특정 구현체 타입으로 변환
  // PrintAge의 매개변수로 어떤 타입이 들어온지 알수 없기 때문에 
  s := stringer.(*Student)
  fmt.Printf("Age: %d\n", s.Age)
  // fmt.Println(stringer.String())
}

func main() {
  s := &Student{100}
  PrintAge(s)
}

type Stringer interface {
  String() string
}

type Student struct {
}

func main() {
  var Stringer stringer
  stringer.(*Student) // 컴파일 에러
}

package main
import "fmt"

type Stringer interface {
  String() string
}

type Student struct {
}

func (s *Student) String() string {
  return "Student"
}

type Actor struct {
}

func (a *Actor) String() string {
  return "Actor"
}

func ConvertType(stringer Stringer) {
  student := stringer.(*Student)
  fmt.Println(student)
}

func main() {
  actor := &Actor{}

  // 런타임 에러:
  // Actor -> Student 타입 에러!!!
  //  panic: interface conversion: main.Stringer is *main.Actor, not *main.Student
  ConvertType(actor)
}

var AInterface = ConcreteType{}
b := a.(BInterface)

package main
import "fmt"

type Reader interface {
  Read()
}

type Closer interface {
  Close()
}

type File struct {
}

func (*f File) Read() {
}

func ReadFile(reader Reader) {
  c := reader.(Closer)
  // ERROR! 발생!
  // reader 인터페이스변수는 File타입을 가리키고 있고,
  // File 타입은 Close() 메서드를 포함하고 있지 않기 때문에 에러발생
  c.Close()
}

func main() {
  file := &File{}

  // ERROR!
  ReadFile(file)
}

package main
import (
  "fmt"
  "os"
)

type Reader interface {
  Read()
}

type Closer interface {
  Close()
}

type File struct {
}

func (f *File) Read() {
}

func ReadFile(reader Reader {
  if c, ok := reader.(Closer); ok {
    c.Close()
  }
}

func main() {
  f := &File{}
  ReadFile(f)
}

package main
import "fmt"

func sum(nums ...int) int {
  sum := 0

  fmt.Printf("nums 타입: %T\n", nums)
  for _,v := range nums {
    sum += v
  }
  return sum
}

func PrintT(args ...interface{}) {
  for _,arg := range args {
    switch f := arg.(type) {
      case int:
        val := arg.(int)
        fmt.Println(val, int(f))
        fmt.Println(val == int(f))
        // Print로직
      case float64:
        val := arg.(float64)
        fmt.Println(val == float64(f))
      case string:
        val := arg.(string)
        fmt.Println(val == string(f))
    }
  }
}

func main() {
  fmt.Println(sum(1,2,3,4,5))
  fmt.Println(sum(10,20))
  fmt.Println(sum())

  PrintT(1,3.14, "abc")

}

package main

import (
	"fmt"
	"os"
)

// 1->2->3->4
// 파일에 Hello World를 씁니다.
// 파일을 닫았습니다.
// 반드시 호출됩니다.
func main() {
	f, err := os.Create("test.txt") // 파일 생성
	if err != nil {
		fmt.Println("Failed to create a file")
		return
	}
	defer fmt.Println("반드시 호출됩니다.") // 4
	defer f.Close() // 3
	defer fmt.Println("파일을 닫았습니다.") // 2

	fmt.Println("파일에 Hello World를 씁니다.") //1
	fmt.Fprintln(f, "Hello, World!") // 파일에 텍스트를 씁니다.
}

package main

import "fmt"

func add(a, b int) int {
  return a + b
}

func mul(a, b int) int {
  return a * b
}

type opFunc func(int, int) int

func getOperator(op string) opFunc {
  if op == "+" {
    return add
  } else if op == "*" {
    return mul
  } else {
    return nil
  }
}

func main() {
  // var opFnc func(int,int) int = getOperator("*")
  opFnc := getOperator("*")

  res := opFnc(2, 9)
  fmt.Println("2*9 = ", res)
}

package main
import "fmt"

func getOperator(operator string) func(int, int) int {
  if operator == "*" {
    return func(a, b int) int {
      return a * b
    }
  } else if operator == "+" {
    return func(a, b int) int {
      return a + b
    }
  } else {
    return nil
  }
}

func main() {
  fn := getOperator("*")
  a, b := 3,4
  fmt.Printf("%d x %d = %d\n", a,b, fn(a,b))
}

package main
import "fmt"
func main() {
  i := 0

  // 함수
  f := func() {
    i += 10
  }

  i++
  f()
  fmt.Println(i)
}

package main
import "fmt"

func CaptureLoop() {
  // make slice of functions with length 3
  f := make([]func(), 3)
  fmt.Println("CaptureLoop")

  // i 가 복사되는것이 아닌 참조되기 떄문에
  for i :=0; i< len(f); i++ {
    f[i] = func() {
      // 캡쳐할 떄 캡쳐하는 순간의 i값(1,2,3)이
      // 복제 되는 것이 아니라, 변수가 참조로 캡쳐되므로
      // i가 최종적으로 3이 되었을떄
      // i를 참조하는 f[0], f[1], f[2]는 모두 i=3를 참조하게 됨
      fmt.Println(i)
    }
  }

  for i :=0; i< len(f); i++ {
    f[i]()
  }
}


func CaptureLoop2() {
  // make slice of functions with length 3
  f := make([]func(), 3)
  fmt.Println("CaptureLoop2")

  // i 가 복사되는것이 아닌 참조되기 떄문에
  for i :=0; i< len(f); i++ {
    v := i
    f[i] = func() {
      // 캡쳐할 떄 캡쳐하는 순간의 i값(1,2,3)이
      // 복제 되는 것이 아니라, 변수가 참조로 캡쳐되므로
      // i가 최종적으로 3이 되었을떄
      // i를 참조하는 f[0], f[1], f[2]는 모두 i=3를 참조하게 됨
      fmt.Println(v)
    }
  }

  for i :=0; i< len(f); i++ {
    f[i]()
  }
}

func main() {
  // 3 3 3
  CaptureLoop()
  // 1 2 3
  CaptureLoop2()
}

package main
import (
  "os"
  "fmt"
)

type Writer func(string)

func writeHello(writer Writer) {
  writer("Hello World")
}

func main() {
  f, err := os.Create("test.txt")
  if err != nil {
    fmt.Println("Failed to create a file")
    return
  }

  defer f.Close()

  writeHello(func (msg string) {
    // 함수리터럴 외부 변수 f사용
    fmt.Fprintf(f, msg)
  })
}

type Element struct {
  Value interface{}
  Next *Element
  Prev *Element
}

// Element
func (e *Element) Next() *Element
func (e *Element) Prev() *Element

// List
// Package list implements a doubly linked list.
func New() *List
func (l *List) Back() *Element
func (l *List) Front() *Element
func (l *List) Init() *List
func (l *List) InsertAfter(v any, mark *Element) *Element
func (l *List) InsertBefore(v any, mark *Element) *Element
func (l *List) Len() int
func (l *List) MoveAfter(e, mark *Element)
func (l *List) MoveBefore(e, mark *Element)
func (l *List) MoveToBack(e *Element)
func (l *List) MoveToFront(e *Element)
func (l *List) PushBack(v any) *Element
func (l *List) PushBackList(other *List)
func (l *List) PushFront(v any) *Element
func (l *List) PushFrontList(other *List)
func (l *List) Remove(e *Element) any