פונקציות מובנות ב-TypeScript

מאמר זה מסביר על פונקציות מובנות ב-TypeScript.

YouTube Video

פונקציות מובנות ב-TypeScript

פונקציות מובנות ב-TypeScript הן פונקציות נוחות שנועדו לבצע פעולות יומיומיות באופן תמציתי. אלו פונקציות סטנדרטיות של JavaScript עם בטיחות טיפוס משופרת, מה שהופך אותן למועילות במיוחד ב-TypeScript. כאן נסביר בפירוט על כמה פונקציות מובנות חשובות, אופן השימוש בהן, והגדרת סוגים.

מהן פונקציות מובנות?

הפונקציות המובנות של TypeScript מבוססות על פונקציות סטנדרטיות של JavaScript. יישום מערכת הטיפוסים של TypeScript משפר את בדיקת הטיפוסים ואת ההשלמה האוטומטית. הפונקציות העיקריות כוללות את הבאות:.

• parseInt()
• parseFloat()
• isNaN()
• isFinite()
• Number()
• String()
• Array()
• Array.isArray()
• eval()
• encodeURI()
• decodeURI()
• setTimeout()
• setInterval()

פונקציות אלו נמצאות בשימוש נרחב בפרויקטים ב-TypeScript להמרה והערכת נתונים באופן תמציתי.

parseInt()

parseInt() היא פונקציה המשמשת להמרת מחרוזת למספר שלם. ניתן לציין את בסיס המספרים (כגון בינארי, עשרוני) כארגומנט שני. ב-TypeScript, ניתן לציין את הסוג באופן הבא:.

 1function stringToInt(value: string, radix: number = 10): number {
 2    const result: number = parseInt(value, radix);
 3    if (isNaN(result)) {
 4        throw new Error('Invalid number format');
 5    }
 6    return result;
 7}
 8
 9console.log(stringToInt("42")); // 42
10console.log(stringToInt("101010", 2)); // 42 (converted from binary)

• ציין שהקלט הוא מחרוזת עם value: string
• ערך ההחזרה מצוין במפורש כטיפוס number.

parseFloat()

parseFloat() היא פונקציה המשמשת להמרת מחרוזת למספר בנקודה צפה.

 1function stringToFloat(value: string): number {
 2    const result: number = parseFloat(value);
 3    if (isNaN(result)) {
 4        throw new Error('Invalid number format');
 5    }
 6    return result;
 7}
 8
 9console.log(stringToFloat("3.14")); // 3.14
10console.log(stringToFloat("2.71828")); // 2.71828

• parseFloat() יכולה לנתח מספרים בצורה נכונה כולל נקודות עשרוניות.
• על ידי ציון הסוג, ניתן לקבל אזהרה במהלך בדיקת טיפוסים אם הקלט אינו מספר.

isNaN()

isNaN() היא פונקציה שקובעת אם הערך שניתן הוא NaN (לא מספר). דוגמה לשימוש ב-TypeScript היא כדלקמן:.

1function checkNaN(value: unknown): boolean {
2    return isNaN(Number(value));
3}
4
5console.log(checkNaN("hello")); // true
6console.log(checkNaN(123)); // false

• הטיפוס unknown הוא טיפוס כללי שיכול לקבל כל טיפוס.
• המר למספר באמצעות פונקציית Number(), ובדוק אם התוצאה היא NaN.

isFinite()

isFinite() קובעת אם ערך הוא סופי.

1function isValueFinite(value: unknown): boolean {
2    return isFinite(Number(value));
3}
4
5console.log(isValueFinite("100")); // true
6console.log(isValueFinite(Infinity)); // false

• פונקציה זו גם משתמשת ב-Number() כדי להמיר את הערך למספר לפני קביעה.

Number()

פונקציית Number() ממירה מחרוזות או ערכי בוליאן למספרים.

1function convertToNumber(value: string | boolean): number {
2    return Number(value);
3}
4
5console.log(convertToNumber("42")); // 42
6console.log(convertToNumber(true)); // 1

• בדוגמה זו, משתמשים בסוג איחוד string | boolean כדי לציין שהארגומנט הוא או מחרוזת או בוליאני.

String()

הפונקציה String() ממירה מספרים או ערכי בוליאניים למחרוזות.

1function convertToString(value: number | boolean): string {
2    return String(value);
3}
4
5console.log(convertToString(123)); // "123"
6console.log(convertToString(false)); // "false"

• בדוגמה זו, פונקציה נוצרת שמקבלת איחוד מסוג number | boolean וממירה את התוצאה למחרוזת.

Array()

הפונקציה Array() משמשת ליצירת מערך חדש. בנוסף, היא מספקת שיטות מועילות רבות ליצירת תת-מערכים ממערכים קיימים או לחילוץ אלמנטים ספציפיים.

 1function createArray(): Array<number> {
 2    return Array(1, 2, 3, 4, 5); // 新しい配列を作成
 3}
 4
 5function getSubArray(array: Array<number>): Array<number> {
 6    return array.slice(1, 4); // サブ配列を作成
 7}
 8
 9const numbers = createArray();
10console.log(numbers); // [1, 2, 3, 4, 5]
11
12const subArray = getSubArray(numbers);
13console.log(subArray); // [2, 3, 4]

• בדוגמה זו, מודגם כיצד ליצור מערך חדש באמצעות הפונקציה Array() וליצור תת-מערך באמצעות השיטה slice().

Array.isArray()

Array.isArray() קובעת האם הערך הנתון הוא מערך.

1function checkArray(value: unknown): boolean {
2    return Array.isArray(value);
3}
4
5console.log(checkArray([1, 2, 3])); // true
6console.log(checkArray("Not an array")); // false

• על ידי שימוש בסוג unknown, אנו מקבלים כל סוג ובו בזמן בודקים אם הוא מערך.

eval()

הפונקציה eval() מעריכה מחרוזת כביטוי ומחזירה את התוצאה. עם זאת, לא מומלץ להשתמש בה בשל סיכוני אבטחה וביצועים.

1function evaluateExpression(expression: string): any {
2    return eval(expression);
3}
4
5console.log(evaluateExpression("2 + 3")); // 5
6console.log(evaluateExpression("'Hello ' + 'World!'")); // "Hello World!"

• בדוגמה זו, ביטוי המסופק כמחרוזת מוערך באמצעות eval, והתוצאה מוצגת.

encodeURI()

הפונקציה encodeURI() מקודדת את כתובת ה-URL כולה ומתחמקת מדמויות ספציפיות.

1const uri = "https://example.com/page?name=John Doe&age=30";
2const encodedURI = encodeURI(uri);
3
4console.log(encodedURI); // "https://example.com/page?name=John%20Doe&age=30"

• בדוגמה זו, רווחים מקודדים ל-%20 כדי ליצור URL בטוח.

decodeURI()

הפונקציה decodeURI() מפענחת כתובת URL מקודדת חזרה לפורמט המקורי שלה.

1const encodedURI = "https://example.com/page?name=John%20Doe&age=30";
2const decodedURI = decodeURI(encodedURI);
3
4console.log(decodedURI); // "https://example.com/page?name=John Doe&age=30"

• בדוגמה זו, מחרוזת URL מקודדת מפוענחת בחזרה ל-URL המקורי.

setTimeout()

הפונקציה setTimeout() מריצה פונקציה מסוימת לאחר זמן העיכוב הנתון (במילישניות).

1setTimeout(() => {
2    console.log("Executed after 2 seconds");
3}, 2000);

• בדוגמה זו, מוצגת הודעה לאחר 2 שניות.

setInterval()

הפונקציה setInterval() מבצעת באופן חוזר פונקציה מסוימת במרווח הזמן המוגדר (במילישניות).

1let count = 0;
2const intervalId = setInterval(() => {
3    count++;
4    console.log(`Interval executed ${count} time(s)`);
5    if (count === 3) {
6        clearInterval(intervalId); // Stops the interval after 3 executions
7    }
8}, 1000);

• דוגמה זו מציגה הודעה במרווחים של שנייה ועוצרת לאחר ביצוע שלוש פעמים.

סיום

הפונקציות המובנות של TypeScript מאפשרות קידוד בטוח ויעיל יותר על ידי הוספת בטיחות סוגים לפונקציות סטנדרטיות של JavaScript. הפונקציות האלו מפשטות משימות תכנות יומיומיות ומשפרות את הקריאות והתחזוקה של הקוד. כל פונקציה משמשת בצורה נכונה בהתאם למטרתה, ועל ידי ציון סוגים, ניתן לאתר שגיאות מראש, ולמלא תפקיד חשוב בשיפור האמינות של תהליך הפיתוח.

על ידי שימוש ב-TypeScript, ניתן לנצל את ההקלדה הסטטית תוך ניצול הגמישות של JavaScript.

תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.

YouTube Video