Push Objects To Array So Long As Object Property Is Not Nan

I am aware that I could use .filter to achieve this, however I am not sure how to implement it. I have objects as follows within an array item { title : g.attributes.title, cat

Solution 1:

functionload(id){
   itemPath = lev1.lev2.lev3;
   items = [];
   for (var i = 0; i<itemPath.length; i++) {
      if(itemPath[i].attributes.id==id) {
         return itemPath[i].attributes.grades.models.map(function(g) {
            if(g.attributes.possible !== g.attributes.possible){
               return;
            }


            items.push(
               {
                  title : g.attributes.title,
                  category : g.attributes.categoryid,
                  possible: g.attributes.possible
               });
         });
      }
   }
}

NaN is the only property in javascript that does not equal itself. Just loop over the properties and check them for this, or use the built in NaN() function within the loop as suggested elsewhere.

Update

Since you're only worried about the possible property, just check that one as part of the if statement using === self, or isNaN()

Solution 2:

Just change your test line from

if(itemPath[i].attributes.id==id)

to use isNaN function on the properties you want to check

var attr = itemPath[i].attributes;
if (attr.id==id && !isNaN(attr.title) && !isNaN(attr.categoryid) && !isNaN(attr.possible))

Solution 3:

You can use the isNaN() and test it before adding it...

functionload(id){
   itemPath = lev1.lev2.lev3;
   items = [];
   for (var i = 0; i<itemPath.length; i++) {
      if(itemPath[i].attributes.id==id) {
         return itemPath[i].attributes.grades.models.map(function(g) {
            if( isNaN(g.attributes.title) || isNaN(g.attributes.categoryid) || isNaN(g.attributes.possible)  ){
            items.push(
               {
                  title : g.attributes.title,
                  category : g.attributes.categoryid,
                  possible: g.attributes.possible
               });
            }
         });
      }
   }
}

Solution 4:

You're code is a little confusing

functionload(id){
   itemPath = lev1.lev2.lev3;
   items = [];
   for (var i = 0; i<itemPath.length; i++) {
      if(itemPath[i].attributes.id==id) {
         return itemPath[i].attributes.grades.models.map(function(g) {
            items.push(
               {
                  title : g.attributes.title,
                  category : g.attributes.categoryid,
                  possible: g.attributes.possible
               });
         });
      }
   }
}

It doesn't look like you are using map right. Map works like list compresions in the sense that it iterates over a sequence to preform some kind of operation on each element and returns a new sequence

var arr = [1,2,3];
var complexMagic = arr.map( function(n) { return n + 10; } );
// complexMagic === [11,12,13]

FYI, this is how filter, works. Filter takes in a predicate function( aka, Boolean function) to build a new sequence. If the predicate returns true, then the element will be stored in the new sequence.

var arr = [1, 123, 42, 1001, 1100];
var oddNumbers = arr.filter( function(n) {
    return1 === (n & (-n) );
} );

// oddNumbers === [1, 123, 1001] );// Bit hacks are fun ;P

It looks like you don't need items array or to even push new elements onto it.

functionload(id){
   itemPath = lev1.lev2.lev3;
   items = [];
   for (var i = 0; i<itemPath.length; i++) {
      if(itemPath[i].attributes.id==id) {
         return itemPath[i].attributes.grades.models.map(function(g) {

            // You don't have to return anything.// This might be an ok place for the NaN check.return ({
                  title : g.attributes.title,
                  category : g.attributes.categoryid,
                  possible: g.attributes.possible
               });
         });
      }
   }
}

I'm lazy and didn't testing any of my code so reader beware. Also avoid the push method if possible. It can be a inefficient approach to append new elements onto an array.