//swift中打印用 print,句末中可以不用分号结尾
// print("hello world");
//let声明常量 ，var声明变量
let myConstant = 42
var myVariable = 42
myVariable = 50
print(myConstant,myVariable)
//如果初始值没有提供足够的信息（或没有初始值），那需要在变量后面声明类型，用冒号分割。
let string:String = "ssss"
print(string)
//值永远不会被隐式转换成其他类型，如果需要把一个值转换成其他类型，请显示转换
let label = "the width is"
let width = 100
let widthLabel = label + String(width)
print(widthLabel)
//简单的把值转换成字符串的方法：把值写到括号中，并在括号之前写一个反斜杠
let apples = 3
let oranges = 5
let appleSummary = "I have\(apples) apple."
let fruitSummary = "I have\(apples + oranges) pieces of fruit"
print(appleSummary,fruitSummary)
//使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素，最后一个元素后面允许有个逗号。
var shoppingList = ["1","2","3","4"]
shoppingList[1] = "bottle if water"
var occupadtions = ["Malcolm":"Captain","Kaylee":"Mechanic",]
occupadtions["Jayne"] = "Public Relations"
print(shoppingList ,occupadtions);
//创建一个空数组或者字典，使用初始化语法
let emptyArray = [String]()
let emptyDictionary = [String:Float]()
//如果类型信息可以被推断出来，可以用[]和[:]来创建空数组和空字典--就像你声明变量或给函数传参数的时候一样
shoppingList = []
occupadtions = [:]
//控制流
//使用if和switch来进行条件操作，使用for-in,for,while和repeat-while来进行循环，包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的
let individuaScores = [75,43,103,87,12]
var teamScore = 0
for score in individuaScores {
if score > 50 {
teamScore += 3
}else{
teamScore += 1
}
}
print(teamScore);//输出值为11
//使用if语句中，条件必须是一个布尔表达式---这意味着像if score {...} 这样的代码将报错，而不会隐形的与0作对比。可以用if和let来处理缺失的情况，这些值可由可选值来代表，一个可选的值是一个具有的值或者是nil以表示值缺失。在类型后面加一个问号 来标记这个变量的值是可选的
var optionalString:String? = "Hello"
print(optionalString == nil)
//如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过，如果不是nil，会将值解包并赋值给let后面的常量，这样代码块就可以使用这个值了。
var optionalName:String? = "John Appleseed"
var greeting = "hello"
if let name = optionalName {
greeting = "Hello,\(name)"
}else{
//把optionalName改成nil,greeting会是什么?添加一个optionalName语句,当optionalName是nil时给 greeting 赋一个不同的值。
greeting = "Hello,\(optionalName == nil)"
}
print(greeting)
// print("hello,\(greeting)")
//另一种处理可选值的方法是通过使用??操作符号来提供一个默认值，如果可选值缺失的话，可以使用默认值来代替。
let nickName:String? = nil
let fullName:String = "Jhon Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
print(informalGreeting)
//switch支持任意类型的数据以及各种比较操作--不仅仅是整数以及测试相等
let vegetable = "red pepper"
switch vegetable {
case "cekery":
print("Add some raisins and make ants on a log")
case "cucumber","watercress":
print("That would make a good tea sandwich")
//注意let 将匹配等式的值赋值给常量x
case let x where x.hasSuffix("pepper"):
print("Is it a spicy \(x)?")
default:
print("Everything tastes good in soup.")
}
//用for-in 来遍历字典,需要两个变量来表示每个键值对.字典是一个无需的集合,所以他们的键和值以任意顺序迭代结束
let interstingNumbers = ["Prime":[2,3,5,7,11,13],
"Fibonacci":[1,1,2,3,5,8],
"Square":[1,4,9,16,25],]
var largest = 0
for (kind,numbers) in interstingNumbers {
print(numbers,kind)
for number in numbers {
if number > largest {
largest = number
}
}
}
print(largest)
//使用while 来重复运行一段代码知道不满足条件，循环条件也可以在结尾，保证能至少循环一次
var n = 2
while n < 100 {
n = n * 2
}
print(n)
var m = 2
repeat {
m=m * 2
} while m < 100
print(m)
//你可以在循环中使用..<来表示范围，如果想包含的话需要使用...
var total = 0
for i in 0..<4 {
total += i
}
print(total)
/*-------------函数和闭包----------------*/
//使用func 来声明一个函数，使用名字和参数来调用函数，使用->来指定函数返回值得的类型
func greets(persons:String,day:String) -> String {
return "Hello \(persons) , today is \(day)."
}
print(greets(persons: "Bob" , day: "Tuesday"))
//默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用_表示不使用参数标签
func greet (_ person:String, on day:String)->String{
return"hello \(person),today is \(day)"
}
print(greet("John", on: "wednesday"))
//使用元祖来让一个函数返回多个值，该元素的元素可以用名称或数字来表示
func calculateStatistics(scores:[NSInteger]) -> (min: NSInteger,max:NSInteger,sum:NSInteger) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
}else if score < min{
min = score
}
sum += score
}
return (min,max,sum)
}
let statistics = calculateStatistics(scores: [5,3,100,3,9])
print(statistics.sum)
print(statistics.1)
//函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式
func sumOf(numbers:NSInteger...) -> NSInteger{
var sum = 0
for number in numbers {
sum += number
}
return sum
}
print(sumOf(),sumOf(numbers: 42,597,12))
//函数可以嵌套，被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数
func returnFifteen() -> NSInteger {
var y = 10
func add() {
y += 5
}
add()
return y
}
print(returnFifteen())
//函数是第一等类型，这意味着函数可以作为另一个函数的返回值
func makeIncrementer() -> ((NSInteger) -> (NSInteger)){
func addOne(number: NSInteger) ->NSInteger {
return 1 + number
}
return addOne
}
let increment = makeIncrementer()
print(increment(7))
//函数也可以当做参数传入另一个函数
func hasAnyMatches(list:[NSInteger],condition:(NSInteger) -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number:NSInteger) -> Bool {
return number < 10
}
let numbers = [20,19,7,12]
print(hasAnyMatches(list: numbers, condition: lessThanTen))
//函数实际上是一种特殊的闭包：它是一段能之后被调取的代码，闭包中的代码能访问闭包所建作用域中能得到的变量函数，即使闭包是在一个不同的作用域被执行的，你已经在嵌套函数例子中多看到，你可以用{}来创建一个匿名闭包， 使用in将参数和返回值类型声明与闭包函数进行分离
let mappedNumbers1 = numbers.map({
(number:NSInteger) -> NSInteger in
let resault = 3 * number
return resault
})
print(mappedNumbers1)
//有很多种创建简单的闭包方法，如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值，单个语句闭包会把他语句的值当做结果返回
let mappedNumbers2 = numbers.map({number in 3*number})
print(mappedNumbers2)
//你可以通过参数位置而不是参数名字来引用参数---这个方法在非常的闭包中非常有用。当一个闭包作为最后一个参数传至给一个函数的时候，它可以直接跟在括号后面，当一个闭包是还给函数的唯一参数，你可以完全忽略括号
let sortedNumbers = numbers.sorted()
print(sortedNumbers)