Comment concaténer des chaînes et des variables dans PowerShell?

Supposons que j'ai l'extrait de code suivant:

$assoc = New-Object psobject -Property @{
    Id = 42
    Name = "Slim Shady"
    Owner = "Eminem"
}

Write-host $assoc.Id + "  -  "  + $assoc.Name + "  -  " + $assoc.Owner

Je m'attends à ce que cet extrait montre:

42 - Slim Shady - Eminem

Mais à la place, cela montre:

42 + - + Slim Shady + - + Eminem

Ce qui me fait penser que l' +opérateur n'est pas approprié pour concaténer des chaînes et des variables.

Comment devez-vous aborder cela avec PowerShell?

Write-Host "$($assoc.Id) - $($assoc.Name) - $($assoc.Owner)"

Voir l' extension de sous-expressions Windows PowerShell Language Specification version 3.0 , p34.

Personne ne semble avoir mentionné la différence entre les guillemets simples et doubles. (J'utilise PowerShell 4).

Vous pouvez le faire (comme l'a dit @Ben):

$name = 'Slim Shady'
Write-Host 'My name is'$name
-> My name is Slim Shady

Ou vous pouvez le faire:

$name = 'Slim Shady'
Write-Host "My name is $name"
-> My name is Slim Shady

Les guillemets simples sont pour littéral, affichez la chaîne exactement comme ceci, s'il vous plaît. Les guillemets doubles sont pour quand vous voulez faire un prétraitement (comme les variables, les caractères spéciaux, etc.)

Donc:

$name = "Marshall Bruce Mathers III"
Write-Host "$name"
-> Marshall Bruce Mathers III

Tandis que:

$name = "Marshall Bruce Mathers III"
Write-Host '$name'
-> $name

( http://ss64.com/ps/syntax-esc.html je trouve bon pour référence).

Une façon est:

Write-host "$($assoc.Id)  -  $($assoc.Name)  -  $($assoc.Owner)"

Un autre est:

Write-host  ("{0}  -  {1}  -  {2}" -f $assoc.Id,$assoc.Name,$assoc.Owner )

Ou juste (mais je n'aime pas ça;)):

Write-host $assoc.Id  "  -  "   $assoc.Name  "  -  "  $assoc.Owner

Vous pouvez aussi utiliser -join

Par exemple

$name = -join("Jo", "h", "n");

Attribuerait "John" à $ nom.

Donc, pour sortir, en une seule ligne:

Write-Host (-join("Jo", "h", "n"))

Essayez d'envelopper tout ce que vous souhaitez imprimer entre parenthèses:

Write-host ($assoc.Id + "  -  "  + $assoc.Name + "  -  " + $assoc.Owner)

Votre code est interprété comme autant de paramètres transmis Write-Host. L'encapsuler entre parenthèses concatène les valeurs, puis transmet la valeur résultante en tant que paramètre unique.

Une autre option est:

$string = $assoc.ID
$string += " - "
$string += $assoc.Name
$string += " - "
$string += $assoc.Owner
Write-Host $string

La "meilleure" méthode est probablement celle suggérée par CB:

Write-host "$($assoc.Id)  -  $($assoc.Name)  -  $($assoc.Owner)"

Vous devez placer l'expression entre parenthèses pour éviter qu'elles ne soient traitées comme des paramètres différents de l'applet de commande:

Write-host ($assoc.Id + "  -  "  + $assoc.Name + "  -  " + $assoc.Owner)

Alors que l'expression:

"string1" + "string2" + "string3"

va concaténer les chaînes. Vous devez mettre un $ devant la parenthèse pour qu'elle soit évaluée comme un seul argument lorsqu'elle est passée à une commande powershell. Exemple:

Write-Host $( "string1" + "string2" + "string3" ) 

En prime, si vous souhaitez qu'il s'étende sur plusieurs lignes, vous devez utiliser la syntaxe d'acquittement vers l'arrière à la fin de la ligne (sans espaces ni caractères à droite de l'arrière). Exemple:

Write-Host $(`
    "The rain in "        +`
    "Spain falls mainly " +`
    "in the plains"       )`
    -ForegroundColor Yellow

(En fait, je pense que Powershell est actuellement implémenté un peu mal en nécessitant des retours en arrière inutiles entre parenthèses. Si Microsoft devait simplement suivre les règles de parenthèse "Python" ou "TCL" pour vous permettre de mettre autant de nouvelles lignes que vous le souhaitez entre le démarrage et la fin des parenthèses résoudrait alors la plupart des problèmes que les gens n'aiment pas à propos de la PowerShell liés à la continuation de ligne et à la concaténation des chaînes. J'ai trouvé que vous pouvez laisser les tiques en arrière parfois en ligne entre les parenthèses, mais sa vraiment floconneux et imprévisible si cela fonctionne .. il vaut mieux simplement ajouter les contre-coups.)

Voici une autre façon comme alternative:

Write-host (" {0}  -  {1}  -  {2}" -f $assoc.Id, $assoc.Name, $assoc.Owner)

Je veux juste apporter une autre façon de le faire en utilisant .NET String.Format :

$name = "Slim Shady"
Write-Host ([string]::Format("My name is {0}", $name))

(Version PS actuelle 5.1.17134.407)

Tout est dit et fait maintenant, je suppose, mais cela fonctionne aussi à partir de maintenant:

$myVar = "Hello"

echo "${myVar} World"

Remarque: cela ne fonctionne qu'avec des guillemets doubles

Ces réponses semblent toutes très compliquées. Si vous l'utilisez dans un script PowerShell, vous pouvez simplement le faire:

$name = 'Slim Shady'
Write-Host 'My name is'$name

Il produira

Je m'appelle Slim Shady

Notez comment un espace est placé entre les mots pour vous

De quoi faire / ne pas faire dans PowerShell: Partie 1 :

$id = $assoc.Id
$name = $assoc.Name
$owner = $assoc.owner
"$id - $name - $owner"

Concaténer des chaînes comme au temps DOS. C'est un gros problème pour la journalisation, alors voilà:

$strDate = Get-Date
$strday = "$($strDate.Year)$($strDate.Month)$($strDate.Day)"

Write-Output "$($strDate.Year)$($strDate.Month)$($strDate.Day)"
Write-Output $strday

Je semble avoir du mal avec cela (et bien d'autres choses non intuitives) chaque fois que j'utilise PowerShell après un temps loin de lui, alors j'opte maintenant pour:

[string]::Concat("There are ", $count, " items in the list")

Write-Host peut également concaténer comme ceci:

Write-Host $assoc.Id" - "$assoc.Name" - "$assoc.Owner

C'est le moyen le plus simple, à mon humble avis.

$assoc = @{
    Id = 34
    FirstName = "John"
    LastName = "Doe"
    Owner = "Wife"
}

$assocId = $assoc.Id
$assocFN = $assoc.FirstName
$assocLN = $assoc.LastName
$assocName = $assocFN, $assocLN -Join " "
$assocOwner = $assoc.Owner

$assocJoin = $assocId, $assocName, $assocOwner -join " - "
$assocJoin
#Output = 34 - John Doe - Wife

Si vous concaténez des chaînes pour créer des chemins de fichier, utilisez la commande join-path:

join-path C:\temp "MyNewFolder"

Il ajoutera automatiquement les barres obliques de fin / de tête appropriées pour vous, ce qui rend les choses beaucoup plus faciles.

Je m'excuse si c'est trop hors sujet, mais j'ai pensé que cela pourrait aider certains.
Si je n'utilise pas PowerShell pendant un certain temps, parfois j'oublie qu'il existe et commence à rechercher les opérateurs de concaténation.

Vous pouvez également accéder aux méthodes C # /. NET, et les éléments suivants fonctionnent également:

$string1 = "Slim Shady, "
$string2 = "The real slim shady"

$concatString = [System.String]::Concat($string1, $string2)

Output:

Slim Shady, The real slim shady

Juste pour le plaisir. Vous pouvez également accéder directement aux valeurs du PSObject comme ci-dessous:

$assoc.psobject.Properties.value -join " - "

Mais si vous ne spécifiez pas que l'objet doit être ordonné, Powershell affichera les valeurs dans un ordre aléatoire. Il faut donc ajouter le drapeau [commandé]

$assoc = [pscustomobject] [ordered] @{
    Id = 42
    Name = "Slim Shady"
    Owner = "Eminem"
}