大概问的是，一个kafka message会不会被分成几部分存在不同的partitions上，不会。consumer获得的最小粒度应该就是以一个kafka message为单位，也就是每个offset上存的都是个完整的kafka message。

If a consumer is assigned multiple partitions to fetch data from, it will try to consume from all of them at the same time, effectively giving these partitions the same priority for consumption.

fetch.max.bytes and max.partition.fetch.bytes in the fetch request are used by the brokers to respectively determine how much data to return in total and per partition.

By default, the Consumer tries to consume from all partitions fairly.

If a consumer is assigned multiple partitions to fetch data from, it will try to consume from all of them at the same time, effectively giving these partitions the same priority for consumption.
However in some cases consumers may want to first focus on fetching from some subset of the assigned partitions at full speed, and only start fetching other partitions when these partitions have few or no data to consume.

public void assign(java.util.Collection<TopicPartition> partitions)

<TextField...
/>

s = '2020-06-24T22:30';
timeInMillis = Date.parse(s);

Because I forget to import react: import * as React from 'react';.
Because b.tsx does directly rely on React. The line will be turned into a React.createComponent call.

With lambda forEach()

players.forEach(player->{if (player.getTeam().equals(teamName)) {playersOfTeam.add(player);}});

But the next one doesn’t work:

players.forEach(player->{if (player.getName().contains(name)) {return player;}});

The return there is returning from the lambda expression rather than from the containing method. Instead of forEach you need to filter the stream:

players.stream().filter(player -> player.getName().contains(name)).findFirst().orElse(null);

Using !== and === will do a more strict compare than ==/!=. The former will check if the objects being compared are of the same type, as well as if the values matches.

Using == will make it possible for an implicit cast to be made, see the below examples.

(0 ==  '0') // true
(0 === '0') // false('' ==  0 ) // true, the string will implicitly be converted to an integer
('' === 0 ) // false, no implicit cast is being made

If you’re able to use ES6 and Babel, you can use this new feature:

{[yourKeyVariable]: someValueArray,
}  

The selector will be called with the entire Redux store state as its only argument.

The selector will be run whenever the function component renders (unless its reference hasn’t changed since a previous render of the component so that a cached result can be returned by the hook without re-running the selector).

useSelector() will also subscribe to the Redux store, and run your selector whenever an action is dispatched.

const map = {"key1": {k1: 1,k2: 2},"key2": {k1: 3,k2: 4}
}

arr = Object.keys(map).reduce((r, k) => {return r.concat(k, Object.keys(map[k]).map(key => map[k][key]));
}, []);  // arr is:
["key1", 1, 2, "key2", 3, 4]

arr = []
Object.keys(map).map(key => {arr.push([].concat(key, Object.keys(map[key]).map(k => map[key][k])));
}
// arr is:
[["key1", 1, 2], ["key2", 3, 4]]

另外，Object.keys返回的就是一个arr，所以以下两种方法返回的结果是一样的：

const func = (map) => {const arr = [];Object.keys(map).map(key => {const tmpMap = {};tmpMap["key"] = map[key];  Object.keys(map[key]).map(k => {tmpMap[k] = map[key][k];});arr.push(tmpMap);});return arr;
}
const a = func(map);// then a is:
[{key: key1, k1: 1, k2: 2}, {key: key2, k1: 3, k2: 4}]

are equivalent to:

const a = Object.keys(map).map(key => {const tmpMap = {};tmpMap['key'] = key;Object.keys(map[key]).map(k => {tmpMap[k] = map[key][k];});return tmpMap;
});

if(this.props.onChange) {this.props.onChange(select);
}