Voilà un articles de documentation qui présente toutes les différentes méthodes que vous pouvez utilisez lorsque vous codez des messages sur DIalog Insight

**Notez que cette documentation s'adresse aux partenaires**

Les guillemets du langage DI#

Échappement depuis du HTML

Tout ce qui se trouve en dehors d'une paire de balises ouvrantes/fermantes est ignoré par le compilateur, ce qui permet d'avoir du code DI# mixant les contenus. Ceci permet à DI# d'être contenu dans des documents HTML, pour créer par exemple des templates.

1 <p>Ceci sera ignoré par le compilateur et affiché dans le navigateur.</p>

2 [[="Alors que ceci sera analysé par le compilateur de DI";]]

3 <p>Ceci sera aussi ignoré par le compilateur et affiché au navigateur.</p>

Ou

1 <p>Ceci sera ignoré par le compilateur et affiché dans le navigateur.</p>

2 [[ output.write("Alors que ceci sera analysé par le compilateur de DI"); ]]

3 <p>Ceci sera aussi ignoré par le compilateur et affiché au navigateur.</p>

Exemple : Échappement avancé en utilisant des conditions

1 [[ if (a > b) { ]]

2   Ceci sera affiché si l'expression est vraie.

3 [[ } else { ]]

4   Sinon, ceci sera affiché.

5 [[ } ]]

Ou

 1 [[

 2 if (a > b)

 3 { 

 4     output.write("Ceci sera affiché si l'expression est vraie.");

 5 } 

 6 else 

 7 {

 8     output.write("Sinon, ceci sera affiché.");

 9 }

10 ]]

Les types de données

Exemple :

1 string a = "texte";

2 int b = 1;

3 decimal c = 1.234;

4 datetime d1 = 2016.01.01 12:34:56;

5 datetime d2 = 2016.01.01;

6 bool e = true; // ou false ou null

7 timespan g = 2.25; // 2 jours 6 heures

8 datasource h = {1, 2, 3};

Les extension des types de données

Propriétés

Méthodes

Exemples :

 1 [[

 2 string MonTexte = "ceci EST une chaîne de caractère  ";

 3 

 4 MonTexte.Length; 

 5 // Retourne le nombre 34

 6 

 7 MonTexte.Capitalize(true); 

 8 // Retourne Ceci EST Une Chaîne De Caractère

 9 

10 MonTexte.Capitalize(); // ou MonTexte.Capitalize(false);

11 // Retourne la chaine : "Ceci EST une chaîne de caractère  "

12 

13 MonTexte.IndexOf("a"); 

14 // Retourne le nombre 15

15 

16 MonTexte.LastIndexOf("a"); 

17 // Retourne le nombre 26

18 

19 MonTexte.Left(12); 

20 // Retourne la chaine : "ceci EST une"

21 

22 MonTexte.Right(12); 

23 // Retourne la chaîne : "caractère"

24 

25 MonTexte.Replace("une chaîne", "un test"); 

26 // Retourne la chaîne : "ceci EST un test de caractère  "

27 

28 MonTexte.Substring(12); 

29 // Retourne la chaîne : "chaîne de caractère "

30 

31 MonTexte.Substring(12, 3); 

32 // Retourne la chaîne : " ch"

33 

34 MonTexte.ToLower(); 

35 // Retourne la chaîne : "ceci est une chaîne de caractère  "

36 

37 MonTexte.ToUpper(); 

38 // Retourne la chaîne : "CECI EST UNE CHAÎNE DE CARACTÈRE  "

39 

40 MonTexte.Trim(); 

41 // Retourne "ceci EST une chaîne de caractère"

42 ]]

int

decimal

datetime

 1 [[

 2 datetime MyDate = 2016.01.01 12:34:56;

 3 

 4 MyDate.AddYears(3); // Résultat : 2019-01-01 12:34:56

 5 MyDate.AddMonths(3); // Résultat : 2016-04-01 12:34:56

 6 MyDate.AddDays(3); // Résultat : 2016-01-04 12:34:56

 7 MyDate.AddHours(3); // Résultat : 2016-01-01 15:34:56 

 8 MyDate.AddMinutes(3); // Résultat : 2016-01-01 12:37:56

 9 MyDate.AddSeconds(3); // Résultat : 2016-01-01 12:34:59

10 

11 MyDate.DateDiff("2014.03.03").Days; // Affiche 669

12 MyDate.isDST(); // Affiche False

13 MyDate.ToString(); // Affiche : 2016.01.01 12:34:56

14 MyDate.ToString("d/M/yyyy HH:mm:ss"); // Résultat : 1-1-2016 12:34:56

15 MyDate.ToString("F"); // Résultat : 1 janvier 2016 12:34:56

16 MyDate.ToString("ddd, dd MMM yyyy HH':'mm':'ss 'GMT' "); 

17 // Résultat : ven., 01 janv. 2016 12:34:56 GMT

18 

19 MyDate.Date; // Résultat : 2016-01-01 00:00:00

20 MyDate.Day; // Résultat : 1

21 MyDate.DayOfWeek; // Résultat : 5

22 MyDate.DayOfYear; // Résultat : 1

23 MyDate.Hour; // Résultat : 12

24 MyDate.Minute; // Résultat : 34

25 MyDate.Month; // Résultat : 1

26 MyDate.Second; // Résultat : 56

27 MyDate.Ticks; // Résultat : 635872484960000000

28 MyDate.Year; // Résultat : 2016

29 ]]

bool

timespan

Tableaux et collections

Un tableau en DI# est en fait une carte ordonnée. Une carte est un type qui associe des valeurs à des clés. Ce type est optimisé pour différentes utilisations ; il peut être considéré comme un tableau, une liste, une table de hashage, un dictionnaire, une collection, une pile, une file d'attente et probablement plus. On peut avoir, comme valeur d'un tableau, d'autres tableaux, multidimensionnels ou non. Autrement dit, on peut instancier un tableau de n’importe quel datatype qui serait soit fixe (voir les types listés ci-dessus), soit dynamique (équivalent à List en .NET).

Déclaration

On peut définir un tableau en DI# comme ceci :

{ value1, value2, value3 }

Exemple :

datasource myDictionary  = { Prenom : "John", Nom : "Smith", Age : 30 };

Les valeurs listées sont des Expressions, dont la valeur peut elle-même contenir une expression. On peut combiner les deux comme dans cet exemple :

1 datasource myArray = 

2 {

3 { Prenom : "Jean", Nom : "Tremblay", Age : 40 }, 

4 { Prenom : "John", Nom : "Smith", Age : 30 } 

5 };

Il existe deux façon d’instancier un tableau :

• soit en créant un tableau de longueur fixe : int a[10];
• soit en créant un tableau de longueur variable : string b[];

Exemples :

1 string a[] = {"texte1", "texte2", "texte3"};

2 int b[] = {1, 2, 3};

3 decimal c[] = {1.111, 2.222, 3.333};

4 datetime d[] = {2016.01.01 01:01:01, 2016.02.02 02:02:02, 2016.03.03 03:03:03};

5 bool e[] = {true, false, null};

6 timespan g[] = {1472500, 1472500};

7 datasource h[] = {123, "texte1", 1.111, 2016.01.01 01:01:01, true};

Instanciation

On peut assigner des valeurs initiales en déclarant l'array :

1 int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

2 string b[] = { "texte 1", "test", "abc" };

Lorsqu’une variable est déclarée de type tableau, cette dernière ne peut accepter que des valeurs du type de données du tableau. Exemple : int a[10] n’acceptera que des int.

Les Opérateurs

Opérateurs simple

Opérateurs complexes

• LIKE (ou son contraire NOTE LIKE) :

L’opérateur LIKE permet d’effectuer une recherche sur un modèle particulier. Il est par exemple possible de rechercher si une valeur d’une chaine de caractère commence par telle ou telle lettre.

• LIKE "%a" : le caractère « % » est un caractère joker qui remplace tous les autres caractères. Ainsi, ce modèle permet de rechercher toutes les chaines de caractère qui se termine par un « a ».
• LIKE "a%" : ce modèle permet de rechercher toutes les lignes de « colonne » qui commence par un « a ».
• LIKE "%a%" : ce modèle est utilisé pour rechercher tous les enregistrements qui utilisent le caractère « a ».
• LIKE "pa%on" : ce modèle permet de rechercher les chaines qui commence par « pa » et qui se terminent par « on », comme « pantalon » ou « pardon ».

Note : Utiliser l’opérateur LIKE sans modèle sur une chaine de caractère produit le même effet que d’utiliser l’opérateur égal : ==

• CONTAINS (ou son contraire NOT CONTAINS) :

L’opérateur CONTAINS permet d’effectuer une recherche sur un modèle particulier. Il est par exemple possible de rechercher si une valeur est contenu dans une chaine de caractère. Note : Utiliser l’opérateur CONTAINS sur une chaine de caractère produit le même effet que d’utiliser l’opérateur LIKE avec ce modèle "%a%".

Les opérateurs LIKE et CONTAINS ne s’appliquent que sur des chaines de caractères. Autrement dit, il n’est pas possible d’utiliser CONTAINS pour savoir si une valeur est contenue dans un tableau par exemple.

• IS NULL (ou son contraire IS NOT NULL) :

L’opérateur IS NULL permet de savoir si la variable contient une valeur.

Exemples :

1 string a = "ceci est un test";

2 output.write(a contains "ceci" ? true : false); // Affiche True

3 output.write(a like "ceci" ? true : false); // Affiche False

4 output.write(a like"ceci%" ? true : false); // Affiche True 

5 output.write(a is null ? true : false); // Affiche False

Les opérateurs arithmétiques

Les opérateurs de tableaux

Opération unique

Ajouter un item à une position fixe :

1 x[0] = 123; // ajouter l'entier 123 à la position 0 du tableau

Ajouter un item à la fin d’un tableau dynamique

1 x[] += "test"; // ajoute "test" à la fin du tableau

Supprimer un item d’un tableau dynamique

1 x[] -= "test"; // efface toutes les instances égales à "test" du tableau

Opération en lot

Assigner plusieurs valeurs en une seule instruction :

1 x = { "blue", "red", "green" }; 

2 // x contient maintenant blue, red et green

Attention, cette instanciation ne fonctionnera que si toutes valeurs passées sont bien du même type que le tableau, ici des chaînes de caractères.

Ajouter des éléments à la fin d’un tableau dynamique:

1 x[] += { "blue", "pink", "blue" }; 

2 // x contient maintenant blue, red, green, blue, pink et blue

Portée des variables (scope)

La portée d'une variable dépend du contexte dans lequel la variable est définie. Une variable définie à la racine du code aura une portée sur la totalité du script. Mais, une variable définie dans une fonction sera locale à la fonction. Autrement dit, toute variable créée à une portée limitée à sa propre fonction, ainsi qu’à ses fonctions sous-jacentes.

Exemple :

1 [[

2 int x = 123; // portée globale

3

4 string MyFunction(string value)

5 {

6   int y = 456; // portée locale

7   x = x + 1; // utilisation possible d'une variable globale dans la fonction

8 }

9 ]]

Le contexte est quant à lui délimité par { et }. Ainsi, la déclaration d’une variable à l’intérieur de ces accolades, en fera une variable locale.

Expressions de requête

Les expressions de requête peuvent être utilisées pour interroger et transformer des données à partir de n'importe quelle source de données complexe. Ces requêtes servent à manipuler, trier ou filtrer un tableau (ou dictionnaire, liste, etc.).

L’objectif est, à partir d’un tableau, de créer une nouvelle source de données qui :

• Filtre optionnellement le tableau original (clauses “Where”)
• Trie optionnellement le tableau original (clauses “Order by”)
• Extrait une propriété spécifique des items du tableau original
• Dédoublonne optionnellement les résultats

Utilisation

Concrètement, les expressions de requêtes s’utilise comme ceci :

1 select identifier.propriete3

2 from identifier in expression

3 where identifier.propriete1 = valeur

4 order by (identifier.propriete2 asc)

• Expression : la structure dans laquelle on veut récupérer un élément (un tableau, une collection, etc.)
• Identifier : le nom de la variable qui va récupérer l’élément du tableau sélectionné par la clause Where

Exemples

Supposons la source de données suivante :

1 [[

2 datasource Vehicules = 

3 {

4    { Marque: "Toyota", Modele: "Sienna", Annee: 2015},

5    { Marque: "Ford", Modele: "Fusion", Annee: 2013},

6    { Marque: "Chevrolet ", Modele: "Equinox", Annee: 2005 },

7    { Marque: "Hyundai", Modele: "Accent", Annee: 2016 },

8    { Marque: "Mazda", Modele: "CX-5", Annee: 2015 },

9    { Marque: "Hyundai", Modele: "Accent", Annee: 2010 },

10 };

11 ]]

Pour sélectionner toutes les marques de tous les véhicules :

1 [[

2 datasource Marques =   select voiture.Marque 

3 from voiture in Vehicules;

4 /*

5 le tableau Marques contient :

6 Toyota

7 Ford

8 Chevrolet

9 Hyundai

10 Mazda

11 Hyundai

12 */

13 ]]

Pour sélectionner toutes les marques uniques (sans doublon) de tous les véhicules ordonnés du modèle le plus récent au plus ancien :

1 [[

2 datasource Marques =   select distinct voiture.Marque

3 from voiture in Vehicules

3 order by (voiture.Annee desc); 

4 /*

5 le tableau Marques contient :

6 Hyundai

7 Mazda

8 Toyota

9 Ford

10 Chevrolet

11 */

12 ]]

Pour sélectionner toutes les marques uniques (sans doublon) de tous les véhicules ordonnés du modèle le plus récent au plus ancien, en excluant les modèles avant 2014 :

1 [[

2 datasource Marques =   select distinct voiture.Marque 

3 from voiture in Vehicules  

4 where (voiture.Annee > 2014)

5 order by (voiture.Annee desc); 

6 /*

7 le tableau Marques contient :

8 Hyundai

9 Mazda

10 Toyota

11 */

12 ]]

Note : il est possible de cloner un tableau en sélectionnant tous items de ce dernier :

1 [[

2 datasource VehiculesCopie = select voiture from voiture in Vehicules; 

3 ]]

Notes importantes

Ces fonctionnalités de requête et recherche de données dans les sources disponibles, bien que très puissantes, imposent des pénalités de performance importantes.

Si utilisées de manière incorrecte dans un message, par exemple, ces requêtes peuvent avoir un impact important sur la vitesse de production des messages – considérez par exemple que toutes requêtes faitent dans un message transmis à un million de contact devra être traitée un million de fois.

N’hésitez pas à communiquer avec notre équipe de support ou nos analystes pour des conseils lors de la création de messages nécessitant ce degré de complexité.

Les structures de contrôle

if

L'instruction if est une des plus importantes instructions de tous les langages. Elle permet l'exécution conditionnelle d'une partie de code. Les fonctionnalités de l'instruction if sont les mêmes qu'en C :

1 if (expression)

2    commande ;

ou

1 if (expression)

2 {

3    Commandes 1 ;

4    Commandes 2 ;

5 }

L’instruction if converti son expression en sa valeur booléenne. Si l'expression vaut TRUE, DI# exécutera l'instruction et si elle vaut FALSE, l'instruction sera ignorée.

L'exemple suivant affiche la phrase « a est plus grand que b » si a est plus grand que b :

1 [[

2 int a = 1;

3 int b = 2;

4 if (a > b)

5    output.write("a est plus grand que b");

6 [[

Vous pouvez imbriquer indéfiniment des instructions if dans d'autres instructions if, ce qui permet une grande flexibilité dans l'exécution d'une partie de code suivant un grand nombre de conditions.

else

Souvent, vous voulez exécuter une instruction si une condition est remplie, et une autre instruction si cette condition n'est pas remplie. C'est à cela que sert else. else fonctionne après un if et exécute les instructions correspondantes au cas où l'expression du if est FALSE. Dans l'exemple suivant, ce bout de code affiche « a est plus grand que b » si la variable a est plus grande que la variable b, et « a est plus petit que b » dans le cas contraire :

1 [[

2 int a = 1;

3 int b = 2;

4 if (a > b) {

5    output.write("a est plus grand que b");

6 } else {

7    ouput.write("a est plus petit que b");

8 }

9 ]]

if/else raccourci

Comme en C#, il est possible d’utiliser un raccourci à l’instruction if/else en utilisant l’opérateur conditionnel ? : tel que :

1 (condition) ? (expression_si_vrai) : (expression_si_faux);

Exemple :

1 [[

2 int a = 1;

3 int b = 2;

4 output.write((a > b) ? "a est plus grand que b" : "a est plus petit que b"); 

5 ]]

Note : Dû à des limitations du compilateur DI#, assurez-vous de placer la condition entre parenthèses lorsque vous utilisez cette forme.

while

La boucle while est le moyen le plus simple d'implémenter une boucle en DI#. Cette boucle se comporte de la même manière qu'en C. L'exemple le plus simple d'une boucle while est le suivant :

1 while (expression)

2    commande ;

ou

1 while (expression)

2 {

3    Commandes 1 ;

4    Commandes 2 ;

5 }

L’exemple suivant affiche tous les nombres de 1 jusqu'à 10 :

1 [[

2 int a = 1;

3 while (a <= 10)

4 {

5    output.write(a);

6    a+=1;

7 }

8 ]]

Note : Portez attention à la gestion de vos variables qui contrôlent la boucle pour ne pas créer une boucle sans fin. Par mesure de protection, l’exécution des boucles while en DI# prennent fin automatiquement dès que 250 itérations sont atteintes.

foreach

Itération sur un tableau

La structure de langage foreach fournit une façon simple de parcourir des tableaux.

1 foreach (identifier in expression)

2    commande;

ou

1 foreach (identifier in expression)

2 {

3    commande 1 ;

4    commande 2 ;

5 }

Dans cette structure, «identifier» est le nom que l’on choisit pour la variable qui itère les valeurs du tableau retourné par l’ «expression». Cette variable doit être du même type que les valeurs du tableau.

L’exemple suivant montre comment afficher tous les éléments d’un simple tableau de nombres entiers :

1 [[

2 int myArray[] = { 1, 2, 3, 4, 5}; 

3 foreach(number in myArray)

4 {

5    output.write(number);

6 }

7 ]]

Utilisation d’une expression complexe

Puisqu’un foreach permet d’itérer n’importe quel tableau issu d’une expression, il est possible d’utiliser des expressions complexes directement dans la structure du foreach, comme par exemple une expression de requête (voir leurs utilisations dans la partie précédente).

Exemple :

1 [[

2 datasource myArray =

3 {

4    { Prenom : "Jean", Nom : "Tremblay", Age : 40 },

5    { Prenom : "John", Nom : "Smith", Age : 30 }

6 };

7

8  foreach(Namevalue in (select item.Nom

9  from item in myArray

10 order by (item.Age)))

11 {

12    output.write("Nom :" + Namevalue);

13 }

14 ]]

Itération avec compteur

Comme dans de nombreux langages, il est possible d’entretenir un compteur pendant que l’on itère les valeurs de l’expression :

1 foreach (compteur => identifier in expression)

2    commande ;

Dans cette structure, «compteur» est le nom d’une variable qui est un nombre entier initialisé à 0 qui s’incrémentera à chaque itération de l’expression. Ceci permet d’avoir en tout temps

1 [[

2 int myArray[] = { 1, 2, 3, 4, 5};

3 foreach(itemOrder => number in myArray)

4 {

5    output.write("position : " + itemOrder);

6    output.write("valeur : " + number);

7 }

8 ]]

Note : tout comme pour la boucle while, une boucle foreach s’interrompt automatiquement après 250 itérations.

break

L'instruction break permet de sortir d'une structure itérative foreach ou while. L’exemple suivant permet de «casser» la boucle du foreach afin de n’afficher que les 3 premiers nombres :

1 [[

2 int myArray[] = { 1, 2, 3, 4, 5};

3 foreach(number in myArray)

4 {

5    output.write(number);

6    if (number == 3)

7       break;

8 }

9 ]]

switch

L'instruction switch équivaut à une série d'instructions if. En de nombreuses occasions, vous aurez besoin de comparer la même variable (ou expression) avec un grand nombre de valeurs différentes, et d'exécuter différentes parties de code suivant la valeur à laquelle elle est égale. C'est exactement à cela que sert l'instruction switch.

Utilisation :

1 switch (expression)

2 {

3 case valeur :

4    commande;

5 }

ou

1 switch (expression)

2 {

3    case valeur :

4    {

5    commande 1;

6    commande 2;

7    }

8 }

Les deux exemples suivants sont deux manières différentes d'écrire la même chose, l'une en utilisant une série de if, et l'autre en utilisant l'instruction switch :

1 [[

2 int i = 0;

3 if (i == 0)

4    output.write("i égal 0");

5 if (i == 1)

6    output.write("i égal 1");

7 if (i == 2)

8    output.write("i égal 2");

9

10 switch (1)

11 {

12    case 0:

13       output.write("i égal 0");

14    case 1:

15       output.write("i égal 1");

16    case 2:

17       {

18       output.write("i égal 2");

19       output.write("i égal 2");

20       }

21 }

22 ]]

Contrairement à d’autres langages, il n’est pas nécessaire d’utiliser l’instruction break dans un switch de DI#. En effet dès qu’un des cas est respecté, ses instructions seront exécutées et le compilateur sortira immédiatement du switch.

Notez qu’il n’y a également pas de default dans le DI#, ainsi si aucun cas n’est respecté, le switch n’exécutera aucune instruction.

continue

L'instruction continue est utilisée dans une boucle afin d'éluder les instructions de l'itération courante et de continuer l'exécution à la condition de l'évaluation et donc, de commencer la prochaine itération. L’exemple ci-dessous affiche tous les nombres entiers contenus dans le tableau à l’exception du nombre 3 car l’instruction continue aura pour conséquence de passer à l’instruction suivante, avant d’afficher le nombre 3 :

1 [[

2 Datasource myArray[] = { 1, 2, 3, 4, 5 };

3 foreach(number in myArray)

4 {

5 if (number == 3)

6    continue;

7    output.write(number);

8 }

9 ]]

Un continue arrête donc immédiatement les instructions de la boucle et passe à la prochaine itération.

return

L’instruction return retourne le contrôle du programme au module appelant. L'exécution reprend alors à l'endroit de l'invocation du module.

• Si appelée depuis une fonction, la commande return termine immédiatement la fonction, et retourne l'argument qui lui est passé.
• Si appelée depuis l'environnement global, l'exécution du script est interrompue.

Return accepte une valeur de retour optionnel. Ceci permet d’assigner à une variable le résultat de ce qui a mis fin au script.

Dans l’exemple suivant l’instruction return, en plus d’arrêter le l’exécution de la fonction checkNumber retourne une valeur qui peut être assigné directement à une variable :

1 [[

2 string checkNumber(int x)

3 {

4    if (x == 0)

5       return "x égal 0";

6    if (x == 1) 

7       return "x égal 1";

8    if (x == 2)

9       return "x égal 2";

10 }

11

12 string result = checkNumber(1);

13

14 output.write(result);

15 // Affiche "x égal 1"

16 ]]

Note : si l’instruction return est utilisée à la racine du script, ceci stop l’exécution complète du script et la valeur retournée par return peut dans certain cas remplacer ce que le script aurait dû afficher.

Les fonctions

Déclaration

Une fonction DI# se déclare de la même façon qu’en C. C’est-à-dire :

1 [Type] [Nom] ([Paramètre1], [Paramètre2], etc.)

2 {

3 Instructions...

4 }

Les fonctions doivent être définies à la racine du template, c’est-à-dire qu’elles ne peuvent pas être définies à l’intérieur d’un scope.

Exemple d’une déclaration classique, avec valeur de retour définit :

1 int addNumbers (int x, int y)

2 {

3    return x + y

4 }

Exemple d’une déclaration avec une valeur par défaut :

1 void OutputWithHTMLTag (string value, string Tag = "B")

2 {

3 if (value is null) 

4    return;

5    output.write("<" + Tag + ">" + value + "");

6 }

Note :

• Une fonction peut retourner n’importe quel type (string, int, decimal, etc.). Dans ce cas, la fonction doit nécessairement retourner une valeur. Cette valeur doit être obligatoirement du même type que le retour attendu par la fonction.
• Une fonction peut aussi être déclarée de type void. Dans ce cas, la fonction est utilisable comme simple instruction. L’exécution de cette fonction doit se terminer par un « return » (sans valeur de retour) ou bien atteindre la fin de la fonction.

Appel

Une fonction s’appelle comme dans tous les autres langages :

1 nom(params)

2 // ou

3 nom()

Une fonction peut être utilisée comme statement/commande dans le script, par exemple :

1 OutputWithTags("mon texte", "i");

Les fonctions qui retournent une valeur (i.e. toutes les fonctions dont le type n’est pas void) peuvent aussi être utilisées en tant qu’expression ou valeur :

1 int x = addNumbers(1,1);