dstructures

Question 1

js: a blob is

Answer 1

the binary string of an entire file stored in ram. Like a file stored fully in ram.

Question 2

cs: a binary is

Answer 2

a string sequence of 0s or 1s that make up any file

Question 3

cs: a bit is

Answer 3

a string, either 0 or 1

Question 4

cs: a byte is

Answer 4

a string of 8 bits (which are either 0 or 1)

Question 5

cs: All digital media (text, pictures, videos, etc) is

Answer 5

stored as bits at the lowest level

Question 6

cs: bit stands for

Answer 6

binary digit

https://medium.freecodecamp.org/do-you-want-a-better-understanding-of-buffer-in-node-js-check-this-out-2e29de2968e8

Question 7

cs: To save a number, a computer must first

Answer 7

convert it to its binary representation whic is the same number written in base-2. So, 3 becomes 11.

Question 8

cs: To save a letter, a computer must first

Answer 8

convert it to a number (using the character to number dictionary called character set, usually unicode), and then convert that number into binary aka base-2.

Question 9

cs: To know which letter corresponds with which number, a computer must check the

Answer 9

character to number dictionary, aka, character set, usually unicode

Question 10

cs: The most common character set is

Answer 10

Unicode

Question 11

cs: A character set is

Answer 11

a character to number dictionary

Question 12

cs: A character encoding is a

Answer 12

set of rules about how to format the binary you created from a letter

Question 13

cs: The most popular character encoding it

Answer 13

UTF-8

Question 14

cs: The UTF-8 rules about converting a character to a byte force you to

Answer 14

save into a bytes (8 digits). When the letter’s number’s base-2 version is less than 8 digits, you must add 0s to the beginning of the byte.

Question 15

cs: Chunks are kinda big

Answer 15

a large text file can have just 2 chunks.

Question 16

js: During a stream, node automatically creates

Answer 16

an internal buffer

Question 17

cs: The three types of stream are

Answer 17

readable, writable and duplex

Question 18

cs: Some common uses of streams are

Answer 18

reading and writing to disk, sending response to client from server, console.log()

Question 19

cs: In http streams, usually

Answer 19

an internal buffer in ram gets filled with bytes, and then when the internal buffer is full it sends a chunk to the client and asks for new data.

https: //www.youtube.com/watch?v=GpGTYp_G9VE
https: //www.youtube.com/watch?v=YpVDaVufDVU

Question 20

cs: streams emit

Answer 20

events, like data and end

Question 21

node: To write a script that echos back whatever you type into the console, type

Answer 21

process. stdin.pipe(process.stdout)

process. stdout is a callback function that gets the process.stdin return as a parameter

Question 22

cs: To start a stream’s transfer of bits, type

Answer 22

myStream.read()

Question 23

cs: A buffer is

Answer 23

an object that holds binary string
held in ram
fills with data up to allocated limit

https: //nodejs.org/api/stream.html#stream_buffering
https: //hackernoon.com/https-medium-com-amanhimself-converting-a-buffer-to-json-and-utf8-strings-in-nodejs-2150b1e3de57
https: //allenkim67.github.io/programming/2016/05/17/nodejs-buffer-tutorial.html

Question 24

js: A stream is basically an

Answer 24

object that spits out bytes of data continuously into an internal buffer which fills up to its byte limit, and then sends all that data as a chunk to a stream receiver, and asks for next data.

The stream runs .emit(‘data’, payload) whenever it wants to send data and then your event handler runs with that data payload as a param.

https://medium.freecodecamp.org/node-js-streams-everything-you-need-to-know-c9141306be93

To make a stream stop sending data

https://youtu.be/lQAV3bPOYHo?t=168

Question 25

cs: in -Buffer 02 04 06 08 0a 0c 0e 10> each number represents

Answer 25

a byte translated into hexadecimal

Question 26

cs: the size of a buffer is a count of it’s

Answer 26

bytes

Question 27

cs: To concatenate many blobs together, type

Answer 27

add them all to an array
let myBobs = [Blob1, Blob2, Blob3]

and then
let fullBlob = new Blob(myBobs, {type: 'video/webm'})

Set whatever type you want

Question 28

cs: setting a blob to application/octet-stream means

Answer 28

it is arbitrary binary data

https://stackoverflow.com/questions/20508788/do-i-need-content-type-application-octet-stream-for-file-download

Question 29

cs: To end a running stream, you

Answer 29

push null into the stream
this.push(null)

https://gist.github.com/joyrexus/10026630

Question 30

cs: The end event from readable streams is important because it

Answer 30

tells the internal buffer thats not full yet to send the remaining data.

Question 31

exp: In express, the response object is a stream, so

Answer 31

you can pipe data to it, and it will send all the chunks.
file.pipe(res)
or
res.write(‘string’)

https: //medium.com/@daspinola/video-stream-with-node-js-and-html5-320b3191a6b6
https: //stackoverflow.com/questions/38788721/how-do-i-stream-response-in-express

Question 32

js: when you .push() to a readable stream, but the consumer is not ready

Answer 32

the data gets buffered

https://github.com/substack/stream-handbook

Question 33

js: To write a readable stream, type

Answer 33

var Readable = require(‘stream’).Readable;

var myStream = new Readable;
myStream.push(‘beep ‘);
myStream.push(‘boop\n’);
myStream.push(null);

myStream.pipe(process.stdout);

Question 34

js: To only start pushing data onto a stream after the consumer calls read, type

Answer 34

var Readable = require('stream').Readable;
var myStream = Readable();

myStream._read = function () {
    myStream.push('beep ');
    myStream.push('boop\n');
    myStream.push(null);
};

myStream.pipe(process.stdout);

Question 35

cs: Converting a file to base-64 means

Answer 35

encoding it with an algorithm.

https: //www.youtube.com/watch?v=8qkxeZmKmOY
https: //www.youtube.com/watch?v=eUjVcUiNbD4

Question 36

cs: The streams data event gets triggered when

Answer 36

its buffer gets full and sends a chunk

myStream.on(‘data’, (chunk)=>{
console.log(‘chunk sent’)
})

Question 37

js: To convert a Buffer to json, type

Answer 37

JSON.stringify(bufferName);

=> {type: ‘Buffer’, data: [12,34,45…]}

https://hackernoon.com/https-medium-com-amanhimself-converting-a-buffer-to-json-and-utf8-strings-in-nodejs-2150b1e3de57

Question 38

js: To convert a node Buffer object to a javascript ArrayBuffer object

Answer 38

https://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer

Question 39

Node: Once a buffers size is set

Answer 39

it cannot be changed

Question 40

js: A buffer is a lot like a

Answer 40

blob

Question 41

js: What this is basically doing is myReadableStream.pipe(myWritableStream)

Answer 41

myReadableStream.on('data', (chunk) => {
  myWritableStream.write(chunk);
});
myReadableStream.on('end', () => {
  myWritableStream.end();
});

Question 42

js: To create an event emitter, type

Answer 42

Note:
Event emitters need chainable .on() functions

https: //www.youtube.com/watch?v=X-AhceP6jpA (apparently this guy made mistakes. Maybe use:
https: //gist.github.com/mudge/5830382 spinmutoli’s design

Question 43

js: to convert a readable stream into a blob, type

Answer 43

let chunks = []
myStream.on('data', function (chunk) {
  chunks.push(chunk)
})
.on('end', function () {
  let blob = new Blob(chunks, { type: 'myType' })
})

Question 44

js: To convert a function to a promise and rely on its return for another function, type

Answer 44

//  bad
const slowFunc = () => {
  setTimeout(() => {return 'string'}, 5000)
}

const reliesOnSlowFunc = () => {
  console.log(slowFunc() + 'string')
}

reliesOnSlowFunc()
undefinedstring

//  good
const slowFunc = () => {
    return new Promise((resolve, reject) => {
      setTimeout(() => resolve('string') , 5000)
  })
}

const reliesOnSlowFunc = () => {
slowFunc().then((res) => console.log(res + ‘string’))
}
> stringstring // after 5 seconds

Note: The last function is always a side effect function. If you rely on the return, then it must be a promise.

Question 45

i need to learn this Promise.resolve(path.join(path1, path2)).then(function(path) {
   // use the result here
});

Answer 45

https://stackoverflow.com/questions/36826592/what-is-the-best-way-to-wrap-synchronous-functions-in-to-a-promise