function isHappy(array){
// записываем пустой массив в array
// (не важно что там мы получили, теперь этого нет)
array = []
// получаем 6 переменных с значением "ничего"(undefined)
let[x,y,z,b,n,v] = array
// сравниваем x+y+z == b+n и выкидываем, никак не используя
// с помощью оператора запятая(,) в if попадает только v
// как мы знаем во всех переменных undefined - if(undefined) - ложь
if(x+y+z == b+n,v){
console.log(`Число ${array} - счастливое!`);
}
else{
console.log(`Число ${array} - несчастливое`);
}
}
// вызываем isHappy с аргументом 000000, который является числом 0,
// просто записанным длинно, а не массивом
isHappy(000000)
type TestResult<T extends string[] | CustomClass[]> = T extends CustomClass[] ? T : void;
function test<T extends string[] | CustomClass[]>(data: T): TestResult<T> {
if (data[0] instanceof CustomClass) {
return data as TestResult<T>;
}
return undefined as TestResult<T>;
}
type Alph = 'Q' | 'W' | 'E' | 'R' | 'T' | 'Y' | 'U' | 'I' | 'O' | 'P' | 'A' | 'S' | 'D' | 'F' | 'G' | 'H' | 'J' | 'K' | 'L' | 'X' | 'Z' | 'C' | 'V' | 'B' | 'N' | 'M'
type CamelToSnake<T extends string> = T extends `${infer S1}${Alph}${string}` ? T extends `${S1}${infer S2}` ? `${Lowercase<S1>}_${CamelToSnake<Uncapitalize<S2>>}` : T : T;
type AsdSnake = CamelToSnake<'asdAsdAsd'> // asd_asd_asd
type SnakeToCamel<T extends string> = T extends `${infer S1}_${infer S2}` ? `${Lowercase<S1>}${Capitalize<SnakeToCamel<S2>>}` : T;
type AsdCamel = SnakeToCamel<'asd_asd_asd'> // asdAsdAsd
type SnakePropToCamel<T extends PropertyKey> = T extends string ? SnakeToCamel<T> : T;
type CamelPropToSnake<T extends PropertyKey> = T extends string ? CamelToSnake<T> : T;
let camelToSnakeCase: <T extends PropertyKey>(str: T) => CamelPropToSnake<T>;
type CamelObjectToSnake<T extends {[key: string]: any}> = {
[K in keyof T as CamelPropToSnake<K>]: T[K]
}
function camelCaseObject<T extends {[key: string]: any}>(obj: T) {
return Object.entries(obj)
.reduce((acc, [key, value]) =>
(acc[camelToSnakeCase(key as keyof T)] = value, acc),
{} as CamelObjectToSnake<T>
)
}
function camelToSnakeKeysOfArrayObject<T extends Array<{[key: string]: any}>>(arr: T) {
return arr.map(camelCaseObject) as {
[K in keyof T]: CamelObjectToSnake<T[K]>
};
}
camelToSnakeKeysOfArrayObject([{
aaAa: 1,
bbBb: true
}, {
aaAa: 'ggg'
}]);
'get' | 'set'
), методы (функциональный тип на инстансе) и static методы (функциональный тип на самом классе).declare class ViewHack {
getPosOnScale(currentPos: number): number;
}
describe('some method', () => {
test('should return smth', () => {
const view = new View('range-slider', settings);
jest.spyOn(view as unknown as ViewHack, 'getPosOnScale').mockReturnValue(100);
});
});
Мне лично на ум приходит такие как VBA
const zip = (...arrs) =>
arrs[0]?.map((n, i) => arrs.map(m => m[i])) ?? [];
const result = zip(arr1, arr2);
const zip = (arrs, defaultValue = null) =>
Array.from(
{ length: Math.max(...arrs.map(n => n.length)) },
(n, i) => arrs.map(m => i < m.length ? m[i] : defaultValue)
);
// или
const zip = (arrs, defaultValue = null) =>
arrs.reduce((acc, n, i) => (
n.forEach((m, j) => (acc[j] ??= Array(arrs.length).fill(defaultValue))[i] = m),
acc
), []);
const result = zip([ arr1, arr2 ]);
.zip([ [ 1, 2, 3 ], [], [ 99 ] ], Infinity)
- в результате получим[
[ 1, Infinity, 99 ],
[ 2, Infinity, Infinity ],
[ 3, Infinity, Infinity ]
]
function* zip(data, defaultValue = null) {
const iterators = Array.from(data, n => n[Symbol.iterator]());
for (let doneAll = false; doneAll = !doneAll;) {
const values = [];
for (const n of iterators) {
const { value, done } = n.next();
values.push(done ? defaultValue : value);
doneAll &&= done;
}
if (!doneAll) {
yield values;
}
}
}
const result = [...zip([ arr1, arr2 ])];
.Array.from(zip((function*() {
yield [ , true, false, NaN ];
yield 'abcde';
yield Array(3).keys();
})()))
[
[ undefined, 'a', 0 ],
[ true, 'b', 1 ],
[ false, 'c', 2 ],
[ NaN, 'd', null ],
[ null, 'e', null ]
]
function call<R>(f: () => R): R {
return f()
}