小编mie*_*war的帖子

我是RxJS的新手。

鉴于以下流

[ 'foo ', 'bar', ' b', 'az 12', '3', '4567' ]

我想将其转换为固定大小的数据包（例如3个字节）+其余的数据包

['foo', ' ba', 'r b', 'az ', '123', '456', '7']

在现实生活中，它实际上是二进制数据的缓冲区。

我想知道什么是惯用的RxJS方法。

我发现的简单方法是：

from([ 'foo ', 'bar', ' b', 'az 12', '3', '4567' ])
.pipe(
    Rx.concatMap(v => from(v)),
    Rx.bufferCount(3),
    Rx.map(v => v.join(''))
)
.subscribe(v => console.log(v))

将所有内容分割为一个字符似乎很浪费，所以我发现的另一种方法是使用.slice（）可能更好，但更冗长。

const bufferToSize = (chunkSize) => (source) =>
    Observable.create(subscriber => {
        let buffer = new Buffer('')

        return source.subscribe({
            next: (value) => {
                buffer += value

                while (buffer.length > …

我正在调试一些Julia代码并试图弄清楚为什么以下不起作用.(朱莉娅0.6.3)

struct Foo
    foo::String
end

k = Foo("bar")

finalizer(k, k->print("finalized!"))

虽然我希望它打印"最终确定!",但实际上我收到以下错误:

ERROR: objects of type Foo cannot be finalized
Stacktrace:
 [1] finalizer(::Any, ::Any) at ./base.jl:127

我可以找到关于终结器功能的文档很少,没有例子,我做错了什么？

我正在运行以下基准测试:

int main(int argc, char **argv)
{
 char *d = malloc(sizeof(char) * 13);

 TIME_THIS(func_a(999, d), 99999999);
 TIME_THIS(func_b(999, d), 99999999);

 return 0;
}

通过正常编译,两个函数的结果相同

% gcc func_overhead.c func_overhead_plus.c -o func_overhead && ./func_overhead                                                                               
[func_a(999, d)                     ]      9276227.73
[func_b(999, d)                     ]      9265085.90

但是与-O3他们是非常不同的

% gcc -O3 func_overhead.c func_overhead_plus.c -o func_overhead && ./func_overhead                                                                
[func_a(999, d)                     ]    178580674.69
[func_b(999, d)                     ]     48450175.29

func_a和func_b定义如下:

char *func_a(uint64_t id, char *d)
{
 register size_t i, j;
 register char c;

 for (i = 0, j = 36; i <= …