performance - AS3-创建实例以访问方法/函数或使用静态[更新-一些基准测试-已添加]

Question

Noobie华夫饼和/或序言：

好吧，这是我的第一个问题，多年来，SO始终没有引导我正确的方向，尽管如此，我仍然是一个穷人，或者充其量只是想成为一名程序员，并且仍然继续发现一些困扰我的问题。和回头。这个问题就是其中之一，但是有一次我找不到具体的答案，有很多切题和平行讨论，但是我认为回答这个问题没有什么让我更清楚地理解。

因此，事不宜迟...

问题：

什么是更快（和/或最佳实践）；制作一个静态的类函数，从而可以从包中的其他任何地方调用它，或者在您希望使用它的时间和位置实例化该类，然后引用实例函数？

我到目前为止所读的所有内容都指出，静态通常比实例函数/变量要慢，但是我一直在与之抗争的是，首先实例化一个类，仅访问其中的一个元素并没有成本。

似乎实例化的行为除了要随后访问要使用的属性（在ClassName.function（）中）外，在MS中还应付出代价。不，这意味着静态路由会更快吗？无论哪种方式，多少钱？仅在单击时调用的内容或仅以ENTER_FRAME事件的速率显示的内容是否会引起注意？

除了速度外，实例化一个类也没有存储成本，例如，当您只想从包装盒中直接购买一包时就购买了多包薯片，从长远来看，这可能会更好，但是从长远来看，如果您只吃过一包薯片，实际上成本更高，而且它在您的手推车上占据了更多空间，这意味着其他东西的空间更少了，对我来说没有泡沫腾涌：(我不确定如果这个比喻有帮助...

无论如何，我将开始尝试自己进行基准测试，但与此同时，对于那些有知识的人（比我更有知识和经验的人）来说，这似乎是一个简单的答案， ，如果能提供宝贵的见解，我将不胜感激。

到目前为止，this最接近于回答我的问题，但是我在提取问题的具体答案时遇到了麻烦，也许是我缺乏理解才是原因所在，并且答案已经存在。

回顾TLDR和节省时间；


什么是更快/最佳实践；调用静态函数或实例化一个类，然后调用实例函数？
是否仅考虑实例化一个类的成本，以仅访问该类的一个元素？
对于更快的路线，要快多少？
在仅通过点击或ENTER_FRAME调用的内容上是否会引起注意？
除了速度之外，实例化整个类是否比使用静态方法引用要高得多的内存开销？


如果您有时间回答，我想先谢谢您。

[编辑]

好的，所以我进行了快速测试，我已经回答了我的问题，但是仍然认为最佳实践和其他人的意见会对我的学习有所帮助。 （请参阅下面的测试。

好的，所以我有两个类，主文档类和另一个类。

维护

    import flash.display.Sprite;
import flash.utils.getTimer;

public class Main extends Sprite
{       
    private static var preInstancedOtherClass:OtherClass = new OtherClass();
    private var averageOf:int = new int(10);
    public function Main()
    {
        runTests();
    }

    private function runTests() : void
    {
        var msRuntime1:Number = 0;
        var msRuntime2:Number = 0;
        var msRuntime3:Number = 0;
        for(var i:int = 0; i < averageOf; i++)
        {
            msRuntime1 += test1();
            msRuntime2 += test2();
            msRuntime3 += test3();

        }
        trace("static function ex-time: " + (msRuntime1/averageOf));
        trace("instance function ex-time: " + (msRuntime2/averageOf));
        trace("preInstance function ex-time: " + (msRuntime3/averageOf));
    }

    private function test1() : Number
    {
        var start_time:int = getTimer();
        OtherClass.testFunc1();
        return (getTimer()-start_time);
    }

    private function test2() : Number
    {
        var start_time:int = getTimer();
        var instanceofOtherClass:OtherClass = new OtherClass();
        instanceofOtherClass.testFunc2();
        return (getTimer()-start_time);
    }

    private function test3() : Number
    {
        var start_time:int = getTimer();
        preInstancedOtherClass.testFunc2();
        return (getTimer()-start_time);
    }
}

其他类

    import flash.display.Sprite;

public class OtherClass extends Sprite
{
    private var testLoop:int = new int(1000000);
    private static var staticTestLoop:int = new int(1000000);

    public function OtherClass() : void
    {
        //Do naffink
    }

    public static function testFunc1() : void
    {
        var testInt:int = 0;
        for(var i:int = 0; i < staticTestLoop; i++)
        {
            testInt += 10;
        }
    }

    public function testFunc2() : void
    {
        var testInt:int = 0;
        for(var i:int = 0; i < testLoop; i++)
        {
            testInt += 10;
        }
    }
}

结果：

因此，我大部分都回答了我。运行10次测试后，看来static的平均速度要快9/10倍，尽管不是很多，所以我应该使用static函数方法吗？因为它只能访问静态var，所以使事情变得更困难，但是对于实用程序类，它可以节省一些时间。

是否有更好的（OOP）和更快的方式完全解决？

节省这么小的MS时间是否重要？我不知道这是否会增加很多钱，或者通过更多有价值的操作和复杂的操作，需要更多的测试或浪费我的时间而变得更大？

结果如下：

（代表过低而无法发布图片）

静态的
70.3 70.5 71.5 71 70.5 71.2 71.4 77.4 72.7 70.2

实例化
71.9 73.5 73.7 73.8 73.7 70.9 73.4 77.9 74.9 73.4

先前实例化
71.9 73.2 73.7 73.6 73.9 71 73.4 78.8 75.1 73.1

我发现有趣的是，在类开始时实例化一次实际上与动态创建新实例相当。因此，也许这可以回答我有关内联实例化的问题，即没有太多开销。

思想将不胜感激，如此小的差异是否重要，还有更好的选择吗？

Answer 1

由于问题缺乏适当的上下文，因此我在这里假设某种通用的上下文。与这些事情一样，请测试您的特定情况以查看最适合您的情况。


回顾TLDR和节省时间；

什么是更快/最佳实践；调用静态函数或实例化一个类，然后调用实例函数？


看来您已经更快地解决了。最佳实践...所有静态函数（无I / O，并且给定相同的输入，相同的输出）应静态调用。就像您使用Math一样。 Math.random()是这里的例外。但是，如果需要保持某种状态，则最好实例化该类。


是否仅考虑实例化一个类的成本，以仅访问该类的一个元素？


措词含糊，因此请改写：“我在回答第一个问题时是否考虑了性能成本？”是的，我做到了。我立即放弃了它对我的回答的影响。在需要多次使用该函数的循环中，将实例化作为几乎自然的优化而移出了循环。剩下的唯一情况是常规的一次性使用-那时不再重要。停止微优化，直到需要它为止-花费时间在开发上，这样，当您确实需要额外的性能时，就可以串接一堆性能提升（正确设置基准测试环境是一件麻烦的事情，最好一次完成）。

例如。您在代码中混合了数字类型Number和int。这需要转换。那是性能上的打击。多大？您必须进行测试。但是通常情况下，如果您开始担心这些小的优化，您就会错过更大的优化。


对于更快的路线，要快多少？


显然，在您的测试环境上需要2毫秒。


在仅通过点击或ENTER_FRAME调用的内容上是否会引起注意？


不。在30 FPS时，您有33.3ms的可用时间。在60 FPS时，您有16.6ms的可用时间。 2毫秒很容易就可以装在那里。


除了速度之外，实例化整个类是否比使用静态方法引用要高得多的内存开销？


内存成本？
上课吗？
您不必担心的另一件事（如果您想知道，请进行测试...）
对象吃得多的内存。特别是对象的集合。
在游戏中，这将是一个关卡的所有图块，或者是所有敌人，所有图形……这一切需要占用更多，更多，更多的内存。

简而言之...

除非您必须在非常旧的设备上工作，或者遇到性能/内存问题（并且已经在设计级上消除了很多缺陷！），否则大多数情况都无关紧要。