Section 1
Preview this deck
call the added "greet" function
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
1
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (229)
Section 1
(50 cards)
call the added "greet" function
available to be invoked / called thru javascript
function constructor
use the "new" keyword - calls the function, makes a new empty object, add properties and methods to that empty object, and returns that object automatically. - use a capital letter to help indicate that something is a constructor
output from node
console.log , just like for the browser
The fundamental question of Node JS
What does JavaScript need to manage a server?
process.binding
grab the C++ feature and make it available within the javascript when you use zlib you are using the JS library that wraps the C++ feature for you
Object Literal
Web Server / Browser
client / server model using the internet (http is standard Request & Response format)
name / value pair
can have other name value pairs
v8 can run standalone...
... or can be embedded into any C++ application there is an "embedder's guide" in the engine docs
Object
you need to explicitly make code available between modules
this won't just work
module.exports
only things attached to this will be exposed for outside use then if var greet = require('./greet') you can call greet( )
./
at the same folder level as where you are working
invoke
run or "call" the function, it's all the same
a c++ file that uses (includes) v8
this is a little shell -shell.cc, part of v8, - it passes whatever is given it to v8 and gives back whatever v8 gives back (may just be for windows powershell, not sure)
require
a function that takes the string of the path to the module you wish to import
Machine Language
some process converts your code into something the processor can understand - sometimes your code is converted into several different processor languages so it can be run in many places machine language speaks directly to the microprocessor
util.js
things you could have written yourself, but they have written for you (like isBoolean) - it's not a C++ wrapper
make new greet function available to JS via V8
Objects sit in memory and point to other values or objects
An expression
function expressions are possible in JS - you can make a function on the fly
Argument
Module
lots of other programming languages had this feature, but not JS (there were workarounds)
JavaScript Engine
when I run 'print', run this print function I added
can access the properties of any of your obj's prototypes
es6 class obj works with this,
adding "print" and "load" features to v8
Request & Response...
take standard formats
Levels of Abstraction
shell --print_code
will show you the generated machine code specific to YOUR computer's processor
First-Class functions
a lot of languages do NOT have this feature
a function can be passed around like a variable...
this is possible because functions are just special kinds of Objects no parens because you don't want to RUN the function and give it the result
function expression
this variable now has a function as its value it's still first class and can be passed around
Server
a computer performs services as requested
function statement
CommonJS
Node added the idea of modules based on commonjs
pass in the whole function...
javascript engine allows this kind of syntax
v8 hooks
if someone writes something in their JS code, it will cause MY C++ to run C++ has far more features than JS does (ex, can connect directly to a db) anything you can do in C++ can be made available to your JS
v8 normally...
constructor example
C++ greet function
Inheritance
Microprocessor Languages
Machine Code Example
what to do with what pieces of memory on your computer
v8 has sets of code for each microprocessor type
ECMAScript
the standard upon which JS is based browsers made different JS engines, and they need to conform to this core standard if you wrote your own engine, what you cause JS to do should match the spec
NodeJS webserver
CLI
Client
asks for services
Breakpoint
Section 2
(50 cards)
Listener
this function will be invoked when the event happen lots of listeners can be listening for one kind of event in the case of javascript, the listeners will be invoked one at a time
Event
we tend to conflate the 2 different kinds of events
using the real emitter is the SAME as the simple, fake one
... except var Emitter. require('events'); that's the native module
using the event emitter
require the emitter MANUALLY trigger the event with emtr.emit('greet'); all the functions in the array get called
Module pattern: replace module.exports with your own object constructor
a function constructor var greet3 = require('./greet3'); greet3.greet( ) if you make a change like greet3.greeting = "changed!" ... and then if you require the file again greet3b = require('./greet3') you will get "changed!" module returns CACHED module.exports even though your code calls new Greeter(), it is only ever really called once... but then you end up making only a single object but then everything references it, so all your changes persist
javascript quirk - assignment breaks reference
originally pointed to the same spot in memory; not anymore
Custom Events - in the javascript core, this is from the event emitter
often javascript code wraps the c++, so sometimes we respond to c++ events as if they were custom events core modules are built on top of this
set a variable to string, use that string in bracket syntax and you can access the property on an object
import from json as well...
exports is a shorthand for module.exports , they both point to the same memory location, UNTIL you ASSIGN exports to something
module.exports !== exports now
an array full of functions can then all be invoked
iterate over them with forEach and call them
the REAL event module...
has a lot more features but is very similar
JSON
pass by reference
prop1 is changed to a func and prop2 has been added when you pass in an object it will be mutated and when you are out of the function those changes will remain
pass by value
outputs 1
index.js
the entrypoint into a dir require('greet'), if it does not find a file, will look for a directory, and will look for index.js within that directory index can make multiple modules available as a single object (very common for the key and value to have the same names in this case)
modules help us move towards using javascript as a web server because...
Mutate
!!! if I say Person.prototype...
it's NOT the prototype of "Person", it's the prototype of any object created FROM "Person" - it establishes a prototype chain for all the obj you create!
Events aren't really special... they are just prototype properties associated with an array of functions that will be called when that property is accessed
the end of this file would say module.exports = Emitter; there is an events object that starts as an empty array, and then gets event names and arrays of their associated listeners
you can do things to a string or number immediately - 'John'.length, 3.round.... I want a function object I can do things to, so it needs to be an expression
(function( ){ }) - NOW it's a function object
Revealing Module Pattern
when you pass an object something vERY different happens - it is passed BY REFERENCE
Module pattern: returning the constructor itself so you make a new object each time the file is required
(gets around the problem from 71) var Greet4 = require('./greet4'); var greeter = new Greet4(); greeter.greet( );
every object has...
a prototype, which may have different properties than it does, but can be accessed alongside its own property (OH is this why hasOwnProperty exists? so you know what's yours vs. what's mom's?) many objects can point to the same object as its prototype
restricting scope by using an IIFE
first name will be 'Jane'
when you assign one value to another OR pass a primitive value to a function, it is passed BY VALUE
a copy of the primitive is made, and if you tweak b then a will NOT be affected
the idea of modules was added by node, but...
javascript engines, like v8, now support modules via es6
all objects made by the constructor can access property on the prototype
accessing native but NOT global node modules
use require: var util = require('util'); (NOTE it doesn't have ./ ... not having a path makes it look for a native module) util.log is nifty because it adds a timestamp
there are several ways to set up a prototype chain
function constructors, es6 class keyword (and "extends", which sets up the prototype chain) OR use an object literal let object use properties and methods of a different object makes it simple to create a sequence of objects
Primitive
you CAN pass things into an IIFE...
...it just looks kind weird
to use export in place of module.exports, DON'T assign it, MUTATE it
just tack things onto it :) to lower your cognitive load, you can just use module.exports, why not :)
.inherts sets up an empty "proto" middleman object
Module pattern: return an object from exports that reveals only what you wish (this is the revealing module pattern)
var greet5 = require('./greet5').greet; you cannot access or change the "greeting" variable
peek the prototype of "john" : var john = new Person('John', 'Doe')
john.__proto__ no need for this in real production code
.__proto__ for two things from the same constructor should point to the EXACT same prototype object
a reference to the SAME object
since module.exports in passed by reference, it becomes the window into your code
global node modules
you get just use them - like console.log
module pattern: overwriting exports with a single function
Scope
inheriting from the event emitter.
var greeter1 = new Greetr( ); greeter.on('greet', function( ) { console.log('Someone says hi'); }) greet1.greet( );
Magic String
event emitter, in our cases so far, is using a magic string could pull it out into a variable (remember that will work fine) - put it in a config file,
.on in the real module is just an alias for addListener
... and it has a change that it is a function, which makes it superior to ours
.inherits in util.js takes two function constructors
my code is wrapped by a function...
in module.js in the javascript side of node core
es6 module syntax
System Events - from the C++ side of the node core via library called libuv
events coming from the computer system: "I've finished reading the file" "the file is open" "I've received data from the internet we can then respond to those things happening with our code
Module pattern: add new property to the exports object
var greet2 = require(./greet2').greet;
Section 3
(50 cards)
binary data
bit - short for "binary digit" transistor - is electricity flowing or nah?
character encoding
the representation of characters on the keyboard with bytes, most having roots in the earliest standard, ASCII (American Standard Code for Information Interchange). from base10 to base2 !
Callback
this idea DOES exist in multiple languages, including C++
EventEmitter.call(this)
since it is passed by reference the EventEmitter will be called with this.greeting and the "this" object we make will definitely have all of the EventEmitter stuff as well as greeting
Non-blocking
node can go do something else while your javascript continues running when the v8 engine is no longer busy, then something can happen (?) having multiple sets of code running simultaneously is hard to manage node lets us write synchronous JS and pick up things that run asynchronously
Chunks
es6 typed arrays (nothing to do with node, a new feature of v8)
CAN deal with binary data nothing Int32 - a number stored with 32 0s and 1s can store 2 numbers in this view view here will let you put in regular base10 numbers but it will make binary again, node has nothing to do with this
example of util.inherits WITH the importance of .call
Person has this.firstname 'John' and a greet function the Policeman will be greeted with 'Hello undefined' "greet" is on the prototype, and THAT is connected up but the properties are not for that, you need .call to give context (the function constructor is never actually run, so he says)
callback example with params / data
Libuv
embedded inside node, handles system events manages events coming from the OS
Abstract (Base) Class
you never really make a new Stream you make some variable of stream
2. libuv picks up something from its queue that is complete, processes it, sees that they thing has a callback
callback involves running some javascript code node is async because both these things are going on at once, so he says... "event-driven non-blocking I/o in v8 javascript"
unicode character set example
Buffer object (it's global! and in JS! not unlike using new Date( ) )
created on c++ side, wrapped in JS buffer can hold binary data and will let us decode them
data sits on the heap
the memory space that the javascript engine is using - the buffer data sits there we need to minimize how much data we are working with at any one time instead the buffer
class syntax with a function
character set
A list of the characters and the codes used to represent each one
Buffer
just a spot in memory... gather some data, and move it along Buffer (usually) moves through stream
objects can do things and...
emit events, because they have the eventEmitter in their prototype chain
.call can change the "this"
run the function on whatever "this" you provide so you can send in another object entirely obj.greet( ) outputs "Hello John Doe" because of the internal object and obj.greet.call({name: 'Jane Doe'}) gives "Hello Jane Doe"
stream.js - now there are several types of streams
built on top of the eventEmitter streams are merely an abstract class...
template literal
you would have to convert this with babel in the browser, but node knows how to handle it
fs.readSync
var fs = require('fs'); var myFileContents = fs.readFileSync(__dirname + './myFile.text', 'utf8'); console.log(myFileContents);
use jsconfig to make vscode not complain about es6 feature
util.inherits is extending EventEmitter
create new objects that have a combination of new properties and inherited properties
Stream
speed of the stream may be impacted by, say, your internet connection speed usually as the stream runs, something gathers and processes it
Synchronous
v8 (javascript) is synchronous, but node is asynchronous
buffers may be coming back from a feature within node...
... but you rarely have to deal with them directly
otherwise buffer behaves like an array console.log(buf[2])
outputs 108 which is... l
.apply is the same as .call but takes its params in an ARRAY (and params and the SECOND argument in both cases)
obj.call({name: 'Jane'}, param1, param2, param3) obj.apply({name: 'Jane'}, [param1, param2, param3])
var buf = new Buffer('Hello, 'utf8') console.log(buf)
(utf8 is default anyway) outputs in hexadecimal notation (which is binary but easier to read)
var buf = new Buffer('Hello, 'utf8'); console.log(buf); console.log(buf.toString( ) ); console.log(buf.toJSON( ) );
string will put it back to 'Hello', JSON will build an JSON with 'type' and 'data' keys
... use .call t get properties
Person has this.firstname 'John' and a greet function Person.call(this) will send an empty object, a place to hold properties that allows first name to be attached to it ...then within Policeman badge number will ALSO be attached the Policeman will be greeted with 'Hello John'
if you have many simultaneous users, you don't want to read synchronously (especially if the file is very large)
var fs = require('fs'); var myOtherFileContents = fs.read(__dirname + './myOtherFile.text', function(err, data ) { <do something> }'utf8'); console.log(myFileContents); hey, c++, go do your thing and get file contents, the javascript that outputs it will run when you are done 'Done!' will run right after the sync fs is done, because it could, and THEN the async fs will finish
can also add in parameters
class syntax with properties
you still can call new Person(firstname, lastname)
class syntax with the EventEmitter
constructor doesn't have any params because we don't need any extends instead of util.inherits calling super( ) calls EventEmitter ensuring all its properties go onto the prototype greet function is put onto the prototype (SO class is building a prototype !)
"buffering"
gathering enough data until you can continue to, say, watch video
Stream + Buffer
data comes down the stream, a certain amount is gathered into the buffer, then that subset of data is processed, something is done with it when continue to get data until the stream is done
utf8 - each character gets 8 bits to encode it, even if the unicode number doesn't make it look like it needs all of them
set - what number represents each character encoding - how many numbers will we use to store it ... javascript isn't good at the encoding node expands on js to let us deal better with binary data
callback simple example
1. libuv runs through its queue while, simultaneously, v8 is synchronously running
babeljs.io
will let you write es6 in the browser
Asynchronous
byte
8 zeros and ones
libuv
asynchronous I/o made simple libuv.org written in c uv_run (in core.c) is its primary loop, checking for things to invoke, listening for events
Error-First Callbacks
a standard pattern by default a callback's first parameter is an error, and if there is no error it is "null"
you can write to a buffer buf.write('wo') console.log(buf.toString( ) )
..it will overwrite part of what would otherwise be there, it's a finite amount of space wollo
class expression exported from a module, put it in greetr.js then call the constructor function
var Greetr = require('./greetr'); var greeter1 = new Greetr( ); greeter1.on('greet, function(data) { console.log('someone greeted: ' + data) }); greeter.greet('Tony'); event is received and we get 'someone greeted: Tony'
syntactic sugar
Section 4
(50 cards)
Routing
choose to give different content based on different urls
a more robust implementation of the read / write we wrote
pipe returns its destination to us
writeable stream - write from one file to another
listen for the data event, then write didn't need a big buffer to work with the file
port mapping to connect up to the right program
we often specify 80 is a typical default (?)
we think of node as being a web server...
BUT you could use it to build a mail server, a file server, etc.
Pipe
conditional logic on the req to route
return different responses from '/' and '/api'
Send template data to the html
<h1>{Message}</h1> template engines aren't in the nodeJS core, but of course we know they exist externally
stream to stream to stream - chaining
node likes it when we work with streams, because it helps it be performant tend towards asynchronous methods and streams
Endpoint
http.js ALSO wraps eventEmitter
there is also https.js to deal with secure connections contains .createServer
Package
machine code is running once you have started the server...
so if you have made an update you need to restart the server every time you change content
TCP is the same CONCEPT as a stream...
... so node treats them as a stream
send an html file
Protocol
see it come back as text but in smaller chunks (specify the buffer size) then measure the length of each chunk
16384, 16384, 16384, 12456
Patch
fs.js lets you look at a concrete implementation of stream, it makes a new ReadStream (a specialized type of readable stream)
_http_server.js wraps http_parser...
and has the idea of status codes
http
Serialize
usually serialize "turn it into json" and deserialize "turn it back into a javascript object"
now we know how to do everything for a web server but deal with databases...
socket
the connection between two computers - with the internet, we are opening and closing them constantly a web socket is open all the time (?)
http_parser
a c program from joyent - parses requests and response the node js JavaScript side of the core has a wrapper for it
use stream to get the html in a more performant way
response is a writeable stream we have a readable file, pipe it into the response (sending it a chunk at a time in a stream)
Dependency
zlib
gzip is an algorithm to compress files zlib will do this compression for you
Now we are closer to being able to have a web server...
Template
readableStream
readable stream inherits from Stream readable is a type of stream... and also a type of event emitter... since stream is a type of event emitter
outputting json - essentially an API endpoint
any application in any language could come and grab the data from this url
reading in a big file, a 'data' event will fire when the buffer fills up
we can console out each chunk of data as the buffer fills
neat read / write using pipe
Versioning
the numbers MEAN something - that makes it "semantic" semver.org
Method Chaining
Readable.prototype.pipe
socket opens between two ips
tcp knows how to take information in one of the protocols (smtp, http, ftp) and send it over the socket
Package Management
Mime type
http response example
port
prototype chain including stream
http request example with headers
== vs. ===
== tries to convert one side to match the other, just in case - coercion!
pipe from readable to readable&writeable
writeable and readable...
... from node's perspective
pipe from readable to writeable...
tcp sends info over a bit at a time, in packets
node can create a socket and send information
API
Section 5
(29 cards)