Рубрики
Без рубрики

Полное учебное пособие по реагированию на 2021 – изучать основные концепции реагирования, создавая проект

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

Автор оригинала: FreeCodeCamp Community Member.

Добро пожаловать в полное учебное пособие на реагирование на 2021 год. Это руководство должно помочь вам вступить в силу с реагированием как можно быстрее как можно быстрее, поскольку вы создаете полное применение по пути.

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

Вы узнаете, как создать целое приложение React Application все вблизи около 100 строк кода, что использует многие из основных концепций реагирования: крючки, управление состоянием, форм, элементы JSX, компоненты, реквизиты, стиль и условные условные.

И лучше всего, вы узнаете все эти концепции во время кодировки, практически. Давайте начнем!

Как загрузить ваш реактивный проект

Мы собираемся создать наше приложение React, собираемся на сайт реагировать. Новое Отказ

Что это сделает, это создать новый код песочницы для нас. Мы можем использовать код Sandbox Code для создания и разработки полных приложений RACT без необходимости устанавливать ничего на нашем компьютере.

После того, как вы посетите Reav.new, вы увидите ваш редактор кода и, с правой стороны, мы видим живую версию нашего приложения, к которой мы можем внести изменения:

Сейчас мы смотрим на наш компонент приложения, который является единственным компонентом, который отображается в нашем приложении. Если мы посмотрим на наш файл Explorer слева, мы увидим приложение импортируют и отображаются здесь в этом файле index.js.

// src/index.js
import { StrictMode } from "react";
import ReactDOM from "react-dom";

import App from "./App";

const rootElement = document.getElementById("root");
ReactDOM.render(
  
    
  ,
  rootElement
);

Что делает весь этот код?

Он просто «отображает» или отображает наше приложение, впрыскивая его в файл index.html, который мы видим в правой части страницы.

Код также находит и помещает наше приложение в так называемый корневой элемент (Div с идентификатором «root»). Если вы хотите увидеть, где этот элемент, вы можете найти его в нашей общедоступной папке, в частности, в файле index.html.

Как использовать JSX

Теперь, когда у нас есть работает приложение React React, давайте начнем строить его и меняя то, что мы видим.

Давайте начнем в наше DIV, удалив этот элемент H2, и в нашем H1 просто вызовите наше приложение «ToDo List»:

Что мы работаем здесь, называется Jsx Отказ Это выглядит очень похоже на HTML, но на самом деле находится JavaScript. Мы используем его для создания структуры нашего приложения, как мы бы использовали HTML.

Важно отметить, что существуют некоторые незначительные различия между JSX и HTML.

Атрибуты, которые мы используем на JSX, немного отличаются от обычных HTML-элементов. Они написаны в стиле CameBase, который является стандартным способом записи переменных или свойств в JavaScript.

Например, чтобы применить класс на элементе JSX, мы используем атрибут, называемый классное значение Отказ Для нормального HTML, это просто называют Класс Отказ

// src/App.js
import "./styles.css";

export default function App() {
  return (
    

      
Todo List

    

  );
}

Если мы используем Класс вместо классное значение Для JSX мы собираемся получить предупреждение, говорящий в классе – недействительное свойство DOM:

Как создать список элементов TODO

Поскольку мы создаем приложение TODO, давайте создадим наш список Todo под нашим заголовком H1.

Мы могли бы начать, сделав неупорядоченный список с некоторыми элементами списка в качестве детей элементов. Каждый Todo будет перечислен в пределах Ли элемент:

// src/App.js
import "./styles.css";

export default function App() {
  return (
    

      
Todo List

      
      
    
      	
  • Todo Item
    • 
      

    

  );
}

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

Как создавать новые компоненты реагирования

Компоненты являются основой любого реактивного приложения.

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

Так же, как у нас есть компонент приложения, мы можем создать компонент, который будет отображаться в приложении. Поскольку это список TODOS, давайте назовем это «тодолистом»:

// src/App.js
import "./styles.css";

export default function App() {
  return (
    

      
Todo List

      
       {/* component with single tag */}
    

  );
}

Реагистрационные правила

Каждый компонент должен начать с заглавной буквы. И как только компонент будет объявлен, его можно записать и использовать очень аналогично элементу HTML.

Компонент может состоять из одного тега или двух тегов. Если у него ничего нет между двумя тегами, которые называются дети , он должен иметь только как один тег, что и код выше отображения: Отказ

Кроме того, если компонент или элемент состоит только из одного тега, он должен быть самозакрывающимся. Значение, это должно заканчиваться вперед, как И НЕ ).

Мы пытаемся показать наш тодолистский компонент, но мы еще не создали его. Для этого мы можем создать еще один функциональный компонент, как приложение, с именем ToList.

На данный момент мы собираемся получить эту ошибку, сказав, что ничего не возвращалось из визуализации:

Нам нужно что-то вернуть, в частности, какой-то JSX. Каждый компонент, который мы производим, должны вернуть элементы и компоненты JSX (которые должны также в конечном итоге быть состоят из JSX).

В нашем случае мы хотим вернуть наш список TODOS. Давайте возьмем наш неупорядоченный список со всеми нашими нашими элементами списка, которые мы хотим показать. У нас еще нет никаких данных, поэтому давайте создадим некоторые.

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

// src/App.js
import "./styles.css";

export default function App() {
  const todos = [
    { id: 1, text: "Wash dishes", done: false },
    { id: 2, text: "Do laundry", done: false },
    { id: 3, text: "Take shower", done: false }
  ];

  return (
    

      
Todo List

      
    

  );
}

function TodoList() {}

Как передавать данные на компоненты с реквизитами

Теперь вопрос в том, как мы передаем все эти данные и отображаем его в нашем списке Todo?

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

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

Поскольку наши данные называют Тодос, давайте назвать наш опоры то же самое: «Тодос». Мы используем оператор Equals, чтобы установить значение PROP, а также набор фигурных скобок. Это связано с тем, что наш массив TODOS – это переменная (динамическое значение):

// src/App.js
import "./styles.css";

export default function App() {
  const todos = [
    { id: 1, text: "Wash dishes", done: false },
    { id: 2, text: "Do laundry", done: false },
    { id: 3, text: "Take shower", done: false }
  ];

  return (
    

      
Todo List

      
    

  );
}

function TodoList() {}

В рамках компонента Todolist, где наши реквизиты собираются в конечном итоге отображать наши данные TODOS? Они будут получать именно то, где любая функция получит свои аргументы.

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

Мы можем видеть, что мы передаем эти данные, используя console.log (реквизит) Отказ Если мы посмотрим на нашу консольную вкладку, у нас есть это свойство на нашем объекте реквизита под названием «ToDos».

Он имеет массив из трех предметов, как мы ожидали, что мы ожидали:

// src/App.js
import "./styles.css";

export default function App() {
  const todos = [
    { id: 1, text: "Wash dishes", done: false },
    { id: 2, text: "Do laundry", done: false },
    { id: 3, text: "Take shower", done: false }
  ];

  return (
    

      
Todo List

      
    

  );
}

function TodoList(props) {
  console.log(props) // {todos: Array(3)}
}

Как набрать на карте над предметами массива с функцией карты

Чтобы отобразить каждый из этих элементов списка, мы можем принять массив, который находится на ropps.todos Отказ

В частности, мы можем использовать специальную функцию, которая реагирует, дает нам на массиве TODOS под названием карта Отказ

Поскольку мы хотим отобразить это в ToList, мы еще раз должны использовать набор фигурных скобок для отображения его в нашем JSX. Использование Props.todo.map Мы рассмотрим этот массив, как мы бы обычный массив JavaScript.

.map () Принимает внутреннюю функцию и в этой функции мы можем получить доступ к каждому Todo. Используя функцию стрелки, мы можем вернуть каждое Todo в своем собственном JSX.

Наконец, мы можем сразу же вернуть этот JSX, упаковывая его в набор скобок:

В рамках нашей внутренней функции мы получаем доступ к каждому Data Data. Чтобы отобразить эти данные, мы можем принять каждый TODO, который мы знаем, является объектом. Мы можем использовать набор фигурных скобок для вывода динамического значения того, что на todo.text Отказ

Когда мы сделаем это, мы можем увидеть наши три Тодос:

Что такое оперативные ключи (и почему они имеют значение)?

Если мы посмотрим на вкладку консоли внизу, мы увидим предупреждение, говоря, что каждый ребенок в списке должен иметь «уникальный ключ».

Причина этого заключается в том, что реагирование необходимо отслеживать порядок каждого из элементов в нашем списке. Это делает это с помощью специального React Rup под названием ключ Отказ

Так почему же важно ключи? Реагировать, чтобы реагировать на выяснение, как он должен соответственно обновлять наш пользовательский интерфейс. Если бы мы должны были обновить текстовое или выполненное значение TODO, ключ – это то, что говорит реагировать на то, какой элемент TODO должен быть обновлен.

Как только мы добавим клавишу опоры на элемент или компонент, который мы переживаем, мы больше не получаем это предупреждение:

Как получить индивидуальные реквизиты с разрушением

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

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

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

// src/App.js
import "./styles.css";

export default function App() {
  const todos = [
    { id: 1, text: "Wash dishes", done: false },
    { id: 2, text: "Do laundry", done: false },
    { id: 3, text: "Take shower", done: false }
  ];

  return (
    

      
Todo List

      
    

  );
}

// using object destructuring on the props object
function TodoList({ todos }) {
  return (
    
    
      {todos.map((todo) => (
        
  • {todo.text}
    • 
      ))}
    

  );
}

Как добавить новые элементы списка TodDo

Теперь, как насчет добавления новых тодосов в наш список?

Под нашим тодолистом, давайте добавим новый компонент, который отвечает за добавление новых TODOS. Логическое имя для этого было бы «Addtodo».

Мы можем создать это под нашим компонентом списка. Давайте добавим ADDTODO вернуть элемент формы, который содержит базовый текстовый ввод и кнопку отправки.

// src/App.js
import "./styles.css";

export default function App() {
  const todos = [
    { id: 1, text: "Wash dishes", done: false },
    { id: 2, text: "Do laundry", done: false },
    { id: 3, text: "Take shower", done: false }
  ];

  return (
    

      
Todo List

      
      
    

  );
}

function TodoList({ todos }) {
  return (
    
    
      {todos.map((todo) => (
        
  • {todo.text}
    • 
      ))}
    

  );
}

function AddTodo() {
  return (
    

      
      
    

  );
}

Теперь вопрос в том, как мы введем на наш вход, отправьте нашу форму и получите новый TODO, добавленный в наш массив TODOS?

Как обрабатывать формы представления в реакции

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

В нашем случае мы хотим использовать событие «Отправить», когда наша форма представлена нашим пользователем, и для реагирования на решение этой формы, добавив новый TODO.

Реагистрация добавляет специальный опора для элемента формы под названием OnsUbmit Отказ ONSUBMIT принимает функцию в пределах набора фигурных скобок. Давайте создадим новую функцию, которую мы позвоним Handleaddtodo Отказ

Важно отметить, что эта функция должна быть создана в самой компоненте (Addtodo), не снаружи этого. Когда Handleaddtodo передается на OnsUbmit Опора, он будет вызван, когда наша форма представлена:

// src/App.js
import "./styles.css";

// ...

function AddTodo() {
  function handleAddTodo() {}

  return (
    

      
      
    

  );
}

Как предотвратить поведение формы по умолчанию

Когда мы нажимаем кнопку «Отправить» или нажмите клавишу возврата, данные из события отправления передаются автоматически к нашей функции, подключенной к ONSUBMIT. Мы получаем эти данные события в параметрах Handleaddtodo Отказ

Первое, что мы хотим сделать с этим событием, называется методом на него называется .PreventDefault () Отказ Этот метод предотвращает действия по умолчанию всякий раз, когда мы отправляем форму:

// src/App.js
import "./styles.css";

// ...

function AddTodo() {
  function handleAddTodo(event) {
    event.preventDefault();
  }

  return (
    

      
      
    

  );
}

Всякий раз, когда мы отправляем форму, по умолчанию страница обновляется. Мы не хотим, чтобы это поведение с реагированием – мы хотим JavaScript контролировать все, что происходит дальше.

После предотвращения обновления мы хотим получить доступ к тому, что было напечатано на вход, чтобы создать новый Todo с ним. Как мы это делаем?

Как получить доступ к данным формы по представлению

То, как мы получаем доступ ко всем элементам в пределах нашей форме, с помощью недвижимости event.target.elements Отказ

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

Если бы мы были в Console.log event.target.elements Прямо сейчас отправьте нашу форму и посмотрите на нашу консоль, мы видим только объект с парой свойств, как называется «0», и один под названием «1».

Это не очень полезно для нас, хотя мы видим, что это наш вход и наша кнопка:

Вместо этого мы хотим получить то, что было напечатано на наш вклад.

Для этого мы можем добавить атрибут «ID», либо «имя» на нашему входу. Добавим атрибут имени со значением «ADDTODO». Когда мы снова ударим, это даст нам новое свойство на объекте элементов, также называемых Addtodo Отказ Из этой ссылки мы можем очень легко получить то, что было введено в него.

Это позволяет нам использовать Event.Target.Elements.adttodo.value Чтобы получить то, что было введено в любой текст. Когда мы сделаем это, когда мы введем текст на наш ввод, и нажмите «Отправить», мы видим, что он зарегистрирован в консоли:

Теперь, когда у нас есть наш текст, мы поставим его в переменную под названием «текст». Используя это, мы хотим создать новый Todo.

Мы знаем, что каждый TODO – это объект, и он должен состоять из идентификатора свойств, текста и выполненного. Давайте создадим переменную Todo И это будет равно новым объектам, где идентификатор будет 4, текст будет равен тексту, который мы получаем от объекта элементов, и мы можем установить для False.

По умолчанию новые добавления TODOS не будут сделаны:

// src/App.js
import "./styles.css";

//...

function AddTodo() {
  function handleAddTodo(event) {
    event.preventDefault();
    const text = event.target.elements.addTodo.value;
    const todo = {
      id: 4,
      text,
      done: false
    };
  }

  return (
    

      
      
    

  );
}

И, наконец, большой вопрос, как мы добавляем эту тоду на наш массив, Тодос ?

Введение в государство в реагировании

Это где приходит концепция государства.

Прямо сейчас мы имеем дело со статическими данными – нет реального способа обновить этот массив TODOS. Быть ясным, там это Способ сделать это с помощью JavaScript, но то, что мы в настоящее время не можем сделать, это скажут, даже если мы должны были обновить его, что ему нужно повторно рендеринг Этот список.

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

Государство требуется исправить нашу проблему.

Как управлять состоянием в реакции с крючком

Мы можем управлять состоянием в реакции, используя Уместите крюк. Чтобы использовать USESTATE крюк, первое, что нам нужно сделать, это импорт реагировать вверху вверху, потому что umestate поступает из основной библиотеки Ractive.

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

Уместитель возвращает массив двумя элементами:

  1. Первоначальное значение, которое мы позвонили в размере (нашем массиве TODOS), и это становится нашей государственной переменной
  2. Специальная функция, которая позволяет нам обновлять, что хранится в переменной состояния

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

Мы позвоним нашей государственной переменной Тодос и сеттер для управления нашим государством Сатодос Отказ

Все, что нам нужно сделать, чтобы обновить наше состояние – пройти его, все, что мы хотим, чтобы новое состояние было. Это Сатодос Функция будет передана на наш компонент ADDTODO, поэтому давайте добавим это как опору одно и то же имя. Мы также разрушаем Сатодос от нашего объекта реквизита в Addtodo.

И, наконец, мы можем позвонить Сатодос внизу Handleaddtodo Отказ Что значительно в этой функции, вместо того, чтобы передать массив Todos, эта функция может дать нам предыдущее состояние с помощью функции, которую мы можем получить внутри него:

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

Если бы мы хотели опустошить наше состояние TODOS, мы могли бы просто вернуть пустой массив прямо здесь. Если бы мы должны были представить нашу форму, мы бы увидим, что все наши Тодос были удалены.

Как только мы отправим нашу форму, состояние обновляется, и наше приложение повторно оказывается в результате.

Рендеры в реакцию

Обратите внимание, что любая повторная визуализация внутри родительского компонента приведет к восстановлению каких-либо дочерних компонентов. Это означает, когда наши данные TODO обновляются, тодолистский компонент (ребенок компонента приложения) обновляется с помощью этих новых данных.

Если мы вернемся к Handleaddtodo мы можем взять наши предыдущие Тодос и использовать .concat () Способ добавить эту новую тоду в наш массив в штате. Все, что нам нужно сделать, это вернуть это выражение.

Давайте добавим новый TODO, например, «Checkbook Balance». Как только мы ударим отправку, мы видим, что сразу добавлено в наш список:

Теперь здесь есть одна проблема: мы не очищаем наш вклад после отправки нашей формы.

Это означает, что если бы мы хотели добавить еще один TODO, мы должны были бы вручную очистить его. Как мы возьмем это значение и очистить это?

React Refs и Useref

Для проведения общих действий, таких как очистка значения ввода или фокусировка нашего ввода, мы можем использовать то, что называется A Ref Отказ

В этом случае мы хотим ссылку на этот входной элемент с именем «Addtodo».

Как и наше государство, мы можем работать с Refs, вызывая соответствующий реактивный крюк. Чтобы создать Ref, нам просто нужно позвонить Rect.Useref () В верхней части Addtodo. Нам не нужно пропускать его начальное значение, но мы можем дать ему значение по умолчанию, если нам нужно.

Мы будем называть это создано Ref inputref Отказ Использование INPUTREF, мы можем создать ссылку на наш входной элемент, который мы можем получить доступ к везде, где нам нравится, используя встроенный REF PROP, установив ref = {inputref} :

// src/App.js
import React from "react";
import "./styles.css";

//...

function AddTodo({ setTodos }) {
  const inputRef = React.useRef();

  function handleAddTodo(event) {
    event.preventDefault();
    const text = event.target.elements.addTodo.value;
    const todo = {
      id: 4,
      text,
      done: false
    };
    setTodos((prevTodos) => {
      return prevTodos.concat(todo);
    });
  }

  return (
    

      
      
    

  );
}

Что это делает? Это позволяет нам внутри Handleaddtodo использовать свойство inputref.current , который содержит сам входной элемент. Если бы мы хотели регистрировать input.ref.wurrent Мы бы увидели наш входной элемент.

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

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

Основные правила реагированных крюков

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

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

Но, как видите, нет ничего особенного в реактивных крючках. Они работают очень похоже на регулярные функции JavaScript.

Как отметить TODOS как сделать с OnClick

После создания Тодоса мы хотим переключить их – чтобы ударить их, если мы закончили данную TODO. Как мы добавим эту функцию?

Если мы вернемся к нашему списку элемент, в ToList, мы можем увидеть, что это будет выглядеть, применяя некоторые встроенные стили. Мы видели, как добавить стили через классы. Для стилей, которые мы хотим применить внизу на любой данный элемент, мы не можем использовать тот же синтаксис, поскольку мы будем с обычным HTML.

Если мы попытались использовать синтаксис HTML, мы собираемся получить ошибку, сообщаю нам «Стиль опоры ожидает свойств стиля в объекте, а не в строке»:

Чтобы исправить это, мы предоставим объект. Нам нужно предоставить этот объект в течение другого набора фигурных скобок. Затем мы предоставим любое недвижимость, как мы бы в обычном объекте JavaScript, чтобы применить этот удар по стилю.

Для каждого из наших элементов списка мы можем установить свойство TextDecoration до «продвижения»:

Мы не хотим, чтобы каждый предмет был ударил, мы только хотим, чтобы это было применено, если данный TODO сделан. Как мы это делаем?

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

Если мы изменим один из наших массив ToDos, чтобы сделать доброе значение правда Мы видим, что это правило стиля применяется:

// src/App.js

//...

function TodoList({ todos }) {
  return (
    
    
      {todos.map((todo) => (
        
  • 
          {todo.text}
        
    • 
      ))}
    

  );
}

//...

Как мы на самом деле переключаем это Todo?

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

Чтобы обрабатывать событие щелчка с реагированием, мы предоставляем OnClick опоры до данного элемента, для которого мы хотим зарегистрировать это событие. В этом случае это Ли элемент.

Еще раз, нам нужно подключить его к функции для обработки нашего события клики. Мы собираемся назвать это Handletoggletodo И создать его в нашем тодолистском компонентах. В этом случае наша функция, которую мы используем для обработки события, не должны получать какие-либо данные о событиях. Эта функция будет обработать обновление нашего государства TODO.

Мы хотим Handletoggletodo пройти через Тодос Массив и посмотрите, нажал ли тот, который пользователь нажал на существование в нашем массиве. Если это так, его величина может быть переключена на противоположное логическое значение.

Чтобы получить соответствующие данные ToDo для соответствующего списка элемент, который нажат, мы можем позвонить Handletoggletodo В качестве встроенной стрелки функция и передайте данные Todo в качестве аргумента:

// src/App.js

//...

function TodoList({ todos }) {
  function handleToggleTodo(todo) {}
    
  return (
    
    
      {todos.map((todo) => (
        
  •  handleToggleTodo(todo)}
          style={{
            textDecoration: todo.done ? "line-through" : ""
          }}
          key={todo.id}
        >
          {todo.text}
        
    • 
      ))}
    

  );
}

//...

Чтобы обновить наше состояние TODOS, мы передадим Сатодос к нашему тодолисту компоненту. Мы передадим Сатодос как опоры для тодолиста и разрушают его от объекта реквизита.

Еще раз, мы можем позвонить Сатодос и получить доступ к предыдущему TODOS, включая внутреннюю функцию. Во-первых, что мы можем сделать, это взять нашу нашу массив TODOS и карту над ним с .map () Функция массива.

Во внутренней функции передается на карту, мы проверим, что ID TODOS мы отображаем, равное ToDo, нажав на нажав. Если это так, мы возвращаем новый объект со всеми предыдущими свойствами ToDo, но с сделано переключается на противоположное логическое значение:

// src/App.js

//...

function TodoList({ todos, setTodos }) {
  function handleToggleTodo(todo) {
    // confused by this code? Here's what it says:
      
    // if a todo's id is equal to the one we clicked on,
    // just update that todo's done value to its opposite,
    // otherwise, do nothing (return it)
      
    const updatedTodos = todos.map((t) =>
      t.id === todo.id
        ? {
            ...t,
            done: !t.done
          }
        : t
    );
  }

  return (
    
    
      {todos.map((todo) => (
        
  •  handleToggleTodo(todo)}
          style={{
            textDecoration: todo.done ? "line-through" : ""
          }}
          key={todo.id}
        >
          {todo.text}
          
        
    • 
      ))}
    

  );
}

//...

В противном случае, если это то, что мы иверим, не тот, на которого мы нажали, мы просто хотим его вернуть (без изменения его). Этот обновленный массив – это то, что мы перейдем к Сатодос обновить наше состояние.

Если мы нажмем на Todo, мы переключаем это. Если мы снова нажимаем на него, он переключается, чтобы отменить:

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

Вместо того, чтобы настроить каждый новый TOO, чтобы иметь ID 4, мы можем просто использовать Math.random () Чтобы сделать полустороннее значение и убедиться, что нет элементов списка с тем же идентификатором.

Наконец, как альтернатива OnClick мы можем использовать другое опор события, ondoubleclick В случае, если пользователи случайно щелкнули данную TODO. Теперь, если пользователь дважды щелкнул элемент списка, только тогда мы переключаем это.

Как обращаться с удалением ToDos

Последний кусочек функциональности, которые мы ищем, это уметь удалить данный TODO.

Мы можем добавить эту функциональность в ToDolist, добавив еще один вложенный компонент. Под нашим текстом Todo мы добавим новый компонент: DELETETODO. Давайте объявляем этот новый компонент выше, где мы объявили Addtodo.

Что состоит этот компонент? В нем мы вернем диапазон, который будет функционировать как кнопку для нас. Пользователь может нажать на это и удалить данный TODO.

На наш пролет, давайте добавим некоторые правила стиля – мы можем дать ему цвет красного цвета, делайте его смелым, и отделите его из текста Todo, установив MarginLeft: 10 Отказ Что ждете в отношении объекта стиля, заключается в том, что нам не нужно говорить 10 пикселей в виде строки – мы можем использовать значение 10 или включить любое целое число, которое нам нравится.

Вот код для нашего компонента Deletetodo до сих пор:

Чтобы удалить TODO, мы хотим иметь возможность нажать на него и показать диалоговое окно подтверждения. Если пользователь подтверждает, что они хотят удалить его, только тогда это удален Todo.

Поскольку мы отображаем каждый товар TODO, включая DeletetoDo, мы можем пропустить опоры под названием только Todo с каждыми данными Todo на нем.

В Deletetodo, на нашем элементе SPAN, мы хотим добавить OnClick обращаться с удалением нашего Todo. Чтобы справиться с этим, мы назовем новую функцию: Обрабатывающая обработка Отказ

Используя эту функцию, сначала мы хотим показать диалоговое окно подтверждения. Мы можем сделать это, сказав window.confirm () С сообщением: «Вы хотите удалить это»? окно.confirm собирается вернуть значение true или false на основе того, подтвердил ли пользователь диалоговое окно или нет. Мы поставим результат этого действия в переменной под названием подтвержден :

// src/App.js
// ...

function TodoList({ todos, setTodos }) {
  // ...

  return (
    
    
      {todos.map((todo) => (
        
  •  handleToggleTodo(todo)}
          style={{
            textDecoration: todo.done ? "line-through" : ""
          }}
          key={todo.id}
        >
          {todo.text}
          {/* pass todo data down as a prop to DeleteTodo */}
          
        
    • 
      ))}
    

  );
}

function DeleteTodo({ todo, setTodos }) {
  function handleDeleteTodo() {
    const confirmed = window.confirm("Do you want to delete this?");
    if (confirmed) {
      // take care of deleting the todo
    }
  }

  return (
    
      x
    
  );
}

//...

Если подтвержден Это правда, только тогда мы хотим удалить Todo.

Для этого нам нужно использовать Сатодос снова. Мы передам его еще один уровень от тодолиста к компоненту делитетодо и разрушают его от объекта реквизита.

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

Для этого мы уверены, что все TODOS в нашем массиве не имеют идентификатора, равного тому, которое мы пытаемся удалить:

// src/App.js

// ...

function DeleteTodo({ todo, setTodos }) {
  function handleDeleteTodo() {
    const confirmed = window.confirm("Do you want to delete this?");
    if (confirmed) {
      setTodos((prevTodos) => {
        return prevTodos.filter((t) => t.id !== todo.id);
      });
    }
  }

  return (
    
      x
    
  );
}

// ...

Теперь, если мы попытаемся удалить один из наших TODOS, мы видим наш диалог подтверждения, мы ударили «ОК», и немедленно его удалено из нашего списка.

Если мы удалим все наши Тодос, мы больше ничего не видим. Если мы хотим сказать, что наш пользователю нет TODOS в списке, когда массив пуст, давайте отправимся до нашего тодолиста.

Если у нас есть пустой массив TODOS, мы можем добавить условное выше наше возвращение и проверять, будет ли длина нашего массива равна 0. Если это так, мы будем отображать элемент абзаца с текстом «Нет TODOS):

// ...

function TodoList({ todos, setTodos }) {
  function handleToggleTodo(todo) {
    const updatedTodos = todos.map((t) =>
      t.id === todo.id
        ? {
            ...t,
            done: !t.done
          }
        : t
    );
    setTodos(updatedTodos);
  }

  if (!todos.length) {
    return 
No todos left!
;
  }

  return (
    
    
      {todos.map((todo) => (
        
  •  handleToggleTodo(todo)}
          style={{
            textDecoration: todo.done ? "line-through" : ""
          }}
          key={todo.id}
        >
          {todo.text}
          
        
    • 
      ))}
    

  );
}

// ...

Поздравляю!

Теперь у вас есть работающее приложение TODO, которое имеет полную функциональность CRUD, которая может создавать, читать, обновлять и удалять TODOS.

Вы смогли понять, сколько основных концепций React React Rections работают в первую очередь, и вы сейчас находитесь в отличном положении, чтобы начать строить свои собственные приложения React.

Если вы хотите посмотреть на наш последний код приложения, вы можете увидеть это здесь Отказ

Готов к следующему шагу? Присоединяйтесь к React BootCamp

React Bootcamp Занимает все, что вы должны знать о изучении реагирования и связки в один комплексный пакет, включая видео, обманывать, плюс специальные бонусы.

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

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

Читайте ещё по теме: