Vba массивы: VBA Excel. Массивы (одномерные, многомерные, динамические)

Содержание

Примеры использования массивов в VBA

Массивы используются в большинстве языков программирования и VBA, как язык высокого уровня, тоже не мог обойтись без них. Данный материал расскажет о создании массивов, их применении, а так же вы здесь найдете примеры использования массивов. Для начала разберем синтаксис определения массивов.

Объявление массивов

Пример 1. Создание (объявление) одномерного массива выполняется, так:


Dim Arr1(10) As Integer
Dim Arr2(5 To 10) As String
Dim Arr3() As Long

В данном примере объявляются: одномерный массив Arr1, содержащий ячейки с 0-й до 10-й типа Integer, массив Arr2, содержащий ячейки с 5-й до 10-й типа String и динамический массив Arr3.

Прежде чем использовать динамический массив, его необходимо «инициализировать», т.е. выделить для него необходимую память. Менять размер динамического массива можно много раз в программе, даже в цикле, если хотите. Правда учитывайте, что выделение памяти для массива — ресурсно-затратная операция, поэтому не стоит менять размер массива очень часто, это сильно замедлит программу.

Пример 2. Инициализация динамического массива и изменение его размеров


Dim Arr3() As Long
ReDim Preserve Arr3(10)
ReDim Preserve Arr3(20)

В данном примере мы сначала с помощью ReDim задали размер динамического массива в 11 элементов (c 0-го по 10-й), а затем снова увеличили размер до 21-го элемента. Кроме того, использовали ключевое слово Preserve — означающее, что нужно сохранить уже имеющиеся элементы с их значениями (без этого ключевого слова массив обнуляется).

Примечание: изменение размеров функцией ReDim возможно только для динамических массивов. Если размер массива был изначально задан, то его размер уже не будет меняться функцией.

Пример 3. Объявление многомерного массива


Dim Arr4(10, 10) As Integer
Dim Arr5(5 To 10, 15 To 20, 30) As String

Arr4 — двумерных массив 11х11 элементов, а массив Arr5 — трехмерный.

Пример 4. Создание массива массивов

В следующем примере массив Arr2 будет содержать элементы другого массива Arr1


Dim Arr1 As Variant
Dim Arr2(10) As Variant
Arr1 = Array(10, 20, 30)
Arr2(0) = Arr1
For i = LBound(Arr2(0)) To UBound(Arr2(0))
  MsgBox Arr2(0)(i) ' Выведет последовательно 10, 20 и 30
Next i

Определение нижней и верхней границы массива

Чтобы узнать какой самый наименьший индекс у массива и какой самый максимальный индекс массива, нужно использовать функции LBound для определения нижней границы и UBound для определения верхней границы.

Пример 5. Определение границ массива


Dim Arr1(2 To 15) As Integer
MsgBox LBound(Arr1) ' Выведет: 2
MsgBox UBound(Arr1) ' Выведет: 15
Dim Arr2() As Integer
ReDim Arr2(8)
MsgBox LBound(Arr2) ' Выведет: 0
MsgBox UBound(Arr2) ' Выведет: 8

Чтобы определить границы многомерных массивов, нужно просто использовать второй параметр функций UBound и LBound.


Dim Arr(1 To 10, 5 To 20) As Integer
MsgBox LBound(Arr, 2) ' Выведет: 5
MsgBox UBound(Arr, 2) ' Выведет: 20

Задание нижней границы по-умолчанию

Иногда бывает очень не удобно, что VBA начинает нумерацию элементов массивов с нуля (0), это часто может привести к путанице и усложнению кода программы. Для решения этой проблемы есть специальный оператор Option Base, аргумент которого может быть 0 или 1. Указав значение 1, индексация массивов будет начинаться с 1, а не с 0.

Пример 6. Указание нижней границы по-умолчанию.


Option Base 1

Sub Test()
Dim Arr1(10) As Integer
MsgBox LBound(Arr1)
End Sub

В данном примере я намеренно использовал процедуру, чтобы показать, что Option Base нужно применять не внутри процедур и функций, а в разделе «Declarations». В результате выполнения процедуры Test будет отображено сообщение с индексом нижней границы массива, т.е. «1».

Примечание: Оператор Option Base так же влияет на функцию Array и не влияет на функцию Split (будут рассмотрены ниже), что означает, что при задании «Option Base 1», функция Array вернет массив с индексацией с 1-цы, а функция Split вернет массив с индексацией с 0.

Запись данных в массивы

Для сохранения каких-либо значений в массив, можно воспользоваться несколькими способами. С помощью примеров, покажу эти способы.

Пример 7. Запись данных в массив в цикле.


Dim Arr(10) As Integer
For i = 0 To 10
    Arr(i) = i * 2
Next i

Пример 8. Запись заранее известных данных с помощью Array


Dim Arr()
Arr = Array("красный", "зеленый", "синий")
MsgBox Arr(2)

Функция Array возвращает массив из перечисленных данных типа Variant. При этом, массив, который будет содержать значения, должен быть динамическим, т.е. без указания его размеров и границ.

Пример 9. Получение массива из строки с разделителями


Dim Arr() As String
Arr = Split("красный;зеленый;синий", ";")
MsgBox Arr(2)

Обход элементов массива

Обычно, массивы используются для хранения большого кол-ва данных, а не 1-2 значений, поэтому чтобы получить все эелементы и использовать их для чего-то, обычно используют циклы. Наиболее удобны в этом плане циклы For и For Each.

Пример 10. Обход элементов массива циклом For.


Dim Sum As Integer
Dim Arr()
Arr = Array(10, 20, 30)
For i = 0 To 2
    Sum = Sum + Arr(i)
Next i
MsgBox Sum

Пример 11. Обход элементов массива циклом For Each.


Dim Sum As Integer
Dim Val As Variant
Dim Arr()
Arr = Array(10, 20, 30)
For Each Val In Arr
    Sum = Sum + Val
Next
MsgBox Sum

Иногда, бывает необходимость работы с массивом внутри других типов циклов, но получение значение элемента, всё-равно в них будет таким же, как и в цикле For, т.е. через индекс элемента.

Объявление массивов (VBA) | Microsoft Docs

12/21/2018

Чтение занимает 2 мин

В этой статье

Массивы объявляются так же, как и другие переменные, при помощи операторов Dim, Static, Private или PublicArrays are declared the same way as other variables, by using the Dim, Static, Private, or Public statements. Отличие скалярных переменных (которые не являются массивами) от переменных массивов заключается в том, что для массива, как правило, необходимо указывать размер.The difference between scalar variables (those that aren’t arrays) and array variables is that you generally must specify the size of the array. Массив с указанным размером является массивом фиксированного размера.An array whose size is specified is a fixed-size array. Массив, размер которого можно изменить во время выполнения программы, является динамическим массивом.An array whose size can be changed while a program is running is a dynamic array.

Индексация массива от 0 или 1 зависит от оператора Option Base.Whether an array is indexed from 0 or 1 depends on the setting of the Option Base statement. Если не указано Option Base 1, все индексы массива будут начинается с нуля.If Option Base 1 is not specified, all array indexes begin at zero.

Объявление статического массиваDeclare a fixed array

В приведенном ниже примере кода массив фиксированного размера объявлен массивом целых переменных (Integer) с 11 строками и 11 столбцами:In the following line of code, a fixed-size array is declared as an Integer array having 11 rows and 11 columns:

Dim MyArray(10, 10) As Integer

Первый аргумент определяет количество строк, второй — столбцов.The first argument represents the rows; the second argument represents the columns.

Как и в случае объявления любой другой переменной, если для объявленного массива не указать тип данных, его элементам будет присвоен тип данных Variant.As with any other variable declaration, unless you specify a data type for the array, the data type of the elements in a declared array is Variant. Каждый числовой элемент Variant массива использует 16 байтов.Each numeric Variant element of the array uses 16 bytes. Каждый строчный элемент Variant использует 22 байта.Each string Variant element uses 22 bytes. Чтобы написать как можно более компактный код, четко объявите для своих массивов тип данных, отличный от Variant.To write code that is as compact as possible, explicitly declare your arrays to be of a data type other than Variant.

В приведенном ниже примере кода сравниваются размеры нескольких массивов.The following lines of code compare the size of several arrays.

' Integer array uses 22 bytes (11 elements * 2 bytes). 
ReDim MyIntegerArray(10) As Integer 
 
' Double-precision array uses 88 bytes (11 elements * 8 bytes). 
ReDim MyDoubleArray(10) As Double 
 
' Variant array uses at least 176 bytes (11 elements * 16 bytes). 
ReDim MyVariantArray(10) 
 
' Integer array uses 100 * 100 * 2 bytes (20,000 bytes). 
ReDim MyIntegerArray (99, 99) As Integer 
 
' Double-precision array uses 100 * 100 * 8 bytes (80,000 bytes). 
ReDim MyDoubleArray (99, 99) As Double 
 
' Variant array uses at least 160,000 bytes (100 * 100 * 16 bytes). 
ReDim MyVariantArray(99, 99)

Максимальный размер массивов зависит от операционной системы и доступного объема памяти.The maximum size of an array varies, based on your operating system and how much memory is available. Использование массивов, размер которых превышает объем доступной оперативной памяти вашего компьютера, приводит к снижению скорости, поскольку системе необходимо выполнять запись данных и чтение с диска.Using an array that exceeds the amount of RAM available on your system is slower because the data must be read from and written to disk.

Объявление динамического массиваDeclare a dynamic array

Объявив динамический массив, вы сможете менять его размер во время выполнения кода.By declaring a dynamic array, you can size the array while the code is running. Используйте операторы Static, Dim, Private или Public, чтобы объявить массив, не указывая значение в скобках, как показано в следующем примере:Use a Static, Dim, Private, or Public statement to declare an array, leaving the parentheses empty, as shown in the following example.

Dim sngArray() As Single

Примечание

Вы можете неявно объявить массив в процедуре при помощи оператора ReDim.You can use the ReDim statement to declare an array implicitly within a procedure. Будьте внимательны и вводите имя массива без ошибок при использовании оператора ReDim.Be careful not to misspell the name of the array when you use the ReDim statement. Даже если в модуль включен оператор Option Explicit, будет создан второй массив.Even if the Option Explicit statement is included in the module, a second array will be created.

В процедуре внутри области массива используйте оператор ReDim, чтобы изменить количество измерений, задать количество элементов и определить нижнюю и верхнюю границы каждого измерения.In a procedure within the array’s scope, use the ReDim statement to change the number of dimensions, to define the number of elements, and to define the upper and lower bounds for each dimension. Вы можете менять динамический массив при помощи оператора ReDim в любое время.You can use the ReDim statement to change the dynamic array as often as necessary. Однако значения внутри массива при этом не сохраняются.However, each time you do this, the existing values in the array are lost. Используйте ReDim Preserve для расширения массива, сохраняя при этом текущие значения.Use ReDim Preserve to expand an array while preserving existing values in the array.

Например, приведенный ниже оператор увеличивает массив на 10 элементов, сохраняя при этом текущие значения исходных элементов.For example, the following statement enlarges the array by 10 elements without losing the current values of the original elements.

ReDim Preserve varArray(UBound(varArray) + 10)

Примечание

При использовании ключевого слова Preserve внутри динамического массива можно менять только верхнюю границу последнего измерения; изменить количество измерений нельзя.When you use the Preserve keyword with a dynamic array, you can change only the upper bound of the last dimension, but you can’t change the number of dimensions.

См. такжеSee also

Поддержка и обратная связьSupport and feedback

Есть вопросы или отзывы, касающиеся Office VBA или этой статьи?Have questions or feedback about Office VBA or this documentation? Руководство по другим способам получения поддержки и отправки отзывов см. в статье Поддержка Office VBA и обратная связь.Please see Office VBA support and feedback for guidance about the ways you can receive support and provide feedback.

Все про массивы в VBA. Полное руководство

Автор Дмитрий Якушев На чтение 24 мин. Просмотров 32k.

Дональд Кнут
Список настолько же силен, как и его самое слабое звено

В таблице ниже краткая справка по использованию массивов в VBA. В статье постарался замахнуться на звание самого подробного руководства, которое вы найдете о массивах VBA.

Краткое руководство по массивам VBA

Задача	Статический массив	Динамический массив
Объявление	Dim arr(0 To 5) As Long	Dim arr() As Long Dim arr As Variant
Установить размер	Dim arr(0 To 5) As Long	ReDim arr(0 To 5)As Variant
Увеличить размер (сохранить существующие данные)	Только динамический	ReDim Preserve arr(0 To 6)
Установить значения	arr(1) = 22	arr(1) = 22
Получить значения	total = arr(1)	total = arr(1)
Первая позиция	LBound(arr)	LBound(arr)
Последняя позиция	Ubound(arr)	Ubound(arr)
Читать все записи (1D)	For i = LBound(arr) To UBound(arr) Next i Or For i = LBound(arr,1) To UBound(arr,1) Next i	For i = LBound(arr) To UBound(arr) Next i Or For i = LBound(arr,1) To UBound(arr,1) Next i
Читать все записи (2D)	For i = LBound(arr,1) To UBound(arr,1) For j = LBound(arr,2) To UBound(arr,2) Next j Next i	For i = LBound(arr,1) To UBound(arr,1) For j = LBound(arr,2) To UBound(arr,2) Next j Next i
Читать все записи	Dim item As Variant For Each item In arr Next item	Dim item As Variant For Each item In arr Next item
Перейти на Sub	Sub MySub(ByRef arr() As String)	Sub MySub(ByRef arr() As String)
Возврат из функции	Function GetArray() As Long() Dim arr(0 To 5) As Long GetArray = arr End Function	Function GetArray() As Long() Dim arr() As Long GetArray = arr End Function
Получить от функции	Только динамический	Dim arr() As Long Arr = GetArray()
Стереть массив	Erase arr *Сбрасывает все значения по умолчанию	Erase arr *Удаляет массив
Строка в массив	Только динамический	Dim arr As Variant arr = Split(«James:Earl:Jones»,»:»)
Массив в строку	Dim sName As String sName = Join(arr, «:»)	Dim sName As String sName = Join(arr, «:»)
Заполните значениями	Только динамический	Dim arr As Variant arr = Array(«John», «Hazel», «Fred»)
Диапазон в массив	Только динамический	Dim arr As Variant arr = Range(«A1:D2»)
Массив в диапазон	Так же, как в динамическом	Dim arr As Variant Range(«A5:D6») = arr

Введение

В этой статье подробно рассматриваются массивы на языке программирования Excel VBA. Она охватывает важные моменты, такие как:

Зачем вам массивы
Когда вы должны их использовать
Два типа массивов
Использование более одного измерения
Объявление массивов
Добавление значений
Просмотр всех предметов
Супер эффективный способ чтения Range в массив

В первом разделе мы рассмотрим, что такое массивы и зачем они нужны. Вы можете не понимать часть кода в первом разделе. Это нормально. Я буду разбивать на простые термины в следующих разделах статьи.

Быстрые заметки

Иногда коллекции лучше, чем массивы. Вы можете прочитать о коллекциях здесь.

Массивы и циклы идут рука об руку. Наиболее распространенными циклами, которые вы используете с массивами, являются циклы For i и For Each.

Что такое массивы и зачем они нужны?

Массив VBA — это тип переменной. Используется для хранения списков данных одного типа. Примером может быть сохранение списка стран или списка итогов за неделю.

В VBA обычная переменная может хранить только одно значение за раз.

В следующем примере показана переменная, используемая для хранения оценок ученика.

' Может хранить только 1 значение за раз
Dim Student1 As Integer
Student1 = 55

Если мы хотим сохранить оценки другого ученика, нам нужно создать вторую переменную.

В следующем примере у нас есть оценки пяти студентов

Мы собираемся прочитать эти отметки и записать их в Immediate Window.

Примечание. Функция Debug.Print записывает значения в Immediate Window. Для просмотра этого окна выберите View-> Immediate Window из меню (сочетание клавиш Ctrl + G).

Как видите в следующем примере, мы пишем один и тот же код пять раз — по одному для каждого учащегося.

Public Sub StudentMarks()

    With ThisWorkbook.Worksheets("Лист1")

        ' Объявите переменную для каждого студента
        Dim Student1 As Integer
        Dim Student2 As Integer
        Dim Student3 As Integer
        Dim Student4 As Integer
        Dim Student5 As Integer

        ' Читайте оценки студентов из ячейки
        Student1 = .Range("C2").Offset(1)
        Student2 = .Range("C2").Offset(2)
        Student3 = .Range("C2").Offset(3)
        Student4 = .Range("C2").Offset(4)
        Student5 = .Range("C2").Offset(5)

        ' Печать студенческих оценок
        Debug.Print "Оценки студентов"
        Debug.Print Student1
        Debug.Print Student2
        Debug.Print Student3
        Debug.Print Student4
        Debug.Print Student5

    End With

End Sub

Ниже приведен вывод из примера

Проблема с использованием одной переменной для каждого учащегося заключается в том, что вам необходимо добавить код для каждого учащегося. Поэтому, если в приведенном выше примере у вас будет тысяча студентов, вам понадобится три тысячи строк кода!

К счастью, у нас есть массивы, чтобы сделать нашу жизнь проще. Массивы позволяют нам хранить список элементов данных в одной структуре.
Следующий код показывает приведенный выше пример с использованием массива.

Public Sub StudentMarksArr()

    With ThisWorkbook.Worksheets("Лист1")

        ' Объявите массив для хранения оценок для 5 студентов
        Dim Students(1 To 5) As Integer

        ' Читайте оценки учеников из ячеек C3: C7 в массив
        Dim i As Integer
        For i = 1 To 5
            Students(i) = .Range("C2").Offset(i)
        Next i

        ' Распечатывать оценки студентов из массива
        Debug.Print "Оценки студентов"
        For i = LBound(Students) To UBound(Students)
            Debug.Print Students(i)
        Next i

    End With

End Sub

Преимущество этого кода в том, что он будет работать для любого количества студентов. Если нам нужно изменить этот код для работы с 1000 студентами, нам нужно всего лишь изменить (от 1 до 5) на (от 1 до 1000) в декларации. В предыдущем примере нам нужно было добавить примерно пять тысяч строк кода.

Давайте проведем быстрое сравнение переменных и массивов. Сначала мы сравним процесс объявления.

 ' Объявляем переменные
        Dim Student As Integer
        Dim Country As String

  ' Объявляем массивы
        Dim Students(1 To 3) As Integer
        Dim Countries(1 To 3) As String

Далее мы сравниваем присвоение значения

    ' присвоить значение переменной
        Student1 = .Cells(1, 1) 

    ' присваивать значение первому элементу в массиве
        Students(1) = .Cells(1, 1)

Наконец, мы смотрим на запись значений

  ' Вывести значение переменной
        Debug.Print Student1

  ' Вывести значение первого студента в массиве
        Debug.Print Students(1)

Как видите, использование переменных и массивов очень похоже.

Важным является тот факт, что массивы используют индекс (также называемый нижним индексом) для доступа к каждому элементу. Это означает, что мы можем легко получить доступ ко всем элементам в массиве, используя цикл For.

Теперь, когда у вас есть представление о том, почему массивы полезны, давайте пройдемся по ним шаг за шагом.

Типы массивов VBA

В VBA есть два типа массивов:

Статический — массив фиксированного размера.
Динамический — массив, в котором размер задается во время выполнения

Разница между этими массивами в основном в том, как они создаются. Доступ к значениям в обоих типах массивов абсолютно одинаков. В следующих разделах мы рассмотрим оба типа.

Объявление массива

Статический массив объявляется следующим образом

Public Sub DecArrayStatic()

    ' Создать массив с местоположениями 0,1,2,3
    Dim arrMarks1(0 To 3) As Long

    ' По умолчанию от 0 до 3, то есть местоположения 0,1,2,3
    Dim arrMarks2(3) As Long

    ' Создать массив с местоположениями 1,2,3,4,5
    Dim arrMarks1(1 To 5) As Long

    ' Создать массив с местоположениями 2,3,4 'Это редко используется
    Dim arrMarks3(2 To 4) As Long

End Sub

Как видите, размер указывается при объявлении статического массива. Проблема в том, что вы никогда не можете быть заранее уверены, какой размер вам нужен. Каждый раз, когда вы запускаете макрос, у вас могут быть разные требования к размеру.

Если вы не используете все расположения массива, ресурсы тратятся впустую. Если вам нужно больше места, вы можете использовать ReDim, но это по сути создает новый статический массив.

Динамический массив не имеет таких проблем. Вы не указываете размер, когда объявляете. Поэтому вы можете увеличиваться и уменьшаться по мере необходимости.

Public Sub DecArrayDynamic()

    ' Объявить динамический массив
    Dim arrMarks() As Long

    ' Установите размер массива, когда вы будете готовы
    ReDim arrMarks(0 To 5)

End Sub

Динамический массив не выделяется, пока вы не используете оператор ReDim. Преимущество в том, что вы можете подождать, пока не узнаете количество элементов, прежде чем устанавливать размер массива. Со статическим массивом вы должны указать размер заранее.

Присвоение значений массиву

Чтобы присвоить значения массиву, вы используете номер местоположения (пересечении строки и столбца). Вы присваиваете значение для обоих типов массивов одинаково.

Public Sub AssignValue()

    ' Объявить массив с местоположениями 0,1,2,3
    Dim arrMarks(0 To 3) As Long

    ' Установите значение позиции 0
    arrMarks(0) = 5

    ' становите значение позиции 3
    arrMarks(3) = 46

    ' Это ошибка, так как нет местоположения 4
    arrMarks(4) = 99

End Sub

Номер места называется индексом. Последняя строка в примере выдаст ошибку «Индекс вне диапазона», так как в примере массива нет местоположения 4.

Использование функций Array и Split

Вы можете использовать функцию Array для заполнения массива списком элементов. Вы должны объявить массив как тип Variant. Следующий код показывает, как использовать эту функцию.

  Dim arr1 As Variant
    arr1 = Array("Апельсин", "Персик","Груша")

  Dim arr2 As Variant
    arr2 = Array(5, 6, 7, 8, 12)

Массив, созданный функцией Array, начнется с нулевого индекса, если вы не используете Option Base 1 в верхней части вашего модуля. Затем он начнется с первого индекса. В программировании, как правило, считается плохой практикой иметь ваши реальные данные в коде. Однако иногда это полезно, когда вам нужно быстро протестировать некоторый код. Функция Split используется для разделения строки на массив на основе разделителя. Разделитель — это символ, такой как запятая или пробел, который разделяет элементы.

Следующий код разделит строку на массив из трех элементов.

 Dim s As String
    s = "Красный,Желтый,Зеленый,Синий"

    Dim arr() As String
    arr = Split(s, ",")

Функция Split обычно используется, когда вы читаете из cvs или txt-файла, разделенного запятыми, или из другого источника, который предоставляет список элементов, разделенных одним и тем же символом.

Использование циклов с массивами

Использование цикла For обеспечивает быстрый доступ ко всем элементам массива. Вот где сила использования массивов становится очевидной. Мы можем читать массивы с десятью значениями или десятью тысячами значений, используя те же несколько строк кода. В VBA есть две функции: LBound и UBound. Эти функции возвращают самый маленький и самый большой индекс в массиве. В массиве arrMarks (от 0 до 3) LBound вернет 0, а UBound вернет 3.

В следующем примере случайные числа присваиваются массиву с помощью цикла. Затем он печатает эти числа, используя второй цикл.

Public Sub ArrayLoops()

    ' Объявить массив
    Dim arrMarks(0 To 5) As Long

    ' Заполните массив случайными числами
    Dim i As Long
    For i = LBound(arrMarks) To UBound(arrMarks)
        arrMarks(i) = 5 * Rnd
    Next i

    ' Распечатайте значения в массиве
    Debug.Print "Место нахождения", "Значение"
    For i = LBound(arrMarks) To UBound(arrMarks)
        Debug.Print i, arrMarks(i)
    Next i

End Sub

Функции LBound и UBound очень полезны. Их использование означает, что наши циклы будут работать правильно с любым размером массива. Реальное преимущество заключается в том, что если размер массива изменяется, нам не нужно менять код для печати значений. Цикл будет работать для массива любого размера, пока вы используете эти функции.

Использование цикла For Each

Вы можете использовать цикл For Each с массивами. Важно помнить, что он доступен только для чтения. Это означает, что вы не можете изменить значение в массиве.

В следующем коде значение метки изменяется, но оно не меняет значение в массиве.

 For Each mark In arrMarks
        ' Не изменит значение массива
        mark = 5 * Rnd
    Next mark

Цикл For Each отлично подходит для чтения массива. Как видите, лучше писать специально для двумерного массива.

  Dim mark As Variant
    For Each mark In arrMarks
        Debug.Print mark
    Next mark

Использование Erase

Функция Erase может использоваться для массивов, но она работает по-разному в зависимости от типа массива.

Для статического массива функция Erase сбрасывает все значения по умолчанию. Если массив состоит из целых чисел, то все значения устанавливаются в ноль. Если массив состоит из строк, то все строки устанавливаются в «» и так далее.

Для динамического массива функция удаления стирает память. То есть она удаляет массив. Если вы хотите использовать его снова, вы должны использовать ReDim для выделения памяти.

Давайте рассмотрим пример статического массива. Этот пример аналогичен примеру ArrayLoops в последнем разделе с одним отличием — мы используем Erase после установки значений. Когда значение будет распечатано, все они будут равны нулю.

Public Sub EraseStatic()

    ' Объявить массив
    Dim arrMarks(0 To 3) As Long

    ' Заполните массив случайными числами
    Dim i As Long
    For i = LBound(arrMarks) To UBound(arrMarks)
        arrMarks(i) = 5 * Rnd
    Next i

    ' ВСЕ ЗНАЧЕНИЯ УСТАНОВЛЕНЫ НА НОЛЬ
    Erase arrMarks

    ' Распечатайте значения - там все теперь ноль
    Debug.Print "Место нахождения", "Значение"
    For i = LBound(arrMarks) To UBound(arrMarks)
        Debug.Print i, arrMarks(i)
    Next i

End Sub

Теперь мы попробуем тот же пример с динамикой. После того, как мы используем Erase, все места в массиве были удалены. Нам нужно использовать ReDim, если мы хотим использовать массив снова.

Если мы попытаемся получить доступ к членам этого массива, мы получим ошибку «Индекс вне диапазона».

Public Sub EraseDynamic()

    ' Объявить массив
    Dim arrMarks() As Long
    ReDim arrMarks(0 To 3)

    ' Заполните массив случайными числами
    Dim i As Long
    For i = LBound(arrMarks) To UBound(arrMarks)
        arrMarks(i) = 5 * Rnd
    Next i

    ' arrMarks теперь освобожден. Места не существуют.
    Erase arrMarks

End Sub

ReDim с Preserve

Если мы используем ReDim для существующего массива, то массив и его содержимое будут удалены.

В следующем примере второй оператор ReDim создаст совершенно новый массив. Исходный массив и его содержимое будут удалены.

Sub UsingRedim()

    Dim arr() As String
    
    ' Установить массив в слоты от 0 до 2
    ReDim arr(0 To 2)
    arr(0) = "Яблоко"
    
    ' Массив с яблоком теперь удален
    ReDim arr(0 To 3)

End Sub

Если мы хотим расширить размер массива без потери содержимого, мы можем использовать ключевое слово Preserve.

Когда мы используем Redim Preserve, новый массив должен начинаться с того же начального размера, например мы не можем сохранить от (0 до 2) до (от 1 до 3) или до (от 2 до 10), поскольку они являются различными начальными размерами.

В следующем коде мы создаем массив с использованием ReDim, а затем заполняем массив типами фруктов.

Затем мы используем Preserve для увеличения размера массива, чтобы не потерять оригинальное содержимое.

Sub UsingRedimPreserve()

    Dim arr() As String
    
    ' Установить массив в слоты от 0 до 1
    ReDim arr(0 To 2)
    arr(0) = "Яблоко"
    arr(1) = "Апельсин"
    arr(2) = "Груша"
    
    ' Изменение размера и сохранение исходного содержимого
    ReDim Preserve arr(0 To 5)

End Sub

Из приведенных ниже снимков экрана видно, что исходное содержимое массива было «сохранено».

Предостережение: в большинстве случаев вам не нужно изменять размер массива, как мы делали в этом разделе. Если вы изменяете размер массива несколько раз, то вам захочется рассмотреть возможность использования коллекции.

Использование Preserve с 2-мерными массивами

Preserve работает только с верхней границей массива.

Например, если у вас есть двумерный массив, вы можете сохранить только второе измерение, как показано в следующем примере:

Sub Preserve2D()

    Dim arr() As Long
    
    ' Установите начальный размер
    ReDim arr(1 To 2, 1 To 5)
    
    ' Изменить размер верхнего измерения
    ReDim Preserve arr(1 To 2, 1 To 10)

End Sub

Если мы попытаемся использовать Preserve на нижней границе, мы получим ошибку «Индекс вне диапазона».

В следующем коде мы используем Preserve для первого измерения. Запуск этого кода приведет к ошибке «Индекс вне диапазона»:

Sub Preserve2DError()

    Dim arr() As Long
    
    ' Установите начальный размер
    ReDim arr(1 To 2, 1 To 5)
    
    ' Ошибка «Вне диапазона»
    ReDim Preserve arr(1 To 5, 1 To 5)

End Sub

Когда мы читаем из диапазона в массив, он автоматически создает двумерный массив, даже если у нас есть только один столбец.

Применяются те же правила сохранения. Мы можем использовать Preserve только на верхней границе, как показано в следующем примере:

Sub Preserve2DRange()

    Dim arr As Variant
    
    ' Назначить диапазон массиву
    arr = Sheet1.Range("A1:A5").Value
    
    ' Preserve будет работать только на верхней границе
    ReDim Preserve arr(1 To 5, 1 To 7)

End Sub

Сортировка массива

В VBA нет функции для сортировки массива. Мы можем отсортировать ячейки листа, но это медленно, если данных много.

Функция быстрой сортировки ниже может использоваться для сортировки массива.

Sub QuickSort(arr As Variant, first As Long, last As Long)
  
  Dim vCentreVal As Variant, vTemp As Variant
  
  Dim lTempLow As Long
  Dim lTempHi As Long
  lTempLow = first
  lTempHi = last
  
  vCentreVal = arr((first + last) / 2)
  Do While lTempLow <= lTempHi
  
    Do While arr(lTempLow) < vCentreVal And lTempLow < last
      lTempLow = lTempLow + 1
    Loop
    
    Do While vCentreVal < arr(lTempHi) And lTempHi > first
      lTempHi = lTempHi - 1
    Loop
    
    If lTempLow <= lTempHi Then
    
        ' Поменять значения
        vTemp = arr(lTempLow)

        arr(lTempLow) = arr(lTempHi)
        arr(lTempHi) = vTemp
      
        ' Перейти к следующим позициям
        lTempLow = lTempLow + 1
        lTempHi = lTempHi - 1
      
    End If
    
  Loop
  
  If first < lTempHi Then QuickSort arr, first, lTempHi
  If lTempLow < last Then QuickSort arr, lTempLow, last
  
End Sub

Вы можете использовать эту функцию так:

Sub TestSort()

    ' Создать временный массив
    Dim arr() As Variant
    arr = Array("Банан", "Дыня", "Персик", "Слива", "Яблоко")
  
    ' Сортировать массив
    QuickSort arr, LBound(arr), UBound(arr)

    ' Печать массива в Immediate Window(Ctrl + G)
    Dim i As Long
    For i = LBound(arr) To UBound(arr)
        Debug.Print arr(i)
    Next i

End Sub

Передача массива в Sub или функцию

Иногда вам нужно будет передать массив в процедуру. Вы объявляете параметр, используя круглые скобки, аналогично тому, как вы объявляете динамический массив.

Переход к процедуре с использованием ByRef означает, что вы передаете ссылку на массив. Таким образом, если вы измените массив в процедуре, он будет изменен, когда вы вернетесь.

Примечание. Когда вы используете массив в качестве параметра, он не может использовать ByVal, он должен использовать ByRef. Вы можете передать массив с помощью ByVal, сделав параметр вариантом.

' Передает массив в функцию
Public Sub PassToProc()
    Dim arr(0 To 5) As String
    ' Передать массив в функцию
    UseArray arr
End Sub

Public Function UseArray(ByRef arr() As String)
    ' Использовать массив
    Debug.Print UBound(arr)
End Function

Возвращение массива из функции

Важно помнить следующее. Если вы хотите изменить существующий массив в процедуре, вы должны передать его как параметр, используя ByRef (см. Последний раздел). Вам не нужно возвращать массив из процедуры.

Основная причина возврата массива — это когда вы используете процедуру для создания нового. В этом случае вы присваиваете возвращаемый массив массиву в вызывающей программе. Этот массив не может быть уже выделен. Другими словами, вы должны использовать динамический массив, который не был выделен.

Следующие примеры показывают это:

Public Sub TestArray()

    ' Объявить динамический массив - не выделен
    Dim arr() As String
    ' Возврат нового массива
    arr = GetArray

End Sub

Public Function GetArray() As String()

    ' Создать и выделить новый массив
    Dim arr(0 To 5) As String
    ' Возвращаемый массив
    GetArray = arr

End Function

Двумерные массивы

Массивы, на которые мы смотрели до сих пор, были одномерными. Это означает, что массивы представляют собой один список элементов.

Двумерный массив — это список списков. Если вы думаете об одной строке электронной таблицы как об одном измерении, то более одного столбца является двухмерным. На самом деле электронная таблица является эквивалентом двумерного массива. Он имеет два измерения — строки и столбцы.

Следует отметить одну маленькую вещь: Excel обрабатывает одномерный массив как строку, если вы записываете его в электронную таблицу. Другими словами, массив arr (от 1 до 5) эквивалентен arr (от 1 до 1, от 1 до 5) при записи значений в электронную таблицу.

На следующем рисунке показаны две группы данных. Первый — это одномерный массив, а второй — двухмерный.

Чтобы получить доступ к элементу в первом наборе данных (одномерном), все, что вам нужно сделать, это дать строку, например. 1,2, 3 или 4.

Для второго набора данных (двумерного) вам нужно указать строку И столбец. Таким образом, вы можете думать, что 1-мерное — это несколько столбцов, а одна строка и двухмерное — это несколько строк и несколько столбцов.

Примечание. В массиве может быть более двух измерений. Это редко требуется. Если вы решаете проблему с помощью 3+-мерного массива, то, вероятно, есть лучший способ сделать это.

Вы объявляете двумерный массив следующим образом:

Dim ArrayMarks(0 To 2, 0 To 3) As Long

В следующем примере создается случайное значение для каждого элемента в массиве и печатается значение в Immediate Window.

Public Sub TwoDimArray()

    ' Объявить двумерный массив
    Dim arrMarks(0 To 3, 0 To 2) As String

    ' Заполните массив текстом, состоящим из значений i и j
    Dim i As Long, j As Long
    For i = LBound(arrMarks) To UBound(arrMarks)
        For j = LBound(arrMarks, 2) To UBound(arrMarks, 2)
            arrMarks(i, j) = CStr(i) &amp; ":" &amp; CStr(j)
        Next j
    Next i

    ' Вывести значения в массиве в Immediate Window
    Debug.Print "i", "j", "Знаечние"
    For i = LBound(arrMarks) To UBound(arrMarks)
        For j = LBound(arrMarks, 2) To UBound(arrMarks, 2)
            Debug.Print i, j, arrMarks(i, j)
        Next j
    Next i

End Sub

Видите, что мы используем второй цикл For внутри первого цикла, чтобы получить доступ ко всем элементам.

Результат примера выглядит следующим образом:

Этот макрос работает следующим образом:

Входит в цикл i
i установлен на 0
цикл Enters j
j установлен на 0
j установлен в 1
j установлен на 2
Выход из цикла j
i установлен в 1
j установлен на 0
j установлен в 1
j установлен на 2
И так до тех пор, пока i = 3 и j = 2

Заметьте, что LBound и UBound имеют второй аргумент 2. Это указывает, что это верхняя или нижняя граница второго измерения. Это начальное и конечное местоположение для j. Значение по умолчанию 1, поэтому нам не нужно указывать его для цикла i.

Использование цикла For Each

Использование For Each лучше использовать при чтении из массива.
Давайте возьмем код сверху, который выписывает двумерный массив.

 ' Для цикла For необходимо два цикла
    Debug.Print "i", "j", "Значение"
    For i = LBound(arrMarks) To UBound(arrMarks)
        For j = LBound(arrMarks, 2) To UBound(arrMarks, 2)
            Debug.Print i, j, arrMarks(i, j)
        Next j
    Next i

Теперь давайте перепишем его, используя цикл For Each. Как видите, нам нужен только один цикл, и поэтому гораздо проще написать:

 ' Использование For Each требует только одного цикла
    Debug.Print "Значение"
    Dim mark As Variant
    For Each mark In arrMarks
        Debug.Print mark
    Next mark

Использование цикла For Each дает нам массив только в одном порядке — от LBound до UBound. В большинстве случаев это все, что вам нужно.

Чтение из диапазона ячеек в массив

Если вы читали мою статью о ячейках и диапазонах, то вы знаете, что VBA имеет чрезвычайно эффективный способ чтения из диапазона ячеек в массив и наоборот.

Public Sub ReadToArray()

    ' Объявить динамический массив
    Dim StudentMarks As Variant

    ' Считать значения в массив из первой строки
    StudentMarks = Range("A1:Z1").Value

    ' Запишите значения обратно в третий ряд
    Range("A3:Z3").Value = StudentMarks

End Sub

Динамический массив, созданный в этом примере, будет двухмерным массивом. Как видите, мы можем прочитать весь диапазон ячеек в массив всего за одну строку.

В следующем примере будут считаны примеры данных студента ниже из C3: E6 Лист1 и распечатаны в Immediate Window.

Public Sub ReadAndDisplay()

    ' Получить диапазон
    Dim rg As Range
    Set rg = ThisWorkbook.Worksheets("Лист1").Range("C3:E6")

    ' Создать динамический массив
    Dim StudentMarks As Variant

    ' Считать значения в массив из листа 1
    StudentMarks = rg.Value

    ' Вывести значения массива
    Debug.Print "i", "j", "Значение"
    Dim i As Long, j As Long
    For i = LBound(StudentMarks) To UBound(StudentMarks)
        For j = LBound(StudentMarks, 2) To UBound(StudentMarks, 2)
            Debug.Print i, j, StudentMarks(i, j)
        Next j
    Next i

End Sub

Как видите, первое измерение (доступное через i) массива — это строка, а второе — столбец. Чтобы продемонстрировать это, взглянем на значение 44 в Е4 данных образца. Это значение находится в строке 2 столбца 3 наших данных. Вы можете видеть, что 44 хранится в массиве в StudentMarks (2,3).

Как заставить ваши макросы работать на суперскорости

Если ваши макросы работают очень медленно, этот раздел будет очень полезным. Особенно, если вы имеете дело с большими объемами данных. В VBA это держится в секрете.

Обновление значений в массивах происходит экспоненциально быстрее, чем обновление значений в ячейках.

В последнем разделе вы увидели, как мы можем легко читать из группы ячеек в массив и наоборот. Если мы обновляем много значений, то мы можем сделать следующее

Скопируйте данные из ячеек в массив.
Измените данные в массиве.
Скопируйте обновленные данные из массива обратно в ячейки.

Например, следующий код будет намного быстрее, чем код ниже:

Public Sub ReadToArray()

    ' Считать значения в массив из первой строки
    Dim StudentMarks  As Variant
    StudentMarks = Range("A1:Z20000").Value

    Dim i As Long
    For i = LBound(StudentMarks) To UBound(StudentMarks)
        ' Обновление отметок здесь
        StudentMarks(i, 1) = StudentMarks(i, 1) * 2
        '...
    Next i

    ' Запишите новые значения обратно на лист
    Range("A1:Z20000").Value = StudentMarks

End Sub

Sub UsingCellsToUpdate()
    
    Dim c As Variant
    For Each c In Range("A1:Z20000")
        c.Value = ' Обновите значения здесь
    Next c
    
End Sub

Назначение из одного набора ячеек в другой также намного быстрее, чем с помощью копирования и вставки.

' Назначение - быстрее
Range("A1:A10").Value = Range("B1:B10").Value

' Копировать Вставить - медленнее
Range("B1:B1").Copy Destination:=Range("A1:A10")

Заключение

Ниже приводится краткое изложение основных моментов этой статьи.

Массивы — это эффективный способ хранения списка элементов одного типа.
Вы можете получить доступ к элементу массива напрямую, используя номер местоположения, который известен как индекс.
Распространенная ошибка «Индекс вне диапазона» вызвана доступом к несуществующему местоположению.
Существует два типа массивов: статический и динамический.
Статический используется, когда размер массива всегда одинаков.
Динамические массивы позволяют вам определять размер массива во время выполнения.
LBound и UBound обеспечивают безопасный способ поиска самых маленьких и самых больших подписок массива.
Основной массив является одномерным. Есть еще многомерные массивы.
Чтобы только передать массив в процедуру, используйте ByRef. Вы делаете это так: ByRef arr() as long.
Вы можете вернуть массив из функции, но массив, которому он назначен, не должен быть выделен в данный момент.
Рабочий лист с его строками и столбцами по сути является двумерным массивом.
Вы можете читать непосредственно из диапазона листа в двухмерный массив всего за одну строку кода.
Вы также можете записать из двумерного массива в диапазон всего за одну строку кода.

Массивы в VBA: как работать с массивами

Мы очень хорошо знаем, что переменная является контейнером для хранения значения. Иногда разработчики могут удерживать более одного значения в одной переменной за раз. Когда ряд значений хранится в одной переменной, он известен как переменная массива.

Объявление массивов

Массивы объявляются так же, как объявлена переменная, за исключением того, что объявление переменной массива использует скобки. В следующем примере размер массива указан в скобках.

'Method 1 : Using DimDim arr1()	'Without Size'Method 2 : Mentioning the SizeDim arr2(5)  'Declared with size of 5'Method 3 : using 'Array' ParameterDim arr3arr3 = Array("apple","Orange","Grapes")

Хотя размер массива указывается как 5, он может содержать 6 значений, поскольку индекс массива начинается с ZERO.

Индекс массива не может быть отрицательным.

Массивы VBScript могут хранить любой тип переменной в массиве. Следовательно, массив может хранить целое число, строку или символы в одной переменной массива.

Назначение значений массиву

Значения присваиваются массиву, указывая значение индекса массива для каждого из назначаемых значений. Это может быть строка.

Пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   Dim arr(5)   arr(0) = "1"           'Number as String   arr(1) = "VBScript"    'String   arr(2) = 100 		   'Number   arr(3) = 2.45 		   'Decimal Number   arr(4) = #10/07/2013#  'Date   arr(5) = #12.45 PM#    'Time     msgbox("Value stored in Array index 0 : " & arr(0))   msgbox("Value stored in Array index 1 : " & arr(1))   msgbox("Value stored in Array index 2 : " & arr(2))   msgbox("Value stored in Array index 3 : " & arr(3))   msgbox("Value stored in Array index 4 : " & arr(4))   msgbox("Value stored in Array index 5 : " & arr(5))End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

Value stored in Array index 0 : 1
Value stored in Array index 1 : VBScript
Value stored in Array index 2 : 100
Value stored in Array index 3 : 2.45
Value stored in Array index 4 : 7/10/2013
Value stored in Array index 5 : 12:45:00 PM

Многомерные массивы

Массивы не ограничиваются одним измерением, однако они могут иметь максимум 60 измерений. Двумерными массивами являются наиболее часто используемые.

пример

В следующем примере многомерный массив объявляется с тремя строками и четырьмя столбцами.

Private Sub Constant_demo_Click()   Dim arr(2,3) as Variant	' Which has 3 rows and 4 columns   arr(0,0) = "Apple"    arr(0,1) = "Orange"   arr(0,2) = "Grapes"              arr(0,3) = "pineapple"    arr(1,0) = "cucumber"              arr(1,1) = "beans"              arr(1,2) = "carrot"              arr(1,3) = "tomato"              arr(2,0) = "potato"                arr(2,1) = "sandwitch"               arr(2,2) = "coffee"                arr(2,3) = "nuts"                          msgbox("Value in Array index 0,1 : " &  arr(0,1))   msgbox("Value in Array index 2,2 : " &  arr(2,2))End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

Value stored in Array index : 0 , 1 : Orange
Value stored in Array index : 2 , 2 : coffee

Объявление ReDim

Оператор ReDim используется для объявления переменных динамического массива и распределения или перераспределения пространства для хранения.

Синтаксис
ReDim [Preserve] varname(subscripts) [, varname(subscripts)]
Параметр Описание

Preserve — необязательный параметр, используемый для сохранения данных в существующем массиве при изменении размера последнего измерения.

Varname — обязательный параметр, который обозначает имя переменной, которое должно соответствовать стандартным соглашениям об именах.

Subscript — требуемый параметр, который указывает размер массива.

пример

В следующем примере массив был переопределен, а затем значения сохранялись при изменении существующего размера массива.

Примечание. При изменении размера массива, меньшего, чем это было первоначально, данные в устраненных элементах будут потеряны.

Private Sub Constant_demo_Click()   Dim a() as variant   i = 0   redim a(5)   a(0) = "XYZ"   a(1) = 41.25   a(2) = 22     REDIM PRESERVE a(7)   For i = 3 to 7   a(i) = i   Next     'to Fetch the output   For i = 0 to ubound(a)      Msgbox a(i)   NextEnd Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

XYZ
41.25
22
3
4
5
6
7

Методы массива

В VBScript есть встроенные функции, которые помогают разработчикам эффективно обрабатывать массивы. Все методы, которые используются вместе с массивами, перечислены ниже. Чтобы узнать об этом, нажмите на имя метода.

Функции для работы с массивами

LBound

Функция LBound возвращает наименьший индекс указанного массива.Следовательно, LBound массива — ZERO.

Синтаксис
LBound(ArrayName[,dimension])
Параметы и Описание

ArrayName — обязательный параметр. Этот параметр соответствует имени массива.

Размер — необязательный параметр. Это принимает целочисленное значение, соответствующее размеру массива. Если это «1», то он возвращает нижнюю границу первого измерения;если это «2», то он возвращает нижнюю границу второго измерения и так далее.

пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   Dim arr(5) as Variant   arr(0) = "1"           'Number as String   arr(1) = "VBScript     'String   arr(2) = 100           'Number   arr(3) = 2.45          'Decimal Number   arr(4) = #10/07/2013#  'Date   arr(5) = #12.45 PM#    'Time   msgbox("The smallest Subscript value of  the given array is : " & LBound(arr))   ' For MultiDimension Arrays :   Dim arr2(3,2) as Variant   msgbox("The smallest Subscript of the first dimension of arr2 is : " & LBound(arr2,1))   msgbox("The smallest Subscript of the Second dimension of arr2 is : " & LBound(arr2,2))End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

The smallest Subscript value of the given array is : 0
The smallest Subscript of the first dimension of arr2 is : 0
The smallest Subscript of the Second dimension of arr2 is : 0

Функция, которая возвращает целое число, соответствующее наименьшему индексу данных массивов.

UBound

Функция UBound возвращает наибольший индекс указанного массива.Следовательно, это значение соответствует размеру массива.

Синтаксис
UBound(ArrayName[,dimension])
Параметры и Описание

ArrayName — обязательный параметр. Этот параметр соответствует имени массива.

Размер — необязательный параметр. Это принимает целочисленное значение, соответствующее размеру массива. Если это «1», то он возвращает нижнюю границу первого измерения;если он равен «2», то он возвращает нижнюю границу второго измерения и т. д.

пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   Dim arr(5) as Variant   arr(0) = "1"           'Number as String   arr(1) = "VBScript     'String   arr(2) = 100           'Number   arr(3) = 2.45          'Decimal Number   arr(4) = #10/07/2013#  'Date   arr(5) = #12.45 PM#    'Time   msgbox("The smallest Subscript value of  the given array is : " & UBound(arr))   ' For MultiDimension Arrays :   Dim arr2(3,2) as Variant   msgbox("The smallest Subscript of the first dimension of arr2 is : " & UBound(arr2,1))   msgbox("The smallest Subscript of the Second dimension of arr2 is : " & UBound(arr2,2))End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

The Largest Subscript value of the given array is : 5
The Largest Subscript of the first dimension of arr2 is : 3
The Largest Subscript of the Second dimension of arr2 is : 2

Функция, которая возвращает целое число, соответствующее самому большому индексу данных массивов.

Split

Функция Split возвращает массив, который содержит определенное количество значений, разделенных на основе разделителя.

Синтаксис
Split(expression [,delimiter[, count[, compare]]])
Параметры и Описание

Выражение — требуемый параметр. Строковое выражение, которое может содержать строки с разделителями.

Разделитель — необязательный параметр. Параметр, который используется для преобразования в массивы на основе разделителя.

Count — необязательный параметр. Количество подстрок, которые нужно вернуть, и если указано как -1, то возвращаются все подстроки.

Compare — Необязательный параметр. Этот параметр указывает, какой метод сравнения следует использовать.

0 = vbBinaryCompare — выполняет двоичное сравнение

1 = vbTextCompare — выполняет текстовое сравнение

пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   ' Splitting based on delimiter comma '$'   Dim a as Variant   Dim b as Variant      a = Split("Red $ Blue $ Yellow","$")   b = ubound(a)      For i = 0 to b      msgbox("The value of array in " & i & " is :"  & a(i))   NextEnd Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

The value of array in 0 is :Red
The value of array in 1 is : Blue
The value of array in 2 is : Yellow

Функция, которая возвращает массив, содержащий указанное количество значений. Разделить на разделитель.

Join

Это функция, которая возвращает строку, содержащую указанное количество подстрок в массиве. Это полная противоположная функция метода разделения.

Синтаксис
Join(List[,delimiter])
Параметры и Описание

Список — требуемый параметр. Массив, содержащий подстроки, которые должны быть соединены.

Разделитель — необязательный параметр. Символ, который используется как разделитель при возврате строки. По умолчанию разделителем является Space.

пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   ' Join using spaces   a = array("Red","Blue","Yellow")   b = join(a)   msgbox("The value of b " & " is :"  & b)     ' Join using $   b = join(a,"$")   msgbox("The Join result after using delimiter is : " & b)End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

The value of b is :Red Blue Yellow
The Join result after using delimiter is : Red$Blue$Yellow

Функция, которая возвращает строку, содержащую указанное количество подстрок в массиве. Это полная противоположная функция метода разделения.

Filter

Функция фильтра, которая возвращает массив на основе нуля, который содержит подмножество массива строк на основе определенных критериев фильтра.

Синтаксис
Filter(inputstrings, value[, include [,compare]])
Параметры и Описание

Inputstrings — обязательный параметр. Этот параметр соответствует массиву строк для поиска.

Значение — требуемый параметр. Этот параметр соответствует строке для поиска по параметру inputstrings.

Include — необязательный параметр. Это логическое значение, которое указывает, следует ли возвращать подстроки, которые включают или исключают.

Compare — Необязательный параметр. Этот параметр описывает, какой метод сравнения строк должен использоваться.

0 = vbBinaryCompare — выполняет двоичное сравнение

1 = vbTextCompare — выполняет текстовое сравнение

пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   Dim a,b,c,d as Variant   a = array("Red","Blue","Yellow")   b = Filter(a,"B")   c = Filter(a,"e")   d = Filter(a,"Y")     For each x in b      msgbox("The Filter result 1: " & x)   Next     For each y in c      msgbox("The Filter result 2: " & y)   Next     For each z in d      msgbox("The Filter result 3: " & z)   NextEnd Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.p
The Filter result 1: Blue
The Filter result 2: Red
The Filter result 2: Blue
The Filter result 2: Yellow
The Filter result 3: Yellow

Функция, которая возвращает массив с нулевым основанием, который содержит подмножество массива строк на основе определенных критериев фильтра.

IsArray

Функция IsArray возвращает логическое значение, указывающее, является ли указанная входная переменная переменной или переменной NOT переменной массива.

Синтаксис
IsArray(variablename)
пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   Dim a,b as Variant   a = array("Red","Blue","Yellow")   b = "12345"     msgbox("The IsArray result 1 : " & IsArray(a))   msgbox("The IsArray result 2 : " & IsArray(b))End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

The IsArray result 1 : True
The IsArray result 2 : False

Функция, возвращающая логическое значение, указывающее, является ли входная переменная массивом.

Erase

Функция Erase используется для сброса значений массивов фиксированного размера и освобождения памяти динамических массивов.Он ведет себя в зависимости от типа массивов.

Синтаксис
Erase ArrayName

Фиксированный числовой массив, каждый элемент в массиве сбрасывается до нуля.

Исправлен строковый массив, каждый элемент в массиве сбрасывается до нулевой длины «».

Массив объектов, каждый элемент в массиве сбрасывается до специального значения Nothing.

пример

Добавьте кнопку и добавьте следующую функцию.

Private Sub Constant_demo_Click()   Dim NumArray(3)   NumArray(0) = "VBScript"   NumArray(1) = 1.05   NumArray(2) = 25   NumArray(3) = #23/04/2013#     Dim DynamicArray()   ReDim DynamicArray(9)   ' Allocate storage space.     Erase NumArray          ' Each element is reinitialized.   Erase DynamicArray      ' Free memory used by array.     ' All values would be erased.   msgbox("The value at Zeroth index of NumArray is " & NumArray(0))   msgbox("The value at First index of NumArray is " & NumArray(1))   msgbox("The value at Second index of NumArray is " & NumArray(2))   msgbox("The value at Third index of NumArray is " & NumArray(3))End Sub

Когда вы выполняете вышеуказанную функцию, она производит следующий вывод.

The value at Zeroth index of NumArray is
The value at First index of NumArray is
The value at Second index of NumArray is
The value at Third index of NumArray is

Функция, которая восстанавливает выделенную память для переменных массива.

С уважением, авторы сайта Компьютерапия

Понравилась статья? Поделитесь ею с друзьями и напишите отзыв в комментариях!

Использование массивов (VBA) | Microsoft Docs

12/26/2018

Чтение занимает 2 мин

В этой статье

Можно объявить массив для работы с набором значений одного типа данных.You can declare an array to work with a set of values of the same data type. Массив представляет собой одиночную переменную с множеством ячеек для хранения значений, тогда как типовая переменная имеет только одну ячейку хранилища, в которой может храниться только одно значение.An array is a single variable with many compartments to store values, while a typical variable has only one storage compartment in which it can store only one value. Следует обращаться к массиву как одному целому, когда необходимо сослаться на все значения, хранящиеся в нем, или можно обращаться к отдельным элементам.Refer to the array as a whole when you want to refer to all the values it holds, or you can refer to its individual elements.

Например, чтобы хранить ежедневные расходы по каждому дню года, можно объявить одну переменную массива с 365 элементами, а не объявлять 365 переменных.For example, to store daily expenses for each day of the year, you can declare one array variable with 365 elements, rather than declaring 365 variables. Каждый элемент массива содержит одно значение.Each element in an array contains one value. В приведенном ниже операторе объявляется переменная массива с элементами 365.The following statement declares the array variable with 365 elements. По умолчанию массив индексируется, начиная с нуля, так что верхняя граница массива равна 364, а не 365.By default, an array is indexed beginning with zero, so the upper bound of the array is 364 rather than 365.

Dim curExpense(364) As Currency

Чтобы установить значение отдельного элемента, указывается индекс этого элемента.To set the value of an individual element, you specify the element’s index. В следующем примере каждому элементу массива присваивается начальное значение, равное 20.The following example assigns an initial value of 20 to each element in the array.

Sub FillArray() 
 Dim curExpense(364) As Currency 
 Dim intI As Integer 
 For intI = 0 to 364 
 curExpense(intI) = 20 
 Next 
End Sub

Изменение нижней границыChanging the lower bound

С помощью оператора Option Base в верхней части модуля можно изменить индекс по умолчанию для первого элемента с 0 на 1.You can use the Option Base statement at the top of a module to change the default index of the first element from 0 to 1. В следующем примере оператор Option Base изменяет индекс для первого элемента, а оператор Dim объявляет переменную массива с элементами 365.In the following example, the Option Base statement changes the index for the first element, and the Dim statement declares the array variable with 365 elements.

Option Base 1 
Dim curExpense(365) As Currency

Можно также в явном виде установить нижнюю границу массива, используя выражение To, как показано в следующем примере.You can also explicitly set the lower bound of an array by using a To clause, as shown in the following example.

Dim curExpense(1 To 365) As Currency 
Dim strWeekday(7 To 13) As String

Хранение значений Variant в массивахStoring Variant values in arrays

Существует два способа создания массивов значений Variant .There are two ways to create arrays of Variant values. Один способ — объявление массива с типом данных Variant, как показано в следующем примере:One way is to declare an array of Variant data type, as shown in the following example:

Dim varData(3) As Variant 
varData(0) = "Claudia Bendel" 
varData(1) = "4242 Maple Blvd" 
varData(2) = 38 
varData(3) = Format("06-09-1952", "General Date")

Другой способ — присвоение массива, возвращаемого функцией Array, переменной Variant, как показано в следующем примере.The other way is to assign the array returned by the Array function to a Variant variable, as shown in the following example.

Dim varData As Variant 
varData = Array("Ron Bendel", "4242 Maple Blvd", 38, _ 
Format("06-09-1952", "General Date"))

Независимо от способа создания массива элементы в массиве значений Variant идентифицируют по индексу.You identify the elements in an array of Variant values by index, no matter which technique you use to create the array. Например, в любом из предыдущих примеров может быть добавлен следующий оператор.For example, the following statement can be added to either of the preceding examples.

MsgBox "Data for " & varData(0) & " has been recorded."

Использование многомерных массивовUsing multidimensional arrays

В Visual Basic допускается объявлять массивы с 60 размерностями, максимум.In Visual Basic, you can declare arrays with up to 60 dimensions. Например, следующий оператор объявляет 2-мерный массив 5 на 10.For example, the following statement declares a 2-dimensional, 5-by-10 array.

Dim sngMulti(1 To 5, 1 To 10) As Single

Если рассматривать массив как матрицу, первый аргумент представляет строки, а второй аргумент представляет столбцы.If you think of the array as a matrix, the first argument represents the rows and the second argument represents the columns.

Используйте вложенные для… Next для обработки многомерных массивов.Use nested For…Next statements to process multidimensional arrays. Следующая процедура позволяет заполнить двумерный массив значениями Single.The following procedure fills a two-dimensional array with Single values.

Sub FillArrayMulti() 
 Dim intI As Integer, intJ As Integer 
 Dim sngMulti(1 To 5, 1 To 10) As Single 
 
 ' Fill array with values. 
 For intI = 1 To 5 
 For intJ = 1 To 10 
 sngMulti(intI, intJ) = intI * intJ 
 Debug.Print sngMulti(intI, intJ) 
 Next intJ 
 Next intI 
End Sub

См. такжеSee also

Поддержка и обратная связьSupport and feedback

Массивы в VBA — Макросы и программы VBA — Excel — Каталог статей

Содержание:

Зачем нужны массивы

Массивы очень упрощают процесс программирования. Без них практически невозможно написать универсальную программу. Например, представьте себе, что вы манипулируете информацией о квартирах жилого дома. Вы объявляете переменные K1 — для первой квартиры, K2 — для второй и так далее. K1=54 будет означать, что площадь первой квартиры 54 кв.м., К2=72 и т.д. Теперь представим, что нам надо подсчитать общую площадь всех квартир в доме. Очевидно, что это что-то типа Total_S = K1+K2+…+Kn. В одном доме у нас 36 квартир, а в другом 144. Представляете бредовость процесса подобного программирования? Если в первом случае я должен буду использовать 36 отдельных переменных для вычисления общей площади, то для второго дома уже 144. Очень быстро вы придёте к мысли, что вам нужна переменная, состоящая из нумерованных ячеек. Тогда обретают смысл все те операторы циклов, входящие в состав любого языка программирования. Но об этом чуть позже…

▲ вверх

Что такое массив

Массив — переменная, состоящая из некоторого количества однотипных элементов. У массива, как и у любой другой переменной, есть имя. А доступ к конкретному элементу массива осуществляется через указание в скобках после имени его индекса. Например, A(5) означает, что я обращаюсь к элементу с индексом 5 массива, имеющего имя A.

▲ вверх

Типы массивов

Массивы в VBA и во многих других языках программирования делятся на 2 класса:

Фиксированные массивы. Такие массивы состоят из заранее известного количества элементов. Это количество определяется во время объявления массива и уже не может быть изменено в процессе его жизненного цикла. Вы, конечно же, сможете использовать меньшее количество элементов, но не существует способа увеличить количество элементов сверх объявленного.
Динамические массивы. Эти массивы можно «переобъявлять» в процессе жизненного цикла. То есть мы можем управлять количеством элементов динамических масивов в зависимости от наших потребностей. Это очень удобно, так как в подавляющем большинстве случаев программист не может заранее знать, с каким объёмом данных он столкнётся. Если вы собираетесь писать более-менее универсальные программы, то этот тип массивов определенно стоит изучить.

▲ вверх

Объявление массивов

Объявление фиксированных массивов

Рекомендация: при объявлении массивов VBA я советую вам давать всем именам префикс «arr». Я сторонник венгерской нотации.

Как мы видим, тут объявлено 2 одномерных массива arrTemp и arrTest. Одномерные массивы в программировании также часто называют векторами. Типом элементов первого массива является Long, второго массива — String. В этом типе синтаксиса в скобках указан максимальный индекс (верхняя граница ) элемента массива. А что насчёт минимального индекса (нижней границы) массива? По-умолчанию минимальным индексом является ноль. В данном случае стандартное поведение интерпретатора языка VBA можно изменить при помощи оператора option base {0|1}. Option base 1 заставляет VBA считать нижней границей массива — единицу, а не ноль.

Таким образом, по-умолчанию массив arrTemp имеет 11 элементов — от 0 до 10. Но, если в начало модуля, в котором этот массив объявляется, вставить оператор Option Base 1, то массив arrTemp будет иметь 10 элементов — от 1 до 10.

Помимо вышеуказанного вы вправе использовать следующий синтаксис, который НЕ зависит от option base {0|1}:

таким образом вы в явном виде указываете и нижнюю, и верхнюю границы. Как видите, нижняя граница совершенно не обязательно должна начинаться с 0 или 1. Более того, индексы границ могут принимать и отрицательные значения, главное чтобы нижняя была меньше верхней.

Помимо одномерных массивов, можно объявлять и массивы с размерностью больше единицы.

arrMulti — двумерный массив, а arrData3 — трёхмерный. Первый содержит 11*31=341 элемент, второй — 2*3*10=60 элементов. Теоретически допускается объявлять до 60 размерностей массива.

Какие типы данных могут стать элементами массива? Тут всё, как в шутке про фамилию еврея, — абсолютно любой тип данных годится на роль элемента массива, включая объектные типы, User Data Type, другие массивы (через тип Variant). Если вы не указываете при объявлении тип данных массива, то предполагается, что этим типом является тип Variant.

▲ вверх

Объявление динамических массивов

Динамические массивы объявляться так:

Однако, использовать их после такого объявления пока ещё нельзя. Необходимо выделить память под массив. Особенность работы с динамическим массивом как раз состоит в том, что программист отвечает за его своевременное расширение (усечение) в памяти. Для этого существует специальный оператор, который имеет следующий синтаксис:

ReDim [Preserve] varname(subscripts) [As Type]

Например:

После этого оператора, вы можете использовать элементы массива arrOpen с 0-го по 5-й. Всё, что мы говорили про оператор option base и нижнюю границу, верно и для динамических массивов. Предположим, что вы сохранили информацию в элементах 0-5 и у вас поспела новая порция информации для элементов 6-11. Чтобы разместить в данном массиве новые элементы и не потерять старые, вы должны сделать следующее:

то есть мы тут увеличиваем верхнюю границу массива и используем ключевое слово Preserve, чтобы во время этой операции не потерять текущее содержимое arrOpen, так как в противном случае (без слова Preserve) массив будет расширен, а память заполнена нулями. Вы также вправе вообще не декларировать массив оператором Dim, а сделать это впервые через ReDim и там же указать лип элементов. Но, если вы в первом ReDim (или Dim) указали определенный тип элементов, то в последующих операторах ReDim этот тип переопределён быть не может — возникнет ошибка на этапе компиляции проекта.

▲ вверх

Изменение элементов массива

Пора бы нам уже научиться пользоваться нашими массивами — то есть записывать информацию в их элементы и считывать её оттуда. Это довольно просто:

Как и с обычными переменными запись информации в элемент массива происходит через оператор присваивания (=), но указанием индекса элемента массива.

▲ вверх

Чтение элементов массива

▲ вверх

Определение границ массива

В подпрограммах часто приходится иметь дело с массивами, которые переданы вам в качестве параметра (как это сделать показано ниже), поэтому в этом случае очень актуален вопрос определения нижней и верхней границ индекса массива. Для этого в языке предусмотрены 2 функции: LBound и UBound. Первая возвращает нижнюю границу индекса, вторая — верхнюю.

LBound( array [, dimension])

UBound( array [, dimension])

Для одномерных массивов параметр dimension можно не указывать. Для многомерных массивов его указывать необходимо. Кстати, это означает, что, если вы точно не знаете, с каким массивом имеете дело, но необходимо узнать его первую размерность, то лучше использовать вариант UBound(arrTemp,1), а не UBound(arrTemp), так как последний вариант вызовет ошибку, если массив окажется многомерным.

Если вы ошибётесь с указанием правильного индекса массива, то возникнет ошибка периода исполнения с кодом 9. Эта же ошибка возникнет, если вы в функции LBound / UBound укажете несуществующую размерность массива (например, 3 для двумерного массива).

▲ вверх

Перебор элементов массива

Собственно массивы нужны для того, чтобы хранить в них однотипную информацию и перебирать их в цикле. Как правило, алгоритм делает что-то полезное с одним элементом массива, а цикл повторяет эти типовые действия для всех элементов массива.

Наиболее удобный оператор цикла для перебора элементов массива — это безусловно For … Next.

так же есть способ не заботиться об определении нижней и верхней границ, если алгоритм не требует от нас знания текущего индекса массива:

Вы, конечно, можете перебирать массив и в других типах циклов Do … Loop, но, право, смысла и удобства в этом не много. По крайней мере я не сталкивался, кажется, с ситуациями, когда для перебора массива цикл For не подошёл.

▲ вверх

Передача массивов в подпрограммы

Массивы удобнее всего передавать в подпрограммы в виде параметра типа Variant.

Обратите внимание, что функции GetResult в качестве параметра передаются массивы. При чём, в первом случае это массив с типом элементов Long, а во втором — String. За счёт того, что внутри функции используются переменные типа Variant, то сначала функция нам возвращает сумму элементов массива arrIntegers, а во втором результат сложения (конкатенации) строк массива arrStrings. Кроме того, параметр parArray не описан как массив (parArray As Variant), но мы внутри функции GetResult ведём себя с ним, как с массивом (For Each Element In parArray)! Это возможно, так как переменные типа Variant умеют определять, что им присваивается и вести себя далее в соответствии с тем, что они содержат. Если переменной parArray присвоили массив (через вызов функции — строки 17 и 18), то она себя будет вести как массив.

▲ вверх

Массив с элементами типа массив

Продемонстрируем, как можно хранить в качестве элементов массива другие массивы.

Результат отладочной печати:

▲ вверх

Функция Array

Данная функция полезна для создания справочных массивов. Она возвращает переменную типа Variant, содержащую одномерный массив с типом элементов Variant.

Array( arglist )

Вызов функции без параметров приведёт к возврату массива нулевой длинны. При этом будет наблюдаться интересный эффект LBound вернёт вам 0, а UBound вернёт -1, то есть верхняя граница окажется меньше нижней границы.

▲ вверх

Функция Split

Split возвращает одномерный массив, содержащий подстроки, из строкового выражении с учётом указанного разделителя

Split(expression[, delimiter[, limit[, compare]]])

expression — строковое выражение, содержащая подстроки и разделители. Обязательный параметр.
delimiter — текстовый разделитель. Необязательный параметр. Если опущен, то предполагается, что разделителем является символ пробела.
limit — количество подстрок, которое необходимо вернуть. -1 или отсутствие параметра означает, что вернуть надо все подстроки.
compare — константа, указывающая тип сравнения для символов разделителей. 1 — текстовое сравнение (без учёта регистра), 0 — бинарное сравнение (с учётом регистра).

Результат выглядит так:

Если вы в качестве разделителя укажете пустую строку, то на выходе получите массив, состоящий из одного элемента. Кстати, split всегда возвращает массив с нулевой нижней границей вне всякой зависимости от наличия option base 1.

▲ вверх

Нюансы работы с динамическими массивами

Неинициализированный массив

У динамического массива есть такое промежуточное состояние, когда он уже объявлен, но ещё не содержит никаких элементов.

То есть у переменной динамического массива есть такое состояние, когда мы не можем воспользоваться вспомогательными функциями LBound / UBound для определения его (массива) статуса. Это особенно надо учитывать, когда вы пишите подпрограммы, работающие с массивами. Прежде чем работать (перебирать) массив необходимо убедиться, что он проинициализирован, в противном случае программа вылетит с ошибкой 9.

Для этого я предлагаю пользоваться функцией подобной нижеописанной IsNotEmptyArray:

▲ вверх

Расширение массива

Как правило, расширять динамический массив приходится в цикле. Возможны 2 стратегии: расширение на 1 элемент, как только в этом есть необходимость (назовём это эластичным расширением), и расширение авансом, когда вы увеличиваете верхнюю границу скачками, скажем сразу на 100 элементов. Реализовав оба варианта, я для себя сделал вывод, что авансовое расширение получилось и компактнее, и работает быстрее, так как операция расширения, вообще говоря, затратна и, чем реже вызывается, тем лучше.

Результат:

Авансовый метод вышел даже компактнее

▲ вверх

Удаление массива

Существует оператор Erase, который полностью освобождает память из-под динамического массива. Будучи вызванным для статического массива он его обнуляет, а если он строковый, то элементам присваивается пустые строки.

▲ вверх

Получение массива на основе диапазона Excel

Самый эффективный по скорости способ получить содержимое диапазона Excel для манипулирования в VBA — это скопировать его в массив с элементами Variant. Делается так:

Даже, если вы передаёте в массив столбец или строку, получаемый массив всегда будет иметь 2 измерения. Измерение 1 отвечает за строки, измерение 2 — за столбцы. То есть ячейка C5 будет в элементе arrTemp(5,3). Нижняя граница таких массивов всегда будет начинаться с единицы.

▲ вверх

Дополнительные источники

В качестве источника дополнительной информации по массивам я могу порекомендовать замечательный, исчерпывающий ресурс Чарльза Пирсона (Charles H. Pearson). Его сайт следует штудировать всем, кто серьёзно осваивает VBA. Конкретно по массивам там огромное количество готовых подпрограмм для работы с ними, исходные коды, снабженные подробнейшими комментариями, продвинутые объяснения для копающих в глубину. Без преувеличения великолепный ресурс!

▲ вверх

Массивы в Excel VBA — Блог: Управление проектами

В данной статье подробно рассматриваются массивы на языке программирования Excel VBA. Рассматриваются различные вопросы и схемы применения, такие как:

Зачем нужны массивы
Когда нужно применять массивы
Типы массивов
Использования многомерных массивов
Объявление массивов
Добавление значений
Просмотр всех элементов
Эффективный способ чтения диапазонов (Range) в массив

Задача	Статический массив	Динамический массив
Объявление	Dim arr(0 To 5) As Long	Dim arr() As Long Dim arr As Variant
Задать размер	см. выше	ReDim arr(0 To 5)As Variant
Получить размер(количество элементов)	см. функцию ArraySize .	см. функцию ArraySize
Увеличить размер (с сохранением данных)	Только динамический массив	ReDim Preserve arr(0 To 6)
Задать значение	arr(1) = 22	arr(1) = 22
Получить значение	total = arr(1)	total = arr(1)
Первый элемент	LBound(arr)	LBound(arr)
Последний элемент	Ubound(arr)	Ubound(arr)
Прочитать все элементы(1D)	For i = LBound(arr) To UBound(arr) Next i Or For i = LBound(arr,1) To UBound(arr,1) Next i	For i = LBound(arr) To UBound(arr) Next i Or For i = LBound(arr,1) To UBound(arr,1) Next i
Прочитать все элементы(2D)	For i = LBound(arr,1) To UBound(arr,1) For j = LBound(arr,2) To UBound(arr,2) Next j Next i	For i = LBound(arr,1) To UBound(arr,1) For j = LBound(arr,2) To UBound(arr,2) Next j Next i
Прочитать все элементы	Dim item As Variant For Each item In arr Next item	Dim item As Variant For Each item In arr Next item
Передать в процедуру	Sub MySub(ByRef arr() As String)	Sub MySub(ByRef arr() As String)
Вернуть из функции	Function GetArray() As Long() Dim arr(0 To 5) As Long GetArray = arr End Function	Function GetArray() As Long() Dim arr() As Long GetArray = arr End Function
Получить из функции	Только динамические массивы	Dim arr() As Long Arr = GetArray()
Стереть массив	Erase arr *сбрасывает все значения по умолчанию	Erase arr *удаляет массив
Строку в массив	Только динамические массивы	Dim arr As Variant arr = Split(“James:Earl:Jones”,”:”)
Массив в строку	Dim sName As String sName = Join(arr, “:”)	Dim sName As String sName = Join(arr, “:”)
Заполнить значениями	Только динамические массивы	Dim arr As Variant arr = Array(“Значение1”, “Значение2”, “Значение3”)
Диапазон в массив	Только динамические массивы	Dim arr As Variant arr = Range(“A1:D2”)
Массив в диапазон	также как в динамическом массиве	Dim arr As Variant Range(“A5:D6”) = arr

Типы массивов VBA

В VBA есть два типа массивов:
Статический – массив фиксированного размера.
Динамический – массив, в котором размер задается во время выполнения.
Разница между этими массивами в основном в том, как они создаются. Доступ к значениям в обоих типах массивов абсолютно одинаков. В следующих разделах мы рассмотрим оба типа.

Объявление массива

Статический массив объявляется следующим образом

Public Sub DecArrayStatic()

    ' создаем массив с элементами 0,1,2,3
    Dim arrMarks1(0 To 3) As Long

    ' массив с элементами 0,1,2,3
    Dim arrMarks2(3) As Long

    ' массив с элементами 1,2,3,4,5
    Dim arrMarks3(1 To 5) As Long

    ' массив с элементами 2,3,4 ' редко используется
    Dim arrMarks4(2 To 4) As Long

End Sub

Как видите, при объявлении статического массива указывается его размер. Но проблема в том, что вы никогда не можете заранее знать, какой размер вам нужен. Каждый раз при запуске макроса у вас могут быть разные требования к размеру массива

Если вы не используете все элементы массива, ресурсы памяти расходуются в пустую. Если нужно добавить больше элементов можно использовать метод ReDim, но по сути это создает новый статический массив

Динамические массивы не имеют таких проблем. Размер массивы не указывается при объявлении. Поэтому его размер может расти и уменьшаться по мере необходимости

Public Sub DecArrayDynamic()

    ' Объявление динамического массива
    Dim arrMarks() As Long

    ' Устанавливаем размер массива 
    ReDim arrMarks(0 To 5)

End Sub

Динамический массив не создается, пока вы не используете оператор ReDim. Преимущество в том, что вы можете подождать, пока не узнаете количество элементов, прежде чем устанавливать размер массива. Со статическим массивом вы должны указать размер заранее.

Чтение из диапазона ячеек в массив

VBA имеет очень эффективный способ чтения из диапазона ячеек в массив и наоборот

Public Sub ReadToArray()

    ' Объявляем динамический массив
    Dim StudentMarks As Variant

    ' Считываем данные в массив из первой строки
    StudentMarks = Range("A1:Z1").Value

    ' Записываем значения назад в третью строку
    Range("A3:Z3").Value = StudentMarks

End Sub

В следующем примере будут считаны данные из диапазона C3: E6 листа Sheet1 и отображены в окне Immediate Window.

Public Sub ReadAndDisplay()

    ' Получаем диапазон
    Dim rg As Range
    Set rg = ThisWorkbook.Worksheets("Sheet1").Range("C3:E6")

    ' Создаем динамический массив
    Dim StudentMarks As Variant

    ' Записываем данные в массив 
    StudentMarks = rg.Value

    ' Печатаем данные из массива
    Debug.Print "i", "j", "Value"
    Dim i As Long, j As Long
    For i = LBound(StudentMarks) To UBound(StudentMarks)
        For j = LBound(StudentMarks, 2) To UBound(StudentMarks, 2)
            Debug.Print i, j, StudentMarks(i, j)
        Next j
    Next i

End Sub

Как сделать выполнение ваших макросов супер скоростным

Если ваши макросы работают очень медленно, этот метод может оказаться очень полезным. Особенно если вы имеете дело с большими объемами данных.

Обновление значений в массивах происходит гораздо быстрее, чем обновление значений в ячейках.

В последнем разделе вы увидели, как мы можем легко читать из группы ячеек в массив и наоборот. Если мы обновляем много значений, мы можем сделать следующее

Копируем данные из ячеек в массив.
Изменяем данные в массиве.
Копируем обновленные данные из массива обратно в ячейки.

Например, следующий код будет намного быстрее, чем код ниже

Public Sub ReadToArray()

    ' Считываем данные в массив
    Dim StudentMarks  As Variant
    StudentMarks = Range("A1:Z20000").Value

    Dim i As Long
    For i = LBound(StudentMarks) To UBound(StudentMarks)
        ' Update marks here
        StudentMarks(i, 1) = StudentMarks(i, 1) * 2
        '...
    Next i

    ' Записываем новые значения на лист
    Range("A1:Z20000").Value = StudentMarks

End Sub

Sub UsingCellsToUpdate()
    
    Dim c As Variant
    For Each c In Range("A1:Z20000")
        c.Value = ' Обновляем значения 
    Next c
    
End Sub

Назначение из одного множества ячеек в другой также намного быстрее, чем с помощью копирования и вставки

' Ассоциирование диапазона- это быстро
Range("A1:A10").Value = Range("B1:B10").Value

' Копировать вставить - медленно
Range("B1:B1").Copy Destination:=Range("A1:A10")

Пример с динамическим диапазоном

Sub ReadingRange()
    
    Dim arr As Variant
    arr = shData.Range("A1").CurrentRegion

    Dim i as long
    For i = LBound(arr,1) + 1 to UBound(arr,1)
      arr(i,5) = arr(i,5) - 100
    next i

    shData.Range("h2").CurrentRegion.ClearContents
    Dim rowCount as Long, columnCount as Long
    rowCount  - UBound(arr,1)
    columnCount = UBound(arr,2)
    
    shData.Range("h2".Resize(rowCount, columnCount).Value = arr

End Sub

Использование массивов (VBA) | Документы Microsoft

26.12.2018
2 минуты на чтение

В этой статье

Вы можете объявить массив для работы с набором значений одного и того же типа данных. Массив — это отдельная переменная с множеством отсеков для хранения значений, тогда как типичная переменная имеет только одно отсек для хранения, в котором она может хранить только одно значение.Обратитесь к массиву в целом, если вы хотите обратиться ко всем содержащимся в нем значениям, или вы можете обратиться к его отдельным элементам.

Например, чтобы хранить ежедневные расходы на каждый день года, вы можете объявить одну переменную массива с 365 элементами, а не объявлять 365 переменных. Каждый элемент в массиве содержит одно значение. Следующий оператор объявляет переменную массива с 365 элементами. По умолчанию массив индексируется, начиная с нуля, поэтому верхняя граница массива равна 364, а не 365.

  Dim curExpense (364) как валюта

Чтобы установить значение отдельного элемента, вы указываете индекс элемента. В следующем примере каждому элементу массива присваивается начальное значение 20.

  Подложка FillArray ()
 Dim curExpense (364) как валюта
 Dim intI как целое число
 Для intI = от 0 до 364
 curExpense (intI) = 20
 следующий
Конец подписки

Изменение нижней границы

Вы можете использовать оператор Option Base в верхней части модуля, чтобы изменить индекс первого элемента по умолчанию с 0 на 1.В следующем примере оператор Option Base изменяет индекс для первого элемента, а оператор Dim объявляет переменную массива с 365 элементами.

  Опциональная база 1
Dim curExpense (365) как валюта

Вы также можете явно установить нижнюю границу массива с помощью предложения To , как показано в следующем примере.

  Dim curExpense (от 1 до 365) как валюта
Dim strWeekday (с 7 по 13) как строка

Сохранение значений Variant в массивах

Существует два способа создания массивов значений Variant .Один из способов — объявить массив типа данных Variant, как показано в следующем примере:

  Dim varData (3) как вариант
varData (0) = "Клаудиа Бендель"
varData (1) = "4242 Maple Blvd"
varData (2) = 38
varData (3) = Format ("06-09-1952", "Общая дата")

Другой способ — присвоить массив, возвращаемый функцией Array , переменной Variant , как показано в следующем примере.

  Dim varData как вариант
varData = Array ("Рон Бендель", "4242 Maple Blvd", 38, _
Формат («06-09-1952», «Общая дата»))

Вы идентифицируете элементы в массиве значений Variant по индексу, независимо от того, какой метод вы используете для создания массива.Например, следующий оператор можно добавить к любому из предыдущих примеров.

  MsgBox "Данные для" & varData (0) & "были записаны."

Использование многомерных массивов

В Visual Basic вы можете объявлять массивы, содержащие до 60 измерений. Например, следующий оператор объявляет двумерный массив 5 на 10.

  Dim sngMulti (от 1 до 5, от 1 до 10) как одиночный

Если вы думаете о массиве как о матрице, первый аргумент представляет строки, а второй аргумент представляет столбцы.

Используйте вложенные операторы For … Next для обработки многомерных массивов. Следующая процедура заполняет двумерный массив значениями Single .

  Подложка FillArrayMulti ()
 Dim intI как целое число, intJ как целое число
 Dim sngMulti (от 1 до 5, от 1 до 10) как одиночный
 
 'Заполнить массив значениями.
 Для intI = от 1 до 5
 Для intJ = от 1 до 10
 sngMulti (intI, intJ) = intI * intJ
 Debug.Print sngMulti (intI, intJ)
 Следующий intJ
 Следующий intI
Конец подписки

См. Также

Поддержка и отзывы

Есть вопросы или отзывы об Office VBA или этой документации? См. Раздел Поддержка и отзывы Office VBA, чтобы узнать, как получить поддержку и оставить отзыв.

массивов — Visual Basic | Документы Microsoft

06.12.2017
28 минут на чтение

В этой статье

Массив — это набор значений, которые называются элементами , которые логически связаны друг с другом. Например, массив может содержать количество учеников в каждом классе гимназии; каждый элемент массива — это количество учеников в одном классе.Точно так же массив может состоять из оценок учащегося за класс; каждый элемент массива относится к одной категории.

Возможно отдельные переменные для хранения каждого из наших элементов данных. Например, если наше приложение анализирует оценки учащихся, мы можем использовать отдельную переменную для оценки каждого учащегося, например, englishGrade1 , englishGrade2 и т. Д. Этот подход имеет три основных ограничения:

Во время проектирования мы должны точно знать, сколько сортов нам нужно обработать.
Обработка большого количества сортов быстро становится громоздкой. Это, в свою очередь, увеличивает вероятность возникновения серьезных ошибок в приложении.
Сложно обслуживать. Каждая новая оценка, которую мы добавляем, требует, чтобы приложение было изменено, перекомпилировано и повторно развернуто.

Используя массив, вы можете ссылаться на эти связанные значения под тем же именем и использовать число, которое называется индексом или индексом для идентификации отдельного элемента на основе его позиции в массиве.Индексы массива варьируются от 0 до на единицу меньше, чем общее количество элементов в массиве. Когда вы используете синтаксис Visual Basic для определения размера массива, вы указываете его наивысший индекс, а не общее количество элементов в массиве. Вы можете работать с массивом как с единым целым, и возможность повторять его элементы освобождает вас от необходимости точно знать, сколько элементов он содержит во время разработки.

Несколько простых примеров перед объяснением:

  'Объявите одномерный массив из 5 чисел.Тусклые числа (4) как целое число

'Объявите одномерный массив и установите для него 4 значения.
Тусклые числа = новое целое число () {1, 2, 4, 8}

'Измените размер существующего массива на 16 элементов и сохраните текущие значения.
Номера ReDim Preserve (15)

'Переопределите размер существующего массива и сбросьте значения.
ReDim числа (15)

'Объявите многомерный массив 6 x 6.
Тусклая матрица (5, 5) как двойная

'Объявите многомерный массив 4 x 3 и установите значения элементов массива.
Тусклая матрица = новое целое число (3, 2) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

'Объявить зубчатый массив
Тусклые продажи () () как двойное = новое двойное (11) () {}

Элементы массива в простом массиве

Давайте создадим массив с именем студентов для хранения количества учеников в каждом классе гимназии.Индексы элементов варьируются от 0 до 6. Использовать этот массив проще, чем объявлять семь переменных.

На следующем рисунке показан массив студентов . Для каждого элемента массива:

В следующем примере содержится код Visual Basic, который создает и использует массив:

 
Модуль SimpleArray
   Публичная подпрограмма Main ()
      'Объявить массив из 7 элементов.
      Тусклые студенты (6) как целое число

      'Присвойте значения каждому элементу.студенты (0) = 23
      студенты (1) = 19
      студенты (2) = 21
      студенты (3) = 17
      студенты (4) = 19
      студенты (5) = 20
      студенты (6) = 22
      
      'Отобразите значение каждого элемента.
      Для ctr как целое число = от 0 до 6
         Нечеткая оценка как строка = If (ctr = 0, "детский сад", $ "grade {ctr}")
         Console.WriteLine ($ "Учащиеся в {grade}: {student (ctr)}")
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'Ученики детского сада: 23
'Учащимся 1 класса: 19
Ученики 2 класса: 21
'Учащимся 3 класса: 17
'Учащимся 4 класса: 19
'Учащимся 5 класса: 20
'Учащимся 6 класса: 22

Пример выполняет три функции:

Он объявляет массив студентов с семью элементами.Число 6 в объявлении массива указывает последний индекс в массиве; это на единицу меньше количества элементов в массиве.
Он присваивает значения каждому элементу в массиве. Доступ к элементам массива осуществляется с помощью имени массива и включения индекса отдельного элемента в круглые скобки.
В нем перечислены все значения массива. В примере используется оператор For для доступа к каждому элементу массива по его номеру индекса.

Массив студентов в предыдущем примере является одномерным массивом, поскольку он использует один индекс.Массив, в котором используется более одного индекса или нижнего индекса, называется многомерным . Дополнительные сведения см. В оставшейся части этой статьи и в разделе «Измерения массива в Visual Basic».

Создание массива

Вы можете определить размер массива несколькими способами:

Вы можете указать размер при объявлении массива:

  'Объявите массив из 10 элементов.
Тусклый груз Вес (9) Двойной
'Объявите массив 24 x 2.
Тусклые почасовые температуры (23, 1) как целое число
'Объявите зубчатый массив из 31 элемента.Dim januaryInquiries (30) () В виде строки

Вы можете использовать предложение New , чтобы указать размер массива при его создании:

  'Объявите массив из 10 элементов.
Dim cargoWeights () As Double = Новый двойной (9) {}
'Объявите массив 24 x 2.
Dim hourlyTemperatures (,) As Integer = New Integer (23, 1) {}
'Объявите зубчатый массив из 31 элемента.
Dim januaryInquiries () () As String = New String (30) () {}

Если у вас есть существующий массив, вы можете переопределить его размер с помощью оператора ReDim .Вы можете указать, что оператор ReDim сохраняет значения, которые находятся в массиве, или вы можете указать, что он создает пустой массив. В следующем примере показаны различные варианты использования оператора ReDim для изменения размера существующего массива.

  'Назначьте новый размер массива и сохраните текущие значения.
ReDim Preserve Cargo Масса (20)
'Назначьте новый размер массива и сохраните только первые пять значений.
ReDim Preserve Cargo Масса (4)
'Назначьте новый размер массива и отбросьте все текущие значения элементов.ReDim CargoWeights (15)

Для получения дополнительной информации см. Заявление ReDim.

Сохранение значений в массиве

Вы можете получить доступ к каждому месту в массиве, используя индекс типа Integer . Вы можете сохранять и извлекать значения в массиве, ссылаясь на каждое местоположение массива, используя его индекс, заключенный в круглые скобки. Индексы для многомерных массивов разделяются запятыми (,). Вам нужен один индекс для каждого измерения массива.

В следующем примере показаны некоторые операторы, которые хранят и извлекают значения в массивах.

 
Пример модуля
   Публичная подпрограмма Main ()
      'Создайте целочисленный массив из 10 элементов.
      Тусклые числа (9) как целое число
      Значение затемнения как целое число = 2
        
      «Запишите в него ценности.
      Для ctr как целое число = от 0 до 9
         числа (ctr) = значение
         значение * = 2
      следующий
        
      'Прочтите и просуммируйте значения массива.
      Дим-сумма как целое число
      Для ctr как целое число = от 0 до 9
         сумма + = числа (ctr)
      следующий
      Console.WriteLine ($ "Сумма значений равна {sum: N0}")
    Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'Сумма значений составляет 2 046

Заполнение массива литералами массива

Используя литерал массива, вы можете заполнить массив начальным набором значений одновременно с его созданием.Литерал массива состоит из списка значений, разделенных запятыми, заключенных в фигурные скобки ( {} ).

Когда вы создаете массив с помощью литерала массива, вы можете либо указать тип массива, либо использовать вывод типа для определения типа массива. В следующем примере показаны оба варианта.

  'Литералы массива с явным определением типа.
Тусклые числа = новое целое число () {1, 2, 4, 8}
'Литералы массива с выводом типа.
Тусклые удвоения = {1,5, 2, 9,9, 18}
'Литералы массива с явным определением типа.Тусклые статьи () как String = {"the", "a", "an"}

'Литералы массива с явным определением расширяющегося типа.
Затемнить значения () As Double = {1, 2, 3, 4, 5}

При использовании вывода типа тип массива определяется доминирующим типом в списке литеральных значений. Доминирующий тип — это тип, до которого могут расширяться все другие типы в массиве. Если этот уникальный тип не может быть определен, доминирующим типом является уникальный тип, до которого могут сузиться все другие типы в массиве.Если ни один из этих уникальных типов не может быть определен, доминирующим типом является Объект . Например, если список значений, который передается в литерал массива, содержит значения типа Integer , Long и Double , результирующий массив будет иметь тип Double . Поскольку Integer и Long расширяются только до Double , Double является доминирующим типом. Для получения дополнительной информации см. Расширение и сужение преобразований.

Примечание

Выявление типа можно использовать только для массивов, которые определены как локальные переменные в члене типа. Если явное определение типа отсутствует, массивы, определенные с помощью литералов массива на уровне класса, имеют тип Object [] . Для получения дополнительной информации см. Выведение локального типа.

Обратите внимание, что предыдущий пример определяет значений как массив типа Double , хотя все литералы массива имеют тип Integer . Вы можете создать этот массив, потому что значения в литерале массива могут расширяться до Double значений.

Вы также можете создать и заполнить многомерный массив, используя литералы вложенного массива . Литералы вложенных массивов должны иметь ряд измерений, согласованных с результирующим массивом. В следующем примере создается двумерный массив целых чисел с помощью вложенных литералов массива.

  'Создайте и заполните массив 2 x 2.
Тусклая сетка1 = {{1, 2}, {3, 4}}
'Создайте и заполните массив 2 x 2 тремя элементами.
Затемнить сетку2 (,) = {{1, 2}, {3, 4}, {5, 6}}

При использовании литералов вложенных массивов для создания и заполнения массива возникает ошибка, если количество элементов во вложенных литералах массива не совпадает.Ошибка также возникает, если вы явно объявляете, что переменная массива имеет другое число измерений, чем литералы массива.

Как и для одномерных массивов, вы можете полагаться на вывод типа при создании многомерного массива с вложенными литералами массива. Выведенный тип является доминирующим для всех значений во всех литералах массива для всех уровней вложенности. В следующем примере создается двумерный массив типа Double [,] из значений типа Integer и Double .

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

Дополнительные примеры см. В разделе Практическое руководство. Инициализация переменной массива в Visual Basic.

Итерация по массиву

При итерации по массиву вы получаете доступ к каждому элементу в массиве от самого низкого индекса до самого высокого или от самого высокого до самого низкого. Как правило, для перебора элементов массива используют либо оператор For … Next, либо оператор For Each … Next. Если вы не знаете верхних границ массива, вы можете вызвать метод Array.GetUpperBound, чтобы получить максимальное значение индекса. Хотя наименьшее значение индекса почти всегда равно 0, вы можете вызвать метод Array.GetLowerBound, чтобы получить наименьшее значение индекса.

В следующем примере выполняется итерация по одномерному массиву с помощью оператора For ... Next .

 
Модуль IterateArray
   Публичная подпрограмма Main ()
      Тусклые числа = {10, 20, 30}

      Для индекса = 0 К числам. GetUpperBound (0)
         Console.WriteLine (числа (индекс))
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'10
'20
'30

В следующем примере выполняется итерация по многомерному массиву с использованием объекта For...Следующий отчет . Метод GetUpperBound имеет параметр, определяющий размер. GetUpperBound (0) возвращает наивысший индекс первого измерения, а GetUpperBound (1) возвращает наивысший индекс второго измерения.

 
Модуль IterateArray
   Публичная подпрограмма Main ()
      Тусклые числа = {{1, 2}, {3, 4}, {5, 6}}

      Для index0 = 0 Для чисел.GetUpperBound (0)
         Для index1 = 0 К числам. GetUpperBound (1)
            Console.Write ($ "{числа (индекс0, индекс1)}")
         следующий
         Консоль.WriteLine ()
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
' Выход
'1 2
'3 4
'5 6

В следующем примере оператор For Each … Next используется для перебора одномерного массива и двумерного массива.

 
Модуль IterateWithForEach
   Публичная подпрограмма Main ()
      'Объявить и перебрать одномерный массив.
      Тусклые числа1 = {10, 20, 30}
      
      Для каждого числа В числах1
         Console.WriteLine (число)
      следующий
      Консоль.WriteLine ()
      
      Тусклые числа = {{1, 2}, {3, 4}, {5, 6}}

      Для каждого числа В числах
         Console.WriteLine (число)
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'10
'20
'30
'
'1
'2
'3
'4
'5
'6

Размер массива

Размер массива — это произведение длин всех его измерений. Он представляет собой общее количество элементов, содержащихся в данный момент в массиве. Например, в следующем примере объявляется 2-мерный массив с четырьмя элементами в каждом измерении.Как видно из выходных данных примера, размер массива равен 16 (или (3 + 1) * (3 + 1).

 
Пример модуля
   Публичная подпрограмма Main ()
      Dim arr (3, 3) как целое число
      Console.WriteLine (arr.Length)
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'16

Примечание

Это обсуждение размера массива не относится к зубчатым массивам. Для получения информации о зубчатых массивах и определении размера зубчатого массива см. Раздел «Неровные массивы».

Вы можете узнать размер массива, используя свойство Array.Length. Вы можете найти длину каждого измерения многомерного массива с помощью метода Array.GetLength.

Вы можете изменить размер переменной массива, назначив ей новый объект массива или используя оператор ReDim Statement. В следующем примере оператор ReDim используется для изменения массива из 100 элементов на массив из 51 элемента.

 
Пример модуля
   Публичная подпрограмма Main ()
      Dim arr (99) как целое число
      Консоль.WriteLine (длина строки)
      
      Редим обр (50)
      Console.WriteLine (arr.Length)
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
100
'51

При работе с размером массива следует помнить о нескольких вещах.


Размер Длина	Индекс каждого измерения отсчитывается от 0, что означает, что он находится в диапазоне от 0 до его верхней границы. Следовательно, длина данного измерения на единицу больше заявленной верхней границы этого измерения.31) — 1. Однако общий размер массива также ограничен объемом памяти, доступной в вашей системе. Если вы попытаетесь инициализировать массив, размер которого превышает объем доступной памяти, среда выполнения выдает исключение OutOfMemoryException.
Размер и размер элемента	Размер массива не зависит от типа данных его элементов. Размер всегда представляет собой общее количество элементов, а не количество байтов, которые они потребляют в памяти.
Потребление памяти	Делать какие-либо предположения относительно того, как массив хранится в памяти, небезопасно.Хранилище различается на платформах с разной шириной данных, поэтому один и тот же массив может потреблять больше памяти в 64-битной системе, чем в 32-битной системе. В зависимости от конфигурации системы при инициализации массива среда CLR может назначить хранилище для упаковки элементов как можно ближе друг к другу или для выравнивания их всех по естественным границам оборудования. Кроме того, массив требует накладных расходов на хранилище для своей управляющей информации, и эти накладные расходы увеличиваются с каждым добавленным измерением.

Тип массива

Каждый массив имеет тип данных, который отличается от типа данных его элементов.Не существует единого типа данных для всех массивов. Вместо этого тип данных массива определяется количеством измерений или рангом массива и типом данных элементов в массиве. Две переменные массива имеют один и тот же тип данных, только если они имеют одинаковый ранг и их элементы имеют один и тот же тип данных. Длины измерений массива не влияют на тип данных массива.

Каждый массив наследуется от класса System.Array, и вы можете объявить переменную типа Array , но вы не можете создать массив типа Array .Например, хотя следующий код объявляет, что переменная arr имеет тип Array и вызывает метод Array.CreateInstance для создания экземпляра массива, типом массива оказывается Object [].

 
Пример модуля
   Публичная подпрограмма Main ()
      Dim arr As Array = Array.CreateInstance (GetType (Object), 19)
      Console.WriteLine (arr.Length)
      Console.WriteLine (arr.GetType (). Имя)
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'19
'Объект []

Кроме того, оператор ReDim не может работать с переменной, объявленной как тип , массив .По этим причинам и для обеспечения безопасности типов рекомендуется объявлять каждый массив как определенный тип.

Вы можете узнать тип данных массива или его элементов несколькими способами.

Вы можете вызвать метод GetType для переменной, чтобы получить объект Type, представляющий тип времени выполнения переменной. Объект Type содержит обширную информацию о своих свойствах и методах.
Вы можете передать переменную в функцию TypeName, чтобы получить String с именем типа времени выполнения.

В следующем примере вызываются как метод GetType , так и функция TypeName для определения типа массива. Тип массива — байт (,) . Обратите внимание, что свойство Type.BaseType также указывает, что базовым типом массива байтов является класс Array.

 
Пример модуля
   Публичная подпрограмма Main ()
      Тусклые байты (9,9) как байты
      Console.WriteLine ($ "Тип массива {nameof (bytes)}: {bytes.GetType (). Name}")
      Console.WriteLine ($ "Базовый класс {nameof (bytes)}: {bytes.GetType (). BaseType.Name} ")
      Console.WriteLine ()
      Console.WriteLine ($ "Тип массива {nameof (bytes)}: {TypeName (bytes)}")
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'Тип байтового массива: Byte [,]
'Базовый класс байтов: Массив
'
'Тип байтового массива: Byte (,)

Массивы как возвращаемые значения и параметры

Чтобы вернуть массив из процедуры Function , укажите тип данных массива и количество измерений в качестве типа возвращаемого значения оператора Function.Внутри функции объявите переменную локального массива с тем же типом данных и количеством измерений. В операторе возврата включите переменную локального массива без скобок.

Чтобы указать массив в качестве параметра для процедуры Sub или Function , определите параметр как массив с указанным типом данных и количеством измерений. При вызове процедуры передайте переменную массива с тем же типом данных и количеством измерений.

В следующем примере функция GetNumbers возвращает Integer () , одномерный массив типа Integer .Процедура ShowNumbers принимает аргумент Integer () .

 
Модуль ReturnValuesAndParams
   Публичная подпрограмма Main ()
      Размыть числа как целые () = GetNumbers ()
      ShowNumbers (числа)
   Конец подписки

   Частная функция GetNumbers () как целое число ()
      Размыть числа как целое () = {10, 20, 30}
      Номера возврата
   Конечная функция

   Private Sub ShowNumbers (числа как целые ())
      Для индекса = 0 К числам. GetUpperBound (0)
         Console.WriteLine ($ "{числа (индекс)}")
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'10
'20
'30

В следующем примере функция GetNumbersMultiDim возвращает Integer (,) , двумерный массив типа Integer .Процедура ShowNumbersMultiDim принимает аргумент Integer (,) .

 
Пример модуля
   Публичная подпрограмма Main ()
      Размыть числа как целое число (,) = GetNumbersMultidim ()
      ShowNumbersMultidim (числа)
   Конец подписки

   Частная функция GetNumbersMultidim () как целое число (,)
      Тусклые числа как целое (,) = {{1, 2}, {3, 4}, {5, 6}}
      Номера возврата
   Конечная функция

   Private Sub ShowNumbersMultidim (числа как целые (,))
      Для index0 = 0 Для чисел.GetUpperBound (0)
         Для index1 = 0 до чисел.GetUpperBound (1)
            Console.Write ($ "{числа (индекс0, индекс1)}")
         следующий
         Console.WriteLine ()
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'1 2
'3 4
'5 6

Неровные массивы

Иногда структура данных в вашем приложении двумерная, но не прямоугольная. Например, вы можете использовать массив для хранения данных о высокой температуре каждого дня месяца. Первое измерение массива представляет месяц, а второе измерение представляет количество дней, а количество дней в месяце не является однородным.Зубчатый массив , который также называют массивом массивов , разработан для таких сценариев. Неровный массив — это массив, элементы которого также являются массивами. Неровный массив и каждый элемент неровного массива могут иметь одно или несколько измерений.

В следующем примере используется массив месяцев, каждый элемент которого представляет собой массив дней. В примере используется зубчатый массив, поскольку в разных месяцах разное количество дней. В этом примере показано, как создать зубчатый массив, присвоить ему значения, а также получить и отобразить его значения.

  Система импорта. Глобализация

Модуль JaggedArray
   Публичная подпрограмма Main ()
      'Объявите зубчатый массив из 12 элементов. Каждый элемент представляет собой массив Double.
      Тусклые продажи (11) () как двойные
      'Установите каждый элемент массива продаж в массив Double подходящего размера.
      Для месяца как целое число = от 0 до 11
         «Количество дней в месяце определяет подходящий размер.
         Dim daysInMonth As Integer =
            DateTime.DaysInMonth (Год (сейчас), месяц + 1)
         продажи (месяц) = Новый двойной (daysInMonth - 1) {}
      следующий

      'Сохранять значения в каждом элементе.Для месяца как целое число = от 0 до 11
         Для dayOfMonth = 0 К продажам (месяц) .GetUpperBound (0)
            продажи (месяц) (dayOfMonth) = (month * 100) + dayOfMonth
         следующий
      следующий

      'Получить и отобразить значения массива.
      Тусклые monthNames = DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames
      'Показать названия месяцев.
      Console.Write ("")
      Для ctr = 0 В sales.GetUpperBound (0)
         Console.Write ($ "{monthNames (ctr)}")
      следующий
      Console.WriteLine ()
      'Отображать данные за каждый день каждого месяца.Для dayInMonth = от 0 до 30
         Console.Write ($ "{dayInMonth + 1,2}.")
         Для monthNumber = 0 Для продажи.GetUpperBound (0)
            Если dayInMonth> sales (monthNumber) .GetUpperBound (0), то
               Console.Write ("")
            Еще
               Console.Write ($ "{продажи (monthNumber) (dayInMonth), - 5}")
            Конец, если
         следующий
         Console.WriteLine ()
      следующий
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'Янв фев мар апр май июн июл авг сен окт ноя дек
'1.0100200300400500600700800900 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. 8108 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.12112 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 10 15 11 15
'17. 16116 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.20120220320420520620720820920 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

В предыдущем примере значения неровному массиву присваиваются поэлементно с помощью цикла For ... Next . Вы также можете присвоить значения элементам зубчатого массива, используя литералы вложенных массивов. Однако попытка использовать литералы вложенных массивов (например, Dim valuesjagged = {{1, 2}, {2, 3, 4}} ) генерирует ошибку компилятора BC30568. Чтобы исправить ошибку, заключите литералы внутреннего массива в круглые скобки.Скобки приводят к вычислению выражения литерала массива, а полученные значения используются с литералом внешнего массива, как показано в следующем примере.

 
Пример модуля
   Публичная подпрограмма Main ()
      Тусклые значения1d = {1, 2, 3}
      Тусклые значения2d = {{1, 2}, {2, 3}, {3, 4}}
      Тусклые значенияjagged = {({1, 2}), ({2, 3, 4})}
   Конец подписки
Конечный модуль

Неровный массив — это одномерный массив, элементы которого содержат массивы. Следовательно, свойство Array.Length и массив .GetLength (0) метод возвращает количество элементов в одномерном массиве, а Array.GetLength (1) выдает исключение IndexOutOfRangeException, поскольку зубчатый массив не является многомерным. Вы определяете количество элементов в каждом подмассиве, извлекая значение свойства Array.Length каждого подмассива. В следующем примере показано, как определить количество элементов в неровном массиве.

 
Пример модуля
   Публичная подпрограмма Main ()
      Тусклый зазубренный = {({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9, 10})}
      Консоль.WriteLine ($ "Значение jagged.Length: {jagged.Length}.")
      Общий тусклый = зубчатый. Длина
      Для ctr As Integer = 0 To jagged.GetUpperBound (0)
         Console.WriteLine ($ "Элемент {ctr + 1} имеет {jagged (ctr) .Length} элементов.")
         всего + = зубчатый (ctr). Длина
      следующий
      Console.WriteLine ($ "Общее количество элементов в неровном массиве: {total}")
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
'Значение jagged.Length: 4.
«Элемент 1 состоит из 2 элементов.«Элемент 2 состоит из 3 элементов.
«В элементе 3 2 элемента.
«Элемент 4 состоит из 4 элементов.
'Общее количество элементов в зубчатом массиве: 15

Массивы нулевой длины

Visual Basic различает неинициализированный массив (массив со значением Nothing ) и массив нулевой длины или пустой массив (массив, не имеющий элементов). Неинициализированный массив — это массив, размеры которого не были измерены или были любые присвоенные ему значения. Например:

  Dim arr () как строка

Объявлен массив нулевой длины с размером -1.Например:

  Dim arrZ (-1) как строка

Вам может потребоваться создать массив нулевой длины в следующих случаях:

Не рискуя исключить исключение NullReferenceException, ваш код должен обращаться к членам класса Array, таким как Length или Rank, или вызывать функцию Visual Basic, такую как UBound.
Вы хотите, чтобы ваш код был простым, не проверяя Nothing как особый случай.
Ваш код взаимодействует с интерфейсом прикладного программирования (API), который либо требует от вас передать массив нулевой длины одной или нескольким процедурам, либо возвращает массив нулевой длины из одной или нескольких процедур.

Разделение массива

В некоторых случаях может потребоваться разбить один массив на несколько массивов. Это включает в себя определение точки или точек, в которых массив должен быть разделен, а затем разделение массива на два или более отдельных массива.

Примечание

В этом разделе не обсуждается разделение одной строки на массив строк на основе некоторого разделителя. Для получения информации о разделении строки см. Метод String.Split.

Наиболее распространенные критерии разделения массива:

Количество элементов в массиве.Например, вы можете захотеть разделить массив, состоящий из более чем указанного количества элементов, на несколько примерно равных частей. Для этой цели вы можете использовать значение, возвращаемое методом Array.Length или Array.GetLength.
Значение элемента, которое служит разделителем, указывающим, где следует разбить массив. Вы можете искать конкретное значение, вызывая методы Array.FindIndex и Array.FindLastIndex.

После того, как вы определили индекс или индексы, по которым массив должен быть разделен, вы можете затем создать отдельные массивы, вызвав метод Array.Метод копирования.

В следующем примере массив разбивается на два массива примерно равного размера. (Если общее количество элементов массива нечетное, в первом массиве на один элемент больше, чем во втором.)

 
Пример модуля
   Публичная подпрограмма Main ()
      'Создайте массив из 100 элементов.
      Dim arr (99) как целое число
      'Заполните массив.
      Dim rnd As new Случайно ()
      Для ctr = 0 Для arr.GetUpperBound (0)
         arr (ctr) = rnd.Next ()
      следующий
      
      'Определите, сколько элементов должно быть в каждом массиве.Тусклый делитель = 2
      Тусклый остаток как целое число
      Тусклая граница = Math.DivRem (arr.GetLength (0), делитель, остаток)
            
      'Скопируйте массив.
      Dim arr1 (граница - 1 + остаток), arr2 (граница - 1) как целое число
      Array.Copy (arr, 0, arr1, 0, граница + остаток)
      Array.Copy (arr, граница + остаток, arr2, 0, arr.Length - граница)
   Конец подписки
Конечный модуль

В следующем примере массив строк разбивается на два массива в зависимости от наличия элемента со значением «zzz», который служит разделителем массива.Новые массивы не включают элемент, содержащий разделитель.

 
Пример модуля
   Публичная подпрограмма Main ()
      Dim rnd As New Random ()
      
      'Создайте массив из 100 элементов.
      Dim arr (99) как строка
      'Заполните каждый элемент произвольным символом ASCII.
      Для ctr = 0 Для arr.GetUpperBound (0)
         arr (ctr) = ChrW (Rnd.Next (& h31, & h7F))
      следующий
      'Получите случайное число, которое будет представлять точку для вставки разделителя.
      обр (рнд.Далее (0, arr.GetUpperBound (0))) = "zzz"

      'Найдите разделитель.
      Тусклое местоположение = Array.FindIndex (arr, Function (x) x = "zzz")

      'Создайте массивы.
      Dim arr1 (расположение - 1) как строка
      Dim arr2 (arr.GetUpperBound (0) - расположение - 1) как строка
      
      'Заполните два массива.
      Array.Copy (arr, 0, arr1, 0, местоположение)
      Array.Copy (arr, location + 1, arr2, 0, arr.GetUpperBound (0) - местоположение)
   Конец подписки
Конечный модуль

Объединение массивов

Вы также можете объединить несколько массивов в один больший массив.Для этого вы также используете метод Array.Copy.

Примечание

В этом разделе не обсуждается объединение массива строк в одну строку. Для получения информации о присоединении к строковому массиву см. Метод String.Join.

Перед копированием элементов каждого массива в новый массив необходимо сначала убедиться, что вы инициализировали массив так, чтобы он был достаточно большим для размещения нового массива. Вы можете сделать это одним из двух способов:

Используйте оператор ReDim Preserve , чтобы динамически расширять массив перед добавлением в него новых элементов.Это самый простой метод, но он может привести к снижению производительности и чрезмерному потреблению памяти при копировании больших массивов.
Рассчитайте общее количество элементов, необходимых для нового большого массива, затем добавьте к нему элементы каждого исходного массива.

В следующем примере используется второй подход для добавления четырех массивов по десять элементов каждый в один массив.

  Импорт System.Collections.Generic
Импортирует System.Threading.Tasks

Пример модуля
   Публичная подпрограмма Main ()
      Заменить задачи как новый список (Of Task (Of Integer ()))
      'Создать четыре массива.Для ctr = от 0 до 3
         Значение затемнения = ctr
         tasks.Add (Task.Run (Функция ()
                               Dim arr (9) как целое число
                               Для ndx = 0 Для arr.GetUpperBound (0)
                                  arr (ndx) = значение
                               следующий
                               Возврат прибл.
                            Конец функции))
       следующий
       Task.WaitAll (tasks.ToArray ())
       'Подсчитайте количество элементов во всех массивах.
       Тусклые элементы = 0
       Для каждой задачи В задачах
          элементы + = задача.Результат.Длина
       следующий
       Dim newArray (elements - 1) как целое число
       Тусклый индекс = 0
       Для каждой задачи В задачах
          Dim n = task.Result.Length
          Array.Copy (task.Result, 0, newArray, index, n)
          индекс + = n
       следующий
      Console.WriteLine ($ "Новый массив содержит элементов {newArray.Length}.")
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
«В новом массиве 40 элементов.

Поскольку в этом случае все исходные массивы малы, мы также можем динамически расширять массив по мере добавления в него элементов каждого нового массива.Следующий пример делает это.

  Импорт System.Collections.Generic
Импортирует System.Threading.Tasks

Пример модуля
   Публичная подпрограмма Main ()
      Заменить задачи как новый список (Of Task (Of Integer ()))
      'Создать четыре массива.
      Для ctr = от 0 до 3
         Значение затемнения = ctr
         tasks.Add (Task.Run (Функция ()
                               Dim arr (9) как целое число
                               Для ndx = 0 Для arr.GetUpperBound (0)
                                  arr (ndx) = значение
                               следующий
                               Возврат прибл.
                            Конец функции))
       следующий
       Задача.WaitAll (tasks.ToArray ())

       'Измерьте размер целевого массива и скопируйте в него каждый элемент каждого исходного массива.
       Dim newArray () As Integer = {}
       'Определите следующую позицию для копирования в newArray.
       Тусклый индекс = 0
       Для каждой задачи В задачах
          Dim n = Task.Result.Length
          ReDim Preserve newArray (newArray.GetUpperBound (0) + n)
          Array.Copy (task.Result, 0, newArray, index, n)
          индекс + = n
       следующий
      Console.WriteLine ($ "Новый массив содержит {newArray.Length} элементов. ")
   Конец подписки
Конечный модуль
'В этом примере отображается следующий вывод:
«В новом массиве 40 элементов.

Коллекции как альтернатива массивам

Массивы наиболее полезны для создания и работы с фиксированным количеством строго типизированных объектов. Коллекции обеспечивают более гибкий способ работы с группами объектов. В отличие от массивов, которые требуют явного изменения размера массива с помощью оператора ReDim , коллекции растут и сжимаются динамически по мере изменения потребностей приложения.

Когда вы используете ReDim для изменения размеров массива, Visual Basic создает новый массив и освобождает предыдущий. Это требует времени выполнения. Следовательно, если количество элементов, с которыми вы работаете, меняется часто, или вы не можете предсказать максимальное количество элементов, которые вам нужны, вы, как правило, получите лучшую производительность, используя коллекцию.

Для некоторых коллекций вы можете назначить ключ любому объекту, который вы помещаете в коллекцию, чтобы вы могли быстро получить объект с помощью ключа.

Если ваша коллекция содержит элементы только одного типа данных, вы можете использовать один из классов в пространстве имен System.Collections.Generic. Универсальная коллекция обеспечивает безопасность типов, поэтому к ней нельзя добавлять другие типы данных.

Для получения дополнительной информации о коллекциях см. Коллекции.

См. Также

Функция массива (Visual Basic для приложений)

11.12.2018
2 минуты на чтение

В этой статье

Возвращает вариант, содержащий массив.

Синтаксис

Массив ( список аргументов )

Обязательный аргумент arglist представляет собой разделенный запятыми список значений, которые присваиваются элементам массива, содержащегося в Variant .Если аргументы не указаны, создается массив нулевой длины.

Замечания

Обозначение, используемое для ссылки на элемент массива, состоит из имени переменной, за которым следуют круглые скобки, содержащие порядковый номер, указывающий желаемый элемент.

В следующем примере первая инструкция создает переменную с именем A как вариант . Второй оператор присваивает массив переменной A . Последний оператор присваивает значение, содержащееся во втором элементе массива, другой переменной.

  Размер A как вариант, B как долго, i как долго
A = Array (10, 20, 30) 'A - это список из трех элементов, по умолчанию индексированный от 0 до 2
B = A (2) 'B сейчас 30
ReDim Preserve A (4) 'Увеличьте длину A до пяти элементов
A (4) = 40 'Установить значение пятого элемента
Для i = LBound (A) To UBound (A)
    Debug.Print "A (" & i & ") =" & A (i)
Далее я

Нижняя граница массива, созданного с помощью функции Array , определяется нижней границей, указанной с помощью оператора Option Base , если только Array не уточняется именем библиотеки типов (например, VBA.Массив ). Если указано имя библиотеки типов, Array не зависит от Option Base .

Примечание

Вариант , который не объявлен как массив, все еще может содержать массив. Переменная Variant может содержать массив любого типа, кроме строк фиксированной длины и определяемых пользователем типов. Хотя Variant , содержащий массив, концептуально отличается от массива, элементы которого относятся к типу Variant , доступ к элементам массива осуществляется таким же образом.

Пример

В этом примере используется функция Array для возврата Variant , содержащего массив.

  Dim MyWeek, MyDay
MyWeek = массив («Пн», «Вт», «Ср», «Чт», «Пт», «Сб», «Вс»)
'Возвращаемые значения предполагают, что нижняя граница установлена на 1 (с использованием Option Base
' заявление).
MyDay = MyWeek (2) 'MyDay содержит «Вт».
MyDay = MyWeek (4) 'MyDay содержит «чт».

См. Также

Поддержка и отзывы

Объявление массивов (VBA) | Документы Microsoft

21.12.2018
3 минуты на чтение

В этой статье

Массивы объявляются так же, как и другие переменные, с помощью операторов Dim , Static , Private или Public . Разница между скалярными переменными (теми, которые не являются массивами) и переменными массива в том, что обычно вы должны указывать размер массива.Массив, размер которого указан, является массивом фиксированного размера. Массив, размер которого можно изменять во время работы программы, является динамическим массивом.

Индексирован ли массив от 0 или 1, зависит от настройки оператора Option Base . Если Option Base 1 не указан, все индексы массива начинаются с нуля.

Объявить фиксированный массив

В следующей строке кода массив фиксированного размера объявлен как массив Integer , имеющий 11 строк и 11 столбцов:

  Dim MyArray (10, 10) как целое число

Первый аргумент представляет строки; второй аргумент представляет столбцы.

Как и в случае любого другого объявления переменной, если вы не укажете тип данных для массива, тип данных элементов в объявленном массиве будет Variant . Каждый числовой элемент Variant массива использует 16 байтов. Каждая строка Variant элемента использует 22 байта. Чтобы написать максимально компактный код, явно объявите ваши массивы с типом данных, отличным от Variant .

В следующих строках кода сравниваются размеры нескольких массивов.

  'Целочисленный массив использует 22 байта (11 элементов * 2 байта).
ReDim MyIntegerArray (10) как целое число
 
'Массив двойной точности использует 88 байтов (11 элементов * 8 байтов).
ReDim MyDoubleArray (10) как двойной
 
'Вариантный массив использует не менее 176 байт (11 элементов * 16 байт).
ReDim MyVariantArray (10)
 
'Целочисленный массив использует 100 * 100 * 2 байта (20 000 байтов).
ReDim MyIntegerArray (99, 99) как целое число
 
'Массив двойной точности использует 100 * 100 * 8 байт (80 000 байт).
ReDim MyDoubleArray (99, 99) как Double
 
'Вариантный массив использует не менее 160 000 байт (100 * 100 * 16 байт).ReDim MyVariantArray (99, 99)

Максимальный размер массива зависит от вашей операционной системы и объема доступной памяти. Использование массива, который превышает объем оперативной памяти, доступной в вашей системе, происходит медленнее, потому что данные должны быть прочитаны и записаны на диск.

Объявить динамический массив

Объявляя динамический массив, вы можете изменять размер массива во время выполнения кода. Используйте оператор Static , Dim , Private или Public для объявления массива, оставив круглые скобки пустыми, как показано в следующем примере.

  Dim sngArray () как одиночный

Примечание

Вы можете использовать оператор ReDim для неявного объявления массива внутри процедуры. Будьте осторожны, чтобы не ошибиться при написании имени массива при использовании оператора ReDim . Даже если в модуль включен оператор Option Explicit , будет создан второй массив.

В процедуре в области действия массива используйте оператор ReDim , чтобы изменить количество измерений, определить количество элементов и определить верхнюю и нижнюю границы для каждого измерения.Вы можете использовать оператор ReDim для изменения динамического массива по мере необходимости. Однако каждый раз, когда вы это делаете, существующие значения в массиве теряются. Используйте ReDim Preserve для расширения массива при сохранении существующих значений в массиве.

Например, следующий оператор увеличивает массив на 10 элементов без потери текущих значений исходных элементов.

  ReDim Preserve varArray (UBound (varArray) + 10)

Примечание

Когда вы используете ключевое слово Preserve с динамическим массивом, вы можете изменить только верхнюю границу последнего измерения, но не можете изменить количество измерений.

Декабрь 2024
Пн	Вт	Ср	Чт	Пт	Сб	Вс
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31