新普金娱乐网址


数学坚持进取,璀璨人生

王菲:我下意识冒犯你们凑合的人生

制造业工业工程师转互联网产品经理,Are you kidding?

  • 九月 06, 2018
  • 数学
  • 没有评论

Swift

自从投简历开始都同圆满了,投下的简历都已经石沉大海,虽然曾经预想到出现这种情形,依然约略沮丧。
于某个招聘APP中唯一一个重操旧业我之hr是如此对自己的题目之:

简介

  • Swift 语言由苹果商店于 2014 年推出,用来作 OS X 和 iOS 应用程序
  • 2014 年,在 Apple WWDC 发布

自我:冒昧的问讯一下,除了为没有更,您当我急需以哪些方面改进才能够得到面试时也?
hr:您没互联网行业经验

特点

  • 由它的语法中能观看Objective-C、JavaScript、C#、Python等语言的黑影
  • 语法简单、代码简洁、使用方便
    • 而是及Objective-C混合使用(相互调用)
    • 提供了看似 Java
      的讳空间(namespace)、泛型(generic)、运算对象重载(operator
      overloading)
    • 可选绑定、可选类型、类型推导
  • 干什么设计Swift语言
    • 受用开发还简便易行、更快、更安定
    • 保最终利用具有更好的品质

还说超行求职难,现在的协调也是深有体会,艰难暂且不表,这首文章主要说说

历史

  • 2010 年 7 月,苹果开发者工具部门总监 Chris Lattner,开始在手 Swift
    编程语言的宏图工作
  • 就此同样年岁月,完成中心架构
  • Swift 大约历经 4 年的开发期,2014 年 6 月上

Chris Lattner

  • IE和PM是怎么的
  • 干什么我只要打制造业的IE(工业工程师)转入互联网PM(产品经营)?
  • 自从以为生哪优劣势
  • 投机一度与着做的备选

克里斯·拉特纳何许人?

  • LLVM 项目之第一发起人与作者有
  • Clang 编译器的撰稿人
  • 苹果商店『开发者工具』部门的司
  • 领导Xcode、Instruments和编译器团队
  • Swift的大部基础架构均出于外1人口就
  • 评价:
    • 大神中之大神
    • 牛逼中的牛逼

IE和PM是怎的

美国工业工程协会概念:工业工程是针对性人口、物料、设备、能源、和消息相当所组成的集成系统,进行统筹、改善与实施之同帮派课程,它概括使用数学、物理、和社会是的专门知识和技巧,结合工程分析以及筹划之原理和方式,对拖欠系统所取的果实进行确认、预测及评价。

日本IE协会针对工业工程的定义:IE是这样平等栽运动,它以正确的道,有效地使用人、财、物、信息、时间相当经营资源,优质、廉价并马上地提供市场所急需的货物和劳动,同时射各种法子为从这些工作之人们带来饱和幸福。

本身之解:IE是坐人数吧仍,以提高效率,降低本钱为导向,对成品全都生命周期涉及到之人数、物、料、财等资源以对的方式进行合理配置,以极其少之投入达极端可怜、最漂亮的起。

百度百科中产品经营定义:产品经理(Product
Manager)是合作社吃特意负责产品管理之位置,产品经营负责调研并基于用户之需,确定支付何种产品,选择何种技术、商业模式等。并推动相应产品之开发团队,他还要根据产品之生命周期,协调研发、营销、运营等,确定及团组织实施相应的出品政策,以及另外一律层层有关的制品管理活动。

互联网产品经理:是互联网企业受到的同等种植效应,负责互联网产品的计划跟放开,以及互联网产品生命周期的演化。

产品经营的概念来许多,既然是设解答是干吗的,我道最好简易、易懂的就是是《人人都是产品经营》对成品经理的解释。

活经理是如出一辙近似人,他的做事思路及方法可缓解过剩实际上的生题材。只要你能够发现问题并讲述清楚,转化为一个需求,进而转化为一个职责,争取到支撑,发动打一批判人,将以此任务到位,并频频不断因东道主的情绪去跟、维护这个结局。

Playground是什么?

  • 打Xcode6开始产出(Swift开始出现)
  • 翻译为:操场/游乐场
  • 对上Swift基本语法非常便利
  • 所见就所得(快速查看结果)
  • 语法特性有变动时,可以很快查看.
  • Swift最基本的语法变化
    • 导入框架 import UIKit
    • 概念标识符时,必须声明该标识符是变量还是常量
      • 扬言标识符的格式:变量/常量关键字 名称 : 数据类型
    • 报句结束时不需要加以;
      • 假定与一行来多独话,则还是亟待加以
      • 可是非建议一行多长条语句
    • Swift中之打印语句:print(打印的情节)

为何自己一旦自制造业的IE(工业工程师)转入互联网PM(产品经理)

林天宏(韩寒旗下之上海发生培训文化传播有限公司(原上海亭东文化传媒有限公司)副总裁)离开《人物》杂志时就说,“你当一个尚无前途的行业,耗尽了和睦的热心、才华、所有的生机,然后你发现将这些精力投入到一个顺势而为的行业里去,能获取的东西远远超此的”。

  • 时势造英雄

援上面那段话不是说制造业没前途,是说以现有的状况下制造业对于自身吧不是一个极致美的挑三拣四,从毕业后,我就上制造业到今天也时有发生4年多了,先是汽车行业,然后是花电子行业,清楚的觉得到人工资本的升高带来的下压力,制造转型之切肤之痛,制造业的缕缕清淡。现在境内各个制造型企业还当用力提倡工业4.0,但事实上过多还还保持在工业2.0时代,而制造业作为重资产的行业想只要进去工业4.0尚发出平等长条很丰富之路途如果走。

下一场我们更来拘禁互联网行业,截至2016年12月,中国网民规模达7.31亿,互联网普及率为53.2%。其中手机网民规模及6.95亿,网民中运用手机上网人群占比较提升至95.1%。互联网行业由流量时代进入存量时代,“互联网+”概念流行,马云提出“新零售、新做、新金融、新技巧与新能源”,其中新打造就是经互联网去改造制造业,提升制造业的周转效率,推动产业提升为升级经济生产力和功力。

互联网打破了时空与空间的限制,工业4.0拿打破实体和编造网络的范围,未来他们之休戚与共也用隆重。

  • 马斯洛需求

美国心理学家亚伯拉罕·马斯洛在1943年于《人类激励理论》论文中将人类需要像阶梯一样打没有到强照层次分为五种,分别是:生理需求、安全需要、社交需求、尊重需要与自我实现需求。

随着工作时限和年龄的增高,我起来思索自己前途底差事倾向。现在的局IE(Industrial
Engineering
)的劳作重中之重是负担专业工时、产能的制订,layout规划,流程优化等,我的掌管是一个涉嫌了即20年的人口,主管的牵头是台湾总人口(台资公司大家了解的),所以升职当主持基本无可能,在制造厂的薪资基本属于吃的满足,富不起的音频。在这家企业干了正满两年,工厂当一个封的环境,很多同事都换得麻木,失去进取心,尤其年龄大一些的同事还落在混的心绪,生活就是像一滩死水,很无耻到啊发展前景。
冲上面的场面,很自然之想到了更换工作,但是发现要还是当制造业只是易到别的店,相同的职务,改变似乎未会见特别酷。IE在自身清楚来拘禁而想的确的举行的好,必须学会以产品所有生命周期去分析、改造,而非一味是在生育环节去举行优化,但是于制造业为主是颇为难落实之,也没对应的位置。可能某些类型好做到,但是这种大型项目一般是合作社至少可总级别作为牵头羊才发或实现,否则都见面不了了底。
如此我不怕想开了关注之互联网行业,仔细分析后,互联网行业产品经理需要参与到活的所有生命流程中,设计、规划、分析,迭代,核心力量再偏于为软实力,这样好有效应用做IE时养的力,降低迁移成本,也克重好的践行从源头以及整个产品流程中去把控、改变、创新,提升自己的私价值以及社会价值。

哎是常量和变量

  • 以Swift中规定:在概念一个标识符时必须旗帜鲜明说明该标识符是一个常量还是变量
  • 动用let来定义常量,定义之后不可以修改
  • 以var来定义变量,定义之后方可改

从认为生哪些优劣势

旗帜鲜明,对于axure、Visio、Mindmanager等软件的利用从都未是权一个产品经营好坏的正经,其中心力量又偏于为软实力,下面简单说说自己以为好装有的优劣势。

产品经营因待以全部产品生命周期都设插手进来,这就需要直面运营、研发、UI、测试等各种不同职能部门同事,更新各方面的文化,以便与她们再度好的联络,推进、协调各国机构的劳作,保证项目如期、高质上丝。所以学习能力、适应力、项目管理、执行力和沟通能力即便成为影响产品经营基本素质重要之触发。IE的屡见不鲜工作吧是类似于活经理一样,没有实际的行政权力,需作为主导去推动、协调PE、QC、MP等诸单位保证改善型之得手实施。

出品经营,作为产品最初的创造者,资本发现否是必备,根据店家的范围、技术实力、人力等自源头去考虑一个成品如何筹划。这样做的好处呢是妇孺皆知的,举个简单的事例,假而于一个产品还非想闹清晰的商业模式时,降低资金就代表可以争取到再也多的时间错开成。IE在头里的定义着说过,是坐减低资金为导向的饭碗,所以这也总算一个优势。

出品经理,规划产品,必然关系到流程设计,IE工作被举足轻重的同样有些就是是流程优化,这有的IE与产品经理则因为行业不同,要关注之流程是匪平等的,但是基本的核心理念还是相通的。

结构化思维和数目解析否是活经理重要力量的相同环。IE平常分析问题时常,也急需以MECE法则、5W1H、鱼骨图、帕累托定律(二八条件)当工具去分析问题,分析数据,找到问题之源头从而化解问题,在及时过程遭到也殊好的培养了自之结构化思维与中心的数目解析能力。

出品经营与IE使用的洋洋家伙及公理都来共同性,比如PDCA、SMART法则、SWOT分析等等。

点简单说了几碰优势,劣势也是判,没有互联网行业经验。

常量和变量的动注意:

  • 注意:
    • 凡凭借于的目标不可以重复开展修改.但是好透过指针获得对象后,修改对象中的习性
    • 当实际使用过程中,建议先定义常量,如果急需改再修改为变量(更加安全)

协调都与在开的备选

互联网热点以及时事新闻每天还有关流动,学习过程首先看了相同不折不扣蚊子老师的《产品经理深入浅出》的视频,画了3布置合计导图;阅读了产品经营入门经典图书以《人人都是产品经营》、《结网》、《启示录
打造用户喜爱的出品》、《用户体验要素》、《Don’t Make Me
Think》、《简约至上-交互设计四国策》等挥毫,通过这些,构建由了主导的出品理论框架,大致了解了安做出一个产品的流水线,应该关爱哪些方面,后续还索要经验的共计来调整、修加,以充分自己之思维体系。

于众人都是成品经理上登了2首文章《伪考拉理财诞生记:小型理财产品,如何稳定好切入市场?》和《从考拉理财来拘禁中小互联网理财公司未来什么发展》。

技术方面达成大学时可用java写简单的小程序,现在着力忘完了,也会重捡起来。

常用的Axure、visio、Mindmanager等软件基本采用没有问题,最近吗正在做一个大概的出品demo等等。

Swift中之种推导

  • Swift是强类型的言语
  • Swift中其他一个标识符都起显著的档次
  • 注意:
    • 假设定义一个标识符时有一直进行赋值,那么标识符后面的类型可以望略.
    • 因Swift有路推导,会自行根据后面的赋值来支配前的标识符的数据类型
    • 得经过option+鼠标左键来查阅变量的数据类型

结尾

本身明白自己还有多不足,很多之非懂得,但自当大力成为一个成品经理,我以缩小同一个秋的出品经理的别,进行并拿努力下去!

终极我思念以《进击的高个子》OP《自由之翼》
的乐章,鼓舞自己,也刺激所有活动以温馨挑的征途上之人,虽然困难,希望在前沿!

双手紧握刚刃 心中高奏凯歌
身后飘飘扬扬自由之翼
以坚定的信心置于胸前
斩断一切愚昧螺旋
甘当自由之翼翱翔于苍穹

Swift中挑大梁运算

  • Swift中于开展基本运算时务必确保项目一致,否则会拧
    • 一如既往档次中才得以展开演算
    • 坐Swift中尚无隐式转换
  • 数据类型的转向
    • Int类型转成Double类型:Double(标识符)
    • Double类型转成Int类型:Int(标识符)

let a = 10
let b = 3.14

// 错误写法
//let c = a + b

// 正确写法
let c = Double(a) + b
let d = a + Int(b)

支行的介绍

  • 分层就if/switch/三目运算符等看清语句
  • 由此分支语句可以控制次的实践流程

if分支语句

  • 以及OC中if语句有得之界别
    • 看清句可以不加以()
    • 于Swift的论断句被须出鲜明的真假
      • 不再出非0即确实
      • 非得产生肯定的Bool值
      • Bool有个别个取值:false/true

// 演练一:
let a = 10

// 错误写法:
//if a {
// print("a")
//}

// 正确写法
if a > 9 {
  print(a)
}

// 演练二:
let score = 87

if score < 60 {
  print("不及格")
} else if score <= 70 {
  print("及格")
} else if score <= 80 {
  print("良好")
} else if score <= 90 {
  print("优秀")
} else {
  print("完美")
}

老三望运算符

  • Swift中之 三目运算保持了跟 OC一致的作风

var a = 10
var b = 50
var result = a > b ? a : b
println(result)

guard的使用

  • guard是Swift2.0初长的语法
  • 其与if语句非常相近,它计划的目的是增长程序的可读性
  • guard语词必须带有else语句,它的语法如下:
    • 当极表达式为true时候跳了else语词被之始末,执行语句组内容
    • 基准表达式为false时候执行else语句被的始末,跳反语句一般是return、break、continue和throw

guard 条件表达式 else {  
  // 条换语句
  break
}
语句组
  • 例子

var age = 18

func online(age : Int) -> Void {

  guard age >= 18 else {
    print("回家去")
    return
  }
  print("可以上网")
}

online(age)

switch的简要利用

  • 骨干用法及OC用法平
  • 不同之处:
    • switch后可不跟()
    • case后可以免跟break(默认会发break)
    • 一个case判断中,可以判定多独价
    • 差不多个价值为,隔开

let sex = 0

switch sex {
  case 0, 1: 
    print("正常人")
  default: 
    print("其他")}
  • 粗略以上:
    • 假若指望出现前的case穿外露,则可以以主要字fallthrough

let sex = 0

switch sex {
  case 0: 
    fallthrough
  case 1:
    print("正常人")
  default: 
    print("其他")
}

switch支持多数据类

  • 浮点型的switch判断

let f = 3.14

switch f {
  case 3.14: 
    print("π")
  default: 
    print("not π")
}
  • 支撑字符串类型

let m = 5
let n = 10
var result = 0
let opration = "+"

switch opration {
  case "+": 
    result = m + n
  case "-":
    result = m - n
  case "*":
    result = m * n
  case "/":
    result = m / n
  default:
    result = 0
}

print(result)

switch支持区间判断

  • 嘿是距离?
    • 平常咱们靠的是数字区间:010,100200
    • swift中之间隔时表现有半点种
      • 开区间:0..<10 表示:0~9,不包括10
      • 闭区间:0…10 表示:0~10

let score = 88

switch score {
  case 0..<60:
    print("不及格")
  case 60..<80:
    print("几个")
  case 80..<90:
    print("良好")
  case 90..<100:
    print("优秀")
  default:
    print("满分")
}

for循环的写法

  • 无限健康写法

// 传统写法
for var i = 0; i < 10; i++ {
  print(i)
}
  • 区间for循环

//开区间
for i in 0..<10 {
  print(i)
}

//闭区间
for i in 0...10 {
  print(i)
}
  • 破例写法
    • 设当for循环中未欲运用下标i

for _ in 0..<10 {
  print("hello")
}
  • while和do while循环
    • while循环
      • while的判断句必须有正确的真伪,没有非0即确实
      • while后面的()可以略

var a = 0
while a < 10 {
  a++
}
  • do while循环
    • 使repeat关键字来替了do

let b = 0
repeat {
  print(b) 
  b++
} while b < 20

字符串的牵线

  • OC和Swift中字符串的分别
    • 每当OC中字符串类型时NSString,在Swift中字符串类型是String
    • OC中字符串@””,Swift中字符串””
  • 使用 String的原因
    • String是一个结构体,性能更胜
    • NSString是一个 OC对象,性能略差
    • String支持直接遍历
    • Swift提供了 String和NSString之间的无缝转换

字符串的使用

  • 遍历字符串

// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {
  print(c)
}
  • 字符串拼接
    • 点滴单字符串的拼凑

let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2
  • 字符串和另外数据类型的拼凑

let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"
  • 字符串的格式化
    • 论时间:03:04

let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])

字符串的截取

  • Swift中提供了异常的截取方式
    • 该法充分辛苦
    • Index非常麻烦创建
    • 简短的主意是将String转成为NSString来使用
      • 当标识符后加:as NSString即可

let myStr = "zhenniukeji"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

屡组的牵线

  • 数组(Array)是一样串有序的由同样类别元素结合的成团
  • 数组中的集合元素是不变的,可以重新出现
  • Swift中的数组
    • swift字典类型是Array,是一个泛型集合

频繁组的初始化

  • 数组分成:可变数组和不可变数组
    • 利用let修饰的数组是不足变数组
    • 运用var修饰的数组是不过变数组

// 定义一个可变数组,必须初始化才能使用
var array1 : [String] = [String]()

// 定义一个不可变数组
let array2 : [NSObject] = ["why", 18]
  • 于宣称一个Array类型的时可使下列的语句之一

var stuArray1:Array<String>
var stuArray2: [String]
  • 声明的数组需要进行初始化才会用,数组类型往往是当宣称的以拓展初始化的

// 定义时直接初始化
var array = ["why", "lnj", "lmj"]

// 先定义,后初始化
var array : Array<String>
array = ["why", "lnj", "lmj"]

对屡次组的基本操作

// 添加数据array.append("yz")
// 删除元素array.removeFirst()
// 修改元素array[0] = "why"
// 取值array[1]

累组的遍历

// 遍历数组
for i in 0..<array.count {
  print(array[i])
}

// for in方式
for item in array {
  print(item)
}

// 设置遍历的区间
for item in array[0..<2] {
  print(item)
}

频组的合

// 数组合并
// 注意:只有相同类型的数组才能合并
// 不建议一个数组中存放多种类型的数据
var array = ["why", "lmj","lnj"]var array1 = ["yz", "wsz"]
var array2 = array + array1

字典的牵线

  • 字典允许以有只键来访问元素
  • 字典是出于少数局部集合构成的,一个凡键(key)集合,一个是价值(value)集合
  • 键集合是不可知发生更元素的,而值集合是可还的,键和价值是成对出现的
  • Swift中的字典
    • Swift字典类型是Dictionary,也是一个泛型集合

字典的初始化

  • Swift中的可变和不可变字典
    • 使let修饰的数组是不足变字典
    • 下var修饰的数组是不过转换字典

// 定义一个可变字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定义一个不可变字典
let dict2 = ["name" : "why", "age" : 18]
  • 以声明一个Dictionary类型的当儿可以下下的说话之一

var dict1: Dictionary<Int, String>
var dict2: [Int: String]
  • 宣称的字典需要开展初始化才能够采取,字典类型往往是以声明的同时进行初始化的

// 定时字典的同时,进行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]

字典的基本操作

// 添加数据dict["height"] = 1.88dict["weight"] = 70.0
// 删除字段dict.removeValueForKey("height")
// 修改字典dict["name"] = "NN"
// 查询字典dict["name"]

字典的遍历

// 遍历字典中所有的值

for value in dict.values {
  print(value)
}

// 遍历字典中所有的键
for key in dict.keys {
  print(key)
}

// 遍历所有的键值对
for (key, value) in dict {
  print(key)
  print(value)
}

字典的汇合

// 字典的合并
var dict1 = ["name" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]

// 字典不可以相加合并
for (key, value) in dict1 {
  dict2[key] = value
}

元组的牵线

  • 元组是Swift中有意的
  • 她是啊为?
    • 它们是同样种植多少结构,在数学中采取广泛。
    • 好像于数组或者字典
    • 得用于定义一组数据

元祖的概念

  • 元祖的泛写法时有发生半点栽

("1001", "张三", 30, 90)
(id:"1001", name:"张三", english_score:30, chinese_score:90)

元祖的大概利用

  • 用元组来讲述一个HTTP的错误信息

// 元祖:HTTP错误
// let array = [404, "Not Found"]

// 写法一:
let error = (404, "Not Found")print(error.0)print(error.1)

// 写法二:
let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

// 写法三:
let (errorCode, errorIno) = (404, "Not Found")
print(errorCode)
print(errorIno) 

唯独选类型的牵线

  • 概念:
    • 于OC开发被,如果一个变量暂停不采用,可以赋值为0(基本特性类型)或者赋值为空(对象类型)
    • 当swift开发被,nil也是一个不同寻常之类型.因为与真实的类不兼容是勿能够赋值的(swift是强语言)
    • 只是付出被赋值nil,在所难免.因此推出了但选类型
  • 然而选类型的取值:
    • 空值
    • 有值

概念可选类型

  • 概念一个可选类型有三三两两栽写法
    • 无限中心的写法
    • 语法糖(常用)

// 错误写法
// let string : String = nil

// 正确写法:
// 写法一:定义可选类型
let string : Optional<String> = nil

// 写法二:定义可选类型,语法糖(常用)
let string : String? = nil

而是选类型的用

// 演练一:

// 定义可选类型
var string : Optional<String> = nil

// 给可选类型赋值
string = "Hello world"

// 打印结果
print(string)

// 结果:
Optional("Hello world")\n
// 因为打印出来的是可选类型,所有会带Optional

// 演练二:
// 取出可选类型的真实值(解包)
print(string!)
// 结果:Hello world\n
//注意:如果可选类型为nil,强制取出其中的值(解包),会出错string = nilprint(string!) 

// 正确写法:
if string != nil {
  print(string!)
}

// 简单写法:为了让在if语句中可以方便使用string

if var str = string {
  print(str)
}

实在应用场景

  • 目的:让代码更加严谨(可选绑定)

// 通过该方法创建的URL,可能有值,也可能没有值
// 错误写法:如果返回值是nil时,就不能接收了
let url : NSURL = NSURL(string: "www.baidu.com")

// 正确写法:使用可选类型来接收
let url : NSURL? = NSURL(string: "www.baidu.com")

// 通过url来创建request对象
if let tempUrl = url {
  let request = NSURLRequest(URL: tempUrl)
}

函数的介绍

  • 函数相当给OC中的不二法门
  • 函数的格式如下

func 函数名(参数列表) -> 返回值类型 {
  代码块
  return 返回值
}
  • func是最主要字,多单参数列表中可以据此逗号(,)分隔,也堪没有参数
  • 运箭头“->”指向返回值类型
  • 使函数没有回值,返回值为Void.并且“-> 返回值类型”部分好简简单单

广的函数类型

// 1.没有参数,没用返回值
func about() -> Void {
  print("iphone6s plus")
}
// 调用函数
about()

// 简单写法
// 如果没用返回值,Void可以写成()
func about1() -> () {
  print("iphone6s plus")
}

// 如果没有返回值,后面的内容可以都不写
func about2() {
  print("iphone6s plus")
}

about2()

// 2.有参数,没用返回值
func callPhone(phoneNum : String) {
  print("打电话给\(phoneNum)")
}

callPhone("+86 110")

// 3.没用参数,有返回值
func readMessage() -> String {
  return "吃饭了吗?"
}

var str = readMessage()
print(str)

// 4.有参数,有返回值
func sum(num1 : Int, num2 : Int) -> Int {
  return num1 + num2
}

var result = sum(20, num2: 30)
print(result)

函数的应用注意

  • 只顾一: 外部参数与内部参数
    • 于函数内部可以看来底参数,就是中参数
    • 每当函数外面好看的参数,就是标参数
    • 默认情况下,从第二独参数开始,参数名称既是其中参数为是表面参数
    • 要第一独参数为想只要来表面参数,可以安装标签:在变量名前加标签即可
    • 使未思如果外表参数,可以于参数名称前加_

// num1和a是外部参数的名称
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
  return num1 * num2 * num3
}

var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
  return num1 * num2
}

var result2 = ride(20, 20)
  • 小心二: 默认参数
    • 一点情况,如果无传到具体的参数,可以下默认参数

func makecoffee(type :String = "卡布奇诺") -> String {
  return "制作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("拿铁")
let coffee2 = makecoffee()
  • 只顾三: 可转移参数
    • swift中函数的参数个数可以转,它可以接受不确定数量的输入型参数
    • 她要具有相同的种
    • 我们可以通过在参数类型名后加入(…)的法来指示这是只是更换参数

func sum(numbers:Double...) -> Double {
  var total: Double = 0

  for number in numbers {
    total += number
  } 
  return total
}

sum(100.0, 20, 30)
sum(30, 80)
  • 留神四: 引用类型(指针的传递)
    • 默认情况下,函数的参数是值传递.如果想转外界的变量,则需要传递变量的地点
    • 务必是变量,因为急需以里面改变其值
    • Swift提供的inout要害字就算足以兑现
    • 相比之下下列两独函数

// 函数一:值传递
func swap(var a : Int, var b : Int) {
  let temp = a; 
  a = b; 
  b = temp
  print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)print("a:\(a), b:\(b)")

// 函数二:指针的传递
func swap1(inout a : Int, inout b : Int) {
  let temp = a
  a = b
  b = temp
  print("a:\(a), b:\(b)")
}
swap1(&a, b: &b)
print("a:\(a), b:\(b)")
  • 函数的嵌套使用(了解即可)
    • swift中函数可以嵌套使用
    • 尽管函数中带有函数,但是非引进该写法

// 函数的嵌套
let value = 55
func test() {
  func demo() {
    print("demo \(value)")
  }
  print("test")
  demo()
}
demo() // 错误
test()

看似的牵线

  • Swift也是平等家面向对象开发之言语
  • 面向对象的功底是相仿,类闹了靶
  • 在Swift中如何定义类呢?
    • class是Swift中之机要字,用于定义类

class 类名 : SuperClass {
  // 定义属性和方法
}
  • 注意:
    • 概念的近乎,可以无父类.那么该类是rootClass
    • 习以为常状态下,定义类时.继承自NSObject(非OC的NSObject)

什么样定义类的性

  • Swift中类的性质有强
    • 积存属性:存储实例的常量和变量
    • 测算属性:通过某种方式计算出来的性
    • 类属性:与合类自身有关的习性
  • 仓储属性
    • 存储属性是无与伦比简便易行的性,它看做类实例的一致部分,用于存储常量和变量
    • 可以让存储属性提供一个默认值,也可于初始化方法中针对其开展初始化
    • 下面是储存属性的写法
      • age和name都是储存属性,用来记录该学员的年华和姓名
      • chineseScore和mathScore也是储存属性,用来记录该生的语文分数和数学分数

class Student : NSObject {
  // 定义属性
  // 存储属性
  var age : Int = 0
  var name : String? 
  var chineseScore : Double = 0.0
  var mathScore : Double = 0.0
}

// 创建学生对象
let stu = Student()

// 给存储属性赋值
stu.age = 10
stu.name = "why"
stu.chineseScore = 89.0
stu.mathScore = 98.0

计算属性

  • 计量属性并无存储实际的价值,而是提供一个getter和一个可选的setter来间接获与其它设置属性
  • 积存属性一般才供getter方法
  • 万一就供getter,而不提供setter,则该算属性也单读属性,并且可省略get{}
  • 脚是测算属性之写法
    • averageScore是计量属性,通过chineseScore和mathScore计算而来的性质
    • 每当setter方法中出一个newValue变量,是网指定分配的

class Student : NSObject {
  // 定义属性
  // 存储属性
  var age : Int = 0
  var name : String?
  var chineseScore : Double = 0.0
  var mathScore : Double = 0.0

  // 计算属性
  var averageScore : Double {
  get {
    return (chineseScore + mathScore) / 2
    } 

  // 没有意义.newValue是系统分配的变量名,内部存储着新值
  set {
    self.averageScore = newValue
    }
  }
}

// 获取计算属性的值
print(stu.averageScore)

类属性

  • 类属性是与类似相关联的,而休是暨类似的实例相关联
  • 富有的类似及实例都并来平等卖类属性.因此在某个同介乎改动之后,该类属性就会让改
  • 类属性的安和改动,需要经过类似来完成
  • 下是类属性的写法
    • 类属性使用static来修饰
    • 章:courseCount是类属性,用来记录学生出微微家课程

class Student : NSObject {
  // 定义属性
  // 存储属性
  var age : Int = 0
  var name : String?
  var chineseScore : Double = 0.0
  var mathScore : Double = 0.0

  // 计算属性
  var averageScore : Double {
    get {
      return (chineseScore + mathScore) / 2
    } 

    // 没有意义.newValue是系统分配的变量名,内部存储着新值
    set {
      self.averageScore = newValue
    }
  } 

  // 类属性
  static var corseCount : Int = 0
}

// 设置类属性的值
Student.corseCount = 3

// 取出类属性的值
print(Student.corseCount)

监听属性的改动

  • 以OC中我们可再次写set方法来监听属性之转
  • Swift中得以经过属性观察者来监听和应属性值的转
  • 普普通通是监听积存属性与类属性的改变.(对于计算属性,我们不欲定义属性观察者,因为咱们好在计算属性之setter中一直观测并应这种价值的变更)
  • 咱们通过设置以下观察措施来定义观察者
    • willSet:在属于性值被积存之前设置。此时初属性值作为一个常量参数为盛传。该参数名默认为newValue,我们得好定义该参数名
    • didSet:在新属性值被储存后当即调用。与willSet相同,此时传回的是特性的旧值,默认参数名为oldValue
    • willSet和didSet只发生以性质先是不行给安装时不时才会调用,在初始化时,不会见错过调用这些监听方法
    • 监听的艺术如下:
      • 监听age和name的变化

class Person : NSObject {
 var name : String? {
    // 可以给newValue自定义名称
    willSet (new){
      // 属性即将改变,还未改变时会调用的方法
      // 在该方法中有一个默认的系统属性newValue,用于存储新值
      print(name)
      print(new)
     }

     // 可以给oldValue自定义名称
     didSet (old) {
      // 属性值已经改变了,会调用的方法
      // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
      print(name)
      print(old)
     } 
  } 

  var age : Int = 0
  var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "why"

构造函数的介绍

  • 构造函数类似于OC中之初始化方法:init方法
  • 默认情况下充斥创建一个看似时,必然会调用一个构造函数
  • 纵使是从未编制任何构造函数,编译器也会见供一个默认的构造函数。
  • 若果是继往开来自NSObject,可以针对父类的构造函数进行重写

构造函数的为主以

  • 接近的性质必须出价
  • 倘若无是当概念时初始化值,可以以构造函数中赋值

class Person: NSObject {
  var name : Stringvar
  age : Int

  // 重写了NSObject(父类)的构造方法
  override init() {
    name = "" 
   age = 0
  }
}

// 创建一个Person对象
let p = Person()

初始化时于属性赋值

  • 多多早晚,我们以开立一个目标时即会被属性赋值
  • 得打定义构造函数
  • 留意:如果起定义了构造函数,会覆盖init()方法,即非以闹默认的构造函数

class Person: NSObject {
  var name : String
  var age : Int

  // 自定义构造函数,会覆盖init()函数
  init(name : String, age : Int) {
    self.name = name
    self.age = age
  }
}

// 创建一个Person对象
let p = Person(name: "why", age: 18)

字典转模型(初始化时传出字典)

  • 忠实创建对象时,更多之凡拿字典转成为模型
  • 注意:
    • 错过字典中取有的是NSObject,任意档次
    • 足由此as!转成需要之类,再赋值(不得以一直赋值)

class Person: NSObject {
  var name : Stringvar
  age : Int

  // 自定义构造函数,会覆盖init()函数
  init(dict : [String : NSObject]) {
    name = dict["name"] as! String
    age = dict["age"] as! Int
  }
}

// 创建一个Person对象
let dict = ["name" : "why", "age" : 18]
let p = Person(dict: dict)

字典转模型(利用KVC转化)

  • 采取KVC字典转模型会愈加有利
  • 注意:
    • KVC并无可知确保会给所有的习性赋值
    • 用属性需要有默认值
    • 骨干数据列默认值设置为0
    • 目标或结构体类型定义为而选类型即可(可选类型没有赋值前为nil)

class Person: NSObject {
  // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
  var name : String? 

  // 基本数据类型不能是可选类型,否则KVC无法转化
  var age : Int = 0

  // 自定义构造函数,会覆盖init()函数
  init(dict : [String : NSObject]) {
    // 必须先初始化对象
    super.init()

    // 调用对象的KVC方法字典转模型
    setValuesForKeysWithDictionary(dict)
  }
}

// 创建一个Person对象
let dict = ["name" : "why", "age" : 18]
let p = Person(dict: dict)

闭包的牵线

  • 闭包和OC中之block非常相像
  • OC中的block是匿名的函数
  • Swift中的闭包是一个不同寻常之函数
  • block和闭包都时常用来回调

闭包的施用

block的用法回顾

  • 概念网络要的切近

@interface HttpTool : NSObject
- (void)loadRequest:(void (^)())callBackBlock;

@end

@implementation HttpTool
- (void)loadRequest:(void (^)())callBackBlock{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
      NSLog(@"加载网络数据:%@", [NSThread currentThread]); 

    dispatch_async(dispatch_get_main_queue(), ^{
      callBackBlock(); 
    });
  });
}
@end
  • 进展网络要,请求到数码后以block进行回调

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
  [self.httpTool loadRequest:^{
    NSLog(@"主线程中,将数据回调.%@", [NSThread currentThread]);
  }];
}
  • block写法总结:

block的写法: 类型: 返回值(^block的名称)(block的参数) 

值: ^(参数列表) { 
  // 执行的代码
};

动闭包代替block

  • 概念网络要的切近

class HttpTool: NSObject {
  func loadRequest(callBack : ()->()){
      dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
        print("加载数据", [NSThread.currentThread()])

      dispatch_async(dispatch_get_main_queue(), { () -> Void in
        callBack()
      })
    }
  }
}
  • 开展网络要,请求到数量后用闭包进行回调

override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
  // 网络请求
  httpTool.loadRequest ({ () -> () in
    print("回到主线程", NSThread.currentThread());
  })
}
  • 闭包写法总结:

闭包的写法: 类型:(形参列表)->(返回值)

技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值

值: { (形参) -> 返回值类型 in 
  // 执行代码 
}

闭包的简写

  • 若是闭包没有参数,没有回值.in和in之前的情可概括

  httpTool.loadRequest({
    print("回到主线程", NSThread.currentThread());
  })
  • 随行闭包写法:
    • 若闭包是函数的末梢一个参数,则好拿闭包写于()后面
    • 而函数只生一个参数,并且这参数是闭包,那么()可以免写

httpTool.loadRequest() {
  print("回到主线程", NSThread.currentThread());
}

// 开发中建议该写法
httpTool.loadRequest {
  print("回到主线程", NSThread.currentThread());
}

闭包的循环引用

  • 若果以HttpTool中发出指向闭包进行大引用,则会形成巡回引用

class HttpTool: NSObject {

// 定义属性,来强引用传入的闭包
var callBack : (()->())? 
func loadRequest(callBack : ()->()){
      dispatch_async(dispatch_get_global_queue(0, 0)) {() -> Void in
        print("加载数据", [NSThread.currentThread()])
      dispatch_async(dispatch_get_main_queue(), { () -> Void in
        callBack()
      })
    }

    self.callBack = callBack
  }
}
  • swift中解决循环引用的法子

// weak var weakSelf = self;
// [weak self] () -> () in
// [unowned self] () -> () in

httpTool.loadRequest { [unowned self] () -> () in
  self.view.backgroundColor = UIColor.redColor()
  print("回到主线程", NSThread.currentThread());
}

懒加载的牵线

  • swift中吗产生懒加载的点子
    • (苹果之计划性思想:希望有的对象在以时才真的加载到内存中)
    • 跟OC不同的凡swift有特别的机要字来贯彻懒加载
    • lazy关键字可以用来定义有一个性懒加载

懒加载的以

  • 格式

lazy var 变量: 类型 = {
  创建变量代码
}()
  • 懒加载的使

// 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性
// lazy的作用是只会赋值一次lazy

var array : [String] = { () -> [String] in
  return ["why", "lmj", "lnj"]
}()

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图