window_windows - CSDN
精华内容
参与话题
  • js的window对象与属性的使用

    千次阅读 2018-12-16 12:02:15
     浏览器对象:window对象。  Window 对象会在 <body> 或 <frameset> 每次出现时被自动创建。 2. window对象 window对象是BOM中所有对象的核心。BOM Browser Object Model 3.window...

    1.BOM的概述
        browser object modal :浏览器对象模型。
        浏览器对象:window对象。
        Window 对象会在 <body> 或 <frameset> 每次出现时被自动创建。

    2. window对象

    window对象是BOM中所有对象的核心。BOM    Browser  Object Model

    3.window对象的属性

    window.open(), (打开窗口)
    window.close(), (关闭一个窗口)
    window.self()(窗口本身)  
    window.focus()(使当前的窗口在所有窗口之前. )
    window.status=”内容” (js中状态栏显示内容:)
    window.navigate(”http://www.google.com”); (js中的窗口重定向:)
    window.print() (js中的打印:)
    window.prompt(”message”,”defaultreply”); (js中的提示输入框:)
    window.scroll(x,y) (js中的窗口滚动条)
    window.scrollby(js中的窗口滚动到位置:)
    window.history.back()返回上一页
    window.history.forward()返回下一页,
    window.history.go(返回第几页,也可以使用访问过的url) 如果是0那么就是刷新
    history.length 
    window.createElement
    

    1.(位置类型-获得浏览器的位置)
    IE:
    window.screenLeft
    可以获得浏览器距屏幕左上角的左边距  
    window.screenTop
    可以获得浏览器距屏幕左上角的上边距

     FF:  
    alert(screenX)  
    alert(screenY)

    //IE
    左边距
    alert(screenLeft)
    上边距
    alert(screenTop)
    
    //FF
    左边距
    alert(screenX)
    上边距
    alert(screenY)

    (获得浏览器的尺寸)

    FF:window.innerWidth  获得窗口的宽度
    window.innerHeight  获得窗口的高度

    //FF:
    alert(window.innerWidth);
    alert(window.innerHeight);
    //IE:
    alert(document.documentElement.clientWidth)
    alert(document.documentElement.clientHeight)
    

    2.窗体控制

    screen对象记录了客户端显示屏的信息

    a.属性

    availHeight   返回显示屏幕的高度 (除 Windows 任务栏之外)。

    availWidth    返回显示屏幕的宽度 (除 Windows 任务栏之外)。

    height       返回显示屏幕的高度。

    width        返回显示屏幕的宽度。

    <script>
      document.write(screen.availHeight)
      document.write("<br/>")
      document.write(screen.height)
       document.write("<hr/>")
      document.write(screen.availWidth)
       document.write("<br/>")
      document.write(screen.width)
    </script>

    b.方法

    对窗体的移动,window.moveBy(x,y)  相对于当前位置沿着X\Y轴移动指定的像素,如负数是反方向。moveTo(x,y)  相对于浏览器的左上角沿着X\Y轴移动到指定的像素,如负数是反方向。

    窗体尺寸的改变,resizeBy(x,y)  相对于当前窗体的大小,调整宽度和高度。resizeTo(x,y)  把窗体调整为指定宽度和高度

    script>
    //窗体控制
    //位置
    moveBy(100,100);
    //moveTo(200,200)
    //尺寸
     window.resizeBy(100,100)
    resizeTo(400,400)
    </script>

    对窗体滚动条的控制,scrollBy(x,y) 相对于当前滚动条的位置移动的像素(前提有滚动条)。scrollTo(x,y) 相对于当前窗口的高度或宽度,移动到指定的像素

    scrollBy(0,100)
    scrollTo(0,200)

    innerHeight: 
    innerWidth:  IE不支持

     </head>
    	<script type="text/javascript">
    	<!--
    		  /*
    			window对象的属性:
    					  1.innerHeight: 返回文档显示区的高度  
    					  2.innerWidth: 返回文档显示区的宽度   IE不支持
    						  通用写法: window.document.body.clientWidth ;
    					  3. outerheight  包括了工具栏,菜单栏等的高度
    					  4. outerwidth   包括滚动条的宽度
    
    		  */
    		function init(){
    			var x = window.document.body.clientWidth ;
    			var y = window.document.body.clientHeight ;
    			alert(x + ":" + y) ;
    		}
    	//-->
    	</script>
     <body onload = "init()">
           <p>你好</p>
     </body>

    3.window.event window事件

    获取事件对象,当没有事件发生的时候为null。

     window.event
     window.onload=function  (e) {
    	 e
    	 var ev=e||window.event;
    }

    a.鼠标事件

    相对于浏览器位置的(左上角为(0,0))
         clientX  当鼠标事件发生的时候,鼠标相对于浏览器X轴的位置
         clientY  当鼠标事件发生的时候,鼠标相对于浏览器Y轴的位置

    相对于屏幕位置的
         screenX   当鼠标事件发生的时候,鼠标相对于屏幕X轴的位置
         screenY

      window.onload=function  (e) {
         window.event
    	 var ev=e||window.event;
    	 var div1=document.getElementById("div1");
         document.onmousemove=function  (e) {
           var ev=e||window.event;
    	   var cx=ev.clientX;
    	   var cy=ev.clientY;
    	   var sx=ev.screenX;
    	   var sy=ev.screenY;
    	   div1.innerHTML="cx:"+cx+"--cy:"+cy+"<br/>sx:"+sx+"--sy:"+sy;
    	 }
    }
    
    <div id="div1" style="width:200px;height:200px;border:1px solid red">

    相对于事件源的位置
    IE:
    offsetX   当鼠标事件发生的时候,鼠标相对于事件源X轴的位置
    offsetY

    FF:
    layerX   当鼠标事件发生的时候,鼠标相对于事件源X轴的位置
    laterY

     window.onload=function  (e) {
         window.event
    	 var ev=e||window.event;
    	 var div1=document.getElementById("div1");
         div1.onclick=function  (e) {
         var ev=e||window.event;
    	 var ox=ev.offsetX ||ev.layerX;
    	 var oy=ev.offsetY ||ev.layerY;
         div1.innerHTML="ox:"+ox+"--oy:"+oy;
         }

    具体使用

    模拟窗口拖拽

    divs=document.createElement("div");	  
     divs.onmousedown=function  (e) {
            var ev=e||window.event;
            var ox=ev.offsetX ||ev.layerX;//第一次点击div不能动,相对于事件源的位置
    	     var oy=ev.offsetY ||ev.layerY;
    		 var ok=true;//标识鼠标放开的时候还移动
    		this.onmousemove=function  (e) {//移动的时候跟随鼠标移动
    		   if(ok){
    		   var ev=e||window.event;
    		   var cx=ev.clientX;
    		   var cy=ev.clientY;
    		   this.style.top=cy-oy+"px";//绝对定位
    		   this.style.left=cx-ox+"px";
    		   }
    		}
    		this.onmouseup=function  () {
             if(ok){
    		   ok=false;
    		 }
    	   }
    	   }
    
    <input type="button" id="but">

    b.键盘事件对象

    keyCode  获得键盘码
    空格:32   回车13  左上右下:37 38 39 40
    altKey   判断alt键是否被按下  按下是true 反之是false   布尔值
    ctrlKey   判断ctrl键
    shiftKey 判断shift键
    type   用来检测事件的类型   主要是用于多个事件通用一个事件处理程序的时候

    document.body.onkeydown=function  (e) {
    	   var ev=e||window.event;
    	   ev.keyCode
    	   ev.altKey
    	   ev.type
    }

    具体使用

    点击提交,内容自动读取

    <Script>
      window.onload=function  () {
        var one=document.getElementById("one");
        var texts=document.myform.texts;
    	var but=document.myform.but;
    	but.onclick=texts.onkeydown=function  (e) {//回车
    	   var ev=e||window.event;
           if(ev.type=="click" ||(ev.type=="keydown" && ev.keyCode==13 && ev.ctrlKey==true)){
    	      var elep=document.createElement("p");
    		  elep.innerHTML=texts.value;
    		  elep.className="pone";
    		  one.appendChild(elep);
    		  texts.value="";
    
    	   }
    	}
    
      }
    </script>
    
    
    <body>
    <div id="one" style="width:400px; background-color:#eeeeee;padding:10px">
      <h3>
         留言记录:
      </h3>
      <hr/>
      <p class="pone">
         你好
      </p>
    </div>
    <form name="myform">
      <textarea name="texts" cols=50 rows=10>
      </textarea>
      <input type="button" value="提交" id="but">
    </form>
    </body>

    4.关系类型

     A.parent返回父窗口
     B.top返回顶层窗口

     C.self===window

     D.stutas  设置窗口状态栏的文本

    <script>
      window.onload=function  () {
         alert(top===parent)
    	window.status="自定义的状态栏文字"
    	alert(frames[0])
      }
    </script>
    
    <frameset rows="20%,*">
       <frame src="top.html" >
       <frameset cols="20%,*" >
       <frame src="left.html" >
       <frame src="right.html" >
       </frameset>
    </frameset>

    self :等同于window对象
    opener:当前打开窗口的父窗口对象,支持opener.opener…的多重继续。
                       2种情况下使用opener:
                       1.使用winodw.open()方法打开的页面
                       2.超链(里面的target属性要设置成_blank)
    open方法,是打开一个页面.

    js中分为两种窗体输出:模态和非模态.window.showmodaldialog(),window.showmodeless()

    js的window.open()方法的使用

    open(string method,string url,boolean asynch,String username,string password)

    指定和服务器端交互的HTTP方法,URL地址,即其他请求信息;
    method:表示http请求方法,一般使用"GET","POST".
    url:表示请求的服务器的地址;
    asynch:表示是否采用异步方法,true为异步,false为同步;
    后边两个可以不指定,username和password分别表示用户名和密码,提供http认证机制需要的用户名和密码。

            		var url = "completeFormone.html?s=" + Math.random()+"&installAcceptId="+rows[0].installAcceptId;
            		window.open(url);

    打开新的窗口,open(url,name,feafurse,replace) 通过脚本打开新的窗口。

    open("test.html","windows","status=0,menubar=0,toolbar=0")
     window.onload=function  () {
        var names=document.getElementById("names");
    	var but=document.getElementById("but");
    	but.onclick=function  () {
    	  open("test.html","windows","status=0,menubar=0,toolbar=0")
    	}
     }

    模态和非模态.window.showmodaldialog(),window.showmodeless()

    showmodaldialog(”url”[,arguments][,features])

    重新打开一个页面

    	<script type="text/javascript">
    	<!--
    		function fun(){
    		
    			window.open("sub.html","","width=200,height=200,status=no,titlebar=no,menubar=no,toolbar=no,resizable=0") ;
    		}
    	//-->
    	</script>
     <body>
    	<input type="button" value="打开sub.html页面" onclick="fun()">
     </body>
    		  function fun(){
    			 self.open("sub.html") ;
    		  }
    
    	</script>
     <body>
          <input type="text" name="" id = "txt"> 
    	  <input type="button" value="打开sub.html页面" onclick="fun()">
    
    	  <a href = "sub.html" target = "_blank">打开sub.html页面</a>
     </body>

    openWindow()参数的传递与关闭刷新

    点击弹出一个新窗口

    	afvButton.click(function(){
    		debugger;
    		var orandid = $($("body input[id='orandid_view_act']"),$("div[id='divMain']",$("body",parent.document)).context.activeElement).val();
    		var volid = _grid.getIds();
    		openWindow(volid+"&volType=1",orandid);
    	})
    
    function openWindow(ids,orandid){
    	var options = {
    		modal : true,
    		title : "站箱调压器AFV检修记录",
    		collapsible : false,
    		minimizable : false,
    		maximizable : false,
    		closable : true,
    		closed : false
    	};
    	var uid = "self_card_";
    	options["id"] = uid;
    	winFormDesigner = UIFactory.getUI(uid);
    	if(!winFormDesigner){
    		winFormDesigner = UIFactory.create(xpad.ui.Window, options);
    	}
    	var root = jQuery("body");
    	var offset = root.offset();
    	var winleft = 0;
    	var wintop = 0;
    	var newSize = {};
    	newSize["left"] = 0;
    	newSize["top"] = 0;
    	newSize["width"] = jQuery("body").width();
    	newSize["height"] = jQuery("body").height();
    	winFormDesigner.window("resize", newSize);
    	setTimeout(function(){
    			winFormDesigner.loadURL(Leopard.getContextPath() + "/platform/views/cusviews/devMatainView/afvVoltage.jsp?ids="+ids+"&orandid="+orandid);
    		
    	}, 0);
    }
    

    设置窗口的滚动条

    为class为list_wrap增加overflow:auto属性,并动态设置高度

    如果内容被修剪,则浏览器会显示滚动条,以便查看其余内容

    <script type="text/javascript">
    $(function(){
    var height = $(window).height();
    $(".list_wrap").css("height",height);	
    })
    </script>
    

    参数的传递

    jsp获取openWindow传递的参数

    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
    <%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
    
    <c:set var="ctx" value="${pageContext.request.contextPath}" />
    <input id="root" type="hidden" value="${ctx }"/>
    <input id="ids" type="hidden" value="<%=request.getParameter("ids") %>"/>
    <input id="volType" type="hidden" value="<%=request.getParameter("volType") %>"/>
    <input id="orandid" type="hidden" value="<%=request.getParameter("orandid") %>"/>

    js获取jsp页面的值

    var root = null;
    var ids = null;
    var xcbh = null;
    
    
    $(document).ready(function() {
    	root = $("#root").val();
    	ids = $("#ids").val();
    	volType = $("#volType").val();
    	orandid = $("#orandid").val();
    	initpage();
    });
    
    function initpage(){
    	var isRead = $("#isRead").val();
    	if(isRead && isRead=="true"){
    		$(".tb_query").show();
    	}else{
    		$(".tb_query").hide();
    	}
    	root = $("#root").val();
    	
    	showTime();
    	
    	if(ids!="null"){
    		readxctyz();
    		readxctyzx();
    	}
    	var timer = "";
    	$("#save").click(function(){
    		xctyz();
    		$(this).attr("disabled", true); 
    		timer = setTimeout(function(){
    			$("#save").attr("disabled", false); 
            },6000);
    
    	})
    	
    	 $("#reset").click(function(){
    		    tjbxxcz();
    		    tyzxccz();
    	})
    }

    后台接收参数

    	@SuppressWarnings("unchecked")
    	@RequestMapping("/Addxctyz")
    	@ResponseBody
    	public Boolean Addxctyz(HttpServletRequest request, HttpServletResponse response,String requestParam){
    		String orandid = request.getParameter("orandid ");
    		String ids = request.getParameter("ids");
    }

    关闭openwindow刷新页面

    在外面div设置刷新按钮

    if($("#reloadGrid").length==0){
    	$("#SY_TYZJKXC-QForm .formBody").append("<button id='reloadGrid' style="dispaly:none">刷新</button>");
    	$("#reloadGrid").hide();
    	$("#reloadGrid").click(function(){
    		_grid.reload();
    	});
    }

    返回刷新外层div

        $.ajax({  
            url:root + "/AddAfv",  
            data:param,  
            type:"post",  
            dataType:"json",  
            success:function(data){  
                alert("保存成功");  
                debugger;
                $($("#reloadVolGrid",$("#layout_RECODR_MAINTAIN_VOLTAGE_listbar",parent.$(".panel window").context))).click();
            },  
            error:function(){  
            	alert("服务器正忙,请稍后重试");  
            }  
        }) 

    窗口全屏大小:

    <script>function fullscreen(){ this.moveto(0,0);this.outerwidth=screen.availwidth;this.outerheight=screen.availheight;}window.maximize=fullscreen;</script> 
    

    close方法

     <body>
    	<script type="text/javascript">
    	<!--
    		window.close() ;
    	//-->
    	</script>
     </body>

    parent:是打开窗口的父窗口对象

    2种情况下使用parent:
                       1.iframe 框架
                       2.frame 框架
    frames[]: 数组类型,代表子窗口的window对象的集合,可以通过frames[索引]拿到子窗口的window对象。
    示例:父子窗口相互传参.

      <title>window对象的parent属性</title>
     </head>
    	<script type="text/javascript">
    	<!--
    		function fun(){
    			//1.拿到文本框中填写的数据
    			   var v = document.getElementById("txt").value ;
    			//2.拿到子窗口对象
    			   var w = window.frames[0];
    			//3.拿到子窗口中的文本框对象
    			   var txt = w.document.getElementById("txt") ;
    			//4.将内容赋值给父窗口中的文本框对象的value属性
    				txt.value = v ;
    		}
    	//-->
    	</script>
     <body>
    	  姓名:<input type="text" name="" id = "txt"><input type="button" value="传递数据到子窗口中" onclick="fun()">
    	  <iframe src = "sub1.html"></iframe>
     </body>

    sub1.html

     </head>
    	<script type="text/javascript">
    	<!--
    		function fun(){
    			//1.拿到文本框中填写的数据
    			   var v = document.getElementById("txt").value ;
    			//2.拿到父窗口对象
    			   var w = window.parent;
    			//3.拿到父窗口中的文本框对象
    			   var txt = w.document.getElementById("txt") ;
    			//4.将内容赋值给父窗口中的文本框对象的value属性
    				txt.value = v ;
    		}
    	//-->
    	</script>
     <body>
          <input type="text" name="" id = "txt"><input type="button" value="传递数据到父窗口中" onclick="fun()">
     </body>

     对话框:
    1)消息框 alert() ;
    2)确认框 confirm() ;
    3)输入框 prompt() ; (了解)

    	<script type="text/javascript">
    	<!--
    		/*
    			三种对话框:1. 消息框:alert() ;
    					    2. 确认框: confirm() :返回Boolean类型的值
    						3. 输入框: prompt(): 返回输入的字符串(了解)
    		*/
    		//window.alert("你好") ;
    
    		/*while(true){
    			if(confirm("你爱我吗?") == false)
    			   continue ;
    			break ;
    		}*/
    
    		var a = prompt("请输入年龄:",12) ;
    		alert(a) ;
    	//-->
    	</script>

    window的模态窗体

     <body>
    	  <script type="text/javascript">
    	  <!--
    		   /*
    			    模态窗体:
    		   */
    
    		 //  window.showModalDialog("你好") ;  
    		  window.showModelessDialog("你好");
    	  //-->
    	  </script>
     </body>

    history对象

    history对象包含浏览器访问过的url,浏览器的历史记录访问

    <Script>
      window.onload=function  () {
         var one=document.getElementById("one");
    	 one.onclick=function  () {
    	    history.forward()
                history.back()
    		history.go(-3)
    		history.go(3)
    	 }
      }
    </script>
    
    <body>
    <p>
       history1.html
    </p>
    <script>
      alert(history.length)
    </script>
    <a href="history2.html">链接到2</a>
    <input type="button" value="前进" id="one">
    
    </body>

    a.  forward()前进  b.  back() 后退  c.  go(n) 正数是前进,负数是后退.

     </head>
    	 <script type="text/javascript">
    	 <!--
    		  /*
    			   history对象存储了访问过的页面。
    		  */
    
    		  function fun(){
    				history.forward();
    		  }
    	 //-->
    	 </script>
     <body>
    	  <a href = "b.html">b.html</a>
    	  <input type="button" value="前进" onclick="fun()">
     </body>

    b.html

     <script type="text/javascript">
    	 <!--
    		  /*
    			   history对象存储了访问过的页面。
    		  */
    
    		  function fun(){
    				history.forward();
    		  }
    
    		  function fun1(){
    			   history.back() ;
    		  }
    
    		  function fun2(){
    			   history.go(2) ;
    		  }
    	 //-->
    	 </script>
     <body>
    	  <a href = "c.html">c.html</a>
    	  <input type="button" value="前进" onclick="fun()">
    	  <input type="button" value="后退" onclick="fun1()">
    	  <input type="button" value="直接去d页面" onclick="fun2()">
     </body>

    c.html

     <script type="text/javascript">
    	 <!--
    		  /*
    			   history对象存储了访问过的页面。
    		  */
    
    		  function fun(){
    				history.forward();
    		  }
    
    		  function fun1(){
    			   history.back() ;
    		  }
    
    		  function fun2(){
    			   history.go(-2) ;
    		  }
    	 //-->
    	 </script>
     <body>
    	  <a href = "d.html">d.html</a>
    	  <input type="button" value="前进" onclick="fun()">
    	  <input type="button" value="后退" onclick="fun1()">
    	  <input type="button" value="直接去a页面" onclick="fun2()">
     </body

    d.html

     <script type="text/javascript">
    	 <!--
    		  /*
    			   history对象存储了访问过的页面。
    		  */
    
    		  function fun1(){
    			   history.back() ;
    		  }
    
    		  function fun2(){
    			   history.go(-3) ;
    		  }
    	 //-->
    	 </script>
     <body>
    	  <input type="button" value="后退" onclick="fun1()">
    	  <input type="button" value="直接去a页面" onclick="fun2()">
     </body>

    location对象

    location对象包含有当前url的相关信息
    1.href 属性: 是指要连接到其他的URL,返回完整的url
                            写法一、window.location.href='demo_window对象的close方法.html' ;
                            写法二、window.location='demo_window对象的close方法.html' ;

    1.reload方法: 刷新
                写法: window.location.reload() ;

    2.search   返回url?后面的查询部分

    3.protocol(http:),

    4.hostname(www.example.com)

    5.port(80)

    6.host(www.example.com:80)

    7.pathname(”/a/a.html”)

    8.hash(”#giantgizmo”,指跳转到相应的锚记)

    方法

    assign()   加载新的文档

    reload(boolean)   重新加载文档, 当参数是true,任何时候都会重新加载,false的时候,只有在文档改变的时候才会加载,否则直接读取内存当中的。

    replace() 用新的文档代替当前的文档  (没有历史记录)

    location.href="location2.html?1234"
    location.assign("location2.html");
    location.reload()
    location.replace("location2.html")
    
    
    window.location.reload()(刷新当前页面.)
    
    window.location.href=”url” (指定当前显示链接的位置)
    
    parent.location.reload()刷新父亲对象(用于框架)
    
    opener.location.reload()刷新父窗口对象(用于单开窗口)
    
    top.location.reload()刷新最顶端对象(用于多开窗口)
    
    
    	<script type="text/javascript">
    	<!--
    		/*1 href属性
    		  2. reload()方法:重新加载本页面
    		*/
    		function fun(){
    			//window.location.href = "b.html" ;
    			window.location = "b.html" ;
    		}
    
    		function fun1(){
    			window.location.reload();
    		}
    	//-->
    	</script>
     <body>
    		<input type="button" value="直接去b.html" onclick="fun()">
    		<input type="button" value="重新加载本页面" onclick="fun1()">
     </body>

    跳转到其他页面

    window.location.href=CONTEXT_PATH + "/subjectClassify/showSubjectClassifyNewsList?act=" + WebConst.EDIT+"&entityId="+subjectClassifyId;

    window.location.href在当前页面重新打开连接

       <div class="tit"><span onclick="ProdataShow.indexSkip('device')">资产信息</span></div>
    
            <div class="wrap_sub" style="height: 50%;">
             <div class="wraper">
                <div class="tit"><span onclick="ProdataShow.indexSkip('rushRepair')">应急抢修</span></div>
                <div class="con" id="demo1"></div>
             </div>
            </div>
    <script type="text/javascript" src="${rc.contextPath}/view/cusviews/js/index.js"></script>

    index.js

    $(function(){
    	ProdataShow.initOther();
    });
    
    /**
     * 首页
     */
    var ProdataShow = {
    		initOther:function(){
    			$(".amap-maptypecontrol").css("top","38px");
    			$(".amap-toolbar").css("top","86px");
    		},
    		
    		/**
    		 * 首页各个功能跳转
    		 * type:device-资产信息、rushRepair-应急抢修、pipeRun-管网运行、produceWork-生产作业
    		 * leakCheck-泄露检测
    		 */
    		indexSkip:function(type){
    			if($.isEmptyStr(type)){
    				layer.alert('地址不存在!', {icon: 0});
    				return;
    			}
    			var url = ""
    			switch(type)
    			{
    			case 'device':
    				url = CONTEXT_PATH + "/cusviews/dev/index";
    				break;
    			case 'rushRepair':
    				url = CONTEXT_PATH + "/cusviews/rush/index";
    				break;
    			case 'pipeRun':
    				url = CONTEXT_PATH + "/cusviews/pipe/index";
    				break;
    			case 'produceWork':
    				url = CONTEXT_PATH + "/cusviews/produce/index";
    				break;
    			case 'leakCheck':
    				url = CONTEXT_PATH + "/cusviews/leak/index";
    				break;
    			default:
    				url = CONTEXT_PATH + "/cusviews/index";
    			}
    			window.location.href = url;
    		}
    
    		
    }

    定时器倒数跳转其他页面

    <script>
    window.onload=function  () {
    setTimeout(function  () {
       location.href="location1.html";
    },3000)
    
    var num=document.getElementById("num")
    var nums=3
    setInterval(function  () {
        nums--
    	num.innerHTML=nums;
    },1000)
    }
    
    </script>
    <center>
    <div id="out">
       <div class="one">
       </div>
       <div class="two">
          3秒钟以后跳转
    	  <p id="num">
    	     3
    	  </p>
       </div>
    </div>
    </center>


     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Windows编程之Window介绍

    2019-03-31 12:17:11
    先来介绍下什么是window(窗口)。 当我们谈到window时,所想到的可能是这样的。 这种窗口称为应用窗口或者主窗口。通常有一个带标题栏的边框,最大化最小化按钮,以及其他UI元素。这个边框称为Window的no...

    最近在学习windows编程,本来想写个总结。可发现仅仅 3 天没碰代码,记忆就淡了。话说这个记忆力可能提前奔三了。所以依旧用复习的老办法,再看一遍官方文档,翻译,并且记录。

    先来介绍下什么是window(窗口)

    当我们谈到window时,所想到的可能是这样的。

    这种窗口称为应用窗口或者主窗口。通常有一个带标题栏的边框,最大化最小化按钮,以及其他UI元素。这个边框称为Window的no-client区域。这是操作系统管理Window的地方。边框里面的区域称为client区域,这是我们的代码所管理的地方。

    Windows编程中新鲜的是,UI controls类似于button,edit box,都被称为window。UI 控件和主窗口的区别是UI控件不能独立存在,他们在主窗口之内,以相对位置的形式存在。例如,拖拽主窗口,使得其变大或变小,UI控件也跟着改变,以使得窗口中的内容布局与未拖拽之前相同。主窗口与其内控件也可以通信交流。例如主窗口接收控件的点击事件。

    当提到Window时,我们需要按照程序编码的逻辑来考虑:

    • 将控件放在合适的位置上
    • 该控件是否可见
    • 知道其如何绘制
    • 响应用户或者是操作系统发出事件

    Parent Window和Owner Window

    UI控件是主窗口的child window,主窗口为UI控件的parent window,父窗口提供坐标系统来安置子窗口,并能让他们显示。

    另一种关系是主窗口和对话框窗口,当主窗口展示一个对话框窗口时,主窗口为Owner Window,对话框窗口为Owned Window,Owned Window总是显示在Owner Window之前。当主窗口最小化后,Owned Window也随之消失,主窗口destroy后,Owned Window也随着主窗口被destroy。

    以上是Owner Window和Owned Window的示例。Dialog box是Owned Window,主窗口是其Owner Window。Dialog 又是其中两个按钮的父窗口。

    Window Handles(起码学了5天了,依旧不知道如何翻译,忧伤~)

    Windows是对象,既有代码又有数据,但他们不是C++类。程序通过使用一个叫handle的来引用window。handle实质上就是一个数字,或者称为编号更准确一点,操作系统用这样的编号来标识一个对象。可以理解为,操作系统中有一个表,其中包含了所有已经创建了的窗口,每个窗口都有一个标识用以操作系统检索他。这个标识就是handle。window handle的数据类型为HWND。

    window handle的值由CreateWindow()和CreateWindowEx()这两个方法返回。

    如果想在一个窗口上执行一个操作,通常需要调用一些函数,而这些函数大多都有一个HWND类型的参数。也就是说,当你想要操作一个窗口时,往往需要向操作函数提供其handle。例如,想要改变窗口在屏幕上的位置,需要调用MoveWindow函数。

    BOOL MoveWindow(HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint);

    第一个参数就是要移动的窗口的handle。其他的参数定义了窗口的新位置,还有是否要重绘窗口。

    需要注意的是,handle不是指针,如果hwnd是一个包含handle的变量,用*hwnd来解除其与handle的关联是错误的。

    屏幕和窗口坐标

    坐标是以与设备无关的像素来测量的。根据任务的不同,你可以测量相对于屏幕的坐标,相对于一个窗口甚至是窗口边框、窗口client区域的坐标。例如,你可以使用屏幕坐标来安置一个窗口在屏幕上的位置,但你需要用client坐标来填充窗口内部。

    在任何情况下,(0,0)都表示区域左上角的位置。

     

    展开全文
  • 一篇文章看明白 Activity 与 Window 与 View 之间的关系

    万次阅读 多人点赞 2019-07-15 12:23:13
    Android - Activity 与 Window 与 View 之间的关系 概述 我们知道 Activity 启动后就可以看到我们写的 Layout 布局界面,Activity 从 setContentView() 到显示中间做了什么呢?下面我们就来分析下这个过程。 如...

    Android - Activity 与 Window 与 View 之间的关系

    相关系列

    概述

    我们知道 Activity 启动后就可以看到我们写的 Layout 布局界面,Activity 从 setContentView() 到显示中间做了什么呢?下面我们就来分析下这个过程。

    如不了解 Activity 的启动过程请参阅:Activity 启动过程

    本文主要对于以下问题进行分析:

    • Window 是什么?
    • Activity 与 PhoneWindow 与 DecorView 之间什么关系?

    onCreate() - Window 创建过程

    这里写图片描述

    在 Activity 创建过程中执行 scheduleLaunchActivity() 之后便调用到了 handleLaunchActivity() 方法。

    ActivityThread.handleLaunchActivity():

    private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        handleConfigurationChanged(null, null);
        //初始化 WindowManagerService,主要是获取到 WindowManagerService 代理对象
        WindowManagerGlobal.initialize();
        //详情见下面分析
        Activity a = performLaunchActivity(r, customIntent);
    
        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            //详见下面分析 [onResume() - Window 显示过程]
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed);
            ...
        }
        ...
    }
    
    ...
    
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
        Activity activity = null;
        //获取 ClassLoader
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        //创建目标 Activity 对象
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        StrictMode.incrementExpectedActivityCount(activity.getClass());
        r.intent.setExtrasClassLoader(cl);
        r.intent.prepareToEnterProcess();
        if (r.state != null) {
            r.state.setClassLoader(cl);
        }
    
        //创建 Application 对象
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        if (activity != null) {
            Context appContext = createBaseContextForActivity(r, activity);
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);
            //详情见下面分析
            activity.attach(appContext, this, getInstrumentation(), r.token,
                    r.ident, app, r.intent, r.activityInfo, title, r.parent,
                    r.embeddedID, r.lastNonConfigurationInstances, config,
                    r.referrer, r.voiceInteractor);
            ...
            //回调 Activity.onCreate()
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            ...
        return activity;
    }
    
    ...
    
    final void attach(Context context, ActivityThread aThread, Instrumentation instr, IBinder token, int ident, Application application, Intent intent, ActivityInfo info, CharSequence title, Activity parent, String id, NonConfigurationInstances lastNonConfigurationInstances, Configuration config, String referrer, IVoiceInteractor voiceInteractor) {
        attachBaseContext(context);
    
        mWindow = new PhoneWindow(this); //创建 PhoneWindow
        mWindow.setCallback(this);
        mWindow.setOnWindowDismissedCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
        ...
        mApplication = application; //所属的 Application
        ...
        //设置并获取 WindowManagerImpl 对象
        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        mWindowManager = mWindow.getWindowManager();
        mCurrentConfig = config;
    }
    

    可看出 Activity 里新建一个 PhoneWindow 对象。在 Android 中,Window 是个抽象的概念, Android 中 Window 的具体实现类是 PhoneWindow,Activity 和 Dialog 中的 Window 对象都是 PhoneWindow。

    同时得到一个 WindowManager 对象,WindowManager 是一个抽象类,这个 WindowManager 的具体实现是在 WindowManagerImpl 中,对比 Context 和 ContextImpl。

    Window.setWindowManager():

    public void setWindowManager(WindowManager wm, IBinder appToken, String appName, boolean hardwareAccelerated) { 
        ...    
        mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
        ...
    }
    

    每个 Activity 会有一个 WindowManager 对象,这个 mWindowManager 就是和 WindowManagerService 进行通信,也是 WindowManagerService 识别 View 具体属于那个 Activity 的关键,创建时传入 IBinder 类型的 mToken。

    mWindow.setWindowManager(..., mToken, ..., ...)
    

    这个 Activity 的 mToken,这个 mToken 是一个 IBinder,WindowManagerService 就是通过这个 IBinder 来管理 Activity 里的 View。

    回调 Activity.onCreate() 后,会执行 setContentView() 方法将我们写的 Layout 布局页面设置给 Activity。

    Activity.setContentView():

    public void setContentView(@LayoutRes int layoutResID) {
        getWindow().setContentView(layoutResID);        
        initWindowDecorActionBar();    
    }
    

    PhoneWindow.setContentView():

    public void setContentView(int layoutResID) {
        ...    
        installDecor(); 
        ... 
    }
    

    PhoneWindow.installDecor():

    private void installDecor() {    
    //根据不同的 Theme,创建不同的 DecorView,DecorView 是一个 FrameLayout 
    }
    

    这时只是创建了 PhoneWindow,和DecorView,但目前二者也没有任何关系,产生关系是在ActivityThread.performResumeActivity 中,再调用 r.activity.performResume(),调用 r.activity.makeVisible,将 DecorView 添加到当前的 Window 上。

    onResume() - Window 显示过程

    Activity 与 PhoneWindow 与 DecorView 关系图:

    这里写图片描述

    ActivityThread.handleResumeActivity():

    final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward, boolean reallyResume) {
        //执行到 onResume()
        ActivityClientRecord r = performResumeActivity(token, clearHide);
    
        if (r != null) {
            final Activity a = r.activity;
            boolean willBeVisible = !a.mStartedActivity;
            ...
            if (r.window == null && !a.mFinished && willBeVisible) {
                r.window = r.activity.getWindow();
                View decor = r.window.getDecorView();
                decor.setVisibility(View.INVISIBLE);
                ViewManager wm = a.getWindowManager();
                WindowManager.LayoutParams l = r.window.getAttributes();
                a.mDecor = decor;
                l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                l.softInputMode |= forwardBit;
                if (a.mVisibleFromClient) {
                    a.mWindowAdded = true;
                    wm.addView(decor, l);
                }
    
            }
            ...
            if (!r.activity.mFinished && willBeVisible
                    && r.activity.mDecor != null && !r.hideForNow) {
                ...
                mNumVisibleActivities++;
                if (r.activity.mVisibleFromClient) {
                    //添加视图,详见下面分析
                    r.activity.makeVisible(); 
                }
            }
    
            //resume 完成
            if (reallyResume) {
                  ActivityManagerNative.getDefault().activityResumed(token);
            }
        } else {
            ...
        }
    }
    
    
    public final ActivityClientRecord performResumeActivity(IBinder token, boolean clearHide) {
        ActivityClientRecord r = mActivities.get(token);
        if (r != null && !r.activity.mFinished) {
            ...
            //回调 onResume()
            r.activity.performResume();
            ...
        }
        return r;
    }
    

    Activity.makeVisible():

    void makeVisible() {
        if (!mWindowAdded) {
            ViewManager wm = getWindowManager();
            //详见下面分析
            wm.addView(mDecor, getWindow().getAttributes());
            mWindowAdded = true;
        }
        mDecor.setVisibility(View.VISIBLE);
    }
    

    WindowManager 的 addView 的具体实现在 WindowManagerImpl 中,而 WindowManagerImpl 的 addView 又会调用 WindowManagerGlobal.addView()。

    WindowManagerGlobal.addView():

    public void addView(View view, ViewGroup.LayoutParams params,Display display, Window parentWindow) {
        ...
        ViewRootImpl root = new ViewRootImpl(view.getContext(), display);        
        view.setLayoutParams(wparams);    
        mViews.add(view);    
        mRoots.add(root);    
        mParams.add(wparams);        
        root.setView(view, wparams, panelParentView);
        ...
    }
    

    这个过程创建一个 ViewRootImpl,并将之前创建的 DecoView 作为参数传入,以后 DecoView 的事件都由 ViewRootImpl 来管理了,比如,DecoView 上添加 View,删除 View。ViewRootImpl 实现了 ViewParent 这个接口,这个接口最常见的一个方法是 requestLayout()。

    ViewRootImpl 是个 ViewParent,在 DecoView 添加的 View 时,就会将 View 中的 ViewParent 设为 DecoView 所在的 ViewRootImpl,View 的 ViewParent 相同时,理解为这些 View 在一个 View 链上。所以每当调用 View 的 requestLayout()时,其实是调用到 ViewRootImpl,ViewRootImpl 会控制整个事件的流程。可以看出一个 ViewRootImpl 对添加到 DecoView 的所有 View 进行事件管理。

    ViewRootImpl:

    public ViewRootImpl(Context context, Display display) {
        mContext = context;
        //获取 IWindowSession 的代理类
        mWindowSession = WindowManagerGlobal.getWindowSession();
        mDisplay = display;
        mThread = Thread.currentThread(); //主线程
        mWindow = new W(this); 
        mChoreographer = Choreographer.getInstance();
        ...
    }
    
    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
      synchronized (this) {
        ...
        //通过 Binder 调用,进入 system 进程的 Session
        res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
              getHostVisibility(), mDisplay.getDisplayId(),
              mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
              mAttachInfo.mOutsets, mInputChannel);
        ...
      }
    }
    

    WindowManagerGlobal:

    public static IWindowSession getWindowSession() {
        synchronized (WindowManagerGlobal.class) {
            if (sWindowSession == null) {
                try {
                    //获取 InputManagerService 的代理类
                    InputMethodManager imm = InputMethodManager.getInstance();
                    //获取 WindowManagerService 的代理类
                    IWindowManager windowManager = getWindowManagerService();
                    //经过 Binder 调用,最终调用 WindowManagerService
                    sWindowSession = windowManager.openSession(
                            new IWindowSessionCallback.Stub() {...},
                            imm.getClient(), imm.getInputContext());
                } catch (RemoteException e) {
                    ...
                }
            }
            return sWindowSession
        }
    }
    

    通过 binder 调用进入 system_server 进程。
    Session:

    final class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {
    
        public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs, int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets, Rect outOutsets, InputChannel outInputChannel) {
            //详情见下面
            return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
                    outContentInsets, outStableInsets, outOutsets, outInputChannel);
        }
    }
    

    WindowManagerService:

    public int addWindow(Session session, IWindow client, int seq, WindowManager.LayoutParams attrs, int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets, Rect outOutsets, InputChannel outInputChannel) {
        ...
        WindowToken token = mTokenMap.get(attrs.token);
        //创建 WindowState
        WindowState win = new WindowState(this, session, client, token,
                    attachedWindow, appOp[0], seq, attrs, viewVisibility, displayContent);
        ...
        //调整 WindowManager 的 LayoutParams 参数
        mPolicy.adjustWindowParamsLw(win.mAttrs);
        res = mPolicy.prepareAddWindowLw(win, attrs);
        addWindowToListInOrderLocked(win, true);
        // 设置 input
        mInputManager.registerInputChannel(win.mInputChannel, win.mInputWindowHandle);
        // 创建 Surface 与 SurfaceFlinger 通信,详见下面[SurfaceFlinger 图形系统]
        win.attach();
        mWindowMap.put(client.asBinder(), win);
        
        if (win.canReceiveKeys()) {
            //当该窗口能接收按键事件,则更新聚焦窗口
            focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
                    false /*updateInputWindows*/);
        }
        assignLayersLocked(displayContent.getWindowList());
        ...
    }
    

    创建 Surface 的过程详见:SurfaceFlinger 图形系统

    Activity 中 Window 创建过程:

    这里写图片描述

    总结

    • Window 是什么?

    Window 是 Android 中窗口的宏观定义,主要是管理 View 的创建,以及与 ViewRootImpl 的交互,将 Activity 与 View 解耦。

    • Activity 与 PhoneWindow 与 DecorView 之间什么关系?

    一个 Activity 对应一个 Window 也就是 PhoneWindow,一个 PhoneWindow 持有一个 DecorView 的实例,DecorView 本身是一个 FrameLayout。

    参考资料

    其他系列

    Gradle 系列

    更多文章:

    这是我博客长期更新的项目,欢迎大家 Star。
    https://github.com/jeanboydev/Android-ReadTheFuckingSourceCode

    我的公众号

    欢迎你「扫一扫」下面的二维码,关注我的公众号,可以接受最新的文章推送,有丰厚的抽奖活动和福利等着你哦!?

    qrcode_android_besos_black_512.png

    如果你有什么疑问或者问题,可以 点击这里 提交 issue,也可以发邮件给我 jeanboy@foxmail.com

    同时欢迎你 Android技术进阶:386463747 来一起交流学习,群里有很多大牛和学习资料,相信一定能帮助到你!

    展开全文
  • console.log(window.location); 地址栏上的#及后面的内容:console.log(window.location); 主机名及端口号:console.log(window.location.host); 主机名:console.log(window.location.hostname); 文件路径:相对...

    BOM:
    Browser Object Model 浏览器对象模型

    window对象是浏览器的顶级对象,是JS访问浏览器窗口的一个接口,它是一个全局对象,定义在全局作用域中的变量/函数都会变成window对象的属性和方法。调用的时候可以忽略window,对话框方法都属于window对象方法,如alert()/prompt()等。

    窗口加载事件

        window.onload=function(){}或window.addEventListener("load",function(){});
    

    window.onload是窗口(页面 )加载事件,当文档内容完全加载完成会触发该事件(包括图像/脚本文件/CSS文件等)就调用的处理函数。

    有了window.onload就可以把JS代码写到页面元素的上方,因为onload是等页面内容全部加载完毕,再去执行处理函数。

    load等页面内容全部加载完毕,包含页面dom元素/图片/flash/css等
    DOMContentLoaded是DOM加载完毕,不包含图片/flash/css等就可以执行,加载速度比load更快一些。

    调整窗口大小事件

    window.onresize=function(){}
    window.addEventListener("resize",function(){});
    

    window.onresize是调整窗口大小加载事件,当触发时就调用的处理函数。
    注意:
    1.只要窗口大小发生像素变化,就会触发这个事件。
    2.经常利用这个事件完成响应式布局。window.innerWidth当前屏幕的宽度

    location对象
    console.log(window.location);

    地址栏上的#及后面的内容:console.log(window.location);
    主机名及端口号:console.log(window.location.host);
    主机名:console.log(window.location.hostname);
    文件路径:相对路径:console.log(window.location.pathname);
    端口号:console.log(window.location.port);
    协议:console.log(window.location.protocol);
    搜索的内容:console.log(window.location.search);

        <script>
            onload=function(){
                document.getElementById("btn").onclick=function () {
                    //设置跳转的页面地址
                    location.href="http://www.jd.com";//属性
                    location.assign("http://www.jd.com");//方法
                    location.reload();//重新加载
                    location.replace("http://www.jd.com");//没有历史记录
                };
            };
        </script>
    

    history对象没啥用

    <input type="button" value="跳过" id="btn1"/>
    <input type="button" value="前进" id="btn2"/>
    <script>
        //跳转的
        my$("btn1").onclick=function(){
            window.location.href="15test.html";
        };
        //前进
        my$("btn2").onclick=function(){
            window.history.forward();
        };
    </script>
    

    navigator对象

    <script>
    console.log(window.navigator.userAgent);
    //通过platform可以判断浏览器所在的系统平台类型
        console.log(window.navigator.platform);
    </script>
    

    定时器
    window.setTimeout(调用函数,[延迟的毫秒数]);
    window在调用的时候可以省略,延时时间单位是毫秒,但是可以省略,如果省略默认是0。
    setTimeout()方法用于设置一个定时器,该定时器在定时器到期后执行调用函数。
    setTimeout(function(){},2000);
    这个调用函数可以直接写函数,或者写函数名或者采取字符串’函数名()'三种形式。第三种不推荐。

    停止定时器
    window.clearTimeout(timeoutID)

    <button>点击停止定时器</button>
    <script>
        var btn=document.querySelector('button');
        var timer=setTimeout(function(){
            console.log('爆炸');
        },5000);
        btn.addEventListener('click',function(){
            clearTimeout(timer);
        })
    </script>
    

    setInterval
    参数1:函数
    参数2:时间——毫秒——1000毫秒——1秒
    执行过程:页面加载完毕后,过了1秒,执行一次函数代码,又过了1秒再次执行函数
    返回值就是定时器的id值

    <input type="button" value="停止" id="btn"/>
    <script>
        var timeID=setInterval(function(){
            alert("hello");//断言
        },1000);
        document.getElementById("btn").onclick=function(){
            //点击按钮,停止定时器
            //参数:要清理的定时的id的值
            window.clearInterval(timeID);
        };
    </script>
    

    setTimeout延时时间到了,就去调用这个回调函数,只调用一次就结束了这个定时器
    setInterval每隔这个延时时间,就去调用这个回调函数,会调用很多次,重复调用这个函数

    开启/停止定时器

            <button class="begin">开启定时器</button>
            <button class="stop">停止定时器</button>
            <script>
                var begin = document.querySelector('.begin');
                var stop = document.querySelector('.stop');
                var timer = null; //全局变量 null是一个空对象
                begin.addEventListener('click', function() {
                    timer =  setInterval(function() {
                        console.log('你好呀');
                    },1000);
                })
                stop.addEventListener('click',function(){
                    clearInterval(timer);
                })
            </script>
    

    发送验证码:
    按钮点击之后,会禁用disabled为true
    同时按钮里面的内容会变化,注意button里面的内容通过innerHTML修改
    里面秒数是有变化的,因此需要用到定时器
    定义一个变量,在定时器里面,不断递减
    如果变量为0说明到了时间,需要停止定时器,并且复原按钮初始状态

        <script>
            var btn = document.querySelector('button');
            var time = 1; //定义剩下的秒数
            btn.addEventListener('click', function() {
                btn.disabled = true;
                var timer = setInterval(function() {
                    if (time == 0) {
                        //清除定时器和复原按钮
                        clearInterval(timer);
                        btn.disabled = false;
                        btn.innerHTML = '发送';
                    } else {
                        btn.innerHTML = '还剩下' + time + '秒';
                        time--;
                    }
                }, 1000);
            })
        </script>
    
    展开全文
  • js的window对象与方法

    千次阅读 2018-09-24 11:21:46
    一、window对象 window对象 是BOM中所有对象的核心。BOM Browser Object Model 二、window属性 1.(位置类型-获得浏览器的位置) alert(screenX) alert(screenY) //IE 左边距 alert(screenLeft) 上边距 ...
  • a in window 与 'a' in window的区别

    千次阅读 2020-04-07 18:55:30
    window.a = 1; a in window; //返回false 'a' in window; //返回true //这个貌似是正常的,和我们理解的一样 var xx = 1; console.log(xx in window); //false console.log('xx' in windo...
  • Eclipse 下载安装 WindowBuilder ,下载失败问题解决

    万次阅读 多人点赞 2019-06-01 17:35:45
    今天下载WindowBuilder一直错误,刚开始以为是版本不兼容,把所有的版本都下载了一边还是有问题。后来换用了国内的源就好了,由此可知下载错误的原因,可能是需要访问外网,有些jar包下载不下来。 如果你所有的版本...
  • 有时候我们需要在桌面上显示一个类似悬浮窗的东西,这种效果就需要用 Window 来实现,Window 是一个抽象类,表示一个窗口,它的具体实现类是 PhoneWindow,实现位于 WindowManagerService 中。相信看到 ...
  • 30多年可以把一个人变成什么样子?微软的比尔盖茨给出了一个最好的答案。 同样的,作为一款历经30多年风雨的操作系统,可以说,Windows发展的30多年,其实就是整个计算机应用,从小众化向大众化消费领域,快速前行的...
  • windows下面的nc命令

    千次阅读 2019-06-14 03:28:28
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 在应用有frameset或者iframe的页面时,parent是父...语法:window.self注:window、self、window.self是等价的。window.top功能:返回顶层窗口,即浏览器窗口。语法:window.top注:如果窗口本身就是顶层窗口,top属
  • WindowBuilder的安装与使用

    万次阅读 多人点赞 2018-03-09 15:23:38
    最近因为学校课程设计的原因,需要大量的使用GUI画界面,但是如果只是单纯的靠写标签的方式,工作量是非常大的... WindowBuilder的安装 1.查看你的Eclipse的版本 在你的eclipse中点击Help-&gt;About Eclipse, ...
  • 由此可知,每一个Activity组件都有一个关联的ContextImpl对象,同时,它还关联有一个Window对象,用来描述一个具体的应用程序窗口。由此又可知,Activity只不过是一个高度抽象的UI组件,它的具体UI实现其实是由其它...
  • window.open和window.location.href的几种用法       转自:http://zhanz.blogbus.com/logs/73885336.html 因为要让window.open不在新窗口打开,所以找了一些资料 windows.open("URL","窗口名称","窗口...
  • window.location.href和window.open的几种用法和区别

    万次阅读 多人点赞 2017-03-02 10:11:15
    一、location.href常见的几种形式二、location.href不同形式之间的区别三、location.href总结四、window.location.href和window.open的区别 使用js的同学一定知道js的location.href的作用是什么,但是在js中...
  • java可视化编程-eclipse安装windowbuilder插件

    万次阅读 多人点赞 2017-02-15 17:53:37
    找了一下发现可以安装windowbuilder来实现java的可视化编程,但是很多资料里的连接都失效了。 刚自己弄完比较熟悉,总结一下希望能帮到。 我是直接在线安装的windowbuilder 一.找到对应版本的windowbuilder 打开这个...
  • javascript中window.open()与window.location.href的区别

    万次阅读 多人点赞 2012-11-16 15:29:12
    window.open("index.aspx",'top'); 只是表示打开这个页面,并不是打开并刷新index.aspx window.location.href="index.aspx"; 表示重新定向到新页面,同时刷新打开的这个页面; eg: 进行中项目;curs
  • window.location.replace和window.location.href区别

    万次阅读 多人点赞 2017-04-30 22:14:21
    1:b->c 是通过window.location.replace("..xx/c") 此时b页面的url会被c页面代替,并且点击后退按钮时会回退到a页面(最开始的页面) 2:b->c是通过window.location.href("..xx/c") 此时b页面的路径会被c页面...
  • 今天,在网上看到很多关于Mac电脑的WindowServer的疑问。 网友小A说:“WindowServer这个进程为什么内存占用这么大?” 网友小B说:“为啥WindowServer这个进程这么吃CPU?这个是啥啊?我没有装Windows” 网友小C说:...
  • 1>window.opener 的用法 在一般的用法中,只是用来解决关闭窗口时不提示弹出窗口, 而对它更深层的了解一般比较少。其 实 window.opener是指调用window.open方法的窗口。  在工作中主要是用来解决部分提交...
1 2 3 4 5 ... 20
收藏数 1,660,799
精华内容 664,319
关键字:

window