15097298855

Committed 18 May 2025 03:13PM UTC coverage: 84.727% (+1.2%) from 83.515%

Build # 15097298855

Build Type

push

github

Committed by

jimxl

Commit Message

完善了代码的测试覆盖度

Coverage Stats

699 of 825 relevant lines covered (84.73%)

19.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.47

/array.go

package goby

import (
        "fmt"
        "math/rand"
        "sort"
        "strings"
)

// RArray 实现类似 Ruby 中 Array 类的功能
type RArray struct {
        BaseObject
        elements []Object
}

// NewRArray 创建一个新的 RArray 对象
func NewRArray(elements []Object) RArray {
        return RArray{
                BaseObject: NewBaseObject("Array"),
                elements:   elements,
        }
}

// ToString 返回数组的字符串表示
func (a RArray) ToString() string {
        strs := make([]string, len(a.elements))
        for i, elem := range a.elements {
                strs[i] = elem.ToString()
        }
        return fmt.Sprintf("[%s]", strings.Join(strs, ", "))
}

// Equal 比较两个对象是否相等
func (a RArray) Equal(other Object) bool {
        otherArr, ok := other.(RArray)
        if !ok || len(a.elements) != len(otherArr.elements) {
                return false
        }

        for i, elem := range a.elements {
                if !elem.Equal(otherArr.elements[i]) {
                        return false
                }
        }
        return true
}

// Length 返回数组长度
func (a RArray) Length() int {
        return len(a.elements)
}

// Size 是 Length 的别名
func (a RArray) Size() int {
        return a.Length()
}

// Empty 检查数组是否为空
func (a RArray) Empty() bool {
        return len(a.elements) == 0
}

// First 返回数组的第一个元素
func (a RArray) First() Object {
        if a.Empty() {
                return nil
        }
        return a.elements[0]
}

// Last 返回数组的最后一个元素
func (a RArray) Last() Object {
        if a.Empty() {
                return nil
        }
        return a.elements[len(a.elements)-1]
}

// Include 检查数组是否包含指定元素
func (a RArray) Include(obj Object) bool {
        for _, elem := range a.elements {
                if elem.Equal(obj) {
                        return true
                }
        }
        return false
}

// Push 将元素添加到数组末尾
func (a *RArray) Push(obj Object) *RArray {
        a.elements = append(a.elements, obj)
        return a
}

// Pop 移除并返回数组的最后一个元素
func (a *RArray) Pop() Object {
        if a.Empty() {
                return nil
        }

        lastIndex := len(a.elements) - 1
        lastElement := a.elements[lastIndex]
        a.elements = a.elements[:lastIndex]
        return lastElement
}

// Join 使用指定分隔符连接数组元素
func (a RArray) Join(sep string) RString {
        strs := make([]string, len(a.elements))
        for i, elem := range a.elements {
                strs[i] = elem.ToString()
        }
        return NewRString(strings.Join(strs, sep))
}

// Map 对数组每个元素应用函数并返回新数组
func (a RArray) Map(fn func(Object) Object) RArray {
        result := make([]Object, len(a.elements))
        for i, elem := range a.elements {
                result[i] = fn(elem)
        }
        return NewRArray(result)
}

// Select 返回满足条件的元素
func (a RArray) Select(fn func(Object) bool) RArray {
        var result []Object
        for _, elem := range a.elements {
                if fn(elem) {
                        result = append(result, elem)
                }
        }
        return NewRArray(result)
}

// Reject 返回不满足条件的元素
func (a RArray) Reject(fn func(Object) bool) RArray {
        var result []Object
        for _, elem := range a.elements {
                if !fn(elem) {
                        result = append(result, elem)
                }
        }
        return NewRArray(result)
}

// Reverse 反转数组
func (a RArray) Reverse() RArray {
        reversed := make([]Object, len(a.elements))
        for i, j := 0, len(a.elements)-1; j >= 0; i, j = i+1, j-1 {
                reversed[i] = a.elements[j]
        }
        return NewRArray(reversed)
}

// Shuffle 随机打乱数组元素顺序
func (a RArray) Shuffle() RArray {
        shuffled := make([]Object, len(a.elements))
        copy(shuffled, a.elements)

        rand.Shuffle(len(shuffled), func(i, j int) {
                shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
        })

        return NewRArray(shuffled)
}

// Sort 对数组元素进行排序（按字符串表示）
func (a RArray) Sort() RArray {
        sorted := make([]Object, len(a.elements))
        copy(sorted, a.elements)

        sort.Slice(sorted, func(i, j int) bool {
                return sorted[i].ToString() < sorted[j].ToString()
        })

        return NewRArray(sorted)
}

// Uniq 返回去重后的数组
func (a RArray) Uniq() RArray {
        seen := make(map[string]bool)
        var result []Object

        for _, elem := range a.elements {
                str := elem.ToString()
                if !seen[str] {
                        seen[str] = true
                        result = append(result, elem)
                }
        }

        return NewRArray(result)
}

// Get 获取指定索引的元素
func (a RArray) Get(index int) Object {
        if index < 0 {
                index = len(a.elements) + index
        }

        if index < 0 || index >= len(a.elements) {
                return nil
        }

        return a.elements[index]
}

// ToArray 返回底层数组
func (a RArray) ToArray() []Object {
        return a.elements
}

// Compact 移除所有nil元素
func (a RArray) Compact() RArray {
        var result []Object
        for _, elem := range a.elements {
                if elem != nil {
                        result = append(result, elem)
                }
        }
        return NewRArray(result)
}

// Flatten 展平嵌套数组
func (a RArray) Flatten() RArray {
        var result []Object
        for _, elem := range a.elements {
                if arr, ok := elem.(RArray); ok {
                        result = append(result, arr.Flatten().elements...)
                } else {
                        result = append(result, elem)
                }
        }
        return NewRArray(result)
}

// Index 返回元素首次出现的位置，不存在则返回-1
func (a RArray) Index(obj Object) int {
        for i, elem := range a.elements {
                if elem.Equal(obj) {
                        return i
                }
        }
        return -1
}

// RIndex 返回元素最后出现的位置，不存在则返回-1
func (a RArray) RIndex(obj Object) int {
        for i := len(a.elements) - 1; i >= 0; i-- {
                if a.elements[i].Equal(obj) {
                        return i
                }
        }
        return -1
}

// Count 计算元素出现次数
func (a RArray) Count(obj Object) int {
        count := 0
        for _, elem := range a.elements {
                if elem.Equal(obj) {
                        count++
                }
        }
        return count
}

// Any 检查是否有元素满足条件
func (a RArray) Any(fn func(Object) bool) bool {
        for _, elem := range a.elements {
                if fn(elem) {
                        return true
                }
        }
        return false
}

// All 检查是否所有元素都满足条件
func (a RArray) All(fn func(Object) bool) bool {
        for _, elem := range a.elements {
                if !fn(elem) {
                        return false
                }
        }
        return true
}

// None 检查是否没有元素满足条件
func (a RArray) None(fn func(Object) bool) bool {
        return !a.Any(fn)
}

// Slice 返回指定范围的子数组
func (a RArray) Slice(start, end int) RArray {
        if start < 0 {
                start = len(a.elements) + start
        }
        if end < 0 {
                end = len(a.elements) + end
        }
        if start < 0 {
                start = 0
        }
        if end > len(a.elements) {
                end = len(a.elements)
        }
        if start >= end {
                return NewRArray([]Object{})
        }
        return NewRArray(a.elements[start:end])
}

// SliceFrom 返回从指定位置到结尾的子数组
func (a RArray) SliceFrom(start int) RArray {
        return a.Slice(start, len(a.elements))
}

// Take 返回前n个元素
func (a RArray) Take(n int) RArray {
        if n <= 0 {
                return NewRArray([]Object{})
        }
        if n > len(a.elements) {
                n = len(a.elements)
        }
        return NewRArray(a.elements[:n])
}

// Drop 返回除前n个元素外的所有元素
func (a RArray) Drop(n int) RArray {
        if n <= 0 {
                return a
        }
        if n >= len(a.elements) {
                return NewRArray([]Object{})
        }
        return NewRArray(a.elements[n:])
}

// GroupBy 按指定条件分组
func (a RArray) GroupBy(fn func(Object) Object) map[string]RArray {
        groups := make(map[string]RArray)
        for _, elem := range a.elements {
                key := fn(elem).ToString()
                if group, exists := groups[key]; exists {
                        groups[key] = NewRArray(append(group.elements, elem))
                } else {
                        groups[key] = NewRArray([]Object{elem})
                }
        }
        return groups
}

// Partition 将数组分为满足条件和不满足条件的两部分
func (a RArray) Partition(fn func(Object) bool) (RArray, RArray) {
        var truePart, falsePart []Object
        for _, elem := range a.elements {
                if fn(elem) {
                        truePart = append(truePart, elem)
                } else {
                        falsePart = append(falsePart, elem)
                }
        }
        return NewRArray(truePart), NewRArray(falsePart)
}

// Each 对每个元素执行操作
func (a RArray) Each(fn func(Object)) {
        for _, elem := range a.elements {
                fn(elem)
        }
}

// EachWithIndex 对每个元素及其索引执行操作
func (a RArray) EachWithIndex(fn func(Object, int)) {
        for i, elem := range a.elements {
                fn(elem, i)
        }
}

// EachCons 对每个连续n个元素执行操作
func (a RArray) EachCons(n int, fn func(RArray)) {
        if n <= 0 || n > len(a.elements) {
                return
        }
        for i := 0; i <= len(a.elements)-n; i++ {
                fn(NewRArray(a.elements[i : i+n]))
        }
}

// EachSlice 将数组分成n个元素的切片并执行操作
func (a RArray) EachSlice(n int, fn func(RArray)) {
        if n <= 0 {
                return
        }
        for i := 0; i < len(a.elements); i += n {
                end := i + n
                if end > len(a.elements) {
                        end = len(a.elements)
                }
                fn(NewRArray(a.elements[i:end]))
        }
}

1	package goby
2
3	import (
4	"fmt"
5	"math/rand"
6	"sort"
7	"strings"
8	)
9
10	// RArray 实现类似 Ruby 中 Array 类的功能
11	type RArray struct {
12	BaseObject
13	elements []Object
14	}
15
16	// NewRArray 创建一个新的 RArray 对象
17	func NewRArray(elements []Object) RArray {	189✔
18	return RArray{	189✔
19	BaseObject: NewBaseObject("Array"),	189✔
20	elements: elements,	189✔
21	}	189✔
22	}	189✔
23
24	// ToString 返回数组的字符串表示
25	func (a RArray) ToString() string {	1✔
26	strs := make([]string, len(a.elements))	1✔
27	for i, elem := range a.elements {	3✔
28	strs[i] = elem.ToString()	2✔
29	}	2✔
30	return fmt.Sprintf("[%s]", strings.Join(strs, ", "))	1✔
31	}
32
33	// Equal 比较两个对象是否相等
34	func (a RArray) Equal(other Object) bool {	5✔
35	otherArr, ok := other.(RArray)	5✔
36	if !ok \|\| len(a.elements) != len(otherArr.elements) {	6✔
37	return false	1✔
38	}	1✔
39
40	for i, elem := range a.elements {	11✔
41	if !elem.Equal(otherArr.elements[i]) {	9✔
42	return false	2✔
43	}	2✔
44	}
45	return true	2✔
46	}
47
48	// Length 返回数组长度
49	func (a RArray) Length() int {	50✔
50	return len(a.elements)	50✔
51	}	50✔
52
53	// Size 是 Length 的别名
54	func (a RArray) Size() int {	1✔
55	return a.Length()	1✔
56	}	1✔
57
58	// Empty 检查数组是否为空
59	func (a RArray) Empty() bool {	12✔
60	return len(a.elements) == 0	12✔
61	}	12✔
62
63	// First 返回数组的第一个元素
64	func (a RArray) First() Object {	3✔
65	if a.Empty() {	4✔
66	return nil	1✔
67	}	1✔
68	return a.elements[0]	2✔
69	}
70
71	// Last 返回数组的最后一个元素
72	func (a RArray) Last() Object {	6✔
73	if a.Empty() {	7✔
74	return nil	1✔
75	}	1✔
76	return a.elements[len(a.elements)-1]	5✔
77	}
78
79	// Include 检查数组是否包含指定元素
80	func (a RArray) Include(obj Object) bool {	4✔
81	for _, elem := range a.elements {	13✔
82	if elem.Equal(obj) {	11✔
83	return true	2✔
84	}	2✔
85	}
86	return false	2✔
87	}
88
89	// Push 将元素添加到数组末尾
90	func (a RArray) Push(obj Object) RArray {	2✔
91	a.elements = append(a.elements, obj)	2✔
92	return a	2✔
93	}	2✔
94
95	// Pop 移除并返回数组的最后一个元素
96	func (a *RArray) Pop() Object {	1✔
97	if a.Empty() {	1✔
98	return nil	×
99	}	×
100
101	lastIndex := len(a.elements) - 1	1✔
102	lastElement := a.elements[lastIndex]	1✔
103	a.elements = a.elements[:lastIndex]	1✔
104	return lastElement	1✔
105	}
106
107	// Join 使用指定分隔符连接数组元素
108	func (a RArray) Join(sep string) RString {	10✔
109	strs := make([]string, len(a.elements))	10✔
110	for i, elem := range a.elements {	27✔
111	strs[i] = elem.ToString()	17✔
112	}	17✔
113	return NewRString(strings.Join(strs, sep))	10✔
114	}
115
116	// Map 对数组每个元素应用函数并返回新数组
117	func (a RArray) Map(fn func(Object) Object) RArray {	2✔
118	result := make([]Object, len(a.elements))	2✔
119	for i, elem := range a.elements {	5✔
120	result[i] = fn(elem)	3✔
121	}	3✔
122	return NewRArray(result)	2✔
123	}
124
125	// Select 返回满足条件的元素
126	func (a RArray) Select(fn func(Object) bool) RArray {	3✔
127	var result []Object	3✔
128	for _, elem := range a.elements {	9✔
129	if fn(elem) {	8✔
130	result = append(result, elem)	2✔
131	}	2✔
132	}
133	return NewRArray(result)	3✔
134	}
135
136	// Reject 返回不满足条件的元素
137	func (a RArray) Reject(fn func(Object) bool) RArray {	3✔
138	var result []Object	3✔
139	for _, elem := range a.elements {	9✔
140	if !fn(elem) {	7✔
141	result = append(result, elem)	1✔
142	}	1✔
143	}
144	return NewRArray(result)	3✔
145	}
146
147	// Reverse 反转数组
148	func (a RArray) Reverse() RArray {	3✔
149	reversed := make([]Object, len(a.elements))	3✔
150	for i, j := 0, len(a.elements)-1; j >= 0; i, j = i+1, j-1 {	7✔
151	reversed[i] = a.elements[j]	4✔
152	}	4✔
153	return NewRArray(reversed)	3✔
154	}
155
156	// Shuffle 随机打乱数组元素顺序
157	func (a RArray) Shuffle() RArray {	×
158	shuffled := make([]Object, len(a.elements))	×
159	copy(shuffled, a.elements)	×
160		×
161	rand.Shuffle(len(shuffled), func(i, j int) {	×
162	shuffled[i], shuffled[j] = shuffled[j], shuffled[i]	×
163	})	×
164
165	return NewRArray(shuffled)	×
166	}
167
168	// Sort 对数组元素进行排序（按字符串表示）
169	func (a RArray) Sort() RArray {	×
170	sorted := make([]Object, len(a.elements))	×
171	copy(sorted, a.elements)	×
172		×
173	sort.Slice(sorted, func(i, j int) bool {	×
174	return sorted[i].ToString() < sorted[j].ToString()	×
175	})	×
176
177	return NewRArray(sorted)	×
178	}
179
180	// Uniq 返回去重后的数组
181	func (a RArray) Uniq() RArray {	3✔
182	seen := make(map[string]bool)	3✔
183	var result []Object	3✔
184		3✔
185	for _, elem := range a.elements {	9✔
186	str := elem.ToString()	6✔
187	if !seen[str] {	10✔
188	seen[str] = true	4✔
189	result = append(result, elem)	4✔
190	}	4✔
191	}
192
193	return NewRArray(result)	3✔
194	}
195
196	// Get 获取指定索引的元素
197	func (a RArray) Get(index int) Object {	70✔
198	if index < 0 {	73✔
199	index = len(a.elements) + index	3✔
200	}	3✔
201
202	if index < 0 \|\| index >= len(a.elements) {	72✔
203	return nil	2✔
204	}	2✔
205
206	return a.elements[index]	68✔
207	}
208
209	// ToArray 返回底层数组
210	func (a RArray) ToArray() []Object {	×
211	return a.elements	×
212	}	×
213
214	// Compact 移除所有nil元素
215	func (a RArray) Compact() RArray {	2✔
216	var result []Object	2✔
217	for _, elem := range a.elements {	7✔
218	if elem != nil {	8✔
219	result = append(result, elem)	3✔
220	}	3✔
221	}
222	return NewRArray(result)	2✔
223	}
224
225	// Flatten 展平嵌套数组
226	func (a RArray) Flatten() RArray {	5✔
227	var result []Object	5✔
228	for _, elem := range a.elements {	17✔
229	if arr, ok := elem.(RArray); ok {	15✔
230	result = append(result, arr.Flatten().elements...)	3✔
231	} else {	12✔
232	result = append(result, elem)	9✔
233	}	9✔
234	}
235	return NewRArray(result)	5✔
236	}
237
238	// Index 返回元素首次出现的位置，不存在则返回-1
239	func (a RArray) Index(obj Object) int {	4✔
240	for i, elem := range a.elements {	11✔
241	if elem.Equal(obj) {	9✔
242	return i	2✔
243	}	2✔
244	}
245	return -1	2✔
246	}
247
248	// RIndex 返回元素最后出现的位置，不存在则返回-1
249	func (a RArray) RIndex(obj Object) int {	4✔
250	for i := len(a.elements) - 1; i >= 0; i-- {	13✔
251	if a.elements[i].Equal(obj) {	11✔
252	return i	2✔
253	}	2✔
254	}
255	return -1	2✔
256	}
257
258	// Count 计算元素出现次数
259	func (a RArray) Count(obj Object) int {	4✔
260	count := 0	4✔
261	for _, elem := range a.elements {	19✔
262	if elem.Equal(obj) {	19✔
263	count++	4✔
264	}	4✔
265	}
266	return count	4✔
267	}
268
269	// Any 检查是否有元素满足条件
270	func (a RArray) Any(fn func(Object) bool) bool {	4✔
271	for _, elem := range a.elements {	12✔
272	if fn(elem) {	9✔
273	return true	1✔
274	}	1✔
275	}
276	return false	3✔
277	}
278
279	// All 检查是否所有元素都满足条件
280	func (a RArray) All(fn func(Object) bool) bool {	2✔
281	for _, elem := range a.elements {	6✔
282	if !fn(elem) {	4✔
283	return false	×
284	}	×
285	}
286	return true	2✔
287	}
288
289	// None 检查是否没有元素满足条件
290	func (a RArray) None(fn func(Object) bool) bool {	2✔
291	return !a.Any(fn)	2✔
292	}	2✔
293
294	// Slice 返回指定范围的子数组
295	func (a RArray) Slice(start, end int) RArray {	10✔
296	if start < 0 {	15✔
297	start = len(a.elements) + start	5✔
298	}	5✔
299	if end < 0 {	14✔
300	end = len(a.elements) + end	4✔
301	}	4✔
302	if start < 0 {	12✔
303	start = 0	2✔
304	}	2✔
305	if end > len(a.elements) {	13✔
306	end = len(a.elements)	3✔
307	}	3✔
308	if start >= end {	14✔
309	return NewRArray([]Object{})	4✔
310	}	4✔
311	return NewRArray(a.elements[start:end])	6✔
312	}
313
314	// SliceFrom 返回从指定位置到结尾的子数组
315	func (a RArray) SliceFrom(start int) RArray {	×
316	return a.Slice(start, len(a.elements))	×
317	}	×
318
319	// Take 返回前n个元素
320	func (a RArray) Take(n int) RArray {	×
321	if n <= 0 {	×
322	return NewRArray([]Object{})	×
323	}	×
324	if n > len(a.elements) {	×
325	n = len(a.elements)	×
326	}	×
327	return NewRArray(a.elements[:n])	×
328	}
329
330	// Drop 返回除前n个元素外的所有元素
331	func (a RArray) Drop(n int) RArray {	×
332	if n <= 0 {	×
333	return a	×
334	}	×
335	if n >= len(a.elements) {	×
336	return NewRArray([]Object{})	×
337	}	×
338	return NewRArray(a.elements[n:])	×
339	}
340
341	// GroupBy 按指定条件分组
342	func (a RArray) GroupBy(fn func(Object) Object) map[string]RArray {	1✔
343	groups := make(map[string]RArray)	1✔
344	for _, elem := range a.elements {	6✔
345	key := fn(elem).ToString()	5✔
346	if group, exists := groups[key]; exists {	8✔
347	groups[key] = NewRArray(append(group.elements, elem))	3✔
348	} else {	5✔
349	groups[key] = NewRArray([]Object{elem})	2✔
350	}	2✔
351	}
352	return groups	1✔
353	}
354
355	// Partition 将数组分为满足条件和不满足条件的两部分
356	func (a RArray) Partition(fn func(Object) bool) (RArray, RArray) {	1✔
357	var truePart, falsePart []Object	1✔
358	for _, elem := range a.elements {	6✔
359	if fn(elem) {	7✔
360	truePart = append(truePart, elem)	2✔
361	} else {	5✔
362	falsePart = append(falsePart, elem)	3✔
363	}	3✔
364	}
365	return NewRArray(truePart), NewRArray(falsePart)	1✔
366	}
367
368	// Each 对每个元素执行操作
369	func (a RArray) Each(fn func(Object)) {	1✔
370	for _, elem := range a.elements {	4✔
371	fn(elem)	3✔
372	}	3✔
373	}
374
375	// EachWithIndex 对每个元素及其索引执行操作
376	func (a RArray) EachWithIndex(fn func(Object, int)) {	1✔
377	for i, elem := range a.elements {	4✔
378	fn(elem, i)	3✔
379	}	3✔
380	}
381
382	// EachCons 对每个连续n个元素执行操作
383	func (a RArray) EachCons(n int, fn func(RArray)) {	1✔
384	if n <= 0 \|\| n > len(a.elements) {	1✔
385	return	×
386	}	×
387	for i := 0; i <= len(a.elements)-n; i++ {	4✔
388	fn(NewRArray(a.elements[i : i+n]))	3✔
389	}	3✔
390	}
391
392	// EachSlice 将数组分成n个元素的切片并执行操作
393	func (a RArray) EachSlice(n int, fn func(RArray)) {	1✔
394	if n <= 0 {	1✔
395	return	×
396	}	×
397	for i := 0; i < len(a.elements); i += n {	3✔
398	end := i + n	2✔
399	if end > len(a.elements) {	2✔
400	end = len(a.elements)	×
401	}	×
402	fn(NewRArray(a.elements[i:end]))	2✔
403	}
404	}

GoLangDream / rgo / 15097298855

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous