go assignment mismatch 2 variables but 1 value

Go by Example : Multiple Return Values

Next example: Variadic Functions .

by Mark McGranaghan and Eli Bendersky | source | license

Why can you ignore a returned error without an underscore?

Perhaps there is a simple reason for this… but I don’t understand why the compiler allows this:

It’s not that hard to forget that the hello function returns an error (in a more complicated scenario) and if you were just code reviewing main (assume the hello func is in some lib) a reviewer would definitely miss the fact that an error might have occurred.

Running example: The Go Playground

If I saw a call to a function that took no params and returned nothing, I would probably examine it. I don’t think the Go compiler is trying to prevent you from doing certain things like ignoring errors. It’s just trying to make you do so intentionally. This, to me, seems intentional.

I’ve been bitten by plenty of things while writing software. Can’t say that calling a function named hello while ignoring that it might return something has been one of them. Especially in go, given that it’s idiomatic to return errors if errors are possible. And thus it’s idiomatic to also check for errors. What’s the real-world scenario you are trying to protect against?

I guess my example was quite contrived. I was just trying to illustrate the function signature that would cause the issue I was asking about. The context for the question is that I have been working to bring Go into my team at work - so I’ve been trying to learn a lot about the smaller edge cases in the language and to understand where a new Go programmer might make mistakes.

I would also counter that Go does attempt to ensure you don’t make simple mistakes (maybe not errors specifically since they are just another value). To me, my hello example would be the same thing as attempting to do this (again just a contrived example for illustrative purposes):

Which of course does not compile. Instead, the compiler says: ./prog.go:12:11: assignment mismatch: 1 variable but executeUpdate returns 2 values .

Why doesn’t my hello example fail to compile with the same type of error (e.g. assignment mismatch: 0 variables but hello returns 1 value )?

I would expect that you would need to write _ = hello() for the compiler to accept it (which is OK as well… but not required).

I should note that I don’t think anyone disagrees that this is bad code and not idiomatic Go. I’m just trying to understand why the compiler doesn’t enforce it because it seems like a simple case that would ensure cleaner and easier to read code. I also know (don’t have an exact specific example) that I’ve copy/pasted function signatures and forgot to handle the error and when the compiler doesn’t complain, I forget. So it’s not about trying to take a short cut so much as trying to catch simple mistakes.

Here’s a GitHub issue with some discussion:

Some creative solutions were put forward but it didn’t get much traction and at this point it would break the compatibility promise .

Ah! Thank you for sharing that. I missed that in my search. I think that pretty much answers my question then - and makes sense that at this point it would break backwards compatibility.

They make a reference to this package: GitHub - kisielk/errcheck: errcheck checks that you checked errors.

Which I think would probably satisfy my concern in terms of catching mistakes. Perhaps a bit noisy, but it looks like you can supply an allow-list for functions that you don’t care about.

I’ll give that a try and keep track of those proposals to see where they land. Thanks again!

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

Golang中的变量声明

第3部分：变量

这是Golang教程系列中的第三篇教程，它涉及Golang中的变量。

您可以阅读Golang教程第2部分：Hello World，以了解有关配置Go和运行hello world程序的信息。

什么是变量？ 变量是为存储位置指定的名称，用于存储特定类型的值。Go中有多种语法来声明变量。让我们一一看一下。

声明一个变量 var name type是声明单个变量的语法。

该语句var age int声明一个名为agetype 的变量int。我们尚未为该变量分配任何值。如果未为变量分配任何值，则Go会使用变量类型的零值自动对其进行初始化。在这种情况下，为age分配了值0，即零值int。如果运行此程序，则可以看到以下输出。

可以将变量分配给其类型的任何值。在上面的程序中，age可以分配任何整数值。

上面的程序将打印以下输出。

声明具有初始值的变量 声明变量时，还可以为其提供初始值。以下是声明具有初始值的变量的语法。

在上述程序中，age是类型的变量，int并且具有初始值29。上面的程序将打印以下输出。

它显示年龄已经用值29初始化。

类型推断 如果变量具有初始值，Go将自动使用该初始值来推断该变量的类型。因此，如果变量具有初始值，则可以删除变量声明中的type。

如果使用以下语法声明了变量

Go会自动从初始值推断出该变量的类型。

在下面的示例中，我们可以看到int变量的类型age已在行号中删除.由于变量具有初始值29，因此Go可以推断出它的类型int。

多变量声明 可以使用单个语句声明多个变量。

上面的程序将width is 100 height is 50作为输出打印。

正如您现在可能已经猜到的那样，如果未为宽度和高度指定初始值，则将它们初始值指定为0。

在某些情况下，我们可能希望在单个语句中声明属于不同类型的变量。这样做的语法是

下面的程序使用上面的语法声明不同类型的变量。

在这里我们声明一个变量name,类型为string，age和height，类型为int。（在下一个教程中，我们将讨论Golang中可用的各种类型）。

Go还提供了另一种简洁的声明变量的方法。这被称为简写声明，它使用:=运算符。

以下程序使用简写语法声明一个count初始化为的变量10。Go会自动推断出该count类型，int因为它已经使用整数值进行了初始化10。

以上程序将打印，

也可以使用简写语法在一行中声明多个变量。

上述程序声明两个变量name和age, 类型分别为string和int。

如果您运行上述程序，则可以看到my name is naveen age is 29打印内容。

简写声明要求赋值左侧所有变量的初始值。以下程序将打印错误assignment mismatch: 2 variables but 1 values。这是因为尚未为age分配值。

仅当新声明了:=左侧变量中的至少一个时，才可以使用简写语法。考虑以下程序，

在上面的程序中， b已经被声明，但是c是新声明的，因此它可以工作并输出

而如果我们运行以下程序，

它将打印错误，/prog.go:8:10: no new variables on left side of :=这是因为变量a和b已经被声明，并且在行号:=的左侧没有新变量。

也可以为变量分配在运行时计算的值。考虑以下程序，

在上面的程序中，math是一个包，Min是该包中的函数。现在不用担心，我们将在即将到来的教程中详细讨论软件包和功能。所有我们需要知道的是，c的值在运行时计算，它在a和b中选出最小的值。上面的程序将打印，

由于Go是强类型的，因此不能为声明为属于一种类型的变量分配另一种类型的值。以下程序将打印错误，cannot use “naveen” (type string) as type int in assignment因为age已声明为type，int并且我们正在尝试为其分配string值。

“相关推荐”对你有帮助么？

请填写红包祝福语或标题

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

Learn Go with tests

You can find all the code for this chapter here

In arrays & slices , you saw how to store values in order. Now, we will look at a way to store items by a key and look them up quickly.

Maps allow you to store items in a manner similar to a dictionary. You can think of the key as the word and the value as the definition. And what better way is there to learn about Maps than to build our own dictionary?

First, assuming we already have some words with their definitions in the dictionary, if we search for a word, it should return the definition of it.

Write the test first

In dictionary_test.go

Declaring a Map is somewhat similar to an array. Except, it starts with the map keyword and requires two types. The first is the key type, which is written inside the [] . The second is the value type, which goes right after the [] .

The key type is special. It can only be a comparable type because without the ability to tell if 2 keys are equal, we have no way to ensure that we are getting the correct value. Comparable types are explained in depth in the language spec .

The value type, on the other hand, can be any type you want. It can even be another map.

Everything else in this test should be familiar.

Try to run the test

By running go test the compiler will fail with ./dictionary_test.go:8:9: undefined: Search .

Write the minimal amount of code for the test to run and check the output

In dictionary.go

Your test should now fail with a clear error message

dictionary_test.go:12: got '' want 'this is just a test' given, 'test' .

Write enough code to make it pass

Getting a value out of a Map is the same as getting a value out of Array map[key] .

I decided to create an assertStrings helper to make the implementation more general.

Using a custom type

We can improve our dictionary's usage by creating a new type around map and making Search a method.

In dictionary_test.go :

We started using the Dictionary type, which we have not defined yet. Then called Search on the Dictionary instance.

We did not need to change assertStrings .

In dictionary.go :

Here we created a Dictionary type which acts as a thin wrapper around map . With the custom type defined, we can create the Search method.

The basic search was very easy to implement, but what will happen if we supply a word that's not in our dictionary?

We actually get nothing back. This is good because the program can continue to run, but there is a better approach. The function can report that the word is not in the dictionary. This way, the user isn't left wondering if the word doesn't exist or if there is just no definition (this might not seem very useful for a dictionary. However, it's a scenario that could be key in other usecases).

The way to handle this scenario in Go is to return a second argument which is an Error type.

Notice that as we've seen in the pointers and error section here in order to asset the error message we first check that the error is not nil and then use .Error() method to get the string which we can then pass to the assertion.

Try and run the test

This does not compile

Your test should now fail with a much clearer error message.

dictionary_test.go:22: expected to get an error.

In order to make this pass, we are using an interesting property of the map lookup. It can return 2 values. The second value is a boolean which indicates if the key was found successfully.

This property allows us to differentiate between a word that doesn't exist and a word that just doesn't have a definition.

We can get rid of the magic error in our Search function by extracting it into a variable. This will also allow us to have a better test.

By creating a new helper we were able to simplify our test, and start using our ErrNotFound variable so our test doesn't fail if we change the error text in the future.

We have a great way to search the dictionary. However, we have no way to add new words to our dictionary.

In this test, we are utilizing our Search function to make the validation of the dictionary a little easier.

Write the minimal amount of code for the test to run and check output

Your test should now fail

Adding to a map is also similar to an array. You just need to specify a key and set it equal to a value.

Pointers, copies, et al

An interesting property of maps is that you can modify them without passing as an address to it (e.g &myMap )

This may make them feel like a "reference type", but as Dave Cheney describes they are not.

A map value is a pointer to a runtime.hmap structure.

So when you pass a map to a function/method, you are indeed copying it, but just the pointer part, not the underlying data structure that contains the data.

A gotcha with maps is that they can be a nil value. A nil map behaves like an empty map when reading, but attempts to write to a nil map will cause a runtime panic. You can read more about maps here .

Therefore, you should never initialize a nil map variable:

Instead, you can initialize an empty map or use the make keyword to create a map for you:

Both approaches create an empty hash map and point dictionary at it. Which ensures that you will never get a runtime panic.

There isn't much to refactor in our implementation but the test could use a little simplification.

We made variables for word and definition, and moved the definition assertion into its own helper function.

Our Add is looking good. Except, we didn't consider what happens when the value we are trying to add already exists!

Map will not throw an error if the value already exists. Instead, they will go ahead and overwrite the value with the newly provided value. This can be convenient in practice, but makes our function name less than accurate. Add should not modify existing values. It should only add new words to our dictionary.

For this test, we modified Add to return an error, which we are validating against a new error variable, ErrWordExists . We also modified the previous test to check for a nil error.

Try to run test

The compiler will fail because we are not returning a value for Add .

Now we get two more errors. We are still modifying the value, and returning a nil error.

Here we are using a switch statement to match on the error. Having a switch like this provides an extra safety net, in case Search returns an error other than ErrNotFound .

We don't have too much to refactor, but as our error usage grows we can make a few modifications.

We made the errors constant; this required us to create our own DictionaryErr type which implements the error interface. You can read more about the details in this excellent article by Dave Cheney . Simply put, it makes the errors more reusable and immutable.

Next, let's create a function to Update the definition of a word.

Update is very closely related to Add and will be our next implementation.

Write minimal amount of code for the test to run and check the failing test output

We already know how to deal with an error like this. We need to define our function.

With that in place, we are able to see that we need to change the definition of the word.

We already saw how to do this when we fixed the issue with Add . So let's implement something really similar to Add .

There is no refactoring we need to do on this since it was a simple change. However, we now have the same issue as with Add . If we pass in a new word, Update will add it to the dictionary.

We added yet another error type for when the word does not exist. We also modified Update to return an error value.

We get 3 errors this time, but we know how to deal with these.

Write the minimal amount of code for the test to run and check the failing test output

We added our own error type and are returning a nil error.

With these changes, we now get a very clear error:

This function looks almost identical to Add except we switched when we update the dictionary and when we return an error.

Note on declaring a new error for Update

We could reuse ErrNotFound and not add a new error. However, it is often better to have a precise error for when an update fails.

Having specific errors gives you more information about what went wrong. Here is an example in a web app:

You can redirect the user when ErrNotFound is encountered, but display an error message when ErrWordDoesNotExist is encountered.

Next, let's create a function to Delete a word in the dictionary.

Our test creates a Dictionary with a word and then checks if the word has been removed.

By running go test we get:

After we add this, the test tells us we are not deleting the word.

Go has a built-in function delete that works on maps. It takes two arguments. The first is the map and the second is the key to be removed.

The delete function returns nothing, and we based our Delete method on the same notion. Since deleting a value that's not there has no effect, unlike our Update and Add methods, we don't need to complicate the API with errors.

Wrapping up

In this section, we covered a lot. We made a full CRUD (Create, Read, Update and Delete) API for our dictionary. Throughout the process we learned how to:

Create maps

Search for items in maps

Add new items to maps

Update items in maps

Delete items from a map

Learned more about errors

How to create errors that are constants

Writing error wrappers

Last updated 7 days ago

Get the Reddit app

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

assignment mismatch error

I have a simple sqlite query...

func main() {

database, _ := sql.Open ("sqlite3", "./database.db")

select_user, _ := database.Prepare("SELECT username FROM users WHERE username='ANDY'")

query := select_user.Exec()

fmt.Println("The SELECT statement returned "+ query)

But I get this error...

assignment mismatch: 1 variable but select_user.Exec returns 2 values

However we can see from the client it returns a single string...

sqlite> SELECT username FROM users WHERE username='ANDY';

So why does this not work ? Thanks !!

• เข้าสู่ระบบ
• สมัครสมาชิก

assignment mismatch: 2 variables but scanner.Text returns 1 value Go คือ วิธีแก้ไข

รันโค้ดภาษา Go (Golang) รับค่าจากผู้ใช้งานแต่พอรันแล้วไม่สำเร็จขึ้นข้อความ Error ว่า assignment mismatch: 2 variables but scanner.Text returns 1 value แบบนี้ต้องแก้ไขอย่างไร

ปัญหานี้เกิดจาก s, _ := เนื่องจากคำสั่ง scanner.Text จะส่งคืนค่า (return) แค่ค่าเดียว แต่ตอนประกาศตัวแปรมารับค่าประกาศ 2 ตัว คือ s กับ _ ซึ่งให้ลบในอักษร _ หรือ skip error ออก ดังนี้

• SQL BETWEEN TIME แสดงข้อมูลระหว่างเวลา
• loop ในภาษา PHP มีกี่แบบ แต่ละแบบเขียนยังไง
• JavaScript เช็คค่าว่าง radio button
• SQL ย้อนหลัง 7 วัน ด้วยคำสั่ง - INTERVAL 7 DAY
• HTML slide ที่ละหลายภาพ หลายรูป

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

Golang variable assignment

Is there a way in go to assign two variables to a function that returns two values when you have one variable declared and the other not.

For example:

In the above code, host is declared but err isn't. I want a clean way to do this other than declaring err

• Pretty sure it does that automatically. := if there is a new variable, = if both exist. –  Puzzle84 Commented Aug 18, 2016 at 22:55
• If the second statement is an if/for statement. Will the declared variable "host" hold the value returned by func()? –  Keeto Commented Aug 18, 2016 at 23:00
• Short answer is what you're asking for isn't possible. You have to also declare err . –  Endophage Commented Aug 19, 2016 at 0:38
• @Keeto see: stackoverflow.com/questions/36553134/… –  user6169399 Commented Aug 19, 2016 at 7:16

2 Answers 2

In your example you simply shouldn't be declaring host. There is no way to do partial assignment like that... Either your using := which is short hand for declaration and assignment or you using = and you're doing assignment only. I personally very rarely write the word var in Go.

To be clear, if you have one variable that has already been declared with one or more that have not, you're allowed to use := to assign to it, but the inverse is not true. Meaning you cannot use = if one or more of the left hand side values haven't been declared already.

• @Keeto it will, however when you do that host will only be available in the scope of the if . Here's an example on play; play.golang.org/p/3ONeB2D6kH As you can see host isn't in scope outside the if. –  evanmcdonnal Commented Aug 18, 2016 at 23:09

When you use := in an if like that, you will always get new variables declared in the scope of the if . Following the if , the value of host will be the same as it was before. If you want to do this, you need to declare both host and err before the if (and don't use := in the if ).

Your Answer

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

Sign up or log in

Post as a guest.

Required, but never shown

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

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

• Featured on Meta
• Upcoming sign-up experiments related to tags
• The return of Staging Ground to Stack Overflow
• Should we burninate the [lib] tag?
• Policy: Generative AI (e.g., ChatGPT) is banned
• What makes a homepage useful for logged-in users

Hot Network Questions

• Check for key in dictionary without magic value comparison
• Folk stories and notions in mathematics that are likely false, inaccurate, apocryphal, or poorly founded?
• Diagnosing tripped breaker on the dishwasher circuit?
• What is the meaning of the angle bracket syntax in `apt depends`?
• Could space habitats have large transparent roofs?
• Have there been any scholarly attempts and/or consensus as regards the missing lines of "The Ruin"?
• Why was the animal "Wolf" used in the title "The Wolf of Wall Street (2013)"?
• How to join two PCBs with a very small separation?
• Am I doing a forcing argument here?
• Weird behavior by car insurance - is this legit?
• Are positions with different physical pieces on two squares but same kind and same color, considered the same?
• Montreal Airport US arrival to International Departure
• Why depreciation is considered a cost to own a car?
• How are "pursed" and "rounded" synonymous?
• What actual purpose do accent characters in ISO-8859-1 and Windows 1252 serve?
• Why is completeness (as in Gödel completeness theorem) a desirable feature?
• A chess engine in Java: generating white pawn moves
• Would a spaceport on Ceres make sense?
• Is there a smooth function, which is in L^1, but not in L^2?
• What stops a plane from rolling when the ailerons are returned to their neutral position?
• Co-authors with little contribution
• How can these passive RLC circuits change a sinusoid's frequency?
• Tubeless tape width?
• Why can Ethernet NICs bridge to VirtualBox and most Wi-Fi NICs don't?

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

Error: (random.go) assignment mismatch: 2 variables but 1 values #355

gencer commented Aug 1, 2018

aarondl commented Aug 1, 2018

Sorry, something went wrong.

gencer commented Aug 1, 2018 • edited Loading

No branches or pull requests