Develop Reference

How to handle boolean values itself in the ternary operator or boolean operators?

I am parsing a JSON response and if the data exists I need to return the value as it is, otherwise return null. I tried using ternary operator/boolean operators for this and it works for other datatypes, but not for boolean values itself
Example:
let dummyObj = {
data: {
testdata: false
}
};
console.log(dummyObj.data && dummyObj.data.testdata || null); // returns null always, should return false
console.log((dummyObj.data && dummyObj.data.testdata) ? dummyObj.data.testdata : null); // same behavior, always returns null if the testdata value is false
This statement always returns null as the value of testdata is itself false, it goes into the or condition and returns the null. This works fine if the data is not boolean or the value is true.
How can I make this work? Is there a way to handle boolean values?

Nullish Coalescing operator is a good alternative. This is mostly supported in modern browsers, and optional chaining also help to safely validate your nested properties
console.log(dummyObj?.data?.testdata ?? null);
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

If you really want to return the value as is if the property exists, then you have to test its existence with the hasOwnProperty method or the in operator:
dummyObject.data?.hasOwnProperty('testdata') ? dummyObject.data.testdata : null
('data' in dummyObject && 'testdata' in dummyObject.data) ? dummyObject.data.testdata : null
If you also want to treat the property as non-existing if it has the values undefined or null, then there are shorter ways as decribed in the other answer.
Another way to phrase this: Determine the exact the range of possible values (or data types) of the property and use the simplest solution that works for that range of values.

How does logical expressions work in JavaScript?

This seems to be a common issue, but I didn't find anything that would help me understand.
I have a bunch of items with introduced member of type bool. Some items have introduced value of true, some of false. So coming from c++ I don't expect this to return 'false' (item.introduced is boolean)
if ((show_introduced == "false") && (item.introduced)) {console.log(item.introduced)};
but I acctually see 'false' an well as 'true'.
For me it is the same as, which, of course, never output anything.
var a = false;
if (true && a) {console.log(a)};
Does && works differently in js, or I should find the problem somewhere in the rest of the code?
EDITED: Because item.introduced was read from JSON, it was actually a string, so that's the reason why it didn't work.

'false' in quotes makes it a string, which is true. So, "false" != false
write it like
(show_introduced === false)
EDIT:
Falsy values in Javascript:
false (boolean)
"" (an empty string)
0 (zero)
null
undefined
NaN
if you get anything from above, they are falsy value, and everything else if truthy.

Don't attempt to compare boolean values with true or false, just use them as booleans
if ( showIntroduced )
or
if ( ! showIntroduced )
Logical operators such as && and || in JavaScript behave as you would expect from C/C++, with the same short-circuit rules.

Reference and datatype checking, are these the same?

I have a simple function in my library that checks the validity of an object reference (object here meaning, a reference to a created HTML element, mostly DIV's). It looks like this:
function varIsValidRef(aRef) {
return ( !(aRef == null || aRef == undefined) && typeof(aRef) == "object");
}
While experimenting i found that this has the same effect:
function varIsValidRef(aRef) {
return (aRef) && typeof(aRef) == "object";
}
I understand there are some controversies regarding the short hand () test? While testing against various datatypes (null, undefined, integer, float, string, array) i could find no difference in the final outcome. The function seem to work as expected.
Is it safe to say that these two versions does the exact same thing?

No, in my opinion these functions don't work the same:
First option
If aRef is not undefined or null and the type of the var is object it returns true.
Second option
First we convert aRef to a boolean. Values like null, undefined and 0 become false, everything else become true. If it is true (so not one of those values) it checks if the type is object.
So the second option return false if aRef is 0, something you don't want. And it isn't option a elegant way to check it, because you check if an object or string or something is equal to a boolean.
And at least they don't return the same thing. The first option returns a boolean, but the second option returns the value you put in the function if (aRef) is false:
varIsValidRef(0);
>>> 0
varIsValidRef('');
>>> ""
varIsValidRef(undefined);
>>> undefined
varIsValidref(null);
>>> null
Because JavaScript use these values as falsy values you don't see the difference between these return values if you use if statements or something like that.
So I suggest you to use the first option.

they are strongly different:
!(aRef == null || aRef == undefined)
this part is evaluated to false with any of these "null", null, "undefined", undefined
(aRef)
while this other with any of these 0, "", false, null, undefined, NaN

Interesting case, but it seems logical for both to behave the same way despite being totally different. Lets see the first staement.
return ( !(aRef == null || aRef == undefined) && typeof(aRef) == "object");
Here,
null and undefined both denote a false state combined with the ! infront, makes it equal to the expression aRef which will return true in case both are either not null or not undefined.

They don't do the same, though they end up with the same results.
The first function is more strict in what it will count as false together, or if it's not, if its an object.
The second function will check if aRef is !false or not any of the falsy values (ie [], null, undefined) and check if the type is an object if it isn't.
I would prefer the first function, since its stricter in what it accepts, but if its all the same the function which performs the best should be used.
As for the controversy, its true that you have to be careful about how/when you use falsy values in equations but if it does what you want it to do (and for that you'll need to know what falsy values are) and you implement it correctly it should be no problem. The two are hard to put together though. So with that, if this does what you want it to do, and nothing more or less, by all means use it.

Check for false

Is there any better way of doing this?
if(borrar() !== false)
{
alert('tatatata bum bum bum prapra');
}
return false;

If you want to check for false and alert if not, then no there isn't.
If you use if(val), then anything that evaluates to 'truthy', like a non-empty string, will also pass. So it depends on how stringent your criterion is. Using === and !== is generally considered good practice, to avoid accidentally matching truthy or falsy conditions via JavaScript's implicit boolean tests.

If you want an explicit check against false (and not undefined, null and others which I assume as you are using !== instead of !=) then yes, you have to use that.
Also, this is the same in a slightly smaller footprint:
if(borrar() !== !1)

You can use something simpler:
if(!var){
console.log('var is false');
}

If you want it to check explicit for it to not be false (boolean value) you have to use
if(borrar() !== false)
But in JavaScript we usually use falsy and truthy and you could use
if(!borrar())
but then values 0, '', null, undefined, null and NaN would not generate the alert.
The following values are always falsy:
false,
,0 (zero)
,'' or "" (empty string)
,null
,undefined
,NaN
Everything else is truthy. That includes:
'0' (a string containing a single zero)
,'false' (a string containing the text “false”)
,[] (an empty array)
,{} (an empty object)
,function(){} (an “empty” function)
Source: https://www.sitepoint.com/javascript-truthy-falsy/
As an extra perk to convert any value to true or false (boolean type), use double exclamation mark:
!![] === true
!!'false' === true
!!false === false
!!undefined === false

Checking if something isn't false... So it's true, just if you're doing something that is quantum physics.
if(!(borrar() === false))
or
if(borrar() === true)

Like this:
if(borrar())
{
// Do something
}
If borrar() returns true then do something (if it is not false).

is there any function like string.isnullorempty() in javascript

I always (thing != undefined || thing != null)?...:...; check. Is there any method will return bool after this check in javascript or jquery ?
And how would you add this check in jquery as a function?

if (thing)
{
//your code
}
Is that what you are looking for?

In Javascript, the values null, undefined, "", 0, NaN, and false are all "falsy" and will fail a conditional.
All other values are "truthy" and will pass a conditional.
Therefore, you can simply write thing ? ... : ....

Try this
function SringisEmpty(str) {
str=str.trim();
return (!str || 0 === str.length);
}

As the others here have mentioned, several things evaluate as "falsy" that you might not want to (such as empty strings or zero). The simplest way I've found in JavaScript to check for both null and undefined in one statement is:
thing != null
This is using type coercion (double equals instead of triple equals), so undefined values are coerced to null here, while empty strings, zero, etc. do not.