Prinsip Pengasingan Antara Muka (ISP) ialah salah satu prinsip SOLID dalam pengaturcaraan berorientasikan objek, yang memfokuskan pada mereka bentuk antara muka supaya tiada kelas dipaksa untuk melaksanakan kaedah yang tidak diperlukan.
Dalam istilah mudah, ISP mencadangkan bahawa daripada mencipta antara muka yang besar dan merangkumi semua, kita harus mereka bentuk antara muka yang lebih kecil dan lebih fokus. Ini memastikan bahawa setiap kelas hanya melaksanakan kaedah yang sebenarnya diperlukan.
Jika antara muka yang besar mengandungi banyak fungsi, tetapi kelas tidak memerlukan semua fungsi itu, ia masih perlu melaksanakan kesemuanya—walaupun ada yang tidak diperlukan. ISP mencadangkan bahawa kita harus membahagikan antara muka yang besar itu kepada yang lebih kecil dan lebih fokus. Dengan cara ini, setiap kelas hanya boleh melaksanakan fungsi yang sebenarnya diperlukan dan mengelak daripada melaksanakan fungsi yang tidak perlu.
Dengan mengikuti pendekatan ini, kerumitan kod dikurangkan, menjadikannya lebih mudah untuk difahami dan diselenggara.
Memecahkan antara muka yang besar dan kompleks kepada antara muka yang lebih kecil dan lebih spesifik.
Memastikan kelas tidak perlu melaksanakan fungsi yang tidak perlu.
Mengelakkan daripada meletakkan tanggungjawab yang tidak wajar pada kelas, menghasilkan kod yang lebih bersih dan lebih mudah difahami.
Jika antara muka mempunyai 10 kaedah, tetapi kelas tertentu hanya memerlukan 2 daripadanya, ISP mengesyorkan memisahkan antara muka yang besar ini. Dengan cara ini, setiap kelas hanya boleh melaksanakan kaedah yang diperlukan, tanpa perlu melaksanakan yang lain.
Katakan kami mempunyai antara muka Pekerja yang digunakan untuk semua jenis tugas:
Kod Java:
interface Worker {
void work();
void eat();
}
Kini, terdapat dua kelas: HumanWorker dan RobotWorker. HumanWorker boleh makan dan bekerja, tetapi RobotWorker tidak boleh makan. Namun, RobotWorker perlu melaksanakan kaedah eat(), yang melanggar ISP:
Kod Java:
class HumanWorker implements Worker {
public void work() {
System.out.println("Human is working");
}
public void eat() {
System.out.println("Human is eating");
}
}
class RobotWorker implements Worker {
public void work() {
System.out.println("Robot is working");
}
public void eat() {
// Robot can't eat, but still needs to implement this method
}
}
Kami boleh menyelesaikan masalah ini menggunakan ISP dengan mencipta antara muka yang berasingan untuk berfungsi Boleh Kerja dan Boleh Dimakan:
Kod Java:
interface Workable {
void work();
}
interface Eatable {
void eat();
}
class HumanWorker implements Workable, Eatable {
public void work() {
System.out.println("Human is working");
}
public void eat() {
System.out.println("Human is eating");
}
}
class RobotWorker implements Workable {
public void work() {
System.out.println("Robot is working");
}
}
Kini, RobotWorker tidak perlu lagi melaksanakan kaedah eat() yang tidak perlu, mematuhi Prinsip Pengasingan Antara Muka (ISP).
Katakan terdapat antara muka mesin yang boleh berjalan dan mengecas semula:
Kod JavaScript:
class Machine {
run() {
console.log("Machine is running");
}
recharge() {
console.log("Machine is recharging");
}
}
Namun, sesetengah mesin hanya boleh berjalan tetapi tidak boleh mengecas semula. Menurut ISP, kita harus memisahkan tanggungjawab mengecas semula kepada antara muka yang berbeza:
Kod JavaScript:
class RunnableMachine {
run() {
console.log("Machine is running");
}
}
class RechargeableMachine {
recharge() {
console.log("Machine is recharging");
}
}
Kini, mesin yang tidak perlu mengecas semula hanya melaksanakan kaedah run(), manakala mesin boleh dicas semula melaksanakan kaedah recharge(). Pemisahan ini mengikut Prinsip Pengasingan Antara Muka (ISP).
Katakan terdapat kelas Pencetak yang boleh mencetak dan mengimbas:
Kod JavaScript:
class Printer {
print() {
console.log("Printing...");
}
scan() {
console.log("Scanning...");
}
}
Namun, tidak semua pencetak mempunyai keupayaan untuk mengimbas. Dalam kes ini, kita boleh memisahkan kaedah yang diperlukan kepada antara muka yang berbeza:
Kod JavaScript:
class PrintOnly {
print() {
console.log("Printing...");
}
}
class ScanAndPrint {
print() {
console.log("Printing...");
}
scan() {
console.log("Scanning...");
}
}
Kini, pencetak yang hanya memerlukan fungsi cetakan akan melaksanakan kelas PrintOnly, manakala pencetak yang memerlukan kedua-dua pencetakan dan pengimbasan akan melaksanakan kelas ScanAndPrint. Reka bentuk ini mematuhi Prinsip Pengasingan Antara Muka (ISP), memastikan setiap kelas hanya melaksanakan perkara yang benar-benar diperlukan.
Katakanlah kami mempunyai kelas Kenderaan yang boleh memandu dan terbang:
Kod JavaScript:
class Vehicle {
drive() {
console.log("Driving...");
}
fly() {
console.log("Flying...");
}
}
Namun, tidak semua kenderaan boleh terbang. Untuk menyelesaikannya, kami boleh mencipta antara muka berasingan:
Kod JavaScript:
class DriveOnly {
drive() {
console.log("Driving...");
}
}
class FlyAndDrive {
drive() {
console.log("Driving...");
}
fly() {
console.log("Flying...");
}
}
Kini, kenderaan yang hanya boleh memandu akan melaksanakan kelas DriveOnly, manakala kenderaan yang boleh memandu dan terbang akan melaksanakan kelas FlyAndDrive. Penyelesaian ini mengikut Prinsip Pengasingan Antara Muka (ISP), memastikan kelas hanya melaksanakan fungsi yang mereka perlukan.
Meningkatkan Kebolehselenggaraan Kod: ISP memastikan bahawa kelas hanya diperlukan untuk melaksanakan kaedah yang mereka perlukan. Ini menjadikan kod lebih mudah untuk diselenggara kerana kelas tidak bersepah dengan kaedah yang tidak perlu.
Penggunaan Antara Muka Khusus: Dengan menggunakan antara muka yang lebih kecil dan lebih fokus berbanding antara muka yang besar dan umum, pembangunan menjadi lebih cekap kerana tidak perlu berurusan dengan fungsi yang tidak diperlukan.
Penyelesaian Kehidupan Sebenar: Bayangkan anda bekerja dengan pelbagai jenis peranti seperti pencetak, pengimbas dan peranti berbilang fungsi. Setiap peranti mempunyai set tugasan tersendiri. Menggunakan ISP, anda boleh mencipta antara muka yang berasingan untuk setiap tugasan (cth., mencetak, mengimbas) supaya setiap peranti hanya melaksanakan fungsi yang diperlukannya. Ini memastikan kod bersih dan teratur.
Apabila berbilang kelas mempunyai keperluan yang berbeza, bukannya menggunakan antara muka umum yang besar, anda harus memecahkannya kepada antara muka yang lebih kecil dan lebih khusus.
Jika anda perasan bahawa kelas terpaksa melaksanakan kaedah yang tidak diperlukan atau digunakan, anda boleh menggunakan ISP untuk memastikan kelas hanya melaksanakan fungsi yang berkaitan.
Pelaksanaan Kaedah yang Tidak Perlu: Apabila kelas melaksanakan antara muka yang besar tetapi tidak menggunakan semua kaedah, ia terpaksa melaksanakan kaedah yang tidak perlu. Ini membawa kepada kaedah luar dalam kod yang tidak diperlukan.
Peningkatan Kerumitan Kod: Antara muka yang besar boleh menyebabkan tanggungjawab yang berlebihan untuk kelas, menjadikan kod itu tidak perlu rumit. Kerumitan ini menyukarkan untuk mengekalkan kod dan memperkenalkan perubahan baharu boleh menjadi berisiko.
Pelanggaran Tanggungjawab Kelas: Apabila ISP dilanggar, kelas mungkin perlu melaksanakan kaedah yang tidak berkaitan secara langsung dengan fungsi terasnya. Ini juga melanggar Prinsip Tanggungjawab Tunggal (SRP), kerana kelas terlibat dalam tugas di luar peranan utamanya.
Isu Penyelenggaraan dan Kemas Kini: Apabila perubahan dibuat pada antara muka yang besar, semua kelas yang melaksanakan antara muka itu mesti menyesuaikan diri dengan perubahan tersebut. Jika antara muka yang lebih kecil digunakan, hanya kelas yang berkaitan memerlukan kemas kini, menjadikannya lebih mudah untuk mengekalkan konsistensi. Mengekalkan konsistensi sedemikian dengan antara muka yang besar boleh menjadi mencabar.
Kebolehgunaan Semula Kod Menurun: Antara muka yang besar memaksa semua kelas untuk melaksanakan semua kaedah, yang membawa kepada penurunan kebolehgunaan semula. Setiap kelas mungkin mengandungi kod yang tidak diperlukan, yang mengurangkan kebolehgunaan semula keseluruhan kod.
Andaikan anda mempunyai antara muka besar yang dipanggil Worker, yang merangkumi kaedah work() dan eat(). Kini, untuk robot, kaedah eat() tidak diperlukan, tetapi kelas robot masih diperlukan untuk melaksanakannya. Ini melanggar ISP dan mengakibatkan kaedah tidak perlu yang tidak berkaitan dengan fungsi robot.
Oleh itu, melanggar ISP membawa kepada peningkatan kerumitan kod, menyukarkan penyelenggaraan dan memaksa pelaksanaan kaedah yang tidak perlu.
Prinsip Pengasingan Antara Muka (ISP) hanya menyatakan bahawa objek atau komponen tidak boleh dipaksa untuk melaksanakan kaedah yang tidak digunakan. Setiap komponen harus diberikan kaedah atau prop yang relevan dengan keperluan khususnya.
Idea teras ISP ialah pelanggan tidak seharusnya diberikan antara muka atau API yang mereka tidak perlu gunakan. Dalam istilah yang lebih mudah, ia mencadangkan memecahkan antara muka atau kelas yang besar kepada yang lebih kecil, lebih fokus, membenarkan pelanggan menggunakan hanya bahagian yang diperlukan untuk mereka.
Pendekatan ini menggalakkan kod yang lebih bersih, lebih boleh diselenggara dan meningkatkan fleksibiliti sistem dengan memastikan setiap komponen berinteraksi hanya dengan fungsi yang diperlukannya.
Bayangkan sebuah restoran yang mempunyai tiga jenis pelanggan: 1) mereka yang datang untuk makan nasi, 2) mereka yang datang untuk makan pasta, dan 3) mereka yang datang untuk makan salad. Jika kami menyediakan semuanya dengan menu yang sama yang merangkumi semuanya bersama-sama, banyak item akan menjadi tidak relevan kepada sesetengah pelanggan. Ini akan menjadikan menu tidak perlu rumit untuk mereka.
Mengikut Prinsip Pengasingan Antaramuka (ISP), pelanggan yang datang untuk mendapatkan nasi hanya perlu diberikan menu nasi, pemakan pasta hanya perlu menerima menu pasta, dan pemakan salad hanya perlu mendapatkan menu salad. Dengan cara ini, pengalaman dipermudahkan untuk semua orang, membolehkan setiap pelanggan menumpukan pada perkara yang sebenarnya mereka inginkan tanpa sebarang pilihan yang tidak perlu.
Analogi ini menggambarkan bagaimana ISP menggalakkan menyesuaikan antara muka untuk memenuhi keperluan khusus, menjadikan interaksi lebih mudah dan cekap.
In React, we often create large components that contain many props or methods. However, it's common for a component not to need all of those props. According to the Interface Segregation Principle (ISP), components should be broken down into smaller parts so that each component only receives the props and methods that are necessary for its functionality.
By following this principle, you can achieve:
Cleaner Code: Each component remains focused on its specific task, making the codebase easier to understand and maintain.
Improved Reusability: Smaller components can be reused in different contexts without carrying unnecessary props.
Better Performance: Since components only receive what they need, rendering becomes more efficient.
For example, instead of a large UserProfile component that handles both user information and user settings, you could create two separate components: UserInfo and UserSettings. Each component would only receive the relevant props, following the ISP and resulting in a more modular and maintainable structure.
Imagine we have created a large Button component that can perform various actions such as onClick, onHover, onFocus, and more. However, in some cases, we might only need the onClick functionality, but the other functions also come with the component, which we don’t need.
According to the Interface Segregation Principle (ISP), we can break down this large Button component into smaller, more focused components. For example:
JSX code:
const ClickableButton = ({ onClick }) => (
<button onClick={onClick}>Click Me</button>
);
const HoverableButton = ({ onHover }) => (
<button onMouseOver={onHover}>Hover Over Me</button>
);
Imagine we have a large Form component that contains multiple fields (name, address, email, password). However, sometimes we only need the email and password fields, not the entire form component.
According to the Interface Segregation Principle (ISP), we can break down the form into smaller parts. For example:
JSX code:
const EmailField = ({ email, onChange }) => (
<input type="email" value={email} onChange={onChange} />
);
const PasswordField = ({ password, onChange }) => (
<input type="password" value={password} onChange={onChange} />
);
Now, when we only need the email and password, we can use just those specific components instead of the entire form component. This approach allows us to create a more focused and modular structure, adhering to ISP principles.
Imagine we have a large Dashboard component that includes various user information, graphs, and settings. However, there might be a page where we only need the user settings, yet we are using the entire Dashboard component.
According to the Interface Segregation Principle (ISP), we should break down the large Dashboard component into smaller, more focused parts. For example:
JSX code:
const UserInfo = ({ name, email }) => (
<div>
<p>{name}</p>
<p>{email}</p>
</div>
);
const UserSettings = ({ settings }) => (
<div>
<h3>Settings</h3>
{/* Code to display the settings */}
</div>
);
Now, we can utilize these separate parts wherever necessary, allowing us to display only the relevant sections needed for that specific page. This approach ensures that our components are lightweight and tailored to their intended functionality.
Following the Interface Segregation Principle (ISP), React components should be designed as separate, small interfaces or props tailored for specific tasks. This approach allows components to be easier to manage and used only as needed, promoting a more efficient and clean codebase.
By breaking down components into smaller, focused parts, we ensure that each component does one thing well, enhancing maintainability and making it easier to adapt or extend functionality in the future. This method also facilitates better reusability, as developers can select only the components that fit their requirements without carrying unnecessary baggage.
While the Interface Segregation Principle (ISP) has several advantages, it also comes with some limitations. Below are some disadvantages of ISP:
Need for More Interfaces: Following ISP often requires breaking large interfaces into smaller ones. This can lead to the creation of a large number of interfaces, making code management somewhat complex.
Increased Coding and Maintenance: With many interfaces, each one requires a separate implementation. This increases the workload for developers and can take more time. Additionally, making changes later might necessitate updates in multiple places, complicating maintenance.
Risk of Over-Engineering: ISP can sometimes introduce excessive complexity, especially when too many small interfaces are created. This approach may lead to over-engineering, resulting in unnecessary complexity for the project.
Pengurusan Ketergantungan Kompleks: Menggunakan ISP boleh menjadikan komponen atau kelas bergantung pada pelbagai antara muka. Ini boleh merumitkan pengurusan kebergantungan, kerana kebergantungan berbilang timbul daripada beberapa antara muka, menjadikannya sukar untuk menjejakinya.
Apabila menggunakan ISP, isu seperti penciptaan antara muka yang berlebihan, peningkatan pengekodan dan cabaran pengurusan boleh timbul, yang boleh meningkatkan kerumitan projek.
Prinsip Pengasingan Antara Muka (ISP) membantu mengekalkan modulariti dan fleksibiliti dalam pengaturcaraan. Dengan memecahkan antara muka atau komponen yang besar kepada bahagian yang lebih kecil, ia menghapuskan kerumitan yang tidak perlu. Menggunakan ISP membolehkan kami melaksanakan hanya kaedah atau prop yang diperlukan dalam komponen, menjadikan kod lebih mudah, lebih boleh digunakan semula dan boleh diselenggara. Walaupun kadangkala ia boleh membawa kepada peningkatan dalam antara muka dan kod, apabila digunakan dengan betul, ia boleh meningkatkan organisasi dan keberkesanan reka bentuk perisian. Oleh itu, pelaksanaan ISP yang betul adalah penting untuk meningkatkan kualiti dan kejayaan jangka panjang dalam pembangunan perisian.
Atas ialah kandungan terperinci I - Prinsip Pengasingan Antara Muka (ISP). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
