Swift基本语法

作者: l1Dan | 来源:发表于2015-06-27 22:17 被阅读0次

Swift 基本语法04-"switch"和
Swift 基本语法06-数组和字典
Swift 基本语法03-"if let"和
Swift 基本语法05-"String"
Swift基本语法之函数
Swift基本语法之数组和字典
Swift基本语法之元组和可选类型
Swift基本语法之闭包
Swift 基本语法02-"let"和&qu
Swift基本语法之类的使用

<h3>写在前面的话</h3>

Hi你好！在你要往下读这篇文章时，我希望你能花几十秒读完这段“写在前面的话”。这是我第一次写文章，文笔不好哈！！！首先我是一名iOS开发者，最近在学Swift，这是我的博客。写博客其实是我一直想做的事，因为一直有事所以拖到现在，这里写的大多是我学习的心得，又或者说是我目前学习的进度。我希望通过写博客这样一种方式来跟大家沟通交流，以后我大概会一个礼拜写一篇文章，这是我对自己的要求。基于我也是刚刚开始接触Swift，所以难免会写错，有些地方也可能写得不好，希望大家多多包涵！如果你有什么疑问或者文章中有哪里写得不对的地方你可以在下方评论留言，我会及时回复的。文章中如果我有引用到别人写的文章，或者转载别人的文章，我也会署名出处。言归正传。如果你看到这句话，我要说一声谢谢！！！

关于Swift的介绍我就不多说了，大家可以去看苹果的官方文档，下面是连接：<a href="https://developer.apple.com/swift/">https://developer.apple.com/swift/</a>

Swift支持的最低IDE环境是Xcode6.0；

<h3>快速预览 </h3>
一般来说学习编程语言首先就是打印一条<code>Hello, World</code>，Swift用一条代码就可以实现输出’Hello, World’。学习Swift我们可以充分利用Xcode6的新特性，打开Xcode6选择新建一个<code>playground</code>文件，如果输入正确的代码是正确的在<code>playground</code>文件的右边的代码预览区就会出现运行时的结果。现在我们来完成‘Hello, World‘的输出：
<pre><code>println("Hello, World!")</code></pre>
像上面这样我们就完成了，不用像C或者Objective-C一样。不需要<code>main</code>函数，也不需要<code>;</code>。因为全局作用域的代码会被当做程序的入口点，按下回车键就等于语句的结束，当然你加上分号也是对的。如果一行中有多句代码，那么必须加上分号分隔开。以后的代码我就不加分号了，因为这是官方推荐的。

<h3>基本语法</h3>
<ul>
<li>语法一：变量与常量</li>
</ul>

用var表示可变变量，let表示不可变变量即常量。这里的常量不同于平常所说的常量。像java中的常量在编译期间就已经确定，并保存在常量池中。这里的常量在编译期间并不需要有明确的值，但他们有一个共同的特点就是一经赋值，后面便不能再次修改。如果我们有一个值在多个地方用到并且是固定不变的，那么我们就可以采用常量。let常量可以代替static修饰的变量与宏定义。
<pre><code>
let ID = "tableViewCell"
let width = 320
</code></pre>

声明变量的同时我们可以指定变量的类型,将上面的代码稍加修改就可以了，就像下面这样：

<pre><code>let ID : String = "tableViewCell"
let width : Int = 320
</code></pre>

其实他们都是一样的，只不过上面没有指定类型。如果没有指定类型编译器会自动推断类型，也可以得出ID是String类型的。赋值时ID就必须是String类型，width也必须是Int类型。下面的代码是错误的：

<pre><code>var apples = 20
var apple = apples + 3.0
</code></pre>

Swift是一门类型安全的语言，值永远不会被隐式转换为其他类型。这里的apple是Float类型apples是Int类型，所以它们相加是错的。这里就需要显示转换：

<pre><code>var apple = Float(apples) + 3.0
let label = "The width is"
let width = 94
let widthLabel = label + String(width)
</code></pre>

我们还可以用<code>\( )</code>来转换成字符串：

<pre><code>var myAge = 23
var myName = "l1Dan"
println("my name is \(myName), and my age is \(myAge)")
</code></pre>
<pre><code>
func int2String (num : Int) -> String {
return "\(num)"
}
int2String(20)
</code></pre>

创建数组与字典。Swift数组与字典的创建非常相似。

<pre><code>let arrayOfIntegers : [Int] = [1, 2, 3]
let implicitArrayOfIntegers = [6, 7, 8]
let anOtherArray = [Int]()
</code></pre>

上面是创建数组的三种方式：

第一个是创建一个Int类型的数组。第二个自动推断为Int类型数组，暗含数组类型。第三个是创建一个空数组。

可以通过下标来访问数组。

<pre><code>arrayOfIntegers[2]
</code></pre>

这样访问的是arrayOfIntegers数组下标为2的元素，也就是第三个元素即:3;

我们还可以通过下标来操作数组：

<pre><code>var myArray = [1, 2, 3]
</code></pre>

在数组末尾添加一个元素：

<pre><code>myArray.append(4)
</code></pre>

在数组末尾插入一个元素：

<pre><code>myArray.insert(5, atIndex: 0)
</code></pre>

根据下标删除一个元素：

<pre><code>myArray.removeAtIndex(4)
</code></pre>

快速颠倒数组内容 reverse：

<pre><code>myArray.reverse()
</code></pre>

下面我们来学习数组的创建：

<pre><code>var crew = [
"Caption": "Jean-Kuc Picard",
"First officer": "William Riker",
"Second Officer": "Data"
];

crew["Intern"] = "Wesley Crusher"
println(crew)

var aNumberDictionaty = [1 : 2] 可以用整数表示键&值
occupations = [:] 空字典
</code></pre>

用<code>if</code>和<code>switch</code>是选择语句，用它们来进行条件操作：

<pre><code>if 1 + 1 == 2 {
println("The math checks out!")
}

let integerSwitch = 3
</code></pre>

用Int类型切换

<pre><code>switch integerSwitch {
case 0:
println("It is 0")
case 1:
println("It is 1")
case 2:
println("It is 2")
default:
println("It is something else")
}
</code></pre>

我们看到<code>if</code>和<code>switch</code>条件都没有用括号括起来，上面的语句其实是对的，括号是可以省略的。但是循环体的大括号是必须的。哪怕循环体中只有一句代码。在<code>if</code>语句中判断条件必须是一个布尔表达式也就是说下面这样写是错的:

<pre><code>var miss = 2
if miss {
println("Error!!!")
}
</code></pre>

在<code>switch</code>语句中不用加break来终止语句。只要一找到结果程序会自动退出<code>switch</code>语句。<code>switch</code>中的<code>default:</code>可写也可以不用写，这要看情况。如果能够确定<code>switch</code>语句中的说有情况就可不写，如果不能确定就需要写。

用Int类型切换

<pre><code>switch integerSwitch {
case 0:
println("It is 0")
case 1:
println("It is 1")
case 2:
println("It is 2")
default:
println("It is something else")
}

let stringSwitch = "Hello"
switch stringSwitch {
case "Hello":
println("A greeting")
case "Godbye":
println("A farewell")
default:
println("someting else")
}
</code></pre>

用元组切换

<pre><code>let tupleSwitch = ("Yes", 123)
switch tupleSwitch {
case ("Yes", 123):
println("Tuple contains 'Yes' and '123' ")
case ("Yes", _):
println("Tuple contains 'Yes' and someting else")
default:
break
}
</code></pre>

用一段范围做切换条件

<pre><code>var someNumber = 15
switch someNumber {
case 0...10:
println("Number is between 0 and 10")
case 11...20:
println("Number is between 11 and 20")
default:
println("Number is someting else")
}
</code></pre>

使用<code>for-in、for、while和do-while</code>来进行循环。

使用<code>while</code>来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。

<pre><code>var n = 2
while n < 100 {
n = n * 2
}
n

var m = 2
do {
m = m * 2
} while m < 100
m
</code></pre>

你可以在循环中使用<code>..<</code>来表示范围，也可以使用传统的写法，两者是等价的：

<pre><code>var firstForLoop = 0”
for i in 0..<4 {
firstForLoop += i
}
firstForLoop

var secondForLoop = 0
for var i = 0; i < 4; ++i {
secondForLoop += i
}
secondForLoop
</code></pre>

使用<code>..<</code>创建的范围不包含上界，如果想包含的话需要使用<code>...</code>。

<ul>
<li>语法三：函数和闭包</li>
</ul>

函数以func开头

无参无返回值

<pre><code>func firstFuncation() {
println("Hello")
}
</code></pre>

无参有返回值返回类型是Int Swift用 <code>-> </code>来表示有返回，后面接返回值类型

<pre><code>func secondFuncation() -> Int {
return 123
}
</code></pre>

有参数有返回值有两个Int类型的参数并且有一个Int类型的返回值。

<pre><code>func thirdFuncation(firstValue: Int, secondValue: Int) -> Int {
return firstValue + secondValue
}
</code></pre>

有多个参数和多个返回值

<pre><code>func fourthFuncation(firstValue: Int, secondValue: Int) -> (doubled: Int, quadrupled: Int) {
return (firstValue * 2, secondValue * 4)
}
fourthFuncation(2, 4)
fourthFuncation(3, 5).1
fourthFuncation(4, 6).doubled
</code></pre>

返回两个数相加的和 <code>firstNumber</code>与 <code>secondNumber</code>是外部参数，<code>num1</code>与<code>num2</code>是内部参数。如果函数定义了外部参数，在调用时就必须使用外部参数名字。

<pre><code>func addNumbers(firstNumber num1: Int, secondNumber num2: Int) -> Int {
return num1 + num2
}
addNumbers(firstNumber: 3, secondNumber: 4)
</code></pre>

函数的内部参数前面加上<code>#</code>就可以变成外部参数。

<pre><code>func multiplyNumbers(#firstNumber: Int, #multiply: Int) -> Int {
return firstNumber * multiply
}
multiplyNumbers(firstNumber: 3, multiply: 4)
</code></pre>

函数参数还可以有默认值<code>multiplyNumber: Int = 2</code> 当我们第二个参数不传是默认值就是2。有默认参数的结论：如果一个函数含有默认参数，那么它的最后一个参数一定是默认参数。

<pre><code>func multiptyNumbers2(firstNumer: Int, multiplyNumber: Int = 2) -> Int {
return firstNumer * multiplyNumber
}
multiptyNumbers2(3)
</code></pre>

<code>…</code>表示参数个数不确定，也就是说可以传入多个参数。

<pre><code>func sumNumbers(numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
sumNumbers(2, 3, 4, 5)
</code></pre>

两个数的交换（传值与传地址）

<pre><code>func swapValues(inout firstValue: Int, inout secondValue: Int) {
let tempValue = firstValue
firstValue = secondValue
secondValue = tempValue
}
var swap1 = 2
var swap2 = 3
swapValues(&swap1, &swap2)
</code></pre>

将函数用作变量: 只要一个函数的参数与返回值类型都与声明中的函数相同，就可以将它存储在这个变量中。

<pre><code>var numbersFunc:(Int, Int) -> Int
numbersFunc = addNumbers
numbersFunc(2, 3)
func timesThree(number: Int) -> Int {
return number * 3
}
</code></pre>

函数接受其他函数并且使用它们

<pre><code>func doSomethingToNumber(aNumber: Int, thingToDo: (Int) -> Int) -> Int {
return thingToDo(aNumber)
}
doSomethingToNumber(4, timesThree)
</code></pre>

函数返回其他函数

<pre><code>func createAdder(numberToAdd: Int) -> (Int) -> Int {
func adder(number: Int) -> Int {
return number + numberToAdd
}
return adder
}
var addTwo = createAdder(2)
addTwo(2)
</code></pre>

一个函数还可以捕获一个值，并多次使用

<pre><code>func createIncrementor(incrementAmiunt: Int) -> () -> Int {
var amount = 0
func incrementor() -> Int {
amount += incrementAmiunt
return amount
}
return incrementor
}
var incrementByTen = createIncrementor(10)
incrementByTen()
incrementByTen()

var incrementByFifteen = createIncrementor(15)
incrementByFifteen()
</code></pre>

闭包排序

<pre><code>var sortingInline = [2, 5, 86, 2, 13, 47]
sort(&sortingInline)
sortingInline

var numbers = [3, 65, 92, 2, 100, 0, 2]
var numbersSorted = sorted(numbers, {(n1: Int, n2: Int) -> Bool in

return n2 > n1
})</code></pre>

Swift 基本语法04-"switch"和
Swift 基本语法01-Swift简介Swift 基本语法02-"let"和"var"Swift 基本语法03-...
Swift 基本语法06-数组和字典
Swift 基本语法01-Swift简介Swift 基本语法02-"let"和"var"Swift 基本语法03-...
Swift 基本语法03-"if let"和
Swift 基本语法01-Swift简介Swift 基本语法02-"let"和"var"Swift 基本语法04-...
Swift 基本语法05-"String"
Swift 基本语法01-Swift简介Swift 基本语法02-"let"和"var"Swift 基本语法03-...
Swift基本语法之函数
Swift基本语法之初体验-常量变量-数据类型 Swift基本语法之逻辑分支 Swift基本语法之循环 Swift...
Swift基本语法之数组和字典
Swift基本语法之初体验-常量变量-数据类型 Swift基本语法之逻辑分支 Swift基本语法之循环 Swift...
Swift基本语法之元组和可选类型
Swift基本语法之初体验-常量变量-数据类型 Swift基本语法之逻辑分支 Swift基本语法之循环 Swift...
Swift基本语法之闭包
Swift基本语法之初体验-常量变量-数据类型 Swift基本语法之逻辑分支 Swift基本语法之循环 Swift...
Swift 基本语法02-"let"和&qu
Swift 基本语法01-Swift简介Swift 基本语法03-"if let"和"guard let"Swif...
Swift基本语法之类的使用
Swift中类的使用 Swift基本语法之初体验-常量变量-数据类型 Swift基本语法之逻辑分支 Swift基本...