Partager via


about_Comparison_Operators

RUBRIQUE
    about_Comparison_Operators

DESCRIPTION COURTE
    Décrit les opérateurs qui comparent des valeurs dans Windows 
    PowerShell.

DESCRIPTION LONGUE
    Les opérateurs de comparaison vous permettent de spécifier des 
    conditions pour la comparaison de valeurs et la recherche de valeurs 
    correspondant aux modèles spécifiés. Pour utiliser un opérateur 
    de comparaison, spécifiez les valeurs à comparer de part et 
    d'autre de l'opérateur.


    Par défaut, tous les opérateurs de comparaison ne respectent pas 
    la casse. Pour qu'un opérateur de comparaison respecte la casse, 
    faites précéder son nom de la lettre " c ". Par exemple, la 
    version respectant la casse de " -eq " est " -ceq ". Pour rendre 
    le non-respect de la casse explicite, faites précéder l'opérateur 
    de la lettre " i ". Par exemple, la    version ne respectant pas 
    la casse explicitement de " -eq " est " ieq ".


    Tous les opérateurs de comparaison, à l'exception des opérateurs 
    de relation contenant contenu (-contains, -notcontains) et des 
    opérateurs de type (-is, -isnot), renvoient une valeur booléenne 
    lorsque l'entrée de l'opérateur (valeur située à gauche de 
    l'opérateur) est une valeur unique (scalaire). Lorsque l'entrée 
    est une collection de valeurs, les opérateurs de relation 
    contenant contenu et les opérateurs de type retournent n'importe 
    quelle valeur correspondante. S'il n'existe aucune correspondance 
    dans une collection, ces opérateurs ne retournent aucune valeur. Les 
    opérateurs de relation contenant contenu et les opérateurs de type 
    renvoient toujours une valeur booléenne.


    Windows PowerShell prend en charge les opérateurs de comparaison 
    suivants :


    -eq
      Description : égal à. Inclut une valeur identique.
      Exemple :


          C:\PS> "abc", "def" -eq "abc"
          abc


    -ne
      Description : différent de. Inclut une valeur différente.
      Exemple :


          C:\PS> "abc", "def" -ne "abc"
          def


    -gt
      Description : supérieur à.
      Exemple :


          C:\PS> 8 -gt 6
          True



    -ge
      Description : supérieur ou égal à.
      Exemple :


          C:\PS> 8 -ge 8
          True         


    -lt
      Description : inférieur à.
      Exemple :


          C:\PS> 8 -lt 6
          False


    -le
      Description : inférieur ou égal à.
      Exemple :


          C:\PS> 6 -le 8
          True

 
    -like
      Description : établit une correspondance à l'aide du caractère 
      générique (*).
      Exemple :


          C:\PS> "Windows PowerShell" -like "*shell"
          True


    -notlike
      Description : n'établit pas de correspondance à l'aide du caractère 
      générique (*).
      Exemple :


          C:\PS> "Windows PowerShell" -notlike "*shell"
          False
               

    -match 
      Description : met en correspondance une chaîne à l'aide 
                    d'expressions régulières. Si l'entrée est une valeur scalaire, 
                    celle-ci remplit la variable automatique $Matches. 
      Exemple :

                                      
          C:\PS> "Septembre" -match "sept" 
          True 

          C:\PS> $matches 
          Name Value 
          ---- ----- 
          0  sept
 
 
    -notmatch
      Description : vérifie l'absence de correspondance avec une 
                    chaîne. Utilise des expressions régulières.
                    Si l'entrée est une valeur scalaire, celle-ci 
                    remplit la variable automatique $Matches. 
      Exemple :


          C:\PS> "Septembre" -notmatch "sept"
          False

          C:\PS> $matches 
          Name Value 
          ---- ----- 
          0  sept

 
    -contains
      Description : opérateur de relation contenant contenu. Inclut 
                    une valeur identique qui ne fait pas partie d'une valeur. 
                    Retourne toujours une valeur booléenne.
      Exemple :


          C:PS> "abc", "def" -contains "def"
          True


    -notcontains
      Description : opérateur de relation contenant contenu. N'inclut 
      pas de valeur identique. Retourne toujours une valeur booléenne.
      Exemple :


          C:PS> "Windows", "PowerShell" -notcontains "Shell"
          True
 

    -replace
      Description : opérateur de remplacement. Modifie les éléments 
      spécifiés d'une valeur.
      Exemple :


          C:\PS> "Get-Process" -replace "Get", "Stop"
          Stop-Process
               

  Opérateurs d'égalité
      Les opérateurs d'égalité (-eq, -ne) renvoient la valeur TRUE ou 
      les correspondances si une ou plusieurs des valeurs d'entrée sont 
      identiques au modèle spécifié. Le modèle entier doit correspondre 
      à une valeur entière.


      Les exemples suivants montrent l'effet de l'opérateur Égal à :


          C:PS> 1,2,3 -eq 2
          2

          C:PS> "PowerShell" -eq "Shell"
          False

          C:PS> "Windows", "PowerShell" -eq "Shell"
          C:PS> 

          C:\PS> "abc", "def", "123" -eq "def"
          def
 

  Opérateurs de relation contenant contenu
      Les opérateurs de relation contenant contenu (-contains et 
      -notcontains) sont semblables aux opérateurs d'égalité. 
      Toutefois, les opérateurs de relation contenant contenu 
      retournent toujours une valeur booléenne, même quand l'entrée 
      est une collection. 


      En outre, contrairement aux opérateurs d'égalité, les 
      opérateurs de relation contenant contenu renvoient une valeur 
      dès qu'ils détectent la première correspondance. Les opérateurs 
      d'égalité évaluent toutes les entrées, puis retournent toutes 
      les correspondances de la collection.
      Les exemples suivants montrent l'effet de l'opérateur -contains :


          C:PS> 1,2,3 -contains 2
          True

          C:PS> "PowerShell" -contains "Shell"
          False

          C:PS> "Windows", "PowerShell" -contains "Shell"
          False

          C:\PS> "abc", "def", "123" -contains "def"
          True

          C:\PS> "vrai", "bleu", "six" -contains "vrai"
          True
 

      L'exemple ci-dessous montre la différence entre les opérateurs 
      de relation contenant contenu et l'opérateur Égal à. Les 
      opérateurs de relation contenant contenu retournent la valeur 
      TRUE à la première correspondance.
 

          C:\PS> 1,2,3,4,5,4,3,2,1 -eq 2
          2
          2

          C:\PS> 1,2,3,4,5,4,3,2,1 -contains 2
          True
 
      
      Dans une très grande collection, l'opérateur -contains retourne les 
      résultats plus rapidement que l'opérateur Égal à.


  Opérateurs de correspondance
      Les opérateurs de correspondance (-match et -notmatch) 
      recherchent des éléments correspondant ou non à un modèle 
      spécifié à l'aide d'expressions régulières. 

      La syntaxe est la suivante :

          <string[]> -match <expression régulière>
          <string[]> -notmatch <expression régulière>


      Les exemples suivants illustrent quelques emplois possibles de 
      l'opérateur -match :


          C:\PS> "Windows", "PowerShell" -match ".shell"
          PowerShell

          C:\PS> (get-command get-member -syntax) -match "-vue"
          True

          C:\PS> (get-command get-member -syntax) -notmatch "-chemin"
          True

          C:\PS> (get-content servers.txt) -match "^Server\d\d"
          Server01
          Server02

         
      Les opérateurs de correspondance effectuent la recherche 
      uniquement dans les chaînes. Ils ne peuvent pas rechercher dans 
      des tableaux d'entiers ou dans d'autres objets. 

      Les opérateurs -match et -notmatch remplissent la variable 
      automatique $Matches lorsque l'entrée (argument situé à gauche) de 
      l'opérateur correspond à un objet scalaire unique. Si l'entrée est 
      une valeur scalaire, les opérateurs -match et -notmatch retournent 
      une valeur booléenne et définissent la valeur de la variable 
      automatique $Matches sur les composants de l'argument mis en 
      correspondance.

      Si l'entrée est une collection, les opérateurs -match et -notmatch 
      retournent les membres correspondants de cette collection, mais ne 
      remplissant pas la variable $Matches.

      Par exemple, la commande ci-dessous soumet une collection de 
      chaînes à l'opérateur -match. L'opérateur -match retourne les 
      éléments correspondants de la collection. Il ne remplit pas la 
      variable automatique $Matches.

          C:\PS> "Septembre", "Octobre", "Novembre" -match "sept"
          Septembre

          C:\PS> $matches
          C:\PS>


      Par opposition, la commande ci-dessous soumet une chaîne unique à 
      l'opérateur de correspondance. L'opérateur -match retourne une valeur 
      booléenne et remplit la variable automatique $Matches.

          C:\PS> "Septembre" -match "sept"
          True

          C:\PS> $matches

          Name                           Value
          ----                           -----
          0                              Sept


      L'opérateur -notmatch remplit la variable automatique $Matches 
      lorsque l'entrée correspond à une valeur scalaire et que le 
      résultat est False, c'est-à-dire lorsqu'il détecte une 
      correspondance.


          C:\PS> "Septembre" -notmatch "pluie"
          True

          C:\PS> $matches
          C:\PS>
          
          C:\PS> "Minuit" -notmatch "nuit"
          False

          C:\PS> $matches
          C:\PS>

          Name                           Value
          ----                           -----
          0                              nuit

        
  Opérateur de remplacement
      L'opérateur -replace remplace tout ou partie d'une valeur par 
      la valeur spécifiée à l'aide d'expressions régulières. Vous 
      pouvez utiliser l'opérateur -replace pour de nombreuses tâches 
      d'administration, telles que la modification des noms de fichiers. 
      Par exemple, la commande suivante remplace les extensions de noms 
      de fichiers de tous les fichiers .gif par .jpg :
 

          Get-ChildItem | Rename-Item -NewName { $_ -replace 
          '.gif$','.jpg$' }

 
      La syntaxe de l'opérateur -replace se présente comme suit, où 
      l'espace réservé <original> représente les caractères à remplacer 
      et l'espace réservé <remplacement> correspond aux caractères de 
      remplacement :


          <entrée> <opérateur> <original>, <remplacement> 


      Par défaut, l'opérateur -replace ne respecte pas la casse. Pour 
      qu'il respecte la casse, utilisez -creplace. Pour qu'il ne 
      respecte pas la casse explicitement, utilisez ireplace. Examinez les 
      exemples suivants :


          C:\PS> "verre" -replace "V", "T"
          Terre
          C:\PS> "verre" -ireplace "V", "T" 
          Terre
          C:\PS> "verre" -creplace "V", "T"
          verre
 

  Opérateurs de bits
      Windows PowerShell prend en charge les opérateurs de bits 
      standard, y compris les opérateurs de bits AND (-band), de même 
      que les opérateurs de bits OR inclusifs et exclusifs (-bor et 
      -bxor). Depuis Windows PowerShell 2.0, tous les opérateurs de bits 
       fonctionnent avec les entiers 64 bits.


      Windows PowerShell prend en charge les opérateurs de bits suivants :


      Opérateur  Description               Exemple  
      --------  ----------------------    -------------------
      -band     Opérateur de bits AND     C:\PS> 10 -band 3
                                          2
 
      -bor      Opérateur de bits OR      C:\PS> 10 -bor 3
                (inclusif)                11 
                                             

      -bxor     Opérateur de bits OR      C:\PS> 10 -bxor 3
                (exclusif)                9
 
      Les opérateurs de bits agissent sur le format binaire d'une 
      valeur. Par exemple, la structure de bits du nombre 10 est 
      00001010 (sur la base d'un octet) et la structure de bits du 
      nombre 3 est 00000011. Lorsque vous utilisez un opérateur de 
      bits pour comparer 10 et 3, la comparaison s'effectue sur 
      chaque bit de l'octet.
 

      Dans une opération AND au niveau du bit, le bit résultant a la 
      valeur 1 uniquement lorsque les deux bits d'entrée ont la valeur 1.


          00001010   (10)
          00000011   ( 3)
          ------------------ bAND
          00000010   ( 2)

 
      Dans une opération OR (inclusif) au niveau du bit, le bit 
      résultant a la valeur 1 lorsque l'un des bits d'entrée ou les 
      deux ont la valeur 1. Le bit résultant a la valeur 0 uniquement 
      lorsque les deux bits d'entrée ont la valeur 0.


          00001010   (10)
          00000011   ( 3)
          ------------------ bOR (inclusif)
          00001011   (11)


      Dans une opération OR (exclusif) au niveau du bit, le bit 
      résultant a la valeur 1 uniquement lorsqu'un bit d'entrée 
      a la valeur 1.


          00001010   (10)
          00000011   ( 3)
          ------------------ bXOR (exclusif)
          00001001   ( 9)
 

VOIR AUSSI
    about_Operators
    about_Regular_Expressions
    about_Wildcards
    Compare-Object