个人中心
gpt4 book ai didi

swift学习文档(笔记)

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章swift学习文档(笔记)由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

Swift是供iOS和OS X应用编程的新编程语言，基于C和Objective-C，而却没有C的一些兼容约束。Swift采用了安全的编程模式和添加现代的功能来是的编程更加简单、灵活和有趣。界面则基于广受人民群众爱戴的Cocoa和Cocoa Touch框架，展示了软件开发的新方向.

变量与常量 。

变量定义使用var，常量使用let，类型安全，有自动类型推导，注意赋值的=号两边必须有空格。变量和常量名是可以几乎所有字符，这些都非常像javascript。中文编程一下牛逼了.

?
1
2
3
var a = 123 //a为Int
let b = "helo" //b为String
var 猫叫 ＝ "喵"

数字 。

  • 十进制
  • 二进制 0b101
  • 八进制 0o5
  • 十六进制 0x5

比较长的数字间可以加上_用来提高程序的可读性，比如0_0其实就是0，_线不能加在开头 。

布尔类型 。

true和false，流程控制if的时候，判断语句返回必须是一个Bool值，比如:

?
1
2
3
4
let i = 1
if i {
  //编译报错
}

这样就可以通过 。

?
1
2
if i == 1 {
}

它不像js里会有自动类型转换 。

类型别名 。

给现在的类型添加别名，同样可以提高程序的可读性，如 。

?
1
typealias 音频采样 = UInt16

可以在别的地方使用 var 已发现的最大振幅 = 音频采样.min 。

元组 。

它可以是一组值，这些值不必是相同的类型，例如，定义我自己:

?
1
var jserme = ("183cm", 26, "76kg")

可以像数组一样访问 。

?
1
println(jserme.0) //返回183cm

元组还原为独立的变量或者常量 。

?
1
2
3
let jserme = ("183cm",26,"76kg")
let (身高, 年龄, 体重) = jserme
println("身高是 \(身高)")

也可以给每个值命名（这就像在JS里把数组搞成了对象了。。。） 。

?
1
2
let jserme = (身高:"183cm",年龄:26,体重:"76kg")
println("身高是 \(jserme.身高)")

字符串 。

字符串字面量只能用""来定义，String本质上是Character的有序集合.

?
1
2
3
4
5
6
7
8
9
10
for char in "一言既出"{
  println(char)
}
 
/*
一
言
既
出
*/

字面量与判断是否为空 。

?
1
2
3
4
5
6
7
8
9
10
var 字符串 = "我是字符串"
var 空字符串 = ""
 
if 空字符串.isEmpty {
  println("这是一个空的字符串")
}
 
if 空字符串 == "" {
  println("这是一个空的字符串")
}

字符串实例有两个方法hasPrefix与hasSuffix，如:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var 成语数组 = [
  "一言既出",
  "一触即发",
  "一呼百应",
  "一槌定音",
  "一无所有",
  "一生一世",
  "一见钟情"
]
 
var count = 0
for 成语 in 成语数组 {
  if(成语.hasPrefix("一")){
   count++
  }
}
 
println(count) //输出7

与js一样，string也是传值引用，下面的两个变量的修改不会影响到彼此 。

?
1
2
3
4
5
6
var 一串 = "我是字符串一"
var 二串 = 一串
 
二串 = "我是字符串二"
 
println("字符串一:\(一串)， 字符串二:\(二串)")

区间运算符 。

闭区间使用a...b，从a到b，包含a与b，半区间a..b，从a到b，不包含b，例如:

?
1
2
3
4
5
6
7
8
9
10
var 成语数组 = [
  "一言既出",
  "一触即发",
  "一呼百应"
]
 
for i in 0..成语数组.count {
  println("第\(i)个成语是:\(成语数组[i])")
}
//这里如何使用...会报错，因为成语数组[3]是没有值的

两种集合,array 和 dictionaries 。

相对于js对数组和对象成员松散的要求，swift要求数组和dictionaries里成员类型必须一致 。

?
1
2
3
var 购物清单: String[] = ["鸡蛋", "牛奶"]
//也可以是下面的这样
//var 购物清单 = ["鸡蛋", "牛奶"]

数组的修改可以使用append方法或者+= 。

?
1
2
3
4
5
6
7
var 购物清单 = ["鸡蛋", "牛奶"]
 
购物清单.append("苹果")
 
购物清单 += "草莓"
 
println("\(购物清单)") //[鸡蛋, 牛奶, 苹果, 草莓]

数组的获取，可以通过索引，也可以通过区间运算符 。

?
1
2
3
4
5
6
var 购物清单 = ["鸡蛋", "牛奶"]
 
println("\(购物清单[0])") //鸡蛋
println("\(购物清单[0..1])") //[鸡蛋]
println("\(购物清单[0...1])") //[鸡蛋, 牛奶]
println("\(购物清单[0...2])") //[鸡蛋, 牛奶, ]

dictionaries的定义 。

?
1
2
3
4
var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]
 
//也可以简化为
//var airports = ["TYO": "Tokyo", "DUB": "Dublin"]

它的修改与读取使用[],而不能使用. 。

?
1
airports["BJ"] = "Beijin"

控制语句 。

如前面的几个例子所示，控制语句的条件不像js有小括号 。

?
1
2
3
4
5
6
for var index = 0; index < 3; index++ {
  println("index is \(index)")
}
//index is 0
//index is 1
//index is 2

函数 。

函数的声明与调用:

?
1
2
3
4
5
6
func sayHello(personName: String) -> String {
  let greeting = "Hello, " + personName + "!"
  return greeting
}
 
println(sayHello("jserme"))

无返回的函数，其实质是返回一个Void，它等同于一个空的元组() 。

多返回值的函数与默认参数:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
func info(word:String = "aha") -> (length:Int, containA:Bool){
  var containA = false
  for char in word {
   if( char == "a") {
    containA = true
    break
   }
  }
 
  return (word.utf16count, containA)
}
 
println(info(word: "波波")) //(2, false)
println(info()) //(3, true)

便于阅读的外部参数名，在参数定义之前，与参数定义以空格隔开，如下面的多个参数 。

?
1
2
3
4
5
6
7
8
func join(string s1: String, toString s2: String, withJoiner joiner: String)
  -> String {
  return s1 + joiner + s2
}
 
//调用的时候
join(string: "hello", toString: "world", withJoiner: ", ")
// returns "hello, world"

参数名与外部参数名一致，可以给参数名加#标识:

?
1
2
3
4
5
6
7
8
9
10
func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
  for character in string {
   if character == characterToFind {
    return true
   }
  }
  return false
}
let containsAVee = containsCharacter(string: "aardvark", characterToFind: "v")
// containsAVee equals true, because "aardvark" contains a "v"

函数的参数是常量，不可以修改，如果在函数内修改，变量定义前加var 。

?
1
2
3
4
5
6
7
8
9
10
11
12
func alignRight(var string: String, count: Int, pad: Character) -> String {
  let amountToPad = count - countElements(string)
  for _ in 1...amountToPad {
   string = pad + string
  }
  return string
}
 
let originalString = "hello"
let paddedString = alignRight(originalString, 10, "-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"

如果想在函数内修改传入的参数，可以使用inout关键字来标识，传入的参数需要前缀&，这内部实现应该是指针.

?
1
2
3
4
5
6
7
8
9
10
func swapTwoInts(inout a: Int, inout b: Int) {
  let temporaryA = a
  a = b
  b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// prints "someInt is now 107, and anotherInt is now 3"

函数类型，可以像js一样使用函数作为参数及返回值 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
func addTwoInts(a: Int, b: Int) -> Int {
  return a + b
} //函数类型为 (Int, Int) -> Int
func multiplyTwoInts(a: Int, b: Int) -> Int {
  return a * b
}//函数类型为 (Int, Int) -> Int
 
//接收名为mathFunction的函数类型
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
  println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8"
 
//返回函数类型
func stepForward(input: Int) -> Int {
  return input + 1
}
func stepBackward(input: Int) -> Int {
  return input - 1
}
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
  return backwards ? stepBackward : stepForward
}
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

闭包 。

函数与它包含的上下文的变量在一起称为闭包。如sort函数

?
1
2
3
4
5
6
7
8
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 
func backwards(s1: String, s2: String) -> Bool {
  return s1 > s2
}
var reversed = sort(names, backwards)
println(reversed)
// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]s

使用闭包可以表示为

?
1
2
3
4
5
6
7
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 
var reversed = sort(names, {(s1:String, s2:String) -> Bool in
  return s1 > s2
})
println(reversed)
// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

也可以简化为 。

?
1
2
3
4
5
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 
var reversed = sort(names, { s1, s2 in s1 > s2 } )
 
println(reversed)

枚举 。

通过下面的语法声明 。

?
1
2
3
4
enum Barcode {
  case UPCA(Int, Int, Int) = (1,2,3)
  case QRCode(String) = "hello"
}

类与结构体 。

推荐使用首字母大写来命名 。

?
1
2
3
4
5
6
7
8
9
10
struct Resolution {
  var width = 0
  var heigth = 0
}
class VideoMode {
  var resolution = Resolution()
  var interlaced = false
  var frameRate = 0.0
  var name: String?
}

生成实例:

?
1
2
let someResolution = Resolution()
let someVideoMode = VideoMode()

属性访问与修改，使用.语法:

?
1
2
3
println("The width of someVideoMode is \(someVideoMode.resolution.width)")
someVideoMode.resolution.width = 12880
println("The width of someVideoMode is now \(someVideoMode.resolution.width)")

结构体有自动成员初始化器，类实例没有:

?
1
let vga = resolution（width:640, heigth: 480）

结构体与枚举都是值类型，类是引用类型 。

对于引用了同一个实例的值，可以使用===和!==来进行判断 。

延迟属性,@lazy，设置在调用的时候才初始化特定的属性 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class DataImporter {
  /*
  DataImporter 是一个将外部文件中的数据导入的类。
  这个类的初始化会消耗不少时间。
  */
  var fileName = "data.txt"
  // 这是提供数据导入功能
}
 
class DataManager {
  @lazy var importer = DataImporter()
  var data = String[]()
  // 这是提供数据管理功能
}
 
let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
// DataImporter 实例的 importer 属性还没有被创建

类、结构体、枚举都可以通过设置setter与getter来 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct AlternativeRect {
  var origin = Point()
  var size = Size()
  var center: Point {
  get {
   let centerX = origin.x + (size.width / 2)
   let centerY = origin.y + (size.height / 2)
   return Point(x: centerX, y: centerY)
  }
  set { //这里setter 没有定义表示新值的参数名，则可以使用默认名称newValue
   origin.x = newValue.x - (size.width / 2)
   origin.y = newValue.y - (size.height / 2)
  }
  }
}

只读属性去掉get与set 。

属性监视可以使用willset和didset来处理 。

类型属性有点像静态变量，以static关键字声明 。

?
1
2
3
4
5
6
struct SomeStructure {
  static var storedTypeProperty = "Some value."
  static var computedTypeProperty: Int {
  // 这里返回一个 Int 值
  }
}

下标 。

类、结构体、枚举都可以有下标，它有像给它们增加了一个快捷方式，如下:

?
1
2
3
4
5
6
7
8
9
struct TimesTable {
  let multiplier: Int
  subscript(index: Int) -> Int {
   return multiplier * index
  }
}
let threeTimesTable = TimesTable(multiplier: 3)
println("3的6倍是\(threeTimesTable[6])")
// 输出 "3的6倍是18"

继承 。

定义一个类 。

?
1
2
3
4
5
6
7
8
9
10
11
class Vehicle {
  var numberOfWheels: Int
  var maxPassengers: Int
  func description() -> String {
   return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers"
  }
  init() {
   numberOfWheels = 0
   maxPassengers = 1
  }
}

继承类 。

?
1
2
3
4
5
6
class Bicycle: Vehicle {
  init() {
   super.init()
   numberOfWheels = 2
  }
}

重写属性与方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Car: Vehicle {
  var speed: Double = 0.0
  override var speed: Double {
  get {
   return super.speed
  }
  set {
   super.speed = min(newValue, 40.0)
  }
  }
  init() {
   super.init()
   maxPassengers = 5
   numberOfWheels = 4
  }
  override func description() -> String {
   return super.description() + "; "
    + "traveling at \(speed) mph"
  }
}

防止重写，在方法与属性前加关键字@final，编译时会出错 。

构造函数 。

声明里可以写多个init，这有点像重载 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Celsius {
  var temperatureInCelsius: Double = 0.0
  init(fromFahrenheit fahrenheit: Double) {
   temperatureInCelsius = (fahrenheit - 32.0) / 1.8
  }
  init(fromKelvin kelvin: Double) {
   temperatureInCelsius = kelvin - 273.15
  }
}
 
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
// boilingPointOfWater.temperatureInCelsius 是 100.0
let freezingPointOfWater = Celsius(fromKelvin: 273.15)
// freezingPointOfWater.temperatureInCelsius 是 0.0”

类的析构 。

有些地方叫反初始化，很别扭的名字哦 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Player {
  var coinsInPurse: Int
  init(coins: Int) {
   coinsInPurse = Bank.vendCoins(coins)
  }
 
  func winCoins(coins: Int) {
   coinsInPurse += Bank.vendCoins(coins)
  }
 
  deinit {
   Bank.receiveCoins(coinsInPurse)
  }
}
 
var player = Player(coins:200)
player = nil //调用deinit方法

扩展 。

对于类、结构体、枚举，可以扩展它们的一切 。

?
1
2
3
4
5
6
7
8
9
10
11
class Player{
  var age:Int
}
 
extension Player{
  func repetitions(task: () -> ()) {
   for i in 0..self {
    task()
   }
  }
}

协议 。

其实就是接口描述 。

?
1
2
3
4
5
protocol SomeProtocol {
  var mustBeSettable: Int { get set }
  var doesNotNeedToBeSettable: Int { get }
  func someTypeMethod()
}

协议继承 。

?
1
2
3
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
  // protocol definition goes here
}

泛型 。

这个函数的泛型版本使用了节点类型命名（通常此情况下用字母T来表示）来代替实际类型名（如Int、String或Double）。节点类型名并不是表示T必须是任何类型，但是其规定a和b必须是同一类型的T，而不管T表示任何类型。只有swapTwoValues函数在每次调用时所传入的实际类型决定了T所代表的类型.

?
1
2
3
4
5
func swapTwoValues<T>(inout a: T, inout b: T) {
  let temporaryA = a
  a = b
  b = temporaryA
}

运算符重载 。

这里演示重载+号运算符 。

?
1
2
3
4
5
6
struct Vector2D {
  var x = 0.0, y = 0.0
}
@infix func + (left: Vector2D, right: Vector2D) -> Vector2D {
  return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
  • 前置运算符 @prefix
  • 后置运算符 @postfix
  • 组合赋值运算符 @assignment
  • 比较运算符 @infix
?
1
2
3
4
@prefix @assignment func ++ (inout vector: Vector2D) -> Vector2D {
  vector += Vector2D(x: 1.0, y: 1.0)
  return vector
}

自定义运算符 。

个性的运算符只能使用这些字符 / = - + * % < >！& | ^。~ 。

?
1
2
3
4
5
operator prefix +++ {}
@prefix @assignment func +++ (inout vector: Vector2D) -> Vector2D {
  vector += vector
  return vector
}

结合性(associativity)的值默认为none,可用left,right,none，优先级(precedence)默认为100.

?
1
2
3
4
5
6
7
8
operator infix +- { associativity left precedence 140 }
func +- (left: Vector2D, right: Vector2D) -> Vector2D {
  return Vector2D(x: left.x + right.x, y: left.y - right.y)
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector 此时的值为 (4.0, -2.0)

来自：http://jser.me 。

最后此篇关于swift学习文档(笔记)的文章就讲到这里了,如果你想了解更多关于swift学习文档(笔记)的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： mac git xcrun error active developer path 错误
文章推荐： Java微信公众平台开发（12） 微信用户信息的获取
文章推荐： Java微信公众平台开发（11） 微信三大平台的关联
文章推荐： Swift 编程语言入门教程
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com