🧵 #100GündeSolidity 039 : Kütüphaneler

Kütüphaneler: Kodunuzu Daha Etkili Hale Getirmenin Yolu

Solidity programlama dili, akıllı sözleşmelerin yazılması için en sık kullanılan dil olarak öne çıkıyor. Sözleşmelerin karmaşıklığı arttıkça, tekrar eden kod blokları yazma ihtiyacı da artıyor. Bu durumda, kodun daha etkili hale getirilmesi için kütüphaneler kullanmak önemli bir adım haline geliyor. Bu e-bültenimizde Solidity’de kütüphanelerin ne olduğu, nasıl kullanıldığı ve ne gibi faydalar sağladığı hakkında detaylı bilgi edineceksiniz.

Kütüphane Nedir?

Kütüphaneler, Solidity programlama dilinde kullanılan ve birçok farklı sözleşmede ortak olarak kullanılan kod bloklarının tekrar tekrar yazılmasını önlemek için oluşturulan bir yapıdır. Kütüphaneler, sözleşme kodlarında kullanılan fonksiyonları içerebilen bir dosyadır.

Kütüphanelerin birçok avantajı vardır. En önemli avantajlarından biri, kodun daha az tekrarlanarak daha az hata yapılmasını sağlamasıdır. Ayrıca, kodun daha az yer kaplaması, daha hızlı yürütülmesi ve daha kolay bakım yapılması da sağlanır. Bu nedenle, Solidity programlama dilinde kütüphaneler kullanmak, kodun daha verimli ve okunabilir hale getirilmesinde önemli bir adımdır.

Kütüphane ve Sözleşmeler Arasındaki Farklar Nelerdir?

Kütüphaneler ve sözleşmeler Solidity programlama dilinde kullanılan iki farklı yapıdır. İkisi arasındaki farklar şöyle özetlenebilir:

1. Kütüphaneler, state variable (durum değişkeni) tanımlayamazlar. Sözleşmeler ise tanımlayabilirler.
2. Kütüphaneler, Ethereum ağında bir hesap olarak konuşlandırılamazlar ve Ether alamazlar. Sözleşmeler ise bir Ethereum hesabı olarak konuşlandırılabilir ve Ether alabilirler.
3. Kütüphaneler, bir sözleşmenin içinde yer alabilirler. Sözleşmeler ise kendi başlarına ayakta durabilen bir yapıya sahiptirler.
4. Kütüphaneler, fonksiyonlarına dışarıdan erişilmesini sağlamak için export anahtar kelimesi kullanırlar. Sözleşmelerin fonksiyonları ise varsayılan olarak erişime açıktır.
5. Kütüphaneler, yalnızca diğer sözleşmelerin içinde kullanılabilirler. Sözleşmeler ise, diğer sözleşmelerin yanı sıra kullanıcılar ve dış sistemler tarafından da çağrılabilirler.

Bu farklılıklar, kütüphanelerin ve sözleşmelerin farklı amaçlar için kullanılabilecekleri anlamına gelir. Kütüphaneler, kodun daha verimli bir şekilde yazılmasını sağlarken, sözleşmeler, işlevlerini yerine getirmek ve akıllı sözleşme platformunda çalışmak için kullanılır.

Kütüphane Nasıl Tanımlanır?

Kütüphaneler, Solidity programlama dilinde “library” anahtar kelimesiyle tanımlanırlar. Kütüphane tanımlanırken aşağıdaki özellikler belirtilmelidir:

1. Kütüphane adı: Kütüphanenin adı, diğer fonksiyonlar gibi bir isimle belirlenir.
2. Fonksiyonlar: Kütüphanenin içinde yer alacak fonksiyonlar, normal fonksiyonlar gibi tanımlanır. Ancak, fonksiyonlara “library” anahtar kelimesi eklenerek tanımlanırlar.

Aşağıdaki örnek, basit bir kütüphane tanımlaması göstermektedir:

// Kütüphane tanımı
library MyLibrary {
  function add(uint256 a, uint256 b) public pure returns (uint256) {
    return a + b;
  }

  function sub(uint256 a, uint256 b) public pure returns (uint256) {
    return a - b;
  }
}

Yukarıdaki örnekte, “MyLibrary” adlı bir kütüphane tanımlanmıştır. Bu kütüphane, iki adet fonksiyona sahiptir: “add” ve “sub”. Bu fonksiyonlar, sayısal değerlerin toplamı ve farkı hesaplamak için kullanılabilirler. Bu fonksiyonlar, “pure” anahtar kelimesiyle tanımlanmıştır. “pure” anahtar kelimesi, fonksiyonun state variable’ları değiştirmeyeceğini ve başka bir sözleşmeye ether transferi yapmayacağını belirtir.

İçsel Kütüphaneler ve Gömülü Kütüphaneler Arasındaki Farklar Nelerdir?

Solidity’de, kütüphaneler iki farklı şekilde kullanılabilir: içsel kütüphaneler (internal libraries) ve gömülü kütüphaneler (embedded libraries).

İçsel kütüphaneler, kütüphanenin tüm fonksiyonlarının, tanımlandığı sözleşmenin içinde kullanıldığı durumlarda kullanılır. Bu durumda kütüphane, sözleşmenin bytecode’una dahil edilir ve kod boyutunu azaltır. İçsel kütüphaneler, “internal” anahtar kelimesiyle tanımlanırlar ve sadece aynı sözleşme içinde kullanılabilirler. Örneğin:

contract MyContract {
  // İçsel kütüphane tanımı
  library MyLibrary {
    // ...
  }

  // MyLibrary kütüphanesindeki fonksiyonları kullanmak için
  // bir fonksiyon tanımlıyoruz
  function useMyLibrary() public {
    uint256 result = MyLibrary.add(2, 3);
    // ...
  }
}

Gömülü kütüphaneler, kütüphanenin ayrı bir sözleşme olarak deploy edildiği ve daha sonra farklı sözleşmeler tarafından kullanıldığı durumlarda kullanılır. Bu durumda kütüphane, önce deploy edilir ve sonra sözleşme tarafından kullanılabilmesi için linklenir. Gömülü kütüphaneler, “library” anahtar kelimesiyle tanımlanırlar ve “internal” anahtar kelimesi kullanılamaz. Örneğin:

// Gömülü kütüphane sözleşmesi
library MyLibrary {
  // ...
}

// Kullanılacak sözleşme
contract MyContract {
  // Kütüphane adresi
  address myLibraryAddress = 0x123...;

  // MyLibrary kütüphanesindeki fonksiyonları kullanmak için
  // bir fonksiyon tanımlıyoruz
  function useMyLibrary() public {
    MyLibrary myLibrary = MyLibrary(myLibraryAddress);
    uint256 result = myLibrary.add(2, 3);
    // ...
  }
}

Gömülü kütüphaneler, daha modüler bir kod yapısı sağlar ve aynı kütüphanenin farklı sözleşmeler tarafından kullanılabilmesine imkan verir. Ancak, içsel kütüphanelere göre daha fazla deploy işlemi gerektirirler ve daha yüksek gas maliyeti oluşturabilirler.

Kütüphanelerin Kullanımı ve Faydaları Nelerdir?

Solidity’de kütüphaneler, tekrar kullanılabilir kod bloklarını kolayca oluşturmak için kullanılabilirler. Bu, kodun daha az yazılmasına ve daha az hata yapılmasına yardımcı olur. Kütüphaneler, özellikle sık kullanılan matematiksel işlemler, veri türleri ve fonksiyonlar için kullanışlıdır. Bazı kullanımlar şunları içerir:

1. Kod tekrarını önleme: Sık sık kullanılan kod parçalarını kütüphanelere taşımak, kod tekrarını önleyerek daha az kod yazılmasını sağlar ve kodu daha modüler hale getirir.
2. Kod boyutunu azaltma: Kütüphaneler, kodun boyutunu azaltarak, daha az gas tüketir ve daha hızlı bir şekilde çalışır.
3. Güvenlik: Kütüphaneler, sık kullanılan kod bloklarını güvenli bir şekilde kullanmayı sağlar. Özellikle matematiksel fonksiyonlarda doğru sonuçların üretilmesi ve olası hataların en aza indirgenmesi için kütüphaneler kullanışlıdır.
4. Modülerlik: Kütüphaneler, sözleşmeler arasında kodu paylaşmayı ve kodu daha modüler hale getirmeyi sağlar. Bu, daha büyük ve karmaşık sözleşmelerin daha kolay yazılmasını ve yönetilmesini sağlar.

Kütüphaneler, Solidity geliştiricileri için güçlü bir araçtır ve kod yazma sürecini kolaylaştırır.

Kütüphanelerin Kurulumu ve Bağlantısı Nasıl Yapılır?

Bir kütüphane tanımlamak için, library anahtar kelimesi kullanılır ve bu tanımlama sözleşmenin içinde yer alır. Kütüphane, içsel (internal) veya harici (external) olabilir.

İçsel bir kütüphane, sadece sözleşmenin içinde kullanılabilir ve kütüphaneye erişmek için bir bağlantı gerektirmez. Bu nedenle, sözleşme ve kütüphane aynı bytecode içinde yer alır. İçsel kütüphaneler için, tüm fonksiyonlar internal olarak tanımlanmalıdır. Aşağıdaki örnek, içsel bir kütüphane kullanımını göstermektedir:

pragma solidity ^0.8.0;

library Math {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }
}

contract MyContract {
    function doMath(uint a, uint b) external pure returns (uint) {
        return Math.add(a, b);
    }
}

Harici bir kütüphane, ayrı bir sözleşme olarak tanımlanır ve daha sonra sözleşme içinde kullanılmak üzere bağlanır (link edilir). Harici kütüphaneler, import anahtar kelimesi kullanılarak çağrılır. Aşağıdaki örnek, harici bir kütüphanenin nasıl kullanılacağını göstermektedir:

pragma solidity ^0.8.0;

import "./Math.sol";

contract MyContract {
    function doMath(uint a, uint b) external pure returns (uint) {
        return Math.add(a, b);
    }
}

./Math.sol import satırı, Math isimli harici bir kütüphanenin dosyasını çağırır. Kütüphanenin fonksiyonlarına erişmek için, Math. ifadesi kullanılır.

Harici kütüphaneler, önceki örnekte olduğu gibi internal fonksiyonlar içerebilir. Bu durumda, fonksiyonlar public yerine external olarak tanımlanır.

Kütüphanelerle İlgili Örnekler ve Kod Parçaları

Aşağıda, kütüphanelerle ilgili örnekler ve kod parçaları verilmiştir:

Örnek 1: İçsel bir kütüphanenin kullanımı

pragma solidity ^0.8.0;

library Math {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }
}

contract MyContract {
    function doMath(uint a, uint b) external pure returns (uint) {
        return Math.add(a, b);
    }
}

Bu örnekte, Math isimli bir içsel kütüphane tanımlanır. add fonksiyonu, iki sayının toplamını döndürür. MyContract isimli sözleşme, doMath fonksiyonu aracılığıyla Math kütüphanesinin add fonksiyonunu kullanır.

Örnek 2: Harici bir kütüphanenin kullanımı

pragma solidity ^0.8.0;

import "./Math.sol";

contract MyContract {
    function doMath(uint a, uint b) external pure returns (uint) {
        return Math.add(a, b);
    }
}

Bu örnekte, Math isimli harici bir kütüphane import anahtar kelimesi kullanılarak çağrılır. MyContract isimli sözleşme, doMath fonksiyonu aracılığıyla Math kütüphanesinin add fonksiyonunu kullanır.

Örnek 3: Harici bir kütüphanenin oluşturulması

pragma solidity ^0.8.0;

library Math {
    function add(uint a, uint b) external pure returns (uint) {
        return a + b;
    }
}

contract MyContract {
    function doMath(uint a, uint b) external pure returns (uint) {
        return Math.add(a, b);
    }
}

library StringUtils {
    function concat(string memory a, string memory b) external pure returns (string memory) {
        bytes memory ba = bytes(a);
        bytes memory bb = bytes(b);
        bytes memory result = new bytes(ba.length + bb.length);
        uint i;
        uint j = 0;
        for (i = 0; i < ba.length; i++) {
            result[j++] = ba[i];
        }
        for (i = 0; i < bb.length; i++) {
            result[j++] = bb[i];
        }
        return string(result);
    }
}

Bu örnekte, Math kütüphanesiyle birlikte StringUtils isimli bir harici kütüphane de tanımlanır. concat fonksiyonu, iki string ifadesini birleştirir ve sonucu döndürür. MyContract isimli sözleşme, doMath fonksiyonu aracılığıyla Math kütüphanesinin add fonksiyonunu kullanırken, StringUtils kütüphanesi, sözleşmede kullanılmaz. Ancak, bu kütüphane, diğer sözleşmelerde kullanılabilir.

SONUÇ BAĞLAMI

Kütüphaneler, Solidity programlama dilinde, ortak işlevlerin birden fazla sözleşmede kullanılması gerektiğinde yeniden kullanılabilir birimler olarak kullanılır. İçsel kütüphaneler, sözleşmenin içinde tanımlanırken, harici kütüphaneler ayrı bir dosyada oluşturulur. Kütüphaneler, gas tasarrufu sağlayarak ve kodun daha modüler olmasını sağlayarak faydalıdır. Kütüphaneler, Solidity ile geliştirme yaparken, sık kullanılan kod bloklarının paylaşılmasına ve tekrar kullanılmasına olanak tanır. Bu, programlama sürecini daha verimli ve hızlı hale getirir.

Solidity Programlama Dili Öğrenme yolculuğunuz hakkında daha iyi rehberlik almak için Solidity nedir? Ethereum Akıllı Sözleşmelerinin Dili Rehberi içeriğimize göz atın. Dilerseniz Yeni Başlayanlar için Solidity – Akıllı Sözleşme Geliştirme Hızlandırılmış Kursuna katılın.

Çalışmaya nereden başlayacağım diyenler için Blockchain ​​Developer Olmak İçin Yol Haritası içeriğine de muhakkak bakın.

Gelin aklınızdaki soruları SUPERPEER sohbetinde cevaplayalım.

Bu makaleyi okuduğunuz için teşekkürler! Bana destek olmak isterseniz;

Beni Twitter, Linkedin ve YouTube‘da takip edin.

Kısa bir yorum bırakmayı UNUTMAYIN!