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

Массивы в Visual Basic.NET

Массивы

Последнее обновление: 30.10.2015

Массив представляет собой набор данных одного типа. Например, объявим массив элементов типа Integer:

Dim nums(5) As Integer
nums(0) = 0
nums(1) = 1
nums(2) = 2
nums(3) = 3
Console.WriteLine(nums(3))

Здесь мы объявили массив из 6 элементов типа Integer. По умолчанию всем шести элементам в массиве присваивается 0.
Затем первым четырем элементам массива мы присваиваем некоторые значения. Обратите внимание, что индексация в массиве начинается с нуля.
При этом мы не можем выйти за рамки установленной длины массива в 6 элементов. А следующий код вызовет исключение ArrayIndexOutOfRange,
поскольку восьмого элемента в массиве не существует, в нем определено только 6 элементов:

Dim nums(5) As Integer
nums(7) = 7

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

Dim nums() As Integer

В таком случае нам его еще предстоит инициализировать. Мы это можем сделать так:

Dim nums() As Integer
nums = New Integer(5) {}
nums(0) = 0
nums(1) = 1
nums(2) = 2
nums(3) = 3

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

Dim nums2 As Integer() = New Integer(5) {0, 1, 2, 3, 4, 5}

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

'Не указываем размер массива
Dim nums1 As Integer() = New Integer() {0, 1, 2, 3, 4, 5}
'Сокращенный синтаксис инициализации
Dim nums2 As Integer() = {0, 1, 2, 3, 4, 5}

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

Dim nums = {0, 1, 2, 3, 4, 5}

Кроме размера массив характеризуется таким понятием как размерность (dimension). В предыдущих примерах мы использовали одномерные массивы.
Но массивы бывают и многомерными. Например:

'Одномерный массив
Dim nums1 As Integer() = {0, 1, 2, 3, 4, 5}
'Двухмерный массив
Dim nums2 As Integer(,) = {{0, 1, 2}, {3, 4, 5}}
Console.WriteLine(nums2(1, 1))

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

Одномерный массив nums1

Двухмерный массив nums2

Изменение размера массива

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

Dim nums1 As Integer() = {0, 1, 2, 3, 4, 5}
ReDim nums1(8)

ReDim пересоздает массив с новым размером. Чтобы сохранить все прежние элементы, нам надо также использовать ключевое слово Preserve.

Dim nums1 As Integer() = {0, 1, 2, 3, 4, 5}
ReDim Preserve nums1(8)

Некоторые методы и свойства массивов

• Свойство Length позволяет получить количество элементов массива

• Свойство Rank позволяет получить размерность массива

• Метод Reverse изменяет порядок следования элементов массива на обратный

• Метод Sort сортирует элементы массива

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

Dim nums1 As Integer() = {8, 1, 5, 3, 4, 2}
Dim lenght As Integer = nums1.Length()
Console.WriteLine("количество элементов: {0}", lenght)
Dim rank As Integer = nums1.Rank()
Console.WriteLine("размерность массива: {0}", rank)
nums1.Reverse()
Array.Sort(nums1)
Console.WriteLine(nums1(1))

Массивы в VB

Массивы в Vb

На этом уроке мы узнаем, как объявлять и заполнять массивы в visual basic net

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

Массив – это набор элементов с общим именем. К элементу массива можно обратиться по его индексу (значение первого элемента имеет индекс 0, второго 1 и т.д.). Задается массив в Vb следующим образом
Dim имя массива () As тип элемента

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

Например, a (1) = 100 присвоит элементу массива a с номером 1 значение 100

Существуют различные способы заполнения массивов в vb.net

Заполнение массива случайными числами

Заполнение массива при объявлении

Заполнение массива с клавиатуры с помощью диалогового окна

Заполнение массива из файла

Заполнение массива в Vb случайными числами

Мы задаем массив произвольным образом (случайные целые числа) и выведем массив на экран в элемент Listbox

Размещаем в форме элементы Listbox и Button. Чтобы задать случайные числа в Vb, необходимо в начале программы создать объект, отвечающий за случайные числа.
Dim random As New Random()

Чтобы получить случайное значение в диапазоне от min до max, используется функция
random.Next(min, max)

Чтобы присвоить всем элементам массива  значения и вывести их в элемент ListBox, используется цикл For. В этом цикле граница цикла совпадает с размерностью массива (числом элементов в массиве). Переменная цикла используется при обращении к элементам массива.
For i = 1 To 10 Step 1

    a(i) = random.Next(1, 1000)

    ListBox1.Items.Add(i & vbTab & a(i))

Next i
Полная версия программы в Vb для заполнение массива случайнйми числами:
Public Class Form1

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim a(100) As Integer ‘задаем целочисленный массив

        Dim i As Integer ‘переменная для цикла

        Dim random As New Random() ‘задаем объект случайных чисел

        ‘пробегаемся по всему массиву

        For i = 1 To 10 Step 1

            a(i) = random.Next(1, 1000) ‘присваиваем элементу массива с номером i случайное число в диапазоне от 1 до 1000

            ListBox1.Items.Add(i & vbTab & a(i)) ‘выводим в Listbox номер массива и значение массива

        Next i

    End Sub

End Class

Заполнение массива в vb при объявлении

Массив в Vb можно ввести прямо при его объявлении. Для этого необходимо при объявлении массива не указывать его размер, а просто оставить пустые скобки, и далее после равно в фигурных скобках ввести значения элементов массива через запятую. 
Public Class Form1

    Dim matr() As Integer = {2, 2, 4, 4}

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim i, j As Integer

        For i = 0 To 3

            ListBox1.Items.Add(matr(i))

        Next

    End Sub

End Class

Заполнение массива с помощью клавиатуры, с помощью элемента InputBox

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

Перменная=InputBox(“Сообщение”, “название окна”)

matr (i)=InputBox(«Введите пожалуйста (» + Str(i + 1) + ”) элемент массива»,»Заполнение массива»)

Функция Str(числовое значение) в vb преобразует  числовое значение в текстовое выражение для последующего вывода в диалоговом меню

Пример программы на visual basic для ввода массива с клавиатуры
Public Class Form1

    Dim matr(3) As Integer

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim i, j As Integer

        For i = 0 To 3

            matr(i) = InputBox(«Введите (» + Str(i + 1) + «) элемент массива», «Заполнение массива»)

            ListBox1.Items.Add(matr(i))

        Next

    End Sub

End Class

Заполнение массива vb из файла

Для работы с файлами в Vb необходимо в начале программы указать
Imports System

Imports System.IO

Весь файл можно записать в строковый массив, используя команду
Dim имя массива() As String = IO.File.ReadAllLines(«путь к файлу», System.Text.Encoding.Default)

Например команда
Dim Massiv() As String = IO.File.ReadAllLines(«C: ext.txt», System.Text.Encoding.Default)

Запишет все строки файла C:ext.txt в массив строк Massiv()

Чтобы перевести строковое значение в числовое значение используется функция Val(строка)

Напишем программу на vb, которая считывает из файла массив чисел и записывает его в массив, выводит полученный массив в элемент ListBox. Чтобы вывести весь массив в ListBox нужно в цикле For использовать размер массива, который можно узнать с помощью команды
имя массива.Length
Полная программа Vb для считывания массива из файла
Imports System

Imports System.IO

Public Class Form1

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim i As Integer

        Dim a(10) As Integer

        Dim Massiv() As String = IO.File.ReadAllLines(«C:UsersuserDesktop ext.txt», System.Text.Encoding.Default)

        For i = 0 To Massiv.Length — 1

            a(i) = Val(Massiv(i))

            ListBox1.Items.Add(a(i))

        Next i

    End Sub

End Class

   Вернуться к содержанию  Перейти к следующему уроку Матрицы в VB

Полезно почитать по теме массивы в Vb:
Двумерные массивы матрицы в visual basic 
Циклы в Vb

Поделиться:

Visual Basic с нуля. Глава 10. Массивы. Их границы. Сортировка.

Visual Basic с нуля. Глава 10. Массивы. Их границы. Сортировка.

Массивы.

Массивы, друзья мои, очень простая и крайне необходимая
штука. Простой пример: ты считал из директории 50 имен файлов и тебе необходимо
как-то поместить их в памяти, что-бы потом с ними работать. Без использования
массива, ты должен объявить пятьдесят переменных и в каждую записать имя файла.
Это безумие. Но еще большее безумие потом работать с этими переменными, пытаясь
найти в них нужные нужные тебе данные. Иное дело массив. Имея его (в хорошем
смысле), можно под одним именем запомнить все твои пятьдесят имен файлов и перебирать
их сколько угодно, в любом цикле, меняя лишь индекс члена массива. Т.е., другими
словами,

Массив — это сколько угодно значений,
объединенных одним именем.

Массив, прежде чем использовать, надо объявить.
Объявляется он совершенно также как и переменная. Если ты объявишь его локально
в процедуре (здесь можно использовать ключевое слово Static), то он будет
доступен только в этой процедуре и нигде больше, если в разделе (General)-(Daclarations)
формы (c оператором Dim) — то во всей форме, а если тебе нужно объявить
его глобально, так, чтобы он был доступен всему проекту, то в стандартном модуле
с ключевым словом Public.

Кроме того , массивы бывают статическими и динамическими.

Статические
массивы.

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

Dim Chislo(9) As Long

Что здесь важно.
Dim — оператор, который точно также, как и при объявлении переменной,
объявляет массив и выделяет для нее память.
Chislo — ну это просто имя, придумывается также как и для переменной
и отвечает тем же требованиям.
(9) — количество элементов в массиве — их 10. Почему так. Дело в том,
что элементы массива нумеруются с нуля, а не с единицы, поэтому у нас десять
элементов массива c номерами 0, 1, 2, 3, 4, 5, 6, 7, 8 и 9. Если для каких-то
целей такой порядок тебя не устраивает, то используется оператор Option Base
1, который прописывается в разделе Declarations и привязывает первый
элемент ВСЕХ, повторяю ВСЕХ, массивов в программе к единице.
As Long — определение типа данных массива так же как тип обычной переменной.
Почти всегда все элементы массива имеют один и тот же тип ( в данном случае
длинное число Long). На крайняк, если это не так, или если ты не знаешь какого
типа будут данные, можно задать тип Variant, но это нежелательно из-за того,
что это занимает значительный объем памяти, особенно если массив большой.
Размерность — ее так сразу не заметно, но она здесь присутствует и равна
единице, потому, что у на одна циферка (девятка), т.е. наш массив является одномерным
— по сути список значений.

Теперь создадим массив для хранения результатов, ну скажем таблицы умножения
на 8. Поскольку на ноль умножать бесперспективно, привязываем первый элемент
массива к единице и объявляем переменную x для организации цикла For…Next.

Option Explicit

Option Base 1
Dim Chislo(10) As Long
'так как
мы используем оператор Option Base, то элементы массива нумеруются с единицы

Dim x As Long

Положим на форму Text1 с установленными свойствами .MultiLine
в True, а .ScrollBars — в 2-Вертикаль, а также кнопку Command1.
В процедуре Form_Load напишем цикл, который будет присваивать каждому
элементу массива значение, соответствующее его номеру, умноженному на 8.

Private Sub
Form_Load()

Text1.Text = ""
For x = 1 To 10

Chislo(x) = x * 8
Next x
End Sub

Как видите, в цикле мы вместо номера элемента
просто используем значение x, и таким образом перебираются все элементы массива.
Теперь мы выведем значения элементов массива в Text1 в процедуре Command1.

Private Sub
Command1_Click()
For x = 1 To 10

Text1.Text = Text1.Text & Chislo(x) & vbCrLf
Next x
End Sub

Таким образом наш одномерный массив представляет собой аналог
таблицы с одной строчкой:

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

Option Explicit

Option Base 1
Dim Chislo(10, 2) As Long
Dim x As Long

Private Sub Form_Load()

Text1.Text = «»
For x = 1 To 10

Chislo(x, 1) = x

Chislo(x, 2) = x * 8
Next x

Private Sub Command1_Click()
For x = 1 To 10

Text1.Text = Text1.Text & «8 x » & Chislo(x, 1) & »
= » & Chislo(x, 2) & vbCrLf
Next x
End Sub

И наш массив будет представлять собой следующее

таким образом элемент массива Chislo (7,2) будет иметь
значение 56.
Обратите внимание, что размерность массива определяет колиство циферек в
объявлении. Массив Chislo (10,5) — тоже двухмерный, только строк в табличке
было-бы не две, а пять. А объявление трехмерного массива выглядело бы так
Dim(10,5,2).Такую трехмерную таблицу нарисовать мне затруднительно. В
принципе VB поддерживает до 64 размерностей массива, но это в голове трудно
укладывается.

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

Динамические
массивы.

Часто
возникает ситуация, когда мы не знаем заранее, сколько элементов массива мы
будем использовать заранее. Поэтому массив объявляется без размерности, например
Dim Mass () as String

Но, перед его непосредственным использованием, его надо переобъявить c указанием
размерности. Делается это с помощью оператора Redim.

Redim Mass (5) as
String

Вообще-то, у нас два пути использования динамического массива.

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

Второй путь, это когда мы в одном цикле при нахождении каждого нового данного
переобъявляем массив с увеличением количества его элементов. Но этот способ
загружает компьютер и может занимать много времени на обработку, особенно если
создается большой массив. Происходит это из-за перераспределения элементов массива
в памяти всякий раз при его переобъявлении и добавлении нового члена. Но именно
такой способ мы применим при разработке программки Scanfiles,
которая будет сканировать файлы в выбранной директории, сортировать их по-возрастанию
и выводить в Text1. Хочу сразу заметить, что при переобъявлении массива
все записанные в него данные стираются — массив обнуляется. Чтобы этого не происходило,
надо использовать ключевое слово Peserve:

Redim
Preserve Mass (5) as String

Идем дальше. Поместим на форму объекты Dir1
и Text1. Начнем писать код. Обратите внимание, что процедуры Form_Load
у нас не будет, так как под это событие обрабатывать нам нечего. Ну-с, фигачим

Option Explicit
'Установим начальную нумерацию массива
с единицы, сейчас так удобнее
Option Base 1
'объявим переменные
Dim OurDir As
String 'для директории, где будем искать файлы
Dim FileName As String 'для
имен находимых файлов
Dim X As Long 'просто
для цикла
'и, наконец, наш динамический массив, как
строковый
Dim Files() As
String

Кроме того, поскольку
одни имена — это уж совсем скучно, то мы еще во вторую размерность массива выведем
атрибуты файла. Атрибуты, это когда по файлу шлепаешь правой кнопкой мыши и
в выпавшем меню выбираешь «Свойства«. Тогда снизу окна этих
свойств можно увидеть галочки рядом с загадочными словами «Только чтение»,
«Скрытый» и «Архивный». Именно эти свойства можно устанавливать
или получать с помощью оператора SetAttr и функции GetAttr. Весь
геморрой в том, что этот атрибут представляет из себя число, получаемое из суммы
значений атрибутов, приведенных в таблице ниже, и чтобы понять, какой атрибут
все-таки у файла, нужно «с помощью оператора And выполнить поразрядное
сравнение значения». Друзья мои. Это цитату из Help5 я привел для того,
чтобы можно было почувствовать разницу между «академическим» и «вольным»
изложением проблемы. Короче, привожу таблицу этих атрибутов:

Из всей этой дребедни нам нужны три константы: vbArchive,
vbReadOnly и vbHidden для этого самого «поразрядного сравнения».
Делается это так:

Чтобы узнать, только для чтения ли этот файл:
Переменная = GetAttr(«полный путь к файлу») And
vbReadOnly

Если в Переменной не ноль, то файл — только для чтения. Аналогично для других
констант.

Чтобы установить аттрибут, например «Архивный» для файла:
SetAttr «C:\Andrey\index.htm», vbReadOnly

при этом уже установленные атрибуты файла сбрасываются. Если надо установить
атрибуты «только для чтения» и «архивный»:
SetAttr «C:\Andrey\index.htm», vbReadOnly +vbArchive

Все просто, а по сути — издевательство. Про атрибуты — все. Более интересные
данные о файлах мы получим, когда начнем использовать FSO. Но об этом не сегодня.

Итак, для хранения атрибута (на основании «поразрядного сравнения»)
продолжаем объявлять переменные (еще две)

Dim Attr As
Long 'числовая, для атрибута файла
Dim AttributFile As String
'строковая, для записи атрибута в виде слов

Напишем маленькую процедурку для Dir1 на событие Change.
Дело в том, что событие Change наступает при двойном клике, а я и хочу,
чтобы директория для поиска файлов устанавливалась по двойному клику. В этой
процедурке мы очистим Text1 и обнулим переменные, ну и главное, запишем
в переменную OurDir полный путь к директории, после чего перейдем к другой
поцедуре — ScanDir, где собственно и будем искать файлы и записывать
их имена и атрибуты в наш массив Files.

Private Sub
Dir1_Change()

Text1.Text = ""

FileName = ""

X = 0

OurDir = Dir1.Path

ScanDir 'переходим к процедуре сканирования файлов
End Sub

Далее в процедуре ScanDir все, с учетом комментариев, понятно:

Private Sub
ScanDir()

FileName = Dir(OurDir & "\*.*", 0) 'присваиваем
переменной значение функции Dir для всех файлов
ReDim Files(2, 1) 'переобъявляем
массив с минимальной размерностью, иначе может возникать ошибка
Do While FileName <> ""
'запускаем цикл, до тех пор, пока Dir не вернет пустую строку

X = X + 1 'счетчик элементов массива
ReDim Preserve Files(2, X) 'переобъявляем
массив по счетчику, сохраняя уже имеющиеся в нем данные

AttributFile = "" 'обнуляем переменные

Attr = 0
'проверяем файл на атрибут архивный

Attr = GetAttr(OurDir & "\" & FileName) And
vbArchive
If Attr > 0 Then
AttributFile = AttributFile & " Архивный"
'проверяем файл на атрибут только для чтения

Attr = GetAttr(OurDir & "\" & FileName) And
vbReadOnly
If Attr > 0 Then
AttributFile = AttributFile & " Только чтение"
'проверяем файл на атрибут скрытый для порядка, Бейсик
все равно не видит такие файлы

Attr = GetAttr(OurDir & "\" & FileName) And
vbHidden
If Attr > 0 Then
AttributFile = AttributFile & " Скрытый"

Files(1, X) = FileName 'пишем в массив имя файла

Files(2, X) = AttributFile 'пишем в массив атрибут файла

FileName = Dir() 'запускаем функцию Dir без атрибутов
Loop 'и так в цикле, пока
файлы в директории не закончатся

If X > 0 Then

Sort ' если хоть один файл найден,

'отправляемся к процедуре сортировки
Else

Text1.Text = "Файлов не найдено" 'в противном
случае выводим сообщение.
End If

End Sub


Основная прелесть массивов в том, что с данными, записанными в них, можно что
угодно делать: сортировать, разбивать на группы, осуществлять поиск, делать
выборки и т.п. Сейчас мы наш массив отсортирум по возрастанию имен файлов. Скажу
сразу, что алгоритмы сортировки разработаны и существуют давно. Приводимый в
примере был разработан лично мною, а возможное совпадение его с другими алгоритмами
совершенно случайно. Но прежде, чем перейти к сортировке, я хочу рассказать
вот о чем.
Поскольку количество элементов нашего массива меняется,
а для сортировки его с помощью циклов For…Next нам надо точно знать
минимальный (нижняя граница) и максимальный (верхняя граница) доступные значения
индекса массива, то я использую функции LBound для определения минимального
индекса и UBound для определения максимального индекса указанной размерности.
Синтаксис их такой

Переменная=LBound(Massive,1) 'возвращает в Переменную
минимальный индекс массива Massive по размерности 1.
Переменная=UBound(Massive,1) 'возвращает в Переменную
максимальный индекс массива Massive по размерности 1.

Надо сказать, что размерность — не обязательный параметр и по-умолчанию принимается
за единицу.

Теперь перейдем к сортировке массива:

Private Sub Sort() 'процедура
сортировки
Dim K As Long
Dim N As Long
Dim y As Long 'просто
для цикла For...Next
Dim Peremen As String
'для временного храненения из массива имени файла
Dim Peremen2 As String
'и атрибута файла
Dim NomerPerem As String
Dim NomerPerem2 As String
'сортировка массива

K = LBound(Files, 2) 'присваиваем переменной К начальное
значение массива - 1 (нижняя граница)
For y = LBound(Files, 2) To
UBound(Files, 2) 'просматриваем все строки массива с нижней
до верхней границы

Peremen = Files(1, y) 'присваиваем каждую строку в переменные

Peremen2 = Files(2, y)
'вложенный цикл
For N = y To UBound(Files,
2) 'просматриваем строки массива, начиная с той,

'значения которой храняться в переменных Peremen и Peremen2

If Files(1, N) < Peremen Then
‘если значение в массиве меньше, чем в переменной

Peremen = Files(1, N) ‘то присваиваем переменным Peremen
и Peremen2 новые, меньшие значения

Peremen2 = Files(2, N)

K = N ‘присваиваем номер найденного элемента массива переменной
K
End If
Next N
‘конец вложенного цикла

NomerPerem = Files(1, y) ‘сохраняем в переменных старые
значения строки массива

NomerPerem2 = Files(2, y)

Files(1, y) = Peremen ‘ и присваиваем этой строке массива
новые

Files(2, y) = Peremen2
If K > 0 Then ‘если K
не ноль,

Files(1, K) = NomerPerem ‘то строке К присваиваем старые
значения из строки y

Files(2, K) = NomerPerem2
End If

Peremen = «» ‘обнуляем переменные

Peremen2 = «»

K = 0
Next y
‘конец сортировки
‘просто выводим в Text1 отсортированные значения массива
For X = 1 To UBound(Files,
2)

Text1.Text = Text1.Text & Files(1, X) & Files(2, X) & vbCrLf
Next X
End Sub

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

Можно ли присвоить один массив другому не по отдельному элементу (в цикле),
а сразу.

Присвоение массивов.

Visual Basic 6.0 и версии выше дают возможность проводить операции присваивания
с массивами точно также, как с переменными. Теперь нет необходимости создавать
цикл For…Next для присваивания одного массива другому по каждому элементу.
Достаточно написать такой оператор
NewMassive=OldMassive

и содержимое массива OldMassive присвоится массиву NewMassive.

Однако при этом следут учитывать, что для исключинения ошибок при таком присвоении,
желательно соблюдать одинаковую размерность и тип массивов. Хотя при присвоении
динамического массива динамическому массиву, массив в левой части оператора
изменяется, как бы подстраивается под оператор в правой части. Однако при работе
со статическими массивами возможна ошибка компиляции. Кроме того при присвоении,
например массива типа Long типу Integer может возникнуть ошибка переполнения
(Owerflow). В программе операция присвоения может выглядеть приблизиельно так
(на форме должны быть кнопка Command1 и текстбокс Text1):

Option Explicit

Dim OldMassive() As Long
Dim NewMassive() As Long

Private Sub Command1_Click()
Dim x As Long

For x = 0 To 999 ‘просто
заполнение массива цифрами
ReDim Preserve OldMassive(x)

OldMassive(x) = x
Next x

NewMassive = OldMassive ‘присоение массивов

For x = 0 To UBound(NewMassive)
‘ считывание нового массива в Text1

Text1.Text = Text1.Text & NewMassive(x) & vbCrLf
Next x
End Sub

Я думаю, особых комментариев здесь не требуется.





Сайт создан в системе uCoz

Работа с массивами в Visual Basic

* Задание: Разработайте приложение, которое вычисляет сумму и среднее арифметическое 10 целых чисел от 0 до 100.

Выполнение:

1. Создайте новый проект. Расположите элементы управления на новой форме (рис. 15.1).

Рис. 15.1. Форма «Массивы»

2. Задайте свойству Multiline для текстового окна txtМассив значение равное true (для того, чтобы в текстовом окне можно было выводить текст в несколько строк).
3. Далее необходимо запрограммировать кнопку Вычислить так, чтобы в текстовое окно выводились элементы массива, их сумма, а затем их среднее арифметическое. Для этого в процедуре, описывающей событие щелчка мыши по кнопке Вычислить, опишем переменные, которые мы будем использовать при решении поставленной задачи:

Dim Массив(9) As Integer
Dim i As Integer
Dim Сумма As Integer

Dim Массив(9) As Integer
Dim i As Integer
Dim Сумма As Integer

4. Для среднего арифметического специальную переменную описывать не надо, потому что оно вычисляется по формуле Сумма разделить на 10.
5. Для того чтобы задать значения элементов массива, воспользуемся циклом:

For i = 0 To 9
Массив(i) = Rnd() * 100
Next

For i = 0 To 9
Массив(i) = Rnd() * 100
Next

Функция Rnd возвращает значение, которое меньше 1, но больше или равно нуля.

6. Теперь задайте начальное значение для Суммы, равное 0
7. С помощью следующего цикла вычислим сумму элементов массива:

For i = 0 To 9
 Сумма = Сумма + Массив(i)
Next

For i = 0 To 9
Сумма = Сумма + Массив(i)
Next

8. Теперь осталось вывести элементы массива, сумму и среднее арифметическое в текстовое окно.
9. Сначала выведите фразу Массив:

txtМассив.Text = "Массив: "

txtМассив.Text = «Массив: «

10. Теперь в цикле необходимо вывести элементы массива:

For i = 0 To 9
 txtМассив.Text = txtМассив.Text + Str(Массив(i))
Next

For i = 0 To 9
txtМассив.Text = txtМассив.Text + Str(Массив(i))
Next

Функция str представляет возвращаемое числовое значение как строковое (String).

11. Для того чтобы выводить текст с новой строки, добавьте символ перехода на новую строку, ASCII-код которого равен Chr(10)+Chr(13) (или значение встроенной константы vbCrLf), т.е.:

txtМассив.Text = txtМассив.Text + vbCrLf + "Сумма:" + Str(Сумма)

txtМассив.Text = txtМассив.Text + vbCrLf + «Сумма:» + Str(Сумма)

12. Самостоятельно добавьте вывод в текстовое окно среднего арифметического.
13. Запустите и отладьте программу.

Дополнительное задание:

1. Разработать приложение, которое находит максимальное и минимальное число из 15 заданных целых чисел.

Контрольное задание:

1. Разработайте приложение сортировки одномерного массива по возрастанию.

Вопросы для самоконтроля:

1. Как объявляется массив в VB?
2. Сколько элементов будет содержать массив, который описан с помощью следующего оператора:

Dim Девять(9) as integer

Dim Девять(9) as integer

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

* При использовании материалов обязательна ссылка на источник: Майер С.Ф., «MS Visual Basic 2008» — Учебно-методическое пособие : Южный федеральный университет. – Ростов-на-Дону, 2017. – 92 с.

Visual Basic.NET. Массивы

Урок из серии «Программирование на Visual Basic.NET для школьников»

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

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

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

Преимущество в использовании массивов состоит в том, что:

• Не нужно придумывать большое количество имен для идентификации ячеек, предназначенных для хранения информации в памяти. Достаточно  одного имени — имени массива. Доступ к отдельным элементам будет  осуществляется по имени массива и порядковому номеру (индексу) элемента в массиве.
• Использование переменных  в качестве индексов позволяет применять для обработки массивов операторы цикла.

Итак ….

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

Массив – это набор однотипных переменных или объектов, объединенных одним именем.

В массиве элементы пронумерованы. Номер элемента в массиве называется индексом.

Массив может быть одномерным или многомерным.

Размерность массива соответствует числу индексов, необходимых для идентификации отдельного элемента. Можно задать до 32 индексов, хотя случаи использования более трех индексов очень редки.

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

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

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

Доступ к элементу массива производится по его имени, состоящему из имени массива и значению индекса, например N(5).

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

Например, оператор:

a(1) = a(0)

присваивает второму элементу массива значение, равное значению первого элемента.

Как массивы хранятся в памяти компьютера

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

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

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

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

Объявим одномерный целочисленный массив, содержащий 10 элементов.

Dim N(9) As Integer

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

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

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

Это можно сделать различными способами:

• заполнить массив случайными числами;
• заполнить массив символами с клавиатуры;
• заполнить массив из файла.

Проект «Заполнение массива»

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

1. Создадим графический интерфейс проектаДля этого поместить на форму:
   • Список ListBox1 для вывода целочисленного массива, заполненного случайными числами;
   • Список ListBox2  для вывода строкового массива, заполненного символами с клавиатуры;
   • Список ListBox3  для вывода строкового массива, заполненного символами алфавита из файла;
   • Кнопки Button1, Button2, Button3 для создания обработчиков событий.
2. Заполним массив N(I) целыми случайными числами из диапазона от 1 до 100.На языке Visual Basic.NET для генерации случайных чисел используется функцию Rnd(). При запуске программы функция Rnd() дает псевдослучайную (т.е. каждый раз повторяющуюся) последовательность чисел из диапазона [0, 1].Для получения числовой последовательности случайных чисел из промежутка [0; 100], умножим полученное с помощью функции Rnd() число но 100 и выделим из полученного числа целую часть: Int(Rnd()* 100). Для получения случайных чисел из произвольного интервала [A;B] можно воспользоваться следующей формулой:

   (B – A) * Rnd() +A.

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

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

   ' Заполнение массива случайными числами
   
         Dim i, N(9) As integer
         Randomize()
         ListBox1.Items.Clear()
         For i = 0 To 9
             N(i) = Int(Rnd() * 100)
             ListBox1.Items.Add(Str(N(I)))
         Next i

3. Заполним массив с клавиатуры.Для ввода элементов массива с клавиатуры можно использовать функцию InputBox(). Аргументами этой функции являются две строки, которые отображаются в диалоговом окне ввода, а значением функции – символ, введенный пользователем.Обработчик события заполнения массива с клавиатуры:

    'Заполнение текстового массива из 5 элементов  с клавиатуры
        Dim A(4) As String
        Dim i As integer
        For I = 0 To 4
            A(I) = InputBox("Введите " + Str(I + 1) + " элемент массива:", 
                             "Ввод элементов массива с клавиатуры")
            ListBox2.Items.Add(A(I))
        Next I

4. Заполним строковый массив буквами русского алфавита из текстового файла.Создадим в текстовом редакторе файл и введем первые 10 букв русского алфавита по одной букве в строке. Файл должен содержать только коды самих символов (не должен содержать управляющие коды форматирования текста) и, следовательно, должен создаваться в простейшем текстовом редакторе типа Блокнот. Сохраним файл alfavit.txt в кодировке Unicode.Для чтения из файла предназначен класс объектов StreamWriter из пространства имен System.IO. Поэтому добавим следующие операторы в самом начале кода, перед объявлением класса формы, которое начинается с Public Class Form1.

     
   Imports System
   Imports System.IO

   В обработчике события заполнения массива из файла объявим массив и переменную, которая будет ссылкой на объект StreamReader. В цикле со счетчиком произведем чтение букв алфавита из файла с использованием метода ReadLine() и введем буквы в список.

   Обработчик события заполнения массива из файла:

    
   'Заполнение текстового массива из  файла
   Dim B(32) As String
   Dim sr As StreamReader
   sr = New StreamReader("alfavit.txt") 
   
   For I = 0 To 9
       B(I) = sr.ReadLine()
       ListBox3.Items.Add(B(I))
   Next I

   Более подробно о работе с текстовым файлом можно посмотреть здесь.

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

   Так как не все элементы массива помещаются в список, появляется вертикальная полоса прокрутки.

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

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

Следующий урок: Обработка массива. Поиск максимального элемента

До встречи в следующем уроке.

Visual Basic 6.0.
Основные
навыки —
Глава 5

Лабораторная
работа №5

Массивы

Цель
работы:
Освоить
работу с
массивами.

Теоретическое
введение.

Помимо
отдельных
ячеек памяти
Visual Basic работает
также с
массивами.

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

Чтобы
объявить
массив
используют
следующий
синтаксис:

Dim | Public | Private
ArrayName(Subscript) As DataType

·       
Dim
| Public | Private –
ключевое
слово Visual Basic, которое
определяет
область его
видимости
(см. выше
раздел
«Переменные»).

·       
ArrayName
– имя
массива.

·       
Subscript
– номер
последнего
элемента в
массиве (например,
если это чис­ло
6, то в массиве
будет семь
элементов;
помните, что
номера эле­ментов
в массиве
начинаются с
нуля).

·       
As
– ключевое
слово Visual Basic, которое
предваряет
объявление
типа.

·       
DataType
– любой
допустимый в Visual Basic тип
данных,
например «Integer»
или «Double».

Следовательно,
объявление
массива из
пяти
элементов
типа «Integer» должно
выглядеть
так:

Dim MyArray(4) As Integer

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

MyArray(0) =  9

MyArray(l) = 342

MyArray(2) = 2746

MyArray(3) = 0

MyArray(4) = 8901

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

ReDim [Preserve]
ArrayName(Subscript) [As DataType]

·       
ReDim —
ключевое
слово Visual Basic,
означающее
изменение
размеров
массива.

·       
Preserve —
необязательное
ключевое
слово Visual Basic, указывающее
на
необходимость
сохранения
прежних
значений
элементов
массива. Если
при переопределении
размеров
массива это
ключевое
слово не
использовать,
значения
всех
элементов
будут равны:
нулю — для числовых
типов данных,
пустой
строке — для
строкового
типа и «Empty» —
для типа Variant.

·       
ArrayName — имя
массива.

·       
Subscript
— индекс
последнего
элемента в
массиве.

·       
As
— ключевое
слово Visual Basic,
предваряющее
объявление
типа данных.

·       
DataTуре —
любой
допустимый в
Visual Basic тип данных.
При переопределении
размера
массива этот
параметр
необязателен,
т.к. изменить
тип невозможно.
Тип массива
можно
переопределить
ключевым
словом «ReDim»
только в том
случае, если
массив имеет
тип «Variant».

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

‘ Создаем
массив без
элементов

Dim strMyArray() as String

‘ Определяем
начальную
размерность
массива

ReDim strMyArray(5)

‘
Присваиваем
значения
элементам
массива

strMyArray(0) = «I
am a pitcher.»

strMyArray(1) = «I
am a catcher.»

strMyArray(2) = «I
play first base.»

strMyArray(3) = «I
play second base.»

strMyArray(4) = «I
play third base.»

strMyArray(5) =
«I play shortstop.»

‘Добавляем элемент
таким
образом,
чтобы
сохранить

‘ значения
элементов,
определенных
ранее

ReDim Preserve strMyArray(6)

‘Присваиваем
значение
новому
элементу массива

strMyArray(6) = «I
am the designated hitter»

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

Массивы,
объявленные
с уже
конкретным
количеством
ячеек,
называются статическими.
Под них сразу
резервируется
необходимое количество
памяти ОЗУ,
определяемое
его типом и
количеством
ячеек.

До сих пор
обсуждались
лишь
одномерные
массивы.
Однако в Visual Basic
можно
создавать и
много­мерные
массивы,
число
размерностей
которых
ограничено 60.

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

iVar(2,3) = 49

Оператор
объявления
двухмерного
массива
имеет
следующий
синтаксис:

Dim | Public | Private
MyArray(NumOfCols, NumOfRows) As DataType

Независимо
от
размерности
массивов
работа с ними
осуществляется
аналогично
вышеприведенной
для
одномерных
объектов.

Задание1.
Составить
программу
для расчета
суммы и произведения
элементов
одномерного
массива:
задание №11
и №12,
методичка 279 с
применением
операторов
цикла.
Исходные массивы
заполнить
автоматически
датчиком
случайных
величин.

Пояснения:

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

Заполнение
массива
случайными
числами должно
происходить
автоматически.
Это
осуществляется
функцией «RND(1)»,
которая
выдает
случайное
число в диапазоне
[0; 1). Для того
чтобы
выражение
могло генерировать
число в
диапазоне [b; c] нужно
воспользоваться
следующим
выражением:

Int(Rnd(1)
* (c — b + 1)) + b

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

Задание2.
Составить
программу
для расчета
указанных
параметров:
задание №14
(расчет
двухмерного
массива), №15
(расчет суммы
элементов
двухмерного
массива), №16
(расчет
одномерного
массива) методичка
279 с
применением
операторов
вложенных
циклов.
Исходные
массивы
заполнить
автоматически
датчиком
случайных
величин.

Пояснения:

Форма
окна
приложения
для 15 задания
будет
аналогичной
предыдущему.
Для 14 и 16 задачи
необходимо
вывести на
экран
полученный
массив. Для
этого
используем
текстовые
поля в режиме
многострочности.
Для этого у
текстового
поля
изменяем
значение
свойства «Multiline»
на «True».
Текстовое
поле после этого
можно
растягивать
по вертикали
(сделайте его
крупнее для
вмещения
всего массива
на экран). Для
вывода
значений
всего массива
используем
стандартный
прием:
сначала стираем
весь текст из
текстового
окна (до начала
цикла), а
затем на
каждой
итерации берем
содержимое
окна,
прибавляем к
нему новый элемент
массива,
символ
перехода на
следующую
строчку и все
это
присваиваем
тому же текстовому
окну:

For i = 1
to 10

  TextBox1.Text = TextBox1.Text &
Massiv(i) & vbCrLf

Next

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

Для
получения
ровных
столбцов
используют
функцию «Format». Она
позволяет
представить
число в нужном
формате.
Формат
указывается
вторым аргументом
с помощью
маски (0 –
обязательный
разряд числа:

For i = 1 to 10

  For j = 1 to 10

    TextBox1.Text =
TextBox1.Text & Format(Massiv(i), «0.000») & “  “

  Next

  TextBox1.Text =
TextBox1.Text & vbCrLf

Next

где число
предстанет в
виде одного
разряда в
целой части и
три разряда в
дробной.

VBA — Жесткие массивы (массивы массивов)

пример

Ядра массивов НЕ многомерные массивы

Массивы массивов (Jagged Arrays) не совпадают с многомерными массивами, если вы думаете о них визуально. Многомерные массивы будут выглядеть как Matrices (Rectangular) с определенным количеством элементов по их размерам (внутри массивов), в то время как массив Jagged будет похож на ежегодный календарь с внутренними массивами, имеющими различное количество элементов, например, дни в разные месяцы.

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

Создание поврежденного массива

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

Dim OuterArray() As Variant
Dim Names() As Variant
Dim Numbers() As Variant
'arrays are declared variant so we can access attribute any data type to its elements

Names = Array("Person1", "Person2", "Person3")
Numbers = Array("001", "002", "003")

OuterArray = Array(Names, Numbers)
'Directly giving OuterArray an array containing both Names and Numbers arrays inside

Debug.Print OuterArray(0)(1)
Debug.Print OuterArray(1)(1)
'accessing elements inside the jagged by giving the coordenades of the element

Динамическое создание и чтение массивов с зубцами

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

   Name -   Phone   -  Email  - Customer Number 
Person1 - 153486231 - 1@STACK - 001
Person2 - 153486242 - 2@STACK - 002
Person3 - 153486253 - 3@STACK - 003
Person4 - 153486264 - 4@STACK - 004
Person5 - 153486275 - 5@STACK - 005

Мы будем динамически строить массив заголовков и массив Customers, заголовок будет содержать заголовки столбцов, а массив Customers будет содержать информацию каждого клиента / строки в виде массивов.

Dim Headers As Variant
' headers array with the top section of the customer data sheet
    For c = 1 To 4
        If IsEmpty(Headers) Then
            ReDim Headers(0)
            Headers(0) = Cells(1, c).Value
        Else
            ReDim Preserve Headers(0 To UBound(Headers) + 1)
            Headers(UBound(Headers)) = Cells(1, c).Value
        End If
    Next
    
Dim Customers As Variant
'Customers array will contain arrays of customer values
Dim Customer_Values As Variant
'Customer_Values will be an array of the customer in its elements (Name-Phone-Email-CustNum)
    
    For r = 2 To 6
    'iterate through the customers/rows
        For c = 1 To 4
        'iterate through the values/columns
            
            'build array containing customer values
            If IsEmpty(Customer_Values) Then
                ReDim Customer_Values(0)
                Customer_Values(0) = Cells(r, c).Value
            ElseIf Customer_Values(0) = "" Then
                Customer_Values(0) = Cells(r, c).Value
            Else
                ReDim Preserve Customer_Values(0 To UBound(Customer_Values) + 1)
                Customer_Values(UBound(Customer_Values)) = Cells(r, c).Value
            End If
        Next
        
        'add customer_values array to Customers Array
        If IsEmpty(Customers) Then
            ReDim Customers(0)
            Customers(0) = Customer_Values
        Else
            ReDim Preserve Customers(0 To UBound(Customers) + 1)
            Customers(UBound(Customers)) = Customer_Values
        End If
        
        'reset Custumer_Values to rebuild a new array if needed
        ReDim Customer_Values(0)
    Next

    Dim Main_Array(0 To 1) As Variant
    'main array will contain both the Headers and Customers
    
    Main_Array(0) = Headers
    Main_Array(1) = Customers

To better understand the way to Dynamically construct a one dimensional array please check Dynamic Arrays (Array Resizing and Dynamic Handling) on the Arrays documentation.

Результатом приведенного выше фрагмента является массив с чередованием с двумя массивами, один из тех массивов с 4 элементами, 2 уровня отступа, а другой сам по себе является другим массивом Jagged, содержащим 5 массивов из 4 элементов каждый и 3 уровня отступа, см. Ниже структуру:

Main_Array(0) - Headers - Array("Name","Phone","Email","Customer Number")
          (1) - Customers(0) - Array("Person1",153486231,"1@STACK",001)
                Customers(1) - Array("Person2",153486242,"2@STACK",002)
                ...
                Customers(4) - Array("Person5",153486275,"5@STACK",005)

Чтобы получить доступ к информации, которую вы должны иметь в виду о структуре созданного массива Jagged Array, в приведенном выше примере вы можете видеть, что Main Array содержит массив Headers и массив массивов ( Customers ), следовательно, с различными способами доступ к элементам.

Теперь мы прочитаем информацию о Main Array и распечатаем каждую из данных Клиентов в виде Info Type: Info .

For n = 0 To UBound(Main_Array(1))
    'n to iterate from fisrt to last array in Main_Array(1)
    
    For j = 0 To UBound(Main_Array(1)(n))
        'j will iterate from first to last element in each array of Main_Array(1)
        
        Debug.Print Main_Array(0)(j) & ": " & Main_Array(1)(n)(j)
        'print Main_Array(0)(j) which is the header and Main_Array(0)(n)(j) which is the element in the customer array
        'we can call the header with j as the header array has the same structure as the customer array
    Next
Next

ЗАПОМНИТЕ, чтобы отслеживать структуру вашего Jagged Array, в приведенном выше примере для доступа к имени клиента, Main_Array -> Customers -> CustomerNumber -> Name к Main_Array -> Customers -> CustomerNumber -> Name который состоит из трех уровней, для возврата "Person4" вам понадобится расположение клиентов в Main_Array, затем местоположение клиента 4 в массиве Jagged Customers и, наконец, местоположение Main_Array(1)(3)(0) элемента в этом случае Main_Array(1)(3)(0) который является Main_Array(Customers)(CustomerNumber)(Name) .

Массивы Visual Basic

Главная »Учебное пособие по Excel-VBA» Массивы Visual-Basic

Введение в массивы Visual Basic

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

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

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

После того, как вы объявили массив, как указано выше, каждая запись массива может быть заполнена следующим образом:

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

Это показано в примере кода ниже, который выводит каждое имя в массиве Team_Members в столбец A текущего рабочего листа Excel:

Даже с 20 именами преимущества использования массива очевидны, но представьте, если бы у вас было 1000 имен для хранения! А представьте, что вы хотите хранить фамилии отдельно от имен! Вскоре стало почти невозможно обрабатывать такой объем данных без использования массивов в вашем коде VBA.

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

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

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

Чтобы получить доступ к записям в массиве Jan_Sales_Figures, вам необходимо использовать два индекса, со ссылкой на день месяца и номер команды. Например, данные о продажах для Team2 15 января будут обозначаться как:

Таким же образом можно объявлять массивы с 3 или более измерениями. Т.е. путем добавления дополнительных измерений в объявление и использования дополнительного индекса для ссылки на записи массива.

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

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

Это объявление сообщает компилятору VBA, что массив Team_Members имеет 20 переменных, которые являются на которые ссылаются индексы от 1 до 20. Однако мы также можем решить проиндексировать 20 переменных массива от 0 до 19, и в этом случае объявление будет выглядеть следующим образом:

In Фактически, по умолчанию индексирование массива начинается с 0, поэтому, если вы опустите начальный индекс в объявлении и просто объявите массив как:

Затем VBA компилятор поймет, что это массив из 20 переменных, индексированных от 0 до 19.

Те же правила применяются к объявлениям многомерных массивов Visual Basic. Как показано в предыдущем примере, двумерный массив объявляется путем разделения индексов измерений запятой:

Однако, если мы опустим начальные индексы из обоих измерений, как показано ниже:

это понимается как двумерный массив, в котором первое измерение имеет 32 записи, проиндексированные от 0 до 31 а второе измерение имеет 6 записей, индексированных от 0 до 5.

Динамические массивы

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

Динамический массив объявляется с пустыми круглыми скобками, как показано ниже:

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

Если во время выполнения кода вам нужно увеличить размер массива, вы можете снова использовать ReDim:

Следует отметить, что изменение размера динамического массива таким образом приведет к потере всех значений, которые ранее были сохранены в массиве.Если вы хотите избежать этой потери и сохранить значения, которые были ранее присвоены массиву, вам необходимо использовать ключевое слово «Preserve», как показано ниже:

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

Перейти к Excel VBA Tutorial, Часть 4 — Функции и подпроцедуры
Вернуться на страницу Excel VBA Tutorial .

Учебное пособие по массивам Visual Basic

Адам Вехманн

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

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

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

Массив очень похож на стойку для компакт-дисков. Вы знаете: одна из тех прямоугольных коробок с прорезями для вставки компакт-дисков, расположенных друг над другом.
Существует два типа массивов Visual Basic: массивы фиксированного размера и динамические.

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

Массив фиксированного размера наиболее точно соответствует анологии нашей стойки для компакт-дисков. Количество слотов, в которые можно вставлять компакт-диски, ограничено. Представьте, что у вас есть три компакт-диска: один от Deftones, другой от Tool, а третий от Disturbed. Чтобы все это поместилось в стойке, в ней должно быть не менее трех слотов. Итак, вы объявляете стойку для компакт-дисков имеющей три слота:

 Dim strCDRack (от 0 до 2) как строка 

Вы только что создали переменную strCDRack, которая содержит три слота (# 0, # 1 и # 2) и имеет тип данных String.Теперь вы можете вставить в него свои компакт-диски:

 Dim strCDRack (от 0 до 2) как строка
      
strCDRack (0) = "Deftones"
strCDRack (1) = "Инструмент"
strCDRack (2) = "Потревоженный" 

Обратите внимание, что каждая из трех новых строк начинается с имени переменной, а затем дает номер элемента перед присвоением значения. Это похоже на нумерацию слотов на стойке для компакт-дисков, начиная с 0 до 2, а затем вставку компакт-диска в каждый слот.

Формат объявления массива:

Dim | Public | Private ArrayName ( Subscript ) As DataType

• Dim , Public и Private объявляют массив и его область действия.Использование Dim в процедуре сделает массив доступным только внутри этой процедуры. Использование его в разделе общих объявлений сделает его доступным для всех процедур в этом модуле. Private имеет тот же эффект и должен использоваться только на модульном уровне. Использование Public сделает массив доступным на протяжении всего проекта.
• ArrayName — имя массива.
• Нижний индекс — это размеры массива.
• DataType — любой допустимый тип данных.

Динамические массивы

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

 Dim strCDRack () как строка
      
ReDim strCDRack (от 0 до 2) как строка
      
strCDRack (0) = "Deftones"
strCDRack (1) = "Инструмент"
strCDRack (2) = "Потревоженный" 

Что вы наделали? Ничего страшного, вы только что изменили размер вашего массива другим способом, который допускает расширение.Обратите внимание, что нижний индекс оператора Dim отсутствует. Хорошо; он сообщает VB, что ваш массив является динамическим, что означает, что вы можете изменить его размер с помощью ReDim .

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

 Dim strCDRack () как строка
      
ReDim strCDRack (от 0 до 2) как строка
      
strCDRack (0) = "Deftones"
strCDRack (1) = "Инструмент"
strCDRack (2) = "Потревожено"
      
ReDim Сохранить strCDRack (от 0 до 3) как строку
      
strCDRack (3) = "Церковь Шарлотты" 

В этом фрагменте есть еще две строки, в первой выполняется изменение размеров массива на один элемент больше, а во второй задается значение этого элемента.Обратите внимание на ключевое слово Preserve : оно заставляет Visual Basic сохранять значения всех существующих элементов. Без этого ключевого слова все ваши старые компакт-диски были бы потеряны, и вы бы застряли только на Шарлотте Черч.

Синтаксис ключевого слова ReDim:

ReDim [Сохранить] Имя массива ( Подстрочный индекс ) Как Тип данных

• ReDim — это ключевое слово, которое обозначает, что мы изменяем размер массива.
• Preserve — необязательное ключевое слово, которое заставляет Visual Basic сохранять значения всех существующих элементов. Без этого все элементы вернутся к своим значениям по умолчанию. (Числовые типы данных равны 0, строки переменной длины — «» (строка нулевой длины), строки фиксированной длины заполнены нулями, а варианты — пустыми.)
• ArrayName — имя массива.
• Нижний индекс — это размеры массива.
• DataType — любой допустимый тип данных. Тип данных не может быть изменен из исходного объявления при использовании ключевого слова ReDim . (Если он изначально не был заявлен как вариант.)

Получение содержимого массива

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

 Dim strFriends (от 0 до 6) как строка
      
strFriends (0) = "Бьянка"
strFriends (1) = "Джина"
strFriends (2) = "Сэм"
strFriends (3) = "Дженна"
strFriends (4) = "Эрин"
strFriends (5) = "Кэролайн"
strFriends (6) = "Кейт" 

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

 Dim strFriends (от 0 до 6) как строка, lngPosition как длинное
      
strFriends (0) = "Бьянка"
strFriends (1) = "Джина"
strFriends (2) = "Сэм"
strFriends (3) = "Дженна"
strFriends (4) = "Эрин"
strFriends (5) = "Кэролайн"
strFriends (6) = "Кейт"
      
Для lngPosition = LBound (strFriends) To UBound (strFriends)

    MsgBox strFriends (lngPosition)

Следующее lngPositionlngPositionlngPosition 

В этом фрагменте кода есть две новые функции. LBound и UBound используются для определения нижней и верхней границ массива. Поскольку strFriends имеет нижнюю границу 0 и верхнюю границу 6. Эти
Функции позволяют вам перебирать массив с динамическим размером и избавляют вас от необходимости самостоятельно отслеживать размер массива.
На каждой итерации этого цикла lngPosition будет считать от 0 до 6. Обращаясь к массиву как strFriends (lngPosition) , вы значительно сокращаете объем кода, который вам нужно написать.

Добавление новых элементов на лету

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

 Dim strSongNames () As String 'Массив названий песен
Dim blDimensioned As Boolean 'Измерен ли массив?
Dim strText As String 'Для временного хранения имен
Dim lngPosition as Long 'Counting
      
'Размер массива еще не определен:
blDimensioned = Ложь
      
Делать
          
    'Спроси название песни
    strText = InputBox ("Введите название песни:")
              
    Если strText "" Тогда
              
        'Были ли размеры массива рассчитаны?
        Если blDimensioned = True, то
                  
            «Да, поэтому увеличьте массив на один элемент больше, чем его текущая верхняя граница.'Без ключевого слова "Preserve" ниже предыдущие элементы в нашем массиве
            'будет стерто с изменением размера
            ReDim Сохранить strSongNames (от 0 до UBound (strSongNames) + 1) как строку
                      
        Еще
                  
            «Нет, поэтому обмерьте его и отметьте как размер.
            ReDim strSongNames (от 0 до 0) как строка
            blDimensioned = True
                      
        Конец, если
                  
        'Добавьте название песни к последнему элементу массива.strSongNames (UBound (strSongNames)) = strText
              
    Конец, если
          
Цикл до strText = ""
      
'Показать введенные названия песен:
      
Для lngPosition = LBound (strSongNames) To UBound (strSongNames)
      
    MsgBox strSongNames (lngPosition)
          
Следующая lngPosition
      
'Стереть массив
      
Стереть strSongName
 

Посмотрите комментарии, чтобы узнать, что происходит.

Стирание массива

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

 Dim strFriends (от 0 до 2) как строка
      
strFriends (0) = "Бьянка"
strFriends (1) = "Джина"
strFriends (2) = "Эрин"
      
Стереть strFriends 

Функция разделения

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

 Dim cdList As String
cdList = "Nevermind, хорошо, компьютер, мне не все равно, потому что ты любишь, Icky Thump" 

Было бы неплохо, если бы мы могли легко взять этот список и поместить его в массив, не так ли?
Это можно сделать, используя встроенные строковые функции Visual Basic, однако, написав и
обновление этого кода может оказаться трудоемким и утомительным.К счастью для нас, Visual Basic 6.0 предоставляет встроенный
в функции под названием split , которая позволяет нам легко извлекать информацию из строки и размещать ее
в массив. Она имеет
следующий синтаксис:

ArrayName = split ( Sting Input [, Delimiter [, Length Limit [, Compare Mode ]]])

• String Input — это строка, которую вы хотите проанализировать.
• Разделитель — необязательный параметр, указывающий, какой тип строки разделяет элементы во входной строке. По умолчанию этот параметр установлен на «». Это будет означать, что вводимая строка «Это тест» даст массив из 4 элементов («Это», «равно», «а», «тест»).
• Ограничение длины — это максимальный размер выходного массива.Текст, оставшийся для анализа, будет установлен в качестве последнего элемента в массиве.
• Режим сравнения . По умолчанию Visual Basic сравнивает строки посимвольно, используя их значения ASCII. Однако вы можете использовать разные режимы, которые заставят Visual Basic по-разному сравнивать строки. Например, vbTextCompare делает сравнение строк нечувствительным к регистру. Этот параметр влияет на то, как Delimiter анализирует Input String .

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

 Dim strCDRack () как строка
Dim cdList как строка
Dim i как целое число
          
cdList = "Ладно, хорошо, компьютер, мне не все равно, потому что ты любишь, Ики"
strCDRack = Разделить (cdList, ",")
          
Для i = LBound (strCDRack) To UBound (strCDRack)
          
    MsgBox strCDRack (i)
          
Следующий 

Функция соединения

Функция split позволила нам разбить строки на массивы, есть ли функция, которая позволяет нам
взять массивы и сделать их одной большой длинной строкой? Да, да, есть, и называется он , присоединиться к . join — очень простая функция. Он имеет следующий синтаксис:

StringName = join ( Вход массива [, Delimiter ])

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

Используя один из наших предыдущих примеров, вот пример кода о том, как можно использовать соединение:

 Dim strFriends (от 0 до 6) как строка, lngPosition как длинное
      
strFriends (0) = "Бьянка"
strFriends (1) = "Джина"
strFriends (2) = "Сэм"
strFriends (3) = "Дженна"
strFriends (4) = "Эрин"
strFriends (5) = "Кэролайн"
strFriends (6) = "Кейт"

Dim myFriends как строка

'Это даст следующую строку: «Бьянка, Джина, Сэм, Дженна, Эрин, Кэролин, Кейт»
myFriends = Присоединиться (strFriends, ",")

MsgBox myFriends 

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

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

 'Здесь мы определим массив, в котором первое измерение содержит 2 элемента и
'второе измерение содержит 4 элемента
ReDim cdRack (от 0 до 1, от 0 до 3) как строка

'Стойка для компакт-дисков для Битлз
cdRack (0, 0) = "Резиновая душа"
cdRack (0, 1) = "Револьвер"
cdRack (0, 2) = "Белый альбом"
cdRack (0, 3) = "Пусть будет"

Стойка для компакт-дисков для Rolling Stones
cdRack (1, 0) = «Липкие пальцы»
cdRack (1, 1) = "Банкет нищих"
cdRack (1, 2) = "Пусть кровоточит"
cdRack (1, 3) = "Сделать татуировку"
 

Первый элемент первого измерения — это массив для компакт-дисков Beatles, а второй элемент первого измерения — массив
для компакт-дисков Rolling Stones.Вы также можете добавить третье измерение, если хотите. Продолжая нашу аналогию со стойкой для компакт-дисков, вы можете представить
это третье измерение как коридор с несколькими комнатами. Внутри каждой комнаты будет ряд стоек для компакт-дисков. Если бы ты хотел свой
в коридорах, чтобы иметь 10 комнат, каждая со стойками для компакт-дисков, как в приведенном выше примере, вы можете объявить свой массив
следующее:

 Dim cdRackHallway (от 0 до 9, от 0 до 1, от 0 до 3) как строка 

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

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

 'Здесь мы определим массив, в котором первое измерение содержит 2 элемента и
'второе измерение содержит 4 элемента
ReDim cdRack (от 0 до 1, от 0 до 3) как строка

'Стойка для компакт-дисков для Битлз
cdRack (0, 0) = "Резиновая душа"
cdRack (0, 1) = "Револьвер"
cdRack (0, 2) = "Белый альбом"
cdRack (0, 3) = "Пусть будет"

Стойка для компакт-дисков для Rolling Stones
cdRack (1, 0) = «Липкие пальцы»
cdRack (1, 1) = "Банкет нищих"
cdRack (1, 2) = "Пусть кровоточит"
cdRack (1, 3) = "Сделать татуировку"

ReDim Сохранить cdRack (от 0 до 1, от 0 до 4) как строку

'Давайте добавим еще один компакт-диск Beatles
cdRack (0, 4) = "Эбби Роуд"

'Давайте добавим еще один компакт-диск Rolling Stones
cdRack (1, 4) = "Изгнание на главной улице."
 

Слово Пэта (владельца patorjk.com):
Надеюсь, вам понравилось и вы узнали что-то из этого урока. Изначально это руководство было написано для patorjk.com еще в
1999 Адам Веманн. После того, как patorjk.com был возрожден в 2007 году, я решил вернуть учебник, так как он получил некоторые положительные отзывы.
Обратная связь. Когда он был восстановлен, с концентрацией Адама я внес три новых раздела: «Функция разделения», «Функция соединения» и «Многомерные массивы».Все остальное было написано Адамом в его оригинальном представлении 1999 года.

.