检查字符串是否为空

有没有办法在 Swift 中检查字符串的 nil和 ""？在 Rails 中，我可以使用 blank()来检查。

我现在有这个，但看起来有点过了:

    if stringA? != nil {
if !stringA!.isEmpty {
...blah blah
}
}
128994 次浏览
小开

我建议。

if stringA.map(isEmpty) == false {
println("blah blah")
}

如果可选参数是 .Some，则 map应用函数参数。
如果允许可选绑定，操场捕获还显示了新的 Swift 1.2的另一种可能性。

enter image description here

小开

您可以创建自己的自定义函数，如果这是您希望做很多工作的话。

func isBlank (optionalString :String?) -> Bool {
if let string = optionalString {
return string.isEmpty
} else {
return true
}
}






var optionalString :String? = nil


if isBlank(optionalString) {
println("here")
}
else {
println("there")
}
小开

您可以使用 if-let-where 子句:

斯威夫特3:

if let string = string, !string.isEmpty {
/* string is not blank */
}

斯威夫特2:

if let string = string where !string.isEmpty {
/* string is not blank */
}
小开 
var str: String? = nil


if str?.isEmpty ?? true {
print("str is nil or empty")
}


str = ""


if str?.isEmpty ?? true {
print("str is nil or empty")
}
小开

如果您处理的是可选字符串，那么可以这样做:

(string ?? "").isEmpty

如果 ?? nil 聚合运算符为非 nil，则返回左侧，否则返回右侧。

您也可以像这样使用它来返回默认值:

(string ?? "").isEmpty ? "Default" : string!
小开

如果您正在使用 Swift 2，这里有一个我的同事提供的示例，它在可选的 String 上添加 isNilOrEmpty 属性:

protocol OptionalString {}
extension String: OptionalString {}


extension Optional where Wrapped: OptionalString {
var isNilOrEmpty: Bool {
return ((self as? String) ?? "").isEmpty
}
}

然后可以对可选字符串本身使用 isNilOrEmpty

func testNilOrEmpty() {
let nilString:String? = nil
XCTAssertTrue(nilString.isNilOrEmpty)


let emptyString:String? = ""
XCTAssertTrue(emptyString.isNilOrEmpty)


let someText:String? = "lorem"
XCTAssertFalse(someText.isNilOrEmpty)
}
小开

如果您希望以非可选的形式访问字符串，应该使用 Ryan 的回答，但是如果您只关心字符串的非空性，那么我对此的首选速记方法是

if stringA?.isEmpty == false {
...blah blah
}

由于 ==可以很好地使用可选的布尔值，我认为这使得代码可读而不模糊原始意图。

如果您想检查相反的内容: 如果字符串是 nil或 ""，我倾向于显式检查这两种情况，以显示正确的意图:

if stringA == nil || stringA?.isEmpty == true {
...blah blah
}
小开

使用 guard语句

在学习 guard语句之前，我使用 Swift 一段时间。现在我是你的超级粉丝。它的用法类似于 if语句，但是它支持 提前回来，并且通常使代码更加简洁。

若要在检查时使用 Guard 以确保字符串既不为 nil 也不为空，可以执行以下操作:

let myOptionalString: String? = nil


guard let myString = myOptionalString, !myString.isEmpty else {
print("String is nil or empty.")
return // or break, continue, throw
}


/// myString is neither nil nor empty (if this point is reached)
print(myString)

这将打开可选字符串并检查它是否一次性全部为空。如果它为 nil (或空) ，则立即从函数(或循环)返回，并忽略它之后的所有内容。但是如果监护语句通过，则可以安全地使用未包装的字符串。

参见

小开

你可以用这个函数

 class func stringIsNilOrEmpty(aString: String) -> Bool { return (aString).isEmpty }
小开

当处理从本地数据库到服务器的值传递以及反之亦然时，我遇到了太多的麻烦？还有！什么的。

所以我做了一个 Swift3.0实用程序来处理空的情况，我几乎可以完全避免？还有！在密码里。

func str(_ string: String?) -> String {
return (string != nil ? string! : "")
}

例如:-

以前:

    let myDictionary: [String: String] =
["title": (dbObject?.title != nil ? dbObject?.title! : "")]

之后:

    let myDictionary: [String: String] =
["title": str(dbObject.title)]

当需要检查有效字符串时,

    if !str(dbObject.title).isEmpty {
//do stuff
}

这节省了我不得不通过增加和删除的麻烦无数？还有！是在编写合理有意义的代码之后。

小开

迅捷3号解决方案 使用可选的取消包装值并检查布尔值。

if (string?.isempty == true) {
// Perform action
}
小开

创建一个 String 类扩展:

extension String
{   //  returns false if passed string is nil or empty
static func isNilOrEmpty(_ string:String?) -> Bool
{   if  string == nil                   { return true }
return string!.isEmpty
}
}// extension: String

注意，如果字符串包含一个或多个空格，则返回 TRUE。

return string!.trimmingCharacters(in: CharacterSet.whitespaces).isEmpty

这需要基金会。

这样使用它..。

if String.isNilOrEmpty("hello world") == true
{   print("it's a string!")
}
小开

Swift 3 这样可以很好地检查字符串是否真的为空，因为当有空格时 isEmpty 返回 true。

extension String {
func isEmptyAndContainsNoWhitespace() -> Bool {
guard self.isEmpty, self.trimmingCharacters(in: .whitespaces).isEmpty
else {
return false
}
return true
}
}

例子:

let myString = "My String"
myString.isEmptyAndContainsNoWhitespace() // returns false


let myString = ""
myString.isEmptyAndContainsNoWhitespace() // returns true


let myString = " "
myString.isEmptyAndContainsNoWhitespace() // returns false
小开

我知道这个问题有很多答案，但似乎没有一个能像这个(在我看来)验证 UITextField数据那样方便，这是使用 UITextField数据最常见的情况之一:

extension Optional where Wrapped == String {
var isNilOrEmpty: Bool {
return self?.trimmingCharacters(in: .whitespaces).isEmpty ?? true
}
}

你可以用

textField.text.isNilOrEmpty

如果您不认为空格是一个空字符串，或者将其用于更复杂的输入测试，例如，您也可以跳过 .trimmingCharacters(in:.whitespaces)

var isValidInput: Bool {
return !isNilOrEmpty && self!.trimmingCharacters(in: .whitespaces).characters.count >= MIN_CHARS
}
小开

使用三元操作符(也称为条件运算符，C++ forever!) :

if stringA != nil ? stringA!.isEmpty == false : false { /* ... */ }

stringA!力展开只发生在 stringA != nil时，所以它是安全的。在某种程度上，== false的冗长比 !(stringA!.isEmpty)的另一个叹号更具可读性。

我个人比较喜欢略有不同的形式:

if stringA == nil ? false : stringA!.isEmpty == false { /* ... */ }

在上面的语句中，很明显，当变量为 nil时，整个 if块不会执行。

小开

SWIFT 3

extension Optional where Wrapped == String {


/// Checks to see whether the optional string is nil or empty ("")
public var isNilOrEmpty: Bool {
if let text = self, !text.isEmpty { return false }
return true
}
}

在可选字符串上使用如下:

if myString.isNilOrEmpty { print("Crap, how'd this happen?") }
小开

有助于从 UITextField获得值和检查 nil和 empty字符串

@IBOutlet weak var myTextField: UITextField!

下面是从 UITextField 获取字符串并执行其他操作的函数(当您点击 button时)

@IBAction func getStringFrom_myTextField(_ sender: Any) {


guard let string = myTextField.text, !(myTextField.text?.isEmpty)!  else { return }
//use "string" to do your stuff.
}

这将处理 nil值和 empty字符串。

对我来说很有效。

小开

Swift 3 检查空字符串的最佳方法

if !string.isEmpty{


// do stuff


}
小开

你应该这样做:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Nil 合并运算符检查可选项是否为 Nil，如果不是 Nil，则检查其属性，在本例中为 isEmpty。因为这个可选项可以是 nil，所以您提供了一个默认值，当您的可选项为 nil 时将使用该值。

小开

使用 Swift 5，您可以实现 String类型的 Optional扩展，其布尔属性在可选字符串为空或没有值时返回:

extension Optional where Wrapped == String {


var isEmptyOrNil: Bool {
return self?.isEmpty ?? true
}


}

但是，String通过遵守协议 Collection来实现 isEmpty属性。因此，我们可以用一个更广泛的约束(Wrapped: Collection)来替换以前代码的通用约束(Wrapped == String) ，这样 Array、 Dictionary和 Set也可以使我们的新 isEmptyOrNil属性受益:

extension Optional where Wrapped: Collection {


var isEmptyOrNil: Bool {
return self?.isEmpty ?? true
}


}

与 String的用法:

let optionalString: String? = nil
print(optionalString.isEmptyOrNil) // prints: true

let optionalString: String? = ""
print(optionalString.isEmptyOrNil) // prints: true

let optionalString: String? = "Hello"
print(optionalString.isEmptyOrNil) // prints: false

与 Array的用法:

let optionalArray: Array<Int>? = nil
print(optionalArray.isEmptyOrNil) // prints: true

let optionalArray: Array<Int>? = []
print(optionalArray.isEmptyOrNil) // prints: true

let optionalArray: Array<Int>? = [10, 22, 3]
print(optionalArray.isEmptyOrNil) // prints: false

资料来源:

小开

使用是空的

"Hello".isEmpty  // false
"".isEmpty       // true

使用 all滿

extension String {
var isBlank: Bool {
return allSatisfy({ $0.isWhitespace })
}
}


"Hello".isBlank        // false
"".isBlank             // true

使用可选的 String

extension Optional where Wrapped == String {
var isBlank: Bool {
return self?.isBlank ?? true
}
}


var title: String? = nil
title.isBlank            // true
title = ""
title.isBlank            // true

参考资料: https://useyourloaf.com/blog/empty-strings-in-swift/

小开

这是符合 Collection协议的所有类型的通用解决方案，其中包括 String:

extension Optional where Wrapped: Collection {
var isNilOrEmpty: Bool {
self?.isEmpty ?? true
}
}
小开

斯威夫特5.6-Xcode 13

extension Optional where Wrapped: Collection {
var isEmptyOrNil: Bool {
guard let self = self else { return true }
return self.isEmpty
}
}

用法:

var name: String?


if name.isEmptyOrNil {
///true
}


name = "John Peter"


guard !name.isEmptyOrNil else { return }
/// Name is not empty
小开

基于 这篇中文文章，对 Swift 5稍作调整，我得到了这个有效的代码。

if let stringA, !stringA.isEmpty {
...blah blah
}

尽管我理解创建扩展的好处，但我认为它可能会帮助那些只需要一个小组件/包的人。


提交答案