Swift3.0基本知识

import Foundation

//print("Hello, World!")

print("1","2")

//输出多个字符串，并用“--”分割，并使用\n换行。

print("1","2","3","4", separator: "--", terminator: "\n")

//常量

let num = 120

// num = 10 error!!!

//变量

var num2 = 18

num2 = 10

print(num,num2)

/*

/* 多行注释允许嵌套*/*/

//类型安全和类型推断

let num3:Int = 18

// num3 = 3.14 类型不匹配

var num4:Float = 2.123

//num4 = Int(4)类型不匹配

//类型推断

//根据赋值推断出常量和变量的类型,推断的时候向大范围推。

var num5 = 9

let num6 = 3.14//double类型的

var char:Character = "C"

var char2 = "C"//String

var str = String("123456")

var str2 = "123456" //自面量创建方式

let 二进制 = 0b010101

print(二进制)

let 八进制 = 0o11

print(八进制)

let 十进制 = 111

let 十六进制 = 0x11

print(十六进制)

//数据类型转换

let t = 18

let t1 = 2.34

let result = Double(t) + t1

print("Double: \( result)")

let result2 = t + Int(t1)

print("result2: \(result2)")

let result3 = String(t)

print("String: \(result3)")

let result4 = Int("123")// 返回值是可选类型 Int？

print(result4) //Optional(123)

let result5 = result4! + 5 //可选类型不能直接参与参数运算，需要解包取出里面包裹的值，在做运算

print(result5)

//布尔值 Bool 主要用作判断条件和循环条件，Swift不存在非零为真

var flag = true

print(flag)

flag = false

print(flag)

if true {

print("永真")

}

/*while true{

print("死循环")

}*/

//元组 Tuple 主要用来处理，当一个函数有多个返回值的情况；

let tuple = (name:"李斯",age:18,123)

//访问元组内容

//通过下标来访问的

print(tuple.0)

print(tuple.1)

//通过元素名来访问

print(tuple.name)

print(tuple.age)

/*

func <#name#>(<#parameters#>) -> <#return type#> {

<#function body#>

func 函数名（参数列表）->返回值类型{

函数体

}*/

//求和的函数

func sum(sum1:Int, sum2:Int) ->Int{

return sum1+sum2

}

print(sum(sum1: 1, sum2: 2))

//元组使用场景

func backValues(sum1:Int ,sum2:Int) ->(Int ,Int ){

return(sum1 + sum2, sum1 - sum2)

}

let tuple2 = backValues(sum1: 12 ,sum2: 3)

print(tuple2)

print(tuple2.0,tuple2.1)

//可选类型 Optional,可选类型主要用来处理值可能缺失的情况

var aString:String? = nil //定义了一个可选类型的字符串

let aInt:Int? = nil //定义了一个可选类型的整数

aString = "JingNingShiFan"

print(aString)

//对一个值为空的可选类型进行解包是很危险的，解包前要判断可选类型是否有值，或者赋值

let newString = aString! + "IOS class"

print(newString)

//先判断可选类型是否为空，不空才解包

var sum = 0

if aInt != nil{

sum = aInt! + 10

}

print(sum)

//可选绑定

let str3:String? = "i love"

var str4 = ""

//系统内部就帮我们吧可选类型str3值解包出来了，不需要手动在解包,如果str3不为空，if就是ture，执行if语句，如果str3为空，if就是false，则不执行if语句

if let ValueString = str3 {

str4 = ValueString + "canglaoshi"

}

print("----" + str4)

//隐式解包类型

//隐式解包类型要求必须赋值 才能使用

let v:Int! = 18

//此时再使用v 中的值时就不用！解包了，因为已经解包过了

let value = v + 12

print(value)

//for 循环的c语言的格式已经被弃用了

/*for(i:Int; i < 10; i++){

}*/

//使用for循环输出1-10

//...代表闭区间[1,10]

for i in 1...10{

print(i)

}

//使用for循环输出1到9

//..<代表开区间 [1,10)

for i in 1..<10{

print(i)

}

//输出10遍hello word 如果没有使用到循环变量，可以使用_替换掉

for _ in 1...10{

print("hello word")

}

//求1到100的和

//定义一个变量存储最终结果 sum1

var sum1 = 0

//利用for循环遍历1-100数字，并把结果放到sum1中

for i in 1...100{

sum1 += i

}

print(sum1)

//repeat——while循环

var m = 0

repeat{

print("班里美女")

m += 1 //m -= 1 ++ 和 --已经被弃用了

}while m < 10

//字符串

//创建字符串

//字面量格式创建

let s1 = "字面量格式创建"

print(s1)

//使用初始化方法创建

let s2 = String ("使用初始化方法创建")//创建出来的是可选类型字符串

print(s2!)

//操作字符串的方法和属性

let s3 = "hello word"

//获取字符串的长度

print(s3.characters.count)

//大写字符串方法

let nStr = s3.uppercased()

print(nStr, s3)

//小写

let nStr2 = nStr

print(nStr2, nStr)

//字符串的拼接

var s4 = "zhangquandan"

s4.append(" futukang")//拼接的内容直接作用到原串上

print(s4)

let nStr3 = s4.appending(" qipashuo")//拼接的内容没有作用到原串上，而是返回一个新的字符串上

print("nStr3"+nStr3, "s4"+s4)

//遍历字符串

let s5 = "we are family"

for i in s5.characters{

print(char)

}

//字符串的格式化拼接

for i in 1..<10{

let str = String(format:"student%02d", i)

print(str)

}