Quels sont les arguments en faveur d'un typage faible?

Cela a été abordé lors d'une discussion avec un ami et je me suis trouvé dans l'impossibilité de trouver de bons arguments. Quels avantages confère le typage faible?

Le problème avec ce type de discussion est simplement que les termes "typage faible" et "typage fort" ne sont pas définis, contrairement à par exemple les termes "typage statique", "typage dynamique", "typage explicite", "typage implicite", " dactylographie "," typage structural "ou" typage nominal ". Heck, même les termes "typage manifeste" et "typage latent", qui restent des domaines ouverts de recherche et de discussion, sont probablement mieux définis.

Donc, tant que votre ami n’a pas défini le terme "typage faible" suffisamment stable pour pouvoir servir de base à une discussion, il n’a même aucun sens de répondre à cette question.

Malheureusement, mis à part la réponse de Nick , personne n’a pris la peine de donner sa définition non plus, et vous pouvez voir la confusion qui en résulte dans certains des commentaires. C'est difficile à dire, car personne ne fournit réellement leurs définitions, mais je pense en compter au moins trois différentes, rien que sur cette page.

Certaines des définitions les plus couramment utilisées sont (et oui, je sais qu’aucune d’entre elles n’a de sens, mais ce sont les définitions que j’ai déjà vues utiliser):

• typage faible = typage non sécurisé / typage fort = typage sécurisé
• typage faible = typage dynamique / typage fort = typage statique
• typage faible = typage canard / typage fort = typage nominal
• typage faible = typage structurel / typage fort = typage nominal
• typage faible = typage implicite / typage fort = typage explicite
• typage faible = typage latent / typage fort = typage manifeste
• frappe faible = pas de frappe / frappe forte = frappe
• typage faible = conversions implicites / typage puissant = uniquement des distributions explicites
• typage faible = incantations implicites ou explicites / typage fort = pas d'incantation du tout
• typage faible = conversions implicites / typage fort = uniquement les conversions explicites
• typage faible = conversions implicites ou explicites / typage fort = pas de conversion du tout
• typage faible = interprétation / typage fort = compilation
• typage faible = typage lent / fort = rapide
• typage faible = récupération de place / typage puissant = gestion manuelle de la mémoire
• typage faible = gestion manuelle de la mémoire / typage fort = récupération de place
• … et plein d'autres

Les trois définitions qui semblent être les plus utilisées sont toutefois:

• typage faible = votre langage de programmation pourri stupide / typage fort = mon langage de programmation super génial
• typage faible = tout autre langage de programmation / typage fort = le seul langage de programmation que j'ai jamais pris la peine d'apprendre (généralement Java, C # ou C ++; étrangement, les personnes qui apprennent, par exemple, Haskell ou Scheme comme leur premier et unique langage ne semblent pas partager cette vision du monde)
• typage faible = tous les langages que je ne comprends pas / typage fort = Java (remplace par C # ou C ++ à volonté)

À moins que tout le monde est d' accord sur une définition de « typage faible » , même est , il ne fait même pas de sens de penser à ce que ses avantages pourraient être. Avantages de quoi? Pire encore, s’il n’ya pas de définition du tout , alors tout le monde peut modifier ses définitions pour s’ajuster à ses arguments, et chaque discussion est pratiquement garantie de dégénérer en guerre-flamme.

Personnellement, j’ai moi-même changé plusieurs fois de définition au cours des années et j’ai maintenant atteint le point où je ne considère même plus que les termes sont utiles. J'avais aussi l'habitude de penser que le typage faible (dans ses diverses définitions) avait sa place dans les scripts shell, mais chaque fois que je dois résoudre le même problème dans Bash et PowerShell, je me rappelle douloureusement à quel point je me suis trompé.

N'oubliez pas qu'il existe deux concepts majeurs qui sont souvent confondus:

Frappe dynamique

Un langage de programmation est dit dynamiquement typé lorsque la majorité de sa vérification de type est effectuée au moment de l'exécution, par opposition à la compilation. En typage dynamique, les valeurs ont des types mais pas les variables; c'est-à-dire qu'une variable peut faire référence à une valeur de n'importe quel type.

Les avantages ici sont souvent considérés comme réservés aux "nouveaux" programmeurs, mais peuvent également convenir à tout programmeur:

if (!(arr is Array)) arr = [arr]; // is, instanceof, .constructor ==, whatever

Moins de code dans les cas où vous auriez sinon dû attribuer ou attribuer une nouvelle valeur:

if (data is Array)) {
    i = data.length; // no i = ((Array)data).length or Array myArr=(Array)data;
}

Typage lâche ou faible

Un typage faible signifie qu'un langage convertit (ou convertit) de manière implicite les types lorsqu'il est utilisé.

Avantages:

• Transmettez une valeur de type en tant que paramètre à une fonction . Utile pour les rappels, les API flexibles et permet une implémentation plus simple des fermetures.

• Évaluation booléenne implicite . Tout type peut être évalué comme un booléen. Cela présente également des avantages, tels qu'une partie d'un et ||peut être utilisé dans une affectation sans conversion en booléen:

  var a = param || defaultValue;
  

• Encore une fois, moins de code:

  var num = 5;
  var str = "Hello";
  input.innerHTML = input.value = num;
  for (var i=0; i < input.value; i++) { ... }
  

  Même Java devait aller en partie, avec l'appel implicite à la .toString()combinaison d'objets avec un String; sinon, les programmeurs Java le maudiraient toute la journée (les instructions du journal seraient hors de contrôle).

^{Les deux définitions proviennent de http://en.wikipedia.org/wiki/Type_system . Il l'a dit mieux que moi.}

Le principal argument en faveur d'un typage faible est celui de la performance. (Ceci est pour répondre à la question des PO comme indiqué). Il y a beaucoup de bonnes discussions sur dynamique vs statique, implicite vs explicite. etc.

C est le langage le plus célèbre faiblement typé, et il n’effectue aucune vérification à l’exécution ni à la compilation du type de variable. Essentiellement, vous pouvez lancer un char *vers un int *et la langue ne l’intéressera pas. Alors pourquoi feriez-vous cela?

La programmation en C est assez proche de la façon dont vous procéderiez avec un assemblage, il est donc parfois nécessaire de ne se préoccuper que d’une adresse. Il n’est pas rare de donner ou de faire passer une void *référence pour cette raison même. Si vous savez comment la mémoire est organisée (encore une fois un problème de C et d’assemblage), vous pouvez effectuer des calculs assez intéressants en fonction de l’adresse indiquée dans le void *pour obtenir les informations dont vous avez besoin. Cela peut vous permettre de court-circuiter le processus que vous auriez à suivre en Java, par exemple.

Bien que la vérification de type au moment de l’exécution ne génère pas une charge de travail extraordinaire, il arrive parfois qu’elle soit juste suffisante pour que la section critique soit trop lente. Je pense surtout à la programmation intégrée et aux systèmes temps réel dans ce cas.

Cela dit, dans la plupart des cas, avoir un système de type fort contrôlé à la compilation ou à l'exécution aide plus souvent que nécessaire.

Les utilisateurs débutants ont plus de facilité à saisir les fautes de frappe, par exemple dans Excel, javascript et vbscript. Vous négociez également une vitesse de développement pour des erreurs potentielles.

Bon article sur le sujet: typage fort vs tests forts