What do you think is better? global or $GLOBALS

[davidjam]

This may be a matter of opinion or some may have actually benchmarked this. Which do you think is faster? Well actually, I should say, "better" because there may be reasons why the slower of the two is still better to use...

1. global

$var = "hello";
function test() {
     global $var;
     return($var);
}
print test();

2. $GLOBALS

$var = "hello";
function test() {
     return($GLOBALS['var']);
}
print test();

I'm sure the speed difference in this example is extremely slight, but I will be using it in a loop so the difference may become noticeable.

[AstroTeg]

You really shouldn't be using global variables at all. They can cause security issues. More likely they'll cause bugs to crop up. The best practice would be to do:

function test($var) {
     return($var);
}

$var = "hello";
print test($var);

[davidjam]

Thanks astro, I know you're right and I have been advised that before. But here is the structure I am building:

I have multiple objects that represent form elements (field, popup, etc). On refresh I want to validate the form, so I call a validator function/class to do the job. Within that class there is likely going to be some loops that traverse the list of form elements (an array called $elements) one by one and check them for various conditions (i.e. some value (required), or $this depends upon $that, or regex emails, etc). Presently all I can think to do is globalize each object one at a time to verify its contents are valid.

What do you think of this? Is there a better way?

[Weedpacket]

Maybe attach the validation methods to the field objects themselves, so that you can go

foreach($this->fields as $field) // $this is the form.
{
    $field->validate();
}

(modulo whatever you're wanting to do with the results of the validation)?

[Shrike]

The Strategy design pattern applied to form validation 🙂

abstract class Validate
{
  private $err;
  abstract function validate($input);
  protected function add($err)
  {
    $this->err = $err;
  }
  public function get()
  {
    return $this->err;
  }
  public function valid()
  {
    empty($this->err) ? return true : return false;
  }
}
class EmptyValidator extends Validator
{
  function __construct($input)
  {
    $this->validate($input);
  }
  private function validate($input)
  {
    empty($input) ? $this->add("Field is required") : return false;
  }
}
$validators[] = new EmptyValidator($_POST['field']);
$validators[] = new EmptyValidator($_POST['field2']);
foreach($validators as $v)
{
  if(!$v->valid())
  {
    echo $v->get();
  }
}

[davidjam]

Thank you weedpacket. That was a very good suggestion. Also, shrike, I appreciate the code. But I can think of 4 things off the top that these approaches will not accomplish, at least not "as is".

My day job is damn typesetter :glare: and I just got a job to set some technical/safety document in English and Spanish, so I am out of the loop for a while.

Thanks again. 🙂