proposed access modifier "silent" ... was: Re: Implicit isset/isempty check on short-ternary operator

If doing the suppression of undefined notices be better if the ? was put after the
opening square bracket, thereby removing the ambiguity (which I think would be
more troublesome than you think)? $array[?"foo"]

I suppose a non-array-specific version would be to put it after the $.

$?variable
$?array['foo']['bar']

I wonder if you could even use : with this syntax.

$?variable:"default"
$?array['foo']['bar']:"default"

Perhaps using it in function definitions is something to consider, too,
for a callee-specified undefined-notice-silencing mechanism.

function foo($?arg) {
}

Doesn't work for the variable arguments case, though, without resorting
to something IMHO ugly/hard-to-read-and-understand like:

function foo(?) {
}

It's another idea to throw in the mix, though.

I do think the 'silent' modifier that was the original suggestion in
this thread is worth further thought. It may well allow userland
functions to be developed, which might be a benefit.

I personally, though, think a modified ternary operator like the
proposed ??: or the syntax above, is better.

Ben.

Hello,

On Mon, Apr 11, 2011 at 11:47 AM, Matthew Weier O'Phinney
weierophinney@php.net wrote:

I might come off rather crumudgeonly here, but these last few
threads I've seen going across to silence notices have a common
theme - "I wanna be a lazier coder."

My suggestion to use ?? I will say has little to do with laziness. I
would be happy with any solution that solves my problem, I just know
that implementing a patch for ?? would be simple enough (I could even
do so if requested). Everyone has different use patterns as shown in
other examples, this is natural and just comes with the domain.
However, you may find 415,000 reasons why this feature could be useful
for developers in [1].

I also really like the <whatevername>($foo['not exists'], $config['not
exists'], $foo, $bar, 'default') function. I personally only usually
need 1 default value but I feel like many people may find uses for
this as well.

In addition I would like to mention that the checking being "isset"
for such a feature would be a very reasonable option, seeing as empty
[2], array_key_exists [3] (7000 uses found only) etc type use cases
are probably going to be a big minority. Most of the time checks done
with empty() seem to be done on known or already isset() checked, I.E.
isset($foo['bar']) && !empty($foo['bar']) anyways.

Just some food for thought,

-Chris

[1] http://www.google.com/codesearch?hl=en&lr=&q=.*isset%28.%2B%3F%29[\s]{0%2C1}%3F&sbtn=Search
[2] http://www.google.com/codesearch?hl=en&lr=&q=file%3A.*php+.*empty%28.%2B%3F%29[\s]{0%2C1}%3F&sbtn=Search
[3] http://www.google.com/codesearch?hl=en&lr=&q=.*array_key_exists%28.%2B%3F%29[\s]{0%2C1}%3F&sbtn=Search

Something I've been doing for a long time is similar, but in my opinion a much better practice.

function coalesce(&$val, $ifnull = false)
{
return empty($val) ? $ifnull : $val;
}

Add whatever restrictive logic you wish here, if empty() isn't good enough for your purposes.

$_GET['mightnotexist'] = coalesce($_GET['mightnotexist'], 'default');

Personally, I think if you're writing your code where a variable's existence is ambiguous, you should be seeing notices.

I'm not arguing whether the following code fragment is good
or bad (it's certainly less than ideal), but given the recent
threads, I thought I'd show how I feel I've been encourage by
php to code:

<?php
$x = array();
$y = 'something';
$temp =& $x[$y];
$temp++;
unset($temp);
?>

I'm not sure where (if anywhere) that technique is documented
or even if it should be documented, but if you want to avoid
"Undefined index" notices, that's one of the more terse
approaches. The relative brevity is more obvious when the
variable names are long and $temp is re-linked several times
before unsetting. It's probably less clear than alternatives
unless you see it often.

Here is an application to the defaults for configurations thread:

<?php
$config = array();
$param = 'param1';
$temp =& $config[$param];
$temp = $temp ?: 'default';
unset($temp);
var_dump($config);
?>

It isn't beautiful, but it avoids writing "$config[$param]"
more than once and it avoids the notices.

• Todd

I'm not arguing whether the following code fragment is good
or bad (it's certainly less than ideal), but given the recent
threads, I thought I'd show how I feel I've been encourage by
php to code:

<?php
$x = array();
$y = 'something';
$temp =& $x[$y];
$temp++;
unset($temp);
?>

I'm not sure where (if anywhere) that technique is documented
or even if it should be documented, but if you want to avoid
"Undefined index" notices, that's one of the more terse
approaches. The relative brevity is more obvious when the
variable names are long and $temp is re-linked several times
before unsetting. It's probably less clear than alternatives
unless you see it often.

Here is an application to the defaults for configurations thread:

<?php
$config = array();
$param = 'param1';
$temp =& $config[$param];
$temp = $temp ?: 'default';
unset($temp);
var_dump($config);
?>

It isn't beautiful, but it avoids writing "$config[$param]"
more than once and it avoids the notices.

I believe that using + for configuration settings makes much more sense:

$defaults = array('foo' => 'bar', 'gee' => 'plop');
$conf += $defaults;

and that's it. You no longer have to worry about 'foo' or 'gee' being
defined, whether you use them or not: $conf is fully defined for every
possible configuration settings.

Now you could of course use the same mechanism for filling $_GET
and $_POST, but I usually prefer leaving $_GET and $_POST untouched, so
that it still reflects what the user actually sent, so even the
technique with references would not work for me.

Best,

• Todd