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())

Swift 学习- 01 -- 基础部分的更多相关文章

  1. shell-bash学习01基础、打印、环境变量

    基础 终端提示符: username@hostname$; $: 一般用户 #:root用户 运行脚本 Bash执行: * bash script.sh; 直接运行: 脚本开头添加shebang起始: ...

  2. Swift 学习- 02 -- 基础部分2

    class NamedShape{ var numberOfSides: Int = 0 var name: String init(name: String) { self.name = name ...

  3. 01.基础架构:一条SQL查询语句是如何执行的?学习记录

    01.基础架构:一条SQL查询语句是如何执行的?学习记录http://naotu.baidu.com/file/1c8fb5a0f2497c3a2655fed89099cb96?token=ff25d ...

  4. 零基础使用Swift学习数据科学

    概述 Swift正迅速成为数据科学中最强大.最有效的语言之一 Swift与Python非常相似,所以你会发现2种语言的转换非常平滑 我们将介绍Swift的基础知识,并学习如何使用该语言构建你的第一个数 ...

  5. 学习webpack基础笔记01

    学习webpack基础笔记 1.webpack搭建环境最重要的就是如何使用loader和plugins,使用yarn/npm安装插件.预处理器,正确的配置好去使用 2.从0配置webpack - 1. ...

  6. Python学习--01入门

    Python学习--01入门 Python是一种解释型.面向对象.动态数据类型的高级程序设计语言.和PHP一样,它是后端开发语言. 如果有C语言.PHP语言.JAVA语言等其中一种语言的基础,学习Py ...

  7. iOS ---Swift学习与复习

    swift中文网 http://www.swiftv.cn http://swifter.tips/ http://objccn.io/ http://www.swiftmi.com/code4swi ...

  8. Android Testing学习01 介绍 测试测什么 测试的类型

    Android Testing学习01 介绍 测试测什么 测试的类型 Android 测试 测什么 1.Activity的生命周期事件 应该测试Activity的生命周期事件处理. 如果你的Activ ...

  9. 12套swift学习资源分享

    虽然objective-c编程语言在过去很长一段时间都是iOS应用开发的基础语言,且很多iOS开发者对其也深爱有佳,但是随着swift编程语言的问世,迅速发展为开发者追捧的语言.且今年伴随着swift ...

随机推荐

  1. 【转】const int *p和int * const p的区别(常量指针与指向常量的指针)

    [转]作者:xwdreamer   出处:http://www.cnblogs.com/xwdreamer 对于指针和常量,有以下三种形式都是正确的: const char * myPtr = &am ...

  2. luogu P2387 [NOI2014]魔法森林

    传送门 这题似乎不好直接做,可以考虑按照\(a_i\)升序排序,然后依次加边更新答案 具体实现方法是用lct维护当前的树,这里需要维护链上最大的\(b_i\).每次加一条边,如果加完以后没有环直接加, ...

  3. ThinkPHP5基础学习(慕课版)

    一.thinkphp 5.0 的安装及配置 二.URL和路由 三.请求和相应 四.视图和模板 五.数据库的操作 六.模型的操作

  4. 【JS】正则向前查找和向后查找

    正向查找:就是匹配前面或后面是什么内容的,所以分类是:正向前查找,正向后查找 负向查找:就是匹配前面或后面不是什么内容的,所以分类是:负向前查找,负向后查找   操作符 说明 描述 (?=exp) 正 ...

  5. 深刻了解jQuery对象和普通DOM对象的区别

    深刻了解jQuery对象和普通DOM对象的区别.互相转化见Q1 Q1,js的写法:document.getElementById('save').disabled=true; 在jquery中我是这样 ...

  6. Windows jdk安装以及版本切换

    Windows jdk版本切换 一.安装 1.下载 官网: Java SE Development Kit 8 Downloads Java SE 7 Archive Downloads 1.7之前的 ...

  7. LOJ #2183「SDOI2015」序列统计

    有好多好玩的知识点 LOJ 题意:在集合中选$ n$个元素(可重复选)使得乘积模$ m$为$ x$,求方案数对$ 1004535809$取模 $ n<=10^9,m<=8000且是质数,集 ...

  8. backgroud-size属性

    backgroud-size:100% 改为:backgroud-size:100% 100%; 就能解决下面的问题.

  9. 【MongoDB】 Failed to connect to 127.0.0.1:27017, reason: Connection refused

    由于项目需要,在一台虚拟机上安装了MongoDB,但是在启动的时候,出现如下错误: [root@localhost bin]# ./mongo MongoDB shell version v3.4.0 ...

  10. 【Linux-Redhat】新手需要知道的Linux命令

    好像接触运维有一年的时间了吧,查的资料什么的,也算是挺多的了.再加上最近看的<Linux就该这么学>,也算是把自己最近学的东西系统化了一下.今天就来说说,常用的Linux命令有什么,如果你 ...