Komunikasi komponen global Vue3 menyediakan/menyuntik analisis kod sumber

1. Kata Pengantar

Seperti namanya, komponen datuk-cucu mempunyai hubungan rujukan yang lebih mendalam daripada komunikasi antara komponen ibu bapa-anak (juga dipanggil "komponen yang diasingkan generasi"):

Komponen C diperkenalkan ke dalam komponen B, komponen B diperkenalkan ke dalam komponen A untuk pemaparan Pada masa ini, A ialah tahap datuk C (mungkin terdapat lebih banyak perhubungan hierarki jika anda menggunakan prop, anda hanya boleh lulus). mereka turun peringkat demi tahap, yang terlalu rumit, jadi kami memerlukan kaedah komunikasi yang lebih langsung.

Hubungan antara mereka adalah seperti berikut Grandson.vue tidak dipasang secara langsung di bawah Grandfather.vue. Terdapat sekurang-kurangnya satu Son.vue di antara mereka (mungkin terdapat berbilang):

Grandfather.vue
└─Son.vue
  └─Grandson.vue

Oleh kerana konsistensi hubungan antara pihak atasan dan bawahan, skema komunikasi komponen datuk-cucu juga terpakai untuk komunikasi komponen ibu bapa-anak Anda hanya perlu menggantikan hubungan datuk-cucu dengan hubungan bapa-anak.

2. menyediakan / menyuntik

Ciri ini mempunyai dua bahagian: Grandfather.vue mempunyai pilihan menyediakan untuk menyediakan data dan Grandson.vue mempunyai pilihan suntikan untuk mula menggunakan data .

• Grandfather.vue memberikan nilai kepada Grandson.vue melalui provide (boleh termasuk fungsi yang ditetapkan)

• Cucu.vue memberikan nilai kepada Datuk melalui inject .vue mencetuskan pelaksanaan acara komponen datuk

Tidak kira sedalam mana hierarki komponen, komponen yang memulakan penyediaan boleh digunakan sebagai penyedia pergantungan untuk semua komponen bawahannya
Kandungan bahagian ini Perubahannya sangat besar, tetapi ia sebenarnya sangat mudah digunakan Jangan panik, terdapat tempat yang sama:

• Komponen induk tidak perlu. untuk mengetahui komponen kanak-kanak mana yang menggunakan harta yang disediakannya

• Komponen anak tidak perlu tahu dari mana harta suntikan itu berasal

Selain itu , satu perkara yang perlu diingat ialah pengikatan menyediakan dan menyuntik tidak responsif. Ini disengajakan, tetapi jika objek yang boleh didengar dimasukkan, sifat objek itu akan tetap responsif.

3. Mulakan menyediakan

Mari kita semak semula penggunaan 2.x:

export default {
  // 定义好数据
  data () {
    return {
      tags: [ '中餐', '粤菜', '烧腊' ]
    }
  },
  // provide出去
  provide () {
    return {
      tags: this.tags
    }
  }
}

Versi lama penggunaan menyediakan adalah serupa dengan data dan dikonfigurasikan sebagai pulangan fungsi objek.
Versi baharu provide in 3.x agak berbeza dalam penggunaan daripada 2.x.

Dalam 3.x, menyediakan perlu diimport dan didayakan dalam persediaan, dan kini merupakan kaedah baharu sepenuhnya.
Setiap kali anda ingin memberikan sekeping data, anda mesti memanggilnya secara berasingan.
Setiap kali anda menelefon, anda perlu lulus dalam 2 parameter:

参数	类型	说明
key	string	数据的名称
value	any	数据的值

Mari kita lihat cara membuat penyediaan:

// 记得导入provide
import { defineComponent, provide } from 'vue'

export default defineComponent({
  // ...
  setup () {
    // 定义好数据
    const msg: string = 'Hello World!';

    // provide出去
    provide('msg', msg);
  }
})

Operasinya sangat mudah, tetapi anda perlu memberi perhatian Perkaranya, menyediakan tidak responsif Jika anda ingin menjadikannya responsif, anda perlu memasukkan data responsif

4. Menerima suntikan

juga merupakan ulasan 2.x dahulu. Penggunaan:

export default {
  inject: ['tags'],
  mounted () {
    console.log(this.tags);
  }
}

Penggunaan versi lama suntikan adalah serupa dengan penggunaan props versi baharu dalam 3.x juga agak berbeza daripada penggunaan dalam 2. x.

Dalam 3.x, suntikan adalah sama seperti menyediakan Ia juga perlu diimport dahulu dan kemudian didayakan dalam persediaan.
Setiap kali anda ingin menyuntik sekeping data, anda perlu memanggilnya secara berasingan.
Setiap kali anda membuat panggilan, anda hanya perlu lulus dalam 1 parameter:

参数	类型	说明
key	string	与provide对应的数据名称

// 记得导入inject
import { defineComponent, inject } from 'vue'

export default defineComponent({
  // ...
  setup () {
    const msg: string = inject('msg') || '';
  }
})

也是很简单（写 TS 的话，由于 inject 到的值可能是 undefined，所以要么加个 undefined 类型，要么给变量设置一个空的默认值）。

5、响应性数据的传递与接收

之所以要单独拿出来说， 是因为变化真的很大

在前面我们已经知道，provide 和 inject 本身不可响应，但是并非完全不能够拿到响应的结果，只需要我们传入的数据具备响应性，它依然能够提供响应支持。

我们以 ref 和 reactive 为例，来看看应该怎么发起 provide 和接收 inject。

先在 Grandfather.vue 里 provide 数据：

export default defineComponent({
  // ...
  setup () {
    // provide一个ref
    const msg = ref<string>(&#39;Hello World!&#39;);
    provide(&#39;msg&#39;, msg);

    // provide一个reactive
    const userInfo: Member = reactive({
      id: 1,
      name: &#39;Petter&#39;
    });
    provide(&#39;userInfo&#39;, userInfo);

    // 2s 后更新数据
    setTimeout(() => {
      // 修改消息内容
      msg.value = &#39;Hi World!&#39;;

      // 修改用户名
      userInfo.name = &#39;Tom&#39;;
    }, 2000);
  }
})

在 Grandsun.vue 里 inject 拿到数据：

export default defineComponent({
  setup () {
    // 获取数据
    const msg = inject('msg');
    const userInfo = inject('userInfo');

    // 打印刚刚拿到的数据
    console.log(msg);
    console.log(userInfo);

    // 因为 2s 后数据会变，我们 3s 后再看下，可以争取拿到新的数据
    setTimeout(() => {
      console.log(msg);
      console.log(userInfo);
    }, 3000);

    // 响应式数据还可以直接给 template 使用，会实时更新
    return {
      msg,
      userInfo
    }
  }
})

非常简单，非常方便！！！

响应式的数据 provide 出去，在子孙组件拿到的也是响应式的，并且可以如同自身定义的响应式变量一样，直接 return 给 template 使用，一旦数据有变化，视图也会立即更新。

但上面这句话有效的前提是，不破坏数据的响应性，比如 ref 变量，你需要完整的传入，而不能只传入它的 value，对于 reactive 也是同理，不能直接解构去破坏原本的响应性。

切记！切记！！！

6、引用类型的传递与接收 (针对非响应性数据的处理)

provide 和 inject 并不是可响应的，这是官方的故意设计，但是由于引用类型的特殊性，在子孙组件拿到了数据之后，他们的属性还是可以正常的响应变化。

先在 Grandfather.vue 里 provide 数据：

export default defineComponent({
  // ...
  setup () {
    // provide 一个数组
    const tags: string[] = [ '中餐', '粤菜', '烧腊' ];
    provide('tags', tags);

    // provide 一个对象
    const userInfo: Member = {
      id: 1,
      name: 'Petter'
    };
    provide('userInfo', userInfo);

    // 2s 后更新数据
    setTimeout(() => {
      // 增加tags的长度
      tags.push('叉烧');

      // 修改userInfo的属性值
      userInfo.name = 'Tom';
    }, 2000);
  }
})

在 Grandsun.vue 里 inject 拿到数据：

export default defineComponent({
  setup () {
    // 获取数据
    const tags: string[] = inject('tags') || [];
    const userInfo: Member = inject('userInfo') || {
      id: 0,
      name: ''
    };

    // 打印刚刚拿到的数据
    console.log(tags);
    console.log(tags.length);
    console.log(userInfo);

    // 因为 2s 后数据会变，我们 3s 后再看下，能够看到已经是更新后的数据了
    setTimeout(() => {
      console.log(tags);
      console.log(tags.length);
      console.log(userInfo);
    }, 3000);
  }
})

export default defineComponent({
  setup () {
    // 获取数据
    const tags: string[] = inject('tags') || [];
    const userInfo: Member = inject('userInfo') || {
      id: 0,
      name: ''
    };

    // 打印刚刚拿到的数据
    console.log(tags);
    console.log(tags.length);
    console.log(userInfo);

    // 因为 2s 后数据会变，我们 3s 后再看下，能够看到已经是更新后的数据了
    setTimeout(() => {
      console.log(tags);
      console.log(tags.length);
      console.log(userInfo);
    }, 3000);
  }
})

引用类型的数据，拿到后可以直接用，属性的值更新后，子孙组件也会被更新。
但是！！！由于不具备真正的响应性，return 给模板使用依然不会更新视图，如果涉及到视图的数据，请依然使用 响应式 API 。

7、基本类型的传递与接收 (针对非响应性数据的处理)

基本数据类型被直接 provide 出去后，再怎么修改，都无法更新下去，子孙组件拿到的永远是第一次的那个值。

先在 Grandfather.vue 里 provide 数据：

export default defineComponent({
  // ...
  setup () {
    // provide 一个数组的长度
    const tags: string[] = [ '中餐', '粤菜', '烧腊' ];
    provide('tagsCount', tags.length);

    // provide 一个字符串
    let name: string = 'Petter';
    provide('name', name);

    // 2s 后更新数据
    setTimeout(() => {
      // tagsCount 在 Grandson 那边依然是 3
      tags.push('叉烧');

      // name 在 Grandson 那边依然是 Petter
      name = 'Tom';
    }, 2000);
  }
})

在 Grandsun.vue 里 inject 拿到数据：

export default defineComponent({
  setup () {
    // 获取数据
    const name: string = inject('name') || '';
    const tagsCount: number = inject('tagsCount') || 0;

    // 打印刚刚拿到的数据
    console.log(name);
    console.log(tagsCount);

    // 因为 2s 后数据会变，我们 3s 后再看下
    setTimeout(() => {
      // 依然是 Petter
      console.log(name);

      // 依然是 3
      console.log(tagsCount);
    }, 3000);
  }
})

很失望，并没有变化。

那么是否一定要定义成响应式数据或者引用类型数据呢？

当然不是，我们在 provide 的时候，也可以稍作修改，让它能够同步更新下去。

先在 Grandfather.vue 里 provide 数据：

export default defineComponent({
  // ...
  setup () {
    // provide 一个数组的长度
    const tags: string[] = [ '中餐', '粤菜', '烧腊' ];
    provide('tagsCount', (): number => {
      return tags.length;
    });

    // provide 字符串
    let name: string = 'Petter';
    provide('name', (): string => {
      return name;
    });

    // 2s 后更新数据
    setTimeout(() => {
      // tagsCount 现在可以正常拿到 4 了
      tags.push('叉烧');

      // name 现在可以正常拿到 Tom 了
      name = 'Tom';
    }, 2000);
  }
})

再来 Grandsun.vue 里修改一下 inject 的方式，看看这次拿到的数据：

export default defineComponent({
  setup () {
    // 获取数据
    const tagsCount: any = inject('tagsCount');
    const name: any = inject('name');

    // 打印刚刚拿到的数据
    console.log(tagsCount());
    console.log(name());

    // 因为 2s 后数据会变，我们 3s 后再看下
    setTimeout(() => {
      // 现在可以正确得到 4
      console.log(tagsCount());

      // 现在可以正确得到 Tom
      console.log(name());
    }, 3000);
  }
})

这次可以正确拿到数据了，看出这2次的写法有什么区别了吗？

基本数据类型，需要 provide 一个函数，将其 return 出去给子孙组件用，这样子孙组件每次拿到的数据才会是新的。
但由于不具备响应性，所以子孙组件每次都需要重新通过执行 inject 得到的函数才能拿到最新的数据。

按我个人习惯来说，使用起来挺别扭的，能不用就不用……

由于不具备真正的响应性，return 给模板使用依然不会更新视图，如果涉及到视图的数据，请依然使用 响应式 API 。

Atas ialah kandungan terperinci Komunikasi komponen global Vue3 menyediakan/menyuntik analisis kod sumber. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!