Ugrás a tartalomhoz

strong typing

A Wikiszótárból, a nyitott szótárból
(strong and weak typing szócikkből átirányítva)


Főnév

strong typing (tsz. strong typings)

  1. (informatika) A strong typing — magyarul erős típusosság — azt jelenti, hogy a programozási nyelv szigorúan figyelembe veszi az adatok típusát, és nem engedi meg, hogy egymással inkompatibilis típusokat keverjünk, hacsak a programozó nem végez kifejezett típuskonverziót (cast).

Ennek ellentéte a weak typing — gyenge típusosság — ahol a nyelv automatikusan és sokszor rejtetten is konvertál típusok között, ami akár hibákhoz is vezethet.


Típusosság dimenziói

A típusosság két fontos dimenzióban szokás vizsgálni:

1. Statisztikus vs. dinamikus típusosság

  • Statikus typing: a típusellenőrzés fordítási időben (compile-time) történik, pl. C, C++, Java.
  • Dinamikus typing: a típusellenőrzés futási időben (runtime) történik, pl. Python, JavaScript.

2. Erős vs. gyenge típusosság

  • Strong typing: a nyelv szigorúan ragaszkodik a típusokhoz. Ha két típus nem kompatibilis, a nyelv nem hajt végre automatikus átalakítást, és hibát dob, hacsak a programozó nem ír expliciten típuskódot.
  • Weak typing: a nyelv hajlamos automatikusan átkonvertálni típusokat, néha a programozó szándékától függetlenül is.

Fontos: egy nyelv lehet statikusan típusos ÉS gyengén típusos (pl. C), vagy dinamikusan típusos és erősen típusos (pl. Python).


Példák strong typing-re

Python (dinamikus, erős típusosságú)

x = "123"
y = 456
z = x + y  # TypeError: can only concatenate str (not "int") to str

Magyarázat: a Python nem hajlandó automatikusan átalakítani az int-et str-ré, vagy fordítva. Itt a program hibát dob.

Ha kifejezetten szeretnénk, konverziót kell írni:

z = x + str(y)  # OK

C (statikus, gyenge típusosságú)

int x = 10;
float y = 3.14;
float z = x + y;  // automatikus konverzió OK

Itt a C automatikusan konvertálja az int típust float-tá.

De a C gyenge típusosságát igazán az mutatja meg, hogy nagyon könnyen lehet pointerekkel is trükközni:

int x = 42;
char* p = (char*)&x;  // explicit cast, de C engedi

Itt egy int típusú adatot char* pointerként lehet elérni, ami memóriaszintű “hackelésre” ad lehetőséget — ez az erős típusosságú nyelvekben gyakran tiltott.


Java (statikus, erős típusosságú)

String s = "Hello";
int n = 5;
String result = s + n;  // OK, mert Java a + operátor String-re overloadolva van

int x = "123";  // Fordítási hiba!

A Java sok tekintetben erősen típusos: nem lehet egy String-et int-ként értelmezni. Ha ilyet akarunk, expliciten konvertálni kell:

int x = Integer.parseInt("123");

Mik az előnyei a strong typing-nek?

1. Hibák korai észlelése

  • Ha a nyelv nem enged meg automatikus típuskeverést, a hibák (pl. számokkal történő szövegkeverés) gyorsabban kiderülnek.
  • A kód így megbízhatóbb, könnyebben olvasható.

2. Jobb olvashatóság és karbantarthatóság

  • Egyértelműbb, hogy mely változó milyen típusú, így kevesebb a félreértés.

3. Biztonság

  • Megakadályozza a trükközéseket (pl. memóriacímekkel), ami erősen típusos rendszerekben nem megengedett.
  • Fontos pl. banki rendszerekben, repülőgépvezérlésben.


Mik a hátrányai?

1. Több kódolási “macerát” igényelhet

  • Több helyen kell expliciten konvertálni típusokat.
  • Gyors prototípus-fejlesztésnél (pl. szkriptnyelvekben) hátráltathat.

2. Nem mindig rugalmas

  • Egyes helyzetekben, ahol a típus automatikus konverziója teljesen egyértelmű lenne, a strong typing szándékosan nem engedi meg, hogy “könnyítsünk”.


Példák nyelvek erős/gyenge típusosságára

Nyelv Típusellenőrzés ideje Erős vagy gyenge típusosság
Python Dinamikus Erős
Java Statikus Erős
C Statikus Gyenge
C++ Statikus Alapvetően gyenge, de lehet erős is (opcionális eszközökkel)
JavaScript Dinamikus Gyenge
Rust Statikus Erős
Go Statikus Erős


Típuskonverzió: implicit vs. explicit

Implicit konverzió (gyenge típusosság jele):

let x = "5" + 3;  // "53"
let y = "5" - 3;  // 2 (WTF?)

Itt a JavaScript automatikusan próbálja kitalálni, mit akarunk. Ez néha hasznos, de gyakran hibás kódhoz vezet.

Explicit konverzió (strong typing preferálja):

x = "5"
y = int(x) + 3  # 8

Itt a programozó világosan jelzi, hogy str -> int konverzió történik.


Mitől lesz egy nyelv “erősen típusos”?

Nincs mindenhol teljesen precíz, hivatalos definíció. De általános szabályként:

  • A típusok között nem történik automatikus, rejtett konverzió inkompatibilis típusok között.
  • Ha a programozó külön nem kéri, a típuskeverés nem hajtható végre.
  • Az interpreter vagy a fordító hibát dob nem megengedett típusműveletekre.
  • Pointeres trükközés nem lehetséges, vagy csak szigorúan szabályozott környezetben (pl. Java, Python, Rust).


Strong typing és típusbiztonság

A típusbiztonság (type safety) egy kapcsolódó, de nem teljesen azonos fogalom:

  • Type-safe nyelv: nem engedi meg, hogy a memóriában valamit “másnak nézzünk”, mint ami valójában.
  • Egy nyelv lehet strong-typed ÉS type-safe (pl. Java), vagy strong-typed, de nem teljesen type-safe (pl. C++ opcionálisan).


Összefoglalás

  • A strong typing segít megelőzni típushibákat.
  • Nagyobb kódminőséget, karbantarthatóságot és biztonságot eredményez.
  • Néha viszont több kódolási ráfordítást igényel.
  • A legtöbb modern nyelv — különösen, ahol kritikus rendszereket írnak (pl. Rust, Java, Go) — erősen típusos.


A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=strong_typing&oldid=3499956”