Học tập‎ > ‎C#‎ > ‎

Cấu trúc điều khiển trong C#

Không thể tìm thấy URL thông số tiện ích
Người đăng bài : duaca (30/11/2010 12:16:48 AM)

Các cấu trúc điều khiển trong C#

Khi xây dựng ứng dụng viết bởi ngôn ngữ lập trình C#, chúng ta thường phải ứng dụng các kỹ thuật cũng như khái niệm của lập trình hướng đối tượng để triển khai các lớp (Class), các giao diện (Interface), các công cụ (Library, User control, …) cần thiết cho chương trình của mình. Để thực hiện những điều này, bạn buộc phải nắm vững những khái niệm cơ bản có liên quan đến việc sử dụng biến (Variable), hằng (Constant), các kỹ thuật cơ bản hỗ trợ cho quá trình xây dựng mã lệnh. Một trong những kỹ năng cần có chính là phải hiểu rõ và sử dụng các cấu trúc điều khiển chương trình của C# một cách thuần thục.

C# cung cấp khá đa dạng và linh hoạt các cấu trúc điều khiển cơ bản để lập trình viên có thể sử dụng khi viết mã lệnh, các cấu trúc lệnh này thông thường được chia làm 3 nhóm như sau

-          Các cấu trúc lựa chọn để thực thi lệnh theo tình huống (Selection constructs): với mục đích làm cho khả năng thực thi của chương trình được linh hoạt chúng ta sẽ sử dụng cấu trúc dạng này. Ứng với mỗi tình huống khác nhau sẽ có những cách giải quyết khác nhau, các lệnh thuộc dạng này thường thấy: if …; ifelse …; switch … (Các cấu trúc thuộc dạng này còn được gọi với cụm từ :Cấu trúc rẽ nhánh”).

-          Các cấu trúc lặp để thực thi các lệnh theo chu kỳ (Loop constructs): Khi có 1 hoặc nhiều lệnh cần phải thực thi nhiều lần, chúng ta sẽ sử dụng đến cấu trúc lặp trong chương trình của mình. Thường thì cấu trúc lặp trong các ngôn ngữ lập trình hiện đại thường chia làm 3 dạng: lặp với số lần xác định, không xác định và lặp trên 1 tập hợp các phần tử (Ở đây ta hiểu số lần lặp xác định và không xác định là đối với trước khi thực hiện quá trình lặp, còn dĩ nhiên sau khi đã thực hiện xong thì đã biết chính xác tại thời điểm đó lặp bao nhiêu lần rồi). Các cấu trúc lặp mà chúng ta sẽ sử dụng trong C#: for …, dowhile, while …, foreach

-          Các cấu trúc lệnh “Jump” (Jump constructs): Như chúng ta biết, mặc nhiên thì quá trình thực thi các lệnh trong chương trình sẽ là “tuần tự, liên tục”. Tức là khi chương trình thi hành, các lệnh sẽ thực thi từ trên xuống dưới, từ trái qua phải, hết lệnh này sẽ thực thi đến lệnh kế tiếp. Tuy nhiên, trong những tình huống nào đó, sau khi thi hành đến lệnh thứ n thì không cần thiết phải thực thi những lệnh còn lại nữa bởi vì đến đó, bài toán đã được giải quyết, việc thực thi các lệnh còn lại là dư thừa. Để giải quyết vấ đề này, C# cung cấp cho chúng ta các lệnh: break, continue, return, goto, …

Ở trên, tôi đã tóm lược những ý chính mô tả cho mục tiêu của bài viết này. Bây giờ, chúng ta sẽ làm quen với cả 3 dạng cấu trúc lệnh như đã giới thiệu.

Cấu trúc thực thi lệnh dựa theo tình huống (Selection constructs)

Như đã giới thiệu ở trên, để làm cho chương trình được thông minh hợn, biết xử lý dữ liệu với nhiều cách ứng với mỗi tình huống của dữ liệu đưa vào thì chúng ta sẽ dùng cấu trúc dạng này. Trong đó thông thường với những tình huống xử lý mà dữ liệu có logic suy diễn dạng kế thừa thì chúng ta sẽ dùng ifelse … Ví dụ: nếu giá trị số không lớn hơn 5 thì ngược lại chắc chắn sẽ nhỏ hơn hoặc bằng 5, hoặc nếu không phải là số chẵn thì chắc chắn sẽ là số lẻ…

Cấu trúc ifelse

Cấu trúc if có thể sử dụng ở 2 dạng đơn và kép, cú pháp được mô tả như sau

Cú pháp:

      if (<biểu_thức_logic)>)
      {
                <lệnh>;
                …
                …
      }

Với cú pháp này, cấu trúc if chỉ dùng để thực thi 1 tập lệnh khi thỏa mãn điều kiện của biểu thức logic (kết quả của biểu thức logic trả về là true). Ở đây biểu thức logic sử dụng thông thường là dạng relational expression với các toán tử quan hệ để so sánh sự tương quan giữa 2 giá trị (Nếu quên phần toán tử và biều thức quan hệ, bạn nên xem lại bài ‘Lệnh và toán tử trong C#)

Tôi sử dụng 1 bài minh họa truyền thống mà có lẽ bạn thường thấy trong các tài liệu dạy lập trình để minh họa cho việc sử dụng cấu trúc if ở dạng đơn. Yêu cầu: viết chương trình cho nhập 3 số sau đó in ra số lớn nhất trong 3 số đã nhập

static void Main(string[] args)
{
    int a = 0, b = 0, c = 0;
      string tam = "";
           
      Console.Write("Nhap so thu nhat:");  
// Đưa ra thông báo nhập sữ liệu cho số a
      tam = Console.ReadLine();             // Chuyển dữ liệu nhập dạng chuỗi thành kiểu int
      a = int.Parse(tam);                   // Gán kết quả sau khi chuyễn đổi cho biến a
           
      Console.Write("Nhap so thu hai:");   
// Tương tự như việc nhập số a
      tam = Console.ReadLine(); 
      b = int.Parse(tam);

      Console.Write("Nhap so thu ba:");    
// Tương tự như việc nhập số a
      tam = Console.ReadLine();
      c = int.Parse(tam);

      int max = a;                          
// Giả thiết số a lớn nhất
      if (b > max)                          // Kiểm tra giả thiết, nếu giả thiết là sai
            max = b;                        // thì tới đây ta biết được a, b số nào lớn nhất
      if (c > max)                          // tương tự, đến đây ta xác định được
            max = c;                        // số lớn nhất trong 3 số đã nhập
      Console.WriteLine("So lon nhat trong 3 so: {0}", max); Console.ReadLine();
}

Nếu cú pháp dạng đơn chỉ quan tâm xử lý, thực thi lệnh khi biểu thức logic đúng thì với cú pháp dạng kép, chúng ta sẽ đưa ra các phương án xử lý trong cả trường hợp đúng lẫn trường hợp sai.

Cú pháp:

      if (<bieu_thuc_logic>)
      {
                <Lệnh>;
                …
      }
else
      {
                <Lệnh>;
                …
      }

Như vậy, với cú pháp này thì tập lệnh đặt ngay sau biểu thức điều kiện của if sẽ thực thi khi kết quả của biểu thức logic là đúng, ngược lại thì tập lệnh đặt sau từ khóa else sẽ thực hiện

Chúng ta thực hiện minh họa cấu trúc này thông qua việc xác định 1 số nhập vào từ bàn phím là chẵn hay lẻ.

static void Main(string[] args)
{
    int x = 0;
    string tam = "";
           
    Console.Write("Nhap vao so can xet:");
// Đưa ra thông báo nhập sữ liệu cho số x
    tam = Console.ReadLine();              // Chuyển dữ liệu dạng chuỗi thành kiểu int
    x = int.Parse(tam);                    // Gán kết quả sau khi chuyễn đổi cho biến x

    if (x < 0)
    {
          Console.WriteLine("Đay la so am, khong xet !");
    }
    else                                  
// Ngược lại chắc chắn đó là số dương
    {
          if (x % 2 ==0)                   
// Nếu chia hết cho 2 thì là số chẵn
                Console.WriteLine("{0} là số chẵn !",x);
          else                            
// nếu không chia hết cho 2 thì là số lẻ
                Console.WriteLine("{0} là số lẻ !", x);
    }
    Console.ReadLine();
}

Cấu trúc switch () ……

Trên thực tế ta thấy khi dữ liệu đưa vào là hữu hạn và điều kiện xét để thực thi tình huống có tính liệt kê, ta sẽ dùng cấu trúc dạng này. Ví dụ : ngày mai không phải thứ 2 thì chưa chắc đã là thứ 3, có thể là 1 thứ nào đó trong 1 tuần.

Cú pháp

      switch (<biến_giá_trị>)
      {
               
case <giá_trị>:
                         <lệnh>;
                         …
                         
break;
               
case <giá_trị>:
                          <lệnh>;
                          …
                        
break;
               
case <giá_trị>:
                          <lệnh>;
                         …
                        
break;
                …
                …
               
default:
                         <lệnh>;
                          …
      }

Như bạn thấy, khi sử dụng cấu trúc switch, 1 biến thuộc kiểu dữ liệu hữu hạn, đếm được (byte, int, short, char, long,  bool … không thể là float hay double) được chỉ định trong giới hạn của cặp dấu “()” sau đó các tình huống mà giá trị của biến có thể liệt kê được sẽ thể hiện dựa vào từ khóa case ở tập lệnh mô tả kế tiếp. Khi biến mang giá trị tương ứng với giá trị liệt kê ở case nào thì các lệnh thuộc case đó sẽ được thực hiện tuần tự, liên tục cho đến khi gặp lệnh break thì thoát khỏi cấu trúc (Nếu không có lệnh break để kết thúc việc thi hành tập lệnh của case đó thì tập lệnh của case kế tiếp sau nó sẽ tiếp tục được thực hiện, chính vì thế để kết thúc 1 case thì ta phải có lệnh break đặt ở vị trí cuối cùng của case tương ứng).

Với ví dụ minh họa sau đây, chúng ta sẽ mô tả cho tình huống nhập vào 2 giá trị số tương ứng vói tháng và năm cần xét, sau đó chương trình sẽ in ra thông báo trên màn hình cho biết tháng đã nhập có bao nhiêu ngày

static void Main(string[] args)
{
    int thang = 0, nam=0, sn=0;
    string tam = "";

    Console.Write("Nhap vao thang can xet:");
    tam = Console.ReadLine(); thang = int.Parse(tam);
    Console.Write("Nhap vao nam can xet:");
    tam = Console.ReadLine(); nam = int.Parse(tam);
    if ((thang < 1) || (thang > 12))
          Console.WriteLine("Không có tháng này {0}. Không xét !.", thang);
    else
    {
          switch (thang)
          {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                      sn = 31;
                      break;
                case 4:
                case 6:
                case 9:
                case 11:
                      sn = 28;
                      break;
                case 2:
                      if((nam % 400 == 0)||((nam % 100 != 0)&&(nam % 4 == 0)))
                            sn = 29;
                      else
                            sn = 28;
          }
    }
    Console.WriteLine("Tháng {0} năm {1} có {2} ngày !", thang,nam,sn);
    Console.ReadLine();
}

Lưu ý:

Theo như tôi được biết, thì cách tính năm nhuần được xét đến với 2 tình huống: nếu là năm đầu thế kỷ thì phải chia hết cho 400 hoặc nếu không phải là năm đầu thế kỷ thì chia hết cho 4, tháng 2 của năm tương ứng sẽ có 29 ngày (Cách tính này tham khảo theo cách tính của năm dương lịch mà ra, chúng ta chỉ biểu diễn bằng cấu trúc lệnh trong lập trình mà thôi, bạn không nên quá chú trọng vào đoạn code tính nhuần cho tháng 2 quá nhiều, mục tiêu chính của chúng ta là mô tả cấu trúc lệnh switch)

Cấu trúc lặp, thực thi lệnh theo chu kỳ (Loop constructs)

Khi các lệnh cho cùng mục tiêu cần phải thực thi nhiều lần (lặp đi lặp lại) thì chúng ta sẽ cần đến cấu trúc lệnh dạng này trong chương trình của mình.

Cấu trúc do while

Với cấu trúc này, bạn cần nó trong trường hợp muốn thực thi 1 số lệnh nào đó nhiều lần nhưng không biết trước sẽ lặp bao nhiêu lần trước khi vòng lặp thực hiện.

Cú pháp

       do
      {
                <Lệnh>;
                …
                …
      }while (<biểu_thức_logic>);

Theo cú pháp, tập lệnh trong vòng lặp của cấu trúc dowhile sẽ thực thi trước, sau đó kiểm tra biểu thức logic, nếu thỏa mãn thì tập lệnh tiếp tục được thực hiện, nếu biểu thức logic không thỏa mãn thì vòng lặp sẽ dừng lại, như vậy ta thấy nếu sử dụng cấu trúc này thì tối thiểu số lần lặp của tập lệnh sẽ là 1 lần

Trong ví dụ minh họa sau đây, tôi sẽ ứng dụng cấu trúc dowhile cho mục đích kiểm tra dữ liệu đầu vào. Nếu dữ liệu thỏa mãn thì chương trình sẽ tiến hành tính toán và in ra thông báo kết quả, nếu dữ liệu nhập sai thì chương trình sẽ yêu cầu nhập lại cho đến khi nào đúng thì thôi.

Yêu cầu: Viết 1 chương trình cho phép người dùng nhập vào 1 giá tri số tượng trưng cho điểm của 1 môn học nào đó. Nếu điểm nhập vào nằm trong khoảng từ 0 … 10 thì tính xếp loại và in ra thông báo. Nếu điểm nhập sai (Ngoài khoảng 0 … 10) thì yêu cầu nhập lại đến khi nào đúng thì thôi.

static void Main(string[] args)
{
    float diem;
    string xepLoai = ""; string tam;
   
//--- Thực hiện lặp và kiểm tra dữ liệu, vòng lặp chỉ dừng khi dữ liệu nhập đúng
    do{
          try
          {
                Console.Write("Hãy nhập điểm môn học:");
                tam = Console.ReadLine(); diem = float.Parse(tam);
          }
          catch (Exception ex)
          {
                diem = -1;
          }
          if ((diem<0)||(diem>10))
                Console.WriteLine("Điểm phải là giá trị trong khoảng 0 ... 10");
    }while ((diem<0)||(diem>10));
   
//--- Sử dụng cấu trúc if ... else ... để xác định khoảng giá trị phù hợp với xepLoai
    if (diem < 5)
          xepLoai = "Yếu";
    else if (diem < 7)
          xepLoai = "Trung bình";
    else if (diem < 8)
          xepLoai = "Khá";
    else if (diem < 9.5)
          xepLoai = "Giỏi";
    else
          xepLoai = "Xuất sắc";
   
//--- In ra thông báo về diem đã nhập cùng với xếp loại tính được
    Console.WriteLine("Điểm đã nhập: {0:f} - xếp loại: {1}", diem,xepLoai);
    Console.ReadLine();
}

Trong ví dụ trên, tôi sử dụng cấu trúc trycatch … để kiểm soát những lỗi “bất khả kháng” trong quá trình chương trình hoạt động (runtime error). Đây là 1 dạng lỗi có thể phát sinh vào thời điểm mà chương trìn thi hành, chúng ta rất khó để có thể kiểm soát được chính xác vấn đề phát sinh tại thời điểm đó (ví dụ khi nhập dữ liệu, người dùng không nhập số mà nhập chữ), như vậy việc thực thi phương thức parse có nguy cơ dẫn đến lỗi runtime, lúc này cấu trúc trycatch … sẽ có ý nghĩa như sau, nếu dữ liệu nhập đúng, tập lệnh trong phạp vi của try sẽ thực thi như bình thường, nếu dữ liệu nhập vào là sai dẫn đến lệnh float.parse bị lỗi, lúc này tập lệnh của catch sẽ được thực thi để giải quyết hậu quả.

Cấu trúc while

Khác với dowhile, cấu trúc while sẽ kiểm tra điều kiện trước khi thi hành và nó chỉ lặp, thi hành tập lệnh bên trong nó khi điều kiện logic đúng, như thế có thể nói cấu trúc này có số lần lặp tối thiểu là 0 (Điều kiện không thỏa mãn ngay lần lặp đầu tiên).

Cú pháp

       while (<biểu_thức_logic>)
      {
               <Lệnh>;
               …
               …
      }

Với cấu trúc này, chúng ta sẽ cùng viết 1 ví dụ minh họa cho việc xác định xem 1 số có phải là nguyên tố hay không ?. Như chúng ta đã biết số nguyên tố là 1 số tự nhiên chỉ chia hết cho 1 và cho chính nó. Như vậy ví dụ dưới đây ta ứng dụng việc sử dụng cấu trúc while để xét xem số x có chia hết cho số nào nhỏ hơn nó hay không?.

static void Main(string[] args)
{
    int x=0; string tam="";
    //--- Thực hiện lặp và kiểm tra dữ liệu, vòng lặp chỉ dừng khi dữ liệu nhập đúng
    do
    {
          try{
                Console.Write("Hãy nhập số cần xét:");
                tam = Console.ReadLine(); x = int.Parse(tam);
          }
          catch (Exception ex){
                x = -1;
          }
          if (x < 0) Console.WriteLine("Phải nhập số nguyên dương !");
    } while (x >= 0);

    int i = 2;                          //--- Khởi động i với giá trị ban đầu = 2
    while ((i < x) && (x % i != 0))     //--- Lặp khi i còn chưa bằng x và x không chia hết cho i
          i++;                          //--- Tăng giá trị của i khi 2 điều kiện trên cùng thỏa mãn
    if (i == x)                         //--- Nếu i=x chứng tỏ x chỉ chia hết cho chính nó
          Console.WriteLine("{0} Là số nguyên tố !", x);
    else
          Console.WriteLine("{0} Không phải số nguyên tố !", x);
    Console.ReadLine();
}

Cấu trúc for

Không giống như cấu trúc while và dowhile, for là cấu trúc lặp thường sử dụng trong tình huống đã xác định trước số lần lặp trước khi vòng lặp thực hiện, cấu trúc này khi sử dụng phải đảm bảo 3 nguyên tắc sau:

-          Cần 1 biến kiểm soát vòng lặp thuộc kiểu hữu hạn (thường hay dùng là kiểu nguyên như int, byte, short, long, char,...)

-          Phải có 1 biểu thức logic để vòng lặp kết thúc (thực thi với số lần hữu hạn)

-          Biến kiểm soát vòng lặp phải bị biến đổi để tiến đến giá trị mong muốn tương ứng với việc làm cho biểu thức logic không thỏa mãn và vòng lặp sẽ dừng lại

Cú pháp

       for(<kiểu_dl> <biến>=<giá_trị>; <biểu_thức_logic>; <biến_đổi_gt_biến_điều_khiển>)
      {
               <Lệnh>;
               …
               …
      }

Ví dụ : Chúng ta muốn tính tổng của các số trong giới hạn từ 1 … 10, ta sẽ ứng dụng cú pháp của for như sau

      int tong = 0;
      for(int i=1; i<=10; i++)
      {
               tong += i;
      }
     
Console.WriteLine("Tổng các số từ 1 … 10 = {0}", tong);
    Console.ReadLine();

trong tình huống của ví dụ trên, bạn thấy tôi sử dụng biến i để điều khiển vòng lặp với giá trị khởi đầu =1 (nguyên tắc thứ 1), biểu thức điều khiển đưa ra là lặp khi nào i còn nhỏ hơn hay bằng 10, như thế khi i lớn hơn 10 thì vòng lặp sẽ kết thúc (nguyên tắc thứ 2), thành phần biến đổi giá trị biến điều khiển tôi sử dụng toán tử tăng (++) cho biến i và như thế, sau mỗi lần lặp biến i sẽ tự động tăng lên 1 giá trị (nguyên tắc thứ 3).

Bây giờ, chúng ta sẽ cùng nhau thực hiện 1 ví dụ đơn giản là viết chương trình ứng dụng vòng lặp for để in ra bảng cửu chương thứ i trên màn hình

    static void Main(string[] args)
    {
          int cc = 0;
          //--- Thực hiện lặp và kiểm tra dữ liệu, vòng lặp chỉ dừng khi dữ liệu nhập đúng
          do
          {
                try{
                      Console.Write("Hãy bảng cửu chương cần xem:");
                      tam = Console.ReadLine(); cc = int.Parse(tam);
                }catch (Exception ex){
                      cc = -1;
                }
                if ((cc <= 0)|| (cc>10)) Console.WriteLine("Phải nhập số nguyên dương trong khoảng 1..10!");
          } while ((cc <= 0)||(cc>10));
          Console.WriteLine("Bảng cửu chương {0}", cc);
          for (int i = 1; i <= 10; i++)
          {
                Console.WriteLine(" {0} x {1} = {2}", cc, i, cc * i);
          }
          Console.ReadLine();
    }

Cấu trúc foreach

Về cơ bản thì foreach có cách thức hoạt động cũng gần giống như cấu trúc for, tuy nhiên theo quan điểm thì nếu dùng for bạn phải xác định được khi bắt đầu lặp thì giá trị khởi đầu của biến điều khiển là bao nhiêu và khi kết thúc, biến điều khiển sẽ là bao nhiêu. Trong những tình huống đặc biệt, việc xác định như vậy hoàn toàn không dễ (vẫn có thể xác định được nhưng không dễ dàng và như thế thì lập trình viên sẽ phải vất vả hơn chút chút);

Hãy thử liên tưởng đến tình huống nếu bạn làm việc với tập hợp các ô (Cells) trong bảng tính của Excel, bạn luôn phải xác định bắt đầu lặp từ ô nào, địa chỉ bao nhiêu, vị trí thứ mấy và sẽ lặp đến ô nào, ô đó …, …, … !!! mới nghĩ đến đây đã thấy ngại rồi (mặc dù chúng ta rất chịu khó). Quan điểm lập trình nếu sử dụng foreach khá đơn giản, vẫn với tình huống trên, chúng ta chỉ việc nhìn nhận theo quan điểm khai báo 1 biến thuộc kiểu dữ liệu tương đương với ô của bảng tính (Cells) sau đó tiến hành lặp trên tập hợp các ô của bảng dữ liệu đã đọc được là đủ

 Khi sử dụng foreach, ta phải đảm bảo 1 nguyên tắc:

-          Biến điều khiển phải có kiểu dữ liệu tương ứng với kiểu dữ liệu của các phần tử thuộc tập hợp mà bạn chỉ ra và trong quá trình lặp, do đó biến điều khiển sẽ lần lượt chứa các giá trị chính là các phần tử của tập hợp mà bạn cần xét

Cú pháp

       foreach(<kiểu_dl> <biến_điều_khiển> in <tâp_hợp>)
      {
               <Lệnh>;
               …
               …
      }

Trên thực tế việc sử dụng foreach trong khá nhiều tình huống sẽ biểu diễn thuật toán của chương trình trong sáng, đơn giản. Tuy nhiên nếu bạn là người mới bắt đầu với lập trình, có lẽ ví dụ trong phần này sẽ hơi khó hiểu. Chính vì vậy tôi sẽ chỉ giới thiệu 1 ví dụ mang tính giả định để bạn biết cách sử dụng cú pháp, tạm thời bạn đừng quan tâm nhiều đến ý nghĩa thực tế của nó.

Giả thiết tôi cần đọc giá trị của tất cả các ô(TableCell) có trong 1 bảng (Table), như vậy tôi sẽ dùng 2 vòng lặp foreach, vòng lặp thứ nhất tôi sẽ lặp trên tất cả các dòng (TableRow) cùa bảng, vòng lặp thứ 2, tương ứng với mỗi dòng tôi sẽ lặp trên tập hợp các ô thuộc dòng đó để lấy dữ liệu trong các ô và viết ra màn hình.

          Table tb = (Table)this.bangTTGD.Controls[0];  //--- Đọc thông tin của bảng từ giao diện
          //--- Lặp trên tất cả các dòng của ba2ngTTLD để lấy dữ liệu ---------------
          foreach (TableRow dong in a.Rows)
          {
                //-- Lặp trên tất cả các ô thuộc dòng hiện hành
                foreach (TableCell o in dong.Cells)
                {
                      Console.Write("{0} ",o.Text);
                }
                Console.WriteLine();
          }
          Console.ReadLine();

Nhóm lệnh “Jump” của c# (Jump constructs)

Khác với các cấu trúc khác của C#, các lệnh thuộc nhóm này thường dùng cho mục đích phá vỡ tính tuần tự, liên tục (Sequence, flow) đối với việc thi hành lệnh trong chương trình.

Lệnh  break

Lệnh này thường dùng để thoát khỏi cấu trúc switch, hay 1 cấu trúc lặp nào đó, bỏ qua việc thực thi các lệnh còn lại.

Cú pháp

       break;

Ngoại trừ cấu trúc switch, thông thường lệnh break nếu sử dụng trong 1 cấu trúc lặp thì phải đi kèm với 1 cấu trúc if với ý nghĩa rằng nó chỉ thoát khỏi vòng lặp khi thỏa mãn 1 điều kiện logic nào đó. Hãy quan sát hình minh họa dưới đây khi ứng dụng lệnh break trong cấu trúc for

Lệnh  continue

Lệnh này thường chỉ dùng cho các cấu trúc lặp trong C#, sự khác biệt của nó so với lệnh break ở chỗ là lệnh break sẽ bỏ qua việc thực thi các lệnh còn lại và kết thúc vòng lặp còn continue thì bỏ qua việc thi hành các lệnh và quay về đầu cấu trúc để sẵn sàng cho lần lặp kế tiếp

Cú pháp

       continue;

Hãy quan sát hình minh họa dưới đây khi ứng dụng lệnh continue trong cấu trúc for

Lệnh  goto

Lệnh goto cho phép bạn có thể chuyển quyền thực thi chương trình đến 1 nhãn (label) đã được định nghĩa trong chương trình để thiếp tục thực thi các lệnh đặt ở phía sau nhãn này

Cú pháp

       Goto <nhan>;

Nhãn là 1 định đanh (identified) được tạo ra trong chương trình giống như việc ta tạo ra 1 điểm mốc để chương trình biết và chuyển đến đó, cách đặt tên nhãn cũng giống như đặt tên biến nhưng luôn phải bắt đầu bởi ký tự trong bảng chữ cái và kết thúc bở dấu “:” .

Nhãn Hãy quan sát hình minh họa dưới đây khi ứng dụng lệnh goto trong chương trình

Lệnh  return

Về cơ bản thì lệnh return cũng khá giống với lệnh goto ở trên, tuy nhiên nếu lệnh goto làm việc với 1 nhãn đã có trong chương trình thì lệnh return chỉ làm việc với hàm, phương thức (function, method). Mục đích của việc sử dụng lệnh return là trả quyền điều khiển thực thi chương trình cho nơi đã gọi hàm có

Cú pháp

       return [giá_trị];

Hãy quan sát hình minh họa dưới đây cho việc sử dụng lệnh return

Đũa cả

www.bodua.com

Tài liệu tham khảo : Giáo trình Aptech

Comments