London | 26-ITP-January | Karla Grajales | Sprint 2 | Data Groups

Sprint-2/debug/address.js

@@ -12,4 +12,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

@@ -11,6 +11,10 @@ const author = {
   alive: true,
 };
 
-for (const value of author) {
+for (const value of Object.values(author)) {
   console.log(value);
 }
+
+
+// It did work because an object is not iterable as an array, but we can use Object.values() 
+// to get an array of the property values and then iterate over that array.

Sprint-2/debug/recipe.js

@@ -4,12 +4,20 @@
 // Each ingredient should be logged on a new line
 // How can you fix it?
 
+// it won't work because the last line is calling the object property recipe and we
+// need the ingredientes, the console.log is trying to log the whole array of ingredients 
+// as a string, but we want to log each ingredient on a new line. We can fix this by 
+// using a for loop to iterate over the ingredients array and log each ingredient separately.
+
 const recipe = {
-  title: "bruschetta",
+  title: "Bruschetta",
   serves: 2,
   ingredients: ["olive oil", "tomatoes", "salt", "pepper"],
 };
 
-console.log(`${recipe.title} serves ${recipe.serves}
-  ingredients:
-${recipe}`);
+console.log(`Recipe: ${recipe.title} \nserves: ${recipe.serves}`);
+for(const ingredient of recipe.ingredients) {
+  console.log(`${ingredient}`);
+}
+
+

Sprint-2/implement/contains.js

@@ -1,3 +1,12 @@
-function contains() {}
+function contains(obj, property) {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)){
+        return false;
+    }
+
+    return property in obj;
+}
+
 
 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("return true when an object has the property name", () => {
+    expect(contains({a: 1, b: 2}, "a")).toBe(true);
+})
 
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
+test("returns false on empty object ", () => {
+    expect(contains({}, "a")).toBe(false);
+});
 
 // Given an object with properties
 // When passed to contains with an existing property name
 // Then it should return true
+test("return true when pass an object that contains the property name", () => {
+    expect(contains({name: "John", age: 30}, "name")).toBe(true);
+})
 
 // Given an object with properties
 // When passed to contains with a non-existent property name
 // Then it should return false
+test("return false when pass an object that does not contain the property name", () => {
+    expect(contains({id: 12, status: "active"}, "age")).toBe(false);
+})
 
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("return false when pass an array instead of an object", () => {
+    expect(contains([1, 2, 3], "name")).toBe(false);
+    expect(contains(null, "prop")).toBe(false);
+})

Sprint-2/implement/lookup.js

@@ -1,5 +1,9 @@
-function createLookup() {
-  // implementation here
+function createLookup(pairs) {
+  const result = {};
+  for(const [country, currency] of pairs) {
+    result[country] = currency;
+  }
+  return result
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -1,6 +1,5 @@
 const createLookup = require("./lookup.js");
 
-test.todo("creates a country currency code lookup for multiple codes");
 
 /*
 
@@ -33,3 +32,20 @@ It should return:
    'CA': 'CAD'
  }
 */
+
+test("return an object with country codes as keys and currency codes as values", () => {
+  expect( createLookup([ ["MX", "MXN"], ["JP", "JPY"] ])).toEqual({ MX: "MXN", JP: "JPY"});
+  expect( createLookup([ ["AU", "AUD"], ["CH", "CHF"] ])).toEqual({ AU: "AUD", CH: "CHF" });
+});
+
+describe("return an object with country codes as keys and currency codes as values", () => {
+  [
+    { input: [["US", "USD"],["CA", "CAD"]], expected: { US: "USD", CA: "CAD" } },
+    { input: [["GB", "GBP"],["FR", "EUR"]], expected: { GB: "GBP", FR: "EUR" } },
+    { input: [["JP", "JPY"],["AU", "AUD"]], expected: { JP: "JPY", AU: "AUD" } },
+  ].forEach(({ input, expected }) => {
+    it(`should convert ${JSON.stringify(input)} into ${JSON.stringify(expected)}`, () => {
+      expect(createLookup(input)).toEqual(expected);
+    });
+  });
+});

Sprint-2/interpret/invert.js

@@ -10,20 +10,50 @@ function invert(obj) {
   const invertedObj = {};
 
   for (const [key, value] of Object.entries(obj)) {
-    invertedObj.key = value;
+    invertedObj[value] = key;
   }
 
   return invertedObj;
 }
 
-// a) What is the current return value when invert is called with { a : 1 }
+console.log(invert({ a: 1, b: 2 })); // Expected output: { '1': 'a', '2': 'b' }
 
-// b) What is the current 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}
 
-// c) What does Object.entries return? Why is it needed in this program?
+/*
+a) What is the current return value when invert is called with { a : 1 }
+    *the value { key: 1 }
+
+b) What is the current return value when invert is called with { a: 1, b: 2 }
+    *the first pair is { key: 1 }  
+    *and the second pair the value is  { key: 'b' } that means the first pair is 
+    being overwritten by the second pair, so the final return value is { key: 'b' }
+
+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" }
+
+d) What does Object.entries return? Why is it needed in this program?
+    *Return value: It returns an array of arrays, where each sub-array is a [key, value] 
+    pair (e.g., [['a', 1]]).
+    *Why it's needed: Objects are not iterables by default. We need Object.entries 
+    to convert the object into an array so we can use the for...of loop to go through each pair.
+
+e) Explain why the current return value is different from the target output
+    *Literal Property Creation: The current code uses dot notation (invertedObj.key), 
+    which creates a property literally named "key" instead of using the value stored 
+    inside the key variable.
+
+    *Overwriting: Because it keeps targetting the same literal property name ("key"), 
+    each iteration overwrites the previous one. This is why the final object only contains 
+    the last value processed.
+
+    *Target vs. Current: The target output requires bracket notation (invertedObj[value]) 
+    to dynamically assign the new keys based on the input's values.
+
+
+f) Fix the implementation of invert (and write tests to prove it's fixed!)
+    expect({ a: 1, b: 2 })toEqual({ '1': 'a', '2': 'b' } ) now is working as expected
+
+**/
 
-// d) Explain why the current return value is different from the target output
 
-// e) Fix the implementation of invert (and write tests to prove it's fixed!)