小编and*_*ras的帖子

我有一个像这样的表驱动测试用例:

func CountWords(s string) map[string]int

func TestCountWords(t *testing.T) {
  var tests = []struct {
    input string
    want map[string]int
  }{
    {"foo", map[string]int{"foo":1}},
    {"foo bar foo", map[string]int{"foo":2,"bar":1}},
  }
  for i, c := range tests {
    got := CountWords(c.input)
    // TODO test whether c.want == got
  }
}

我可以检查长度是否相同,并编写一个循环来检查每个键值对是否相同.但是当我想将它用于另一种类型的地图时(例如map[string]string),我必须再次编写此检查.

我最终做的是,我将地图转换为字符串并比较字符串:

func checkAsStrings(a,b interface{}) bool {
  return fmt.Sprintf("%v", a) != fmt.Sprintf("%v", b) 
}

//...
if checkAsStrings(got, c.want) {
  t.Errorf("Case #%v: Wanted: %v, got: %v", i, c.want, got)
}

这假设等效映射的字符串表示是相同的,在这种情况下似乎是正确的(如果键是相同的,那么它们散列到相同的值,因此它们的顺序将是相同的).有一个更好的方法吗？在表驱动测试中比较两个映射的惯用方法是什么？

我有一个Duck对象的集合,我想用多个键对它们进行排序.

class Duck {
    DuckAge age; //implements Comparable
    DuckWeight weight; //implements Comparable
    String name;
}
List<Duck> ducks = Pond.getDucks();

例如.我想主要根据他们的重量来排序,其次是他们的年龄.如果两只鸭子具有完全相同的重量和完全相同的年龄,那么让我们使用它们的名称作为三级键来区分它们.我可能会这样做:

Collections.sort(ducks, new Comparator<Duck>(){
    @Override
    public int compare(Duck d1, Duck d2){
        int weightCmp = d1.weight.compareTo(d2.weight);
        if (weightCmp != 0) {
            return weightCmp;
        }
        int ageCmp = d1.age.compareTo(d2.age);
        if (ageCmp != 0) {
            return ageCmp;
        }
        return d1.name.compareTo(d2.name);
    }
});

我经常这样做,但这个解决方案闻不到.它不能很好地扩展,并且很容易搞砸.当然必须有一种更好的方法来使用多个键对Ducks进行排序!有人知道更好的解决方案吗？

EDIT删除了不必要的else分支

我无法按字符排序字符串(检查两个字符串是否为字谜,我想对它们进行排序,并检查是否相等).

我可以得到这样[]rune的字符串表示s:

runes := make([]rune, len(s)) 
copy(runes, []rune(s))

我可以像这样排序

someInts := []int{5, 2, 6, 3, 1, 4} // unsorted
sort.Ints(someInts)

但这rune只是一个别名,int32所以我应该可以打电话

sort.Ints(runes) 

但是,我收到错误:

cannot use runes (type []rune) as type []int in function argument

那么......我如何对int32,int64或int*进行排序？

编辑:我确实得到了我的符文排序,但男孩,这是丑陋的.

type RuneSlice []rune

func (p RuneSlice) Len() int           { return len(p) }
func (p RuneSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p RuneSlice) Swap(i, j int)      { p[i], p[j] = …

我在循环中在后台启动1000个子shell.我假设他们使用大致相同的内存量.

for i in `seq 1000`; do
  (
    echo $i;
    sleep 100;
  )&
done;

但是,他们没有.每个新的子shell比前一个子shell占用更多的内存.他们的内存使用量正在增加

$ ps -eo size,command --sort -size | grep subshell | head -n2
  624 /bin/bash /tmp/subshells.sh
  624 /bin/bash /tmp/subshells.sh
$ ps -eo size,command --sort -size | grep subshell | tail -n2
  340 /bin/bash /tmp/subshells.sh
  340 /bin/bash /tmp/subshells.sh

最小的子shell使用340KB,而最大的子shell需要624KB.

这里发生了什么？有办法避免这种情况吗？我很难过,因为我的并行计算的组织方式需要成千上万个背景的子壳,而且我的内存耗尽.