Commande expr

Editer en ligne

Objectif

Evalue les arguments sous forme d'expressions.

Syntaxe

Expr Expression

Descriptif

La commande Expr lit le paramètre Expression , l'évalue et écrit le résultat dans la sortie standard.

Vous devez appliquer les règles suivantes au paramètre Expression :

Séparez chaque terme par des blancs.
Precede caractères spéciaux à l'interpréteur de commandes avec un \ (barre oblique inversée).
Chaînes de devis contenant des blancs ou d'autres caractères spéciaux.

Les entiers peuvent être précécés d'un trait d'union libre. En interne, les entiers sont traités comme des nombres de complément de 32 bits.

Remarque: The Expr command returns 0 to indicate a zero value, rather than the null string.

Les éléments suivants décrivent les opérateurs de paramètres et les mots clés Expression . Les caractères qui doivent être échappés sont précéceux d'un \ (barre oblique inversée). Les éléments sont répertoriés par ordre de priorité croissante, avec des opérateurs de priorité égale regroupés dans { } (accolades):

Article	Descriptif
Expression1 \\| Expression2	Renvoie Expression1 s'il ne s'agit ni d'une valeur nulle, ni d'une valeur 0 ; sinon, elle renvoie Expression2.
Expression1 \& Expression2	Renvoie Expression1 si les deux expressions ne sont ni une valeur nulle ni une valeur 0 ; sinon, elle renvoie une valeur de 0.
Expression1 { =, \>, \>=, \<, \<=, != } Expression2	Renvoie le résultat d'une comparaison d'entiers si les deux expressions sont des entiers ; sinon, elle renvoie le résultat d'une comparaison de chaîne.
Expression1 {+, - } Expression2	Ajoute ou soustrait des arguments de valeur entière.
Expression1 *{ \, /, % }** Expression2	Multiplie, divise ou fournit le reste à partir de la division des arguments de valeur entière.
Expression1 : Expression2	Compare la chaîne résultant de l'évaluation de Expression1 avec le modèle d'expression régulière résultant de l'évaluation de Expression2. La syntaxe d'expression régulière est identique à celle de la commande Ed , sauf que tous les modèles sont ancrés au début de la chaîne (c'est-à-dire que seules les séquences commençant au premier caractère d'une chaîne correspondent à l'expression régulière). Par conséquent, un ^ (caret) n'est pas un caractère spécial dans ce contexte. Normalement, l'opérateur correspondant renvoie le nombre de caractères correspondant (0 en cas d'échec). Si le modèle contient une sous-expression, c'est-à-dire: `$ Expression $` Puis une chaîne contenant les caractères correspondants réels est renvoyée. Une séquence de classement peut définir des classes d'équivalence à utiliser dans les plages de caractères. Pour plus d'informations sur les séquences de classement et les classes d'équivalence, voir "Understanding Locale Environment Variables" dans le document Globalization Guide and Reference .

Remarque: Les arguments de chaîne suivants sont des extensions au-delà de celles des normes, et le comportement peut être différent selon les systèmes d'exploitation. Ces arguments de chaîne ne sont PAS portables.

Article	Descriptif
Correspondance String1 String2	Idem Expression1 : Expression2.
Longueur String1	Renvoie la longueur de String1.
Index String1 String2	Renvoie la première position dans String1 où il existe un caractère dans String2 .
substr String1 StartPosition Longueur	Renvoie une chaîne qui commence par le caractère StartPosition dans String1 et continue pour Longueur caractères

Statut de sortie

Cette commande renvoie les valeurs de sortie suivantes :

Article	Descriptif
0 %	Le paramètre Expression n'a pour résultat aucune valeur NULL ni 0.
1 seul	Le paramètre Expression a pour résultat la valeur NULL ou 0.
2	Le paramètre Expression n'est pas valide.
>2	Une erreur s'est produite.

Remarque: Après le traitement du paramètre par le shell, la commande Expr ne peut pas faire la distinction entre un opérateur et un opérande, à l'exception de la valeur. Ainsi, si la valeur de$aestj, la commande:

expr $a = j

Se présente comme suit:

expr j = j

Une fois que le shell a transmis les arguments à la commande Expr . Les informations suivantes sont également vraies:

expr X$a = Xj

Exemples

Pour modifier une variable de shell, entrez:
```
COUNT=`expr $COUNT + 1`
```
Ceci ajoute1à la variable de shell$COUNT. La commande Expr est incluse dans les accents graves, ce qui permet à l'interpréteur de commandes de remplacer la sortie standard de la commande Expr dans laCOUNT=commande . :NONE.$COUNTDoit être initialisée avant utilisation.
Pour rechercher la longueur de la variable de shell $STR , entrez:
```
LENGTH=`expr $STR : ".*"`
```
Cette option définit lesLENGTHà la valeur donnée par l'opérateur: (colon). Le modèle .* (point, astérisque) correspond à n'importe quelle chaîne du début à la fin, donc l'opérateur de deux-points donne la longueur de$STRVariable au fur et à mesure que le nombre de caractères correspond. Notez que.*Doit être entre guillemets pour empêcher le shell de traiter l'astérisque (*) comme un caractère de correspondance. Les guillemets ne font pas partie du modèle.
Si la commande$STRLa variable est définie sur la chaîne nulle ou contient un espace blanc (blancs ou tabulations), puis la commande affiche le message d'erreurexpr: syntax error. Cela se produit car l'interpréteur de commandes ne transmet normalement pas les chaînes NULL aux commandes. Dans ce cas, la commande Expr ne voit que:
```
:.*
```
Le shell supprime également les apostrophes. Cela ne fonctionne pas car l'opérateur deux-points requiert deux valeurs. Le problème est résolu en fermant la variable de shell entre guillemets:
```
LENGTH=`expr "$STR" : ".*"`
```
Maintenant si la valeur de la$STRLa variable est null, leLENGTHEst définie sur une valeur de 0. Il est généralement recommandé de fermer des variables de shell entre guillemets. Ne pas enfermer des variables de shell entre apostrophes.
Pour utiliser une partie d'une chaîne, entrez:
```
FLAG=`expr "$FLAG" : "-*$.*$"`
```
Cela supprime, le cas échéant, les traits d'union de premier plan de$FLAGVariable de shell. L'opérateur deux-points donne la partie deFLAGVariable correspondant à la sous-expression entre les caractères \ (et \) (barre oblique inversée, parenthèse ouvrée et barre oblique inversée, parenthèse fermante). Si vous omettant les caractères de sous-expression \ (et \), l'opérateur deux-points donne le nombre de caractères correspondant.
Si la commande$FLAGEst définie sur-(trait d'union), la commande affiche un message d'erreur de syntaxe. Cela se produit car la coque remplace la valeur de la$FLAGAvant d'exécuter la commande Expr . La commande Expr ne sait pas que le trait d'union est la valeur d'une variable. Elle ne peut voir que:
```
- : -*$.*$
```
Et il interprète le premier trait d'union comme l'opérateur de soustraction. Pour éliminer ce problème, utilisez:
```
FLAG=`expr "x$FLAG" : "x-*$.*$"`
```
Pour utiliser la commande Expr dans une instruction Si , entrez:
```
if expr "$ANSWER" : "[yY]" >/dev/null
then
echo ANSWER begins with "y" or "Y"
fi
```
Si la commande$ANSWERLa variable commence paryouY, lethenUne partie de l'instruction Si est exécutée. Si la correspondance aboutit, le résultat de l'expression est 1 et la commande Expr renvoie une valeur de sortie 0, qui est reconnue comme la valeur logique True par l'instruction Si . Si la correspondance échoue, le résultat est 0 et la valeur de sortie 1 (False).
La redirection de la sortie standard de la commande expr vers le fichier spécial /dev/null supprime le résultat de l'expression. Si vous ne le redirigez pas, le résultat est écrit dans la sortie standard, qui est généralement l'écran de votre poste de travail.
Prenez en compte l'expression suivante:
```
expr "$STR" = "="
```
Si la commande$STRLa variable a la valeur=(signe égal), après que le shell traite cette commande, la commande Expr voit l'expression:
```
= = =
```
La commande Expr interprète cela en tant que trois = opérateurs d'une ligne et affiche un message d'erreur de syntaxe. Cela se produit chaque fois que la valeur d'une variable de shell est identique à celle de l'un des opérateurs Expr . Vous pouvez éviter ce problème en formulant l'expression comme suit:
```
expr "x$STR" = "x="
```
Pour renvoyer la longueur de la variable d'environnement $SHELL, /usr/bin/ksh, entrez:
```
expr length $SHELL
```
Les éléments suivants s'affichent:
```
12
```
Pour renvoyer la première position où les caractères de la chaîne "de" se trouvent dans "abcdef", entrez:
```
expr index abcdef de
```
Les éléments suivants s'affichent:
```
4
```
Pour renvoyer la première position où les caractères de la chaîne "fd" se trouvent dans "abcdef", entrez:
```
expr index abcdef fd
```
Les éléments suivants s'affichent:
```
4
```
Pour renvoyer la chaîne commençant à la position 11, pour une longueur de 6 de la chaîne "Goodnight Ladies", entrez:
```
expr substr "Goodnight Ladies" 11 6
```
Les éléments suivants s'affichent:
```
Ladies
```

Fichiers

Article	Descriptif
/usr/bin/expr	Contient la commande Expr .