9. Matrizes

  • Artigo

9.1 Introdução

O PowerShell suporta matrizes de uma ou mais dimensões com cada dimensão com zero ou mais elementos. Dentro de uma dimensão, os elementos são numerados na ordem número vez maior ascendente a partir de zero. Qualquer elemento individual pode ser acedido através do operador [] de suporte de matriz (§7.1.4). O número de dimensões numa matriz é chamado de sua posição.

Um elemento pode conter um valor de qualquer tipo, incluindo um tipo de matriz. Uma matriz com um ou mais elementos cujos valores são de qualquer tipo de matriz é chamada de matriz irregular. Uma matriz multidimensional tem múltiplas dimensões, neste caso, o número de elementos em cada linha de uma dimensão é o mesmo. Um elemento de uma matriz irregular pode conter uma matriz multidimensional, e vice-versa.

As matrizes multidimensionais são armazenadas em ordem de fila- grande. O número de elementos numa matriz é chamado de comprimento da matriz, que é fixado quando a matriz é criada. Como tal, os elementos de uma matriz 1 dimensional A tendo comprimento N podem ser acedidos (isto é, subscritos) utilizando as expressões A[0], A[1], ..., A[N-1]. Os elementos numa matriz 2 dimensional B com linhas M , com cada linha com colunas N , podem ser acedidos usando as expressões B[0,0], B[0,1], ..., B[0,N-1], B[1,0], B[1,1], ..., B[1,N-1], ..., B[M-1,0], B[M-1,1], ..., B[M-1,N-1]. E assim por diante para matrizes com três ou mais dimensões.

Por padrão, uma matriz é polimórfica; ou seja, os seus elementos não precisam todos do mesmo tipo. Por exemplo,

$items = 10,"blue",12.54e3,16.30D # 1-D array of length 4
$items[1] = -2.345
$items[2] = "green"

$a = New-Object 'object[,]' 2,2 # 2-D array of length 4
$a[0,0] = 10
$a[0,1] = $false
$a[1,0] = "red"
$a[1,1] = $null

Uma matriz 1-dimensional tem tipo type[], uma matriz 2-dimensional tem tipo type[,], uma matriz tridimensional tem tipo type[,,], e assim por diante, onde o tipo é objeto para uma matriz de tipo não constrangido, ou o tipo limitado para uma matriz restrita (§9.4).

Todos os tipos de matrizes são derivados do tipo Array (§4.3.2).

9.2 Criação de matriz

Uma matriz é criada através de uma expressão de criação de matriz, que tem as seguintes formas: operador de vírgula unary (§7.2.1) , expressão de matriz (§7.1.7), operador de vírgula binária (§7.3), operador de gama (§7.4) ou cmdlet new-object .

Aqui estão alguns exemplos de criação e utilização de matrizes:

$values = 10, 20, 30
for ($i = 0; $i -lt $values.Length; ++$i) {
    "`$values[$i] = $($values[$i])"
}

$x = , 10                         # x refers to an array of length 1
$x = @(10)                        # x refers to an array of length 1
$x = @()                          # x refers to an array of length 0

$a = New-Object 'object[,]' 2, 2  # create a 2x2 array of anything
$a[0, 0] = 10                     # set to an int value
$a[0, 1] = $false                 # set to a boolean value
$a[1, 0] = "red"                  # set to a string value
$a[1, 1] = 10.50D                 # set to a decimal value
foreach ($e in $a) {              # enumerate over the whole array
    $e
}

O seguinte está escrito ao oleoduto:

$values[0] = 10
$values[1] = 20
$values[2] = 30

10
False
red
10.50

O valor inicial padrão de qualquer elemento não explicitamente inicializado é o valor padrão para o tipo desse elemento (isto é, $falsezero, ou $null).

9.3 Concatenação de matriz

Matrizes de tipo e comprimento arbitrários podem ser concatenadas através dos + operadores e += operadores, ambos os quais resultam na criação de uma nova matriz unidimensional não condicionada. As matrizes existentes são inalteradas. Consulte §7.7.3 para obter mais informações e §9.4 para uma discussão de adicionar a um conjunto de tipos constrangidos.

9.4 Tipos de elementos de restrição

Uma matriz 1-dimensional pode ser criada de modo a que seja limitado por tipo-restrição prefixando a expressão de criação de matriz com um elenco tipo array. Por exemplo,

$a = [int[]](1,2,3,4)   # constrained to int
$a[1] = "abc"           # implementation-defined behavior
$a += 1.23              # new array is unconstrained

A sintaxe para a criação de uma matriz multidimensional requer a especificação de um tipo, e esse tipo torna-se o tipo de restrição para essa matriz. No entanto, ao especificar o tipo object[], não existe realmente qualquer restrição, uma vez que um valor de qualquer tipo pode ser atribuído a um elemento de uma matriz desse tipo.

Concatenar duas matrizes (§7.7.3) resulta sempre numa nova matriz que não é constrangida, mesmo que ambas as matrizes estejam limitadas pelo mesmo tipo. Por exemplo,

$a = [int[]](1,2,3)    # constrained to int
$b = [int[]](10,20)    # constrained to int
$c = $a + $b           # constraint not preserved
$c = [int[]]($a + $b)  # result explicitly constrained to int

9.5 Matrizes como tipos de referência

Como os tipos de matriz são tipos de referência, uma variável que designa uma matriz pode ser feita para se referir a qualquer matriz de qualquer grau, comprimento e tipo de elemento. Por exemplo,

$a = 10,20                     # $a refers to an array of length 2
$a = 10,20,30                  # $a refers to a different array, of length 3
$a = "red",10.6                # $a refers to a different array, of length 2
$a = New-Object 'int[,]' 2,3   # $a refers to an array of rank 2

A atribuição de uma matriz envolve uma cópia rasa; ou seja, a variável atribuída refere-se à mesma matriz, nenhuma cópia da matriz é feita. Por exemplo,

$a = 10,20,30
">$a<"
$b = $a         # make $b refer to the same array as $a
">$b<"

$a[0] = 6       # change value of [0] via $a
">$a<"
">$b<"          # change is reflected in $b

$b += 40        # make $b refer to a new array
$a[0] = 8       # change value of [0] via $a
">$a<"
">$b<"          # change is not reflected in $b

O seguinte está escrito ao oleoduto:

>10 20 30<
>10 20 30<
>6 20 30<
>6 20 30<
>8 20 30<
>6 20 30 40<

9.6 Matrizes como elementos de matriz

Qualquer elemento de uma matriz pode ser por si só uma matriz. Por exemplo,

$colors = "red", "blue", "green"
$list = $colors, (,7), (1.2, "yes") # parens in (,7) are redundant; they
                                    # are intended to aid readability
"`$list refers to an array of length $($list.Length)"
">$($list[1][0])<"
">$($list[2][1])<"

O seguinte está escrito ao oleoduto:

$list refers to an array of length 3
>7<
>yes<

$list[1] refere-se a uma matriz de 1 elemento, o inteiro 7, que é acedido via $list[1][0], como mostrado. Compare-o com o seguinte caso subtilmente diferente:

$list = $colors, 7, (1.2, "yes") # 7 has no prefix comma
">$($list[1])<"

Aqui, $list[1] refere-se a um scalar, o inteiro 7, que é acedido via $list[1].

Considere o seguinte exemplo,

$x = [string[]]("red","green")
$y = 12.5, $true, "blue"
$a = New-Object 'object[,]' 2,2
$a[0,0] = $x               # element is an array of 2 strings
$a[0,1] = 20               # element is an int
$a[1,0] = $y               # element is an array of 3 objects
$a[1,1] = [int[]](92,93)   # element is an array of 2 ints

9.7 Subscrição negativa

Isto é discutido em §7.1.4.1.

9.8 Verificação de limites

Isto é discutido em §7.1.4.1.

9.9 Fatias de matriz

Uma fatia de matriz é uma matriz de 1 dimensão não constrangida cujos elementos são cópias de zero ou mais elementos de uma coleção. Uma fatia de matriz é criada através do operador [] subscrito (§7.1.4.5).

9.10 Copiar uma matriz

Um conjunto contíguo de elementos pode ser copiado de uma matriz para outra utilizando o método [Array]::Copy. Por exemplo,

$a = [int[]](10,20,30)
$b = [int[]](0,1,2,3,4,5)
[Array]::Copy($a, $b, 2)        # $a[0]->$b[0],
$a[1]->$b[1]
[Array]::Copy($a, 1, $b, 3, 2)  # $a[1]->$b[3],
$a[2]->$b[4]

9.11 Enumerando sobre uma matriz

Embora seja possível circular através de uma matriz que aceda a cada um dos seus elementos através do operador subscript, podemos enumerar sobre os elementos dessa matriz usando a declaração de proa. Para uma matriz multidimensional, os elementos são processados em ordem de linha-grande. Por exemplo,

$a = 10, 53, 16, -43
foreach ($elem in $a) {
    # do something with element via $e
}

foreach ($elem in -5..5) {
    # do something with element via $e
}

$a = New-Object 'int[,]' 3, 2
foreach ($elem in $a) {
    # do something with element via $e
}

9.12 Achatamento de matriz multidimensional

Algumas operações numa matriz multidimensional (como a replicação (§7.6.3) e a concatenação (§7.7.3)) exigem que esse conjunto seja achatado; isto é, para ser transformado numa matriz unidimensional de tipo não constrangido. A matriz resultante assume todos os elementos em ordem de fila-grande.

Considere o exemplo seguinte:

$a = "red",$true
$b = (New-Object 'int[,]' 2,2)
$b[0,0] = 10
$b[0,1] = 20
$b[1,0] = 30
$b[1,1] = 40
$c = $a + $b

A matriz designada por $c contém os elementos "vermelho", $true10, 20, 30 e 40.