SwiftLint代码规范属性说明(一)

最新推荐文章于 2022-08-26 11:48:49 发布
最新推荐文章于 2022-08-26 11:48:49 发布
阅读量1.2k 收藏 1
点赞数
文章标签： swift xcode
原文链接：https://juejin.im/post/5aabb31a518825558723505e
版权

SwiftLint代码规范属性说明(一)

上一篇Xcode代码规范之SwiftLint配置介绍了SwiftLint的安装和使用

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

以下个属性均按照字母顺序排列

规则1: closing_brace

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

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

官方示例:

//编译通过
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启用nolint

示例:

//不会触发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启用yesstyle

具体示例:

//不会触发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未启用nostyle

具体示例:

//不会触发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启用nostyle

具体示例:

/// 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未启用yesstyle

以下示例:

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

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

规则7: colon

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

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

具体示例:

//不会触发警告
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启用yesstyle

具体示例:

//不触发警告
[a, b, c, d]

//触发警告
[a ,b]
复制代码

规则9: compiler_protocol_init

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

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

官方示例:

    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未启用nostyle

具体示例:

/// 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未启用noperformance

具体示例:

//推荐写法
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启用nostyle

具体示例:

//建议写法
if condition {
if (a, b) == (0, 1) {

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

规则13: custom_rules

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

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

规则14: cyclomatic_complexity

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

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

规则15: discarded_notification_center_observer

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

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

代码示例:

//推荐写法
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启用nolint

代码示例:

//建议写法
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未启用noidiomatic

代码示例:

//建议写法
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未启用noidiomatic

代码示例:

//不建议写法
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启用nolint

代码示例:

/// 正确的做法
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未启用nolint

官方示例:

    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未启用noperformance

代码示例:

/// 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启用yesstyle

代码示例:

//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启用yesstyle

代码示例:

/// 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启用yesstyle

代码示例:


复制代码

规则25: aaa

...

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

代码示例:

//不会触发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未启用noidiomatic

官方代码示例:

//非触发示例
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未启用noidomatic

代码示例:

//推荐写法
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未启用noidiomatic

代码示例:


复制代码

规则29: no_extension_access_modifier

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

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

代码示例:

//不建议以下写法
private extension String {}
public extension String {}
open extension String {}
internal extension String {}
fileprivate extension String {}
复制代码

规则30: fallthrough

switch语句中不建议使用fallthrough

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

代码示例:

//推荐写法
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未启用noidiomatic

代码示例:

//推荐写法
required init?(coder aDecoder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
}

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

复制代码

规则32: file_header

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

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

代码示例:

/// 不会触发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启用nometrics

代码示例:

复制代码

规则34: first_where

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

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

官方代码示例:

    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启用noidiomatic

代码示例:

//推荐写法
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启用noidiomatic

代码示例:

//建议写法
NSNumber() as? Int

//不推荐
NSNumber() ↓as! Int
复制代码

规则37: force_try

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

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

代码示例:

func myFunction() throws { }

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

}

/// 这样直接触发 error
try! myFunction()
复制代码

规则38: force_unwrapping

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

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

代码示例:

/// 将触发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启用nometrics

代码示例:

复制代码

规则40: function_parameter_count

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

代码示例:

复制代码

规则41: generic_type_name

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

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

代码示例:

//推荐写法
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启用nostyle

官方给出的示例:

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启用nostyle

代码示例:

//不会触发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未启用nostyle

代码示例:

//推荐写法
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未启用noidiomatic

下面吗给出官方示例:

    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启用noidiomatic

代码示例:

//推荐写法
_ = Set(syntaxKinds).isDisjoint(with: commentAndStringKindsSet)
let isObjc = !objcAttributes.isDisjoint(with: dictionary.enclosedSwiftAttributes)
复制代码

规则48: joined_default_parameter

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

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

代码示例:

//建议写法
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启用nometrics

代码示例:

//不会触发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启用yesstyle

代码示例:

/// 不会触发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个规则详细介绍

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

weixin_33859231
关注
Backpack-swiftlint-rules：SwiftLint规则的集合，可以帮助提高背包的采用率
02-14
SwiftLint背包规则 SwiftLint规则的集合，可以帮助提高背包的采用率。 安装 不幸的是，我们没有办法通过任何程序包管理器来分发它们，因此，如果要使用这些规则，只需从复制所需的规则，然后将其放在您自己的.swiftlint.yml文件中。 提示：您可能想添加一条注释，说明它们的来源，以便日后轻松进行更新。 用法 每当您有正当理由忽略规则时，只需使用。 误报 如果您遇到任何假阳性（或假阴性），请通知背包，或在回购交易中提出问题。 贡献 随意分叉并提交PR。 设置 要安装必要的依赖项，请首先确保已安装Node并运行npm ci 。 测试 运行npm test以确保您所做的更改没有破坏任何现有用例。
[译] Swift 里的强制 @inline 注解
weixin_34179968的博客
05-11 832
原文地址：The Forbidden @inline Attribute in Swift 原文作者：Bruno Rocha 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：iWeslie 校对者：CLOXnu Swift 中的 @inline 注解是一个含糊不清的东西，你在 Apple 的文档中是找不到它的，它并不能帮助你编写更清晰的代码，也没...
Swift中使用inline
一只iOS程序员的博客
11-20 2828
Swift中使用inline OC代码编写中我们经常会使用static inline来修饰函数替代宏，得到更好的性能。 那么在swift中如何使用呢？ ##@inline(option) @inline(__always) func foo1() { /// do something... } @inline(never) func foo2() { /// do somethin...
iOS- 工程配置SwiftLint
yuge486的博客
08-27 1033
代码规范工具SwiftLint Github公布的Swift代码规范 Homebrew安装SwiftLint brew install swiftlint 在Xcode中添加运行脚本 在Xcode中选择Build Phase-Add Build Phase-New Run Script Phase，添加如下脚本 if which swiftlint &gt;/dev/nul...
SwiftLint 源码
04-07
SwiftLint 是一个用于强制检查 Swift 代码风格和规定的一个工具，基本上以 Kodeco's Swift 代码风格指南为基础。 SwiftLint Hook 了 Clang 和 SourceKit 从而能够使用 AST 来表示源代码文件的更多精确结果。 编译...
静态的代码分析工具 SwiftLint
09-11
静态的代码分析工具，目的是用于提升代码...圈复杂度注解： 圈复杂度（一种代码复杂度衡量标准），用于衡量一个模块判定结构的复杂程度，数量上表现为独立线性条数，也可理解为覆盖所有可能情况最少使用的测试用例数。
swift-SwiftLint——Swift代码风格检查及自动格式化工具
08-15
SwiftLint是一款强大的开源工具，专为Swift编程语言设计，用于执行代码风格检查和自动格式化。它可以帮助开发者遵循一致的编码规范，提升代码质量和可读性。SwiftLint基于规则进行工作，这些规则涵盖了命名规范、...
swiftlint-config:SwiftLint的良好入门配置
05-19
使用.swiftlint.yml命令在项目的根目录中创建一个.swiftlint.yml文件： parent_config: https://raw.githubusercontent.com/sindresorhus/swiftlint-config/main/.swiftlint.yml （如果想要可预测的构建，请使用...
优化 Swift 代码的艺术：SwiftLint 实践全指南
最新发布
07-22
SwiftLint 是一个用于静态分析 Swift 代码的强大工具，旨在帮助开发者提高代码质量和一致性。其主要优点包括： 1. **代码质量提升**：确保代码符合最佳实践和编码标准。 2. **团队协作**：统一团队成员的代码风格和...
Objective-C语法之KVO的使用
wangyx810328的专栏
11-26 552
http://www.189works.com/article-84627-1.html 简介： 上篇我们讲到了KVC，这篇我们学习KVO，全名为：Key Value Observing，直译为：基于键值的观察者。 那它有什么用呢？KVO主要用于视图交互方面，比如界面的某些数据变化了，界面的显示也跟着需要变化，那就要建立数据和界面的关联。 ObjC中提供的KVO就是
SyntaxError: can‘t assign to operator 问题解决
flyconley的博客
06-02 7812
错误原因: project-dump = “./project” 变量名不能有"-"
第3篇——控制语句
zy010101博客
05-09 292
控制语句 控制流语句通过使用决策、循环和分支来分解执行流。Java 编程语言支持的决策语句（if、if-else、switch）、循环语句（for、while、do-while）和分支语句（break、continue、return）。 if和if-else语句 java中的if和if-else语句和C/C++中的没有什么区别。下面直接用例子来展示。 class IfElseDemo { public static void main(String[] args) { int te
iOS swift swiftLint m1 安装+规则
SCDNBB的博客
04-24 5670
iOS swiftLint m1 安装+规则 m1安装 终端不使用Rosetta brew install swiftlint Cocapods 安装 pod 'SwiftLint' 打开项目xcode，新建两个脚本命令 这里分别复制 if which swiftlint >/dev/null; then swiftlint #echo "skip" else echo "warning: SwiftLint not installed, download from https://git
圈复杂度 Cyclomatic complexity 介绍
gigglesun的专栏
05-22 3696
圈复杂度介绍
用 SwiftLint 保持 Swift 风格一致
网罗天下方法，方便你我开发！！！
08-26 472
如果将 SwiftLint 添加到显示数百个问题的现有项目中，“修复所有冲突”的方法可能非常困难。在这种情况下，将 SwiftLint 配置添加到项目中可能更合适。这是一个YAML文件，在该文件中可以禁用规则，列出选择开启的规则，或者将规则仅限于此文件中的规则。这样， SwiftLint 就可以无限定制。有关更多详细信息，请参阅SwiftLint配置部分。警告的一个例子是代码中存在 TODO 注释。SwiftLint 将这些 TODO 标记为警告，以表示这些地方还有未完成的工作。...
delegate和protocol
Just Code
03-15 195
protocol和delegate完全不是一回事，放在一起说，只是因为我们经常在同一个头文件里看到这两个word。   协议(protocol)，就是使用了这个协议后就要按照这个协议来办事，协议要求实现的方法就一定要实现。   委托(delegate)，顾名思义就是委托别人办事，就是当 一件事情发生后，自己不处理，让别人来处理。   举个浅显的例子：            我上班的工...
Swift Delegate 协议的使用
meiyulong518的博客
09-28 2075
Swift Delegate 协议的使用   协议规定了用来实现某一特定功能所必需的方法和属性。 任意能够满足协议要求的类型被称为遵循(conform)这个协议。 类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能   第一个界面的代码 import UIKit //遵循代理 class ViewController: UIViewController, ...
对 Delegate的误用及解决办法
lionzl的专栏
06-25 693
对 Delegate的误用及解决办法<br />      在开发Silverligh程式的时候，发现了一个问题。<br />      先看一段代码：目的很简单，就是在执行查询的时候进行异步处理。Code<br />public partial class test : UserControl<br />     {<br />         ISDApp01Xml.SDApp01XmlSoapClient client = new ISDApp01Xml.SDApp01XmlSoapClient
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值