Question

When is a JavaScript Error Object thrown?

Answer 1

The Error object is how JavaScript deals with runtime errors - so at code runtime!

Answer 2

Using the keyword throw you can throw your own runtime errors that will stop program execution.

Answer 3

We can use try...catch blocks with functions that might throw an error to catch that error and continue code execution after that error was thrown

Answer 4

A SyntaxError is thrown when there is an error in the syntax of the executed code.

Answer 5

A TypeError is thrown when an operation cannot be performed because the operand is a value of the wrong type.

Answer 6

The ReferenceError object represents an error when a non-existent variable is referenced.

Answer 7

ReferenceError: pupy is not defined

Answer 8

TypeError: dog is not a function

Answer 9

TypeError: Assignment to constant variable.

Answer 10

Syntax Error: Unexpected token '}'

Answer 11

SyntaxError: missing ) after argument list

Answer 12

Writing tests before code ensures that the code written works.
Only required code is written.
TDD helps enforced code modularity.
Better understanding of what the code should be doing

Answer 13

Test-driven development

Answer 14

Red
Green
Refactor

Answer 15

Write the tests and watch them fail (a failing test is red). It's important to ensure the tests initially fail so that you don't have false positives.

Answer 16

Write the minimum amount of code to ensure the tests pass (a passing test will be green).

Answer 17

Refactor the code you just wrote. Your job is not over when the tests pass! One of the most important things you do as a software developer is to ensure the code you write is easy to maintain and read.

Answer 18

#3: Refactor: The third step of the TDD workflow is Refactor where you refactor the code you wrote to ensure it is of the highest quality.

Answer 19

#2: Red EXPLANATION: The first step of the TDD workflow is Red where you write a test and watch it fail.

Answer 20

EXPLANATION: The second step of the TDD workflow is Green where you write the minimum amount of code required to pass the test.

Answer 21

#2: The sandwichMaker function is being invoked with an argument that will throw an error - halting program execution. To avoid this we could wrap the sandwichMaker function within another function.

Answer 22

#1: The afterEach Mocha hook will be invoked AFTER each of the tests within the same block.

Answer 23

The beforeEach Mocha hook will be invoked BEFORE EACH of the tests within the same block.

Answer 24

#1 EXPLANATION The before Mocha hook with be invoked once before all tests within the same block are run.

Answer 25

#2: EXPLANATION In the above code snippet we are setting two states (have kernels vs. don't have kernels) using two describe blocks. We should instead use the alias for describe, context, to signify we are testing two different contexts.

Answer 26

Host: specifies the domain name of the server.
User-Agent: a string that identifies the operating system, software vendor or version of the requester
Referer: the address of the previous web page from which a link to the currently requested page was followed.
Accept: informs the server about the types of data that can be sent back.
Content-Type: Indicates the media type found in the body of the HTTP message

Answer 27

GET: a request to retrieve data. It will never have a body.
POST: sends data to the server creating a new resource.
PUT: updates a resource on the server.
PATCH: similar to PUT, but it applies partial modifications to a resource.
DELETE: deletes the specified resource.

Answer 28

200: OK. The request has succeeded.
302: Found. The URI of requested resource has been changed temporarily.
400: Bad Request. The server could not understand the request due to invalid syntax.
401: Unauthorized. The client must authenticate itself to get the requested response.
402: Payment Required.
403: Forbidden. The client does not have access rights to the content.
404: Not Found. The server cannot find the requested resource.
500: Internal Server Error. The range from 500-599 indicate server errors.

Answer 29

Request:

nc -v google.com 80
GET / HTTP/1.1

Response: HTTP/1.1 200 OK
Date: Thu, 28 May 2020 20:50:17 GMT
Expires: -1
Cache-Control: private, max-age=0
Content-Type: text/html; charset=ISO-8859-1
<!doctype html>
<html>
</html>

Answer 30

const http = require('http');

Answer 31

http.createServer(function (request, response) { }).listen(8080, function() {});

Answer 32

    http.createServer(function(request, response) {
        if (request.url === '/') {
            response.writeHead(
                200,
                { 'Content-Type': 'text/html' }
            );
            response.write('<h1>OK</h1>');
            response.end();
        } else {
            response.writeHead(404);
            response.end();
        }
    }).listen(8080, function() {
        console.log(
            'listening for requests on port 8080...'
        );
    });

Answer 33

const myPromise = new Promise((resolve, reject) => {});

Answer 34

    const sleep = (millisenconds) => {
        return new Promise((resolve) => {
            setTimeout(resolve, milliseconds);
        });
    }

Now that setTimeout is wrapped in a promise we can use it in the synchronous fashion:


    sleep(1000)
        .then(() => doAThing())
        .then(() => sleep(1000))
        .then(() => doADifferentThing())
        .then(() => sleep(3000))
        .then(() => doAFinalThing());
        .catch((reject) => fixIt());

Answer 35

Promise.all([
        fs.readFile("d1.md", "utf-8"),
        fs.readFile("d2.md", "utf-8"),
        fs.readFile("d3.md","utf-8")
    ])
    .then((contents1, contents2, contents3) => {
        return contents1 + contents2 + contents3;
    })
    .then((concatted) => {
        console.log(concattted);
    });

Answer 36

const fs = require('fs').promises

Answer 37

const fetch = require('node-fetch');

Answer 38

    const fetch = require('node-fetch');

    fetch("https://ifconfig.me/all.json")
        .then((response) => {
            return response.json(); // convert from json
        })
        .then((data) => {
            console.log(data);
        });

Answer 39

    async function syncLike() {
        console.log(await slow());
        console.log(await fast());
    }

Answer 40

    const fetch = require('node-fetch');

    async function getIpAddress() {
        const response = await fetch("https://ifconfig.me/all.json");
        const ipInfo = await response.json();
        return ipInfo;
    }

    (async() => {
        const ipInfo = await getIpAddress();
    })();

Answer 41

(async() => {})();

Answer 42

npm install node-fetch
const fetch = require('node-fetch');

Answer 43

<script async type="module" src="index.js"></script>

Answer 44

<link rel="stylesheet" href="style.css">

Answer 45

<!DOCTYPE html>

Answer 46

<a href="https://marylark.com/work-samples">Quizzes</a>

Answer 47

Red: We begin by writing a test (or tests) that specify what we expect our code to do. We run the test, to see it fail, and in doing so we ensure that our test won't be a false positive.

Answer 48

We write the minimum amount of code to get our test to pass. This step may take just a few moments, or a longer time depending on the complexity of the task.

Answer 49

The big advantage of test driven development is that it means we always have a set of tests that cover our codebase. This means that we can safely make changes to our code, and as long as our tests still pass, we can be confident that the changes did not break any functionality. This gives us the confidence to be able to constantly refactor and simplify our code - we include a refactor step after each time we add a passing test, but it isn't always necessary to make changes.

Answer 50

Syntax Error: These errors refer to problems with the syntax of our code, they usually refer to either missing or rogue characters that cause the compiler to be able to understand the code we are feeding it.
Reference Error: These errors refer to times in our code where we reference a variable that is not available in the current scope.
TypeError: These errors refer to times in our code where we reference a variable of the wrong type. Modifying a value that cannot be changed, using a value in an inappropriate way, or an argument of an unexpected type being passed to a function, are all causes of TypeErrors.

Answer 51

const assert = require("assert");

Answer 52

const reverseString = require('../lib/reverse-string').reverseString;

Answer 53

const assert = require("assert");
const reverseString = require('../lib/reverse-string').reverseString

    describe("reverseString", () => {
        it("should reverse simple strings", () => {
            assert.equal(reverseString("fun"), "nuf");
        });
        it("should throw a TypeError if it doesn't receive a string", () => {
            assert.throws(() => reverseString(0));
        });
    });

Answer 54

assert.throws(() => reverseString());

Answer 55

Behavior Driven Development

Answer 56

Chai, where rather than assert.equal(foo, 'bar'); from the strict Mocha TDD-style, chai provides more human readable code expect(foo).to.be.a('string'); or foo.should.equal('bar')

Answer 57

Runs once before the first test in this block.

    describe('hooks', function() {
        before(function() {
            //to run once before the first test in this block.
        }
    });

Answer 58

Runs once after the last test in this block.

    describe('hooks', function() {
        after(function() {
            //to run once after the last test in this block.
        }
    });

Answer 59

Runs before each test in this block.

    describe('hooks', function() {
        beforeEach(function() {
            //to run before EACH test in this block.
        }
    });

Answer 60

Runs after each test in this block

    describe('hooks', function() {
        afterEach(function() {
            //to run after EACH test in this block.
        }
    });

Week 6 Quiz