Go进阶之长参数函数的实现

// Println formats using the default formats for its operands and writes to standard output.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Println(a ...any) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}



// Printf formats according to a format specifier and writes to standard output.
// It returns the number of bytes written and any write error encountered.
func Printf(format string, a ...any) (n int, err error) {
	return Fprintf(os.Stdout, format, a...)
}

// Printf calls l.Output to print to the logger.
// Arguments are handled in the manner of [fmt.Printf].
func (l *Logger) Printf(format string, v ...any) {
	l.output(0, 2, func(b []byte) []byte {
		return fmt.Appendf(b, format, v...)
	})
}

// Println calls l.Output to print to the logger.
// Arguments are handled in the manner of [fmt.Println].
func (l *Logger) Println(v ...any) {
	l.output(0, 2, func(b []byte) []byte {
		return fmt.Appendln(b, v...)
	})
}

func sum(arg ...int) int {
	var total int 
	//arg的类型为[]int
	for _, v := range arg {
		total += v
	}
	return total
}

func main() {
	a, b, c := 1, 2, 3
	fmt.Println(sum(a, b, c))

	nums := []int{1, 2, 3}
	fmt.Println(sum(nums...))
}

func sum(arg ...int) int {
	var total int
	//arg的类型为[]int
	for _, v := range arg {
		total += v
	}
	return total
}

func main() {
	s := []string{"a", "b", "c"}
	dump(s...)
}

func dump(args ...interface{}) {
	for _, v := range args {
		fmt.Println(v)
	}
}

func main() {
	s := []interface{}{"a", "b", "c"}
	dump(s...)
}

func dump(args ...interface{}) {
	for _, v := range args {
		fmt.Println(v)
	}
}

func main() {
	b := []byte{}
	b = append(b, "hello"...)
	fmt.Println(b)
}

func main() {
	b := []byte{}
	b = append(b, "hello"...)
	fmt.Println(b)
	
	fooTest(b)
}

func fooTest(b ...byte) {
	fmt.Println(b)
}

func concat(a, b int) string {
	return fmt.Sprintf("%d %d", a, b)
}

func concat(x, y string) string {
	return fmt.Sprintf("%s %s", x, y)
}

func concat(s []string)string  {
	return strings.Join(s, " ")
}

func main() {
	fmt.Println(concat("-", 1, 2))
	fmt.Println(concat("-", "hello", "gopher"))

}

func concat(sep string, args ...interface{}) string {
	var result string
	for i, v := range args {
		if i != 0 {
			result += sep
		}
		switch v.(type) {
		case int, int8, int16, int32, int64,
			uint, uint8, uint16, uint32, uint64:
			result += fmt.Sprintf("%v", v)
		case string:
			result += fmt.Sprintf("%s", v)
		case []int:
			ints := v.([]int)
			for i, v := range ints {
				if i != 0 {
					result += sep
				}
				result += fmt.Sprintf("%v", v)
			}
		case []string:
			strings := v.([]string)
			result += fmt.Sprintf("%v", strings)
		default:
			fmt.Println("不支持此类型")
			return ""
		}
	}
	return result
}

type record struct {
	name    string
	gender  string
	age     int
	city    string
	country string
}

func enroll(args ...interface{}) (*record, error) {
	if len(args) > 5 || len(args) < 3 {
		return nil, fmt.Errorf("the number of arguments passed to wrong")
	}

	r := &record{
		city:    "ShanXi",
		country: "TaiYuan",
	}

	for i, v := range args {
		switch i {
		case 0:
			name, ok := v.(string)
			if !ok {
				return nil, fmt.Errorf("the first argument to enroll must be a string")
			}
			r.name = name
		case 1:
			gender, ok := v.(string)
			if !ok {
				return nil, fmt.Errorf("the second argument to enroll must be a string")
			}
			r.gender = gender
		case 2:
			age, ok := v.(int)
			if !ok {
				return nil, fmt.Errorf("the third argument to enroll must be an uint16")
			}
			r.age = age
		case 3:
			city, ok := v.(string)
			if !ok {
				return nil, fmt.Errorf("the third argument to enroll must be a string")
			}
			r.city = city
		case 4:
			country, ok := v.(string)
			if !ok {
				return nil, fmt.Errorf("the fourth argument to enroll must be a string")
			}
			r.country = country
		default:
			return nil, fmt.Errorf("unknown argument %d", i)
		}
	}
	return r, nil

}

func main() {
	r, _ := enroll("小明", "male", 26)
	fmt.Printf("%+v\n", *r)

	r1, _ := enroll("小明", "male", 26, "linfen")
	fmt.Printf("%+v\n", *r1)

}

type FinishedHouse struct {
	style                  int
	centralAirConditioning bool
	floorMaterial          string
	wallMaterial           string
}

func NewFinishedHouse(style int, centralAirConditioning bool, floorMaterial, wallMaterial string) *FinishedHouse {
	h := &FinishedHouse{
		style:                  style,
		centralAirConditioning: centralAirConditioning,
		floorMaterial:          floorMaterial,
		wallMaterial:           wallMaterial,
	}
	return h
}

func main() {
	fmt.Printf("%+v\n", NewFinishedHouse(0, true, "wood", "paper"))
}

type FinishedHouse struct {
	style                  int
	centralAirConditioning bool
	floorMaterial          string
	wallMaterial           string
}

type Options struct {
	style                  int
	centralAirConditioning bool
	floorMaterial          string
	wallMaterial           string
}

func NewFinishedHouse(options *Options) *FinishedHouse {
	var style  = 0
	var centralAirConditioning = true
	var floorMaterial = "wood"
	var wallMaterial = "paper"
	if options != nil {
		style = options.style
		centralAirConditioning = options.centralAirConditioning
		floorMaterial = options.floorMaterial
		wallMaterial = options.wallMaterial
	}
	h := &FinishedHouse{
		style:                  style,
		centralAirConditioning: centralAirConditioning,
		floorMaterial:          floorMaterial,
		wallMaterial:           wallMaterial,
	}
	return h
}

func main() {
	fmt.Printf("%+v\n", NewFinishedHouse(0, true, "wood", "paper"))
}

type FinishedHouse struct {
	style                  int
	centralAirConditioning bool
	floorMaterial          string
	wallMaterial           string
}

type Option func(h *FinishedHouse)

func NewFinishedHouse(options ...Option) *FinishedHouse {
	h := &FinishedHouse{
		style:                  0,
		centralAirConditioning: true,
		floorMaterial:          "wood",
		wallMaterial:           "paper",
	}

	for _, option := range options {
		option(h)
	}

	return h
}

func WithStyle(style int) Option {
	return func(h *FinishedHouse) {
		h.style = style
	}
}

func WithCentralAirConditioning(centralAirConditioning bool) Option {
	return func(h *FinishedHouse) {
		h.centralAirConditioning = centralAirConditioning
	}
}

func WithFloorMaterial(floorMaterial string) Option {
	return func(h *FinishedHouse) {
		h.floorMaterial = floorMaterial
	}
}

func WithWallMaterial(wallMaterial string) Option {
	return func(h *FinishedHouse) {
		h.floorMaterial = wallMaterial
	}
}

func main() {
	//默认.
	fmt.Printf("%+v\n", NewFinishedHouse())

	fmt.Printf("%+v\n", NewFinishedHouse(WithStyle(1), WithFloorMaterial("title")))

}