Que signifie le mot "littéral"?
Que signifie le mot "littéral" lorsqu'il est utilisé dans un contexte tel que des chaînes littérales et des valeurs littérales?
Quelle est la différence entre une valeur littérale et une valeur?
Un littéral est "toute notation pour représentant une valeur dans le code source" ( wikipedia )
(Comparez ceci avec identifiants, qui référez-vous à une valeur en mémoire.)
Exemples:
"hey"(une chaîne)false(un booléen)3.14(un nombre réel)[1,2,3](une liste de nombres)(x) => x*x(une fonction)/^1?$|^(11+?)\1+$/(une expression rationnelle)
Certaines choses qui ne sont pas littérales:
std::cout(un identifiant)foo = 0;(une déclaration)1+2(une expression)
Un littéral est une valeur qui a été codée en dur directement dans votre source.
Par exemple:
string x = "This is a literal";
int y = 2; // so is 2, but not y
int z = y + 4; // y and z are not literals, but 4 is
int a = 1 + 2; // 1 + 2 is not a literal (it is an expression), but 1 and 2 considered separately are literals
Certains littéraux peuvent avoir une syntaxe spéciale, vous savez donc quel type est le littéral:
//The 'M' in 10000000M means this is a decimal value, rather than int or double.
var accountBalance = 10000000M;
Ce qui les distingue des variables ou des ressources est que le compilateur peut les traiter comme des constantes ou effectuer certaines optimisations avec du code là où elles sont utilisées, car il est certain qu'elles ne changeront pas.
Un littéral est une affectation à une valeur explicite, telle que
int i = 4; // i is assigned the literal value of '4'
int j = i // j is assigned the value of i. Since i is a variable,
//it can change and is not a 'literal'
EDIT: Comme indiqué, l’affectation en soi n’a rien à voir avec la définition d’un littéral, j’utilisais l’affectation dans mon exemple, mais un littéral peut aussi être passé à une méthode, etc.
Un littéral consiste à inclure la valeur dans le code source (par opposition à la référence à une variable ou à une constante). Par exemple:
int result = a + 5; // a is a variable with a value, 5 is a literal
string name = "Jeff Atwood"; // name is a variable initialized
// with the string literal, "Jeff Atwood"
int[] array = new int[] {1, 2, 3}; // C# has array literals (this is actually three
// int literals within an array literal)
Si le littéral représente une quantité, comme une constante physique, il est préférable de lui attribuer un nom plutôt que d'écrire le même littéral partout où vous en avez besoin. De cette façon, lorsque vous lisez le code source, vous savez ce que le nombre signifie, qui est généralement plus important que sa valeur (qui peut changer de toute façon).
const int maxUsers = 100;
const double gravitationalAcceleration = 9.8;
En général, les seuls littéraux numériques que j'utilise (à part pour initialiser les constantes comme ci-dessus) sont 0 ou 1, et parfois 2 si je saute tous les autres éléments d'une boucle. Si le sens du nombre est plus important que son valeur actuel (il l'est généralement), il est préférable de le nommer.
Une valeur littérale est une valeur , mais une valeur peut également être stockée dans une variable. Dans la déclaration
string str = "string literal";
il y a une variable de chaîne (str) et un littéral de chaîne. Une fois que l'instruction est exécutée, ils ont tous deux la même valeur.
Sachez que dans de nombreuses langues, la variable et la valeur littérale ne doivent même pas nécessairement être du même type. Par exemple:
int a = 1.0;
La valeur littérale ci-dessus est un type à virgule flottante. La valeur sera forcée par le compilateur pour tenir dans la variable int.
Pour un autre exemple, dans la première ligne de code C++, le type d'un littéral de chaîne n'est pas du tout le type de bibliothèque string. Pour maintenir la compatibilité ascendante avec C, les littéraux de chaîne en C++ sont des tableaux de caractères.
Exemple rapide:
int my_int_var = 723;
723 - Cet ensemble de caractères fait référence à un entier literal.
my_int_var - Cet ensemble de caractères fait référence à une valeur entière variable.
Un littéral est quand vous le mettez dans le code. Donc, un littéral de chaîne est
string s = "SomeText";
Ceci est opposé à la construction de la chaîne ou à sa prise en paramètre.
Généralement, lorsque quelqu'un utilise le mot littéral, cela signifie que la valeur est déchiffrable depuis le code (texte), comme le montrent de nombreux exemples dans d'autres articles.
Une autre utilisation courante concerne les valeurs converties en valeurs immédiates dans Assembly. Ce sont des valeurs qui sont insérées directement dans l'instruction machine au lieu de nécessiter des charges de registre.
J'ai entendu dire que les littéraux de chaîne étaient utilisés avec désinvolture pour désigner ce que la spécification C # désigne en fait comme littéral de chaîne. Un littéral de chaîne normal permet l'échappement de certains caractères (préfixés par un a), comme\t pour une tabulation. Un littéral de chaîne textuel est précédé de @ et est traité textuellement,\n'a pas de signification particulière.
//regular
string regular = "\thello world";
//verbatim
string verbatim = @"C:\";
//the regular equivalent of this would be "C:\\"
Un littéral est "représentation du code source des données".
Les littéraux sont des notations abrégées pour les valeurs de certains types que le langage considère comme tellement importants ou fondamentaux qu'il est doté d'un sucre de syntaxe dédié.
Exemple de types dont les valeurs sont souvent représentées par des littéraux:
Boolean = { true, false }
Integer = { ..., -2, -1, 0, 1, 2, ... }
Character = { 'a', 'b', ... }
String = { "hello", "world", ... }
Certaines langues ont littéraux même pour les types de fonctions:
Integer -> Integer = { (x: Integer) => x + 2), (x: Integer) => x/2, ...}
Un exemple de valeurs qui ne sont généralement pas représentées par des littéraux serait les valeurs Des types de classe:
Car(brand: String, seats: Integer) = { Car("BMW", 5), Car("Ferrari", 2), ...}
Ici, la valeur Car("BMW", 5) dans le type Car est effectivement désignée de manière unique à l'aide d'une séquence de symboles. Cependant, la valeur n'est pas représentée à l'aide d'un littéral abrégé dédié, mais utilise des mécanismes notionnels généraux (verbeux) pour désigner les valeurs de tout type de classe.
Le terme literal est synonyme de termes value, instance, constant, member et element de type, mais comporte un bit de signification supplémentaire qui nous dit qu'il existe un raccourci pour l'écrire.
J'aime penser les littéraux comme des hiéroglyphes égyptiens plutôt que d'enchaîner des caractères d'un alphabet pour exprimer un concept.