Go convert to float from string which represent binary

Go gRPC metadata, get and convert the value.

In my logs, i saw that the metadata was being translated into another type (I think it's a byte array) like this

"latitude-bin":"\ufffd\u0019\u0014\ufffd\ufffdϑL","longitude-bin":"@Z\ufffd\ufffd\ufffd\u000e\ufffdD"

Both of those value should be a Double if I'm not mistaken.
I want to convert those value into a Double or float64 in Golang, but I'm a bit unsure about my approach, since I don't know the type of latitude-bin or longitude-bin and I can't reproduce those value (taken from the logs by my clients)

Here is my approach

// GetLangitute get latitude from metadata `latitude-bin` and return nil when fails
func GetLangitute(ctx context.Context) *float64 {
	metadataList := getMetaDataListByKey(ctx, latitudeBin)
	if metadataList != nil {
		s := metadataList[metadataIndex]
		b := []byte(s)
		// TODO: 
		// I'm still a bit unsure about this approach
		data := math.Float64frombits(binary.BigEndian.Uint64(b))
		return &data
	}

	return nil
}

func getMetaDataListByKey(ctx context.Context, key string) []string {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return nil
	}

	metadataList := md.Get(key)
	if isEmpty(metadataList) {
		return nil
	}

	return metadataList
}

func isEmpty(metadataList []string) bool {
	return len(metadataList) == 0
}

I tried to test using a Unit Test and look good, but still I'm unsure about the expected result since I can't reproduce it, here is my Unit test

f := math.Float64frombits(uint64(6662343813755067509))
// ...
name: "Given key exist in metadata",
			args: args{
				ctx: metadata.NewIncomingContext(
					context.Background(),
					metadata.Pairs("latitude-bin", `\ufffd\u0019\u0014\ufffd\ufffdϑL`),
				),
			},
			want: &f,
// ...
t.Run(tt.name, func(t *testing.T) {
	got := GetLangitute(tt.args.ctx)
	if tt.want != nil {
		if *got != *tt.want {
			t.Errorf("GetLangitute() = %v, want %v", got, tt.want)
		}
	} else {
		assert.Nil(t, got)
	}
})

Unfortunately it seems your input JSON is already "screwed". Your latitude and longitude values in JSON are 8-byte values, but they don't represent the original values. The original value is lost.

Go stores strings as their UTF-8 encoded byte sequence. When converting other types to string (e.g. int), when invalid values are encountered, the conversion will result in the Unicode replacement character 0xFFFD.

Your input contains multiple of these runes: \ufffd. This means the encoding algorithm that produces your input JSON is faulty and resulted in information loss. It's unlikely you can reproduce the original latitude and longitude values.

You must fix the encoding part of your source.

Note: if your input would be valid / correct, you could simply convert the string value to []byte like this:

b := []byte(s)

The above conversion would result in the bytes of s, regardless whether s contains valid UTF-8 sequence or not.