Erősen típusos programozási nyelv

A Wikipédiából, a szabad enciklopédiából

A programozási nyelvek csoportosíthatók a bennük létrehozott változókra, típusokra vonatkozó műveletek szigorúsága alapján: ezen szempontból beszélhetünk erősen vagy gyengén típusos nyelvekről. Azon nyelveket, melyekben minden változót előre deklarálnunk kell, és minden adattípussal csak a rajta elvégezhető műveleteket tehetjük meg, erősen tipikus programozási nyelvnek hívjuk.

Értelmezés[szerkesztés | forrásszöveg szerkesztése]

Általánosságban az erősen típusos nyelvek szigorú korlátozásokat tartalmaznak a bennük használható változók között végzett műveletek áttetszőségével kapcsolatban. Amely program ezen korlátozásokat megszegi, az már a fordítás idején megakad, tipikusan a fordító hibát generál, és az algoritmus nem is éri el a futási időt. Ilyen korlátozásokra példa, hogy az összeadás nem értelmezhető ezen nyelvekben szám és szöveg (sztring) típusú változók között, vagy listákon végezhető művelet nem hívható meg számokra.

Ilyen nyelv például a Java, C#, C++, Python, Object Pascal. (Ellenben gyengén típusos pl. a JavaScript, vagy a BASIC.)

Példa[szerkesztés | forrásszöveg szerkesztése]

// gyengén típusos nyelvnél ez működik:
int a = 2;
String b = "2";
 
return a + b; // 4-et ad vissza
b.concat(a); // "22"-t ad vissza
 
// erősen típusos nyelvnél a fenti típushibát generál (Type mismatch), mivel számot nem tud szöveggel összeadni
// ilyen nyelveknél tipikusan a következők szerint lehet eljárni
 
return Integer.toString(a)+b; // "22"-t ad vissza (szövegként)
return a+Integer.parseInt(b); // 4-et ad vissza

Tulajdonságok[szerkesztés | forrásszöveg szerkesztése]

  • Típusbiztosság (type-safety): futási vagy fordítási időben meg van akadályozva, hogy illegális művelet hajtódjon végre adatokon.
  • A változók típusa a program futása során nem változhat meg.
  • A típus-rendszer megkerülhetetlen: nincs olyan mód, kiskapu, amit a programozók kihasználva típusfüggetlenné tehetnének egy változót.
  • Nincs implicit típuskonverzió: csak a programozó, explicit módon határozhatja meg, mikor van szükség típusegyeztetésre.
  • Fordítási időben történik az ellenőrzés.

Változatok[szerkesztés | forrásszöveg szerkesztése]

  • Java, C#, Pascal, Ada, C nyelvek mindegyikében szükséges, hogy a változóknak legyen egy definiált típusuk, és a köztük való műveleteket explicit konverziókkal érhetjük el.
  • Objektumorientált nyelveknél, mint például a Ruby, Python, Smalltalk, az objektumok között létezhet egyfajta implicit konverzió, mert a fordító nem ellenőrzi a típusokat szigorúan.
  • ML, F#, OCaml, és több más (elsősorban funkcionális) nyelvek esetén a fordító következtet az adattagok típusára, az azokon végzett műveletek alapján, amit statikusan kezel. Tehát ha egy változót egész számként értelmez a program futása elején, valamilyen aritmetikai művelet hatására, akkor a futás közben beszúrt sztring művelet a változón hibát fog generálni.
  • Visual Basic-ben létezik egy Variant (ill. C#-ban 3.0-ás verziótól felfelé var) nevű adattípus, mely egyfajta hibrid, bármilyen adattagot tartalmazhat, tárolhat, és végezhetőek rajta az alapvető műveletek - mint egy gyengén típusos nyelv esetén.
  • Az assembly nyelv típusmentes. Minden műveletet a programozónak ellenőriznie kell, hogy a megfelelő módon értelmezve fussanak le.

Jegyzetek[szerkesztés | forrásszöveg szerkesztése]

Források[szerkesztés | forrásszöveg szerkesztése]

További információk[szerkesztés | forrásszöveg szerkesztése]

Kapcsolódó szócikkek[szerkesztés | forrásszöveg szerkesztése]