【问题标题】:React.js - input losing focus when rerenderingReact.js - 重新渲染时输入失去焦点
【发布时间】:2014-04-29 16:33:47
【问题描述】:

我只是在写文本输入,在onChange 事件中我调用setState,所以 React 重新渲染了我的 UI。问题是文本输入总是失去焦点,所以我需要为每个字母再次聚焦:D。

var EditorContainer = React.createClass({

    componentDidMount: function () {
        $(this.getDOMNode()).slimScroll({height: this.props.height, distance: '4px', size: '8px'});
    },

    componentDidUpdate: function () {
        console.log("zde");
        $(this.getDOMNode()).slimScroll({destroy: true}).slimScroll({height: 'auto', distance: '4px', size: '8px'});
    },

    changeSelectedComponentName: function (e) {
        //this.props.editor.selectedComponent.name = $(e.target).val();
        this.props.editor.forceUpdate();
    },

    render: function () {

        var style = {
            height: this.props.height + 'px'
        };
        return (
            <div className="container" style={style}>
                <div className="row">
                    <div className="col-xs-6">
                    {this.props.selected ? <h3>{this.props.selected.name}</h3> : ''}
                    {this.props.selected ? <input type="text" value={this.props.selected.name} onChange={this.changeSelectedComponentName} /> : ''}
                    </div>
                    <div className="col-xs-6">
                        <ComponentTree editor={this.props.editor} components={this.props.components}/>
                    </div>
                </div>
            </div>
        );
    }

});

【问题讨论】:

  • 发生这种情况的唯一原因是 a) 其他东西抢走了焦点,或者 b) 输入闪烁。你能提供一个显示问题的 jsfiddle/jsbin 吗?这是base react jsbin
  • 大声笑...这听起来有点烦人:P 使用 jquery 我会为新呈现的输入文件设置一个标识符,然后调用它的焦点。不确定代码在纯 js 中的外观。但我相信你能做到:)
  • @FakeRainBrigand:闪烁是什么意思?
  • @Krab,就像 this.props.selected 变成了假,然后又变成了真的。这会导致输入卸载,然后再次安装。
  • @Krab,尝试删除 slimScroll 线;这可能会导致一些奇怪的问题。

标签: javascript reactjs


【解决方案1】:

对我来说,我在门户内有一个文本区域。此文本区域失去焦点。我的错误门户实现是这样的:

export const Modal = ({children, onClose}: modelProps) => {
  const modalDOM = document.getElementById("modal");
  const divRef = useRef(document.createElement('div')); 

  useEffect(()=>{
    const ref = divRef.current;
    modalDOM?.appendChild(ref);
    return ()=>{
      modalDOM?.removeChild(ref);
    }
  });

  const close = (e: React.MouseEvent) => {
    e.stopPropagation();
    onClose();
  };

  const handleClick = (e: React.MouseEvent) => {
    e.stopPropagation()
  }

  return (
    createPortal(
    <div className="modal" onClick={close}>
      <div className="modal__close-modal" onClick={close}>x</div>
      {children}
    </div>, 
    divRef.current)
  )
}

const Parent = ({content: string}: ParentProps) => {
  const [content, setContent] = useState<string>(content);
  
  const onChangeFile = (e: React.MouseEvent) => {
    setContent(e.currentTarget.value);
  }

  return (
    <Modal>
      <textarea
        value={content}
        onChange={onChangeFile}>
      </textarea>
    </Modal>
    )
  }

原来下面的实现工作正常,这里我直接将模态组件附加到 DOM 元素。

export const Modal = ({children, onClose}: modelProps) => {
  const modalDOM = document.getElementById("modal");

  const close = (e: React.MouseEvent) => {
    e.stopPropagation();
    onClose();
  };

  return (
    createPortal(
      <div className="modal" onClick={close}>
        <div className="modal__close-modal" onClick={close}>x</div>
          {children}
        </div>, 
        modalDOM || document.body)
    )
  }

【讨论】:

    【解决方案2】:

    我所做的只是将value 属性更改为defaultValue,第二个更改是将onChange 事件更改为onBlur

    【讨论】:

    • OnBlur 解决了我的问题,谢谢
    【解决方案3】:

    我的问题是我在 InputContainer 组件上设置的关键道具值和输入字段本身是使用 Math.random() 生成的。值的非恒定性质使得很难跟踪正在编辑的输入字段。

    【讨论】:

      【解决方案4】:

      我在使用钩子时也有同样的症状。然而我的问题是在父级内部定义一个组件。

      错误:

      const Parent =() => {
          const Child = () => <p>Child!</p>
          return <Child />
      }
      

      对:

      const Child = () => <p>Child!</p>
      const Parent = () => <Child />
      
      

      【讨论】:

      • const child 应该是 const Child,在“错误”示例中。
      • 请注意,您仍然可以通过常规函数调用使用这样的嵌套子级。例如,return &lt;div&gt;{Child()}&lt;/div&gt; 可以,尽管确实有点难看。有时我发现将 JSX 表达式的不可重用部分提取到本地闭包中以提高可读性会很有帮助,而不必使它们成为具有大量 props 传递的完整独立组件。焦点行为有点问题。
      • 每次父级重新渲染时挂载子级
      • 只是为了扩展@ilkerkaran 所说的内容,因为 React 将在每次状态更新时运行您的组件函数(Parent 函数),内部 Child 的值对于每次渲染都会有所不同。因此,React 无法在每次渲染中重用您的子组件,并且每次更新都会得到新元素。
      【解决方案5】:

      在我的情况下的简单解决方案:

      <input ref={ref => ref && ref.focus()}
          onFocus={(e)=>e.currentTarget.setSelectionRange(e.currentTarget.value.length, e.currentTarget.value.length)}
          />
      

      ref 触发焦点,并触发onFocus 计算结束并相应地设置光标。

      【讨论】:

      • 我收到Warning: Function components cannot be given refs. Attempts to access this ref will fail. Did you mean to use React.forwardRef()?
      • @VitalyZdanevich 如果你给我一个 CodeSandbox 我很乐意调试
      • 只看这个ref只用于类组件,不用于新功能组件。
      • 我把它放在一个功能组件中的&lt;input /&gt; 上,它起作用了。您是否有一个不起作用的功能组件示例?
      【解决方案6】:

      在标签输入中包含下一个代码:

      ref={(input) => {
           if (input) {
               input.focus();
           }
       }}
      

      之前:

      <input
            defaultValue={email}
            className="form-control"
            type="email"
            id="email"
            name="email"
            placeholder={"mail@mail.com"}
            maxLength="15"
            onChange={(e) => validEmail(e.target.value)}
      />
      

      之后:

      <input
           ref={(input) => {
                if (input) {
                   input.focus();
                }
            }}
            defaultValue={email}
            className="form-control"
            type="email"
            id="email"
            name="email"
            placeholder={"mail@mail.com"}
            maxLength="15"
            onChange={(e) => validEmail(e.target.value)}
      />
      

      【讨论】:

        【解决方案7】:

        我的回答和@z5h 说的差不多。

        在我的例子中,我使用Math.random() 为组件生成一个唯一的key

        我认为key 仅用于触发该特定组件的重新渲染,而不是重新渲染该数组中的所有组件(我在我的代码中返回一个组件数组)。不知道是用来恢复渲染后的状态的。

        删除它为我完成了这项工作。

        【讨论】:

        【解决方案8】:

        我遇到了这个问题,结果是我正在使用功能组件并与父组件的状态链接。如果我切换到使用类组件,问题就消失了。希望在使用功能组件时有办法解决这个问题,因为它对于简单的项目渲染器等来说更方便。

        【讨论】:

          【解决方案9】:

          我解决了同样的问题,删除输入和他的父元素中的 key 属性

          // Before
          <input
              className='invoice_table-input invoice_table-input-sm'
              type='number'
              key={ Math.random }
              defaultValue={pageIndex + 1}
              onChange={e => {
                  const page = e.target.value ? Number(e.target.value) - 1 : 0
                  gotoPage(page)
              }}
          />
          // After
          <input
              className='invoice_table-input invoice_table-input-sm'
              type='number'
              defaultValue={pageIndex + 1}
              onChange={e => {
                  const page = e.target.value ? Number(e.target.value) - 1 : 0
                  gotoPage(page)
              }}
          />

          【讨论】:

          • 没错,在我的情况下,我删除了密钥并且它运行良好。我正在映射多个 textInputs
          • 需要注意的是 Math.random 作为 key 是一个 react 反模式。 key 的全部意义在于告诉 React,“这是我的组件,你可以通过这个 key 找到它。在需要时重新渲染这个组件”拥有一个新的随机 key 不会让 React 跟踪它。
          【解决方案10】:

          如果输入字段在另一个元素内(即像&lt;div key={"bart"}...&gt;&lt;input key={"lisa"}...&gt; ... &lt;/input&gt;&lt;/div&gt;这样的容器元素——这里的省略号表示省略代码),容器元素上必须有一个唯一且恒定的键(以及在输入字段上)。否则,当子状态更新时,React 会渲染一个全新的容器元素,而不仅仅是重新渲染旧容器。从逻辑上讲,应该只更新子元素,但是...

          我在尝试编写一个包含大量地址信息的组件时遇到了这个问题。工作代码如下所示

          // import react, components
          import React, { Component } from 'react'
          
          // import various functions
          import uuid from "uuid";
          
          // import styles
          import "../styles/signUp.css";
          
          export default class Address extends Component {
            constructor(props) {
              super(props);
              this.state = {
                address1: "",
                address2: "",
                address1Key: uuid.v4(),
                address2Key: uuid.v4(),
                address1HolderKey: uuid.v4(),
                address2HolderKey: uuid.v4(),
                // omitting state information for additional address fields for brevity
              };
              this.handleChange = this.handleChange.bind(this);
            }
          
            handleChange(event) {
              event.preventDefault();
              this.setState({ [`${event.target.id}`]: event.target.value })
            }
          
            render() {
              return (
                <fieldset>
                  <div className="labelAndField" key={this.state.address1HolderKey} >
                    <label className="labelStyle" for="address1">{"Address"}</label>
                    <input className="inputStyle"
                      id="address1"
                      name="address1"
                      type="text"
                      label="address1"
                      placeholder=""
                      value={this.state.address1}
                      onChange={this.handleChange}
                      key={this.state.address1Key} ></input >
                  </div> 
                  <div className="labelAndField" key={this.state.address2HolderKey} >
                    <label className="labelStyle" for="address2">{"Address (Cont.)"}</label>
                    <input className="inputStyle"
                      id="address2"
                      name="address2"
                      type="text"
                      label="address2"
                      placeholder=""
                      key={this.state.address2Key} ></input >
                  </div>
                  {/* omitting rest of address fields for brevity */}
                </fieldset>
              )
            }
          }
          

          眼尖的读者会注意到&lt;fieldset&gt; 是一个包含元素,但它不需要键。 &lt;&gt;&lt;React.Fragment&gt; 甚至 &lt;div&gt; 也是如此,为什么?也许只有直接容器需要密钥。我不知道。正如数学教科书所说,解释留给读者作为练习。

          【讨论】:

            【解决方案11】:

            我的问题是我用项目的值动态命名了我的键,在我的例子中是“名称”,所以键是 key={${item.name}-${index}}。因此,当我想以 item.name 作为值来更改输入时,它们的键也会发生变化,因此 react 将无法识别该元素

            【讨论】:

              【解决方案12】:

              我在一个 html 表格中遇到了同样的问题,我在其中的一列中输入了文本行。在一个循环中,我读取了一个 json 对象并创建了行,特别是我有一个带有 inputtext 的列。

              http://reactkungfu.com/2015/09/react-js-loses-input-focus-on-typing/

              我设法通过以下方式解决了它

              import { InputTextComponent } from './InputTextComponent';
              //import my  inputTextComponent 
              ...
              
              var trElementList = (function (list, tableComponent) {
              
                  var trList = [],
                      trElement = undefined,
                      trElementCreator = trElementCreator,
                      employeeElement = undefined;
              
              
              
                  // iterating through employee list and
                  // creating row for each employee
                  for (var x = 0; x < list.length; x++) {
              
                      employeeElement = list[x];
              
                      var trNomeImpatto = React.createElement('tr', null, <td rowSpan="4"><strong>{employeeElement['NomeTipologiaImpatto'].toUpperCase()}</strong></td>);
                      trList.push(trNomeImpatto);
              
                      trList.push(trElementCreator(employeeElement, 0, x));
                      trList.push(trElementCreator(employeeElement, 1, x));
                      trList.push(trElementCreator(employeeElement, 2, x));
              
                  } // end of for  
              
                  return trList; // returns row list
              
                  function trElementCreator(obj, field, index) {
                      var tdList = [],
                          tdElement = undefined;
              
                      //my input text
                      var inputTextarea = <InputTextComponent
                          idImpatto={obj['TipologiaImpattoId']}//index
                          value={obj[columns[field].nota]}//initial value of the input I read from my json data source
                          noteType={columns[field].nota}
                          impattiComposite={tableComponent.state.impattiComposite}
                          //updateImpactCompositeNote={tableComponent.updateImpactCompositeNote}
                      />
              
                      tdElement = React.createElement('td', { style: null }, inputTextarea);
                      tdList.push(tdElement);
              
              
                      var trComponent = createClass({
              
                          render: function () {
                              return React.createElement('tr', null, tdList);
                          }
                      });
                      return React.createElement(trComponent);
                  } // end of trElementCreator
              
              });
              ...    
                  //my tableComponent
                  var tableComponent = createClass({
                      // initial component states will be here
                      // initialize values
                      getInitialState: function () {
                          return {
                              impattiComposite: [],
                              serviceId: window.sessionStorage.getItem('serviceId'),
                              serviceName: window.sessionStorage.getItem('serviceName'),
                              form_data: [],
                              successCreation: null,
                          };
                      },
              
                      //read a json data soure of the web api url
                      componentDidMount: function () {
                          this.serverRequest =
                              $.ajax({
                                  url: Url,
                                  type: 'GET',
                                  contentType: 'application/json',
                                  data: JSON.stringify({ id: this.state.serviceId }),
                                  cache: false,
                                  success: function (response) {
                                      this.setState({ impattiComposite: response.data });
                                  }.bind(this),
              
                                  error: function (xhr, resp, text) {
                                      // show error to console
                                      console.error('Error', xhr, resp, text)
                                      alert(xhr, resp, text);
                                  }
                              });
                      },
              
                      render: function () {
                  ...
                  React.createElement('table', {style:null}, React.createElement('tbody', null,trElementList(this.state.impattiComposite, this),))
                  ...
                  }
              
              
              
                          //my input text
                          var inputTextarea = <InputTextComponent
                                      idImpatto={obj['TipologiaImpattoId']}//index
                                      value={obj[columns[field].nota]}//initial value of the input I read //from my json data source
                                      noteType={columns[field].nota}
                                      impattiComposite={tableComponent.state.impattiComposite}//impattiComposite  = my json data source
              
                                  />//end my input text
              
                                  tdElement = React.createElement('td', { style: null }, inputTextarea);
                                  tdList.push(tdElement);//add a component
              
                      //./InputTextComponent.js
                      import React from 'react';
              
                      export class InputTextComponent extends React.Component {
                        constructor(props) {
                          super(props);
                          this.state = {
                            idImpatto: props.idImpatto,
                            value: props.value,
                            noteType: props.noteType,
                            _impattiComposite: props.impattiComposite,
                          };
                          this.updateNote = this.updateNote.bind(this);
                        }
              
                      //Update a inpute text with new value insert of the user
              
                        updateNote(event) {
                          this.setState({ value: event.target.value });//update a state of the local componet inputText
                          var impattiComposite = this.state._impattiComposite;
                          var index = this.state.idImpatto - 1;
                          var impatto = impattiComposite[index];
                          impatto[this.state.noteType] = event.target.value;
                          this.setState({ _impattiComposite: impattiComposite });//update of the state of the father component (tableComponet)
              
                        }
              
                        render() {
                          return (
                            <input
                              className="Form-input"
                              type='text'
                              value={this.state.value}
                              onChange={this.updateNote}>
                            </input>
                          );
                        }
                      }
              

              【讨论】:

              • 请使用最少的代码来回答 - 这里我们有很多不相关的代码。
              【解决方案13】:

              我将value 属性切换为defaultValue。这对我有用。

              ...
              // before
              <input value={myVar} />
              
              // after
              <input defaultValue={myVar} />
              

              【讨论】:

              • 不过,这是一个完全不同的问题。
              【解决方案14】:

              我也有同样的行为。

              我的代码中的问题是我创建了一个嵌套的 jsx 元素数组,如下所示:

              const example = [
                          [
                              <input value={'Test 1'}/>,
                              <div>Test 2</div>,
                              <div>Test 3</div>,
                          ]
                      ]
              
              ...
              
              render = () => {
                  return <div>{ example }</div>
              }
              

              每次我更新父元素时,这个嵌套数组中的每个元素都会重新渲染。所以输入每次都会丢失“ref”道具

              我修复了将内部数组转换为反应组件的问题 (带有渲染功能的函数)

              const example = [
                          <myComponentArray />
                      ]
              
               ...
              
              render = () => {
                  return <div>{ example }</div>
              }
              

              编辑:

              当我构建一个嵌套的React.Fragment时出现同样的问题

              const SomeComponent = (props) => (
                  <React.Fragment>
                      <label ... />
                      <input ... />
                  </React.Fragment>
              );
              
              const ParentComponent = (props) => (
                  <React.Fragment>
                      <SomeComponent ... />
                      <div />
                  </React.Fragment>
              );
              

              【讨论】:

              【解决方案15】:

              原来我将this 绑定到导致它重新渲染的组件。

              我想我会把它贴在这里以防其他人遇到这个问题。

              我必须改变

              <Field
                  label="Post Content"
                  name="text"
                  component={this.renderField.bind(this)}
              />
              

              <Field
                  label="Post Content"
                  name="text"
                  component={this.renderField}
              />
              

              简单的修复,因为在我的情况下,我实际上并不需要 renderField 中的 this,但希望我发布此内容对其他人有所帮助。

              【讨论】:

                【解决方案16】:

                对我来说,这是因为搜索输入框在 same 组件(称为 UserList)中呈现为搜索结果列表。所以每当搜索结果发生变化时,整个 UserList 组件都会重新渲染,包括输入框。

                我的解决方案是创建一个名为 UserListSearch 的全新组件,它与 UserList 是分开的。我不需要在 UserListSearch 的输入字段上设置键就可以了。我的 UsersContainer 的渲染函数现在看起来像这样:

                class UserContainer extends React.Component {
                  render() {
                    return (
                      <div>
                        <Route
                          exact
                          path={this.props.match.url}
                          render={() => (
                            <div>
                              <UserListSearch
                                handleSearchChange={this.handleSearchChange}
                                searchTerm={this.state.searchTerm}
                              />
                              <UserList
                                isLoading={this.state.isLoading}
                                users={this.props.users}
                                user={this.state.user}
                                handleNewUserClick={this.handleNewUserClick}
                              />
                            </div>
                          )}
                        />
                      </div>  
                    )
                  }
                }
                

                希望这对某人也有帮助。

                【讨论】:

                  【解决方案17】:

                  我一次又一次地回到这里,最后总能找到我在别处的解决方案。 所以,我会在这里记录下来,因为我知道我会再次忘记这一点!

                  input 在我的案例中失去焦点的原因是我在状态更改时重新渲染了 input

                  错误代码:

                  import React from 'react';
                  import styled from 'styled-components';
                  
                  class SuperAwesomeComp extends React.Component {
                    state = {
                      email: ''
                    };
                    updateEmail = e => {
                      e.preventDefault();
                      this.setState({ email: e.target.value });
                    };
                    render() {
                      const Container = styled.div``;
                      const Input = styled.input``;
                      return (
                        <Container>
                          <Input
                            type="text"
                            placeholder="Gimme your email!"
                            onChange={this.updateEmail}
                            value={this.state.email}
                          />
                        </Container>
                      )
                    }
                  }
                  

                  所以,问题是我总是在一个地方开始编写所有代码以快速测试,然后将其分解为单独的模块。 但是,这里这种策略适得其反,因为在输入更改时更新状态会触发渲染功能并且焦点会丢失。

                  修复很简单,从头做模块化,换句话说,“将Input组件移出render函数”

                  固定代码

                  import React from 'react';
                  import styled from 'styled-components';
                  
                  const Container = styled.div``;
                  const Input = styled.input``;
                  
                  class SuperAwesomeComp extends React.Component {
                    state = {
                      email: ''
                    };
                    updateEmail = e => {
                      e.preventDefault();
                      this.setState({ email: e.target.value });
                    };
                    render() {
                      return (
                        <Container>
                          <Input
                            type="text"
                            placeholder="Gimme your email!"
                            onChange={this.updateEmail}
                            value={this.state.email}
                          />
                        </Container>
                      )
                    }
                  }
                  

                  参考。解决办法:https://github.com/styled-components/styled-components/issues/540#issuecomment-283664947

                  【讨论】:

                  • 我在渲染函数中使用了 HOC,将 HOC 调用移至组件定义就可以了。有点类似于这个答案。
                  • 我认为这是我的问题,但由于引用了this,我无法将组件移出render()class ... extends Component。例如onChange={this.handleInputChange}
                  • 讲道理,对于 React 类组件,不要在 render 函数内定义组件,对于 React 函数式组件,不要在函数体中定义组件。
                  • @Wong Jia Hau:在React函数式组件的函数体中定义组件会发生什么?我也有类似的问题,并通过应用您的建议得到解决。
                  • @Nateous 我遇到了完全相同的情况。 render 函数内部的 HOC 调用被传递给 'this.handleChange' 方法并返回要使用的组件。例如。 const TextAreaDataField = TextAreaDataFieldFactory(this.handleChange)。我只是将组件创建移至构造函数,并在render 方法中以this.TextAreaDataField 访问它们。像魅力一样工作。
                  【解决方案18】:

                  提供的答案对我没有帮助,这就是我所做的,但我有一个独特的情况。

                  为了清理代码,我倾向于使用这种格式,直到我准备好将组件拉入另一个文件。

                  render(){
                     const MyInput = () => {
                        return <input onChange={(e)=>this.setState({text: e.target.value}) />
                     }
                     return(
                        <div>
                           <MyInput />
                        </div>
                     )
                  

                  但这导致它失去焦点,当我将代码直接放在它工作的 div 中时。

                  return(
                     <div>
                        <input onChange={(e)=>this.setState({text: e.target.value}) />
                     </div>
                  )
                  

                  我不知道这是为什么,这是我以这种方式编写它时遇到的唯一问题,我在我拥有的大多数文件中都这样做,但如果有人做了类似的事情,这就是它失去焦点的原因。

                  【讨论】:

                    【解决方案19】:

                    如果反应路由器 &lt;Route/&gt; 中存在问题,请使用 render 属性而不是 component

                    <Route path="/user" render={() => <UserPage/>} />
                    


                    失去焦点是因为 component 属性每次都使用 React.createElement 而不是重新渲染更改。

                    详情请看:https://reacttraining.com/react-router/web/api/Route/component

                    【讨论】:

                    • 这本质上是我的问题。具体来说,我向组件 prop 传递了一个匿名函数,触发了焦点丢失:&lt;Route component={() =&gt; &lt;MyComponent/&gt;} /&gt;,而我应该完成 &lt;Route component={MyComponent} /&gt;
                    • stackoverflow.com/a/47660885/11667949。就我而言,这有帮助
                    【解决方案20】:

                    autoFocus 属性应用于input 元素可以在只有一个输入需要关注的情况下作为一种解决方法。在这种情况下,key 属性将是不必要的,因为它只是一个元素,而且您不必担心将 input 元素分解为自己的组件,以避免失去对重新渲染主要组件的关注。

                    【讨论】:

                    • 不得不尝试这个作为最后的解决方法。我很高兴它有效。我的应用程序中显然存在一个错误,因为每当我尝试在页面中输入唯一的搜索输入时,应用程序都会重新呈现。但是让autofocus 进入输入字段是一个开始。 ?
                    • 在尝试了许多其他解决方案之后,这也对我有用。它仍然重新渲染,这不是很好,但它是功能性的。泰!
                    【解决方案21】:

                    核心原因是:当 React 重新渲染时,你之前的 DOM ref 会失效。这意味着 react 改变了 DOM 树,而你 this.refs.input.focus 不起作用,因为这里的输入已经不存在了。

                    【讨论】:

                    • 那么你的解决方案是什么?
                    【解决方案22】:

                    我刚遇到这个问题,就来这里寻求帮助。检查你的 CSS!输入字段不能有user-select: none;,否则在 iPad 上不起作用。

                    【讨论】:

                      【解决方案23】:

                      没有看到您的其余代码,这是一个猜测。 创建 EditorContainer 时,为组件指定唯一键:

                      &lt;EditorContainer key="editor1"/&gt;

                      当发生重新渲染时,如果看到相同的键,这将告诉 React 不要破坏并重新生成视图,而是重用。然后焦点项目应该保持焦点。

                      【讨论】:

                      • 这解决了我渲染包含输入表单的子组件的问题。但在我的情况下,我需要相反的——当我想要的时候,表单没有重新渲染。添加关键属性有效。
                      • 向输入添加键没有帮助
                      • 可能包含您的输入的组件也会重新渲染。检查封闭组件上的键。
                      猜你喜欢
                      • 2018-12-12
                      • 2022-01-24
                      • 2023-01-20
                      • 2021-02-15
                      • 2017-09-17
                      • 2021-03-19
                      • 2017-09-14
                      • 1970-01-01
                      • 1970-01-01
                      相关资源
                      最近更新 更多