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>


     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 由此可知,每一个Activity组件都有一个关联的ContextImpl对象,同时,它还关联有一个Window对象,用来描述一个具体的应用程序窗口。由此又可知,Activity只不过是一个高度抽象的UI组件,它的具体UI实现其实是由其它...

           在前文中,我们分析了Android应用程序窗口的运行上下文环境的创建过程。由此可知,每一个Activity组件都有一个关联的ContextImpl对象,同时,它还关联有一个Window对象,用来描述一个具体的应用程序窗口。由此又可知,Activity只不过是一个高度抽象的UI组件,它的具体UI实现其实是由其它的一系列对象来实现的。在本文中,我们就将详细分析Android应用程序窗口对象的创建过程。

    《Android系统源代码情景分析》一书正在进击的程序员网(http://0xcc0xcd.com)中连载,点击进入!

           从前面Android应用程序窗口(Activity)实现框架简要介绍和学习计划一文可以知道,在PHONE平台上,与Activity组件所关联的窗口对象的实际类型为PhoneWindow,后者是从Window类继承下来的。Activity、Window和PhoneWindow三个类的关系可以参考Android应用程序窗口(Activity)实现框架简要介绍和学习计划一文中的图3和图5。为了方便接下来描述类型为PhoneWindow的应用程序窗口的创建过程,我们将这两个图拿过来,如以下的图1和图2所示:


    图1 Activity和Window的类关系图


    图2 Window和PhoneWindow的类关系图

           上述两个图中所涉及到的类的描述可以参考Android应用程序窗口(Activity)实现框架简要介绍和学习计划一文,本文主要从Android应用程序窗口的创建过程来理解Activity、Window和PhoneWindow三个类的关系。

           从Android应用程序窗口(Activity)的运行上下文环境(Context)的创建过程分析一文又可以知道,与Activity组件所关联的一个PhoneWindow对象是从Activity类的成员函数attach中创建的,如图3所示:


    图3 Android应用程序窗口的创建过程

           这个过程可以分为9个步骤,接下来我们就详细分析每一个步骤。

           Step 1. Activity.attach

    public class Activity extends ContextThemeWrapper  
            implements LayoutInflater.Factory,  
            Window.Callback, KeyEvent.Callback,  
            OnCreateContextMenuListener, ComponentCallbacks {  
        ......   
      
        private Window mWindow;   
        ......  
      
        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,  
                Object lastNonConfigurationInstance,  
                HashMap<String,Object> lastNonConfigurationChildInstances,  
                Configuration config) {  
            ......  
      
            mWindow = PolicyManager.makeNewWindow(this);  
            mWindow.setCallback(this);  
            if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {  
                mWindow.setSoftInputMode(info.softInputMode);  
            }  
            ......  
      
            mWindow.setWindowManager(null, mToken, mComponent.flattenToString());  
            ......  
        
        }  
      
        ......  
    }  

            这个函数定义在文件frameworks/base/core/java/android/app/Activity.java中。

            在前面Android应用程序窗口(Activity)的运行上下文环境(Context)的创建过程分析一文中,我们已经分析过这个函数的实现了,这里我们只关注与应用程序窗口创建相关的代码。

            函数首先调用PolicyManager类的静态成员函数makeNewWindow来创建一个类型为PhoneWindow的应用程序窗口,并且保存在Activity类的成员变量mWindow中。有了这个类型为PhoneWindow的应用程序窗口,函数接下来还会调用它的成员函数setCallback、setSoftInputMode和setWindowManager来设置窗口回调接口、软键盘输入区域的显示模式和本地窗口管理器。

            PhoneWindow类的成员函数setCallback、setSoftInputMode和setWindowManager都是从父类Window继承下来的,因此,接下来我们就继续分析PolicyManager类的静态成员函数makeNewWindow,以及Window类的成员函数setCallback、setSoftInputMode和setWindowManager的实现。

            Step 2. PolicyManager.makeNewWindow

    public final class PolicyManager {
        private static final String POLICY_IMPL_CLASS_NAME =
            "com.android.internal.policy.impl.Policy";
    
        private static final IPolicy sPolicy;
    
        static {
            // Pull in the actual implementation of the policy at run-time
            try {
                Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);
                sPolicy = (IPolicy)policyClass.newInstance();
            } catch (ClassNotFoundException ex) {
                throw new RuntimeException(
                        POLICY_IMPL_CLASS_NAME + " could not be loaded", ex);
            } catch (InstantiationException ex) {
                throw new RuntimeException(
                        POLICY_IMPL_CLASS_NAME + " could not be instantiated", ex);
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(
                        POLICY_IMPL_CLASS_NAME + " could not be instantiated", ex);
            }
        }
    
        ......
    
        // The static methods to spawn new policy-specific objects
        public static Window makeNewWindow(Context context) {
            return sPolicy.makeNewWindow(context);
        }
    
        ......
    }
           这个函数定义在文件frameworks/base/core/java/com/android/internal/policy/PolicyManager.java中。

           PolicyManager是一个窗口管理策略类,它在第一次被使用的时候,就会创建一个Policy类实例,并且保存在静态成员变量sPolicy中,以后PolicyManager类的窗口管理策略就是通过这个Policy类实例来实现的,例如,PolicyManager类的静态成员函数makeNewWindow就是通过调用这个Policy类实例的成员函数makeNewWindow来创建一个具体的应用程序窗口的。

           接下来,我们就继续分析Policy类的成员函数makeNewWindow的实现。

           Step 3. Policy.makeNewWindow

    public class Policy implements IPolicy {
        ......
    
        public PhoneWindow makeNewWindow(Context context) {
            return new PhoneWindow(context);
        }
     
        ......
    }
            这个函数定义在文件frameworks/base/policy/src/com/android/internal/policy/impl/Policy.java中。

            Policy类的成员函数makeNewWindow的实现很简单,它只是创建了一个PhoneWindow对象,然后返回给调用者。

            接下来,我们就继续分析PhoneWindow类的构造函数的实现,以便可以了解一个类型为PhoneWindow的应用程序窗口的创建过程。

            Step 4. new PhoneWindow

    public class PhoneWindow extends Window implements MenuBuilder.Callback {
        ......
    
        // This is the top-level view of the window, containing the window decor.
        private DecorView mDecor;
    
        // This is the view in which the window contents are placed. It is either
        // mDecor itself, or a child of mDecor where the contents go.
        private ViewGroup mContentParent;
        ......
    
        private LayoutInflater mLayoutInflater;
        ......
    
        public PhoneWindow(Context context) {
            super(context);
            mLayoutInflater = LayoutInflater.from(context);
        }
    
        ......
    }
           这个函数定义在文件frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindow.java中。

           PhoneWindow类的构造函数很简单,它首先调用父类Window的构造函数来执行一些初始化操作,接着再调用LayoutInflater的静态成员函数from创建一个LayoutInflater实例,并且保存在成员变量mLayoutInflater中。这样,PhoneWindow类以后就可以通过成员变量mLayoutInflater来创建应用程序窗口的视图,这个视图使用类型为DecorView的成员变量mDecor来描述。PhoneWindow类还有另外一个类型为ViewGroup的成员变量mContentParent,用来描述一个视图容器,这个容器存放的就是成员变量mDecor所描述的视图的内容,不过这个容器也有可能指向的是mDecor本身。在后面的文章中,我们再详细分析类型为PhoneWindow的应用程序窗口的视图的创建过程。

          Window的构造函数定义在文件frameworks/base/core/java/android/view/Window.java中,它的实现很简单,只是初始化了其成员变量mContext,如下所示:

    public abstract class Window {
        ......
    
        private final Context mContext;
        ......
    
        public Window(Context context) {
            mContext = context;
        }
      
        ......
    }
           从前面的调用过程可以知道,参数context描述的是正在启动的Activity组件,将它保存在Window类的成员变量mContext之后,Window类就可以通过它来访问与Activity组件相关的资源了。

           这一步执行完成之后,回到前面的Step 1中,即Activity类的成员函数attach中,接下来就会继续调用前面所创建的PhoneWindow对象从父类Window继承下来的成员函数setCallback来设置窗口回调接口,因此,接下来我们就继续分析Window类的成员函数setCallback的实现。

           Step 5. Window.setCallback

    public abstract class Window {
        ......
    
        private Callback mCallback;
        ......
    
        /**
         * Set the Callback interface for this window, used to intercept key
         * events and other dynamic operations in the window.
         *
         * @param callback The desired Callback interface.
         */
        public void setCallback(Callback callback) {
            mCallback = callback;
        }
      
        ......
    }

            这个函数定义在文件frameworks/base/core/java/android/view/Window.java中。

            正在启动的Activity组件会将它所实现的一个Callback接口设置到与它所关联的一个PhoneWindow对象的父类Window的成员变量mCallback中去,这样当这个PhoneWindow对象接收到系统给它分发的IO输入事件,例如,键盘和触摸屏事件,转发给与它所关联的Activity组件处理,这一点可以参考前面Android应用程序键盘(Keyboard)消息处理机制分析一文。

            这一步执行完成之后,回到前面的Step 1中,即Activity类的成员函数attach中,接下来就会继续调用前面所创建的PhoneWindow对象从父类Window继承下来的成员函数setSoftInputMode来设置应用程序窗口的软键盘输入区域的显示模式,因此,接下来我们就继续分析Window类的成员函数setSoftInputMode的实现。

            Step 6. Window.setSoftInputMode

    public abstract class Window {
        ......
    
        private boolean mHasSoftInputMode = false;
        ......
    
        public void setSoftInputMode(int mode) {
            final WindowManager.LayoutParams attrs = getAttributes();
            if (mode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
                attrs.softInputMode = mode;
                mHasSoftInputMode = true;
            } else {
                mHasSoftInputMode = false;
            }
            if (mCallback != null) {
                mCallback.onWindowAttributesChanged(attrs);
            }
        }
    
        ......
    }

           这个函数定义在文件frameworks/base/core/java/android/view/Window.java中。

           参数mode有SOFT_INPUT_STATE_UNSPECIFIED、SOFT_INPUT_STATE_UNCHANGED、SOFT_INPUT_STATE_HIDDEN、SOFT_INPUT_STATE_ALWAYS_HIDDEN、SOFT_INPUT_STATE_VISIBLE和SOFT_INPUT_STATE_ALWAYS_VISIBLE一共六个取值,用来描述窗口的软键盘输入区域的显示模式,它们的含义如下所示:

          1. SOFT_INPUT_STATE_UNSPECIFIED:没有指定软键盘输入区域的显示状态。

          2. SOFT_INPUT_STATE_UNCHANGED:不要改变软键盘输入区域的显示状态。

          3. SOFT_INPUT_STATE_HIDDEN:在合适的时候隐藏软键盘输入区域,例如,当用户导航到当前窗口时。

          4. SOFT_INPUT_STATE_ALWAYS_HIDDEN:当窗口获得焦点时,总是隐藏软键盘输入区域。

          5. SOFT_INPUT_STATE_VISIBLE:在合适的时候显示软键盘输入区域,例如,当用户导航到当前窗口时。

          6. SOFT_INPUT_STATE_ALWAYS_VISIBLE:当窗口获得焦点时,总是显示软键盘输入区域。

          当参数mode的值不等于SOFT_INPUT_STATE_UNSPECIFIED时,就表示当前窗口被指定软键盘输入区域的显示模式,这时候Window类的成员函数setSoftInputMode就会将成员变量mHasSoftInputMode的值设置为true,并且将这个显示模式保存在用来描述窗口布局属性的一个WindowManager.LayoutParams对象的成员变量softInputMode中,否则的话,就会将成员变量mHasSoftInputMode的值设置为false。

          设置完成窗口的软键盘输入区域的显示模式之后,如果Window类的成员变量mCallback指向了一个窗口回调接口,那么Window类的成员函数setSoftInputMode还会调用它的成员函数onWindowAttributesChanged来通知与窗口所关联的Activity组件,它的窗口布局属性发生了变化。

           这一步执行完成之后,回到前面的Step 1中,即Activity类的成员函数attach中,接下来就会继续调用前面所创建的PhoneWindow对象从父类Window继承下来的成员函数setWindowManager来设置应用程序窗口的本地窗口管理器,因此,接下来我们就继续分析Window类的成员函数setWindowManager的实现。

           Step 7. Window.setWindowManager

    public abstract class Window {
        ......
    
        private WindowManager mWindowManager;
        private IBinder mAppToken;
        private String mAppName;
        ......
    
        public void setWindowManager(WindowManager wm,
                IBinder appToken, String appName) {
            mAppToken = appToken;
            mAppName = appName;
            if (wm == null) {
                wm = WindowManagerImpl.getDefault();
            }
            mWindowManager = new LocalWindowManager(wm);
        }
    
        ......
    }
           这个函数定义在文件frameworks/base/core/java/android/view/Window.java中。

           参数appToken用来描述当前正在处理的窗口是与哪一个Activity组件关联的,它是一个Binder代理对象,引用了在ActivityManagerService这一侧所创建的一个类型为ActivityRecord的Binder本地对象。从前面Android应用程序的Activity启动过程简要介绍和学习计划一系列文章可以知道,每一个启动起来了的Activity组件在ActivityManagerService这一侧,都有一个对应的ActivityRecord对象,用来描述该Activity组件的运行状态。这个Binder代理对象会被保存在Window类的成员变量mAppToken中,这样当前正在处理的窗口就可以知道与它所关联的Activity组件是什么。

           参数appName用来描述当前正在处理的窗口所关联的Activity组件的名称,这个名称会被保存在Window类的成员变量mAppName中。

           参数wm用来描述一个窗口管理器。从前面的调用过程可以知道, 这里传进来的参数wm的值等于null,因此,函数首先会调用WindowManagerImpl类的静态成员函数getDefault来获得一个默认的窗口管理器。有了这个窗口管理器之后,函数接着再使用它来创建一个本地窗口管理器,即一个LocalWindowManager对象,用来维护当前正在处理的应用程序窗口。

           接下来,我们首先分析WindowManagerImpl类的静态成员函数getDefault的实现,接着再分析本地窗口管理器的创建过程,即LocalWindowManager类的构造函数的实现。

           Step 8. WindowManagerImpl.getDefault

    public class WindowManagerImpl implements WindowManager {
        ......
    
        public static WindowManagerImpl getDefault()
        {
            return mWindowManager;
        }
     
        ......
    
        private static WindowManagerImpl mWindowManager = new WindowManagerImpl();
    }
           这个函数定义在文件frameworks/base/core/java/android/view/WindowManagerImpl.java中。

           WindowManagerImpl类的静态成员函数getDefault的实现很简单,它只是将静态成员变量mWindowManager所指向的一个WindowManagerImpl对象返回给调用者,这个WindowManagerImpl对象实现了WindowManager接口,因此,它就可以用来管理应用程序窗口。

          这一步执行完成之后,回到前面的Step 7中,即Window类的成员函数setWindowManager中,接下来就会使用前面所获得一个WindowManagerImpl对象来创建一个本地窗口管理器,即一个LocalWindowManager对象。

          Step 9. new LocalWindowManager

    public abstract class Window {
        ......
    
        private final Context mContext;
        ......
    
        private class LocalWindowManager implements WindowManager {
            LocalWindowManager(WindowManager wm) {
                mWindowManager = wm;
                mDefaultDisplay = mContext.getResources().getDefaultDisplay(
                        mWindowManager.getDefaultDisplay());
            }
    
            ......
    
            private final WindowManager mWindowManager;
    
            private final Display mDefaultDisplay;
        }
    
        ......
    }
           这个函数定义在文件frameworks/base/core/java/android/view/Window.java中。

           LocalWindowManager类的构造函数首先将参数wm所描述的一个WindowManagerImpl对象保存它的成员变量mWindowManager中,这样以后就将窗口管理工作交给它来处理。

           LocalWindowManager类的构造函数接着又通过成员变量mWindowManager所描述的一个WindowManagerImpl对象的成员函数getDefaultDisplay来获得一个Display对象,用来描述系统屏幕属性。

           由于前面所获得的Display对象描述的是全局的屏幕属性,而当前正在处理的窗口可能配置了一些可自定义的屏幕属性,因此,LocalWindowManager类的构造函数需要进一步地调整前面所获得的Display对象所描述的屏幕属性,以便可以适合当前正在处理的窗口使用。LocalWindowManager类的构造函数首先通过外部类Window的成员变量mContext的成员函数getResources来获得一个Resources对象,接着再调用这个Resources对象的成员函数getDefaultDisplay来调整前面所获得的Display对象所描述的屏幕属性。最终调整完成的Display对象就保存在LocalWindowManager类的成员变量mDefaultDisplay中。

           从前面的Step 4可以知道,类Window的成员变量mContext描述的是与当前窗口所关联的一个Activity组件。Activity类的成员函数getResources是从父类ContextWrapper继续下来的,它实现在文件frameworks/base/core/java/android/content/ContextWrapper.java中,如下所示:

    public class ContextWrapper extends Context {
        Context mBase;
        ......
    
        @Override
        public Resources getResources()
        {
            return mBase.getResources();
        }
    
        ......
    }
           从前面Android应用程序窗口(Activity)的运行上下文环境(Context)的创建过程分析一文可以知道,ContextWrapper类的成员变量mBase指向的是一个ContextImpl对象,用来描述一个Activity组件的运行上下文环境。通过调用这个ContextImpl对象的成员函数getResources,就可以获得与一个Resources对象,而通过这个Resources对象,就可以访问一个Activity组件的资源信息,从而可以获得它所配置的屏幕属性。

           至此,我们就分析完成一个Activity组件所关联的应用程序窗口对象的创建过程了。从分析的过程可以知道:

          1. 一个Activity组件所关联的应用程序窗口对象的类型为PhoneWindow。

          2. 这个类型为PhoneWindow的应用程序窗口是通过一个类型为LocalWindowManager的本地窗口管理器来维护的。

          3. 这个类型为LocalWindowManager的本地窗口管理器又是通过一个类型为WindowManagerImpl的窗口管理器来维护应用程序窗口的。

          4. 这个类型为PhoneWindow的应用程序窗口内部有一个类型为DecorView的视图对象,这个视图对象才是真正用来描述一个Activity组件的UI的。

          在接下来的一篇文章中,我们将继续分析应用程序窗口内部的视图对象的创建过程,敬请关注!

    老罗的新浪微博:http://weibo.com/shengyangluo,欢迎关注!

    展开全文
  • js的window对象与方法

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

    一、window对象  

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

    二、window属性    

    1.(位置类型-获得浏览器的位置)    

    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)
    

    三、window方法

    .js中指定当前打开窗口的父窗口:window.opener,支持opener.opener…的多重继续.

    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) 
    window.createElement
    

     

    展开全文
  • 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...

    先看个很经典的例子:

       // 例子如下   
       window.a = 1;
    
        a in window;   //返回false
       'a' in window;  //返回true
    
    
        //这个貌似是正常的,和我们理解的一样
        var xx = 1;
        console.log(xx in window);   //false
        console.log('xx' in window); //true 
    
    
        //但是这个就有点奇怪了,只声明变量,结果两种情况返回的的都是true,
        var x;
        console.log(x in window);    //true
        console.log('x' in window);  //true
        console.log(x); //undefined    我们打印下X 发现X其实就是undefined
        // 所以其实  x in window 等价于  undefined in window 所以为true
    
    

    首先要知道为什么,就必须先了解 in 操作符的用法。

    如果指定的属性在指定的对象或其原型链中,则in 运算符返回true

    prop in object

    1.prop

    一个字符串类型或者 symbol 类型的属性名或者数组索引(非symbol类型将会强制转为字符串)。

    2.objectName

    检查它(或其原型链)是否包含具有指定名称的属性的对象。

    参考   https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/in

    例子:

    // 数组
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
    0 in trees        // 返回true
    3 in trees        // 返回true
    6 in trees        // 返回false
    "bay" in trees    // 返回false (必须使用索引号,而不是数组元素的值)
    
    "length" in trees // 返回true (length是一个数组属性)
    
    Symbol.iterator in trees // 返回true (数组可迭代,只在ES2015+上有效)
    
    
    // 内置对象
    "PI" in Math          // 返回true
    
    // 自定义对象
    var mycar = {make: "Honda", model: "Accord", year: 1998};
    "make" in mycar  // 返回true
    "model" in mycar // 返回true

     in右操作数必须是一个对象值。例如,你可以指定使用String构造函数创建的字符串,但不能指定字符串文字。

    var color1 = new String("green");
    "length" in color1 // 返回true
    var color2 = "coral";
    "length" in color2 // 报错(color2不是对象)

    所以回到这个问题,

    
       window.a = 1;
    
        a in window;   //返回false
       'a' in window;  //返回true
    
        var xx = 1;
        console.log(xx in window);   //false
        console.log('xx' in window); //true 
    
        var x;
        console.log(x in window);    //true
        console.log('x' in window);  //true

    其实就是 a 是个变量,a in window 实际等于 1 in window,所以1 不在对象window或其原型链中,in 运算符返回false

     而'a' in window 我们window.a 定义过了,a已经在window属性中的,所以返回true。

    接着第二个例子 var xx = 1, 其实我们要知道这个js中 var 的全局变量的声明是等价于 windw.xx = 1的, 明白了这个,所以 其实第二个例子和上面一样。

    第三个例子, var x; 其实可以等价于  window.x = undefined ;   所以在undefined in window的时候,我们可以看到window上 确实有undefined属性,所以为true。 而'x' in window 与之前例子同理,window上已有x属性所以为true。

     

     

    打印window,我们确实看到xx, x, a 已经是window的属性,且x值为undefined。另外我们也在window上面找到了自带的undefined属性,可以证明我们的理论是正确的。

    展开全文
  • window对象的子对象

    千次阅读 2019-03-19 22:59:38
    window对象(有属性和方法) 特点: window是浏览器宿主对象,与js无关,支持所有浏览器,表示浏览器窗口 所有js的全局对象、全局函数、全局变量都是window对象的成员 注:以下所有属性都可以不需要window前缀,...
  • 一篇文章看明白 Activity 与 Window 与 View 之间的关系

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

    千次阅读 2019-06-14 03:28:28
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 30多年可以把一个人变成什么样子?微软的比尔盖茨给出了一个最好的答案。 同样的,作为一款历经30多年风雨的操作系统,可以说,Windows发展的30多年,其实就是整个计算机应用,从小众化向大众化消费领域,快速前行的...
  • window.a和var a的区别

    千次阅读 2018-05-10 14:20:49
    首先window是一个全局对象。先看一下结果:相同情况:var a = 1 //function(){console.log(this)}window.a = 2 //function(){console.log(this)}测试结果 constructor和proto和this指向(window)都一样不同情况:...
  • 在应用有frameset或者iframe的页面时,parent是父...语法:window.self注:window、self、window.self是等价的。window.top功能:返回顶层窗口,即浏览器窗口。语法:window.top注:如果窗口本身就是顶层窗口,top属
  • window.location.href刷新页面

    万次阅读 2015-09-09 09:23:46
    window.location.href=window.location.href; 或者 window.location.href="当前URL",例如 window.location.href="http://www.hao123.com/indexnt.html"; PS:如果不考虑window.location.href,可以直接...
  • JS中window.alert()与alert()的区别 alert与window.alert没什么区别,如果有人觉得有区别,那就来解释一下:所有以window.开始的语句,都可以直接把window省略。只是在有些软件中,由于其编译器特性,当你写了window....
  • window.open()参数传递及获取

    万次阅读 多人点赞 2016-10-21 23:27:19
    20161021 1、带参数打开新窗口 ...$window.open("/bdfence/bdfence-division/bdfence.html?vehicleId="+ id );...var afterUrl = window.location.search.substring(1);(问号以后的字符串) var afterE
  • window.scrollTop()设置失效问题

    万次阅读 2018-02-17 09:32:45
    window.scrollTop()设置失效问题body没有添加高度,window.scrollTop()设置失效。
  • window location跳转

    万次阅读 2019-06-20 10:38:56
    "top.location.href"是最外层的页面跳转 ...location是window对象的属性,而所有的网页下的对象都是属于window作用域链中(这是顶级作用域),所以使用时是可以省略window。而top是指向顶级窗口对象,parent...
  • JavaScript使用Window Location进行页面跳转概述​ 在Web开发中,常有页面跳转的需要,跳转页面的方式也有很多种,不过这里仅介绍使用window.location的方法,这种方法既可以用于具有onclick事件的标签,也可以用于...
  • 查了一下stackoverflow 上面的代码好像是错误的 我改成了 window.getHeight= function(){ if(window.innerHeight!= undefined){ return window.innerHeight;
  • 用wireshark进行协议分析时经常会遇到专家系统提示:window is full 和 window is zero的提示,到底它们有什么不同呢?
  • window.screen.availWidth 返回当前屏幕宽度(空白空间) window.screen.availHeight 返回当前屏幕高度(空白空间) window.screen.width 返回当前屏幕宽度(分辨率值) window.screen.height 返回当前屏幕高度...
  • window的onload事件的用法

    万次阅读 2018-09-13 17:15:23
    1.最简单的用法 ...3.window.onload()的加载问题 由于HTML加载时由上往下的,在HTML加载的时候,遇到function关键字,声明一个函数的时候,就会在内存中开辟一个新的空间来对函数进行存储,方便以...
1 2 3 4 5 ... 20
收藏数 1,675,826
精华内容 670,330
关键字:

window