Explication détaillée de la création d'objets JavaScript, de l'encapsulation de fonctions et des exemples de codes d'attribut

Créer des objets

Tout d'abord, comprenons la programmation orientée objet (POO). Lorsque nous utilisons la technologie POO, nous avons souvent besoin d'utiliser. beaucoup de modules Code, chaque module apporte des fonctions spécifiques, chaque module est isolé, voire complètement indépendant des autres modules. Cette approche de programmation modulaire offre une grande diversité et augmente considérablement les possibilités de réutilisation du code. Pour illustrer davantage ce problème, considérons une application hautes performances sur votre ordinateur qui est une voiture de course de première classe. En utilisant les techniques de programmation traditionnelles, la voiture serait une unité. Si vous souhaitez améliorer la voiture, vous devez remplacer l'ensemble de l'unité, la renvoyer au constructeur, la faire mettre à niveau par un expert automobile ou acheter une nouvelle voiture. Si vous utilisez la technologie OOP, il vous suffit d'acheter un nouveau moteur auprès du fabricant et de le remplacer vous-même conformément aux instructions, au lieu de couper la carrosserie de la voiture avec une scie à métaux. Cependant, la plupart des arguments sont que JavaScript n'est pas un langage directement orienté objet, mais que grâce à la simulation, il peut faire beaucoup de choses que seuls les langages orientés objet peuvent faire, comme l'héritage, le polymorphisme et l'encapsulation. (il n'y a rien qu'il ne puisse pas faire, je n'y pense tout simplement pas)

//以下三种构造对象的方法 
//new Object，实例化一个Object 
var a=new Object(); 
a.x=1,a.y=2; 
//对象直接量 
var b={x:1,y:2}; 
//定义类型 
function Point(x,y){ //类似于C#中的类 
this.x=x; 
this.y=y; 
} 
var p=new Point(1,2); //实例化类

La première méthode est obtenue en construisant un objet de base et en ajoutant directement des attributs. La deuxième méthode est similaire à la première méthode et. peut être considéré comme une notation raccourcie de la première méthode. Parmi les trois méthodes, vous pouvez créer plusieurs objets du même type basés sur des "classes"

Encapsulation des propriétés d'objet (publiques et privées)

🎜>
Illustré avec des exemples

function List(){

m_elements=Array.apply(m_elements,arguments); 
//此处模拟getter，使用时alist.length; 
//等价于getName()方式：this.length=function(){return m_elements.length;}，使用时 
alist.length(); 
//公有属性，可以通过"."运算符或下标来访问 
this.length={ 
valueOf:function(){ 
return m_elements.length; 
}, 
toString:function(){ 
return m_elements.length; 
} 
} 
//公有方法，此方法使用得alert(alist)相当于alert(alist.toString()) 
this.toString=function(){ 
return m_elements.toString(); 
} 
//公有方法 
this.add=function(){ 
m_elements.push.apply(m_elements,arguments); 
} 
//私有方法如下形式，这里涉及到了闭包的概念，接下来继续说明 
//var add=function()或function add() 
//{ 
//m_elements.push.apply(m_elements,arguments); 
//} 
} 
var alist=new List(1,2,3); 
dwn(alist); //=alert(alist.toString())，输出1,2,3 
dwn(alist.length); //输出3 
alist.add(4,5,6); 
dwn(alist); //输出1,2,3,4,5,6 
dwn(alist.length); //输出6

var m_elements=[]; //Les membres privés ne sont pas accessibles en dehors de l'objet. S'il n'y a pas de déclaration var ici, m_elements deviendra une variable globale. , afin qu'il soit directement accessible de l'extérieur. Par exemple, alert(m_elements[0])

Types de propriétés et méthodes

En JavaScript, les propriétés et les méthodes d'objets prennent en charge 4 types différents : propriétés de propriété privée (propriété privée), propriété publique dynamique (propriétés publiques dynamiques), propriété publique statique/propriété de prototype (propriétés publiques statiques ou propriétés de prototype), propriété statique (propriétés statiques ou propriétés de classe) . Les propriétés privées sont complètement inaccessibles au monde extérieur et sont accessibles via des getters et setters internes (les deux propriétés publiques dynamiques sont accessibles par le monde extérieur, et chaque instance d'objet contient une copie et n'affectera pas les propriétés des prototypes) ; de chaque instance d'objet Une copie unique est partagée ; les attributs de classe ne sont pas traités comme des attributs de l'instance, uniquement comme des attributs de la classe.

//动态公有类型，静态公有类型（原型属性） 
function myClass(){ 
var p=100; //private property 
this.x=10; //dynamic public property 
} 
myClass.prototype.y=20; //static public property or prototype property，动态为myClass的原型添 
加了属性，将作用于所有实例化了的对象，注意这里用到了prototype，这是一个非常有用的东东 
//要想成为高级javascript阶段，prototype和闭包必须得理解和适当应用 
myClass.z=30; //static property 
var a=new myClass(); 
dwn(a.p) //undefined 
dwn(a.x) //10 
dwn(a.y) //20 
a.x=20; 
a.y=40; 
dwn(a.x); //20 
dwn(a.y); //40 
delete(a.x); //删除对象a的属性x 
delete(a.y); //删除对象a的属性y 
dwn(a.x); //undefined 
dwn(a.y); //20 静态公有属性y被删除后还原为原型属性y 
dwn(a.z); //undefined 类属性无法通过对象访问 
dwn(myClass.z);

Voici des exemples :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!