Арифметические операции в Swift

Когда вы берете одну или несколько частей данных и превращаете их в другую часть данных, это называется операцией.

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

Простая арифметика встречается повсюду в ваших приложениях: от подсчета количества «лайков» на сообщении до вычисления правильного размера и положения кнопки или окна — числа повсюду!

В этой статье вы узнаете о различных арифметических операциях, которые предлагает Swift, рассмотрев, как они применяются к числам.

Простые операции

Все операции в Swift используют символ, известный как оператор, для обозначения типа выполняемой операции. Рассмотрим четыре арифметические операции, которые вы изучали еще в школе: сложение, вычитание, умножение и деление. Для этих простых операций Swift использует следующие операторы:

  • Сложение: +
  • Вычитание: —
  • Умножение: *
  • Деление: /

Эти операторы используются следующим образом:

2 + 6 
10 - 2 
2 * 4 
24 / 3

Каждая из этих строк является выражением, то есть имеет значение. В данном случае все четыре выражения имеют одно и то же значение: 8. Обратите внимание, что код выглядит так же, как если бы вы записывали операции ручкой и на бумаге. Вы можете ввести их прямо в Playground.

арифметические операции в swift

Номера строк, выделенные светло-синим цветом, еще не запущены. Чтобы запустить код, нажмите на синюю кнопку воспроизведения на последней строке рядом с курсором.

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

Если вы хотите, вы можете удалить пробелы, окружающие оператор:

2+6

Когда вы внесете это изменение, снова появится синяя боковая панель, указывающая, какие строки нужно запустить заново. Повторный запуск можно выполнить, нажав на синюю стрелку или воспользовавшись сочетанием клавиш Shift-Enter.

Shift-Enter запускает все утверждения до текущего курсора и переходит к следующей строке. Это позволяет легко нажимать Shift-Enter и запускать всю Playground шаг за шагом.

Удаление пробельных символов — это «все или ничего»; нельзя смешивать стили. Например:

2+6   // Ок
2 + 6 // Ок
2 +6  // Ошибка
2+ 6  // Ошибка

Первая ошибка будет:

Consecutive statements on a line must be separated by ';'

А для второй ошибки вы увидите:

 '+' is not a postfix unary operator

Сейчас вам не нужно разбираться в этих сообщениях об ошибках. Просто помните, что с обеих сторон оператора должны быть пробелы или их не должно быть!

Часто легче читать выражения, когда с обеих сторон есть пробелы.

Десятичные числа

Во всех приведенных выше операциях использовались целые числа, более формально известные как целые числа. Однако, как вы уже знаете, не каждое число является целым.

В качестве примера рассмотрим следующее:

22 / 7

Вы, возможно, удивитесь, узнав, что в результате получается число 3. Это происходит потому, что если вы используете в выражении только целые числа, Swift делает результат также целым числом. В этом случае результат округляется до следующего целого числа.

Вы можете указать Swift использовать десятичные числа:

22.0 / 7.0

На этот раз вы получите результат 3,142857142857143, как и ожидалось.

Операция с остатком от деления

Четыре операции, с которыми вы познакомились до сих пор, легко понять, потому что вы выполняли их большую часть своей жизни. В Swift есть и более сложные операции, которые вы можете использовать. Все они являются стандартными математическими операциями, просто менее распространенными. Давайте перейдем к ним.

Первая из них — операция остатка, также называемая операцией модуляции. При делении знаменатель входит в числитель целое число раз, плюс остаток. Этот остаток и есть то, что дает операция остатка. Например, 10 по модулю 3 равно 1, потому что 3 трижды переходит в 10 с остатком 1.

В Swift оператор остатка — это символ %, и вы используете его следующим образом:

28 % 10

В данном случае результат равен 8, потому что 10 дважды входит в 28 с остатком 8. Если вы хотите вычислить то же самое, используя десятичные числа, то сделайте это следующим образом:

(28.0).truncatingRemainder(dividingBy: 10.0)

Это вычисляет 28, деленное на 10, затем усекает результат, отсекая лишние десятичные знаки, и возвращает остаток. Результат идентичен %, когда нет десятичных знаков.

Операции сдвига

Операции сдвига влево и сдвига вправо принимают двоичную форму десятичного числа и сдвигают цифры влево или вправо, соответственно. Затем они возвращают десятичную форму нового двоичного числа.

Например, десятичное число 14 в двоичной форме, расширенное до 8 цифр, равно 00001110. Если сдвинуть его на два разряда влево, то получится 00111000, что в десятичном исчислении равно 56.

Вот иллюстрация того, что происходит во время этой операции:

Цифры, которые приходят, чтобы заполнить пустые места справа, становятся 0. Цифры, которые выпадают из конца слева, теряются. Сдвиг вправо — то же самое, но цифры перемещаются вправо.

Операторы для этих двух операций следующие:

  • Сдвиг влево: <<
  • Сдвиг вправо: >>

Это первые операторы, которые вы видите, содержащие более одного символа. Операторы могут содержать любое количество символов.

Вот пример, в котором используются оба этих оператора:

1 << 3 
32 >> 2

Оба эти значения равны числу 8.

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

Аналогично, сдвиг вправо на один равен делению на два, сдвиг вправо на два равен делению на четыре и так далее.

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

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

Порядок операций

Конечно, вы вполне можете захотеть использовать более одного оператора при вычислении значения. Вот пример того, как это сделать в Swift:

((8000 / (5 * 10)) - 32) >> (29 % 5)

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

350 / 5 + 2

Равно ли оно 72 (350 разделить на 5, плюс 2) или 50 (350 разделить на 7)?

Те из вас кто хорошо учился в школе, будут утверждать: «72!». И вы будете правы!

Swift использует те же самые рассуждения и добивается этого с помощью так называемого приоритета операторов. Оператор деления (/) имеет более высокий приоритет, чем оператор сложения (+), поэтому в данном примере код сначала выполняет операцию деления.

Если бы вы хотели, чтобы Swift сначала выполнил сложение — то есть вернул 50, то вы могли бы использовать круглые скобки следующим образом:

350 / (5 + 2)

Правила старшинства соответствуют тем, которые вы изучали в школе на уроках математики. Умножение и деление имеют одинаковый приоритет, более высокий, чем сложение и вычитание, которые также имеют одинаковый приоритет.

Математические функции

В Swift также имеется широкий набор математических функций, которые вы можете использовать при необходимости. Никогда не знаешь, когда понадобится тригонометрия, особенно если вы профессионал в Swift и пишете сложные игры!

Не все эти функции являются частью Swift. Некоторые из них предоставляются операционной системой. Не удаляйте оператор import, который входит в шаблон Playground, иначе Xcode сообщит вам, что не может найти эти функции.

Например, рассмотрим следующее:

sin(45 * Double.pi / 180)
// 0.7071067811865475
 
cos(135 * Double.pi / 180)
// -0.7071067811865475

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

А вот это:

 (2.0).squareRoot()
// 1.414213562373095

Это позволяет вычислить квадратный корень из 2. Знаете ли вы, что синус 45° равен 1 над квадратным корнем из 2? Попробуйте!

max(5, 10)
// 10
 
min(-5, -10)
// -10

Эти функции вычисляют максимум и минимум двух чисел соответственно.

Вы можете даже комбинировать эти функции следующим образом:

 max((2.0).squareRoot(), Double.pi / 2)
// 1.570796326794897

Инкремента и декремента

Часто встречающаяся операция, которая вам понадобится, — это увеличение или уменьшение переменной. В Swift это достигается следующим образом:

var counter: Int = 0
counter += 1
// counter = 1
counter -= 1
// counter = 0

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

Другими словами, приведенный выше код является сокращением для следующего:

var counter: Int = 0
counter = counter + 1
counter = counter - 1

Аналогично, операторы *= и /= выполняют эквивалентные действия для умножения и деления, соответственно:

counter = 10
counter *= 3  // аналогично = counter * 3
// counter = 30
counter /= 2  // аналогично = counter / 2
// counter = 15
Читайте также:
Добавить комментарий

Ваш адрес email не будет опубликован.