Matrizes no Visual BasicArrays in Visual Basic

Uma matriz é um conjunto de valores, que são chamados elementos, que são logicamente relacionados uns aos outros.An array is a set of values, which are termed elements, that are logically related to each other. Por exemplo, uma matriz pode consistir no número de alunos em cada nível em uma escola primária; cada elemento da matriz é o número de alunos em uma única nota.For example, an array may consist of the number of students in each grade in a grammar school; each element of the array is the number of students in a single grade. Da mesma forma, uma matriz pode consistir em curso de um aluno para uma classe; cada elemento da matriz é uma única nota.Similarly, an array may consist of a student's grades for a class; each element of the array is a single grade.

É possíveis variáveis individuais para armazenar cada um dos nossos itens de dados.It is possible individual variables to store each of our data items. Por exemplo, se o nosso aplicativo analisa as notas de alunos, podemos usar uma variável separada para cada nota do aluno, tais como englishGrade1, englishGrade2, etc. Essa abordagem tem três principais limitações:For example, if our application analyzes student grades, we can use a separate variable for each student's grade, such as englishGrade1, englishGrade2, etc. This approach has three major limitations:

  • Precisamos saber em tempo de design exatamente quantas notas que temos de lidar com.We have to know at design time exactly how many grades we have to handle.
  • Tratamento de grandes números de notas rapidamente se torna complicado.Handling large numbers of grades quickly becomes unwieldy. Isso torna um aplicativo muito mais probabilidade de ter sérios erros.This in turn makes an application much more likely to have serious bugs.
  • É difícil de manter.It is difficult to maintain. Cada nível novo que adicionamos requer que o aplicativo ser modificado, recompilado e reimplantado.Each new grade that we add requires that the application be modified, recompiled, and redeployed.

Usando uma matriz, você pode consultar esses valores relacionados com o mesmo nome e usar um número que é chamado de um índice ou subscrito para identificar um elemento individual com base em sua posição na matriz.By using an array, you can refer to these related values by the same name, and use a number that’s called an index or subscript to identify an individual element based on its position in the array. Os índices de uma matriz variam de 0 a menos que o número total de elementos na matriz.The indexes of an array range from 0 to one less than the total number of elements in the array. Quando você usa a sintaxe do Visual Basic para definir o tamanho de uma matriz, você pode especificar o índice mais alto, não o número total de elementos na matriz.When you use Visual Basic syntax to define the size of an array, you specify its highest index, not the total number of elements in the array. Você pode trabalhar com a matriz como uma unidade e a capacidade de iterar seus elementos libera você da necessidade de saber exatamente quantos elementos ela contém no tempo de design.You can work with the array as a unit, and the ability to iterate its elements frees you from needing to know exactly how many elements it contains at design time.

Alguns exemplos rápidos antes da explicação:Some quick examples before explanation:

' Declare a single-dimension array of 5 numbers.
Dim numbers(4) As Integer

' Declare a single-dimension array and set its 4 values.
Dim numbers = New Integer() {1, 2, 4, 8}

' Change the size of an existing array to 16 elements and retain the current values.
ReDim Preserve numbers(15)

' Redefine the size of an existing array and reset the values.
ReDim numbers(15)

' Declare a 6 x 6 multidimensional array.
Dim matrix(5, 5) As Double

' Declare a 4 x 3 multidimensional array and set array element values.
Dim matrix = New Integer(3, 2) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

' Declare a jagged array
Dim sales()() As Double = New Double(11)() {}

Elementos da matriz em uma matriz simplesArray elements in a simple array

Vamos criar uma matriz chamada students para armazenar o número de alunos em cada nível em uma escola primária.Let's create an array named students to store the number of students in each grade in a grammar school. Os índices dos elementos variam de 0 a 6.The indexes of the elements range from 0 through 6. Usar essa matriz é mais simples do que declarar sete variáveis.Using this array is simpler than declaring seven variables.

A ilustração a seguir mostra o students matriz.The following illustration shows the students array. Para cada elemento da matriz:For each element of the array:

  • O índice do elemento representa a classificação (o índice 0 representa o jardim de infância).The index of the element represents the grade (index 0 represents kindergarten).

  • O valor contido no elemento representa o número de alunos nessa série.The value that’s contained in the element represents the number of students in that grade.

Diagrama que mostra uma matriz de números de alunos

O exemplo a seguir contém o código do Visual Basic que cria e usa a matriz:The following example contains the Visual Basic code that creates and uses the array:


Module SimpleArray
   Public Sub Main()
      ' Declare an array with 7 elements.
      Dim students(6) As Integer

      ' Assign values to each element.
      students(0) = 23
      students(1) = 19
      students(2) = 21
      students(3) = 17
      students(4) = 19
      students(5) = 20
      students(6) = 22
      
      ' Display the value of each element.
      For ctr As Integer = 0 To 6
         Dim grade As String = If(ctr = 0, "kindergarten", $"grade {ctr}")
         Console.WriteLine($"Students in {grade}: {students(ctr)}")
      Next
   End Sub
End Module
' The example displays the following output:
'     Students in kindergarten: 23
'     Students in grade 1: 19
'     Students in grade 2: 21
'     Students in grade 3: 17
'     Students in grade 4: 19
'     Students in grade 5: 20
'     Students in grade 6: 22

O exemplo faz três coisas:The example does three things:

  • Ele declara um students matriz com sete elementos.It declares a students array with seven elements. O número 6 na matriz de declaração indica o último índice na matriz; ele é um menor do que o número de elementos na matriz.The number 6 in the array declaration indicates the last index in the array; it is one less than the number of elements in the array.
  • Ele atribui valores a cada elemento da matriz.It assigns values to each element in the array. Elementos da matriz são acessados usando o nome da matriz e incluindo o índice do elemento individual entre parênteses.Array elements are accessed by using the array name and including the index of the individual element in parentheses.
  • Ele lista cada valor da matriz.It lists each value of the array. O exemplo usa uma For instrução para acessar cada elemento da matriz por seu número de índice.The example uses a For statement to access each element of the array by its index number.

O students matriz no exemplo anterior é uma matriz unidimensional, porque ele usa um índice.The students array in the preceding example is a one-dimensional array because it uses one index. Uma matriz que usa mais de um índice ou subscrito é chamada multidimensional.An array that uses more than one index or subscript is called multidimensional. Para obter mais informações, consulte o restante deste artigo e dimensões de matriz no Visual Basic.For more information, see the rest of this article and Array Dimensions in Visual Basic.

Criando uma matrizCreating an array

Você pode definir o tamanho de uma matriz de várias maneiras:You can define the size of an array in several ways:

  • Você pode especificar o tamanho quando a matriz é declarada:You can specify the size when the array is declared:

    ' Declare an array with 10 elements.
    Dim cargoWeights(9) As Double               
    ' Declare a 24 x 2 array.
    Dim hourlyTemperatures(23, 1) As Integer
    ' Declare a jagged array with 31 elements.
    Dim januaryInquiries(30)() As String
    
  • Você pode usar um New cláusula para fornecer o tamanho de uma matriz quando ele é criado:You can use a New clause to supply the size of an array when it’s created:

    ' Declare an array with 10 elements.
    Dim cargoWeights() As Double = New Double(9) {} 
    ' Declare a 24 x 2 array.
    Dim hourlyTemperatures(,) As Integer = New Integer(23, 1) {}
    ' Declare a jagged array with 31 elements. 
    Dim januaryInquiries()() As String = New String(30)() {}
    

Se você tiver uma matriz existente, você poderá redefinir o tamanho usando o ReDim instrução.If you have an existing array, you can redefine its size by using the ReDim statement. Você pode especificar que o ReDim instrução manter os valores que estão na matriz, ou você pode especificar que ele crie uma matriz vazia.You can specify that the ReDim statement keep the values that are in the array, or you can specify that it create an empty array. O exemplo a seguir mostra os diferentes usos da instrução ReDim para modificar o tamanho de uma matriz existente.The following example shows different uses of the ReDim statement to modify the size of an existing array.

' Assign a new array size and retain the current values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)

Para obter mais informações, consulte o instrução ReDim.For more information, see the ReDim Statement.

Armazenando valores em uma matrizStoring values in an array

Você pode acessar cada local em uma matriz usando um índice do tipo Integer.You can access each location in an array by using an index of type Integer. Você pode armazenar e recuperar valores em uma matriz, fazendo referência a cada local de matriz usando seu índice entre parênteses.You can store and retrieve values in an array by referencing each array location by using its index enclosed in parentheses. Índices de matrizes multidimensionais são separados por vírgulas (,).Indexes for multidimensional arrays are separated by commas (,). Você precisa de um índice para cada dimensão de matriz.You need one index for each array dimension.

O exemplo a seguir mostra algumas declarações que armazenam e recuperam valores em matrizes.The following example shows some statements that store and retrieve values in arrays.


Module Example
   Public Sub Main()
      ' Create a 10-element integer array.
      Dim numbers(9) As Integer
      Dim value As Integer = 2
        
      ' Write values to it.
      For ctr As Integer = 0 To 9
         numbers(ctr) = value
         value *= 2
      Next
        
      ' Read and sum the array values.  
      Dim sum As Integer
      For ctr As Integer = 0 To 9
         sum += numbers(ctr)
      Next
      Console.WriteLine($"The sum of the values is {sum:N0}")
    End Sub
End Module
' The example displays the following output:
'     The sum of the values is 2,046

Preenchendo uma matriz com literais de matrizPopulating an array with array literals

Usando um literal de matriz, você pode preencher uma matriz com um conjunto inicial de valores ao mesmo tempo que você criá-lo.By using an array literal, you can populate an array with an initial set of values at the same time that you create it. Um literal de matriz consiste em uma lista de valores separados por vírgulas que são colocados entre chaves ({}).An array literal consists of a list of comma-separated values that are enclosed in braces ({}).

Ao criar uma matriz usando um literal de matriz, você pode fornecer o tipo de matriz ou usar inferência de tipos para determinar o tipo de matriz.When you create an array by using an array literal, you can either supply the array type or use type inference to determine the array type. O exemplo a seguir mostra as duas opções.The following example shows both options.

' Array literals with explicit type definition.
Dim numbers = New Integer() {1, 2, 4, 8}
' Array literals with type inference.
Dim doubles = {1.5, 2, 9.9, 18}
' Array literals with explicit type definition.
Dim articles() As String = { "the", "a", "an" }

' Array literals with explicit widening type definition.
Dim values() As Double = { 1, 2, 3, 4, 5 }

Quando você usa a inferência de tipo, o tipo da matriz é determinado pelo tipo dominante na lista de valores literais.When you use type inference, the type of the array is determined by the dominant type in the list of literal values. O tipo dominante é o tipo ao qual todos os outros tipos na matriz podem ampliar.The dominant type is the type to which all other types in the array can widen. Se esse tipo exclusivo não puder ser determinado, o tipo dominante será o tipo exclusivo ao qual todos os outros tipos na matriz poderão restringir.If this unique type can’t be determined, the dominant type is the unique type to which all other types in the array can narrow. Se nenhum desses tipos exclusivos puder ser determinado, o tipo dominante será Object.If neither of these unique types can be determined, the dominant type is Object. Por exemplo, se a lista de valores que é fornecida para o literal de matriz contiver os valores do tipo Integer, Long e Double, a matriz resultante será do tipo Double.For example, if the list of values that’s supplied to the array literal contains values of type Integer, Long, and Double, the resulting array is of type Double. Porque Integer e Long são ampliados apenas para Double, Double é o tipo dominante.Because Integer and Long widen only to Double, Double is the dominant type. Para obter mais informações, consulte Ampliando e restringindo conversões.For more information, see Widening and Narrowing Conversions.

Observação

Você pode usar inferência de tipo apenas para matrizes que são definidas como variáveis locais em um membro de tipo.You can use type inference only for arrays that are defined as local variables in a type member. Se uma definição de tipo explícito estiver ausente, matrizes definidas com literais de matriz no nível de classe são do tipo Object[].If an explicit type definition is absent, arrays defined with array literals at the class level are of type Object[]. Para obter mais informações, consulte inferência de tipo Local.For more information, see Local type inference.

Observe que o exemplo anterior define values como uma matriz do tipo Double mesmo que os literais de matriz são do tipo Integer.Note that the previous example defines values as an array of type Double even though all the array literals are of type Integer. Você pode criar essa matriz porque os valores no literal de matriz podem ser ampliados com Double valores.You can create this array because the values in the array literal can widen to Double values.

Você também pode criar e preencher uma matriz multidimensional usando aninhados literais de matriz.You can also create and populate a multidimensional array by using nested array literals. Literais de matriz aninhados devem ter um número de dimensões que é consistente com a matriz resultante.Nested array literals must have a number of dimensions that’s consistent with the resulting array. O exemplo a seguir cria uma matriz bidimensional de inteiros usando literais de matriz aninhados.The following example creates a two-dimensional array of integers by using nested array literals.

' Create and populate a 2 x 2 array.
Dim grid1 = {{1, 2}, {3, 4}}
' Create and populate a 2 x 2 array with 3 elements.
Dim grid2(,) = {{1, 2}, {3, 4}, {5, 6}}

Ao usar literais de matriz aninhados para criar e preencher uma matriz, ocorrerá um erro se o número de elementos em literais de matriz aninhados não corresponde.When using nested array literals to create and populate an array, an error occurs if the number of elements in the nested array literals don't match. Também ocorrerá um erro se você declarar explicitamente a variável de matriz para ter um número diferente de dimensões que os literais de matriz.An error also occurs if you explicitly declare the array variable to have a different number of dimensions than the array literals.

Assim como para matrizes unidimensionais, você pode contar com inferência de tipo ao criar uma matriz multidimensional usando literais de matriz aninhados.Just as you can for one-dimensional arrays, you can rely on type inference when creating a multidimensional array with nested array literals. O tipo inferido é o tipo dominante para todos os valores em todos os literais de matriz para o nível de aninhamento de todos os.The inferred type is the dominant type for all the values in all the array literals for all nesting level. O exemplo a seguir cria uma matriz bidimensional de tipo Double[,] dos valores que são do tipo Integer e Double.The following example creates a two-dimensional array of type Double[,] from values that are of type Integer and Double.

Dim arr = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}

Para obter exemplos adicionais, consulte como: Inicializar uma variável de matriz no Visual Basic.For additional examples, see How to: Initialize an Array Variable in Visual Basic.

Iterando por uma matrizIterating through an array

Quando você itera através de uma matriz, pode acessar cada elemento na matriz do índice menor para o mais alto ou da maior para o mais baixo.When you iterate through an array, you access each element in the array from the lowest index to the highest or from the highest to the lowest. Em geral, use o para... Próxima instrução ou o para cada um... Próxima instrução para iterar por meio dos elementos de uma matriz.Typically, use either the For...Next Statement or the For Each...Next Statement to iterate through the elements of an array. Quando você não souber os limites superiores da matriz, você pode chamar o Array.GetUpperBound método para obter o valor mais alto do índice.When you don't know the upper bounds of the array, you can call the Array.GetUpperBound method to get the highest value of the index. Embora o menor valor de índice é quase sempre é 0, você pode chamar o Array.GetLowerBound método para obter o valor mais baixo do índice.Although lowest index value is almost always 0, you can call the Array.GetLowerBound method to get the lowest value of the index.

O exemplo a seguir itera por meio de uma matriz unidimensional usando o For...Next instrução.The following example iterates through a one-dimensional array by using the For...Next statement.


Module IterateArray
   Public Sub Main()
      Dim numbers = {10, 20, 30}

      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine(numbers(index))
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30

O exemplo a seguir itera por meio de uma matriz multidimensional usando um For...Next instrução.The following example iterates through a multidimensional array by using a For...Next statement. O método GetUpperBound tem um parâmetro que especifica a dimensão.The GetUpperBound method has a parameter that specifies the dimension. GetUpperBound(0) Retorna o maior índice da primeira dimensão, e GetUpperBound(1) retorna o índice mais alto da segunda dimensão.GetUpperBound(0) returns the highest index of the first dimension, and GetUpperBound(1) returns the highest index of the second dimension.


Module IterateArray
   Public Sub Main()
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
' Output 
'  1 2 
'  3 4 
'  5 6

O exemplo a seguir usa um para cada um... Próxima instruçãopara iterar por meio de uma matriz unidimensional e uma matriz bidimensional.The following example uses a For Each...Next Statementto iterate through a one-dimensional array and a two-dimensional array.


Module IterateWithForEach
   Public Sub Main()
      ' Declare and iterate through a one-dimensional array.
      Dim numbers1 = {10, 20, 30}
      
      For Each number In numbers1
         Console.WriteLine(number)
      Next
      Console.WriteLine()
      
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For Each number In numbers
         Console.WriteLine(number)
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30
'
'  1
'  2
'  3
'  4
'  5
'  6

Tamanho da matrizArray size

O tamanho de uma matriz é o produto dos comprimentos de todas as suas dimensões.The size of an array is the product of the lengths of all its dimensions. Ele representa o número total de elementos contidos no momento na matriz.It represents the total number of elements currently contained in the array. Por exemplo, o exemplo a seguir declara uma matriz dimensional de 2 com quatro elementos em cada dimensão.For example, the following example declares a 2-dimensional array with four elements in each dimension. Como mostra a saída do exemplo, o tamanho da matriz é 16 (ou (3 + 1) * (3 + 1).As the output from the example shows, the array's size is 16 (or (3 + 1) * (3 + 1).


Module Example
   Public Sub Main()
      Dim arr(3, 3) As Integer
      Console.WriteLine(arr.Length)     
   End Sub
End Module
' The example displays the following output:
'     16

Observação

Esta discussão sobre o tamanho da matriz não se aplicam a matrizes denteadas.This discussion of array size does not apply to jagged arrays. Para obter informações sobre matrizes denteadas e determinar o tamanho de uma matriz denteada, consulte o matrizes denteadas seção.For information on jagged arrays and determining the size of a jagged array, see the Jagged arrays section.

Você pode encontrar o tamanho de uma matriz usando a propriedade Array.Length.You can find the size of an array by using the Array.Length property. Você pode encontrar o tamanho de cada dimensão de uma matriz multidimensional usando o Array.GetLength método.You can find the length of each dimension of a multidimensional array by using the Array.GetLength method.

Você pode redimensionar uma variável de matriz atribuindo um novo objeto de matriz a ela ou usando o ReDim instrução instrução.You can resize an array variable by assigning a new array object to it or by using the ReDim Statement statement. O exemplo a seguir usa o ReDim instrução para alterar uma matriz de elementos de 100 para uma matriz de elementos de 51.The following example uses the ReDim statement to change a 100-element array to a 51-element array.


Module Example
   Public Sub Main()
      Dim arr(99) As Integer
      Console.WriteLine(arr.Length)
      
      Redim arr(50)
      Console.WriteLine(arr.Length)
   End Sub
End Module
' The example displays the following output:
'     100
'     51

 

Há várias coisas para ter em mente ao lidar com o tamanho de uma matriz.There are several things to keep in mind when dealing with the size of an array.

Tamanho da dimensãoDimension Length O índice de cada dimensão é baseado em 0, o que significa que ele varia de 0 para o limite superior.The index of each dimension is 0-based, which means it ranges from 0 to its upper bound. Portanto, o comprimento de uma determinada dimensão é maior do que o limite superior declarado da dimensão.Therefore, the length of a given dimension is one greater than the declared upper bound of that dimension.
Limites de comprimentoLength Limits O comprimento de cada dimensão de uma matriz é limitado ao valor máximo do Integer tipo de dados, que é Int32.MaxValue ou (2 ^ 31) - 1.The length of every dimension of an array is limited to the maximum value of the Integer data type, which is Int32.MaxValue or (2 ^ 31) - 1. No entanto, o tamanho total de uma matriz também é limitado pela memória disponível no sistema.However, the total size of an array is also limited by the memory available on your system. Se você tentar inicializar uma matriz que excede a quantidade de memória disponível, o tempo de execução gera uma OutOfMemoryException.If you attempt to initialize an array that exceeds the amount of available memory, the runtime throws an OutOfMemoryException.
Tamanho e tamanho do elementoSize and Element Size Um tamanho de matriz é independente do tipo de dados de seus elementos.An array's size is independent of the data type of its elements. O tamanho sempre representa o número total de elementos, não o número de bytes que eles consomem na memória.The size always represents the total number of elements, not the number of bytes that they consume in memory.
Consumo de memóriaMemory Consumption Não é seguro fazer suposições sobre como uma matriz é armazenada na memória.It is not safe to make any assumptions regarding how an array is stored in memory. O armazenamento varia em plataformas de larguras de dados diferentes, então a mesma matriz pode consumir mais memória em um sistema de 64 bits que em um sistema de 32 bits.Storage varies on platforms of different data widths, so the same array can consume more memory on a 64-bit system than on a 32-bit system. Dependendo da configuração do sistema ao inicializar uma matriz, o CLR (Common Language Runtime) pode atribuir armazenamento para elementos do pacote o mais próximo possível, ou alinhá-los em limites naturais de hardware.Depending on system configuration when you initialize an array, the common language runtime (CLR) can assign storage either to pack elements as close together as possible, or to align them all on natural hardware boundaries. Além disso, uma matriz de armazenamento requer sobrecarga de armazenamento para suas informações de controle, e essa sobrecarga aumenta com cada nova dimensão.Also, an array requires a storage overhead for its control information, and this overhead increases with each added dimension.

O tipo de matrizThe array type

Cada matriz tem um tipo de dados, que é diferente do tipo de dados de seus elementos.Every array has a data type, which differs from the data type of its elements. Não há nenhum tipo de dados único para todas as matrizes.There is no single data type for all arrays. Em vez disso, o tipo de dados de uma matriz é determinado pelo número de dimensões, ou classificação, da matriz e o tipo de dados dos elementos na matriz.Instead, the data type of an array is determined by the number of dimensions, or rank, of the array, and the data type of the elements in the array. Duas variáveis de matriz são dos mesmos dados somente quando elas têm a mesma classificação de tipo e seus elementos têm os mesmos tipo de dados.Two array variables are of the same data type only when they have the same rank and their elements have the same data type. Os comprimentos das dimensões de uma matriz não influenciam o tipo de dados de matriz.The lengths of the dimensions of an array do not influence the array data type.

Cada matriz herda da classe System.Array e você pode declarar uma variável para ser do tipo Array, mas não pode criar uma matriz do tipo Array.Every array inherits from the System.Array class, and you can declare a variable to be of type Array, but you cannot create an array of type Array. Por exemplo, embora o código a seguir declara a arr variável seja do tipo Array e chama o Array.CreateInstance prova de método para criar uma instância de matriz, o tipo de matriz a ser Object [].For example, although the following code declares the arr variable to be of type Array and calls the Array.CreateInstance method to instantiate the array, the array's type proves to be Object[].


Module Example
   Public Sub Main()
      Dim arr As Array = Array.CreateInstance(GetType(Object), 19)
      Console.WriteLine(arr.Length)
      Console.WriteLine(arr.GetType().Name)
   End Sub
End Module
' The example displays the following output:
'     19
'     Object[]

Além disso, a instrução ReDim não pode operar em uma variável declarada como tipo Array.Also, the ReDim Statement cannot operate on a variable declared as type Array. Por esses motivos e à segurança de tipo, é aconselhável declarar cada matriz como um tipo específico.For these reasons, and for type safety, it is advisable to declare every array as a specific type.

Você pode descobrir o tipo de dados de uma matriz ou seus elementos de várias maneiras.You can find out the data type of either an array or its elements in several ways.

  • Você pode chamar o GetType método na variável para obter um Type objeto que representa o tipo de tempo de execução da variável.You can call the GetType method on the variable to get a Type object that represents the run-time type of the variable. O objeto Type mantém informações abrangentes em suas propriedades e métodos.The Type object holds extensive information in its properties and methods.
  • Você pode passar a variável para o TypeName função para obter um String com o nome do tipo de tempo de execução.You can pass the variable to the TypeName function to get a String with the name of run-time type.

O exemplo a seguir chama a ambos os GetType método e o TypeName função para determinar o tipo de uma matriz.The following example calls the both the GetType method and the TypeName function to determine the type of an array. O tipo de matriz é Byte(,).The array type is Byte(,). Observe que o Type.BaseType propriedade também indica que o tipo base da matriz de bytes é a Array classe.Note that the Type.BaseType property also indicates that the base type of the byte array is the Array class.


Module Example
   Public Sub Main()
      Dim bytes(9,9) As Byte
      Console.WriteLine($"Type of {nameof(bytes)} array: {bytes.GetType().Name}")
      Console.WriteLine($"Base class of {nameof(bytes)}: {bytes.GetType().BaseType.Name}")
      Console.WriteLine()
      Console.WriteLine($"Type of {nameof(bytes)} array: {TypeName(bytes)}")
   End Sub
End Module
' The example displays the following output:
' Type of bytes array: Byte[,]
' Base class of bytes: Array
' 
' Type of bytes array: Byte(,)


Matrizes como valores de retorno e parâmetrosArrays as return values and parameters

Para retornar uma matriz de um procedimento Function, especifique o tipo de dados de matriz e o número de dimensões como o tipo de retorno de instrução de função.To return an array from a Function procedure, specify the array data type and the number of dimensions as the return type of the Function Statement. Dentro da função, declare uma variável da matriz local com o mesmo tipo de dados e número de dimensões.Within the function, declare a local array variable with same data type and number of dimensions. Na instrução Return, inclua a variável da matriz local sem parênteses.In the Return Statement, include the local array variable without parentheses.

Para especificar uma matriz como um parâmetro para um procedimento Sub ou Function, defina o parâmetro como uma matriz com um tipo de dados especificado e o número de dimensões.To specify an array as a parameter to a Sub or Function procedure, define the parameter as an array with a specified data type and number of dimensions. A chamada ao procedimento, pode passe uma variável de matriz com o mesmo tipo de dados e o número de dimensões.In the call to the procedure, pass an array variable with the same data type and number of dimensions.

No exemplo a seguir, o GetNumbers função retorna um Integer(), uma matriz unidimensional do tipo Integer.In the following example, the GetNumbers function returns an Integer(), a one-dimensional array of type Integer. O procedimento ShowNumbers aceita um argumento Integer().The ShowNumbers procedure accepts an Integer() argument.


Module ReturnValuesAndParams
   Public Sub Main()
      Dim numbers As Integer() = GetNumbers()
      ShowNumbers(numbers)
   End Sub

   Private Function GetNumbers() As Integer()
      Dim numbers As Integer() = {10, 20, 30}
      Return numbers
   End Function

   Private Sub ShowNumbers(numbers As Integer())
      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine($"{numbers(index)} ")
      Next
   End Sub
End Module
' The example displays the following output:
'   10
'   20
'   30
    

No exemplo a seguir, o GetNumbersMultiDim função retorna um Integer(,), uma matriz bidimensional de tipo Integer.In the following example, the GetNumbersMultiDim function returns an Integer(,), a two-dimensional array of type Integer. O procedimento ShowNumbersMultiDim aceita um argumento Integer(,).The ShowNumbersMultiDim procedure accepts an Integer(,) argument.


Module Example
   Public Sub Main()
      Dim numbers As Integer(,) = GetNumbersMultidim()
      ShowNumbersMultidim(numbers)
   End Sub

   Private Function GetNumbersMultidim() As Integer(,)
      Dim numbers As Integer(,) = {{1, 2}, {3, 4}, {5, 6}}
      Return numbers
   End Function

   Private Sub ShowNumbersMultidim(numbers As Integer(,))
      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'     1 2
'     3 4
'     5 6

Matrizes denteadasJagged arrays

Às vezes, a estrutura de dados em seu aplicativo é bidimensional, mas não retangular.Sometimes the data structure in your application is two-dimensional but not rectangular. Por exemplo, você pode usar uma matriz para armazenar dados sobre a temperatura máxima de cada dia do mês.For example, you might use an array to store data about the high temperature of each day of the month. A primeira dimensão da matriz representa o mês, mas a segunda dimensão representa o número de dias e o número de dias em um mês não é uniforme.The first dimension of the array represents the month, but the second dimension represents the number of days, and the number of days in a month is not uniform. Um matriz denteada, que também é chamado um matriz de matrizes, foi projetado para esses cenários.A jagged array, which is also called an array of arrays, is designed for such scenarios. Uma matriz denteada é uma matriz cujos elementos também são matrizes.A jagged array is an array whose elements are also arrays. Uma matriz denteada e cada elemento em uma matriz denteada podem ter uma ou mais dimensões.A jagged array and each element in a jagged array can have one or more dimensions.

O exemplo a seguir usa uma matriz de meses, cada elemento é uma matriz de dias.The following example uses an array of months, each element of which is an array of days. O exemplo usa uma matriz denteada como diferentes meses têm diferentes números de dias.The example uses a jagged array because different months have different numbers of days. O exemplo mostra como criar uma matriz denteada, atribuir valores a ele e recuperar e exibir seus valores.The example shows how to create a jagged array, assign values to it, and retrieve and display its values.

Imports System.Globalization

Module JaggedArray
   Public Sub Main()
      ' Declare the jagged array of 12 elements. Each element is an array of Double.
      Dim sales(11)() As Double
      ' Set each element of the sales array to a Double array of the appropriate size.
      For month As Integer = 0 To 11
         ' The number of days in the month determines the appropriate size.
         Dim daysInMonth As Integer =
            DateTime.DaysInMonth(Year(Now), month + 1)
         sales(month) = New Double(daysInMonth - 1) {}
      Next 

      ' Store values in each element.
      For month As Integer = 0 To 11
         For dayOfMonth = 0 To sales(month).GetUpperBound(0)
            sales(month)(dayOfMonth) = (month * 100) + dayOfMonth
         Next
      Next

      ' Retrieve and display the array values.
      Dim monthNames = DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames
      ' Display the month names.
      Console.Write("    ")
      For ctr = 0 To sales.GetUpperBound(0)
         Console.Write($" {monthNames(ctr)}   ")
      Next   
      Console.WriteLine()
      ' Display data for each day in each month.
      For dayInMonth = 0 To 30
         Console.Write($"{dayInMonth + 1,2}.  ")
         For monthNumber = 0 To sales.GetUpperBound(0)
            If dayInMonth > sales(monthNumber).GetUpperBound(0) Then 
               Console.Write("       ")
            Else
               Console.Write($"{sales(monthNumber)(dayInMonth),-5}  ")
            End If
         Next   
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'      Jan    Feb    Mar    Apr    May    Jun    Jul    Aug    Sep    Oct    Nov    Dec
'  1.  0      100    200    300    400    500    600    700    800    900    1000   1100
'  2.  1      101    201    301    401    501    601    701    801    901    1001   1101
'  3.  2      102    202    302    402    502    602    702    802    902    1002   1102
'  4.  3      103    203    303    403    503    603    703    803    903    1003   1103
'  5.  4      104    204    304    404    504    604    704    804    904    1004   1104
'  6.  5      105    205    305    405    505    605    705    805    905    1005   1105
'  7.  6      106    206    306    406    506    606    706    806    906    1006   1106
'  8.  7      107    207    307    407    507    607    707    807    907    1007   1107
'  9.  8      108    208    308    408    508    608    708    808    908    1008   1108
' 10.  9      109    209    309    409    509    609    709    809    909    1009   1109
' 11.  10     110    210    310    410    510    610    710    810    910    1010   1110
' 12.  11     111    211    311    411    511    611    711    811    911    1011   1111
' 13.  12     112    212    312    412    512    612    712    812    912    1012   1112
' 14.  13     113    213    313    413    513    613    713    813    913    1013   1113
' 15.  14     114    214    314    414    514    614    714    814    914    1014   1114
' 16.  15     115    215    315    415    515    615    715    815    915    1015   1115
' 17.  16     116    216    316    416    516    616    716    816    916    1016   1116
' 18.  17     117    217    317    417    517    617    717    817    917    1017   1117
' 19.  18     118    218    318    418    518    618    718    818    918    1018   1118
' 20.  19     119    219    319    419    519    619    719    819    919    1019   1119
' 21.  20     120    220    320    420    520    620    720    820    920    1020   1120
' 22.  21     121    221    321    421    521    621    721    821    921    1021   1121
' 23.  22     122    222    322    422    522    622    722    822    922    1022   1122
' 24.  23     123    223    323    423    523    623    723    823    923    1023   1123
' 25.  24     124    224    324    424    524    624    724    824    924    1024   1124
' 26.  25     125    225    325    425    525    625    725    825    925    1025   1125
' 27.  26     126    226    326    426    526    626    726    826    926    1026   1126
' 28.  27     127    227    327    427    527    627    727    827    927    1027   1127
' 29.  28            228    328    428    528    628    728    828    928    1028   1128
' 30.  29            229    329    429    529    629    729    829    929    1029   1129
' 31.  30            230           430           630    730           930           1130

O exemplo anterior atribui valores para a matriz denteada em uma base de elemento por elemento usando um For...Next loop.The previous example assigns values to the jagged array on an element-by-element basis by using a For...Next loop. Você também pode atribuir valores aos elementos de uma matriz denteada usando literais de matriz aninhados.You can also assign values to the elements of a jagged array by using nested array literals. No entanto, a tentativa de usar aninhados literais de matriz (por exemplo, Dim valuesjagged = {{1, 2}, {2, 3, 4}}) gera o erro do compilador BC30568.However, the attempt to use nested array literals (for example, Dim valuesjagged = {{1, 2}, {2, 3, 4}}) generates compiler error BC30568. Para corrigir o erro, coloque os literais de matriz interna entre parênteses.To correct the error, enclose the inner array literals in parentheses. Os parênteses forçam a expressão literal de matriz a ser avaliada e os valores resultantes são usados com a matriz externa literal, como mostra o exemplo a seguir.The parentheses force the array literal expression to be evaluated, and the resulting values are used with the outer array literal, as the following example shows.


Module Example
   Public Sub Main()
      Dim values1d = { 1, 2, 3 }
      Dim values2d = {{1, 2}, {2, 3}, {3, 4}}
      Dim valuesjagged = {({1, 2}), ({2, 3, 4})}
   End Sub
End Module

Uma matriz denteada é uma matriz unidimensional cujos elementos contêm matrizes.A jagged array is a one-dimensional array whose elements contain arrays. Portanto, o Array.Length propriedade e o Array.GetLength(0) método retorna o número de elementos na matriz unidimensional, e Array.GetLength(1) lança um IndexOutOfRangeException como uma matriz denteada não é multidimensional.Therefore, the Array.Length property and the Array.GetLength(0) method return the number of elements in the one-dimensional array, and Array.GetLength(1) throws an IndexOutOfRangeException because a jagged array is not multidimensional. Determinar o número de elementos em cada submatriz ao recuperar o valor de cada submatriz Array.Length propriedade.You determine the number of elements in each subarray by retrieving the value of each subarray's Array.Length property. O exemplo a seguir ilustra como determinar o número de elementos em uma matriz denteada.The following example illustrates how to determine the number of elements in a jagged array.


Module Example
   Public Sub Main()
      Dim jagged = { ({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9, 10}) }
      Console.WriteLine($"The value of jagged.Length: {jagged.Length}.")
      Dim total = jagged.Length
      For ctr As Integer = 0 To jagged.GetUpperBound(0)
         Console.WriteLine($"Element {ctr + 1} has {jagged(ctr).Length} elements.") 
         total += jagged(ctr).Length 
      Next
      Console.WriteLine($"The total number of elements in the jagged array: {total}")
   End Sub
End Module
' The example displays the following output:
'     The value of jagged.Length: 4.
'     Element 1 has 2 elements.
'     Element 2 has 3 elements.
'     Element 3 has 2 elements.
'     Element 4 has 4 elements.
'     The total number of elements in the jagged array: 15

Matrizes de comprimento zeroZero-length arrays

Visual Basic faz distinção entre uma matriz não inicializada (uma matriz cujo valor é Nothing) e uma matriz de comprimento zero ou uma matriz vazia (uma matriz que não tem nenhum elemento.) Uma matriz não inicializada é aquele que não foi dimensionada ou tinham todos os valores atribuídos a ele.Visual Basic differentiates between a uninitialized array (an array whose value is Nothing) and a zero-length array or empty array (an array that has no elements.) An uninitialized array is one that has not been dimensioned or had any values assigned to it. Por exemplo:For example:

Dim arr() As String

Uma matriz de comprimento zero é declarada com uma dimensão de -1.A zero-length array is declared with a dimension of -1. Por exemplo:For example:

Dim arrZ(-1) As String

Talvez seja necessário criar uma matriz de tamanho igual a zero nas seguintes circunstâncias:You might need to create a zero-length array under the following circumstances:

  • Sem arriscar uma NullReferenceException exceção, seu código precisa acessar membros do Array classe, como Length ou Rank, ou chamar uma função do Visual Basic, como UBound.Without risking a NullReferenceException exception, your code must access members of the Array class, such as Length or Rank, or call a Visual Basic function such as UBound.

  • Para manter seu código simples por não ter que verificar Nothing como um caso especial.You want to keep your code simple by not having to check for Nothing as a special case.

  • Seu código interage com uma API (interface de programação do aplicativo) que exige que você passe uma matriz de tamanho igual a zero para um ou mais procedimentos ou retorna uma matriz de tamanho igual a zero de um ou mais procedimentos.Your code interacts with an application programming interface (API) that either requires you to pass a zero-length array to one or more procedures or returns a zero-length array from one or more procedures.

Divisão de uma matrizSplitting an array

Em alguns casos, você precisa dividir uma única matriz em várias matrizes.In some cases, you may need to split a single array into multiple arrays. Isso envolve identificar o ponto ou pontos em que a matriz deve ser dividida e spitting, em seguida, a matriz em duas ou mais matrizes separadas.This involves identifying the point or points at which the array is to be split, and then spitting the array into two or more separate arrays.

Observação

Esta seção discute a dividir uma única cadeia de caracteres em uma matriz de cadeia de caracteres com base em um delimitador.This section does not discuss splitting a single string into a string array based on some delimiter. Para obter informações sobre como dividir uma cadeia de caracteres, consulte o String.Split método.For information on splitting a string, see the String.Split method.

Os critérios mais comuns para a divisão de uma matriz são:The most common criteria for splitting an array are:

  • O número de elementos na matriz.The number of elements in the array. Por exemplo, você talvez queira dividir uma matriz de mais de um número especificado de elementos em um número de aproximadamente partes iguais.For example, you might want to split an array of more than a specified number of elements into a number of approximately equal parts. Para essa finalidade, você pode usar o valor retornado por qualquer um de Array.Length ou Array.GetLength método.For this purpose, you can use the value returned by either the Array.Length or Array.GetLength method.

  • O valor de um elemento, que serve como um delimitador que indica onde a matriz deve ser dividida.The value of an element, which serves as a delimiter that indicates where the array should be split. Você pode procurar por um valor específico chamando o Array.FindIndex e Array.FindLastIndex métodos.You can search for a specific value by calling the Array.FindIndex and Array.FindLastIndex methods.

Depois de determinar o índice ou índices em que a matriz deve ser dividida, em seguida, você pode criar as matrizes individuais chamando o Array.Copy método.Once you've determined the index or indexes at which the array should be split, you can then create the individual arrays by calling the Array.Copy method.

O exemplo a seguir divide uma matriz em duas matrizes de aproximadamente igual tamanho.The following example splits an array into two arrays of approximately equal size. (Se o número total de elementos da matriz for ímpar, a primeira matriz tem um elemento a mais que o segundo).(If the total number of array elements is odd, the first array has one more element than the second.)


Module Example
   Public Sub Main()
      ' Create an array of 100 elements.
      Dim arr(99) As Integer
      ' Populate the array.
      Dim rnd As new Random()
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = rnd.Next()
      Next
      
      ' Determine how many elements should be in each array.
      Dim divisor = 2
      Dim remainder As Integer
      Dim boundary = Math.DivRem(arr.GetLength(0), divisor, remainder)
            
      ' Copy the array.
      Dim arr1(boundary - 1 + remainder), arr2(boundary - 1) as Integer
      Array.Copy(arr, 0, arr1, 0, boundary + remainder)
      Array.Copy(arr, boundary + remainder, arr2, 0, arr.Length - boundary) 
   End Sub
End Module

O exemplo a seguir divide uma matriz de cadeia de caracteres em duas matrizes com base na presença de um elemento cujo valor é "zzz", que serve como o delimitador de matriz.The following example splits a string array into two arrays based on the presence of an element whose value is "zzz", which serves as the array delimiter. As novas matrizes não incluem o elemento que contém o delimitador.The new arrays do not include the element that contains the delimiter.


Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      ' Create an array of 100 elements.
      Dim arr(99) As String
      ' Populate each element with an arbitrary ASCII character.
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = ChrW(Rnd.Next(&h21, &h7F))
      Next
      ' Get a random number that will represent the point to insert the delimiter.
      arr(rnd.Next(0, arr.GetUpperBound(0))) = "zzz"

      ' Find the delimiter.
      Dim location = Array.FindIndex(arr, Function(x) x = "zzz")

      ' Create the arrays.
      Dim arr1(location - 1) As String
      Dim arr2(arr.GetUpperBound(0) - location - 1) As String
      
      ' Populate the two arrays.
      Array.Copy(arr, 0, arr1, 0, location)
      Array.Copy(arr, location + 1, arr2, 0, arr.GetUpperBound(0) - location)
   End Sub
End Module

Ingressar em matrizesJoining arrays

Você também pode combinar várias matrizes em uma única matriz maior.You can also combine a number of arrays into a single larger array. Para fazer isso, você também usar o Array.Copy método.To do this, you also use the Array.Copy method.

Observação

Esta seção discute a ingressar em uma matriz de cadeia de caracteres em uma única cadeia de caracteres.This section does not discuss joining a string array into a single string. Para obter informações sobre como ingressar em uma matriz de cadeia de caracteres, consulte o String.Join método.For information on joining a string array, see the String.Join method.

Antes de copiar os elementos de cada matriz para a nova matriz, primeiro você deve assegurar que você inicializou a matriz para que ele seja grande o suficiente para acomodar a nova matriz.Before copying the elements of each array into the new array, you must first ensure that you have initialized the array so that it is large enough to accommodate the new array. Você pode fazer isso de duas maneiras:You can do this in one of two ways:

  • Use o ReDim Preserve instrução expandir dinamicamente a matriz antes de adicionar novos elementos a ele.Use the ReDim Preserve statement to dynamically expand the array before adding new elements to it. Essa é a técnica mais fácil, mas isso pode resultar em degradação de desempenho e consumo excessivo de memória quando você estiver copiando matrizes grandes.This is the easiest technique, but it can result in performance degradation and excessive memory consumption when you are copying large arrays.
  • Calcular o número total de elementos necessários para a nova matriz grande, em seguida, adicionar os elementos de cada matriz de origem a ele.Calculate the total number of elements needed for the new large array, then add the elements of each source array to it.

O exemplo a seguir usa a segunda abordagem para adicionar quatro matrizes com dez elementos a uma única matriz.The following example uses the second approach to add four arrays with ten elements each to a single array.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())
       ' Compute the number of elements in all arrays.
       Dim elements = 0
       For Each task In tasks
          elements += task.Result.Length
       Next
       Dim newArray(elements - 1) As Integer
       Dim index = 0
       For Each task In tasks
          Dim n = task.Result.Length
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Como nesse caso, as matrizes de origem são todos pequenas, podemos também dinamicamente pode expandir a matriz como podemos adicionar os elementos de cada nova matriz a ela.Since in this case the source arrays are all small, we can also dynamically expand the array as we add the elements of each new array to it. O exemplo a seguir faz isso.The following example does that.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())

       ' Dimension the target array and copy each element of each source array to it.
       Dim newArray() As Integer = {}
       ' Define the next position to copy to in newArray.
       Dim index = 0
       For Each task In tasks
          Dim n = Task.Result.Length
          ReDim Preserve newArray(newArray.GetUpperBound(0) + n)
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Coleções como uma alternativa para matrizesCollections as an alternative to arrays

As matrizes são mais úteis para criar e trabalhar com um número fixo de objetos fortemente tipados.Arrays are most useful for creating and working with a fixed number of strongly typed objects. As coleções fornecem uma maneira mais flexível de trabalhar com grupos de objetos.Collections provide a more flexible way to work with groups of objects. Ao contrário das matrizes, que exige que você altere explicitamente o tamanho de uma matriz com o ReDim instrução, coleções de crescer e reduzir dinamicamente conforme as necessidades de uma alteração no aplicativo.Unlike arrays, which require that you explicitly change the size of an array with the ReDim Statement, collections grow and shrink dynamically as the needs of an application change.

Quando você usa ReDim para redimensionar uma matriz, o Visual Basic cria uma nova matriz e libera o anterior.When you use ReDim to redimension an array, Visual Basic creates a new array and releases the previous one. Isso leva o tempo da execução.This takes execution time. Portanto, se o número de itens que você está trabalhando com forem alterados com frequência, ou você não pode prever o número máximo de itens que você precisa, você geralmente obterá melhor desempenho usando uma coleção.Therefore, if the number of items you are working with changes frequently, or you cannot predict the maximum number of items you need, you'll usually obtain better performance by using a collection.

Para algumas coleções, você pode atribuir uma chave para qualquer objeto que colocar na coleção para que você possa recuperar rapidamente o objeto, usando a chave.For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

Se a coleção contiver elementos de apenas um tipo de dados, você poderá usar uma das classes no namespace System.Collections.Generic.If your collection contains elements of only one data type, you can use one of the classes in the System.Collections.Generic namespace. Uma coleção genérica impõe segurança de tipos para que nenhum outro tipo de dados possa ser adicionado a ela.A generic collection enforces type safety so that no other data type can be added to it.

Para obter mais informações sobre coleções, consulte Coleções.For more information about collections, see Collections.

TermoTerm DefiniçãoDefinition
Dimensões de matriz no Visual BasicArray Dimensions in Visual Basic Explica a classificação e as dimensões em matrizes.Explains rank and dimensions in arrays.
Como: Inicializar uma variável de matriz no Visual BasicHow to: Initialize an Array Variable in Visual Basic Descreve como preencher matrizes com valores iniciais.Describes how to populate arrays with initial values.
Como: Classificar uma matriz no Visual BasicHow to: Sort An Array in Visual Basic Mostra como classificar os elementos de uma matriz em ordem alfabética.Shows how to sort the elements of an array alphabetically.
Como: Atribuir uma matriz a outra matrizHow to: Assign One Array to Another Array Descreve as regras e as etapas para atribuir uma matriz a outra variável de matriz.Describes the rules and steps for assigning an array to another array variable.
Solução de problemas de matrizesTroubleshooting Arrays Aborda alguns problemas comuns que surgem ao trabalhar com matrizes.Discusses some common problems that arise when working with arrays.

Consulte tambémSee also