├── .gitignore
├── README.md
├── core.js
├── github.js
├── index.html
├── root_affix_rule.csv
├── roots-and-affixes.csv
├── style.css
└── word-exchanges.csv
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pem
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Find root-affixes of word
2 |
3 | 查找英语单词的词根词缀组合。
4 |
5 | #### 查找规则
6 |
7 | 0. 直接返回小于等于长度为 2 的单词
8 | 1. 先获取单词原形，还原复数、比较级、过去式等单词形式
9 | 2. 再通过穷举获得所有的词根词缀组合
10 | 3. 然后去除不完整的组合，即该拼写组合 != 单词
11 | 4. 在所有符合条件的组合中，比较所有组合的长度，获取最小长度的组合，如果有多个，则记录多个最小长度组合
12 | 5. 在所有的最小长度组合中，优先获取单词根组合
13 | 6. 在剩余的组合中，取词缀和词根的长度差值最小的组合
14 | 7. 返回所有符合条件的组合
15 |
16 | #### 问题
17 |
18 | 1. 缺少必要的词根词缀，导致部分单词查找不到组合，比如 `wolf`, `strong`
19 | 2. 不准确
20 | - 查找规则可能导致部分正确组合被过滤了
21 | - 问题1的延伸
22 | - 两个单词的组合词，比如 `honeyguide`
23 | 3. 多组合
24 | - 依然有可能返回多种词根词缀组合，比如 `agitation`
25 |
26 | #### 改进
27 |
28 | 首先想加入词干提取（[`Snowball`](https://snowballstem.org/)），用词干提取器代替单词原型表，优点：减少大量的无效组合，减少穷举次数，降低单词原型表带来的不确定性。
29 |
30 | 缺点：不准确，比如 `wolves` -> `wolv`，应为 `wolf`, `went` -> `went`, 应为 `go`。暂时还没有使用过其他词干提取器，不知道 `NLTK` 的 `WordNet` 会不会更好一点。其次是使原词与词干失去了关联属性，不过这点可以用单词原形表补充，如果有必要的话。
31 |
32 | 然后整理最简单词表，比如 `homeworker`，即是由 `home` 和 `worker` 两个单词组成，查找词根词缀时，拆分为两个单词查找，应更为妥当。
33 |
34 | 第三，添加词根词缀表示规则。比如，`^` 表示该词根词缀只能出现在单词开头，`$` 表示只能出现在单词结尾，其他详见 [root_affix_rule.csv](root_affix_rule.csv)。
35 |
36 | 最后是对词根词缀进行打分，这是一个粗糙的想法，未经过验证，而且如何打分，也没有什么好的思路。
37 |
38 | #### 测试
39 |
40 | 项目测试地址：[Find root-affixes🍂 of word](https://excing.github.io/find-roots-of-word/index.html)
41 |
42 | 遇到错误或可能错误的词根词缀组合，可以通过页面右下角的 **Bad root-affixes, report to GitHub** 链接发送 Issue 到 [Github issues](https://github.com/excing/find-roots-of-word/issues)
43 |
44 | #### 资源
45 |
46 | - 项目中使用到的词根词缀表：[Roots and affixes](roots-and-affixes.csv)
47 | - 项目中使用到的单词其他形式表：[Word exchanges](word-exchanges.csv)
48 |
49 | 其中参考了以下开源项目的资源：
50 |
51 | - [lnkDrop/Match-Root](https://github.com/lnkDrop/Match-Root)
52 | - [skywind3000/ECDICT](https://github.com/skywind3000/ECDICT)
53 |
54 | 感谢！
55 |
56 | ## LICENSE
57 |
58 | MIT License
59 |
60 | Copyright (c) 2022 excing
--------------------------------------------------------------------------------
/core.js:
--------------------------------------------------------------------------------
1 | // Exchange is english word exchange
2 | class Exchange {
3 | constructor(name, word, lamme, desc) {
4 | this.name = name
5 | this.word = word
6 | this.lamme = lamme
7 | this.desc = desc
8 | }
9 | }
10 |
11 | class Path {
12 | constructor(value, start, size) {
13 | this.value = value
14 | this.start = start
15 | this.size = size
16 | }
17 | toString() {
18 | return this.value
19 | }
20 | }
21 |
22 | class Result {
23 | constructor(exchange, paths, all, useTime) {
24 | this.exchange = exchange
25 | this.paths = paths
26 | this.all = all
27 | this.useTime = useTime
28 | }
29 |
30 | markdown() {
31 | var str = "## Final combinations\n"
32 | if (0 == this.paths.length) {
33 | str += `\n**No available root-affix combinations were found.**`
34 | }
35 | this.paths.forEach(path => {
36 | str += `\n- ${path}`
37 | })
38 | if (1 < this.paths.length) {
39 | str += `\n\n**Too many combinations.**`
40 | }
41 | str += `\n\nTakes ${this.useTime}ms`
42 | if (this.exchange) {
43 | var exchange = this.exchange
44 | str += `\n\nThe **${exchange.desc}** of \`${exchange.lamme}\``
45 | }
46 | return str
47 | }
48 |
49 | label() {
50 | if (0 == this.paths.length) {
51 | return "No result"
52 | } else if (1 < this.paths.length) {
53 | return "Many combinations"
54 | } else {
55 | return "Bad combination"
56 | }
57 | }
58 | }
59 |
60 | async function initRootsAndAffixesResource() {
61 | if (0 < rootsAndAffixesMap.size) {
62 | return Promise.resolve()
63 | }
64 | return fetch(roots_and_affixes_csv_url, { method: 'GET', })
65 | .then(response => {
66 | if (200 != response.status) {
67 | throw `Init ${roots_and_affixes_csv_filename} failed: ${response.statusText}`
68 | }
69 | return response
70 | })
71 | .then(response => response.text())
72 | .then(text => text.split("\n"))
73 | .then(lines => {
74 | lines.forEach(line => {
75 | var temp = line.split("|")
76 | if (2 == temp.length) {
77 | rootsAndAffixesMap.set(temp[0], temp[1])
78 | }
79 | })
80 | })
81 | .then(_ => console.log(`Root-affix length is ${rootsAndAffixesMap.size}`))
82 | .catch(err => console.error(err))
83 | }
84 |
85 | async function initWordExchangesResource() {
86 | if (0 < wordExchangeMap.size) {
87 | return Promise.resolve()
88 | }
89 | const handleExchangeDesc = function (name) {
90 | switch (name) {
91 | case "p":
92 | return `past tense`
93 | case "d":
94 | return `past participle`
95 | case "i":
96 | return `present participle`
97 | case "3":
98 | return `third-person singular`
99 | case "r":
100 | return `comparative`
101 | case "t":
102 | return `superlative`
103 | case "s":
104 | return `plural`
105 | default:
106 | return ""
107 | }
108 | }
109 | const handleWordExchange = function (lamme, exchanges) {
110 | // 格式
111 | // i:eating,p:ate,d:eaten,3:eats
112 | let arr = exchanges.split(",")
113 | arr.forEach(element => {
114 | let temp = element.split(":")
115 | if (wordExchangeMap.has(temp[1])) {
116 | let wordExchange = wordExchangeMap.get(temp[1])
117 | wordExchange.name += temp[0]
118 | wordExchange.desc += ", " + handleExchangeDesc(temp[0])
119 | } else {
120 | wordExchangeMap.set(
121 | temp[1],
122 | new Exchange(temp[0], temp[1], lamme, handleExchangeDesc(temp[0])),
123 | )
124 | }
125 | })
126 | }
127 | return fetch(word_exchanges_csv_url, { method: 'GET', })
128 | .then(response => {
129 | if (200 != response.status) {
130 | throw `Init ${word_exchanges_csv_filename} failed: ${response.statusText}`
131 | }
132 | return response
133 | })
134 | .then(response => response.text())
135 | .then(text => text.split("\n"))
136 | .then(lines => {
137 | lines.forEach(line => {
138 | var temp = line.split("|")
139 | if (2 == temp.length) {
140 | handleWordExchange(temp[0], temp[1])
141 | }
142 | })
143 | })
144 | .then(_ => console.log(`Word exchanges length is ${wordExchangeMap.size}`))
145 | .catch(err => console.error(err))
146 | }
147 |
148 | const domain = location.origin + location.pathname.replace("/index.html", "")
149 | const roots_and_affixes_csv_filename = 'roots-and-affixes.csv'
150 | const word_exchanges_csv_filename = 'word-exchanges.csv'
151 | const roots_and_affixes_csv_url = `${domain}/${roots_and_affixes_csv_filename}`
152 | const word_exchanges_csv_url = `${domain}/${word_exchanges_csv_filename}`
153 |
154 | const rootsAndAffixesMap = new Map()
155 | const wordExchangeMap = new Map()
156 | const historyResult = new Map()
157 |
158 | // WordRootAffixes is find root-affixes of word
159 | async function WordRootAffixes(word) {
160 | // QA: https://stackoverflow.com/questions/46241827/fetch-api-requesting-multiple-get-requests
161 | return Promise
162 | .all([initRootsAndAffixesResource(), initWordExchangesResource()])
163 | .then(_ => findWordRootAffixes(word.toLowerCase()))
164 | }
165 |
166 | function WordHistoryResult(word) {
167 | return historyResult.get(word)
168 | }
169 |
170 | function findWordRootAffixes(word) {
171 | // Step 0.
172 | if (word.length <= 2) {
173 | return new Result(null, [word], [new Path(word, 0, word.length)], 0)
174 | }
175 | // Step 1.
176 | var currentTime = new Date().getTime()
177 | var result
178 | if (wordExchangeMap.has(word)) {
179 | let exchange = wordExchangeMap.get(word)
180 | if (exchange.lamme.length <= 2) {
181 | return new Result(
182 | exchange,
183 | [exchange.lamme],
184 | [new Path(exchange.lamme, 0, exchange.lamme.length)],
185 | )
186 | }
187 | result = findLammeRootAffixes(exchange.lamme)
188 | result.exchange = exchange
189 | } else {
190 | result = findLammeRootAffixes(word)
191 | }
192 | result.useTime = new Date().getTime() - currentTime
193 | historyResult.set(word, result)
194 | return result
195 | }
196 |
197 | function findLammeRootAffixes(lamme = "") {
198 | // Step 2.
199 | var rootPaths = finAvailableRootPath(lamme)
200 | var availablePaths = []
201 | var tempPaths = []
202 | rootPaths.forEach(rootPath => {
203 | availablePaths.push(rootPath)
204 | let prefixPaths = findAvailablePrefixPath(lamme.substring(0, rootPath.start), "-")
205 | let suffixPaths = findAvailableSuffixPath(lamme.substring(rootPath.start + rootPath.size), "-")
206 | tempPaths = []
207 | if (0 == prefixPaths.length) {
208 | tempPaths.push(rootPath)
209 | }
210 | prefixPaths.forEach(prefixPath => {
211 | tempPaths.push(new Path(
212 | prefixPath.value + "," + rootPath.value,
213 | prefixPath.start,
214 | prefixPath.size + rootPath.size,
215 | ))
216 | })
217 | if (0 == suffixPaths.length) {
218 | tempPaths.forEach(tempPath => {
219 | availablePaths.push(tempPath)
220 | })
221 | }
222 | suffixPaths.forEach(suffixPath => {
223 | tempPaths.forEach(tempPath => {
224 | availablePaths.push(new Path(
225 | tempPath.value + "," + suffixPath.value,
226 | tempPath.start,
227 | tempPath.size + suffixPath.size,
228 | ))
229 | })
230 | })
231 | })
232 |
233 | var all = availablePaths
234 |
235 | // Step 3.
236 | tempPaths = availablePaths
237 | availablePaths = []
238 | tempPaths.forEach(path => {
239 | if (path.start == 0 && path.start + path.size == lamme.length) {
240 | availablePaths.push(path)
241 | }
242 | })
243 |
244 | // Step 4.
245 | var maxPathLength = lamme.length
246 | tempPaths = availablePaths
247 | availablePaths = []
248 | tempPaths.forEach(path => {
249 | let len = path.value.split(",").length
250 | if (len < maxPathLength) {
251 | maxPathLength = len
252 | availablePaths = []
253 | availablePaths.push(path)
254 | } else if (len == maxPathLength) {
255 | availablePaths.push(path)
256 | }
257 | })
258 |
259 | // Step 5.
260 | var singleRootPaths = []
261 | tempPaths = availablePaths
262 | availablePaths = []
263 | tempPaths.forEach(path => {
264 | let affixes = path.value.split(",")
265 | let rootCount = 0
266 | affixes.forEach(affix => {
267 | if (affix.charAt(0) != "-" && affix.charAt(affix.length - 1) != "-") {
268 | rootCount++
269 | }
270 | })
271 | if (1 < rootCount) {
272 | availablePaths.push(path)
273 | } else {
274 | singleRootPaths.push(path)
275 | }
276 | })
277 | if (0 != singleRootPaths.length) {
278 | availablePaths = singleRootPaths
279 | }
280 |
281 | // Step 6.
282 | var lastValueOfMaxMinusMin = lamme.length
283 | tempPaths = availablePaths
284 | availablePaths = []
285 | tempPaths.forEach(path => {
286 | let affixes = path.value.split(",")
287 | let maxAffixLength = 0
288 | let minAffixLength = lamme.length
289 | let maxValue = 0
290 | for (let i = 0; i < affixes.length; i++) {
291 | // QA: https://stackoverflow.com/q/26156292
292 | const affix = affixes[i].replace(/^\-+|\-+$/g, '')
293 | if (maxAffixLength < affix.length) {
294 | maxAffixLength = affix.length
295 | }
296 | if (affix.length < minAffixLength) {
297 | minAffixLength = affix.length
298 | }
299 | if (i == 0) {
300 | continue
301 | }
302 | let value = maxAffixLength - minAffixLength
303 | if (maxValue < value) {
304 | maxValue = value
305 | }
306 | }
307 | if (maxValue < lastValueOfMaxMinusMin) {
308 | lastValueOfMaxMinusMin = maxValue
309 | availablePaths = []
310 | availablePaths.push(path)
311 | } else if (maxValue == lastValueOfMaxMinusMin) {
312 | availablePaths.push(path)
313 | }
314 | })
315 |
316 | // Step 7.
317 | var affixes = []
318 | availablePaths.forEach(path => {
319 | affixes.push(path.value)
320 | })
321 | return new Result(null, affixes, all)
322 | }
323 |
324 | function finAvailableRootPath(word) {
325 | var paths = []
326 | for (let i = 0; i < word.length; i++) {
327 | for (let j = i + 1; j <= word.length; j++) {
328 | let temp = word.substring(i, j)
329 | if (rootsAndAffixesMap.has(temp)) {
330 | paths.push(new Path(temp, i, temp.length))
331 | let _paths = findAvailableSuffixPath(word.substring(j), "")
332 | _paths.forEach(path => {
333 | paths.push(new Path(temp + "," + path.value, i, temp.length + path.size))
334 | })
335 | }
336 | }
337 | }
338 | return paths
339 | }
340 |
341 | function findAvailablePrefixPath(word = "", symbol = "") {
342 | var paths = []
343 | for (let i = word.length - 1; 0 <= i; i--) {
344 | let temp = word.substring(i)
345 | let symbolTemp = temp + symbol
346 | if (rootsAndAffixesMap.has(symbolTemp)) {
347 | let _paths = findAvailablePrefixPath(word.substring(0, i), symbol)
348 | paths.push(new Path(symbolTemp, i, temp.length))
349 | _paths.forEach(path => {
350 | paths = [
351 | new Path(path.value + "," + symbolTemp, path.start, temp.length + path.size),
352 | ].concat(paths)
353 | })
354 | }
355 | }
356 | return paths
357 | }
358 |
359 | function findAvailableSuffixPath(word = "", symbol = "") {
360 | var paths = []
361 | for (let i = 1; i <= word.length; i++) {
362 | let temp = word.substring(0, i)
363 | let symbolTemp = symbol + temp
364 | if (rootsAndAffixesMap.has(symbolTemp)) {
365 | let _paths = findAvailableSuffixPath(word.substring(i), symbol)
366 | paths.push(new Path(symbolTemp, 0, temp.length))
367 | _paths.forEach(path => {
368 | paths.push(new Path(symbolTemp + "," + path.value, 0, temp.length + path.size))
369 | })
370 | }
371 | }
372 | return paths
373 | }
--------------------------------------------------------------------------------
/github.js:
--------------------------------------------------------------------------------
1 | // GitHub 认证及 Issues 相关代码
2 |
3 | const GITHUB_CLIENT_ID = "Iv1.26792a5af3379280"
4 | const GITHUB_CLIENT_SECRET = "a22c85062021e8e85a13a145d2813978d817cfaf"
5 | const REPO_OWNER = "excing"
6 | const REPO_NAME = "find-roots-of-word"
7 |
8 | const historyIssues = new Map()
9 |
10 | async function GithubIssue(title) {
11 | if (historyIssues.has(title)) {
12 | var issue = historyIssues.get(title)
13 | if (issue) {
14 | return Promise.resolve(issue)
15 | } else {
16 | return Promise.reject()
17 | }
18 | }
19 | return getGithubIssue(title)
20 | }
21 |
22 | async function CreateGithubIssue(title, body, label) {
23 | var token = localStorage.getItem("access_token")
24 | return postGithubIssue(
25 | token,
26 | title,
27 | body,
28 | [label, "invalid"])
29 | }
30 |
31 | // 1. 用户被重定向，以请求他们的 GitHub 身份
32 | function AuthorizeGithub(state, redirect_uri) {
33 | window.location = (`https://github.com/login/oauth/authorize?client_id=${GITHUB_CLIENT_ID}&state=${state}&redirect_uri=${redirect_uri}`)
34 | }
35 |
36 | // QA: https://docs.github.com/cn/developers/apps/building-github-apps/refreshing-user-to-server-access-tokens
37 | function LoginGithub() {
38 | var token = localStorage.getItem("access_token")
39 | if (!token || token === "") {
40 | // QA: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject
41 | return Promise.reject()
42 | }
43 | var expiresTime = localStorage.getItem("expires_time")
44 | if (new Date().getTime() < new Number(expiresTime)) {
45 | return Promise.resolve()
46 | }
47 | var refreshTokenExpiresTime = localStorage.getItem("refresh_token_expires_time")
48 | if (new Number(refreshTokenExpiresTime) < new Date().getTime()) {
49 | return Promise.reject()
50 | }
51 | // 使用 refresh token 刷新当前 token
52 |
53 | var refreshToken = localStorage.getItem("refresh_token")
54 | var formData = new FormData()
55 | formData.append("client_id", GITHUB_CLIENT_ID)
56 | formData.append("client_secret", GITHUB_CLIENT_SECRET)
57 | formData.append("refresh_token", refreshToken)
58 | formData.append("grant_type", "refresh_token")
59 | return postAccessGithubToken(formData)
60 | }
61 |
62 | // AccessGithubToken is login oauth access token of github
63 | // QA: https://docs.github.com/cn/developers/apps/building-github-apps/identifying-and-authorizing-users-for-github-apps
64 | // 2. 用户被 GitHub 重定向回您的站点
65 | // 3. 您的 GitHub 应用程序使用用户的访问令牌访问 API
66 | async function AccessGithubToken(code, state, redirectURI) {
67 | var formData = new FormData()
68 | formData.append("client_id", GITHUB_CLIENT_ID)
69 | formData.append("client_secret", GITHUB_CLIENT_SECRET)
70 | formData.append("code", code)
71 | formData.append("state", state)
72 | formData.append("redirect_uri", redirectURI)
73 | return postAccessGithubToken(formData)
74 | }
75 |
76 | async function postAccessGithubToken(formData) {
77 | // QA: https://github.com/isaacs/github/issues/330
78 | return fetch("https://api.icsq.xyz/github/login/oauth/access_token", {
79 | method: "POST",
80 | // mode: 'no-cors',
81 | cache: 'no-cache',
82 | headers: {
83 | Accept: "application/vnd.github+json",
84 | },
85 | body: formData,
86 | })
87 | .then(responseOK)
88 | .then(response => response.json())
89 | .then(data => {
90 | if (data.error) {
91 | throw data.error
92 | }
93 | return data
94 | })
95 | .then(data => {
96 | let expiresIn = new Number(data.expires_in) * 1000 // 原单位为秒
97 | let refreshTokenExpiresIn = new Number(data.refresh_token_expires_in) * 1000
98 | localStorage.setItem("access_token", data.access_token)
99 | localStorage.setItem("expires_time", new Date().getTime() + expiresIn)
100 | localStorage.setItem("refresh_token", data.refresh_token)
101 | localStorage.setItem("refresh_token_expires_time", new Date().getTime() + refreshTokenExpiresIn)
102 | localStorage.setItem("scope", data.scope)
103 | localStorage.setItem("token_type", data.token_type)
104 | })
105 | }
106 |
107 | // QA: https://docs.github.com/cn/rest/issues/issues#create-an-issue
108 | // QA: https://github.com/excing/find-roots-of-word/labels
109 | async function postGithubIssue(token, title, content, labels) {
110 | if (!token) return Promise.reject()
111 | var data = {
112 | title: title,
113 | body: content,
114 | labels: labels,
115 | }
116 | return fetch(`https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/issues`, {
117 | method: "POST",
118 | cache: "no-cache",
119 | headers: {
120 | Accept: "application/vnd.github+json",
121 | Authorization: `token ${token}`
122 | },
123 | body: JSON.stringify(data),
124 | })
125 | .then(responseOK)
126 | .then(response => response.json())
127 | .then(issue => {
128 | historyIssues.set(title, issue)
129 | return issue
130 | })
131 | }
132 |
133 | // QA: https://docs.github.com/cn/rest/search#search-issues-and-pull-requests
134 | // QA: https://docs.github.com/cn/rest/search#constructing-a-search-query
135 | // QA: https://docs.github.com/cn/search-github/searching-on-github/searching-issues-and-pull-requests
136 | // TEST: https://api.github.com/search/issues?q=is:issue subterranean -- Bad root-affix combinations in:title repo:excing/find-roots-of-word
137 | async function getGithubIssue(title) {
138 | var queryString = "q=" + encodeURIComponent(`is:issue ${title} in:title repo:${REPO_OWNER}/${REPO_NAME}`)
139 | return fetch(`https://api.github.com/search/issues?${queryString}`)
140 | .then(responseOK)
141 | .then(response => response.json())
142 | .then(data => {
143 | for (let index = 0; index < data.items.length; index++) {
144 | const issue = data.items[index]
145 | if (issue.title == title) {
146 | historyIssues.set(title, issue)
147 | return issue
148 | }
149 | }
150 | historyIssues.set(title, null)
151 | throw `No result`
152 | })
153 | }
154 |
155 | function responseOK(response) {
156 | if (!response.ok) {
157 | throw `${response.method}: ${response.statusText}`
158 | }
159 | return response
160 | }
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Find root-affixes🍂 of word
6 |
7 |
8 |
9 |
10 |
11 |
12 |
17 |
20 |
21 |
22 |
29 |
30 | Log
31 |
32 |
33 |