Accès aux éléments

Q# prend en charge l’accès aux éléments de tableau et aux éléments dans les types définis par l’utilisateur. Dans les deux cas, l’accès est en lecture seule. La valeur ne peut pas être modifiée sans créer une nouvelle instance à l’aide d’une expression de copie et mise à jour.

Accès aux éléments de tableau et découpage de tableau

À partir d’une expression de tableau et d’une expression de type Int ou Range, une nouvelle expression peut être formée à l’aide de l’opérateur d’accès à l’élément de tableau constitué de [ et ].

Si l’expression à l’intérieur des crochets est de type Int, la nouvelle expression contient l’élément de tableau au niveau de cet index. Par exemple, si arr est de type Double[] et contient cinq éléments ou plus, arr[4] est une expression de type Double.

Si l’expression à l’intérieur des crochets est de type Range, la nouvelle expression contient un tableau de tous les éléments indexés par l’élément Range spécifié. Si Range est vide, le tableau résultant est vide. Par exemple,

let arr = [10, 11, 36, 49];
let ten = arr[0]; // contains the value 10
let odds = arr[1..2..4]; // contains the value [11, 49]
let reverse = arr[...-1...]; // contains the value [49, 36, 11, 10]

Dans la dernière ligne de l’exemple, les valeurs de début et de fin de la plage ont été omises pour des raisons pratiques. Pour plus d’informations, consultez Expressions contextuelles.

Si l’expression de tableau n’est pas un identificateur simple, elle doit être placée entre parenthèses afin d’extraire un élément ou une tranche. Par exemple, si arr1 et arr2 sont tous deux des tableaux d’entiers, un élément de la concaténation est exprimé sous la forme (arr1 + arr2)[13]. Pour plus d’informations, consultez Priorité et associativité.

Tous les tableaux dans Q# sont de base zéro, c’est-à-dire que le premier élément d’un tableau arr est toujours arr[0]. Une exception est levée au moment de l’exécution si l’index ou l’un des index utilisés pour le découpage se trouve en dehors des limites du tableau, par exemple, s’il est inférieur à zéro ou supérieur ou égal à la longueur du tableau.

Accès aux éléments pour les types définis par l’utilisateur

(Pour plus d’informations sur la définition de types personnalisés contenant un ou plusieurs éléments nommés ou anonymes, consultez Déclarations de type).

Les éléments contenus sont accessibles via leur nom ou par déconstruction, illustrés par les instructions suivantes qui peuvent être utilisées dans le cadre d’une opération ou d’une implémentation de fonction :

    let complex = Complex(1., 0.); // create a value of type Complex
    let (re, _) = complex!;       // item access via deconstruction
    let im = complex::Imaginary;  // item access via name

L’opérateur d’accès aux éléments (::) récupère les éléments nommés, comme illustré dans l’exemple suivant :

newtype TwoStrings = (str1 : String, str2 : String);

operation LinkTwoStrings(str : TwoStrings) : String {
    let s1 = str::str1;
    let s2 = str::str2;
    return s1 + s2;
}

Alors que les éléments nommés sont accessibles par leur nom ou via la déconstruction, les éléments anonymes ne sont accessibles qu’à cette dernière. Étant donné que la déconstruction repose sur tous les éléments contenus, l’utilisation d’éléments anonymes est déconseillée lorsque ces éléments doivent être accessibles en dehors de l’unité de compilation dans laquelle le type est défini.

L’accès via la déconstruction utilise l’opérateur Unwrap (!). Cet opérateur de désencapsulage retourne un tuple de tous les éléments contenus, où la forme du tuple correspond à celle définie dans la déclaration et un tuple d’élément unique équivaut à l’élément lui-même (consultez cette section).

Par exemple, pour une valeur nested de type Nested définie comme suit

newtype Nested = (Double, (ItemName : Int, String));

l’expression nested! retourne une valeur de type (Double, (Int, String)).

L’opérateur ! a une priorité plus faible que les deux opérateurs d’accès aux éléments, mais une priorité supérieure à celle de tout autre opérateur. Pour obtenir la liste complète des précédences, consultez Priorité et associativité.