popup窗口访问父窗口的4种方法以及相互传值(

合集下载

wpf 窗体间互相传值的方式

wpf 窗体间互相传值的方式WPF（Windows Presentation Foundation）是Microsoft推出的一种用于创建图形用户界面的框架。

在WPF中，窗体之间传值是一项非常常见的任务，可以通过多种方式来实现。

以下是几种常用的窗体间传值的方式。

1.构造函数传值：在创建新窗体的时候，可以通过构造函数来传递参数。

在要传值的窗体类中定义一个带参数的构造函数，并在打开新窗体的时候传入相应的值。

下面是一个示例：MainWindow.xaml.cs:```csharppublic partial class MainWindow : Window{public MainWindow(){InitializeComponent();}private void btnOpenWindow_Click(object sender, RoutedEventArgs e){//创建新窗体并传递参数ChildWindow childWindow = new ChildWindow("Hello World!");childWindow.ShowDialog();}}```ChildWindow.xaml.cs:```csharppublic partial class ChildWindow : Windowpublic ChildWindow(string value){InitializeComponent();//使用传递的参数label.Text = value;}}```2.属性传值：可以通过公共属性来传递数据。

在打开新窗体之前，设置目标窗体的属性值。

下面是一个示例：MainWindow.xaml.cs:```csharppublic partial class MainWindow : Windowpublic string Value { get; private set; }public MainWindow(){InitializeComponent();}private void btnOpenWindow_Click(object sender, RoutedEventArgs e){//设置目标窗体的属性值Value = "Hello World!";ChildWindow childWindow = new ChildWindow();childWindow.ShowDialog();}```ChildWindow.xaml.cs:```csharppublic partial class ChildWindow : Window{public ChildWindow(){InitializeComponent();//使用传递的参数label.Text =((MainWindow)Application.Current.MainWindow).Value;}}3.静态属性传值：使用静态属性来传递数据，可以避免创建新的窗体实例。

wpf 窗体间互相传值的方式

在WPF（Windows Presentation Foundation）中，窗体间互相传值的方式有多种。

以下是一些常用的方法：
1. 通过属性传递：可以通过在两个窗体之间创建公共属性或使用属性绑定，以便从一个窗体将值传递到另一个窗体。

这需要在两个窗体之间共享一个公共属性，并且需要在其中一个窗体中设置该属性的值，然后在另一个窗体中读取该值。

2. 通过事件传递：可以通过在源窗体中触发事件，并在目标窗体中订阅该事件来传递值。

源窗体可以在事件处理程序中设置事件数据，然后目标窗体可以从事件数据中读取该值。

3. 通过命令传递：可以使用命令绑定将一个窗体的命令与另一个窗体的命令关联起来。

源窗体中的命令可以传递值，而目标窗体可以通过命令参数接收该值。

4. 通过共享服务传递：可以在应用程序中创建一个共享服务，该服务可以包含一个属性或方法来存储和检索值。

然后，两个窗体都可以访问该服务以获取或设置值。

5. 通过数据绑定传递：可以使用数据绑定将一个窗体的数据源与另一个窗体的控件关联起来。

源窗体中的数据源可以更新值，而目标窗体中的控件会自动更新以反映该值。

这些方法可以根据具体的应用程序需求和架构选择适合的方法来传递值。

使用jquery的ligerui实现弹出窗（父子页面相互传值）

使⽤jquery的ligerui实现弹出窗（⽗⼦页⾯相互传值）⽗页⾯调⽤⼦页⾯，请求后台后打开⼀个新页⾯作为⼦窗⼝//点击事件选择约束关系弹窗（⽗窗⼝）function constraint(treeId){var url=__ctx +'/code/base/baseConstraintTree/constraintList.ht?treeId='+treeId; //跳转⼊⼀个新的页⾯url=url.getNewUrl();$.ligerDialog.open({height:500,width: 700,title : '选择约束关系',url: url,isResize: true,//⾃定义参数sucCall:function(rtn){alert(rtn); //⼦窗⼝返回的数据$("#myYsgx").val(rtn);}});}⼦窗⼝<%@page language="java" pageEncoding="UTF-8"%><%@include file="/commons/include/html_doctype.html"%><html><head><title></title><%@include file="/commons/include/form.jsp" %><script type="text/javascript" src="${ctx}/js/util/SelectOption.js"></script><script type="text/javascript">var dialog = frameElement.dialog; //调⽤页⾯的dialog对象(ligerui对象)function hqsj(jdmc){$.ligerDialog.success("成功!",'提⽰信息',function(){dialog.close(); //关闭窗⼝dialog.get("sucCall")(jdmc); //向⽗页⾯返回数据});}</script></head>。

wpf page 访问父窗体方法

访问父窗体方法
在 WPF 中，子窗体可以通过调用父窗体的方法来访问父窗体。

以下是三种常见的访问父窗体方法的方式：
1. 使用 Window.Owner 属性
Window.Owner 属性表示当前窗口的拥有者窗口。

通过将此属性设置为父窗体对象，可以在子窗体中使用 Window.Owner 属性来访问父窗体方法。

例如，在父窗体中定义一个方法：
```c#
public void ParentMethod()
{
// 方法实现
}
```
然后在子窗体中通过以下方式调用：
```c#
this.Owner.ParentMethod();
```
2. 使用 Window.RootVisual 属性
Window.RootVisual 属性表示当前窗口的根可视化对象。

通过将此属性设置为父窗体对象，可以在子窗体中使用 Window.RootVisual 属性来访问父窗体方法。

例如，在父窗体中定义一个方法：
```c#
public void ParentMethod()
{
// 方法实现
}
```
然后在子窗体中通过以下方式调用：
```c#
((Window)this.RootVisual).ParentMethod();
```
3. 使用 MessageBox.Show 方法
MessageBox.Show 方法可以显示一个对话框，并在其中显示消息。

通过将消息设置为父窗体的标题，可以在子窗体中使用MessageBox.Show 方法来访问父窗体方法。

wpf 窗体间互相传值的方式

WPF 窗体间互相传值的方式在 WPF (Windows Presentation Foundation) 中，窗体间的数据传递是一个常见的需求。

不同窗体之间的数据传递可以通过多种方式实现，如使用属性、事件、委托、命令等。

本文将介绍几种常用的方式来实现 WPF 窗体间的数据传递。

1. 通过属性传值通过属性传值是最简单的一种方式，可以通过在窗体类中定义公共属性来传递数据。

下面是一个示例：public partial class MainWindow : Window{public string Data { get; set; }public MainWindow(){InitializeComponent();}private void OpenWindowButton_Click(object sender, RoutedEventArgs e){SecondWindow secondWindow = new SecondWindow();secondWindow.Data = Data;secondWindow.ShowDialog();}}在上述示例中，MainWindow类定义了一个名为Data的公共属性，用于传递数据。

当点击OpenWindowButton按钮时，创建一个SecondWindow实例，并将Data属性的值传递给SecondWindow实例。

2. 通过事件传值通过事件传值是另一种常见的方式，可以通过定义事件和事件处理程序来实现窗体间的数据传递。

下面是一个示例：public partial class MainWindow : Window{public event EventHandler<DataEventArgs> DataChanged;private string data;public string Dataget { return data; }set{data = value;OnDataChanged(new DataEventArgs(data));}}protected virtual void OnDataChanged(DataEventArgs e){DataChanged?.Invoke(this, e);}public MainWindow(){InitializeComponent();}private void OpenWindowButton_Click(object sender, RoutedEventArgs e) {SecondWindow secondWindow = new SecondWindow();DataChanged += secondWindow.MainWindow_DataChanged;secondWindow.ShowDialog();}}public class DataEventArgs : EventArgs{public string Data { get; set; }public DataEventArgs(string data){Data = data;}}public partial class SecondWindow : Window{public void MainWindow_DataChanged(object sender, DataEventArgs e){string data = e.Data;// 处理数据}在上述示例中，MainWindow类定义了一个名为DataChanged的事件，当Data属性的值发生变化时，会触发该事件。

jquery父子窗口之间传值的方法

一、简介jQuery是一种流行的JavaScript框架，用于简化在网页中使用JavaScript的任务。

它提供了许多有用的功能和工具，方便开发者在网页中进行元素选择、事件处理、动画效果和AJAX交互等操作。

在web开发中，经常会遇到需要在父子窗口之间进行数值传递的情况，这就需要用到jQuery的一些方法来实现。

二、父子窗口的概念1. 父窗口和子窗口是指在浏览器中打开的不同的网页页面。

2. 父窗口是指打开子窗口的那个页面，而子窗口则是通过父窗口打开的页面。

3. 父子窗口之间的通信是指在这两个窗口之间进行数据的传递和交互。

三、在父窗口中使用jQuery传值给子窗口1. 获取子窗口的DOM对象使用`window.open`打开子窗口后，可以使用`window.opener`来获取父窗口的DOM对象，然后就可以通过jQuery来操作子窗口的元素了。

2. 通过URL参数传递可以通过URL的参数来将值传递给子窗口，例如：```var childWindow =window.open('child.html?id=123name=abc', 'child');```子窗口中可以使用`location.search`来获取这些参数值，然后进行相应的处理。

3. 使用localStorage父窗口可以使用`localStorage`来存储要传递的值，子窗口则可以通过`localStorage`来获取这些值。

例如：```// 在父窗口中localStorage.setItem('data', 'some data');// 在子窗口中var data = localStorage.getItem('data');```四、在子窗口中使用jQuery传值给父窗口1. 使用`window.opener`来获取父窗口的DOM对象，然后就可以通过jQuery来操作父窗口的元素了。

JS弹出窗口的各种传值方法

JS弹出窗口的各种传值方法在JavaScript中，弹出窗口是一种常见的用户交互方式。

通过弹出窗口，可以显示其他页面、表单或者提示框等内容。

而传值则是在弹出窗口中传递数据的一种方式，使得弹出窗口可以获取到主页面中的数据，并在弹出窗口中进行操作。

下面将介绍JS弹出窗口的各种传值方法，包括使用URL参数、使用cookie、使用localStorage、使用sessionStorage和使用postMessage 等。

1.使用URL参数：使用URL参数是一种简单的传值方法，可以通过在URL后面添加参数的形式将数据传递给弹出窗口。

例如：```javascriptvar data = 'Hello World!';window.open(url, 'popup', 'width=500,height=500');```在弹出窗口的页面中，可以通过获取URL参数来获取传递的数据：```javascriptvar urlParams = new URLSearchParams(window.location.search);var data = urlParams.get('data');```2. 使用cookie：使用cookie也是一种传值的常见方式。

通过设置cookie，可以将数据保存在用户的浏览器中，然后在弹出窗口中读取cookie来获取数据。

例如：```javascriptdocument.cookie = "data=Hello World!";window.open('popup.html', 'popup', 'width=500,height=500');```在弹出窗口的页面中，可以通过document.cookie来获取cookie的值：```javascriptvar cookieValue = document.cookie.split('; ').find(row => row.startsWith('data=')).split('=')[1];```3. 使用localStorage：localStorage是一种HTML5提供的本地存储方式，可以将数据保存在用户的浏览器中。

子窗口调用父窗口的方法

子窗口调用父窗口的方法我们需要了解什么是子窗口和父窗口。

在计算机科学领域，窗口是指操作系统中的一个矩形区域，可以显示程序的部分内容。

在Windows操作系统中，子窗口是指在父窗口内嵌入的另一个窗口，可以通过代码控制。

父窗口则是包含子窗口的窗口。

子窗口调用父窗口的方法是指在子窗口内部使用代码访问父窗口的元素或者方法。

通过这种方法，可以完成一些需要父窗口和子窗口之间交互的操作。

接下来我们将详细介绍如何实现子窗口调用父窗口的方法。

第一种方法是使用API函数。

API函数是Windows操作系统提供的一组函数库，包含了大量的功能，可以通过调用这些函数实现对Windows操作系统的访问和操作。

在子窗口调用父窗口的方法中，可以使用API函数来访问父窗口的句柄（handle）并执行父窗口的操作。

句柄是Windows系统中标识控件或者窗口的唯一标识符。

有了父窗口的句柄，就可以在子窗口内部完成对父窗口的操作。

```HWND hWndParent = GetParent(hWndChild);SendMessage(hWndParent, WM_COMMAND, (WPARAM)IDOK, (LPARAM)hwndChild);```上述代码中，GetParent函数用于获取子窗口的父窗口句柄，SendMessage函数用于向父窗口发送消息。

具体消息的类型、参数等可以根据实际需求进行替换。

第二种方法是使用MFC类框架。

MFC（Microsoft Foundation Classes）是微软公司推出的一套类库，可以帮助开发人员更加容易地开发Windows应用程序。

在MFC框架下，可以通过调用GetParentFrame函数获取父窗口的指针，并执行父窗口上的操作。

框架会自动处理CWnd类和CFrameWnd类之间的交互，让代码更加简洁易懂。

两种方法各有优缺点，选择哪种方法取决于实际需要。

使用API函数需要进行较多的手动操作，但可以在较底层的层次上控制操作；使用MFC类框架则需要掌握一定的MFC类库知识，但可以更加快速地实现功能。

window.showModalDialog刷新父窗口父子窗口之间传值问题

关于子窗体向父窗体传值方法

关于子窗体向父窗体传值方法第一种：Open1. 通过Opener方法调用父窗体方法传值父窗体1<html>2<head>3<meta http-equiv="Content-Type" content="text/html; charset=gb2312">4<title>父窗体</title>5</head>6<body>7<form name="form1" method='get'>8<input type=text name='txtvalue' value=''>9<input type='button'onclick='openWindow()' value="弹出">10</form>11<script type="text/javascript">12 function openWindow() {13window.open(子窗体.html','newWindow','height=300,width=300,scrollbars=auto');14 }15 function setValue(returnValue) {16document.getElementById('txtvalue').value= returnValue;17 }18</script>1920</body>21</html>子窗体1<html>2<head>3<meta http-equiv="Content-Type" content="text/html; charset=gb2312">4<title>子窗口</title>5 <script type="text/javascript">67 function valueExit() {8var returnValue= docment.getElementById('txtValue').value;9 opener.setValue(returnValue);10 window.close();11 }12 </script>13</head>14<body>15<h1 align='center'>子窗口!</h1><hr>16<div align='center'>17<form name="fz" action='#' method='get'>18<input type=text name='txtValue' id='txtValue'>19<input type='button'value='关闭' onclick='valueExit()'/>20</form>21</div>22</body>23</html>2.在子窗体里面用window.opener.document.from方法传值父窗体1<html>2<head>3<meta http-equiv="Content-Type" content="text/html; charset=gb2312">4<title>父窗体</title>5</head>6<body>7<form name="f1" action='#' method='get'>8<input type=text name='ft' value=''>9<input type='button'onclick='openWindow()' value="弹出"/>10</form>11<script type="text/javascript">1220</script>21</select>22</body>23</html>Code1<html>2<head>3<meta http-equiv="Content-Type" content="text/html;charset=gb2312">4<title>子窗口</title>5</head>6<body>7<h1 align='center'> 子窗口!</h1><hr>8<div align='center'>9<form name="fz" action='#' method='get'>10<input type=text name='tt'>11<input type='button'value='关闭' onclick='window.opener.document.f1.ft.value=document.fz.tt.value;self.close();' />12</form>13</div>14</body>15</html>扩展：子窗体关闭要刷新父窗体，在子窗体赋值的第一句加上opener.location= opener.location.href;第二种：ShowModalDialog1.window.returnValue方法传值父窗体1<html>2<head>3<script type="text/javascript">function fnOpen() {4var returnTarget= window.showModalDialog("zichuangti.aspx",'newWindow', 'dialogHeight=500px;dialogWidth=700px;center=yes;resizable= yes;help=no;');5if(returnTarget!= undefined && returnTarget.length > 0) {6document.getElementById("oArgs").value=returnTarget;7 }}8 </script>9</head>10<body>11 <form id="form1" runat="server">12 <div>13传过来的值:<input type="text" id="oArgs" runat ="server"/>14<input id="button" name="button"type="button"value="打开窗口"runat ="server" onclick="fnOpen()"/>15 </div>16 </form>1718</body>19</html>202122<html><head><script type="text/javascript">function exit(){window.returnValue = form1.txtreturn.value; //返回值window.close();}</script></head><body><form id="form1" runat="server"><div>传递过来的值: <input type="text" id="txtreturn" runat ="server"/><input id="button"name="button"type="button" value="关闭窗口" runat ="server" onclick="exit()"/> </div></form></body></html>扩展：子窗体关闭要刷新父窗体，在打开窗体的URL后面加上window.location.reload();本文作者:未知。

uni-popup 子组件调用父组件方法

Calling Parent Component Methods from Child Component in uni-popupEnglish Answer:In the context of uni-popup, a child component can call a method of its parent component by utilizing the event emission mechanism provided by Vue.js. Here's a step-by-step approach to achieve this:Define the Method in the Parent Component:First, ensure that the method you want to call from the child component is defined in the parent component's methods object.javascriptexport default {methods: {parentMethod() {// Code for the parent method}}}Emit an Event from the Child Component:In the child component, you need to emit an event when the desired action occurs. This event will be caught by the parent component.javascriptexport default {methods: {childAction() {// Emit an event with any necessary datathis.$emit('child-event', { /* event data */ });}}}Listen to the Event in the Parent Component:In the parent component's template, listen for the event emitted by the child component and call the desired method when the event is triggered.html<template><div><child-component @child-event="parentMethod"></child-component></div></template>By following these steps, when the childAction method is called in the child component, it will emit the child-event event, which will then be caught by the parent component and triggerthe parentMethod.Chinese Answer:在uni-popup的上下文中，子组件可以通过Vue.js提供的事件发射机制调用其父组件的方法。

子窗口调用父窗口js方法

子窗口调用父窗口js方法子窗口调用父窗口的JS方法可以通过以下几种方式实现：通过window对象、通过window.opener对象、通过postMessage方法。

1. 使用window对象：在子窗口中，可以通过window.parent来引用父窗口的window对象，从而调用其定义的JS方法。

例如，在父窗口中定义了一个名为testFunc的方法，可以在子窗口中通过以下方式调用：window.parent.testFunc();这样就可以在子窗口中调用父窗口的testFunc方法。

2. 使用window.opener对象：在子窗口中，可以通过window.opener来引用父窗口的window对象，从而调用其定义的JS方法。

例如，在父窗口中定义了一个名为testFunc的方法，可以在子窗口中通过以下方式调用：window.opener.testFunc();这样就可以在子窗口中调用父窗口的testFunc方法。

需要注意的是，使用window.opener对象的前提是，打开子窗口时是通过window.open方法或者target属性指定的，而不是通过a标签或者表单的target属性等其他方式打开的新窗口。

否则，会出现“无法获取opener”的错误。

3. 使用postMessage方法：postMessage方法是HTML5中新增的一个用于多窗口间通信的方法，通过它可以实现跨窗口的消息传递。

在父窗口中，需要定义一个消息事件的监听器，用于接收子窗口发来的消息：window.addEventListener('message', function(event) {if (event.origin !== '子窗口的origin') return; 过滤非法来源的消息处理子窗口发来的消息console.log('收到子窗口发来的消息：', event.data);}, false);在子窗口中，可以使用postMessage方法向父窗口发送消息：window.parent.postMessage('Hello, 父窗口!', '父窗口的origin');这样就可以在子窗口中向父窗口发送消息。

js子窗口和父窗口的数据传递和交互的应用

js子窗口和父窗口的数据传递和交互的应用js子窗口和父窗口的数据传递和交互的应用子窗口和父窗口交互的内容，是把子窗口的信息传递给父窗口，并且关闭自己等等，或者是父窗口把自己的信息传递给子窗口等等。

1。

父窗口传递信息给子窗口看代码实例：<script language=javascript>function outPut(){//获取父窗口的文本信息赋值给textvar text = document.abc.text.value;//打开子窗口，并且把操作句柄赋值给win变量，以下所有操作都是针对win对象的var win = window.open(”",”mywin”, “menubar=no,width=400,height=100,resizeable=yes”);//输出基本信息win.document.writeln(”<title>输出结果</title>”);win.document.writeln(”你的信息是：<p>”);//输出从父窗口获取的信息win.document.writeln(text);win.document.close();win.focus();}</script><form name=abc method=post><input type=text name=text size=50>//调用上面的函数<input type=button value=提交onClick=”outPut()”></form>2。

子窗口传递参数给父窗口我们对上面的代码进行改造：<script language=javascript>function outPut(){var text = document.abc.text.value;var win = window.open(”",”mywin”, “menubar=no,width=400,height=100,resizeable=yes”);win.document.writeln(”<title>输出结果</title>”);win.document.writeln(”你的信息是：<p>”);win.document.writeln(text);win.document.writeln(”<input type=text name=child value=子窗口信息>”);//对子窗口本身操作，使用self对象，对父窗口操作使用opener 对象，这是关键//把子窗口中表单的值回传给父窗口，取代父窗口表单以前的值，然后关闭子窗口win.document.writeln(”<input type=button value=关闭自己onClick=window.opener.abc.text.value=self.child.value;self.close() >”);//可以控制关闭父窗口win.document.writeln(”<input type=button value=关闭父窗口onClick= window.opener.opener=null;window.opener.close() >”);//刷新父窗口win.document.writeln(”<input type=button value=刷新父窗口 onClick= window.opener.location.reload() >”);win.document.close();win.focus();}</script><form name=abc method=post><input type=text name=text size=50><input type=button value=提交onClick=”outPut()”></form>3。

子组件调用父组件的方法并传值

子组件调用父组件的方法并传值
当子组件需要调用父组件的方法并传值时，通常可以通过以下几种方式实现：
1. 通过props传递方法，父组件可以将需要调用的方法以props的形式传递给子组件，在子组件中调用该方法并传递需要的数值。

这种方式可以实现父子组件之间的通信，但适用于一些简单的场景。

2. 使用事件总线，可以在Vue.js中使用事件总线来实现子组件调用父组件的方法。

父组件可以在创建事件总线时注册一个事件监听器，子组件可以通过事件总线触发相应的事件，从而调用父组件的方法并传递数值。

3. 通过$emit触发事件，在Vue.js中，子组件可以通过$emit 触发一个自定义事件，父组件可以监听这个事件并在相应的处理函数中调用需要的方法。

同时，子组件可以在$emit时传递需要的数值。

4. 使用Vuex进行状态管理，如果应用中使用了Vuex进行状态
管理，子组件可以通过commit触发mutation来改变state，从而实现调用父组件的方法并传递数值。

总的来说，子组件调用父组件的方法并传值可以通过props、事件总线、$emit触发事件以及Vuex进行状态管理等方式来实现。

在实际应用中，可以根据具体的场景和需求选择合适的方式来进行实现。

详解layui弹窗父子窗口之间传参数的方法

详解layui弹窗⽗⼦窗⼝之间传参数的⽅法本⽂介绍了layui弹窗⽗⼦窗⼝之间传参数的⽅法，分享给⼤家，具体如下：1、⽗页⾯打开⼦页⾯并向⼦页⾯传参数function setChooseValues(ret){var oView = document.getElementById("userName");var oValue = document.getElementById("userIds");var i = 0;if( ret != null){oValue.value="";oView.value="";oView.title="";for( x in ret){i++;oView.title=oView.title + ret[x].name+",";oValue.value=oValue.value+ret[x].id+",";oView.value = oView.value+ret[x].name+"\n";}if(i==0){oView.value="";}}}function OpenFrame( oValue, oView) {var dialogArgumentsA = new Array(oValue.value , spitToString(oView));var url = "${rootPath}/page/system/roleallot/role_allot.jsp";layer.open({type: 2,skin: 'layui-layer-lan',title: '选择⼈员',fix: false,shadeClose: false,maxmin: true,id:'selectUser',move: false,closeBtn:2,//以下代码为打开窗⼝添加按钮/* btn: ['确定', '取消'],btnAlign: 'c',yes: function(index, layero){/* //layer.closeAll();//关闭所有弹出层//var parentWin = layero.find('iframe')[0];var parentWin = layer.getChildFrame('body', index);alert(parentWin);parentWin.contentWindow.doOk();//layer.close(index);//这块是点击确定关闭这个弹出层}, */area: ['750px', '450px'],content: url,success: function(layero, index){var body = layer.getChildFrame('body', index);var iframeWin = window[layero.find('iframe')[0]['name']]; //得到iframe页的窗⼝对象，执⾏iframe页的⽅法：iframeWin.method(); var ids = dialogArgumentsA[0].split(",");var names = dialogArgumentsA[1].split(",");for (var i = 0; i < ids.length; i++ ) {if ('' != ids[i]) {var option = $("<option>").val(ids[i]).text(names[i]);body.find('select').append(option);}}}});}2、⼦页⾯向⽗页⾯传参数并关闭弹窗function newBuildReturnValue(selectName){var ret = new Array();$("#"+selectName+" option").each(function(){//遍历所有optionvar value = $(this).val(); //获取option值var text = $(this).text();if(text!=''){var o = new Element(value, text, 0);ret.push(o);}});return ret;}//点击确定向⼦页⾯传参并关闭窗⼝function doOk(){var ret = newBuildReturnValue("select");parent.setChooseValues(ret);var index = yer.getFrameIndex();yer.close(index);}//点击取消关闭窗⼝function doCancel(){var index = yer.getFrameIndex();yer.close(index);}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

JS 弹出窗口的各种传值方法

父窗口<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML><HEAD><TITLE>New Document </TITLE><META content="EditPlus" name="Generator"><META content="" name="Author"><META content="" name="Keywords"><META content="" name="Description"><script language="javascript"></script></HEAD><BODY><FONT face="宋体"></FONT><br>传递到父窗口的值:<input id="txt9" type="text" value="3333333333333" name="txt9"><br>返回的值:<input id="txt11" type="text" name="txt11"><br>子窗口设置的值:<input id="txt10" type="text" name="txt10"><br><input id="Button1" onclick="openChild()" type="button" value="openChild" name="Button1"></BODY></HTML>子窗口<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML><HEAD><TITLE>New Document </TITLE><META content="EditPlus" name="Generator"><META content="" name="Author"><META content="" name="Keywords"><META content="" name="Description"><meta http-equiv="Expires" content="0"><meta http-equiv="Cache-Control" content="no-cache"><meta http-equiv="Pragma" content="no-cache"></HEAD><BODY><FONT face="宋体"></FONT><br>父窗口传递来的值:<input id="txt0" type="text" name="txt0"><br>输入要设置父窗口的值:<input id="txt1" type="text" name="txt1"><input id="Button1" onclick="setFather()" type="button" value="设置父窗口的值" name="Button1"><br>输入返回的值:<input id="txt2" type="text" name="txt2"><input id="Button2" onclick="retrunValue()" type="button" value="关闭切返回值" name="Button2"><input id="Button3" onclick="relodeValue()" type="button" value="关闭刷新父窗口" name="Button3"><script language="javascript"></script></BODY></HTML>。

子窗口调用父窗口的方法

子窗口调用父窗口的方法在Web开发中，经常会遇到需要在子窗口中调用父窗口的方法的情况。

这种情况通常发生在需要在子窗口中进行某些操作，而这些操作需要在父窗口中进行处理的情况下。

本文将介绍如何在子窗口中调用父窗口的方法。

一、使用window.opener对象在子窗口中，可以使用window.opener对象来访问父窗口的属性和方法。

window.opener是一个指向打开当前窗口的父窗口的引用。

通过window.opener对象，可以访问父窗口中的全局变量和函数。

下面是一个简单的例子，演示如何在子窗口中调用父窗口的方法：父窗口代码：```function showMessage(message) {alert(message);}```子窗口代码：```window.opener.showMessage('Hello, world!');```在子窗口中，通过window.opener.showMessage()调用了父窗口中的showMessage()方法，并传递了一个参数。

二、使用postMessage方法另一种在子窗口中调用父窗口的方法是使用postMessage方法。

postMessage方法是HTML5中引入的一种跨窗口通信的方法，可以在不同的窗口之间传递数据。

下面是一个简单的例子，演示如何在子窗口中调用父窗口的方法：父窗口代码：```window.addEventListener('message', function(event) {if (event.data === 'showMessage') {showMessage('Hello, world!');}});function showMessage(message) {alert(message);}```子窗口代码：```window.parent.postMessage('showMessage', '*');```在子窗口中，通过window.parent.postMessage()方法向父窗口发送了一个消息。

在基于nuxt的移动端页面中引用mintUI的popup组件之父子组件传值

在基于nuxt的移动端页⾯中引⽤mintUI的popup组件之⽗⼦组件传值最近在做移动端的wap页⾯，考虑到要做SEO，所以选定了nuxt+vue+mint ui。

有⼀个需求是这样的，点击头部菜单栏，出现⼀个⽓泡，点击返回⾸页。

由于⼀些页⾯没有统⼀引⽤mint的mt-header组件，所以决定把这个⽓泡（popup）封装为⼀个组件，在需要的地⽅调⽤。

点击header右侧的三个点时，控制popup的显⽰和隐藏，因此涉及到了⽗⼦组件传值。

代码如下：1 <template>2 <div>3 <mt-header :title="title">4 <a @click="$router.go(-1)" slot="left">5 <mt-button icon="back" v-if="headerType == 'back'">返回</mt-button>6 <mt-button @click="handleClose" v-if="headerType == 'close'">关闭</mt-button>7 </a>8 <mt-button icon="more" slot="right" v-if="headerType == 'more'" @click="TogglePopupMore"></mt-button>9 <mt-button slot="right" v-if="headerType == 'mRight'">{{stringRight}}</mt-button>10 <mt-button slot="right" v-if="headerType == 'setting'">11 <div>12 <i class="icon iconfont icon-31shezhi"></i>13 </div>14 </mt-button>15 </mt-header>16 <v-indexPopup v-model="tab"></v-indexPopup>17 </div>18 </template>第8⾏TogglePopupMore这个⽅法会切换popupMoreTrigger的true和false，进⽽控制popup的显⽰和隐藏，第16⾏就是引⼊的⽓泡这个组件。

父子组件之间传值方法汇总

父子组件之间传值方法汇总1. props和$emit：props和$emit是Vue.js中最常用的父子组件通信方式。

props用于父组件向子组件传递数据，$emit用于子组件向父组件传递消息。

先来看一个实际的例子：```html<template><div><p>{{childMessage}}</p></div></template><script>export default},datreturnparentMessage: 'Hello from parent',childMessage: ''};},methods:handleChildClick(message)this.childMessage = message;}}};</script>```2. provide和inject：provide和inject是Vue.js中另一种用于父子组件通信的方式。

它能够实现父组件向子组件传递数据，而不需要显式地声明props。

下面是一个示例：```html<template><div></div></template><script>export default},providreturnparentMessage: 'Hello from parent' };}};</script><template><div><p>{{childMessage}}</p></div></template><script>export defaultinject: ['parentMessage'],datreturnchildMessage: ''};},mountethis.childMessage = this.parentMessage;}};</script>```在这个例子中，父组件通过provide关键字提供parentMessage，子组件通过inject关键字注入parentMessage，并将其赋值给childMessage。