Lua'da atamalar ve kontrol yapıları

Geçmiş eğitimlerde nasıl olduğunu gördük Lua hem değerlerin hem de türlerin dinamik bir şekilde ele alınmasına olanak tanır, bu işlemleri gerçekleştirirken her zaman sadeliği ve çok yönlülüğü ile öne çıkar.
Ama bu hepsi değil Lua basitlik açısından sunar, geleneksel olarak dillerde bulabileceğimiz bildirimleri destekler. C veya paskalBu bildirimlerin hem atamaları hem de kontrol yapılarını içerdiği durumlarda, çoklu atamalar ve yerel bildirimler gibi bazı alışılmamış yollara bile rastlayabiliriz.
içindeki atamalar Lua Son derece basittirler ve programımızda belirli bir zamanda bir değişkenin değerini değiştirmek için çalışırlar, etkileşimli konsolu kullanarak basit bir örnek görelim. Lua, ayrılmış kelimeyi yerleştirerek girebileceğimiz lua Terminalde:

Gördüğümüz gibi, değişkenlerin değerini birleştirme işlemleriyle, aritmetikle veya basitçe değer yazarak değiştirerek, bazı basit atama örneklerimiz var. Ayrıca, Lua bir değer listesinin bir değişken listesine atandığı, doğru işlem için bu listeleri her zaman virgülle ayırarak çoklu atamaya izin verir:

görebildiğimiz gibi var1 sayısal değeri aldım ve var2 metin değeri, bu atamanın yapıldığı sıraya göre. Gözlemciysek, her iki değişkenin değerlerini de nasıl değiştirebileceğimizi görüyoruz, bu, işlevlerle çalışırken kullanışlı olan bir şey.
Lua Hatta mevcut değişken sayısı için değer sayısını bile ayarlayabilirsiniz, örneğin değerler listesi değişkenler listesinden daha az ise ekstra değişkenlere değer tipi verilir. sıfır varsayılan olarak değerleri olarak, bu işlemin bir örneğini görelim:

Gördüğümüz gibi, ilk iki değişken karşılık gelen değerleri alır ve bunlardan sonuncusu otomatik olarak alır. sıfır açıkladığımız gibi. Birden fazla atamanın her zaman basit atamalardan daha hızlı olmadığını belirtmek önemlidir, ancak birkaçını adlandırmak için bir işlev çağrısından birden çok dönüş toplamamıza yardımcı olurlar.
Global değişkenlere ek olarak, Lua Global değişkenlerden farklı olarak, tanımlandıkları bloğa bağlı olarak sınırlı bir kapsamı olan yerel değişkenleri destekler, bir yerel değişkeni nasıl bildireceğimizi görelim:

Bu değişkenlerin bildirimini gördüğümüz gibi bunları ayrılmış kelime ile yapıyoruz. yerelBu değişkenler tanımlandıkları blokta çalışırlar, örneğin bir bloğun bir kontrol yapısı veya bir fonksiyon olabileceğini söyleyebiliriz, aşağıdaki örneği görelim:

 x = 10 yerel i = 1 iken i <= x do yerel x = i * 2 yazdır (x) i = i + 1 son ise i> 20 ise yerel xx = 20 yazdır (x + 2) yoksa yazdır (x) son yazdır (x) 

Aynısını terminalimizde uygularsak, sonucun beklediğimiz gibi olmayabileceğini göreceğiz ve bunun nedeni değişkenleri kullandığımız farklı bloklarımız olması, sonucu görelim:

Programımızın kontrolü sınırlı olsa da sınırlayıcıları kullanabiliriz. bitmek bilmeyen Bir blok belirtmek ve yerel değişkenlerimizin kapsamının ne kadar olduğunu bilmek için, bunu yapabileceğimiz bir örnek görelim:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Var1 ve var2 print (x, y) print (var1, var2) kapsamı burada sona eriyor

Terminalimizde çalıştırdığımızda, x ve y değişkenlerinin global oldukları için sorunsuz gösterildiğini, ancak var1 ve var2 için kapsamlarının blokla bittiğini göreceğiz. bitmek bilmeyen, görelim:

Programlarımızda yerel değişkenlerin kullanılmasının iyi bir uygulama olduğunu, gereksiz isimlerle global ortama dokunmamamıza yardımcı olduğunu, ayrıca bu değişkenlere erişimin global değişkenlerle yaptığımızdan çok daha hızlı olduğunu ve son olarak bu değişkenlerin çok daha hızlı olduğunu vurgulayabiliriz. değişkenler kapsamları biter bitmez kaybolur, böylece bellek alanı boşaltılır, bu nedenle mümkün olduğunda bunların kullanılmasını öneririz.
Kontrol YapılarıDiğer programlama dilleri gibi, Lua iyi bilinen kullanarak programlarımızda kullanmamız için bize bir dizi kontrol yapısı sağlar. Eğer koşulları ele almak ve süre, tekrar et Y için dışında yinelemeli döngüler için tekrar et açık sonlandırıcıya sahip olan a kadar ve diğerleri ile biten son.
Çoğu programlama dilinde olduğu gibi beyanname Eğer bir koşulu kontrol eder ve bir kısmını yürütür Daha sonra ya da parçası Başka, ikincisinin isteğe bağlı olabileceği durumlarda, programlarımızda görüldüğü gibi bu koşulların bir dizisini görelim:

 var1 <0 ise var1 = 0 end eğer var1 max satırları ise () satırları göster = 0 end

Burada üç tür işlemimiz var, temel olan Daha sonra, koşula göre bir değer döndürmek için return ve bir işlevi çağıran biraz daha eksiksiz bir kod parçası kullanmak. Bunun dışında yazabiliriz Eğer kullanarak iç içe başka türlü, bu da bizi birden fazla kullanmak zorunda kalmaktan kurtarıyor biter, nasıl göründüğüne bir bakalım:

 if işlemi == "+" ise sonuç = a + b elseif işlemi == "-" o zaman sonuç = a - b elseif işlemi == "*" o zaman sonuç = a * b elseif işlemi == "/" o zaman sonuç = a / b else hatası ("Geçersiz işlem") sonu

Bunun sadece daha optimal değil, aynı zamanda gerekli olduğuna dikkat etmek önemlidir. Lua tür bildirimlerine sahip değil değiştirmek bu nedenle bu tür iç içe koşullar programlarımızda oldukça yaygın olacaktır.
Diğer dillerde olduğu gibi, Lua önce durumunu değerlendir süre, koşul false ise döngü sona erer ve aksi halde aşağıdaki kod satırları yürütülür ve koşul false olana kadar işlem tekrarlanır, bunu göstermek için basit bir örnek görelim:

 local i = 1 iken var1 [i] do print (var1 [i]) i = i + 1 end

Bu açıklamanın aksine süre koşulun içindeki kodu doğru olana kadar tekrar etmemize izin verir, burada koşulun değerlendirilmesi sonunda yapıldığından bu kod bile en az bir kez çalıştırılabilir, bir örnek görelim:

 satırı tekrarla = os.read () ~ = "" satırına kadar yazdır (satır)

Yinelemeli döngülerle ilgili için, Lua iki çeşidi vardır, sayısal için ve için genel. Sayısalın sözdizimine bakalım:

 var = exp1, exp2, exp3 için do end

Bu döngü, her bir değer için bir şeyler yürütecektir. var itibaren exp1 a kadar exp2 kullanarak exp3 dahil etmezsek, var veya azaltılacak değer olarak Lua varsayılan olarak birer birer gittiğini varsayar, bu döngülerin daha ayrıntılı bir örneğini görelim:

 var = 1, f (x) için yazdır (var) bitiş için var2 = 10,1, -1 yazdır (var2) bitiş

Uygulamasının oldukça basit olduğunu ve programlarımızda yararlı yinelemeli döngüleri uygulamamıza izin verdiğini gördüğümüze göre, şimdi bunun sözdizimini görelim. için genel:

 i için, ipairs'de (dizi) var yazdır (var) bitiş

Bu döngünün yaptığı, bize verdiği işlevi kullanmaktır. Lua aramak ipairs, dizilerin bir yineleyicisidir, burada her yineleme için bir dizin alır, var ise bu dizinle ilişkili değeri alır.
İçindeki ifadeleri gördüğümüz gibi Lua Diğer dillerden çok farklı değiller, ancak dil, sözdizimini çok daha hızlı öğrenmemizi ve çok daha etkili bir şekilde kullanmamızı sağlamak için bu ekstra basitliği ekliyor. Bununla, içindeki atamaları ve kontrol yapılarını öğrendiğimiz bu öğreticiyi bitiriyoruz. Lua, böylece bu basit ama güçlü dil söz konusu olduğunda başka bir bilgi katmanı ekler.