Explication détaillée des propriétés et méthodes de fonctionnement basées sur des objets JS

Auteur：Eve Cole Date de mise à jour：2025-08-03 17:16:01

1. Présentation

Dans la langue java, nous pouvons définir nos propres classes et créer des objets en fonction de ces classes à utiliser. Dans JavaScript, nous pouvons également définir nos propres classes, telles que la définition de la classe utilisateur, la classe de hashtable, etc.

Actuellement en JavaScript, il existe des classes standard, telles que la date, le tableau, le regexp, la chaîne, les mathématiques, le numéro, etc., qui nous fournissent de nombreuses commodités à la programmation. Mais pour les programmes clients complexes, ceux-ci sont loin d'être suffisants.

Contrairement à Java, Java2 nous fournit de nombreuses classes standard, qui répondent essentiellement à nos besoins en programmation. Cependant, JavaScript fournit peu de classes standard, et de nombreux besoins en programmation doivent être mis en œuvre par nous-mêmes. Par exemple, JavaScript n'a pas de table de hachage, qui n'est pas pratique dans la gestion des valeurs de clés.

Par conséquent, je pense personnellement qu'une vue complète d'objet JavaScript devrait être la suivante:

2. Concepts de base

1. Personnalisez l'objet.

Selon le mécanisme d'extension des objets de JS, les utilisateurs peuvent personnaliser les objets JS, ce qui est similaire à la langue Java.

Correspondant aux objets personnalisés sont des objets standard JS, tels que la date, le tableau, les mathématiques, etc.

2. Prototype

Dans JS, c'est un moyen de créer des propriétés et des méthodes d'objets, et via le prototype, vous pouvez ajouter de nouvelles propriétés et méthodes à des objets.

Avec le prototype, nous pouvons ajouter de nouvelles propriétés et méthodes à des objets standard JS, par exemple, pour les objets de chaîne, nous pouvons y ajouter une nouvelle méthode TRIM ().

Contrairement aux langages de programmation stricts tels que Java, nous pouvons ajouter dynamiquement de nouvelles propriétés aux objets JS pendant l'exécution.

Trois, règles de grammaire

1. Méthode de création d'objets

1) Méthode d'initialisateur d'objet

Format: objectName = {propriété1: value1, propriété2: value2,…, propriétén: valuen}

la propriété est la propriété d'un objet

La valeur est la valeur de l'objet, et la valeur peut être celle d'une chaîne, d'un nombre ou d'un objet

Par exemple: var user = {name: "user1", âge: 18};

var user = {name: "user1", travail: {salaire: 3000, titre: programmeur}

Des méthodes qui peuvent également être initialisées de cette manière, par exemple:

 var user = {name: "user1", Âge: 18, getName: function () {return this.name; }}

Les éléments suivants seront expliqués avec le foyer de la méthode du constructeur, y compris la définition des attributs et des méthodes, et seront également expliqués en référence à la méthode du constructeur.

2) Méthode du constructeur

Écrivez un constructeur et créez un objet via une nouvelle méthode. Le constructeur aurait pu transporter des paramètres du constructeur

Par exemple:

 fonction user (nom, âge) {this.name = name; this.age = âge; this.Canfly = false; } var use = new User ();

2. Définir les propriétés des objets

1) Dans JS, trois types de propriétés peuvent être définis pour les objets: propriétés privées, propriétés d'instance et propriétés de classe. Semblable à Java, les propriétés privées ne peuvent être utilisées qu'à l'intérieur d'objets. Les propriétés d'instance doivent être référencées via l'instance de l'objet et les propriétés de classe peuvent être référencées directement via le nom de classe.

2) Définition d'attribut privé

Les attributs privés ne peuvent être définis et utilisés dans le constructeur.

Format de syntaxe: var propriétéName = valeur;

Par exemple:

 Fonction User (Age) {this.age = age; var ischild = âge <12; this.islittlechild = ischild; } var user = nouvel utilisateur (15); alert (user.islittlechild); // la bonne voie alerte (user.ischild); // l'erreur: l'objet ne prend pas en charge cette propriété ou cette méthode

3) Il existe également deux façons de définir les attributs d'instance:

Méthode de prototype, format de syntaxe: functionname.prototype.propertyName = valeur

Cette méthode, Format de syntaxe: this.propertyName = valeur, faites attention à l'emplacement utilisé dans les exemples suivants

La valeur ci-dessus peut être la création, le nombre et l'objet de caractères.

Par exemple:

 fonction user () {} user.prototype.name = "user1"; User.prototype.age = 18; var user = new User (); alerte (user.age); - ―vision `` arele - `` are

3) Définition de l'attribut de classe

Format de syntaxe: functionname.propertyName = valeur

Par exemple:

 fonction user () {} user.max_age = 200; User.min_age = 0; alert (user.max_age);

Reportez-vous aux propriétés de classe des objets standard JS:

Numéro.max_value // valeur numérique maximale math.pi // pi

4) En plus des méthodes plus formelles ci-dessus, il existe également un moyen très spécial de définir les attributs, Format de syntaxe: obj [index] = valeur

exemple:

 fonction user (name) {this.name = name; this.age = 18; ce [1] = "ok"; Ce [200] = "année"; } var user = nouvel utilisateur ("user1"); alert (utilisateur [1]);

Dans l'exemple ci-dessus, il est important de noter que l'attribut d'âge n'est pas obtenu par le biais de ce [1], et cela ne peut pas être obtenu à travers cela [0]. Autrement dit, l'index défini par l'index doit être référencé à l'aide du mode d'index, et non défini par le mode d'index, et doit être référencé de manière normale.

3. Définir la méthode de l'objet

1) Il existe trois types de méthodes qui peuvent être définies pour les objets en JS: méthodes privées, méthodes d'instance et méthodes de classe, similaires à Java:

Les méthodes privées ne peuvent être utilisées que des objets à l'intérieur des objets

Les méthodes d'instance doivent être instanciées avant de pouvoir être utilisées

Les méthodes de classe peuvent être utilisées directement via les noms de classe

Remarque: La définition de la méthode ne peut pas être effectuée via la méthode d'index mentionnée ci-dessus.

2) Définir les méthodes privées

Les méthodes privées doivent être définies dans le corps du constructeur et ne peuvent être utilisées que dans le corps du constructeur.

Format de syntaxe: Fonction Methodname (Arg1,…, Argn) {}

Par exemple:

 fonction user (name) {this.name = name; Fonction getNameLength (NAMELRS) {return NAMESTR.Length; } this.NameLength = getNameLength (this.name); }

3) Définir une méthode d'instance, actuellement deux méthodes peuvent être utilisées:

Méthode prototype, utilisée en dehors du constructeur, format de syntaxe:

functionname.prototype.methodname = méthode;

functionName.prototype.MethodName = fonction (arg1,…, argn) {};

Cette méthode, utilisée à l'intérieur du constructeur, format de syntaxe:

this.MethodName = méthode;

this.MethodName = function (arg1,…, argn) {};

Dans la description de syntaxe ci-dessus, la méthode est une méthode qui existe déjà à l'extérieur. La méthode de l'objet à définir par MethodName signifie qu'une méthode externe est attribuée directement à une méthode de l'objet.

Définir la méthode d'objet sous la forme de la fonction (Arg1,…, Argn) {} est quelque chose que les développeurs devraient maîtriser.

Quelques exemples de définition d'une méthode d'instance: Exemple 1

 fonction user (name) {this.name = name; this.getName = getUsername; this.setName = setUsername; } fonction getUserName () {return this.name; } Fonction setUserName (name) {this.name = name; }

Quelques exemples de définition d'une méthode d'instance: Exemple 2

 fonction user (name) {this.name = name; this.getName = function () {return this.name; }; this.setName = function (newname) {this.name = newname; }; }

Quelques exemples de définition d'une méthode d'instance: Exemple 3

 fonction user (name) {this.name = name; } User.prototype.getName = getUserName; User.prototype.setname = setUsername (); fonction getUserName () {return this.name; } Fonction setUserName (name) {this.name = name; }

Quelques exemples de définition d'une méthode d'instance: Exemple 4

 fonction user (name) {this.name = name; } User.prototype.getName = function () {return this.name; }; User.prototype.setName = function (newname) {this.name = newname; };

4) Définir les méthodes de classe

Les méthodes de classe doivent être définies en dehors du constructeur et peuvent être référencées directement par le nom du constructeur.

Format de syntaxe:

functionName.MethodName = méthode;

functionName.MethodName = function (arg1,…, argn) {};

exemple:

 fonction user (name) {this.name = name; } User.getMaxage = getUserMaxage; fonction getUserAxage () {return 200; }

User.getMaxage = function () {return 200;};

alert (user.getMaxage ());

4. Références des propriétés et méthodes

1) Du point de vue de la visibilité:

Les propriétés et méthodes privées ne peuvent être référencées que dans l'objet.

Les propriétés et méthodes d'instance peuvent être utilisées n'importe où, mais doivent être référencées par des objets.

Les propriétés et méthodes de classe peuvent être utilisées n'importe où, mais ne peuvent pas être référencées par une instance d'un objet (ceci est différent de Java, où les membres statiques sont accessibles par une instance).

2) Du niveau d'objet:

Semblable aux références aux haricots Java, des références profondes peuvent être faites.

Plusieurs façons:

Propriété simple: obj.propertyname

Propriétés de l'objet: obj.innerobj.propertyname

Propriété index: obj.propertyname [index]

Pour des références plus profondes, similaires à celles ci-dessus.

3) D'après la méthode de définition:

Les attributs définis via la méthode d'index doivent être référencés via la méthode d'index.

Les attributs définis par les méthodes non index doivent être référencés de manière normale.

Remarque également: la méthode de l'objet ne peut pas être définie via la méthode d'index.

5. Ajout dynamique et suppression des propriétés et des méthodes

1) Pour un objet qui a été instancié, nous pouvons ajouter et supprimer dynamiquement ses propriétés et méthodes. La syntaxe est la suivante (en supposant que l'instance d'objet est obj):

Augmentez dynamiquement les propriétés des objets

obj.newpropertyName = valeur;

Augmenter dynamiquement la méthode des objets

obj.newMethodName = méthode ou = fonction (arg1,…, argn) {}

Supprimer dynamiquement les propriétés des objets

supprimer obj.propertyname

Supprimer dynamiquement la méthode d'objet

supprimer obj.methodname

2) Exemple:

 fonction user (name) {this.name = name; this.age = 18; } var user = nouvel utilisateur ("user1"); user.sister = "Susan"; alert (user.sister); // exécuter via supprimer user.sister; alert (user.sister); // Erreur de rapport: l'objet ne prend pas en charge cette propriété user.getMotherName = function () {return "Mary";} alert (user.getMotherName ()); // Exécuter via delete user.getMotherName; alert (user.getMotherName ()); // Rapport Erreur: l'objet ne prend pas en charge cette méthode

Quatre, résumé

1. Le mécanisme des objets personnalisés est l'un des mécanismes les plus attractifs pour JS. C'est tout simplement idéal pour les programmeurs C ++ et Java!

2. Il existe deux façons de créer un objet: initialiseur d'objet et constructeur.

3. Propriétés et méthodes d'objet, les contraintes avec la visibilité, les attributs et les méthodes avec une visibilité différente sont définis différemment.

L'article ci-dessus est basé sur les objets JS, les attributs de fonctionnement et les méthodes, qui sont tous le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.