1. введение в urbiScript — часть 1
2. введение в urbiScript — часть 2
Продолжим рассмотрение возможностей скриптового языка urbiScript от компании Gostai, предназначенного для управления роботами.
Напомню, что urbiScript выполняется на Urbi-сервере, который запускается либо на роботе, либо на компьютере и к которому можно подключиться через сеть простым telnet-ом.
Взаимодействие с аппаратной частью робота осуществляется через объекты UObject, которые выполняют роль драйверов (прослойка между Urbi и аппаратной частью робота).
Данные драйвера реализуются в виде библиотек (.dll), подключаются к серверу Urbi и далее могут прозрачным образом использоваться в urbiScript (вызывать функции, изменять переменные).
9. Объекты
Все используемые в urbiScript сущности являются объектами (и переменные определённые через var и строки).
Объект в urbiScript строится на простой концепции — список слотов.
Слот, в данном случае, — это значение связанное с именем.
Т.о. объект — это список названий слотов, каждое из которых индексирует значение (как словарь).
// Создаём объект с двумя слотами
class Foo
{
var a = 42;
var b = "foo";
};
[00000000] Foo
Чтобы получить список названий слотов объекта можно воспользоваться методом localSlotNames:
// посмотрим список слотов Foo.localSlotNames; [00000000] ["a", "asFoo", "b", "type"]
Значение пременной объекта можно получить, обратившись к ней через точку (.)
// зная имя слота, можно посмотреть его содержимое Foo.a; [00000000] 42 Foo.b; [00000000] "foo"
Так же есть метод inspect, который распечатывает более подробную информацию о структуре объекта:
Foo.inspect; [00000009] *** Inspecting Foo [00000010] *** ** Prototypes: [00000011] *** Object [00000012] *** ** Local Slots: [00000014] *** a : Float [00000015] *** asFoo : Code [00000016] *** b : String [00000013] *** type : String
Все объекты urbiScript имеют своим родителем Object.
// содане переменной o как нового объекта var o = Object.clone; [00000000] Object_0x00000000 // посмотрим его содержимое o.inspect; [00006725] *** Inspecting Object_0x00000000 [00006725] *** ** Prototypes: [00006726] *** Object [00006726] *** ** Local Slots:
Получили пустой объект.
Обратите внимание, что объект выводится, как Object_ и далее следует шестнадцатеричное число — это уникальный идентификатор (есть у каждого urbiScript-объекта).
Приведённому выше пустому объекту можно динамически создать слоты, используя метод
setSlot, который в качестве параметров принимает название слота и его значение:
o.setSlot("a", 42);
[00000000] 42
o.inspect;
[00009837] *** Inspecting Object_0x00000000
[00009837] *** ** Prototypes:
[00009837] *** Object
[00009838] *** ** Local Slots:
[00009838] *** a : Float
выше создан слот a в котором хранится 42. Создать слот можно и другим способом — используя ключевое слово var:
// эквивалентно: o.setSlot("b", "foo").
var o.b = "foo";
[00000000] "foo"
o.inspect;
[00072678] *** Inspecting Object_0x00000000
[00072678] *** ** Prototypes:
[00072679] *** Object
[00072679] *** ** Local Slots:
[00072679] *** a : Float
[00072680] *** b : String
получить слот можно используя метод getSlot, который в качестве параметра принимает название слота.
Используя setSlot() и getSlot() можно динамически работать со слотами объекта.
function set(object, name, value)
{
// используем setSlot с динамическим названием слота
return object.setSlot("x_" + name, value);
} |;
function get(object, name)
{
// используем getSlot с динамическим названием слота
return object.getSlot("x_" + name);
} |;
var x = Object.clone;
[00000000] Object_0x00000000
set(x, "foo", 0);
[00000000] 0
set(x, "bar", 1);
[00000000] 1
x.localSlotNames;
[00000000] ["x_bar", "x_foo"]
get(x, "foo");
[00000000] 0
get(x, "bar");
[00000000] 1
Как не трудно догадаться чтобы изменить содержимое слота существует метод updateSlot, который принимает 2 параметра — название слота и новое значение:
o.a;
[00000000] 42
o.updateSlot("a", 51);
[00000000] 51
o.a;
[00000000] 51
так же несложно догадаться, что можно поступить намного проще и использовать оператор =
o.b;
[00000000] "foo"
// эквивалентно: o.updateSlot("b", "bar")
o.b = "bar";
[00000000] "bar"
o.b;
[00000000] "bar"
Но здесь необходимо знать название слота, а updateSlot() позволяет изменить слот, название которого генерируется динамически.
Обратите внимание, что попытка создать слот с одинаковым именем вернёт ошибку:
var o.c = 0; [00000000] 0 // нельзя переопределять слот var o.c = 1; [00000000:error] !!! slot redefinition: c // изменение значения ошибку не вызовет o.c = 1; [00000000] 1
И разумеется слот можно удалить, используя метод removeSlot, который принимает в качестве параметра название слота:
o.localSlotNames;
[00000000] ["a", "b", "c"]
o.removeSlot("c");
[00000000] Object_0x00000000
o.localSlotNames;
[00000000] ["a", "b"]
Остаётся заметить, что попытки чтения, обновления, удаления слотов, которых не существует в объекте вернут ошибку:
o.d; [00000000:error] !!! lookup failed: d o.d = 0; [00000000:error] !!! lookup failed: d
10. Методы
Метод в urbiScript — это слот объекта, содержащий функцию.
Дотуп к методу осуществляется так же через точку «.»
Внутри метода можно использовать ключевое слово this, которое как и в С++ даст доступ к текущему объекту.
var o = Object.clone;
[00000000] Object_0x0
// сохраняем функцию 'f', как слот объекта 'o'.
function o.f ()
{
echo("This is f with target " + this);
return 42;
} |;
// получим содержимое слота f
o.getSlot("f");
[00000001] function () {
echo("This is f with target ".'+'(this));
return 42;
}
// вызовем метод
o.f;
[00000000] *** This is f with target Object_0x0
[00000000] 42
// можно и с круглыми скобками
o.f();
[00000000] *** This is f with target Object_0x0
[00000000] 42
Получается, что т.к. метод — это всего-лишь слот объекта, а вызов метода не требует обязательного наличия круглых скобок, то методом можно замещать аттрибуты объекта без изменения интерфейса объекта.
Чтобы узнать что же содержит слот — можно использовать метод getSlot:
// метод 'empty' возвращает true если строка пустая
"foo".empty;
[00000000] false
"".empty;
[00000000] true
"".getSlot("empty");
[00000000] Primitive_0xf20488
// посмотрим другой метод
"".getSlot("asList");
[00000000] function () {
split("")
}
"foo".size;
[00000000] 3
"foo".getSlot("size");
[00000000] Primitive_0x0
как видим метод asList — это метод-обёртка, который вызывает функцию split()
А методы empty и size — это методы-примитивы — функции реализованные на С++.
11. Модель переменных в urbiScript
У каждого объекта в urbiScript есть свой уникальный идентификатор. А так как все сущности urbiScript — это объекты, то и идентификатор есть у всех сущностей. Посмотреть его можно через метод uid:
var o = Object.clone; [00000000] Object_0x100000 o.uid; [00000000] "0x100000" 42.uid; [00000000] "0x200000" 42.uid; [00000000] "0x300000"
Как видно, введение целочисленного значения 42 порождает два отдельных объекта.
Чтобы продолжить разбираться далее нужно вспомнить полезные операторы сравнения:
== возвращает симантическое равенство (сравнивается величины (содержимое объектов))
=== возвращает физическое равенство (т.е. если два объекта имеют одинаковый uid):
var a = 42; [00000000] 42 var b = 42; [00000000] 42 a == b; [00000000] true a === b; [00000000] false
Используя эти операторы можно легко убедиться, что в urbiScript при определении переменной или слота не происходит копирование значения (как в С или С++), а происходит связывание с уже существующим значением (как в Ruby или Java).
var a = 42; [00000000] 42 var b = 42; [00000000] 42 var c = a; // c связывается(указывает) с тем же объектом, что и a. [00000000] 42 // a, b и c - равны: они имеют одинаково значение a == b && a == c; [00000000] true // Но только a и c - фактически один и тот же объект a === b; [00000000] false a === c; [00000000] true
Получается, что a и c указывают на один и тот же объект(число 42) и модификации a затронут и c:
a.localSlotNames; [00000000] [] b.localSlotNames; [00000000] [] c.localSlotNames; [00000000] [] var a.flag; // создание слота в a. a.localSlotNames; [00000000] ["flag"] b.localSlotNames; [00000000] [] c.localSlotNames; [00000000] ["flag"]
Однако, обновление слота или локальной переменной не вызовет обновления связанного значения.
var a = 42; [00000000] 42 var b = a; [00000000] 42 // b и a указывают на число 42 a === b; [00000000] true // Обновление b не скажется на связанном значении 42, // а просто b теперь будет ссылаться на число 51. b = 51; [00000000] 51 // Поэтому a остаётся неизменным: a; [00000000] 42
Понимание двух последних примеров очень важно!
На аргументы функций и методов так же можно ссылаться и модифицировать:
function test(arg)
{
var arg.flag; // добавляется слот аргументу arg
echo(arg.uid); // печатаем идентификатор uid
} |;
var x = Object.clone;
[00000000] Object_0x1
x.uid;
[00000000] "0x1"
test(x);
[00000000] *** 0x1
x.localSlotNames;
[00000000] ["flag"]
Однако, нужно очень внимательно подходить к такому изменению аргументов, т.к. поведение может быть не таким, как вы ожидаете:
function test(arg)
{
// обновляем локальную переменную arg,
// но это никак не сказывается на связанном аргументе
arg = 1;
} |;
var x = 0;
[00000000] 0
test(x);
[00000000] 1
// x не модифицируется
x;
[00000000] 0
12. Операторы if/while/for/switch
Операторы if/while/for аналогичны одноимённым операторам в С/С++.
12.1 if
if (true)
echo("ok");
[00000000] *** ok
if (false)
echo("ko")
else
echo("ok");
[00000000] *** ok
можно использовать внутри выражений:
echo({ if (false) "a" else "b" });
12.2 while
var x = 2;
[00000000] 2
while (x < 40)
{
x += 10;
echo(x);
};
[00000000] *** 12
[00000000] *** 22
[00000000] *** 32
[00000000] *** 42
12.3 for
for (var x = 2; x < 40; x += 10) echo(x); [00000000] *** 2 [00000000] *** 12 [00000000] *** 22 [00000000] *** 32
другой вариант использования for - передавать ему коллекцию переменных в виде в виде списка.
Т.е. сначала идёт for, затем var, идентификатор, двоеточие или in и выражение:
for (var e : [1, 2, 3]) { echo(e) }; //for (var e in [1, 2, 3]) { echo(e) };
[00000000] *** 1
[00000000] *** 2
[00000000] *** 3
12.4 break и continue
как и в С++ внутри циклов for и while можно использовать ключевые слова break и continue:
break - выполняет остановку цикла (переход за границу цикла)
continue - запускает следующую итерацию цикла.
var i = 5|
for (; true; echo(i))
{
if (i > 8)
break;
i++;
};
[00000000] *** 6
[00000000] *** 7
[00000000] *** 8
[00000000] *** 9
for (var i = 0; i < 8; i++)
{
if (i % 2 != 0) // если число нечётное
continue;
echo(i);
};
[00000000] *** 0
[00000000] *** 2
[00000000] *** 4
[00000000] *** 6
12.5 switch
Синтаксис оператора switch аналогичен С/С++, но в urbiScript он работает с любыми типами объектов, а не только с целочисленными. Сравнение аналогично оператору ==.
Так же не требуется использовать break;
switch ("bar")
{
case "foo": 0;
case "bar": 1;
case "baz": 2;
case "qux": 3;
};
[00000000] 1
12.6 do
оператор do позволяет выполнить сразу несколько действий над объектом.
Например, можно написать так:
var o1 = Object.clone; [00000000] Object_0x100000 var o1.one = 1; [00000000] 1 var o1.two = 2; [00000000] 2 echo(o1.uid); [00000000] *** 0x100000
, а можно то же самое реализовать через оператор do:
var o2 = Object.clone;
[00000000] Object_0x100000
// все сообщения в данной области предназначены объекту o2
do (o2)
{
var one = 1; // var - простой вызов setSlot
var two = 2;
echo(uid);
};
[00000000] *** 0x100000
[00000000] Object_0x100000
12.7 loop
ключевое слово loop по смыслу эквивалентно бесконечному циклу while(true)
{
var n = 10|;
var res = []|;
loop;
{
n--;
res << n;
if (n == 0)
break
};
res
}
==
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
13. Области и выражения
Области в urbiScript - это выражения и поэтому они могут быть использованы там, где ожидается выражение:
// области выполняются до последнего выражения внутри:
{ 1; 2; 3};
[00000000] 3
// область - это выражение
echo({1; 2; 3});
[00000000] *** 3
Внутри области можно использовать внутренние переменные:
var x = 0; // Define the outer x.
[00000000] 0
{
var x = 1; // определяется внутренняя переменная x.
x = 2; // изменение значения
echo(x); // внутренней переменной x
};
[00000000] *** 2
x; // внешний x не затрагивался
[00000000] 0
{
x = 3; // а вот это уже внешний x.
echo(x);
};
[00000000] *** 3
x;
[00000000] 3
14. Локальные функции
Функции могут быть определены в любом месте программы. Если они определяются внутри области, то и доступ к ним может быть только в данной области:
function max3(a, b, c) // максимальная из 3 переменных
{
function max2(a, b)
{
if (a > b)
return a
else
return b
};
max2(a, max2(b, c));
} | {};
max3(2,4,1); // проверим
[00000000] 4
15. Замыкания
Замыкание - это захват функцией переменной внешней функции. urbiScript поддерживает замыкание, т.о. функция может ссылаться на внешнюю переменную пока та видна (в области).
function printSalaries(rate)
{
var charges = 100;
function computeSalary(hours)
{
// rate и charges захватываются
// из внешней функции
rate * hours - charges
};
echo("Alice's salary is " + computeSalary(35));
echo("Bob's salary is " + computeSalary(30));
} | {};
printSalaries(15);
[00000000] *** Alice's salary is 425
[00000000] *** Bob's salary is 350
Замыкание так же позволяет изменять внешние переменные:
var a = 0;
[00000000] 0
var b = 0;
[00000000] 0
function add(n)
{
// x и y обновляются замыканием
a += n;
b += n;
void
} | {};
add(25);
add(25);
add(1);
a;
[00000000] 51
b;
[00000000] 51
NB!
Стоит обратить внимание, что urbiScript испольует автоматический сборщик мусора(automatic garbage collection). Т.е. при создании нового объекта можно не заботиться о последующей очистке памяти. urbiScript подсчитывает количество ссылок на объект и в случае когда этот счётчик достигает нуля - объект удаляется.
{
var x = List.new; // новый объект списка
x << 42;
};
// за пределами области этого объекта уже нет.
Однако, как отмечается в документации, это свойство не является частью языка и автоматическая сборка мусора в будущем может быть изменена. Поэтому не стоит полагаться на текущее поведение сборщика мусора или детерминизм времени удаления объекта.
К тому же, текущий алгоритм уборки мусора не удалит объекты, если они ссылаются друг на друга.
Читать далее: введение в urbiScript - часть 3