10 examples of 'golang interface to string' in Go

544
func interfaceToString(data interface{}) string {
545
	if data == nil {
546
		return ""
547
	}
548
	switch data.(type) {
549
	case string:
550
		return data.(string)
551
	case []interface{}:
552
		interfaceArr := data.([]interface{})
553
		results := []string{}
554
		for _, v := range interfaceArr {
555
			results = append(results, interfaceToString(v))
556
		}
557
		return "[" + strings.Join(results, ",") + "]"
558
	default:
559
		return fmt.Sprintf("%v", data)
560
	}
561
}

389
func ifaceToString(iface interface{}) (string, error) {
390
	switch iface.(type) {
391
	case int:
392
		return strconv.Itoa(iface.(int)), nil
393
	case float64:
394
		return strconv.FormatFloat(iface.(float64), 'f', -1, 32), nil
395
	case float32:
396
		return strconv.FormatFloat(iface.(float64), 'f', -1, 32), nil
397
	case string:
398
		return iface.(string), nil
399
	case bool:
400
		return strconv.FormatBool(iface.(bool)), nil
401
	default:
402
		return "", errors.New("error, undefined type cast")
403
	}
404
}

107
func toString(t uint32) string {
108
	switch t {
109
	case null:
110
		return "null"
111
	case bytearray:
112
		return "binary"
113
	case t_uint32:
114
		return "uint32"
115
	default:
116
		return "unknown"
117
	}
118
}

25
func ToString(i interface{}) string {
26
	if i == nil {
27
		return ""
28
	}
29
	if f, ok := i.(appString); ok {
30
		return f.String()
31
	}
32
	switch value := i.(type) {
33
	case int:
34
		return strconv.Itoa(value)
35
	case int8:
36
		return strconv.Itoa(int(value))
37
	case int16:
38
		return strconv.Itoa(int(value))
39
	case int32:
40
		return strconv.Itoa(int(value))
41
	case int64:
42
		return strconv.Itoa(int(value))
43
	case uint:
44
		return strconv.FormatUint(uint64(value), 10)
45
	case uint8:
46
		return strconv.FormatUint(uint64(value), 10)
47
	case uint16:
48
		return strconv.FormatUint(uint64(value), 10)
49
	case uint32:
50
		return strconv.FormatUint(uint64(value), 10)
51
	case uint64:
52
		return strconv.FormatUint(value, 10)
53
	case float32:
54
		return strconv.FormatFloat(float64(value), 'f', -1, 32)
55
	case float64:
56
		return strconv.FormatFloat(value, 'f', -1, 64)
57
	case bool:
58
		return strconv.FormatBool(value)
59
	case string:
60
		return value
61
	case []byte:
62
		return zstring.Bytes2String(value)
63
	default:
64
		if f, ok := value.(appString); ok {
65
			return f.String()
66
		}
67
		jsonContent, _ := json.Marshal(value)
68
		return string(jsonContent)
69
	}
70
}

210
func toString(v string) *google_protobuf.Value {
211
	return &google_protobuf.Value{
212
		Kind: &google_protobuf.Value_StringValue{
213
			StringValue: v,
214
		},
215
	}
216
}

544
func toString(v reflect.Value) string {
545
	switch v.Kind() {
546
	case reflect.String:
547
		return v.String()
548
	case reflect.Interface:
549
		return toString(v.Elem())
550
	}
551
	return ""
552
}

90
func toInterface(s []string) []interface{} {
91
92
	ret := make([]interface{}, len(s))
93
	for i, v := range s {
94
		ret[i] = interface{}(v)
95
	}
96
	return ret
97
}

614
func AtiToString(val Civalue) string {
615
	cval := C.ati_to_string(val)
616
	return C.GoString(cval)
617
}

156
func toString(val reflect.Value) string {
157
	if !val.IsValid() {
158
		panic("Attempted to coerce undefined value into a string.")
159
	}
160
161
	for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
162
		if val.IsNil() {
163
			return "null"
164
		}
165
		val = val.Elem()
166
	}
167
168
	switch {
169
	case isInt(val):
170
		return strconv.FormatInt(val.Int(), 10)
171
	case isFloat(val):
172
		return strconv.FormatFloat(val.Float(), 'g', -1, 64)
173
	}
174
175
	switch val.Kind() {
176
	case reflect.Bool:
177
		if val.Bool() {
178
			return "true"
179
		}
180
		return "false"
181
	case reflect.String:
182
		return val.String()
183
	case reflect.Slice:
184
		var items = make([]string, val.Len())
185
		for i := 0; i < val.Len(); i++ {
186
			items[i] = toString(val.Index(i))
187
		}
188
		return "[" + strings.Join(items, ", ") + "]"
189
	case reflect.Map:
190
		var keys = val.MapKeys()
191
		var items = make([]string, len(keys))
192
		for i := 0; i < len(keys); i++ {
193
			items[i] = toString(keys[i]) + ": " + toString(val.MapIndex(keys[i]))
194
		}
195
		return "{" + strings.Join(items, ", ") + "}"
196
	}
197
	panic(fmt.Sprintf("unexpected type: %#v", val.Interface()))
198
}

25
func intfflag2string(flag uint64) string {
26
	ss := make([]string, 0, 10)
27
	if flag&syscall.IFF_UP > 0 {
28
		ss = append(ss, "UP")
29
	}
30
	if flag&syscall.IFF_BROADCAST > 0 {
31
		ss = append(ss, "BROADCAST")
32
	}
33
	if flag&syscall.IFF_DEBUG > 0 {
34
		ss = append(ss, "DEBUG")
35
	}
36
	if flag&syscall.IFF_LOOPBACK > 0 {
37
		ss = append(ss, "LOOPBACK")
38
	}
39
	if flag&syscall.IFF_POINTOPOINT > 0 {
40
		ss = append(ss, "POINTOPOINT")
41
	}
42
	if flag&syscall.IFF_RUNNING > 0 {
43
		ss = append(ss, "RUNNING")
44
	}
45
	if flag&syscall.IFF_NOARP > 0 {
46
		ss = append(ss, "NOARP")
47
	}
48
	if flag&syscall.IFF_PROMISC > 0 {
49
		ss = append(ss, "PROMISC")
50
	}
51
	if flag&syscall.IFF_ALLMULTI > 0 {
52
		ss = append(ss, "ALLMULTI")
53
	}
54
	if flag&syscall.IFF_MULTICAST > 0 {
55
		ss = append(ss, "MULTICAST")
56
	}
57
	return strings.Join(ss, " | ")
58
}