Cosa significa la parola “letterale”?

Che cosa significa la parola “letterale” quando viene utilizzata in un contesto come stringhe letterali e valori letterali?

Qual è la differenza tra un valore letterale e un valore?

Un letterale è “qualsiasi notazione per rappresentare un valore all’interno del codice sorgente” ( wikipedia )

(Contrasto con identificatori , che si riferiscono a un valore in memoria.)

Esempi:

  • "hey" (una stringa)
  • false (un booleano)
  • 3.14 (un numero reale)
  • [1,2,3] (una lista di numeri)
  • (x) => x*x (una funzione)
  • /^1?$|^(11+?)\1+$/ (un’espressione regolare)

Alcune cose che non sono letterali:

  • std::cout (un identificatore)
  • foo = 0; (una dichiarazione)
  • 1+2 (un’espressione)

Un valore letterale è un valore che è stato codificato direttamente nella fonte.

Per esempio:

 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 

Alcuni letterali possono avere una syntax speciale, quindi sai qual è il letterale:

 //The 'M' in 10000000M means this is a decimal value, rather than int or double. var accountBalance = 10000000M; 

Ciò che li distingue dalle variabili o risorse è che il compilatore può trattarli come costanti o eseguire determinate ottimizzazioni con il codice in cui vengono utilizzati, perché è certo che non cambieranno.

Un letterale è un assegnamento a un valore esplicito, come ad esempio

 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: Come sottolineato, l’assegnazione stessa non ha nulla a che fare con la definizione di un letterale, stavo usando assegnamento nel mio esempio, ma un letterale può anche essere passato in un metodo, ecc.

Nella programmazione, un valore scritto esattamente come deve essere interpretato. Al contrario, una variabile è un nome che può rappresentare diversi valori durante l’esecuzione del programma. E una costante è un nome che rappresenta lo stesso valore in tutto un programma. Ma un letterale non è un nome: è il valore stesso.

Un letterale può essere un numero, un carattere o una stringa. Ad esempio, nell’espressione,

x = 3

x è una variabile e 3 è un valore letterale.

Un valore letterale è quando si include il valore nel codice sorgente (anziché il riferimento a una variabile oa una costante). Per esempio:

 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) 

Se il letterale rappresenta una certa quantità, come una costante fisica, è meglio dargli un nome invece di scrivere lo stesso letterale ovunque ne abbiate bisogno. In questo modo, quando stai leggendo il codice sorgente, sai cosa significa il numero, che di solito è più importante del suo valore (che potrebbe comunque cambiare).

 const int maxUsers = 100; const double gravitationalAcceleration = 9.8; 

Generalmente, gli unici valori letterali numerici che uso (oltre a inizializzare le costanti come sopra) sono 0 o 1, e talvolta 2 se sto saltando ogni altro elemento in un ciclo. Se il significato del numero è più importante del suo valore reale (di solito lo è), è meglio chiamarlo.

Un valore letterale è un valore, ma un valore potrebbe anche essere memorizzato in una variabile. Nella dichiarazione

 string str = "string literal"; 

c’è una variabile stringa (str) e una stringa letterale. Dopo l’esecuzione dell’istruzione entrambi hanno lo stesso valore.

Siate consapevoli che in molte lingue la variabile e il valore letterale non devono necessariamente essere dello stesso tipo. Per esempio:

 int a = 1.0; 

Il valore letterale sopra riportato è un tipo a virgola mobile. Il valore verrà forzato dal compilatore per adattarsi alla variabile int.

Per un altro esempio, nella prima riga del codice C ++ sopra il tipo di stringa letterale non è affatto la string tipo di libreria. Per mantenere la retrocompatibilità con C, i letterali stringa in C ++ sono array di caratteri.

Esempio veloce:

int my_int_var = 723;

723 – Questo set di caratteri si riferisce a un valore intero letterale .

my_int_var – Questo set di caratteri fa riferimento a un valore intero variabile .

Un letterale è quando lo inserisci nel codice. Quindi una stringa letterale è

 string s = "SomeText"; 

Questo è in contrasto con la costruzione della stringa, o prenderlo come parametro.

Generalmente quando qualcuno usa la parola letterale significa che il valore è decifrabile dal codice (testo) come mostrato in molti degli esempi in altri post.

Un altro utilizzo comune è per i valori che vengono convertiti in valori immediati in assembly. Questi sono valori che vengono inseriti direttamente nell’istruzione della macchina anziché richiedere i carichi di registro.

Ho sentito delle stringhe letterali usate casualmente per riferirsi a ciò a cui le specifiche C # si riferiscono effettivamente come letterali stringa letterali. Un letterale stringa regolare consente l’escape di determinati caratteri (preceduti da a), come \ t per una scheda. Un letterale stringa letterale è preceduto da @ ed elaborato letteralmente, \ non ha alcun significato speciale.

 //regular string regular = "\thello world"; //verbatim string verbatim = @"C:\"; //the regular equivalent of this would be "C:\\" 

Un letterale è “rappresentazione del codice sorgente dei dati”.

I letterali sono notazioni abbreviate per valori in certi tipi che la lingua considera così importanti o fondamentali che ha dedicato lo zucchero di syntax solo per loro.

Esempio di tipi i cui valori sono spesso rappresentati da valori letterali:

 Boolean = { true, false } Integer = { ..., -2, -1, 0, 1, 2, ... } Character = { 'a', 'b', ... } String = { "hello", "world", ... } 

Alcune lingue hanno letterali anche per i tipi di funzione:

 Integer -> Integer = { (x: Integer) => x + 2), (x: Integer) => x/2, ...} 

Un esempio di valori che di solito non sono rappresentati con valori letterali sarebbero valori di tipi di classi:

 Car(brand: String, seats: Integer) = { Car("BMW", 5), Car("Ferrari", 2), ...} 

Qui il valore Car("BMW", 5) nel tipo Car è infatti indicato in modo univoco utilizzando una sequenza di simboli, tuttavia, il valore non è rappresentato utilizzando un letterale abbreviato dedicato, ma utilizza invece meccanismi nozionali generali (verbosi) per denotare valori di qualsiasi tipo di class.

Il termine letterale è sinonimo di valore , istanza , costante , membro ed elemento di un tipo, ma porta un po ‘di significato in più che ci dice che esiste una scorciatoia per scriverlo.

Mi piace pensare ai letterali come ai geroglifici egiziani anziché mettere insieme i caratteri di un alfabeto per esprimere un concetto.