Tipi di Riferimento ECMAScript

I tipi di riferimento sono solitamente chiamati classi (class).

Questo tutorial discuterà una vasta gamma di tipi di riferimento predefiniti di ECMAScript.

Tipi di riferimento

I tipi di riferimento sono solitamente chiamati classi (class), il che significa che, quando si gestisce un valore di riferimento, si sta lavorando con un oggetto.

Questo tutorial discuterà una vasta gamma di tipi di riferimento predefiniti di ECMAScript.

Da ora in poi, discuteremo principalmente i tipi di riferimento strettamente correlati ai tipi primitivi già discussi.

Attenzione:In senso tradizionale, ECMAScript non ha veramente classi. In realtà, oltre a indicare l'assenza di classi, la parola 'classe' non compare affatto nel ECMA-262. ECMAScript definisce 'definizione oggetto', logicamente equivalente alle classi di altri linguaggi di programmazione.

Suggerimento:Questo tutorial utilizzerà il termine "oggetto".

Gli oggetti vengono creati utilizzando l'operatore new e il nome dell'oggetto da istanziare. Ad esempio, il seguente codice crea un'istanza dell'oggetto Object:

var o = new Object();

Questo sintassi è simile al linguaggio Java, ma ECMAScript richiede l'uso di parentesi quando ci sono più parametri. Se non ci sono parametri, come nel codice seguente, i parentesi possono essere omessi:

var o = new Object;

Attenzione:Nonostante i parentesi non siano obbligatori, è meglio usarli per evitare confusione.

Suggerimento:Esploreremo più a fondo gli oggetti e il loro comportamento nel capitolo di base sugli oggetti.

Questo capitolo si concentra sui tipi di riferimento che hanno tipi primitivi equivalenti.

Oggetto Object

L'oggetto Object è utile di per sé, ma è sempre consigliabile conoscerlo prima di comprendere altre classi. Poiché l'oggetto Object in ECMAScript è simile a java.lang.Object in Java, tutti gli oggetti in ECMAScript derivano da questo oggetto, e tutte le proprietà e i metodi dell'oggetto Object appariranno negli altri oggetti, quindi comprendere l'oggetto Object aiuta a comprendere meglio gli altri oggetti.

L'oggetto Object ha le seguenti proprietà:

constructor
Riferimento alla funzione che ha creato l'oggetto (puntatore). Per l'oggetto Object, questo puntatore punta alla funzione originale Object().
Prototype
Riferimento all'oggetto prototipo dell'oggetto. Per tutti gli oggetti, restituisce per default un'istanza dell'oggetto Object.

L'oggetto Object ha anche alcuni metodi:

hasOwnProperty(property)
Determina se l'oggetto ha un attributo specifico. Deve essere specificato come stringa l'attributo (ad esempio, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Determina se l'oggetto è il prototipo di un altro oggetto.
PropertyIsEnumerable
Determina se l'attributo specificato può essere enumerato con la语句 for...in.
ToString()
Restituisce la rappresentazione in stringa originale dell'oggetto. Per l'oggetto Object, ECMA-262 non definisce questo valore, quindi diversi implementazioni ECMAScript possono avere valori diversi.
ValueOf()
Restituisce il valore originale più adatto per l'oggetto. Per molti oggetti, il valore restituito da questo metodo è lo stesso del valore restituito da ToString().

Commento:Ogni proprietà e metodo elencato sopra sarà sovrascritto da altri oggetti.

Oggetto Boolean

L'oggetto Boolean è un tipo di riferimento del tipo Boolean originale.

Per creare un oggetto Boolean, è sufficiente passare un valore Boolean come parametro:

var oBooleanObject = new Boolean(true);

L'oggetto Boolean sovrascrive il metodo ValueOf() dell'oggetto Object, restituendo il valore originale, ossia true e false. Il metodo ToString() viene anche sovrascritto, restituendo la stringa "true" o "false".

Purtroppo, gli oggetti Boolean non vengono utilizzati spesso in ECMAScript, e anche se vengono utilizzati, sono difficili da comprendere.

I problemi si verificano spesso quando si utilizza l'oggetto Boolean in un'espressione Booleana. Ad esempio:

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true;	// Output true

In questo pezzo di codice, viene creato un oggetto Boolean con il valore false. Poi questo valore viene eseguito un'operazione AND con il valore originale true. Il risultato dell'operazione AND tra false e true nel calcolo Booleano è false. Tuttavia, in questa riga di codice, viene calcolato oFalseObject, non il suo valore false.

Come discusso in precedenza, in un'espressione Booleana, tutti gli oggetti vengono automaticamente convertiti in true, quindi il valore di oFalseObject è true. Poi true viene eseguito un'operazione AND con true, il risultato è true.

Attenzione:Anche se dovresti conoscere la disponibilità dell'oggetto Boolean, è meglio utilizzare i valori originali Boolean, per evitare i problemi menzionati in questa sezione.

See

Per ulteriori informazioni sull'oggetto Boolean, visita Manuale di riferimento dell'oggetto Boolean JavaScript.

Oggetto Number

Come potresti immaginare, l'oggetto Number è un tipo di riferimento del tipo Number originale. Per creare un oggetto Number, utilizzare il seguente codice:

var oNumberObject = new Number(68);

Dovresti aver riconosciuto l'oggetto Number menzionato nella sezione precedente di questo capitolo, quando si ha discusso sui valori speciali (come Number.MAX_VALUE). Tutti i valori speciali sono attributi statici dell'oggetto Number.

Per ottenere il valore originale di Number dell'oggetto numerico, è sufficiente utilizzare il metodo valueOf():

var iNumber = oNumberObject.valueOf();

Certo, la classe Number ha anche il metodo toString(), che è stato discusso in dettaglio nella sezione sulla conversione di tipo.

Oltre ai metodi standard ereditati dall'oggetto Object, l'oggetto Number ha anche alcuni metodi专用 per il trattamento dei numeri.

Il metodo toFixed()

Il metodo toFixed() restituisce la rappresentazione in stringa di un numero con un numero specifico di cifre decimali. Ad esempio:

var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  // Output: "68.00"

In questo caso, il parametro del metodo toFixed() è 2, il che significa che devono essere visualizzati due decimali. Questo metodo restituisce "68.00", i caratteri di stringa vuoti vengono riempiti con 0. Questo metodo è molto utile per applicazioni che trattano denaro. Il metodo toFixed() può rappresentare numeri con da 0 a 20 cifre decimali, i valori oltre questo intervallo causano un errore.

Il metodo toExponential()

Un altro metodo correlato alla formattazione dei numeri è toExponential(), che restituisce la rappresentazione in stringa del numero in notazione scientifica.

Simile al metodo toFixed(), il metodo toExponential() ha anche un parametro che specifica il numero di cifre decimali da output. Ad esempio:

var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  // Output: "6.8e+1"

Il risultato di questo codice è "6.8e+1", come spiegato in precedenza, rappresenta 6.8x101. Il problema è, cosa fare se non si sa in quale forma (forma predefinita o forma esponenziale) rappresentare il numero? Puoi usare il metodo toPrecision().

Il metodo toPrecision()

Il metodo toPrecision() restituisce la forma predefinita o la forma esponenziale del numero in base alla forma più significativa. Ha un parametro, ovvero il numero totale di cifre utilizzate per rappresentare il numero (escluso l'esponente). Ad esempio,

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  // Output: "7e+1"

Il compito di questo codice è rappresentare il numero 68 con un singolo numero, il risultato è "7e+1", rappresentato in un altro modo è 70. Certamente, il metodo toPrecision() arrotonda i numeri. Ma se si rappresenta il numero 68 con 2 cifre, è molto più facile:

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  // Output: "68"

Certo, l'output è "68", perché è esattamente la rappresentazione corretta di quel numero. Ma cosa succede se il numero di cifre specificato è maggiore di quello necessario?

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  // output "68.0"

In this case, toPrecision(3) is equivalent to toFixed(1), and the output is "68.0".

The toFixed(), toExponential(), and toPrecision() methods all perform rounding operations to correctly represent a number with the correct number of decimal places.

Suggerimento:Similar to the Boolean object, the Number object is also very important, but it should be used less to avoid potential problems. As far as possible, use the primitive representation of numbers.

See

For more information about the Number object, please visit Manuale di riferimento dell'oggetto Number JavaScript.

String object

The String object is the object representation of the String primitive type, which is created in the following way:

var oStringObject = new String("hello world");

Both the valueOf() and toString() methods of the String object return the original value of the String type:

alert(oStringObject.valueOf() == oStringObject.toString());	// output "true"

If this code is run, the output is "true", indicating that these values are indeed equal.

Commento:The String object is one of the more complex reference types in ECMAScript. Similarly, the focus of this section is only on the basic functions of the String class. For more advanced features, please read the relevant sections of this tutorial or refer to Manuale di riferimento dell'oggetto String JavaScript.

length property

The String object has a property called length, which is the number of characters in the string:

var oStringObject = new String("hello world");
alert(oStringObject.length);	// output "11"

This example outputs "11", which is the number of characters in "hello world". Note that even if the string contains double-byte characters (relative to ASCII characters, which only occupy one byte), each character is counted as one character.

charAt() and charCodeAt() methods

The String object also has a large number of methods.

Firstly, both the charAt() and charCodeAt() methods access a single character in a string. Both methods have a parameter, which is the position of the character to be operated on.

The charAt() method returns a string containing the character at the specified position:

var oStringObject = new String("hello world");
alert(oStringObject.charAt(1));	// output "e"

Nel testo "hello world", il carattere alla posizione 1 è "e". Nella sezione "Tipi originali ECMAScript", abbiamo spiegato che la posizione del primo carattere è 0, la posizione del secondo carattere è 1, e così via. Quindi, la chiamata a charAt(1) restituisce "e".

Se si desidera ottenere non il carattere, ma il codice del carattere, si può chiamare il metodo charCodeAt():

var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1));	// Output: "101"

Questo esempio stampa "101", che è il codice del carattere minuscolo "e".

concat() method

Ecco il metodo concat(), utilizzato per aggiungere uno o più stringhe al valore originale di un oggetto String. Questo metodo restituisce il valore originale di String, mantenendo l'oggetto String originale invariato:

var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
alert(sResult);		// Output: "hello world"
alert(oStringObject);	// Output: "hello "

In questo pezzo di codice, il risultato della chiamata al metodo concat() è "hello world", mentre l'oggetto String rimane "hello ". Per questo motivo, è più comune usare il segno più (+) per connettere stringhe, poiché questo formato indica logicamente il comportamento reale:

var oStringObject = new String("hello ");
var sResult = oStringObject + "world";
alert(sResult);		// Output: "hello world"
alert(oStringObject);	// Output: "hello "

indexOf() and lastIndexOf() methods

Fino ad ora, sono stati discussi i metodi per connettere stringhe, e i metodi per accedere a un singolo carattere all'interno di una stringa. Tuttavia, se non si è sicuri che un carattere esista effettivamente in una stringa, quale metodo si dovrebbe chiamare? In questo caso, si può chiamare indexOf() e lastIndexOf() method.

Both indexOf() and lastIndexOf() methods return the position of the specified substring within another string, or -1 if the substring is not found.

Le differenze tra questi metodi sono che indexOf() parte dalla fine della stringa (posizione 0) per cercare la stringa, mentre lastIndexOf() parte dalla fine della stringa per cercare la sottostringa. Ad esempio:

var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o"));		// Output: "4"
alert(oStringObject.lastIndexOf("o"));		// Output: "7"

In questo caso, la prima occorrenza della stringa "o" si trova alla posizione 4, ovvero "hello" contiene "o"; l'ultima occorrenza della stringa "o" si trova alla posizione 7, ovvero "world" contiene "o". Se la stringa contiene solo una occorrenza della stringa "o", allora le posizioni restituite dai metodi indexOf() e lastIndexOf() sono le stesse.

Metodo localeCompare()

Il seguente metodo è localeCompare(), che serve per ordinare le stringhe. Questo metodo ha un parametro - la stringa da confrontare, e restituisce uno dei tre valori seguenti:

  • Se l'oggetto String è ordinato in ordine alfabetico prima della stringa specificata come parametro, viene restituito un numero negativo.
  • Se l'oggetto String è uguale alla stringa specificata come parametro, viene restituito 0
  • Se l'oggetto String è ordinato in ordine alfabetico dopo la stringa specificata come parametro, viene restituito un numero positivo.

Commento:Se il valore restituito è negativo, il più comune è -1, ma il valore effettivo è determinato dall'implementazione. Se il valore restituito è positivo, allo stesso modo, il più comune è 1, ma il valore effettivo è determinato dall'implementazione.

Ecco un esempio:

var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick"));		// Output: "1"
alert(oStringObject.localeCompare("yellow"));		// Output: "0"
alert(oStringObject.localeCompare("zoo"));		// Output: "-1"

In questo pezzo di codice, la stringa "yellow" è stata confrontata con 3 valori, ovvero "brick", "yellow" e "zoo". Poiché sono ordinati in ordine alfabetico, "yellow" è dopo "brick", quindi localeCompare() restituisce 1; "yellow" è uguale a "yellow", quindi localeCompare() restituisce 0; "zoo" è dopo "yellow", localeCompare() restituisce -1. Ribadisco, poiché il valore restituito è determinato dall'implementazione, è meglio chiamare il metodo localeCompare() nel modo seguente:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " viene prima di " + oStringObject2);
}
  alert(oStringObject1 + " viene dopo " + oStringObject2);
}
  alert("Le due stringhe sono uguali");
}

Adottando questa struttura, si può garantire che questo codice funzioni correttamente in tutte le implementazioni.

La particolarità della metodo localeCompare() sta nel fatto che la regione (locale, che si riferisce sia alla nazione/regione che alla lingua) in cui viene implementato specifica esattamente il modo in cui questo metodo viene eseguito. Negli Stati Uniti, l'inglese è la lingua standard dell'implementazione ECMAScript, localeCompare() è sensibile alle maiuscole, con le lettere maiuscole che si trovano dopo le lettere minuscole nell'ordine alfabetico. Tuttavia, in altre regioni, la situazione potrebbe non essere la stessa.

slice() e substring()

ECMAScript fornisce due metodi per creare valori di stringa da una sottostringa, ovvero slice() e substring(). Entrambi i metodi restituiscono una sottostringa della stringa da trattare e accettano un numero o due parametri. Il primo parametro è la posizione di partenza della sottostringa da ottenere, il secondo parametro (se utilizzato) è la posizione di terminazione della sottostringa (cioè, il carattere alla posizione di terminazione non è incluso nel valore restituito). Se si omette il secondo parametro, la posizione di terminazione è impostata come la lunghezza della stringa.

Come concat(), sia slice() che substring() non modificano il valore dell'oggetto String. Ritornano solo il valore originale della String, mantenendo l'oggetto String invariato.

var oStringObject = new String("hello world");
alert(oStringObject.slice("3")); // Output: "lo world"
alert(oStringObject.substring("3")); // Output: "lo world"
alert(oStringObject.slice("3", "7")); // Output: "lo w"
alert(oStringObject.substring("3", "7")); // Output: "lo w"

In questo esempio, l'uso di slice() e substring() è lo stesso e anche i valori di ritorno sono identici. Quando c'è solo un parametro 3, entrambi i metodi restituiscono "lo world", perché il secondo "l" in "hello" si trova alla posizione 3. Quando ci sono due parametri "3" e "7", entrambi i metodi restituiscono "lo w" (l'lettera "o" nella parola "world" si trova alla posizione 7, quindi non è inclusa nel risultato).

Perché ci sono due metodi con funzionalità completamente identiche? In realtà, questi due metodi non sono completamente identici, ma differiscono solo nel modo in cui trattano i parametri negativi.

Per parametri negativi, il metodo slice() aggiunge il parametro alla lunghezza della stringa, mentre il metodo substring() lo tratta come 0 (cioè lo ignora). Ad esempio:

var oStringObject = new String("hello world");
alert(oStringObject.slice("-3")); // Output: "rld"
alert(oStringObject.substring("-3")); // Output: "hello world"
alert(oStringObject.slice("3, -4")); // Output: "lo w"
alert(oStringObject.substring("3, -4")); // Output: "hel"

In questo modo si può vedere la principale differenza tra i metodi slice() e substring().

Quando si utilizza solo il parametro -3, slice() restituisce "rld", mentre substring() restituisce "hello world". Questo perché per la stringa "hello world", slice("-3") viene convertito in slice("8"), mentre substring("-3") viene convertito in substring("0").

Anche quando si utilizzano i parametri 3 e -4, la differenza è evidente. slice() viene convertito in slice(3, 7), come nell'esempio precedente, restituendo "lo w". Mentre la funzione substring() interpreta i due parametri come substring(3, 0), che è sostanzialmente substring(0, 3), poiché substring() considera sempre il numero più piccolo come posizione di inizio e il numero più grande come posizione di fine. Pertanto, substring("3, -4") restituisce "hel". L'ultima riga di codice è utilizzata per illustrare come utilizzare questi metodi.

toLowerCase(), toLocaleLowerCase(), toUpperCase() e toLocaleUpperCase()

L'ultima serie di metodi da discutere riguarda la conversione di maiuscole e minuscole. Ci sono 4 metodi per eseguire la conversione di maiuscole e minuscole, ovvero

  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

Come suggerisce il nome, le prime due funzioni vengono utilizzate per convertire una stringa in minuscolo, mentre le ultime due funzioni vengono utilizzate per convertire una stringa in maiuscolo.

Le funzioni toLowerCase() e toUpperCase() sono originali e sono implementate come prototipi delle stesse funzioni in java.lang.String.

La funzione toLocaleLowerCase() e toLocaleUpperCase() sono implementate in base a una regione specifica (come la funzione localeCompare()). In molte regioni, i metodi specifici per la regione sono identici ai metodi generici. Tuttavia, alcune lingue applicano regole specifiche per la conversione di maiuscole e minuscole Unicode (ad esempio, il turco), quindi è necessario utilizzare i metodi specifici per la regione per effettuare la conversione corretta.

var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());	// output "HELLO WORLD"
alert(oStringObject.toUpperCase());		// output "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase());	// output "hello world"
alert(oStringObject.toLowerCase()); // Output "hello world"

In questo codice, toUpperCase() e toLocaleUpperCase() restituiscono entrambi "HELLO WORLD", mentre toLowerCase() e toLocaleLowerCase() restituiscono entrambi "hello world". Di solito, se non si conosce il codice di encoding con cui viene eseguito un linguaggio, è più sicuro utilizzare i metodi specifici della regione.

Suggerimento:Ricorda, tutte le proprietà e i metodi dell'oggetto String possono essere applicati ai valori String originali, poiché sono pseudo-oggetti.

Operatore instanceof

Quando si utilizza l'operatore typeof con tipi di riferimento, si verifica un problema, poiché indipendentemente dal tipo di oggetto di cui si fa riferimento, restituisce sempre "object". ECMAScript ha introdotto un altro operatore Java, instanceof, per risolvere questo problema.

L'operatore instanceof è simile all'operatore typeof, utilizzato per identificare il tipo dell'oggetto in trattamento. A differenza del metodo typeof, l'operatore instanceof richiede che lo sviluppatore confermi esplicitamente che l'oggetto è di un tipo specifico. Ad esempio:

var oStringObject = new String("hello world");
alert(oStringObject instanceof String); // Output "true"

Questo codice chiede se "l'oggetto oStringObject è un'istanza dell'oggetto String?" oStringObject è effettivamente un'istanza dell'oggetto String, quindi il risultato è "true". Nonostante non sia altrettanto flessibile come il metodo typeof, l'operatore instanceof è molto utile quando il metodo typeof restituisce "object".