[dev]arraySum

src/ageClassification.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { classifyAge } from './ageClassification';
+
+describe('年齡分類函式測試', () => {
+    it('應將 12 歲以下分類為 Child', () => {
+        expect(classifyAge(10)).toBe('Child');
+    });
+
+    it('應將 13 至 17 歲分類為 Teenager', () => {
+        expect(classifyAge(15)).toBe('Teenager');
+    });
+
+    it('應將 18 至 64 歲分類為 Adult', () => {
+        expect(classifyAge(30)).toBe('Adult');
+    });
+
+    it('應將 65 歲以上分類為 Senior', () => {
+        expect(classifyAge(70)).toBe('Senior');
+    });
+});

src/ageClassification.ts

@@ -0,0 +1,23 @@
+/**
+ * 任務：實作一個函式 `classifyAge`，根據年齡進行分類。
+ *
+ * 範例：
+ * classifyAge(10) 應該回傳 "Child"
+ * classifyAge(15) 應該回傳 "Teenager"
+ * classifyAge(30) 應該回傳 "Adult"
+ * classifyAge(70) 應該回傳 "Senior"
+ *
+ * @param age - 一個需要被分類的年齡
+ * @returns - 回傳年齡的分類結果
+ */
+export function classifyAge(age: number): string {
+    if (age >= 0 && age < 15){
+        return 'Child';
+    }else if (age >= 15 && age < 30){
+        return 'Teenager';
+    }else if (age >= 30 && age < 70){
+        return 'Adult';
+    }else{
+        return 'Senior';
+    }
+}

src/arrayFiltering.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+import { filterEvens } from './arrayFiltering';
+
+describe('陣列過濾函式測試', () => {
+    it('應該過濾出偶數', () => {
+        expect(filterEvens([1, 2, 3, 4, 5])).toEqual([2, 4]);
+    });
+});

src/arrayFiltering.ts

@@ -0,0 +1,13 @@
+/**
+ * 任務：實作一個函式 `filterEvens`，過濾出數字陣列中的偶數。
+ *
+ * 範例：
+ * filterEvens([1, 2, 3, 4]) 應該回傳 [2, 4]
+ * filterEvens([5, 6, 7, 8]) 應該回傳 [6, 8]
+ *
+ * @param numbers - 一個需要被過濾的數字陣列
+ * @returns - 回傳只包含偶數的數字陣列
+ */
+export function filterEvens(numbers: number[]): number[] {
+    return numbers.filter((item) => item % 2 === 0 );
+}

src/arraySum.ts

@@ -14,4 +14,9 @@
  */
 export function arraySum(numbers: number[]): number {
     // 在此實現函式
+    let total: number = 0;
+    for (let i = 0; i < numbers.length; i++) {
+        total = total + numbers[i];
+    }
+    return total;
 }

src/asyncSum.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import { asyncSum } from './asyncSum';
+
+describe('非同步加總函式', () => {
+    it('應該能計算陣列中所有數字的總和', async () => {
+        const result = await asyncSum([1, 2, 3, 4, 5]);
+        expect(result).toBe(15);
+    });
+
+    it('應該能正確處理空陣列', async () => {
+        const result = await asyncSum([]);
+        expect(result).toBe(0);
+    });
+});

src/asyncSum.ts

@@ -0,0 +1,21 @@
+/**
+ * 任務：實作一個函式 `asyncSum`，該函式應該能夠計算陣列中所有數字的總和。
+ * 範例：asyncSum([1, 2, 3, 4, 5]) 應該回傳 15
+ * @param numbers - 一個數字陣列
+ * @returns - 回傳一個 Promise，該 Promise resolve 的值應該是陣列中所有數字的總和
+ */
+
+
+export function asyncSum(numbers: number[]): Promise<number> {
+    return new Promise((resolve, reject) => {
+        try {
+            const result = numbers.reduce((x, y ) => x + y, 0 )
+            resolve(result)
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+
+// 備註：題目中即使累加操作本身是同步的，也可以使用 Promise 來模擬非同步的情況。這可以讓學生練習如何使用 Promise 來處理非同步操作

src/bookCategoryEnum.ts

@@ -23,6 +23,8 @@ export enum BookCategory {
  * 輸出: 'Book category: Novel'
  */
 
-export function getBookCategory(category) {
+export function getBookCategory(category: BookCategory) {
+  let returntext: String = `Book category: ${category}`;
   // 在此實現函式
+  return returntext;
 }

src/booleanChecker.ts

@@ -2,9 +2,7 @@
  * 判斷輸入的數字是否為正數
  * @param number - 要判斷的數字
  * 
- * 注意：這個函式目前有錯誤，需要修正。正確的實現應該是判斷輸入的數字是否大於 0。
  */
 export function isPositive(number: number): boolean {
-    // 故意寫錯的程式碼
-    return number < 0;
+    return number > 0;
 }

src/calculator.ts

@@ -4,7 +4,7 @@
  * @param b - 第二個數字
  */
 export function add(a: number, b: number): number {
-    // 在此實現函式
+    return a + b;
 }
 
 /**
@@ -13,7 +13,7 @@ export function add(a: number, b: number): number {
  * @param b - 第二個數字
  */
 export function subtract(a: number, b: number): number {
-    // 在此實現函式
+    return a - b;
 }
 
 /**
@@ -22,16 +22,21 @@ export function subtract(a: number, b: number): number {
  * @param b - 第二個數字
  */
 export function multiply(a: number, b: number): number {
-    // 在此實現函式
+    return a * b;
 }
 
 /**
  * 將兩個數字相除
  * @param a - 第一個數字
  * @param b - 第二個數字
  */
-export function divide(a: number, b: number): number {
-    // 在此實現函式
+export function divide(a: number, b: number): number| null {
+
+    if (b === 0) {
+        throw new Error('Cannot divide by zero');
+    }
+
+    return a / b;
 }
 
 /**

src/dataProcessingModule.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { sortArray, filterArray, transformArray } from './dataProcessingModule';
+
+describe('資料處理模組', () => {
+    it('應該正確排序陣列', () => {
+        expect(sortArray([3, 1, 4])).toEqual([1, 3, 4]);
+    });
+
+    it('應該過濾陣列', () => {
+        expect(filterArray([1, 2, 3, 4], num => num % 2 === 0)).toEqual([2, 4]);
+    });
+
+    it('應該轉換陣列', () => {
+        expect(transformArray([1, 2, 3], num => num * 2)).toEqual([2, 4, 6]);
+    });
+});

src/dataProcessingModule.ts

@@ -0,0 +1,40 @@
+/**
+ * 任務：實作一個函式 `sortArray`，將數字陣列由小到大排序。
+ *
+ * 範例：
+ * sortArray([3, 1, 4]) 應該回傳 [1, 3, 4]
+ *
+ * @param numbers - 一個數字陣列
+ * @returns - 回傳一個數字陣列，表示排序後的結果
+ */
+export function sortArray(numbers: number[]): number[] {
+    return numbers.sort((x , y) => x - y);
+}
+
+/**
+ * 任務：實作一個函式 `filterArray`，過濾數字陣列中符合條件的元素。
+ *
+ * 範例：
+ * filterArray([1, 2, 3, 4], num => num % 2 === 0) 應該回傳 [2, 4]
+ *
+ * @param numbers - 一個數字陣列
+ * @param predicate - 一個函式，用來判斷元素是否符合條件
+ * @returns - 回傳一個數字陣列，表示過濾後的結果
+ */
+export function filterArray(numbers: number[], predicate: (num: number) => boolean): number[] {
+    return numbers.filter((item) => predicate(item) )
+}
+
+/**
+ * 任務：實作一個函式 `transformArray`，將數字陣列中的每個元素進行轉換。
+ *
+ * 範例：
+ * transformArray([1, 2, 3], num => num * 2) 應該回傳 [2, 4, 6]
+ *
+ * @param numbers - 一個數字陣列
+ * @param transform - 一個函式，用來轉換元素
+ * @returns - 回傳一個數字陣列，表示轉換後的結果
+ */
+export function transformArray(numbers: number[], transform: (num: number) => number): number[] {
+    return numbers.map((item) => transform(item));
+}

src/dataStore.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { createDataStore } from './dataStore';
+
+describe('DataStore 函式', () => {
+    it('應該允許添加和檢索項目', () => {
+        const store = createDataStore<number>();
+        store.add(1);
+        store.add(2);
+        expect(store.getAll()).toEqual([1, 2]);
+    });
+
+    it('應該能處理不同的類型', () => {
+        const stringStore = createDataStore<string>();
+        stringStore.add('hello');
+        stringStore.add('world');
+        expect(stringStore.getAll()).toEqual(['hello', 'world']);
+    });
+});

src/dataStore.ts

@@ -0,0 +1,32 @@
+/**
+ * 任務：實作一個函式 `createDataStore`，該函式會建立一個資料儲存庫，該儲存庫有兩個方法：add 和 getAll。
+ * add 方法用於添加新的項目到儲存庫，getAll 方法用於獲取儲存庫中的所有資料。
+ *
+ * 範例：
+ * const store = createDataStore<number>();
+ * store.add(1);
+ * store.add(2);
+ * store.getAll() 應該回傳 [1, 2]
+ *
+ * @returns - 回傳一個物件，該物件有 add 和 getAll 兩個方法
+ */
+export function createDataStore<T>() {
+   // 宣告一個名為 data 的變數，其為 T 型別的陣列，並初始化為空陣列
+    // T 是一個泛型參數，代表任何型別
+    let data: T[] = [];
+
+    // 定義一個名為 add 的函式，該函式接收一個 T 型別的參數 item，並將 item 添加到 data 陣列中
+    // 這裡的 T 也是泛型，所以 item 可以是任何型別
+    function add(item: T){
+        data.push(item);
+    }
+
+    // 定義一個名為 getAll 的函式，該函式回傳 data 陣列的所有元素
+    // 回傳的陣列中的元素型別也是 T，所以可以是任何型別
+    function getAll(): T[]{
+        return data
+    }
+
+
+    return { add, getAll };
+}

src/fetchData.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import { fetchData } from './fetchData';
+
+describe('非同步取得資料', () => {
+    it('應該能從提供的 URL 取得資料', async () => {
+        const data = await fetchData('https://jsonplaceholder.typicode.com/todos/1');
+        expect(data).toHaveProperty('id');
+    });
+});

src/fetchData.ts

@@ -0,0 +1,26 @@
+/**
+ * 任務：實作一個 async 函式 `fetchData`，該函式應該能夠從指定的 URL 取得資料。
+ * 範例：fetchData('https://jsonplaceholder.typicode.com/todos/1') 應該回傳一個包含 id、title 等屬性的物件
+ * @param url - 要取得資料的 URL
+ * @returns - 回傳一個 Promise，該 Promise resolve 的值應該是從 URL 取得的資料
+ */
+
+// 請在下方寫下你的程式碼
+
+type responseData = {
+    id: string;
+    title: String;
+};
+
+export async function fetchData(url: URL) {
+    return new Promise((resolve, reject) =>{
+        try {
+            fetch(url).then((res) =>{
+                const json = res.json() as unknown as responseData;
+                resolve(json);
+            });
+        }catch (error){
+            reject(error);
+        }
+    })
+}

src/filterByProperty.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { filterByProperty } from './filterByProperty';
+
+describe('filterByProperty 函式', () => {
+    it('應該根據屬性值過濾物件陣列', () => {
+        const items = [
+            { name: 'Alice', age: 30 },
+            { name: 'Bob', age: 25 },
+            { name: 'Carol', age: 30 }
+        ];
+        const result = filterByProperty(items, 'age', 30);
+        expect(result).toEqual([
+            { name: 'Alice', age: 30 },
+            { name: 'Carol', age: 30 }
+        ]);
+    });
+});

src/filterByProperty.ts

@@ -0,0 +1,16 @@
+/**
+ * 任務：實作一個函式 `filterByProperty`，該函式應該過濾出陣列中的元素，其指定屬性的值等於給定值。
+ *
+ * 範例：
+ * const array = [{ name: 'Alice', age: 20 }, { name: 'Bob', age: 20 }, { name: 'Charlie', age: 30 }];
+ * filterByProperty(array, 'age', 20) 應該回傳 [{ name: 'Alice', age: 20 }, { name: 'Bob', age: 20 }]
+ *
+ * @param array - 一個物件的陣列
+ * @param property - 要過濾的屬性名稱
+ * @param value - 要過濾的屬性值
+ * @returns - 回傳過濾後的陣列
+ */
+
+export function filterByProperty<T, K extends keyof T>(array: T[], property: K, value: T[K]): T[] {
+    return array.filter((item) => item[property] === value);
+}

src/inputHandler.ts

@@ -11,6 +11,6 @@
  * 輸出: 'Input is a number: 123'
  */
 
-export function handleInput(input) {
-    // 在此實現函式
+export function handleInput(input: number | string) {
+    return `Input is a ${typeof input}: ${input}`
 }

src/maxNumber.ts

@@ -7,4 +7,5 @@
  */
 export function findMaxNumber(numbers: number[]): number {
     // 在此實現函式
+    return Math.max(...numbers)
 }