Fork me on GitHub

SwiftLint代码规范属性说明01

下面来具体介绍一下SwiftLint的具体的代码规则的相关说明

规则1: closing_brace

在使用Swift 3.2或更高版本时,首选系统的KVO 的API和keypath

识别码 默认是否启用 是否支持自动更正 类型
block_based_kvo 启用 no idiomatic

官方示例:

1
2
3
4
5
6
7
8
9
10
11
//编译通过
let observer = foo.observe(\.value, options: [.new]) { (foo, change) in
print(change.newValue)
}

//会触发警告
class Foo: NSObject {
override func observeValue(forKeyPath keyPath: String?, of object: Any?,
change: [NSKeyValueChangeKey : Any]?,
context: UnsafeMutableRawPointer?) {}
}

规则2: class_delegate_protocol

委托协议应该只是class类,可以被弱引用(官方解释,先放出官方示例吧)

识别码 默认是否启用 是否支持自动更正 类型
class_delegate_protocol 启用 no lint

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//不会触发warning
protocol FooDelegate: class {}
protocol FooDelegate: class, BarDelegate {}
protocol Foo {}
class FooDelegate {}
@objc protocol FooDelegate {}
@objc(MyFooDelegate)
protocol FooDelegate {}
protocol FooDelegate: BarDelegate {}
protocol FooDelegate: AnyObject {}
protocol FooDelegate: NSObjectProtocol {}

//会触发warning
protocol FooDelegate {}
protocol FooDelegate: Bar {}

规则3: closing_brace

类似小括号包含大括号的不能用空格

识别码 默认是否启用 是否支持自动更正 类型
closing_brace 启用 yes style

具体示例:

1
2
3
4
5
6
7
8
9
10
11
//不会触发warning
[1, 2].map({ $0 })

[1, 2].map(
{ $0 }
)

//会触发warning
[1, 2].map({ $0 } )
[1, 2].map({ $0 } )
[1, 2].map( { $0 })

规则4: closure_end_indentation

闭包的封闭端和开始端有相同的缩进, 意思就是 大括号(一般是方法)上下对齐的问题,这样使code看起来更加整洁

识别码 默认是否启用 是否支持自动更正 类型
closure_end_indentation 未启用 no style

具体示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//不会触发closure_end_indentation
[1, 2].map { $0 + 1 }
//不会触发closure_end_indentation
SignalProducer(values: [1, 2, 3])
.startWithNext { number in
print(number)
}
//不会触发closure_end_indentation
function {
..........
}

//会触发closure_end_indentation
SignalProducer(values: [1, 2, 3])
.startWithNext { number in
print(number)
}
//不会触发closure_end_indentation
function {
..........
}

规则5: closure_parameter_position

闭包参数位置, 闭包参数应该和大括号左边在同一行, 推荐使用

识别码 默认是否启用 是否支持自动更正 类型
closure_parameter_position 启用 no style

具体示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/// number 和 { 在同一行, 不会触发warning
let names = [1, 2, 3]
names.forEach { (number) in
print(number)
}

let names = [1, 2, 3]
names.map { number in
number + 1
}



/// 这样不行,违背 closure_parameter_position规则, 触发warning
let names = [1, 2, 3]
names.forEach {
(number) in
print(number)
}

let names = [1, 2, 3]
names.map {
number in
number + 1
}

规则6: closure_spacing

在闭包的{}中间要有一个空格,如map({ $0 })

识别码 默认是否启用 是否支持自动更正 类型
closure_spacing 未启用 yes style

以下示例:

1
2
3
4
5
6
7
8
9
不会触发警告
map({ $0 })
[].map ({ $0.description })

//会触发警告
map({$0 })
map({ $0})
map({$0})
[].map ({$0.description })

规则7: colon

冒号的使用, swiftlint的这个colon属性规则很简单,要求“ :”紧靠所定义的常量或变量等,必须没有空格,与所指定的类型之间必须只有一个空格,多一个或少一个都不行,如果是用在Dictionary中,则要求紧靠Key,与Value之间必须有且仅有一个空格。这个规则我觉得应该强制推荐使用

识别码 默认是否启用 是否支持自动更正 类型
colon 启用 yes style

具体示例:

1
2
3
4
5
6
7
8
9
10
//不会触发警告
let abc: String = "jun"
let abc = [1: [3: 2], 3: 4]
let abc = [1: [3: 2], 3: 4]

//会触发警告
let jun:Void
let jun : Void
let jun :Void
let jun: Void

规则8: comma

逗号使用只要遵循“前不离身后退一步”就行了,这个也强制推荐使用

识别码 默认是否启用 是否支持自动更正 类型
comma 启用 yes style

具体示例:

1
2
3
4
5
//不触发警告
[a, b, c, d]

//触发警告
[a ,b]

规则9: compiler_protocol_init

编译器协议初始化, 不建议.init等初始化方式, 建议使用简单的初始化形式

识别码 默认是否启用 是否支持自动更正 类型
compiler_protocol_init 启用 no lint

官方示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static let description = RuleDescription(
identifier: "compiler_protocol_init",
name: "Compiler Protocol Init",
description: "The initializers declared in compiler protocols such as `ExpressibleByArrayLiteral` " +
"shouldn't be called directly.",
kind: .lint,
nonTriggeringExamples: [
"let set: Set<Int> = [1, 2]\n",
"let set = Set(array)\n"
],
triggeringExamples: [
"let set = ↓Set(arrayLiteral: 1, 2)\n",
"let set = ↓Set.init(arrayLiteral: 1, 2)\n"
]
)

规则10: conditional_returns_on_newline

条件语句不能写在同一行, 条件返回语句应该在新的一行。 当有条件返回的时候应该换行返回,而不是在同一行

识别码 默认是否启用 是否支持自动更正 类型
conditional_returns_on_newline 未启用 no style

具体示例:

1
2
3
4
5
6
7
8
9
10
11
12
/// swiftlint 不推荐的写法, 否则会触发warning
if true { return }
guard true else { return }

/// swiftlint 推荐的写法
if true {
return
}

guard true else {
return
}

规则11: contains_over_first_not_nil

类似first函数不能判断是否为nil

识别码 默认是否启用 是否支持自动更正 类型
contains_over_first_not_nil 未启用 no performance

具体示例:

1
2
3
4
5
6
7
//推荐写法
let first = myList.first(where: { $0 % 2 == 0 })
let first = myList.first { $0 % 2 == 0 }

//不推荐写法
myList.first { $0 % 2 == 0 } != nil
myList.first(where: { $0 % 2 == 0 }) != nil

规则12: control_statement

控制语句, for,while,do,catch语句中的条件不能包含在()中

识别码 默认是否启用 是否支持自动更正 类型
control_statement 启用 no style

具体示例:

1
2
3
4
5
6
7
8
//建议写法
if condition {
if (a, b) == (0, 1) {

//不建议写法
if (condition) {
if(condition) {
if ((a || b) && (c || d)) {

规则13: custom_rules

自定义规则。 这个属性可以通过提供正则表达式来创建自定义规则, 可选指定语法类型搭配, 安全、级别和要陈列的什么信息。 这个属性只要熟悉使用正则表达式的人使用,目前可以不适用

识别码 默认是否启用 是否支持自动更正 类型
custom_rules 启用 no style

规则14: cyclomatic_complexity

循环复杂度。函数体的复杂度应该要限制,这个属性主要约束条件句、循环句中的循环嵌套问题, 当嵌套太多的循环时,则会触发swiftlint中的warning和error,当达到10个循环嵌套时就会报warning,达到20个循环嵌套时就会报error

识别码 默认是否启用 是否支持自动更正 类型
cyclomatic_complexity 启用 no metrics

规则15: discarded_notification_center_observer

当使用注册的通知时, 应该存储返回的观察者, 便于用完之后移除通知

识别码 默认是否启用 是否支持自动更正 类型
discarded_notification_center_observer 启用 no lint

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//推荐写法
let foo = nc.addObserver(forName: .NSSystemTimeZoneDidChange, object: nil, queue: nil) { }

let foo = nc.addObserver(forName: .NSSystemTimeZoneDidChange, object: nil, queue: nil, using: { })

func foo() -> Any {
return nc.addObserver(forName: .NSSystemTimeZoneDidChange, object: nil, queue: nil, using: { })
}


//不推荐写法
nc.addObserver(forName: .NSSystemTimeZoneDidChange, object: nil, queue: nil) { }

nc.addObserver(forName: .NSSystemTimeZoneDidChange, object: nil, queue: nil, using: { })

@discardableResult func foo() -> Any {
return nc.addObserver(forName: .NSSystemTimeZoneDidChange, object: nil, queue: nil, using: { })
}

规则16: discouraged_direct_init

阻止直接初始化导致的错误类型, 有类方法的,用类方法初始化(不建议直接init初始化)

识别码 默认是否启用 是否支持自动更正 类型
discouraged_direct_init 启用 no lint

代码示例:

1
2
3
4
5
6
7
8
9
10
//建议写法
let foo = UIDevice.current
let foo = Bundle.main
let foo = Bundle(path: "bar")
let foo = Bundle(identifier: "bar")

//不建议写法
let foo = UIDevice()
let foo = Bundle()
let foo = bar(bundle: Bundle(), device: UIDevice())

规则17: discouraged_optional_boolean

不建议使用可选布尔值

识别码 默认是否启用 是否支持自动更正 类型
discouraged_optional_boolean 未启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
11
//建议写法
var foo: Bool
var foo: [String: Bool]
var foo: [Bool]
let foo: Bool = true

//不建议写法
var foo: Bool?
var foo: [String: Bool?]
var foo: [Bool?]
let foo: Bool? = nil

规则18: discouraged_object_literal

优先使用对象初始化方法, 不建议使用代码块初始化

识别码 默认是否启用 是否支持自动更正 类型
discouraged_object_literal 未启用 no idiomatic

代码示例:

1
2
3
//不建议写法
let white = #colorLiteral(red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0)
let image = ↓#imageLiteral(resourceName: "image.jpg")

规则19: dynamic_inline

避免一起使用 dynamic 和 @inline(_ _always), 否则报 error

识别码 默认是否启用 是否支持自动更正 类型
dynamic_inline 启用 no lint

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/// 正确的做法
class LangKe {
dynamic func myFunction() {

}
}

class LangKe {
@inline(__always) func myFunction() {

}
}

class LangKe {
@inline(never) dynamic func myFunction() {

}
}

/// 只要同时使用 dynamic 和 @inline(_ _always)都报错 error!!!
class LangKe {
@inline(__always) public dynamic func myFunction() {

}
}

规则20: array_init

序列转化成数组时, 优先使用数组转化, 而不是seq.map {$ 0}将序列转换为数组

识别码 默认是否启用 是否支持自动更正 类型
array_init 未启用 no lint

官方示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public static let description = RuleDescription(
identifier: "array_init",
name: "Array Init",
description: "Prefer using Array(seq) than seq.map { $0 } to convert a sequence into an Array.",
kind: .lint,

//以下示例不会触发警告
nonTriggeringExamples: [
"Array(foo)\n",
"foo.map { $0.0 }\n",
"foo.map { $1 }\n",
"foo.map { $0() }\n",
"foo.map { ((), $0) }\n",
"foo.map { $0! }\n",
"foo.map { $0! /* force unwrap */ }\n",
"foo.something { RouteMapper.map($0) }\n"
],

//以下示例会触发警告
triggeringExamples: [
"↓foo.map({ $0 })\n",
"↓foo.map { $0 }\n",
"↓foo.map { return $0 }\n",
"↓foo.map { elem in\n" +
" elem\n" +
"}\n",
"↓foo.map { elem in\n" +
" return elem\n" +
"}\n",
"↓foo.map { (elem: String) in\n" +
" elem\n" +
"}\n",
"↓foo.map { elem -> String in\n" +
" elem\n" +
"}\n",
"↓foo.map { $0 /* a comment */ }\n"
]
)

规则21: empty_count

建议使用isEmpty判断,而不是使用count==0判断

识别码 默认是否启用 是否支持自动更正 类型
empty_count 未启用 no performance

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/// swiftlint不建议这样使用
let number = "long"
if number.characters.count == 0 {
print("为空")
} else {
print("不为空")
}

/// swiftlint建议这种正式风格
if number.isEmpty {
print("为空")
} else {
print("不为空")
}

规则22: empty_enum_arguments

当枚举与关联类型匹配时,如果不使用它们,参数可以省略

识别码 默认是否启用 是否支持自动更正 类型
empty_enum_arguments 启用 yes style

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//SwiftLint建议写法
switch foo {
case .bar: break
}
switch foo {
case .bar(let x): break
}
switch foo {
case let .bar(x): break
}
switch (foo, bar) {
case (_, _): break
}
switch foo {
case "bar".uppercased(): break
}

//SwiftLint不建议写法
switch foo {
case .bar(_): break
}
switch foo {
case .bar(): break
}
switch foo {
case .bar(_), .bar2(_): break
}

规则23: empty_parameters

闭包参数为空时,建议使用() ->Void, 而不是Void ->Void

识别码 默认是否启用 是否支持自动更正 类型
empty_parameters 启用 yes style

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
/// 01 不会触发warning
let abc: () -> Void

func foo(completion: () -> Void) {

}

/// 02 直接报错
let bcd: Void -> Void

func foo(completion: Void -> Void) {

}

规则24: empty_parentheses_with_trailing_closure

在使用尾随闭包的时候, 应该尽量避免使用空的圆括号

识别码 默认是否启用 是否支持自动更正 类型
empty_parentheses_with_trailing_closure 启用 yes style
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//不会触发warning
[1, 2].map { $0 + 1 }
[1, 2].map({ $0 + 1 })
[1, 2].reduce(0) { $0 + $1 }
[1, 2].map { number in
number + 1
}

//会触发warning
[1, 2].map() { $0 + 1 }
[1, 2].map( ) { $0 + 1 }
[1, 2].map() { number in
number + 1
}
[1, 2].map( ) { number in
number + 1
}

规则26: explicit_acl

…所有属性和方法的声明, 都应该明确指定修饰关键字

识别码 默认是否启用 是否支持自动更正 类型
explicit_acl 未启用 no idiomatic

官方代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//非触发示例
internal enum A {}
public final class B {}
private struct C {}
internal func a() { let a = }
private struct C { let d = 5 }
internal class A { deinit {} }
internal protocol A {
func b()
var c: Int
}


//触发示例
enum A {}
final class B {}
internal struct C { let d = 5 }
public struct C { let d = 5 }
func a() {}
internal let a = 0
func b() {}

规则27: explicit_type_interface

声明的属性应该明确其类型, 如: var myVar: Int = 0

识别码 默认是否启用 是否支持自动更正 类型
explicit_type_interface 未启用 no idomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
11
//推荐写法
class Foo {
var myVar: Int? = 0
let myLet: Int? = 0
}

//不建议写法
class Foo {
var myVar = 0
let myLet = 0
}

规则28: extension_access_modifier

在自定义类中,推荐使用extension扩展

识别码 默认是否启用 是否支持自动更正 类型
extension_access_modifier 未启用 no idiomatic

规则29: no_extension_access_modifier

在extension扩展前面,不建议使用(fileprivate, public)等修饰符

识别码 默认是否启用 是否支持自动更正 类型
no_extension_access_modifier 未启用 no idiomatic

代码示例:

1
2
3
4
5
6
//不建议以下写法
private extension String {}
public extension String {}
open extension String {}
internal extension String {}
fileprivate extension String {}

规则30: fallthrough

switch语句中不建议使用fallthrough

识别码 默认是否启用 是否支持自动更正 类型
fallthrough 启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
//推荐写法
switch foo {
case .bar, .bar2, .bar3:
something()
}

//不建议写法
switch foo {
case .bar:
fallthrough
case .bar2:
something()
}

规则31: fatal_error_message

执行fatalError错误时,建议有一个提示信息; 如:fatalError(“Foo”)

识别码 默认是否启用 是否支持自动更正 类型
fatal_error_message 未启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
//推荐写法
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}

//不建议
required init?(coder aDecoder: NSCoder) {
fatalError("")
}

规则32: file_header

文件头。新建的文件开始的注释应该一样

识别码 默认是否启用 是否支持自动更正 类型
aaa 未启用 no style

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/// 不会触发warning
/// 如果我新建一个工程,在ViewController.swift文件中, 开始的注释应该是:

// ViewController.swift
// SwiftLint
//
// Created by langke on 17/1/17.
// Copyright © 2017年 langke. All rights reserved.
//

改变一下变为:
//
// MyViewController.swift...................由于这里和外面的文件名不一样,所以触发warning(实际上在swift 3.0上测试这个属性暂时没有任何作用!!)
// SwiftLint
//
// Created by langke on 17/1/17.
// Copyright © 2017年 langke. All rights reserved................官方terminal表示,Copyright和Created没有对齐,也会触发warning!!!
//

规则33: file_length

文件内容行数, 超过400行warning, 超过1000行给error

识别码 默认是否启用 是否支持自动更正 类型
file_length 启用 no metrics

规则34: first_where

不建议在使用filter和map函数后直接使用.first

识别码 默认是否启用 是否支持自动更正 类型
first_where 未启用 no performance

官方代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static let description = RuleDescription(
identifier: "first_where",
name: "First Where",
description: "Prefer using `.first(where:)` over `.filter { }.first` in collections.",
kind: .performance,

//不会触发警告
nonTriggeringExamples: [
"kinds.filter(excludingKinds.contains).isEmpty && kinds.first == .identifier\n",
"myList.first(where: { $0 % 2 == 0 })\n",
"match(pattern: pattern).filter { $0.first == .identifier }\n",
"(myList.filter { $0 == 1 }.suffix(2)).first\n"
],
//以下写法会触发警告
triggeringExamples: [
"↓myList.filter { $0 % 2 == 0 }.first\n",
"↓myList.filter({ $0 % 2 == 0 }).first\n",
"↓myList.map { $0 + 1 }.filter({ $0 % 2 == 0 }).first\n",
"↓myList.map { $0 + 1 }.filter({ $0 % 2 == 0 }).first?.something()\n",
"↓myList.filter(someFunction).first\n",
"↓myList.filter({ $0 % 2 == 0 })\n.first\n",
"(↓myList.filter { $0 == 1 }).first\n"
]
)

规则35: for_where

在for循环中,不建议使用单个if语句或者只使用一次循环变量,可使用where或者if{}else{}语句

识别码 默认是否启用 是否支持自动更正 类型
for_where 启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//推荐写法
for user in users where user.id == 1 { }
for user in users {
if let id = user.id { }
}
for user in users {
if var id = user.id { }
}
for user in users {
if user.id == 1 { } else { }
}
for user in users {
if user.id == 1 { }
print(user)
}
for user in users {
let id = user.id
if id == 1 { }
}
for user in users {
if user.id == 1 && user.age > 18 { }
}

//不建议写法
for user in users {
if user.id == 1 { return true }
}

规则36: force_cast

不建议直接强解类型

识别码 默认是否启用 是否支持自动更正 类型
force_cast 启用 no idiomatic

代码示例:

1
2
3
4
5
//建议写法
NSNumber() as? Int

//不推荐
NSNumber() ↓as! Int

规则37: force_try

对会抛出异常(throws)的方法,不建议try!强解

识别码 默认是否启用 是否支持自动更正 类型
force_try 启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
11
func myFunction() throws { }

/// 这样写是可以的,不会触发 error
do {
try myFunction()
} catch {

}

/// 这样直接触发 error
try! myFunction()

规则38: force_unwrapping

强制解包/拆包。我们知道,当一个类型是可选类型的时候,当我们获取值时,需要强制解包(也叫隐式解包), 通常我们是在一个变量或者所需要的常量、类型等后面加一个“ !”, 然而,swiftlint建议强制解包应该要避免, 否则将给予warning

识别码 默认是否启用 是否支持自动更正 类型
force_unwrapping 未启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
/// 将触发warning
navigationController!.pushViewController(myViewController, animated: true)

let url = NSURL(string: "http://www.baidu.com")!
print(url)

return cell!

/// 不会触发warning
navigationController?.pushViewController(myViewController, animated: true)

规则39: function_body_length

函数体长度, 函数体不应该跨越太多行, 超过40行给warning, 超过100行直接报错

识别码 默认是否启用 是否支持自动更正 类型
function_body_length 启用 no metrics

规则40: function_parameter_count

  • 函数参数个数, 函数参数数量(init方法除外)应该少点, 不要太多,swiftlint规定函数参数数量超过5个给warning, 超过8个直接报error
  • 注:function_parameter_count: error 这样并不能改变它的警告或错误,该属性不允许修改,但是可以禁用
识别码 默认是否启用 是否支持自动更正 类型
function_parameter_count 启用 no metrics

规则41: generic_type_name

泛型类型名称只能包含字母数字字符,以大写字母开头,长度介于1到20个字符之间

识别码 默认是否启用 是否支持自动更正 类型
generic_type_name 未启用 no idiomatic

代码示例:

1
2
3
4
5
6
7
8
9
10
11
//推荐写法
func foo<T>() {}
func foo<T>() -> T {}
func foo<T, U>(param: U) -> T {}
func foo<T: Hashable, U: Rule>(param: U) -> T {}

//不推荐写法
func foo<T_Foo>() {}
func foo<T, U_Foo>(param: U_Foo) -> T {}
func foo<TTTTTTTTTTTTTTTTTTTTT>() {}
func foo<type>() {}

规则42: identifier_name

变量标识符名称应该只包含字母数字字符,并以小写字母开头或只应包含大写字母。在上述例外情况下,当变量名称被声明为静态且不可变时,变量名称可能以大写字母开头。变量名称不应该太长或太短

识别码 默认是否启用 是否支持自动更正 类型
identifier_name 启用 no style

官方给出的示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
internal struct IdentifierNameRuleExamples {
//不会触发error
static let nonTriggeringExamples = [
"let myLet = 0",
"var myVar = 0",
"private let _myLet = 0",
"class Abc { static let MyLet = 0 }",
"let URL: NSURL? = nil",
"let XMLString: String? = nil",
"override var i = 0",
"enum Foo { case myEnum }",
"func isOperator(name: String) -> Bool",
"func typeForKind(_ kind: SwiftDeclarationKind) -> String",
"func == (lhs: SyntaxToken, rhs: SyntaxToken) -> Bool",
"override func IsOperator(name: String) -> Bool"
]

//会触发error
static let triggeringExamples = [
"↓let MyLet = 0",
"↓let _myLet = 0",
"private ↓let myLet_ = 0",
"↓let myExtremelyVeryVeryVeryVeryVeryVeryLongLet = 0",
"↓var myExtremelyVeryVeryVeryVeryVeryVeryLongVar = 0",
"private ↓let _myExtremelyVeryVeryVeryVeryVeryVeryLongLet = 0",
"↓let i = 0",
"↓var id = 0",
"private ↓let _i = 0",
"↓func IsOperator(name: String) -> Bool",
"enum Foo { case ↓MyEnum }"
]
}

规则44: implicit_getter

对于只有只读属性不建议重写get方法

识别码 默认是否启用 是否支持自动更正 类型
implicit_getter 启用 no style

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//不会触发error
//重写get和set方法
class Foo {
var foo: Int {
get {
return 3
}
set {
_abc = newValue
}
}
}
//只读
class Foo {
var foo: Int {
return 20
}
}

class Foo {
static var foo: Int {
return 20
}
}


//会触发error
class Foo {
var foo: Int {
get {
return 20
}
}
}

class Foo {
var foo: Int {
get{
return 20
}
}
}

规则45: implicit_return

建议使用隐式返回闭包; 如: foo.map({ $0 + 1 })

识别码 默认是否启用 是否支持自动更正 类型
implicit_return 未启用 no style

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
//推荐写法
foo.map { $0 + 1 }
foo.map({ $0 + 1 })
foo.map { value in value + 1 }

//不建议写法
foo.map { value in
return value + 1
}
foo.map {
return $0 + 1
}

规则46: implicitly_unwrapped_optional

尽量避免隐式解析可选类型的使用

识别码 默认是否启用 是否支持自动更正 类型
implicitly_unwrapped_optional 未启用 no idiomatic

下面吗给出官方示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public static let description = RuleDescription(
identifier: "implicitly_unwrapped_optional",
name: "Implicitly Unwrapped Optional",
description: "Implicitly unwrapped optionals should be avoided when possible.",
kind: .idiomatic,

//不会触发warning
nonTriggeringExamples: [
"@IBOutlet private var label: UILabel!",
"@IBOutlet var label: UILabel!",
"@IBOutlet var label: [UILabel!]",
"if !boolean {}",
"let int: Int? = 42",
"let int: Int? = nil"
],

//会触发warning
triggeringExamples: [
"let label: UILabel!",
"let IBOutlet: UILabel!",
"let labels: [UILabel!]",
"var ints: [Int!] = [42, nil, 42]",
"let label: IBOutlet!",
"let int: Int! = 42",
"let int: Int! = nil",
"var int: Int! = 42",
"let int: ImplicitlyUnwrappedOptional<Int>",
"let collection: AnyCollection<Int!>",
"func foo(int: Int!) {}"
]
)

规则47: is_disjoint

初始化集合Set时,推荐使用Set.isDisjoint(), 不建议:Set.intersection

识别码 默认是否启用 是否支持自动更正 类型
is_disjoint 启用 no idiomatic

代码示例:

1
2
3
//推荐写法
_ = Set(syntaxKinds).isDisjoint(with: commentAndStringKindsSet)
let isObjc = !objcAttributes.isDisjoint(with: dictionary.enclosedSwiftAttributes)

规则48: joined_default_parameter

joined方法使用默认分隔符时, 建议使用joined()方法, 而不是joined(separator: “”)方法

识别码 默认是否启用 是否支持自动更正 类型
joined_default_parameter 未启用 yes idiomatic

代码示例:

1
2
3
4
5
6
7
8
//建议写法
let foo = bar.joined()
let foo = bar.joined(separator: ",")
let foo = bar.joined(separator: toto)

//不建议写法
let foo = bar.joined(separator: "")
let foo = bar.filter(toto).joined(separator: "")

规则49: large_tuple

定义的元组成员个数,超过两个warning

识别码 默认是否启用 是否支持自动更正 类型
large_tuple 启用 no metrics

代码示例:

1
2
3
4
5
6
7
8
9
//不会触发warning
let foo: (Int, Int)
let foo: (start: Int, end: Int)
let foo: (Int, (Int, String))

//会触发warning
let foo: (Int, Int, Int)
let foo: (start: Int, end: Int, value: String)
let foo: (Int, (Int, Int, Int))

规则50: leading_whitespace

文件开始不应该有空格或者换行, 否则就会触发warning

识别码 默认是否启用 是否支持自动更正 类型
leading_whitespace 启用 yes style

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// 不会触发warning
//
// ViewController.swift
// SwiftLint
//
// Created by langke on 17/1/12.
// Copyright © 2017年 langke. All rights reserved.
//

/// 会触发warning
//..................................这里有一个空格
// ViewController.swift
// SwiftLint
//
// Created by langke on 17/1/12.
// Copyright © 2017年 langke. All rights reserved.
//

/// 会触发warning
......................................这里是一个空行
//
// ViewController.swift
// SwiftLint
//
// Created by langke on 17/1/12.
// Copyright © 2017年 langke. All rights reserved.
//

参考文档
SwiftLint规则官方文档
SwiftLint个规则详细介绍

有些地方的解释和示例可能不是很完善, 希望各位大神多多指导,后续会持续更新中…….

-------------本文结束感谢您的阅读-------------
欢迎您扫一扫下面的微信公众号,订阅我的博客!
TitanKing wechat
坚持原创技术分享,您的支持将鼓励我继续创作!
分享到:
0%