Автор оригинала: Peter de Croos.

Давайте порезать в погоню, JavaScript как язык красивый горячий мусор …

Я просто гурил “Горячий мусор”, и это просто было связано с JavaScript …

ОК, хорошо, положите свои вилы! ES6 – это фантастический набор итераций над Langauge для строительных решений для веб-сайтов, серверов и мобильных платформ. Однако у него все еще есть много вопросов, которые осматривают здесь и там. Динамическое набрав помогает создавать системы с минимальной котельной и позволяет нам допустить быстрее.

Однако, поскольку ваша заявка растет, JavaScript действительно приглашает вас нарисовать себя в угол.

Возьмите эту невинную функцию.

function doTheThing(data) {
  return data.subproperty.doTheThing();	
}

Хотя JavaScript будет счастливо ожидать этого, фактическое поведение зависит от неформального договора с любой системой, которая использует эту функцию. Если вам нужно воспользоваться этим, не могли бы вы ответить на следующее?

1. Как выглядит аргумент данных?

Здесь мы видим, что данные должны иметь подпробую с методом Dotheth (). Что делает Dothethet () На самом деле сделать это? Что это возвращает?

1. Что мы делаем с возвращаемой стоимостью?

Сколько систем полагается на то, что возвращало значение, чтобы следовать определенной схеме свойств и методов для установки интерфейса? В этом случае мы делегируем это к аргументу данных. Это также добавляет немного косвенности к полученной системе. Если мы полагаемся на это возвращаемое значение, чтобы соответствовать определенному интерфейсу, то по определению мы должны посмотреть на все экземпляры данных в вызовах, чтобы убедиться, что все они подчиняются.

1. Субпропорты всегда существуют на данных?

Скажем, кто-то делает некоторые несвязанные рефакторы на одном значении объекта данных, и он удаляет субпротерейку. Мы получим ошибку … во время выполнения; Надеюсь, пока вы разрабатываете. Ошибки времени выполнения имеют способ промывать как кокосохойцы, и никто не хочет иметь дело с необходимостью отлаживать это при производстве. Это еще одна вещь, которую вам придется следить за тем, что может быть трудно, если вы не знаете внутренний представитель dothething (данные)

Я не знаю о вас, но это много для документирования, и это одна функция.

Требуется этот тип проверки, требуется эпонциально, когда кодовая база становится больше. Fortunatly, Tymdercript придает нам инструменты для автоматизации этой задачи, позволяя нам добавлять аннотации типа.

Давайте посмотрим на пример TeameScript.

interface IThingArgs {
  subProperty: {
    	doTheThing: () => string;
    };
}

function doTheThing(data: IThingArgs): number {
  return data.subProperty.doTheThing();
}

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

Предположим, мы стараемся сделать что-то, что мы не должны делать.

let delegationThingy = {
  subProperty: {
    	doTheThing() {
        	return 5
        }
    }
}

let result = doTheThing(delegationThingy);
console.log(result.length);

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

С нашим типографическим кодом мы получаем ошибку на определенную информацию типа, сообщая нам о том, что делегация. Благодаря правильной инструкции, потенциально дорогое для отслеживания ошибки времени выполнения только что превратилось в строку ошибки, которая отображается, как только вы закончите, написав наличие оскорбительной строки кода.

«Держись на секунду», вы можете сказать: «Что, если мы хотим, если мы хотим универсальный многоразовый код? Я могу использовать бесполезную версию Dothething () в нескольких контекстах, где мне нужен разные типы возврата и делегируют, что между аргументом и тем, что потребляет результат!” И к этому я бы согласился, оригинальный код Javscript – очень острый нож и является более гибким, чем версия TearmScript.

Мы можем иметь свой пирог и съесть его, чтобы использовать дженерики.

interface IThingArgs {
  subProperty: {
    	doTheThing: () => T;
    };
}

function doTheThing(data: IThingArgs): T {
  return data.subProperty.doTheThing();
}

Указывает, что мы будем делегировать фактический тип, который идет сюда потребителю этой функции. Именно там мы можем обеспечить соблюдение ограничений типа и попечкой, будет гарантировать, что все работает.

let delegationThingy = {
  subProperty: {
    	doTheThing() {
        	return 5
        }
    }
}

let delegationThingy2 = {
  subProperty: {
    	doTheThing() {
        	return "foo"; 
        }
    }
}

let result: number = doTheThing(delegationThingy);
let result2: string = doTheThing(delegationThingy2);
console.log(result + result2.length);

console.log(doTheThing(delegationThingy2).length); //compile error

Недавно я выталкивал Typescript в проектах redux. Как проекты Redux становятся больше, я лично боролся с возвращением, чтобы посмотреть на источник для моих действий и редукторов, чтобы узнать, какие аргументы мне нужно плагин. Добавило, большая часть моего штата дерево следует неформально определенной, но очень жесткую структуру, что остальное мое приложение зависит от.

Мне нужны довольно твердые гарантии, что каждая функция редуктора сохраняет структуру того, как должно выглядеть мое состояние, когда его соревновались его модификации.

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

export interface ITodo {
 content: string;
 completed: boolean;
 subtasks?: ITodo[];
}

export interface ITodoListState {
  tasks: ITodo[];
}

const initialState = {
  tasks: [
  	{
      content: 'first task',
      completed: false,
    }
  ]
}

Когда имеет интерфейс A ? В свойстве это означает, что этот тип необязательно, и проверка компиляции не будет бросать ошибку, если она не включена. У него есть дополнительное преимущество в том, что он удостоверится, что вы учитывают значения, которые могут быть неопределенными при компилятере.

Позвольте сказать, что у нас есть компонент реагирования, который оказывает тодо товара. Мы могли бы сделать первую трещину на нем так.

interface ITodoItemProps {
  todo: ITodo;
}

const TodoItem = (props: ITodoItemProps): JSX.Element => {
  return (
    

      
			
          {props.todo.content}
      
      

      {
        props.todo.subtasks.map((subtask) => 
 {subtask.content} 
)
      }
      
    
  )
}

Это может привести к противным ошибкам времени выполнения, потому что подзадачи могут не всегда существовать. Thnatscript знает, что это необязательный тип и лает у вас, чтобы сначала проверить на неопределенный.

Опять же, компилятор премьюциват предупреждает нас об использовании имущества, которое может не существовать и информировать нас, чтобы включить код для проверки этого. Добавление проверки для undefined удаляет ошибку и помогает избежать ошибки в вашем React Code.

const TodoItem = (props: ITodoItemProps): JSX.Element => {
  return (
    

      
			
          {props.todo.content}
      
      {
        (props.todo.subtasks) ? (
          

          {
            props.todo.subtasks.map((subtask) => 
 {subtask.content} 
)
          }
          
        ) : null
      }
    
  );
};

Как видите, TypeScript дает нам много инструментов, чтобы избежать проблем времени выполнения с интерфейсами. Мы можем даже расширить интерфейсы и пройти расширенные типы для функций, ожидая базового типа аналогично расширенным классам.

В Redux мы отправляем действия в редуктор. Разве не было бы неплохо создавать общий тип действия и ограничения типа принуждения?

interface IAction {
  type: string;
  payload: T
}

export const addTodoAction = (todo: ITodo): IAction => {
  return {
      type: "ADD_TODO",
      payload: todo
    }
};

const addTodoReducer = (state: ITodoListState, action: IAction): ITodoListState => {
    return {
      ...state,
      tasks: state.tasks.concat([action.payload])
    };
}

Не только мы можем проверить аргументы во время компиляции, его довольно однозначно, что каждая часть этой системы ожидает как входные данные. Если либо ввод, либо ожидаемый выход не совпадают, типесипт будет проинформировать пользователю задолго до того, как они когда-либо увидят ошибку выполнения.