info@teknoedu.com
PowerShell

PowerShell’de Diziler, ArrayList ve List[T]: Doğru Koleksiyonu Seçmek ve Performans

Döngü içinde += ile dizi büyütmek neden binlerce kayıtta betiğinizi yavaşlatır? PowerShell dizilerini, ArrayList ve List[T] koleksiyonlarını, aralarındaki farkları ve doğru kullanım kalıplarını öğrenin.

PowerShell'de Diziler, ArrayList ve List[T]: Doğru Koleksiyonu Seçmek ve Performans

Hemen her PowerShell betiği bir şeylerin listesiyle çalışır: kullanıcılar, dosyalar, sunucular, satırlar. Bu listeleri tutmak için PowerShell’in varsayılan dizisi çoğu zaman yeterlidir; ancak kayıt sayısı büyüdüğünde yanlış kalıp betiğin dakikalarca sürmesine neden olabilir. Bu yazıda dizilerin nasıl çalıştığını, ArrayList ve List[T] ile farklarını ve hangi durumda hangisini seçmeniz gerektiğini anlatıyoruz.

Dizi oluşturmanın yolları

$sehirler = "Ankara", "İzmir", "Bursa"     # virgülle
$bos      = @()                             # boş dizi
$sayilar  = 1..10                           # aralık operatörü
$dosyalar = @(Get-ChildItem C:\Temp -File)  # sonucu her zaman dizi yap
[int[]]$notlar = 85, 92, 70                 # türü sabit dizi

@() dizi alt ifadesi özellikle önemlidir. Bir komut tek sonuç döndürdüğünde PowerShell onu dizi değil, tek nesne olarak verir. @() ile sararsanız sonuç her zaman bir dizi olur ve .Count güvenle kullanılabilir.

Elemanlara erişim ve dilimleme

Diziler sıfırdan başlar. Negatif indeks sondan saymayı sağlar:

$sehirler[0]       # Ankara
$sehirler[-1]      # Bursa (son eleman)
$sehirler[0..1]    # Ankara, İzmir
$sehirler[0,2]     # Ankara, Bursa
$sehirler.Count    # 3

Bir değerin dizide olup olmadığını sormak için iki okunaklı operatör vardır:

$sehirler -contains "İzmir"    # True
"Bursa" -in $sehirler          # True

PowerShell 4 ve sonrasında gelen .Where() ve .ForEach() metodları, pipeline’a göre daha hızlı filtreleme sunar:

$notlar.Where({ $_ -ge 80 })          # 85, 92
$notlar.ForEach({ $_ + 5 })           # 90, 97, 75
$notlar.Where({ $_ -ge 80 }, 'First') # yalnızca ilk eşleşen

+= neden yavaş?

PowerShell dizileri sabit boyutludur. $dizi += $yeniEleman yazdığınızda PowerShell mevcut diziye eleman eklemez; bir eleman büyük yeni bir dizi oluşturur, eski elemanların hepsini kopyalar ve yenisini ekler. On elemanda fark edilmez, ancak on binlerce elemanda her eklemede tüm dizinin kopyalanması ciddi yavaşlamaya yol açar.

# Kaçınılması gereken kalıp
$sonuc = @()
foreach ($i in 1..20000) {
    $sonuc += "Kayıt $i"
}

Kendi bilgisayarınızda Measure-Command ile bu döngüyü aşağıdaki alternatiflerle karşılaştırırsanız farkı net biçimde görürsünüz. Kesin süreler donanıma ve sürüme göre değişir; PowerShell 7.5 ile += işlemi iyileştirilmiş olsa da büyük koleksiyonlarda hâlâ önerilen yöntem değildir.

Daha iyi yol 1: Döngü çıktısını doğrudan toplamak

Çoğu zaman ayrı bir koleksiyona hiç ihtiyacınız yoktur. Döngünün çıktısını doğrudan değişkene atayabilirsiniz:

$sonuc = foreach ($i in 1..20000) {
    "Kayıt $i"
}

PowerShell döngünün ürettiği her değeri toplar ve en sonda tek seferde dizi oluşturur. Hem hızlı hem de okunaklı olduğu için ilk tercihiniz bu olmalı.

Daha iyi yol 2: List[T]

Elemanları koşullu ekleyip çıkarmanız, ortada bir yerde araya eleman koymanız gerekiyorsa genel (generic) liste kullanın:

$liste = [System.Collections.Generic.List[string]]::new()
$liste.Add("Ankara")
$liste.Add("İzmir")
$liste.Insert(0, "İstanbul")    # başa ekle
$liste.Remove("İzmir")          # değere göre sil, True/False döner
$liste.RemoveAt(0)              # indekse göre sil
$liste.Contains("Ankara")       # True
$liste.Count

Herhangi bir türde nesne tutmak istiyorsanız [System.Collections.Generic.List[object]] ya da özel nesneler için [System.Collections.Generic.List[pscustomobject]] kullanabilirsiniz. Türü belirtmek, yanlış türde eleman eklenmesini de engeller.

Birden fazla elemanı tek seferde eklemek için AddRange() metodu vardır:

$liste.AddRange([string[]]@("Bursa", "Konya"))

ArrayList: Eski ama hâlâ karşınıza çıkacak

Eski betiklerde sıkça System.Collections.ArrayList görürsünüz:

$al = [System.Collections.ArrayList]::new()
$al.Add("ilk")       # ekrana 0 yazar!
[void]$al.Add("ikinci")
$null = $al.Add("üçüncü")

ArrayList.Add() eklenen elemanın indeksini döndürür. Bunu bastırmazsanız fonksiyonlarınızın çıktısına istenmeyen sayılar karışır. Bu yüzden [void] veya $null = kullanmak gerekir. Microsoft’un .NET belgeleri yeni geliştirmelerde ArrayList yerine genel List<T> kullanılmasını önerir; yeni betiklerde List[T] tercih etmeniz için bu da iyi bir neden.

Hangisini ne zaman seçmeli?

Senaryo Önerilen yapı
Sabit, küçük liste (sunucu adları, ayarlar) Normal dizi @()
Döngüde üretilen sonuçları toplamak $sonuc = foreach (...) { }
Koşullu ekleme/silme, araya ekleme List[T]
Eski betiği bakımla güncellemek ArrayList yerine List[T]‘ye geçiş
Tek eleman da gelse dizi garantisi @(...) ile sarmak

Dizilerle ilgili pratik kalıplar

Tekrarsız liste

$departmanlar = $kullanicilar.Departman | Sort-Object -Unique

Dizi birleştirme ve metne çevirme

$hepsi = $liste1 + $liste2
$metin = $sehirler -join ", "         # "Ankara, İzmir, Bursa"
$parca = "a;b;c" -split ";"           # a, b, c

Tek elemanlı dizi döndürme

Bir fonksiyonun tek elemanlı diziyi “açılmadan” döndürmesini istiyorsanız virgül operatörünü kullanın:

function Get-Liste { , @("tek") }
(Get-Liste).GetType().Name   # Object[]

Diziyi gruplara bölmek

Toplu API çağrılarında listeyi 100’lük parçalara ayırmak sık ihtiyaçtır:

$boyut = 100
for ($i = 0; $i -lt $liste.Count; $i += $boyut) {
    $grup = $liste[$i..([math]::Min($i + $boyut, $liste.Count) - 1)]
    # $grup ile işlem yap
}

Sıralama, karşılaştırma ve ölçüm

Diziler çoğu zaman pipeline komutlarıyla birlikte kullanılır. Birkaç temel kalıbı bilmek, ek kod yazma ihtiyacını azaltır:

$notlar | Sort-Object                      # küçükten büyüğe
$notlar | Sort-Object -Descending          # büyükten küçüğe
$notlar | Measure-Object -Average -Maximum -Minimum

İki listeyi karşılaştırıp farkları bulmak için Compare-Object kullanılır. Örneğin dün ve bugün alınan sunucu listeleri arasındaki farkı görmek isteyelim:

$dun   = "srv01", "srv02", "srv03"
$bugun = "srv01", "srv03", "srv04"
Compare-Object -ReferenceObject $dun -DifferenceObject $bugun

Çıktıdaki SideIndicator sütununda <= yalnızca referans listede (dün), => yalnızca fark listesinde (bugün) bulunan öğeyi gösterir. Ortak öğeleri de görmek isterseniz -IncludeEqual ekleyebilirsiniz.

Nesne dizileriyle çalışmak

Gerçek betiklerde diziler genellikle metin değil, nesne tutar. Nesne dizisinde bir özelliğin tüm değerlerini almak için “üye numaralandırma” (member enumeration) özelliğinden yararlanabilirsiniz:

$surecler = Get-Process
$surecler.Name             # tüm süreç adları
$surecler.Count
($surecler | Where-Object CPU -gt 100).Name

$surecler.Name yazdığınızda PowerShell dizideki her nesnenin Name özelliğini toplayıp yeni bir dizi olarak döndürür. Bu, ForEach-Object { $_.Name } yazmaktan hem kısa hem de hızlıdır.

İç içe diziler (dizi içinde dizi) de oluşturabilirsiniz; ancak okunabilirlik açısından çoğu durumda PSCustomObject dizisi daha anlaşılırdır:

$tablo = @(
    @("Ali", 85),
    @("Ayşe", 92)
)
$tablo[1][0]    # Ayşe

Sık yapılan hatalar

  • Döngüde += ile binlerce eleman eklemek.
  • ArrayList.Add() çıktısını bastırmayı unutmak.
  • Tek sonuç dönebilecek komutların çıktısını @() ile sarmamak ve .Count değerinin beklenmedik çıkması.
  • -contains ile -like/-match operatörlerini karıştırmak: -contains tam eleman eşleşmesi arar, metin içinde arama yapmaz.

İpucu: Performanstan emin olmadığınızda tahmin etmeyin, ölçün: Measure-Command { ...kod... } | Select-Object TotalMilliseconds.

Sonuç

Küçük listelerde hangi yapıyı kullandığınız fark etmez; ama yönetici betikleri genellikle büyür. Sonuçları döngü çıktısından toplamak, gerektiğinde List[T] kullanmak ve += alışkanlığını büyük koleksiyonlarda bırakmak, betiklerinizi hem hızlı hem de öngörülebilir kılar. Bir sonraki adım, anahtar-değer çiftleriyle çalışan karma tablolardır.