swift4.0语法杂记（精简版）

"??".count // 人 + 肤色
"?‍?‍?‍?".count // 有4个成员的家庭
"??\u{200D}??\u{200D}??\u{200D}??".count // 家庭 + 肤色
"??‍?".count // 人 + 肤色 + 职业

var x = 10;
let y = 20;

let z   //错误示范，let z 在声明的时候并没有赋值常量是不可改变的，只能在声明时赋值

let z = UIView()
print(z)

//错误示范
let a = 10
let b = 12.5
print(x + y)

let a = 10
let b = 12.5
print(a + Int(b))

print(Double(a)+b)

let str = "小仙女"
let str1:String = "hahh"

let str = "小仙女"
let mesg1 = "one"+str //用加号的方式
let mesg2 = "two,\(str)" //反斜杠的方式
print(mesg1,mesg2)

let min = 2
let second = 10

String(format: "%02d:%02d", min,second)

for c in str{
    print(c)      //swift4中的遍历
}
print(str.count)  //打印字符串长度

for char in myString.characters {
    print(char)   // swift3的遍历
 } 
print(str..characters.count)  //swift3打印字符串长度

let urlStr = "www.baidu.com"
let header = (urlStr as NSString).substring(to: 3)  //截取前三位

let middle = (urlStr as NSString).substring(with: NSMakeRange(4, 5))//去除前四个字符截取，范围之后五位字符

let footer = (urlStr as NSString).substring(from: 10)   //从第十个字符开始截取

let x:Optional = 10
print(x)

let x:Optional = 10  //第一种写法

let x:Int? = 20     //第二种写法
print(x)

print(x!+y!)

//错误示范1
let y : Int?
print(y)

//错误示范2：
let y : Int? = nil
print(y)

//默认值测试
let x: Int?
print(x)
var y :Int?
print(y)

let url: URL? = URL(string: "https://www.baidu.com")

if let url = url {
    let request = URLRequest(url: url)
}

let x = 9
if x > 5 {
    print("小仙女")
}else{
    print("妖精哪里跑")
}

let x = 10
x > 5 ? print("小仙女"):print("妖精")

x > 5 ? print("你都写了我两次啦"):()

let x:Int? = nil
let y:Int? = 9
print((x ?? 0) + (y ?? 0))

let name:String? = "安琪拉"
print((name ?? "") + "火烧屁屁咯")
print(name ?? "" + "火烧屁屁咯")

import UIKit
let age = 20
func online(age : Int){
    guard age >= 18 else {
        print("还未成年呢")
        return
    }
    print("一起来开黑吖")
}

let age = 20
let money = true
let idcard  = true
func online2(age : Int,money:Bool,idcard:Bool){
    if age >= 18 {
        if money {
            if idcard {
                print("一起来开黑吖")
            }else{
                print("回去带身份证吧")
            }
        }else{
             print("回去拿钱")
        }
    }else {
        print("还未成年呢")
    }
}
//调用
online2(age: age, money: money, idcard: idcard)

func online1(age : Int){
    //判断年龄
    guard age >= 18 else {
        print("还未成年呢")
        return
    }
    //判断是否有钱
    guard money else {
        print("回去拿钱")
        return
    }
    //判断是否带了身份证
    guard idcard else {
         print("回去带身份证吧")
        return
    }
    print("一起来开黑吖")
}

let sex = 0
switch sex {
case 0:
    print("男")
case 1:
    print("女")
default:
    print("其他")
}

case  0:
    print("男")
    fallthrough

let sex = 0
switch sex {
case  0,1:
    print("正常人")

default:
    print("其他")
}

switch 3.14 {
case  0:
    print("正常人")

default:
    print("其他")
}

let opration = "+"
switch opration {
case  "+":
    print("加法")
case "-":
    print("减法")
default:
    print("其他")
}

func demo1() {
    for i in 0..<5 {
        print(i)
    }
    print("^^^^^^^")
    
    for i in 0...5 {
        print(i)
    }
}
demo1()

func demo1() {
    for i in (0..<5).reversed() {
        print(i)
    }
    
}
demo1()

//定义不可变数组
let array = ["爱丽丝","小红帽","白雪公主"]

//定义可变数组
var arrayM = [String]()
var arrayM1:[String]
var arrayM2 = Array<String>()

var threeDouble = Array(repeating: 0.0, count: 3)
print(threeDouble[1])

arrayM.append("1")
arrayM.append("2")
arrayM.append("3")
arrayM.append("4")
arrayM.append("5")

arrayM.insert("10", at: 2)

arrayM.remove(at: 0)
arrayM.removeSubrange(1..<3)
arrayM.removeAll()
arrayM.removeLast() //可以去除最后一项，避免捕获数组count属性

arrayM[0] = "小红帽"
print(arrayM[2])

//替换第2项和第3项的值
arrayM[2...4] = ["22","33"]
print(arrayM[3])

//根据下标值进行遍历
for i in 0..<arrayM.count {
    print(arrayM[i])
}
//直接遍历数组中的元素
for i in arrayM {
    print(i)
}

for(index,value) in arrayM.enumerated(){
    print(String(index+1)+":"+value)
}

let resultArray = arrayM + array

//创建空集合
var letters = Set<Character>()
//使用字面量创建集合
var favorite:Set<String> = ["绮罗生","意琦行"]

var favorite:Set = ["绮罗生","意琦行"]

favorite.insert("寒烟翠")
print(favorite.count)

if let removeBack = favorite.remove("意琦行"){
    print(removeBack)
}else{
    print("没有找到值")
}

print(oddD.union(evenD).sorted()) //并集

print(oddD.intersection(evenD).sorted())//交集

print(oddD.subtracting(siggleDPrime).sorted())//取差值

print(oddD.symmetricDifference(siggleDPrime).sorted())//去掉相同值

for item in favorite {
    print(item)
}
//按照首字母的顺序输出
for item1 in favorite.sorted() {
    print(item1)
}

let dict = [1:"one",2:"two",3:"three"]  //定义不可变字典

var dictM = Dictionary<String,NSObject>()  //定义可变字典
var dictM1 = [String:NSObject]()

//AnyObject一般用于指定类型，NSObject一般用于创建对象

dictM1["name"] = "小仙女" as NSObject
dictM["age"] = 17 as NSObject
dictM.removeValue(forKey:"name")
//获取：swift中只保留了最简单的写法，OC中有objectforkey的方法在swift中也被删除掉了。
dictM["name"]  

dictM["name"] = "llx"

for (key,value) in dictM {
    print(key)
    print(value)
}

var dict1 = ["name":"llx","age":"17"]
var dict2 = ["num":"007"]

for (key,value) in dict2 {
    dict1[key] = value
}
dict

//使用元组来描述个人信息
let info1 = ("1001","张三",30)

//给元素加上名称，之后可以通过元素名称访问元素
let info2 = (id:"1001",name:"张三",age:30)
info2.name

let (name,age) = ("张三",18)
name

func 函数名（参数列表）-> 返回值类型 {
    代码块
    return 返回值
}

func phone()->Void {
    print("小米")
}
phone()

func phoneNum() -> String {
    return "123456"
}
 print(phoneNum())

func callPhone(phoneNum:String){
    print("打电话给\(phoneNum)")
}
callPhone(phoneNum: "123456")

func sum(num1 : Int,num2 : Int) -> Int{
    return num1 + num2
}
sum(num1: 30, num2: 30)

func sum(number1 num1: Int,number2 num2 : Int) -> Int{
    return num1 + num2
}
sum(number1: 2, number2: 4)

func makeIceCream(flavor:String = "原味") -> String {
    return "制作一个\(flavor)冰淇淋"
}
makeIceCream()
makeIceCream(flavor: "抹茶")

func sum(num:Int...) -> Int {
    var result = 0
    for i in num {
        result += i
    }
    return result
}
sum(num: 18,29,3)

func swapNum1( m : inout Int, n : inout Int) {
    let tempNum = m
    m = n
    n = tempNum
}
swapNum1(m: &m, n: &n)
print("m:\(m),n:\(n)")

class 类名:SuperClass {
    //定义属性和方法
}

class Person : NSObject {
    //定义存储属性
    var age : Int = 0
    var name : String? //对象的属性必须赋值,不赋值会报错的哦
}
let p = Person()

p.age = 10
p.name = "llx"
if let name = p.name {
    print(name)
}

// 定义方法，返回平均成绩
func getAverage() -> Double {
        return (mathScore + EnglishScore)*0.5
    }

let average = p.getAverage()

var averageS : Double {
        return (mathScore + EnglishScore) * 0.5
    }

    static var courseCount : Int = 0

Person.courseCount = 2

class Person : NSObject {
    var name : String?
    var age : Int = 0
    
    override init() {
        print("hello world")
    }
}
let p = Person()

class Person : NSObject {
    var name : String?
    var age : Int = 0
    
    // 自定义构造函数
    init(name:String,age:Int){
        self.name = name
        self.age = age
    }
}
// 调用自定义的构造函数
let p1 = Person(name: "kaka", age: 12)
print(p1.age)

class Person : NSObject {
   @objc var  name : String?
   @objc var age : Int = 0
    
    
    init(dict:[String : Any]) {
        super.init()
   // 要调用系统的`setValue`方法就必须先调用系统的构造函数创建出对象
        setValuesForKeys(dict)
    }
    // 防止奔溃
    override func setValue(_ value: Any?, forUndefinedKey key: String) {
    }

}

let p2 = Person(dict:["name":"lala","age":18,"score":33])
p2.name
p2.age

class Person : NSObject {
    //属性监听器
    var name:String? {
        willSet {
            print(name as Any)
            //如果想要查看接下来的新值，可以使用newValue
            print(newValue as Any)
        }
        didSet {
           print(name as Any)
        }
    }
}

let p = Person()
p.name = "llx"

let b1 = {
  print("干掉他们")
}
b1()

let b2 = {
    (x:String)->() in print(x)
}

b2("string")

class HttpTool: NSObject {
    //闭包类型:(参数列表)->(返回值类型)
   
    func loadData(callback:@escaping(_ jsonData : String)->()) {
        DispatchQueue.global().async {
            print("发生网络请求:\(Thread.current)")
        }

        
        DispatchQueue.main.async {
            ()->Void in
            print("获取到数据，并且回调：\(Thread.current)")
            
            callback("jsonData数据")
        }
    }
}

import UIKit

class ViewController: UIViewController {

    var tools : HttpTool = HttpTool()
    
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        //用闭包将json数据拿到
        tools.loadData { (jsonData) ->() in
            print("在viewcontroller中拿到数据\(jsonData)" )
        }
    }

}

//这个函数接受一个String和一个闭包
//函数体内调用闭包，并且将String作为参数传递给闭包
func myFunc(strP:String,closeP:(String)->Void) {
    closeP(strP)
}

//普通调用
myFunc(strP: "hello", closeP: {(string) in print(string)})
//尾随闭包
myFunc(strP: "hello") {
    (string) in print(string)
}

 //定义数组，里面的元素都是闭包类型的
var callBackArray : [()->Void] = []

//定义一个接收闭包的函数
func testEscapingClosure(callBack:@escaping ()-> Void) {
    callBackArray.append(callBack)
}

class SomeClass {
    var x = 10
    
    func doSomething(){
        testEscapingClosure {
            self.x = 100
        }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
callBackArray.first?()
print(instance.x)

weak var weakself = self

[weak self]

[unowned self]

//懒加载只能用于结构体或者类的成员变量中
class Person:NSObject {
    lazy var array : [String] = {
        ()->[String] in
        return ["llx","lll"]
    }()
}

class ViewController: UIViewController {
    
    lazy var tableView:UITableView = UITableView()
    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(tableView)
       
        }
}

tableView.frame = view.bounds

class ViewController: UIViewController ,UITableViewDataSource,UITableViewDelegate{
    
    lazy var tableView:UITableView = UITableView()
    override func viewDidLoad() {
        super.viewDidLoad()
       
        view.addSubview(tableView)
        tableView.frame = view.bounds
        //设置数据源
        tableView.dataSource = self
        tableView.delegate = self
    }
  }

 func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return 20
    }

 func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let CellID = "CellID"
        var cell = tableView.dequeueReusableCell(withIdentifier: CellID)
        if cell == nil {
            cell = UITableViewCell(style: .default, reuseIdentifier: CellID)
        }
        cell?.textLabel?.text = "测试数据:\(indexPath.row)"
        return cell!
    }

 func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        print("点击了：\(indexPath.row)")
    }

class ViewController: UIViewController ,UITableViewDataSource,UITableViewDelegate{
    // MARK:- 懒加载
    lazy var tableView:UITableView = UITableView()
    // MARK:- 系统回调函数
    override func viewDidLoad() {
        super.viewDidLoad()
        }
    }

enum SomeEnum {
    // 在这里定义枚举
    case north
    case south
    case east
    case west
}

enum Plant {
    case mercury,earth,mars
}

var directionT = SomeEnumeration.west

directionT = .east

class Person:NSObject{
    var directionT = SomeEnum.west
   
    func direc()  {
        switch directionT {
        case .north:
            print("north")
        case .east:
            print("east")
        default:
            print("没有方向")
        }
    }
}

enum BarCode {
    case upc(Int,Int,Int,Int)
    case qrCode(String)
}

class Person:NSObject {
    // 创建一个名为pBar变量，并将Barcode.upc赋值给它。
    func function() {
        var pBar = BarCode.upc(9, 0, 3, 3)
        pBar = .qrCode("ABCD")
    }
    
}

enum ASCIICHAR : Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}

enum Planet : Int {
    case mercury = 1, venus,earth,mars
}

let earthsOrder = Planet.earth.rawValue

indirect enum Ari {
    case number(Int)
    case addition(Ari,Ari)
    case multi(Ari,Ari)
}

let five = Ari.number(5)
let four  = Ari.number(4)
let sum = Ari.addition(five, four)
let product = Ari.multi(sum, Ari.number(2))

struct teacher {
    var name : String = ""
    var age : Int  = 30
}

  extension 某个现有的class {
    //添加新功能
  }

extension String {
    func sayHello() {
        print("Hello from extension")
    }
}

var hello = "hi"
hello.sayHello()

extension Int {
    var squared : Int {
        return (self * self)
    }
}

var newInt = 30
newInt.squared
999.squared

class Lisa {
    var lisa = "半边天使"
}

extension Lisa {
    func describe() -> String {
        return "我可是会傲娇的"
    }
    
}

 var stringArray = ["Hi", "Hello", "Bye"]
 var intArray = [1,2,3]
 var doubleArray = [1.1,2.2,3.3]

func printStringFromArray(a: [String]) {
      for s in a {
print(s) }
}
  func printIntFromArray(a: [Int]){
      for i in a {
print(i) }
}
  func printdoubleFromArray(a:[Double]) {
      for d in a {
print(d) }
}
  printStringFromArray(a: stringArray)
  printIntFromArray(a: intArray)
  printdoubleFromArray(a: doubleArray)

func printEelementFormArray<T>(a:[T]){
    for element in a {
              print(element)
          }
      }

protocol People {
    
}

struct Lisa: People {
    
}

protocol People {
    var name: String {get set}
    var race: String {get set}
    func sayHi()
}

struct Lisa: People {
    var name: String = "Lisa"
    var race: String = "Asian"
    func sayHi() {
        print("Hi~, I'm \(name)")
    }
}

protocol superman {
      var canFly: Bool {get set}
      func punch()
}

protocol superman: People {
      var canFly: Bool {get set}
      func punch()
}

struct AngleLisa: superman {
var name: String = "Lisa"
var race: String = "Asian"
func sayHi() {
    print("Hi, I'm \(name)")
}
var canFly: Bool = true
func punch() {
    print("punch  Vergil")
}
}

struct Date: Equatable, Comparable {
    private let secondsSinceReferenceDate: Double
    static func ==(lhs: Date, rhs: Date) -> Bool {
        return lhs.secondsSinceReferenceDate == rhs.secondsSinceReferenceDate
    }
    static func <(lhs: Date, rhs: Date) -> Bool {
        return lhs.secondsSinceReferenceDate < rhs.secondsSinceReferenceDate
    }
}

struct Date {
    private let secondsSinceReferenceDate: Double
}
extension Date: Equatable {
    static func ==(lhs: Date, rhs: Date) -> Bool {
        return lhs.secondsSinceReferenceDate == rhs.secondsSinceReferenceDate
    }
}
extension Date: Comparable {
    static func <(lhs: Date, rhs: Date) -> Bool {
        return lhs.secondsSinceReferenceDate < rhs.secondsSinceReferenceDate
    }
}

struct Date {
    fileprivate let secondsSinceReferenceDate: Double
}
...

protocol Shakeable {
    func shake()
}

extension UIButton: Shakeable { func shake() {/* */ } }
extension UISlider: Shakeable { func shake() {/* */ } }

func shakeEm(controls: [???]) {
    for control in controls where control.state.isEnabled {
    }
    control.shake()
}

func shakeEm(controls: [UIControl & Shakeable]) {
    for control in controls where control.isEnabled {
        control.shake()
    }
}

protocol Sequence {
    associatedtype Element where Self.Element == Self.Iterator.Element
    // ...
}

@objcMembers class Kid: NSObject {
    dynamic var nickname: String = ""
    dynamic var age: Double = 0.0
    dynamic var friends: [Kid] = []
}

var ben = Kid(nickname: "Benji", age: 5.5)

let kidsNameKeyPath = #keyPath(Kid.nickname)

let name = ben.valueForKeyPath(kidsNameKeyPath)
ben.setValue("Ben", forKeyPath: kidsNameKeyPath)

\Kid.nickname

\.nickname

struct Kid {
    var nickname: String = ""
    var age: Double = 0.0
    var friends: [Kid] = []
}

var ben = Kid(nickname: "Benji", age: 8, friends: [])

let name = ben[keyPath: \Kid.nickname]
ben[keyPath: \Kid.nickname] = "BigBen"

struct GenericDictionary<Key: Hashable, Value> {
    private var data: [Key: Value]
    
    init(data: [Key: Value]) {
        self.data = data
    }
    
    subscript<T>(key: Key) -> T? {
        return data[key] as? T
    }
}

let dictionary = GenericDictionary(data: ["Name": "Xiaoming"])

let name: String? = dictionary["Name"] // 不需要再写 as? String

var family = "?"
family += "\u{200D}?"
family += "\u{200D}?" 
family += "\u{200D}?"

print(family)
print(family.characters.count)

Swift 3:

let values = "abcdefg"
let startSlicingIndex = values.index(values.startIndex, offsetBy: 3)
let subvalues = values[startSlicingIndex..<values.endIndex]
// defg
Swift 4:

let values = "abcdefg"
let startSlicingIndex = values.index(values.startIndex, offsetBy: 3)
let subvalues = values[startSlicingIndex...] // One-sided Slicing
// defg

let abc: String = "abc"
print(String(abc.reversed()))
// cba

let abc: String = "abc"
for c in abc {
    print(c)
}
/*
a
b
c
*/

// map
let abc: String = "abc"
_ = abc.map {
    print($0.description)
}

// filter
let filtered = abc.filter { $0 == "b" }

// reduce
let result = abc.reduce("1") { (result, c) -> String in
    print(result)
    print(c)
    return result + String(c)
}
print(result)

let big = downloadHugeString()
let small = extractTinyString(from: big)

mainView.titleLabel.text = small // Swift 4 编译报错

mainView.titleLabel.text = String(small) // 编译通过

func tellJoke(name: String, character: Character) {
    let punchline = name.filter { $0 != character }
    let n = name.count - punchline.count
    let joke = "Q: Why does \(name) have \(n) \(character)'s in their name?\nA: I don't know, why does \(name) have \(n) \(character)'s in their name?\nQ: Because otherwise they'd be called \(punchline)."
    print(joke)
}
tellJoke(name: "Edward Woodward", character: "d")

func tellJoke(name: String, character: Character) {
    let punchline = name.filter { $0 != character }
    let n = name.count - punchline.count
    let joke = """
        Q: Why does \(name) have \(n) \(character)'s in their name?
        A: I don't know, why does \(name) have \(n) \(character)'s in their name?
        Q: Because otherwise they'd be called \(punchline).
        """
    print(joke)
}
tellJoke(name: "Edward Woodward", character: "d")

struct Language: Codable {
    var name: String
    var version: Int
}

let swift = Language(name: "Swift", version: 4)
if let encoded = try? JSONEncoder().encode(swift) {
    // 把 encoded 保存起来
}

if let decoded = try? JSONDecoder().decode(Language.self, from: encoded) {
    print(decoded.name)
}

Swift 3:

protocol Sequence {
    associatedtype Iterator: IteratorProtocol
    func makeIterator() -> Iterator
}

Swift 4:

protocol Sequence {
    associatedtype Element
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
    func makeIterator() -> Iterator
}

protocol Sequence {
    associatedtype SubSequence: Sequence 
        where SubSequence.SubSequence == SubSequence,
              SubSequence.Element == Element
}

+-------------+   +-------------+
        +------>+   Numeric   |   | Comparable  |
        |       |   (+,-,*)   |   | (==,<,>,...)|
        |       +------------++   +---+---------+
        |                     ^       ^
+-------+------------+        |       |
|    SignedNumeric   |      +-+-------+-----------+
|     (unary -)      |      |    BinaryInteger    |
+------+-------------+      |(words,%,bitwise,...)|
       ^                    ++---+-----+----------+
       |         +-----------^   ^     ^---------------+
       |         |               |                     |
+------+---------++    +---------+---------------+  +--+----------------+
|  SignedInteger  |    |  FixedWidthInteger      |  |  UnsignedInteger  |
|                 |    |(endianness,overflow,...)|  |                   |
+---------------+-+    +-+--------------------+--+  +-+-----------------+
                ^        ^                    ^       ^
                |        |                    |       |
                |        |                    |       |
               ++--------+-+                +-+-------+-+
               |Int family |-+              |UInt family|-+
               +-----------+ |              +-----------+ |
                 +-----------+                +-----------+

let n = NSNumber(value: 999)
let v = n as? UInt8 // Swift 4: nil, Swift 3: 231

var mutableArray = [1, 2, 3, 4]
mutableArray.swapAt(1, 2)
print(mutableArray)
// 打印结果：[1, 3, 2, 4]

struct Date {
    private let secondsSinceReferenceDate: Double
}

extension Date: Equatable {
    static func ==(lhs: Date, rhs: Date) -> Bool {
        return lhs.secondsSinceReferenceDate == rhs.secondsSinceReferenceDate
    }
}

extension Date: Comparable {
    static func <(lhs: Date, rhs: Date) -> Bool {
        return lhs.secondsSinceReferenceDate < rhs.secondsSinceReferenceDate
    }
}

class MyClass: NSObject {
    func print() { ... } // 包含隐式的 @objc
    func show() { ... } // 包含隐式的 @objc
}

extension MutableCollection {
    mutating func modifyEach(_ body: (inout Element) -> ()) {
        for index in self.indices {
            body(&self[index])
        }
    }
}

var numbers = [1, 2, 3]
numbers.modifyEach { element in
    element *= 2
    numbers.removeAll()
}