strconv.Itoa does not accept values of type int64

Im learning to create REST APIs using Go. Here's where I am stuck.

> When user sends a CREATE request:

1. From the Slice of articles, I need to take the last article
2. Convert the ID(originally string) to Integer
3. Increment the Integer and convert it back to string and save it

Article Struct

type Article struct {
	Id       string  `json:"id"`
	Title    string  `json:"title"`
	Desc     string  `json:"desc"`
	Content  string  `json:"content"`
}

Here's the logic

// get the last id and convert it to integer and increment
	lastId, err := strconv.ParseInt(Articles[len(Articles) - 1].Id, 10, 64)
	lastId = lastId + 1 
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
	}
	response := []Article{
		{
			Id: strconv.Itoa(lastId),// 👈 ERROR
			Title:   articleBody.Title,
			Desc:    articleBody.Desc,
			Content: articleBody.Content,
		},
	}

<h3>ERROR</h3>

cannot use lastId (variable of type int64) as int value 
in argument to strconv.Itoa compiler (IncompatibleAssign)

Go has a strong typing system so Int32 and Int64 are not compatible type. Try to convert lastId into an int when calling Itoa:

    response := []Article{
        {
            Id: strconv.Itoa(int(lastId)),
            Title:   articleBody.Title,
            Desc:    articleBody.Desc,
            Content: articleBody.Content,
        },
    }

Edit:
As mention by @kostix in his answer, beware of overflows when converting int type (see his answer for details).
A safer solution would be something like this:

newId := int(lastId)
if int64(newId) != lastId {
  panic("overflows!")
}
response := []Article{
            {
                Id: strconv.Itoa(newId),
                Title:   articleBody.Title,
                Desc:    articleBody.Desc,
                Content: articleBody.Content,
            },
 }

The language specification says:

> uint either 32 or 64 bits
> int same size as uint

This means, on a particular platform/version of Go int may be the same size as int32, and this is the reason why Go would not silently allow you to pass a value of type int64 as an argument of type int.

Moreover, a plain type conversion int(lastId) suggested in another answer should be taken with a grain of salt: what happens when your program is compiled and int ends up having 32 bits in size in the compiled code, and a particular lastId value is outside the number range supported by a signed 32-bit integer, say, 2,147,483,648?
Again, the spec says:

> When converting between integer types, if the value is a signed integer, it is sign extended to implicit infinite precision; otherwise it is zero extended. It is then truncated to fit in the result type's size. For example, if v := uint16(0x10F0), then uint32(int8(v)) == 0xFFFFFFF0. The conversion always yields a valid value; there is no indication of overflow.

Hence the code

var i64 int64 = 2_147_483_648
var i32 = int32(i64)
fmt.Println(i32)

prints

-2147483648

And when this value is passed to strconv.Itoa, it returns "-2147483648" — quite possibly not what you would expect.

So, in a robust code, you ought to watch out when doing such type conversions, and either check the converted value for sanity, like in

v := int(lastId)
if int64(v) != lastId {
  panic("ouch!")
}

or merely use the largest convenient type via strconv.FormatInt.