标签：
//MARK:
// 定义常量 (使用完第一次就不能修改它的值)
let myGender = "男";
// 定义变量
var carName = "BMW";
carName = "Audi";
print(carName)
// MARK: - 定义常量变量 : 变量类型的隐式转换
// 在Swift中如果定义常量变量不给定相关的类型,它会隐式转换成String类型
let name = "Jack" // 如果这样子定义出来一个常量,它会隐式转换成String类型
let name1 : String = "Rose" // 如果给定类型,后边赋值的时候需要根据类型进行赋值
let age : Int = 18 // 如果定义常量最好给出初始值,定义变量可以不给初始值
var age1 : Int? //?表示age1的类型为可选类型,其值可以为空
print(age1)
// 定义一个字符类型的变量
var char:Character = "A" // 赋值字符类型的时候仅需一个字母即可
// 定义一个BOOL类型的变量 [在swift中bool类型的变量只有ture或者false]
var flag : Bool = true
// MARk: - 字符串string
// 1.创建一个空的字符串
var str_emperty = ""
var str1_emperty = String()
// 2.判断一个字符串为空字符串
if str_emperty.isEmpty {
print("str_emperty is emperty")
}
// 3.字符串的拼接
var str_url = "http://"
var str = "www.baidu.com"
var str_new_url = str_url + str
print(str_new_url)
print("百度网址:\(str_new_url)\n") // \(变量名)输出相关的内容 [插入式取值]
// 4.获取字符串的长度
var str1 : String = "abcdef"
print(str1.characters.count)
// 5.字符串的比较
var str2 = "MBBoy"
var str3 = "GBLW"
if str2 != str3 {
print("两个字符串不相等")
}
// MARK: - 数组
// Swift中数组中的元素类型必须相同
// 定义一个数组
var nameArray = ["yuanyuan", "GBLW", "WYW"]
print(nameArray)
var nameArray1 : Array<String> = ["YQ", "XQ", "FatZhou"]
//定义一个空数组(字符串)
let array = Array<String>()
print(array)
// 访问数组中的元素
print(nameArray[1])
// 向数组中添加元素
var int_array = Array<Int>()
int_array.append(520)
int_array.append(123)
print(int_array)
// 使用运算符添加数组元素
int_array += [100,99]
print(int_array)
// 使用运算符添加多个元素
int_array += [999,888,777]
print(int_array)
// 插入元素到具体的位置
int_array.insert(521, atIndex: 1)
print(int_array)
// 移除某个元素
int_array.removeAtIndex(2);
print(int_array)
// 移除所有元素
int_array.removeAll()
print(int_array)
// MARK: - 字典
// 定义一个字典类型的变量
var dic : Dictionary<String,Int> = ["a":18, "b":69,"c":38]
print(dic)
// 定义空字典
var dic1 : Dictionary<String,Int> = [:]
var dic2 = Dictionary<String,Int>()
//往字典里添加键值对
dic["d"] = 50
print(dic)
// 修改字典中的内容 (根据键去修改值)
dic["a"] = 90
print(dic["a"])
// 删除字典中的键值对
dic.removeValueForKey("b")
print(dic)
// MARK: - 元组
//定义一个元组
// 方法一: 直接初始化一个元组 (使用Swift隐式转换的特点)
let tuples = ("蓝鸥1班",["iOS","html5", "Android"])
print(tuples)
// 方法二: 显示初始化的方式
let tuplesNew : (String,Array) = ("蓝鸥8班",["iOS", "html5", "Android"])
// 取出元组中值
// 第一种取值方式 : 直接把元素赋值给另一个常量,根据相关标记进行取值
let tuplesNew1 : (classroom:String,course:Array) = tuplesNew
var classInfo = tuplesNew1.classroom + tuplesNew1.course[0] + tuplesNew1.course[1] + tuplesNew1.course[2]
print(classInfo)
// 第二种取值方式: 直接根据下标取值
var classInfoNew = tuplesNew1.0 + tuplesNew1.1[0] + tuplesNew1.1[1] + tuplesNew1.1[2]
print(classInfoNew)
// MARK: - 循环
// 第一种形式:
for var i = 1;i < 10;i++ {
print(i)
}
// 第二种形式
for number in 1..<10
{
print(number)
}
// 第三种形式
for number1 in 1...10
{
print(number1)
}
// while循环和repeat...while
var i = 8
while i > 0
{
i--
print(i)
}
repeat { // 先执行一次循环体,再进行相关的循环
print("I love you")
} while 1 < 0
// 使用循环遍历数组
var animalArray = ["dog", "pig", "cat", "tiger"]
for animal in animalArray
{
print(animal)
}
// 使用循环遍历字典
var animalDic = ["dog":"??","pig": "??", "cat": "??"]
for (key,value) in animalDic
{
print("key = \(key), value = \(value)")
}
// MARK: - 分支结构(if结构和switch格式)
// if形式
let flag1 = true
if flag1 == true
{
print("我是真的I love you")
} else {
print("I love you. too")
}
// swithch形式使用fallthrough实现贯穿每种可能
let value = 0
switch value
{
case 0:
print("0")
fallthrough
case 1:
print("1")
fallthrough
default:
print("other")
}
// 特点二:case后可以使用一个范围
switch value
{
case 0..<10:
print("输出0-10之间的数值")
case 10...100:
print("输出10-100之间的数值")
default:
print("other")
}
/**
* 特点三:case 后可以使用 (let和var修饰的常量或者变量)where是满足某种条件
*/
switch value
{
case var i where value >= 0 && value < 6:
i = 99
print(i)
default:
print("other")
}
// 特点4: case后还可以匹配一个元组
let point = (10,10)
switch point
{
case (10,0):
print("111111")
case (10,8):
print("222222")
case (_,10): // _ 代表可以忽略某个元素
print("333333")
case (10,10):
print("4444444")
default:
print("other")
}
// MARK: - 枚举(enum)
// 枚举原始类型为int类型的
enum Direction:Int
{
case east = 0
case south = 1
case west = 2
case north = 3
}
print(Direction.east.rawValue) // rawValue就是找到相对应枚举的原始值
// 枚举原始类型为String类型的
enum Season:String
{
case spring = "春天"
case summer = "夏天"
case autumn = "秋天"
case winter = "冬天"
}
print(Season.autumn.rawValue)
// 根据原始值获取枚举的类型
print(Direction(rawValue: 2))
// MARK: - 函数
// 表示函数的关键字: func
// 函数的类型有: 四种
// 1: 无返回值,无参
func function1() -> Void
{
print("无返回值,无参数")
}
function1();
// 2: 无返回值,有参数
func function2(name str:String) -> Void
{
print(str)
}
function2(name: "雷坤")
// 3.有返回值, 无参数
func function3() -> String
{
return "雷神"
}
print(function3())
// 4. 有返回值,有参数
func function4(num1:Int,num2:Int) -> Int
{
return num1 + num2
}
print(function4(5, num2: 6))
// 函数的返回值为元组类型的
func function5(num1:Int,num2:Int) -> (Int,Int)
{
return (num1 + num2,num1 - num2)
}
print(function5(9, num2: 2))
// 外部参数和内部参数
// first和second为外部参数, 在函数调用的时候会显示出来这两个名称 one 和 two 为内部参数, 在函数内部使用
// 默认的情况下,第一个外部参数在调用的时候不显示,其余的均显示,而且和你定义的名字一样
func function6(first one:Int,second two:Int)
{
print((one,two))
}
function6(first: 10, second: 10)
// 如果不都想显示外部参数
func function7(one:Int,_ two:Int) // "_" 忽略的作用
{
print("忽略外部参数")
}
function7(8, 9)
// 函数的嵌套
/*
func test1()
{
func test2(){
func test3(){
print("hello world")
}
test3()
}
test2()
print("??????")
}
test1()
// inout修饰的参数
func test(inout name:String)
{
name = "MBBoy"
print(name)
}
var myName = "leikun"
print("myName:\(myName)")
test(&myName)
print(myName)
*/
func admin(var name:String)
{
name = "MBBoy"
print("nameOld = \(name)")
}
var myName = "dog"
print("myName = \(myName)")
admin(myName)
print("myName = \(myName)")
3. ? 和 ! 的区别
？的使用场景：
1）声明Optional值变量
2）在对Optional值操作中，用来判断是否能响应后面的操作
！的使用场景：
1）强制对Optional值进行拆包
2）声明隐式拆包变量，一般用于类中的属性
3)用?修饰的变量不能直接强制转型、会被标识为Optional变量等
如果你在隐式解析可选类型没有值的时候进行取值，会crash。和在没有值的可选类型里面拆包是一样的。
1）OC中，nil是一个指向不存在对象的指针；
2）Swift中，nil不是指针，它是一个确定的值，用于表示值缺失。任何类型的可选状态都可以设置为nil，不只是对象类型；
标签：
原文地址：http://www.cnblogs.com/leikun1113/p/5521044.html
