簡單的this，麻煩的this

作者：劉欣 2018-08-31 15:36:45

開發(fā) 開發(fā)工具

周末的Hello World咖啡館總是熱鬧非凡。 Java , Python, Ruby, JavaScript圍坐在一起，一邊喝咖啡，一邊海闊天空。

周末的Hello World咖啡館總是熱鬧非凡。

Java , Python, Ruby, JavaScript圍坐在一起，一邊喝咖啡，一邊海闊天空。

C老頭兒則待在一旁，冷眼旁觀。

聊著聊著，這話題不知怎么著轉(zhuǎn)移到了“this”上來了。

Java 說： “唉！你們不知道吧，對于一個(gè)初學(xué)Java的人來說，this 是非常難于理解的。”

Python說：“this 在你那里已經(jīng)夠簡單了啊。還難于理解？”

“我們都是支持面向?qū)ο缶幊痰模谖疫@里，this 可以用到實(shí)例方法或者構(gòu)造器中，表示對當(dāng)前對象實(shí)例的引用。”

public class Point { 
    private double x = 0.0; 
    private double y = 0.0; 
    public Point(int x, int y) { 
        this.x = x; 
        this.y = y; 
    } 
 
   public double distanceTo(Point that) { 
        double dx = this.x - that.x; 
        double dy = this.y - that.y; 
        return Math.sqrt(dx*dx + dy*dy); 
    } 
}

“這不很容易理解嗎？ ” Ruby 問道。

“對于***次接觸面向?qū)ο缶幊痰娜藖碚f，他分不清這個(gè)當(dāng)前對象this到底是哪個(gè)對象。” Java說，“我必須得再寫一段代碼給他掰扯一下。”

Point p1 = new Point(1,1); 
Point p2 = new Point(2,2); 
 
// this 指向的是p1 
p1.distanceTo(p2);   
 
// this 指向的是p2 
p2.distanceTo(p1);

“對啊，this必須得有個(gè)上下文才能準(zhǔn)確理解。” Python說，“還有，你那個(gè)this吧，是個(gè)隱式的，像我是顯式的：”

class Point: 
    def __init__(this, x, y): 
        this.x = x 
        this.y = y 
    def distanceTo(this,point): 
        dx = this.x - point.x 
        dy = this.y - point.y 
        return math.sqrt(dx**2+dy**2)

Java 說：“你不是一直用self嗎，怎么現(xiàn)在是this?”

Python笑道：“我這不是為了和你Java老弟保持一致嘛，反正只是個(gè)變量名，你想用this就用this,想用that就用that，只不過我們習(xí)慣于用self 。”

Ruby說： “Python兄，你把this放到方法中作為一個(gè)參數(shù)，實(shí)在是太丑陋了，一點(diǎn)美感都沒有。”

“那是我們的哲學(xué)，我們信奉 Explicit is better than implicit。”

“可是在調(diào)用的時(shí)候，怎么不把一個(gè)對象傳給那個(gè)方法？你的self去哪里了？”

p1 = Point(1,1) 
p2 = Point(2,2) 
 
p1.distanceTo(p2) 
p2.distanceTo(p1)

“你怎么不寫成： distanceTo(p1,p2) ？”

“那不行，” Python說，“如果那樣的話我們就不是面向?qū)ο罅耍嫦蜻^程了。 ”

“哼哼，” C老頭兒在一旁冷笑一聲，“說來說去，還不是披了一層面向?qū)ο蟮耐庖拢瑑?nèi)部實(shí)現(xiàn)依然是面向過程的？！”

“此話怎講？” Java一直以正統(tǒng)的面向?qū)ο笞跃樱幌馪ython, Ruby ，Java即使是想輸出一個(gè)Hello World也得定義一個(gè)類不可。

“就說你吧，Java小子，你的Java 源文件被編譯以后變成了.class文件，這個(gè)class文件被裝載到了Java虛擬機(jī)的一個(gè)區(qū)域，這個(gè)區(qū)域叫什么？” C 老頭兒出手不凡。

“當(dāng)然是Method Area, 方法區(qū)了，這我會不知道？！”

“對啊，它為什么叫方法區(qū)? 為什么不叫Class Area, 類區(qū)？” C 老頭兒真是別出心裁。

“這…… ” Java 語噻了，他從來就沒有想過這個(gè)問題。

“你的方法區(qū)是被各個(gè)線程所共享的，存儲虛擬機(jī)加載類的信息，常量池，其中最主要的就是類中定義的方法相關(guān)的代碼。而你創(chuàng)建的對象呢，卻是放在‘堆中’，虛擬機(jī)在執(zhí)行的時(shí)候，要從方法區(qū)找到‘方法’，這些方法的字節(jié)碼在運(yùn)行的過程中，會操作位于堆中的對象。 ”

“所以你看，你的數(shù)據(jù)和方法是分離的，一個(gè)地方是方法（所以叫方法區(qū)），一個(gè)地方是數(shù)據(jù)，和我們C寫出的程序是一樣的，都是面向過程的！” C老頭兒經(jīng)過一系列證明后做了最終陳述。

Python也沉默了，他知道，自己在運(yùn)行時(shí)也和這種方式差不多。

過了一會兒，Java 醒悟了過來：“不對，老頭兒你這是混淆概念，我們是站在程序員的角度在談?wù)撜Z言是不是面向?qū)ο蟮模銊t把我們拉到了實(shí)現(xiàn)層面，這是不對的。”

Python也附和道：“對對，我們是面向?qū)ο蟮恼Z言，抽象程度比你的面向過程要高！”

“抽象？哼哼，” C 老頭兒又冷笑一聲，“Linus 用C 寫了Linux，用C 寫了Git，你覺得他沒有做抽象？笑話！依我看來，抽象就是要在變化的東西中找到不變的東西，和具體的編程語言關(guān)系不大啊。” C老頭說了一句至理名言。

Java 悄悄對Python說： “老頭兒主要做操作系統(tǒng)內(nèi)核，操作系統(tǒng)中的那些虛擬內(nèi)存，進(jìn)程，線程，文件系統(tǒng)概念都很清晰，并且很穩(wěn)定，估計(jì)他沒有接觸到應(yīng)用層變態(tài)的，不講道理的業(yè)務(wù)邏輯。 ”

C 老頭兒說：“別以為你們面向?qū)ο笥卸嗝戳瞬黄穑腋嬖V你，有很多程序員，用著面向?qū)ο蟮恼Z言，寫著面向過程的程序！關(guān)鍵是人！”

Ruby 說：“兩位兄臺，算了，不和老頭兒爭論了，來看看我的this吧，奧不，是self, 我這里必須用self。我的self 和你們的都不一樣，在不同的位置表示不同的含義。比如說：”

class Point 
 
    # 此處的Self 就是Point這個(gè)類 
    puts "Self is :#{self}" 
 
    # 定義一個(gè)Class級別（靜態(tài)）的方法，self還是Point這個(gè)類 
    def self.name 
        puts "Self inside class method is: #{self}"         
    end 
    # 定義一個(gè)實(shí)例方法， 此處的self 就是對象實(shí)例了 
    def name 
        puts "Self inside instance method is: #{self}"   
    end 
end

Java 說：“你這搞得太麻煩了，定義一個(gè)靜態(tài)方法，用static 不就結(jié)了？”

半天都沒有說話的JavaScript突然說道：“這也叫麻煩，來看看我是怎么處理this的！”

function add(y){ 
    return this.x + y 
}

熟悉面向?qū)ο蟮腏ava, Python看到這么古怪的代碼，大為吃驚，這是什么鬼？ add函數(shù)中的這個(gè)this 到底指向誰？

JavaScript說：“不要大驚小怪！我的this和你們的this ,self都不一樣，它是動(dòng)態(tài)的，在定義時(shí)確定不了到底指向誰，只有等到函數(shù)調(diào)用的時(shí)候才能確定，this 指向的是最終調(diào)用它的那個(gè)對象，比如：”

function add(y){ 
    //此時(shí)的this 指向的是全局的對象，在瀏覽器運(yùn)行就是window 
    return this.x + y 
} 
 
x = 10 
console.log(add(20))

在這里調(diào)用add函數(shù)的是全局上下文，所以this指向的是全局對象，輸出的值是30 。

JavaScript說：“我還可以給add函數(shù)傳遞一個(gè)對象當(dāng)作this。”

function add(y){ 
    //此時(shí)的this 指向的是對象obj,this.x 是20 ，不是10 
    return this.x + y 
} 
 
x = 10 
 
var obj = {x: 20}; 
//傳遞一個(gè)對象給add函數(shù) 
add.call(obj,20)  // 40

大家更加吃驚了。

JavaScript又展示了一個(gè)例子：

var obj = { 
    x:100, 
    print:function(){ 
       console.log(this.x);  
    }     
} 
 
obj.print() //100

Python說： “這個(gè)很容易理解，這個(gè)this應(yīng)該是指向obj這個(gè)對象實(shí)例，所以print函數(shù)輸出的x是100，對吧。”

“對的，再來看一個(gè)：”

var obj = { 
    x:100, 
    y:{ 
        x : 200, 
        print:function(){ 
            console.log(this.x);  
        } 
    }         
} 
obj.y.print() //200

Java 說道：“按照你的規(guī)則，這個(gè)this 指向的應(yīng)該是最終調(diào)用它的對象，那就是y , 在y中，x是200，所以應(yīng)該輸出200 ！”

JavaScript說：“如果我把對象y中的x:200 給去掉，輸出是什么？ ”

“難道是100 ？不，它不會向上一級去找，只會在y中尋找x 的值，如果沒有，就是undefined，唉！你這this規(guī)則實(shí)在是太麻煩。”

JavaScript笑了笑：“再來看個(gè)更古怪的例子：”

var obj = { 
    x:100, 
    y:{ 
        x : 200, 
        print:function(){ 
            console.log(this.x);  
        } 
    }         
} 
 
var point ={x:15,y:15, f: obj.y.print} 
 
point.f() //輸出什么？ 
 
var x = 10 
g = obj.y.print 
g()  //輸出什么？