Dynamique des Opérateurs de Comparaison dans PHP

Est-il possible, de toute façon, pour passer des opérateurs de comparaison que les variables d'une fonction? Je suis à la recherche à la production de certaines fonctions de confort, par exemple (et je sais que cela ne fonctionnera pas):

function isAnd($var, $value, $operator = '==')
{
    if(isset($var) && $var $operator $value)
        return true;
}

if(isAnd(1, 1, '===')) echo 'worked';

Merci d'avance.

Quel est l'intérêt d'une telle fonction? L'appel de la fonction est beaucoup plus long que l'opération elle-même et je ne peux pas penser à quelque chose d'utile à faire avec ça.
Vous pouvez si vous utilisez le Schéma. Il peut être un très puissant motif.

OriginalL'auteur BenTheDesigner | 2010-05-27

  1. 9

    Comment parler d'une petite classe:

    class compare
{
  function is($op1,$op2,$c)
  {
     $meth = array('===' => 'type_equal', '<' => 'less_than');
     if($method = $meth[$c]) {
        return $this->$method($op1,$op2);
     }
     return null; //or throw excp.
  }
  function type_equal($op1,$op2)
  {
      return $op1 === $op2;
  }
  function less_than($op1,$op2)
  {
      return $op1 < $op2;
  }
}
    Je ne pensais même pas à l'aide d'une classe, trop tôt dans la matinée, peut-être? Merci.
    Pourquoi a-t-il besoin d'être une classe?
    Avant 5.3 c'est le meilleur choix, avec des espaces de noms et de vrais rappels d'autres bonnes solutions sont possibles. Mais une classe est probablement le plus simple.
    Il faut un certain temps pour comprendre votre question. Vous avez raison, une classe n'est pas obligatoire, mais c'est une pratique courante en PHP.
    Très motivantes pour faire une comparaison de la classe! Résolu mon problème ! La question ressemble à mon problème. Très pratique ! +1

    OriginalL'auteur giftnuss

  2. 26

    Vous pouvez également utiliser version_compare() fonction, vous pouvez passer de l'opérateur qui sera utilisé pour la comparaison comme troisième argument.

    genius. +1 c'est plutôt une solution créative et fonctionne très bien pour les comparaisons.
    Voici l'exemple, if (version_compare(5.9, 6,'<=')) echo TRUE; // returns 1
    J'étais en fait la création d'une version de comparer la fonction de mon propre parce que je ne savais pas PHP a cette fonction, génial!

    OriginalL'auteur alokin

  3. 13

    Comment à ce sujet?

    function num_cond ($var1, $op, $var2) {

    switch ($op) {
        case "=":  return $var1 == $var2;
        case "!=": return $var1 != $var2;
        case ">=": return $var1 >= $var2;
        case "<=": return $var1 <= $var2;
        case ">":  return $var1 >  $var2;
        case "<":  return $var1 <  $var2;
    default:       return true;
    }   
}

    Test:

    $ops = array( "=", "!=", ">=", "<=", ">", "<" );
$v1 = 1; $v2 = 5;

foreach ($ops as $op) {
    if (num_cond($v1, $op, $v2)) echo "True  ($v1 $op $v2)\n"; else echo "False ($v1 $op $v2)\n";
}
    vous devez inclure d'entrée/sortie dans votre test.
    c'est une très bonne idée, j'ai utilisé celui-ci dans mon code.merci
    Meilleure réponse. Merci!

    OriginalL'auteur Goran

  4. 3

    Le plus gros problème est que cette fonction est assez inutile. Nous allons remplacer un véritable (à titre d'hypothèse de travail) exemple:

    function isAnd($var, $value, $operator = '==') {
    return isset($var) && $var $operator $value;
}

isAnd($foo, 1, '===');

    Dans cet exemple $foo n'est pas définie. Vous recevrez un message d'erreur parce que vous essayez de passer un inexistante variable ($foo) à une fonction (isAnd). Ainsi, vous aurez besoin de tester $foo pour isset avant appel isAnd:

    isset($foo) && isAnd($foo, 1, '===');

    Toute variable qui n'entre dans la isAnd fonction est établi définitivement. Vous n'avez pas besoin de test pour l'intérieur de la fonction. Ainsi, l'ensemble de l'exercice est assez inutile.

    Ce qui peut être déroutant, c'est que isset() et empty() n'ont pas cette limitation, c'est à dire que vous pouvez passer d'un inexistante variable sans erreur. La chose est cependant, ce ne sont pas des fonctions normales, ils sont spéciaux constructions de langage (qui ressemblent à des fonctions; le blâme PHP). Malheureusement vous ne peut pas faire de ces sortes de constructions, les paramètres de vos fonctions toujours besoin d'exister.

    Vous faut juste s'habituer à l'écriture isset($foo) && $foo === 1. Avec le bon code structuré, vous pouvez réduire ce risque au minimum par toujours déclarer toutes les variables que vous allez l'utiliser, ce qui est bien pratique quand même.

    Pour la dynamique de l'opérateur... vous aurez besoin d'une certaine forme de if ... else quelque part pour décider quel opérateur à utiliser de toute façon. Au lieu de définir l'opérateur variable, puis d'évaluer, n'est-il pas plus facile de faire l'évaluation de la juste là?

    Également voir stackoverflow.com/questions/1960509/...

    OriginalL'auteur deceze

  5. 2

    Si vous ne pouvez vous insistez, vous pouvez utiliser la fonction eval.

    if(isset($var) && eval("return $var $operator $value"))
    return true;

    Mais je ne le recommande pas.

    +1 mais une explication de pourquoi vous ne le recommande pas, il peut être utile pour les lecteurs

    OriginalL'auteur Michael Krelin - hacker

  6. 2

    La réponse sommet recommande une petite classe, mais j'ai comme un trait.

    trait DynamicComparisons{

private $operatorToMethodTranslation = [
    '=='  => 'equal',
    '===' => 'totallyEqual',
    '!='  => 'notEqual',
    '>'   => 'greaterThan',
    '<'   => 'lessThan',
];

protected function is($value_a, $operation, $value_b){

    if($method = $this->operatorToMethodTranslation[$operation]){
        return $this->$method($value_a, $value_b);
    }

    throw new \Exception('Unknown Dynamic Operator.');
}

private function equal($value_a, $value_b){
    return $value_a == $value_b;
}

private function totallyEqual($value_a, $value_b){
    return $value_a === $value_b;
}

private function notEqual($value_a, $value_b){
    return $value_a != $value_b;
}

private function greaterThan($value_a, $value_b){
    return $value_a > $value_b;
}

private function lessThan($value_a, $value_b){
    return $value_a < $value_b;
}

private function greaterThanOrEqual($value_a, $value_b){
    return $value_a >= $value_b;
}

private function lessThanOrEqual($value_a, $value_b){
    return $value_a <= $value_b;
}

}

    OriginalL'auteur Tarek Adam

  7. 1

    Que Michael Krelin suggère que vous pourriez utiliser eval - mais qui permet potentiellement beaucoup de code des attaques par injection.

    Vous ne pouvez pas substituer une variable par un opérateur - mais vous pouvez remplacer une variable par une fonction:

    function is_equal($a, $b) {
  return $a==$b;
} 
function is_same($a, $b) {
  return $a===$b;
}
function is_greater_than($a, $b)
....

$compare='is_equal';
if ($compare($a, $b)) {
   ....

    C.

    OriginalL'auteur symcbean

  8. 0

    Autant que je sache, il n'est pas possible et qu'il n'existe pas de référence à propos de rappel sur les opérateurs dans la documentation de PHP,
    http://www.php.net/manual/en/language.operators.php

    au lieu d'utiliser eval, je voudrais redéfinir chacun des opérateurs dans les fonctions globales et les utiliser php rappels
    Comment puis-je mettre en œuvre un rappel en PHP?

    OriginalL'auteur snowflake

  9. -3

    Non, c'est impossible.
    Vous pouvez utilisez les opérateurs conditionnels à la place, mais il sera beaucoup,beaucoup mieux si vous refonte de votre application pour faire une telle comparaison dynamique inutiles.

    OriginalL'auteur Your Common Sense