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
-
Vue.component('blog-post', { // 在 JavaScript 中是 camelCase 的 props: ['postTitle'], template: '<h3>{{ postTitle }}</h3>' })
<!-- 在 HTML 中是 kebab-case 的 --> <blog-post post-title="hello!"></blog-post>
Encore une fois, si vous utilisez un modèle de chaînes, alors cette restriction n'existe pas.
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 Passez une valeur booléenne<blog-post v-bind="post"></blog-post>
<blog-post
v-bind:id="post.id"
v-bind:title="post.title"
></blog-post>
Passer dans un tableau Passer un objetprops: ['initialCounter'],
data: function () {
return {
counter: this.initialCounter
}
}
props: ['size'],
computed: {
normalizedSize: function () {
return this.size.trim().toLowerCase()
}
}
Si vous souhaitez transmettre tous les attributs d'un objet comme accessoires, vous pouvez Utilisez le modèle suivant : Transmettre tous les attributs d'un objet
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
}
}
}
})
function Person (firstName, lastName) {
this.firstName = firstName
this.lastName = lastName
}
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 会在一个组件实例创建之前进行验证,所以实例的属性 (如
data
、computed
等) 在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 endefault
ou les fonctionsvalidator
ne sont pas disponibles. 🎜
🎜Type check🎜🎜🎜🎜 🎜Remplacer/fusionner des fonctionnalités existantes🎜🎜🎜🎜Imaginer 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 : Dans ce cas, nous définissons deux 对于绝大多数特性来说,从外部提供给组件的值会替换掉组件内部设置好的值。所以如果传入 禁用特性继承 如果你不希望组件的根元素继承特性,你可以在组件的选项中设置 这尤其适合配合实例的 有了 注意: 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 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 type
peut être le natif suivant construit Une des fonctions : 🎜
🎜De plus, String
🎜Number
🎜Booléen
🎜Array
🎜Objet code >🎜
Date
🎜Fonction
🎜Symbole< / code>🎜
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> ; code> sur l’élément racine. 🎜🎜
🎜<bootstrap Le modèle de -date-input>
ressemble à ceci : 🎜rrreeeclass
différentes Valeur : class
的值:form-control
,这是在组件的模板内设置好的date-picker-theme-dark
,这是从组件的父级传入的type="text"
就会替换掉 type="date"
并把它破坏!庆幸的是,class
和 style
特性会稍微智能一些,即两边的值会被合并起来,从而得到最终的值:form-control date-picker-theme-dark
。inheritAttrs: false
。例如:$attrs
属性使用,该属性包含了传递给一个组件的特性名和特性值,例如:inheritAttrs: false
和 $attrs
,你就可以手动决定这些特性会被赋予哪个元素。在撰写基础组件的时候是常会用到的: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 composanttype="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
. 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🎜🎜🎜