React 备忘清单

import React, {Component} from 'react'
import ReactDOM from 'react-dom'

export class Hello extends Component {
  ...
}
export default function World() {
  /* ... */
}

使用 export 导出 Hello，export default 导出 World 组件

import World, { Hello } from './hello.js';

使用 import 导入 Hello 组件，在示例中使用。

import React from "react";
import "./Student.css";

export const Student = (
  <div className="Student"></div>
);

注意：类属性 className

const divStyle = {
  backgroundImage: 'url(' + imgUrl + ')',
};
export const Student = (
  <div style={divStyle}></div>
);

<Student name="Julie" age={23}
  pro={true} />

函数组件 Student 中访问属性

function Student(props) {
  return <h1>Hello, {props.name}</h1>;
}

Class 组件 Student 中访问属性

class Student extends React.Component {
  render() {
    return (
      <h1>Hello, {this.props.name}</h1>
    );
  }
}

class 组件使用 this.props 访问传递给组件的属性。

const elm = ['one', 'two', 'three'];
function Student() {
  return (
    <ul>
      {elm.map((value, index) => (
        <li key={index}>{value}</li>
      ))}
    </ul>
  );
}

key 值在兄弟节点之间必须唯一

export default function Hello() {
  function handleClick(event) {
    event.preventDefault();
    alert("Hello World");
  }

  return (
    <a href="/" onClick={handleClick}>
      Say Hi
    </a>
  );
}

function addNumbers(x1, x2) {
  return x1 + x2;
}

const element = (
  <div>
    {addNumbers(2, 5)}
  </div>
);

import { useState } from 'react'
import Avatar from './Avatar';
import Profile from './Profile';

function Student() {
  const [count, setCount] = useState(0);
  return (
    <div>
      <Avatar src={count} />
      <Profile username={count} />
    </div>
  );
}

React 并_没有_创建一个新的 div。它只是把子元素渲染到 domNode 中。domNode 是一个可以在任何位置的有效 DOM 节点。

render() {
  return ReactDOM.createPortal(
    this.props.children,
    domNode
  );
}

提供了一种将子节点渲染到存在于父组件以外的 DOM 节点的优秀的方案

render() {
  return 'Look ma, no spans!';
}

您可以只返回一个字符串。查看: Fragments & strings

const Student = () => [
  <li key="A">First item</li>,
  <li key="B">Second item</li>
];

不要忘记 key！查看: Fragments & strings

import {Component,createRef} from 'react'

class MyComponent extends Component {
  constructor(props) {
    super(props);
    this.myRef = createRef();
  }

  render() {
    return <div ref={this.myRef} />;
  }
}

提示：Refs 适用于类组件，但不适用于函数组件（除非您使用 useRef hook，请参阅hooks）

function CustomTextInput(props) {
  // 这里必须声明 $input，这样 ref 才可以引用它
  const $input = useRef(null);
  function handleClick() {
    $input.current.focus();
  }
  return (
    <div>
      <input type="text" ref={$input} />
      <input
        type="button" value="聚焦文本输入"
        onClick={handleClick}
      />
    </div>
  );
}

<div>
  <Header />
  <React.StrictMode>
    <div>
      <ComponentOne />
      <ComponentTwo />
    </div>
  </React.StrictMode>
  <Footer />
</div>

• 识别不安全的生命周期
• 关于使用过时字符串 ref API 的警告
• 关于使用废弃的 findDOMNode 方法的警告
• 检测意外的副作用
• 检测过时的 context API
• 确保可复用的状态

突出显示应用程序中潜在问题的工具。请参阅：严格模式

function CustomButton(props) {
  const { color = 'blue' } = props;
  return <div>{color}</div>
}

function CustomButton() {
  const [color, setColor]=useState('blue')
  return <div>{color}</div>
}

扩展运算符可用于一次传递所有 Props。

function Profile(props) {
  return <p>{props.name}, {props.age}</p>;
}

const user = { name: "John", age: 25 };
<Profile {...user}/>

• Props（“properties”的缩写）用于将数据从父组件传递到子组件。
• 它们是只读的，不能在子组件内修改。

<MyComponent propName="value" />

您可以通过 JSX 中的属性将 props 从父组件传递到子组件。

function ParentComponent() {
  return <ChildComponent name="John" age={25} />;
}

function ChildComponent (props) {
  return <div>Hello，{props.name}. You are {props.age} years old. </div>;
}

props 可以解构以便于访问。

function Greeting({ name }) {
  return <h1>Hello, {name}!</h1>;
}

可以使用 props 对象在功能组件中访问 Props。

function Greeting(props) {
  return <h1>Hello, {props.name}!</h1>;
}

道具可用于组件内部的条件渲染。

function Greeting({ name, isLoggedIn }) {
  return isLoggedIn ? <hl>Welcome back, {name}</h1>: <h1>Please log in</h1>;
}

function Greeting({ name = "Bob" } = 0}) {
  return <h1>Hello, {name}!</h1>;
}
// Renders "Hello, Bob!"
< Greeting />

您可以为 props 设置默认值。

你可以将事件处理程序作为 props 传递给 handle 用户交互。

function Button({ onClick }) {
  return < button onClick={onClick}>Click me</button>;
}

function App() {
  const handleClick = () => alert("Button clicked!"):
  return <Button onClick={handleClick} />;
}

const Menu = ({ children }) => (
  <div className="menu">{children}<div>
);

Menu.Item = ({ children }) => (
  <div>{children}<div>
);

<Menu>
  <Menu.Item>菜单一</Menu.Item>
  <Menu.Item>菜单二</Menu.Item>
<Menu>

let element = <h1>Hello, world!</h1>;
let emptyHeading = <h1 />;

const root = ReactDOM.createRoot(
  document.getElementById('root')
);

const element = <h1>Hello, world</h1>;
root.render(element);

参考：渲染元素

const avatarUrl = "img/picture.jpg"
const element = <img src={avatarUrl} />;

const element = (
  <button className="btn">
    点击我
  </button>
);

注意：类属性 className

let name = '张三';
let element = <h1>Hello, {name}</h1>;

function fullName(firstName, lastName) {
  return firstName + ' ' + lastName;
}
let element = (
  <h1>
    Hello, {fullName('三', '张')}
  </h1>
);

const divStyle = {
  color: 'blue',
  backgroundImage: 'url(' + imgUrl + ')',
};
function MyComponent() {
  return <div style={divStyle}>组件</div>;
}

const markup = {__html: '我 · 你' };

const MyComponent = () => (
  <div dangerouslySetInnerHTML={markup} />
);

dangerouslySetInnerHTML 是 React 为浏览器 DOM 提供 innerHTML 的替换方案。

const MyComponent = () => (
  <div>
    <input type="radio" id="ab" name="v">
    <label for="ab">HTML</label>
  </div>
);

for 在 JS 中是保留字，JSX 元素使用了 htmlFor 代替

非受控组件的属性，设置组件第一次挂载时的 value

<textarea defaultValue="Hello" />

<input>、<select> 和 <textarea> 支持 value 属性

非受控组件的属性，设置组件是否被选中

<input type="radio" defaultChecked />

类型为 checkbox 或 radio 时，组件支持 checked 属性

属性用于指定 CSS 的 class

<div className="warp">...</div>

React 中使用 Web Components 使用 class 属性代替

export default function Weather(props) {
  const isLoggedIn = props.isLoggedIn;
  return (
    <div>
      <b>{isLoggedIn ? '已' : '未'}</b>登录。
    </div>
  );
}

{isShow && <div>内容</div>}

<Dropdown>
  下拉列表
  <Menu>
    <Menu.Item>菜单一</Menu.Item>
    <Menu.Item>菜单二</Menu.Item>
    <Menu.Item>菜单三</Menu.Item>
  </Menu>
</Dropdown>

组件名称以大驼峰式命名。

function Greeting(props) {
  let button;
  if (props.isLoggedIn) {
    button = <UserGreeting />;
  } else {
    button = <GuestGreeting />;
  }
  return <div>{button}</div>;
}

function Student() {
  const [count, setCount] = useState(0);
  return (
    <Fragment>
      {/* 这里写注释 */}
    </Fragment>
  );
}

class Welcome extends React.Component {
  render() {
    return <h1>{this.props.name}</h1>;
  }
}

import React, {PureComponent} from 'react'

class MessageBox extends PureComponent {
  ···
}

import React, { Component } from 'react';
// 高阶组件 with
const with = data => WrappedComponent => {
  return class extends Component {
    constructor(props) {
      super(props);
    }
    render() {
      return (
        <WrappedComponent data={data} />
      )
    }
  }
}

使用高阶组件

const LowComponent = (props) => (
  <div>{props.data}</div>
);

const MyComp = with('Hello')(LowComponent)

function FancyBorder(props) {
  return (
    <div className={'Fancy'+props.color}>
      {props.children}
    </div>
  );
}

组件可以通过 JSX 嵌套

function WelcomeDialog() {
  return (
    <FancyBorder color="blue">
      <h1 className="title">欢迎</h1>
      <p className="message">
        感谢您访问我们的宇宙飞船
      </p>
    </FancyBorder>
  );
}

function SplitPane(props) {
  return (
    <div className="SplitPane">
      <div className="left">
        {props.left}
      </div>
      <div className="right">
        {props.right}
      </div>
    </div>
  );
}

function App() {
  return (
    <SplitPane
      left={<Contacts />}
      right={<Chat />}
    />
  );
}

给组件 SplitPane 传递 left 和 right 两个组件参数

import React from 'react';
import UserAvatar from "./UserAvatar";

export default function UserProfile() {
  return (
    <div className="UserProfile">
      <UserAvatar />
      <UserAvatar />
    </div>
  );
}

注意：假设 UserAvatar 在 UserAvatar.js 中声明

import React from 'react';
import {Button} from 'uiw';
export default function UserProfile() {
  return (
    <div className="UserProfile">
      <Button type="primary">
        主要按钮
      </Button>
    </div>
  );
}

注意：uiw 组件在 npmjs.com 上找到，需要先安装导入

const Menu = ({ children }) => (
  <div className="menu">{children}<div>
);

Menu.Item = ({ children }) => (
  <div>{children}<div>
);

<Menu>
  <Menu.Item>菜单一</Menu.Item>
  <Menu.Item>菜单二</Menu.Item>
<Menu>

function TextInputWithFocusButton() {
  const $input = useRef(null);
  const onButtonClick = () => {
    $input.current.focus();
  };
  return (
    <>
      <input ref={$input} type="text" />
      <button onClick={onButtonClick}>
        聚焦输入
      </button>
    </>
  );
}

current 指向已挂载到 DOM 上的文本输入元素

function FancyInput(props, ref) {
  const inputRef = useRef();
  useImperativeHandle(ref, () => ({
    focus: () => {
      inputRef.current.focus();
    }
  }));
  return <input ref={inputRef} />;
}
FancyInput = forwardRef(FancyInput);

父组件使用

<FancyInput ref={inputRef} />
inputRef.current.focus()

useEffect(() => {
  const subs = props.source.subscribe();
  return () => {
    subs.unsubscribe();
  };
}, [props.source]);

const memoizedCallback = useCallback(
  () => {
    doSomething(a, b);
  },
  [a, b],
);

const memoizedValue = useMemo(
  () => {
    return computeExpensiveValue(a, b)
  },
  [a, b]
);

function Checkbox() {
  const id = useId();
  return (
    <>
      <label htmlFor={id}>
        你喜欢React吗？
      </label>
      <input id={id} type="checkbox" />
    </>
  );
};

用于生成跨服务端和客户端稳定的唯一 ID 的同时避免 hydration 不匹配

function useFriendStatus(friendID) {
  const [
    isOnline, setIsOnline
  ] = useState(null);
  // ...
  // 在开发者工具中的这个 Hook 旁边显示标签
  // e.g. "FriendStatus: Online"
  useDebugValue(
    isOnline ? 'Online' : 'Offline'
  );
  return isOnline;
}

不推荐你向每个自定义 Hook 添加 debug 值

useEffect(
  () => {
    // componentDidMount
    // 组件挂载时，可以在这里完成你的任务
    return () => {
      // componentWillUnmount
      // 卸载时执行，清除 effect
    };
  },
  [ ]
);

这是一个类似 class 组件中 componentDidMount & componentWillUnmount 两个生命周期函数的写法。

MyComponent.propTypes = {
  email:      PropTypes.string,
  seats:      PropTypes.number,
  callback:   PropTypes.func,
  isClosed:   PropTypes.bool,
  any:        PropTypes.any
  symbol:     PropTypes.symbol,
}

你可以将属性声明为 JS 原生类型，默认都是可选的。

MyComponent.propTypes = {
  // 确保这个 prop 没有被提供时，会打印警告信息
  requiredFunc: PropTypes.func.isRequired,

  // 任意类型的必需数据
  requiredAny: PropTypes.any.isRequired,
}

你可以在任何 PropTypes 属性后面加上 isRequired。

MyComponent.propTypes = {
  // 只能是特定的值，枚举类型。
  optionalEnum: PropTypes.oneOf([
    'News', 'Photos'
  ]),
  // 一个对象可以是几种类型中的任意一个类型
  optionalUnion: PropTypes.oneOfType([
    PropTypes.string,
    PropTypes.number,
    PropTypes.instanceOf(Message)
  ]),
}

MyComponent.propTypes = {
  // 任何可被渲染的元素
  // (包括数字、字符串、元素或数组)
  // (或 Fragment) 也包含这些类型。
  node: PropTypes.node,

  // 一个 React 元素。
  element: PropTypes.element,

  // 一个 React 元素类型（即，MyComponent）
  elementType: PropTypes.elementType,
}

MyComponent.propTypes = {
  // 可以指定一个对象由某一类型的值组成
  objectOf: PropTypes.objectOf(
    PropTypes.number
  ),
  // 可以指定一个对象由特定的类型值组成
  objectWithShape: PropTypes.shape({
    color: PropTypes.string,
    fontSize: PropTypes.number
  }),
  // 带有额外属性警告的对象
  objectWithStrictShape: PropTypes.exact({
    name: PropTypes.string,
    quantity: PropTypes.number
  }),
}

MyComponent.propTypes = {
  custom: (props, propName, compName) => {
    if (!/matchm/.test(props[propName])) {
      // 它在验证失败时应返回一个 Error 对象
      return new Error(
        '无效的prop `'
        ` \`${propName}\` 提供给` + 
        ` \`${compName}\`。验证失败。`
      );

    }
  },
}

请不要使用 console.warn 或抛出异常，因为这在 oneOfType 中不会起作用。

MyComponent.propTypes = {
  arr: PropTypes.arrayOf(PropTypes.number),
};

可以指定一个数组由某一类型的元素组成

MyComponent.propTypes = {
  message: PropTypes.instanceOf(Message),
};

声明 message 为类的实例