swift x输入流_Swift笔记：基础语法

突然发现swift上手入门比较简单，大学很多编程基础都还用得上，捣鼓了一阵子把知识整理了一下，欢迎一起交流，下次文章应该会分享更多进阶的内容。

这篇文章介绍字符类型、判断逻辑、元组、开闭区间、循环的多种写法、函数、闭包、Map方法、Filter方法、Optional值的概念、Storyboard和ViewController的简单应用，作为笔记，这里只写了我觉得比较重要，需要长期查阅和记忆的内容，其他内容会有空再写。

---

Storyboard中布置页面内容

按钮是Button 标签是Label 图片是Imageview

ViewController用来控制页面行为

键盘按住control拖动storyboard中的Botton到ViewController.swift中，可以进行按钮的行为控制，例如打印出helloWorld

Action与Outlet

Action会和使用者互动，从画面发送至代码 Outlet是代码控制画面

Var表示变量，变量随时可改

案例：var time = 100

Let表示常量，常量不可改

案例：let score = 10

Int表示整数，用于标明数的类型为整数

案例：var score:Int = 10 注意Int的首字母必须大写

求余数用%

列一个算式就懂了：7 % 3 = 1

Float和Double表示浮点数，后者能存储的精度更高，为双精度浮点数

案例：let score:Float = 23``var score:Double = 42 不同种类的数如果需要在一起运算，需要先转换 案例：score是整数，number是双精度浮点数，它们想要相加，需要都转换成双精度浮点数，写成 Double(score) + number

布尔值

布尔值表真假，只有两种值：false/true 案例：var isTheGameWin:Bool = true

字符串

存储一长串字符 案例：let iWantToSay:String = “Good Job” PS：用加号可以连接两个字符串 案例：iWantToSay += “Swift”

字符串中抓入数字

var firstNumber:Float = 20
var GamePoint:String = “Your GamePoint is “
GamePoint =  GamePoint + “(firstNumber)”

在字符串中加入符号可以用反斜线’’

例如var name1:String = “ My Name is ”MarioSem” “

临时改变字符的大小写，可以使用 .lowercased() 和 .uppercased()

例如

var name2:String = “Good Job”
name2 = name2.uppercased()
name2 = name2.lowercased()

多行字符串可以通过三个双引号来前后换行

例如

var name3:String =
“””
Good Job
My boy
“””
print(name3)

数组阵列Array

阵列可以存储一大串同类型的数 var animaArray = ["cat","dog","mouse","tiger"] 定义类型的数组 var animaArray:[Int] = [1,2,3,4,5] 生成空数组的两种方式（都必须声明数组类型）

var animalArray2:[Int] = []
var animalArray3 = [Int]()

重新赋值 animaArray[2] = "monkey" 计数：可以通过.count来算出数组中内容的个数，例如： x = animaArray.count 末尾插入：也可以通过.append为数组增加一格，例如： animaArray.append("rabbit") 中间插入：可以通过insert在数组指定位置插入一格，当前格子和后续格子的已有内容向后顺移一格子。例如： animaArray.insert("cow" ,at:2) 删除格子：有三种方法分别用于删除指定格子和首尾格子，后续格子向前顶位，例如：

animaArray.remove(at: 2)
animaArray.removeLast()
animaArray.removeFirst()

顺序颠倒，例如： animalArray.reverse() 数组相加：后面的数组直接接在前面的数组尾巴上

var animalArray = ["cat","dog","mouse","tiger"]
var anotherArray = ["sheep","goat"]
animalArray += anotherArray

字典

字典中有多组key和对应值，例如： var fruitDict = ["red":"apple","yellow":"banana"] 可以在生成字典时声明字典key和值的类型，例如： let score:[String:Int] = [“English”:120,”math”:110] 可以通过key来获得对应的值，例如： fruitDict["red"] 和数组不同的是，如果查询的key不存在，会返回nil值，如以下值为nil： fruitDict["orange"] 可以通过下列两种方式新增/修改指定key的值：

fruitDict["red"] = "tomato"
fruitDict.updateValue("apple", forKey: "red")

有两种方法可以同时删除key和值，如

fruitDict[“keynote”] = nil
fruitDict.removeValue(forkey:”yellow”)

注意：从字典中拿到的值是optional（Int？, Double？…）的，和指定的值类型（Int, Double…）不太一样，他有可能是nil

可以通过option+左键点击数值，来查看数的类型

IF判断式

和c很相似，但省了很多括号～一个简单的案例：

var price = 80
if price == 80{
    print ("buy it")
}
if price > 80{
    print ("buy it")
}else if price < 50{
    print("very cheap")
}else{
    print("buy it")
}

注释

单行使用两个斜线//，多行注释使用/* 内容 */

惊叹号!表相反值

例如:

let isTrue = true
!isTrue

&&表“且”，|| 表“或”

例如：

var price = 80
var money = 90
if price == 80 && money >= 80 {
    print ("buy it")
}
var price = 80
var money = 90
if price <= 90 || money >= 80 {
    print ("buy it")
}

使用if和else的思路做一个猜数字的游戏

知识点1:获取文字输入框的信息 let inputText = inputTextField.text! 知识点2:数的后面加惊叹号是确保有值可用，否则不会使用此值（暂时的理解）

if inputNumber! > answer{
    maxNumber = inputNumber! - 1}

知识点3：使用.random(int: 1…100)来生成区间内的随机数

answer = Int.random(in: 1…100)

知识点4：在viewDidLoad()中加入拉起键盘，可以在进入页面时打开虚拟键盘

override func viewDidLoad() {
    super.viewDidLoad()
    inputTextField.becomeFirstResponder()
}

switch

遇到大量的else if ，且当需要判断的值是唯一的时，可以使用switch，更加简洁

switch <#value#> {
case <#pattern#>:
    <#code#>
case <#pattern#>:
    <#code#>
default:
    <#code#>
}

另外可以使用…来划定闭区间，例如：

var num = 24
switch num {
    case 1…18:
    print(“teenager”)
    case 19…150:
    print(“adut”)
default:
    print(“R U human ?”)
}

闭区间/半闭区间/开区间

闭区间a…b 半闭区间a..<b

Tuple元组

Tuple可以存储很多不同类型的值，写法如： let numberTuple = (“hello”,3,0.1,true,[“switch",”ps4”]) 或类似于keyValue的写法 let fruitTuple = (red:”apple”,yellow:”banana",green:”mango”) 可以通过定位拿到指定的值： numberTuple.2 或是tuple中的数组： numberTuple.4[1] 或是通过key找到指定值 numberTuple.red

For Loop

写法：

for <#item#> in <#items#> {
    <#code#>
}

其中的<#item#>是可以自定义的，配合数组使用案例：

var animalArray = [“cat”,”dog”,”mouse"]
for animal in animalArray {
    print(animal)
}

结合区间使用

for index in 1…10{
    print(index)
}

也可以省略 <#item#>

for _ in 1…10{
    print(“Hi”)
}

还可以使用where设置生效条件，不满足条件时直接进入下一个loop

for main in 1…10 where main % 2 == 0 {
    print(main)
}

While loop

写法：

while <#condition#> {
    <#code#>
}

例如:

var index = 1
while index < 10{
    print(index)
    index += 1
}

Repeat While loop

先执行再判断，和while不同的是，即使条件不符，也至少会执行一次

repeat{
    print(index)
    index -= 1
}while index >= 1

函数 Function

定义无参函数：

func makeCake(){
    需要执行的代码
}

调用无参函数： makeCake() 定义带参函数：

func eat(foodname:String){
    print(“I want to eat (foodname)”)
}
func eat(foodname1:String,foodname2:String){
    print(“I want to eat (foodname1) and (foodname2)”)
}

调用带参函数： eat(foodname:”apple”) eat(foodname1:”apple”,foodname2:"banana”) 有返回参数的函数：

func add(number1:Int, number2:Int) -> Int{
    var result = number1 + number2
    return result
}

调用： let answer = add(number1: 2, number2: 2) 外部参数名,外部参数在调用时使用，内部参数在函数内使用：

func calculateArea(withwidth width:Float,andheight height:Float) -> Float{
    return width * height
}

calculateArea(withwidth: 20.5, andheight: 10.2)

如果外部参数名用下划线表示，那调用时可以直接录入数，不写参数名

func calculateArea(_ width:Float, _ height:Float) -> Float{
    return width * height
}

calculateArea(20.5,10.2)

注： 1-函数内可以调用函数外定义的数，但函数外不能调用函数内定义的数 2-同理：{}中定义的函数，不能在外面访问

没有名字的函数 Closure

使用定义常数的方式来定义函数，写法相对比较简单，同样支持带参回参

//定义无参closure
let helloEveryone = {
    print("hello Everyone”)
}
//调用无参closure
helloEveryone()

//定义有参closure
let eatFood = {
    (foodName:String) in
    print("I want to eat (foodName) ")
}
//调用有参closure
eatFood("apple”)

//定义有返回值closure
let addNumber = {
    (number1:Double, number2:Double) -> Double in
    return number1 * number2
}
//调用有返回值closure
var result = addNumber(2.0,2.0)
print(“(result)”)

也可以把入参回参的类型描写的更明确一点，但稍微有点麻烦

//定义无参closure
let helloEveryone:()->() = {
    print(“hello Everyone”)
}
//定义有参closure
let eatFood:(String)->() = {
    (foodName:String) in
    print(“I want to eat (foodName) “)
}
//定义有返回值closure
let addNumber:(Double,Double)->Double = {
    (number1:Double, number2:Double) -> Double in
    return number1 * number2
}

Closure可以作为入参和回参，作为入参的案例：

//定义一个加法closure
let addNumber:(Int,Int) -> Int = {
    (number1:Int, number2:Int) -> Int in
    let result = number1 + number2
    return result
}
//定义一个入参为2个整数+1个closure的函数
func calculate(num1:Int, num2:Int, operation:(Int,Int)->Int){
    print(operation(num1,num2))
}
//调用此函数
calculate(num1: 2, num2: 4, operation: addNumber)

Closure是可以简写的，规则比较绕，这里就列一个自己写的范例：

//原版
let addNumber:(Int,Int) -> Int = {
    (number1:Int, number2:Int) -> Int in
    let result = number1 + number2
    return result
}
//简写
let addNumber:(Int,Int) -> Int = {$0 + $1}

Map方法

Map方法可以使用数组中的每一项进行操作，操作来源于map方法中调用的closure

//定义一个closure
let numberArrayAddTen = { $0 + 10 }
//定义一个数组
var numberArray = [1,2,3,4,5]
//使用map方法调用closure
let result = numberArray.map(numberArrayAddTen)
//此时result为一个[10,20,30,40,50]的数组
result

Filter方法

Filter方法可以通过调用closure筛选数组中满足表达式条件的数

//定义一个数组
var numberArray = [1,2,3,4,5]
//筛选numberArray中大于3的数
numberArray.filter { (num1) -> Bool in
    return num1 > 3
}
//简写法
var a = numberArray.filter { $0 > 3 }

Optional值

Ophtional值是一种不确定的值，可能为空

//Optional代表值可能为对应数，也可能为空（nil）
var Number:Int? = nil
var oneWord:String? = “Hello”
print(oneWord)

//也可以使用！定义Optional值
var Number:Int!= nil

//被定义为optional的值不能进行正常的运算，如
Number += 1

可以通过IF判断，将Optional值转成正常值：

var x:Int! = 8
var loadScore:Int = 0
if x != nil{
    loadScore = x!
}

更推荐通过binding将Optional值转成正常值：

var x:Int? = 8
var loadScore:Int = 0
if let trueNumber = x{
    loadScore = trueNumber
}else{
    loadScore = 0
}

上述代码还可以简写成

var x:Int? = 8
var loadScore:Int = 0
loadScore = x ?? 0

质数判断

知识点：可以通过Command + 鼠标点击，全局替换某一个数，如：

知识点：在调试时，可以通过Debug view Hierarchy模式查看实时页面层级

知识点：在closure中调用方法需要加self，如：

checkPrime(withNumber: inputNumber) { (result) in
                self.resultLabel.text = result
                self.resultLabel.isHidden = false
            }