124 lines
2.1 KiB
Go
124 lines
2.1 KiB
Go
package search
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// ID ...
|
|
type ID struct {
|
|
ID int
|
|
Score float64
|
|
Title []string
|
|
}
|
|
|
|
// Search ...
|
|
type Search struct {
|
|
Titles map[interface{}][][]string
|
|
IgnoreWords []string
|
|
RemoveCharacters []string
|
|
}
|
|
|
|
// CleanSearch ...
|
|
func (DB *Search) CleanSearch(title string) []string {
|
|
s := []string{}
|
|
for _, c := range DB.RemoveCharacters {
|
|
title = strings.Replace(title, c, ` `, -1)
|
|
}
|
|
for _, v := range strings.Split(title, ` `) {
|
|
matched := false
|
|
if v == `` || v == ` ` {
|
|
continue
|
|
}
|
|
for _, w := range DB.IgnoreWords {
|
|
if v == w {
|
|
matched = true
|
|
}
|
|
}
|
|
if !matched {
|
|
s = append(s, strings.ToLower(v))
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
// IndexSearch ...
|
|
func (DB *Search) IndexSearch(id interface{}, st [][]string) {
|
|
if DB.Titles == nil {
|
|
DB.Titles = make(map[interface{}][][]string)
|
|
}
|
|
for _, t := range st {
|
|
DB.Titles[id] = append(DB.Titles[id], t)
|
|
}
|
|
|
|
}
|
|
|
|
// Ignore ...
|
|
func (DB *Search) Ignore(list []string) {
|
|
DB.IgnoreWords = list
|
|
}
|
|
|
|
// Replace ...
|
|
func (DB *Search) Replace(list []string) {
|
|
DB.RemoveCharacters = list
|
|
}
|
|
|
|
// Match ...
|
|
func (DB *Search) Match(Title string) []interface{} {
|
|
IDS := []ID{}
|
|
title := DB.CleanSearch(strings.ToLower(Title))
|
|
mainLoop:
|
|
for i := range DB.Titles {
|
|
for _, t := range DB.Titles[i] {
|
|
if len(t) == 0 {
|
|
continue
|
|
}
|
|
|
|
sim := similarity(t, title)
|
|
if sim > 0 {
|
|
IDS = append(IDS, ID{ID: i.(int), Score: sim, Title: t})
|
|
continue mainLoop
|
|
}
|
|
}
|
|
}
|
|
fmt.Println(DB.Titles[1])
|
|
fmt.Println(DB.Titles[`1`])
|
|
sort.Slice(IDS, func(i, j int) bool {
|
|
return IDS[i].Score > IDS[j].Score
|
|
})
|
|
|
|
ids := []interface{}{}
|
|
for _, v := range IDS {
|
|
ids = append(ids, v.ID)
|
|
}
|
|
return ids
|
|
}
|
|
|
|
func similarity(a, b []string) float64 {
|
|
var s float64
|
|
var matched []int
|
|
loop:
|
|
for _, i := range a {
|
|
for f, l := range b {
|
|
if i == l && !intInSlice(f, matched) {
|
|
s++
|
|
matched = append(matched, f)
|
|
continue loop
|
|
} else {
|
|
s = s - 0.125
|
|
}
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
func intInSlice(a int, list []int) bool {
|
|
for _, b := range list {
|
|
if b == a {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|