echo Komutu: Terminal Çıktısı ve Değişken Kullanımı

yazar

Terminal’de çalışırken farkında bile olmadan sürekli kullandığımız komutların başında echo geliyor. Öyle basit görünüyor ki çoğu zaman üzerinde durulmaya değmez gibi hissettiriyor. Ama script yazarken, debug yaparken ya da bir pipeline kurarken echo‘nun inceliklerini bilmemek sizi ciddi anlamda yavaşlatabilir. Bu yazıda echo komutunu A’dan Z’ye ele alacağız; temel kullanımdan değişkenlerle entegrasyona, bash scriptlerinde pratik uygulamalara kadar her şeyi masaya yatıracağız.

echo Nedir ve Neden Bu Kadar Önemlidir?

echo kelime anlamıyla “yankı” demek. Komutun işlevi de tam olarak bu: kendisine verilen argümanı standart çıktıya (stdout) yazar. Kulağa çok basit geliyor, değil mi? Ama sistem yönetiminde bu kadar geniş kullanım alanı olan az komut vardır.

Bir script çalışırken ne yapıyor? Log dosyalarına mesaj yazıyor. Kullanıcıya bilgi veriyor. Bir değişkenin değerini kontrol ediyor. Hepsinde echo var. Ayrıca echo komutunun iki farklı versiyonu olduğunu hemen belirtmek gerekiyor:

  • Bash built-in echo: Shell’in içine gömülü olan versiyon, type echo yazınca “echo is a shell builtin” gösterir
  • /bin/echo: Sistemde bağımsız bir binary olarak duran harici versiyon

Çoğu zaman aralarındaki fark önemli olmasa da özellikle taşınabilir script yazarken hangi echo‘yu kullandığınız kritik olabilir. Bu yazıda bash built-in versiyonunu baz alacağız.

Temel Kullanım

En yalın haliyle echo şöyle çalışır:

echo "Merhaba Dunya"
echo Merhaba Dunya
echo 'Sistem kontrol ediliyor...'

Tırnak işaretleri olmadan da çalışır ama bu alışkanlık ileride başınızı ağrıtabilir. Özellikle içinde boşluk, özel karakter ya da değişken olan string’lerde tırnak kullanmak neredeyse zorunlu hale geliyor.

Temel Parametreler

echo komutunun en sık kullanılan parametreleri şunlardır:

  • -n: Satır sonuna newline karakteri eklemez, cursor aynı satırda kalır
  • -e: Backslash escape karakterlerini yorumlar (n, t gibi)
  • -E: Escape yorumlamayı devre dışı bırakır (varsayılan davranış zaten böyledir)
# -n parametresi: Aynı satırda kalmak
echo -n "Kullanici adi: "
read username

# -e parametresi: Escape karakterlerini kullanmak
echo -e "Birinci satirnIkinci satirnUcuncu satir"

# Tab karakteri kullanmak
echo -e "Ad:tAhmetnSoyad:tYilmaz"

-e parametresiyle kullanabileceğiniz escape karakterleri:

  • n: Yeni satır
  • t: Yatay sekme (tab)
  • r: Carriage return
  • \: Backslash karakterinin kendisi
  • a: Alarm/bel sesi
  • b: Backspace
  • c: Sonraki çıktıyı bastırır (satır sonu dahil)

Değişkenlerle Kullanım

echo‘nun gerçek gücü değişkenlerle birleşince ortaya çıkıyor. Bash’te değişken kullanımı için iki temel tırnak türü arasındaki farkı anlamak şart.

Çift Tırnak vs Tek Tırnak

isim="Mehmet"
sehir="Istanbul"

# Cift tirnak: degiskenler yorumlanir
echo "Hosgeldiniz, $isim. Seciliniz sehir: $sehir"
# Cikti: Hosgeldiniz, Mehmet. Seciliniz sehir: Istanbul

# Tek tirnak: degiskenler literal olarak yazdirilir
echo 'Hosgeldiniz, $isim. Seciliniz sehir: $sehir'
# Cikti: Hosgeldiniz, $isim. Seciliniz sehir: $sehir

Bu fark özellikle script yazarken kritik. Kullanıcıya değişkenin adını değil değerini göstermek istiyorsanız çift tırnak kullanmalısınız. Ama değişken adını olduğu gibi yazdırmak istiyorsanız (örneğin bir dokümantasyon scripti yazıyorsanız) tek tırnak işinizi görür.

Değişken Süslü Parantez Kullanımı

renk="mavi"

# Sorunlu kullanim: bash 'renkler' degiskenini arayor
echo "Favori $renkler benim icin cok onemli"

# Dogru kullanim: surdeli parantez ile siniri belirle
echo "Favori ${renk}ler benim icin cok onemli"
# Cikti: Favori maviler benim icin cok onemli

Bu detayı atlayan scriptler sessiz sedasız yanlış çıktı üretir ve debug etmesi can sıkıcı olur.

Komut Sonuçlarını echo ile Yazdırmak

echo sadece statik metinleri değil, komutların çıktılarını da yazdırabilir. Bunun için command substitution kullanıyoruz.

# Eski stil: backtick
echo "Sunucu adi: `hostname`"

# Modern ve onerilen: $() syntax
echo "Sunucu adi: $(hostname)"
echo "Tarih: $(date '+%d/%m/%Y %H:%M')"
echo "Calistirim suresi: $(uptime -p)"
echo "Disk kullanimi: $(df -h / | awk 'NR==2 {print $5}')"

$() syntax’ı iç içe geçirme (nesting) için çok daha uygun. Backtick ile iç içe komut yazmak gerçek bir kabus olabilir.

Renk ve Formatlama ile echo

Terminal çıktısını renklendirmek hem daha okunabilir hem de daha profesyonel scriptler yazmanızı sağlar. Bunun için ANSI escape kodları kullanıyoruz.

# Renk kodlari
KIRMIZI='33[0;31m'
YESIL='33[0;32m'
SARI='33[1;33m'
MAVI='33[0;34m'
KALIN='33[1m'
ITALIK='33[3m'
SIFIRLA='33[0m'

# Kullanim ornekleri
echo -e "${YESIL}[BASARILI]${SIFIRLA} Yedekleme tamamlandi."
echo -e "${KIRMIZI}[HATA]${SIFIRLA} Veritabani baglantisi kurulamadi!"
echo -e "${SARI}[UYARI]${SIFIRLA} Disk dolulugu %85'i gecti."
echo -e "${MAVI}[BILGI]${SIFIRLA} Servis yeniden baslatiliyor..."

Bu pattern’i bir kez tanımladıktan sonra tüm scriptlerinizde tutarlı bir görünüm elde edebilirsiniz. Özellikle uzun süre çalışan backup veya deployment scriptlerinde kullanıcının ne olduğunu anlık olarak görmesi çok değerli.

Gerçek Dünya Senaryoları

Senaryo 1: Sistem Durum Raporu Scripti

Sabah işe geldiğinizde sunucuların genel durumunu hızlıca görmek için bir script:

#!/bin/bash

YESIL='33[0;32m'
KIRMIZI='33[0;31m'
SARI='33[1;33m'
SIFIRLA='33[0m'
CIZGI="=================================================="

echo -e "${CIZGI}"
echo -e "  SUNUCU DURUM RAPORU - $(date '+%d.%m.%Y %H:%M')"
echo -e "${CIZGI}"
echo ""

# CPU bilgisi
cpu_kullanim=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
echo -e "CPU Kullanimi    : ${SARI}%${cpu_kullanim}${SIFIRLA}"

# RAM bilgisi
ram_toplam=$(free -m | awk 'NR==2{print $2}')
ram_kullanim=$(free -m | awk 'NR==2{print $3}')
echo -e "RAM Kullanimi    : ${SARI}${ram_kullanim}MB / ${ram_toplam}MB${SIFIRLA}"

# Disk bilgisi
disk_kullanim=$(df -h / | awk 'NR==2{print $5}')
echo -e "Disk Kullanimi   : ${SARI}${disk_kullanim}${SIFIRLA}"

# Son login
echo -e "Son Login        : $(last -1 | head -1 | awk '{print $1, $3, $4, $5, $6}')"

echo ""
echo -e "${CIZGI}"

Senaryo 2: Log Dosyasına Zaman Damgalı Yazma

Script çalışırken hem ekrana hem de log dosyasına yazmak çok yaygın bir ihtiyaç:

#!/bin/bash

LOG_DOSYASI="/var/log/yedekleme.log"

log_yaz() {
    local mesaj="$1"
    local zaman=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$zaman] $mesaj" | tee -a "$LOG_DOSYASI"
}

log_yaz "Yedekleme islemi basliyor..."
log_yaz "Kaynak dizin kontrol ediliyor: /var/www/html"

if [ -d "/var/www/html" ]; then
    log_yaz "Dizin bulundu, yedekleme baslatiliyor..."
    # yedekleme komutu burada olacak
    log_yaz "Yedekleme tamamlandi."
else
    log_yaz "HATA: Dizin bulunamadi!"
    exit 1
fi

tee komutuyla birlikte hem terminale hem de dosyaya aynı anda yazabiliyorsunuz. Bu pattern production ortamında altın değerinde.

Senaryo 3: Kullanıcıdan Girdi Alma

echo -n ile prompt oluşturma:

#!/bin/bash

echo -n "Kullanici adi: "
read kullanici

echo -n "Sunucu IP adresi: "
read sunucu_ip

echo -n "Port numarasi [22]: "
read port
port=${port:-22}  # Bos birakildiysa 22 kullan

echo ""
echo -e "Baglanti bilgileri:"
echo -e "  Kullanici : ${kullanici}"
echo -e "  Sunucu    : ${sunucu_ip}"
echo -e "  Port      : ${port}"
echo ""
echo -n "Bu bilgilerle devam edilsin mi? (e/h): "
read onay

if [ "$onay" = "e" ]; then
    echo "Baglaniliyor..."
    ssh -p "$port" "${kullanici}@${sunucu_ip}"
else
    echo "Islem iptal edildi."
fi

echo ile Dosyaya Yazma

echo‘yu yönlendirme operatörleriyle birleştirerek dosyalara hızlıca içerik yazabilirsiniz.

# Yeni dosya olustur veya ustune yaz
echo "Bu bir test satirıdir" > /tmp/test.txt

# Dosyaya ekleme yap (var olani silmez)
echo "Bu satir eklendi" >> /tmp/test.txt

# Cok satirli dosya olusturma
echo -e "Satir 1nSatir 2nSatir 3" > /tmp/cok_satirli.txt

# Bos dosya olusturma (alternatif: touch komutu)
echo -n "" > /tmp/bos_dosya.txt

# Config dosyasina parametre ekleme
echo "MAX_CONNECTIONS=100" >> /etc/myapp/config.conf
echo "TIMEOUT=30" >> /etc/myapp/config.conf
echo "DEBUG=false" >> /etc/myapp/config.conf

Burada > ile >> arasındaki farka dikkat edin. > mevcut içeriği siler ve baştan yazar. >> ise var olan dosyanın sonuna ekler. Yanlış kullanım production ortamında ciddi veri kayıplarına yol açabilir.

Özel Karakterler ve Kaçış Dizileri

echo kullanırken özel karakterlerle bazen uğraşmak zorunda kalırsınız:

# Tirnak isaretleri
echo "Bu bir "alinti" metnidir"
echo 'It'''s a test'  # Tek tirnak icinde tek tirnak

# Dolar isareti - degisken olarak yorumlanmasin
echo "Fiyat: $25.00"
echo 'Fiyat: $25.00'  # Tek tirnak daha temiz

# Ters slash
echo "Windows yolu: C:\Users\Admin"

# Bos satir basmak
echo ""
echo  # Parametre vermeden de calisir

printf ile Karşılaştırma

echo her ne kadar kullanışlı olsa da bazı durumlarda printf daha iyi bir seçenek olabilir. Farkları bilmek hangi durumda hangisini kullanacağınıza karar vermenizi sağlar:

# echo ile basit cikti
echo "Merhaba $isim"

# printf ile formatli cikti - C'deki printf gibi calisir
printf "Merhaba %sn" "$isim"
printf "%-20s: %sn" "Sunucu Adi" "$(hostname)"
printf "%-20s: %d MBn" "Toplam RAM" "$(free -m | awk 'NR==2{print $2}')"
printf "%-20s: %.2f%%n" "CPU Kullanim" "75.5678"

# Birden fazla satir duzgun hizalama
printf "%-15s %-15s %-10sn" "KULLANICI" "SUNUCU" "PORT"
printf "%-15s %-15s %-10sn" "admin" "192.168.1.10" "22"
printf "%-15s %-15s %-10sn" "deploy" "192.168.1.20" "2222"

printf özellikle tablolu çıktı, sayı formatlama ve taşınabilir script yazmak için daha güvenilir. Ama günlük kullanımda basit mesajlar için echo her zaman daha pratik.

Script Debugging’de echo Kullanımı

Scriptleriniz beklenmedik davranışlar sergilediğinde echo en hızlı debug aracınızdır:

#!/bin/bash

# Degisken degerlerini kontrol et
kullanici="root"
dizin="/etc/nginx"
dosya_sayisi=$(ls "$dizin" 2>/dev/null | wc -l)

echo "DEBUG: kullanici=$kullanici"
echo "DEBUG: dizin=$dizin"
echo "DEBUG: dosya_sayisi=$dosya_sayisi"

# Kosul kontrolu
if [ "$kullanici" = "root" ]; then
    echo "DEBUG: Root kullanicisi, devam ediliyor"
    # islemler...
fi

# Dongu debug
for servis in nginx mysql redis; do
    echo "DEBUG: $servis kontrol ediliyor..."
    systemctl is-active "$servis" > /dev/null 2>&1
    if [ $? -eq 0 ]; then
        echo "  [CALISIYOR] $servis"
    else
        echo "  [DURDU] $servis"
    fi
done

Production ortamına geçmeden önce bu DEBUG satırlarını kaldırmayı ya da bir DEBUG=false değişkeniyle kontrol etmeyi unutmayın. Daha şık bir yöntem şu:

DEBUG=true

debug_mesaj() {
    if [ "$DEBUG" = "true" ]; then
        echo "[DEBUG] $1" >&2  # Stderr'e yaz, stdout'u kirletme
    fi
}

debug_mesaj "Script basliyor..."
debug_mesaj "Config dosyasi okunuyor..."

>&2 ile mesajı stderr’e yönlendiriyoruz. Bu sayede scriptinizin normal çıktısı temiz kalıyor, debug mesajları ayrı bir kanalda akıyor.

echo ile /dev/null Kullanımı

Zaman zaman bir komutun çıktısını susturmak isteyebilirsiniz. echo bağlamında değil ama pipeline içinde sıkça karşınıza çıkan bir pattern:

# Hata mesajlarini gizle
echo "test" > /dev/null 2>&1

# Sadece hatali calistiysa mesaj goster
komutum 2>/dev/null || echo "Komut basarisiz oldu, detaylar icin log'a bakin"

# Ciktiyi hem dosyaya hem ekrana yaz, hatalari gizle
echo "Islem tamamlandi" | tee /var/log/islem.log

Yaygın Hatalar ve Dikkat Edilecekler

Deneyimli sysadminlerin bile zaman zaman takıldığı birkaç nokta var:

  • Tırnak ihmalı: echo $degisken yerine echo "$degisken" kullanın. Değişken boşluk veya özel karakter içeriyorsa tırnaksız kullanım beklenmedik split davranışına yol açar.
  • -e parametresini unutmak: n gibi karakterlerin çalışması için mutlaka -e gerekir. Yoksa n literal olarak ekrana basar.
  • Bash ile sh farkı: Script başında #!/bin/bash yerine #!/bin/sh kullandıysanız, echo -e desteklenmeyebilir. printf kullanmak daha güvenli.
  • > yerine >> hatası: Dosyaya ekleme yaparken > kullanmak mevcut içeriği siler. Özellikle log dosyalarında bu hata can yakar.
  • Renk kodlarını sıfırlamamak: 33[0;31m ile kırmızı rengi açtıktan sonra 33[0m ile sıfırlamazsanız terminalin geri kalanı da renkli görünür.

Sonuç

echo ilk bakışta tek satır metin basan sıradan bir komut gibi görünse de sistem yönetiminin neredeyse her köşesinde karşımıza çıkıyor. Değişken kontrolü, renkli terminal çıktıları, log yönetimi, kullanıcı etkileşimi… Bunların hepsinde echo‘yu doğru ve etkili kullanmak scriptlerinizin hem okunabilirliğini hem de güvenilirliğini artırıyor.

Özellikle şu üç noktayı aklınızda tutun: değişkenleri her zaman çift tırnak içinde kullanın, -e parametresini escape karakterleri için aktif edin ve renk kodlarını sıfırlamayı unutmayın. Bu üç alışkanlık bile echo kullanımınızı önemli ölçüde iyileştirecek.

Sonraki adım olarak kendi scriptlerinizde bir log fonksiyonu oluşturun, bunu bir library dosyasına atın ve tüm scriptlerinizden source ile çağırın. Zaman içinde biriken bu küçük yardımcı fonksiyonlar sizi gerçekten hızlandırıyor.

Yorum yapın