精华内容
下载资源
问答
  • 如果不去遍历世界,我们就不知道什么是我们精神和情感的寄托。但我们一旦遍历了世界,却发现我们再也无法回到那美好的地方去了。当我们开始寻求,我们就已经失去,而我们不开始寻求,我们根本无法知道自己身边的一切...


    如果不去遍历世界,我们就不知道什么是我们精神和情感的寄托。但我们一旦遍历了世界,却发现我们再也无法回到那美好的地方去了。当我们开始寻求,我们就已经失去,而我们不开始寻求,我们根本无法知道自己身边的一切是如此可贵。 —— 圣埃克苏佩里《小王子》


    成都图片




    国庆节的时候,一个在大理认识的杭州姐姐特意来成都看我,

    由于国庆各景点都人满为患,于是带她去逛了逛大街、各种树荫的街道。

    东区音乐公园和山城风串串成了最终的落脚点。


    这件事情让闺蜜知道后,抱怨了老半天。

    “每次都是逛街逛街,你怎么都不带我去东区、不带我去吃串串,哼,点儿都不耿直”

    于是...... 周末闲暇,相约随处逛逛。


    成都东站汇合。

    成都自助游图片

     

    成都图片

     

     

    146路 — 崔家店路下车 — 转乘 20路 — 龙潭立交三环路东站下车— 转乘 14路 — 龙潭水乡


    成都景点图片

     

    成都青年旅行社成都龙潭水乡位于成华区龙潭总部经济城核心区域,占地面积220亩。

    历经4年时间打造的,规模相当于周庄的古镇,建设风格融江南水乡和川西民居为一体。


    成都旅游攻略图片

     

    成都自助游图片

     

     

    生活其实也可以很简单,顺自己的心、随自己的意,开心就笑。

    优雅看世界,从容过生活,不急不躁度人生。


    成都图片


     

    成都景点图片

     

    成都旅游攻略图片

     


    我是没有文字天赋对每张图做定义的,那些过去充其量就是入了我的眼,留下了些印记。

    成都自助游图片

     

    成都图片

     

    成都景点图片

     

    成都旅游攻略图片

     

    略显夸张的 “门泊东吴万里船”

    成都自助游图片



    为了与我相约成都,闺蜜特意做了个发型,但最终以失败告终,为此,她坚决不要正面上镜头。

    成都图片

     

    成都景点图片


     

    有些记忆、有些画面,总会在某个瞬间被重拾。

    成都旅游攻略图片

     

    成都自助游图片

     



    成都图片

     


    小转悠了一下,不知是天气不佳还是怎的,人气不高、人群不多、就连吃的也很少。

    成都景点图片

     


    成都旅游攻略图片



    成都自助游图片

     

    成都图片

     


    生活简单就会迷人,人心简单就会幸福。

    享受眼前,珍惜生活,原来是那样简单。

    成都景点图片

     

    成都旅游攻略图片



    笑,多微笑,心自然开阔。

     成都自助游图片

     

    成都图片

     

    继续行走,沐浴阳光,顺自己的心意过生活,真是而不刻意。

    成都景点图片

     



    年轻时,给自己一个疯狂的过度期,自由狂野的追寻,毫无遗憾度人生。


    趁年轻的时候,折腾吧,瞎起哄、瞎胡闹。

    趁年轻的时候,跳跃吧,即便会有坠落的可能,但依然相信它会让你弹得更高。

    趁年轻的时候,相信吧,信你可以随心所欲,信你可以做自己要做的。

                                                                       —— 小嚴妹儿/文

     

    成都旅游攻略图片

     

    成都自助游图片

     

    成都图片

     

    成都景点图片

     


    人生总有无数的可能,而每一次的转身,不定都是华丽的,但一定要是毫无遗憾。

    2013 行在一条与别人无关的修行中,走在一段特属于自己的风景中,微笑着继续前行。


    成都旅游攻略图片

     



    14路(返回) — 龙潭立交三环路东站 — 转乘 20路 — 十里店(成都理工大学)— 180路— 东郊记忆


    成都自助游图片

     


    成都周边游东郊记忆旅游景区按城市工业用地更新和工业遗存保护相结合的方式,

    在成华区原红光电子管厂旧址上修建而成,

    是工业遗存保护和文化创意产业相结合的新型旅游景区。


    位于成都市成华区建设南支路的“成都东区音乐公园”

    2012年11月1日起正式升级更名为“东郊记忆”。

    成都图片

     

    成都景点图片

     

    成都旅游攻略图片

     

    人生总有那么几次犯二的时候,时而疯癫、时而狂妄自大、时而神经质。

    每次犯傻的瞬间,就像是被定格一样,再度回想起的时候,还是会傻傻乐在其中。

    成都自助游图片

     

    成都图片

     


    成都景点图片

     

    成都旅游攻略图片

     

    成都自助游图片

     


    成都图片

     


    在有阳光、有故事的地方,捕捉精彩、美好的瞬间。

    成都景点图片


    成都旅游攻略图片

     

    成都自助游图片

     

    成都图片

     

    成都景点图片

     

    成都旅游攻略图片

     

    成都自助游图片

     


    成都图片

     


    无线音乐基地

    成都景点图片

     


    180路 — 一环路建设路南 — 步行至电子科大宿舍大楼 — 山城风串串

    成都旅游攻略图片

     



    适时的给自己找些乐趣,生活是不至于颓废如死水。

    人生就就这样,短暂,或许不尽人意,或许不留遗憾。

    心如开阔,每天都是旅行、每天都行在路上。

    —— End 。

     



    来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/17037463/viewspace-775288/,如需转载,请注明出处,否则将追究法律责任。

    转载于:http://blog.itpub.net/17037463/viewspace-775288/

    展开全文
  • “ 别害怕顾虑,想到就做,这世界就是这样,当你把实现梦想的时候梦想就会离你越来越远,当你勇敢地追梦的时候,全世界都会来帮你。”你好,我是梦阳辰!未来我陪你一起成长!01.变量定义:变量是存储信息...

    “ 别害怕顾虑,想到就去做,这世界就是这样,当你把不敢去实现梦想的时候梦想就会离你越来越远,当你勇敢地去追梦的时候,全世界都会来帮你。”你好,我是梦阳辰!未来我陪你一起成长!

    01.变量

    定义:变量是存储信息的“容器”,是内存单元。

    1.格式:var pi;//声明变量var x =5;//赋值

    2.注意:如果重新声明变量,该变量的值不会丢失。var name = "MengYangChen";var name;

    name的值依然是MengYangChen

    3.动态类型

    变量的类型,为赋值语句后面数据的类型。var x;//如果没有赋值默认为undefinedvar x =3;var = "MengYangChen";

    4.变量的作用域:

    再javaScript中,对象和函数同样也是变量。

    4.1局部变量:变量在函数内声明,变量为局部作用域,只能在函数内部访问。function myFunction(){

    var age = 20;}

    注意:如果在函数内没有声明(即没有使用var关键字),改变量为全局变量。

    4.2全局变量

    在函数体外定义,即为全局变量。全局变量具有全局作用域,网页中所有脚本和汉数据可以使用。

    4.3JavaScript 中,变量可以在使用后声明,也就是变量可以先使用再声明。

    原因:变量提升:函数声明和变量声明总是会被解释器悄悄地被"提升"到方法体的最顶部。x = 5; // 变量 x 设置为 5elem = document.getElementById("demo"); // 查找元素elem.innerHTML = x;                     // 在元素中显示 xvar x; // 声明 x

    注意:JavaScript 只有声明的变量会提升,初始化的不会。var x = 5; // 初始化 xelem = document.getElementById("demo"); // 查找元素elem.innerHTML = x + " " + y;           // 显示 x 和 yvar y = 7; // 初始化 y

    结果:x 为:5,y 为:undefined

    y 输出了 undefined,这是因为变量声明 (var y) 提升了,但是初始化(y = 7) 并不会提升,所以 y 变量是一个未定义的变量。

    5.变量的生命周期

    开始:声明时候的初始化。

    结束:

    局部变量在函数执行完毕销毁。

    全局变量在页面关闭后销毁。

    6.JavaScript 严格模式(use strict)

    “use strict” 指令在 JavaScript 1.8.5 (ECMAScript5) 中新增。

    它不是一条语句,但是是一个字面量表达式,在 JavaScript 旧版本中会被忽略。

    “use strict” 指令只允许出现在脚本或函数的开头。

    严格模式下你不能使用未声明的变量。"use strict";x = 3.14;       // 报错 (x 未定义)

    不允许删除变量或对象。"use strict";var x = 3.14;delete x;

    不允许删除函数。"use strict";function x(p1, p2) {};delete x;                // 报错

    不允许变量重名。"use strict";function x(p1, p1) {};   // 报错

    不允许使用8进制,转义字符等。

    为什么使用严格模式?

    消除Javascript语法的一些不合理、不严谨之处,减少一些怪异行为.

    严格模式"体现了Javascript更合理、更安全、更严谨的发展方向,包括IE 10在内的主流浏览器,都已经支持它,许多大项目已经开始全面拥抱它。

    另一方面,同样的代码,在"严格模式"中,可能会有不一样的运行结果;一些在"正常模式"下可以运行的语句,在"严格模式"下将不能运行。02.数据类型

    1.javaScript数据类型分为:

    值类型(基本类型)/原始数据类型:字符串(String)、数字(Number)、布尔(Boolean)、对空(Null)、未定义(Undefined)、Symbol。

    引用数据类型:对象(Object)、数组(Array)、函数(Function)。

    2.String(字符串)

    字符串可以使用单引号或双引号。

    比较字符串是否相等用双等号。

    2.1字符串对象

    第一种:var s=“sag”;(小String,属于String类型)

    第二种:var a2= new String(“ab”);(大String,属于Object类型)

    Sting是一个内置的类,可以直接使用。

    3.Number(数字)

    javaScript只有一种数字类型,可以带小数点,也可以不带。很大的数据可以用科学计数法表示。var x = 33;var x = 33.00;var y = 12e6;var y = 12e-6;

    3.1注意:NaN,表示Not a Number不是一个数字,但是属于Number类型。

    Infinity,表示无穷大。

    0,-1,123,…小数,复数,无穷大都是属于number类型。

    当除数为0时,结果为无穷大。

    isNaN(数据):结果为true表示不是一个数字。

    parseInt()函数:可以将字符串自动转换成数字。保留Int。

    parseFloat()函数:将字符串转换成数字。

    Math.Ceil()函数:向上取整。2.1会变为3。

    4.Boolean数据类型

    布尔(逻辑)只能有两个值:true 或 false。

    注意:当某个地方一定是boolean类型时,会自动转换成boolean类型。例如if后面的括号。

    NaN,0,"",null,undefined会自动转换成false。

    5.Undefined 和 Null

    Undefined 这个值表示变量不含有值。

    可以通过将变量的值设置为 null 来清空变量。

    6.typeof动态的求出变量的数据类型alert(typeof null);//Objectalert(typeof NaN);//numberalert(typeof undefined);//undefined

    7.用”new“声明变量类型var x = new Stirng;var y = new Number;var person = new Object;var flag = new Boolean;

    8.JavaScript 变量均为对象。当您声明一个变量时,就创建了一个新的对象。03.输出语句

    javaScript可以通过不同的方式输出数据:

    1.使用window.alert()弹出警告框,window可以省略。

    2.使用document.write()方法将内容写到HTML文档中。

    3.使用innerHTML写入到HTML元素中。

    4.使用console.log()写入到浏览器控制台,console可以省略。html>

    输出语句

    var x = prompt("请输入一个数据:");

    var y = 3.1;

    alert(x);

    document.write(x+y);

    var temp = document.getElementById("one");

    temp.innerHTML=x+y;

    console.log(x+y);

    输入数据:

    可以用prompt(”请输入你的姓名:“)在页面弹出一个输出框。数据为字符串类型。04.数组

    1.javaScript数组为一个无限大的容器,数组类型可以是不一致。

    2.创建方式:var nums = new Array();news[0] =  11;news[1] = "22";//或者var computerBrand = new ("ASUS","DELL");

    3.数组的遍历

    3.1for循环遍历

    3.2for/in循环遍历html>

    数组的遍历

    var arr = new Array();

    arr[0]="MengYangChen";

    arr[1]="20";

    arr[2]="boy";

    for(var i = 0;i

    document.write(arr[i]+"
    ");

    }

    for(var i in arr){

    document.write(arr[i]+"
    ");

    }

    05.函数

    JavaScript 函数语法

    1.函数就是包裹在花括号中的代码块,前面使用了关键词 function:function functionname(){

    // 执行代码}或者functionname=function{

    //执行代码}

    2.具有参数的函数function myFunction(var1,var2){

    //代码}

    3.具有返回值的参数function myFunction(){

    var x=5;

    return x;}document.getElementById("demo").innerHTML=myFunction();function myFunction(a,b){

    return a*b;}

    document.getElementById("demo").innerHTML=myFunction(4,3);06.对象

    1.avaScript 中的所有事物都是对象:字符串、数值、数组、函数…。

    此外,JavaScript 允许自定义对象。

    对象也是一个变量。对象可以包含多个值。var computer ={brand:"ASUS",color:"silveryWhite",price:"13"};

    2.可以使用字面量来定义和创建 JavaScript 对象:var person ={firstName : "YangChen",lastName :"Meng",age: 20,gender : "men"};

    键值对通常写法为 name : value (键与值以冒号分割)。

    键值对在 JavaScript 对象通常称为 对象属性。

    3.访问对象属性:person.lastName;person["lastName"];

    4.对象方法

    4.1创建对象方法:methodName : function() {

    // 代码 }

    案例:html>

    对象

    var person ={

    firstName :"YangChen",

    lastName :"Meng",

    age: 20,

    gender : "men",

    fullName : function()

    {

    return this.firstName + " " + this.lastName;

    }

    };

    document.getElementById("demo").innerHTML=person.fullName();

    5.访问对象的方法objectName.methodName();

    6.创建JavaScript对象

    新建对象有两种不同的方法:

    6.1使用 Object 定义并创建对象的实例。

    在 JavaScript 中,几乎所有的对象都是 Object 类型的实例,它们都会从 Object.prototype 继承属性和方法。

    Object 构造函数创建一个对象包装器。

    Object 构造函数,会根据给定的参数创建对象,具体有以下情况:

    如果给定值是 null 或 undefined,将会创建并返回一个空对象。

    如果传进去的是一个基本类型的值,则会构造其包装类型的对象。

    如果传进去的是引用类型的值,仍然会返回这个值,经他们复制的变量保有和源对象相同的引用地址。

    当以非构造函数形式被调用时,Object 的行为等同于 new Object()。

    6.2使用函数来定义对象,然后创建新的对象实例。(对象构造器)

    this.firstname=firstname;

    this.lastname=lastname;

    this.age=age;

    this.eyecolor=eyecolor;

    this.changeName=changeName;

    function changeName(name)

    {

    this.lastname=name;

    }}myFather=new person("John","Doe",50,"blue");document.write(myFather.firstname + " is " + myFather.age + " years old.");

    有了对象构造器,就可以创建新的对象:var myFather=new person("John","Doe",50,"blue");var myMother=new person("Sally","Rally",48,"green");07.事件

    1.HTML 事件是发生在 HTML 元素上的事情。

    2.在事件触发时 JavaScript 可以执行一些代码。点这里

    document.getElementById("demo").innerHTML=Date();}

    3.常见的HTML事件

    下面是一些常见的HTML事件的列表:onchangeHTML 元素改变,下拉列表选中改变,或文本框内容改变。

    onclick用户点击 HTML 元素

    onmouseover用户在一个HTML元素上移动鼠标

    onmouseout用户从一个HTML元素上移开鼠标

    onkeydown用户按下键盘按键

    onload浏览器已完成页面的加载

    在js中,doucument.getElementById(‘ 标签的id’);发生一个交互事件时,js和html是分离的,获取标签对象。08.DOM

    1.文档对象模型(Document Object Model,简称DOM),是W3C组织推荐的处理可扩展标记语言(HTML或者XML)的标准编程接口。

    w3C已经定义了一系列的DOM接口,通过这些DOM接口可以改变网页的内容、结构和样式。

    DOM树

    98cb7cf90bc1dd4a17ee964f0e9d6759.gif

    文档:一个页面就是一个文档,DOM中使用document表示。

    元素:页面中的所有标签都是元素,DOM中使用element表示。

    节点︰网页中的所有内容都是节点(标签、属性、文本、注释等),DOM中使用node表示。

    2.获取元素

    2.1根据ID获取

    使用getElementById()方法可以获取带有ID的元素对象,找不到返回null。console.dir()方法:

    打印我们返回元素的对象,更好的查看里面的属性和方法。

    2.2根据标签名获取

    使用getElementsByTagName()方法,可以返回带有指定标签名的对象的集合。

    得到的元素是动态的。

    如果页面中只有一个元素,返回的还是一个伪数组。

    如果没有该元素返回空的伪数组。

    可以指定父元素,获取父元素内部所有指定标签名的子元素。

    注意:父元素必须是单个对象(必须指明是哪一个元素对象),获取的时候不包括父元素自己。即先获取父元素,再根据父元素获取,子元素。

    如:var ol = document.getElementsByTagName("ol");console.log(ol[0].getElementsByTagName("li");

    根据类名获取元素

    document.getElementsByClassName(“box”);

    返回一个伪数组。

    根据指定选择器返回第一个元素对象

    document.querySelector(“选择器”);

    根据指定选择器返回集合

    document.querySelectorAll(“选择器”);var b = document.querySelectorAll(".two");

    b[0].innerHTML="常";

    b[1].innerHTML="有意思!";

    获取body和html标签document.body;document.documentElement;//html

    或则通过添加id,class…。

    事件

    JavaScript使我们有能力创建动态页面,而事件是可以被JavaScript侦测到的行为。

    简单理解︰触发—响应机制。

    网页中的每个元素都可以产生某些可以触发JavaScript的事件,例如,我们可以在用户点击某按钮时产生一个事件,然后去执行某些操作。

    事件有三部分组成:(也称事件三要素)

    事件源ffvar btn = document.getElementById("btn);

    事件类型

    如何触发,什么事件,比如鼠标点击(onclick)还是鼠标经过,还是键盘按下。

    事件处理程序:

    通过函数完成

    执行事件的步骤。

    1.获取事件源。

    2.注册事件(绑定事件)。btn.οnclick=function(){}

    3.添加事件处理程序。

    ecda587df1a7a67b78f9e95612215c18.png

    操作元素

    JavaScript的DOM操作可以改变网页内容、结构和样式,我们可以利用DOM操作元素来改变元素里面的内容、属性等。注意以下都是属性。

    改变元素的内容

    innerTest和innerHTML

    innerTest(非标准)不识别HTML的标签,而innerHTML识别。

    可以获取里面的内容,innerTest会去除空格和换行,而innerHTML保留空格和换行。

    常用元素的属性操作

    先获取标签元素对象,然后通过对象.属性来修改属性。

    分时显示不同图片,显示不同的问候语。

    1.获取当前时间。

    表单元素的属性操作

    利用DOM可以操作如下表单元素的属性:

    type,value,checked,selected,disabled

    点击我

    //1.获取元素

    var btn  = document.querySelector("button");

    var input = document.querySelector("input");

    //注册事件

    btn.onclick = function () {

    input.value = '他点击我了';

    //btn.disabled=true;//禁用按钮

    this.disabled = true;//指向当前对象,事件函数的调用者

    }

    点击按钮密码框切换为文本框,并可以查看密码明文

    1.思路将密码框改为文本框

            

    var eye = document.getElementById('eye');

    var pwd = document.getElementById('pwd');

    //注册事件

    var flag =0;

    eye.onclick = function () {

    if(flag = 0 ){

    pwd.type= "text";

    this.src="#1";

    flag = 1;

    } else {

    pwd.type = 'password';

    this.src="#";

    flag = 0 ;

    }

    }

    样式属性操作

    我们可以通过js修改元素的大小,颜色,位置样式

    1.element.style 行内样式操作

    js修改style样式操作,产生的是行内样式,css权重比较高。html>

    样式属性

    div{

    width: 200px;

    height: 200px;

    background-color: red;

    }

    2.element.className 类名样式操作

    通过写好样式,然后通过获取元素,在响应事件后,将元素的类名赋我们事先绑定好的样式来改变元素的样式。.change{......}var test  = document.querySelector('div');test.onclick = function(){this.className = 'change';}

    如果样式修改较多,可以采用这种方式。

    原先的类名会被覆盖。

    如果想要保留原先的类名,可以采用以下方式:this.className = 'first change';

    6685b5594682a33e344182cbdeee9866.png

    获取自定义属性值

    1.element.属性 获取属性值

    获取内置属性值(元素本身自带的属性)

    2.element.getAttribute('属性‘);

    可以获取自定义属性,程序员自定义的属性

    3.设置属性值element.属性 = '值';element.setAttribute('属性','值');//主要用于自定义属性

    4.移除属性element.removeAttribute('属性');

    H5的自定义属性

    自定义属性的目的:是为了保存并使用数据。有些数据可以保存到页面中而不用保存到数据库中。

    自定义属性获取是通过getAttribute('属性’)获取。

    但是有些自定义属性很容易引起歧义,不容易判断是元素的内置属性还是自定义属性。

    var di = document.querySelector('div');

    如何区分是自定义属性还是内置属性呢?

    H5规定自定义属性data-开头做为属性名并且赋值。

    比如:

    或者使用Js设置

    element.setAttribute(‘data-index’,2);

    H5获取自定义属性的方法1.element.getAttribute('data-indexd data-list-name=andy');2.H5新增element.dataset.index 或者element.dataset['index'] ie11才开始支持。

    dataset是一个集合里面存放了所有以data开头的自定义属性。

    如果自定义属性里面有多个-连接的单词,我们获取的时候才去驼峰命名法

    ```java

    div.getAtrribute("data-list-name");div.dataset.listName;

    节点操作

    为什么学节点操作?

    获取元素通常使用两种方式:

    1.利用DOM提供的方法获取元素

    document.getElementById();

    document.getElementByTagName();

    document.querySelector();

    缺点:逻辑性不强,繁琐。

    2.利用节点的层次关系获取元素(父子兄弟关系)

    逻辑性强,但是兼容性差

    一般节点至少拥有nodeType(节点类型),nodeName(节点名称)和nodeValue(节点值)这三个基本属性。

    元素节点nodeType 为1

    属性节点nodeType为2

    文本节点nodeType 为3(文本节点包含文字、空格、换行等)

    一般获取元素节点。

    3.节点层级

    利用DOM树可以把节点划分为不同的层级关系,常见的是父子兄层级关系。

    父级节点

    得到与元素最近的节点。找不到父节点则返回为null。node.parentNode;

    子节点

    得到所有的子节点,包括元素节点,文本节点,等parentNode.ChildNodes(标准)

    parentNode.ChildNodes返回包含指定节点的子节点的集合,改集合为即时更新的集合。

    如果只想获得里面的元素节点,则需要专门处理,所以我们一般不提倡使用。var ul =document. queryselector ( 'ul');for(var i = 0; i 

    为了解决这个问题还有一种非标准的用法。parentNode.children(非标准)

    parentNode.children是一个只读属性,返回所有的子元素节点。它只返回子元素节点,其余节点不返回(这个是我们重点掌握的)。

    虽然children是一个非标准,但是得到了各个浏览器的支持,因此我们可以放心使用。

    第一个节点和最后一个节点父节点.firstChild

    父节点.lastChild

    第一个子元素和最后一个元素节点父节点.firstElementChild

    父节点.LastElementChild

    4.三种动态创建元素的区别

    4.1document.write()document.write("

    fa
    "):

    会导致页面重绘:document.write是直接将内容写入页面的内容流,但是文档流执行完毕,再使用该语句,则它会导致页面全部重绘。

    4.2 element.innerHTMLelement.innerHTML="dfa";

    4.3 document.createElement();var a = document.createElement();element.appendChild(a);

    innerHTML是将内容写入某个DOM节点,不会导致页面全部重绘.

    innerHTML创建多个元素效率更高(不要拼接字符串,采取数组形式拼接),结构稍微复杂

    .

    createElement(创建多个元素效率稍低一点点,但是结构更清晰09.BOM

    什么是BOM对象?

    Brower Object Model,指的是浏览器对象模型。

    作用:操作浏览器窗口及窗口上的空间,实现用户和页面的动态交互。如返回,前进,刷新,地址栏,关闭窗口,缩放窗口等。

    浏览器对象:指的是浏览器提供的一系列内置对象的统称。

    BOM浏览器对象模型:各内置对象之间按照某种层次组织起来的模型的统称。

    b70a34102fa47b253b7ed4818c3f3651.png

    document(文档对象)﹔也称为DOM对象,是HTML页面当前窗体的内容,同时也是JavaScript重要组成部分之一。

    history(历史对象)﹔主要用于记录浏览器的访问历史记录,也就是浏览网页的前进与后退功能。

    location(地址栏对象)﹔用于获取当前浏览器中URL地址栏内的相关数据。navigator(浏览器对象)﹔用于获取浏览器的相关数据,例如浏览器的名称、版本等,也称为浏览器的嗅探器。

    screen(屏幕对象):可获取与屏幕相关的数据,例如屏幕的分辨率等。

    window对象

    window对象是BOM中所有对象的核心,同时也是BOM中所有对象的父对象。定义在全局作用域中的变量、函数以及JavaScript中的内置函数都可以被window对象调用。

    window对象的属性和方法:

    9c8661df8ed57dd391ed6a2fd76f2079.png

    67020dcae23a8e06dca39997cad0a9d8.png

    98cb7cf90bc1dd4a17ee964f0e9d6759.gif

    9241294e355d80799f4ebbc24f13169b.png

    setTimeout()方法在执行一次后即停止了操作;setlnterval()方法一旦开始执行,在不加干涉的情况下,间歇调用将会一直执行到页面关闭为止。

    若要在定时器启动后,取消该操作,可以将setTimeout()的返回值(定时器ID)传递给clearTimeout()方法;或将setlnterval()的返回值传递给clearIntexal()方法。

    location对象

    location对象提供的用于改变URL地址的方法,所有主流的浏览器都支持。

    98cb7cf90bc1dd4a17ee964f0e9d6759.gif

    利用location.href可以跳转到指定的url地址中。

    history对象

    history对象可对用户在浏览器中访问过的URL历史记录进行操作。

    出于安全方面的考虑,history对象不能直接获取用户浏览过的URL,但可以控制浏览器实现“后退”和“前进”的功能。

    348f28f3c70bcacdc18d10d5f0baeb4a.png

    navigator对象

    navigator对象提供了有关浏览器的信息,主流浏览器中存在的属性和方法如下:

    98cb7cf90bc1dd4a17ee964f0e9d6759.gif

    98cb7cf90bc1dd4a17ee964f0e9d6759.gif

    screen对象

    screen对象用于返回当前渲染窗口中与屏幕相关的属性信息,如屏幕的宽度和高度等。

    16f1a269fe68005cd66d4aaf0716fa66.pngIf your happiness depends on what somebody else does, I guess you do have a problem. 

    如果你的快乐与否取决于别人做了什么,我想,你真的有点问题。

    展开全文
  • 比如说,你下午四点钟来。那么从三点钟起,我就开始感到幸福。时间越临近,我就越感到幸福。到了四点钟的时候,我就会... 如果不去遍历世界,我们就不知道什么是我们的精神和情感的寄托,但我们一旦遍历了世界,却...
    比如说,你下午四点钟来。那么从三点钟起,我就开始感到幸福。时间越临近,我就越感到幸福。到了四点钟的时候,我就会坐立不安:我就会发现幸福的代价。
    本质的东西是用眼睛看不见的,只能用心去看。正是因为你为你的玫瑰费的时光,才使得你的玫瑰变得如此重要。对你驯养过的东西,你永远都有责任。你必须对你的玫瑰负责。
         如果不去遍历世界,我们就不知道什么是我们的精神和情感的寄托,但我们一旦遍历了世界,却发现我们再也无法回到那美好的地方去了。当我们开始寻求,我们就已经失去,而我们不开始寻求,我们却根本无法知道自己身边的一切是如此可贵。

     

     
     
     
     



     

     

    转载于:https://www.cnblogs.com/one99/p/9612906.html

    展开全文
  • 走遍天下,世界那么大,我想看看 在计算机中,Iterator意为迭代器,迭代有重复的含义,在程序中,更有“遍历”的含义 如果给定一个数组,我们可以通过for循环来遍历这个数组,这种遍历就叫做迭代 对于数组...
        
    迭代器模式(Iterator)
    image_5c11cddc_d4
     
    走遍天下,世界那么大,我想去看看
     
    image_5c11cddc_5f0c
    在计算机中,Iterator意为迭代器,迭代有重复的含义,在程序中,更有“遍历”的含义
    如果给定一个数组,我们可以通过for循环来遍历这个数组,这种遍历就叫做迭代
    对于数组这种数据结构,我们称为是可迭代的
    所以
    迭代器就是可以用来对于一个数据集合进行遍历的对象

    意图

    提供一种方法,顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示。
    别名:游标 Cursor

    集合与遍历

    由一个或多个确定的元素所构成的整体叫做集合
    多个对象聚集在一起形成的总体称之为聚集aggregate。
    集合和聚集有相似的含义。
    容器是指盛物品的器具,Java的Collection框架,就是设计用来保存对象的容器
    容器可以认为是集合、聚集的具体体现形式,三个元素在一起叫做集合(聚集),怎么在一起?数组,列表?这具体的体现形式就是容器
     
    容器必须提供内部对象的访问方式,如果不能获取对象,容器也失去了存在的意义,一个只能进不能出的储蓄罐你要它何用?
    因为容器的存在就是为了更方便的使用、管理对象。
    而且通常需要容器提供对于内部所有元素的遍历方法
     
    然而容器其内部有不同的摆放形式,可顺序,可无序堆集
    简言之,就是不同类型的容器必然有不同的内部数据结构
    那么,一种解决办法就是不同的容器各自提供自己的遍历方法
    这样的话,对于使用容器管理对象的客户端程序来说:
    如果迭代的逻辑,也就是业务逻辑没有变化
    当需要更换为另外的集合时,就需要同时更换这个迭代方法
    考虑这样一个场景
    有一个方法,
    方法的参数类型为 Collection
    他的迭代逻辑,也就是业务逻辑为遍历所有元素,读取每个元素的信息,并且进行打印...
    如果不同的容器有不同的遍历方法,也就是一种实现类有一种不同的遍历方法
    一旦更换实现类,那么就需要同步更换掉这个迭代方法,否则方法将无法通过编译
     
    如果集合的实现不变,需要改变业务逻辑,也就是迭代的逻辑
    那么就需要修改容器类的迭代方法,也就是修改原来的遍历方法
     
    还是上面的场景
    有一个方法,方法的参数类型为 Collection
    他的迭代逻辑,也就是业务逻辑为遍历所有元素,读取每个元素的信息,并且进行打印...
    现在他的实现类无需变化
    但是业务逻辑需要变动,比如希望从后往前的方式进行遍历,而不再是从前往后
    就需要修改原来的方法或者重新写一个方法
     
     
    出现上述问题的根本原因就在于元素的迭代逻辑与容器本身耦合在一起
    当迭代逻辑或者集合实现发生变更时,需要进行修改,不符合开闭原则
    容器自身不仅仅需要存储管理对象,还要负责对象的遍历访问,不符合单一职责原则
     
    存储管理对象是容器的核心职责,虽然经常需要提供遍历方法,但是他并不是核心职责
    但是为了提供遍历元素的方法,可能不得不在容器类内提供各种全局变量,比如保存当前的位置等,这无疑也会导致容器聚集类设计的复杂度

    结构

    image_5c11cddc_779f
    抽象迭代器角色Iterator
    定义遍历元素所需要的接口
    具体的迭代器ConcreteIterator
    实现了Iterator接口,并且跟踪当前位置
    抽象集合容器角色Aggregate
    定义创建相应迭代器的接口(方法)
    就是一个容器类,并且定义了一个返回迭代器的方法
    具体的容器角色ConcreteAggregate
    Aggregate的子类,并且实现了创建Iterator对象的接口,也就是返回一个ConcreteIterator实例
    客户端角色Client
    持有容器对象以及迭代器对象的引用,调用迭代对象的迭代方法遍历元素
     
    迭代器模式中,通过一个外部的迭代器来对容器集合对象进行遍历。
    迭代器定义了遍历访问元素的协议方式。
    容器集合对象提供创建迭代器的方法。

    示例代码

    Aggregate角色
    提供了iterator()获取Iterator
    package iterator;
    public abstract class Aggregate {
    abstract Iterator iterator();
    abstract Object get(int index);
    abstract int size();
    }
    ConcreateAggregate角色
    内部使用一个Object数组,数组直接通过构造方法传递进去(只是为了演示学习模式,不要纠结这算不上一个容器)
    提供了大小的获取方法以及获取指定下标元素的方法
    尤其是实现了iterator()方法,创建一个ConcreteIterator实例,将当前ConcreteAggregate作为参数传递给他的构造方法
    package iterator;
    public class ConcreateAggregate extends Aggregate {
     
    private Object[] objects;
     
    ConcreateAggregate(Object[] objects) {
    this.objects = objects;
    }
     
    @Override
    Iterator iterator() {
    return new ConcreateIterator(this);
    }
     
    @Override
    Object get(int index) {
    return objects[index];
    }
     
    @Override
    int size() {
    return objects.length;
    }
    }
     
    迭代器接口
    一个是否还有元素的方法,一个获取下一个元素的方法
    package iterator;
    public interface Iterator {
    boolean hasNext();
    Object next();
    }
    具体的迭代器
    内部维护了数据的大小和当前位置
    如果下标未到最后,那么就是还有元素
    next()方法用于获取当前元素,获取后当前位置往后移动一下
    package iterator;
    public class ConcreateIterator implements Iterator {
    private Aggregate aggregate;
    private int index = 0;
    private int size = 0;
     
    ConcreateIterator(Aggregate aggregate) {
    this.aggregate = aggregate;
    size = aggregate.size();
    }
     
    @Override
    public boolean hasNext() {
    return index < size ? true : false;
    }
     
    @Override
    public Object next() {
    Object value = aggregate.get(index);
    index++;
    return value;
    }
    }
    测试类
    package iterator;
    public class Client {
    public static void main(String[] args) {
    Object[] objects = {"1", 2, 3, 4, 5};
    Aggregate aggregate = new ConcreateAggregate(objects);
    Iterator iterator = aggregate.iterator();
    while (iterator.hasNext()) {
    System.out.println(iterator.next());
    }
    }
    }
    image_5c11cddc_5524
    示例代码中ConcreateAggregate本身提供了获取指定下标元素的方法,可以直接调用获取元素
    借助于Iterator,将迭代逻辑从Aggregate中剥离出来,独立封装实现
    在客户端与容器之间,增加了一层Iterator,实现了客户端程序与容器的解耦
    image_5c11cddc_440b
    说白了,增加了Iterator,相当于通过Iterator封装了真实容器对象的获取元素的方法
    不直接调用方法,经过Iterator转换一层
     
    而且仔细品味下,这有点“适配”的韵味,适配的目标就是统一的元素访问协议,通过Iterator约定
    而被适配的角色,则是真实容器对象元素的操作方法
    总之“间接”“委托”“代理”的感觉,对吧,好处自己品味

    外部迭代与内部迭代

    在上面的示例程序中,通过引入Iterator,实现了迭代逻辑的封装抽象 
    但是容器聚集对象本身有获取元素的方法,所以客户端仍旧可以自行遍历
    Iterator也只不过是容器聚集对象的一个客户而已
    这种迭代器也叫做外部迭代器
    对于外部迭代器有一个问题,对于不同的ConcreteAggregate,可能都需要一个不同的ConcreteIterator
    也就是很可能会不得不创建了一个与Aggregate等级结构平行的Iterator结构,出现了很多的ConcreteIterator类
    这势必会增加维护成本
    而且,虽然迭代器将客户端的访问与容器进行解耦,但是迭代器却是必须依赖容器对象
    也就是迭代器类ConcreteIterator与ConcreteAggregate必须进行通信,会增加设计的复杂度,而且这也会增加类之间的耦合性
     
    另外的一种方法是使用内部类的形式,也就是将ConcreteIterator的实现,移入到ConcreteAggregate的内部
    借助于内部类的优势:对外部类有充足的访问权限,也就是无需担心为了通信要增加复杂度的问题
    准确的说,你没有任何的通信成本,内部类可以直接读取外部类的属性数据信息
    而且,使用内部类的方式不会导致类的爆炸(尽管仍旧是会有另一个class文件,但是从代码维护的角度看算是一个类)
    这种形式可以叫做内部迭代器
     
    不过无论哪种方式,你可以看得出来,使用迭代器的客户端代码,都是一样的
    借助于工厂方法iterator()获得一个迭代器实例(简单工厂模式)
    然后借助于迭代器进行元素遍历

    JDK中的迭代

    我们看下JDK中的Collection提供给我们的迭代方式
    Collection是所有集合的父类,Collection实现了Iterable接口
    Iterable接口提供了iterator()方法用于返回一个Iterator类的一个实例对象
    Iterator类提供了对元素的遍历方法
    image_5c11cddc_295f
    接下来看下ArrayList的实现
    ArrayList中iterator()返回了一个Itr对象,而这个对象是ArrayList的内部类,实现了Iterator接口
    image_5c11cddc_26d
    看得出来,java给集合框架内置了迭代器模式
    在ArrayList中使用就是内部类的形式,也就是内部迭代器
    boolean hasNext()
    是否拥有更多元素,换句话说,如果next()方法不会抛出异常,就会返回true
    next();
    返回下一个元素
    remove()
    删除元素
     
    有几点需要注意
    1.)初始时,可以认为“当前位置”为第一个元素前面
    所以next()获取第一个元素
    image_5c11cddc_3d19
    2.)根据第一点,初始的当前位置”为第一个元素前面,所以如果想要删除第一个元素的话,必须先next,然后remove
    Iterator iterator = list.iterator();
    
    iterator.next();
    
    iterator.remove();

     

    否则,会抛出异常
    image_5c11cddc_6e70
    3.)不仅仅是删除第一个元素需要先next,然后才能remove,每一个remove,前面必须有一个next,成对出现
    所以remove是删除当前元素
    如果下面这样,会抛出异常
    iterator.next();
    
    iterator.remove();
    
    iterator.remove();

     

    image_5c11cddc_424a
    4.)迭代器只能遍历一次,如果需要重新遍历,可以重新获取迭代器对象
    如果已经遍历到尾部之后仍旧继续使用,将会抛出异常
    Iterator iterator = list.iterator();
    while (iterator.hasNext()) {
    iterator.next();
    }
    iterator.next();
    image_5c11cddc_7a48

    总结

    在java中万事万物都是对象
    前面的命令模式将请求转换为命令对象
    解释器模式中,将语法规则转换为终结符表达式和非终结符表达式
    迭代器模式中,将“遍历元素”转换为对象
     
    通过迭代器模式引入迭代器,将遍历逻辑功能从容器聚集对象中分离出来
    聚合对象本身只负责数据存储,遍历的职责交给了迭代器
     
    对于同一个容器对象,可以定义多种迭代器,也就是可以定义多种遍历方式
    如果需要使用另外的迭代方式,仅仅需要更改迭代器对象即可
    这样你甚至可以把ConcreteIterator使用配置文件进行注入,灵活设置 
     
    将迭代遍历的逻辑从容器对象中分离,必然会减少容器类的复杂程度
     
    当增加新的容器类或者迭代器类时,不需要修改原有的代码,符合开闭原则
     
    如果你想要将容器聚集对象的遍历逻辑从容器对象中的分离
    或者想要提供多种不同形式的遍历方式时,或者你想为不同的容器对象提供一致性的遍历接口逻辑
    你就应该考虑迭代器模式了
    迭代器模式的应用是如此广泛,以至于java已经将他内置到集合框架中了
    所以对于我们自己来说,多数时候可以认为迭代器模式几乎用不到了
    因为绝大多数时候,使用框架提供的应该就足够了
    在java实现中,迭代器模式的比较好的做法就是Java集合框架使用的这种形式---内部类形式的内部迭代器,如果真的需要自己搞一个迭代器,建议仿照集合框架搞吧
     
    借助于迭代器模式,如果迭代的逻辑不变,更换另外的集合实现,因为实现了共同的迭代器接口,所以不需要对迭代这块,无需做任何变动
    如果需要改变迭代逻辑,必须增加新的迭代形式,只需要增加一个新的内部类实现迭代器接口即可,其他使用的地方只需要做很小的调整
    ArrayList中的ListIterator<E> listIterator() 方法就是如此
    有人觉得增加一个类和一个方法这不也是修改么?个人认为:开闭原则尽管最高境界是完全的对扩展开放对修改关闭,但是也不能死抠字眼
    增加了一个新的获取迭代对象的方法以及一个新的类,总比将原有的源代码中添加新的方法那种修改要强得多,所有的遍历逻辑都封装在新的迭代器实现类中,某种程度上可以认为并没有“修改源代码”
    使用内部类的形式,有人觉得不还是在一个文件中么?但是内部类会有单独的class文件,而且,内部类就像一道墙,分割了内外,所有的逻辑被封装在迭代器实现类中
    不需要影响容器自身的设计实现,所以也是符合单一职责原则的。
    展开全文
  • 一个骑士无聊了,于是进行世界旅行,他的世界是一个矩形棋盘,当他移动的时候,先向一个方向走两个,再在垂直的方向上走一格,能走出棋盘,我们的任务是找到一条路径,骑士走遍所有的格子,每个走一次,如果有那么...
  • 大话数据结构

    2018-12-14 16:02:18
    能非要被毒蛇咬一口才知道蛇可以招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大的数组,然后把所有年份按下标数字对应,如果是闰年,此数组项的值就是1,如果不是...
  • 如果GitHub方便看,可以进入博客:CSDN:易函123/思否:易函123/掘金:易函123 最近更新 --2021-04-01~2021-04-30 npm insatll 下载依赖总会卡住 --2021-04-12 ES6五种遍历对象属性的方式 --2021-04-03 ...
  • 这是一个发生在平行宇宙的事情,那个世界同样有太阳系,同样有地球,也同样有中国和美国,最重要的,他们也使用... 还得多说一句,“大”不代表“好”,只不过有时候,这个“大”是一个既定事实,你不得不去面对。
  • 如果上网方便,按照程序提示也能做好。 在VC6 IDE开发环境中点击run按钮,程序运行有提示: Darwin Streaming Server must either be started from the DOS Console using the -d command-line option, or ...
  • 强调模拟现实世界中的算法而强调概念 C. 使用现实世界的概念抽象地思考问题从而自然地解决问题 D. 鼓励开发者在软件开发的绝大部分中都用实际领域的概念思考 (47) 在结构化方法中,软件功能分解属于下列软件...
  • antlr4权威指南

    2017-09-30 10:47:22
    一条规则能引用另外一条规则,如果后者的备选分支之一在左侧直接引用了前者(而没有匹配一个词法符号)。详见5.4节。  除了上述两项与语法相关的改进,ANTLR 4还使得编写语言类应用程序更加容易。ANTLR生成的语法...
  • (4) 如果一个工人可管理多个设施,而一个设施只被一个工人管理,则实体"工人"与实体"设备"之间存在______联系。 答:一对多#1:N#1:n (5) 关系数据库管理系统能实现的专门关系运算包括选择、连接和______。 答:...
  • 魔兽世界'; var message = function(){ var _wow = '123'; } </code></pre> 在这个例子中全局环境中包含了两个对象(全局环境的变量对象不算),window.wow和window....

空空如也

空空如也

1 2 3 4
收藏数 77
精华内容 30
关键字:

如果不去遍历世界