Partager via


about_Operators

RUBRIQUE
    about_Operators

DESCRIPTION COURTE
    Décrit les opérateurs pris en charge par Windows PowerShell. 

DESCRIPTION LONGUE
    Un opérateur est un élément de langage que vous pouvez utiliser 
    dans une commande ou dans une expression. Windows PowerShell 
    prend en charge plusieurs types d'opérateurs pour vous aider à 
    manipuler des valeurs.


  Opérateurs arithmétiques
      Utilisez les opérateurs arithmétiques (+, -, *, /, %) pour 
      calculer les valeurs d'une commande ou d'une expression. Avec ces 
      opérateurs, vous pouvez ajouter, soustraire, multiplier ou diviser 
      des valeurs et calculer le reste d'une opération de division.


      Vous pouvez également utiliser les opérateurs arithmétiques avec 
      des chaînes, des tableaux et des tables de hachage. L'opérateur 
      d'addition concatène des éléments. L'opérateur de multiplication 
      retourne le nombre spécifié de copies de chaque élément.


      Pour plus d'informations, consultez about_Arithmetic_Operators. 


  Opérateurs d'affectation
      Utilisez les opérateurs d'affectation (=, +=, -=, *=, /=, %=) pour 
      affecter une ou plusieurs valeurs aux variables, pour modifier 
      les valeurs d'une variable et ajouter des valeurs aux variables. 
      Vous pouvez également transtyper la variable comme tout type 
      de données Microsoft .NET Framework, par exemple chaîne, objet 
      DateTime ou variable Process.


      Pour plus d'informations, consultez about_Assignment_Operators.


  Opérateurs de comparaison
      Utilisez les opérateurs de comparaison (-eq, -ne, -gt, -lt, 
      -le, -ge) pour comparer des valeurs et des conditions de test. 
      Par exemple, vous pouvez comparer deux valeurs de chaîne pour 
      déterminer si elles sont égales. 


      Les opérateurs de comparaison incluent les opérateurs de 
      correspondance (-match, -notmatch) servant à rechercher des 
      modèles à l'aide d'expressions régulières ; l'opérateur 
      de remplacement (-replace), qui utilise des expressions 
      régulières pour modifier des valeurs d'entrée ; et les 
      opérateurs de ressemblance (-like, -notlike), qui recherchent 
      des modèles à l'aide de caractères génériques (*). 


      Ils incluent également les opérateurs au niveau du bit 
      (-bAND, -bOR, -bXOR, -bNOT) pour manipuler les modèles 
      binaires des valeurs.


    Pour plus d'informations, consultez about_Comparison_Operators. 


  Opérateurs logiques
      Utilisez les opérateurs logiques (-and, -or, -xor, -not, !) 
      pour connecter des instructions conditionnelles en une seule 
      condition complexe. Par exemple, vous pouvez utiliser un 
      opérateur -and logique pour créer un filtre d'objet avec deux 
      conditions différentes.


      Pour plus d'informations, consultez about_Logical_Operators.


  Opérateurs de redirection
      Utilisez les opérateurs de redirection (>, >>, 2>, 2> et 2>&1) pour 
      envoyer la sortie d'une commande ou expression vers un fichier texte. 
      Les opérateurs de redirection fonctionnent comme l'applet de commande 
      Out-File (sans paramètre), mais ils vous permettent également de 
      rediriger la sortie d'erreurs vers des fichiers précis. Vous pouvez 
      également utiliser l'applet de commande Tee-Object pour rediriger la 
      sortie.


      Pour plus d'informations, consultez about_Redirection.


  Opérateurs de fractionnement et de jointure
      Les opérateurs -split et -join divisent et combinent des 
      sous-chaînes. L'opérateur -split fractionne une chaîne en 
      sous-chaînes. L'opérateur -join concatène plusieurs chaînes 
      en une seule.


      Pour plus d'informations, consultez about_Split et about_Join.


  Opérateurs de type
      Utilisez les opérateurs de type (-is, -isnot, -as) pour 
      rechercher ou modifier le type .NET Framework d'un objet. 

      Pour plus d'informations, consultez about_Type_Operators.


  Opérateurs unaires
      Utilisez des opérateurs unaires pour incrémenter ou décrémenter des 
      variables ou des propriétés d'objet et pour définir des entiers sur 
      des nombres positifs ou négatifs. Par exemple, pour incrémenter la 
      variable $a afin qu'elle passe de la valeur 9 à la valeur 10, 
      tapez $a++.


  Opérateurs spéciaux
      Utilisez des opérateurs spéciaux pour effectuer des tâches que 
      les autres types d'opérateurs ne permettent pas de réaliser. 
      Par exemple, les opérateurs spéciaux vous permettent d'exécuter 
      des opérations telles que l'exécution de commandes et le 
      changement de type de données d'une valeur.

    
      Opérateur d'appel &
        Description : exécute une commande, un script ou un bloc de 
        script. Étant donné que l'opérateur d'appel n'analyse pas, il 
        ne peut pas interpréter les paramètres de commande. L'opérateur 
        d'appel, également appelé " opérateur d'invocation ", indique 
        que la valeur qu'il précède est une commande. Cela vous permet 
        d'exécuter des commandes stockées dans des variables et 
        représentées par des chaînes. Exemples :


            & "nouvelle applet de commande"
            $c = "get-executionpolicy"  
            & $c


      . Opérateur de déréférencement de propriété
        Description : accède aux propriétés et aux méthodes d'un objet. 
        Exemples :


            $myString.length
            $myString.substring(1,3)


      . Opérateur d'appel de source de type " dot sourcing "
        Description : exécute un script pour que les éléments qu'il 
        contient fassent partie de la portée appelante. Pour plus 
        d'informations, consultez about_Scope. Exemple :


            . c:\scripts.sample.ps1


        Remarque : le point (.) est également utilisé comme symbole de 
                   répertoire parent, comme dans cet exemple :

                   .\sample.ps1

                   Cette commande exécute le script sample.ps1, mais pas 
                   dans le cadre de la portée appelante.


      Opérateur de membre statique ::
        Description : appelle l'opérateur de propriétés statiques et les 
        méthodes d'une classe .NET Framework. Pour rechercher les propriétés 
        statiques et les méthodes d'un objet, utilisez le paramètre Static 
        de l'applet de commande Get-Member. Exemple :


            [datetime]::now
 

      .. Opérateur de plage
        Description : représente les nombres entiers séquentiels d'un 
        tableau de nombres entiers, avec une limite inférieure et une 
        limite supérieure. Exemples :


            1..10
            10..1
            foreach ($a in 1..$max) {write-host $a}


      -Opérateur de mise en forme f
        Description : met en forme des chaînes à l'aide de la méthode 
        de format d'objets chaînes. Entrez la chaîne de mise en forme 
        à gauche de l'opérateur et les objets à mettre en forme à sa 
        droite. Exemples :


            C:\PS> "{0} {1,-10} {2:N}" -f 
            C:\PS> 1,"bonjour",[math]::pi
            1 bonjour 3.14


      Opérateur de sous-expression $( )
        Description : retourne le résultat d'une ou de plusieurs 
        instructions. Pour un résultat unique, retourne une valeur 
        scalaire. Pour plusieurs résultats, retourne un tableau. 
        Exemples :


            $($x * 23)
            $(Get-WMIObject win32_Directory)


      Opérateur de sous-expression de tableau @( )
        Description : retourne le résultat d'une ou de plusieurs 
        instructions sous forme de tableau. Pour un seul élément, 
        le tableau n'a qu'un seul membre. Exemple :


            @(Get-WMIObject win32_logicalDisk)
                       

      Opérateur ,
        Description : en tant qu'opérateur binaire, la virgule crée 
        un tableau. En tant qu'opérateur unaire, la virgule crée un 
        tableau avec un membre. Placez la virgule avant le membre. 
        Exemples :


            $myArray = 1,2,3 
            $SingleArray = ,1   

       
VOIR AUSSI
    about_Arithmetic_Operators
    about_Assignment_Operators
    about_Comparison_Operators
    about_Logical_Operators
    about_Type_Operators
    about_Split
    about_Join
    about_Redirection