Web Dev Zone

    Utilisation de motifs de reliure dans Ballerina

    Utilisation de motifs de reliure dans Ballerina

    Dans l’article précédent, nous avons discuté du quoi et du comment des modèles de reliure dans Ballerina. Dans cet article, nous examinerons comment les modèles de liaison sont utilisés dans d’autres concepts de langage dans Ballerina.

    Les deux principaux concepts du langage Ballerina qui utilisent des modèles de liaison peuvent être identifiés comme suit :

    1. Mission déstructurante
    2. Déclaration de correspondance

    Mission déstructurante

    Une affectation déstructurante fait correspondre un modèle de liaison (dans ce cas, peut être appelé modèle de liaison déstructurant) à une valeur résultant de l’évaluation d’une action ou d’une expression qui entraînera l’attribution de valeurs aux variables apparaissant dans le modèle de liaison. À l’exception des modèles de liaison de capture, tous les autres modèles de liaison peuvent être utilisés dans les affectations de déstructuration dans Ballerina. Les modèles de liaison de déstructuration sont essentiellement utilisés pour faire référence à des variables existantes et déstructurer la valeur donnée sur le côté droit et affecter ces valeurs à chaque variable individuelle du type pertinent au moment de l’exécution. Cependant, pour qu’une correspondance soit réussie, les points ci-dessous doivent être satisfaits :

    • Le type statique de l’action ou de l’expression doit être un sous-type du type statique du modèle de liaison (impliqué par les variables qu’il contient).
    • Un modèle de liaison dans une affectation de déstructuration ne doit pas faire référence à une variable déclarée par une déclaration de variable de module qui inclut isolated.

    On trouvera ci-dessous quelques exemples des différentes manières dont le motif de liaison déstructurant peut être utilisé.

    Vous trouverez ci-dessous un exemple de modèle de liaison de déstructure de tuple. Ce qui se passe ici, c’est que les valeurs dans x sera affecté aux références de variables individuelles sur le côté gauche.

    [int, string, string, string...] x = [1, "a", "b"];
int a;
string b;
string[] c;

// Tuple destructure binding pattern
[a, b, ...c] = x; 

    C’est également un exemple de modèle de liaison de déstructure de tuple. Cependant, contrairement à l’exemple précédent, la variable référence a1, a2, et a3 sont créés à l’aide du modèle de liaison de tuple [string, [int, boolean]] [a1, [a2, a3]]. Lors de l’utilisation du modèle de liaison de structure de tuple, les références de variables créées se verront attribuer les membres de la valeur de type de tuple ["Ballerina", [453, false]]. 

    [string, [int, boolean]] [a1, [a2, a3]] = ["Hello", [123, true]]; 

// Tuple destructure binding pattern
[a1, [a2, a3]] = ["Ballerina", [453, false]];

    Vous trouverez ci-dessous un exemple de modèle de liaison de déstructure d’enregistrement. Il déstructure et attribue les valeurs de chaque champ de l’enregistrement person aux références variables personId, firstName et lastName.

    type Person record {
   int id;
   string fname;
   string lname;
};

public function main() {
    int personId;
    string firstName;
    string lastName;

    Person person = {id: 123, fname: "Anne", lname: "Frank"};

    // Record destructure binding pattern
    {id: personId, fname: firstName, lname: lastName} = person; 
}

    Ceci est un autre exemple d’un modèle de liaison de déstructuration d’enregistrement. Cependant, contrairement à l’exemple ci-dessus, il y a quelques autres choses qui se produisent dans le processus de déstructuration dans cet exemple. Après avoir fait correspondre les champs id, fname, et lname du premier enregistrement {id: 1, fname: "Alex", lname: "George", "age": 3} dans la liste des enregistrements nommés personList avec les références variables personId, firstName, et lastName sur le côté gauche, le champ restant age sera assorti au reste du motif de reliure ...otherDetails de genre map<anydata|error>. Les extraPerson la variable sera mise en correspondance avec le deuxième enregistrement {id: 2, fname: "Ranjan", lname: "Fonseka", "age": 4} dans la liste des enregistrements personList.

    type Person record {
   int id;
   string fname;
   string lname;
};


public function main() {
    int personId;
    string firstName;
    string lastName;
    map<anydata|error> otherDetails;
    Person extraPerson;

    Person[2] personList = [{id: 1, fname: "Alex", lname: "George", "age": 3}, 
                          {id: 2, fname: "Ranjan", lname: "Fonseka", "age": 4}];

    // Record destructure binding pattern
    [{id: personId, fname: firstName, lname: lastName, ...otherDetails}, extraPerson] = personList;  
}

    Ci-dessous, un modèle de liaison de déstructuration d’erreurs. Il déstructure le error valeur du type SampleError et attribue les valeurs aux références de variables pertinentes. La valeur de la chaîne de raison dans le SampleError sera affecté à la référence variable nommée reason. Les valeurs dans le mappage détaillé seront affectées aux références de variables pertinentes dans le modèle de liaison de déstructuration, dans ce cas errorInfo et errorCode. 

    type ErrorDetail record {
    string message?;
    error cause?;
    string info;
    int code;
};

type SampleError error<ErrorDetail>;

public function main() {
    string reason;
    string errorInfo;
    int errorCode;

    SampleError err = error SampleError("ERROR", info = "Detail Info", code = 123);

    // Error destructure binding pattern
    error(reason, info = errorInfo, code = errorCode) = err;
}

    Il s’agit d’un autre exemple d’un modèle de liaison de déstructuration d’erreurs. Cependant, contrairement à l’exemple précédent, le mappage de détail ErrorDetail dans ce cas a été déstructuré en un map<anydata|error> type référence de variable nommée params. Cela a été fait en utilisant un paramètre de repos ...params.

    type ErrorDetail record {
    string message?;
    error cause?;
    string info;
    int code;
};

type SampleError error<ErrorDetail>;

public function main() {
    string reason;
    map<anydata|error> params;

    SampleError err = error SampleError("ERROR", info = "Detail Info", code = 123);

    // Error destructure binding pattern
    error(reason, ...params) = err;
 }

    Vous trouverez ci-dessous un exemple de modèle de liaison de déstructuration d’erreur qui contient un modèle de liaison de déstructure générique symbolisé par _. Le trait de soulignement _ sign peut être utilisé pour ignorer la chaîne de raison ou le mappage détaillé d’une erreur.

    type ErrorDetail record {
    string message?;
    error cause?;
    string info;
    int code;
};

type SampleError error<ErrorDetail>;

public function main() {
   string errorInfo;
   SampleError err = error SampleError("ERROR", info = "Detail Info", code = 123);

   // Error destructure binding pattern with wildcard destructure binding pattern
   error(_, info = errorInfo) = err;
}

    Déclaration de correspondance

    Une instruction de correspondance sélectionne un bloc d’instructions et l’exécute en fonction des modèles auxquels une valeur correspond, un peu comme un switch déclaration dans des langages comme C et JavaScript. Il ne correspond pas au type. Dans une déclaration de correspondance, il existe un match clause qui consiste en un match pattern list. Cette match pattern list peut être comparé à une valeur.

    Les motifs de liaison sont membres de ce match pattern list ainsi que divers types d’autres modèles de correspondance. De plus, des modèles de liaison sont utilisés dans les instructions de correspondance lors de la création de variables en cas de correspondance réussie. Cela se fait en utilisant le var mot-clé. Les identifiants utilisés dans les modèles de correspondance se réfèrent à constants tandis que les identifiants utilisés dans les modèles de liaison se réfèrent à variables. Cependant, la portée des variables créées dans un match pattern list d’un match clause couvre à la fois le match guard, s’il existe, et le statement block dans ce match clause.

    Vous trouverez ci-dessous quelques exemples de la façon dont les modèles de liaison peuvent être utilisés dans les déclarations de correspondance.

    L’exemple ci-dessous illustre une instruction de correspondance impliquant un modèle de liaison de mappage qui utilise un type d’enregistrement. Dans cet exemple, ce qui se trouve entre les parenthèses de match person est la clause de correspondance. La liste des modèles de correspondance dans cet exemple se compose de deux membres : un modèle de liaison et une forme de modèle de correspondance (qui ne sera pas abordée dans cet article). Cette instruction de correspondance correspond à la valeur de la référence de variable commonPerson.

    Dans ce cas, la partie du motif de reliure est var {name, age, ...other}. Puisque nous passons un Person taper l’enregistrement {name:"Tom", age:25} qui a des champs similaires à {name, age, ...other} (comme discuté dans la section Mapping Binding Patterns de l’article Binding Patterns in Ballerina, c’est la même chose que de dire var {name : name, age : age, ...other}), une correspondance réussie se produit avec le premier membre de la liste des modèles de correspondance. Ainsi, comme dans un modèle de liaison d’enregistrement typique, la variable nommée name sera lié au name domaine de commonPerson et le age variable sera liée à la age domaine de commonPerson. L’opérateur de propagation ...other sera lié avec une carte qui comprend le reste des champs dans commonPerson. Après une correspondance réussie, les variables créées peuvent être utilisées indépendamment dans le cadre de ce bloc d’instructions (ce qui se trouve entre les parenthèses après le => opérateur).

    import ballerina/io;

type Person record {
    string name;
    int age;
};

function testFunction(any commonPerson) {
    match commonPerson {
        var {name, age, ...other} => {
            io:println("Name: ", name);
            io:println("Age: ", age);
            io:println("More info: ", other);
        }
        () => {
            io:println("Not A Match");
        }
    }
}

public function main() {
   Person tom = {name:"Tom",
                    age:25
                };
   
   testFunction(tom);
}

    L’instruction de correspondance ci-dessous utilise le modèle de liaison de liste de types de tuples var [[a1, a2], a3]. Puisque dans ce cas le tuplePattern référence de variable contiendra la valeur [[true, “text], 2], cela créera une correspondance réussie avec [[a1, a2], a3], et comme dans un modèle de liaison de liste typique, les variables a1, a2, et a3 sera lié avec les membres de la valeur dans tuplePattern dans leur ordre d’apparition. 

    import ballerina/io;

function testFunction(any tuplePattern) {
    match tuplePattern {
        var [[a1, a2], a3]  => {
            io:println("a1: ", a1);
            io:println("a2: ", a2);
            io:println("a3: ", a3);
        }
        () => {
            io:println("Not a Match");
        }
    }
}

public function main() {
    testFunction([[true, "text"], 2]);
}

    L’exemple ci-dessous illustre un modèle de liaison d’erreur utilisé avec l’instruction match. Son mode de liaison fonctionne de la même manière que dans un modèle de liaison d’erreur typique étant donné qu’il aboutit à une correspondance réussie.

    import ballerina/io;

type ErrorDetail1 record {
    string message?;
    error cause?;
    string info;
    int code;
};

type TestError error<ErrorDetail1>;

function testFunction(any|TestError err) {
    match err {
        var error(reason, info = errorInfo, code = errorCode)   => {
            io:println("Reason: ", reason);
            io:println("Info: ", errorInfo);
            io:println("Error Code: ", errorCode);
        }
        () => {
            io:println("Not A Match");
        }
    }
}

public function main() {
   TestError err1 = error("ERROR", info = "Text", code = 123);
   testFunction(err1);
}

    Dans l’exemple ci-dessous, nous pouvons voir deux modèles de correspondance : {name: "Tom", age: var age} et (). Cependant, à l’intérieur du {name: "Tom", age: var age} motif de correspondance, nous pouvons également voir le motif de liaison de capture var age. Ce qui se passe dans cet exemple, c’est que lorsqu’une correspondance réussie se produit avec {name: "Tom", age: var age}, la variable nommée…

    Share.
    Add A Comment

    Leave A Reply