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

946

Escucho mucho que los nuevos lenguajes de programación se escriben dinámicamente, pero ¿qué significa en realidad cuando decimos que un lenguaje se escribe dinámicamente frente a estáticamente?

Rachel
fuente
25
Buena pregunta pero su respuesta aceptada no es la respuesta correcta.
Jon Harrop
42
¿puedes referir algo que es correcto entonces?
Sagiruddin Mondal
@EricLeschinski Creo que las pruebas unitarias ayudan ahora con ese problema y los lenguajes escritos dinámicamente como JavaScript se pueden codificar con la seguridad de que se mantendrá, lo que lo hace elegible para el desarrollo de software empresarial, ¿no crees?
pixel 67
8
En el mejor de los casos, esas pruebas unitarias se deterioran con el tiempo y son desactivadas por los compañeros de trabajo que intentan aumentar la seguridad laboral, en el peor de los casos, nunca se escriben en primer lugar. Es como sugerirle a un mecánico profesional que use cinta adhesiva en los autos de sus clientes. Sí junior, usar cinta adhesiva en este trabajo de transmisión es una buena idea ... para ti.
Eric Leschinski
2
Sé que esta pregunta tiene 10 años, pero por lo que leí en los comentarios, probablemente debería cambiar para aceptar la respuesta de "Christopher Tokar".
Rev1.0

Respuestas:

854

Lenguajes estáticamente escritos

Un idioma se escribe estáticamente si el tipo de una variable se conoce en tiempo de compilación. Para algunos lenguajes, esto significa que usted, como programador, debe especificar de qué tipo es cada variable (por ejemplo: Java, C, C ++); otros idiomas ofrecen alguna forma de inferencia de tipos , la capacidad del sistema de tipos para deducir el tipo de una variable (por ejemplo: OCaml, Haskell, Scala, Kotlin)

La principal ventaja aquí es que el compilador puede realizar todo tipo de comprobaciones y, por lo tanto, se detectan muchos errores triviales en una etapa muy temprana.

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

Idiomas tipificados dinámicamente

Un idioma se escribe dinámicamente si el tipo está asociado con valores de tiempo de ejecución y no con variables / campos / etc. Esto significa que usted como programador puede escribir un poco más rápido porque no tiene que especificar 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 secuencias de comandos tienen esta característica, ya que de todos modos no hay un compilador para hacer una verificación de tipos estática, pero puede encontrarse buscando un error debido a que el intérprete malinterpreta el tipo de una variable. Afortunadamente, los guiones tienden a ser pequeños, por lo que los errores no tienen tantos lugares para esconderse.

La mayoría de los idiomas escritos dinámicamente le permiten proporcionar información de tipo, pero no la requieren. Un lenguaje que se está desarrollando actualmente, Rascal , adopta un enfoque híbrido que permite la escritura dinámica dentro de las funciones pero que impone la escritura estática para la firma de la función.

No hombre
fuente
66
@NomeN ¿Puede nombrar algún lenguaje de tipo dinámico que implemente la inferencia de tipo HM?
Pete Kirkham el
88
"Un idioma se escribe dinámicamente si el tipo de una variable se interpreta en tiempo de ejecución": No. Un idioma se escribe dinámicamente si el tipo está asociado con valores de tiempo de ejecución y no con variables / campos nombrados, etc.
Paul Biggar el
15
Incorrecto, la tipificación estática significa "que un valor de referencia está claramente (que no es lo mismo que en tiempo de compilación) restringido con respecto al tipo de valor que puede denotar, y que la implementación del lenguaje, ya sea un compilador o un intérprete , tanto hace cumplir y utiliza estas restricciones tanto como sea posible ". citado de: c2.com/cgi/wiki?StaticTyping que, según tengo entendido, es correcto.
Matthias Wolf el
66
Lo más obvio acerca de los sistemas de tipos de Java, C, C ++, Pascal y muchos otros lenguajes de "industria" ampliamente utilizados no es que estén tipados estáticamente, sino que están tipeados explícitamente. En otras palabras, requieren muchos Declaraciones de tipo. (En el mundo de los lenguajes tipados menos explícitamente, donde estas declaraciones son opcionales, a menudo se denominan "anotaciones de tipo"). Esto no tiene nada que ver con los tipos estáticos. continúa ..
Vipresh
77
Los primeros idiomas tipados estáticamente fueron tipados explícitamente por necesidad. Sin embargo, los algoritmos de inferencia de tipos: técnicas para observar el código fuente sin ninguna declaración de tipo, y decidir cuáles son los tipos de sus variables han existido durante muchos años. El lenguaje ML, que lo usa. Haskell, que mejora, ahora tiene unos 15 años. Incluso C # ahora está adoptando la idea, lo que levantará muchas cejas y sin duda dará lugar a afirmaciones de que está "tipeado débilmente". continúa ...
Vipresh
399

Los lenguajes de programación con tipos estáticos realizan la verificación de tipos (es decir, el proceso de verificación y aplicación de las restricciones de los tipos) en tiempo de compilación en lugar de tiempo de ejecución .

Los lenguajes de programación dinámicamente tipados verifican los tipos en tiempo de ejecución en lugar de en tiempo de compilación .

Ejemplos de lenguajes tipados estáticamente son: - Java, C, C ++

Ejemplos de lenguajes escritos dinámicamente son: - Perl, Ruby, Python, PHP, JavaScript

Christopher Tokar
fuente
19
Creo que esta es la mejor respuesta. En particular, la respuesta aceptada es en gran medida objetivamente incorrecta.
Jon Harrop
1
@ JonHarrop ¿De qué maneras específicamente?
1252748
21
@thomas: "Esto significa que usted como programador puede escribir un poco más rápido porque no tiene que especificar el tipo cada vez". No tiene que especificar el tipo cada vez con escritura estática si tiene inferencia de tipos. Ver SML, OCaml, F #, Haskell ...
Jon Harrop
1
En lenguajes de programación con escritura estática, la verificación de tipo se realiza antes del tiempo de ejecución, pero no exactamente en el momento de la compilación.
Luiz Felipe el
307

Aquí hay un ejemplo que contrasta cómo Python (de tipo dinámico) y Go (de tipo estático) manejan un error de tipo:

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

Python escribe la verificación en tiempo de ejecución y, por lo tanto:

silly(2)

Funciona perfectamente bien y produce el resultado esperado Hi. El error solo se genera si se golpea la línea problemática:

silly(-1)

Produce

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

porque la línea relevante se ejecutó realmente.

Ir por otro lado hace la verificación de tipo 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 siguiente error:

invalid operation: "3" + 5 (mismatched types string and int)
Akavall
fuente
55
Gracias por el ordenado ejemplo. Entonces, ¿infiero que todos los lenguajes de scripting se escriben dinámicamente, ya que no se compilan?
CᴴᴀZ
8
si. Todos los lenguajes de secuencias de comandos se escriben dinámicamente, porque de todos modos no es un compilador para hacer una verificación de tipo estático. Este punto ha sido ilustrado en este artículo sitepoint.com/typing-versus-dynamic-typing .
Shashi
99
¡Scala se puede usar como lenguaje de script y se escribe estáticamente! #discussion @Shashi
Sagiruddin Mondal
3
La compilación de @Shashi no significa tipado estáticamente. Haskell se puede interpretar con runhaskell, por ejemplo.
BalinKingOfMoria Reinstale CMs
2
Además, el lenguaje de secuencias de comandos NO significa lenguaje interpretado. TypeScript es de tipo estático, compilado / transpilado, pero con lenguaje de script.
metalim
161

En pocas palabras: en un lenguaje de tipo estático , los tipos de variables son estáticos , lo que significa que una vez que establece una variable en un tipo, no puede cambiarla. Esto se debe a que la tipificación está asociada con la variable en lugar del valor al 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

Donde, por otro lado: en un lenguaje de tipo dinámico , los tipos de variables son dinámicos , lo que significa que después de establecer una variable en un tipo, PUEDE cambiarla. Esto se debe a que la tipificación está asociada con el valor que asume en lugar de la variable en sí.

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, es mejor pensar en las variables en lenguajes escritos dinámicamente como punteros genéricos a los valores escritos.

En resumen, el tipo describe (o debería haber descrito) las variables en el idioma en lugar del lenguaje en sí. Podría haber sido mejor utilizado como un lenguaje con variables escritas estáticamente frente a un lenguaje con variables escritas dinámicamente en mi humilde opinión.

Los lenguajes de tipo estático generalmente son lenguajes compilados, por lo tanto, los compiladores comprueban los tipos (¿tiene sentido, verdad? Ya que no se permite cambiar los tipos más adelante en tiempo de ejecución).

Los lenguajes de tipo dinámico generalmente se interpretan, por lo tanto, la verificación de tipos (si la hay) ocurre en tiempo de ejecución cuando se usan. Por supuesto, esto conlleva algunos costos de rendimiento y es una de las razones por las que los lenguajes dinámicos (p. Ej., Python, ruby, php) no escalan tan bien como los escritos (java, c #, etc.). Desde otra perspectiva, los idiomas tipados estáticamente tienen un costo inicial más elevado: por lo general, usted escribe más código, un código más difícil. Pero eso paga más tarde.

Lo bueno es que ambas partes están prestando características del otro lado. Los lenguajes mecanografiados están incorporando características más dinámicas, por ejemplo, genéricos y bibliotecas dinámicas en C #, y los lenguajes dinámicos incluyen más verificación de tipos, por ejemplo, anotaciones de tipo en python o HACK variante de PHP, que generalmente no son esenciales para el lenguaje y no se pueden usar en demanda.

Cuando se trata de la selección de tecnología, ninguno de los lados tiene una superioridad intrínseca sobre el otro. Es solo una cuestión de preferencia si desea más control para comenzar o flexibilidad. simplemente elija la herramienta adecuada para el trabajo y asegúrese de verificar lo que está disponible en términos opuestos antes de considerar un cambio.

mehmet
fuente
8
Esto tiene mucho sentido. Creo que explica al menos el razonamiento detrás de los nombres mucho mejor que otras respuestas aquí.
JamEngulfer
Según esta referencia, Python es un lenguaje de tipo estático y de tipo dinámico: wiki.python.org/moin/… ¿Alguien sabe por qué?
modulitos
1
Lucas, por el contrario, el documento sigue repitiendo que Python está tipado de forma fuerte y dinámica. ¿Dónde viste eso? ¿Puedes citar?
mehmet
2
Creo que esta respuesta comunica mejor el concepto de la manera más simple. Muchas otras respuestas intentan describir de manera abstracta el concepto, pero fallan con cierto detalle. Prefiero ver esta respuesta en la parte superior de la lista.
Hawkeye
55
La mayoría de las otras respuestas crearon más preguntas en mi mente. Este los eliminó a todos. Esta respuesta realmente debería estar en lo más alto en mi humilde opinión
Hami Torun
39

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

Mecanografía estática

Se dice que un lenguaje de programación usa la escritura 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 escritura estática, los tipos están asociados con variables, no valores. Los lenguajes de tipo estático incluyen Ada, C, C ++, C #, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (con respecto a la distinción de escalares, matrices, hash y subrutinas) y Scala. La tipificación estática es una forma limitada de verificación del programa (ver seguridad de tipos): en consecuencia, permite detectar muchos errores de tipo al principio del ciclo de desarrollo. Los verificadores 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 cumplan para todas las ejecuciones posibles del programa, lo que elimina la necesidad de repetir 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 con menos memoria) al omitir las comprobaciones de tipo de tiempo de ejecución y habilitar 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 verificadores de tipo estático son conservadores. Rechazarán algunos programas que pueden comportarse bien en tiempo de ejecución, pero que no se puede determinar estáticamente que estén bien escritos. 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 escrito, porque un análisis estático no puede determinar que la rama else no se tomará. [1] El comportamiento conservador de los verificadores de tipo estático es ventajoso cuando se evalúa como falso con poca frecuencia: un verificador de tipo estático puede detectar errores de tipo en rutas de código poco utilizadas. Sin una verificación de tipo estática, incluso las pruebas de cobertura de código con una cobertura de código del 100% pueden no ser capaces de encontrar tales errores de tipo. Las pruebas de cobertura de código pueden no detectar dichos errores de tipo porque se debe tener en cuenta la combinación de todos los lugares donde se crean los valores y todos los lugares donde se usa un cierto valor.

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

Escritura dinámica

Se dice que un lenguaje de programación se tipea dinámicamente, o simplemente 'dinámico', cuando la mayoría de su verificación de tipo se realiza en tiempo de ejecución en lugar de en tiempo de compilación. En la tipificación dinámica, los tipos están asociados con valores, no con variables. Los lenguajes de tipo dinámico incluyen Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (con respecto a los tipos definidos por el usuario pero no a los tipos integrados), PHP, Prolog, Python, Ruby, Smalltalk y Tcl. En comparación con la escritura estática, la escritura 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 de tipo dinámico acepta e intenta ejecutar algunos programas que pueden ser considerados inválidos por un verificador de tipo estático.

La escritura dinámica puede generar errores de tipo en tiempo de ejecución; es decir, en tiempo de ejecución, un valor puede tener un tipo inesperado y se aplica una operación sin sentido 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 tipados dinámicamente, en comparación con sus primos tipados estáticamente, realizan menos verificaciones de "tiempo de compilación" en el código fuente (pero verifican, por ejemplo, que el programa sea sintácticamente correcto). Las comprobaciones en tiempo de ejecución pueden ser potencialmente más sofisticadas, 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 en 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. La prueba es una práctica clave en el desarrollo de software profesional, y es particularmente importante en lenguajes de tipo dinámico. En la práctica, las pruebas realizadas para garantizar el funcionamiento correcto del programa pueden detectar una gama mucho más amplia de errores que la verificación de tipos estática, pero, por el contrario, no pueden buscar de manera tan exhaustiva los errores que tanto la prueba como la verificación de tipos estáticos 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", en el sentido de que el usuario del programa no tendrá que ejecutar dichas pruebas manualmente.

Referencias

  1. Pierce, Benjamin (2002). Tipos y lenguajes de programación. MIT Press. ISBN 0-262-16209-1.
Jacob
fuente
75
La idea principal de SO es construir un cuerpo de conocimiento, no proporcionar enlaces a otros lugares. Debe intentar al menos hacer un extracto de la wiki que responda a la pregunta.
NomeN
55
Simplemente parecía redundante ya que es un enlace a Wikipedia y no a un sitio web transitorio, pero lo recordaré la próxima vez.
Jacob el
2
De alguna manera, todavía no puedo pensar en un ejemplo en un lenguaje de tipo dinámico donde un tipo no esté claro en el momento de la compilación, pero debe ser resuelto en tiempo de ejecución. ¿Me podría dar un poco?
Novellizator
3
@Novellizator Comentario anterior, pero imagine un escenario en el que algunos datos se recogen de un servidor remoto y luego se usan para seleccionar una propiedad de un objeto. Ej: myObject[remoteDataName]. Entonces no hay forma de saber qué propiedad elegirá o incluso si es una propiedad válida.
Mike Cluck
14

La terminología "escrita dinámicamente" es lamentablemente engañosa. Todos los idiomas tienen tipos estáticos y los tipos son propiedades de expresiones (no de valores como algunos piensan). Sin embargo, algunos idiomas tienen solo un tipo. Estos se llaman lenguajes unipatificados. 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 dan como resultado una recursión infinita o un término lambda, pero nunca señalan 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 lo único sensato es señalar un error cuando esto sucede, pero para poder hacerlo, cada valor debe etiquetarse con un indicador que indique si el término es un término lambda o un número. El operador de suma luego verificará que, de hecho, ambos argumentos estén etiquetados como números y, si no lo están, indicará un error. Tenga en cuenta que estas etiquetas no son tipos, porque los tipos son propiedades de los programas, no de los valores producidos por esos programas.

Un lenguaje de tipo único que hace esto se llama de tipo dinámico.

Los lenguajes como JavaScript, Python y Ruby son todos de tipo único. Nuevamente, el typeofoperador en JavaScript y la typefunción en Python tienen nombres engañosos; devuelven las etiquetas asociadas con los operandos, no sus tipos. Del mismo modo, dynamic_casten C ++ y instanceofen Java no realice verificaciones de tipo.

pliegue derecho
fuente
7

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, código de máquina)
  • Tiempo de ejecución : período en el que el programa ejecuta comandos (después de la compilación, si se compila)
  • Idioma 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 los tipos están marcados"

5 + '3'es un ejemplo de un error de tipo en lenguajes fuertemente tipados como Go y Python, porque no permiten la "coerción de tipo" -> la capacidad de un valor para cambiar el tipo en ciertos contextos, como la fusión de dos tipos. Los idiomas mal escritos , como JavaScript, no arrojarán un error de tipo (resultados '53').

  • Estático : Tipos verificados antes del tiempo de ejecución
  • Dinámico : tipos marcados 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 marcan los tipos" vs. "cuando se traduce el código fuente".

¡Obtendrá los mismos errores de tipo independientemente de si el idioma está compilado o interpretado ! Necesita 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 en el que se está ejecutando. ¡El elsebloque nunca se ejecuta, por 5 + '3'lo que nunca se mira!

¿Qué pasa si se ha escrito estáticamente?

Se generaría un error de tipo incluso antes de que se ejecute el código. Todavía realiza la verificación de tipo antes del tiempo de ejecución aunque se interprete.

¿Qué pasa si fue compilado?

El elsebloque se traduciría / miraría antes del tiempo de ejecución, pero como se escribe dinámicamente, ¡no arrojaría un error! Los idiomas 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 ejecutarse (estáticos) y el error de tipo se detecta inmediatamente! Los tipos aún se verificarían antes del tiempo de ejecución si se interpretaran, teniendo el mismo resultado. Si fuera dinámico, no arrojaría ningún error a pesar de que el código se vería durante la compilación.


Actuación

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

Los lenguajes tipados estáticamente tienen un mejor rendimiento en tiempo de ejecución intrínsecamente debido a que no es necesario verificar los tipos dinámicamente durante la ejecución (se verifica antes de ejecutarse).

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

Tenga en cuenta que tanto los idiomas compilados como los estáticamente escritos tendrán un retraso antes de ejecutar la traducción y la verificación de tipos, respectivamente.


Más diferencias

La escritura estática detecta los errores temprano, en lugar de encontrarlos durante la ejecución (especialmente útil para programas largos). Es más "estricto", ya que no permitirá errores de tipo en ningún lugar de su programa y, a menudo, evita que las variables cambien de tipo, lo que defiende aún más contra errores no intencionados.

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 los tipos, lo que puede provocar errores inesperados.

JBallin
fuente
" Debido a que Python se interpreta y se escribe dinámicamente, solo traduce y verifica el código en el que se está ejecutando ", ese no es realmente el caso. Python (al menos la implementación de referencia) compila todo su código en el momento de la importación (también puede compilar módulos antes / sin importarlos). El compilador presenta varias optimizaciones (al menos en lo que permite la naturaleza dinámica de Python).
Eli Korvigo
6

Lenguajes estáticamente tipados : cada variable y expresión ya se conoce en tiempo de compilación.

( int a;a puede tomar solo valores de tipo entero en tiempo de ejecución)

Ejemplos: C, C ++, Java

Lenguajes de tipo dinámico : las variables pueden recibir diferentes valores en tiempo de ejecución y su 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.

Raman Gupta
fuente
5

Verificación de tipos de idiomas estáticamente escritos en tiempo de compilación y el tipo NO puede cambiar. (No te pongas lindo con los comentarios de conversión de tipos, se crea una nueva variable / referencia).

Verificación de tipo de idiomas escritos dinámicamente en tiempo de ejecución y el tipo de una variable PUEDE cambiarse en tiempo de ejecución.

RESTfulGeoffrey
fuente
4

Definiciones dulces y simples, pero que se ajustan a la necesidad: los lenguajes tipados estáticamente vinculan el tipo a una variable para todo su alcance (Seg: SCALA) Los lenguajes tipados dinámicamente vinculan el tipo al valor real al que hace referencia una variable.

usuario3627021
fuente
3
  • En un lenguaje de tipo estático, una variable está asociada con un tipo que se conoce en tiempo de compilación, y ese tipo permanece sin cambios durante la ejecución de un programa. De manera equivalente, a la variable solo se le puede asignar un valor que sea una instancia del tipo conocido / especificado.
  • En un lenguaje de tipo dinámico, una variable no tiene tipo, y su valor durante la ejecución puede ser de cualquier forma.
Chudong
fuente
2

Los lenguajes tipados estáticamente como C ++, Java y los lenguajes tipados dinámicamente como Python difieren solo en términos de la ejecución del tipo de la variable. Los lenguajes tipados estáticamente tienen un tipo de datos estáticos para la variable, aquí el tipo de datos se verifica durante la compilación, por lo que la depuración es mucho más simple ... mientras que los lenguajes tipados dinámicamente no hacen lo mismo, se verifica el tipo de datos que ejecuta el programa y, por lo tanto, el La depuración es un poco difícil.

Además, tienen una diferencia muy pequeña y pueden relacionarse con lenguajes fuertemente tipados y débilmente tipados . Un lenguaje fuertemente tipado no le permite usar un tipo como otro, por ejemplo. C y C ++ ... mientras que los lenguajes débilmente escritos permiten, por ejemplo, python

Akash Sharma
fuente
2

Mecanografiado estáticamente

Los tipos se verifican antes del tiempo de ejecución para que los errores puedan detectarse antes.

Ejemplos = c ++

Mecanografiado dinámicamente

Los tipos se verifican durante la ejecución.

Ejemplos = Python

Atticus Denewmont
fuente
2
Esto realmente no agrega nada que aún no esté cubierto por otras respuestas, ¿verdad?
Robert
1
Sí, pero la mayoría de las respuestas no eran muy claras, así que quería una respuesta que fuera fácil de entender.
Atticus Denewmont
1

Lenguajes de tipo estático (el compilador resuelve llamadas a métodos y compila referencias):

  • generalmente mejor rendimiento
  • retroalimentación de error de compilación más rápida
  • mejor soporte IDE
  • no es adecuado para trabajar con formatos de datos indefinidos
  • más difícil comenzar un desarrollo cuando el modelo no está definido cuando
  • mayor tiempo de compilación
  • en muchos casos requiere escribir más código

Lenguajes de tipo dinámico (decisiones tomadas en la ejecución del programa):

  • menor rendimiento
  • desarrollo más rápido
  • algunos errores pueden detectarse solo más tarde en tiempo de ejecución
  • bueno para formatos de datos indefinidos (meta programación)
MagGGG
fuente
0

El lenguaje de tipo dinámico ayuda a prototipar rápidamente los conceptos de algoritmo sin la sobrecarga de pensar qué tipos de variables deben usarse (lo cual es una necesidad en el lenguaje de tipo estático ).

Pavan Kanajar
fuente
-15

Escritura estática: los lenguajes como Java y Scala son de escritura estática.

Las variables deben definirse e inicializarse antes de usarse en un código.

por ej. int x; x = 10;

System.out.println (x);

Escritura dinámica: Perl es un lenguaje de escritura dinámica.

No es necesario inicializar las variables antes de usarlas en el código.

y = 10; use esta variable en la parte posterior del código

Prakhyat
fuente
2
Bueno, esta respuesta no es completamente correcta. En ambos idiomas, las variables deben ser inicializadas antes de ser utilizadas. Sin embargo, en los idiomas escritos dinámicamente, puede optar por omitir el tipo donde se usa.
darshan
Parece que estás usando mal el término "variables", deberías haber dicho "tipos" en su lugar.
Emir
Yo diría que Perl está estáticamente tipado: tiene 3 tipos, scalar ( $), array ( @) y hash ( %). El tipo de una variable en Perl se conoce en tiempo de compilación y permanece igual para el resto de la vida útil de las variables.
CoffeeTableEspresso