PHP：为什么`global`的使用比在函数内部声明变量要慢？

Question

I have been reading PHP manual pages, but I am obviously reading the wrong ones. I ran a few simple tests to see which means of obtaining a variable was faster: using global , declaring the variable inside the function, or using a declared constant.

Summary:

1. Declaring the variable (eg, $keyspace = 012...; ) was fastest.
2. Using global (eg, global $keyspace; ).
3. Defining a constant (eg, define('keyspace', '01234...'); was slowest.

Question: Why is using global or define slower than declaring a variable in PHP?

(1) Variable defined outside function, function uses global

$keyspace = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
function buildSKU(){
        global $keyspace;
        $sku = '';
        $max = mb_strlen($keyspace, '8bit') - 1;
        for ($i = 0; $i < 8; ++$i) {
                $sku .= $keyspace[random_int(0, $max)];
        }
        return $sku;
}

(2) Variable defined inside function

function buildSKU(){
        $keyspace = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $sku = '';
        $max = mb_strlen($keyspace, '8bit') - 1;
        for ($i = 0; $i < 8; ++$i) {
                $sku .= $keyspace[random_int(0, $max)];
        }
        return $sku;
}

(3) Variable defined as a constant

define('keyspace', '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ');
function buildSKU(){
        $sku = '';
        $max = mb_strlen(keyspace, '8bit') - 1;
        for ($i = 0; $i < 8; ++$i) {
                $sku .= keyspace[random_int(0, $max)];
        }
        return $sku;
}

My test bed:

<?php

$start = microtime(true);
//Put (1) or (2) here...
for($i=0; $i<10000; $i++){ buildSKU(); }
$end = microtime(true) - $start;
echo "\n\nTime: ".$end."\nMemory:".memory_get_peak_usage(true)."\n\n";

Answer 1

Your title is a bit misleading. A function variable is not being 'declared' over and over, it was declared once when you wrote the function code. You also focused on an apples to oranges comparison.

With the function variable example, the scope of the variable is entirely different. A local variable declared inside a function ceases to exist (at least from the scope perspective) once the function completes. It's also being initialized, unlike the global example where the state of the variable at the start of the function is completely unknown.

You spent a lot of time looking at micro optimization and a meaningless benchmark, when the answer is much simpler. It is never better to use the global keyword to inject a variable into function scope.

You have parameters for doing that which can be passed by reference or value, but you did not evaluate those options, although I have to reiterate that in my opinion you aren't really going to find out anything interesting.

In most languages that create a compiled program, function variables are allocated on the stack. Once the function completes, that area of memory is popped off the stack and discarded. PHP however, has aa variable naming and memory allocation scheme that is shared across all variables and objects. You can search for information on 'php zval' and php internals, and find out more about the way variables are allocated, reference counted, and associated with names via symbol tables.

The important point to make here, is that the variable allocation occurs in the same way regardless of the type of variable it is, so any expectation about performance purely of variable allocation syntax is unlikely to provide any meaningful differences.

PHP makes all sorts of decisions in regards to when it needs to make a new zval or simply point multiple symbols at the same one, and that is meant to be transparent to you.

Answer 2

I think the main issue with global is the dependency issue, where your entire code base would be depended on that global variable and its existence, as your code grows , it is very hard to keep track and trouble shoot. Even a name change requires you change everywhere in your code.

in your code if key doesn't change maybe you should consider using constant.

Answer 3

除非绝对需要，否则请始终使用局部变量，并且别无选择。