¿Cuál es la diferencia entre un lenguaje fuertemente tipado y un lenguaje de tipos estáticos?

Question

Además, puede uno implica al otro?

Answer 1

  

¿Cuál es la diferencia entre un lenguaje fuertemente tipado y un lenguaje de tipos estáticos?

Un lenguaje de tipos estáticos tiene un sistema del tipo que se comprueba en tiempo de compilación por la aplicación (un compilador o intérprete). La verificación de tipos rechaza algunos programas, y los programas que pasan la verificación general vienen con algunas garantías; por ejemplo, las garantías del compilador para no utilizar entero instrucciones aritméticas con números en coma flotante.

No hay un acuerdo real sobre lo que significa "inflexible", aunque la definición más ampliamente utilizado en la literatura profesional es que en un lenguaje "inflexible", no es posible para el programador de trabajo en torno a las restricciones impuestas por el sistema de tipos. Este término se utiliza casi siempre para describir lenguajes de tipos estáticos.

estático vs dinámico

Lo contrario de tipos estáticos es "tipos dinámicos", lo que significa que

1. Los valores utilizados en tiempo de ejecución se clasifican en tipos.
2. Hay restricciones sobre cómo se pueden utilizar estos valores.
3. Cuando se violan dichas restricciones, la violación se reporta como un error de tipo (dinámico).

Por ejemplo, Lua , un lenguaje de tipos dinámicos, tiene un tipo de cadena, un tipo de número, y un tipo booleano , entre otros. En Lua cada valor pertenece a exactamente un tipo, pero esto no es un requisito para todos los lenguajes de tipado dinámico. En Lua, es permisible para concatenar dos cadenas, pero no es permisible para concatenar una cadena y un booleano.

Fuerte vs débil

Lo contrario de "inflexible" es "tipos débiles", que significa que puede trabajar en todo el sistema de tipos. C es notoriamente tipos débiles, ya que cualquier tipo de puntero se puede convertir en cualquier otro tipo de puntero, simplemente mediante fundición. Pascal estaba destinado a ser fuertemente tipado, pero un descuido en el diseño (registros variantes sin etiquetar) introdujo un vacío en el sistema de tipo, por lo que técnicamente se escribe débilmente. Ejemplos de lenguajes verdaderamente inflexible incluyen CLU, Standard ML y Haskell. Ml estándar de hecho, ha sido objeto de varias revisiones para eliminar las lagunas existentes en el sistema de tipos que fueron descubiertos después de que el lenguaje fue ampliamente desplegado.

Lo que realmente está pasando aquí?

En general, resulta no ser 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 que existe para llegar en la práctica, y cuáles son las consecuencias de la explotación de una laguna. En la práctica, lo mejor es evitar los términos "fuerte" y "débil" por completo , porque

• Los aficionados a menudo los confunden con "estático" y "dinámica".

• Al parecer, "la tipificación débil" es utilizado por algunas personas para hablar sobre el prevalance o ausencia relativa de las conversiones implícitas.

• Los profesionales no se ponen de acuerdo sobre exactamente lo que significan los términos.

• En general, es poco probable que informar o ilustrar a su público.

La triste verdad es que cuando se trata de escribir sistemas, "fuerte" y "débil" no tienen un acuerdo universal sobre el significado técnico. Si usted quiere discutir la fuerza relativa de tipo sistemas, es mejor discutir exactamente lo garantías son y no se proporcionan. Por ejemplo, una pregunta bueno preguntar es lo siguiente: "es cada valor de un tipo determinado (o clase) garantiza que se han creado llamando a uno de los constructores de ese tipo?" En C, la respuesta es no. En CLU, F #, y Haskell es que sí. Para C ++ No estoy seguro-I gustaría saber.

Por el contrario, tipificación estática significa que los programas son verificado antes de ser ejecutado , y un programa podría ser rechazada antes de que comience. dinámico escribiendo significa que los tipos de Los valores es inspeccionado a durante ejecución, y una deficientemecanografiada operación podría provocar que el programa se detenga o de lo contrario señalar un error en tiempo de ejecución. Una razón principal para la tipificación estática es descartar los programas que podrían tener tales "errores dinámicos de tipo".

  

Cómo uno implica al otro?

En un nivel pedante, no, porque la palabra "fuerte" en realidad no nada malo. Pero en la práctica, la gente casi siempre lo hacen una de dos cosas:

• (incorrectamente) el uso "fuerte" y "débil" en el sentido de "estática" y "dinámica", en cuyo caso (incorrectamente) están utilizando "inflexible" y "tipos estáticos" de manera intercambiable.

• Utilizan "fuerte" y "débil" para comparar las propiedades de los 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 ADELANTE, que en realidad no tienen ningún tipo de un sistema de tipo, no puedo pensar en un lenguaje de tipos dinámicos, donde el sistema de tipos puede ser subvertido. Algo así por definición, dichos controles se bulit en el motor de ejecución, y cada operación consigue revisados ??por la cordura antes de ser ejecutado.

De cualquier manera, si una persona llama a un lenguaje "inflexible", esa persona es muy probable que se habla de un lenguaje de tipos estáticos.

Answer 2

Esto es a menudo mal entendido así que vamos a aclararlo.

estático / dinámico Typing

tipificación estática es donde el tipo está ligado a la variables . Tipos se comprueban en tiempo de compilación.

dinámico escribiendo es donde el tipo está destinada a la valor . Tipos se comprueban en tiempo de ejecución.

Así que en Java, por ejemplo:

String s = "abcd";

s será "siempre" será un String. Durante su vida puede apuntar a diferentes Strings (ya s es una referencia en Java). Puede tener un valor null pero nunca se referirá a una Integer o una List. Eso es tipos estáticos.

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 tipado dinámico.

tipado fuerte / débil

(Editar alerta!)

La tipificación estricta es una frase sin sentido ampliamente acordados. La mayoría de los programadores que utilizan este término para referirse a algo que no sea el uso de tipos estáticos que implican que hay una disciplina de tipo que se aplica por el compilador. Por ejemplo, CLU tiene un sistema de tipo fuerte que no permite el código de cliente para crear un valor de tipo abstracto, excepto mediante el uso de los constructores proporcionados por el tipo. C tiene un sistema de tipo un poco fuerte, pero se puede "subvertido" en un grado debido a que un programa siempre puede convertir un valor de tipo de un puntero a un valor de otro tipo de puntero. Así, por ejemplo, en C se puede tomar un valor devuelto por malloc() y alegremente echarlo a FILE*, y el compilador no va a tratar de detenerlo, o incluso que le avise de que está haciendo poco fiables nada.

(La respuesta original dijo algo de un valor "no se cambia el tipo en tiempo de ejecución". He conocido a muchos diseñadores del lenguaje y los autores de compiladores y no he conocido uno que habló sobre los valores cambiantes de tipo en tiempo de ejecución, excepto, posiblemente, algunos muy avanzada la investigación en sistemas de tipo, en los que esto se conoce como la "fuerte problema de actualización".)

tipificación débil implica que el compilador no hace cumplir un discpline escribir, o tal vez que la aplicación puede ser fácilmente subvertido.

El original de esta respuesta combinó tipificación 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 a una cadena antes de ser concatenado con "abc". Se puede argumentar que el compilador de Java que vuelve a escribir código como:

String s = "abc" + new Integer(123).toString();

Considere un PHP clásico "se inicia con el" problema:

if (strpos('abcdef', 'abc') == false) {
  // not found
}

El error aquí es que los rendimientos strpos() el índice del partido, siendo 0. 0 es obligada a false boolean y por lo tanto la condición es realmente cierto. La solución es utilizar === 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 conducir programadores mal camino.

Compare eso a Ruby:

val = "abc" + 123

que es un error de ejecución porque en Ruby la objeto 123 es no implícitamente convertidos sólo porque pasa a ser pasado a un método +. En Rubí el programador debe hacer la conversión explícita:

val = "abc" + 123.to_s

La comparación de PHP y Ruby es un buen ejemplo aquí. Ambos son de tipo dinámico PHP idiomas, pero tiene un montón de conversiones implícitas y Ruby (quizás 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 debido a una fuerte vs tipificación débil no es sólo menos claramente definidos, no existe un consenso real sobre exactamente lo que se entiende por una fuerte y débil. Por esta razón tipado fuerte / débil es mucho más de un tono of gris en lugar de negro o blanco.

Así que para responder a su pregunta:. Otra manera de mirar esto que de sobre todo correcto es decir que los tipos estáticos es la seguridad de tipos en tiempo de compilación y tipado fuerte es la seguridad de tipos en tiempo de ejecución

La razón de esto es que las variables en un lenguaje de tipos estáticos tienen un tipo que debe ser declarado y se puede comprobar en tiempo de compilación. Un lenguaje de tipo fuerte tiene valores que tienen un tipo en tiempo de ejecución, y es difícil para el programador de subvertir el sistema de tipos sin una verificación dinámica.

Pero es importante entender que una lengua puede ser estático / Fuerte, estático / Débil, dinámico / Fuerte o Dinámico / débil.

Answer 3

Los dos son polos en dos ejes diferentes:

• vs. inflexible tipos débiles
• vs. estático de tipos de tipos dinámicos

fuertemente tipado medios, un no se convierten automáticamente a partir de un tipo a otro. tipos débiles es lo contrario: Perl puede utilizar una cadena como "123" en un contexto numérico, convirtiendo automáticamente en el 123 int. Un lenguaje fuertemente tipado como Python no hará esto.

tipos estáticos medios, las cifras del compilador fuera del tipo de cada variable en tiempo de compilación. lenguajes con tipos dinámicos única averiguar los tipos de variables en tiempo de ejecución.

Answer 4

significa que hay restricciones entre las conversiones entre tipos inflexible de tipos. Estático de tipos medios que los tipos no son dinámicas - no se puede cambiar el tipo de una variable una vez que ha sido creado.

Answer 5

La coacción de datos no significa necesariamente tipos débiles porque a veces su azúcar syntacical:

El ejemplo anterior de Java siendo tipos débiles debido a

String s = "abc" + 123;

No es ejemplo de tipos débiles debido a su realmente haciendo:

String s = "abc" + new Integer(123).toString()

coacción datos tampoco es tipos débiles, si usted está construyendo un nuevo objeto. Java es un muy mal ejemplo de tipos débiles (y cualquier lenguaje que tiene buen reflejo muy probablemente no ser tipos débiles). Debido a que el tiempo de ejecución de la lengua siempre sabe lo que es del tipo (a excepción podría ser tipos nativos).

Esto es a diferencia C. C es el uno de los mejores ejemplos de tipos débiles. El tiempo de ejecución tiene ni idea de si 4 bytes es un entero, una estructura, un puntero o un 4 caracteres.

El tiempo de ejecución del lenguaje que realmente define si es o no su tipos débiles de lo contrario es realmente sólo una opinión.

EDIT: pensaron Después de más esto no es necesariamente cierto que el tiempo de ejecución no tiene que tener todos los tipos reificadas en el sistema de tiempo de ejecución para ser un sistema inflexible de tipos. Haskell y ML tienen tales análisis estático completa que puedan potencial de información de tipo ommit desde el tiempo de ejecución.

Answer 6

Uno no implica la otra. Para que una lengua sea estáticamente mecanografiado que significa que son conocidos o inferidos en tiempo de compilación los tipos de todas las variables.

fuertemente lenguaje escrito no se le permite utilizar un tipo como otro. C es un lenguaje de tipos débiles y es un buen ejemplo de lo inflexible de tipos idiomas no permiten. En C se puede pasar un elemento de datos del tipo incorrecto y no se quejará. En lenguajes fuertemente tipados no se puede.

Answer 7

La tipificación estricta probablemente significa que las variables tienen un tipo bien definido y que hay reglas estrictas acerca de la combinación de variables de diferentes tipos de expresiones. Por ejemplo, si A es un número entero y B es un flotador, entonces la regla estricta sobre A + B podría ser que A es fundido a un flotador y el resultado devuelto 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.

tipos estáticos probablemente significa que los tipos se asignan en tiempo de compilación (o su equivalente para los idiomas no compilado) y no se puede cambiar durante la ejecución del programa.

Tenga en cuenta que estas clasificaciones no son mutuamente excluyentes, de hecho yo esperaría que ocurren juntos con frecuencia. Muchos lenguajes de tipo fuerte son también estáticamente mecanografiadas.

Y tenga en cuenta que cuando se utiliza la palabra 'probablemente' es porque no están universalmente aceptada definición de estos términos. Como ya habrán visto en las respuestas hasta el momento.

Answer 8

  

respuesta ya se ha dado anteriormente. Se trata de diferenciar entre una fuerte vs semana y estática vs concepto dinámico.

¿Qué es inflexible de tipos VS tipos débiles?

inflexible de tipos: no se convertirán automáticamente a partir de un tipo a otro

En Go o Python como los lenguajes fuertemente tipados "2" + 8 elevarán un error de tipo, ya que no permiten el "tipo de coacción".

Débilmente (libremente) proporcionado: se convertirán automáticamente a un tipo a otro: idiomas tipos débiles como JavaScript o Perl no generará un error y en este caso se Javascript resultados '28' y Perl darán como resultado 10.

Perl Ejemplo:

my $a = "2" + 8;
print $a,"\n";

Guardar a main.pl y correr perl main.pl y obtendrá la salida 10.

¿Qué es estático VS Dyamic tipo?

En la programación, progammer definir tipos estáticos y tipado dinámico con respecto al punto en el que se comprueban los tipos de variables. Estática mecanografiado idiomas son aquellos en los que la verificación de tipos se realiza en tiempo de compilación, mientras que tecleó dinámica lenguas son aquellos en los que la verificación de tipos se realiza en tiempo de ejecución.

• estática: Tipos comprueba antes de tiempo de ejecución
• Dinámica: Tipos comprobado sobre la marcha, durante la ejecución

Lo que es significa esto?

En la pasan cheques escribirse antes de tiempo de ejecución (comprobación estática). Esto significa que no sólo se traduce y controles de tipo de código que está ejecutando, pero va a escanear a través de todo el código y el error tipo serían lanzados antes de que el código se ejecuta incluso. Por ejemplo,

package main

import "fmt"

func foo(a int) {
    if (a > 0) {
        fmt.Println("I am feeling lucky (maybe).")
    } else {
        fmt.Println("2" + 8)
    }
}

func main() {
    foo(2)
}

Guardar este archivo en main.go y ejecutarlo, obtendrá mensaje fallido de compilación para esto.

go run main.go
# command-line-arguments
./main.go:9:25: cannot convert "2" (type untyped string) to type int
./main.go:9:25: invalid operation: "2" + 8 (mismatched types string and int)

Pero este caso no es válida para Python. Por ejemplo siguiente bloque de código se ejecutará por primera foo (2) llamada y fallará para la segunda foo (0) llamada. Es porque Python se escribe de forma dinámica, sólo se traduce y controles de tipo de código se ejecuta en. El bloque de los demás nunca se ejecuta para foo (2), por lo que "2" + 8 está ni siquiera contemplado, y para foo (0) llaman a tratar de ejecutar ese bloque y han fracasado.

def foo(a):
    if a > 0:
        print 'I am feeling lucky.'
    else:
        print "2" + 8
foo(2)
foo(0)

Usted verá siguiente salida

python main.py
I am feeling lucky.
Traceback (most recent call last):
  File "pyth.py", line 7, in <module>
    foo(0)
  File "pyth.py", line 5, in foo
    print "2" + 8
TypeError: cannot concatenate 'str' and 'int' objects