Has descubierto un punto débil en la terminología que usan los aficionados para hablar de lenguajes de programación. No use los términos "fuerte" y "débil" escribiendo, porque no tienen un significado técnico universalmente acordado. Por el contrario, la tipificación estáticasignifica que los programas se comprueban antes de ser ejecutados, y un programa puede ser rechazado antes de que se inicie. La tipificación dinámica significa que los tipos de los valores se comprueban durante la ejecución , y una operación mal escrita puede hacer que el programa se detenga o de lo contrario señale un error en tiempo de ejecución. Una razón principal para la tipificación estática es descartar programas que podrían tener tales "errores de tipo dinámico".

La tipificación fuerte generalmente significa que no hay lagunasen el sistema de tipos, mientras que la tipificación débil significa que el sistema de tipos puede ser subvertido (invalidando cualquier garantía). Los términos se utilizan a menudo incorrectamente para significar estático y mecanografía dinámica. Para ver la diferencia, piense en C: el lenguaje se comprueba en tiempo de compilación (tipeo estático), pero hay muchas lagunas; puede casi convertir un valor de cualquier tipo a otro tipo del mismo tamaño---en particular, puede convertir tipos de puntero libremente. Pascal era un lenguaje que estaba destinado a ser fuertemente escrito, pero tenía una laguna imprevista: un registro variante sin etiqueta.

Las implementaciones de lenguajes fuertemente tipeados a menudo adquieren lagunas con el tiempo, generalmente para que parte del sistema de tiempo de ejecución se pueda implementar en el lenguaje de alto nivel. Por ejemplo, Objective Caml tiene una función llamada Obj.magic que tiene el efecto de tiempo de ejecución de simplemente devolver su argumento, pero en tiempo de compilación convierte un valor de cualquier tipo a uno de cualquier otro tipo. Mi ejemplo favorito es Modula-3, cuyos diseñadores llamaron a su construcción de fundición de tipos LOOPHOLE.

Habiendo dicho eso, no puedes contar con dos personas que usen las palabras "fuerte" y "débil" en exactamente de la misma manera. Así que evítalos.

Simplemente póngalo de esta manera: en un lenguaje estáticamente tipado el tipo es estático, lo que significa que una vez que establece una variable a un tipo, NO PUEDE cambiarla. Esto se debe a que escribir está asociado con la variable en lugar del valor al que se refiere.

Por ejemplo en Java:

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

Mientras que en un lenguaje dinámicamente escrito el tipo es dinámico, lo que significa que después de establecer una variable a un tipo, puede cambiarla. Esto se debe a que escribir está asociado con la valor en lugar de la variable.

Por ejemplo en Python:

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

Por otro lado, el mecanografía fuerte/débil en un lenguaje está relacionado con conversiones de tipos implícitas (en parte tomadas de la respuesta de @Darío):

Por ejemplo en Python:

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

Considerando que en PHP:

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

La tipificación estática permite comprobar la corrección del tipo en tiempo de compilación. Los lenguajes tipeados estáticamente son generalmente compilados, y los lenguajes tipeados dinámicamente son interpretados. Pues, dynamicly typed languages puede comprobar la escritura en tiempo de ejecución.

La tipificación débil significa que el tipo de un objeto puede cambiar dependiendo del contexto. Por ejemplo, en un lenguaje débilmente escrito, la cadena " 123 " puede ser tratada como el número 123 si le agrega otro número. Ejemplos de lenguajes con tipado débil son bash, awk y PHP.

Otro tipo de lenguaje de tipo débil es C, donde los datos en una dirección de memoria se pueden tratar como un tipo diferente mediante el casting.

En un lenguaje fuertemente escrito el tipo de un objeto no cambia - un int es siempre un int y tratar de usarlo como una cadena resultará en un error. Tanto Java como Python están fuertemente tipeados.

La diferencia entre la tipificación dinámica y estática es cuando se aplican las reglas de tipo. En un lenguaje de tipo estático, el tipo de cada variable y parámetro debe declararse en el código fuente y se aplica en tiempo de compilación. En un lenguaje dinámicamente escrito, los tipos solo se comprueban cuando se usan en tiempo de ejecución. Así que Java se escribe estáticamente y Python se escribe dinámicamente escribir.

Sin embargo, los límites pueden ser un poco borrosos a veces. Por ejemplo, aunque Java se escribe estáticamente, cada vez que se utiliza reflexión o un cast (por ejemplo, cuando se utilizan contenedores de Objetos) se está aplazando la comprobación de tipo a tiempo de ejecución.

De manera similar, los lenguajes con tipos más fuertes aún se convertirán automáticamente entre enteros y flotadores (y en algunos lenguajes BigInts de precisión abitraria).

Hoy investigando sobre este tema me encontré con este gran artículo http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Aclaró muchas cosas para mí y pensé que podría agregar algunas de las grandes respuestas anteriores.

Mecanografía fuerte y Débil:

Probablemente la forma más común en que se clasifican los sistemas de tipos es " strong" o "débil."Esto es desafortunado, ya que estas palabras casi no tienen significado en absoluto. Lo es, a un alcance limitado, posible comparar dos lenguajes con sistemas de tipos muy similares, y designan a uno como el más fuerte de esos dos sistemas. Más allá de eso, las palabras no significan nada en absoluto.

Tipos estáticos y dinámicos

Esta es casi la única clasificación común de sistemas de tipos eso tiene un significado real. De hecho, su importancia es frecuentemente subestimado [...] Los sistemas de tipo dinámico y estático son dos cosas completamente diferentes, cuyos objetivos pasan a ser parcialmente superponer.

Un sistema de tipo estático es un mecanismo por el cual un compilador examina código fuente y asigna etiquetas (llamadas "tipos" ) a piezas de la sintaxis, y luego los utiliza para inferir algo sobre el programa de comportamiento. Un sistema de tipo dinámico es un mecanismo por el cual un compilador genera código para realizar un seguimiento del tipo de datos (casualmente, también llamado su "tipo") utilizado por el programa. El uso de la misma palabra "escriba" en cada uno de estos dos sistemas, por supuesto, no es realmente del todo coincidencia; sin embargo, se entiende mejor como tener una especie de débil importancia histórica. Gran confusión resulta de tratar de encontrar un visión del mundo en la que "tipo" realmente significa lo mismo en ambos sistema. No lo hace.

Tipos explícitos / implícitos:

Cuando se utilizan estos términos se refieren a la medida en que un el compilador razonará sobre los tipos estáticos de partes de un programa. Todo los lenguajes de programación tienen alguna forma de razonamiento sobre tipos. Algunos tener más que otros. ML y Haskell tienen tipos implícitos, en que no (o muy pocos, dependiendo del idioma y las extensiones en uso) tipo se necesitan declaraciones. Java y Ada tienen tipos muy explícitos, y uno está constantemente declarando los tipos de cosas. Todo lo anterior tiene (relativamente, en comparación con C y C++, por ejemplo) tipo estático fuerte sistema.

Creo que los otros colegas hicieron un buen trabajo esp. explicando la diferencia entre la tipificación estática y dinámica. Pero en lo que respecta a la tipificación fuerte y débil, debe decirse que hay diferentes entendimientos / puntos de vista.

Aquí dos ejemplos:

• Algunos dicen que Haskell está fuertemente escrito, porque no se le permite hacer ninguna conversión de tipo.

• Otros (por ejemplo, la opinión de Darío) dicen que un lenguaje que permite convertir implícitamente de string to number a propósito se escribe débilmente, pero incluso otros lo llaman solo duck typing.

Ambas sentencias no resaltan los extremos opuestos de un sistema de tipos, sino aspectos completamente diferentes. Así que me uno a la opinión del Sr. Ramsey de no usar los términos "fuerte" y "débil" para distinguir entre los sistemas de tipos.

Estáticamente v / s lenguajes tipeados dinámicamente

• Los lenguajes de tipo estático son aquellos en los que la comprobación de tipos se realiza en el momento de la compilación, por lo que esto también significa que en los lenguajes de tipo estático cada variable tiene un tipo y no cambia a lo largo del curso. Ahora, en contraste, las lanagües dinámicamente escritas son aquellas en las que la comprobación de tipos se realiza en tiempo de ejecución, y no hay comprobación de tipos en tiempo de compilación, por lo que esto también significa que en lenguajes dinámicamente escritos hay puede o no ser un tipo asociado con variables, y si un tipo está asociado, entonces podría ser un tipo genérico como "var" en JS, que es válido tanto para una cadena como para un número.
  • "Las implementaciones de lenguajes comprobados dinámicamente generalmente asocian cada objeto de tiempo de ejecución con una etiqueta de tipo (es decir, una referencia a un tipo) que contiene su información de tipo. Esta información de tipo de tiempo de ejecución (RTTI) también se puede usar para implementar despacho dinámico, enlace tardío, fundición descendente, reflexión y características similares."
• Incluso si el lenguaje se escribe estáticamente, todavía podría tener alguna característica de tipo dinámico, lo que básicamente significa que algún tipo de comprobación de tipo en tiempo de ejecución también. Esto es útil en la fundición de tipos.
  • "Una serie de características útiles y comunes del lenguaje de programación no se pueden comprobar estáticamente, tales como down casting. Por lo tanto, muchos idiomas tendrán comprobación de tipo estático y dinámico; el comprobador de tipo estático verifica lo que puede, y dinámico los cheques verifican el resto."
• "Algunos lenguajes permiten escribir código que no es seguro para el tipo. Por ejemplo, en C, los programadores pueden emitir libremente un valor entre dos tipos que tengan el mismo tamaño."
• La ventaja de los lanaguges" estáticamente " tipeados es que:
  • Dado que la mayor parte de la comprobación de tipos se realiza en tiempo de compilación, el intérprete o el tiempo de ejecución pueden ejecutarse a toda velocidad, sin preocuparse por los tipos.
  • Conduce a un menor número de excepciones en tiempo de ejecución o errores relacionados con el tipo, porque la mayor parte de la comprobación de tipos se realiza en tiempo de compilación.
• La ventaja de los lanaguges "dinámicamente" tipeados es que:
  • Podrían ayudar en la creación de prototipos extremadamente rápidos, ya que el desarrollador no necesita entender el sistema de tipos para que dev pueda crear variables y ejecutarlo, y esto conduce a la creación de prototipos muy rápida.
• Lista de tipos estáticos y dinámicos lanaguges:
  • Estáticamente:
    • Java
    • C (C es un lenguaje de tipo estático pero menos "fuertemente" tipeado en comparación con Java porque permite más conversiones implícitas)
    • C++
    • C #
  • Dinámicamente:
    • PERL
    • PHP
    • Python
    • JavaScript
    • Ruby
• La comprobación de tipos es una característica de seguridad importante. Supongamos que no hay verificación de tipo, y un method acepta un objeto de tipo "BankAccount "que tiene un método llamado como" creditAccount(BankAccountDetails)", ahora en tiempo de ejecución si no hay verificación de tipo entonces puedo pasar un objeto de mi propia clase que tiene el mismo método" creditAccount(BankAccountDetails) "y se ejecutará, teniendo en cuenta que estamos hablando de lenguaje orientado a objetos porque OOP soporta" polimorfismo "y aquí lo que estamos discutiendo es nada más que"polimorfismo". Por lo tanto, básicamente un lenguaje orientado a objetos (que básicamente significa que es compatible con "polimorfismo") que no tiene una comprobación de tipo fuerte puede conducir a problemas de seguridad.

Fuertemente v / s débilmente mecanografiado lanaguges

• Lanagues fuertemente tipeados son aquellos en los que las conversiones implícitas no están permitidas si hay pérdida de precisión. Por ejemplo, en Java, puede lanzar un "int a largo" porque no hay pérdida de precisión, pero no puede "implícitamente" lanzar un "largo a int" porque habría pérdida de precisión. En contraste, en forma débil las conversiones implícitas se permiten incluso si hay pérdida de precisión.
• Creo que el lenguaje dinámicamente escrito también puede ser un lenguaje fuertemente escrito si "en tiempo de ejecución" no permite conversiones implícitas en las que hay pérdida de precisión.

Bueno más lecturas

• Type_system
• Strong_and_weak_typing
• Categoría: Statically_typed_programming_languages
• Categoría: Dynamically_typed_programming_languages

De Scott Programming Language Pragmatics , 3rd edidition page 291, tenemos

La comprobación de tipos es el proceso de asegurar que un programa obedece reglas de compatibilidad de tipos de lenguaje. Se conoce una violación de las reglas como un choque tipo. Se dice que un lenguaje está fuertemente escrito si prohibe, de una manera que la implementación del lenguaje puede hacer cumplir, el aplicación de cualquier operación a cualquier objeto que no esté destinado a apoya esa operación. Un se dice que el lenguaje está escrito estáticamente si se escribe fuertemente y la comprobación de tipos se puede realizar en compile tiempo. En el sentido más estricto del término, pocos idiomas son estáticamente escribir. En la práctica, el término se aplica a menudo a las lenguas en las que la mayoría de la comprobación de tipos se puede realizar en tiempo de compilación, y el resto puede se realizará en tiempo de ejecución.

Algunos ejemplos: Ada está fuertemente escrito, y en su mayor parte estáticamente tipado (ciertas restricciones de tipo deben ser comprobado en la ejecución tiempo). Una implementación de Pascal también puede hacer la mayor parte de su comprobación de tipo en tiempo de compilación, aunque el lenguaje no está fuertemente escrito: los registros de variantes sin etiquetar (que se analizarán en la sección 7.3.4) son sus sólo una laguna. C89 es significativamente más fuertemente mecanografiado que su dialectos predecesores, pero todavía significativamente menos fuertemente mecanografiados que Pascal. Sus lagunas incluyen uniones, subrutinas con números variables de parámetros, y la interoperabilidad de punteros y arrays (para ser discutido en la sección 7.7.1). Las implementaciones de C rara vez comprueban cualquier cosa en tiempo de ejecución.

La comprobación de tipos dinámica (en tiempo de ejecución) es una forma de enlace tardío, y tiende se encuentra en idiomas que retrasan otros problemas hasta el tiempo de ejecución como bien. Lisp y Smalltalk se escriben dinámicamente (aunque fuertemente). Mas los lenguajes de scripting también se escriben dinámicamente; algunos (por ejemplo, Python y Ruby) están fuertemente escritos. Los idiomas con alcance dinámico son generalmente dinámicamente tipado (o no se escribe en absoluto): si el compilador no puede identificar el objeto al que se refiere un nombre, por lo general no puede determinar el tipo del objeto.

Entonces, en términos simples, la tipificación estática/dinámica se refiere al tiempo en que se produce la comprobación de tipos: tiempo de compilación para la tipificación estática y tiempo de ejecución para los lenguajes dinámicos. Del mismo modo, la tipificación fuerte/débil se refiere a lo agresivo que es un lenguaje para imponer su sistema de tipos.

He tratado de traducir la descripción de Scott en un buen diagrama que he publicado a continuación.

Los lenguajes de tipo estático generalmente requieren que declare los tipos de variables, que luego se comprueba en tiempo de compilación para reducir los errores. La palabra "static" en " statically typed "se refiere a" static code analysis", que es el proceso de examinar el código antes de ejecutarlo. Aunque es posible para un lenguaje de tipo estático inferir el tipo de la variable desde el lado derecho de una expresión o parámetros reales, en la práctica la mayoría de los lenguajes de tipo estático requieren tipos de variables a declarar explícitamente.

Los lenguajes tipeados dinámicamente generalmente no requieren que las declaraciones de variables tengan tipos, y deducen tipos de variables basados en el tipo calculado como resultado de evaluar el lado derecho de cada instrucción de asignación o los parámetros reales de una llamada a función. Dado que a la variable se le pueden dar varias asignaciones durante su vida útil, su tipo puede cambiar con el tiempo y es por eso que se llama "dinámicamente tipado". Además, el tiempo de ejecución el entorno necesita realizar un seguimiento del tipo actual para cada variable, por lo que el tipo está vinculado al valor en lugar de con la declaración de variable. Esto se puede considerar un sistema de información de tipo de tiempo de ejecución (RTTI).

Se pueden combinar elementos de lenguajes tipeados estática y dinámicamente. Por ejemplo, C# admite variables de tipo estático y dinámico, y los lenguajes orientados a objetos generalmente admiten la reducción de la jerarquía de tipos. Los idiomas de tipo estático suelen proporcionar varias formas de evitar la comprobación de tipos, por ejemplo, mediante el uso de fundición, reflexión e invocación dinámica.

La tipificación fuerte vs.Débil se refiere a un continuo de cuánto intenta el lenguaje evitar errores debido al uso de una variable como si fuera un tipo cuando de hecho es otro tipo. Por ejemplo, tanto C como Java son lenguajes de tipo estático, sin embargo Java utiliza una comprobación de tipos mucho más fuerte que C. El siguiente código de C es feliz de compilar y ejecutar, y pondrá un valor aleatorio en el variable b en tiempo de ejecución, lo más probable es que cause un error:

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

El código Java equivalente producirá un error de compilación, que generalmente es preferible:

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