please explain or refer: $string = isset($xyz) ? $xyz : "something else";

[juglesh]

"$string = isset($xyz) ? $xyz : "something else";"

Hello, someone gave code like this in another thread. I understand (by
inference) what it does, but have not found any documentation on this
type of syntax.

Any one have links to this shortuct(?) syntax and other types of
syntax?

thanks
j

[juglesh]

ahh, sorry, wrong group

all apologies
j

[Lasse Reichstein Nielsen]

"juglesh" <ju*********@hotmail.com> writes:

"$string = isset($xyz) ? $xyz : "something else";"

Hello, someone gave code like this in another thread. I understand (by
inference) what it does, but have not found any documentation on this
type of syntax.

Any one have links to this shortuct(?) syntax and other types of
syntax?

Well, the definitive guide would be ECMA 262, 3rd edition:
<URL:http://www.ecma-international.org/publications/standards/Ecma-262.htm>

For less ... detailed ... descriptions, you can use:
JScript:
<URL:http://msdn.microsoft.com/library/en-us/script56/html/js56jslrfjscriptlanguagereference.asp>
JavaScript 1.1:
<URL:http://wp.netscape.com/eng/mozilla/3.0/handbook/javascript/>
JavaScript 1.5:
<URL:http://www.croczilla.com/~alex/reference/javascript_ref/>

In all these, the "...?...:..." syntax is described under "operators"
(beacuse that is what it is :)

/L
--
Lasse Reichstein Nielsen - lr*@hotpop.com
DHTML Death Colors: <URL:http://www.infimum.dk/HTML/rasterTriangleDOM.html>
'Faith without judgement merely degrades the spirit divine.'

[Justin Koivisto]

juglesh wrote:

"$string = isset($xyz) ? $xyz : "something else";"

Hello, someone gave code like this in another thread. I understand (by
inference) what it does, but have not found any documentation on this
type of syntax.

Any one have links to this shortuct(?) syntax and other types of
syntax?

thanks
j

javascript version of PHP's isset would be:

typeof(xyz)!='undefined'

Therefore:

string = typeof(xyz)!='undefined' ? xyz : 'something else';

--
Justin Koivisto - ju****@koivi.com
http://koivi.com

[Richard Cornford]

Justin Koivisto wrote:
<snip>

javascript version of PHP's isset would be:

typeof(xyz)!='undefined'

Therefore:

string = typeof(xyz)!='undefined' ? xyz : 'something else';

Except that in javascript - typeof - is an operator so its operand does
not need to be parenthesised. Though doing so is harmless, it is just
potentially misleading as to the nature of - typeof - because the
results resemble a function call.

Richard.

[Thomas 'PointedEars' Lahn]

Justin Koivisto wrote:

javascript version of PHP's isset would be:

typeof(xyz)!='undefined'

No, because PHP's isset()

,-<http://php.net/isset>
| Returns TRUE if var exists; FALSE otherwise.

"Exists" has to be read as "has been defined, its value is not NULL and
unset() was not applied on it.":

,-<ibid.>
| If a variable has been unset with unset(), it will no longer be set.
| isset() will return FALSE if testing a variable that has been set to
| NULL.

But in JS, there are fundamental differences:

1. An already instantiated variable may have/become the
value of `undefined':

var x;
alert(typeof x); // `undefined'
alert(x); // `undefined' or nothing

var y = y;
alert(typeof y); // `undefined'
alert(y); // `undefined'

2. An already instantiated variable may be undefined by
having the `delete' operator applied on it, provided
that it was not declared (`var' keyword was not used):

z = 2;
alert(typeof z); // `number'
delete z;
alert(typeof z); // `undefined'
alert(z); // ReferenceError

3. A named function argument may be not supplied. In
that case, its value is, by definition :), `undefined':

function foo(a, b)
{
alert([typeof a, typeof b]); // `number,undefined'
}
foo(42);

4. Although `null' in JS is a special value of the internal Null type,

,-<ECMAScript 3>
| 4.3.11 Null Value
| The null value is a primitive value that represents
| the null, empty, or non-existent reference.
|
| 4.3.12 Null Type
| The type Null has exactly one value, called null.

which it has in common with PHP (where NULL is the sole value of
the NULL type), it yields

var x = null;
alert(typeof x); // `object'

This is most certainly an attribution to the fact that a reference
always refers to an object or not.
Conclusion:

Besides risking a ReferenceError (and hopefully catching it with exception
handling), there is no way in JS to determine whether a variable/property
was defined or not; it is only possible to determine whether it yields
`undefined' (the sole value of the internal Undefined type) or `null', or
not.
PointedEars
--
When the power of love overcomes the love
of power, the world will know peace.
-- Jimi Hendrix