PowerShell'de İşlevler Arasında Değişkenler Nasıl Paylaşılır?

Bir PowerShell yöneticisi bana PowerShell'deki işlevler arasında değişkenlerin paylaşılması hakkında soru sordu. Bunu yapmanın farklı yöntemleri vardır. Bu eğitimde sizlere PowerShell'de fonksiyonlar arasında değişkenlerin nasıl paylaşılacağını örneklerle göstereceğim.

Global değişken yöntemini kullanarak PowerShell'deki işlevler arasında değişkenleri paylaşmak için, $global: önekiyle bir değişken bildirebilir ve bu değişkene, iç işlevler de dahil olmak üzere betiğinizin herhangi bir yerinden erişilebilir hale getirebilirsiniz. Örneğin, $global:userCount=0, AddUser ve RemoveUser gibi herhangi bir işlev tarafından değiştirilebilen genel bir değişkeni başlatır ve değişkenin değeri sürekli olarak güncellenir ve farklı işlevlerde erişilebilir.

PowerShell'de İşlevler Arasındaki Değişkenleri Paylaşın

Şimdi size PowerShell'de işlevler arasında değişkenleri paylaşmanın farklı yöntemlerini göstereyim.

1. Global Değişkenleri Kullanmak

PowerShell'deki işlevler arasında değişkenleri paylaşmanın bir yolu genel değişkenleri kullanmaktır. Global bir değişken bildirmek için $global: önekini ve ardından değişken adını kullanabilirsiniz. Genel değişkenlere, iç işlevler de dahil olmak üzere PowerShell betiğinizin herhangi bir yerinden erişilebilir.

İşte global değişkenlerin kullanımını gösteren bir örnek:

$global:userCount = 0

function AddUser {
    $global:userCount++
    Write-Host "User added. Total users: $global:userCount"
}

function RemoveUser {
    $global:userCount--
    Write-Host "User removed. Total users: $global:userCount"
}

AddUser
AddUser
RemoveUser

Bu örnekte, kullanıcı sayısını takip etmek için $global:userCount global değişkenini tanımladık. AddUser ve RemoveUser işlevleri genel değişkeni değiştirir ve değişiklikler komut dosyası boyunca yansıtılır.

Yukarıdaki PowerShell betiğini çalıştırdım ve çıktıyı aşağıdaki ekran görüntüsünde görebilirsiniz:

2. Değişkenleri Parametre Olarak Aktarmak

Şimdi size işlevler arasında değişkenleri paylaşmak için başka bir yöntem göstereyim.

Değişkenleri işlevler arasında paylaşmaya yönelik başka bir yaklaşım da onları parametre olarak iletmektir. Bu, hangi değişkenlerin açıkça paylaşıldığını belirtmenize olanak tanır ve değişkenlerin kapsamı üzerinde daha iyi kontrol sağlar.

Size basit bir örnek göstereyim.

function Get-UserName {
    param (
        [string]$userName
    )
    Write-Output "User Name: $userName"
}

function Set-UserName {
    param (
        [string]$newName
    )
    return $newName
}

# Call functions
$userName = "User01"
Get-UserName -userName $userName
$userName = Set-UserName -newName "User02"
Get-UserName -userName $userName

Bu örnekte, Set-UserName işlevi yeni bir değer döndürür ve bu değer daha sonra Get-UserName işlevine aktarılır.

Yukarıdaki PowerShell betiğini yürüttükten sonra aşağıdaki ekran görüntüsündeki çıktı.

Size başka bir örnek göstereyim.

function CalculateTax($amount, $taxRate) {
    $tax = $amount * $taxRate
    return $tax
}

function ProcessInvoice($invoiceAmount) {
    $salesTaxRate = 0.08
    $stateTaxRate = 0.05

    $salesTax = CalculateTax -amount $invoiceAmount -taxRate $salesTaxRate
    $stateTax = CalculateTax -amount $invoiceAmount -taxRate $stateTaxRate

    $totalTax = $salesTax + $stateTax
    $totalAmount = $invoiceAmount + $totalTax

    Write-Host "Invoice Amount: $invoiceAmount"
    Write-Host "Sales Tax: $salesTax"
    Write-Host "State Tax: $stateTax"
    Write-Host "Total Amount: $totalAmount"
}

ProcessInvoice -invoiceAmount 1000

Bu örnekte, CalculateTax işlevi $amount ve $taxRate parametrelerini kabul eder ve hesaplanan vergiyi döndürür. ProcessInvoice işlevi CalculateTax'ı iki kez çağırarak fatura tutarını ve ilgili vergi oranlarını bağımsız değişken olarak iletir. Döndürülen değerler daha sonra toplam vergiyi ve toplam tutarı hesaplamak için kullanılır.

Çıktıyı aşağıdaki ekran görüntüsünde görebilirsiniz:

PowerShell'de Bir Değişkenin Boş Olup Olmadığı Nasıl Kontrol Edilir? konusuna göz atın.

3. Komut Dosyası Kapsamını Kullanma

PowerShell, aynı komut dosyasındaki işlevler arasında değişkenleri paylaşmanıza olanak tanıyan bir komut dosyası kapsamı sağlar. Bir modüldeki komut dosyası kapsamını kullanarak değişkenleri ayarladığınızda, değişkenler modülün işlevleri arasında paylaşılabilir hale gelir.

Betik kapsamındaki değişkenler, betik içindeki tüm işlevler için kullanılabilir. Bu yöntem, değişkenleri küresel olarak erişilebilir hale getirmeden paylaşmak için kullanışlıdır.

Size bir örnek göstereyim.

# Declare a script scope variable
$script:databaseName = "Database01"

function Get-DatabaseName {
    Write-Output "Database Name: $script:databaseName"
}

function Set-DatabaseName {
    param (
        [string]$newName
    )
    $script:databaseName = $newName
}

# Call functions
Get-DatabaseName
Set-DatabaseName -newName "Database02"
Get-DatabaseName

Burada, $script:databaseName, Get-DatabaseName ve Set-DatabaseName işlevleri arasında paylaşılır ve yalnızca komut dosyasından erişilebilir.

Betik kapsamının kullanımını açıklayan başka bir örnek:

$script:dbConnection = $null

function ConnectToDatabase {
    $script:dbConnection = New-Object System.Data.SqlClient.SqlConnection("ConnectionString")
    $script:dbConnection.Open()
    Write-Host "Connected to the database"
}

function ExecuteQuery($query) {
    $command = $script:dbConnection.CreateCommand()
    $command.CommandText = $query
    $result = $command.ExecuteReader()
    return $result
}

function DisconnectFromDatabase {
    $script:dbConnection.Close()
    Write-Host "Disconnected from the database"
}

ConnectToDatabase
$data = ExecuteQuery -query "SELECT * FROM Users"
# Process the data...
DisconnectFromDatabase

Bu örnekte, veritabanı bağlantısını depolamak için komut dosyası kapsamlı bir $script:dbConnection değişkeni bildiriyoruz. ConnectToDatabase işlevi bağlantıyı başlatır ve ExecuteQuery işlevi bir sorguyu yürütmek için paylaşılan bağlantıyı kullanır. Son olarak DisconnectFromDatabase işlevi bağlantıyı kapatır.

PowerShell Yazdırma Değişkenini Oku

4. Referans Türü Değişkenlerini Kullanma

PowerShell'de referans türü değişkenleri, bir işlevin kapsamı dışındaki bir değişkenin değerini değiştirmesine olanak tanır. Bu yöntem, bir değişkeni doğrudan değiştirmek için bir işleve ihtiyacınız olduğunda kullanışlıdır.

İşte bir örnek.

function Increment-Count {
    param (
        [ref]$count
    )
    $count.Value++
}

# Declare a variable
$count = 0

# Call function
Increment-Count -count ([ref]$count)
Write-Output "Count: $count"
Increment-Count -count ([ref]$count)
Write-Output "Count: $count"

Bu örnekte, Artış-Sayı işlevi, $count değişkenini doğrudan değiştirmek için bir referans değişkeni kullanır.

Çözüm

Bu eğitimde, global değişkenler, değişkenleri parametre olarak iletmek, komut dosyası kapsamından yararlanmak vb. gibi farklı yöntemler kullanarak PowerShell'deki işlevler arasında değişkenleri nasıl paylaşacağımı açıkladım.

İlgili makaleler