London | Forogh Aghaeiyarijani | Module-Structuring-and-Testing-Data | sprint1| week1

Sprint-1/errors/0.js

@@ -1,2 +1,2 @@
-This is just an instruction for the first activity - but it is just for human consumption
-We don't want the computer to run these 2 lines - how can we solve this problem?
+// This is just an instruction for the first activity - but it is just for human consumption
+// We don't want the computer to run these 2 lines - how can we solve this problem?

Sprint-1/errors/1.js

@@ -1,4 +1,4 @@
 // trying to create an age variable and then reassign the value by 1
 
-const age = 33;
+let age = 33;
 age = age + 1;

Sprint-1/errors/2.js

@@ -1,5 +1,6 @@
 // Currently trying to print the string "I was born in Bolton" but it isn't working...
 // what's the error ?
-
-console.log(`I was born in ${cityOfBirth}`);
 const cityOfBirth = "Bolton";
+console.log(`I was born in ${cityOfBirth}`);
+
+//Computer reads code from the line by line, so we need to first define variables and then get console.

Sprint-1/errors/3.js

@@ -1,4 +1,4 @@
-const cardNumber = 4533787178994213;
+const cardNumber = "4533787178994213";
 const last4Digits = cardNumber.slice(-4);
 
 // The last4Digits variable should store the last 4 digits of cardNumber
@@ -7,3 +7,12 @@ const last4Digits = cardNumber.slice(-4);
 // Then run the code and see what error it gives.
 // Consider: Why does it give this error? Is this what I predicted? If not, what's different?
 // Then try updating the expression last4Digits is assigned to, in order to get the correct value
+
+console.log(last4Digits);
+
+// If cardNumber were a number (not a string), this would raise a TypeError because numbers don't have a slice() method.
+// If cardNumber were a number, JavaScript would throw a TypeError because slice() is not a method for numbers.
+// Why String Conversion Might Not Always Be Ideal:
+// 1-Loss of Numerical Context: After converting to a string, performing arithmetic operations requires converting back to a number.
+// 2-Performance Considerations: String manipulation can be less efficient than numerical operations, especially in large-scale data processing.
+// 3-Clarity: Maintaining a variable as a number can make the code easier to understand in contexts where numeric operations are expected. ​​

Sprint-1/errors/4.js

@@ -1,2 +1,13 @@
-const 12HourClockTime = "20:53";
-const 24hourClockTime = "08:53";
+const HourClockTime = "20:53";  // Clearly a 24-hour time
+const hourClockTime = "08:53";  // Suggests a 12-hour format (AM/PM context implied)
+
+// Definition: A system of timekeeping where the day is divided into two 12-hour periods: AM (Ante Meridiem, before noon) and PM (Post Meridiem, after noon).
+// Example: 8:53 PM in 12-hour format is written as 08:53 PM.
+
+// Definition: A system where the day runs from 00:00 (midnight) to 23:59 (one minute before the next midnight), without using AM or PM.
+// Example: 20:53 in 24-hour format is 8:53 PM in 12-hour format.
+// labels in coding is matters!Why? 
+// 1. Consistency in Naming: Helps with understanding the flow of data.
+// 2. Avoiding Ambiguity: Mislabeling can lead to incorrect assumptions about the data type or its usage.
+// 3. Efficient Communication: When collaborating, meaningful labels reduce the need for excessive comments or explanations.
+

Sprint-1/exercises/count.js

@@ -4,3 +4,12 @@ count = count + 1;
 
 // Line 1 is a variable declaration, creating the count variable with an initial value of 0
 // Describe what line 3 is doing, in particular focus on what = is doing
+console.log(count)
+
+// Explanation of Line 3 (count = count + 1):
+// - Assignment (=): The = operator is used to assign a value to a variable. It takes the value on the right-hand side and stores it in the variable on the left-hand side.
+
+// - What Happens in Line 3:
+
+// 1. Right-Hand Side (count + 1): This expression is evaluated first. It takes the current value of count (which is 0 initially) and adds 1 to it. The result of this calculation is 1.
+// 2. Assignment: The result (1) is then assigned back to the variable count, updating its value from 0 to 1.

Sprint-1/exercises/decimal.js

@@ -7,3 +7,12 @@ const num = 56.5678;
 // Create a variable called roundedNum and assign to it an expression that evaluates to 57 ( num rounded to the nearest whole number )
 
 // Log your variables to the console to check your answers
+
+const wholeNumberPart = Math.floor(num); // 56
+console.log("Whole Number Part:", wholeNumberPart);
+
+const decimalPart = num - wholeNumberPart;
+console.log("Decimal Part:", decimalPart); 
+
+const roundedNum = Math.round(num); // 57
+console.log("Rounded Number:", roundedNum);

Sprint-1/exercises/initials.js

@@ -4,3 +4,7 @@ let lastName = "Johnson";
 
 // Declare a variable called initials that stores the first character of each string.
 // This should produce the string "CKJ", but you must not write the characters C, K, or J in the code of your solution.
+
+let firstCaracter = (firstName[0] + middleName[0] + lastName[0]);
+
+console.log(firstCaracter)

Sprint-1/exercises/paths.js

@@ -16,3 +16,9 @@ console.log(`The base part of ${filePath} is ${base}`);
 
 // Create a variable to store the dir part of the filePath variable
 // Create a variable to store the ext part of the variable
+const dir = filePath.slice(0, lastSlashIndex);
+console.log(`The dir part of ${filePath} is ${dir}`); 
+
+const lastDotIndex = base.lastIndexOf(".");
+const ext = base.slice(lastDotIndex + 1);
+console.log(`The ext part of ${filePath} is ${ext}`);

Sprint-1/exercises/random.js

@@ -7,3 +7,33 @@ const num = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
 // Try breaking down the expression and using documentation to explain what it means
 // It will help to think about the order in which expressions are evaluated
 // Try logging the value of num and running the program several times to build an idea of what the program is doing
+console.log(num)
+
+
+// Math.random():
+// Generates a random floating-point number between 0 (inclusive) and 1 (exclusive). This means the result could be anything from 0 up to but not including 1.
+// Example: 0.345, 0.876, etc.
+
+// Math.random() * (maximum - minimum + 1):
+// This scales the random number to the desired range.
+// maximum - minimum + 1 ensures the range includes all numbers between minimum and maximum, inclusive.
+// If maximum is 100 and minimum is 1, this gives 100 - 1 + 1 = 100, so the range is now from 0 to just under 100.
+// Example: 0.345 * 100 could give 34.5.
+
+// Math.floor():
+// Takes the floating-point number from the previous step and rounds it down to the nearest whole number.
+// This ensures we get an integer.
+// Example: Math.floor(34.5) would result in 34.
+
+
+// + minimum:
+// After scaling and flooring, we shift the range to start from minimum instead of 0.
+// Adding minimum (1 in this case) ensures the random number falls between minimum and maximum.
+// Example: If Math.floor() gave 34, adding 1 results in 35.
+
+// Result:
+// num will be a random integer between 1 (inclusive) and 100 (inclusive).
+
+
+
+