Mga Nakapaloob na Function sa TypeScript

Ang artikulong ito ay nagpapaliwanag ng mga nakapaloob na function sa TypeScript.

YouTube Video

Mga Nakapaloob na Function sa TypeScript

Ang mga nakapaloob na function sa TypeScript ay mga madaling gamiting function na ibinigay upang maisagawa ang pang-araw-araw na operasyon nang maikli. Ito ay mga karaniwang function ng JavaScript na may dagdag na kaligtasan ng uri, na ginagawang partikular na kapaki-pakinabang kapag nagkokodigo sa TypeScript. Dito, ipapaliwanag namin nang detalyado ang ilang mahahalagang nakapaloob na function, ang kanilang paggamit, at pagtukoy ng uri.

Ano ang Mga Nakapaloob na Function?

Ang mga nakapaloob na function ng TypeScript ay nakabase sa karaniwang mga function ng JavaScript. Ang paggamit ng sistema ng uri ng TypeScript ay nagpapahusay ng pagsusuri ng uri at awtomatikong pagkumpleto. Ang mga pangunahing function ay kinabibilangan ng mga sumusunod:.

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

Ang mga function na ito ay malawakang ginagamit sa mga proyekto ng TypeScript para sa maikling conversion at pagsusuri ng data.

parseInt()

Ang parseInt() ay isang function na ginagamit upang i-convert ang isang string sa isang integer. Maaari mong tukuyin ang radix (tulad ng binary, decimal) bilang pangalawang argumento. Sa TypeScript, maaari mong tukuyin ang uri tulad ng sumusunod:.

 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)

• Tukuyin na ang input ay isang string gamit ang value: string
• Ang return value ay tahasang tinukoy bilang uri na number.

parseFloat()

Ang parseFloat() ay isang function na ginagamit upang i-convert ang isang string sa isang floating-point na numero.

 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

• Ang parseFloat() ay maaaring tama na i-parse ang mga numero kabilang ang mga decimal na punto.
• Sa pamamagitan ng pagtukoy ng uri, maaari kang makatanggap ng babala sa panahon ng pagsusuri ng uri kung ang input ay hindi isang numero.

isNaN()

Ang isNaN() ay isang function na tumutukoy kung ang ibinigay na halaga ay NaN (Not-a-Number). Ang isang halimbawa ng paggamit sa TypeScript ay tulad ng sumusunod:.

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

• Ang unknown na uri ay isang pangkaraniwang uri na maaaring tumanggap ng anumang uri.
• I-convert sa numero gamit ang Number() function, at suriin kung ang resulta ay NaN.

isFinite()

Ang isFinite() ay tumutukoy kung ang isang halaga ay may hangganan.

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

• Gumagamit din ang function na ito ng Number() upang i-convert ang halaga sa isang numero bago tukuyin.

Number()

Ang Number() na function ay nagko-convert ng mga string o boolean na halaga sa mga numero.

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

• Sa halimbawang ito, ginagamit ang union type na string | boolean upang tukuyin na ang argumento ay alinman sa string o boolean.

String()

Ang String() function ay nagko-convert ng mga numero o boolean values sa mga string.

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

• Sa halimbawang ito, gumawa ng isang function na tumatanggap ng union ng number | boolean na uri at nagko-convert ng resulta sa string.

Array()

Ang Array() function ay ginagamit upang lumikha ng bagong array. Bukod dito, nagbibigay ito ng maraming kapaki-pakinabang na mga method para lumikha ng mga subarray mula sa mga umiiral na array o kumuha ng mga espesipikong elemento.

 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]

• Ipinakikita ng halimbawang ito kung paano gumawa ng bagong array gamit ang Array() function at lumikha ng subarray gamit ang slice() method.

Array.isArray()

Ang Array.isArray() ay tumutukoy kung ang ibinigay na halaga ay isang array.

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

• Gamit ang unknown na uri, tumatanggap tayo ng anumang uri habang sinisiyasat kung ito ay isang array.

eval()

Ang eval() function ay nag-e-evaluate ng isang string bilang isang expression at ibinabalik ang resulta. Gayunpaman, hindi inirerekomenda ang paggamit nito dahil sa mga panganib sa seguridad at pagganap.

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

• Sa halimbawang ito, isang expression na ibinigay bilang string ay ine-evaluate gamit ang eval, at ang resulta ay inilalabas.

encodeURI()

Ang encodeURI() function ay nag-e-encode ng buong URL at nag-e-escape ng ilang mga karakter.

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"

• Ang halimbawang ito ay nag-e-encode ng mga espasyo sa %20 upang makabuo ng isang ligtas na URL.

decodeURI()

Ang decodeURI() function ay nagde-decode ng isang encoded URL pabalik sa orihinal nitong anyo.

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"

• Ang halimbawang ito ay nagde-decode ng isang encoded URL string pabalik sa orihinal na URL.

setTimeout()

Ang setTimeout() function ay nagsasagawa ng isang partikular na function matapos ang itinakdang oras ng pagkaantala (sa milliseconds).

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

• Ang halimbawang ito ay nagpapakita ng mensahe matapos ang 2 segundo.

setInterval()

Ang setInterval() function ay paulit-ulit na nagsasagawa ng isang partikular na function sa itinakdang pagitan ng oras (sa milliseconds).

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);

• Ipinapakita ng halimbawang ito ang isang mensahe tuwing isang segundo at titigil matapos itong maisagawa ng tatlong beses.

Konklusyon

Ang mga built-in functions ng TypeScript ay nagbibigay-daan para sa mas ligtas at mas epektibong coding sa pamamagitan ng pagdaragdag ng type safety sa mga standard na JavaScript functions. Ang mga function na ito ay nagpapadali ng araw-araw na mga gawain sa programming at nagpapabuti ng kakayahang basahin at pag-me-maintain ng code. Ang bawat function ay nagagamit nang tama ayon sa layunin nito, at sa pamamagitan ng pagtukoy ng mga uri, maaari nitong ma-detect ang mga error nang maaga, na may mahalagang papel sa pagpapahusay ng pagiging maaasahan ng proseso ng development.

Sa paggamit ng TypeScript, maaaring samantalahin ng development ang static typing habang ginagamit ang flexibility ng JavaScript.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video