前言
总结下 swift下的基础语法，里面涉及到：常量&变量、Swift中的数据类型、逻辑分支、循环、字符串相关、数组和字典、方法的书写调用等内容，考虑到阅读体验分多篇来展示，希望对大家学习swift有所帮助，同时也是对自己的一个总结。
Swift| 基础语法（一）
Swift| 基础语法（二）
Swift| 基础语法（三）
Swift| 基础语法（四）
Swift| 基础语法（五）
本文涉及：
- 字符串
- 数组
- 字典
- 方法的书写
- 访问修饰符
一、字符串
-
在OC中字符串类型时NSString,在Swift中字符串类型是String
-
OC中字符串@"",Swift中字符串""
使用 String 的原因 String 是一个结构体，性能更高 NSString 是一个 OC 对象，性能略差 String 支持直接遍历 Swift 提供了 String 和 NSString 之间的无缝转换
遍历字符串
// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {
print(c)
}
字符串拼接
两个字符串的拼接
let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2
字符串和其他数据类型的拼接
let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"
字符串的格式化
比如时间:03:04
let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])
字符串的截取
Swift中提供了特殊的截取方式
该方式非常麻烦
Index创建较为麻烦
简单的方式是将String转成NSString来使用
在标识符后加:as NSString即可
let myStr = "www.520it.com"
var subStr = (myStr as NSString).substring(from: 4)
print("subStr:\(subStr)")
subStr = (myStr as NSString).substring(to: 3)
print("subStr1:\(subStr)")
subStr = (myStr as NSString).substring(with: NSRange(location: 4, length: 5))
print("subStr2:\(subStr)")
=++++ 打印结果 ++++++
subStr: 520it.com
subStr1: www
subStr2: 520it
字符串的判断
//与oc方法的 isEqualToString方法一样
if str == str1 {
print("======")
} else {
print("!=====")
}
ASC 值进行比较
let s1 = "abc"
let s2 = "xyz"
if s1 > s2 {
print("大于")
} else {
print("小于")
}
二、数组
数组（Array）是一串有序的由相同类型元素构成的集合
数组分成:可变数组和不可变数组
- 使用let修饰的数组是不可变数组
- 使用var修饰的数组是可变数组
// 定义一个不可变数组
let array2 : [NSObject] = ["why", 18]
// 定义一个可变数组,必须初始化才能使用
var array1 : [String] = [String]()
在声明一个Array类型的时候可以使用下列的语句之一
var stuArray1:Array<String>
var stuArray2: [String]
声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的
// 定义时直接初始化
var array = ["why", "lnj", "lmj"]
// 先定义,后初始化
var array : Array<String>
array = ["why", "lnj", "lmj"]
//作为参数
init(dict: [String]){
}
对数组的基本操作
// 添加数据
array.append("yz")
// 删除元素
array.removeFirst()
// 修改元素
array[0] = "why"
// 取值
array[1]
// 对原数组进行升序排序
array.sort()
// 对原数组进行降序排序
array.sort(by: >)
// 将原数组除了最后一个以外的所有元素赋值给另一个数组
let anotherNums = Array(array[0 ..< nums.count - 1])
数组的遍历
// 遍历数组
for i in 0..<array.count {
print(array[i])
}
// forin方式
for item in array {
print(item)
}
// 设置遍历的区间
for item in array[0..<2] {
print(item)
}
数组的合并
// 数组合并
// 注意:只有相同类型的数组才能合并
var array = ["why", "lmj","lnj"]
var array1 = ["yz", "wsz"]
var array2 = array + array1;
// 不建议一个数组中存放多种类型的数据
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4
Swift中关于数组的 Sorted、forEach、 Map,Flatmap,Filter,Reduce的用法
简化参数名，如1(从0开始，表示第i个参数...)
-
Sorted
/* 数组提供了一个排序函数，sorted().使用的是默认规则，当然我们也可以定制排序规则。 */ let names = ["ZZZZZZ", "BB", "A", "CCCC", "EEEEE"] names.sorted() // ["A", "BB", "CCCC", "EEEEE", "ZZZZZZ"] //更改排序规则 其实就是利用了函数重载，具体可看函数定义 //sorted(by: <#T##(String, String) throws -> Bool#>) names.sorted { $0.count > $1.count } // ["ZZZZZZ", "EEEEE", "CCCC", "BB", "A"] -
forEach
/* 循环遍历集合中的元素，相当于for-in 快速遍历 */ let values = [5, 3, 2, 3,1] values.forEach { print("element is \($0)") } -
Map
在OC中，对数组元素的操作是很不方便的一件事，遍历，操作，赋值给新数组，显得太繁琐。 在swift中，对数组的操作就简洁了很多。 map方法作用是把数组[T]通过闭包函数把每一个数组中的元素变成U类型的值，最后组成数组[U] +将示例数组，每个数字都加10，获得一个新的数组： //map函数里面可以直接使用函数作为参数,这里采用函数的方式。 let numberArray = [1,2,3,4,5] func fmap(a : Int) -> Int{ return a + 10 } var result = numberArray.map(fmap) print(result) //采用闭包的方式 var result = numberArray.map({($0) + 10}) print(result) + map不只是可以用来做简单的数值运算，还可以处理一些其他复杂操作，如：在数字后拼接字符串，返回新的数组 用常规方式写： for number in numberArray { stringsArray.append("\(number)只") } print(stringsArray) 使用map： resultArray = numberArray.map({"\($0)只"}) print(resultArray) -
FlatMap
flatMap 更加强大，可以传入N个处理方法，将处理后得到数据，组合到同一个数组中 resultArray = numberArray.flatMap({["\($0)个","\($0 )只"]}) print(resultArray) //输出结果： ["1个", "1只", "2个", "2只", "3个", "3只", "4个", "4只", "5个", "5只"] -
Filter
filter就是筛选的功能，参数是一个用来判断是否筛除的筛选闭包， 根据闭包函数返回的Bool值来过滤值。为True则加入到结果数组中。 + 找出数组中大于2的数 常规方式实现： var filteredArray : [Int] = [] for number in numberArray { if number > 2 { filteredArray.append(number) } } print(filteredArray) 使用filter实现： filteredArray = numberArray.filter({$0 > 2}) print(filteredArray) -
reduce
reduce的作用给定一个类型为U的初始值， 把数组[T]中每一个元素传入到combine的闭包函数里面，通过计算得到最终类型为U的结果值。 +计算数组中所有数字的和，积 常规方式实现： var sum = 0 for number in numberArray { sum += number } print(sum) var product = 1 for number in numberArray { product = product * number } print(product) 使用reduce实现： sum = numberArray.reduce(0, combine: {$0 + $1}) print(sum)
三、字典
字典允许按照某个键来访问元素
字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合
键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的
Swift字典类型是Dictionary，也是一个泛型集合。
字典的初始化
- 使用let修饰的数组是不可变字典
- 使用var修饰的数组是可变字典
// 定义一个不可变字典
let dict2 = ["name" : "why", "age" : 18]
// 定义一个可变字典
var dict1 := [String : NSObject]()
在声明一个Dictionary类型的时候可以使用下面的语句之一
var dict1: Dictionary<Int, String>
var dict2: [Int: String]
声明的字典需要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的
// 定时字典的同时,进行初始化
var dict = ["name" : "why", "age" : 18]
// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]
//作为参数
init(dict: [String : AnyObject]){
}
字典的基本操作
// 添加数据
dict["height"] = 1.88
dict["weight"] = 70.0
// 删除字段
dict.removeValueForKey("height")
// 修改字典
dict["name"] = "lmj"
// 查询字典
dict["name"]
字典的遍历
// 遍历字典中所有的值
for value in dict.values {
print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
print(key)
}
// 遍历所有的键值对
for (key, value) in dict {
print(key，value)
}
字典的合并
// 字典的合并
var dict1 = ["name" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
dict2[key] = value
}
四、方法的书写
方法调用 闭包中必须使用 self，类中使用时不必加self
func 函数名(形参列表) -> 返回值类型 {
// 函数体...
}
有参数、无返回值：
func switchMethod(a:Int) -> (){
switch a {
case 100:
print("值为100")
default:
print("常规值")
}
}
无参数、有一个返回值：
func backCountValue() -> String {
let strq = "backCountValue"
let strq1 = "New"
let str1 = strq1+strq
return str1
}
无参数、有二个返回值：
func getNume()->(a:Int,b:Int)
{
return (2,3)
}
有若干个不确定的参数、有一个返回值：
//写一个可变参数的函数只需要在声明参数时在类型后面加上 ... 就可以了
//输入的 input 在函数体内部将被作为数组 [Int] 来使用，
func sum(input:Int...)->Int{
return input.reduce(0, {$0+$1})
}
函数的外部参数
//外部参数 width是提供给调用方来进行使用的，方便调用方明白函数里面参数的具体意思
//内部参数 a 是提供给函数内部使用的
func square(width a: Int,height b: Int) -> Int{
return a * b
}
五、访问修饰符
在Swift语言中，目前有五种修饰符，有 open public internal fileprivate private 这五个访问权限，都可以修饰属性和方法。
1、private
private修饰的属性或者方法只能在当前类里面访问。
2、fileprivate
fileprivate访问级别所修饰的属性或者方法在当前的Swift源文件里可以访问，
(上面例子中private改为fileprivate就不会报错)
3、internal（默认访问级别，internal修饰符可写可不写）
internal访问级别所修饰的属性或方法在源代码所在的整个模块都可以访问。
如果是框架或者库代码，则在整个框架内部都可以访问，框架由外部代码所引用时，则不可以访问。
(默认权限，如果项目没有进行组件化开发，整个APP项目内都是可以访问的。)
4、public
可以被任何人访问，但是在其他模块中不可以被重写和继承，而在本模块中可以重写和继承
5、open
可以任何人使用，包括重写和继承。
5种修饰符访问权限排序
open>public>internal>fileprivate>private
网友评论