Faire une boucle via un hachage ou utiliser un tableau dans PowerShell

J'utilise ce morceau de code (simplifié) pour extraire un ensemble de tables de SQL Server avec 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
}

Cela fonctionne très bien, mais maintenant certaines tables doivent être extraites via des vues, et d'autres non. J'ai donc besoin d'une structure de données comme celle-ci:

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

Je regardais les hachages, mais je ne trouve rien sur la façon de parcourir un hachage. Quelle serait la bonne chose à faire ici? Peut-être simplement utiliser un tableau, mais avec les deux valeurs, séparées par un espace?

Ou est-ce que je rate quelque chose d'évident?

La réponse de Christian fonctionne bien et montre comment vous pouvez parcourir chaque élément de table de hachage en utilisant la GetEnumeratorméthode. Vous pouvez également parcourir en boucle en utilisant la keyspropriété. Voici un exemple comment:

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

Production:

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

La sténographie n'est pas préférée pour les scripts; il est moins lisible. L'opérateur% {} est considéré comme un raccourci. Voici comment procéder dans un script pour plus de lisibilité et de réutilisation:

Configuration variable

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

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

Option 1: GetEnumerator ()

Remarque: préférence personnelle; la syntaxe est plus facile à lire

La méthode GetEnumerator () serait effectuée comme indiqué:

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

Production:

c: 3
b: 2
a: 1

Option 2: Clés

La méthode Keys serait effectuée comme indiqué:

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

Production:

c: 3
b: 2
a: 1

Information additionnelle

Soyez prudent en triant votre hashtable ...

Sort-Object peut le changer en tableau:

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

Ceci et d'autres boucles PowerShell sont disponibles sur mon blog.

Vous pouvez également le faire sans variable

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

À propos de la boucle sur un hachage:

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

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

Voici un autre moyen rapide, en utilisant simplement la clé comme index dans la table de hachage pour obtenir la valeur:

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

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

Je préfère cette variante à la méthode de l'énumérateur avec un pipeline, car vous n'avez pas à vous référer à la table de hachage dans le foreach (testé dans PowerShell 5):

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

Production:

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

Maintenant, cela n'a pas été délibérément trié sur la valeur, l'énumérateur renvoie simplement les objets dans l'ordre inverse.

Mais comme il s'agit d'un pipeline, je peux maintenant trier les objets reçus de l'énumérateur sur la valeur:

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

Production:

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

Si vous utilisez PowerShell v3, vous pouvez utiliser JSON au lieu d'une table de hachage et le convertir en objet avec 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
    }