Ru:Introduction to SourcePawn

From AlliedModders Wiki
Jump to: navigation, search

Это руководство призвано дать Вам самые основные представления по основам написания сприптов в SourcePawn. Pawn это "скриптовый" язык используемый для внедрения функциональности в других программах. Это означает, что это не самостоятельный язык, как C++ или Java, и его элементы будут отличаться в различных приложениях. SourcePawn это вариация языка Pawn используемая в SourceMod.

Это руководство не расскажет Вам как писать SourceMod плагины; оно предназначено для получения общих представлений о синтаксисе и семантике этого языка. Читайте отдельную статью Ru:Introduction to SourceMod Plugins (Введение в SourceMod плагины), для введения в SourceMod API.

Введение для новичков

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

Идентификаторы/Ключевые слова

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

Есть несколько зарезервированных символов, которые имеют особое значение. Например, if, for, и return специальные конструкции в языке, которые будут описаны позднее. Они не могут быть использованы в качестве названий идентификаторов.

Переменные

Существует несколько важных конструкций, которые Вы должны знать, прежде чем приступить к написанию сценария. Во-первых, это переменные. Переменная это идентификатор, который содержит данные. Например, переменная "a" может содержать числа "2", "16", "0", и так далее. Переменные создаются для хранения данных внутри программы. Переменные должны быть объявлены до их использования, с помощью ключевого слова "new". Данные можно присвоить переменной, используя знак равенства (=). Пример:

new a, b, c, d;
 
a = 5;
b = 16;
c = 0;
d = 500;

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

  • Однострочные (могут содержать только произвольные числовые данные), как показано выше.
  • Многострочные (могут содержать целый ряд текстовых символов)

Функции

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

функция(<параметры>)

Примеры:

show(56);   //Активирует функцию "show" и присваивает ей число 56
show();     //Активирует функцию "show" без каких-либо данных, пустую
show(a);    //Активирует функцию "show" и присваивает ей переменную с данными

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

Комментарии

Примечания и любой текст, который пишется после "//" считается "Комментарием", а не фактическим кодом. Есть два стиля комментариев:

  • // - Двойная косая черта, всё следующие после этой строки игнорируется.
  • /* */ - Много-строчный комментарий, весь текст, внутри звездочек игнорируются. You cannot nest these.

Массивы

Описание массивов. Вы можете группировать код в виде "массивов", разделенных { и }. Это фактически создает возможность работать с целым массивом как с одним оператором. Например:

{
   here;
   is;
   some;
   code;
}

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


Особенности языка

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

  • Pawn не печатает Pawn имеет только один тип данных - однострочный. Подробнее будет описано позже. [В дальнейшем автор рассказывает, что существует два типа данных: однострочный и многострочный]
  • Pawn не собирает мусор Pawn, как язык, не имеет встроенных ресурсов памяти, и потому он не мусорит. Если функция выделит память, то Вы отвечаете за её освобождение.
  • Pawn не объектно-ориентированный язык Pawn является процедурным, и полагается на подпрограммы. Также у него нету C подобных структур.
  • Pawn не функциональный. Pawn является процедурным, и не поддерживает функции "лямбды" (Lambda), поздние присвоения, и все то, что можно найти в языках высшего уровня, таких как Python и Ruby.
  • Pawn однопоточный As of this writing, Pawn is not thread safe.
  • Pawn не интерпретируемый Ну, почти. Он интерпретируется на очень низком уровне. Вы должны скомпилировать код, из которого получится бинарный файл. Эта программа будет работать на той платформе, которую использует хост. Это ускоряет загрузку и позволяет легче находить ошибки.

Этот язык был выпущен ITB CompuPhase. Язык разработан для устройств низкого уровня и таким образом конечные программы очень маленькие по размеру и очень быстрые.

Переменные

В Pawn есть всего два типа переменных: однострочные и многострочные. Однострочные могут содержать 32 бита цифровых данных. Многострочные - последовательный список из UTF-8 символов.

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

  • (пусто), или _ - Нет тега. Обычно используют для целых чисел (Integers).
  • Float - используют для чисел с плавающей точкой (небольших).
  • bool - используют для хранения значений true (истина) или false (ложь).

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

Объявления

Примеры разных правильных объявлений переменных.

new a = 5;
new Float:b = 5.0;
new bool:c = true;
new bool:d = 0;      //Работает, поскольку 0 равно false (ложь)

Неправильные объявления переменных

new a = 5.0;         //Несоответствие тегов. 5.0 с тегом Float
new Float:b = 5;     //Несоответствие тегов. 5 без тега.

Если переменная не определена в объявлении то ее значения станет 0

new a;        //значение 0
new Float:b;  //значение 0.0
new bool:c;   //значение false

Присвоение

Переменным могут быть присвоены данные после создания. Пример:

new a, Float:b, bool:c;
 
a = 5;
b = 5.0;
c = true;

Массивы

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

Описание

Массив объявляется с помощью квадратных скобок. Вот некоторые примеры массивов:

new players[32];     //Набор из 32 однострочных (числовых) данных
new Float:origin[3]; //Набор из 3 чисел с плавающей точкой

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

new numbers[5] = {1, 2, 3, 4, 5};       //Набор 1, 2, 3, 4, 5 из однострочных данных.
new Float:origin[3] = {1.0, 2.0, 3.0};  //Набор 1.0, 2.0, 3.0 из однострочных данных.

Вы можете оставить массив без размера, если вы собираетесь заранее присвоить ему данные. Например:

new numbers[] = {1, 3, 5, 7, 9};

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

Использование

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

Вот пример кода с использованием индексов:

new numbers[5], Float:origin[3];
 
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
origin[0] = 1.0;
origin[1] = 2.0;
origin[2] = 3.0;

Заметим, что индекс это текст, который находится в квадратных скобках. Индекс всегда начинается с нуля. То есть, если массив имеет N элементов, его действительный индекс от 0 до N-1. Доступ к данным с индексами работает так же, как с обычной переменной.

Использование неверного индекса вызовет ошибку. Например:

new numbers[5];
 
numbers[5] = 20;

Это может выглядеть верно, но число 5 не является допустимым индексом. Наибольшим значением индекса является число 4.

Вы можете использовать любые выражения, как индекс. Например:

new a, numbers[5];
 
a = 1;                   //Сделает a = 1
numbers[a] = 4;          //Сделает numbers[1] = 4
numbers[numbers[a]] = 2; //Сделает numbers[4] = 2

Выражения будут обсуждаться подробнее в конце статьи.

Строки

Строки являются удобным способом хранения текста. Символы хранятся в массиве. Строка ограничивается нулевым символом, или 0. Без нулевого символа, Pawn не знает, где остановить чтение строки. Все строки в SourcePawn используют кодировку UTF-8.

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

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

Использование

Строки были созданы почти в равной степени и для массивов. Например:

new String:message[] = "Hello!";
new String:clams[6] = "Clams";

Это равносильно следующему:

new String:message[7], String:clams[6];
 
message[0] = 'H';
message[1] = 'e';
message[2] = 'l';
message[3] = 'l';
message[4] = 'o';
message[5] = '!';
message[6] = 0;
clams[0] = 'C';
clams[1] = 'l';
clams[2] = 'a';
clams[3] = 'm';
clams[4] = 's';
clams[5] = 0;

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

Заметим, что строка должна быть заключена в двойных кавычках, а символ в одиночных.

Символы

Особенность текста может быть использована в любой строке или однострочной переменной. Например:

new String:text[] = "Crab";
new clam;
 
clam = 'D';         //Устанавливает однострочной переменной значение 'D'
text[0] = 'A';      //Меняет 'C' на 'A', сейчас получилось 'Arab'
clam = text[0];     //Устанавливает однострочной переменной значение 'A'
text[1] = clam;     //Меняет 'r' на 'A', сейчас получилось 'AAab'

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

new clams[] = "Clams";                       //Не верно, нужен тип String:
new clams[] = {'C', 'l', 'a', 'm', 's', 0};  //Верно, но это НЕ СТРОКА.

Функции

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

Существуют два типа вызова функции:

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

Существуют шесть видов функций:

  • native: Прямая, внутренняя функция, предусмотренная в приложении.
  • public: Функция обратного вызова, что делает её видимой для приложения и других сценариев.
  • normal: Нормальная функция, которую Вы можете только вызвать.
  • static: The scope of this function is restricted to the current file, can be used in combination with stock.
  • stock: Нормальная функция, предусмотренная если включает в себя файл. Если не используется, то не компилируется.
  • forward: Эта функция представляет собой глобальное событие, предусмотренная приложением. Если Вы её привели в исполнение, она будет вызвона.

Весь код в Pawn должен существовать в функциях. Это основное отличие от языков, таких как PHP, Perl и Python, которые позволяют Вам писать глобальный код. Это происходит потому, что Pawn вызывается на основе другого языка: он реагирует на действия от родительского приложения, и функции должны быть написаны для обработки этих действий. Хотя наш пример, часто содержат свободно плавающий код, это сделано исключительно для демонстрационных целей. Свободно плавающий код в нашем примере означает, что код является частью ряда функций.

Описание

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

Пример функции:

AddTwoNumbers(first, second)
{
  new sum = first + second;
 
  return sum;
}

Это простая функция. Модель этой строки:

AddTwoNumbers(first, second)

Распишем по отдельности:

  • AddTwoNumbers - Название функции.
  • first - Название первого параметра, который представляет собой простой элемент.
  • second - Название второго параметра, который представляет собой простой элемент.

Тело представляет собой простой блок кода. Он создает новую переменную, названную sum, и присваивает ей значение этих двух параметров, добавленных совместно (другие выражения будут позже). Важно заметить оператор return, в котором обозначается конец функции и возврат с полученными значениями из этой функции. Все функции возвращают значения после завершения. Это означает, например:

new sum = AddTwoNumbers(4, 5);

Приведенный выше код будет присваивать число 9 к sum. Функция получает два значения и передает новое значение sum в качестве возвращаемого значения. Если функция не имеет возвращаемого значения или не имеет значений для возврата, то возвращается 0 по умолчанию.

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

Float:AddTwoFloats(Float:a, Float:b)
{
   new Float:sum = a + b;
 
   return sum;
}

Заметим, что если в приведенной выше функции, Вам вернулась не Float значение, Вы получите не соответствие значений.

Можно, конечно, передавать переменные в функции:

new numbers[3] = {1, 2, 0};
 
numbers[2] = AddTwoNumbers(numbers[0], numbers[1]);

Заметим, что однострочные переменные передаются по значению. То есть, их значение не может быть изменено функцией. Например:

new a = 5;
 
ChangeValue(a);
 
ChangeValue(b)
{
   b = 5;
}

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

Больше примеров функций будут демонстрироваться и в других частях статьи.

Publics

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

forward OnPluginStart();
forward OnClientDisconnected(client);

Чтобы выполнить и получить эти два события, Вы должны написать такие функции как:

public OnPluginStart()
{
   /* Код здесь */
}
 
public OnClientDisconnected(client)
{
   /* Код здесь */
}

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

Natives

Natives имеют встроенные функции, предоставляемые SourceMod. Вы можете вызвать их, как если бы они были normal функциями. Например, SourceMod имеет следующие функции:

native FloatRound(Float:num);

Её можно вызвать таким образом:

new num = FloatRound(5.2);     //Результат в num = 5

Параметры массива

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

new example[] = {1, 2, 3, 4, 5};
 
ChangeArray(example, 2, 29);
 
ChangeArray(array[], index, value)
{
   array[index] = value;
}

Эта функция устанавливает заданный индекс в массиве с учетом значений. Когда она запускается на примере нашего массива, она меняет индекс 2 для значения 3 на 29. То есть:

example[2] = 29;

Это возможно лишь потому, что массив может быть непосредственно изменён. Чтобы предотвратить массив от изменения, можно пометить его как постоянную const. Это позволит понизить риск на ошибку в коде от её изменения. Например:

CantChangeArray(const array[], index, value)
{
   array[index] = value;    //Не компилируется
}

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

Выражения

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

Приведем пример простейшего выражения:

0;   //Возвращает число 0
(0); //Так же возвращает число 0

Хотя выражения могут возвращать значения, они также могут ответить какое значение содержит ответ ноль или не ноль. В этом смысле, ноль является ложью (false), а не нулевое значение истиной (true). Например, -1 истина в Pawn, поскольку она не является нулем. Не думайте, что отрицательные числа являются ложными.

Порядок операций выражения аналогичен языку C. PMDAS: Parenthesis, Multiplication, Division, Addition, Subtraction. Вот несколько примеров выражений:

5 + 6;                   //Вычисляет как 11
5 * 6 + 3;               //Вычисляет как 33
5 * (6 + 3);             //Вычисляет как 45
5.0 + 2.3;               //Вычисляет как 7.3
(5 * 6) % 7;             //Modulo operator, вычисляет как 2
(5 + 3) / 2 * 4 - 9;     //Вычисляет как 7

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

new a = 5 * 6;
new b = a * 3;      //Вычисляет как 90
new c = AddTwoNumbers(a, b) + (a * b);

Примечание: String manipulation routines may be found in the string.inc file located in the include subdirectory. They may be browsed through the API Reference as well.

Операторы

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

new a = 5;
 
a = a + 5;

Может быть переписан, как:

new a = 5;
a += 5;

Это верно в отношении следующих операторов в Pawn:

  • Four-function: *, /, -, +
  • Bit-wise: |, &, ^, ~, <<, >>

Кроме того, существуют инкремент/декремент операторы:

a = a + 1;
a = a - 1;

Может быть упрощено, как:

a++;
a--;

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

  • До: Переменная увеличивается до определения и остальная часть выражения видит новое значение.
  • Пост: Переменная увеличивается после определения и остальная часть выражения видит старое значение.

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

Например:

new a = 5;
new b = a++;   // b = 5, a = 6  (1)
new c = ++a;   // a = 7, c = 7  (2)

(1) b присваивается a со старым значением, до того, как он будет увеличено до 6. (2) c присваивается a с новым значением, после того, как он увеличивается до 7.

Операторы сравнения

Существуют шесть операторов для сравнения двух числовых значений, а результат является либо истиной (не ноль) или ложью (ноль):

  • a == b - Действительно, если и b имеет то же значение.
  • a != b - Действительно, если b имеет другое значение.
  • a > b - Действительно, если оно больше b
  • a >= b - Действительно, если оно больше или равно b
  • a < b - Действительно, если оно меньше b
  • a <= b - Действительно, если оно меньше или равно b

Например:

(1 != 3);         //Определяется как истина, поскольку 1 не равно 3.
(3 + 3 == 6);     //Определяется как истина, поскольку 3+3 равно 6.
(5 - 2 >= 4);     //Определяется как ложь, поскольку 3 меньше 4.

Заметим, что эти операторы не работают с массивами и строками. То есть, вы не можете сравнить их с помощью ==.

Действительные операторы

Действительные операторы могут быть скомбинированы тремя булевыми (boolean) операторами:

  • a && b - Истина, если a и b истинные. Ложь, если a и (или) b ложные.
&& 0 1
0 0 0
1 0 1
  • a || b - Истина, если a или b (или обе переменные) истинные. Ложь, если обе переменные a и b ложные.
|| 0 1
0 0 1
1 1 1
  • !a - Истина, если a ложь. Ложь, если a истина.
! 0 1
1 0

Например:

(1 || 0);         //Определяется как истина, так как выражение 1 истинное
(1 && 0);         //Определяется как ложь, так как выражение 0 ложное
(!1 || 0);        //Определяется как ложь, так как выражение !1 ложное.

Левое/правое значения

Два важных понятия левого и правого значений, или левостороннее и правостороннее значения. Левостороннее значение имеет то, что появляется на левой стороне выражения, а правостороннее значение - появляется на правой стороне выражения.

Например:

new a = 5;

В этом примере a является левосторонним значением и 5 является правосторонним значением.

Правила:

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

Условия

Условия позволяют Вам запускать код, определенное условие выполнено.

Если соответствует

Если соответствует одно или более условий. Например:

if (a == 5)
{
   /* Код будет запущен, если условие будет истинным */
}

Они могут быть расширены для более сложных случаев:

if (a == 5)
{
   /* Код */
}
else if (a == 6)
{
   /* Код */
}
else if (a == 7)
{
   /* Код */
}

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

if (a == 5)
{
   /* Код */
}
else
{
   /* Код, который будет запущен если нет истинного выражения */
}

Оператор выбора

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

switch (a)
{
   case 5:
   {
      /* Код */
   }
   case 6:
   {
      /* Код */
   }
   case 7:
   {
      /* Код */
   }
   case 8, 9, 10:
   {
      /* Код */
   }
   default:
   {
      /* будет запущен, если не одно условие не соответствует */
   }
}

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

Циклы

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

For циклы

For циклы, это циклы, которые состоят из четырех частей:

  • Оператор инициализации - запускается один раз перед первым циклом.
  • Оператор условия - проверяет условие и запускает следующий цикл, в том числе первый. Цикл прекращается, когда это выражение становится ложным.
  • Оператор итерации - запускается после каждого цикла.
  • тело цикла - запускается каждый раз, пока оператор условия вычисляется как истинный.
for ( /* инициализация */ ; /* условие */ ; /* итерация */ )
{
   /* тело */
}

Простым примером является функция сложения массива:

new array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
new sum = SumArray(array, 10);
 
SumArray(const array[], count)
{
   new total;
 
   for (new i = 0; i < count; i++)
   {
      total += array[i];
   }
 
   return total;
}

По отдельности:

  • new i = 0 - Создает новую переменную для цикла, и устанавливает её в 0.
  • i < count - Только запускает цикл, если i меньше, чем count. Это гарантирует, что чтение цикла прекращается в определенный момент. В этом случае, мы не хотим читать недействительные индексы в массиве.
  • i++ - Увеличивает i на единицу после каждого цикла. Это гарантирует, что цикл не будет запущен вечно; в конце концов i станет слишком большим, и цикл завершится.

Таким образом, функция SumArray будет циклом каждого действительного индекса массива, каждый раз добавляя это значение в sum. Для циклов очень распространены массивы такие, как в нашем примере.

While циклы

While циклы являются менее распространенными, чем for циклы, но на самом деле это более простые циклы. Они имеют только две части:

  • Оператор условия - проверяется перед началом каждого цикла. Цикл прекращается, когда условие становится ложным.
  • тело цикла - запускается каждый раз пока цикл выполняется.
while ( /* условие */ )
{
   /* тело */
}

До тех пор, пока условие выражения остается истинным, цикл будет выполняться. Каждый for цикл может быть переписан, как while цикл:

/* инициализация */
while ( /* условие */ )
{
   /* тело */
   /* итерация */
}

Вот предыдущий for цикл переписан как while цикл:

SumArray(const array[], count)
{
   new total, i;
 
   while (i < count)
   {
      total += array[i];
      i++;
   }
 
   return total;
}

Существуют также do...while циклы, которые используются еще реже. Они работают как и while циклы, но проверяют условие ПОСЛЕ каждого цикла, а не перед ним. Это означает, что цикл всегда будет запущен, по крайней мере один раз. Например:

do
{
   /* тело */
}
while ( /* условие */ );

Управление циклами

Существуют два случая, в которых Мы хотели бы контролировать цикл:

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

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

/**
 * Возвращает массив, если индекс значения, или -1, не найдены.
 */
SearchInArray(const array[], count, value)
{
   new index = -1;
 
   for (new i = 0; i < count; i++)
   {
      if (array[i] == value)
      {
         index = i;
         break;
      }
   }
 
   return index;
}

Конечно, эту функцию можно вернуть и способом return i, но пример показывает, как break может остановить цикл.

Кроме того, ключевое слово continue пропускает итерации цикла. Например, Мы хотим суммировать все четные числа:

SumEvenNumbers(const array[], count)
{
   new sum;
 
   for (new i = 0; i < count; i++)
   {
      /* If divisibility by 2 is 1, we know it's odd */
      if (array[i] % 2 == 1)
      {
         /* Пропускаем оставшуюся часть итерации цикла */
         continue;
      }
      sum += array[i];
   }
 
   return sum;
}

Область действия

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

new A, B, C;
 
Function1()
{
   new B;
 
   Function2();
}
 
Function2()
{
   new C;
}

В этом примере, A, B, и C имеют глобальную область действия. Их можно увидеть в любой функции. Вместе с тем, B в функции Function1 не является той же переменной, как B на глобальном уровне. Вместо этого она находится в локальной области действия, и поэтому является локально изменяемой.

Кроме того, функции Function1 и Function2 ничего не знают о существовании других переменных.

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

Function1()
{
   new B;
 
   Function1();
}

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

Это свойство можно объяснить проще тем, что область действия переменной равна уровню её вложенности. То есть, переменная на глобальной области действия видна для всех функций. Переменная в локальной области действия видна всему блоку кода расположенному "ниже" этого уровня. Например:

Function1()
{
   new A;
 
   if (A)
   {
      A = 5;
   }
}

Приведенный выше код является действительным, поскольку в область действия распространяется по всей функции. Однако этот код, работать не будет:

Function1()
{
   new A;
 
   if (A)
   {
      new B = 5;
   }
 
   B = 5;
}

Отметим, что B объявляется в новом блоке кода. Это означает, что B доступна только в том блоке кода, в котором была создана (и всем под-блокам вложенных внутри него). Как только блок кода прекращается, B становится не действительной.

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

Динамические массивы это массивы, которые не имеют фиксированного размера. Например:

Function1(size)
{
   new array[size];
 
   /* Код */
}

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

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

Расширенное объявление переменных

Переменные могут быть объявлены более длинным путем чем просто new.

decl

Назначение

По умолчанию, все переменные в Pawn будут инициализированы как нуль. Если есть явная инициализация, переменная инициализируется для выражения = определенным символам. В локальной области действия, это может потребовать время на выполнение. Ключевое слово decl (которое действительно только в локальной области действия) было введено, чтобы позволить решать пользователю, хочит ли он инициализировать переменную или нет.

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

Объяснение

Например:

new c = 5;
new d;
new String:blah[512];
 
Format(blah, sizeof(blah), "%d %d", c, d);

В этом коде, c равна 5 и d равна 0. Во время выполнения этого кода затраты на инициализацию незначительные. Вместе с тем, blah является большим массивом, и затраты на инициализацию всего массива могут быть больше 0 сек. и иметь плохие последствия в определенных ситуациях.

Заметим, что blah не должен быть нулевой. В период времени с объявления new и и перемещения в Format(), массив blah никогда не будет загружен или прочитан. Данный код будет более эффективен, если будет написанный следующим образом:

new c = 5;
new d;
decl String:blah[512];
 
Format(blah, sizeof(blah), "%d %d", c, d);

Предостережения

Обратная сторона decl состоит в том, что его переменные будут начинаться с "ненужного" содержания. Например, если мы будем использовать:

new c = 5;
new d;
decl String:blah[512];
 
PrintToServer("%s", blah);
 
Format(blah, sizeof(blah), "%d %d", c, d);

Этот код может привести к падению сервера, так как массив blah может быть полностью испорчен (строки требуют нулевой символ, который может отсутствовать). Точно так же, если мы сделаем:

new c = 5;
decl d;
decl String:blah[512];
 
Format(blah, sizeof(blah), "%d %d", c, d);

Значение d в настоящее время не определенно. Оно может быть любым значением, отрицательным или положительным.

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

decl String:blah[512];
 
blah[0] = '\0';

Золотые правила

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

Примечания

Обратите внимание, что decl переменную инициализировать явно, но ТОЛЬКО как строку:

decl String:blah[512] = "a";

However, any other tag will fail to compile, because the purpose of decl is to avoid any initialization:

decl Float:blah[512] = {1.0};

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

Также обратите внимание, он является неправильным для явной инициализации decl:

decl String:blah[512] = "a";

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

static

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

Глобальный static

Глобальные static переменные могут быть доступны только в рамках того же файла. Например:

//file1.inc
static Float:g_value1 = 0.15f;
 
//file2.inc
static Float:g_value2 = 0.15f;

Если плагин включает в себя оба этих файла, он не сможет использовать g_value1 или g_value2. Это простой механизм сокрытия информации, и аналогичен элементам объявления переменных, например private в таких языках, как C++, Java, или C#.

Локальный static

Локальная static переменная является глобальной переменной, которая является видимой лишь из её местной области действия. Например:

MyFunction(inc)
{
   static counter = -1;
 
   counter += inc;
 
   return counter;
}

В этом примере, counter технически глобальная переменная -- она инициализируется один раз как -1 и никогда не инициализируется заново. Оно не существует в наборе. Это означает, что при каждом запуске функции MyFunction, переменная counter и ее хранение в памяти одно и тоже.

Возьмем следающий пример:

MyFunction(5);
MyFunction(6);
MyFunction(10);

В этом примере, counter может быть -1 +5 +6 +10, или 20, поскольку она сохраняется за рамками этой функции. Это может создавать проблемы для рекурсивной функции: если ваша функция может быть рекурсивной, то static, как правило, не является хорошей идеей, если только Ваш код не реентерабельный.

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

Заметим, что statics может существовать в любой локальной области действия:

MyFunction(inc)
{
   if (inc > 0)
   {
      static counter;
      return (counter += inc);
   }
   return -1;
}