ホームページ  >  記事  >  ウェブフロントエンド  >  VUE の 2 つのコア、レスポンシブ開発とコンポーネントベース開発の詳細な説明

VUE の 2 つのコア、レスポンシブ開発とコンポーネントベース開発の詳細な説明

WBOY
WBOY転載
2022-08-08 16:39:161405ブラウズ

この記事では、vue に関する関連知識を提供します。主に、vue に関する 2 つの主要な問題、応答性、コンポーネント化について紹介します。一緒に見てみましょう。皆さんのお役に立てれば幸いです。

VUE の 2 つのコア、レスポンシブ開発とコンポーネントベース開発の詳細な説明

【関連する推奨事項: javascript ビデオ チュートリアルvue.js チュートリアル

vue2.0 の応答式

1. オブジェクト応答式

1.1 Object.defineProperty

Object.defineProperty(obj, prop, descriptor) メソッドは、オブジェクトの新しいプロパティを直接定義するか、オブジェクトの既存のプロパティを変更して、このオブジェクトを返します。

obj—属性を定義するオブジェクト
prop—定義または変更する属性の名前またはシンボル
descriptor—オブジェクト、定義する属性記述子または変更されました

// descriptor{
  value: undefined, // 属性的值
  get: undefined,   // 获取属性值时触发的方法
  set: undefined,   // 设置属性值时触发的方法
  writable: false,  // 属性值是否可修改,false不可改
  enumerable: false, // 属性是否可以用for...in 和 Object.keys()枚举
  configurable: false  // 该属性是否可以用delete删除,false不可删除,为false时也不能再修改该参数}

代入操作によって追加された通常のプロパティは列挙可能であり、オブジェクト プロパティ (for...in または Object.keys メソッド) を列挙するときに列挙されます。これらの値は変更できます。の属性も削除できます。この方法では、デフォルトの追加オプション (または構成) を変更できます。
デフォルトでは、Object.defineProperty() を使用して追加されたプロパティ値は不変です。
例:

const a = {b : 1}
console.log(Object.getOwnPropertyDescriptor(a, 'b'))
// {value: 1, writable: true, enumerable: true, configurable: true}

Object.defineProperty(a, 'c', {value: '2'})
console.log(Object.getOwnPropertyDescriptor(a, 'c'))
// {value: '2', writable: false, enumerable: false, configurable: false}

a.c = 3
console.log(a.c)
// 2

Object.defineProperty(a, 'c', {value: '4'})
console.log(a.c)
// error: Uncaught TypeError: Cannot redefine property: c

1.2 set and get

// 模拟vue响应式过程const app = document.getElementById('app')const data = {
	a: {
	  b: {
	    c: 1
	  }
	}}function render () {
  const virtualDom = `这是我的内容${data.a.b.c}`		
  app.innerHTML = virtualDom}function observer (obj) {
  let value  for (const key in obj) {  // 递归设置set和get
    value = obj[key]
    if (typeof value === 'object'){
      arguments.callee(value)
    } else {
      Object.defineProperty(obj, key, {
        get: function(){
          return value        },
        set: function(newValue){
          value = newValue          render()
        }
      })
    }
  }}render()observer(data)setTimeout(() => {
  data.a.b.c = 22}, 2000)setTimeout(() => {
  data.a.b.c = 88}, 5000)

上記のメソッドはデータ応答を実装していますが、大きな問題があります。set を 1 回トリガーすると、全体が必要になります。ページを再レンダリングします。ただし、この値は特定のコンポーネントでのみ使用できます。
VUE の 2 つのコア、レスポンシブ開発とコンポーネントベース開発の詳細な説明

そのため、get と set は最適化されます:

Object.defineProperty(data, key, {
  get: function(){
    dep.depend() // 这里进行依赖收集
    return value  },
  set: function(newValue){
    value = newValue    // render()
    dep.notify()  // 这里进行virtualDom更新,通知需要更新的组件render
  }});

dep は Vue が依存関係の管理を担当するクラスです

補足: Vue は追加を検出できませんまたはプロパティの追加 Remove。 Vue はインスタンスの初期化時にプロパティのゲッター/セッター変換を実行するため、Vue が応答型の

const vm = new Vue({
	data: {
		a: 1
	}})// vm.a是响应式的vm.b = 2// vm.b是非响应式的

2 に変換するには、そのプロパティがデータ オブジェクトに存在する必要があります。 #Vue は配列の変更を処理し、添え字を通じてビューの変更を直接トリガーします。使用できるのはプッシュ、シフト、その他のメソッドのみであり、配列では Object.defineProperty() を使用できません。

実際、Vue はデコレータ モードを使用します。これらのメソッド


Object.create(proto,[propertiesObject])

メソッドは、既存のオブジェクトを使用して新しいオブジェクトを作成し、__proto__## を提供します。新しく作成されたオブジェクトの #proto

——新しく作成されたオブジェクトのプロトタイプ オブジェクト;

propertiesObject——オプション、タイプはオブジェクトですパラメーターが指定されており、 unknown でない場合、渡されたオブジェクト自身の列挙可能なプロパティ (つまり、プロトタイプ チェーン上の列挙されたプロパティではなく、独自に定義されたプロパティ) は、指定されたプロパティ値と対応するプロパティ記述子を新しく作成されたオブジェクト

const a = {}
// 相当于
const a = Object.create(Object.prototype)

const person = {
  isHuman: false,
  printIntroduction: function () {
    console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
  }
};

const me = Object.create(person);

me.name = 'Matthew'; // "name" is a property set on "me", but not on "person"
me.isHuman = true; // inherited properties can be overwritten

me.printIntroduction();
// expected output: "My name is Matthew. Am I human? true"
const o = Object.create(Object.prototype, {
  foo: { // foo会成为所创建对象的数据属性
    writable:true,
    configurable:true,
    value: "hello"
  },
  bar: { // bar会成为所创建对象的访问器属性
    configurable: false,
    get: function() { return 10 },
    set: function(value) {
      console.log("Setting `o.bar` to", value);
    }
  }});console.log(o) // {foo: 'hello'}
vueのデコレーターモード
const arraypro = Array.prototype    // 获取Array的原型
const arrob = Object.create(arraypro) // 用Array的原型创建一个新对象,arrob.__proto__ === arraypro,免得污染原生Array;
const arr=['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse']   // 需要重写的方法

arr.forEach(function(method) {
  arrob[method] = function () {
    arraypro[method].apply(this, arguments) // 重写时先调用原生方法
    dep.notify() // 并且同时更新
  }
})

// 对于用户定义的数组,手动将数组的__proto__指向我们修改过的原型
const a = [1, 2, 3]
a.__proto__ = arrob
新しいオブジェクトarrobの上記のメソッドでは、値を直接割り当てます。これにより問題が発生します。つまり、ユーザーが誤って行う可能性があります。オブジェクトを変更します。そのため、この問題を回避するには、前に説明した Object.defineProperty を使用できます。特に、値を変更できないプロパティを設定するためのパブリック メソッド def を作成します。

function def (obj, key, value) {
  Object.defineProperty(obj, key, {
    // 这里我们没有指定writeable,默认为false,即不可修改
    enumerable: true,
    configurable: true,
    value: value,
  });}// 数组方法重写改为arr.forEach(function(method){
  def(arrob, method, function () {
    arraypro[method].apply(this, arguments)  // 重写时先调用原生方法
    dep.notify()// 并且同时更新
  })})
3. 補足: データオブジェクトのプロパティとアクセサ 属性

データ属性:

データ値の読み取りおよび書き込みが可能なデータ値の場所が含まれます

データの 4 つの記述子属性:

構成可能means プロパティを再定義するために delete によってプロパティを削除できますか? プロパティのプロパティを変更できますか? プロパティをアクセサー プロパティとして変更できますか? デフォルトは true enumerablefor-in ループを通じて属性を返すことができるかどうかを示します。デフォルトは trueですwritable属性は変更できます。デフォルトは truevalue この属性のデータ値が含まれます。デフォルトは未定義です
意味
#

アクセサー属性: この属性にはデータ値が含まれませんが、get メソッドと set メソッドのペアが含まれています。アクセサー属性の読み取りおよび書き込み時には、これら 2 つのメソッドを使用して操作が実行されます。

アクセサー プロパティの 4 つの記述子:

##意味##configurableenumerable です。 getset

vue3.0数据响应

vue3.0的响应式和vue2.0响应式原理类似,都是在get中收集依赖,在set中通知依赖更新视图,但vue3.0使用了es6新增的proxy来代替Object.defineProperty()

proxy相对于Object.defineProperty()的好处:

  1. Object.defineProperty需要指定对象和属性,对于多层嵌套的对象需要递归监听,Proxy可以直接监听整个对象,不需要递归;
  2. Object.defineProperty的get方法没有传入参数,如果我们需要返回原值,需要在外部缓存一遍之前的值,Proxy的get方法会传入对象和属性,可以直接在函数内部操作,不需要外部变量;
  3. set方法也有类似的问题,Object.defineProperty的set方法传入参数只有newValue,也需要手动将newValue赋给外部变量,Proxy的set也会传入对象和属性,可以直接在函数内部操作;
  4. new Proxy()会返回一个新对象,不会污染源原对象
  5. Proxy可以监听数组,不用单独处理数组

proxy劣势: vue3.0将放弃对低版本浏览器的兼容(兼容版本ie11以上)

这样上边的observe方法就可以优化成:

function observer () {
  var self = this;
  data = new Proxy(data, {
    get: function(target, key){
      dep.depend() // 这里进行依赖收集
      return target[key]
    },
    set: function(target, key, newValue){
      target[key] = newValue;
      // render()
	  dep.notify()  // 这里进行virtualDom更新,通知需要更新的组件render
    }
  });}

模块化(组件化)开发

按照功能(或按照复用性)把一个页面拆成各个板块(模块),每一个模块都是一个单独的文件(单独的组件),最后把各个模块(组件)拼在一起即可!!

目的 :方便团队协作开发 实现复用

组件分类

功能型组件「UI组件库中提供的一般都是功能型组件:element/iview/antdv/vant/cube..」

  •     + 一般UI组件库提供的功能组件就够用了
  •     + 偶尔UI组件库中不存在的,才需要自己封装「难点」
  •     + 我们经常会把功能型组件进行二次封装(结合自己项目的业务逻辑)「特殊亮点」

业务型组件

  •   + 通用业务型组件「好多页面都需要用到的,我们把其封装成为公共的组件」
  •   + 普通组件

以后开发项目,拿到设计稿的第一件事情:划分组件「按照功能版块划分、本着复用性原则,拆的越细越好(这样才能更好的实现复用)」

组件的创建及使用

创建一个 Xxx.vue 就是创建一个vue组件{局部组件、私有组件},组件中包含:结构、样式、功能

 结构:基于template构建        

       + 只能有一个根元素节点(vue2)
     + vue的视图就是基于template语法构建的(各种指令&小胡子...),最后vue会把其编译为真实的DOM插入到页面指定的容器中
      首先基于 vue-template-compiler 插件把template语法编译为虚拟DOM「vnode」
      其次把本次编译出来的vnode和上一次的进行对比,计算出差异化的部分「DOM-DIFF」
      最后把差异化的部分变为真实的DOM放在页面中渲染
 

样式:基于style来处理

  • + lang="less" 指定使用的CSS预编译语言「需要提前安装对应的loader」
  • + scoped 指定当前编写的样式是私有的,只对当前组件中的结构生效,后期组件合并在一起,保证样式之间不冲突

 功能:通过script处理

    + 导出的这个对象是VueComponent类的实例(也是Vue的实例):对象 -> VueComponent.prototype -> Vue.prototype
    + 在对象中基于各种 options api 「例如:data、methods、computed、watch、filters、生命周期函数...」实现当前组件的功能
       + 在组件中的data不再是一个对象,而是一个“闭包”
       + 各个组件最后会合并在一起渲染,为了保证组件中指定的响应式数据是“私有的”,组件之间数据即使名字相同,也不会相互污染...所以需要基于闭包来管理

注意;App.vue页面入口相当于首页,写好的组件都导入到这个里面

<template>
  <div>
    {{ msg }}
  </div>
</template>

<script>
export default {
  name: "Test",
  data() {
    return {
      //编写响应式数据
      msg: "你好,世界",
    };
  },
};
</script>

<style>
.box {
  font-size: 20px;
  color: red;
}
</style>

私有组件(使用的时候首先进行导入,然后注册,这样视图中就可以调用组件进行渲染了)

  • 需要使用私有组件的时候,需要先导入import Test from "./Test.vue";

  • 然后注册:这样就可以调用组件进行渲染了

<template>
  <div>
      //3.使用组件:可以使用单闭合或双闭合
      
    <test></test>
      <test>
  </test>
</div>
</template>


<script>
//1、导入组件
import Test from "./Test.vue";
export default {
  name: "App",
  components:{
    //2、注册使用的组件
    Test,
  }
};
</script>

创建全局组件

1. 创建一个局部组件 

<template>
  <div>{{ msg }}</div>
</template>

<script>
export default {
  name: "Vote",
  data() {
    return {
      msg: "今夜阳光明媚",
    };
  },
};
</script>

@2 在main.js入口中,导入局部组件Vote,把其注册为全局组件

import Vote from './Vote.vue';
Vue.component('Vote', Vote)

@3 这样在任何组件(视图中),无需基于components注册,直接可以在视图中调用

插槽

调用组件的方式

调用组件的时候,可以使用:

双闭合

双闭合的方式可以使用插槽slot

 @1 在封装的组件中,基于 标签预留位置
 @2 调用组件的时候,基于双闭合的方式,把要插入到插槽中的内容写在双闭合之间

  单闭合

组件的名字可以在“kebab-case”和“CamelCase”来切换:官方建议组件名字基于CamelCase命名,渲染的时候基于kebab-case模式使用!

 插槽的作用

  • 让组件具备更高的复用性(或扩展性)
  • 我们封装好一个组件,把核心部分都实现了,但是我们期望用户调用组件的时候,可以自定义一些内容,防止在已经封装好的组件内部:

插槽分为了默认插槽、具名插槽、作用域插槽

默认插槽:只需要在调用组件<test><test></test></test>内插入我们想要的插入的html代码,会默认放到组件源代码的<slot name="default"></slot>插槽中

组件内部
slot预留位置  默认name:default
<slot></slot>
调用组件的时候
//只有一个的时候可以不用template包裹
<test>
<div>头部导航</div>
</test>

具名插槽:组件中预设好多插槽位置,为了后期可以区分插入到哪,我们把插槽设置名字

  • 在调用组件<test><test></test></test>内自己写的代码,我们用template包裹代码,并把v-slot:xxx写在template上,这时就会将xxx里面的代码,包裹到组件源代码的<slot name="”xxx“"></slot>的标签中
  • ==组件内部:== <slot name="xxx"></slot> 默认名字是default
  • ==调用组件:==需要把v-slot写在template上
  组件内部
      <slot>
      默认名字是default
    调用组件:需要把v-slot写在template上
      <template>
         ...
      </template>
      <template>
         ...
      </template>
    v-slot可以简写为#:#xxx</slot>

   作用域插槽:把组件内部定义的数据,拿到调用组件时候的视图中使用

        组件中data内的数据只能在本模块中使用,如果想让调用组件的插槽也能获取数据,就需要对组件内对的slot做bind绑定数据,调用组件的template标签做#top="AAA",获取数

   ==组件内部==:
 <slot name="top" :list="list" :msg="msg"></slot>
  • 把组件中的list赋值给list属性,把msg赋值给msg属性,插槽中提供了两个作用域属性:list/msg
==调用组件==:
 <template #top="AAA"></template>
  • 定义一个叫做AAA的变量,来接收插槽中绑定的所有数据(对象格式)
  • 如果插槽名是default则使用v-slot="AAA":default="AAA"获取数据
 组件内部
      <slot></slot>
      把组件中的list赋值给list属性,把msg赋值给msg属性,插槽中提供了两个作用域属性:list/msg

    调用组件
      <template></template>
      定义一个叫做AAA的变量,来接收插槽中绑定的数据
      AAA={
        list:[...],
        msg:...
      }

组件传参 

调用组件的时候

每创建一个组件其实相当于创建一个自定义类,而调用这个组件就是创建VueCommponent(或者Vue)类的实例

  • 实例(this)->VueComponent.prototype->Vue.prototype->Object.prototype
  • 当前实例可以访问Vue.prototype上的一些公共属性和方法

组件中的script中存在的状态值和属性值?

  • ==状态值==:data中的数据值称为状态值
  • ==属性值==:props中的数据值称为属性值
  • 状态值和属性值是直接挂载到_vode对象的私有属性中(所以状态值和属性值名字不能重复)
  • 我们在视图template标签中调用状态值和属性值,不需要加this,直接调用状态名或属性名
  • 我们在功能script标签中调用状态值和属性值,需要加this调用
  • ==computed(计算属性)==:也是挂载实例上的,所以他们三个都不能重名

vue中的单向数据流

父子组件传递数据时,只能由父组件流向子组件,不能由子组件流向父组件。这样会防止从子组件意外改变父级组件的状态,从而导致你的应用的数据流向难以理解。

组件传参的分类7种:

  • 父组件向子组件传参:props
  • 子组件向父组件传参:发布订阅(@xxx给子组件标签自定义事件、$emit)
  • 组件相互传参(兄弟):发布订阅(on、emit)【2和3传参是一种】
  • 祖先向后代传参(provide[提供],inject[接收])
  • vue实例属性传参(parent、children[n]、root、refs)
  • vuex
  • localStorage sessionStorage

1.父组件向子组件传参

父组件向子组件传参:props

  • 我们传给组件的值,默认是==字符串类型==的,比如msg
  • 如果想传==数字类型==的,则需要调用v-bind或冒号的形式传值
  • 我们每调用一次coma,都会生成一个独立的VueComponent的实例

第一步:父组件在组件调用标签中自定义属性

//如果想把data中的状态值传递过去需要v-bind绑定
<coma></coma>

注意 如果想把data中的状态值传递过去需要v-bind绑定

第二步:子组件通过props接收(数组,对象)

  • props中的属性是只读的,子组件不能修改这些值,否则会报错
  • 解决只读问题:用自定义变量接收传递过来的值,页面使用自定义变量
  • props可以是对象或数组类型,对象可以对数据做校验,数组不能
    // props的值是只读的 能改,会报错
    <input>
    //数组格式
    props:["msg","num"]
    //对象格式
     props: {
    msg: {
      //传参类型必须是字符串
      type: String,
      //必须传参
      required: true,
    },
    num: {
      type: Number,
      //如果不传参默认是102
      default: 102,
    },
  },
    //----------------------------------------
    //用自定义变量numa接收num,然后页面使用numa(解决只读问题)
    <h1>我是子组件 coma------{{ msg }}----{{ numa }}</h1>
    <input>
    props: ["msg", "num"],
      data() {
        return {
        numa: this.num,
       };
     },

2.子组件向父组件传参

子组件向父组件传参,基于==发布订阅(@xxx给子组件标签自定义事件、$emit)==

第一步:父组件在调用子组件的标签上需要自定义一个事件,这个事件及绑定的方法就会添加到子组件的事件池中:底层实质上是调用了this.$on("myEvent",fn)

<coma></coma>
 methods: {
    getData() {},
  },

第二步:子组件用this.$emit()接受(this.$emit(myEvent,参数1,参数2)), 参数可以是子组件的,顺便传给父组件,实现子组件向父组件传值

  <button>向父组件发送数据</button>
 data() {
    return {
      flag: "你很美",
      n: 101,
    };
  methods: {
    goParentData() {
      //执行父组件自定义的事件
      this.$emit("myEvent", this.flag, this.n);
    },
  },

第三步:父组件使用传递过来的数据

 data() {
    return {
      n: 0,
      flag: "",
    };
  },
  methods: {
    getData(...parans) {
      console.log(parans);
      //传递过来的是数组
      this.n = parans[0];
      this.flag = parans[1];
    },
  },

3.组件之间相互传参    原生事件法  (发布订阅)

b--->c发送数据

  • c向事件池中添加方法(自定义方法):$on
  • b执行方法把参数传过去:$emit

第一步:全局的main.js中创建一个全局的EventBus,挂载 vue的原型上  this.$bus

  • 作用:将EventBus看作定义在公有属性上的事件池(事件公交),之后基于这个$bus.$on()绑定的事件函数,在哪个vue实例上都可以基于$bus.$empty()执行,还可以传值
//创建一个全局的 Eventbus
let Eventbus=new Vue();
//挂载 vue的原型上  后期基于this.$bus
Vue.prototype.$bus=Eventbus;

第二步:comc向事件池中绑定事件:this.$bus.$on("事件名",函数)

  created() {
    //向事件池中添加方法
    this.$bus.$on("myEvent", () => {});
  },

第三步:comb从事件池中获取事件函数并执行:this.$bus.$emit("事件名",想传的参数)

    <button>发送数据给comc</button>
      data() {
        return {
          msg: "我是comb",
    };
    methods: {
    send() {
      //执行事件池中的方法,并且传参
      this.$bus.$emit("myEvent", this.msg);
    },

第四步 comc使用传递过来的数据

   <h1>组件 comc----{{ msg }}</h1>
     data() {
        return {
          msg: "",
      };
  //创建之后的钩子函数向事件池中添加方法
 created() {
    //向事件池中添加方法
    this.$bus.$on("myEvent", (value) => {
      console.log(value);
      this.msg = value;
    });
  },

4.祖先和后代相互传参

  • 第一步:祖先要使用provide方法传参,不是写在methods里面,与methods同级
 data() {
    return {
      title: "我是about祖先",
    };
  },
  provide() {
    return {
      title: this.title,
    };
  },

第二步:后代使用inject属性接受祖先中的参数,inject是data中的数据,是数组类型

  inject: ["title"],因为inject是数组类型,所以它符合如果数据项不是对象类型,则不做劫持,如果数据项是对象,则这个对象中的属性会做劫持。

  data() {
    return {
      title: "我是about祖先",
    };
  },
//祖先 传递的title是非响应式
  provide() {
    return {
      title: this.title,
    };
  },
//------------------------------
  data() {
    return {
      //obj非响应式
      obj: {
        //title是响应式
        title: "我是about祖先",
      },
    };
  },
  //祖先 传递的参数失去响应式,但里面的值会是响应式
  provide() {
    return {
      obj: this.obj,
    };
  },

vue实例属性传参

vue的实例中存在一些属性能够获取不同关系的元素,获取之后就可以基于这个元素获取其中的数据或方法了:

  • $parent 获取父元素的数据/方法  获取父元素的整个vm实例
  • 子组件可以在任何生命周期函数中获取父元素【父子组件的生命周期
  created() {
    console.log(this.$parent.title);
  },
  •  $children  获取子元素的数据/方法(mounted钩子函数,要有下标)
  • this.$children[n]:获取第n个子元素的vm实例
  • 父组件只能在mounted生命周期函数里或之后获取子元素【父子组件的生命周期
  mounted() {
    console.log(this.$children[0].msg);
  },
  • $root获取根组件的数据/方法
  • this.$root:获取根元素的vm实例(main.js中new 的Vue实例)
et mv = new Vue({
  router,
  data() {
    return {
      rootmsg: "我是草根"
    }
  },
  render: h => h(App)
}).$mount('#app')
---------------------
  mounted() {
    console.log(this.$root.rootmsg);
  },
  • this.$refs:this的子元素中需要定义ref属性:比如ref="xxx"
  • ==如果ref定义在DOM标签中==:this.$refs.xxx获取的是DOM对象
  • ==如果ref定义在子组件标签中==:this.$refs.xxx获取的是子组件的vm实例
  //获取的是dom元素
  <div>11111</div>
   mounted() {
    console.log(this.$refs.one);
  },
-----------------------------------
获取的是组件
  <comb></comb>
  mounted() {
    console.log(this.$refs.b);
  },
//如果不是组件获取的就是dom元素,如果是组件,获取的就是组件的实例

父子组件的生命周期

重点:父组件更新默认不会触发子组件更新,但是**==如果子组件中绑定调用了父组件的数据aaa,父组件的aaa数据更新触发重新渲染时,使用aaa数据{{$parent.aaa}}的子组件也会触发更新==**

一、父子组件生命周期执行过程

  • 父->beforeCreated
  • 父->created
  • 父->beforeMount
  •         子->beforeCreate
  •        子->created
  •         子->beforeMount
  •         子->mounted
  • 父->mounted

二、子组件更新过程:

  • 父->berforeUpdate
  •         子->berforeUpdate
  •        子->updated
  • 父->updated

三、父组件更新过程:

  • 父->berforeUpdate
  • 父->updated

四、父组件销毁过程:

  • 父->beforeDestory
  •         子beforeDestory
  •         子destoryed
  • 父->destoryed

扩展------------------------

父组件绑定在子组件标签中的事件,是无法触发的,如何解决?

@xxx.native: 监听组件根元素的原生事件。

  • 例子<my-component></my-component>

  • 原理:在父组件中给子组件绑定一个==原生(click/mouseover...)==的事件,就将子组件变成了普通的HTML标签,不加'. native'父组件绑定给子组件标签的事件是无法触发的

虚拟DOM

虚拟DOM对象:_vnode,作用:

第一步:vue内部自己定义的一套对象,基于自己规定的键值对,来描述视图中每一个节点的特征:

  • tag标签名
  • text文本节点,存储文本内容
  • children:子节点
  • data:属性
  • 第二步:基于vue-template-compiler去渲染解析 template 视图,最后构建出上述的虚拟DOM对象
  • 第三步:组件重新渲染,又重新生成一个 _vnode
  • 第四步:对比两次的 _vnode. 获取差异的部分
  • 第五步:把差异的部分渲染为真实的DOM

组件库

  • element-ui:饿了么
  • antdv :蚂蚁金服
  • iview :京东
  • Element - The world's most popular Vue UI framework
  • ==vue2.xx==:elemnetui
  • ==vue3.xx==:element plus

如何在项目中使用功能性组件?

==第一步==:安装element-ui:$npm i element-ui -s

==第二步==:导入:

完整导入:整个组件库都导入进来,想用什么直接用Vue.use(xxx)即可

缺点:如果我们只用几个组件,则无用的导入组件会造成项目打包体积变大[不好],所以项目中推荐使用按需导入

按需导入

1、需要安装依赖$ npm install babel-plugin-component

样式私有化

在Vue中我们基于scoped设置样式私有化之后:

  • 会给组件创建一个唯一的ID(例如:data-v-5f109989)

  • 在组件视图中,我们编写所有元素(包含元素调用的UI组件),都设置了这个ID属性;但是我们调用的组件内部的元素,并没有设置这个属性!!

   <div>
      <button>
        <span>新增任务</span>
      </button>
    </div>

而我们编写的样式,最后会自动加上属性选择器:

 .task-box {
      box-sizing: border-box;
      ...
    }
---------编译后成为:---------
    .task-box[data-v-5f1969a9]{
      box-sizing: border-box;
    }
  • ==组件样式私有化的原理==:设置唯一的属性(组件ID)、组件内部给所有样式后面都加上该属性选择器
  • ==问题==:组件内部的元素没有设置这个属性,但是我们编写的样式是基于这个属性选择器在css设置的选择器,
  • ==解决==:在组件内部的元素选择器前加/deep/:
    /deep/.el-textarea__inner,
    	/deep/.el-input__inner{
   		 border-radius: 0;
 		 }

API

  • 在真实项目中,我们会把数据请求和axios的二次封装,都会放到src/api路径下进行管理

//main.js
	import api from '@/api/index';
	// 把存储接口请求的api对象挂载搭配Vue的原型上:
    后续在各个组件基于this.$api.xxx()就可以发送请求了,无需在每个组件中再单独导入这个api对象。
	Vue.prototype.$api=api;

【相关推荐:javascript视频教程web前端


delete によって属性を削除して属性を再定義できるかどうか、属性の特性を変更できるかどうか、または属性をアクセサー属性として変更できるかどうかを示します。デフォルトは次のとおりです。 false
は、for-in ループを通じて属性を返すことができるかどうかを示します。デフォルトは false
プロパティの読み取り時に呼び出される関数、デフォルト値は未定義です。
プロパティの書き込み時に呼び出される関数、デフォルト値は未定義です

以上がVUE の 2 つのコア、レスポンシブ開発とコンポーネントベース開発の詳細な説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

声明:
この記事はcsdn.netで複製されています。侵害がある場合は、admin@php.cn までご連絡ください。