Example 1:
var events = require('events');
var eventEmitter = new events.EventEmitter();
var connectHandler = function connected() {
console.log('connection succesful.');
eventEmitter.emit('data_received');
}
eventEmitter.on('connection', connectHandler);
eventEmitter.on('data_received', function() {
console.log('data received succesfully.');
});
eventEmitter.emit('connection');
console.log("Program Ended.");
Example 2:
var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
if (err) return console.error(err);
console.log(data.toString());
});
console.log("Program Ended");
Example 3:
var fs = require("fs");
var data = fs.readFileSync('input.txt');
console.log(data.toString());
console.log("Program Ended");
Example 4:
function a_function(fn) {
console.log('before');
// call the call back function. It requires 2 arguments.
var result = fn(4, 5);
console.log('after');
return result;
}
function test() {
var result = a_function(function(x, y) {
var value = x + y;
console.log(value);
return value;
});
console.log('result: ' + result);
}
test()
Example 5:
function test(container)
{
var idx = 0;
while (idx < container.length)
{
console.log('item: ' + container[idx]);
idx += 1;
}
}
var container = [11, 22, 33, ];
test(container);
Example 6:
// Node program to demonstrate theurl object properties
// Get different parts of the URL
// using object properties
const url = require('url');
// URL address
const address ='https://smarteportal.blogspot.com';
// Call parse() method using url module
let urlObject = url.parse(address, true);
console.log('Url host');
// Returns 'smarteportal.blogspot.com'
console.log(urlObject.host);
console.log('Url pathname');
console.log(urlObject.pathname);
console.log('Url search');
console.log(urlObject.search);
let queryData = urlObject.query;
console.log(queryData);
console.log('Url query object');
console.log(queryData.lang);
Example 7:
const http = require('http')
const hostname = '127.0.0.1'
const port = 8000
const server = http.createServer((req, res) =>
{
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
server.listen(port, hostname, () =>
{
console.log(`Server running at http://${hostname}:${port}/`)
})
Example 8:
var Calc = function() {
'use strict';
this.vars = {
pi: Math.PI
};
};
Calc.prototype.evaluate = function(expression) {
'use strict';
// Trigger final instruction to execute at end.
expression += ' ';
// Loop Variables
var length = expression.length,
iter,
char,
type;
// Flags
var flag_number = false,
flag_float = false,
flag_keyword = false,
flag_operator = false,
flag_operator_waiting = false,
flag_brackets = 0,
flag_var = false,
flag_var_name = '',
flag_math = false,
flag_math_op = '';
// Parser Variables
var buffer = '',
total = 0,
cur_operator = null,
buffer_parsed = 0;
// Math Functions
var stdOps = ['log', 'tan'],
customOps = {
fact: function(value) {
var iter,
multiplier;
for(multiplier = value - 1; multiplier > 0; --multiplier) {
value *= multiplier;
}
return value;
},
sin: function(value) {
return Math.sin(value * Math.PI / 180);
},
cos: function(value) {
return Math.cos(value * Math.PI / 180);
}
};
// Helper Functions
function isAlpha(char) {
return 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(char) !== -1;
}
function isNumeric(char) {
return '1234567890.,'.indexOf(char) !== -1;
}
function isSpecial(char) {
return '+-*/^'.indexOf(char) !== -1;
}
function applyOperator(left, right, operator) {
// Addition
if(operator === '+') {
return left + right;
}
// Subtraction
if(operator === '-') {
return left - right;
}
// Division
if(operator === '/') {
return left / right;
}
// Multiplication
if(operator === '*') {
return left * right;
}
if(operator === '^') {
return Math.pow(left, right);
}
return null;
}
for(iter = 0; iter < length; ++iter) {
char = expression.charAt(iter);
// Are we parsing a number
if(flag_number) {
// The number has finished
if(!isNumeric(char)) {
if(isSpecial(buffer) && !isSpecial(char)) {
flag_number = false;
flag_operator = false;
}
// Is it a float?
if(flag_float) {
buffer_parsed = parseFloat(buffer, 10);
} else {
buffer_parsed = parseInt(buffer, 10);
}
// Is there an operator waiting?
if(cur_operator !== '' && cur_operator !== null) {
total = applyOperator(total, buffer_parsed, cur_operator);
// Reset flags
flag_number = false;
flag_float = false;
flag_operator_waiting = false;
// Unkown operator
if(total === null) {
process.stdout.write('Unrecognised operator ' + cur_operator);
break;
}
// Reset current operator
cur_operator = '';
} else {
// Is a mathematical function waiting? (sin, cos, tan etc)
if(flag_math) {
flag_math = false;
buffer = flag_math_op(buffer_parsed).toString();
// Check if float
if(buffer.indexOf('.') !== -1) {
flag_float = true;
}
iter--;
continue;
}
// Else it's just a number, function call, or variable at the beginning of the expression
total = buffer_parsed;
flag_number = false;
}
buffer = '';
cur_operator = '';
} else {
// Check for float
if(char === '.') {
flag_float = true;
}
// Allow for commas
if(char === ',') {
continue;
}
buffer += char;
continue;
}
}
if(flag_keyword) {
if(!isAlpha(char)) {
flag_keyword = false;
// Case insensitivity
buffer = buffer.toLocaleLowerCase(buffer);
switch(buffer) {
case 'exit':
process.exit();
break;
case 'set':
// setting a variable
flag_var = true;
default:
// Standard Math.[sin|cos|tan|log] operations
if(stdOps.indexOf(buffer) !== -1) {
flag_math = true;
flag_math_op = Math[buffer];
}
// Custom operations: fact (factorial)
if(buffer in customOps) {
flag_math = true;
flag_math_op = customOps[buffer];
}
// If not mathematical function, it must be a variable
if(!flag_math) {
// Are we setting a variable?
if(flag_var) {
flag_var_name = buffer;
} else {
// We are referencing a variable, not setting it
if(buffer in this.vars) {
buffer = this.vars[buffer].toString();
flag_number = true;
// Check if variable is float
if(buffer.indexOf('.') !== -1) {
flag_float = true;
}
--iter;
continue;
}
}
}
}
buffer = '';
} else {
buffer += char;
continue;
}
}
// Are we parsing an operator?
if(flag_operator) {
// Are we ending an operator?
if(!isSpecial(char) || char === '-' || char === '+') {
// reset flags
flag_operator = false;
cur_operator = buffer;
// reset buffer
buffer = '';
flag_operator_waiting = true;
if(char === '-' || char === '+') {
flag_number = true;
buffer += char;
continue;
}
} else {
buffer += char;
continue;
}
}
// A number has started
if(isNumeric(char)) {
flag_number = true;
buffer += char;
continue;
}
// A keyword, variable or function has started
if(isAlpha(char)) {
flag_keyword = true;
buffer += char;
continue;
}
// An operator has started
if(isSpecial(char)) {
if((char === '-' || char === '+') && (flag_operator_waiting || flag_math)) {
buffer += char;
flag_number = true;
continue;
} else {
flag_operator = true;
buffer += char;
continue;
}
}
// Parse parentheses
if(char === '(') {
var bIndex = expression.indexOf(')', iter + 1);
if(bIndex !== -1) {
// extract and independtly evaluate this sub-expression, in a recursive fashion
buffer = this.evaluate(expression.substring(iter + 1, bIndex)).toString();
flag_number = true;
flag_float = buffer.indexOf('.') !== -1;
iter = bIndex;
continue;
} else {
console.log("Invalid bracket syntax");
break;
}
}
}
// We are setting a variable
if(flag_var) {
this.vars[flag_var_name] = total;
}
return total;
};
var calc = new Calc();
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(expression) {
console.log(calc.evaluate(expression))
process.stdout.write("> ");
});
console.log("Welcome to calc.js:");
process.stdout.write("> ");
Example 9:
let os=require('os');
let totalmemory=os.totalmem();
let freememory=os.freemem();
console.log('total memory:' +totalmemory);
console.log('free memory:' +freememory);
console.log('Total Memory: ${totalMemory}')
console.log('Free Memory: ${freeMemory}')
Example 10:
// Throws with a ReferenceError because b is undefined
try
{
const a = 1;
const b = 1;
const c = a + b;
console.log(c);
}
catch (err)
{
console.log(err);
}