PHP在程序编程中避免全局变量

I normally use procedural programming with PHP and looking at other questions here asking how to avoid globals the answers were often to use OOP instead. Is it not possible to avoid globals with procedural programming?

For example I can write the following function in two ways. Both have advantages and disadvantages. If I call this function often then it looks bloated with the second method since it has to pass all the variables each time. The alternative is the first method where the function simply passes the value and the variables are all globals in the function.

doWhatIneedtodo(2);

function doWhatIneedtodo($val) {
  global $this; global $that; global $theother;
  if ($val == 1) { 
    $this++;
  } else
  if ($val == 2) { 
    $that++;
  } else
  if ($val == 3) { 
    $theother++;
  }
}

doWhatIneedtodo(2,$this,$that,$theother);

function doWhatIneedtodo($val,&$this,&$that,&$theother) {
  if ($val == 1) { 
    $this++;
  } else
  if ($val == 2) { 
    $that++;
  } else
  if ($val == 3) { 
    $theother++;
  }
}

Or perhaps there's a better way to do this that I haven't though of?

The reason you mostly find answers regarding this question for OOP is twofold I think:

• Everybody does PHP OOP these days, it's really worth it.
• In OOP globals are bad as you want to avoid global state. Introducing global state results in code that's harder to test and to maintain. In procedural PHP everything is global anyways so there's much less need to avoid globals.

Apart from that, my preference goes to your second implementation because it would be far more easy to transition this into proper OOP code. If you use the first implementation and you'd want to change the names of the variables, you'd have to adjust the calling code and the function itself.

It's very much a progression from troublesome code to less troublesome code:

• Purely procedural code without using functions: almost impossible to reuse or modularise, quickly leads to name clashes and spaghetti code in any decent-sized program.
• Procedural code using functions: some namespacing/scoping for some variables, though eventually still the same issues as above if you use globals.
• Procedural code with functions and without globals, veering towards functional programming: no name clashes, great reusability, but a lot of passing around of individual values.
• In other languages this is where structs would come in to define structured "bundles" of values to pass around between functions, but since PHP is lacking structs you'd be using arrays, which are tedious because they are entirely unstructured and untyped and it becomes difficult to keep their structure straight in the long run.
• So then objects enter the picture, which provide data structures.
• And while you're using objects anyway, you may as well go for encapsulation and let object methods act on their own data, hiding the internal data structure and instead exposing functionality (methods), so the underlying data structures can be changed and that change is localised to the class itself, instead of all the functions that consume a certain struct/array.

So you see, solving problems with global procedural code one by one eventually leads to OOP anyway, at least in PHP. There's a fork in the road halfway through where you could go to pure functional programming as well, but PHP is ill-equipped for being a purely functional language.