小编Mac*_* Sz的帖子

我有一个图书馆foo/foo-lib,其requires具体从GitHub承诺:

{
    "name": "foo/foo-lib",
    "repositories": [
        {
            "type": "vcs",
            "url": "https://github.com/KnpLabs/Gaufrette.git"
        }
    ],
    "require": {
        "knplabs/gaufrette": "dev-master#2633721877cae79ad461f3ca06f3f77fb4fce02e"
    }
}

它工作正常:

$ composer update
Loading composer repositories with package information
Updating dependencies (including require-dev)                                 
  - Updating knplabs/gaufrette dev-master (2633721 => 2633721)
    Checking out 2633721877cae79ad461f3ca06f3f77fb4fce02e

Generating autoload files

但是当我在其他项目中需要该库时:

{
    "name": "bar/bar-app",
    "repositories": [
        {
            "type": "vcs",
            "url": "ssh://git.example.com/foo-lib"
        }
    ],
    "require-dev": {
        "foo/foo-lib": "dev-master"
    }
}

它产生依赖性错误:

Your requirements could not be resolved to an installable set …

实施例#2从PHP手册http://php.net/manual/en/language.oop5.traits.php状态

<?php
class Base {
    public function sayHello() {
        echo 'Hello ';
    }
}

trait SayWorld {
    public function sayHello() {
        parent::sayHello();
        echo 'World!';
    }
}

class MyHelloWorld extends Base {
    use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
?>

这是正确的代码,但parent::在该上下文中使用是不安全的.假设我写了自己的'hello world'类,它不继承任何其他类:

<?php
class MyOwnHelloWorld
{
    use SayWorld;
}
?>

在调用sayHello()方法之前,此代码不会产生任何错误.这是不好的.

另一方面,如果特征需要使用某种方法,我可以将此方法编写为抽象,这很好,因为它确保在编译时正确使用特征.但这不适用于父类:

<?php
trait SayWorld
{
    public function sayHelloWorld()
    {
        $this->sayHello();
        echo 'World!';
    }

    public abstract function sayHello(); // compile-time safety

} …

我有一个方法,它采用一个生成器加上一些额外的参数,并产生一个新的生成器:

function merge(\Generator $carry, array $additional)
{
    foreach ( $carry as $item ) {
        yield $item;
    }
    foreach ( $additional as $item ) {
        yield $item;
    }
}

此函数的常用用例与此类似:

function source()
{
    for ( $i = 0; $i < 3; $i++ ) {
        yield $i;
    }
}

foreach ( merge(source(), [4, 5]) as $item ) {
    var_dump($item);
}

但问题是有时我需要将空源传递给merge方法.理想情况下,我希望能够做到这样的事情:

merge(\Generator::getEmpty(), [4, 5]);

这正是我在C#中所做的事情(有一个IEnumerable<T>.Empty属性).但我手册中没有看到任何类型的empty发电机.

我已经设法使用此函数解决此问题(现在):

function sourceEmpty()
{
    if ( false ) { …

描述

我有一个TestSuite,我需要将其标记为跳过(整个测试套件 - 而不是套件中的特定测试用例).

class AllTests
{    
    public static function suite()
    {
        // this does not work same as within TestCase:
        // throw new \PHPUnit_Framework_SkippedTestError("Out of order");

        $Suite = new \PHPUnit_Framework_TestSuite(__NAMESPACE__);
        $Suite->addTestSuite(translators\AllTests::cls());
        $Suite->addTestSuite(TlScopeTest::cls());
        $Suite->addTestSuite(TlNsTest::cls());
        $Suite->addTestSuite(TlElementTest::cls());
        $Suite->addTestSuite(TlItemTest::cls());
        $Suite->addTestSuite(LangCodeTest::cls());
        $Suite->addTestSuite(TlElemClassTagTest::cls());
        return $Suite;
    }
}

如你所见,抛出PHPUnit_Framework_SkippedTestError异常不起作用.它不会被PHPUnit捕获,并且会将执行中断为任何未捕获的异常(这是可以理解的,因为suite()在构建测试层次结构时,在实际运行测试之前调用该方法).

我见过一个名为的异常类PHPUnit_Framework_SkippedTestSuiteError,但不知道如何利用它.有任何想法吗？

动机

我有一个TestSuite,它聚合了许多测试用例以及其他测试套件.几乎所有的测试都失败了,因为我在代码的核心部分做了一些改变.

问题是这个包不是重要的,并且计划在以后修复.在那之前,我必须为每个其他软件包运行测试,但是当我这样做时,PHPUnit输出会充满来自相关软件包的错误.这会强迫我每次检查是否有任何其他软件包发生故障.

正如您可能怀疑的那样,这很容易受到人为错误的影响,即我可能会错过一个实际上非常重要的失败.

我只能运行我目前正在使用的测试套件,但是我无法控制一个软件包中的更改是否导致其他软件包出现故障.

我不想评论那个测试套件,因为我担心我(或者会在我之后接管代码的人)可能完全忘记它.

经过多年编写单元测试后,我才开始使用CodeceptionPHPUnit.有一件事让我烦恼,我无法找到一种方法来控制调用测试的顺序.

在纯旧的PHPUnit我手动构建测试结构,如下所示:

$suite = new PHPUnit_Framework_TestSuite();
$suite->addTest('MyFirstTest');
$suite->addTest('MySecondTest');

并且将按照它们添加到套件中的顺序调用测试.Codeception另一方面,似乎是在遍历目录并运行它可以找到的每个测试.

我希望能够在两个级别上控制测试的顺序:

1. 在不同类型的测试被调用的顺序(即我想运行unit tests之前acceptance tests)
2. 我想控制在特定测试类型中调用的测试顺序(与PHPUnit构建套件类似)

广告.2:假设我在acceptance目录中有两个测试:

AbcCept.php
WebGuy.php
XyzCept.php

我希望能够运行XyzCept.php之前AbcCept.php.这甚至可能吗？

并且预测挑剔的评论:是的,我知道测试应该能够以任何顺序运行,而不是彼此依赖,但这不是我要求的.

我的git repo服务器上有两个项目.第一个是我写的图书馆,让我们称之为foo/lib-bar.第二个是使用该库的应用程序foo/app-bar.目前该库处于开发版本,因此composer.json该库的文件如下所示:

{
    "name": "foo/lib-bar",
    "description": "Bar library",
    "version": "1.0.0-dev",
    "type": "library",
    "require": {
        "php": ">=5.4",
        "ext-posix": "*"
    }
}

应用程序使用此库,因此它包含必要的要求:

{
    "name": "foo/app-bar",
    "description": "Bar application",
    "version": "0.5.0-dev",
    "type": "application",
    "repositories": [
        {
            "type": "vcs",
            "url": "ssh://user@git.example.com/lib-foo"
        }
    ],
    "require-dev": {
        "foo/lib-bar": ">=1.0.0-dev",
    },
    "require": {
        "php": ">=5.5.3"
    }
}

一切是顺利了这一点:既composer install和composer update按预期运行,安装依赖,我可以看到它在vendor/

现在,文档说明了这一点

require#

Lists packages required by this package. The package will not be …

我知道我可以通过给出这样的问题编号来引用问题:#123.通过这种方式,问题的标题显示在悬停数字上.但我有一个主要问题,我想汇总所有相关问题.为了做到这一点,我想在描述中包含一个问题列表并将标题内联,如下所示:

My frontend issues
- #32 Fix unclosed HTLM tags
- #36 Remove unsupported tags
- #41 Split very complex templates into blocks
- #44 Give all images an alt attribute

有没有办法做到这一点,以便如果我更新实际问题标题,评论保持最新？

我在这里和这里搜索过,但找不到办法.

是否有本机（支持语言）的惰性评估语法？像lazy valScala一样。

我已经浏览了文档，但找不到任何东西。只有一章关于“延迟加载库”，但这不是我要的。

基于这项研究，我倾向于相信（如果我错了，请纠正我）当前没有这种事情。但是，也许您知道将提供该功能的任何计划或功能请求？还是Dart团队考虑并拒绝了它？

如果确实对此没有本地支持，那么实现惰性评估的最佳实践（最佳语法）是什么？一个例子将不胜感激。

编辑：

我正在寻找的功能的优点与其他语言的实现几乎相同：Scalalazy val或C＃Lazy<T>或Hack的__Memorize属性：

1. 简洁的语法
2. 延迟计算直到需要该值
3. 缓存结果（需要的惰性）
4. 不要打破纯粹的功能范式（下面的解释）

一个简单的例子：

class Fibonacci {

  final int n;
  int _res = null;

  int get result {
    if (null == _res) {
      _res = _compute(this.n);
    }
    return _res;
  }

  Fibonacci(this.n);

  int _compute(n) {
    // ...
  }
}

main(List<String> args) async {
  print(new Fibonacci(5).result);
  print(new Fibonacci(9).result);
}

吸气剂非常冗长，并且具有重复的代码。此外，我无法创建构造函数，const因为_res必须根据需要计算缓存变量。我想像一下，如果我具有类似Scala的lazy功能，那么我也将拥有支持常量构造函数的语言支持。这是由于以下事实：延迟的求值 …

我有一个基本抽象类,它聚合了一个集合中的一堆项目:

abstract class AMyAbstract
{
    List<string> Items { get; private set; }

    public AMyAbstract(IEnumerable<string> items)
    {
        this.Items = new List<string>(items);
    }
}

有很多子类,让我们为它们命名Foo,Bar,Baz,等他们都是一成不变的.现在我需要一个merge()方法,它将合并items两个对象,如下所示:

abstract class AMyAbstract
{
    // ...
    public AMyAbstract merge(AMyAbstract other)
    {
        // how to implement???
    }
}

Foo foo1 = new Foo(new string[] {"a", "b"});
Bar bar1 = new Bar(new string[] {"c", "d"});
Foo fooAndBar = foo1.merge(bar1);
// items in fooAndBar now contain: {"a", "b", …

我们可以使用->和->>运算符访问PostgreSQL 9.3中的任何JSON元素。在我看来，#>和#>>仅提供编写JSON路径的较短形式。还是在#>操作员后面有更大的前景？它是否有特殊目的/相对于箭头符号提供了任何优势？首选的写路径方法是哪一种？

这一切都在问：为什么我应该使用#>和#>>运营商在->和->>？

该文档对此有点神秘。

下面的两个查询给出相同的结果：

=> select '{"a":[1,2,3],"b":[4,5,6]}'::json#>'{a,2}';
 ?column? 
----------
 3

=> select '{"a":[1,2,3],"b":[4,5,6]}'::json->'a'->>2;
 ?column? 
----------
 3

我正在寻找Eric Lippert提出的这样的解决方案。这是一个很好的实现，因为它是不可变的，附加时间为O(1)，但缺点是O(i)随机访问时间。

另一方面，有一个很好的实现集合的方法，O(1)它具有追加访问和随机访问两种功能。唯一的问题是它强烈依赖于可变性。

我的问题是如何实现将两种解决方案的优点结合在一起的集合？那是：

1. 不变性
2. O(1) 追加时间
3. O(1) 随机访问时间

内存复杂性对我来说不是什么大问题。

我正在寻找一个单一的 Cypher查询,它将增加一个整数节点参数,并在启动它时返回该值0,以防它不存在.

类似于遵循伪Cypher:

MATCH (n:Order)
IF n.product_count IS NULL THEN n.product_count = 0 // this line is what I need
SET n.product_count = n.product_count + 1
RETURN n.product_count

我能够将一个查询与一个FOREACH完成工作的语句放在一起,但这看起来很糟糕,并不适合我的用例:

MATCH (n:Order)
WHERE id(n) = 9503
FOREACH ( i in (CASE WHEN n.product_count IS NULL THEN [1] ELSE [] END) | SET n.product_count = 0 )
SET n.product_count = n.product_count + 1
RETURN n.product_count; 

如何以正确的方式完成？

注意:Order节点非常复杂并且包含许多其他属性,因此MERGE在这种情况下的定义非常不受欢迎.