Brett Zamir
Jun 21st

  Kevin, I believe dmitriy means filtering via hasOwnProperty inside the for loop. I can make the change, but for this function I wonder whether some users might like to verify that the array/object is _really_ empty (including of prototype-inherited properties). Thoughts? Maybe add an ini_set() configuration option to allow both cases?

Kevin van Zonneveld
Jun 19th

  @ dmitriy kulichkin: Could you maybe provide an example?

dmitriy kulichkin
Jun 9th

  empty([]) will fail if we extend Array with some methods via prototype. I suppose we should check our keys do not to be function. Does it have a sense?

Brett Zamir
16 Nov '09

  @Stoyan Kyosev: I committed a change at http://github.com/kvz/phpjs/commit/dd40b8850a29c0617a40c7ca5ed2ae90fd720a22 to use the "typeof" check, which doesn't suffer from the same problem (nor will it encourage bad practices for those who see our code and don't know why we're doing it). However, I'm not really sure it is justified to do this for all our other functions which test for it since 1) It takes up a little more space, and 2) JavaScript has quite a few ways for you to redefine things (e.g., var isNaN = 5;). Any opinions? But it doesn't hurt, so there ya go... :) Thanks for the input...

Stoyan Kyosev
16 Nov '09

  As noted in http://www.sitepoint.com/blogs/2009/11/12/google-closure-how-not-to-write-javascript/:

"This function checks if a particular variable has a value defined. Or it does, unless a 3rd party script sets the global undefined variable to something else. "

var undefined = 5; 

"u might think that anyone who assigns a value to undefined deserves what they get, but the fix in this case is trivial: simply declare a local undefined variable for use within the function!simply declare a local undefined variable for use within the function!"

function empty(val) {
var undefined;
return val !== undefined;
};

I suggest to use this "fix" in the current implementation of 'empty'.

Kevin van Zonneveld
14 Apr '09

  @ Knoxius: Sometimes the most simple functions require the most insane JavaScript code. Seen echo ? ;)

Brett Zamir
13 Apr '09

  @Knoxius, PHP.JS is treating objects as associative arrays, including ones without a length property, so that wouldn't work for our project. We are also attempting to mimic PHP behavior fully for those familiar with PHP or wishing to use its approach. For example, your function would not consider any number to be non-empty, whereas PHP only considers 0 as such. Of course, your function might work just fine for your own purposes, but we're trying to build a reliable, consistent API, and PHP is the standard to go by (if we just made our own decisions at every turn, there wouldn't be much justification for sticking to PHP function names, as it'd probably just be more confusing for those who expected it to behave as in PHP).

Knoxius
9 Apr '09

  This version seems a bit complex for the mock-function. Couldn't it be simpler by doing something like this:

function empty(string) {
	if(string.length == 0) {
		return true;
	} else {
		return false;
	}
}

It seems a lot simpler, and it still works perfectly fine.

Example:

var myString = 'This is a string.';

if(empty(null)) { //Returns true
alert("It is empty.");
} else if(empty(myString)) { //Returns false
alert("It is not empty.");
}

There could be something about your code that is better, but it seems a bit too complex for what it could be.

Kevin van Zonneveld
4 Mar '09

  @ Marc Jansen: Fixed in svn, thank you!

Marc Jansen
3 Mar '09

  Nice work folks, but I think I found a bug: shouldn't the following code yield 'false'?

var anObj = { 
  'aFunc' : function () { alert('humpty'); } 
}; 
alert( empty( anObj ) ); // alerts true, but the object contains an element 

This is IMHO wrong for arrays as well:

var anArr = [ 
  function () { alert( 'dumpty' ); } 
]; 
alert( empty( anArr ) ) ; // alerts true, but the array contains an element

Named functions should behave the same.

Kevin van Zonneveld
11 Feb '09

  @ Brett Zamir: wicked

Brett Zamir
10 Feb '09

  If it's all right, Kevin, I'll change the text for !== 'function' to be a test for whether o.hasOwnProperty(i). That solves the prototype problem (though even that might be considered non-empty) but avoids the current issue of considering this to be empty: var o = {method:function(){}}

Brett Zamir
3 Nov '08

  If you like, here's a little bit cleaner and slightly safer implementation, I think:

function create_function (args, code) {
	//$newfunc = create_function('$a,$b', 'return $a + $b;');
	// alert($newfunc(5, 4)); 
	var argmnts = [];	
	argmnts = args.split(/,\s*/);	
	return Function.apply(null, argmnts.concat(code));
}

But if one just wishes an anonymous function, they can just do:

call_user_func_array(function(arg) {...}, $a);

or if they need a string

call_user_func_array(new Function($arg1, $code), $a);

For one behaving more like PHP in returning a global name for the new function:

function create_function (args, code) {
	// $newfunc = create_function('$a,$b', 'return $a + $b;');
	// alert($newfunc); // 'lambda_1'
	// alert(     window[$newfunc](5, 3)    ); // 8 (need window to call it, since the PHP behavior is to return a string)

	var funcName = '';
	if (!this.php_js) {
		this.php_js = {};
	}
	if (!this.php_js.create_function_ct) {
		this.php_js.create_function_ct = 0;
	}
	this.php_js.create_function_ct++;	
	funcName = 'lambda_'+this.php_js.create_function_ct;

	eval(funcName+' = function (' + args + ') { ' +  code + '}');

	return funcName;
}

Francesco
26 Oct '08

  If you extend the Array or Object prototype, empty([]) and empty({}) return true...

i've added
if (typeof mixed_var[key] !== 'function' )
this test before returning false in the for cicle, thanks

Kevin van Zonneveld
6 Oct '08

  @ Onno Marsman: Excellent thought and well executed Onno!

Onno Marsman
6 Oct '08

  typeof array will be 'object' so the check for 'array' maxes no sense:

[CODE="Javascript"]
function empty( mixed_var ) {
if (mixed_var === ""
|| mixed_var === 0
|| mixed_var === "0"
|| mixed_var === null
|| mixed_var === false
|| mixed_var === undefined
|| (mixed_var instanceof Array && mixed_var.length === 0)
) {
return true;
}
[/CODE]

Something else: what about empty({}) ?
If you consider {} an object as in PHP then it will never be empty. But I would never use it like that. It would make more sense to call empty({}) when {} could be considered as an associative array, and in that case it is empty and should return true:

[CODE="Javascript"]
function empty( mixed_var ) {
if (mixed_var === ""
|| mixed_var === 0
|| mixed_var === "0"
|| mixed_var === null
|| mixed_var === false
|| mixed_var === undefined
){
return true;
}
if (typeof mixed_var == 'object') {
for (var i in mixed_var) {
return false;
}
return true;
}
return false;
}
[/CODE]
Note that in this implementation I removed the line that handles arrays because the section that takes care of objects handles this correctly for arrays anyway.

Kevin van Zonneveld
5 Sep '08

  @ Onno Marsman: Thanks again man! Remember if you have a homepage or something, I can add it to the credit sections.

Onno Marsman
4 Sep '08

  should also return true on undefined

IT
26 Jan '08

  Awesome! Exactly what I needed ;)