Swift| 基础语法（三）

// 字符串遍历
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("!=====")
}

let s1 = "abc"
let s2 = "xyz"
if s1 > s2 {
    print("大于")
} else {
    print("小于")
}

// 定义一个不可变数组
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]

// 遍历数组
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

// 定义一个不可变字典
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
}

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
}

  1、private 
  private修饰的属性或者方法只能在当前类里面访问。
  2、fileprivate 
  fileprivate访问级别所修饰的属性或者方法在当前的Swift源文件里可以访问，
  (上面例子中private改为fileprivate就不会报错)
  3、internal（默认访问级别，internal修饰符可写可不写） 
  internal访问级别所修饰的属性或方法在源代码所在的整个模块都可以访问。 
  如果是框架或者库代码，则在整个框架内部都可以访问，框架由外部代码所引用时，则不可以访问。 
  (默认权限，如果项目没有进行组件化开发，整个APP项目内都是可以访问的。)
  4、public 
  可以被任何人访问，但是在其他模块中不可以被重写和继承，而在本模块中可以重写和继承
  5、open 
  可以任何人使用，包括重写和继承。