London | 26-ITP-May | Chinwe Chukwuma | Sprint 2 | Module-Data-Groups

Sprint-2/debug/address.js

@@ -4,6 +4,19 @@
 // but it isn't working...
 // Fix anything that isn't working
 
+/*const address = {
+  houseNumber: 42,
+  street: "Imaginary Road",
+  city: "Manchester",
+  country: "England",
+  postcode: "XYZ 123",
+};
+
+console.log(`My house number is ${address[0]}`); */
+
+// The line "address[0]" is wrong. Because address is an object not an array, so "address[0]" is undefined. The output will be "My house number is undefined".
+
+// Corrected code
 const address = {
   houseNumber: 42,
   street: "Imaginary Road",
@@ -12,4 +25,4 @@ const address = {
   postcode: "XYZ 123",
 };
 
-console.log(`My house number is ${address[0]}`);
+console.log(`My house number is ${address.houseNumber}`);

Sprint-2/debug/author.js

@@ -3,7 +3,7 @@
 // This program attempts to log out all the property values in the object.
 // But it isn't working. Explain why first and then fix the problem
 
-const author = {
+/* const author = {
   firstName: "Zadie",
   lastName: "Smith",
   occupation: "writer",
@@ -14,3 +14,21 @@ const author = {
 for (const value of author) {
   console.log(value);
 }
+*/
+
+// Prediction and Explanation
+/* The line "for (const value of author) {console.log(value);}" will not work because for-of is used only for iterable things, e.g: arrays, strings, maps, sets.
+But author is a plain object (created with {}), and plain objects are not iterable. So Javascript throws: TypeError: author is not iterable because objects don't have a natural order to loop through. */
+
+// Corrected code
+const author = {
+  firstName: "Zadie",
+  lastName: "Smith",
+  occupation: "writer",
+  age: 40,
+  alive: true,
+};
+
+for (const value of Object.values(author)) {
+  console.log(value);
+} 

Sprint-2/debug/recipe.js

@@ -4,7 +4,7 @@
 // Each ingredient should be logged on a new line
 // How can you fix it?
 
-const recipe = {
+/*const recipe = {
   title: "bruschetta",
   serves: 2,
   ingredients: ["olive oil", "tomatoes", "salt", "pepper"],
@@ -13,3 +13,26 @@ const recipe = {
 console.log(`${recipe.title} serves ${recipe.serves}
   ingredients:
 ${recipe}`);
+*/
+
+// Prediction and Explanation
+/* 
+The line inside the template string: ${recipe} does not print the ingredients. 
+Instead, JavaScript converts the entire recipe object into a string, which becomes "[object Object]". This happens 
+because plain objects {} are not automatically converted into readable text. The program should print each ingredient on a new line, but the current code 
+never loops through recipe.ingredients, so nothing is printed correctly.
+*/
+
+// Corrected code
+const recipe = {
+  title: "bruschetta",
+  serves: 2,
+  ingredients: ["olive oil", "tomatoes", "salt", "pepper"],
+};
+
+console.log(`${recipe.title} serves ${recipe.serves}
+ingredients:`);
+
+for (const ingredient of recipe.ingredients) {
+  console.log(ingredient);
+}

Sprint-2/implement/contains.js

@@ -1,3 +1,10 @@
-function contains() {}
+function contains(obj, prop) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return false;
+  }
+
+  return obj.hasOwnProperty(prop);
+}
 
 module.exports = contains;
+

Sprint-2/implement/contains.test.js

@@ -16,20 +16,35 @@ as the object doesn't contains a key of 'c'
 // Given a contains function
 // When passed an object and a property name
 // Then it should return true if the object contains the property, false otherwise
+test("returns true when object contains the property", () => {
+  const obj = { a: 1, b: 2 };
+  expect(contains(obj, "a")).toBe(true);
+});
+
+test("returns false when object does not contain the property", () => {
+  const obj = { a: 1, b: 2 };
+  expect(contains(obj, "c")).toBe(false);
+});
+
 
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
+// test.todo("contains on empty object returns false");
+test("contains on empty object returns false", () => {
+  expect(contains({}, "a")).toBe(false);
+});
 
-// Given an object with properties
-// When passed to contains with an existing property name
-// Then it should return true
 
-// Given an object with properties
-// When passed to contains with a non-existent property name
-// Then it should return false
 
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("returns false for invalid parameters", () => {
+  const arr = ["apple", "banana"];
+
+  expect(contains(arr, "0")).toBe(false);
+  expect(contains(null, "a")).toBe(false);
+  expect(contains(123, "a")).toBe(false);
+  expect(contains("hello", "0")).toBe(false);
+});

Sprint-2/implement/lookup.js

@@ -1,5 +1,14 @@
-function createLookup() {
-  // implementation here
+function createLookup(countryCurrencyPairs) {
+  const lookup = {};
+
+  for (const pair of countryCurrencyPairs) {
+    const countryCode = pair[0];
+    const currencyCode = pair[1];
+
+    lookup[countryCode] = currencyCode;
+  }
+
+  return lookup;
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -1,7 +1,5 @@
 const createLookup = require("./lookup.js");
 
-test.todo("creates a country currency code lookup for multiple codes");
-
 /*
 
 Create a lookup object of key value pairs from an array of code pairs
@@ -33,3 +31,14 @@ It should return:
    'CA': 'CAD'
  }
 */
+test("creates a country currency code lookup for multiple codes", () => {
+  const countryCurrencyPairs = [
+    ["US", "USD"],
+    ["CA", "CAD"],
+  ];
+
+  expect(createLookup(countryCurrencyPairs)).toEqual({
+    US: "USD",
+    CA: "CAD",
+  });
+});

Sprint-2/implement/querystring.js

@@ -6,8 +6,32 @@ function parseQueryString(queryString) {
   const keyValuePairs = queryString.split("&");
 
   for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
-    queryParams[key] = value;
+    if (pair === "") {
+      continue;
+    }
+
+    if (!pair.includes("=")) {
+      const key = decodeURIComponent(pair.replace(/\+/g, " "));
+      queryParams[key] = "";
+      continue;
+    }
+
+    const equalsIndex = pair.indexOf("=");
+    const key = decodeURIComponent(
+      pair.slice(0, equalsIndex).replace(/\+/g, " ")
+    );
+
+    const value = decodeURIComponent(
+      pair.slice(equalsIndex + 1).replace(/\+/g, " ")
+    );
+
+    if (queryParams[key] === undefined) {
+      queryParams[key] = value;
+    } else if (Array.isArray(queryParams[key])) {
+      queryParams[key].push(value);
+    } else {
+      queryParams[key] = [queryParams[key], value];
+    }
   }
 
   return queryParams;

Sprint-2/implement/querystring.test.js

@@ -37,6 +37,12 @@ test("should replace '+' by ' '", () => {
   });
 });
 
+test("should decode a percent-encoded key without a value", () => {
+  expect(parseQueryString("%6B%65%79")).toEqual({
+    key: "",
+  });
+});
+
 // Stretch exercise: Handling query strings that contain identical keys
 
 // Delete this test if you are not working on this optional case

Sprint-2/implement/tally.js

@@ -1,3 +1,18 @@
-function tally() {}
+function tally(items) {
+    if (!Array.isArray(items)) {
+    throw new Error("Input must be an array");
+  }
+
+  const counts = {};
+
+  for (const item of items) {
+    if (!Object.hasOwn(counts, item)) {
+      counts[item] = 1;
+    } else {
+      counts[item] = counts[item] + 1;
+    }
+  }
+  return counts;
+}
 
 module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -23,12 +23,30 @@ const tally = require("./tally.js");
 // Given an empty array
 // When passed to tally
 // Then it should return an empty object
-test.todo("tally on an empty array returns an empty object");
-
+test("tally on an empty array returns an empty object", () => {
+  expect(tally([])).toEqual({});
+});
 // Given an array with duplicate items
 // When passed to tally
 // Then it should return counts for each unique item
+test("tally counts duplicate items", () => {
+  expect(tally(["a", "a", "b", "c"])).toEqual({
+    a: 2,
+    b: 1,
+    c: 1,
+  });
+});
 
 // Given an invalid input like a string
 // When passed to tally
 // Then it should throw an error
+test("tally throws an error for invalid input", () => {
+  expect(() => tally("hello")).toThrow();
+});
+
+
+test("tally counts items named toString", () => {
+  expect(tally(["toString", "toString"])).toEqual({
+    toString: 2,
+  });
+});

Sprint-2/interpret/invert.js

@@ -5,7 +5,7 @@
 // Then it should swap the keys and values in the object
 
 // E.g. invert({x : 10, y : 20}), target output: {"10": "x", "20": "y"}
-
+/*
 function invert(obj) {
   const invertedObj = {};
 
@@ -15,15 +15,31 @@ function invert(obj) {
 
   return invertedObj;
 }
+  */
 
-// a) What is the current return value when invert is called with { a : 1 }
+// a) What is the current return value when invert is called with { a : 1 } - The current return value is { key: 1}
 
-// b) What is the current return value when invert is called with { a: 1, b: 2 }
+// b) What is the current return value when invert is called with { a: 1, b: 2 } - The current return value is { key: 2}
 
-// c) What is the target return value when invert is called with {a : 1, b: 2}
+// c) What is the target return value when invert is called with {a : 1, b: 2} - The target return value is { "1": "a", "2": "b" }
 
 // c) What does Object.entries return? Why is it needed in this program?
+/* Object.entries(obj) returns an array of [key, value] pairs. Example: Object.entries({ a:1, b:2 }) returns [["a", 1], ["b", 2]].
+It is needed because the loop "for (const [key, value] of Object.entries(obj))" let's each pair destructure easily.
+*/
 
-// d) Explain why the current return value is different from the target output
+// d) Explain why the current return value is different from the target output - It is because this line "invertedObj.key = value;" uses literal string "key instead of the variable key" which is a wrong property name,
+// instead of this "invertedObj[value] = key;"
 
 // e) Fix the implementation of invert (and write tests to prove it's fixed!)
+function invert(obj) {
+  const invertedObj = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    invertedObj[value] = key;
+  }
+
+  return invertedObj;
+}
+
+module.exports = invert;

Sprint-2/interpret/invert.test.js

@@ -0,0 +1,17 @@
+const invert = require("./invert.js");
+
+test("inverts a single key-value pair", () => {
+  expect(invert({ a: 1 })).toEqual({ 1: "a" });
+});
+
+test("inverts multiple key-value pairs", () => {
+  expect(invert({ a: 1, b: 2 })).toEqual({ 1: "a", 2: "b" });
+});
+
+test("handles empty objects", () => {
+  expect(invert({})).toEqual({});
+});
+
+test("handles string values", () => {
+  expect(invert({ x: "hello" })).toEqual({ hello: "x" });
+});