Verifica dell'esistenza di un campo in un entity_metadata_wrapper

Sto analizzando una raccolta di campi e avvolgendo gli elementi della raccolta di campi con entity_metadata_wrapper. Vorrei verificare l'esistenza del campo prima di chiamare il suo valuemetodo (che si traduce in un errore su campi che non hanno un valore), ma non riesco a trovare un modo per farlo.

$field_collection_item = field_collection_item_load($id);
$item_wrapper = entity_metadata_wrapper('field_collection_item', $field_collection_item);

// this results in an error if the field_contrib_headshot field is empty
$headshot = $item_wrapper->field_contributor->field_contrib_headshot->value();

La mia attuale soluzione alternativa è utilizzare field_get_itemsper vedere se il campo è vuoto, ma mi piacerebbe poterlo fare attraverso il wrapper dei metadati, se possibile.

Chiama semplicemente la funzione PHP isset():

$headshot = array();
if (isset($item_wrapper->field_contributor->field_contrib_headshot)) {
  $headshot = $item_wrapper->field_contributor->field_contrib_headshot->value();
}

EntityStructureWrapper implementa la __isset()funzione secondo il principio del sovraccarico .

Ogni volta che c'è un riferimento di entità o una raccolta di campi, isset () non ha mai funzionato per me. Cosa sembra funzionare ogni volta che abbiamo un riferimento a un'entità:

if($wrapped_entity->entity_reference_field->getIdentifier()) {
  // This code only fires if there is an entity reference or field collection set.
}

Sembra che tu abbia da entity_referencequalche parte lì dentro a causa del metodo incatenato. Ma guarda il metodo __isset () per EntityStructureWrapper .

Controlla come:

$has_headshot = $item_wrapper->field_contributor->__isset('field_contrib_headshot');

e poi usa un IFblocco per fare la tua logica ...

MODIFICARE:

$has_headshot ora è valido il controllo desiderato.

$wrapper = entity_metadata_wrapper('node', 123);
if($wrapper->__isset('field_middle_name')) {
    // Do something awesome with the middle name.
} else {
    // Don't do anything awesome, they don't have a middle name.
}

Campi di riferimento entità e raccolte di campi

// also check if there is an identifier, __isset alone is not enough!
if ($wrapper->__isset('field_project_number') && $wrapper->field_project_number->getIdentifier()) {
    $number =  $wrapper->field_project_number->field_project_number_complete->value();
    return $number;
}

Copiato e incollato direttamente da http://dropbucket.org/node/1201 ma sembra essere un esempio migliore di qualsiasi altra risposta finora ...

Per EntityMetadataWrapper:

Se hai blocchi di codice in esecuzione che non dovrebbero o se hai riscontrato errori PHP, guarda alcuni degli esempi seguenti. In questo esempio viene utilizzata la proprietà nid.

PU ALL TUTTO L'ERRORE

if ($wrapper->__isset('nid')) {
  $var = $wrapper->nid->value();
}
else {
  // Do something it's FALSE;
}

O

if ($wrapper->__isset('nid')) {
  $var = $wrapper->nid->getIdentifier();
}
else {
  // Do something it's FALSE;
}

O

if ($wrapper->nid->value()) {
  // Do something it's TRUE.
}
else {
  // Do something it's FALSE;
}

Potresti scoprire che l'utilizzo di isset in questo modo potrebbe valutare true anche se il nid non è presente. -> getIdentifier () o -> value () o -> raw () possono generare eccezioni.

PROBABILMENTE SEMPRE VERO

if (isset($wrapper->nid)) {
  // Do something it must be TRUE....Ah Hem wait.. this runs every time.
}

UTILIZZARE QUESTO INSTEAD

try {
  $var = $wrapper->nid->raw();
} 
catch (EntityMetadataWrapperException $e) {
  $var = FALSE;
}

Ho scoperto che isset () non può essere utilizzato sul risultato di una chiamata di funzione. Dato che viene restituito un valore booleano con la seguente istruzione, sono stato in grado di verificare che l'elemento wrapped, in effetti, avesse un valore.

if ( $wrapper->field_media_alternate[0]->value() ) {
  //...valid logic...
} else {
  //...not valid logic...
}

Le persone spesso sbagliano. Quando chiami isset su un wrapper di metadati di entità, stai verificando se il bundle di entità supporta quella proprietà. Non ha nulla a che fare con il valore reale del campo.

Non esiste davvero un metodo indipendente per verificare se è impostato un valore. Devi solo valutare value () o, preferibilmente, raw (). (Puoi anche chiamare count () se è un campo multi-valore, ma raw () restituirà un array vuoto quindi non è effettivamente richiesto.)

$w = entity_metadata_wrapper('node', $nid);
//Start by checking whether the node bundle supports field_entityref_myfield.
if (isset($w->field_entityref_myfield)) {
  //If we called value(), then that would cause the referenced entity
  //to be loaded, whereas raw() just gives us the entity_id if the value
  //is set, and Null if it isn't.
  if ($w->field_entityref_myfield->raw()) {
    //Do some things based on the entity-reference being set.
  } else {
    //Do some other things based on the entity-reference NOT being set.
  }
}

Per ribadire, raw () è il valore che dovresti usare per verificare se esiste un campo. È affidabile e computazionalmente economico.

Ecco la mia funzione di aiuto personale per ottenere un valore da una catena di riferimenti di entità potenzialmente non impostata:

function _get_wrapped_value_ifset($wentity, $field_chain){
  $root = $wentity;
  try{
    foreach ( $field_chain as $field_name ) {
      $root = $root->{$field_name};
    }
    return $root->value();
  }
  catch (EntityMetadataWrapperException $e){
    return null;
  }
}

$ wentity è l'entità spostata, $ field_chain è una matrice di field_names in questo modo:

[
  'field_reference_from_the_wentity',
  'field_wanted_field_from_the_referenced_entity'
] 

puoi anche fare:

[
  'field_reference_from_the_wentity', 
  'field_reference_from_the_referenced_entity',
  ... 
  'field_wanted_field_from_the_N_referenced_entity'
]

funzionerà!