Ciclando attraverso un hash o usando un array in PowerShell

Sto usando questo pezzo di codice (semplificato) per estrarre un set di tabelle da SQL Server con BCP .

$OutputDirectory = "c:\junk\"
$ServerOption =   "-SServerName"
$TargetDatabase = "Content.dbo."

$ExtractTables = @(
    "Page"
    , "ChecklistItemCategory"
    , "ChecklistItem"
)

for ($i=0; $i -le $ExtractTables.Length – 1; $i++)  {
    $InputFullTableName = "$TargetDatabase$($ExtractTables[$i])"
    $OutputFullFileName = "$OutputDirectory$($ExtractTables[$i])"
    bcp $InputFullTableName out $OutputFullFileName -T -c $ServerOption
}

Funziona benissimo, ma ora alcune tabelle devono essere estratte tramite le visualizzazioni e altre no. Quindi ho bisogno di una struttura dati simile a questa:

"Page"                      "vExtractPage"
, "ChecklistItemCategory"   "ChecklistItemCategory"
, "ChecklistItem"           "vExtractChecklistItem"

Stavo guardando gli hash, ma non ho trovato nulla su come eseguire il loop attraverso un hash. Quale sarebbe la cosa giusta da fare qui? Forse usi solo un array, ma con entrambi i valori, separati da uno spazio?

O mi sto perdendo qualcosa di ovvio?

La risposta di Christian funziona bene e mostra come puoi scorrere ogni elemento della tabella hash usando il GetEnumeratormetodo. È inoltre possibile eseguire il ciclo utilizzando la keysproprietà. Ecco un esempio di come:

$hash = @{
    a = 1
    b = 2
    c = 3
}
$hash.Keys | % { "key = $_ , value = " + $hash.Item($_) }

Produzione:

key = c , value = 3
key = a , value = 1
key = b , value = 2

La stenografia non è preferita per gli script; è meno leggibile. L'operatore% {} è considerato abbreviazione. Ecco come dovrebbe essere fatto in uno script per leggibilità e riusabilità:

Configurazione variabile

PS> $hash = @{
    a = 1
    b = 2
    c = 3
}
PS> $hash

Name                           Value
----                           -----
c                              3
b                              2
a                              1

Opzione 1: GetEnumerator ()

Nota: preferenza personale; la sintassi è più facile da leggere

Il metodo GetEnumerator () verrebbe eseguito come mostrato:

foreach ($h in $hash.GetEnumerator()) {
    Write-Host "$($h.Name): $($h.Value)"
}

Produzione:

c: 3
b: 2
a: 1

Opzione 2: chiavi

Il metodo Keys verrebbe eseguito come mostrato:

foreach ($h in $hash.Keys) {
    Write-Host "${h}: $($hash.Item($h))"
}

Produzione:

c: 3
b: 2
a: 1

Informazioni aggiuntive

Fai attenzione a ordinare la tua tabella hash ...

Sort-Object può cambiarlo in un array:

PS> $hash.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Hashtable                                System.Object


PS> $hash = $hash.GetEnumerator() | Sort-Object Name
PS> $hash.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

Questo e altri loop di PowerShell sono disponibili sul mio blog.

Puoi anche farlo senza una variabile

@{
  'foo' = 222
  'bar' = 333
  'baz' = 444
  'qux' = 555
} | % getEnumerator | % {
  $_.key
  $_.value
}

Informazioni sul ciclo attraverso un hash:

$Q = @{"ONE"="1";"TWO"="2";"THREE"="3"}
$Q.GETENUMERATOR() | % { $_.VALUE }
1
3
2

$Q.GETENUMERATOR() | % { $_.key }
ONE
THREE
TWO

Ecco un altro modo rapido, utilizzando semplicemente la chiave come indice nella tabella hash per ottenere il valore:

$hash = @{
    'a' = 1;
    'b' = 2;
    'c' = 3
};

foreach($key in $hash.keys) {
    Write-Host ("Key = " + $key + " and Value = " + $hash[$key]);
}

Preferisco questa variante sul metodo enumeratore con una pipeline, perché non devi fare riferimento alla tabella hash in foreach (testata in PowerShell 5):

$hash = @{
    'a' = 3
    'b' = 2
    'c' = 1
}
$hash.getEnumerator() | foreach {
    Write-Host ("Key = " + $_.key + " and Value = " + $_.value);
}

Produzione:

Key = c and Value = 1
Key = b and Value = 2
Key = a and Value = 3

Ora, questo non è stato deliberatamente ordinato in base al valore, l'enumeratore restituisce semplicemente gli oggetti in ordine inverso.

Ma poiché questa è una pipeline, ora posso ordinare gli oggetti ricevuti dall'enumeratore in base al valore:

$hash.getEnumerator() | sort-object -Property value -Desc | foreach {
  Write-Host ("Key = " + $_.key + " and Value = " + $_.value);
}

Produzione:

Key = a and Value = 3
Key = b and Value = 2
Key = c and Value = 1

Se stai usando PowerShell v3, puoi usare JSON invece di una tabella hash e convertirlo in un oggetto con Convert-FromJson :

@'
[
    {
        FileName = "Page";
        ObjectName = "vExtractPage";
    },
    {
        ObjectName = "ChecklistItemCategory";
    },
    {
        ObjectName = "ChecklistItem";
    },
]
'@ | 
    Convert-FromJson |
    ForEach-Object {
        $InputFullTableName = '{0}{1}' -f $TargetDatabase,$_.ObjectName

        # In strict mode, you can't reference a property that doesn't exist, 
        #so check if it has an explicit filename firest.
        $outputFileName = $_.ObjectName
        if( $_ | Get-Member FileName )
        {
            $outputFileName = $_.FileName
        }
        $OutputFullFileName = Join-Path $OutputDirectory $outputFileName

        bcp $InputFullTableName out $OutputFullFileName -T -c $ServerOption
    }