//第一种：字面量
 var o1 = {name: 'o1'};
 var o2 = new Object({name: 'o2'});
//第二种  通过构造函数
 var M = function (name) { this.name = name; };
 var o3 = new M('o3');
//第三种  Object.create
 var p = {name: 'p'};
 var o4 = Object.create(p);

1，构造函数
fn Animal(){
this.name = 'name'
}
2，ES6class的声明
class Animal2 {
//↓↓构造函数
constructor(){
this.name=name
}
}
实例化类
console.log(new Animal(),new Animal2())

fn parent1（）{
this.name= 'parent1'
}
parent1.prototype.say(){
console.log('hello')
}
fn child1() {
parent1.call(this)
this.type='child1'
}

• 根元素
• float的值不为none
• overflow的值不为visible
• display的值为inline-block、table-cell、table-caption
• position的值为absolute或fixed

1. 内部的Box会在垂直方向上一个接一个的放置
2. 垂直方向上的距离由margin决定。（完整的说法是：属于同一个BFC的两个相邻Box的margin会发生重叠，与方向无关。）
3. 每个元素的左外边距与包含块的左边界相接触（从左向右），即使浮动元素也是如此。（这说明BFC中子元素不会超出他的包含块，而position为absolute的元素可以超出他的包含块边界）
4. BFC的区域不会与float的元素区域重叠
5. 计算BFC的高度时，浮动子元素也参与计算
6. BFC就是页面上的一个隔离的独立容器，容器里面的子元素不会影响到外面元素，反之亦然

• 前言

链表是常见的数据结构之一,但是很多同学只听说过链表,并不知道什么是链表,所以本文将会带领各位同学手写一个LinkedList,源码跟官方会有点不一样,不过思路是大概相同的,最后再带领大家读官方源码

为了降低源码难度简化泛型代码,手写的LinkedList只能添加String类型数据

• 什么是链表?

可以理解为,把一些数据按照顺序排好,手拉手 每一个数据就是一个节点,所有节点连在一起,就组成了链表 

• LinkedList的节点定义

LinkedList是双链表,所以有左节点和右节点,我们先定义一个实体类,这个实体类就可以理解为节点

    /**

     * 节点实体类

     */

    private static class NodeBean {

        NodeBean leftNode; //左节点

        String value; //节点的值

        NodeBean rightNode; //右节点

    }

复制代码

• 节点怎么连接?

看完上面的图片,应该大概知道两个节点的连接方法了,我们只需要:

节点1.右节点 = 节点2

节点2.左节点 = 节点1

复制代码

我们先实现链表的add方法,add方法其实就是将两个节点连接:

    /**

     * 添加值

     */

    public void add(String value) {

        //先获取尾节点(上一个节点)

        NodeBean lastNode = this.lastNode;

        //创建一个新节点

        NodeBean newNode = new NodeBean();

        //为节点赋值

        newNode.value = value;

        //左节点为最后一个节点(尾节点)

        newNode.leftNode = lastNode;

        //由于是添加节点,所以右节点为null,可以不写

        newNode.rightNode = null;

        //将成员变量的最后一个节点改为当前新节点

        this.lastNode = newNode;

        //判断头节点是否为空

        if (this.firstNode == null) {

            //如果为空说明当前是第一个节点,需要把头结点也设为当前节点

            this.firstNode = newNode;

        }else{

            //如果不为空,需要把前一个节点的右节点指向当前节点

            //两个节点相连接的条件是:

            //      1. 前一个节点的右节点指向当前节点

            //      2. 当前节点的左节点指向上一个节点

            lastNode.rightNode = newNode;

        }

        //链表长度+1

        size++;

    }

复制代码

• 节点怎么断开?

两个节点断开只需要将自己的上一个节点的右节点指向自己的下一个节点左节点,同时自己的下一个节点的左节点,指向上一个节点的右节点

注意看下图箭头方向,这样节点2就可以直接断开,节点1和节点3直接连接,这里也可以很明显的看出,链表增删很快,只需要断开前后节点就可以

先看一下断开节点的大概代码思路:

节点2.左节点 = null

节点2.右节点 = null

节点1.右节点 = 节点3

节点3.左节点 = 节点1



这样就可以断开当前节点,并且将链表重新连接起来

复制代码

现在我们来实现remove(index)方法,根据索引删除指定节点:

    /**

     * 删除值

     */

    public void remove(int index){

        这里代码通过索引查找节点,为了简化代码,请忽略这里的代码

        通过索引查找节点,下面会写到

        ...

        ***indexNode就是我们通过索引拿到的节点***

        

        indexNode = 通过索引查找节点(index)

        

        //拿到该节点的左节点、右节点以及值

        NodeBean leftNode = indexNode.leftNode;

        NodeBean rightNode = indexNode.rightNode;



        //判断左节点是否为空,如果为空说明当前节点为(头结点)第一个节点

        if (leftNode == null) {

            this.firstNode = indexNode;

        }else{

            //左节点不为空,需要断开自己的左节点

            indexNode.leftNode = null;

            //将上一个节点的右节点连接到下一个节点

            leftNode.rightNode = rightNode;

        }



        //判断右节点是否为空,如果为空说明当前为(尾节点)最后一个节点

        if (rightNode == null) {

            this.lastNode = indexNode;

        }else{

            //右节点不为空,需要断开自己的右节点

            indexNode.rightNode = null;

            //将下一个节点的左节点连接到上一个节点

            rightNode.leftNode = leftNode;

        }



        //当前节点值置空

        indexNode.value = null;

        size--;

    }

复制代码

• 通过索引查找节点

1. 先拿到头节点

2. 拿到当前要查找的索引index

3. 循环index的次数

4. 每循环一次,就从头结点开始往后移动一个节点

复制代码

现在我们来实现以下get(index)方法,通过索引获取置顶节点:

    /**

     * 通过索引获取节点的值

     */

    public String get(int index){

        //由于链表没有索引,所以只能一个一个遍历查找

        //先拿到链表的第一个节点(头节点)

        NodeBean firstNode = this.firstNode;

        for (int i = 0; i < index; i++) {

            //每次循环就从头结点往后挪动一个节点

            firstNode = firstNode.rightNode;

        }

        //为了简化代码便于理解,这里不考虑tempNode为null的情况

        return firstNode.value;

    }

复制代码

• 总结

1. 链表的每个节点之间都有连接,如果新增节点只需要直接插入就行,所以==链表新增快==
2. 链表断开节点只需要将自己的前后节点重新连接就可以,所以链表==删除快==
3. 链表没有索引,查找需要循环整个链表,所以==查询慢==

• MyLinkedList完整代码:

public class MyLinkedList {

    private int size; //当前链表的长度

    private NodeBean firstNode; //头节点

    private NodeBean lastNode; //尾节点



    /**

     * 添加值

     */

    public void add(String value) {

        //先获取尾节点

        NodeBean lastNode = this.lastNode;

        //创建一个新节点

        NodeBean newNode = new NodeBean();

        //为节点赋值

        newNode.value = value;

        //左节点为最后一个节点(尾节点)

        newNode.leftNode = lastNode;

        //由于是添加节点,所以右节点为null,可以不写

        newNode.rightNode = null;

        //将成员变量的最后一个节点改为当前新节点

        this.lastNode = newNode;

        //判断头节点是否为空

        if (this.firstNode == null) {

            //如果为空说明当前是第一个节点,需要把头结点也设为当前节点

            this.firstNode = newNode;

        }else{

            //如果不为空,需要把前一个节点的右节点指向当前节点

            //两个节点相连接的条件是:

            //      1. 前一个节点的右节点指向当前节点

            //      2. 当前节点的左节点指向上一个节点

            lastNode.rightNode = newNode;

        }

        //链表长度+1

        size++;

    }



    /**

     * 删除值

     */

    public void remove(int index){

        //先找到当前索引对应的节点

        //由于链表没有索引,所以只能一个一个遍历查找

        //先拿到链表的第一个节点(头节点)

        NodeBean indexNode = this.firstNode;

        for (int i = 0; i < index; i++) {

            //每次循环就从头结点往后挪动一个节点

            indexNode = indexNode.rightNode;

        }

        //拿到该节点的左节点、右节点以及值

        NodeBean leftNode = indexNode.leftNode;

        NodeBean rightNode = indexNode.rightNode;



        //判断左节点是否为空,如果为空说明当前节点为(头结点)第一个节点

        if (leftNode == null) {

            this.firstNode = indexNode;

        }else{

            //左节点不为空,需要断开自己的左节点

            indexNode.leftNode = null;

            //将上一个节点的右节点连接到下一个节点

            leftNode.rightNode = rightNode;

        }



        //判断右节点是否为空,如果为空说明当前为(尾节点)最后一个节点

        if (rightNode == null) {

            this.lastNode = indexNode;

        }else{

            //右节点不为空,需要断开自己的右节点

            indexNode.rightNode = null;

            //将下一个节点的左节点连接到上一个节点

            rightNode.leftNode = leftNode;

        }



        //当前节点值置空

        indexNode.value = null;

        size--;

    }



    /**

     * 通过索引获取节点的值

     */

    public String get(int index){

        //由于链表没有索引,所以只能一个一个遍历查找

        //先拿到链表的第一个节点(头节点)

        NodeBean firstNode = this.firstNode;

        for (int i = 0; i < index; i++) {

            //每次循环就从头结点往后挪动一个节点

            firstNode = firstNode.rightNode;

        }

        //为了简化代码便于理解,这里不考虑tempNode为null的情况

        return firstNode.value;

    }



    /**

     * 获取链表长度

     */

    public int getSize(){

        return this.size;

    }



    /**

     * 节点实体类

     */

    private static class NodeBean {

        NodeBean leftNode; //左节点

        String value; //节点的值

        NodeBean rightNode; //右节点

    }

}



复制代码

• 重点

• 如果你看完上面的增删查方法, 可以完全看懂了,就可以继续往下看了
• 如果你没看懂,请复制上面的完整代码到编辑器,自己断点研究一下

==如果上面的代码理解了,恭喜你! 现在你应该已经可以看懂官方源码了==

• 官方代码解析

• 节点实体类

    private static class Node<E> {

        E item;

        Node<E> next;

        Node<E> prev;



        Node(Node<E> prev, E element, Node<E> next) {

            this.item = element;

            this.next = next;

            this.prev = prev;

        }

    }

复制代码

代码对比 

• 插入节点

    void linkLast(E e) {

        final Node<E> l = last;

        final Node<E> newNode = new Node<>(l, e, null);

        last = newNode;

        if (l == null)

            first = newNode;

        else

            l.next = newNode;

        size++;

        modCount++;

    }

复制代码

代码对比 

• 断开节点

    E unlink(Node<E> x) {

        // assert x != null;

        final E element = x.item;

        final Node<E> next = x.next;

        final Node<E> prev = x.prev;



        if (prev == null) {

            first = next;

        } else {

            prev.next = next;

            x.prev = null;

        }



        if (next == null) {

            last = prev;

        } else {

            next.prev = prev;

            x.next = null;

        }



        x.item = null;

        size--;

        modCount++;

        return element;

    }

复制代码

代码对比 

• 最后总结

• 如果现在你可以看懂官方的这三个方法了,那可以尝试自己去读剩下的部分方法,比如==unlinkFirst()和linkFirst()==
• 读源码并不可怕,只要理解源码的思路,顿时豁然开朗

// 本地和云端都存在的字符串

MyLang.getString("local_string", R.string.local_string)



// 云端存在 remote_string_only

// 但本地没有 R.string.remote_string_only，用 R.string.fallback_string 代替

MyLang.getString("remote_string_only", R.string.fallback_string)

//应用一种语言（这里自动处理了语言包的升级、语言包内部字符串的升级）

MyLang.getInstance().applyLanguage(Context, LocaleInfo, force=true, init=false);



//删除一种语言

MyLang.getInstance().deleteLanguage(Context, LocaleInfo);

//1. 所有云端的语言包

MyLang.getInstance().remoteLanguages



//2. 所有下载到本地、可用的语言包

MyLang.getInstance().languages



//3. 所有非官方的语言包

MyLang.getInstance().unofficialLanguages



//4. 除内置支持的语言外，另外安装的云端的语言包

MyLang.getInstance().otherLanguages

//build.gradle

allprojects {

    repositories {

        google()

        jcenter()

        maven { url "https://github.com/LinXueyuanStdio/MLang/raw/main/dist/" }

    }

}



//app/build.gradle

implementation 'com.timecat.component:MLang:2.0.2'

public class MyApplication extends Application {

    @SuppressLint("StaticFieldLeak")

    public static volatile Context applicationContext;

    public static volatile Handler applicationHandler;



    @Override

    public void onCreate() {

        super.onCreate();

        applicationContext = this;

        applicationHandler = new Handler(applicationContext.getMainLooper());

        MyLang.init(applicationContext);

    }



    @Override

    public void onConfigurationChanged(@NonNull Configuration newConfig) {

        super.onConfigurationChanged(newConfig);

        MyLang.onConfigurationChanged(newConfig);

    }

}

public class MyLang {

    private static File filesDir;

    private static LangAction action;

    public static void init(@NonNull Context applicationContext) {

        filesDir = applicationContext.getCacheDir();

        action = new MyLangAction();

        getInstance();

    }

    public static MLang getInstance() {

        return MLang.getInstance(MyApplication.applicationContext, filesDir, action);

    }

    public static void onConfigurationChanged(@NonNull Configuration newConfig) {

        getInstance().onDeviceConfigurationChange(getContext(), newConfig);

    }

}

MLang.getInstance(context, filesDir, action);

public interface LangAction {

    /**

     * SharedPreferences preferences = Utilities.getGlobalMainSettings();

     * SharedPreferences.Editor editor = preferences.edit();

     * editor.putString("language", language);

     * editor.commit();

     * @param language localeInfo.getKey() 语言 id

     */

    void saveLanguageKeyInLocal(String language);



    /**

     * SharedPreferences preferences = Utilities.getGlobalMainSettings();

     * String lang = preferences.getString("language", null);

     * @return @Nullable lang 语言 id

     */

    String loadLanguageKeyInLocal();



    /**

     * 在其他线程网络请求，在主线程或UI线程调用callback

     * 这里设计成这样，是因为这个方法里支持异步执行

     * 您需要在合适的时机手动调用 callback，且只能调用一次

     * @param lang_pack 语言包名字

     * @param lang_code 语言包版本名称

     * @param from_version 语言包版本号

     * @param callback @NonNull 在主线程或UI线程调用

     */

    void langpack_getDifference(String lang_pack, String lang_code, int from_version, GetDifferenceCallback callback);



    /**

     * 在其他线程网络请求，在主线程或UI线程调用callback

     * 这里设计成这样，是因为这个方法里支持异步执行

     * 您需要在合适的时机手动调用 callback，且只能调用一次

     * @param callback @NonNull 在主线程或UI线程调用

     */

    void langpack_getLanguages(GetLanguagesCallback callback);



    /**

     * 在其他线程网络请求，在主线程或UI线程调用callback

     * 这里设计成这样，是因为这个方法里支持异步执行

     * 您需要在合适的时机手动调用 callback，且只能调用一次

     * @param lang_code 语言包版本名称

     * @param callback @NonNull 在主线程或UI线程调用

     */

    void langpack_getLangPack(String lang_code, GetLangPackCallback callback);



    interface GetLanguagesCallback {

        /**

         * 必须在UI线程或者主线程调用

         * 所有可用的语言包

         * @param languageList 语言包列表

         */

        void onLoad(List<LangPackLanguage> languageList);

    }



    interface GetDifferenceCallback {

        /**

         * 必须在UI线程或者主线程调用

         * 如果服务端没有实现增量分发的功能，可以用完整的语言包代替

         * @param languageList 增量的语言包

         */

        void onLoad(LangPackDifference languageList);

    }



    interface GetLangPackCallback {

        /**

         * 必须在UI线程或者主线程调用

         * @param languageList 完整的语言包

         */

        void onLoad(LangPackDifference languageList);

    }



}

public class MyLangAction implements LangAction {

   @Override

   public static void saveLanguageKeyInLocal(String language) {

       SharedPreferences preferences = getContext().getSharedPreferences("language_locale", Context.MODE_PRIVATE);

       SharedPreferences.Editor editor = preferences.edit();

       editor.putString("language", language);

       editor.apply();

   }



   @Override

   @Nullable

   public static String loadLanguageKeyInLocal() {

       SharedPreferences preferences = getContext().getSharedPreferences("language_locale", Context.MODE_PRIVATE);

       return preferences.getString("language", null);

   }

   @Override

   public void langpack_getDifference(String lang_pack, String lang_code, int from_version, @NonNull final LangAction.GetDifferenceCallback callback) {

       Server.request_langpack_getDifference(lang_pack, lang_code, from_version, new Server.GetDifferenceCallback() {

           @Override

           public void onNext(final LangPackDifference difference) {

               callback.onLoad(difference);

           }

       });

   }



   @Override

   public void langpack_getLanguages(@NonNull final LangAction.GetLanguagesCallback callback) {

       Server.request_langpack_getLanguages(new Server.GetLanguagesCallback() {

           @Override

           public void onNext(final List<LangPackLanguage> languageList) {

               callback.onLoad(languageList);

           }

       });

   }



   @Override

   public void langpack_getLangPack(String lang_code, @NonNull final LangAction.GetLangPackCallback callback) {

       Server.request_langpack_getLangPack(lang_code, new Server.GetLangPackCallback() {

           @Override

           public void onNext(final LangPackDifference difference) {

               callback.onLoad(difference);

           }

       });

   }

}

public class Server {

    public static LangPackLanguage chineseLanguage() {

        LangPackLanguage langPackLanguage = new LangPackLanguage();

        langPackLanguage.name = "chinese";

        langPackLanguage.native_name = "简体中文";

        langPackLanguage.lang_code = "zh";

        langPackLanguage.base_lang_code = "zh";

        return langPackLanguage;

    }

    public static LangPackDifference chinesePackDifference() {

        LangPackDifference difference = new LangPackDifference();

        difference.lang_code = "zh";

        difference.from_version = 0;

        difference.version = 1;

        difference.strings = chineseStrings();

        return difference;

    }

    public static ArrayList<LangPackString> chineseStrings() {

        ArrayList<LangPackString> list = new ArrayList<>();

        list.add(new LangPackString("LanguageName", "中文简体"));

        list.add(new LangPackString("LanguageNameInEnglish", "Chinese"));

        list.add(new LangPackString("local_string", "中文的云端字符串"));

        list.add(new LangPackString("remote_string_only", "本地缺失，云端存在的字符串"));

        return list;

    }

}

MLang.isRTL = false; //是否从右到左阅读（默认 false）

MLang.is24HourFormat = false; //是否 24 小时制（默认 false） 

    SnakeViewMaker snakeViewMaker = new SnakeViewMaker(MainActivity.this);

    snakeViewMaker

    .addTargetView(imageView)                                  // 绑定目标View

    .attachToRootLayout((ViewGroup) findViewById(R.id.root));  // 绑定Activity/Fragment的根布局

    snakeViewMaker.detachSnake();                // 解除绑定

    snakeViewMaker.updateSnakeImage();           // 当目标View的视图发生变化时，调用此方法用以更新Snake视图状态

    snakeViewMaker.interceptTouchEvent(true);    // Snake拖动过程中是否需要屏蔽其他onTouch事件，默认屏蔽

    snakeViewMaker.setVisibility(View.VISIBLE);  // 控制可见性

    snakeViewMaker.setClickable(true);           // 控制可点击

    snakeViewMaker.setEnabled(true);             // 控制可触摸

    snakeViewMaker = new SnakeViewMaker(MainActivity.this);

    Glide.with(this).load(url).asBitmap()

                    .into(new BitmapImageViewTarget(imageView) {

                        @Override

                        protected void setResource(Bitmap resource) {

                            super.setResource(resource);

                            snakeViewMaker.addTargetView(imageView)

                                    .attachToRootLayout((ViewGroup) findViewById(R.id.root));

                        }

                    });

//判断是否完成

    BOOL done = NO;

    //判断已写大小

    if (bytesWritten > 0)

    {

        // Update total amount read for the current write

        //更新当前总共写的大小

        currentWrite->bytesDone += bytesWritten;

        LogVerbose(@"currentWrite->bytesDone = %lu", (unsigned long)currentWrite->bytesDone);

        

        // Is packet done?

        //判断当前写包是否写完

        done = (currentWrite->bytesDone == [currentWrite->buffer length]);

    }

同样为的也是三种数据包：一次性包，粘包，断包

  //如果完成了

    if (done)

    {

        //完成操作

        [self completeCurrentWrite];

        

        if (!error)

        {

            dispatch_async(socketQueue, ^{ @autoreleasepool{

                //开始下一次的读取任务

                [self maybeDequeueWrite];

            }});

        }

    }

    //未完成

    else

    {

        // We were unable to finish writing the data,

        // so we're waiting for another callback to notify us of available space in the lower-level output buffer.

        //如果不是等待 而且没有出错

        if (!waiting && !error)

        {

            // This would be the case if our write was able to accept some data, but not all of it.

            //这是我们写了一部分数据的情况。

            

            //去掉可接受数据的标记

            flags &= ~kSocketCanAcceptBytes;

            //再去等读source触发

            if (![self usingCFStreamForTLS])

            {

                [self resumeWriteSource];

            }

        }

        

        //如果已写大于0

        if (bytesWritten > 0)

        {

            // We're not done with the entire write, but we have written some bytes

            

            __strong id theDelegate = delegate;



            //调用写的进度代理

            if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:didWritePartialDataOfLength:tag:)])

            {

                long theWriteTag = currentWrite->tag;

                

                dispatch_async(delegateQueue, ^{ @autoreleasepool {

                    

                    [theDelegate socket:self didWritePartialDataOfLength:bytesWritten tag:theWriteTag];

                }});

            }

        }

    }

    

- (void)maybeDequeueWrite

{

    LogTrace();

    NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

    

    

    // If we're not currently processing a write AND we have an available write stream

    if ((currentWrite == nil) && (flags & kConnected))

    {

        if ([writeQueue count] > 0)

        {

            // Dequeue the next object in the write queue

            currentWrite = [writeQueue objectAtIndex:0];

            [writeQueue removeObjectAtIndex:0];

            

            //TLS

            if ([currentWrite isKindOfClass:[GCDAsyncSpecialPacket class]])

            {

                LogVerbose(@"Dequeued GCDAsyncSpecialPacket");

                

                // Attempt to start TLS

                flags |= kStartingWriteTLS;

                

                // This method won't do anything unless both kStartingReadTLS and kStartingWriteTLS are set

                [self maybeStartTLS];

            }

            else

            {

                LogVerbose(@"Dequeued GCDAsyncWritePacket");

                

                // Setup write timer (if needed)

                [self setupWriteTimerWithTimeout:currentWrite->timeout];

                

                // Immediately write, if possible

                [self doWriteData];

            }

        }

        //写超时导致的错误

        else if (flags & kDisconnectAfterWrites)

        {

            //如果没有可读任务，直接关闭socket

            if (flags & kDisconnectAfterReads)

            {

                if (([readQueue count] == 0) && (currentRead == nil))

                {

                    [self closeWithError:nil];

                }

            }

            else

            {

                [self closeWithError:nil];

            }

        }

    }

}

- (void)doWriteData

{

    LogTrace();

    

    // This method is called by the writeSource via the socketQueue

    

    //错误，不写

    if ((currentWrite == nil) || (flags & kWritesPaused))

    {

        LogVerbose(@"No currentWrite or kWritesPaused");

        

        // Unable to write at this time

        

        //

        if ([self usingCFStreamForTLS])

        {

            // CFWriteStream only fires once when there is available data.

            // It won't fire again until we've invoked CFWriteStreamWrite.

        }

        else

        {

            // If the writeSource is firing, we need to pause it

            // or else it will continue to fire over and over again.

            

            //如果socket中可接受写数据，防止反复触发写source，挂起

            if (flags & kSocketCanAcceptBytes)

            {

                [self suspendWriteSource];

            }

        }

        return;

    }

    

    //如果当前socket无法在写数据了

    if (!(flags & kSocketCanAcceptBytes))

    {

        LogVerbose(@"No space available to write...");

        

        // No space available to write.

        

        //如果不是cfstream

        if (![self usingCFStreamForTLS])

        {

            // Need to wait for writeSource to fire and notify us of

            // available space in the socket's internal write buffer.

            //则恢复写source，当有空间去写的时候，会触发回来

            [self resumeWriteSource];

        }

        return;

    }

    

    //如果正在进行TLS认证

    if (flags & kStartingWriteTLS)

    {

        LogVerbose(@"Waiting for SSL/TLS handshake to complete");

        

        // The writeQueue is waiting for SSL/TLS handshake to complete.

        

        if (flags & kStartingReadTLS)

        {

            //如果是安全通道，并且I/O阻塞，那么重新去握手

            if ([self usingSecureTransportForTLS] && lastSSLHandshakeError == errSSLWouldBlock)

            {

                // We are in the process of a SSL Handshake.

                // We were waiting for available space in the socket's internal OS buffer to continue writing.

            

                [self ssl_continueSSLHandshake];

            }

        }

        //说明不走`TLS`了，因为只支持写的TLS

        else

        {

            // We are still waiting for the readQueue to drain and start the SSL/TLS process.

            // We now know we can write to the socket.

            

            //挂起写source

            if (![self usingCFStreamForTLS])

            {

                // Suspend the write source or else it will continue to fire nonstop.

                [self suspendWriteSource];

            }

        }

        

        return;

    }

    

    // Note: This method is not called if currentWrite is a GCDAsyncSpecialPacket (startTLS packet)

    

    //开始写数据

    

    BOOL waiting = NO;

    NSError *error = nil;

    size_t bytesWritten = 0;

    

    //安全连接

    if (flags & kSocketSecure)

    {

        //CFStreamForTLS

        if ([self usingCFStreamForTLS])

        {

            #if TARGET_OS_IPHONE

            

            // 

            // Writing data using CFStream (over internal TLS)

            // 

            

            const uint8_t *buffer = (const uint8_t *)[currentWrite->buffer bytes] + currentWrite->bytesDone;

            

            //写的长度为buffer长度-已写长度

            NSUInteger bytesToWrite = [currentWrite->buffer length] - currentWrite->bytesDone;

            

            if (bytesToWrite > SIZE_MAX) // NSUInteger may be bigger than size_t (write param 3)

            {

                bytesToWrite = SIZE_MAX;

            }

            //往writeStream中写入数据， bytesToWrite写入的长度

            CFIndex result = CFWriteStreamWrite(writeStream, buffer, (CFIndex)bytesToWrite);

            LogVerbose(@"CFWriteStreamWrite(%lu) = %li", (unsigned long)bytesToWrite, result);

        

            //写错误

            if (result < 0)

            {

                error = (__bridge_transfer NSError *)CFWriteStreamCopyError(writeStream);

            }

            else

            {

                //拿到已写字节数

                bytesWritten = (size_t)result;

                

                // We always set waiting to true in this scenario.

                //我们经常设置等待来信任这个方案

                // CFStream may have altered our underlying socket to non-blocking.

                //CFStream很可能修改socket为非阻塞

                // Thus if we attempt to write without a callback, we may end up blocking our queue.

                //因此，我们尝试去写，而不用回调。 我们可能终止我们的队列。

                waiting = YES;

            }

            

            #endif

        }

        //SSL写的方式

        else

        {

            // We're going to use the SSLWrite function.

            // 

            // OSStatus SSLWrite(SSLContextRef context, const void *data, size_t dataLength, size_t *processed)

            // 

            // Parameters:

            // context     - An SSL session context reference.

            // data        - A pointer to the buffer of data to write.

            // dataLength  - The amount, in bytes, of data to write.

            // processed   - On return, the length, in bytes, of the data actually written.

            // 

            // It sounds pretty straight-forward,

            //看起来相当直观，但是这里警告你应注意。

            // but there are a few caveats you should be aware of.

            // 

            // The SSLWrite method operates in a non-obvious (and rather annoying) manner.

            // According to the documentation:

            // 这个SSLWrite方法使用着一个不明显的方法（相当讨厌）导致了下面这些事。

            //   Because you may configure the underlying connection to operate in a non-blocking manner,

            //因为你要辨别出下层连接 操纵 非阻塞的方法，一个写的操作将返回errSSLWouldBlock，表明需要写的数据少了。

            //   a write operation might return errSSLWouldBlock, indicating that less data than requested

            //   was actually transferred. In this case, you should repeat the call to SSLWrite until some

            //在这种情况下你应该重复调用SSLWrite，直到一些其他结果被返回

            //   other result is returned.

            // This sounds perfect, but when our SSLWriteFunction returns errSSLWouldBlock,

            //这样听起来很完美，但是当SSLWriteFunction返回errSSLWouldBlock，SSLWrite返回但是却设置了进度长度？

            // then the SSLWrite method returns (with the proper errSSLWouldBlock return value),

            // but it sets processed to dataLength !!

            // 

            // In other words, if the SSLWrite function doesn't completely write all the data we tell it to,

            //另外，SSLWrite方法没有完整的写完我们给的所有数据，因此它没有告诉我们到底写了多少数据，

            // then it doesn't tell us how many bytes were actually written. So, for example, if we tell it to

            //因此。举个例子，如果我们告诉它去写256个字节，它可能只写了128个字节，但是告诉我们写了0个字节

            // write 256 bytes then it might actually write 128 bytes, but then report 0 bytes written.

            // 

            // You might be wondering:

            //你可能会觉得奇怪，如果这个方法不告诉我们写了多少字节，那么该如何去更新参数来应对下一次的SSLWrite？

            // If the SSLWrite function doesn't tell us how many bytes were written,

            // then how in the world are we supposed to update our parameters (buffer & bytesToWrite)

            // for the next time we invoke SSLWrite?

            // 

            // The answer is that SSLWrite cached all the data we told it to write,

            //答案就是，SSLWrite缓存了所有的数据我们要它写的。并且拉出这些数据，只要我们下次调用SSLWrite。

            // and it will push out that data next time we call SSLWrite.

            

            // If we call SSLWrite with new data, it will push out the cached data first, and then the new data.

            //如果我们用新的data调用SSLWrite,它会拉出这些缓存的数据，然后才轮到新数据

            // If we call SSLWrite with empty data, then it will simply push out the cached data.

            // 如果我们调用SSLWrite用一个空的数据，则它仅仅会拉出缓存数据。

            // For this purpose we're going to break large writes into a series of smaller writes.

            //为了这个目的，我们去分开一个大数据写成一连串的小数据，它允许我们去报告进度给代理。

            // This allows us to report progress back to the delegate.

            

            OSStatus result;

            

            //SSL缓存的写的数据

            BOOL hasCachedDataToWrite = (sslWriteCachedLength > 0);

            //是否有新数据要写

            BOOL hasNewDataToWrite = YES;

            

            if (hasCachedDataToWrite)

            {

                size_t processed = 0;

                

                //去写空指针，就是拉取了所有的缓存SSL数据

                result = SSLWrite(sslContext, NULL, 0, &processed);

                

                //如果写成功

                if (result == noErr)

                {

                    //拿到写的缓存长度

                    bytesWritten = sslWriteCachedLength;

                    //置空缓存长度

                    sslWriteCachedLength =  0;

                    //判断当前需要写的buffer长度，是否和已写的大小+缓存 大小相等

                    if ([currentWrite->buffer length] == (currentWrite->bytesDone + bytesWritten))

                    {

                        // We've written all data for the current write.

                        //相同则不需要再写新数据了

                        hasNewDataToWrite = NO;

                    }

                }

                //有错

                else

                {

                    //IO阻塞，等待

                    if (result == errSSLWouldBlock)

                    {

                        waiting = YES;

                    }

                    //报错

                    else

                    {

                        error = [self sslError:result];

                    }

                    

                    // Can't write any new data since we were unable to write the cached data.

                    //如果读写cache出错，我们暂时不能去读后面的数据

                    hasNewDataToWrite = NO;

                }

            }

            

            //如果还有数据去读

            if (hasNewDataToWrite)

            {

                //拿到buffer偏移位置

                const uint8_t *buffer = (const uint8_t *)[currentWrite->buffer bytes]

                                                        + currentWrite->bytesDone

                                                        + bytesWritten;

                

                //得到需要读的长度

                NSUInteger bytesToWrite = [currentWrite->buffer length] - currentWrite->bytesDone - bytesWritten;

                //如果大于最大值,就等于最大值

                if (bytesToWrite > SIZE_MAX) // NSUInteger may be bigger than size_t (write param 3)

                {

                    bytesToWrite = SIZE_MAX;

                }

                

                size_t bytesRemaining = bytesToWrite;

                

                //循环值

                BOOL keepLooping = YES;

                while (keepLooping)

                {

                    //最大写的字节数？

                    const size_t sslMaxBytesToWrite = 32768;

                    //得到二者小的，得到需要写的字节数

                    size_t sslBytesToWrite = MIN(bytesRemaining, sslMaxBytesToWrite);

                    //已写字节数

                    size_t sslBytesWritten = 0;

                    

                    //将结果从buffer中写到socket上（经由了这个函数，数据就加密了）

                    result = SSLWrite(sslContext, buffer, sslBytesToWrite, &sslBytesWritten);

                    

                    //如果写成功

                    if (result == noErr)

                    {

                        //buffer指针偏移

                        buffer += sslBytesWritten;

                        //加上些的数量

                        bytesWritten += sslBytesWritten;

                        //减去仍需写的数量

                        bytesRemaining -= sslBytesWritten;

                        //判断是否需要继续循环

                        keepLooping = (bytesRemaining > 0);

                    }

                    else

                    {

                        //IO阻塞

                        if (result == errSSLWouldBlock)

                        {

                            waiting = YES;

                            //得到缓存的大小（后续长度会被自己写到SSL缓存去）

                            sslWriteCachedLength = sslBytesToWrite;

                        }

                        else

                        {

                            error = [self sslError:result];

                        }

                        

                        //跳出循环

                        keepLooping = NO;

                    }

                    

                } // while (keepLooping)

                

            } // if (hasNewDataToWrite)

        }

    }

    

    //普通socket

    else

    {

        // 

        // Writing data directly over raw socket

        // 

        

        //拿到当前socket

        int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;

        

        //得到指针偏移

        const uint8_t *buffer = (const uint8_t *)[currentWrite->buffer bytes] + currentWrite->bytesDone;

        

        NSUInteger bytesToWrite = [currentWrite->buffer length] - currentWrite->bytesDone;

        

        if (bytesToWrite > SIZE_MAX) // NSUInteger may be bigger than size_t (write param 3)

        {

            bytesToWrite = SIZE_MAX;

        }

        //直接写

        ssize_t result = write(socketFD, buffer, (size_t)bytesToWrite);

        LogVerbose(@"wrote to socket = %zd", result);

        

        // Check results

        if (result < 0)

        {

            //IO阻塞

            if (errno == EWOULDBLOCK)

            {

                waiting = YES;

            }

            else

            {

                error = [self errnoErrorWithReason:@"Error in write() function"];

            }

        }

        else

        {

            //得到写的大小

            bytesWritten = result;

        }

    }

    

    // We're done with our writing.

    // If we explictly ran into a situation where the socket told us there was no room in the buffer,

    // then we immediately resume listening for notifications.

    // 

    // We must do this before we dequeue another write,

    // as that may in turn invoke this method again.

    // 

    // Note that if CFStream is involved, it may have maliciously put our socket in blocking mode.

    //注意，如果用CFStream,很可能会被恶意的放置数据 阻塞socket

    

    //如果等待，则恢复写source

    if (waiting)

    {

        //把socket可接受数据的标记去掉

        flags &= ~kSocketCanAcceptBytes;

        

        if (![self usingCFStreamForTLS])

        {

            //恢复写source

            [self resumeWriteSource];

        }

    }

    

    // Check our results

    

    //判断是否完成

    BOOL done = NO;

    //判断已写大小

    if (bytesWritten > 0)

    {

        // Update total amount read for the current write

        //更新当前总共写的大小

        currentWrite->bytesDone += bytesWritten;

        LogVerbose(@"currentWrite->bytesDone = %lu", (unsigned long)currentWrite->bytesDone);

        

        // Is packet done?

        //判断当前写包是否写完

        done = (currentWrite->bytesDone == [currentWrite->buffer length]);

    }

    

    //如果完成了

    if (done)

    {

        //完成操作

        [self completeCurrentWrite];

        

        if (!error)

        {

            dispatch_async(socketQueue, ^{ @autoreleasepool{

                //开始下一次的读取任务

                [self maybeDequeueWrite];

            }});

        }

    }

    //未完成

    else

    {

        // We were unable to finish writing the data,

        // so we're waiting for another callback to notify us of available space in the lower-level output buffer.

        //如果不是等待 而且没有出错

        if (!waiting && !error)

        {

            // This would be the case if our write was able to accept some data, but not all of it.

            //这是我们写了一部分数据的情况。

            

            //去掉可接受数据的标记

            flags &= ~kSocketCanAcceptBytes;

            //再去等读source触发

            if (![self usingCFStreamForTLS])

            {

                [self resumeWriteSource];

            }

        }

        

        //如果已写大于0

        if (bytesWritten > 0)

        {

            // We're not done with the entire write, but we have written some bytes

            

            __strong id theDelegate = delegate;



            //调用写的进度代理

            if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:didWritePartialDataOfLength:tag:)])

            {

                long theWriteTag = currentWrite->tag;

                

                dispatch_async(delegateQueue, ^{ @autoreleasepool {

                    

                    [theDelegate socket:self didWritePartialDataOfLength:bytesWritten tag:theWriteTag];

                }});

            }

        }

    }

    

    // Check for errors

    //如果有错，则报错断开连接

    if (error)

    {

        [self closeWithError:[self errnoErrorWithReason:@"Error in write() function"]];

    }

    

    // Do not add any code here without first adding a return statement in the error case above.

}

//SSL读取数据最终方法

- (OSStatus)sslReadWithBuffer:(void *)buffer length:(size_t *)bufferLength

{

    //...

    ssize_t result = read(socketFD, buf, bytesToRead);

    //....

}