Initial commit.

javascript-practice/src/dWhileLoops/whileLoops.test.js

+import { countDigits } from './whileLoops.js';
+
+describe('the `countDigits` function', () => {
+  test('counts digits in a one-digit positive integer', () => {
+    expect(countDigits(5)).toBe(1);
+  });
+  test('counts digits in a two-digit positive integer', () => {
+    expect(countDigits(55)).toBe(2);
+  });
+  test('counts digits in a three-digit positive integer', () => {
+    expect(countDigits(555)).toBe(3);
+  });
+  test('counts digits in a four-digit positive integer', () => {
+    expect(countDigits(5555)).toBe(4);
+  });
+  test('counts digits in a five-digit positive integer', () => {
+    expect(countDigits(55555)).toBe(5);
+  });
+  test('counts digits in a six-digit positive integer', () => {
+    expect(countDigits(555555)).toBe(6);
+  });
+  test('counts digits in a seven-digit positive integer', () => {
+    expect(countDigits(5555555)).toBe(7);
+  });
+  test('counts digits in an eight-digit positive integer', () => {
+    expect(countDigits(55555555)).toBe(8);
+  });
+});

javascript-practice/src/eCounterBasedForLoops/counterBasedForLoops.js

+export function triangularNumber(termCount) {
+  let result = 0;
+  // INSTRUCTIONS: Write a counter-based loop here so that the loop variable
+  // begins at zero, the loop variable goes up by one each iteration, and the
+  // loop terminates as soon as the loop variable reaches `termCount`.  Inside
+  // the loop, add the loop variable to `result`.
+  //
+  // Resources:
+  // <https://javascript.info/while-for#the-for-loop>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for>
+  // <https://javascript.info/operators#modify-in-place>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Addition_assignment>
+  return result;
+}

javascript-practice/src/eCounterBasedForLoops/counterBasedForLoops.key.js

+export function triangularNumber(termCount) {
+  let result = 0;
+  for (let i = 0; i < termCount; ++i) {
+    result += i;
+  }
+  return result;
+}

javascript-practice/src/eCounterBasedForLoops/counterBasedForLoops.test.js

+import { triangularNumber } from './counterBasedForLoops.js';
+
+describe('the `triangularNumber` function', () => {
+  test('computes the zeroth triangular number', () => {
+    expect(triangularNumber(0)).toBe(0);
+  });
+  test('computes the first triangular number', () => {
+    expect(triangularNumber(1)).toBe(0);
+  });
+  test('computes the second triangular number', () => {
+    expect(triangularNumber(2)).toBe(1);
+  });
+  test('computes the third triangular number', () => {
+    expect(triangularNumber(3)).toBe(3);
+  });
+  test('computes the fourth triangular number', () => {
+    expect(triangularNumber(4)).toBe(6);
+  });
+  test('computes the fifth triangular number', () => {
+    expect(triangularNumber(5)).toBe(10);
+  });
+  test('computes the sixth triangular number', () => {
+    expect(triangularNumber(6)).toBe(15);
+  });
+  test('computes the seventh triangular number', () => {
+    expect(triangularNumber(7)).toBe(21);
+  });
+});

javascript-practice/src/fForEachLoops/forEachLoops.js

+export function sum(collection) {
+  let result = 0;
+  // INSTRUCTIONS: Write a loop that iterates over the given collection of
+  // numbers and adds each element to the result.
+  //
+  // Resources:
+  // <https://javascript.info/array#loops>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of>
+  // <https://javascript.info/operators#modify-in-place>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Addition_assignment>
+  return result;
+}

javascript-practice/src/fForEachLoops/forEachLoops.key.js

+export function sum(collection) {
+  let result = 0;
+  for (const element of collection) {
+    result += element;
+  }
+  return result;
+}

javascript-practice/src/fForEachLoops/forEachLoops.test.js

+import { sum } from './forEachLoops.js';
+
+describe('the `sum` function', () => {
+  test('totals elements of an empty', () => {
+    expect(sum([])).toBe(0);
+  });
+  test('totals elements of a nonempty list', () => {
+    expect(sum([4, 5, 6])).toBe(15);
+  });
+  test('totals elements of an empty set', () => {
+    expect(sum(new Set([]))).toBe(0);
+  });
+  test('totals elements of a nonempty set', () => {
+    expect(sum(new Set([6, 7, 8]))).toBe(21);
+  });
+});

javascript-practice/src/gConstructorsAndFields/constructorsAndFields.js

+export class Book {
+  // INSTRUCTIONS: Write a constructor that takes two parameters, `title` and
+  // `author`, and stores them in two public fields, `this.title` and
+  // `this.author`.
+  //
+  // Resources:
+  // <https://javascript.info/class>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/constructor>
+}

javascript-practice/src/gConstructorsAndFields/constructorsAndFields.key.js

+export class Book {
+  constructor(title, author) {
+    this.title = title;
+    this.author = author;
+  }
+}

javascript-practice/src/gConstructorsAndFields/constructorsAndFields.test.js

+import { Book } from './constructorsAndFields.js';
+
+describe('the first `Book` class', () => {
+  test('has `title` and `author` fields and no others', () => {
+    const book = new Book('A Title', 'An Author');
+    expect(Object.getOwnPropertyNames(book).sort()).toEqual(['author', 'title']);
+  });
+  test('stores the title and author given at construction time', () => {
+    const book = new Book('A Title', 'An Author');
+    expect(book.title).toBe('A Title');
+    expect(book.author).toBe('An Author');
+  });
+});

javascript-practice/src/hProtectedFieldsAndGetters/protectedFieldsAndGetters.js

+export class Book {
+  // INSTRUCTIONS: Write a constructor that takes two parameters, `title` and
+  // `author`, and stores them in two protected fields, `this._title` and
+  // `this._author`.
+  //
+  // Resources:
+  // <https://javascript.info/class>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/constructor>
+
+  // INSTRUCTIONS: Write a getter so that if `b` is a book with title 'X' and
+  // author 'Y', then `b.entry` is equal to the string 'X by Y'.
+  //
+  // Resources:
+  // <https://javascript.info/private-protected-properties-methods>
+  // <https://javascript.info/class#getters-setters>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals>
+  // <https://javascript.info/types#string>
+  // <https://javascript.info/string#quotes>
+}

javascript-practice/src/hProtectedFieldsAndGetters/protectedFieldsAndGetters.key.js

+export class Book {
+  constructor(title, author) {
+    this._title = title;
+    this._author = author;
+  }
+
+  get entry() {
+    return `${this._title} by ${this._author}`;
+  }
+}

javascript-practice/src/hProtectedFieldsAndGetters/protectedFieldsAndGetters.test.js

+import { Book } from './protectedFieldsAndGetters.js';
+
+describe('the second `Book` class', () => {
+  test('has `_title` and `_author` fields and no others', () => {
+    const book = new Book('A Title', 'An Author');
+    expect(Object.getOwnPropertyNames(book).sort()).toEqual(['_author', '_title']);
+  });
+  test('stores the title and author given at construction time', () => {
+    const book = new Book('A Title', 'An Author');
+    expect(book.entry).toBe('A Title by An Author');
+  });
+  test('computes its entry based on the most recent title and author data', () => {
+    const book = new Book('A Title', 'An Author');
+    book._title = 'A New Title';
+    expect(book.entry).toBe('A New Title by An Author');
+  });
+});

javascript-practice/src/iSetters/setters.js

+const FAHRENHEIT_FREEZING = 32;
+const FAHRENHEIT_PER_CELSIUS = 1.8;
+
+export class Temperature {
+  constructor(celsius) {
+    this.celsius = celsius;
+  }
+
+  get fahrenheit() {
+    return FAHRENHEIT_FREEZING + FAHRENHEIT_PER_CELSIUS * this.celsius;
+  }
+
+  // INSTRUCTIONS: Write a setter so that if `t` is a `Temperature` object, a
+  // statement like `t.fahrenheit = 32;` will set `t.celsius` to the equivalent
+  // temperature in Celsius.
+  //
+  // Resources:
+  // <https://javascript.info/class#getters-setters>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set>
+}

javascript-practice/src/iSetters/setters.key.js

+const FAHRENHEIT_FREEZING = 32;
+const FAHRENHEIT_PER_CELSIUS = 1.8;
+
+export class Temperature {
+  constructor(celsius) {
+    this.celsius = celsius;
+  }
+
+  get fahrenheit() {
+    return FAHRENHEIT_FREEZING + FAHRENHEIT_PER_CELSIUS * this.celsius;
+  }
+
+  set fahrenheit(fahrenheit) {
+    this.celsius = (fahrenheit - FAHRENHEIT_FREEZING) / FAHRENHEIT_PER_CELSIUS;
+  }
+}

javascript-practice/src/iSetters/setters.test.js

+import { Temperature } from './setters.js';
+
+describe('the `Temperature` class', () => {
+  test('has a `celsius` field and no others', () => {
+    const temperature = new Temperature(20);
+    expect(Object.getOwnPropertyNames(temperature).sort()).toEqual(['celsius']);
+  });
+  test('stores the Celsius temperature given at construction time', () => {
+    const temperature = new Temperature(20);
+    expect(temperature.celsius).toBe(20);
+  });
+  test('provides a getter for the equivalent Fahrenheit temperature', () => {
+    const temperature = new Temperature(20);
+    expect(temperature.fahrenheit).toBe(68);
+  });
+  test('supports modifications by setting an object\'s `celsius` field', () => {
+    const temperature = new Temperature(20);
+    temperature.celsius = 15;
+    expect(temperature.celsius).toBe(15);
+    expect(temperature.fahrenheit).toBe(59);
+  });
+  test('supports modifications via a `fahrenheit` setter', () => {
+    const temperature = new Temperature(20);
+    temperature.fahrenheit = 59;
+    expect(Object.getOwnPropertyNames(temperature).sort()).toEqual(['celsius']);
+    expect(temperature.celsius).toBe(15);
+    expect(temperature.fahrenheit).toBe(59);
+  });
+});

javascript-practice/src/jMethods/methods.js

+export class PlanarVector {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  // INSTRUCTIONS: Write a `dotProduct` method so that if `u` and `v` are
+  // vectors, then `u.dotProduct(v)` is equivalent to `(u.x * v.x + u.y + v.y)`.
+  //
+  // Resources:
+  // <https://javascript.info/class>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#prototype_methods>
+  // <https://javascript.info/function-basics>
+  // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions>
+}

javascript-practice/src/jMethods/methods.key.js

+export class PlanarVector {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  dotProduct(other) {
+    return this.x * other.x + this.y * other.y;
+  }
+}

javascript-practice/src/jMethods/methods.test.js

+import { PlanarVector } from './methods.js';
+
+describe('the first `PlanarVector` class', () => {
+  test('correctly computes dot products between parallel vectors', () => {
+    const u = new PlanarVector(1, 4);
+    const v = new PlanarVector(-2, -8);
+    expect(u.dotProduct(v)).toBe(-34);
+  });
+  test('correctly computes dot products between orthogonal vectors', () => {
+    const u = new PlanarVector(1, 4);
+    const v = new PlanarVector(8, -2);
+    expect(u.dotProduct(v)).toBe(0);
+  });
+  test('correctly computes dot products between vectors at an angle', () => {
+    const u = new PlanarVector(1, 4);
+    const v = new PlanarVector(5, 9);
+    expect(u.dotProduct(v)).toBe(41);
+  });
+});

javascript-practice/src/kArrays/arrays.js

+export class PlanarVector {
+  constructor() {
+    this.coordinates = [0, 0];
+  }
+
+  get x() {
+    // INSTRUCTIONS: Make this getter return the first number in
+    // `this.coordinates`.
+    //
+    // Resources:
+    // <https://javascript.info/array>
+    // <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array>
+  }
+
+  set x(x) {
+    // INSTRUCTIONS: Make this getter update the first number in
+    // `this.coordinates`.
+  }
+
+  get y() {
+    // INSTRUCTIONS: Make this getter return the second number in
+    // `this.coordinates`.
+  }
+
+  set y(y) {
+    // INSTRUCTIONS: Make this getter update the second number in
+    // `this.coordinates`.
+  }
+}