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

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,

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,

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,

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,

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,

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.

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,

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.

That's all 😃!

Feel free to share if you found this useful 😃.

---