你可以试试这样的方法：

<input v-on:keyup.enter="$event.target.nextElementSibling.focus()" type="text">

**一个

更新

如果目标元素在form元素内部，而下一个表单元素不是真实的的兄弟元素，那么可以执行以下操作：

超文本标记语言

<form id="app">
  <p>{{ message }}</p>

  <input v-on:keyup.enter="goNext($event.target)" type="text">
  
  <div>
      <input type="text">
  </div>

</form>

日本

new Vue({
  el: '#app',
  data: {
    message: 'Hello Vue.js!',
    focusNext(elem) {
      const currentIndex = Array.from(elem.form.elements).indexOf(elem);
      elem.form.elements.item(
        currentIndex < elem.form.elements.length - 1 ?
        currentIndex + 1 :
        0
      ).focus();
    }
  }
})

**第一个e第一个f第一个x

在我看来，从this答案开始，使用$refs API是一个更干净的替代方案。
使用$refs API，可以让您以更简单的方式定位元素，而无需遍历DOM。
Example

经过一些测试，它起作用了

new Vue({
    el:'#app',
    methods: {
      nextPlease: function (event) {
        document.getElementById('input2').focus();
      }
    }
});

<script src="https://vuejs.org/js/vue.js"></script>
<div id='app'>
    <input type="text" v-on:keyup.enter="nextPlease">
    <input id="input2" type="text">
</div>

试试这个

<input ref="email" /> 
this.$refs.email.focus()

directives: {
    focusNextOnEnter: {
        inserted: function (el,binding,vnode) {
            let length = vnode.elm.length;
            vnode.elm[0].focus();
            let index = 0;
            el.addEventListener("keyup",(ev) => {
                if (ev.keyCode === 13 && index<length-1) {
                  index++;
                  vnode.elm[index].focus();
                }
            });
            for (let i = 0;i<length-1;i++) {
                vnode.elm[i].onfocus = (function(i) {
                  return function () {
                    index = i;
                  }
                })(i);
            }
        }
    }
}

使用它：

<el-form v-focusNextOnEnter>
...
</el-form>

虽然我喜欢指令答案，因为它可以处理其他元素（样式 Package 器等）中的输入，但我发现它对于来来去去的元素有点不灵活，特别是如果它们根据其他字段来来去去。
相反，我将以下两个不同的指令放在一起。在HTML中按照以下方式使用它们：

<form v-forcusNextOnEnter v-focusFirstOnLoad>
...
</form>

在Vue对象上（或在mixin中）定义它们：

directives: {
        focusFirstOnLoad: {
            inserted(el, binding, vnode) {
                vnode.elm[0].focus();
            },
        },
        focusNextOnEnter: {
            inserted(el, binding, vnode) {
                el.addEventListener('keyup', (ev) => {
                    let index = [...vnode.elm.elements].indexOf(ev.target);

                    if (ev.keyCode === 13 && index < vnode.elm.length - 1) {
                        vnode.elm[index + 1].focus();
                    }
                });
            },
        },
    },

在按下回车键时，它在输入列表中查找当前输入的索引，验证它是否可以被提升，并关注下一个元素。
主要差异：长度和索引在点击时计算，使其更适合字段添加/删除;不需要额外的事件来改变缓存的变量。
缺点是，这将是一个有点慢/更密集的运行，但鉴于它的基础上关闭UI交互...

Vue.js的指令是满足此要求的良好实践。
定义全局指令：

Vue.directive('focusNextOnEnter', {
  inserted: function (el, binding, vnode) {
    el.addEventListener('keyup', (ev) => {
      if (ev.keyCode === 13) {
        if (binding.value) {
          vnode.context.$refs[binding.value].focus()
          return
        }
        if (!el.form) {
          return
        }
        const inputElements = Array.from(el.form.querySelectorAll('input:not([disabled]):not([readonly])'))
        const currentIndex = inputElements.indexOf(el)
        inputElements[currentIndex < inputElements.length - 1 ? currentIndex + 1 : 0].focus()
      }
    })
  }
})

注意：我们应该排除禁用和只读输入。
使用方法：

<form>
<input type="text" v-focus-next-on-enter></input>
<!-- readonly or disabled inputs would be skipped -->
<input type="text" v-focus-next-on-enter readonly></input>
<input type="text" v-focus-next-on-enter disabled></input>
<!-- skip the next and focus on the specified input -->
<input type="text" v-focus-next-on-enter='`theLastInput`'></input>
<input type="text" v-focus-next-on-enter></input>
<input type="text" v-focus-next-on-enter ref="theLastInput"></input>
</form>