type-safety - qué - tipado sinonimo
¿Cuál es la diferencia entre un lenguaje fuertemente tipado y un lenguaje tipificado estáticamente? (8)
¿Cuál es la diferencia entre un lenguaje fuertemente tipado y un lenguaje tipificado estáticamente?
Un lenguaje de tipo estático tiene un sistema de tipo que se comprueba en tiempo de compilación por la implementación (un compilador o intérprete). La verificación de tipo rechaza algunos programas, y los programas que pasan la verificación generalmente vienen con algunas garantías; por ejemplo, el compilador garantiza no usar instrucciones aritméticas de enteros en números de punto flotante.
No existe un acuerdo real sobre lo que significa "tipificación fuerte", aunque la definición más utilizada en la literatura profesional es que en un lenguaje "tipificado fuertemente" no es posible que el programador evite las restricciones impuestas por el sistema de tipos. . Este término se usa casi siempre para describir idiomas tipificados estáticamente.
Estático vs dinámico
El opuesto de tipificación estática es "tipado dinámicamente", lo que significa que
- Los valores utilizados en el tiempo de ejecución se clasifican en tipos.
- Hay restricciones sobre cómo se pueden usar tales valores.
- Cuando se violan esas restricciones, la violación se informa como un error de tipo (dinámico).
Por ejemplo, Lua , un lenguaje de tipo dinámico, tiene un tipo de cadena, un tipo de número y un tipo booleano, entre otros. En Lua, todos los valores pertenecen exactamente a un tipo, pero esto no es un requisito para todos los idiomas escritos dinámicamente. En Lua, está permitido concatenar dos cadenas, pero no está permitido concatenar una cadena y un Booleano.
Fuerte vs débil
El opuesto de "fuertemente tipado" es "débilmente tecleado", lo que significa que puede solucionar el sistema de tipos. C es notoriamente débilmente tipado porque cualquier tipo de puntero es convertible a cualquier otro tipo de puntero simplemente lanzando. Se pretendía que Pascal fuera tipificado enérgicamente, pero un descuido en el diseño (registros de variante sin etiquetar) introdujo una laguna en el sistema de tipos, por lo que técnicamente está tipificado de manera débil. Los ejemplos de lenguajes verdaderamente fuertemente tipados incluyen CLU, Standard ML y Haskell. De hecho, Standard ML ha sufrido varias revisiones para eliminar las lagunas en el sistema de tipos que se descubrieron después de que el lenguaje se implementó ampliamente.
¿Qué está pasando aquí realmente?
En general, resulta que no es tan útil hablar de "fuerte" y "débil". Si un sistema de tipo tiene una laguna es menos importante que el número exacto y la naturaleza de las lagunas, la probabilidad de que surjan en la práctica y cuáles son las consecuencias de explotar una laguna. En la práctica, es mejor evitar los términos "fuerte" y "débil" por completo , porque
Los aficionados a menudo los combinan con "estático" y "dinámico".
Aparentemente, algunas personas usan la "escritura débil" para hablar sobre la prevalencia relativa o la ausencia de conversiones implícitas.
Los profesionales no pueden ponerse de acuerdo exactamente sobre lo que significan los términos.
En general, es poco probable que informe o ilumine a su audiencia.
La triste verdad es que cuando se trata de sistemas tipográficos, "fuerte" y "débil" no tienen un significado técnico universalmente acordado. Si desea analizar la fuerza relativa de los sistemas tipográficos, es mejor analizar exactamente qué garantías se ofrecen y cuáles no. Por ejemplo, una buena pregunta es: "¿se garantiza que cada valor de un tipo (o clase) dado haya sido creado al llamar a uno de los constructores de ese tipo?" En C la respuesta es no. En CLU, F #, y Haskell es sí. Para C ++ no estoy seguro, me gustaría saberlo.
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".
¿Uno implica el otro?
En un nivel pedante, no, porque la palabra "fuerte" en realidad no significa nada. Pero en la práctica, las personas casi siempre hacen una de dos cosas:
Ellos (incorrectamente) usan "fuerte" y "débil" para significar "estático" y "dinámico", en cuyo caso ellos (incorrectamente) están usando "fuertemente tipado" y "estáticamente tipificado" indistintamente.
Usan "fuerte" y "débil" para comparar las propiedades de los sistemas de tipo estático. Es muy raro escuchar a alguien hablar sobre un sistema de tipo dinámico "fuerte" o "débil". A excepción de FORTH, que en realidad no tiene ningún tipo de sistema de tipos, no puedo pensar en un lenguaje de tipo dinámico en el que se pueda subvertir el sistema de tipos. Más o menos, por definición, esas comprobaciones se incorporan al motor de ejecución, y cada operación se revisa para comprobar su cordura antes de ejecutarse.
De cualquier manera, si una persona llama a un idioma "fuertemente tipado", es muy probable que esa persona esté hablando de un idioma tipificado estáticamente.
Además, ¿uno implica el otro?
Ambos son polos en dos ejes diferentes:
- mecanografiado fuertemente contra mecanografiado débilmente
- mecanografiado estáticamente vs mecanografiado dinámicamente
Significados fuertemente , no se convertirá automáticamente de un tipo a otro. Débilmente escrito es lo opuesto: Perl puede usar una cadena como "123" en un contexto numérico, convirtiéndola automáticamente en el int 123 . Un lenguaje fuertemente tipado como python no hará esto.
Significados estáticamente significa, el compilador calcula el tipo de cada variable en tiempo de compilación. Los idiomas tipificados dinámicamente solo determinan los tipos de variables en tiempo de ejecución.
Data Coercion no significa necesariamente tipado débilmente porque a veces su azúcar sintáctica:
El ejemplo anterior de Java está escrito de forma débil debido a
String s = "abc" + 123;
No es un ejemplo tipificado débilmente porque realmente está haciendo:
String s = "abc" + new Integer(123).toString()
La coacción de datos tampoco se escribe de manera débil si está construyendo un nuevo objeto. Java es un muy mal ejemplo de tipificación débil (y cualquier lenguaje que tenga una buena reflexión probablemente no se tipifique débilmente). Debido a que el tiempo de ejecución del idioma siempre sabe cuál es el tipo (la excepción podría ser los tipos nativos).
Esto es diferente a C. C es uno de los mejores ejemplos de tipificación débil. El tiempo de ejecución no tiene idea de si 4 bytes son un entero, una estructura, un puntero o 4 caracteres.
El tiempo de ejecución del lenguaje realmente define si su tipificación débil o no es su opinión realmente justa.
EDITAR: Después de una reflexión adicional, esto no es necesariamente cierto, ya que el tiempo de ejecución no tiene que tener todos los tipos reificados en el sistema de tiempo de ejecución para ser un sistema fuertemente tipado. Haskell y ML tienen un análisis estático tan completo que pueden omitir la información de tipo del tiempo de ejecución.
En la programación de computadoras, los lenguajes de programación a menudo se denominan coloquialmente fuertemente tipados o tipificados débilmente. Estos términos no tienen una definición precisa, pero en general es más probable que un lenguaje fuertemente tipificado genere un error o se niegue a compilar si el argumento pasado a una función no coincide con el tipo esperado. Por otro lado, un lenguaje de tipo muy débil puede producir resultados impredecibles o puede realizar una conversión de tipo implícita
Esto es a menudo mal entendido, así que déjame aclararlo.
Mecanografía estática / dinámica
La escritura estática es donde el tipo está vinculado a la variable . Los tipos se verifican en tiempo de compilación.
La escritura dinámica es donde el tipo está vinculado al valor . Los tipos se verifican en tiempo de ejecución.
Así en Java por ejemplo:
String s = "abcd";
s será "por siempre" una String . Durante su vida útil puede apuntar a diferentes String s (ya que s es una referencia en Java). Puede tener un valor null , pero nunca se referirá a un Integer o una List . Eso es tipificación estática.
En PHP:
$s = "abcd"; // $s is a string
$s = 123; // $s is now an integer
$s = array(1, 2, 3); // $s is now an array
$s = new DOMDocument; // $s is an instance of the DOMDocument class
Eso es tipificación dinámica.
Mecanografía fuerte / débil
(Editar alerta!)
La escritura fuerte es una frase sin un significado ampliamente aceptado. La mayoría de los programadores que usan este término para significar algo más que la tipificación estática lo utilizan para dar a entender que existe una disciplina de tipo que impone el compilador. Por ejemplo, CLU tiene un sistema de tipo sólido que no permite que el código del cliente cree un valor de tipo abstracto, excepto mediante el uso de los constructores proporcionados por el tipo. C tiene un sistema de tipo algo fuerte, pero puede ser "subvertido" en cierta medida porque un programa siempre puede convertir un valor de un tipo de puntero a un valor de otro tipo de puntero. Entonces, por ejemplo, en C puedes tomar un valor devuelto por malloc() y alegremente convertirlo en FILE* , y el compilador no intentará detenerte, ni siquiera advertirte que estás haciendo algo peligroso.
(La respuesta original decía algo acerca de un valor "que no cambia el tipo en el tiempo de ejecución". Conozco a muchos diseñadores de idiomas y escritores de compiladores y no conozco uno que hablara de los valores que cambian de tipo en el tiempo de ejecución, excepto posiblemente una investigación muy avanzada en el tipo sistemas, donde esto se conoce como el "problema de actualización fuerte".)
La tipificación débil implica que el compilador no impone una disciplina de escritura, o tal vez esa subvención puede ser fácilmente subvertida.
El original de esta respuesta combinaba la tipificación débil con la conversión implícita (a veces también llamada "promoción implícita"). Por ejemplo, en Java:
String s = "abc" + 123; // "abc123";
Este código es un ejemplo de promoción implícita: 123 se convierte implícitamente a una cadena antes de concatenar con "abc" . Se puede argumentar que el compilador de Java vuelve a escribir ese código como:
String s = "abc" + new Integer(123).toString();
Considere un problema clásico de PHP "comienza con":
if (strpos(''abcdef'', ''abc'') == false) {
// not found
}
El error aquí es que strpos() devuelve el índice de la coincidencia, siendo 0. 0 se convierte en booleano false y, por lo tanto, la condición es verdadera. La solución es utilizar === lugar de == para evitar la conversión implícita.
Este ejemplo ilustra cómo una combinación de conversión implícita y escritura dinámica puede desviar a los programadores.
Compara eso con Ruby:
val = "abc" + 123
que es un error de tiempo de ejecución porque en Ruby el objeto 123 no se convierte implícitamente solo porque se pasa a un método + . En Ruby el programador debe hacer explícita la conversión:
val = "abc" + 123.to_s
Comparando PHP y Ruby es una buena ilustración aquí. Ambos son lenguajes de tipo dinámico, pero PHP tiene muchas conversiones implícitas y Ruby (tal vez sorprendentemente si no está familiarizado con él) no lo hace.
Estático / Dinámico vs Fuerte / Débil
El punto aquí es que el eje estático / dinámico es independiente del eje fuerte / débil. La gente los confunde probablemente en parte porque la tipografía fuerte contra débil no solo se define con menos claridad, sino que no existe un consenso real sobre lo que se entiende por fuerte y débil. Por esta razón, la tipificación fuerte / débil es mucho más gris que el negro o el blanco.
Entonces, para responder a su pregunta: otra forma de ver esto que en su mayoría es correcta es decir que la tipificación estática es la seguridad de tipo compilación y la tipificación fuerte es la seguridad de tipo runtime.
La razón de esto es que las variables en un lenguaje tipificado estáticamente tienen un tipo que debe declararse y puede verificarse en el momento de la compilación. Un lenguaje fuertemente tipado tiene valores que tienen un tipo en tiempo de ejecución, y es difícil para el programador subvertir el sistema de tipos sin una comprobación dinámica.
Pero es importante entender que un lenguaje puede ser Estático / Fuerte, Estático / Débil, Dinámico / Fuerte o Dinámico / Débil.
La escritura fuerte probablemente significa que las variables tienen un tipo bien definido y que existen reglas estrictas sobre la combinación de variables de diferentes tipos en expresiones. Por ejemplo, si A es un entero y B es un flotante, entonces la regla estricta sobre A + B podría ser que A se convierte en un flotador y el resultado se devuelve como un flotador. Si A es un entero y B es una cadena, entonces la regla estricta podría ser que A + B no es válido.
La escritura estática probablemente significa que los tipos se asignan en el momento de la compilación (o su equivalente para idiomas no compilados) y no pueden cambiar durante la ejecución del programa.
Tenga en cuenta que estas clasificaciones no son mutuamente excluyentes, de hecho espero que se produzcan juntas con frecuencia. Muchos lenguajes fuertemente tipados también están tipificados estáticamente.
Y tenga en cuenta que cuando uso la palabra "probablemente" es porque no hay definiciones universalmente aceptadas de estos términos. Como ya habrás visto por las respuestas hasta ahora.
La tipificación fuerte significa que hay restricciones entre las conversiones entre tipos. Escrito de forma estática significa que los tipos no son dinámicos, no se puede cambiar el tipo de una variable una vez que se ha creado.
Uno no implica el otro. Para que un idioma se escriba estáticamente significa que los tipos de todas las variables se conocen o se deducen en el momento de la compilación.
Un lenguaje fuertemente tipado no le permite usar un tipo como otro. C es un lenguaje de tipificación débil y es un buen ejemplo de lo que no permiten los lenguajes de tipificación fuerte. En C puede pasar un elemento de datos del tipo incorrecto y no se quejará. En idiomas fuertemente tipados no puedes.