Array Kullanımı: Eleman Ekleme, Silme, Arama ve Sıralama İşlemleri
#100GündeSolidity serisinin 13. gününde “Array” üzerine konuşacağız. Haydi bugün hangi konulara değineceğimizi listeleyelim.
- Array nedir ve nasıl kullanılır?
- Array’te eleman ekleme ve silme işlemleri.
- Array içinde arama yapma.
- Array sıralama işlemleri.
- Array’lerin diğer veri tipleriyle nasıl kullanılacağı.
- Array’lerin sınırları ve performansı.
- Array’lerin fonksiyonlara ve kontratlara nasıl geçirileceği.
- Array’lerin kullanımı örnek uygulamalarda.
Array nedir ve nasıl kullanılır?
Array, Solidity programlama dili içerisinde kullanılan bir veri yapısıdır. Array, birden fazla elemanın saklandığı ve indeks numarası ile erişilebilen bir dizidir. Array’ler, aynı veri tipindeki elemanları saklamak için kullanılır. Örneğin, bir dizi içerisinde sadece tamsayılar saklanabilir veya bir dizi içerisinde sadece adresler saklanabilir.
Array kullanımı, aşağıdaki gibi yapılır:
// Tam sayıları içeren bir array oluşturma
uint[] sayilar;
// Adresleri içeren bir array oluşturma
address[] adresler;
Array’ler, ilklendirme işlemi yapılmadıklarından başlangıçta boşdur. Eleman eklemek için, dizinin indeks numarasını kullanabiliriz:
// 0. indekse değer atama
sayilar[0] = 5;
// 1. indekse değer atama
adresler[1] = 0x1234567890abcdef;
Array içindeki elemanları erişmek için indeks numarası kullanılır :
// 0. indeksteki değer
uint ilkDeger = sayilar[0];
// 1. indeksteki değer
address ikinciAdres = adresler[1];
Array’lerin boyutu, ilklendirme yapıldığı anda belirlenir ve değiştirilemez. Boyutu belirli bir değerden daha fazla eleman eklemek istenirse, ayrı bir array oluşturulmalıdır.
Array’te eleman ekleme ve silme işlemleri
Array’de eleman ekleme işlemi, dizinin sonuna eleman eklemek için push() fonksiyonu kullanılır. Bu fonksiyon, dizinin sonuna yeni bir eleman ekler ve dizinin boyutunu arttırır. Örnek olarak:
// sayilar dizisi tanımlanmış
sayilar.push(6); // dizinin sonuna 6 eklenir
sayilar.push(7); // dizinin sonuna 7 eklenir
Array’de eleman silme işlemi, dizinin sonundan eleman silmek için pop() fonksiyonu kullanılır. Bu fonksiyon, dizinin sonundaki elemanı siler ve dizinin boyutunu azaltır. Örnek olarak:
// sayilar dizisi tanımlanmış ve içinde elemanlar var
sayilar.pop(); // dizinin sonundaki eleman silinir
Ayrıca Array’de belirli indeksteki elemanı silmek için delete keyword kullanabiliriz :
delete sayilar[1]; // 1. indeksdeki eleman silinir
Delete keyword’ü kullanarak silinen elemanlar için memory boşluğu temizlenmez. Bu yüzden bu yöntem performans açısından uygun değildir.
Not: Array’de eleman ekleme ve silme işlemleri sadece dizinin sonuna yapılabilir. Array’lerin başlangıcındaki elemanları eklemek veya silmek için farklı yöntemler kullanılmalıdır.
Array içinde arama yapma
Array içinde arama yapmak için, dizi içindeki elemanların indeks numarasını kullanabiliriz. Örneğin, bir dizi içinde aranacak değerin indeks numarasını bulmak için aşağıdaki gibi bir kod yazabiliriz:
function findIndex(uint[] _array, uint _value) public view returns(uint) {
for (uint i = 0; i < _array.length; i++) {
if (_array[i] == _value) {
return i;
}
}
return uint(-1);
}
Bu fonksiyon, verilen dizi ve aranacak değer için dizi içinde arama yapar ve eğer aranan değer dizi içinde mevcutsa, değerin indeks numarasını döndürür. Eğer aranan değer dizi içinde mevcut değilse, -1 değerini döndürür.
Ayrıca arama işlemi için built-in fonksiyonları kullanabiliriz. indexOf() fonksiyonu, verilen değerin dizi içindeki ilk indeks numarasını döndürür. Eğer aranan değer dizi içinde yoksa, -1 döndürür.
function findIndex(uint[] memory _array, uint _value) public view returns(int) {
return _array.indexOf(_value);
}
Ayrıca contains() fonksiyonu ile dizide aradığınız elemanın var olup olmadığını kontrol edebilirsiniz.
function isExist(uint[] memory _array, uint _value) public view returns(bool) {
return _array.contains(_value);
}
Not: Bu fonksiyonlar sadece Solidity 0.8 veya daha üst sürümlerinde mevcut.
Array sıralama işlemleri
Array sıralama işlemleri, dizi içindeki elemanların belirli bir sıralama kriteriye göre yeniden dizilenmesini sağlar. Solidity dilinde, array sıralama işlemleri için built-in fonksiyonlar mevcut değildir. Ancak, kullanıcı tarafından yazılan fonksiyonlar kullanarak diziyi sıralayabiliriz.
Aşağıdaki örnekte, sortArray() fonksiyonu bir diziyi küçükten büyüğe sıralar:
function sortArray(uint[] memory _array) public pure {
for (uint i = 0; i < _array.length; i++) {
for (uint j = i + 1; j < _array.length; j++) {
if (_array[i] > _array[j]) {
// Elemanların yerlerini değiştir
uint temp = _array[i];
_array[i] = _array[j];
_array[j] = temp;
}
}
}
}
Bu fonksiyon, bubble sort algoritmasını kullanarak diziyi sıralar. Bu algoritma, dizinin elemanlarını ikişer ikişer karşılaştırarak, dizinin sonunda en büyük elemanı yerleştirir. Bu işlem dizinin boyutu kadar tekrarlanır ve sonunda dizi küçükten büyüğe sıralanmış olur.
Ayrıca sıralama işlemi için farklı algoritmalar kullanılabilir. Örneğin, quick sort, merge sort gibi.
Not: Bu fonksiyon sadece memory’de yer alan dizileri sıralayabilir. Storage‘da yer alan diziler için sıralama fonksiyonları yazmak daha kapsamlı ve dikkatli olması gereken bir işlemdir.
Array’lerin diğer veri tipleriyle nasıl kullanılacağı
Array, Solidity dilinde sadece bir veri tipi olarak değil aynı zamanda diğer veri tipleriyle de kullanılabilir. Örneğin, bir struct içerisinde array olarak tanımlanmış elemanlar bulunabilir veya bir fonksiyonun parametresi olarak array tipinde bir değer alabilir.
Aşağıdaki örnekte, bir struct içerisinde array olarak tanımlanmış elemanlar bulunur :
struct Ogrenci {
address adres;
uint[] notlar;
}
Bu struct içerisinde, bir adres ve bir notlar array’i bulunur. Bu struct, bir öğrencinin adresi ve notlarını saklamak için kullanılabilir.
Ayrıca bir fonksiyonun parametresi olarak array tipinde bir değer alabilir. Örnek olarak aşağıdaki gibi bir fonksiyon tanımlayabiliriz:
function ortalamaHesapla(uint[] _notlar) public view returns (uint) {
uint toplam = 0;
for (uint i = 0; i < _notlar.length; i++) {
toplam += _notlar[i];
}
return toplam / _notlar.length;
}
Bu fonksiyon, verilen notlar array’inin ortalamasını hesaplar ve döndürür.
Not: Array’lerin diğer veri tipleriyle kullanımı, programlama dillerinde olduğu gibi Solidity dilinde de aynıdır. Array’ler, veri yapıları olarak kullanılabildiği gibi, fonksiyon parametreleri veya değişkenler olarak da kullanılabilir.
Array’lerin sınırları ve performansı
Array’ler, Solidity dilinde sınırlı bir boyutta oluşturulabilirler. Bu sınır, 2^256 – 1 adet eleman saklamak için yeterlidir. Ancak, bu sınırın üzerinde bir boyutta array oluşturmak performans açısından sakıncalı olabilir. Bu nedenle, array’lerin boyutu ihtiyaçlar doğrultusunda ve performans açısından uygun seviyede oluşturulmalıdır.
Array’lerin performansı, boyutlarına ve işlemlerine bağlı olarak değişebilir. Örneğin, dizi içinde arama işlemi, dizi boyutu büyüdükçe daha yavaş olabilir. Aynı şekilde, dizi içinde eleman ekleme ve silme işlemleri, dizi boyutu büyüdükçe daha yavaş olabilir.
Array’lerin boyutlarını sınırlamak için kullanılan yöntemler arasında isDynamic() fonksiyonu vardır. Bu fonksiyon, dizi boyutunu kontrol eder ve sınırlar içerisinde kalıyorsa true, aksi halde false döndürür.
function isDynamic(uint[] memory _arr) public pure returns(bool){
return _arr.length <= MAX_SIZE;
}
Ayrıca array’lerin boyutlarını sınırlamak için gerekli olan performans için, yerine mapping yapısını kullanabilirsiniz. Mapping yapısı, key-value şeklinde verileri saklamak için kullanılan bir veri yapısıdır. Bu yapı performans açısından daha avantajlıdır.
Son olarak, array’lerin performansını arttırmak için dizi boyutlarını sınırlamak ve gerektiğinde diğer veri yapılarını kullanmak önemlidir.
Array’lerin fonksiyonlara ve kontratlara nasıl geçirileceği
Array’ler, Solidity dilinde fonksiyonlara ve kontratlara direk olarak geçirilebilir. Array’ler, fonksiyon parametreleri olarak veya değişken olarak kullanılabilir. Örneğin, bir fonksiyonun parametresi olarak array tipinde bir değer alabilir.
Aşağıdaki örnekte, bir fonksiyonun parametresi olarak array tipinde bir değer alır:
function ortalamaHesapla(uint[] _notlar) public view returns (uint) {
uint toplam = 0;
for (uint i = 0; i < _notlar.length; i++) {
toplam += _notlar[i];
}
return toplam / _notlar.length;
}
Bu fonksiyon, verilen notlar array’inin ortalamasını hesaplar ve döndürür.
Array’lerin kullanım örnekleri
Array’ler, Solidity dilinde çeşitli kullanım alanlarına sahiptir. Örneğin:
- Bir blockchain platformunda, bir kullanıcının işlem geçmişini saklamak için array kullanabiliriz.
- Bir oyun platformunda, oyuncunun skor geçmişini saklamak için array kullanabiliriz.
- Bir e-ticaret platformunda, bir ürünün fiyat geçmişini saklamak için array kullanabiliriz.
- Bir arama motorunda, kullanıcıların arama geçmişini saklamak için array kullanabiliriz.
- Bir topluluk platformunda, bir kullanıcının yaptığı yorumları saklamak için array kullanabiliriz.
Aşağıdaki örnekte, bir dizi oluşturup içine eleman ekleyip sonra dizinin içeriğini göstermek için kullanılır.
pragma solidity ^0.8.0;
contract ArrayExample {
uint[] public sayilar;
function addNumber(uint _number) public {
sayilar.push(_number);
}
function getNumbers() public view returns(uint[] memory) {
return sayilar;
}
}
Bu örnekte, addNumber fonksiyonu ile diziye eleman eklenir, getNumbers fonksiyonu ile ise dizinin içeriği görüntülenir.
Array’ler, veri yapıları olarak kullanıldıklarında, verilerin yönetiminde ve saklanmasında çok yararlı olabilir. Ancak, array’lerin performansı ve boyutları dikkate alınmalıdır.
Örnek Akıllı Sözleşme Analizi
Sözleşme 1
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract Array {
// Several ways to initialize an array
uint[] public arr;
uint[] public arr2 = [1, 2, 3];
// Fixed sized array, all elements initialize to 0
uint[10] public myFixedSizeArr;
function get(uint i) public view returns (uint) {
return arr[i];
}
// Solidity can return the entire array.
// But this function should be avoided for
// arrays that can grow indefinitely in length.
function getArr() public view returns (uint[] memory) {
return arr;
}
function push(uint i) public {
// Append to array
// This will increase the array length by 1.
arr.push(i);
}
function pop() public {
// Remove last element from array
// This will decrease the array length by 1
arr.pop();
}
function getLength() public view returns (uint) {
return arr.length;
}
function remove(uint index) public {
// Delete does not change the array length.
// It resets the value at index to it's default value,
// in this case 0
delete arr[index];
}
function examples() external {
// create array in memory, only fixed size can be created
uint[] memory a = new uint[](5);
}
}
Bu akıllı sözleşme, bir array veri yapısını kullanarak farklı işlemler yapabileceğimiz bir örnek sözleşmedir.
Sözleşmenin başında, 3 adet array tanımlanmıştır. İlki arr adında ve tanımlanmış ama başlangıç değeri yok, ikincisi arr2 adında ve [1,2,3] değerleri ile başlangıç değeri verilmiş, üçüncüsü ise sabit boyutlu ve tüm elemanların başlangıç değeri 0 olarak tanımlanmıştır.
Sözleşme içinde, array içinden bir elemana erişmek için get fonksiyonu, array’in tamamını döndürmek için getArr fonksiyonu, array’e eleman eklemek için push fonksiyonu, array’den eleman silmek için pop ve remove fonksiyonları, array’in boyutunu döndürmek için getLength fonksiyonları mevcut.
pop fonksiyonu ile array’in son elemanı silinirken, remove fonksiyonu ile belirli bir indexteki eleman silinir. delete operatörü kullanıldığında, indexteki elemanın değeri varsayılan değerine (0) geri döner.
examples fonksiyonu içerisinde ise, memory alanında sabit boyutlu bir array oluşturulmuş.
Sözleşme içerisinde yer alan fonksiyonlar, array veri yapısının nasıl kullanılabileceğini ve nasıl işlem yapabileceğimizi göstermektedir. Ancak, array’lerin performansı ve boyutları dikkate alınması gerektiği unutulmamalıdır.
Sözleşme 2
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract ArrayRemoveByShifting {
// [1, 2, 3] -- remove(1) --> [1, 3, 3] --> [1, 3]
// [1, 2, 3, 4, 5, 6] -- remove(2) --> [1, 2, 4, 5, 6, 6] --> [1, 2, 4, 5, 6]
// [1, 2, 3, 4, 5, 6] -- remove(0) --> [2, 3, 4, 5, 6, 6] --> [2, 3, 4, 5, 6]
// [1] -- remove(0) --> [1] --> []
uint[] public arr;
function remove(uint _index) public {
require(_index < arr.length, "index out of bound");
for (uint i = _index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
arr.pop();
}
function test() external {
arr = [1, 2, 3, 4, 5];
remove(2);
// [1, 2, 4, 5]
assert(arr[0] == 1);
assert(arr[1] == 2);
assert(arr[2] == 4);
assert(arr[3] == 5);
assert(arr.length == 4);
arr = [1];
remove(0);
// []
assert(arr.length == 0);
}
}
Bu akıllı sözleşme, array veri yapısından belirli bir indexteki elemanı silmek için kullanabileceğimiz bir yöntemi göstermektedir.
Sözleşmede remove fonksiyonu tanımlanmıştır. Bu fonksiyon, belirli bir indexteki elemanı silmek için kullanılır. Öncelikle, silinecek indexin array boyutunun dışında olup olmadığı kontrol edilir. Daha sonra, silinecek indexteki eleman ile sonraki eleman arasındaki tüm elemanlar, bir sonraki elemana kaydırılır. En sonunda, array’in son elemanı silinir. Bu yöntemle, array boyutu korunur ancak silinen indexteki eleman yerine sonraki elemanlar kaydırılır.
Sözleşme içerisinde yer alan test fonksiyonu, remove fonksiyonunun nasıl kullanılabileceğini göstermek için birkaç örnek kullanım sunmaktadır. Örnekte remove(2) ile belirtilen indexteki eleman silinir ve array boyutu değişmez ancak silinen indexteki eleman yerine sonraki elemanlar kaydırılır.
Bu sözleşme, array veri yapısından belirli bir indexteki elemanı silmek için kullanabileceğimiz bir yöntemi gösterir. Ancak, array boyutunun kontrolü önemlidir ve bu yöntem performans açısından yavaş olabilir.
Sözleşme 3
Bu akıllı sözleşme, array veri yapısından belirli bir indexteki elemanı silmek için kullanabileceğimiz bir yöntemi göstermektedir.
Sözleşmede remove fonksiyonu tanımlanmıştır. Bu fonksiyon, belirli bir indexteki elemanı silmek için kullanılır. Öncelikle, silinecek indexteki eleman ile array’in son elemanı yer değiştirilir. Daha sonra, array’in son elemanı silinir. Bu yöntemle, array boyutu korunur ancak silinen indexteki eleman yerine array’in son elemanı yerleştirilir.
Sözleşme içerisinde yer alan test fonksiyonu, remove fonksiyonunun nasıl kullanılabileceğini göstermek için birkaç örnek kullanım sunmaktadır. Örnekte remove(1) ile belirtilen indexteki eleman silinir ve array boyutu değişmez ancak silinen indexteki eleman yerine array’in son elemanı yerleştirilir.
Bu sözleşme, array veri yapısından belirli bir indexteki elemanı silmek için kullanabileceğimiz bir yöntemi gösterir. Ancak, array boyutunun kontrolü önemlidir ve bu yöntem performans açısından daha hızlı olabilir.
Örnek Akıllı Sözleşme Karşılaştırması
1 – ArrayRemoveByShifting sözleşmesi:
- İşlev: Bu sözleşme belirli bir indexteki elemanı silmek için bir yöntem sunmaktadır. Silinen indexteki eleman ile sonraki elemanlar arasındaki tüm elemanlar bir sonraki elemana kaydırılır. Array boyutu korunur ancak silinen indexteki eleman yerine sonraki elemanlar kaydırılır.
- Verimlilik: Bu yöntem performans açısından yavaş olabilir çünkü silinen indexteki eleman ile sonraki elemanlar arasındaki tüm elemanlar bir sonraki elemana kaydırılır.
- Güvenlik: Bu sözleşme içerisinde indexin array boyutunun dışında olup olmadığı kontrol edilir. Bu nedenle, array içinde güvenli bir şekilde eleman silme işlemi gerçekleştirilir.
2 – ArrayReplaceFromEnd sözleşmesi:
- İşlev: Bu sözleşme belirli bir indexteki elemanı silmek için bir yöntem sunmaktadır. Silinecek indexteki eleman ile array’in son elemanı yer değiştirilir.
- Verimlilik: Bu yöntem performans açısından daha hızlı olabilir çünkü sadece array’in son elemanı ile silinecek indexteki eleman yer değiştirir. Array boyutu korunur ve silinen indexteki eleman yerine array’in son elemanı yerleştirilir.
- Güvenlik: Bu sözleşme içerisinde indexin array boyutunun dışında olup olmadığı kontrol edilmemektedir. Bu nedenle, array içinde güvenli bir şekilde eleman silme işlemi gerçekleştirilmeyebilir.
3 – Array sözleşmesi:
- İşlev: Bu sözleşme array veri yapısını kullanarak farklı işlemler yapabileceğimiz bir örnek sözleşmedir. Array içinden elemana erişme, eleman ekleme, eleman silme, array boyutunu döndürme gibi işlemler yapılabilir.
- Verimlilik: Bu sözleşme içerisinde array boyutunun kontrolü yapılmış ancak verimlilik açısından diğer sözleşmelerle karşılaştırıldığında farklılık yok.
- Güvenlik: Bu sözleşme içerisinde indexin array boyutunun dışında olup olmadığı kontrol edilmiştir. Bu nedenle, array içinde güvenli bir şekilde eleman silme işlemi gerçekleştirilir.
Sonuç olarak, her üç sözleşme de array veri yapısını kullanarak farklı işlemler yapabileceğimiz örnek sözleşmelerdir. Ancak, ArrayRemoveByShifting ve ArrayReplaceFromEnd sözleşmelerinde eleman silme işlemi gerçekleştirilirken verimlilik ve güvenlik açısından farklılıklar vardır. ArrayRemoveByShifting sözleşmesi indexin array boyutunun dışında olup olmadığını kontrol eder ve silinen indexteki eleman ile sonraki elemanlar arasındaki tüm elemanlar bir sonraki elemana kaydırır. ArrayReplaceFromEnd sözleşmesi ise indexin array boyutunun dışında olup olmadığını kontrol etmez ancak silinecek indexteki eleman ile array’in son elemanı yer değiştirir. Bu nedenle, ArrayRemoveByShifting sözleşmesi güvenlik açısından daha iyidir ancak ArrayReplaceFromEnd sözleşmesi performans açısından daha iyidir.
Örnek Akıllı Sözleşmelerinin Yeniden Dizaynı
3 Örnek sözleşmeyi tek bir sözleşme olarak düzenlemek istesek, yeni akıllı sözleşme nasıl olurdu?
pragma solidity ^0.8.17;
contract ArrayManipulation {
uint[] public arr;
function remove(uint index) public {
require(index < arr.length, "index out of bound");
// method 1: shift all elements to the right of the deleted index
for (uint i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
arr.pop();
}
function remove2(uint index) public {
require(index < arr.length, "index out of bound");
// method 2: replace the deleted index with the last element
arr[index] = arr[arr.length - 1];
arr.pop();
}
function remove3(uint index) public {
require(index < arr.length, "index out of bound");
// method 3: delete the element at the index
delete arr[index];
}
function push(uint i) public {
// Append to array
// This will increase the array length by 1.
arr.push(i);
}
function pop() public {
// Remove last element from array
// This will decrease the array length by 1
arr.pop();
}
function getLength() public view returns (uint) {
return arr.length;
}
function test() public {
arr = [1, 2, 3, 4, 5];
remove(2);
// [1, 2, 4, 5]
assert(arr[0] == 1);
assert(arr[1] == 2);
assert(arr[2] == 4);
assert(arr[3] == 5);
assert(arr.length == 4);
arr = [1, 2, 3, 4, 5];
remove2(2);
// [1, 2, 4, 5]
assert(arr[0] == 1);
assert(arr[1] == 2);
assert(arr[2] == 4);
assert(arr[3] == 5);
assert(arr.length == 4);
arr = [1];
remove3(0);
// []
assert(arr.length == 0);
}
}
Bu sözleşme, array veri yapısından eleman silmek için 3 farklı yöntemi sunmaktadır: remove, remove2 ve remove3 fonksiyonları. remove fonksiyonu ArrayRemoveByShifting sözleşmesinde kullanılan yöntemi kullanır, remove2 fonksiyonu ArrayReplaceFromEnd sözleşmesinde kullanılan yöntemi kullanır ve remove3 fonksiyonu array içinde belirli bir indexteki elemanı sadece silerek, array boyutunu değiştirmeyen yöntemi kullanır. Ayrıca, array’e eleman ekleme, array’in son elemanını silme ve array boyutunu döndürme gibi işlemleri gerçekleştirebileceğimiz fonksiyonlar da mevcut. Test fonksiyonunda ise bu fonksiyonların nasıl kullanılacağı örnek olarak verilmiştir.
Yeni sözleşmeyi işlev, verimlilik, güvenlik açılarından inceleyelim.
- İşlev: Yeni sözleşme array veri yapısını kullanarak farklı işlemler yapabileceğimiz bir örnek sözleşmedir. Array içinden elemana erişme, eleman ekleme, eleman silme (3 farklı yöntemle), array boyutunu döndürme gibi işlemler yapılabilir.
- Verimlilik: Yeni sözleşme içerisinde array boyutunun kontrolü yapılmış ve 3 farklı yöntemle eleman silme işlemi gerçekleştirilebilir. Bu nedenle, eleman silme işlemi için en verimli yöntemi seçebilirsiniz. Örneğin, array’in son elemanını silmek için remove2 fonksiyonu, array’in boyutunu değiştirmek istemiyorsanız remove3 fonksiyonu kullanabilirsiniz.
- Güvenlik: Yeni sözleşme içerisinde indexin array boyutunun dışında olup olmadığı kontrol edilmiştir. Bu nedenle, array içinde güvenli bir şekilde eleman silme işlemi gerçekleştirilir.
Sonuç olarak, yeni sözleşme array veri yapısını kullanarak birçok işlem yapabileceğiniz bir sözleşme olarak tasarlanmış ve eleman silme işlemi için 3 farklı yöntem sunmaktadır. Bu yöntemlerin verimliliği ve güvenliği açısından farklılıklar vardır. Bu nedenle, kullanıcının ihtiyacına göre en uygun yöntemi seçebilirsiniz.
Sonuç Bağlamı
Array, Solidity dilinde kullanılan dinamik boyutlu veri yapılarından biridir. Array’ler, birbirine benzer veri tiplerinden oluşan elemanları saklamak için kullanılır. Bu gün, Array veri yapısının nasıl kullanılacağı, eleman ekleme ve silme işlemleri, array içinde arama yapma, array sıralama işlemleri, array’lerin diğer veri tipleriyle nasıl kullanılacağı, array’lerin sınırları ve performansı, array’lerin fonksiyonlara ve kontratlara nasıl geçirileceği ve array’lerin kullanım örnekleri gibi konuları inceledik. Ayrıca, 3 farklı örnek sözleşme de incelendi ve her birinin işlev, verimlilik ve güvenlik açısından değerlendirildi. Bunun yanı sıra tek bir sözleşme olarak tüm örneklerin düzenlenmesi için öneri sunuldu. Array veri yapısının kullanımı, Solidity programlamada önemli bir rol oynar ve bu nedenle, bu konunun iyi anlaşılması önemlidir.
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!
