iOS中 Swift初级入门学习(一)

版权声明：本文为博主原创文章，未经博主允许不得转载。

/  

//  copyright (c) 2015年 韩俊强. all rights reserved.  

//  

import foundation  

// swift当中的输出函数  

// println swift2.0 之前使用的输出函数, 可以自动换行  

// print swift2.0之前自动换行, swift2.0之后可以自动换行  

println("hello, world!")  

// 单行注释和以前一样  

// 块注释  

/*  

      块注释  

    /*  

     可以嵌套注释  

    */  

*/  

// 如何声明一个常量 规则: let 常量名: 类型 = 值  

// swift当中我们不必再代码语句的结尾处加分号, 但是如果一行中写了几句代码, 那么代码之间就要用分号隔开  

let a: int = 5;    let b: int = 10  

// 如何声明一个变量 var 变量名: 类型 = 值  

// character 字符型  

var c: character = "a"  

println(c)  

// 常量的值不可以发生改变, 变量的值可以改变  

// a = 10 错误  

c = "b"  

// 命名规则  

// 我们可以使用大部分的特殊符号, 中文也可以, 数字, 字母, 下划线, 但是非法的unicode编码, 数字符号, 标志符是不可以的  

let 小韩哥: string = "好帅"  

<pre name="code" class="plain">// 类型推断  

// swift 会根据我们给常量或者变量赋的值来推断我们常量或者变量的类型  

let 常量 = 10  // 根据推断: 常量是int类型  

var 变量 = 20 // 变量是一个int 类型  

// swift是一门类型安全的语言, 我们不能给一个类型的变量赋给另一个类型  

// 变量 = 19.5 错误  

变量 = 30  

println(变量)  

// 数值字面量  

// 20, 10 , 字符串  

// 0b  

//let ab = 1011  

//println(ab)  

let ab = 0b1010  

println(ab)  

// 八进制值字面量  

let ac = 0o17  

println(ac)  

// 十进制字面量, 默认的数组就是十进制  

let ad = 18  

// 十六进制字面量 0x 开头  

let ae = 0xabc  

println(ae)  

// 字符串插值  

// swift当中没有占位符, 我们可以以字符串插值的形式当做占位符 \(), 括号中存放常量或者变量的名字  

let af = "hello,wold"  

println("af = \(af)")  

// 类型转换  

let 浮点型: float = 15.9  

let 整型: int = 20  

// 不同类型不可以直接做运算  

// 浮点型转化成int类型 int()  

//  int类型转化为浮点型  float()  

let result = int(浮点型) + 整型  

// 打印最大值, 最小值  

println(int8.max)  

println(int16.min)  

println(uint8.max)  

println(uint8.min)  

// 类型别名的使用  

typealias newint32 = int32;  

println(newint32.max)  

// 布尔值 只有true false  

var 布尔值 = true  

println(布尔值)  

布尔值 = false  

// 元组  

// 多个不同类型的值组合成的一个复合值  

let 元组 = ("小明",28,95.5);  

// 取出元组里面的值  

// 通过元组名. 下标的形式取出元组的内容  

println(元组.0)  

println(元组.2)  

// 如果我们声明元组的时候,给元组里面的内容前加一个名字, 那么我们就可以通过 元组名.元素名字 的方式取出元组里面的内容  

let 小韩 = (身高: 170,年龄:25 )  

println(小韩.身高,小韩.年龄)  

// 元组的分解  

let (身高,年龄) = 小韩  

println(身高,年龄)  

// 可选类型  

// 可选类型是用来处理值缺失的情况, 一个变量声明成可选类型的话, 证明这个变量可能有值,也可能未空  

// 声明一个可选类型  

var str: string?  

println(str)  

str = "hello,good morning"  

// 我们要使用可选类型变量值的话,需要把可选类型里面的值解析出来, 方式:变量名 + ! ,这种方式叫做强制解析  

var astr = "95588"  

var aintofoptinal = astr.toint()  

println(aintofoptinal)  

// 强制解析之前我们要确保变量有值, 如果没有值, 我们不能在可选类型后面 + !来强制解析  

var result1 = aintofoptinal! + 10  

println(result1)  

// 隐式解析类型  

// 为了我们使用可选类型的时候, 不用发每次都用强制解析的方式取值, 我们可以在声明变量的时候在类型标注后面不用? 而用!的形式  

// for example  

var 隐式解析类型: int!  

println(隐式解析类型)  

隐式解析类型 = 20;  

// 断言  

// 起到断点调试的作用  

var bstr: string?  

bstr = "忘赋值了"  

assert(bstr != nil, "字符串不为空")  

println(bstr!)  

// 运算符  

// 根据操作数的不同, 运算符可以分为一元, 二元, 三元运算符  

// + - *  /  %  

// +   

let a = 3; let b = 5  

var c = a + b  

println("c = \(c)")  

// -   

c = b - a  

// *  

c = a * b  

// /  

c = b / a  

// %  

c = a % b  

// 自增, 自减运算  

// ++  

var anumber = 10  

// ++ 在前取新值, ++ 在后取旧址 , 不管++在变量的前面, 还是在变量的后面, 该变量都会自增1  

let result = ++anumber + anumber++ + ++anumber  

println("result = \(result)")  

println(anumber++)  

// --  

let result2 = --anumber - anumber-- + --anumber  

println(--anumber)  

println(result2)  

// 复合运算符  

// +=   -=    /=     %=  

// +=  

var 变量 = 10  

变量 += 5 // 变量 = 变量 + 5  

// -=  

变量 -= 5  

//  /=  

变量 /= 2  

// %=  

变量 %= 1  

// 三目运算符  条件 ? 值1 : 值2 条件为真的时候取值1, 条件为假的时候取值2  

let maxnumber = 5; let minnumber = 3  

let result3 = maxnumber > minnumber ? maxnumber : minnumber  

println(result3)  

// 比较运算符 >, < , <= , >= ,== , !=  

if maxnumber > minnumber {  

    println( "\(maxnumber) 比 \(minnumber) 大")  

}  

if maxnumber < minnumber {  

    println("\(maxnumber) 比 \(minnumber) 小")  

if maxnumber <= minnumber {  

    println("\(maxnumber) 不比 \(minnumber) 大")  

if maxnumber >= minnumber {  

    println("\(maxnumber) 不比 \(minnumber) 小")  

if maxnumber != minnumber {  

    println("\(maxnumber) 不等于 \(minnumber) ")  

if maxnumber == minnumber {  

    println("\(maxnumber) 等于 \(minnumber)")  

// 逻辑运算符, 逻辑与 &&, 逻辑或 || , 逻辑非 !  

// 注意  逻辑与 逻辑或 的短路现象  

// 逻辑与 运算符前面条件为假, 运算符后面的语句就不走(一假即真)  

// 逻辑或 运算符前面条件为真, 运算符后面的语句就不走(一真即真)  

// 逻辑非 取反  

var num = 10  

if num++ == 10 || num-- > 0 {  

    println(num)  

// 空合运算符 ??   

var str = "123"  

var num3 = str.toint()  

// 判断一个可选类型, 如果为空,就给一个常量赋值 567, 如果不为空, 就取这个可选类型变量解析出来的值  

// 等价于  

if num3 == nil {  

    let result = 567  

    println(result)  

} else {  

    let result = num3!  

let result4 = num3 == nil ? 567 : num3!  

println(result4)  

let result5 = num3 ?? 567  

println(result5)  

// 区间运算符  

// (a...b) 包含 a 到 b 范围内的数, 且包含 a 和 b  

// (a..<b) 包含 a 到 b 范围的数, 包含 a  不包含 b  

for 数字 in (1...9) {  

    println(数字)  

for number in (1..<9) {  

    println(number)  

// 字符串  

// 在swift当中没有可变字符串与不可变字符串之分, 字符串的可变与不可变只有我们用let. 还是var 来修饰有关, 如果let修饰,那么字符串不可变, var 修饰,这个字符串就可变  

var str = "hello,word"  

// 遍历字符串中的每个字符  

for 字符 in str {  

    println(字符)  

// 字符串的拼接, 我们可以直接通过运算拼接字符串  

str += " = 你好世界!"  

// 这种方式只能拼接一个字符, 并且字符的位置在字符串的最后  

let charactor : character = "啊"  

str.append(charactor)  

// 判断字符串是否有前后缀  

let astr = "meinv.png"  

if astr.hasprefix("meinv") {  

    println("有前缀meinv")  

}else{  

    println("没有前缀")  

// 判断字符串是否有后缀  

if astr.hassuffix(".png") {  

    println("png格式")  

    println("其他格式")  

// 判断字符串是否为空  

if astr.isempty {  

    println("字符串为空")  

    println("字符串不为空")  

// 全部大写  

let resultofstr = astr.uppercasestring  

println(resultofstr)  

// 全部小写  

let resultofstr1 = astr.lowercasestring  

println(resultofstr1)  

// 首字母大写  

let resultofstr2 = astr.capitalizedstring  

println(resultofstr2)  

// oc里面的字符串  

let bstr : nsstring = "hello"  

let resultofstr3 = bstr.length  

println(resultofstr3)  

// 数组  

// 通过构造方法来创建一个空数组  

var array : array<string> = array()  

// 第二种  

var array1 = [int]()  

// 第三种  

var array2 : [string] = array()  

// oc里面创建数组  

var array3 = nsarray()  

var arrayofbook = ["金瓶梅","玉女心经","玉蒲团","一路向西"]  

// 修改数组中的元素  

arrayofbook[3] = "西游记"  

for element in arrayofbook {  

     println(element)  

// 另一种方式  

for (index,value) in enumerate(arrayofbook){  

    println((index,value))  

// swift2.0之后写法 点语法  

//for (不知道,不知道2) in arrayofbook.enumerate{  

//    println((不知道,不知道2))  

//}  

arrayofbook[0...2] = ["三国演义","水浒传","红楼梦","通讯录"]  

    println(element)  

// 插入元素  

arrayofbook.insert("射雕英雄传", atindex: 0)  

// 删除元素  

arrayofbook.removelast()  

println(arrayofbook.capacity)  

// 删除所有元素  

// keepcapacity表示是否保持容量，如果参数为true的话, 同时把元素清为零,但是保留清空之前的空间, 如果参数为false 的话, 清空元素后每添加一个元素时,空间不够用时,会开辟添加上一次元素空间的2倍  

arrayofbook.removeall(keepcapacity: false)  

// 判断数组是否为空  

if arrayofbook.isempty {  

    println(arrayofbook.capacity)  

arrayofbook.insert("text", atindex: 0)  

   println(arrayofbook.capacity)  

// 字典  

// c语言的创建一个空字典方式  

var dict : dictionary<int, int> = dictionary()  

var dict2 : [string : string] = dictionary()  

// oc的形式  

var dict3 = nsdictionary()  

var studentofdict = ["name" : "小明","age" : 18]  

// 遍历子典里面的所有的key  

for key in studentofdict.keys {  

    println(key)  

// 遍历字典里所有的value  

for value in studentofdict.values{  

    println(value)  

// 给字典添加一个元素  

studentofdict["adress"] = "天下第一楼"  

println(studentofdict)  

// 删除一个元素  

studentofdict.removevalueforkey("adress")  

studentofdict["age"] = nil  

// 遍历字典里面的key和value  

for (key,value) in studentofdict {  

    println((key,value))  

原文地址：http://blog.csdn.net/qq_31810357/article/details/50032053