Matrices en Visual BasicArrays in Visual Basic

Una matriz es un conjunto de valores, que se denomina elementos, que se relacionan lógicamente entre sí.An array is a set of values, which are termed elements, that are logically related to each other. Por ejemplo, una matriz puede constar del número de alumnos de cada curso en una escuela primaria; cada elemento de la matriz es el número de alumnos en un único nivel.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. De forma similar, una matriz puede constar de las calificaciones de un estudiante de una clase; cada elemento de la matriz es un único nivel.Similarly, an array may consist of a student's grades for a class; each element of the array is a single grade.

Es posible variables individuales para almacenar cada uno de nuestros elementos de datos.It is possible individual variables to store each of our data items. Por ejemplo, si nuestra aplicación analiza alumnos, podemos usamos una variable independiente para el nivel de cada alumno, tales como englishGrade1, englishGrade2, etcetera. Este enfoque tiene tres principales limitaciones: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:

  • Tenemos que saber en tiempo de diseño exactamente cuántas calificaciones se tiene que controlar.We have to know at design time exactly how many grades we have to handle.
  • Controlar un gran número de grados de rápidamente es difícil de manejar.Handling large numbers of grades quickly becomes unwieldy. A su vez, esto hace que una aplicación mucho más probable que tengan errores graves.This in turn makes an application much more likely to have serious bugs.
  • Es difícil de mantener.It is difficult to maintain. Cada curso nueva que agregamos requiere que la aplicación se puede modificar, vuelve a compilar y volver a implementar.Each new grade that we add requires that the application be modified, recompiled, and redeployed.

Mediante el uso de una matriz, puede hacer referencia a estos valores relacionados con el mismo nombre y usar un número que se llama a un índice o subíndice para identificar un elemento individual en función de su posición en la 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. Los índices de una matriz van desde 0 hasta uno menos que el número total de elementos de la matriz.The indexes of an array range from 0 to one less than the total number of elements in the array. Cuando usa la sintaxis de Visual Basic para definir el tamaño de una matriz, especificar su índice más alto, no el número total de elementos de la 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. Puede trabajar con la matriz como una unidad y la capacidad para recorrer en iteración sus elementos le libera de la necesidad de saber exactamente cuántos elementos contiene en tiempo de diseño.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.

Veamos algunos ejemplos rápidos antes de la explicación: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 de la matriz en una matriz sencillaArray elements in a simple array

Vamos a crear una matriz llamada students para almacenar el número de alumnos de cada curso en una escuela primaria.Let's create an array named students to store the number of students in each grade in a grammar school. Los índices de los elementos van del 0 al 6.The indexes of the elements range from 0 through 6. Uso de esta matriz es más fácil que declarar siete variables.Using this array is simpler than declaring seven variables.

La siguiente ilustración muestra el students matriz.The following illustration shows the students array. Para cada elemento de la matriz:For each element of the array:

  • El índice del elemento representa el curso (el índice 0 representa la guardería).The index of the element represents the grade (index 0 represents kindergarten).

  • El valor que se encuentra en el elemento representa el número de estudiantes en dicho curso.The value that’s contained in the element represents the number of students in that grade.

Diagrama que muestra una matriz de los números de estudiantes

El ejemplo siguiente contiene el código de Visual Basic que crea y utiliza la 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

El ejemplo hace tres cosas:The example does three things:

  • Declara un students matriz con siete elementos.It declares a students array with seven elements. El número 6 en la matriz declaración indica el último índice de la matriz; es uno menos que el número de elementos de la 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.
  • Asigna valores a cada elemento de la matriz.It assigns values to each element in the array. Se tiene acceso a los elementos de matriz utilizando el nombre de la matriz y el índice del elemento individual se incluyen entre paréntesis.Array elements are accessed by using the array name and including the index of the individual element in parentheses.
  • Enumera cada valor de la matriz.It lists each value of the array. El ejemplo se usa un For instrucción para tener acceso a cada elemento de la matriz por su número de índice.The example uses a For statement to access each element of the array by its index number.

El students matriz en el ejemplo anterior es una matriz unidimensional porque utiliza un índice.The students array in the preceding example is a one-dimensional array because it uses one index. Una matriz que se usa más de un índice o subíndice se denomina multidimensionales.An array that uses more than one index or subscript is called multidimensional. Para obtener más información, vea el resto de este artículo y dimensiones de la matriz en Visual Basic.For more information, see the rest of this article and Array Dimensions in Visual Basic.

Creación de una matrizCreating an array

Puede definir el tamaño de una matriz de varias maneras:You can define the size of an array in several ways:

  • Puede especificar el tamaño cuando se declara la matriz: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
    
  • Puede usar un New cláusula para proporcionar el tamaño de la matriz cuando se crea: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(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
    

Si tiene una matriz existente, puede volver a definir su tamaño utilizando la ReDim instrucción.If you have an existing array, you can redefine its size by using the ReDim statement. Puede especificar que el ReDim instrucción mantenga los valores que se encuentran en la matriz, o puede especificar que crear una matriz vacía.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. El ejemplo siguiente muestra los diferentes usos de la instrucción ReDim para modificar el tamaño de una 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 obtener más información, consulte el instrucción ReDim.For more information, see the ReDim Statement.

Almacenar valores en una matrizStoring values in an array

Puede tener acceso a cada ubicación en una matriz mediante un índice del tipo Integer.You can access each location in an array by using an index of type Integer. Puede almacenar y recuperar los valores en una matriz haciendo referencia a cada ubicación de la matriz usando su índice entre paréntesis.You can store and retrieve values in an array by referencing each array location by using its index enclosed in parentheses. Los índices para las matrices multidimensionales se separan mediante comas (,).Indexes for multidimensional arrays are separated by commas (,). Necesita un índice para cada dimensión de la matriz.You need one index for each array dimension.

El ejemplo siguiente muestra algunas instrucciones que almacenan y recuperan valores de las matrices.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

Rellenar una matriz con literales de matrizPopulating an array with array literals

Mediante el uso de un literal de matriz, puede rellenar una matriz con un conjunto inicial de valores al mismo tiempo que la crea.By using an array literal, you can populate an array with an initial set of values at the same time that you create it. Un literal de matriz consta de una lista de valores separados por comas entre llaves ({}).An array literal consists of a list of comma-separated values that are enclosed in braces ({}).

Cuando se crea una matriz mediante un literal de matriz, puede proporcionar el tipo de matriz o usar la inferencia de tipo para determinar el 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. El ejemplo siguiente muestra ambas opciones.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 }

Cuando se usa la inferencia de tipos, el tipo de la matriz viene determinada por la tipo dominante en la lista de valores literales.When you use type inference, the type of the array is determined by the dominant type in the list of literal values. El tipo dominante es el tipo al que se pueden ampliar todos los demás tipos de la matriz.The dominant type is the type to which all other types in the array can widen. Si no se puede determinar este tipo único, el tipo dominante es el tipo único al que todos los demás tipos de la matriz se pueden 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. Si no se puede determinar ninguno de estos tipos únicos, el tipo dominante es Object.If neither of these unique types can be determined, the dominant type is Object. Por ejemplo, si la lista de valores que se proporciona al literal de matriz contiene valores de tipo Integer, Longy Double, la matriz resultante es de 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. Dado que Integer y Long amplían solo a Double, Double es el tipo dominante.Because Integer and Long widen only to Double, Double is the dominant type. Para obtener más información, consulta Widening and Narrowing Conversions.For more information, see Widening and Narrowing Conversions.

Nota

Puede usar la inferencia solo para las matrices que se definen como las variables locales en un miembro de tipo.You can use type inference only for arrays that are defined as local variables in a type member. Si falta una definición de tipo explícito, las matrices definidas con literales de matriz en el nivel de clase son de tipo Object[].If an explicit type definition is absent, arrays defined with array literals at the class level are of type Object[]. Para obtener más información, consulte inferencia de tipos Local.For more information, see Local type inference.

Tenga en cuenta que el ejemplo anterior se define values como una matriz de tipo Double , aunque todos los literales de matriz son del 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. Puede crear esta matriz porque los valores del literal de matriz se pueden ampliar Double valores.You can create this array because the values in the array literal can widen to Double values.

También puede crear y rellenar una matriz multidimensional mediante anidar los literales de matriz.You can also create and populate a multidimensional array by using nested array literals. Literales de matriz anidados deben tener un número de dimensiones que sea coherente con la matriz resultante.Nested array literals must have a number of dimensions that’s consistent with the resulting array. El ejemplo siguiente crea una matriz bidimensional de enteros mediante el uso de literales de matriz anidados.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}}

Al usar literales de matriz anidados para crear y rellenar una matriz, se produce un error si el número de elementos en los literales de matriz anidados no coincide.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. También se produce un error si se declara explícitamente la variable de matriz tienen un número diferente de dimensiones que los literales de matriz.An error also occurs if you explicitly declare the array variable to have a different number of dimensions than the array literals.

Se puede hacer para las matrices unidimensionales, puede confiar en la inferencia de tipos al crear una matriz multidimensional con literales de matriz anidados.Just as you can for one-dimensional arrays, you can rely on type inference when creating a multidimensional array with nested array literals. El tipo inferido es el tipo dominante para todos los valores de todos los literales de matriz para el nivel de anidamiento de todos.The inferred type is the dominant type for all the values in all the array literals for all nesting level. En el ejemplo siguiente se crea una matriz bidimensional de tipo Double[,] de valores que son del tipo Integer y 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 obtener ejemplos adicionales, vea Cómo: Inicializar una Variable de matriz en Visual Basic.For additional examples, see How to: Initialize an Array Variable in Visual Basic.

Recorrer en iteración una matrizIterating through an array

Cuando recorren en iteración una matriz, tener acceso a cada elemento de la matriz desde el índice más bajo al más alto o de mayor a menor.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. Por lo general, use el para... Instrucción Next o para cada... Instrucción Next para recorrer en iteración los elementos de una matriz.Typically, use either the For...Next Statement or the For Each...Next Statement to iterate through the elements of an array. Si no conoce los límites superiores de la matriz, puede llamar a la Array.GetUpperBound método para obtener el valor más alto del í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. Aunque el valor de índice mínimo es casi siempre es 0, puede llamar a la Array.GetLowerBound método para obtener el valor más bajo del índice.Although lowest index value is almost always 0, you can call the Array.GetLowerBound method to get the lowest value of the index.

El ejemplo siguiente se recorre en iteración una matriz unidimensional mediante el uso de la For...Next instrucción.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

El ejemplo siguiente se recorre en iteración una matriz multidimensional utilizando un For...Next instrucción.The following example iterates through a multidimensional array by using a For...Next statement. El método GetUpperBound tiene un parámetro que especifica la dimensión.The GetUpperBound method has a parameter that specifies the dimension. GetUpperBound(0) Devuelve el índice más alto de la primera dimensión y GetUpperBound(1) devuelve el índice más alto de la segunda dimensión.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

En el ejemplo siguiente se usa un For Each... Instrucción Nextpara recorrer en iteración una matriz unidimensional y una 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

Tamaño de la matrizArray size

El tamaño de una matriz es el producto de las longitudes de todas sus dimensiones.The size of an array is the product of the lengths of all its dimensions. Representa el número total de elementos contenidos actualmente en la matriz.It represents the total number of elements currently contained in the array. Por ejemplo, en el ejemplo siguiente se declara una matriz de 2 dimensiones con cuatro elementos en cada dimensión.For example, the following example declares a 2-dimensional array with four elements in each dimension. Como se muestra el resultado del ejemplo, el tamaño de la matriz es 16 (o (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

Nota

Esta discusión de tamaño de la matriz no es aplicable a las matrices escalonadas.This discussion of array size does not apply to jagged arrays. Para obtener información sobre las matrices escalonadas y determinar el tamaño de una matriz escalonada, consulte el matrices escalonadas sección.For information on jagged arrays and determining the size of a jagged array, see the Jagged arrays section.

Puede encontrar el tamaño de una matriz mediante la propiedad Array.Length.You can find the size of an array by using the Array.Length property. Puede encontrar la longitud de cada dimensión de una matriz multidimensional utilizando el Array.GetLength método.You can find the length of each dimension of a multidimensional array by using the Array.GetLength method.

Puede cambiar el tamaño de una variable de matriz asignando un nuevo objeto de matriz a él o mediante el ReDim instrucción instrucción.You can resize an array variable by assigning a new array object to it or by using the ReDim Statement statement. En el ejemplo siguiente se usa el ReDim instrucción para cambiar una matriz de 100 elementos a una 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

 

Hay varios aspectos que se deben tener en cuenta cuando se trabaja con el tamaño de una matriz.There are several things to keep in mind when dealing with the size of an array.

Longitud de la dimensiónDimension Length El índice de cada dimensión es de base 0, lo que significa que va desde 0 a su límite superior.The index of each dimension is 0-based, which means it ranges from 0 to its upper bound. Por lo tanto, la longitud de una dimensión determinada es una unidad mayor que el límite máximo declarado de esa dimensión.Therefore, the length of a given dimension is one greater than the declared upper bound of that dimension.
Límites de longitudLength Limits La longitud de cada dimensión de una matriz se limita al valor máximo de la Integer tipo de datos, que es Int32.MaxValue o (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. Sin embargo, el tamaño total de una matriz también está limitado por la memoria disponible en el sistema.However, the total size of an array is also limited by the memory available on your system. Si se intenta inicializar una matriz que supera la cantidad de memoria disponible, el runtime produce una OutOfMemoryException.If you attempt to initialize an array that exceeds the amount of available memory, the runtime throws an OutOfMemoryException.
Tamaño y tamaño de elementoSize and Element Size El tamaño de la matriz es independiente del tipo de datos de sus elementos.An array's size is independent of the data type of its elements. El tamaño siempre representa el número total de elementos, no el número de bytes que se usan en la memoria.The size always represents the total number of elements, not the number of bytes that they consume in memory.
Consumo de memoriaMemory Consumption No es seguro dar nada por supuesto en lo que respecta al modo de almacenar una matriz en la memoria.It is not safe to make any assumptions regarding how an array is stored in memory. El almacenamiento varía en función de las plataformas de diferentes anchos de datos, por lo que la misma matriz puede utilizar más memoria en un sistema de 64 bits que en un 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. Según la configuración del sistema cuando inicializa una matriz, Common Language Runtime (CLR) puede asignar el almacenamiento para empaquetar los elementos tan juntos como sea posible o para alinearlos todos en los límites naturales del 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. Asimismo, una matriz requiere una sobrecarga de almacenamiento para obtener su información de control y esta sobrecarga aumenta con cada dimensión agregada.Also, an array requires a storage overhead for its control information, and this overhead increases with each added dimension.

El tipo de matrizThe array type

Cada matriz tiene un tipo de datos, que difiere del tipo de datos de sus elementos.Every array has a data type, which differs from the data type of its elements. No existe ningún tipo de datos para todas las matrices.There is no single data type for all arrays. En su lugar, el tipo de datos de una matriz lo determina el número de dimensiones, o rango, de la matriz y el tipo de datos de los elementos de la 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. Escriba solo cuando tienen el mismo rango y sus elementos tienen los mismos datos escriba, son dos variables de matriz de los mismos datos.Two array variables are of the same data type only when they have the same rank and their elements have the same data type. Las longitudes de las dimensiones de matriz no influyen en el tipo de datos de matriz.The lengths of the dimensions of an array do not influence the array data type.

Cada matriz hereda la clase System.Array y puede declarar una variable del tipo Array, pero no puede crear una matriz del 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 ejemplo, aunque el código siguiente declara la arr variable es de tipo Array y llama a la Array.CreateInstance método para crear una instancia de la matriz, el tipo de la matriz demuestra para 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[]

Además, la Instrucción ReDim no puede funcionar en una variable declarada de tipo Array.Also, the ReDim Statement cannot operate on a variable declared as type Array. Por estos motivos y seguridad de tipos, es aconsejable declarar cada matriz como un tipo específico.For these reasons, and for type safety, it is advisable to declare every array as a specific type.

Puede averiguar el tipo de datos de una matriz o de sus elementos de varias maneras.You can find out the data type of either an array or its elements in several ways.

  • Puede llamar a la GetType método en la variable para obtener un Type objeto que representa el tipo de tiempo de ejecución de la variable.You can call the GetType method on the variable to get a Type object that represents the run-time type of the variable. El objeto Type contiene amplia información en sus propiedades y métodos.The Type object holds extensive information in its properties and methods.
  • Puede pasar la variable a la TypeName función para obtener un String con el nombre del tipo de tiempo de ejecución.You can pass the variable to the TypeName function to get a String with the name of run-time type.

En el ejemplo siguiente se llama tanto el GetType método y el TypeName función para determinar el tipo de matriz.The following example calls the both the GetType method and the TypeName function to determine the type of an array. El tipo de matriz es Byte(,).The array type is Byte(,). Tenga en cuenta que el Type.BaseType propiedad también indica que el tipo base de la matriz de bytes es el Array clase.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(,)


Matrices como valores devueltos y parámetrosArrays as return values and parameters

Para devolver una matriz desde un procedimiento Function, especifique el tipo de datos de matriz y el número de dimensiones como tipo de valor devuelto de la Instrucción Function.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 de la función, declare una variable de matriz local con el mismo tipo de datos y número de dimensiones.Within the function, declare a local array variable with same data type and number of dimensions. En la Instrucción Return, incluya la variable de matriz local sin paréntesis.In the Return Statement, include the local array variable without parentheses.

Para especificar una matriz como parámetro para un procedimiento Sub o Function , defina el parámetro como una matriz con un tipo de datos especificado y el número de dimensiones.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. En la llamada al procedimiento, pase una variable de matriz con el mismo tipo de datos y el número de dimensiones.In the call to the procedure, pass an array variable with the same data type and number of dimensions.

En el ejemplo siguiente, la GetNumbers función devuelve un Integer(), una matriz unidimensional de tipo Integer.In the following example, the GetNumbers function returns an Integer(), a one-dimensional array of type Integer. El procedimiento ShowNumbers acepta un 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
    

En el ejemplo siguiente, la GetNumbersMultiDim función devuelve un Integer(,), una matriz bidimensional de tipo Integer.In the following example, the GetNumbersMultiDim function returns an Integer(,), a two-dimensional array of type Integer. El procedimiento ShowNumbersMultiDim acepta un 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

Matrices escalonadasJagged arrays

A veces la estructura de datos de la aplicación es bidimensional pero no rectangular.Sometimes the data structure in your application is two-dimensional but not rectangular. Por ejemplo, podría utilizar una matriz para almacenar datos acerca de la temperatura máxima de cada día del mes.For example, you might use an array to store data about the high temperature of each day of the month. La primera dimensión de la matriz representa el mes, pero la segunda dimensión representa el número de días y el número de días del mes no es 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. Un matriz escalonada, que también se denomina un matriz de matrices, está diseñado para estos escenarios.A jagged array, which is also called an array of arrays, is designed for such scenarios. Una matriz escalonada es una matriz cuyos elementos también son matrices.A jagged array is an array whose elements are also arrays. Una matriz escalonada y cada elemento de una matriz escalonada pueden tener una o más dimensiones.A jagged array and each element in a jagged array can have one or more dimensions.

El ejemplo siguiente usa una matriz de meses, cada elemento del que es una matriz de días.The following example uses an array of months, each element of which is an array of days. El ejemplo utiliza una matriz escalonada porque distintos meses tienen un número diferente de días.The example uses a jagged array because different months have different numbers of days. El ejemplo muestra cómo crear una matriz escalonada, asignar valores a él y recuperar y mostrar sus 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

El ejemplo anterior asigna valores a la matriz escalonada según un elemento por elemento mediante el uso de un For...Next bucle.The previous example assigns values to the jagged array on an element-by-element basis by using a For...Next loop. También puede asignar valores a los elementos de una matriz escalonada mediante literales de matriz anidados.You can also assign values to the elements of a jagged array by using nested array literals. Sin embargo, anidada al intentar utilizar literales de matriz (por ejemplo, Dim valuesjagged = {{1, 2}, {2, 3, 4}}) genera el error del compilador BC30568.However, the attempt to use nested array literals (for example, Dim valuesjagged = {{1, 2}, {2, 3, 4}}) generates compiler error BC30568. Para corregir el error, encierre los literales de matriz internos entre paréntesis.To correct the error, enclose the inner array literals in parentheses. Los paréntesis fuerzan la expresión literal de matriz que se debe evaluar y los valores resultantes se utilizan con el exterior literal de matriz, como se muestra en el ejemplo siguiente.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

Una matriz escalonada es una matriz unidimensional cuyos elementos contienen las matrices.A jagged array is a one-dimensional array whose elements contain arrays. Por lo tanto, el Array.Length propiedad y el Array.GetLength(0) método devuelve el número de elementos en la matriz unidimensional, y Array.GetLength(1) produce una IndexOutOfRangeException porque una matriz escalonada no es 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 el número de elementos de cada submatriz recuperando el valor de cada submatriz Array.Length propiedad.You determine the number of elements in each subarray by retrieving the value of each subarray's Array.Length property. El ejemplo siguiente muestra cómo determinar el número de elementos de una matriz escalonada.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

Matrices de longitud ceroZero-length arrays

Visual Basic marca la diferencia entre una matriz sin inicializar (una matriz cuyo valor es Nothing) y un matriz de longitud cero o matriz vacía (una matriz sin elementos). Una matriz sin inicializar es aquel que no ha sido dimensionada o tenía asignado ningún valor.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 ejemplo:For example:

Dim arr() As String

Una matriz de longitud cero se declara con una dimensión de -1.A zero-length array is declared with a dimension of -1. Por ejemplo:For example:

Dim arrZ(-1) As String

Puede que tenga que crear una matriz de longitud cero en las circunstancias siguientes:You might need to create a zero-length array under the following circumstances:

  • Sin arriesgar una NullReferenceException excepción, el código debe tener acceso a los miembros de la Array clase, como Length o Rank, o llamar a una función de 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.

  • Desea simplificar el código al no tener que comprobar Nothing como un caso especial.You want to keep your code simple by not having to check for Nothing as a special case.

  • El código interactúa con una interfaz de programación de aplicaciones (API) que requiere pasar una matriz de longitud cero a uno o más procedimientos o que devuelve una matriz de longitud cero desde uno o más procedimientos.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.

División de una matrizSplitting an array

En algunos casos, necesita dividir una sola matriz varias matrices.In some cases, you may need to split a single array into multiple arrays. Esto implica que identifica el punto o puntos en el que se va a dividir la matriz y, a continuación, escupir la matriz en dos o más matrices independientes.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.

Nota

En esta sección describen la dividir una cadena única en una matriz de cadenas según algún delimitador.This section does not discuss splitting a single string into a string array based on some delimiter. Para obtener información sobre la división de una cadena, vea el String.Split método.For information on splitting a string, see the String.Split method.

Los criterios para dividir una matriz más comunes son:The most common criteria for splitting an array are:

  • Número de elementos de la matriz.The number of elements in the array. Por ejemplo, es posible que desee dividir un conjunto de más de un número especificado de elementos en un número de partes iguales aproximadamente.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 ello, puede usar el valor devuelto por la Array.Length o Array.GetLength método.For this purpose, you can use the value returned by either the Array.Length or Array.GetLength method.

  • El valor de un elemento, que actúa como un delimitador que indica dónde se debe dividir la matriz.The value of an element, which serves as a delimiter that indicates where the array should be split. Puede buscar un valor específico mediante una llamada a la Array.FindIndex y Array.FindLastIndex métodos.You can search for a specific value by calling the Array.FindIndex and Array.FindLastIndex methods.

Una vez que haya determinado el índice o índices en el que se debe dividir la matriz, a continuación, puede crear las matrices individuales mediante una llamada a la 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.

El ejemplo siguiente divide una matriz en dos matrices de aproximadamente el mismo tamaño.The following example splits an array into two arrays of approximately equal size. (Si el número total de elementos de la matriz es impar, la primera matriz tiene más de un elemento que el 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

El ejemplo siguiente divide una matriz de cadenas en dos matrices en función de la presencia de un elemento cuyo valor es "zzz", que actúa como el 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. Las nuevas matrices no incluyen el elemento que contiene el 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

Unirse a matricesJoining arrays

También puede combinar un número de matrices en una sola matriz más grande.You can also combine a number of arrays into a single larger array. Para ello, utilice también el Array.Copy método.To do this, you also use the Array.Copy method.

Nota

En esta sección describen la unirse a una matriz de cadenas en una sola cadena.This section does not discuss joining a string array into a single string. Para obtener información sobre la unión a una matriz de cadenas, vea el String.Join método.For information on joining a string array, see the String.Join method.

Antes de copiar los elementos de cada matriz en la nueva matriz, primero debe asegurarse de que se ha inicializado la matriz para que sea suficientemente grande como para dar cabida a la nueva 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. Hay dos maneras de hacerlo:You can do this in one of two ways:

  • Use la ReDim Preserve instrucción expandir dinámicamente la matriz antes de agregar nuevos elementos a él.Use the ReDim Preserve statement to dynamically expand the array before adding new elements to it. Ésta es la técnica más sencilla, pero puede provocar una degradación del rendimiento y consumo de memoria excesivo cuando va a copiar matrices de gran tamaño.This is the easiest technique, but it can result in performance degradation and excessive memory consumption when you are copying large arrays.
  • Calcular el número total de elementos que necesita para la nueva matriz de gran tamaño, a continuación, agregarle los elementos de cada matriz de origen.Calculate the total number of elements needed for the new large array, then add the elements of each source array to it.

El ejemplo siguiente usa el segundo enfoque para agregar cuatro matrices con diez elementos a una sola 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.

Puesto que en este caso, las matrices de origen son todos los pequeñas, podemos expandir dinámicamente también la matriz de medida que se agreguen los elementos de cada matriz nuevo a él.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. En el siguiente ejemplo se realiza esto.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.

Colecciones como alternativa a las matricesCollections as an alternative to arrays

Las matrices son muy útiles para crear y trabajar con un número fijo de objetos fuertemente tipados.Arrays are most useful for creating and working with a fixed number of strongly typed objects. Las colecciones proporcionan una manera más flexible de trabajar con grupos de objetos.Collections provide a more flexible way to work with groups of objects. A diferencia de las matrices, que requiere que cambie explícitamente el tamaño de una matriz con el ReDim instrucción, colecciones de crecer y reducirse dinámicamente a medida que las necesidades de un cambio en la aplicación.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.

Cuando usas ReDim para dimensiones de matriz, Visual Basic crea una nueva matriz y libera la anterior.When you use ReDim to redimension an array, Visual Basic creates a new array and releases the previous one. Esto requiere tiempo de ejecución.This takes execution time. Por lo tanto, si el número de elementos que trabaja cambia con frecuencia, o si no puede predecir el número máximo de elementos que necesita, normalmente obtendrá un mejor rendimiento mediante el uso de una colección.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 algunas colecciones, puede asignar una clave a cualquier objeto que incluya en la colección para, de este modo, recuperar rápidamente el objeto con la clave.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.

Si la colección contiene elementos de un solo tipo de datos, puede usar una de las clases del espacio de nombres 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. Una colección genérica cumple la seguridad de tipos para que ningún otro tipo de datos se pueda agregar a ella.A generic collection enforces type safety so that no other data type can be added to it.

Para más información sobre las colecciones, vea Colecciones.For more information about collections, see Collections.

TérminoTerm DefiniciónDefinition
Array Dimensions in Visual BasicArray Dimensions in Visual Basic Explica el rango y las dimensiones de las matrices.Explains rank and dimensions in arrays.
Cómo: Inicializar una Variable de matriz en Visual BasicHow to: Initialize an Array Variable in Visual Basic Describe cómo se llenan las matrices con valores iniciales.Describes how to populate arrays with initial values.
Cómo: Ordenar una matriz en Visual BasicHow to: Sort An Array in Visual Basic Muestra cómo ordenar alfabéticamente los elementos de una matriz.Shows how to sort the elements of an array alphabetically.
Cómo: Asignar una matriz a otraHow to: Assign One Array to Another Array Describe las reglas y los pasos para asignar una matriz a otra variable de matriz.Describes the rules and steps for assigning an array to another array variable.
Solución de problemas de matricesTroubleshooting Arrays Describe algunos problemas comunes que surgen al trabajar con matrices.Discusses some common problems that arise when working with arrays.

Vea tambiénSee also