Glasgow| May-2025| Bassam Alshujaa| Sprint-2 | module-Data-Groups

Sprint-2/debug/address.js

@@ -12,4 +12,6 @@ const address = {
   postcode: "XYZ 123",
 };
 
-console.log(`My house number is ${address[0]}`);
+console.log(`My house number is ${address.houseNumber}`);
+
+// the code has an error which is address[0], this an object so we can't get it by index

Sprint-2/debug/author.js

@@ -11,6 +11,8 @@ const author = {
   alive: true,
 };
 
-for (const value of author) {
-  console.log(value);
+for (const value in author) {
+  console.log(author[value]);
 }
+
+// we can't loop an object by for.. of loop when can loop using for.. in

Sprint-2/debug/recipe.js

@@ -9,7 +9,11 @@ const recipe = {
   serves: 2,
   ingredients: ["olive oil", "tomatoes", "salt", "pepper"],
 };
+console.log(recipe.title);
+console.log(`serves:${recipe.serves}`);
+console.log(`ingredients:`);
 
-console.log(`${recipe.title} serves ${recipe.serves}
-  ingredients:
-${recipe}`);
+for (let i of recipe.ingredients) {
+  console.log(i);
+}
+// We should loop recipe.ingredients  to  log them out separately 

Sprint-2/implement/contains.js

@@ -1,3 +1,22 @@
-function contains() {}
+function contains(obj,check) {
+    const out = {}
+    // console.log(obj)
+    if (Object.keys(obj).length ==0) {
+        console.log("Empty");
+        return false;
+    }
+    for (let i in obj){
+        if (obj[check]) {
+            console.log("Yes");
+            return true;
+        } else {
+            console.log("NO");
+            return false;
+        }
+    }
+}
+console.log(contains({} , []));
+
+
 
 module.exports = contains;

Sprint-2/implement/contains.test.js

@@ -20,16 +20,36 @@ as the object doesn't contains a key of 'c'
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
+test("contains on empty object returns false" , () =>{
+    const input = { } ;
+    const outPut = contains(input, 'a') 
+    expect(outPut).toEqual(false)
+});
 
 // Given an object with properties
 // When passed to contains with an existing property name
 // Then it should return true
 
+test("contains  with an existing property name returns true", () => {
+  const input = { a: 1, b: 2, s: 5 };
+  const outPut = contains(input, "a");
+  expect(outPut).toEqual(true);
+});
 // Given an object with properties
 // When passed to contains with a non-existent property name
 // Then it should return false
 
+test("contains with a non-existent property name returns false", () => {
+  const input = { a: 1, b: 2, s: 5 };
+  const outPut = contains(input, "l");
+  expect(outPut).toEqual(false);
+});
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+
+test("contains  invalid parameters like an array returns false", () => {
+  const input = 'abx';
+  const outPut = contains(input, "p");
+  expect(outPut).toEqual(false);
+});

Sprint-2/implement/lookup.js

@@ -1,5 +1,12 @@
-function createLookup() {
-  // implementation here
+function createLookup(obj) {
+  if (!Array.isArray(obj) || !obj.every(Array.isArray)) {
+    throw new Error("Input must be an array of arrays");
+  }
+  const cur = {};
+  for (let list of obj) {
+      cur[list[0]] = list[1];
+  }
+  return cur;
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -1,7 +1,23 @@
 const createLookup = require("./lookup.js");
 
-test.todo("creates a country currency code lookup for multiple codes");
-
+test("creates a country currency code lookup for multiple codes", () => {
+  const input = createLookup([
+    ["US", "USD"],
+    ["CA", "CAD"],
+  ]);
+  const outPut = { US: "USD", CA: "CAD" };
+  expect(input).toEqual(outPut);
+});
+
+test("creates a lookup from multiple pairs", () => {
+  const input = [
+    ["US", "USD"],
+    ["CA", "CAD"],
+    ["JP", "JPY"],
+  ];
+  const expected = { US: "USD", CA: "CAD", JP: "JPY" };
+  expect(createLookup(input)).toEqual(expected);
+});
 /*
 
 Create a lookup object of key value pairs from an array of code pairs

Sprint-2/implement/querystring.js

@@ -4,13 +4,18 @@ function parseQueryString(queryString) {
     return queryParams;
   }
   const keyValuePairs = queryString.split("&");
-
-  for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
-    queryParams[key] = value;
+  for (let pair = 0; pair < keyValuePairs.length; pair++) {
+    const index = keyValuePairs[pair].indexOf("="); 
+    if (index === -1) {
+      queryParams[keyValuePairs[pair]] = "";
+    } else {
+      const key = keyValuePairs[pair].slice(0, index);
+      const value = keyValuePairs[pair].slice(index + 1);
+      queryParams[key] = value;
+    }
   }
-
   return queryParams;
 }
+parseQueryString("equation=x=y+1");
 
 module.exports = parseQueryString;

Sprint-2/implement/querystring.test.js

@@ -6,7 +6,17 @@
 const parseQueryString = require("./querystring.js")
 
 test("parses querystring values containing =", () => {
-  expect(parseQueryString("equation=x=y+1")).toEqual({
-    "equation": "x=y+1",
-  });
+  expect(parseQueryString("equation=x=y+1")).toEqual({equation: "x=y+1"});
 });
+
+test("parses multiple key-value pairs", () => {
+  expect(parseQueryString("a=1&b=2&c=3")).toEqual({ a: "1", b: "2", c: "3" });
+});
+
+test("handles key with empty value", () => {
+  expect(parseQueryString("key=")).toEqual({ key: "" });
+});
+
+test("takes the last value for duplicate keys", () => {
+  expect(parseQueryString("a=1&a=2&a=3")).toEqual({ a: "3" });
+});

Sprint-2/implement/tally.js

@@ -1,3 +1,20 @@
-function tally() {}
+function tally(list) {
+  if (!Array.isArray(list)) {
+    throw new Error ("Input must be an array");
+  } else {
+    const result = {};
+    if (list) {
+      for (const item of list) {
+        if (result[item]) {
+          result[item] += 1;
+        } else {
+          result[item] = 1;
+        }
+      }
+    }
+    return result;
+  }
+}
+console.log(tally());
 
 module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -23,12 +23,25 @@ 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", () => {
+  const input = "";
+  const outPut = {};
+  expect(tally(input)).toEqual(outPut);
+});
 
 // Given an array with duplicate items
 // When passed to tally
 // Then it should return counts for each unique item
-
+test("tally counts duplicates correctly", () => {
+  const input = ["a", "b", "a", "c", "b"];
+  const output = { a: 2, b: 2, c: 1 };
+  expect(tally(input)).toEqual(output);
+});
 // Given an invalid input like a string
 // When passed to tally
 // Then it should throw an error
+test("tally throws error on invalid input", () => {
+  const input = 'ab';
+  const output = "Input must be an array";
+  expect(() =>tally(input)).toThrow(output);
+});

Sprint-2/implement/tempCodeRunnerFile.js

@@ -0,0 +1 @@
+equation=x=y+1

Sprint-2/interpret/invert.js

@@ -10,20 +10,28 @@ function invert(obj) {
   const invertedObj = {};
 
   for (const [key, value] of Object.entries(obj)) {
-    invertedObj.key = value;
+    invertedObj[value] = key;
   }
-
   return invertedObj;
 }
+console.log(invert({ s: 1, c: 2 , p:5}));
 
 // a) What is the current return value when invert is called with { a : 1 }
+//  the current value is  { key: 1 }
 
 // b) What is the current return value when invert is called with { a: 1, b: 2 }
+// the current value is { key: 2 }
 
 // c) What is the target return value when invert is called with {a : 1, b: 2}
+// { '1': 'a', '2': 'b' }
 
 // c) What does Object.entries return? Why is it needed in this program?
+//  it returns one array containing smaller arrays — each one holds key and value, 
+// and this lets us access the keys and values easily by looping the array
 
 // d) Explain why the current return value is different from the target output
+// because it returns a key that is called key not the key in the obj and  it equals the value which gives {key: value}
 
 // e) Fix the implementation of invert (and write tests to prove it's fixed!)
+// console.log(invert({ a: 1, b: 2 }));    returns  { '1': 'a', '2': 'b' }
+// console.log(invert({ s: 1, c: 2, p: 5 }));  returns  { '1': 's', '2': 'c', '5': 'p' }