I den här handledningen lär du dig om olika bitvisa operationer i Swift. Dessa används för beräkning av bitnivå i ett uttryck.
En bit används för att beteckna en binär siffra. En binär siffra kan ha två möjliga värden antingen 0 eller 1. Som nybörjarnivåprogrammerare behöver du inte arbeta med operationer på bitnivå.
Att arbeta med primitiva datatyper som: heltal, float, boolean, sträng etc räcker. Du kan behöva arbeta på bitnivå när du har att göra med programmering på låg nivå.
Swift tillhandahåller en rik uppsättning operatörer, förutom grundläggande operatörer, för att manipulera bitar. Dessa operatörer liknar de logiska operatörerna, förutom att de arbetar med binära representationer av data (bitar).
Bitvisa operatorer är operatorer som används för att ändra enskilda bitar i en operand. Operand är en variabel eller konstant där operationen utförs.
Nedan listas alla bitvisa operatörer som är tillgängliga snabbt:
1. Bitvis INTE operatör
Det representeras av tilde- ~tecken och kan appliceras på en enda operand. Detta inverterar alla bitar. dvs. ändrar 1 till 0 och 0 till 1.
Om x är en variabel / konstant som innehåller binärt värde, dvs 0 eller 1. Den bitvisa funktionen som inte fungerar på x-variabeln kan representeras i tabellen nedan:
INTE| x | ~ x |
|---|---|
| 0 | 1 |
| 1 | 0 |
Exempel 1: Bitvis INTE operator för osignerat heltal
let initalNumber:UInt8 = 1 let invertedNumber = ~initalNumber print(invertedNumber)
När du kör programmet ovan kommer utmatningen att vara:
254
I ovanstående program är uttalandet let initalNumber:UInt8 = 1av typen Unsigned int av storlek 8 bitar. Så, 1 i decimal kan representeras som 00000001i binär.
Bitvis inte-operatören ändrar hela biten av en variabel eller konstant, bit 0 ändras till 1 och 1 till 0. Så invertedNumber innehåller bitar 11111110. Efter att ha konverterat den till decimal representeras den som 254. Så uttalandet print(invertedNumber)matar ut 254 på skärmen.
Du kan också utföra bitvis operatör direkt i bitarna som:
Exempel 2: Bitvis INTE operatör i bitar
let initialBits: UInt8 = 0b11111111 let invertedBits = ~initialBits print(invertedBits)
När du kör programmet ovan kommer utmatningen att vara:
0
initialBits innehåller binärt värde 11111111som motsvarar 255 i decimal. För att representera talet i binär har vi 0bsom ett prefix i bokstav. Utan 0bsom ett prefix kommer det att behandlas som ett normalt heltal och du får ett överflödsfel (UInt8 kan lagra nummer från endast 0 till 255).
Eftersom vi har använt bitvis inte operatör, ändrar det alla 1 till 0. Så, de konstanta inverterade bitarna innehåller 00000000vilket motsvarar 0 tum UInt8.
Exempel 3: Bitvis INTE operatör för signerat heltal
let initalNumber:Int = 1 let invertedNumber = ~initalNumber print(invertedNumber)
När du kör programmet ovan kommer utmatningen att vara:
-2
I ovanstående program kan 1 i decimal representeras som 00000001i binär. Bitvis inte-operatören ändrar hela biten av en variabel eller konstant, bit 0 ändras till 1 och 1 till 0. Så, invertedNumber innehåller bitar 11111110. Detta ska mata ut 254 på skärmen. Men returnerar istället -2. Konstigt, eller hur? Låt oss undersöka nedan hur detta hände.
let initalNumber:Int = 1är ett signerat int som kan innehålla både positiva och negativa heltal. Därför, när vi inte använde operator för ett signerat heltal, kan den returnerade binära också representera ett negativt tal.
Hur tolkade kompilatorn -2 som 11111110 binärt?
Kompilatorn använde Two's komplement för att representera heltal. För att få de två kompletterande negativa beteckningarna för ett heltal, bör du först skriva ut numret i binär, sedan invertera siffrorna och lägga till en i resultatet.
Steg för att ta reda på Two's komplement på -2 :
- Skriv 2 i binär form:
00000010 - Invertera siffrorna. 0 blir 1 och 1 blir 0:
11111101 - Lägg till 1:
11111110
Så tolkar kompilatorn binärt tal 1111110som -2i decimal. Men det finns en liten vridning som kompilatorn gjorde som vi inte märkte. Det härleddes också typen av inverterat nummer som Int8typ.
För att förstå detta, låt oss se ett exempel nedan:
print(Int8(bitPattern: 0b11111110)) print(0b11111110)
När du kör programmet ovan kommer utmatningen att vara:
-2 254
I exemplet ovan behandlade kompilatorn det binära talet till -2 i decimal endast för det signerade 8-bitars heltalet. Därför sänder print(Int8(bitPattern: 0b11111110))utdrag -2 på skärmen.
Men för den vanliga heltalstypen vars storlek är 32/64 bit och kan innehålla stora värden, tolkar den värdet som 254. Därför sänder print(0b11111110)utskrift 254 på skärmen.
2. Bitvis OCH operatör
Den representeras av &och kan tillämpas på två operander. AND-operatören jämför två bitar och returnerar 1 om båda bitarna är 1, annars returnerar 0.
Om x och y är variabla / konstanta som har binärt värde dvs 0 eller 1. Bitvis OCH-operation på x och y kan representeras i tabellen nedan:
OCH| x | y | x & y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
| 1 | 0 | 0 |
Exempel 5: Bitvis OCH drift
let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits & yBits print("Binary:",String(result, radix: 2)) print(result)
När du kör programmet ovan kommer utmatningen att vara:
Binär: 10000011 131
I ovanstående program let result = xBits & yBitskombinerar uttalandet bitarna i två operander xBits och yBits. Det returnerar 1 det båda bitarna är 1 annars returnerar det 0.
String(value , radix: )initialiserare används för att representera nummer i olika nummersystem. Om vi levererar radixvärde 2. Omvandlar talet till binärt talsystem. På samma sätt kan vi använda 16 för hex och 10 för decimal.
Uttalandet print("Binary:",String(result, radix: 2))matar ut binärt: 10000011 på skärmen. 10000011motsvarar 131 i decimal, uttalandet print(result)matar ut 131 i konsolen.
3. Bitvis ELLER operatör
Den representeras som |och kan tillämpas på två operander. Bitvis ELLER-operatör jämför två bitar och genererar ett resultat om 1 om en eller flera av dess ingångar är 1 annars 0.
Om x och y är variabla / konstanta som har binärt värde dvs 0 eller 1. Bitvis ELLER-operation på x och y kan representeras i tabellen nedan:
ELLER| x | y | x | y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 1 |
| 1 | 0 | 1 |
Exempel 6: Bitvis ELLER drift
let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits | yBits print("Binary:", String(result, radix: 2)) print(result)
När du kör programmet ovan kommer utmatningen att vara:
Binär: 11111111 255
I ovanstående program let result = xBits | yBitskombinerar uttalandet bitarna i två konstanter xBits och yBits. Den returnerar 1 om någon av bitarna är 1 annars returnerar den 0.
Uttalandet print("Binary:",String(result, radix: 2))matar ut Binär: 11111111 på skärmen. Eftersom, 11111111är ekvivalent med 255i decimal, print(result)matar satsen 255 ut på skärmen.
4. Bitvis XOR-operatör
Den representeras som ^och kan tillämpas på två operander. XOR-operatören jämför två bitar och genererar ett resultat av 1 om exakt en av dess ingångar är 1 annars returnerar den 0.
Om x och y är variabla / konstanta som har binärt värde dvs. 0 eller 1. Bitvis XOR-operation på x och y kan representeras i tabellen nedan:
XOR| x | y | x y |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 0 |
| 1 | 0 | 1 |
Exempel 7: Bitvis XOR-funktion
let xBits = 0b10000011 let yBits = 0b11111111 let result = xBits yBits print("Binary:", String(result, radix: 2)) print(result)
När du kör programmet ovan kommer utmatningen att vara:
Binär: 1111100 124
I ovanstående program let result = xBits yBitskombinerar uttalandet bitarna i två konstanter xBits och yBits. Den returnerar 1 om exakt en av bitarna är 1 annars returnerar den 0.
Uttalningen print("Binary:",String(result, radix: 2))matar ut binärt: 1111100 (motsvarar 01111100) på skärmen. Eftersom, 1111100är ekvivalent med 124i decimal, print(result)matar utdraget 124 ut på skärmen.
5. Bitvis växlingsoperatör
Dessa operatorer används för att flytta alla bitar i ett nummer till vänster eller höger med ett visst antal platser och kan appliceras på enstaka operand. Det representeras som <<eller >>.
Det finns två typer av skiftoperatörer:
Bitvis vänster skiftoperatör
- Betecknas som
<< - Det gör att bitarna flyttas åt vänster specificeras av numret följt av
<<. - De bitpositioner som har lämnats av skiftoperationen är nollfyllda.
- Att förskjuta ett heltal bitar åt vänster med en position fördubblar dess värde
Exempel 8: Bitvis vänster skiftoperatör
let someBits:UInt8 = 0b11000100 print(someBits << 1)
När du kör programmet ovan kommer utmatningen att vara:
136
I ovanstående program har vi använt vänster skiftoperatör. Att använda <<1 betyder att flytta biten med 1 åt vänster. Siffrorna flyttas åt vänster med en position och den sista siffran till höger fylls med noll.
Du kan också se att siffran som flyttas "från slutet" från vänster sida går förlorad. Det sveper inte igen från höger. Om du flyttar den en bit åt vänster tas 1 bort från binären och lägger till 0 i höger för att fylla det förskjutna värdet, så att resten av de andra bitarna flyttas mot vänster position med 1.
Detta returnerar 10001000vilket motsvarar 136in UInt8. Därför print(someBits << 1)sänder utdrag 136 på skärmen.
Bitvis höger skiftoperatör
- Betecknas som
>> - Det gör att bitarna flyttas till höger av numret följt av
>> - För osignerade nummer är bitpositionerna som har lämnats av skiftoperationen nollfyllda.
- För signerade nummer (nummer som också kan vara negativa) används signbit för att fylla de lediga bitpositionerna. Med andra ord, om talet är positivt används 0 och om talet är negativt används 1.
- Om du flyttar den åt höger med en position halveras värdet.
Exempel 9: Bitvis höger skiftoperatör för osignerat heltal
let someBits: UInt8 = 4 print(someBits>> 1)
När du kör programmet ovan kommer utmatningen att vara:
2
I ovanstående program har vi använt höger skiftoperatör på ett osignerat heltal. Att använda >>1 betyder att flytta biten med 1 åt höger. De bitpositioner som har lämnats av skiftoperationen fylls alltid noll på ett osignerat heltal.
Eftersom 4 representeras som 00000100binärt. Om du flyttar det en bit åt höger, returneras 00000010vilket motsvarar 2in UInt8. Därför print(someBits>> 1)sänder utdrag 2 på skärmen.
Exempel 10: Bitvis höger skiftoperatör för signerat heltal
let someBits:Int = -4 print(someBits>> 1)
När du kör programmet ovan kommer utmatningen att vara:
-2
I ovanstående program har vi använt höger skiftoperatör på ett osignerat heltal. Till skillnad från positiva tal används >>1 för att fylla den lediga platsen istället för 0 med negativa siffror.
Eftersom, -4representeras som 11111100i binär. Om du flyttar det en bit åt höger och placerar 1 i ledig position, returneras 11111110vilket motsvarar -2för Int8typ. Därför print(someBits>> 1)sänder utskrifter -2 på skärmen.
