Comment générer du texte sans nouvelle ligne dans PowerShell?

Je veux que mon script PowerShell imprime quelque chose comme ceci:

Enabling feature XYZ......Done

Le script ressemble à ceci:

Write-Output "Enabling feature XYZ......."
Enable-SPFeature...
Write-Output "Done"

Mais Write-Outputimprime toujours une nouvelle ligne à la fin pour que ma sortie ne soit pas sur une seule ligne. Y a-t-il un moyen de faire cela?

Write-Host -NoNewline "Activation de la fonction XYZ ......."

Malheureusement, comme indiqué dans plusieurs réponses et commentaires, Write-Hostpeut être dangereux et ne peut pas être redirigé vers d'autres processus et Write-Outputn'a pas le -NoNewlinedrapeau.

Mais ces méthodes sont les moyens "* nix" pour afficher la progression, la manière "PowerShell" de le faire semble être Write-Progress: il affiche une barre en haut de la fenêtre PowerShell avec des informations de progression, disponibles à partir de PowerShell 3.0, voir le manuel pour détails.

# Total time to sleep
$start_sleep = 120

# Time to sleep between each notification
$sleep_iteration = 30

Write-Output ( "Sleeping {0} seconds ... " -f ($start_sleep) )
for ($i=1 ; $i -le ([int]$start_sleep/$sleep_iteration) ; $i++) {
    Start-Sleep -Seconds $sleep_iteration
    Write-Progress -CurrentOperation ("Sleep {0}s" -f ($start_sleep)) ( " {0}s ..." -f ($i*$sleep_iteration) )
}
Write-Progress -CurrentOperation ("Sleep {0}s" -f ($start_sleep)) -Completed "Done waiting for X to finish"

Et pour prendre l'exemple du PO:

# For the file log
Write-Output "Enabling feature XYZ"

# For the operator
Write-Progress -CurrentOperation "EnablingFeatureXYZ" ( "Enabling feature XYZ ... " )

Enable-SPFeature...

# For the operator
Write-Progress -CurrentOperation "EnablingFeatureXYZ" ( "Enabling feature XYZ ... Done" )

# For the log file
Write-Output "Feature XYZ enabled"

Bien que cela ne fonctionne pas dans votre cas (puisque vous fournissez une sortie informative à l'utilisateur), créez une chaîne que vous pouvez utiliser pour ajouter la sortie. Quand il est temps de le sortir, sortez simplement la chaîne.

Ignorant bien sûr que cet exemple est idiot dans votre cas mais utile dans son concept:

$output = "Enabling feature XYZ......."
Enable-SPFeature...
$output += "Done"
Write-Output $output

Affiche:

Enabling feature XYZ.......Done

Oui, comme les autres réponses ont des états, cela ne peut pas être fait avec Write-Output. Là où PowerShell échoue, tournez-vous vers .NET, il y a même quelques réponses .NET ici, mais elles sont plus complexes que nécessaire.

Utilisez simplement:

[Console]::Write("Enabling feature XYZ.......")
Enable-SPFeature...
Write-Output "Done"

Ce n'est pas le PowerShell le plus pur, mais cela fonctionne.

Pour écrire dans un fichier, vous pouvez utiliser un tableau d'octets. L'exemple suivant crée un fichier ZIP vide, auquel vous pouvez ajouter des fichiers:

[Byte[]] $zipHeader = 80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
[System.IO.File]::WriteAllBytes("C:\My.zip", $zipHeader)

Ou utiliser:

[Byte[]] $text = [System.Text.Encoding]::UTF8.getBytes("Enabling feature XYZ.......")
[System.IO.File]::WriteAllBytes("C:\My.zip", $text)

Une simplification de la réponse de FrinkTheBrave:

[System.IO.File]::WriteAllText("c:\temp\myFile.txt", $myContent)

Le problème que j'ai rencontré était que Write-Output fait en fait des sauts de ligne dans la sortie lors de l'utilisation de PowerShell v2, au moins vers stdout. J'essayais d'écrire un texte XML sur stdout sans succès, car il serait dur enveloppé au caractère 80.

La solution de contournement consistait à utiliser

[Console]::Out.Write($myVeryLongXMLTextBlobLine)

Ce n'était pas un problème dans PowerShell v3. Write-Output semble y fonctionner correctement.

Selon la façon dont le script PowerShell est appelé, vous devrez peut-être utiliser

[Console]::BufferWidth =< length of string, e.g. 10000)

avant d'écrire dans stdout.

Il ne semble y avoir aucun moyen de le faire dans PowerShell. Toutes les réponses précédentes ne sont pas correctes, car elles ne se comportent pas comme elles le font Write-Outputmais plutôt comme celles Write-Hostqui n'ont pas ce problème de toute façon.

La solution ferme semble être utilisée Write-Hostavec le -NoNewLineparamètre. Vous ne pouvez pas diriger ceci, ce qui est généralement un problème, mais il existe un moyen de remplacer cette fonction comme décrit dans Write-Host => Exporter vers un fichier , afin que vous puissiez facilement lui faire accepter le paramètre pour un fichier de sortie. C'est encore loin d'être une bonne solution. Avec Start-Transcriptcela, c'est plus utilisable, mais cette cmdlet a des problèmes avec les applications natives.

Write-Outputne peut tout simplement pas faire ce dont vous avez besoin dans un contexte général.

Write-Hostest terrible, un destructeur de mondes, mais vous pouvez l'utiliser simplement pour afficher la progression d'un utilisateur tout en utilisant Write-Outputpour se connecter (pas que l'OP ait demandé la journalisation).

Write-Output "Enabling feature XYZ" | Out-File "log.txt" # Pipe to log file
Write-Host -NoNewLine "Enabling feature XYZ......."
$result = Enable-SPFeature
$result | Out-File "log.txt"
# You could try{}catch{} an exception on Enable-SPFeature depending on what it's doing
if ($result -ne $null) {
    Write-Host "complete"
} else {
    Write-Host "failed"
}

Vous ne pouvez tout simplement pas demander à PowerShell d'omettre ces nouvelles lignes embêtantes ... Il n'y a pas de script ou d'applet de commande qui le fasse. Bien sûr, Write-Host est un non-sens absolu, car vous ne pouvez pas en rediriger / rediriger!

Néanmoins, vous pouvez écrire votre propre fichier EXE pour le faire.C'est ce que j'ai expliqué comment faire dans la question Stack Overflow Comment sortir quelque chose dans PowerShell .

La réponse de shufler est correcte. En d'autres termes: au lieu de transmettre les valeurs à Write-Output en utilisant le ARRAY FORM,

Write-Output "Parameters are:" $Year $Month $Day

ou l'équivalent par plusieurs appels à Write-Output,

Write-Output "Parameters are:"
Write-Output $Year
Write-Output $Month
Write-Output $Day
Write-Output "Done."

concaténez d'abord vos composants dans une STRING VARIABLE:

$msg="Parameters are: $Year $Month $Day"
Write-Output $msg

Cela empêchera les CRLF intermédiaires provoqués par l'appel de plusieurs fois Write-Output (ou ARRAY FORM), mais bien sûr ne supprimera pas le CRLF final de la commandlet Write-Output. Pour cela, vous devrez écrire votre propre commandlet, utiliser l'une des autres solutions de contournement compliquées répertoriées ici ou attendre que Microsoft décide de prendre en charge l' -NoNewlineoption d'écriture-sortie.

Votre désir de fournir un indicateur de progression textuel à la console (c'est-à-dire "....") par opposition à l'écriture dans un fichier journal, doit également être satisfait en utilisant Write-Host. Vous pouvez accomplir les deux en collectant le texte du msg dans une variable pour l'écrire dans le journal ET en utilisant Write-Host pour fournir une progression à la console. Cette fonctionnalité peut être combinée dans votre propre commandlet pour une meilleure réutilisation du code.

Ce qui suit replacera le curseur au début de la ligne précédente. A vous de le placer dans la bonne position horizontale (en utilisant $ pos.X pour le déplacer latéralement):

$pos = $host.ui.RawUI.get_cursorPosition()
$pos.Y -= 1
$host.UI.RawUI.set_cursorPosition($Pos)

Votre sortie actuelle est de 27 espaces, donc $ pos.X = 27 pourrait fonctionner.

Ce n'est peut-être pas très élégant, mais il fait exactement ce qu'OP a demandé. Notez que l'ISE joue avec StdOut, donc il n'y aura aucune sortie. Afin de voir ce travail de script, il ne peut pas être exécuté dans l'ISE.

$stdout=[System.Console]::OpenStandardOutput()
$strOutput="Enabling feature XYZ... "
$stdout.Write(([System.Text.Encoding]::ASCII.GetBytes($strOutput)),0,$strOutput.Length)
Enable-SPFeature...
$strOutput="Done"
$stdout.Write(([System.Text.Encoding]::ASCII.GetBytes($strOutput)),0,$strOutput.Length)
$stdout.Close()

J'ai triché, mais je crois que c'est la seule réponse qui répond à toutes les exigences. À savoir, cela évite le CRLF de fin, fournit un endroit pour que l'autre opération se termine dans l'intervalle, et redirige correctement vers stdout si nécessaire.

$c_sharp_source = @"
using System;
namespace StackOverflow
{
   public class ConsoleOut
   {
      public static void Main(string[] args)
      {
         Console.Write(args[0]);
      }
   }
}
"@
$compiler_parameters = New-Object System.CodeDom.Compiler.CompilerParameters
$compiler_parameters.GenerateExecutable = $true
$compiler_parameters.OutputAssembly = "consoleout.exe"
Add-Type -TypeDefinition $c_sharp_source -Language CSharp -CompilerParameters $compiler_parameters

.\consoleout.exe "Enabling feature XYZ......."
Write-Output 'Done.'

$host.UI.Write('Enabling feature XYZ.......')
Enable-SPFeature...
$host.UI.WriteLine('Done')

o / p désiré: Activation de la fonction XYZ ...... Terminé

vous pouvez utiliser la commande ci-dessous

$ a = "Activation de la fonction XYZ"

Sortie d'écriture "$ a ...... Done"

vous devez ajouter une variable et une déclaration entre guillemets. j'espère que cela vous sera utile :)

Merci Techiegal

Il y a déjà tellement de réponses ici que personne ne fera défiler ici. Quoi qu'il en soit, il existe également une solution pour écrire du texte sans nouvelle ligne à la fin, avec les éléments suivants:

Sortie de fichier avec encodage:

  # a simple one liner
  "Hello World, in one line" | Out-File -Append -Encoding ascii -NoNewline -FilePath my_file.txt;

  # this is a test to show how it works
  "Hello World".Split(" ") | % { "_ $_ _" | Out-File -Append -Encoding ascii -NoNewline -FilePath my_file.txt; }

Sortie de la console:

  # a simple one liner
  "Hello World, in one line" | Write-Host -NoNewline;

  # this is a test to show how it works
  "Hello World".Split(" ") | % { "_ $_ _" | Write-Host -NoNewline; }

Vous pouvez absolument le faire. Write-Output a un indicateur appelé " NoEnumerate " qui est essentiellement la même chose.