swift基本语法

应用程序需要引入import Cocoa。ios需要引入import UIKit。

Swift不要求在每行结尾使用分号，但在同一行书写多条语句时，必须用分号隔开

数据类型

Int,UInt,Float,Double,Bool,String,单个字母：Character,可选类型：Optional,类型别名：typealias

变量的定义

var variableName= <intial value>
var varA = 40
print(varA)

var varB:Float = 3.1415
var varC = "hello"
//字符串
var stringA = "Hello,World!"
var stringB = String("Hello")
var stringC = stringA + stringB
var stringD = stringA.append(stringB)
if stringS.isEmpty{
  
}
print("\(stringC.count)")
//遍历字符串中的字符
for ch in "Runoob".characters {
    print(ch)
}

常量的定义

常量需要以字母或下划线开始

let constantName = <initial value>
let constA=40
let constB:Float = 3.14159

类型转换

//字符串转整型
let myString: String = "256"
let myInt: Int? = Int(myString)
//分割字符串
let fullName = "sf|ff|ss"
let fullNameArr = fullName.characters.split{$0 == "|"}.map(String.init)

枚举的定义

// 定义枚举
enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}
enum Student{
    case Name(String)
    case Mark(Int,Int,Int)
}
var studDetails = Student.Name("Runoob")
var studMarks = Student.Mark(98,97,95)
switch studMarks {
case .Name(let studName):
    print("学生的名字是: \(studName)。")
case .Mark(let Mark1, let Mark2, let Mark3):
    print("学生的成绩是: \(Mark1),\(Mark2),\(Mark3)。")
}

数组的定义

var someInts:[Int] = [10, 20, 30]
//创建数量为3，初始值为0
var someInts = [Int](repeating: 0, count: 3)
someInts.append(10)
someInts+= 20
someInts[1]=50
//计算个数
print(someInts.count)
//合并数组
var intsC = intsA+intsB
for (index, item) in someInts.enumerated() {
    print("在 index = \(index) 位置上的值为 \(item)")
}
//判断数组是否为空
intsA.isEmpty

字典

var someDict = [Int: String]()
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
someDict[1] = "hello"
//修改值，如果不存在则创建
someDict.updateValue("One 新的值", forKey: 1)
//移除值
someDict[1] = nil
someDict.removeValue(forKey: 1)
//遍历
for (key, value) in someDict {
   print("字典 key \(key) -  字典 value \(value)")
}
//我们也可以使用enumerate()方法来进行字典遍历，返回的是字典的索引及 (key, value) 对，实例如下:
for (key, value) in someDict.enumerated() {
    print("字典 key \(key) -  字典 (key, value) 对 \(value)")
}

//字典转数组
var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

print("输出字典的键(key)")

for (key) in dictKeys {
    print("\(key)")
}

print("输出字典的值(value)")

for (value) in dictValues {
    print("\(value)")
}

变量与常量的输出

let name = "常量1"
var age = "变量"
print("输出：\(name),\(\age)")

控制结构

条件控制

//if语句
if true{
  
}else if{
  
}else{
  
}
//switch语句
switch var{
  case 1:
  fallthrough //可选,如果使用了fallthrough 语句，则会继续执行之后的 case 或 default 语句，不论条件是否满足都会执行。
  case 2,3:
  default:
}
//三元运算
Exp1 ? Exp2 : Exp3;

循环控制

for index in var {
   循环体
}
while condition
{
   statement(s)
}
repeat
{
   statement(s);
}while( condition );

函数

语法

一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。

如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。

func runoob(name: String, site: String) -> String {
    return name + site
}
print(runoob(name: "菜鸟教程：", site: "www.runoob.com"))
print(runoob(name: "Google：", site: "www.google.com"))
//可变参数
func vari<N>(members: N...){
    for i in members {
        print(i)
    }
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu", "Runoob")

函数类型

在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

函数类型作为参数类型、函数类型作为返回类型

func sum(a: Int, b: Int) -> Int {
    return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
    print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)

闭包

let studname = { print("Swift 闭包实例。") }
studname()
//以下闭包形式接收两个参数并返回布尔值：
let divide = {(val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}
let result = divide(200, 20)
print (result)

//使用闭包排序
let names = ["AT", "AE", "D", "S", "BE"]

// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
    return s1 > s2
}
var reversed = names.sorted(by: backwards)
print(reversed)

//缩写参数名
let names = ["AT", "AE", "D", "S", "BE"]
var reversed = names.sorted( by: { $0 > $1 } )
print(reversed)

类

结构体

struct MarksStruct {
   var mark: Int

   init(mark: Int) {
      self.mark = mark
   }
}
var aStruct = MarksStruct(mark: 98)
var bStruct = aStruct // aStruct 和 bStruct 是使用相同值的结构体！
bStruct.mark = 97
print(aStruct.mark) // 98
print(bStruct.mark) // 97

类定义

class student{
   var studname: String
   var mark: Int 
   var mark2: Int 
  init(){ //构造函数
    
  }
  deinit {//析构函数
        
  }
}
//判断两个类相等用===和!==
let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")
if spClass1 === spClass2 {// false
    print("引用相同的类实例 \(spClass1)")
}
//get set
var middle: (Double, Double) {
    get{
        return (length / 2, breadth / 2)
    }
    set(axis){
        no1 = axis.0 - (length / 2)
        no2 = axis.1 - (breadth / 2)
    }
}
var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)

//只读属性
class film {
    var head = ""
    var duration = 0.0
    var metaInfo: [String:String] {
        return [
            "head": self.head,
            "duration":"\(self.duration)"
        ]
    }
}

属性观察器

属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。
可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。

注意：

• 不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。
• 可以为属性添加如下的一个或全部观察器：
• willSet在设置新的值之前调用
• didSet在新的值被设置之后立即调用
• willSet和didSet观察器在属性初始化过程中不会被调用

class Samplepgm {
    var counter: Int = 0{
        willSet(newTotal){
            print("计数器: \(newTotal)")
        }
        didSet{
            if counter > oldValue {
                print("新增数 \(counter - oldValue)")
            }
        }
    }
}
let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

类继承

//final 关键字防止重写
class SomeClass: SomeSuperclass {
  //重写属性
  override var area: String {
      return super.area + " ，但现在被重写为 \(print)"
  }
  init() //构造函数
  {
      super.init(stm1: 93, results: 89)
  }
  //重写方法
  override func show() {
        print("这是子类 SubClass")
    }
}

协议（接口）

protocol SomeProtocol {
    
    var marks: Int { get set }
    var result: Bool { get }
    init(aprot: Int)
    func attendance() -> String
    func markssecured() -> String
    
}
class SomeClass: SomeProtocol {
   required init(someParameter: Int) {
      // 构造器实现
   }
}
class subClass: SomeClass, tcpprotocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }
    // 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
    required override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}

附录

内置数据类型