Wat is het verschil tussen statisch getypte en dynamisch getypte talen?

Ik hoor veel dat nieuwe programmeertalen dynamisch worden getypt, maar wat betekent het eigenlijk als we zeggen dat een taal dynamisch wordt getypt versus statisch getypt?

Antwoord 1, autoriteit 100%

Statisch getypeerde talen

Een taal is statisch getypeerd als het type van een variabele bekend is tijdens het compileren. Voor sommige talen betekent dit dat je als programmeur moet specificeren welk type elke variabele is; andere talen (bijv. Java, C, C++) bieden een vorm van type-inferentie, de mogelijkheid van het typesysteem om het type van een variabele af te leiden (bijv. OCaml, Haskell, Scala, Kotlin).

Het belangrijkste voordeel hier is dat allerlei soorten controle door de compiler kunnen worden gedaan, en daarom worden veel triviale bugs in een zeer vroeg stadium ontdekt.

Voorbeelden: C, C++, Java, Rust, Go, Scala

Dynamisch getypeerde talen

Een taal wordt dynamisch getypt als het type is gekoppeld aan runtime-waarden en niet met de naam variabelen/velden/etc. Dit betekent dat u als programmeur iets sneller kunt schrijven omdat u niet elke keer typen hoeft op te geven (tenzij u een statisch getypeerde taal gebruikt met type-inferentie).

Voorbeelden: Perl, Ruby, Python, PHP, JavaScript, Erlang

De meeste scripttalen hebben deze functie omdat er toch geen compiler is om statische typecontrole uit te voeren, maar u kunt merken dat u op zoek bent naar een bug die te wijten is aan het verkeerd interpreteren van het type variabele door de interpreter. Gelukkig zijn scripts meestal klein, dus bugs hebben niet zoveel plekken om te verbergen.

In de meeste dynamisch getypte talen kunt u type-informatie opgeven, maar dit is niet vereist. Een taal die momenteel wordt ontwikkeld, Rascal, hanteert een hybride benadering die dynamisch typen binnen functies mogelijk maakt, maar statische typen voor de functiehandtekening.

Antwoord 2, autoriteit 47%

Statisch getypeerde programmeertalen doen typecontrole (dwz het proces van het verifiëren en afdwingen van de beperkingen van typen) tijdens compile-timein tegenstelling tot runtime.

p>

Dynamisch getypeerde programmeertalen doen typecontrole tijdens run-timein tegenstelling tot compile-time.

Voorbeelden van statisch getypte talen zijn:-
Java, C, C++

Voorbeelden van dynamisch getypte talen zijn: –
Perl, Ruby, Python, PHP, JavaScript

Antwoord 3, autoriteit 35%

Hier is een voorbeeld van hoe Python (dynamisch getypt) en Go (statisch getypt) een typefout afhandelen:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python voert typecontrole uit tijdens runtime, en daarom:

silly(2)

Loopt prima, en produceert de verwachte output Hi. Fout wordt alleen gemeld als de problematische regel wordt geraakt:

silly(-1)

Produceert

TypeError: unsupported operand type(s) for +: 'int' and 'str'

omdat de betreffende regel daadwerkelijk is uitgevoerd.

Go daarentegen doet aan typecontrole tijdens het compileren:

package main
import ("fmt"
)
func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}
func main() {
    silly(2)
}

Het bovenstaande kan niet worden gecompileerd, met de volgende fout:

invalid operation: "3" + 5 (mismatched types string and int)

Antwoord 4, autoriteit 19%

Simpel gezegd: in een statisch getypeerde taalzijn de typen variabelen statisch, wat betekent dat als je een variabele eenmaal hebt ingesteld op een type, je deze niet meer kunt wijzigen. Dat komt omdat typen wordt geassocieerd met de variabele in plaats van met de waarde waarnaar deze verwijst.

Bijvoorbeeld in Java:

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

Waar aan de andere kant: in een dynamisch getypeerde taalzijn de typen variabelen dynamisch, wat betekent dat nadat je een variabele hebt ingesteld op een type, je deze KAN veranderen. Dat komt omdat typen wordt geassocieerd met de waarde die het aanneemt in plaats van met de variabele zelf.

Bijvoorbeeld in Python:

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

Dus het is het beste om variabelen in dynamisch getypte talen te beschouwen als alleen algemene verwijzingen naar getypte waarden.

Samenvattend, typebeschrijft (of had moeten beschrijven) de variabelen in de taal in plaats van de taal zelf. Het had beter kunnen worden gebruikt als een taal met statisch getypte variabelenversus een taal met dynamisch getypte variabelenIMHO.

Talen met statisch type zijn over het algemeen gecompileerde talen, dus de compilers controleren de typen (volkomen logisch toch? aangezien typen later tijdens runtime niet mogen worden gewijzigd).

Dynamisch getypte talen worden over het algemeen geïnterpreteerd, waardoor het type (indien aanwezig) (indien aanwezig) gebeurt wanneer ze worden gebruikt. Dit brengt natuurlijk een aantal prestatiekosten met zich mee en is een van de redenen waarom dynamische talen (bijvoorbeeld Python, Ruby, PHP) niet zo goed als de types (Java, C #, enz.) Niet schalen. Vanuit een ander perspectief hebben statisch getypte talen meer van een opstartkosten: laat je meestal meer code, hardere code schrijven. Maar dat loont later.

Het goede ding is aan beide zijden leentekeningen van de andere kant. Typed Talen omvatten meer dynamische kenmerken, bijv. Generics en dynamische bibliotheken in C #, en dynamische talen, inclusief meer typecontrole, bijvoorbeeld annotaties in Python, of hackvariant van PHP, die meestal geen kern zijn voor de taal en bruikbaar vraag naar.

Als het gaat om technische selectie, heeft geen van beide zijkant een intrinsieke superioriteit over de andere. Het is gewoon een kwestie van voorkeur of u meer controle wilt om te beginnen met of flexibiliteit. Kies gewoon de juiste tool voor de klus en zorg ervoor dat u controleert wat er beschikbaar is in termen van het tegenovergestelde voordat u een schakelaar beschouwt.

Antwoord 5, Autoriteit 4%

http://en.wikipedia.org/wiki/type_system

Static-typen

Er wordt gezegd dat een programmeertaal wordt gebruikt
Statisch typen bij het controleren van type is
uitgevoerd tijdens compileren als
in tegenstelling tot run-time. In statisch typen,
typen worden geassocieerd met variabelen
geen waarden. Statisch getypte talen
Voeg Ada, C, C++, C #, Jade, Java toe,
Fortran, Haskell, ML, Pascal, Perl
(met betrekking tot het onderscheiden
Scalars, arrays, hashes en
Subroutines) en Scala. Statisch typen
is een beperkte vorm van het programma
Verificatie (zie Type Veiligheid):
Dienovereenkomstig maakt het veel type
Fouten die vroeg in de
ontwikkelingscyclus. Statisch type:
checkers evalueren alleen het type
informatie die kan worden bepaald op
compileertijd, maar kunnen verifiëren
dat de gecontroleerde voorwaarden gelden voor
alle mogelijke uitvoeringen van de
programma, waardoor het niet meer nodig is om
herhaal typecontroles elke keer dat de
programma wordt uitgevoerd. Programma uitvoering
kan ook efficiënter worden gemaakt (d.w.z.
sneller of met minder geheugen) door
het weglaten van runtime-typecontroles en
andere optimalisaties inschakelen.

Omdat ze type-informatie evalueren
tijdens de compilatie, en daarom ontbreken
typ informatie die alleen is
beschikbaar tijdens runtime, statisch type
schijven zijn conservatief. Ze zullen
verwerp sommige programma’s die mogelijk
braaf gedragen tijdens runtime, maar dat?
kan niet statisch worden bepaald
goed getypt. Zelfs als bijvoorbeeld een
uitdrukking altijd
evalueert naar waar tijdens runtime, a
programma dat de code bevat

if <complex test> then 42 else <type error>

zal worden afgewezen als slecht getypt, omdat
een statische analyse kan niet bepalen
dat de else-tak niet zal zijn
genomen.[1] Het conservatieve gedrag
van statische type checkers is
voordelig wanneer
evalueert zelden naar onwaar: A
statische typecontrole kan type detecteren
fouten in zelden gebruikte codepaden.
Zelfs zonder statische typecontrole
codedekkingstests met 100% code
dekking mogelijk niet in staat om dergelijke te vinden
typ fouten. Code dekkingstests kunnen:
dergelijke typefouten niet detecteren
omdat de combinatie van alle plaatsen
waar waarden worden gecreëerd en zo
plaatsen waar een bepaalde waarde wordt gebruikt
moet in acht worden genomen.

De meest gebruikte statisch getypte
talen zijn formeel niet typeveilig.
Ze hebben “mazen” in de
programmeertaalspecificatie
programmeurs in staat stellen code te schrijven
die de verificatie omzeilt
uitgevoerd door een statische typecontrole en
dus een breder scala aan problemen aanpakken.
Bijvoorbeeld Java en de meeste C-stijl
talen hebben woordspelingen, en
Haskell heeft functies als:
unsafePerformIO: dergelijke operaties kunnen
onveilig zijn tijdens runtime, in die zin dat ze kunnen
ongewenst gedrag veroorzaken door:
onjuist typen van waarden wanneer de
programma loopt.

Dynamisch typen

Er wordt gezegd dat een programmeertaal
dynamisch getypt, of gewoon ‘dynamisch’,
wanneer de meerderheid van zijn typecontrole
wordt uitgevoerd tijdens runtime in tegenstelling tot
tijdens het compileren. Bij dynamisch typen,
typen zijn gekoppeld aan waarden die niet
variabelen. Dynamisch getypte talen
omvatten Groovy, JavaScript, Lisp, Lua,
Objective-C, Perl (met betrekking tot
door de gebruiker gedefinieerde typen maar niet ingebouwd
typen), PHP, Prolog, Python, Ruby,
Smalltalk en Tcl. Vergeleken met statisch
typen, dynamisch typen kan meer zijn
flexibel (bijvoorbeeld door programma’s toe te staan
genereer typen en functionaliteit gebaseerd
op runtime-gegevens), hoewel bij de
ten koste van minder a priori garanties.
Dit komt omdat een dynamisch getypte
taal accepteert en probeert
enkele programma’s uitvoeren die mogelijk
ongeldig verklaard door een statisch type
checker.

Dynamisch typen kan leiden tot runtime
typefouten – dat wil zeggen, tijdens runtime, a
waarde kan een onverwacht type hebben, en
een operatie die onzinnig is voor dat type
is toegepast. Deze operatie kan optreden
lang na de plaats waar de
programmeerfout is gemaakt, dat wil zeggen,
de plaats waar het verkeerde type gegevens
overgegaan naar een plaats waar het niet zou moeten
hebben. Dit maakt de bug moeilijk te
lokaliseren.

Dynamisch getypeerde taalsystemen,
vergeleken met hun statisch getypte
neven, maak minder “compileertijd”
controleert de broncode (maar zal
controleer bijvoorbeeld of het programma
syntactisch correct is). Looptijd
controles kunnen mogelijk meer zijn
geavanceerd, omdat ze kunnen gebruiken
dynamische informatie evenals elke
informatie die aanwezig was tijdens
compilatie. Anderzijds,
Runtime-cheques beweren dat alleen
Condities houden in een bepaalde
Uitvoering van het programma, en deze
Cheques worden voor elke keer herhaald
uitvoering van het programma.

Ontwikkeling in dynamisch getypt
Talen wordt vaak ondersteund door
programmeermethoden zoals eenheid
Testen. Testen is een belangrijke praktijk in
Professionele softwareontwikkeling, en
is vooral belangrijk in
dynamisch getypt talen. In
oefenen, het getuigen gedaan om te zorgen
Correcte programmabewerking kan een
veel breder scala aan fouten dan statisch
typecontrole, maar niet kan
zoek zo volledig voor de
Fouten die zowel testen als statisch zijn
typecontrole is in staat om te detecteren.
Testen kan worden opgenomen in de
Software Build Cycle, in welk geval het
kan worden beschouwd als een “compile-time”
Controleer, in dat de programma-gebruiker zal
hoeft niet handmatig dergelijke tests te gebruiken.

referenties

1. PIERCE, Benjamin (2002). Typen en programmeertalen. Mit pers.
   ISBN 0-262-16209-1.

Antwoord 6, Autoriteit 2%

De terminologie “dynamisch getypt” is helaas misleidend. Alle talen worden statisch getypt en typen zijn eigenschappen van uitdrukkingen (niet van waarden als enige denken). Sommige talen hebben echter slechts één type. Deze worden Uni-getypte talen genoemd. Een voorbeeld van een dergelijke taal is de ongegeerde lambda-calculus.

In het niet-gevetterde Lambda-calculus zijn alle termen Lambda-voorwaarden en de enige bewerking die op een term kan worden uitgevoerd, is het toepassen op een andere term. Vandaar dat alle operaties altijd resulteren in oneindige recursie of een lambda-term, maar nooit een fout signaleren.

Als we echter de ongetypeerde lambda-calculus zouden aanvullen met primitieve getallen en rekenkundige bewerkingen, dan zouden we onzinnige bewerkingen kunnen uitvoeren, zoals het optellen van twee lambda-termen: (λx.x) + (λy.y). Je zou kunnen stellen dat het enige verstandige om te doen is om een fout te signaleren wanneer dit gebeurt, maar om dit te kunnen doen, moet elke waarde worden getagd met een indicator die aangeeft of de term een lambda-term of een getal is. De opteloperator controleert dan of beide argumenten inderdaad als getallen zijn getagd, en als dat niet het geval is, signaleert u een fout. Merk op dat deze tags geentypen zijn, omdat typen eigenschappen zijn van programma’s, niet van waarden die door die programma’s worden geproduceerd.

Een uni-getypeerde taal die dit doet, wordt dynamisch getypt genoemd.

Talen zoals JavaScript, Python en Ruby zijn allemaal uni-typed. Nogmaals, de operator typeofin JavaScript en de functie typein Python hebben misleidende namen; ze retourneren de tags die zijn gekoppeld aan de operanden, niet hun typen. Op dezelfde manier voeren dynamic_castin C++ en instanceofin Java geentypecontroles uit.

Antwoord 7

Samengesteld versus geïnterpreteerd

“Als de broncode is vertaald”

• Broncode: originele code (meestal door een mens in een computer getypt)
• Vertaling: broncode omzetten in iets dat een computer kan lezen (bijv. machinecode)
• Run-Time: periode waarin het programma opdrachten uitvoert (na compilatie, indien gecompileerd)
• Gecompileerde taal: code vertaald vóór runtime
• Geïnterpreteerde taal: code direct vertaald, tijdens uitvoering

Typen

“Als typen zijn aangevinkt”

5 + '3'is een voorbeeld van een typefout in sterk getypt talen zoals Go en Python, omdat ze niet toestaan ​​dat “Type Cuterion” – & GT; het vermogen om een ​​waarde te wijzigen in bepaalde contexten, zoals het samenvoegen van twee typen. zwak getypt talen, zoals JavaScript, geen typefout gooien (resulteert in '53').

• Static : typen gecontroleerd vóór runtime
• Dynamic : typen gecontroleerd op de vlieg, tijdens uitvoering

De definities van “Static & amp; gecompileerd” en “Dynamic & Amp; geïnterpreteerd” zijn behoorlijk vergelijkbaar … maar onthoud dat het is “wanneer typen worden gecontroleerd” versus “wanneer broncode wordt vertaald”.

U krijgt dezelfde typefouten, ongeacht of de taal wordt gecompileerd of geïnterpreteerd ! U moet deze voorwaarden concurreren.

Python Voorbeeld

Dynamic, geïnterpreteerd

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'
silly(2)

Omdat Python zowel geïnterpreteerd als dynamisch wordt getypt, vertaalt het alleen en typt het type-controlescode. De elseBlock voert nooit uit, dus 5 + '3'wordt zelfs nooit bekeken!

Wat als het statisch is getypt?

Er zou een type fout worden gegooid voordat de code zelfs wordt uitgevoerd. Het voert nog steeds typencontrole vóór de looptijd, ook al wordt het geïnterpreteerd.

Wat als het is samengesteld?

De elseBlock zou vóór de looptijd worden vertaald / bekeken, maar omdat het dynamisch wordt getypt, zou het geen fout gooien! Dynamisch getypte talen controleren typen niet tot uitvoering, en die lijn wordt nooit uitgevoerd.

GO-voorbeeld

Statisch, samengesteld

package main
import ("fmt"
)
func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}
func main() {
  silly(2)
}

De typen worden gecontroleerd voordat ze worden uitgevoerd (statisch) en de typefout wordt onmiddellijk opgemerkt! De typen zouden nog vóór runtime worden gecontroleerd als ze werden geïnterpreteerd, met hetzelfde resultaat. Als het dynamisch was, zou het geen fouten veroorzaken, ook al zou de code tijdens het compileren worden bekeken.

Prestaties

Een gecompileerde taal zal tijdens runtime beter presteren als deze statisch is getypt (vs. dynamisch); kennis van typen zorgt voor optimalisatie van machinecodes.

Talen met statisch type presteren intrinsiek beter tijdens runtime, omdat typen niet dynamisch hoeven te worden gecontroleerd tijdens het uitvoeren (het controleert voordat ze worden uitgevoerd).

Evenzo zijn gecompileerde talen sneller tijdens runtime omdat de code al is vertaald in plaats van deze meteen te moeten “interpreteren”/vertalen.

Houd er rekening mee dat zowel gecompileerde als statisch getypte talen een vertraging hebben voordat ze respectievelijk worden uitgevoerd voor vertaling en typecontrole.

Meer verschillen

Statisch typen vangt fouten vroeg op, in plaats van ze tijdens de uitvoering te vinden (vooral handig voor lange programma’s). Het is “strenger” omdat het nergens in je programma typefouten toestaat en vaak voorkomt dat variabelen van type veranderen, wat verder verdedigt tegen onbedoelde fouten.

num = 2
num = '3' // ERROR

Dynamisch typen is flexibeler, wat sommigen op prijs stellen. Het zorgt er meestal voor dat variabelen van type kunnen veranderen, wat kan resulteren in onverwachte fouten.

Antwoord 8

Statisch getypeerde talen: elke variabele en expressie is al bekend tijdens het compileren.

(int a;a kan tijdens runtime alleen waarden van het type integer aannemen)

Voorbeelden: C, C++, Java

Dynamisch getypeerde talen: variabelen kunnen tijdens runtime verschillende waarden krijgen en hun type wordt tijdens runtime gedefinieerd.

(var a;a kan tijdens runtime allerlei waarden aannemen)

Voorbeelden: Ruby, Python.

Antwoord 9

Statisch getypeerde talen type-check tijdens het compileren en het type kan NIET veranderen. (Wees niet schattig met type-casting-opmerkingen, er wordt een nieuwe variabele/referentie gemaakt).

Dynamisch getypeerde taaltypecontrole tijdens runtime en het type van een variabele KAN tijdens runtime worden gewijzigd.

Antwoord 10

Lieve en eenvoudige definities, maar passend bij de behoefte:
Statisch getypeerde talen binden het type aan een variabele voor het volledige bereik (Seg: SCALA)
Dynamisch getypeerde talen binden het type aan de werkelijke waarde waarnaar wordt verwezen door een variabele.

Antwoord 11

• In een statisch getypeerde taal wordt een variabele geassocieerd met een type dat bekend is tijdens het compileren, en dat type blijft ongewijzigd gedurende de uitvoering van een programma. Op equivalente wijze kan aan de variabele alleen een waarde worden toegewezen die een instantie is van het bekende/gespecificeerde type.
• In een dynamisch getypte taal heeft een variabele geen type, en de waarde ervan tijdens de uitvoering kan van alles zijn, van welke vorm dan ook.

Antwoord 12

Statisch getypeerde talen (compiler lost methodeaanroepen op en compileert referenties):

• meestal betere prestaties
• snellere compileerfoutfeedback
• betere IDE-ondersteuning
• niet geschikt om met ongedefinieerde gegevensformaten te werken
• moeilijker om een ontwikkeling te starten wanneer het model niet is gedefinieerd wanneer
• langere compilatietijd
• in veel gevallen is het nodig om meer code te schrijven

Dynamisch getypeerde talen (beslissingen genomen in lopend programma):

• lagere prestaties
• snellere ontwikkeling
• sommige bugs kunnen pas later tijdens runtime worden gedetecteerd
• goed voor ongedefinieerde dataformaten (metaprogrammering)

Antwoord 13

Statisch getypeerde talen zoals C++, Java en dynamisch getypeerde talen zoals Python verschillen alleen wat betreft de uitvoering van het type variabele.
Statisch getyptetalen hebben een statisch gegevenstype voor de variabele, hier wordt het gegevenstype gecontroleerd tijdens het compileren, dus debuggen is veel eenvoudiger…terwijl Dynamisch getyptetalen het niet doen hetzelfde, het gegevenstype wordt gecontroleerd waardoor het programma wordt uitgevoerd en daarom is het debuggen een beetje moeilijk.

Bovendien hebben ze een heel klein verschil en kunnen ze gerelateerd zijn aan sterk getypteen zwak getyptetalen. Een sterk getypte taal staat je niet toe om het ene type als een ander te gebruiken, bijv. C en C++ …terwijl zwak getypte talen bv.python toestaan

Antwoord 14

Statisch getypt

De typen worden vóór de runtime gecontroleerd, zodat fouten eerder kunnen worden opgemerkt.

Voorbeelden = c++

Dynamisch getypt

De typen worden gecontroleerd tijdens de uitvoering.

Voorbeelden = Python

Antwoord 15

dynamisch getypte taalhelpt bij het snel prototypen van algoritmeconcepten zonder de overhead van het nadenken over welke variabele typen moeten worden gebruikt (wat een noodzaak is in statisch getypeerde taale) .

Antwoord 16

Statisch type:Typecontrole uitgevoerd tijdens het compileren.

Wat wordt er eigenlijk bedoeld met statische taal:

• type van een variabele moet worden opgegeven
• een variabele kan alleen verwijzen naar een bepaald type object*
• typecontrole voor de waarde wordt uitgevoerd tijdens het compileren en elke typecontrole wordt op dat moment gerapporteerd
• geheugen wordt toegewezen op compileertijd om de waarde van dat specifieke type

op te slaan

Voorbeeld van statische type taal zijn C, C++, Java.

Dynamic Type: Type-controle uitgevoerd bij runtime .

Wat betekent eigenlijk door dynamische typetaal:

• Niet nodig om het type van de variabele

op te geven

• dezelfde variabele kan verwijzen naar verschillende soorten objecten

Python, robijn zijn voorbeelden van taaltype taal.

_{* Sommige objecten kunnen worden toegewezen aan verschillende soorten variabelen door het typen (een veel voorkomende praktijk in talen zoals C en C++)}

Antwoord 17

static typen:
De talen zoals Java en Scala zijn statisch getypt.

De variabelen moeten worden gedefinieerd en geïnitialiseerd voordat ze in een code worden gebruikt.

voor ex. int x; x = 10;

System.out.Println (x);

dynamisch typen:
Perl is een dynamische getypte taal.

Variabelen hoeven niet te worden geïnitialiseerd voordat ze in de code worden gebruikt.

y = 10; Gebruik deze variabele in het latere code