Блог

Прошлой ночью я думал об этом вопросе во Flash

 var a:Number = 5;
var a = 5;
  

Какое объявление лучше? Работает ли первое объявление быстрее и занимает ли меньше памяти?
Все примеры AS содержат метод первого объявления (например http://actionscriptexamples.com/2010/05/03/getting-started-with-the-tlftextfield-class-in-actionscript-3-0-and-flash-cs5/ ).

 var tlfTxt:TLFTextField = new TLFTextField();
  

Почему они используют первый метод вместо второго?

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

var a:* = 5 что может быть использовано потрясающе, все же рассмотрим следующий тест оптимизации:

 var a = 5;
var b:* = 5;
var c:Number = 5;
var d:int = 5;
var e:uint = 5;

var time_start:Number = getTimer();

for(var i:int = 0; i < 10000000; i  )
{
    a  = 1;
    //b  = 1;
    //c  = 1;
    //d  = 1;
    //e  = 1;
}

var time_stop:Number = getTimer();

trace(time_stop - time_start, "ms");

//a.) 650 ms
//b.) 651 ms
//c.) 106 ms
//d.) 69 ms
//e.) 69 ms
  

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

В случаях a и b мы не указывали тип переменной. В третьем случае (c.) мы присвоили ему тип, и мы достигли увеличения скорости в 6,14 раз.

В случаях d и e вы можете видеть, что произойдет, если вы действительно зададите тип конкретно: целые числа и целые числа без знака. В данном случае, если вы используете целые числа, скорость, которую вы можете получить, действительно велика (10x).

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

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

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

 private var _foo; // no type is defined
  

Позже вы захотите добавить для нее свойство get / set:

 public function get foo():??? { return _foo; }
public function set foo(val:???):void { _foo = val; }
  

Что бы вы передали? И как вы документируете это для использования кем-то другим?

Где, как если бы у вас было

 private var _foo:Number;

public function get foo():Number { return _foo; }
public function set foo(val:Number):void { _foo = val; }
  

Сразу становится ясно, что foo делает в обоих случаях get / set.

И еще одна вещь. Если вы хотите создать переменную MovieClip, которая ссылается на что-либо на сцене, скажем:

 var mymc = stage_mc; // Hmmm, not so good
  

Если вы хотите вызвать метод MovieClip на mymc, скажем, play(), компилятор выдаст ошибку, потому что он «не знает», что у mymc есть метод воспроизведения (как бы это?). Таким образом, вводя его (в смысле добавления к нему типа, такого как MovieClip), вы даете компилятору знать, какие методы и свойства должны быть доступны.

Пример:

 var mymc:MovieClip = stage_mc; // Ahh, much better!
  

Это также позволяет компилятору выполнять проверку типов. Итак, в приведенном выше примере, если вы попытались передать текстовое поле в переменную movieclip mymc, ошибка выдаст ошибку. Это останавливает появление более крупных ошибок.

Я очень увлечен проверкой типов в AS3 — я рад, что Flash наконец представил ее, и теперь, когда она здесь, давайте ее использовать!

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

Что касается различий в скорости / памяти, это довольно хорошее объяснение: http://onflex.org/ACDS/AS3TuningInsideAVM2JIT.pdf

На языке с сильной статической типизацией, таком как AS3, вы всегда должны вводить свои объекты при объявлении, это сделает ваш код более чистым и поможет вам легче отслеживать ошибки.

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

     private var foo;

    public final function run():void {

        bar();
        baz();
    }

    private function bar():void {

        foo = 4;
        foo -= 0.5;
        trace( foo ); // traces "3.5"
    }

    private function baz():void {

        foo = "qux";
        trace( foo ); // traces "qux"
    }
  

во 2-й инструкции компилятор должен решить, какой тип он должен использовать. то есть 5 — это целое число, которое, как он также мог предположить, вы имеете в виду

 var a:int = 5;  or  var a:uint = 5;
  

также для целей завершения кода лучше определить тип 😉 но это не реальная причина для этого, потому что некоторые IDE могут обрабатывать и это.