CLI NodeJS（并发，回调，.method）

Question

Just a couple of questions regarding using Nodejs in Web Development.

1) For my Concurrency question, it regards syntax. Is there a difference between:

setInterval(function() {
    console.log('Task A');
}, 10);

and

function setInterval() {
    console.log('Task A');
}, 10);

Also, i'm a little confused what the '10' means at the end of the method, my guess is the time it takes for the method to complete?

2) Callbacks - Are Callbacks just technically another name in Node for testing code?

3) Is there a method I can use in the Node(CLI) to see all of the methods in a module?

EX:

var fs = require('fs');

Obviously there are tons of methods in the File Systems module, but like the language Ruby, using PRY in the CLI, you can type 'fs.methods', which will display all of the methods. Then using 'cat', you can see the contents of each individual method. Something like this for Node(CLI)?

Thanks for all of the advice/answers!

Cheers, G

Answer 1

1. In the first, you pass in an anonymous function which will be invoked at the interval. Here you are using the node.js API setInterval.

In the second example, you are declaring a function called setInterval. Looks like a syntax error is there...

setInterval is a function that takes 2 objects in as parameters. That's it. the first parameter should be a function, and the second parameter should be a the the interval time in milliseconds. All that setInterval does is run the function passed in in the first parameter(a callback) every x milliseconds as specified in the 2nd parameter.

2. No. Callbacks are functions that can be passed to other functions so that they can be "called-back" later in the code. Callbacks are pervasive in node.js applications and tightly related to it's asynchronous event based architecture. It is one of the most common patterns seen in node.js.

3. Just look in node.js api docs on their website.

My recommendation to you would be to read about the node.js event loop and asynchronous programming.

Answer 2

First off, you're asking about some pretty fundamental aspects of Javascript so I'd suggest you work though some basic Javascript training because it will be hard to learn node.js if you don't already have a core understanding of the basics of Javascript. In particular callbacks are integral to much of nodejs coding.

Is there a difference between these two?

Yes, the two are completely different. One uses a built-in timer function, the other attempts to declare it's own function that has nothing to do with timers.

Let me explain your two examples:

The built-in setInterval function

setInterval(function() {
    console.log('Task A');
}, 10);

Nodejs has a built-in timer function called setInterval . You can find the doc for it here.

You pass this function two arguments. The first argument is a function reference, the second argument is an amount of time in milliseconds. The nodejs timer infrastructure will call the function you passed it every N milliseconds.

It might be slightly easier to understand how setInterval works by seeing it used like this:

function myFunction() {
    console.log('Task A');
}

setInterval(myFunction, 10);

This has the same output as your first example, but I think it shows more clearly how setInterval() is a built-in function that takes two arguments, a function and a number.

In your example, instead of the named function you are passing an anonymous function that simply does console.log('Task A'); and that function will be called every 10ms (approximately).

Create Your Own Function

 function setInterval() {
     console.log('Task A');
 }, 10);

This block of code is a Javascript Syntax Error and will not work. It looks like you're attempting to define your own function called setInterval() , but this is not the proper syntax for declaring a function.

You could make it legal syntax like this:

function setInterval() {
    console.log('Task A');
}

And, then you would call it like this:

 setInterval();

This has nothing to do with the previous example. This just creates a function that runs once each time you call it. If you actually gave it the same name as the global function setInterval() , then your local definition would replace it within the scope it was declared.

Your Other Questions

Also, i'm a little confused what the '10' means at the end of the method, my guess is the time it takes for the method to complete?

The 10 in the first example is the number of milliseconds for the interval timer. The 10 in the second example does not belong there - it's part of a Javascript syntax error.

Callbacks - Are Callbacks just technically another name in Node for testing code?

No. A callback is when a function takes an argument that is a function reference (eg the name of a function or an anonymous function). When you pass a callback to this function, you can expect that the function will call the callback one or more times at some time in the future. When exactly it is called or how many times it is called depends entirely upon what the function does and how it is written. The term "callback" comes from the notion that this function will be "called back" some time in the future.

Is there a method I can use in the Node(CLI) to see all of the methods in a module?

I'm not aware of a specific feature in the command line interface that will give you the methods of a module, but you can iterate them yourself or look at them in the debugger.

When you load a module in node with something like:

var fs = require('fs');

The object you get back from the require() function is a Javascript object. All the methods of that module are properties on that object. You can inspect that object in the debugger or with console.log(fs) or by writing code to iterate the properties of that object.

var fs = require('fs');
for (var prop in fs) {
    if (fs.hasOwnProperty(prop)) {
        console.log(prop);
    }
}