GO·NOTE

package main

import "fmt"

func main() {
	array := []int{80, 60, 20, 10, 1}
	fmt.Println(array[:4])
	fmt.Println(InsertData(array, 2))
}

func InsertData(array []int, num int) []int {
	for i := 0; i < len(array); i++ {
		if num > array[i] {
			arrayTmp := make([]int, len(array))
			copy(arrayTmp, array)
			array = append(append(arrayTmp[:i], num), array[i:]...)
			break
		}
		if i == len(array)-1 {
			array = append(array, num)
		}
	}
	return array
}

package main

import "fmt"

func main() {

	m := map[string]bool{"a": true, "b": false}
	for k := range m {
		fmt.Println(k)
	}

	for k, v := range m {
		fmt.Println(k, v)
	}

}

//a
//b
//a true
//b false

package main

import (
	"fmt"
	"math/big"
	"strconv"
)

func main() {
	x := 2.1
	y := 0.8
	fmt.Println(x+y)
	fmt.Println(float64Add(x,y))
}

func float64Add(x float64, y float64, more ...float64) float64 {
	floatX := new(big.Float).SetFloat64(x)
	floatY := new(big.Float).SetFloat64(y)
	result := new(big.Float).Add(floatX, floatY)
	if len(more) > 0 {
		for _, m := range more {
			floatM := new(big.Float).SetFloat64(m)
			result = new(big.Float).Add(result, floatM)
		}
	}
	f, _ := strconv.ParseFloat(result.String(), 64) // 忽略 error
	return f
}

package main

import (
	"encoding/json"
	"fmt"
	"github.com/intel-go/fastjson"
)

type BpResponse struct {
	User resUser `json:"user"`
}

type resUser struct {
	Uid            string              `json:"uid"`
	Name           string              `json:"name"`
	SocialAccounts []map[string]string `json:"social_accounts"`
}

func main() {

	resp := `{
    "user":{
        "name":"",
        "phone":{
            "phone_number":""
        },
        "social_accounts":[
            {
                "access_token":"sxXxxxxxxxxxxxxxxxxxxxx-sdfsfsf-",
                "expiration_date":1596509376000,
                "id":"oydXy061Ux9aeYRJg1LUJoOP4kYQ",
                "openid":"orabwwjJaGHi-ShsuqX4Pxk3Uz9Q",
                "platform":"wechat"
            }
        ],
        "uid":"UUASRHAHJ5PH3"
    }
}`

	bpR := &BpResponse{}
	fmt.Println(fastjson.Unmarshal([]byte(resp), bpR))
	fmt.Println(bpR)

	fmt.Println(json.Unmarshal([]byte(resp), bpR))
	fmt.Println(bpR)

}

//json: cannot unmarshal number into Go value of type string
//&{{  [map[access_token:xxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxx-bt0ZXUq1eqOb23cM6A5q7MjJgOXaxAbyKFUn847xVnRoQlp3IQJ7_s67rMTp93oY]]}}
//
//json: cannot unmarshal number into Go struct field resUser.user.social_accounts of type string
//&{{UUASRHAHJ5PH3  [map[access_token:35_Dnloy3E9cbRM76y9IX_2tyLeaVtHTTJa-bt0ZXUq1eqOb23cM6A5q7MjJXXXXXXXXXXXXXXXXXXJ7_s67rMTp93oY expiration_date: id:oydXy061Ux9aeXXXXXXXXXXXXXXOP4kYQ openid:orabwwjJaGxxxxxxxxxxxxxxxxX4Pxk3Uz9Q platform:wechat]]}}

package main

import (
	"context"
	"fmt"

	"github.com/olivere/elastic/v7"
)

var client *elastic.Client


func init()  {
	var err error
	client, err = elastic.NewClient(elastic.SetURL("http://xmge.top:9200/"),elastic.SetSniff(false))
	if err != nil {
		panic(err)
	}
	fmt.Println("connect to es success")
}


type Person struct {
	Id int `json:"id"`
	Name    string `json:"name"`
	Age     int    `json:"age"`
	Married bool   `json:"married"`
	CompanyId int `json:"company_id"`
}

type Company struct {
	Id int `json:"id"`
	Name string `json:"name"`
	Location string `json:"location"`
}

func main() {
	persons := []Person{
		{1, "小明", 30, true,1},
		{2, "小白", 30, true,1},
		{3, "小黑", 28, true,2},
		{4, "小红", 27, true,3},
		{5, "小蓝", 26, true,3},
	}
	insertPersons("users",persons...)

	companys := []Company{
		{1, "A公司", "西二旗"},
		{2, "B公司", "上地"},
		{3, "C公司", "望京"},
	}
	insertCompany("company",companys...)
}


func insertPersons(index string,items ...Person) {
	for _, item := range items {
		put1,err :=client.Index().Index(index).BodyJson(item).Do(context.Background())
		if err != nil {
			panic(err)
		}
		fmt.Printf("Indexed %s %s to index %s, type %s\n", index,put1.Id, put1.Index, put1.Type)
	}
}

func insertCompany(index string,items ...Company) {
	for _, item := range items {
		put1,err :=client.Index().Index(index).BodyJson(item).Do(context.Background())
		if err != nil {
			panic(err)
		}
		fmt.Printf("Indexed %s %s to index %s, type %s\n", index,put1.Id, put1.Index, put1.Type)
	}
}

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	address := "xmge.top"
	conn, err := net.Dial("ip:icmp", "xmge.top")
	if err != nil {
		log.Fatal(err)
	}
	add := conn.RemoteAddr()
	fmt.Printf("%s's ip is %s:", address, add.String())
}

package main

import (
	"fmt"
	"net"
)

func main() {
	//查找DNS A记录
	iprecords, _ := net.LookupIP("xmge.top")
	for _, ip := range iprecords {
		fmt.Println(ip)
	}
	//查找DNS CNAME记录
	canme, _ := net.LookupCNAME("www.baidu.com")
	fmt.Println(canme)
	//查找DNS PTR记录
	ptr, e := net.LookupAddr("118.24.10.218")
	if e != nil {
		fmt.Println(e)
	}
	for _, ptrval := range ptr {
		fmt.Println(ptrval)
	}
	//查找DNS NS记录
	nameserver, _ := net.LookupNS("baidu.com")
	for _, ns := range nameserver {
		fmt.Println("ns记录", ns)
	}
	//查找DNS MX记录
	mxrecods, _ := net.LookupMX("google.com")
	for _, mx := range mxrecods {
		fmt.Println("mx:", mx)
	}
	//查找DNS TXT记录
	txtrecords, _ := net.LookupTXT("baidu.com")

	for _, txt := range txtrecords {
		fmt.Println("txt:", txt)
	}
}

func ExampleHasPrefix() {
	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("Go")))
	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("C")))
	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("")))
	// Output:
	// true
	// false
	// true
}

func TestNonpollableDeadline(t *testing.T) {
	// On BSD systems regular files seem to be pollable,
	// so just run this test on Linux.
	if runtime.GOOS != "linux" {
		t.Skipf("skipping on %s", runtime.GOOS)
	}

	f, err := ioutil.TempFile("", "ostest")
	if err != nil {
		t.Fatal(err)
	}
	defer os.Remove(f.Name())
	defer f.Close()
	deadline := time.Now().Add(10 * time.Second)
	if err := f.SetDeadline(deadline); err != os.ErrNoDeadline {
		t.Errorf("SetDeadline on file returned %v, wanted %v", err, os.ErrNoDeadline)
	}
	if err := f.SetReadDeadline(deadline); err != os.ErrNoDeadline {
		t.Errorf("SetReadDeadline on file returned %v, wanted %v", err, os.ErrNoDeadline)
	}
	if err := f.SetWriteDeadline(deadline); err != os.ErrNoDeadline {
		t.Errorf("SetWriteDeadline on file returned %v, wanted %v", err, os.ErrNoDeadline)
	}
}

// TestRacyRead tests that it is safe to mutate the input Read buffer
// immediately after cancellation has occurred.
func TestRacyRead(t *testing.T) {
	t.Parallel()

	r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	defer w.Close()

	var wg sync.WaitGroup
	defer wg.Wait()

	go io.Copy(w, rand.New(rand.NewSource(0)))

	r.SetReadDeadline(time.Now().Add(time.Millisecond))
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			b1 := make([]byte, 1024)
			b2 := make([]byte, 1024)
			for j := 0; j < 100; j++ {
				_, err := r.Read(b1)
				copy(b1, b2) // Mutate b1 to trigger potential race
				if err != nil {
					if !os.IsTimeout(err) {
						t.Error(err)
					}
					r.SetReadDeadline(time.Now().Add(time.Millisecond))
				}
			}
		}()
	}
}

package main

import (
	"fmt"
	"log"
	"net/http"
	_ "net/http/pprof"
	"time"
)

// goroutine 阻塞时的排查方法
// 项目中首先要引进 pprof
// 通过访问 host/debug/pprof/goroutine?debug=1 即可查看出哪里的 goroutine 阻塞了
// 通过访问 host/debug/pprof/goroutine?debug=2 可以更详细的查看每个 goroutine 的信息

var c = make(chan int)

func main() {

	// 模拟 goroutine 阻塞
	go func() {
		for range time.Tick(time.Microsecond*100){
			c <- time.Now().Second()
		}
	}()

	for i := 0; i < 100; i++ {
		go func() {
			for {
				fmt.Println(<-c)
			}
		}()
	}

	// 多次访问 /ping 模拟阻塞的 goroutine
	http.HandleFunc("/ping", func(writer http.ResponseWriter, request *http.Request) {
		select {}
	})

	log.Fatal(http.ListenAndServe(":8080",nil))
}