Hola, descubrimos la respuesta a lo que buscas, has scroll y la obtendrás a continuación.
Solución:
¿Cuál es la diferencia entre un idioma fuertemente tipado y un lenguaje tipado estáticamente?
Un lenguaje de tipado estático tiene un sistema de tipos que la implementación (un compilador o intérprete) verifica en el momento de la compilación. 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 utilizar instrucciones aritméticas enteras en números de punto flotante.
No hay un acuerdo real sobre lo que significa “fuertemente tipado”, aunque la definición más utilizada en la literatura profesional es que en un lenguaje “fuertemente tipado”, el programador no puede evitar las restricciones impuestas por el sistema de tipos. . Este término casi siempre se usa para describir lenguajes de tipado estático.
Estático vs dinámico
Lo contrario de tipado estático es “tipado dinámicamente”, lo que significa que
- Los valores utilizados en tiempo de ejecución se clasifican en tipos.
- Existen restricciones sobre cómo se pueden utilizar dichos valores.
- Cuando se infringen esas restricciones, la infracción se informa como un error de tipo (dinámico).
Por ejemplo, Lua, un lenguaje escrito dinámicamente, tiene un tipo de cadena, un tipo de número y un tipo booleano, entre otros. En Lua todo valor pertenece exactamente un tipo, pero esto no es un requisito para todos los lenguajes tipados dinámicamente. En Lua, está permitido concatenar dos cadenas, pero no está permitido concatenar una cadena y un booleano.
Fuerte vs débil
Lo opuesto a “fuertemente tipado” es “débilmente tipado”, lo que significa que puede evitar el sistema de tipos. C tiene un tipo notoriamente débil porque cualquier tipo de puntero es convertible a cualquier otro tipo de puntero simplemente mediante la conversión. Pascal estaba destinado a ser muy tipado, pero un descuido en el diseño (registros variantes sin etiquetar) introdujo una laguna en el sistema de tipos, por lo que técnicamente está débilmente tipado. Algunos ejemplos de lenguajes verdaderamente tipados son CLU, Standard ML y Haskell. De hecho, el ML estándar ha sido objeto de 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 realmente aquí?
En general, no resulta tan útil hablar de “fuerte” y “débil”. Si un sistema de tipos 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 utilizan la “tipificación débil” para hablar sobre la prevalencia relativa o la ausencia de conversiones implícitas.
-
Los profesionales no pueden ponerse de acuerdo sobre el significado exacto de 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 de tipos, “fuerte” y “débil” no tienen un significado técnico universalmente acordado. Si desea discutir la fuerza relativa de los sistemas de tipos, es mejor discutir exactamente qué garantías se brindan y cuáles no. Por ejemplo, una buena pregunta es la siguiente: “¿Se garantiza que todos los valores de un tipo (o clase) determinados se hayan creado llamando 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, escritura estática significa que los programas son comprobado antes de ser ejecutadoy es posible que un programa se rechace antes de que comience. Escritura dinámica significa que los tipos de valores están marcados durante ejecución, y una operación mal escrita puede hacer que el programa se detenga o indique un error en 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, la gente casi siempre hace una de dos cosas:
-
Ellos (incorrectamente) usan “fuerte” y “débil” para significar “estático” y “dinámico”, en cuyo caso (incorrectamente) están usando “fuertemente tipado” y “tipado estáticamente” indistintamente.
-
Usan “fuerte” y “débil” para comparar propiedades de sistemas de tipo estático. Es muy raro escuchar a alguien hablar de 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 escrito dinámicamente donde el sistema de tipos pueda ser subvertido. Por definición, esas comprobaciones están integradas en el motor de ejecución, y se comprueba la cordura de cada operación antes de ejecutarla.
De cualquier manera, si una persona llama a un idioma “fuertemente tipado”, es muy probable que esa persona esté hablando de un idioma tipado estáticamente.
Esto a menudo se malinterpreta, así que déjame aclararlo.
Escritura estática / dinámica
Escritura estática es donde el tipo está ligado al variable. Los tipos se comprueban en el momento de la compilación.
Escritura dinámica es donde el tipo está ligado al valor. Los tipos se comprueban en tiempo de ejecución.
Entonces, en Java, por ejemplo:
String s = "abcd";
s será “para siempre” un String. Durante su vida puede apuntar a diferentes Strings (desde s es una referencia en Java). Puede tener un null valor, pero nunca se referirá a un Integer o un List. Eso es escritura 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 escritura dinámica.
Escritura fuerte / débil
(¡Editar alerta!)
Escritura fuerte es una frase sin un significado ampliamente aceptado. La mayoría de los programadores que utilizan este término para referirse a algo más que tipado estático lo utilizan para dar a entender que existe una disciplina de tipos impuesta por el compilador. Por ejemplo, CLU tiene un sistema de tipos fuerte 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 tipos algo fuerte, pero se puede “subvertir” hasta cierto punto 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 puede tomar un valor devuelto por malloc() y alegremente lanzarlo a FILE*, y el compilador no intentará detenerte, ni siquiera advertirte que estás haciendo algo dudoso.
(La respuesta original decía algo sobre un valor que “no cambia de tipo en tiempo de ejecución”. He conocido a muchos diseñadores de lenguajes y escritores de compiladores y no he conocido uno que hable sobre valores que cambian de tipo en tiempo de ejecución, excepto posiblemente alguna investigación muy avanzada en tipo sistemas, donde esto se conoce como el “problema de actualización fuerte”.)
Tipeo débil implica que el compilador no impone una discpline de mecanografía, o tal vez que la aplicación puede ser fácilmente subvertida.
El original de esta respuesta combinó la escritura débil con conversión implícita (a veces también llamado “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 en una cadena antes de concatenarse con "abc". Se puede argumentar que el compilador de Java reescribe 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, que es 0. 0 se convierte en booleano false y así la condición es realmente verdadera. La solución es usar === en lugar de == para evitar la conversión implícita.
Este ejemplo ilustra cómo una combinación de conversión implícita y tipado dinámico puede desviar a los programadores.
Compare eso con Ruby:
val = "abc" + 123
que es un error de tiempo de ejecución porque en Ruby el objeto 123 es no convertido implícitamente sólo porque pasa a un + método. En Ruby, el programador debe hacer explícita la conversión:
val = "abc" + 123.to_s
Comparar PHP y Ruby es una buena ilustración aquí. Ambos son lenguajes escritos dinámicamente, pero PHP tiene muchas conversiones implícitas y Ruby (quizás sorprendentemente si no está familiarizado con él) no.
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 tipificación fuerte frente a la débil no solo está menos claramente definida, sino que no existe un consenso real sobre qué se entiende exactamente por fuerte y débil. Por esta razón, la escritura fuerte / débil es mucho más de un tono de gris que de negro o blanco.
Entonces, para responder a su pregunta: otra forma de ver esto es principalmente correcto es decir que la escritura estática es seguridad de tipo en tiempo de compilación y la escritura fuerte es seguridad de tipo en tiempo de ejecución.
La razón de esto es que las variables en un lenguaje de tipado estático tienen un tipo que debe declararse y puede verificarse en tiempo de 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 verificación dinámica.
Pero es importante entender que un idioma puede ser Estático / Fuerte, Estático / Débil, Dinámico / Fuerte o Dinámico / Débil.
Ambos son polos en dos ejes diferentes:
- fuertemente tipado vs. débil tipado
- tipado estáticamente frente a tipado dinámicamente
Fuertemente tipado significa que a no se convertirá automáticamente de un tipo a otro. La escritura débil es lo opuesto: Perl puede usar una cadena como "123" en un contexto numérico, convirtiéndolo automáticamente en el int 123. Un lenguaje fuertemente tipado como Python no hará esto.
Tipado estáticamente significa que el compilador determina el tipo de cada variable en el momento de la compilación. Los lenguajes tipados dinámicamente solo determinan los tipos de variables en tiempo de ejecución.
Comentarios y puntuaciones
Si guardas algún reparo y forma de regenerar nuestro noticia te insinuamos escribir una ilustración y con placer lo estudiaremos.