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
在定义一个变量或者常量的时候,必须要有确定的类型

leta
: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循环

forvar
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("四毛")

}

var
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)