Qual é a diferença entre linguagens de tipagem estática e tipagem dinâmica?

StackOverflow https://stackoverflow.com/questions/1517582

Pergunta

Eu ouço um monte de que as novas linguagens de programação são digitadas dinamicamente mas o que isso realmente significa quando dizemos que um idioma é digitado dinamicamente vs. tipagem estática?

Foi útil?

Solução

tipagem estática línguas

A linguagem é digitado estaticamente se o tipo de uma variável é conhecido em tempo de compilação. Para alguns idiomas, isto significa que você como o programador deve especificar o tipo de cada variável é (por exemplo .: Java, C, C ++); outras línguas oferecem alguma forma de inferência de tipos , a capacidade do sistema de tipo de deduzir o tipo de uma variável (por exemplo .: OCaml, Haskell, Scala, Kotlin)

A principal vantagem aqui é que todos os tipos de verificação pode ser feito pelo compilador, e, portanto, um monte de erros triviais são capturados numa fase muito precoce.

Exemplos: C, C ++, Java, Rust, GO, Scala

dinamicamente digitado línguas

A linguagem é digitado dinamicamente se o tipo está associado com valores em tempo de execução, e não nomeado variáveis ??/ campos / etc. Isso significa que você como um programador pode escrever um pouco mais rápido, porque você não tem que especificar os tipos de cada vez (a menos que usando uma linguagem estaticamente digitada com inferência de tipos ).

Exemplos: Perl, Ruby, Python, PHP, JavaScript

A maioria das linguagens de script tem esta característica como não há compilador para fazer tipo de verificação estática de qualquer maneira, mas você pode encontrar-se à procura de um bug que é devido ao intérprete interpretando mal o tipo de uma variável. Felizmente, os scripts tendem a ser pequenos para que os erros não têm tantos lugares para se esconder.

A maioria das linguagens digitadas dinamicamente permitem que você forneça informações de tipo, mas não o exigem. Uma linguagem que está sendo desenvolvido, Rascal , tem uma abordagem híbrida que permite tipagem dinâmica dentro de funções, mas impor estática digitação para a assinatura função.

Outras dicas

tipagem estática linguagens de programação fazer a verificação de tipo (ou seja, o processo de verificação e fazer cumprir as restrições de tipos) em tempo de compilação em oposição à em tempo de execução .

dinamicamente digitado linguagens de programação fazer verificação de tipo no em tempo de execução em oposição à tempo de compilação .

Aqui está um exemplo contrastante como Python (tipagem dinâmica) e Go (tipagem estática) lidar com um erro do tipo: 

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

Python faz a verificação de tipo em tempo de execução, pelo que: 

silly(2)

Funciona perfeitamente bem, e produz o Hi saída esperada. Erro só é gerado se a linha problemática é atingido: 

silly(-1)

Produz 

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

porque a linha relevante foi realmente executado.

Go por outro lado, faz tipo de verificação em tempo de compilação: 

package main

import ("fmt"
)

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

func main() {
    silly(2)
}

A descrição acima não irá compilar, com o seguinte erro: 

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

Basta colocá-lo desta maneira: em um linguagem de tipagem estática tipos das variáveis ??são estática , ou seja, uma vez que você definir uma variável de um tipo, você não pode mudá-lo. Isso é porque a digitação está associada com a variável em vez do valor que se refere.

Por exemplo, em 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

Onde, por outro lado: em um linguagem de tipagem dinâmica tipos das variáveis ??são dinâmico , ou seja, depois de definir uma variável para um tipo, você pode mudá-lo. Isso é porque a digitação é associado com o valor que ele assume em vez da própria variável.

Por exemplo, em Python: 

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

Assim, é melhor pensar de variáveis ??em linguagens de tipagem dinâmica como apenas ponteiros genéricos com valores digitados.

Para resumir, tipo descreve (ou deveria ter descrito) as variáveis ??na língua em vez da própria linguagem. Poderia ter sido melhor utilizado como uma linguagem com variáveis ??de tipagem estática contra uma linguagem com variáveis ??digitadas dinamicamente IMHO.

tipagem estática línguas são geralmente compilado línguas, assim, os compiladores verificar os tipos (sentido certo perfeito? Como tipos não estão autorizados a ser alterado posteriormente em tempo de execução).

dinamicamente digitado línguas são geralmente interpretadas, assim, verificação de tipo (se houver) acontece em tempo de execução quando eles são usados. Isto, obviamente, traz algum custo de desempenho, e é uma das razões pelas linguagens dinâmicas (por exemplo, Python, Ruby, PHP) não se adaptam tão bons quanto os digitadas (Java, C #, etc.). De outra perspectiva, linguagens de tipagem estática ter mais de um custo start-up: faz você costuma escrever mais código, código mais difícil. Mas que paga mais tarde fora.

A coisa boa é ambos os lados estão a tomar emprestado recursos do outro lado. linguagens digitadas estão incorporando características mais dinâmicas, por exemplo, genéricos e bibliotecas dinâmicas em c # e linguagens dinâmicas estão incluindo mais verificação de tipo, por exemplo, as anotações de tipo em python, ou variante HACK do PHP, que geralmente não são fundamentais para a linguagem e sobre utilizável exigem.

Quando se trata de seleção de tecnologia, nenhum dos lados tem uma superioridade intrínseca sobre o outro. É apenas uma questão de preferência se você quer mais controle para começar ou flexibilidade. basta escolher a ferramenta certa para o trabalho, e certifique-se de verificar o que está disponível em termos do oposto antes de considerar um switch.

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

estático digitando

Uma linguagem de programação é dito para uso tipagem estática quando a verificação de tipo é realizada durante de tempo de compilação quanto oposição ao tempo de execução. Em tipagem estática, tipos estão associados a variáveis não valoriza. linguagens de tipagem estática incluir Ada, C, C ++, C #, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (Com respeito a distintiva escalares, as matrizes, e guisados subrotinas) e Scala. tipagem estática é uma forma limitada de programa verificação (ver segurança de tipo): por conseguinte, permite que muitos tipo erros para ser capturado no início da ciclo de desenvolvimento. tipo estático verificadores de avaliar apenas o tipo informação que pode ser determinado em tempo de compilação, mas são capazes de verificar que as condições verificados segure por todas as possíveis execuções do programa, que elimina a necessidade de Tipo controlos repetidos cada vez que o programa é executado. A execução do programa também pode ser feito mais eficiente (i.e. mais rápido ou tomar memória reduzida) por omitindo tipo runtime cheques e permitindo que outras otimizações.

Porque eles avaliam informações de tipo durante a compilação, e, portanto, falta digite informações que só é disponível em tempo de execução, tipo estático verificadores são conservadoras. Elas vão rejeitar alguns programas que podem ser bem-comportado em tempo de execução, mas que não pode ser estaticamente determinada como sendo bem digitado. Por exemplo, mesmo que um expressão sempre avalia a verdade em tempo de execução, a programa que contém o código 

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

será rejeitado como mal digitado, porque uma análise estática não pode determinar que o ramo mais não será feita. [1] O comportamento conservador de damas tipo estático é vantajoso quando avalia a falsa raro: a verificador de tipos estática pode detectar o tipo de erros nos caminhos de código raramente usado. Sem verificação de tipo estático, mesmo testes de cobertura de código com o código 100% cobertura pode ser incapaz de encontrar tais digite erros. testes de cobertura de código pode não conseguem detectar tais erros de tipo porque a combinação de todos os lugares onde os valores são criados e todos lugares onde um determinado valor é usado deve ser levado em conta.

O mais usado tipagem estática línguas não são do tipo formalmente seguro. Eles têm "lacunas" no especificação da linguagem de programação permitindo que os programadores a escrever código que contorna a verificação realizada por um verificador de tipo estático e assim abordar uma ampla gama de problemas. Por exemplo, Java e mais de estilo C línguas têm tipo trocadilhos, e Haskell tem caraterísticas como unsafePerformIO: tais operações poderão não ser seguro em tempo de execução, na medida em que pode causar um comportamento indesejado devido a tipagem incorrecta de valores quando o dirige o programa.

dinâmica de digitação

A linguagem de programação está a ser dito tipagem dinâmica, ou apenas 'dinâmico', quando a maioria de sua verificação de tipo é realizado em tempo de execução, em oposição a em tempo de compilação. Em tipagem dinâmica, tipos estão associados a valores não variáveis. linguagens dinamicamente digitados incluem Groovy, JavaScript, Lisp, Lua, Objectivo-C, Perl (com respeito a tipos definidos pelo usuário, mas não built-in tipos), PHP, Prolog, Python, Ruby, Smalltalk e Tcl. Comparado a estática digitação, tipagem dinâmica pode ser mais flexível (por exemplo, permitindo que a programas gerar tipos e funcionalidade baseados em dados de tempo de execução), embora no custa de menos de garantias a priori. Isso ocorre porque uma tipagem dinâmica linguagem aceita e tentativas de executar alguns programas que podem ser governado como inválida por um tipo estático verificador.

tipagem dinâmica pode resultar em tempo de execução Tipo erros, ou seja, em tempo de execução, um valor pode ter um tipo inesperado, umand uma operação sem sentido para esse tipo é aplicado. pode ocorrer esta operação muito tempo depois o lugar onde o erro de programação foi feito, isto é, o lugar onde o tipo errado de dados passou para um lugar que não deveria ter. Isso faz com que o bug difícil localizar.

dinamicamente digitado sistemas de linguagem, comparação com a sua tipagem estática primos, fazer menos "tempo de compilação" controlo do código fonte (mas verificar, por exemplo, que o programa é sintacticamente correcto). Tempo de execução os cheques podem ser potencialmente mais sofisticada, já que eles podem usar informações dinâmicas, bem como qualquer informação que estava presente durante compilação. Por outro lado, tempo de execução verifica única afirmam que condições de segurar em um determinado execução do programa, e estes verificações são repetidas para cada execução do programa.

Desenvolvimento em dinamicamente digitado línguas é muitas vezes apoiados por práticas de programação, tais como unidade testes. O teste é uma prática fundamental na desenvolvimento de software profissional, e é particularmente importante em tipagem dinâmica idiomas. Dentro prática, o teste feito para garantir operação do programa correto pode detectar uma muito mais ampla gama de erros do que estática verificação de tipo, mas, inversamente, não pode procurar de forma tão abrangente para o erros que tanto testes e estática verificação de tipo são capazes de detectar. O teste pode ser incorporada no software ciclo de construção, no caso, que pode ser pensado como um "em tempo de compilação" verificar, em que a vontade do usuário programa não tem que executar manualmente tais testes.

Referências

  1. Pierce, Benjamin (2002). Tipos e Linguagens de Programação. MIT Press. ISBN 0-262-16209-1.

A terminologia "tipagem dinâmica" é, infelizmente, enganosa. Todas as línguas são de tipagem estática, e os tipos são propriedades de expressões (não de valores como alguns pensam). No entanto, algumas línguas têm apenas um tipo. Estes são chamados de línguas digitado-uni. Um exemplo de tal linguagem a é o cálculo lambda não tipado.

No cálculo lambda não tipado, todos os termos são termos lambda, e a única operação que pode ser executada em um termo é aplicá-lo para mais um mandato. Por isso todas as operações sempre resultar em uma recursão infinita ou um termo lambda, mas nunca sinalizar um erro.

No entanto, fomos para aumentar o cálculo lambda não tipado com números primitivos e operações aritméticas, então nós poderíamos realizar operações sem sentido, como a adição de dois termos lambda juntos: (λx.x) + (λy.y). Alguém poderia argumentar que a única coisa sensata a fazer é sinalizar um erro quando isso acontece, mas para ser capaz de fazer isso, cada valor tem que ser marcado com um indicador que indica se o termo é um termo lambda ou um número. O operador de adição irá então verificar que de fato ambos os argumentos são marcados como números, e se eles não estão, sinaliza um erro. Note-se que essas marcas são não tipos, porque os tipos são propriedades de programas, não de valores produzidos por esses programas.

A linguagem uni-digitado que faz isso é chamado de tipagem dinâmica.

Linguagens como JavaScript, Python e Ruby são todos-uni digitado. Mais uma vez, o operador typeof em JavaScript ea função type em Python têm enganosa nomes; eles retornam as tags associados aos operandos, e não os seus tipos. Da mesma forma, dynamic_cast em C ++ e instanceof em Java fazer não do tipo cheques.

Compilado vs. Interpretado

"Quando o código-fonte é traduzida como"

  • Código Fonte : código original (geralmente digitada por um ser humano em um computador)
  • Tradução : Conversão de código-fonte em algo um computador pode ler (ou seja, o código de máquina)
  • Run-Time : Período quando o programa é executar comandos (após a compilação, se compilado)
  • Compilado Língua : Código traduzido antes de tempo de execução
  • linguagem interpretada : Código traduzido em tempo real, durante a execução

Digitação

"Quando os tipos são verificados"

5 + '3' é um exemplo de um erro de tipo no fortemente digitado linguagens como Go e Python, porque eles não permitem "tipo de coerção" -> a capacidade de um valor para o tipo de mudança na certos contextos, tais como fusão de dois tipos. fracamente tipado linguagens, como JavaScript, não vai jogar um erro de tipo (resultados em '53').

  • estático : Tipos verificados antes de tempo de execução
  • dinâmico : Tipos verificados em tempo real, durante a execução

As definições de "Static & Compilado" e "Dynamic & Interpretado" são bastante semelhantes ... mas lembre-se que é "quando os tipos são verificados" versus "quando o código fonte é traduzido".

Você vai obter os mesmos erros de tipo, independentemente da linguagem é compilado ou interpretado ! Você precisa separar estes termos conceitualmente.

Python Exemplo

Dinâmico, Interpretado 

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

silly(2)

Porque Python é tanto interpretado e dinamicamente digitado, ele só traduz e código de verificações tipo que está executando em. O bloco else nunca executa, de forma 5 + '3' nunca é sequer olhou para!

O que se ele foi digitado estaticamente?

Um erro de tipo seria jogado antes do código está até mesmo correr. Ele ainda se apresenta antes de tempo de execução, mesmo que ele é interpretado de verificação de tipo.

E se ele foi compilado?

O bloco else seria traduzido / olhado antes run-time, mas porque é tipagem dinâmica que não iria lançar um erro! Dinamicamente digitado línguas não verificar tipos até a execução, e que a linha nunca executa.

Go Exemplo

estática, Compilado 

package main

import ("fmt"
)

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

func main() {
  silly(2)
}

Os tipos são verificados antes de executar (estático) e do erro de tipo é imediatamente apanhado! Os tipos seria ainda ser verificado antes de tempo de execução se ele foi interpretado, tendo o mesmo resultado. Se fosse dinâmico, não jogaria nenhum erro mesmo que o código iria ser olhado durante a compilação.

Desempenho

A linguagem compilada terá melhor desempenho em tempo de execução se for digitado estaticamente (vs. dinamicamente); conhecimento de tipos permite a otimização de código de máquina.

tipagem estática línguas têm melhor desempenho em tempo de execução intrinsecamente devido a não necessidade de verificar os tipos de forma dinâmica durante a execução (ele verifica antes de executar).

Da mesma forma, linguagens compiladas são mais rápidos em tempo de execução como o código já foi traduzido em vez de precisar de "interpretar" / traduzi-lo em tempo real.

Note que tanto compilado e estaticamente linguagens digitadas terá um atraso antes de correr para a tradução e verificação de tipo, respectivamente.

Mais Diferenças

estática digitação pega erros no início, em vez de encontrá-los durante a execução (especialmente útil para programas de comprimento). É mais "rigorosa" na medida em que não vai permitir que os erros do tipo em qualquer lugar no seu programa e muitas vezes impede variáveis ??de mudança de tipos, que defende mais contra erros não intencionais. 

num = 2
num = '3' // ERROR

tipagem dinâmica é mais flexível, que alguns apreciar. Ele normalmente permite variáveis ??a tipos de mudança, que pode resultar em erros inesperados.

tipagem estática línguas tipo de verificação em tempo de compilação e do tipo não pode mudar. (Não fique bonito com comentários de fundição do tipo, uma nova variável / referência é criada).

dinamicamente digitado línguas tipo de verificação em tempo de execução e o tipo de uma variável pode ser alterado em tempo de execução.

tipagem estática línguas : cada variável e expressão já é conhecido em tempo de compilação.

(int a; um pode ter apenas valores de número inteiro de tipo em tempo de execução)

Exemplos: C, C ++, Java

dinamicamente digitado línguas : as variáveis ??podem receber valores diferentes em tempo de execução e seu tipo é definida em tempo de execução.

(var a; um pode tomar qualquer tipo de valores em tempo de execução)

Exemplos:. Ruby, Python

definições doce e simples, mas ajustando a necessidade: Estaticamente digitado idiomas liga do tipo para uma variável em todo o seu âmbito de aplicação (Seg: Scala) linguagens dinamicamente digitados ligam o tipo com o valor real referenciada por uma variável.

  • Em uma linguagem de tipagem estática, uma variável é associado a um tipo que é conhecido em tempo de compilação, e que tipo permanece inalterado durante toda a execução de um programa. De forma equivalente, a variável só pode ser atribuído um valor, que é um exemplo do tipo conhecido / especificado.
  • Em uma linguagem de tipagem dinâmica, uma variável não tem nenhum tipo, e seu valor durante a execução pode ser qualquer coisa de qualquer forma e formulário.

tipagem estática linguagens como C ++, Java e dinamicamente digitado linguagens como Python diferem apenas em termos de execução do tipo da variável. tipagem estática línguas têm o tipo de dados estáticos para a variável, aqui o tipo de dados é verificado durante a compilação de modo a depuração é muito mais simples ... enquanto dinamicamente digitado línguas não fazer o mesmo, o tipo de dados é verificado que a execução do programa e, portanto, a depuração é um pouco difícil.

Além disso, eles têm uma diferença muito pequena e pode ser relacionado com fortemente digitado e fracamente tipado idiomas. A linguagem fortemente digitado não permite que você use um tipo como outro exemplo. C e C ++ ... línguas enquanto fracamente digitados permitem eg.python

linguagem de tipagem dinâmica ajuda a prototipar rapidamente algoritmo conceitos sem a sobrecarga de cerca de pensamento que tipos de variáveis ??precisam ser usados ??(que é uma necessidade em tipagem estática languag e) .

estática digitado línguas (chamadas de método resolve compilador e referências compilar):

  • geralmente melhor desempenho
  • rápido compilação de feedback de erro
  • melhor suporte IDE
  • não é adequado para trabalhar com formatos de dados indefinidos
  • mais difícil de iniciar um desenvolvimento quando modelo não está definido quando
  • mais tempo de compilação
  • em muitos casos requer a escrever mais código

Dinâmica digitado línguas (decisões tomadas na execução do programa):

  • menor desempenho
  • desenvolvimento mais rápido
  • alguns erros podem ser detectados somente mais tarde, em tempo de execução
  • bom para formatos de dados indefinidos (programação meta)

estático Typing: As linguagens como Java e Scala são digitados estático.

As variáveis ??têm de ser definidas e inicializadas antes de serem usados ??em um código.

para ex. int x; x = 10;

System.out.println (x);

Tipagem Dinâmica: Perl é uma linguagem dinâmica digitado.

As variáveis ??não precisam ser inicializados antes de serem usados ??no código.

y = 10; usar essa variável na parte posterior do código

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top