Partager via


about_Split

RUBRIQUE
    about_Split

DESCRIPTION COURTE
    Explique comment utiliser l'opérateur split pour fractionner une 
    ou plusieurs chaînes en sous-chaînes. 

DESCRIPTION LONGUE
    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 split :
    
    -- Délimiteur. La valeur par défaut est un espace blanc, mais vous 
       pouvez spécifier les caractères, les chaînes, les modèles ou 
       blocs de script qui spécifient le délimiteur.
    
    -- Nombre maximal de sous-chaînes. La valeur par défaut est le 
       retour de 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 mis en correspondance, telles que SimpleMatch et 
       Multiline. 


  SYNTAXE

   Le diagramme suivant affiche la syntaxe pour l'opérateur -split.

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

    -Split <String>

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

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

   Dans toute instruction split, vous pouvez remplacer -split par 
   -iSplit ou -cSplit. Les opérateurs -iSplit et -split ne respectent 
   pas la casse. L'opérateur -cSplit respecte la casse, ce qui signifie 
   que la casse est prise en compte lorsque les règles du délimiteur 
   sont appliquées.


  PARAMÈTRES

   <String>
        Spécifie une ou plusieurs chaînes à fractionner. Si vous 
        envoyez plusieurs chaînes, toutes les chaînes sont 
        fractionnées à l'aide des mêmes règles du délimiteur.
        Exemple :

        -split "rouge jaune bleu vert"
        rouge
            jaune
        bleu
        vert

   <Delimiter>
        Caractères qui identifient la fin d'une sous-chaîne. Le 
        délimiteur par défaut est un espace blanc, y compris les 
        espaces et les caractères non imprimables, tels que les 
        caractères nouvelle ligne (`n) et tabulation (`t). Lorsque 
        les chaînes sont fractionnées, le délimiteur est omis de 
        toutes les sous-chaînes. Exemple :

        "Nom:Prénom:Adresse" -split ":"
        Nom
        Prénom
        Adresse
    
    <Max-substrings>
        Spécifie le nombre maximal de sous-chaînes retournées. La 
        valeur par défaut est celle de toutes les sous-chaînes 
        fractionnées par le délimiteur. S'il y a plus de 
        sous-chaînes, elles sont concaténées à la dernière 
        sous-chaîne. S'il y a moins de sous-chaînes, toutes les 
        sous-chaînes sont retournées. Une valeur 0 et des valeurs 
        négatives retournent toutes les sous-chaînes.

        Si vous envoyez plusieurs chaînes (un tableau de chaînes) à 
        l'opérateur split, la limite Max-substrings est appliquée 
        séparément à chaque chaîne. Exemple :

        $c = "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Neptune" 
        $c -split ",", 5
        Mercure
        Vénus
        Terre
        Mars
        Jupiter,Saturne,Uranus,Neptune
    

    <ScriptBlock>
        Expression qui spécifie des règles pour l'application du 
        délimiteur. L'expression doit prendre la valeur $true ou 
        $false. Placez le bloc de script entre accolades. Exemple :
    
            $c = "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Nept une" 
        $c -split {$_ -eq "e" -or $_ -eq "p"}
        M
        rcur,Vénus,Trr,Mars,Ju
        it
        r,Saturn,Uranus,N

        tun

    <Options>
        Placez le nom d'option entre guillemets. Les options sont 
        valides seulement si le paramètre <Max-substrings> est 
        utilisé dans l'instruction.

        La syntaxe du paramètre Options est la suivante :

        "SimpleMatch [,IgnoreCase]"

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

 
        Les options SimpleMatch sont :
            
          -- SimpleMatch : utilise la comparaison de chaînes simple 
             lors de l'évaluation du délimiteur. Ne peut pas être 
             utilisée avec RegexMatch.

          -- IgnoreCase : force la mise en correspondance avec 
             non-respect de la casse, même si l'opérateur -cSplit est 
             spécifié.


        Les options RegexMatch sont :

          -- RegexMatch : utilise la 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.

          -- IgnoreCase : force la mise en correspondance avec 
             non-respect de la casse, même si l'opérateur -cSplit est 
             spécifié.

          -- CultureInvariant : ignore les différences culturelles de 
             langue lorsque le délimiteur est évalué. Valide 
             uniquement avec RegexMatch.

          -- IgnorePatternWhitespace : ignore l'espace blanc sans 
             séquence d'échappement et les commentaires marqués du 
             signe dièse (#). Valide uniquement avec RegexMatch.

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

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

          -- ExplicitCapture : ignore les groupes de correspondance 
             non nommés afin que seuls les groupes de capture 
             explicites soient retournés dans la liste de résultats. 
             Valide uniquement avec RegexMatch.
    

  OPÉRATEURS SPLIT UNAIRE et BINAIRE

    L'opérateur split unaire (-split <string>) a une priorité plus 
    élevée qu'une virgule. Par conséquent, si vous envoyez une liste 
    de chaînes séparée 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 (<string> -split <delimiter>). Placez toutes les chaînes 
    entre parenthèses ou stockez les chaînes dans une variable, 
    puis envoyez la variable à l'opérateur split.

    Considérez 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 à distance"

    Windows
    PowerShell
    2.0
    Windows
    PowerShell
    à
    distance


    L'instruction suivante fractionne la chaîne au niveau de toutes 
    les virgules.

    C:\PS> "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Neptune" -split ','

        Mercure
        Vénus
        Terre 
        Mars
        Jupiter
        Saturne
        Uranus
        Neptune


    L'instruction suivante fractionne la chaîne au niveau du modèle " er ".

    C:\PS> "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Neptune" -split 'er'

    M
    cure,Vénus,Tre,Mars,Jupit
    ,Saturne,Uranus,Neptune



    L'instruction suivante exécute un fractionnement qui respecte la 
    casse au niveau de la lettre " N ".

    C:\PS> "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Neptune" -cSplit 'N'

    Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus, 
    eptune



    L'instruction suivante fractionne la chaîne au niveau de " e " et " t ".

        C:\PS> "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Neptune" -split '[et]'

        M
        rcur,Vénus,
        rr
        ,Mars,Jupi

        r,Sa
        urn,Uranus,N
        p
        un

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

        C:\PS> "Mercure,Vénus,Terre,Mars,Jupiter,Saturne,Uranus,Neptune" -split '[er]', 6

    M

    cu
    ,Vénus
    ,T
    ,Mars,Jupiter,Saturne,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 dans la chaîne 
    here au niveau du premier chiffre. Elle utilise l'option Multiline 
    pour reconnaître le début de chaque ligne et de chaque chaîne.

    Le 0 représente la valeur " retourner tout " du paramètre 
    Max-substrings. Vous pouvez utiliser des options, telles que 
    Multiline, uniquement lorsque la valeur Max-substrings est spécifiée.
    
        C:\PS> $a = @'
    1La première ligne.
    2La deuxième ligne.
    3La troisième des trois lignes.
    '@
        
        C:\PS> $a -split "^\d", 0, "multiline"
    
    La première ligne.


    La deuxième ligne.


    La troisième des trois lignes.



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

    Avec la valeur par défaut, RegexMatch, le point entre guillemets 
    (".") est interprété comme pouvant correspondre à tout caractère 
    à l'exception d'un caractère de nouvelle ligne. Par conséquent, 
    l'instruction split retourne une ligne vierge pour chaque 
    caractère sauf celui de nouvelle ligne.

    Le 0 représente la valeur " retourner tout " du paramètre 
    Max-substrings. Vous pouvez utiliser des options, telles que 
    SimpleMatch, uniquement lorsque la valeur Max-substrings est 
    spécifiée.

        C:\PS> "Cela.est.un.test" -split ".", 0, "simplematch"

    Cela
        est
        un 
    test    



    L'instruction suivante fractionne la chaîne au niveau de l'un des 
    deux délimiteurs, selon la valeur d'une variable.

        C:\PS>   $i = 1
        C:\PS>   $c = "Nom, Prénom; Adresse, Ville, État, Code postal"
        C:\PS>   $c -split {if ($i -lt 1) {$_ -eq ","} else {$_ -eq ";"}}

    Nom, Prénom
     Adresse, Ville, État, Code postal
        
    

    Les instructions split suivantes fractionnent un fichier XML 
    d'abord au niveau du crochet pointu, puis au niveau du 
    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