How to convert a string type value to a uint type value in Go or Golang?
Tags: go
Published: 2022-08-21 10:57:11

---
  title: How to convert a string type value to a uint type value in Go or Golang?
  published: true
  tags: Go
  date: Sun Aug 21 2022 16:27:11 GMT+0530 (India Standard Time)
  canonical_url: https://melvingeorge.me/blog/convert-string-type-value-to-uint-type-value-go-golang
  cover_image: https://melvingeorge.me/_next/static/images/main-b3a53a08dd18011e4f76579e296ecb68.jpg
  ---
  [Originally posted here!](https://melvingeorge.me/blog/convert-string-type-value-to-uint-type-value-go-golang)
  
To convert a `string` type value to a `uint` type value, you can use the `ParseUint()` method from the `strconv` standard package in Go or Golang.

The `ParseUint()` method:

- accepts a `string` type value as its first argument
- a number base of `uint` type value as its second argument
- a bit size of `uint` type value as its third argument
- and returns 2 values, the first one being the converted `uint` type value if any and the second being the `error` data if any.

### TL;DR

```go
package main

// import `strconv` package
import (
    "fmt"
    "strconv"
)

func main() {
    // convert `string` type value of "3000"
    // using the `ParseUint()` method and passing
    // the value "3000" as its first argument
    // 10, the number base as its second argument
    // 32, the bit size as its third argument
    convertedUintValue, err := strconv.ParseUint("3000", 10, 32)
    // check if any error happened
    if err != nil {
        fmt.Println(err.Error())
        return
    }

    // log output of the `convertedUintValue`
    // variable to the console
    fmt.Println(convertedUintValue) // 3000 and the type is uint ✅
}
```

For example, let's say we need to convert a `string` type value of `"3000"` to its corresponding `uint` type value.

To do that let's first import the `strconv` standard package like this,

```go
package main

// import `strconv` package
import "strconv"
```

After importing the package, inside the `main()` function we can use the `ParseUint()` method from the `strconv` package and pass the `string` type value of `"3000"` as its first argument,`10` as the number base as its second argument, and `32` the bit size as its third argument to the function.

It can be done like this,

```go
package main

// import `strconv` package
import "strconv"

func main(){
    // convert `string` type value of "3000"
    // using the `ParseUint()` method and passing
    // the value "3000" as its first argument
    // 10, the number base as its second argument
    // 32, the bit size as its third argument
    strconv.ParseUint("3000", 10, 32)
}
```

The `ParseUint()` method returns 2 values where the first value is the converted `uint` type value if successfully converted and the second value is the `error` data if anything happened during the conversion. To capture these 2 data, let's assign 2 variables.

It can be done like this,

```go
package main

// import `strconv` package
import "strconv"

func main(){
    // convert `string` type value of "3000"
    // using the `ParseUint()` method and passing
    // the value "3000" as its first argument
    // 10, the number base as its second argument
    // 32, the bit size as its third argument
    convertedUintValue, err := strconv.ParseUint("3000", 10, 32)
}
```

Before dealing with the converted `uint` value we need to check if there was any error during the conversion process. Let's use a simple `if` conditional statement and check to see if the `err` data variable is `nil` or not. If it is not `nil`, then there must have been an error that happened during the conversion.

It can be done like this,

```go
package main

// import `strconv` package
import (
    "fmt"
    "strconv"
)

func main(){
    // convert `string` type value of "3000"
    // using the `ParseUint()` method and passing
    // the value "3000" as its first argument
    // 10, the number base as its second argument
    // 32, the bit size as its third argument
    convertedUintValue, err := strconv.ParseUint("3000", 10, 32)
    // check if any error happened
    if err != nil {
        fmt.Println(err.Error())
        return
    }
}
```

If there is no error then it is safe to assume that the `convertedUintValue` variable must be having the converted `uint` type value. Let's log the output to the console like this,

```go
package main

// import `strconv` package
import (
    "fmt"
    "strconv"
)

func main() {
    // convert `string` type value of "3000"
    // using the `ParseUint()` method and passing
    // the value "3000" as its first argument
    // 10, the number base as its second argument
    // 32, the bit size as its third argument
    convertedUintValue, err := strconv.ParseUint("3000", 10, 32)
    // check if any error happened
    if err != nil {
        fmt.Println(err.Error())
        return
    }

    // log output of the `convertedUintValue`
    // variable to the console
    fmt.Println(convertedUintValue) // 3000 and the type is uint ✅
}
```

As you can see that the `string` type value of `"3000"` is successfully converted to its corresponding `uint` type value which is what we want.

See the above code live in [The Go Playground](https://go.dev/play/p/Rlt2IYuTxcX).

Now let's try to give a `string` type value composed of alphabets like `John Doe` and then try to convert it to its `uint` type value like this,

```go
package main

// import `strconv` package
import (
    "fmt"
    "strconv"
)

func main() {
    // convert `string` type value of "John Doe"
    // using the `ParseUint()` method and passing
    // the value "John Doe" as its first argument
    // 10, the number base as its second argument
    // 32, the bit size as its third argument
    convertedUintValue, err := strconv.ParseUint("John Doe", 10, 32) // Error ❌. strconv.ParseUint: parsing "John Doe": invalid syntax
    // check if any error happened
    if err != nil {
        fmt.Println(err.Error())
        return
    }

    // log output of the `convertedUintValue`
    // variable to the console
    fmt.Println(convertedUintValue)
}
```

As you can see that the Go compiler shows us an error saying that `strconv.ParseUint: parsing "John Doe": invalid syntax` which essentially means that it cannot parse this value to its corresponding `uint` type value.

See the above code live in [The Go Playground](https://go.dev/play/p/JUikZl6aMU6).

That's all 😃!

### Feel free to share if you found this useful 😃.

---