我想所有 Java 程序员都曾被这个 new String 的问题困扰过，这是一道高频的 Java 面试题，但可惜的是网上众说纷纭，竟然找不到标准的答案。有人说创建了 1 个对象，也有人说创建了 2 个对象，还有人说可能创建了 1 个或 2 个对象，但谁都没有拿出干掉对方的证据，这就让我们这帮吃瓜群众们陷入了两难之中，不知道到底该信谁得。

但是今天，老王就斗胆和大家聊聊这个话题，顺便再拿出点证据。

以目前的情况来看，关于 new String("xxx") 创建对象个数的答案有 3 种：

1. 有人说创建了 1 个对象；


2. 有人说创建了 2 个对象；


3. 有人说创建了 1 个或 2 个对象。

而出现多个答案的关键争议点在「字符串常量池」上，有的说 new 字符串的方式会在常量池创建一个字符串对象，有人说 new 字符串的时候并不会去字符串常量池创建对象，而是在调用 intern() 方法时，才会去字符串常量池检测并创建字符串。

那我们就先来说说这个「字符串常量池」。

字符串常量池

字符串的分配和其他的对象分配一样，需要耗费高昂的时间和空间为代价，如果需要大量频繁的创建字符串，会极大程度地影响程序的性能，因此 JVM 为了提高性能和减少内存开销引入了字符串常量池（Constant Pool Table）的概念。

字符串常量池相当于给字符串开辟一个常量池空间类似于缓存区，对于直接赋值的字符串（String s="xxx"）来说，在每次创建字符串时优先使用已经存在字符串常量池的字符串，如果字符串常量池没有相关的字符串，会先在字符串常量池中创建该字符串，然后将引用地址返回变量，如下图所示：

以上说法可以通过如下代码进行证明：

public class StringExample {

    public static void main(String[] args) {

        String s1 = "Java";

        String s2 = "Java";

        System.out.println(s1 == s2);

    }

}

以上程序的执行结果为：true，说明变量 s1 和变量 s2 指向的是同一个地址。

在这里我们顺便说一下字符串常量池的再不同 JDK 版本的变化。

这里，顺便送大家一份经典学习资料，我把大学和工作中用的经典电子书库（包含数据结构、操作系统、C++/C、网络经典、前端编程经典、Java相关、程序员认知、职场发展）、面试找工作的资料汇总都打包放在这。

戳这里直接获取:

计算机经典必读书单(含下载方式)

Java 入门到精通含面试最全资料包(含下载方式)

常量池的内存布局

从JDK 1.7 之后把永生代换成的元空间，把字符串常量池从方法区移到了 Java 堆上。

JDK 1.7 内存布局如下图所示：

JDK 1.8 内存布局如下图所示：

JDK 1.8 与 JDK 1.7 最大的区别是 JDK 1.8 将永久代取消，并设立了元空间。官方给的说明是由于永久代内存经常不够用或发生内存泄露，会爆出 java.lang.OutOfMemoryError: PermGen 的异常，所以把将永久区废弃而改用元空间了，改为了使用本地内存空间，官网解释详情：openjdk.java.net/jeps/122

答案解密

认为 new 方式创建了 1 个对象的人认为，new String 只是在堆上创建了一个对象，只有在使用 intern() 时才去常量池中查找并创建字符串。

认为 new 方式创建了 2 个对象的人认为，new String 会在堆上创建一个对象，并且在字符串常量池中也创建一个字符串。

认为 new 方式有可能创建 1 个或 2 个对象的人认为，new String 会先去常量池中判断有没有此字符串，如果有则只在堆上创建一个字符串并且指向常量池中的字符串，如果常量池中没有此字符串，则会创建 2 个对象，先在常量池中新建此字符串，然后把此引用返回给堆上的对象，如下图所示：

老王认为正确的答案：创建 1 个或者 2 个对象。

技术论证

解铃还须系铃人，回到问题的那个争议点上，new String 到底会不会在常量池中创建字符呢？我们通过反编译下面这段代码就可以得出正确的结论，代码如下：

public class StringExample {

    public static void main(String[] args) {

        String s1 = new String("javaer-wang");

        String s2 = "wang-javaer";

        String s3 = "wang-javaer";

    }

}

首先我们使用 javac StringExample.java 编译代码，然后我们再使用 javap -v StringExample 查看编译的结果，相关信息如下：

Classfile /Users/admin/github/blog-example/blog-example/src/main/java/com/example/StringExample.class

  Last modified 2020年4月16日; size 401 bytes

  SHA-256 checksum 89833a7365ef2930ac1bc3d7b88dcc5162da4b98996eaac397940d8997c94d8e

  Compiled from "StringExample.java"

public class com.example.StringExample

  minor version: 0

  major version: 58

  flags: (0x0021) ACC_PUBLIC, ACC_SUPER

  this_class: #16                         // com/example/StringExample

  super_class: #2                         // java/lang/Object

  interfaces: 0, fields: 0, methods: 2, attributes: 1

Constant pool:

   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V

   #2 = Class              #4             // java/lang/Object

   #3 = NameAndType        #5:#6          // "<init>":()V

   #4 = Utf8               java/lang/Object

   #5 = Utf8               <init>

   #6 = Utf8               ()V

   #7 = Class              #8             // java/lang/String

   #8 = Utf8               java/lang/String

   #9 = String             #10            // javaer-wang

  #10 = Utf8               javaer-wang

  #11 = Methodref          #7.#12         // java/lang/String."<init>":(Ljava/lang/String;)V

  #12 = NameAndType        #5:#13         // "<init>":(Ljava/lang/String;)V

  #13 = Utf8               (Ljava/lang/String;)V

  #14 = String             #15            // wang-javaer

  #15 = Utf8               wang-javaer

  #16 = Class              #17            // com/example/StringExample

  #17 = Utf8               com/example/StringExample

  #18 = Utf8               Code

  #19 = Utf8               LineNumberTable

  #20 = Utf8               main

  #21 = Utf8               ([Ljava/lang/String;)V

  #22 = Utf8               SourceFile

  #23 = Utf8               StringExample.java

{

  public com.example.StringExample();

    descriptor: ()V

    flags: (0x0001) ACC_PUBLIC

    Code:

      stack=1, locals=1, args_size=1

         0: aload_0

         1: invokespecial #1                  // Method java/lang/Object."<init>":()V

         4: return

      LineNumberTable:

        line 3: 0



  public static void main(java.lang.String[]);

    descriptor: ([Ljava/lang/String;)V

    flags: (0x0009) ACC_PUBLIC, ACC_STATIC

    Code:

      stack=3, locals=4, args_size=1

         0: new           #7                  // class java/lang/String

         3: dup

         4: ldc           #9                  // String javaer-wang

         6: invokespecial #11                 // Method java/lang/String."<init>":(Ljava/lang/String;)V

         9: astore_1

        10: ldc           #14                 // String wang-javaer

        12: astore_2

        13: ldc           #14                 // String wang-javaer

        15: astore_3

        16: return

      LineNumberTable:

        line 5: 0

        line 6: 10

        line 7: 13

        line 8: 16

}

SourceFile: "StringExample.java"

备注：以上代码的运行也编译环境为 jdk1.8.0_101。

其中 Constant pool 表示字符串常量池，我们在字符串编译期的字符串常量池中找到了我们 String s1 = new String("javaer-wang"); 定义的“javaer-wang”字符，在信息 #10 = Utf8 javaer-wang 可以看出，也就是在编译期 new 方式创建的字符串就会被放入到编译期的字符串常量池中，也就是说 new String 的方式会首先去判断字符串常量池，如果没有就会新建字符串那么就会创建 2 个对象，如果已经存在就只会在堆中创建一个对象指向字符串常量池中的字符串。

那么问题来了，以下这段代码的执行结果为 true 还是 false？

String s1 = new String("javaer-wang");

String s2 = new String("javaer-wang");

System.out.println(s1 == s2);

既然 new String 会在常量池中创建字符串，那么执行的结果就应该是 true 了。其实并不是，这里对比的变量 s1 和 s2 堆上地址，因为堆上的地址是不同的，所以结果一定是 false，如下图所示：

从图中可以看出 s1 和 s2 的引用一定是相同的，而 s3 和 s4 的引用是不同的，对应的程序代码如下：

public static void main(String[] args) {

    String s1 = "Java";

    String s2 = "Java";

    String s3 = new String("Java");

    String s4 = new String("Java");

    System.out.println(s1 == s2);

    System.out.println(s3 == s4);

}

程序执行的结果也符合预期：

true false

扩展知识

我们知道 String 是 final 修饰的，也就是说一定被赋值就不能被修改了。但编译器除了有字符串常量池的优化之外，还会对编译期可以确认的字符串进行优化，例如以下代码：

public static void main(String[] args) {

    String s1 = "abc";

    String s2 = "ab" + "c";

    String s3 = "a" + "b" + "c";

    System.out.println(s1 == s2);

    System.out.println(s1 == s3);

}

按照 String 不能被修改的思想来看，s2 应该会在字符串常量池创建两个字符串“ab”和“c”，s3 会创建三个字符串，他们的引用对比结果也一定是 false，但其实不是，他们的结果都是 true，这是编译器优化的功劳。

同样我们使用 javac StringExample.java 先编译代码，再使用 javap -c StringExample 命令查看编译的代码如下：

警告: 文件 ./StringExample.class 不包含类 StringExample

Compiled from "StringExample.java"

public class com.example.StringExample {

  public com.example.StringExample();

    Code:

       0: aload_0

       1: invokespecial #1                  // Method java/lang/Object."<init>":()V

       4: return



  public static void main(java.lang.String[]);

    Code:

       0: ldc           #7                  // String abc

       2: astore_1

       3: ldc           #7                  // String abc

       5: astore_2

       6: ldc           #7                  // String abc

       8: astore_3

       9: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;

      12: aload_1

      13: aload_2

      14: if_acmpne     21

      17: iconst_1

      18: goto          22

      21: iconst_0

      22: invokevirtual #15                 // Method java/io/PrintStream.println:(Z)V

      25: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;

      28: aload_1

      29: aload_3

      30: if_acmpne     37

      33: iconst_1

      34: goto          38

      37: iconst_0

      38: invokevirtual #15                 // Method java/io/PrintStream.println:(Z)V

      41: return

}

从 Code 3、6 可以看出字符串都被编译器优化成了字符串“abc”了。

总结

本文我们通过 javap -v XXX 的方式查看编译的代码发现 new String 首次会在字符串常量池中创建此字符串，那也就是说，通过 new 创建字符串的方式可能会创建 1 个或 2 个对象，如果常量池中已经存在此字符串只会在堆上创建一个变量，并指向字符串常量池中的值，如果字符串常量池中没有相关的字符，会先创建字符串在返回此字符串的引用给堆空间的变量。我们还将了字符串常量池在 JDK 1.7 和 JDK 1.8 的变化以及编译器对确定字符串的优化，希望能帮你正在的理解字符串的比较。

最后的话 原创不易，本篇近 3000 的文字描述，以及大量精美的图片，耗费了作者大概 5 个多小时的时间，写作是一件很酷，并且能帮助他人的事，作者希望一直能坚持下去。如果觉得有用，请随手点击一个赞吧，谢谢。

runtime怎么添加属性、方法等

• ivar表示成员变量
• class_addIvar

• class_addMethod
• class_addProperty

• class_addProtocol
• class_replaceProperty

是否可以把比较耗时的操作放在NSNotificationCenter中

• 首先必须明确通知在哪个线程中发出，那么处理接受到通知的方法也在这个线程中调用
• 如果在异步线程发的通知，那么可以执行比较耗时的操作；

• 如果在主线程发的通知，那么就不可以执行比较耗时的操作

runtime 如何实现 weak 属性

首先要搞清楚weak属性的特点

weak策略表明该属性定义了一种“非拥有关系” (nonowning relationship)。

为这种属性设置新值时，设置方法既不保留新值，也不释放旧值。此特质同assign类似;

然而在属性所指的对象遭到摧毁时，属性值也会清空(nil out)

那么runtime如何实现weak变量的自动置nil？

runtime对注册的类，会进行布局，会将 weak 对象放入一个 hash 表中。

用 weak 指向的对象内存地址作为 key，当此对象的引用计数为0的时候会调用对象的 dealloc 方法，

假设 weak 指向的对象内存地址是a，那么就会以a为key，在这个 weak hash表中搜索，找到所有以a为key的 weak 对象，从而设置为 nil。

weak属性需要在dealloc中置nil么

• 在ARC环境无论是强指针还是弱指针都无需在 dealloc 设置为 nil ， ARC 会自动帮我们处理
• 即便是编译器不帮我们做这些，weak也不需要在dealloc中置nil

• 在属性所指的对象遭到摧毁时，属性值也会清空

// 模拟下weak的setter方法，大致如下

- (void)setObject:(NSObject *)object

{

    objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN);

    [object cyl_runAtDealloc:^{

        _object = nil;

    }];

}

一个Objective-C对象如何进行内存布局？（考虑有父类的情况）

• 所有父类的成员变量和自己的成员变量都会存放在该对象所对应的存储空间中
• 父类的方法和自己的方法都会缓存在类对象的方法缓存中，类方法是缓存在元类对象中

• 每一个对象内部都有一个isa指针,指向他的类对象,类对象中存放着本对象的如下信息

• 对象方法列表
• 成员变量的列表

• 属性列表

• 每个 Objective-C 对象都有相同的结构，如下图所示

• 根类对象就是NSObject，它的super class指针指向nil
• 类对象既然称为对象，那它也是一个实例。类对象中也有一个isa指针指向它的元类(meta class)，即类对象是元类的实例。元类内部存放的是类方法列表，根元类的isa指针指向自己，superclass指针指向NSObject类

一个objc对象的isa的指针指向什么？有什么作用？

• 每一个对象内部都有一个isa指针，这个指针是指向它的真实类型
• 根据这个指针就能知道将来调用哪个类的方法

下面的代码输出什么？

@implementation Son : Father

- (id)init

{

    self = [super init];

    if (self) {

        NSLog(@"%@", NSStringFromClass([self class]));

        NSLog(@"%@", NSStringFromClass([super class]));

    }

    return self;

}

@end

• 答案：都输出 Son
• 这个题目主要是考察关于objc中对 self 和 super 的理解：

• self 是类的隐藏参数，指向当前调用方法的这个类的实例。而 super 本质是一个编译器标示符，和 self 是指向的同一个消息接受者
• 当使用 self 调用方法时，会从当前类的方法列表中开始找，如果没有，就从父类中再找；

• 而当使用 super时，则从父类的方法列表中开始找。然后调用父类的这个方法
• 调用[self class] 时，会转化成 objc_msgSend函数

id objc_msgSend(id self, SEL op, ...)

• 调用 [super class]时，会转化成 objc_msgSendSuper函数

id objc_msgSendSuper(struct objc_super *super, SEL op, ...)

• 第一个参数是 objc_super 这样一个结构体，其定义如下

struct objc_super {

__unsafe_unretained id receiver;

__unsafe_unretained Class super_class;

};

• 第一个成员是 receiver, 类似于上面的 objc_msgSend函数第一个参数self
• 第二个成员是记录当前类的父类是什么，告诉程序从父类中开始找方法，找到方法后，最后内部是使用 objc_msgSend(objc_super->receiver, @selector(class))去调用， 此时已经和[self class]调用相同了，故上述输出结果仍然返回 Son

• objc Runtime开源代码对- (Class)class方法的实现

    -(Class)class {

      return object_getClass(self);

    }

1. 基本数据结构

数组

数组是最基本的数据结构。在 Swift 中，以前 Objective-C 时代中将 NSMutableArray 和 NSArray 分开的做法，被统一到了唯一的数据结构 —— Array 。虽然看上去就一种数据结构，其实它的实现有三种：

• ContiguousArray：效率最高，元素分配在连续的内存上。如果数组是值类型（栈上操作），则 Swift 会自动调用 Array 的这种实现；如果注重效率，推荐声明这种类型，尤其是在大量元素是类时，这样做效果会很好。
• Array：会自动桥接到 Objective-C 中的 NSArray 上，如果是值类型，其性能与 ContiguousArray 无差别。

• ArraySlice：它不是一个新的数组，只是一个片段，在内存上与原数组享用同一区域。

下面是数组最基本的一些运用。

// 声明一个不可修改的数组

let nums = [1, 2, 3]

let nums = [Int](repeating: 0, count: 5)



// 声明一个可以修改的数组

var nums = [3, 1, 2]

// 增加一个元素

nums.append(4)

// 对原数组进行升序排序

nums.sort()

// 对原数组进行降序排序

nums.sort(by: >)

// 将原数组除了最后一个以外的所有元素赋值给另一个数组

// 注意：nums[0..<nums.count - 1] 返回的是 ArraySlice，不是 Array

let anotherNums = Array(nums[0 ..< nums.count - 1])

不要小看这些简单的操作：数组可以依靠它们实现更多的数据结构。Swift 虽然不像 Java 中有现成的队列和栈，但我们完全可以用数组配合最简单的操作实现这些数据结构，下面就是用数组实现栈的示例代码。

// 用数组实现栈

struct Stack<Element> {

  private var stack: [Element]

  var isEmpty: Bool { return stack.isEmpty }

  var peek: AnyObject? { return stack.last }



  init() {

    stack = [Element]()

  }



  mutating func push(_ element: Element) {

    stack.append(object)

  }



  mutating func pop() -> Element? {

    return stack.popLast()

  }

}



// 初始化一个栈

let stack = Stack<String>()

最后特别强调一个操作：reserveCapacity()。它用于为原数组预留空间，防止数组在增加和删除元素时反复申请内存空间或是创建新数组，特别适用于创建和 removeAll() 时候进行调用，为整段代码起到提高性能的作用。

字典和集合

字典和集合（这里专指HashSet）经常被使用的原因在于，查找数据的时间复杂度为 O(1)。

一般字典和集合要求它们的 Key 都必须遵守 Hashable 协议，Cocoa 中的基本数据类型都

满足这一点；自定义的 class 需要实现 Hashable，而又因为 Hashable 是对 Equable 的扩展，

所以还要重载 == 运算符。

下面是关于字典和集合的一些实用操作：

let primeNums: Set = [3, 5, 7, 11, 13]

let oddNums: Set = [1, 3, 5, 7, 9]



// 交集、并集、差集

let primeAndOddNum = primeNums.intersection(oddNums)

let primeOrOddNum = primeNums.union(oddNums)

let oddNotPrimNum = oddNums.subtracting(primeNums)



// 用字典和高阶函数计算字符串中每个字符的出现频率，结果 [“h”:1, “e”:1, “l”:2, “o”:1]

Dictionary("hello".map { ($0, 1) }, uniquingKeysWith: +)

集合和字典在实战中经常与数组配合使用，请看下面这道算法题：

这道题是传说中经典的 “2Sum”，我们已经有一个数组记为 nums，也有一个目标值记为 target，最后要返回一个 Bool 值。

最粗暴的方法就是每次选中一个数，然后遍历整个数组，判断是否有另一个数使两者之和为 target。这种做法时间复杂度为 O(n^2)。

采用集合可以优化时间复杂度。在遍历数组的过程中，用集合每次保存当前值。假如集合中已经有了目标值减去当前值，则证明在之前的遍历中一定有一个数与当前值之和等于目标值。这种做法时间复杂度为 O(n)，代码如下。

func twoSum(nums: [Int], _ target: Int) -> Bool {

  var set = Set<Int>()



  for num in nums {

    if set.contains(target - num) {

      return true

    }



    set.insert(num)

  }



  return false

}

如果把题目稍微修改下，变为

思路与上题基本类似，但是为了方便拿到序列号，我们采用字典，时间复杂度依然是 O(n)。代码如下。

func twoSum(nums: [Int], _ target: Int) -> [Int] {

  var dict = [Int: Int]()



  for (i, num) in nums.enumerated() {

    if let lastIndex = dict[target - num] {

      return [lastIndex, i]  

    } else {

      dict[num] = i

    }

  }



  fatalError("No valid output!")

}

字符串和字符

字符串在算法实战中极其常见。在 Swift 中，字符串不同于其他语言（包括 Objective-C），它是值类型而非引用类型，它是多个字符构成的序列（并非数组）。首先还是列举一下字符串的通常用法。

// 字符串和数字之间的转换

let str = "3"

let num = Int(str)

let number = 3

let string = String(num)



// 字符串长度

let len = str.count



// 访问字符串中的单个字符，时间复杂度为O(1)

let char = str[str.index(str.startIndex, offsetBy: n)]



// 修改字符串

str.remove(at: n)

str.append("c")

str += "hello world"



// 检测字符串是否是由数字构成

func isStrNum(str: String) -> Bool {

  return Int(str) != nil

}



// 将字符串按字母排序(不考虑大小写)

func sortStr(str: String) -> String {

  return String(str.sorted())

}



// 判断字符是否为字母

char.isLetter



// 判断字符是否为数字

char.isNumber



// 得到字符的 ASCII 数值

char.asciiValue

关于字符串，我们来一起看一道以前的 Google 面试题。

这道题目一看好简单，不就是反转字符串的翻版吗？这种方法有以下两个问题

• 每个单词长度不一样
• 空格需要特殊处理
  这样一来代码写起来会很繁琐而且容易出错。不如我们先实现一个字符串翻转的方法。

fileprivate func reverse<T>(_ chars: inout [T], _ start: Int, _ end: Int) {

  var start = start, end = end



  while start < end {

    swap(&chars, start, end)

    start += 1

    end -= 1

  }

}



fileprivate func swap<T>(_ chars: inout [T], _ p: Int, _ q: Int) {

  (chars[p], chars[q]) = (chars[q], chars[p])

}

有了这个方法，我们就可以实行下面两种字符串翻转：

• 整个字符串翻转，"the sky is blue" -> "eulb si yks eht"
• 每个单词作为一个字符串单独翻转，"eulb si yks eht" -> "blue is sky the"
  整体思路有了，我们就可以解决这道问题了

func reverseWords(s: String?) -> String? {

  guard let s = s else {

    return nil

  }



  var chars = Array(s), start = 0

  reverse(&chars, 0, chars.count - 1)



  for i in 0 ..< chars.count {

    if i == chars.count - 1 || chars[i + 1] == " " {

      reverse(&chars, start, i)

      start = i + 2

    }

  }



  return String(chars)

}

时间复杂度还是 O(n)，整体思路和代码简单很多。

总结

在 Swift 中，数组、字符串、集合以及字典是最基本的数据结构，但是围绕这些数据结构的问题层出不穷。而在日常开发中，它们使用起来也非常高效（栈上运行）和安全（无需顾虑线程问题），因为他们都是值类型。

2. 链表

本节我们一起来探讨用 Swift 如何实现链表以及链表相关的技巧。

基本概念

对于链表的概念，实在是基本概念太多，这里不做赘述。我们直接来实现链表节点。

class ListNode { 

  var val: Int 

  var next: ListNode? 



  init(_ val: Int) {

    self.val = val

  }

}

有了节点，就可以实现链表了。

class LinkedList {

  var head: ListNode?

  var tail: ListNode?



  // 头插法 

  func appendToHead(_ val: Int) {

    let node = ListNode(val)



    if let _ = head {

      node.next = head

    } else {

      tail = node

    }



    head = node

  }



  // 头插法

  func appendToTail(_ val: Int) {

    let node = ListNode(val)



    if let _ = tail {

      tail!.next = node

    } else {

      head = node

    }



    tail = node

  }

}

有了上面的基本操作，我们来看如何解决复杂的问题。

Dummy 节点和尾插法

话不多说，我们直接先来看下面一道题目。

直觉告诉我们，这题要先处理左边（比 x 小的节点），然后再处理右边（比 x 大的节点），最后再把左右两边拼起来。

思路有了，再把题目抽象一下，就是要实现这样一个函数：

func partition(_ head: ListNode?, _ x: Int) -> ListNode? {}

即我们有给定链表的头节点，有给定的x值，要求返回新链表的头结点。接下来我们要想：怎么处理左边？怎么处理右边？处理完后怎么拼接？

先来看怎么处理左边。我们不妨把这个题目先变简单一点：

给一个链表和一个值 x，要求只保留链表中所有小于 x 的值，原链表的节点顺序不能变。

例：1->5->3->2->4->2，给定x = 3。则我们要返回 1->2->2

我们只要采用尾插法，遍历链表，将小于 x 值的节点接入新的链表即可。代码如下：

func getLeftList(_ head: ListNode?, _ x: Int) -> ListNode? { 

  let dummy = ListNode(0)

  var pre = dummy, node = head



  while node != nil { 

    if node!.val < x { 

      pre.next = node 

      pre = node!

    }

    node = node!.next

  }



  // 防止构成环 

  pre.next = nil

  return dummy.next 

}

现在我们解决了左边，右边也是同样处理。接着只要让左边的尾节点指向右边的头结点即可。全部代码如下：

func partition(_ head: ListNode?, _ x: Int) -> ListNode? {

  // 引入Dummy节点 

  let prevDummy = ListNode(0), postDummy = ListNode(0) 

  var prev = prevDummy, post = postDummy 



  var node = head 



  // 用尾插法处理左边和右边 

  while node != nil { 

    if node!.val < x { 

      prev.next = node

      prev = node!

    } else { 

      post.next = node

      post = node!

    }    

    node = node!.next

  }



  // 防止构成环 

  post.next = nil

  // 左右拼接 

  prev.next = postDummy.next



  return prevDummy.next 

}

注意这句 post.next = nil，这是为了防止链表循环指向构成环，是必须的但是很容易忽略的一步。

刚才我们提到了环，那么怎么检测链表中是否有环存在呢？

快行指针

笔者理解快行指针，就是两个指针访问链表，一个在前一个在后，或者一个移动快另一个移动慢，这就是快行指针。来看一道简单的面试题：

答案是用两个指针同时访问链表，其中一个的速度是另一个的 2 倍，如果他们相等了，那么这个链表就有环了，这就是快行指针的实际使用。代码如下：

func hasCycle(_ head: ListNode?) -> Bool { 

  var slow = head

  var fast = head



  while fast != nil && fast!.next != nil { 

    slow = slow!.next

    fast = fast!.next!.next



    if slow === fast { 

      return true 

    }

  }



  return false 

}

再举一个快行指针一前一后的例子，看下面这道题。

解题思路依然是快行指针，这次两个指针移动速度相同。但是一开始，第一个指针（指向头结点之前）就落后第二个指针 n 个节点。接着两者同时移动，当第二个移动到尾节点时，第一个节点的下一个节点就是我们要删除的节点。代码如下：

func removeNthFromEnd(head: ListNode?, _ n: Int) -> ListNode? {

  guard let head = head else { 

    return nil 

  }



  let dummy = ListNode(0) 

  dummy.next = head

  var prev: ListNode? = dummy 

  var post: ListNode? = dummy 



  // 设置后一个节点初始位置 

  for _ in 0 ..< n { 

    if post == nil { 

      break 

    }

    post = post!.next

  }



  // 同时移动前后节点 

  while post != nil && post!.next != nil { 

    prev = prev!.next

    post = post!.next

  }



  // 删除节点 

  prev!.next = prev!.next!.next



  return dummy.next 

}

这里还用到了 Dummy 节点，因为有可能我们要删除的是头结点。

总结

这次我们用 Swift 实现了链表的基本结构，并且实战了链表的几个技巧。在结尾处，我还想强调一下 Swift 处理链表问题的两个细节问题：

• 一定要注意头结点可能就是 nil。所以给定链表，我们要看清楚 head 是不是 optional，在判断是不是要处理这种边界条件。
• 注意每个节点的 next 可能是 nil。如果不为 nil，请用"!"修饰变量。在赋值的时候，也请注意"!"将 optional 节点传给非 optional 节点的情况。

3. 栈和队列

这期我们来讨论一下栈和队列。在 Swift 中，没有内设的栈和队列，很多扩展库中使用 Generic Type 来实现栈或是队列。正规的做法使用链表来实现，这样可以保证加入和删除的时间复杂度是 O(1)。然而笔者觉得最实用的实现方法是使用数组，因为 Swift 没有现成的链表，而数组又有很多的 API 可以直接使用，非常方便。

基本概念

对于栈来说，我们需要了解以下几点：

• 栈是后进先出的结构。你可以理解成有好几个盘子要垒成一叠，哪个盘子最后叠上去，下次使用的时候它就最先被抽出去。
• 在 iOS 开发中，如果你要在你的 App 中添加撤销操作（比如删除图片，恢复删除图片），那么栈是首选数据结构

• 无论在面试还是写 App 中，只关注栈的这几个基本操作：push, pop, isEmpty, peek, size。

protocol Stack {

  /// 持有的元素类型

  associatedtype Element



  /// 是否为空

  var isEmpty: Bool { get }

  /// 栈的大小

  var size: Int { get }

  /// 栈顶元素

  var peek: Element? { get }



  /// 进栈

  mutating func push(_ newElement: Element)

  /// 出栈

  mutating func pop() -> Element?

}



struct IntegerStack: Stack {

  typealias Element = Int



  var isEmpty: Bool { return stack.isEmpty }

  var size: Int { return stack.count }

  var peek: Element? { return stack.last }



  private var stack = [Element]()



  mutating func push(_ newElement: Element) {

    stack.append(newElement)

  }



  mutating func pop() -> Element? {

    return stack.popLast()

  }

}

对于队列来说，我们需要了解以下几点：

• 队列是先进先出的结构。这个正好就像现实生活中排队买票，谁先来排队，谁先买到票。
• iOS 开发中多线程的 GCD 和 NSOperationQueue 就是基于队列实现的。

• 关于队列我们只关注这几个操作：enqueue, dequeue, isEmpty, peek, size。

protocol Queue {

  /// 持有的元素类型

  associatedtype Element



  /// 是否为空

  var isEmpty: Bool { get }

  /// 队列的大小

  var size: Int { get }

  /// 队首元素

  var peek: Element? { get }



  /// 入队

  mutating func enqueue(_ newElement: Element)

  /// 出队

  mutating func dequeue() -> Element?

}



struct IntegerQueue: Queue {

  typealias Element = Int



  var isEmpty: Bool { return left.isEmpty && right.isEmpty }

  var size: Int { return left.count + right.count }

  var peek: Element? { return left.isEmpty ? right.first : left.last }



  private var left = [Element]()

  private var right = [Element]()



  mutating func enqueue(_ newElement: Element) {

    right.append(newElement)

  }



  mutating func dequeue() -> Element? {

    if left.isEmpty {

      left = right.reversed()

      right.removeAll()

    }

    return left.popLast()

  }

}

栈和队列互相转化

处理栈和队列问题，最经典的一个思路就是使用两个栈/队列来解决问题。也就是说在原栈/队列的基础上，我们用一个协助栈/队列来帮助我们简化算法，这是一种空间换时间的思路。下面是示例代码：

// 用栈实现队列

struct MyQueue {

  var stackA: Stack

  var stackB: Stack



  var isEmpty: Bool {

    return stackA.isEmpty

  }



  var peek: Any? {

    get {

      shift()

      return stackB.peek

    }

  }



  var size: Int {

    get {

      return stackA.size + stackB.size

    }

  }



  init() {

    stackA = Stack()

    stackB = Stack()

  }



  func enqueue(object: Any) {

    stackA.push(object);

  }



  func dequeue() -> Any? {

    shift()

    return stackB.pop();

  }



  fileprivate func shift() {

    if stackB.isEmpty {

      while !stackA.isEmpty {

        stackB.push(stackA.pop()!);

      }

    }

  }

}



// 用队列实现栈

struct MyStack {

  var queueA: Queue

  var queueB: Queue



  init() {

    queueA = Queue()

    queueB = Queue()

  }



  var isEmpty: Bool {

    return queueA.isEmpty

  }



  var peek: Any? {

    get {

      if isEmpty {

        return nil

      }



      shift()

      let peekObj = queueA.peek

      queueB.enqueue(queueA.dequeue()!)

      swap()

      return peekObj

    }

  }



  var size: Int {

    return queueA.size

  }



  func push(object: Any) {

    queueA.enqueue(object)

  }



  func pop() -> Any? {

    if isEmpty {

      return nil

    }



    shift()

    let popObject = queueA.dequeue()

    swap()

    return popObject

  }



  private func shift() {

    while queueA.size > 1 {

      queueB.enqueue(queueA.dequeue()!)

    }

  }



  private func swap() {

    (queueA, queueB) = (queueB, queueA)

  }

}

上面两种实现方法都是使用两个相同的数据结构，然后将元素由其中一个转向另一个，从而形成一种完全不同的数据。

面试题实战

这是一道 Facebook 的面试题。这道题目其实就是平常在终端里面敲的 cd、pwd 等基本命令所得到的路径。

根据常识，我们知道以下规则：

• “. ” 代表当前路径。比如 “ /a/. ” 实际上就是 “/a”，无论输入多少个 “ . ” 都返回当前目录
• “..”代表上一级目录。比如 “/a/b/.. ” 实际上就是 “ /a”，也就是说先进入 “a” 目录，再进入其下的 “b” 目录，再返回 “b” 目录的上一层，也就是 “a” 目录。

然后针对以上信息，我们可以得出以下思路：

1. 首先输入是个 String，代表路径。输出要求也是 String, 同样代表路径；
2. 我们可以把 input 根据 “/” 符号去拆分，比如 "/a/b/./../d/" 就拆成了一个String数组["a", "b", ".", "..", "d"]；

3. 创立一个栈然后遍历拆分后的 String 数组，对于一般 String ，直接加入到栈中，对于 ".." 那我们就对栈做 pop 操作，其他情况不错处理。

思路有了，代码也就有了

func simplifyPath(path: String) -> String {

  // 用数组来实现栈的功能

  var pathStack = [String]()

  // 拆分原路径

  let paths = path.split(separatedBy: "/")



  for path in paths {

    // 对于 "." 我们直接跳过       

    guard path != "." else {

      continue

    }

    // 对于 ".." 我们使用pop操作       

    if path == ".."  {

      if (!pathStack.isEmpty) {

        pathStack.removeLast()

      }

    // 对于太注意空数组的特殊情况

    } else if path != "" {

      pathStack.append(path)

    }

  }

  // 将栈中的内容转化为优化后的新路径     

  return "/" + pathStack.joined(separator: "/")

}

上面代码除了完成了基本思路，还考虑了大量的特殊情况、异常情况。这也是硅谷面试考察的一个方面：面试者思路的严谨，对边界条件的充分考虑，以及代码的风格规范。

总结

在 Swift 中，栈和队列是比较特殊的数据结构，笔者认为最实用的实现和运用方法是利用数组。虽然它们本身比较抽象，却是很多复杂数据结构和 iOS 开发中的功能模块的基础。这也是一个工程师进阶之路理应熟练掌握的两种数据结构。

1.简历的准备

在面试中，我发现很多人都不能写好一份求职简历，所以我们首先谈谈如何写一份针对互联网公司的求职简历。

1.简洁的艺术

互联网公司和传统企业有着很大的区别，通常情况下，创新和效率是互联网公司比较追求的公司文化，所以体现在简历上，就是超过一页的简历通常会被认为不够专业。

更麻烦的是，多数超过一页的简历很可能在 HR 手中就被过滤掉了。因为 HR 每天会收到大量的简历，一般情况下每份简历在手中的停留时间也就 10 秒钟左右。而超过一页的简历会需要更多的时间去寻找简历中的有价值部分，对于 HR 来说，她更倾向于认为这种人通常是不靠谱的，因为写个简历都不懂行规，为什么还要给他面试机会呢?

那么我们应该如何精简简历呢? 简单说来就是一个字：删！

删掉不必要的自我介绍信息。很多求职者会将自己在学校所学的课程罗列上去，例如：C 语言，数据结构，数学分析⋯⋯好家伙，一写就是几十门，还放在简历的最上面，就怕面试官看不见。对于这类信息，一个字：删！面试官不关心你上了哪些课程，而且在全中国，大家上的课程也都大同小异，所以没必要写出来。

删除不必要的工作或实习、实践经历。如果你找一份程序员的工作，那么你参加了奥运会的志愿者活动，并且拿到了奖励或者你参加学校的辩论队，获得了最佳辩手这些经历通常是不相关的。诸如此类的还有你帮导师代课，讲了和工作不相关的某某专业课，或者你在学生会工作等等。删除不相关的工作、实习或实践内容可以保证你的简历干净。当然，如果你实在没得可写，比如你是应届生，一点实习经历都没有，那可以适当写一两条，保证你能写够一页的简历，但是那两条也要注意是强调你的团队合作能力或者执行力之类的技能，因为这些才是面试官感兴趣的。

删除不必要的证书。最多写个 4、6 级的证书，什么教师资格证，中高级程序员证，还有国内的各种什么认证，都是没有人关心的。

删除不必要的细节。作为 iOS 开发的面试官，很多求职者在介绍自己的 iOS 项目经历的时候，介绍了这个工程用的工作环境是 Mac OS，使用的机器是 Mac Mini，编译器是 Xcode，能够运行在 iOS 什么版本的环境。还有一些人，把这个项目用到的开源库都写上啦，什么 AFNetworking, CocoaPods 啥的。这些其实都不是重点，请删掉。后面我会讲，你应该如何介绍你的 iOS 项目经历。

自我评价，这个部分是应届生最喜欢写的，各种有没有的优点都写上，例如：

这些内容在面试的时候不太好考查，都可以删掉。通常如果有 HR 面的话，HR 自然会考查一些你的沟通，抗压，性格等软实力。

我相信，不管你是刚毕业的学生，还是工作十年的老手，你都可以把你的简历精简到一页 A4 纸上。记住，简洁是一种美，一种效率，也是一种艺术。

2.重要的信息写在最前面

将你觉得最吸引人的地方写在最前面。如果你有牛逼公司的实习，那就把实习经历写在最前面，如果你在一个牛逼的实验室里面做科研，就把研究成果和论文写出来，如果你有获得过比较牛逼的比赛名次（例如 Google code jam, ACM 比赛之类），写上绝对吸引眼球。

所以，每个人的简历的介绍顺序应该都是不一样的，不要在网上下载一个模板，然后就一项一项地填：教育经历，实习经历，得奖经历，个人爱好，这样的简历毫无吸引力，也无法突出你的特点。

除了你的个人特点是重要信息外，你的手机号、邮箱、毕业院校、专业以及毕业时间这些也都是非常重要的，一定要写在简历最上面。

3.不要简单地罗列工作经历

不要简单地说你开发了某某 iOS 客户端。这样简单的罗列你的作品集并不能让面试官很好地了解你的能力，当然，真正在面试时面试官可能会仔细询问，但是一份好的简历，应该省去一些面试官额外询问你的工作细节的时间。

具体的做法是：详细的描述你对于某某 iOS 客户端的贡献。主要包括：你参与了多少比例功能的开发? 你解决了哪些开发中的有挑战的问题? 你是不是技术负责人?

而且，通过你反思这些贡献，你也可以达到自我审视，如果你发现这个项目你根本什么有价值的贡献都没做，就打了打酱油，那你最好不要写在简历上，否则当面试官在面试时问起时，你会很难回答，最终让他发现你的这个项目经历根本一文不值时，肯定会给一个负面的印象。

4.不要写任何虚假或夸大的信息

刚刚毕业的学生都喜欢写精通 Java，精通 C/C++，其实代码可能写了不到 1 万行。我觉得你要精通某个语言，至少得写 50 万行这个语言的代码才行，而且要对语言的各种内部机制和原理有了解。那些宣称精通 Java 的同学，连 Java 如何做内存回收，如何做泛型支持，如何做自动 boxing 和 unboxing 的都不知道，真不知道为什么要写精通二字。

任何夸大或虚假的信息，在面试时被发现，会造成极差的面试印象。所以你如果对某个知识一知半解，要么就写 “使用过” 某某，要么就干脆不写。如果你简历实在太单薄，没办法写上了一些自己打酱油的项目，被问起来怎么办? 请看看下面的故事：

这倒是一个不错的办法，对于一个没有项目经验，但是聪明并且数据结构和算法基础知识扎实的应届生，其实我们是非常愿意培养的。很多人以为公司面试是看经验，希望招进来就能干活，其实不是的，至少我们现在以及我以前在网易招人，面试的是对方的潜力，潜力越大，可塑性好，未来进步得也更快；一些资质平庸，却经验稍微丰富一点的开发者，相比聪明好学的面试者，后劲是不足的。

总之，不要写任何虚假或夸大的信息，即使你最终骗得过面试官，进了某公司，如果能力不够，在最初的试用期内，也很可能因为能力不足而被开掉。

5.留下更多信息

刚刚说到，简历最好写够一张 A4 纸即可，那么你如果想留下更多可供面试官参考的信息怎么办呢？其实你可以附上更多的参考链接，这样如果面试官对你感兴趣，自然会仔细去查阅这些链接。对于 iOS 面试来说，GitHub 上面的开源项目地址、博客地址都是不错的参考信息。如果你在微博上也频繁讨论技术，也可以附上微博地址。

我特别建议大家如果有精力，可以好好维护一下自己的博客或者 GitHub 上的开源代码。因为如果你打算把这些写到简历上，让面试官去上面仔细评价你的水平，你就应该对上面的内容做到足够认真的准备。否则，本来面试完面试官还挺感兴趣的，结果一看你的博客和开源代码，评价立刻降低，就得不偿失了。

6.不要附加任何可能带来负面印象的信息

任何与招聘工作无关的东西，尽量不要提。有些信息提了可能有加分，也可能有减分，取决于具体的面试官。下面我罗列一下我认为是减分的信息。

1）个人照片

不要在简历中附加个人照片。个人长相属于与工作能力不相关的信息，也许你觉得你长得很帅，那你怎么知道你的样子不和面试官的情敌长得一样? 也许你长得很漂亮，那么你怎么知道 HR 是否被你长得一样的小三把男朋友抢了? 我说得有点极端，那人们对于长相的评价标准确实千差万别，萝卜青菜各有所爱，加上可能有一些潜在的极端情况，所以没必要附加这部分信息。这属于加了可能有加分，也可能有减分的情况。

2）有风险的爱好

不要写各种奇怪的爱好。喜欢打游戏、抽烟、喝酒，这类可能带来负面印象的爱好最好不要写。的确有些公司会有这种一起联机玩游戏或者喝酒的文化，不过除非你明确清楚对于目标公司，写上会是加分项，否则还是不写为妙。

3）使用 PDF 格式

不要使用 Word 格式的简历，要使用 PDF 的格式。我在招 iOS 程序员时，好多人的简历都是 Word 格式的，我都怀疑这些人是否有 Mac 电脑。因为 Mac 下的 office 那么难用，公司好多人机器上都没有 Mac 版 office。我真怀疑这些人真是的想投简历么? PDF 格式的简历通常能展现出简历的专业性。

4）QQ号码邮箱

不要使用 QQ 号开头的 QQ 邮箱，例如 12345@qq.com ，邮箱的事情我之前简单说过，有些人很在乎这个，有些人觉得无所谓，我个人对用数字开头的 QQ 邮箱的求职者不会有加分，但是对使用 Gmail 邮箱的求职者有加分。因为这涉及到个人的工作效率，使用 Gmail 的人通常会使用邮件组，过滤器，IMAP 协议，标签，这些都有助于提高工作效率。如果你非要使用 QQ 邮箱，也应该申请一个有意义的邮箱名，例如 tangqiaoboy@qq.com 。

7.职业培训信息

不要写参加过某某培训公司的 iOS 培训，特别是那种一、两个月的速成培训。这对于我和身边很多面试官来说，绝对是负分。

这个道理似乎有点奇怪，因为我们从小都是由老师教授新知识的。我自己也实验过，掌握同样的高中课本上的知识，自己自学的速度通常比老师讲授的速度要慢一倍的时间。即一个知识点，如果你自己要看 2 小时的书才能理解的话，有好的老师给你讲解的话，只需要一个小时就够了。所以，我一直希望在学习各种东西的时候都能去听一些课程，因为我认为这样节省了我学习的时间。

但是这个道理在程序员这个领域行不通，为什么这么说呢？原因有两点：

1. 计算机编程相关的知识更新速度很快。同时，国内的 IT 类资料的翻译质量相当差，原创的优秀书籍也很少。所以，我们通常需要靠阅读英文才能掌握最新的资料。拿 iOS 来说，每年 WWDC 的资料都非常重要，而这些内容涉及版权，国内培训机构很难快速整理成教材。
2. 计算机编程知识需要较多的专业知识积累和实践。学校的老师更多只能做入门性的教学工作。
   如果一个培训机构有一个老师，他强到能够通过自己做一些项目来积累很多专业知识和实践，并且不断地从国外资料上学习最新的技术。那么这个人在企业里面会比在国内的培训机构更有施展自己能力的空间。国内的培训机构因为受众面的原因，基本上还是培养那种初级的程序员新手，所以对老师的新技术学习速度要求不会那么高，自然老师也不会花那么时间在新技术研究上。但是企业就不一样了，企业需要不停地利用新技术来增强自己的产品竞争力，所以对于 IT 企业来说，产品的竞争就是人才的竞争，所以给优秀的人能够开出很高的薪水。
   所以，我们不能期望从 IT 类培训机构中学习到最新的技术，一切只能通过我们自学。当然，自学之后在同行之间相互交流，对于我们的技术成长也是很有用的。小结
   
   
   

上图是本节讨论的总结，在简历准备上，我们需要考虑简历的简洁性等各种注意事项。

2.寻找机会

1.寻找内推机会

其实，最好的面试机会都不是公开渠道的。好的机会都隐藏于各种内部推荐之中。通过内部推荐，你可以更加了解目标工作的团队和内容，另外内部推荐通常也可以跳过简历筛选环节，直接参加笔试或面试。我所在的猿辅导公司为内推设立了非常高的奖金激励，因为我们发现，综合各种渠道来看，内推的渠道的人才的简历质量最高，面试通过率最高的。

所以，如果你是学生，找找你在各大公司的师兄师姐内推；如果你已经工作了，你可以找前同事或者通过一些社交活动认识的技术同行内推。

大部分情况下，如果在目标公司你完全没有认识的人，你也可以找机会来认识几个。比如你可以通过微博、知乎、Twitter、GitHub 来结交新的朋友。然后双方聊天如果愉快的话，我相信内推这种举手之劳的事情对方不会拒绝的。

如果你都工作 5 年以上，还是没有建立足够好的社交圈子帮助你内推，那可能你需要做很多的社交活动交一些朋友。

2.其它常见的渠道

内推之外，其它的公开招聘渠道通常都要差一些。现在也有一些专门针对互联网行业的招聘网站，例如拉勾、100offer 这类，它们也是不错的渠道，可以找到相关的招聘信息。

但因为这类公开渠道简历投放数量巨大，通常 HR 那边就会比较严格地筛选简历，拿我们公司来说，通常在这些渠道看 20 份简历，才会有 1 份愿意约面的简历。而且 HR 会只挑比较好的学校或者公司的候选人，也不排除还有例如笔试这种更多的面试流程。但是面试经验都是慢慢积累的，建议你也可以尝试这些渠道。

3.面试流程

1.流程简述

就我所知，大部分的 iOS 公司的面试流程都大同小异。我们先简述一下大体的流程，然后再详细讨论。

在面试的刚开始，面试官通常会要求你做一个简短的自我介绍。然后面试官可能会和你聊聊你过去的实习项目或者工作内容。接着面试官可能会问你一些具体的技术问题，有经验的面试官会尽量找一些和你过去工作相关的技术问题。最后，有些公司会选择让你当场写写代码，Facebook 会让你在白板上写代码，国内的更多是让你在 A4 纸上写。有一些公司也会问一些系统设计方面的问题，考查你的整体架构能力。在面试快要结束时，通常面试官还会问你有没有别的什么问题。

以上这些流程，不同公司可能会跳过某些环节。比如有一些公司就不会考察当场在白板或 A4 纸上写代码。有些公司可能跳过问简历的环节直接写代码，特别是校园招聘的时候，因为应届生通常项目经验较少。面试流程图如下所示：

2.自我介绍

自我介绍通常是面试中最简单、最好准备的环节。

一个好的自我介绍应该结合公司的招聘职位来做定制。比如公司有硬件的背景，就应该介绍一下在硬件上的经验或者兴趣；公司如果注重算法能力，则介绍自己的算法练习；公司如果注重团队合作，那么你介绍一下自己的社会活动都是可以的。

一个好的自我介绍应该提前写下来，并且背熟。因为候选人通常的紧张感都是来自于面试刚开始的几分钟，如果你刚开始的几分钟讲的结结巴巴，那么这种负面情绪会加剧你面试时的紧张感，从而影响你正常发挥。如果你提前把自我介绍准备得特别流利，那么开始几分钟的紧张感过去之后，你很可能就会很快进入状态，而忘记紧张这个事情了。

即使做到了以上这些仍然是不够的，候选者常见的问题还包括：

• 太简短
• 没有重点

• 太拖沓
• 不熟练

我们在展开讨论上面这些问题之前，我们可以站在面试官的立场考虑一下：如果你是面试官，你为什么要让候选人做自我介绍？你希望在自我介绍环节考察哪些信息？

在我看来，自我介绍环节相当重要，因为：

• 首先它考察了候选人的表达能力。大部分的程序员表达能力可能都一般，但是如果连自我介绍都说不清楚，通常就说明表达沟通能力稍微有点问题了。面试官通过这个环节可以初步考察到候选人的表达能力。
• 它同样也考察了候选人对于面试的重视程度。一般情况下，表达再差的程序员，也可以通过事先拟稿的方式，把自我介绍内容背下来。如果一个人自我介绍太差，说明他不但表达差，而且不重视这次面试。

• 最后，自我介绍对之后的面试环节起到了支撑作用。因为自我介绍中通常会涉及自己的项目经历，自己擅长的技术等。这些都很可能吸引面试官追问下去。好的候选人会通过自我介绍 “引导” 面试官问到自己擅长的领域知识。如果面试官最后对问题答案很满意，通过面试的几率就会大大增加。

所以我如果是面试官，我希望能得到一个清晰流畅的自我介绍。下面我们来看看候选人在面试中的常见问题。

1）太简短

一个好的自我介绍大概是 3～5 分钟。过短的自我介绍没法让面试官了解你的大致情况，也不足以看出来你的基本表达能力。

如果你发现自己没法说出足够时间的自我介绍。可以考虑在介绍中加入：自己的简单的求学经历，项目经历，项目中有亮点的地方，参与或研究过的一些开源项目，写过的博客，其它兴趣爱好，自己对新工作的期望和目标公司的理解。

我相信每个人经过准备，都可以做到一个 5 分钟长度的自我介绍。

2）没有重点

突破了时间的问题，接下来就需要掌握介绍的重点。通常一个技术面试，技术相关的介绍才是重点。所以求学经历，兴趣爱好之类的内容可以简单提到即可。

对于一个工作过的开发者，你过去做的项目哪个最有挑战，最能展示出你的水平其实自己应该是最清楚的。所以大家可以花时间把这个内容稍微强调一下。

当然你也没必要介绍得太细致，面试官如果感兴趣，自然会在之后的面试过程中和你讨论。

3）太拖沓

有些工作了几年的人，做过的项目差不多有个 3～5 个，面试的时候就忍不住一个一个说。单不说这么多项目在自我介绍环节不够介绍。就是之后的详细讨论环节，面试官也不可能讨论完你的所有项目经历。

所以千万不要做这种 “罗列经历” 的事情，你要做的就是挑一个或者最多两个项目，介绍一下项目大致的背景和你解决的主要问题即可。至于具体的解决过程，可以不必介绍。

4）不熟练

即便你的内容完全合适，时间长度完全合理，你也需要保证一个流利的陈述过程。适当在面试前多排练几次，所有人都可以做到一个流利的自我介绍。

还有一点非常神奇，就是一个人在做一件事情的时候，通常都是开始的前以及刚开始几分钟特别紧张。比如考试，演讲或者面试，通常这几分钟之后，人们进入 “状态” 了，就会忘记紧张了。

将自己的自我介绍背下来，可以保证一个流利顺畅的面试开局，这可以极大舒缓候选人的紧张情绪。相反，一开始自我介绍就结结巴巴，会加剧候选人的紧张情绪，而技术面试如果不能冷静的话，是很难在写代码环节保证逻辑清晰正确的。

所以，请大家务必把这个小环节重视起来，做出一个完美的开局。

3.项目介绍

自我介绍之后，就轮到讨论更加具体的内容环节了，通常面试官都会根据自我介绍或者你的简历，选一个他感兴趣的项目来详细讨论。

这个时候，大家务必需要提前整理出自己参与的项目的具体挑战，以及自己做得比较好的地方。切忌不要说：“这个项目很简单，没什么挑战，那个项目也很简单，没什么好说的”。再简单的事情，都可以做到极致的，就看你有没有一个追求完美的心。

比如你的项目可能在你看来就是摆放几个 iOS 控件。但是，这些控件各自有什么使用上的技巧，有什么优化技巧？其实如果专心研究，还是有很多可以学习的。拿 UITableView 来说，一个人如果能够做到把它的滑动流程度优化好，是非常不容易的。这里面涉及网络资源的异步加载、图片资源的缓存、后台线程的渲染、CALayer 层的优化等等。

这其实也要求我们做工作要精益求精，不求甚解。所以一场成功的面试最最本质上，看得还是自己平时的积累。如果自己平时只是糊弄工作，那么面试时就很容易被看穿。

在这一点上，我奉劝大家在自己的简历上一定要老实。不要在建简历上弄虚作假，把自己没有做过的项目写在里面。

顺便我在这里也教一下大家如何面试别人。如果你是面试官，考察简历的真假最简单的方法就是问细节。一个项目的细节如果问得很深入，候选人有没有做过很容易可以看出来。

举个例子，如果候选人说他在某公司就职期间做了某某项目。你就可以问他：

• 这个工作具体的产品需求是什么样的？
• 大概做了多长时间？

• 整体的软件架构是什么样的？
• 涉及哪些人合作？几个开发和测试？

• 项目的时间排期是怎么定的？
• 你主要负责的部分和合作的人？

• 项目进行中有没有遇到什么问题？
• 这个项目最后最大的收获是什么？遗憾是什么？

• 项目最困难的一个需求是什么？具体什么实现的？

面试官如果做过类似项目，还可以问问通常这个项目常见的坑，看看候选人是什么解决的。

4.写代码

编程能力，说到底还是一个实践的能力，所以说大部分公司都会考察当场写代码。我面试过上百人，见到过很多候选人在自我介绍和项目讨论时都滔滔不绝，侃侃而谈，感觉非常好。但是一到写代码环节就怂了，要么写出来各种逻辑问题和细节问题没处理好，要么就是根本写不出来。

由于人最终招进来就是干活写代码的，所以如果候选人当场写代码表现很差的话，基本上面试就挂掉了。

程序员这个行业，说到底就是一个翻译的工作，把产品经理的产品文档和设计师的 UI 设计，翻译成计算机能够理解的形式，这个形式通常就是一行一行的源码。

当面试官考察你写代码的时候，他其实在考察：

• 你对语言的熟悉程度。如果候选人连常见的变量定义和系统函数都不熟悉，说明他肯定经验还是非常欠缺。
• 你对逻辑的处理能力。产品经理关注的是用户场景和核心需求，而程序员关注的是逻辑边界和异常情况。程序的 bug 往往就是边界和特殊情况没有处理好。虽然说写出没有 bug 的程序几乎不可能，但是逻辑清晰的程序员能够把思路理清楚，减少 bug 发生的概率。

• 设计和架构能力。好的代码需要保证易于维护和修改。这里面涉及很多知识，从简单的 “单一职责” 原则，到复杂的 “好的组合优于继承” 原则，其中设计模式相关的知识最多。写代码的时候多少还是能够看出这方面的能力。另外有些公司，例如 Facebook，会有专门的系统设计（System Design）面试环节，专注于考察设计能力。

5.系统设计

有一些公司喜欢考查一些系统设计的问题，简单来说，就是让你解决一个具体的业务需求，看看你是否能够将业务逻辑梳理清楚，并且拆解成各个模块，设计好模块间的关系。举几个例子，面试官可能让你：

• 设计一个类似微博的信息流应用。
• 设计一个本地数据缓存架构。

• 设计一个埋点分析系统。
• 设计一个直播答题系统。

• 设计一个多端的数据同步系统。
• 设计一个动态补丁的方案。

这些系统的设计都非常考查一个人知识的全面性。通常情况下，如果一个人只知道 iOS 开发的知识，是很难做出相关的设计的。为了能够解决这些系统设计题，我们首先需要有足够的知识面，适度了解一下 Android 端、Web 端以及服务器端的各种技术方案背后的原理。你可以不写别的平台的代码，但是一定要理解它们在技术上能做到什么，不能做到什么。你也不必过于担心，面试官在考查的时候，还是会重点考查 iOS 相关的部分。

我们将在下一小节，展开讨论如何准备和回答系统设计题。

6.提问

提问环节通常在面试结束前，取决于前面的部分是否按时结束，有些时候前面的环节占用了太多时间，也可能没有提问环节了。在后面的章节，我们会展开讨论一下如何提问。

2.死锁的原因

3.介绍虚拟内存

4.常见排序算法，排序算法稳定的意思，快排的复杂度什么时候退化，基本有序用什么

5.TCP可靠性

6.http+https

算法

Z字遍历二叉树，归并排序

后面说因为我不会java和安卓，会帮忙转推到iOS的组（面试的这个组是java客户端）

腾讯PCG iOS一面（1h）

1.聊项目，聊了很久，一开始没有意会面试官想知道什么，最后说是想知道我这么做比起从客户端自己去实现的区别（这个项目是小米实习时候的项目，做的浏览器内核，页面翻译功能，

基本每一个客户端应用都会有一个类似于浏览器内核的东西，对页面进行渲染，呈现，也可以叫渲染引擎，学前端的肯定知道这个东西，他主要是解释html，css，js的。

我做的这个页面翻译功能可以不经过内核直接由客户端工程师用安卓客户端实现整套逻辑，所以这么问我了）

2.实现string类，实现构造，析构，里面加一个kmp

3.介绍智能指针，智能指针保存引用计数的变量存在哪里，引用计数是否线程安全

4.算法：两个只有0和1的数字序列，只能0  1互换，每次当前位互换都会使后面的也换掉（比如，011000，换第二位，成了000111），计算从一个变到另一个需要几步操作。

5.https，验证公钥有效的方法，为什么非对称对称并用

腾讯PCG iOS二面 （40min）

1.算法：

合并排序链表

2.static关键字的作用

3.const关键字的作用

4.成员初始化列表的作用

5.指针和引用的区别

6.又是很久的项目，怎么去学习浏览器内核（chromium内核的代码量有几千万行，而且写的很难懂，用了大量的设计模式，作为一个菜鸡真的很痛苦）

，怎么去调试项目中遇到的问题（这里主要是一个ipc接口没用对），你觉得人家google的是怎么去调的，你为什么和人家做法不一样？

腾讯PCG iOS三面（2h）

1.还是聊了很久项目（已经麻了，做过的东西一定要能说出口）

2.浏览器呈现一个页面经过了哪几步（DOM树，layoutobject树，browser进程绘制）

3.C++多态的实现

4.DNS解析，递归与迭代的区别

5.chromium用的渲染引擎是什么，这个渲染引擎对应的js解释引擎是什么（blink和v8，前几个问题表现有些差，这会在问一些1+1的问题了，哭）

6.平时怎么学习技术的，看过哪些书，有过哪些输出（我把实习时写的项目wiki给截了个图）

然后反问，打开牛客让我写了个代码，他不知道去哪了，我自己在这写，写了一个多钟头，你以为这是道很难的题吗？no，是我那会确实很菜，哈哈

题目是，给一个字符串插入最少的字符，让这个字符串变成回文

腾讯hr面 （40min）

1.有哪些缺点

2.投了哪些，为什么不投阿里头条（实习忙的我面你们都要面不过来了）

3.如何选择offer

4.家是哪的，为什么愿意去深圳

每一个问题都不是简单的答完就完事了，他会跟着问很多

然后反问时我问问题给我说了20分钟

抖音 iOS一面 （1h20min）

上来闲聊了一会

1.算法：

字符串大数相加

写完问我有没有需要优化的地方（内存可以优化一下）

2.string类赋值运算符是深拷贝还是浅拷贝

3.算法：

根据前序和中序输出二叉树的后续遍历

4.C++ deque底层，deque有没有重载[]

5.为什么要内存对齐，内存对齐的规则

6.算法：

上台阶，加了个条件，这次上两级，下次就只能上一级

7.反问+闲聊

抖音 iOS二面 （1h）

十分钟不到的项目

1.进程和线程的区别和联系

2.线程共享哪些内存空间

3.进程内存模型

4.进程间通信方式

5. 虚拟内存，为什么要有虚拟内存，虚拟内存如何映射到物理内存

后面还挖了一些操作系统的问题，记不太清了

5.TCP为什么四次挥手

6.https客户端验证公钥的方法

7.描述并写一下LRU

8.说一下怎么学chromium的，怎么上手项目的

9.C++内存分配，写了一段代码，看里面申请了哪部分内存，申请了多少，代码有什么问题

10.代码里面的内存泄漏怎么解决，智能指针的引用计数怎么实现，那些成员函数会影响到引用计数

11.代码里面有无线程安全问题，线程安全问题的是否会导致程序崩溃，为什么

12.C++虚函数的实现原理，纯虚函数

13.C++引用和指针的区别，引用能否为空

抖音 iOS三面 （1h）

1.lambda表达式，它应用表达式外变量的方式和区别

2.decltype的作用，他和auto有什么不同

3.C++的所有智能指针介绍一下

4.C++thread里面的锁，条件变量，讲一下怎么用他们实现生产者消费者模型

5.C++20有什么新东西（我就知道支持了协程，然后他说我就想问你协程，然后我说，其实我具体不了解，丢人了）

6.右值引用是什么，移动构造函数有什么好处

7.操作系统微内核宏内核（懵）

8.进程间通信的共享内存，如何保证安全性（信号量），结合epoll讲讲共享内存

9.TCP协议切片（懵）

10.TCP协议的流量控制机制，滑窗为0时，怎么办

11.算法

合并K个排序链表

12.合并K个排序数组，讲思路，我说归并，他说，传输参数是数组，不是vector，你如何判断数组的大小

1、NSArray与NSSet的区别？

• NSArray内存中存储地址连续，而NSSet不连续
• NSSet效率高，内部使用hash查找；NSArray查找需要遍历

• NSSet通过anyObject访问元素，NSArray通过下标访问

2、NSHashTable与NSMapTable？

• NSHashTable是NSSet的通用版本，对元素弱引用，可变类型；可以在访问成员时copy
• NSMapTable是NSDictionary的通用版本，对元素弱引用，可变类型；可以在访问成员时copy

(注：NSHashTable与NSSet的区别：NSHashTable可以通过option设置元素弱引用/copyin，只有可变类型。但是添加对象的时候NSHashTable耗费时间是NSSet的两倍。

NSMapTable与NSDictionary的区别：同上)

3、属性关键字assign、retain、weak、copy

• assign：用于基本数据类型和结构体。如果修饰对象的话，当销毁时，属性值不会自动置nil，可能造成野指针。
• weak：对象引用计数为0时，属性值也会自动置nil

• retain：强引用类型，ARC下相当于strong，但block不能用retain修饰，因为等同于assign不安全。
• strong：强引用类型，修饰block时相当于copy。

4、weak属性如何自动置nil的？

• Runtime会对weak属性进行内存布局，构建hash表：以weak属性对象内存地址为key，weak属性值(weak自身地址)为value。当对象引用计数为0 dealloc时，会将weak属性值自动置nil。

5、Block的循环引用、内部修改外部变量、三种block

• block强引用self，self强引用block
• 内部修改外部变量：block不允许修改外部变量的值，这里的外部变量指的是栈中指针的内存地址。__block的作用是只要观察到变量被block使用，就将外部变量在栈中的内存地址放到堆中。

• 三种block：NSGlobalBlack(全局)、NSStackBlock(栈block)、NSMallocBlock(堆block)

6、KVO底层实现原理？手动触发KVO？swift如何实现KVO？

• KVO原理：当观察一个对象时，runtime会动态创建继承自该对象的类，并重写被观察对象的setter方法，重写的setter方法会负责在调用原setter方法前后通知所有观察对象值得更改，最后会把该对象的isa指针指向这个创建的子类，对象就变成子类的实例。
• 如何手动触发KVO：在setter方法里，手动实现NSObject两个方法：willChangeValueForKey、didChangeValueForKey

• swift的kvo：继承自NSObject的类，或者直接willset/didset实现。

7、categroy为什么不能添加属性？怎么实现添加？与Extension的区别？category覆盖原类方法？多个category调用顺序

• Runtime初始化时categroy的内存布局已经确定，没有ivar，所以默认不能添加属性。
• 使用runtime的关联对象，并重写setter和getter方法。

• Extenstion编译期创建，可以添加成员变量ivar，一般用作隐藏类的信息。必须要有类的源码才可以添加，如NSString就不能创建Extension。
• category方法会在runtime初始化的时候copy到原来前面，调用分类方法的时候直接返回，不再调用原类。如何保持原类也调用(https://www.jianshu.com/p/40e28c9f9da5)。

• 多个category的调用顺序按照：Build Phases ->Complie Source 中的编译顺序。

8、load方法和initialize方法的异同。——主要说一下执行时间，各自用途，没实现子类的方法会不会调用父类的？

load initialize 调用时机 app启动后，runtime初始化的时候 第一个方法调用前调用 调用顺序 父类->本类->分类 父类->本类(如果有分类直接调用分类，本类不会调用) 没实现子类的方法会不会调用父类的 否 是 是否沿用父类实现 否 是

9、对 runtime 的理解。——主要是方法调用时如何查找缓存，如何找到方法，找不到方法时怎么转发，对象的内存布局

OC中向对象发送消息时，runtime会根据对象的isa指针找到对象所属的类，然后在该类的方法列表和父类的方法列表中寻找方法执行。如果在最顶层父类中没找到方法执行，就会进行消息转发：Method resoution（实现方法）、fast forwarding（转发给其他对象）、normal forwarding（完整消息转发。可以转发给多个对象）

10、runtime 中，SEL和IMP的区别?

每个类对象都有一个方法列表，方法列表存储方法名、方法实现、参数类型，SEL是方法名(编号)，IMP指向方法实现的首地址

11、autoreleasepool的原理和使用场景?

• 若干个autoreleasepoolpage组成的双向链表的栈结构，objc_autoreleasepoolpush、objc_autoreleasepoolpop、objc_autorelease
• 使用场景：多次创建临时变量导致内存上涨时，需要延迟释放

• autoreleasepoolpage的内存结构：4k存储大小

12、Autorelase对象什么时候释放？

在没有手加Autorelease Pool的情况下，Autorelease对象是在当前的runloop迭代结束时释放的，而它能够释放的原因是系统在每个runloop迭代中都加入了自动释放池Push和Pop。

13、Runloop与线程的关系？Runloop的mode? Runloop的作用？内部机制？

• 每一个线程都有一个runloop，主线程的runloop默认启动。
• mode：主要用来指定事件在运行时循环的优先级

• 作用：保持程序的持续运行、随时处理各种事件、节省cpu资源(没事件休息释放资源)、渲染屏幕UI

14、iOS中使用的锁、死锁的发生与避免

• @synchronized、信号量、NSLock等
• 死锁：多个线程同时访问同一资源，造成循环等待。GCD使用异步线程、并行队列

15、NSOperation和GCD的区别

• GCD底层使用C语言编写高效、NSOperation是对GCD的面向对象的封装。对于特殊需求，如取消任务、设置任务优先级、任务状态监听，NSOperation使用起来更加方便。
• NSOperation可以设置依赖关系，而GCD只能通过dispatch_barrier_async实现

• NSOperation可以通过KVO观察当前operation执行状态(执行/取消)
• NSOperation可以设置自身优先级(queuePriority)。GCD只能设置队列优先级(DISPATCH_QUEUE_PRIORITY_DEFAULT)，无法在执行的block中设置优先级

• NSOperation可以自定义operation如NSInvationOperation/NSBlockOperation，而GCD执行任务可以自定义封装但没有那么高的代码复用度
• GCD高效，NSOperation开销相对高

16、oc与js交互

• 拦截url
• JavaScriptCore(只适用于UIWebView)

• WKScriptMessageHandler(只适用于WKWebView)
• WebViewJavaScriptBridge(第三方框架)

17、swift相比OC有什么优势？

18、struct、Class的区别

• class可以继承，struct不可以
• class是引用类型，struct是值类型

• struct在function里修改property时需要mutating关键字修饰

19、访问控制关键字(public、open、private、filePrivate、internal)

• public与open：public在module内部中，class和func都可以被访问/重载/继承，外部只能访问；而open都可以
• private与filePrivate：private修饰class/func，表示只能在当前class源文件/func内部使用，外部不可以被继承和访问；而filePrivate表示只能在当前swift源文件内访问

• internal：在整个模块或者app内都可以访问，默认访问级别，可写可不写

20、OC与Swift混编

• OC调用swift：import "工程名-swift.h” @objc 
• swift调用oc：桥接文件

21、map、filter、reduce？map与flapmap的区别？

• map：数组中每个元素都经过某个方法转换，最后返回新的数组（xx.map({$0 * $0})）
• flatmap：同map类似，区别在flatmap返回的数组不存在nil，并且会把optional解包；而且还可以把嵌套的数组打开变成一个（[[1,2],[2,3,4],[5,6]] ->[1,2,2,3,4,5,6]）

• filter：用户筛选元素（xxx.filter({$0 > 25})，筛选出大于25的元素组成新数组）
• reduce：把数组元素组合计算为一个值，并接收初始值（）

22、guard与defer

• guard用于提前处理错误数据，else退出程序，提高代码可读性
• defer延迟执行，回收资源。多个defer反序执行，嵌套defer先执行外层，后执行内层

23、try、try?与try!

• try：手动捕捉异常
• try?：系统帮我们处理，出现异常返回nil；没有异常返回对应的对象

• try!：直接告诉系统，该方法没有异常。如果出现异常程序会crash

24、@autoclosure：把一个表达式自动封装成闭包

25、throws与rethrows：throws另一个throws时，将前者改为rethrows

26、App启动优化策略？main函数执行前后怎么优化

• 启动时间 = pre-main耗时+main耗时
• pre-main阶段优化：

• 删除无用代码
• 抽象重复代码

• +load方法做的事情延迟到initialize中，或者+load的事情不宜花费太多时间
• 减少不必要的framework，或者优化已有framework

• Main阶段优化
• didFinishLauchingwithOptions里代码延后执行

• 首次启动渲染的页面优化

27、crash防护？

• unrecognized selector crash
• KVO crash

• NSNotification crash
• NSTimer crash

• Container crash（数组越界，插nil等）
• NSString crash （字符串操作的crash）

• Bad Access crash （野指针）
• UI not on Main Thread Crash (非主线程刷UI (机制待改善))

28、内存泄露问题？

主要集中在循环引用问题中，如block、NSTime、perform selector引用计数问题。

29、UI卡顿优化？

30、架构&设计模式

• MVC设计模式介绍
• MVVM介绍、MVC与MVVM的区别？

• ReactiveCocoa的热信号与冷信号
• 缓存架构设计LRU方案

• SDWebImage源码，如何实现解码
• AFNetWorking源码分析

• 组件化的实施，中间件的设计
• 哈希表的实现原理？如何解决冲突

31、数据结构&算法

• 快速排序、归并排序
• 二维数组查找(每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数)

• 二叉树的遍历：判断二叉树的层数
• 单链表判断环

32、计算机基础

1. http与https？socket编程？tcp、udp？get与post？
2. tcp三次握手与四次握手

3. 进程与线程的区别

一点点搭建一个架构，架构对于开发比较重要，有固定的模式，第一不容易产生bug，并且有利于对于项目以及开发架构的理解。 对于一个app，常见的架构一般是底部有Tabbar形式，或者采用抽屉的形式，底部Tabbar大部分app都是平铺的，中间有一块凸出来的形式。

普通Tabbar

 比较简单代码直接贴出来了

 @override

  Widget build(BuildContext context) {

    return Scaffold(

      bottomNavigationBar: normalBottomBar(),

    );

  }

  normalBottomBar() {

    return BottomNavigationBar(

      // 底部导航

      items: <BottomNavigationBarItem>[

        BottomNavigationBarItem(

            icon: Icon(Icons.home),

            label: 'Home',

            activeIcon: Icon(Icons.access_alarm)),

        BottomNavigationBarItem(icon: Icon(Icons.search), label: 'search'),

        BottomNavigationBarItem(icon: Icon(Icons.people), label: 'mine'),

      ],

      currentIndex: _selectedIndex,

      fixedColor: Colors.blue,

      elevation: 10, // default： 8.0

      type: BottomNavigationBarType.fixed,

      iconSize: 30,

      selectedFontSize: 12, // 默认是14，未选择是14

      onTap: _onItemTapped,

    );

  }

  _onItemTapped(int index) {

    setState(() {

      _selectedIndex = index;

    });

  }

中间凸出的Tabbar

官方的Material风格库中存在这种效果，不过个人感觉跟现在流行的风格有点不太匹配，所以封装了一个接近于现在流行风格的Tabbar。 刚开始的效果是这样的：  凸出的按钮封装了一下的代码片段：

import 'dart:math';



import 'package:flutter/material.dart';



class CenterNavigationItem extends StatefulWidget {

  CenterNavigationItem({Key key, this.onTap}) : super(key: key);



  final Function onTap;



  @override

  _CenterNavigationItemState createState() => _CenterNavigationItemState();

}



class _CenterNavigationItemState extends State<CenterNavigationItem> {

  @override

  Widget build(BuildContext context) {

    return Stack(

      children: [

        // CustomPaint(size: Size(76, 76), painter: MyPainter()),

        Container(

          width: 76,

          height: 76,

          padding: EdgeInsets.all(8),

          decoration: BoxDecoration(

              color: Color.fromRGBO(250, 250, 250, 1),

              borderRadius: BorderRadius.circular(38)),

          child: FloatingActionButton(

              child: Icon(Icons.add),

              // child: TextField(),

              tooltip: '测试', // 长按弹出提示

              onPressed: () {

                widget.onTap();

              }),

        ),

      ],

    );

  }

}

// 主页面引用：

@override

  Widget build(BuildContext context) {

    return Scaffold(

      floatingActionButtonLocation: FloatingActionButtonLocation.centerDocked,

      floatingActionButton: CenterNavigationItem(

        onTap: () {

          setState(() {

            _selectedIndex = 1;

          });

        },

      ),

      bottomNavigationBar: normalBottomBar(),

    );

  }

感觉还是差点意思， 在于底部线与线直接连接的不够平滑 

带有动画效果的Tabbar

继续改造一下的想法就是通过CustomPainter去画一个半圆。效果如下：  代码片段：

class MyPainter extends CustomPainter {

  @override

  paint(Canvas canvas, Size size) {

    Paint paint = Paint()

      ..isAntiAlias = false

      ..color = Colors.green

      ..strokeCap = StrokeCap.round

      ..strokeWidth = 0

      ..style = PaintingStyle.stroke;

    print(pi);

    canvas.drawArc(

        new Rect.fromCircle(center: Offset(38, 38), radius: size.width / 2),

        pi,

        2 * pi * 0.5,

        false,

        paint);

  }



  @override

  bool shouldRepaint(CustomPainter oldDelegate) {

    return false;

  }

}

在凸出的按钮封装的代码中添加：

class _CenterNavigationItemState extends State<CenterNavigationItem> {

  @override

  Widget build(BuildContext context) {

    return Stack(

      children: [

        CustomPaint(size: Size(76, 76), painter: MyPainter()),

        class _CenterNavigationItemState extends State<CenterNavigationItem> {

  @override

  Widget build(BuildContext context) {

    return Stack(

      children: [

        // 这个位置加入！！！！！！！！！！

        CustomPaint(size: Size(76, 76), painter: MyPainter()),

        Container(

          width: 76,

          height: 76,

          padding: EdgeInsets.all(8),

          decoration: BoxDecoration(

              color: Color.fromRGBO(250, 250, 250, 1),

              borderRadius: BorderRadius.circular(38)),

          child: FloatingActionButton(

              child: Icon(Icons.add),

              // child: TextField(),

              tooltip: '测试', // 长按弹出提示

              onPressed: () {

                widget.onTap();

              }),

        ),

      ],

    );

  }

}

      ],

    );

  }

}

最终就是这个效果。还有就是也不能闭门造车，上网搜搜大家都是怎么去构建Tabbar的。其中在github上发现一个加入了动画的开源代码。Motion-Tab-Bar。分析了一波代码，看了一眼效果如下： 

稍加修改了一下，留着以后项目可能用的上。over～欢迎讨论

one more thing...

• 1， 路由管理，
• 2， 国际化管理，
• 3， 数据持久化管理，
• 4， 响应式管理方法

接上一篇文章，这篇文章主要介绍，路由管理，国际化管理，响应式管理方法，数据持久化管理。还是先看看大神么们都是怎么写的，从中学习一下。看到又一个比较好用的库getx，方便简介，基本上都包含今天要封装的内容，那就用起来吧。ps：有人可能会有想法说是应该自己写，总用第三方的库，遇到问题不好处理，有点道理，换个想法如果自己没达到那个水平也可以先使用第三方库，好好看看大神的源码，来提升自己。总之所当面看待吧。

引入GetX

在pubspec.yaml文件中加入

dependencies:

 get: ^3.24.0

在需要使用的文件中引入

import 'package:get/get.dart'

在main.dart中使用GetMaterialApp替换MaterialApp

 return GetMaterialApp(

        enableLog: false,

        debugShowCheckedModeBanner: false,

        defaultTransition: Transition.rightToLeftWithFade,

        theme: ThemeData(

          primarySwatch: Colors.orange,

          visualDensity: VisualDensity.adaptivePlatformDensity,

        ),

        home: TabBarPage());

路由管理

比较喜欢这个的原因： 不需要获取上下文context直接跳转页面，代码很简洁，并且支持别名路由跳转
效果：

不带参数颇通跳转

Get.to(OtherPage())

带参数跳转

Get.to(OtherPage(id：''))

无返回跳转

比如在登录成功之后的跳转，不能够再返回到登录页面

Get.off(OtherPage(id：''))

跳转到Tabbar页面

比如在商品的详情页面直接跳转到购物车页面，一般购物车页面在Tabbar上。

Get.off(TabbarPage(currentIndex: 1));

别名跳转

这种情况大家可以去看下GetX的文档，这里就不介绍了。因为我不打算在项目里面坐这种跳转。ps：纯个人原因

SnackBars，Dialogs，BottomSheets使用

GetX中，我们也可以不获取上下文context进行跳用SnackBars，Dialogs， BottomSheets使用

SnackBars

效果：

 Get.snackbar(

   "Hey i'm a Get SnackBar!", 

   "It's unbelievable! I'm using SnackBar without context, without boilerplate, without Scaffold, it is something truly amazing!", 

     icon: Icon(Icons.alarm),

      shouldIconPulse: true,

      barBlur: 20,

     isDismissible: true,

     duration: Duration(seconds: 3),

     backgroundColor: Colors.red);

具体的属性，大家可以点击进去看下源码配置

Dialogs

效果：

 Get.defaultDialog(

                        onConfirm: () => print("Ok"),

                        buttonColor: Colors.white,

                        middleText: "Dialog made in 3 lines of code");

 

也可以弹出自定义的组件

Get.dialog(YourDialogWidget());

BottomSheets

效果：

Get.bottomSheet(Container(

                      decoration: BoxDecoration(color: Colors.red),

                      child: Wrap(

                        children: <Widget>[

                          ListTile(

                              leading: Icon(Icons.music_note),

                              title: Text('Music'),

                              onTap: () {}),

                          ListTile(

                            leading: Icon(Icons.videocam),

                            title: Text('Video'),

                            onTap: () {},

                          ),

                        ],

                      ),

                    ))；

以上是简单的用法，我们可以新建哥utils文件夹，封装成一个工具类去调用这个方法。

国际化管理

目前涉及到2中模式，

• 根据系统语言设置国际化


• 在应用内设置国际化显示

首先创建一个Languages.dart文件 简单的写了一个hello的中英文含义

import 'package:get/get.dart';

class Languages extends Translations {

  @override

  Map<String, Map<String, String>> get keys => {

        'zh_CN': {

          'hello': '你好 世界',

        },

        'en_US': {

          'hello': 'Hallo Welt',

        }

      };

}

在main.dart中加入代码：

return GetMaterialApp(

    translations: Languages(), // 你的翻译

    locale: Locale('zh', 'CN'), // 将会按照此处指定的语言翻译

    fallbackLocale: Locale('en', 'US'), // 添加一个回调语言选项，以备上面指定的语言翻译不存在

);

显示只需要加入如下就ok。很简单

Text('hello'.tr)

跟随系统语言

ui.window.locale 获取当前系统语言，设置本地语言

GetMaterialApp(

 translations: Languages(), // 你的翻译

 locale: ui.window.locale, // 将会按照此处指定的语言翻译

 fallbackLocale: Locale('en', 'US'), // 添加一个回调语言选项，以备上面指定的语言翻译 不存在

  ......

)

在应用内设置国际化显示

更新文字显示为中文如下：

var locale = Locale('zh', 'CN');

Get.updateLocale(locale);

多写两句用RadioListTile实现一下效果

RadioListTile(

	value: 'chinese',

	groupValue: _selected,

	title: Text('中文'),

	subtitle: Text('中文'),

	selected: _selected == 'chinese',

	onChanged: (type) {

	  var locale = Locale('zh', 'CN');

	  Get.updateLocale(locale);

	  setState(() {

		_selected = type;

	  });

}),

RadioListTile(

   value: 'english',

   groupValue: _selected,

   title: Text('英文'),

   subtitle: Text('英文'),

   selected: _selected == 'english',

   onChanged: (type) {

      var locale = Locale('en', 'US');

      Get.updateLocale(locale);

          setState(() {

             _selected = type;

          });

     },

   ),

这是本人测试使用用的代码。看一下效果

响应式管理方法

GetX举例是一个计数器的例子，已经很容易理解了，作用就是不用在引入过多的状态管理的库，比如provide之类的。用法差不多。更简洁。还是记录一下，方便以后查看用

class Controller extends GetxController{

  var count = 0.obs;

  increment() => count++;

}

lass Home extends StatelessWidget {



  @override

  Widget build(context) {



    // 使用Get.put()实例化你的类，使其对当下的所有子路由可用。

    final Controller c = Get.put(Controller());



    return Scaffold(

      // 使用Obx(()=>每当改变计数时，就更新Text()。

      appBar: AppBar(title: Obx(() => Text("Clicks: ${c.count}"))),



      // 用一个简单的Get.to()即可代替Navigator.push那8行，无需上下文！

      body: Center(child: RaisedButton(

              child: Text("Go to Other"), onPressed: () => Get.to(Other()))),

      floatingActionButton:

          FloatingActionButton(child: Icon(Icons.add), onPressed: c.increment));

  }

}



class Other extends StatelessWidget {

  // 你可以让Get找到一个正在被其他页面使用的Controller，并将它返回给你。

  final Controller c = Get.find();



  @override

  Widget build(context){

     // 访问更新后的计数变量

     return Scaffold(body: Center(child: Text("${c.count}")));

  }

}

这块还没有在程序中使用，但是状态管理在程序中使用还是很方便的，比如更改用户信息，登录。购物车逻辑中都可以使用

数据持久化管理

这个地方引入了第二个第三方库

  flustars: ^0.3.3

  # https://github.com/Sky24n/sp_util

  # sp_util分拆成单独的库，可以直接引用

  sp_util: ^1.0.1

用起来也很方便感觉不错。
为了之后方便使用，现定义一个Global.dart文件，做初始化操作

import 'package:flustars/flustars.dart';

class Global {

  static Future initSqutil() async => await SpUtil.getInstance();

}

在main方法中调用：

Global.initSqutil(); 

接下来进行存储数据以及获取数据的方法，类型包括：字符串，布尔值，对象，数组
举个例子：

存数据

SpUtil.putString( 'login', '登录了',);

取数据

SpUtil.getString('login',defValue: '');

额外提的一点就是存储对象类型数组,分两种形式，getObjList， getObjectList方法

 类似泛型的结构， 可以进行转换

 List<Map> dataList = SpUtil.getObjList('cityMap', (v) => v);

 返回一个Map数组

 List<Map> dataList = SpUtil.getObjectList('cityMap');

这个地方可以配合国际化语言切换时使用。比如每次改变语言进行存储。然后每次打开app进行，获取初始化。

one more things...

• 网络请求


• 页面不同状态展示封装

对于前端模块化总是稀里糊涂，今天深入学习一下前端模块化，彻底弄懂CommonJs和ES6 Module，希望本文可以给你带来帮助。

CommonJS

模块

CommonJS中规定每个文件是一个模块。将一个JS文件通过script标签插入页面与封装成CommonJS模块最大的不同在于，前者的顶层作用域是全局作用域，在进行变量及函数声明时会污染全局环境；而后者形成一个属于模块自身的作用域，所有的变量及函数只能自己访问，对外不可见。

导出

导出是一个模块向外暴露自身的唯一方式。在commonJS中，通过modul
e.exports可以导出模块中的内容。下面的代码导出了一个对象，包含name和add属性。

module.exports = {

    name: 'calculater',

    add: function(a, b){

        return a+b;

    }

}

为了书写方便，CommonJS也支持直接使用exports。

exports.name = 'calculater';

exports.add = function(a, b){

    return a+b;

}

exports可以理解为

var module = {

    exports:{}

};

var exports = module.exports;

注意错误的用法：

1. 不要给exports直接赋值，否则导出会失效。如下代码，对exports赋值，使其指向新的对象。module.exports却仍然是原来的空对象，因此name属性并不会被导出。

exports = {

    name: 'calculater'

}

2. 不恰当的把module.exports和exports混用。如下代码，先通过exports导出add属性，然后将module.exports重新赋值为另一个对象，将导致add属性丢失，最后导出只有name。

exports.add = function(a,b){

    return a+b;

}

module.exports = {

    name: 'calculater'

}

导入

在CommonJs中，使用require进行模块导入。

const calculator = require('./calculator.js')

let sum = calculator.add(2,3)

注意：

1. require的模块是第一次被加载，这时会首先执行该模块，然后导出内容
2. require的模块曾被加载过，这时该模块的代码不会再次执行，而是直接导出上次执行后得到的结果。
3. 对于不需要获取导出内容的模块，直接使用require即可。
4. require函数可以接收表达式，借助这个特性可以动态地指定模块加载路径。

const moduleName = ['a.js', 'b.js'];

moduleNames.forEach(name => {

    require('./'+name)

})

ES6 Module

模块

ES6 Module是ES语法的一部分，它也是将每个文件作为一个模块，每个模块拥有自身的作用域。

导出

在ES6 Module中使用export命令来导出模块。export有两种形式：

• 命名导出
• 默认导出

一个模块可以有多个命名导出，它有两种不同的写法：

//写法1,将变量的声明和导出写在一行

export const name = 'calculator'

export const add = function(a, b){return a+b}



//写法2，先进行变量的声明，然后在用同一个export语句导出。

const name = 'calculator'

const add = function(a, b){return a+b}

export {name, add}

与命名导出不同，模块的默认导出只能有一个。

export default {

    name: 'calculator',

    add: function(a, b){

        return a+b

    }

}

导入

ES6 Module中使用import语法导入模块。

加载带有命名导出的模块

有两种方式

1. import后面要跟一对大括号，将导入的变量名包裹起来。并且这些变量名要与导出的变量名完全一致。

//calculator.js

const name = 'calculator'

const add = function(a, b){return a+b}

export {name, add}



//index.js

import {name, add} from './calculator.js'

add(2,3)

2. 采用整体导入的方式, 使用import * as myModule可以把所有导入的变量作为属性值添加到myModule中，从而减少对当前作用域的影响。

import * as calculator from './calculator.js'

console.log(calculator.add(2,3))

console.log(calculator.name)

加载默认导出的模块

import后面直接跟变量名，并且这个名字可以自由指定

//calculator.js

export default {

    name: 'calculator',

    add: function(a, b){

        return a+b

    }

}

//index.js

import calculator from './calculator.js'

calculator.add(2,3)

两种导入方式混合起来

import React, {Component} from 'react'

这里的React对应的是该模块的默认导出，Component则是其命名导出中的一个变量。

CommonJS和ES6 Module的区别

动态和静态

相比于CommonJS,ES6 Module有如下优势：

1. 死代码监测和排除
2. 模块变量和类型检查
3. 编译器优化

值拷贝和动态映射

在导入一个模块时，对于CommonJs来说，获取的是一份导出值的拷贝。而在ES6 Module中则是值的动态映射，并且这个映射是只读的。

总结

CommonJS使用Module.exports或exports导出

CommonJS使用require()函数导入，该函数返回一个对象，包含导出的变量。

ES6 Module使用export导出，包括命名导出或者默认导出。

命名导出是export后面跟一个大括号，括号里面包含导出的变量

命名导出的另一种方式是export和变量声明在一行。

默认导出是export default，只能有一个默认导出

ES6 Module导入使用import

加载带有命名导出的模块，import后面要跟一对大括号，将导入的变量名包裹起来。并且这些变量名要与导出的变量名完全一致。

采用整体导入的方式, 使用import * as 可以把所有导入的变量作为属性值添加到中，从而减少对当前作用域的影响。

加载默认导出的模块，import后面直接跟变量名，并且这个名字可以自由指定。

作者：邓惠子本尊

前言

本文讲述了JS常用的几种数组遍历方式以及性能分析对比。

如果这篇文章有帮助到你，❤️关注+点赞❤️鼓励一下作者，文章公众号首发，关注 前端南玖 第一时间获取最新的文章～

数组的方法

JavaScript发展到现在已经提供了许多数组的方法，下面这张图涵盖了数组大部分的方法，这篇文章主要说一说数组的遍历方法，以及各自的性能，方法这么多，如何挑选性能最佳的方法对我们的开发有非常大的帮助。

数组遍历的方法

for

标准的for循环语句，也是最传统的循环语句

var arr = [1,2,3,4,5]

for(var i=0;i<arr.length;i++){

  console.log(arr[i])

}

最简单的一种遍历方式，也是使用频率最高的，性能较好，但还能优化

优化版for循环语句

var arr = [1,2,3,4,5]

for(var i=0,len=arr.length;i<len;i++){

  console.log(arr[i])

}

使用临时变量，将长度缓存起来，避免重复获取数组长度，尤其是当数组长度较大时优化效果才会更加明显。

这种方法基本上是所有循环遍历方法中性能最高的一种

forEach

普通forEach

对数组中的每一元素运行给定的函数,没有返回值，常用来遍历元素

var arr5 = [10,20,30]

var result5 = arr5.forEach((item,index,arr)=>{

    console.log(item)

})

console.log(result5)

/*

10

20

30

undefined   该方法没有返回值

*/

数组自带的foreach循环，使用频率较高，实际上性能比普通for循环弱

原型forEach

由于foreach是Array型自带的，对于一些非这种类型的，无法直接使用(如NodeList)，所以才有了这个变种，使用这个变种可以让类似的数组拥有foreach功能。

const nodes = document.querySelectorAll('div')

Array.prototype.forEach.call(nodes,(item,index,arr)=>{

  console.log(item)

})

实际性能要比普通foreach弱

for...in

任意顺序遍历一个对象的除Symbol以外的可枚举属性，包括继承的可枚举属性。

一般常用来遍历对象，包括非整数类型的名称和继承的那些原型链上面的属性也能被遍历。像 Array和 Object使用内置构造函数所创建的对象都会继承自Object.prototype和String.prototype的不可枚举属性就不能遍历了.

var arr = [1,2,3,4,5]

for(var i in arr){

  console.log(i,arr[i])

}  //这里的i是对象属性，也就是数组的下标

/**

0 1

1 2

2 3

3 4

4 5 **/

大部分人都喜欢用这个方法，但它的性能却不怎么好

for...of（不能遍历对象）

在可迭代对象（具有 iterator 接口）（Array，Map，Set，String，arguments）上创建一个迭代循环，调用自定义迭代钩子，并为每个不同属性的值执行语句，不能遍历对象

let arr=["前端","南玖","ssss"];

    for (let item of arr){

        console.log(item)

    }

//前端 南玖 ssss



//遍历对象

let person={name:"南玖",age:18,city:"上海"}

for (let item of person){

  console.log(item)

}

// 我们发现它是不可以的 我们可以搭配Object.keys使用

for(let item of Object.keys(person)){

    console.log(person[item])

}

// 南玖 18 上海

这种方式是es6里面用到的，性能要好于forin，但仍然比不上普通for循环

map

map: 只能遍历数组，不能中断，返回值是修改后的数组。

let arr=[1,2,3];

const res = arr.map(item=>{

  return item+1

})

console.log(res) //[2,3,4]

console.log(arr) // [1,2,3]

every

对数组中的每一运行给定的函数，如果该函数对每一项都返回true,则该函数返回true

var arr = [10,30,25,64,18,3,9]

var result = arr.every((item,index,arr)=>{

      return item>3

})

console.log(result)  //false

some

对数组中的每一运行给定的函数，如果该函数有一项返回true,就返回true，所有项返回false才返回false

var arr2 = [10,20,32,45,36,94,75]

var result2 = arr2.some((item,index,arr)=>{

    return item<10

})

console.log(result2)  //false

reduce

reduce()方法对数组中的每个元素执行一个由你提供的reducer函数（升序执行），将其结果汇总为单个返回值

const array = [1,2,3,4]

const reducer = (accumulator, currentValue) => accumulator + currentValue;



// 1 + 2 + 3 + 4

console.log(array1.reduce(reducer));

filter

对数组中的每一运行给定的函数，会返回满足该函数的项组成的数组

// filter  返回满足要求的数组项组成的新数组

var arr3 = [3,6,7,12,20,64,35]

var result3 = arr3.filter((item,index,arr)=>{

    return item > 3

})

console.log(result3)  //[6,7,12,20,64,35]

性能测试

工具测试

使用工具测试性能分析结果如下图所示

手动测试

我们也可以自己用代码测试：

//测试函数

function clecTime(fn,fnName){

        const start = new Date().getTime()

        if(fn) fn()

        const end = new Date().getTime()

        console.log(`${fnName}执行耗时:${end-start}ms`)

}



function forfn(){

  let a = []

  for(var i=0;i<arr.length;i++){

    // console.log(i)

    a.push(arr[i])

  }

}

clecTime(forfn, 'for')   //for执行耗时:106ms



function forlenfn(){

  let a = []

  for(var i=0,len=arr.length;i<len;i++){

    a.push(arr[i])

  }

}

clecTime(forlenfn, 'for len')   //for len执行耗时:95ms



function forEachfn(){

  let a = []

  arr.forEach(item=>{

    a.push[item]

  })

}

clecTime(forEachfn, 'forEach')   //forEach执行耗时:201ms



function forinfn(){

  let a = []

  for(var i in arr){

    a.push(arr[i])

  }

}

clecTime(forinfn, 'forin') //forin执行耗时:2584ms (离谱)



function foroffn(){

  let a = []

  for(var i of arr){

    a.push(i)

  }

}

clecTime(foroffn, 'forof') //forof执行耗时:221ms



//  ...其余可自行测试

结果分析

经过工具与手动测试发现，结果基本一致，数组遍历各个方法的速度：传统的for循环最快，for-in最慢

for-len > for > for-of > forEach > map > for-in

javascript原生遍历方法的建议用法：

• 用for循环遍历数组


• 用for...in遍历对象


• 用for...of遍历类数组对象（ES6）


• 用Object.keys()获取对象属性名的集合

为何for… in会慢？

因为for … in语法是第一个能够迭代对象键的JavaScript语句，循环对象键（{}）与在数组（[]）上进行循环不同，引擎会执行一些额外的工作来跟踪已经迭代的属性。因此不建议使用for...in来遍历数组

引言

async/await是非常棒的语法糖，可以说他是解决异步问题的最终解决方案。从字面意思来理解。async 是异步的意思，而 await 是 等待 ，所以理解 async用于申明一个function是异步的，而 await 用于等待一个异步方法执行完成。

async作用

async声明function是一个异步函数，返回一个promise对象，可以使用 then 方法添加回调函数。async函数内部return语句返回的值，会成为then方法回调函数的参数。

async function test() {

  return 'test';

}

console.log(test); // [AsyncFunction: test] async函数是[`AsyncFunction`]构造函数的实例

console.log(test()); // Promise { 'test' }



// async返回的是一个promise对象

test().then(res=>{

  console.log(res); // test

})



// 如果async函数没有返回值 async函数返回一个undefined的promise对象

async function fn() {

  console.log('没有返回');

}

console.log(fn()); // Promise { undefined }



// 可以看到async函数返回值和Promise.resolve()一样，将返回值包装成promise对象，如果没有返回值就返回undefined的promise对象

await

await 操作符只能在异步函数 async function 内部使用。如果一个 Promise 被传递给一个 await 操作符，await 将等待 Promise 正常处理完成并返回其处理结果，也就是说它会阻塞后面的代码，等待 Promise 对象结果。如果等待的不是 Promise 对象，则返回该值本身。

async function test() {

  return new Promise((resolve)=>{

    setTimeout(() => {

        resolve('test 1000');

    }, 1000);

  })

}

function fn() {

  return 'fn';

}



async function next() {

    let res0 = await fn(),

        res1 = await test(),

        res2 = await fn();

    console.log(res0);

    console.log(res1);

    console.log(res2);

}

next(); // 1s 后才打印出结果 为什么呢 就是因为 res1在等待promise的结果 阻塞了后面代码。

错误处理

如果await后面的异步操作出错，那么等同于async函数返回的 Promise 对象被reject。

async function test() {

  await Promise.reject('错误了')

};



test().then(res=>{

  console.log('success',res);

},err=>{

  console.log('err ',err);

})

// err 错误了

防止出错的方法，也是将其放在try...catch代码块之中。

async function test() {

  try {

    await new Promise(function (resolve, reject) {

      throw new Error('错误了');

    });

  } catch(e) {

      console.log('err', e)

  }

  return await('成功了');

}

多个await命令后面的异步操作，如果不存在继发关系（即互不依赖），最好让它们同时触发。

let foo = await getFoo();

let bar = await getBar();

// 上面这样写法 getFoo完成以后，才会执行getBar



// 同时触发写法 ↓



// 写法一

let [foo, bar] = await Promise.all([getFoo(), getBar()]);



// 写法二

let fooPromise = getFoo();

let barPromise = getBar();

let foo = await fooPromise;

let bar = await barPromise;

async/await优点

async/await的优势在于处理由多个Promise组成的 then 链，在之前的Promise文章中提过用then处理回调地狱的问题，async/await相当于对promise的进一步优化。
假设一个业务，分多个步骤，且每个步骤都是异步的，而且依赖上个步骤的执行结果。

// 假设表单提交前要通过俩个校验接口



async function check(ms) { // 模仿异步 

  return new Promise((resolve)=>{

    setTimeout(() => {

        resolve(`check ${ms}`);

    }, ms);

  })

}

function check1() {

  console.log('check1');

  return check(1000);

}

function check2() {

  console.log('check2');

  return check(2000);

}



// -------------promise------------

function submit() {

  console.log('submit');

  // 经过俩个校验 多级关联 promise传值嵌套较深

  check1().then(res1=>{

    check2(res1).then(res2=>{

       /*

        * 提交请求

        */

    })

  })

}

submit();



// -------------async/await-----------

async function asyncAwaitSubmit() {

    let res1 = await check1(),

        res2 = await check2(res1);

        console.log(res1, res2);

        /*

        * 提交请求

        */

}

原理

async 函数的实现原理，就是将 Generator 函数和自动执行器，包装在一个函数里。

async function fn(args) {

  // ...

}



// 等同于



function fn(args) {

  return spawn(function* () {

    // ...

  });

}

/*

* Generator 函数就是一个封装的异步任务，或者说是异步任务的容器。

* 异步操作需要暂停的地方，都用 yield 语句注明

* 调用 Generator 函数，返回的是指针对象(这是它和普通函数的不同之处),。调用指针对象的 next 方法，会移动内部指针。

* next 方法的作用是分阶段执行 Generator 函数。每次调用 next 方法，会返回一个对象，表示当前阶段的信息（ value 属性和 done 属性）。value 属性是 yield 语句后面表达式的值，表示当前阶段的值；done 属性是一个布尔值，表示 Generator 函数是否执行完毕，即是否还有下一个阶段。

*/



// 了解generator的用法

function* Generator() {

  yield '1';

  yield  Promise.resolve(2);

  return 'ending';

}

 

var gen = Generator(); // 返回指针对象 Object [Generator] {}



let res1 = gen.next();

console.log(res1); // 返回当前阶段的值 { value: '1', done: false }



let res2 = gen.next();

console.log(res2); // 返回当前阶段的值 { value: Promise { 2 }, done: false }



res2.value.then(res=>{

  console.log(res); // 2

})



let res3 = gen.next();

console.log(res3);  // { value: 'ending', done: true }



let res4 = gen.next();

console.log(res4); // { value: undefined, done: true }

Generator实现async函数

// 接受一个Generator函数作为参数

function spawn(genF) {

  // 返回一个函数

  return function() {

     // 生成指针对象

     const gen = genF.apply(this, arguments);

     // 返回一个promise

     return new Promise((resolve, reject) => {

          // key有next和throw两种取值，分别对应了gen的next和throw方法

          // arg参数则是用来把promise resolve出来的值交给下一个yield

          function step(key, arg) {

            let result;



                // 监控到错误 就把promise给reject掉 外部通过.catch可以获取到错误

                try {

                  result = gen[key](arg)

                } catch (error) {

                  return reject(error)

                }



                // gen.next() 返回 { value, done } 的结构

                const { value, done } = result;



                if (done) {

                      // 如果已经完成了 就直接resolve这个promise

                      return resolve(value)

                } else {

                      // 除了最后结束的时候外，每次调用gen.next()

                      return Promise.resolve(

                        // 这个value对应的是yield后面的promise

                        value

                      ).then((val)=>step("next", val),(err) =>step("throw", err))

                }

          }

          step("next")

     })

  }

}

测试

function fn(nums) {

  return new Promise(resolve => {

    setTimeout(() => {

      resolve(nums)

    }, 1000)

  })

}

// async 函数

async function testAsync() {

  let res1 = await fn(1);

  console.log(res1); // 1

  let res2 = await fn(2);

  console.log(res2); // 2

  return res2;

}

let _res = testAsync();

console.log('testAsync-res',_res); // Promise

_res.then(v=>console.log('testAsync-res',v)) // 2



// Generator函数

function* gen() {

  let res1 = yield fn(3);

  console.log(res1); // 3

  let res2 = yield fn(4);

  console.log(res2); // 4

  // let res3 = yield Promise.reject(5);

  //  console.log(res3);

  return res2;

}



let _res2 = spawn(gen)();

console.log('gen-res',_res2); // Promise



_res2

.then(v=>console.log('gen-res',v)) // 4

.catch(err=>{console.log(err)}) // res3 执行会抛出异常

总结

async/await语法糖可以让异步代码变得更清晰，可读性更高，所以快快卷起来吧。Generator有兴趣的可以了解一下。

我们结婚了！

是的，这次不是女朋友啦，是老婆了！

时隔将近一个月，老婆又让我给她下载腾讯视频，如果按照上次探索的内容来下载的话，倒是可以一步步下载，合并，不过很麻烦，程序员不都是为了解决麻烦的吗，这么麻烦的步骤，有没有简单点呢。有!当然有，有很多简单的工具，上一期很多朋友给我推荐了各种工具，这里我没有一一查看，我可以列举出来，有需要的同学可以尝试看看，不想尝试的也可以看看我下面为了偷懒准备的方法。

心路历程

最初，我是想着把我之前的步骤，用无头浏览器加载一遍，然后用代码去下载ts片段，然后在机器上用ffmpeg进行合并，但是仿佛还是有些许麻烦，然后我就去npm搜了一下关键词：m3u8tomp4

m3u8-to-mp4

于是我点击了第一个包:m3u8-to-mp4

纳尼？这个包就一个版本，用了3年，而且周下载量还不少

于是我想着这个包要么就是很牛逼，一次性解决了m3u8转mp4的问题，一劳永逸，所以3年没更新过了，要么就是作者忘记了自己还有这个包

于是我就用了这个3年没人维护没人更新的包。

用法也很简单，就copy example 就好了。代码如下：

var m3u8ToMp4 = require("m3u8-to-mp4");

var converter = new m3u8ToMp4();

(async function() {

    var url = "https://apd-666945ea97106754c57813479384d30c.v.smtcdns.com/omts.tc.qq.com/AofRtrergNwkAhpHs4RrxH2_9DWLWSG8xjDMZDQoFGyY/uwMROfz2r55kIaQXGdGnC2deOm68BrdPrRewQlOzrMAbixNO/svp_50001/cKAgRbCb6Re4BpHkI-IlK_KN1VJ8gQVK2sZtkHEY3vQUIlxVz7AtWmVJRifZrrPfozBS0va-SSJFhQhOFSKVNmqVi165fCQJoPl8V5QZBcGZBDpSIfrpCImJKryoZOdR5C0oGYkzIW77I4his7UkPY9Iwmf1QWjaHwNV2hpKv3aD9ysL_-YByA/szg_9276_50001_0bc3uuaa2aaafmaff4e3ijqvdjodbwsqadka.f304110.ts.m3u8?ver=4"

  await converter

    .setInputFile(url)

    .setOutputFile("dummy.mp4")

    .start();

  console.log("File converted");

})();

视频地址是 v.qq.com/x/page/v331…

然后视频就转换成功了，哇哦！

so easy ! so beautiful!

原理

带着好奇，我想看下这个包是如何进行转换的

于是我点进去m3u8-to-mp4这个包文件

包文件内容如下

只有一个文件？

然后我打开了index.js ，只有64行😂

全部代码如下

/**

* @description M3U8 to MP4 Converter

* @author Furkan Inanc

* @version 1.0.0

*/



let ffmpeg = require("fluent-ffmpeg");



/**

* A class to convert M3U8 to MP4

* @class

*/

class m3u8ToMp4Converter {

 /**

  * Sets the input file

  * @param {String} filename M3U8 file path. You can use remote URL

  * @returns {Function}

  */

 setInputFile(filename) {

   if (!filename) throw new Error("You must specify the M3U8 file address");

   this.M3U8_FILE = filename;



   return this;

 }



 /**

  * Sets the output file

  * @param {String} filename Output file path. Has to be local :)

  * @returns {Function}

  */

 setOutputFile(filename) {

   if (!filename) throw new Error("You must specify the file path and name");

   this.OUTPUT_FILE = filename;



   return this;

 }



 /**

  * Starts the process

  */

 start() {

   return new Promise((resolve, reject) => {

     if (!this.M3U8_FILE || !this.OUTPUT_FILE) {

       reject(new Error("You must specify the input and the output files"));

       return;

     }



     ffmpeg(this.M3U8_FILE)

       .on("error", error => {

         reject(new Error(error));

       })

       .on("end", () => {

         resolve();

       })

       .outputOptions("-c copy")

       .outputOptions("-bsf:a aac_adtstoasc")

       .output(this.OUTPUT_FILE)

       .run();

   });

 }

}



module.exports = m3u8ToMp4Converter;

大致看了下这个包做的内容，就是检测并设置了输入链接，和输出文件名，然后调用了fluent-ffmpeg这个库

???

站在巨人的肩膀上吗，自己就包了一层😂

接着看fluent-ffmpeg这个包，是如何实现转换的

然后我们在这个包文件夹下面搜索.run方法，用来定位到具体执行的地方

凭借多年的cv经验，感觉应该是processor.js这个文件里的，然后我们打开这个文件，定位到该方法处

往下看代码，我注意到了这段代码

因为都是基于ffmpeg这个大爹来做的工具，所以最底层也都是去调用ffmpeg的command

这几个if判断都是对结果进行捕获异常，那么我们在这个核心代码的地方打个端点看下

貌似是调用了几个命令行参数

于是我就有了一个大胆的想法！

是的，我手动在终端将这个命令拼接起来，用我的本地命令去跑应该也没问题的吧，于是我尝试了一下

没想到还成功了，其实成功是必然的，因为都是借助来ffmpeg这个包，只不过我是手动去操作，框架是代码去拼接这个命令而已

剩余的时间里，我看了看fluent-ffmpeg的其他代码，它做的东西比较多，比如去本查找ffmpeg的绝对路径啊，对ffmpeg的结果进行捕获异常信息等...

为什么要写BaseAcivity

我们都知道在做Android应用开发的时候都需要创建一个Activity，但很多时候我们的程序有多个界面并且每个界面都有相似的内容（例如：Toolbar、DrawerLayout）和后台的操作有共同的方法，这个时候我们写一个BaseActivity作为每一个Activity的基类，统一管理程序中的每个Activity。

一行代码实现 Toolbar 效果

activity_main.xml 的代码

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity"

    android:gravity="center"

    android:background="@android:color/holo_blue_light">



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="我是MainActivity的界面"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintLeft_toLeftOf="parent"

        app:layout_constraintRight_toRightOf="parent"

        app:layout_constraintTop_toTopOf="parent" />



</LinearLayout>

MainAcitvity.java 的代码

public class MainActivity extends BaseActivity {



    @Override

    protected int getContentView() {

        return R.layout.activity_main;

    }

}

“少啰嗦，先看东西”

• 
  

  创建 BaseActivity

  
  

  在项目创建后，我们可以看到AndroidStudio自动帮我们生成了MainActivity.java和activity_main.xml文件，然后我们再创建一个新的Activity，命名为BaseActivity。

  

  
  


• 
  

  修改 activity_base.xml 文件

  
  

  接着打开activity_base.xml文件，把父布局的ConstraintLayout换成垂直的LinearLayout（其实也可以不换的，主要是我喜欢用LinearLayout），并在里面添加两个元素Toolbar和FrameLayout。

  
  

  
  

  注意：由于Toolbar代替 ActionBar，所以先把 ActionBar 去掉，我们通过设置 Application 的 theme 来隐藏，这样项目中所有的界面的 ActionBar 就都隐藏了。

  
  

  
  

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".BaseActivity"

    android:orientation="vertical">



    <androidx.appcompat.widget.Toolbar

        android:id="@+id/toolbar"

        android:layout_width="match_parent"

        android:layout_height="?attr/actionBarSize"

        android:background="?attr/colorPrimary"

        android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"

        app:popupTheme="@style/ThemeOverlay.AppCompat.Light"/>



    <FrameLayout

        android:id="@+id/container"

        android:layout_width="match_parent"

        android:layout_height="match_parent">



    </FrameLayout>



</LinearLayout>

• 
  

  修改 BaseActivity.java 文件

  
  

  接下来打开 BaseActivity.java 文件，让 BaseActivity 继承 AppCompatActivity ，修改代码如下

  
  

  
  

  注意：protected abstract int getContentView(); 是一个抽象方法，所以我们要将 BaseActivity 修改成抽象类。为什么要修改成抽象类呢？原因很简单，因为一个类里是不允许有一个抽象方法的，如要有抽象方法，那这个类就必须是抽象类。那可能你又会问，为什么要用抽象方法呢？（你是十万个为什么吗？哪来的那么多为什么）因为我们想让其他 Activity 的界面显示到 BaseActivity 中，那这个方法是必须要实现的，如果设置成普通的方法的话，我们很有可能在写代码的时候忘记了调用了这个方法，导致界面不显示。所以我们得用抽象方法，这样每个 Activity 继承这个 BaseActivity 的时候就必须覆写 getContentView() 这个方法。

  
  

  
  

public abstract class BaseActivity extends AppCompatActivity {



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_base);

        initView();

    }



    private void initView() {

        // 绑定控件

        Toolbar toolbar = findViewById(R.id.toolbar);

        FrameLayout container = findViewById(R.id.container);

        // 初始化设置Toolbar

        toolbar.setTitle("我是BaseActivity的Toolbar");

        setSupportActionBar(toolbar);

        // 将继承了BaseActivity的布局文件解析到 container 中，这样 BaseActivity 就能显示 MainActivity 的布局文件了

        LayoutInflater.from(this).inflate(getContentView(), container);

    }



    /**

     * 获取要显示内容的布局文件的资源id

     *

     * @return 显示的内容界面的资源id

     */

    protected abstract int getContentView();



}

• 修改 activity_main.xml 文件
  打开 activity_main.xml 文件，然后我们将父布局的背景颜色修改一下，方便我们辨别到底是 MainActivity 的布局文件还是 BaseActivity 的布局文件。再添加添加一个 TextView ，原因也是和修改背景颜色是一样的。

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity"

    android:gravity="center"

    android:background="@android:color/holo_blue_light">



    <TextView

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="我是MainActivity的界面"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintLeft_toLeftOf="parent"

        app:layout_constraintRight_toRightOf="parent"

        app:layout_constraintTop_toTopOf="parent" />



</LinearLayout>

• 修改 MainActivity.java 文件
  让 MainActivity 继承 BaseActivity 并覆写 getContentView() 方法，然后删除onCreate()方法。通过 getContentView() 方法返回当前的布局资源ID给 BaseActivity，让 BaseActivity 加载布局文件。

public class MainActivity extends BaseActivity {



    @Override

    protected int getContentView() {

        return R.layout.activity_main;

    }

}

• 
  

  运行项目

  
  

  现在你运行一下项目，我们并没有在 MainActivity 的布局中添加 ToolBar,但是运行出来的效果是 Toolbar 已经存在了。
  

  

  
  现在就能做到用一行代码实现 Toolbar 的效果。那你现在可能就会有疑问，如果我像对 Toolbar 修改标题和添加按钮呢？其实也简单，我们继续往下看。
  
  


• 
  

  修改标题
  我们在 BaseActivity 中再添加一个抽象方法，并在初始化 Toolbar 那一处调用我们写的这个抽象方法。

  
  

public abstract class BaseActivity extends AppCompatActivity {



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_base);

        initView();

    }



    private void initView() {

        // 绑定控件

        Toolbar toolbar = findViewById(R.id.toolbar);

        FrameLayout container = findViewById(R.id.container);

        // 初始化设置Toolbar

        toolbar.setTitle(setTitle());

        setSupportActionBar(toolbar);

        // 将继承了BaseActivity的布局文件解析到 container 中，这样 BaseActivity 就能显示 MainActivity 的布局文件了

        LayoutInflater.from(this).inflate(getContentView(), container);

    }



    /**

     * 获取要显示内容的布局文件的资源id

     *

     * @return 显示的内容界面的资源id

     */

    protected abstract int getContentView();



    /**

     * 设置标题

     * 

     * @return 要显示的标题名称

     */

    protected abstract String setTitle();



}

• 修改 MainActivity.java
  我们还是像刚才一样覆写 setTitle() 方法，并在返回值输入我们想要显示的标题

public class MainActivity extends BaseActivity {



    @Override

    protected int getContentView() {

        return R.layout.activity_main;

    }



    @Override

    protected String setTitle() {

        return "我是MainActivity的标题";

    }

}

这个时候再运行以下你的程序就会出现你设置的标题了。

• 
  

  显示返回按钮
  我们先给 Toolbar 显示返回按钮，通过 getSupportActionBar() 得到 ActionBar 的实例，再调用 ActionBar 的 setDisplayHomeAsUpEnabled(true) 方法让返回按钮显示出来。

  
  

  
  

  Toolbar 最左侧的按钮是叫做HomeAsUp，默认是隐藏的，并且它的图标是一个返回箭头。还有一种 setNavigationcon() 方法也能设置图标，具体可以查找 Toolbar 的文档说明

  
  

  
  

private void initView() {

        // 绑定控件

        Toolbar toolbar = findViewById(R.id.toolbar);

        FrameLayout container = findViewById(R.id.container);

        // 初始化设置Toolbar

        toolbar.setTitle(setTitle());

        setSupportActionBar(toolbar);

        // 将继承了BaseActivity的布局文件解析到 container 中，这样 BaseActivity 就能显示 MainActivity 的布局文件了

        LayoutInflater.from(this).inflate(getContentView(), container);

        // 显示返回按钮

        ActionBar actionBar = getSupportActionBar();

        if (actionBar != null) {

            actionBar.setDisplayHomeAsUpEnabled(true);

        }

        // 初始化

        init();

    }

• 
  

  自己定义一个接口并声明
  这里我就用截图显示代码片段

  

  
  


• 
  

  设置监听事件
  打开 MainActivity.java 文件，覆写 init() 方法，并调用父类的 setBackOnClickListener() 方法。

  
  

  
  

  这里我用了 lambda 表达式，这是 java 8 才支持的，默认项目是不支持的，你在 build.gradle 中需要声明一下。

  
  

  
  

	@Override

    protected void init() {

        setBackOnClickListener(() ->

                Toast.makeText(this, "点击了一下返回按钮", Toast.LENGTH_SHORT).show()

        );

    }

• 运行app
  

  

最后

相信你对 BaseActivity 有了一些简单的了解了，具体如何使用还是得看你的项目，不是项目里就一定要写 BaseActivity 和所有 Activity 都要继承 BaseActivity ，我只是将我所理解的 BaseActivity 和大家分享一下。可能你看完了这一篇文章发现还是没能理解，在这里我想说声抱歉，可能有些地方讲的不够通俗易懂或是讲解有误，还请您多多指教，我会虚心接受并及时改正（就算是讲错了我也不会改）。

Demo的Github地址：
github.com/lmx0206/Bas…
Demo的Gitee地址：
gitee.com/Leungmx/Bas…

脚手架是什么？（What）

脚手架存在的意义？（Why）

前言

佛祖保佑， 永无bug。Hello 大家好！我是海的对岸！

实际开发中，碰到一个日历的需求，这个日历的需求中要加入定制的业务，网上没有现成的，手动实现了一下，整理记录下。

动画效果：

实现

实现背景

工作上碰到一个需求，需要有一个可以在日历上能看到每天的污染情况的状态，因此，我们梳理下需求：

1. 要有一个日历组件


2. 要在这个日历组件中追加自己的业务逻辑

简单拎一下核心代码的功能

实现日历模块

大体上日历就是看某个月有多少多少天，拆分下，如下所示：

再对比这我们的效果图，日历上还要有上个月的末尾几天

实现上个月的末尾几天

monthFisrtDay() {

      // 所指的星期中的某一天，使用本地时间。返回值是 0（周日） 到 6（周六） 之间的一个整数

      // eslint-disable-next-line radix

      const currDT = (parseInt(this.year.substr(0, 4)) + '/' + parseInt((this.month).replace('月', '')) + '/1');

      let currWeek = new Date(currDT).getDay();

      return ++currWeek || 7;

    },

    // 刷新日历 获得上个月的结尾天数 <=7

    refreshCalendar() {

      this.nunDays = [];

      const lastDays = [];

      const lastMon = (this.month).replace('月', '') * 1 - 1;

      let lastDay = new Date(new Date(this.year.substr(0, 4), lastMon).getTime() - 8.64e7).getDate();

      for (let i = 1; i < this.monthFisrtDay(); i += 1) {

        lastDays.unshift(lastDay);

        lastDay -= 1;

      }

      this.nunDays = lastDays;

    },

实现每个月的实际天数

// 展示 日历数据

    getDatas() {

      if (this.dealDataFinal && this.dealDataFinal.length > 0) {

        // console.log(this.dealDataFinal);

        this.list = [];

        const datas = this.dealDataFinal;

        const dataMap = {};

        if (datas.length > 0) {

          datas.forEach((item) => {

            item.level -= 1;

            item.dateStr = item.tstamp.substr(0, 10);

            item.date = item.tstamp.substr(8, 2);

            dataMap[item.date] = item;

          });

        }



        const curDay = new Date().getDate();

        for (let i = 1; i <= this.monthDays; i += 1) {

          let currColor = this.lvls[6];

          let dateStr = String(i);

          let isCurDay = false;

          if (i == curDay) {

            isCurDay = true; // 表示刚好是今天(该日期 和网络上的今天是同一天)

          }

          dateStr = '0' + dateStr;

          dateStr = dateStr.substr(dateStr.length - 2);

          const dataObj = dataMap[dateStr];

          if (dataObj) {

            if (dataObj.level >= 0 && dataObj.level <= 5) {

              currColor = this.lvls[dataObj.level].color;

            } else {

              currColor = this.lvls[6].color;

            }



            this.list.push({

              date: i,

              curDay: isCurDay,

              color: currColor,

              datas: dataObj,

              checkedColor: undefined, // 选中颜色

            });

          } else {

            this.list.push({

              date: i,

              curDay: isCurDay,

              color: this.lvls[6].color,

              datas: {},

              checkedColor: undefined, // 选中颜色

            });

          }

        }

        // console.log(this.list);

      } else {

        this.clearCalendar();

      }

    },

    // 清除上一次的记录

    clearCalendar() {

      this.list = [];

      for (let i = 1; i <= this.monthDays; i += 1) {

        this.list.push({

          date: i,

          color: this.lvls[6].color,

          datas: {},

        });

      }

    },