Can PHP dissect its own syntax?

Can PHP dissect its own syntax? For example, I'd like to write a function that takes in an input like $object->attribute and says to itself:

OK, he's giving me $foo->bar, which means he must think that $foo is an object that has a property called bar. Before I try accessing bar and potentially get a 'Trying to get property of non-object' error, l开发者_运维百科et me check whether $foo is even an object.

The end goal is to echo a value if it is set, and fail silently if not.

I want to avoid repetition like this:

<input value="<? if(is_object($foo) && is_set($foo->bar)){ echo $foo->bar; }?> "/>

...and to avoid writing a function that does the above, but has to have the object and attribute passed in separately, like this:

<input value="<? echoAttribute($foo,'bar') ?>" />

...but to instead write something which:

• preserves the object->attribute syntax
• is flexible: can also handle array keys or regular variables

Like this:

<input value="<? echoIfSet($foo->bar); ?> />
<input value="<? echoIfSet($baz['buzz']); ?> />
<input value="<? echoIfSet($moo); ?> />

But this all depends on PHP being able to tell me "what kind of thing am I asking for when I say $object->attribute or $array[$key]", so that my function can handle each according to its own type.

Is this possible?

Update

I got some good answers here and did some experimenting. Wanted to summarize.

• The answer to my original question appears to be "no," but we did find a way to accomplish was I was trying to do. Techpriester pointed out that I could pass the string '$foo->bar' to a function and have it parse that and eval() it. Not the approach I want to take, but deserves a mention.
• Peter Bailey pointed out that something like $foo->bar gets evaluated before getting passed to a function. I should have thought of this, but for some reason didn't. Thanks, Peter!
• Will Vousden showed that passing $foo->$bar by reference allows the function to evaluate it, rather than having it evaluated beforehand. His function shows that isset($foo->bar) will not complain if $foo is not an object, which I didn't know.

More interestingly, his example seems to imply that PHP waits to evaluate a variable until it absolutely has to.

If you're passing something by value, then of course PHP has to determine the value right then. Like this:

$foo->bar = 'hi';
somefunction($foo->bar); // same as somefunction('hi');

But if you're passing by reference, it can wait to determine the value when it actually needs to.

Like this (following the order in which things happen):

echo ifSet($foo->bar); // PHP has not yet evaluated $foo->bar...
function ifSet(&$somevar){ // ...because we're passing by reference (&$somevar)
  // Now we're inside the function, but it still hasn't evaluated $foo->bar; it 
  // just made its local variable, $somevar, point to the same thing as $foo->bar
  if(isset($somevar)){ // Right HERE is where it's evaluated - when we need it
    return $bar;
  }
}

Thanks to everyone who responded! If I've misstated something, please let me know.

---

You can pass it by reference:

<?php

function foo(&$bar)
{
    if (isset($bar))
    {
        echo "$bar\r\n";
    }
    else
    {
        echo "It's not set!\r\n";
    }
}

$baz = new stdClass;
$baz->test = 'test';
foo($baz->test);
foo($baz->test2);

$baz = array();
foo($baz['test3']);

?>

Note that this won't work if you try to access an object as an array or vice versa.

You shouldn't try to rely on something like this too much, though.

---

maybe in this very specific case you could use the @ symbol:

<input value="<?php echo @$foo->bar; ?> "/>

---

The reason you'll never be able to do something like this

echoIfSet($foo->bar);

Is because $foo->bar is evaluated before its sent to the function. If that value is a string, all echoIfSet() will see is a string - it has no idea that the string came from the property of an object.

So, no, in a word. PHP can't "dissect its own syntax"

Every option you have (using __get()/__set() or Reflection) involves more code and work than what you're trying to avoid - and they still don't get you exactly what you want.

---

Wrapping your array's and objects in a special array. you can acces the properties using php's magic methods.

class wrap implements ArrayAccess{
  private $fields=array();
  function __get($name){
    if(isset($this->fields[$name])){
      return $this->fields[$name];
    }
  }
  function __set($name, $value){
    $this->fields[$name] = $value;
  }
  // with function isset()
  public function offsetExists($offset) {
    return isset($this->$fields[$offset]);
  }

  public function offsetGet($offset) {
    return $this->$fields[$offset];
  }

  public function offsetSet($offset, $value) {
    return $this->$fields[$offset] = $value;
  }

  public function offsetUnset($offset) {
    unset($this->$fields[$offset]);
  }
}

this wil allow you to do all things you wanted.

---

There is a language feature that will execute any PHP code that you pass it as a string : eval().

But you really, really (as in "I'm dead serious"), should not use it. It causes much more problems than it solves and makes your code unmaintainable.

There's usually a better and cleaner way.

"eval()" leads to the dark side of the force, err I mean, of PHP.

If you just want the "obj" and "attribute" part of the supplied string, regular expression could do that. It'll be something like "/\$(\w+)->(\w+)/". You can feed this to preg_match() and it will give you the string components.

---

Are you just looking for the eval statement?

---

If you are looking for something that gives you the name of the variable you passed in, as in:

function foo($variable)
{
    echo variableName($variable);
}

$test = "Hello World";
// echoes "test"
foo($test);

Then you are not going to find it. PHP doesn't have such a feature.