Дмитрий Беляев

post<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;

Оба дженерика имеют типы по умолчанию, а значит если их не указать именно они и будут использоваться
Когда мы вызываемaxios.post<ResponseApi>(/* ... */)мы явно указываем, что T - это тип ResponseApi, а R берется по умолчанию, то есть AxiosResponse<T>, что в нашем случае соответствует AxiosResponse<ResponseApi>, а если и дальше развернуть, то выходит, что R - это

{
  data: ResponseApi;
  status: number;
  statusText: string;
  headers: any;
  config: AxiosRequestConfig;
  request?: any;
}

он и попадает в возвращаемый тип, обернутый в Promise, но TS знает про поведение await и деструктуризации, а следовательно без проблем вычисляет тип для data - ResponseApi

Вот так можно собрать все ключи, что есть в localStorage:

const storageKeys = Array.from({length: localStorage.length}, (_, i) => localStorage.key(i));
console.log(storageKeys);

Подскажите пожалуйста какова на данный момент ситуация с Rust

Дефицит вакансий, дефицит грамотных разработчиков. Те что есть хотят много денег.

до сих пор еще дорабатывают, вышел ли в продакшен?

он "вышел в продакшен" 5-6 лет назад, а насчет доработок - этот процес вечен, ну или пока язык не забросили, ну или как с Go не уперлись в собственный говнокод

Может ли на данный момент потягаться по кол-ву библиотек в web с Golang и в машинном обучении с Python?

Ну так посмотрите сами: https://crates.io/

Планируется ли что-то в ближ. год/два?

https://blog.rust-lang.org/2020/09/03/Planning-202...

У реализации должна быть наиболее общая сигнатура от всех перегрузок. Притом типы в реализации работают только внутрь, а наружу торчат только перегрузки:

export class MyHttpClient {
  constructor(private readonly http: HttpClient) {}

  put(params: Params<'body', 'arraybuffer'>): Observable<ArrayBuffer>;
  put(params: Params<'body', 'blob'>): Observable<Blob>;
  put(params: Params<'body', 'text'>): Observable<string>;
  put(params: Params<'events', 'arraybuffer'>): Observable<HttpEvent<ArrayBuffer>>;
  put(params: Params<'events', 'blob'>): Observable<HttpEvent<Blob>>;
  put(params: Params<'events', 'text'>): Observable<HttpEvent<string>>;
  put(params: Params<'events', 'json'>): Observable<HttpEvent<Object>>;
  put<T>(params: Params<'events', 'json'>): Observable<HttpEvent<T>>;
  put(params: Params<'response', 'arraybuffer'>): Observable<HttpResponse<ArrayBuffer>>;
  put(params: Params<'response', 'blob'>): Observable<HttpResponse<Blob>>;
  put(params: Params<'response', 'text'>): Observable<HttpResponse<string>>;
  put(params: Params<'response', 'json'>): Observable<HttpResponse<Object>>;
  put<T>(params: Params<'response', 'json'>): Observable<HttpResponse<T>>;
  put(params: Params<'body', 'json'>): Observable<Object>;
  put(params: Params<Observe, ResponseType>): Observable<unknown> {
    return this.http.put(params.url, params.body, params.options as Params<'body', 'json'>['options']);
  }
}

А вообще, мне почему-то кажется, что так будет гораздо проще:

type ResponseTypeMap = {
  arraybuffer: ArrayBuffer;
  blob: Blob;
  text: string;
  json: Object;
};
type ResponseTypes = keyof ResponseTypeMap;
type ObserveWrapperMap<T extends ResponseTypeMap[ResponseTypes]> = {
  body: Observable<T>;
  events: Observable<HttpEvent<T>>;
  response: Observable<HttpResponse<T>>;
};
type ObserveWrappers = keyof ObserveWrapperMap<ResponseTypeMap[ResponseTypes]>;
type Result<O extends ObserveWrappers, R extends ResponseTypes> = ObserveWrapperMap<ResponseTypeMap[R]>[O];
type Params<O extends ObserveWrappers, R extends ResponseTypes> = {
  url: string;
  body: any;
  options?: {
    headers?: HttpHeaders | Record<string, string | string[]>;
    observe?: O;
    params?: HttpParams | Record<string, string | string[]>;
    reportProgress?: boolean;
    responseType: R;
    withCredentials?: boolean;
  };
}

export class MyHttpClient {
  constructor(private readonly http: HttpClient) {}

  put<O extends ObserveWrappers = 'body', R extends ResponseTypes = 'json'>(params: Params<O, R>): Result<O, R> {
    const {url, body, options} = params as Params<'body', 'json'>;
    return this.http.put(url, body, options) as Result<O, R>;
  }
}

особенно если помимо put будут и другие методы

test: '/\.png$/'
ковычки лишние
test: /\.png$/

function filterObjectProps<O extends Record<string, unknown>, P extends keyof O>(obj: O, props: readonly P[]) {
  const entries: [P, O[P]][] = [];
  for(const prop of props) {
    if(prop in obj) {
      entries.push([prop, obj[prop]]);
    }
  }
  return Object.fromEntries(entries) as {
    [K in P]: O[K];
  };
}

// ...
updateItem(id: string, updateItemDto: UpdateItemDto): Item {
  const item = this.getItemById(id);
  return {
    ...item,
    ...filterObjectProps(updateItemDto, ['name', 'lastname', 'prop1', 'prop2'])
  };
}

background-image в инлайн стилях перекрывает background в классе, можно так:

Данное условие никогда не выполнитсяif (correct_Login == 1 && correct_Password == 1)

Ну и почитайте на досуге: https://habr.com/ru/post/491534/

вместо проверки className, который содержит строку со всеми классами элемента, проверьте:event.target.classList.contains('delete__button')

Можно так же медиа запросами:
https://developer.mozilla.org/ru/docs/Web/API/Wind...
Можно даже подписаться на изменение состояния по медиа запросу:
https://developer.mozilla.org/en-US/docs/Web/API/M...

В данном коде нет данной ошибки.
Но неплохо бы научится читать саму ошибку, а не бежать за помощью в интернет:

TypeError: Cannot read property 'data' of undefined

Не могу прочитать свойство data из undefined

У Вас где-то происходит обращение к свойству data из переменной содержащей undefined
И не просто где-то, в тексте ошибки и это есть:

at C:\Users\Andre\Desktop\YCH cryptowallet\node_modules\node-qiwi-api\lib\callbackApi.js:759:39

в файле C:\Users\Andre\Desktop\YCH cryptowallet\node_modules\node-qiwi-api\lib\callbackApi.js
на строке 759 символ 39
Вы можете зайти туда и посмотреть, а что за функцию Вы вызвали неправильно

arr.flatMap(el => el.region).flatMap(el => el.cities).map(el => el.name)

Потому что прототипы есть только у объектов, то есть у сущностей (entity) для которых верноtypeof entity === 'object'Правда тут есть одно исключение - в спеке нет типа function, а во всех реализациях он есть по историческим причинам. То есть с точки зрения спеки:typeof function(){} === 'object'а на деле:typeof function(){} === 'function'Поэтому правильное тождество будет такое:

typeof entity === 'object' || typeof entity === 'function'

У остальных типов прототипа нет, в чем можно легко убедится

1 instanceof Number
1 instanceof Object
'a' instanceof String
'a' instanceof Object
true instanceof Boolean
true instanceof Object
1n instanceof BigInt
1n instanceof Object
Symbol() instanceof Symbol
Symbol() instanceof Object
null instanceof Object
undefined instanceof Object

все эти выражения ложны, а как известно instanceof проверяет именно прототипы.

А для того чтоб работали методы для большинства этих типов есть объектные обертки, к которым присутствует неявное приведение при обращении к свойствам через точку или квадратные скобки. Эти обертки не сложно получить передав данные примитивы в Object как функцию, а не как конструктор:

Object(1) instanceof Number
Object(1) instanceof Object
Object('a') instanceof String
Object('a') instanceof Object
Object(true) instanceof Boolean
Object(true) instanceof Object
Object(1n) instanceof BigInt
Object(1n) instanceof Object
Object(Symbol()) instanceof Symbol
Object(Symbol()) instanceof Object

все эти выражения истинны.
Однако надо понимать, что обертка - это уже не примитив:

typeof Object(1) === 'object'
typeof Object('a') === 'object'
typeof Object(true) === 'object'
typeof Object(1n) === 'object'
typeof Object(Symbol()) === 'object'

это все так же истинно.

А вот у юнит-типов (типов-значений) null и undefined таких оберток нет. И хотя Object(null) и Object(undefined) возвращают просто пустой объект, обратится к методам null и undefined нельзя:

null.property // TypeError: Cannot read property 'property' of null
undefined.property // TypeError: Cannot read property 'property' of undefined

Если строка действительно такого простого вида, то регулярки - непростительное расточительство ресурсов.
'2020-09-30'.split('-').reverse().join('.')
Ну а если в большой строке заменить, то:

'2020-09-30'.replace(/(\d{4})-(\d{2})-(\d{2})/, '$3.$2.$1')