小编Boo*_*oon的帖子

我发现关于GCDAsyncSocket的didReadData回调不直观的一件事是,除非你发出另一个readData,否则它不会再次调用.为什么这样设计？期望库的用户启动另一个读取调用以获得回调是正确的还是这是一个设计缺陷？

例如

- (void)socket:(GCDAsyncSocket *)sock didAcceptNewSocket:(GCDAsyncSocket *)newSocket {
     ...
    // initiate the first read
    self.socket = newSocket;
    [self.socket readDataWithTimeout:-1 tag:0];
}

- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag {
    // do what you need with the data...

    // read again, or didReadData won't get called!
    [self.socket readDataWithTimeout:-1 tag:0];
}

我有一系列我正在执行的dispatch_async,我只想在完成后更新UI.问题是dispatch_async中的方法在一个单独的线程中调用某些内容,因此它在数据完全加载之前返回,并在加载所有内容之前调用dispatch_group_notify.

所以我引入一个无限循环让它等到标志设置.这是最好的方法吗？见下面的代码.

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();

for (...) {
  dispatch_group_async(group, queue, ^{
    __block BOOL dataLoaded = NO;

    [thirdPartyCodeCallWithCompletion:^{
       dataLoaded = YES;
    }];

    // prevent infinite loop
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), 
    queue, ^{
          dataLoaded = YES;
    });

    // infinite loop to wait until data is loaded
    while (1) {
       if (dataLoaded) break;
    }
  }

  dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    //update UI
  });
}

我正在使用dispatch_async,它反过来调用其他使用dispatch_async的代码,它使用for循环来分配至少50-100个对象.我怎么知道何时应该使用@autoreleasepool？我是否可以在分配超过10个对象的任何dispatch_async中使用@autoreleasepool,或者是否存在使用过多autoreleasepool的风险？

在Swift中,可以选择使用unowned或weak.为何unowned可以使用weak？似乎两者几乎相同,weak更安全.

何时使用size_t vs uint32_t？我在项目中看到一个方法,它接收一个名为length(类型为uint32_t)的参数来表示要处理的字节数据的长度,该方法用于计算接收到的字节数据的CRC.该参数的类型后来被重构为size_t.在这种情况下使用size_t是否具有技术优势？

例如

- (uint16_t)calculateCRC16FromBytes:(unsigned char *)bytes length:(uint32_t)length;

- (uint16_t)calculateCRC16FromBytes:(unsigned char *)bytes length:(size_t)length;

在Apple关于可空性的博客中,他们提到了这一点:

"...在Swift中,可选和非可选引用之间存在很大的区别,例如NSView与NSView？,而Objective-C将这两种类型都表示为NSView*.因为Swift编译器无法确定是否存在特别是NSView*是否可选,该类型作为一个隐式解包的可选NSView进入Swift!"

这是否意味着之前在声明Objective-C方法为在Swift中隐式解包可选的方法时,它实际上可能会崩溃(因为使用隐式解包的可选项声明的某些方法可能会返回nil)？或者,Apple是否确保只有那些绝对不返回nil的Objective-C方法被声明为隐式解包的可选项？

为什么防护让x = x在一个方法中的行为与外部不同？

下面的示例代码将从Playground中复制出来.

var x:Int? = 3

func foo(x: Int?) {
    guard let x = x else {
        return
    }

     print(x)  // print "3\n"
}

foo(x)

guard let x = x else { 
  throw NSError(domain: "app", code: 0, userInfo: nil)
}

print(x)  // print "Optional(x)\n"

在Objective-C中,将NSString/NSArray/NSDictionary声明为副本是常见的,是否有必要为readonly属性执行此操作,或者没有区别？如果NSString是只读的,它将永远不会被设置,因此声明强大或复制将具有相同的效果吗？

//在这里使用强而非复制,因为它永远不会被复制,所以它会起作用吗？

@property(nonatomic,readonly)NSString*string;

@weakify如何在幕后工作？使用@weakify(self)的想法是让它作为一个简写:

__weak __typeof__(self) weakSelf = self;

注意:@weakify宏在这里定义.

我试图通过收集它使用的所有宏来了解它是如何工作的:

#define weakify(...) \
            ext_keywordify \
            metamacro_foreach_cxt(ext_weakify_,, __weak, __VA_ARGS__)

#define ext_weakify_(INDEX, CONTEXT, VAR) \
    CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);

#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) \
        metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)

#define metamacro_argcount(...) \
        metamacro_at(20, __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)


#define metamacro_concat(A, B) \
        metamacro_concat_(A, B)

#define metamacro_concat_(A, B) A ## B

#define metamacro_foreach_cxt1(MACRO, SEP, …

在GHCi中,执行以下收益:

:t (==) 

(==) :: Eq a => a -> a -> Bool

要么

:t elem

elem :: (Eq a, Foldable t) => a -> t a -> Bool

我对箭头从a到a,然后是a到Bool感到困惑.是因为==或elem是一个curry函数？

elem的类型签名与==非常相似,除了额外的t.是什么t a在:t elem意思？