標準對象

正則對象

正則表達式是一種處理文本信息的神器汹押，在JavaScript中可以方便的使用正則對象對文本進行處理。JavaScript中聲明正則對象可以使用var name = /.../和var name = new RegExp("...")吆视，第二種方法個人是不推薦的典挑，要處理一系列的文本轉(zhuǎn)義，正則表達式定以后可以使用.test()方法檢驗是否有匹配和.exec()方法分組

var re_test = /\w+@\w+\.\w+/
console.log(re_test) ///\w+@\w+\.\w+/
console.log(re_test.test("avbd@163.com")) //true
console.log(re_test.test("adfasd")) //false

var group_test = /(\w+)@(\w+)\.\w+/
console.log(group_test.exec("avbd@163.com")) 
//[ 'avbd@163.com', 'avbd', '163', index: 0, input: 'avbd@163.com' ]

另外啦吧，在正則結(jié)尾后的/處可以加一些參數(shù)您觉，比如加g就是啟用全局匹配，調(diào)用.exec()會像迭代器一樣逐個返回匹配到的值授滓。當匹配完所有值后將返回null

var global_test = /\w+/g
console.log(global_test.exec("avbd@163.com"))
//[ 'avbd', index: 0, input: 'avbd@163.com' ]
console.log(global_test.exec("avbd@163.com"))
//[ '163', index: 5, input: 'avbd@163.com' ]
console.log(global_test.exec("avbd@163.com"))
//[ 'com', index: 9, input: 'avbd@163.com' ]
console.log(global_test.exec("avbd@163.com"))
//null

JSON對象

json是一種超輕量級的數(shù)據(jù)傳遞格式琳水，脫胎于JavaScript的對象，將按JSON格式完成的對象序列化成文本便可以在網(wǎng)絡(luò)中傳輸褒墨，接收到文本后反序列化即可獲得原數(shù)據(jù)
序列化使用JSON.stringify()方法炫刷，第一個參數(shù)為要序列化的object，第二個參數(shù)可以是一個列表郁妈，描述哪些屬性被序列化（默認全部序列化），也可以是一個輸入?yún)?shù)為(key,value)的函數(shù)绍申，被序列化的內(nèi)容是key:value+噩咪，value+是該函數(shù)的返回值

var json_test = {
    name:"qian",
    age:20,
    skill:"python"
}
json_string = JSON.stringify(json_test)
console.log(typeof(json_string),json_string)
//string {"name":"qian","age":20,"skill":"python"}
console.log(JSON.stringify(json_test,["name","age"]))
//{"name":"qian","age":20}
console.log(JSON.stringify(json_test, function(key,value) {
    if (key == "age") {
        return value - 1
    } else {
        return value
    }
})) //{"name":"qian","age":19,"skill":"python"}

反序列化使用JSON.parse()方法，輸入?yún)?shù)為JSON文本

json_return = JSON.parse(json_string)
console.log(typeof(json_return),json_return)

面向?qū)ο缶幊?/h1>

創(chuàng)建對象

面向?qū)ο缶幊淌悄壳熬幊陶Z言的潮流极阅，JavaScript的面向?qū)ο缶幊谭椒ɑ谠玩湺cC++和python的class-object方法不同胃碾。JavaScript可以通過一個對象創(chuàng)立另一個對象，或者通過構(gòu)造函數(shù)創(chuàng)建變量
通過某個對象創(chuàng)建對象時筋搏，使用Object.create()方法仆百，傳入一個對象可依據(jù)傳入的對象創(chuàng)建出一個平級的對象（而不是繼承的），但是創(chuàng)建出的對象沒有任何屬性奔脐，僅保留了方法

test = {
    name:"javascript",
    time:0,
    use:function (){
        this.time ++
        return this.time
    }
}

var python = Object.create(test)
console.log(python) //{}
python.name = "python"
python.time = 1
console.log(python.use()) //2

另一種可以通過構(gòu)造函數(shù)來創(chuàng)建對象俄周，使用一個內(nèi)部使用了this的函數(shù)并在函數(shù)內(nèi)聲明各種屬性和方法，使用new function的方法調(diào)用

function createobject(name) {
    this.name = name
    this.time = 0
    this.use = function () {
        this.time ++
        return this.time
    }
}
var golang = new createobject("golang") 
console.log(golang) //createobject { name: 'golang', time: 0, use: [Function] }
console.log(golang.use()) //1

原型繼承

個人認為JavaScript最有意思的一點就是其原型繼承的繼承機制髓迎，由于JavaScript中沒有類峦朗，因此繼承是由對象到對象的。每個對象都有原型.prototype排龄，該原型可以簡單的和class類比波势，一個對象是由原型創(chuàng)建的，那么將一個對象的原型指向另一個對象就可以說是繼承了橄维。
但是如果使用直接使用.prototype = objectname的話尺铣，在子對象中添加方法的時候方法就會被添加到父對象中從而修改父類，這是不希望看到的争舞，于是可以指定一個空的且與父對象原型相同的對象（父對象平級的空對象凛忿，將其prototype指向父對象的prototype），于是這個對象就具備了父對象的所有方法兑障，但是屬性仍是空的侄非。
為了繼承屬性蕉汪，需要在子對象的構(gòu)造函數(shù)里使用parentobject.call(this,...)的方法。call將父對象的構(gòu)造函數(shù)中的所有方法和對象的this改為指向子對象逞怨，于是父對象的方法和屬性被子對象繼承且原型鏈正確者疤，子對象新的方法被定義在那個空對象中，不會改變父對象叠赦。

function createobject(name) {
    this.x = name
    this.time = 0
    this.use = function () {
        this.time ++
        return this.time
    }
}
var golang = new createobject("golang")
console.log(golang) //createobject { x: 'golang', time: 0, use: [Function] }

function inherit(parent,child) {
    function F() {
    }
    F.prototype = parent
    child.prototype = F
    child.prototype.constructor = child
}
function inherit_test(name) {
    createobject.call(this,name)
}
inherit(createobject,inherit_test)
test_object = new inherit_test("a")
console.log(test_object) //inherit_test { x: 'a', time: 0, use: [Function] }

以上的例子中驹马，F()是空對象的構(gòu)造方法，函數(shù)inherit(parent,child)封裝了繼承的原型鏈修改部分除秀，子對象構(gòu)造函數(shù)inherit_test(name)中的createobject.call(this,name)則拉取了父對象的所有方法和屬性

類繼承

沒有類這一概念可以說是JavaScript的缺點糯累，因為原型繼承大大復雜了繼承的實現(xiàn)成本，對對象本身的操作卻沒有數(shù)量級的提升册踩，于是在新的JavaScript語法中泳姐，class被引進
類的聲明使用class 類名 {方法}，有一個特殊的方法叫constructor()暂吉，這是類的構(gòu)造函數(shù)胖秒，和Python的__init__類似，屬性可以在該方法中使用this.屬性名 = 值聲明慕的。調(diào)用類生成對象時與使用構(gòu)造函數(shù)生成類一樣阎肝，使用var var_name = new class_name

class TestClass {
    constructor(name) {
        this.name = name
        this.usetime = 0
    }

    useonetime() {
        this.usetime ++
        console.log(this.usetime)
    }
}
var a = new TestClass("javascript")
console.log(a) //TestClass { name: 'javascript', usetime: 0 }
a.useonetime() //1

類的引入方便了繼承的實現(xiàn)，在class中實現(xiàn)繼承只需要兩個操作

• 在聲明類時使用class 類名 extends 父類名 {}即可
• 在構(gòu)造函數(shù)中使用super()調(diào)用父類的構(gòu)造函數(shù)

class TestIherit extends TestClass {
    constructor(name,data) {
        super(name)
        this.data = data
    }

    reportdata () {
        console.log(this.data)
    }
}
var b = new TestIherit("python",10)
console.log(b)
//TestIherit { name: 'python', usetime: 0, data: 10 }
b.useonetime() //1
b.reportdata() //10