Widzę te terminy w różnych miejscach w programowaniu i mam niejasne pojęcie o ich znaczeniu. Wyszukiwanie pokazuje mi, że takie rzeczy były w rzeczywistości pytane o przepełnienie całego stosu. O ile mi wiadomo, pisanie statyczne / dynamiczne w językach subtelnie różni się od pisania silnego / słabego, ale jaka to różnica mi umyka. Różne źródła wydają się używać różnych znaczeń, a nawet terminów zamiennie. Nie mogę znaleźć czegoś, co mówi o obu tych rzeczach i właściwie wyjaśnia różnicę. Byłoby miło, gdyby ktoś mógł to jasno przeliterować tutaj dla mnie i reszty świata.

• Wpisywanie statyczne / dynamiczne dotyczy momentu uzyskania informacji o typie (w czasie kompilacji lub w czasie wykonywania)

• Silne / słabe pisanie dotyczy tego, jak ściśle rozróżniane są typy (np. Czy język próbuje dokonać niejawnej konwersji ciągów na liczby).

Zobacz stronę wiki, aby uzyskać bardziej szczegółowe informacje.

Odkryłeś słabość terminologii używanej przez amatorów do mówienia o językach programowania. Nie używaj terminów „mocne” i „słabe” pisanie , ponieważ nie mają one powszechnie uzgodnionego znaczenia technicznego. Natomiast wpisywanie statyczne oznacza, że ​​programy są sprawdzane przed uruchomieniem, a program może zostać odrzucony przed jego uruchomieniem. Wpisywanie dynamiczne oznacza, że ​​typy wartości są sprawdzane podczas wykonywania , a źle wpisana operacja może spowodować zatrzymanie programu lub inny sygnał błędu w czasie wykonywania . Podstawowym powodem pisania statycznego jest wykluczenie programów, które mogą mieć takie „błędy typu dynamicznego”.

Silne pisanie na ogół oznacza, że ​​nie ma luk w systemie typów, natomiast słabe pisanie oznacza, że ​​system typów może zostać obalony (unieważniając wszelkie gwarancje). Terminy są często używane nieprawidłowo, aby oznaczać pisanie statyczne i dynamiczne. Aby zobaczyć różnicę, pomyśl o C: język jest sprawdzany podczas kompilacji (pisanie statyczne), ale jest wiele luk; możesz rzucić dowolną wartość na inny typ tego samego rozmiaru - w szczególności możesz dowolnie rzutować typy wskaźników. Pascal był językiem, który miał być mocno napisany na maszynie, ale słynął z nieprzewidzianej luki: wariant zapisu bez tagu.

Implementacje silnie typowanych języków często nabierają luk w czasie, zwykle po to, aby część systemu wykonawczego mogła zostać zaimplementowana w języku wysokiego poziomu. Na przykład Objective Caml ma wywoływaną funkcję, Obj.magicktóra w czasie wykonywania po prostu zwraca swój argument, ale w czasie kompilacji konwertuje wartość dowolnego typu na dowolny inny typ. Moim ulubionym przykładem jest Modula-3, której projektanci nazwali konstrukcję rzutową LOOPHOLE.

Powiedziawszy to, nie można liczyć na to, że dwie osoby będą używać słów „silny” i „słaby” w dokładnie taki sam sposób. Więc ich unikaj.

Mówiąc prosto: w języku o typie statycznym typ jest statyczny , co oznacza, że ​​po ustawieniu zmiennej na typ NIE MOŻNA go zmienić. Wynika to z faktu, że pisanie jest powiązane ze zmienną, a nie z wartością, do której się odnosi.

Na przykład w Javie:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

Podczas gdy w języku dynamicznie typowanym typ jest dynamiczny , co oznacza, że ​​po ustawieniu zmiennej na typ, MOŻNA ją zmienić. Wynika to z faktu, że pisanie jest powiązane z wartością, a nie ze zmienną.

Na przykład w Pythonie:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

Z drugiej strony, silne / słabe pisanie w języku jest powiązane z niejawnymi konwersjami typów (częściowo zaczerpniętymi z odpowiedzi @ Dario):

Na przykład w Pythonie:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

podczas gdy w PHP:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

Wpisywanie statyczne pozwala sprawdzić poprawność typu w czasie kompilacji. Języki o typie statycznym są zwykle kompilowane, a języki o typie dynamicznym są interpretowane. Dlatego języki dynamicznie wpisywane mogą sprawdzać pisanie w czasie wykonywania.

Słabe pisanie oznacza, że ​​typ obiektu może się zmieniać w zależności od kontekstu. Na przykład w słabo wpisanym języku ciąg „123” może być traktowany jako liczba 123, jeśli dodasz do niego kolejny numer. Przykładami języków o słabym pisaniu są bash, awk i PHP.

Innym rodzajem słabo wpisanego języka jest C, gdzie dane pod adresem pamięci można traktować jako inny typ przez rzutowanie.

W silnie typowanym języku typ obiektu nie zmienia się - int jest zawsze int i próba użycia go jako łańcucha spowoduje błąd. Zarówno Java, jak i Python są mocno wpisane.

Różnica między pisaniem dynamicznym a statycznym polega na egzekwowaniu reguł typów. W języku o typie statycznym typ każdej zmiennej i parametru musi być zadeklarowany w źródle i jest wymuszany w czasie kompilacji. W języku dynamicznie wpisywanym typy są sprawdzane tylko wtedy, gdy są używane w czasie wykonywania. Zatem Java jest wpisywana statycznie, a Python jest wpisywany dynamicznie.

Jednak granice mogą być czasami rozmyte. Na przykład, chociaż Java jest wpisywana statycznie, za każdym razem, gdy używasz refleksji lub rzutowania (np. Podczas używania kontenerów obiektów), odkładasz sprawdzanie typu na środowisko wykonawcze.

Podobnie najbardziej silnie wpisane języki będą nadal automatycznie konwertować między liczbami całkowitymi i liczbami zmiennoprzecinkowymi (aw niektórych językach BigInts z precyzją alfabetyczną).

Dzisiaj badając ten temat natknąłem się na ten świetny artykuł http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html To wyjaśniło wiele rzeczy dla mnie i pomyślałem, że może to dodać do niektórych świetnych odpowiedzi powyżej.

Mocne i słabe pisanie:

Prawdopodobnie najczęstszym sposobem klasyfikacji systemów typów jest „silny” lub „słaby”. Jest to niefortunne, ponieważ te słowa prawie nie mają żadnego znaczenia. W ograniczonym zakresie możliwe jest porównanie dwóch języków z bardzo podobnymi systemami typów i oznaczenie jednego jako silniejszego z tych dwóch systemów. Poza tym słowa w ogóle nic nie znaczą.

Typy statyczne i dynamiczne

Jest to prawie jedyna wspólna klasyfikacja systemów typów, która ma prawdziwe znaczenie. W rzeczywistości jego znaczenie jest często niedoceniane [...] Dynamiczne i statyczne układy typu to dwie zupełnie różne rzeczy, których cele częściowo się pokrywają.

System typów statycznych to mechanizm, za pomocą którego kompilator sprawdza kod źródłowy i przypisuje etykiety (zwane „typami”) do części składni, a następnie używa ich do wnioskowania o zachowaniu programu. System typu dynamicznego jest mechanizmem, za pomocą którego kompilator generuje kod do śledzenia rodzaju danych (przypadkowo zwanych także „typem”) używanych przez program. Użycie tego samego słowa „typ” w każdym z tych dwóch systemów nie jest oczywiście całkowicie przypadkowe; ale najlepiej to rozumieć jako mające słabe znaczenie historyczne. Wielkie zamieszanie wynika z próby znalezienia poglądu na świat, w którym „typ” naprawdę oznacza to samo w obu systemach. Tak nie jest.

Typy jawne / niejawne:

Kiedy te terminy są używane, odnoszą się one do zakresu, w jakim kompilator będzie uzasadniał statyczne typy części programu. Wszystkie języki programowania mają jakąś formę wnioskowania o typach. Niektóre mają więcej niż inne. ML i Haskell mają typy niejawne, ponieważ nie są potrzebne (lub bardzo niewiele, w zależności od języka i używanych rozszerzeń) deklaracje typu. Java i Ada mają bardzo wyraźne typy, a jeden stale deklaruje typy rzeczy. Wszystkie powyższe mają (względnie w porównaniu do na przykład C i C ++) silne systemy typu statycznego.

Ze Scott's Programming Language Pragmatics , wydanie trzecie, strona 291, mamy

Sprawdzanie typów to proces zapewniający, że program przestrzega reguł zgodności typów języka. Naruszenie zasad jest znane jako konflikt typów. Mówi się, że język jest silnie pisany, jeśli zabrania, w sposób, który implementacja języka może wymusić, zastosowania dowolnej operacji do dowolnego obiektu, który nie jest przeznaczony do obsługi tej operacji. Mówi się, że język jest wpisywany statycznie, jeśli jest mocno wpisany, a sprawdzanie typu można wykonać w czasie kompilacji. W najściślejszym znaczeniu tego terminu kilka języków jest wpisywanych statycznie. W praktyce termin ten jest często stosowany w językach, w których większość sprawdzania typu można wykonać w czasie kompilacji, a resztę można wykonać w czasie wykonywania.

Kilka przykładów: Ada jest silnie wpisana, a przeważnie wpisana statycznie (pewne ograniczenia typu muszą być sprawdzone w czasie wykonywania). Implementacja Pascal może również sprawdzać większość swoich typów w czasie kompilacji, chociaż język nie jest dość mocno wpisany: nieoznakowane rekordy wariantów (do omówienia w rozdziale 7.3.4) są jedyną luką. C89 jest znacznie silniej pisany niż jego wcześniejsze dialekty, ale wciąż znacznie słabiej pisany niż Pascal. Jego luki obejmują związki, podprogramy o zmiennej liczbie parametrów oraz interoperacyjność wskaźników i tablic (do omówienia w rozdziale 7.7.1). Implementacje C rzadko sprawdzają cokolwiek w czasie wykonywania.

Dynamiczne sprawdzanie typu (w czasie wykonywania) jest formą późnego wiązania i zwykle znajduje się w językach, które opóźniają inne problemy również do czasu wykonania. Lisp i Smalltalk są dynamicznie (choć mocno) wpisywane. Większość języków skryptowych jest także wpisywana dynamicznie; niektóre (np. Python i Ruby) są mocno wpisane. Języki z dynamicznym określaniem zakresu są na ogół dynamicznie wpisywane (lub wcale nie są wpisywane): jeśli kompilator nie może zidentyfikować obiektu, do którego odnosi się nazwa, zwykle nie może również określić typu obiektu.

W prostych słowach, pisanie statyczne / dynamiczne odnosi się do czasu, w którym następuje sprawdzenie typu: czas kompilacji dla pisania statycznego i czas wykonywania dla języków dynamicznych. Podobnie, silne / słabe pisanie odnosi się do tego, jak agresywny jest język w egzekwowaniu swojego systemu czcionek.

Próbowałem przetłumaczyć opis Scotta na ładny schemat, który zamieściłem poniżej.

Myślę, że inni koledzy zrobili dobrą robotę, esp. wyjaśniając różnicę między pisaniem statycznym a dynamicznym. Ale jeśli chodzi o mocne i słabe pisanie, należy powiedzieć, że istnieją różne interpretacje / poglądy.

Oto dwa przykłady:

• Niektórzy twierdzą, że Haskell jest silnie napisany na maszynie, ponieważ nie wolno dokonywać żadnych konwersji typu.

• Inni (np. Pogląd Dario) twierdzą, że język, który pozwala celowo konwertować ciąg znaków na liczbę, jest celowo słabo wpisany, ale nawet inni nazywają to po prostu pisaniem kaczych znaków.

Oba stwierdzenia podkreślają nie przeciwne skrajności systemu typów, ale zupełnie inne aspekty. Tak więc przyłączam się do poglądu pana Ramseya, aby nie używać terminów „silny” i „słaby” do rozróżnienia systemów typów.

Języki o typie dynamicznym v / s

• Języki o typie statycznym to te, w których sprawdzanie typu odbywa się w czasie kompilacji, więc oznacza to również, że w językach o typie statycznym każda zmienna ma typ i nie zmienia się w trakcie przebiegu. W przeciwieństwie do tego, dynamicznie typowane języki to te, w których sprawdzanie typu odbywa się w czasie wykonywania, i nie ma sprawdzania typu w czasie kompilacji, więc oznacza to również, że w dynamicznie typowanych językach może istnieć lub nie być typ powiązany ze zmiennymi , a jeśli typ jest skojarzony, może to być typ ogólny, taki jak „var” w JS, który dobrze pasuje zarówno do ciągu, jak i liczby.
  • „Implementacje języków dynamicznie sprawdzanych typu zazwyczaj kojarzą każdy obiekt środowiska wykonawczego ze znacznikiem typu (tj. Odniesieniem do typu) zawierającym informacje o jego typie. Te informacje o typie środowiska wykonawczego (RTTI) można również wykorzystać do wdrożenia dynamicznej wysyłki, późnego wiązania, rzutowania w dół, odbicia i podobnych funkcji. ”
• Nawet jeśli język jest wpisywany statycznie, nadal może mieć jakąś dynamicznie wpisywaną funkcję, co w zasadzie oznacza, że ​​pewne sprawdzanie typów również w czasie wykonywania. Jest to przydatne w rzutowaniu typów.
  • „Szereg przydatnych i popularnych funkcji języka programowania nie można sprawdzić statycznie, takich jak rzutowanie w dół. Dlatego wiele języków będzie miało zarówno statyczne, jak i dynamiczne sprawdzanie typu; moduł sprawdzania typu statycznego sprawdza, co może, a sprawdzanie dynamiczne weryfikuje resztę. ”
• „Niektóre języki umożliwiają pisanie kodu, który nie jest bezpieczny dla typu. Na przykład w C programiści mogą dowolnie rzutować wartość między dowolne dwa typy o tym samym rozmiarze. ”
• Zaletą języków „statycznych” jest to, że:
  • Ponieważ większość sprawdzania typów jest wykonywana w czasie kompilacji, więc interpreter lub środowisko wykonawcze może działać z pełną prędkością, nie martwiąc się o typy.
  • Prowadzi to do mniejszej liczby wyjątków czasu wykonywania lub błędów związanych z typem, ponieważ większość sprawdzania typu odbywa się w czasie kompilacji.
• Zaletą języków dynamicznych jest to, że:
  • Mogą pomóc w niezwykle szybkim prototypowaniu, ponieważ deweloper nie musi rozumieć systemu typów, aby programista mógł swobodnie tworzyć zmienne i uruchamiać je, a to prowadzi do bardzo szybkiego prototypowania.
• Lista języków wpisywanych statycznie i dynamicznie :
  • Statycznie:
    • Jawa
    • C (C jest językiem typowanym statycznie, ale mniej „silnie” typowanym w porównaniu z Javą, ponieważ pozwala na bardziej niejawną konwersję)
    • C ++
    • DO#
  • Dynamicznie:
    • PERL
    • PHP
    • Pyton
    • JavaScript
    • Rubin
• Sprawdzanie typu jest ważną funkcją bezpieczeństwa. Załóżmy, że nie ma sprawdzania typu, a metoda akceptuje obiekt typu „BankAccount”, który ma metodę o nazwie „creditAccount (BankAccountDetails)”, teraz w czasie wykonywania, jeśli nie ma sprawdzania typu, wówczas mogę przekazać własny obiekt klasa, która ma tę samą metodę „creditAccount (BankAccountDetails)” i zostanie wykonana, biorąc pod uwagę, że mówimy o języku obiektowym, ponieważ OOP obsługuje „polimorfizm”, a tutaj omawiamy tylko „polimorfizm”. Tak więc w zasadzie język obiektowy (co w zasadzie oznacza, że ​​obsługuje „polimorfizm”), który nie ma silnego sprawdzania typu, może prowadzić do problemów bezpieczeństwa.

Języki silnie v / s słabo wpisane

• Języki silnie typowane to te, w których niejawne konwersje są niedozwolone w przypadku utraty precyzji. Na przykład w Javie można rzutować „int na long”, ponieważ nie ma utraty precyzji, ale nie można „niejawnie” rzutować „int na long”, ponieważ nastąpiłaby utrata precyzji. Natomiast w słabo wpisanych językach dozwolone są niejawne konwersje nawet w przypadku utraty precyzji.
• Wydaje mi się, że dynamicznie pisany język może być również silnie pisanym językiem, jeśli „w czasie wykonywania” nie pozwala na niejawne konwersje, w których występuje utrata precyzji.

Dobre dalsze odczyty

• System_typu
• Strong_and_weak_typing
• Kategoria: Języki_programowania statycznego
• Kategoria: Języki_programowania dynamicznego

Języki o typie statycznym zazwyczaj wymagają deklarowania typów zmiennych, które są następnie sprawdzane w czasie kompilacji w celu ograniczenia błędów. Słowo „statyczny” w „statycznie typowany” odnosi się do „statycznej analizy kodu”, która jest procesem sprawdzania kodu przed jego wykonaniem. Chociaż możliwe jest, aby język o typie statycznym mógł wywnioskować typ zmiennej z prawej strony wyrażenia lub rzeczywistych parametrów, w praktyce większość języków o typie statycznym wymaga jawnego zadeklarowania typów zmiennych.

Języki o typie dynamicznym generalnie nie wymagają deklaracji zmiennych, aby mieć typy, i wnioskują o typach zmiennych na podstawie typu obliczonego w wyniku oceny prawej strony każdej instrukcji przypisania lub rzeczywistych parametrów wywołania funkcji. Ponieważ zmienna może mieć wiele przypisań przez cały okres jej istnienia, jej typ może zmieniać się w czasie i dlatego nazywany jest „typowaniem dynamicznym”. Ponadto środowisko wykonawcze musi śledzić bieżący typ dla każdej zmiennej, więc typ jest powiązany z wartością, a nie z deklaracją zmiennej. Można to uznać za system informacji o środowisku wykonawczym (RTTI).

Elementy języków pisanych statycznie i dynamicznie można łączyć. Na przykład C # obsługuje zarówno zmienne o typie statycznym, jak i dynamicznym, a języki zorientowane obiektowo ogólnie obsługują hierarchię typów. Języki o typie statycznym zazwyczaj zapewniają różne sposoby na ominięcie sprawdzania typu, na przykład za pomocą rzutowania, odbicia i dynamicznego wywoływania.

Mocne vs. słabe pisanie odnosi się do kontinuum tego, jak bardzo język próbuje zapobiec błędom z powodu używania zmiennej tak, jakby był jednym typem, podczas gdy w rzeczywistości jest innym typem. Na przykład zarówno C, jak i Java są językami o typie statycznym, jednak Java korzysta ze znacznie silniejszego sprawdzania typów niż C. Poniższy kod C z przyjemnością się kompiluje i uruchamia, i wstawi losową wartość do zmiennej b w czasie wykonywania, najprawdopodobniej powodując pluskwa:

char *a = "123";
int b = (int)a;

Odpowiednik kodu Java spowoduje błąd kompilacji, co jest ogólnie preferowane:

String a = "123"
int b = (int)a;