标签: optional

我对flatMap有点困惑(添加到Swift 1.2)

假设我有一些可选类型的数组,例如

let possibles:[Int?] = [nil, 1, 2, 3, nil, nil, 4, 5]

在Swift 1.1中,我会做一个过滤器,然后是这样的地图:

let filtermap = possibles.filter({ return $0 != nil }).map({ return $0! })
// filtermap = [1, 2, 3, 4, 5]

我一直尝试使用flatMap这样做:

var flatmap1 = possibles.flatMap({
    return $0 == nil ? [] : [$0!]
})

和

var flatmap2:[Int] = possibles.flatMap({
    if let exercise = $0 { return [exercise] }
    return []
})

我更喜欢最后一种方法(因为我不必强制解包$0!...我害怕这些并且不惜一切代价避免它们)除了我需要指定数组类型.

是否有一个替代方法可以根据上下文计算出类型,但是没有强制解包？

我正在Swift中创建一个NSManagedObject子类,当我创建一个类型为Int,Float或Double的可选属性时,我得到一个错误(也许是其他我没试过的).

@NSManaged var number: Float? //error:Property cannot be marked @NSManaged because its type cannot be represented in Objective-C
@NSManaged var anotherNumber: Float //no error
@NSManaged var array: NSArray? //no error
@NSManaged var anotherArray: Array<String>? //no error

Objective-C中可以表示哪些可选类型？当我使用Swift数组或字符串时(以及当我没有使用Optional Int或Double时),为什么不出现错误？

我试图找到一种干净,代码高效的转换Optional<Integer>方式Optional<Long>.我正在使用Guava在Java 7中工作.

所以在代码中的一个地方我创建了一个可选的整数

    Optional<Integer> optionalInt = Optional.fromNullable(someInt);

在另一个领域,我需要它作为一个可选的长.我能想到的最好的事情是:

    Optional<Long> optionalLong = optionalInt.transform(new Function<Integer, Long>() {
        @Override
        public Long apply(Integer inputInt) {
            if (inputInt != null)
                return inputInt.longValue();
            else
                return null;
        }
    });

但这很麻烦,特别是如果你考虑在我使用原始类型时转换类型是多么容易.

有什么好主意吗？

我想在Realm中使用一个可选的Int并且我想到了一个老错误.

码

dynamic var reps: Int? = nil

错误

'Property cannot be marked dynamic because its type cannot be represented in Objective-C'

我使用Realm 0.96.1和XCode 7.1

我在Realm文档中理解它表示Int不支持Optional但是https://twitter.com/realm/status/656621989583548416.这是来自Realm twitter,这就是为什么我感到困惑.是Optional Int支持还是仍然没有？

我的iOS应用程序有一个非常常见的设置:它向使用JSON对象响应的API服务器进行HTTP查询.然后将这些JSON对象解析为适当的Swift对象.

最初,我将属性划分为必需的属性和可选属性,主要基于我的API服务器的数据库要求.例如id,email和name如此他们使用非可选类型需要的字段.其他人可以NULL在数据库中,因此它们是可选类型.

class User {
  let id: Int
  let email: String
  let profile: String?
  let name: String
  let motive: String?
  let address: String?
  let profilePhotoUrl: String?
}

最近,我开始怀疑这是否是一个很好的设置.我发现尽管某些属性可能总是在数据库中,但这并不意味着这些属性将始终包含在JSON响应中.

例如,在"用户配置文件"页面中,需要所有这些字段才能正确显示视图.因此,JSON响应将包括所有这些字段.但是,对于列出用户名称的视图,我不需要email或者id,JSON响应也可能不包括这些属性.不幸的是,这将导致错误和解析JSON响应到斯威夫特对象时,因为应用程序崩溃预计的应用id,email,name是永远不会比零.

我正在考虑将Swift对象的所有属性更改为可选对象,但感觉就像丢掉了这种特定于语言的功能的所有好处.此外,我将不得不编写更多代码行来打开应用程序中其他地方的所有这些选项.

另一方面,JSON对象本质上不能与Swift的严格静态类型和nil检查非常互操作,所以最好简单地接受这种烦恼.

我应该过渡到每个属性作为选项的模型吗？或者,还有更好的方法？我很感激这里有任何评论.

我有一个返回Optional的Java方法.我想为它写一个易于阅读的单元测试

1. 返回的Optional有一个值(即,Optional不为空)和那个

2. 返回值等于期望值.

假设我的测试方法是

Optional<String> testedMethod(){
  return Optional.of("actual value");
}

可以说我有两个类和两个方法:

class Scratch {
    private class A{}
    private class B extends A{}

    public Optional<A> getItems(List<String> items){
        return items.stream()
             .map(s -> new B())
             .findFirst();
    }

    public Optional<A> getItems2(List<String> items){
        return Optional.of(
            items.stream()
                 .map(s -> new B())
                 .findFirst()
                 .get()
        );
    }
}

为什么getItems2编译时getItems会出现编译器错误

incompatible types: java.util.Optional<Scratch.B> cannot be converted to java.util.Optional<Scratch.A>

所以,当我返回get的值和使用编译器再次包装它时,会识别继承,但如果我直接使用结果,则不会.OptionalfindFirstOptional.offindFirst

经过几个小时的搜索,我决定问这个问题.为什么这个正则表达式:^(dog).+?(cat)?不起作用,因为我认为它应该工作(捕获第一只狗和猫,如果有的话)？我在这里错过了什么？

dog, cat
dog, dog, cat
dog, dog, dog

给出以下代码:

#include <iostream>
#include <optional>

struct foo
{
    explicit operator std::optional<int>() {
        return std::optional<int>( 1 );
    }
    explicit operator int() {
        return 0;
    }
};

int main()
{
    foo my_foo;
    std::optional<int> my_opt( my_foo );
    std::cout << "value: " << my_opt.value() << std::endl;
}

gcc 7.2.0写道 value: 1.

MSVC 2017(15.3)和clang 4.0.0然而写 value: 0.

根据C++标准,哪一个是正确的？

我很惊讶地得知移动构造函数(以及该事项的赋值)std::optional没有重置可选的移动,如[19.6.3.1/7]中所示,其中"bool(rhs)不变".

这也可以通过以下代码看出:

#include <ios>
#include <iostream>
#include <optional>
#include <utility>

int main() {
  std::optional<int> foo{ 0 };
  std::optional<int> bar{ std::move(foo) };

  std::cout << std::boolalpha
            << foo.has_value() << '\n'  // true
            << bar.has_value() << '\n'; // true
}

这似乎与在标准库中移动的其他实例相矛盾,例如移动std::vector容器的位置通常以某种方式重置(在向量的情况下保证之后为空)以使其"无效",即使其中包含的对象也是如此他们自己已经离开了.这个或潜在的用例是否有任何理由支持,例如可能试图模仿相同类型的非可选版本的行为？