精华内容
下载资源
问答
  • JAVA代码优化总结 通过使用一些辅助性工具来找到程序中的瓶颈然后就可以对瓶颈部分的代码进行优化一般有两种方案即优化代码或更改设计方法我们一般会选择后者因为不去调用以下代码要比调用一些优化的代码更能提高...
  • PHP代码优化的方法

    2016-03-01 11:56:11
    PHP代码优化的目的是为了提高PHP程序的执行效率,编写PHP代码时,可以从以下方面着手优化: 1. 用单引号代替双引号来包含字符串 2. 如果能将类的方法定义成static,就尽量定义成static,它的速度会提升将近4倍。 3...
    PHP代码优化的目的是为了提高PHP程序的执行效率,编写PHP代码时,可以从以下方面着手优化:
    1. 用单引号代替双引号来包含字符串
    2. 如果能将类的方法定义成static,就尽量定义成static,它的速度会提升将近4倍。
    3. 用 echo 代替 print,效率更好
    4. 及时注销不用的变量,尤其是大数组,以便释放内存
    5. 尽量避免使用__get(),__set(),__autoload()
    6. require_once()代价昂贵,尽量少用
    7. 尽量用函数代替正则表达式完成相同的功能
    8. str_replace 函数比 preg_replace 函数快
    9. 使用分支语句(即 switch case)好于使用多个 if,else if 语句
    10. 用@屏蔽错误消息的做法非常低效
    11. 当执行变量$i的递增或递减时,++$i 会比 $i++ 快一些
    12. 尽量使用PHP的内置函数
    13. 循环体内部不要声明变量,尤其是大变量
    14. foreach 效率更高,尽量用 foreach 代替 while 和 for 循环
    15. 用 $i+=1 代替 $i=$i+1,效率更高
    16. 对于 global 全局变量,用完后立即 unset() 掉
    17. 适当地做一些缓存处理

    展开全文
  • 代码优化

    2012-05-30 10:40:13
    代码优化的目的是最大限度地提升你的Flash资源的性能,同时尽可能使用最少的系统资源-RAM和CPU。在本教程中,我们从一个可以运行但是耗费很多资源的Flash应用程序开始,然后逐渐地在我们的源代码中应用一些优化方法...

    代码优化的目的是最大限度地提升你的Flash资源的性能,同时尽可能使用最少的系统资源-RAM和CPU。在本教程中,我们从一个可以运行但是耗费很多资源的Flash应用程序开始,然后逐渐地在我们的源代码中应用一些优化方法,最后得到一个更快,更简洁的SWF文件。

    最终结果预览:

    先看看我们要得到的最后的结果:



    注意“MemoryUsed(内存使用)”以及“CPU Load(CPU 负荷)”这两个状态是基于你已经打开的浏览器窗口中的所有SWF文件,包括Flash广告以及相类似的一些东西。这个SWF文件与真实的它相比,这里就可能显得要消耗更多的资源。

    第1步:理解这个Flash影片

    这个Flash 影片有两个主要元素:一个是对火焰的例子模拟,另外一个是一张图,这张图显示的是这个动画随着时间变化的资源消耗情况。这张图的粉红色的线条是以兆字节为单位来跟踪这个影片的所有内存消耗,而绿色线条是以百分比的形式绘制出CPU的负荷情况。

         ActionScript对象占用了系统分配给Flash  Player的大部分内存,并且一个影片中包含的ActionScript对象越多,影片消耗的内存也就越多。为了让一个程序的内存消耗保存在低水平,Flash  Player 一般会通过清理一些ActionScript 对象同时释放掉那些不再使用的内存来进行垃圾回收。

    内存消耗图一般显示的是像一座小山一样的由上而下的这样一种图形,而后在每次执行垃圾回收之后,这个图像就变得倾斜,然后又随着新对象的创建慢慢上升。只上升的线条表明垃圾回收出现了问题,这意味着新的对象被添加到内存中,而没有其它的对象被删除。如果继续这样的一个趋势的话,Flash  Player  可能最终因为耗尽了所有的内存而崩溃。

          CPU负荷是通过跟踪影片的帧速来进行计算的。一个Flash 影片的帧速就有点类似于它的心跳。每一帧,Flash  Player更新并且渲染屏幕上的所有元素,同时运行所有的要完成的ActionScript 任务。

    帧速决定了Flash  Player 在每一帧上该花多长的时间,所以10帧每秒(10fps)的帧速意味着至少每帧100毫秒。如果所有所需的任务在这样的一个时间段内完成了,那么Flash  Player会一直等到本帧的剩余时间结束,才会开始下一帧。另一方面,如果以某一特定的帧速,所有所需的任务需要很高的CPU消耗以致于不能在相应的时间段内完成,那么帧速会自动减缓来获取一些额外的时间。一旦负荷减轻了,帧速又会自动加上去,返回到原来的设定值。

    (在程序父窗口失去焦点或者移动到屏幕边界外面的情况下,Flash Player会自动地将帧速减小到4fps。这样做是确保无论用户的焦点在哪里,都能保护系统资源。)

    所有的这些意味着实际上存在两种帧速:一种是你最初设置的并且希望你的影片总是以这个速度运行,另外一种是它实际的运行帧速。我们将称你自己设置的这个帧速叫做目标帧速,而它实际运行的速度称作实际帧速。

    图中的CPU负荷是通过实际帧速和目标帧速的比值来进行计算的。使用到的公式如下:

    CPU  load=(目标帧速– 实际帧速 )/ 实际帧速 *100;

    例如,如果目标帧速被设为50fps,但是影片实际的帧速为25fps,CPU 负荷将会是50%,计算方法是(50-25)/50*100.

    请注意这并不是运行这个影片所要使用的系统CPU 资源的实际百分比,而是对真实值的一个初略的估计。对于这里描述的优化过程,这个估计对与手边的任务而言已经是一个很好的度量。为了可以获取到CPU 的实际使用率,可以使用你的操作系统提供的工具。例如,Windows中的任务管理器,现在看看我的任务管理器,它显示没有优化的影片正使用53%的CPU资源,而影片的图形上却显示CPU负荷为41.7%。

    请注意:本教程中的所有影片截图都是来自我个人电脑上的Flash  Player版本。这张图上的数字很可能在你的系统上显示的就不一样了,这主要依据你的操作系统,浏览器以及Flash  Player版本。如果你已经在不同的浏览器窗口中或者Flash player中打开了其它的Flash  应用程序,那么在某些系统上它也可能影响到内存的使用大小。当分析你的程序的性能时,一定要确保没有其它的Flash 程序正在运行,因为它们可能影响到你的度量。

    对于CPU 负荷而言,影片无论什么时候移动到了屏幕的边界之外,它的值就会飙升到90%。例如,如果你切换到另外一个浏览器或者将这一页往下翻,这是由更低的帧速造成的。更低的帧速不是由需要消耗大量CPU资源的任务造成的,而是无论什么时候,当该应用程序不在你的视野之内时,Flash就会压制帧速。

    第2步:这些代码会让我的Flash工程变得更庞大吗?

        这个影片的源代码在下面展示出来了并且只包含了一个类,类名叫做Flames,这个类也是文档类。这个类包含了一组的属性来跟踪这个影片的内存以及CPU负荷历史,跟踪到的数据用来绘制图形。内存和CPU负荷的统计信息是在Flames.getStatus()方法中计算并且更新的,图形是通过调用Flames.drawGraph()方法来进行绘制的。为了创建这个火焰效果,Flames.createParticles()方法首先每秒生成成百上千个粒子,这些粒子存放在fireParticles数组中,这个数组在Flames.drawParticles()方法中进行循环,利用每个粒子的属性来创建这个效果。

    花一些时间来学习这个Flames类,你是否已经能找到一些快速的改变,而这些改变对程序的优化有很大的帮助呢?

        package com.pjtops{
        import flash.display.MovieClip;
        import flash.events.Event;
        import fl.motion.Color;
        import flash.geom.Point;
        import flash.geom.Rectangle;
        import flash.text.TextField;
        import flash.system.System;
        import flash.utils.getTimer;

        public class Flames extends MovieClip{

            private var memoryLog = new Array(); // stores System.totalMemory values for display in the graph
            private var memoryMax = 0; // the highest value of System.totalMemory recorded so far
            private var memoryMin = 0;  // the lowest value of System.totalMemory recorded so far
            private var memoryColor; // the color used by text displaying memory info

            private var ticks = 0; // counts the number of times getStats() is called before the next frame rate value is set
            private var frameRate = 0;  //the original frame rate value as set in Adobe Flash
            private var cpuLog = new Array(); // stores cpu values for display in the graph
            private var cpuMax = 0; // the highest cpu value recorded so far
            private var cpuMin = 0; // the lowest cpu value recorded so far
            private var cpuColor;   // the color used by text displaying cpu
            private var cpu; // the current calculated cpu use  

            private var lastUpdate = 0; // the last time the framerate was calculated
            private var sampleSize = 30; // the length of memoryLog & cpuLog
            private var graphHeight;
            private var graphWidth;

            private var fireParticles = new Array(); // stores all active flame particles
            private var fireMC = new MovieClip(); // the canvas for drawing the flames
            private var palette = new Array(); // stores all available colors for the flame particles
            private var anchors = new Array(); // stores horizontal points along fireMC which act like magnets to the particles
            private var frame; // the movieclips bounding box

            // class constructor. Set up all the events, timers and objects
            public function Flames() {
                addChildAt( fireMC, 1 );
                frame = new Rectangle( 2, 2, stage.stageWidth - 2, stage.stageHeight - 2 );

                var colWidth = Math.floor( frame.width / 10 );
                for( var i = 0; i < 10; i++ ){
                    anchors[i] = Math.floor( i * colWidth );
                }

                setPalette();

                memoryColor = memoryTF.textColor;
                cpuColor = cpuTF.textColor;
                graphHeight = graphMC.height;
                graphWidth = graphMC.width;

                frameRate = stage.frameRate;

                addEventListener( Event.ENTER_FRAME, drawParticles );
                addEventListener( Event.ENTER_FRAME, getStats );
                addEventListener( Event.ENTER_FRAME, drawGraph );
            }

            //creates a collection of colors for the flame particles, and stores them in palette
            private function setPalette(){
                var black = 0x000000;
                var blue = 0x0000FF;
                var red = 0xFF0000;
                var orange = 0xFF7F00;
                var yellow = 0xFFFF00;
                var white = 0xFFFFFF;
                palette = palette.concat( getColorRange( black, blue, 10 ) );
                palette = palette.concat( getColorRange( blue, red, 30 ) );
                palette = palette.concat( getColorRange( red, orange, 20 ) );
                palette = palette.concat( getColorRange( orange, yellow, 20 ) );
                palette = palette.concat( getColorRange( yellow, white, 20 ) );
            }

            //returns a collection of colors, made from different mixes of color1 and color2
            private function getColorRange( color1, color2, steps){
                var output = new Array();
                for( var i = 0; i < steps; i++ ){
                    var progress = i / steps;
                    var color = Color.interpolateColor( color1, color2, progress );
                    output.push( color );
                }
                return output;
            }

            // calculates statistics for the current state of the application, in terms of memory used and the cpu %
            private function getStats( event ){
                ticks++;
                var now = getTimer();

                if( now - lastUpdate < 1000 ){
                    return;
                }else {
                    lastUpdate = now;
                }

                cpu = 100 - ticks / frameRate * 100;
                cpuLog.push( cpu );
                ticks = 0;
                cpuTF.text = cpu.toFixed(1) + '%';
                if( cpu > cpuMax ){
                    cpuMax = cpu;
                    cpuMaxTF.text = cpuTF.text;
                }
                if( cpu < cpuMin || cpuMin == 0 ){
                    cpuMin = cpu;
                    cpuMinTF.text = cpuTF.text;
                }

                var memory = System.totalMemory / 1000000;
                memoryLog.push( memory );
                memoryTF.text = String( memory.toFixed(1) ) + 'mb';
                if( memory > memoryMax ){
                    memoryMax = memory;
                    memoryMaxTF.text = memoryTF.text;
                }
                if( memory < memoryMin || memoryMin == 0 ){
                    memoryMin = memory;
                    memoryMinTF.text = memoryTF.text;
                }
            }

            //render's a graph on screen, that shows trends in the applications frame rate and memory consumption
            private function drawGraph( event ){
                graphMC.graphics.clear();
                var ypoint, xpoint;
                var logSize = memoryLog.length;

                if( logSize > sampleSize ){
                    memoryLog.shift();
                    cpuLog.shift();
                    logSize = sampleSize;
                }
                var widthRatio = graphMC.width / logSize;   

                graphMC.graphics.lineStyle( 3, memoryColor, 0.9 );
                var memoryRange = memoryMax - memoryMin;
                for( var i = 0; i < memoryLog.length; i++ ){
                    ypoint = ( memoryLog[i] - memoryMin ) / memoryRange * graphHeight;
                    xpoint = (i / sampleSize) * graphWidth;
                    if( i == 0 ){
                        graphMC.graphics.moveTo(  xpoint, -ypoint );
                        continue;
                    }
                    graphMC.graphics.lineTo( xpoint, -ypoint );
                }

                graphMC.graphics.lineStyle( 3, cpuColor, 0.9 );
                for( var j = 0; j < cpuLog.length; j++ ){
                    ypoint = cpuLog[j] / 100 * graphHeight;
                    xpoint = ( j / sampleSize ) * graphWidth;
                    if( j == 0 ){
                        graphMC.graphics.moveTo(  xpoint, -ypoint );
                        continue;
                    }
                    graphMC.graphics.lineTo( xpoint, -ypoint );
                }
            }

            //renders each flame particle and updates it's values
            private function drawParticles( event ) {
                createParticles( 20 );

                fireMC.graphics.clear();
                for ( var i in fireParticles ) {
                    var particle = fireParticles[i];

                    if (particle.life == 0 ) {
                        delete( fireParticles[i] );
                        continue;
                    }

                    var size = Math.floor( particle.size * particle.life/100 );
                    var color = palette[ particle.life ];
                    var transperency = 0.3;                             

                    if( size < 3 ){
                        size *= 3;
                        color = 0x333333;
                        particle.x += Math.random() * 8 - 4;
                        particle.y -= 2;
                        transperency = 0.2;
                    }else {
                        particle.y = frame.bottom - ( 100 - particle.life );

                        if( particle.life > 90 ){
                            size *= 1.5;
                        }else if( particle.life > 45){
                            particle.x += Math.floor( Math.random() * 6 - 3 );
                            size *= 1.2;
                        }else {
                            transperency = 0.1;
                            size *= 0.3;
                            particle.x += Math.floor( Math.random() * 4 - 2 );
                        }
                    }               

                    fireMC.graphics.lineStyle( 5, color, 0.1 );
                    fireMC.graphics.beginFill( color, transperency );
                    fireMC.graphics.drawCircle( particle.x, particle.y, size );
                    fireMC.graphics.endFill();
                    particle.life--;
                }
            }

            //generates flame particle objects
            private function createParticles( count ){
                var anchorPoint = 0;
                for(var i = 0; i < count; i++){
                    var particle = new Object();
                    particle.x = Math.floor( Math.random() * frame.width / 10 ) + anchors[anchorPoint];
                    particle.y = frame.bottom;
                    particle.life = 70 + Math.floor( Math.random() * 30 );
                    particle.size = 5 + Math.floor( Math.random() * 10 );
                    fireParticles.push( particle );

                    if(particle.size > 12){
                        particle.size = 10;
                    }
                    particle.anchor = anchors[anchorPoint] + Math.floor( Math.random() * 5 );

                    anchorPoint = (anchorPoint == 9)? 0 : anchorPoint + 1;
                }
            }

        }
        }

    复制代码



    有很多东西要理解,但是不要担心-----我们将会在教程的剩下部分对这些代码进行不同的改进。

    第3步:使用强类型给所有的变量指定数据类型


    我们对这个类做的第一个改进的地方是给所有声明的变量,函数参数以及函数返回值指定数据类型。

    例如,将下面的代码

        protected var memoryLog = new Array();
        protected var memoryMax = 0; // yes, but what exactly are you?

    复制代码


    改成

        protected var memoryLog:Array = new Array();
        protected var memoryMax:Number = 0; // memoryMax the Number, much better!

    复制代码


    无论什么时候声明变量,一定要指定它们的数据类型,因为这可以让Flash 编译器在生成SWF文件的时候执行一些特殊的优化。单独这一个就可以带来很大的性能提升,我们将很快从我们的例子中看到效果。另外一个使用强类型的好处是编译器将会捕捉并且对任何与数据类型有关的bug会做出警告。


    第4步:检查结果


    这张屏幕截图显示的内容是经过上面的优化之后Flash 影片的性能,我们可以看到当前的或者最大的CPU负荷并没有因为上面的优化而发生改变,最小CPU负荷从8.3%降到了4.2%。最大的内存消耗从9MB减少到了8.7MB。

    相比步骤2中显示的图片中的内存线条,上图中的内存线条的倾斜度也发生了改变。它仍然呈现出相同的锯齿形的形状,但是现在它以一个很缓慢的速率下降和上升。如果你认为内存消耗的突然下降是由Flash  Player的垃圾回收造成的,而内存消耗的突然下降事件常常在分配的内存即将耗尽时触发,那么这是一件很棒的事情。这样的垃圾回收可能会是一次代价非常高的操作,因为Flash  Player必须遍历所有的对象,寻找那些不再需要但仍然占用内存的对象。这样的操作做的次数越少,对整个应用程序而言性能就越好。

    第5步:高效地存储数值数据


    ActionScript提供了3中数值数据类型,Number,uint以及int。在这三种类型中,Number消耗的内存最多,因为与其它两种类型相比,它可以存储更大的数值。而且它也是能唯一存储十进制小数的数据类型。

    Flame 类有很多的数值属性,所有的这些属性使用的都是Number数据类型。由于int和uint是更轻便的数据类型,我们可以通过在所有的场合中使用它们而不是使用Number来节省一些内存,当然这些场合中我们是不需要使用到十进制小数的。

    一个比较好的例子是在循环和数组索引中,例如我们将把下面的代码

        for( var i:Number = 0; i < 10; i++ ){
            anchors[i] = Math.floor( i * colWidth );
        }

    复制代码


    改成

        for( var i:int = 0; i < 10; i++ ){
            anchors[i] = Math.floor( i * colWidth );
        }

    复制代码



    cpu,cpuMax以及memoryMax的属性将仍然使用Number数据类型,因为它们很有可能要存储十进制数据,而memoryColor,cpuColor以及ticks可以改成uint类型,因为它们将用来存储正整数。

    第6步:进行最少的函数调用



    函数调用的代价非常高,尤其是调用另外一个类中的函数。如果那个类是在不同的包中或者该函数为一个静态方法(函数),那么情况就会变得更糟。这里的Math.floor()函数就是一个非常好的例子,它在Flames类中被用来对小数值进行四舍五入。这个函数调用可以通过使用uint而不是使用Number来存储整数的方法进行避免。

        // So instead of having:
        anchors[i] = Math.floor( i * colWidth );
        // we instead cast the value to a uint
        anchors[i] = uint( i * colWidth );

        // The same optimization can be performed by simply assigning the uint data type, for example changing
        var size:uint = Math.floor( particle.size * particle.life/100 );
        // into
        var size:uint = particle.size * particle.life/100;

    复制代码


    在上面的例子中,调用Math.floor()函数不是必须的,因为Flash会自动地在将十进制小数值转换成uint型数值时进行四舍五入。

    第7步:乘法比除法快多了


    Flash  Player明显地发现乘法运算比除法运算快得多,所以我们寻找整个Flames 类并且将所有的除法运算转换成等价的乘法运算。转换公式涉及到获取操作符右边的值的倒数,并且用该倒数乘以操作符左边的数值。一个数的倒数等于1除以这个数。

        var colWidth:uint = frame.width / 10; //division by ten
        var colWidth:uint = frame.width * 0.1; //produces the same result as multiplication by 0.1

    复制代码


    让我们快速地看看我们最近几步优化的结果吧。CPU负荷终于从41.7%降到了37.5%,但是内存消耗却呈现出不一样的变化。最大的内存消耗已经上升到了9.4MB,这是目前为止最高的数值了,并且图中尖尖的,锯齿形的线条表明垃圾回收现在执行的非常频繁。一些优化技术将会对内存和CPU负荷产生副作用,改善了其中一个而把另一个作为代价。由于内存消耗基本上是回到了最开始的值,所以还有很多的工作要做啊!


    第8步:循环利用有利于整个环境


    你也可以在改善程序环境上做好你的工作。当写AS3代码的时候重复利用你的对象可以减少程序中资源消耗的数量。新对象的创建和销毁要付出的代价很高。如果你的程序经常创建和销毁同一类型的对象,那么通过重复利用这些对象可以获取到很大的性能提升。看看Flames类,我们可以看到每一秒都有很多的例子对象被创建和销毁。

        private function drawParticles( event ):void {
            createParticles( 20 );

            fireMC.graphics.clear();
            for ( var i:* in fireParticles ) {
                var particle:Object = fireParticles[i];

                if (particle.life == 0 ) {
                    delete( fireParticles[i] );
                    continue;
                }

    复制代码


    有很多的方法来重复利用对象,大部分都涉及到创建一个第二变量来存储不需要的对象,而不是删除它们。然后当需要同一类型的新对象时,它可以从存储的数据中重新获取而不需要重新创建一个新的对象。新的对象只在没有存储数据的时候才被创建。我们将对Flames类的粒子对象做些类似的优化。

    首先,我们创建一个新的数组,数组名为inactiveFireParticles[],这里面存放着粒子的引用,这些例子的life属性都设为了0.(没有生命)在drawParticles()函数中,不需要删除一个没有生命的粒子,我们将它添加到inactiveFireParticles[]数组中。

        private function drawParticles( event ):void {
            createParticles( 20 );

            fireMC.graphics.clear();
            for ( var i:* in fireParticles ) {
                var particle:Object = fireParticles[i];

                if( particle.life <= 0 ) {
                    if( particle.life == 0 ){
                        particle.life = -1;
                        inactiveFireParticles.push( particle );
                    }
                    continue;
                }

    复制代码


    接着我们修改cureateParticles()方法来对存放在inactiveFireParticles()数组进行第一次的遍历,并且在创建新的粒子之前使用它们。

        private function createParticles( count ):void{
            var anchorPoint = 0;
            for(var i:uint = 0; i < count; i++){

                var particle:Object;
                if( inactiveFireParticles.length > 0 ){
                    particle = inactiveFireParticles.shift();
                }else {
                    particle = new Object();
                    fireParticles.push( particle );
                }               

                particle.x = uint( Math.random() * frame.width * 0.1 ) + anchors[anchorPoint];
                particle.y = frame.bottom;
                particle.life = 70 + uint( Math.random() * 30 );
                particle.size = 5 + uint( Math.random() * 10 );

                if(particle.size > 12){
                    particle.size = 10;
                }
                particle.anchor = anchors[anchorPoint] + uint( Math.random() * 5 );

                anchorPoint = (anchorPoint == 9)? 0 : anchorPoint + 1;
            }
        }

    复制代码



    第9步:在任何可能的情况下使用Object和Array字面值

    当创建新的对象或者数组是,使用文字型语法比使用new操作符更快。

        private var memoryLog:Array = new Array(); // array created using the new operator
        private var memoryLog:Array = []; // array created using the faster array literal

        particle = new Object(); // object created using the new operator
        particle = {}; // object created using the faster object literal

    复制代码


    第10步:避免使用动态类



    ActionScript中的类可以使密封的也可以是动态的。它们默认是密封的,这意味着一个对象能从类中唯一获取到的属性和方法必须在类中进过了定义。而对于动态类而言,新的属性和方法可以再运行时进行添加。密封类比动态类更高效,因为当一个类的所有可能的功能都已经知道了的话,那么一些Flash  Player的性能优化就可以进行了。


    在Flames 类中,成千上万个粒子是继承自内建的Object类,这个类是动态类。由于没有新的属性在运行时需要被添加到粒子中,我们将通过给粒子创建一个自定义的密封类来节省更多的资源。

    下面的是新的Particle,这已经被添加到同一个Flames.as文件中去了。

        class Particle{
            public var x:uint;
            public var y:uint;
            public var life:int;
            public var size:Number;
            public var anchor:uint;
        }

    复制代码


    CreateParticles()方法也将作出调整,将下面的这两行

        var particle:Object;
        particle = {};

    复制代码


    改成

        var particle:Particle;
        particle = new Particle();

    复制代码


    第11步:当你不需要时间轴的时候就使用Sprites

    就和Object类一样,MovieClips属于动态类,MovieCliip类继承自Sprite类,并且这两者之间最主要的不同点在于MovieClip有时间轴。因为Sprite涵盖了MovieClip中除时间轴外的所有功能,在你的显示对象不需要时间轴的任何时候都尽量使用Sprite.Flames类继承自MovieClip,但是它并不使用时间轴,因为它的所有的动画都是通过ActionScript来控制的。火焰离子是在fireMC中绘制的,这也是一个不需要时间轴的影片剪辑。

    我们将Flames和fireMC都改成继承自Flames和fireMC,下面的代码

        import flash.display.MovieClip;
        private var fireMC:MovieClip = new MovieClip();
        public class Flames extends MovieClip{

    复制代码


    可以被替换成

       

        import flash.display.Sprite;
        private var fireMC:Sprite = new Sprite();
        public class Flames extends Sprite{

    复制代码


    第12步:当你不需要子显示对象或者鼠标输入的时候,使用Shape来代替Sprite



    Shape类比起Sprite类来更显得轻便,但是他不支持鼠标事件或者包含子显示对象。由于fireMC并不需要这些功能,我们可以安全地将它装换成Shpae类型。

        import flash.display.Shape;
        private var fireMC:Shape = new Shape();

    复制代码



    这张图显示内存消耗上我们得到了很大的改进,数值下降并且稳定地保持在4.8MB这个水平线上。锯齿线也被近乎水平直线所替代,意味着垃圾回收现在很少运行。但是CPU负荷又基本上回到了起始水平41.7%。


    第13步:避免循环内的复杂计算

    他们说一个程序超过50%的时间是用来执行它10%的代码,并且而那10%中的大部分时间都花在了循环上。很多循环优化技术涉及到将很多高CPU消耗的操作移到循环体的外面。这些操作包括对象的创建,变量的查找以及计算。

        for( var i = 0; i < memoryLog.length; i++ ){
            // loop body
        }

    复制代码


    上面显示的drawGraph()方法中的第一个循环。这个循环遍历了memoryLog数组中的每一项,利用这些数据来在图中绘制出每一个点。在每次开始运行的时候,它找到memoryLog数组的长度并且将它和循环计数值的大小相比较。如果memoryLog数组有200项,这个循环就要执行200次,并且执行200次同样的查找。因为memoryLog的长度并不会改变,那么重复的查找就显得很浪费并且是没有必要的。最好是在查找开始之前一次找出memoryLog.length的值,并把它存到一个本地变量中,因为访问一个本地变量比访问一个对象的属性要快得多。

        var memoryLogLength:uint = memoryLog.length;
        for( var i = 0; i < memoryLogLength; i++ ){
            // loop body
        }

    复制代码

    在Flames类中,我们如上面所示地调整了drawGraph()方法中的两个循环。


    第14步:将条件语句中最可能为真的语句放到第一位

    考虑下面的if…else条件语句区块,它们是drawParticles()方法里面的一部分:

        if( particle.life > 90 ){ // a range of 10 values, between 91 - 100
            size *= 1.5;
        }else if( particle.life > 45){ // a range of 45 values, between 46 - 90
            particle.x += Math.random() * 6 - 3;
            size *= 1.2;
        }else { // a range of 45 values, values between 0 - 45
            transperency = 0.1;
            size *= 0.3;
            particle.x += Math.random() * 4 - 2;
        }

    复制代码


    一个粒子的生命可以使0到100之间的任何一个值。If语句测试当前的例子生命是否是在91到100之间,并且如果是的话,它就会执行相应区块下的代码。else----if字句测试粒子的生命值是否在46到90之间,然后else字句测试的是剩下的值,这些值的氛围是在0到45之间。考虑到第一个检测成功的可能性最小,因为它只有很小的数值范围,它应该放在最后来进行条件测试。这个if—else区块在下面进行了重写,这样的话最可能成功的情况最先检测,这就使得计算更高效。

        if( particle.life < 46 ){
            transperency = 0.1;
            size *= 0.3;
            particle.x += Math.random() * 4 - 2;
        }else if( particle.life < 91 ){
            particle.x += Math.random() * 6 - 3;
            size *= 1.2;
        }else {
            size *= 1.5;
        }

    复制代码

    第15步:不使用push来将元素添加到数组的末尾



    Array.push()方法在Flames类中用到很多。它将会被一个更快速的方法替代,这个方法使用到了数组的length属性。

        cpuLog.push( cpu ); // slow and pretty
        cpuLog[ cpuLog.length ] = cpu; // fast and ugly

    复制代码

    当我们知道数组的长度,我们可以用一种更快的技术来替代Array.push()方法,下面是示例:

        cpuLog.push( cpu ); // slow and pretty
        cpuLog[ cpuLog.length ] = cpu; // fast and ugly

    复制代码

    第16步:用Vectors替代Arrays



    Array和Vecotr两个类非常相似,但也有两个不同点:Vecotrs只能存储同一类型的对象,并且他们比数组更高效,更快。由于Flames类中所有的数组只是根据需要存储一种类型的变量---int,uint或者Particle---我们可以将它们全部转换成Vectors.

    这些数组:

        private var memoryLog:Array = [];
        private var cpuLog:Array = [];
        private var fireParticles:Array = [];
        private var palette:Array = [];
        private var anchors:Array = [];
        private var inactiveFireParticles:Array = [];

    复制代码


    可以用等价的Vector进行替换:

        private var memoryLog:Vector.<Number> = new Vector.<Number>();
        private var cpuLog:Vector.<Number> = new Vector.<Number>();
        private var fireParticles:Vector.<Particle> = new Vector.<Particle>();
        private var palette:Vector.<uint> = new Vector.<uint>();
        private var anchors:Vector.<uint> = new Vector.<uint>();
        private var inactiveFireParticles:Vector.<Particle> = new Vector.<Particle>();

    复制代码


    然后我们修改getColorRange()方法来正常使用Vectors而不使用数组。

        private function getColorRange( color1, color2, steps):Vector.<uint>{
            var output:Vector.<uint> =  new Vector.<uint>();
            for( var i:uint = 0; i < steps; i++ ){
                var progress:Number = i / steps;
                var color:uint = Color.interpolateColor( color1, color2, progress );
                output[i] = color;
            }
            return output;
        }

    复制代码


    第17步:谨慎使用事件模式



    虽然很方便,快捷,但是AS3的事件模式是建立在复杂的事件侦听,发送以及对象上面的;然后就有了事件的传送,冒泡以及更多操作,所有的这些在教科书上应该会有讲到。无论什么时候只要有可能,总是直接去调用一个方法而不使用事件模型。

        addEventListener( Event.ENTER_FRAME, drawParticles );
        addEventListener( Event.ENTER_FRAME, getStats );
        addEventListener( Event.ENTER_FRAME, drawGraph );

    复制代码


    Flames类有三种事件侦听器,分别调用三种不同的方法,并且都绑在了ENTER_FRAME事件上。在这种情况下,我们可以执行第一个事件侦听器而不需要另外两个,然后先是执行drawParticles()方法,然后是getStarus()方法,最后调用drawGraph()方法。作为选择,我们可以只创建一个新的方法,这个方法为我们直接调用getStatus(),drawGraph()以及drawParticles(),然后只有一个事件侦听器绑定到这个新的方法上。可是第二种做法的代价更高,所以我们还是选择第一种做法。

        // this line is added before the end of the <code> drawParticles </code>() method
        getStats();
        // this line is added before the end of the <code> getStats() </code> method
        drawGraph();

    复制代码


    我们也将从drawGraph()和getStatus()方法中移除事件参数(这个参数持有事件对象),因为它们已经不再需要了。


    第18步:给所有不需要鼠标事件的显示对象关闭它们的鼠标事件相应功能


    由于这个Flash动画并不需要进行任何的用户交互,我们可以关闭掉显示对象的发送鼠标事件功能。在Flames类中,我们通过将它的mouseEnabled属性设置为false来达到目的。我们也通过设置mouseChildren属性为false来禁止它所有的子对象的鼠标响应事件功能。把下面的代码添加到Flames构造函数中。

        mouseEnabled = false;
        mouseChildren = false;

    复制代码


    第19步:使用Graphics.drawPath()方法来绘制复杂的形状

    当使用很多的直线或者曲线来绘制复杂的路径时,Graphics.drawPath()方法可以用来进行性能优化,在Flames.drawGraph()方法中,CPU负荷以及内存消耗图线都是使用Graphics.moveTo()和Graphics.lineTo()方法组合来进行绘制的。

        for( var i = 0; i < memoryLogLength; i++ ){
            ypoint = ( memoryLog[i] - memoryMin ) / memoryRange * graphHeight;
            xpoint = (i / sampleSize) * graphWidth;
            if( i == 0 ){
                graphMC.graphics.moveTo(  xpoint, -ypoint );
                continue;
            }
            graphMC.graphics.lineTo( xpoint, -ypoint );
        }

    复制代码


    我们调用Graphics.drawPath()方法来替代最初的绘制方法。经过改进了的代码的一个额外的好处是我们也将绘图代码从循环中移除了。

        var commands:Vector.<int> = new Vector.<int>();
        var data:Vector.<Number> = new Vector.<Number>();

        for( var i = 0; i < memoryLogLength; i++ ){
            ypoint = ( memoryLog[i] - memoryMin ) / memoryRange * graphHeight;
            xpoint = (i / sampleSize) * graphWidth;

            if( i == 0 ){
                data[ data.length ] = xpoint;
                data[ data.length ] = -ypoint;
                commands[ commands.length ] = 1;
            }

            data[ data.length ] = xpoint;
            data[ data.length ] = -ypoint;
            commands[ commands.length ] = 2;
        }
        graphMC.graphics.drawPath( commands, data );

    复制代码


    第20步:最终完成这些类

    Final属性定义了一个不可以被重写的方法或者不能被继承的类。它也可以让一个类执行的更快,所以我们将Flames和Particle类的属性设为final。

    编者按:读者Moko给我们展示了一篇由Jackson Dunstan写的很棒的文章,这篇文章中提到了final关键字并不会对性能有任何的影响。


    CPU 负荷现在是33.3%,而所有的内存使用保持在4.8到5MB之间。从最初的CPU负荷为41.7%以及最大的内存消耗为9MB到现在的状态,我们走过了一段很长的路程。

    知道什么时候停止,它给我们带来了在优化的过程中要做的最重要的决定之一。如果你停止的太早,你的游戏或者应用程序可能在低端系统上面执行的性能会比较差,并且如果你停止的太晚,你的代码可能会变得很模糊并且很难去维护。对于这个特定的应用程序,动画看起来很平滑很流畅,同时CPU和内存使用的情况也很正常,所以我们在这里停止。

    总结:

    我们使用Flames类作为一个例子来展示这样一个优化过程。同时很多的优化技巧通过一步一步的改变展现出来了,它们之间的顺序没有任何的关系。最重要的是要理解很多可以让我们的程序变慢的问题,并且采取措施来改正它们。

    但是记住要当心过早的优化。首先应该专注于构建你的程序并且让它运行起来,然后才开始进行优化。
    展开全文
  • 第10章代码优化.ppt

    2020-11-08 13:51:53
    要求明确代码优化的目的和分类 2. 掌握基本块的划分方法基本块的 DAG 表 示及优化实现 3. 掌握循环优化的三种优化方法 2 教学内容 10.1 局部优化 10.2 循环内优化 3 第 10 章 代码优化 目的 提高目标代
  • java代码优化

    2018-04-02 20:20:00
    一、 代码优化的目的:  1,减小代码体积 : 还有助于增加代码的可阅读性(这个很重要)  2,提高运算效率 二、 代码优化细节  1、尽量指定类、 变量、 方法的 final 修饰符  带有修饰符的类是不可派生...

    本文的主要类容来自  微信公众号  :  java后端技术,    (之后了解到的其他细节也会在此文中进行补充)

      一、 代码优化的目的:

          1,减小代码体积 : 还有助于增加代码的可阅读性(这个很重要)

          2,提高运算效率

     

    二、 代码优化细节

      1、尽量指定类、 变量、 方法的  final  修饰符

        带有修饰符的类是不可派生的, 在java的api中 像String之类的就是属于这类。

        被final修饰的类不能被继承,  被final修饰的方法不能被重写。  如果指定一个类是final的,那么这个类中所有的方法都是final的。

        文中的作者指出:  java的编译器会内联所有的final方法, 这对java运行效率提升很大, (可以达到   50% 左右)。

     

      2、尽量重用对象,   特别是String对象的使用, 出现字符串连接的时候,  应该使用StringBuilder  或者 StringBuffer代替,  因为java

        虚拟机 不仅要创建String对象(String对象为final对象,不能被改变), 这样可以减少内存中的对象信息,。

      3,、如果可以的话, 尽量使用局部变量, 局部变量 存在与 stack中, 随着方法运行的结束 而消失。 而其他的变量 则会存在与heap中, 这在

        方法运行结束后 还需要额外的垃圾回收。

      4、及时的关闭流, 在进行数据库连接或者 io编程的时候, 在使用完毕应当即使的关闭 用来释放资源。 因为流的操作会造成极大的性能开销。

      5、尽可能的减少重复的计算 , 在方法的调用的时候, 即便只有一句话,也是系统的性能开销。  在进行 集合 或者数组的遍历的时候, 其长度

        可以先计算出来。尤其是在 length恒大的时候, 对性能的提高就越发的明显

      6、尽量使用 懒加载策略,   在已经马上需要该类的时候再去创造该类。

      7、谨慎使用 异常,  在使用异常的时候 java虚拟机 就一定回去调用堆栈信息, 消耗很多资源。 所以不要为了达到某个普通的逻辑功能来使用异常。

      8、try catch 语句  最好放在最外面, 不要被选择  ,循环等判断。

      9、如果能估计到 最后添加的类容的长度, 可以为 底层使用数组方法、实现的集合指定长度   :  ArryList 、 LinkeList 、 StringBuffer 、 StringBuidler

        HashMap 、 HashSet 等。  因为 当集合数据满时, 会自动在底层创建一个 两倍当前长度的 集合,并将数据拷贝到新集合中。  而集合的初始

        默认长度较小, 所以数据量较大的时候,   会创建很多 类, 消耗大量的资源。

      10、当复制大量数据的时候,  使用  System.arrycopy()

      11、 乘法  和 除法使用移位操作,   这回加快计算机的执行速度

      12、循环内不要创建新的对象引用,   因为 如果循环量较大的话, 会在 stack中创建大量的临时引用。

      13、如无必要, 应当尽量使用 array  , 而不是使用 arrayList(当无法确定数组大小的时候再使用 list)

      14、如果没有同步要求, 尽量使用 HashMap, ArrayList,  StringBuilder。 不要使用 Hashtable, Vechtor,StringBuffer

      15、不要将一个数组 声明成一个 public static final    数组声明为 final 也还是能被改变, 而一个public 的数组明显并不安全。

      16、 在合适的场合使用单例模式  : 单例模式 可以减轻加载的负担,  减少加载的时间, 提高加载的效率, 

         使用场合 :  1)控制资源使用, 通过线程同步来控制资源的并发访问

              2)控制数据的共享, 以达到节约资源的目的

              3)控制数据共享, 再不建立直接关联的情况下, 让多个不相干的进程和线程中实现共享。

      17、尽量避免随意使用静态变量,    一个静态的变量  一般不会被 gc 回收,。

      18、及时清除不需要的会话   session 等 。

      19、 实现   RandomAccess  接口的集合   (ArryList 等) , 应当使用普通的 for 循环 而不是 forEach循环。

          因为foreach 循环底层使用的是 iterator  , 其是顺序访问的,  而RandomAccess接口表明支持随记访问。  

          而随记访问使用 for 循环更加的高效 , 反之亦然。

      20、使用同步代码块  来代替 同步方法,

      21、将常量声明为 static final ,并大写命名  : 虚拟机会将该常量放入常量池。

      22、不要创建一些不使用的 对象, 不要引入一些不使用的类。

      23、 少使用 反射,   虽然反射机制非常强大, 但是效率不太高。    建议:  在项目启动的时候 通过反射机制将要反射的地方创建出反射的对象。

      24、使用数据库连接池  和 线程池   (不用解释)

      25、使用带缓冲的输入输出流

      26、顺序插入和随机访问较多的地方 使用 ArrayList  ,  删除和中间插入比较多的使用 LinkedList  (底层数据结构)。

      27、public 方法中不要有太多形参

      28、字符串变量  和  字符串常量进行比较的时候将   常量放在前面。

      29、在java中 i==1 和 1==i是没有什么区别的, 但是在习惯上使用  i == 1.

      30、不建议对 数组使用 toString 方法,  因为 会打印成一个 哈希地址, 但是可以对 集合使用toString方法, 因为其父类中重写了 toSting方法。

      31、不要对超出范围的基本数据类型使用强制向下转型。如: 将一个 long 类型的强制转换成一个 int类型的,    这是因为 : 在java中向下转型是

          切断了long 的高 32 为二进制码,  所以并不能直接得到 是、十进制上的后面位数。  

      32、在公共的集合中, 不使用的类要即使清理掉,  集合没有在方法中的话, 只要对象一直存在集合就会一直存在,  随着使用的增加, 集合中的数据也会增加

          当增加到一定程度时 , 有可能造成内存泄露隐患。

      33、如果将一个 基本数据类型转换成一个字符串, 那么  运行速度最快的是   toString()方法,  之后是 String.valueOf(), 在之后是 “” + “” 最慢

        因为String.valueOf()底层使用的是toString方法, 而 “”+底层使用的是 Stringuilder实现的。

      34、使用最有效率的方法来遍历  Map

        

    public static void main(String [] args){
             HashMap<String, String> hm = new HashMap<String, String>;
             hm.put("hehe","java");
           
             Set<Map.entry<String,String>> entrySet = hm.entrySet();
             Iterator it = entrySet.iterator();       
    
             while(it.hasNext()){
                     ......
    
             }      
    
    }        

        如果只想遍历 key的话,   使用 keySet就好了

      35、对资源的  close 应当分开进行:   因为一个 close 操作的时要 使用try catch 语句进行异常处理,   如果有多个close,  当一个出现了异常

          那么他后面的 close就能操作了。

      36、在使用  ThreadLocal 的时候,   在使用前 和使用后都要进行  remove  操作。

          因为在使用 线程池的时候, 当一个线程使用结束之后,  会将其放入线程池中,而不会将其 销毁, 我们拿到一个线程之后, 很可能

          拿到其上绑定的其它数据,  由此造成的异常非常难以查明。

      37、应当使用 常量的定义来代替魔鬼数字(没有具体含义的数字 和 字符串), 会极大地提高可阅读性。

      38、在long 或者 Long 类型赋值的时候 应当使用  L 而不是 l,    因为 l 易于 1 混淆。

      39、所有重写的方法都应当 保留  @Override 注解

          一是这样可以  知道这个放法是个重写方法,

          二是能够判断你的重写是否有语法错误

          三是在抽像类 或者 接口中进行 签名修改的时候,   继承类中会出现异常, 容易定义到具体的类。

      40、在循环 中  不要使用  +  进行字符串的拼接,   直接使用 StringBuilder 的 apperd方法进行拼接。 

           前面提到过  +  操作底层使用的是 SringBuilder 进行的,  这样就会生成 循环次数 个 StringBuilder

      41、推荐使用  jdk7 中提供的  行的   Objects  类进行equals比较, 直接使用 equals 有空指针危险。

      42、不要使用多线程对 一个 Random对象进行操作,  虽然没有线程安全问题, 但是会降低性能,推荐使用 ThreadLocalRandom

      43、 静态类 、单例类 、 工厂类 的构造器使用  private  

     

     

     

     

     

     

     

     

     

     

     

      

    转载于:https://www.cnblogs.com/soficircle/p/8681314.html

    展开全文
  • 优化代码的目的分类

    2010-09-10 15:14:20
    把可能在多处使用的代码写在一个公用方法里,好处有2个:避免大段重复;代码变化时只需修改1处。 3、解耦。划清功能模块,各自独立。反面例子:一个类包含了2个功能毫无联系方法m1,m2,分属于两个功能模块A...
    偶然的想法,还请拍砖。
    1、易读。就这么简单,最原始的需求。有些时候实在找不出把一段代码分出去一部份的理由,这就是最合适的解释。
    2、复用。把可能在多处使用的代码写在一个公用的方法里,好处有2个:避免大段的重复;代码变化时只需修改1处。
    3、解耦。划清功能模块,各自独立。反面例子:一个类包含了2个功能毫无联系的方法m1,m2,分属于两个功能模块A、B,由于A模块的变更使其修改了m1;同时B模块的变更使得m2方法也产生了改变;待到发布版本更新包时,只要发布了A模块,就必须发布该类,致使B模块所有使用了m2的类也要跟着一起发布,A和B紧紧地粘在一起,分不开了,这时就很郁闷了。解耦在此处就是把m1、m2分开,让它们按功能属于2个不同的类,A和B就都自由了。
    4、时间不多了,想起来再说。
    展开全文
  • 首先,代码优化的目的: 1.减小代码的体积;2.提高代码运行效率。 优化总结: (1)尽量指定类、方法的final修饰符 1.带有final修饰符的类是不可派生的。final修饰的类不可被继承,fianl修饰的方法不可被重写。 2....
  • JAVA代码优化

    2018-09-03 15:41:20
    可供程序利用的资源(内存、CPU时间、网络带宽等)是有限的,优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容:减小代码的体积,提高代码的运行效率。本文讨论的主要是如何提高代码...
  • gcc代码优化

    2016-11-03 20:41:14
    gcc提供的代码优化功能非常强大,它通过编译选项-On(其中n是代表优化级别整数)来控制优化代码生成。 对于不同版本gcc来讲,n取值范围及其对应优化效果可能并不完全相同,比较典型范围是从0变化到2或3...
  • Java代码优化

    2010-05-19 14:20:00
    可供程序利用的资源(内存、CPU时间、网络带宽等)是有限的,优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容:减小代码的体积,提高代码的运行效率。本文讨论的主要是如何提高代码...
  • 原文:4 More Techniques for Writing Better Java 作者:Justin Albano 翻译:Vincent 本文我们将介绍一些有助于解决常见问题通用设计策略和目标实现技术,... 只做有目的的优化 常量尽量使用枚举(后续补...
  • 编译原理之代码优化

    2020-04-07 11:52:20
    代码优化的分类: 机器无关优化 :针对中间代码 机器相关优化 :针对目标代码 局部代码优化 :单个基本块范围内的优化 全局代码优化 :面向多项基本块的优化 优化和变形的目的: 为改进代码所进行的等价程序变换...
  • 网站代码优化的目的: 1、利用权重代码优化关键词 2、利用搜索引擎不认识、不爬取的代码屏蔽网站内容 3、精简网站代码 已、iframe: 特点:搜索引擎不识别 利用iframe标记屏蔽广告,可以实现展现、引流但不输出权重...
  • Java代码优化的一些方法(总结)

    千次阅读 2018-10-10 11:11:30
    代码优化目的有两个,第一个就是为了让我们代码体积尽可能变小,看起来比较清晰,第二个就是为了提高代码运行效率。个人觉得,在平时编写代码同时,尽量要求自己,养成良好编码习惯,一个小优化点,积攒起来...
  • 优化是一个非常大的主题,本文并不是去深入探讨性能分析理论,算法的效率,况且我也没有这个能力。我只是想把一些可以简单的应用到你的C++代码中的优化技术总结在这里,这样,当你遇到几种...这也是本文的目的之所在。
  • 有很多新手Java程序员想知道代码优化的方法有哪些,还有很多想要转行学Java的同学想知道2020年学Java就业前景如何,接下来就给大家简单分析一下。Java代码优化的方法有哪些?1)尽量指定类、方法的final修饰符。带有...
  • PHP优化的目的是花最少的代价换来最快的运行速度与最容易维护的代码。给大家提供下面这些优化技巧: 1.echo比print快。 2.使用echo的多重参数代替字符串连接。 3.在执行for循环之前确定最大循环数,不要每循环一...
  • java 代码优化

    2015-04-08 22:39:00
    可供程序利用的资源(内存、CPU时间、网络带宽等)是有限的,优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容:减小代码的体积,提高代码的运行效率。 本文讨论的主要是如何提高...
  • C++代码优化

    2014-01-27 10:18:29
    C++代码优化方法总结    优化是一个非常大主题,本文并不是去深入探讨性能分析理论,算法效率,况且我也没有这个能力。我只是想把一些可以简单应用到你C++代码中优化技术总结在这里,这样,当你遇到几...
  • Javascript代码优化大全

    2021-04-14 13:20:43
    在学习JavaScript代码优化之前,我们先应该知道JavaScript语言的特性: JavaScript中的内存管理自动完成 执行引擎会使用不用的GC算法 算法工作的目的是为了实现内存空间良性循环 Performance工具检测内存变化 ...
  • 关于Java代码优化

    2019-01-15 09:10:14
    可供程序利用的资源(内存、CPU时间、网络带宽等)是有限的,优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容:减小代码的体积,提高代码的运行效率。 本文讨论的主要是如何提高...
  • 前端代码优化

    2018-05-27 08:30:38
    【】数据交互时数据量的合理安排 并不是收越少越好,而是按照数据量,流量和服务器性能计算出最...包括js,css等这些脚本文件,尽量做文件合并,合并的目的是减少http请求,但是在合并和通用之间做合理安排 【】使用...
  • java代码优化大全

    2011-06-01 22:49:13
    可供程序利用的资源(内存、CPU时间、网络带宽等)是有限的,优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容:减小代码的体积,提高代码的运行效率。本文讨论的主要是如何提高代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,736
精华内容 1,494
关键字:

代码优化的目的