Private Sub Command1_Click(). Напишем для определения номера свободного файла

Напишем для определения номера свободного файла

F = FreeFile

и откроем файл для чтения

Open App.Path & " \Справка.txt" For Input As #F

Обратите внимание, что для указания пути файла мы опять используем функцию App.Path. Если бы мы написали просто " c: \VB\example\Справка.txt", то при переносе нашей паки с программой на другой диск или компьютер этот путь оказался бы ложным. А функция App.Path всегда возвращает путь, где лежит наша программа. Только перед именем файла не забывайте ставить обратный слеж (\), иначе запись работать не будет.
Для считывания строки текста существует оператор Line Input. Попробуем считать с его помощью содержимое файла в переменную MyText:

Line Input #F, MyText

Передадим значение MyText переменной в Text1, чтобы увидеть, что мы там считали:

Text1.Text = MyText

затем закроем файл

Close #F
End Sub

и запустим нашу программу. Когда мы нажмем кнопку Command1, то в Text1 появиться содержимое файла " Справка.txt". Проблема только в том, что, если, (как и случилось в нашем файле " Справка.txt"), при создании текста применялось нажатие кнопки ENTER (перевод строки), то оператор Line Input считает текст до этого знака и все, потому, что строка кончилась. Чтобы этого избежать, мы применим цикл и будем считывать строки до конца файла. Для этого придется разобраться с новым для нас циклом по условию Do... Loop.

Это очень простая вещь. Цикл работает до тех пор, пока не выполнится какое-нибудь условие. Например мы будем увеличивать переменную X до тех пор, пока оне не станет равной, например, 100. Для этого применяется аргумент Until:

Do Until x> =100
x=x+1
Loop

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

Do
x = x + 1
Loop Until x > =100

Можно цикл записать наоборот, и он будеn выполняться до тех пор, пока соблюдается какое-то условие. Для этого применяется аргумент While (делать, пока...):

Do While x < 100
x = x + 1
Loop

или же:

Do
x = x + 1
Loop While x < 100

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

Do While x =100
x = x + 1
Loop

а этот будет бесконечным

Do Until x < 0
x = x + 1
Loop

Ну а теперь используем наш цикл для считывания строк из файла до тех пор, пока не настанет конец файла. Чтобы узнать, достигнут ли конец файла, можно использовать функцию EOF(номер файла), которая примет значение True, как только конец файла будет достигнут. Теперь переделаем нашу процедуру следующим образом:

Private Sub Command1_Click() '1
Text1.Text = " " '2
F = FreeFile '3
Open App.Path & " \Справка.txt" For Input As #F '4
Do Until EOF(F) '5
Line Input #F, MyText '6
Text1.Text = Text1.Text & MyText & vbCrLf '7
Loop '8
Close #F '9
End Sub '10

По строкам здесь:
1 - объявление нашей процедуры
2 - очистка Text1
3 - присваиваем переменной F свободный номер файла
4 - открываем файл " Справка.txt" для последовательного чтения
5 - цикл по условию: до тех пор пока не конец файла
6 - DO в цикле считываем каждую строчку
7 - Присоединяем очередную строку к Text1 и ставим перевод строки (vbCrLf) чтоб красиво было
8 - LOOP завершаем цикл
9 - закрываем наш файл
10- конец процедуры
Ну вот и готово.

Сейчас мы считаем файл другим способом, с помощью функции Input. Синтаксис ее такой:
Input(число, [#]номерФайла)

Смысл ее такой, что она из файла [#]номерФайла, открытого в режиме Input считывает число знаков. Мы используем ее также, как оператор Line Input, только считывать будем не по одной строчке, а по одному символу, и собирать их будем в переменной AllMyText, значение которой присвоим потом текстбоксу Text1. Поместим на нашу форму еще одну кнопку Command2 (свойство Caption присвоим " Функция Input") и создадим для нее прцедуру, где и используем функцию Input.

Private Sub Command2_Click()
F = FreeFile
Open App.Path & " \Справка.txt" For Input As #F
Do Until EOF(F)
MyText = Input(1, #F)
AllMyText = AllMyText & MyText
Loop
Close #F
Text1.Text = AllMyText
End Sub

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

Ну и в дополнение попробуем прочитать наш файл с помощью оператора Input #. Это не самая лучшая идея, так как эта инструкция считывает файл, желательно, записанный с оператора Write #. Синтаксис такой:

Input #номерФайла, списокПеременных

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

Private Sub Command3_Click()
F = FreeFile
Open App.Path & " \Справка.txt" For Input As #F
Do Until EOF(F)
Input #F, MyText
AllMyText = AllMyText & ", " & MyText
Loop
Close #F
Text1.Text = AllMyText
End Sub

Это, конечно, некорректное применение оператора, но мы вернемся к нему, когда будем рассматривать запись в файл с помощью оператора Write #. Как ты видишь, запятые не выводятся, приходится их запихивать насильно, не всегда к месту, но ради полноты, я посчитал надо показать и это. Все, теперь запись.

Как и для считывания, прежде, чем записывать в текстовой файл, нужно получить к нему доступ. Для этого используем оператор Open с ключевым словом Output.
Добавим на форму еще кнопку Command4. Создадим для нее процедуру и напишем там:

Private Sub Command4_Click()
F = FreeFile
Open App.Path & " \Запись.txt" For Output As #F

Таким образом мы открыли файл с последовательным доступом, который называется " Запись.txt" в нашей текущей директории под свободным номером #F, для записи (For Output). При этом, если такого файла не существует, он будет создан, а если существует и в нем что-то записано, то это что-то будет стерто, а вместо будет помещены наши новые данные, которые мы сейчас будем записывать, например, скажем с помощью оператора Print #. Записать его можно аналогично оператору считывания Line Input:

Print #F, Text1.Text

То есть, мы записываем содержимое нашего текстбокса (если там что-то есть. Считайте в текстбокс Text1 наш файл Справка.txt нажатием одной из кнопок Command1-Command3) в файл " Запись.txt". Затем закрываем файл и конец процедуре:

Close #F
End Sub

Ты можешь открыть этот файл с помощью Виндусового Блокнота или в любом текстовом редакторе и посмотреть его. Или напиши в нашей программе свой код, чтоб считать этот файл в Text1 и сразу его посмотреть.
В принципе, если тебе это надо, оператор Print # может форматировать текст, т.е. менять отступы от края, вставлять пробелы, но только между переменными, а не конечно в середину, скажем, нашего текста. Для этого используется аргументы Spc (количество пробелов) для введения пробелов и Tab(номер столбца) для вывода данных по столбцам. Положим на форму еще текстбокс Text2 и кнопку Command5 и в ее процедуре напишем код для форматированной записи. Потом считаем наши записи в Text2 с помощью оператора Line Input. С этим, я думаю, ты разберешся сам. (Не забудь поставить свойства Text2: свойство Multiline поставим в True, а свойство ScrollBars в 2 - Вертикаль.

Private Sub Command5_Click()
F = FreeFile
Open App.Path & " \Запись.txt" For Output As #F
'печатаем тексты с 15-й позиции
Print #F, Spc(15); " Я вывожу этот текст"
Print #F, Spc(15); " очень красиво"
Print #F, Spc(15); " потому, что я настоящий"
Print #F, Spc(15); " ПРОГРАММИСТ"
'печатаем пустую строку
Print #F,
'печатаем тексты в 30-ем, 40-м и 50-м стобцах соответственно
Print #F, Tab(30); " тридцатый столбец"
Print #F, Tab(40); " сороковой столбец"
Print #F, Tab(50); " пятидесятый столбец"
'если оператор завершать точкой с запятой, то перехода на следующую строку не будет
Print #F, Spc(15); " Печатаю текст";
Print #F, Spc(15); " не очень хорошо"
' и наконец несколько текстов в одном операторе
Print #F, Spc(10); " 10 пробелов"; Tab(30); " 30-й столбец+ 10 пробелов в начале"; Spc(5); " Пять пробелов"
Close #F

'считаем записанный текст в Text2
Text2.Text = " "
MyText = " "
F = FreeFile
Open App.Path & " \Запись.txt" For Input As #F
Do Until EOF(F)
Line Input #F, MyText
Text2.Text = Text2.Text & MyText & vbCrLf
Loop
Close #F
End Sub

Теперь запишем чего-нибудь в файл с помощью оператора Write #, а потом, уже корректно считаем это оператором Input # о котором мы уже говорили в этой главе. С помощью оператора Write # удобно записывать данные твоей программы. Есть две особенности. Первое - данные разделяются разделителем (запятой), и второе - данные надо считывать в переменные того же типа, что и запись в файле (то есть число - в число, дату в дату, стоку в строку и т.п., иначе возникнет ошибка) и представляются они в файле в достаточно своеобразном виде - каждый в своем формате. Сейчас разберем это на примере, я так думаю, будет понятнее. Положим еще одну кнопку Command6 на форму и в ней объявим переменные четырех разных типов.

Private Sub Command6_Click()
Dim Chislo As Long ' числовая
Dim Stroka As String ' строковая
Dim Logika As Boolean ' логическая
Dim DDate As Date' дата (не путайте с Data)

Надо заметить, что число выводится в файл как число, строка - как строка в кавычках, логическая переменная может принимать только два значения Да и Нет в формате #False# или #True#, а дата в виде #2004-07-20#, что соответствует 20 июля 2004 года. Дальше присваиваем переменным какие-нибудь значения в соответствующем формате

Chislo = 15
Stroka = " пятнадцать"
Logika = True
DDate = #7/20/2004#

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

F = FreeFile
Open App.Path & " \Запись.txt" For Output As #F
Write #F, Chislo; Stroka
Write #F, Logika; DDate
Close #F

'теперь считаем данные с помощью оператора Input#
F = FreeFile
Open App.Path & " \Запись.txt" For Input As #F
Input #F, Chislo, Stroka, Logika, DDate
'и выведем их в Text2
Text2.Text = Chislo & " " & Stroka & " " & Logika & " " & DDate
Close #F
End Sub

Сейчас, когда ты запустишь программу, ты увидишь, что в Text2 данные вывелись в очень достойном виде, но это потому, что мы используем для считывания оператор Input #. Если же ты откроешь файл " Запись" в блокноте или считаешь файл с помощью оператора Line Input, то увидишь несколько иную картину, вот такую:

15, " пятнадцать"
#TRUE#, #2004-07-20#

Поэтому делать текстовые файлы для чтения их в других приложения бессмысленно. Но использовать операторы Write# - Input# внутри программы для работы с собстенными данными очень удобно.

Чтобы добавить новые данные в текстовой файл и при этом не стирать имеющихся там, надо просто открыть файл с ключевым словом Append. Новые данные будут записываться в конец файла. Быстренько разберем это на примере. Для этого положим на форму последнюю кнопку Command7 и в ней напишем код:

Private Sub Command7_Click()
Text2.Text = " "
MyText = " "
F = FreeFile
'открываем файл для дабавления
Open App.Path & " \Запись.txt" For Append As #F
Print #F, Spc(15); " Я добавляю этот текст снова и снова"
Close #F

'считаем записанный текст в Text2
F = FreeFile
Open App.Path & " \Запись.txt" For Input As #F
Do Until EOF(F)
Line Input #F, MyText
Text2.Text = Text2.Text & MyText & vbCrLf
Loop
Close #F
End Sub

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

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

Рисунок 16.

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

Создадим новый exe-проект и положим на форму, например три флажка (CheckBox'а). Ну и вот, по умолчанию в квадратике нет ничего и главное значение этого объекта .Value равно 0 - Неотмечено. Когда мы щелкаем по флажку, то появляется галочка, и значение .Value становится равным 1-Отмечено. Bот и все. Есть еще и третье значение 2 - Выключено, но установить его щелканьем мышки не удасться. Надо либо в окне свойств задать значение, либо в коде написать
Check1.Value=2
при этом квадратик станет сереньким, типа выключился, но если по нему щелкнуть, то он опять примет значение включенного.

Аналогично работает и и радиокнопка (OptionButton) за исключением следующего. Первое: у OptionButton только два значения и принимают они " False " - выключено, точки в кружочке нет, и " True " - включено, точка есть. А второе, если вы на форму положите пять Check'ов, то вы можете включить сколько угодно из них, хоть три, хоть все пять. А вот Option можно включить только один. Если щелкнешь по другому, то включенный тут же выключится.
Кроме того, и у Check и у Option есть еще одно свойство Style. По умолчанию оно равно 0 - Standart. Но если его поставить в состояние 1- Graphical, то бац, твоя фигня с галочкой превращается по виду в кнопку. Внешне от кнопки Command она отличается тем, что в нажатом состоянии она показана, как нажатая. Ну и само собой свойство Caption позволяет Вам обзывать эти объекты, как угодно.

Далее объект Фрейм (Frame). Это как-бы окно, в которое можно запихивать флажки, радиокнопки, да что угодно. Но чтоб объект попал во Frame, надо его туда класть сразу. Если ты его создашь в форме вне фрейма, а потом перетащишь его во фрейм, то ничего не выйдет. Объект просто ляжет сверху. Ну и передвигая фрейм, ты сразу двигаешь и запихнутые туда объекты, что удобно. А если уничтожишь фрейм, то погибнут и все встроенные в него объекты. Вообще фреймами удобно делить форму на зоны. Кроме того, радиокнопки одного фрейма не связаны с радиокнопками другого или с внешними (на форме). Т.е. ты в каждом фрейме можешь создавать свой блок кнопок.

Сейчас мы напишем программку для тестов, где все это попробуем, а заодно потренируемся работать с текстовыми файлами, о чем говорилось в прошлой главе. Смысл программки в том, что мы готовим тест, например, психологический и на вопрос предлагаем испытуемому несколько ответов. По результатам теста выводим характеристику испытуемому.
Во-первых сделаем одну форму Form1 для создания контрольных вопросов, которую испытуемому видеть ни к чему - это форма для руководителя проекта тестирования. А вторая - Form2 - предлагается испытуемому для проведения теста.
Создадим новый exe-проект и на Form1 положим Text1 для занесения вопроса (не забудь его свойство Multiline поставить в True), Text2, Text3 и Text4 - для ответов, Text5, Text6, и Text7 для баллов по каждому ответу, кнопку Command1 для записи этого в файл и кнопки Command2 и Command3 для навигации по файлам (типа вверх-вниз). Я не стал использовать ScrollBar, чтобы не затемнять смысл программы. Поскольку мы еще не все познали-изучили (массивы или там файлы с прямым доступом), то будем записывать каждый вопрос в отдельный файл. Поэтому один Label1 надо положить сразу, он будет показывать номер вопроса, который будет и именем txt-файлов. А лучше сразу положить еще Label2 и Label3. У тебя должно получиться что-то типа рис.17

Рисунок 17.

Теперь убираем во всех Text'ах свойство Text (просто стираем в окне свойств), затем в свойстве Caption лейблов Label2 и Label3 пишем Ответы и Баллы соответственно. В свойствах Caption у кнопки Command1 пишем Сохранить вопрос, у кнопки Command2 - Назад, у кнопки Command3 - Вперед и изменяем их размеры соответственно надписи. Теперь пишем код в окне кода.

Перво-наперво, конечно Option Explicit, если вы не смогли установить VB, чтоб он прописывал это автоматом (я рассказывал как). Потом там - же, в области (General) - (Declarations) объявляем следующие переменные:

Option Explicit
'Для хранения номера вопроса (числовое, потому, что будем
'складывать и вычитать) и одновременно имя файла (строковое).
' Вот единственный случай использования типа Variant
Dim NomVopros As Variant
'и для каждого нашего текстбокса
Dim Vopros As String 'Text1-строковое, здесь пишем вопрос
Dim Otvet1 As String 'Text2-строковое- пишем возможный ответ №1
Dim Otvet2 As String 'Text3 - строковое- пишем возможный ответ №2
Dim Otvet3 As String 'Text4 - строковое- пишем возможный ответ №3
Dim Ball1 As Long 'Text5 -числовое - баллы к ответу №1
Dim Ball2 As Long 'Text6-числовое - баллы к ответу №2
Dim Ball3 As Long 'Text7-числовое - баллы к ответу №3

Почему так? На фик нам эти переменные? Писали бы в файл и грузили бы сразу из TextBox'ов. А потому, во-первых, что из TextBox'ов все бы записывалось как текст (строка), а у нас переменные разных типов, а во-вторых, при считывании вообще возникла бы ошибка, потому что нельзя так. И вообще, лучше всегда использовать переменные, а не объекты. Далее объявим еще две переменные, одна просто для получения свободного номера файла