2

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

 Встроенные типы данных

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

Числа

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

16543      -1951434        100      -1066        0

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

52.887             -11.0005               1668468.1           -0.000004          0.0

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

  *В главе 13 будет дано пояснение

Числовые границы

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

Строки

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

"abcdefghijklmnopqrstuvwxyz"           "Mary had a little lamb"       "123456789"

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

Строковые типы PureBasic

*Определяется длиной, заданной пользователем.

Строки могут быть составлены из любого символа в кодировке ASCII, включая управляющие символы(используемые в памяти) кроме нулевого символа, поскольку он используется, чтобы показать конец строки. Не растраивайтесь, если что то непонятно в этом предложении, просто читайте дальше, со временем все поймете.

Переменные и константы

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

Переменные

Как правило, имя переменной привязано к конкретной области и объему памяти (определяется по его типу данных) , и любые операции с переменной будут манипулировать с областью памяти. Имя переменной задается по желанию и может быть любым, но многие люди делают его максимально информативным, чтобы передать смысл того, что в ней содержится. Переменные являются строительными блоками любой компьютерной программы, так как они хранят данные, которыми можно манипулировать. Переменные, необходимы для организации и хранения данных. Ладно, давайте наконец перейдем к практике в  PureBasic. Откроем среду разработки(IDE) PureBasic и создадим нашу первую переменную. Для того чтобы создать переменную, нужно ввести имя переменной. После имени указать суффикс, которым определяется тип переменной, далее оператором   =   присваиваем значение:

NumberOfLinesOfCode.b = 1

Обратите внимание на имя переменной, в ней нет пробелов и быть не должно! Если вы хотите разделять слова в переменной для большего понимания кода, тогда используйте нижний дефис:

Number_Of_Lines_Of_Code.b = 1

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

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

NumberOfLinesOfCode = 1

Тогда переменная будет иметь тип Long это устанавливается по умолчанию компилятором. PureBasic предоставляет возможность изменять тип по умолчанию с помощью
оператора Define:

Define.b
NumberOfLinesOfCode = 1
TodaysDate = 11

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

Define MyChar.c
Define MyLong.l
Define MyWord.w

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

Define.w Day, Month, Year

Этот код присваивает тип Word для трех переменных Day, Month  и Year. Поскольку они задаются без значений, то им  присваивается значение 0 (ноль).
А теперь пример, показывающий, создание всех типов переменных в PureBasic:

ByteVariable.b = 123
CharVariable.c = 222
WordVariable.w = 4567
LongVariable.l = 891011
QuadVariable.q = 9223372036854775807
FloatVariable.f = 3.1415927
DoubleVariable.d = 12.53456776674545
StringVariableOne.s = "Test String One"
StringVariableTwo$ = "Test String Two"
StringVariableThree.s{6} = "abcdef"
StringVariableFour${3} = "abc"

Вы заметили, последние четыре переменные являются строками, но все они имеют разные суффиксы. Первые два с неограниченной длиной строки, а в двух последних с фиксированной длиной. Суффиксы .S  и  $ . Оба идентичны во всех отношениях. Просто один является старым стилем, а другой новым. Можно применять любой или оба в вашей программе. Но помните: они не являются взаимозаменяемыми. Например, эти две переменные различны:

StringVariable.s = "Test String One"
StringVariable$ = "Test String Two"

Даже если они имеют одинаковое название, различные суффиксы показывают, что они являются различными переменными. Не верите? Ну это можно проверить:

StringVariable.s = "Test String One"
StringVariable$ = "Test String Two"
Debug StringVariable.s
Debug StringVariable$
Debug StringVariable$+" "+StringVariable.s

А теперь по порядку. Присваиваем переменным StringVariable.s   и   StringVariable$   разные значения. А затем с помощью команды Debug выводим результаты в окно отладки. Запустите код нажав F5 . В окне отладки должно быть три результата:

Test String One

Test String Two

Test String Two Test String One (результат сложения двух строк).       " "  используется для разделения пробелом

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

И еще один момент хотелось бы отметить. Переменные не чувствительны к регистру. Посмотрите на следующий пример:

TestVariable.s = "Test String One"
testvariable = "Test String Two"
TeStVaRiAbLe = "Test String Three"
Debug     tEsTvArIaBlE

Вам наверно показалось, что я присвоил трем разным переменным разные значения. На самом деле, я каждый раз присваивал разные значения одной и той же переменной. Фишка вся в том, что если мы какой либо переменной присвоили тип (в нашем случае String), то на протяжении всей последующей жизни программы, эта переменная будет иметь этот тип. И нам не надо каждый раз писать суффикс. А сейчас пример неправильного кода, на который будет ругаться компилятор:

StringVariable.s = "Test String One"
StringVariable = 100

Если вы попробуете запустить, вы получите вежливое послание IDE о том, что вы не можете писать числовые значения в переменную String. Следующий пример будет работать:

StringVariable.s = "Test String One"
StringVariable = "One Hundred"

Поскольку переменная StringVariable была первоначально объявлена как строка, то только строки и можно в нее заносить.
А теперь обобщим основные правила для переменных:

1). Переменные не должны содержать пробелов.
2). Имена переменных не должны начинаться с цифры, но могут их содержать.
3). Имена переменных не должны быть сходны ни с одним из любых операторов.
4). Имена переменных не должны содержать какие-либо специальные символы.
5). По умолчанию, если не указывается суффикс для переменных, то его тип данных Long (до версии 4.30) и Integer (в версии 4.30 и последующих).
6). Если переменная была объявлена, его тип данных не может быть изменен во время выполнения.
7). После объявления переменной ее можно использовать свободно, без суффикса, компилятор помнит его тип.

 Константы

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

#DAYS_IN_THE_YEAR = "365"

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

#DAYS_IN_THE_YEAR = "365"
Debug "There are " + #DAYS_IN_THE_YEAR + " days in the year."

Этот пример, в нашей программе, для компилятора будет таким:

Debug "There are 365 days in the year."

поскольку заменяется постоянной величиной, в данном случае '365 ', а затем компилируется.

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

Перечисление Констант

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

Enumeration
#ZERO
#ONE
#TWO
#THREE
EndEnumeration

Debug #ZERO
Debug #ONE
Debug #TWO
Debug #THREE

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

Enumeration 10
#TEN
#ELEVEN
#TWELVE
EndEnumeration

Debug #TEN
Debug #ELEVEN
Debug #TWELVE

Теперь вы можете увидеть, что у первой константы значение '10', а остальные увеличиваются, начиная с нее( то есть 11,12).
Вы даже можете использовать  шаг увеличения констант. Посмотрите на следующий пример:

Enumeration 10 Step 5
#TEN
#FIFTEEN
#TWENTY
EndEnumeration

Debug #TEN
Debug #FIFTEEN
Debug #TWENTY

Теперь константы увеличивается на '5 ', начиная с '10'.

Если присвоить какое нибудь значение в любом месте перечисления блока, это установит новое значение
перечисления:

Enumeration 5
#FIVE
#ONE_HUNDRED = 100
#ONE_HUNDRED_AND_ONE
#ONE_HUNDRED_AND_TWO
EndEnumeration

Debug #FIVE
Debug #ONE_HUNDRED
Debug #ONE_HUNDRED_AND_ONE
Debug #ONE_HUNDRED_AND_TWO

Здесь вы можете увидеть что, после строки: '# ONE_HUNDRED = 100',  все константы далее пронумерованы от '100 '.  Нумерованные констант используются в основном для программирования графического интерфейса пользователя (см. главу 9), где каждому окну или гаджету нужен собственный идентификатор, перечислить которые константами очень удобно. Это помогает избежать трудностей, в первую очередь анализируя свой собственный код, в особенности когда гаджетов и окон много.

Ну вот я надеюсь, что вам все понятно из данной главы. Если все же есть пробелы, не печальтесь, все со временем заполнится. Я (Станислав Будинов) пытался переводить достаточно понятным языком. Иногда правда приходилось отходить от авторской мысли, чтобы вам казалось, что текст написан изначально на русском языке и вам не пришлось ничего домысливать, но в основном стиль автора сохранен. Автор же данного материала Gary Willoughby.