标签：gre ack list fan oda 完全 函数返回 orange rem
print("世界,你好")
var myVariable = 42
myVariable = 50
let myConstant = 42
let implicitinteger = 70
let fffffff = 70.0
let exnfjenb: Double = 80
let changliang: Float = 4
var frewf: Double = 5
print(changliang)
let label = "你哦好的"
let width = 94
let widthlabel = label + String(width)
let label2 = "1234565"
let heught: Int = 88
let all = String(heught) + label2
let apples = 3
let oranges = 5
let appleCount = "I have \(apples) apples"
let fruitCount = "i have \(oranges) oranges"
print(fruitCount)
let fudina: Double = 402.0840000
let helloStr = "nihao de \(fudina) nihao"
print(helloStr)
var shoplist = ["apple","oranges","banage","blueanj"]
shoplist[1] = "bbbbbb"
shoplist .removeAll()
if shoplist.count > 2 {
print(shoplist[1])
}else{
print("数组为空")
}
var dictionary = ["aaa":"AAA","bbb":"BBB"]
var emptyArray = [String]()
let individualScores = [12,23,34,45,56]
var teamScores = 0
for score in individualScores {
if score > 20 {
teamScores += 3
}else{
teamScores += 1
}
}
print(teamScores)
// 在 if 语句中 条件必须是一个bool值,这意味着 判断不会隐形的与 0 做对比
// 你可以一起使用 if 与 let 来处理值确实的情况,这些值将由可选值来代表
// 一个可选值是一个具体的值或者是 nil 以表示值缺失,在类型后面加一个问号来标记这个变量的值是可选的
var optionalName: String? = "John Appleseed"
optionalName = nil
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}else{
greeting = "Hello!,(杜露茜)"
}
print(greeting)
// 如果变量的可选值是nil,条件会判断为false , 大括号中的代码会被跳过,如果不是nil ,会将值解包并赋给 let 后面的常量,这样代码中就可以使用这个值了
// 还有一种处理可选值的方法就是通过使用 ?? 操作符来提供一个默认值,如果可选值缺失的话,可以使用默认值来代替
let nickName: String? = "dingzhiije"
let fullName: String = "DingZhijie"
let myName = "my name is \(nickName ?? fullName)"
print(myName)
// switch 支持任意类型的数据以及各种比较操作--不仅仅是整数以及测试相等
let vegetrabel = "red pepper"
switch vegetrabel {
case "red pepper":
print("red")
case "black":
print("black")
default:
print("no")
}
// swift 中 运行 switch 的时候 运行完匹配完的子句之后,程序会退出 switch 语句,并不会向下运行,所以不需要再每个子句之后写 break;
let interestingNumbers = [
"Prime":[2,3,5,7,11,13],
"Fibonacci":[1,1,2,3,5,8],
"Square":[1,4,9,16,25]
]
// 遍历字典
var largest = 0
var largestKey: String = ""
for (kind,numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number;
largestKey = kind
}
}
}
print(largest)
print(largestKey)
var num = 0
var addNum = 0
while num < 101 {
addNum = addNum + num
num += 1
}
print(addNum)
// 循环条件也可以在结尾循环一次,至少会循环一次
// repeat 循环语句
var m = 2
repeat { // 重复
m = m * 2
} while m < 100
print(m)
// 可以再循环中使用 ..< 来表示范围
var total = 0
for i in 0 ..< 4 {
total += 1
print(i)
}
// a ..< b 的范围是 大于等于 a , 但是小于 b
// a ... b 的范围是 大于等于 a , 而且小于等于 b
// 这是因为 ..< 创建的范围不包含上界, 但是 ... 创建的范围包含上界
// 使用 func 来声明一个函数,使用名字和参数来调用函数, 使用 -> 来指定函数的返回值的类型
func green(person: String, day: String) -> String {
return "hello \(person), today is \(day)"
}
print(green(person: "houdecheng", day: "2017-5-5"))
func eat(person: String, eatWhat: String) -> String {
return "hello, \(person), my today wat\(eatWhat)"
}
print(eat(person: "houdehcneg", eatWhat: "danchaofan"))
// 默认情况下,函数使用它们的参数名称作为它们参数的标签, 在参数名称前面可以自定义参数标签, 或者使用 _ 表示不使用参数标签
func ceshi( _ person: String,on day: String) -> String{
return "hello, \(person), today is \(day)"
}
print(ceshi("houdehceg", on: "2017-5-5"))
// 使用元组让函数返回多个值,元组的元素可以用名称或者数字来表示
func yuanzuceshi(scores: [Int]) -> (min: Int,max: Int, sum: String){
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;
}
let sumStr: String = String(sum)
return (min,max,sumStr)
}
print(yuanzuceshi(scores: [15,54,45,54,78,15,6,98]))
// 函数可以带有可变个数的参数,这些参数在函数内表现为数组的形式
func kebiancanshu(numbers: Int...) -> Double {
var sum = 0
for i in numbers {
sum += i
}
let pingjunzhi: Double = Double(sum)/Double(numbers.count)
return pingjunzhi
}
print(kebiancanshu(numbers: 4,3,5,6))
// 函数可以嵌套 , 被嵌套的函数可以访问外侧函数的的变量 你可以使用嵌套函数来重构一个太长或者太复杂的函数
func returnFifteen() -> Int{
var y = 10
func add(){
y += 5
}
add()
return y
}
print(returnFifteen())
// 函数是第一等类型 这意味着函数可以作为另一个函数的返回值
func addOne(number: Int,str: String) -> Int{
return Int(str)! + number
}
func makeIncrmenter() -> ((Int,String) -> Int) {
return addOne(number:str:)
}
var increment = makeIncrmenter()
print(increment(88,"44"))
// 函数也可以当做参数传入另一个函数
func hasAnyMatches(list: [Int] , condition: (Int) -> Bool) -> Bool{
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
let numbers = [20,19,7,12]
let dictionary2: Dictionary = ["1":45,"2":43]
print(hasAnyMatches(list: numbers, condition: lessThanTen(number:)))
// 函数实际上是一种特殊的闭包, 他是一段之后能调用的代码.闭包中的代码能访问闭包所创建作用域中能得到的变量和函数,即使闭包是在一个不同的作用域被执行的 - 可以使用 {} 来创建一个匿名闭包, 使用 in 将参数和返回值类型与闭包函数体进行分离
print(numbers.map { (number: Int) -> Int in
let result = 3 * number
return result
})
// 有很多种创建更简洁的闭包的方法,如果一个闭包的类型已知,比如作为一个回调函数,你可以忽略参数的类型和返回值,单个语句闭包会把它语句的值当做返回值返回
//let mappedNumbers = numbers.map({ number in 3 * number })
//print(mappedNumbers)
let mappendNumbers = numbers.map { (number: Int) -> Int in
let result = 3 * number
return result
}
print(mappendNumbers)
// 可以通过参数的位置而不是参数的名称来引用参数 -- 这个方法在非常短的闭包中非常有用,当一个闭包作为最后一个参数传给函数的时候,他可以直接在括号后面,当一个闭包是传给函数的唯一参数,你可以完全忽略括号
let sortedNumbers = numbers.sorted { (a, b) -> Bool in
a > b
}
print(sortedNumbers)
// 字典的排序
let dicSorted = dictionary2.sorted { (a, b) -> Bool in
a.value > b.value
}
print(dicSorted)
// 对象和类
// 使用 class 和类名创建一个类. 类中属性的声明和变量,变量声明一样,唯一的区别就是他们的上下文是类,同样,方法核函数声明也一样
class Shape {
var numberOfSides = 0
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
// 要创建一个类的实例,在类名后面加上括号,使用点语法来访问实例的属性和方法
var shape = Shape()
shape.numberOfSides = 7
print(shape.simpleDescription())
class MyDay{
let day = "2017年 5月 5号"
func prienDay(day: String) -> String {
return "今天是 \(day)"
}
}
var mydays = MyDay.init()
print(mydays.prienDay(day: mydays.day))
// 这个版本的 Shape 缺少了一些重要的东西,一个构造函数来初始化实例,使用 init 来创建一个构造器
class NamedShape{
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDecription() -> String {
return "A shape with \(numberOfSides) \(name) sides"
}
}
var nameShpe = NamedShape.init(name: "houdehcneg")
print(nameShpe.simpleDecription())
// 注意 self 被用来区别实例变量,当你创建的时候,像传入函数参数一样给类擦混入构造器的参数,每个属性都需要赋值 -- 无论是通过声明 (例如 numberOfSides) 还是通过构造器 (例如 name)
// 如果你需要在删除对象之前进行一些清理工作, 使用 deinit 创建一个拆构函数
// 子类的定义方法是在他们的类名后面加上父类的名字,用冒号分割,创建类的时候并不需要一个标准的跟类,所以你可以忽略父类
// 子类如果需要重写父类的方法,需要用 override 标记 -- 如果没有添加 override 就去重写父类的方法编辑器会报错,编辑器同样会检测 override 标记的方法是否确实在父类中
class Square: NamedShape{
var sideLength: Double
init(sideLength: Double,name: String) {
self.sideLength = sideLength;
super.init(name: name)
numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDecription() -> String {
return "A squre with side of length \(sideLength) \(numberOfSides)"
}
}
let test = Square.init(sideLength: 5.2, name: "my test squre")
print(test.area())
print(test.simpleDecription())
class Circle: NamedShape{
var banjing:Double
init(banjing: Double,name: String) {
self.banjing = banjing
super.init(name: name)
}
func area() -> Double {
return self.banjing
}
override func simpleDecription() -> String {
return "\(banjing),\(numberOfSides),\(name)"
}
}
var circle = Circle.init(banjing: 2.0, name: "dinngzhijie")
print(circle.area())
print(circle.simpleDecription())
标签：gre ack list fan oda 完全 函数返回 orange rem
原文地址：http://www.cnblogs.com/dingzhijie/p/6888722.html
