webentwicklung-frage-antwort-db.com.de

Mehrere Vordergrundfarben in PowerShell in einem Befehl

Ich möchte mit einer Anweisung viele verschiedene Vordergrundfarben ausgeben.

PS C:\> Write-Host "Red" -ForegroundColor Red
Red

Diese Ausgabe ist rot.

PS C:\> Write-Host "Blue" -ForegroundColor Blue
Blue

Diese Ausgabe ist blau.

PS C:\> Write-Host "Red", "Blue" -ForegroundColor Red, Blue
Red Blue

Diese Ausgabe ist Magenta, aber ich möchte, dass die Farbe Rot für das Word-Rot und Blau für das Word-Blau mit dem Befehl one ist. Wie kann ich das machen?

50
Mark Tomlin

Bearbeiten (7. Mai 2018): Ich habe Write-Color zu 0.5 aktualisiert und als Modul veröffentlicht. Auch Code ist jetzt auf Github veröffentlicht.

Änderungen in 0,5:

  • hintergrundfarbe hinzugefügt
  • aliase T/B/C zum kürzeren Code hinzugefügt 
  • alias ​​zur Funktion hinzugefügt (kann mit "WC" verwendet werden)
  • korrekturen an der Modulveröffentlichung

Änderungen in 0.4

  • kleine Probleme behoben
  • als Modul veröffentlicht

Links zu Ressourcen:

Dank des veröffentlichten Moduls können Sie den Code wie folgt verwenden:

Install-Module PSWriteColor
Write-Color -Text "Some","Text" -Color Yellow,Red

Code muss nicht mehr kopiert/eingefügt werden. Genießen.

Alter Code ist unten. Es wird dringend empfohlen, die obigen Links für den neuesten Code zu verwenden:

Bearbeiten (9. April 2018): Ich habe Write-Color auf v0.3 aktualisiert. Fühlen Sie sich frei, es an meiner Site zu erhalten, wo ich Write-Color pflege. Es gibt einige kleine Änderungen. Enthält die Option -NoNewLine und -ShowTime

Bearbeiten (Juni 2017): Mit neuer Version aktualisiert, Protokollierung zu Protokollierungszwecken in der Datei hinzugefügt

Die Methode von Josh war so großartig, dass ich sie tatsächlich für meine Bedürfnisse erweitert habe. Ich habe einen Blogbeitrag geschrieben Wie man PowerShell mit mehreren Farben formatiert darüber (mit Screenshots und allem - für die gesamte Geschichte und Verwendung). 

    function Write-Color([String[]]$Text, [ConsoleColor[]]$Color = "White", [int]$StartTab = 0, [int] $LinesBefore = 0,[int] $LinesAfter = 0, [string] $LogFile = "", $TimeFormat = "yyyy-MM-dd HH:mm:ss") {
    # version 0.2
    # - added logging to file
    # version 0.1
    # - first draft
    # 
    # Notes:
    # - TimeFormat https://msdn.Microsoft.com/en-us/library/8kb3ddd4.aspx

    $DefaultColor = $Color[0]
    if ($LinesBefore -ne 0) {  for ($i = 0; $i -lt $LinesBefore; $i++) { Write-Host "`n" -NoNewline } } # Add empty line before
    if ($StartTab -ne 0) {  for ($i = 0; $i -lt $StartTab; $i++) { Write-Host "`t" -NoNewLine } }  # Add TABS before text
    if ($Color.Count -ge $Text.Count) {
        for ($i = 0; $i -lt $Text.Length; $i++) { Write-Host $Text[$i] -ForegroundColor $Color[$i] -NoNewLine } 
    } else {
        for ($i = 0; $i -lt $Color.Length ; $i++) { Write-Host $Text[$i] -ForegroundColor $Color[$i] -NoNewLine }
        for ($i = $Color.Length; $i -lt $Text.Length; $i++) { Write-Host $Text[$i] -ForegroundColor $DefaultColor -NoNewLine }
    }
    Write-Host
    if ($LinesAfter -ne 0) {  for ($i = 0; $i -lt $LinesAfter; $i++) { Write-Host "`n" } }  # Add empty line after
    if ($LogFile -ne "") {
        $TextToFile = ""
        for ($i = 0; $i -lt $Text.Length; $i++) {
            $TextToFile += $Text[$i]
        }
        Write-Output "[$([datetime]::Now.ToString($TimeFormat))]$TextToFile" | Out-File $LogFile -Encoding unicode -Append
    }
}


Write-Color -Text "Red ", "Green ", "Yellow " -Color Red,Green,Yellow

Write-Color -Text "This is text in Green ",
                   "followed by red ",
                   "and then we have Magenta... ",
                   "isn't it fun? ",
                   "Here goes DarkCyan" -Color Green,Red,Magenta,White,DarkCyan

Write-Color -Text "This is text in Green ",
                   "followed by red ",
                   "and then we have Magenta... ",
                   "isn't it fun? ",
                   "Here goes DarkCyan" -Color Green,Red,Magenta,White,DarkCyan -StartTab 3 -LinesBefore 1 -LinesAfter 1

Write-Color "1. ", "Option 1" -Color Yellow, Green
Write-Color "2. ", "Option 2" -Color Yellow, Green
Write-Color "3. ", "Option 3" -Color Yellow, Green
Write-Color "4. ", "Option 4" -Color Yellow, Green
Write-Color "9. ", "Press 9 to exit" -Color Yellow, Gray -LinesBefore 1



Write-Color -LinesBefore 2 -Text "This little ","message is ", "written to log ", "file as well." -Color Yellow, White, Green, Red, Red -LogFile "C:\testing.txt" -TimeFormat "yyyy-MM-dd HH:mm:ss"
Write-Color -Text "This can get ","handy if ", "want to display things, and log actions to file ", "at the same time." -Color Yellow, White, Green, Red, Red -LogFile "C:\testing.txt"

 How to format PowerShell with Multiple Colors

Es bietet zusätzliche Überprüfungen und Funktionen über das Skript von Josh.

30
MadBoy

Sie können Ihren eigenen Write-Color-Befehl ausführen oder nach Inline-Token suchen, die die Farbe ändern. So arbeiteten ANSI-Escape-Sequenzen in den BBS-Tagen.

Aber Sie können erreichen, was Sie wollen, indem Sie Folgendes tun:

Write-Host "Red " -f red -nonewline; Write-Host "Blue " -f blue;

Hier ist eine einfache kleine Funktion, die das tut, was Sie gefragt haben.

function Write-Color([String[]]$Text, [ConsoleColor[]]$Color) {
    for ($i = 0; $i -lt $Text.Length; $i++) {
        Write-Host $Text[$i] -Foreground $Color[$i] -NoNewLine
    }
    Write-Host
}

Write-Color -Text Red,White,Blue -Color Red,White,Blue
48
Josh

Diese Funktion bietet verschiedene syntaktische Zucker:

function color-Write
{
    # DO NOT SPECIFY param(...)
    #    we parse colors ourselves.

    $allColors = ("-Black",   "-DarkBlue","-DarkGreen","-DarkCyan","-DarkRed","-DarkMagenta","-DarkYellow","-Gray",
                  "-Darkgray","-Blue",    "-Green",    "-Cyan",    "-Red",    "-Magenta",    "-Yellow",    "-White")
    $foreground = (Get-Host).UI.RawUI.ForegroundColor # current foreground
    $color = $foreground
    [bool]$nonewline = $false
    $sofar = ""
    $total = ""

    foreach($arg in $args)
    {
        if ($arg -eq "-nonewline") { $nonewline = $true }
        elseif ($arg -eq "-foreground")
        {
            if ($sofar) { Write-Host $sofar -foreground $color -nonewline }
            $color = $foregrnd
            $sofar = ""
        }
        elseif ($allColors -contains $arg)
        {
            if ($sofar) { Write-Host $sofar -foreground $color -nonewline }
            $color = $arg.substring(1)
            $sofar = ""
        }
        else
        {
            $sofar += "$arg "
            $total += "$arg "
        }
    }
    # last bit done special
    if (!$nonewline)
    {
        Write-Host $sofar -foreground $color
    }
    elseif($sofar)
    {
        Write-Host $sofar -foreground $color -nonewline
    }
}

Beispiele:

color-Write This is normal text
color-Write Normal -Red Red -White White -Blue Blue -ForeGround Normal
5
Jesse Chisholm

Hier ist eine kleine Funktion, die ich geschrieben habe, um farbigen Text auszugeben (er ist zwar kleiner, aber ich habe ihn neu geschrieben, um ihn verständlicher zu machen):

function Write-Color() {
    Param (
        [string] $text = $(Write-Error "You must specify some text"),
        [switch] $NoNewLine = $false
    )

    $startColor = $Host.UI.RawUI.ForegroundColor;

    $text.Split( [char]"{", [char]"}" ) | ForEach-Object { $i = 0; } {
        if ($i % 2 -eq 0) {
            Write-Host $_ -NoNewline;
        } else {
            if ($_ -in [enum]::GetNames("ConsoleColor")) {
                $Host.UI.RawUI.ForegroundColor = ($_ -as [System.ConsoleColor]);
            }
        }

        $i++;
    }

    if (!$NoNewLine) {
        Write-Host;
    }
    $Host.UI.RawUI.ForegroundColor = $startColor;
}

Die Verwendung ist ganz einfach: Verwenden Sie einfach Write-Color "your text" und fügen Sie zwischen geschweiften Klammern einen Farbnamen hinzu, an dem der Text farbig sein soll.

Beispiele:

`Write-Color "Hello, {red}my dear {green}friend !"` will output

Skript-Screenshot

Sie können es in Ihre $profile-Datei einfügen, um es in einer einfachen PowerShell-Eingabeaufforderung zu verwenden, oder Sie fügen es einfach zu einigen Skripts hinzu.

4
Raphaël Gomes

Das funktioniert auch ...

Write-Host "Don't forget to " -ForegroundColor Yellow -NoNewline; Write-Host "CALL YOUR MOM " -ForegroundColor Red -NoNewline; Write-Host "every day!" -ForegroundColor Yellow
3
Abraham Lincoln

Leichte Änderung an dieser Version ... Ich nahm Version 2, entfernte die Protokollierung (weil ich sie nicht möchte) und fügte dann einen booleschen Parameter hinzu, ähnlich wie -NoNewLine für Write-Host. Ich habe insbesondere versucht, die Möglichkeit hinzuzufügen, die Farben und die Eingabeaufforderung für Benutzereingaben in derselben Zeile zu ändern, damit ich die Standardantwort hervorheben kann, wenn der Benutzer nichts eingibt.

Mir ist klar, dass dies in Write-HostColored (in einer früheren Antwort) verfügbar war ... aber manchmal möchte man einfach einfacheren Code ...

function Write-Color([String[]]$Text, [ConsoleColor[]]$Color = "White", [int]$StartTab = 0, [int] $LinesBefore = 0,[int] $LinesAfter = 0, [bool] $NewLine = $True) {

    # Notes:
    # - TimeFormat https://msdn.Microsoft.com/en-us/library/8kb3ddd4.aspx
    #
    # Example:  Write-Color -Text "Red ", "Green ", "Yellow " -Color Red,Green,Yellow -NewLine $False
    #
    $DefaultColor = $Color[0]
    if ($LinesBefore -ne 0) {
        for ($i = 0; $i -lt $LinesBefore; $i++) {
            Write-Host "`n" -NoNewline
        }
    } # Add empty line before

    if ($StartTab -ne 0) {
        for ($i = 0; $i -lt $StartTab; $i++) {
            Write-Host "`t" -NoNewLine
        }
    }  # Add TABS before text

    if ($Color.Count -ge $Text.Count) {
        for ($i = 0; $i -lt $Text.Length; $i++) {
            Write-Host $Text[$i] -ForegroundColor $Color[$i] -NoNewLine
        }
    }
    else {
        for ($i = 0; $i -lt $Color.Length ; $i++) {
            Write-Host $Text[$i] -ForegroundColor $Color[$i] -NoNewLine
        }
        for ($i = $Color.Length; $i -lt $Text.Length; $i++) {
            Write-Host $Text[$i] -ForegroundColor $DefaultColor -NoNewLine
        }
    }

    if ($NewLine -eq $False) {
        Write-Host -NoNewLine
    }
    else {
        Write-Host
    }

    if ($LinesAfter -ne 0) {
        for ($i = 0; $i -lt $LinesAfter; $i++) {
            Write-Host "`n"
        }
    }  # Add empty line after

}  # END FUNCTION Write-Color

Probe von dem, was ich zu erreichen versuchte:

Write-Color -Text "Is this correct? ","[y]","/n" -Color White, Magenta, White -NewLine $False ; Read-Host " "
1
EricM

Im Folgenden finden Sie erweiterte function Write-HostColored, die das Einbetten von Farbanweisungen in einen String sowohl für die Vordergrund- als auch die Hintergrundfarbe ermöglicht:

Write-HostColored "I'm #green#green#, I'm #red#red#, and I'm #blue:white#blue on white#."

Die oben genannten Erträge:

 sample output

Sie können eine Standard-Vorder- und Hintergrundfarbe mit -ForegroundColor und -BackgroundColor, Akzeptieren. Sie können eine oder mehrere Farbspezifikationen in die Zeichenfolge einbetten, Verwenden Sie die folgende Syntax:

#<fgcolor>[:<bgcolor>]#<text>#

<fgcolor> und <bgcolor> müssen gültige [ConsoleColor]-Werte sein, wie green oder white (Groß- und Kleinschreibung spielt keine Rolle) ..__ Alles, was der Farbspezifikation bis zum nächsten # oder implizit bis zum Ende des Strings folgt, wird in dieser Farbe geschrieben .


Write-HostColored-Quellcode (PSv2 +):

<#
.SYNOPSIS
A wrapper around Write-Host that supports selective coloring of
substrings via embedded coloring specifications.

.DESCRIPTION
In addition to accepting a default foreground and background color,
you can embed one or more color specifications in the string to write,
using the following syntax:
#<fgcolor>[:<bgcolor>]#<text>#

<fgcolor> and <bgcolor> must be valid [ConsoleColor] values, such as 'green' or 'white' (case does not matter).
Everything following the color specification up to the next '#', or impliclitly to the end of the string,
is written in that color.

Note that nesting of color specifications is not supported.
As a corollary, any token that immediately follows a color specification is treated
as text to write, even if it happens to be a technically valid color spec too.
This allows you to use, e.g., 'The next Word is #green#green#.', without fear
of having the second '#green' be interpreted as a color specification as well.

.PARAMETER ForegroundColor
Specifies the default text color for all text portions
for which no embedded foreground color is specified.

.PARAMETER BackgroundColor
Specifies the default background color for all text portions
for which no embedded background color is specified.

.PARAMETER NoNewline
Output the specified string withpout a trailing newline.

.NOTES
While this function is convenient, it will be slow with many embedded colors, because,
behind the scenes, Write-Host must be called for every colored span.

.EXAMPLE
Write-HostColored "#green#Green foreground.# Default colors. #blue:white#Blue on white."

.EXAMPLE
'#black#Black on white (by default).#Blue# Blue on white.' | Write-HostColored -BackgroundColor White

#>
function Write-HostColored() {
    [CmdletBinding()]
    param(
        [parameter(Position=0, ValueFromPipeline=$true)]
        [string[]] $Text
        ,
        [switch] $NoNewline
        ,
        [ConsoleColor] $BackgroundColor = $Host.UI.RawUI.BackgroundColor
        ,
        [ConsoleColor] $ForegroundColor = $Host.UI.RawUI.ForegroundColor
    )

    begin {
        # If text was given as a parameter value, it'll be an array.
        # Like Write-Host, we flatten the array into a single string
        # using simple string interpolation (which defaults to separating elements with a space,
        # which can be changed by setting $OFS).
        if ($Text -ne $null) {
            $Text = "$Text"
        }
    }

    process {
        if ($Text) {

            # Start with the foreground and background color specified via
            # -ForegroundColor / -BackgroundColor, or the current defaults.
            $curFgColor = $ForegroundColor
            $curBgColor = $BackgroundColor

            # Split message into tokens by '#'.
            # A token between to '#' instances is either the name of a color or text to write (in the color set by the previous token).
            $tokens = $Text.split("#")

            # Iterate over tokens.
            $prevWasColorSpec = $false
            foreach($token in $tokens) {

                if (-not $prevWasColorSpec -and $token -match '^([a-z]*)(:([a-z]+))?$') { # a potential color spec.
                    # If a token is a color spec, set the color for the next token to write.
                    # Color spec can be a foreground color only (e.g., 'green'), or a foreground-background color pair (e.g., 'green:white'), or just a background color (e.g., ':white')
                    try {
                        $curFgColor = [ConsoleColor] $matches[1]
                        $prevWasColorSpec = $true
                    } catch {}
                    if ($matches[3]) {
                        try {
                            $curBgColor = [ConsoleColor] $matches[3]
                            $prevWasColorSpec = $true
                        } catch {}
                    }
                    if ($prevWasColorSpec) {
                        continue
                    }
                }

                $prevWasColorSpec = $false

                if ($token) {
                    # A text token: write with (with no trailing line break).
                    # !! In the ISE - as opposed to a regular PowerShell console window,
                    # !! $Host.UI.RawUI.ForegroundColor and $Host.UI.RawUI.ForegroundColor inexcplicably
                    # !! report value -1, which causes an error when passed to Write-Host.
                    # !! Thus, we only specify the -ForegroundColor and -BackgroundColor parameters
                    # !! for values other than -1.
                    # !! Similarly, PowerShell Core terminal windows on *Unix* report -1 too.
                    $argsHash = @{}
                    if ([int] $curFgColor -ne -1) { $argsHash += @{ 'ForegroundColor' = $curFgColor } }
                    if ([int] $curBgColor -ne -1) { $argsHash += @{ 'BackgroundColor' = $curBgColor } }
                    Write-Host -NoNewline @argsHash $token
                }

                # Revert to default colors.
                $curFgColor = $ForegroundColor
                $curBgColor = $BackgroundColor

            }
        }
        # Terminate with a newline, unless suppressed
        if (-not $NoNewLine) { write-Host }
    }
}
1
mklement0

Dieser Code ist mit einer anderen Anzahl von Argumenten verfügbar: Text, ForeGroundColor und BackGroundColor.

Jede Farbliste wird mit einer Rotationsimplementierung verwendet:

function Write-Color([String[]]$Text, [ConsoleColor[]]$ForeGroundColor, [ConsoleColor[]]$BackGroundColor) {
    for ($i = 0; $i -lt $Text.Length; $i++) {
        $Color = @{}
        if ($ForeGroundColor -and $BackGroundColor){
            $Color = @{
                ForegroundColor = $ForeGroundColor[$i%($ForeGroundColor.count)]
                BackgroundColor = $BackGroundColor[$i%($BackGroundColor.count)]
            }
        } elseif ($ForeGroundColor) {
            $Color = @{
                ForegroundColor = $ForeGroundColor[$i%($ForeGroundColor.count)]
            }
        } elseif ($BackGroundColor) {
            $Color = @{
                BackgroundColor = $BackGroundColor[$i%($BackGroundColor.count)]
            }
        }
        Write-Host $Text[$i] @color -NoNewLine
    }
    Write-Host
}

Protokollnutzung:

Write-Color "Check color list...".PadRight(50), '[', '   OK   ', ']' -fore cyan, White, green, white
Write-Color "Red Check is good...".PadRight(50), '[' ,' ERROR! ', ']' -fore cyan, White, red, white
Write-Color "Write-Color is cool !".PadRight(50), '[', '  WARN  ', ']' -fore cyan, White, Yellow, white

 Enter image description here

List Usage (nur 2 backGroundColor und 4 foreGroundColor):

Write-Color (@(100..115) | %{" -> $_ : ".PadRight(30) + "`n"}) -ForeGroundColor cyan, yellow, Magenta, red -BackGroundColor gray, black

 Enter image description here

Standardschreibhost

Write-Host (@(100..115) | %{" -> $_ : ".PadRight(30) + "`n"}) -BackgroundColor gray

 Enter image description here

1
Alban

Ich habe versucht, dies auf einer Windows Server 2012R2-Box unter ISE auszuführen, und die Funktion von Jesse Chisholm schlug fehl, da aus irgendeinem Grund (Get-Host) .UI.RawUII.ForegroundColor -1 war. Um dies zu verhindern und die Funktion zu vereinfachen, habe ich es ein wenig geändert:

function Write-ColorText
{
    # DO NOT SPECIFY param(...)
    #    we parse colors ourselves.

    $allColors = ("-Black",   "-DarkBlue","-DarkGreen","-DarkCyan","-DarkRed","-DarkMagenta","-DarkYellow","-Gray",
                  "-Darkgray","-Blue",    "-Green",    "-Cyan",    "-Red",    "-Magenta",    "-Yellow",    "-White",
                   "-Foreground")

    $color = "Foreground"
    $nonewline = $false

    foreach($arg in $args)
    {
        if ($arg -eq "-nonewline")
        { 
            $nonewline = $true 
        }
        elseif ($allColors -contains $arg)
        {
            $color = $arg.substring(1)
        }
        else
        {
            if ($color -eq "Foreground")
            {
                Write-Host $arg -nonewline
            }
            else
            {
                Write-Host $arg -foreground $color -nonewline
            }
        }
    }

    Write-Host -nonewline:$nonewline
}

Ich weiß, dass dies ein alter Beitrag ist, aber hoffentlich ist dies für jemanden nützlich und danke Jesse, dass sie mir diese wunderbare Funktion gegeben hat !!

0
pauby

Ich habe eine viel einfachere Option gefunden unter https://blogs.technet.Microsoft.com/heyscriptingguy/2011/05/17/writing-output-with-powershell/

Grundsätzlich beinhaltet der erste write-Host die Option -NoNewLine. Dies verhindert, dass sich die neue Linie bildet. Der nächste write-Host wird unmittelbar nach dem vorherigen Text hinzugefügt. Und jeder der separaten write-Host kann -forroundcolor-Optionen haben. Dies kann für jeden gewünschten Farbwechsel wiederholt werden.

Beispiel mit einer Textzeile mit drei Farben:

write-Host "Your text here " -ForeGroundColor Red -NoNewLine
write-Host "some other text here " -ForeGroundColor Yellow -NoNewLine
write-Host "And the last text here."

Beachten Sie, dass hinter dem Text im ersten und zweiten Write-Host ein Leerzeichen steht. PowerShell verkettet oder kombiniert den Text nicht, er bewegt den Cursor einfach nicht in die nächste Zeile.

0
Clifford

Also, hier ist etwas, das ich mir ausgedacht habe. Hoffe, es hilft jemandem.

$e = "$([char]27)"

enum ANSIFGColors {
  Black   = 30
  Red     = 91
  Green   = 92
  Yellow  = 93
  Blue    = 94
  Magenta = 95
  Cyan    = 96
  White   = 97
}

enum ANSIBGColors {
  Black   = 40
  Red     = 41
  Green   = 42
  Yellow  = 103
  Blue    = 44
  Magenta = 105
  Cyan    = 46
  White   = 107
}

function Colorize-Text {
  param (
    [string]$StringToColor,
    [ANSIFGColors]$TextColor,
    [ANSIBGColors]$BackgroundColor
  )

  $retValue = $null

  if ($BackgroundColor -ne $null ) { $retValue = [string]"$e[$($TextColor.value__);$($BackgroundColor.value__)m$StringToColor$e[0m" }
  else                             { $retValue = [string]"$e[$($TextColor.value__)m$StringToColor$e[0m" }

  return $retValue

}

Kann so verwendet werden;

$FirstVar = Colorize-Text -StringToColor "This is Green" -TextColor Green

$SecondVar = Colorize-Text -StringToColor "This is NOT Green" -TextColor Cyan -BackgroundColor Red

Write-Host $FirstVar $SecondVar

Oder welche andere Kombination Sie auch wählen.

0
Stan

Hier ist eine vereinfachte Möglichkeit, dies zu tun

if ($help)
{

    Write-Host "     For the switch " -NoNewline; Write-Host " -userUniqueId" -ForegroundColor Green -NoNewline; Write-Host ", enter an email address or samaccountname (pin) so '-userUniqueId 123456' "
    Write-Host "";
    Write-Host "     For the switch " -NoNewline; Write-Host " -disableMFAForUser" -ForegroundColor Green -NoNewline; Write-Host ", enter an email address or samaccountname (pin) with the -userUniqueId and then '-disableMFAForUser $true' "
    Write-Host "";
    Write-Host "     For the switch " -NoNewline; Write-Host "-enableMFAForUser" -ForegroundColor Green -NoNewline; Write-Host ", enter an email address or samaccountname (pin) with the -userUniqueId and then '-enableMFAForUser $true' "
    Write-Host "";
    Write-Host "     For the switch " -NoNewline; Write-Host "-verifyAllMFAEnabled" -ForegroundColor Green -NoNewline; Write-Host ", enter '-verifyAllMFAEnabled $true' "
    Write-Host "";
    Write-Host "     For the switch " -NoNewline; Write-Host " -verifyAllMFADisabledSpecificUser" -ForegroundColor Green -NoNewline; Write-Host ", enter an email address or samaccountname (pin) and then '-verifyAllMFADisabledSpecificUser $true' "
    Write-Host "";

    return;
}
0
Bbb

Wenn Sie sich in meiner Situation befinden, habe ich einen einfachen Vanilla-Weg von Microsoft-Dokumenten zum Konsolenmodus gefunden. Es gibt also eine einfache Möglichkeit, die 256-Farben-Unterstützung der ansi-Konsole in cmd und powershell zu starten und zu beenden:

// https://docs.Microsoft.com/en-us/windows/console/setconsolemode
#include <Windows.h>
#include <iostream>
struct  console_data {
    HANDLE hstdin;
    DWORD  mode;

    DWORD start()
    {
        hstdin = GetStdHandle(STD_OUTPUT_HANDLE);
        GetConsoleMode(hstdin, &mode);
        if (!SetConsoleMode(hstdin, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)) {
            DWORD E = GetLastError();
            std::cout << " Error #" << E << "in:"  __FUNCTION__ "\n";
            return GetLastError();
        }
        std::cout << "\033[1;14mReady.\e[0m\n";
        return 0;
    }

    void end()
    {
        SetConsoleMode(hstdin, mode);
    }
    ~console_data() {
        end();
    }
    //...
}RTConsole;

//...
int main()
{
   //... 
   RTConsole.start();
   std::cout << "\033[38;5;192m Should be 'Orange'\n";
   RTConsole.end();
   return 0;
}

https://docs.Microsoft.com/de-de/windows/console/setconsolemode

Hinweis: Ich habe keine Unterstützung für die Unterstützung von 256 Farben in der Poswershell-Erweiterung von VS Code gefunden.

0
Bretzelus