web-dev-qa-db-fra.com

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

Cela est apparu lors d'une discussion avec un ami, et je me suis retrouvé aux abois pour trouver de bons arguments. Quels avantages confère une frappe faible?

type-systemstype-safetyweak-typing
41
Fishtoaster

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 aux termes "typage statique", "typage dynamique", "typage explicite", "typage implicite", " typage canard "," typage structurel "ou" typage nominal ". Heck, même les termes "typage manifeste" et "typage latent", qui sont encore des domaines de recherche et de discussion ouverts, sont probablement mieux définis.

Donc, jusqu'à ce que votre ami fournisse une définition du terme "typage faible" qui soit suffisamment stable pour servir de base à une discussion, cela n'a même pas de sens de répondre à cette question.

Malheureusement, à part réponse de Nick , aucun des répondeurs n'a pris la peine de fournir sa définition non plus, et vous pouvez voir la confusion qui se produit dans certains des commentaires. C'est difficile à dire, car personne ne fournit réellement leurs définitions, mais je pense que j'en compte au moins trois différentes, juste sur cette même page.

Certaines des définitions les plus couramment utilisées sont (et oui, je sais que pratiquement aucune n'a de sens, mais ce sont les définitions que j'ai vu que les gens utilisent réellement):

  • typage faible = typage dangereux/typage fort = typage sûr
  • 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 = transtypages implicites/typage fort = uniquement transtypages explicites
  • typage faible = transtypages implicites ou explicites/typage fort = pas de transtypages du tout
  • typage faible = conversions implicites/typage fort = uniquement les conversions explicites
  • typage faible = conversions implicites ou explicites/typage fort = aucune conversion du tout
  • typage faible = interprétation/typage fort = compilation
  • typage faible = typage lent/fort = rapide
  • typage faible = garbage collection/typage fort = gestion manuelle de la mémoire
  • typage faible = gestion manuelle de la mémoire/typage fort = collecte des ordures
  • … et plein d'autres

Cependant, les trois définitions qui semblent être utilisées le plus le plus largement sont

  • typage faible = votre langage de programmation stupide et merdique/typage fort = mon langage de programmation super génial
  • typage faible = tous les autres langages 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 gens qui apprennent par exemple Haskell ou Scheme comme leur premier et unique langage ne semblent pas partager cette vision du monde)
  • typage faible = toutes les langues que je ne comprends pas/typage fort = Java (substituer avec C # ou C++ à volonté)

À moins que tout le monde ne s'accorde sur une définition de ce qu'est même un "typage faible" , cela n'a même pas de sens de penser à ses avantages. Avantages de quoi? Pire encore, s'il n'y a pas de définition du tout , alors tout le monde peut simplement changer ses définitions pour s'adapter à ses arguments, et chaque discussion est à peu près garantie de se déléguer dans une guerre des flammes.

J'ai moi-même changé plusieurs fois ma propre définition au fil des ans et j'en suis arrivé au point où je ne considère même plus les termes comme utiles. Je pensais également que la faible frappe (dans ses différentes définitions) a 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 trompais.

46
Jörg W Mittag

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

Saisie dynamique

Un langage de programmation est dit être typé dynamiquement lorsque la majorité de sa vérification de type est effectuée au moment de l'exécution plutôt qu'au moment de 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 ignorés uniquement pour les "nouveaux" programmeurs, mais peuvent également être pratiques pour tout programmeur:

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

Moins de code dans tous les cas où vous auriez autrement à caster ou attribuer une nouvelle valeur:

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

Dactylographie lâche ou faible

Un typage faible signifie qu'un langage convertit (ou transforme) implicitement les types lorsqu'il est utilisé.

Avantages:

  • Passez n'importe quelle valeur de type comme 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 a également des avantages secondaires, comme une partie d'un || Peut être utilisé dans l'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 a dû aller à mi-chemin, avec l'appel implicite à .toString() lors de la combinaison d'objets avec un String; sinon Java = les programmeurs le maudiraient toute la journée (les instructions de 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.

25
Nicole

L'argument principal pour le typage faible est celui de la performance. (ceci pour répondre à la question du PO comme indiqué). Il y a beaucoup de bonnes discussions sur dynamique contre statique, implicite contre explicite. etc.

C est le langage faiblement typé le plus connu, et il n'effectue aucune vérification au moment de l'exécution ni aucune vérification du temps de compilation du type de variables. En substance, vous pouvez lancer un char * à un int * et la langue s'en fichait. Alors pourquoi tu fais ça?

La programmation C est assez proche de la façon dont vous feriez les choses avec Assembly, donc il y a des moments où vous ne vous souciez que d'une adresse. Il n'est pas rare de lancer ou de passer un 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 faire des calculs assez cool en fonction de l'adresse dans le void * pour obtenir les informations dont vous avez besoin. Cela peut vous permettre de court-circuiter le processus que vous devrez suivre dans Java par exemple.

Bien que la vérification du type au moment de l'exécution n'ait pas une surcharge extraordinaire, il y a des moments où elle suffit juste pour ralentir une section critique. Je pense principalement à la programmation embarquée et aux systèmes en temps réel dans ce cas.

Cela dit, dans la plupart des cas, avoir un système de type robuste qui est soit vérifié lors de la compilation soit vérifié lors de l'exécution aide plus souvent qu'il ne fait mal.

7
Berin Loritsch

Une saisie faible est généralement plus facile à saisir pour les débutants, par exemple dans des choses comme Excel, javascript et vbscript. Vous échangez également une certaine vitesse de développement contre des erreurs potentielles.

Bon article sur le sujet: Typage fort vs tests forts

2
Homde