chore: unnecessary use of fmt.Sprintf

.gitignore

@@ -6,3 +6,4 @@
 /build-in-package/http/keyboard.jpeg
 /awesome-go/rpcx/registry/consul/server/server.go
 /awesome-go/rpcx/registry/multiple/server/server.go
+/.idea/codeStyles/codeStyleConfig.xml

Language_Specification/build-in-function/panic_and_recover.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"gobyexample/Language_Specification/errors"
+	"ultimate-go/Language_Specification/errors"
 )
 
 // panic, 立刻stops execution the current function, then unwinding the stack, then run deferred functions

Language_Specification/build-in-type/str/str.go

@@ -0,0 +1,43 @@
+package str
+
+import (
+	"encoding/base64"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func Base64Encode(s string) string {
+	return base64.StdEncoding.EncodeToString([]byte(s))
+}
+func Base64Decode(s string) string {
+	b, err := base64.StdEncoding.DecodeString(s)
+	if err != nil {
+		return ""
+	}
+	return string(b[:])
+}
+func IdsString2Slice(s string) []int64 {
+	if s == "" {
+		return []int64{}
+	}
+	arr := strings.Split(s, ",")
+	n := len(arr)
+	ids := make([]int64, 0, n)
+	for _, s2 := range arr {
+		i64, err := strconv.ParseInt(s2, 10, 64)
+		if err == nil {
+			ids = append(ids, i64)
+		}
+	}
+	return ids
+}
+func Slice2IdsString(ids []int64) string {
+	arr := make([]string, len(ids))
+	for i, id := range ids {
+		arr[i] = fmt.Sprintf("%d", id)
+	}
+	s := ""
+	s = strings.Join(arr, ",")
+	return s
+}

Language_Specification/build-in-type/str/str_test.go

@@ -0,0 +1,106 @@
+package str
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestIdsString2Slice(t *testing.T) {
+	type args struct {
+		ids string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int64
+	}{
+		{
+			name: "IdsString2Slice",
+			args: args{ids: "1,2,3"},
+			want: []int64{1, 2, 3},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IdsString2Slice(tt.args.ids); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("String2SliceInt64() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSlice2IdsString(t *testing.T) {
+	type args struct {
+		ids []int64
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "IdsString2Slice",
+			args: args{
+				ids: []int64{1, 2, 3},
+			},
+			want: "1,2,3",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := Slice2IdsString(tt.args.ids); got != tt.want {
+				t.Errorf("Slice2IdsString() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBase64Encode(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "Base64Encode",
+			args: args{s: "sss"},
+			want: "c3Nz",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := Base64Encode(tt.args.s); got != tt.want {
+				t.Errorf("Base64Encode() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBase64Decode(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "Base64Decode",
+			args: args{
+				s: "c3Nz",
+			},
+			want: "sss",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := Base64Decode(tt.args.s); got != tt.want {
+				t.Errorf("Base64Decode() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

Language_Specification/constant/constant.go

@@ -3,23 +3,23 @@ package main
 import "fmt"
 
 const (
-	A1 = iota // 如同数据库里面的serial, 自增, iota默认Increment by 1
+	A1 = iota // like mysql serial, auto increment, iota default increment by 1
 	A2
 	A3
 )
 const (
-	B1 = iota + 2 // start by iot + 2,即2, Increment by iot, 即1
+	B1 = iota + 2 // start by iot + 2, that is 2, Increment by iot, that is 1
 	B2
 	B3
 )
 const (
-	C1 = iota * 2 // start iot*2, 即0, Increment by iot * 2, 即2
+	C1 = iota * 2 // start iot*2, that 0, Increment by iot * 2, that is 2
 	C2
 	C3
 	C4
 )
 const (
-	D1 = 1 << iota // start by 1 , Increment by iot * iot
+	D1 = 1 << 2 // start by 1 , left shift 1
 	D2
 	D3
 	D4

Language_Specification/exporting/exporting.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"gobyexample/Language_Specification/exporting/codes"
+	"ultimate-go/Language_Specification/exporting/codes"
 )
 
 // -------------------

Language_Specification/import/bar/bar.go

@@ -0,0 +1,12 @@
+package bar
+
+import (
+	"fmt"
+)
+
+type Bar struct {
+}
+
+func (b *Bar) Bar() {
+	fmt.Println("this bar")
+}

Language_Specification/import/bar/bar_test.go

@@ -0,0 +1,25 @@
+package bar
+
+import (
+	"fmt"
+	"testing"
+
+	"ultimate-go/Language_Specification/import/foo"
+)
+
+func TestBar_Bar(t *testing.T) {
+	tests := []struct {
+		name string
+	}{
+		{
+			name: "test",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := &foo.Foo{}
+			b := &Bar{}
+			fmt.Println(b, f)
+		})
+	}
+}

Language_Specification/import/barer/barer.go

@@ -0,0 +1,5 @@
+package barer
+
+type Barer interface {
+	Bar()
+}

Language_Specification/import/foo/foo.go

@@ -0,0 +1,15 @@
+package foo
+
+import (
+	"fmt"
+
+	"ultimate-go/Language_Specification/import/barer"
+)
+
+type Foo struct {
+	b barer.Barer
+}
+
+func (b *Foo) Bar() {
+	fmt.Println("this bar")
+}

Language_Specification/packages/main.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"                                             // import package
-	"gobyexample/Language_Specification/packages/app" // import nested package
+	"ultimate-go/Language_Specification/packages/app" // import nested package
 )
 
 /*

Language_Specification/reference-type/struct/structs_Declare_Initialize.go

@@ -13,18 +13,24 @@ type Address struct {
 }
 
 func main() {
-	type User struct{}
+	type User struct{ Name string }
 	type User1 User   // new type User1
-	type User2 = User // User2 是User类型的别名
-	// Defining Name type, 相同结构不可=
+	type User2 = User // User2 is an alias of User
+	user0 := User{Name: "user0"}
+	user1 := User1{Name: "user1"}
+	user2 := User2{Name: "user2"}
+	fmt.Printf("user0 type: %T, value: %v\n", user0, user0)
+	fmt.Printf("user1 type: %T, value: %v\n", user1, user1)
+	fmt.Printf("user2 type: %T, value: %v\n", user2, user2)
+	// Defining Name type
 	type Shop struct {
 		Id      string `json:"id"`
 		Name    string `json:"name"`
 		Owner   string `json:"owner"`
 		Order   []string
 		Address Address `json:"address"`
 	}
-	// Defining Anonymous type， 相同结构可=
+	// Defining Anonymous type
 	shopAnonymous := struct {
 		Id    string `json:"id"`
 		Name  string `json:"name"`

Language_Specification/variables/variables.go

@@ -53,12 +53,12 @@ func main() {
 	// Short Variable Declare
 	aa := 10
 	bb := "hello"
-	cc := 3.145
+	co := 3.145
 	dd := true
 
 	fmt.Printf("aa : %T  , value is : [%v] \n", aa, aa)
 	fmt.Printf("bb : %T  , value is : [%v] \n", bb, bb)
-	fmt.Printf("cc : %T  , value is : [%v] \n", cc, cc)
+	fmt.Printf("co : %T  , value is : [%v] \n", co, co)
 	fmt.Printf("dd : %T  , value is : [%v] \n", dd, dd)
 
 }

LearnConcurrency/communicate_channel/multiplexing/multiplexing_test.go

@@ -2,8 +2,8 @@ package multiplexing
 
 import (
 	"fmt"
-	"gobyexample/LearnConcurrency/communicate_channel/ping_pong"
 	"testing"
+	"ultimate-go/LearnConcurrency/communicate_channel/ping_pong"
 )
 
 func TestFanIn(t *testing.T) {

LearnConcurrency/user_concurrency/user_concurrency_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"gobyexample/utils"
+	"ultimate-go/utils"
 )
 
 func TestDetailById(t *testing.T) {