blocks|key|3786961|text|func+NewWhatevers(a+...int)+(r+[]Whatever)+{
++++++++r+=+make([]Whatever,+len(a))
++++++++for+i,+v+:=+range+a+{
++++++++++++++++r[i]+=+Whatever(v)
++++++++}
++++++++return
}

...

myWhatevers+:=+NewWhatevers(7,+4,+2,+1)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3786962|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>func NewWhatevers(a ...int) (r []Whatever) {
 r = make([]Whatever, len(a))
 for i, v := range a {
 r[i] = Whatever(v)
 }
 return
}

...

myWhatevers := NewWhatevers(7, 4, 2, 1)
</code></pre>

blocks|key|29527|text|此外，是否有更好的方法来完成我正在尝试的工作，即生成满足测试中使用的接口的硬数据？
|type|blockquote|depth|inlineStyleRanges|entityRanges|data|29528|unstyled|29529|也许吧。您遇到的问题是，[]Comparable和[]testInt是根本不同的，不能交换，因为内存中的底层表示是不同的。如果您的代码不是关于单个项目(即Comparable+)，而是更多关于可以比较的项片，那么您可以重构您的代码来处理整个切片。|offset|length|style|CODE|29530|看看package+sort是如何做到这一点的:它不是在一个可比较的部分上操作，而是在一个“可比较的部分”上操作。|29531|//+FloatOrder+is+a+slice+with+comparable+and+float-convertible+elements+
type+FloatOrder+interface+{
++++Less(i,+j+int)+bool++//+Compare+element+i+and+j+and+return+true+first+is+less+than+the+other
++++Float(i+int)+float64+//+Return+element+i+as+a+float64
}

type+testInts+[]int
func+(n+testInts)+Less(i,+j+int)+bool+{return+n[i]+<+n[j]}
func+(n+testInts)+Float(i+int)+float64+{+return+float64(n[i])+}

func+FunctionTotest(fo+FloatOrder)+{+...+}

func+TestAFunction(t+*testing.T)+{+
+++++++FunctionToTest(testInts{1,2,3,4})
+++++++....
}|code-block|syntax|javascript|29532|(完全未经测试的纯插图代码)|29533|entityMap^0|0|0|C|C|P|9|25|A|0|2|C|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|C|7|W|8|@$F|X|G|Y|H|I]|$F|Z|G|10|H|I]|$F|11|G|12|H|I]]|9|@]|A|$]]|$1|J|3|K|5|C|7|13|8|@$F|14|G|15|H|I]]|9|@]|A|$]]|$1|L|3|M|5|N|7|16|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|C|7|17|8|@]|9|@]|A|$]]|$1|S|3|-4|5|C|7|18|8|@]|9|@]|A|$]]]|T|$]]

<blockquote>
 Additionally, is there perhaps a better way to accomplish what I am trying to do, i.e., generate hard data that satisfies an interface for use in testing?
</blockquote>

Maybe. The problem you encountered is that <code>[]Comparable</code> and <code>[]testInt</code> are fundamentally different and cannot be exchanged as the underlying representation in memory is different.
If your code is less about individual item which are <code>Comparable</code> but more about slices of items which can be compared than you could refactor your code to work on whole Slices.

Have a look at how <code>package sort</code> does this: It doesn't operate on a slice of comparables but on a "comparable slice".

<pre><code>// FloatOrder is a slice with comparable and float-convertible elements 
type FloatOrder interface {
 Less(i, j int) bool // Compare element i and j and return true first is less than the other
 Float(i int) float64 // Return element i as a float64
}

type testInts []int
func (n testInts) Less(i, j int) bool {return n[i] &lt; n[j]}
func (n testInts) Float(i int) float64 { return float64(n[i]) }

func FunctionTotest(fo FloatOrder) { ... }

func TestAFunction(t *testing.T) { 
 FunctionToTest(testInts{1,2,3,4})
 ....
}
</code></pre>

(Completely untested, illustration-only code)

blocks|key|3787018|text|要做到这一点，有许多方法。正如您正确地指出的，问题是Go编译器不能自动将int转换为Comparable+(因为这样做需要查找所有可能的等效类型，并确定哪些等效类型满足Comparable接口，然后如果有多个.你明白的)。因此，您必须做两件事中的一件：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3787019|编写显式类型转换：|3787020|FunctionToTest([]Comparable{+testInt(7),+testInt(4),+testInt(2),+testInt(1)+})|code-block|syntax|javascript|3787021|然而，如果您需要大量的文字，这可能会变得非常烦人。因此，您还可以：|3787022|编写一个将[]int转换为[]Comparable的函数|3787023|func+intToComparable(i+[]int)+[]Comparable+{
++++c+:=+make([]Comparable,+len(i))
++++for+i,+v+:=+range+i+{
++++++++c[i]+=+testInt(v)
++++}
++++return+c
}|3787024|然后你只需要做：|3787025|FunctionToTest(intToComparable([]int{+7,+4,+2,+1+}))|3787026|entityMap^0|10|3|16|A|2C|A|0|0|0|0|5|5|D|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|W|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|X|$]]

There are a number of ways to accomplish this. The problem, as you correctly state, is that the Go compiler cannot automatically convert <code>int</code> to <code>Comparable</code> (since doing so would require finding all possible equivalent types, and figuring out which of those equivalent types satisfy the <code>Comparable</code> interface, and then if there are more than one... you get the idea). Thus, you'll have to do one of two things:

Write an explicit type conversion:

<pre><code>FunctionToTest([]Comparable{ testInt(7), testInt(4), testInt(2), testInt(1) })
</code></pre>

However, if you need a lot of literals, this could get really annoying. Thus, you could also:

Write a function to convert <code>[]int</code> to <code>[]Comparable</code>:

<pre><code>func intToComparable(i []int) []Comparable {
 c := make([]Comparable, len(i))
 for i, v := range i {
 c[i] = testInt(v)
 }
 return c
}
</code></pre>

and then you'd only have to do:

<pre><code>FunctionToTest(intToComparable([]int{ 7, 4, 2, 1 }))
</code></pre>

I have some golang code that manipulates slices of an interface type (Comparable). To test my code, I want to create some fake data and operate on it. However, I'm having trouble doing this in a way that is not incredibly tedious. The only thing I can think to do is create a new type for testing (in this case an alias of type int) that satisfies the Comparable interface, and then feed my tests literal slices of that type. I envision it looking something like the following:

<pre><code>type Comparable interface {
 LT(Comparable) bool
 AsFloat() float64
} 

type testInt int 

func (self testInt) LT(other Comparable) bool { 
 return float64(self) &lt; other.AsFloat() 
} 

func (self testInt) AsFloat() float64 { 
 return float64(self) 
} 

func TestAFunction(t *testing.T) { 
 FunctionToTest([]Comparable{7, 4, 2, 1})
 ....
}
</code></pre>

However, with this example, the compiler will complain that type int cannot be used as a Comparable. I understand why this is happening, but I'm not sure how to solve it. First, I don't know how to create a literal of type testInt. Second, I have to write a significant number of these functions. Working with literal ints is far more convenient for my purposes.

Is there a way to work with type aliases of builtin types such that the compiler can correctly infer the correct type of literals with a minimum of code?

Additionally, is there perhaps a better way to accomplish what I am trying to do, i.e., generate hard data that satisfies an interface for use in testing?

How to create a literal slice of an alias to a builtin type in Go

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一些golang代码来操作接口类型的切片(可比较的)。为了测试我的代码，我想要创建一些假数据并对其进行操作。然而，我在这样做时遇到了困难，因为这样做并不令人难以置信的乏味。我想要做的唯一一件事是创建一个新类型，用于测试(在本例中是int类型的别名)，它满足可比较的接口，然后为我的测试提供该类型的文本切片。我设想它看...

问如何在Go中为内置类型创建别名的文字切片
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Go中为内置类型创建别名的文字切片EN