Swift (一)

变量和常量

在Swift中使用 let 修饰一个常量, 使用 var 修饰一个变量;

let 修饰常量的值是不可以更改的

var修饰的变量的值是可以更改的;

在声明常量和变量的时候可以用表情符号, 中文等命名常量名和变量名.

// 输出函数

print ( "Hello, World!" )
// 定义一个常量
// 方法 1:
// 定义之后 , 后面的值只能是字符串 , 因为指定了常量的类型
let name : String = " 科本 "
// 方法 2:
// 特性 : 隐式类型推断 , 由初始值来推断常量的类型
let gener = " 男 "
// 使用 let 定义的常量的值永远不可以更改

// 定义一个变量的方式
// 方式 1:
var age = 100
// 方式 2:
var height : Int = 140    //Swift 在定义一个变量或者常量的时候 , 必须要有确定的类型

let a : Int = 10

let b : String = "Hello"

let c : Character = "A" //字符使用双引号,但是只能放单个字符

let d : Bool = false // false 和 ture

字符串String

有序的字符的集合 

// 创建一个字符串类型的常量

let string = " 科本 "

// 创建一个值为空的字符串

let string1 = ""

let string2 = String ();

// 字符串拼接

var name = " 曼森 "

var newName :  String = name + “520"

// 获取字符串的长度

print ( newName . characters . count )

// 运算符重载 当对两个字符串类型做加法操作时 , 会自动拼接到一起

let q = " 科特 "

let w = " 科本 "

let r = q + w

//Swift 不支持 隐式类型转化

var age = 100

let e = "Cobain's age is"

let words = e + String ( age )

// 如果想要对两个不一样的数据类型的变量或者常量进行运算 , 需要使用这样的格式 :

// 变量 ( 常量 ) A +\-\*\/ 目标类型 (B)

var width = 100.2

var f = width + Double ( height )

数组

// 定义空数组
var array3 = [ String ]()

// 向数组中追加一个元素

array1 . append (108)

// 使用运算符重载 向数组中追加一个或多个元素

array1 += [502]

// 在数组指定位置插入一个元素

array1 . insert ( " 洪七公 " , atIndex: 2)

// 向数组指定位置插入 一个相同类型的集合数据
let array5 = [ " 黄蓉 " , 52]

array1 . insertContentsOf ( array5 , at: 2)

// 全部删除
array1 . removeAll ()
// 全部删除 但保留内存
array1 . removeAll (keepCapacity: true )
// 删除第一个元素
array1 . removeFirst ()
// 从第一个元素开始删除几个
array1 . removeFirst (2)
// 删除指定位置的元素
array1 . removeAtIndex (2)
// 删除最后一个元素
array1 . removeLast ()
// 删除 range 范围的元素 ( 包含起始索引 , 不包含终止索引 )
let range : Range = Range . init (start: 1, end: 4)
array1 . removeRange ( range )

//

print ( "kiki \ ( array )" )

字典

// 定义一个字典

var dict = Dictionary <</span>String, Int>()

let dictionary = [ "a" : 1, "b" : 2]

// 当 key 的类型不一样时 , key 就为 NSObject 类型
let dictionary1 = [ "a" : 1, 2 : "b" ]

// 提前指定 key 和 value 的类型 创建一个字典

let dictionary2 : [ Int : String ] = [1 : "a" , 2 : "b" ]

// 可以直接通过 key 值访问字典中的元素
print ( dictionary2 [1])

var dictionary3 = [ " 欧阳锋 " : " 吸毒 " , 102 : 522]

dictionary3 [ " 欧阳锋 " ] = " 西毒 "

// 对一个不存在的 key 值进行操作 , 即 插入一条数据

dictionary3 [ " 洪七公 " ] = " 北丐 "

// 让某一个 key 值为 nil 表示删除掉这个 key 和对应的 value

dictionary3 [102] = nil

dictionary3 . removeValueForKey ( " 欧阳锋 " )

元组

//元组 是一个可以返回多个值的数据格式

//在Swift里面声明的时候使用"()"声明

// 元组可以通过下标去访问元素 , 也可以通过 key 值去访问元素

//整体的数据结构有点类似C语言里面的结构体

let type = ( " 东邪 " , [ " 西毒 " , " 南帝 " ], " 北丐 " , " 伯通 " )
print ( type )

print ( type .0)

//定义数据类型

let type1 : ( String , Int ) = ( " 乔峰 " , 100)

//根据key值输出

let type2 : (name : String , age : Int ) = type1

print ( type2 .age)

循环和分支

// for循环

for var i = 0; i < 100; i++ {

    print (i)
}

for ( var i = 0; i < 100; i++){
    print (i)

}

// for in 循环遍历

// 1...10 表示全闭区间 [1,10]
// 1..<10 表示半闭区间 [1,10)
for i in 1...10 {
    print (i)

}

let animals = [ " 东邪 " , " 吸毒 " , " 南帝 " , " 北丐 " ]
for a in animals {
    print (a)
}

let dict = [ " 东邪 " : " 黄药师 " , " 西毒 " : " 欧阳锋 " ]
for b in dict {
    print (b)
}

for (key, value) in dict {
    print ( "key : \ ( key ) value : \ ( value )" )

}

//while
var number = 0
while number < 10 {
    print ( number )
    number += 1

}

// repeat while 即C中的 do...while

var num = 0
repeat {
    print ( num )
    num += 1

} while num < 10

// 分支结构
if 1==0 {
   
}

// String? 在变量的类型后面加 ? , 表示这个变量为可选类型 , 可以置为 nil
var string : String ? = "gakki"
if ( string != nil ) {
   
}

// 在 Swift 里面 , 每一个 case 里面自带一个 break

let age = 23

switch age {

case 1:

    print("age = 1")

    fallthrough  //贯穿 (不会break,而回继续走case 2)

case 2:
    print ( "age = 2" )
case 3:
    print ( "age = 3" )
case 4:
    print ( "age = 4" )
default :
    print ( "age = 5" )
}

//Swift 中的 switch 可以根据区间去获取值
switch age {
case 0...10:
    print ( " 一毛 " )
case 11...20:
    print ( " 二毛 " )
case 21...30:
    print ( " 三毛 " )
default :
    print ( " 四毛 " )
}

v ar a = 5

switch a {
case var value where a < 10 && a > 0:
    value += 1
    print (value)
default :
    print ( "Other" )
}

// Swift 中的 swift 可以对一个元组做判断
// "_" 表示忽略元组中这个位置的元素

// 条件齐全了,就可以不写default

let point = (10, 42)

switch point {
case (10, 10):
    print ( " 第一象限 " )
case ( _ , 10):
    print ( " 一 , 二 象限 " )
case (10, _ ):
    print ( " 一 , 四象限 " )
case ( _ , _ ):
    print ( " 谁知道在哪 " )

}

函数

• 无参无返回值
• 无参有返回值
• 有参无返回值
• 有参有返回值
• 无参有多个返回值
• 有参有多个返回值
• inout函数

//func + 函数名 ( 参数列表 ) -> 返回值类型 ( 无返回值可以以省略 -> Void) {}
func text() -> Void {
    print ( " 无参无返回值的函数 " )

}

text ()

// 无参有返回值
func text1() -> String {
    return " 无参有返回值 "

}

let string = text1 ()
print ( string )

// 有参无返回值
func text2(name : String , age : Int ) {
    print ( " 东邪是 \ ( name ), \ ( age )" )
}
text2 ( " 黄药师 " , age : 100)  // age : 外部参数名

/ / 有参有返回值

func text3(name : String , age : Int ) -> Array <</span>NSObject> {

    let array : Array<</span>NSObject> = [name, age]
   

return array

}

let array : [ NSObject ] = text3 ( " 西毒 " , age : 99)
print ( array )

// 函数的外部参数名 第一个名字表示外部参数名 , 当外界使用这个函数的时候使用的名字 . 第二个参数表示内部参数名 , 当函数里面使用这个参数的时候使用的名字, 外部函数可以用 _ 忽略掉

func text4(number myNumber : Int , name myName : String ) {
    print ( " 名字是 \ ( myName ), 编号是 \ ( myNumber )" )

}

text4 (number: 101, name: " 一灯 " )


// 无参数有多个返回值的
func text5() -> ( String , Int ) {
    return ( " 张三 " , 108)

}

let type = text5 ()
print ( type )

// 有参有多个返回值

func text6(name myName : NSString ,age myAge : Int ) -> ( NSString , Int ){
    return (myName, myAge)

}

let type2 = text6 (name: "kk" , age: 102)
print ( type2 )

// 函数嵌套

func text7() {
    func text() {
        print ( " 第一层嵌套函数 " )
        func text2() {
            print ( " 第二层 " )
            func text3() {
                print ( " 第三层 " )
            }
            text3 ()
        }
        text2 ()
    }
    text ()

}

text7 ();

//inout 函数

// Swift 中的参数 本身上是使用let定义的,即常量, 是不能更改的

//  如果参数 使用 inout 来修饰, 就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.

func text8( inout name : String ) {
    name = " 洪七公 "
}
var name = "PDD"

text8 (& name )

print ( name )