Opérateur ternaire dans PowerShell

D'après ce que je sais, PowerShell ne semble pas avoir d'expression intégrée pour ce que l'on appelle l' opérateur ternaire .

Par exemple, dans le langage C, qui prend en charge l'opérateur ternaire, je pourrais écrire quelque chose comme:

<condition> ? <condition-is-true> : <condition-is-false>;

Si cela n'existe pas vraiment dans PowerShell, quelle serait la meilleure façon (c'est-à-dire facile à lire et à entretenir) pour obtenir le même résultat?

$result = If ($condition) {"true"} Else {"false"}

Tout le reste est une complexité fortuite et donc à éviter.

Pour l'utiliser dans ou en tant qu'expression, pas seulement une affectation, enveloppez-la $(), ainsi:

write-host  $(If ($condition) {"true"} Else {"false"}) 

La construction PowerShell la plus proche que j'ai pu imaginer est:

@({'condition is false'},{'condition is true'})[$condition]

Powershell 7 l'a. https://toastit.dev/2019/09/25/ternary-operator-powershell-7/

PS C:\Users\js> 0 ? 'yes' : 'no'
no
PS C:\Users\js> 1 ? 'yes' : 'no'
yes

Par ce billet de blog PowerShell , vous pouvez créer un alias pour définir un ?:opérateur:

set-alias ?: Invoke-Ternary -Option AllScope -Description "PSCX filter alias"
filter Invoke-Ternary ([scriptblock]$decider, [scriptblock]$ifTrue, [scriptblock]$ifFalse) 
{
   if (&$decider) { 
      &$ifTrue
   } else { 
      &$ifFalse 
   }
}

Utilisez-le comme ceci:

$total = ($quantity * $price ) * (?:  {$quantity -le 10} {.9} {.75})

Moi aussi, j'ai cherché une meilleure réponse, et bien que la solution dans le post d'Edward soit "ok", j'ai trouvé une solution beaucoup plus naturelle dans ce post de blog

Court et doux:

# ---------------------------------------------------------------------------
# Name:   Invoke-Assignment
# Alias:  =
# Author: Garrett Serack (@FearTheCowboy)
# Desc:   Enables expressions like the C# operators: 
#         Ternary: 
#             <condition> ? <trueresult> : <falseresult> 
#             e.g. 
#                status = (age > 50) ? "old" : "young";
#         Null-Coalescing 
#             <value> ?? <value-if-value-is-null>
#             e.g.
#                name = GetName() ?? "No Name";
#             
# Ternary Usage:  
#         $status == ($age > 50) ? "old" : "young"
#
# Null Coalescing Usage:
#         $name = (get-name) ? "No Name" 
# ---------------------------------------------------------------------------

# returns the evaluated value of the parameter passed in, 
# executing it, if it is a scriptblock   
function eval($item) {
    if( $item -ne $null ) {
        if( $item -is "ScriptBlock" ) {
            return & $item
        }
        return $item
    }
    return $null
}

# an extended assignment function; implements logic for Ternarys and Null-Coalescing expressions
function Invoke-Assignment {
    if( $args ) {
        # ternary
        if ($p = [array]::IndexOf($args,'?' )+1) {
            if (eval($args[0])) {
                return eval($args[$p])
            } 
            return eval($args[([array]::IndexOf($args,':',$p))+1]) 
        }

        # null-coalescing
        if ($p = ([array]::IndexOf($args,'??',$p)+1)) {
            if ($result = eval($args[0])) {
                return $result
            } 
            return eval($args[$p])
        } 

        # neither ternary or null-coalescing, just a value  
        return eval($args[0])
    }
    return $null
}

# alias the function to the equals sign (which doesn't impede the normal use of = )
set-alias = Invoke-Assignment -Option AllScope -Description "FearTheCowboy's Invoke-Assignment."

Ce qui facilite les choses comme (plus d'exemples dans le blog):

$message == ($age > 50) ? "Old Man" :"Young Dude" 

Essayez l' instruction switch de powershell comme alternative, en particulier pour l'affectation des variables - plusieurs lignes, mais lisible.

Exemple,

$WinVer = switch ( Test-Path $Env:windir\SysWOW64 ) {
  $true    { "64-bit" }
  $false   { "32-bit" }
}
"This version of Windows is $WinVer"

Puisqu'un opérateur ternaire est généralement utilisé lors de l'attribution d'une valeur, il doit renvoyer une valeur. Voici comment cela peut fonctionner:

$var=@("value if false","value if true")[[byte](condition)]

Stupide, mais fonctionnant. Cette construction peut également être utilisée pour transformer rapidement un int en une autre valeur, ajoutez simplement des éléments de tableau et spécifiez une expression qui renvoie des valeurs non négatives basées sur 0.

Comme je l'ai déjà utilisé plusieurs fois et que je ne l'ai pas vu ici, je vais ajouter ma pièce:

$var = @{$true="this is true";$false="this is false"}[1 -eq 1]

le plus laid de tous!

un peu la source

J'ai récemment amélioré (ouvrez PullRequest) les opérateurs conditionnels ternaires et coalescents nuls dans les libs PoweShell 'Pscx'. Cherchez
ma solution.

Ma branche de sujet github: UtilityModule_Invoke-Operators

Les fonctions:

Invoke-Ternary
Invoke-TernaryAsPipe
Invoke-NullCoalescing
NullCoalescingAsPipe

Alias

Set-Alias :?:   Pscx\Invoke-Ternary                     -Description "PSCX alias"
Set-Alias ?:    Pscx\Invoke-TernaryAsPipe               -Description "PSCX alias"
Set-Alias :??   Pscx\Invoke-NullCoalescing              -Description "PSCX alias"
Set-Alias ??    Pscx\Invoke-NullCoalescingAsPipe        -Description "PSCX alias"

Usage

<condition_expression> |?: <true_expression> <false_expression>

<variable_expression> |?? <alternate_expression>

En tant qu'expression, vous pouvez passer:
$ null, un littéral, une variable, une expression 'externe' ($ b -eq 4) ou un scriptblock {$ b -eq 4}

Si une variable dans l'expression variable est $ null ou n'existe pas , l'expression alternative est évaluée en sortie.

PowerShell ne dispose pas actuellement d'un If intégré natif (ou If ternaire ), mais vous pouvez envisager d'utiliser l'applet de commande personnalisée:

IIf <condition> <condition-is-true> <condition-is-false>

Voici une autre approche de fonction personnalisée:

function Test-TernaryOperatorCondition {
    [CmdletBinding()]
    param (
        [Parameter(ValueFromPipeline = $true, Mandatory = $true)]
        [bool]$ConditionResult
        ,
        [Parameter(Mandatory = $true, Position = 0)]
        [PSObject]$ValueIfTrue
        ,
        [Parameter(Mandatory = $true, Position = 1)]
        [ValidateSet(':')]
        [char]$Colon
        ,
        [Parameter(Mandatory = $true, Position = 2)]
        [PSObject]$ValueIfFalse
    )
    process {
        if ($ConditionResult) {
            $ValueIfTrue
        }
        else {
            $ValueIfFalse
        }
    }
}
set-alias -Name '???' -Value 'Test-TernaryOperatorCondition'

Exemple

1 -eq 1 |??? 'match' : 'nomatch'
1 -eq 2 |??? 'match' : 'nomatch'

Différences expliquées

• Pourquoi s'agit-il de 3 points d'interrogation au lieu d'un?
  • Le ?personnage est déjà un alias pour Where-Object.
  • ?? est utilisé dans d'autres langues comme un opérateur de coalescence nul, et je voulais éviter toute confusion.
• Pourquoi avons-nous besoin du tuyau avant la commande?
  • Puisque j'utilise le pipeline pour évaluer cela, nous avons toujours besoin de ce caractère pour canaliser la condition dans notre fonction
• Que se passe-t-il si je passe dans un tableau?
  • Nous obtenons un résultat pour chaque valeur; ie -2..2 |??? 'match' : 'nomatch'donne: match, match, nomatch, match, match(c'est-à-dire que tout entier non nul est évalué à true; tandis que zéro est évalué à false).
  • Si vous ne le souhaitez pas, convertissez le tableau en booléen; ([bool](-2..2)) |??? 'match' : 'nomatch'(ou tout simplement: [bool](-2..2) |??? 'match' : 'nomatch')

Si vous cherchez simplement un moyen syntaxiquement simple d'affecter / renvoyer une chaîne ou un numérique basé sur une condition booléenne, vous pouvez utiliser l'opérateur de multiplication comme ceci:

"Condition is "+("true"*$condition)+("false"*!$condition)
(12.34*$condition)+(56.78*!$condition)

Si le résultat ne vous intéresse que lorsque quelque chose est vrai, vous pouvez simplement omettre complètement la fausse partie (ou vice versa), par exemple un simple système de notation:

$isTall = $true
$isDark = $false
$isHandsome = $true

$score = (2*$isTall)+(4*$isDark)+(10*$isHandsome)
"Score = $score"
# or
# "Score = $((2*$isTall)+(4*$isDark)+(10*$isHandsome))"

Notez que la valeur booléenne ne doit pas être le terme principal dans la multiplication, c'est-à-dire que $ condition * "true" etc. ne fonctionnera pas.

À partir de PowerShell version 7, l'opérateur ternaire est intégré à PowerShell.

1 -gt 2 ? "Yes" : "No"