Solidity Fonksiyon Türleri Nelerdir?

Fonksiyon türleri, farklı türlerde parametreler alabilen, çeşitli işlemleri gerçekleştiren ve sonucunda farklı türlerde değer döndürebilen ya da döndürmeyen fonksiyon türleridir.

Fonksiyonlar internal ya da external türlerde olabilir. Fonksiyon aracılığıyla depolama alanının yalnızca okunması, değişiklik yapılamaması istendiği durumlarda view , okuma ve yazma işlemlerinin hiçbirinin yapılmaması gerektiğindeyse pure etiketi kullanılır.

Solidity'nin önceki versiyonlarında bu iki tür yerine constant etiketi kullanılmakta olsa da güncel versiyonlarda pure ya da view kullanılması gerekmekedir. constant etiketi kullanılırsa derleyiciden Panic Error hatası fırlatılacaktır.

Fonksiyonlar işlemleri gerçekleştirdikten sonra değer döndürebilir. Fonksiyonlar döndüreceği değerleri returns (<dönüş tipi>) etiketi ile döndürmelidir. Not olarak, bir fonksiyonun değer döndürmesi zorunlu değildir.

Tüm bu etiketlerin örnek kullanımı aşağıdaki gibidir.

function (<parameter types>) {internal|external} [pure|view|payable] [returns (<return types>)]

Dahili fonksiyonlar yalnızca bulundukları sözleşmelerin -contract -içerisinde çağrılabilirler. Farklı sözleşmeler contract içerisinde kullanılamazlar.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;


//Kod: Solidity Docs
library ArrayUtils {
    // dahili fonksiyonlar yalnızca dahili kütüphanedeki fonksiyonlarda kullanılabilirler
    function map(uint[] memory self, function (uint) pure returns (uint) f)
        internal
        pure
        returns (uint[] memory r)
    {
        r = new uint[](self.length);
        for (uint i = 0; i < self.length; i++) {
            r[i] = f(self[i]);
        }
    }


    function reduce(
        uint[] memory self,
        function (uint, uint) pure returns (uint) f
    )
        internal
        pure
        returns (uint r)
    {
        r = self[0];
        for (uint i = 1; i < self.length; i++) {
            r = f(r, self[i]);
        }
    }


    function range(uint length) internal pure returns (uint[] memory r) {
        r = new uint[](length);
        for (uint i = 0; i < r.length; i++) {
            r[i] = i;
        }
    }
}




contract Pyramid {
    using ArrayUtils for *;


    function pyramid(uint l) public pure returns (uint) {
        return ArrayUtils.range(l).map(square).reduce(sum);
    }


    function square(uint x) internal pure returns (uint) {
        return x * x;
    }


    function sum(uint x, uint y) internal pure returns (uint) {
        return x + y;

Harici fonksiyonlar, address değerini ve fonksiyon imzasını bulunduran, farklı sözleşmelerde çağrılabilen, kullanılabilen ve sonucunda değer döndürebilen fonksiyonlardır.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;


//Kod: Solidity Docs
contract Oracle {
    //Request sınıfını(yapısını) tanımla
    struct Request {
        bytes data;
        //Harici bir callback fonksiyonu oluştur
        function(uint) external callback;
    }


    //Request yapısını gizli olarak kalıt
    Request[] private requests;
    event NewRequest(uint);


    function query(bytes memory data, function(uint) external callback) public {
        //Gelen isteği istekler listesine kaydedin
        requests.push(Request(data, callback));
        //Yeni bir istek olduğunu belirtelim
        emit NewRequest(requests.length - 1);
    }


    function reply(uint requestID, uint response) public {
        // İsteğin güvenilir kaynaktan gelip gelmediğini sorgula
        //Fonksiyonu harici olarak aldığımız için response değerini burada gönderebildik. Fonksiyonu farklı bir sözleşmeden direk aldık ve kullandık.
        requests[requestID].callback(response);
    }
}




contract OracleUser {
    //Oracle sözleşmesini kalıt
    Oracle constant private ORACLE_CONST = Oracle(address(0x00000000219ab540356cBB839Cbe05303d7705Fa)); // known contract
    //Döviz kuru değeri  tanımla
    uint private exchangeRate;


    //Alım fonksyionu oluştur
    function buySomething() public {
        ORACLE_CONST.query("USD", this.oracleResponse);
    }


    //Fonksiyonu external olarak tanımladık. Bu fonksiyonu this. kullanarak diğer sözleşmelerde kullanılacak şekilde kullanabiliriz.
    function oracleResponse(uint response) external {
        require(
            msg.sender == address(ORACLE_CONST),
            "Only oracle can call this."
        );
        exchangeRate = response;

Harici fonksiyonlar .addressve .selector ile birlikte kullanılabilirler.

• .address ,fonksiyonun bulunduğu sözleşmenin karma adresini(hash address) verir.
• .selector , ABI fonksiyon seçicisini döndürür.

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.4 <0.9.0;


contract Ornek{
    function fonksiyon() public payable returns (bytes4) {
        //Fonksiyon sözleşmesinin adresi 
        assert(this.fonksiyon.address == address(this));
        //ABI seçicisi bytes4 türündeki değerini döndürüyoruz.
        return this.fonksiyon.selector;
    }


    function gazAl() public {
        this.fonksiyon{gas: 10, value: 800}();
    }

public fonksiyonlar farklı sözleşmelerde kullanılabilirlerken private fonksiyonlar yalnızca dahil olduğu sözleşmede kullanılırlar.

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.7;


contract Ornek{
    function acikFonksiyon() public pure returns(address) {
        address adresim = 0x1234; //Örnek adres
        return adresim;
    }
}


contract Ornek2{
    address sozlesmeAdresi = 0x1234; //Örnek adres
    function ornekSozlesmedekiFonksiyonuKullan() private view{
        Ornek ornekSozlesmesi = Ornek(sozlesmeAdresi);
        ornekSozlesmesi.acikFonksiyon();
    }

Fonksiyonlarda bir değer döndürüleceği zaman returns (<return types>) komutu kullanılır ve returns kodu içerisine döndürülmek istenen türde en az bir değişken belirtilmek zorundadır. returns (<return types>) kodu kullanılmadığında fonksiyonun bir değer döndürmeyeceği anlaşılır. Bu durumu birçok programlama dilindeki void türüne benzetebiliriz.

• public , bulunduğu sözleşmenin yanında diğer sözleşmelerde de kullanılabilen fonksiyonlardır. Fonksiyonların varsayılan görünürlük değeridir.
• private , kendi oluşturulduğu sözleşmede kullanılabilen diğer sözleşmelerden erişilemeyen fonksiyonlardır.
• internal , sistem içerisindeki sözleşme ve bunlardan türetilmiş sözleşmelerdeki fonksiyonlardan erişiebilen dahili fonksiyonlardır.
• external , yalnızca harici olarak erişilebilen fonksiyonlardır. this. ile çağrılabilir.

Aşağıdaki örnek tüm maddeleri özetleyecek örnekleri bulunduruyor.

//G fonksiyonu public türündedir
function G() {  }
//Burada çağırdığımız G fonksiyon türüdür. Harici(internal) bir fonksiyondur.
function F(function (uint) G) { ... }