Test and echo without repetition?

Question

This is a minor thing, but it's been bugging me for a while. I've wracked my brain for a way to write statements like this without any repetition of code. For example:

echo isset($array[0])? $array[0]: 'not set';
$var = empty($other_var)? '$other_var not set': $other_var;

Is there some sort of test-and-return (for the former) or test-and-set (for the latter) operator I don't know about? This may seem like a minor point, but the duplication seems unnecessary and can lead to very long lines that can complicate maintenance. Consider:

$another_var = array_key_exists($array[Utility::FindIndex($username)][Constants::App_CRITERION], $haystack[NthDimension('my dimensional indicator')])? $array[Utility::FindIndex($username)][Constants::App_CRITERION], $haystack[NthDimension('my dimensional indicator')]: 'not set';

Yes, yes, the above line is totally contrived but it's not unthinkable that something like this could occur. It just seems strange to me that there isn't a way to test something and assign it's value (if true) without repetition without repetition.

Answer 1

I think in PHP 6 there was a function planned called issetor or something similar. But I can't remember the name. And PHP 6 is dead either way.

So, write it yourself:

function issetor(&$var, $default) {
    return isset($var) ? $var : $default;
}

echo issetor($_GET['me'], 'you');

If you want to make it even more abstract, look at this:

function isor(&$var, $default, $condition) {
    if (!is_callable($condition)) {
        throw new InvalidArgumentExpression('condition not callable!');
    }

    return $condition($var) ? $var : $default;
}

// this is equivalent to issetor($_GET['me'], 'you');
echo isor($_GET['me'], 'you', function(&$var) { return isset($var); });

// but you may use a more complicated thing here, too:
echo isor($_GET['me'], 'you', function($var) use($allowed) { return in_array($var, $allowed); });
// this is equivalent to:
echo in_array($_GET['me'], $allowed) ? $_GET['me'] : 'you';
// now the "normal" version is still shorter. But using isor allows you to store often used $condition closures in variables. For example, if you want to check if several values are in an array, you could write:
$isAllowed = function ($var) use ($allowed) {
    return in_array($var, $allowed);
};
$a = isor($a, 'default', $inAllowed);
$b = isor($b, 'default', $inAllowed);
$c = isor($c, 'default', $inAllowed);
$d = isor($d, 'default', $inAllowed);

If you want to pass additional variables to your condition function without always useing closures you may add another argument. (Note I didn't use an argument array and call_user_func_array, because you may not pass per reference using it, but obviously you may extend the code so it does so.)

function isor(&$var, $default, $condition, $addArgument = null) {
    if (!is_callable($condition)) {
        throw new InvalidArgumentExpression('condition not callable!');
    }

    return $condition($var, $addArgument) ? $var : $default;
}

// the above in_array condition:
echo isor($a, 'default', 'in_array', $allowed);

Answer 2

It won't handle the isset () case, which is a main use case for this pattern, but PHP 5.3 does have a short form for the ternary operator.

$new_val = $if_true ? $if_true : $if_false;

can be shortened to

$new_val = $if_true ?: $if_false;

I couldn't find it in the docs, strangely, but here's a question about it: http://stackoverflow.com/questions/2153180/what-is-in-php-5-3