Type assertion
A type assertion is a language construct that states or checks that a value has a specified type, with runtime behavior depending on the language.
Go by Example
A runtime type assertion is a Go expression that checks and retrieves the concrete value represented by an interface value at run time.
- How it is used
- Enables handlers, wrappers, Context helpers, and database code to discover optional behavior or recover typed values.
- How deep it goes
- Demonstrates comma-ok checks, wrapper unwrapping, Context extraction, and Scanner validation without detailing assertion runtime internals.
- Examples
- Uses http.Flusher on ResponseWriter, trace IDs stored in Context, and a base64 SQL Scanner.
- What you can do after
- Apply it via Go interfaces to safely invoke optional capabilities and validate dynamically typed boundary values.
Essential TypeScript 5, Third Edition
A type assertion is a TypeScript construct that tells the compiler to treat an expression as a specified type without performing a runtime type conversion.
- How it is used
- Overrides compiler uncertainty when a value's type is known to the programmer, including union results and DOM event targets.
- How deep it goes
- Explains `as` syntax, union narrowing, rejected assertions, double assertions, and unchanged runtime values; does not present assertions as validation.
- Examples
- Uses a tax function returning strings or numbers, a task-selection answer, and a select-element quantity handler.
- What you can do after
- Apply it via TypeScript's `as` syntax to access an expected type's members while checking that the runtime value matches.
Read how Essential TypeScript 5, Third Edition explains type assertion →
Build and Orchestrator in Go (From Scratch)
A type assertion is a Go operation that extracts a value of a specified concrete or interface type from an interface value.
- How it is used
- Uses assertions to recover concrete tasks from interface-based stores during retrieval, updates, listing, and event processing.
- How deep it goes
- Explains the two-result assertion, its ok check, and failure handling, but does not descend into runtime representation internals.
- Examples
- Demonstrates assertions while storing, retrieving, updating, listing, and processing task and task-event values.
- What you can do after
- Diagnose/debug with it by checking ok and returned errors before using an interface value as its expected concrete type.
Read how Build and Orchestrator in Go (From Scratch) explains type assertion →
Go in Action, Second Edition
A type assertion is a Go operation that checks whether an interface value contains a specified concrete type and retrieves the contained value if it does.
- How it is used
- Checks interface values when generic behavior must occasionally access concrete, type-specific data.
- How deep it goes
- Explains comma-ok results, contrasts type switches, and covers exact generic-instantiation checks without broader runtime internals.
- Examples
- Uses MetricWeight inspection, measurement-system classification, and Collection[int] assertions to illustrate concrete-type handling.
- What you can do after
- Apply it via comma-ok assertions for one concrete type and type switches for several possible interface implementations.
Read how Go in Action, Second Edition explains type assertion →
Go in Practice, Second Edition
A type assertion is a Go operation that retrieves the concrete value of an interface value when it has a specified dynamic type.
- How it is used
- Uses interface assertions to test compatibility and retrieve typed values from interface-bearing APIs such as context.
- How deep it goes
- Explains assertion syntax through runnable examples and contrasts it with reflection for interface types selected at runtime.
- Examples
- Demonstrates Stringer checks on a bytes.Buffer and integer, then retrieves web configuration from context in an HTTP handler.
- What you can do after
- Apply it via Go's assertion syntax to test interface satisfaction and retrieve typed configuration from an interface value.
Read how Go in Practice, Second Edition explains type assertion →
Also covered in
What to know first
- GoGo is a statically typed, compiled, general-purpose programming language with garbage collection and built-in support for concurrency.
- inheritanceInheritance is a mechanism in which a derived type or descendant element receives properties or behavior from a parent, subject to rules that may allow specialization or overriding.
- MapA map is an associative data structure that stores key-value associations and supports retrieving values by key.
- arrayAn array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
Related concepts
- reflectionalternative to · Reflection is a programming-language or runtime capability that lets a program inspect or manipulate its own types, structure, values, or metadata during execution.
- any typeuses · The any type is a TypeScript type that permits values to be treated as having essentially any type, largely disabling static type checking for them.
- as operatoruses · The as operator is language syntax that associates a value or expression with a specified type through assertion, casting, or conversion, depending on the language.
- data conversioncontrasts with · Data conversion is the transformation of a value or data from one type, format, or representation to another, explicitly or implicitly.
- natural language interfaceuses · A natural language interface enables interaction with a system through human-language text or speech.
- sql.DBused by · sql.DB is a Go database/sql handle that provides database operations while managing a pool of database connections.
Questions about type assertion
What is type assertion?
A type assertion is a language construct that states or checks that a value has a specified type, with runtime behavior depending on the language.
Which Manning books explain type assertion?
Go by Example, Essential TypeScript 5, Third Edition, Build and Orchestrator in Go (From Scratch), Go in Action, Second Edition and Go in Practice, Second Edition.
What should I know before learning type assertion?
Manning books that teach type assertion usually introduce Go, inheritance, Map and array first.
What is the difference between type assertion and reflection?
A type assertion is a language construct that states or checks that a value has a specified type, with runtime behavior depending on the language. Reflection is a programming-language or runtime capability that lets a program inspect or manipulate its own types, structure, values, or metadata during execution.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.




