Being a little more dynamic with Go

I'm new to Go and I do like the static type checking a lot, it has saved my bacon a few times already at compile phase!

I do however see that I am duplicating a lot of code such as...

if string(key) == "altitude" {
	altitudeInt, _ := jsonparser.ParseInt(value)
	n.ThisDataRaw.Altitude = new(int)
	*n.ThisDataRaw.Altitude = int(altitudeInt)
	return nil
}

if string(key) == "heading" {
	headingInt, _ := jsonparser.ParseInt(value)
	n.ThisDataRaw.Heading = new(int)
	*n.ThisDataRaw.Heading = int(headingInt)
	return nil
}

if string(key) == "speed" {
	speedInt, _ := jsonparser.ParseInt(value)
	n.ThisDataRaw.Speed = new(int)
	*n.ThisDataRaw.Speed = int(speedInt)
	return nil
}

Is it possible to get a little bit more dynamic so that I don't need to duplicate the code and for the example below have a single function at all?

Without any "magic", your code can be simplified to this:

parsed, err := jsonparser.ParseInt(value)
// check err
switch intValue := int(parsed); key {
case "altitude":
	n.ThisDataRaw.Altitude = &intValue
case "heading":
	n.ThisDataRaw.Heading = &intValue
case "speed":
	n.ThisDataRaw.Speed = &intValue
}

It's much cleaner and contains minimal code redundancy. If the n.ThisDataRaw field is a pointer, we can do a little more:

parsed, err := jsonparser.ParseInt(value)
// check err
switch intValue, tdr := int(parsed), n.ThisDataRaw; key {
case "altitude":
	tdr.Altitude = &intValue
case "heading":
	tdr.Heading = &intValue
case "speed":
	tdr.Speed = &intValue
}

If the n.ThisDataRaw field is not a pointer, we can still apply this last step, by taking its address:

switch intValue, tdr := int(parsed), &n.ThisDataRaw; key {

(The rest of the code is the same.)

You should be satisfied by this. If not, read on.

If the data identifying your struct field comes as a string, we either have to use some kind of branching (like the switch above), or we may use reflection to get the field based on the string value.

Note: using reflection instead of the switch, we'd risk setting fields which otherwise we would not want to. Also reflection will make it slower, and harder to understand. If the number of fields is not big, just use the switch.

If the key value equals to the field name, this would be very simple, but be sure to pass a pointer to reflect.ValueOf(), else it won't be settable.

If the key value does not equal to the field name, we could create a mapping from the actual key values to the target field names, so again after indexing this map getting the target field would be the same. This solution also gives us some kind of protection: if the key value is not in the map, we would not change any fields.