CODEWITHSUNDEEP
javascript
Steve Jobs
Steve Jobs

Reputation: 181

Confused about Javascript. A boolean function can act as a void function?

I'm trying to refresh some Javascript knowledge for an upcoming interview. I was reading a blog that says

"The delete operator returns true if the delete was successful."

and then shows an example of it in use: 

var christmasList = {mike:"Book", jason:"sweater" }
​delete christmasList.mike; // deletes the mike property​

In that example it looks like delete is used in the manner that a void function (in the general programming sense -- I know that JS doesn't require declarations like void) would be.

Can someone explain to me, or give me a link to, the documentation that explains how JS functions can act with different return values, and does such require separate implementations for each return value?

Upvotes: 1

Views: 1079

Answers (5)

Andrew Larson
Andrew Larson

Reputation: 483

As others note, delete is technically an operator and not a function; for our immediate concerns, however, the difference is academic, as the operator's behavior is the same as that of many functions used for their side effects (which is to say, void functions). Both the rule of the language and the conventions of their use are simple.

Rule

  1. All functions provide a return value; if no return statement is reached, this will be undefined

Conventions

Since we always get a return value, we can take advantage of it to improve our programs. There are two conventions; which one should be used depends on the use case.

  1. Return a boolean, signalling success or failure
  2. Return some object being operated on

Option 2 is most useful for methods on objects: if our method changes the state of the object and then returns the object, we can bundle several changes into a single line of method calls: object.change1().change2().change3(newVal);

Option 1 is most useful when we want to use the success or failure of an operation to determine program flow; maybe we want to throw an exception if the property was not deleted but continue normally if it was. Then we can use if (delete object.property) to attempt to delete the property and branch into success/failure cases immediately.

Upvotes: 2

Quentin
Quentin

Reputation: 944205

In that example it looks like delete is used in the manner that a void function

The delete operator is not a function, it is an operator. It deals with properties of objects, not their values.

Functions are something else, but since you asked:

Can someone explain to me how JS functions can act with different return values

JavaScript is loosely typed. Functions don't care about the types of values unless they need to, and (most of the time) conversion between types is handled by operators.

If a function needs to are about what it is operating on, then it has to examine the value to see what it is.

For example:

function myFunction(myArgument) {
    if (typeof myArgument === "function") {
        return myArgument();
    } else {
        return myArgument;
    }
}

A function can return any value it likes.

function string_or_number() {
    if (Math.random() > 0.5) {
        return 1;
    } else {
        return "1";
    }
}

Strongly typed languages care about what type of value a function returns and what type of value is passed into an argument.

Loosely typed ones simply don't. There's nothing special about it from the point of view of someone using the language.

It shunts most of the complexity about having to care about types to the compiler author instead of the user of the compiler (who just has to care that, if a function is designed to do something to a duck, what they pass is sufficiently like a duck to not break the function).

Upvotes: 3

Tschallacka
Tschallacka

Reputation: 28742

Javascript functions always return ambigious values. One function can return boolean, string, object, array or HTMLElement.

There is no fixed type.

function masterSwitch(input) {
    switch(input) {
       case 0 : return "Hello";
       case 1 : return 0xdead;
       case 2 : return 0.00042;
       case 3 : return document.createElement("DIV");
       case 4 : return true;
       case 5 : return window;
       case 6 : return this;
       case 7 : return null;
       default:window.alert("Please specify input from 0 to 8");
    }

}
<input type="text" id="output"> <SELECT onchange="document.getElementById('output').value = typeof masterSwitch(this.selectedIndex);">
<option>string</option>
<option>int</option>
<option>float</option>
<option>HTMLElement</option>
<option>boolean</option>
<option>window</option>
<option>this</option>
<option>null</option>
</select>

Upvotes: 0

Cerbrus
Cerbrus

Reputation: 72947

From the MDN on the delete operator:

Throws in strict mode if the property is an own non-configurable property (returns false in non-strict). Returns true in all other cases.

I can't make it simpler than that. Aside from a small example:

alert(delete window.window)
alert(delete window.foobar)
alert(delete window.alert)

Upvotes: 0

Rahul Tripathi
Rahul Tripathi

Reputation: 172578

You can check the Delete operator which says:

If desc.[[Configurable]] is true, then

  • Remove the own property with name P from O.

  • Return true.

Note that delete only works for properties of objects. Also a good read:- JavaScript Delete() Only Affects The Referenced Object Regardless Of Prototype Chain

Upvotes: 3

Related Questions