小编ssc*_*zio的帖子

我想在Vert.x中实现TCP透明代理的概念验证.

需求

侦听端口X的Verticle,当有人连接并发送数据时,它会打开一个客户端连接,指向预配置的TCP服务器.从此刻开始,直到任何对等体关闭连接,保持双向通道,数据在通道上从客户端到服务器上下流动,反之亦然.

这是我的尝试无效.

 vertx.createNetServer().connectHandler(new Handler<NetSocket>() {
        public void handle(final NetSocket socket) {
            vertx.createNetClient().connect(6367, "localhost", new Handler<NetSocket>() {

                @Override
                public void handle(NetSocket cliSocket) {
                    Pump.createPump(socket, cliSocket);
                    Pump.createPump(cliSocket, socket);

                }
            });     
    }
    }).listen(3000);
}

至少这是我理解Pump类的含义:

http://vertx.io/core_manual_java.html#pump

哪里是我的错误？

我有一个超类Command,许多不同的子类的命令,并在同一时间延长也可以扩展这些性状的一种或多种ValuesCommand,KeysCommand,MembersCommand和其他许多人.

现在我想模式匹配Command扩展a ValuesCommand和KeysCommand同时的所有实现.

这是我想要实现的一些伪代码:

def apply(cmd : Command) = {
  cmd match {
    case c:(ValuesCommand && KeysCommand) => c.doSomething()
  }
}

我可以回退以匹配第一个特征并嵌套一秒match.但我真的不需要它,看起来很糟糕.

我不知道为什么这不起作用:

import scala.concurrent.future
import scala.concurrent.Future
import scala.concurrent.ExecutionContext

import scala.concurrent.ExecutionContext.Implicits.global

object FutureTest {

  def main(args: Array[String]) {
    val result1 = future("a")
    val result2 = future("b")
    val result3 = future("c")

    val res = for {
      r1 <- result1
      r2 <- result2
      r3 <- result3
    } yield (r1 + r2 + r3)

    for { r <- res} yield(println(r))
  }
}

我期待这个打印"abc",但没有真正发生.

我有一个Swift可选类型,我想将转换链接到它(map)并最终将它传递给打印它的闭包.

我想避免解包(使用!)可选类型,因为我不想执行闭包,除非我们在可选内部有一些东西.

在Scala中,我们使用foreach作为一个map返回单位.

val oi = Option(2)
oi.map(_+1).foreach(println)

在Swift中我只得到增量(并转换为字符串)

let oi:Int? = 1
let oiplus = oi.map({$0 + 1}).map({String($0)})
// now we have "2"

现在我如何print()仅在可选项不是nil的情况下给出这个？

我很难理解从PostgreSQL切换到Redshift是否是一个好主意,同样的轻松心态会从MySQL转移到Aurora.

与AWS宣传的有关Aurora的内容类似,随着数据集的增长,人们报告了大约5倍的性能和更多的线性可扩展性.

我可以将我的主要,延迟敏感的PostgreSQL迁移到Redshift并自己测试,但我想我会问,因为我无法相信我是唯一一个想到这一点的人.

那么,有什么问题？

我读到了Couchbase用作离线在线内容中心应用程序的内容分发.但我无法弄清楚什么是保持一切同步的算法.

是否只是在发生任何变化时下载整个文档？

或者DB只发送一个delta？在这种情况下,delta如何计算和交付？

是否可以将同步配置为通过压缩HTTP进行？

此外,我对产品命名感到困惑:如果我想要一个在我更改服务器中的文档后立即向用户显示更新的应用程序,我需要使用哪种产品或产品组合？

Cohchbase-LITE？Couchbase移动？Couchbase同步网关？

我正在使用Scala 2.10.4,我无法弄清楚为什么我不能获得非现有密钥的默认值.我得到的是Option[Int]价值None.

  val m = Map[String, Int]().withDefaultValue(0) 
//> m  : scala.collection.immutable.Map[String,Int] = Map()
  m.get("ss") 
//> res0: Option[Int] = None

我期待res0成为0.

为什么不呢？我怎样才能获得预期的行为？

我将我的数据模型表示为案例类,键入可能为null的值作为Option.

case class Document(id: Long, title: String, subtitle: Option[String])

现在我尝试实例化case类:

Document(123, "The Title", "Subtitle") // Doesn't work

但是NOPE!这不起作用,我必须将可选值包装在Some中.

Document(123, "The Title", Some("Subtitle")) // Works

Scala对于类型一般非常聪明,但为什么硬编码文字或(任何字符串)与null/None不同,这是不言自明的？

通过添加这种隐式转换,我能够解决这个问题并使Scala"更加聪明"

implicit def autoSome[T](any:T) = Some(any)
Document(123, "The Title", "Subtitle") // Now it works!

问题:我是唯一一个应该提供隐式转换的语言T - > Some(T)开箱即用吗？或者是否有任何我不知道的问题是默认情况下如此广泛隐含？

我有两个班级"ClassA"和"ClassB".我想从ClassA*中获取类对象,显然我不能这样做.

class ClassA {
  ClassB.getClass() // <-- won't compile
}
class ClassB {
}

唯一的方法是实例化特定的类并从新创建的对象中调用getClass().但我真的不想为此创建一个新对象!

class ClassA {
  new ClassB().getClass() // <-- compiles, but I don't want to create a new object!
}
class ClassB {
}

在Java中,这是直截了当的.Scala做同样的问题是什么？

*就上下文而言,我最终希望获得ClassB的FQCN.

我有这个 JSON 对象，它将补丁集的兼容性映射到特定的软件版本。

{
   "compatibility":{
      "v7.11.x":[
         "7.12.1",
         "7.12.0",
         "7.11.2",
         "7.11.1",
         "7.11.0"
      ],
      "v7.13.x":[
         "7.14.2",
         "7.14.1",
         "7.14.0",
         "7.13.1",
         "7.13.0"
      ],
      "v7.15.x":[
         "8.1.0",
         "8.0.1",
         "8.0.0",
         "7.17.1",
         "7.17.0",
         "7.16.1",
         "7.16.0",
         "7.15.1",
         "7.15.0"
      ]
   }
}

当给定特定版本（例如“8.1.0”）时，是否可以jq返回补丁集名称（例如“v7.15.x”）？