一.嘮嘮WebAssembly的發展歷程

　　目前有很多支持WebAssembly的項目，但發展最快的是Blazor，這是一個構建單頁面的.NET技術，目前已經從Preview版本升級到了beta版本，微軟計劃在2020年5月發布Blazor的第一個版本。

　　Blazor是什麼？它是一項將C＃和.NET都放入瀏覽器的Microsoft技術。它使用WebAssembly來工作，WebAssembly是一種高性能的管道，可以將代碼預編譯為緊湊的二進制格式。最重要的是，每個主流瀏覽器（包括移動版本）都支持WebAssembly。

　　十年前，JavaScript統治世界還不是很明顯。Flash和Silverlight也正在運行。這二個都需要使用瀏覽器插件來完成工作，並且都以不同的用戶界面方法替換了HTML。這種方法使他們在功能方面遙遙領先於JavaScript，但隨着移動互聯網的出現，他們就慢慢過時。

　　但隨後從最初的Javascript再到微軟的JScript和CEnvi的ScriptEase三足鼎立，再到最後的統一標準，當時微軟憑藉Windows系統捆綁Internet Explorer的先天優勢擊潰Netscape后，兩大巨頭就此進入了長達數年的靜默期，JavaScript就是在這樣的情況下被構想出來的，當時的瀏覽器之王，Netscape Navigator創始人Marc Andreessen認為Netscape需要一種“glue language”來支持HTML，讓Web設計師和兼職程序員可以很容易地使用它來組裝諸如圖像和插件之類的組件，且代碼是可以直接寫在網頁標記中。除此之外微軟的步步緊逼也迫使Andreessen不得不聘請Brendan Eich，及早將Scheme編程語言嵌入到Netscape Navigator中。1995年，JavaScript以Mocha為名開發，並於9月在Netscape Navigator 2.0的測試版中首次發布，當時被稱為LiveScript，12月，在Netscape Navigator 2.0 beta 3中部署時被重命名為JavaScript 。雖然Netscape Navigator在Chrome、Internet Explorer和Firefox等多款瀏覽器的圍追堵截中最終落敗，但是JavaScript卻推動了網頁的發展，並一直被沿用至今。

　　這是一個諷刺。在JavaScript征服世界的同時，播下了一顆很小的種子，這可能會在將來的某個時候暗示JavaScript的終結。那顆種子是名為asm.js的實驗技術。

　　這是Mozilla的開發人員在2013年完成的一個古怪的實驗。他們正在尋找在瀏覽器中運行高性能代碼的方法。但是與插件不同，asm.js並未嘗試在瀏覽器旁邊運行。相反，它的目的是直接通過Javascript的虛擬化。

　　從本質上講，asm.js是簡潔，優化的JavaScript語法。它比普通的JavaScript運行得更快，因為它避免了該語言的慢動態部分。但是認識到它的網絡瀏覽器也可以應用其他優化，從而大大提高性能。換句話說，asm.js遵循黃金法則- 不要破壞網絡 -同時提供通往未來改進的途徑。Firefox團隊使用asm.js以及名為的轉碼工具來獲取用C ++構建的實時3D遊戲，並將其放入Web瀏覽器中，並且僅在JavaScript和原始野心上運行。

　　有人問為什麼asm.js好在哪裡，簡單而言，它的性能比JavaScript高几百倍，當然是在沒有谷歌的V8引擎之下，因為JavaScript是弱類型語言，它需要猜測你的數據類型來進行編譯，這樣的情況下，在我看來它肯定需要遍歷完一個方法，然後再進行運算，與其這樣我為什麼不打個標識呢？當然在不破壞JavaScript的情況下，arm.js選擇了一個騷氣的想法，如果你想你的數據類型是int，那麼聲明一個值就變成了變量名|0，就這樣它的目的就達到了。

　　儘管asm.js實驗產生了一些令人眼花撩亂的演示，但工作的開發人員基本上忽略了它。對他們來說，這隻是超越現代的一個有趣方面。但這隨着WebAssembly的創建而改變。

　　WebAssembly既是asm.js的後繼產品，又是一項截然不同的技術。這是一種緊湊的二進制代碼格式。像asm.js一樣，WebAssembly代碼也被輸入到JavaScript執行環境中。它具有相同的沙箱和相同的運行時環境。與asm.js一樣，WebAssembly的編譯方式也可以提高效率。但是現在，這些效率比有以前更加明顯，並且瀏覽器可以完全跳過JavaScript解析階段。對於普通的邏輯，WebAssembly遠比常規JavaScript快，幾乎與本機編譯的代碼一樣快。

 　　WebAssembly於2015年首次出現。如今，桌面和移動設備上的四大瀏覽器（Chrome，Edge，Safari和Firefox）已完全支持它。儘管可以通過將WebAssembly代碼轉換為asm.js來實現向後兼容，但Internet Explorer不支持它。就讓IE涼透吧！但需要注意的是WebAssembly無法迴避JavaScript，因為它已鎖定在JavaScript運行時環境中。實際上，WebAssembly需要與至少一些普通的JavaScript代碼一起運行，因為它不能直接訪問頁面。這意味着如果不通過JavaScript層，就無法操縱DOM或接收事件。

 　　聽我說起來，這是一個限制，但聰明的微軟開發者已經找到了走私的方法，在瀏覽器中下載一個微型.NET運行時，作為已編譯的WASM文件。此運行時處理JavaScript互操作，並提供基本服務，它能給我們提供GC或者其它用法。Blazor不是唯一一個由WebAssembly支持的實驗。考慮一下，它旨在將Python放入瀏覽器中，並帶有用於數據分析的高級數學工具包。據我所知這應該使用emscripten的編譯器。

 　　人們常說，何時Javascript能夠替代服務器端語言，又有人說什麼時候可以代替桌面級應用程序，所以WebAssembly並不是用來代替JavaScript的。而是為了解決現代問題，如果它做到了，那就真的做到了！所以作為一個程序員，你應該對WebAssembly引起足夠的重視，未來快速加載Web應用程序的需求肯定會增加。

 　　就現在我們的.NET Core提供了兩種Blazor模板，包括Blazor Server 以及 Blazor WebAssembly。

• Blazor Server使用熟悉的.NET環境在Web服務器上運行代碼。訣竅是瀏覽器和服務器之間的通信方式。當用戶與頁面進行交互時，JavaScript代碼將回調到發生實際頁面生命周期的服務器。（要建立此連接，該頁面使用名為的Microsoft API ）運行服務器端代碼后，Blazor Server呈現該頁面並將更改發送回Web頁面，該Web頁面將相應地進行更新。
• Blazor WebAssembly使用由WebAssembly提供支持的微型.NET運行時在瀏覽器中運行代碼。您的客戶端代碼可以訪問許多熟悉的.NET庫，並且您使用C＃語言編寫它，您仍然可以像在JavaScript頁面中一樣在Web服務器上調用API。
  

　　Blazor Server是一種具有一些有趣用例的技術，但是由於不斷的通信，您顯然會犧牲一些性能-甚至不用問脫機功能。Blazor WebAssembly是受到最多宣傳的一種，也是我們在本文中探討的一種。

　　關於Blazor，程序員最常見的誤解是將其C＃代碼編譯為WebAssembly，然後發送到瀏覽器，然後執行。這種方法並非不可能-Blazor的創建者暗示他們將來可能會嘗試這種技術。但是如今Blazor的工作方式並不是如此。

　　換句話說，如今的Blazor是當您訪問使用Blazor的網頁時，該頁面將從下載按比例縮小的.NET運行時開始。然後它將下載您的應用程序以及您的應用程序使用的任何其他.NET庫，所有這些都在其本機IL中。最後，Blazor運行時執行IL。

二.配置您的開發環境

 　　由於Blazor是一個預發布的早期Beta產品。基礎結構的關鍵部分正在發生變化，您將無法獲得與其他類型的Microsoft項目相同級別的工具支持。我嘗試在Visual Studio 2019中進行編碼，需要注意的是您需要勾選.NET FrameWork 4.8 以及 .NET Core 3.0 + ，這樣您才具有Web Assembly的項目。完成設置后，您可以輕鬆創建Blazor項目。只需啟動Visual Studio，創建一個新項目，然後選擇“ Blazor App”項目即可。Visual Studio會詢問您是否需要Blazor Server應用程序或Blazor WebAssembly應用程序.

 三.Blazor的數據綁定與組件傳值

　　由於關於Blazor的一篇我編寫的文章，未能提及更深入的內容，那麼現在我將要介紹一下高級的Blazor用法，到最後還會有一個糖果，園友力作的Blazor UI！多麼激動人心的時刻，那麼趕快開始吧.

3.1 Child Component

　　在Blazor的Child Component中可以使用[Parameter] 關鍵字，來進行傳值的定義，我們可以這麼來做，現在只是提一下這個概念，下面會仔細說下組件之間如何進行跨組件綁定值。

<div>
    <p>標題：@title</p>
</div>
@code{
    [Parameter]
    public string title { get; set; }
}

隨後在調用時，Visual Studio IDE 就可以直接向您的視覺進行提示輸入相關屬性。

<Demorazor title="Hello 博客園的兄弟們！"></Demorazor>

運行效果如下：

3.2 single Bind and Two-way binding

single bind就不用說了，新建項目自帶的模板Counter示例那就是如此。

@page "/counter"

<h1>Counter</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
}

此處 @currentCount 值根據點擊按鈕的數量遞增Click me。<p>標記元素中的值會自動刷新，無需任何組件刷新。

two-way binding 我們可以自定義我們的事件 一共分為二中綁定方式 包括@bind 和 @Bind-Value，值得一提的是還可以通過使用event參數指定@bind-value屬性, 使用其他事件來綁定屬性或字段。例如第四個文本框就是綁定changeString採用oninput事件的屬性，以到達在文本框的值更改時激發，經過我的測試如果你的綁定事件是Javascript中不存在的，那麼也無妨，不會報出系統級別的異常，我想如果是從IL轉換到WebAssembly中，就會直接過濾掉，但是Visual Studio 2019 沒有給我們提示，也讓我們編譯通過，即使是當前的最高16.0.4 預覽版也是如此，這個是令我詫異的。

<p>
    <span>在這裏可以使用bind-value 或者 bind 當然這裏確保您不使用其它事件！</span>
    <input @bind-value="changeString" />
    <p>這是我輸入的內容: @changeString</p>
</p>
<p>
    <span>oninput</span>
    <input @bind-value="changeString" @bind-value:event="oninput" />
</p>

@code {
    string changeString = "";
}  

運行效果如下：

 3.3 Component bindings

 　　想要跨組件進行綁定屬性值，可以使用,@bind-{property}可在其中跨組件綁定屬性值，我們試着嘗試，首先我們創建一個子控件，這個blazor就叫Baby，有一個身份證Id的屬性和出生地址。

　　 EventCallback的用法非常廣泛，它可以跨組件共享方法和屬性，如不寫下面的兩個屬性，則就會報錯。

@page "/baby"
<h2>Child Compoent</h2>
<p>出生的Baby IdentityCard:@Baby_IdentityCrad_Id</p>
<h3>在{@Baby_new_Address} 生的</h3>
@code {
    [Parameter]
    public string Baby_IdentityCrad_Id{ get; set; }

    /// <summary>
    /// 這個屬性也是牛的雅皮~~~ hhh
    /// </summary>
    [Parameter]
    public string Baby_new_Address{ get; set; }
    
    [Parameter]
    public EventCallback<string> Baby_IdentityCrad_IdChanged { get; set; }

    [Parameter]
    public EventCallback<string> Baby_new_AddressChanged { get; set; }
}

 　　有什麼樣的兒子就會有什麼樣的爸爸？ 現在我們創建出父親，那就直接叫做一個Father.razor吧~

@page "/father"
<h3>Father</h3>

<Baby @bind-Baby_IdentityCrad_Id="@id_Card"
      @bind-Baby_new_Address="@address">
</Baby>
<button class="btn btn-primary" @onclick="@ChangeTheYear">new baby()</button>
@code {
    public string id_Card { get; set; }
    public string address { get; set; }
    private void ChangeTheYear()
    {
        id_Card = Guid.NewGuid().ToString();
        address = "老張";
    }
}

運行效果如下：

 如果要在子組件中定義事件，則可以MouseEventArgs來接受設備上的事件，然後再進行附加事件。

[Parameter]
public EventCallback<MouseEventArgs> OnClick { get; set; }

四.級聯傳值

 　　在某些情況下, 使用組件參數將數據從祖先組件流式傳輸到附屬組件是不方便的, 尤其是在有多個組件層時。 級聯值和參數通過提供一種方便的方法, 使上級組件為其所有子代組件提供值。 級聯值和參數還提供了一種方法來協調組件。我們試着去構建一個例子，首先創建一個最頂層的組件。

@page "/myDome"
<p><span>姓名：</span><input @bind="@pName" /></p>
<p><span>年齡：</span><input @bind-value="@pAge" @bind-value:event="oninput"/></p>
<CascadingValue Value="@pName" Name="ProfileName">
    <CascadingValue Value="@pAge" Name="ProfileAge">
        <ParentComponent />
    </CascadingValue>
</CascadingValue>
@code {
    private string pName { get; set; } = "張三";
    private int pAge { get; set; } = 35;
}

ParentComponent.razor：

<div style="background-color:darkgray;width:200px;">
    <p>Parent Component</p>
    <div style="padding:10px;">
        <p> 年齡 :@Age</p>
        <ChildComponent />
    </div>
</div>
@code{
    [CascadingParameter(Name = "ProfileAge")]
    int Age { get; set; }
}

ChildComponent.razor：

<div style="background-color:beige;width:200px;">
    <p>Child Component</p>
    <p>名稱 : @Name.ToString()</p>
</div>

@code{
    [CascadingParameter(Name = "ProfileName")]
    string Name { get; set; }
}

 運行效果如下：

 可以發現，一級直接將二級和三級的組件進行了數據穿透，不過需要注意的是CascadingValue的Name一定要和CascadingParameter的Name相同，否則將會執行錯誤。

五.路由

 　　從古至今，任何大型的開發框架，都是具有路由的，否則可能將會無法工作，其實Blazor的啟動頁也就使用了路由，這是毋庸置疑的。當你的組件帶有 @page 指令時，將為生成的類指定  指定路由模板的。 在運行時，路由器將使用 RouteAttribute 查找組件類，並呈現哪個組件包含與請求的 URL 匹配的路由模板。

@page "/luyou"
@page "/luyou/{text}"

<h1>Blazor is @Text!</h1>

@code {
    [Parameter]
    public string Text { get; set; }

    protected override void OnInitialized()
    {
        Text = Text ?? "fantastic";
    }
}

運行效果如下：

在上面的示例中應用了兩個 @page 指令。 第一個允許導航到沒有參數的組件。 第二個 @page 指令採用 {text} 路由參數，並將該值分配給 Text 屬性。

關於Blazor的基礎入門咱們這篇就說到這裏，相信你一定覺得Blazor了不起！它是一個現代的開源框架。它也由一家擁有悠久歷史的公司擁有，該公司放棄了昨天的閃亮新技術。因此，大多數開發人員都應該謹慎對待Blazor。只要JavaScript能夠執行Blazor可以做的所有事情，而沒有下載大小，性能和新工具堆棧帶來的額外挑戰，大多數開發人員將一如既往。

這並不意味着Blazor不能在所有這些領域都佔有一席之地。它甚至可能成為.NET Web應用程序開發中的主導力量。但是如果我今天必須下注，這就是我要依靠的東西。WebAssembly是未來。但就目前而言，Blazor只是一種有趣的可能性。

六.彩蛋

就現在！我的好朋友宇辰正在開發一款名為Blazui的UI組件。它為什麼叫Blazui？

Blazor + Element UI = Blazui，Element UI 的blazor版本，無JS，無TS，用 .Net 寫前端的 UI 框架，非 Silverlight，非 WebForm，開箱即用！！

Blazui 演示地址：。QQ群：74522853，碼雲地址：

參考Blazor使用的前提條件：

1. 安裝 .Net Core 3.0
2. 安裝 VS2019
3. 安裝所有 VS2019 Blazor Extension

現在Blazor正在逐漸變好，讓我們即刻出發！.NET Core 不只是開源！

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

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

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

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

前言

我在看SOFAJRaft的源碼的時候看到了使用了對象池的技術，看了一下感覺要吃透的話還是要新開一篇文章來講，內容也比較充實，大家也可以學到之後運用到實際的項目中去。

這裏我使用RecyclableByteBufferList來作為講解的例子：

RecyclableByteBufferList

public final class RecyclableByteBufferList extends ArrayList<ByteBuffer> implements Recyclable {

    private transient final Recyclers.Handle handle;

    private static final Recyclers<RecyclableByteBufferList> recyclers = new Recyclers<RecyclableByteBufferList>(512) {

        @Override
        protected RecyclableByteBufferList newObject(final Handle handle) {
            return new RecyclableByteBufferList(
                    handle);
        }
    };

      //獲取一個RecyclableByteBufferList實例
    public static RecyclableByteBufferList newInstance(final int minCapacity) {
        final RecyclableByteBufferList ret = recyclers.get();
        //容量不夠的話，進行擴容
        ret.ensureCapacity(minCapacity);
        return ret;
    }
      //回收RecyclableByteBufferList對象
    @Override
    public boolean recycle() {
        clear();
        this.capacity = 0;
        return recyclers.recycle(this, handle);
    }
}

我在上面將RecyclableByteBufferList獲取對象的方法和回收對象的方法給列舉出來了，獲取實例的時候會通過recyclers的get方法去獲取，回收對象的時候會去調用list的clear方法清空list裏面的內容之後再去調用recyclers的recycle方法進行回收。
如果recyclers裏面沒有對象可以獲取，那麼會調用newObject方法創建一個對象，然後將handle對象傳入構造器中進行實例化。

對象池Recyclers

數據結構

1. 每一個 Recyclers 對象包含一個 ThreadLocal<Stack<T>> threadLocal實例；
   每一個線程包含一個 Stack 對象，該 Stack 對象包含一個 DefaultHandle[]，而 DefaultHandle 中有一個屬性 T value，用於存儲真實對象。也就是說，每一個被回收的對象都會被包裝成一個 DefaultHandle 對象
2. 每一個 Recyclers 對象包含一個ThreadLocal<Map<Stack<?>, WeakOrderQueue>> delayedRecycled實例；
   每一個線程對象包含一個 Map<Stack<?>, WeakOrderQueue>，存儲着為其他線程創建的 WeakOrderQueue 對象，WeakOrderQueue 對象中存儲一個以 Head 為首的 Link 數組，每個 Link 對象中存儲一個 DefaultHandle[] 數組，用於存放回收對象。

假設線程A創建的對象

1. 線程A回收RecyclableByteBufferList時，直接將RecyclableByteBufferList的DefaultHandle 對象壓入 Stack 的 DefaultHandle[] 中；
2. 線程B回收RecyclableByteBufferList時，會首先從其 Map<Stack<?>, WeakOrderQueue> 對象中獲取 key=線程A的Stack 對象的 WeakOrderQueue，然後直接將RecyclableByteBufferList的DefaultHandle 對象（內部包含RecyclableByteBufferList對象）壓入該 WeakOrderQueue 中的 Link 鏈表中的尾部 Link 的 DefaultHandle[]中，同時，這個 WeakOrderQueue 會與線程 A 的 Stack 中的 head 屬性進行關聯，用於後續對象的 pop 操作；
3. 當線程 A 從對象池獲取對象時，如果線程 A 的 Stack 中有對象，則直接彈出；如果沒有對象，則先從其 head 屬性所指向的 WeakorderQueue 開始遍歷 queue 鏈表，將 RecyclableByteBufferList 對象從其他線程的 WeakOrderQueue 中轉移到線程 A 的 Stack 中（一次 pop 操作只轉移一個包含了元素的 Link），再彈出。

Recyclers靜態代碼塊

private static final int DEFAULT_INITIAL_MAX_CAPACITY_PER_THREAD = 4 * 1024; // Use 4k instances as default.
private static final int DEFAULT_MAX_CAPACITY_PER_THREAD;
private static final int INITIAL_CAPACITY;

static {
    // 每個線程的最大對象池容量
    int maxCapacityPerThread = SystemPropertyUtil.getInt("jraft.recyclers.maxCapacityPerThread", DEFAULT_INITIAL_MAX_CAPACITY_PER_THREAD);
    if (maxCapacityPerThread < 0) {
        maxCapacityPerThread = DEFAULT_INITIAL_MAX_CAPACITY_PER_THREAD;
    }

    DEFAULT_MAX_CAPACITY_PER_THREAD = maxCapacityPerThread;
    if (LOG.isDebugEnabled()) {
        if (DEFAULT_MAX_CAPACITY_PER_THREAD == 0) {
            LOG.debug("-Djraft.recyclers.maxCapacityPerThread: disabled");
        } else {
            LOG.debug("-Djraft.recyclers.maxCapacityPerThread: {}", DEFAULT_MAX_CAPACITY_PER_THREAD);
        }
    }
    // 設置初始化容量信息
    INITIAL_CAPACITY = Math.min(DEFAULT_MAX_CAPACITY_PER_THREAD, 256);
}

 public static final Handle NOOP_HANDLE = new Handle() {};

Recyclers會在靜態代碼塊中做一些對象池容量初始化的工作，初始化了最大對象池容量和初始化容量信息。

從對象池中獲取對象

Recyclers#get

// 線程變量，保存每個線程的對象池信息，通過 ThreadLocal 的使用，避免了不同線程之間的競爭情況
private final ThreadLocal<Stack<T>> threadLocal = new ThreadLocal<Stack<T>>() {

    @Override
    protected Stack<T> initialValue() {
        return new Stack<>(Recyclers.this, Thread.currentThread(), maxCapacityPerThread);
    }
};

public final T get() {
    if (maxCapacityPerThread == 0) {
        return newObject(NOOP_HANDLE);
    }
    //從threadLocal中獲取一個棧對象
    Stack<T> stack = threadLocal.get();
    //拿出棧頂元素
    DefaultHandle handle = stack.pop();
    //如果棧裏面沒有元素，那麼就實例化一個
    if (handle == null) {
        handle = stack.newHandle();
        handle.value = newObject(handle);
    }
    return (T) handle.value;
}

Get方法會從threadLocal中去獲取數據，如果獲取不到，那麼會初始化一個Stack，並傳入當前Recyclers實例，當前線程，與最大容量。然後從stack中pop拿出棧頂元素，如果獲取的元素為空，那麼直接調用newHandle新建一個DefaultHandle實例，並調用Recyclers實現類的newObject獲取實現類的實例。也就是說DefaultHandle是用來封裝真正的對象的實例。

從stack中申請一個對象

Stack(Recyclers<T> parent, Thread thread, int maxCapacity) {
    this.parent = parent;
    this.thread = thread;
    this.maxCapacity = maxCapacity;
    elements = new DefaultHandle[Math.min(INITIAL_CAPACITY, maxCapacity)];
}

DefaultHandle pop() {
    int size = this.size;
    if (size == 0) {
        if (!scavenge()) {
            return null;
        }
        size = this.size;
    }
    //size表示整個stack中的大小
    size--;
    //獲取最後一個元素
    DefaultHandle ret = elements[size];
    if (ret.lastRecycledId != ret.recycleId) {
        throw new IllegalStateException("recycled multiple times");
    }
    // 清空回收信息，以便判斷是否重複回收
    ret.recycleId = 0;
    ret.lastRecycledId = 0;
    this.size = size;
    return ret;
}

獲取對象的邏輯也比較簡單，當 Stack 中的 DefaultHandle[] 的 size 為 0 時，需要從其他線程的 WeakOrderQueue 中轉移數據到 Stack 中的 DefaultHandle[]，即 scavenge方法，該方法下面再聊。當 Stack 中的 DefaultHandle[] 中最終有了數據時，直接獲取最後一個元素

對象池回收對象

我們再來看看RecyclableByteBufferList是怎麼回收對象的。
RecyclableByteBufferList#recycle

public boolean recycle() {
    clear();
    this.capacity = 0;
    return recyclers.recycle(this, handle);
}

RecyclableByteBufferList回收對象的時候首先會調用clear方法清空屬性，然後調用recyclers的recycle方法進行對象回收。

Recyclers#recycle

public final boolean recycle(T o, Handle handle) {
    if (handle == NOOP_HANDLE) {
        return false;
    }

    DefaultHandle h = (DefaultHandle) handle;
    //stack在實例化的時候會在構造器中傳入一個Recyclers作為parent
    //所以這裡是校驗一下，如果不是當前線程的, 直接不回收了
    if (h.stack.parent != this) {
        return false;
    }
    if (o != h.value) {
        throw new IllegalArgumentException("o does not belong to handle");
    }
    h.recycle();
    return true;
}

這裡會接着調用DefaultHandle的recycle方法進行回收

DefaultHandle

static final class DefaultHandle implements Handle {
    //在WeakOrderQueue的add方法中會設置成ID
    //在push方法中設置成為OWN_THREAD_ID
    //在pop方法中設置為0
    private int lastRecycledId;
    //只有在push方法中才會設置OWN_THREAD_ID
    //在pop方法中設置為0
    private int recycleId;
    //當前的DefaultHandle對象所屬的Stack
    private Stack<?> stack;
    private Object value;

    DefaultHandle(Stack<?> stack) {
        this.stack = stack;
    }

    public void recycle() {
        Thread thread = Thread.currentThread();
        //如果當前線程正好等於stack所對應的線程，那麼直接push進去
        if (thread == stack.thread) {
            stack.push(this);
            return;
        }
        // we don't want to have a ref to the queue as the value in our weak map
        // so we null it out; to ensure there are no races with restoring it later
        // we impose a memory ordering here (no-op on x86)
        // 如果不是當前線程，則需要延遲回收，獲取當前線程存儲的延遲回收WeakHashMap
        Map<Stack<?>, WeakOrderQueue> delayedRecycled = Recyclers.delayedRecycled.get();
        // 當前 handler 所在的 stack 是否已經在延遲回收的任務隊列中
        // 並且 WeakOrderQueue是一個多線程間可以共享的Queue
        WeakOrderQueue queue = delayedRecycled.get(stack);
        if (queue == null) {
            delayedRecycled.put(stack, queue = new WeakOrderQueue(stack, thread));
        }
        queue.add(this);
    }
}

DefaultHandle在實例化的時候會傳入一個stack實例，代表當前實例是屬於這個stack的。
所以在調用recycle方法的時候，會判斷一下，當前的線程是不是stack所屬的線程，如果是那麼直接push到stack裏面就好了，不是則調用延遲隊列delayedRecycled；
從delayedRecycled隊列中獲取Map<Stack<?>, WeakOrderQueue> delayedRecycled ，根據stack作為key來獲取WeakOrderQueue，然後將當前的DefaultHandle實例放入到WeakOrderQueue中。

同線程回收對象

Stack#push

void push(DefaultHandle item) {
    // (item.recycleId | item.lastRecycleId) != 0 等價於 item.recycleId!=0 && item.lastRecycleId!=0
    // 當item開始創建時item.recycleId==0 && item.lastRecycleId==0
    // 當item被recycle時，item.recycleId==x，item.lastRecycleId==y 進行賦值
    // 當item被pop之後， item.recycleId = item.lastRecycleId = 0
    // 所以當item.recycleId 和 item.lastRecycleId 任何一個不為0，則表示回收過
    if ((item.recycleId | item.lastRecycledId) != 0) {
        throw new IllegalStateException("recycled already");
    }
    // 設置對象的回收id為線程id信息，標記自己的被回收的線程信息
    item.recycleId = item.lastRecycledId = OWN_THREAD_ID;

    int size = this.size;
    if (size >= maxCapacity) {
        // Hit the maximum capacity - drop the possibly youngest object.
        return;
    }
    // stack中的elements擴容兩倍，複製元素，將新數組賦值給stack.elements
    if (size == elements.length) {
        elements = Arrays.copyOf(elements, Math.min(size << 1, maxCapacity));
    }

    elements[size] = item;
    this.size = size + 1;
}

同線程回收對象 DefaultHandle#recycle 步驟：

1. stack 先檢測當前的線程是否是創建 stack 的線程，如果不是，則走異線程回收邏輯；如果是，則首先判斷是否重複回收，然後判斷 stack 的 DefaultHandle[] 中的元素個數是否已經超過最大容量（4k），如果是，直接返回；
2. 判斷當前的 DefaultHandle[] 是否還有空位，如果沒有，以 maxCapacity 為最大邊界擴容 2 倍，之後拷貝舊數組的元素到新數組，然後將當前的 DefaultHandle 對象放置到 DefaultHandle[] 中
3. 最後重置 stack.size 屬性

異線程回收對象

WeakOrderQueue

static final class Stack<T> {
    //使用volatile可以立即讀取到該queue
      private volatile WeakOrderQueue head;
}
WeakOrderQueue(Stack<?> stack, Thread thread) {
    head = tail = new Link();
    //使用的是WeakReference ，作用是在poll的時候，如果owner不存在了
    // 則需要將該線程所包含的WeakOrderQueue的元素釋放，然後從鏈表中刪除該Queue。
    owner = new WeakReference<>(thread);
    //假設線程B和線程C同時回收線程A的對象時，有可能會同時創建一個WeakOrderQueue，就坑同時設置head，所以這裏需要加鎖
    synchronized (stackLock(stack)) {
        next = stack.head;
        stack.head = this;
    }
}

創建WeakOrderQueue對象的時候會初始化一個WeakReference的owner，作用是在poll的時候，如果owner不存在了， 則需要將該線程所包含的WeakOrderQueue的元素釋放，然後從鏈表中刪除該Queue。

然後給stack加鎖，假設線程B和線程C同時回收線程A的對象時，有可能會同時創建一個WeakOrderQueue，就坑同時設置head，所以這裏需要加鎖。

以head==null的時候為例
加鎖：
線程B先執行，則head = 線程B的queue；之後線程C執行，此時將當前的head也就是線程B的queue作為線程C的queue的next，組成鏈表，之後設置head為線程C的queue
不加鎖：
線程B先執行 next = stack.head此時線程B的queue.next=null->線程C執行next = stack.head;線程C的queue.next=null-> 線程B執行stack.head = this;設置head為線程B的queue -> 線程C執行stack.head = this;設置head為線程C的queue，此時線程B和線程C的queue沒有連起來。

WeakOrderQueue#add

void add(DefaultHandle handle) {
    // 設置handler的最近一次回收的id信息，標記此時暫存的handler是被誰回收的
    handle.lastRecycledId = id;

    Link tail = this.tail;
    int writeIndex;
    // 判斷一個Link對象是否已經滿了：
    // 如果沒滿，直接添加；
    // 如果已經滿了，創建一個新的Link對象，之後重組Link鏈表，然後添加元素的末尾的Link（除了這個Link，前邊的Link全部已經滿了）
    if ((writeIndex = tail.get()) == LINK_CAPACITY) {
        this.tail = tail = tail.next = new Link();
        writeIndex = tail.get();
    }
    tail.elements[writeIndex] = handle;
    // 如果使用者在將DefaultHandle對象壓入隊列后，將Stack設置為null
    // 但是此處的DefaultHandle是持有stack的強引用的，則Stack對象無法回收；
    //而且由於此處DefaultHandle是持有stack的強引用，WeakHashMap中對應stack的WeakOrderQueue也無法被回收掉了，導致內存泄漏
    handle.stack = null;
    // we lazy set to ensure that setting stack to null appears before we unnull it in the owning thread;
    // this also means we guarantee visibility of an element in the queue if we see the index updated
    // tail本身繼承於AtomicInteger，所以此處直接對tail進行+1操作
    tail.lazySet(writeIndex + 1);
}

Stack異線程push對象流程：

1. 首先獲取當前線程的 Map<Stack<?>, WeakOrderQueue> 對象，如果沒有就創建一個空 map；
2. 然後從 map 對象中獲取 key 為當前的 Stack 對象的 WeakOrderQueue；
3. 如果獲取的WeakOrderQueue對象為null，那麼創建一個WeakOrderQueue對象，並將對象放入到map中，最後調用WeakOrderQueue#add添加對象

WeakOrderQueue 的創建流程：

1. 創建一個Link對象，將head和tail的引用都設置為此對象
2. 創建一個WeakReference指向owner對象，設置當前的 WeakOrderQueue 所屬的線程為當前線程。
3. 先將原本的 stack.head 賦值給剛剛創建的 WeakOrderQueue 的 next 節點，之後將剛剛創建的 WeakOrderQueue 設置為 stack.head（這一步非常重要：假設線程 A 創建對象，此處是線程 C 回收對象，則線程 C 先獲取其 Map<Stack<?>, WeakOrderQueue> 對象中 key=線程A的stack對象的 WeakOrderQueue，然後將該 Queue 賦值給線程 A 的 stack.head，後續的 pop 操作打基礎），形成 WeakOrderQueue 的鏈表結構。

WeakOrderQueue#add添加對象流程

1. 首先設置 item.lastRecycledId = 當前 WeakOrderQueue 的 id
2. 然後看當前的 WeakOrderQueue 中的 Link 節點鏈表中的尾部 Link 節點的 DefaultHandle[] 中的元素個數是否已經達到 LINK_CAPACITY（16）
3. 如果不是，則直接將當前的 DefaultHandle 元素插入尾部 Link 節點的 DefaultHandle[] 中，之後置空當前的 DefaultHandle 元素的 stack 屬性，最後記錄當前的 DefaultHandle[] 中的元素數量；
4. 如果是，則新建一個 Link，並且放在當前的 Link 鏈表中的尾部節點處，與之前的 tail 節點連起來（鏈表），之後進行第三步的操作。

從異線程獲取對象

我再把pop方法搬下來一次：

DefaultHandle pop() {
    int size = this.size;
    // size=0 則說明本線程的Stack沒有可用的對象，先從其它線程中獲取。
    if (size == 0) {
        // 當 Stack<T> 此時的容量為 0 時，去 WeakOrder 中轉移部分對象到 Stack 中
        if (!scavenge()) {
            return null;
        }
        //由於在transfer(Stack<?> dst)的過程中，可能會將其他線程的WeakOrderQueue中的DefaultHandle對象傳遞到當前的Stack,
        //所以size發生了變化，需要重新賦值
        size = this.size;
    }
    //size表示整個stack中的大小
    size--;
    //獲取最後一個元素
    DefaultHandle ret = elements[size];
    if (ret.lastRecycledId != ret.recycleId) {
        throw new IllegalStateException("recycled multiple times");
    }
    // 清空回收信息，以便判斷是否重複回收
    ret.recycleId = 0;
    ret.lastRecycledId = 0;
    this.size = size;
    return ret;
}

1. 首先獲取當前的 Stack 中的 DefaultHandle 對象中的元素個數。
2. 如果為 0，則從其他線程的與當前的 Stack 對象關聯的 WeakOrderQueue 中獲取元素，並轉移到 Stack 的 DefaultHandle[] 中（每一次 pop 只轉移一個有元素的 Link），如果轉移不成功，說明沒有元素可用，直接返回 null；
3. 如果轉移成功，則重置 size屬性 = 轉移后的 Stack 的 DefaultHandle[] 的 size，之後直接獲取 Stack 對象中 DefaultHandle[] 的最後一位元素，之後做防護性檢測，最後重置當前的 stack 對象的 size 屬性以及獲取到的 DefaultHandle 對象的 recycledId 和 lastRecycledId 回收標記，返回 DefaultHandle 對象。

scavenge轉移

Stack#scavenge

boolean scavenge() {
    // continue an existing scavenge, if any
    // 掃描判斷是否存在可轉移的 Handler
    if (scavengeSome()) {
        return true;
    }
    
    // reset our scavenge cursor
    prev = null;
    cursor = head;
    return false;
}

調用scavengeSome掃描判斷是否存在可轉移的 Handler，如果沒有，那麼就返回false，表示沒有可用對象

Stack#scavengeSome

boolean scavengeSome() {
    WeakOrderQueue cursor = this.cursor;
    if (cursor == null) {
        cursor = head;
        // 如果head==null，表示當前的Stack對象沒有WeakOrderQueue，直接返回
        if (cursor == null) {
            return false;
        }
    }

    boolean success = false;
    WeakOrderQueue prev = this.prev;
    do {
        // 從當前的WeakOrderQueue節點進行 handler 的轉移
        if (cursor.transfer(this)) {
            success = true;
            break;
        }
        // 遍歷下一個WeakOrderQueue
        WeakOrderQueue next = cursor.next;
        // 如果 WeakOrderQueue 的實際持有線程因GC回收了
        if (cursor.owner.get() == null) {
            // If the thread associated with the queue is gone, unlink it, after
            // performing a volatile read to confirm there is no data left to collect.
            // We never unlink the first queue, as we don't want to synchronize on updating the head.
            // 如果當前的WeakOrderQueue的線程已經不可達了
            //如果該WeakOrderQueue中有數據，則將其中的數據全部轉移到當前Stack中
            if (cursor.hasFinalData()) {
                for (;;) {
                    if (cursor.transfer(this)) {
                        success = true;
                    } else {
                        break;
                    }
                }
            }
            //將當前的WeakOrderQueue的前一個節點prev指向當前的WeakOrderQueue的下一個節點，
            // 即將當前的WeakOrderQueue從Queue鏈表中移除。方便後續GC
            if (prev != null) {
                prev.next = next;
            }
        } else {
            prev = cursor;
        }

        cursor = next;

    } while (cursor != null && !success);

    this.prev = prev;
    this.cursor = cursor;
    return success;
}

1. 首先設置當前操作的 WeakOrderQueue cursor，如果為 null，則賦值為 stack.head 節點，如果 stack.head 為 null，則表明外部線程沒有回收過當前線程創建的 對象，外部線程在回收對象的時候會創建一個WeakOrderQueue，並將stack.head 指向新創建的WeakOrderQueue對象，則直接返回 false；如果不為 null，則繼續向下執行；
2. 首先對當前的 cursor 進行元素的轉移，如果轉移成功，則跳出循環，設置 prev 和 cursor 屬性；
3. 如果轉移不成功，獲取下一個線程 Y 中的與當前線程的 Stack 對象關聯的 WeakOrderQueue，如果該 queue 所屬的線程 Y 還可達，則直接設置 cursor 為該 queue，進行下一輪循環；如果該 queue 所屬的線程 Y 不可達了，則判斷其內是否還有元素，如果有，全部轉移到當前線程的 Stack 中，之後將線程 Y 的 queue 從查詢 queue 鏈表中移除。

transfer轉移

    boolean transfer(Stack<?> dst) {
        //尋找第一個Link
        Link head = this.head;
        // head == null，沒有存儲數據的節點，直接返回
        if (head == null) {
            return false;
        }
        // 讀指針的位置已經到達了每個 Node 的存儲容量，如果還有下一個節點，進行節點轉移
        if (head.readIndex == LINK_CAPACITY) {
            //判斷當前的Link節點的下一個節點是否為null，如果為null，說明已經達到了Link鏈表尾部，直接返回，
            if (head.next == null) {
                return false;
            }
            // 否則，將當前的Link節點的下一個Link節點賦值給head和this.head.link，進而對下一個Link節點進行操作
            this.head = head = head.next;
        }
        // 獲取Link節點的readIndex,即當前的Link節點的第一個有效元素的位置
        final int srcStart = head.readIndex;
        // 獲取Link節點的writeIndex，即當前的Link節點的最後一個有效元素的位置
        int srcEnd = head.get();
        // 本次可轉移的對象數量（寫指針減去讀指針）
        final int srcSize = srcEnd - srcStart;
        if (srcSize == 0) {
            return false;
        }
        // 獲取轉移元素的目的地Stack中當前的元素個數
        final int dstSize = dst.size;
        // 計算期盼的容量
        final int expectedCapacity = dstSize + srcSize;
        // 期望的容量大小與實際 Stack 所能承載的容量大小進行比對，取最小值
        if (expectedCapacity > dst.elements.length) {
            final int actualCapacity = dst.increaseCapacity(expectedCapacity);
            srcEnd = Math.min(srcStart + actualCapacity - dstSize, srcEnd);
        }

        if (srcStart != srcEnd) {
            // 獲取Link節點的DefaultHandle[]
            final DefaultHandle[] srcElems = head.elements;
            // 獲取目的地Stack的DefaultHandle[]
            final DefaultHandle[] dstElems = dst.elements;
            // dst數組的大小，會隨着元素的遷入而增加，如果最後發現沒有增加，那麼表示沒有遷移成功任何一個元素
            int newDstSize = dstSize;
            //// 進行對象轉移
            for (int i = srcStart; i < srcEnd; i++) {
                DefaultHandle element = srcElems[i];
                // 表明自己還沒有被任何一個 Stack 所回收
                if (element.recycleId == 0) {
                    element.recycleId = element.lastRecycledId;
                //  避免對象重複回收
                } else if (element.recycleId != element.lastRecycledId) {
                    throw new IllegalStateException("recycled already");
                }
                // 將可轉移成功的DefaultHandle元素的stack屬性設置為目的地Stack
                element.stack = dst;
                // 將DefaultHandle元素轉移到目的地Stack的DefaultHandle[newDstSize ++]中
                dstElems[newDstSize++] = element;
                // 設置為null，清楚暫存的handler信息，同時幫助 GC
                srcElems[i] = null;
            }
            // 將新的newDstSize賦值給目的地Stack的size
            dst.size = newDstSize;

            if (srcEnd == LINK_CAPACITY && head.next != null) {
                // 將Head指向下一個Link，也就是將當前的Link給回收掉了
                // 假設之前為Head -> Link1 -> Link2，回收之後為Head -> Link2
                this.head = head.next;
            }
            // 設置讀指針位置
            head.readIndex = srcEnd;
            return true;
        } else {
            // The destination stack is full already.
            return false;
        }
    }
}

1. 尋找 cursor 節點中的第一個 Link如果為 null，則表示沒有數據，直接返回；
2. 如果第一個 Link 節點的 readIndex 索引已經到達該 Link 對象的 DefaultHandle[] 的尾部，則判斷當前的 Link 節點的下一個節點是否為 null，如果為 null，說明已經達到了 Link 鏈表尾部，直接返回，否則，將當前的 Link 節點的下一個 Link 節點賦值給 head ，進而對下一個 Link 節點進行操作；
3. 獲取 Link 節點的 readIndex，即當前的 Link 節點的第一個有效元素的位置
4. 獲取 Link 節點的 writeIndex，即當前的 Link 節點的最後一個有效元素的位置
5. 計算 Link 節點中可以被轉移的元素個數，如果為 0，表示沒有可轉移的元素，直接返回
6. 獲取轉移元素的目標 Stack 中當前的元素個數（dstSize）並計算期盼的容量 expectedCapacity，如果 expectedCapacity 大於目標Stack 的長度（dst.elements.length），則先對目的地 Stack 進行擴容，計算 Link 中最終的可轉移的最後一個元素的下標；
7. 如果發現目的地 Stack 已經滿了（ srcStart ！= srcEnd為false），則直接返回 false
8. 獲取 Link 節點的 DefaultHandle[] （srcElems）和目標 Stack 的 DefaultHandle[]（dstElems）
9. 根據可轉移的起始位置和結束位置對 Link 節點的 DefaultHandle[] 進行循環操作
10. 將可轉移成功的 DefaultHandle 元素的stack屬性設置為目標 Stack（element.stack = dst），將 DefaultHandle 元素轉移到目的地 Stack 的 DefaultHandle[newDstSize++] 中，最後置空 Link 節點的 DefaultHandle[i]
11. 如果當前被遍歷的 Link 節點的 DefaultHandle[] 已經被掏空了（srcEnd == LINK_CAPACITY），並且該 Link 節點還有下一個 Link 節點
12. 重置當前 Link 的 readIndex

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

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

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

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

人生苦短，我用 Python

前文傳送門：

Linux 基礎

CentOS 官網： 。

CentOS 官方下載鏈接： 。

Linux 目前在企業中廣泛的應用於服務器系統，無論是寫好的代碼，還是使用的第三方的開源的產品，絕大多數都是部署在 Linux 上面運行的。

可能很多同學一提到 Linux 就慫了，黒糊糊的一篇，連個界面都沒有，滿屏幕都是神秘代碼，沒有一個看得懂的。

表怕，本文就帶你入門 Linux 。

Linux 有不同的發行版本，而我們在企業中一般使用的是 CentOS ，目前比較常用的版本已經到了 7.x 。

由於 Linux 是開源的，所以不同廠商之間提供的發行版會有非常多，比較常見的有 Ubuntu（ 基於Debian的桌面版 ） 、Debian（ 國際化組織的開源操作系統 ） 、 RedHat（ 紅帽企業系統 ） 、 Fedora（ 最初由紅帽公司發起的桌面版系統套件 ） 等等。

因為在企業中使用比較多的還是 CentOS ，所以我們還是拿 CentOS 來介紹。

在 win 系統下的安裝可以使用第三方廠商提供的 VMware 或者 win 自帶的 Hyper-V 構建一個虛擬機進行安裝，也可以使用雲服務廠商提供的入門版的雲服務器（1H1G1M），一般新用戶首年價格都在100元以內。

安裝的過程我就不介紹了，百度一下大把。

安裝完成后，設置好 Linux root 用戶的密碼后，可以使用 ssh 工具進行連接，這裏的工具可以選擇 xshell （個人使用免費，就是官網屬實有點慢），打開 xshell 輸入 ip 、用戶名（root）、密碼后，應該可以看到如下界面：

小編這裏使用的是京東雲的服務器，打碼部分涉及 IP 信息，所以隱藏掉了，屬實怕大神搞我。

因為我們的目標不是 Linux 運維工程師，只需要能正常使用，一些簡單常用指令足夠我們日常操作 Linux 了。

首先介紹一下 Linux 的目錄，因為是使用 root 賬號登錄的，所以我們登錄后的目錄是在 /root ，查詢當前所在目錄可以使用命令 pwd ，如下：

輸入命令 cd / ，進入根目錄，再輸出命令 ls ，查看根目錄下都有什麼目錄：

大致介紹下每個目錄放的都是什麼東西：

很多都是系統使用的目錄，我們無需關注，一般會使用到的目錄有 /etc （修改一些系統配置，如改host文件，系統環境變量等）， /usr （這裡會安裝一些應用程序），/opt （這裏其實也是安裝一些應用程序）。

簡單介紹幾個命令，有了這幾個命令，基本上我們就可以愉快的操作起來了：

1. cd：這個不用多講了吧，就是切換目錄。
2. ls：這個是查看目錄內容。
3. pwd：显示當前工作目錄 。
4. mkdir：創建目錄。
5. vi：編輯文檔，這個命令稍微複雜一點
   1. vi 文件名 ：進入一般模式（不能輸入）
   2. 按下 i 從一般模式，進入到插入模式，這時可以修改文檔
   3. 按下esc從插入模式，退出到一般模式 ，這時無法修改文檔
   4. 在一般模式下，輸入:wq ，保存退出編輯；或者還可以輸入 !q 不保存編輯內容退出。
6. ps： 查看任務管理器： ps -ef ，例如查看 mysql 的進程，ps -ef | grep mysql 。
7. kill：這個就是殺進程，常用格式 kill -9 pid（進程編號），配合上面的 ps 命令一起使用，殺掉你想殺的進程。
8. tar：壓縮與解壓，常用解壓命令 tar -xvzf [需解壓的文件名] ，常用壓縮命令 tar -cvzf [壓縮后的文件名] [被壓縮的文件名] 。
9. reboot：重啟
10. halt：關機
11. rm：刪除命令，常用核彈級命令 rm -rf / ；此命令禁止在任何地方嘗試，一旦執行，將無法逆轉，含義是將跟目錄直接刪除。

下面我們來演示下如何在 CentOS 上安裝 Python3 。

因為 CentOS 本身自帶 Python ，但是版本是 Python2.7 ：

這裏我們不去管它，首先去 Python 官網找到 Python 的下載地址：

Python 官網下載鏈接：

小編這裏選擇的是截止目前最新發布的 3.8.0 版本。

這時我們切換到 xshell 的操作界面開始操作起來，首先切換至 /opt 目錄：

cd /opt

然後下載 Python3.8 的安裝包：

wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz

這裏遇到新的命令 wget ，這個命令如果 CentOS 未提供，需要先進行安裝：

yum install wget

簡單介紹一下， yum 是在 Linux 中的一個包管理工具，可以進行簡單的安裝操作。

等待進度條下載完，下載完成后直接解壓：

tar -xvzf Python-3.8.0.tgz

解壓后編譯安裝：

# 創建安裝目錄
mkdir /usr/local/python3
cd Python-3.8.0
# 檢查配置
./configure --prefix=/usr/local/python3
# 編譯、安裝
make && make install
# 創建軟連接
ln -s /usr/local/python3/bin/python3 /usr/bin/python3
ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3

測試安裝結果：

# 輸入
python3 -V
# 輸出
Python 3.8.0
# 輸入
pip3 -V
# 輸出
pip 19.2.3 from /usr/local/python3/lib/python3.8/site-packages/pip (python 3.8)

因為 Linux 部分功能也是依賴 Python 的，我們不覆蓋當前的 Python 命令的版本，直接創建一個新的 Python 命令 python3 。以及新的 pip 包管理命令 pip3 。

希望各位同學可以自己使用虛擬機安裝一個 CentOS 試試看，後續的部分內容將會涉及 Linux 。

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

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

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

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

引言

又是一年寒冬季，只身前往沿海工作，也是我第一次感受到沿海城市冬天的寒冷。剛過完金九銀十，經過一場慘烈的江湖廝殺后，相信有很多小夥伴兒已經找到了自己心儀的工作，也有的正在找工作的途中。考慮到年後必定又是一場不可避免的廝殺，這裏提前記錄一下自己平時遇到和總結的一些知識點，自己鞏固複習加強基礎的同時也希望能在你的江湖路上對你有所幫助。筆者在入職最近這家公司之前也曾有過長達3個月的閉關修鍊期，期間查閱資料無數，閱讀過很多文章，但總結下來真正讓你印象深刻的，不是那些前沿充滿神秘感的新技術，也不是為了提升代碼逼格的奇淫巧技，而是那些我們經常由於項目周期緊而容易忽略的基礎知識。所謂萬丈高樓平地起，只有你的地基打得足夠牢固，你才有搭建萬丈高樓的底氣，你才能在你的前端人生路上越走越遠。

這篇主要是先總結一下CSS相關的知識點，可能某些部分不會涉及到太多具體的細節，主要是對知識點做一下匯總，如果有興趣或者有疑惑的話可以自行百度查閱下相關資料或者在下方評論區留言討論，後續文章再繼續總結JS和其他方面相關的知識點，如有不對的地方還請指出。

1. CSS盒模型

CSS盒模型就是在網頁設計中經常用到的CSS技術所使用的一種思維模型。CSS 假定所有的HTML 文檔元素都生成了一個描述該元素在HTML文檔布局中所佔空間的矩形元素框，可以形象地將其看作是一個盒子。CSS 圍繞這些盒子產生了一種“盒子模型”概念，通過定義一系列與盒子相關的屬性，可以極大地豐富和促進各個盒子乃至整個HTML文檔的表現效果和布局結構。

CSS盒模型可以看成是由從內到外的四個部分構成，即內容區（content）、內邊距(padding)、邊框(border)和外邊距(margin)。內容區是盒子模型的中心，呈現盒子的主要信息內容；內邊距是內容區和邊框之間的空間；邊框是環繞內容區和內邊距的邊界；外邊距位於盒子的最外圍，是添加在邊框外周圍的空間。

根據計算寬高的區域我們可以將其分為IE盒模型和W3C標準盒模型，可以通過box-sizing來進行設置：

• content-box：W3C標準盒模型
• border-box：IE盒模型

區別：
W3C標準盒模型：width(寬度) = content(內容寬度)
IE盒模型：width(寬度) = content(內容寬度) + padding(內邊距) + border(邊框)

2. BFC

BFC即Block Fromatting Context(塊級格式化上下文)，它是頁面中的一塊獨立的渲染區域，並且有一套渲染規則，它決定了其子元素將如何定位，以及和其他元素的關係和相互作用。具有BFC特性的元素可以看成是一個隔離的獨立容器，讓處於BFC內部的元素與外部的元素相互隔離，使內外元素的定位不會相互影響。

IE瀏覽器下為hasLayout，一般可以通過zoom:(除normal外任意值)來觸發，hasLayout是IE瀏覽器渲染引擎的一個內部組成部分。在IE瀏覽器中，一個元素要麼自己對自身的內容進行計算大小和組織，要麼依賴於父元素來計算尺寸和和組織內容。為了調節這兩個不同的概念，渲染引擎採用了hasLayout的屬性，屬性值可以為true或false。當一個元素的hasLayout屬性為true時，我們就說這個元素有一個布局(Layout)。當擁有布局后，它會負責對自己和可能的子孫元素進行尺寸計算和定位，而不是依賴於祖先元素來完成這些工作。

2.1 觸發條件

• 根元素(<html>)
• 浮動元素(元素的float不是none)
• 絕對定位元素(元素的position為absolute或fixed)
• 行內塊元素(元素的display為inline-block)
• 表格單元格(元素的display為table-cell，HTML表格單元格默認為該值)
• 表格標題(元素的display為table-caption，HTML表格標題默認為該值)
• display值為flow-root的元素
• overflow屬性的值不為visible
• 彈性元素(display為flex或inline-flex元素的直接子元素)

• 網格元素(display為grid或者inline-grid元素的直接子元素)

  2.2 布局規則

  普通文檔流布局規則：

• 浮動的元素是不會被父級計算高度的
• 非浮動元素會覆蓋浮動元素的位置
• margin會傳遞給父級

• 兩個相鄰元素上下margin會發生重疊

BFC布局規則：

• 浮動的元素會被父級計算高度(父級觸發了BFC)
• 非浮動元素不會覆蓋浮動元素的位置(非浮動元素觸發了BFC)
• margin不會傳遞給父級(父級觸發了BFC)

• 兩個相鄰元素上下margin不會發生重疊(給其中一個元素增加一個父級，並讓它的父級觸發BFC)

  2.3 應用

• 防止margin重疊
• 清除內部浮動(原理是父級計算高度時，浮動的子元素也會參与計算)
• 自適應兩欄布局

• 防止元素被浮動元素所覆蓋

  3. 層疊上下文

  層疊上下文(stacking context)，是HTML中一個三維的概念。在CSS2.1規範中，每個盒模型的位置都是三維的，分別是平面畫布上的X軸，Y軸以及表示層疊的Z軸。一般情況下，元素在頁面上沿X軸Y軸平鋪，我們察覺不到它們在Z軸上的層疊關係。而一旦元素髮生堆疊，這時就能發現某個元素可能覆蓋了另一個元素或者被另一個元素覆蓋。

如果一個元素含有層疊上下文，我們就可以理解為這個元素在Z軸上就”高人一等”，最終表現就是它離屏幕觀察者更近。

你可以把層疊上下文理解為該元素當了官，而其他非層疊上下文元素則可以理解為普通群眾。凡是”當了官的元素”就比普通元素等級要高，也就是說元素在Z軸上更靠上，更靠近觀察者。

3.1 觸發條件

• 根層疊上下文(<html>)
• position屬性為非static值並設置z-index為具體數值
• CSS3中的屬性也可以產生層疊上下文
  • flex
  • transform
  • opacity
  • filter
  • will-change

  • -webkit-overflow-scrolling

    3.2 層疊等級

    層疊等級(stacking level)，又叫”層疊級別”或者”層疊水平”。

• 在同一個層疊上下文中，它描述定義的是該層疊上下文中的層疊上下文元素在Z軸上的上下順序

• 在其他普通元素中，它描述定義的是這些普通元素在Z軸上的上下順序

  注意：

  1. 普通元素的層疊等級優先由其所在的層疊上下文決定。
  2. 層疊等級的比較只有在當前層疊上下文元素中才有意義，不同層疊上下文中比較層疊等級是沒有意義的。

根據以上的層疊等級圖，我們在比較層疊等級時可以按照以下的思路來順序比較：

• 首先判定兩個要比較的元素是否處於同一個層疊上下文中
• 如果處於同一個層疊上下文中，則誰的層疊等級大，誰最靠上
• 如果處於不同的層疊上下文中，則先比較他們所處的層疊上下文的層疊等級
• 當兩個元素層疊等級相同，層疊順序相同時，在DOM結構中後面的元素層疊等級在前面元素之上

4. CSS3中新增的選擇器以及屬性

• 屬性選擇器：

• 結構偽類選擇器

• CSS3新增屬性

5. CSS3中transition和animation的屬性

1) transition(過渡動畫)

用法：transition: property duration timing-function delay
| 屬性 | 含義描述 |
| —- | —- |
| transition-property | 指定哪個CSS屬性需要應用到transition效果 |
| transition-duration | 指定transition效果的持續時間 |
| transition-timing-function | 指定transition效果的速度曲線 |
| transition-delay | 指定transition效果的延遲時間 |

2) animation(關鍵幀動畫)

用法：animation: name duration timing-function delay iteration-count direction fill-mode play-state
| 屬性 | 含義描述 |
| —- | —- |
| animation-name | 指定要綁定到選擇器的關鍵幀的名稱 |
| animation-duration | 指定動畫的持續時間 |
| animation-timing-function | 指定動畫的速度曲線 |
| animation-delay | 指定動畫的延遲時間 |
| animation-iteration-count | 指定動畫的播放次數 |
| animation-direction | 指定是否應該輪流反向播放動畫 |
| animation-fill-mode | 規定當動畫不播放時（當動畫完成時，或當動畫有一個延遲未開始播放時），要應用到元素的樣式 |
| animation-play-state | 指定動畫是否正在運行或已暫停 |

6. 清除浮動的方式以及各自的優缺點

• 額外標籤法(在最後一個浮動元素的後面新加一個標籤如<div class="clear"></div>，並在其CSS樣式中設置clear: both;)

  優點：簡單，通俗易懂，寫少量代碼，兼容性好
  缺點：額外增加無語義html元素，代碼語義化差，後期維護成本大

• 給父級設置高度

  優點：簡單，寫少量代碼，容易掌握
  缺點：不夠靈活，只適用於高度固定的布局

• 觸發父級BFC(如給父元素設置overflow:hidden，特別注意的是：在IE6中還需要觸發hasLayout，例如給父元素設置zoom:1。原理是觸發父級BFC后，父元素在計算高度時，浮動的子元素也會參与計算)

  優點：簡單，代碼簡潔
  缺點：設置overflow:hidden容易造成不會自動換行導致超出的尺寸被隱藏掉，無法显示要溢出的元素

• 使用after偽元素，常見的寫法如下：

 .clearfix::after {
    content: ".";
    display: block;
    height: 0;
    line-height: 0;
    clear: both;
    visibility:hidden;
    font-size: 0;
 }
 
 .clearfix {
    // 注意此處是為了兼容IE6和IE7瀏覽器，即觸發hasLayout
    zoom: 1;
 }

優點：符合閉合浮動思想，結構語義化正確
缺點：代碼量多，因為IE6-7下不支持after偽元素，需要額外寫zoom:1來觸發hasLayout

7. 居中布局的方式

水平居中：

• 若是行內元素，則直接給其父元素設置text-align: center即可
• 若是塊級元素，則直接給該元素設置margin: 0 auto即可
• 若子元素包含浮動元素，則給父元素設置width:fit-content並且配合margin

.parent {
    width: -webkit-fit-content;
    width: -moz-fit-content;
    width: fit-content;
    margin: 0 auto;
}

• 使用flex布局的方式，可以輕鬆實現水平居中，即使子元素中存在浮動元素也同樣適用

// flex 2012年版本寫法
.parent {
    display: flex;
    flex-direction: row;
    justify-content: center;
}

// flex 2009年版本寫法
.parent {
    display: box;
    box-orient: horizontal;
    box-pack: center;
}

• 使用絕對定位的方式，再配合CSS3新增的transform屬性

.child {
    position: absolute;
    left: 50%;
    transform: translate(-50%, 0);
}

• 使用絕對定位的方式，再配合負值的margin-left(此方法需要固定寬度)

.child {
    position: absolute;
    left: 50%;
    width: 200px; // 假定寬度為200px
    margin-left: -100px; // 負值的絕對值為寬度的一半
}

• 使用絕對定位的方式，再配合left:0;right:0;margin:0 auto;(此方法需要固定寬度)

.child {
    position: absolute;
    left: 0;
    right: 0;
    margin: 0 auto;
    width: 200px; // 假定寬度為200px
}

垂直居中：

• 若元素是單行文本，則直接給該元素設置line-height等於其父元素的高度
• 若元素是行內塊級元素，可以配合使用display:inline-block;vertical-align:middle和一個偽元素來讓內容塊居中

.parent::after, .child {
    display: inline-block;
    vertical-align: middle;
}

.parent::after {
    content: "";
    height: 100%;
}

• 使用vertical-align屬性並且配合使用display:table和display:table-cell來讓內容塊居中

.parent {
    display: table;
}

.child {
    display: table-cell;
    vertical-align: middle;
}

• 使用flex布局的方式，可以輕鬆實現垂直居中，即使子元素中存在浮動元素也同樣適用

// flex 2012年版本寫法
.parent {
    display: flex;
    align-items: center;
}

// flex 2009年版本寫法
.parent {
    display: box;
    box-orient: vertical;
    box-pack: center;
}

• 使用絕對定位的方式，再配合CSS3新增的transform屬性

.child {
    position: absolute;
    top: 50%;
    transform: translate(0, -50%);
}

• 使用絕對定位的方式，再配合負值的margin-top(此方法需要固定高度)

.child {
    position: absolute;
    top: 50%;
    height: 200px; // 假定高度為200px
    margin-top: -100px; // 負值的絕對值為高度的一半
}

• 使用絕對定位的方式，再配合top:0;bottom:0;margin:auto 0;(此方法需要固定高度)

.child {
    position: absolute;
    top: 0;
    bottom: 0;
    margin: auto 0;
    height: 200px; // 假定高度為200px
}

水平垂直居中：

• 使用flex布局的方式同樣可以輕鬆實現水平垂直居中

// flex 2012年版本寫法
.parent {
    display: flex;
    justify-content: center;
    align-items: center;
}

// flex 2009年版本寫法
.parent {
    display: box;
    box-pack: center;
    box-align: center;
}

• 使用絕對定位的方式，再配合CSS3新增的transform屬性

.child {
    position: absolute;
    left: 50%;
    top: 50%;
    transform: translate(-50%, -50%);
}

• 使用絕對定位的方式，再配合使用負值的margin-top和負值的margin-left(此方法需要同時固定寬度和高度)

.child {
    position: absolute;
    left: 50%;
    top: 50%;
    margin-top: -50px; // 負值的絕對值為高度的一半
    margin-left: -100px; // 負值的絕對值為寬度的一半
    width: 200px; // 假定寬度為200px
    height: 100px; // 假定高度為100px
}

8. CSS的優先級和權重

9. 移動端1px物理像素邊框

我們知道，在移動端存在物理像素(physical pixel)和設備獨立像素(density-independent pixel)的概念。物理像素也稱為設備像素，它是显示設備中一個最微小的物理部件，每個像素可以根據操作系統設置自己的顏色和亮度。設備獨立像素也稱為密度無關像素，可以認為是計算機坐標系統中的一個點，這個點代表一個可以由程序使用的虛擬像素(比如CSS像素)，然後由相關係統轉換為物理像素。根據物理像素和設備獨立像素也衍生出了設備像素比(device pixel ratio)的概念，簡稱為dpr，其定義了物理像素和設備獨立像素的對應關係，其計算公式為設備像素比 = 物理像素 / 設備獨立像素。因為視網膜(Retina)屏幕的出現，使得一個物理像素並不能和一個設備獨立像素完全對等，如下圖所示：

在上圖中，在普通屏幕下1個CSS像素對應1個物理像素，而在Retina屏幕下，1個CSS像素卻對應4個物理像素，即在Retina屏幕下會有不同的dpr值。為了追求在移動端網頁中更好的显示質量，因此我們需要做各種各樣的適配處理，最經典的莫過於1px物理像素邊框問題，我們需要根據移動端不同的dpr值來對邊框進行處理。在JavaScript中，可以通過window.devicePixelRatio來獲取當前設備的dpr，在CSS中，可以通過-webkit-device-pixel-ratio，-webkit-min-device-pixel-ratio和-webkit-max-device-pixel-ratio來進行媒體查詢，從而針對不同的設備，來做一些樣式適配。這裏對於1px像素的邊框問題，給出一種最常見的寫法：

.border-1px {
    position: relative;
}

.border-1px::after {
    content: "";
    position: absolute;
    left: 0;
    bottom: 0;
    width: 100%;
    height: 1px;
    background-color: #000;
    -webkit-transform: scaleY(.5);
    transform: scaleY(.5);
}

@media only screen and (-webkit-min-device-pixel-ratio: 2.0), (min-device-pixel-ratio: 2.0) {
    .border-1px::after {
        -webkit-transform: scaleY(.5);
        transform: scaleY(.5);
    }
}

@media only screen and (-webkit-min-device-pixel-ratio: 3.0), (min-device-pixel-ratio: 3.0) {
    .border-1px::after {
        -webkit-transform: scaleY(.33);
        transform: scaleY(.33);
    }
}

10. 實現三欄布局的方式有哪些

三欄布局，顧名思義就是分為左中右三個模塊進行布局，並且左右兩邊固定，中間模塊根據瀏覽器的窗口變化進行自適應，效果圖如下：

這裏給出四種實現三欄布局的方式：

• 使用絕對定位的方式

.container {
    position: relative;
    height: 200px;
    line-height: 200px;
    text-align: center;
    font-size: 20px;
    color: #fff;
}

.left {
    position: absolute;
    left: 0;
    top: 0;
    width: 150px;
    background: red;
}

.main {
    margin-left: 160px;
    margin-right: 110px;
    background: green;
}

.right {
    position: absolute;
    right: 0;
    top: 0;
    width: 100px;
    background: blue;
}

<div class="container">
    <div class="left">左</div>
    <div class="main">中</div>
    <div class="right">右</div>
</div>

優點：方便快捷，簡單實用，不容易出現問題，而且還可以將<div class="main"></div>元素放到最前面，使得主要內容被優先加載。
缺點：元素脫離了文檔流，可能會造成元素的重疊。

• 使用flex布局的方式

.container {
    display: flex;      
    height: 200px;
    line-height: 200px;
    text-align: center;
    font-size: 20px;
    color: #fff;
}

.left {
    width: 150px;
    background: red;
}

.main {
    margin: 0 10px;
    flex: 1;
    background: green;
}

.right {
    width: 100px;
    background: blue;
}

<div class="container">
    <div class="left">左</div>
    <div class="main">中</div>
    <div class="right">右</div>
</div>

優點：簡單實用，是現在比較流行的方案，特別是在移動端，大多數布局都採用的這種方式，是目前比較完美的一個。
缺點：需要考慮到瀏覽器的兼容性，根據不同的瀏覽器廠商需要添加相應的前綴。

• 雙飛翼布局

.content {
    float: left;
    width: 100%;
}

.main,
.left,
.right {
    height: 200px;
    line-height: 200px;
    text-align: center;
    font-size: 20px;
    color: #fff;
}

.main {
    margin-left: 160px;
    margin-right: 110px;
    background: green;
}

.left {
    float: left;
    margin-left: -100%;
    width: 150px;
    background: red;
}

.right {
    float: right;
    margin-left: -100px;
    width: 100px;
    background: blue;
}

<div class="content">
    <div class="main">中</div>
</div>
<div class="left">左</div>
<div class="right">右</div>

優點：比較經典的一種方式，通用性強，沒有兼容性問題，而且支持主要內容優先加載。
缺點：元素脫離了文檔流，要注意清除浮動，防止高度塌陷，同時額外增加了一層DOM結構，即增加了渲染樹生成的計算量。

• 聖杯布局

.container {
    margin-left: 160px;
    margin-right: 110px;
}

.left,
.main,
.right {
    height: 200px;
    line-height: 200px;
    text-align: center;
    font-size: 20px;
    color: #fff;    
}

.main {
    float: left;
    width: 100%;
    background: green;      
}

.left {
    position: relative;
    left: -160px;
    margin-left:  -100%;
    float: left;
    width: 150px;
    background: red;
}

.right {
    position: relative;
    right: -110px;
    margin-left:  -100px;
    float: left;
    width: 100px;
    background: blue;
}

<div class="container">
    <div class="main">中</div>
    <div class="left">左</div>
    <div class="right">右</div>
</div>

優點：相比於雙飛翼布局，結構更加簡單，沒有多餘的DOM結構層，同樣支持主要內容優先加載。
缺點：元素同樣脫離了文檔流，要注意清除浮動，防止高度塌陷。

11. 實現等高布局的方式有哪些

等高布局，顧名思義就是在同一個父容器中，子元素高度相等的布局。從等高布局的實現方式來說，可以分為兩種，分別是偽等高和真等高。偽等高是指子元素的高度差依然存在，只是視覺上給人的感覺就是等高，真等高是指子元素的高度真實相等。效果圖如下：

這裏給出五種實現等高布局的方式：

偽等高：

• 使用padding-bottom和負的margin-bottom來實現

.container {
    position: relative;
    overflow: hidden;
}
    
.left,
.main,
.right {
    padding-bottom: 100%;
    margin-bottom: -100%;
    float: left;
    color: #fff;
}

.left {
    width: 20%;
    background: red;
}

.main {
    width: 60%;
    background: green;
}

.right {
    width: 20%;
    background: blue;
}

<div class="container">
    <div class="left">左側內容</div>
    <div class="main">
        <p>中間內容</p>
        <p>中間內容</p>
        <p>中間內容</p>
    </div>
    <div class="right">右側內容</div>
</div>

真等高：

• 使用flex布局的方式

.container {
    display: flex;
}

.left,
.main,
.right {
    flex: 1;
    color: #fff;
}

.left {
    background: red;
}

.main {
    background: green;
}

.right {
    background: blue;
}

<div class="container">
    <div class="left">左側內容</div>
    <div class="main">
        <p>中間內容</p>
        <p>中間內容</p>
        <p>中間內容</p>
    </div>
    <div class="right">右側內容</div>
</div>

• 使用絕對定位的方式

.container {
  position: relative;
  height: 200px;
}

.left,
.main,
.right {
    position: absolute;
    top: 0;
    bottom: 0;
    color: #fff;
}

.left {
    left: 0;
    width: 20%;
    background: red;
}

.main {
    left: 20%;
    right: 20%;
    background: green;
}

.right {
    right: 0;
    width: 20%;
    background: blue;
}

<div class="container">
    <div class="left">左側內容</div>
    <div class="main">
        <p>中間內容</p>
        <p>中間內容</p>
        <p>中間內容</p>
    </div>
    <div class="right">右側內容</div>
</div>

• 使用table布局的方式

.container {
    width: 100%;
    display: table;
}

.left,
.main,
.right {
    display: table-cell;
    color: #fff;
}

.left {
    width: 20%;
    background: red;
}

.main {
    width: 60%;
    background: green;
}

.right {
    width: 20%;
    background: blue;
}

<div class="container">
    <div class="left">左側內容</div>
    <div class="main">
        <p>中間內容</p>
        <p>中間內容</p>
        <p>中間內容</p>
    </div>
    <div class="right">右側內容</div>
</div>

• 使用grid網格布局的方式

.container {
    display: grid;
    width: 100%;
    grid-template-columns: 1fr 1fr 1fr;
    color: #fff;
}

.left {
    background: red;
}

.main {
    background: green;
}

.right {
    background: blue;
}

<div class="container">
    <div class="left">左側內容</div>
    <div class="main">
        <p>中間內容</p>
        <p>中間內容</p>
        <p>中間內容</p>
    </div>
    <div class="right">右側內容</div>
</div>

12. CSS實現三角形的原理

工作中我們經常會遇到需要三角形圖標的應用場景，例如內容展開收起、左右箭頭點擊切換輪播，點擊某條列表數據查看詳情等。三角形圖標的應用範圍之廣，使得我們有必要了解一下它的實現原理。
1) 首先我們來實現一個最基礎的邊框效果

.content {
    width: 50px;
    height: 50px;
    border: 2px solid;
    border-color:#ff9600 #3366ff #12ad2a #f0eb7a;
}

效果如下：

2) 然後我們嘗試將border值放大10倍

.content {
    width: 50px;
    height: 50px;
    border: 20px solid;
    border-color: #ff9600 #3366ff #12ad2a #f0eb7a;
}

效果如下：

上圖中我們可以很清楚地看到，在繪製border的時候並不是矩形區域，而是梯形區域，那麼此時如果我們將width和height值設置為0，看會發生什麼：

.content {
    width: 0;
    height: 0;
    border: 20px solid;
    border-color: #ff9600 #3366ff #12ad2a #f0eb7a;
}

效果如下：

此時會看到一個由四個三角形拼裝而成的矩形區域，即由上下左右四個邊框組合而成。因此不難想象，如果我們想得到某一個方向的三角形，我們只需要讓其他方向的邊框不可見就行了，例如我們想得到一個朝左的三角形：

.content {
    width: 0;
    height: 0;
    border: 20px solid;
    border-color: transparent #3366ff transparent transparent;
}

效果如下:

這樣就得到了一個很完美的三角形圖標，是不是很簡單？

13. link與@import的區別

• 從屬關係區別

  @import是CSS提供的語法規則，只有導入樣式表的作用；link是HTML提供的標籤，不僅可以加載 CSS 文件，還可以定義 RSS，Rel連接屬性，設置瀏覽器資源提示符preload、prefetch等。

• 加載順序區別

  HTML文檔在解析的過程當中，如果遇到link標籤，則會立即發起獲取CSS文件資源的請求；@import引入的CSS將在頁面加載完畢后才會被加載。

• 兼容性區別

  @import是CSS2.1才有的語法，因此需要IE5以上才能識別；link標籤作為HTML元素，不存在兼容性問題。

• DOM可控性區別

  link標籤可以通過JS來動態引入，而@import無法通過JS來插入樣式

const loadStyle = (url) => {
    const link = document.createElement('link');
    link.setAttribute('type', 'text/css');
    link.setAttribute('rel', 'stylesheet');
    link.setAttribute('href', url);
    
    document.head.appendChild(link);
}

14. 瀏覽器是怎樣解析CSS選擇器的

CSS選擇器的解析是從右向左解析的。若從左向右地匹配，發現不符合規則，需要進行回溯，會損失很多性能。若從右向左匹配，先找到所有的最右節點，對於每一個節點，向上尋找其父節點直到找到根元素或滿足條件的匹配規則，則結束這個分支的遍歷。兩種匹配規則的性能差別很大，是因為從右向左的匹配在第一步就篩選掉了大量的不符合條件的最右節點(恭弘=叶 恭弘子節點)，而從左向右的匹配規則的性能都浪費在了失敗的查找上面。而在CSS解析完畢后，需要將解析的結果與DOM Tree的內容一起進行分析建立一棵 Render Tree，最終用來進行繪圖。在建立Render Tree時瀏覽器就要為每個DOM Tree中的元素根據CSS的解析結果(Style Rules)來確定生成怎樣的Render Tree。

15. CSS的性能優化方案

• 層級盡量扁平，避免嵌套過多層級的選擇器；
• 使用特定的選擇器，避免解析器過多層級的查找；
• 減少使用通配符與屬性選擇器；
• 減少不必要的多餘屬性；
• 避免使用!important標識，可以選擇其他選擇器；
• 實現動畫時優先使用CSS3的動畫屬性，動畫時脫離文檔流，開啟硬件加速；
• 使用link標籤代替@import；
• 將渲染首屏內容所需的關鍵CSS內聯到HTML中；
• 使用資源預加載指令preload讓瀏覽器提前加載CSS資源並緩存；
• 使用Gulp，Webpack等構建工具對CSS文件進行壓縮處理；

推薦閱讀

交流

終於接近尾聲了，居然花費掉了我一整個周末的時間，不過這篇主要是先總結一下CSS相關的知識點，當然還有很多地方沒有總結到，只是列出了個人覺得比較容易考察的點，如果你有其他補充的，歡迎在下方留言區討論哦，也歡迎關注我的公眾號[前端之境]，關注后我可以拉你加入微信前端交流群，我們一起互相交流學習，共同進步。
後續會陸續總結出JS方面、瀏覽器視角、算法基礎和框架方面的內容，希望你能夠喜歡！

文章已同步更新至，若覺文章尚可，歡迎前往star！

你的一個點贊，值得讓我付出更多的努力！

逆境中成長，只有不斷地學習，才能成為更好的自己，與君共勉！

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

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

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

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