难点组件之间的传值——反向传值

 在这之前我们已经学习过了组件的属性,它可以用于组件的传值,将父组件的数据传给子组件。但是它只能实现单向的组件传值,还不能实现子传父。

在此基础上,我们今天来研究组件之间的反向传值。

这里我介绍三种组件中反向传值的方法:

一、利用this.$emit()函数实现

实现原理:有时候我们子组件的data 数据需要交给父组件使用: 通过在子组件上定义自定义事件,在子组件中通过$emit 来触发事件;子组件的事件被触发并传参,事件处理函数可以接收到子组件的数据;事件绑定的事件处理函数在父节点上,故可在事件处理函数中用到子组件的数据值来修改父节点的数据。

1、首先创建Box1.vue文件,配置子组件,并创建好自定义事件。

<template>
    <div class="box1">
     <button @click="fn">修改属性title</button>
    </div>
</template>
<script>
    export default{
        data() {
            return {
                msg:"修改后的msg值"
            }
        },
        methods: {
            fn(){
          //当点击按钮后,我们自定义的事件触发并将当前组件的msg传到父组件中绑定的监听函数
                this.$emit("updatemsg",this.msg)
            }
        },
    }
</script>
<style>
    .box1{
        width: 150px;
        height: 150px;
        background-color: aqua;
    }
</style>

2、创建App.vue文件,配置父组件,导入注册使用Box1组件,在Box1标签中绑定我们的自定义事件updatemsg,绑定的函数接收子组件传来的值。

<template>
  <div class="app">
    <h1>app父组件</h1>
    <div>{{this.msg}}</div>
    <Box1  @updatemsg="fm"></Box1>
  </div>
</template>

<script>
import Box1 from "@/components/box1.vue"
export default {
  data() {
    return {
      msg:"父组件的数据"
    }
  },
  components:{
    Box1
  },
  methods: {
    fm(arg){
      this.msg=arg
    }
  },
}
</script>

<style>
  .app{
    width: 300px;
    height: 300px;
    background-color: aquamarine;
  }
</style>

当我们点击按钮以后,父组件的msg的值改为子组件传来的值,对应页面从新渲染。

效果:

初始页面:

 点击后:

 即子组件向父组件传值成功。

二、利用this.$emit()函数和.sync实现

这一种可以说是第一种的优化,当对于子组件有属性时,我们父组件再给子组件传值时只需要在属性名后.sync就不用再给该子组件绑定自定义事件,对应子组件中this.$emit("update:属性名",传入参数),过后系统会自动帮我们处理。

缺点:只能用在子组件有属性时,只能改变传入属性的值。

改进上面的代码:

子组件中添加属性,改动this.$emit()

<template>
    <div class="box1">
        <!-- 等待父组件传title属性的值 -->
     <div>{{title}}</div>
     <button @click="fn">修改属性title</button>
    </div>
</template>
<script>
    export default{
        //创建属性
        props:["title"],
        data() {
            return {
                msg:"修改后的msg值"
            }
        },
        methods: {
            fn(){
                this.$emit("update:title",this.msg)
            }
        },
    }
</script>
<style>
    .box1{
        width: 150px;
        height: 150px;
        background-color: aqua;
    }
</style>

父组件:

<template>
  <div class="app">
    <h1>app父组件</h1>
    <div>{{this.msg}}</div>
    <Box1 :title.sync="msg"></Box1>
  </div>
</template>

<script>
import Box1 from "@/components/box1.vue"
export default {
  data() {
    return {
      msg:"父组件的数据"
    }
  },
  components:{
    Box1
  },
}
</script>

<style>
  .app{
    width: 300px;
    height: 300px;
    background-color: aquamarine;
  }
</style>

三、利用v-model和this.$emit()函数传值

v-model前面在双向数据绑定我们已经学习过了,其实它也可以将其用在组件上。

v-model本质是一种语法糖,解析为:value和@input。

了解完本质后,我想大家应该知道如何实现了。首先我们需要在子组件中定义一个value属性,我们在v-model="传值"时,就相当于给子组件的value属性传值。然后我们还需要在this.$emit("input","参数")中如下操作,当触发this.$emit时,参数就会传给父组件传值的那个属性。

父组件代码:

<template>
  <div class="app">
    <h1>app父组件</h1>
    <div>{{this.msg}}</div>
    <Box1 v-model="msg"></Box1>
  </div>
</template>

<script>
import Box1 from "@/components/box1.vue"
export default {
  data() {
    return {
      msg:"父组件的数据"
    }
  },
  components:{
    Box1
  },
}
</script>

<style>
  .app{
    width: 300px;
    height: 300px;
    background-color: aquamarine;
  }
</style>

子组件代码:

<template>
    <div class="box1">
        <!-- 等待父组件传title属性的值 -->
     <div>{{value}}</div>
     <button @click="fn">修改属性msg</button>
    </div>
</template>
<script>
    export default{
        //创建属性
        props:["value"],
        data() {
            return {
                msg:"修改后的msg值"
            }
        },
        methods: {
            fn(){
                this.$emit("input",this.msg)
            }
        },
    }
</script>
<style>
    .box1{
        width: 150px;
        height: 150px;
        background-color: aqua;
    }
</style>

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
反向传播算法(Backpropagation)是一种用于训练神经网络的常见优化算法。它通过计算损失函数相对于每个参数的梯度,并使用梯度下降来更新参数。下面我将给出反向传播算法的公式推导及示例代码。 1. 反向传播算法公式推导: 首先,定义神经网络的损失函数为L,该函数是由网络输出和真实标签之间的差异计算得出。假设神经网络有多个隐藏层,每个隐藏层的参数为W和b。 1.1 前向传播: 首先,我们通过前向传播计算每一层的输出值。假设输入为x,第l层的输出为a[l],则有: a = x z[l] = W[l] * a[l-1] + b[l] a[l] = g(z[l]) 其中,g()是激活函数。 1.2 反向传播: 接下来,我们需要计算损失函数相对于每个参数的梯度,然后使用梯度下降更新参数。假设我们有L层神经网络,则有以下公式: 输出层的梯度: dz[L] = dL / da[L] * g'(z[L]) 隐藏层的梯度: dz[l] = (W[l+1]的转置 * dz[l+1]) * g'(z[l]) 参数梯度: dW[l] = dz[l] * a[l-1的转置] db[l] = dz[l] 更新参数: W[l] = W[l] - learning_rate * dW[l] b[l] = b[l] - learning_rate * db[l] 其中,dL / da[L]是损失函数对输出层输出的导数,g'()是激活函数的导数。 2. 反向传播算法示例代码: 下面是一个使用反向传播算法进行训练的示例代码: ```python # 假设网络有三个隐藏层 hidden_layers = [10, 20, 30] output_size = 2 # 初始化参数 parameters = {} layers_dims = [input_size] + hidden_layers + [output_size] L = len(layers_dims) - 1 for l in range(1, L + 1): parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * 0.01 parameters['b' + str(l)] = np.zeros((layers_dims[l], 1)) # 前向传播 def forward_propagation(X, parameters): caches = [] A = X for l in range(1, L): Z = np.dot(parameters['W' + str(l)], A) + parameters['b' + str(l)] A = sigmoid(Z) cache = (Z, A) caches.append(cache) Z = np.dot(parameters['W' + str(L)], A) + parameters['b' + str(L)] AL = softmax(Z) cache = (Z, AL) caches.append(cache) return AL, caches # 反向传播 def backward_propagation(AL, Y, caches): grads = {} dZ = AL - Y m = AL.shape[1] grads['dW' + str(L)] = 1/m * np.dot(dZ, caches[-1][1].T) grads['db' + str(L)] = 1/m * np.sum(dZ, axis=1, keepdims=True) for l in reversed(range(1, L)): dA_prev = np.dot(parameters['W' + str(l+1)].T, dZ) dZ = dA_prev * sigmoid_derivative(caches[l-1][0]) grads['dW' + str(l)] = 1/m * np.dot(dZ, caches[l-1][1].T) grads['db' + str(l)] = 1/m * np.sum(dZ, axis=1, keepdims=True) return grads # 参数更新 def update_parameters(parameters, grads, learning_rate): for l in range(1, L+1): parameters['W' + str(l)] -= learning_rate * grads['dW' + str(l)] parameters['b' + str(l)] -= learning_rate * grads['db' + str(l)] return parameters # 训练模型 def train_model(X, Y, learning_rate, num_iterations): for i in range(num_iterations): AL, caches = forward_propagation(X, parameters) cost = compute_cost(AL, Y) grads = backward_propagation(AL, Y, caches) parameters = update_parameters(parameters, grads, learning_rate) if i % 100 == 0: print("Cost after iteration {}: {}".format(i, cost)) return parameters # 使用示例 parameters = train_model(X_train, Y_train, learning_rate=0.01, num_iterations=1000) ``` 这是一个简单的反向传播算法示例代码,其中的sigmoid()、softmax()、sigmoid_derivative()和compute_cost()函数需要根据具体情况自行实现。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值