JavaScript基础

全局变量和局部变量

方法内部用var声明的变量是局部变量，方法外部用var声明或者方法内部不加var的都是全局变量

function test(){
    a=10;
}
console.log(a);// a is not defined
test();
console.log(a); //10

说明：a虽然是全局变量，但是此时从上到下解析没有完成，a未定义，所以在test()执行之后就没问题了。

数据类型

基本数据类型：Number，Boolean，String(区别于java，是引用数据类型)，Undefined Null

Number类型

    var a1=10;
    var a2=10.5;
    var a3=NaN;
    var a4=1/0;
    console.log(a4); //Infinity 正无穷
    var a5=070;//八进制
    console.log(a5);//56
    var a6=0x20;
    console.log(a6);//32

    //浮点数精度是17位，所以浮点数相加判断是不准确的
    var a6=0.1;
    var a7=0.2;
    console.log(a6+a7==0.3);//false
    console.log(a6+a7);//0.30000000000000004
    var a8=parseInt("12a");
    var a9=parseInt("a12");
    console.log(a8,a9);//12 NaN

引用数据类型

Object类型(例如：对象，数组，RegExp,Date。。)

 var a=null;//虽然null是基本数据类型，但是指向一个空对象的引用
    var a1=undefined;
    var a2=NaN;
    console.log(typeof(a),typeof(a1),typeof(a2));//object undefined number

变量自动转换

    var a=1;
    var b=true;
    console.log(a==b,a===b);//true false
    //== 自动转换，比较的数值
    //=== 自动转换，比较值，在比较数据类型

引用类型

数组

js中的数组更加类似java的容器，长度可变，元素类型也可以不同，数组长度随时可变，length属性

常用方法：
    push:数组最后追加元素，返回新数组的长度
    pop：删除数组最后的元素，返回删除的元素
    shift：删除第一个数组元素，返回删除的元素
    unshift：在数组最前面追加元素，返回新数组长度
    splice：很特别，操作数组本身
    参数一：起始位置
    参数二:截取的个数
    参数三以及以后的：需要添加的元素

    slice：切割数组，并返回新数组，原数组不变。
    参数一：起始位置
    参数二：结束位置，不包含
    concat：连接两个数组,并返回新数组，原数组不变
    join：遍历数组元素，添加分隔符，并返回字符串
    sort：数组排序
    reverse：反转数组

基本案例：
   var arr=[1,2,3,5];
    var b=arr.pop();
    console.log(arr,b);//[1,2,3] 5
    arr.push(4);
    console.log(arr);//[1,2,3,4]
    arr.shift();
    console.log(arr);//[2,3,4]
    arr.unshift(1);
    console.log(arr);//[1,2,3,4]
    arr.length=5;
    console.log(arr);//[1,2,3,4,empty]

    var arr=[1,2,3,4,5];
    arr.splice(1,2,3,4,5);
    console.log(arr);//[1,3,4,5,4,5];
    var a1=arr.slice(0,2);
    console.log(a1);//[1,3]

    var a2=[1,2,4];
    var info=a2.join("-");
    console.log(info,typeof(info));//1-2-4 string

    console.log(a2.concat(arr));//[1, 2, 4, 1, 3, 4, 5, 4, 5]

sort数组排序

基本数组升序排序：
    var arr1=[1,3,5,2];
    function sortNum(a,b){
        return a-b;
    }
    console.log(arr1.sort(sortNum));

基本数组降序排序：
    var arr1=[1,3,5,2];
    function sortNum(a,b){
        return b-a;
    }
    console.log(arr1.sort(sortNum));

对象根据某个属性排序：
    var arr = [
    {name:'zopp',age:0},
    {name:'gpp',age:18},
    {name:'yjj',age:8}
    ];
    function sortObj(property){
        return function(a,b){
            var info1=a[property];
            var info2=b[property];
            return info1-info2;
        }
    }
    console.log(arr.sort(sortObj("age")));
说明：此时是根据年纪大小升序排序。

数组补充es5

位置方法：indexOf lastIndexOf
迭代方法：every filter forEach some map
缩小方法：reduce reduceRight

基本案例：位置
    var arr=[1,2,3,4,5,4,3,2,1];
    console.log(arr.indexOf(4));//3
    console.log(arr.lastIndexOf(4));//5
    //参数一，表示起始位置，参数二还是值
    console.log(arr.indexOf(4,4));//5

基本案例：循环

every:传入function，如果都符合返回true，否则返回false

    var arr=[1,2,3,4,5,6];
    var res=arr.every(function(value,index,arr){
        return  value>5;
    });
    console.log(res);//false

filter:过滤，符合的添加到值数组中
    var arr=[1,2,3,4,5,6];
    var res=arr.filter(function(value,index,arr){
        return value>4;
    });
    console.log(res);//5,6

forEach:遍历
var arr=[1,2,3,4,5,6];
    arr.forEach(function(value,index,arr){
        console.log(index,value,arr);
})

    var arr=[1,2,3,4,5,6];
    var a1=arr.map(function(value,index,arr){
        return value*2;
    });
    console.log(a1);//[2,4,6,8,10,12]

some:有一个true就返回true和every反过来的
    var arr=[1,2,3,4,5,6];
    var a1=arr.some(function(value,index,arr){
        return value>2;
    });
    console.log(a1);//true

    var arr=[1,2,3,4,5,6];
    var a=arr.reduce(function(pre,cur,index,arr){
        return pre+cur;
    })
    console.log(a);//21

说明：reduceRight类似reduce，但是从右往左遍历。