You could simplify the code a bit and return null if there's no more than one iteration to check the prefix. Also you could add an extra check for empty or 1 word arrays, otherwise your code would fail.

function prefix(words) {
    if(words.length < 2 || words[0] === '') { // extra check for 0 or 1 words
      return words[0] || null;
    }
    let i = 0;
    while (true) {
        const c = words[0][i];
        for (let j = 1; j < words.length; j++) {
            if (c != words[j][i]) {
                return i ? words[0].slice(0, i) : null;
            }
        }
        i++; // this will happen when at least 1 character is common
    }
}
console.log(prefix([]));
console.log(prefix(['']));
console.log(prefix(['', '']));
console.log(prefix(['flower', '']));
console.log(prefix(['flower']));
console.log(prefix(["flower", "flowers", "floyd", "flow", "floor"]))
console.log(prefix(["flower", "flowers", "floyd", "flow", "sunflower", "floor"]))

And a benchmark:

<script benchmark data-count="10000000">

const words = ["flower", "flowers", "floyd", "flow", "floor"];

// @benchmark museum/tom
    function prefix(words) {
      for (let i = 0; i < words[0].length; i++) {
        const char = words[0][i];
        for (let j = 1; j < words.length; j++) {
          // first letter unequal
          if (i === 0 && words[j][i] !== char) {
            return null;
          }
          if (i === words[j].length || words[j][i] !== char) {
            return words[0].substring(0, i);
          } 
        }
      }
      // No common prefix found
      return null;
    }
    // @run
    prefix(words);

// @benchmark Alexander
    function prefix2(words) {
        if(words.length < 2 || words[0] === '') { // extra check for 0 or 1 words
          return words[0] || null;
        }
        let i = 0;
        while (true) {
            const c = words[0][i];
            for (let j = 1; j < words.length; j++) {
                if (c != words[j][i]) {
                    return i ? words[0].slice(0, i) : null;
                }
            }
            i++;
        }
    }
    // @run
    prefix2(words);
</script>
<script src="https://cdn.jsdelivr.net/gh/silentmantra/benchmark/loader.js"></script>

TL;DR

Assuming we only need to apply a straight forward modification, I would avoid too much syntactical sugar and just write it this way:

function divide(num1, num2) {
  if (arguments.length < 2) {
    return null;
  }
  return num1/num2;
}

If we want to make it simple and elegant, I would write it this way (requires ES6 features):

const divide = (...args) => args.length < 2 ? null : args[0] / args[1];

Explanation

Improvement steps in vanilla JS (ES5 and before)

• Using function arguments: this is simply an array like object that will magically appear inside your function, which contains the arguments you have passed to the function.

function divide(num1, num2) {
  if (arguments.length < 2) {
    return null;
  }
  return num1/num2;
}

While this is a great solution for the problem there are a downsides to it, if you wanted to switch to arrow function arguments object doesn't appear.

• **Using ternary operator**you can farther more reduce the code by using the ternary ? which is best suitable for simple if statements

function divide(num1,num2) {
  return arguments.length < 2 ? null : num1 / num2;
}

Improvement steps in ES6

• Using spread (in this case it is actually called rest): the ... can be used to either collect items into an array known as rest, or expand an array known as spread.

function divide(...args) {
  return args.length < 2 ? null : args[0] / args[1];
}

JavaScript will collect all the arguments passed to the function and put them into an array called args, I like this better since the reader can see where is args defined.

• using arrow function: there are many difference between arrow and normal function, but many prefer it since it is shorter, and since we have a one-liner function why not use it.

const divide = (...args) => args.length < 2 ? null : args[0] / args[1];

On a final note all the previous solutions has a downside that we are only checking for length of arguments but not contents of arguments, lets assume that someone sent undefined into one of the first two arguments, you'll have 2 arguments but one of them is kinda missing and you'll get NaN since number of arguments is 2.

function divide(num1, num2) {
	  if (num1 === undefined || num2 === undefined) {
return null;
  }
  return num1/num2;
}

Demo

function divide1(num1, num2) {
	  if (arguments.length < 2) {
	    return null;
	  }
	  return num1/num2;
	}
	
function divide2(num1,num2) {
	  return arguments.length < 2 ? null : num1 / num2;
	}
	
	
function divide3(...args) {
	  return args.length < 2 ? null : args[0] / args[1];
	}


const divide4 = (...args) => args.length < 2 ? null : args[0] / args[1];


const test = (cb) => {
  console.log("-------->" + cb.name)
  console.log(cb());
  console.log(cb(1));
  console.log(cb(1, 2));
  console.log(cb(1, undefined));
  console.log(cb(1, null));
  console.log(cb(1, 2, 3));
};

test(divide1);
test(divide2);
test(divide3);
test(divide4);

Undefined typically refers to something which has not yet been assigned a value (yet). Null refers to something which definitively has no value. In that case, I would recommend returning a null. Note that a function with no specified return value implicitly returns undefined.

From the ECMAScript2015 spec

4.3.10 undefined value

primitive value used when a variable has not been assigned a value

4.3.12 null value

primitive value that represents the intentional absence of any object value

http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-undefined-type

Further reading:

When is null or undefined used in JavaScript?

1 <= num <= 7 does not do what you think it does. In JavaScript, binary operators are evaluated from left to right. So 1 <= num <= 7 is really (1 <= num) <= 7, which is either true <= 7 or false <= 7 (depending on what num is). Either way, it will evaluate to true, but don’t ask me why, because you really shouldn’t compare booleans with numbers anyway. Since the condition is always true, the else branch is never executed, so you never get null.

I think what you want to write is:

if (1 <= num && num <= 7) {
   ...
} else {
   ...
}

Furthermore, remember that array indices start with 0. In your example, days[1] would be 'Tuesday', not 'Monday'.

You can eventually do it by parsing the ECMAScript Language Specification which conviniently provides the implementation of the native methods.

For instance, Object.defineProperty(O, P, Attributes) is documented like this:

1. If Type(O) is not Object, throw a TypeError exception.
2. Let key be ? ToPropertyKey(P).
3. Let desc be ? ToPropertyDescriptor(Attributes).
4. Perform ? DefinePropertyOrThrow(O, key, desc).
5. Return O.

Here, simply by parsing the list, you can determine that:

• The method actually returns something, because one of the elements from the list matches the Return .*\. pattern.

• The method returns the parameter O, because O is among the arguments of the method.

Similarly, Array.prototype.find very conviniently tells you that sometimes, the method:

7. Return[s] undefined.

The difficulty is that even this simplest example isn't easy to perform programmatcially. I suppose that while ECMAScript is very consistent in its descriptions of the methods, the high number of possible forms of those methods make any parsing of the documentation rather complex. For instance, Array.prototype.join returns R, but R is not an argument: instead, it is a value which is assigned through the statements such as:

7. If element0 is undefined or null, let R be the empty String; otherwise, let R be ? ToString(element0).

Unless there is an actual BNF grammar that was used to write the spec, parsing such statements would be difficult to impossible.

The good side, however, is that if you achieve to create such parser, it will include the “edge cases, including functions used improperly” you were talking about.

My use case that inspired my question was coding a "maybe" monad that would need to deal with null or undefined coming from any source, and I was just interested in creating a few different demo functions that would do so.

In my humble opinion, creating the list of all JavaScript methods just to have “a few different demo functions” is an overkill. Why not limiting yourself by one or several methods and to use them as a demo?

Still using the spec, an example of a method which returns undefined is Array.prototype.find already listed above; for null, an example could be Date.prototype.toJSON.

Your example doesn't seem to need a loop. That and returning from the loop-delegate doesn't do anything for you.

You can test if a key appears in an object using the in operator.

function exampleFunction(param){
  return param in exampleData ? exampleData[param] : null;
}

You could make a "factory function" or "static factory method" instead:

Foo.CreateFoo = function() {
  // not to confuse with Foo.prototype. ...
  if (something) {
    return null;
  }
  return new Foo();
};

// then instead of new Foo():
var obj = Foo.CreateFoo();

Same thing using the newer class syntax:

class Foo {
  static CreateFoo() {
    if (something) {
      return null;
    }
    return new Foo();
  }
}