Какие типы являются изменяемыми и неизменяемыми в языке Google Go?

Не волнуйтесь - Go позволит вам выстрелить себе в ногу, если вы действительно этого хотите :-)

Go не похож на Erlang, и это может быть то, что вы имеете в виду, задавая вопрос.

x := 1
x = 2

выделяет одну переменную x со значением 1, затем переназначает ее на 2 - здесь не выделяется дополнительная память.

Как вы заметили, строки неизменяемы, поэтому манипуляции со строками могут привести к созданию копий. Если вы обнаружите, что хотите внести изменения в символьные данные на месте, вы, вероятно, захотите работать с переменными []byte через пакет bytes.

Сообщение Расса Кокса об этом должно ответить на большинство ваших вопросов об основных структурах данных: http://research.swtch.com/2009/11/go-data-structures.html

Как отмечали другие комментаторы, вам стоит взглянуть на семантику значений функций Go - поначалу они могут показаться немного неожиданными.

Если у вас есть следующая функция:

func (t MyType) myFunc() {
    // do something to set a field in t
}

и вы звоните в свой код

myVar.myFunc()

вы можете быть удивлены, увидев, что это не делает то, что вы хотите, потому что t, который виден в myFunc(), на самом деле является копией myVar.

Но следующее будет работать:

func (t *myType) myFunc() {
    // do something to set a field in t
}

потому что функция имеет копию указателя и может обращаться к базовой структуре через этот указатель.

На мой взгляд, прежде всего следует разделить следующие два понятия:

• целые числа как математические объекты (то есть: значения)

• переменные типа int

Тогда ответ таков: Целочисленные переменные изменяемы, целые значения неизменны.

Это представление согласуется со спецификацией Go, в которой говорится, что строки неизменяемы. Очевидно, строковая переменная изменяема.

Переменные (как концепция) в Go как минимум:

• именованные переменные (например: var i int)
• переменные, доступные через указатели

Объекты Mutable Go:

• массивы и срезы
• карты
• каналы
• замыкания, которые захватывают как минимум 1 переменную из внешней области видимости

Неизменяемые объекты Go:

• интерфейсы
• логические, числовые значения (включая значения типа int)
• струны
• указатели
• указатели на функции и замыкания, которые можно свести к указателям на функции
• структуры с одним полем

Go объекты, которые некоторые люди могут считать изменяемыми, в то время как другие могут считать их неизменными:

• структуры с несколькими полями

Да, слово неизменяемый встречается в спецификации Go ровно один раз. И это при обсуждении type string. Я думаю, вам следует взглянуть на это с двух точек зрения: назначаемости и Адресуемость. Например, Go, очевидно, запретит вам повторно связывать переменную с другим значением типа с неэкспортированными свойствами. Вроде как в C ++ для классов, не предоставляющих конструктор копирования, но в Go Pimpl гораздо менее неудобно, соответствует общему содержанию философии горутин.

«Изменчивость» имеет смысл только тогда, когда вы говорите о каком-то составном типе, о чем-то, что имеет «внутренние» части, которые, возможно, могут быть изменены независимо от того, что его содержит. Строки естественным образом состоят из символов, и в языке нет механизма, который позволял бы нам изменять символ в существующей строке, за исключением назначения всей новой строки, поэтому мы говорим, что она неизменяема.

Для int на самом деле не имеет смысла говорить об изменчивости, потому что каковы «компоненты» int? Вы изменяете int, присваивая целиком новый int, но присвоение не считается "изменением".

Существует некоторая связь между проблемами изменчивости и типов ссылок и значений. Семантически нет разницы между неизменяемым ссылочным типом и типом значения. Почему? Предположим, что int на самом деле был указателем на неизменяемый объект (т.е. *InternalIntObject без функций для изменения InternalIntObject). После того, как вы назначите такой указатель переменной, он всегда будет представлять одно и то же целочисленное значение (не может быть изменено другими, которые используют тот же объект), поскольку объект неизменяем. Это то же поведение, что и у целочисленного типа значения. Вы можете назначить целые числа с помощью оператора присваивания; аналогично вы можете назначить эти указатели путем присваивания; результат будет таким же: присвоенная переменная представляет то же целое число, что и присвоенное ей. Единственная разница будет заключаться в том, что сравнение и арифметические операторы необходимо будет переопределить, чтобы отменить ссылку на указатель для вычисления результата.

Таким образом, изменчивость имеет смысл только для ссылочных типов.

Что касается того, что вы спросили, «изменяемые» типы обычно считаются ссылочными типами, кроме строковых: карты, каналы, срезы (по отношению к данным, на которые указывает срез), а также указатели на что угодно (поскольку вы можете изменять значение в месте, указанном указателем).

Кажется, ваша забота больше связана с распределением, чем неизменностью. Неизменяемость, безусловно, влияет на распределение, делая невозможным повторное использование памяти. Умный компилятор мог бы повторно использовать любую «неизменяемую» память, адрес которой, как ему известно, не ускользнул.

Помимо строк, будьте осторожны с интерфейсами. Все, что больше размера слова, должно быть выделено при назначении интерфейсу (не считая оптимизаций). Кроме того, переменные, объявленные в теле цикла, адреса которых уходят, в том числе через замыкание, должны будут выделяться каждый раз в цикле. Однако в противном случае задание - это просто задание. Значение просто копируется в память, представленную переменной.

Если вы используете make или new в цикле или любой литерал, который создает ссылку, выделение должно произойти (опять же, при условии оптимизации).

По сути, все сводится к тому, чтобы попытаться повторно использовать память там, где это возможно, и надеяться, что компилятор сделает это за вас, когда вы не можете, если это имеет смысл.