Qual è la differenza tra oggetti nativi e oggetti host?

Quest’ultimo si riferisce semplicemente agli oggetti funzione non primitivi che sono stati creati da un costruttore personalizzato (ad es. Var bird1 = new Bird ();)?

Entrambi i termini sono definiti nelle specifiche ECMAScript:

object nativo

object in un’implementazione ECMAScript la cui semantica è completamente definita da questa specifica piuttosto che dall’ambiente host.

NOTA Gli oggetti nativi standard sono definiti in questa specifica. Alcuni oggetti nativi sono integrati; altri possono essere costruiti durante l’esecuzione di un programma ECMAScript.

Fonte: http://es5.github.com/#x4.3.6

object host

object fornito dall’ambiente host per completare l’ambiente di esecuzione di ECMAScript.

NOTA Qualsiasi object che non sia nativo è un object host.

Fonte: http://es5.github.com/#x4.3.8


Alcuni esempi:

Oggetti nativi: Object (costruttore), Date , Math , parseInt , eval , metodi stringa come indexOf e replace , metodi array, …

Oggetti host (presupponendo l’ambiente del browser): window , document , location , history , XMLHttpRequest , setTimeout , getElementsByTagName , querySelectorAll , …

È più chiaro se distinguiamo tra tre tipi di oggetti:

Oggetti integrati : String , Math , RegExp , Object , Function ecc. – oggetti predefiniti di base sempre disponibili in JavaScript. Definito nella specifica ECMAScript.

Oggetti host : oggetti come window , XmlHttpRequest , nodes DOM e così via, forniti dall’ambiente browser. Sono distinti dagli oggetti built-in perché non tutti gli ambienti avranno gli stessi oggetti host. Se JavaScript viene eseguito all’esterno del browser, ad esempio come linguaggio di scripting lato server come in Node.js, saranno disponibili diversi oggetti host.

Oggetti utente : oggetti definiti nel codice JavaScript. Quindi “Bird” nel tuo esempio sarebbe un object utente.

La specifica JavaScript raggruppa oggetti e oggetti utente integrati come oggetti nativi . Questo è un uso non ortodosso del termine “nativo”, dal momento che gli oggetti utente sono ovviamente implementati in JavaScript mentre i built-in sono molto probabilmente implementati in una lingua diversa, proprio come gli oggetti host. Ma dal punto di vista della specifica JavaScript, sia i builtin che gli oggetti utente sono nativi di JavaScript perché sono definiti nelle specifiche JavaScript, mentre gli oggetti host non lo sono.

Ecco la mia comprensione delle specifiche.

Questo:

 var bird = new Bird(); 

… genera un object nativo che è semplicemente stato creato utilizzando il new operatore.

Gli oggetti nativi hanno una proprietà interna [[Classe]] di uno dei seguenti:

“Arguments”, “Array”, “Boolean”, “Date”, “Error”, “Function”, “JSON”, “Math”, “Number”, “Object”, “RegExp” e “String” .

Per il tuo bird1 sarà:

“Oggetto”

Proprio come se si crea una funzione:

 function my_func() { // ... } 

my_func non è definito in ECMAScript, ma è ancora un object nativo con la [[Class]] interna:

“Funzione”

Un object host è un object fornito dall’ambiente per servire uno scopo specifico per quell’ambiente non definito dalla specifica.

Per esempio:

 var divs = document.getElementsByTagName('div') 

L’object a cui fa riferimento divs è un NodeList , che è integrato nell’ambiente in modo tale da sembrare un normale object JavaScript, eppure non è definito da nessuna parte in base alle specifiche.

La sua proprietà interna [[Classe]] è:

“NodeList”

Ciò fornisce ai progettisti di implementazione una certa flessibilità nel soddisfare l’implementazione in base alle esigenze specifiche dell’ambiente.

Esistono requisiti degli oggetti host definiti in tutte le specifiche.

Non ho potuto vedere una risposta convincente alla domanda se var bird1 = new Bird(); è un object nativo o host. Supponendo che Bird sia una funzione definita dall’utente, verrà creato un object nativo non incorporato secondo http://es5.github.io/#x13.2 dall’implementazione di javascript. Al contrario, gli oggetti nativi built-in saranno presenti dall’inizio di un programma javascript (come Object e molti altri). Una differenza tra un object nativo e un object host è che il primo è creato dall’implementazione di javascript e il secondo è fornito dall’ambiente host. Di conseguenza, la proprietà interna dell’object [[class]] dell’object host può essere diversa da quelle utilizzate dagli oggetti built-in (ad es. “Arguments”, “Array”, “Boolean”, “Date”, “Error”, “Function”, ” JSON “,” Math “,” Number “,” Object “,” RegExp “e” String “).

Inoltre, vale la pena notare che ECMA6 http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf non utilizza più la terminologia nativa e gli oggetti host. Invece, definisce sotto i tipi di object, con spiegazioni più chiare del loro comportamento previsto.

4.3.6 object ordinario

object che ha il comportamento predefinito per i metodi interni essenziali che devono essere supportati da tutti gli oggetti

4.3.7 object esotico

object che non ha il comportamento predefinito per uno o più dei metodi interni essenziali che devono essere supportati da tutti gli oggetti. NOTA Qualsiasi object che non sia un object ordinario è un object esotico.

4.3.8 object standard

object la cui semantica è definita da questa specifica

4.3.9 object incorporato

object specificato e fornito da un’implementazione ECMAScript

Oltre alle altre risposte riguardanti gli oggetti host.

Gli oggetti host sono specifici per un ambiente. Quindi, accanto agli oggetti host del browser, ci sono anche oggetti specifici su nodejs.

Per l’esempio, iniziamo prima con gli oggetti Standard come definiti in Javascript. Quindi gli oggetti comuni per il browser / DOM. Il nodo ha i propri oggetti.

  1. Esempi di oggetti incorporati standard Javascript :

    • Oggetto
    • Funzione
    • booleano
    • Simbolo
    • Numero
    • Matematica
    • … ( vedi l’elenco completo su MDN web docs )
  2. Esempi di oggetti modello documento oggetti host:

    • Finestra
    • Documento
    • Storia
    • … ( vedi l’elenco completo degli oggetti DOM su MDN web docs )
    • XMLHttpRequest (parte dell’API Web)
    • … ( consulta l’elenco completo delle API Web sui documenti Web MDN )
  3. Oggetti host in Node.js :

    • http
    • https
    • fs
    • url
    • os
    • … ( Vedi la lista completa su nodejs.org )

Considerando tre oggetti: Host, Nativo, Personalizzato.

Gli oggetti host sono creati dall’ambiente e sono specifici dell’ambiente. Il miglior ambiente conosciuto sarebbe un browser web ma potrebbe essere un’altra piattaforma. Gli oggetti host creati nel browser Web potrebbero essere l’object finestra o il documento. In genere un browser utilizza un’API per creare oggetti host in modo da riflettere il modello di object documento in JavaScript. (I web browser hanno diversi motori JavaScript che lo fanno) Un object host viene creato automaticamente nel momento in cui la pagina viene visualizzata in un browser.

Un object nativo viene creato dallo sviluppatore utilizzando classi predefinite di JavaScript. Gli oggetti nativi sono nella tua sceneggiatura scritta.

Di conseguenza, un object personalizzato viene creato dallo sviluppatore da una class personalizzata (non predefinita o parzialmente predefinita).

Gli oggetti nativi sono oggetti che aderiscono alle specifiche, cioè “oggetti standard”.

Gli oggetti host sono oggetti che il browser (o altro ambiente di runtime come Node) fornisce.

La maggior parte degli oggetti host sono oggetti nativi e ogni volta che si crea un’istanza usando new , si può essere sicuri al 99,99% che si tratta di un object nativo, a meno che non si scherzi con oggetti host strani.

Questa nozione è stata introdotta a causa della presenza di oggetti molto bizzarri in IE (e altri vecchi browser?) . Per esempio:

 typeof document.all == "undefined"; // true document.all.myElementId; // object 

Vedendo questo, tutti sarebbero d’accordo che document.all è chiaramente “non standard”, e quindi un object host non nativo .

Quindi, perché non chiamare gli oggetti nativi oggetti standard in primo luogo? Semplice: dopotutto, il documento Standard (!) Parla anche di oggetti non nativi, e chiamarli non standard porterebbe a un paradosso.

Ancora:

  • nativo == “standard”
  • host == fornito dal browser o dal nodo o …
  • la maggior parte degli oggetti host sono nativi e anche tutti gli oggetti non host sono nativi

Questo può essere eccessivo, ma per semplicità un object nativo esiste ed è utilizzabile in qualsiasi ambiente che implementa un motore compatibile con ECMAScript. Questo è solitamente (ma non sempre) un browser.

Quindi, il tuo Internet Explorer o il tuo Google Chrome, non rende l’object String a tua disposizione, ad esempio. Il motivo per cui è ansible utilizzare l’object String è perché è “nativo” (incorporato) al linguaggio JavaScript stesso.

Tuttavia, se desideri creare una finestra popup, devi utilizzare l’object finestra. L’object window è fornito dal software del browser stesso, quindi non è nativo di JavaScript, ma fa parte del “Browser Object Model” o del BOM.