访问排行榜
谷歌广告
谷歌广告
从PHP 到Golang 的笔记 ( 转 )
Author 沐青之枫 | Posted 2018-05-30 16:00:00

转载地址:www.jianshu.com/p/44905bdeb505

———文章来源 YamiOdymel/PHP-to-Golang

为什么从PHP 转到Golang?

PHP和模块之间的关系令人感到烦躁,假设你要读取yaml档案,你需要有一个yaml的模块,为此,你还需要将其编译然后将编译后的模块摆放至指定位置,之后换了一台伺服器你还要重新编译,这点到现在还是没有改善;顺带一提之后出了PHP 7效能确实提升了许多(比Python 3快了些),但PHP仍令我感到臃肿,我觉得是时候
(转行)了。

PHP 和Golang 的效能我想毋庸置疑是后者比较快(而且是以倍数来算),也许有的人会认为两种不应该被放在一起比较,但Golang 本身就是偏向Web 开发的,所以这也是为什么我考虑转用Golang 的原因,起初我的考虑有几个:Node.js 和Rust 还有最终被选定的Golang;先谈谈Node.js 吧。

Node.js

Node.js的效能可以说是快上PHP 3.5倍至6倍左右,而且撰写的语言还是JavaScript,蒸蚌,如此一来就不需要学习新语言了!搭配Babel更可以说是万能,不过那跟「跳跳虎」一样的Async逻辑还有那恐怖的Callback Hell,有人认为前者是种优点,这点我不否认,但是对学习PHP的我来说太过于"Mind Fuck",至于后者的Callback Hell虽然有Promise,但是那又是另一个「Then Hell」的故事了。相较于Golang之下,Node.js似乎就没有那么吸引我了。你确实可以用Node.js写出很多东西,不过那V8引擎的效能仍然有限,而且要学习新的事物,不就应该是「全新」的吗;)?

题外话:为什么Node.js不适合大型和商业专案?

Rust

在抛弃改用Node.js 之后我曾经花了一天的时间尝试Rust 和Iron 框架,嗯⋯⋯Rust 太强大了,强大到让我觉得Rust 不应该用在这里,这想法也许很蠢,但Rust 让我觉得适合更应该拿来用在系统或者是部分底层的地方,而不应该是网路服务。

Golang

Golang是我最终的选择,主要在于我花了一天的时间来研究的时候意外地发现Golang夭寿简洁(关键字只有25个),相较之下Rust太过于「强大」令我怯步;而且Golang带有许多工具,例如go fmt会自动帮你整理程式码、go doc会自动帮你生产文件、go test可以自动单元测试并生产覆盖率报表、也有go get套件管理工具(虽然没有版本功能),不过都很实用,而且也不需要加上分号(;),真要说不好的地方⋯⋯大概就是强迫你花括号不能换行放吧(没错,我就是花括号会换行放的人)。

还请先阅读⋯

当我在撰写这份文件的时候我会先假设你有一定的基础,你可以先阅读下列的手册,他们都很不错。


定义变数-Variables

你能够在PHP 里面想建立一个变数的时候就直接建立,夭寿赞,是吗?

PHP

$a = "foo";
$b = "bar";

Golang

蒸蚌!那么Golang 呢?在Golang 中变数分为几类:「新定义」、「预先定义」、「自动新定义」、「覆盖」。让我们来看看范例:

// 新定義:定義新的 a 變數為字串型別,而且值是「foo」
var a string = "foo"

// 預先定義:先定義一個新的 b 變數為字串型別但是不賦予值
var b string

// 自動新定義:讓 Golang 依照值的內容自己定義新變數的資料型態
c := "bar"

// 覆蓋:先前已經定義過 a 了,所以可以像這樣直接覆蓋其值
a = "fooooooo"  

输出-Echo

在PHP中你会很常用到echo来显示文字,像这样。

PHP

echo "Foo"; // 輸出:Foo

$A = "Bar"
echo $A; // 輸出:Bar

$B = "Hello"
echo $B . ", world!"; // 輸出:Hello, world!

$C = [1, 2, 3];
echo var_dump($C); // 輸出:array(3) {[0]=>int(1) [1]=>int(2) [2]=>int(3)}  

Golang

然而在Golang中你会需要fmt套件,关于「什么是套件」的说明你可以在文章下述了解。

fmt.Println("Foo") // 輸出:Foo

A := "Bar"  
fmt.Println(A) // 輸出:Bar

B := "Hello"  
fmt.Printf("%s, world!", B) // 輸出:Hello, world!

C := []int{1, 2, 3}  
fmt.Println(C) // 輸出:[1 2 3]  

函式-Function

这很简单,而且两个语言的用法相差甚少,下面这是PHP:

PHP

function test() {  
    return "Hello, world!";
}

echo test(); // 輸出:Hello, world!  

Golang

只是Golang 稍微聒噪了一点,你必须在函式后面宣告他最后会回传什么资料型别。

func test() string {  
    return "Hello, world!"
}

fmt.Println(test()) // 輸出:Hello, world!  

多值回传-Multiple Value

在PHP 中你要回传多个资料你就会用上阵列,然后将资料放入阵列里面,像这样。

PHP

function test() {  
    return ['username' => 'YamiOdymel', 
            'time'     => 123456];
}
$data = test();

echo $data['username'], $data['time']; // 輸出:YamiOdymel 123456  

Golang

然而在Golang 中你可以不必用到一个阵列,函式可以一次回传多个值:

func test() (string, int) {  
    return "YamiOdymel", 123456
}
username, time := test()

fmt.Println(username, time) // 輸出:YamiOdymel 123456  

匿名函式-Anonymous Function

两个语言的撰写方式不尽相同。

PHP

$a = function() {
    echo "Hello, world!";
};

$a(); // 輸出:Hello, world!

Golang

a := func() {  
    fmt.Println("Hello, world!")
}

a() // 輸出:Hello, world!  

多资料储存型态-Stores

主要是PHP 的阵列能做太多事情了,所以在PHP 里面要储存什么用阵列就好了。

PHP

$array  = [1, 2, 3, 4, 5];
$array2 = ['username' => 'YamiOdymel', 
           'password' => '2016 Spring'];

在Golang里⋯⋯没有这么万能的东西,首先要先了解Golang中有这些型态:array, slice, map, interface

你他妈的我到底看了三洨,首先你要知道Golang是个强型别语言,意思是你的阵列中只能有一种型态,什么意思?当你决定这个阵列是用来摆放字串资料的时候,你就只能在里面放字串。没有数值、没有布林值,就像你没有女朋友一样。

阵列-Array

一个存放固定长度的阵列。

先撇开PHP 的「万能阵列」不管,Golang 中的阵列既单纯却又十分脑残,在定义一个阵列的时候,你必须给他一个长度还有其内容存放的资料型态,你的阵列内容不一定要填满其长度,但是你的阵列内容不能超过你当初定义的长度。

PHP

$a = ["foo", "bar"];

echo $a[0]; // 輸出:foo  

Golang

var a [2]string

a[0] = "foo"  
a[1] = "bar"

fmt.Println(a[0]) // 輸出:foo  

切片-Slice

可供「裁切」而且供自由扩展的阵列。

切片⋯⋯这听起来也许很奇怪,但是你确实可以「切」他,让我们先谈谈「切片」比起「阵列」要好在哪里:「你不用定义其最大长度,而且你可以直接赋予值」,没了。

PHP

$a = ["foo", "bar"];

echo $a[0]; // 輸出:foo  

Golang

a := []string{"foo", "bar"}

fmt.Println(a[0]) // 輸出:foo  

我们刚才有提到你可以「切」他,记得吗?这有点像是PHP中的array_slice(),但是Golang直接让Slice「内建」了这个用法,其用法是:slice[開始:結束]

Golang

p := []int{1, 2, 3, 4, 5, 6}

fmt.Println(p[0:1]) // 輸出:[1]  
fmt.Println(p[1:1]) // 輸出:[]  (!注意這跟 PHP 不一樣!)  
fmt.Println(p[1:])  // 輸出:[2, 3, 4, 5, 6]  
fmt.Println(p[:1])  // 輸出:[1]  

在PHP中倒是没有那么方便,在下列PHP范例中你需要不断地使用array_slice()

PHP

$p = [1, 2, 3, 4, 5, 6];

echo array_slice($p, 0, 1); // 輸出:[1]  
echo array_slice($p, 1, 1); // 輸出:[2]  
echo array_slice($p, 1);    // 輸出:[2, 3, 4, 5, 6]  
echo array_slice($p, 0, 1); // 輸出:[1]  

映照-Map

有键名和键值的阵列。

你可以把「映照」看成是一个有键名和键值的阵列,但是记住:「你需要事先定义其键名、键值的资料型态」,这仍限制你没办法在映照中存放多种不同型态的资料。

PHP

$data["username"] = "YamiOdymel";
$data["password"] = "2016 Spring";

echo $data["username"]; // 輸出:YamiOdymel  

Golang

在Golang里可就没这么简单了,你需要先用make()宣告map

data := make(map[string]string)

data["username"] = "YamiOdymel"  
data["password"] = "2016 Spring"

fmt.Println(data["username"]) // 輸出:YamiOdymel  

接口-Interface

终于;一个可存放多种资料型态的阵列,但难以捉模(干)。

也许你不喜欢「接口」这个词,但用「介面」我怕会误导大众,所以,是的,接下来我会继续称其为「接口」。还记得你可以在PHP 的关联阵列里面存放任何型态的资料吗,像下面这样?

PHP

$mixedData  = ["foobar", 123456];
$mixedData2 = ['username' => 'YamiOdymel', 
               'time'     => 123456];

Golang

现在你有福了!正因为Golang中的interface{}可以接受任何内容,所以你可以把它拿来存放任何型态的资料。

mixedData := []interface{}{"foobar", 123456}

mixedData2 := make(map[string]interface{})  
mixedData2["username"] = "YamiOdymel"  
mixedData2["time"]     = 123456  

不定值-Mixed Type

有时候你也许会有个不定值的变数,在PHP 里你可以直接将一个变数定义成字串、数值、空值、就像你那变心的女友一样随时都在变。

PHP

$mixed = 123;
echo $mixed; // 輸出:123

$mixed = 'Moon, Dalan!';
echo $mixed; // 輸出:Moon, Dalan!

$mixed = ['A', 'B', 'C'];
echo $mixed; // 輸出:['A', 'B', 'C']  

Golang

在Golang中你必须给予变数一个指定的资料型别,不过还记得刚才提到的:「Golang中有个interface{}能够存放任何事物」吗(虽然也不是真的任何事物啦⋯⋯)?

var mixed interface{}

mixed = 123  
fmt.Println(mixed) // 輸出:123

mixed = "Moon, Dalan!"  
fmt.Println(mixed) // 輸出:Moon, Dalan!

mixed = []string{"A", "B", "C"}  
fmt.Println(mixed) // 輸出:["A", "B", "C"]  

逆向处理-Defer

当我们程式中不需要继续使用到某个资源或是发生错误的时候,我们索性会将其关闭或是抛弃来节省资源开销,例如PHP 里的读取档案:

PHP

$handle = fopen('example.txt', 'r');

if($errorA)  
    errorHandlerA();

if($errorB)  
    errorHandlerB();

fclose($handle); // 關閉檔案  

Golang

在Golang中,你可以使用defer来在函式结束的时候自动执行某些程式(其执行方向为反向)。所以你就不需要在函式最后面结束最前面的资源。

defer可以被称为「推迟执行」,实际上就是在函式结束后会「反序」执行的东西,例如你按照了这样的顺序定义deferA->B->C->D,那么执行的顺序其实会是D->C->B->A,这用在程式结束时还蛮有用的,让我们看看Golang如何改善上述范例。

handle := file.Open("example.txt")  
defer file.Close() // 關閉檔案但「推遲執行」,所有程式結束後才會執行這裡

if errorA {  
    errorHandlerA()
}
if errorB {  
    errorHandlerB()
}

跳往-Goto

这东西很邪恶,不是吗?又不是在写BASIC,不过也许有时候你会在PHP 用上呢。但是拜托,不要。

PHP

goto a;  
echo 'foo';

a:  
echo 'bar'; // 輸出:bar  

Golang

goto a  
fmt.Println("foo")

a:  
fmt.Println("bar") // 輸出:bar  

回圈-Loops

Golang中仅有for一种回圈但却能够达成foreachwhilefor多种用法。普通for回圈写法在两个语言中都十分相近。

PHP

for($i = 0; $i < 3; $i++)  
    echo $i; // 輸出:012

$j = 0;
for($j; $j < 5; $j++)  
    echo $j; // 輸出:01234

Golang

在Golang请记得:如果你的i先前并不存在,那么你就需要定义它,所以下面这个范例你会看见i := 0

for i := 0; i < 3; i++ {  
    fmt.Println(i) // 輸出 012
}

j := 0  
for ; j < 5 ; j++ {  
    fmt.Println(j) // 輸出:01234
}

每个-Foreach

在PHP里,foreach()能够直接给你值和键名,用起来十分简单。

PHP

$data = ['a', 'b', 'c'];

foreach($data as $index => $value)  
    echo $index . $value . '|' ; // 輸出:0a|1b|2c|

foreach($data as $index => $value)  
    echo $index . '|' ; // 輸出:0|1|2|

foreach($data as $value)  
    echo $value . '|' ; // 輸出:a|b|c|

Golang

Golang里面虽然仅有for()但却可以使用range达成和PHP一样的foreach方式。

data := []string{"a", "b", "c"}

for index, value := range data {  
    fmt.Printf("%d%s|", index, value)  // 輸出:0a|1b|2c|
}

for index := range data {  
    fmt.Printf("%d|", index)  // 輸出:0|1|2|
}

for _, value := range data {  
    fmt.Printf("%s|", value)  // 輸出:a|b|c|
}

重复-While

一个while(條件)回圈在PHP里面可以不断地执行区块中的程式,直到條件false为止。

PHP

$i = 0;

while( $i < 3 ) {  
    $i++;
    echo $i; // 輸出:123
}

while(true)  
    echo "WOW" // 輸出:WOWWOWWOWWOWWOW...

Golang

在Golang里也有相同的做法,但仍是透过for回圈,请注意这个for回圈并没有任何的分号(;),而且一个没有条件的for回圈会一直被执行。

i := 0

for i < 3 {  
    i++
    fmt.Println(i) // 輸出:123
}

for {  
    fmt.Println("WOW") // 輸出:WOWWOWWOWWOWWOW...
}

做.. 重复-Do While

PHP中有do .. while()回圈可以先做区块中的动作。

PHP

$i = 0;

do {  
    $i++;
    echo $i; // 輸出:123
} while($i < 3);

Golang

在Golang中则没有相关函式,但是你可以透过一个无止尽的for回圈加上条件式来让他结束回圈。

i := 0

for {  
    i++
    fmt.Println(i) // 輸出:123

    // 注意這個條件式和 PHP 有所不同
    if i > 2 {
        break
    }
}

Golang

要是你真的希望完全符合像是PHP那样的设计方式,或者你可以在Golang中使用很邪恶的goto

i := 0

LOOP:  
    i++
    fmt.Println(i) // 輸出:123

    if i < 3 {
        goto LOOP
    }

日期-Date

在PHP中我们可以透过date()像这样取得目前的日期。

PHP

echo date("Y-m-d H:i:s"); // 輸出:2016-07-13 12:59:59  

Golang

在Golang就稍微有趣点了,因为Golang中并不是以Y-m-d这种格式做为定义,而是123,这令你需要去翻阅文件,才能够知道1的定义是代表什么。

fmt.Println(time.Now().Format("2006-2-1 03:04:00"))          // 輸出:2016-07-13 12:59:59  
fmt.Println(time.Now().Format("Mon, Jan 2, 2006 at 3:04pm")) // 輸出: Mon, Jul 13, 2016 at 12:59pm  

切割字串-Split

俗话说:「爆炸就是艺术」,可爱的PHP用词真的很大胆,像是:explode()(爆炸)、die()(死掉),回归正传,如果你想在PHP里面将字串切割成阵列,你可以这么做。

PHP

$data  = 'a, b, c, d';
$array = explode(', ', $data);

Golang

简单的就让一个字串给「爆炸」了,那么Golang 呢?

data  := "a, b, c, d"  
array := strings.Split(data, ", ")  

对了,记得引用strings套件。

关联阵列-Associative Array

这真的是很常用到的功能,就像物件一样有着键名和键值,在PHP 里面你很简单的就能靠阵列(Array)办到。

PHP

$data = ['username' => 'YamiOdymel',
         'password' => '2016 Spring'];

echo $data["username"]; // 輸出:YamiOdymel  

Golang

真是太棒了,那么Golang呢?用map是差不多啦。如果有必要的话,你可以稍微复习一下先前提到的「多资料储存型态-Stores」。

data := map[string]string{  
           "username": "YamiOdymel", 
           "password": "2016 Spring"}

fmt.Println(data["username"]) // 輸出:YamiOdymel  

是否存在-Isset

你很常会在PHP里面用isset()检查一个索引是否存在,不是吗?

PHP

// 如果 $data['username'] 存在
if(isset($data['username'])) {  
    $username = $data['username'];
}

Golang

在Golang里面很简单的能够这样办到(仅适用于map)。

username, exists := data["username"]

if !exists {  
    fmt.Printf("你要找的資料不存在。")
}

指针-Pointer

指针(有时也做参照)是一个像是「变数别名」的方法,这种方法让你不用整天覆盖旧的变数,让我们假设A = 1; B = A;这个时候B会复制一份A且两者不相干,倘若你希望修改B的时候实际上也会修改到A的值,就会需要指针。

指针比起复制一个变数,他会建立一个指向到某个变数的记忆体位置,这也就是为什么你改变指针,实际上是在改变某个变数。

PHP

function zero(&$number) { // & 即是指針  
    $number = 0;
}

$A = 5;
zero($A);

echo $A; // 輸出:0  

Golang

在Golang你需要用上*还有&符号。

func zero(number *int) {  
    number = 0
}

func main() {  
    A := 5;
    zero(&A)

    fmt.Printf("%d", A) // 輸出:0
}

错误处理-Error Exception

有些时候你会回传一个阵列,这个阵列里面可能有资料还有错误代号,而你会用条件式判断错误代号是否非空值。

PHP

function foo($number) {  
    if($number !== 1)
        return ['number' => -1, 
                'error'  => '$number is not 1'];

    return ['number' => $number, 
            'error'  => null];
}

$bar = foo(0);

if($bar['error'])  
    echo $bar['number'], $bar['error']; // 輸出:-1
                                        //      $number is not 1

Golang

在Golang中函式可以一次回传多个值。为此,你不需要真的回传一个阵列,不过要注意的是你将会回传一个属于error资料型态的错误,所以你需要引用errors套件来帮助你做这件事。

该注意的是Golang没有try .. catch,因为Golang推荐这种错误处理方式,你应该在每一次执行可能会发生错误的程式时就处理错误,而非后来用try到处包覆你的程式。

import "errors"

func foo(number int) (int, error) {  
    if number != 1 {
        return -1, errors.New("$number is not 1")
    }
    return number, nil
}

if bar, err := foo(0); err != nil {  
    fmt.Println(bar, err) // 輸出:-1
                          //      $number is not 1
}

if条件式里宣告变数会让你只能在if内部使用这个变数,而不会污染到全域范围。

抛出和捕捉异常-Try & Catch

也许你在PHP中更常用的会是try .. catch,在大型商业逻辑时经常看见如此地用法,实际上这种用法令人感到聒噪(因为你会需要一堆try区块):

PHP

function foo($number) {  
    if($number < 10)
        throw new Exception('$number is less than 10');
    else if($number > 10)
        throw new Exception('$number is greater than 10');
}

try {  
    foo(9);
} catch(Exception $e) {
    echo $e->getMessage(); // 輸出:$number is less than 10
}

try {  
    foo(11);
} catch(Exception $e) {
    echo $e->getMessage(); // 輸出:$number is greater than 10
}

Golang

Golang中并没有try .. catch,实际上Golang也不鼓励这种行为(Golang推荐逐一处理错误的方式),倘若你真想办倒像是捕捉异常这样的方式,你确实可以使用Golang中另类处理错误的方式(可以的话尽量避免使用这种方式):panic(), recover(), defer

你可以把panic()当作是throw(丢出错误),而这跟PHP的exit()有87%像,一但你执行了panic()你的程式就会宣告而终,但是别担心,因为程式结束的时候会呼叫defer,所以我们接下来要在defer停止panic()

关于defer上述已经有提到了,他是一个反向执行的宣告,会在函式结束后被执行,当你呼叫了panic()结束程式的时候,也就会开始执行defer,所以我们要在defer内使用recover()让程式不再继续进行结束动作,这就像是捕捉异常。

recover()可以看作catch(捕捉),我们要在defer里面用recover()解决panic(),如此一来程式就会回归正常而不会被结束。

// 建立一個模仿 try&catch 的函式供稍後使用
func try(fn func(), handler func(interface{})) {  
    // 這不會馬上被執行,但當 panic 被執行就會結束程式,結束程式就必定會呼叫 defer
    defer func() { 
        // 透過 recover 來從 panic 狀態中恢復,並呼叫捕捉函式
        if err := recover(); err != nil {
            handler(err)
        }
    }()
    // 執行可能帶有 panic 的程式
    fn()
}

func foo(number int) {  
    if number < 10 {
        panic("number is less than 10")
    }
    if number > 10 {
        panic("number is greater than 10")
    }
}

func main() {  
    try(func() {
        foo(9)
    }, func(e interface{}) {
        fmt.Println(e) // 輸出:number is less than 10
    })

    try(func() {
        foo(11)
    }, func(e interface{}) {
        fmt.Println(e) // 輸出:number is greater than 10
    })
}

套件/汇入/汇出-Package / Import / Export

还记得在PHP里要引用一堆档案的日子吗?到处可见的require()或是include()?到了Golang这些都不见了,取而代之的是「套件(Package)」。现在让我们来用PHP解释一下。

PHP

// a.php
<?php  
    $foo = "bar";
?>

// index.php
<?php  
    include "a.php";

    echo $foo; // 輸出:bar
?>

这看起来很正常对吧?但假设你有一堆档案,这马上就成了Include Hell,让我们看看Golang怎么透过「套件」解决这个问题。

Golang

// a.go
package main

var foo string = "bar"  

// main.go
package main

import "fmt"

func main() {  
    fmt.Println(foo) // 輸出:bar
}

蛤???杀小???」你可能如此地说道。是的,main.go中除了引用fmt套件(为了要输出结果用的套件)之外完全没有引用到a.go

蛤???杀小??????」你仿佛回到了几秒钟前的自己。

既然没有引用其他档案,为什么main.go可以输出foo呢?注意到了吗,两者都是属于main套件,因此他们共享同一个区域,所以接下来要介绍的是什么叫做「套件」。

套件-Package

套件是每一个.go档案都必须声明在Golang原始码中最开端的东西,像下面这样:

package main  

这意味着目前的档案是属于main套件(你也可以依照你的喜好命名),那么要如何让同个套件之间的函式沟通呢?

PHP

// a.php
<?php  
    function foo() {
        // ...
    }
?>

// index.php
<?php  
    include "a.php";

    foo();
?>

Golang

接着是Golang;注意!你不需要引用任何档案,因为下列两个档案同属一个套件。

// a.go
package main

func foo() {  
    // ...
}

// main.go
package main

func main() {  
    foo()
}

一个由「套件」所掌握的世界,比起PHP的include()require()还要好太多了,对吗?

汇入-Import

在Golang 中没有引用单独档案的方式,你必须汇入一整个套件,而且你要记住:「一定你汇入了,你就一定要使用它」,像下面这样。

package main

import (  
    "fmt"                           // 引用底層套件
    "time"                          // 這也是底層套件
    "github.com/yamiodymel/teameow" // 來自 Github 的 "teameow" 套件
)

func main() {  
    // 然後像下面這樣使用你剛匯入的套件
    fmt.XXX()
    time.XXX()
    teameow.XXX()
}

假如你不希望使用你汇入的套件,你只是为了要触发那个套件的main()函式而引用的话⋯⋯,那么你可以在前面加上一个底线(_)。

import (  
    _ "fmt"
)

如果你的套件出现了名称冲突,你可以在套件来源前面给他一个新的名称。

import (  
    "github.com/karisu/teameow"
    neko "github.com/yamiodymel/teameow"
)

func main() {  
    teameow.XXX()
    neko.XXX()
}

汇出-Export

现在你知道可以汇入套件了,那么什么是「汇出」?同个套件内的函式还有共享变数确实可以直接用,但那并不表示可以给其他套件使用,其方法取决于函式/变数的「开头大小写」

是的。Golang依照一个函式/变数的开头大小写决定这个东西是否可供「汇出」

// a.go
package hello

// 注意:這裡的 Foo 的開頭字母是大寫!
var Foo string = "bar"

// 注意:這個 World 函式的開頭字母是大寫!
func World() {  
    // ...
}

// b.go
package test

import (  
    "hello"
    "fmt"
)

func main() {  
    fmt.Println(hello.Foo) // 輸出:bar

    hello.World()
}

这用在区别函式的时候格外有用,因为小写开头的任何事物都是不供汇出的,反之,大写开头的任何事物都是用来汇出供其他套件使用的。

一开始可能会觉得这是什么奇异的规定,但写久之后,你就能发现比起JavaScript和Python以「底线为开头的命名方式」还要来得更好;比起成天宣告publicprivateprotected还要来得更快。

类别-Class

在Golang 中没有类别,但有所谓的「建构体(Struct)」和「接口(Interface)」,这就能够满足几乎所有的需求了,这也是为什么我认为Golang 很简洁却又很强大的原因。

让我们先用PHP 建立一个类别,然后看看Golang 怎么解决这个问题。

PHP

class Foobar {  
    public $a = "hello, world";

    public function test() {
        echo $this->a;
    }
}

$b = new Foobar();
$b->test(); // 輸出:hello, world!

Golang

虽然Golang没有类别,但是「建构体(Struct)」就十分地堪用了,首先你要知道在Golang中「类别」的成员还有方法都是在「类别」外面所定义的,这跟PHP在类别内定义的方式有所不同,在Golang中还有一点,那就是他们没有publicprivateprotected的种类。

// 先定義一個 Foobar 建構體,然後有個叫做 a 的字串成員
type Foobar struct {  
    a string
}

// 定義一個屬於 Foobar 的 test 方法
func (f *Foobar) test () {  
    // 接收來自 Foobar 的 a(等同於 PHP 的 `$this->a`)
    fmt.Println(f.a)
}

b := &Foobar{a: "hello, world!"}  
b.test() // 輸出:hello, world!  

建构子-Constructor

在PHP中,当有一个类别被new的时候会自动执行该类别内的建构子(__construct()),通常你会用这个来初始化一些类别内部的值。

PHP

class Test{  
    public $a;

    function __construct() {
        $this->a = "foobar";
    }

    function show() {
        echo $this->a;
    }
}

$b = new Test();
$b->show(); // 輸出:foobar

Golang

但是在Golang 里因为没有类别,也就没有建构子,不巧的是建构体本身也不带有建构子的特性,这个时候你只能自己在外部建立一个建构用函式。

type Test struct {  
    a string
}

func (t *Test) show() {  
    fmt.Println(t.a)
}

// 用來建構 Test 的假建構子
func newTest() (test *Test) {  
    test = &Test{a: "foobar"}

    // 這裡會回傳一個型態是 *Test 建構體的 test 變數
    return
}

b := newTest()  
b.show() // 輸出:foobar  

嵌入-Embed

让我们假设你有两个类别,你会把其中一个类别传入到另一个类别里面使用,废话不多说!先上个PHP 范例(为了简短篇幅我省去了换行)。

PHP

class Foo {  
    public $msg = "Hello, world!";
}

class Bar {  
    public $foo;

    function __construct($foo){ $this->foo = $foo;    }
    function show()           { echo $this->foo->msg; }
}

$a = new Foo();
$b = new Bar($a);
$b->show(); // 輸出:Hello, world!

Golang

在Golang中你也有相同的用法,但是请记得:「任何东西都是在「类别」外完成建构的」。

type Foo struct {  
    msg string
}

type Bar struct {  
    *Foo
}

func (b *Bar) show() {  
    // Foo 中的 msg 會直接暴露在 Bar 底下
    // 所以你可以直接使用 b.msg
    fmt.Println(b.msg)
}

a := &Foo{msg: "Hello, world!"}  
b := &Bar{a}  
b.show() // 輸出 Hello, world!  

遮蔽-Shadowing

在PHP 中没有相关的范例,这部分会以刚才「嵌入」章节中的Golang 范例作为解说对象。

你可以看见Golang在进行Foo嵌入Bar的时候,会自动将Foo的成员暴露在Bar底下,那么假设「双方之间有相同的成员名称」呢?

这个时候被嵌入的成员就会被「遮蔽」,下面是个实际范例,还有你如何解决遮蔽问题:

type Foo struct {  
    msg string
}

type Bar struct {  
    *Foo
    msg string // 遮蔽了 Foo 的 msg
}

a := &Foo{msg: "Hello, world!"}  
b := &Bar{Foo: a, msg: "Moon, Dalan!"}

fmt.Println(b.msg)     // 輸出:Moon, Dalan!  
fmt.Println(b.Foo.msg) // 輸出:Hello, world!  

多形-Polymorphism

虽然都是呼叫同一个函式,但是这个函式可以针对不同的资料来源做出不同的举动,这就是多形。你也能够把这看作是:「讯息的意义由接收者定义,而不是传送者」。

目前PHP 中没有真正的「多形」,不过你仍可以做出同样的东西。

PHP

class Foo{ public $msg = "hello";  }  
class Bar{ public $msg = "world!"; }

class Handler {  
    public function process($class) {
        switch(get_class($class)) {
            // 依照不同的資料類型做出不同的舉動
            case 'Foo':
                echo '處理 Foo | ' . $class->msg . ', world!';
                break;

            case 'Bar':
                echo '處理 Bar | ' . 'hello, ' . $class->msg;
                break;
        }
    }
}

$foo = new Foo();
$bar = new Bar();
$handler = new Handler();

// 雖然都是同個函式,但是可以處理不同資料
$handler->process($foo); // 輸出:處理 Foo | hello, world!
$handler->process($bar); // 輸出:處理 Bar | hello, world!

Golang

嗯⋯⋯那么Golang呢?实际上更简单而且更有条理了,在Golang中有interface可以帮忙完成这个工作。

type Foo struct {  
    msg string
}

type Bar struct {  
    msg string
}

// 透過 Handler 實作 process
type Handler interface {  
    process()
}

// 處理 Foo 資料的 process
func (f Foo) process() {  
    fmt.Printf("處理 Foo | %s, world!", f.msg)
}

// 處理 Bar 資料的 process
func (b Bar) process() {  
    fmt.Printf("處理 Bar | hello, %s", b.msg)
}

foo := Foo{msg: "hello"}  
bar := Bar{msg: "world!"}

// 雖然都是同個函式,但是可以處理不同資料
Handler.process(foo) // 輸出:處理 Foo | hello, world!  
Handler.process(bar) // 輸出:處理 Bar | hello, world!  

如果你对Interface还不熟悉,可以试着查看「解释Golang中的Interface到底是什么」文章。

谢谢你看到这里,可惜这篇文章却没有说出Golang 最重要的卖点:「Goroutine」和「Channel」

Android+GoLang+SprintBoot探讨群:186305789(疯狂的程序员),绝影大神在等你

个人兴趣网站:zero接码平台

个人兴趣网站:猿指


Comments

comments powered by zero