Как выглядят инструкции объявления констант и переменных

Объявление (описание) переменных и констант

Переменная
объявляется
(описывается) с помощью ключевых слов
Private,
Public,
Static, Dim.
Чтобы явно указать тип переменной,
используется ключевое слово As.

Примеры
описания простых переменных:

    Private
X

    Public
i As Integer, r As Long, c As Date

    Static
Строка As String

    Dim
Y

    Dim
Z As Single ‘Явный
способ объявления переменной.
   
Самый простой и надёжный.

Примеры
описания индексированных переменных:

    Dim
Массив1() As Integer

    Dim
Массив2(12) As String

    Dim
Массив3(1 to 20) As Single

    Dim
Массив4(1 to 5, 1 to 7) As Byte

Примечание.
Подробности излагаются в параграфе
2.4.6.

Константа
объявляется
с помощью ключевого слова Const.

   
При этом можно указать её тип, область
действия и присвоить ей значение.
   
Синтаксис
объявления:

    Const
<имя
константы> As
<тип>
= <значение>
     или
   
Const
<имя
константы> = <значение>

Если
в константе явно не указан тип данных,
то VBA назначает ей тип, который соответствует
значению выражения.

Примеры:

      Private
Const q = 44,55
     
Public Const pi = 3,1459
     
Static Const QWER=2,54
     
Const y = 34
     
Const Con As Byte = 34

      Const z As Single = -3,8374E-22

      Все
строковые
константы
указываются
в
кавычках.

Примеры:

      Const
prv As String = “Язык
программирования
VBA”
     
Public Const prv= “Язык
программирования
VBA”

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

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

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

Переменные
подразделяются на простые и индексированные
(переменные с индексом). Индексированными
переменными являются элементы массивов.
Все подробности о массивах будут
рассмотрены в параграфе 2.4.6.

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

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

—
первым символом всегда должна быть
буква;

—
в составе имени нельзя использовать
символы: !,
@, &, $, # , пробел;

—
в качестве имени нельзя использовать
ключевые
     (зарезервированные)
слова, входящие в конструкции
    
языка VBA;

—
длина имени не может быть более 255
символов;

—
имя нельзя повторять в пределах области
его видимости
     (действия).

2.2.1.Область действия переменных и констант

Область
действия переменных и констант
определяется с помощью ключевых слов:
Private,
Public и
Static.

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

Public
–
область действия в пределах приложения.

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

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

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

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

Типизированные
константы типа «массив»

    При
описании константы типа «массив»
компоненты каждой размерности массива
заключаются в отдельные скобки и
разделяются запятыми. Компоненты,
расположенные в самых внутренних скобках
соответствуют последней (самой правой)
размерности массива.

    Примеры
констант типа «массив»:

одномерный
числовой массив

const

DigVector
: array
[1..7] of
Real = (0.1, 3.25, 21.32, 55, 11.99, 78.1, 4.5);

двумерный
числовой массив

const

DigMatrix
: array
[1. .3,1..2] of
Integer = ( (1,2), (3,4), (5,6) );

    В
результате элементы матрицы DigMatrix
получат такие значение

DigMatrix[l,l]
= 1;

DigMatrix[1,2]
= 2;

DigMatrix[2,1]
= 3;

DigMatrix[2,2]
= 4;

DigMatrix[3,1]
= 5;

DigMatrix[3,2]
= 6;

трехмерный
числовой массив

const

Dig3D
: array
[1..4,1..3,1..2] of
Byte = ( ((1,2),(1,2),(1,2)),

((1,2),
(1,2), (1,2)),

((1,2),
(1,2), (1,2)),

((1,2),
(1,2), (1,2)) );

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

const

CharVect1
: array
[1..6] of
Char = (‘P’ ,’A’ , ‘S’ , ‘C, ‘A’, ‘L’) ;

или
более кратко

CharVect2
: array
[1..6] of
Char = ‘PASCAL’;

К
оглавлению

Типизированные
константы типа «множество»

    Синтаксис
описания констант типа «множество»
определяется следующими правилами.

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

    Примеры
констант типа «множество»:

type

Digits
= set
of
0..9;

CharDig
= set
of
‘0’..’9′;

const

DigSetl
: Digits = [0, 2, 4, 6, 8];

DigSet2
: Digits = [1..3, 5..7];

CharDigSet1
: CharDig = [ ‘0’ , ‘2’ , ‘4’ , ‘6’ , ‘8’ ] ;

CharDigSet2
: CharDig = [‘0’..’3′, ‘5’..’7′];

CharSet
: set
of
Char = [‘a’..’z’,’A’..’Z’];

Типизированные
константы типа «запись»

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

    Примеры
типизированных констант типа «запись».

type

Reс
= record

R
: Real;

В
: Boolean;

C
: Char;

end;

ArrayOfRec
= array
[1..3] of
Rec;

RecOfArray
= record

ArrInt
: array
[1..3] of
Integer;

ArrChar
: array
[1..2] of
Char;

end;

RecOfRec
= record

I
: Integer;

S
: String;

Z
: Rec;

end;

const

RecElem
: Rec = ( R: 3.1415; B: True; С
: ‘*’ ) ;

ArrRec
: ArrayOfRec =

(
( R: 3.1415; B: True; C : ‘*’ ),

(
R: 0.0; B: False; C : ‘$’ ),

(
R: 6.2832; B: True; C : ‘&’ ) );

RecArr
: RecOfArray =

(
Arrlnt: (1,2 ,3); ArrChar: (‘ 1’ , ‘ 2’) ) ;

RecRec
: RecOfRec =

(
I: 32767; S: ‘PASCAL’;

Z:
( R: 3.1415; В: True; С: ‘*’ ) ) ;

34

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

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

В своем развитии Visual Basic прошел сложный путь — от бестипового языка с примитивным способом объявления переменных к структурированному языку с хорошо определенными типами данных и структурами управления. Но рудименты продолжают жить, и потому в языке одновременно существуют разные по идеологии способы определения данных. В частности, переменные можно объявлять или не объявлять, и тогда тип ей будет присвоен по умолчанию или по первой букве имени или по специальному символу объявления типа, которым может заканчиваться имя. Явно объявить переменную можно как в начале блока, так и в том произвольном месте, где возникла необходимость использовать новую переменную. Всеми этими рудиментами пользоваться не следует. Если в начало модуля вставить оператор Option Explicit (Опция «Явно»), то явное объявление переменных в этом модуле становится обязательным. Мы рекомендуем придерживаться следующей стратегии:

Всегда используйте явное объявление типа. Всегда помещайте объявления переменных в начало блока. Включите в Редакторе VBA в меню Tools на вкладке Editor флажок Require Variable Declaration. В этом случае во всех модулях Ваших проектов будет автоматически появляться оператор Option Explicit. Тем самым, Вы принуждаете себя следить за соблюдением правил хорошего тона в программировании.

При объявлении переменной определяется ее тип и область видимости — область, где имя переменной видимо и, значит, возможен доступ к ее значению. Важно понимать, что переменные можно объявлять на двух уровнях — уровне процедуры и уровне модуля . Для объявления переменных используются операторы Dim, Public, Private и Static. Первый можно использовать на обоих уровнях, Public и Private — на уровне модуля, Static — только на уровне процедуры.

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

• на все процедуры одного модуля, в котором они объявлены; такие глобальные переменные, называемые закрытыми ( Private ), должны быть объявлены на уровне модуля либо оператором Private либо оператором Dim ;
• на весь программный проект — все процедуры всех модулей данного проекта; такие глобальные переменные, называемые открытыми ( Public ), должны быть объявлены оператором Public.

Локальные переменные уровня процедуры могут быть объявлены оператором Static, что делает их статическими. У таких переменных увеличивается время жизни. Обычные локальные переменные рождаются при входе в процедуру, видимы только в ней и «умирают», выходя из процедуры. Это значит, что память под переменные отводится при входе в процедуру, а при выходе она освобождается. Область видимости статических переменных по-прежнему — процедура, но время жизни иное, так как у них не отбирается память при выходе, — она просто становится временно недоступной. Поэтому при повторном входе в процедуру статические переменные восстанавливают те значения, что у них были при последнем выходе. Статические переменные — это хранители информации между многократными вызовами одной и той же процедуры. Чтобы статические переменные имели смысл, необходима первоначальная инициализация переменных, — они должны иметь хоть какие-то значения уже при первом вхождении в процедуру. Вот как VBA инициализирует переменные в момент их объявления:

• 0 — для численных значений;
• пустая строка («») — для строк переменной длины;
• строка, содержащая нули, — для строк фиксированной длины;
• Empty (значение, указывающее на отсутствие инициализации) — для типа Variant ;
• для массивов и записей (типа, определенного программистом), каждый элемент инициализируется в соответствии с указанными правилами.

Синтаксис объявления простых переменных

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

{Dim | Private | Public | Static }<имя переменной> [ As <имя типа>]
      [, <имя переменной> [ As <имя типа>]]…

Вначале идет имя оператора, а потом список объявлений переменных, где роль разделителя играет запятая. Каждое объявление связывает имя переменной с ее типом, заданным конструкцией As. Будьте внимательны, VBA неприятно отличается в этом вопросе от других языков программирования. Здесь, как обычно, одним оператором можно объявить произвольное число переменных, но следует в каждом объявлении указывать конструкцию As, иначе переменным без As будет приписан тип Variant. На наш взгляд, то, что одним As нельзя объявить список переменных одного типа, — некий синтаксический «прокол», приводящий, если не к серьезным ошибкам, то к излишнему и не предполагаемому употреблению типа Variant.

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

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

'Option Explicit
Public Fx As Byte, Fz As Integer
Private Fy As Integer

Public Sub Start()
	'Инициализация глобальных переменных
	Fx = 10: Fy = 11: Fz = 12
	Mx = 20: My = 21: Mz = 22
	Father1
End Sub

Public Sub Father1()
	Dim Fz As Byte 'Локальная переменная
	Fx = Fx + 2
	Fy = Mx - 2
	Fz = 1
	Debug.Print "Father1: Fx=", Fx, " Fy =", Fy, "Fz =", Fz
'Вызов процедуры другого модуля
	Mother1
End Sub

Здесь мы приводим тексты модуля Mother:

'Option Explicit
Public Mx As Byte
Private My As Integer

Public Sub Mother1()
	'Объявление статической переменной
	Static Count As Byte
	Count = Count + 1
	Mx = Mx - 2: Fz = My + 2
	Debug.Print "Mother: Статическая переменная Count =", Count
	'Вызов процедуры Father другого модуля или заключительной - Finish
	If Fx < Mx Then Father1 Else Finish
End Sub

Public Sub Finish()
	'Заключительная печать
	Debug.Print "Finish: Fx = ", Fx, "Fy =", Fy, "Fz =", Fz
	Debug.Print "Mx =", Mx, "My =", My, "Mz =", Mz
	'Объявления разных типов и печать значений, полученных при объявлении
	Dim B As Byte, I As Integer, L As Long
	Dim Sng As Single, D As Double, C As Currency
	Dim SF As String * 7, SV As String, Dat As Date
	Dim O As Object, V
	Debug.Print "B =", B, "I=", I, "L=", L
	Debug.Print "Sng =", Sng, "D =", D; "C=", C
	Debug.Print "SF =", SF, "SV =", SV, "Dat=", Dat
	If O Is Nothing Then Debug.Print "Объект не определен"
	If V = Empty Then Debug.Print "Variant переменные не инициализированы"
End Sub

Запустив процедуру Start модуля Father, мы получили такие результаты отладочной печати:

Father1: Fx=	12	Fy =	18	Fz =	1 
Mother: Статическая переменная Count =	1 
Father1: Fx=	14	Fy =	16	Fz =	1 
Mother: Статическая переменная Count =	2 
Father1: Fx=	16	Fy =	14	Fz =	1 
Mother: Статическая переменная Count =	3 
Finish: Fx =16	Fy =	Fz =	2 
Mx =	14	My =	0	Mz =	
B =	0	I=	0	L=	0 
Sng =	0	D =	0	 C=	0 
SF =	SV =	Dat=	0:00:00 
Объект не определен
Variant переменные не инициализированы

Дадим краткий комментарий:

• Процедуры Father и Mother трижды взаимно вызывают друг друга. Статическая переменная Count подсчитывает число сделанных обращений.
• Процедура Father печатает значения глобальных переменных Fx, Fy и локальной переменной Fz. Заметьте, локальное объявление «сильнее» глобального.
• Процедура Finish печатает заключительные значения переменных Fx, Fy, Fz, Mx, My и Mz. Здесь печатается значение глобальной переменной Fz, а значения двух переменных — Fy и Mz — не определены. Дело в том, что Fy — закрытая переменная модуля Father, а Mz вообще не объявлялась. И все же ошибки не возникает, так как действуют объявления по умолчанию и обе эти переменные считаются объявленными в модуле Mother и по умолчанию имеют тип Variant. Именно здесь кроется причина возможных ошибок, во избежание которых мы и советовали включить оператор Option Excplicit. Будь это сделано, — появились бы предупреждающие сообщения. У нас эти опции написаны, но специально закомментированы для демонстрации эффекта их отсутствия. Если их включить, то ошибка сразу встретится в процедуре Start — ведь переменные My и Mz не определены в модуле Father.
• Вторая часть процедуры Finish носит самостоятельный характер, — она демонстрирует объявления всех простых типов и печать значений, получаемых переменными при объявлении. Заметьте, как проверяется неопределенность объекта и пустота значений переменных.

Объявления по умолчанию

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

• % — Integer ;
• & — Long ;
• ! — Single ;
• # — Double ;
• @ — Currency ;
• $ — String.

Есть еще одна возможность определения типа по первой букве имени. С этой целью в язык введена серия операторов DefType (по одному на каждый тип DefBool, DefInt и т. д.), определяющих свой диапазон букв для каждого типа. Если первая буква имени необъявленной переменной входит в тот или иной диапазон, ей приписывается соответствующий тип. Эти операторы устанавливаются на уровне модуля и действуют на все его процедуры.

Концевой символ установления типа сильнее, чем DefType, а тот сильнее стандартного «умолчания» Variant. Но все они — архаизмы, не приличествующие современному стилю программирования.

Константы

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

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

[Public | Private] Const <имя константы> [As type] = <константное выражение>

Вот пример определения классической константы:

Public Const pi As Double = 3.141593

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

Встроенных констант огромное количество. Есть, например, встроенные константы, связанные с тем или иным приложением, например, Excel или Word. Обычно они имеют соответствующий префикс ( xl, wd и т. д.). Но есть и встроенные константы самого VBA. Они позволяют задавать тип календаря, дни недели, цвет, клавиши и могут применяться в конкретной ситуации, скажем, при работе с окном сообщений. Большинство таких констант начинается с префикса vb, например:

vbWhite, vbSunday, vbKeyEscape, vbOKOnly.

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

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

//Это моя первая программа

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

/*Это моя 
первая программа
*/

Причем,
смотрите, все комментарии текстовый редактор Sublime Text отображает
серым цветом, что удобно для быстрой ориентации в программе.

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

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

Начиная со
стандарта ES6 от 2015 года, JavaScript заметно
изменился и современным браузерам теперь приходится учитывать как «старый код»,
написанный по стандарту ES5 и ниже, так и новый – по стандарту ES6 и выше. Если
вы пишите программу по новым стандартам, то лучше явно сообщить об этом браузеру,
чтобы его JavaScript машина
переключилась в «современный» режим работы. Это делается с помощью директивы

«use
strict» или ‘use strict’

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

Я рекомендую
всегда использовать эту директиву и программировать в стандарте ES6+. Во всех
наших занятиях я буду исходить из того, что эта директива включена.

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

• хранить
  данные в переменных;

• выполнять
  арифметические операции;

• проверять
  условия (реализация операторов ветвления);

• организовывать
  циклы.

И по большому
счету – это все! Да, все многообразие программ – это комбинация таких простых
операций. И изучать язык программирования следует с этих моментов. Начнем с
самого начала – с описания переменных в JavaScript.

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

let <имя
переменной> [= присваиваемое значение];

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

Здесь
message – это имя
переменной и ей ничего не присваивается. Почему имя переменной именно message? Да, в
общем-то, не почему, просто такое имя мне пришло в голову. Ее можно было бы
назвать и иначе, например,

msg или var или a или str и т.д.

Здесь важно лишь
следовать правилам задания таких имен. Во-первых, пишите их только на латинице,
не используя другие символы (например, кириллицу). Далее, в качестве первого
символа можно использовать или буквы (по нашей договоренности – это символы
латиницы от a до z или от A до Z), а также
символ подчеркивания _ и $. Никакие другие символы писать не стоит. Далее,
вторым и последующими символами могут быть еще и цифры. Вот примеры правильных
и неправильных имен переменных.

Причем,
переменная arg и Arg – это две разные
переменные, т.к. язык JavaScript чувствителен к регистру и,
например, буквы ‘a’ и ‘A’ – это два разных символа.

И последнее –
имена переменных должны отражать смысл хранимых данных, то есть, они должны
быть осмысленными и быть существительными (то есть, отвечать на вопрос: кто,
что). Например, если переменная хранит emai-адрес, то так
ее и назовите:

но не sendEmail – это уже
глагол, действие. Далее, если это какой-либо цвет, то пусть она называется

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

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

С основными
моментами определились, давайте теперь выведем значение нашей переменной message в консоль:

Мы видим
значение

undefined

и это логично,
так как в JavaScript любая
переменная, которой не было присвоено никакого значения, принимает значение undefined. Присвоим ей
значение, запишем в таком виде:

Теперь, при
выводе в консоль мы видим строчку «Hello». Строки можно
записывать еще и такими способами:

let message = 'Hello';
let message = `Hello`;

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

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

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

let user = 'Alex', age = 25, email='1@my.ru';

их часто
записывают еще и в таком более наглядном виде:

let user = 'Alex', 
         age = 25, 
         email='1@my.ru';

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

age = 17;
email='mymail@my.ru';

Мы даже можем присвоить
им такие значения:

age = 'Возраст 17 лет';
email = 0;

То есть,
переменная age, которая
содержала число, теперь хранит строку, а переменная email, наоборот,
вместо строки – число. Это возможно, так как JavaScript относится к
языкам программирования со слабой типизацией, в отличие, например, от С++, Java, Pascal и другим
подобным. Здесь, во-первых, при объявлении переменной не указывается ее тип, а
во-вторых, переменной можно присваивать самые разные данные.

Далее, мы можем
сделать и так:

в этом случае
данные из age будут
скопированы в переменную email. Такие операции можно делать с любыми
переменными.

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

const <имя
константы> = значение;

например, так:

Теперь, при попытке
ее изменения

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

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

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

В этом уроке рассмотрим:

1. Структуру программы на языке Паскаль
2. Примеры простейших программ
3. Работу с переменными. Примеры
4. Справочная информация по типам данных
5. Справочная информация по операторам ввода/вывода
6. Справочная информация выражениям и стандартным функциям

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

1 Структура программы на Паскаль

PROGRAM имя программы;
(английскими буквами, одно слово. Хотите глубже? То необходимо воспользоваться правилами написания идентификаторов)

USES подключаемые библиотеки (модули);
(дополнительные возможности, их можно подключать к программе в этой строке)

LABEL список меток;
(из одного места программы «прыгать» в другое)

CONST раздел описания констант;
(постоянные величины, их нельзя изменять)

TYPE описание типов переменных;

VAR определение глобальных переменных;
(описание всех переменных величин, которые в программе могут изменяться)

ОПРЕДЕЛЕНИЕ ПРОЦЕДУР;

ОПРЕДЕЛЕНИЕ ФУНКЦИЙ;

BEGIN

основной блок программы

END.

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

Program ex123; 
Begin 
End. 

Данная программа ни чего не делает, так как в ней нет ни одного оператора.

2 Пример программы на Pascal

Hello world на паскаль

Результатом данный программы будет вывод на экран строки «Hello, World!».

Program Hello_World;
Begin
	Write('Hello, World');
End.

Запустите Turbo Pascal и перепишите исходный код программы. Теперь запустите программу, это можно сделать зажав сочетание клавиш Ctrl+F9. Результат выполнения программы всегда можно посмотреть зажав сочетание клавиш Alt+F5.

Тут:

1. Program Hello_World; — это название вашей программы, зачастую его не используют.
2. Все что пишется до первого Begin — это раздел описания. Здесь программа просто сообщает компилятору сведения об используемых объектах и еще некоторую информацию.
3. Основной блок кода, так называемый раздел операторов, всегда начинается с Begin и заканчивается End. (обратите внимание: Begin всегда без точки, а последний закрывающий End. всегда с точкой).
4. Write('Hello, World'); — это первый исполняемый оператор в нашей программе, который сообщает компилятору о том, что необходимо напечатать строку "Hello, World!".

Стоит отметить, что язык Паскаль не чувствителен к регистру символов, т.е. write(), Write(), WRITE(), и даже WrItE() — все это для Паскаля означает одно и тоже.

Вычисление суммы двух чисел на Паскаль

Program Summa; { программа называется Summa }

Const
  A = 23;
  B = 76;

var
  S: integer;

begin
  S := A + B; { сумма чисел A и B }
  writeln('Сумма чисел 23 и 76 равна: S = ', S);
  readln { <-- Ожидание нажатия Enter, после 
   которого программа завершится }
end.

Предлагаю сразу запустить эту программу, а пояснения к ней можно найти ниже…

3 Константы и переменные. Примеры

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

3.1 Константы

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

• Числовые константы (целочисленные и вещественные). Пример:

  const
    N: integer = 12; //число N – целого типа
    S: integer = 5; //число S – целого типа
    pi: real = 3.14; //число «пи» - вещественного 
  

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

• Символьные константы. Единичный символ, записанный в апострофы:

  'А', 'В'

• Строковые константы. Некоторая произвольная последовательность символов, заключенная в апострофы:

  'Pascal programming language'

Рассмотрим программу «Hello world!» с использованием константы.

Program Hello_World_With_Const;
Uses Crt;

Const hello = 'Привет, ';

Var name:string;

Begin
	ClrScr;
	Write('Введите имя: ');
	Read(name);
	Write(hello, name, '!');
	ReadLn
End.

В данном случае мы объявили константу hello равную значению ‘Привет, ‘. Далее в программе достаточно в нужном месте подставить эту константу. Теперь если нам вдруг понадобиться вместо программы, которая здоровается, сделать программу, которая прощается, достаточно в начале программы поменять «Привет, » на «До свидания, » и программа будет прощаться с пользователем.

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

Помимо обычных констант существуют Типизированные константы. Тип таких констант объявляется явно:

Const
  Stroka :string = 'Привет';
  Number :Integer = 777;
  Pi :Real = 3.14159;

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

Const
  stroka = 'I''m a programmer!';

3.2 Переменные в Pascal

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

Read(name);

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

Хочу обратить Ваше внимание на тот факт, что все идентификаторы(переменные, название программы) в коде Turbo Pascal могут состоять исключительно из символов латинского алфавита (A-Z, a-z), цифр (0-9) и символа нижнего подчеркивания («_»). Также идентификаторы не должны начинаться с цифр.

/* Примеры правильных имен переменных */
    variable
    Variable
    var1
    var_1234
    VARIABLE
/* Примеры не правильных имен переменных */
    -variable
    123Var
    Var-123	

Для целых чисел часто используются два основных типа: Integer и LongInt. Единственным отличием типов переменных, используемых для одного формата данных, — это Диапазон допустимых значений. К примеру для Integer диапазон допустимых значений [-32768, 32767], то есть минимальным значением для переменной типа Integer является число -32768, а максимальным — 32767.

Переменные перед использованием надо объявить в секции var, при этом указывается тип переменных. Например:

var
  N, m: integer;
  Q, r, t: real;

Секция описания переменных всегда стоит после описания констант (постоянных) – сначала идет конструкция const, а потом var.

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

Program Hello_World_With_Variable;
Uses Crt;

Var name :string;
    years, height :Integer;
Begin
    ClrScr;
    Write('Введите Ваше имя: ');
    ReadLn(name);
    Write('Сколько Вам лет? ')
    ReadLn(years);
    Write('Какой у Вас рост?(в см) ')
    ReadLn(height);
    Write('Привет, ', name, '! Я знаю что тебе ', years, ' лет', ' и твой рост составляет', height, ' см');
    ReadLn
End.

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

4 Справочная информация по типам данных

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

По способу представления и обработки типы данных бывают:

• простые
• структурированные
• указатели
• объекты
• процедуры

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

4.1 Целочисленный тип

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

Объявить целочисленную переменную можно в разделе Var, например:
Var book: word;

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

4.2 Вещественный тип

В Паскале бывают следующие вещественные типы данных:

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

• sin(x) – синус;
• cos(x) – косинус;
• arctan(x) – арктангенс;
• ln(x) – натуральный логарифм;
• sqrt(x) – квадратный корень;
• exp(x) – экспонента.

4.3 Логический тип

Переменная, имеющая логический тип данных может принимать всего два значения: true (истина) и false (ложь). Здесь истине соответствует значение 1, а ложь тождественная нулю. Объявить булеву переменную можно так:
Var A: Boolean;
Над данными этого типа могут выполняться операции сравнения и логические операции: not , and, or, xor.

4.4 Символьный тип

Символьный тип данных – это совокупность символов, используемых в том или ином компьютере. Переменная данного типа принимает значение одного из этих символов, занимает в памяти компьютера 1 байт. Слово Char определяет величину данного типа. Существует несколько способов записать символьную переменную (или константу):

1. как одиночный символ, заключенный в апострофы: ‘W’, ‘V’, ‘п’;
2. указав код символа, значение которого должно находиться в диапазоне от 0 до 255.
3. при помощи конструкции ^K, где K – код управляющего символа. Значение K должно быть на 64 больше кода соответствующего управляющего символа.

К величинам символьного типа данных применимы операции отношения и следующие функции:

• Succ(x) — возвращает следующий символ;
• Pred(x) — возвращает предыдущий символ;
• Ord(x) — возвращает значение кода символа;
• Chr(x) — возвращает значение символа по его коду;
• UpCase(x) — переводит литеры из интервала

4.5 Строковый тип

Строка в Паскале представляет собой последовательность символов заключенных в апострофы, и обозначается словом String. Число символов (длина строки) должно не превышать 255. Если длину строки не указывать, то она автоматически определиться в 255 символов. Общий вид объявления строковой переменной выглядит так:

Var <имя_переменной>: string[<длина строки>];

Каждый символ в строке имеет свой индекс (номер). Индекс первого байта – 0, но в нем храниться не первый символ, а длина всей строки, из чего следует, что переменная этого типа будет занимать на 1 байт больше числа переменных в ней. Номер первого символа – 1, например, если мы имеем строку S=‘stroka’, то S[1]=s;. В одном из следующих уроков строковый тип данных будет рассмотрен подробнее.
Перечисляемый тип данных

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

Type Day=(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

Var A: Day;

Переменная A может принимать лишь значения определенные в разделе Type. Также можно объявить переменную перечисляемого типа в разделе Var:

Var A: (Monday, Tuesday);

К данному типу применимы операции отношения, при этом заранее определенно, что Monday<Tuesday<Wednesday т. д. Также можно применять функции succ, pred, ord, процедуры inc и dec, и использовать операцию присваивания: A:=Tuesday;

4.6 Интервальный тип данных

Когда необходимо задать какой то диапазон значений, то в таких ситуациях применяется интервальный тип данных. Для объявления используется конструкция m..n, где m – минимальное (начальное) значение, а n – максимально (конечное); здесь m и n являются константами, которые могут быть целого, символьного, перечисляемого или логического типа. Описываться величины интервального типа могут как в разделе типов, так и в разделе описания переменных.

Общий вид:

TYPE <имя_типа> = <мин. значение>..<макс. значение>;

Пример:

TYPE Cards = 1..36;

5 Pascal. Операторы ввода-вывода

5.1 Ввод данных

Процедура ввода данных с клавиатуры – Read (читать). Ее можно представить так:

Read(<Список ввода>);

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

Для перевода каретки после выполнения оператора Read на новую строку, следует прибавить окончание ln:

Readln(<Список ввода>);

Также можно не указывать список ввода:

Readln;

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

5.2 Вывод данных

Для вывода данных в Паскале имеется оператор Write. Для того, чтобы каретка переводилась на следующую строку, к нему прибавляется окончание ln и получается Writeln. В общем виде эти операторы имеют вид:

Write(<Список вывода>);

Writeln(<Список вывода>);

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

Write(x, y);

Здесь x и y – параметры, заключенные в круглые скобки. Возможно использование оператора вывода и без параметров:

Writeln; {Курсор переведется на следующую строку}

Недостаточно просто вывести значение на экран, нужно также сделать это как можно корректнее. Допустим нам нужно в одном операторе Write вывести значения нескольких переменных (a=1, b=2, c=3). Пишем:

Write(a, b, c);

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

1) Вписать пробел вручную, например:

Write(a, ‘ ’, b, ‘ ’, c);

2) Воспользоваться возможностью форматированного вывода:

Write(a, b:2, c:2);

Двоеточие относиться к переменной, после которой оно следует, и говорит программе, что при выводе (переменной) нужно выделить место, заданное целым числом (в нашем случае это 2), т. е. под значения, хранящиеся в переменных b и c отводиться две клетки, сами они выведутся «прижатыми» к правому краю.

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

Write(32.1012:5:2);

Результат выполнения: 32.101

Формат 5 означает, что всего под число 32.1012 выделено 5 клеток, а 2 – из этих пяти под дробную часть отводиться 2 клетки.

6 Выражения с тандартные функции

6.1 Стандартные функции Pascal

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

6.2 Выражения в Pascal

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

1) 12+3*3=21 (12+3)*3=45

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

2) (a>1) and (a<=20)

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

3) (a+3>0) and (a+3<15) or (b>1) and (b<10)

Условие вернет истину, тогда когда истинными будут два условия слева или справа от OR, а также если они оба будут истинными.

Логическая операция OR (или) суть дизъюнкция в логики и поэтому имеет следующую таблицу истинности:

Ложь имеет место только когда X и Y ложны (нули). В том случае, чтобы истина возвращалась только тогда, когда одно из условий верно следует применить оператор XOR (исключающее или):

(a+3>0) and (a+3<15) xor (b>1) and (b<10)

4) x^(a) = exp(a*ln(x))

В Pascal нет функции возведения числа в степень (кроме степени 2), поэтому существует два пути:

1 — умножать число само на себя, какое то количество раз;

2 — воспользоваться функциями экспоненты и натурального логарифма.

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