Updated to go1.18 & Added a Generic GetAs function

map[string]interface{}{
  "name": "Andy"
}

val, err := GetAs[string](m, "name")
val == "Andy"

This simplifies access to the maps as the user does not have to keep casting the returned interface{} to the simple types they need

Author: theouteredge

go.mod

@@ -1,3 +1,3 @@
 module github.com/iv-p/mapaccess
 
-go 1.13
+go 1.18

mapaccess.go

@@ -24,6 +24,21 @@ func Get(data interface{}, key string) (interface{}, error) {
 	return state, nil
 }
 
+// GetAs returns the corresponding key from the map and converts it to type T
+func GetAs[T any](data interface{}, key string) (T, error) {
+	if val, err := Get(data, key); err != nil {
+		var zero T
+		return zero, err
+
+	} else {
+		if res, ok := val.(T); ok {
+			return res, nil
+		}
+		var zero T
+		return zero, fmt.Errorf("expected type %s but got %s", reflect.TypeOf(zero), reflect.TypeOf(val))
+	}
+}
+
 func get(data interface{}, key token) (interface{}, error) {
 	switch state := data.(type) {
 	case map[string]interface{}:

mapaccess_test.go

@@ -3,7 +3,7 @@ package mapaccess
 import (
 	"fmt"
 	"html/template"
-	"io/ioutil"
+	"io"
 	"reflect"
 	"testing"
 )
@@ -69,6 +69,68 @@ func TestGet(t *testing.T) {
 	}
 }
 
+func TestGetAs(t *testing.T) {
+	type args struct {
+		key  string
+		data interface{}
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{"root", args{"one", data}, "two", false},
+		{"root array", args{"array[0]", data}, "value", false},
+		{"nested", args{"nested.key", data}, "three", false},
+		{"nested array", args{"nested.array[0]", data}, "four", false},
+
+		{"spaces", args{" one.two[0]", data}, "", true},
+		{"spaces", args{"o.test.", data}, "", true},
+		{"spaces", args{"[0]", data}, "", true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetAs[string](tt.args.data, tt.args.key)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("Get() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestGetAsInt(t *testing.T) {
+	m := map[string]interface{}{
+		"one":   1,
+		"two":   2.2,
+		"three": 0.3,
+	}
+
+	if val, err := GetAs[int](m, "one"); err != nil {
+		t.Errorf("GetAs() error = %v", err)
+
+	} else if val != 1 {
+		t.Errorf("GetAs() = %v, want %v", val, 1)
+	}
+
+	if val, err := GetAs[float64](m, "two"); err != nil {
+		t.Errorf("GetAs() error = %v", err)
+	} else if val != 2.2 {
+		t.Errorf("GetAs() = %v, want %v", val, 2.2)
+	}
+
+	if val, err := GetAs[float64](m, "three"); err != nil {
+		t.Errorf("GetAs() error = %v", err)
+	} else if val != 0.3 {
+		t.Errorf("GetAs() = %v, want %v", val, 0.3)
+	}
+
+}
+
 func benchmarkMapaccess(key string, b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		Get(data, key)
@@ -81,7 +143,7 @@ func benchmarkGoTemplate(key string, b *testing.B) {
 		if err != nil {
 			fmt.Println(err)
 		}
-		t.Execute(ioutil.Discard, typed)
+		t.Execute(io.Discard, typed)
 	}
 }
 

readme.md

@@ -28,9 +28,11 @@ It is intended towards using with serializing arbitary JSON and getting an arbit
 j := []byte(`{
     "id": "9b92b11b-b57f-4fa6-af5e-e35a290dc764",	
     "name": "John Doe",
+    "age": 44,
     "friends": [
         {
-            "name": "Jaime Mckinney"
+            "name": "Jaime Mckinney",
+            "age": 41
         },
         {
             "name": "Evangeline Alvarado"
@@ -89,6 +91,17 @@ mapaccess.Get(data, "[0].[1]")
 mapaccess.Get(data, "friends[0].[1]")
 ```
 
+### Generic GetAs[T any] Method
+The `GetAs[T any]` method allows you too simplify accessing maps by casting the extraced value to a concrete type
+```go
+// Valid
+mapaccess.GetAs[string](data, "id")
+mapaccess.GetAs[string](data, "name")
+mapaccess.GetAs[int](data, "age")
+mapaccess.GetAs[string](data, "friends[0].name")
+mapaccess.GetAs[int](data, "friends[0].age")
+```
+
 ## Valid keys
 
 There is a limitation of the alphabet for keys, it includes underscores, dashes and alphanumeric characters.