01．基礎技術體系

我認為知識技能體系化是判斷技術是否過關的第一步。知識體系化包含兩層含義：

1、 能夠知道技術知識圖譜（高清版圖譜掃文末二維碼）的內容

比如分佈式系統中常用的RPC技術，其背後就涉及到網絡IO（Netty）、網絡協議、服務發現（Zookeeper配置中心）、RPC服務治理（限流、熔斷、降級）、負載均衡等。

2、 能夠理清各類技術概念之間的區別和聯繫

在分佈式系統領域中，有很多相似的概念，但又分佈在不同的產品或層級中。比如負載均衡這個詞，DNS、LVS、Ngnix、F5等產品都能實現，而且在大型分佈式系統中他們會同時存在，那麼就要搞清楚他們各自的位於什麼層級，解決了什麼問題。

再比如緩存這項技術，有分佈式緩存、本地緩存、數據庫緩存，在往下還有硬件層級的緩存。同樣都是緩存，他們之間的區別又是什麼？

如果你仔細去觀察，大廠的後端開發工程師總是能對整個技術體系了如指掌，從而在系統設計與技術選型階段就能夠做出較為合理的架構。 

02．實踐經驗的積累

       能否快速解決實戰中的業務問題是判斷技術是否過關的第二步。
       大家在面試的過程中，都會有一種體會：我的知識體系已經建立了，但在回答面試官問題的時候，總感覺像在背答案，而且也沒有辦法針對性的回答面試官問題。比如在面試官問到這些問題時：

1. 我們知道消息隊列可應用於耦系統，應對異步消費等場景，那如何在網絡不可靠的場景下保證業務數據處理的正確性？
2. 我們都知道在分佈式系統會用到緩存，那該如何設置緩存失效機制才能避免系統出現緩存雪崩？
3. 我們都或多或少的知道系統發布上線的流程，但在大流量場景下採用何種發布機制才能盡可能的做到平滑？

能完善的解決這些問題是區分一個程序員是否有經驗的重要標誌，知識的體系化是可以從書本不斷的凝練來獲得，但經驗的積累需要通過實戰的不斷總結

對很多人來說很為難的一點是，平時寫着的業務代碼，很少有機會接觸到大廠的優秀實踐，那麼這時候更需要從如下兩個角度逼問：

1、當流量規模再提高几個量級，那麼我的系統會出現什麼問題？

2、假如其中一個環節出現了問題，那麼該怎麼保證系統的穩定性？

03．技術的原理

上面的提到都是將技術用於業務實踐，以及高效的解決業務中出現的問題。但這是否就意味着自己的技術已經過關了呢？我認為還不能。

判斷技術是否過關的第三步是能否洞察技術背後的設計思想和原理。

如果你參加過一些大廠面試，還會問到一些開放性的問題：

1、 寫一段程序，讓其運行時的表現為觸發了5次Young GC、3次Full GC、然後3次Young GC；

2、 如果一個Java進程突然消失了，你會怎麼去排查這種問題？

3、 給了一段Spring加載Bean的代碼片段，闡述一下具體的執行流程？

       是不是看上去很難，是不是和自己準備的“題庫”中的問題不一樣？不知道從何處下手？如果你有這種感覺，那麼說明你的技術還需要繼續修鍊。

       你要明白的是這種開放性的問題，提問的角度千變萬化，但最終落腳點卻都是基本原理。如果你不了解GC的觸發條件，你就肯定無法答出第一題；同樣，如果你對Spring啟動機制了解的很清楚，那麼無論他給出的是什麼樣的代碼，你都能回答出代碼經歷的過程。如果你能以不變應萬變，那麼恭喜你，你的技術過關了。

       上面提到了很多技術問題，這裏我不做詳細的解釋，都能在下面的技術圖譜中找到答案:

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包”嚨底家”

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

新能源汽車業發展日益成熟之時，單純的財政補貼帶來的車企騙補等諸多負面效應逐漸顯現。對此，有專家提出建議採用積分交易機制替代財政補貼政策，促進車企在傳統燃油車節能和新能源車技術進步兩方面共同發展。  
  中國汽車技術研究中心新能源汽車積分政策負責人時間表示，相比真金白銀的財政補貼，新能源積分交易制度靈活性更高，是當下國家推動新能源產業發展的一種可行方式。   新能源積分交易制度，即政府將企業年度“零排放”車型的銷售情況記錄成積分，以積分為依據來考核企業在節能減排方面是否達標。若企業積分不達標，可以購買同行業其餘公司的積分，或者向政府繳納高額罰款。   中國若要實施積分交易制度 政府部門職責需合理分配。   為此，積分政策負責人時間給出幾點建議：作為政策的制定者政府，需要部門間進行合理的職責分配，物質保障方面，中國新能源基礎設施建設尚需進一步完善。意識形態方面，當前，消費者對新能源車的認識還不充足，對制度實施造成一定阻礙。企業方面，不同規模的企業須在政策上區別對待，為中小企業的發展提供空間；當企業規模有所變更時，應當提供相應的扶持政策。   文章來源：人民網

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包”嚨底家”

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

準備

我的環境是python3.6,sc2包0.11.1
機器學習包下載鏈接：
地圖下載鏈接
pysc2是DeepMind開發的星際爭霸Ⅱ學習環境。 它是封裝星際爭霸Ⅱ機器學習API，同時也提供Python增強學習環境。
以神族為例編寫代碼，神族建築科技圖如下：

採礦

# -*- encoding: utf-8 -*-
'''
@File    :   __init__.py.py    
@Modify Time      @Author       @Desciption
------------      -------       -----------
2019/11/3 12:32   Jonas           None
'''

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer


class SentdeBot(sc2.BotAI):
    async def on_step(self, iteration: int):
        await self.distribute_workers()


run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Easy)
],realtime = True)

注意
game_data.py的assert self.id != 0註釋掉
pixel_map.py的assert self.bits_per_pixel % 8 == 0, "Unsupported pixel density"註釋掉
否則會報錯

運行結果如下，农民開始採礦

可以正常採礦

建造农民和水晶塔

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import *


class SentdeBot(sc2.BotAI):
    async def on_step(self, iteration: int):
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()

    # 建造农民
    async def build_workers(self):
        # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            # 是否有50晶體礦
            if self.can_afford(UnitTypeId.PROBE):
                await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且水晶不是正在建造
        if self.supply_left<5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON,near=nexuses.first)

## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Easy)
],realtime = True)

運行結果如下，基地造农民，农民造水晶

收集氣體和開礦

代碼如下

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import *


class SentdeBot(sc2.BotAI):
    async def on_step(self, iteration: int):
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()

    # 建造农民
    async def build_workers(self):
        # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            # 是否有50晶體礦
            if self.can_afford(UnitTypeId.PROBE):
                await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0,nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0,vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR,vaspene))

    ## 開礦
    async def expand(self):
        if self.units(UnitTypeId.NEXUS).amount<3 and self.can_afford(UnitTypeId.NEXUS):
            await self.expand_now()

## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Easy)
], realtime=False)

run_game的realtime設置成False，可以在加速模式下運行遊戲。
運行效果如下：

可以建造吸收廠和開礦

建造軍隊

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import *


class SentdeBot(sc2.BotAI):
    async def on_step(self, iteration: int):
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()
        await self.offensive_force_buildings()
        await self.build_offensive_force()

    # 建造农民
    async def build_workers(self):
        # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            # 是否有50晶體礦
            if self.can_afford(UnitTypeId.PROBE):
                await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0,nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0,vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR,vaspene))

    ## 開礦
    async def expand(self):
        if self.units(UnitTypeId.NEXUS).amount<2 and self.can_afford(UnitTypeId.NEXUS):
            await self.expand_now()

    ## 建造進攻性建築
    async def offensive_force_buildings(self):
        if self.units(UnitTypeId.PYLON).ready.exists:
            pylon = self.units(UnitTypeId.PYLON).ready.random
            if self.units(UnitTypeId.PYLON).ready.exists:
                # 根據神族建築科技圖，折躍門建造過後才可以建造控制核心
                if self.units(UnitTypeId.GATEWAY).ready.exists:
                    if not self.units(UnitTypeId.CYBERNETICSCORE):
                        if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                            await self.build(UnitTypeId.CYBERNETICSCORE,near = pylon)
                # 否則建造折躍門
                else:
                    if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                        await self.build(UnitTypeId.GATEWAY,near=pylon)

    # 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            if self.can_afford(UnitTypeId.STALKER) and self.supply_left>0:
                await self.do(gw.train(UnitTypeId.STALKER))



## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Easy)
], realtime=False)

運行結果如下：

可以看到，我們建造了折躍門和控制核心並訓練了追獵者

控制部隊進攻

代碼如下

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import *
import random

class SentdeBot(sc2.BotAI):
    async def on_step(self, iteration: int):
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()
        await self.offensive_force_buildings()
        await self.build_offensive_force()
        await self.attack()

    # 建造农民
    async def build_workers(self):
        # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            # 是否有50晶體礦
            if self.can_afford(UnitTypeId.PROBE):
                await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0,nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0,vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR,vaspene))

    ## 開礦
    async def expand(self):
        if self.units(UnitTypeId.NEXUS).amount<3 and self.can_afford(UnitTypeId.NEXUS):
            await self.expand_now()

    ## 建造進攻性建築
    async def offensive_force_buildings(self):
        if self.units(UnitTypeId.PYLON).ready.exists:
            pylon = self.units(UnitTypeId.PYLON).ready.random
            # 根據神族建築科技圖，折躍門建造過後才可以建造控制核心
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE,near = pylon)
            # 否則建造折躍門
            elif len(self.units(UnitTypeId.GATEWAY))<=3:
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY,near=pylon)

    ## 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            if self.can_afford(UnitTypeId.STALKER) and self.supply_left>0:
                await self.do(gw.train(UnitTypeId.STALKER))

    ## 尋找目標
    def find_target(self,state):
        if len(self.known_enemy_units)>0:
            # 隨機選取敵方單位
            return random.choice(self.known_enemy_units)
        elif len(self.known_enemy_units)>0:
            # 隨機選取敵方建築
            return random.choice(self.known_enemy_structures)
        else:
            # 返回敵方出生點位
            return self.enemy_start_locations[0]

    ## 進攻
    async def attack(self):
        # 追獵者數量超過15個開始進攻
        if self.units(UnitTypeId.STALKER).amount>15:
            for s in self.units(UnitTypeId.STALKER).idle:
                await self.do(s.attack(self.find_target(self.state)))

        # 防衛模式：視野範圍內存在敵人，開始攻擊
        if self.units(UnitTypeId.STALKER).amount>5:
            if len(self.known_enemy_units)>0:
                for s in self.units(UnitTypeId.STALKER).idle:
                    await self.do(s.attack(random.choice(self.known_enemy_units)))

## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Medium)
], realtime=False)

運行結果如下

可以看到，4個折躍門訓練追獵者並發動進攻。

擊敗困難電腦

我們目前的代碼只能擊敗中等和簡單電腦，那麼如何擊敗困難電腦呢？
代碼如下

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import *
import random


class SentdeBot(sc2.BotAI):
    def __init__(self):
        # 經過計算，每分鐘大約165迭代次數
        self.ITERATIONS_PER_MINUTE = 165
        # 最大农民數量
        self.MAX_WORKERS = 65

    async def on_step(self, iteration: int):
        self.iteration = iteration
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()
        await self.offensive_force_buildings()
        await self.build_offensive_force()
        await self.attack()

    # 建造农民
    async def build_workers(self):
        # 星靈樞鈕*16（一個基地配備16個农民）大於農民數量並且現有农民數量小於MAX_WORKERS
        if len(self.units(UnitTypeId.NEXUS))*16>len(self.units(UnitTypeId.PROBE)) and len(self.units(UnitTypeId.PROBE))<self.MAX_WORKERS:
                # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
                for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                    # 是否有50晶體礦建造农民
                    if self.can_afford(UnitTypeId.PROBE):
                        await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0,nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0,vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR,vaspene))

    ## 開礦
    async def expand(self):
        # (self.iteration / self.ITERATIONS_PER_MINUTE)是一個緩慢遞增的值,動態開礦
        if self.units(UnitTypeId.NEXUS).amount<self.iteration / self.ITERATIONS_PER_MINUTE and self.can_afford(UnitTypeId.NEXUS):
            await self.expand_now()

    ## 建造進攻性建築
    async def offensive_force_buildings(self):
        print(self.iteration / self.ITERATIONS_PER_MINUTE)
        if self.units(UnitTypeId.PYLON).ready.exists:
            pylon = self.units(UnitTypeId.PYLON).ready.random
            # 根據神族建築科技圖，折躍門建造過後才可以建造控制核心
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            # 否則建造折躍門
            # (self.iteration / self.ITERATIONS_PER_MINUTE)/2 是一個緩慢遞增的值
            elif len(self.units(UnitTypeId.GATEWAY)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)
            # 控制核心存在的情況下建造星門
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                if len(self.units(UnitTypeId.STARGATE)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

    ## 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            if not self.units(UnitTypeId.STALKER).amount > self.units(UnitTypeId.VOIDRAY).amount:

                if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
                    await self.do(gw.train(UnitTypeId.STALKER))

        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

    ## 尋找目標
    def find_target(self,state):
        if len(self.known_enemy_units)>0:
            # 隨機選取敵方單位
            return random.choice(self.known_enemy_units)
        elif len(self.known_enemy_units)>0:
            # 隨機選取敵方建築
            return random.choice(self.known_enemy_structures)
        else:
            # 返回敵方出生點位
            return self.enemy_start_locations[0]

    ## 進攻
    async def attack(self):
        # {UNIT: [n to fight, n to defend]}
        aggressive_units = {UnitTypeId.STALKER: [15, 5],
                            UnitTypeId.VOIDRAY: [8, 3]}

        for UNIT in aggressive_units:
            # 攻擊模式
            if self.units(UNIT).amount > aggressive_units[UNIT][0] and self.units(UNIT).amount > aggressive_units[UNIT][
                1]:
                for s in self.units(UNIT).idle:
                    await self.do(s.attack(self.find_target(self.state)))
            # 防衛模式
            elif self.units(UNIT).amount > aggressive_units[UNIT][1]:
                if len(self.known_enemy_units) > 0:
                    for s in self.units(UNIT).idle:
                        await self.do(s.attack(random.choice(self.known_enemy_units)))
## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Hard)
], realtime=False)

運行結果如下

可以看到，擊敗了困難人族電腦，但是電腦選擇了rush戰術，我們寫得AI腳本會輸掉遊戲。顯然，這不是最佳方案。
“只有AI才能拯救我的勝率”，請看下文。

採集地圖數據

這次我們只造一個折躍門，全力通過星門造虛空光輝艦
修改offensive_force_buildings(self)方法的判斷

elif len(self.units(GATEWAY)) < 1:
                if self.can_afford(GATEWAY) and not self.already_pending(GATEWAY):
                    await self.build(GATEWAY, near=pylon)

註釋或者刪除build_offensive_force(self)的建造追獵者的代碼

        ## 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        # for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
        #     if not self.units(UnitTypeId.STALKER).amount > self.units(UnitTypeId.VOIDRAY).amount:
        #
        #         if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
        #             await self.do(gw.train(UnitTypeId.STALKER))

        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

attack(self)中的aggressive_units註釋掉Stalker
導入numpy和cv2庫

game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)

建立以地圖Heigt為行，Width為列的三維矩陣

for nexus in self.units(NEXUS):
            nex_pos = nexus.position
            print(nex_pos)
            cv2.circle(game_data, (int(nex_pos[0]), int(nex_pos[1])), 10, (0, 255, 0), -1)  # BGR

遍歷星靈樞紐，獲取下一個位置，畫圓，circle(承載圓的img, 圓心, 半徑, 顏色, thickness=-1表示填充)
接下來我們要垂直翻轉三維矩陣，因為我們建立的矩陣左上角是原點(0,0)，縱坐標向下延申，橫坐標向右延申。翻轉之後就成了正常的坐標系。

flipped = cv2.flip(game_data, 0)

圖像縮放，達到可視化最佳。

        resized = cv2.resize(flipped, dsize=None, fx=2, fy=2)
        cv2.imshow('Intel', resized)
        cv2.waitKey(1)

至此，完整代碼如下

import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import *
import random
import numpy as np
import cv2


class SentdeBot(sc2.BotAI):
    def __init__(self):
        # 經過計算，每分鐘大約165迭代次數
        self.ITERATIONS_PER_MINUTE = 165
        # 最大农民數量
        self.MAX_WORKERS = 65

    async def on_step(self, iteration: int):
        self.iteration = iteration
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()
        await self.offensive_force_buildings()
        await self.build_offensive_force()
        await self.intel()
        await self.attack()

    async def intel(self):
        # 根據地圖建立的三維矩陣
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)
        for nexus in self.units(UnitTypeId.NEXUS):
            nex_pos = nexus.position
            # circle(承載圓的img, 圓心, 半徑, 顏色, thickness=-1表示填充)
            # 記錄星靈樞紐的位置
            cv2.circle(game_data, (int(nex_pos[0]), int(nex_pos[1])), 10, (0, 255, 0), -1)
        # 圖像翻轉垂直鏡像
        flipped = cv2.flip(game_data, 0)
        # 圖像縮放
        # cv2.resize(原圖像,輸出圖像的大小,width方向的縮放比例,height方向縮放的比例)
        resized = cv2.resize(flipped, dsize=None, fx=2, fy=2)
        cv2.imshow('Intel', resized)

        # cv2.waitKey(每Xms刷新圖像)
        cv2.waitKey(1)

    # 建造农民
    async def build_workers(self):
        # 星靈樞鈕*16（一個基地配備16個农民）大於農民數量並且現有农民數量小於MAX_WORKERS
        if len(self.units(UnitTypeId.NEXUS)) * 16 > len(self.units(UnitTypeId.PROBE)) and len(
                self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                # 是否有50晶體礦建造农民
                if self.can_afford(UnitTypeId.PROBE):
                    await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vaspene))

    ## 開礦
    async def expand(self):
        # (self.iteration / self.ITERATIONS_PER_MINUTE)是一個緩慢遞增的值,動態開礦
        if self.units(UnitTypeId.NEXUS).amount < self.iteration / self.ITERATIONS_PER_MINUTE and self.can_afford(
                UnitTypeId.NEXUS):
            await self.expand_now()

    ## 建造進攻性建築
    async def offensive_force_buildings(self):
        print(self.iteration / self.ITERATIONS_PER_MINUTE)
        if self.units(UnitTypeId.PYLON).ready.exists:
            pylon = self.units(UnitTypeId.PYLON).ready.random
            # 根據神族建築科技圖，折躍門建造過後才可以建造控制核心
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            # 否則建造折躍門
            # (self.iteration / self.ITERATIONS_PER_MINUTE)/2 是一個緩慢遞增的值
            # elif len(self.units(UnitTypeId.GATEWAY)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)
            # 控制核心存在的情況下建造星門
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                if len(self.units(UnitTypeId.STARGATE)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

    ## 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

    ## 尋找目標
    def find_target(self, state):
        if len(self.known_enemy_units) > 0:
            # 隨機選取敵方單位
            return random.choice(self.known_enemy_units)
        elif len(self.known_enemy_units) > 0:
            # 隨機選取敵方建築
            return random.choice(self.known_enemy_structures)
        else:
            # 返回敵方出生點位
            return self.enemy_start_locations[0]

    ## 進攻
    async def attack(self):
        # {UNIT: [n to fight, n to defend]}
        aggressive_units = {UnitTypeId.VOIDRAY: [8, 3]}

        for UNIT in aggressive_units:
            # 攻擊模式
            if self.units(UNIT).amount > aggressive_units[UNIT][0] and self.units(UNIT).amount > aggressive_units[UNIT][1]:
                for s in self.units(UNIT).idle:
                    await self.do(s.attack(self.find_target(self.state)))
            # 防衛模式
            elif self.units(UNIT).amount > aggressive_units[UNIT][1]:
                if len(self.known_enemy_units) > 0:
                    for s in self.units(UNIT).idle:
                        await self.do(s.attack(random.choice(self.known_enemy_units)))


## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Hard)
], realtime=False)

運行結果如下

採集到了地圖位置。

偵察

在intel(self)里創建一個字典draw_dict，UnitTypeId作為key,半徑和顏色是value

        draw_dict = {
            UnitTypeId.NEXUS: [15, (0, 255, 0)],
            UnitTypeId.PYLON: [3, (20, 235, 0)],
            UnitTypeId.PROBE: [1, (55, 200, 0)],
            UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
            UnitTypeId.GATEWAY: [3, (200, 100, 0)],
            UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
            UnitTypeId.STARGATE: [5, (255, 0, 0)],
            UnitTypeId.ROBOTICSFACILITY: [5, (215, 155, 0)],

            UnitTypeId.VOIDRAY: [3, (255, 100, 0)]
        }

迭代同上

for unit_type in draw_dict:
            for unit in self.units(unit_type).ready:
                pos = unit.position
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), draw_dict[unit_type][0], draw_dict[unit_type][1], -1)

存儲三族的主基地名稱（星靈樞紐，指揮中心，孵化場），刻畫敵方建築。

# 主基地名稱
        main_base_names = ["nexus", "supplydepot", "hatchery"]
        # 記錄敵方基地位置
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)

刻畫敵方單位，如果是农民畫得小些，其他單位則畫大些。

        for enemy_unit in self.known_enemy_units:

            if not enemy_unit.is_structure:
                worker_names = ["probe", "scv", "drone"]
                # if that unit is a PROBE, SCV, or DRONE... it's a worker
                pos = enemy_unit.position
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

在offensive_force_buildings(self)方法中添加建造机械台

            if self.units(CYBERNETICSCORE).ready.exists:
                if len(self.units(ROBOTICSFACILITY)) < 1:
                    if self.can_afford(ROBOTICSFACILITY) and not self.already_pending(ROBOTICSFACILITY):
                        await self.build(ROBOTICSFACILITY, near=pylon)

創建scout()，訓練Observer

async def scout(self):
        if len(self.units(OBSERVER)) > 0:
            scout = self.units(OBSERVER)[0]
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                move_to = self.random_location_variance(enemy_location)
                print(move_to)
                await self.do(scout.move(move_to))

        else:
            for rf in self.units(ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(OBSERVER))

生成隨機位置，很簡單。意思是橫坐標累計遞增-0.2和0.2倍的橫坐標，限制條件為如果x超過橫坐標，那麼就是橫坐標最大值。
縱坐標同理。

    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20))/100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20))/100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x,y)))
        return go_to

完整代碼如下

# -*- encoding: utf-8 -*-
'''
@File    :   demo.py
@Modify Time      @Author       @Desciption
------------      -------       -----------
2019/11/3 12:32   Jonas           None
'''

import sc2
from sc2 import run_game, maps, Race, Difficulty, position
from sc2.player import Bot, Computer
from sc2.constants import *
import random
import numpy as np
import cv2


class SentdeBot(sc2.BotAI):
    def __init__(self):
        # 經過計算，每分鐘大約165迭代次數
        self.ITERATIONS_PER_MINUTE = 165
        # 最大农民數量
        self.MAX_WORKERS = 50

    async def on_step(self, iteration: int):
        self.iteration = iteration
        await self.scout()
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()
        await self.offensive_force_buildings()
        await self.build_offensive_force()
        await self.intel()
        await self.attack()

    ## 偵察
    async def scout(self):
        if len(self.units(UnitTypeId.OBSERVER)) > 0:
            scout = self.units(UnitTypeId.OBSERVER)[0]
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                move_to = self.random_location_variance(enemy_location)
                print(move_to)
                await self.do(scout.move(move_to))

        else:
            for rf in self.units(UnitTypeId.ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(UnitTypeId.OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(UnitTypeId.OBSERVER))

    async def intel(self):
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)

        # UnitTypeId作為key,半徑和顏色是value
        draw_dict = {
            UnitTypeId.NEXUS: [15, (0, 255, 0)],
            UnitTypeId.PYLON: [3, (20, 235, 0)],
            UnitTypeId.PROBE: [1, (55, 200, 0)],
            UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
            UnitTypeId.GATEWAY: [3, (200, 100, 0)],
            UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
            UnitTypeId.STARGATE: [5, (255, 0, 0)],
            UnitTypeId.ROBOTICSFACILITY: [5, (215, 155, 0)],

            UnitTypeId.VOIDRAY: [3, (255, 100, 0)],
            # OBSERVER: [3, (255, 255, 255)],
        }

        for unit_type in draw_dict:
            for unit in self.units(unit_type).ready:
                pos = unit.position
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), draw_dict[unit_type][0], draw_dict[unit_type][1], -1)

        # 主基地名稱
        main_base_names = ["nexus", "supplydepot", "hatchery"]
        # 記錄敵方基地位置
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            # 不是主基地建築，畫小一些
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)

        for enemy_unit in self.known_enemy_units:

            if not enemy_unit.is_structure:
                worker_names = ["probe", "scv", "drone"]
                # if that unit is a PROBE, SCV, or DRONE... it's a worker
                pos = enemy_unit.position
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

        for obs in self.units(UnitTypeId.OBSERVER).ready:
            pos = obs.position
            cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (255, 255, 255), -1)

        # flip horizontally to make our final fix in visual representation:
        flipped = cv2.flip(game_data, 0)
        resized = cv2.resize(flipped, dsize=None, fx=2, fy=2)

        cv2.imshow('Intel', resized)
        cv2.waitKey(1)

    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20)) / 100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20)) / 100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x, y)))
        return go_to

    # 建造农民
    async def build_workers(self):
        # 星靈樞鈕*16（一個基地配備16個农民）大於農民數量並且現有农民數量小於MAX_WORKERS
        if len(self.units(UnitTypeId.NEXUS)) * 16 > len(self.units(UnitTypeId.PROBE)) and len(
                self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                # 是否有50晶體礦建造农民
                if self.can_afford(UnitTypeId.PROBE):
                    await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vaspene))

    ## 開礦
    async def expand(self):
        # (self.iteration / self.ITERATIONS_PER_MINUTE)是一個緩慢遞增的值,動態開礦
        if self.units(UnitTypeId.NEXUS).amount < self.iteration / self.ITERATIONS_PER_MINUTE and self.can_afford(
                UnitTypeId.NEXUS):
            await self.expand_now()

    ## 建造進攻性建築
    async def offensive_force_buildings(self):
        print(self.iteration / self.ITERATIONS_PER_MINUTE)
        if self.units(UnitTypeId.PYLON).ready.exists:
            pylon = self.units(UnitTypeId.PYLON).ready.random
            # 根據神族建築科技圖，折躍門建造過後才可以建造控制核心
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            # 否則建造折躍門
            # (self.iteration / self.ITERATIONS_PER_MINUTE)/2 是一個緩慢遞增的值
            # elif len(self.units(UnitTypeId.GATEWAY)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)
            # 控制核心存在的情況下建造机械台
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                if len(self.units(UnitTypeId.ROBOTICSFACILITY)) < 1:
                    if self.can_afford(UnitTypeId.ROBOTICSFACILITY) and not self.already_pending(
                            UnitTypeId.ROBOTICSFACILITY):
                        await self.build(UnitTypeId.ROBOTICSFACILITY, near=pylon)

            # 控制核心存在的情況下建造星門
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                if len(self.units(UnitTypeId.STARGATE)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

    ## 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        # for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
        #     if not self.units(UnitTypeId.STALKER).amount > self.units(UnitTypeId.VOIDRAY).amount:
        #
        #         if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
        #             await self.do(gw.train(UnitTypeId.STALKER))

        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

    ## 尋找目標
    def find_target(self, state):
        if len(self.known_enemy_units) > 0:
            # 隨機選取敵方單位
            return random.choice(self.known_enemy_units)
        elif len(self.known_enemy_units) > 0:
            # 隨機選取敵方建築
            return random.choice(self.known_enemy_structures)
        else:
            # 返回敵方出生點位
            return self.enemy_start_locations[0]

    ## 進攻
    async def attack(self):
        # {UNIT: [n to fight, n to defend]}
        aggressive_units = {UnitTypeId.VOIDRAY: [8, 3]}

        for UNIT in aggressive_units:
            # 攻擊模式
            if self.units(UNIT).amount > aggressive_units[UNIT][0] and self.units(UNIT).amount > aggressive_units[UNIT][
                1]:
                for s in self.units(UNIT).idle:
                    await self.do(s.attack(self.find_target(self.state)))
            # 防衛模式
            elif self.units(UNIT).amount > aggressive_units[UNIT][1]:
                if len(self.known_enemy_units) > 0:
                    for s in self.units(UNIT).idle:
                        await self.do(s.attack(random.choice(self.known_enemy_units)))


## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Hard)
], realtime=False)

運行結果如下，紅色和粉紅色是敵方單位。

創建訓練數據

統計資源、人口和軍隊人口比，在intel方法添加如下代碼

        # 追蹤資源、人口和軍隊人口比
        line_max = 50
        mineral_ratio = self.minerals / 1500
        if mineral_ratio > 1.0:
            mineral_ratio = 1.0

        vespene_ratio = self.vespene / 1500
        if vespene_ratio > 1.0:
            vespene_ratio = 1.0

        population_ratio = self.supply_left / self.supply_cap
        if population_ratio > 1.0:
            population_ratio = 1.0

        plausible_supply = self.supply_cap / 200.0

        military_weight = len(self.units(UnitTypeId.VOIDRAY)) / (self.supply_cap - self.supply_left)
        if military_weight > 1.0:
            military_weight = 1.0

        # 农民/人口      worker/supply ratio
        cv2.line(game_data, (0, 19), (int(line_max * military_weight), 19), (250, 250, 200), 3)
        # 人口/200    plausible supply (supply/200.0)
        cv2.line(game_data, (0, 15), (int(line_max * plausible_supply), 15), (220, 200, 200), 3)
        # (人口-現有人口)/人口  population ratio (supply_left/supply)
        cv2.line(game_data, (0, 11), (int(line_max * population_ratio), 11), (150, 150, 150), 3)
        # 氣體/1500   gas/1500
        cv2.line(game_data, (0, 7), (int(line_max * vespene_ratio), 7), (210, 200, 0), 3)
        # 晶體礦/1500  minerals minerals/1500
        cv2.line(game_data, (0, 3), (int(line_max * mineral_ratio), 3), (0, 255, 25), 3)

運行結果如下，左下角自上而下依次是“农民/人口”，“人口/200”，“(人口-現有人口)/人口”，“氣體/1500”，“晶體礦/1500”

採集進攻行為數據，在attack方法中加入如下代碼

        if len(self.units(UnitTypeId.VOIDRAY).idle) > 0:
            choice = random.randrange(0, 4)
            target = False
            if self.iteration > self.do_something_after:
                if choice == 0:
                    # 什麼都不做
                    wait = random.randrange(20, 165)
                    self.do_something_after = self.iteration + wait

                elif choice == 1:
                    # 攻擊離星靈樞紐最近的單位
                    if len(self.known_enemy_units) > 0:
                        target = self.known_enemy_units.closest_to(random.choice(self.units(UnitTypeId.NEXUS)))

                elif choice == 2:
                    # 攻擊敵方建築
                    if len(self.known_enemy_structures) > 0:
                        target = random.choice(self.known_enemy_structures)

                elif choice == 3:
                    # 攻擊敵方出生位置
                    target = self.enemy_start_locations[0]

                if target:
                    for vr in self.units(UnitTypeId.VOIDRAY).idle:
                        await self.do(vr.attack(target))
                y = np.zeros(4)
                y[choice] = 1
                print(y)
                self.train_data.append([y, self.flipped])

輸出如下結果

···
[1. 0. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]
[0. 0. 1. 0.]
[1. 0. 0. 0.]
···

為了使用self.flipped = cv2.flip(game_data, 0)，修改

        flipped = cv2.flip(game_data, 0)
        resized = cv2.resize(flipped, dsize=None, fx=2, fy=2)

為

        self.flipped = cv2.flip(game_data, 0)
        resized = cv2.resize(self.flipped, dsize=None, fx=2, fy=2)

init 方法添加do_something_after和train_data

    def __init__(self):
        self.ITERATIONS_PER_MINUTE = 165
        self.MAX_WORKERS = 50
        self.do_something_after = 0
        self.train_data = []

採集攻擊數據的時候不需要畫圖,我們在類前加HEADLESS = False，intel方法代碼修改如下

        self.flipped = cv2.flip(game_data, 0)

        if not HEADLESS:
            resized = cv2.resize(self.flipped, dsize=None, fx=2, fy=2)
            cv2.imshow('Intel', resized)
            cv2.waitKey(1)

加入on_end方法，只存儲勝利的數據，在和代碼同級目錄新建train_data文件夾

    def on_end(self, game_result):
        print('--- on_end called ---')
        print(game_result)

        if game_result == Result.Victory:
            np.save("train_data/{}.npy".format(str(int(time.time()))), np.array(self.train_data))

完整代碼如下

import os
import time

import sc2
from sc2 import run_game, maps, Race, Difficulty, position, Result
from sc2.player import Bot, Computer
from sc2.constants import *
import random
import numpy as np
import cv2

HEADLESS = True
# os.environ["SC2PATH"] = 'F:\StarCraft II'

class SentdeBot(sc2.BotAI):
    def __init__(self):
        # 經過計算，每分鐘大約165迭代次數
        self.ITERATIONS_PER_MINUTE = 165
        # 最大农民數量
        self.MAX_WORKERS = 50
        self.do_something_after = 0
        self.train_data = []

    def on_end(self, game_result):
        print('--- on_end called ---')
        print(game_result)

        if game_result == Result.Victory:
            np.save("train_data/{}.npy".format(str(int(time.time()))), np.array(self.train_data))

    async def on_step(self, iteration: int):
        self.iteration = iteration
        await self.scout()
        await self.distribute_workers()
        await self.build_workers()
        await self.build_pylons()
        await self.build_assimilators()
        await self.expand()
        await self.offensive_force_buildings()
        await self.build_offensive_force()
        await self.intel()
        await self.attack()

    ## 偵察
    async def scout(self):
        if len(self.units(UnitTypeId.OBSERVER)) > 0:
            scout = self.units(UnitTypeId.OBSERVER)[0]
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                move_to = self.random_location_variance(enemy_location)
                print(move_to)
                await self.do(scout.move(move_to))

        else:
            for rf in self.units(UnitTypeId.ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(UnitTypeId.OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(UnitTypeId.OBSERVER))

    async def intel(self):
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)

        # UnitTypeId作為key,半徑和顏色是value
        draw_dict = {
            UnitTypeId.NEXUS: [15, (0, 255, 0)],
            UnitTypeId.PYLON: [3, (20, 235, 0)],
            UnitTypeId.PROBE: [1, (55, 200, 0)],
            UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
            UnitTypeId.GATEWAY: [3, (200, 100, 0)],
            UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
            UnitTypeId.STARGATE: [5, (255, 0, 0)],
            UnitTypeId.ROBOTICSFACILITY: [5, (215, 155, 0)],

            UnitTypeId.VOIDRAY: [3, (255, 100, 0)],
            # OBSERVER: [3, (255, 255, 255)],
        }

        for unit_type in draw_dict:
            for unit in self.units(unit_type).ready:
                pos = unit.position
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), draw_dict[unit_type][0], draw_dict[unit_type][1], -1)

        # 主基地名稱
        main_base_names = ["nexus", "supplydepot", "hatchery"]
        # 記錄敵方基地位置
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            # 不是主基地建築，畫小一些
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)

        for enemy_unit in self.known_enemy_units:

            if not enemy_unit.is_structure:
                worker_names = ["probe", "scv", "drone"]
                # if that unit is a PROBE, SCV, or DRONE... it's a worker
                pos = enemy_unit.position
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

        for obs in self.units(UnitTypeId.OBSERVER).ready:
            pos = obs.position
            cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (255, 255, 255), -1)


        # 追蹤資源、人口和軍隊人口比
        line_max = 50
        mineral_ratio = self.minerals / 1500
        if mineral_ratio > 1.0:
            mineral_ratio = 1.0

        vespene_ratio = self.vespene / 1500
        if vespene_ratio > 1.0:
            vespene_ratio = 1.0

        population_ratio = self.supply_left / self.supply_cap
        if population_ratio > 1.0:
            population_ratio = 1.0

        plausible_supply = self.supply_cap / 200.0

        military_weight = len(self.units(UnitTypeId.VOIDRAY)) / (self.supply_cap - self.supply_left)
        if military_weight > 1.0:
            military_weight = 1.0

        # 农民/人口      worker/supply ratio
        cv2.line(game_data, (0, 19), (int(line_max * military_weight), 19), (250, 250, 200), 3)
        # 人口/200    plausible supply (supply/200.0)
        cv2.line(game_data, (0, 15), (int(line_max * plausible_supply), 15), (220, 200, 200), 3)
        # (人口-現有人口)/人口  population ratio (supply_left/supply)
        cv2.line(game_data, (0, 11), (int(line_max * population_ratio), 11), (150, 150, 150), 3)
        # 氣體/1500   gas/1500
        cv2.line(game_data, (0, 7), (int(line_max * vespene_ratio), 7), (210, 200, 0), 3)
        # 晶體礦/1500  minerals minerals/1500
        cv2.line(game_data, (0, 3), (int(line_max * mineral_ratio), 3), (0, 255, 25), 3)




        # flip horizontally to make our final fix in visual representation:
        self.flipped = cv2.flip(game_data, 0)

        if HEADLESS:
            resized = cv2.resize(self.flipped, dsize=None, fx=2, fy=2)

            cv2.imshow('Intel', resized)
            cv2.waitKey(1)

    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20)) / 100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20)) / 100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x, y)))
        return go_to

    # 建造农民
    async def build_workers(self):
        # 星靈樞鈕*16（一個基地配備16個农民）大於農民數量並且現有农民數量小於MAX_WORKERS
        if len(self.units(UnitTypeId.NEXUS)) * 16 > len(self.units(UnitTypeId.PROBE)) and len(
                self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            # 星靈樞紐(NEXUS)無隊列建造，可以提高晶體礦的利用率，不至於佔用資源
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                # 是否有50晶體礦建造农民
                if self.can_afford(UnitTypeId.PROBE):
                    await self.do(nexus.train(UnitTypeId.PROBE))

    ## 建造水晶
    async def build_pylons(self):
        ## 供應人口和現有人口之差小於5且建築不是正在建造
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            nexuses = self.units(UnitTypeId.NEXUS).ready
            if nexuses.exists:
                if self.can_afford(UnitTypeId.PYLON):
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

    ## 建造吸收廠
    async def build_assimilators(self):
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            # 在瓦斯泉上建造吸收廠
            vaspenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vaspene in vaspenes:
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                worker = self.select_build_worker(vaspene.position)
                if worker is None:
                    break
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vaspene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vaspene))

    ## 開礦
    async def expand(self):
        # (self.iteration / self.ITERATIONS_PER_MINUTE)是一個緩慢遞增的值,動態開礦
        if self.units(UnitTypeId.NEXUS).amount < self.iteration / self.ITERATIONS_PER_MINUTE and self.can_afford(
                UnitTypeId.NEXUS):
            await self.expand_now()

    ## 建造進攻性建築
    async def offensive_force_buildings(self):
        # print(self.iteration / self.ITERATIONS_PER_MINUTE)
        if self.units(UnitTypeId.PYLON).ready.exists:
            pylon = self.units(UnitTypeId.PYLON).ready.random
            # 根據神族建築科技圖，折躍門建造過後才可以建造控制核心
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            # 否則建造折躍門
            # (self.iteration / self.ITERATIONS_PER_MINUTE)/2 是一個緩慢遞增的值
            # elif len(self.units(UnitTypeId.GATEWAY)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)
            # 控制核心存在的情況下建造机械台
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                if len(self.units(UnitTypeId.ROBOTICSFACILITY)) < 1:
                    if self.can_afford(UnitTypeId.ROBOTICSFACILITY) and not self.already_pending(
                            UnitTypeId.ROBOTICSFACILITY):
                        await self.build(UnitTypeId.ROBOTICSFACILITY, near=pylon)

            # 控制核心存在的情況下建造星門
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                if len(self.units(UnitTypeId.STARGATE)) < ((self.iteration / self.ITERATIONS_PER_MINUTE) / 2):
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

    ## 造兵
    async def build_offensive_force(self):
        # 無隊列化建造
        # for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
        #     if not self.units(UnitTypeId.STALKER).amount > self.units(UnitTypeId.VOIDRAY).amount:
        #
        #         if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
        #             await self.do(gw.train(UnitTypeId.STALKER))

        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

    ## 尋找目標
    def find_target(self, state):
        if len(self.known_enemy_units) > 0:
            # 隨機選取敵方單位
            return random.choice(self.known_enemy_units)
        elif len(self.known_enemy_units) > 0:
            # 隨機選取敵方建築
            return random.choice(self.known_enemy_structures)
        else:
            # 返回敵方出生點位
            return self.enemy_start_locations[0]

    ## 進攻
    async def attack(self):
        if len(self.units(UnitTypeId.VOIDRAY).idle) > 0:
            choice = random.randrange(0, 4)
            target = False
            if self.iteration > self.do_something_after:
                if choice == 0:
                    # 什麼都不做
                    wait = random.randrange(20, 165)
                    self.do_something_after = self.iteration + wait

                elif choice == 1:
                    # 攻擊離星靈樞紐最近的單位
                    if len(self.known_enemy_units) > 0:
                        target = self.known_enemy_units.closest_to(random.choice(self.units(UnitTypeId.NEXUS)))

                elif choice == 2:
                    # 攻擊敵方建築
                    if len(self.known_enemy_structures) > 0:
                        target = random.choice(self.known_enemy_structures)

                elif choice == 3:
                    # 攻擊敵方出生位置
                    target = self.enemy_start_locations[0]

                if target:
                    for vr in self.units(UnitTypeId.VOIDRAY).idle:
                        await self.do(vr.attack(target))
                y = np.zeros(4)
                y[choice] = 1
                print(y)
                self.train_data.append([y, self.flipped])


## 啟動遊戲
run_game(maps.get("AcidPlantLE"), [
    Bot(Race.Protoss, SentdeBot()), Computer(Race.Terran, Difficulty.Medium)
], realtime=False)

可以看到train_data文件夾下存儲了勝利數據

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

在之前的文章中，我們介紹過編碼格式的發展史：[文章傳送門-todo]。今天我們通過幾個例子，來徹底搞清楚python3中的編碼格式原理，這樣你之後寫python腳本時碰到編碼問題，才能有章可循。

我們先搞清楚幾個概念：

• 系統默認編碼：指python解釋器默認的編碼格式，在python文件頭部沒有聲明其他編碼格式時，python3默認的編碼格式是utf-8。
• 本地默認編碼：操作系統默認的編碼，常見的Windows的默認編碼是gbk，Linux的默認編碼是UTF-8。
• python文件頭部聲明編碼格式：修改的是文件的默認編碼格式，只是會影響python解釋器讀取python文件時的編碼格式，並不會改變系統默認編碼和本地默認編碼。

通過python自帶的庫，可以查看系統默認編碼和本地默認編碼

Python 3.7.4 (tags/v3.7.4:e09359112e, Jul  8 2019, 20:34:20) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.getdefaultencoding()
'utf-8'
>>> import locale
>>> locale.getdefaultlocale()
('zh_CN', 'cp936')
>>>

注意，因為我在windows系統的電腦上 進行測試，所以系統默認編碼返回“cp936”, 這是代碼頁（是字符編碼集的別名），而936對應的就是gbk。如果你在linux或者mac上執行上面的代碼，應該會返回utf-8編碼。

其實總結來看，容易出現亂碼的場景，基本都與讀寫程序有關，比如：讀取/寫入某個文件，或者從網絡流中讀取數據等，因為這個過程中涉及到了編碼 和解碼的過程，只要編碼和解碼的編碼格式對應不上，就容易出現亂碼。下面我們舉兩個具體的例子，來驗證下python的編碼原理，幫助你理解這個過程。注意：下面的例子都是在pycharm中寫的。

01默認的編碼格式

我們新建一個encode_demo.py的文件，其文件默認的編碼格式是UTF-8（可以從pycharm右下角看到編碼格式），代碼如下：

"""
    @author: asus
    @time: 2019/11/21
    @function: 驗證編碼格式
"""
import sys, locale


def write_str_default_encode():
    s = "我是一個str"
    print(s)
    print(type(s))
    print(sys.getdefaultencoding())
    print(locale.getdefaultlocale())

    with open("utf_file", "w", encoding="utf-8") as f:
        f.write(s)
    with open("gbk_file", "w", encoding="gbk") as f:
        f.write(s)
    with open("jis_file", "w", encoding="shift-jis") as f:
        f.write(s)


if __name__ == '__main__':
    write_str_default_encode()

我們先來猜測下結果，因為我們沒有聲明編碼格式，所以python解釋器默認用UTF-8去解碼文件，因為文件默認編碼格式就是UTF-8，所以字符串s可以正常打印。同時以UTF-8編碼格式寫文件不會出現亂碼，而以gbk和shift-jis（日文編碼）寫文件會出現亂碼（這裏說明一點，我是用pycharm直接打開生成的文件查看的，編輯器默認編碼是UTF-8，如果在windows上用記事本打開則其默認編碼跟隨系統是GBK，gbk_file和utf_file均不會出現亂碼，只有jis_file是亂碼），我們運行看下結果：

# 運行結果
我是一個str
<class 'str'>
utf-8
('zh_CN', 'cp936')

# 寫文件utf_file、gbk_file、jis_file文件內容分別是：
我是一個str
����һ��str
�䐥�꘢str

和我們猜測的結果一致，下面我們做個改變，在文件頭部聲明個編碼格式，再來看看效果。

02 python頭文件聲明編碼格式

因為上面文件encode_demo.py的格式是UTF-8，那麼我們就將其變為gbk編碼。同樣的我們先來推測下結果，在pycharm中，在python文件頭部聲明編碼為gbk后（頭部加上 # coding=gbk ），文件的編碼格式變成gbk，同時python解釋器會用gbk去解碼encode_demo.py文件，所以運行結果應該和用UTF-8編碼時一樣。運行結果如下：

# 運行結果
我是一個str
<class 'str'>
utf-8
('zh_CN', 'cp936')

# 寫文件utf_file、gbk_file、jis_file文件內容分別是：
我是一個str
����һ��str
�䐥�꘢str

結果確實是一樣的，證明我們推論是正確的。接下來我們再做個嘗試，假如我們將（# coding=gbk）去掉（需要注意，在pycharm中將 # coding=gbk去掉，並不會改變文件的編碼格式，也就是說encode_demo.py還是gbk編碼），我們再運行一次看結果：

  File "D:/codespace/python/pythonObject/pythonSample/basic/encodeDemo/encode_demo.py", line 4
SyntaxError: Non-UTF-8 code starting with '\xd1' in file D:/codespace/python/pythonObject/pythonSample/basic/encodeDemo/encode_demo.py on line 5, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details

運行直接報錯了，我們加個斷點，看看具體的異常信息：

看錯誤提示是UnicodeDecodeError，python解釋器在對encode_demo.py文件解碼時，使用默認的UTF-8編碼，但是文件本身是gbk編碼，所以當碰到有中文沒辦法識別時，就拋出DecodeError。

03 敲黑板，划重點

python3中的str和bytes

python3的重要特性之一就是對字符串和二進制流做了嚴格的區分，我們聲明的字符串都是str類型，不過Str和bytes是可以相互轉換的：

def str_transfor_bytes():
    s = '我是一個測試Str'
    print(type(s))
    # str 轉bytes
    b = s.encode()
    print(b)
    print(type(b))
    # bytes轉str
    c = b.decode('utf-8')
    print(c)
    print(type(c))


if __name__ == '__main__':
    str_transfor_bytes()

需要注意一點：在調用encode()和decode()方法時，如果不傳參數，則會使用python解釋器默認的編碼格式UTF-8（如果不在python頭文件聲明編碼格式）。但是如果傳參的話，encode和decode使用的編碼格式要能對應上。

python3默認編碼是UTF-8？還是Unicode？

經常在很多文章里看到，python3的默認編碼格式是Unicode，但是我在本文中卻一直在說python3的默認編碼格式是UTF-8，那麼哪種說法是正確的呢？其實兩種說法都對，主要得搞清楚Unicode和UTF-8的區別（之前文章有提到）：

• Unicode是一個字符集，說白了就是把各種編碼的映射關係全都整合起來，不過它是不可變長的，全部都以兩個字節或四個字節來表示，佔用的內存空間比較大。
• UTF-8是Unicode的一種實現方式，主要對 Unicode 碼的數據進行轉換，方便存儲和網絡傳輸 。它是可變長編碼，比如對於英文字母，它使用一個字節就可以表示。

在python3內存中使用的字符串全都是Unicode碼，當python解釋器解析python文件時，默認使用UTF-8編碼。

open()方法默認使用本地編碼

在上面的例子中，我們往磁盤寫入文件時，都指定了編碼格式。如果不指定編碼格式，那麼默認將使用操作系統本地默認的編碼格式，比如：Linux默認是UTF-8，windows默認是GBK。其實這也好理解，因為和磁盤交互，肯定要考慮操作系統的編碼格式。這有區別於encode()和decode()使用的是python解釋器的默認編碼格式，千萬別搞混淆了。

總結

不知道你看完上面的例子后，是否已經徹底理解了python3的編碼原理。不過所有的編碼問題，都逃不過“編碼”和“解碼”兩個過程，當你碰到編碼問題時，先確定源文件使用的編碼，再確定目標文件需要的編碼格式，只要能匹配，一般就可以解決編碼的問題。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

什麼是fastjson？

Fastjson是一個Java語言編寫的高性能功能完善的JSON庫。它採用一種“假定有序快速匹配”的算法，把JSON Parse的性能提升到極致，是目前Java語言中最快的JSON庫。Fastjson接口簡單易用，已經被廣泛使用在緩存序列化、協議交互、Web輸出、Android客戶端等多種應用場景。

主要特點：

• 快速FAST (比其它任何基於Java的解析器和生成器更快，包括jackson）
• 強大（支持普通JDK類包括任意Java Bean Class、Collection、Map、Date或enum）
• 零依賴（沒有依賴其它任何類庫除了JDK）

背景

最近關於fastjson的消息，引起了很多人的關注！

fastjson爆出重大漏洞，攻擊者可使整個業務癱瘓

漏洞描述

常用JSON組件FastJson存在遠程代碼執行漏洞，攻擊者可通過精心構建的json報文對目標服務器執行任意命令，從而獲得服務器權限。此次爆發的漏洞為以往漏洞中autoType的繞過。

影響範圍

FastJson < 1.2.48

很多開發者才猛然發現，fastjson已經深入到我們開發工作的方方面面。那麼除了趕快升級你的json外，我們來挖挖fastjson最常用的用法。

fastjson常用方式

1.maven依賴(記得升級到1.2.48以上版本哦)

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.62</version>
        </dependency>    

2.FastJson對於json格式字符串的解析主要用到了一下三個類：

（1）JSON：fastJson的解析器，用於JSON格式字符串與JSON對象及javaBean之間的轉換。

（2）JSONObject：fastJson提供的json對象。

（3）JSONArray：fastJson提供json數組對象。

3.常用方式

3.1 string和java對象

 

實例1：對象轉json字符串

        Map<String,String> map=new HashMap<String,String>();
        map.put("code","0");
        map.put("message","ok");
        String json=JSON.toJSONString(map);
        System.out.println(json);

輸出結果為：

{"code":"0","message":"ok"}

實例2：字符串轉對象

        Map<String,String> map=new HashMap<String,String>();
        map.put("code","0");
        map.put("message","ok");
        String json=JSON.toJSONString(map);
        System.out.println(json);
        
        Map obj=(Map)JSON.parse(json);
        System.out.println("code="+obj.get("code")+",message="+obj.get("message"));

輸出結果

{"code":"0","message":"ok"}
code=0,message=ok

3.2 工具類JSONObject

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("code","0");
        map.put("message","ok");
        String json=JSON.toJSONString(map);
        System.out.println(json);
        
        Map obj=(Map)JSON.parse(json);
        System.out.println("code="+obj.get("code")+",message="+obj.get("message"));        
        
        String code=JSON.parseObject(json).getString("code");
        String message=JSON.parseObject(json).getString("message");
        System.out.println("code="+code+",message="+message);
    }

輸出結果

{"code":"0","message":"ok"}
code=0,message=ok
code=0,message=ok

3.3 數組對象

List<user> list=new ArrayList<user>(JSONArray.parseArray(jsonString,user.class)); 

Fastjson 與各種JSON庫的性能比較：

 

json庫	序列化性能	反序列化性能	jar大小
fastjson	1201	1216	fastjson-1.1.26.jar(356k) fastjson-1.1.25-android.jar(226k)
jackson	1408	1915	jackson-annotations-2.1.1.jar(34k) jackson-core-2.1.1.jar(206k) jackson-databind-2.1.1.jar(922k) 總共1162k
gson	7421	5065	gson-2.2.2.jar(189k)
json-lib	27555	87292	json-lib-2.4-jdk15.jar(159k)

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

據報導，自7月1日起，德國頒佈最新的電動車補貼計畫，截止目前已經有近2000位申請者，其中寶馬車主占多數。  
  為了促進電動車等環保車型的普及，德國為每位購買電動車的消費者提供4000歐元的補貼，插電式混合動力車的補貼為3000歐元。在計畫實施後，有1791位插電式混合動力車的車主申請了補貼，其中有581位購買了寶馬的車型。同時還有444位申請者購買了雷諾車型，大眾汽車買主為154位。   據統計，目前德國人汽車擁有量為4500萬輛，而其中僅有5萬輛是純電動或者是混合動力車輛。為改善這一情況，德國此次計畫共投入12億歐元，由政府和汽車製造商平攤，希望能夠在2019年6月底，即計畫截止期前售出40萬輛電動車。   文章來源：環球網

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

一、背景

電商平台的搜索廣告數據處理鏈路通常較長，一般會經歷如下過程：

• 廣告主在後台進行廣告投放；
• 投放廣告品及關鍵詞數據寫入數據庫；
• 數據庫中的數據通過全量構建（導入數據倉庫再進行離線批處理）或增量構建（藉助消息隊列和流計算引擎）的方式產出用於構建在線索引的“內容文件”；
• BuildService基於“內容文件”，構建出在搜索服務檢索時使用的索引。

下圖是ICBU的廣告系統的買賣家數據處理鏈路：

右半部分（BP->DB）和offline部分即為廣告投放數據的更新過程。

複雜的數據處理鏈路結合海量（通常是億級以上）的商品數據，對線上全量商品的投放狀態正確性測試提出巨大挑戰。從數據庫、到離線大規模數據聯表處理、到在線索引構建，鏈路中的任一節點出現異常或數據延遲，都有可能會對廣告主以及平台造成“資損”影響，例如：

• 廣告主在後台操作取消A商品的廣告投放，但是因為數據鏈路處理延遲，搜索引擎中A的狀態仍處於“推廣中”，導致A能繼續在買家搜索廣告時得到曝光，相應地當“點擊”行為發生時，造成錯誤扣款。
• 廣告主設定某個產品只限定對某個地域/國家的客戶投放廣告，但是因為搜索引擎的過濾邏輯處理不恰當，導致客戶的廣告品在所有地區都進行廣告投放，同樣會造成錯誤點擊扣款。

傳統的測試手段，或聚焦於廣告主後台應用的模塊功能測試，或聚焦於搜索引擎的模塊功能測試，對於全鏈路功能的測試缺乏有效和全面的測試手段。而線上的業務監控，則側重於對業務效果指標的監控，如CTR（click through rate，點擊率）、CPC（cost per click，點擊成本）、RPM（revenue per impression，千次瀏覽收益）等。對涉及廣告主切身利益和平台總營收的廣告錯誤投放問題，缺乏有效的發現機制。

我們期望對在線搜索廣告引擎所有實際曝光的商品，通過反查數據庫中曝光時刻前它的最後狀態，來校驗它在數據庫中的投放狀態與搜索引擎中的狀態的一致性，做到線上廣告錯誤投放問題的實時發現。同時，通過不同的觸發檢測方式，做到數據變更的各個環節的有效覆蓋。

二、階段成果

我們藉助日誌流同步服務(TTLog)、海量數據NoSQL存儲系統（Lindorm）、實時業務校驗平台（BCP）、消息隊列（MetaQ）、在線數據實時同步服務（精衛）以及海量日誌實時分析系統（Xflush）實現了ICBU搜索廣告錯誤投放問題的線上實時發現，且覆蓋線上的全部用戶真實曝光流量。同時，通過在數據變更節點增加主動校驗的方式，可以做到在特定場景下（該廣告品尚未被用戶檢索）的線上問題先於用戶發現。

此外，藉助TTLog+實時計算引擎Blink+阿里雲日誌服務SLS+Xflush的技術體系，實現了線上引擎/算法效果的實時透出。

下面是ICBU廣告實時質量大盤：

從八月底開始投入線上使用，目前這套實時系統已經發現了多起線上問題，且幾乎都是直接影響資損和廣告主的利益。

三、技術實現

圖一：

1. 引擎曝光日誌數據處理

對於電商搜索廣告系統，當一個真實的用戶請求觸達（如圖一中1.1）時，會產生一次實時的廣告曝光，相對應地，搜索引擎的日誌里會寫入一條曝光記錄（如圖一中2）。我們通過日誌流同步服務TTLog對搜索引擎各個服務器節點上的日誌數據進行統一的搜集（如圖一中3），然後藉助數據對賬服務平台BCP對接TTLog中的“流式”數據（如圖一中4），對數據進行清洗、過濾、採樣，然後將待校驗的數據推送到消息隊列服務MetaQ（如圖一中5）。

2. DB數據處理

圖二：

如圖二所示，通常，業務數據庫MySQL針對每個領域對象，只會存儲它當前時刻最新的數據。為了獲取廣告品在引擎中真實曝光的時刻前的最後數據，我們通過精衛監聽數據庫中的每次數據變更，將變更數據“快照”寫入Lindorm（底層是HBase存儲，支持海量數據的隨機讀寫）。

3. 數據一致性校驗

在廣告測試服務igps（我們自己的應用）中，我們通過監聽MetaQ的消息變更，拉取MetaQ中待校驗的數據（如圖一中6），解析獲得曝光時每個廣告品在搜索引擎中的狀態，同時獲得其曝光的時刻點。然後基於曝光時刻點，通過查詢Lindorm，獲得廣告品於曝光時刻點前最後在MySQL中的數據狀態（如圖一中7）。然後igps對該次廣告曝光，校驗引擎中的數據狀態和MySQL中的數據狀態的一致性。

如果數據校驗不一致，則打印出錯誤日誌。最後，藉助海量日誌實時分析系統Xflush（如圖一中8），我們可以做到對錯誤數據的實時聚合統計、可視化展示以及監控報警。

4. 數據變更節點的主動校驗

因為線上的實時用戶搜索流量具有一定的隨機性，流量場景的覆蓋程度具有很大的不確定性，作為補充，我們在數據變更節點還增加了主動校驗。

整個數據鏈路，數據變更有兩個重要節點：

• MySQL中的數據變更；
• 引擎索引的切換。

對於MySQL中的數據變更：我們通過精衛監聽變更，針對單條數據的變更信息，構建出特定的引擎查詢請求串，發起查詢請求（如圖一中1.3）。

對於引擎索引的切換（主要是全量切換）：我們通過離線對歷史（如過去7天）的線上廣告流量進行聚合分析/改寫，得到測試用例請求集合。再監聽線上引擎索引的切換操作。當引擎索引進行全量切換時，我們主動發起對引擎服務的批量請求（如圖一中1.2）。

上述兩種主動發起的請求，最後都會復用前面搭建的數據一致性校驗系統進行廣告投放狀態的校驗。

上圖是對廣告投放狀態的實時校驗錯誤監控圖，從圖中我們清晰看到當前時刻，搜索廣告鏈路的數據質量。無論是中美業務DB同步延遲、DB到引擎數據增量處理鏈路的延遲、或者是發布變更導致的邏輯出錯，都會導致錯誤數據曲線的異常上漲。校驗的規則覆蓋了推廣計劃（campaign）、推廣組（adgroup）、客戶狀態（customer）、詞的狀態（keyword）、品的狀態（feed）。校驗的節點覆蓋了曝光和點擊兩個不同的環節。

5. 引擎及算法的實時質量

圖三：

搜索引擎日誌pvlog中蘊含了非常多有價值的信息，利用好這些信息不僅可以做到線上問題的實時發現，還能幫助算法同學感知線上的實時效果提供抓手。如圖三所示，通過實時計算引擎Blink我們對TTLog中的pv信息進行解析和切分，然後將拆分的結果輸出到阿里雲日誌服務SLS中，再對接Xflush進行實時的聚合和可視化展示。

如上圖所示，上半年我們曾出現過一次線上的資損故障，是搜索應用端構造的搜索廣告引擎SP請求串中缺失了一個參數，導致部分頭部客戶的廣告沒有在指定地域投放，故障從發生到超過10+客戶上報才發現，歷經了10幾個小時。我們通過對SP請求串的實時key值和重要value值進行實時監控，可以快速發現key值或value值缺失的場景。

此外，不同召回類型、扣費類型、以及扣費價格的分佈，不僅可以監控線上異常狀態的出現，還可以給算法同學做實驗、調參、以及排查線上問題時提供參考。

四、幾個核心問題

1. why lindorm？

最初的實現，我們是通過精衛監聽業務DB的變更寫入另一個新的DB（MySQL），但是性能是一個非常大的瓶頸。我們的數據庫分了5+個物理庫，1000+張分表，單表的平均數據量達到1000+w行，總數據達到千億行。

后通過存儲的優化和按邏輯進行分表的方式，實現了查詢性能從平均1s到70ms的提升。

2. why BCP + MetaQ + igps？

最初我們是想直接使用BCP對數據進行校驗：通過igps封裝lindorm的查詢接口，然後提供hsf接口供在BCP里直接使用。

但是還是因為性能問題：TTLog的一條message平均包含60+條pv，每個pv可能有5個或更多廣告，每個廣告要查6張表，單條message在BCP校驗需要調用約60x5x6=1800次hsf請求。當我們在BCP中對TTLog的數據進行10%的採樣時，後端服務igps的性能已經出現瓶頸，hsf線程池被打滿，同時7台服務器的cpu平均使用率達到70%以上。

藉助MetaQ的引入，可以剔除hsf調用的網絡開銷，同時將消息的生產和消費解耦，當流量高峰到達時，igps可以保持自己的消費速率不變，更多的消息可以暫存在隊列里。通過這一優化，我們不僅扛住了10%的採樣，當線上採樣率開到100%時，我們的igps的服務器的平均cpu使用率仍只維持在20%上下，而且metaq中沒有出現消息堆積。

不過這樣一來，bcp的作用從原來的“採樣、過濾、校驗、報警”，只剩下“採樣、過濾”。無法發揮其通過在線編碼可以快速適應業務變化的作用。

3. why not all blink?

其實“BCP + MetaQ + igps”的流程可以被“Blink + SLS”取代，那為什麼不都統一使用Blink呢。

一方面，目前點擊的校驗由於其流量相對較小的因素，我們目前是直接在BCP里編寫的校驗代碼，不需要走發布流程，比較快捷。而且BCP擁有如“延遲校驗”、“限流控制”等個性化的功能。另一方面，從我們目前使用Blink的體驗來看，實時的處理引擎尚有一些不穩定的因素，尤其是會有不穩定的網絡抖動（可能是數據源和Blink workder跨機房導致）。

4. SP請求的key值如何拆分？

在做SP請求串的實時key值監控的時候，遇到了一個小難題：SP的請求串中參數key是動態的，並不是每個key都會在每個串中出現，而且不同的請求串key出現的順序是不一樣的。如何切分使其滿足Xflush的“列值分組”格式要求。

實現方式是，對每個sp請求串，使用Blink的udtf（自定義表值函數）進行解析，得到每個串的所有key和其對應的value。然後輸出時，按照“validKey={key}，validValue={value}”的格式對每個sp請求串拆分成多行輸出。然後通過Xflush可以按照validKey進行分組，並對行數進行統計。

五、總結及後續規劃

本文介紹了通過大數據的處理技術做到電商搜索廣告場景下數據端到端一致性問題的實時發現，並且通過“實時發現”結合“數據變更節點的主動校驗”，實現數據全流程的一致性校驗。

後續的優化方向主要有兩方面：

• 結合業務的使用場景，透出更豐富維度的實時數據。
• 將該套技術體系“左移”到線下/預發測試階段，實現“功能、性能、效果”的一鍵式自動化測試，同時覆蓋從搜索應用到引擎的全鏈路。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

Transaction事務是指一個邏輯單元，執行一系列操作的SQL語句。

事務中一組的SQL語句，要麼全部執行，要麼全部回退。在Oracle數據庫中有個名字，叫做transaction ID

在關係型數據庫中，事務必須ACID的特性。

• 原子性，事務中的操作，要不全部執行，要不都不執行
• 一致性，事務完成前後，數據的必須保持一致。
• 隔離性，多個用戶併發訪問數據庫時，每一個用戶開啟的事務，相互隔離，不被其他事務的操作所干擾。
• 持久性，事務一旦commit，它對數據庫的改變是持久性的。

目前重點討論隔離性。數據庫一共有四個隔離級別

• 未提交讀(RU,Read Uncommitted)。它能讀到一個事物的中間狀態，不符合業務中安全性的保證，違背 了ACID特性，存在臟讀的問題，基本不會用到，可以忽略

• 提交讀(RC,Read Committed)。顧名思義，事務提交之後，那麼我們可以看到。這是一種最普遍的適用的事務級別。我們生產環境常用的使用級別。

• 可重複讀(RR,Repeatable Read)。是目前被使用得最多的一種級別。其特點是有GAP鎖，目前還是默認級別，這個級別下會經常發生死鎖，低併發等問題。

• 可串行化，這種實現方式，其實已經是不是多版本了，而是單版本的狀態，因為它所有的實現都是通過鎖來實現的。

因此目前數據庫主流常用的是RC和RR隔離級別。

隔離性的實現方式，我們通常用Read View表示一個事務的可見性。

RC級別，事務可見性比較高，它可以看到已提交的事務的所有修改。因此在提交讀(RC,Read Committed)隔離級別下，每一次select語句，都會獲取一次Read View，得到數據庫最新的事務提交狀態。因此對於數據庫，併發性能也最好。

RR級別，則不是。它為了避免幻讀和不可重複讀。保證在一個事務內前後數據讀取的一致。其可見性視圖Read View只有在自己當前事務提交之後，才會更新。

那如何保證數據的一致性？其核心是通過redo log和undo log來保證的。

而在數據庫中，為了實現這種高併發訪問，就需要對數據庫進行多版本控制，通過事務的可見性來保證事務看到自己想看到的那個數據版本(或者是最新的Read View亦或者是老的Read View)。這種技術叫做MVCC

多版本是如何實現的？通過undo日誌來保證。每一次數據庫的修改，undo日誌會存儲之前的修改記錄值。如果事務未提交，會回滾至老版本的數據。其MVCC的核心原理，以後詳談

舉例論證:

##  開啟事務
MariaDB [scott]> begin;                   
Query OK, 0 rows affected (0.000 sec)

##查看當前的數據
MariaDB [scott]>  select * from dept;
+--------+------------+----------+
| deptno | dname      | loc      |
+--------+------------+----------+
|     10 | ACCOUNTING | beijing  |
|     20 | RESEARCH   | DALLAS   |
|     30 | SALES      | CHICAGO  |
|     40 | OPERATIONS | beijing  |
|     50 | security   | beijing  |
|     60 | security   | nanchang |
+--------+------------+----------+
6 rows in set (0.001 sec)

##更新數據
MariaDB [scott]> update dept set loc ='beijing' where deptno = 20;
Query OK, 1 row affected (0.001 sec)

## 其行記錄| 20 | RESEARCH | DALLAS |已經被放置在undo日誌中，目前最新的記錄被改為'beijing':
MariaDB [scott]> select * from dept;
+--------+------------+----------+
| deptno | dname      | loc      |
+--------+------------+----------+
|     10 | ACCOUNTING | beijing  |
|     20 | RESEARCH   | beijing  |
|     30 | SALES      | CHICAGO  |
|     40 | OPERATIONS | beijing  |
|     50 | security   | beijing  |
|     60 | security   | nanchang |
+--------+------------+----------+

##事務不提交，回滾。數據回滾至老版本的數據。
MariaDB [scott]> rollback;
Query OK, 0 rows affected (0.004 sec)

MariaDB [scott]> select * from dept;
+--------+------------+----------+
| deptno | dname      | loc      |
+--------+------------+----------+
|     10 | ACCOUNTING | beijing  |
|     20 | RESEARCH   | DALLAS   |
|     30 | SALES      | CHICAGO  |
|     40 | OPERATIONS | beijing  |
|     50 | security   | beijing  |
|     60 | security   | nanchang |
+--------+------------+----------+
6 rows in set (0.000 sec)

因為MVCC，讓數據庫有了很強的併發能力。隨着數據庫併發事務處理能力大大增強，從而提高了數據庫系統的事務吞吐量，可以支持更多的用戶併發訪問。但併發訪問，會出現帶來一系列問題。如下:

數據庫併發帶來的問題	概述解釋
臟讀(Dirty Reads)	當一個事務A正在訪問數據，並且對數據進行了修改，而這種修改還沒有提交到數據庫中，這時，另外一個事務B也訪問這同一個數據，如不控制，事務B會讀取這些”臟”數據，並可能做進一步的處理。這種現象被稱為”臟讀”(Dirty Reads)
不可重複讀(Non-Repeatable Reads)	指在一個事務A內，多次讀同一數據。在這個事務還沒有結束時，另外一個事務B也訪問該同一數據。那麼，在事務A的兩次讀數據之間，由於第二個事務B的修改，那麼第一個事務兩次讀到的的數據可能是不一樣的 。出現了”不可重複讀”(Non-Repeatable Reads)的現象
幻讀(Phantom Reads)	指在一個事務A內，按相同的查詢條件重新檢索以前檢索過的數據，同時發現有其他事務插入了數據，其插入的數據滿足事務A的查詢條件。因此查詢出了新的數據，這種現象就稱為”幻讀”(Phantom Reads)

隔離級別和上述現象之間的聯繫。

隔離級別有:未提交讀(RU,Read Uncommitted),提交讀(RC,Read Committed),可重複讀(RR,Repeatable Read),可串行化(Serializable)

隔離級別	臟讀	不可重複讀	幻讀
未提交讀(RU,Read Uncommitted)	可能	可能	可能
提交讀(RC,Read Committed)	不可能	可能	可能
可重複讀(RR,Repeatable Read)	不可能	不可能	可能 （間隙鎖解決）
可串行化(Serializable)	不可能	不可能	不可能

實驗環節

舉例在隔離級別RR和RC下，說明“不可重複讀”問題。

MySQL的默認級別是Repeatable Read,如下:

MariaDB [(none)]> select @@global.tx_isolation;
+-----------------------+
| @@global.tx_isolation |
+-----------------------+
| REPEATABLE-READ       |
+-----------------------+
1 row in set (0.000 sec)

這裏修改當前會話級別為Read Committed

MariaDB [scott]> set session transaction isolation level read committed;
Query OK, 0 rows affected (0.001 sec)

MariaDB [scott]> select @@tx_isolation;
+----------------+
| @@tx_isolation |
+----------------+
| READ-COMMITTED |
+----------------+
1 row in set (0.000 sec)

在隔離級別已提交讀(RC,Read Committed)下，出現了不可重複讀的現象。在事務A中可以讀取事務B中的數據。

在隔離級別可重複讀(RR,Repeatable Read)，不會出現不可重複讀現象，舉例如下:

舉例說明“幻讀”的現象。

行鎖可以防止不同事務版本的數據在修改(update)提交時造成數據衝突的問題。但是插入數據如何避免呢？

在RC隔離級別下，其他事務的插入數據，會出現幻讀(Phantom Reads)的現象。

而在RR隔離級別下，會通過Gap鎖，鎖住其他事務的insert操作，避免”幻讀”的發生。

因此，在MySQL事務中，鎖的實現方式與隔離級別有關，如上述實驗所示。在RR隔離級別下，MySQL為了解決幻讀的問題，已犧牲并行度為代價，通過Gap鎖來防止數據的寫入。這種鎖，并行度差，衝突多。容易引發死鎖。

目前流行的Row模式可以避免很多衝突和死鎖問題，因此建議數據庫使用ROW+RC(Read Committed)模式隔離級別，很大程度上提高數據庫的讀寫并行度，提高數據庫的性能。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

1. Overview

Adaptive softmax算法在鏈接1中的論文中提出，該算法目的是為了提高softmax函數的運算效率，適用於一些具有非常大詞彙量的神經網絡。

在NLP的大部分任務中，都會用到softmax,但是對於詞彙量非常大的任務，每次進行完全的softmax會有非常大的計算量，很耗時(每次預測一個token都需要O(|V|)的時間複雜度)。

所以paper中提出adaptive softmax來提升softmax的運算效率。

1) 該算法的提出利用到了單詞分佈不均衡的特點(unbalanced word distribution)來形成clusters, 這樣在計算softmax時可以避免對詞彙量大小的線性依賴關係，降低計算時間；

2) 另外通過結合現代架構和矩陣乘積操作的特點，通過使其更適合GPU單元的方式進一步加速計算。

2. Introduction

2.1 一般降低softmax計算複雜度的兩種方式

1) 考慮原始分佈：近似原始概率分佈或近似原始概率分佈的子集

2) 構造近似模型，但是產生準確的概率分佈。比如：hierarchical softmax.

(上述兩個方法可以大致區分為：一是準確的模型產生近似概率分佈，二是用近似模型產生準確的概率分佈)

2.2 本文貢獻點

paper中主要採用的上述(2)的方式，主要借鑒的是hierarchical softmax和一些變型。與以往工作的不同在於，本paper結合了GPU的特點進行了計算加速。主要

1. 定義了一種可以生成 近似層次模型 的策略，該策略同時考慮了矩陣乘積運算的計算時間。這個計算時間並非與矩陣的維數是簡單線性關係。

2. 在近來的GPU上對該模型進行了實證分析。在所提出的優化算法中也包含了對實際計算時間模型的定義。

3. 與一般的softmax相比，有2× 到 10× 的加速。這等價於在同等算力限制下提高了準確度。另外一點非常重要，該paper所提出的這種高效計算的方法與一些通過并行提高效率的方法相比，在給定一定量的training data下，對準確度並沒有損失。

3. Adaptive Softmax 

3.1 矩陣乘積運算的計算時間模型

hidden states: (B × d); Word representation: (d × k); 這兩個矩陣的乘積運算時間: g(k, B)。其中B是batch size, d: hidden layer 的size, k vectors的數量。

(1) 固定B,d, 探究k值大小與g(k)的關係：

在K40、 M40兩種GPU model中進行實驗，發現k在大約為$k_0 \approx 50$的範圍之內，g(k)是常數級別的，在$k > k_0$后，呈線性依賴關係。其計算模型為：

同樣的，關於B的計算時間的函數也呈現這樣的關係。這可以表示，矩陣相乘時，當其中一個維度很小時，矩陣乘法是低效的。

如何理解呢？比如對於 $k_1 = 2^2$, $k_2 = 2^4$，它們均在同樣的常量時間內完成運算，那麼顯然對於$k1$量級有算力被浪費了。

那麼這也說明，一些words的層次結構，其每個節點只具有少量的子節點(比如huffman 編碼的tree)，是次優的。

(2) 探究batch size B值大小與g(B)的關係：

同樣的，當探究計算用時與batch size $B$，的關係時，發現在矩陣乘法運算中，其中一個維度很小時計算並不高效。因此會導致：

(i) 在層次結構中，因為每個節點只有少數一些孩子節點 (比如Huffman 樹)，其計算效率是次優的；

(ii) 對於按照詞頻劃分clusters后，那些只包含稀有詞的cluster，被選擇的概率為p, 並且其batch size也縮減為 $p B$，也會出現以上所述的低效的矩陣乘積運算問題。

(3) 本文的計算模型

所以paper中綜合考慮了k與B，提出了下面的計算模型：

對於Adaptive Softmax， 其核心思想是根據詞頻大小，將不同詞頻區間的詞分為不同的clusters，按照詞頻高的優先訪問的原則，來對每個cluster整體，進而對cluster中的每個詞進行訪問，進行softmax操作。

那麼paper中首先以2個clusters為例，對該模型進行講解，之後推廣到多個clusters的一般情況。

3.2 Two-Clusters Case

根據Zipf定律，在Penn TreeBank中 20%的詞，可以覆蓋一般文檔中87%的出現過的詞。

直觀地，可以將字典$V$中的詞分為$V_h$、$V_t$兩個部分。其中$V_h$表示高頻詞集合(head)，$V_t$表示低頻詞集合(tail)。一般地，$|V_h| << |V_t|$，$P(V_h) >> P(V_t)$。

(1) Clusters 的組織

直觀地可以想到對於這兩個clusters有兩種組織方式：(i) 兩個clusters都是2層的樹結構，(ii) 將head部分用一個短列表保存，對tail部分用二層樹結構。何種方式更優可以就其計算效率和準確率進行比較：

在準確率方面，(i) 較之 (ii) 一般有 5 ~ 10 %的下降。原因如下：

對於屬於cluster $c$的每個詞$w$的概率計算為： 

若採用(i):  $P(c | h) * P(w | c, h)$

若採用(ii): 對於高頻詞head部分可以直接計算獲得 $P(w | h)$，其更為簡單直接。

因此，除非(i)(ii)的計算時間有非常大的差別，否則選擇(ii)的組織方式。

(2) 對計算時間的縮短

 

圖2. Two clusters示意圖

如圖2所示，$k_h = |V_h|, k_t = k – k_h, p_t = 1 – p_h$

(i) 對於第一層：對於batch size 為B的輸入，在head中對$k_h$個高頻詞以及1個單位的二層cluster的向量（加陰影部分），共$k_h + 1$個向量，做softmax，

這樣占文檔中$p_h$的詞可以基本確定下來，在head 的 short list 部分找到對應的單詞；

而如果與陰影部分進行softmax值更大，表明待預測的詞，在第二層的低頻詞部分；

第一層的計算開銷為：$g(k_h + 1, B)$

(ii) 在short list 中確定了 $p_h × B$ 的內容后，還剩下 $p_t B$的輸入需要在tail中繼續進行softmax來確定所預測的詞。

第二層中需要對$k_t$個向量做softmax；

第二層的計算開銷為：$g(k_t, pB)$

綜上，總的計算開銷為：$$C = g(k_h + 1, B) + g(k_t, p_t B)$$

相比於最初的softmax，分母中需要對詞典中的每個詞的向量逐一進行計算；採用adaptive softmax可以使得該過程分為兩部分進行，每部分只需對該部分所包含的詞的向量進行計算即可，降低了計算用時。

論文中的Figure 2显示了，對於$k_h$的合理劃分，最高可以實現相較於完全softmax的5x加速。

(3) 不同cluster的分類器能力不同

由於每個cluster基本是獨立計算的，它們並不要求有相同的能力(capacity)。

一般可以為高頻詞的cluster予以更高的capacity，而可以適當降低詞頻詞的cluster的capacity。因為低頻詞在文檔中很少出現，因此對其capacity的適當降低並不會非常影響總體的性能。

在本文中，採取了為不同的clusters共享隱層，通過加映射矩陣的方式降低分類器的輸入大小。一般的，tail部分的映射矩陣將其大小從$d$維縮小到$d_t = d / 4$維。

3.3 一般性情況

在3.2中以分為2個cluster為例，介紹了adaptive softmax如何組織並計算的，這裏將其拓展為一般情況，即可以分為多個clusters時的處理方式。

假設將整個詞典分為一個head部分和J個詞頻詞cluster部分，那麼有：

$$V = V_h \cup V_1 … V_j, V_i \cap V_j = \phi$$

其中$V_h$在第一層，其餘均在第二層，如圖Figure 3所示。

每個cluster中的詞向量的數目為$k_i = |V_i|$，單詞$w$屬於某個cluster的概率為：$p_i = \sum_{w \in V_i} p(w)$.

那麼，

計算head部分的時間開銷為：$C_h = g(J + k_h, B)$

計算每個二層cluster的時間開銷為：$\forall_i, C_i = g(k_i, p_i B)$

那麼總的時間開銷為：$C = g(J + k_h, B) + \sum_i g(k_i, p_i B) \tag8$

 

回顧公式(7):

$$g(k,B) = max(c + \lambda k_0 B_0, c + \lambda k B) \tag7$$

這裡有兩部分，一個是常數部分$c + \lambda k_0 B_0$，一個是線性變換部分$c + \lambda k B$。

通過3.1可知，在常數部分GPU的算力並未得到充分利用，因此應盡量避免落入該部分。那麼需要滿足：

$kB \geq k_0B_0$，這樣在求max時，可以利用以上的第二部分。

將(8)式代入(7)的第二部分得：

 

那麼接下來的目標就是根據(10) 以最小化時間開銷C. 

在(10)中，$J ,B$是固定的，那麼可以重點關注$\sum_i p_ik_i$與$k_h$。

(1) $\sum_i p_ik_i$

假設$p_{i + j} = p_i + p_j$, 那麼 $p_jk_j = (p_{i + j} – p_i) k_j$

$p_ik_i + p_jk_j = p_i(k_i – k_j) + p_{i + j}k_j \tag{11}$  

假設$k_i > k_j, p_{i + j}$， $k_j$均固定，那麼(11)中只有$p_i$可變，可以通過減小$p_i$的方式使(11)式減小。=> 也即$k_i > k_j$ 且 $p_i$盡量小，即包含越多詞的cluster，其概率越小。

(2) $k_h$

減小$k_h$可以使(10)式減小。 => 即為可以使高頻詞所在的cluster包含更少的詞。

綜上，給定了cluster的個數J，與batch size B，可以通過給大的cluster分配以更小的概率降低時間開銷C.

另外paper中講到可以用動態規劃的方法，在給定了J后，對$k_i$的大小進行劃分。

cluster的劃分個數$J$。paper中實驗了採用不同的J所導致的不同計算時間。如圖Figure 4所示。雖然在$10 ~ 15$區間內效果最好，但$ > 5$之後效果沒有非常明顯的提升。所以文中建議採用2~5個clusters。

實驗主要在text8, europarl, one billion word三個數據集上做的，通過比較ppl發現，adaptive softmax仍能保持低的ppl，並且相比於原模型有2x到10x的提速。

  

參考鏈接：

1. Efficient softmax approximation for GPUs: 

Some of us get dipped in flat, some in satin, some in gloss. But every once in a while you find someone who’s iridescent, and when you do, nothing will ever compare. ~ Flipped

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

一二面（基礎面）

1. 一面基礎面

1.1 面試準備

1.1.1 個人簡歷

• 基本信息：姓名-年齡-手機-郵箱-籍貫
• 工作經歷：時間-公司-崗位-職責-技術棧-業績（哪些成就）
• 學歷： 博士 > 碩士 > 本科 > 大專
• 工作經歷：時間-公司-崗位-職責-技術棧-業績
• 開源項目：GitHub和說明

1.2.2 自我陳述

1.2.2.1 把我面試的溝通方向（別把自己帶到坑裡面）

答：我平時喜歡研究一些網站，並對一些技術的原理和好玩的點感興趣，我自己也喜歡思考，也喜歡嘗試探索有沒有更好的方式和實現。（有所收留，不要全部說出來，稍微留一點懸念留作面試官來提問）

1.2.2.2 豁達、自信的適度發揮

答：適當自信，向自己擅長的方向上面來引路；要讓面試官來欣賞我，而不是來鄙視他。

1.2.2.3 自如談興趣

（豁達自信，適當收住），巧妙演示實例，適時討論疑問（不知道的問題請求指導一下，如何去解決，不要說不知道，或者不了解）

1.2.2.4 節奏要適宜

切忌小聰明（盡量把問題的所有實現方法都寫出來，表現出來的是熟練）

1.2 面試實戰

[!NOTE]
> 1. 方向要對，過程要細（性能優化，過程詳細）
> 2. 膽子要大、心態要和（算法題認真思考，認真使勁想；敢於承擔責任，不要輕易放棄）

2. CSS相關

2.1 頁面布局

2.1.1 如何實現垂直居中布局呢？

1.已知寬高

/*v1*/
.container {
    position: absolute;
    left: 50%;
    top: 50%;
    marigin-left: -width / 2;
    marigin-top: -width / 2;
}

/*v2*/
.container {
    position: absolute;
    top: calc(50% - 5em);
    left: calc(50% - 9em);
}

2.未知寬高

/*v1*/
.container {
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
}

/*v2:flex+ auto*/
.wrapper {
    dislay: flex;
}
.content {
    margin: auto;
}

/*v3. 父元素居中*/
.wrapper {
    display: flex;
    /* 盒子橫軸的對齊方式 */
    justify-content: center;
    /* 盒子縱軸的對齊方式 */
    align-items: center;
}

/*v4.body內部居中*/
.content {
     /* 1vh = 1% * 視口高度 */
      margin: 50vh auto;
      transform: translateY(-50%);
}

2.1.2 如何實現水平居中布局呢？

1. 如果需要居中的元素為常規流中 inline / inline-block 元素，為父元素設置 text-align: center;
2. 父元素上設置 text-align: center; 居中元素上margin 為 auto。
3. 如果元素positon: absolute; 那麼
   • 0）設置父元素postion: relative
   • 1）為元素設置寬度，
   • 2）偏移量設置為 50%，
   • 3）偏移方向外邊距設置為元素寬度一半乘以-1

2.1.3 如何實現三欄布局呢？

1. left和right寫在center前面，並且分別左右浮動；
2. 左右區域分別postion：absolute，固定到左右兩邊;中間的這個div因為是塊級元素，所以在水平方向上按照他的包容塊自動撐開。
3. 父元素display: table;並且寬度為100%; 每一個子元素display: table-cell; 左右兩側添加寬度，中間不加寬度
4. 包裹這個3個塊的父元素display: flex; 中間的元素flex: 1;
5. 網格布局

/* 網格布局 */
.wrapper {
    display: grid;
    width: 100%;
    grid-template-columns: 300px 1fr 300px;
}

2.2 知道CSS動畫的實現嗎？

[!NOTE]
知道transition 過渡動畫和animation 關鍵幀動畫區別和具體實現。

• 1.CSS動畫實現輪播圖
• 2.CSS動畫實現旋轉的硬幣
• 3.CSS動畫實現鐘擺效果

2.3 CSS盒子模型

2.3.1 說一下CSS的盒子模型？標準模型和IE模型的區別？CSS如何設置這兩種模型？

• 標準盒子模型：width = content

• IE盒子模型：width = content + pading + border

• box-sizing : content-box

• box-sizing : border-box

2.4 CSS樣式獲取

2.4.1 JS如何設置獲取盒子模型對應的寬度和高度？(面試重點)

• dom.style.width/height ： 只能取到內聯樣式的的屬性信息（拿不到外部引入的CSS樣式信息的）
• dom.currentStyle.width/height : 會拿到瀏覽器渲染之後的屬性信息（IE瀏覽器）
• window.getComputedStyle(dom).width/height : Chrome/Firefox 兼容， Firefox可以通過document.defaultView.getComputedStyle(dom)的方式來獲取
• dom.getBoundingClientRect().width/height : 可以獲取距離viewport位置的寬度和高度

2.5 BFC

2.5.1 根據盒子模型解釋邊距額重疊問題？邊距重疊問題的解決方案？

• 父子元素
• 兄弟元素
• 其他 ————————–計算方式：以參數的最大值來進行計算

解決方案：對父級元素創建BFC

2.5.2 BFC原理

[!NOTE]
BFC： 塊級格式化上下文，IFC（內聯格式化上下文）

1. 在BFC的垂直邊距上面會發生重疊
2. BFC的區域不會與浮動元素的BOX重疊
3. BFC在頁面上是一個獨立的渲染區域，外部的元素不會影響到我，同時也不會影響到外部的元素
4. 計算BFC的高度的時候，浮動元素也會參与運算

2.5.3 如何創建BFC？

1. float值不是none
2. position值不是static或者relative
3. display值為table, table-cell, inline-box1.
4. overflow : auto/hidden

2.5.4 BFC的使用場景？（重點理解）

1. 解決邊距的重疊問題

<section id="margin">
        <style>
            #margin {
                background-color: #4eff35;
                overflow: hidden;
            }
            #margin>p {
                /*上 左右 下*/
                margin: 5px auto 25px;
                background-color: #ff255f;
            }
        </style>
        <p>1</p>
        <!--把一個元素放在一個容器裏面，為這個容器創建BFC即可解決邊距重疊問題-->
        <div style="overflow: hidden">
            <p>2</p>
        </div>

        <p>3</p>
</section>

1. BFC 不與float部分重疊的解決

<section id="layout">
      <style>
          #layout {
              background-color: #48adff;
          }
          #layout .left {
              float: left;
              height: 300px;
              width: 200px;
              background-color: #ff4344;
          }
          #layout .right {
              height: 400px;
              background-color: #ff255f;
              /*給右邊的這個盒子容器創建一個BFC, 這個容器裏面的內容就會沿着垂直方向延伸*/
              overflow: auto;
              /*overflow: auto;*/
              /*display: table;*/
              /*float: left;*/
              /*position: fixed;*/
          }
      </style>
      <div class="left">
          LEFT
      </div>
      <div class="right">
          RIGHT
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
          <p>111</p>
      </div>
  </section>

1. BFC子元素即使是float元素也要參与運算

<section id="float">
      <style>
          /*一個盒子內部的內容如果是浮動的話，那麼這個盒子的內容實際上是不參与父容器高度計算的*/
          #float {
              background-color: red;
              /*overflow: hidden;*/
              float: left;
          }
          #float .float {
              float: left;
              font-size: 30px;
          }
      </style>
      <div class="float">
          我是浮動的元素
      </div>
</section>

3. 事件相關

3.1 DOM事件

3.1.1 DOM事件的級別有哪些？

[!NOTE]
DOM級別一共可以分為四個級別：DOM0級、DOM1級、DOM2級和DOM3級。而DOM事件分為3個級別：DOM0級事件處理，DOM2級事件處理和DOM3級事件處理。

1. DOM0 : element.onclick = function(e) {}
   DOM1 ：該標準中未涉及到事件綁定的相關東西
2. DOM2 : element.addEventListener(‘click’, function(e){}, false)， 一個DOM元素可以添加多個事件
3. DOM3 : element.addEventListener(‘keyup’, function(e){}, false)，在DOM2標準基礎上面增加了新的事件類型：鼠標事件，鍵盤事件，焦點事件

3.1.2 DOM事件模型有哪些？

1. 事件捕獲：從外向內, window -> document -> body -> button
2. 事件冒泡：從內向外，button -> body -> document -> window

3.1.3 DOM事件流？

瀏覽器為當前的頁面與用戶進行交互的過程中，點擊鼠標後事件如何傳入和響應的呢？

• 1. 捕獲階段：從外部容器開始向內
• 1. 目標階段：事件通過捕獲到達目標階段
• 1. 冒泡階段：從目標元素再上傳到window對象

3.1.4 什麼事件可以代理？什麼事件不可以代理呢？

什麼樣的事件可以用事件委託，什麼樣的事件不可以用呢？

[!NOTE]

1. 通常支持事件冒泡（Event Bubbling）的事件類型為鼠標事件和鍵盤事件，例如：mouseover, mouseout, click, keydown, keypress。
2. 接口事件(指的是那些不一定與用戶操作有關的事件)則通常不支持事件冒泡（Event Bubbling），例如：load, change, submit, focus, blur。

很明顯：focus 和 blur 都屬於不支持冒泡的接口事件。既然都不支持冒泡，那又如何實現事件代理呢？

3.1.5 IE和DOM事件流的區別？

IE採用冒泡型事件 Netscape使用捕獲型事件 DOM使用先捕獲后冒泡型事件

1. 冒泡型事件模型： button -> div -> body (IE瀏覽器本身只支持Bubbling不支持Capturing)
2. 捕獲型事件模型： body -> div-> button (Netscape事件流，網景瀏覽器公司)
3. DOM事件模型： body -> div -> button -> button -> div -> body (先捕獲后冒泡，除了IE以外的其他瀏覽器都支持標準的DOM事件處理模型)

[!NOTE]

• 規範和瀏覽器實現的差別？
  • DOM2級事件規範的捕獲階段，事件從文檔節點document開始傳播，現代瀏覽器大多數都是從window對象開始傳播事件的；
  • DOM2級事件規範捕獲階段不涉及事件目標，現代瀏覽器大多數都在這個階段包含事件目標。

3.1.6 事件對象event的屬性方法的差別?

        IE                    DOM
cancelBubble = true    stopPropagation()    // 停止冒泡
returnValue = false    preventDefault()     // 阻止元素默認事件
srcEelement            target               // 事件目標

3.1.7 描述DOM事件捕獲的具體流程？

window -> document -> HTML標籤 -> body -> … -> 目標元素

[!NOTE]
關鍵點： 注意根節點是window這個對象的

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
  <div id="container">
      <style>
          #container {
              width: 200px;
              height: 200px;
              background-color: #ff255f;
          }
      </style>
  </div>
  <script>
      // 事件捕獲機制
      window.addEventListener('click', function(){
          console.log('window capture');
      }, true)
      document.addEventListener('click', function () {
          console.log('document capture');
      }, true)
      document.documentElement.addEventListener('click', function () {
          console.log('HTML capture');
      }, true)
      document.body.addEventListener('click', function () {
          console.log('body capture');
      }, true)
      document.getElementById('container').addEventListener('click', function () {
          console.log('container capture');
      }, true)

      // 事件冒泡機制
      window.addEventListener('click', function(){
          console.log('window capture');
      })
      document.addEventListener('click', function () {
          console.log('document capture');
      })
      document.documentElement.addEventListener('click', function () {
          console.log('HTML capture');
      })
      document.body.addEventListener('click', function () {
          console.log('body capture');
      })
      document.getElementById('container').addEventListener('click', function () {
          console.log('container capture');
      })

      // 輸出結果
      window capture  --> document capture --> HTML capture --> body capture --> container capture --> container capture -->  body capture --> HTML capture --> document capture --> window capture
  </script>
</body>
</html>

3.1.8 如何拿到HTML這個標籤節點元素呢？(加分項)

  var html = document.documentElement;

3.1.9 描述Event對象的常見應用？

1. e.preventDefault() : 阻止默認事件（如阻止a標籤的默認跳轉行為）
2. e.stopPropagation() : 阻止事件冒泡的行為
3. *** e.stopImmediatePropagation() : 事件響應的優先級的應用場景，如果一個元素綁定了多個事件，但是又不想讓其他的事件執行的時候使用該方法【也會阻止冒泡】
4. e.currentTarget : 當前所綁定的事件對象

  document.documentElement.onclick = function(e) {
    console.log(e.currentTarget, e.target);       // <html><body>...</body></html>（）給綁定事件的那個元素, 當前被點擊的那個元素
  }

[!NOTE]
e.target : 當前被點擊的元素，父元素使用事件代理的方式來實現，可以直接使用該屬性獲取被點擊的那個元素

3.2 如何自定義事件？(重點))

3.2.1 如何給一個按鈕綁定一個自己定義的事件呢？

  // v1. 使用Event對象來自定義事件
  // 開始創建一個自己定義的事件對象
  var eve = new Event('customEvent');
  // 使用dom2事件處理的方式來給這個元素綁定一個事件
  var dom = document.documentElement;
  dom.addEventListener('customEvent', function(e) {
    console.log('customEvent called!');
  });
  // 下面的這句話可以在適合的場景中來觸發一個自己定義的事件對象
  setTimeout(function(){
    // 在1s之後觸發這個事件
    dom.dispatchEvent(eve);
  }, 1000)


  // v2. 使用CustomEvent來實現自定義事件
  var dom = document.documentElement;
  // 使用CustomEvent的方式可以在事件觸發的時候傳遞一個參數，然後通過e.detail 的方式來獲取這個參數信息
  var myClick = new CustomEvent('myClick', {detail : {name : 'zhangsan', age : 24}});
  dom.addEventListener('myClick', function(e){
    console.log(e.detail, e.target)
  })
  dom.dispatchEvent(myClick);

4. HTTP協議

4.1 HTTP協議的主要特點？

• 簡單快速
• 靈活
• 無連接
• 無狀態

4.2 HTTP報文的組成部分？

• 請求報文
  請求行：請求方法 資源地址 HTTP版本
  請求頭： key : value
  空行 :
  請求體 : name=zhangsan&age=18
• 響應報文 : HTTP版本 狀態碼
  狀態行
  響應頭
  空行
  響應體

4.3 HTTP方法？

• GET : 獲取資源
• POST ： 傳輸資源
• PUT ：更新資源
• DELETE ： 刪除資源
• HEAD ：獲取報文首部
• OPTIONS : 允許客戶端查看服務器的性能。

4.4 POST和GET的區別？

1. GET請求在瀏覽器回退的時候是無害的，而POST會再次提交請求
2. GET請求產生的URL地址可以被收藏，而POST不可以
3. GET請求會被瀏覽器主動緩存，而POST不會，除非主動設置
4. GET請求只能進行URL編碼，而POST支持多種編碼方式
5. GET請求參數會被完整第保留在瀏覽器的歷史記錄裏面，而POST參數不會被保留
6. GET請求愛URL中傳送的參數的長度是有限的（2KB），而POST沒有限制
7. 對參數的數據類型，GET值接受ASCII字符，而POST沒有限制
8. POST比GET更安全，GET參數直接暴露在URL上，所以不能用來傳遞敏感信息
   9. GET參數通過URL傳遞，POST參數直接放在了Request body中

4.5 HTTP狀態碼？

4.5.1 狀態碼的第一位

• 1xx ：指示信息-表示請求已接收，繼續處理（重點）
• 2xx ：成功-表示請求已被成功接收
• 3xx ：重定向-要完成請求必須進行更進一步的操作
• 4xx ：客戶端錯誤-請求有語法錯誤或請求無法實現
• 5xx ：服務器錯誤-服務器未能實現合法的請求

4.5.2 狀態碼詳解

• 200 OK ： 客戶端請求成功
• 206 Partial Content ： 客戶端發送了一個帶有Range頭的GET請求（Video標籤或者audio標籤在請求數據的時候）
• 301 Moved Permanently ： 請求的頁面已經轉移到了新的URL
• 302 Found ： 所請求的頁面已經臨時轉移到了新的URL
• 304 Not Modified ：客戶端有緩衝的文檔併發出了一個條件下的請求，原來緩衝的文檔還可以繼續使用
• 400 Bad Request ： 客戶端請求有語法錯誤，不被服務器所理解
• 401 Unauthorized ： 請求未經授權，這個狀態碼必須和WWW-Authenticate報頭域一起使用
• 403 Forbidden：對被請求頁面的訪問被禁止
• 404 Not Found ： 請求資源不存在
• 500 Internal Server Error ：服務器發生不可預期的錯誤，原來緩衝的文檔還可以繼續使用
• 503 Service Unavailable ： 請求未完成，服務器臨時過載或宕機，一段時間后可能恢復正常

4.6 什麼是持久連接？

[!NOTE]
HTTP協議採用‘請求-應答’模式， HTTP1.1版本才支持的，使用Keep-alive字段可以建立一個長連接，從而不需要每次請求都去建立一個新的連接。

4.7 什麼是管線化？

4.7.1 基本概念

• 在使用持久連接（Keep-alive）的情況下，某個連接上的消息的傳遞類似於：請求1 –> 響應1 –> 請求2 –> 響應2 –> 請求3 –> 響應3
• 管線化的過程： 請求1 –> 請求2 –> 請求3 –> 響應1 –> 響應2 –> 響應3

4.7.2 管線化的特點（特點）

1. 管線化機制通過持久連接完成，僅在HTTP1.1版本之後支持
2. 只有GET和HEAD請求可以進行管線化，POST有所限制的
3. 初次創建連接的時候不應該啟動管線機制，因為對方（服務器）不一定支持HTTP1.1版本的協議
4. 管線化不會影響到響應到來的順序，HTTP響應返回的順序並未改變
5. HTTP1.1 要求服務器支持管線化，但並不要求服務器也對響應進行管線化處理，只是要求對於管線化的請求不失敗即可
6. 由於上面提到的服務器端問題，開啟管線化很可能並不會帶來大幅度的性能提升，而且很多服務器和代理程序對管線化的支持並不好，因此現代的瀏覽器如Chrome和Firefox默認並沒有開啟管線化支持

5. 原型鏈

5.1 創建對象的幾種方法？

// 1. 使用字面量的方式來創建
var o1 = {name : 'zhangsan'};
var o11 = new Object({name : 'zhangsan'});

// 2. 使用普通構造函數的方式來創建
var M = function(){
    this.name = 'zhangsan';
}
var o2 = new M();

// 3. Object.create方法
var p = {name : 'zhangsan'};
var o3 = Object.create(p);

5.2 原型、構造函數、實例、原型鏈？

構造函數：使用new運算符來聲明一個實例（任何函數都是可以通過構造函數來使用的）

原型鏈：通過原型鏈可以找到上一級別的原型對象

原型對象：多個實例公用的數據和屬性或者方法

5.3 instanceof的原理？

[!NOTE]
instanceof 檢測一個對象A是不是另一個對象B的實例的原理是：查看對象B的prototype指向的對象是否在對象A的[[prototype]]鏈上。如果在，則返回true,如果不在則返回false。不過有一個特殊的情況，當對象B的prototype為null將會報錯(類似於空指針異常)。

// 2. 使用普通構造函數的方式來創建
var M = function(){
  this.name = 'zhangsan';
}
var o2 = new M();
undefined
o2.__proto__ == M.prototype
true
o2.__proto__ == M.prototype
true
o2.__proto__.constructor === Object
false
o2.__proto__.constructor === M
true

5.4 new運算符的原理？

1. 一個新對象被創建。它繼承於foo.prototype
2. 構造函數foo被執行。執行的時候，相應的傳參會被傳入，同時上下文(this)會被指定為這個新實例，new foo等同於 new foo(),只能用在不傳遞任何參數的情況
3. 如果構造函數返回了一個“對象”，那麼這個對象會取代整個new出來的結果。如果構造函數沒有返回對象，那麼new 出來的結果為步驟1創建的對象

// new 一個對象的過程
var _new = function (fn) {
  // 1. 創建一個對象，這個對象要繼承fn這個構造函數的原型對象
  var o = Object.create(fn.prototype);
  // 2. 執行構造函數
  var k = fn.call(o, arguments);
  // 3. 看下執行的這個函數的運行效果是不是函數
  if (typeof k === 'object'){
      return k;
  }
  else
  {
      return o;
  }
}

6. 面向對象

6.1 類與繼承：如何實現繼承，繼承的幾種實現方式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<script>
  // 類的聲明
  function Animal1() {
      this.name = 'name';
  }
  // ES6 中的class的聲明
  class Animal2 {
      constructor(){
          this.name = 'name';
      }
  }

  console.log(new Animal1(), new Animal2());
  ///////////////////////////////////////////////////////////////////////////////////////////


  // 如何實現類的繼承呢？？？-----------本質：原型鏈
  // v1. 藉助構造函數實現繼承
  function Parent1() {
      this.name = 'parent1'
  }
  Parent1.prototype.sayHello = function () {
      console.log('hello');
  }
  function Child1() {
      // 執行父親的構造函數：
      // 1. 實現原理：將父級函數的this指向了這個子類的實例上面去了
      // 2. 缺點：父親的原型鏈上面的方法或者屬性不能被繼承；只能實現部分繼承
      Parent1.call(this);
      this.type = 'child1';
  }
  // 沒有參數的時候，可以直接new + 函數名稱
  console.log(res = new Child1);




  // v2. 藉助原型鏈實現繼承
  function Parent2() {
      this.name = 'parent2';
      this.data = [1, 2, 3];
  }
  Parent2.prototype.sayHello = function () {
      console.log('hello');
  }
  function Child2() {
      this.type = 'child2';
  }
  // prototype 就是為了讓這個對象的實例可以訪問到原型鏈上的內容
  Child2.prototype = new Parent2();
  // new Child2().__proto__ === Child2.prototype  // true
  // new Child2().__proto__.name                  // parent2
  // 原型鏈繼承的缺點：
  // 1. 原理：通過修改原型鏈來實現對象的繼承關係
  // 2. 缺點：修改第一個對象上面的屬性，會直接修改第二個對象屬性數據(引用類型)
  var c1 = new Child2();
  var c2 = new Child2();
  c1.data.push(100, 200, 300);

  // v3. 組合繼承
  function Parent3() {
      this.name = 'parent3';
      this.data = [1, 2, 3];
  }
  function Child3() {
      // 1. 借用構造函數繼承
      Parent3.call(this);
      this.type = 'child3';
  }
  // 2. 原型鏈繼承
  // child3的原型對象是Parent3的一個實例對象，但是這個實例對象中是沒有constructor這個屬性的，因此尋找屬性的時候回沿着這個實例對象的原型鏈繼續向上尋找new Parent3().prototype 這個原型對象的，
  // 最終在Parent3.prototype這個原型對象中找到了這個屬性，new一個對象找的實際上是{Parent3.prototype.constructor : Parent3}
  Child3.prototype = new Parent3();
  var c1 = new Child3();
  var c2 = new Child3();
  c1.data.push(100, 200, 300);
  // 組合繼承的特點：
  // 1. 原理：結合借用構造函數繼承和原型鏈繼承的優點，摒棄二者的缺點
  // 2. 缺點：父類構造函數在創建實例的時候總共執行了兩次（new Parent3(), new Child3()）


  // v4. 組合繼承的優化1
  function Parent4() {
      this.name = 'parent4';
      this.data = [1, 2, 3];
  }
  function Child4() {
      // 1. 借用構造函數繼承
      Parent4.call(this);
      this.type = 'child4';
  }
  // 讓子類的構造函數的原型對象和父類構造函數的原型對象執向同一個對象(都是同一個對象)
  Child4.prototype = Parent4.prototype;
  // 測試
  var c1 = new Child4();
  var c2 = new Child4();
  console.log(c1 instanceof Child4, c1 instanceof Parent4);
  console.log(c1.constructor)         // Parent4? 如何實現：c1.constructor(c1.__proto__.constructor) === Child4 呢？
  // 缺點：
  // 1. 無法通過原型對象的constructor屬性來獲取對象的屬性對應的構造函數了(子類和父類公用的是一個contructor)
  // 2. obj instanceof Child4 === true; obj instanceof Parent4 === true
  // 3. obj.__proto__.constructor === Child4; obj.__proto__.constructor === Parent4  ???

  // v5. 組合繼承的優化2【完美寫法】
  function Parent5() {
      this.name = 'parent5';
      this.data = [1, 2, 3, 4, 5];
  }
  function Child5(){
      Parent5.call(this);
      this.type = 'child5';
  }

  // 通過創建中間對象的方式來把兩個對象區分開
  // var obj = new Object(); obj.__proto__ = Constructor.prototype;
  // 1. Object.create創建的對象obj, 這個obj的原型對象就是參數
  // 2. Child5的原型對象是Child5.prototype
  // 3. Child5.prototype = obj，obj這個對象相當於就是一个中間的橋樑關係
  Child5.prototype = Object.create(Parent5.prototype);
  // 當前的方式還是會按照原型鏈一級一級向上尋找的, 給Child5的原型對象上面綁定一個自己定義的constructor屬性
  Child5.prototype.constructor = Child5;

  // var s1 = new Child5()

  // 上面的代碼等價於
  var obj = Object.create(Parent5.prototype);     // obj.prototype = Parent5.prototype
  Child5.prototype = obj;
  Child5.prototype.constructor = Child5;
  // 1. 對象之間就是通過__proto__ 屬性向上尋找的
  // 2. 尋找規則： child5 ---> Child5.prototype ---> obj(Object.create(Parent5.prototype)) ---> Parent5.prototype


  // 技巧：不要讓面試官問太多題目：拖拉時間【擠牙膏】，把一個問題盡量吃透
  // 消化這一塊內容
</script>
</body>
</html>

[!WARNING]
面試技巧

1. 不要讓面試官問太多題目：拖拉時間【擠牙膏】，把一個問題盡量吃透
2. 知識深度

7. 通信

7.1 什麼是同源策略個限制？

[!NOTE]
同源策略限制是從一個源加載的文檔或腳本如何與來自另一個源的資源進行交互。這是一個用於隔離潛在惡意文件的關鍵的安全機制。（一個源的文檔或腳本是沒有權利直接操作另外一個源的文檔或腳本的）

1. Cookie， LocalStorage和IndexDB無法讀取
2. DOM無法獲得；（document.body是無法獲取的）
3. Ajax請求不能發送

7.2 前後端如何進行通信呢？

1. Ajax（有同源策略限制）；Fetch API則是XMLHttpRequest的最新替代技術， 它是W3C的正式標準
2. WebSocket：支持跨域請求數據，沒有同源策略的限制
3. CORS：新的協議通信標準；CORS則將導致跨域訪問的請求分為三種：Simple Request，Preflighted Request以及Requests with Credential；cors相對於jsonp而言的好處就是支持所有的請求方式，不止是get請求，還支持post,put請求等等，而它的缺點就很明顯，無法兼容所有的瀏覽器，對於要兼容到老式瀏覽器而言，還是使用jsonp好點

7.3 如何創建Ajax呢？

1. XMLHttpRequest對象的工作流程
2. 瀏覽器的兼容性處理【重點】
3. 事件的觸發條件
4. 事件的觸發順序

  function ajax(params){
    // 1. 創建對象，考慮兼容性【重點】
    var xhr = XMLHTTPRequest ? new XMLHTTPRequest() : new window.ActiveXObject('Microsoft.XMLHTTP');      // *** 兼容性問題必須考慮
    // 2. 打開連接
    var type = params.type || 'GET',
        url = params.url || '',
        data = params.data || {},
        success = params.success,
        error = params.error,
        dataArr = [];
    for (var k in data) {
      dataArr.push(k + '=' + data[k]);
    }
    //帶上Cookie
    xhr.withCredentials = true;
    if (type.toUpperCase() === 'GET') {
      // get
      url += '?' + dataArr.join('&');
      // 問號結尾的話，直接替換為空字符串
      xhr.open(type, url.replace(/\?$/g, ''), true);
      // GET 請求的話，是不需要再send方法中帶上參數的
      xhr.send();
    }
    else {
      // POST
      xhr.open(type, url, true);
      xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
      // POST 請求需要把數據放在send方法裏面， data = name=zhangsna&age=18&sex=male
      xhr.send(dataArr.join('&'));
    }
    // 開始監聽變化
    xhr.onreadystatechange = function(){
      // 這裏需要考慮強緩存和協商緩存的話直接處理，206是媒體資源的創建方式
      if (xhr.readyState === 4 && xhr.status === 200 || xhr.status === 304) {
          var res;
          if (success instanceof Function) {
            res = xhr.responseText;
            if (typeof res === 'string') {
              res = JSON.parse(res);
              // 開始執行成功的回調函數
              success.call(xhr, res);
            }
          } else {
            if (error instanceof Function) {
              // 失敗的話直接返回這個responseText中的內容信息
              error.call(xhr, res);
            }
          }
      }
    }
  }

7.4 跨域通信的幾種方式？

7.4.1 JSONP

  function jsonp(url, onsuccess, onerror, charset){
    // 1. 全局註冊一個callback
    var callbackName = 'callback' + Math.random() * 100;
    window[callbackName] = function(){
      if (onsuccess && typeof onsuccess === 'Function') {
        onsuccess(arguments[0]);
      }
    }
    // 2. 動態創建一個script標籤
    var script = document.createElement('script');
    script.setAttribute('type', 'text/javascript');
    charset && script.setAttribute('charset', charset);
    script.setAttribute('src', url);
    script.async = true;
    // 3. 開始監聽處理的過程
    script.onload = script.onreadystatechange = function(){
      if (!script.readyState || /loaded|complete/.test(script.readyState)) {
        // 4. 成功之後移除這個事件
        script.onload = script.onreadystatechange = null;
        // 刪除這個script的DOM對象（head.removeChild(script), 這個DOM節點的父節點相當於是head標籤這個父節點）
        script.parentNode && script.parentNode.removeChild(script);
        // 刪除函數或變量
        window[callbackName] = null;
      }
    }
    script.onerror = function(){
      if (onerror && typeof onerror === 'Function') {
        onerror();
      }
    }
    // 5. 開始發送這個請求(把這個標籤放在頁面中的head標籤中即可)
    document.getElementsByTagName('head')[0].appendChild(script);
  }

7.4.2 Hash

hash 改變后頁面不會刷新的

[!NOTE]
使用場景：當前的頁面A通過iframe或者frame嵌入了跨域的頁面

  // 1. A頁面中的代碼如下
  var B = document.getElementsByTagName('iframe');
  B.src = B.src + '#' + JSON.stringfy(data);
  // 2. B中的偽代碼如下
  window.onhashchange = function(){
    var data = window.location.hash;    // 接受數據
    data = JSON.parse(data);
  }

7.4.3 postMessage(HTML5中新增)

[!NOTE]
使用場景： 可以實現窗口A(A.com)向窗口B(B.com)發送信息

  // 1. 窗口B中的代碼如下
  var BWindow = window;
  BWindow.postMessage(JSON.stringfy(data), 'http://www.A.com');   
  // 2. 窗口A中代碼
  var AWindow = window;
  AWindow.addEventListener('message', function(e){
      console.log(e.origin);                  // http://www.B.com
      console.log(e.source);                  // BWindow

      e.source.postMessage('已成功收到消息');

      console.log(JSON.parse(e.data));        // data
  }, false)
  // 父窗口給子窗口發信息，需要用iframe的contentWindow屬性作為調用主體
  // 子窗口給父窗口發的信息需要使用window.top，多層iframe使用window.frameElement

7.4.4 . WebSocket

[!NOTE]
不受同源策略影響，可以直接使用

  var ws = new window.WebSocket('ws://echo.websocket.org');

  // 打開連接
  ws.onopen = function(e){
    console.log('Connection open ……');
    ws.send('Hello WebSocket!');
  }

  // 接受消息
  ws.onmessage = function(e){
    console.log('Received Message : ', e.data);
  }

  // 關閉連接
  ws.onclose = function(e){
    console.log('Connection closed');
  }

7.4.5 CORS

支持跨域通信版本的Ajax，是一種新的標準（Origin頭）【ajax的一個變種，適用於任何】

  fetch('/get/name', {
    method : 'get'
  }).then(function(response){
    console.log(response);
  }).catch(function(err){
    // 出錯了；等價於then的第二個參數
  });
  // 原因：瀏覽器默認會攔截ajax請求，會根據頭中的origin消息進行判斷處理消息；Origin字段用來說明，本次請求來自哪個源（協議 + 域名 + 端口）。服務器根據這個值，決定是否同意這次請求。JSONP只支持GET請求，CORS支持所有類型的HTTP請求。JSONP的優勢在於支持老式瀏覽器，以及可以向不支持CORS的網站請求數據。

7.4.5.1 CORS請求的基本流程

1. 對於簡單請求，瀏覽器直接發出CORS請求。具體來說，就是在頭信息之中，增加一個Origin字段。
2. Origin字段用來說明，本次請求來自哪個源（協議 + 域名 + 端口）。服務器根據這個值，決定是否同意這次請求。
3. 如果Origin指定的源，不在許可範圍內，服務器會返回一個正常的HTTP回應。瀏覽器發現，這個回應的頭信息沒有包含Access-Control-Allow-Origin字段（詳見下文），就知道出錯了，從而拋出一個錯誤，被XMLHttpRequest的onerror回調函數捕獲。
4. 如果Origin指定的域名在許可範圍內，服務器返回的響應，會多出幾個頭信息字段。

  Access-Control-Allow-Origin: http://api.bob.com   // 必需的字段
  Access-Control-Allow-Credentials: true            // 可選字段： 是否允許發送cookie
  Access-Control-Expose-Headers: FooBar
  Content-Type: text/html; charset=utf-8

1. 簡單請求的CORS請求，會在正式通信之前，增加一次HTTP查詢請求，稱為”預檢”請求（preflight）。OPTIONS表示當前的這個請求是用來詢問的；服務器收到”預檢”請求以後，檢查了Origin、Access-Control-Request-Method和Access-Control-Request-Headers字段以後，確認允許跨源請求，就可以做出回應。

7.4.5.2 JSONP和CORS的區別？

1. JSONP只支持GET請求，CORS支持所有類型的HTTP請求
2. JSONP的優勢在於支持老式瀏覽器，以及可以向不支持CORS的網站請求數據。

8. 安全

8.1 CSRF

8.1.1 基本概念和縮寫

CSRF： 跨站請求偽造，Cross site request forgery

8.1.2 CSRF 攻擊原理

8.1.3 可以成功攻擊的條件？

1. 目標網站存在CSRF漏洞的請求接口（一般為get請求）
2. 目標用戶之前已經成功登錄過這個網站（留下了Cookie）

8.1.4 如何防禦呢？

1. Token驗證：訪問服務器接口的時候，會自動帶上這個token
2. Referer驗證：驗證網站的頁面來源（只有我當前網站下的頁面才可以請求，對於來自其他網站的請求一律攔截）
3. 隱藏令牌： 隱藏信息會放在header中（類似於Token）

8.2 XSS

8.2.1 基本概念和縮寫

XSS： cross-site scripting, 跨站腳本攻擊

8.2.2 XSS防禦

攻擊原理: 注入JS腳本

防禦措施: 讓JS代碼無法解析執行

8.3 CSRF和XSS的區別呢？

1. CSRF：網站本身存在漏洞的接口，依賴這些登錄過目標網站的用戶來實現信息的竊取；
2. XSS：向頁面中注入JS執行，JS函數體內執行目標任務；

[!NOTE]

1. 一定要說出中文名稱，實現原理，防範措施都說出來
2. 不要拖泥帶水，言簡意賅

9. 算法

[!NOTE]
算法攻略：多刷題才是硬道理！！！

二三面（知識深度面）

10. 渲染機制

10.1 什麼是DOCTYPE及作用？

1. DTD（Document Type Definition）：文檔類型定義，是一系列的語法規則，用來定義XML或者(X)HTML的文件類型。瀏覽器會使用它來判斷文檔的類型，決定使用哪一種協議來解析，以及切換瀏覽器模式；
2. DOCTYPE： 是用來聲明文檔類型和DTD規範的，一個主要的用途是文件的合法性驗證；如果文件代碼不合法，那麼瀏覽器解析的時候就會出現一些出錯
3. 總結：Doctype就是通知瀏覽器當前的文檔是屬於那種類型的，包含哪些DTD。

  <!--HTML5的寫法-->
  <DOCTYPE html>
  <!-- HTML 4.01  Strict
    1. 這個DTD 包含所有的HTML元素和屬性
    2. 但是不包含展示性的和棄用的元素（比如font）
  -->
  <DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd" >
  <!-- HTML 4.0.1 Transitional
    1. 這個DTD 包含所有的HTML元素和屬性
    2. 也包含展示性的和棄用性的元素（比如font）
  -->
  <DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" " http://www.w3.org/TR/html4/loose.dtd" >

[!NOTE]
在W3C標準出來之前，不同的瀏覽器對頁面渲染有不同的標準，產生了一定的差異。這種渲染方式叫做混雜模式。在W3C標準出來之後，瀏覽器對頁面的渲染有了統一的標準，這種渲染方式叫做標準模式。<!DOCTYPE>不存在或者形式不正確會導致HTML或XHTML文檔以混雜模式呈現，就是把如何渲染html頁面的權利交給了瀏覽器，有多少種瀏覽器就有多少種展示方式。因此要提高瀏覽器兼容性就必須重視<!DOCTYPE>

10.2 嚴格模式和混雜模式

[!NOTE]
嚴格模式和混雜模式都是瀏覽器的呈現模式，瀏覽器究竟使用混雜模式還是嚴格模式呈現頁面與網頁中的DTD（文件類型定義）有關，DTD裡面包含了文檔的規則。比如：loose.dtd

• 嚴格模式：又稱標準模式，是指瀏覽器按照W3C標準來解析代碼，呈現頁面
• 混雜模式：又稱為怪異模式或者兼容模式，是指瀏覽器按照自己的方式來解析代碼，使用一種比較寬鬆的向後兼容的方式來显示頁面。

10.3 瀏覽器的渲染過程？

10.3.1 開始進行DOM解析，渲染DOM Tree

10.3.2 開始進行CSS解析，渲染CSSOM Tree

10.3.3 DOM樹和CSS樹的結合，最後會轉換為Render Tree

10.3.4 Layout的過程，計算每一個DOM元素的位置、寬度、高度等信息，最終渲染並显示頁面到瀏覽器

10.4 何時會觸發Reflow？

[!NOTE]
定義：DOM結構中每個元素都有自己的盒子模型，這些都是需要根據各種樣式來計算並根據計算結果將元素放在它該出現的位置，這個過程就是reflow；

1. 當你增加、刪除、修改DOM節點的時候，會導致Reflow或Repaint
2. 當你移動DOM的位置，或者設置動畫的時候
3. 當你修改CSS樣式的時候
4. 當你Resize窗口的時候（移動端沒有這個問題，與瀏覽器有關），或者在滾動窗口的時候
5. 當你修改網頁的默認的字體的時候

10.5 何時回觸發Repaint？

[!NOTE]
定義：當各種盒子的位置、大小以及其他屬性，例如顏色、字體大小都確定下來以後，瀏覽器於是便按照元素各自的特性繪製了一遍，於是頁面的內容出現了，這個過程就是repaint

1. DOM改動
2. CSS改動

10.6 如何最大程度上的減少瀏覽器的重繪Repaint過程(頻率)呢？

10.6.1 避免在document上直接進行頻繁的DOM操作，如果確實需要可以採用off-document的方式進行

• 1. 先將元素從document中刪除，完成修改之後然後再把元素放回原來的位置
• 1. 將元素的display設置為none, 然後完成修改之後再把元素的display屬性修改為原來的值
• 1. 如果需要創建多個DOM節點，可以使用DocumentFragment創建完畢之後一次性地加入document中去

  var frag = document.createDocumentFragment();
  frag.appendChild(dom);    /*每次創建的節點先放入DocumentFragment中*/

10.6.2 集中修改樣式

1. 盡可能少的修改元素style上的屬性
2. 盡量通過修改className來修改樣式(一次性修改)
3. 通過cssText屬性來設置樣式值

  document.getElementById("d1").style.cssText = "color:red; font-size:13px;";

10.6.3 緩存Layout的屬性值

[!NOTE]
對於Layout屬性中非引用類型的值（数字型），如果需要多次訪問則可以在一次訪問時先存儲到局部變量中，之後都使用局部變量，這樣可以避免每次讀取屬性時造成瀏覽器的渲染。

  var width = el.offsetWidth;
  var scrollLeft = el.scrollLeft;

10.6.4 設置元素的position為absolute或fixed

[!NOTE]
在元素的position為static和relative時，元素處於DOM樹結構當中，當對元素的某個操作需要重新渲染時，瀏覽器會渲染整個頁面。將元素的position設置為absolute和fixed可以使元素從DOM樹結構中脫離出來獨立的存在，而瀏覽器在需要渲染時只需要渲染該元素以及位於該元素下方的元素，從而在某種程度上縮短瀏覽器渲染時間。

11. 布局Layout？

Layout屬性包括：

1. offsetLeft、offsetTop、offsetHeight、offsetWidth: 相對於父對象的邊距信息，且返回值為数字；left獲取或設置相對於具有定位屬性(position定義為relative)的父對象的邊距信息，返回值為字符串10px
2. scrollTop/Left/Width/Height：滾動條在各個方向上拉動的距離，返回值為数字
3. clientTop/Left/Width/Height：瀏覽器的可視區域的大小
4. getComputedStyle()、currentStyle(in IE)：瀏覽器渲染DOM元素之後的寬度和高度等樣式信息

12. JS運行機制

12.1 如何理解JS的單線程？

看代碼，寫結果？

  // 同步任務
  console.log(1);
  // 異步任務要掛起
  setTimeout(function(){
    console.log(2)
  }, 0);
  console.log(3)
  // out : 1 3 2

  console.log('A');
  setTimeout(function(){
    console.log('B')
  }, 0);
  while (true) {

  }

  // out : A

12.2 什麼是任務隊列？

  for (var i = 0; i < 4; i++) {
    // setTimeout , setInterval 只有在時間到了的時候，才會把這個事件放在異步隊列中去
    setTimeout(function(){
      console.log(i);
    }, 1000);
  }
  // out : 4 4 4 4

12.3 什麼是Event Loop？

[!NOTE]
JS是單線程的，瀏覽器引擎會先來執行同步任務，遇到異步任務之後，會把當前的這個異步任務放在time模塊中，等到主線程中的所有的同步任務全部執行完畢之後；然後當前的這個異步任務只有時間到了之後，才會把這個任務（回調函數）放在一個異步隊列中；噹噹前的任務棧中的任務全部執行完畢了之後，會先去執行微任務隊列中的任務（Promise），然後等到微任務隊列中的所有任務全部執行完畢之後，再去執行process.nextTick()這個函數，等到這個函數執行完畢之後，本次的事件輪訓結束；
開啟新的執行棧，從宏任務隊列中依次取出異步任務，開始執行；每個宏任務執行都會重新開啟一個新的任務執行棧

12.3.1 3個關鍵點

1. 執行棧執行的是同步任務；
2. 什麼時候去異步隊列中取這個任務；

3. 什麼時候向這個任務隊列中放入新的異步任務

   12.3.2 異步任務的分類

• setTimeout, setInterval;
• DOM事件（點擊按鈕的時候也會先去執行同步任務）；
• Promise

13. 知識點總結

1. 理解JS的單線程的概念
2. 理解任務隊列
3. 理解Event Loop
4. 理解哪些語句會翻入到異步任務隊列

5. 理解與放入到異步任務隊列的時機

   13.1 頁面性能

   13.1.1 提升頁面性能的方法有哪些？

6. 資源壓縮合併，減少HTTP請求；
7. 非核心代碼的異步加載 —> 異步加載的方式有哪些？ —> 異步加載的區別？
8. 利用瀏覽器的緩存 —> 緩存的分類 —> 緩存的原理
9. 使用CDN加速

10. 預解析DNS：DNS Prefetch 是一種DNS 預解析技術，當你瀏覽網頁時，瀏覽器會在加載網頁時對網頁中的域名進行解析緩存，這樣在你單擊當前網頁中的連接時就無需進行DNS的解析，減少用戶等待時間，提高用戶體驗。（提前解析域名，而不是點擊鏈接的時候才去進行DNS域名解析，可以節省DNS解析需要耗費的20-120毫秒時間）

  <!-- https協議的網站，默認是關閉了DNS的預解析的，可以使用下面的語句開啟  -->
  <meta http-equiv="x-dns-prefetch-control" content="on">
  <!-- 開始配置需要進行DNS預解析的域名 -->
  <link rel="dns-prefetch" href="//www.zhix.net">                               <!--支持http和HTTPS-->
  <link rel="dns-prefetch" href="http://bdimg.share.baidu.com" />               <!--支持http的協議-->
  <link rel="dns-prefetch" href="http://nsclick.baidu.com" />
  <link rel="dns-prefetch" href="http://hm.baidu.com" />
  <link rel="dns-prefetch" href="http://eiv.baidu.com" />

14. 異步加載的方式

14.1 動態腳本的加載

  var script = document.createElement('script');
  document.getElementsByTagName('head')[0].appendChild(script);

  // 沒有 defer 或 async，瀏覽器會立即加載並執行指定的腳本，“立即”指的是在渲染該 script 標籤之下的文檔元素之前，也就是說不等待後續載入的文檔元素，讀到就加載並執行。
  <script src="script.js"></script>

14.2 defer

<!-- 有 defer，加載後續文檔元素的過程將和 script.js 的加載并行進行（異步），但是 script.js 的執行要在所有元素解析完成之後，DOMContentLoaded 事件觸發之前完成。 -->
<script defer src="myscript.js"></script>

14.3 async

  <!-- 有 async，加載和渲染後續文檔元素的過程將和 script.js 的加載與執行并行進行（異步）。 -->
  <script async src="script.js"></script>

14.4 異步加載的區別？

[!NOTE]

1. defer是在HTML解析完成之後（DOMContentLoaded事件執行之後）才會執行，如果是多個，會按照加載的順序依次執行（按照順序執行）
2. async是在加載完之後立即執行，如果是多個，執行順序和加載順序無關（與順序無關）

15. 說一下瀏覽器的緩存機制吧？

15.1 緩存的分類

[!NOTE]
緩存目的就是為了提升頁面的性能

15.1.1 強緩存

直接從本地讀取，不發送請求

    Response Headers
    cache-control: max-age=315360000（相對時間，優先級比expires高）
    expires: Sat, 10 Mar 2029 04:01:39 GMT(絕對時間)

15.1.2 協商緩存

問一下服務器，這個文件有沒有過期，然後再使用這個文件

    Response Headers
    last-modified: Tue, 12 Mar 2019 06:22:34 GMT（絕對時間）
    etag: "52-583dfb6f4de80"

向服務器請求資源的時候，帶上if-Modified-Since或者if-None-Match這個請求頭，去詢問服務器：

    Request Headers
    if-Modified-Since: Tue, 12 Mar 2019 06:22:34 GMT
    if-None-Match: "52-583dfb6f4de80"

16. 錯誤監控/如何保證前端產品的上線質量？

16.1 前端錯誤的分類？

1. 即時運行錯誤：代碼錯誤
2. 資源加載錯誤：圖片/css/js文件加載失敗

16.2 錯誤的捕獲方式？

16.2.1 即時運行錯誤的捕獲方式

  // 方法一：使用try catch捕獲
  try {
    // ...
  } catch (e) {
    // error
  } finally {
    // handle error
  }

  // 方法二：使用window.onerror 捕獲錯誤
  // 無法捕獲到資源加載錯誤
  window.onerror = function(msg, url, line, col, error){
    // ...
  }  
  window.addEventListener('error', function(msg, url, line, col, error){
    // ...
  })

16.2.2 資源加載錯誤（不會向上冒泡）

  // 方法一: 直接在script, img這些DOM標籤上面直接加上onerror事件
  Object.onerror = function(e){
      // ...
  }

  // 方法二：window.performace.getEntries(間接獲取資源加載錯誤的數量)
  var loadedResources = window.performance.getEntries();           // 1. 獲取瀏覽器中已經加載的所有資源（包括各個階段的詳細加載時間）
  var loaderImgs = loadedResources.filter(item => {
      return /\.jpg|png|gif|svg/.test(item.name)
  });
  var imgs = document.getElementsByTagName('img');                // 2. 獲取頁面中所有的img集合
  var len = imgs.length - loaderImgs.length;                      // 3. 加載失敗的圖片數量
  console.log('圖片加載失敗數量：', len, '條');


  // 方法三： 使用事件捕獲的方式來實現Error事件捕獲
  // 使用事件捕獲的方式來實現資源加載錯誤的事件的捕獲：window ---> document --> html --- > body ---> div ---...
  window.addEventListener('error', function (msg) {
      console.log(msg);
  }, true);

16.2.3 補充的方法

      // 使用事件捕獲的方式來實現
     window.addEventListener('error', function (msg) {
         console.log('資源加載異常成功捕獲：', msg);
     }, true);
     // 使用事件冒泡的方式是只能捕獲到運行的時候的一些異常
     window.addEventListener('error', function (e) {
         console.log('運行異常成功捕獲1：', e.message, e.filename, e.lineno, e.colno, e.error);
     }, false);

     // 這種方式是可以按照參數的方式來接受相關的參數信息
     window.onerror = function (msg, url, line, col, error) {
         console.log('運行異常成功捕獲2：', msg, url, line, col, error);
     }

16.2.4 問題的延伸：跨域的js運行錯誤可以捕獲嗎，錯誤提示是什麼？應該怎麼處理呢？

16.2.4.1 錯誤信息

errorinfo :
Script0 error
0 row
0 col

16.2.4.2 處理方法

1. 第一步：在script標籤上增加crossorigin屬性

  <!-- script 表情添加crossorigin屬性 -->
  <!-- 除了 script，所有能引入跨域資源的標籤包括 link 和 img 之類，都有一樣的屬性 -->
  <script crossorigin  src="http://www.lmj.com/demo/crossoriginAttribute/error.js"></script>

1. 第二步：設置js資源響應頭’Access-Control-Allow-Origin: * ‘,服務器端需要開啟

  // 服務器可以直接設置一個響應頭信息
  res.setResponseHeader('Access-Control-Allow-Origin', 'www.lmj.com');

16.3 上報錯誤的基本原理？

1. 採用Ajax通信的方式來上報
2. 利用Image對象進行上報（cnzz）[重點理解掌握]

  // 下面的兩種方式都是可以實現錯誤信息的上報功能的
  (new Image).src = 'http://www.baidu.com?name=zhangsna&age=18&sex=male'
  (new Image()).src = 'https://www.baidu.com?name=zhangsan'

17. 如何使用JS獲取客戶端的硬件信息呢？

  // IE 瀏覽器提供的獲取電腦硬件的API
  var locator = new ActiveXObject ("WbemScripting.SWbemLocator");
  var service = locator.ConnectServer(".");
  var properties = service.ExecQuery("SELECT * FROM Win32_Processor");

18. 使用window.performace 來實現用戶體驗的數據記錄呢？

[!NOTE]
可以參考性能優化章節-performance性能監控一文內容。

三四面（業務項目面）

[!NOTE]

• 知識面要廣
• 理解要深刻
• 內心要誠實：沒了解過，問面試官有哪些資料可以學習
• 態度要謙虛
• 回答要靈活：把握一個度，不要和面試官爭執對錯
• • 要學會讚美：被問住了可以回答，適當讚美（沒面試官理解的那麼深，虛心請教）

19.介紹一下你做過的項目？

19.1 項目介紹模板（業務能力體現）

1. 我做過什麼業務？
2. 負責的業務有什麼業績？
3. 使用了什麼技術方案？
4. 突破了什麼技術難點？
5. 遇到了什麼問題？
6. 最大的收穫是什麼？

19.2 團隊協作能力

19.3 事務推動能力

19.4 帶人能力

終面（HR面）

20. 技術終面或HR面試要點

[!NOTE]
主要考察點：樂觀积極、主動溝通、邏輯順暢、上進有責任心、有主張，做事果斷、職業競爭力、職業規劃

20.1 職業競爭力

1. 業務能力：可以做到行業第一

2. 思考能力：對同一件事可以從不同角度去思考，找到最優解

3. 學習能力：不斷學習新的業務，沉澱、總結

4. 無上限的付出：對於無法解決的問題可以熬夜、加班

20.2 職業規劃

1. 目標是什麼：在業務上成為專家，在技術上成為行業大牛

2. 近階段的目標：不斷的學習積累各方面地經驗，以學習為主

3. 長期目標：做幾件有價值的事情，如開源作品、技術框架等

4. 方式方法：先完成業務上的主要問題，做到極致，然後逐步向目標靠攏

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整