CODEWITHSUNDEEP
javascriptnode.js
Kajiyama VK
Kajiyama VK

Reputation: 454

Why this callback is not running properly?

I'm a noob in coding. I'm really sorry about that. I have this code here....

function fn1(){
    setTimeout(function(){console.log("fn1")},3000)
}

function fn2(){

    console.log("fn2")

}

function fn3(callback, callback2){

    if(callback){
        console.log("It works!")
    } else {
        callback2
    }
    
    
}

fn3(fn1(),fn2())

The objective here is to call Function3(fn3) console.log ("It works") only after Function1(fn1) runs ok. If Function1 fails, it should return Function2.

The output that I'm getting is:

fn2
fn1

I know it is extremely wrong but I don't know WHAT is wrong. I know that there are other stuff (that I still don't know - like promises, async, await and stuff) but I wanna learn this method first.

Could you guys help me?

Upvotes: 0

Views: 174

Answers (3)

Guerric P
Guerric P

Reputation: 31835

You have to pass references on the functions as parameters of fn3 (you currently call them and pass their result).

Also, in the fn3, you need to call the function.

Your code fixed below (if I correctly understood what you were looking for):

function fn1(next) {
    setTimeout(next, 3000);
}

function fn2() {
    console.log("fn2")
}

function fn3(callback, callback2){

    function itWorks() {
        console.log('it works!');
    }

    try {
        callback(itWorks);
    }
    catch (e) {
        callback2();
    }
}

fn3(fn1, fn2); // Will display "it works!" after 3 seconds
fn3(undefined, fn2); // Will display "fn2" because trying to call an undefined function

Upvotes: 2

Ishank
Ishank

Reputation: 2926

I understood that you want to call f3 after the f1 is called successfully and call the f2 when f1 fails? If yes then see this

function fn3(){
    console.log("It Works!");
  }
  function fn2(){
    console.log("fn2");
  }
  function fn1(){
    const promisePass = new Promise((resolve, reject) => {
          setTimeout(resolve, 100)}); //Emulate success


    const promiseFail = new Promise((resolve, reject) => {
          setTimeout(reject, 100);});//Emulate fail


  promisePass.then(function(){
    fn3();
  }).catch(function(){
    fn2();
  });
  promiseFail.then(function(){
    fn3();
  }).catch(function(){
    fn2();
  });
  }
fn1(); //<<-- calling f1 now will pass and fail the setTimeout method and then 
   // fn2 and fn3 are called accordingly

Upvotes: 0

makmonty
makmonty

Reputation: 465

Yes, you are right. This is a huge nonsense.

Correct me if I'm wrong: you want the console to log "It works!" after the timeout set in the fn1. Then you'll need the fn1 to tell somehow that it finished it's execution so it can run the console.log. If you want to use the callback approach, then the fn1 could be something like:

function fn1(callback, errorCallback) {
  setTimeout(function() {
    try {
      callback();
    } catch (error) {
      errorCallback();
    }
  }, 3000);
}

And the fn3 could go like this:

function fn3() {
  fn1(function() { console.log('It works!'); }, fn2);
}

You can call fn3 just with fn3().

To be honest, as simple as these functions are, there's no way the fn2 is called as there are no errors in the code and no human interaction. Well, maybe if there's no standard output available to do the console.log, but I don't know if that's even possible.

As you can see, in the fn3 we are passing two functions as parameters to fn1. The first is an anonymous function that shows the text in the output. The second function is the fn2, that should be run in case of error. No parenthesis here when passing them as parameters as we want to pass functions, not the result of calling them (which would be undefined in this example).

The fn1 receives those functions as parameters and runs them in different situations. The first, when the timeout has finished, and the second if there's any error when calling the callback.

Upvotes: 2

Related Questions