小编Ric*_*777的帖子

public class KV<K, V> {
    public K key;
    public V value;
    public KV(K key, V value) {
        this.key = key;
        this.value = value;
    } 
}

我试图重构类变量value,它发生在适当的位置.这意味着没有弹出对话框; 我按回车键,它会尝试在整个项目中进行重构,包括评论和不包含的内容,包括:

<%--<link href="<c:url value="../core/core.css" />" />--%>

在.jsp文件中.这太巧妙了,试图重构整个项目中匹配的评论.这通常会导致很多bug风险,并且在Java环境中进行重构不再安全.

在Intellij 12中也发生了同样的事情.说真的,我不需要Intellij推荐任何被认为不安全的东西,或者当它不确定它是同一个东西时!

我可以排除重构,但我没有时间每次评估五个"建议".它只是增加了人为错误的可能性:大多数时候我只是按下回车键,然后重写事物.

当有时尝试替换.js文件中的内容时,重构也是Java环境中的一个主要问题.说真的,这必须停止.

没有弹出对话框,我无法取消勾选"搜索字符串".即使那是在打勾,应该的IntelliJ 绝不包括默认的建议,特别是当它是当前文件之外.它也可以建议重构它们,但默认情况下应排除它们.也就是说,它应该是一个选择加入功能,而不是默认销毁所有内容.

这是一个严重的用户体验问题,最近所谓的"智能"Intellij重构.在重构JS文件时,我不想在Java文件中搜索注释或字符串!期!反之亦然!

安全第一!知道自己在做什么的开发人员会在需要时自行搜索字符串.在动态语言环境中,它使Intellij无法使用,因为经常,并且没有任何明确的模式,有时重构会经历,有时它会改变整个项目的内容而不是.

应该有一个选项,说"仅重构相对于此文件或100%推断!",特别是对于动态语言!对于静态语言,它甚至不应该尝试在文件外部查找注释和字符串.

我并不是故意将其公之于众,但我在2年前曾在bugtracker中提出过这个问题,但是没有人注意到.

编辑

对于那些认为我可能会走得很远的人,我只是尝试了这个:

有了这个课程:

public class KV<K, V> {
    public K key;
    public V val;
    public KV(K key, V val) {
        this.key = key;
        this.val = val;
    }
}

并将其添加到任何 Java类,例如:

public …

我试图生成一个地图,然后将其转换为yaml文件,如下所示:

uid :
      kasi:
        cn: Chaithra
        street: fkmp
      nandan:
        cn: Chaithra
        street: fkmp
      remya:
        cn: Chaithra
        street: fkmp

我认为在创建地图时我遗漏了一些重要的东西.我的代码如下.

package main

import (
    "fmt"
    "gopkg.in/yaml.v2"
)

type T struct {
    cn     string
    street string
}

func main() {
    names := []string{"kasi", "remya", "nandan"}

    m := make(map[string]map[string]T, len(names))
    for _, name := range names {

        //t := T{cn: "Chaithra", street: "fkmp"}

        m["uid"][name] = T{cn: "Chaithra", street: "fkmp"}

    }
    fmt.Println(m)

    y, _ := yaml.Marshal(&m)

    fmt.Println(string(y))
    //fmt.Println(m, names)
}

它给出以下错误:

panic: runtime error: …

我试图将我的Go地图转换为带有encoding/jsonMarshal 的json字符串,但它导致了一个空字符串.

这是我的代码:

package main

import (
    "encoding/json"
    "fmt"
)

type Foo struct {
    Number int    `json:"number"`
    Title  string `json:"title"`
}

func main() {
    datas := make(map[int]Foo)

    for i := 0; i < 10; i++ {
        datas[i] = Foo{Number: 1, Title: "test"}
    }

    jsonString, _ := json.Marshal(datas)

    fmt.Println(datas)
    fmt.Println(jsonString)
}

我的输出是:

map[9:{1 test} 2:{1 test} 7:{1 test} 3:{1 test} 4:{1 test} 5:{1 test} 6:{1 test} 8:{1 test} 0:{1 test} 1:{1 test}]

[]

我真的不知道我哪里错了.谢谢您的帮助.

我开始在Go中编写服务器端应用程序.我想使用Accept-Encoding请求标头来确定是否GZIP响应实体.我曾希望使用http.Serve或http.ServeFile方法直接找到一种方法.

这是一个非常普遍的要求; 我错过了什么或者我需要推出自己的解决方案吗？

我开始在JMeter中编写一些基本测试,并且惊讶于测量结果与Apache ab的测量结果非常不同.

我有一个千兆局域网连接运行Nginx的Intel i7服务器和运行JMeter或ab的i5测试机.最初,我只是测试开箱即用的Nginx主页响应率.

ab -c 1 -n 100 http://testserver.local/

给

Document Path:          /
Document Length:        151 bytes

Concurrency Level:      1
Time taken for tests:   0.078 seconds
Complete requests:      100
Failed requests:        0
Write errors:           0
Total transferred:      38400 bytes
HTML transferred:       15100 bytes
Requests per second:    1280.77 [#/sec] (mean)
Time per request:       0.781 [ms] (mean)
Time per request:       0.781 [ms] (mean, across all concurrent requests)
Transfer rate:          480.29 [Kbytes/sec] received

该结果始终可重复,+/ - 百分之几.

在JMeter中,我有一个1用户的100循环线程组,其中包含:

• HTTP头管理器设置Accept-Encoding:gzip
• HTTP Get/sampler
• 摘要报告监听器

只有100个样本,每次运行时都会产生非常不一致的结果.但最令人吃惊的事实是报告吞吐量低至每秒40个请求(而不是1280).最高记录率为1030,这仅在我增加到10,000个样本时才实现. …

Goroutines是轻量级进程,由Go运行时自动切片到一个或多个操作系统线程上.(这是Go的一个非常酷的功能!)

假设我有一个像Web服务器一样的并发应用程序.在我的假设计划中同时发生了大量的事情,没有太多的非并发(Amdahl定律)比率.

似乎使用的默认操作系统线程数目是1.这是否意味着只使用一个CPU核心？

如果我开始我的程序

runtime.GOMAXPROCS(runtime.NumCPU())

是否可以合理有效地使用我PC上的所有内核？

使用更多的 OS线程是否有任何"并行松弛"的好处,例如通过一些启发式方法

runtime.GOMAXPROCS(runtime.NumCPU() * 2)

？

我试图在Go中对一片整数进行反向排序.

  example := []int{1,25,3,5,4}
  sort.Ints(example) // this will give me a slice sorted from 1 to the highest number

如何对其进行排序以使其从最高到最低？所以[25 5 4 3 1]

我试过这个

sort.Sort(sort.Reverse(sort.Ints(keys)))

资料来源:http://golang.org/pkg/sort/#Reverse

但是,我收到以下错误

# command-line-arguments
./Roman_Numerals.go:31: sort.Ints(keys) used as value

如何在Go中正确比较两个数组？

例如,如何将二维数组与int条目或任何其他类型进行比较？

这种比较有多深？

为什么Go 打字 nil？为方便起见,它会抛出一个显式的接口验证检查.什么是无类型的问题nil以及设计师想要用打字解决的问题是什么nil？

我正在阅读包的代码,time然后我想知道它是如何func After(d Duration) <-chan Time工作的.

我发现代码如下:

func After(d Duration) <-chan Time {
    return NewTimer(d).C
}

func NewTimer(d Duration) *Timer {
    c := make(chan Time, 1)
    t := &Timer{
        C: c,
        r: runtimeTimer{
            when: nano() + int64(d),
            f:    sendTime,
            arg:  c,
        },
    }
    startTimer(&t.r)
    return t
}

所以我找到了startTimer- 函数startTimer没有函数体这么奇怪.

func startTimer(*runtimeTimer)

我想知道:

1. 真正的代码在哪里？ startTimer
2. 为什么这里可以存在"抽象方法"
3. 为什么Go的作者这样写了

谢谢!