Les termes implicites et explicites prendre un certain obtention utilisé lors de l’entendre. Quand vous les entendez en termes de programmation, qu’est-ce que cela signifie exactement pour vous? Est une façon meilleure que l’autre? Ici, nous allons passer en revue chacune de ces idées et fournir des exemples avec certains avantages du modèle de conception qui peuvent en découler.
les Termes
en programmation, implicite est souvent utilisé pour faire référence à quelque chose qui est fait pour vous par un autre code dans les coulisses., Explicite est l’approche manuelle pour accomplir le changement que vous souhaitez avoir en écrivant les instructions à faire explicitement. Dans la plus petite image, implicite et explicite sont souvent des termes utilisés pour les types de casting dans le type que vous auriez à être. Dans l’ensemble, vous parlez peut-être de convention sur la configuration où la convention est ce qui est implicitement fait pour vous par une base de code ou un framework et la configuration est simplement des paramètres explicites.,
Il existe également des différences de pertinence ou d’avantage pour l’utilisation selon le langage de programmation en question et si le langage est typé statiquement ou dynamiquement. Cela dépend également si les choses peuvent être déduites à partir d’un temps d’exécution ou pendant la compilation. En raison de ces facteurs, affirmer qu’une méthodologie est meilleure qu’une autre ne peut être vrai que dans des contextes étroits, car vous devez prendre en considération la conception des langages de programmation et des programmes en question.,
Un exemple de type implicites et explicites de la coulée C est comme suit:
int implicit;implicit = 4.5;int explicit;explicit = (int)4.5;
Ici, les noms de variable implicit et explicit ont été définies pour être de type int. Une fois donné une valeur 4.5la version implicite a le compilateur convertir ce qui serait normalement un type float ou double en un entier alors que la version explicite l’a explicitement converti en un entier avec l’utilisation de (int) étant ce qui lance le type.,
langages statiquement typés
dans les langages statiquement typés tels que Rust, une grande majorité de la création de valeur et de l’affectation auront des exigences explicites d’annotation de type avec une exception pour chaque fois que le compilateur peut déduire le type. Ce qui suit est un exemple montrant les types explicites et implicites dans Rust.
fn add_one(input: u8) -> u8 { input + 1}let four = add_one(3);
Ici, la méthode add_one explicite sur le type d’entrée et le type de sortie., Le numéro 1 ajouté ici est implicitement fait un numéro u8 au moment de la compilation car le contexte aide à déduire le type et l’addition pour u8 n’est implémenté que pour fonctionner avec des numéros u8. La dernière ligne est implicitement tapée pour être un u8 puisque la méthode elle-même définit le type qui sera renvoyé.
ce qui peut être déduit dans Rust est assez impressionnant avec l’utilisation de génériques. Mais l’utilisation de l’inférence est limitée aux choses qui peuvent être connues au moment de la compilation., S’il ne peut pas être connu au moment de la compilation, vous devez définir explicitement le type à n’importe quel point d’affectation. Prendre la définition de la méthode:
use std::ops::Add;fn add_both<T: Add>(a: T, b: T) -> T::Output { a + b}
Ici T peut être n’importe quel type qui implémente le trait Add. Le typeT::Output est défini lorsque le trait Add est défini pour votre type spécifique et est généralement du même type queT lui-même dans ce cas. Maintenant, si nous fournissons deux nombres comme paramètres, le compilateur en déduit le type.,
let x = add_both(3 , 4 ); // implicit typelet y: u8 = add_both(3u8 , 4u8 ); // explicit typelet z: u32 = add_both(3u32, 4u32); // explicit type
Lorsque j’exécute le code ci-dessus x est supposé être le type i32. Les exemplesy Etz nécessitent que les types de paramètres d’entrée soient connus lorsqu’ils sont fournis à la fonction en tant qu’inférence pourT::Output ne sont pas nécessairement les mêmes que ce que T peut être déduit Il est par défaut à i32 et puis l’attribution d’une i32 dans un u8 ou u32 il est tout simplement faux.,
langages dynamiquement typés
maintenant, avec les langages dynamiquement typés, vous devez vous soucier moins des types, en soi, et plus des objets ou comportements implicites ou explicites. La modélisation du code autour d’objets qui ont le même comportement est ce qu’on appelle le typage de canard qui est un domaine de pensée supérieur en programmation orientée objet où la manipulation de ces objets est implicite. Alors que la modélisation du code autour de classes d’objets spécifiques ressemble beaucoup à l’utilisation d’un typage explicite ou implicite., Mais lorsque vous acceptez tout type d’objet en entrée, le code de cette section doit gérer explicitement différents objets ou transférer cette responsabilité ailleurs.
pour plus de précisions, lorsque vous écrivez du code pour gérer différents types de choses, vous écrivez du code explicite. Cependant, lorsque ce même code a déjà été écrit et que vous le réutilisez avec un simple appel de méthode, le comportement dans ce nouveau contexte est alors implicite. Implicite étant les choses faites comme automatiquement et traitées en dehors de votre portée actuelle.,
dans Ruby, la plupart des types ont un design pour la conversion explicite ou implicite. L’idée est la conversion implicite méthodes sont destinées à être utilisées dans des contextes implicites et explicites conversions sont destinés aux développeurs d’écrire en ligne dans beaucoup d’autres contextes. Permettez-moi de le démontrer par l’exemple.
# explicit"4".to_i + "5".to_i# => 9# implicitclass Seven def to_int 7 endendArray.new(Seven.new)# =>
Voici l’exemple explicite rend très évident pour le lecteur que nous sommes conversion String objets Integer objet et l’exécution de plus entre les deux., Et l’exemple implicite n’est pas si évident pour le lecteur que la méthode Array.new appelle implicitement la méthode to_int sur le paramètre qui lui est donné. La classe Integer a la méthode to_int définie sur chaque instance de celle-ci qui renvoie simplement self. Si vous écrivez 42.to_int vous obtenez tout simplement en arrière 42. Cette utilisation de l’utilisation de la conversion implicite comme garde d’entrée pour les appels de méthode est une excellente conception pour la sécurité de type par conception. Voici ce qui se passe si vous lui donnez le mauvais type d’objet en entrée qui ne définit pas to_int.,
Array.new("32")# TypeError (no implicit conversion of String into Integer)
Non seulement il échoue, mais il nous donne un message utile qu’une conversion implicite a essayé et raconte à la classe de l’objet donné et la classe de l’objet qu’il attend. Les méthodes de conversion implicites dans Ruby sont une façon de dire que cet objet est vraiment ce que vous attendez. Et la conversion explicite consiste simplement à effectuer la conversion au type attendu.
Ruby a des options implicites et explicites pour beaucoup de ses objets de base.,
Ruby a également quelques classes avec des méthodes de classe qui effectueront une conversion implicite ou retourneront nil et ce nom de méthode esttry_convert.
nous pouvons suivre L’exemple de Ruby avecArray.new et avoir une bonne garde pour le type de paramètres d’entrée que nous donnons en concevant des conversions implicites pour nos propres types personnalisés. Pour cet exemple, étant donné que to_f est une conversion explicite en un nombre flottant dans Ruby, nous utiliserons as_ comme préfixe au lieu de to_., Voici un exemple de base d’implication comme modèle de sécurité.
maintenant, cela aidera les autres développeurs qui utilisent la classeBar à ne pas la transmettre en tant que paramètre incompatible. Il suit une convention dans le langage Ruby et devrait être beaucoup plus facile à comprendre pour les développeurs avec des erreurs plus utiles. Lorsque vous avez d’autres objets que vous souhaitez convertir en un objet Foo, alors vous pouvez définir un as_f méthode pour une conversion explicite et le développeur qui utilise ce nouvel objet sera explicite dans son utilisation Bar.new(Baz.new.as_f)., Cela garantit que le code fonctionnera dans la mesure où Bar Et Foo fonctionnent déjà.
résumé
l’acte de codage implicite et explicite, et le code implicite et explicite, est défini par le contexte d’exécution d’un comportement supplémentaire ou d’un réglage / casting de type. Plus précisément, les méthodes implicites ou explicites sont définies par les contextes dans lesquels elles sont destinées à être utilisées. Le code implicite peut être une très belle expérience si les choses sont bien nommées car il garde les choses simples.,
cependant, le code implicite, le code qui fait les choses dans les coulisses pour vous, peut également être un problème difficile à résoudre lorsqu’il est mal fait. Le code explicite rend le code clair lorsque vous le regardez car les détails de ce qui est fait sont déjà présentés devant vous et vous n’avez pas à traquer les problèmes ailleurs, mais signifie généralement beaucoup plus de travail pour l’écrire. En soi, il peut devenir accablant, donc trouver un bon équilibre entre les deux est souvent la meilleure solution. Soyez explicite lorsque vous le DEVEZ, et implicite lorsque les concepts de conception et de dénomination sont faciles à comprendre., Cela fera une expérience de développement plus pratique.