about_Split

  • Article

Mis à jour: mai 2014

S'applique à: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0

RUBRIQUE

about_Split

DESCRIPTION COURTE

Explique comment utiliser l’opérateur Split pour fractionner une ou plusieurs chaînes en sous-chaînes.

DESCRIPTION DÉTAILLÉE

L’opérateur Split fractionne une ou plusieurs chaînes en sous-chaînes. Vous pouvez modifier les éléments suivants de l’opération de fractionnement :

  • -- Délimiteur. La valeur par défaut est un espace blanc, mais vous pouvez spécifier des caractères, des chaînes, des modèles ou des blocs de script qui spécifient le délimiteur. L’opérateur Split de Windows PowerShell® utilise une expression régulière dans le délimiteur, au lieu d’un caractère simple.

  • -- Nombre maximal de sous-chaînes. Le comportement par défaut est de retourner toutes les sous-chaînes. Si vous spécifiez un nombre inférieur au nombre de sous-chaînes, les sous-chaînes restantes sont concaténées dans la dernière sous-chaîne.

  • -- Options qui spécifient les conditions dans lesquelles le délimiteur est identifié, comme SimpleMatch et Multiline.

SYNTAXE

Le diagramme suivant montre la syntaxe de l’opérateur -split.

Les noms des paramètres n’apparaissent pas dans la commande. Incluez seulement les valeurs des paramètres. Les valeurs doivent apparaître dans l’ordre spécifié dans le diagramme de la syntaxe.

-Split <String>

<String> -Split <Delimiter>[,<Max-substrings>[,"<Options>"]]

<String> -Split {<ScriptBlock>} [,<Max-substrings>]

Vous pouvez remplacer -split par -iSplit ou par -cSplit dans n’importe quelle instruction Split binaire (une instruction Split qui comprend un délimiteur ou un bloc de script). Les opérateurs -iSplit et -split respectent la casse. L’opérateur -cSplit respecte la casse, ce qui signifie que la casse est prise en compte quand les règles de délimiteur sont appliquées.

PARAMÈTRES

  • <Chaîne>
    Spécifie une ou plusieurs chaînes à fractionner. Si vous soumettez plusieurs chaînes, toutes les chaînes sont fractionnées selon les mêmes règles de délimiteur. Exemple :

              -split "red yellow blue green"
          red
          yellow
          blue
          green

  • <Délimiteur>
    Les caractères qui identifient la fin d’une sous-chaîne. Le délimiteur par défaut est un espace blanc, ce qui comprend les espaces et les caractères non imprimables, comme le saut de ligne (`n) et la tabulation (`t). Quand les chaînes sont fractionnées, le délimiteur est omis dans toutes les sous-chaînes. Exemple :

              "Lastname:FirstName:Address" -split ":"
          Lastname
          FirstName
          Address

    Par défaut, le délimiteur est omis dans les résultats. Pour conserver tout ou partie du délimiteur, placez entre des parenthèses la partie que vous voulez conserver. Si le paramètre <Nombre maximal de sous-chaînes> est ajouté, il est prioritaire quand votre commande fractionne la collection. Si vous choisissez d’inclure un délimiteur dans la sortie, la commande retourne le délimiteur dans la sortie. Cependant, le fait de fractionner la chaîne pour retourner le délimiteur dans la sortie ne compte comme un fractionnement. .Exemples :

              "Lastname:FirstName:Address" -split "(:)"
          Lastname
          :
          FirstName
          :
          Address    


          "Lastname/:/FirstName/:/Address" -split "/(:)/"
          Lastname
          :
          FirstName
          :    
          Address

    Dans l’exemple suivant, <Nombre maximal de sous-chaînes> est défini sur 3. Il en résulte trois fractionnements des valeurs de la chaîne, mais un total de cinq chaînes dans la sortie : le délimiteur est inclus après les fractionnements, jusqu’à ce que le nombre maximal de trois sous-chaînes soit atteint. Les autres délimiteurs de la dernière sous-chaîne font partie intégrante de la sous-chaîne.

             'Chocolate-Vanilla-Strawberry-Blueberry' -split '(-)', 3;

         Chocolate
         -
         Vanilla
         -
         Strawberry-Blueberry

  • <Nombre maximal de sous-chaînes>
    Spécifie le nombre maximal de fractionnements d’une chaîne. La comportement par défaut est que toutes les sous-chaînes sont fractionnées par le délimiteur. S’il existe plusieurs sous-chaînes, elles sont concaténés dans la dernière sous-chaîne. S’il existe moins de sous-chaînes, toutes les sous-chaînes sont retournées. La valeur 0 et les valeurs négatives retournent toutes les sous-chaînes.

    Le paramètre Nombre maximal de sous-chaînes ne spécifie pas le nombre maximal d’objets qui sont retournés ; sa valeur est égale au nombre maximal de fois qu’une chaîne est fractionnée. Si vous soumettez plusieurs chaînes (un tableau de chaînes) à l’opérateur Split, la limite Nombre maximal de sous-chaînes est appliquée séparément à chaque chaîne. Exemple :

              $c = "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune"
          $c -split ",", 5
          Mercury
          Venus
          Earth
          Mars
          Jupiter,Saturn,Uranus,Neptune

  • <Bloc de script>
    Une expression qui spécifie les règles pour l’application du délimiteur. L’expression doit s’évaluer à $true ou à $false. Placez le bloc de script entre des accolades. Exemple :

                $c = "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune"
          $c -split {$_ -eq "e" -or $_ -eq "p"}
          M
          rcury,V
          nus,Earth,Mars,Ju
          it
          r,Saturn,Uranus,N

          tun

  • <Options>
    Placez le nom de l’option entre des guillemets. Les options sont valides seulement quand le paramètre <Nombre maximal de sous-chaînes> est utilisé dans l’instruction.

    La syntaxe pour le paramètre Options est :

        "SimpleMatch [,IgnoreCase]"

            "[RegexMatch] [,IgnoreCase] [,CultureInvariant]
            [,IgnorePatternWhitespace] [,ExplicitCapture] 
            [,Singleline | ,Multiline]"

    Les options SimpleMatch sont :

    • -- SimpleMatch : Utiliser une comparaison de chaînes simple lors de l’évaluation du délimiteur. Ne peut pas être utilisée avec RegexMatch.

    • -- IgnoreCase : Force une correspondance ne respectant pas la casse, même si l’opérateur -cSplit est spécifié.

    Les options RegexMatch sont :

    1. -- RegexMatch : Utiliser une correspondance d’expression régulière pour évaluer le délimiteur. Il s’agit du comportement par défaut. Ne peut pas être utilisée avec SimpleMatch.

    2. -- IgnoreCase : Force une correspondance ne respectant pas la casse, même si l’opérateur -cSplit est spécifié.

    3. -- CultureInvariant : Ignore les différences culturelles dans la langue lors de l’évaluation du délimiteur. Valide seulement avec RegexMatch.

    4. -- IgnorePatternWhitespace : Ignore l’espace blanc sans caractère d’échappement et les commentaires marqués du signe dièse (#). Valide seulement avec RegexMatch.

    5. -- Multiline : Le mode Multiline reconnaît le début et la fin des lignes et des chaînes. Valide seulement avec RegexMatch. Singleline est la valeur par défaut.

    6. -- Singleline : Le mode Singleline reconnaît seulement le début et la fin des chaînes. Valide seulement avec RegexMatch. Singleline est la valeur par défaut.

    7. -- ExplicitCapture : Ignore les groupes de correspondances non nommés, de sorte que seuls les groupes de capture explicites sont retournés dans la liste des résultats. Valide seulement avec RegexMatch.

OPÉRATEURS SPLIT UNAIRES ET BINAIRES

L’opérateur split unaire (-split <chaîne>) a une priorité plus élevée qu’une virgule. Par conséquent, si vous soumettez une liste de chaînes séparées par des virgules à l’opérateur split unaire, seule la première chaîne (avant la première virgule) est fractionnée.

Pour fractionner plusieurs chaînes, utilisez l’opérateur split binaire (<chaîne> -split <délimiteur>). Placez toutes les chaînes entre des parenthèses ou bien stockez les chaînes dans une variable, puis soumettez la variable à l’opérateur split.

Prenons l’exemple suivant :

        -split "1 2", "a b"
        1
        2
        a b


        "1 2", "a b" -split " "
        1
        2
        a
        b


        -split ("1 2", "a b")
        1
        2
        a
        b

        $a = "1 2", "a b"
        -split $a
        1
        2
        a
        b

EXEMPLES

L’instruction suivante fractionne la chaîne au niveau de l’espace blanc.

        C:\PS> -split "Windows PowerShell 2.0`nWindows PowerShell with remoting"

        Windows
        PowerShell
        2.0
        Windows
        PowerShell
        with
        remoting

L’instruction suivante fractionne la chaîne au niveau des virgules.

        C:\PS> "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune" -split ','

        Mercury
        Venus
        Earth 
        Mars
        Jupiter
        Saturn
        Uranus
        Neptune

L’instruction suivante fractionne la chaîne au niveau du modèle « er ».

        C:\PS>"Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune" -split 'er'

        M
        cury,Venus,Earth,Mars,Jupit
        ,Saturn,Uranus,Neptune

L’instruction suivante effectue un fractionnement respectant la casse au niveau de la lettre « N ».

        C:\PS> "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune" -cSplit 'N'

        Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,
        eptune

L’instruction suivante fractionne la chaîne au niveau de « e » et de « t ».

        C:\PS> "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune" -split '[et]'

        M
        rcury,V
        nus,
        ar
        h,Mars,Jupi

        r,Sa
        urn,Uranus,N
        p
        un

L’instruction suivante fractionne la chaîne au niveau de « r » et de « e », mais limite les sous-chaînes résultantes à six.

        C:\PS> "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune" -split '[er]', 6

        M

        cu
        y,V
        nus,
        arth,Mars,Jupiter,Saturn,Uranus,Neptune

L’instruction suivante fractionne une chaîne en trois sous-chaînes.

        C:\PS> "a,b,c,d,e,f,g,h" -split ",", 3

        a
        b
        c,d,e,f,g,h

L’instruction suivante fractionne deux chaînes en trois sous-chaînes. (La limite est appliquée indépendamment à chaque chaîne.)

        C:\PS> "a,b,c,d", "e,f,g,h" -split ",", 3

        a
        b
        c,d
        e
        f
        g,h

L’instruction suivante fractionne chaque ligne de la here-string au niveau du premier chiffre. Elle utilise l’option Multiline pour reconnaître le début de chaque ligne et de la chaîne.

La valeur 0 représente la valeur « retourner tout » du paramètre Nombre maximal de sous-chaînes. Vous pouvez utiliser des options, comme Multiline, seulement quand la valeur de Nombre maximal de sous-chaînes est spécifiée.

        C:\PS> $a = @'
        1The first line.
        2The second line.
        3The third of three lines.
        '@
        
        C:\PS> $a -split "^\d", 0, "multiline"
        
        The first line.


        The second line.


        The third of three lines.

L’instruction suivante utilise l’option SimpleMatch pour indiquer à l’opérateur -split d’interpréter littéralement le délimiteur point (.).

Avec la valeur par défaut, RegexMatch, le point placé entre des guillemets (".") est interprété de façon à correspondre à n’importe quel caractère, sauf un caractère de saut de ligne. Par conséquent, l’instruction Split retourne une ligne vide pour chaque caractère, à l’exception du saut de ligne.

La valeur 0 représente la valeur « retourner tout » du paramètre Nombre maximal de sous-chaînes. Vous pouvez utiliser des options, comme SimpleMatch, seulement quand la valeur de Nombre maximal de sous-chaînes est spécifiée.

        C:\PS> "This.is.a.test" -split ".", 0, "simplematch"

        This
        is
        a 
        test

L’instruction suivante fractionne la chaîne au niveau d’un délimiteur parmi deux, selon la valeur d’une variable.

        C:\PS> $i = 1
        C:\PS> $c = "LastName, FirstName; Address, City, State, Zip"
        C:\PS> $c -split {if ($i -lt 1) {$_ -eq ","} else {$_ -eq ";"}}

        LastName, FirstName
         Address, City, State, Zip

Les instructions split suivantes fractionnent un fichier XML d’abord au crochet angulaire, puis au point-virgule. Le résultat est une version lisible du fichier XML.

        C:\PS> get-process PowerShell | export-clixml ps.xml
        C:\PS> $x = import-clixml ps.xml
        C:\PS> $x = $x -split "<"
        C:\PS> $x = $x -split ";"

Pour afficher le résultat, tapez « $x ».

        C:\PS> $x

        @{__NounName=Process
        Name=PowerShell
        Handles=428
        VM=150081536
        WS=34840576
        PM=36253696
        ...

VOIR AUSSI

Split-Path

about_Operators

about_Comparison_Operators

about_Join