Cette section décrit les expressions contenues dans les robots et la façon dont elles sont modifiées et évaluées.

De nombreuses propriétés dans les étapes de robot peuvent être spécifiées soit comme une valeur simple (par exemple, un nombre), soit comme une expression. Une expression est évaluée, puis le résultat de l'évaluation est utilisé pour la propriété, où des valeurs simples sont utilisées directement comme valeur de la propriété. Par exemple, la propriété Compteur dans l'étape Clic pourrait être spécifiée sous la forme d'un nombre, par exemple 2, mais aussi sous la forme d'une expression, comme clickCount, où clickCount est une variable définie dans le périmètre de l'étape et affectée d'une valeur ailleurs dans le robot.

Les expressions du robot sont très similaires aux expressions des langages de programmation les plus courants, tels que Java, C#, JavaScript, etc. Elles se composent de constantes, de variables, d'opérations (addition, soustraction, multiplication, comparaison, logique, etc.) et de fonctions. Voici quelques exemples d'expressions :

• (1 + 2)*3

• x > 0 || x <= 6

• max(x, 10)

• "hello".substring(3)

Les expressions ont des types et ces types sont identiques à ceux des variables. Cela signifie que l'opération et la fonction ne peuvent être appliquées qu'à des opérandes d'un certain type. Selon le type d'opérande, une valeur d'un type donné est retourné lors de l'évaluation. Par exemple, l'addition de deux opérandes de type Entier produit un résultat de type Entier, tel que 1+2 donne 3. Si le type des opérandes est Nombre, le résultat est de type Nombre, tel que 1.0+2.0 qui produit 3.0. Le type d'une expression est vérifié statiquement avant que l'expression ne soit évaluée, et une erreur de type dans une expression est signalée comme une erreur dans le robot.

L'évaluation d'une expression ne peut pas changer l'état du workflow, c'est-à-dire que vous ne pouvez pas attribuer de valeur à une variable à l'intérieur de l'expression. Seules les étapes peuvent le faire, par exemple l'Étape Assigner assigne une valeur à une variable et cette valeur peut provenir de l'évaluation d'une expression.

Les sections suivantes expliquent les différents composants des expressions.

Constantes

Les constantes sont des valeurs des types simples suivants.

Type	Exemple
Entier	42 -17
Nombre	3.14159 -.33
Booléen	true faux
Texte	"Hello" "Premier"

Les valeurs texte ne doivent pas contenir des guillemets doubles ("), car cela termine la valeur Texte. Utilisez plutôt \" lorsque vous avez besoin d'un guillemet double dans votre valeur Texte. La barre oblique inverse (\) est généralement utilisée pour les caractères spéciaux dans les valeurs Texte que vous ne pouvez pas écrire directement dans les expressions. Les caractères spéciaux sont :

Caractère	Description
\n	saut de ligne Remarque Pour se servir du saut de ligne dans le navigateur intégré, utilisez \r\n
\r	retour à la ligne
\f	saut de page
\"	guillemets doubles
\t	tab
\b	retour arrière
\\	La barre oblique elle-même
\uXXXX	Caractère Unicode codé en nombre hexadécimal, par exemple "\u002A" est une autre façon d'écrire "*"

Variables

Les variables d'une expression peuvent être n'importe quelles variables ou n'importe quels paramètres d'entrée définis dans un workflow, qui sont dans la portée dans l'emplacement de l'expression. Les paramètres d'entrée sont toujours dans la portée, car leur portée est l'ensemble du workflow. Les variables ont une portée si elles sont définies au niveau le plus élevé du workflow ou à l'intérieur d'une Étape Groupe.

Opérations

Une opération est une expression composée d'un opérateur et de d'opérandes. Dans l'expression 1+2, + est l'opérateur et 1 et 2 sont les opérandes. L'opérateur définit donc une opération qui doit être effectuée sur la valeur des opérandes lors de l'évaluation de l'expression. Dans cette section, nous décrivons les opérateurs qui peuvent exister dans les expressions. Dans la plupart des cas, l'opération que ces opérateurs exécutent est simple. Si les expressions des langages de programmation vous sont familières, pouvez ignorer cette description et consulter le tableau récapitulatif ci-dessous.

Opérations arithmétiques

Les expressions prennent en charge les opérations arithmétiques normales, telles que l'addition (+), la soustraction (-), la multiplication (*), la division (/) et le modulo (%). Chacune des opérations accepte deux opérandes qui peuvent avoir n'importe quelle combinaison de type Entier et Nombre. Si au moins un des opérandes est de type Nombre, le type de résultat est également Nombre. Sinon, il est de type Entier.

Lors de l'utilisation d'une opération d'addition (+), si l'un des opérandes est de type Texte et l'autre opérande est de type Entier, Nombre, Booléen ou Texte, le type de résultat est Texte. Par exemple, "a" + 1 produit le texte "a1". La valeur de l'opérande qui n'est pas de type Texte est convertie en texte, puis les valeurs des deux opérandes sont concaténées dans le texte résultant. L'opération de soustraction - peut être également utilisée comme la négation de nombres, comme -x, où x est de type Entier ou Nombre. L'opérateur % s'appelle un modulo ou opérateur de reste. Il renvoie le reste après la division de deux opérandes. Par exemple, 5 % 2 renvoie 1. Plus précisément, il est défini mathématiquement comme suit :

x % y = x - trunc(x / y) * y
where
trunc(x) = sgn(x) * floor(|x|)

L'évaluation d'une opération arithmétique peut générer une exception. Cela peut se produire pour les opérations d'addition, de soustraction, de multiplication et de division si le résultat est en dehors de la limite des nombres, comme un débordement si la valeur d'un nombre est trop grande. Dans ce cas, une exception OverflowIssue est générée. Les opérateurs division et modulus génèrent une exception DivisionByZeroIssue si la valeur du deuxième opérande est égale à zéro. Par exemple :

• 17 % 2 retourne 1.

• -17.3 % 2.0 retourne -1.3

Opérateurs d'égalité

Il existe deux opérateurs d'égalité dans les expressions de workflow.

• == détermine si la valeur d'un opérande est égale à une autre.

• != détermine si la valeur d'un opérande n'est pas égale à celle d'un autre.

Ces opérateurs fonctionnent sur tous les types d'opérandes, mais le type des opérandes doit être identique. Par exemple, vous ne pouvez pas comparer un nombre à un entier.

Opérateurs relationnels

Les opérateurs relationnels déterminent si un opérande est inférieur ou supérieur à un autre opérande. Les opérandes doivent être des nombres, c'est-à-dire de type Entier ou Nombre, et les types des opérandes dans une expression doivent être identiques. Il existe quatre opérateurs relationnels :

Opérateur	Description
<	Inférieur à
<=	inférieur ou égal à
>	supérieur à
>=	supérieur ou égal à

Opérateurs logiques

Il existe deux opérateurs logiques binaires (acceptant deux opérandes) : AND(&&) et OR(||), et un opérateur unaire (accepte un opérande) : NOT (!). Ils sont définis pour les opérandes booléens et leur type de retour est également booléen. L'opérateur && renvoie True si la valeur de ses deux opérandes est vraie et False dans tous les autres cas. L'opérateur || retourne True si la valeur d'au moins un de ses opérandes est vraie et False dans le cas où ils sont les deux faux. L'opérateur ! retourne True si la valeur de l'opérande est fausse et False si l'opérande est vrai.

L'évaluation des opérateurs && et || est légèrement différente de l'évaluation de la plupart des autres opérateurs. Normalement, tous les opérandes sont évalués avant l'opérateur, mais pour les opérateurs && et ||, le premier opérande est évalué en premier, et si cela suffit à déterminer le résultat de l'opération, le second argument n'est pas évalué. Par exemple, dans x==1 || x==2 si x est 1, la deuxième partie de l'expression(x==2) n'est pas évaluée.

Opérateur conditionnel

L'opérateur conditionnel accepte trois opérandes et se présente comme suit :

<Op>?<Op>:<Op>

où <Op> peut être n'importe quel opérande avec certaines restrictions. Par exemple, x==1?0:1 retourne 0 si la valeur de x est 1, et 1 autrement. Le type du premier opérande doit être booléen, et les deux autres opérandes peuvent être de n'importe quel type, mais doivent être identiques.

L'évaluation de l'opérateur conditionnel est également légèrement différente de celle de la plupart des autres opérateurs. Pour l'opérateur conditionnel, le premier opérande est évalué en premier et ensuite, en fonction de sa valeur, seul un des deux autres opérandes est évalué. Si le premier opérande est vrai (ou faux), le deuxième (ou le troisième) opérande est évalué, et le résultat est le résultat de cette évaluation. Cela signifie également que même si une erreur d'évaluation se produit dans l'opérande qui n'est pas évalué, cela ne génère pas d'exception. Par exemple, dans x == 0.0? 1/x si x a la valeur 0.0, 1/x n'est pas évalué, aucune exception DivisionByZeroIssue n'est générée.

Résumé des opérateurs

Le tableau ci-dessous répertorie les opérateurs d'expression.

Opérateur	Description	Exemples
+	Addition ou concaténation de texte	1+2 "hello" + nom
-	Soustraction ou négation	1-2 5-2.9 -5
*	Multiplication	42*2 1.0*17
/	Division	1/2 1/2.0
%	Modulus	x % 2 2.5 % 1.0
==,!=	Égal, différent de	true == false x != 0
<,<=	Inférieur à, inférieur à ou égal à	0 < 1 1.0 <= 0.0
>,>=	Supérieur à, supérieur à ou égal à	0 > 1 1.0 >= 0.0
&&,||	AND logique, OR logique	true || x false && y
!	NOT logique	!true
_?_:_	Opérateur conditionnel	x>0? x: 0

Parenthèses

Vous pouvez utiliser des parenthèses pour déterminer l'ordre d'évaluation dans une expression et modifier le résultat obtenu à partir de l'expression. Par exemple, l'expression 1+2*3 retourne 7, mais si vous insérez une parenthèse comme suit : (1+2)*3, le résultat devient 9, car le contenu de la parenthèse est évalué avant l'opérateur.

Fonction

Les expressions peuvent également contenir des appels de fonction. Il existe deux façons d'appeler une fonction. La première s'appelle un appel de fonction direct et se présente comme suit : f(<Op>,...,<Op>), tel que max(1,2). La deuxième s'appelle un appel de fonction de méthode et se présente comme suit : <Op>.f(<Op>,...,<Op>), par exemple, 1.max(2). Les deux manières sont liées comme suit :

<Op₁>.f(<Op₂>,...,<Op_n>) est identique à f(<Op₁>,...,<Op_n>).

Les fonctions sont similaires aux opérateurs dans la mesure où les opérandes doivent avoir certains types et où le type de résultat dépend des types des opérandes. Par exemple, la fonction max qui détermine le maximum de deux nombres peut être appelée avec des opérandes de type Entier ou Nombre, et le type de retour est identique à celui des opérandes.

Si au cours de l'évaluation, une fonction obtient une valeur d'opérande incorrecte, par exemple, une valeur en dehors de la plage attendue, une exception IncorrectValueIssue est générée.

Kofax RPA fournit les fonctions suivantes.

Tableau 1. Fonctions numériques

Fonction	Type de résultat
abs(Integer)	Entier
abs(Number)	Nombre
ceil(Number)	Entier
computeMD5(binary: Binaire)	Texte Calcule la somme de contrôle MD5 de l'entrée binaire.
floor(Number)	Entier
round(Number)	Entier
trunc(Number)	Entier
max(Integer, Integer)	Entier
max(Number, Number)	Nombre
min(Integer, Integer)	Entier
min(Number, Number)	Nombre
random()	Nombre Renvoie un nombre aléatoire supérieur ou égal à 0,0 et inférieur à 1,0.
random(Integer, Integer)	Entier Renvoie un entier aléatoire supérieur ou égal à la valeur du premier opérande et inférieur ou égal à la valeur du second opérande.

Exemples	Retourne le résultat suivant
abs(-2)	2
1.5.round()	2
random(1,6)	une valeur entière comprise entre 1 et 6

Tableau 2. Fonctions texte

Fonction	Type de résultat
length(Text)	Entier
substring(Text, Integer)	Texte
substring(Text, Integer, Integer)	Texte
indexOf(Text, Text)	Entier
contains(Text, Text)	Booléen
trim(Text)	Texte
capitalize(Text)	Texte
startsWith(Text, Text)	Booléen
endsWith(Text, Text)	Booléen
toLowerCase(Text)	Texte
toUpperCase(Text)	Texte
matches(text: Text, regex: Text)*	Booléen Vérifie que le texte correspond à l'expression régulière.
password(text: Text)	Mot de passe Convertit un texte en mot de passe. Cette expression est utile lorsqu'un mot de passe est requis pour se connecter à une application pendant le développement du robot. Pour des raisons de sécurité, cette fonction ne doit pas être utilisée dans un environnement de production.
removeNonPrintable(text: Text)	Texte Supprime les caractères non imprimables.
replaceAll(text: Text, regex: Text, replacement: Text)*	Remplace tout le sous-texte qui correspond à l'expression régulière par le remplacement donné. Les expressions régulières prennent en charge plusieurs correspondances et références avec $. Par exemple, "xx345-84-7735xx".replaceAll("(.*)(\\d{3}-\\d{2}-\\d{4})(.*)","$2") renvoie "345-84-7735". Notez également que la barre oblique inverse doit être précédée d'un caractère d'échappement.
unquote(text: Text)	Texte Supprime les guillemets d'un texte. Par exemple, "hello" et 'hello' produisent tous les deux hello sans les guillemets.

Remarque * Cette fonction peut s'exécuter longtemps en fonction du texte utilisé et de l'expression régulière. Par exemple, l'entrée d'un grand nombre de zéros supplémentaires dans le texte allonge considérablement l'exécution de la fonction matches. En ajoutant un simple A à la fin, elle retourne presque immédiatement True, comme dans matches("0000000000000000000000", "(0*)*A"). Chaque fois que vous modifiez l'expression, l'évaluation précédente est annulée (si elle s'exécute toujours), et une nouvelle évaluation est lancée.

Exemple	Retourne le résultat suivant
"workflow".substring(5)	low
"xx345-84-7735xx".replaceAll("(.*)(\\d{3}-\\d{2}-\\d{4})(.*)","$2")	345-84-7735

Tableau 3. Fonctions de conversion. Les fonctions de conversion convertissent les valeurs d'un type dans un autre. La conversion peut échouer si la valeur de l'opérande ne représente pas une valeur qui peut être convertie en valeur du type du résultat.

Fonction	Type de résultat
ampersandEncode(text: Text)	Texte Perluète code un texte.
ampersandDecode(text: Text)	Texte Perluète décode un texte.
base64Encode(binaire : Binaire)	Texte Encodage en base 64 en utilisant l'encodage de transfert base 64 pour MIME (RFC 2045).
base64Decode(text: Text)	Binaire Décodage en base 64 en utilisant l'encodage de transfert en base 64 pour MIME (RFC 2045).
boolean(text: Boolean)	Booléen Le texte doit correspondre à « True » ou à « False ».
entier(nombre)	Entier Le nombre doit être une valeur entière, par exemple 1.0
integer(Text)	Entier Le texte doit être une représentation textuelle d'un nombre entier, tel que « 42 »
number(Integer)	Nombre
number(Text)	Nombre Le texte doit être une représentation textuelle d'un nombre, tel que « 17.7 »
text(Integer)	Texte
text(Number)	Texte
text(Boolean)	Texte
text(binary: Binary, charsetName: Text)	Texte Convertit une représentation binaire d'un texte en valeur de type Texte. Spécifiez un jeu de caractères, comme UTF8, comme argument.
binary(text: Text, charsetName: Text)	Binaire Convertit une valeur texte en valeur binaire. Spécifiez un jeu de caractères, comme UTF8, comme argument.
toJSON()	Convertit n'importe quel type de valeur, sauf un mot de passe en valeur texte formatée en tant qu'objet JSON. Les types d'enregistrements qui contiennent un attribut de type Password ne peuvent pas être convertis en JSON. Exemples de valeurs converties 5 devient "5" 1.2 devient "1.2" true devient "true" "Hello" devient "\"Hello\"" Une valeur binaire devient un encodage en base 64 de la valeur binaire Une valeur d'enregistrement, R(a = 5, b = true, t = "Hello") devient "a\":5,\"b\":true,\"t\":\"Hello" Remarque La vue d'état de workflow ne contient pas de barres obliques inverses avant les guillemets. La façon dont la valeur d'enregistrement convertie est indiquée ci-dessus est la façon dont vous devez l'écrire dans une expression. La fonction toJSON ne peut pas générer un tableau, tel que [1, 2, 3]. Lorsque vous utilisez une valeur JSON dans un robot, vous pouvez créer vous-même la liste par concaténation de chaînes. De cette façon, vous pouvez renvoyer les valeurs du robot au Robot à Moteur Basique. Voir Utiliser JSON pour plus d'informations.

Le tableau suivant répertorie et décrit des exemples de fonctions de conversion écrites de deux manières : appel de fonction direct, tel que text(2), et appel de méthode, tel que 2.text(). Alors que dans la première variante, la fonction est appelée directement, la deuxième variante permet d'utiliser la saisie de texte lors de l'écriture d'expressions en mode Expression. Pour plus d'informations, consultez Mode Expression plus loin dans cette section.

Exemples
Fonction	Retourne le résultat suivant
ampersandEncode("<b/>") ou "<b/>".ampersandEncode()	<b/>
ampersandDecode("&lt;b/&gt;") ou "&lt;b/&gt;". ampersandDecode()	<b/>
base64Encode(bin) ou bin.base64Encode() où bin est une variable contenant une valeur binaire résultant de "Hello".binary("ASCII")	SGVsbG8=
base64Decode("SGVsbG8=").text("UTF8") ou "SGVsbG8=".base64Decode().text("UTF8")	Hello
"true".boolean() "false".boolean() "False".boolean()	True booléen False booléen Génère une exception ConversionIssue, car elle ne doit correspondre ni à « true » ni à « false »
integer(2.0) ou 2.0.integer() entier("2") ou "2".entier	2
number(2) ou 2.number() number("2") ou "2".number()	2.0
number(".1E10") ou ".1E10".number()	1.0E9
"Hello".binary("UTF8").text("UFT8") où "Hello".binary("UTF8") retourne une valeur binaire encodée en utilisant le codage de caractères UTF8. Lorsque la valeur binaire est convertie en texte, comme dans cet exemple, elle doit être encodée en utilisant le même encodage de caractères (UTF8 dans ce cas).	Hello
"hello".JSON()	"hello"
17.7.toJSON()	17.7
true.toJSON()	true
Company.toJSON() où Company est une variable d'un type d'enregistrement contenant les types de champs Texte, Entier et Booléen.	une valeur texte avec la valeur suivante : {"name":"Acme Corp.", "url":"www.acme-corp.com", "revenue":1000000000, "CEO":"Marvin Acme", "fictional":true}

Limites des valeurs numériques

Entiers

Le plus grand nombre entier pouvant être représenté est 1E34-1. Il s'agit d'un nombre comportant 34 chiffres neuf. Si vous avez ce nombre et que vous y ajoutez 1, vous obtenez une exception OverflowIssue. De même, la plus petite valeur entière qui peut être représentée est -1E34+1. Ainsi, toutes les valeurs entières doivent se situer entre -1E34+1 et 1E34-1 (les deux inclus).

Nombres

La représentation des nombres correspond à la norme IEEE 754R Decimal128 qui utilise 34 chiffres décimaux et une représentation de l'exposant dans la plage comprise entre -2147483648 et +2147483648. Si l'évaluation d'une expression produit un nombre en dehors de la plage, vous obtenez une exception OverflowIssue.

Voir Limites dans les nombres pour plus d'informations.

Il est possible d'entrer des nombres avec un exposant comme suit :

1.234E5, 0.1E-2, 1000.0e42, etc.

Un nombre de base est éventuellement suivi d'un E ou d'un e et d'un exposant entier. Lorsque des nombres sont affichés dans la vue Statut des données ou dans l'éditeur d'expression, ils sont normalisés selon les règles suivantes :

• Un zéro de fin figure après le point décimal s'il n'existe pas d'autres chiffres décimaux, comme 1.0E12
• L'exposant n'est présent que s'il est numériquement supérieur ou égal à 9, à savoir :
• • 1.0E8 est indiqué sous la forme 100000000, mais 1.0E9 est indiqué sous la forme 1.0E9
  • 1.0E-8 est indiqué sous la forme .000000001, mais 1.0E-9 est indiqué sous la forme 1.0E-9
• Tous les chiffres jusqu'au nombre maximum de 34 sont affichés (les chiffres sont arrondis pour disposer d'un maximum de 34 chiffres). Par exemple, le nombre 9,999999999999999999999999999999999 est indiqué tel quel. Si vous ajoutez un 9 à ce nombre, il est indiqué sous la forme 10.0. En fait, la valeur du nombre est arrondie de sorte qu'en interne, elle est également représentée par 10.0. Par conséquent, les nombres peuvent être saisis d'une manière et affichés d'une autre, ce qui ajoute une certaine souplesse dans la manière dont les chiffres peuvent être saisis, comme 10.0 ou 0.1E2.

La fonction de conversion text(Number) retourne également le nombre écrit selon les règles ci-dessus.