小编Ale*_*lex的帖子

我正在尝试验证表单,并且html页面中的逻辑太多了.我已经在使用ngMessages了,因为没有它就没那么绝望了.

我正在做像这样的ng-class的对象变体

ng-class="{ 'has-error' : registerForm.username.$invalid && registerForm.username.$touched, 'has-success' : registerForm.username.$valid && registerForm.username.$touched }"

正如您所看到的,上面已经有很多代码了.我必须使用这个指令6次,所以我现在看来唯一的选择就是将它粘贴到其他5个地方.我尝试过这样的事情但是没有用

<form ng-init="formGroupClassObject = { 'has-error' : registerForm.username.$invalid && registerForm.username.$touched, 'has-success' : registerForm.username.$valid && registerForm.username.$touched }">

<div class="form-group" ng-class="formGroupClassObject"></div>

我不明白为什么这不起作用.您对上述代码的重用能力有任何其他建议吗？

我想知道是否有人在 groupcache 和其他内存缓存工具（如 redis 和 memcached）方面有实际经验，是否知道它们在性能、易用性和其他值得一提的方面进行比较。

我问的原因是因为我有兴趣完全切换到 Go，但我对它没有太多经验，也没有使用 groupcache 的经验。

到目前为止，我已经使用 MySQL 完成了几乎所有事情，但我不喜欢手动分片数据并暂时维护所有这些。

我想构建一个像 Facebook 和 WhatsApp 一样的一对一聊天应用程序，如下图所示：

所以我们这里有两个部分。右侧部分仅显示聊天线程中的所有消息，左侧部分显示聊天线程以及最后一条消息的信息，以及您的聊天伙伴信息，例如姓名和图像等。

到目前为止，这就是我所拥有的：

卡桑德拉非常擅长写作和阅读。但由于墓碑的原因，删除数据的情况就不那么严重了。并且您不想设置gc_grace_seconds为 0，因为如果节点发生故障并发生删除，则修复完成后该删除的行可能会恢复。因此，我们最终可能会在节点进入集群之前删除该节点的所有数据。无论如何，据我所知，Cassandra 非常适合这个聊天应用程序的正确部分。由于消息将按插入时间存储和排序，并且排序永远不会改变。所以你只需写和读。这正是 Cassandra 所擅长的。

我有这些表来存储正确部分的消息：

CREATE TYPE user_data_for_message (
    from_id INT,
    to_id INT,
    from_username TEXT,
    to_username TEXT,
    from_image_name TEXT,
    to_image_name TEXT
);

CREATE TABLE message_by_thread_id (
    message_id TIMEUUID,
    thread_id UUID,
    user_data FROZEN <user_data_for_message>,
    message TEXT,
    created_time INT,
    is_viewed BOOLEAN,
    PRIMARY KEY (thread_id, message_id)
) WITH CLUSTERING ORDER BY (message_id DESC);

在插入新消息之前，如果客户端未提供 thread_id，我可以检查两个用户之间是否存在线程。我可以像这样存储该信息：

CREATE TABLE message_thread_by_user_ids (
    thread_id UUID,
    user1_id INT,
    user2_id INT,
    PRIMARY KEY (user1_id, user2_id)
); …

我应该使用PHP进行单个更复杂的MySQL查询还是多个更简单的查询？

例如

更简单的查询:

UPDATE image SET profile = 0 WHERE user_id = 1;

UPDATE image SET profile = 1 WHERE user_id = 1 AND id = 10;

一个更复杂的查询:

UPDATE image
    SET profile = CASE id WHEN 10 THEN 1 ELSE 0 END
    WHERE user_id = 1;

1:什么是最快,最有效的？

2:什么被认为是最佳实践或首选方法？

我正在使用 VS Code 和 lukehoban 的 Go 扩展：

https://github.com/Microsoft/vscode-go

当您保存文件时，似乎运行了 golint，有没有办法让我在开始输入时运行 golint？通常在我们输入其他扩展和语言（例如 jslint 和 VS Code 上的 tslint）时会发生 linting。如果可以选择使用 golint 也能做到这一点，那就太好了。

我能做些什么来实现这一目标？

我熟悉Go中间件模式,如下所示:

// Pattern for writing HTTP middleware.
func middlewareHandler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Our middleware logic goes here before executing application handler.
        next.ServeHTTP(w, r)
        // Our middleware logic goes here after executing application handler.
    })
}

例如,如果我有一个loggingHandler:

func loggingHandler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Before executing the handler.
        start := time.Now()
        log.Printf("Strated %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
        // After executing the handler.
        log.Printf("Completed %s in %v", r.URL.Path, time.Since(start)) …

为什么我所看到的几乎所有人在创建某种导航时都使用这种结构

<ul>
    <li><a href="/link1">link1</a></li>
    <li><a href="/link2">link2</a></li>
    <li><a href="/link3">link3</a></li>
</ul>

而不是这个？

<div>
    <a href="/link1">link1</a>
    <a href="/link2">link2</a>
    <a href="/link3">link3</a>
</div>

与上一个相比,第一个有什么优势？因为很多人都是这样做的.

我试图看看HTTP服务器可以在我的机器上处理多少请求,所以我尝试做一些测试,但差异太大,我很困惑.

首先,我尝试用ab替补并运行此命令

$ ab -n 100000 -c 1000 http://127.0.0.1/

做1000个并发请求.

结果如下:

Concurrency Level:      1000
Time taken for tests:   12.055 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      12800000 bytes
HTML transferred:       1100000 bytes
Requests per second:    8295.15 [#/sec] (mean)
Time per request:       120.552 [ms] (mean)
Time per request:       0.121 [ms] (mean, across all concurrent requests)
Transfer rate:          1036.89 [Kbytes/sec] received

每秒8295个请求,这似乎是合理的.

但后来我试着用这个命令在wrk上运行它:

$ wrk -t1 -c1000 -d5s http://127.0.0.1:80/

我得到了这些结果:

Running 5s test @ http://127.0.0.1:80/
  1 threads …

我已经找到了一种方法让代码按照我的意愿运行,但我想了解为什么它的行为如此,以便我对Go并发性的理解得到改善.

我正在测试sync.WaitGroup等待一些goroutines完成,因为我计划以这种方式多次上传到Amazon S3.

这是我原来的代码:

func main() {

    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go func() {
            fmt.Println(i)
            time.Sleep(time.Second * 1)
            wg.Done()
        }()
    }

    wg.Wait()
}

我惊讶地看到输出是:6, 6, 6, 6, 6.

而不是像:2, 4, 1, 5, 3.

由于循环甚至没有达到6,这对我来说没有任何意义.我后来将i变量作为参数传递给匿名函数,然后它表现得像我预期的那样.

为什么会这样？我不明白.

我刚刚解决了 Project Euler 上的问题 23，但我注意到 map[int]bool 和 []bool 在性能方面存在很大差异。

我有一个总结一个数的真除数的函数：

func divisorsSum(n int) int {
    sum := 1
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            sum += i
            if n/i != i {
                sum += n / i
            }
        }
    }
    return sum
}

然后在主要我这样做：

func main() {
    start := time.Now()
    defer func() {
        elapsed := time.Since(start)
        fmt.Printf("%s\n", elapsed)
    }()

    n := 28123
    abundant := []int{}
    for i := 12; i <= n; …