This is a follow up to my questions on the Arguments Optional Challenge in Freecodecamp (see below0:
I have now satisfied 5/6 conditions of the challenge, except for when the input is addTogether(2,([3])), which returns '23' as a string instead of the correct 'undefined'.
If the [3] is an array, and an array is an object, shouldn't my checkNum function work to label that as undefined? Where was the string generated?
my code now:
function addTogether() {
function checkNum(x) {
return typeof x === 'number' ? x : undefined;
}
let num1 = checkNum(arguments[0]);
let num2 = checkNum(arguments[1]);
if (arguments.length === 1) {
if (typeof num1 === 'number') {
let a = num1;
return function (b) {
return a + b;
};
}
return undefined;
}
if (arguments.length > 1) {
if (typeof num1 !== 'number' || typeof num2 !== 'number') {
return undefined;
}
if (typeof num1 === 'number' && typeof num2 === 'number');
{
return arguments[0] + arguments[1];
}
}
}
THANKS
//original question below:
I am stuck on the freecodecamp problem Arguments Optional.
https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional
In researching the problem, there have been multiple references to the following code-block, but I just can't get my head around what it means:
if(arguments.length==1){
if (typeof a == "number"){
return function(b){
if (typeof b == "number"){
return a + b;
}
};
}
}
I understand up to the 'return function(b)' part, then my brain melts.
If someone could please explain it as if to a 6-year-old, this noob would really appreciate the help.
This is quite common practice to return a function instead of a value.
When the outer function (which is supposed to do addition) is called with one argument, instead of doing addition (can't do) it is returning a function. When that function is called subsequently with a number parameter it executes the function b and does the sum.
Let us say the outer function name is add() so it can be triggered the following ways:
add(10, 15); // 25
var f = add(20);
f(18) // 38
add(4)(6) // 10
Full example:
function add(a, b) {
if (arguments.length == 1) {
if (typeof a == "number") {
return function (b) {
if (typeof b == "number") {
return a + b;
}
};
} else {
return "undefined";
}
} else if (arguments.length == 2) {
if (typeof a == "number" && typeof b == "number") {
return a + b;
} else {
return "undefined";
}
} else {
return "undefined";
}
}
console.log(add(10, 15));
var f = add(20);
console.log(f(18));
console.log(add("xyz"));
console.log(add(10, "5"));
console.log(add(4)(6));
We can declare functions in 2 ways, the regular way:
function test(){
}
or the interesting way
let test = function(){
}
in this case, the function is returning a function
see here:
function returnfunction(){
return function(b){
if (typeof b == "number"){
return a + b;
}
}
}
let x = returnfunction()
So, x is the return value of returnfunction, which is
function(b){
if (typeof b == "number"){
return a + b;
}
}
So similar to above,
x = function(){
//...
}
I want to check in an JS object (example: { x:false, y:true } ) if some properties are either boolean or if they are (null || undefined).
Is there an easy way in JS or Underscore to check this without doing
(obj.x != null || obj.x != undefined)
???
You could use just the standard typeof operator, which returns 'boolean' if boolean.
console.log(typeof undefined === 'boolean'); // false
console.log(typeof null === 'boolean'); // false
console.log(typeof true === 'boolean'); // true
console.log(typeof false === 'boolean'); // true
The typeof operator can return whether it is boolean or anything else
Reference here
I found an easy way in Underscore:
_.isBoolean(obj.x)
Thanks to Rajesh I know now that obj.x != null returns the same if x is null or undefined.
I prefer the Underscore function because it's readable, but the null comparison is native JS and seems more efficient, and simpler.
Try this Hope it will help you,
JavaScript
function test(v) {
let type = typeof v;
if(type === 'undefined') {
return true;
}
if(type=== 'boolean') {
return false;
}
if(v === null) {
return true;
}
if(v === undefined) {
return true;
}
if(v instanceof Array) {
if(v.length < 1) {
return true;
}
}
else if(type === 'string') {
if(v.length < 1) {
return true;
}
}
else if(type === 'object') {
if(Object.keys(v).length < 1) {
return true;
}
}
else if(type === 'number') {
if(isNaN(v)) {
return true;
}
}
return false;
}
In Javascript, undefined is evaluated as false, so you should be able to do
if (obj.x) {
// ...
}
I have a function that receives 2 arguments and 1 additional, optional argument. The function must return true if the first argument is bigger than the second one, false if not, except if the third argument is true (the third argument can be only true or false, false by default), in which case the function should return true if the first argument is either bigger or equal (strict comparison) to the second argument.
The function isn't guaranteed to receive arguments of the same type, or even arguments that make any sense (the function could be called with null, undefined). Anyways, the function must obey javascript behavior to compare the received arguments.
I have two functions, and I believe the second one should be faster, but neither my own benchmarks nor jsperf results say so. In fact, the first function is ~30-35% faster, which is quite a lot.
How can I track down the slow code paths inside each function? How can I know why the second function is slower?
This is my benchmark:
var microtime = require('microtime');
/* Helper functions */
function maybeBool() {
if(Math.round(Math.random() * 1)) {
return true;
} else {
return false;
}
}
function maybeNullUndef() {
if(Math.round(Math.random() * 1)) {
return null;
} else {
return undefined;
}
}
function randomString() {
return Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
}
function randomDate() {
var y = Math.round(Math.random() * 100);
return new Date(y);
}
function something() {
var x = Math.round(Math.random()*3);
switch(x) {
case 0:
return maybeBool();
break;
case 1:
return maybeNullUndef();
break;
case 2:
return randomString();
break;
case 3:
return randomDate();
break;
}
}
var things_to_compare = [];
for(i = 0; i < 500000; i++) {
var a = something();
var b = something();
things_to_compare.push([a, b]);
}
/* First function */
function gtHelper(prop1, prop2, equal) {
// 'falsy' and Boolean handling
if (!prop1 || !prop2 || prop1 === true || prop2 === true) {
if ((prop1 === true || prop1 === false) && (prop2 === true || prop2 === false)) {
if (equal) {
return prop1 === prop2;
} else {
if (prop1) {
return !prop2;
} else {
return false;
}
}
}
if (prop1 === undefined || prop1 === null || prop1 === false || prop2 === true) {
return !!equal || false;
}
if (prop2 === undefined || prop2 === null || prop1 === true || prop2 === false) {
return true;
}
if (prop1 > prop2) {
return true;
}
if (prop1 < prop2) {
return false;
}
// not lt and and not gt so equality assumed-- this ordering of tests is date compatible
return equal;
}
if (prop1 > prop2) {
return true;
}
if (prop1 < prop2) {
return false;
}
// not lt and and not gt so equality assumed-- this ordering of tests is date compatible
return equal;
}
/* Second function */
function gtHelper2 (prop1, prop2, equal) {
equal = !!equal;
//If 'prop1' is any of those, the result will be always 'false',
//unless 'equal' is true.
switch (prop1) {
case "":
case null:
case false:
case undefined:
return (prop1 === prop2 && equal);
}
//If 'prop2' is any of those, the result will be always 'true'
switch (prop2) {
case "":
case null:
case false:
case undefined:
return true;
}
if (prop1 > prop2 || (prop1 === prop2 && equal)) {
return true;
} else if (prop1 < prop2) {
return false;
} else {
return equal;
}
}
/* Benchmark */
var res1 = 0;
for(n = 0; n < 30; n++) {
var now = microtime.now();
for(i = 0; i < 500000; i++) {
gtHelper(things_to_compare[i][0], things_to_compare[i][1]);
}
var now1 = microtime.now();
res1 += now1 - now;
}
var res2 = 0;
for(n = 0; n < 30; n++) {
var now = microtime.now();
for(i = 0; i < 500000; i++) {
gtHelper2(things_to_compare[i][0], things_to_compare[i][1]);
}
var now1 = microtime.now();
res2 += now1 - now;
}
console.log("gtHelper:", res1/30);
console.log("gtHelper2:", res2/30);
Edit:
I have been further working on the second function, I achieved make it a little bit faster, but it keep lagging behind the first function.
This is how it looks now:
function gtHelper2 (prop1, prop2, equal) {
//If 'prop1' is any of those, the result will be always 'false',
//unless 'equal' is true.
if (!prop1) {
return (prop1 === prop2 && !!equal);
}
//If 'prop2' is any of those, the result will be always 'true'
if (!prop2) {
return true;
}
if (prop1 > prop2) {
return true;
} else if (prop1 < prop2) {
return false;
} else if (prop1 === prop2 && !!equal) {
return true;
} else {
return !!equal;
}
}
Your two functions do not return the same thing.
gtHelper(true, 'string') // true
gtHelper2(true, 'string') // false
gtHelper('string', new Date()) // undefined
gtHelper2('string', new Date()) // false
gtHelper(new Date(), 'string') // undefined
gtHelper2(new Date(), 'string') // false
If you can get these functions behaving the same, I am sure you will see more meaningful results.
You should be aware that, in the browser at least, you should not expect switch to perform the same on all platforms. You should read the ECMA spec on switch to see why optimising this should be so difficult. I know that Firefox did spend a good deal of time on making their switch implementation perform well. I've heard nothing about anything similar on V8.
How can you check if two or more objects/vars have the same reference?
You use == or === :
var thesame = obj1===obj2;
From the MDN :
If both operands are objects, then JavaScript compares internal
references which are equal when operands refer to the same object in
memory.
The equality and strict equality operators will both tell you if two variables point to the same object.
foo == bar
foo === bar
For reference type like objects, == or === operators check its reference only.
e.g
let a= { text:'my text', val:'my val'}
let b= { text:'my text', val:'my val'}
here a==b will be false as reference of both variables are different though their content are same.
but if I change it to
a=b
and if i check now a==b then it will be true , since reference of both variable are same now.
As from ES2015, a new method Object.is() has been introduced that can be used to compare and evaluate the sameness of two variables / references:
Below are a few examples:
Object.is('abc', 'abc'); // true
Object.is(window, window); // true
Object.is({}, {}); // false
const foo = { p: 1 };
const bar = { p: 1 };
const baz = foo;
Object.is(foo, bar); // false
Object.is(foo, baz); // true
Demo:
console.log(Object.is('abc', 'abc'));
console.log(Object.is(window, window));
console.log(Object.is({}, {}));
const foo = { p: 1 };
const bar = { p: 1 };
const baz = foo;
console.log(Object.is(foo, bar));
console.log(Object.is(foo, baz));
Note: This algorithm differs from the Strict Equality Comparison Algorithm in its treatment of signed zeroes and NaNs.
Possible algorithm:
Object.prototype.equals = function(x)
{
var p;
for(p in this) {
if(typeof(x[p])=='undefined') {return false;}
}
for(p in this) {
if (this[p]) {
switch(typeof(this[p])) {
case 'object':
if (!this[p].equals(x[p])) { return false; } break;
case 'function':
if (typeof(x[p])=='undefined' ||
(p != 'equals' && this[p].toString() != x[p].toString()))
return false;
break;
default:
if (this[p] != x[p]) { return false; }
}
} else {
if (x[p])
return false;
}
}
for(p in x) {
if(typeof(this[p])=='undefined') {return false;}
}
return true;
}
How can I check if a variable is empty in Javascript?
if(response.photo) is empty {
do something
else {
do something else
}
response.photo was from JSON, and it could be empty sometimes, empty data cells! I want to check if it's empty.
If you're testing for an empty string:
if(myVar === ''){ // do stuff };
If you're checking for a variable that has been declared, but not defined:
if(myVar === null){ // do stuff };
If you're checking for a variable that may not be defined:
if(myVar === undefined){ // do stuff };
If you're checking both i.e, either variable is null or undefined:
if(myVar == null){ // do stuff };
This is a bigger question than you think. Variables can empty in a lot of ways. Kinda depends on what you need to know.
// quick and dirty will be true for '', null, undefined, 0, NaN and false.
if (!x)
// test for null OR undefined
if (x == null)
// test for undefined OR null
if (x == undefined)
// test for undefined
if (x === undefined)
// or safer test for undefined since the variable undefined can be set causing tests against it to fail.
if (typeof x == 'undefined')
// test for empty string
if (x === '')
// if you know its an array
if (x.length == 0)
// or
if (!x.length)
// BONUS test for empty object
var empty = true, fld;
for (fld in x) {
empty = false;
break;
}
This should cover all cases:
function empty( val ) {
// test results
//---------------
// [] true, empty array
// {} true, empty object
// null true
// undefined true
// "" true, empty string
// '' true, empty string
// 0 false, number
// true false, boolean
// false false, boolean
// Date false
// function false
if (val === undefined)
return true;
if (typeof (val) == 'function' || typeof (val) == 'number' || typeof (val) == 'boolean' || Object.prototype.toString.call(val) === '[object Date]')
return false;
if (val == null || val.length === 0) // null or 0 length array
return true;
if (typeof (val) == "object") {
// empty object
var r = true;
for (var f in val)
r = false;
return r;
}
return false;
}
I see potential shortcomings in many solutions posted above, so I decided to compile my own.
Note: it uses Array.prototype.some, check your browser support.
Solution below considers variable empty if one of the following is true:
JS thinks that variable is equal to false, which already covers many things like 0, "", [], and even [""] and [0]
Value is null or it's type is 'undefined'
It is an empty Object
It is an Object/Array consisting only of values that are empty themselves (i.e. broken down to primitives each part of it equals false). Checks drill recursively into Object/Array structure.
E.g.
isEmpty({"": 0}) // true
isEmpty({"": 1}) // false
isEmpty([{}, {}]) // true
isEmpty(["", 0, {0: false}]) //true
Function code:
/**
* Checks if value is empty. Deep-checks arrays and objects
* Note: isEmpty([]) == true, isEmpty({}) == true, isEmpty([{0:false},"",0]) == true, isEmpty({0:1}) == false
* #param value
* #returns {boolean}
*/
function isEmpty(value){
var isEmptyObject = function(a) {
if (typeof a.length === 'undefined') { // it's an Object, not an Array
var hasNonempty = Object.keys(a).some(function nonEmpty(element){
return !isEmpty(a[element]);
});
return hasNonempty ? false : isEmptyObject(Object.keys(a));
}
return !a.some(function nonEmpty(element) { // check if array is really not empty as JS thinks
return !isEmpty(element); // at least one element should be non-empty
});
};
return (
value == false
|| typeof value === 'undefined'
|| value == null
|| (typeof value === 'object' && isEmptyObject(value))
);
}
Here my simplest solution.
Inspired by PHP empty function
function empty(n){
return !(!!n ? typeof n === 'object' ? Array.isArray(n) ? !!n.length : !!Object.keys(n).length : true : false);
}
//with number
console.log(empty(0)); //true
console.log(empty(10)); //false
//with object
console.log(empty({})); //true
console.log(empty({a:'a'})); //false
//with array
console.log(empty([])); //true
console.log(empty([1,2])); //false
//with string
console.log(empty('')); //true
console.log(empty('a')); //false
A more readable version of #SJ00 answer:
/**
* Checks if a JavaScript value is empty
* #example
* isEmpty(null); // true
* isEmpty(undefined); // true
* isEmpty(''); // true
* isEmpty([]); // true
* isEmpty({}); // true
* #param {any} value - item to test
* #returns {boolean} true if empty, otherwise false
*/
function isEmpty(value) {
return (
value === null || // check for null
value === undefined || // check for undefined
value === '' || // check for empty string
(Array.isArray(value) && value.length === 0) || // check for empty array
(typeof value === 'object' && Object.keys(value).length === 0) // check for empty object
);
}
See http://underscorejs.org/#isEmpty
isEmpty_.isEmpty(object)
Returns true if an enumerable object contains no values (no enumerable own-properties). For strings and array-like objects _.isEmpty checks if the length property is 0.
Combining answers from #inkednm into one function:
function isEmpty(property) {
return (property === null || property === "" || typeof property === "undefined");
}
Empty check on a JSON's key depends on use-case. For a common use-case, we can test for following:
Not null
Not undefined
Not an empty String ''
Not an empty Object {} [] (Array is an Object)
Function:
function isEmpty(arg){
return (
arg == null || // Check for null or undefined
arg.length === 0 || // Check for empty String (Bonus check for empty Array)
(typeof arg === 'object' && Object.keys(arg).length === 0) // Check for empty Object or Array
);
}
Return true for:
isEmpty(''); // Empty String
isEmpty(null); // null
isEmpty(); // undefined
isEmpty({}); // Empty Object
isEmpty([]); // Empty Array
just put the variable inside the if condition, if variable has any value it will return true else false.
if (response.photo){ // if you are checking for string use this if(response.photo == "") condition
alert("Has Value");
}
else
{
alert("No Value");
};
What about doing like this.
JSON.stringify({}) === "{}"
just be careful with all what i see here:
typeof object === 'object' && Object.keys(object).length === 0) is indeed checking if an object is Empty. But did you know that Date in javascript are considered object also?
so if you do:
const shouldNotbeEmpty = new Date(Date.now())
isEmpty(shouldNotbeEmpty) // this will return true when it should not
my only way to figure it out to fix that was to check if the object is a Date instance:
typeof value === "object" && Object.keys(value).length === 0 && !value instanceof Date
so something like this:
const isObject = value => typeof value === "object" && Object.keys(value).length === 0
const isString = value => typeof value === "string" && value.trim().length === 0
const isEmpty = value => {
const isDate = value instanceof Date
return value === undefined || value === null || (isObject(value) && !isDate) || isString(value)
}
exports.isEmpty = isEmpty
const isEmpty = value => {
if (!value && value !== 0) return true
if(Array.isArray(value)){
if(!value.length) return true
return value.every(isEmpty)
}
if (typeof value === 'object') {
return Object.values(value).every(isEmpty)
}
return false
}
isEmpty(); // true
isEmpty(undefined); // true
isEmpty(null); // true
isEmpty(0); // false
isEmpty(1); // false
isEmpty(''); // true
isEmpty('a'); // false
isEmpty([]); // true
isEmpty([0]); // false
isEmpty([1]); // false
isEmpty([[]]); // true
isEmpty([[], []]); // true
isEmpty([[], null, undefined]); // true
isEmpty([[], 1]); // false
isEmpty({}); // true
isEmpty({a: 1}); // false
isEmpty({a: 1, b: 2}); // false
isEmpty({a: 1, b: {}}); // false
isEmpty({a: null, b: [], c: undefined}); // true
isEmpty({a: {}, b: {}, c: {}}); // true
isEmpty(() => {}) // false
It depends on what you mean by "empty". The most common pattern is to check to see if the variable is undefined. Many people also do a null check, for example:
if (myVariable === undefined || myVariable === null)...
or, in a shorter form:
if (myVariable || myVariable === null)...
if (myVar == undefined)
will work to see if the var is declared but not initalized.
Check for undefined:
if (typeof response.photo == "undefined")
{
// do something
}
This would do the equivelant of vb's IsEmpty. If myvar contains any value, even null, empty string, or 0, it is not "empty".
To check if a variable or property exists, eg it's been declared, though it may be not have been defined, you can use the in operator.
if ("photo" in response)
{
// do something
}
If you're looking for the equivalent of PHP's empty function, check this out:
function empty(mixed_var) {
// example 1: empty(null);
// returns 1: true
// example 2: empty(undefined);
// returns 2: true
// example 3: empty([]);
// returns 3: true
// example 4: empty({});
// returns 4: true
// example 5: empty({'aFunc' : function () { alert('humpty'); } });
// returns 5: false
var undef, key, i, len;
var emptyValues = [undef, null, false, 0, '', '0'];
for (i = 0, len = emptyValues.length; i < len; i++) {
if (mixed_var === emptyValues[i]) {
return true;
}
}
if (typeof mixed_var === 'object') {
for (key in mixed_var) {
// TODO: should we check for own properties only?
//if (mixed_var.hasOwnProperty(key)) {
return false;
//}
}
return true;
}
return false;
}
http://phpjs.org/functions/empty:392
what am I missing if empty array... keyless object... falseness
const isEmpty = o => Array.isArray(o) && !o.join('').length || typeof o === 'object' && !Object.keys(o).length || !(+value);
Here's a simpler(short) solution to check for empty variables. This function checks if a variable is empty. The variable provided may contain mixed values (null, undefined, array, object, string, integer, function).
function empty(mixed_var) {
if (!mixed_var || mixed_var == '0') {
return true;
}
if (typeof mixed_var == 'object') {
for (var k in mixed_var) {
return false;
}
return true;
}
return false;
}
// example 1: empty(null);
// returns 1: true
// example 2: empty(undefined);
// returns 2: true
// example 3: empty([]);
// returns 3: true
// example 4: empty({});
// returns 4: true
// example 5: empty(0);
// returns 5: true
// example 6: empty('0');
// returns 6: true
// example 7: empty(function(){});
// returns 7: false
const isEmpty = val => val == null || !(Object.keys(val) || val).length;
function isEmpty(variable) {
const type = typeof variable
if (variable === null) return true
if (type === 'undefined') return true
if (type === 'boolean') return false
if (type === 'string') return !variable
if (type === 'number') return false
if (Array.isArray(variable)) return !variable.length
if (type === 'object') return !Object.keys(variable).length
return !variable
}
My solution:
function isEmpty(object) {
return (
(!object)
|| (object === undefined)
|| (object === null)
|| (object === '')
|| ((object?.length !== undefined) && (object.length === 0))
|| (typeof object === 'object' && Object.keys(object).length === 0)
);
}
Tests with Jest:
describe('isEmpty should return `false` when the parameter have some truthy value.', () => {
test('Empty objects should return true', () => {
expect(utils.isEmpty([])).toBe(true);
expect(utils.isEmpty({})).toBe(true);
expect(utils.isEmpty('')).toBe(true);
expect(utils.isEmpty(undefined)).toBe(true);
expect(utils.isEmpty(null)).toBe(true);
});
test('Truthy objects should return false', () => {
expect(utils.isEmpty([1])).toBe(false);
expect(utils.isEmpty({a: undefined})).toBe(false);
expect(utils.isEmpty({a: 5})).toBe(false);
expect(utils.isEmpty({a: 5, b: 6, c: undefined})).toBe(false);
expect(utils.isEmpty('f00')).toBe(false);
expect(utils.isEmpty('0')).toBe(false);
});
})
var message_1 = message.trim();
if (message_1.length > 0) {
// to do
}