Go Ints and Strings are immutable OR mutable?-CodePudding

What I am reading about ints and strings over internet is they are immutable in the nature. But the following code shows that after changing the values of these types, still they points to the same address. This contradicts the idea behind the nature of types in python. Can anyone please explain me this? Thanks in advance.

package main

import (
    "fmt"
)

func main() {
    num := 2
    fmt.Println(&num)
    num = 3
    fmt.Println(&num) // address value of the num does not change

    str := "2"
    fmt.Println(&str)
    str = "34"
    fmt.Println(&str) // address value of the str does not change

}```

CodePudding user response：

A number is immutable by nature. 7 is 7, and it won't be 8 tomorrow. That doesn't mean that which number is stored in a variable cannot change. Variables are variable. They're mutable containers for values which may be mutable or immutable.

A Go string is immutable by language design; the string type doesn't support any mutating operators (like appending or replacing a character in the middle of the string). But, again, assignment can change which string a variable contains.

In Python (CPython at least), a number is implemented as a kind of object, with an address and fields like any other object. When you do tricks with id(), you're looking at the address of the object "behind" the variable, which may or may not change depending on what you do to it, and whether or not it was originally an interned small integer or something like that.

In Go, an integer is an integer. It's stored as an integer. The address of the variable is the address of the variable. The address of the variable might change if the garbage collector decides to move it (making the numeric value of the address more or less useless), but it doesn't reveal to you any tricks about the implementation of arithmetic operators, because there aren't any.

Strings are more complicated than integers; they are kind of object-ish internally, being a structure containing a pointer and a size. But taking the address of a string variable with &str doesn't tell you anything about that internal structure, and it doesn't tell you whether the Go compiler decided to use a de novo string value for an assignment, or to modify the old one in place (which it could, without breaking any rules, if it could prove that the old one would never be seen again by anything else). All it tells you is the address of str. If you wanted to find out whether that internal pointer changed you would have to use reflection... but there's hardly ever any practical reason to do so.

CodePudding user response：

When you read about a string being immutable, it means you cannot modify it by index, ex:

x := "hello"
x[2] = 'r'
//will raise an error

As a comment says, when you modify the whole var(and not a part of it with an index), it's not related to being mutable or not, and you can do it