Soutenir


Cette page suppose que vous avez lu Bases des composants. Si vous ne savez pas encore grand-chose sur les composants, je vous recommande de le lire en premier.


Répertoire


Prop type


Jusqu'à présent, nous n'avons vu que des accessoires répertoriés sous forme de tableaux de chaînes :
props: ['title', 'likes', 'isPublished', 'commentIds', 'author']
Cependant, vous souhaitez généralement que chaque accessoire ait un type de valeur spécifié. À ce stade, vous pouvez lister les accessoires en tant qu'objets avec les noms et valeurs des noms et types respectifs des accessoires :

props: {
  title: String,
  likes: Number,
  isPublished: Boolean,
  commentIds: Array,
  author: Object,
  callback: Function,
  contactsPromise: Promise // or any other constructor
}

Cela fournit non seulement une documentation pour vos composants, mais fournit également une documentation s'ils rencontrent le mauvais type. Invitez l'utilisateur à partir de la console JavaScript du navigateur. Vous verrez

vérification de type et autres validations d'accessoires

dans le reste de cette page.


Passez une prop statique ou dynamique


Comme ça, vous savez déjà que vous pouvez transmettre une valeur statique à prop comme ceci :

<blog-post title="My journey with Vue"></blog-post>

Vous savez aussi que prop peut être transmis via v-bind< /code > Affectation dynamique, par exemple : v-bind 动态赋值,例如:

<!-- 动态赋予一个变量的值 -->
<blog-post v-bind:title="post.title"></blog-post>

<!-- 动态赋予一个复杂表达式的值 -->
<blog-post
  v-bind:title="post.title + ' by ' + post.author.name"
></blog-post>

在上述两个示例中,我们传入的值都是字符串类型的,但实际上任何类型的值都可以传给一个 prop。


传入一个数字

<!-- 即便 `42` 是静态的,我们仍然需要 `v-bind` 来告诉 Vue -->
<!-- 这是一个 JavaScript 表达式而不是一个字符串。-->
<blog-post v-bind:likes="42"></blog-post>

<!-- 用一个变量进行动态赋值。-->
<blog-post v-bind:likes="post.likes"></blog-post>


传入一个布尔值

<!-- 包含该 prop 没有值的情况在内,都意味着 `true`。-->
<blog-post is-published></blog-post>

<!-- 即便 `false` 是静态的,我们仍然需要 `v-bind` 来告诉 Vue -->
<!-- 这是一个 JavaScript 表达式而不是一个字符串。-->
<blog-post v-bind:is-published="false"></blog-post>

<!-- 用一个变量进行动态赋值。-->
<blog-post v-bind:is-published="post.isPublished"></blog-post>


传入一个数组

<!-- 即便数组是静态的,我们仍然需要 `v-bind` 来告诉 Vue -->
<!-- 这是一个 JavaScript 表达式而不是一个字符串。-->
<blog-post v-bind:comment-ids="[234, 266, 273]"></blog-post>

<!-- 用一个变量进行动态赋值。-->
<blog-post v-bind:comment-ids="post.commentIds"></blog-post>


传入一个对象

<!-- 即便对象是静态的,我们仍然需要 `v-bind` 来告诉 Vue -->
<!-- 这是一个 JavaScript 表达式而不是一个字符串。-->
<blog-post
  v-bind:author="{
    name: 'Veronica',
    company: 'Veridian Dynamics'
  }"
></blog-post>

<!-- 用一个变量进行动态赋值。-->
<blog-post v-bind:author="post.author"></blog-post>


传入一个对象的所有属性

如果你想要将一个对象的所有属性都作为 prop 传入,你可以使用不带参数的 v-bind (取代 v-bind:prop-name)。例如,对于一个给定的对象 post

post: {
  id: 1,
  title: 'My Journey with Vue'
}

Dans les deux exemples ci-dessus, les valeurs que nous avons transmises sont de type chaîne, mais en fait n'importe quel type de valeur peut être transmis à un accessoire.

Passez un numéro

<blog-post v-bind="post"></blog-post>

Passez une valeur booléenne


<blog-post
  v-bind:id="post.id"
  v-bind:title="post.title"
></blog-post>

Passer dans un tableau

props: ['initialCounter'],
data: function () {
  return {
    counter: this.initialCounter
  }
}

Passer un objet

props: ['size'],
computed: {
  normalizedSize: function () {
    return this.size.trim().toLowerCase()
  }
}

Transmettre tous les attributs d'un objet

Si vous souhaitez transmettre tous les attributs d'un objet comme accessoires, vous pouvez Utilisez v-bind sans paramètres (en remplaçant v-bind:prop-name). Par exemple, pour un objet post donné :
Vue.component('my-component', {
  props: {
    // 基础的类型检查 (`null` 和 `undefined` 会通过任何类型验证)
    propA: Number,
    // 多个可能的类型
    propB: [String, Number],
    // 必填的字符串
    propC: {
      type: String,
      required: true
    },
    // 带有默认值的数字
    propD: {
      type: Number,
      default: 100
    },
    // 带有默认值的对象
    propE: {
      type: Object,
      // 对象或数组默认值必须从一个工厂函数获取
      default: function () {
        return { message: 'hello' }
      }
    },
    // 自定义验证函数
    propF: {
      validator: function (value) {
        // 这个值必须匹配下列字符串中的一个
        return ['success', 'warning', 'danger'].indexOf(value) !== -1
      }
    }
  }
})

le modèle suivant :

function Person (firstName, lastName) {
  this.firstName = firstName
  this.lastName = lastName
}

est équivalent à : 🎜
Vue.component('blog-post', {
  props: {
    author: Person
  }
})
🎜🎜🎜🎜🎜🎜Flux de données unidirectionnel🎜🎜🎜🎜🎜Tous Chacun prop forme une 🎜liaison descendante unidirectionnelle🎜 entre ses accessoires parent et enfant : les mises à jour de l'accessoire parent circuleront vers le composant enfant, mais pas l'inverse. Cela empêchera le composant enfant de modifier accidentellement l'état du composant parent, ce qui rendrait difficile la compréhension du flux de données de votre application. 🎜🎜De plus, chaque fois que le composant parent est mis à jour, tous les accessoires du composant enfant seront actualisés avec les dernières valeurs. Cela signifie que vous 🎜ne devriez pas 🎜 modifier les accessoires à l'intérieur d'un composant enfant. Si vous faites cela, Vue émettra un avertissement dans la console du navigateur. 🎜🎜Il existe deux situations courantes lorsque l'on essaie de modifier un accessoire : 🎜🎜 1. 🎜Cet accessoire est utilisé pour transmettre une valeur initiale ; le sous-composant souhaite ensuite l'utiliser comme donnée d'accessoire locale. 🎜Dans ce cas, il est préférable de définir un attribut de données local et d'utiliser cet accessoire comme valeur initiale : 🎜
<bootstrap-date-input data-date-picker="activated"></bootstrap-date-input>
🎜 2. 🎜Cette accessoire est transmise comme valeur primitive et doit être convertie. 🎜Dans ce cas, il est préférable d'utiliser la valeur de cet accessoire pour définir une propriété calculée : 🎜
<input type="date" class="form-control">
🎜🎜Notez qu'en JavaScript les objets et les tableaux sont passés par référence, donc pour un accessoire de type tableau ou objet, Changer le l'objet ou le tableau lui-même dans le composant enfant affectera l'état du composant parent. 🎜🎜🎜🎜🎜

Validation des accessoires


Nous pouvons spécifier les exigences de validation pour les accessoires de composants, tels que les types que vous connaissez. Si une condition n'est pas remplie, Vue vous avertira dans la console du navigateur. Ceci est particulièrement utile lors du développement d’un composant qui sera utilisé par d’autres.

Pour personnaliser la façon dont les accessoires sont validés, vous pouvez fournir un objet avec des exigences de validation pour la valeur dans props au lieu d'un tableau de chaînes. Par exemple : props 中的值提供一个带有验证需求的对象,而不是一个字符串数组。例如:

<bootstrap-date-input
  data-date-picker="activated"
  class="date-picker-theme-dark"
></bootstrap-date-input>

当 prop 验证失败的时候,(开发环境构建版本的) Vue 将会产生一个控制台的警告。

注意那些 prop 会在一个组件实例创建之前进行验证,所以实例的属性 (如 datacomputed 等) 在 default 或 validator 函数中是不可用的。

类型检查

type 可以是下列原生构造函数中的一个:

  • String

  • Number

  • Boolean

  • Array

  • Object

  • Date

  • Function

  • Symbol

额外的,type 还可以是一个自定义的构造函数,并且通过 instanceof 来进行检查确认。例如,给定下列现成的构造函数:

Vue.component('my-component', {
  inheritAttrs: false,
  // ...
})

你可以使用:

{
  required: true,
  placeholder: 'Enter your username'
}

来验证 author prop 的值是否是通过 new Person 创建的。


非 Prop 的特性


一个非 prop 特性是指传向一个组件,但是该组件并没有相应 prop 定义的特性。

因为显式定义的 prop 适用于向一个子组件传入信息,然而组件库的作者并不总能预见组件会被用于怎样的场景。这也是为什么组件可以接受任意的特性,而这些特性会被添加到这个组件的根元素上。

例如,想象一下你通过一个 Bootstrap 插件使用了一个第三方的 <bootstrap-date-input> 组件,这个插件需要在其 <input> 上用到一个 data-date-picker 特性。我们可以将这个特性添加到你的组件实例上:

Vue.component('base-input', {
  inheritAttrs: false,
  props: ['label', 'value'],
  template: `
    <label>
      {{ label }}
      <input
        v-bind="$attrs"
        v-bind:value="value"
        v-on:input="$emit('input', $event.target.value)"
      >
    </label>
  `
})

然后这个 data-date-picker="activated" 特性就会自动添加到 <bootstrap-date-input> 的根元素上。


替换/合并已有的特性

想象一下 <bootstrap-date-input>

<base-input
  v-model="username"
  required
  placeholder="Enter your username"
></base-input>

Lorsque la vérification des accessoires échoue, Vue (version de construction de l'environnement de développement) générera un avertissement de console. 🎜
🎜Notez que ces accessoires seront vérifiés 🎜 avant la création d'une instance de composant 🎜, donc les propriétés de l'instance (telles que data, calculed, etc. ) sont en default ou les fonctions validator ne sont pas disponibles. 🎜
🎜🎜

🎜Type check🎜🎜🎜🎜type peut être le natif suivant construit Une des fonctions : 🎜

  • 🎜String🎜
  • 🎜Number 🎜
  • 🎜Booléen🎜
  • 🎜Array🎜
  • 🎜Objet🎜
  • 🎜Date🎜
  • 🎜Fonction🎜
  • 🎜Symbole< / code>🎜
🎜De plus, type peut également être un constructeur personnalisé et est vérifié via instanceof. Par exemple, étant donné le constructeur prêt à l'emploi suivant : 🎜rrreee🎜, vous pouvez utiliser : 🎜rrreee🎜 pour vérifier que la valeur du prop author a été créée via new Person. 🎜🎜
🎜

🎜🎜Caractéristiques non-prop🎜🎜🎜🎜🎜Une caractéristique non-prop signifie qu'elle est transmise à un composant, mais que le composant n'a pas une caractéristique de définition d'accessoire correspondante. 🎜🎜Étant donné que les accessoires explicitement définis conviennent pour transmettre des informations à un sous-composant, l'auteur de la bibliothèque de composants ne peut pas toujours prévoir dans quels scénarios le composant sera utilisé. C'est pourquoi les composants peuvent accepter des attributs arbitraires, et ces attributs seront ajoutés à l'élément racine du composant. 🎜🎜Par exemple, imaginez que vous utilisez un composant <bootstrap-date-input> tiers via un plug-in Bootstrap. Ce plug-in doit être inclus dans son <. ;input> Une fonctionnalité data-date-picker est utilisée. Nous pouvons ajouter cet attribut à votre instance de composant : 🎜rrreee🎜 Ensuite, cet attribut data-date-picker="activated" sera automatiquement ajouté à <bootstrap-date-input> ; sur l’élément racine. 🎜🎜
🎜

🎜Remplacer/fusionner des fonctionnalités existantes🎜🎜🎜🎜Imaginer<bootstrap Le modèle de -date-input> ressemble à ceci : 🎜rrreee

Afin de personnaliser un thème pour notre plugin de sélecteur de date, nous devrons peut-être ajouter un nom de classe spécial comme celui-ci :

rrreee

Dans ce cas, nous définissons deux class différentes Valeur : class 的值:

  • form-control,这是在组件的模板内设置好的

  • date-picker-theme-dark,这是从组件的父级传入的

对于绝大多数特性来说,从外部提供给组件的值会替换掉组件内部设置好的值。所以如果传入 type="text" 就会替换掉 type="date" 并把它破坏!庆幸的是,classstyle 特性会稍微智能一些,即两边的值会被合并起来,从而得到最终的值:form-control date-picker-theme-dark


禁用特性继承

如果你希望组件的根元素继承特性,你可以在组件的选项中设置 inheritAttrs: false。例如:

rrreee

这尤其适合配合实例的 $attrs 属性使用,该属性包含了传递给一个组件的特性名和特性值,例如:

rrreee

有了 inheritAttrs: false$attrs,你就可以手动决定这些特性会被赋予哪个元素。在撰写基础组件的时候是常会用到的:

rrreee

注意: inheritAttrs: false 选项不会影响 style 和 class

  • form-control, qui est défini dans le modèle du composant
< li>

date-picker -theme-dark, qui est transmis par le parent du composant

Pour la plupart des fonctionnalités, il est fourni en externe à La valeur du composant remplacera la valeur définie en interne dans le composant. Donc si vous transmettez type="text" il remplacera type="date" et le détruira ! Heureusement, les attributs class et style sont un peu plus intelligents, c'est-à-dire que les valeurs des deux côtés sont combinées pour obtenir la valeur finale : form-control date- picker-theme-dark.

🎜🎜

Héritage des fonctionnalités désactivé🎜🎜Si vous Si vous ne souhaitez pas que l'élément racine d'un composant hérite des attributs, vous pouvez définir inheritAttrs: false dans les options du composant. Par exemple : 🎜rrreee🎜Ceci est particulièrement adapté à une utilisation avec l'attribut $attrs de l'instance, qui contient le nom et la valeur de l'attribut transmis à un composant, par exemple : 🎜rrreee🎜With inheritAttrs : false et $attrs, vous pouvez décider manuellement à quel élément ces attributs seront attribués. ÉcritureComposants de base sont souvent utilisés : 🎜rrreee

🎜Remarque : L'option inheritAttrs: false n'affectera pas la liaison du style et de la class. 🎜🎜🎜Ce mode vous permet d'utiliser des composants de base davantage comme des éléments HTML bruts sans vous soucier de savoir quel élément est le véritable élément racine : 🎜rrreee🎜🎜🎜