小编Luc*_*ier的帖子

是否有Elixir或Erlang函数创建大小为n的列表,默认使用给定值初始化？

其他语言的功能示例:

# Python
l = [0] * 5

# Ruby
l = Array.new(5, 0)

# => [0, 0, 0, 0, 0]

我有两个值,每个值来自不同的枚举.我想检查这两者的允许组合,如果没有找到则执行默认操作.我可以以某种方式对这两个值进行切换/案例吗？我想避免多个if/else语句或遵循位掩码模式的枚举,只是因为我认为它们在代码中不像switch/case那么漂亮.

对于了解python的人,我基本上想要在C++中使用这个python代码的解决方案:

val1 = "a"
val2 = 2
actions = {
    ("a", 1): func1,
    ("b" ,1): func2,
    ("a" ,2): func3,
    ("b" ,2): func4
}
action = actions.get((val1, val2), default_func)()
action()

我最近开始了一个业余项目。它应该是一本虚拟的食谱书，具有存储和检索食谱 (CRUD)、对其进行评级和搜索的功能。这不是什么新鲜事，但我想将其构建为桌面应用程序，以了解有关数据库、单元测试、UI 等的更多信息。现在核心域已经基本完成（我使用 DDD 方法）并且我实现了大部分 CRUD 存储库，我想通过在线托管核心功能来使其更具可扩展性，因此我能够编写多个后端（桌面应用程序、Web 应用程序、Web API 等）。

对我来说，面向服务的架构（或微服务）听起来是一个很好的方法。我面临的问题是如何决定项目的哪些部分属于单独的服务以及如何命名它们。

采取该项目的以下部分：

• 核心领域（聚合、实体、值对象、逻辑）-> Java
• 持久性（DAO、存储库、多个数据库后端实现）-> Java
• 搜索（在持久性数据库上使用 SQL 查询进行搜索的搜索服务）-> Java
• 桌面应用程序 -> JS (Electron) 或 JavaFX
• Web 应用程序 -> Flask 或 Rails
• Web API（使用 REST 管理、评分、搜索食谱）-> ?

我最初的方法是将核心域、持久性、搜索和 Web API 放入一个子项目中，并将整个堆栈托管在 Heroku 或类似的东西上。这样我的客户就可以使用网络界面。桌面应用程序和 Web 应用程序本身就是不同的项目。如果 Dektop 应用程序都是用 Java 编写的，则它们可以共享核心域。

这是一种有效的方法，还是我应该将第一个服务分成更小的部分？您如何命名这些服务？

我想计算一个字符串中出现的字数.实现是有问题的,但让我们用它来演示我的问题:

  def count(sentence) do
    words = String.split(sentence)
    occurrences = Enum.map(words, fn w -> {w, Enum.count(words, &(&1 == w))} end)
    Map.new(occurrences)
  end

我想获得与上面相同的结果,但使用管道而不是中间结果变量:

def count(sentence) do
    sentence
    |> String.split
    |> Enum.map(fn w -> {w, Enum.count(???)} end)
    |> Map.new
  end

是否可以在Enum.count函数中引用管道值？或者我必须使用中间变量？

我正在尝试将 Java 库发布到 Bintray，并遇到了从文件中获取的字符串的奇怪行为gradle.properties。

属性文件的内容：

testString = 'test'

我测试字符串行为的任务：

task weirdString {
    println(testString)
    println('test')
    println(testString.class)
    println('test'.class)
    println(testString.equals('test'))
}

运行任务输出：

'test'
test
class java.lang.String
class java.lang.String
false

我无法理解这个问题。第一个和第二个输出之间的差异使我的部署任务崩溃。我想这是 Groovy 内部的一些魔法。有人可以启发我吗？

我正在使用 C++/Qt 进行编程。这些代码片段是否通过复制正确保存了引用的内容？

带有初始化列表：

Foo(const Bar &bar) : bar(bar) { }
Bar bar; //member variable of Foo class

在 Setter 方法中：

void TestClass::setName(const QString &name) {
    this->name = name;
}
QString name; //member variable of TestClass class

如果是，这会复制副本吗？：

void TestClass::setName(const QString name) {
    this->name = name;
}
QString name; //member variable of TestClass class

这是否会导致未定义的行为，因为引用的对象可能会提前解构？：

Foo(Bar &bar) : bar(bar) { }
Bar &bar; //member variable of Foo class

存储传递引用的内容是不是不好的风格？传递需要存储的参数的更好方法是什么？

我有一个 GridPane，在左侧显示描述性标签，在右侧显示内容标签。我在 SceneBuilder 中设置了所有内容USE_COMPUTED_SIZE，并为我的元素添加了填充，这样它们就不会粘得太紧密。如果内容足够大足以占据场景的整个宽度，那么如果左侧标签没有被切断，那么这种方法效果很好：

有没有办法确保在右侧标签获得可用宽度之前完整显示左侧标签？将第一列的最小宽度设置为具体值是可行的，但我希望 JavaFX 确定第一列所需的大小。

我已经看到了两种实现构建器模式的流行方法:

// 1. The build() approach
Product p = builder.part1()
                   .part2()
                   .build();

// 2.The constructor approach
builder.part1()
       .part2();
Product p = new Product(builder);

哪个更好？

我安装了以下内容:

• Visual Studio 2015(包括F#4.0 /在"扩展和更新"选项卡中安装的列表)
• F#4.0(也在PATH中设置)

以下行将无法在我的Visual Studio中编译:

List.contains 1 [1;2]

>> error FS0039: The value, constructor, namespace or type 'contains' is not defined

但是在Powershell的FSI运行以及Visual Studio中的FSI运行良好.Powershell FSI和VS FSI也显示相同的F#Interactive版本号.

任何想法为什么它在交互式运行,但不编译？

在这个例子中,是什么x？它是一个参考？

int x  = 5;   //What is x?
int &y = x;   //This is an alias for x
int *z = &x;  //This is a pointer to x

每当设置一个新列表时,我有一个类需要在列表上重置其内部迭代器:

public class ListElementReceiver implements ElementReceiver {
    private List<Element> elements;
    private Iterator<Element> elementIter;

    public void reset() {
        elementIter = elements.iterator();
    }

    public void setElements(List<Element> elements) {
        this.elements = elements;
        reset();
    }
}

它基本上只是一个列表及其迭代器的包装器,所以我可以将它与我给定的接口一起使用ElementReceiver.我遇到的问题是为这个类构建构造函数.哪两种方法更可取？

// Approach 1: Duplicate logic, independant of Setter
public ListElementReceiver() {
    elements = new List<Element>();
    reset();
}

public ListElementReceiver(List<Element> elements) {
    this.elements = elements;
    reset();
}

//Approach 2: Make dependant on Setter
public ListElementReceiver() {
    setElements(new List<Element>());
}

public ListElementReceiver(List<Element> elements) {
    setElements(elements);
}