time.Now().Format("2006-01-02 15:04:05")

/*
--------------- + ------------ +
Type            | Placeholder  |
--------------- + ------------ +
Year            | 2006         |
Year            | 06           |
Month           | 01           |
Month           | 1            |
Month           | Jan          |
Month           | January      |
Day             | 02           |
Day             | 2            |
Week day        | Mon          |
Week day        | Monday       |
Hours           | 03           |
Hours           | 3            |
Hours           | 15           |
Minutes         | 04           |
Minutes         | 4            |
Seconds         | 05           |
Seconds         | 5            |
AM or PM        | PM           |
Milliseconds    | .000         |
Microseconds    | .000000      |
Nanoseconds     | .000000000   |
Timezone offset | -0700        |
Timezone offset | -07:00       |
Timezone offset | Z0700        |
Timezone offset | Z07:00       |
Timezone        | MST          |
--------------- + ------------ +
*/

// 字符串转数字
str := "123"
num, _ := strconv.Atoi(str)

// 字符串 <=> 字节数组
[]byte(str)
string([]byte{101, 102})

// 布尔值转字符串
strconv.FormatBool(true)

// 整数转字符串
// 第二个参数表示要转换成的进制数，比如2表示转换成二进制后再转成字符串
strconv.FormatInt(123, 10)

// 浮点数转字符串
strconv.FormatFloat(4.01, 'g', -1, 64)

// 各种数字转换
int(123)
uint(123)
uint64(123)
// ...

// 比如现在要将两个 Int 数组合并，想到可以用 **append()** 内置函数
arr1 := []int{1, 2}
arr2 := []int{3, 4}

// 下面这样是做事错误的，因为第二个参数的类型必须是 arr1 数组的元素类型，即 int，解决方式就是使用 ... 操作符
// arr := append(arr1, arr2)

// 正确做法
arr := append(arr1, arr2...)

source := rand.NewSource(time.Now().UnixNano())
	r := rand.New(source)

bs, err := ioutil.ReadFile(fileName)

	if err != nil {
		// Option #1 - log the error and return a call to newDeck()
		// Option #1 - Log the error and entirely quit the program
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	s := strings.Split(string(bs), ",")

//https://github.com/liamg/tml

package main

import "github.com/liamg/tml"

func main() {
    tml.Printf("<red>this text is <bold>red</bold></red> and the following is <green>%s</green>\n", "not red")
}


/*
#!/bin/bash

echo "<red>this text is <bold>red</bold></red> and the following is <green>not red</green>" | tml
*/

package util

import "net"

func IsPublicIP(ip string) bool {
	var IP net.IP
	IP = net.ParseIP(ip)
	if IP.IsLoopback() || IP.IsLinkLocalMulticast() || IP.IsLinkLocalUnicast() {
		return false
	}

	if ip4 := IP.To4(); ip4 != nil {
		switch true {
		case ip4[0] == 10:
			return false
		case ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31:
			return false
		case ip4[0] == 192 && ip4[1] == 168:
			return false
		default:
			return true
		}
	}

	return false
}

// panic_recover.go
package main

import (
	"fmt"
)

func badCall() {
	panic("bad end")
}

func test() {
	defer func() {
		if e := recover(); e != nil {
			fmt.Printf("Panicing %s\r\n", e)
		}
	}()
	badCall()
	fmt.Printf("After bad call\r\n") // <-- wordt niet bereikt
}

func main() {
	fmt.Printf("Calling test\r\n")
	test()
	fmt.Printf("Test completed\r\n")
}

package main

import "fmt"

type Car interface {
	drive()
	buy()
}

type Jeep struct {
}

func (jeep Jeep) drive() {
	fmt.Println("Jeep drive")
}

func (jeep Jeep) buy() {
	fmt.Println("Jeep buy")
}
func main() {
	var car Car
	car = new(Jeep)
	fmt.Println(car)
	if sv, ok := car.(*Jeep); ok {
		fmt.Printf("v implements String(): %v\n", sv) // note: sv, not v
		fmt.Println(ok)
		car.drive()
	}
}

import  "sync"

type Info struct {
	mu sync.Mutex
	// ... other fields, e.g.: Str string
}

func Update(info *Info) {
	info.mu.Lock()
    // critical section:
    info.Str = // new value
    // end critical section
    info.mu.Unlock()
}