หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

ค้นหาเป็นกลุ่ม

ไลบรารีการค้นหาข้อความแบบเต็มที่ปรับให้มีน้ำหนักเบาและอ่าน-เขียนได้ดีที่สุด

เมื่อพูดถึง ความเร็วโดยรวม BulkSearch มีประสิทธิภาพเหนือกว่าไลบรารีการค้นหาทุกแห่งที่มีอยู่ และยังให้ความสามารถในการค้นหาที่ยืดหยุ่น เช่น การจับคู่หลายคำ การแปลงการออกเสียง หรือการจับคู่บางส่วน โดยพื้นฐานแล้วจะขึ้นอยู่กับวิธีที่ HDD จัดการไฟล์ในระบบไฟล์ การเพิ่ม การอัปเดต หรือการลบรายการต่างๆ นั้นทำได้รวดเร็วพอๆ กับการค้นหา แต่ยังต้องใช้หน่วยความจำเพิ่มเติมอีกด้วย เมื่อดัชนีของคุณไม่จำเป็นต้องอัปเดตบ่อยๆ FlexSearch อาจเป็นตัวเลือกที่ดีกว่า BulkSearch ยังมีโมเดลการประมวลผลแบบอะซิงโครนัสให้คุณดำเนินการสืบค้นในเบื้องหลัง

เกณฑ์มาตรฐาน:

  • การเปรียบเทียบ: https://jsperf.com/compare-search-libraries
  • รายละเอียด: https://jsperf.com/bulksearch

แพลตฟอร์มที่รองรับ:

  • เบราว์เซอร์
  • โหนด js

คำจำกัดความของโมดูลที่รองรับ:

  • เอเอ็มดี (ต้องการ JS)
  • CommonJS (โหนด js)
  • ปิด (Xone)
  • ทั่วโลก (เบราว์เซอร์)

คุณสมบัติทั้งหมด:

  • คำบางส่วน
  • หลายคำ
  • ลำดับคำที่ยืดหยุ่น
  • ค้นหาแบบออกเสียง
  • จำกัดผลลัพธ์
  • การแบ่งหน้า
  • การแคช
  • โหมดอะซิงโครนัส
  • ตัวจับคู่แบบกำหนดเอง
  • ตัวเข้ารหัสแบบกำหนดเอง

การติดตั้ง

HTML / จาวาสคริปต์ 
 < html >
< head >
    < script src =" js/bulksearch.min.js " > </ script >
</ head >
...

หมายเหตุ: ใช้ Bulksearch.min.js สำหรับการผลิต และ Bulksearch.js สำหรับการพัฒนา

ใช้ล่าสุดจาก CDN: 

 < script src =" https://cdn.rawgit.com/nextapps-de/bulksearch/master/bulksearch.min.js " > </ script >
โหนด js 
 npm install bulksearch

ในรหัสของคุณมีดังนี้: 

 var BulkSearch = require ( "bulksearch" ) ;

หรือส่งตัวเลือกเมื่อต้องการ: 

 var index = require ( "bulksearch" ) . create ( { /* options */ } ) ;

เอเอ็มดี 

 var BulkSearch = require ( "./bulksearch.js" ) ;

เปรียบเทียบ BulkSearch กับ FlexSearch

คำอธิบาย ค้นหาเป็นกลุ่ม FlexSearch
เข้าถึง ดัชนีเพิ่มประสิทธิภาพการอ่าน-เขียน ดัชนีเพิ่มประสิทธิภาพการอ่านหน่วยความจำ
หน่วยความจำ ใหญ่ (~ 90 ไบต์ต่อคำ) เล็ก (~ 2 ไบต์ต่อคำ)
การใช้งาน
  • เนื้อหามีจำกัด
  • ดัชนีอัพเดทอย่างต่อเนื่อง
  • การค้นหาที่เร็วที่สุดที่เป็นไปได้
  • การอัปเดตที่หายากในดัชนี
  • ความสามารถของหน่วยความจำเหลือน้อย
จำกัดผลลัพธ์ ใช่ ใช่
การแบ่งหน้า ใช่ เลขที่

ภาพรวมของ API

วิธีการทั่วโลก:

  • ค้นหาเป็นกลุ่ม สร้าง (<ตัวเลือก>)
  • ค้นหาเป็นกลุ่ม addMatcher ({ คีย์: มูลค่า })
  • ค้นหาเป็นกลุ่ม ลงทะเบียน (ชื่อ, ตัวเข้ารหัส)
  • ค้นหาเป็นกลุ่ม เข้ารหัส (ชื่อ, สตริง)

วิธีการจัดทำดัชนี:

  • ดัชนี. เพิ่ม (id, สตริง)
  • ดัชนี. ค้นหา (สตริง <จำกัด>, <โทรกลับ>)
  • ดัชนี. ค้นหา (สตริง <หน้า> <โทรกลับ>)
  • ดัชนี. ค้นหา (ตัวเลือก <โทรกลับ>)
  • ดัชนี. อัปเดต (id, สตริง)
  • ดัชนี. ลบ (รหัส)
  • ดัชนี. รีเซ็ต ()
  • ดัชนี. ทำลาย ()
  • ดัชนี. เริ่มต้น (<ตัวเลือก>)
  • ดัชนี. ปรับให้เหมาะสม ()
  • ดัชนี. ข้อมูล ()
  • ดัชนี. addMatcher ({ คีย์: มูลค่า })
  • ดัชนี. เข้ารหัส (สตริง)

การใช้งาน

สร้างดัชนี

ค้นหาเป็นกลุ่ม สร้าง(<ตัวเลือก>) 

 var index = new BulkSearch ( ) ;

หรือคุณสามารถใช้: 

 var index = BulkSearch . create ( ) ;
สร้างดัชนีด้วยตัวเลือกที่กำหนดเอง 
 var index = new BulkSearch ( {

    // default values:

    type : "integer" ,
    encode : "icase" ,
    boolean : "and" ,
    size : 4000 ,
    multi : false ,
    strict : false ,
    ordered : false ,
    paging : false ,
    async : false ,
    cache : false
} ) ;

อ่านเพิ่มเติม: การค้นหาการออกเสียง การเปรียบเทียบการออกเสียง ปรับปรุงการใช้หน่วยความจำ

เพิ่มรายการลงในดัชนี

ดัชนี. เพิ่ม (id, สตริง) 

 index . add ( 10025 , "John Doe" ) ;

ค้นหารายการ

ดัชนี. ค้นหา (สตริง | ตัวเลือก <จำกัด | หน้า>, <โทรกลับ>) 

 index . search ( "John" ) ;

จำกัดผลลัพธ์: 

 index . search ( "John" , 10 ) ;

ดำเนินการค้นหาแบบอะซิงโครนัส: 

 index . search ( "John" , function ( result ) {
    
    // array of results
} ) ;

ส่งพารามิเตอร์เป็นวัตถุ: 

 index . search ( {

    query : "John" , 
    page : '1:1234' ,
    limit : 10 ,
    callback : function ( result ) {
        
        // async
    }
} ) ;

อัปเดตรายการจากดัชนี

ดัชนี. อัปเดต (id, สตริง) 

 index . update ( 10025 , "Road Runner" ) ;

ลบรายการออกจากดัชนี

ดัชนี. ลบ(รหัส) 

 index . remove ( 10025 ) ;

รีเซ็ตดัชนี 

 index . reset ( ) ;

ทำลายดัชนี 

 index . destroy ( ) ;

เริ่มต้นดัชนีอีกครั้ง

ดัชนี. เริ่มต้น(<ตัวเลือก>)

หมายเหตุ: การเริ่มต้นใหม่จะทำลายดัชนีเก่าด้วย!

เริ่มต้น (ด้วยตัวเลือกเดียวกัน): 

 index . init ( ) ;

เริ่มต้นด้วยตัวเลือกใหม่: 

 index . init ( {

    /* options */
} ) ;

เพิ่มตัวจับคู่ที่กำหนดเอง

ค้นหาเป็นกลุ่ม addMatcher ({ REGEX: แทนที่ })

เพิ่มตัวจับคู่สากลสำหรับทุกอินสแตนซ์: 

 BulkSearch . addMatcher ( {

    'ä' : 'a' , // replaces all 'ä' to 'a'
    'ó' : 'o' ,
    '[ûúù]' : 'u' // replaces multiple
} ) ;

เพิ่มตัวจับคู่ส่วนตัวสำหรับอินสแตนซ์เฉพาะ: 

 index . addMatcher ( {

    'ä' : 'a' , // replaces all 'ä' to 'a'
    'ó' : 'o' ,
    '[ûúù]' : 'u' // replaces multiple
} ) ;

เพิ่มตัวเข้ารหัสที่กำหนดเอง

กำหนดตัวเข้ารหัสแบบกำหนดเองส่วนตัวระหว่างการสร้าง/การเริ่มต้น: 

 var index = new BulkSearch ( {

    encode : function ( str ) {
    
        // do something with str ...
        
        return str ;
    }
} ) ;
ลงทะเบียนตัวเข้ารหัสส่วนกลางที่จะใช้กับทุกอินสแตนซ์

ค้นหาเป็นกลุ่ม ลงทะเบียน (ชื่อ, ตัวเข้ารหัส) 

 BulkSearch . register ( 'whitespace' , function ( str ) {

    return str . replace ( / / g , '' ) ;
} ) ;

ใช้ตัวเข้ารหัสทั่วโลก: 

 var index = new BulkSearch ( { encode : 'whitespace' } ) ;
โทรเข้ารหัสโดยตรง

ตัวเข้ารหัสส่วนตัว: 

 var encoded = index . encode ( "sample text" ) ;

ตัวเข้ารหัสสากล: 

 var encoded = BulkSearch . encode ( "whitespace" , "sample text" ) ;
ผสม/ขยายตัวเข้ารหัสหลายตัว 
 BulkSearch . register ( 'mixed' , function ( str ) {
  
    str = this . encode ( "icase" , str ) ;  // built-in
    str = this . encode ( "whitespace" , str ) ; // custom
    
    return str ;
} ) ; 
 BulkSearch . register ( 'extended' , function ( str ) {
  
    str = this . encode ( "custom" , str ) ;
    
    // do something additional with str ...

    return str ;
} ) ;

รับข้อมูล 

 index . info ( ) ;

ส่งกลับข้อมูลเกี่ยวกับดัชนีเช่น: 

{
    "bytes" : 103600 ,
    "chunks" : 9 ,
    "fragmentation" : 0 ,
    "fragments" : 0 ,
    "id" : 0 ,
    "length" : 7798 ,
    "matchers" : 0 ,
    "size" : 10000 ,
    "status" : false
}

หมายเหตุ: เมื่อค่าการกระจายตัวอยู่ที่ประมาณ 50% หรือสูงกว่า คุณควรพิจารณาใช้ cleanup()

ดัชนีเพิ่มประสิทธิภาพ / การล้างข้อมูล

การปรับดัชนีให้เหมาะสมจะทำให้หน่วยความจำที่กระจัดกระจายทั้งหมดว่างและสร้างดัชนีใหม่ด้วยการให้คะแนน 

 index . optimize ( ) ;

การแบ่งหน้า

หมายเหตุ: การแบ่งหน้าสามารถลดเวลาในการสืบค้นลงได้เพียง 100 เท่า

เปิดใช้งานการแบ่งหน้าในการเริ่มต้น: 

 var index = BulkSearch . create ( { paging : true } ) ;

ดำเนินการค้นหาและผ่านขีดจำกัด (รายการต่อหน้า): 

 index . search ( "John" , 10 ) ;

การตอบสนองจะรวมถึงวัตถุการแบ่งหน้าดังนี้: 

{
    "current" : " 0:0 " ,
    "prev" : null ,
    "next" : " 1:16322 " ,
    "results" : []
}

คำอธิบาย:

"ปัจจุบัน" รวมตัวชี้ไปยังหน้าปัจจุบัน
"ก่อนหน้า" รวมตัวชี้ไปยังหน้าก่อนหน้า เมื่อใดก็ตามที่ฟิลด์นี้มีค่า เป็นโมฆะ ก็จะไม่มีหน้าก่อนหน้าอีกต่อไป
"ต่อไป" รวมถึงตัวชี้ไปยังหน้าถัดไป เมื่อใดก็ตามที่ฟิลด์นี้มีค่า เป็นโมฆะ จะไม่มีหน้าเหลืออีกต่อไป
"ผลลัพธ์" อาร์เรย์ของรายการที่ตรงกัน

ดำเนินการค้นหาและส่งตัวชี้ไปยังหน้าเฉพาะ: 

 index . search ( "John" , {
    
    page : "1:16322" , // pointer
    limit : 10
} ) ;

ตัวเลือก

ตัวเลือก ค่านิยม คำอธิบาย
พิมพ์ "ไบต์"
"สั้น"
"จำนวนเต็ม"
"ลอย"
"สตริง"		 ต้องระบุประเภทข้อมูลของ ID ที่ส่งผ่านในการสร้าง ขอแนะนำให้ใช้ช่วงข้อมูลที่ต่ำที่สุดที่เป็นไปได้ เช่น ใช้ "สั้น" เมื่อรหัสไม่สูงกว่า 65,535
เข้ารหัส เท็จ
"ไอเคส"
"เรียบง่าย"
"ขั้นสูง"
"พิเศษ"
ฟังก์ชัน(สตริง):สตริง		 ประเภทการเข้ารหัส เลือกหนึ่งในบิวด์อินหรือส่งฟังก์ชันการเข้ารหัสแบบกำหนดเอง
บูลีน "และ"
"หรือ"		 รูปแบบบูลีนที่ใช้เมื่อเปรียบเทียบคำหลายคำ หมายเหตุ: เมื่อใช้ "หรือ" คำแรกจะถูกเปรียบเทียบกับ "และ" ด้วย ตัวอย่าง: แบบสอบถามที่มี 3 คำ ผลลัพธ์มีทั้ง: ตรงกับคำ 1 และ 2 และคำที่ตรงกัน 1 และ 3
ขนาด 2500 - 10,000 ขนาดของชิ้น. ขึ้นอยู่กับความยาวของเนื้อหาว่าค่าใดเหมาะสมที่สุด ความยาวเนื้อหาสั้น (เช่น ชื่อผู้ใช้) จะเร็วขึ้นด้วยขนาดก้อน 2,500 ข้อความที่ใหญ่กว่าจะทำงานได้เร็วขึ้นด้วยขนาดก้อน 10,000 หมายเหตุ: ขอแนะนำให้ใช้ขนาดชิ้นขั้นต่ำของความยาวเนื้อหาสูงสุดซึ่งจะต้องมีการจัดทำดัชนีเพื่อป้องกันการกระจายตัว
หลาย จริง
เท็จ		 เปิดใช้งานการประมวลผลคำหลายคำ
สั่ง จริง
เท็จ		 คำหลายคำจะต้องอยู่ในลำดับเดียวกันกับรายการที่ตรงกัน
เข้มงวด จริง
เท็จ		 การจับคู่ต้องเริ่มต้นด้วยข้อความค้นหาทุกประการ
แคช จริง
เท็จ		 เปิดใช้งานการแคช

การเข้ารหัสการออกเสียง

ตัวเข้ารหัส คำอธิบาย ผลบวกลวง ระดับการบีบอัด
เท็จ ปิดการเข้ารหัส เลขที่ เลขที่
"ไอเคส" การเข้ารหัสแบบคำนึงถึงขนาดตัวพิมพ์ เลขที่ เลขที่
"เรียบง่าย" การทำให้เป็นมาตรฐานการออกเสียง เลขที่ ~ 3%
"ขั้นสูง" การทำให้เป็นมาตรฐานทางการสัทศาสตร์ + การแปลงตัวอักษร เลขที่ ~ 25%
"พิเศษ" การทำให้เป็นมาตรฐานการออกเสียง + การแปลง Soundex ใช่ ~ 50%

เปรียบเทียบการค้นหาแบบออกเสียง

สตริงอ้างอิง: "บียอร์น-ฟิลลิปป์ เมเยอร์"

แบบสอบถาม ElasticSearch การค้นหาจำนวนมาก (iCase) การค้นหาจำนวนมาก (แบบง่าย) การค้นหาเป็นกลุ่ม (ขั้นสูง) ค้นหาเป็นกลุ่ม (พิเศษ)
บียอร์น ใช่ ใช่ ใช่ ใช่ ใช่
บียอร์ เลขที่ ใช่ ใช่ ใช่ ใช่
บียอร์น เลขที่ เลขที่ ใช่ ใช่ ใช่
บียอร์น เลขที่ เลขที่ เลขที่ ใช่ ใช่
ฟิลิปป์ เลขที่ เลขที่ เลขที่ ใช่ ใช่
ฟิลิป เลขที่ เลขที่ เลขที่ ใช่ ใช่
บียอร์นฟิลลิป เลขที่ เลขที่ ใช่ ใช่ ใช่
ไมเออร์ เลขที่ เลขที่ เลขที่ ใช่ ใช่
บียอร์น ไมเออร์ เลขที่ เลขที่ เลขที่ ใช่ ใช่
ไมเออร์ ฟิลิป เลขที่ เลขที่ เลขที่ ใช่ ใช่
บายอร์น แมร์ เลขที่ เลขที่ เลขที่ เลขที่ ใช่
(ผลบวกลวง) ใช่ เลขที่ เลขที่ เลขที่ ใช่

การใช้หน่วยความจำ

หมายเหตุ: ต้องระบุประเภทข้อมูลของ ID ที่ส่งผ่านในการสร้าง ขอแนะนำให้ใช้ช่วงข้อมูลที่ต่ำที่สุดที่เป็นไปได้ เช่น ใช้ "สั้น" เมื่อรหัสไม่สูงกว่า 65,535

ประเภทบัตรประจำตัว ช่วงของค่า การใช้หน่วยความจำทุกๆ ~ 100,000 คำที่จัดทำดัชนี
ไบต์ 0 - 255 4.5 ลบ
สั้น 0 - 65,535 5.3 ลบ
จำนวนเต็ม 0 - 4,294,967,295 6.8 ลบ
ลอย 0 - * (16 หลัก) 10 เมกะไบต์
สตริง * (ไม่จำกัด) 28.2 ลบ

ผู้แต่ง BulkSearch: โทมัส วิลเกอร์ลิง
ใบอนุญาต: ใบอนุญาต Apache 2.0

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด