¿Cuál es la diferencia entre lenguajes de tipo estático y de tipo dinámico?

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

Pregunta

Escucho mucho que los nuevos lenguajes de programación se escriben dinámicamente, pero ¿qué significa realmente cuando decimos que un lenguaje se escribe dinámicamente vs.¿escrito estáticamente?

¿Fue útil?

Solución

lenguajes con tipos estáticos

Una lengua es de tipo estático si el tipo de una variable es conocido en tiempo de compilación. Para algunos idiomas, esto significa que usted como el programador debe especificar qué tipo es cada variable (ej .: Java, C, C ++); otros idiomas ofrecen algún tipo de inferencia de tipos , la capacidad del sistema de tipos para deducir el tipo de una variable (ej .: OCaml, Haskell, Scala, Kotlin)

La principal ventaja aquí es que todo tipo de comprobación se puede hacer por el compilador, y por lo tanto una gran cantidad de errores triviales están atrapados en una etapa muy temprana.

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

lenguajes con tipos dinámicos

Una lengua se escribe dinámicamente si el tipo se asocia con valores en tiempo de ejecución, y no nombrado variables / campos / etc. Esto significa que usted, como un programador puede escribir un poco más rápido, ya que no tiene que especificar los tipos cada vez (a menos que use un lenguaje de tipo estático con inferencia de tipos ).

Ejemplos: Perl, Ruby, Python, PHP, JavaScript

La mayoría de los lenguajes de programación tienen esta característica ya que no hay que hacer compilador tipo de comprobación de todos modos estático, sino que pueden encontrarse búsqueda de un error que se debe a la mala interpretación de intérprete del tipo de una variable. Por suerte, los guiones tienden a ser pequeños así que los bichos no tienen tantos lugares para esconderse.

La mayoría de las lenguas de tipo dinámico hacen le permiten ofrecer información de tipo, pero no lo requieren. Un lenguaje que se está desarrollando actualmente, Rascal , toma un enfoque híbrido que permite tipado dinámico dentro de las funciones, pero la aplicación estática escribir para la firma de la función.

Otros consejos

lenguajes de programación con tipos estáticos qué tipo de control (es decir, el proceso de verificar y hacer cumplir las restricciones de tipos) a en tiempo de compilación en lugar de en tiempo de ejecución .

lenguajes de programación con tipos dinámicos qué tipo de cheques en en tiempo de ejecución en lugar de en tiempo de compilación .

Este es un ejemplo de contraste cómo Python (tipos dinámicos) y Go (estático de tipos) manejan un error de tipo: 

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

Python no comprobación de tipos en tiempo de ejecución, y por lo tanto: 

silly(2)

funciona perfectamente bien, y produce la salida esperada Hi. El error sólo se produce si se golpea la línea problemática: 

silly(-1)

Produce 

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

debido a que la línea correspondiente se ejecuta realmente.

Ir por el contrario no verificación de tipos en tiempo de compilación: 

package main

import ("fmt"
)

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

func main() {
    silly(2)
}

Lo anterior no se compilará, con el error siguiente: 

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

En pocas palabras esta manera: en un lenguaje de tipos estáticos tipos de variables' son estática , es decir, una vez que se establece una variable de un tipo, no puede cambiarlo. Esto es así porque la tipificación se asocia con la variable en lugar del valor que se refiere.

Por ejemplo en 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

Cuando por el contrario: en un lenguaje de tipos dinámicos tipos de variables son dinámico , es decir, después de configurar una variable de un tipo, puede cambiarlo. Esto se debe a la tipificación se asocia con el valor que asume en lugar de la propia variable.

Por ejemplo en Python: 

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

Por lo tanto, lo mejor es pensar en las variables en lenguajes de tipado dinámico como sólo punteros genéricos a valores escritos.

Para resumir, Tipo describe (o debería haber descrito) las variables en el lenguaje más que el propio lenguaje. Podría haber sido mejor utilizados como un lenguaje con tipos estáticos las variables contra una lengua con las variables de tipo dinámico en mi humilde opinión.

Los lenguajes con tipos estáticos son lenguajes compilados en general, por lo tanto, los compiladores comprobar los tipos (hacen perfecto sentido correcto? Como los tipos no se les permite ser cambiado más adelante en tiempo de ejecución).

lenguajes con tipos dinámicos son generalmente interpretados, por tanto, comprobación de tipos (si lo hay) sucede en tiempo de ejecución cuando se utilizan. Por supuesto, esto trae un poco de costo de rendimiento, y es una de las razones lenguajes dinámicos (por ejemplo, Python, Ruby, PHP) no cambian de escala tan bueno como los escritos unos (Java, C #, etc.). Desde otra perspectiva, tipos estáticos idiomas tienen más de un coste de puesta en marcha: por lo general te hace escribir más código, código sea más difícil. Pero que paga más tarde fuera.

Lo bueno es que ambos lados están pidiendo prestado funciones desde el otro lado. lenguajes de tipo están incorporando características más dinámicas, por ejemplo, genéricos y bibliotecas dinámicas en C #, y los lenguajes dinámicos están incluyendo más comprobación de tipos, por ejemplo, anotaciones de tipo en Python, o CORTE variante de PHP, que por lo general no son el corazón del lenguaje y utilizable en demanda.

Cuando se trata de la selección de la tecnología, ninguna de las partes tiene una superioridad intrínseca sobre el otro. Es sólo una cuestión de preferencia si desea más control para empezar o flexibilidad. sólo debes elegir la herramienta adecuada para el trabajo, y asegúrese de comprobar lo que está disponible en términos de lo contrario antes de considerar un interruptor.

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

Escritura estática

Se dice que un lenguaje de programación utiliza la tipificación estática cuando la verificación de tipo se realiza durante el tiempo de compilación en lugar del tiempo de ejecución.En la tipificación estática, los tipos están asociados con variables, no valores.Los idiomas escrita estáticamente incluyen ADA, C, C ++, C#, Jade, Java, Fortran, Haskell, ML, Pascal, Perl (con respecto a distinguir escalares, matrices, hashes y subrutinas) y Scala.La escritura estática es una forma limitada de verificación del programa (ver seguridad de tipo):En consecuencia, permite que muchos errores de tipo sean capturados temprano en el ciclo de desarrollo.Los controladores de tipo estático evalúan solo la información de tipo que se puede determinar en el momento de la compilación, pero pueden verificar que las condiciones verificadas se mantengan para todas las ejecuciones posibles del programa, que elimina la necesidad de repetir las verificaciones de tipo cada vez que se ejecuta el programa.La ejecución del programa también puede hacerse más eficiente (es decir,más rápido o tomando memoria reducida) omitiendo las verificaciones de tipo de ejecución y habilitando otras optimizaciones.

Debido a que evalúan la información de tipo durante la compilación y, por lo tanto, carecen de información de tipo que solo esté disponible en tiempo de ejecución, los controladores de tipo estático son conservadores.Rechazarán algunos programas que pueden estar bien por el comportamiento en el tiempo de ejecución, pero que no se pueden determinar estáticamente como bien tensados.Por ejemplo, incluso si una expresión siempre se evalúa como verdadera en tiempo de ejecución, un programa que contiene el código

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

Será rechazado como mal tipado, porque un análisis estático no puede determinar que la rama del otro no se tome. [1] El comportamiento conservador de los controladores de tipo estático es ventajoso cuando se evalúa con poca frecuencia:Un verificador de tipo estático puede detectar errores de tipo en rutas de código raramente utilizadas.Sin verificación de tipo estático, las pruebas de cobertura de código incluso con cobertura del código del 100% pueden no poder encontrar tales errores de tipo.Las pruebas de cobertura de código pueden no detectar dichos errores de tipo porque la combinación de todos los lugares donde se crean los valores y todos los lugares donde se usa un cierto valor se debe tener en cuenta.

Los idiomas escrita estáticamente más utilizados no son de tipo formalmente seguro.Tienen "lagunas" en la especificación del lenguaje de programación que permite a los programadores escribir código que elude la verificación realizada por un verificador de tipo estático y, por lo tanto, aborde una gama más amplia de problemas.Por ejemplo, Java y la mayoría de los idiomas de estilo C tienen Punning de tipo, y Haskell tiene características tales como UnsafeperFormio:Dichas operaciones pueden ser inseguras en tiempo de ejecución, ya que pueden causar un comportamiento no deseado debido a la tipificación incorrecta de los valores cuando se ejecuta el programa.

Escritura dinámica

Se dice que un lenguaje de programación está escrito dinámicamente, o simplemente 'dinámico', cuando la mayoría de su comprobación de tipo se realiza en el tiempo de ejecución en lugar de en el tiempo de compilación.En la tipificación dinámica, los tipos están asociados con valores, no variables.Los idiomas tipados dinámicamente incluyen Groovy, JavaScript, LISP, LUA, Objective-C, Perl (con respecto a los tipos definidos por el usuario pero no los tipos incorporados), PHP, Prolog, Python, Ruby, SmallTalk y TCL.En comparación con la tipificación estática, la mecanografía dinámica puede ser más flexible (por ejemplo,Al permitir que los programas generen tipos y funcionalidades basados ​​en datos de tiempo de ejecución), aunque a expensas de menos garantías a priori.Esto se debe a que un lenguaje tipado dinámicamente acepta e intenta ejecutar algunos programas que pueden ser calificados como inválidos por un verificador de tipo estático.

La tipificación dinámica puede dar como resultado errores de tipo de ejecución: es decir, en tiempo de ejecución, un valor puede tener un tipo inesperado, y se aplica una operación no sensible para ese tipo.Esta operación puede ocurrir mucho después del lugar donde se cometió el error de programación, es decir, el lugar donde el tipo incorrecto de datos pasó a un lugar que no debería tener.Esto hace que el error sea difícil de localizar.

Los sistemas de lenguaje mecanografiados dinámicamente, en comparación con sus primos escrita estáticamente, realizan menos verificaciones de "tiempo de compilación" en el código fuente (pero verificarán, por ejemplo, que el programa es sintácticamente correcto).Los controles de tiempo de ejecución pueden ser potencialmente más sofisticados, ya que pueden usar información dinámica, así como cualquier información que estuvo presente durante la compilación.Por otro lado, las verificaciones de tiempo de ejecución solo afirman que las condiciones se mantienen en una ejecución particular del programa, y ​​estas verificaciones se repiten para cada ejecución del programa.

El desarrollo en lenguajes tipados dinámicamente a menudo es compatible con prácticas de programación como pruebas unitarias.Las pruebas son una práctica clave en el desarrollo de software profesional, y es particularmente importante en los idiomas escrita dinámicamente.En la práctica, las pruebas realizadas para garantizar la operación correcta del programa pueden detectar una gama mucho más amplia de errores que la verificación de tipo estática, pero por el contrario no se puede buscar tan exhaustivamente los errores que tanto las pruebas como la verificación de tipo estático pueden detectar.Las pruebas se pueden incorporar al ciclo de compilación del software, en cuyo caso se puede considerar como una verificación de "tiempo de compilación", ya que el usuario del programa no tendrá que ejecutar manualmente tales pruebas.

Referencias

  1. Pierce, Benjamín (2002).Tipos y lenguajes de programación.Prensa del MIT.ISBN 0-262-16209-1.

La terminología "de tipos dinámicos" Sentimos engañosa. Todos los idiomas se escriben de forma estática, y los tipos son propiedad de las expresiones (no de los valores como algunos piensan). Sin embargo, algunas lenguas tienen un solo tipo. Estos son llamados lenguajes uni-mecanografiado. Un ejemplo de tal lenguaje es el cálculo lambda sin tipo.

En el cálculo lambda sin tipo, todos los términos son términos lambda, y la única operación que se puede realizar en un término es aplicarlo a otro término. Por lo tanto todas las operaciones siempre resultan en cualquiera de recursión infinita o un término lambda, pero nunca señalar un error.

Sin embargo, si tuviéramos que aumentar el cálculo lambda sin tipo con los números primitivos y operaciones aritméticas, entonces podríamos realizar operaciones sin sentido, como la adición de dos términos lambda juntos: (λx.x) + (λy.y). Se podría argumentar que la única cosa sensata que hacer es señalar un error cuando esto sucede, pero para ser capaz de hacer esto, cada valor tiene que ser etiquetado con un indicador que indica si el término es un término lambda o un número. El operador de suma se encargarán de verificar que efectivamente ambos argumentos etiquetados como números, y si no lo son, señalar un error. Tenga en cuenta que estas etiquetas son no tipos, porque los tipos son propiedad de los programas, no de valores producidos por esos programas.

Un lenguaje uni-escrito que hace esto se llama tipado dinámico.

Los lenguajes como JavaScript, Python y Ruby son uni-mecanografiado. Una vez más, el operador typeof en JavaScript y la función type en Python tienen nombres engañosos; vuelven las etiquetas asociadas a los operandos, no sus tipos. Del mismo modo, dynamic_cast en C ++ y Java instanceof en hacer no do tipo de cheques.

Compilado vs.Interpretado

"Cuando se traduce el código fuente"

  • Código fuente:Código original (generalmente escrito por un humano en una computadora)
  • Traducción:Convertir el código fuente en algo que una computadora pueda leer (es decir,codigo de maquina)
  • Tiempo de ejecución:Período en el que el programa ejecuta comandos (después de la compilación, si está compilado)
  • Lenguaje compilado:Código traducido antes del tiempo de ejecución
  • Lenguaje interpretado:Código traducido sobre la marcha, durante la ejecución

Mecanografía

"Cuando se verifican los tipos"

5 + '3' es un ejemplo de un error de tipo en fuertemente tipado lenguajes como Go y Python, porque no permiten la "coerción de tipo" -> la capacidad de que un valor cambie de tipo en ciertos contextos, como fusionar dos tipos. débilmente escrito lenguajes, como JavaScript, no arrojarán un error de tipo (da como resultado '53').

  • Estático:Tipos comprobados antes del tiempo de ejecución
  • Dinámica:Tipos comprobados sobre la marcha, durante la ejecución.

Las definiciones de "Estático y compilado" y "Dinámico e interpretado" son bastante similares... pero recuerde que es "cuando se verifican los tipos" vs."cuando se traduce el código fuente".

Obtendrá errores del mismo tipo independientemente de si el lenguaje está compilado o interpretado.!Es necesario separar estos términos conceptualmente.

Ejemplo de Python

Dinámico, Interpretado

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

silly(2)

Debido a que Python se interpreta y se escribe dinámicamente, solo traduce y verifica el código que se está ejecutando.El else El bloque nunca se ejecuta, por lo que 5 + '3' ¡Ni siquiera se mira!

¿Qué pasaría si estuviera escrito estáticamente?

Se produciría un error de tipo incluso antes de ejecutar el código.Todavía realiza una verificación de tipos antes del tiempo de ejecución aunque se interprete.

¿Y si fuera compilado?

El else El bloque se traduciría/miraría antes del tiempo de ejecución, pero debido a que se escribe dinámicamente, ¡no arrojaría un error!Los lenguajes escritos dinámicamente no verifican los tipos hasta la ejecución, y esa línea nunca se ejecuta.

Ir ejemplo

Estático, compilado

package main

import ("fmt"
)

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

func main() {
  silly(2)
}

Los tipos se verifican antes de ejecutar (estático) y el error de tipo se detecta inmediatamente.Los tipos aún se verificarían antes del tiempo de ejecución si se interpretaran, obteniendo el mismo resultado.Si fuera dinámico, no arrojaría ningún error aunque el código se examinara durante la compilación.

Actuación

Un lenguaje compilado tendrá un mejor rendimiento en tiempo de ejecución si se escribe estáticamente (vs.dinamicamente);El conocimiento de los tipos permite la optimización del código de máquina.

Los lenguajes de tipo estático tienen intrínsecamente un mejor rendimiento en tiempo de ejecución debido a que no necesitan verificar los tipos dinámicamente durante la ejecución (se verifica antes de ejecutar).

De manera similar, los lenguajes compilados son más rápidos en tiempo de ejecución ya que el código ya ha sido traducido en lugar de tener que "interpretarlo"/traducirlo sobre la marcha.

Tenga en cuenta que tanto el lenguaje compilado como el de tipo estático tendrán un retraso antes de ejecutarse para la traducción y la verificación de tipo, respectivamente.

Más diferencias

La escritura estática detecta errores tempranamente, en lugar de encontrarlos durante la ejecución (especialmente útil para programas largos).Es más "estricto" en el sentido de que no permitirá errores de tipo en ninguna parte de su programa y, a menudo, evita que las variables cambien de tipo, lo que protege aún más contra errores no deseados.

num = 2
num = '3' // ERROR

La escritura dinámica es más flexible, lo que algunos aprecian.Por lo general, permite que las variables cambien de tipo, lo que puede provocar errores inesperados.

lenguajes con tipos estáticos tipo de comprobación en tiempo de compilación y el tipo no se puede cambiar. (No te linda con comentarios del tipo de fundición a presión, se crea una nueva variable / referencia).

tipos dinámicos lenguajes tipo de comprobación en tiempo de ejecución y el tipo de una variable puede cambiarse en tiempo de ejecución.

lenguajes con tipos estáticos : cada variable y la expresión es ya conocido en tiempo de compilación.

(int a; un sólo puede tomar valores de tipo de número entero en tiempo de ejecución)

Ejemplos: C, C ++, Java

lenguajes con tipos dinámicos : las variables pueden recibir valores diferentes en tiempo de ejecución y de qué tipo se define en tiempo de ejecución.

(var a; a puede tomar cualquier tipo de valores en tiempo de ejecución)

Ejemplos:. Ruby, Python

Sweet y las definiciones simples, pero ajustando la necesidad: lenguajes con tipos estáticos se une el tipo para una variable para la totalidad de su ámbito de aplicación (Seg: SCALA) lenguajes con tipos dinámicos unen el tipo al valor real referenciado por una variable.

  • En un lenguaje de tipos estáticos, una variable está asociada con un tipo que se conoce en tiempo de compilación, y ese tipo no se modificará durante la ejecución de un programa. De manera equivalente, la variable sólo se puede asignar un valor que es una instancia del tipo conocido / especificado.
  • En un lenguaje de tipos dinámicos, una variable no tiene ningún tipo, y su valor durante la ejecución puede ser cualquier cosa de cualquier forma y la forma.

lenguajes con tipos estáticos como C ++, Java y tipos dinámicos lenguajes como Python sólo se diferencian en cuanto a la ejecución del tipo de la variable.     tipos estáticos las lenguas tienen el tipo de datos para la variable estática, aquí el tipo de datos se comprueba durante la compilación por lo que la depuración es mucho más simple ... mientras que tipos dinámicos idiomas no hacen la mismo, el tipo de datos se comprueba que ejecuta el programa y por lo tanto la depuración es poco difícil.

Además tienen una diferencia muy pequeña y puede estar relacionada con inflexible y tipos débiles idiomas. Un lenguaje fuertemente tipado no permite que usted utilice un tipo como otro ejemplo. C y C ++ ... Considerando que las lenguas tipos débiles permiten eg.python

lenguaje de tipos dinámicos ayuda a crear prototipos rápidamente los conceptos de algoritmo sin la sobrecarga de trata de pensar lo que necesitan los tipos de variables a utilizar (que es una necesidad en tipos estáticos languag e) .

estático escrito idiomas (compilador resuelve las llamadas a métodos y compilar las referencias):

  • por lo general un mejor rendimiento
  • recopilar más rápida retroalimentación de error
  • mejor soporte IDE
  • no es adecuado para trabajar con formatos de datos definido
  • más difícil de iniciar un desarrollo cuando el modelo no se define cuando
  • tiempo de compilación más largo
  • en muchos casos requiere para escribir más código

Dynamic mecanografiado idiomas (decisiones tomadas en el programa en ejecución):

  • menor rendimiento
  • desarrollo más rápido
  • algunos errores podrían detectarse sólo más tarde en tiempo de ejecución
  • bueno para los formatos de datos no definidos (programación meta)

tipos estáticos: Los lenguajes como Java y Scala se escriben estática.

Las variables tienen que ser definidas e inicializado antes de ser utilizados en un código.

por ej. int x; x = 10;

System.out.println (x);

Dinámica Typing:  Perl es un lenguaje con tipos dinámicos.

Las variables no tienen por qué ser inicializado antes de ser utilizados en el código.

y = 10; utilizar esta variable en la parte posterior de código

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top