如何在Swift 4中使用String切片下标?


294

我有以下用Swift 3编写的简单代码:

let str = "Hello, playground"
let index = str.index(of: ",")!
let newStr = str.substring(to: index)

从Xcode 9 beta 5,我收到以下警告:

substring(to:)不推荐使用“ ”:请String对带有“ partial range from”运算符的下标进行切片。

如何在Swift 4中使用部分范围的切片下标


var str =“你好,操场”让indexcut = str.firstIndex(of:“,”)print(String(str [.. <indexcut!]))print(String(str [indexcut!...]))
user1828845

Answers:


375

您应将一侧留空,因此命名为“部分范围”。

let newStr = str[..<index]

运算符的部分范围相同,只是将另一侧留空:

let newStr = str[index...]

请记住,这些范围运算符返回Substring。如果要将其转换为字符串,请使用String的初始化函数:

let newStr = String(str[..<index])

您可以在此处阅读有关新子字符串的更多信息。


8
str[..<index]返回Substring。如果你想newStr成为一个,String你必须写:let newStr = "\(str[..<index])"
Lindemann

12
单独使用字符串插值Substring可能会造成一些混乱,因为您真正想要实现的是String初始化:let newStr = String(str[..<index])
加里

5
更新“索引”值只是一个整数的代码会产生错误消息Cannot subscript a value of type 'String' with an index of type 'PartialRangeUpTo<Int>'。在那里必须使用什么类型的值?
ConfusionTowers

22
@ ConfusionTowers,Swift字符串索引不是整数,并且在版本4中没有改变。您可能需要str[..<str.index(str.startIndex, offsetBy: 8)]或类似的东西。请记住,这str.index是函数的线性时间运算offsetBy
zneak

6
@zneak您可能想要str.prefix(8)
Tim Vermeulen

264

将子字符串(Swift 3)转换为字符串切片(Swift 4)

Swift 3、4中的示例:

let newStr = str.substring(to: index) // Swift 3
let newStr = String(str[..<index]) // Swift 4

let newStr = str.substring(from: index) // Swift 3
let newStr = String(str[index...]) // Swift 4 

let range = firstIndex..<secondIndex // If you have a range
let newStr = = str.substring(with: range) // Swift 3
let newStr = String(str[range])  // Swift 4

5
Perfecto,感谢您并排给出3和4个示例,这使我的项目更新变得更容易!
伊桑·帕克

86

斯威夫特5、4

用法

let text = "Hello world"
text[0] // H
text[...3] // "Hell"
text[6..<text.count] // world
text[NSRange(location: 6, length: 3)] // wor

import Foundation

public extension String {
  subscript(value: Int) -> Character {
    self[index(at: value)]
  }
}

public extension String {
  subscript(value: NSRange) -> Substring {
    self[value.lowerBound..<value.upperBound]
  }
}

public extension String {
  subscript(value: CountableClosedRange<Int>) -> Substring {
    self[index(at: value.lowerBound)...index(at: value.upperBound)]
  }

  subscript(value: CountableRange<Int>) -> Substring {
    self[index(at: value.lowerBound)..<index(at: value.upperBound)]
  }

  subscript(value: PartialRangeUpTo<Int>) -> Substring {
    self[..<index(at: value.upperBound)]
  }

  subscript(value: PartialRangeThrough<Int>) -> Substring {
    self[...index(at: value.upperBound)]
  }

  subscript(value: PartialRangeFrom<Int>) -> Substring {
    self[index(at: value.lowerBound)...]
  }
}

private extension String {
  func index(at offset: Int) -> String.Index {
    index(startIndex, offsetBy: offset)
  }
}

14
此功能应为默认的快速行为。
Laimis

4
绝对PR到Swift lib:D
OhadM,

2
这是Swift最丑陋部分的修复。
德米特里

@Dmitry有人不喜欢它,因为此答案为-2。:D
dimpiax

这是一个不好的答案,因为下标运算符隐藏了索引函数的O(n)复杂度。一个好的编程API仅使用下标表示快速查找。
ragnarius

38

在Swift 4/5中更短:

var string = "123456"
string = String(string.prefix(3)) //"123"
string = String(string.suffix(3)) //"456"

26

您的代码到Swift 4的转换也可以通过以下方式完成:

let str = "Hello, playground"
let index = str.index(of: ",")!
let substr = str.prefix(upTo: index)

您可以使用以下代码添加新的字符串:

let newString = String(str.prefix(upTo: index))

17

substring(from:index) 转换为 [index ...]

检查样品

let text = "1234567890"
let index = text.index(text.startIndex, offsetBy: 3)

text.substring(from: index) // "4567890"   [Swift 3]
String(text[index...])      // "4567890"   [Swift 4]

1
字符在Swift 4中已弃用,我认为您必须更改示例以获取Swift 4的索引
AbuTaareq,

这对我有帮助。tnx
user1105951

17

迅捷5

(Java的子字符串方法):

extension String {
    func subString(from: Int, to: Int) -> String {
       let startIndex = self.index(self.startIndex, offsetBy: from)
       let endIndex = self.index(self.startIndex, offsetBy: to)
       return String(self[startIndex...endIndex])
    }
}

用法:

var str = "Hello, Nick Michaels"
print(str.subString(from:7,to:20))
// print Nick Michaels

2
在Swift 5中仍然可以使用。我一直在寻找Java样式的子字符串(fromto-1,例如"Hello".substring(1,4)返回“ ell”)。进行少量修改(startIndex..<endIndex),这是到目前为止我发现的最好的解决方案,只需几行代码即可实现。
Neph

9

一些有用的扩展:

extension String {
    func substring(from: Int, to: Int) -> String {
        let start = index(startIndex, offsetBy: from)
        let end = index(start, offsetBy: to - from)
        return String(self[start ..< end])
    }

    func substring(range: NSRange) -> String {
        return substring(from: range.lowerBound, to: range.upperBound)
    }
}

有趣的是,我在想同样的事情。String(line [“ http://” .endIndex ...])比不赞成使用的子字符串清晰吗?line.substring(from:“ http://” .endIndex)直到他们达到惊人的字符串处理的既定目标之前,它们都不应弃用子字符串。
possen

7

uppercasedFirstCharacterSwift3和Swift4 中便利属性的示例。

属性uppercasedFirstCharacterNew演示了如何在Swift4中使用String切片下标。

extension String {

   public var uppercasedFirstCharacterOld: String {
      if characters.count > 0 {
         let splitIndex = index(after: startIndex)
         let firstCharacter = substring(to: splitIndex).uppercased()
         let sentence = substring(from: splitIndex)
         return firstCharacter + sentence
      } else {
         return self
      }
   }

   public var uppercasedFirstCharacterNew: String {
      if characters.count > 0 {
         let splitIndex = index(after: startIndex)
         let firstCharacter = self[..<splitIndex].uppercased()
         let sentence = self[splitIndex...]
         return firstCharacter + sentence
      } else {
         return self
      }
   }
}

let lorem = "lorem".uppercasedFirstCharacterOld
print(lorem) // Prints "Lorem"

let ipsum = "ipsum".uppercasedFirstCharacterNew
print(ipsum) // Prints "Ipsum"

1
如果您的意思是子字符串(with:range)-> self [range]
Arsen Vartbaronov

6

您可以使用对类String的扩展来创建自定义subString方法,如下所示:

extension String {
    func subString(startIndex: Int, endIndex: Int) -> String {
        let end = (endIndex - self.count) + 1
        let indexStartOfText = self.index(self.startIndex, offsetBy: startIndex)
        let indexEndOfText = self.index(self.endIndex, offsetBy: end)
        let substring = self[indexStartOfText..<indexEndOfText]
        return String(substring)
    }
}

如果要使用endIndex,它还必须能够处理超出范围的问题。
周杰伦

5

使用Swift 4从String创建SubString(前缀和后缀):

let str : String = "ilike"
for i in 0...str.count {
    let index = str.index(str.startIndex, offsetBy: i) // String.Index
    let prefix = str[..<index] // String.SubSequence
    let suffix = str[index...] // String.SubSequence
    print("prefix \(prefix), suffix : \(suffix)")
}

输出量

prefix , suffix : ilike
prefix i, suffix : like
prefix il, suffix : ike
prefix ili, suffix : ke
prefix ilik, suffix : e
prefix ilike, suffix : 

如果要在两个索引之间生成子字符串,请使用:

let substring1 = string[startIndex...endIndex] // including endIndex
let subString2 = string[startIndex..<endIndex] // excluding endIndex

让prefix = str [... <index>]而不是str [.. <index>]单个点丢失。
AbuTaareq,

@AbuTaareq,您在说哪个?让prefix = str [.. <index],这是完美的。(前缀字符串)。尝试在操场上获得更多背景信息。
Ashis Laha

4

我写了一个字符串扩展名来替换'String:subString:'

extension String {

    func sliceByCharacter(from: Character, to: Character) -> String? {
        let fromIndex = self.index(self.index(of: from)!, offsetBy: 1)
        let toIndex = self.index(self.index(of: to)!, offsetBy: -1)
        return String(self[fromIndex...toIndex])
    }

    func sliceByString(from:String, to:String) -> String? {
        //From - startIndex
        var range = self.range(of: from)
        let subString = String(self[range!.upperBound...])

        //To - endIndex
        range = subString.range(of: to)
        return String(subString[..<range!.lowerBound])
    }

}

用法: "Date(1511508780012+0530)".sliceByString(from: "(", to: "+")

结果示例:“ 1511508780012”

PS:可选件必须拆开。请在必要时添加类型安全检查。


注意:选装件被强制拆开。请根据需要添加类型安全检查。
byJeevan

3

编程时,我经常会有只带有纯A-Za-z和0-9的字符串。无需困难的索引操作。此扩展基于普通的旧左/中/右功能。

extension String {

    // LEFT
    // Returns the specified number of chars from the left of the string
    // let str = "Hello"
    // print(str.left(3))         // Hel
    func left(_ to: Int) -> String {
        return "\(self[..<self.index(startIndex, offsetBy: to)])"
    }

    // RIGHT
    // Returns the specified number of chars from the right of the string
    // let str = "Hello"
    // print(str.left(3))         // llo
    func right(_ from: Int) -> String {
        return "\(self[self.index(startIndex, offsetBy: self.length-from)...])"
    }

    // MID
    // Returns the specified number of chars from the startpoint of the string
    // let str = "Hello"
    // print(str.left(2,amount: 2))         // ll
    func mid(_ from: Int, amount: Int) -> String {
        let x = "\(self[self.index(startIndex, offsetBy: from)...])"
        return x.left(amount)
    }
}

好点子!!遗憾的是,仅仅因为它们不断改变事物的工作方式而需要抽象化Swift功能。猜猜他们希望我们所有人都专注于结构而不是生产力。无论如何,我对您的优良代码进行了一些小的更新:pastebin.com/ManWmNnW
Fredrik Johansson

2

使用此方法可以获得特定范围的字符串。您需要传递起始索引,然后传递所需的字符总数。

extension String{
    func substring(fromIndex : Int,count : Int) -> String{
        let startIndex = self.index(self.startIndex, offsetBy: fromIndex)
        let endIndex = self.index(self.startIndex, offsetBy: fromIndex + count)
        let range = startIndex..<endIndex
        return String(self[range])
    }
}

2

这是我的解决方案,没有警告,没有错误,但是很完美

let redStr: String = String(trimmStr[String.Index.init(encodedOffset: 0)..<String.Index.init(encodedOffset: 2)])
let greenStr: String = String(trimmStr[String.Index.init(encodedOffset: 3)..<String.Index.init(encodedOffset: 4)])
let blueStr: String = String(trimmStr[String.Index.init(encodedOffset: 5)..<String.Index.init(encodedOffset: 6)])

的使用encodedOffset认为是有害的,将被弃用
Martin R

1

希望这会有所帮助:-

var string = "123456789"

如果要在某个特定索引后添加子字符串。

var indexStart  =  string.index(after: string.startIndex )// you can use any index in place of startIndex
var strIndexStart   = String (string[indexStart...])//23456789

如果要在删除某些字符串后添加子字符串,请在最后。

var indexEnd  =  string.index(before: string.endIndex)
var strIndexEnd   = String (string[..<indexEnd])//12345678

您还可以使用以下代码创建索引:-

var  indexWithOffset =  string.index(string.startIndex, offsetBy: 4)

0

希望对您有所帮助。

extension String {
    func getSubString(_ char: Character) -> String {
        var subString = ""
        for eachChar in self {
            if eachChar == char {
                return subString
            } else {
                subString += String(eachChar)
            }
        }
        return subString
    }
}


let str: String = "Hello, playground"
print(str.getSubString(","))

0
var str = "Hello, playground"
let indexcut = str.firstIndex(of: ",")
print(String(str[..<indexcut!]))
print(String(str[indexcut!...]))

您可以通过这种方式尝试,并会获得适当的结果。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.