Comment est presque tout en Javascript un object?

C’est vrai, en javascript, presque tout est un object. Mais ces objects sont légèrement différents de ce que nous voyons en Java, C ++ ou d’autres langages conventionnels. Un object dans JS est simplement une table de hachage avec des paires clé-valeur. Une clé est toujours une chaîne, et une valeur peut être n’importe quoi, y compris des chaînes, des entiers, des booléens, des fonctions, d’autres objects, etc. Ainsi, je peux créer un nouvel object comme celui-ci:

var obj = {}; // this is not the only way to create an object in JS 

et ajoutez-y de nouvelles paires clé-valeur:

 obj['message'] = 'Hello'; // you can always attach new properties to an object externally 

ou

 obj.message = 'Hello'; 

De même, si je veux append une nouvelle fonction à cet object:

 obj['showMessage'] = function(){ alert(this['message']); } 

ou

 obj.showMessage = function() { alert(this.message); } 

Maintenant, chaque fois que j’appelle cette fonction, une fenêtre contextuelle contenant le message suivant s’affiche:

 obj.showMessage(); 

Les tableaux sont simplement les objects capables de contenir des listes de valeurs:

 var arr = [32, 33, 34, 35]; // one way of creating arrays in JS 

Bien que vous puissiez toujours utiliser n’importe quel object pour stocker des valeurs, les tableaux vous permettent de les stocker sans associer une clé à chacun d’eux. Vous pouvez donc accéder à un élément en utilisant son index:

 alert(arr[1]); // this would show 33 

Un object tableau, comme tout autre object dans JS, a ses propriétés, telles que:

 alert(arr.length); // this would show 4 

Pour des détails plus approfondis, je recommanderais vivement les techniques Javascript de John Resig.

Non, tout n’est pas un object en JavaScript. Beaucoup de choses avec lesquelles vous interagissez régulièrement (chaînes, nombres, booléens) sont des primitives, pas des objects. Contrairement aux objects, les valeurs primitives sont immuables. La situation est compliquée par le fait que ces primitives ont des wrappers d’objects ( Ssortingng , Number et Boolean ); ces objects ont des méthodes et des propriétés alors que les primitives n’en ont pas, mais les primitives semblent avoir des méthodes car JavaScript crée en mode silencieux un object wrapper lorsque le code tente d’accéder à l’une des propriétés d’une primitive.

Par exemple, considérons le code suivant:

 var s = "foo"; var sub = s.subssortingng(1, 2); // sub is now the ssortingng "o" 

En coulisse, la sous- s.subssortingng(1, 2) se comporte comme si elle effectuait les étapes (approximatives) suivantes:

1. Créer un object wrapper Ssortingng partir de s , équivalent à l’utilisation de new Ssortingng(s)
2. Appelez la méthode subssortingng() avec les parameters appropriés sur l’object Ssortingng renvoyé par l’étape 1
3. Dispose de l’object Ssortingng
4. Renvoie la chaîne (primitive) à partir de l’étape 2.

Cela a pour conséquence que, même s’il semble que vous puissiez affecter des propriétés à des primitives, cela n’a aucun sens car vous ne pouvez pas les récupérer:

 var s = "foo"; s.bar = "cheese"; alert(s.bar); // undefined 

Cela est dû au fait que la propriété est effectivement définie sur un object Ssortingng immédiatement ignoré.

Les nombres et les booléens se comportent également de cette manière. Les fonctions, cependant, sont des objects à part entière et héritent d’ Object (en réalité, Object.prototype , mais c’est un autre sujet). Les fonctions peuvent donc faire tout ce que les objects peuvent, y compris avoir des propriétés:

 function foo() {} foo.bar = "tea"; alert(foo.bar); // tea 

La phrase “En JavaScript, presque tout est un object” est correcte, car les unités de code MAIN (objects, fonctions, tableaux) sont des objects JavaScript.
Le code JavaScript utilise 9 unités différentes plus 1 (multiple):
– 01. tableau
– 02. booléen
– 03. fonction
– 04. null
– numéro 05
– 06. object
– 07. regexp
– 08. chaîne
– 09. undefined
– 10. multiple

MAIS objects JavaScript:
– NE SONT PAS les mêmes créatures que les “objects” d’autres langages orientés object.
– Ils sont une collection de paires nom-valeur.
– Tous ont une fonction de création (son constructeur).
– tous INHERIT les membres du prototype-object de son constructeur et ceci est son prototype.
– toutes les fonctions sont des objects MAIS PAS tous les objects sont des fonctions .
– les fonctions ont une scope, les objects NON (un défaut de conception à mon avis).
– Objet, Fonction, Tableau, Chaîne, … avec le premier CAPITAL sont des fonctions !!!
– les différences entre les objects et les fonctions JS sont plus importantes que les valeurs communes.
– le nom “instance” dans JS a un sens différent du nom “instance” dans la théorie de la connaissance où une instance hérite des atsortingbuts de son concept générique. En JS ne désigne que son constructeur. JavaScript a reçu le nom ‘instance’ de ‘class-based-inheritance’ ool (java) où il s’agit d’un nom approprié, car ces objects héritent des atsortingbuts des classes.
Un meilleur nom pour le mot clé JS ‘instanceof’ est ‘objectof’.

Les fonctions JS SONT des objects JS car:
1) ils peuvent avoir des membres comme objects JS:

     > fonction f () {}
     indéfini
     > fs = "une chaîne"
     "un ssortingng"
     > fs
     "un ssortingng"

2) ils ont une fonction constructeur, comme tous les objects JS, la fonction Function:

     > (fonction f () {}) instance de Fonction
     vrai

3) comme tous les objects JS, leur object-prototype est identique à celui de son constructeur:

     > (fonction f () {}) .__ proto__ === Function.prototype
     vrai
     > ({}) .__ proto__ === Object.prototype
     vrai
     > (nouvel object) .__ proto__ === Object.prototype
     vrai

4) bien sûr, les fonctions JS comme objects JS SPÉCIFIQUES ont des atsortingbuts supplémentaires, comme toutes les fonctions des langages de programmation, que les objects JS n’ont pas, vous pouvez les appeler (exécuter) avec des informations d’entrée et de sortie.

TOUT n’est PAS un object, car, par exemple, nous ne pouvons PAS append de membres à une chaîne littérale:

     > var s = "chaîne"
     indéfini
     > s.s2 = "s2ssortingng"
     "s2ssortingng"
     > s.s2
     indéfini

Tout n’est pas un object en javaScript. JavaScript a des primitives et des objects. Il existe six primitives: null, indéfini, chaîne, nombre, booléen et symbole. Il peut sembler que tout se comporte comme un object à cause des propriétés et de la fonction accessibles.

 var ssortingngvar="this ssortingng"; typeof ssortingngvar; // "ssortingng" ssortingngvar.length; //11 

maintenant, puisque “ssortingngvar” est un type de chaîne, qui est un type primitif, il ne devrait pas pouvoir accéder à la longueur de la propriété.Il peut le faire à cause de quelque chose appelé Boxing.Boxing est le processus dans lequel tout type primitif est converti en un type Object et l’inverse s’appelle Unboxing.Ces types d’object ou wrapper d’object sont créés avec la vue qu’il existe certaines opérations courantes qu’il peut être nécessaire d’exécuter avec les valeurs primitives. Ils contiennent des méthodes et propriétés utiles et sont liés aux prototypes. En ce qui concerne les objects, des paires clé / valeur peuvent être ajoutées à chaque object, même aux tableaux.

 var arr=[1,2,3]; arr.name="my array"; arr; //[1,2,3,name:'my array'] 

cela ne signifie pas que le quasortingème élément du tableau est “nom:” mon tableau “”. “nom” est une propriété qui peut être appelée avec une notation de point (arr.name) ou une notation de crochets (arr [“nom”]) .