Array.prototype.reject(): TypeError: ....reject is not a function

Question

I am taking a cool online course about functional programming in JavaScript. I was following along just fine until the instructor used the Array.prototype.reject() and it did not work for me at run time.

I would like to use "reject" instead of a for loop because it is less code. But, my browser, NodeJS and Express Code consoles tell me that reject is not a function.

I researched other articles that discuss promise.reject is not a function, but provide solutions that do not make sense to my scenario.

Here is the example code in the course:

var animals = [
    { name: 'Fluffykins',   species: 'rabbit' },
    { name: 'Caro',         species: 'dog' },
    { name: 'Hamilton',     species: 'dog' },
    { name: 'Harold',       species: 'fish' },
    { name: 'Ursula',       species: 'cat' },
    { name: 'Jimmy',        species: 'fish' }
];


var isDog = function(animal){
    return animal.species === 'dog';
}

var otherAnimals = animals.reject(isDog);

The work-around with a for-loop:

var notDogs = animals.filter(function(animal){
    return animal.species !== 'dog';
});

Its output is:

> notDogs
[ { name: 'Fluffykins', species: 'rabbit' },
  { name: 'Harold', species: 'fish' },
  { name: 'Ursula', species: 'cat' },
  { name: 'Jimmy', species: 'fish' } ]

Please help me use Array.prototype.reject().

EditL

I found Array.prototype.reject() at GitHub/Array.prototype.reject)

Answer 1

Array.prototype.reject isn't a thing unless a library/custom code adds the reject method to Arrays.

To achieve what you want, you should use the Array.prototype.filter method like you already are. I'm not sure what you think is longer about it because you can write it the same way:

var animals = [
  { name: 'Fluffykins', species: 'rabbit' }, 
  { name: 'Caro', species: 'dog' }, 
  { name: 'Jimmy', species: 'fish' }
];

function noDogs(animal) {
  return animal.species !== 'dog';
}

var otherAnimals = animals.filter(noDogs);
console.log(otherAnimals);

Answer 2

As mentioned in another answer, this was mentioned in a youtube series about functional programming. The video uploader did correct this mistake with an annotation, but you may not have seen that if you were viewing the video on a mobile device.

Answer 3

Array.prototype.reject does not exist in vanilla JavaScript.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

It seems that you were using the example provided by funfunfunction: https://www.youtube.com/watch?v=BMUiFMZr7vk

Notice he never actually executes any of the code he demonstrates in this video.

As others have said, reject does exist in lodash/underscore, or the same result can be derived from using filter, as Dymos suggests.

Answer 4

The reject function is like .filter but in reverse, so you can. You can use the filter function and reverse the callback with the Logical Operator NOT to reverse the outcome.

Array.prototype.reject = function(fn){return this.filter(x => !fn(x))}

• fn is the callback

• this. is the array that the reject function has been called on.

• x is the current entry of that array

Answer 5

For quick & dirty work!

Array.prototype.reject = function(fn) {
 let rej = test => !fn(test);
 return this.filter(rej);
};

Answer 6

You can find _.reject at lodash/underscore

I think that You can use Array.prototype.reduce without any problem but the thing here is that you're mixing between reduce and reject.

reject produces an array without the rejected elements the opposite of filter.

reduce produces a totally new one item value from a list of items

Examples:

function even(number) {
  return number % 2 === 0;
}

_.reject([1, 2, 3, 4], even); // [1, 3]
_.filter([1, 2, 3, 4], even); // [2, 4]

// reduce is totally different method
_.reduce([1, 2, 3, 4], function(total, current) {
  return total + current;
}, 0); // 10

Answer 7

Let's have a look at this array as an example

    const animals = [
    {name: 'Sheru', species: 'Dog' },
    {name: 'Manya', species: 'Cat' },
    {name: 'Monya', species: 'Dog' },
    name: 'Dolly', species: 'fish' }
   ]

We can create a reject function something like this and use

 Array.prototype.reject = function (callback) {
            return this.filter((each, index, array) => !callback(each, index, array))
 }

# We can use something like this to test it


const result = animals.reject((each) => each.species == 'Dog');

console.log(result);

Answer 8

As mentioned in another answer, reject is not built-in, but can be used through underscore.js or a similar library. For example, here's what it looks like

Initially install underscore through npm

npm install -d underscore

Then import it while writing your code

const _ = require("underscore");

var animals = [
    {name: "tommy",species: "dog",},
    {name: "Jimmy",species: "rabbit",},
    {name: "bruno",species: "dog",},
    {name:"meow",species:"cat"}
];

var isDog = (x) => x.species === "dog";

var otherAnimals = _.reject(animals, isDog);

console.table(otherAnimals);

Here is how the output looks like

┌─────────┬─────────┬──────────┐
│ (index) │  name   │ species  │
├─────────┼─────────┼──────────┤
│    0    │ 'Jimmy' │ 'rabbit' │
│    1    │ 'meow'  │  'cat'   │
└─────────┴─────────┴──────────┘