Using Go's reflect package, how do you list a struct's fields and read each field's struct tag?

## The two halves of reflect Go's `reflect` package exposes a value's runtime type and its runtime data as two separate objects: `reflect.Type` (what the thing *is*) and `reflect.Value` (what the thing *holds*). Walking a struct's shape and reading its tags is entirely a `Type` job — the tags and the field list belong to the type, not to any particular instance. That is why a code generator can work from `reflect.TypeOf(User{})` on a zero value it never fills in. ## Getting a struct Type `reflect.TypeOf(x)` takes an `any` and returns the dynamic type of what was passed. If you pass `User{}` you get the struct type directly. If you pass `&User{}` you get a pointer type, and every struct-shaped method on it panics; call `t.Elem()` to step from `*User` to `User`. Defensive walkers usually normalise first: ```go for t.Kind() == reflect.Pointer { t = t.Elem() } if t.Kind() != reflect.Struct { return fmt.Errorf("want a struct, got %s", t) } ``` The guard matters because `NumField`, `Field`, `FieldByName` and friends are documented to panic when the Kind is not `Struct`. Reflection reports misuse by panicking, not by returning errors. ## NumField and Field `t.NumField()` returns the number of fields the struct *declares*. `t.Field(i)` returns the i-th of them, in declaration order, as a `reflect.StructField` — note that this is a plain struct value, not an interface, so you can copy it around freely. Its useful members are: - `Name string` — the field's identifier as written in the source. - `Type reflect.Type` — the field's type, which you can recurse into. - `Tag reflect.StructTag` — the raw back-quoted tag string, or `""` if none was written. - `Index []int` — the index path used by `FieldByIndex`; a single element for a directly declared field. - `Anonymous bool` — true when the field is embedded rather than named. - `PkgPath string` — empty for an exported field, and the declaring package's path for an unexported one. - `Offset uintptr` — the byte offset within the struct, occasionally useful to low-level code. ## Reading the tag `reflect.StructTag` is a defined string type with two methods. `Get(key)` returns the value for a key as a plain string, and `Lookup(key)` returns the value plus a boolean saying whether the key was there at all. The conventional format the parser understands is a space-separated list of `key:"value"` pairs, where the value is a quoted Go string literal: ```go ID int `db:"user_id" validate:"required"` ``` Within a value, packages conventionally use commas to add options — `db:"user_id,pk"` — but that is *convention only*. `reflect` hands you the whole value string, `user_id,pk`, and splitting it is the consuming package's job. The compiler stores the tag as an opaque string in the type's metadata; it never validates its contents. ## A complete walk ```go t := reflect.TypeOf(User{}) for i := 0; i < t.NumField(); i++ { f := t.Field(i) fmt.Printf("%s %s %q\n", f.Name, f.Type, f.Tag.Get("db")) } ``` That loop is the backbone of every tag-driven mapper: an encoder deciding what to emit, a validator deciding what to check, or a generator emitting one SQL column per tagged field. ## Things that surprise people The walk sees the struct's *declared* fields, so an embedded struct arrives as one field whose own fields are not counted; reaching those means recursing, or calling `reflect.VisibleFields`, which performs the breadth-first walk and returns promoted fields too. A field with no tag is not an error — `Tag` is simply the empty string and `Get` returns `""`. And an unexported field still appears in the walk: you can read its name, type and tag from the `StructField`, even though `reflect` will not hand you its value. ## Cost A reflect walk is far slower than direct field access — it allocates, it defeats inlining, and it does string work on every tag read. That is fine at start-up or in a generator that runs once, and it is worth measuring before you put it on a per-request path.