var vs let in Swift

Question

Я новичок в программировании Swift, и я встречал типы и let. Я знаю, что let является константой, и я знаю, что это значит, но я никогда не использовал константу в основном потому, что мне это не нужно. Так почему я должен использовать var вместо let, в какой ситуации я должен использовать его?

Answer 1

Вместо постоянной и переменная, правильная терминология в Свифт неизменны и изменяемые.

Вы используете let, когда знаете, что как только вы присвоите значение переменной, оно не изменится - то есть оно будет неизменным. Если вы объявите идентификатор ячейки таблицы, скорее всего, он не изменится в течение своей жизни, поэтому, объявив его неизменным, нет риска, что вы можете ошибочно изменить его - компилятор проинформирует вас об этом.

Типичные случаи использования:

• Константа (тайм-аут таймера, или ширина размера этикетки фиксированной, максимальное число попыток входа в систему и т.д.). В этом случае константа является заменой буквального значения распределяется по коде (думать о #define)
• возвращаемого значение функции используется в качестве входных данных для другой функции
• промежуточного результат выражения, которые будут использоваться в качестве вход для другого выражения
• контейнера для развернутого значения в факультативно связывания
• данные, возвращаемого с помощью REST API вызова, Десериализованного из JSON в структуры, которые должны быть сохранены в базе данных

и в намного больше. Каждый раз, когда я пишу var, я спрашиваю себя: может ли эта переменная изменяться?. Если ответ отрицательный, я заменяю var на let. Иногда я также использую более защитный подход: я объявляю все неизменным, тогда компилятор сообщит мне, когда я попытаюсь изменить один из них, и для каждого случая я могу действовать соответствующим образом.

Некоторые соображения:

Для ссылочных типов (классов), неизменных означает, что после назначения экземпляра к неизменному переменной, вы не можете назначить другой экземпляр той же переменной.

Для типов значений (числа, строки, массивы, словари, структуры, перечисления) неизменяемое означает, что после присвоения значения вы не можете изменить значение. Для простых типов данных (Int, Float, String) это означает, что вы не можете назначить другое значение того же типа. Для составных типов данных (структур, массивов, словарей) это означает, что вы не можете назначить новое значение (например, новый экземпляр структуры) и, вы не можете изменить какое-либо из их сохраненных свойств.

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

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

Answer 2

В общем случае, если вы знаете, что значение переменной не изменится, объявите его как константу. Неизменяемые переменные сделают ваш код более читаемым, поскольку вы точно знаете, что какая-либо переменная никогда не изменяется. Это также может быть лучше для компилятора, поскольку он может воспользоваться тем фактом, что переменная является постоянной и выполняет некоторые оптимизации.

Это относится не только к Swift. Даже в C, когда значение переменной не изменяется после инициализации, рекомендуется убедиться, что это const.

Итак, как вы думаете, «мне не нужно», должно измениться. Вам не нужна константа только для таких значений, как TIMEOUT и т. Д. У вас должна быть постоянная переменная в любом месте, где вы знаете, значение переменной не нужно менять после инициализации.

Примечание: Это более общий ответ «программирование в целом» и не относится к Swift. @ Ответ Антонио больше ориентирован на Свифта.

Answer 3

Вообще говоря, изменяемое состояние заключается в том, чтобы избежать как можно большего.

Неизменяемые значения помогают в рассуждении о коде, поскольку вы можете легко отследить их и четко определить значение от начала до конца.

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

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

Всякий раз, когда вам нужно использовать var, возможно, потому, что использование этого кода делает код более четким, постарайтесь максимально ограничить область действия и не подвергать никакому изменяемому состоянию. В качестве примера, если вы объявите var внутри функции, это безопасно сделать, если вы не раскрываете эту изменчивость вызывающему абоненту, то есть с точки зрения вызывающего абонента, не имеет значения, используете ли вы var или a val в реализации.