phpcommon comparison
1.0.0
รุ่นล่าสุด: 1.0.0-เบต้า
ไลบรารี PHP 5.4+ เพื่อแสดงความสัมพันธ์และกลยุทธ์ที่เท่าเทียมกันสำหรับการแฮชและการเรียงลำดับค่า
ความสัมพันธ์ที่เท่าเทียมกันมีประโยชน์ในการสร้างวิธีการทั่วไปสำหรับการเปรียบเทียบค่าที่เกี่ยวข้องกับข้อกำหนดเฉพาะโดเมน ตลอดจนเพื่อแสดงเกณฑ์ที่กำหนดเองสำหรับการเปรียบเทียบค่าในบริบทที่มีขอบเขต โดยเฉพาะเพื่อใช้ในคอลเลกชัน
ความสามารถเสริม เช่น การแฮชและการเรียงลำดับ ยังครอบคลุมอยู่ในไลบรารีนี้ ทำให้เป็นส่วนเสริมที่มีคุณค่าสำหรับแถบเครื่องมือการพัฒนาของคุณ
API ได้รับการบันทึกไว้อย่างกว้างขวางในซอร์สโค้ด นอกจากนี้ ยังมีเวอร์ชัน HTML เพื่อการดูที่สะดวกยิ่งขึ้นในเบราว์เซอร์อีกด้วย
ใช้ Composer เพื่อติดตั้งแพ็คเกจ:
$ composer require phpcommon/comparison
ความสัมพันธ์เป็นเครื่องมือทางคณิตศาสตร์สำหรับอธิบายความสัมพันธ์ระหว่างองค์ประกอบของเซต ความสัมพันธ์ถูกนำมาใช้กันอย่างแพร่หลายในวิทยาการคอมพิวเตอร์ โดยเฉพาะอย่างยิ่งในฐานข้อมูลและแอปพลิเคชันการจัดตารางเวลา
ไม่เหมือนกับภาษาสมัยใหม่ส่วนใหญ่ PHP ไม่รองรับการโอเวอร์โหลดของโอเปอเรเตอร์ ซึ่งในอดีตถูกหลีกเลี่ยงในฐานะตัวเลือกการออกแบบ กล่าวอีกนัยหนึ่ง มันเป็นไปไม่ได้ที่จะแทนที่พฤติกรรมเริ่มต้นของตัวดำเนินการดั้งเดิม เช่น เท่ากับ เหมือนกัน มากกว่า น้อยกว่า เป็นต้น ตัวอย่างเช่น Java จัดเตรียมอินเทอร์เฟซที่เปรียบเทียบได้ ในขณะที่ Python จัดเตรียมวิธีการวิเศษบางอย่าง
ความสำคัญของแนวคิดดังกล่าวจะชัดเจนมากขึ้นในสถานการณ์ที่แนวคิดเรื่องความเท่าเทียมกันหรือการเรียงลำดับแตกต่างกันไปตามหัวข้อการเปรียบเทียบหรือบริบท ดังที่อภิปรายในส่วนต่อไปนี้
ในทางคณิตศาสตร์ ความสัมพันธ์ที่เท่าเทียมกันคือความสัมพันธ์แบบไบนารี่ที่มี การสะท้อนกลับ สมมาตร และ สกรรมกริยา อย่างไรก็ตาม ในสาขาคอมพิวเตอร์ มีคุณสมบัติอีกอย่างหนึ่งที่ต้องคำนึงถึง: ความสม่ำเสมอ ความสม่ำเสมอหมายความว่าความสัมพันธ์ไม่ควรให้ผลลัพธ์ที่แตกต่างกันสำหรับอินพุตเดียวกัน
ความสัมพันธ์ที่เท่าเทียมกันทุกหนทุกแห่งคือความสัมพันธ์ที่เท่าเทียมกันระหว่างองค์ประกอบของเซตใดๆ ตัวอย่างอื่นๆ ได้แก่:
สำหรับวัตถุประสงค์ของไลบรารีนี้ ความสัมพันธ์ที่เท่าเทียมกันอาจเป็นแบบทั่วไปหรือแบบเฉพาะเจาะจงก็ได้ ความสัมพันธ์เฉพาะประเภทถูกกำหนดโดยการใช้อินเทอร์เฟซ Equatable หรือ Equivalence ในขณะที่การเทียบเท่าทั่วไปต้องใช้อินเทอร์เฟซสุดท้าย
อินเทอร์เฟซ Equatable กำหนดวิธีการทั่วไปที่คลาสนำไปใช้เพื่อสร้างวิธีการเฉพาะประเภทสำหรับการพิจารณาความเท่าเทียมกันของอินสแตนซ์
เพื่อแสดงให้เห็น ให้พิจารณาคลาส Money ซึ่งมีจุดมุ่งหมายเพื่อแสดงมูลค่าทางการเงิน คลาสนี้เป็นตัวเลือกที่ดีสำหรับการนำอินเทอร์เฟซ Equatable ไปใช้ เนื่องจาก Money คือออบเจ็กต์ค่า นั่นคือ แนวคิดเรื่องความเท่าเทียมกันของออบเจ็กต์เหล่านั้นไม่ได้ขึ้นอยู่กับเอกลักษณ์ ในทางกลับกัน Money สองกรณีจะเท่ากันหากมีค่าเท่ากัน ดังนั้น ในขณะที่ Money::USD(5) === Money::USD(5) ส่งคืน false แต่ Money::USD(5)->equals(Money::USD(5)) ส่งคืน true
นี่คือชั้นเรียนที่กล่าวถึงก่อนหน้านี้:
final class Money implements Equatable
{
private $ amount ;
private $ currency ;
public function __construct ( $ amount , $ currency )
{
$ this -> amount = ( int ) $ amount ;
$ this -> currency = ( string ) $ currency ;
}
public function equals ( Equatable $ other )
{
if (! $ other instanceof self) {
return false ;
}
return $ this -> amount === $ other -> amount && $ this -> currency === $ other -> currency ;
}
}อย่างไรก็ตาม มีหลายกรณีที่จำเป็นต้องมีวิธีการเปรียบเทียบสองค่าที่ไม่ได้มาตรฐานหรือ ภายนอก บางที กรณีการใช้งานที่ชัดเจนที่สุดสำหรับความสัมพันธ์แบบกำหนดเองเหล่านั้นคือการใช้กับคอลเลกชัน แต่ยังมีประโยชน์สำหรับการจัดเตรียมความสามารถเหล่านั้นเพื่อค่าสเกลาร์หรือคลาสที่มีอยู่ซึ่งไม่สามารถจัดเตรียมให้เองได้ เนื่องจากเป็นของแพ็คเกจของบุคคลที่สามหรือสร้างขึ้น ลงใน PHP
สมมติว่าคุณกำลังพัฒนาซอฟต์แวร์เพื่อช่วยโรงพยาบาลในการจัดการการบริจาคโลหิต ข้อกำหนดประการหนึ่งระบุว่าพยาบาลไม่สามารถเก็บเลือดจากผู้บริจาคที่มีกรุ๊ปเลือดเดียวกันได้ ความสัมพันธ์สำหรับสถานการณ์นี้จะมีลักษณะดังนี้:
use PhpCommon Comparison Equivalence ;
class BloodGroupEquivalence implements Equivalence
{
public function equals ( Equatable $ other )
{
return get_class ( $ other ) === static ::class;
}
public function equivalent ( $ left , $ right )
{
if (! $ left instanceof Person) {
UnexpectedTypeException:: forType (Person::class, $ left );
}
if (! $ right instanceof Person) {
return false ;
}
return $ left -> getBloodType () === $ right -> getBloodType ();
}
}ความสัมพันธ์นี้กำหนดว่าคนสองคนมีเลือดกรุ๊ปเดียวกันหรือไม่:
$ equivalence = new BloodGroupEquivalence ();
$ donors = new BloodDonors ( $ equivalence );
$ james = new Person ( ' James ' , ' A ' );
$ john = new Person ( ' John ' , ' A ' );
// James and John are considered equivalent once they are of the same blood group
var_dump ( $ equivalence -> equivalent ( $ james , $ john )); // Outputs bool(true)
// Initially, none of them are present in the collection
var_dump ( $ volunteers -> contains ( $ james )); // Outputs bool(false)
var_dump ( $ volunteers -> contains ( $ john )); // Outputs bool(false)
// Add James to the set of volunteers
$ donors -> add ( $ james );
// Now, considering only the blood group of each donor for equality, both of
// them are considered present in the collection
$ donors -> contains ( $ james ); // Outputs bool(true)
$ donors -> contains ( $ john ); // Outputs bool(true) เนื่องจาก BloodGroupEquivalence สร้างความสัมพันธ์ที่เท่าเทียมกันระหว่างผู้คนตามกลุ่มเลือดของพวกเขา ความพยายามที่จะเพิ่ม John เข้าไปในคอลเลกชันจะถูกเพิกเฉย เนื่องจาก James ปรากฏอยู่แล้วและพวกเขาก็มีกรุ๊ปเลือดเดียวกัน
อาจดูซับซ้อนเล็กน้อยสำหรับข้อกำหนดง่ายๆ ในตอนแรก แต่ในกรณีจริง สามารถใช้เพื่อเปรียบเทียบความเท่าเทียมกันระหว่างหมู่เลือดที่เข้ากันได้ เพื่อแบ่งผู้บริจาคออกเป็นกลุ่มๆ
ไลบรารีนี้จัดเตรียมความสัมพันธ์สมมูลทั่วไปบางส่วนโดยเป็นส่วนหนึ่งของไลบรารีมาตรฐาน ดังที่อธิบายไว้ด้านล่าง
เปรียบเทียบสองค่าสำหรับข้อมูลประจำตัว
ความสัมพันธ์นี้ขึ้นอยู่กับตัวดำเนินการที่เหมือนกัน ในกรณีส่วนใหญ่ ค่าสองค่าจะถือว่าเท่ากันหากมีประเภทและค่าเดียวกัน แต่มีข้อยกเว้นบางประการ:
NAN ไม่เท่ากับค่าอื่นๆ ทั้งหมด รวมถึงตัวมันเองด้วยตารางต่อไปนี้สรุปวิธีการเปรียบเทียบตัวถูกดำเนินการประเภทต่างๆ:
$A $B | โมฆะ | บูลีน | จำนวนเต็ม | ลอย | สตริง | ทรัพยากร | อาร์เรย์ | วัตถุ |
|---|---|---|---|---|---|---|---|---|
| โมฆะ | true | false | false | false | false | false | false | false |
| บูลีน | false | $A === $B | false | false | false | false | false | false |
| จำนวนเต็ม | false | false | $A === $B | false | false | false | false | false |
| ลอย | false | false | false | $A === $B | false | false | false | false |
| สตริง | false | false | false | false | $A === $B | false | false | false |
| ทรัพยากร | false | false | false | false | false | $A === $B | false | false |
| อาร์เรย์ | false | false | false | false | false | false | $A === $B | false |
| วัตถุ | false | false | false | false | false | false | false | $A === $B |
เปรียบเทียบสองค่าเพื่อความเท่าเทียมกัน
ความเท่าเทียมกันของค่าจะมีพฤติกรรมเหมือนกับความเท่าเทียมกันของเอกลักษณ์ ยกเว้นว่าจะมอบหมายการเปรียบเทียบระหว่างวัตถุ Equatable กับวัตถุที่กำลังเปรียบเทียบ นอกจากนี้ ยังสามารถระบุความสัมพันธ์ภายนอกเพื่อเปรียบเทียบค่าประเภทใดประเภทหนึ่งได้ มีประโยชน์ในกรณีที่ต้องการแทนที่ลักษณะการทำงานเริ่มต้นสำหรับประเภทใดประเภทหนึ่ง แต่คงลักษณะอื่นๆ ทั้งหมดไว้ นอกจากนี้ยังมีประโยชน์ในการกำหนดความสัมพันธ์สำหรับอ็อบเจ็กต์ของคลาสที่เป็นของแพ็คเกจของบุคคลที่สามหรือสร้างไว้ใน PHP
กฎต่อไปนี้ใช้เพื่อกำหนดว่าค่าสองค่าถือว่าเท่ากันหรือไม่:
NAN ไม่เท่ากับค่าอื่นๆ ทั้งหมด รวมถึงตัวมันเองด้วยEquatable และนิพจน์ $left->equals($right) ได้รับการประเมินเป็น true$relation->equivalent($left, $right) จะถูกประเมินเป็น trueตารางต่อไปนี้สรุปวิธีการเปรียบเทียบตัวถูกดำเนินการประเภทต่างๆ:
$A $B | โมฆะ | บูลีน | จำนวนเต็ม | ลอย | สตริง | ทรัพยากร | อาร์เรย์ | วัตถุ | เท่าเทียมกัน |
|---|---|---|---|---|---|---|---|---|---|
| โมฆะ | true | false | false | false | false | false | false | false | false |
| บูลีน | false | $A === $B | false | false | false | false | false | false | false |
| จำนวนเต็ม | false | false | $A === $B | false | false | false | false | false | false |
| ลอย | false | false | false | $A === $B | false | false | false | false | false |
| สตริง | false | false | false | false | $A === $B | false | false | false | false |
| ทรัพยากร | false | false | false | false | false | $A === $B | false | false | false |
| อาร์เรย์ | false | false | false | false | false | false | eq($A, $B) | false | false |
| วัตถุ | false | false | false | false | false | false | false | $A === $B | false |
| เท่าเทียมกัน | false | false | false | false | false | false | false | false | $A‑>equals($B) |
โดยที่ eq() หมายถึงฟังก์ชันที่เปรียบเทียบแต่ละคู่ของรายการที่สอดคล้องกันแบบเรียกซ้ำ ตามกฎที่อธิบายไว้ข้างต้น
ความสัมพันธ์นี้ยังให้วิธีการแทนที่ตรรกะความเท่าเทียมกันสำหรับคลาสใดคลาสหนึ่งโดยไม่จำเป็นต้องสร้างความสัมพันธ์ใหม่ ตัวอย่างเช่น สมมติว่าคุณต้องการเปรียบเทียบอินสแตนซ์ของ DateTime ตามค่าของพวกเขา แต่คงลักษณะการทำงานเริ่มต้นสำหรับประเภทอื่นๆ ไว้ สามารถทำได้โดยการระบุความสัมพันธ์แบบกำหนดเองที่จะใช้เมื่อใดก็ตามที่อินสแตนซ์ของ DateTime ถูกเปรียบเทียบกับค่าอื่น:
use PhpCommon Comparison Hasher ValueHasher as ValueEquivalence ;
use PhpCommon Comparison Hasher DateTimeHasher as DateTimeEquivalence ;
use DateTime ;
$ relation = new ValueEquivalence ([
DateTime::class => new DateTimeEquivalence ()
]);
$ date = ' 2017-01-01 ' ;
$ timezone = new DateTimeZone ( ' Pacific/Nauru ' );
$ left = new DateTime ( $ date , $ timezone );
$ right = new DateTime ( $ date , $ timezone );
// Outputs bool(true)
var_dump ( $ relation -> equivalent ( $ left , $ right ));เปรียบเทียบสองค่าสำหรับความเท่าเทียมกันทางความหมาย
มีการวางแผนความเท่าเทียมกันทางความหมายสำหรับเวอร์ชันในอนาคต จะช่วยให้สามารถเปรียบเทียบค่าที่ดูคล้ายกันทางความหมายได้ แม้ว่าค่าเหล่านั้นจะเป็นประเภทที่แตกต่างกันก็ตาม มันคล้ายกับวิธีการทำงานของการเปรียบเทียบแบบหลวมๆ ใน PHP แต่อยู่ภายใต้เงื่อนไขที่เข้มงวดมากขึ้น ในลักษณะที่คุณสมบัติของการสะท้อนกลับ สมมาตร และการส่งผ่านคงอยู่
เปรียบเทียบ DateTime สองอินสแตนซ์ตามวันที่ เวลา และเขตเวลา
ความสัมพันธ์นี้ถือว่าสองอินสแตนซ์ของ DateTime เท่ากันหากมีวันที่ เวลา และเขตเวลาเดียวกัน:
use PhpCommon Comparison Hasher IdentityHasher as IdentityEquivalence ;
use PhpCommon Comparison Hasher DateTimeHasher as DateTimeEquivalence ;
use DateTime ;
$ identity = new IdentityEquivalence ();
$ value = new DateTimeEquivalence ();
$ date = ' 2017-01-01 ' ;
$ timezone = new DateTimeZone ( ' Pacific/Nauru ' );
$ left = new DateTime ( $ date , $ timezone );
$ right = new DateTime ( $ date , $ timezone );
// Outputs bool(false)
var_dump ( $ identity -> equivalent ( $ left , $ right ));
// Outputs bool(true)
var_dump ( $ value -> equivalent ( $ left , $ right ));ใน PHP คีย์อาร์เรย์สามารถแสดงเป็นตัวเลขและสตริงเท่านั้น อย่างไรก็ตาม มีหลายกรณีที่การจัดเก็บประเภทที่ซับซ้อนเป็นคีย์จะมีประโยชน์ ใช้คลาสตัวอย่างที่แสดงตัวเลขหรือสตริงประเภทต่างๆ เช่น อ็อบเจ็กต์ GMP, สตริง Unicode เป็นต้น การใช้อ็อบเจ็กต์ดังกล่าวเป็นคีย์อาร์เรย์จะสะดวกกว่าเช่นกัน
เพื่อเติมเต็มช่องว่างนี้ ไลบรารีนี้แนะนำอินเทอร์เฟซ Hashable และ Hasher ซึ่งระบุโปรโตคอลสำหรับการจัดเตรียมรหัสแฮชสำหรับค่าต่างๆ อินเทอร์เฟซเหล่านี้ไม่จำเป็นต้องมีผู้ดำเนินการเพื่อให้มีฟังก์ชันแฮชที่สมบูรณ์แบบ นั่นคือสองค่าที่ไม่เท่ากันอาจมีรหัสแฮชเดียวกัน อย่างไรก็ตาม เพื่อพิจารณาว่าค่าสองค่าที่มีรหัสแฮชเดียวกันนั้น แท้จริงแล้วเท่ากันหรือไม่ แนวคิดของการแฮชและความเท่าเทียมกันควรนำมารวมกันในลักษณะที่เสริมกัน มันอธิบายว่าทำไม Hasher และ Hashable จึงขยาย Equivalence และ Equatable ตามลำดับ
คำเตือน
รหัสแฮชมีไว้สำหรับการแทรกและการค้นหาที่มีประสิทธิภาพในคอลเลกชันที่อิงตามตารางแฮชและเพื่อการตรวจสอบความไม่เท่าเทียมกันอย่างรวดเร็ว รหัสแฮชไม่ใช่ค่าถาวร ด้วยเหตุนี้:
- อย่าทำให้ค่ารหัสแฮชเป็นอนุกรมหรือเก็บไว้ในฐานข้อมูล
- อย่าใช้รหัสแฮชเป็นกุญแจในการดึงวัตถุจากคอลเลกชันที่คีย์
- อย่าส่งรหัสแฮชข้ามโดเมนแอปพลิเคชันหรือกระบวนการ ในบางกรณี รหัสแฮชอาจถูกคำนวณตามโดเมนต่อกระบวนการหรือต่อแอปพลิเคชัน
- อย่าใช้รหัสแฮชแทนค่าที่ส่งคืนโดยฟังก์ชันแฮชที่เข้ารหัสลับ หากคุณต้องการแฮชที่รัดกุมในการเข้ารหัส
- อย่าทดสอบความเท่าเทียมกันของรหัสแฮชเพื่อตรวจสอบว่าวัตถุทั้งสองเท่ากันหรือไม่ เมื่อค่าที่ไม่เท่ากันสามารถมีรหัสแฮชที่เหมือนกันได้
มีหลายกรณีที่อาจเป็นที่พึงปรารถนาในการกำหนดตรรกะการแฮชแบบกำหนดเองสำหรับคลาสที่ตรงกับความต้องการของคุณมากที่สุด ตัวอย่างเช่น สมมติว่าคุณมีคลาส Point เพื่อแสดงจุด 2D:
namespace PhpCommon Comparison Equatable ;
final class Point implements Equatable
{
private $ x ;
private $ y ;
public function __construct ( $ x , $ y )
{
$ this -> x = ( int ) $ x ;
$ this -> y = ( int ) $ y ;
}
public function equals ( Equatable $ point )
{
if (! $ point instanceof Point) {
return false ;
}
return $ this -> x === $ point -> x && $ this -> y === $ point -> y ;
}
} Point เก็บพิกัด x และ y ของจุด ตามคำจำกัดความของคลาส จุดสองจุดจะถือว่าเท่ากันหากมีพิกัดเดียวกัน อย่างไรก็ตาม หากคุณต้องการจัดเก็บอินสแตนซ์ของ Point ในแผนที่แบบแฮช เนื่องจากคุณต้องการเชื่อมโยงพิกัดกับป้ายกำกับ คุณต้องแน่ใจว่าคลาสของคุณสร้างรหัสแฮชที่ สอดคล้อง กับตรรกะที่ใช้ในการพิจารณาว่าเมื่อใด คะแนนถือว่าเท่ากัน:
namespace PhpCommon Comparison Equatable ;
final class Point implements Hashable
{
private $ x ;
private $ y ;
public function __construct ( $ x , $ y )
{
$ this -> x = ( int ) $ x ;
$ this -> y = ( int ) $ y ;
}
public function equals ( Equatable $ point )
{
if (! $ point instanceof Point) {
return false ;
}
return $ this -> x === $ point -> x && $ this -> y === $ point -> y ;
}
public function getHash ()
{
return 37 * ( 31 + $ this -> $ x ) + $ this -> $ x ;
}
} ด้วยวิธีนี้ เมธอด getHash() จะทำงานตามเมธอด equals() แม้ว่าอัลกอริทึมการแฮชอาจไม่เหมาะก็ตาม การใช้อัลกอริธึมที่มีประสิทธิภาพสำหรับการสร้างโค้ดแฮชอยู่นอกเหนือขอบเขตของคู่มือนี้ อย่างไรก็ตาม ขอแนะนำให้ใช้อัลกอริทึมที่รวดเร็วซึ่งให้ผลลัพธ์ที่แตกต่างกันพอสมควรสำหรับค่าที่ไม่เท่ากัน และเปลี่ยนตรรกะการเปรียบเทียบจำนวนมากเป็น Equatable::equals()
โปรดสังเกตว่าวัตถุที่แฮชได้ควรจะไม่เปลี่ยนรูป หรือคุณจำเป็นต้องมีวินัยในการไม่เปลี่ยนแปลงวัตถุเหล่านั้นหลังจากที่พวกมันถูกใช้ในโครงสร้างแบบแฮชแล้ว
Hasher มีฟังก์ชันแฮชสำหรับประเภทดั้งเดิมและอ็อบเจ็กต์ของคลาสที่ไม่ได้ใช้ Hashable
วิธีการ hash() ที่แนะนำโดยอินเทอร์เฟซนี้มีวัตถุประสงค์เพื่อให้วิธีการสำหรับการดำเนินการตรวจสอบ ความไม่เท่าเทียมกัน อย่างรวดเร็วและการแทรกและการค้นหาที่มีประสิทธิภาพในโครงสร้างข้อมูลแบบแฮช เมธอดนี้จะ เชื่อมโยง กับ equivalent() เสมอ ซึ่งหมายความว่าสำหรับการอ้างอิงใด ๆ $x และ $y ถ้า equivalent($x, $y) แล้ว hash($x) === hash($y) อย่างไรก็ตาม หาก equivalence($x, $y) ประเมินเป็น false , hash($x) === hash($y) อาจจะยังคงเป็นจริง ดังนั้นเหตุใดเมธอด hash() จึงเหมาะสำหรับการตรวจสอบ ความไม่สมดุล แต่ไม่ใช่การตรวจสอบ ความเท่าเทียมกัน
การใช้งาน Equivalence ทั้งหมดที่รวมอยู่ในไลบรารีนี้ยังมีฟังก์ชันการแฮชอีกด้วย ข้อมูลเพิ่มเติมเกี่ยวกับวิธีการแฮชค่าสามารถพบได้ในเอกสารประกอบการใช้งานที่เกี่ยวข้อง
ตามตรรกะเดียวกันของแนวคิดที่กล่าวถึงก่อนหน้านี้ Comparable และ Comparator เป็นอินเทอร์เฟซที่ให้กลยุทธ์การเรียงลำดับ ที่เป็นธรรมชาติ และกำหนดเองตามลำดับ อินเทอร์เฟซทั้งสองระบุความสัมพันธ์ลำดับทั้งหมด ความสัมพันธ์ที่ สะท้อนกลับ ต่อต้านสมมาตร และ สกรรมกริยา
อินเทอร์เฟซนี้กำหนดลำดับรวมบนออบเจ็กต์ของแต่ละคลาสที่นำไปใช้ การจัดลำดับนี้เรียกว่า การเรียงลำดับตามธรรมชาติ ของคลาส และเมธอด Comparable::compareTo() เรียกว่า วิธีการเปรียบเทียบตามธรรมชาติ
ตัวอย่างต่อไปนี้แสดงให้เห็นว่าคลาสสามารถกำหนดลำดับตามธรรมชาติของอินสแตนซ์ได้อย่างไร:
use PhpCommon Comparison UnexpectedTypeException ;
final class BigInteger implements Comparable
{
private $ value ;
public function __construct ( $ value )
{
$ this -> value = ( string ) $ value ;
}
public function compareTo ( Comparable $ other )
{
if (! $ other instanceof self) {
throw UnexpectedTypeException:: forType (BigInteger::class, $ other );
}
return bccomp ( $ this -> value , $ other -> value );
}
} วัตถุประสงค์ของเครื่องมือ Comparator คือเพื่อให้คุณสามารถกำหนดกลยุทธ์การเปรียบเทียบตั้งแต่หนึ่งกลยุทธ์ขึ้นไปที่ไม่ใช่กลยุทธ์การเปรียบเทียบทั่วไปสำหรับชั้นเรียน ตามหลักการแล้ว ตัว Comparator จะต้องถูกนำไปใช้โดยคลาสที่แตกต่างจากคลาสที่กำหนดกลยุทธ์การเปรียบเทียบ หากคุณต้องการกำหนดกลยุทธ์การเปรียบเทียบที่เป็นธรรมชาติสำหรับคลาส คุณสามารถใช้ Comparable แทนได้
ตัวเปรียบเทียบสามารถส่งผ่านไปยังวิธีการเรียงลำดับของคอลเลกชันเพื่อให้สามารถควบคุมลำดับการจัดเรียงได้อย่างแม่นยำ นอกจากนี้ยังสามารถใช้เพื่อควบคุมลำดับของโครงสร้างข้อมูลบางอย่าง เช่น ชุดที่เรียงลำดับหรือแผนที่ที่เรียงลำดับ ตัวอย่างเช่น พิจารณาตัวเปรียบเทียบต่อไปนี้ที่เรียงลำดับสตริงตามความยาว:
use PhpCommon Comparison Comparator ;
class StringLengthComparator implements Comparator
{
public function compare ( $ left , $ right )
{
return strlen ( $ left ) <=> strlen ( $ right );
}
}
$ comparator = new StringLengthComparator ();
// Outputs int(-1)
var_dump ( $ comparator -> compare ( ' ab ' , ' a ' ));การใช้งานนี้แสดงถึงหนึ่งในหลายวิธีที่เป็นไปได้ในการเรียงลำดับสตริง กลยุทธ์อื่นๆ ได้แก่ การเรียงลำดับตามตัวอักษร พจนานุกรม ฯลฯ
โปรดดู CHANGELOG สำหรับข้อมูลเพิ่มเติมว่ามีอะไรเปลี่ยนแปลงเมื่อเร็วๆ นี้
$ composer testตรวจสอบเอกสารการทดสอบสำหรับรายละเอียดเพิ่มเติม
ยินดีต้อนรับการมีส่วนร่วมในแพ็คเกจเสมอ!
โปรดดูรายละเอียดที่การมีส่วนร่วมและการปฏิบัติ
หากคุณพบปัญหาที่เกี่ยวข้องกับความปลอดภัย โปรดส่งอีเมลมาที่ [email protected] แทนการใช้ตัวติดตามปัญหา
เนื้อหาทั้งหมดของแพ็คเกจนี้ได้รับอนุญาตภายใต้ใบอนุญาต MIT
