Java Script Design Patterns
მიმოხილვა: ამ დოკუმენტში ჩვენ ვსაუბრობთ სხვადასხვა დიზაინის ნიმუშები გამოიყენება JavaScript. უმეტესობა დეველოპერები საინტერესოა გაირკვეს, ზუსტი და იდეალური დიზაინის ნიმუში უნდა იქნეს გამოყენებული მათი პროგრამა. გულწრფელად, არ არსებობს კონკრეტული პასუხი ამ კითხვაზე და არ არსებობს ფორმულები, რომელიც გასარკვევად სწორი დიზაინის ნიმუში უნდა იქნეს გამოყენებული მოცემულ სიტუაციაში. ასე რომ, ასეთ მდგომარეობაში,, ჩვენ უნდა ჰქონდეს მტკიცე ამოსუნთქვა დიზაინის მოდელი და კონკრეტული პრობლემები მათ გამკლავება, ჩვენ უნდა იყოს უკეთეს მდგომარეობაში, რათა მიიღოს გადაწყვეტილება, რომელიც დიზაინის ნიმუში უნდა იქნეს გამოყენებული, რომელიც პირობა.
შესავალი:
დიზაინი ნიმუში არის მრავალჯერადი გადაწყვეტა, რომელიც შეიძლება იქნას გამოყენებული საერთო ხელახლა ხდება პრობლემა პროგრამული უზრუნველყოფის დიზაინი და განვითარების. დიზაინი ნიმუში ასევე შეიძლება უწოდა როგორც თარგები გამოიყენება გადაჭრის საერთო პრობლემები. დიზაინის ნიმუშები აქვს სამი ძირითადი სარგებელი:
- ისინი აპრობირებული გადაწყვეტილებები: დიზაინი ნიმუში უზრუნველყოფს მყარი მიდგომა პროგრამული უზრუნველყოფის განვითარებისა და იყენებს დადასტურებული ტექნიკა.
- მარტივად შეიძლება გამოყენებული: დიზაინი ნიმუშებია კონცეპტუალური და გარეთ ყუთი გადაწყვეტა, რომელიც შეესაბამება ჩვენს მოთხოვნებს. ეს ფუნქცია ხდის დიზაინის მოდელი უფრო ძლიერი და ისინი შეიძლება ხელახლა გამოიყენება ანალოგიურ პირობებში.
- ნიმუშები გამომხატველი: ყოველ დიზაინის ნიმუში წარმოდგენილია წინასწარგანსაზღვრული კომპლექტი სტრუქტურა და ლექსიკა, რომელიც შეიძლება გამოყენებულ გადაწყვეტილებების დიდი პრობლემები.
დიზაინი ნიმუში არ უზრუნველყოფს ზუსტი გადაწყვეტა პრობლემა. მნიშვნელოვანია, აღინიშნოს, რომ როლი ნიმუშების არის გამოსავალი სქემა.
სახეები დიზაინი ნიმუშები
დიზაინის ნიმუშები შეიძლება დაიყოს შემდეგ სამ ქვე კატეგორიები:
- შემოქმედებითი დიზაინი Pattern : ამ კატეგორიაში შემდეგი დიზაინის ნიმუშები დაეცემა :
- Singleton
- აღმაშენებლის
- Factory
- აბსტრაქტული
- პროტოტიპი
- აღმაშენებლის
- სტრუქტურული დიზაინი Pattern : ამ კატეგორიაში შემდეგი დიზაინის ნიმუშები დაეცემა :
- დეკორატორი
- ფასადი
- Flyweight
- Adapter
- proxy
- ქცევითი დიზაინი Pattern : ამ კატეგორიაში შემდეგი დიზაინის ნიმუში შემოდგომაზე :
- iterator
- სტუმარი
- მედიატორი
- Observer
ნიმუშების JavaScript:
შემდეგი ნიმუშების გამოიყენება JavaScript:
- კონსტრუქტორი Pattern
- მოდული Pattern
- Singleton Pattern
- დამკვირვებელთა Pattern
- მედიატორი Pattern
- Prototype Pattern
- Command Pattern
- ფასადი Pattern
- Factory Pattern
- დეკორატორი Pattern
- Flyweight Pattern
კონსტრუქტორი Pattern:
რაც შეეხება კლასიკურ ობიექტზე ორიენტირებული პროგრამირების კონცეფცია, კონსტრუქტორი არის სპეციალური ტიპის მეთოდი, რომელიც გამოიყენება, რათა შეიქმნას მაგალითად ობიექტი მეხსიერება. In JavaScript ობიექტის შექმნა კეთდება გამოყენებით ნებისმიერ შემდეგ სამი მიდგომები:
Listing 1: სამი მიდგომები გამოიყენება JavaScript რათა შეიქმნას ობიექტები
[Code]
// მიდგომა 1
იყო newObject = {};
//მიდგომა 2
var newObject = Object.create(ნულოვანი);
//მიდგომა 3
var newObject = ახალი ობიექტის();
[/Code]
მესამე მიდგომა, ობიექტის ის გამოყენებით ობიექტის მშენებელი, სადაც არ ღირებულება გავიდა ან მითითებული. არსებობს მრავალი გზა შექმნას ფასეულობები ახლად შექმნილი ობიექტი. These are:
Listing 2: გზები მითითებული ღირებულებების მშენებელი
[Code]
//მიდგომა 1
newObject.someKey = "Hello World"
//მიდგომა 2
newObject[someKey] = "Hello World"
//მიდგომა 3
| Object.defineProperty( newObject, “someKey”, {
ღირებულება : "გამარჯობა მსოფლიო" ჩაწერადი : ნამდვილი enumerable : ნამდვილი configurable : ნამდვილი ); [/Code] |
Singleton Pattern:
ჩვენ ყველამ ვიცით, რომ singleton ნიმუში ზღუდავს შექმნა ობიექტი ერთი შემთხვევა. Singleton ნიმუში ხორციელდება შექმნით კლასის მეთოდი, რომელიც ქმნის ახალ ინსტანციის ობიექტი მხოლოდ მაშინ, როცა არსებობს სხვა შემთხვევებიც არსებობს. In JavaScript singletons ემსახურება როგორც საერთო რესურსი namespace რომელიც იზოლაციაში განხორციელების გლობალური namespace. in JavaScript, singleton ხორციელდება შემდეგი წესით:
Listing 3: Singleton განხორციელების JavaScript
[Code]
იყო mySingleton = (ფუნქცია () {
// მაგალითად ინახავს მინიშნება Singleton
var მაგალითად;
ფუნქცია init() {
// Singleton
// მეთოდები და ცვლადები
ფუნქცია privateMethod(){
console.log( “ვარ კერძო” );
}
იყო კერძო ცვლადი = “Im ასევე კერძო”;
var privateRandomNumber = Math.random();
return {
// სახალხო მეთოდები და ცვლადები
publicMethod: ფუნქცია () {
console.log( “საჯარო ვხედავთ me!” );
},
publicProperty: “მე ასევე საჯარო”,
getRandomNumber: ფუნქცია() {
დაბრუნდეს privateRandomNumber;
}
};
};
return {
// მიიღეთ Singleton მაგალითად, თუ ერთი არსებობს
// ან შექმნათ ერთი, თუ ეს არ
getInstance: ფუნქცია () {
თუ ( !მაგალითად ) {
მაგალითად = init();
}
დაბრუნდეს მაგალითად;
}
};
})();
იყო myBadSingleton = (ფუნქცია () {
// მაგალითად ინახავს მინიშნება Singleton
var მაგალითად;
ფუნქცია init() {
// Singleton
var privateRandomNumber = Math.random();
return {
getRandomNumber: ფუნქცია() {
დაბრუნდეს privateRandomNumber;
}
};
};
return {
// ყოველთვის ახალი Singleton მაგალითად
getInstance: ფუნქცია () {
მაგალითად = init();
დაბრუნდეს მაგალითად;
}
};
})();
// გამოყენება:
იყო single1 = mySingleton.getInstance();
იყო single2 = mySingleton.getInstance();
console.log( singleA.getRandomNumber() === singleB.getRandomNumber() ); // ნამდვილი
var badSingle1 = myBadSingleton.getInstance();
var badSingle2 = myBadSingleton.getInstance();
console.log( badSingleA.getRandomNumber() !== badSingleB.getRandomNumber() ); // ნამდვილი
[/Code]
რაც შეეხება გ, singleton გამოიყენება შემდეგ შემთხვევებში:
- უნდა არსებობდეს სწორედ ინსტანციის ობიექტი.
- ერთადერთი მაგალითად უნდა გააფართოვოთ საქვეუწყებო classing ეს.
დამკვირვებელთა Pattern:
დამკვირვებლის ნიმუში, the object (ასევე მოუწოდა როგორც საგანი) ინარჩუნებს სია ობიექტების დამოკიდებულია იგი მოიხსენიება, როგორც დამკვირვებლები. სათაური ავტომატურად აცნობებს დამკვირვებლებს ნებისმიერი ცვლილება, რომელიც მოხდა, გამოყენებით სამაუწყებლო მექანიზმი. განხორციელება დამკვირვებელთა Pattern არის ნაჩვენები ქვემოთ.
Listing 4: სია დამოკიდებული დამკვირვებლები საგანი შეიძლება ჰქონდეს
[Code]
ფუნქცია ObserverList(){ this.observerList = [];} ObserverList.prototype.Add = function( obj ){ return this.observerList.push( obj );}; ObserverList.prototype.Empty = function(){ this.observerList = [];}; ObserverList.prototype.Count = function(){ return this.observerList.length;}; ObserverList.prototype.Get = function( index ){ თუ( index > -1 && index < this.observerList.length ){ return this.observerList[ index ]; }}; ObserverList.prototype.Insert = function( obj, index ){ var pointer = -1; თუ( ინდექსი === 0 ){ this.observerList.unshift( obj ); pointer = index; }სხვაგან, თუ( ინდექსი === this.observerList.length ){ this.observerList.push( obj ); pointer = index; } return pointer;}; ObserverList.prototype.IndexOf = function( obj, startIndex ){ var i = startIndex, მაჩვენებელი = -1; ხოლო( i < this.observerList.length ){ თუ( this.observerList[i] === obj ){ pointer = i; } i ; } return pointer;}; ObserverList.prototype.RemoveAt = function( index ){ თუ( ინდექსი === 0 ){ this.observerList.shift(); }სხვაგან, თუ( ინდექსი === this.observerList.length -1 ){ this.observerList.pop(); }}; // Extend an object with an extensionfunction extend( extension, obj ){ ამისთვის ( var გასაღები გაფართოება ){ obj[key] = გაფართოება[key]; }}
[/Code]
Listing 5: თემატიკა
[Code]
ფუნქცია თემა(){ this.observers = new ObserverList();} Subject.prototype.AddObserver = function( დამკვირვებელი ){ this.observers.Add( დამკვირვებელი );}; Subject.prototype.RemoveObserver = function( დამკვირვებელი ){ this.observers.RemoveAt( this.observers.IndexOf( დამკვირვებელი, 0 ) );}; Subject.prototype.Notify = function( კონტექსტში ){ var observerCount = this.observers.Count(); ამისთვის(var i=0; i < observerCount; i ){ this.observers.Get(i).განახლების( კონტექსტში ); }};
[/Code]
ზემოთ მაგალითად, გამოყენებით დამკვირვებელთა კომპონენტები, ჩვენ ახლა განვსაზღვროთ:
- ღილაკი და დასძინა, ახალი შემოწმებადი checkboxes გვერდზე
- კონტროლის ჩამრთველი, რომელიც იმოქმედებს, როგორც საგანი, აცნობებს სხვა checkboxes ისინი უნდა შემოწმდეს
- კონტეინერი ახალი checkboxes მიმდინარეობს დასძინა,
HTML კოდი არის როგორც ქვეშ
Listing 5: HTML კოდი
[Code]
<ღილაკს id =”addNewObserver”>ახალი დამკვირვებელთა ჩამრთველი</ღილაკს><input id =”mainCheckbox” type =”ჩამრთველი”/><div id =”observersContainer”></div>
[/Code]
Summary: ასე რომ, ამ მუხლის მე დეტალები განიხილეს შესახებ JavaScript დიზაინის ნიმუშები. დიზაინის მოდელი გამოიყენება ყველა სახის ენებზე, როგორიცაა ობიექტზე ორიენტირებული ენის java და სკრიფტინგის ენა, როგორიცაა JavaScript. მაგრამ არსებობს განსხვავებები და ჩვენ ვნახეთ, ეს მაგალითები ზემოთ. ასე რომ, უნდა დავასკვნათ, დისკუსია შეიძლება ითქვას, რომ დიზაინის ნიმუშები აწვდიდნენ გამოსავალი გავრცელებული პრობლემები. და გთხოვთ გახსოვდეთ, რომ დიზაინი ნიმუშებია
- დადასტურებული გადაწყვეტა
- მარტივად შეიძლება გამოყენებული
- გამომხატველი
იმედი მაქვს, რომ თქვენ არ ესმოდა ცნებები და იგი დაგეხმარებათ განახორციელოს ეს თქვენი პროექტი. Happy მოსმენით.
სხვა საინტერესო სტატიები JS — თქვენ უნდა წაიკითხოთ
