Как преобразовать Int в UInt8 в Swift? Пример. Я хочу преобразовать номер 22 в 0b00010110
var decimal = 22
var binary:UInt8 = ??? //What should I write here?
Как преобразовать десятичное число в двоичный файл в Swift?
Ответ 1
Вы можете преобразовать десятичное значение в считываемое человеком двоичное представление, используя инициализатор String, который принимает параметр radix:
let num = 22
let str = String(num, radix: 2)
print(str) // prints "10110"
Если бы вы этого захотели, вы также могли бы легко разместить его с любым количеством нулей:
func pad(string : String, toSize: Int) -> String {
var padded = string
for _ in 0..<(toSize - string.characters.count) {
padded = "0" + padded
}
return padded
}
let num = 22
let str = String(num, radix: 2)
print(str) // 10110
pad(string: str, toSize: 8) // 00010110
Ответ 2
Я модифицировал какую-то версию, чтобы swift 3.0 использовал правильный инициализатор для создания строки с повторяющимися значениями
extension String {
func pad(with character: String, toLength length: Int) -> String {
let padCount = length - self.characters.count
guard padCount > 0 else { return self }
return String(repeating: character, count: padCount) + self
}
}
String(37, radix: 2).pad(with: "0", toLength: 8) // "00100101"
Ответ 3
Я согласен с другими, хотя for-loop кажется излишним для повторения символа.
мы можем просто перейти со следующим инициализатором строки:
init(count count: Int, repeatedValue c: Character)
:
let string = String(count: 5, repeatedValue: char)
Вот полный пример:
let someBits: UInt8 = 0b00001110
let str = String(someBits, radix:2) //binary base
let padd = String(count: (8 - str.characters.count), repeatedValue: Character("0")) //repeat a character
print(padd + str)
Ответ 4
Если вы хотите, чтобы binary имел значение 22, просто назначьте его: binary = 22 или вы можете записать его как binary = 0b00010110; эти два утверждения эквивалентны.
Ответ 5
Вот как бы я это сделал:
extension String {
public func pad(with padding: Character, toLength length: Int) -> String {
let paddingWidth = length - self.characters.count
guard 0 < paddingWidth else { return self }
return String(repeating: padding, count: paddingWidth) + self
}
}
String(0b1010, radix: 2).pad(with: "0", toLength: 8) //00001010
Ответ 6
быстрый 4.1
extension String {
public func pad(with padding: Character, toLength length: Int) -> String {
let paddingWidth = length - self.count
guard 0 < paddingWidth else { return self }
return String(repeating: padding, count: paddingWidth) + self
}
}
extension UInt8 {
public func toBits() -> String
{
let a = String( self, radix : 2 )
let b = a.pad(with: "0", toLength: 8)
return b
}
}
func showBits( _ list: [UInt8] )
{
for num in list
{
showBits(num)
}
}
func showBits( _ num: UInt8 )
{
//print(num, String( num, radix : 2 ))
print( "\(num) \t" + num.toBits())
}
let initialBits :UInt8 = 0b00001111
let invertedBits = ~initialBits
showBits( [initialBits, invertedBits] )
результат
15 00001111
240 11110000
хорошо для вас ~
Ответ 7
Итак, у меня это появилось недавно. Другие общие решения не работали для меня из-за различных проблем. Во всяком случае, здесь мое решение (Swift 4):
extension String {
init<B: FixedWidthInteger>(fullBinary value: B) {
self = value.words.reduce(into: "") {
$0.append(contentsOf: repeatElement("0", count: $1.leadingZeroBitCount))
$0.append(String($1, radix: 2))
}
}
}
Тесты:
// result: 0000000000000000000000000000000000000000000000000000000000001001
String(fullBinary: 9)
// result: 1111111111111111111111111111111111111111111111111111111100000000
String(fullBinary: -256)
// result: 1111111111111111111111111111111111111111111111111101100011110001
String(fullBinary: -9999)
// result: 0000000000000000000000000000000000000000000000000010011100001111
String(fullBinary: 9999)
// result: 1100011000000000000000000000000000000000000011110110100110110101
String(fullBinary: 14267403619510741429 as UInt)
Ответ 8
Поскольку ни одно из решений не рассматривает отрицательные числа, я придумал простое решение, которое в основном считывает внутреннее представление числа и автоматически накладывает его на ширину его типа. Это должно работать на всех типах BinaryInteger.
extension BinaryInteger {
var binaryDescription: String {
var binaryString = ""
var internalNumber = self
for _ in (1...self.bitWidth) {
binaryString.insert(contentsOf: "\(internalNumber & 1)", at: binaryString.startIndex)
internalNumber >>= 1
}
return "0b" + binaryString
}
}
Примеры:
UInt8(22).binaryDescription // "0b00010110"
Int8(60).binaryDescription // "0b00111100"
Int8(-60).binaryDescription // "0b11000100"
Int16(255).binaryDescription // "0b0000000011111111"
Int16(-255).binaryDescription // "0b1111111100000001"
Ответ 9
Swift 5/Xcode 10.2
Спасибо Густаво Зейдлер. Моя версия его решения дополняется пробелами для удобства чтения.
extension BinaryInteger {
var binaryDescription: String {
var binaryString = ""
var internalNumber = self
var counter = 0
for _ in (1...self.bitWidth) {
binaryString.insert(contentsOf: "\(internalNumber & 1)", at: binaryString.startIndex)
internalNumber >>= 1
counter += 1
if counter % 4 == 0 {
binaryString.insert(contentsOf: " ", at: binaryString.startIndex)
}
}
return binaryString
}
}
Примеры:
UInt8(9).binaryDescription // "0000 1001"
Int8(5).binaryDescription // "0000 0101"
UInt16(1945).binaryDescription // "0000 0111 1001 1001"
Int16(14).binaryDescription // "0000 0000 0000 1110"
Int32(6).binaryDescription // "0000 0000 0000 0000 0000 0000 0000 0110"
UInt32(2018).binaryDescription // "0000 0000 0000 0000 0000 0111 1110 0010"
Ответ 10
Я изменил вашу версию на Swift 2.0 на строки и добавил проверку длины:
extension String {
func pad(length: Int) -> String {
let diff = length - self.characters.count
if diff > 0 {
var padded = self
for _ in 0..<diff {
padded = "0" + padded
}
return padded
} else {
return self
}
}
}
Ответ 11
Нет никакой разницы между двоичными и десятичными системами счисления, когда вы работаете с переменными до тех пор, пока вы не захотите их визуализировать, или если вы хотите конвертировать типы, которые могут содержать различное количество бит.
В вашем случае достаточно написать
var decimal = 22
var binary = UInt8(decimal)
Но это приведет к сбою (произойдет переполнение), если decimal будет содержать значение больше 255, поскольку это максимальное значение, которое может удерживать UInt8.
В зависимости от того, что вы хотите достичь, вы можете написать
var decimal = 261 // 0b100000101
var binary = UInt8(truncatingBitPattern: decimal) // 0b00000101
В результате вы получите 0, потому что этот инициализатор будет обрезать менее значимые биты.
Вторая опция
var decimal = 256 // 0b100000000
var binary = UInt8(exactly: decimal) // nil
Этот инициализатор возвращает результат nil вместо сбоя, если происходит переполнение.
P.S. Если вы хотите увидеть двоичное представление строки, используйте
String(decimal, radix: 2)
String(binary, radix: 2)
Ответ 12
Пролистал много ответов на этот пост, но мне интересно, почему никто не упомянул API, leadingZeroBitCount на FixedWidthInteger
Это возвращает количество нулей в определенном UInt, например:
UInt(4).leadingZeroBitCount //61
UInt16(4).leadingZeroBitCount //13
Swift Version
4.1
ИСПОЛЬЗОВАНИЕ
let strFive = String.binaryRepresentation(of: UInt8(5))
print(strFive) // Prints: 00000101
ПОД КАПОТОМ
extension String {
static func binaryRepresentation<F: FixedWidthInteger>(of val: F) -> String {
let binaryString = String(val, radix: 2)
if val.leadingZeroBitCount > 0 {
return String(repeating: "0", count: val.leadingZeroBitCount) + binaryString
}
return binaryString
}
}
Ответ 13
Большинство ответов здесь забывают учесть 0, и выводит представление там слишком длинное.
На основании ответа @karwag я представляю:
extension FixedWidthInteger {
var binaryStringRepresentation: String {
words.reduce(into: "") {
$0.append(contentsOf: repeatElement("0", count: $1.leadingZeroBitCount))
if $1 != 0 {
$0.append(String($1, radix: 2))
}
}
}
}