zuobaiquan / javascript Goto Github PK

 Object.prototype.clone = function(){
            var o = this.constructor === Array ? [] : {};
            for(var e in this){
                    o[e] = typeof this[e] === "object" ? this[e].clone() : this[e];
            }
            return o;
    }

// 第一种：对象  
var person = {};// 或者var obj = new Object();  
person.name = "king";  
person.age = 20;  
person.Introduce = function () {  
    alert("My name is " + this.name + ". My age is " + this.age);  
}; 
person.Introduce();  
  
// 第二种：json格式的对象  
var person = {  
    name: "king",  
    age: 20,  
    Introduce: function () {   
        alert("My name is " + this.name + ". My age is " + this.age);   
    }  
};  
person.Introduce();   
alert(person.name);// king  
  
// 第三种（1）：类，类似于默认构造函数  
var Person = function () {  
    this.name = "king";  
    this.age = 20;  
    this.Introduce = function () {  
        alert("My name is " + this.name + ". My age is " + this.age);  
    };  
};  
var person = new Person();// 或者var person = Person();  
person.Introduce();  
alert(person.name);// 输出：king  
alert(person["name"]);// 也可以使用json的访问方式，说明使用function定义类与第二种是等效的  
alert(person.age);// 输出：20  
  
// 第三种（2）：区别仅在于第一行的声明  
function Person () {  
    this.name = "king";  
    this.age = 20;  
    this.Introduce = function () {  
        alert("My name is " + this.name + ". My age is " + this.age);  
    };  
};  
var person = new Person();  
person.Introduce();  
alert(person.name);// 输出：king  
alert(person.age);// 输出：20  
  
// 第四种（1）：可定制的类，类似构造函数  
var Person = function (name, age) {  
    this.name = name;  
    this.age = age;  
    this.Introduce = function () {  
        alert("My name is " + this.name + ". My age is " + this.age);  
    };  
};  
var person = new Person("king", 20);  
person.Introduce();  
alert(person.name);// 输出：king  
alert(person.age);// 输出：20  
  
// 第四种（2）：  
function Person (name, age) {  
    this.name = name;  
    this.age = age;  
    this.Introduce = function () {  
        alert("My name is " + this.name + ". My age is " + this.age);  
    };  
};  
var person = new Person("king", 20);  
person.Introduce();  
alert(person.name);// 输出：king  
alert(person.age);// 输出：20  
  
// 第五种：变量的封装，将其改为私有。采用了闭包。  
// 在function中用this引用当前对象，通过对属性的赋值来声明属性。即this定义的为公有  
// 如果用var声明变量，则该变量为局部变量，只允许在类定义中调用。即var定义的为私有，不用var则为全局  
var Person = function (name, age) {  
    var name = name;  
    var age = age;  
    this.GetName = function () {  
        return name;  
    }  
    this.GetAge = function () {  
        return age;  
    }  
    this.Introduce = function () {  
        alert("My name is " + name + ". My age is " + age);  
    };  
};  
var person = new Person("king", 20);  
alert(person["name"]);// undefined  
alert(person.GetName());// king  
  
// 第五种（2）：可参考第三种（2）和第四种（2）  
  
// 第六种（1）：在函数体中创建一个对象（使用第二种），声明其属性再返回  
function Person() {  
    var obj =  
    {  
        'age':20,  
        'name':'king'  
    };  
    return obj;  
}  
var person = new Person();  
alert(person.age);// 输出：20  
alert(person.name);// 输出：king  
  
// 第六种（2）：函数体内创建对象时使用第一种方法  
function Person() {  
    var obj = new Object();  
    obj.age = 20;  
    obj.name = 'king';  
    return obj;  
}  
var person = new Person();  
alert(person.age);// 输出：20  
alert(person.name);// 输出：king  

'2017年8月22日'.replace(/[年月日]/g,'-');

'2017年8月22日'.match(/\d+/g).join('-')

'2017年8月22日'.replace(/[年月]/g,'-').replace('日','');

 2017-8-22-
 //这时我们可以通过字符串截取来处理
 '2017年8月22日'.replace(/[年月日]/g,'-').slice(0,-1);

'2017年8月22日'.match(/\d+/g).map(n => +n < 10 ? '0'+n : n).join('-')

function format( str ) {
    var result = /^(\d+)年(\d+)月(\d+)日$/.exec(str)
    if( result ) {
        var y = result[ 1 ];
        var m = result[ 2 ];
        var d = result[ 3 ];
        m = Number( m ) < 10 ? '0' + m : m;
        d = Number( d ) < 10 ? '0' + d : d;
        return y + '-' + m + '-' + d;
    }
    return null;
}
console.log(format( '2017年8月22日'))

'2017年8月22日'.match(/\d{1,4}/g).join('-').replace(/\d+/g, function(d) {
   return (d.length > 1)? d : ('0' + d);
})
     
'2017年8月22日'.replace(/(\d+)日/, function(_d, d) {
   return (d.length == 2)? ('-' + d) : ('-0' + d);
}).replace(/(\d+)月/, function(_m, m) {
   return (m.length == 2)? ('-' + m) : ('-0' + m);
}).replace(/(\d+)年/, function(_y, y) {
   return y;
})
     
'2017年8月22日'.replace(/(\d+)[年,月,日]/g, function(_d,d) {
   return (d.length > 1) ? d.length == 4 ? d : ('-' + d) : ('-0' + d);
})

'2017年8月22日'.replace(/(\d{4})年(\d{1,2})月(\d{1,2})日/, (a,b,c,d)=>{
   return `${b}-${c>9?c:'0'+c}-${d}`
 })

var data = [{
    name: "jiang",
    age: 22
  }, {
    name: "AAAAAAAAAAAAAA",
    age: 21
  }, {
    name: "CCCCCCCCc",
    age: 25
  }];
  //定义一个比较器
  function compare(propertyName) {
    return function(object1, object2) {
      var value1 = object1[propertyName];
      var value2 = object2[propertyName];
      if (value2 < value1) {
        return 1;
      } else if (value2 > value1) {
        return -1;
      } else {
        return 0;
      }
    }
  }
  //使用方法
  data.sort(compare("age"));
  console.log(data);

<!DOCTYPE html>
<html>
        <head>
            <script src="http://common.cnblogs.com/script/jquery.js" type="text/javascript"></script> 
            <script type="text/javascript">
                $(document).ready(function() {
                  alert("加载完成！");
                });
           </script>
        </head>
        <body>
             <img src="http://mpic.tiankong.com/8a7/fc2/8a7fc22d9b75d8b9950e990d6d960da2/640.jpg@360h" />
      </body>
</html>

<script type="text/javascript" defer="defer"> 
alert(document.getElementById("p1").firstChild.nodeValue); 
</script> 

<!DOCTYPE html>
<html>
        <head>
                <script type="text/javascript">
                        (function(){
                                var s = document.createElement('script');
                                s.type = 'text/javascript';
                                s.src = "http://code.jquery.com/jquery-1.7.2.min.js";
                                var tmp = document.getElementsByTagName('script')[0];
                                tmp.parentNode.insertBefore(s, tmp);
                        })();
                </script>
        </head>
        <body>
                <img src="http://mpic.tiankong.com/8a7/fc2/8a7fc22d9b75d8b9950e990d6d960da2/640.jpg@360h" />
        </body>
</html>

let person1 = {
    age: 25
}
let person2 = person1;
person2.gae = 20;
console.log(person1 === person2); //true,**注意复杂数据类型，比较的是引用地址**

<script>
    //arguments对象并不是一个数组，但是访问单个参数的方式与访问数组元素的方式相同
    function show(){
        console.log(arguments); 
        //arguments.push(5);   //此时报错arguments.push is not a function
    }
    show(1,2,3,4);
    //在js中 不需要明确指出参数名，就能访问它们，例如：

    function test() {
        var s = "";
        for (var i = 0; i < arguments.length; i++) {
            alert(arguments[i]);
        }
    }
    test("name", "age");
    //arguments.callee引用函数自身。
    //callee 属性是 arguments 对象的一个成员，仅当相关函数正在执行时才可用。
    //callee 属性的初始值就是正被执行的 Function 对象，这允许匿名的递归函数。
    var sum = function (n) {
        if (n==1) {
            return 1;
        }else {
            return n + arguments.callee(n - 1);
        }
    }
    alert(sum(6));
    //总结：arguments此对象大多用来针对同个方法多处调用并且传递参数个数不一样时进行使用。根据arguments的索引来判断执行的方法。
</script>