如何计算整数中的字节数

I have the following variables:

var foo int8
var bar [5]int8

I want to count number of bytes in both variables and output the sum - so right here it should be 1 + 5 = 6. Is this possible?

You can use unsafe.Sizeof (https://play.golang.org/p/FroasKud7I):

unsafe.Sizeof(foo) + unsafe.Sizeof(bar)

You can use reflect.Size, this returns a uintptr for some reason, but is actually just the exact same thing as unsafe.SizeOf without having to use unsafe.

var x [8]byte

t := reflect.TypeOf(x)

fmt.Println(t.Size())

The snags are going to be maps, slices, strings, and pointers, which you'll get the size of the header/metadata (or just the pointer size for pointers). If that's okay, great! If not, you can handle this in various ways, this is the best I have off the top of my head:

func UnderlyingSize(x interface{}) uintptr {
    v := reflect.ValueOf(x)
    t := v.Type()

    var size uintptr;

    switch t.Kind() {
    // For the builtin collections, we just multiply the len by the
    // element size, for maps also do the key
    case reflect.Map:
         l := uintptr(v.Len())
        size = t.Key().Size()*l + t.Elem().Size()*l
    case reflect.Slice:
        t := t.Elem();
        size = t.Size() * uintptr(v.Len())
    case reflect.Ptr:
        t := t.Elem();
        size = t.Size()
    // Strings are just byte arrays, so it's just the len
    case reflect.String:
        size = uintptr(v.Len())
    // For an interface, we need to find the underlying type
    case reflect.Interface:
        v := v.Elem()
        size = UnderlyingSize(v)
    // For anything else, including arrays, Size returns the correct value
    default:
        size = t.Size();
    }

    return size
}

There is an argument to be made for using Cap rather than Len, but it's easy enough to change yourself. You can also add t.Size() to any of these values if you want the size of the header information AND the underlying size. Note a word of warning that the real map probably takes more memory than just the key+value+header size, since there's probably some extra information under the hood.

If you have a data structure that's a collection, you'll have to implement something like this yourself, but if it's a simple struct (i.e. only made of POD structs and builtin types), you can simply add up UnderlyingSize of all the members.