言

編寫條件分支代碼是編碼過程中不可或缺的一部分。

如果用道路來做比喻，現(xiàn)實世界中的代碼從來都不是一條筆直的高速公路，而更像是由無數(shù)個岔路口組成的某個市區(qū)地圖。我們編碼者就像是駕駛員，需要告訴我們的程序，下個路口需要往左還是往右。

編寫優(yōu)秀的條件分支代碼非常重要，因為糟糕、復雜的分支處理非常容易讓人困惑，從而降低代碼質量。所以，這篇文章將會重點談談在 Python 中編寫分支代碼應該注意的地方。

Python 里的分支代碼

Python 支持最為常見的 if/else 條件分支語句，不過它缺少在其他編程語言中常見的 switch/case 語句。

除此之外，Python 還為 for/while 循環(huán)以及 try/except 語句提供了 else 分支，在一些特殊的場景下，它們可以大顯身手。

下面我們從 最佳實踐、常見技巧、常見陷阱 三個方面講一下如果編寫優(yōu)秀的條件分支代碼。

最佳實踐

1. 避免多層分支嵌套

如果這篇文章只能刪減成一句話就結束，那么那句話一定是**“要竭盡所能的避免分支嵌套”**。

過深的分支嵌套是很多編程新手最容易犯的錯誤之一。假如有一位新手 JavaScript 程序員寫了很多層分支嵌套，那么你可能會看到一層又一層的大括號：if { if { if { ... }}}。俗稱 “嵌套 if 地獄（Nested If Statement Hell）”。

但是因為 Python 使用了縮進來代替 {}，所以過深的嵌套分支會產(chǎn)生比其他語言下更為嚴重的后果。比如過多的縮進層次很容易就會讓代碼超過 PEP8 中規(guī)定的每行字數(shù)限制。讓我們看看這段代碼：

def buy_fruit(nerd, store):
    """去水果店買蘋果
    
    - 先得看看店是不是在營業(yè)
    - 如果有蘋果的話，就買 1 個
    - 如果錢不夠，就回家取錢再來
    """
    if store.is_open():
        if store.has_stocks("apple"):
            if nerd.can_afford(store.price("apple", amount=1)):
                nerd.buy(store, "apple", amount=1)
                return
            else:
                nerd.go_home_and_get_money()
                return buy_fruit(nerd, store)
        else:
            raise MadAtNoFruit("no apple in store!")
    else:
        raise MadAtNoFruit("store is closed!")

上面這段代碼最大的問題，就是過于直接翻譯了原始的條件分支要求，導致短短十幾行代碼包含了有三層嵌套分支。

這樣的代碼可讀性和維護性都很差。不過我們可以用一個很簡單的技巧：“提前結束” 來優(yōu)化這段代碼：

def buy_fruit(nerd, store):
    if not store.is_open():
        raise MadAtNoFruit("store is closed!")

    if not store.has_stocks("apple"):
        raise MadAtNoFruit("no apple in store!")

    if nerd.can_afford(store.price("apple", amount=1)):
        nerd.buy(store, "apple", amount=1)
        return
    else:
        nerd.go_home_and_get_money()
        return buy_fruit(nerd, store)

“提前結束”指：在函數(shù)內(nèi)使用 return 或 raise 等語句提前在分支內(nèi)結束函數(shù)。 比如，在新的 buy_fruit 函數(shù)里，當分支條件不滿足時，我們直接拋出異常，結束這段代碼分支。這樣的代碼沒有嵌套分支，更直接也更易讀。

2. 封裝那些過于復雜的邏輯判斷

如果條件分支里的表達式過于復雜，出現(xiàn)了太多的 not/and/or，那么這段代碼的可讀性就會大打折扣，比如下面這段代碼：

# 如果活動還在開放，并且活動剩余名額大于 10，為所有性別為女性，或者級別大于 3
# 的活躍用戶發(fā)放 10000 個金幣
if activity.is_active and activity.remaining > 10 and \
        user.is_active and (user.sex == 'female' or user.level > 3):
    user.add_coins(10000)
    return

對于這樣的代碼，我們可以考慮將具體的分支邏輯封裝成函數(shù)或者方法，來達到簡化代碼的目的：

if activity.allow_new_user() and user.match_activity_condition():
    user.add_coins(10000)
    return

事實上，將代碼改寫后，之前的注釋文字其實也可以去掉了。因為后面這段代碼已經(jīng)達到了自說明的目的。 至于具體的 什么樣的用戶滿足活動條件？ 這種問題，就應由具體的 match_activity_condition() 方法來回答了。

Hint: 恰當?shù)姆庋b不光直接改善了代碼的可讀性，事實上，如果上面的活動判斷邏輯在代碼中出現(xiàn)了不止一次的話，封裝更是必須的。不然重復代碼會極大的破壞這段邏輯的可維護性。

3. 留意不同分支下的重復代碼

重復代碼是代碼質量的天敵，而條件分支語句又非常容易成為重復代碼的重災區(qū)。所以，當我們編寫條件分支語句時，需要特別留意，不要生產(chǎn)不必要的重復代碼。

讓我們看下這個例子：

# 對于新用戶，創(chuàng)建新的用戶資料，否則更新舊資料
if user.no_profile_exists:
    create_user_profile(
        username=user.username,
        email=user.email,
        age=user.age,
        address=user.address,
        # 對于新建用戶，將用戶的積分置為 0
        points=0,
        created=now(),
    )
else:
    update_user_profile(
        username=user.username,
        email=user.email,
        age=user.age,
        address=user.address,
        updated=now(),
    )

在上面的代碼中，我們可以一眼看出，在不同的分支下，程序調用了不同的函數(shù)，做了不一樣的事情。但是，因為那些重復代碼的存在，我們卻很難簡單的區(qū)分出，二者的不同點到底在哪。

其實，得益于 Python 的動態(tài)特性，我們可以簡單的改寫一下上面的代碼，讓可讀性可以得到顯著的提升：

if user.no_profile_exists:
    profile_func = create_user_profile
    extra_args = {'points': 0, 'created': now()}
else:
    profile_func = update_user_profile
    extra_args = {'updated': now()}

profile_func(
    username=user.username,
    email=user.email,
    age=user.age,
    address=user.address,
    **extra_args
)

當你編寫分支代碼時，請額外關注由分支產(chǎn)生的重復代碼塊，如果可以簡單的消滅它們，那就不要遲疑。

4. 謹慎使用三元表達式

三元表達式是 Python 2.5 版本后才支持的語法。在那之前，Python 社區(qū)一度認為三元表達式?jīng)]有必要，我們需要使用 x and a or b 的方式來模擬它。

事實是，在很多情況下，使用普通的 if/else 語句的代碼可讀性確實更好。盲目追求三元表達式很容易誘惑你寫出復雜、可讀性差的代碼。

所以，請記得只用三元表達式處理簡單的邏輯分支。

language = "python" if you.favor("dynamic") else "golang"

對于絕大多數(shù)情況，還是使用普通的 if/else 語句吧。

常見技巧

1. 使用“德摩根定律”

在做分支判斷時，我們有時候會寫成這樣的代碼：

# 如果用戶沒有登錄或者用戶沒有使用 chrome，拒絕提供服務
if not user.has_logged_in or not user.is_from_chrome:
    return "our service is only available for chrome logged in user"

第一眼看到代碼時，是不是需要思考一會才能理解它想干嘛？這是因為上面的邏輯表達式里面出現(xiàn)了 2 個 not 和 1 個 or。而我們?nèi)祟惽『貌簧瞄L處理過多的“否定”以及“或”這種邏輯關系。

這個時候，就該 德摩根定律 出場了。通俗的說，德摩根定律就是 not A or not B 等價于 not (A and B)。通過這樣的轉換，上面的代碼可以改寫成這樣：

if not (user.has_logged_in and user.is_from_chrome):
    return "our service is only available for chrome logged in user"

怎么樣，代碼是不是易讀了很多？記住德摩根定律，很多時候它對于簡化條件分支里的代碼邏輯非常有用。

2. 自定義對象的“布爾真假”

我們常說，在 Python 里，“萬物皆對象”。其實，不光“萬物皆對象”，我們還可以利用很多魔法方法*（文檔中稱為：user-defined method）*，來自定義對象的各種行為。我們可以用很多在別的語言里面無法做到、有些魔法的方式來影響代碼的執(zhí)行。

比如，Python 的所有對象都有自己的“布爾真假”：

• 布爾值為假的對象：None, 0, False, [], (), {}, set(), frozenset(), ... ...
• 布爾值為真的對象：非 0 的數(shù)值、True，非空的序列、元組，普通的用戶類實例，... ...

通過內(nèi)建函數(shù) bool()，你可以很方便的查看某個對象的布爾真假。而 Python 進行條件分支判斷時用到的也是這個值：

>>> bool(object())
True

重點來了，雖然所有用戶類實例的布爾值都是真。但是 Python 提供了改變這個行為的辦法：自定義類的 __bool__ 魔法方法 （在 Python 2.X 版本中為 __nonzero__）。當類定義了 __bool__ 方法后，它的返回值將會被當作類實例的布爾值。

另外，__bool__ 不是影響實例布爾真假的唯一方法。如果類沒有定義 __bool__ 方法，Python 還會嘗試調用 __len__ 方法*（也就是對任何序列對象調用 len 函數(shù)）*，通過結果是否為 0 判斷實例真假。

那么這個特性有什么用呢？看看下面這段代碼：

class UserCollection(object):

    def __init__(self, users):
        self._users = users


users = UserCollection([piglei, raymond])

if len(users._users) > 0:
    print("There's some users in collection!")

上面的代碼里，判斷 UserCollection 是否有內(nèi)容時用到了 users._users 的長度。其實，通過為 UserCollection 添加 __len__ 魔法方法，上面的分支可以變得更簡單：

class UserCollection:

    def __init__(self, users):
        self._users = users

    def __len__(self):
        return len(self._users)


users = UserCollection([piglei, raymond])

# 定義了 __len__ 方法后，UserCollection 對象本身就可以被用于布爾判斷了
if users:
    print("There's some users in collection!")

通過定義魔法方法 __len__ 和 __bool__ ，我們可以讓類自己控制想要表現(xiàn)出的布爾真假值，讓代碼變得更 pythonic。

3. 在條件判斷中使用 all() / any()

all() 和 any() 兩個函數(shù)非常適合在條件判斷中使用。這兩個函數(shù)接受一個可迭代對象，返回一個布爾值，其中：

• all(seq)：僅當 seq 中所有對象都為布爾真時返回 True，否則返回 False
• any(seq)：只要 seq 中任何一個對象為布爾真就返回 True，否則返回 False

假如我們有下面這段代碼：

def all_numbers_gt_10(numbers):
    """僅當序列中所有數(shù)字大于 10 時，返回 True
    """
    if not numbers:
        return False

    for n in numbers:
        if n <= 10:
            return False
    return True

如果使用 all() 內(nèi)建函數(shù)，再配合一個簡單的生成器表達式，上面的代碼可以寫成這樣：

def all_numbers_gt_10_2(numbers):
    return bool(numbers) and all(n > 10 for n in numbers)

簡單、高效，同時也沒有損失可用性。

4. 使用 try/while/for 中 else 分支

讓我們看看這個函數(shù)：

def do_stuff():
    first_thing_successed = False
    try:
        do_the_first_thing()
        first_thing_successed = True
    except Exception as e:
        print("Error while calling do_some_thing")
        return

    # 僅當 first_thing 成功完成時，做第二件事
    if first_thing_successed:
        return do_the_second_thing()

在函數(shù) do_stuff 中，我們希望只有當 do_the_first_thing() 成功調用后*（也就是不拋出任何異常）*，才繼續(xù)做第二個函數(shù)調用。為了做到這一點，我們需要定義一個額外的變量 first_thing_successed 來作為標記。

其實，我們可以用更簡單的方法達到同樣的效果：

def do_stuff():
    try:
        do_the_first_thing()
    except Exception as e:
        print("Error while calling do_some_thing")
        return
    else:
        return do_the_second_thing()

在 try 語句塊最后追加上 else 分支后，分支下的do_the_second_thing() 便只會在 try 下面的所有語句正常執(zhí)行（也就是沒有異常，沒有 return、break 等）完成后執(zhí)行。

類似的，Python 里的 for/while 循環(huán)也支持添加 else 分支，它們表示：當循環(huán)使用的迭代對象被正常耗盡、或 while 循環(huán)使用的條件變量變?yōu)?False 后才執(zhí)行 else 分支下的代碼。

常見陷阱

1. 與 None 值的比較

在 Python 中，有兩種比較變量的方法：== 和 is，二者在含義上有著根本的區(qū)別：

• ==：表示二者所指向的的值是否一致
• is：表示二者是否指向內(nèi)存中的同一份內(nèi)容，也就是 id(x) 是否等于 id(y)

None 在 Python 語言中是一個單例對象，如果你要判斷某個變量是否為 None 時，記得使用 is 而不是 ==，因為只有 is 才能在嚴格意義上表示某個變量是否是 None。

否則，可能出現(xiàn)下面這樣的情況：

>>> class Foo(object):
...     def __eq__(self, other):
...         return True
...
>>> foo = Foo()
>>> foo == None
True

在上面代碼中，F(xiàn)oo 這個類通過自定義 __eq__ 魔法方法的方式，很容易就滿足了 == None 這個條件。

所以，當你要判斷某個變量是否為 None 時，請使用 is 而不是 ==。

2. 留意 and 和 or 的運算優(yōu)先級

看看下面這兩個表達式，猜猜它們的值一樣嗎？

>>> (True or False) and False
>>> True or False and False

答案是：不一樣，它們的值分別是 False 和 True，你猜對了嗎？

問題的關鍵在于：and 運算符的優(yōu)先級大于 or。因此上面的第二個表達式在 Python 看來實際上是 True or (False and False)。所以結果是 True 而不是 False。

在編寫包含多個 and 和 or 的表達式時，請額外注意 and 和 or 的運算優(yōu)先級。即使執(zhí)行優(yōu)先級正好是你需要的那樣，你也可以加上額外的括號來讓代碼更清晰。

結語

代碼內(nèi)的分支語句不可避免，我們在編寫代碼時，需要尤其注意它的可讀性，避免對其他看到代碼的人造成困擾。

看完文章的你，有沒有什么想吐槽的？請留言告訴我吧。

源：《JavaScript設計模式與開發(fā)實踐》

模式和重構之間有著一種與生俱來的關系。從某種角度來看，設計模式的目的就是為許多重構行為提供目標。

1.提煉函數(shù)

在JavaScript開發(fā)中，我們大部分時間都在與函數(shù)打交道，所以我們希望這些函數(shù)有著良好的命名，函數(shù)體內(nèi)包含的邏輯清晰明了。如果一個函數(shù)過長，不得不加上若干注釋才能讓這個函數(shù)顯得易讀一些，那這些函數(shù)就很有必要進行重構。

如果在函數(shù)中有一段代碼可以被獨立出來，那我們最好把這些代碼放進另外一個獨立的函數(shù)中。這是一種很常見的優(yōu)化工作，這樣做的好處主要有以下幾點。

• 避免出現(xiàn)超大函數(shù)。
• 獨立出來的函數(shù)有助于代碼復用。
• 獨立出來的函數(shù)更容易被覆寫。
• 獨立出來的函數(shù)如果擁有一個良好的命名，它本身就起到了注釋的作用。

比如在一個負責取得用戶信息的函數(shù)里面，我們還需要打印跟用戶信息有關的log，那么打印log的語句就可以被封裝在一個獨立的函數(shù)里：

var getUserInfo = function(){
    ajax( 'http:// xxx.com/userInfo', function( data ){
        console.log( 'userId: ' + data.userId );
        console.log( 'userName: ' + data.userName );
        console.log( 'nickName: ' + data.nickName );
    });
};

改成：

var getUserInfo = function(){
    ajax( 'http:// xxx.com/userInfo', function( data ){
        printDetails( data );
    });
};

var printDetails = function( data ){
    console.log( 'userId: ' + data.userId );
    console.log( 'userName: ' + data.userName );
    console.log( 'nickName: ' + data.nickName );
};

2.合并重復的條件片段

如果一個函數(shù)體內(nèi)有一些條件分支語句，而這些條件分支語句內(nèi)部散布了一些重復的代碼，那么就有必要進行合并去重工作。假如我們有一個分頁函數(shù)paging，該函數(shù)接收一個參數(shù)currPage，currPage表示即將跳轉的頁碼。在跳轉之前，為防止currPage傳入過小或者過大的數(shù)字，我們要手動對它的值進行修正，詳見如下偽代碼：

var paging = function( currPage ){
    if ( currPage <= 0 ){
        currPage = 0;
        jump( currPage );    // 跳轉
    }else if ( currPage >= totalPage ){
        currPage = totalPage;
        jump( currPage );    // 跳轉
    }else{
        jump( currPage );    // 跳轉
    }
};

可以看到，負責跳轉的代碼jump( currPage )在每個條件分支內(nèi)都出現(xiàn)了，所以完全可以把這句代碼獨立出來：

var paging = function( currPage ){
    if ( currPage <= 0 ){
        currPage = 0;
    }else if ( currPage >= totalPage ){
        currPage = totalPage;
    }
    jump( currPage );    // 把jump函數(shù)獨立出來
};

3.把條件分支語句提煉成函數(shù)

在程序設計中，復雜的條件分支語句是導致程序難以閱讀和理解的重要原因，而且容易導致一個龐大的函數(shù)。假設現(xiàn)在有一個需求是編寫一個計算商品價格的getPrice函數(shù)，商品的計算只有一個規(guī)則：如果當前正處于夏季，那么全部商品將以8折出售。代碼如下：

var getPrice = function( price ){
    var date = new Date();
    if ( date.getMonth() >= 6 && date.getMonth() <= 9 ){    // 夏天
        return price * 0.8;
    }
    return price;
};

觀察這句代碼：

if ( date.getMonth() >= 6 && date.getMonth() <= 9 ){
    // ...
}

這句代碼要表達的意思很簡單，就是判斷當前是否正處于夏天（7~10月）。盡管這句代碼很短小，但代碼表達的意圖和代碼自身還存在一些距離，閱讀代碼的人必須要多花一些精力才能明白它傳達的意圖。其實可以把這句代碼提煉成一個單獨的函數(shù)，既能更準確地表達代碼的意思，函數(shù)名本身又能起到注釋的作用。代碼如下：

var isSummer = function(){
    var date = new Date();
    return date.getMonth() >= 6 && date.getMonth() <= 9;
};

var getPrice = function( price ){
    if ( isSummer() ){    // 夏天
        return price * 0.8;
    }
    return price;
};

4.合理使用循環(huán)

在函數(shù)體內(nèi)，如果有些代碼實際上負責的是一些重復性的工作，那么合理利用循環(huán)不僅可以完成同樣的功能，還可以使代碼量更少。下面有一段創(chuàng)建XHR對象的代碼，為了簡化示例，我們只考慮版本9以下的IE瀏覽器，代碼如下：

var createXHR = function(){
    var xhr;
    try{
        xhr = new ActiveXObject( 'MSXML2.XMLHttp.6.0' );
    }catch(e){
        try{
            xhr = new ActiveXObject( 'MSXML2.XMLHttp.3.0' );
        }catch(e){
            xhr = new ActiveXObject( 'MSXML2.XMLHttp' );
        }
    }
    return xhr;
};

var xhr = createXHR();

下面我們靈活地運用循環(huán)，可以得到跟上面代碼一樣的效果：

var createXHR = function(){
var versions= [ 'MSXML2.XMLHttp.6.0ddd', 'MSXML2.XMLHttp.3.0', 'MSXML2.XMLHttp' ];
    for ( var i = 0, version; version = versions[ i++ ]; ){
        try{
            return new ActiveXObject( version );
        }catch(e){

        }
    }
};

var xhr = createXHR();

5.提前讓函數(shù)退出代替嵌套條件分支

許多程序員都有這樣一種觀念：“每個函數(shù)只能有一個入口和一個出口?！爆F(xiàn)代編程語言都會限制函數(shù)只有一個入口。但關于“函數(shù)只有一個出口”，往往會有一些不同的看法。

下面這段偽代碼是遵守“函數(shù)只有一個出口的”的典型代碼：

var del = function( obj ){
    var ret;
    if ( !obj.isReadOnly ){    // 不為只讀的才能被刪除
        if ( obj.isFolder ){    // 如果是文件夾
            ret = deleteFolder( obj );
        }else if ( obj.isFile ){    // 如果是文件
            ret = deleteFile( obj );
        }
    }
    return ret;
};

嵌套的條件分支語句絕對是代碼維護者的噩夢，對于閱讀代碼的人來說，嵌套的if、else語句相比平鋪的if、else，在閱讀和理解上更加困難，有時候一個外層if分支的左括號和右括號之間相隔500米之遠。用《重構》里的話說，嵌套的條件分支往往是由一些深信“每個函數(shù)只能有一個出口的”程序員寫出的。但實際上，如果對函數(shù)的剩余部分不感興趣，那就應該立即退出。引導閱讀者去看一些沒有用的else片段，只會妨礙他們對程序的理解。

于是我們可以挑選一些條件分支，在進入這些條件分支之后，就立即讓這個函數(shù)退出。要做到這一點，有一個常見的技巧，即在面對一個嵌套的if分支時，我們可以把外層if表達式進行反轉。重構后的del函數(shù)如下：

var del = function( obj ){
    if ( obj.isReadOnly ){    // 反轉if表達式
        return;
    }
    if ( obj.isFolder ){
        return deleteFolder( obj );
    }
    if ( obj.isFile ){
        return deleteFile( obj );
    }
};

6.傳遞對象參數(shù)代替過長的參數(shù)列表

有時候一個函數(shù)有可能接收多個參數(shù)，而參數(shù)的數(shù)量越多，函數(shù)就越難理解和使用。使用該函數(shù)的人首先得搞明白全部參數(shù)的含義，在使用的時候，還要小心翼翼，以免少傳了某個參數(shù)或者把兩個參數(shù)搞反了位置。如果我們想在第3個參數(shù)和第4個參數(shù)之中增加一個新的參數(shù)，就會涉及許多代碼的修改，代碼如下：

var setUserInfo = function( id, name, address, sex, mobile, qq ){
    console.log( 'id= ' + id );
    console.log( 'name= ' +name );
    console.log( 'address= ' + address );
    console.log( 'sex= ' + sex );
    console.log( 'mobile= ' + mobile );
    console.log( 'qq= ' + qq );
};

setUserInfo( 1314, 'sven', 'shenzhen', 'male', '137********', 377876679 )

;

這時我們可以把參數(shù)都放入一個對象內(nèi)，然后把該對象傳入setUserInfo 函數(shù)，setUserInfo函數(shù)需要的數(shù)據(jù)可以自行從該對象里獲取?，F(xiàn)在不用再關心參數(shù)的數(shù)量和順序，只要保證參數(shù)對應的key值不變就可以了：

var setUserInfo = function( obj ){
    console.log( 'id= ' + obj.id );
    console.log( 'name= ' + obj.name );
    console.log( 'address= ' + obj.address );
    console.log( 'sex= ' + obj.sex );
    console.log( 'mobile= ' + obj.mobile );
    console.log( 'qq= ' + obj.qq );
};

setUserInfo({
    id: 1314,
    name: 'sven',
    address: 'shenzhen',
    sex: 'male',
    mobile: '137********',
    qq: 377876679
});

7.盡量減少參數(shù)數(shù)量

如果調用一個函數(shù)時需要傳入多個參數(shù)，那這個函數(shù)是讓人望而生畏的，我們必須搞清楚這些參數(shù)代表的含義，必須小心翼翼地把它們按照順序傳入該函數(shù)。而如果一個函數(shù)不需要傳入任何參數(shù)就可以使用，這種函數(shù)是深受人們喜愛的。在實際開發(fā)中，向函數(shù)傳遞參數(shù)不可避免，但我們應該盡量減少函數(shù)接收的參數(shù)數(shù)量。下面舉個非常簡單的示例。 有一個畫圖函數(shù)draw，它現(xiàn)在只能繪制正方形，接收了3個參數(shù)，分別是圖形的width、heigth以及square：

var draw = function( width, height, square ){};

但實際上正方形的面積是可以通過width和height計算出來的，于是我們可以把參數(shù)square從draw函數(shù)中去掉：

var draw = function( width, height ){
    var square = width * height;
};

假設以后這個draw函數(shù)開始支持繪制圓形，我們需要把參數(shù)width和height換成半徑radius， 但圖形的面積square始終不應該由客戶傳入，而是應該在draw函數(shù)內(nèi)部，由傳入的參數(shù)加上一定的規(guī)則計算得來。此時，我們可以使用策略模式，讓draw函數(shù)成為一個支持繪制多種圖形的函數(shù)。

8.少用三目運算符

有一些程序員喜歡大規(guī)模地使用三目運算符，來代替?zhèn)鹘y(tǒng)的if、else。理由是三目運算符性能高，代碼量少。不過，這兩個理由其實都很難站得住腳。

即使我們假設三目運算符的效率真的比if、else高，這點差距也是完全可以忽略不計的。在實際的開發(fā)中，即使把一段代碼循環(huán)一百萬次，使用三目運算符和使用if、else的時間開銷處在同一個級別里。

同樣，相比損失的代碼可讀性和可維護性，三目運算符節(jié)省的代碼量也可以忽略不計。讓JS文件加載更快的辦法有很多種，如壓縮、緩存、使用CDN和分域名等。把注意力只放在使用三目運算符節(jié)省的字符數(shù)量上，無異于一個300斤重的人把超重的原因歸罪于頭皮屑。

如果條件分支邏輯簡單且清晰，這無礙我們使用三目運算符：

var global = typeof window !== "undefined" ? window : this;

但如果條件分支邏輯非常復雜，如下段代碼所示，那我們最好的選擇還是按部就班地編寫if、else。if、else語句的好處很多，一是閱讀相對容易，二是修改的時候比修改三目運算符周圍的代碼更加方便：

if ( !aup || !bup ) {
    return a === doc ? -1 :
        b === doc ? 1 :
        aup ? -1 :
        bup ? 1 :
        sortInput ?
        ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
        0;
}

9.合理使用鏈式調用

經(jīng)常使用jQuery的程序員相當習慣鏈式調用方法，在JavaScript中，可以很容易地實現(xiàn)方法的鏈式調用，即讓方法調用結束后返回對象自身，如下代碼所示：

var User = function(){
    this.id = null;
    this.name = null;
};

User.prototype.setId = function( id ){
    this.id = id;
    return this;
};

User.prototype.setName = function( name ){
    this.name = name;
    return this;
};

console.log( new User().setId( 1314 ).setName( 'sven' ) );

或者：

var User = {
    id: null,
    name: null,
    setId: function( id ){
        this.id = id;
        return this;
    },
    setName: function( name ){
        this.name = name;
        return this;
    }
};

console.log( User.setId( 1314 ).setName( 'sven' ) );

使用鏈式調用的方式并不會造成太多閱讀上的困難，也確實能省下一些字符和中間變量，但節(jié)省下來的字符數(shù)量同樣是微不足道的。鏈式調用帶來的壞處就是在調試的時候非常不方便，如果我們知道一條鏈中有錯誤出現(xiàn)，必須得先把這條鏈拆開才能加上一些調試log或者增加斷點，這樣才能定位錯誤出現(xiàn)的地方。

如果該鏈條的結構相對穩(wěn)定，后期不易發(fā)生修改，那么使用鏈式調用無可厚非。但如果該鏈條很容易發(fā)生變化，導致調試和維護困難，那么還是建議使用普通調用的形式：

var user = new User();

user.setId( 1314 );
user.setName( 'sven' );

10.分解大型類

在HTML5版“街頭霸王”的第一版代碼中，負責創(chuàng)建游戲人物的Spirit 類非常龐大，不僅要負責創(chuàng)建人物精靈，還包括了人物的攻擊、防御等動作方法，代碼如下：

var Spirit = function( name ){
    this.name = name;
};

Spirit.prototype.attack = function( type ){    // 攻擊
    if ( type === 'waveBoxing' ){
        console.log( this.name + ': 使用波動拳' );
    }else if( type === 'whirlKick' ){
        console.log( this.name + ': 使用旋風腿' );
    }
};

var spirit = new Spirit( 'RYU' );

spirit.attack( 'waveBoxing' );      // 輸出：RYU: 使用波動拳
spirit.attack( 'whirlKick' );    // 輸出：RYU: 使用旋風腿

后來發(fā)現(xiàn)，Spirit.prototype.attack這個方法實現(xiàn)是太龐大了，實際上它完全有必要作為一個單獨的類存在。面向對象設計鼓勵將行為分布在合理數(shù)量的更小對象之中：

var Attack = function( spirit ){
    this.spirit = spirit;
};

Attack.prototype.start = function( type ){
    return this.list[ type ].call( this );
};

Attack.prototype.list = {
    waveBoxing: function(){
        console.log( this.spirit.name + ': 使用波動拳' );
    },
    whirlKick: function(){
        console.log( this.spirit.name + ': 使用旋風腿' );
    }
};

現(xiàn)在的Spirit類變得精簡了很多，不再包括各種各樣的攻擊方法，而是把攻擊動作委托給Attack類的對象來執(zhí)行，這段代碼也是策略模式的運用之一：

var Spirit = function( name ){
    this.name = name;
    this.attackObj = new Attack( this );
};

Spirit.prototype.attack = function( type ){    // 攻擊
    this.attackObj.start( type );
};

var spirit = new Spirit( 'RYU' );

spirit.attack( 'waveBoxing' );    // 輸出：RYU: 使用波動拳
spirit.attack( 'whirlKick' );    // 輸出：RYU: 使用旋風

11.用return退出多重循環(huán)

假設在函數(shù)體內(nèi)有一個兩重循環(huán)語句，我們需要在內(nèi)層循環(huán)中判斷，當達到某個臨界條件時退出外層的循環(huán)。我們大多數(shù)時候會引入一個控制標記變量：

var func = function(){
    var flag = false;
    for ( var i = 0; i < 10; i++ ){
        for ( var j = 0; j < 10; j++ ){
            if ( i * j >30 ){
                flag = true;
                break;
            }
        }
        if ( flag === true ){
            break;
        }
    }
};

第二種做法是設置循環(huán)標記：

var func = function(){
    outerloop:
    for ( var i = 0; i < 10; i++ ){
        innerloop:
        for ( var j = 0; j < 10; j++ ){
            if ( i * j >30 ){
                break outerloop;
            }
        }
    }
};

這兩種做法無疑都讓人頭暈目眩，更簡單的做法是在需要中止循環(huán)的時候直接退出整個方法：

var func = function(){
    for ( var i = 0; i < 10; i++ ){
        for ( var j = 0; j < 10; j++ ){
            if ( i * j >30 ){
                return;
            }
        }
    }
};

當然用return直接退出方法會帶來一個問題，如果在循環(huán)之后還有一些將被執(zhí)行的代碼呢？如果我們提前退出了整個方法，這些代碼就得不到被執(zhí)行的機會：

var func = function(){
    for ( var i = 0; i < 10; i++ ){
        for ( var j = 0; j < 10; j++ ){
            if ( i * j >30 ){
                return;
            }
        }
    }
    console.log( i );    // 這句代碼沒有機會被執(zhí)行
};

為了解決這個問題，我們可以把循環(huán)后面的代碼放到return后面，如果代碼比較多，就應該把它們提煉成一個單獨的函數(shù)：

var print = function( i ){
    console.log( i );
};

var func = function(){
    for ( var i = 0; i < 10; i++ ){
        for ( var j = 0; j < 10; j++ ){
            if ( i * j >30 ){
                return print( i );
            }
        }
    }
};

func();

- END -

. 流程控制

1. 簡介

在Java項目中，大多數(shù)的代碼都是編寫在一個個的類里面。每個類中還有很多個語句，并且會以英文的分號;來表示語句的結束。有些小白會很好奇，這一行行的代碼語句是按照什么順序執(zhí)行的呢？是按照我們看到的從上到下的順序執(zhí)行的嗎？

其實在實際的代碼中，程序經(jīng)常需要進行各種條件判斷、循環(huán)控制等操作，并不是簡單的從上到下機械執(zhí)行。因此，我們的項目中就需要有多種流程控制語句，來實現(xiàn)程序的分支跳轉和循環(huán)等功能。

我們這里所謂的流程控制語句，就是用來控制程序中各語句執(zhí)行順序的語句，它可以把多個語句組合成能夠完成一定功能的邏輯模塊。

那么在Java中，又有哪些具體的流程控制語句呢？請往下看！

2. 分類

Java中的流程控制語句，根據(jù)結構化程序設計的規(guī)范，整體上可以分為3大類：

順序結構 分支結構 循環(huán)結構

接下來壹哥先簡單給大家介紹一下這幾種類型都是啥子意思。

3. 順序結構

順序結構可以說是項目中最簡單、最基本的流程控制語句了。它也沒有特定的語法結構，就是按照代碼默認的先后順序依次執(zhí)行，程序中大多數(shù)的代碼語句都是順序執(zhí)行的。簡單地說，順序結構就是程序里的語句按照從上到下的順序依次執(zhí)行， 如下圖所示：

咱們前面學過的很多個案例，都是最簡單的順序結構語句，例如：

/**
 * @author 一一哥Sun
 */
public class Demo01 {

    public static void main(String[] args) {
        //輸出語句
	//不換行輸出
	System.out.print("Hello");
	System.out.print(" World");
		
	//換行輸出
	System.out.println("你好");
	System.out.println("一一哥");
		
	//標準的錯誤輸出，控制臺會用紅色文字顯示
	System.err.append("標準的錯誤輸出，哈哈哈");
    }

}

4. 分支結構

所謂的分支結構，就是根據(jù)一定的條件，有選擇性地去執(zhí)行某段代碼。在Java中，分支結構分為if…else...和switch-case兩種條件分支語句，其中的if...else...語句就是我們今天要學習的重點，后面壹哥會詳細講解。

5. 循環(huán)結構

循環(huán)結構是在滿足某些條件的情況下，反復執(zhí)行特定的代碼。 在Java中，循環(huán)結構包括while、do…while、for、foreach等4種循環(huán)語句，壹哥會在后續(xù)的文章中進行細講。

二. 條件分支

順序結構沒什么好講的，就是從上到下的寫代碼，所以接下來，壹哥就直接帶各位來學習分支結構里的條件分支。我們在前面說過，分支結構，或者叫做條件分支，其實有兩種情況。一種是if...else...類型的條件分支，一種是switch...case...類型的條件分支，今天我們先來學習if和else的使用。

1. if基本語法

在Java代碼中，如果我們要根據(jù)某個條件來決定是否執(zhí)行一段代碼，就可以考慮使用if語句。if語句的基本語法是：

if(條件表達式){
    //滿足條件時要執(zhí)行的語句 
} 

在上面的語法中，會根據(jù)if(條件表達式)里的計算結果(true或者false)，由JVM決定是否執(zhí)行{}里的代碼塊。如果為true，就執(zhí)行，否則就不執(zhí)行。

本節(jié)內(nèi)容配套視頻鏈接如下：

player.bilibili.com/player.html…

明白了基本的語法之后，接下來我們就可以繼續(xù)學習啦。

2. if的單分支語句

首先我們通過一個簡單的需求，來學習if的單分支語句。所謂的單分支語句，就是說只有一種判斷情況，條件為真就執(zhí)行，否則就不執(zhí)行。比如這個需求：“如果你年滿18歲，就可以攢勁的節(jié)目”。

/**
 * @author 一一哥Sun
 */
public class Demo01 {

    public static void main(String[] args) {
	// if語句
		
	//案例1：如果年齡大于等于18歲，就可以看攢勁的節(jié)目了
	System.out.println("請輸入你的年齡");
		
	//獲取Scanner對象
	Scanner sc=new Scanner(System.in);
	//獲取年齡
	int age = sc.nextInt();
        //如果語句塊{}里面只有一條執(zhí)行語句，{}可以省略，但建議保留。
	if(age >= 18){
            System.out.println("本節(jié)目只對成年人開放，未成年人請在父母陪同下觀看，節(jié)目正在緩沖......");
	}

    	//案例2：如果身高大于180，且體重小于180，就可以當模特        
	System.out.println("請輸入你的身高");
	int height = sc.nextInt();
	System.out.println("請輸入你的體重");
	int weight = sc.nextInt();
        
    	//條件表達式中，可以結合之前學習過的邏輯運算符
        //采用短路與&&，提高效率
	if(height > 180 && weight < 180){
            System.out.println("恭喜你，可以當模特了");
	}
    }
}

另外如果{}語句塊里面只有一條執(zhí)行語句，{}可以省略，但建議保留。因為如果我們采用縮進的格式，很容易把后面的語句都看成是if語句的執(zhí)行塊，所以不推薦忽略花括號的寫法。

單分支語句應對的情況是很簡單的，在實際開發(fā)中可能會很復雜，這就需要使用多分支語句來進行處理。

3. if的多分支語句

3.1 if...else結構

if...else...結構會根據(jù)條件表達式的結果進行判斷，當表達式的結果為true，則執(zhí)行語句塊A；否則執(zhí)行else后面的語句塊B?；菊Z法結構如下：

 if(邏輯條件){ 
     //滿足邏輯條件執(zhí)行的代碼 
 }else{ 
     //不滿足邏輯條件執(zhí)行的代碼 
 }

案例如下：

/**
 * @author 一一哥Sun
 */
public class Demo01 {

    public static void main(String[] args) {
	// if多分支語句
	Scanner sc=new Scanner(System.in);
		
	//案例：如果用戶名為admin、密碼為123456，就跳轉到首頁，否則跳轉到登錄頁面
	System.out.println("請輸入用戶名");
	String username = sc.next();
	System.out.println("請輸入密碼");
	String password = sc.next();

	//equals()比較方法
	if("admin".equals(username) && "123456".equals(password)){
            System.out.println("跳轉首頁");
	}else{
            System.out.println("跳轉登錄頁面");
	}  
    }
}

我們要注意，在java中，"=="比較的是兩個對象的內(nèi)存地址是否相同，String類中的equals()方法比較的是內(nèi)容是否相同。如果是基本數(shù)據(jù)類型，我們可以使用==進行比較；而對于String字符串，一般是使用equals()方法進行比較。

另外我們在使用equals()方法進行比較時，要采用類似 "admin".equals(username) 的寫法，而不要采用username.equals("admin") 的寫法。 因為username對象的值有可能為null，這樣就可能會產(chǎn)生NullPointerException異常。

3.2 if多分支

if多分支就是可以利用多個if ... else if ...else...進行串聯(lián)。多分支可以根據(jù)多個條件表達式的結果進行判斷：

如果條件表達式1的結果為true，則執(zhí)行語句塊1；否則去判斷條件表達式2； 如果條件表達式2的結果為true，則執(zhí)行語句塊2，否則去判斷條件表達式3； .... 如果所有的條件表達式結果都為false，則執(zhí)行語句塊N+1； else是可選的，根據(jù)需要可以省略。

if多分支的語法結構如下：

if(邏輯條件1){ 
    //滿足邏輯條件1執(zhí)行的代碼 
}else if(邏輯條件2){ 
    //隱藏條件(不滿足條件1) 滿足邏輯條件2執(zhí)行的代碼 
}else if(邏輯條件3){ 
    //隱藏條件(不滿足條件1、2) 滿足邏輯條件3執(zhí)行的代碼 
}else{ 
    //不滿足以上所有邏輯條件執(zhí)行的代碼 
}

需求案例：請你根據(jù)手上的資金選擇購買的手機品牌。如果你手里的錢大于10000，就買個蘋果；如果大于7000, 就買個華為；如果大于5000，就買個小米；如果大于3000，就買個諾基亞；否則，乖乖地去打公共電話。

/**
 * @author 一一哥Sun
 */
public class Demo01 {

    public static void main(String[] args) {
	// if多分支語句
	Scanner sc=new Scanner(System.in);
		
	//請你根據(jù)手上的資金選擇購買的手機品牌。如果你手里的錢大于10000，就買個蘋果；
	//如果大于7000, 就買個華為；如果大于5000，就買個小米；如果大于3000，就買個諾基亞；
	//否則，乖乖地去打公共電話。
	System.out.println("請輸入余額");
	int money = sc.nextInt();
        
	if(money > 10000){
            System.out.println("蘋果手機");
	}else if(money > 7000){ //money <= 10000
            System.out.println("華為手機");
	}else if(money > 5000){
            System.out.println("小米手機");
	}else if(money > 3000){
            System.out.println("諾基亞手機");
	}else{
            System.out.println("打公共電話");
	}
    }
}

大家要注意，我們在串聯(lián)使用多個if時，要特別注意判斷順序和邊界條件的判斷。

4. if嵌套

if嵌套的語法結構如下：

if(邏輯條件1){ 
   if(邏輯條件2){ 
      //滿足邏輯條件1且滿足條件2執(zhí)行的代碼 
   }else{ 
      //滿足邏輯條件1但不滿足條件2執(zhí)行的代碼 
   } 
 }else{ 
     //不滿足邏輯條件1執(zhí)行的代碼 
 }

需求案例：學校舉行跑步比賽，如果成績在15秒以內(nèi)，可以進入決賽，男的進入男子組決賽，女的進入女子組決賽。