Quelle est la différence entre les objets natifs et les objets hôtes?

90

Ce dernier se réfère-t-il simplement à des objets de fonction non primitifs créés par un constructeur personnalisé (par exemple, var bird1 = new Bird ();)?

javascript 
— ppecher
source
2
Les objets natifs sont définis dans la spécification ECMAScript, les objets hôtes ne le sont pas.
— Šime Vidas
6
Un élément DOM - disons, new Image()- est un objet hôte, par exemple.
@ ŠimeVidas: Y a-t-il une raison pour laquelle vous avez laissé un commentaire qui contredit votre réponse?
— user113716
@ Ӫ _._ Ӫ C'est mon truc maintenant:)
— Šime Vidas
1
@ ŠimeVidas: votre commentaire indique que les objets hôtes ne sont pas définis dans la spécification ECMAScript . Votre réponse indique "Les définitions pour les deux sont dans la spécification ECMAScript" .
— user113716

Réponses:

133

Les deux termes sont définis dans la spécification ECMAScript:

objet natif

objet dans une implémentation ECMAScript dont la sémantique est entièrement définie par cette spécification plutôt que par l'environnement hôte.

REMARQUE Les objets natifs standard sont définis dans cette spécification. Certains objets natifs sont intégrés; d'autres peuvent être construits au cours de l'exécution d'un programme ECMAScript.

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

objet hôte

objet fourni par l'environnement hôte pour compléter l'environnement d'exécution d'ECMAScript.

REMARQUE Tout objet qui n'est pas natif est un objet hôte.

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

Quelques exemples:

Objets natifs: Object(constructeur), Date, Math, parseInt, eval, les méthodes de chaînes comme indexOfet replace, les méthodes de tableau, ...

Objets d'accueil ( en supposant l' environnement du navigateur): window, document, location, history, XMLHttpRequest, setTimeout, getElementsByTagName, querySelectorAll, ...

— Šime Vidas
source
8
donnez-lui aussi quelques exemples, objet natif: Array, String .., objet hôte: fenêtre ...
— Poelinca Dorin
1
qu'en est-il d'un custructor personnalisé? par exemple, l'exemple d'oiseau dans mon post
— ppecher
2
@ ŠimeVidas: "Alors c'est un objet hôte." Ce n'est pas correct. Voir la définition de host objectdécrit dans cette réponse .
— user113716
1
ŠimeVidas: Mais la spécification indique 'La valeur de la propriété interne [[Class]] d'un objet hôte peut être n'importe quelle valeur String à l' exception de l' une des valeurs "Arguments", "Array", "Boolean", "Date", "Error", "Function", "JSON", "Math", "Number", "Object" , "RegExp" et "String". ' La propriété interne [[classe]] de votre objet d' oiseau sera 'Object'ou présenté par Object.prototype.toStringcomme '[object Object]'.
— user113716
2
@ ŠimeVidas, je ne suis pas d'accord, s'il Birds'agit d'une fonction définie par l'utilisateur, sa sémantique est "entièrement définie" par la spécification ES (comment fonctionnent les objets de fonction, comment ils sont créés, exécutés, utilisés avec l' newopérateur, etc., etc., etc.) c'est un objet natif ... je pourrais laisser tomber une réponse ...
— Christian C. Salvadó
28

C'est plus clair si l'on distingue trois types d'objets:

Objets intégrés : String, Math, RegExp, Object, Functionetc. - objets prédéfinis de base toujours disponibles en JavaScript. Défini dans la spécification ECMAScript.

Objets hôtes : objets comme window, XmlHttpRequest, noeuds DOM et ainsi de suite, qui est fourni par l'environnement du navigateur. Ils sont distincts des objets intégrés car tous les environnements n'auront pas les mêmes objets hôtes. Si JavaScript s'exécute en dehors du navigateur, par exemple en tant que langage de script côté serveur comme dans Node.js, différents objets hôtes seront disponibles.

Objets utilisateur : objets définis dans le code JavaScript. Ainsi, «Bird» dans votre exemple serait un objet utilisateur.

La spécification JavaScript regroupe les objets intégrés et les objets utilisateur en tant qu'objets natifs . Il s'agit d'une utilisation peu orthodoxe du terme «natif», car les objets utilisateur sont évidemment implémentés en JavaScript alors que les éléments intégrés sont très probablement implémentés dans un langage différent sous le capot, tout comme le seraient les objets hôtes. Mais du point de vue de la spécification JavaScript, les objets intégrés et utilisateur sont natifs de JavaScript car ils sont définis dans la spécification JavaScript, contrairement aux objets hôtes.

— JacquesB
source
Les objets natifs font référence aux objets créés par l'implémentation javascript (moteur). La différence entre les objets intégrés et les autres objets natifs (objets utilisateur) est que d'anciens objets sont présents depuis le démarrage du programme javascript conforme aux règles ECMA pertinentes. Depuis ECMA6 (<ECMA6 ecma-international.org/publications/files/ECMA-ST/… ), il n'utilise pas la terminologie ci-dessus pour classer les objets. Reportez-vous à ma réponse ci-dessous.
— jaaw
17

Voici ma compréhension de la spécification.

Ce:

var bird = new Bird();

... aboutit à un objet natif qui a simplement été créé à l'aide de l' newopérateur.

Les objets natifs ont une propriété [[Class]] interne de l'une des propriétés suivantes:

"Arguments", "Array", "Boolean", "Date", "Error", "Function", "JSON", "Math", "Number", "Object", "RegExp" et "String" .

Pour votre bird1ce sera:

"Objet"

Tout comme si vous créez une fonction:

function my_func() {
    // ...
}

... my_funcn'est pas défini dans ECMAScript, mais il s'agit toujours d'un objet natif avec la [[Class]] interne:

"Fonction"

Un objet hôte est un objet fourni par l'environnement afin de servir un objectif spécifique à cet environnement non défini dans la spécification.

Par exemple:

var divs = document.getElementsByTagName('div')

L'objet référencé par divsest un NodeList , qui est intégré dans l'environnement de telle manière qu'il ressemble à un objet JavaScript normal, mais il n'est défini nulle part par la spécification.

Sa propriété interne [[Class]] est:

"NodeList"

Cela offre aux concepteurs d'implémentation une certaine flexibilité pour adapter l'implémentation aux besoins spécifiques de l'environnement.

Certaines exigences relatives aux objets hôtes sont définies dans la spécification.

— utilisateur113716
source
2
+1, je suis d'accord avec vous, birdet Birdsont des objets natifs , ce sont une fonction définie par l'utilisateur ( Bird), et un objet ( bird) créé par l'utilisation de la fonction en tant que constructeur, toute la sémantique de ceci est définie sur la spécification. A propos des objets hôtes, ne comptez pas trop sur la [[Class]]propriété interne, par exemple window.alerta "Function"comme valeur de sa [[Class]]propriété presque toutes les implémentations, sur IE qu'il a "Object", et c'est toujours un objet hôte ...
— Christian C. Salvadó
Merci @CMS. Ouais, je ne voulais pas trop mettre l'accent sur l'utilisation de l'interne [[Class]]. Plutôt juste pour l'utiliser comme un aperçu tangible de la façon dont les implémenteurs ont interprété les différents types d'objets. Donc, window.alertavoir un interne [[Class]]de "Function"semble être une violation de ES 5?
— user113716
J'essaye de voir cette action ain, mais si j'obtiens le type de cette div, divs/NodeListj'obtiens un object. Je suppose que je ne comprends pas encore cela, mais cela ne ferait-il pas un objet natif?
— Mark B
Ceci est utile . Obtenir tout dans windowmontre tous les objets hôtes
— Mark B
Bird n'est pas un objet natif car son interface n'est pas entièrement décrite dans la norme ECMASCript. C'est vraiment aussi simple que cela. L'objet est natif et String est natif, mais les objets définis par l'utilisateur ou définis par l'hôte ne sont pas natifs.
— Scott Marcus
3

Impossible de voir une réponse convaincante à la question de savoir s'il var bird1 = new Bird();s'agit d'un objet natif ou hôte. En supposant que Bird est une fonction définie par l'utilisateur, un objet natif non intégré sera créé conformément à http://es5.github.io/#x13.2 par l'implémentation javascript. En revanche, natif intégréles objets seront présents depuis le démarrage d'un programme javascript (comme Object et bien d'autres). Une différence entre un objet natif et un objet hôte est que le premier est créé par l'implémentation javascript et le second est fourni par l'environnement hôte. En conséquence, la propriété interne de l'objet hôte [[class]] peut être différente de celles utilisées par les objets intégrés (c'est-à-dire "Arguments", "Array", "Boolean", "Date", "Error", "Function", " JSON "," Math "," Number "," Object "," RegExp "et" String ").

Il convient également de noter que ECMA6 http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf n'utilise plus la terminologie native et host object . Au lieu de cela, il définit les types d'objets ci-dessous, avec des explications plus claires de leur comportement prévu.

4.3.6 objet ordinaire

objet qui a le comportement par défaut pour les méthodes internes essentielles qui doivent être prises en charge par tous les objets

4.3.7 objet exotique

objet qui n'a pas le comportement par défaut pour une ou plusieurs des méthodes internes essentielles qui doivent être prises en charge par tous les objets REMARQUE Tout objet qui n'est pas un objet ordinaire est un objet exotique.

4.3.8 objet standard

objet dont la sémantique est définie par cette spécification

4.3.9 objet intégré

objet spécifié et fourni par une implémentation ECMAScript

— jaaw
source
3

En plus des autres réponses concernant les objets hôtes.

Les objets hôtes sont spécifiques à un environnement. Ainsi, à côté des objets hôtes du navigateur, il existe également des objets spécifiques à nodejs.

Pour les besoins de l'exemple, en commençant par les objets Standard tels que définis en Javascript. Puis les objets communs pour le Browser / DOM. Node a ses propres objets.

  1. Exemples d'objets intégrés Javascript standard :

  2. Exemples de modèle d'objet de document Objets hôtes :

  3. Objets hôtes dans Node.js :

— Remi
source
1

Considérant trois objets: hôte, natif, personnalisé.

Les objets hôtes sont créés par l'environnement et sont spécifiques à l'environnement. Le meilleur environnement connu serait un navigateur Web mais pourrait être une autre plate-forme. Les objets hôtes créés dans le navigateur Web peuvent être l'objet de fenêtre ou le document. En général, un navigateur utilise une API pour créer des objets hôtes afin de refléter le modèle d'objet de document en JavaScript. (Webbrowser a différents moteurs JavaScript qui font cela) Un objet hôte est créé automatiquement au moment où la page est rendue dans un navigateur.

Un objet natif est créé par le développeur à l'aide de classes prédéfinies de JavaScript. Les objets natifs sont dans votre script écrit.

Ensuite, un objet personnalisé est créé par le développeur à partir d'une classe personnalisée (non prédéfinie ou partiellement prédéfinie).

— Khamaseen
source
0

Les objets natifs sont des objets qui adhèrent aux spécifications, c'est-à-dire des "objets standards".

Les objets hôtes sont des objets fournis par le navigateur (ou un autre environnement d'exécution comme Node).

La plupart des objets hôtes sont des objets natifs, et chaque fois que vous instanciez quelque chose en utilisant new, vous pouvez être sûr à 99,99% qu'il s'agit d'un objet natif, à moins que vous ne vous amusiez avec des objets hôtes étranges.

Cette notion a été introduite en raison de la présence d'objets très bizarres dans IE (et d'autres anciens navigateurs?) . Par exemple:

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

En voyant cela, tout le monde conviendrait que document.allc'est clairement "non standard", et donc un objet hôte non natif .

Alors pourquoi ne pas appeler les objets standards des objets natifs en premier lieu? Simple: après tout, le document Standard (!) Parle aussi d'objets non natifs, et les appeler non standard conduirait à un paradoxe.

Encore:

  • native == "standard"
  • hôte == fourni par le navigateur ou Node ou…
  • la plupart des objets hôtes sont natifs et tous les objets non hôtes sont également natifs
— user123444555621
source
Vous avez un peu déraillé là-bas. "La plupart des objets hôtes sont natifs" est incorrect. En fait, par définition, TOUS les objets hôtes ne sont PAS natifs. Native signifie «standard», bien sûr, mais cela signifie standard dans la spécification du langage, pas standard dans le sens de hors de l'ordinaire. JavaScript (ECMASCript) définit plusieurs interfaces / API qui sont implémentées par les navigateurs et autres hôtes, telles que: String, Date, MATH, Boolean, Number, JSON et XmlHTTP. Ces objets sont disponibles car l'hôte implémente un moteur compatible ECMAScript et répond à la norme ECMA.
— Scott Marcus
0

Cela peut être excessif, mais pour simplifier, un objet natif est un objet existant et utilisable dans tout environnement qui implémente un moteur compatible ECMAScript. Il s'agit généralement (mais pas toujours) d'un navigateur.

Ainsi, votre Internet Explorer ou votre Google Chrome, ne met pas l'objet String à votre disposition, par exemple. La raison pour laquelle vous pouvez utiliser l'objet String est qu'il est "natif" (intégré) au langage JavaScript lui-même.

Cependant, si vous souhaitez créer une fenêtre contextuelle, vous devrez utiliser l'objet window. L'objet window est fourni par le logiciel de navigation lui-même, il n'est donc pas natif de JavaScript, mais il fait partie du "Browser Object Model" ou de la nomenclature.

— Scott Marcus
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.