Geliştiriciler İçin Sayı Tabanı Dönüşümü Rehberi: İkilik, Hex, Sekizlik ve Onluk

Bir öğleden sonra hata ayıklayıcıda 0x7FFF5FBFF8C0 değerine bakıyorsunuz, ardından bir CSS dosyasına geçip #FF5733 rengini ince ayarlıyor, sonra terminalde chmod 755 çalıştırıyorsunuz. Üç farklı sayı gösterimi, ama altta yatan aritmetik aynı. Eğer hex ile ikilik arasında zihninizde dönüşüm yapmak için durakladıysanız ya da Unix izinlerinin neden tüm tabanlar arasında sekizlik kullandığını merak ettiyseniz, bu rehber o bağlantıların yerine oturmasını sağlayacak.

Günlük programlamada karşımıza çıkan dört sayı sistemini, ezberlemeye değer üç dönüşüm yöntemini ve JavaScript, Python, Go ile C dillerinde gerçek kodu ele alacağız. Teoriyi atlayıp doğrudan bir sayıyı dönüştürmek istiyorsanız, Sayı Tabanı Dönüştürücü aracımızı açın — 2’den 36’ya kadar her tabanı keyfi hassasiyetle ele alır.

Her Geliştiricinin Kullandığı Dört Sayı Sistemi

Her tabanın programlamada bulunmasının tarihsel bir tesadüf değil, pratik bir nedeni vardır.

İkilik (Taban 2) — Makinenin Dili

İki rakam: 0 ve 1. Bir transistör ya açıktır ya kapalı — bu fiziksel kısıt bize ikilik sistemi verir. Bit maskeleriyle, özellik bayraklarıyla, bitwise işlemlerle ve IP alt ağ hesaplamalarıyla çalışırken doğrudan karşılaşırsınız.

İkilik gösterim hızla hantallaşır. Onluk 255 sayısı ikilikte 11111111 olur — üç onluk basamağa sığan bir değer için sekiz basamak. İşte tam da bu yüzden programcılar, tek tek bit konumları önemli olmadıkça ham ikilik nadiren yazar.

Sekizlik (Taban 8) — Unix Kısayolu

Sekiz rakam: 0’dan 7’ye kadar. Her sekizlik basamak tam olarak üç ikilik bite eşlenir; Unix dosya izinlerinin sekizlik kullanmasının nedeni budur — chmod 755 üç grup üç izin bitini, üç okunabilir basamağa paketler.

Sekizliğin PDP-11 döneminde daha büyük bir rolü vardı; o zamanlar makine sözcükleri 3 bitlik gruplara temiz biçimde bölünüyordu. Bugün ağırlıklı olarak Unix izinleriyle, bir de zaman zaman 0 öneki taşıyan C değişmezleriyle (birinin 0177 yazıp onluk 177 beklemesi yüzünden bir-eksik hatasına yol açan o klasik durum) sınırlı.

Onluk (Taban 10) — İnsan Varsayılanı

On rakam: 0’dan 9’a kadar. Beyninizin varsayılan olarak başvurduğu sistem budur — port numaraları, dizi indeksleri, HTTP durum kodları, piksel boyutları. Bilgisayarlar onluk düşünmez ama insanlar düşünür; bu yüzden kullanıcıya gösterilen her sayı taban 10 olarak çıkar.

Onaltılık (Taban 16) — Geliştiricinin İsviçre Çakısı

On altı sembol: 0-9 ve A-F. Her hex basamağı tam olarak dört ikilik biti (bir nibble) temsil eder; bu da hex’i ikilik verinin ideal kompakt gösterimi yapar. İki hex basamağı = bir bayt. Her zaman.

Bellek adreslerinde (0x7FFF5FBFF8C0), CSS renklerinde (#FF5733), MAC adreslerinde (00:1A:2B:3C:4D:5E), UUID biçimlendirmesinde ve özet (hash) çıktılarında hex’i göreceksiniz. Bayt düzeyi programlamanın ortak dilidir.

Dört sistemin tümü arasında dönüşüm yapmayı Sayı Tabanı Dönüştürücü aracımızda deneyin — herhangi bir tabanda bir değer yazın, diğerlerinin anında güncellenmesini izleyin.

Taban Dönüşümü Nasıl Çalışır: Üç Temel Yöntem

Tabanlar arasında dönüşüm yapmak için bir araca ihtiyacınız yok, gerçi bir araç işleri kesinlikle hızlandırır. Üç yöntem her durumu kapsar.

Yöntem 1 — Konumsal Açılım (Herhangi Bir Taban → Onluk)

Her konumsal sayı sistemi aynı şekilde çalışır: her basamak, sıfırdan başlayıp sağdan sayılan konumunun üssüne yükseltilen tabanla çarpılır.

İkilik 1011:

1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 8   + 0    + 2    + 1
= 11

Hex FF:

15×16¹ + 15×16⁰
= 240   + 15
= 255

Kodda çoğu dil bunu bir ayrıştırma işleviyle halleder:

parseInt('1011', 2)   // 11
parseInt('FF', 16)    // 255
parseInt('755', 8)    // 493

Yöntem 2 — Tekrarlı Bölme (Onluk → Herhangi Bir Taban)

Diğer yöne gitmek için onluk sayıyı hedef tabana art arda bölün ve kalanları toplayın. Kalanları aşağıdan yukarıya doğru okuyun.

Onluk 255 → onaltılık:

255 ÷ 16 = 15  kalan 15 (F)
 15 ÷ 16 =  0  kalan 15 (F)
→ Yukarı doğru okuyun: FF

Onluk 42 → ikilik:

42 ÷ 2 = 21  kalan 0
21 ÷ 2 = 10  kalan 1
10 ÷ 2 =  5  kalan 0
 5 ÷ 2 =  2  kalan 1
 2 ÷ 2 =  1  kalan 0
 1 ÷ 2 =  0  kalan 1
→ Yukarı doğru okuyun: 101010

bin(42)    # '0b101010'
hex(255)   # '0xff'
oct(493)   # '0o755'

Yöntem 3 — Bit Gruplama (İkilik ↔ Hex/Sekizlik Doğrudan)

Deneyimli geliştiricilerin en çok kullandığı yöntem budur. 16 = 2⁴ ve 8 = 2³ olduğundan, ikilik ile hex (veya sekizlik) arasında bitleri doğrudan gruplayarak dönüşüm yapabilirsiniz — aritmetiğe gerek yok.

İkilik → Hex: Sağdan başlayarak nibble’lara (4 bit) gruplayın. Gerekirse en soldaki grubu sıfırlarla doldurun.

İkilik:  1010 1111
Hex:      A    F
→ AF

İkilik → Sekizlik: Sağdan başlayarak üçlülere (3 bit) gruplayın.

İkilik:  111 101 101
Sekizlik: 7   5   5
→ 755

Nibble arama tablosu ezberlemeye değer:

İkilik	Hex	İkilik	Hex
`0000`	0	`1000`	8
`0001`	1	`1001`	9
`0010`	2	`1010`	A
`0011`	3	`1011`	B
`0100`	4	`1100`	C
`0101`	5	`1101`	D
`0110`	6	`1110`	E
`0111`	7	`1111`	F

Bu tabloyu içselleştirdiğinizde, ikilikten hex’e dönüşüm bir bakış-ve-oku işlemine dönüşür.

Her Dilde Taban Dönüşümü

İşte sayı tabanı dönüşümünün en sık karşımıza çıktığı dört dilde bunu nasıl ele alacağınız.

JavaScript / TypeScript

// Ayrıştırma: herhangi bir tabandaki dize → sayı
parseInt('FF', 16)          // 255
parseInt('101010', 2)       // 42
parseInt('755', 8)          // 493

// Biçimlendirme: sayı → herhangi bir tabandaki dize
(255).toString(16)          // 'ff'
(42).toString(2)            // '101010'
(493).toString(8)           // '755'

// Değişmezler
const bin = 0b11111111;     // 255
const oct = 0o377;          // 255
const hex = 0xff;           // 255

// 2⁵³'ten büyük değerler için BigInt
const big = BigInt('0xFFFFFFFFFFFFFFFF');
big.toString(2)             // 64 adet bir
big.toString(10)            // '18446744073709551615'

Python

# Onluk → diğer tabanlar (önekli dizeler döndürür)
bin(255)          # '0b11111111'
oct(493)          # '0o755'
hex(255)          # '0xff'

# Diğer tabanlar → onluk
int('11111111', 2)    # 255
int('FF', 16)         # 255
int('755', 8)         # 493

# Doldurma ile biçimlendirilmiş çıktı
f'{255:08b}'      # '11111111'  (8 basamaklı ikilik, sıfırla doldurulmuş)
f'{255:02x}'      # 'ff'       (2 basamaklı hex, küçük harf)
f'{255:02X}'      # 'FF'       (2 basamaklı hex, büyük harf)

# Python tamsayıları varsayılan olarak keyfi hassasiyettedir
big = int('F' * 64, 16)   # 256 bitlik sayı, taşma yok

Go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Biçimlendirme: int → herhangi bir tabandaki dize
    fmt.Println(strconv.FormatInt(255, 16))  // "ff"
    fmt.Println(strconv.FormatInt(255, 2))   // "11111111"
    fmt.Println(strconv.FormatInt(493, 8))   // "755"

    // Ayrıştırma: herhangi bir tabandaki dize → int
    n, _ := strconv.ParseInt("FF", 16, 64)  // 255
    fmt.Println(n)

    // Printf fiilleri
    fmt.Printf("%b %o %x %d\n", 255, 255, 255, 255)
    // 11111111 377 ff 255
}

C

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    // Onluk, sekizlik, hex çıktısı
    printf("%d %o %x\n", 255, 255, 255);
    // 255 377 ff

    // Herhangi bir tabandan ayrıştırma
    long val = strtol("FF", NULL, 16);   // 255
    long bin = strtol("101010", NULL, 2); // 42

    // Yerleşik ikilik printf yok — manuel çıkarım:
    uint8_t byte = 0xAF;
    for (int i = 7; i >= 0; i--)
        putchar(((byte >> i) & 1) ? '1' : '0');
    // 10101111

    return 0;
}

Gerçek Dünyada Taban Dönüşümü Senaryoları

Taban dönüşümünün akademik olmaktan çıkıp işin bir parçası haline geldiği beş durum.

1. Bellek Adreslerinde Hata Ayıklama

Hata ayıklayıcınız 0x7FFF5FBFF8C0 adresinde bir işaretçi gösteriyor. Son iki baytı ikiliğe çevirmek — 1000 1100 0000 — adresin 64 baytlık bir sınıra hizalandığını ortaya koyar (sondaki altı sıfır). Hizalama; önbellek performansı, SIMD işlemleri ve belleğe eşlenmiş G/Ç için önemlidir. Hex gösterimi bu örüntüleri tek bakışta görünür kılar.

İşaretçi aritmetiğini hex’te akıl yürütmek de daha kolaydır. Bir temel adresten 0x100 ofset tam olarak 256 bayttır — birçok gömülü sistemde bir sayfa. Onlukta bu daha az belirgindir.

2. CSS Hex Renkleri ↔ RGB

#FF5733 rengi, hex çiftleri olarak paketlenmiş üç bayttır:

Çift	Hex	Onluk	Kanal
`FF`	FF	255	Kırmızı (azami)
`57`	57	87	Yeşil
`33`	33	51	Mavi

#F00 gibi kısaltılmış gösterim #FF0000 biçimine açılır — saf kırmızı. 8 basamaklı #FF573380 varyantı bir alfa kanalı ekler; burada 80 (onluk 128) yaklaşık %50 saydamlığa karşılık gelir.

Hex’ten onluğa eşlemeyi bilmek, bir kanalı belirli bir miktarda artırmak ya da azaltmak istediğinizde renk seçiciye daha az başvurmak demektir.

3. Unix Dosya İzinleri (Sekizlik)

chmod 755 şöyle açılır:

7 → 111 → rwx  (sahip: okuma + yazma + çalıştırma)
5 → 101 → r-x  (grup: okuma + çalıştırma)
5 → 101 → r-x  (diğerleri: okuma + çalıştırma)

Her sekizlik basamak tam olarak bir izin grubunu kodlar; çünkü üç izin biti (okuma=4, yazma=2, çalıştırma=1) bir sekizlik basamağa (0-7) eşlenir. Yaygın örüntüler:

Sekizlik	İkilik	İzinler	Tipik kullanım
`755`	`111 101 101`	`rwxr-xr-x`	Çalıştırılabilirler, dizinler
`644`	`110 100 100`	`rw-r--r--`	Sıradan dosyalar
`700`	`111 000 000`	`rwx------`	Özel betikler
`600`	`110 000 000`	`rw-------`	SSH anahtarları, sırlar

4. Ağ Alt Ağ Hesaplamaları

Bir /24 alt ağ maskesi, ikilikte 24 adet baştaki bir anlamına gelir:

11111111.11111111.11111111.00000000
→ 255.255.255.0

Ağ adresini bulmak için IP ve maskeyi ikilikte AND’leyin:

192.168.1.37   → 11000000.10101000.00000001.00100101
255.255.255.0  → 11111111.11111111.11111111.00000000
AND sonucu     → 11000000.10101000.00000001.00000000
               → 192.168.1.0 (ağ adresi)

Ağ mühendisleri rutin olarak onluk (IP gösterimi), ikilik (alt ağ matematiği) ve bazen hex (paket yakalamaları) arasında dönüşüm yapar. Görsel bir denetim tercih ediyorsanız Sayı Tabanı Dönüştürücü aracımız her sekizliyi ayrı ayrı ele alır.

5. Özet (Hash) Çıktılarını ve UUID’leri Okuma

d41d8cd98f00b204e9800998ecf8427e gibi bir MD5 özeti, 16 baytı (128 biti) temsil eden 32 hex karakterdir. Her hex basamak çifti bir bayttır.

Bir UUID, 8-4-4-4-12 hex örüntüsünü izler:

550e8400-e29b-41d4-a716-446655440000

Yani tirelerle ayrılmış 32 hex basamağı — aynı 128 bit, yalnızca farklı biçimlendirilmiş. Sürüm nibble’ı 13. konumda durur (41d4 içindeki 4 UUID v4 anlamına gelir).

MD5 ve SHA Özet Üretici aracımızla özetler oluşturun veya UUID Üretici aracımızla UUID’ler üretin — her ikisi de burada tartışılan ikilik gösterimlere doğrudan eşlenen hex çıktısı üretir.

Taban 16’nın Ötesinde: Taban 36, Taban 64 ve Özel Tabanlar

Standart dört taban işin çoğunu kapsar; ancak özel bağlamlarda birkaç başka taban daha ortaya çıkar.

Taban 36 — Kompakt Alfanümerik Kodlama

Taban 36, 10 rakamın tümünü artı 26 harfi (A-Z) kullanarak mümkün olan en kompakt büyük/küçük harf duyarsız alfanümerik gösterimi sağlar. URL kısaltıcılar bunu çok sever — YouTube video kimlikleri, kısa bağlantılar ve kompakt veritabanı anahtarları sıklıkla taban 36 kullanır.

(1000000).toString(36)    // 'lfls'
parseInt('lfls', 36)      // 1000000

Onluk 1.000.000 yalnızca dört karaktere sıkıştırılır. URL güvenli kısa tanımlayıcılar için bunu yenmek zordur.

Taban 64 — Veri Kodlaması (Bir Sayı Sistemi Değildir)

Base64 başka bir taban gibi görünür, ama farklı bir amaca hizmet eder. Konumsal bir sistemde sayısal bir değeri temsil etmek yerine, Base64 keyfi ikilik veriyi (görüntüler, dosyalar, JWT token’leri) ASCII metin olarak kodlar. A-Z, a-z, 0-9, + ve / kullanır — toplam 64 sembol.

Matematiği taban dönüşümünden farklıdır. Base64, girdiyi 3 baytlık (24 bitlik) bloklar halinde işler ve dört adet 6 bitlik karakter çıktısı verir. Bu bir kodlama şemasıdır, sayı sistemi değil.

Base64 verisini kodlamak ve çözmek için Base64 Kodlayıcı ve Çözücü aracımızı kullanın.

Keyfi Tabanlar (2-36) ve Ne Zaman Karşımıza Çıktıkları

Birkaç başka taban daha vahşi doğada ortaya çıkar:

Taban 12 (düzineli): Saat (12 saat), miktarlar (bir düzine). Bazı matematikçiler, 12’nin daha çok böleni olduğu için günlük kullanımda taban 12’nin taban 10’dan daha iyi olacağını savunur.
Taban 60 (altmışlı): Saat (60 saniye, 60 dakika) ve açılar (360°). Babil matematiğinden miras kalmıştır.
Taban 32: İnsan tarafından okunabilir tanımlayıcılar için Crockford’un Base32 kodlaması (I, L, O gibi belirsiz karakterleri hariç tutar). Ayrıca geohash’lemede de kullanılır.

Sayı Tabanı Dönüştürücü aracımız 2’den 36’ya kadar herhangi bir tamsayı tabanını destekler.

Bitwise İşlemleri ve Taban Dönüşümü

İkiliği anlamak yalnızca sayıları dönüştürmekle ilgili değildir — sistem programlama, oyun geliştirme ve izin sistemlerinde karşımıza çıkan bitwise işlemlerin de temelidir.

const READ  = 0b100;  // 4
const WRITE = 0b010;  // 2
const EXEC  = 0b001;  // 1

// İzinleri OR ile birleştir
const perms = READ | WRITE;  // 0b110 = 6

// Belirli bir izni AND ile denetle
(perms & READ)  !== 0   // true  — okuma var
(perms & EXEC)  !== 0   // false — çalıştırma yok

// Bir izni XOR ile değiştir
perms ^ WRITE   // 0b100 = 4 — yazma kaldırıldı

// Kaydırma işlemleri
1 << 3    // 0b1000 = 8  (1, 3 sola kaydırıldı)
0xFF >> 4  // 0b00001111 = 15  (sağa 4 kaydırma = 16'ya bölme)

Özellik bayrakları, donanım kayıtları, ağ protokolleri ve grafik programlamanın tamamı bitwise işlemlere dayanır. İkilik bir kez yerine oturduğunda, bit manipülasyonu sade mantık gibi okunur — hiçbir sihir yoktur.

SSS

Programlamada kullanılan dört ana sayı sistemi nelerdir?

İkilik (taban 2), sekizlik (taban 8), onluk (taban 10) ve onaltılık (taban 16). İkilik, verinin donanımda fiziksel olarak nasıl var olduğudur. Sekizlik, Unix dosya izinlerine eşlenir. Onluk, insana yönelik varsayılandır. Hex, ikiliği okunabilir biçime sıkıştırır — her hex basamağı tam olarak 4 bittir.

İkiliği onaltılığa nasıl dönüştürürüm?

İkilik basamakları sağdan sola 4’lük gruplara ayırın; gerekirse en soldaki grubu sıfırlarla doldurun. Her grubu eşleyin: 0000=0, 0001=1, …, 1010=A, …, 1111=F. Örnek: ikilik 10101111 → gruplar 1010 1111 → hex AF. Bu çalışır çünkü 16 = 2⁴.

Onaltılığı onluğa nasıl dönüştürürüm?

Her hex basamağını, konumunun (en sağdaki = 0) üssüne yükseltilen 16 ile çarpın, sonra toplayın. A=10, B=11, C=12, D=13, E=14, F=15. Örnek: hex FF = 15×16¹ + 15×16⁰ = 240 + 15 = 255. Kodda: JavaScript parseInt('FF', 16), Python int('FF', 16).

Programcılar neden ikilik yerine onaltılık kullanır?

Hex kompakttır. Her hex basamağı tam olarak 4 bite eşlenir; yani ikilikte 11111111 00001010 hex’te FF0A olur — çok daha kısa ve taranması daha kolay. Hex; bellek adresleri, CSS renkleri (#FF5733), MAC adresleri, özet çıktıları ve UUID biçimlendirmesi için standarttır.

Nibble nedir ve hex dönüşümü için neden önemlidir?

Nibble 4 ikilik bittir — bir baytın yarısı. Bir nibble tam olarak bir hex basamağına eşlenir; bu da ikilikten hex’e dönüşümü nibble-nibble bir aramaya indirger. Bir bayt = iki nibble = iki hex basamağı. Bu temiz 4 bitlik eşleme, hex’in bayt düzeyi veriyi temsil etmek için neden standart hâline geldiğinin nedenidir.

Unix dosya izinleri neden sekizlik yazılır?

Grup başına üç izin biti (okuma=4, yazma=2, çalıştırma=1), üç grup (sahip, grup, diğerleri). 2³ = 8 olduğundan, üç bitlik her grup bir sekizlik basamağa eşlenir. 755; sahip=7 (rwx), grup=5 (r-x), diğerleri=5 (r-x) anlamına gelir. Sekizlik, 3 bitlik gruplamalar için doğal tabandır.

JavaScript’te 2⁵³’ten büyük sayıları nasıl ele alırım?

BigInt kullanın. Bir değişmeze n ekleyin ya da BigInt() yapıcısını kullanın: BigInt('0xFFFFFFFFFFFFFFFF').toString(2) 64 bitin tamamından oluşan ikilik dizeyi üretir. Standart Number 9.007.199.254.740.991’in (2⁵³ - 1) ötesinde hassasiyet kaybeder. Sayı Tabanı Dönüştürücü aracımız dahili olarak BigInt kullanır; bu yüzden her boyutta sayıyı hassasiyet kaybı olmadan ele alır.

Onaltılığı ikiliğe nasıl dönüştürürüm?

Her hex basamağını 4 bitlik ikilik karşılığıyla değiştirin; aynı nibble tablosunu tersten kullanın: 0=0000, 1=0001, …, A=1010, …, F=1111. Örnek: hex AF → A (1010) + F (1111) → ikilik 10101111. Kodda: JavaScript parseInt('AF', 16).toString(2) veya Python bin(int('AF', 16))[2:].

CSS hex renklerinin neden bazen 3, 6 veya 8 basamağı vardır?

Üç biçim de aynı RGB modeline eşlenir ama farklı hassasiyet ve alfa kodlar. 3 basamaklı #F0A, #FF00AA biçimine açılan kısaltmadır (her basamak iki kez yazılır). 6 basamaklı #FF00AA standart RGB biçimidir — kanal başına iki hex basamağı. 8 basamaklı #FF00AA80, dördüncü bayt olarak bir alfa kanalı ekler; burada 80 (onluk 128) yaklaşık %50 saydamlıktır. Modern tarayıcılar üçünü de kabul eder; tasarımcılar amacı koruyan en kısa biçimi seçer.