- Recipe 1: using string functions on buffers
- Recipe 2: using string decoder
- Recipe 3: custom entrypoint for a node package
- Recipe 4: determining if package is executed as a script or if being required by another script
- Recipe 5: understanding how circular dependencies are dealt with in node
- Recipe 6: using C++ addons
- Recipe 7: Use case for process.nextTick
- Recipe 8: Providing Callback and Promise API to a function
- Recipe 9: extending eventEmitter, error event, multiple handlers, .once, .prependListener
- Recipe 11: Node.js REPL, loading modules into a session, TAB completion, _
- Recipe 12: using TCP sockets to create a basic chat server
- Recipe 13: getting familiar with the DNS module
- Recipe 14: getting familiar with the UDP/dgram module
- Recipe 15: error handling best practices
- Recipe 16: basics of unit testing code with Jest
- Recipe 17: using Jest mocks to isolate code from its dependencies for unit testing
- Recipe 18: using manual mocks in Jest to mock modules and complex behaviour
- Recipe 19: HTTP/HTTPS protocol functionality
- Recipe 20: using the fs module two fix corrupted files
- Recipe 21: script that removes files older than 7 days old in a directory
- Recipe 22: console log file events that occur in a given directory
- Recipe 23: demonstration on the improved scalability of streams
- Recipe 24: examples of stream implementations
- Recipe 25: 4 ways to create a new child process
- Recipe 26: examples of using fork()
- Recipe 27: improving cpu utilization using the cluster module
- Recipe 28: improving server availability using the cluster module
- Recipe 29: restarting worker processes one at a time for code updates
- [Recipe 30: playground for understanding Buffers and how they relate to strings]
- 1: Understanding how require works
- 2: CLI debugging
- 3: Chrome Dev Tools debugging
- 4: Understanding the Event Queue
- 5: 3 ways to create Buffers objects
- 6: Errors vs Exceptions
- 7: Streams and Pipes
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- the same methods are available for both strings and buffers
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- StringDecoder is more reliable than Buffer.toString() when receiving text expecially in Unicode in binary since some characters may span 16 bytes.
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- custom entrypoints to a package can be defined in the "main" property in the package.json file
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- require.main contains metadata regarding the entrypoint module for the executed script and it will be the exact same object as the module param wrapping the entrypoint script. This provides a means of determining how a module came to be executed.
- execute index.js which requires printStars.js or run printStars.js and provide the required command line arguments.
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- node will automatically deal with circular dependencies by only allowing the child module access to what has already been exported by the parent up until the point of the parent module requiring the child.
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
The binding.gyp and hello.cc files were obtained from the Node.js documents page on C++ addons. To
run the script perform the following steps:
- npm install
- npm run configure OR npx node-gyp configure
- a build folder will be created in the top-level recipe_6 directory
- npx will execute local modules instead of having to create a script for them
- npm run build OR npx node-gyp build
- npm start
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- the first version of fileSize mixes both async and sync operations
- Node.js best practices dictate that functions should be fully synchronous or asynchronous
- we use process.nextTick to simulate asynchronous behaviour from synchronous functions
- process.nextTick pushes the result to the front of the Node Event Queue
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- Demonstrates an easy way for providing both options for handling asynchronous operations
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- The error event is special because if an error event is emitted without a listener subscribed then the process will exit
- handlers are executed in the order with which they are registered to the event, this can be manipulated using .prependListener()
- a handler registered to an event using .once() will only fire the first time
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- using the event emitter to respond to keyboard inputs emulating a simple terminal app
Node.js: Getting Started, Samer Buna, Pluralsight, (September 11, 2018)
- further commands that can be executed from the REPL can be found using .help
- when in the REPL a single TAB keypress will complete the command if possible
- two consecutive TAB keypresses will print out a list of possible commands in the terminal window
- the _ variable represents the value of the last evaluated expression
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- the first example net.js is a simple echo server
- the second example net-multiple-clients.js connects several clients together
- net-improved-chat.js has some basic improvements on the underlying functionality
- these examples demonstrate the usage of standard TCP socket events such as connect, end and data
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- brief discussion on the differences between the lookup and resolve methods
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- brief of creating both a udp server and client
Node.js: Getting Started, Samer Buna, Pluralsight, (September 11, 2018)
- demonstrates how overly generic catch can mask underlying issues and provides an example of how to address the issue
Testing JavaScript for Node.js with Mocha, Jonathan Mills, Pluralsight, (May 4, 2017)
- using testing hooks (i.e. beforeAll, beforeEach, afterAll, afterEach) allows for convenience setup and teardown. Each hook is scoped to its parent describe block
- describe blocks and tests can invoke the only method and they will be the only tests that are run
- the skip method can be used to skip tests without having to comment them out
- the todo method can be used to document tests that need to be implemented later
- testing asynchronous methods using the callback method
- testing asynchronous methods returning Promises using special expect().resolve/reject methods
Testing JavaScript for Node.js with Mocha, Jonathan Mills, Pluralsight, (May 4, 2017)
- demonstrates how to use mock functions where the code being tested has dependencies that it either invokes, relies on for side effects or handles return values.
- also demonstrates custom matchers in the Jest expect library designed specifically for mocks
Testing JavaScript for Node.js with Mocha, Jonathan Mills, Pluralsight, (May 4, 2017)
- in this recipe I used a manual mock to mock the https modules request functionality which returns a stream to the callback it receives
- we start by invoking jest.mock('name_of_module) in our test file. This mocks out the module only for that file any other requiring of the module will recieve the original implementation.
- the jest.mock() will first look for a manual mock in a folder labeled __mocks__ at the same directory level as the module to be mocked
- in the manual mock file we call jest.createMockFromModule('name_of_module') which automocks the module. In this example I then extended the automocked module for the function .request()
- also created a mock of a user-defined module that returns a function that when executed return a function with private variables
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- understanding the stream/object types that are used in the http/https modules
- self-signing SSL certificates and setting up https protocol
- handling different routes and responding in various ways to requests
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- Challenge: given a directory of corrupted files that have had their content duplicated create a script that will remove the duplicated content.
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- the original challenge was to seed files to manually test the script, however, I added the jest testing and mocking
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- code shown was taken from example provided
- rename event occurs if file was added or removed
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- generates a file of several million lines of code and provides two api endpoints. A curl request to each will show significant differences when viewing the node process in the System Monitor
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- implementation of readable, writable, transformation and duplex streams
- these are implemented using the simplified constructor patterns
- this is an alternative to extending the base classes and implementing _read, _write, or _transform methods
- zip.js and unzip.js files demonstrate a more concrete implementation using pipes extensively
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- child process events:
- exit: child process completes
- disconnect: parent process manually calls child disconnect method
- error: fires when process cannot be manually disconnected or killed
- message: triggered when child process invokes the send() method (only available when using fork())
- close: emitted when stdio objects (out, in, err) of child process are closed
- the stdio objects of the child process emit standard stream events
- spawn()
- launches a command in a new child process
- DOES NOT by default create a new shell instance when issuing a command however, as in Example #4 this can be configured
- preferable to exec if data returned is large
- Example #4 shows how to setup child process to use its parent's stdio
- exec()
- launches a command but DOES start a new shell session for the command (therefore likely less efficient that spawn)
- will batch the output and then pass all data to a callback
- should only be used if returned data is small
- execFile()
- executes a file WITHOUT starting a new shell session. Therefore more efficient than exec but cannot use shell syntax
- fork()
- establishes an IPC connection between parent and child process which is accomplished using the send() command
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- this example demonstrates the performance improvements achieved by employing node clusters
- NOTE: when using clusters each worker process has its own namespace and therefore caching data and user sessions need to be handled either in database or in-memory storage such as redis
- it also demonstrates how to cache and share common data to further improve efficiency
- test load capabilities using apache benchmark tool
- Install apache bench
$ sudo apt install apache2-utils- Start node server
$ node server.js- Run apache bench
- makes 200 concurrent connections for 10 seconds
- provides statistics like
- requests per second
- time per request
$ ab -c200 -t10 http://localhost:8080/- Now run cluster.js instead and rerun apache bench
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- this example demonstrates how the cluster module can listen for crashed node processes and create a new process in response
- the availability of the system can be tested by using the same ab command as Recipe 27 and noting the Failed requests number
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- we issue the command for each worker to restart with:
$ kill -SIGUSR2 master_process_pidwhen a module is created we are given access to several local variables that may appear global. This is because when our module is required in the future Node is implicitly wrapping our code in the file with:
(function(exports, module, require, __dirname, __filename) {And:
return module.exports
})Going back to when our module is required by another module this wrapping is performed and then that new function is executed returning the module.exports as well as caching them for future use.
Steps performed by Node when requiring a module:
- Resolving, search default paths or turning relative to absolute path
- Loading, reading the file
- Wrapping the module in an IIFE, gives a module private scope
- Evaluating, what the vm does with the code in the module
- Caching to be reused
console logging the module object
- has an id property, '.' for startup file, absolute path for every module
- paths property which is an array of default paths to search for the module
- parent property, all modules that require the current module
- children, all modules required by the current module
- [Circular] denotes a circular dependencies
- exports, values exported by the module, values added to exports inside an async function will NOT be exported to the requiring module
# inspect argument differs from --inspect flag which is used when debugging with Chrome Dev Tools
# also applies to nodemon
$ node inspect <filename>
debug> list(10) # print the 10 lines above and below the current line the program is stopped on
debug> n # move to the next line of the program
debug> c # continue the program
debug> repl # can access program's current environment from here
# Set a breakpoint in a Node program
debugger; # include this in source code to cause the program to start there$ node --inspect <filename> # by defualt opens port 9229If debugging is required during app startup we can pause the program at the first line and wait for the debugger to attach by using the following command line argument
$ node --inspect-brk <filename>process.nextTick, setImmediate, timers and the Event Queue when the call stack is empty, Node retrieves the next job from the event queue, and push it to the call stack and move finish that job until:
- asynchronous functionality is reached, at which point the job is moved off the call stack and handled by Node, and the next job is taken from the event queue. Once the asynchronous job is completed it is moved to the event queue.
- the job is complete, the next job is taken from the event queue.
Asynchronous job generally consist of (also the order of priority each completed job enters and is removed from the event queue):
- process.nextTick (when called these jobs are pushed to the front of the Event Queue)
- setImmediate (basically a timer with a 0 ms. delay)
- timers
- I/O functions The above is
- alloc(), will allocate a buffer of the desired size and set the contents to empty (all zeros)
- allocUnsafe(), same as #1 but will not zero out the contents of the buffer has better performance than #1 but might cause side-effects
- from(), accepts one of several types and creates a buffer equal to the size of that object
const a = Buffer.alloc(8);
const b = Buffer.allocUnsage(8);
const c = Buffer.from('string');- An error is a "problem" whereas an exception is a "condition" (Node.js: Getting Started, Samer Buna, Pluralsight, (September 11, 2018))
- Fundamental question we need to ask ourselves is "Is it dangerous for the program to continue after this error has occurred if yes then we let the program fail. Usually this is the result of unforeseen issues however.
- Proceeding gracefully may simply mean we halt the process and inform the user that something wrong has occurred
Advanced Node.js, Samer Buna, Pluralsight, (February 16, 2017)
- Readable
- i.e. fs.createReadStream
- Writable
- i.e. fs.createWriteStream
- Duplex (Readable and Writable)
- i.e. net.Socket
- should be thought of as a grouping of two independent streams and not one with both capabilities
- Transform (used to modify data as it is written or read)
- i.e. zlib.createGzip
We use streams in one of two ways:
- Implement streams
- if we are implementing streams we are usually requiring the stream module
- Consume streams
- to consume streams we are usually piping or listening for stream events
- data (when data is being sent)
- end (no more data to be consumed)
- error
- close
- readable
- pipe(), unpipe()
- read(), unshift(), resume()
- pause(), isPaused()
- setEncoding()
- Paused
- need to use stream.read() to consume
- when an event handler is added to a stream it automatically switches to Flowing mode
- stream.resume() to manually switch to Flowing
- Flowing (data can be lost)
- need to listen to events to consume
- when an event handler is removed from a stream it automatically switches to Paused mode
- stream.pause() to manually switch to Paused
- drain (signal writable stream can receive more data)
- finish (all data has been flushed to writable stream)
- error
- close
- pipe/unpipe
- write()
- end()
- cork(), uncork()
- setDefaultEncoding()
a.pipe(b).pipe(c).pipe(d)
// assumes b & c are duplex streams
// equivalent to
a.pipe(b);
b.pipe(c);
c.pipe(d);- Generally we handles communication between streams on an evented basis OR using pipes
- simpler to use pipes, evented allows for greater customization