Введение в Unity JavaScript - часть 1 из 2

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

Unity JavaScript и JavaScript который вам уже известен.
Он Быстрее.

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

Если в серьёз то нет разницы в скорости между JavaScript, C# и Boo под Unity, есть другие преимущества между ними, но не скорость.

заметка: если вы следите за последними разработками в мире воин между браузерами, то вы наверно заметили, что то что я сказал выше не в точности верно, так как JavaScript в настоящее время на модернизированных браузерах JIT прекомпилирован и даже на нескольких браузерах впечатляюще быстр (Firefoх, Safari и Opera). Но даже если так он не поддерживает строгое определение типов (даже как опцию) а это очень важно для производительности, каждый раз когда вы делаете арифметическую операцию вам нужно определить тип ваших операторов и если нужно конвертировать его. Если стандарт ECMAScripт будет изменён так как запросили Adobe, что позволит определение типов, то возможно что правильно написанные JavaScript программы будут работать значительно быстрее.

И всётаки, на данный момент “настоящий” JavaScript всё ещё как минимум в 2 раза медленнее чем JavaScript от Unity, и даже на “Squirrelfish Ehtreme”.

Subclassing менее нудное чем настоящий JavaScript

В Unity JavaScript не нужно больше мучиться с _prototype, стоит применять Mixins и Helpers вместо Subclassing.
Очень просто писать процессы которые знают друг о друге и взаимодействуют, так и понятней и значительно легче специализировать объекты в Unity чем subclassing.

к примеру:
view plaincopy to clipboardprint
/* Foo.js */

var bar : Bar;

function Start() {
bar = gameObject.GetComponent(Bar);
}

function doEet(){
// делаем что-то тут
if( bar ) {
bar.doEet();
}
}
view plaincopy to clipboardprint
/* Bar.js */

function doEet() {
// делаем тут что-то особенное
}

Это String (Класс String от Mono) а не string
var х : String;

Большая часть функциональности string которую вы знаете и любите из JavaScript всё ещё там, но начинается с большой буквы.

String всегда берётся в двойные кавычки и всегда интерполирован.

В Unity, String всегда в двойных кавычках “”. Одинарные кавычки запрещены.
Звучит ужастно с точки зрения безопасности от профессиональных JavaScripт хакеров, которым двойные кавычки как подарок, чем одинарные которые защищают нас от взлома, но поскольку Unity код компилируется, тут такой проблемы нет. кроме того двойные кавычки будут более удобны.

Интерполирован - это просто красивый способ сказать что “\n” станет новой строкой.
view plaincopy to clipboardprint
var a = 'fred'; // Работает на стандартном JavaScript, но выдаст ошибку на Unity
var b = 'fred\n'; // не конвертирует \n в новую строку
var a = "fred"; // будет работать и на Unity и на Стандартном JavaScript,
// причём Unity от такого применения ковычек производительностью не пострадает.

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

Вы должны, в точности деклариравать переменные. Это также и большой плюс поскольку именно это позволяет программе бежать быстрее, распознавать определённые ошибки во время компиляции - что очень приятно, и также другие ошибки во время запуска - что менее приятно.
view plaincopy to clipboardprint
a = "fred"; // Работает на стандартном JavaScript, но выдаст ошибку на Unity
var a = "fred"; // переменное a сейчас типа string, и содержит значение 'fred'
var b: String; // переменное b сейчас string, но не содержит никакого значения.
b = "wilma";
var c; // c сейчас имеет тип динамического переменного, без значения.
c = "barney";
c = 17;
Вы можете (и часто должны) вточности определять переменные как private, static и так далее…
Unity постараетса сам определить тип переменного если вы дадите ему значение во время его декларации.
view plaincopy to clipboardprint
var a = "fred"; // a сейчас принадлежит типу String
a = 5; // Ошибка! -- a он String
var b : String = "fred"; // Так Надёжней

Но:
view plaincopy to clipboardprint
var a; // a имеет динамический тип
a = "fred"; // работает
a = 5; // работает

автор оригинального текста: Tonio Loewald, перевод - unitydev.ru

Продолжение во 2-ой части: Введение в Unity JavaScript - часть 2

Введение в Unity JavaScript - часть 2 из 2

Имена Method (и Class) в основном начинаются с заглавных букв.
Имена Method (и Class) в основном начинаются с заглавных букв, кроме когда они нет.
Да, это запутывает. Unity JavaScript живёт в мире заглавных букв .NET (где methods CamelCase а properties camelCase), но и также пытается быть как и JavaScript (как C, строга направлен на маленькие буквы и camelCase для всего).

к примеру:
в JavaScript typeof(”fred”) == ’string’,
но в Юнити тип который бы пишите var a: String;

На много больше типов, два вида массива, и без синтаксиса объектов.
В базовом JavaScript есть три типа: число, строка, и объект (ну а функции и массивы и есть объекты). В Unity JavaScript есть намного больше типов, включая:
Объекты, которые НЕ меняются с массивами, или Массивы которые вроде как и JavaScript обеты, но не динамические:
view plaincopy to clipboardprint
var a = new Object(); // работает
a.fred = "wilma"; // ошибка при запуске

Природные массивы (те которые не ассоциируются и не динамичны)
view plaincopy to clipboardprint
var a = [1, 2, 3];
a.Push(4); // ошибка -- работать не будет

Если вам нужно создать массив определённого типа:
view plaincopy to clipboardprint
public var friendsOfCarlotta : Transform[];

Массивы Mono (те которые ассоциируются и динамичны, но не с тем же синтаксисом как объекты):
view plaincopy to clipboardprint
var a = new Array();
a.Push(4); // будет работать

Также можно конвертировать Mono массивы в Природные массивы (которые быстрее но не так гибки) используя ToBuiltIn(тип массива) к примеру:
view plaincopy to clipboardprint
var a = new Array();
a.Push(1);
a.Push(3.1415926535);
a.Push(17);
var b = a.ToBuiltIn(float);

типы integer (включая int, uint32, и так далее…)
float
И ещё много различных встроенных в Юнити классов (к примеру Vector3)
В Юнити String класс отсутствуют много хороших возможностей которые есть в JavaScript strings.
Юнити внутренние массивы намного менее гибкие чем массивы или объекты JavaScript. Если нужна гибкость, то советуем использовать массивы Mono, для скорости нужно пользоваться внутренними массивами Unity.

Каждый .js файл создаёт Класс (по умолчанию)
Очень важно понять что когда вы пишите скрипт поведения в JavaScript Юнити, вы на самом деле пишите класс в котором:
Имя вашего скрипт файла и будет имя класса, к примеру если файл foo.js к нему можно будет в любом месте программы обратится написав var x = new foo()
Определённые “магические” имена методов на самом деле создают event handlers (триггеры на события) к примеру: start(), FixedUpdate() и так далее… На любом таком событии, определение функции это способ самого класса который вы пишите.
Нужно знать что код написанный внутри JavaScript файла но вне функций, запускается внутри тела класса, а переменные объявленные в нём, являются переменными класса.
Статические функции и переменные внутри класса, собственно и есть функции и переменные класса.

Это намного более элегантно чем использование классов в “настоящем” JavaScript, но также и более ограничено… в большинстве случаев с хорошей стороны (вы не сможете связать вместе объекты также свободно, как и в “настоящем” JavaScript).

К примеру, мы создадим новый behavior и назовем его foo, файл будет называться foo.js. Допустим так будет выглядеть наш файл:
view plaincopy to clipboardprint
public name : String; // когда вы перетащите этот скрипт - behavior
// в gameObject - объект игры, эти значения будут видимы и их можно будет
// менять пряма из графического меню программы.

public age : int; // другие скрипты которые ссылаться на этот объект
// (к примеру: они присоединены к этому же объекту)
// могут видеть public functions - публичные функции.

private favoriteColor : Color; // private members – НЕ будут доступны из других скриптов,
// даже если эти скрипты принадлежат тому же объекту.

public bestFriend : foo; // переменному bestFriend можно дать значение перетащив
// gameObject (объект игры) в интерфейсе с привязанной копией
// скрипта поведения foo к этому property. Это даст вам доступ
// к bestFriend public methods and members (его публичным методам и переменным).

static faction : String; // статические переменные всегда и везде видны,
// поэтому другой скрипт может видеть foo.faction

function Update(){
// эта функция вызывается Unity каждый кадр во время игры.
// Так что это event handler (триггер на событие).
var t = transform; // transform это property унаследованный от объекта игры
// к которому привязан скрипт поведения.
}

function Bar(){
// проста функция, если вы сами её не вызовите то она нечего не сделает
}

static function FooBar(){
// глобальная функция. Другие скрипты в этой сцене могут её вызвать foo.FooBar();
}

Команда switch не бежит без конца.
В обычном JavaScript, так же как и в C, switch бежит пока вы не добавите
Break. В Unity каждом case нужен свой собственный break.
view plaincopy to clipboardprint
switch(x) {
case 0: // ошибка в Unity, нужно break перед следующим case
case 1:
// выполнит тоже самое для 0 и 1
break;
case 2:
// выполнит что то другое для 2
break;
}

Точка с запятой не опция.
В JavaScript точка с запятой не обязательны (имеется кое какая свирепая логика, чтоб определять когда команда закончена), в Unity точку с запятой нужно ставить всегда.
view plaincopy to clipboardprint
var foo = 3 // сработает в JavaScript, но выдаст ошибку в Unity
foo += 17

Анонимные функции запрещены.
В Unity нельзя также свободна определять функции.
view plaincopy to clipboardprint
function foo() {} // будет работать в JavaScript и в Unity JavaScript
var bar = function() {} // выдаст ошибку в Unity

Но замете что большая часть удобств работы с функциями JavaScript остались.
view plaincopy to clipboardprint
function foo(x) { print(x); }
var bar = foo;
bar("test"); // будет работать в Unity JavaScript без проблем

Math это Mathf ну а Math.abs это Mathf.Abs
Надоедливая JavaScript математическая библиотека (потому что элементарные вещи как abs() должны быть частью языка программирования) стала Unity (тоже надоедливой) Mathf библиотекой. Запомните, что имена method начинаются в основном с заглавной буквы (в Unity) поэтому Math.abs() стало Mathf.Abs().

Используем Mono (.NET)
В среде JavaScript runtime интенсивно используется Mono (клон .NET с открытым исходным кодам). По правде говоря JavaScript создан из Boo, это язык который работает на «Mono virtual machine» и компилируется в его начальный код.
Много из среды JavaScript runtime (к примеру, String и библиотеки Math) предоставлены из Mono. Вы сможете сразу определить когда вы используете классы Mono, так как они всегда начинаются с заглавной буквы CamelCase для имён классов (к примеру String) и методов (к примеру Mathf.Sin()), но camelCase для properties с JavaScript, там camelCase для всего.

Для того чтоб использовать библиотеки Mono, их нужно импортировать:
view plaincopy to clipboardprint
import System;
import System.IO;

Лучшее место для документации по библиотекам Mono, пожалуй http://www.go-mono.com/docs/

Mono Types
Когда функции Mono нужен char как ввод, вы можете заполучить его индексированием строки. К примеру, если вам нужно передать маленькую a как a char, вы должны написать:
view plaincopy to clipboardprint
"a"[0]

К примеру для использования функции String.Replace(), вы будете писать:
view plaincopy to clipboardprint
var s : String = "Whatever_it_may_be";
s = s.Replace("_"[0], " "[0]); // заменит все underscores (символы подчеркивания)
// на spaces (промежутки).

Массивы Mono более гибкие, чем стандартные встроенные массивы. Также их можно легко конвертировать в более быстрые встроенные массивы при помощи ToBuiltIn(тип):
fastArray : SomeType[] = monoArray.ToBuiltin(SomeType);

Ищем документацию по классам
Когда вы ищите документацию на ресурсе go-mono, обратите внимание что большая её часть которая вам действительно понадобится будет находится в категории Class Library/System.

Debugging (отладка).
Ошибки в скриптах Юнити отображаются красным значком с крестиком в панели статуса.
Щелкните по этому крестику, чтобы вызвать окно консула со списком ошибок, которые должны быть информативными а так же и привести вас к той самой строке которая создаёт ошибку.

Юнити так же генерирует полезные предупреждения - warnings (синий значок с восклицательным знаком) к примеру: предупреждение которое говорит что переменное которое вы декларировали нигде в программе не используется.
Писать код который не генерирует никаких предупреждений, очень полезная привычка.

Сообщения функции print() будут выводиться в панели статуса и консуле. Так же можно использовать Log(”ваше сообщение”); и Debug.Log(”ваше сообщение”);

Debug.Break(); останавливает игру (pause) в окне editor в точности во время вызова. Это очень удобно когда нужно проверить положение объектов в определенной ситуации, к примеру, вы хотите понять что происходит не так когда определенные объекты сталкиваются друг с другом.

Хоть у Юнити и нет обычного “stop, watch, and step” debugger, его интерфейс оживает, когда запускается проект в среде разработки, к примеру в браузере появляются instances которые создаются в реальном времени и нажав на них можно увидеть их положение.

1. Использование Статических переменных

При использовании JavaScript наиболее важной оптимизацией является использование статических типов вместо динамических. Unity использует метод, который называется type inference, для автоматической конвертации переменных JavaScript к статическому коду, для этого вам ничего не понадобиться делать.
view plaincopy to clipboardprint
var foo = 5;

В приведенном выше примере foo автоматически распознается как переменная типа integer. Таким образом Unity может применить множество оптимизаций времени компиляции, без затратных динамических поисков имени переменной и тд. Это одна из причин, почему Unity JavaScript в среднем в 20 раз быстрее чем какие либо другие реализации JavaScript.

Единственная проблема – не все типы возможно распознать, в таких случаях Unity вернётся обратно к динамическому типу для этих переменных. Использование динамических типов на JavaScript было бы проще для написания кода, тем не менее это бы замедлило его выполнение кода.

Рассмотрим несколько примеров:
view plaincopy to clipboardprint
function Start () {
var foo = GetComponent(MyScript);
foo.DoSomething();
}

В данном варианте foo будет динамически определено, таким образом вызов функции DoSomething длится дольше чем нужно, потому что тип foo неизвестен, и вначале нужно выяснить, поддерживает ли foo функцию DoSomething, и если поддерживает то вызвать её.

view plaincopy to clipboardprint
function Start () {
var foo : MyScript = GetComponent(MyScript);
foo.DoSomething();
}

Здесь foo у нас имеет определённый тип. Производительность в данном случае будет гораздо лучше.

2. Используйте #pragma strict

Конечно, сейчас проблема состоит в том, что вы обычно не замечаете использование динамической вёрстки. #pragma strict сможет вам помочь. Просто добавьте в начало кода #pragma strict и Unity отключит динамическую вёрстку в данном скрипте, вынуждая вас использовать статическую. Там где тип будет неизвестен, Unity сообщит нам про ошибки компиляции. В этом случае foo будет выдавать ошибку на этапе компиляции:

view plaincopy to clipboardprint
#pragma strict
function Start () {
var foo = GetComponent(MyScript);
foo.DoSomething();
}

3. Кешированый поиск компонентов

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

Всякий раз когда вы получаете доступ к компоненту через GetComponent или средством доступа переменной, Unity должен найти нужный компонент из игрового объекта. Время на поиск можно легко сократить если использовать кеширование ссылки на компонент в часной (private) переменной.

Просто преобразуйте этот код:
view plaincopy to clipboardprint
function Update () {
transform.Translate(0, 0, 5);
}

В этот:
view plaincopy to clipboardprint
private var myTransform : Transform;
function Awake () {
myTransform = transform;
}

function Update () {
myTransform.Translate(0, 0, 5);
}

Последний вариант будет работать намного быстрее, так как Unity не нужно искать компонент Transform в игровом объекте каждый кадр.
Тоже самое применимо для скриптовых компонентов, где вы используете GetComponent вместо transform или других изменений свойств.

4. Используйте встроенные массивы

Встроенные массивы имеют очень высокую скорость работы, старайтесь использовать их когда это возможно. Хоть ArrayList или классы массивов намного проще использовать, так как в них легче производить добавление элементов, скорость работы у них ниже. Встроенные массивы имеют фиксированный размер, но в большинстве случаев размер известен нам с самого начала, и мы можем в любой момент заполнить его. Одним из важнейших достоинств встроенных массивов является то, что они непосредственно включают типы данных struct в один сильно упакованный буфер, без какой либо дополнительной информации о типе или накладных расходов. Таким образом, совершать интеракции на кеше очень легко, так как в нём всё выровнено.
view plaincopy to clipboardprint
private var positions : Vector3[];
function Awake () {
positions = new Vector3[100];
for (var i=0;i<100;i++)
positions[i] = Vector3.zero;
}

5. Не делайте вызов функции, если без этого можно обойтись

Самый простейший и лучший способ оптимизации – это совершать как можно меньше лишней работы. К примеру, когда враг далеко от нас, наилучшим будет сделать так, чтобы он «заснул». То есть не совершал никаких действий пока игрок не подойдёт ближе. Вот медленный вариант реализации этого случая:
view plaincopy to clipboardprint
function Update ()
{
// Early out if the player is too far away.
if (Vector3.Distance(transform.position, target.position) > 100)
return;
perform real work work...
}

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

1. Использовать OnBecameVisible и OnBecameInvisible. Эти вызовы заложены в системе прорисовки. Как только какая-нибудь камера видит объект, вызывается OnBecameVisible, когда ни одна камера не видит его, делается вызов OnBecameInvisible. В некоторых случаях это оправдано, но иногда это проблематично для AI, так как враги становятся неактивными, когда вы отклоняете от них камеру.
view plaincopy to clipboardprint
function OnBecameVisible () {
enabled = true;
}

function OnBecameInvisible ()
{
enabled = false;
}

2. Используйте триггеры. Простой шарообразный триггер области может творить чудеса. При выходе из выбранной нами области влияния мы получаем вызовы OnTriggerEnter/Exit.
view plaincopy to clipboardprint
function OnTriggerEnter (c : Collider)
{
if (c.CompareTag("Player"))
enabled = true;
}

function OnTriggerExit (c : Collider)
{
if (c.CompareTag("Player"))
enabled = false;
}

3. Используйте Coroutines. Главным недостатком Update является то, что он исполняется каждый кадр. Вполне возможным была бы проверка расстояния до игрока каждые 5 секунд. Это бы неплохо повысило производительность.