Spec-Zone.ru › React Native

Основы React

React Native работает на React, популярной библиотеке с открытым исходным кодом для создания пользовательских интерфейсов с использованием JavaScript. Для максимального использования React Native полезно понимать сам React. Этот раздел поможет вам начать работу или послужит курсом для освежения знаний.

Мы рассмотрим основные понятия React:

  • компоненты
  • JSX
  • свойства (props)
  • состояние (state)

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

Ваш первый компонент

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

  • Функциональный компонент
  • Компонент класса

Вот как это делается: для определения вашего Cat компонента, сначала используйте JavaScript import, чтобы импортировать React и Text Core Component React Native:

import React from 'react';
import { Text } from 'react-native';

Ваш компонент начинается как функция:

const Cat = () => {};

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

Здесь компонент Cat отобразит элемент <Text>:

const Cat = () => {
  return <Text>Hello, I am your cat!</Text>;
};

Вы можете экспортировать свой функциональный компонент с помощью JavaScript export default для использования в приложении, как показано ниже:

const Cat = () => {
  return <Text>Hello, I am your cat!</Text>;
};

export default Cat;

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

Вы дополнительно импортируете Component из React:

import React, { Component } from 'react';

Ваш компонент начинается как класс, расширяющий Component вместо функции:

class Cat extends Component {}

Компоненты класса имеют функцию render(). Все, что возвращается внутри неё, отображается как элемент React:

class Cat extends Component {
  render() {
    return <Text>Hello, I am your cat!</Text>;
  }
}

И, как и в случае с функциональными компонентами, вы можете экспортировать свой компонент класса:

class Cat extends Component {
  render() {
    return <Text>Hello, I am your cat!</Text>;
  }
}

export default Cat;

Это один из многих способов экспорта вашего компонента. Такой способ экспорта хорошо работает с Snack Player. Однако в зависимости от структуры файлов вашего приложения вам может потребоваться использовать другую конвенцию. Эта полезная шпаргалка по импорту и экспорту JavaScript может помочь.

Теперь более подробно рассмотрим оператор return. <Text>Hello, I am your cat!</Text> использует вид синтаксиса JavaScript, который делает написание элементов удобным: JSX.

JSX

React и React Native используют JSX, синтаксис, который позволяет писать элементы внутри JavaScript, например: <Text>Hello, I am your cat!</Text>. Документация React содержит полное руководство по JSX, которое вы можете использовать для получения дополнительной информации. Поскольку JSX является JavaScript, вы можете использовать переменные внутри него. Здесь вы объявляете имя для кошки, name, и встраиваете его с помощью фигурных скобок в <Text>.

Любой JavaScript-выражение будет работать между фигурными скобками, включая вызовы функций, такие как {getFullName("Rum", "Tum", "Tugger")}:

Вы можете рассматривать фигурные скобки как создание портала в функциональность JS в вашем JSX!

Поскольку JSX включён в библиотеку React, он не будет работать, если у вас нет import React from 'react' в верхней части файла!

Пользовательские компоненты

Вы уже познакомились с базовыми компонентами React Native. React позволяет вкладывать эти компоненты друг в друга, чтобы создавать новые компоненты. Эти вложенные, многоразовые компоненты лежат в основе парадигмы React.

Например, вы можете вложить Text и TextInput в View ниже, и React Native отобразит их вместе:

Примечания для разработчиков

  • Android
  • Веб

Если вы знакомы с веб-разработкой, <View> и <Text> могут напомнить вам об HTML! Вы можете рассматривать их как теги <div> и <p> в разработке приложений.

В Android вы обычно помещаете свои представления внутри LinearLayout, FrameLayout, RelativeLayout, и т. д., чтобы определить, как представления-потомки будут расположены на экране. В React Native View использует Flexbox для макета своих потомков. Вы можете узнать больше в нашем руководстве по макетам с Flexbox.

Вы можете отображать этот компонент несколько раз и в разных местах, не дублируя код, используя <Cat>:

Любой компонент, который отображает другие компоненты, является родительским компонентом. Здесь Cafe является родительским компонентом, а каждый Cat является дочерним компонентом.

Вы можете разместить в кафе столько кошек, сколько захотите. Каждый <Cat> отображает уникальный элемент, который можно настроить с помощью свойств (props).

Свойства (Props)

Свойства (Props) — это «свойства». Свойства позволяют настраивать компоненты React. Например, здесь вы передаёте каждой <Cat> разное name для отображения Cat:

Большинство базовых компонентов React Native также можно настраивать с помощью свойств (props). Например, при использовании Image, вы передаёте ему свойство, называемое source, чтобы определить, какое изображение он отображает:

Image имеет множество различных свойств (props), включая style, которое принимает JS-объект пар «свойство-значение», связанных с дизайном и макетом.

Обратите внимание на двойные фигурные скобки {{ }} вокруг ширины и высоты style. В JSX JavaScript-значения ссылаются с помощью {}. Это удобно, если вы передаёте что-то, отличное от строки, как свойства, например, массив или число: <Cat food={["fish", "kibble"]} age={2} />. Однако JS-объекты также обозначаются фигурными скобками: {width: 200, height: 200}. Поэтому, чтобы передать JS-объект в JSX, вы должны обернуть объект в ещё одну пару фигурных скобок: {{width: 200, height: 200}}

Вы можете создать многое с помощью свойств (props) и базовых компонентов Text, Image и View! Но чтобы создать что-то интерактивное, вам понадобится состояние (state).

Состояние (State)

В то время как свойства (props) можно рассматривать как аргументы, используемые для настройки того, как компоненты отображаются, состояние (state) — это как личное хранилище данных компонента. Состояние полезно для обработки данных, которые изменяются со временем или поступают от взаимодействия пользователя. Состояние даёт компонентам память!

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

Следующий пример происходит в кошачьей кафе, где две голодные кошки ждут, чтобы их покормили. Их голод, который, по нашим ожиданиям, будет меняться со временем (в отличие от их имён), хранится в состоянии. Чтобы накормить кошек, нажмите на их кнопки — это обновит их состояние.

  • Функциональный компонент
  • Компонент класса

Вы можете добавить состояние в компонент, вызвав хук useState React. Хук — это своего рода функция, которая позволяет вам «подключиться» к функциям React. Например, useState — это хук, который позволяет добавить состояние в функциональные компоненты. Вы можете узнать больше о других типах хуков в документации React по ссылке.

Сначала вам необходимо импортировать useState из React следующим образом:

import React, { useState } from 'react';

Затем вы объявляете состояние компонента, вызвав useState внутри его функции. В этом примере, useState создаёт переменную состояния isHungry.

const Cat = (props) => {
  const [isHungry, setIsHungry] = useState(true);
  // ...
};

Вы можете использовать useState для отслеживания любых данных: строк, чисел, булевых значений, массивов, объектов. Например, вы можете отслеживать количество раз, когда кошку гладили с помощью const [timesPetted, setTimesPetted] = useState(0)!

Вызов useState выполняет две задачи:

  • создаёт переменную «состояния» с начальным значением — в данном случае, переменная состояния — isHungry, а её начальное значение — true;
  • создаёт функцию для установки значения этой переменной состояния — setIsHungry;

Имена переменных могут быть любыми. Но удобно представлять этот шаблон как [<getter>, <setter>] = useState(<initialValue>).

Далее добавьте компонент ядра Button и задайте ему свойство onPress:

<Button
  onPress={() => {
    setIsHungry(false);
  }}
  //..
/>

Теперь, когда кто-то нажимает кнопку, onPress будет вызывать setIsHungry(false). Это устанавливает переменную состояния isHungry в значение false. Когда isHungry равно false, свойство Button компонента устанавливается в значение true, а его свойство title также изменяется:

<Button
  //..
  disabled={!isHungry}
  title={isHungry ? 'Pour me some milk, please!' : 'Thank you!'}
/>

Вы могли заметить, что хотя isHungry — это const, она, похоже, переназначается! Всё дело в том, что когда вызывается функция установки состояния, например, setIsHungry, её компонент будет перерисовываться. В этом случае функция Cat будет снова запущена — и на этот раз useState даст нам следующее значение isHungry.

Наконец, поместите ваших кошек в компонент Cafe:

const Cafe = () => {
  return (
    <>
      <Cat name="Munkustrap" />
      <Cat name="Spot" />
    </>
  );
};

В старых классах компонентов подход к состоянию немного отличается.

Как всегда с классами компонентов, необходимо импортировать класс Component из React:

import React, { Component } from 'react';

В классах компонентов состояние хранится в объекте состояния:

export class Cat extends Component {
  state = { isHungry: true };
  //..
}

Так же, как и при обращении к свойствам с помощью this.props, вы обращаетесь к этому объекту внутри компонента с помощью this.state:

<Text>
  I am {this.props.name}, and I am
  {this.state.isHungry ? ' hungry' : ' full'}!
</Text>

И вы устанавливаете отдельные значения внутри объекта состояния, передавая объект с парой ключ-значение для состояния и его нового значения в this.setState():

<Button
  onPress={() => {
    this.setState({ isHungry: false });
  }}
  // ..
/>

Не изменяйте состояние вашего компонента напрямую, присваивая ему новое значение с помощью this.state.isHungry = false. Вызов this.setState() позволяет React отслеживать изменения, внесённые в состояние, что приводит к перерисовке. Прямое изменение состояния может нарушить реактивность вашего приложения!

Когда this.state.isHungry равно false, свойство Button компонента устанавливается в значение true, а его свойство title также изменяется:

<Button
  // ..
  disabled={!this.state.isHungry}
  title={
    this.state.isHungry
      ? 'Pour me some milk, please!'
      : 'Thank you!'
  }
/>

Наконец, поместите ваших кошек в компонент Cafe:

class Cafe extends Component {
  render() {
    return (
      <>
        <Cat name="Munkustrap" />
        <Cat name="Spot" />
      </>
    );
  }
}

export default Cafe;

Вы видите <> и </> выше? Эти части JSX являются фрагментами. Смежные элементы JSX должны быть заключены в окружающий тег. Фрагменты позволяют вам сделать это, не вкладывая дополнительный, ненужный оберточный элемент, например, View.

Теперь, когда вы рассмотрели компоненты ядра React и React Native, давайте углубимся в некоторые из этих компонентов ядра, изучив обработку <TextInput>.

© 2022 Facebook Inc.
Licensed under the Creative Commons Attribution 4.0 International Public License.
https://reactnative.dev/docs/intro-react

END_OF_DOCUMENT_MARKER

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API