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

1. Présentation

Dans le langage Java, nous pouvons définir nos propres classes et créer des objets basés sur ces classes à utiliser. En Javascript, nous pouvons également définir nos propres classes, comme définir la classe User. , Classe Hashtable et ainsi de suite.

Actuellement, il existe certaines classes standards en Javascript, telles que Date, Array, RegExp, String, Math, Number, etc., qui nous offrent beaucoup de commodité en programmation. Mais pour les programmes clients complexes, cela est loin d’être suffisant.

Contrairement à Java, Java2 nous fournit de nombreuses classes standard, qui répondent essentiellement à nos besoins de programmation. Cependant, Javascript fournit très peu de classes standard et de nombreux besoins de programmation doivent être implémentés par nous-mêmes. Si vous avez Iriomote Hashtable, cela est très gênant pour traiter les valeurs clés.

Par conséquent, je pense personnellement qu'une vue complète des objets Javascript devrait être la suivante :

2 Concepts de base

1.

Selon le mécanisme d'extension d'objet de JS, les utilisateurs peuvent personnaliser les objets JS, ce qui est similaire au langage Java.

Les objets personnalisés correspondent aux objets standard JS, tels que Date, Array, Math, etc.

2. Prototype

En JS, il s'agit d'un moyen de créer des propriétés et des méthodes d'objet. De nouvelles propriétés et méthodes peuvent être ajoutées aux objets via un prototype.

Grâce au prototype, nous pouvons ajouter de nouvelles propriétés et méthodes aux objets standard JS, par exemple, pour les objets String, nous pouvons 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 au moment de l'exécution.

3. Règles de grammaire

1, méthode de création d'objet

1) Méthode d'initialisation d'objet

Format : objectName = {property1:value1, property2 : value2 ,…, propertyN:valueN>

propriété est l'attribut de l'objet

valeur est la valeur de l'objet La valeur peut être l'une des trois chaînes, nombres ou objets

<.>Par exemple : var user={name:"user1",age:18};

var user={name:"user1",job:{salary:3000,title:programmer}

Les méthodes des objets peuvent également être initialisées de cette manière, par exemple :

var user={name:“user1”,age:18,getName:function(){
 
return this.name;
 
}
 
}

La méthode constructeur sera expliquée plus tard, y compris la définition des attributs et des méthodes, etc. Expliquez la méthode de la fonction constructeur.

2) Méthode du constructeur

Écrivez un constructeur et créez l'objet via une nouvelle méthode. Le constructeur peut avoir des paramètres de construction

Par exemple :

function User(name,age){
 
this.name=name;
 
this.age=age;
 
this.canFly=false;
 
}
 
var use=new User();

2. Définir les attributs des objets

1) Trois types d'attributs peuvent être définis pour les objets dans JS : les attributs privés, les attributs d'instance et les attributs de classe. Semblables à Java, les propriétés privées ne peuvent être que des attributs privés. utilisées à l'intérieur d'un objet, les propriétés d'instance doivent être référencées via une 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 de propriété privée

Les propriétés privées ne peuvent être définies et utilisées qu'à l'intérieur du constructeur.

Format de grammaire : var propertyName=value;

Par exemple :

function User(age){
 
this.age=age;
 
var isChild=age<12;
 
this.isLittleChild=isChild;
 
}
 
var user=new User(15);
 
alert(user.isLittleChild);//正确的方式
 
alert(user.isChild);//报错：对象不支持此属性或方法

3) Il existe deux manières de définir les attributs d'une instance :

Méthode prototype, format de syntaxe : functionName.prototype.propertyName=value

cette méthode, format de syntaxe : this.propertyName=value, faites attention à la position de this utilisée dans l'exemple suivant

La valeur ci-dessus peut être des caractères, des nombres et des objets.

Par exemple :

function User(){ }
 
User.prototype.name=“user1”;
 
User.prototype.age=18;
 
var user=new User();
 
alert(user.age);
 
—————————————–
 
function User(name,age,job){
 
this.name=“user1”;
 
this.age=18;
 
this.job=job;
 
}
 
alert(user.age);

3) Définition de l'attribut de classe

Format de syntaxe : functionName.propertyName=value

Pour exemple :

function User(){ }
 
User.MAX_AGE=200;
 
User.MIN_AGE=0;
 
alert(User.MAX_AGE);

Référez-vous aux attributs de classe des objets standards JS :

Number.MAX_VALUE //Valeur numérique maximale Math.PI //Pi

4) Pour la définition des attributs, en plus de la manière plus formelle ci-dessus, il existe également une manière de définition très particulière, le format syntaxique : obj[index]=value

Exemple :

function User(name){
 
this.name=name;
 
this.age=18;
 
this[1]=“ok”;
 
this[200]=“year”;
 
}
 
var user=new User(“user1”);
 
alert(user[1]);

Dans l'exemple ci-dessus, veuillez noter : l'attribut age ne peut pas être obtenu via ceci[1], et l'attribut name ne peut pas être obtenu via this[0]. La méthode index doit être utilisée pour référencer la méthode index, et il n'y a pas de définition via la méthode index, elle doit être référencée de la manière normale

3, définir les méthodes objet

1) Trois types de méthodes 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 qu'à l'intérieur de l'objet

Les méthodes d'instance doivent être utilisées après l'objet est instancié

Les méthodes de classe peuvent être utilisées directement via le nom de la classe

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

2) Définir des 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 : function methodName(arg1,…,argN){ }

Par exemple :

function User(name){
 
this.name=name;
 
function getNameLength(nameStr){
 
return nameStr.length;
 
}
 
this.nameLength=getNameLength(this.name);
 
}

3) Définir les méthodes d'instance, actuellement Deux méthodes peuvent également être utilisées :

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

functionName.prototype.methodName=method;

ou

functionName.prototype.methodName=function(arg1,…,argN){};

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

this.methodName=method;

ou

this.methodName=function(arg1,…,argN){};

Dans la description de la syntaxe ci-dessus, la méthode est une méthode externe qui existe déjà, et methodName doit be La méthode définie d'un objet signifie attribuer directement une méthode externe à une méthode de l'objet.

以function(arg1,…,argN){}的方式定义对象方法是开发人员应该掌握的。

定义实例方法的一些例子：例子1

function User(name){
 
this.name=name;
 
this.getName=getUserName;
 
this.setName=setUserName;
 
}
 
function getUserName(){
 
return this.name;
 
}
 
Function setUserName(name){
 
this.name=name;
 
}

   

定义实例方法的一些例子：例子2 

function User(name){
 
this.name=name;
 
this.getName=function(){
 
return this.name;
 
};
 
this.setName=function(newName){
 
this.name=newName;
 
};
 
}

定义实例方法的一些例子：例子3 

function User(name){
 
this.name=name;
 
}
 
User.prototype.getName=getUserName;
 
User.prototype.setName=setUserName();
 
function getUserName(){
 
return this.name;
 
}
 
Function setUserName(name){
 
this.name=name;
 
}

定义实例方法的一些例子：例子4 

function User(name){
 
this.name=name;
 
}
 
User.prototype.getName=function(){
 
return this.name;
 
};
 
User.prototype.setName=function(newName){
 
this.name=newName;
 
};

4）定义类方法

类方法需要在构造函数外面定义，可以直接通过构造函数名对其进行引用。

语法格式：

functionName.methodName=method;

或者

functionName.methodName=function(arg1,…,argN){};

例子： 

function User(name){
 
this.name=name;
 
}
 
User.getMaxAge=getUserMaxAge;
 
function getUserMaxAge(){
 
return 200;
 
}

或者

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

alert(User.getMaxAge());

4，属性与方法的引用

1）从可见性上说：

私有属性与方法，只能在对象内部引用。

实例属性与方法，可以在任何地方使用，但必须通过对象来引用。

类属性与方法，可以在任何地方使用，但不能通过对象的实例来引用（这与Java不同，在Java中静态成员可以通过实例来访问）。

2）从对象层次上说：

与Java bean的引用类似，可以进行深层次的引用。

几种方式：

简单属性：obj.propertyName

对象属性：obj.innerObj.propertyName

索引属性：obj.propertyName[index]

对于更深层次的引用与上面类似。

3）从定义方式上说：

通过index方式定义的属性，必须通过index方式才能引用。

通过非index方式定义的属性，必须通过正常的方式才能引用。

另外注意：对象的方法不能通过index方式来定义。

5，属性与方法的动态增加和删除

1）对于已经实例化的对象，我们可以动态增加和删除它的属性与方法，语法如下（假定对象实例为obj）：

动态增加对象属性

obj.newPropertyName=value;

动态增加对象方法

obj.newMethodName=method或者=function(arg1,…,argN){}

动态删除对象属性

delete obj.propertyName

动态删除对象方法

delete obj.methodName

2）例子：

function User(name){
 
this.name=name;
 
this.age=18;
 
}
 
var user=new User(“user1”);
 
user.sister=“susan”;
 
alert(user.sister);//运行通过
 
delete user.sister;
 
alert(user.sister);//报错：对象不支持该属性
 
user.getMotherName=function(){return “mary”;}
 
alert(user.getMotherName());//运行通过
 
delete user.getMotherName;
 
alert(user.getMotherName());//报错：对象不支持该方法

四，总结

1，自定义对象机制，是JS最为吸引人的机制之一，对于C++和Java程序员而言，这简直太棒了！

2，对象创建存在两种方式：对象初始化器和构造函数。

3，对象属性和方法，具有可见性的约束，不同可见性的属性和方法，其定义方式也不一样。

以上这篇基于js对象,操作属性、方法详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持PHP中文网。

更多基于js对象,操作属性、方法详解相关文章请关注PHP中文网！