const promises = [
Promise.reject('rejected1'),
Promise.reject('rejected2'),
Promise.resolve('resolved'),
];1) err => {throw err;}
2) err => {throw err;}
3) onFullfiled
4) onRejected,
5) onRejected
6) v => v,console[level].apply(console, argsWithFormat)
function createRandom(arr) {
const uniqArr = [...new Set(arr)]; // выкидываем дубликаты из массива
let size = uniqArr.length;
let index = -1;
return () => {
const rand = Math.floor(Math.random() * size);
index = (rand + index + 1) % uniqArr.length;
size = uniqArr.length - 1;
return uniqArr[index];
};
}
// использование
const getRand = createRandom([0, 1, 2, 3]);
for (let i = 0; i < 15; ++i) {
console.log(getRand());
}class Solution {
private:
int sumAP(int n, int m) {
int c = n / m;
return m * c * (c + 1) / 2;
}
public:
int sumOfMultiples(int n) {
return sumAP(n, 3) + sumAP(n, 5) + sumAP(n, 7)
- sumAP(n, 3 * 5) - sumAP(n, 3 * 7) - sumAP(n, 5 * 7)
+ sumAP(n, 3 * 5 * 7);
}
};// ----- общий код с генериками ---------------
type Parsers<T extends object> = Omit<{
[K in keyof T]: (str: string) => T[K];
}, 'id'>;
function setValue<T extends object>(obj: T, key: Exclude<keyof T, 'id'>, value: string, parsers: Parsers<T>): void {
obj[key] = parsers[key](value); // магия
}
// ----- конкретный кейс ---------------------
interface Todo {
id: number;
name: string;
text: string;
complete: boolean;
num: number;
}
type List = 'name' | 'text' | 'complete' | 'num';
let list: List[] = ['name', 'text', 'complete', 'num']
const parsers: Parsers<Todo> = {
complete: s => s === 'true',
name: s => s,
text: s => s,
num: s => +s
};
const data: Todo = {
id: 1,
name: '',
text: '',
complete: false,
num: 0,
}
for(let input of list) {
setValue(data, input, formData[input].value, parsers);
}При получении данных, текст всегда поступает в виде строки. А для бинарных данных мы можем выбрать один из двух форматов: Blob или ArrayBuffer.
Это задаётся свойством socket.binaryType, по умолчанию оно равно "blob", так что бинарные данные поступают в виде Blob-объектов.
type TransformType<T> = {
[K in keyof T[keyof T]]: {
[K1 in keyof T]: T[K1][K];
}
}
type Rec = Record<string, Record<string, string>>;
function transformObject<T extends Rec>(obj: T): TransformType<T> {
let result = {} as Rec;
Object.keys(obj).forEach((k) => {
Object.keys(obj[k]).forEach((k1) => {
if (!result[k1]) {
result[k1] = {};
}
result[k1][k] = obj[k][k1];
});
})
return result as TransformType<T>;
};
const src = {
overview: {
ru: 'Общая информация',
en: 'Overview',
},
configuration: {
ru: 'Конфигурация',
en: 'Configuration',
}
};
const res = transformObject(src);
const x = res.en; // { overview: string; configuration: string; }<React.Fragment key={...}>
{idx >= 1 && <div> / </div>}
<Crumb path={crumb.path} title={crumb.title} style={styles.crumbs} />
</React.Fragment>