Comment diviser une chaîne contenant des retours à la ligne

Pour traiter une séquence CRLF dans son ensemble comme séparateur, il est plus simple d'utiliser le -split opérateur , qui est regex - basé:

PS> "This is `r`n`r`n a string." -split '\r?\n'
This is 
 a string.

Remarque:

• \ r? \ n correspond à la fois aux retours à la ligne CRLF (style Windows) et LF uniquement (style Unix); utilisez \ r \ n si vous ne voulez vraiment faire correspondre que les séquences CRLF.

  • Notez l'utilisation d'une chaîne entre guillemets simples ( '...' ), de manière à transmettre la chaîne contenant l'expression rationnelle telle quelle au. Moteur NET regex; le moteur regex utilise \ comme caractère d'échappement; d'où l'utilisation de \ r et \ n .

• L'opérateur -split de PowerShell est une alternative généralement supérieure au [string] .NET de type .Split ( ) méthode - voir cette réponse .

Quant à ce que vous avez essayé :

L'argument de séparation, [Environment] :: NewLine , sous Windows est la chaîne "` r`n ", c'est-à-dire une séquence CRLF.

• Dans PowerShell [Core] v6 + , votre commande fonctionne , car cette chaîne dans son ensemble est considérée comme le séparateur.

• Dans Windows PowerShell , comme Steven le souligne dans sa réponse utile , les caractères individuels - CR et LF séparément sont considérés comme des séparateurs, ce qui entraîne un élément vide supplémentaire - la chaîne vide entre le CR et le LF - dans le tableau de résultats.

Ce changement de comportement s'est produit en dehors du contrôle de PowerShell: .NET Core a introduit une nouvelle surcharge de méthode .Split () avec un type de [string] séparateur, que l'algorithme de résolution de surcharge de PowerShell sélectionne désormais par rapport à l'ancienne surcharge avec le paramètre de type [char []] .
Éviter ces changements de comportement inévitables (bien que rares) par inadvertance est une autre bonne raison de préférer l'opérateur -split natif de PowerShell au code .NET [string] > type .Split () method.

En effet, la méthode .Split () se divisera sur l'un des caractères qu'elle trouve, par exemple:

"This is`r`na string." -split "`r`n"

Sortie:

.Split([Environment]::NewLine), [Stringsplitoptions]::RemoveEmptyEntries)

L'élément supplémentaire est une chaîne vide insérée entre les 2 caractères séparés.

(merci à @ mklement0, pour avoir corrigé cela)

Donc je ne peux que supposons que cela résulte de plusieurs facteurs. Le premier [Environment] :: NewLine est à la fois les caractères CarrigeReturn & LineFeed et la ligne provenant d'Outlook utilise effectivement cette séquence de fin de ligne. Tout est normal dans Windows.

Il y a 2 solutions auxquelles je peux penser:

Option 1:

first part of a string

second part of a string

Bonjour,

Je suis un grand NooB dans PowerShell, mais ...
J'ai écrit ceci

$Result_1.Split("|")
## OUTPUT ##
This is
 a string.

 $Result_2.Split("|")
 ## OUTPUT ##
 This is
 ....a st
 ring...

J'espère que c'est de l'aide ...

PS:

Je viens de réaliser que j'ai oublié le résultat ... ..

$str_1 ="This is

a string."
$splt_1=$str_1.Split()
$cnt_1=1
foreach ($item in $splt_1) {
     $regEx="[a-zA-Z]"
     if ($item -cmatch $regEx){
          $Result_1=$Result_1+"$item "
     } elseif ($cnt_1 -eq 1) {
          $Result_1=$Result_1+"| "
          $cnt_1=$cnt_1+1
     }
}
Write-Host $Result_1
## OUTPUT ##
# This is | a string.

$str_2="
This is

....a st

ring...
"
$splt_2=$str_2.Split()
$cnt_2=1
foreach ($item in $splt_2) {
     $regEx="[a-zA-Z]"
     if ($item -cmatch $regEx){
          $cnt_2=1
          $Result_2=$Result_2+"$item "
     } elseif ($cnt_2 -eq 1) {
          $Result_2=$Result_2+"| "
          $cnt_2=$cnt_2+1
     }
}
Write-Host $Result_2
## OUTPUT ##
# | This is | ....a st | ring... |

EOF

AxelEric.