js的常用功能及属性总结

总结·复习

章节1：基础知识

1.关于<script>：

所有js代码都必须写到标签<script></script>中，否则视为无效。而且此标签可以写到</head>下面的所有地方，包括body，不过一般不写body里。

它有两种方式，内部使用和外部使用，内部使用就不说了。外部的话，一般格式为为<script src=”路径+文件名”></script>。

 

2.常用的数据类型及变量：

数据类型：number（数值）、string（字符串）、boolean（布尔），

typeof：是一个一元运算，返回字符串。（很少用）

 

属性：alert（）：警告提示框（打印，可以打印任何东西）。

      document.write()：直接打印出来。

 

 

第二章：程序设计基础

 

1、变量：

var variable的缩写，声明一个变量，可以储存常量。

变量名命名规则：

1）、关键字不能用。

2）、一般情况下，只用英文开头，也可以是$和_，但不建议使用。不能用数字开头，因为和8进制、16进制产生冲突。命名原则：见名思义。

规范：

（1）尽量使用英文单词或者组合，或者专业名词weight、color、fileName（驼峰命名法）。

（2）尽量不要使用拼音

 

2、对象类型：

在js中对应的是object，一般定义对象的方法有两种：

   1）、var dog={name:"藏藏",type:"藏獒",color:"花色",sex:"雄",age:3,marry:false};

   2）、var dog = newObject();
dog.name="藏藏";
dog.age=3;
dog.marry=false;

使用对象的方法：对象名+“.”+属性。（对象中的属性能有对象类型）

3算术运算符与表达式：

      常用运算符：+-*/%

      表达式：

1、         a++先运算再加

2、         ++a先加在运算

3、         a=a+1  等价于a+=1（以上各种运算符通用）

      字符串也可以靠加进行拼接的。

          vardogName= "zhangsan"
dogName = dogName + "feng";
alert(dogname);

 

4关系运算符与表达式

       记住：等号(== )   不等于(！=)

             错误格式：a<b<c。

             正确的：a<b&&（且的意思） b<c

&&:与   的意思

||：或  的意思

！：非  的意思

 

 

章节三

1判断与循环语句：

1判断

      if（条件满足为true）{

         执行该语句。

}else{

         执行另一个或者不执行。

}

 

if语句的套路：一个选择依据，两个选项

附赠例文：计算三角形面积

var a=Number(prompt("请输入第一个边"));
var b=Number(prompt("请输入第二个边"));
var c=Number(prompt("请输入第三个边"));

if(a+b>c&& a+c>b&& b+c>a){
    var p=(a+b+c)/2;
    var s = Math.sqrt(p*(p-a)*(p - b)*(p - c ));
    alert(s);
}else{
    alert("对不起，您输入的有误！")
}

 

 

 

switch的优点：1.选择结构更加清晰，一目了然。

               2.执行速度相对较快。

switch的执行逻辑：从switch后边圆括号里的变量与从case后边的常量

相等的地方开始，依次执行后边的指令，直到指令结束。

 

2循环

          switch（参数）{

                                 case：对应参数：传出值;break；（直接跳出）

             case：对应参数：传出值;break；（直接跳出）

}

附赠例文：判断是否是自然数

var x = Number(prompt("请您输入x(要求为大于0的自然数)的值："));
 var y;
 switch (x){
     case 1:y= x;break;
     case 2:
     case 3:
     case 4:
     case 5:y= x*x+1;break;
     case 6:
     case 7:
     case 8:
     case 9:y= Math.sqrt(x+1);break;
     default:y =1/(x+1);break;
 }
alert("x="+x+"运算后可以得到"+"y="+y);

default:除了所有case列举的情况之外的

 

3．循环

1).先判断再循环

Wicth（判断条件）{

循环语句

}

2).先循环再判断

Do{

循环语句

}wicth（判断条件）

 

4  

       For（var 变量；变量范围；变量自增自减）{

循环语句

}

 

 

章节四：错误与调试

凭个人经验传递以下几点：

    出错后：1、F12打开开发者工具

 

            2、根据你出错的内容选择

                   一般选这个sources

            

            3、设置断点  

           

 

            4、找到这个

 

 

 

切记：开发者工具的console窗口，能显示错误及其说明try……catch 捕获异常

 

 

好，接下来你就可以自由调试了。

 

章节五：循环结构

以上第三章已经说明过了

共同的特点：有条件地重复地做一件事，每一次做的事情不同但类似。

 

break:跳出所在的switch或者循环结构

continue:结束本次循环，开启下一次循环。

Return：返回（数值，对象等）

注意：循环都是可以嵌套的。

 

 

 

 

 

 

第六章：函数

1函数基础：

函数的引用，主要是将困难的问题简单化，也就是，把大事化小，小事化了的原理。把一个有难度大事件分开成为两个小事情，分成一层一层的，那么，解决大事情麻烦，解决小事情就比较轻松了，小事如果还难的话，就继续划分，直到能简单解决为止。

 

2function 定义函数的关键字

定义格式：定义：

functionisPrime(n){     n为形参，用来接收传入的实参

（内容）

}

 

比如：var a=2；将a传入函数，那么这个a就是实参，是实际数据。

案例：验证100以内的数都符合角谷定理

<script>
    var flag= true;
    for(varn=2;n<=100;n++){
       if(!isJiaogu(n)){
            flag = false;
        }
    }
    alert("角谷定理验证"+(flag?"成功":"失败"));
    /*
    * 功能：判断一个给定的数是否符合角谷定理
    * 名称：isJiaogu
    * 输入参数：待判断的数
    * 输出结果：true/false
    * */

 

函数的本质：直观理解就是实现某个独立功能的代码段，或者说它就是一个数据加工的黑箱子。

 

 

 

3变量：全局变量与局部变量    

全局变量：在函数外部定义的变量，这个变量可以在全局进行使用。

局部变量：在函数内部定义的变量，这个变量只能够在函数的内部使用，在全局中不能够使用。

冲突处理原则：就近原则。

 

在局部中给变量加上window的前缀，就可以访问到全局的变量。

vara = 1;
function doubleVar(){
    var a= 2;
    var a= 3;
    alert(a);
    alert(window.a);
}

 

注意，参数的传递

返回参数  和  接收参数

返回参数：用return

接收参数：用  函数值（参数）；

比较复杂点的案例（没有用冒泡排序）：输入一个四位数，判断其内部大小，再按大小重新排序，输出最大和最小的四位数。

/*
 *
 * 1.输入一个四位数的值
 * 2.拆分
 * 3.重组被拆分的四位数
 * 4.
 *
 * */
var num= prompt("请输入一个四位数：");
var result= {
    value: num,
    max: -1,
    min: 10,
    a: 0,
    b: 0,
    c: 0,
    d: 0
};
split(result);
sort(result);
recombine(result);

/*函数功能：将输入的四位数分别拆分并返回
 * 输入参数：result.value
 * 返回值：拆分之后的四位数result.a  result.b result.c  result.d
 *
 * */
functionsplit(result) {
    result.a = Math.floor(result.value/ 1000)
    result.b = Math.floor((result.value% 1000) / 100);
    result.c = Math.floor(((result.value% 100) / 10));
    result.d = result.value% 10;
}

/*传入参数值，
 *返回排序值（排序好的）
 * */
functionsort(result) {
    var num1= [result.a, result.b, result.c, result.d];
    for (vari = 0;i < 4; i++) {
        var max1= num1[i] >max ? num1[i] : max;
        var min1= num1[i] <min ? num1[i] : min;
    }
    switch (max1) {
        case a:
            var max2= Math.max(result.c, result.b, result, result.d);
            break;
        case b:
            var max2= Math.max(result.c, result.d);
            break;
    }
    result.max=max1*1000+max2*100+max3*10+min1;
    result.min=min1*1000+max3*100+max2*10+max1;

}
/*
 * 传入参数
 * 返回值：最大值：result.max，最小值:result.min
 * */
functionrecombine(result) {
            result.max;
            result.min;
}

 

 

第七章：数组

1.数组基础：

简单案例：计算5名同学的平均分

方案1，普通做法
    var a1,a2,a3,a4,a5;
    a1 =Number(prompt("请输入分数"));
    a2 =Number(prompt("请输入分数"));
    a3 =Number(prompt("请输入分数"));
    a4 =Number(prompt("请输入分数"));
    a5 =Number(prompt("请输入分数"));

    var ave= (a1+a2+a3+a4+a5)/5;
    alert(ave);

方法二：数组做法

var a = [];
var sum= 0;
for(vari=0; i<5;i++){
    a[i] = Number(prompt("请输入分数"));
    sum += a[i];
}
var ave= sum/a.length
alert(ave);

这段代码能够实现同样的功能，而且如果是100人的话，只要把循环的条件改为i<100即可，整个程序的结构和代码量和人数多少没有关系。

主要是可以控制变量，将其储存传入。

 

 

2.数组的定义与元素访问

数组的定义方式有三种：

1.     var a=[];

2.     Var a=[1,2,3,2];

3.     Var a= new Array();

   访问元素：数组名+下标（下表都是从0开始的）

 

 3.数组的常用属性及方法：

       数组长度：length，它告诉我们数组有多长 ，可以通过该属性改变数组的长度。

如下：

var a=[1,2,3,4,5,6];
a=a.length-1;
alert(a);

 

1）unshift：在数组头部添加元素，返回值返回的是新数组的长度。

   shift：删除数组头部的元素，返回值是删除的头部元素。

 

2）indexOf：查找在数组中重复出现的元素第一次出现的位置，返回值是该元素的下标。

lastIndexOf：查找数组中重复出现的元素最后一次出现的位置，返回值是该元素的下标。

 

3）push：在数组的尾部插入元素，返回值是添加元素后数组的长度。

   pop：从数组的尾部删除最后一个元素，返回值是删除的元素。

 

4）slice（开始位置的下标,结束位置的下标）：提取数组中指定连续的子数组。前包括，后不包括。

 

5）splice（开始删除位置的下标，要删除元素的长度，要选择插入或替换的内容），splice有“剪接”的含义。前面两个参数定义“剪”的部分，第三个参数定义“接”的部分，经过不同的参数组合就可以实现以下三个功能：

1、删除操作：删除数组中指定的任意元素

2、插入操作：在数组中指定位置插入元素

3、替换操作：在数组中替换指定位置的元素。

 

6）reverse：将数组中的元素，反序输出。在原数组的基础上进行反序输出，不会重新创建新数组。

 

7）map：原数组的映射，经过函数的加工，返回给一个新数组。

 

4.匿名函数：

将一个函数直接运用到某个方法里，目前我知道的只能用在映射和计时器里。

vara = [2,4,6,8];
var b =a.map(fun);

function fun (value, index, self) {
    return value*value;

}

我们可以将以上内容简写为：

var a = [2,4,6,8];
var b =a.map(function(value, index, self) {
    return value*value;
});

 

用在计时器里如下：

var a=setInterval(function(){
    /*内容*/
},100);

 

这就是匿名函数

 

 

5.For in

var a=[1,2,3,4,5,6];
 for(var i in a){
     document.write(a[i]+"<br>");
 }

for（变量+in+数组名）{

·······}

6.查找

a．这种查找方法最简单，但是查找的次数与数据量成正比，效率不高。

var a = [2,5, 7, 9, 3, 4, 8];
var num = Number(prompt("请输入要查找的值："));
var index = -1;//最初认为要找的数不在数组
for (var i ina) {
    if (a[i] ==num) {
        index = i;
        break;
    }
}

b．折半查找（二分查找）

假设在一个已经有序的数组中，可以利用折半查找大幅提高速率。

/*
* 思路：
*
* 1用left表示查找的范围起点，end表示终点
* 2只要start<=end就重复以下步骤
* 3和中间的位置（mid）两个数进行比较
* a.相等：找到了，结束
* b.大于：在前半段找，即 end=mid-1
* c.小于：在后半段去找，即start=mid+1
*
*
* */

var a = [2, 3,4, 5, 6, 7, 8];
var num = Number(prompt("请输入要查找的值："));
var index = -1;//最初认为要找的数不在数组

var start=0;
var end=a.length-1;

while(start<=end){
    varmid=Math.ceil((start+end)/2);
    if(num==a[mid]){
        index=mid;
        break;
    }else{
        if(num>a[mid]){
            start=+1;
        }else{
            end=mid-1;
        }
    }
}
alert(index)

折半查找的最快查找次数与数据量是对数关系，所以说它的查找量是很高的，但任何事都是有两面行的，它的高效率也是有代价的，也就是要要求有序。

 

 

7.数组的应用：

冒泡排序：

   /*冒泡排序练习*/
    var a=[1,3,2,5,4,9,7];
    for(vari=0;i<a.length-1;i++){//循环的次数
        for(varj=0;j<=a.length-i-1;j++){//要排序的下标
            if(a[j]>a[j+1]){        //利用下标进行元素对比
                var b=a[j];
                a[j]=a[j+1];
                a[j+1]=b;
            }
        }
    }
alert(a);

 

 

利用前面讲的数组的属性，在前面删除插入和在后面的删除插入办到的。了解即可

先进先出（FIFO）,在头部出队(shift)，在尾部收队(push)。

1队列：

 

 

 

 

 

 

 

2. 堆栈

先进后出（FILO）在尾部进（push），在尾部出（pop）。

 

 

第八章：常见的算法

本章，我介绍的重点在于迭代，递推，穷举。而叠加/累积和递归，不再多讲，一个是太简单，一个是太费脑。

 

1.    迭代

 

迭代法也叫辗转法。

规律：就是可以不断的用旧的值去得到新的值，直到我们想要得到的结果。

遇到了迭代的问题怎么解决：

（1）  找到迭代的变量（旧的值）

（2）  确定迭代的关系

（3）  迭代的条件

①   就是知道最终结果

②   循环的次数

 

案例：找到最大公约数

/*
* 1.如果num1<num2则交换，确保num1是较大的
* 2. 计算余数
* 3. 当余数不为0，重复以下步骤4-6：
* 4. num2 => num1,
* 5. 余数 => num2
* 6. 重新计算余数
* 7.最终得到最大公约数，也就是num2的值
* */

function GCD(num1,num2){
    if(num1 < num2){
        var t= num1;
        num1 = num2;
        num2 = t;
    }
    varremainder= num1%num2;
    while(remainder!= 0){
        num1 = num2;    //注意，计算完本轮，把结果值赋给另一个数，方便下一轮运算
        num2 = remainder;
        remainder =num1%num2;
    }
    return num2;
}

 

 

 

 

2.    递推

解决思路：

找到数学规律，通过公式计算到下一项的值。一直到我们要的结果为止。

案例如下：兔子产子：通过前两项得到下一项。

/*一般而言，兔子在出生两个月后，就有繁殖能力，
 一对兔子每个月能生出一对小兔子来。
 如果所有兔子都不死，那么一年以后总共有多少对兔子？*/
/*
*  月份  0   1  2  3   4  5  6
*  幼崽  1   1  1  2   3  5  8
*  成年  0   0  1  1   2  3  5
*  总共  1   1  2  3   5  8  13
* */

var rabbit = [1,1];
for(var m=2;m<=month; m++){
    rabbit[m] = rabbit[m-1]+rabbit[m-2];
}
alert(rabbit[month]);

递推分为顺推和逆推。

 

 

3.穷举

在解决问题时，如果找不到更好地解决方法，那么就用最笨的方法，即为：把所有的结果全部打印出来。没事反正计算机的特点就是计算快。

如下案例：百钱买百鸡：

/*
公鸡一值钱五，母鸡一值钱三，小鸡仔儿三值钱一。
 百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
 */
for(varcock=0;cock<=20;cock++){
    for(varhen=0;hen<=33;hen++){
        var chicken= 100-cock-hen;
        if(100== cock*5+ hen*3+ chicken/3){
            document.write("鸡翁一共："+cock+"鸡母一共："+hen+"小鸡一共："+chicken+"<br>");
        }

}
}

 

第九章：常用对象

1.字符串：

说明一下，字符串与数组有着近乎相同的属性，不过字符有好多专用特有的属性，比数组要方便点。

例如：查找数组用  src[i]

      查找字符用： src。charAt（i）  切记，是括号

取字符串：数组方式用它：slice();

          字符特有式：substr(开始截取的下标，截取长度)

替换：数组方式：splice

      字符特有方式：replace（第一个参数被替换的子串，第二个参数是新的子串）；

toUpperCase()：小写字母转化为大写字母。

toLowerCase()：大写转化为小写。

trim()方法：去除字符串首尾的空格符

trim()方法：去除字符串首尾的空格符

 

 

2.日期

修改日期分量：

下面获取的都是当前：

setYear（年）、setMonth（月）、setDate（日）

getHours（时）、getMinutes（分）、getSeconds（秒）

getSeconds（毫秒）

getTime获取的是从1970-1-1 00:00:00至指定日期所经历的毫秒数。

varshijian=document.getElementById("shijian");
var tier=setInterval("getTime()",1000);
function getTime(){
    /*shijian.innerHTML=newDate().toLocaleString();*/
    var time=new Date();//时间
    var hour=time.getHours();//小时
    var minute=time.getMinutes();//分钟
    var second=time.getSeconds();//秒
    shijian.innerHTML=hour+":"+minute+":"+second;
   /* clearInterval(tier);*///终止计时器
}

 

 

日期转换成字符串

var d = newDate(2017,3,22,8,30,22,500);
document.write(d.toString()+"<br>");
document.write(d.toDateString()+"<br>");
document.write(d.toTimeString()+"<br>");
document.write(d.toLocaleDateString()+"<br>");
document.write(d.toLocaleTimeString()+"<br>");
document.write(d.toUTCString()+"<br>");

 

 

 

第十章：事件

1.事件的概念

事件源→事件名→事件注册→事件处理

举例如下：

粤商大酒店201房间发生火灾，119电话报警，南湖区消防支队出警，赶赴现场通过喷水作业成功灭火。

事件源：粤商大酒店201房间

事件名：火灾

事件注册：事先已经规划好片区，粤商大酒店所属片区归南湖区消防支队负责

事件处理：喷水

 

2.常用事件名

（写在标签里的）：

             1：onclick：鼠标单击事件

             2：ondblclick：鼠标双击事件

             3：onmousedown：鼠标按下事件（不区分鼠标任何键）

             4：onmouseup：鼠标抬起事件（不区分鼠标任何键）

             5：onmouseenter：鼠标移动事件

             6：onmouseleave：鼠标移出事件

             7：onmousemove：鼠标滚动事件。

             8：keydown、keyup可以捕获键盘上所有的键（个别除外）。

             9：onload:页面加载事件

             10：onfocus:获得焦点的事件

             11：onblur:失去焦点事件

             12：onchange:值改变事件

 

3事件的监听：

addEventListener的第一个参数事件名，第二个参数是事件处理函数。可以添加事件监听，当然也就可以移除，用的是removeEventListener，参数与addEventListener参数是一样的。

例1：

vartxt1= document.getElementById("txt1");
    txt1.addEventListener("change",function(){
        alert("值改变了");
    });

 

例2：

   var txt1=document.getElementById("txt1");
    //注册事件的第二种方法
    txt1.onblur =blur2;
    //注册事件的第三种方法
    txt1.addEventListener("change",function(){
        alert("值改变了");
    });

 

4获取元素

（1）getElementById

根据元素的id属性来获取元素，获取到的是一个元素

（2）getElementsByTagName

根据标签名来获取元素，结果是一个元素集合。

（3）getElementsByClassName

根据class属性来获取元素，结果是一个元素集合。

（4）getElementsByName

根据name属性来获取元素，结果是一个元素集合。

 

注意：

document对象支持以上四种，而element对象仅支持getElementsByTagName和getElementsByClassName。

 

5修改元素：

   常用的修改方法：

      修改文本：

         1 innerText：可读取或设置标签的内部文本

functionfun(){
    //获取到指定元素
    var p1= document.getElementById("p1");
    p1.innerText= "我被单击了！";
}

2 innerHTML：属性获取或设置内部文本。

（innerHTML属性获取或设置内部文本。）

         修改样式：

            a. xxx.style.yyy

b. xxx.classname = "……"（相当于修改了class属性）

<body>
    <p id="p1">修改样式测试</p>
    <input type="button"value="样式一"onclick="style1()">
    <input type="button"value="样式二"onclick="style2()">
</body>
<script>
    var p1 = document.getElementById("p1");
    function style1(){
        p1.className= "style1";
    }
    function style2(){
        p1.className= "style2";
    }
</script>

 

5.添加删除元素

     (1)createElement创建一个元素节点

createElement("p"),创建一个段落

(2)createTextNode 创建一个文本节点

createTextNode("文本内容")，创建一个值为“文本内的文本节点.

(3)appendChild 添加子节点

(4)removeChild 删除子节点

动态添加

<body>
    <div id="div1">
    </div>
    <input type="button" value="添加段落"onclick="add()">
</body>
<script>
    var index= 1;
    function add(){
        //创建一个段落标签
        var p= document.createElement("p");
        //创建文本节点
        var content="第"+index+"段落";
        var txt= document.createTextNode(content);
        //将文本节点添加到段落
        p.appendChild(txt);
        //将段落添加到div中
        var div1= document.getElementById("div1");
        div1.appendChild(p);

        index++;
    }
</script>
</html>

 

动态删除

<body>
    <div id="div1">
        <p id="p1">第1段落</p>
        <p id="p2">第2段落</p>
        <p id="p3">第3段落</p>
        <p id="p4">第4段落</p>
    </div>
    <input type="button" value="删除第二段"onclick="del()">
</body>
<script>
    function del(){
        //先找到父节点
        var div1= document.getElementById("div1");
        //再找到要删除的节点
        var p2= document.getElementById("p2");
        //将要删除的节点从父节点中移除
        div1.removeChild(p2);
    }
</script>
</html>

那么如果并不知道父节点是谁，该如何删除呢？

p2.parentNode.removeChild(p2);

动态添加和动态删除：删除动态添加的奇数段落。

思路1：获取div1下的所有段落，遍历所有段落，将序号为奇数的段落删除。

functiondel(){
    var div1= document.getElementById("div1");
    var paras= div1.getElementsByTagName("p");
    for(vari inparas){
        if((i+1)%2== 1){
            div1.removeChild(paras[i]);
        }
    }
}

思路2：添加时通过设置class属性，然后通过getElementsByClassName来获取奇数行

<body>
    <div id="div1">
    </div>
    <input type="button"value="添加段落"onclick="add()">
    <input type="button"value="删除奇数段落"onclick="del()">
</body>
<script>
    var index = 1;
    function add(){
        //创建一个段落标签
        var p= document.createElement("p");
        //创建文本节点
        var content= "第"+index+"段落";
        var txt = document.createTextNode(content);
        //将文本节点添加到段落
        p.appendChild(txt);
        if(index%2== 1) {
            p.setAttribute("class","odd");
        }
        //将段落添加到div中
        var div1= document.getElementById("div1");
        div1.appendChild(p);

        index++;
    }

    function del(){
        var div1 = document.getElementById("div1");

        var paras = div1.getElementsByClassName("odd");
        for(var i=paras.length-1;i>=0; i--){
            div1.removeChild(paras[i]);
        }
    }
</script>
</html>

6.导航

document是根节点

parentNode：获取父节点

childNodes：获取所有子节点

firstChild：第一个子节点

lastChild：获取最后一个子节点

<body>
    <div name="第一章">
        <p id="p1">第一段<span>第一句</span><span>第二句</span></p>
    </div>
    <input type="button"value="获取p1父节点的name属性"onclick="fun1()">
    <input type="button"value="显示p1子节点的个数"onclick="fun2()">
    <input type="button"value="显示p1第一个子节点的节点类型"onclick="fun3()">
    <input type="button"value="显示p1最后一个子节点的节点类型"onclick="fun4()">
</body>
<script>
    var p1 = document.getElementById("p1");
    function fun1(){
        var value = p1.parentNode.getAttribute("name");
        alert(value);
    }
    function fun2(){
        var childs = p1.childNodes;
        alert(childs.length);
    }
    function fun3(){
        alert(p1.firstChild.nodeType);
    }
    function fun4(){
        alert(p1.lastChild.nodeType);
    }
</script>
</html>

 

第十一章：杂记

1.    Bom

Window：窗口，浏览器的窗口。

我们定义的全局变量和全局函数都是window对象的属性和方法。

var a=1;
function tes(){
    var a=1;
    alert(a);
    alert(window.a);
}

在局部获取全局变量的方法，加个window

 

2常用的弹窗：

第一种：

Alert：警告提示框！也可以是window对象下的方法，window可以不写。（没有返回值）

var str= prompt("请输入内容!",”啦啦啦”)

alert("警告提示框!");

 

 

 

 

 

 

 

 

 

第二种：

Prompt：（“提示的信息”，“默认值”）；信息提示输入框，也可以是window对象下的方法，window可以不写。当点击了确定后才返回值，取消则为空。（有返回值）

第三种：

varisRight=confirm("是否确定删除？");
   document.write(typeof(isRight)+"<br>"+isRight);

 

Confirm确认框，当确定是返回true，取消false

      

 

 

 

3cookie：

作用：将信息储存在本地浏览器

Cookie的作用：在本地浏览器存储数据，用于记住账号

Cookie的组成

键值对的形式

存储数据：”usersid：123456  , psd：123132”

有效期：“expires=今天以后的时间”;

 

 

 

获取cookie：

通过document . Cookie就能得到浏览器之前存储的cookie。是一个字符串。将这个字符串进行解析，得到内容。

   var usermima=document.getElementById("usermima").value;
   var username=document.getElementById("username").value;
    var date=newDate();
    date.setDate(date.getDate()+7);

    var cooketext="usermima="+usermima;+";"+"expires="+date;
    var cooketext2="username="+username;+";"+"expires="+date;
    document.cookie=cooketext;
    document.cookie=cooketext2;
    alert(document.cookie);
}

 

 

 

 

 

 

 

 

清除：将储存的cookie的有效期改为过去的某一天，就能清除cookie

function removeCookie(){
    var date=newDate();
    date.setDate(date.getDate()-7);
     var cookieText="username=;expires"+date;
     var cookieText2="usermima=;expires"+date;
    document.cookie=cookieText;
    document.cookie=cookieText2;
}

 

 

 

 

4计时

 

setInterval（“函数”，“毫秒数”）；//计时器，就是个多久时间就调用一次函数。

var tier=setInterval("getTime()",1000);
function getTime(){
    var shijian=document.getElementById("shijian");
    /*shijian.innerHTML=newDate().toLocaleString();*/
    var time=newDate();
    var hour=time.getHours();
    var minute=time.getMinutes();
    var second=time.getSeconds();
    shijian.innerHTML=hour+":"+minute+":"+second;
   

clearInterval（计时器）；//停止一个计时器。

案例：六秒倒计时：

var time=setInterval("shijian()",1000);
var a=6;
function shijian(){
    var shijian=document.getElementById("shijian");
    if(a==0){
        clearInterval(time);
        alert("倒计时结束！")
    }else{
        shijian.innerHTML=a--;
    }
}

 

 

延时器：setTimeout（“函数名”，“毫秒数”）；//，就是隔了多久就调用一个函数。

<p id="p1">您的电话已欠费（三秒后停止）</p>
</body>
<script>
    var timer=setTimeout("ala()",3000);
    function ala(){
        var p1=document.getElementById("p1");
        p1.innerHTML="";
    }