Une boucle dans une table de hachage, ou à l'aide d'un tableau en PowerShell

Je suis en utilisant ce simple bout de code 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
}

Il fonctionne très bien, mais maintenant certaines des tables doivent être extraites via des points de vue, et certains ne le font pas. J'ai donc besoin d'une structure de données à quelque chose comme ceci:

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

J'ai été à la recherche à la hache, mais je ne trouve rien sur comment faire une boucle à travers une table de hachage. Quelle serait la bonne chose à faire ici? Peut-être juste utiliser un tableau, mais avec ces deux valeurs, séparées par l'espace?

Ou ai-je raté quelque chose d'évident?

InformationsquelleAutor Sylvia | 2012-01-26
  1. 97

    Christian réponse fonctionne bien et vous montre comment vous pouvez faire une boucle à travers chaque table de hachage élément à l'aide de la GetEnumerator méthode. Vous pouvez également faire une boucle par l'aide de la keys de la propriété. Voici un exemple comment:

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

    De sortie:

    key = c , value = 3
key = a , value = 1
key = b , value = 2
    • Comment puis-je énumérer le hachage dans un autre ordre? E. g. quand je veux imprimer son contenu dans l'ordre croissant (ici a ... b ... c). Est-il même possible?
    • Pourquoi $hash.Item($_) au lieu de $hash[$_]?
    • utiliser le Tri-méthode de l'Objet pour le faire. Cet article fait une très bonne explication de celui-ci: technet.microsoft.com/en-us/library/ee692803.aspx
    • Vous pourriez même utiliser juste $hash.$_.
    • OMI @TNT commentaire est le meilleur pratiquer réponse. Lorsque $_ est pas de type chaîne de caractères, seuls le Point d'Annotation ne va pas augmenter ParserError. Ce doit être modifiée de façon à répondre.
    • Cette approche ne fonctionne pas si la table de hachage contient key = 'Clés'.

    InformationsquelleAutor Andy Arismendi
  2. 180

    Abréviation n'est pas recommandée pour les scripts, c'est moins lisible. L' %{} l'opérateur est considéré comme abréviation. Voici comment il devrait être fait dans un script pour la lisibilité et la réutilisabilité:

    Variable De Configuration

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

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

    Option 1: GetEnumerator()

    Remarque: les préférences personnelles; la syntaxe est plus facile à lire

    La GetEnumerator() la méthode serait fait comme indiqué:

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

    De sortie:

    c: 3
b: 2
a: 1

    Option 2: Touches

    La méthode de Clés serait fait comme indiqué:

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

    De sortie:

    c: 3
b: 2
a: 1

    Des informations supplémentaires

    Être prudent tri de la table de hachage...

    Tri-Objet peut changer en un 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 PowerShell en boucle sont disponibles sur mon blog.

    • comme ce un plus pour la lisibilité, surtout pour ne pas consacrer powershell développeurs comme moi.
    • Je suis d'accord cette méthode est plus facile à lire et donc probablement mieux pour l'écriture de scripts.
    • La lisibilité de côté, il y a une différence entre VertigoRay solution et Andy solution. %{} est un alias pour ForEach-Object, qui est différente de la foreach déclaration ici. ForEach-Object rend l'utilisation de la canalisation, ce qui peut être beaucoup plus rapide si vous travaillez déjà avec un pipeline. Le foreach déclaration n'est pas; c'est une simple boucle.
    • Je ne vois pas ce que prend en charge votre demande du pipeline d'être plus rapide, basée sur mes tests: gist.github.com/VertigoRay/3bb0166d6a877839b420
    • Dans votre test, vous tuyauterie $hash.Touches, ce qui est essentiellement juste un IEnumerable, afin que vos résultats vont être à peu près similaire à la simple énumération de cas. Le pipeline peut être beaucoup plus rapide, mais vous ne verrez que le comportement où le pipeline contient les résultats à partir d'éléments fonctionnant en parallèle (à l'instar de travaux, ou à partir d'autres serveurs via la Commande Invoke-command).
    • Je fais un copier collé de la réponse fournie par @andy-arismendi d'en haut; c'est le populaire pipeline solution pour cette question. Votre déclaration, qui a culminé à mon intérêt, est que ForEach-Object (aka: %{}) est plus rapide que foreach; j'ai montré que ce n'est pas plus rapide. Je voulais démontrer, si votre point de vue est valide ou pas, parce que moi, comme la plupart des gens, comme mon code pour courir aussi vite que possible. Maintenant, votre argument est en train de changer à l'exécution de travaux en parallèle (éventuellement à l'aide de plusieurs ordinateurs/serveurs) ... ce qui bien sûr est plus rapide que l'exécution d'un travail en série à partir d'un seul fil. Cheers!
    • Je pense aussi powershell suit la traditionnelle avantage que les obus de vous donner lorsque vous dirigez le flux de données entre plusieurs processus: vous obtenez naturel parallélisme à partir du simple fait que chaque étape du pipeline est un processus indépendant (bien sûr, un tampon risque de se vider et à la fin tout le pipeline va aussi lent que son plus lent processus). C'est différent d'avoir un pipeline processus qui décide de sa propre à engendrer de multiples threads, qui est entièrement dépendante de la mise en œuvre du processus lui-même.
    • Option 2 ne fonctionne pas si la table de hachage contient key = 'Clés'.

    InformationsquelleAutor VertigoRay
  3. 5

    Ici est une autre façon rapide, juste à l'aide de la clé comme un 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]);
}
    InformationsquelleAutor user1161625
  4. 5

    Sur une boucle dans une table de hachage:

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

$Q.GETENUMERATOR() | % { $_.key }
ONE
THREE
TWO
    InformationsquelleAutor CB.
  5. 4

    Vous pouvez également le faire sans une variable

    @{
  'foo' = 222
  'bar' = 333
  'baz' = 444
  'qux' = 555
} | % getEnumerator | % {
  $_.key
  $_.value
}
    • Cela me fait un "ForEach-Object : Impossible de lier le paramètre de "Processus". Impossible de convertir le "getEnumerator" valeur "type de Système.Chaîne" pour "type de Système.De la gestion.L'automatisation.ScriptBlock"
    InformationsquelleAutor Steven Penny
  6. 3

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

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

    De sortie:

    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és sur la valeur, l'agent recenseur renvoie simplement les objets dans l'ordre inverse.

    Mais puisque c'est un pipeline, j'ai maintenant possible de trier les objets reçus de l'agent recenseur sur la valeur:

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

    De sortie:

    Key = a and Value = 3
Key = b and Value = 2
Key = c and Value = 1
    InformationsquelleAutor Eelco L.
  7. 1

    Si vous êtes à l'aide de PowerShell v3, vous pouvez utiliser JSON au lieu d'une table de hachage, et la convertir en un objet avec Convertir-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
    }
    • n.b. la commande est ConvertFrom-Json (et, à l'inverse, ConvertTo-Json) -- il vous suffit de changer le tableau de bord de placement.
    InformationsquelleAutor Aaron Jensen