short assignment golang

Go Tutorial

Go exercises, go assignment operators, assignment operators.

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator ( = ) to assign the value 10 to a variable called x :

The addition assignment operator ( += ) adds a value to a variable:

A list of all assignment operators:

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.

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.

• 07 Condition - if/else
• 08 For Loops
• 09 Function
• 10 Packages

Shorthand Declaration Of Variables. ¶

Objective ¶.

Learn how to declare variables using the shorthand method.

Declaration ¶

Go ships with a smart compiler, it can detect the data type and automatically assign it to variables, using short declaration is very widely used in Go, with this method you can create variables on the fly, no need for prior declaration.

General syntax

It is also called as inference type declaration, meaning that the variable type is "inferred" from the value. This method offers various benefits such as compiler can choose the right data type and much more which we will explore as we write more code.

Structure ¶

Navigate to our code folder

For our program create a new folder '06_shorthand_declaration'

And lets create a file 'shorthand_declaration.go' in it, finally the structure would look like this:

Code ¶

Code review ¶.

On line 6, 10 & 14 we declare a new variable

To check the data type we use a special format output function

Note, in the earlier examples we had used

On line 7, 11 & 15, we print out the data type, to check the data type we use a special character "%T", which acts as a placeholder and represent the data "Type", it is followed by the variable name.

If you don't understand the print statements, no worries, we will be having a dedicated section on formatting output, for now type everything as in the code above and make sure it runs.

Run Code ¶

Open your terminal and navigate to our folder

Once in the folder type the following command

Output ¶

Github ¶.

Just in case you have some errors with your code, you can check out the code at github repo

Github Repo

Golang Playground ¶

You can also run the code at playground

Golang Playground

Next ¶

In the next chapter we will see about if/else condition, don't worry if its becoming too geeky, keep up with the code and in no time you will get the hang of it.

Please Donate ❤️ ¶

All the work is provided free of cost and completely open source, but it needs your support and love to keep the activity sustainable.

Any support is genuinely appreciated, you can help by sending a small donation by clicking the below link:

• Data Types in Go
• Go Keywords
• Go Control Flow
• Go Functions
• GoLang Structures
• GoLang Arrays
• GoLang Strings
• GoLang Pointers
• GoLang Interface
• GoLang Concurrency

Short Variable Declaration Operator(:=) in Go

• Difference between var keyword and short declaration operator in Golang
• How to print struct variables data in Golang?
• Printing Struct Variables in Golang
• How to declare and access pointer variable in Golang?
• Different Ways to Find the Type of Variable in Golang
• Scope of Variables in Go
• Printing structure variables in console in Golang
• Golang Program that uses func as Local Variable
• Converting a string variable into Boolean, Integer or Float type in Golang
• Golang program that uses func with variable argument list
• Different Ways to Convert an Integer Variable to String in Golang
• Naming the Return Values of a Function in Golang
• Variadic Functions in Go
• Returning Pointer from a Function in Go
• How to sort a slice stable in Golang?
• reflect.PtrTo() Function in Golang with Examples
• Function that takes an interface type as value and pointer in Golang
• Function Returning Multiple Values in Go Language
• How to use strconv.IsPrint() Function in Golang?

Short Variable Declaration Operator(:=) in Golang is used to create the variables having a proper name and initial value. The main purpose of using this operator to declare and initialize the local variables inside the functions and to narrowing the scope of the variables. The type of the variable is determined by the type of the expression. var keyword is also used to create the variables of a specific type. So you can say that there are two ways to create the variables in Golang as follows:

• Using the var keyword
• Using the short variable declaration operator(:=)

In this article, we will only discuss the short variable declaration operator. To know about var keyword you can refer var keyword in Go . You can also read the difference between var keyword and short variable declaration operator to get a proper idea of using both.

Syntax of using short variable declaration operator:  

Here, you must initialize the variable just after declaration. But using var keyword you can avoid initialization at the time of declaration. There is no need to mention the type of the variable . Expression or value on the right-hand side is used to evaluate the type of the variable.

Example: Here, we are declaring the variables using short declaration operator and we are not specifying the type of the variable. The type of the variable is determined by the type of the expression on the right-hand side of := operator. 

Declaring Multiple Variables Using Short Declaration Operator (:=)

Short Declaration operator can also be used to declare multiple variables of the same type or different types in the single declaration. The type of these variables is evaluated by the expression on the right-hand side of := operator. 

Example:  

Important Points:  

• Short declaration operator can be used when at least one of the variable in the left-hand side of := operator is newly declared. A short variable declaration operator behaves like an assignment for those variables which are already declared in the same lexical block. To get a better idea about this concept, let’s take an example. Example 1: Below program will give an error as there are no new variables in the left-hand side of the := operator .

./prog.go:17:10: no new variables on left side of :=   

Example 2: In the below program, you can see that the line of code geek3, geek2 := 456, 200 will work fine without any error as there is at least a new variable i.e. geek3 on the left-hand side of := operator.

• Go is a strongly typed language as you cannot assign a value of another type to the declared variable.    Example:

./prog.go:16:4: no new variables on left side of :=  ./prog.go:16:7: cannot use “Golang” (type string) as type int in assignment   

• In a short variable declaration, it is allowed to initializing a set of variables by the calling function which returns multiple values. Or you can say variables can also be assigned values that are evaluated during run time.  Example:

Local Variables or Global Variables?

With the help of short variable declaration operator(:=) you can only declare the local variable which has only block-level scope. Generally, local variables are declared inside the function block. If you will try to declare the global variables using the short declaration operator then you will get an error.

Example 1:  

./prog.go:15:1: syntax error: non-declaration statement outside function body   

Output:  

Please Login to comment...

Similar reads.

• Go-Operators
• Go Language

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Go Design Patterns

This post will briefly describe the differences between the assignments and short variable declarations in Go. It assumes that you have completed A Tour of Go and have consulted relevant sections of Effective Go and the target audience is primarily newcomers to the Go programming language.

The assignment operator ( = ) is used to perform assignments (i.e. to assign or reassign values to already declared variables).

The short declaration operator ( := ), on the other hand, is used to perform short variable declarations ), which are shorthand for regular variable declarations but without a specified type.

Here are four different ways to create a variable with static type int and value 10 , each of which are equivalent:

Unlike regular variable declarations, a short variable declaration may redeclare variables in multi-value assignments, assuming at least one variable is new and the redeclared variable is assigned a value of the same type. You’ll see this property used frequently when dealing with errors, as it avoids the need to declare differently named variables such as err1 , err2 , etc. in the same block of code. For example, consider the CopyFunc function below, which opens two files and copies the contents of one file to the other:

In general, short variable declarations should be preferred because they are more concise than regular variable declarations/assignments. Note, however, that short variable declarations can only be used inside of functions/methods (declaring global variables at the package level can only be done using a regular variable declaration: var name type = value ).

Recommended Readings:

• The Assignments and Short variable declarations sections in the official Go Programming Language Specification.
• The Redeclaration and reassignment section in Effective Go.
• Handling errors and Go from the Go Blog.
• The Blank identifier in multiple assignment section in Effective Go.

+1 this blog!

Go Design Patterns is a website for developers who wish to better understand the Go programming language. The tutorials here emphasize proper code design and project maintainability.

Find a typo?

Submit a pull request! The code powering this site is open-source and available on GitHub . Corrections are appreciated and encouraged! Click here for instructions.

© 2014-2018 Alex Lockwood | Android Design Patterns | Go Design Patterns | 2048++

• Conditionals
• Switch-Case
• Error Handling

Variables and Assignments

Sample code link: https://repl.it/@jjoco/go-variables-and-assignment

Primitive Types

Like other programming languages, Go has primitive data types:

• Boolean: bool
• String: string
• Signed Integers: int, int8, int16, int32, int64
• Unsigned integers: uint, uint8, uint16, uint32, uint64
• Byte : byte => alias for uint8
• Rune: rune => alias for int32
• Floats: float32, float64
• Complex numbers: complex64, complex128
• Void is not a type

Note: int and uint "are usually 32 bits wide on 32-bit systems and 64 bits wide on 64-bit systems"

Regular Assignment

At compile time, the developer can specify the type of the variable declared using the var keyword. As an FYI, Go's variable naming convention is camelCase .

• Only var is used when creating a new variable
• No colons when specifying a variable's type
• Number types (eg ints, unsigned ints, floats, etc.) are set to 0
• Boolean types are set to false
• String types are set to empty strings ""

Short Assignment

Multiple assignments.

Golang supports the same arithmetic, comparison, logical, bitwise, and assignment operators as other C-like languages. They are listed below.

• - Subtraction
• * Multiplication
• ++ Increment by 1
• -- Decrement by 1
• < Less than
• > Greater than
• <= Less than or equal to
• >= Greater than or equal to
• == Equal to
• != Not equal to
• && Conditional AND
• || Conditional OR
• += add, then assign
• -= subtract, then assign
• *= multiply, then assign
• /= divide, then assign
• %= modulo, then assign
• & Bitwise AND
• | Bitwise OR
• ^ Bitwise XOR
• << Left shift
• >> Right shift

If else statement

Welcome to tutorial number 8 of our Golang tutorial series .

if statement has a condition and it executes a block of code if that condition evaluates to true . It executes an alternate else block if the condition evaluates to false . In this tutorial we will look at the various syntaxes for using a if statement.

If statement syntax

The syntax of the if statement is provided below

If the condition evaluates to true , the block of code between the braces { and } is executed.

Unlike in other languages like C, the braces { } are not optional and they are mandatory even if there is only one line of code between the braces { } .

Let’s write a simple program to find out whether a number is even or odd.

Run in Playground

In the above program, the condition num%2 in line no. 9 finds whether the remainder of dividing num by 2 is zero or not. Since it is 0 in this case, the text The number 10 is even is printed and the program exits.

The if statement has an optional else construct which will be executed if the condition in the if statement evaluates to false .

In the above snippet, if condition evaluates to false , then the block of code between else { and } will be executed.

Let’s rewrite the program to find whether the number is odd or even using if else statement.

Run in playground

In the above code, instead of returning if the condition is true as we did in the previous section , we create an else statement that will be executed if the condition is false . In this case, since 11 is odd, the if condition is false and the lines of code within the else statement is executed. The above program will print.

If … else if … else statement

The if statement also has optional else if and else components. The syntax for the same is provided below

The condition is evaluated for the truth from the top to bottom.

In the above statement, if condition1 is true, then the block of code within if condition1 { and the closing brace } is executed.

If condition1 is false and condition2 is true, then the block of code within else if condition2 { and the next closing brace } is executed.

If both condition1 and condition2 are false, then the block of code in the else statement between else { and } is executed.

There can be any number of else if statements.

In general, whichever if or else if ’s condition evaluates to true , it’s corresponding code block is executed. If none of the conditions are true then else block is executed.

Let’s write a bus ticket pricing program using else if . The program must satisfy the following requirements.

• If the age of the passenger is less than 5 years, the ticket is free.
• If the age of the passenger is between 5 and 22 years, then the ticket is $10.
• If the age of the passenger is above 22 years, then the ticket price is $15.

In the above program, the age of the passenger is set to 10 . The condition in line no. 12 is true and hence the program will print

Please try changing the age to test whether the different blocks of the if else statement are executed as expected.

If with assignment

There is one more variant of if which includes an optional shorthand assignment statement that is executed before the condition is evaluated. Its syntax is

In the above snippet, assignment-statement is first executed before the condition is evaluated.

Let’s rewrite the program which calculates the bus ticket price using the shorthand syntax.

In the above program age is initialized in the if statement in line no. 9. age can be accessed from only within the if construct. i.e. the scope of age is limited to the if , else if and else blocks. If we try to access age outside the if , else if or else blocks, the compiler will complain. This syntax often comes in handy when we declare a variable just for the purpose of if else construct. Using this syntax in such cases ensures that the scope of the variable is only within the if statement.

The else statement should start in the same line after the closing curly brace } of the if statement. If not the compiler will complain.

Let’s understand this by means of a program.

In the program above, the else statement does not start in the same line after the closing } of the if statement in line no. 11 . Instead, it starts in the next line. This is not allowed in Go. If you run this program, the compiler will print the error,

The reason is because of the way Go inserts semicolons automatically. You can read about the semicolon insertion rule here https://go.dev/ref/spec#Semicolons .

In the rules, it’s specified that a semicolon will be inserted after closing brace } , if that is the final token of the line. So a semicolon is automatically inserted after the if statement’s closing braces } in line no. 11 by the Go compiler.

So our program actually becomes

after semicolon insertion. The compiler would have inserted a semicolon in line no. 4 of the above snippet.

Since if{...} else {...} is one single statement, a semicolon should not be present in the middle of it. Hence this program fails to compile. Therefore it is a syntactical requirement to place the else in the same line after the if statement’s closing brace } .

I have rewritten the program by moving the else after the closing } of the if statement to prevent the automatic semicolon insertion.

Now the compiler will be happy and so are we 😃.

Idiomatic Go

We have seen various if-else constructs and we have in fact seen multiple ways to write the same program. For example, we have seen multiple ways to write a program that checks whether the number is even or odd using different if else constructs. Which one is the idiomatic way of coding in Go? In Go’s philosophy, it is better to avoid unnecessary branches and indentation of code. It is also considered better to return as early as possible. I have provided the program from the previous section below,

The idiomatic way of writing the above program in Go’s philosophy is to avoid the else and return from the if if the condition is true .

In the above program, as soon as we find out the number is even, we return immediately. This avoids the unnecessary else code branch. This is the way things are done in Go 😃. Please keep this in mind whenever writing Go programs.

I hope you liked this tutorial. Please leave your feedback and comments. Please consider sharing this tutorial on twitter or LinkedIn . Have a good day.

Next tutorial - Loops

• 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.

Popular Tutorials

Popular examples, learn python interactively, go introduction.

• Golang Getting Started
• Go Variables
• Go Data Types
• Go Print Statement
• Go Take Input
• Go Comments

Go Operators

• Go Type Casting

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

Go Booleans (Relational and Logical Operators)

• Go Pointers to Structs

In Computer Programming, an operator is a symbol that performs operations on a value or a variable.

For example, + is an operator that is used to add two numbers.

Go programming provides wide range of operators that are categorized into following major categories:

• Arithmetic operators
• Assignment operator
• Relational operators
• Logical operators
• Arithmetic Operator

We use arithmetic operators to perform arithmetic operations like addition, subtraction, multiplication, and division.

Here's a list of various arithmetic operators available in Go.

Example 1: Addition, Subtraction and Multiplication Operators

Example 2: golang division operator.

In the above example, we have used the / operator to divide two numbers: 11 and 4 . Here, we get the output 2 .

However, in normal calculation, 11 / 4 gives 2.75 . This is because when we use the / operator with integer values, we get the quotients instead of the actual result.

If we want the actual result we should always use the / operator with floating point numbers. For example,

Here, we get the actual result after division.

Example 3: Modulus Operator in Go

In the above example, we have used the modulo operator with numbers: 11 and 4 . Here, we get the result 3 .

This is because in programming, the modulo operator always returns the remainder after division.

Note: The modulo operator is always used with integer values.

• Increment and Decrement Operator in Go

In Golang, we use ++ (increment) and -- (decrement) operators to increase and decrease the value of a variable by 1 respectively. For example,

In the above example,

• num++ - increases the value of num by 1 , from 5 to 6
• num-- - decreases the value of num by 1 , from 5 to 4

Note: We have used ++ and -- as prefixes (before variable). However, we can also use them as postfixes ( num++ and num-- ).

There is a slight difference between using increment and decrement operators as prefixes and postfixes. To learn the difference, visit Increment and Decrement Operator as Prefix and Postfix .

• Go Assignment Operators

We use the assignment operator to assign values to a variable. For example,

Here, the = operator assigns the value on right ( 34 ) to the variable on left ( number ).

Example: Assignment Operator in Go

In the above example, we have used the assignment operator to assign the value of the num variable to the result variable.

• Compound Assignment Operators

In Go, we can also use an assignment operator together with an arithmetic operator. For example,

Here, += is additional assignment operator. It first adds 6 to the value of number ( 2 ) and assigns the final result ( 8 ) to number .

Here's a list of various compound assignment operators available in Golang.

• Relational Operators in Golang

We use the relational operators to compare two values or variables. For example,

Here, == is a relational operator that checks if 5 is equal to 6 .

A relational operator returns

• true if the comparison between two values is correct
• false if the comparison is wrong

Here's a list of various relational operators available in Go:

To learn more, visit Go relational operators .

• Logical Operators in Go

We use the logical operators to perform logical operations. A logical operator returns either true or false depending upon the conditions.

To learn more, visit Go logical operators .

More on Go Operators

The right shift operator shifts all bits towards the right by a certain number of specified bits.

Suppose we want to right shift a number 212 by some bits then,

For example,

The left shift operator shifts all bits towards the left by a certain number of specified bits. The bit positions that have been vacated by the left shift operator are filled with 0 .

Suppose we want to left shift a number 212 by some bits then,

In Go, & is the address operator that is used for pointers. It holds the memory address of a variable. For example,

Here, we have used the * operator to declare the pointer variable. To learn more, visit Go Pointers .

In Go, * is the dereferencing operator used to declare a pointer variable. A pointer variable stores the memory address. For example,

In Go, we use the concept called operator precedence which determines which operator is executed first if multiple operators are used together. For example,

Here, the / operator is executed first followed by the * operator. The + and - operators are respectively executed at last.

This is because operators with the higher precedence are executed first and operators with lower precedence are executed last.

Table of Contents

• Introduction
• Example: Addition, Subtraction and Multiplication
• Golang Division Operator

Sorry about that.

Related Tutorials

Programming

The Go Blog

Go maps in action.

Andrew Gerrand 6 February 2013

Introduction

One of the most useful data structures in computer science is the hash table. Many hash table implementations exist with varying properties, but in general they offer fast lookups, adds, and deletes. Go provides a built-in map type that implements a hash table.

Declaration and initialization

A Go map type looks like this:

where KeyType may be any type that is comparable (more on this later), and ValueType may be any type at all, including another map!

This variable m is a map of string keys to int values:

Map types are reference types, like pointers or slices, and so the value of m above is nil ; it doesn’t point to an initialized map. A nil map behaves like an empty map when reading, but attempts to write to a nil map will cause a runtime panic; don’t do that. To initialize a map, use the built in make function:

The make function allocates and initializes a hash map data structure and returns a map value that points to it. The specifics of that data structure are an implementation detail of the runtime and are not specified by the language itself. In this article we will focus on the use of maps, not their implementation.

Working with maps

Go provides a familiar syntax for working with maps. This statement sets the key "route" to the value 66 :

This statement retrieves the value stored under the key "route" and assigns it to a new variable i:

If the requested key doesn’t exist, we get the value type’s zero value . In this case the value type is int , so the zero value is 0 :

The built in len function returns on the number of items in a map:

The built in delete function removes an entry from the map:

The delete function doesn’t return anything, and will do nothing if the specified key doesn’t exist.

A two-value assignment tests for the existence of a key:

In this statement, the first value ( i ) is assigned the value stored under the key "route" . If that key doesn’t exist, i is the value type’s zero value ( 0 ). The second value ( ok ) is a bool that is true if the key exists in the map, and false if not.

To test for a key without retrieving the value, use an underscore in place of the first value:

To iterate over the contents of a map, use the range keyword:

To initialize a map with some data, use a map literal:

The same syntax may be used to initialize an empty map, which is functionally identical to using the make function:

Exploiting zero values

It can be convenient that a map retrieval yields a zero value when the key is not present.

For instance, a map of boolean values can be used as a set-like data structure (recall that the zero value for the boolean type is false). This example traverses a linked list of Nodes and prints their values. It uses a map of Node pointers to detect cycles in the list.

The expression visited[n] is true if n has been visited, or false if n is not present. There’s no need to use the two-value form to test for the presence of n in the map; the zero value default does it for us.

Another instance of helpful zero values is a map of slices. Appending to a nil slice just allocates a new slice, so it’s a one-liner to append a value to a map of slices; there’s no need to check if the key exists. In the following example, the slice people is populated with Person values. Each Person has a Name and a slice of Likes. The example creates a map to associate each like with a slice of people that like it.

To print a list of people who like cheese:

To print the number of people who like bacon:

Note that since both range and len treat a nil slice as a zero-length slice, these last two examples will work even if nobody likes cheese or bacon (however unlikely that may be).

As mentioned earlier, map keys may be of any type that is comparable. The language spec defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using == , and may not be used as map keys.

It’s obvious that strings, ints, and other basic types should be available as map keys, but perhaps unexpected are struct keys. Struct can be used to key data by multiple dimensions. For example, this map of maps could be used to tally web page hits by country:

This is map of string to (map of string to int ). Each key of the outer map is the path to a web page with its own inner map. Each inner map key is a two-letter country code. This expression retrieves the number of times an Australian has loaded the documentation page:

Unfortunately, this approach becomes unwieldy when adding data, as for any given outer key you must check if the inner map exists, and create it if needed:

On the other hand, a design that uses a single map with a struct key does away with all that complexity:

When a Vietnamese person visits the home page, incrementing (and possibly creating) the appropriate counter is a one-liner:

And it’s similarly straightforward to see how many Swiss people have read the spec:

Concurrency

Maps are not safe for concurrent use : it’s not defined what happens when you read and write to them simultaneously. If you need to read from and write to a map from concurrently executing goroutines, the accesses must be mediated by some kind of synchronization mechanism. One common way to protect maps is with sync.RWMutex .

This statement declares a counter variable that is an anonymous struct containing a map and an embedded sync.RWMutex .

To read from the counter, take the read lock:

To write to the counter, take the write lock:

Iteration order

When iterating over a map with a range loop, the iteration order is not specified and is not guaranteed to be the same from one iteration to the next. If you require a stable iteration order you must maintain a separate data structure that specifies that order. This example uses a separate sorted slice of keys to print a map[int]string in key order: