Node.js basics

about me
Ben Lin
A full time entrepreneur
Fall in love with node.js on Jun 2011

dreamerslab.com
ben@dreamerslab.com
twitter.com/dreamerslab

Agenda

1. Dev environment setup
2. npm common commands
3. Execute javascript ﬁles
4. Use external ﬁles
5. Function scopes and closures
6. `this` keyword
7. Call and apply
8. Callbacks
9. Events

Source
Slide : Online tutorial :
http://www.slideshare.net/BenLin2/nodejs- - Install
basics Ubuntu : http://bit.ly/sz4peA
Example code: Mac: http://bit.ly/upnmSi
https://github.com/dreamerslab/ - Basics
nodejs.basics http://bit.ly/sO2lpt
http://bit.ly/vdI4yN
http://bit.ly/rrtun6
http://bit.ly/vk7Mfv
http://bit.ly/vKKjCK
http://bit.ly/tJf3aR
http://bit.ly/tXJ7z2

Dev environment setup
Ubuntu
# Install node
sudo apt-get install python-software-properties
sudo add-apt-repository ppa:chris-lea/node.js
sudo apt-get update
sudo apt-get install nodejs
sudo apt-get install nodejs-dev

# Install npm
curl http://npmjs.org/install.sh | sudo clean=no sh

# Install mongodb
sudo su
apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
echo "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart
dist 10gen" >> /etc/apt/sources.list
apt-get update
apt-get install mongodb-10gen
exit

Dev environment setup
Mac
# Install homebrew
ruby -e "$(curl -fsSLk https://gist.github.com/raw/
323731/install_homebrew.rb)"

# Install Xcode

# Install node
brew update
brew install node

# Install npm
curl http://npmjs.org/install.sh | sudo clean=no sh

# Install mongodb
brew install mongodb

# Create db directory
mkdir /usr/local/db

npm common commands
Install package globally. Global packages are usually for executable
commands.

npm install <package name> -g
# example
npm install express -g
# now we can use express to generate a new app
express new app

Install package locally. Local packages are for the use of require in
the app.

cd /path/to/the/project
npm install <package name>
# example
npm install express
# now you can use `var express = require( 'express' );` in your app

npm common commands
Uninstall global package.
npm uninstall <package name> -g
# example
npm uninstall express -g

Uninstall local package.

npm uninstall <package name>
# example
npm uninstall express

Search package.

npm search <package name>
# example
npm search express

npm common commands
List global packages.
npm ls -g
Update global packages.
npm update -g
List global packages detail.
npm ls -gl
Update local packages.
List local packages. npm update

npm ls

List local packages detail.
npm ls -l

npm common commands
Using package.json to manage your app packages

Instead of doing

npm install mongoose
npm install express
npm install jade

npm common commands
Using package.json to manage your app packages

Create a package.json ﬁle in the root of your app dir

{
"name": "your app name"
, "version": "0.0.1"
, "private": true
, "dependencies": {
"express": ">=2.5.0"
, "jade": ">= 0.16.4"
, "mongoose": ">=2.3.10"
}
}

npm install -l

Execute javascript ﬁles

cd ~/Desktop
touch hey.js
echo "console.log( 'Hey you' );" >> hey.js
node hey.js
# -> Hey you

Use external ﬁles

node.js followsCommonJS
conventions. It uses require and
exports to communicate between
ﬁles and modules.

Use external files
source.txt
I am Ben.

read.js | Read the source file and print to the terminal

// require core module `file system`
var fs = require( 'fs' );

// exports 2 methods for other modules or files to use
module.exports = {
read : function( path, callback ){
// read file data synchronizely
var data = fs.readFileSync( path );

// execute the callback if there is one
callback && callback( data.toString());
},

print : function( data ){
// print out the data
console.log( data );
}
};

Use external files
write.js | Split the write action to this file

// require core module `file system`
var fs = require( 'fs' );

// exports 1 method for other modules or files to use
module.exports = {
write : function( filename, data ){
// write to file synchronizely
fs.writeFileSync( filename, data );
}
};

Use external files
run.js | Flow control

// to use methods from other files we simply use `require` with path name
var reader = require( './read' ),
writer = require( './write' );

// call `read` method from read.js to read `source.txt`
reader.read( './source.txt', function( data ){
// change Ì am` to `You are`
var changed = data.replace( 'I am', 'You are' );

// print out the data
reader.print( data );

// save the changes to `changed.txt`
writer.write( './changed.txt', changed );
});

change.txt | Result

You are Ben.

Use external ﬁles

What’s the differences between the following 3?

var something = require( './something' );
var something = require( './something.js' );
var something = require( 'something' );

Use external ﬁles
exports VS module.exports

Using module.exports

module.exports = {
do_a : function(){
// do something ...
},
do_b : function(){
// do something ...
}
};

Use external ﬁles

Using exports

exports.do_a = function(){
// do something ...
};

exports.do_b = function(){
// do something ...
};

Use external ﬁles

We can use both in another ﬁle with


something.do_a();
something.so_b();

Use external ﬁles

What if we want to use the entire module as a function like the following?


something();

Use external ﬁles

// this works
module.exports = function(){
// do something
};

// this is not going to work
exports = function(){
// do something
};

Use external ﬁles

require only loads the ﬁle once and
will store them in the memory, so don’t be
afraid to use it.

Function scope

Javascript uses function as scope.
Declare a function inside another
function creates a different scope.

Function scope
function outer_scope(){
var a = 'I am `a` from outer scope',
b = 'I am `b` from outer scope';

console.log( 'logging from outer scope before inner scope function declaration' );
console.log( 'a: ' + a );
console.log( 'b: ' + b );
console.log( '------------------------------------------' );

function inner_scope_1(){
console.log( 'logging from inside function inner_scope_1 before variable declaration' );
a = 'I will overwrite the outer scope `a`';
console.log( 'logging from inside function inner_scope_1 after variable declaration' );
console.log( '------------------------------------------' );
}

var b = 'I will not overwrite the outer scope `b`';
console.log( '------------------------------------------' );
}

Function scope
var b = 'I will not overwrite the outer scope `b`';
console.log( '------------------------------------------' );
}

inner_scope_1();
inner_scope_2();

a = 'I will be the new `a`';
b = 'I will be the new `b`';

console.log( 'logging from outer scope after inner scope executed' );
console.log( '------------------------------------------' );
}

outer_scope();

Function scope

logging from outer scope before inner scope function declaration
a: I am à` from outer scope
b: I am `b` from outer scope
------------------------------------------
logging from inside function inner_scope_1 before variable declaration
a: I am à` from outer scope
logging from inside function inner_scope_1 after variable declaration
a: I will overwrite the outer scope à`
------------------------------------------
logging from inside function inner_scope_2 before variable declaration
b: undefined
logging from inside function inner_scope_2 after variable declaration
b: I will not overwrite the outer scope `b`
------------------------------------------
logging from outer scope after inner scope executed
b: I will be the new `b`
b: I will be the new `b`
------------------------------------------

Closure

A closure is a function together
with a referencing environment for the
non-local variables of that function.

Closure
function photo(){
var name = 'ben';

return{
say_my_name : function(){
console.log( name );
},

rename : function( new_name ){
name = new_name;
}
};
}

var pic = new photo;

pic.say_my_name();

pic.rename( 'bibi' );

pic.say_my_name();

Javascript `this`
this points to the current scope object.
var something, another;

something = {

x : 'x',

print : function( callback ){
callback && callback.call( this );
console.log( this.x );
}
};

another = {

x : 'a',

set_x : function(){
this.x = 'b';
}
};

Javascript `this`
this points to the current scope object.
// situation a
something.print( function(){
another.set_x();
});

// situation b
something.print( another.set_x );

// situation c
something.print( function(){
another.set_x.call( this );
});

Javascript `this`
Common mistake
var example = {

name : 'who',

wrong : function(){
setTimeout( function(){
console.log( this.name );
}, 0 );
},

right : function(){
var self = this;

console.log( self.name );
}, 0 );
}
};

example.wrong();
example.right();

call and apply
call and apply invoke the function and switch the
function context with the ﬁrst argument

function fn( arg1, arg2,... ){
// do something
}

fn( arg1, arg2,... );

fn.call( context, arg1, arg2,... );

fn.apply( context, [ arg1, arg2,... ]);

call and apply
A real world use case
function Album( id, title, owner_id ){
this.id = id;
this.name = title;
this.owner_id = owner_id;
};

Album.prototype.get_owner = function( callback ){
var self = this;

$.get( '/owners/' + this.owner_id , function( data ){
callback && callback.call( self, data.name );
});
};

var album = new Album( 1, 'node.js conf', 2 );

album.get_owner( function( owner ){
alert( 'The album' + this.name + ' belongs to ' + owner );
});

call and apply

Speed
Function invoke with call is slightly faster than with apply. But
don’t worry, you really can’t tell the difference, use whatever suits
you.

Callbacks

A callback is a function to be
executed after another function is
executed.

Callbacks

Normal case
function do_a(){
console.log( '`do_a`: this comes out ﬁrst');
}

function do_b(){
console.log( '`do_b`: this comes out later' );
}

do_a();
do_b();

Result

`do_a`: this comes out ﬁrst
`do_b`: this comes out later

Callbacks
This might happen
function do_a(){
console.log( '`do_a`: this takes longer than `do_b` ');
}, 3000 );
}

function do_b(){
console.log( '`do_b`: this is supposed to come out after `do_a`
but it comes out before `do_a`' );
}

do_a();
do_b();

Result
`do_b`: this is supposed to come out after `do_a` but it comes out before `do_a`
`do_a`: this takes longer than `do_b`

Callbacks
The right way
function do_a( callback ){
// simulate a time consuming function
console.log( '`do_a`: this takes longer than `do_b`' );

// if callback exist execute it
callback && callback();
}, 3000 );
}

function do_b(){
console.log( '`do_b`: now we can make sure `do_b` comes out after `do_a`' );
}

do_a( function(){
do_b();
});

Result

`do_a`: this takes longer than `do_b`
`do_b`: now we can make sure `do_b` comes out after `do_a`

Callbacks
Different ways of applying a callback
function basic( callback ){
console.log( 'do something here' );

var result = 'i am the result of `do something` to be past to the callback';

callback && callback( result );
}

basic( function( result ){
console.log( 'this callback is going to print out the result from the function `basic`' );
console.log( result );
});

Result

do something here
this callback is going to print out the result from the function `basic`
i am the result of `do something` to be past to the callback

Callbacks
function callbacks_with_call( arg1, arg2, callback ){

var result1 = arg1.replace( 'argument', 'result' ),
result2 = arg2.replace( 'argument', 'result' );

this.data = 'i am some data that can be use for the callback funciton with `this`
key word';

callback && callback.call( this, result1, result2 );
}

( function(){
var arg1 = 'i am argument1',
arg2 = 'i am argument2';

callbacks_with_call( arg1, arg2, function( result1, result2 ){
console.log( 'this callback is going to print out the results from the function
`callbacks_with_call`' );
console.log( 'result1: ' + result1 );
console.log( 'data from `callbacks_with_call`: ' + this.data );
});
})();

Callbacks

Result

do something here
this callback is going to print out the results from the function `callbacks_with_call`
result1: i am result1
data from `callbacks_with_call`: i am some data that can be use for the callback
function with `this` key word

Callbacks

// this is similar to `callbacks_with_call`
// the only difference is we use `apply` instead of `call`
// so we need to pass arguments as an array
function callbacks_with_apply( arg1, arg2, callback ){

var result1 = arg1.replace( 'argument', 'result' ),
result2 = arg2.replace( 'argument', 'result' );

this.data = 'i am some data that can be use for the callback function with
`this` key word';

callback && callback.apply( this, [ result1, result2 ]);
}

Callbacks
( function(){
var arg1 = 'i am argument1',
arg2 = 'i am argument2';

callbacks_with_apply( arg1, arg2, function( result1, result2 ){
console.log( 'this callback is going to print out the result from the function `callbacks_with_apply`' );
console.log( 'data from `callbacks_with_apply`: ' + this.data );
});
})();

Result
do something here
this callback is going to print out the result from the function `callbacks_with_apply`
data from `callbacks_with_apply`: i am some data that can be use for the callback
function with `this` key word

Events

Because javascript is an event driven
language, we often have to deal with nested
callbacks. It looks ugly and your code is
tighten up.
do_a( function(){
do_b( function(){
do_c( function(){
do_d( function(){
...
});
});
});
});

Events

With EventEmitter of node.js
events module we can ﬂatten the nested
callbacks

event.js
var event = require( 'events' ).EventEmitter;

module.exports = new event;

Events
do_a.js
var event = require( './event' );

console.log( 'we are going to call do_a' );
event.emit( 'do_a' );
};

do_b.js

event.on( 'do_a', function(){
console.log( 'we are going to call do_b' );
event.emit( 'do_b' );
});
};

Events
do_c.js

event.on( 'do_b', function(){
console.log( 'we are going to call do_c' );
event.emit( 'do_c' );
});
};

do_d.js

event.on( 'do_c', function(){
console.log( 'we are going to call do_d' );
event.emit( 'do_d' );
});
};

Events
run.js
var event, todos;

event = require( './event' );
todos = [ './do_d', './do_c', './do_b', './do_a' ];

event.on( 'do_a', function(){
console.log( 'i can do something to do_a out side of do_a' );
});

event.on( 'do_b', function(){
console.log( 'i can do something to do_b out side of do_b' );
});

event.on( 'do_c', function(){
console.log( 'i can do something to do_c out side of do_c' );
});

event.on( 'do_d', function(){
console.log( 'i can do something to do_d out side of do_d' );
});

todos.forEach( function( name ){
require( name )();
});

Node.js basics

More Related Content

What's hot (20)

Similar to Node.js basics (20)

More from Ben Lin (7)

Recently uploaded (20)

Node.js basics

Editor's Notes