let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits // равно 11110000
Целые числа типа UInt8
имеет восемь битов и может хранить любое значение от 0 до 255.
UInt8
двоичным значением 00001111, которое имеет первые 4 бита, заданные 0, а вторые четыре бита, заданные в 1. Это эквивалентно десятичному числу 15.
invertedBits
, которая равна initialBits
, но все её биты инвертированы. Нули становятся единицами, а единицы - нулями. Значение invertedBits
равно 11110000, что равно беззнаковому десятичному числу 240.
firstSixBits
и lastSixBits
оба имеют четыре средних бита, равных 1. Оператор побитового И объединяет их для создания числа 00111100, что равно беззнаковому десятичному числу 60:
let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits // равно 00111100
someBits
и moreBits
имеют различные биты, заданные в 1. Оператор побитового ИЛИ объединяет их для создания числа 11111110, что равно беззнаковому десятичному числа 254:
let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits // равно 11111110
XOR
или "оператор исключающего ИЛИ" (^) сравнивает биты двух чисел. Оператор возвращает новое число, чьи биты установлены в 1 там, где входные биты различны, и в 0, где входные биты идентичны:
firstBits
и otherBits
каждое имеют установленные в 1 биты, где другое этого не делает. Оператор XOR устанавливает эти биты в 1 в выходном значении. Все остальные биты в firstBits
и otherBits
совпадают, так что они будут заданы в 0 в выходном числе:
let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits // равно 00010001
let shiftBits: UInt8 = 4 // 00000100 в двоичной системе
shiftBits << 1 // 00001000
shiftBits << 2 // 00010000
shiftBits << 5 // 10000000
shiftBits << 6 // 00000000
shiftBits >> 2 // 00000001
let pink: UInt32 = 0xCC6699
let redComponent = (pink & 0xFF0000) >> 16 // redComponent is 0xCC, or 204
let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent is 0x66, or 102
let blueComponent = pink & 0x0000FF // blueComponent is 0x99, or 153»
Этот пример использует константу типа UInt32
с названием pink
/ для хранения значения цвета CSS для розового цвета. Значение цвета CSS #CC6699 записывает как 0xCC6699 в шестнадцатиричном представлении Swift. Этот цвет затем раскладывается в красную (CC), зелёную (66) и голубую (99) компоненты с помощью побитового оператора И (&) и побитового оператора правого сдвига (>>).
Int8
числа 4:
Int8
для числа -4:
var potentialOverflow = Int16.max
// potentialOverflow equals 32767, which is the maximum value an Int16 can hold
potentialOverflow += 1
// это вызовет ошибку
Например, целое число Int16
может хранить любое знаковое целое между -32768 и 32767. Попытка задать константе или переменной типа Int16
число за пределами этого диапазона вызовет ошибку:
Предоставление обработки ошибок, когда значения слишком велики или слишком малы, даёт Вам больше гибкости при работе с граничными значениями.
Однако, когда Вы специально хотите использовать состояние переполнения для обрезки числа до дозволенных бит, Вы можете добиться этого поведения вместо вызова ошибки. Swift предоставляет три арифметических оператор с переполнением, что используют поведение переполнения для целочисленных вычислений. Эти операторы все начинаются с амперсанда (&):
var unsignedOverflow = UInt8.max
// unsignedOverflow equals 255, which is the maximum value a UInt8 can hold
unsignedOverflow = unsignedOverflow &+ 1
// unsignedOverflow is now equal to 0
Здесь приведён пример того, что произойдёт если беззнаковое целое будет иметь возможность переполниться в положительное направление, используя оператор сложения с переполнением (&+):
unsignedOverflow
инициализирована максимальным значением, которое может хранить UInt8
(255 или 11111111 в двоичной нотации). Затем она увенчивается на 1 с использованием оператора сложения с переполнением (&+). Это сдвигает её двоичное представление за пределы хранимых размеров UInt8
, что вызовет переполнение границ, как показано на рисунке ниже. Значение, что останется внутри границ типа UInt8
после сложения с переполнением равно 00000000 или нуль.
var unsignedOverflow = UInt8.min
// unsignedOverflow equals 0, which is the minimum value a UInt8 can hold
unsignedOverflow = unsignedOverflow &- 1
// unsignedOverflow is now equal to 255
Минимальное значение, которое может храниться в UInt8
равно 0 или 00000000 в двоичной системе. Если Вы вычтете число 1 из 0000000 с использованием оператора переполняющегося вычитания (&-), то это число переполнится и обернётся в 11111111, или 255 в десятичной системе.
var signedOverflow = Int8.min
// signedOverflow equals -128, which is the minimum value an Int8 can hold
signedOverflow = signedOverflow &- 1
// signedOverflow is now equal to 127
Минимальное значение Int8
равно -128 или 10000000 в двоичной нотации. Вычтя 1 из этого двоичного числа получим двоичное значение 01111111, что меняет бит знака и даёт положительное значение 127, что есть максимальное положительное число, которое может хранить тип Int8
.
2 + 3 % 4 * 5
Если Вы прочитаете его строго слева направо, то Вы можете ожидать, что выражение будет вычислено следующим образом:
2 + ((3 % 4) * 5)
2 + (3 * 5)
2 + 15
Это вычисление в итоге даст ответ 17.