assignment to nil map golang

HatchJS.com

Cracking the Shell of Mystery

Golang: How to Assign a Value to an Entry in a Nil Map

Golang Assignment to Entry in Nil Map

Maps are a powerful data structure in Golang, and they can be used to store key-value pairs. However, it’s important to be aware of the pitfalls of working with nil maps, as assigning a value to an entry in a nil map can cause unexpected results.

In this article, we’ll take a closer look at nil maps and how to avoid common mistakes when working with them. We’ll also discuss some of the best practices for using maps in Golang.

By the end of this article, you’ll have a solid understanding of nil maps and how to use them safely and effectively in your Golang programs.

| Column 1 | Column 2 | Column 3 | |—|—|—| | Key | Value | Error | | `nil` | `any` | `panic: assignment to entry in nil map` | | `map[string]string{}` | `”foo”: “bar”` | `nil` | | `map[string]string{“foo”: “bar”}` | `”foo”: “baz”` | `KeyError: key not found: foo` |

In Golang, a map is a data structure that stores key-value pairs. The keys are unique and can be of any type, while the values can be of any type that implements the `GoValue` interface. When a map is created, it is initialized with a zero value of `nil`. This means that the map does not exist and cannot be used to store any data.

What is a nil map in Golang?

A nil map is a map with a value of nil. This means that the map does not exist and cannot be used to store any data. When you try to access a nil map, you will get a `panic` error.

Why does Golang allow assignment to entry in a nil map?

Golang allows assignment to entry in a nil map because it is a type-safe language. This means that the compiler will check to make sure that the type of the value being assigned to the map entry is compatible with the type of the map. If the types are not compatible, the compiler will generate an error.

How to assign to entry in a nil map in Golang

To assign to an entry in a nil map, you can use the following syntax:

map[key] = value

For example, the following code will assign the value `”hello”` to the key `”world”` in a nil map:

m := make(map[string]string) m[“world”] = “hello”

Assignment to entry in a nil map is a dangerous operation that can lead to errors. It is important to be aware of the risks involved before using this feature.

Additional Resources

• [Golang Maps](https://golang.org/ref/specMaps)
• [Golang Type Safety](https://golang.org/ref/specTypes)

What is a nil map?

A nil map is a map that has not been initialized. This means that the map does not have any entries, and it cannot be used to store or retrieve data.

What are the potential problems with assigning to entry in a nil map?

There are two potential problems with assigning to entry in a nil map:

• The first problem is that the assignment will silently fail. This means that the compiler will not generate an error, and the program will continue to run. However, the assignment will not have any effect, and the map will still be nil.
• The second problem is that the assignment could cause a runtime error. This could happen if the program tries to access the value of the map entry. Since the map is nil, the access will cause a runtime error.

How to avoid problems with assigning to entry in a nil map?

There are two ways to avoid problems with assigning to entry in a nil map:

• The first way is to check if the map is nil before assigning to it. This can be done using the `len()` function. If the length of the map is 0, then the map is nil.
• The second way is to use the `make()` function to create a new map. This will ensure that the map is not nil.

Example of assigning to entry in a nil map

The following code shows an example of assigning to entry in a nil map:

package main

import “fmt”

func main() { // Create a nil map. m := make(map[string]int)

// Try to assign to an entry in the map. m[“key”] = 10

// Print the value of the map entry. fmt.Println(m[“key”]) }

This code will print the following output:

This is because the map is nil, and there is no entry for the key “key”.

Assigning to entry in a nil map can cause problems. To avoid these problems, you should always check if the map is nil before assigning to it. You can also use the `make()` function to create a new map.

Q: What happens when you assign a value to an entry in a nil map in Golang?

A: When you assign a value to an entry in a nil map in Golang, the map is created with the specified key and value. For example, the following code will create a map with the key “foo” and the value “bar”:

m := make(map[string]string) m[“foo”] = “bar”

Q: What is the difference between a nil map and an empty map in Golang?

A: A nil map is a map that has not been initialized, while an empty map is a map that has been initialized but does not contain any entries. In Golang, you can create a nil map by using the `make()` function with the `map` type and no arguments. For example, the following code creates a nil map:

m := make(map[string]string)

You can create an empty map by using the `make()` function with the `map` type and one argument, which specifies the number of buckets to use for the map. For example, the following code creates an empty map with 10 buckets:

m := make(map[string]string, 10)

Q: How can I check if a map is nil in Golang?

A: You can check if a map is nil in Golang by using the `nil` operator. For example, the following code checks if the map `m` is nil:

if m == nil { // The map is nil }

Q: How can I iterate over the entries in a nil map in Golang?

A: You cannot iterate over the entries in a nil map in Golang. If you try to iterate over a nil map, you will get a `panic` error.

Q: How can I avoid assigning a value to an entry in a nil map in Golang?

A: There are a few ways to avoid assigning a value to an entry in a nil map in Golang.

• Use the `if` statement to check if the map is nil before assigning a value to it. For example, the following code uses the `if` statement to check if the map `m` is nil before assigning a value to it:

if m != nil { m[“foo”] = “bar” }

• Use the `defer` statement to delete the entry from the map if it is nil. For example, the following code uses the `defer` statement to delete the entry from the map `m` if it is nil:

defer func() { if m != nil { delete(m, “foo”) } }()

m[“foo”] = “bar”

• Use the `with` statement to create a new map with the specified key and value. For example, the following code uses the `with` statement to create a new map with the key “foo” and the value “bar”:

with(map[string]string{ “foo”: “bar”, })

In this article, we discussed the Golang assignment to entry in nil map error. We first explained what a nil map is and why it cannot be assigned to. Then, we provided several examples of code that would result in this error. Finally, we offered some tips on how to avoid this error in your own code.

We hope that this article has been helpful. If you have any other questions about Golang, please feel free to contact us.

Author Profile

Latest entries

• December 26, 2023 Error Fixing User: Anonymous is not authorized to perform: execute-api:invoke on resource: How to fix this error
• December 26, 2023 How To Guides Valid Intents Must Be Provided for the Client: Why It’s Important and How to Do It
• December 26, 2023 Error Fixing How to Fix the The Root Filesystem Requires a Manual fsck Error
• December 26, 2023 Troubleshooting How to Fix the `sed unterminated s` Command

Similar Posts

How to start a new game in pokmon y.

How to Start a New Game on Pokmon Y Pokmon Y is a role-playing video game developed by Game Freak and published by Nintendo for the Nintendo 3DS. It is the second installment in the sixth generation of the Pokmon video game series, following Pokmon X. The game was released worldwide in October 2013. In…

How to Leave Werewolf Form in Skyrim | A Step-by-Step Guide

How to Leave Werewolf Form in Skyrim The beast within is a powerful force, but it can also be a dangerous one. If you find yourself in werewolf form and you want to return to your human body, there are a few things you can do. In this article, we will discuss the different ways…

How to Convert a List of Dictionaries to a DataFrame in Python

Converting a list of dictionaries to a DataFrame in Python In Python, a DataFrame is a tabular data structure that can be used to store and manipulate data. It is a powerful tool for data analysis, and it can be used to perform a wide variety of tasks, such as grouping data, filtering data, and…

How to Eliminate the Parameter to Find a Cartesian Equation

Have you ever wondered how to find the equation of a curve given its parametric equations? Or how to convert a parametric equation into a Cartesian equation? If so, then you’re in luck! In this article, we’ll discuss how to eliminate the parameter to find a Cartesian equation. We’ll start by reviewing what parametric equations…

How to Run a Minecraft Server on Windows with a .bat File

Minecraft is a popular sandbox game that allows players to build and explore their own worlds. One of the best ways to play Minecraft with friends is to host a multiplayer server. However, setting up a Minecraft server can be a bit tricky, especially if you’re not familiar with the command line. In this article,…

How to Create a New Folder in GitHub

How to Create a New Folder in GitHub GitHub is a popular platform for hosting and collaborating on code. It offers a variety of features that make it easy to manage your projects, including the ability to create new folders. In this tutorial, we’ll show you how to create a new folder in GitHub. We’ll…

Assignment to entry in nil map

Why does this program panic?

You have to initialize the map using the make function (or a map literal) before you can add any elements:

See Maps explained for more about maps.

Golang Tutorial

Golang reference, beego framework, golang error assignment to entry in nil map.

Map types are reference types, like pointers or slices, and so the value of rect 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.

What do you think will be the output of the following program?

The Zero Value of an uninitialized map is nil. Both len and accessing the value of rect["height"] will work on nil map. len returns 0 and the key of "height" is not found in map and you will get back zero value for int which is 0. Similarly, idx will return 0 and key will return false.

You can also make a map and set its initial value with curly brackets {}.

Most Helpful This Week

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:

Example error:

This panic occurs when you fail to initialize a map properly.

Initial Steps Overview

• Check the declaration of the map

Detailed Steps

1) check the declaration of the map.

If necessary, use the error information to locate the map causing the issue, then find where this map is first declared, which may be as below:

The block of code above specifies the kind of map we want ( string: int ), but doesn’t actually create a map for us to use. This will cause a panic when we try to assign values to the map. Instead you should use the make keyword as outlined in Solution A . If you are trying to create a series of nested maps (a map similar to a JSON structure, for example), see Solution B .

Solutions List

A) use ‘make’ to initialize the map.

B) Nested maps

Solutions Detail

Instead, we can use make to initialize a map of the specified type. We’re then free to set and retrieve key:value pairs in the map as usual.

B) Nested Maps

If you are trying to use a map within another map, for example when building JSON-like data, things can become more complicated, but the same principles remain in that make is required to initialize a map.

For a more convenient way to work with this kind of nested structure see Further Step 1 . It may also be worth considering using Go structs or the Go JSON package .

Further Steps

• Use composite literals to create map in-line

1) Use composite literals to create map in-line

Using a composite literal we can skip having to use the make keyword and reduce the required number of lines of code.

Further Information

https://yourbasic.org/golang/gotcha-assignment-entry-nil-map/ https://stackoverflow.com/questions/35379378/go-assignment-to-entry-in-nil-map https://stackoverflow.com/questions/27267900/runtime-error-assignment-to-entry-in-nil-map

Golang Map – Syntax and Examples

Golang map stores the data values in key-value pairs. Go map is an unordered collection of key-value pairs where each key is unique and uses the key to access the element in a map.

Golang provides a built-in map type that implements a hash table and its type is reference types like slice or points in go.

In the Golang map default value is nil which is equivalent to an empty map.

The syntax to create a Go map is:

KeyType: any type

ValueType: any type including another map as well.

For example,

Where variable my_map is a map of string keys to int values.

Let’s create a map and try to add an element to the map.

The above example creates a map but doesn’t initialize it, so the value of my_map is nil . If you try to add an element to a nil map or empty map , it will result in a runtime panic error.

The output of the above program results in a panic runtime error.

Use the make function to create and initialize a map in golang. e.g.

In this tutorial, we will discuss golang map, how to create a map in golang, add elements to a map, and delete an element from the map.

How to Create a Map in Golang Using the make() function

To create a map in Golang, use the built-in make() function to create and initialize a map.

In the make function, provide the key type and value type, and it returns an initialized map.

In the above Golang program to create a map, we have used the make() function.

make() function creates and initializes a map hence you can add an element to it.

To add elements to the map, provide a value type value for each of the strings.e.g.

score[“Gary”] = 75 , create key-value pair where key = Gary and value = 75

Use the fmt.Println to print a map.

Use the len() function to get the total number of keys in a map. e.g. len(score)

How to Access the Values of a Map in Golang

Golang map stores the collection in key:value pairs.

To access the value of a map stored under the key, refer to the following code.

In the above golang map program, to retrieve the value of the key Gary , use score[“Gary”]

It returns the value 75 corresponding to the key Gary in a map.

Cool Tip: How to check if the key exists in a map in Go!

How to Delete Element from the Golang map

Use the delete() function to delete an element of the golang map.

In the above golang program to delete an element from the map using the key, it removes the element.

delete() function in go takes two arguments:

• score – the name of the map
• Mary – key of the element

Use Println() to print the updated map after deleting an element from the map and its length.

How to Iterate over Golang map

Golang map stores the unordered collection of elements in key-value pairs.

To access each of the elements in the Golang map, use the for range loop to iterate over the map.

The output of the above golang program to iterate over the map in go is:

In the above golang map program, to access each element of the map, use the for range loop .

I hope the above article on the golang map, how to create, access the map element, and delete elements from the map is helpful to you.

You can find more topics about the Golang tutorials on the  GolangSpot  Home page.

Leave a Comment Cancel reply

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

Golang Maps Tutorial

Welcome to tutorial no. 13 in Golang tutorial series .

What is a map?

A map is a inbuilt data type in Go which is used to store key-value pairs. A practical use case for a map is for storing the currency codes and the corresponding currency names.

A map will be a perfect fit for the above use case use case. The currency code can be the key and the currency name can be the value. Maps are similar to dictionaries in other languages such as Python.

How to create a map?

A map can be created by passing the data type of key and value to the make function. The following is the syntax to create a new map.

The above line of code creates a map named currencyCode which has string keys and string values.

Run in Playground

The program above creates a map named currencyCode with string key and string value. The above program will print,

Since we have not added any elements to the map, it’s empty.

Adding items to a map

The syntax for adding new items to a map is the same as that of arrays . The program below adds some new currency codes and currency names to the currencyCode map.

Run in playground

We have added 4 currencyCodes namely USD , GBP , EUR , INR and their corresponding names.

The above program prints,

As you might have recognized from the above output, the order of the retrieval of values from a map is not guaranteed to be the same as the order in which the elements were added to the map.

It is also possible to initialize a map during the declaration itself.

The above program declares currencyCode map and adds 3 items to it during the declaration itself. Later one more element with key INR is added. The program prints

It’s not necessary that only string types should be keys. All comparable types such as boolean, integer, float, complex, string, … can also be keys. Even user-defined types such as structs can be keys. If you would like to know more about comparable types, please visit https://go.dev/ref/spec#Comparison_operators

nil map panics

The zero value of a map is nil . If you try to add elements to a nil map, a run-time panic will occur. Hence the map has to be initialized before adding elements.

In the above program, employeeSalary is nil and we are trying to add a new key to a nil map. The program will panic with error

panic: assignment to entry in nil map

Retrieving value for a key from a map

Now that we have added some elements to the map, let’s learn how to retrieve them. map[key] is the syntax to retrieve elements of a map.

The above program is pretty straightforward. The currency name for the currency code USD is retrieved and printed. The program prints

What will happen if an element is not present? The map will return the zero value of the type of that element. In the case of currencyCode map, if we try to access an item which is not present, the zero value of string, “"(the empty string) is returned.

The output of the above program is

The above program returns empty string as the currency name for INR . There will be no runtime error when we try to retrieve the value for a key that is not present in the map.

Checking if a key exists

In the above section we learned that when a key is not present, the zero value of the type will be returned. This doesn’t help when we want to find out whether the key actually exists in the map.

For example, we want to know whether a currency code key is present in the currencyCode map. The following syntax is used to find out whether a particular key is present in a map.

ok in the above line of code will be true when the key is present and the value for the key is present in the variable value . If the key is not present, ok will be false and the zero value is returned for value .

In the above program, in line no. 14, ok will be false since INR key is not present. Hence the program will print,

Iterate over all elements in a map

The range form of the for loop is used to iterate over all elements of a map.

The above program outputs,

One important fact to note is the order of the retrieval of values from a map when using for range is not guaranteed to be the same for each execution of the program. It is also not the same as the order in which the elements were added to the map

Deleting items from a map

delete(map, key) is the syntax to delete key from a map . The delete function does not return any value.

The above program deletes the key EUR and it prints

Even if we try to delete a key that is not present in the map, there will be no runtime error.

Map of structs

So far we have only been storing the currency name in the map. Wouldn’t it be nice if we are able to store the symbol of the currency too? This can be achieved by using a map of structs . The currency can be represented as a struct containing the fields currency name and currency symbol. This struct value can be stored in the map with a currency code as key . Let’s write a program to understand how this can be done.

In the above program, currency struct contains fields name and symbol . We create three currencies curUSD , curGBP and curEUR .

In line no. 26, we initialize a map with string key and value of type currency with the three currencies we created.

The map is iterated in line no. 32 and the currency details are printed in the next line. This program will print,

Length of the map

Length of the map can be determined using the len function.

len(currencyCode) in the above program returns the length of the map. The above program prints,

Maps are reference types

Similar to slices , maps are reference types. When a map is assigned to a new variable, they both point to the same underlying data structure. Hence changes made in one will reflect in the other.

In line no. 14 of the above program, employeeSalary is assigned to modified . In the next line, the salary of mike is changed to 18000 in the modified map. Mike’s salary will now be 18000 in employeeSalary too. The program outputs,

Similar is the case when maps are passed as parameters to functions. When any change is made to the map inside the function, it will be visible to the caller also.

Maps equality

Maps can’t be compared using the == operator. The == can be only used to check if a map is nil .

The above program will fail to compile with error

One way to check whether two maps are equal is to compare each one’s individual elements one by one. The other way is using reflection . I would encourage you to write a program for this and make it work :).

This brings us to the end of this tutorial. Hope you enjoyed it. Please leave your feedback and comments. Please consider sharing this tutorial on twitter and LinkedIn . Have a good day.

Next tutorial - Strings

GO nil detection [interface, slice, pointer, struct, map]

December 26, 2022

In the previous post, I already talked about the zero values and nil in Golang. In today's article, we will discuss how to detect nil value in Go. nil  is a predefined identifier in Go that represents zero values of many types.  nil is usually mistaken as null (or NULL) in other languages, but they are different.

Using nil in Golang

We can use  nil without declaring it. nil can represent the zero values of many data types:

• pointer types (including type-unsafe ones).
• slice types.
• function types.
• channel types.
• interface types.

Common nil detection in Golang

When storage is allocated for a  variable , either through a declaration or a call of  new , or when a new value is created, either through a composite literal or a call of  make , and no explicit initialization is provided, the variable or value is given a default value. Each element of such a variable or value is set to the  zero value  for its type:  false  for booleans,  0  for numeric types,  ""  for strings, and  nil  for pointers, functions, interfaces, slices, channels, and maps. This initialization is done recursively, so for instance each element of an array of structs will have its fields zeroed if no value is specified.

In the example below, we will try to convert a string to unit8 and see how we can catch the error if it is not nil :

Explanation

In the code shown below, we try to handle errors by creating an error variable which is an error type. The zero value for the error type is nil, so we can use the operator != to compare our variable to nil. If it is not nil, it means our program has some problems, we will print the error message and try to handle this case.

Check if a pointer is nil or not

In this example, the pointer is checked whether it is a nil pointer or not:

Check if a struct is nil or not

In this example, we will try to compare a struct instance to nil.

You are comparing a structure instance and nil, which is why the compiler prompts an error message. Since they are not the same type, so the comparison is invalid. The elements of an array or struct will have their fields zeroed if no value is specified. So there's no way to set a struct value to nil . But you could set the value of a pointer to a struct to nil. As mentioned above, the zero value of pointer types is nil .

Check if an interface is nil or not

In this example, the interface is checked whether it is a nil interface or not.

Check if a slice is nil or not

In this example, we are going to check if a slice is nil or not. For the slice, you must clearly understand about an empty and a nil slice. nil and empty slices (with 0 capacity) are not the same, but their observable behavior is the same (almost all the time):

• We can call the builtin len()  and  cap() functions for both nil and empty slice
• We can iterate through them with for range  (will be 0 iterations)

Check if a map is nil or not

The following example shows how to check if a map is empty using the length check and check if the map is nil or not:

As you can see,  nil is not the zero value for every type but only for pointers, functions, interfaces, slices, channels, and maps. For nil detection, we simply use the comparator != . Besides that, some packages provide the IsZero() function to check if it is nil or not. For example, the time.Time type has the IsZero() which reports whether the variable represents the zero time instant, January 1, year 1, 00:00:00 UTC.

https://go.dev/ref/spec#The_zero_value https://go.dev/doc/tutorial/handle-errors https://pkg.go.dev/errors

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!!

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

Panic: assignment to entry in nil map for complex struct

Complete Code : https://play.golang.org/p/bctvsy7ARqS

package main

import ( “fmt” )

type Plan struct { BufferMeasures map[string]*ItemSiteMeasure } type ItemSiteMeasure struct { itemtest string }

func main() {

func (p *Plan) AddBuffer() { fmt.Println(“method start”) p.BufferMeasures[“itmsit1”] = &ItemSiteMeasure{itemtest: “item1”} fmt.Println("obj values : ", p.BufferMeasures) fmt.Println(“method end”) }

Error /output:

start method start panic: assignment to entry in nil map

goroutine 1 [running]: main.(*Plan).AddBuffer(0xc000068f50) /tmp/sandbox633108119/prog.go:29 +0xe8 main.main() /tmp/sandbox633108119/prog.go:20 +0x90

To initialize a map, use the built in make function The Go Blog: Go maps in action

. start method start obj values : map[itmsit1:0xc000010230] method end end

Thanks Petrus, issue resolved.

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

Get the Reddit app

Ask questions and post articles about the Go programming language and related tools, events etc.

`panic: assignment to entry in nil map` at nested maps

this code giving err panic: assignment to entry in nil map

is anything wrong in implementing the maps? i want to create a map key like 1,2,3.... like this, so imeplemented [string(rune(id+1))] now it giving error atfter implementing this one.

i want to create a map to convert it into json like this:

By continuing, you agree to our User Agreement and acknowledge that you understand the Privacy Policy .

Enter the 6-digit code from your authenticator app

You’ve set up two-factor authentication for this account.

Enter a 6-digit backup code

Create your username and password.

Reddit is anonymous, so your username is what you’ll go by here. Choose wisely—because once you get a name, you can’t change it.

Reset your password

Enter your email address or username and we’ll send you a link to reset your password

Check your inbox

An email with a link to reset your password was sent to the email address associated with your account

Choose a Reddit account to continue

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

不要向nil map写入(panic: assignment to entry in nil map) #7

kevinyan815 commented Aug 4, 2019 • edited Loading

• 👍 36 reactions
• 😄 3 reactions
• 🎉 3 reactions

fanyingjie11 commented Apr 25, 2022

Sorry, something went wrong.

kevinyan815 commented Apr 29, 2022

• 👍 2 reactions

No branches or pull requests

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

Assignment to entry in nil map when using http header with Echo golang

here is my test using testing package and echo web http framework : (webserver variable is a global echo instance)

Im trying to test some function that called by REST GET method, but I get this panic error :

The panic is on the line in bold (astrix in the code), when Im trying to set the header. What am I doing wrong?

The error is self explanatory: req.Header is nil; you cannot assign to a nil map.

The solution is to either:

Initialize req.Header with a new instance of net/http.Header

Or, create the req variable with net/http.NewRequest , which does all the internal initializing for you:

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 http go go-echo or ask your own question .

• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Announcing a change to the data-dump process

Hot Network Questions

• Whether an isotone bijection from a power set lattice to another sends singletons to singletons
• Why do tip vortices seem to 'bend' inwards at the tip of a plane wing?
• Generating Random Polytopes for Nonconvex Optimization
• What's wrong with constructions like "Dragons are big, green, and eat people."?
• How should I acknowledge a reviewer who left a negative review?
• Was homology influenced by Euler's polyhedron formula?
• Blocking access to `*.php` in `.well-known`
• The 'correct' way to draw a diagram
• How can a vulnerable function can be a exploited by a non-logged user if it only called in the WP admin section of a plugin?
• Centrifugal force/ pseudo force in circular motion
• Is "Non-Trivial amount of work" a correct phrase?
• Is it correct to say: "To solve an addiction"?
• Can I solder aged copper with patina on it?
• How to play mono (or very unbalanced stereo) through both ears?
• How are multiple sections of a large course assigned?
• What are the specific terms for breaking up English words into roots/components
• Why do doctors always seem to overcharge for services?
• Inserting a 0 in Specific Strings
• Private sector professional being screened out of PhD program
• How should Psalm 5:3 אֶֽעֱרָךְ־ best be translated
• Is a hotter heat source always necessary for an object to be heated?
• Automata reaching the same state when reading the same word long enough
• User does not have access to sudo on Debian 12 unless the system is rebooted
• Movie identification 90s-ish on the Syfy channel sea creature