javascript基础(2)

一、操作符

1) 一元操作符
a.递增 ++
前置：操作该变量之前进行递增或者递减操作
后置：操作该变量之后进行递增或者递减操作
对任意数据类型的操作数都适用，使用前先将其转换为数字(Number())，然后再进行运算
在应用于对象的时候，优先先调用对象的valueOf方法，以取得一个可供操作的值,如果子类
对象仅重写了toString(),调用该方法。
b.递减 –
前置：操作该变量之前进行递增或者递减操作
后置：操作该变量之后进行递增或者递减操作
对任意数据类型的操作数都适用，使用前先将其转换为数字，然后再进行运算
在应用于对象的时候，先调用对象的valueOf方法，以取得一个可供操作的值,如果子类
对象仅重写了toString(),调用该方法。
c.加 +
相当于调用Number();

    var a = "12"    +a ;    // 12  相当于调用了Number("12")

d.减 -
将一元减应用于数值时，数值会变成负数。
将一元减应用于非数值时，遵循与一元加操作符相同的规则，最后将得到的数值转化为负数

2) 布尔操作符 , 非(NOT)，与(and)，或(OR)
a. 逻辑非 !
该操作符应用任何类型数值都返回一个布尔值。
先将任意类型的数值转换为Boolean，然后取反，!a ==> !Boolean(a)

!0  //true!"" //true  !NaN    //true  !false  //true连用两次逻辑非 ，就可以将任意数据类型转化为Boolean类型，!!a ==> Boolean(a)    !!""    //false

b. 逻辑与 &&
可应用于任意数值。如果有一个操作数不是布尔类型，逻辑与就不一定返回boolean类型
1.如果第一个操作数是 null,NaN,undefined,false,0 则返回该值
2.如果第一个数是其他，返回第二个数
var s1 = 8;
var s2 = “briup”;
var result = s1 && s2; //briup

c. 逻辑或 ||
如果两个操作数都是null,NaN,undefined,false,0 则返回相对应的值
如果第一个操作数都是null,NaN,undefined,false,0 则返回第二个操作数

3)加性操作符
a. 加法 +
m + n
1.当m,n不为String,Object类型的时候，先将m,n转换为Number类型，然后再进行计算
true + false; //1；Number(true)+Number(false);
true + 1; //2；Number(true) + 1
null + undefined; //NaN；Number(undefined) -> NaN
2.当m,n有一个为String,无论另一个操作数为何（但不为对象）都要转换为String，然后再进行拼接
“1” + true; // 1true
“1” + undefined;// 1undefined
“1” + 1; // 11
3.当m,n 有一个为对象，如果该对象既重写toString,又重写了valueOf方法，调用valueOf方法获取返回值，
将该返回值和另外一个操作数进行运算。如果该对象没有重写valueOf方法，将调用toString方法获取返回值，
将该返回值和另外一个操作数进行运算。
var o = {
name:”briup”,
valueOf:function(){
return “1”;
}
}
o+1; //2；o+1

b. 减法 -
无论操作数为任何类型，先将其使用Number()转换器转换为Number类型，然后在计算。
true - 1; //0; 1-1
null - true; //-1 ; 0-1
1 - undefined //NaN
var o = {
name:”briup”,
valueOf:function(){
return 1;
}
}
o-1; //0; 1-1

4)乘性操作符

当操作数为非数值的时候执行自动的类型转化Number()
a. 乘法 *
如果两个数都是数值，执行常规的乘法计算
如果一个操作数是NaN,结果为NaN
超过数值范围返回Infinity
如果有一个操作数不是数值，则在后台先调用Number()将其转换为数值。

b. 除法 /
如果两个数都是数值，执行常规的除法计算
如果一个操作数是NaN,结果为NaN （0/0 ; NaN）
一个非0值除0 Infinity
如果有一个操作数不是数值，则在后台先调用Number()将其转换为数值。
var s1 = 5;
var s2 = 2;
var result = s1/s2; //2.5
c. 取余 %
如果两个数都是数值，执行常规的取余计算
如果一个操作数是NaN,结果为NaN （任意数%0 ; NaN）
如果有一个操作数不是数值，则在后台先调用Number()将其转换为数值。

5) 关系操作符

< > <= >= ,返回一个boolean值
a.如果两个操作数是字符串，比较字符串中对应位置的每个字符的字符编码值
“a”>”b” //false
“1”>”a” //false
b.如果一个操作数是数值，将另外一个操作数也转换为数值进行比较
“3”>1; //true
3>true; //true 3>Number(true)
3>undefined; //false Number(undefined)=NaN ;任何数和NaN比较结果都为false
c.如果一个操作数是对象，先将该对象使用Number()转换为Number类型然后再进行比较

        var o = {            name:"briup",            valueOf:function(){            return "13";            }        }        o>2     // true ; "13">2

6) 相等操作符

a.相等和不相等 ==, !=
先转换在比较
如果有一个数为boolean类型，比较前先转换为数值。
如果一个数为字符串，另外一个数为数值，比较前先将字符串转换为数值
如果两个都是字符串，比较字符序列
如果一个数是对象，另外一个数不是，则调用valuesOf()方法，用得到的基本数据类型进行比较
null == undefined //true
如果一个数为NaN,相等操作返回为false，不等操作返回true
如果两个数都为对象，则比较他们是不是同一个对象，如果两个操作数都指向同一个对象，返回true

b.全等和不全等
仅比较不转换，先比较两个数所属的数据类型，如果类型不同则不同，如果类型相同，再继续比较两个数的值

    console.log("55" == 55); true    console.log("55" === 55);false    null === undifined;  //false

7) 三目运算符 ? :

 variable = boolean_expression ? true_value : false_value; 如果boolean_expression为true,将true_value赋给variable，否则将false_value赋给variable 求任意两个数之间最大值 function max(m,n){    return m>n?m:n; //如果m>n为true返回m,如果m>n为false,返回n }

8) 赋值运算符

   将右侧的值赋给左侧的变量   可以和其他算术运算符连用 *= /= %= += -= 

9) 逗号操作符

   可以在一条语句中执行多个操作   var num1=1,num2 = 2, num3 = 3;

二、流程控制语句

1)if语句

    if(condition){        statement1    }else{        statement2    }

condition表示任意表达式，该表达式求值的结果不一定是布尔类型，如果不是布尔类型，ECMAScript会调用Boolean() 转换函数将这个表达式结果转换为一个布尔类型，如果condition求值结果为true,执行statement1。如果求值结果为false，执行statement2

2)do-while语句 do{ }while(condition);
后测试循环语句，循环体内的代码最少被执行一次。

    var i = 0;    var sum = 0;    do{        sum +=i;        i++;    }while(i<10);

3)while语句 while(condition){ }
前测试循环语句

    var i = 0;    var sum =0;    while(i<10){        sum +=i;        i++;    }

4)for语句
前测试循环语句
语法：
初始化表达式，控制表达式，循环后表达式

    for(initialization;expression;post-loop-expression){        //loop option    }    eg:    var sum = 0;    for(int i=0;i<10;i++){        sum +=i;    }    console.log(i); //10

ECMAScript不存在块级作用域，在循环内部定义的变量也可以在外部访问到

      死循环      for(;;){        //当for中的表达式省略的时候，会创建一个死循环      }

5)switch语句

    switch(expression){    case val:        break;    case val2:        break;    default:    }

可以在switch语句中使用任何数据类型。
case的值不一定是常量，也可以是变量，甚至是表达式。

6) for-in 语句
是一种精准的迭代语句，可以用来枚举对象的属性

       for(property in expression){         statement       }       eg: 打印出window对象中所有的属性       for(var propName in window){         console.log(propName);       }

7) label 语句
使用label可以在代码中添加标签，以便将来使用

     label : for(int i=0;i<10;i++){        if(i == 5){          break label;        }     }

8) 关键字
break 跳出循环体
continue 结束每次循环，进行下一次循环

三、函数简介

1)语法

      function functionName(arg0,arg1...,argn) {        statement      }      eg:      function sayHi(name,message){        alert("hello"+name+","+message);      }

函数在定义时不必指定是否返回值，任何函数在任何时候都可以通过”return 值”返回值。
函数在执行完return语句后停止并且立即退出，位于return后的语句永远不会执行。

    function sum(num1,num2){        return num1+num2;        alert(num1+num2); //将不会执行    }

2) 参数
ECMAScript函数不介意参数的个数以及类型。
在一个函数的内部，使用一个数组接受参数，可以通过arguments接受参数

    function sum(){        alert(arguments[0]+arguments[1]);    }

函数的参数仅仅是为了提供便利，但不是必须的。

四、引用类型-Object

引用类型的值（对象）是引用类型的一个实例。在ECMAScript中，引用类型是一种数据结构，用于将数据和功能组织起来。
1) 创建Object实例的方式：
a.new Object();

        var person = new Object();        person.name = "briup";        person.age = 22;

b.使用对象字面量表示法
不同的属性之间用’,’分割，属性名和属性值之间用’:’分割

        var person = {            name : "briup",            age : 22        };

2) 访问对象属性
a.点表示法，右侧必须是以属性名称命名的简单标识符
person.name
b.中括号表示法，中括号中必须是一个计算结果为字符串的表达式
可以通过变量访问属性

        var a = "name";        person[a];  //既person["name"]        person["first name"]

如果属性名中包含语法错误的字符，或者属性名使用的是关键字或保留字，可以使用中括号    person["first name"]

3) 删除属性
delete只是断开了属性和宿主对象的联系，而不会操作属性中的属性，并且delete只会删除自有属性，不能删除继承属性。在销毁对象时，为了防止内存泄露，遍历属性中的属性，依次删除所有属性delete不能删除那些可配置性为false的属性，以及通过变量声明和函数声明创建的全局对象的属性。
语法：delete 属性访问表达式
例子：delete stu.name //删除学生对象中的name属性
4) 检测属性
in 检测某属性是否是某对象的自有属性或者是继承属性

    "toString" in student

hasOwnProperty()检测给定的属性是否是对象的自有属性。

    student.hasOwnProperty("toString")

propertyIsEnumerable() 检测给定的属性是否是该对象的自有属性，并且该属性是可枚举的

  student.propertyIsEnumerable("toString")

5) Object方法

       hasOwnProperty(propertyName);    用于检查给定的属性是否在当前对象实例中       propertyIsEnumerable(propertyName);  用于检查给定的属性在当前对象实例中是否存在       constructor:         保存用户创建当前对象的函数       isPrototypeOf(object);       用于检查传入的对象是否是原型       toLocaleString();    返回对象的字符串表示，该字符串与执行环境的地区对应       toString();      返回对象的字符串表示       valueOf();       返回对象的字符串，数值，布尔值的表示。

6) 对象的三类属性
a.原型属性
对象的原型属性是用来继承属性的，原型属性是在实例对象创建之初就设置好的。
通过对象字面量创建的对象使用Object.prototype作为它们的原型，通过构造函数创建的对象使用构造函数的prototype属性作为它们的原型。

       原型.isPrototypeOf(对象)  用来检测该原型是否是该对象的原型

b.类属性
对象的类属性是一个字符串，用以表示对象的类型信息。

    Object.prototype.toString.call(o).slice(8,-1); //可以获取类型信息

c.可扩展属性
对象的可扩展性用以表示是否可以给对象添加新属性，所有内置对象和自定义对象都是显示可扩展的

     Object.isExtensible(a) 判断a对象是否是可扩展的     Object.preventExtensions() 转换对象为不可扩展，一定对象为不可扩展将不能

    转换可扩展的，该方法只会影响的对象自身的可扩展性，不会影响其原型的

7) 对象序列化
对象序列化是指将对象的状态转换为字符串，也可以反序列化，将字符串还原为对象函数，RegExp,Error对象，undefined值不能序列化和反序列化。

     JSON.stringify()  只能序列化对象可枚举的自有属性。     toJSON()   Object原型中没有toJSON方法，但是对于要执行序列化的对象来说     JSON.stringify()方法会调用toJSON方法，如果待序列化的对象中存在这个方法，则调用，返回值即时序列化的结果，而不是原始对象。     JSON.parse()   反序列化

五、Array类型

ECMAScript数组和其他语言中的数组都是有序列表，但是有以下特性：

    a.每一项都可以保存任何类型的数据。    b.数组的大小是可以动态调整。    c.数组的length属性：可读可写，可以通过设置length的值从数组的末尾移除项或向数组中添加新项

1) 创建方法
a. 使用Array构造函数

          var arr = new Array();          var arr = new Array(20);  // 预先指定数组的大小          var arr = new Array("terry","larry","boss"); //传入参数          注意：new 关键字也可以省略，但是尽量不要省略

b. 使用数组字面量
由一对包含数组项的方括号表示，多个数组项之间用逗号分隔

          var arr = ["terry","larry","boss"];          var arr = []          //空数组

2) 访问数组元素
数组变量名[索引]
1.如果索引小于数组的长度，返回对应项的值

        var arr = ["terry","larry","boss"];        arr[0] ;        //访问数组中第一个元素,返回值为terry

2.如果索引大于数组的长度，数组自动增加到该索引值加1的长度

        var arr = ["terry","larry","boss"];        arr[3] ="jacky";    //添加元素,数组长度变为4    数组最多可以包含4 294 967 295个项

3) 检查数组

    var arr = [];    typeOf(arr);        //返回object    Array.isArray(arr); //判断arr是否是数组类型

4) 转换数组为字符串
数组继承Object方法，并且对这些方法进行了重写

      toLocalString();      toString();在默认情况下都会以逗号分隔字符串的形式返回数组项      var arr = ["terry","larry","boss"];         arr.toString()        //terry,larry,boss       valueOf(); 在默认情况下以数组字面量的方式显示（firefox）      arr.valueOf();        //["terry","larry","boss"];       join();   使用指定的字符串用来分隔数组字符串      arr.join("||");       //briup||terry||jacky

5) 栈，队列方法
a.栈 LIFO (Last-In-First-Out)

      push() 可接受任意类型的参数，将它们逐个添加到数组的末尾，并返回数组的长度      pop()  从数组的末尾移除最后一项，减少数组的length值，返回移除的项

b.队列 FIFO (First-In-First-Out)

      shift()  移除数组中的第一个项并且返回该项，同时将数组的长度减一。      unshift() 在数组的前端添加任意个项，并返回新数组的长度。

6) 排序
reverse() 反转数组项的顺序
sort()
1.默认排序：
该方法会调用每个数组项的toString() 转型方法，然后排序
2.自定义排序：
a.该方法可以接受一个比较函数作为参数，比较函数有两个参数
b.如果第一个参数位于第二个参数之前，返回负数
c.如果第一个参数位于第二个参数之后，返回正数

            var arr = [11,5,23,7,4,1,9,1];            console.log(arr.sort(compare));            //该比较函数适合于大多数数据类型            function compare(v1,v2){                if(v1>v2){                    return -1;                }else if( v1<v2){                    return 1;                }else{                    return 0;                }            }

7) 操作方法
concat() :先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，返回副本

        var arr = ["aa","bb","cc","dd"];        var arr_new = arr.concat("ee","ff");             // arr_new = ["aa", "bb", "cc", "dd", "ee", "ff"]            // arr不改变

slice() :可接受一个或者两个参数（返回项的起始位置，结束位置）
当接受一个参数，从该参数指定的位置开始，到当前数组末尾的所有项
当接受两个参数，起始到结束之间的项，但是不包含结束位置的项

        var arr = ["aa","bb","cc","dd"];        1.接受一个参数时          var arr_new = arr.slice(1);            // arr_new = ["bb", "cc", "dd"],arr 不改变        2.接受两个参数时          var arr_new = arr.slice(1,2);             // arr_new = ["bb"]; arr不改变

splice() : 向数组的中部插入数据，将始终返回一个数组，该数组中包含从原始数组中删除的项。
删除：指定两个参数(删除第一的起始位置，要删除的项数)
插入：指定三个参数(起始位置，0，要插入的项任意数量的项)
替换：指定三个参数(起始位置，要删除的项，要插入的任意数量的项)

        var arr = ["aa","bb","cc","dd"];        1.删除          var del_arr = arr.splice(1,2);            // arr = ["aa","dd"];    在原数组进行了删除操作            // del_arr = ["bb","cc"];返回删除的元素数组        2.插入          var del_arr = arr.splice(1,0,"ee","ff");            // arr =  ["aa", "ee", "ff", "bb", "cc", "dd"] 将指定项插入到1位置处            //del_arr = [], 返回空数组        3.替换          var del_arr = arr.splice(1,2,"ee","ff");            // arr =  ["aa", "ee", "ff", "dd"] 将"bb","cc" 替换成了"ee","ff"            //del_arr = ["bb", "cc"], 返回删除的元素数组

indexOf() (要查找的项，开始查找的位置(可选)) 从数组开头向后查找，使用全等操作符，找不到该元素返回-1

        var arr = ["22","11","cc","dd","11"];        arr.indexOf(11); //返回-1，因为使用"==="进行匹配        arr.indexOf("11"); //返回1，从前往后匹配，返回第一个匹配元素的位置

lastIndexOf()(要查找的项，开始查找的位置(可选)) 从数组末尾向前查找，使用全等操作符，找不到该元素返回-1

        var arr = ["22","11","cc","dd","11"];        arr.lastIndexOf("11"); //返回4，从后往前匹配，返回第一个匹配元素的位置

8) 迭代方法：
参数： 每一项上运行的函数，运行该函数的作用域对象（可选）
every();对数组中的每一运行给定的函数，如果该函数对每一项都返回true,则返回true

            var arr = [11,5,23,7,4,1,9,1];            var result = arr.every(function(item,index,arr){                return item >2;            });            console.log(result); //false

some(); 对数组中的每一运行给定的函数，如果该函数对任一项都返回true,则返回true

            var result = arr.every(function(item,index,arr){                return item >2;            });            console.log(result); //true

filter();对数组中的每一运行给定的函数，会返回满足该函数的项组成的数组

            var result = arr.filter(function(item,index,arr){                return item >2;            });            console.log(result); // [11, 5, 23, 7, 4, 9]

map();对数组中的每一运行给定的函数,返回每次函数调用的结果组成的数组

            var result = arr.map(function(item,index,arr){                return item * 2;            });            console.log(result); // [22, 10, 46, 14, 8, 2, 18, 2]

forEach();对数组中的每一运行给定的函数,没有返回值，常用来遍历元素

            var result = arr.forEach(function(item,index,arr){                console.log(item);            });