terminology - tipado - lenguaje de programacion de firefox

Estático/Dinámico vs Fuerte/Débil (9)

Veo que estos términos aparecen en la programación y tengo una vaga noción de lo que significan. Una búsqueda me muestra que, de hecho, se han preguntado esas cosas en todo el desbordamiento de pila. Por lo que sé, la escritura estática / dinámica en los idiomas es sutilmente diferente de la escritura fuerte / débil, pero esa diferencia es que me elude. Diferentes fuentes parecen usar diferentes significados o incluso usan los términos de manera intercambiable. No puedo encontrar un lugar que habla de ambos y en realidad explica la diferencia. Lo que estaría bien sería si alguien pudiera explicar esto claramente aquí para mí y para el resto del mundo.

Idiomas estáticamente tipados dinámicamente

Los idiomas tipificados estáticamente 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 lanaguges estáticamente tipificados cada variable tiene un tipo y no cambia con el curso. Ahora, en contraste, los lanaguges de tipo dinámico son aquellos en los que la comprobación de tipos se realiza en tiempo de ejecución, y no hay ningún tipo en el momento de la compilación, por lo que esto también significa que en los idiomas de tipo dinámico puede haber o no un tipo asociado con una variable , 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 controlados por tipos dinámicos 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 el envío dinámico, el enlace tardío, la conversión descendente, la reflexión y características similares ".
Incluso si el lenguaje se escribe de forma estática, aún podría tener alguna característica tipificada dinámicamente, lo que básicamente significa que algún tipo de comprobación de tipo también en tiempo de ejecución. Esto es útil en el casting de tipos.
- “Una serie de características útiles y comunes del lenguaje de programación no se pueden verificar de forma estática, como la conversión a baja. Por lo tanto, muchos idiomas tendrán una comprobación de tipos tanto estática como dinámica; el verificador de tipo estático verifica lo que puede, y las verificaciones dinámicas verifican el resto ".
“Algunos idiomas permiten escribir código que no es de tipo seguro. Por ejemplo, en C, los programadores pueden emitir libremente un valor entre cualquiera de los dos tipos que tengan el mismo tamaño ".
La ventaja de los lanaguges tipificados "estáticamente" 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 de tiempo de ejecución o errores relacionados con el tipo, porque la mayor parte de la verificación de tipos se realiza en tiempo de compilación.
La ventaja de los langugadores tipificados "dinámicamente" 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, por lo que los desarrolladores pueden crear variables y ejecutarlo, y esto conduce a una creación de prototipos muy rápida.
Lista de lanaguges mecanografiado estática y dinámicamente :
- Inactivamente:
  - Java
  - C (C es un lenguaje tipado estáticamente pero menos tipificado "fuertemente" en comparación con Java porque permite más conversiones implícitas)
  - C ++
  - DO#
- Dinamicamente:
  - PERL
  - PHP
  - Pitón
  - JavaScript
  - Rubí
La comprobación de tipos es una característica de seguridad importante. Supongamos que no hay verificación de tipos, y un método acepta un objeto de tipo "BankAccount" que tiene un método llamado "creditAccount (BankAccountDetails)", ahora en tiempo de ejecución si no hay una verificación de tipos, entonces puedo pasar un objeto por mi cuenta. clase que tiene el mismo método "creditAccount (BankAccountDetails)" y se ejecutará, considerando que estamos hablando de lenguaje orientado a objetos porque OOP soporta "polimorfismo" y aquí lo que estamos discutiendo no es más que "polimorfismo". Por lo tanto, básicamente un lenguaje orientado a objetos (que básicamente significa que es compatible con el "polimorfismo") que no tiene una comprobación de tipos sólida puede llevar a problemas de seguridad.

Fuertes v / s lanaguges débilmente mecanografiados

Los lanaguges de tipo fuerte son aquellos en los que no se permiten las conversiones implícitas si hay una pérdida de precisión. Por ejemplo, en Java, puede lanzar un "int a long" porque no hay pérdida de precisión, pero no puede "implícitamente" emitir un "long to int" porque habría una pérdida de precisión. Por el contrario, en lanaguges de tipo débil, las conversiones implícitas se permiten incluso si hay pérdida de precisión.
Creo que el lenguaje tipado dinámicamente también puede ser un lenguaje fuertemente tipado si "en tiempo de ejecución" no permite conversiones implícitas en las que hay pérdida de precisión.

Buenas lecturas adicionales

Creo que los otros colegas hicieron un buen trabajo esp. Explicando la diferencia entre 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í hay dos ejemplos:

Algunos dicen que Haskell está fuertemente tipado, porque no se le permite realizar conversiones de tipos.
Otros (por ejemplo, la opinión de Dario) dicen que un lenguaje que permite convertir implícitamente de una cadena a un número a propósito está mal escrito, pero incluso otros lo llaman simplemente escritura de pato.

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

De Scott''s Programming Language Pragmatics , tercera edición, página 291, tenemos

La verificación de tipos es el proceso de asegurar que un programa obedece las reglas de compatibilidad de tipos del idioma. Una violación de las reglas se conoce como un tipo de choque. Se dice que un lenguaje está fuertemente tipado si prohíbe, de una manera que la implementación del lenguaje pueda imponer, la aplicación de cualquier operación a cualquier objeto que no esté destinado a soportar esa operación. Se dice que un idioma se escribe de forma estática si se escribe con fuerza y la comprobación de tipos se puede realizar en tiempo de compilación. En el sentido más estricto del término, pocos idiomas están tipificados estáticamente. En la práctica, el término a menudo se aplica a idiomas en los que la mayoría de las verificaciones de tipos se pueden realizar en tiempo de compilación, y el resto se puede realizar en tiempo de ejecución.
Algunos ejemplos: Ada está muy tipado, y en su mayor parte está tipificado de forma estática (ciertas restricciones de tipo deben verificarse en tiempo de ejecución). Una implementación de Pascal también puede realizar la mayoría de las comprobaciones de tipo en el momento de la compilación, aunque el lenguaje no está muy tipificado: los registros de variante sin etiquetar (que se analizarán en la Sección 7.3.4) son su única laguna. C89 es significativamente más fuertemente tipado que sus dialectos predecesores, pero aún así es significativamente menos tipificado que Pascal. Sus lagunas incluyen uniones, subrutinas con números variables de parámetros y la interoperabilidad de los punteros y matrices (que se analizarán en la Sección 7.7.1). Las implementaciones de C rara vez verifican nada en tiempo de ejecución.
La verificación de tipos dinámica (en tiempo de ejecución) es una forma de enlace tardío y tiende a encontrarse en idiomas que retrasan otros problemas hasta el tiempo de ejecución. Lisp y Smalltalk se escriben dinámicamente (aunque con fuerza). La mayoría de los lenguajes de scripting también se escriben dinámicamente; algunos (por ejemplo, Python y Ruby) están fuertemente tipados. Los lenguajes con alcance dinámico generalmente se escriben dinámicamente (o no se escriben): si el compilador no puede identificar el objeto al que se refiere un nombre, tampoco puede determinar el tipo de objeto.

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

He intentado traducir la descripción de Scott en un bonito diagrama, que he publicado a continuación.

Has descubierto un punto débil en la terminología que los aficionados utilizan para hablar sobre los lenguajes de programación. No utilice los términos "fuerte" y "débil" , porque no tienen un significado técnico universalmente acordado. Por el contrario, la escritura estática significa que los programas se verifican antes de ejecutarse , y un programa puede rechazarse antes de que comience. La escritura dinámica significa que los tipos de valores se verifican durante la ejecución , y una operación mal escrita puede hacer que el programa se detenga o, de lo contrario , indique un error en el tiempo de ejecución . Una razón principal para la escritura estática es descartar programas que puedan tener tales "errores de tipo dinámico".

La tipificación fuerte generalmente significa que no hay lagunas en el sistema de tipos, mientras que la tipificación débil significa que el sistema de tipos se puede subvertir (invalidando cualquier garantía). Los términos a menudo se usan incorrectamente para significar escritura estática y dinámica. Para ver la diferencia, piense en C: el lenguaje se verifica en el momento de la compilación (escritura estática), pero hay muchas lagunas; puede convertir prácticamente un valor de cualquier tipo a otro tipo del mismo tamaño --- en particular, puede emitir tipos de punteros libremente. Pascal era un lenguaje que estaba destinado a ser tipificado enérgicamente, pero tenía una escapatoria imprevista: un registro de variante sin etiqueta.

Las implementaciones de lenguajes fuertemente tipados a menudo adquieren lagunas en 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 el momento de la compilación convierte un valor de cualquier tipo a uno de cualquier otro tipo. Mi ejemplo favorito es Modula-3, cuyos diseñadores llamaron LOOPHOLE construcción de conversión de LOOPHOLE .

Dicho esto, no se puede contar con que dos personas usen las palabras "fuerte" y "débil" exactamente de la misma manera. Así que evítalos.

Hoy, investigando sobre este tema, encontré este gran artículo http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Se aclaró un montón de cosas para mí y pensé que podría agregar a 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 tipo es "fuerte" o "débil". Esto es desafortunado, ya que estas palabras casi no tienen ningún significado. Es, hasta cierto punto, posible comparar dos idiomas con sistemas tipográficos muy similares, y designar 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 que tiene un significado real. De hecho, su importancia es frecuentemente subestimada. Los sistemas de tipo dinámico y estático son dos cosas completamente diferentes, cuyos objetivos se superponen parcialmente.
Un sistema de tipo estático es un mecanismo mediante el cual un compilador examina el código fuente y asigna etiquetas (llamadas "tipos") a partes de la sintaxis, y luego las usa para inferir algo sobre el comportamiento del programa. Un sistema de tipo dinámico es un mecanismo mediante el cual un compilador genera un 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 "tipo" en cada uno de estos dos sistemas no es, por supuesto, una coincidencia; sin embargo, se entiende mejor que tiene una especie de significado histórico débil. Se produce una gran confusión al tratar de encontrar una visión del mundo en la que "tipo" realmente signifique lo mismo en ambos sistemas. No lo hace

Tipos explícitos / implícitos:

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

La escritura débil significa que el tipo de un objeto puede cambiar según el contexto. Por ejemplo, en un lenguaje mal escrito, la cadena "123" puede tratarse como el número 123 si le agrega otro número. Ejemplos de lenguajes con escritura 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 pueden tratarse como un tipo diferente mediante el envío.

En un lenguaje fuertemente tipado, el tipo de un objeto no cambia: un int es siempre un int y tratar de usarlo como una cadena dará como resultado un error. Tanto Java como Python están fuertemente tipados.

La diferencia entre la escritura 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 la fuente y se aplica en el momento de la compilación. En un lenguaje de tipo dinámico, los tipos solo se verifican cuando se utilizan en tiempo de ejecución. Así que Java se escribe estáticamente y Python se escribe dinámicamente.

Sin embargo, los límites pueden ser un poco borrosos a veces. Por ejemplo, aunque Java se escribe de forma estática, cada vez que se utiliza la reflexión o una conversión (por ejemplo, cuando se usan contenedores de Objetos), se aplaza la verificación de tipo al tiempo de ejecución.

De manera similar, la mayoría de los lenguajes de tipo fuerte se convertirán automáticamente entre enteros y flotantes (y en algunos idiomas BigInts de precisión superior).

Los idiomas escritos de manera estática generalmente requieren que declare los tipos de variables, que luego se verifican en el momento de la compilación para reducir los errores. La palabra "estática" en "Escrito estáticamente" se refiere a "análisis de código estático", que es el proceso de examinar el código antes de ejecutarlo. Si bien es posible que un lenguaje de tipo estático deduzca el tipo de variable del lado derecho de una expresión o los parámetros reales, en la práctica, los idiomas de tipo más estático requieren que los tipos de variables se declaren explícitamente.

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

Se pueden combinar elementos de lenguajes tipificados estática y dinámicamente. Por ejemplo, C # admite variables tipificadas estática y dinámicamente, y los lenguajes orientados a objetos generalmente admiten la conversión de la jerarquía de tipos. Los idiomas escritos de forma estática suelen proporcionar varias formas de omitir la verificación de tipos, por ejemplo, mediante el uso de casting, reflexión e invocación dinámica.

La escritura fuerte y débil se refiere a un continuo de cuánto intenta el lenguaje prevenir los errores debido al uso de una variable como si se tratara de un tipo cuando en realidad es otro. Por ejemplo, tanto C como Java son lenguajes con tipos estáticos, sin embargo, Java utiliza una comprobación de tipos mucho más fuerte que C. El siguiente código C está feliz de compilar y ejecutar, y pondrá un valor aleatorio en la variable b en el tiempo de ejecución, lo más probable es que cause un insecto:

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;

Simplemente póngalo de esta manera: en un lenguaje de tipo estático , el tipo es estático , lo que significa que una vez que establece una variable en un tipo, NO puede cambiarlo. Esto se debe a que la escritura está asociada 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 de tipo dinámico , el tipo es dinámico , lo que significa que después de establecer una variable en un tipo, PUEDE cambiarlo. Esto se debe a que la escritura está asociada con el 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, la escritura fuerte / débil en un lenguaje está relacionada con las conversiones de tipo implícitas (en parte, tomadas de la respuesta de @Dario):

Por ejemplo en Python:

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

mientras 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 escritura estática permite verificar la corrección del tipo en el momento de la compilación. Los lenguajes con tipos estáticos generalmente se compilan, y los idiomas con tipos dinámicos se interpretan. Por lo tanto, los idiomas escritos dinámicamente pueden verificar la escritura en tiempo de ejecución.

La escritura estática / dinámica trata sobre cuándo se adquiere la información de tipo (ya sea en tiempo de compilación o en tiempo de ejecución)
La escritura fuerte / débil se refiere a cómo se distinguen los tipos estrictamente (por ejemplo, si el lenguaje intenta realizar una conversión implícita de cadenas a números).

Consulte la wiki-page para obtener información más detallada.