func main() {
	var str0 = "12345678901234567890"
	str1 := str0[:10]
}

func main() {
	var str0 = "12345678901234567890"
	str1 := string([]byte(str0[:10]))
}

func main() {
	var str0 = "12345678901234567890"
	str1 := (" " + str0[:10])[1:]
}

func main() {
	var str0 = "12345678901234567890"
	var builder strings.Builder
	builder.Grow(10)
	builder.WriteString(str0[:10])
	str1 := builder.String()
}

func main() {
	var str0 = "12345678901234567890"
	str1 := strings.Repeat(str0[:10], 1)
}

func main() {
	var s0 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	s1 := s0[:5]
}

func main() {
	var s0 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	s1 := append(s0[:0:0], s0[:5]...)
}

// The append built-in function appends elements to the end of a slice. If
// it has sufficient capacity, the destination is resliced to accommodate the
// new elements. If it does not, a new underlying array will be allocated.
// Append returns the updated slice. It is therefore necessary to store the
// result of append, often in the variable holding the slice itself:
//	slice = append(slice, elem1, elem2)
//	slice = append(slice, anotherSlice...)
// As a special case, it is legal to append a string to a byte slice, like this:
//	slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type

func main() {
	var s0 = []*int{new(int), new(int), new(int), new(int), new(int)}
	s1 := s0[1:3]
}

func main() {
	var s0 = []*int{new(int), new(int), new(int), new(int), new(int)}
	s0[0], s0[3], s0[4] = nil, nil, nil
	s1 := s0[1:3]
}

func main() {
	var arrayA = [3]int{1, 2, 3}
	var arrayB = [3]int{}
	arrayB = arrayA
	fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
	fmt.Printf("arrayB address: %p, arrayB value: %+v\n", &arrayB, arrayB)
	array(arrayA)
}
 
func array(array [3]int) {
	fmt.Printf("array address: %p, array value: %+v\n", &array, array)
}

func main() {
	var arrayA = [3]int{1, 2, 3}
	var arrayB = &arrayA
	fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
	fmt.Printf("arrayB address: %p, arrayB value: %+v\n", arrayB, *arrayB)
	arrayP(&arrayA)
}
 
func arrayP(array *[3]int) {
	fmt.Printf("array address: %p, array value: %+v\n", array, *array)
}

func main() {
	var arrayA = [3]int{1, 2, 3}
	var arrayB = arrayA[:]
	fmt.Printf("arrayA address: %p, arrayA value: %+v\n", &arrayA, arrayA)
	fmt.Printf("arrayB address: %p, arrayB value: %+v\n", &arrayB, arrayB)
	arrayS(arrayB)
}
 
func arrayS(array []int) {
	fmt.Printf("array address: %p, array value: %+v\n", &array, array)
}

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

func main() {
	ticker := time.NewTicker(time.Second * 1)
	for {
		<-ticker.C
		ch := make(chan int)
		go func() {
			for i := 0; i < 100; i++ {
				ch <- i
			}
		}()
 
		for v := range ch {
			if v == 50 {
				break
			}
		}
	}
}

func main() {
	ticker := time.NewTicker(time.Second * 1)
	for {
		<-ticker.C
		cxt, cancel := context.WithCancel(context.Background())
		ch := make(chan int)
		go func(cxt context.Context) {
			for i := 0; i < 100; i++ {
				select {
				case <-cxt.Done():
					return
				case ch <- i:
				}
			}
		}(cxt)
 
		for v := range ch {
			if v == 50 {
				cancel()
				break
			}
		}
	}
}

func main() {
	ch := make(chan int)
	go func() {
		for {
			timerC := time.After(100 * time.Second)
			//timerC 每次都是重新創(chuàng)建的，什么意思呢？簡單說來，當(dāng) select 成功監(jiān)聽 ch 并進(jìn)入它的處理分支，下次循環(huán) timerC 重新創(chuàng)建了，時(shí)間肯定就重置了。
			select {
			//如果有多個(gè) case 都可以運(yùn)行，select 會(huì)隨機(jī)公平選擇出一個(gè)執(zhí)行。其余的則不會(huì)執(zhí)行
			case num := <-ch:
				fmt.Println("get num is", num)
			case <-timerC:
				//等價(jià)于 case <-time.After(100 * time.Second)
				fmt.Println("time's up!!!")
				//done<-true
			}
		}
	}()
 
	for i := 1; i < 100000; i++ {
		ch <- i
		time.Sleep(time.Millisecond)
	}
}

func main() {
	ch := make(chan int)
	go func() {
		timer := time.NewTimer(100 * time.Second)
		defer timer.Stop()
		for {
			timer.Reset(100 * time.Second)
			select {
			case num := <-ch:
				fmt.Println("get num is", num)
			case <-timer.C:
				fmt.Println("time's up!!!")
			}
		}
	}()
 
	for i := 1; i < 100000; i++ {
		ch <- i
		time.Sleep(time.Millisecond)
	}
}