基本语法

1

print("Hello,world")

Note
声明的结尾不需要写分号

简单值

Type Infer: 类型推断

含义：编译器compiler会根据给定的值（constant、variable）自动推断value的类型。

1
2

let implicitInteger = 70 // 自动推断值是一个整型
let implicitDouble = 70.0 // 自动推断值是一个double类型

如何初始值没有提供足够的信息（或没有一个初始值），那么通过在变量后面写具体的类型类指定数据类型，中间用冒号分割。

1

let explicitDouble:Double = 79

值不会隐式转换为另一个类型，需要显式的创建一个类型的实例

1
2
3

let label = "The width is "
let width = 94
let widthLable = label + String(width)

移除String（），将会报错：
Binary operator ‘+’ cannot be applied to operands of type ‘String’ and ‘Int’

数字转字符串的写法总结

数组和字典

创建：使用方括号[]

1
2
3
4
5

var shoppingList = ["fish", "water", "vegitables"]
var occupations = [
	"Mal": "Caption",
  "Sel":"Machine",
]

创建空数组或字典

1
2

let emptyArray:[String] = []
let emptyDictionay: [String: Float] = [:]

访问：

1. 使用index
2. 使用key值

1
2

shoppingList[1] = "air"
occupations[Sel] = "Plbulic"

数组添加元素

数组会自动增长

1

shoppingList.append("blue paint")

流程控制

条件：if、switch

循环：for-in、while、repeat-while

条件和循环变量周围的圆括号可以省略，但body体周围的花括号是必须的

1
2
3
4
5
6
7
8
9

let individualScores = [56,59,60,34,12]
var teamScore = 0
for score in individualScores {
	if score > 50 {
		teamScore += 4
	} else {
		teamScore += 1
	}
}

if声明的注意事项

条件判断必须为一个布尔表达式，if score {…} 是错误的写法

if的其他用法：可选值?与??操作符

if和let一起表示值可能丢失

什么是可选值optional

value 可能有值也可以是nil

可选值写法：在一个类型后面加问号表示该值为可选值

1

var optionalString: String? = "Hello"

1
2
3
4
5

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
	greeting = "Hello, \(name)"
}

代码执行逻辑

1. optionalName 为nil,条件为false, 花括号中的代码将被跳过。
2. 否则，可选值将会被解包，分配给let后面的常量，此时解包的name值在代码块内可用。

处理可选值的方法？？操作符

??操作符

?? 用于提供默认值，如果可选值丢失，使用默认值代替

1
2
3

let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"

Switch的用法

支持任何类型的数据和各种各样的比较操作符，不限于整数和相等性测试

1
2
3
4
5
6
7
8
9
10
11

let vegetable = "red pepper"
switch vegetable {
  case "celery":
  	print("Add some raisins and make ants on a log.")
  case "cucumber", "wattercress":
  	print("That would make a good tea sandwich")
  case let x where x.hasSuffix("pepper"):
		print("Is it a spicy \(x)?")
  default: 
  	print("everything tastes good in soup.")
}

switch用法注意点：

1. default 关键字是必须有的，因为switch循环需要穷尽所有情况；
2. let能够被用在模式中匹配模式给一个常量
3. 一旦case被匹配，执行将退出，不再执行下一个case，所以不需要break声明。

for-in

可用于通过key-value对遍历数组

特点

1. 无序集合，所以键值遍历是任意的顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let interestingNumbers = [
  "Prime": [2,3,5,7,11,13],
  "Fibonacci": [1,1,2,3,5,8],
  "Square": [1,4,9,16,25],
]
var largest = 0
for(_, numbers) in interestingNumbers {
	for number in numbers {
		if number > largest {
			largest = number	
    }
	}
}
print(largest)

“_”代码占位符

.. < 表示索引循环

1
2
3
4
5

var total = 0
for i in 0..< 4 {
  total += i
}
print(tatal)

while

作用：while用于重复一段代码块直到条件改变。

条件在结尾：如果循环的条件放在结尾，那么会保证循环至少执行一次。

1
2
3
4
5
6
7
8
9
10
11

var n = 2
while n < 100 {
	n *= 2
}
print(n)

var m = 2
repeat {
	m *= 2
} while m < 100
print(m)

函数和闭包

函数

1
2
3
4

func greet(person:String, day: String) -> String {
	retrun "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

标签名命名规则

Note

默认情况下使用参数名作为参数的标签名，但可以在参数名前面自定义标签名，或者写“_”表示没有标签名

1
2
3
4

func greet(_ person: String, on day: String) -> String {
	return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

func calculateStatistics (scores: [Int]) -> (min: Int,max: Int, sum: Int) {
	var min = scores[0]
  var max = scores[0]
  var sum = 0
  
  for score in scores {
    if score > max {
      max = score
    } else if score < min {
      min = score
    }
    sum += score
  }
  return (min, max, sum)
}
let statistics = calculateStatistics(scores:[5,3,100,3,9])
print(statistics.sum)
print(statistics.2)

嵌套函数

1. 函数可以被嵌套
2. 被嵌套的函数可以访问外部函数的变量
3. 嵌套函数可以用来组织长函数或复杂函数

1
2
3
4
5
6
7
8
9

func returnFifteen() -> Int {
	var y = 10
  func add() {
    y += 5
  }
  add()
  return y
}
returnFifteen()

函数是一等公民

意味着函数可以返回一个函数作为它的值

1
2
3
4
5
6
7
8

func makeINcrementer() -> ((Int) -> Int) {
  func addOne(number: Int) -> Int {
    return 1 + number
  }
  return addOne
}
var increment = makeIncrementer()
increment(7)

函数作为函数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13

func hasAnyMatches(list: [Int], condition: (Int)-> Bool) -> Bool {
  for item in list {
    if condition(item) {
      return ture
    }
  }
  return false
}
func lessThanTen(number: Int) -> Bool {
  return number < 10
}
var numbers = [20,19,17,2]
hasAnyMatches(list: numbers, condition:lessThanTen)

如何创建闭包

函数是一种特殊的闭包，如何创建没有名称的闭包

1. 使用{}将没有名称的闭包括起来
2. 使用in将函数和返回值与主体分开

1
2
3
4

number.map({(number: Int) -> Int in
	let result = 3 * number
  return result
})

闭包的简化写法1

当一个闭包的类型是已知的，那么可以省略闭包的参数类型或返回类型或者两者。只声明闭包并隐式的返回它的值。

1
2

let mappedNumbers = numbers.map({number in 3 * number})
print(mappedNumbers)

闭包的简化写法2

• 可以通通过数字而不是名称引用参数
• 当闭包是函数的唯一参数是，可以完全省略圆括号

1
2

let sortedNumbers = numbers.sorted { $0  > $1 }
print(sortedNumbers)

对象和类

如何声明一个类

1. class关键字后面跟着一个类名
2. 类中属性的声明与常量和变量的生命相同，只是作用域是在类中
3. 类中方法、函数的声明也一样

1
2
3
4
5
6

class Shape {
  var numberOfSides = 0
  func simpleDescription() -> String {
    	return "A shape with \(numberOfSides) sides."
  }
}

如何创建一个实例

1
2
3

var shape = Shape()
shape.numbersOfSides = 7
var shapeDescription = shape.simpleDescription()

创建一个带初始化器的实例

当实例创建的时候，初始化器被创建，使用init创建初始化器

1
2
3
4
5
6
7
8
9
10
11
12

class NamedShape {
  var numberOfSides: Int = 0
  var name: String
  
  init (name: String) {
    self.name = name
  }
  
  func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
  }
}

Note:

每一个属性都需要赋值，要么在声明中，如numberOfSides, 要么在初始化器中，如name

self用于区分属性名和传给初始化器的参数名

当创建类的实例的时候初始化器会想函数的参数一样被传递

deinit析构器

创建析构器，如果你需要在对象销毁的时候执行一些清理操作

如何包含父类

• 在子类名称的后面包含父类名，以冒号区隔
• 包含父类不是必须的，所以可以根据需要决定是否添加

关于子类方法的复写

• 子类要复写父类方法，需要添加关键字override
• 如果没有添加 override，会出现编译错误
• 如果添加了override，也会出现编译错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Square: NameShapre {
  var sideLength: Double
  
  init(sideLength: Double, name: String) {
    	self.sideLength = sideLength
      super.init(name:name)
    	numberOfSides = 4
  }
  
  func area() -> Double {
    	return sideLength * sideLenth
  }
  
  override func simpleDescription() -> String {
    return "A square with sides of length \(sideLeght)."
  }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

属性的getter和setter

除了简单的属性存储，属性能有getter和setter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class EquilateralTriangle: NamedShape {
  init(sideLength: Double, name Stirng) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 3
  }
  var perimeter: Double {
      get {
        return 3.0 * sideLength
      }
      set {
        sideLength = newValue / 3.0
      }
   }
  override func simpleDescirption() -> String {
      return "An equilateral triangle with sides of length \(sideLength)."
  }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
triangle.perimeter = 9.9
print(triangle.sideLength)

Note

1. 对于perimeter的setter,有一个隐式的名称 newValue,你可以在set后面加圆括号提供一个名字
2. 注意 EquilateralTriangle有3个不同的步骤：
   1. 设置子类声明的属性值
   2. 调用父类的初始化器
   3. 改变在父类定义的属性值。任何使用方法、getter或setter的附加设置工作也在这里完成。

属性的willSet和didSet

如果你不需要计算属性，但仍然需要在设置一个新值之前或之后提供代码，可以使用 willSet 和 didSet。

当值在初始化器之外变化是，就会运行你提高的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class TriangleAndSquare {
  var triangle: EquilaterTriangle {
    willSet {
      square.sideLength = newValue.sideLength
    }
  }
  var square: Square {
    willSet {
      triangle.sideLength = newValue.sideLength
    }
  }
  init(size: Double, name: String) {
    square = Square(sideLength: size, name: name)
    triangle = EquilateralTriangle(sideLength: size, name: name)
  }
}
var triangleAndSquare = TriangleAndSquare(size: 100, name: "another test shape")
print(riangleAndSquare.square.sideLength)
print(riangleAndSquare.triangle.sideLength)
triangleAndSquare.square(sideLength: 50, name: "larger square")
print(triangleAndSquare.trianlge.sideLength)

可选值的使用与计算逻辑

当使用可选值时，你可以在方法、属性和下标操作前写 ？，如果 ？前面的值为nil，那么 ？后面的会被忽略，整个表达式的值为nil.否则，可选值被解包，获取解包值，在这种情况下，整个表达式的值是一个可选值。

1
2

let optionalSquare: Square? = Square(sideLength: 2.5, name：'optional square')
let sideLegnth = optionalSquare?.sideLength

枚举和结构体

如何创建一个枚举

使用 enum创建一个枚举，像类与其他命名类型一样，枚举有与他们相关联的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

enum Rank: Int {
  case ace = 1
  case two, three, four, five, six, serven, eight, nine, ten
  case jack, queen, king
  
  func simepleDescirption() -> String {
    switch self {
      case .ace:
      	return "ace"
      case .jack:
      	return "jack"
      case .queen: 
      	return "queen"
      case .king：
      	return "king"
      default:
      	return String(self.rawValue)
    }
  }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

Note
1.默认行的值从0开始，然后依次增长，但你能够通过复制改变。上面的例子ace被赋值为1，剩下的按递增顺序分配。

2.rawValue还可以是字符串或Float类型，此时每个case都需要声明，无法像数字一样按顺序增长

3.case的方法依然使用rawValue属性

4.注意一下，以上case, three的rawValue为3，jack的rawValue为11

枚举初始化器

使用init?(rawValue:)去从一个rawValue初始化实例。

• 当rawValue匹配时返回一个枚举case
• 当rawValue不匹配时，返回nil

1
2
3

if let convertedRank = Rank(rawValue: 11) {
  canvertedRank.simpleDescription()
}

枚举的rawValue不是必须的

枚举的case值是实际的值，并不是raw values的另一种写法，因此，在没有一个有意义的raw value的情况下，你可以不用提供。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

enum Suit {
  case spades, hearts, diamond, clubs
  
  func simpleDescription() -> String {
    switch self {
      case .spades: 
      	return "spades"
      case .hearts:
      	return "hearts"
      case .diamonds: 
      	return "diamond"
      case .clubs: 
      	return "clubs"
    }
  }
}
let hearts = Suit.hearts
let heartsDescripton = hearts.simpleDescription()

什么时候用省略形式

hearts常量的赋值使用的是全名Suit.hearts

但在switch内部，case使用的是简略形式.hearts,因为self与之相配

在其他任何时候，只要是指的类型是已知的，都可以使用缩略形式

实例决定的枚举值

如果枚举值有rawValues,这些值被决定作为声明的一部分，意味着每一个实例的某个case总有相同的枚举值。

另一种选择是让case和case的值相关联，这样值由实例决定，不同的实例它的case值是不同的。可以认为这些值是枚举实例的存储属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

enum ServerResponse {
  case result(String, String)
  case failure(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure(Out of cheese.)

switch success {
  case let .result(sunrise, sunset):
  	print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
  case let .failure(message):
  	print("Failure... \(message)")
}

结构体

struct关键字用于创建结构体，struct支持很多和类相同的行为，包含方法和初始化器。

structures 和 classes有什么不同

structures总是被copied

当类在代码中传递时，它传递的是引用

协议和扩展

使用protocol声明协议

1
2
3
4

protocol ExampleProtocol {
  var simpleDescription: String { get }
  mutating func adjust()
}

类、枚举、结构体都可以遵守协议

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class SimpleClass: ExampleProtocol {
  var simpleDescription: String = "A very simple class."
  var anotherProperty: Int = 69105
  func adjust() {
    simpleDescription += " Now 100% adjusted."
  }
}
var a = SimpleClass()
a.adjust()
let aDescirption = a.simpleDescription

struct SimpleStucture: ExampleProtocol {
  var simpleDescription: String = "A simple structure"
  mutating func adjust() {
    simpleDescription += " (adjusted)"
  }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

Note

mutating关键字声明在struct 表示修改，在class中不用声明这个关键字，因为class中本来就可以修改。

extension关键字：拓展类型的功能

使用extension给已经存在的类型添加功能，例如一个新方法或者计算属性，可以使用extension添加协议一致性给在其他地方声明的类型，或一个库或框架中导入的类型。

1
2
3
4
5
6
7
8
9

extension Int: ExampleProtocol {
  var simpleDescription: String {
    retrun "The number \(self)"
  }
  mutating func adjust() {
    self +=42
  }
}
print(7.simpleDescription)

用协议声明的属性不能使用协议外定义的方法

你可以使用protocol想使用其他任何被命名的类型一样，例如，去创建一个有不同类型的集合对象，但是他们都遵守同一个协议。当处理类型为协议类型的值是，协议之外的方法不可用。

1
2
3
4
5
6
7
8
9
10
11

class SimpleClass: ExampleProtocol {
  var simpleDescription:String = "A very simple class."
  var anotherProperty: Int = 3455
  func adjust() {
    simpleDescription += " Now 100% ajusted."
  }
}
var a = SimpleClass()
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty) // Uncomment to see error

Note
虽然protocolValue变量有一个运行时类型SimpleClass，但编译器处理它作为被给的类型ExmapleProtocol ,这意味着你不能方法协议之外，遵守该协议的类实现的属性或方法。

错误处理

错误的表示

使用遵守Error协议的任何类型表示错误

1
2
3
4
5

enum PrinterError: Error {
  case outOfPaper
  case noToner
  case onFire
}

定义一个可以抛出错误的函数

如果你在函数内抛出一个错误，函数会立即返回并调用处理函数错误的代码。

1
2
3
4
5
6

func send(job: Int, toPrinter printerName: String) throws -> String {
  if printerName == "Never Has Toner" {
    throw PrinterError.noToner
  }
  return "Job sent"
}

处理错误的方法：do-catch

do： 代码块内在一个能抛出错误的代码前面标记try

catch ：代码块内自动给一个error名字，你可以用一个不同的名字

1
2
3
4
5
6

do {
  let printerResponse = try send(job: 1040, toPrinter: "Never Has Toner")
  print(printerResponse)
} catch {
  print(error)
}

catch可以写多个用于处理具体的错误

catch之后写case和switch之后是一样的。

1
2
3
4
5
6
7
8
9

do {
  let printerResponse = try send(job: 111, toPrinter: "Tne")
} catch PrinterError.onFire {
  print("I'll just put this over here.")
} catch let printerError as PrinterError {
  print("Printer error: \(printerError).")
} catch {
  print(error)
}

错误处理方法try？

使用try？具体的错误将被放弃，并将返回nil

如果有值，则该值被返回

1
2

let printerSuccess = try? send(job:111, toPrinter: "Merge") // Job sent
let printerFalure = try? send(job:1993, toPrinter: "Never Has Toner")  // nil

defer的用法

defer的含义

见字如意，延迟代码执行，会在函数内的所有其他代码执行完成之后执行,因此可以将构建代码和清理代码写在一起，虽然他们会执行在不同的时间。

1
2
3
4
5
6
7
8
9
10
11
12
13

var fridgeOpen = false
let fridgeContent = ["milk","eggs","leftovers"]

func fridgeContains(_ food: String) -> Bool {
  defer {
    fridgeIsOpen = false
  }
  fridgeIsOpen = true
  let result = fridgeContent.contains(food)
  return result
}
fridgeContains("banana")
print(fridgeIsOpen)

泛型

如何定义一个泛型

: 在尖括号内一个名字，组成泛型函数或类型, name名字自定义

1
2
3
4
5
6
7
8

func makeArray<Item>(repeating item: Ele, numberOfTimes: Int) -> [Item] {
  var result: [Item] = []
  for _ in 0..<numberOfTimes {
    result.append(item)
  }
  return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

函数function、方法method、类class、枚举enum、结构体struct都可以使用泛型

1
2
3
4
5
6

enum OptionalValue<Wrapped> {
  case none
  case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possbileInteger = .some("100")

where的用法

where可用于在body前面指定一些条件，比如实现一个protocal,要求两个类型相同，或者要求一个类有特殊的父类。

1
2
3
4
5
6
7
8
9
10
11

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool 
where T.Element: Equatable, T.Element == U.Element{
  for lhsItem in lhs {
    for rhsItem in rhs {
      if lhsItem == rhsItem {
        return true
      }
    }
  }
  return false
}

Note
<T: Equatable> 与 … where T: Equatable是相同的。

大纲概览

reference
a swift tour

构建环境：
macOS 10.15.7

vs code 1.60.2

报错：PhantomJS not found on PATH
下载时会提示：saving to ../var/folders/…/ phantomjs-2.1.1-macosx.zip

1. 重点是：var/folders这个文件在哪里？
   其实这是个隐藏文件，在磁盘的根目录，和Library、Applications 文件夹在同一层次。需要先显示隐藏文件，然后按图索骥即可。

2. 找到文件夹后，做第二件事，下载时会在后台提示一个下载目录：https//github.com…/ phantomjs-2.1.1-macosx.zip
   打开这个链接，直接下载zip文件，放到刚刚那个路径文件夹即可。

3. 最后一步，再次执行npm install即可。

配置环境
macOS：macOS Catalina 10.15.7

Safari：15.0

Xcode：12.4

Simulator：iOS14.4

问题

使用模拟器打开Web页面后，发现Safari控制台一片空白，如下：

解决

查了一下原因，发现下载Safari Technology Preview 可以解决。但官方提供的版本Safari Technology Preview for macOS Big Sur需要macOS 11，公司的Mac系统还无法支持这个版本，即无法升级Mac，后来发现Archive的网站上有各种版本的备份，找了个合适的，搞定。

下载地址：Technology Preview for macOS Catalina

启动Safari Technology Preview 运行效果：

参考：

Donwload link for older Safari Technology Preview version

什么是算法

通俗来说，算法是任何定义良好的计算过程，包含了一些输入值input，和一些输出值ouput,算法是描述输入与输出关系的计算过程的实现。

为什么算法是值得学习的

这需要从算法能解决什么问题说起，算法的应用无所不在，不仅仅局限于计算机领域。

• 人类基因工程要在三亿基因对中识别100000个组成人体的DNA信息。保存这些信息到数据库，开发数据分析工具，每一步都需要复杂的算法。
• 因特网能够在全世界快速的访问和检索大量信息，借助聪明的算法的帮助，因特网上的网站能够管理和维护大量的数据。算法来发现更好的数据传输路径。针对特定问题搜索引擎快速的发现页面。
• 电子商务中货物和服务能够被线上交换和协商。它依赖的个人隐私信息例如：卡号，密码，开户行信息 。被用于电子商务的核心技术包括公钥密码和数字签名，是基于数字算法和数字理论。
• 制造业和其他的实体经济常常需要以最优方式分配有效的资源，一家石油公司可能希望知道哪个地方获利最大，一个潜在的获选人可能需要去决定为了最大化的赢得选举机会把钱花在哪里来购买竞选广告。一家航空公司有可能希望分配它们的员工到航班以尽可能的方式最小化人员开支，来保证每个航班都有人员覆盖,并且符合政府关于人员调度的规定。一个网络服务的提供者可能需要去决定往哪个地方分配额外的资源以便更高效的服务客户。所有的这些问题都将在线性规划问题中被解决。
• 一个道路地图，从A点到B点，有无数种到达方案，哪一条路是最短的，算法将解决这一问题。

算法和其他计算机相关技术的关系是什么

如果计算机的运行可以无限快并且存储空间是无限的，你是否还需要算法呢，答案是YES，因为你不只是想在计算资源的边界内做事，你还常常想找出哪些方法是最容易实现的方式。

然而，计算机的运行时间是有边界的，存储空间也一样。如何更聪明的使用这些资源，算法将帮助我们如何更高效的利用时间和空间。

算法和计算机硬件一样，是一种技术，整个系统的性能既依赖于快速硬件也依赖于高效的算法。正如其他计算机技术在快速发展，算法也一样。

你可能会惊讶，算法在现代计算机上，与其他先进技术相比是否真的重要，例如：

• 先进的计算机结构和制作技术
• 易用、直观，图形化的用户界面
• 对面对象系统
• 集成的web技术
• 快速的网络，有线和无线

答案是YES，虽然一些应用没有在应用层面直接明确的要求算法（例如一些简单的，基于web的应用）。但很多需要，例如，考虑一个基于web的服务决定如何从一个位置传递到另一端。它的实现依赖于快速硬件，一个图形化的界面，广域网络，并且也可能依赖于面对对象系统。然而，对于具体的操作，也依赖于算法，例如发现路由（可能使用最短路径算法），渲染地图，插值处理。

此外，即使一个应用不在应用层面要求算法也严重依赖上面的算法。应用依赖快速硬件吗，硬件就是用算法设计的。应用依赖于图形界面吗？任何图形界面的设计都依赖于算法。应用依赖于网络吗？网络中的路由严重依赖算法。应用是用一种语言编写而不是机器码？然后他可能被编译器、解释器或汇编器处理，所有这些都广泛的使用算法。算法是被用于当代计算机的最核心技术。

更进一步，不断增长的计算机容量，我们可以使用他们去解决比以前更大的问题。例如，当数据量变大的时候，插入排序与合并排序在效率上有显著的不同。

拥有稳固的算法基础和技术是将新手和真正有技术的程序员区分开的标志。用现代计算机技术你能完成一些任务而不用知道太多的算法知识，但有一个好的算法背景，使你可以做更多的事情。

背景

公司产品需要自定义弹窗。而弹窗的背景图片是根据屏幕的宽高自动缩放的，如下：

1
2

#define ALERTVIEW_HEIGHT ([UIScreen mainScreen].bounds.size.width - 60)*1.05
#define ALERTVIEW_WIDTH  [UIScreen mainScreen].bounds.size.width-60

而弹窗上的标题，即‘恭喜’两个字并不是图片，是写上去的，代码如下：

1

UILabel *titleLab = [[UILabel alloc]initWithFrame:CGRectMake(10, 38, self.alertView.frame.size.width - MARGIN, 30)];

这里我给了它距离弹框顶部一个固定的间距，iPhone 6s 模拟器上效果如下：

以下是iPhone 11 模拟器下的效果：

简单点说，iPhone11下字体上移了。这个固定的尺寸不随屏幕的宽高呈现比例变化，那我们如何定义它的高度，以便标题在不同屏幕尺寸下都在中间位置呢。

实现动态高度

此时我们引入一个计算动态高度的宏定义：

1

#define getHeight(h) ((h)*([UIScreen mainScreen].bounds.size.width/414.0f))

在iPhone 11上调试一个合适的高度，这里不再是固定高度，而是使用了刚刚定义的宏动态高度getHeight(40)：

1

UILabel *titleLab = [[UILabel alloc]initWithFrame:CGRectMake(10, getHeight(40), self.alertView.frame.size.width - MARGIN, 30)];

效果如下：

然后我们在切换回iPhone 6s 模拟器下：

大体一致了，类似的实现还可以定义宽度和字体：

1
2

#define gotWidth(w) ((w)*([UIScreen mainScreen].bounds.size.height/896.0f))
#define fontHeight(f) ((f)*([UIScreen mainScreen].bounds.size.width/414.0f))

Cordova的目标是使用一份代码构建多个平台，形式是使用HTML，CSS和JS构建移动应用。

1.安装cordova

Cordova的命令行是运行在Node.js上的，并且在npm上是可用的。第一步是安装cordova框架：

1

$ npm install -g cordova

2.创建工程

导航到你想要创建工程的目录：

1

$ cordova create CordovaApp

3.添加一个平台

导航到工程目录，你需要添加一个平台,这里以iOS为例

1
2

$ cd CordovaApp
$ cordova platform add ios

以下是工程创建之后的目录，这是一份web工程的目录结构：

package-lock.json:
我实在不知道如何介绍它，自己看好了npm-package-lock.json
package.json:

• 包含你工程的依赖包，比如Cordova下载的官方插件
• 指定了你工程的包的版本，默认初始值为：1.0.0，该命名符合语言版本的规则
• 这个文件使你的构建是可复制的，因此你可以很容易的分享给你的开发者

node_modules: node安装包
plugins：所安装的插件
platforms：发布的平台，如iOS，Android
www：web源码所在的文件
hooks:配置脚本命令的地方
config.xml: 全局配置文件，控制Cordova的行为。

如上，是platforms的文件夹，我们刚刚添加了iOS这一个平台。这里面有几个重要的文件夹：
build：构建文件包
HelloCordova：编译出来的Objective-C代码
www:每次编译之后会被外层的www文件夹覆盖更新
HelloCordova.xcodeproj:是Xcode的入口打开文件，安装cocoapods之后，入口文件改为HelloCordova.xcworkspace, cocoapods使用同层的podfile文件管理你的第三方库，相关文件还包括pods.json,pods-release-xcconfig,pods-debug.xcconfig
platform_www:平台安装的插件所在.
cordova: Cordova在iOS平台下的构建运行时环境
CordovaLib：Cordova的库文件
iOS.json：iOS平台的配置文件
frameworks.json：iOS平台的框架配置文件

接下来我们看一下HelloCordova文件，为编译出来的Objective-C代码，不了解的同学可以了解一下：
main.m: 程序的入口文件
config.xml：内含iOS程序的一切配置信息
HelloCordova-Prefix.pch：桥接文件，内含程序引入的库信息头
HelloCordova-Info.plist: iOS程序的权限信息配置文件，比如你想使用相机，就在这里配置权限
Scripts：Cordova程序的构建编译脚本
Plugins：.h和.m结尾的插件文件
Images.xcassets：图片资源，存放比如程序的图标，启动图等图片
Entilements-Release.plist: 发布包的信息配置文件
Entilements-Debug.plist：开发调试包的信息配置文件
Classes：Objective-C 源代码，目前包含AppDelegate和主页文件，由配对的.h和.m文件组成
CDLaunchScreen.storyboad：用于配置程序的启动图
Bridging-Header.h：桥接头文件，目前导入了#import <Cordova.h>

最后我们看一看这个www文件夹：
默认的web程序入口文件是index.html,一切交互事件的入口文件是js/index.js。

4.运行你的app

1

$ cordova run ios

需要提前安装Xcode，Xcode会自动携带模拟器，运行完毕。你会看到Xcode的启动界面。类似如下：

5. 测试你的应用

1

$ corodva emulate ios

以上命令可以在模拟器上重建你的应用，来测试交互。

6.添加插件

我们可以使用标准的web技术修改默认App，但如果想访问设备级别的功能，我们需要插件。

插件为原生的SDK功能提供了一个JS接口。

npm上有一些插件，你可以搜索他们，Apache Cordova提供了一些核心插件API。

可以使用如下命令搜索这些插件

1

cordova plugin search camera

可以使用npm上的包名安装插件：

1

cordova plugin add cordova-plugin-camera

插件也可以使用目录或git repo安装

可以使用plugin ls查看安装的插件：

1
2
3
4
5

$ cordova plugin ls
cordova-plugin-camera 4.1.0 "Camera"
cordova-plugin-contacts 3.0.1 "Contacts"
cordova-plugin-device 2.0.3 "Device"
cordova-plugin-whitelist 1.3.4 "Whitelist"

7.更新Cordova和你的工程

查看当前Cordova版本

1

$ cordova -v

查看npm上Cordova的最新版本

1

$ npm info cordova version

更新cordova的版本

1

sudo npm update -g cordova

安装特定的Cordova版本

1

sudo npm update -g cordova@6.14.5

参考：
create your first app

模拟器连接Charles的步骤

1. 重置你的模拟器确保你没有老的或旧的证书。
2. 在Charles菜单，选择Help > SSL Proxying>Install Charles Root Certificate in iOS Simulators。
3. 重启模拟器。
4. 确保你能够监听到电脑的通信，去菜单Proxy，选择macOS Proxy。
5. 在Charles，确保你想要测试的URLs已经启用了SSL Proxying，去菜单Proxy>SSL Proxy Settings…，添加你感兴趣的URLs，使用*号代表通配。
   否则会出现如下乱码：
   
   正确配置后显示正常：
   

注意：
如果按如上配置仍然无效，可自行检查
1.是否已开启其他代理或科学上网工具，请关闭；
2.保证Charles在模拟器之前打开。

使用场景

请求模拟

比如模拟503/504请求返回：

1. 打开菜单 Tools > Rewrite… 选项。
2. 如上图，在右侧边栏的上面写你要测试的URL，下方写你要模拟的返回，这里我们把200状态码替换为503，如下：

注意：
原来模拟503状态码想使用Map Remote跳转到一个报503的URL，这样使用AFNetworking抓取的网络状态码是0，需要使用如上重写HttpStatus的方式

请求设置断点

1.运行你的程序。
2.查看Charles请求列表。
3.选择你需要设置断点的请求，右击鼠标，在弹出的菜单中选择Breakpoints。

当然如果你的请求参数每次都变化，你可能更适合这种方式，否则下次运行抓取不到断点：
1.选择菜单：Proxy > BreadpointSettings…

2.双击你刚刚设置断点的URL，去掉变量参数。点击OK即可。

3.重新运行程序，程序会停在这个请求处。这里可以选择取消本次断点、中断请求、或继续请求。

参考：
How to Set Up Charles Proxy for an iOS Simulator
Using Charles Proxy to test different HTTP Response Codes

面向对象的概念

面向对象（Object Oriented）：是软件开发方法；是一种对现实世界理解和抽象的方法。是计算机编程技术发展到一定阶段后的产物。
面向对象的方法：就是利用抽象、封装等机制，借助于对象、类、继承、消息传递等概念进行软件系统构造的软件开发方法。

面向对象涉及的基本概念

对象：某一具体事物，即在现实生活中可以看得见摸得着的事物。对象是数据和行为的结合体。
方法：对象能够进行的操作。它另外一个称呼函数。
继承：简单来说是一种层次模型，这种层次模型能够被重用。层次结构的上层具有通用性，下层具有特殊性。
类：具有相同特性（数据元素）和行为（功能）的对象的抽象。对象的抽象是类，类的具体化是对象。也可以说类的实例是对象。类实际上就是一种数据类型。
封装：将对象和代码捆绑到一起。实现了对数据和行为的包装和信息隐藏。
多态：不同事物具有不同表现形式的能力。多态使具有不同内部结构的对象可以共享相同的外部接口。
动态绑定：多态实现的具体形式，指与给定的过程的调用相关联的代码只有在运行期才可知的一种绑定。
消息传递：对象之间需要相互沟通，沟通的途径就是对象之间收发消息。消息的内容包括接收消息的对象标识、需要调用的标识、以及必要的信息。消息传递的概念使得对现实世界的描述更容易。

面向对象的来源

早期的计算机编程是基于面向过程的方法，随着计算机技术的不断提高，计算机被用于解决越来越复杂的问题。一切事物皆对象，通过面向对象的方式，将现实世界的事物抽象成对象，现实世界中的关系抽象成类、继承，帮助人们实现对现实世界的抽象与建模。

面向对象是在结构化设计方法（面向过程）出现很多问题的情况下应运而生的。结构化设计方法它求解问题的基本思路是从功能的角度审视问题域，它与我们人类解决问题的方式存在视角偏差、抽象度不够、没有整体封装、可复用性差等特点，从而面向对象的程序设计方法由此产生。

1967年5月20日，在挪威奥斯陆郊外的小镇莉莎布举行的IFIP TC-2 工作会议上，挪威科学家Ole-Johan Dahl和Kristen Nygaard正式发布了Simula 67语言。Simula 67被认为是最早的面向对象程序设计语言，它引入了所有后来面向对象程序设计语言所遵循的基础概念：对象、类、继承。之后，在1968年2月形成了Simula 67的正式文本。

易混概念

面向对象 VS 基于对象

简单来说：面向对象具有三大特点：封装、继承、多态，三者缺一不可。
而基于对象实现了封装概念，没有实现继承和多态。

对象过程 VS 面向对象

面向过程：分析问题所需要的步骤，而后一步一步实现。
面向对象：把构成问题的事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

定义开发环境变量

项目根目录下，新建.env.development文件，用于开发环境。

1

VUE_APP_PUBLIC_PATH=/data/manageplatform/mallmanagertest/

这里VUE_APP_前缀名称是固定的，不可以改变，这里我们以定义一个公共文件路径为例说明。

定义生产环境变量

项目根目录下，新建.env.production文件，用于产生环境。

1

VUE_APP_PUBLIC_PATH=/data/manageplatform/mallmanagerrelease/

使用环境变量

例如：我们在vue.config.js下使用该变量。

1
2
3

module.exports = {
  publicPath: process.env.VUE_APP_PUBLIC_PATH
}

process.env.APP_PUBLIC_PATH会在项目启动时自动加载，但问题是它怎么知道使用哪个环境的路径呢，所以我们还需做如下配置。

配置启动命令

在 package.json文件中，配置scripts启动脚本。

1
2
3
4
5

"scripts": {
    "serve": "vue-cli-service serve",
    "dev": "vue-cli-service build --mode development",
    "build": "vue-cli-service build"
  },

npm run serve: 启动本地环境，可用于本地调试。
npm run dev: 打包构建，这里我们指定了 --mode development，意味着我们在开发环境，此时.env.development相关配置生效。
npm run build: 打包构建，如果没有指定mode，默认构建生产环境，所以我们的.env.production相关配置生效。当然，我们也可以手动指定 --mode production。

小结

综上，
对于开发环境部署，使用npm run dev构建版本，
对于生产环境部署，使用npm run build构建版本。

在进行前端WEB页面开发的过程中，有时会碰到请求返回500的情况，这意味着服务器端内部出现了错误，一般碰到这种情况，都丢给后端开发人员来解决。他们一般要求给出请求URL、请求参数和返回值等信息。

但当Status Code：500的时候，我们发现在Chrome下，响应信息是这样的：

在Response栏，显示没有可用的响应数据。这个时候会直接告诉后端开发人员没有返回数据，让他们自己解决，没有细究Chrome无法获取响应的原因。

但今天发现同样的请求在Postman下是可以获取响应信息的：

这些响应信息有助于后端开发人员快速排查错误，于是决定查一下问题的原因，最初的想法是看看Chrome浏览器是否能够显示500的响应信息，是不是需要设置什么东西或利用第三方插件，如果能直接查看最好，省去了Postman再走一遍请求。

最先查看了一下Chrome Developers下的Network主题，似乎没有涉及相关内容。于是求助于Google搜索，看到这个解释：Unable to load response for 500 internal server error in chrome，具体看第一个回答。大意是这是Chrome本身的问题，如果响应块没有正确的结束，那么Chrome就不会读取它，但是Firefox和Safari内部处理了这个问题，这就清楚了，因为服务端出现了500内部错误，响应流被中断，没有完整的响应，自然无法读取。文中给出了由后端人员来解决这个问题，这超出了我们讨论的范畴，我们先看看在Safari下的响应结果：

没错，的确可以查看，那么问题的答案就很清楚了。下次出现500错误，想给后端开发人员提供响应信息的时候，你有两种解决方案：在Safari或Firefox浏览器下运行程序，查看返回；或使用Postman等第三方请求模拟工具获取，至于Chrome本身是不支持查看500响应的。

后记于2020-02-03 晚上 11：26分 北京东亚创展国际（修正结论）

今天是春节过后第一天上班，真的是十分囧呀。本来打算把上面的这篇文章发blog而后在公众号上发一个副本后睡觉。

可刚刚竟然发现测试环境下500状态码是可以查看响应的，仔细查看了一下测试环境和本地环境两者的区别，发现我之前的观察和结论是有误的：

我们先来看一下本地环境下Console的打印：

我们再来看一下测试环境下Console的报错打印：

那么测试环境和本地环境到底有什么不同呢，本地环境使用localhost:8080访问URL，由于服务器的请求URL域名和我本地的localhost域名不同，因此服务端是需要做跨域配置的。而测试环境直接使用http://activity.delightful**域名头访问网站，在当前数据请求URL与网站地址域名一致，因此不需要做跨域配置。

在本地环境下，由于需要做跨域配置，因此请求会发送两次，一次返回204允许跨域，而后返回响应数据。而在第二次返回响应数据的时候，由于服务端发生错误，因此响应头并未配置跨域信息，所以报了跨域被阻止，

正常情况下应该是如下这样的，注意Response Headers栏：

由于跨域被阻止，自然没有返回数据，因此本机环境没有响应信息。而测试环境，不存在跨域问题，所以直接返回了500错误，并可以查看响应。

综上：不能查看响应的原因是本地环境下，由于请求失败，缺失跨域所需要的响应头，因此响应被浏览器拦截。因此无法查看响应。与Chrome浏览器无关。