Acesso ao item

Q# oferece suporte ao acesso a itens de matriz e para tipos de struct. Em ambos os casos, o acesso é somente leitura; O valor não pode ser alterado sem criar uma nova instância usando uma expressão de cópia e atualização .

Acesso a itens de matriz e fatiamento de matriz

Dada uma expressão de matriz e uma expressão do tipo Int ou Range, uma nova expressão pode ser formada usando o operador de acesso de item de matriz que consiste em [ e ].

Se a expressão dentro dos colchetes for do tipo Int, a nova expressão conterá o item de matriz nesse índice. Por exemplo, se arr é do tipo Double[] e contém cinco ou mais itens, então arr[4] é uma expressão do tipo Double.

Se a expressão dentro dos colchetes for do tipo Range, a nova expressão conterá uma matriz de todos os itens indexados pelo Rangeespecificado. Se o Range estiver vazio, a matriz resultante estará vazia. Por exemplo

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]

Na última linha do exemplo, o valor inicial e final do intervalo foram omitidos por conveniência. Para obter mais informações, consulte Expressões contextuais.

Se a expressão de matriz não for um identificador simples, ela deverá ser colocada entre parênteses para extrair um item ou uma fatia. Por exemplo, se arr1 e arr2 forem matrizes de inteiros, um item da concatenação será expresso como (arr1 + arr2)[13]. Para obter mais informações, consulte Precedência e associatividade.

Todas as matrizes em Q# são baseadas em zero, ou seja, o primeiro elemento de uma matriz arr é sempre arr[0]. Uma exceção é lançada no tempo de execução se o índice ou um dos índices usados para fatiamento estiver fora dos limites da matriz, por exemplo, se for menor que zero ou maior ou igual ao comprimento da matriz.

Acesso a itens para tipos struct

Os itens contidos em um struct podem ser acessados de duas maneiras:

• Por referência, utilizando um ponto (.)
• Por desconstrução, utilizando o operador unwrap (!).

Por exemplo, dado o struct Complex

struct Complex {
    Real : Double,
    Imaginary : Double,
}

// create an instance of type Complex
let complex = Complex(1., 0.);

// item access via deconstruction
let (re, _) = complex!;

// item access via name reference
let im = complex.Imaginary;

O acesso via desconstrução faz uso do operador de desembrulhar (!). O operador unwrap retorna uma tupla de todos os itens contidos, onde a forma da tupla corresponde à definida na declaração, e uma única tupla de item é equivalente ao próprio item (consulte esta seção).

O operador ! tem menor de precedência de do que ambos os operadores de acesso ao item, mas maior precedência do que qualquer outro operador. Para obter uma lista completa de precedências, consulte Precedência e associatividade.

Para obter mais informações sobre sintaxe de desconstrução, consulte Declarações de variáveis e reatribuições.