Why Does My Function Return Undefined Whilst I Do Give It an Argument

function my_index(arr, score) {
  for (const [index, elem] of arr.entries()) {
    if (elem.includes(score)) {
      return index;
    }
  }
}

function getGrade(score) {
  let grade;
  var gradeDict = {
    A: [26, 27, 28, 29, 30],
    B: [21, 22, 23, 24, 25],
    C: [16, 17, 18, 19, 20],
    D: [11, 12, 13, 14, 15],
    E: [6, 7, 8, 9, 10],
    F: [0, 1, 2, 3, 4, 5],
  };
  var keys = Object.keys(gradeDict);
  var values = Object.values(gradeDict);
  grade = keys[my_index(values, score)];

  return grade;
}

console.log(getGrade(5));
console.log(getGrade(25));

Why the function argument returns undefined when using props?

When working with arrow function, you need to call like,

<Buttons selectReport={() => this.onSelect} > //without parenthesis

also setState is async so you need to use callback in setState to print value.

You need to do this,

export default class Ind extends Component {
  constructor(){
   super();
   this.state = { report: null}
  }
  onSelect = (newreport) => {
      console.log("Parameter: ", newreport)
      this.setState({
        report: newreport
      },()=> console.log("State: ", this.state.report)) //prints in callback
  }

  render(){
   return(
    <Buttons selectReport={() => this.onSelect}>
   )
  }
}

Why does this function returns undefined?

The reason you get undefined is because the function isThree() doesn't return anything. The two returns in your function return from the anonymous function inside foreach().

I think your function tries to determine if there's a value 3 in the array. There is already a function for that: includes(). Your function could be:

function isThree(...args) {
  return args.includes(3);
};

console.log(isThree(1,2,3,4,5));

Is it better to return `undefined` or `null` from a javascript function?

I will argue there is no best way, and even standard functions sometimes choose one or the other.

For example:

• [[Prototype]]

  Ordinary objects have a [[Prototype]] internal slot, which determines from which other object they inherit from. Of course, there must be a way to say that an object does not inherit from any other one. In this case, "there is no such object" is represented using null.

• Object.getOwnPropertyDescriptor

  It is expected to return a property descriptor, that is, an object which describes a property (e.g. value, writability, enumerability and configurability). However, the property may not exist. In this case, "there is no such property" is represented using undefined.

• document.getElementById

  It is expected to return the element with the given ID. However, there might be no element with that ID. In this case, "there is no such element" is represented using null.

So just choose whatever you prefer or think makes more sense for your specific case.

Function Returns undefined object

Because the getStats function isnt returning anything, only the function which is an argument of fs.readFile returns.

Here I have made a callback argument, so that you can do what you need with everyStats inside of a callback function.

var getStats = function (callback){
        fs.readFile('Documents/GitHub/kag-gather-irc-bot/stats.json', 'utf8', function (err,data) {
                if (err) {
                        return console.log(err);
                }
                everyStats = JSON.parse(data);
                console.log(everyStats);
                callback(everyStats);
        });

}

getStats(function(stats) {
  // do what you want with stats
});

Why does this recursive function return undefined?

Explanation

The problem is that you don't return the recursive call's result, thus it is undefined when the whole call to merge is resolved.

Let me take you through the execution, step-by-step:

1. With arguments "AAA" and "BBB", their lengths are not 0, go to else. Once in else, str3 is "AB", call merge("AA", "BB").
2. With arguments "AA" and "BB", their lengths are not 0, go to else. Once in else, str3 is now "ABAB", call merge("A", "B").
3. With arguments "A" and "B", their lengths are not 0, go to else. Once in else, str3 is now "ABABAB", call merge("", "").
4. With empty string arguments, length is 0. Now go to the if statement, where str3 is logged, and returned.
5. Since the merge("", "") call has resolved (to "ABABAB" as it is returned), we continue where we left off in the call merge("A", "B"), thus going "up" the call stack.
6. We start where we left off in call merge("A", "B"), in the else branch. There are no more statements or expressions in that call, so it's resolved. There are no return statements, so by default it returns undefined. We go "up" the call stack to call merge("AA", "BB") where we left off.
7. We start where we left off in call merge("AA", "BB"), in the else branch. There are no more statements or expressions in that call, so it's resolved. Again, there are no return statements so by default it returns undefined. We go "up" the call stack to call merge("AAA", "BBB") where we left off.
8. We start where we left off in call merge("AAA", "BBB"), in the else branch. There are no more statements or expressions in that call, so it's resolved. Again, there are no return statements so by default it returns undefined. There are no more calls, so everything's resolved - and merge("AAA", "BBB") returns undefined.

TL;DR: The recursive call is not returned on each call in the else branch, so the value of str3 is returned to the call merge("A", "B"). The call merge("A", "B") does not return anything, it returns undefined. The same goes for all other calls - they have no return statement in the else branch so undefined is returned. When all calls are resolved, undefined is returned.

Solution

The solution is to simply prepend return to your recursive calls. That way, the result of each call would be returned, 'delegating' the final returned value of str3 up the call stack - the call returns "ABABAB", not undefined.

Since we now return the result of the call, steps 6, 7, and 8 above now have a return statement. That means we don't return undefined, but instead str3. This is because merge("", "") returned "ABABAB", which is the value of str3. That result is then returned in call merge("A", "B") because of the new added return statement, which is then returned in call merge("AA", "BB"), and so on, until the call is completely resolved, and the returns the value of str3.

Here's the new code:

var str3 = "";function merge(str1, str2) {    if(str1.length == 0 || str2.length == 0) {        console.log(str3);        return str3;    } else {        str3 = str3 + str1.substring(0, 1) + str2.substring(0, 1);        return merge(str1.substring(1, str1.length), str2.substring(1, str2.length)); //we return the recursive call    }}
var mergedString = merge("AAA","BBB"); //mergedString is "ABABAB"

function countPositivesSumNegatives(input) {
    let countPositive = 0;
    let sumNegative = 0

    if (!input || input.length === 0){
      return [];
    } else {
      input.forEach(function(num){
        if (num > 0) {
          ++countPositive;
        } else { 
          sumNegative += num;
      });
    }
    return [countPositive, sumNegative];
}