b）如果你不希望为某个参数添加一个标签，可以使用一个下划线（`_`）来代替一个明确的参数标签。
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)
c）当然也可以类似`C++`使用缺省参数，即就是提供默认值
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6)
// parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4)
// parameterWithDefault = 12
d）当然你还可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（`...`）的方式来定义可变参数。可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `[Double]` 型的数组常量。
func arithmeticMean(_ numbers: Double…) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。
e）函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为\_输入输出参数\_
定义一个输入输出参数时，在参数定义前加 `inout` 关键字，且这个值需要时变量而不是常量
当传入的参数作为输入输出参数时，需要在参数名前加 `&` 符，表示这个值可以被函数修改。
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
**3）函数类型**
函数类型就像是函数指针一样。实则，还是那句话"万物皆对象"。
在 Swift 中，每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。使用函数类型就像使用其他类型一样。
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}
var mathFunction: (Int, Int) -> Int = addTwoInts
函数类型可以作为参数类型，返回值类型等。
##### 2.6 闭包
**1) 闭包简介**
OC有Block，C++有lambda表达式，swift则有闭包。
闭包采用如下三种形式之一：
* 全局函数是一个有名字但不会捕获任何值的闭包
* 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
* 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
闭包的语法
{ (parameters) -> return type in
statements
}
// 使用
var blockOne:(String, Int) = {(parma1:String, parma2:Int) -> void in
}
// 还有很多精巧的语法
let names = [“Chris”, “Alex”, “Ewa”, “Barry”, “Daniella”]
// 单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
// 直接通过 $0，$1，$2 来顺序调用闭包的参数，以此类推。
reversedNames = names.sorted(by: { $0 > $1 } )
// Swift 的 String 类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值
reversedNames = names.sorted(by: >)
另外要注意的是闭包表达式是引用类型。
**2) 逃逸闭包**
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。
// @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
**3)尾随闭包**
如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以将闭包书写在函数圆括号之后，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签
func someFunctionThatTakesAClosure(closure: () -> Void) {
// 函数体部分
}
func mySug() {
// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
// 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
// 闭包主体部分
}
}
##### 2.7 枚举、结构体、类
**1）枚举**
Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。
// 枚举的定义
enum SomeEnumeration {
// 枚举定义放在这里
// 使用 case 关键字来定义一个新的枚举成员值。
}
// 枚举的定义例子
enum CompassPoint {
case north
case south
case east
case west
}
// 可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
enum Barcode {
case upc(Int, Int, Int, Int)
case qrCode(String)
}
// 枚举的遍历
enum TestEnum:CaseIterable {
}
for item in TestEnum.allCases {
}
**2）结构体与类**
定义语法：
struct SomeStructure {
// 在这里定义结构体
}
class SomeClass {
// 在这里定义类
}
// 结构体是值类型
// 类是引用类型
// 结构体也可以当类来使用，但是不建议
// 还要很多相同点, 但是class就是定义类的, 不过多赘述struct
注意：
* 继承允许一个类继承另一个类的特征
* 类型转换允许在运行时检查和解释一个类实例的类型
* 析构器允许一个类实例释放任何其所被分配的资源
* 引用计数允许对一个类的多次引用
**3）类的属性与方法**
a）属性
swift中类的属性分为存储属性与计算属性。
存储属性就是存储在特定类或结构体实例里的一个常量或变量。
class FixedLengthRange {
var firstValue: Int
let length: Int
}
计算属性就是不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
struct Point {
var x = 0.0, y = 0.0
}
struct Size {
var width = 0.0, height = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY)
}
set(newCenter) {
origin.x = newCenter.x - (size.width / 2)
origin.y = newCenter.y - (size.height / 2)
}
}
}
swift还有一个类属性，类似C++的static成员。
使用关键字 `static` 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 `class` 来支持子类对父类的实现进行重写。
struct SomeStructure {
static var storedTypeProperty = “Some value.”
static var computedTypeProperty: Int {
return 1
}
}
enum SomeEnumeration {
static var storedTypeProperty = “Some value.”
static var computedTypeProperty: Int {
return 6
}
}
class SomeClass {
static var storedTypeProperty = “Some value.”
static var computedTypeProperty: Int {
return 27
}
class var overrideableComputedTypeProperty: Int {
return 107
}
}
b）方法
实例方法同普通方法一样，方法体可以使用`self`关键字
类方法在方法的 `func` 关键字之前加上关键字 `static`，来指定类型方法。类还可以用关键字 `class` 来指定，从而允许子类重写父类该方法的实现。
##### 2.8 类的构造与析构
**1）基础说明**
类的构造与析构和C++的构造与析构类似，唯一不同的可能就是在语法上不同了。
比如：全缺省构造，默认构造等等。
列出几个比较重要的构造函数语法：
// 默认构造
init() {
// 在构造函数中，如果没有明企鹅super.init()，那么系统会自动添加
// 使用KVC构造时，一定要先super.init()
}
// 参数构造
init(parmaterNmae : type) {
// 有歧义则加self
self.xxx = parmaterNmae;
}
init?(parmaterNmae : type){
// 可能返回空，获取时为可选类型
}
// 必要构造
required init(parmaterNmae : type) {
}
下面挨个举例：
class Color {
let red, green, blue: Double
init () {
// 默认构造
}
init(red: Double, green: Double, blue: Double) {
// 逐一成员构造器
self.red = red
self.green = green
self.blue = blue
}
init(white: Double) {
// 形参构造：同函数的参数标签一样
red = white
green = white
blue = white
}
}
**2）构造代理**
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能避免多个构造器间的代码重复。在《effective OC2.0》中也说到，在设置构造函数的时候，提供一个基础构造方法，共其他构造使用。
由于结构体以及枚举为值类型，无法继承，它们只能代理给自己的其它构造器。
struct Rect {
var origin = Point()
var size = Size()
init() {}
init(origin: Point, size: Size) {
self.origin = origin
self.size = size
}
init(center: Point, size: Size) {
let originX = center.x - (size.width / 2)
let originY = center.y - (size.height / 2)
self.init(origin: Point(x: originX, y: originY), size: size)
}
}
类则不同，它可以继承自其它类。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。
针对类的构造器，有两种，就是指定构造器和便利构造器。(swift针对构造器的设计是真的够啰嗦的)。
简单总结下：
如果一个类是基类，那么构造器就和前面一样写就可以，未初始化的属性一定要初始化。
重点是不是基类的情况：
子类的指定构造器一定要先初始化自己类中的属性，然后再调用父类的指定构造器。重写同理。
便利构造器就是你可以提供简化一下参数，然后调用类中的指定构造器。
类是不继承构造器的。如果触发以下情况，会自动继承：
>
> 1. 前提是你为子类中引入的所有新属性都提供了默认值
> 2. 如果子类没有定义任何指定构造器，它将自动继承父类所有的指定构造器。
> 3. 如果子类提供了所有父类指定构造器的实现——无论是通过规则 1 继承过来的，还是提供了自定义实现——它将自动继承父类所有的便利构造器。
>
>
>
**3）可失败构造**
给构造器传入无效的形参，或缺少某种所需的外部资源，又或是不满足某种必要的条件的时候可以构造失败。
class Document {
var name: String?
// 该构造器创建了一个 name 属性的值为 nil 的 document 实例
init() {}
// 该构造器创建了一个 name 属性的值为非空字符串的 document 实例
init?(name: String) {
if name.isEmpty { return nil }
self.name = name
}
}
**4）必要构造器**
在类的构造器前添加 required 修饰符表明所有该类的子类都必须实现该构造器
class SomeClass {
required init() {
// 构造器的实现代码
}
}
// 在子类重写父类的必要构造器时，必须在子类的构造器前也添加 required 修饰符
// 表明该构造器要求也应用于继承链后面的子类。
// 在重写父类中必要的指定构造器时，不需要添加 override 修饰符
class SomeSubclass: SomeClass {
required init() {
// 构造器的实现代码
}
}
**5）析构**
析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字 deinit 来标示，类似于构造器要用 init 来标示。
deinit {
// 执行析构过程
}
##### 2.9 属性监听器
class SomeClass : NSObject {
var name : String {
// 属性即将改变
willSet {
}
// 属性已经改变
didSet {
}
}
}
// 即使设置相同的值仍会触发
// 不能同setter同时存在
//
##### 2.10 类的继承
面向对象语言的三大特性之一继承，作为复用代码的一种手段，在swift中也是一样。swift和OC不一样，OC中所有的类都是都是基于NSObject的。但是Swift 中的类并不是从一个通用的基类继承而来的。如果你不为自己定义的类指定一个超类的话，这个类就会自动成为基类。
继承的基础语法：
class SomeClass: SomeSuperclass {
// 这里是子类的定义
}
举个例子：
// 父类
class Vehicle {
var currentSpeed = 0.0
var description: String {
return “traveling at (currentSpeed) miles per hour”
}
func makeNoise() {
// 什么也不做——因为车辆不一定会有噪音
}
}
// 子类
class Bicycle: Vehicle {
var hasBasket = false
}
重写
// 重写
// 重写某个特性，你需要在重写定义的前面加上 override 关键字。
class Train: Vehicle {
override func makeNoise() {
print(“Choo Choo”)
}
}
// 如果你在重写属性中提供了 setter，那么你也一定要提供 getter。
// 如果你不想在重写版本中的 getter 里修改继承来的属性值，
// 你可以直接通过 super.someProperty 来返回继承来的值，其中 someProperty 是你要重写的属性的名字。
final关键字
你可以通过把方法，属性或下标标记为 final 来防止它们被重写，只需要在声明关键字前加上 final 修饰符即可（例如：final var、final func、final class func 以及 final subscript）。
任何试图对带有 final 标记的方法、属性或下标进行重写的代码，都会在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final。
可以通过在关键字 class 前添加 final 修饰符（final class）来将整个类标记为 final 。这样的类是不可被继承的，试图继承这样的类会导致编译报错。
##### 2.11 扩展
扩展可以给一个现有的类，结构体，枚举，还有协议添加新的功能。它还拥有不需要访问被扩展类型源代码就能完成扩展的能力（即逆向建模）
* Swift 中的扩展可以：
* 添加计算型实例属性和计算型类属性
* 定义实例方法和类方法
* 提供新的构造器
* 定义下标
* 定义和使用新的嵌套类型
* 使已经存在的类型遵循（conform）一个协议
// 语法
extension SomeType {
// 在这里给 SomeType 添加新的功能
}
// 给一个类添加多个协议
extension SomeType: SomeProtocol, AnotherProtocol {
// 协议所需要的实现写在这里
}
##### 2.13 协议
关键字protocol定义协议。
protocol SomeProtocol {
// 这里是协议的定义部分
}
使某个类遵循协议
class SomeStructure: FirstProtocol, AnotherProtocol {
// 这里是结构体的定义部分
}
// 若是一个类拥有父类，应该将父类名放在遵循的协议名之前，以逗号分隔：
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 这里是类的定义部分
}
协议定义属性
protocol SomeProtocol {
// 可读可写
var mustBeSettable: Int { get set }
// 只读
var doesNotNeedToBeSettable: Int { get }
}
##### 2.10 泛型
**1）基础语法**
对于泛型可以类比C++的模板，C++的标准模板库STL就是泛型编程的经典。
swift的泛型语法也和模板类似——`<T>`。
// swift
// 函数
func swapTwoValues(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}
// 类
class SomeClass {
}
// C++
// 函数
template ;
void swapTwoValues(T& a, T& b) {
T tmp = a;
a = b;
b = tmp;
}
// 类
template ;
class SomeClass {
T _someClass;
};
#### 3. 总结
由于时间关系，总结的比较草率，还有很多需要补充的地方。对于swift语言，只是对语法进行了简单的学习。其核心思想还需进一步的深入学习——实践+概念。
## **题外话**
**初入计算机行业的人或者**大学计算机相关专业毕业生，很多因缺少实战经验，就业处处碰壁。下面我们来看两组数据：
### 如何自学黑客&网络安全
#### 黑客零基础入门学习路线&规划
**初级黑客**
**1、网络安全理论知识（2天）**
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）
**2、渗透测试基础（一周）**
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等
**3、操作系统基础（一周）**
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）
**4、计算机网络基础（一周）**
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现
**5、数据库基础操作（2天）**
①数据库基础
②SQL语言基础
③数据库安全加固
**6、Web渗透（1周）**
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）
恭喜你，如果学到这里，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web 渗透、安全服务、安全分析等岗位；如果等保模块学的好，还可以从事等保工程师。薪资区间6k-15k
到此为止，大概1个月的时间。你已经成为了一名“脚本小子”。那么你还想往下探索吗？
如果你想要入坑黑客&网络安全，笔者给大家准备了一份：282G全网最全的网络安全资料包评论区留言即可领取！
**7、脚本编程（初级/中级/高级）**
在网络安全领域。是否具备编程能力是“脚本小子”和真正黑客的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力.
如果你零基础入门，笔者建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习；搭建开发环境和选择IDE,PHP环境推荐Wamp和XAMPP， IDE强烈推荐Sublime；·Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，不要看完；·用Python编写漏洞的exp,然后写一个简单的网络爬虫；·PHP基本语法学习并书写一个简单的博客系统；熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)；·了解Bootstrap的布局或者CSS。
**8、超级黑客**
这部分内容对零基础的同学来说还比较遥远，就不展开细说了，附上学习路线。
#### 网络安全工程师企业级学习路线
如图片过大被平台压缩导致看不清的话，评论区点赞和评论区留言获取吧。我都会回复的
视频配套资料&国内外网安书籍、文档&工具
当然除了有配套的视频，同时也为大家整理了各种文档和书籍资料&工具，并且已经帮大家分好类了。
一些笔者自己买的、其他平台白嫖不到的视频教程。
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
1472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
