JavaScript对象

EMCA对象

在JavaScript中除了null和undefined之外的其他数据类型都被定义成对象

包含11种内置对象

Array，String，Date，Math，Boolean，Number，Function，Global，Error，RegExp，Object

ECMAScript对象都是由Object对象继承而来，Object对象的所有属性和方法都会在其他对象中体现

其属性有两个：ToString()：返回对象的原始字符串表示，就是某个对象变成用字符串表示

　　　　　　　ValueOf()：返回最适合对象的原始值，对于许多对象来说，该方法返回的值与ToString相同

实例一个对象：var x=new String（）；

创建对象

通过关键字new创建对象：obj = new Object（）

自定义创建构造函数：

// 自定义构造函数
    function Person(name,age){
        this.name = name;
        this.age = age;
        this.sayHi = function(){
            console.log(this.name,this.age);
        };
    }
    var p1 = new Person("ss",22);
    p1.sayHi();

//this代指构造函数实例的对象，

字面量创建对象：obj = {}

在对象中添加属性：obj.name = value

访问属性可以用点，也可以用 [] 

 

String对象

　　 var s1="hello,world,welcome,javascript";
    var s2 = new String("hello");   /*这种创建的全局有效*/

    console.log(s1.length);         /*字符串的属性*/

    //字符串方法
    //字符串的格式编排方法，返回字符串标签
    console.log(s1.italics());   //返回<i>hello</i>
    console.log(s1.bold());      //返回<b>hello</b>
    //字符串大小写转换
    var ss1 = s1.toUpperCase();   /*将字符串的字符转换成大写*/
    var ss2 = s1.toLowerCase();   /*将字符串的字符转换成小写*/
    alert(ss1);
    //获取指定字符
    var ss11 = s1.charAt(2);     /*获取指定位置的字符，charAt里的参数是index位置*/
    var ss22 = s1.charCodeAt(2); /*或者指定位置的字符的Unicode码*/
    //查询字符串
    var s11 = s1.indexOf("w");     /*查询指定字符的位置*/
    var s22 = s1.lastIndexOf("w"); /*从右向左查询字符的位置*/
    var y11 = s1.match("word");    /*获取该字符串中所有匹配成功的字符，以数组形式返回*/
    var y22 = s1.search("word");   /*返回所查询的字符在该子符串中首次出现的位置*/
    //截取子字符串:注意两者区别，一个是截取多少字符长度，一个是从哪截取到哪
    var y1 = s1.substr(2,3);       /*两个参数，第一个是开始位置，第二个是截取的长度*/
    var y2 = s1.substring(2,5);    /*两个参数，开始位置，结束位置*/
    var y3 = s1.slice(1,5);        /*切片，参数为开始位置，结束位置*/
    //字符串替换
    var yy1 = s1.replace("ll","ss");
    //字符串分割
    var yy2 = s1.split(",");
    //字符串连接
    var yy11 = s1.concat("skr")     /*在字符串尾部加上一个字符串*/

Array对象

    //数组Array
    //创建方式
    var arr1 = [1,"hello",[1,2],{"name":"ss"}];

    var arr2 = new Array(4);  /*括号里的参数是size指创建的数组最多有多少元素*/
    arr2[0] = 23;
    arr2[1] = 33;
    arr2[2] = 330;

    var arr3 = new Array(1,"hello");
    //注意直接new Array时，如果括号里只有一个参数且为数字时，这个数字是size，而不会被当做数组的元素
    //创建二维数组：二维数组是里面在放一个数组
    var arr4 = new Array(5);
    for (var i=0;i<=5;i++){
        arr4[i] = new Array(2);
    }
    arr4[0][0] = "hello";
    arr4[0][1] = "world";
    arr4[1][0] = 11;
    arr4[1][1] = 22;

    //数组的属性
    console.log(arr1.length);

    //数组方法
    //插入方法
    console.log(arr1.join("**"));   /*将某个字符插入到数组的每一个之间，该结果为"1**hello**1,2**[object Object]"*/
    //连接方法
    var tes1 = arr1.concat(arr2);  /*将两个数组拼接成一个新数组*/
    console.log(tes1);
    //排序方法
    var tes2 = arr1.reverse();    /*数组翻转*/
    var tes3 = arr1.sort();       /*从最高位小到大排序*/
    //自定义排序，数字从小到大排序
    function f(a,b){
        return a-b;
    }
    var tes4 = arr2.sort(f);
    //删除子数组
    var tes5 = arr1.splice(1,2,33,"yy");  /*参数三部分，从哪个位置开始删，删几个元素，再插入的值，插入可有多个*/
    //切片
    var tes6 = arr1.slice(1,3);  /*参数为开始位置，结束位置*/
    //出栈操作：栈（先进后出，后进先出）
    arr1.push("sy",22);    /*在数组的尾部中push值*/
    console.log(arr1);
    var tes7 = arr1.pop();  /*将数组里的值pop出，后进的先出，这里是尾部最后进的*/
    console.log(tes7);

    arr2.unshift(100,20);    /*在数组的前部添加值*/
    console.log(arr2);
    var tes8 = arr2.shift();  /*将数组里的值拿出，注意后进后出，添加的值是在后进去的，不管它是在哪个位置加进去的*/
    console.log(tes8);      /*这里是数组的第一个数被拿出，因为它是最后进的*/

Function对象

arguments:伪数组，可以获取函数调用时传过来的实参，可以通过数组方式索引实参
作用域链：本地查找---》全局查找，找不到返回undefined

预解析：如果在解析之间就调用函数或变量，则函数提前到调用之前，变量声明也会提前
　　　　但变量值不会提前

//Function 对象:js的函数运行之前会将所有函数体加载完后，再执行，所以函数调用放在函数体之前也是可以的
    //创建方式
　　//函数表达式
　　var ff = function （）{};

　　//函数声明
　　 function f1(x,y){
        return x+y;
    }
    document.write(f1(22,33));

    //Function属性
    console.log(f1.length);  /*获取函数的参数的数量*/

    //Function方法
    console.log(void(f1(11,22)));  /*获取函数的返回值*/

    //函数的调用
    console.log(f1(1,2,3,4,5));   /*当传的参数超过函数定义的参数时，只取所需的，后面舍弃*/
    console.log(f1(2));           /*当传的参数少于函数定义的参数时，少的用NaN表示*/

    //arguments:会将传的参数都封装到一个数组里，不管传多少个参数
    function add(){
        var sum = 0;
        for (var i=0;i<arguments.length;i++){
            sum += arguments[i];
        }
        return sum;
    }
    document.write(add(23,34,55));

    //匿名函数:不能在函数体之前调用
    // var func = function(arg){
    //     document.write(arg);
    // };
    // func("yy")

    //匿名函数不赋值于变量名，无名，直接调用
    (function(arg){
        console.log(arg)
    })("hello")

函数声明和函数表达式的区别：

　　js会预解析代码，当使用函数声明时，声明会提前，

　　如果把相同的函数声明放在if---else判断语句中，在IE8中只会执行最下面的函数，因为在函数预解析时会覆盖前面相同的函数

　　而使用函数表达式则遵循if---else判断

 作用域

对于js来说，if，while没有自身的作用域，而函数有作用域

//作用域
    var city = "shenzhen";
    function func(){
        var city = "beijing";
        function foo(){
            var city = "shanghai";
            console.log(city);
        }
        foo();
    }
    func();            /*执行这个函数得到的结果是shanghai*/

var city = "beijing";
    function bar(){
        console.log(city);
    }
    function inter(){
        var city = "shanghai";
        // console.log(city);
        return bar;
    }
    var t = inter();
    t();              /*执行结果是beijing*/

//闭包
    var city = "beijing";
    function func(){
        var city = "shanghai";
        function foo(){
            // var city = "shenzhen";
            console.log(city);
        }
        return foo;
    }
    var ret = func();
    ret()

作用域，由里向外找变量，先在本地作用域查找，在到上一级查找，然后全局作用域查找