golang value in assignment need type assertion

Go Flow Control

Go Boolean Expression
Go if...else
Go for Loop
Go while Loop
Go break and continue

Go Data Structures

Go Functions
Go Variable Scope
Go Recursion
Go Anonymous Function
Go Packages

Go Pointers & Interface

Go Pointers
Go Pointers and Functions
Go Pointers to Struct

Go Interface

Go Empty Interface

Go Type Assertions

Go Additional Topics

Go defer, panic, and recover

Go Tutorials

Golang type assertions.

Type assertions allow us to access the data and data type of values stored by the interface.

Before we learn about type assertions, let's see why we need type assertions in Go.

We know that an empty interface can accept any type and number of values. For example,

Here, the a variable is of empty interface type, and it is storing both the string and integer value. To learn more about empty interfaces, visit Go Empty Interface .

This seems like an important feature of an empty interface. However, sometimes this will create ambiguity on what data an interface is holding.

To remove this ambiguity, we use type assertions.

Example: Go Type Assertions

In the above example, we have stored the integer value 10 to the empty interface denoted by a . Notice the code,

Here, (int) checks if the value of a is an integer or not. If true , the value will be assigned to interfaceValue .

Otherwise, the program panics and terminates. For example,

Here, the value of the interface is a string. So, a.(int) is not true. Hence, the program panics and terminates.

To learn more about panic, visit Go panic Statement .

Avoiding panic in Type Assertions in Go

In Go, the type assertion statement actually returns a boolean value along with the interface value. For example,

Here, the data type of value 12 matches with the specified type (int) , so this code assigns the value of a to interfaceValue .

Along with this, a.(int) also returns a boolean value which we can store in another variable. For example,

Here, you can see we get both the data and boolean value.

We can use this to avoid panic if the data type doesn't match the specified type.

This is because, when the type doesn't match, it returns false as the boolean value, so the panic doesn't occur. For example,

Here, you can see we get 0 and false as output because the data type of value (string) doesn't match with the specified type (int) .

Introduction

Sorry about that.

Type assertions in Golang

Type assertions in Go help access the underlying type of an interface and remove ambiguity from an interface variable. In this post, we will get a closer look at type assertions.

What are type-assertions in Golang?

Type assertions reveal the concrete value inside the interface variable. Below is an example showing the assertion.

Type assertion syntax

The syntax for type assertion is simple. We take the interface variable and then access type with parenthesis as shown below.

interfaceVariable.(type) is the syntax.

Why use interfaces?

Interfaces are a type that can take any value. This creates ambiguity. Nothing can be told about that variable. Type assertion and type-switches helps to understand what kind of value it contains and what type it is.

Checking type-assertions

To check type assertions we can use the second return value for correctness. Here is how to use that.

Type-assertions and panic

Whenever a wrong assertion occurs panic happens. Panic is an error that can’t be seen before.

Why is it useful?

Type-assertions are useful to remove the ambiguity from interface variables. It helps unwrap the concrete value inside an interface variable.

Golang Type Assertion Explained with Examples

October 4, 2022

Getting started with golang Type Assertion

A type assertion is an operation applied to an interface value. Syntactically, it looks like x.(T) , where x is an expression of an interface type and T is a type, called the “asserted” type. A type assertion checks that the dynamic type of its operand matches the asserted type.

There are two possibilities. First, if the asserted type T is a concrete type, then the type assertion checks whether x’s dynamic type is identical to T . If this check succeeds, the result of the type assertion is x’s dynamic value, whose type is of course T . In other words, a type assertion to a concrete type extracts the concrete value from its operand. If the check fails, then the operation panics. For example:

Second, if instead the asserted type T is an interface type, then the type assertion checks whether x’s dynamic type satisfies T . If this check succeeds, the dynamic value is not extracted; the result is still an interface value with the same type and value components, but the result has the interface type T .

In other words, a type assertion to an interface type changes the type of the expression, making a different (and usually larger) set of methods accessible, but it preserves the dynamic type and value components inside the interface value.

After the first type assertion below, both w and rw hold os.Stdout so each has a dynamic type of *os.File , but w , an io.Writer , exposes only the file’s Write method, whereas rw exposes its Read method too.

No matter what type was asserted, if the operand is a nil interface value, the type assertion fails. A type assertion to a less restrictive interface type (one with fewer methods) is rarely needed, as it behaves just like an assignment, except in the nil case.

Example 1: Simple example of using type assertion in Golang

The code shown below using type assertion to check the concrete type of an interface:

Explanation:

The variable checkInterface is interface{} type which means it can hold any type.
The concrete type that is assigned to the variable is string
If the type assertion is against the int type, running this program will produce a run-time error because we have wrong type assertion.

Example 2: Check Type Assertion status using ok comma idiom

The below example use ok comma idiom to check assertion is successful or not:

Example 3: Logging type assertion errors

We can modify the code in example 3 a little bit to log more information when type assertion has errors. One way is we use the printf format string %T that produces the type.

Example 4: Using Type Switch to determine type of interface

What happens when you do not know the data type before attempting a type assertion? How can you differentiate between the supported data types and the unsupported ones? How can you choose a different action for each supported data type?

The answer is by using type switches . Type switches use switch blocks for data types and allow you to differentiate between type assertion values, which are data types, and process each data type the way you want. On the other hand, in order to use the empty interface in type switches, you need to use type assertions.

In this example, we will use Switch key word to determine interface's type.

Create 2 interface: one contains a string and one contains a map
Use the .(type) function and Switch key word to compare the type of underlying interface's data

A type assertion is a mechanism for working with the underlying concrete value of an interface. This mainly happens because interfaces are virtual data types without their own values—interfaces just define behavior and do not hold data of their own.

Type assertions use the x.(T) notation, where x is an interface type and T is a type, and help you extract the value that is hidden behind the empty interface. For a type assertion to work, x should not be nil and the dynamic type of x should be identical to the T type.

https://pkg.go.dev/fmt

Tuan Nguyen

He is proficient in Golang, Python, Java, MongoDB, Selenium, Spring Boot, Kubernetes, Scrapy, API development, Docker, Data Scraping, PrimeFaces, Linux, Data Structures, and Data Mining. With expertise spanning these technologies, he develops robust solutions and implements efficient data processing and management strategies across various projects and platforms. You can connect with him on his LinkedIn profile.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

For any other feedbacks or questions you can send mail to [email protected]

Thank You for your support!!

Advisory boards aren’t only for executives. Join the LogRocket Content Advisory Board today →

Product Management
Solve User-Reported Issues
Find Issues Faster
Optimize Conversion and Adoption
Start Monitoring for Free

Type assertions vs. type conversions in Go

In this article, we will explore type assertion and type conversion operations in Go using some examples.

Type Assertions Vs. Type Conversions Golang

If you would like to run the snippets as you follow along, you’ll need:

To install Go — find a simple walkthrough here
A code editor, like Sublime Text , Visual Studio Code , or similar

What you’ll learn about type-casting in Go

Here are the major topics regarding type-casting in Go that you will learn about during the course of this article:

What is type assertion?

What is type conversion, type assertion in go, type conversion.

Type assertion (as the name implies) is used to assert the type of a given variable. In Go, this is done by checking the underlying type of an empty interface variable.

Type conversion is the process of changing a variable from one type to another specified type. For example, we can convert an int value to a float64.

In Go, the syntax for type assertions is t := i.(type) . Here is a snippet of a full type assertion operation:

The type assertion operation consists of three main elements:

i , which is the variable whose type we are asserting. This variable must be defined as an interface
type , which is the type we are asserting our variable is (such as string, int, float64, etc)
t , which is a variable that stores the value of our variable i , if our type assertion is correct

It should be further noted that when type assertions are unsuccessful, it throws an error referred to as a “panic” in Go.

From the above we can see that for a type assertion to be successful, we need to specify the correct type to begin with, but in several cases we might not be sure of the type and would like to prevent panics being thrown unnoticed in our scripts.

We can handle the uncertainty in type assertions in two ways, which we’ll look at now.

Second value from type assertion

The first option is by using a second variable on the left side of our type assertions. The type assertion can return two values; the first value (like t above, which is the value of the variable we are checking); and the second, which is a boolean indicator of whether the assertion succeeded.

Our second variable, ok , is a boolean value that holds whether our type assertion was correct or not. So, in our example above, ok would be true because i is of type string .

However, this method is only useful for validating an intuition of a variable’s type without a panic being thrown. If we are unsure of the type of a variable, we can use our second option, which is called Type switching.

Type switch

This is similar to a normal switch statement, which switches through possible types of a variable, rather than the normal switching of values. Here, we will extract the type from our interface variable and switch through several type options.

golang value in assignment need type assertion

Over 200k developers use LogRocket to create better digital experiences

Empty interface

As we mentioned earlier, type assertions in Go can only be performed on interfaces . You might ask, what is an interface, what is an empty interface, and how can it have a type? Well, let’s take a look.

An interface is a definition of the methods and attributes of a variable type. An empty interface is one where the attributes, methods, and the type are not specified until it is initialized.

For example:

Our test variable above is defined as an empty interface, but by assignment takes the type string . Type assertions are performed on interface variables to assert their underlying type.

We’ve talked about empty interfaces and how they get their type at initialization, but you may also be wondering what exactly type is.

Types in Go define how the variable is stored and what methods are available to the variable. In Go, there are basic types such as string, rune, int, and bool, which other types can be built on.

We’ve talked about what type is, now let’s talk about type conversion.

Type conversion is simply changing a value from one type to another, but in Go there is a caveat, which is that types can only be converted between related or similar types. Let’s look at an example:

In our example above, we have defined a type myString using the basic type string . This means that myString inherits the data structure of string , but we can give it its own methods that type string will not have, like the method capitalize in our example.

We can also see in our example that we were able to convert our type myString to string and convert string to myString . This is because they share similar data structures.

Stop guessing about your digital experience with LogRocket

Visualize JSON data with these popular tools

JSON is one of the most popular data structures in and out of web development and data handling because it’s […]

Supabase adoption guide: Overview, examples, and alternatives

Supabase offers comprehensive features that make it easy for frontend devs to build complex backends and focus on crafting exceptional UIs.

Resolving hydration mismatch errors in Next.js

Next.js is a popular React framework that uses server-side rendering (SSR) to build faster and SEO-friendly applications, resulting in a […]

Optimizing CSS time-based animations with new CSS functions

For a long time, the limited support for math functions made creating time-based CSS animations much more challenging. A traditional […]

Type Conversion and Type Assertion in Golang - Everything You Need to Know (With Examples)

If you just want to see the code, you can view all the examples on Github

Type Conversion #

Let’s look at a simple example to convert a []byte to a string type:

Compatible Types For Conversion #

Here, person and child have the same data structure, which is:

This just means that child is based on the same data structure as person (similar to our integer example before)

Type Conversion Between Basic Types #

Type conversion between interfaces #.

Interfaces work a bit differently than concrete types. An interface does not have an underlying data structure, but rather exposes a few methods of a pre-existing concrete type.

Type Assertion #

Type assertion to convert between interfaces #.

💡 To assert that a variable is of an interface type, the underlying variable must implement that interface. Otherwise, you will get a runtime error.

Type Conversion vs Type Assertion #

You can see all the working code from the examples in this post on Github

Type assertions and type switches

A type assertion provides access to an interface’s concrete value.

Type assertions

Type switches.

A type assertion doesn’t really convert an interface to another data type, but it provides access to an interface’s concrete value, which is typically what you want.

The type assertion x.(T) asserts that the concrete value stored in x is of type T , and that x is not nil.

If T is not an interface, it asserts that the dynamic type of x is identical to T .
If T is an interface, it asserts that the dynamic type of x implements T .

A type switch performs several type assertions in series and runs the first case with a matching type.

Type Assertions in Golang

Type assertions in Golang provide access to the exact type of variable of an interface. If already the data type is present in the interface, then it will retrieve the actual data type value held by the interface. A type assertion takes an interface value and extracts from it a value of the specified explicit type. Basically, it is used to remove the ambiguity from the interface variables.

where value is a variable whose type must be an interface, typeName is the concrete type we want to check and underlying typeName value is assigned to variable t .

In the above code, since the value interface does not hold an int type, the statement triggered panic and the type assertion fails. To check whether an interface value holds a specific type, it is possible for type assertion to return two values, the variable with typeName value and a boolean value that reports whether the assertion was successful or not. This is shown in the following example:

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Interfaces and type assertion

The book ‘Mastering Go - second edition’, has a variable declared as follows:

Can any one explain a bit more on how the variable declaration ‘myInt’ works here? My doubts are: in the above code ‘myInt’ is a variable of any type which gets type ‘int’ from the value 123. So myInt is still a variable and not an interface. Maybe its an int variable fulfilling the empty interface. But how does it works type assertion? To my understanding, myInt is not an interface just a variable. If I use int instead of interface{} at the variable declaration, the type assertion does not work. Complaining as non interface type on left.

Can anyone help me grasp this? Thank you!

Hi, @Indirajith_V ,

What I’ll call the “long way” to define a variable in Go is:

Variables can be an interface type (io.Reader, io.Writer, etc.) or a concrete type (int, string, struct { … }, etc.). The values that get assigned to variables are always concrete types. There is no such thing as an “interface value,” the values inside of an interface variable (or struct field, function return value, etc.) are either nil if the interface has not been assigned a value or a concrete type.

In your example above, myInt is a variable whose type is interface{} . The value on the right side of the assignment ( = ) statement is just a constant without a type ( 123 ). Because its explicit type cannot be deduced, Go gives the constant the default type of int (see https://golang.org/ref/spec#Constants for more info).

When the statement is executed, you end up with a variable, myInt whose type is interface{} and inside of that variable is an int with the value 123 .

Regarding the type assertion: That’s the way you take an interface value and try to extract its actual concrete value. The Go runtime will check at the time the program runs if the value inside of myInt is a concrete int value. If it is, k is assigned that value and ok is set to true .

Thank you verymuch @skillian for you detailed explnation. Now I understand it better.

This topic was automatically closed 90 days after the last reply. New replies are no longer allowed.

Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
OverflowAI GenAI features for Teams
OverflowAPI Train & fine-tune LLMs
Labs The future of collective knowledge sharing
About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Need type assertion on functions

I'm trying to learn type assertion and conversion. It's kinda complicated for me.

I have this example: (I'm using gin framework)

So, in the above code.. I'm setting db Env type and passing it to router functions. From there, I need to call another function. How to do that?

When I call e._GetUserId(email), it says

How to solve this problem?. Do I need to use inferface{} instead of struct for Env type?

1 Does session.Get("email") returns interface{} type? If yes then do type assertion for email parameter like this e._GetUserId(email.(string)) . – jeevatkm Commented Jun 17, 2017 at 3:57
@jeevatkm If that's the issue, wouldn't the error message say "cannot convert ... to type string "? – user94559 Commented Jun 17, 2017 at 3:58
I don't think the error message matches up with this code... nowhere that I can see is something called email used where an Env should be. – user94559 Commented Jun 17, 2017 at 3:59
1 @jeevatkm Wow that works! But when I check it with reflect.Typeof(session.Get("email")). It says string value. Why it takes as interface{} in the function argument? – rnk Commented Jun 17, 2017 at 3:59
@rnk You're welcome. reflect.Typeof method accepts any type that's why parameter is interface{} returns the actual type of the value. I will post an answer so you can accept it. – jeevatkm Commented Jun 17, 2017 at 4:09

Drafting answer based on conversation from my comments.

Method session.Get("email") returns interface{} type.

And method e._GetUserId() accepts string parameter, so you need to do type assertion as string like -

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged go go-gin or ask your own question .

Featured on Meta
We've made changes to our Terms of Service & Privacy Policy - July 2024
Bringing clarity to status tag usage on meta sites
Feedback requested: How do you use tag hover descriptions for curating and do...

Hot Network Questions

How to allow just one user to use SSH?
What is the origin and meaning of the phrase “wear the brown helmet”?
bin.usr-is-merged, lib.usr-is-merged, sbin.usr-is-merged - what are the folders?
Is there a source for there being a Psalm inscribed on King David's shield?
How to read data from Philips P2000C over its serial port to a modern computer?
Fitting the 9th piece into the pizza box
Unreachable statement when upgrading APEX class version
Is my encryption format secure?
MOSFETs keep shorting way below rated current
How did Jason Bourne know the garbage man isn't CIA?
Sci-fi book with a part-human, part-machine protagonist who lives for centuries to witness robots gain sentience and wage war on humans
They come in twos
Kyoto is a famous tourist destination/area/site/spot in Japan
Why did R Yochanan say 'We' when he Refuted Reish Lakish on his own?
Uneven Spacing with Consecutive Math Environments
How predictable are the voting records of members of the US legislative branch?
Genus 0 curves on surfaces and the abc conjecture
On airplanes with bleed air anti-ice systems, why is only the leading edge of the wing heated? What happens in freezing rain?
Why do these finite group Dedekind matrices seem to have integer spectrum when specialized to the order of group elements?
Is there a way to say "wink wink" or "nudge nudge" in German?
Elements of finite order in the group of invertible affine transformations
In compound nouns is there a way to distinguish which is the subject or the object?
are "lie low" and "keep a low profile" interchangeable?
Specify geo location of web pages (each is different)

IMAGES

Golang Variables Declaration, Assignment and Scope Tutorial
Type Conversion and Type Assertion in Golang
Convert Interface to Type: Type Assertion · GolangCode
Golang Type Assertion. Using interfaces to determine behavior
#34: Type Assertions
GoLang类型断言使用汇总（type assertion）

COMMENTS

cannot convert data (type interface {}) to type string: need type assertion
Type Assertion. This is known as type assertion in golang, and it is a common practice. Here is the explanation from a tour of go: A type assertion provides access to an interface value's underlying concrete value. t := i.(T) This statement asserts that the interface value i holds the concrete type T and assigns the underlying T value to the ...
Cannot use (type interface {}) as type int in assignment: need type
A type assertion does not impact the object you are asserting on. Instead, it returns the value stored in the interface alongside a success bool. This means that you need to save this returned value and use it. In your case, change your type assertion to the following: if res, ok := input[0].(int); ok {. tree.Val = res.
Idiomatic way to do conversion/type assertion on multiple return values
In my case though I already know what type is stored in the interface, so I skipped the check. I even thought about using an unsafe.Pointer instead of interface{}, but I guessed there is not enough overhead in the type assertion justifying the use of unsafe pointers. -
Golang Type Assertions (With Examples)
Avoiding panic in Type Assertions in Go. In Go, the type assertion statement actually returns a boolean value along with the interface value. For example, var a interface {} a = 12. interfaceValue := a.(int) Here, the data type of value 12 matches with the specified type (int), so this code assigns the value of a to interfaceValue.
Mastering Type Assertion in Go: A Comprehensive Guide
Mar 3, 2023. 1. In Go programming language, assertion is a mechanism to check the dynamic type of a value during runtime. It is used to ensure that the value of a variable conforms to a certain ...
Mastering Type Assertions in Golang: A Comprehensive Guide
Basic Syntax of Type Assertion The basic syntax of a type assertion is as follows: value, ok := x.(T) Here, x is a variable of interface type, and T is the desired type for the assertion. value will hold the value of x converted to type T, and ok is a boolean indicating the success of the type assertion.
Type assertions in Golang
Type-assertions are useful to remove the ambiguity from interface variables. It helps unwrap the concrete value inside an interface variable. Type assertions in Go help access the underlying type of an interface and remove ambiguity from an interface variable. In this post, we will get a closer look.
Golang Type Assertion Explained with Examples
Golang type assertion is a mechanism for working with the underlying concrete value of an interface. Type switches use switch blocks for data types and allow you to differentiate between type assertion values, which are data types, and process each data type the way you want. On the other hand, in order to use the empty interface in type switches, you need to use type assertions.
Type assertions vs. type conversions in Go
Type conversion is the process of changing a variable from one type to another specified type. For example, we can convert an int value to a float64. Type assertion in Go. In Go, the syntax for type assertions is t := i.(type). Here is a snippet of a full type assertion operation:
Type Conversion and Type Assertion in Golang
Type conversion is used to convert between two types that have the same underlying data structure. Whereas, type assertion is used to convert between interfaces, or to convert an interface to a concrete type. During type assertion, the underlying concrete type of the variable does not change.
Golang Type Assertion
Here, the str variable is of type StringSelecter which is an interface that has two methods, String(), and Validate().. There is also a type called MyString and its concrete type is a string.This type has two value receiver methods, String(), and Validate().This infers that this type satisfies the StringSelecter interface.. In line 12, the type of the str variable is printed.
Cannot use word (type interface {}) as type string in assignment: need
Cannot use word (type interface {}) as type string in assignment: need type assertion. resp.Values is an array of arrays, all of which are populated with strings. ... Type assertion failed with correct casting from interface{} in golang. 1. Type assertion failed when using two different (but identical) types. 1. Type assertion and interfaces. 0.
Type assertions and type switches · YourBasic Go
Type assertions; Type switches; Type assertions. A type assertion doesn't really convert an interface to another data type, but it provides access to an interface's concrete value, which is typically what you want.. The type assertion x.(T) asserts that the concrete value stored in x is of type T, and that x is not nil.. If T is not an interface, it asserts that the dynamic type of x is ...
Type assertions in Go
Type assertions are used to check if value held by interface type variable either implements desired interface or is of a concrete type. Syntax of type assertion is defined as: PrimaryExpression .(
Interfaces in Go (part II). Type assertion & type switch
Golang allows to also pass interface type. It checks if the dynamic value satisfies desired interface and returns value of such interface type value. In contract to conversion, method set of ...
Interface ERROR: need type assertion
Why do I get "need type assertion" error? [EDIT] Searching a bit more on Google I found the solution and this was adding ".(TYPE)" at the end of the function call, in my situation ".(string)";
Type Assertions in Golang
A type assertion takes an interface value and extracts from it a value of the specified explicit type. Basically, it is used to remove the ambiguity from the interface variables. Syntax: where value is a variable whose type must be an interface, typeName is the concrete type we want to check and underlying typeName value is assigned to variable t.
Interfaces and type assertion
Regarding the type assertion: That's the way you take an interface value and try to extract its actual concrete value. The Go runtime will check at the time the program runs if the value inside of myInt is a concrete int value. If it is, k is assigned that value and ok is set to true. 4 Likes.
A Tour of Go
Type assertions. A type assertion provides access to an interface value's underlying concrete value.. t := i.(T) This statement asserts that the interface value i holds the concrete type T and assigns the underlying T value to the variable t.. If i does not hold a T, the statement will trigger a panic.. To test whether an interface value holds a specific type, a type assertion can return two ...
Cannot use type assertion on type parameter value
The Go (revised 1.18) language spec explicitly states type parameters are not allowed in a type assertion: For an expression x of interface type, but not a type parameter, and a type T ... the notation x.(T) is called a type assertion. Also from from the generics tutorial on why parameter types need to be resolved at compile-time:
GoLang类型断言使用汇总（type assertion）我正在参与掘金创作者训练营第6期，点击了解活动详情为什么要
为什么要有类型断言(type assertion) GoLang中的 interface{}即 any可以代表所有类型，包括基本类型string、int、int64，以及自定义的 struct类型。. interface{}好比 java中的 Object，java中的所有类都实现了Object。. 下面这个函数接收一个 interface{}的参数，就代表了它可以传递任何 ...
go
7. Drafting answer based on conversation from my comments. Method session.Get("email") returns interface{} type. And method e._GetUserId() accepts string parameter, so you need to do type assertion as string like -. e._GetUserId(email.(string)) answered Jun 17, 2017 at 4:13.

Popular Tutorials