Örtük dönüştürmeler

Örtük dönüştürmeler, birçok bağlamda çalışma zamanında gerçekleşir:

• Atama deyimlerinde

• Değerler işlev argümanları olarak iletildiğinde

• Değerler işlevlerden döndürüldüğünde

• Toplama (+) operatörü gibi belirli operatörleri kullanan ifadelerde

  Kullanıcı tanımlı türler için örtük dönüştürmeler, dönüştürülecek değer hedef sınıfın bir örneği veya hedef sınıftan türetilmiş bir sınıf olduğunda gerçekleşir. Örtük dönüştürme başarısız olursa bir hata oluşur. Örneğin, aşağıdaki kod başarılı bir örtük dönüştürme ve başarısız bir örtük dönüştürme içerir:

  class A {}
  class B extends A {}
  
  var objA:A = new A();
  var objB:B = new B();
  var arr:Array = new Array();
  
  objA = objB; // Conversion succeeds.
  objB = arr; // Conversion fails.

  İlkel türler için örtük dönüştürmeler, açıkça dönüştürme işlevleri tarafından çağrılan aynı dahili dönüştürme algoritmaları çağrılarak işlenir. İlerleyen bölümlerde bu ilkel tür dönüştürmeleri ayrıntılı şekilde ele alınmıştır.

Açıkça dönüştürmeler

Derleme zamanı hatası oluşturacak bir tür uyuşmazlığı istemediğiniz zamanlar olabileceğinden, katı modda derleme yaparken açıkça dönüştürmeleri veya çevrimi kullanmanız yararlı olur. Zorlamanın değerlerinizi çalışma zamanında doğru şekilde dönüştüreceğini bildiğinizde bu durum geçerli olabilir. Örneğin, bir formdan alınan verilerle çalıştığınızda, belirli dize değerlerini sayısal değerlere dönüştürmek için zorlamayı uygulamak isteyebilirsiniz. Aşağıdaki kod, standart modda doğru şekilde de çalışsa, bir derleme zamanı hatası oluşturur:

var quantityField:String = "3";
var quantity:int = quantityField; // compile time error in strict mode

Katı modu kullanmaya devam etmek ancak bir yandan da dizenin bir tam sayıya dönüştürülmesini istiyorsanız, aşağıdaki gibi açıkça dönüştürmeyi kullanabilirsiniz:

var quantityField:String = "3";
var quantity:int = int(quantityField); // Explicit conversion succeeds.

int, uint ve Number türlerine çevrim

Herhangi bir veri türünü üç sayı türünden birine çevirebilirsiniz: int, uint ve Number. Flash Player veya Adobe AIR uygulaması herhangi bir nedenle sayıyı dönüştüremezse, int ve uint veri türleri için 0 varsayılan değeri atanır ve Number veri türü için de NaN varsayılan değeri atanır. Bir Boolean değerini bir sayıya dönüştürürseniz, true değeri 1 ve false değeri de 0 olur.

var myBoolean:Boolean = true;
var myUINT:uint = uint(myBoolean);
var myINT:int = int(myBoolean);
var myNum:Number = Number(myBoolean);
trace(myUINT, myINT, myNum); // 1 1 1
myBoolean = false;
myUINT = uint(myBoolean);
myINT = int(myBoolean);
myNum = Number(myBoolean);
trace(myUINT, myINT, myNum); // 0 0 0

Yalnızca rakam içeren dize değerleri, sayı türlerinden birine başarıyla dönüştürülebilir. Sayı türleri ayrıca negatif sayı gibi görünen dizeleri veya onaltılık bir değeri (örneğin, 0x1A) temsil eden dizeleri dönüştürebilir. Dönüştürme işlemi, dize değerinin başındaki ve sonundaki boşluk karakterlerini yoksayar. Ayrıca Number() öğesini kullanarak kayan nokta sayısı gibi görünen dizeleri de çevirebilirsiniz. Ondalık işareti eklenmesi, uint() ve int() öğelerinin, ondalık işaretini ve bu işareti takip eden karakterleri kırparak bir tam sayı döndürmesine neden olur. Örneğin, aşağıdaki dize değerleri sayılara çevrilebilir:

trace(uint("5")); // 5
trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE
trace(uint(" 27 ")); // 27
trace(uint("3.7")); // 3
trace(int("3.7")); // 3
trace(int("0x1A")); // 26
trace(Number("3.7")); // 3.7

Sayısal olmayan karakterler içeren dize değerleri, int() veya uint() ile çevrildiğinde 0 değerini; Number() ile çevrildiğinde ise NaN değerini döndürür. Dönüştürme işlemi, baştaki ve sondaki boşlukları yoksayar ancak dizede iki sayıyı ayıran bir boşluk varsa, 0 veya NaN değerini döndürür.

trace(uint("5a")); // 0
trace(uint("ten")); // 0
trace(uint("17 63")); // 0

ActionScript 3.0'da, Number() işlevi artık sekizlik veya 8 tabanlı sayıları desteklemez. ActionScript 2.0 Number() işlevine başında sıfır bulunan bir dize sağlarsanız, sayı sekizlik bir sayı olarak yorumlanır ve ondalık eşdeğerine dönüştürülür. ActionScript 3.0'daki Number() işlevinde ise bu geçerli değildir, burada baştaki sıfır yoksayılır. Örneğin, aşağıdaki kod, farklı ActionScript sürümleri kullanılarak derlendiğinde farklı çıktı oluşturur:

trace(Number("044")); 
// ActionScript 3.0 44
// ActionScript 2.0 36

Bir sayısal türdeki değer, farklı bir sayısal türdeki değişkene atandığında çevrim gerekmez. Katı modda da sayısal türler örtük olarak başka sayısal türlere dönüştürülür. Başka bir deyişle, bazı durumlarda bir tür aralığı aşıldığında beklenmeyen değerler ortaya çıkabilir. Aşağıdaki değerlerin bazıları beklenmeyen değerler oluştursa da, tümü katı modda derlenir:

var myUInt:uint = -3; // Assign int/Number value to uint variable
trace(myUInt); // 4294967293

var myNum:Number = sampleUINT; // Assign int/uint value to Number variable
trace(myNum) // 4294967293

var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable
trace(myInt); // 0

myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable
trace(myInt); // -2147483648

Aşağıdaki tabloda, başka veri türlerinden Number, int veya uint veri türüne çevrim sonuçları özetlenmektedir.

null

Boolean değerine çevrim

Herhangi bir sayısal veri türünden (uint, int ve Number) Boolean değerine çevrim, sayısal değer 0 olursa false, aksi takdirde true değerini verir. Number veri türü için, NaN değeri de false değerini verir. Aşağıdaki örnek, -1, 0 ve 1 sayılarının çevrim sonuçlarını gösterir:

var myNum:Number;
for (myNum = -1; myNum<2; myNum++)
{
   trace("Boolean(" + myNum +") is " + Boolean(myNum));
}

Örnekten elde edilen çıktı, üç sayıdan yalnızca 0 sayısının false değeri döndürdüğünü gösterir:

Boolean(-1) is true
Boolean(0) is false
Boolean(1) is true

Bir String değerinden Boolean değerine çevrim, dize null veya boş dize ("") olduğunda false değerini döndürür. Aksi takdirde, true değerini döndürür.

var str1:String; // Uninitialized string is null.
trace(Boolean(str1)); // false

var str2:String = ""; // empty string
trace(Boolean(str2)); // false

var str3:String = " "; // white space only
trace(Boolean(str3)); // true

Object sınıfı örneğinden Boolean değerine çevrim, örnek null ise false değerini; aksi takdirde true değerini döndürür:

var myObj:Object; // Uninitialized object is null.
trace(Boolean(myObj)); // false

myObj = new Object(); // instantiate 
trace(Boolean(myObj)); // true

Boolean değişkenleri katı modda özel değerlendirmeye tabidir; katı modda çevrim yapmadan herhangi bir veri türündeki değerleri Boolean değişkenine atayabilirsiniz. Tüm veri türlerinden Boolean veri türüne örtük zorlama katı modda da gerçekleşir. Başka bir deyişle, diğer tüm veri türlerinin hemen hemen hepsinden farklı olarak, katı mod hatalarını önlemek için Boolean değerine çevrim gerekmez. Aşağıdaki örneklerin tümü katı modda derleme yapar ve çalışma zamanında beklendiği şekilde davranır:

var myObj:Object = new Object(); // instantiate 
var bool:Boolean = myObj;
trace(bool); // true
bool = "random string";
trace(bool); // true
bool = new Array();
trace(bool); // true
bool = NaN;
trace(bool); // false

Aşağıdaki tabloda, başka veri türlerinden Boolean veri türüne çevrim sonuçları özetlenmektedir:

null

false

Ad alanlarını tanımlama

Ad alanları, bazen ad alanı adı olarak da adlandırılan tek bir değer (Uniform Resource Identifier (URI)) içerir. URI, ad alanı tanımınızın benzersiz olmasını sağlamanıza yardımcı olur.

İki yöntemden birini kullanarak bir ad alanı tanımı bildirip bir ad alanı oluşturursunuz. Bir XML ad alanı tanımlayacağınızdan, açık bir URI ile bir ad alanını tanımlayabilir veya URI'yi atabilirsiniz. Aşağıdaki örnek, URI kullanılarak bir ad alanının nasıl tanımlanabildiğini gösterir:

namespace flash_proxy = "http://www.adobe.com/flash/proxy";

URI, o ad alanı için benzersiz bir kimlik dizesi görevi görür. Aşağıdaki örnekteki gibi, URI'yi atarsanız, derleyici URI yerine benzersiz bir dahili kimlik dizesi oluşturur. Bu dahili kimlik dizesine erişiminiz olmaz.

namespace flash_proxy;

Siz URI ile veya URI olmadan bir ad alanını tanımladıktan sonra, o ad alanı aynı kapsamda yeniden tanımlanamaz. Aynı kapsamda önceden tanımlanmış bir ad alanını tanımlama girişimi, bir derleyici hatasına yol açar.

Bir paket veya sınıf içinde bir ad alanı tanımlanırsa, uygun erişim denetimi belirticileri kullanılmadığı sürece, söz konusu ad alanı, o paket veya sınıf dışındaki koda görünmeyebilir. Örneğin, aşağıdaki kod, flash.utils paketinde tanımlanan flash_proxy ad alanını gösterir. Aşağıdaki örnekte, erişim denetimi belirticisinin olmaması, flash_proxy ad alanının yalnızca flash.utils paketindeki koda görüneceği ve bu paket dışındaki kodlara görünmeyeceği anlamına gelir:

package flash.utils
{
   namespace flash_proxy;
}

Aşağıdaki kod, flash_proxy ad alanını paket dışındaki kodlara görünür duruma getirmek için public niteliğini kullanır:

package flash.utils
{
   public namespace flash_proxy;
}

Ad alanlarını uygulama

Ad alanı uygulanması, bir ad alanına bir tanımın yerleştirilmesi anlamına gelir. Ad alanlarına yerleştirilebilen tanımlar arasında, işlevler, değişkenler ve sabitler yer alır. (Özel bir ad alanına sınıf yerleştiremezsiniz.)

Örneğin, public erişim denetimi ad alanı kullanılarak bildirilen bir işlevi göz önünde bulundurun. Bir işlev tanımında public niteliği kullanıldığında, o işlev genel ad alanına yerleştirilir ve böylece işlev, tüm kod için kullanılabilir olur. Bir ad alanını tanımladıktan sonra, tanımladığınız ad alanını public niteliğiyle aynı şekilde kullanabilirsiniz ve tanım da özel ad alanınıza başvurabilen kod için kullanılabilir olur. Örneğin, bir example1 ad alanını tanımlarsanız, aşağıdaki örnekte gösterildiği gibi, nitelik olarak example1 öğesini kullanıp myFunction() adında bir yöntemi ekleyebilirsiniz:

namespace example1;
class someClass
{
   example1 myFunction() {}
}

Nitelik olarak example1 ad alanı kullanılarak myFunction() yönteminin bildirilmesi, yöntemin example1 ad alanına ait olduğu anlamına gelir.

Ad alanlarını uygularken aşağıdakileri göz önünde bulundurmanız gerekir:

• Her bildirime yalnızca bir ad alanı uygulayabilirsiniz.

• Aynı anda birden çok tanıma bir ad alanı niteliği uygulanamaz. Başka bir deyişle, ad alanınızı on farklı işleve uygulamak istiyorsanız, on işlev tanımının her birine nitelik olarak ad alanınızı eklemeniz gerekir.

• Ad alanları ve erişim denetimi belirticileri birbirini dışladığından, bir ad alanı uygularsanız, bir erişim denetimi belirticisi de belirtemezsiniz. Başka bir deyişle, bir işlevi veya özelliği ad alanınıza uygulamanın yanı sıra public, private, protected ya da internal olarak bildiremezsiniz.

Ad alanlarına başvurma

public, private, protected ve internal gibi herhangi bir erişim denetimi ad alanıyla bildirilmiş bir yöntem veya özellik kullandığınızda, ad alanına açıkça başvurulmasına gerek yoktur. Bunun nedeni, bu özel ad alanlarına erişimin bağlama göre denetlenmesidir. Örneğin, private ad alanına yerleştirilen tanımlar, aynı sınıf içindeki kod için otomatik olarak kullanılabilir olur. Ancak tanımladığınız ad alanları için böyle bir bağlam duyarlılığı yoktur. Özel bir ad alanına yerleştirdiğiniz bir yöntem veya özelliği kullanmak için, ad alanına başvurmanız gerekir.

use namespace direktifiyle ad alanlarına başvurabilir veya ad niteleyicisi (::) işaretini kullanarak ad alanıyla adı niteleyebilirsiniz. use namespace direktifiyle bir ad alanına başvurulması, ad alanını “açar”, böylece ad alanı nitelendirilmiş olmayan herhangi bir tanımlayıcıya uygulanabilir. Örneğin, example1 ad alanını tanımladıysanız, use namespace example1 direktifini kullanarak o ad alanındaki adlara erişebilirsiniz:

use namespace example1;
myFunction();

Aynı anda birden çok ad alanı açabilirsiniz. Siz use namespace direktifiyle bir ad alanını açtıktan sonra, bu ad alanı, açıldığı kod bloğu boyunca açık kalır. Ad alanını açıkça kapatmanın bir yolu yoktur.

Ancak birden çok ad alanının açılması, ad çakışması olma olasılığını artırır. Bir ad alanını açmamayı tercih derseniz, yöntem veya özellik adını ad alanı ve ad niteleyicisi işaretiyle niteleyerek use namespace direktifini önleyebilirsiniz. Örneğin, aşağıdaki kod, myFunction() adını example1 ad alanıyla nasıl niteleyebileceğinizi gösterir:

example1::myFunction();

Ad alanlarını kullanma

ActionScript 3.0'ın parçası olan flash.utils.Proxy sınıfında ad çakışmalarını önlemek için kullanılan bir gerçek ad alanı örneğini bulabilirsiniz. ActionScript 2.0'daki Object.__resolve özelliğinin yerini alan Proxy sınıfı, bir hata oluşmadan önce tanımsız özellik veya yöntemlere yapılan başvuruları önlemenize yardımcı olur. Ad çakışmalarını önlemek için, Proxy sınıfının tüm yöntemleri, flash_proxy ad alanında bulunur.

flash_proxy ad alanının nasıl kullanıldığını daha iyi anlamak için, Proxy sınıfının nasıl kullanıldığını anlamanız gerekir. Proxy sınıfının işlevselliği, yalnızca Proxy sınıfından miras alan sınıflar için kullanılabilir durumdadır. Başka bir deyişle, bir nesnede Proxy sınıfının yöntemlerini kullanmak isterseniz, nesnenin sınıf tanımının, Proxy sınıfını genişletmesi gerekir. Örneğin, tanımsız bir yöntemi çağırma girişimlerinin tümünü önlemek istiyorsanız, Proxy sınıfını genişletir ve daha sonra Proxy sınıfının callProperty() yöntemini geçersiz kılarsınız.

Ad alanlarının uygulanmasının genellikle ad alanını tanımlama, uygulama ve ad alanına başvurma olmak üzere üç adımlık bir işlem olduğunu hatırlayabilirsiniz. Ancak, Proxy sınıfı yöntemlerinden herhangi birini asla açıkça çağırmadığınızdan, flash_proxy ad alanı yalnızca tanımlanır ve uygulanır fakat bu ad alanına asla başvurulmaz. ActionScript 3.0, flash_proxy ad alanını tanımlar ve bunu Proxy sınıfında uygular. Kodunuzun yalnızca Proxy sınıfını genişleten sınıflara flash_proxy ad alanını uygulaması gerekir.

flash_proxy ad alanı, flash.utils paketinde aşağıdakine benzer şekilde tanımlanır:

package flash.utils
{
   public namespace flash_proxy;
}

Aşağıdaki Proxy sınıfı alıntısında gösterildiği gibi, ad alanı, Proxy sınıfının yöntemlerine uygulanır:

public class Proxy
{
   flash_proxy function callProperty(name:*, ... rest):*
   flash_proxy function deleteProperty(name:*):Boolean
   ...
}

Aşağıdaki kodda gösterildiği gibi, ilk olarak hem Proxy sınıfını hem de flash_proxy ad alanını içe aktarmanız gerekir. Daha sonra, Proxy sınıfını genişletecek şekilde sınıfınızı bildirmeniz gerekir. (Katı modda derleme yapıyorsanız, ayrıca dynamic niteliğini de eklemeniz gerekir.) callProperty() yöntemini geçersiz kıldığınızda, flash_proxy ad alanını kullanmanız gerekir.

package
{
   import flash.utils.Proxy;
   import flash.utils.flash_proxy;

   dynamic class MyProxy extends Proxy
   {
       flash_proxy override function callProperty(name:*, ...rest):*
       {
           trace("method call intercepted: " + name);
       }
   }
}

MyProxy sınıfının bir örneğini oluşturur ve aşağıdaki örnekte çağrılan testing() yöntemi gibi tanımsız bir yöntem çağırırsanız, Proxy nesneniz yöntem çağrısını önler ve geçersiz kılınan callProperty() yönteminin içinde deyimleri çalıştırır (bu durumda, basit bir trace() deyimi).

var mySample:MyProxy = new MyProxy();
mySample.testing(); // method call intercepted: testing

flash_proxy ad alanının içinde Proxy sınıfı yöntemlerinden birinin bulunmasının iki avantajı vardır. İlk olarak, ayrı bir ad alanının bulunması, Proxy sınıfını genişleten herhangi bir sınıfın genel arabiriminde karmaşıklığı azaltır. (Proxy sınıfında, geçersiz kılabileceğiniz yaklaşık bir düzine yöntem vardır ve bunların hiçbiri doğrudan çağrılmak üzere tasarlanmamıştır. Bunların tümünün genel ad alanına yerleştirilmesi kafa karıştırıcı olabilir.) İkinci olarak, flash_proxy ad alanının kullanılması, Proxy alt sınıfınızın herhangi bir Proxy sınıfı yöntemiyle eşleşen adlara sahip örnek yöntemler içermesi durumunda ad çakışmalarını önler. Örneğin, kendi yöntemlerinizden birine callProperty() adını vermek isteyebilirsiniz. callProperty() yöntemi sürümünüz farklı bir ad alanında olduğundan, aşağıdaki kod kabul edilebilir:

dynamic class MyProxy extends Proxy
{
   public function callProperty() {}
   flash_proxy override function callProperty(name:*, ...rest):*
   {
       trace("method call intercepted: " + name);
   }
}

Dört erişim denetimi belirticisiyle (public, private, internal ve protected) gerçekleştirilemeyecek şekilde yöntemlere veya özelliklere erişim sağlamak istediğinizde de ad alanları yardımcı olabilir. Örneğin, birçok pakete yayılmış birkaç yardımcı program yönteminiz olabilir. Bu yöntemlerin, tüm paketleriniz için kullanılabilir olmasını ancak genel olarak herkese açık olmamasını istersiniz. Bunu yapmak için, yeni bir ad alanı oluşturabilir ve bunu kendi özel erişim denetimi belirticiniz olarak kullanabilirsiniz.

Aşağıdaki örnek, farklı paketlerde bulunan iki işlevi birlikte gruplandırmak için kullanıcı tanımlı bir ad alanı kullanır. Bunları aynı ad alanında gruplandırarak tek bir use namespace deyimini kullanıp her iki işlevi bir sınıf veya paket için görünebilir duruma getirebilirsiniz.

Bu örnekte tekniği göstermek için dört dosya kullanılmaktadır. Tüm dosyaların sınıf yolunuzda yazılması gerekir. Birinci dosya olan myInternal.as, myInternal ad alanını tanımlamak için kullanılır. Dosya, example adındaki bir pakette bulunduğundan, dosyayı example adındaki bir klasöre yerleştirmeniz gerekir. Ad alanı, diğer paketlere içe aktarılabilmesi için public olarak işaretlenir.

// myInternal.as in folder example
package example
{
   public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples";
}

İkinci ve üçüncü dosyalar olan Utility.as ve Helper.as, diğer paketler için kullanılabilir olması gereken yöntemlerin bulunduğu sınıfları tanımlar. Utility sınıfı, example.alpha paketindedir, başka bir deyişle, example klasörünün alt klasörü olan alpha adında bir klasörün içine dosyanın yerleştirilmesi gerekir. Helper sınıfı, example.beta paketindedir, başka bir deyişle, example klasörünün alt klasörü olan beta adında bir klasörün içine dosyanın yerleştirilmesi gerekir. Bu her iki example.alpha ve example.beta paketinin de ad alanını kullanmadan önce içe aktarması gerekir.

// Utility.as in the example/alpha folder
package example.alpha
{
   import example.myInternal;
   
   public class Utility
   {
       private static var _taskCounter:int = 0;
   
       public static function someTask()
       {
           _taskCounter++;
       }
       
       myInternal static function get taskCounter():int
       {
           return _taskCounter;
       }
   }
}

// Helper.as in the example/beta folder
package example.beta
{
   import example.myInternal;
   
   public class Helper
   {
       private static var _timeStamp:Date;
       
       public static function someTask()
       {
           _timeStamp = new Date();
       }
       
       myInternal static function get lastCalled():Date
       {
           return _timeStamp;
       }
   }
}

Dördüncü dosya olan NamespaceUseCase.as, ana uygulama sınıfı olup example klasörünün bir eşdüzeyi olması gerekir. Adobe Flash CS4 Professional'da bu sınıf, FLA'nın belge sınıfı olarak kullanılır. NamespaceUseCase sınıfı ayrıca myInternal ad alanını içe aktarır ve diğer paketlerde bulunan iki statik yöntemi çağırmak için bu ad alanını kullanır. Bu örnek yalnızca kodu basitleştirmek için statik yöntemleri kullanır. myInternal ad alanına hem statik yöntemler hem de örnek yöntemleri yerleştirilebilir.

// NamespaceUseCase.as
package
{
   import flash.display.MovieClip;
   import example.myInternal; // import namespace
   import example.alpha.Utility;// import Utility class
   import example.beta.Helper;// import Helper class
   
   public class NamespaceUseCase extends MovieClip
   {
       public function NamespaceUseCase()
       {
           use namespace myInternal;
           
           Utility.someTask();
           Utility.someTask();
           trace(Utility.taskCounter); // 2
           
           Helper.someTask();
           trace(Helper.lastCalled); // [time someTask() was last called]
       }
   }
}