Типы данных и переменные

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

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

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

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

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

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

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

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

{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 переменные не инициализированы

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

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

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

Есть еще одна возможность определения типа по первой букве имени. С этой целью в язык введена серия операторов 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.

Массивы

Простейший и самый распространенный структурный тип - массив - упорядоченная совокупность данных одного типа. Порядок на элементах массива задается индексами его элементов. В VBA массивы могут быть одномерными и многомерными. Удивительно, сколь высока допустимая размерность массива, - число измерений доходит до 60. За всю свою многолетнюю практику не припомню случая использования более чем трехмерных массивов.

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

{Dim | Private | Public | Static }<имя переменной> (<список размерностей>) 
[ As <имя типа>]

Синтаксически каждое измерение в списке отделяется запятой и определяется заданием нижней и верхней границы изменения индексов. По историческим причинам в Бейсике нижняя граница была фиксирована и равна 0. Затем ввели специальную опцию OptionBase, позволяющую устанавливать эту границу равную 1 или 0. Подумав еще, разрешили задавать нижнюю и верхнюю границу, причем и та и другая могут быть выражениями при одном ограничении - это должны быть константные выражения, не содержащие переменных. Вот "классическое" объявление одномерного массива и работа с ним:

Public Sub MyArray()
	Const LowBound As Integer = -5, HighBound As Integer = 5
	Dim MyArr(LowBound To HighBound) As Byte
	Dim I As Integer
	Debug.Print "Элементы массива MyArr:"
	For I = LowBound To HighBound
		MyArr(I) = I + 6
		Debug.Print MyArr(I)
	Next I
End Sub

При печати элементов этого массива будут напечатаны числа от 1 до 11 по числу его элементов.

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

<граничная пара> ::= <константное выражение> To <константное выражение>

Не используйте Option Base . Это ненадежное средство.

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

Dim BadArr(10)

Запись получилась короткой, он написал ее быстро и был горд собой. Могу подтвердить, Бэдли действительно быстро пишет программы, жаль только, что они не всегда правильно работают. Вот еще один пример его работы:

'Option Base 0
Option Base 1
Dim Vector(10)
Dim A1(5), A2(5) As Integer
'Бэдли добавил новое объявление массива Matrix
'При работе с матрицей ему удобно было, чтобы индексы начинались с 1,
'поэтому он изменил опцию Base, отменив предыдущее соглашение
'Ранее работавшая процедура War перестала работать
Dim Matrix(10, 20) As Double

Public Sub War()
Dim i
    For i = 0 To 5
        A1(i) = i: A2(i) = i + 5
        Vector(i) = A1(i): Vector(i + 5) = A2(i)
    Next i
End Sub

Каждая строчка этого быстро написанного текста должна быть переписана при хорошем программировании.

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

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

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

Рассмотрим пример. На уровне модуля объявим глобальный динамический массив Vector:

'Объявление динамического массива
Public Vector() As Integer

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

Public Sub DynArray()
    'Определяется фактическая размерность массива Vector
    Dim N As Byte, I As Byte
    N = InputBox("Введите число элементов вектора")
    ReDim Vector(1 To N)
    For I = 1 To N
        Vector(I) = 2 * I + 1
    Next I
'   Массив расширяется с сохранением ранее вычисленных элементов
    ReDim Preserve Vector(1 To 2 * N + 1)
    For I = N + 1 To 2 * N + 1
        Vector(I) = 2 * I
    Next I
    'А теперь печать
    Debug.Print "Элементы Vector:"  Chr(13)
    For I = 1 To 2 * N + 1
        Debug.Print Vector(I)
    Next I
End Sub

При печати элементов этого массива будут напечатаны, как нетрудно понять вначале нечетные числа от 3 до 21, а затем четные от 22 до 42.

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

Записи и тип, определенный программистом

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

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

Что же мы имеем в VBA? Формально здесь нет понятия запись или структура, или какого-либо эквивалента. Здесь есть только тип, определенный программистом. Но поскольку он позволяет определять запись, ничего больше и не нужно. Так что записи в VBA есть, но называются они типом, определенным программистом.

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

Синтаксис определения типа в VBA достаточно прозрачен:

[Private | Public] Type <имя типа>
	<имя элемента> [([<размерность массива>])] As <тип элемента>
	[<имя элемента> [([<размерность массива>])] As <тип элемента>]
	...
End Type

Определение типа дается на уровне модуля и, если оно является закрытым ( Private ), распространяется на один модуль, а для общих ( Public ) типов - на все. Мы ограничимся довольно стандартным примером, в котором определяются два типа (записи): Fam и Person, где одно из полей Person имеет тип Fam.

'Определение записей - пользовательских типов
Type Fam
	firstName As String
	lastName As String
End Type

Type Person
	Fio As Fam
	Birthdate As Date
End Type

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

Public Sub UserType()
    Dim Петров As Person
    Dim Козлов As Person
    Петров.Fio.firstName = "Петр"
    Петров.Fio.lastName = "Петров"
    Петров.Birthdate = #1/23/1961#
    Козлов.Fio.firstName = Петров.Fio.firstName
    Козлов.Fio.lastName = "Козлов"
    Козлов.Birthdate = #7/21/1966#
    MsgBox (Петров.Fio.firstName  " "  Петров.Fio.lastName _
      " родился "  Петров.Birthdate)
    MsgBox (Козлов.Fio.firstName  " "  Козлов.Fio.lastName _
     " родился "  Козлов.Birthdate)
End Sub

Вот что будет напечатано в результате ее работы:

Петр Петров родился 23.01.61
Петр Козлов родился 21.07.66

VBA старается помочь при работе с записями, предоставляя возможность выбора полей записи из открывающегося списка. Пусть Вас не смущает форма записи дат рождения - при определении константы для дат можно задавать в более человечной форме. Например, здесь мы задавали их как #January 23, 1961# и #21 July, 66#, - они автоматически были преобразованы в формальный вид.

Что можно делать с записями?

Итак, пусть определен пользовательский тип T и объявлены переменные этого типа, например X и Y. Что можно с ними сделать? Допустимо ли присвоение ( X=Y ) или сравнение ( If (X=Y) Then Fun ), допустимы ли операции над записями? Ответ: нет, за одним исключением - присвоение допустимо, все остальное нет, в том числе и сравнение. Так что можно написать:

Петров = Козлов

Но нельзя написать:

If (Петров = Козлов) Then Debug.Print "Записи идентичны"

Отсутствие разрешенных операций над записями не означает, что с ними нельзя работать. Главное, что определен прямой доступ к полям записи, и этого достаточно, - с полями можно работать, как с переменными. Наш пример ( Sub UserType ) демонстрирует работу с полями записей.

Раздел объявлений

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

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

Раздел опций

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

{Binary | Text | DataBase}

По умолчанию VBA применяет метод Binary, при котором строки сравниваются по внутренним кодам соответствующих символов. В Windows порядок сортировки определяется кодовой страницей. Вот часть типичного такого порядка:

A < Z < a < z 
z < А < Я < а < я

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

(A = a) < (Z = z) 
(Z = z) < (А = а) < (Я = я)

Метод DataBase допустим лишь при работе с Access. Сравнение при этом базируется на порядке, задаваемом локализацией той БД, для которой проводится сравнение.

Разделы констант, типов и переменных

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

Для констант и типов ключевые слова Const и Type однозначно определяют описываемый объект. Для переменных ключевые слова могут быть разными. Заметим, что для переменных уровня модуля не целесообразно использовать ключевое слово Dim, лучше использовать спецификаторы Public или Private, явно указывающие область действия переменной.

Раздел Declare

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

[Public | Private] Declare {Sub | Function} имя Lib "имя_библиотеки" _
[Alias "псевдоним"] [([параметры])] [As возвращаемый_тип]

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

Правила именования

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

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

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

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

Вот несколько примеров правильно построенных имен: gstrOneWord, mintNumberOne, strAnswer, curSalary. Также как по значению константы можно восстановить ее тип, по правильно построенным именам можно однозначно восстановить их объявление. Сделаем это в нашем примере:

Public gstrOneWord As String
Private mintNumberOne As Integer
Dim strAnswer As String
Dim curSalary As Currency

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

Префиксы следует использовать и при именовании объектов, для форм обычно используется префикс frm, для командных кнопок - cmd и так далее. Следует понимать, что, если уж пользоваться префиксами, то обще употребительными, не следует заниматься самодеятельностью в этом вопросе. Мы закончим призывом, - "будьте цивилизованными".