3

所以，我有一个结构类似于下面的对象，所有这些都作为stdClass对象返回给我

$person->contact->phone;
$person->contact->email;
$person->contact->address->line_1;
$person->contact->address->line_2;
$person->dob->day;
$person->dob->month;
$person->dob->year;
$album->name;
$album->image->height;
$album->image->width;
$album->artist->name;
$album->artist->id;

等等......（注意这些例子没有链接在一起）。

是否可以使用变量变量contact->phone作为直接属性调用$person？

例如：

$property = 'contact->phone';
echo $person->$property;

这不会按原样工作并抛出 aE_NOTICE所以我正在尝试制定一种替代方法来实现这一点。

有任何想法吗？

针对与代理方法相关的答案：

除了这个对象来自一个库之外，我会使用它来使用数组映射填充一个新对象，如下所示：

array(
  'contactPhone' => 'contact->phone', 
  'contactEmail' => 'contact->email'
);

然后遍历地图以填充新对象。我想我可以代替映射器...

4

14 回答 14

4

如果我是你，我会创建一个->property();返回的简单方法$this->contact->phone

于 2011-03-21T09:41:39.600 回答
3

是否可以使用变量变量来调用联系人->电话作为 $person 的直接属性？

不能将表达式用作变量变量名。

但你总是可以作弊：

class xyz {

    function __get($name) {

        if (strpos($name, "->")) {
            foreach (explode("->", $name) as $name) {
                $var = isset($var) ? $var->$name : $this->$name;
            }
            return $var;
        }
        else return $this->$name;
    }
}
于 2011-03-21T10:04:41.770 回答
2

试试这个代码

$property = $contact->phone;
echo $person->$property;
于 2011-03-21T09:59:15.237 回答
2

我认为这是一件坏事，因为它导致不可读的代码在其他级别上也是完全错误的，但一般来说，如果您需要在对象语法中包含变量，您应该将其包装在大括号中，以便首先对其进行解析。

例如：

$property = 'contact->phone';
echo $person->{$property};

如果您需要访问名称中包含不允许字符的对象，这同样适用于 SimpleXML 对象经常发生的情况。

$xml->{a-disallowed-field}
于 2011-03-21T10:04:11.180 回答
2

如果它是合法的，并不意味着它也是道德的。这是 PHP 的主要问题，是的，你几乎可以做任何你能想到的事情，但这并不能使它正确。看看得墨忒耳定律：

得墨忒耳法则

如果你真的想试试这个： json_decode(json_encode($person),true);

您将能够将其解析为数组而不是对象，但它为获取而不是设置完成了您的工作。

编辑：

class Adapter {

  public static function adapt($data,$type) {

  $vars = get_class_vars($type);

  if(class_exists($type)) {
     $adaptedData = new $type();
  } else {
    print_R($data);
    throw new Exception("Class ".$type." does not exist for data ".$data);
  }

  $vars = array_keys($vars);

  foreach($vars as $v) {

    if($v) {        
      if(is_object($data->$v)) {
          // I store the $type inside the object
          $adaptedData->$v = Adapter::adapt($data->$v,$data->$v->type);
      } else {
          $adaptedData->$v =  $data->$v;
      }
    }
  }
  return $adaptedData;

  }

}

于 2011-03-21T10:19:02.063 回答
0

OOP 主要是为了将对象的内部与外部世界隔离开来。您在这里尝试做的是提供一种phone通过person界面公开内部信息的方法。这不好。

如果您想要一种便捷的方式来获取“所有”属性，您可能需要为此编写一组显式的便捷函数，如果您愿意，可以将其包装在另一个类中。这样您就可以改进支持的实用程序，而无需触及（并可能破坏）核心数据结构：

class conv {
 static function phone( $person ) {
   return $person->contact->phone;
 }

}

// imagine getting a Person from db
$person = getpersonfromDB();

print conv::phone( $p );

如果您需要更专业的功能，请将其添加到实用程序中。这是很好的解决方案：将便利性与核心分开以降低复杂性，并提高可维护性/可理解性。

Person另一种方法是围绕核心类“内部”构建的便利性“扩展”类：

class ConvPerson extends Person {
   function __construct( $person ) {
     Person::__construct( $person->contact, $person->name, ... );
   }
   function phone() { return $this->contact->phone; }
}

// imagine getting a Person from db
$person = getpersonfromDB();
$p=new ConvPerson( $person );
print $p->phone();
于 2011-03-21T09:54:24.887 回答
0

您可以使用类型转换将对象更改为数组。

$person = (array) $person;

echo $person['contact']['phone'];
于 2011-03-21T09:57:39.223 回答
0

在大多数情况下，您有嵌套的内部对象，这可能是重新评估您的数据结构的好时机。

在上面的例子中，person有contact和dob。联系人还包含地址。在编写复杂的数据库应用程序时，尝试从最高级别访问数据并不少见。但是，您可能会发现最好的解决方案是将数据整合到person类中，而不是试图从本质上“挖掘”到内部对象中。

于 2011-03-21T10:12:59.377 回答
0

尽管我讨厌这样说，但你可以做一个 eval ：

foreach ($properties as $property) {
     echo eval("return \$person->$property;");
}
于 2011-03-21T10:19:25.950 回答
0

除了使function getPhone(){return $this->contact->phone;}您可以创建一个可以查看请求字段的内部对象的魔术方法。请记住，魔术方法虽然有点慢。

class Person {
    private $fields = array();

    //...

    public function __get($name) {
        if (empty($this->fields)) {
            $this->fields = get_class_vars(__CLASS__);
        }
        //Cycle through properties and see if one of them contains requested field:
        foreach ($this->fields as $propName => $default) {
            if (is_object($this->$propName) && isset($this->$propName->$name)) {
                return $this->$propName->$name;
            }
        }
        return NULL;
        //Or any other error handling
    }
}
于 2011-03-21T10:19:26.450 回答
0

我决定放弃这整个方法，并采用更冗长但更清洁并且很可能更有效的方法。一开始我并不太热衷于这个想法，大多数人都在这里发表了我的想法。谢谢你的回答。

编辑：

如果你感兴趣：

public function __construct($data)
{
  $this->_raw = $data;
}

public function getContactPhone()
{
  return $this->contact->phone;
}

public function __get($name) 
{
  if (isset($this->$name)) {
    return $this->$name;
  }

  if (isset($this->_raw->$name)) {
    return $this->_raw->$name;
  }

  return null;
}
于 2011-03-21T10:36:05.600 回答
0

如果您以类似结构的方式使用您的对象，您可以显式地为所请求节点的“路径”建模。然后，您可以使用相同的检索代码“装饰”您的对象。

“仅检索”装饰代码的示例：

function retrieve( $obj, $path ) {
    $element=$obj;
    foreach( $path as $step ) { 
       $element=$element[$step];
    }
    return $element;
}

function decorate( $decos, &$object ) {
   foreach( $decos as $name=>$path ) {
      $object[$name]=retrieve($object,$path);
   }
}

$o=array( 
  "id"=>array("name"=>"Ben","surname"=>"Taylor"),
  "contact"=>array( "phone"=>"0101010" )
);

$decorations=array(
  "phone"=>array("contact","phone"),
  "name"=>array("id","name")  
);

// this is where the action is
decorate( $decorations, &$o);
print $o->name;
print $o->phone;

（在键盘上找到它）

于 2011-03-21T10:46:16.743 回答
0

如果您知道这两个函数的名称，您可以这样做吗？（未测试）

$a = [
    'contactPhone' => 'contact->phone', 
    'contactEmail' => 'contact->email'
];

foreach ($a as $name => $chain) {
    $std = new stdClass();
    list($f1, $f2) = explode('->', $chain);
    echo $std->{$f1}()->{$f2}(); // This works
}

如果它不总是两个功能，你可以更多地破解它以使其工作。重点是，只要使用括号格式，就可以使用变量变量调用链式函数。

于 2016-08-16T20:49:28.377 回答
-1

我所知道的最简单和最干净的方式。

function getValueByPath($obj,$path) {
    return eval('return $obj->'.$path.';');
}

用法

echo getValueByPath($person,'contact->email');
// Returns the value of that object path
于 2016-02-23T22:25:58.760 回答