golang multi variable assignment

Go Tutorial

Go exercises, go multiple variable declaration.

In Go, it is possible to declare multiple variables in the same line.

This example shows how to declare multiple variables in the same line:

Note: If you use the type keyword, it is only possible to declare one type of variable per line.

If the type keyword is not specified, you can declare different types of variables in the same line:

Go Variable Declaration in a Block

Multiple variable declarations can also be grouped together into a block for greater readability:

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• Getting started with Go
• Awesome Book
• Awesome Community
• Awesome Course
• Awesome Tutorial
• Awesome YouTube
• Base64 Encoding
• Best practices on project structure
• Build Constraints
• Concurrency
• Console I/O
• Cross Compilation
• Cryptography
• Developing for Multiple Platforms with Conditional Compiling
• Error Handling
• Executing Commands
• Getting Started With Go Using Atom
• HTTP Client
• HTTP Server
• Inline Expansion
• Installation
• JWT Authorization in Go
• Memory pooling
• Object Oriented Programming
• Panic and Recover
• Parsing Command Line Arguments And Flags
• Parsing CSV files
• Profiling using go tool pprof
• Protobuf in Go
• Select and Channels
• Send/receive emails
• Text + HTML Templating
• The Go Command
• Type conversions
• Basic Variable Declaration
• Blank Identifier
• Checking a variable's type
• Multiple Variable Assignment
• Worker Pools
• Zero values

Go Variables Multiple Variable Assignment

Fastest entity framework extensions.

In Go, you can declare multiple variables at the same time.

If a function returns multiple values, you can also assign values to variables based on the function's return values.

Got any Go Question?

• Advertise with us
• Cookie Policy
• Privacy Policy

Get monthly updates about new articles, cheatsheets, and tricks.

This is the third tutorial in our Golang tutorial series and it deals with variables in Golang.

You can read part 2 to learn about configuring Go and running the hello world program.

What is a variable?

Variable is the name given to a memory location to store a value of a specific type . There are various syntaxes to declare variables in Go. Let’s look at them one by one.

Declaring a single variable

var name type is the syntax to declare a single variable.

Run in playground

The statement var age int declares a variable named age of type int . We have not assigned any value to this variable. If a variable is not assigned any value, Go automatically initializes it with the zero value of the variable’s type. In this case, age is assigned the value 0 , which is the zero value of int . If you run this program, you can see the following output.

A variable can be assigned to any value of its type. In the above program, age can be assigned any integer value.

The above program will print the following output.

Declaring a variable with an initial value

A variable can also be initialized with a value when it is declared. The following is the syntax to declare a variable with an initial value.

In the above program, age is a variable of type int and has initial value 29 . The above program will print the following output.

It confirms that age has been initialized with the value 29.

Type inference

If a variable has an initial value, Go will automatically be able to infer the type of that variable using that initial value. Hence if a variable has an initial value, the type in the variable declaration can be removed.

If the variable is declared using the following syntax

Go will automatically infer the type of that variable from the initial value.

In the following example, we can see that the type int of the variable age has been removed in line no. 6. Since the variable has an initial value 29 , Go can infer that it is of type int .

Multiple variable declaration

Multiple variables can be declared using a single statement.

var name1, name2 type = initialvalue1, initialvalue2 is the syntax for multiple variable declaration.

The type can be removed if the variables have an initial value. Since the above program has initial values for variables, the int type can be removed.

The above program will print

As you would have probably guessed by now, if the initial value is not specified for price and quantity , they will have 0 assigned as their initial value.

There might be cases where we would want to declare variables belonging to different types in a single statement. The syntax for doing that is

The following program uses the above syntax to declare variables of different types.

Here we declare a variable name of type string , age and height of type int . (We will discuss the various types available in Golang in the next tutorial ).

Running the above program will print

Short hand declaration

Go also provides another concise way to declare variables. This is known as short hand declaration and it uses := operator.

name := initialvalue is the short hand syntax to declare a variable.

The following program uses the short hand syntax to declare a variable count initialized to 10 . Go will automatically infer that count is of type int since it has been initialized with the integer value 10 .

The above program will print,

It is also possible to declare multiple variables in a single line using short hand syntax.

The above program declares two variables name and age of type string and int respectively.

If you run the above program, you can see

getting printed.

Short hand declaration requires initial values for all variables on the left-hand side of the assignment. The following program will print an error assignment mismatch: 2 variables but 1 value . This is because age has not been assigned a value.

Short hand syntax can only be used when at least one of the variables on the left side of := is newly declared. Consider the following program,

In the above program, in line no. 8, b has already been declared but c is newly declared and hence it works and outputs

Whereas if we run the program below,

it will print error ./prog.go:8:7: no new variables on left side of := This is because both the variables a and b have already been declared and there are no new variables in the left side of := in line no. 8

Variables can also be assigned values which are computed during run time. Consider the following program,

In the above program math is a package and Min is a function in that package. Don’t worry about it right now, we will discuss packages and functions in detail in the upcoming tutorials. All we need to know is, the value of c is calculated at run time and it’s the minimum of a and b . The program above will print,

Since Go is strongly typed, variables declared as belonging to one type cannot be assigned a value of another type. The following program will print an error cannot use "Naveen" (untyped string constant) as int value in assignment because age is declared as type int and we are trying to assign a string value to it.

Thanks for reading. Please post your feedback and queries in the comments section. Please consider sharing this tutorial on twitter or LinkedIn . Have a good day.

Next tutorial - Types

• TutorialKart
• SAP Tutorials
• Salesforce Admin
• Salesforce Developer
• Visualforce
• Informatica
• Kafka Tutorial
• Spark Tutorial
• Tomcat Tutorial
• Python Tkinter

Programming

• Bash Script
• Julia Tutorial
• CouchDB Tutorial
• MongoDB Tutorial
• PostgreSQL Tutorial
• Android Compose
• Flutter Tutorial
• Kotlin Android

Web & Server

• Selenium Java
• Golang Tutorial
• Run Golang Program
• Golang Comments
• Golang – Initialize Multiple Variables in Single Line
• Golang – Constants
• Golang – If
• Golang If Else
• ADVERTISEMENT
• Golang Switch
• Golang – For Loop
• Golang – Break
• Golang – Continue
• Golang – Goto
• Golang For Each
• Golang – Factorial using For loop
• Golang – Addition Operator
• Golang – Subtraction Operator
• Golang – Multiplication Operator
• Golang – Division Operator
• Golang – Remainder Operator
• Golang – Increment Operator
• Golang – Decrement Operator
• Golang Functions
• Golang – String length
• Golang – String concatenation
• Golang – Check if strings are equal
• Golang – Compare strings
• Golang – Check if string contains substring
• Golang – Check if string starts with a specific substring
• Golang – Check if String ends with a specific substring
• Golang – Count occurrences of substring
• Golang – Find index of last occurrence of substring
• Golang – Get index of a substring
• Golang – Join/Concatenate string and integer
• Golang – Replace substring in string
• Golang – Split string
• Golang – String to uppercase
• Golang – String to lowercase
• Golang – Trim spaces around string
• Golang – Convert string to integer
• Golang – Convert string to float
• Golang – Convert int to string
• Golang – Convert string into array of characters
• Golang – Array Length
• Golang – Create String Array
• Golang – Create Integer Array
• Golang – Iterate over Array using For Loop
• Golang – Check if Specific Element is present in Array
• Golang Slice
• Golang – Slice Length
• Golang – Iterate over Slice using For Loop
• Golang – Check if Specific Element is present in Slice
• Golang – Sort Slice of Strings
• Golang – Sort Slice of Integers
• Golang Struct
• Golang Class
• Golang – Iterate over Range using For Loop
• Golang – Create empty Map
• Golang – Map length
• Golang – Iterate over Map
• Golang – Update key in Map
• Golang – Nested Maps
• Golang – Check if specific key is present in Map
• Golang – Convert Map to JSON
• Golang – Convert JSON to Map
• Golang Goroutine
• Golang Channel
• ❯ Golang Tutorial
• ❯ Golang – Datatypes
• ❯ Golang – Initialize Multiple Variables in Single Line

Initialize multiple Variables in Single Line in Golang

Initialize multiple variables in single line.

To assign/initialize multiple Variables in a single line, specify the variables as comma separated on the left side of assignment operator, and the comma separated values on the right side of assignment operator.

In this tutorial, we will learn how to initialize multiple variables in a single line, with examples covering different scenarios based on number of variables assigned, and datatype of variables.

Assign Two Variables

In the following example, we will assign two variables, x and y , in a single statement with integer values.

Assign Different Datatypes

Now, let us assign an integer and a string to variables in a single line.

Assign Four Variables

In this Golang Tutorial , we learned how to initialize multiple variables in a single line in Go language, with the help of example programs.

Popular Courses by TutorialKart

App developement, web development, online tools.

How to Declare Multiple variables in Golang with examples

• Dec 31, 2023

Some programming languages allow you to declare multiple variables with a single line.

This post shows you how to declare multiple variables.

In Golang, Variables are declared as follows

# How to declare multiple variables of the same type in Golang?

Is it possible to declare multiple variables in Golang?

Yes, It is possible to declare multiple variables of the same type in a single statement.

Here is a declaration syntax for multiple variables.

Three variables are declared v1,v2, and v3 with string type.

# How to declare multiple variables of a different type in Golang?

And It gives an error to declare multiple variables of different types with the type declaration.

You can also declare and assign variables

Here is code to declare and assign multiple variables.

The above type is removed because of the initial value.

You can declare and assign multipe variables of different types.

# Conclusion

In golang, You can declare multiple variables of the same type, does not accept multiple variables of different types with the type declaration.

Still, you can declare multiple variables of different types with an initial value, without type.

Simplifying variable scope in Golang [Practical Examples]

December 31, 2023

Understanding variables in Go

A variable is a symbolic name or identifier used to store or hold values of a different data type and an associated name. A variable name to reference the values stored within a program. Specific Data type in Go includes string , integer, Boolean, float, array, slice, interface, and maps. A data type is a set of values and allowable operands on those values. In Golang , we can infer the data type from the right side of the assignment.

Variable naming styles and rules followed in Go

The naming of variables is so flexible, but there are some styles and rules to keep in mind:-

• Variable names must only be one word (as in no spaces). example of valid naming:- userName , userAge , userEmail
• Variable names must be made up of only letters, numbers, and underscores (_). e.g user_Name
• Variable name terms cannot begin with a number. e.g userName1

Different ways to declare variables in Go

In Go, we can declare a variable in two ways which include:-

• Using var keyword variable declaration
• Using := shorthand variable declaration

Method-1: Using var keyword variable declaration

The most explicit way of declaring any variable is by using var keyword, for example

If the type on the righthand side of the  =  is the expected type of your variable, you can leave off the type from the left side of the  = . Since the default type of an integer literal is  int , the following declares x to be a variable of type  int :

If you want to declare a variable and assign it the zero value, you can keep the type and drop the = on the righthand side:

You can declare multiple variables at once with  var , and they can be of the same type:

all zero values of the same type:

or of different types:

There’s one more way to use var. If you are declaring multiple variables at once, you can wrap them in a declaration list:

Method-2: Using := shorthand variable declaration

Go also supports a short declaration format. When you are within a function, you can use the  :=  operator to replace a  var  declaration that uses type inference. The following two statements do exactly the same thing: they declare x to be an int with the value of 10:

Like var, you can declare multiple variables at once using :=. These two lines both assign 10 to x and “hello” to y:

The := operator can do one trick that you cannot do with var: it allows you to assign values to existing variables, too. As long as there is one new variable on the lefthand side of the :=, then any of the other variables can already exist:

There is one limitation on := . If you are declaring a variable at package level, you must use var because := is not legal outside of functions.

See the following example below.

The example above shows two (name and age) variables declared using shorthand notation.

Variable scope definition in Go

Variable scope refers to the particular places it is accessible from within the function or block level, a package of a given program. A package-level variable is defined outside of any function in a program. It is accessible throughout the package and can only be of var declaration since the shorthand := operator is not being available outside the function. The scope of the variable is determined during compilation time. Variables can be called within the block of code in which it is defined.

In Golang scope of variables can be divided into two categories which depend on where the variables are declared:

• Local variables (Declared inside a block or function)
• Global variables (Declared outside a block or function)

Local variables

• It's also known as block variables.
• These are variables declared inside a function or a block , thus the variable is not accessible outside the function or block.
• These variables can also be declared inside the for loop inside a function.
• There will be a compile-time error if these variables are declared twice with the same name in the same scope.
• These variables can be accessed by the nested code blocks inside a function.
• These variables don’t exist after the function’s execution is over.
• A variable that is declared inside a loop body will not be visible to the outside of the loop body.
• The variable which is declared outside the loop is also accessible within the nested loops.
• The local variable will be accessible to loop and function inside that function.

Example of a local variable scope:

Explanation:- The sum variable is local to the add() function, so it can only be accessed within the function. That’s why we get an error when we try to access the function from the main() . To fix this issue, we can either return the value of the local variable or assign it to another variable inside the main function. Or we can make the variable sum global.

Local variable source code from go playground

Global variables

• The global variables are defined outside of the function in the go program.
• Functions can be accessing these variables anywhere in the go program.
• The variables are accessible by all functions defined in the go program.
• In a nested function is declared, then the parent function's local variable will act as a global variable for his child's function.
• If the global variable and local variable have the same name within a function in the go program. Still, in this case, the function will prioritize his local variable over the global variable and perform all operations on his local variable's value.
• These are declared at top of the program outside all functions or blocks.
• These can be accessed from any portion of the program.
• These are available throughout the lifetime of a program means they will exist at the end of the execution process of the go program.

Example of a global variable scope

Explanation:- Since we have declared sum as global variable using var keyword, we can access the sum variable from inside the main() function. Although you may notice that we have just declared the type of var sum while the actual value assignment is happening inside func add but still var sum will be considered as global variable.

global variable source code from go playground

"var" vs ":-" in golang and when to use them in your code?

• When initializing a variable to its zero value, use  var x int . This makes it clear that the zero value is intended.
• When assigning an untyped constant or a literal to a variable and the default type for the constant or literal isn’t the type you want for the variable, use the long  var  form with the type specified. While it is legal to use a type conversion to specify the type of the value and use  :=  to write  x := byte(20) , it is idiomatic to write  var x byte = 20 .
• Because  := allows you to assign to both new and existing variables, it sometimes creates new variables when you think you are reusing existing ones. In those situations, explicitly declare all of your new variables with var to make it clear which variables are new, and then use the assignment operator ( = ) to assign values to both new and old variables.
• The case and default keywords also introduce a new scope even though no curly braces are involved.
• The location where a variable is declared determines which variable scope it’s in.
• An opening curly brace { introduces a new scope that ends with a closing brace }.
• Variables declared on the same line as a for, if, or switch is in scope until the end of that statement.
• A wide variable scope is better than a narrow scope in some situations—and vice versa.
• A variable declared within an inner scope having the same name as the variable declared in the outer scope will shadow the variable in the outer scope.

variable scope in golang scope-of-variable-go

Deepak Prasad

He is the founder of GoLinuxCloud and brings over a decade of expertise in Linux, Python, Go, Laravel, DevOps, Kubernetes, Git, Shell scripting, OpenShift, AWS, Networking, and Security. With extensive experience, he excels in various domains, from development to DevOps, Networking, and Security, ensuring robust and efficient solutions for diverse projects. 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!!

Leave a Comment Cancel reply

Save my name and email in this browser for the next time I comment.

Notify me via e-mail if anyone answers my comment.

We try to offer easy-to-follow guides and tips on various topics such as Linux, Cloud Computing, Programming Languages, Ethical Hacking and much more.

Recent Comments

Popular posts, 7 tools to detect memory leaks with examples, 100+ linux commands cheat sheet & examples, tutorial: beginners guide on linux memory management, top 15 tools to monitor disk io performance with examples, overview on different disk types and disk interface types, 6 ssh authentication methods to secure connection (sshd_config), how to check security updates list & perform linux patch management rhel 6/7/8, 8 ways to prevent brute force ssh attacks in linux (centos/rhel 7).

Privacy Policy

HTML Sitemap

Go by Example : Multiple Return Values

Next example: Variadic Functions .

by Mark McGranaghan and Eli Bendersky | source | license

Working with Variables in Go

Can you program without variables? Maybe in some esoteric languages, but in Go, you can’t. So it’s important to get acquainted with how variables work in the language so that you can write effective programs. And that’s what this article is all about.

Variables are an essential component of Go programs. A variable is a name given to a location in memory where some data is stored. Each variable also has a data type ( string , int , bool e.t.c.) associated with it.

To write good Go programs, you need to learn the idiomatic way of working with variables in the language, so that’s what this tutorial will cover. You can run the code snippets presented on this page in the Go playground , or locally on your computer if you prefer.

Naming conventions

Before we discuss how variables are created in Go, let’s look at the naming conventions that you should be aware of. A name in Go begins with a Unicode letter or an underscore, followed by any number of additional letters, digits and underscores. Names are also case sensitive in Go, so fetchNews and fetchnews are different names.

The convention in Go is to use camelCase for names, and Go programmers tend to lean towards short names especially if the scope of the variable is small, although there is no limit for how long a name could be. Go also has 25 keywords such as var and func which cannot be used as identifiers in the language.

How to create variables in Go

The snippet below shows the two main ways of creating variables in Go:

We have a variable hello that is declared using the var keyword and it is assigned the string “Hello” and a second variable world declared using the short variable declaration syntax and is assigned the string “world!”. The fmt.Println() method subsequently prints the text “Hello world!” to the standard output.

There are some differences between these two ways of creating variables in Go. Let’s talk about the var keyword first.

var declarations

A var declaration has the general form shown below:

Either the type or the expression may be omitted, but not both at the same time. As you’ve already seen, the hello variable declared in the previous section omits the type but includes the expression. In the case where the type is omitted from the declaration, it would be inferred from the expression. This is known as type inference and it makes it easy to declare a variable without having to explicitly annotate its type.

Here are a some examples:

It’s also possible to declare multiple variables using a single var declaration as shown below:

Zero values

Go allows you to create variables without explicitly initialising them to a value. In this case, the type of the variable must be present.

If you’re declaring multiple variables that are all of the same type without initialising them, you can use the syntax below:

When the expression part of a variable declaration is omitted, the variable will be assigned the zero value for that type which is 0 for number types, an empty string ("") for strings, false for booleans, and nil for interfaces and pointers.

Here’s an example that demonstrates this concept:

This concept of zero values has an important implication that you must be aware of: there is nothing like an uninitialised variable in Go . A variable will always contain a value, either the one you assigned to it, or an implicitly assigned zero value for its type. This behaviour exempts Go programmers from dealing with the uninitialised variable problem that exists in other programming languages.

Short variable declaration

The second type of variable declaration in Go is called the short variable declaration using the := operator. This is the way the majority of variables are declared in Go due to its terse syntax.

Just like var declarations, multiple short variable declarations can be made in a single line:

Unlike var declarations, there is no implicit assignment to zero values when using the short variable declaration syntax, and you cannot annotate the type of the variable; it is always inferred from the expression on the right-hand side.

Variable assignment

You can assign to an already declared variable using the = operator. All variables are mutable in Go, but the type associated with a variable cannot be changed after declaration.

You can also assign to several variables at once using another form called tuple assignment . The right-hand side expression is evaluated before any left-hand side variables are updated.

When using this tuple assignment style to assign variables to a function’s return values, the number of variables must match the number of return values.

Variable scope

A variable in Go can be declared either at package or block level. A package-level variable is one that appears outside of any function. It is accessible throughout the package and can only be a var declaration due to the := operator not being available outside functions.

On the other hand, a block-level variable is one that is declared inside a block such as inside a function, for loop, if block, or even a standalone block. The idiomatic way to declare block-level variables is by using the short variable declaration syntax.

Here’s an example that denotes both package-level, and block-level variable declarations:

If you’ve worked with a lexically scoped programming language before, this behavior should be familiar to you. Aside from explicit blocks that are clearly defined with a matching pair of curly braces, Go has a few implicit blocks that you should be aware of. For example, each clause in a switch or select statement is also an implicit block even though curly braces are not present:

Another example is in if statements. This is one you are likely to encounter more frequently in Go programs:

As an aside, the var declaration syntax may also be used to declare a block-level variables, but it’s typically only used when you want to initialise a variable to its zero value, then assign to it later.

Shadowing is a feature in Go that allows you to declare a variable in one block, and declare another variable with the same name in an inner block. Here’s an example:

The first str variable declared in the main function is assigned the string value “world”. In an inner block, a second str variable is declared and assigned the string value of “hello”. Whenever you access the str variable in the inner block, it will always refer to the inner declaration. So we say that the first str variable is shadowed by the second.

Note that the inner str does not affect the outer str in any way. In fact, the inner variable does not have to be of the same type as the outer one because they are actually completely different from each other. They just happen to share the same name. Keep in mind that due to this behaviour you will not be able to access the outer str from the inner block unless you change its name.

Variable shadowing does not apply if you attempt to redeclare a variable within the same block. The program will fail to compile:

However, the program below will compile and run just fine.

Although it appears as if the a and b variables are being redeclared on the second line of the main function, that’s actually not the case. What happens here is that only the c variable is declared while the other two are assigned to. This reason is that the := operator does always declare all the variables on its left-hand side.

At least one new variable needs to be present when using the short declaration syntax for this to work though. If we remove the c variable declaration from the above snippet, the code will fail to compile as before:

In this article, you learned how to create and assign variables in Go, what zero values are and how variable scoping and shadowing work in the language. Now that you’ve explored how variables work, the next article will look at the data types they can have.

Thanks for reading, and happy coding!

Short Variable Declaration (:= Operator) in Golang

The usage of variables is essential in any programming language. In this post, we will use the shorthand syntax of declaring variables in Go.

Variable declarations in Go

There are multiple ways of declaring variables . The shorthand syntax allows us to declare and initialize the variable both at the same time. This not only reduces code but creates concise syntax. First, let’s see the regular syntax of declaring variables.

var variableName variableType

Now, we can assign a value to it of type variableType .

The shorthand syntax merges two steps into one. Below is the syntax.

variableName := initialValueOfTheVariable

The operator above ( := ) is called the short declaration operator.

Type inferencing

After declaring a variable with the short declaration syntax the variable gets a type. So, if it is reassigned to another type then it throws an error.

The variable type gets inferred by the Go compiler after the declaration happens so it cannot be reassigned with a new type.

Declaring multiple variables

Multiple variables can be declared using the shorthand syntax of variable declaration. To declare multiple variables, the order should be maintained on both sides of the operator. The declaration below shows that.

var1, var2, var3, ... := value1, value2, value3, ...

Declaring functions

Functions can be declared with the same short syntax as well. Go has great support for functions and allows support anonymous functions in Go code. The code below shows how to declare functions using the shorthand syntax.

Advantages of short declaration

The short declaration of variables has some advantages. It enables the code to be short and concise. Also, it stops assigning wrong types to a variable.

A function can return multiple values in Go. So, in that case, multiple assignments can be made easily. Error handling is a use case of this particular type.

Drawbacks of short declaration

The short declaration has some drawbacks also. It cannot be used in the Global scope. It must be inside a function. To declare outside the function scope var, const, func must be used accordingly.

Go Wiki: Switch

Spec: https://go.dev/ref/spec#Switch_statements

Go’s switch statements are pretty neat. For one thing, you don’t need to break at the end of each case.

src/pkg/html/escape.go

Not just integers

Switches work on values of any type.

Missing expression

In fact, you don’t need to switch on anything at all. A switch with no value means “switch true”, making it a cleaner version of an if-else chain, as in this example from Effective Go:

Go’s switch statements break implicitly, but break is still useful:

Fall through

To fall through to a subsequent case, use the fallthrough keyword:

Another example:

src/pkg/encoding/ascii85/ascii85.go

The ‘fallthrough’ must be the last thing in the case; you can’t write something like

However, you can work around this by using a ’labeled’ fallthrough :

Note: fallthrough does not work in type switch.

Multiple cases

If you want to use multiple values in the same case, use a comma-separated list.

Type switch

With a type switch you can switch on the type of an interface value (only):

You can also declare a variable and it will have the type of each case :

Sometimes it useful to have cases that require no action. This can look confusing, because it can appear that both the noop case and the subsequent case have the same action, but isn’t so.

This content is part of the Go Wiki .