Mga Pahayag sa Pag-uulit ng TypeScript

Ipinaliwanag ng artikulong ito ang mga pahayag sa pag-uulit sa TypeScript.

YouTube Video

Ang for na pahayag sa TypeScript

Ang for na pahayag sa TypeScript ay isang pangunahing istrukturang loop para sa pagsasagawa ng mga paulit-ulit na operasyon. Sa isang for na loop, ang parehong bloke ng code ay maaaring ulit-ulitin sang-ayon sa tinukoy na bilang o kundisyon.

Pangunahing Syntax

1for (initialization; condition; update) {
2    // Code to execute repeatedly while the condition is true
3}

• ..
• ..
• .

Halimbawa 1: Pangunahing for na loop

Sa halimbawa sa ibaba, nagbibigay ito ng mga numero mula 0 hanggang 4 sa sunud-sunod na pagkakasunod.

1for (let i = 0; i < 5; i++) {
2    console.log("The value of i is: " + i);
3}
4// Outputs:
5// The value of i is: 0
6// The value of i is: 1
7// The value of i is: 2
8// The value of i is: 3
9// The value of i is: 4

Halimbawa 2: for na loop na may array

Maaari mo ring gamitin ang isang for na loop upang iproseso ang mga elemento ng isang array nang sunud-sunod.

1let fruits: string[] = ["apple", "banana", "cherry"];
2
3for (let i = 0; i < fruits.length; i++) {
4    console.log("Fruit: " + fruits[i]);
5}
6// Outputs:
7// Fruit: apple
8// Fruit: banana
9// Fruit: cherry

Halimbawa 3: for-in na loop

Ang for-in na loop ay ginagamit upang umulit sa mga katangian ng isang object o sa mga indeks ng isang array nang sunud-sunod.

1let car = { brand: "Toyota", model: "Corolla", year: 2020 };
2
3for (let key in car) {
4    console.log(key + ": " + car[key]);
5}
6// Outputs:
7// brand: Toyota
8// model: Corolla
9// year: 2020

Halimbawa 4: for-of na loop

Ang for-of na loop ay ginagamit upang makuha ang halaga ng bawat elemento nang sunud-sunod mula sa mga iterable na object tulad ng mga array o string.

1let colors: string[] = ["red", "green", "blue"];
2
3for (let color of colors) {
4    console.log("Color: " + color);
5}
6// Outputs:
7// Color: red
8// Color: green
9// Color: blue

Halimbawa 5: Naka-nest na for Loop

Posible ring gumamit ng isang for na loop sa loob ng isa pang for na loop, na kilala bilang isang nested na loop. Ito ay nagbibigay-daan sa iyo na lumikha ng mga dobleng loop, bukod sa iba pa.

 1for (let i = 0; i < 3; i++) {
 2    console.log("Outer loop i: " + i);
 3    for (let j = 0; j < 2; j++) {
 4        console.log("  Inner loop j: " + j);
 5    }
 6}
 7// Outputs:
 8// Outer loop i: 0
 9//   Inner loop j: 0
10//   Inner loop j: 1
11// Outer loop i: 1
12//   Inner loop j: 0
13//   Inner loop j: 1
14// Outer loop i: 2
15//   Inner loop j: 0
16//   Inner loop j: 1

Buod

• Ang for na pahayag ay gumaganap ng paulit-ulit na proseso batay sa tinukoy na mga bilang o kondisyon.
• Ang for-in ay ginagamit upang makuha ang mga katangian ng isang object o ang mga indeks ng isang array.
• Ang for-of ay kumukuha ng mga halaga ng mga elemento mula sa mga iterable na object tulad ng mga array.
• Posible rin ang kumplikadong paulit-ulit na proseso gamit ang naka-nest na for loops.

Ang for na pahayag sa TypeScript ay nagbibigay ng malakas at flexible na paulit-ulit na pagproseso, katulad ng ibang mga loop.

Mga While na Pahayag sa TypeScript

Sa TypeScript, ang while statement ay isang loop construct na nagpapatupad ng paulit-ulit na proseso habang ang tinukoy na kondisyon ay true. Kagaya ng for loop, ang while loop ay angkop sa mga sitwasyon kung saan ang bilang ng pag-uulit ay hindi pa tiyak, o kung nais mong kontrolin ang pag-uulit batay sa isang kondisyon.

Pangunahing Syntax

1while (condition) {
2    // Code to execute repeatedly while the condition is true
3}

• Kondisyon: Ang kondisyon kung saan nagpapatupad ang loop. Ang loop ay magpapatuloy hangga't ang kondisyon na ito ay true, at titigil kapag naging false ito.

Halimbawa 1: Batayang while Loop

Sa halimbawa sa ibaba, patuloy nitong ipapakita ang halaga ng i habang ang i ay mas mababa sa 5.

 1let i: number = 0;
 2
 3while (i < 5) {
 4    console.log("The value of i is: " + i);
 5    i++;
 6}
 7// Outputs:
 8// The value of i is: 0
 9// The value of i is: 1
10// The value of i is: 2
11// The value of i is: 3
12// The value of i is: 4

Sa halimbawang ito, natatapos ang loop kapag ang i ay naging 5 o higit pa dahil nagiging false ang kondisyon.

Halimbawa 2: Halimbawa ng Walang Katapusang Loop

Kung ang kondisyon sa isang while loop ay laging true, maaari itong maging isang walang katapusang loop. Kadalasan, nagiging sanhi ito upang ang programa ay hindi tumigil ayon sa layunin, kaya't kailangan ng pag-iingat.

 1let x: number = 0;
 2
 3while (true) {
 4    console.log("The value of x is: " + x);
 5    x++;
 6    if (x >= 5) {
 7        break; // Exit the loop when the condition is met
 8    }
 9}
10// Outputs:
11// The value of x is: 0
12// The value of x is: 1
13// The value of x is: 2
14// The value of x is: 3
15// The value of x is: 4

Maaari mong gamitin ang break statement upang pilit na lumabas sa loop kapag ang isang kundisyon ay natugunan.

Halimbawa 3: do-while Loop

Ang do-while loop ay isang istruktura kung saan ang proseso ng loop ay isinasagawa nang hindi bababa sa isang beses. Dahil ang kondisyon ay sinusuri pagkatapos ng proseso, tumatakbo ang proseso nang hindi bababa sa isang beses kahit na ang kondisyon ay false.

1let j: number = 5;
2
3do {
4    console.log("The value of j is: " + j);
5    j++;
6} while (j < 5);
7// Outputs: The value of j is: 5

Sa halimbawang ito, ang j ay 5 mula sa simula, at ang j < 5 ay false, ngunit sa isang do-while loop, tumatakbo ito nang hindi bababa sa isang beses kahit ano pa ang kondisyon.

Buod

• Ang isang while loop ay inuulit ang proseso hangga't ang kondisyon ay true.
• Kung ang kondisyon para matapos ang loop ay hindi malinaw, kailangan mong maging maingat sa mga walang katapusang loop.
• Ang do-while loop ay naiiba sa isang karaniwang while loop dahil isinasagawa ang proseso nang hindi bababa sa isang beses.

Ang while statement sa TypeScript ay kapaki-pakinabang para sa loop processing na may hindi tiyak na bilang ng mga pag-uulit o kung kinakailangan ang dynamic na pagsusuri ng kondisyon.

break at continue

Maaari mong gamitin ang break at continue sa loob ng mga loop.

• Ginagamit ang break upang wakasan ang isang loop nang maaga.
• Ginagamit ang continue upang laktawan ang kasalukuyang pag-ulit at pumunta sa susunod na pag-ulit.

Halimbawa ng break

 1for (let i = 0; i < 10; i++) {
 2    if (i === 5) {
 3        break;  // Exits the loop when i is 5
 4    }
 5    console.log(i);
 6}
 7// Outputs 0, 1, 2, 3, 4
 8
 9let i = 0;
10
11while (i < 10) {
12    if (i === 5) {
13        break;  // Ends the loop when i is 5
14    }
15    console.log(i++);
16}
17// Outputs 0, 1, 2, 3, 4

Sa kasong ito, ang break ay naisagawa kapag ang i ay naging 5. Bilang resulta, mga numero mula 0 hanggang 4 ang ipinapakita.

Halimbawa ng continue

 1for (let i = 0; i < 5; i++) {
 2    if (i === 2) {
 3        continue;  // Skips when i is 2
 4    }
 5    console.log(i);
 6}
 7// Outputs 0, 1, 3, 4
 8
 9let i = 0;
10
11while (i < 5) {
12    i++;
13    if (i === 3) {
14        continue;  // Skips when i is 3
15    }
16    console.log(i);
17}
18// Outputs 1, 2, 4, 5

Sa kasong ito, ang continue ay naisagawa kapag ang i ay 2. Bilang resulta, mga numero maliban sa 2 ang ipinapakita.

Mga Nested Loop sa TypeScript

Ang nested loop ay isang istruktura kung saan ang isang loop ay ginagamit sa loob ng isa pang loop. Sa TypeScript, sinusuportahan ang mga istruktura ng loop gaya ng for, while, at do-while. Sa pamamagitan ng paggamit ng mga nested loop, maaari mong iproseso ang mga two-dimensional array (matrices) at gawing mas epektibo ang pagproseso batay sa maraming kondisyon.

Pangunahing Syntax

Ang pangunahing syntax ng isang nested loop ay ang mga sumusunod.

1for (let i: number = 0; i < n; i++) {
2  for (let j: number = 0; j < m; j++) {
3    // Processing for the inner loop
4  }
5}

Sa bawat pagtakbo ng panlabas na loop, matapos ng panloob na loop ang lahat ng pag-ulit nito. Ang istrukturang ito ay napaka-kapaki-pakinabang kapag humahawak ng maramihang mga loop o mga istruktura ng datos.

Halimbawa ng isang nested loop sa TypeScript

Pag-navigate sa isang two-dimensional array

Ang mga nested loop ay madalas gamitin kapag nagpoproseso ng mga multidimensional na istruktura ng data tulad ng mga two-dimensional array. Sa sumusunod na halimbawa, ang mga elemento ng isang two-dimensional array ay ina-navigate, at ang kanilang mga halaga ay ipinapakita sa console.

 1const matrix: number[][] = [
 2  [1, 2, 3],
 3  [4, 5, 6],
 4  [7, 8, 9]
 5];
 6
 7for (let row: number = 0; row < matrix.length; row++) {
 8  for (let col: number = 0; col < matrix[row].length; col++) {
 9    console.log(`matrix[${row}][${col}] = ${matrix[row][col]}`);
10  }
11}
12// Output
13// matrix[0][0] = 1
14// matrix[0][1] = 2
15// matrix[0][2] = 3
16// matrix[1][0] = 4
17// matrix[1][1] = 5
18// matrix[1][2] = 6
19// matrix[2][0] = 7
20// matrix[2][1] = 8
21// matrix[2][2] = 9

Sa halimbawa na ito, ina-navigate natin ang two-dimensional array na matrix. Ang panlabas na loop ay namamahala sa mga hilera, at ang panloob na loop ay namamahala sa mga kolum, ipinapakita ang bawat elemento nang sunod-sunod.

Kombinasyon ng dalawang arrays

Susunod, magpapakilala kami ng isang halimbawa ng pagkalkula ng lahat ng kombinasyon ng dalawang arrays. Halimbawa, maaari kang kumuha ng isang elemento mula sa bawat isa sa dalawang arrays at ilabas ang lahat ng posibleng mga pares.

 1const array1: string[] = ['A', 'B', 'C'];
 2const array2: number[] = [1, 2, 3];
 3
 4for (let i: number = 0; i < array1.length; i++) {
 5  for (let j: number = 0; j < array2.length; j++) {
 6    console.log(`Pair: (${array1[i]}, ${array2[j]})`);
 7  }
 8}
 9// Output
10// Pair: (A, 1)
11// Pair: (A, 2)
12// Pair: (A, 3)
13// Pair: (B, 1)
14// Pair: (B, 2)
15// Pair: (B, 3)
16// Pair: (C, 1)
17// Pair: (C, 2)
18// Pair: (C, 3)

Sa halimbawang ito, lahat ng mga pares sa pagitan ng string array na array1 at ang number array na array2 ay nililikha. Ang panlabas na loop ay kumukuha ng mga elemento mula sa array1, at ang panloob na loop ay kumukuha ng mga elemento mula sa array2, ipinapakita ang bawat pares.

Pagbuo ng mga coordinate gamit ang triple loop

Sa pamamagitan ng paggamit ng triple nested loops, maaari kang lumikha ng mga coordinate sa isang three-dimensional na espasyo, halimbawa.

 1for (let x: number = 0; x < 3; x++) {
 2  for (let y: number = 0; y < 3; y++) {
 3    for (let z: number = 0; z < 3; z++) {
 4      console.log(`Coordinate: (${x}, ${y}, ${z})`);
 5    }
 6  }
 7}
 8// Output
 9// Coordinate: (0, 0, 0)
10// Coordinate: (0, 0, 1)
11// Coordinate: (0, 0, 2)
12// ...
13// Coordinate: (2, 2, 1)
14// Coordinate: (2, 2, 2)

Sa ganitong paraan, ang paggamit ng triple nested loops ay nagpapahintulot sa iyo na madaling makabuo ng mga coordinate sa isang three-dimensional na espasyo.

Pagganap ng nested loops

Ang nested loops ay maginhawa, ngunit ang gastos sa pagkalkula ay mabilis na tumataas habang tumataas ang lalim ng mga loop. Halimbawa, kung mayroong n na iterations ng panlabas na loop at m na iterations ng panloob na loop, ang kabuuang bilang ng iterations ay magiging n * m. Kapag ito ay lalong naging nested, ang computational complexity ay tumataas nang eksponensyal, na maaaring makaapekto sa pagganap ng programa.

Narito ang mga computational complexities kapag nilibot ang tatlong arrays.

 1const array1: number[] = [1, 2, 3];
 2const array2: number[] = [4, 5, 6];
 3const array3: number[] = [7, 8, 9];
 4
 5for (let i: number = 0; i < array1.length; i++) {
 6  for (let j: number = 0; j < array2.length; j++) {
 7    for (let k: number = 0; k < array3.length; k++) {
 8      console.log(`Combination: (${array1[i]}, ${array2[j]}, ${array3[k]})`);
 9    }
10  }
11}

Sa kasong ito, kailangan mong kalkulahin ang array1.length * array2.length * array3.length, na nagreresulta sa 3 * 3 * 3 = 27 iterations upang maproseso ang lahat ng kombinasyon.

Pag-optimize ng nested loops

Kapag gumagamit ng nested loops, maaari mong pagbutihin ang pagganap sa pamamagitan ng pagsasaalang-alang sa mga sumusunod na optimizations.

1. Magpasok ng maagang paglabas: Lumabas sa loop nang maaga kapag nakamit na ang layunin upang maiwasan ang hindi kinakailangang iterations.
2. I-cache ang mga loop variable: Pre-cache ang mga halaga ng variable na ginagamit sa loob ng loop (lalo na ang haba at saklaw) upang mabawasan ang gastos sa pagkalkula sa bawat oras.
3. Baguhin ang mga istruktura ng data: Ang pagbabago sa istruktura ng mga arrays at objects ay maaaring maging epektibo sa pagpapabilis ng tiyak na mga paulit-ulit na proseso.

Konklusyon

Ang nested loops ay isang makapangyarihang tool sa masalimuot na pagproseso ng data at mga algorithm. Gayunpaman, habang tumataas ang lalim ng loop at bilang ng iterations, maaaring magdulot ito ng mga isyu sa pagganap. Sa tamang optimizations at maingat na disenyo, maaari mong mahusay na magamit ang nested loops sa TypeScript.

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