Get nth character of a string in Swift programming language

Question

How can I get the nth character of a string  I tried bracket     accessor with no luck    var string    Hello  world    var firstChar   string 0     Throws error      ERROR   subscript  is unavailable  cannot subscript String with an Int  see the documentation comment for discussion

User · Answer

There s an alternative  explained in String manifesto  extension String   BidirectionalCollection       subscript i  Index  - gt  Character   return characters i

User · Answer

Swift 5 1  Here might be the easiest solution out of all these answers   Add this extension   extension String       func retrieveFirstCharacter   - gt  String            guard self count  gt  0 else   return nil           let numberOfCharacters   self count         return String self dropLast numberOfCharacters - 1

User · Answer

Get  amp  Set Subscript  String  amp  Substring  - Swift 4 2 Swift 4 2  Xcode 10 I based my answer off of  alecarlson s answer  The only big difference is you can get a Substring or a String returned  and in some cases  a single Character   You can also get and set the subscript  Lastly  mine is a bit more cumbersome and longer than  alecarlson s answer and as such  I suggest you put it in a source file   Extension  public extension String       public subscript  i  Int  - gt  Character           get               return self index startIndex  offsetBy  i                     set  c                let n   index startIndex  offsetBy  i              replaceSubrange n   n  with   quot   c  quot                       public subscript  bounds  CountableRange lt Int gt   - gt  Substring           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return self start    lt  end                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start    lt  end  with  s                      public subscript  bounds  CountableClosedRange lt Int gt   - gt  Substring           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return self start     end                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start     end  with  s                               public subscript  bounds  CountablePartialRangeFrom lt Int gt   - gt  Substring           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              return self start     end                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              replaceSubrange start     end  with  s                      public subscript  bounds  PartialRangeThrough lt Int gt   - gt  Substring           get               let end   index startIndex  offsetBy  bounds upperBound              return self startIndex     end                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex     end  with  s                      public subscript  bounds  PartialRangeUpTo lt Int gt   - gt  Substring           get               let end   index startIndex  offsetBy  bounds upperBound              return self startIndex    lt  end                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex    lt  end  with  s                           public subscript  i  Int  - gt  String           get               return  quot   self index startIndex  offsetBy  i    quot                    set  c                let n   index startIndex  offsetBy  i              self replaceSubrange n   n  with   quot   c  quot                       public subscript  bounds  CountableRange lt Int gt   - gt  String           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return  quot   self start    lt  end   quot                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start    lt  end  with  s                      public subscript  bounds  CountableClosedRange lt Int gt   - gt  String           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return  quot   self start     end   quot                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start     end  with  s                               public subscript  bounds  CountablePartialRangeFrom lt Int gt   - gt  String           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              return  quot   self start     end   quot                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              replaceSubrange start     end  with  s                      public subscript  bounds  PartialRangeThrough lt Int gt   - gt  String           get               let end   index startIndex  offsetBy  bounds upperBound              return  quot   self startIndex     end   quot                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex     end  with  s                      public subscript  bounds  PartialRangeUpTo lt Int gt   - gt  String           get               let end   index startIndex  offsetBy  bounds upperBound              return  quot   self startIndex    lt  end   quot                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex    lt  end  with  s                           public subscript  i  Int  - gt  Substring           get               return Substring  quot   self index startIndex  offsetBy  i    quot                     set  c                let n   index startIndex  offsetBy  i              replaceSubrange n   n  with   quot   c  quot                     public extension Substring       public subscript  i  Int  - gt  Character           get               return self index startIndex  offsetBy  i                     set  c                let n   index startIndex  offsetBy  i              replaceSubrange n   n  with   quot   c  quot                                public subscript  bounds  CountableRange lt Int gt   - gt  Substring           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return self start    lt  end                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start    lt  end  with  s                      public subscript  bounds  CountableClosedRange lt Int gt   - gt  Substring           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return self start     end                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start     end  with  s                      public subscript  bounds  CountablePartialRangeFrom lt Int gt   - gt  Substring           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              return self start     end                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              replaceSubrange start     end  with  s                               public subscript  bounds  PartialRangeThrough lt Int gt   - gt  Substring           get               let end   index startIndex  offsetBy  bounds upperBound              return self startIndex     end                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex    lt  end  with  s                      public subscript  bounds  PartialRangeUpTo lt Int gt   - gt  Substring           get               let end   index startIndex  offsetBy  bounds upperBound              return self startIndex    lt  end                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex    lt  end  with  s                      public subscript  i  Int  - gt  String           get               return  quot   self index startIndex  offsetBy  i    quot                    set  c                let n   index startIndex  offsetBy  i              replaceSubrange n   n  with   quot   c  quot                       public subscript  bounds  CountableRange lt Int gt   - gt  String           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return  quot   self start    lt  end   quot                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start    lt  end  with  s                      public subscript  bounds  CountableClosedRange lt Int gt   - gt  String           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              return  quot   self start     end   quot                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange start     end  with  s                               public subscript  bounds  CountablePartialRangeFrom lt Int gt   - gt  String           get               let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              return  quot   self start     end   quot                    set  s                let start   index startIndex  offsetBy  bounds lowerBound              let end   index endIndex  offsetBy  -1              replaceSubrange start     end  with  s                      public subscript  bounds  PartialRangeThrough lt Int gt   - gt  String           get               let end   index startIndex  offsetBy  bounds upperBound              return  quot   self startIndex     end   quot                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex     end  with  s                      public subscript  bounds  PartialRangeUpTo lt Int gt   - gt  String           get               let end   index startIndex  offsetBy  bounds upperBound              return  quot   self startIndex    lt  end   quot                    set  s                let end   index startIndex  offsetBy  bounds upperBound              replaceSubrange startIndex    lt  end  with  s                           public subscript  i  Int  - gt  Substring           get               return Substring  quot   self index startIndex  offsetBy  i    quot                     set  c                let n   index startIndex  offsetBy  i              replaceSubrange n   n  with   quot   c  quot

User · Answer

In order to feed the subject and show swift subscript possibilities  here s a little string  substring-toolbox  subscript based  These methods are safe and never go over string indexes  extension String          string i  - gt  one string char     subscript pos  Int  - gt  String   return String Array self  min self length-1 max 0 pos               string pos len  - gt  substring from pos for len chars on the left     subscript pos  Int  len  Int  - gt  String   return self pos  len   pos len   left2right            string pos  len   right2left  - gt  substring from pos for len chars on the right     subscript pos  Int  len  Int  way  Way  - gt  String   return self pos  len   pos len  way            string range  - gt  substring form start pos on the left to end pos on the right     subscript range  Range lt Int gt   - gt  String   return self range startIndex  range endIndex   start end   left2right            string range   right2left  - gt  substring start pos on the right to end pos on the left     subscript range  Range lt Int gt   way  Way  - gt  String   return self range startIndex  range endIndex   start end  way         var length  Int   return countElements self        enum Mode   case pos len  start end       enum Way   case left2right  right2left       subscript var val1  Int  var val2  Int  mode  Mode  way  Way  - gt  String           if mode     start end               if val1  gt  val2   let val val1   val1 val2   val2 val               val2   val2-val1                   if way     left2right               val1   min self length-1  max 0 val1               val2   min self length-val1  max 1 val2             else               let val1    val1             val1   min self length-1  max 0  self length-val1 -val2                val2   max 1   self length-1-val1  - val1-1                      return self bridgeToObjectiveC   substringWithRange NSMakeRange val1  val2              -- Alternative code without bridge --           var range  Range lt Int gt    pos    pos len-1            var start   advance startIndex  range startIndex            var end   advance startIndex  range endIndex            return self substringWithRange Range start  start  end  end             println  0123456789  3      return  3   println  0123456789  3 2      return  34   println  0123456789  3 2  right2left      return  56   println  0123456789  5 10  pos len  left2right      return  56789   println  0123456789  8 120  pos len  right2left      return  01   println  0123456789  120 120  pos len  left2right      return  9   println  0123456789  0   4      return  01234   println  0123456789  0  4      return  0123   println  0123456789  0   4  right2left      return  56789   println  0123456789  4   0  right2left      return  678   lt  lt  because     range can wear endIndex at 0

User · Answer

Update for swift 2 0 subString   public extension String       public subscript  i  Int  - gt  String           return self substringWithRange self startIndex   lt self startIndex advancedBy i   1              public subscript  r  Range lt Int gt   - gt  String           get               return self substringWithRange self startIndex advancedBy r startIndex    lt self startIndex advancedBy r endIndex

User · Answer

Swift 2 0 as of Xcode 7 GM Seed  var text    Hello  world    let firstChar   text text startIndex advancedBy 0       H    For the nth character  replace 0 with n-1   Edit  Swift 3 0  text text index text startIndex  offsetBy  0      n b  there are simpler ways of grabbing certain characters in the string  e g  let firstChar   text characters first

User · Answer

Using characters  would do the job  You can quickly convert the String to an array of characters that can be manipulated by the CharacterView methods   Example   let myString    Hello World   let myChars    myString characters    full CharacterView doc    tested in Swift 3

User · Answer

Xcode 11     Swift 5 1  You can extend StringProtocol to make the subscript available also to the substrings   extension StringProtocol       subscript   offset  Int                      - gt  Element       self index startIndex  offsetBy  offset         subscript   range  Range lt Int gt                 - gt  SubSequence   prefix range lowerBound range count  suffix range count        subscript   range  ClosedRange lt Int gt           - gt  SubSequence   prefix range lowerBound range count  suffix range count        subscript   range  PartialRangeThrough lt Int gt   - gt  SubSequence   prefix range upperBound advanced by  1         subscript   range  PartialRangeUpTo lt Int gt      - gt  SubSequence   prefix range upperBound        subscript   range  PartialRangeFrom lt Int gt      - gt  SubSequence   suffix Swift max 0  count-range lowerBound           extension LosslessStringConvertible       var string  String    init self          extension BidirectionalCollection       subscript safe offset  Int  - gt  Element            guard  isEmpty  let i   index startIndex  offsetBy  offset  limitedBy  index before  endIndex   else   return nil           return self i              Testing  let test    Hello USA     Hello Brazil      test safe  10          test 11           test 10               Hello Brazil      test 10   lt 12           test 10   12            test    10        Hello USA   test    lt 10        Hello USA   test first       H  test last               Subscripting the Substring  test         3       Hell      Note that they all return a Substring of the original String     To create a new String from a substring test 10     string          Hello Brazil

User · Answer

Best way which worked for me is  var firstName    quot Olivia quot  var lastName    quot Pope quot   var nameInitials text    quot   firstName prefix 1   quot     quot       lastName prefix 1   quot   Output  quot OP quot

User · Answer

Swift 5 3 I think this is very elegant  Kudos at Paul Hudson of  quot Hacking with Swift quot  for this solution   available  macOS 10 15      extension String       subscript idx  Int  - gt  String           String self index startIndex  offsetBy  idx              Then to get one character out of the String you simply do  var string    quot Hello  world  quot   var firstChar   string 0     No error  returns  quot H quot  as a String

User · Answer

Swift 4  String Array stringToIndex  index      This is probably the best way of solving this problem one-time  You probably want to cast the String as an array first  and then cast the result as a String again  Otherwise  a Character will be returned instead of a String   Example String Array  HelloThere   1   will return  e  as a String    Array  HelloThere   1  will return  e  as a Character   Swift does not allow Strings to be indexed like arrays  but this gets the job done  brute-force style

User · Answer

Swift 3  another solution  tested in playground   extension String       func substr   start Int  length Int 0  - gt  String            guard start  gt  -1 else               return nil                    let count   self characters count - 1          guard start  lt   count else               return nil                    let startOffset   max 0  start          let endOffset   length  gt  0   min count  startOffset   length - 1    count          return self self index self startIndex  offsetBy  startOffset    self index self startIndex  offsetBy  endOffset             Usage   let txt    12345   txt substr -1    nil txt substr 0     12345  txt substr 0  length  0     12345  txt substr 1     2345  txt substr 2     345  txt substr 3     45  txt substr 4     5  txt substr 6    nil txt substr 0  length  1     1  txt substr 1  length  1     2  txt substr 2  length  1     3  txt substr 3  length  1     4  txt substr 3  length  2     45  txt substr 3  length  3     45  txt substr 4  length  1     5  txt substr 4  length  2     5  txt substr 5  length  1    nil txt substr 5  length  -1    nil txt substr -1  length  -1    nil

User · Answer

As an aside note  there are a few functions applyable directly to the Character-chain representation of a String  like this   var string    Hello  playground  let firstCharacter   string characters first    returns  H  let lastCharacter   string characters last    returns  d    The result is of type Character  but you can cast it to a String   Or this   let reversedString   String string characters reverse       returns  dnuorgyalp  olleH      -

User · Answer

No indexing using integers  only using String Index  Mostly with linear complexity  You can also create ranges from String Index and get substrings using them   Swift 3 0  let firstChar   someString someString startIndex  let lastChar   someString someString index before  someString endIndex   let charAtIndex   someString someString index someString startIndex  offsetBy  10    let range   someString startIndex   lt someString index someString startIndex  offsetBy  10  let substring   someString range    Swift 2 x  let firstChar   someString someString startIndex  let lastChar   someString someString endIndex predecessor    let charAtIndex   someString someString startIndex advanceBy 10    let range   someString startIndex   lt someString startIndex advanceBy 10  let subtring   someString range    Note that you can t ever use an index  or range  created from one string to another string  let index10   someString startIndex advanceBy 10     will compile   sometimes it will work but sometimes it will crash or result in undefined behaviour let charFromAnotherString   anotherString index10

User · Answer

If you see Cannot subscript a value of type  String     use this extension   Swift 3  extension String       subscript  i  Int  - gt  Character           return self self characters index self startIndex  offsetBy  i              subscript  i  Int  - gt  String           return String self i  as Character             subscript  r  Range lt Int gt   - gt  String           let start   index startIndex  offsetBy  r lowerBound          let end   index startIndex  offsetBy  r upperBound          return self start   lt end             subscript  r  ClosedRange lt Int gt   - gt  String           let start   index startIndex  offsetBy  r lowerBound          let end   index startIndex  offsetBy  r upperBound          return self start   end            Swift 2 3  extension String       subscript integerIndex  Int  - gt  Character           let index   advance startIndex  integerIndex          return self index             subscript integerRange  Range lt Int gt   - gt  String           let start   advance startIndex  integerRange startIndex          let end   advance startIndex  integerRange endIndex          let range   start   lt end         return self range            Source  http   oleb net blog 2014 07 swift-strings

User · Answer

Swift 4 2 This answer is ideal because it extends String and all of its Subsequences  Substring  in one extension public extension StringProtocol            public subscript  i  Int  - gt  Element           return self index startIndex  offsetBy  i              public subscript  bounds  CountableClosedRange lt Int gt   - gt  SubSequence           let start   index startIndex  offsetBy  bounds lowerBound          let end   index startIndex  offsetBy  bounds upperBound          return self start   end                 public subscript  bounds  CountableRange lt Int gt   - gt  SubSequence           let start   index startIndex  offsetBy  bounds lowerBound          let end   index startIndex  offsetBy  bounds upperBound          return self start   lt end                 public subscript  bounds  PartialRangeUpTo lt Int gt   - gt  SubSequence           let end   index startIndex  offsetBy  bounds upperBound          return self startIndex   lt end                 public subscript  bounds  PartialRangeThrough lt Int gt   - gt  SubSequence           let end   index startIndex  offsetBy  bounds upperBound          return self startIndex   end                 public subscript  bounds  CountablePartialRangeFrom lt Int gt   - gt  SubSequence           let start   index startIndex  offsetBy  bounds lowerBound          return self start   lt endIndex           Usage var str    quot Hello  playground quot   print str 5        5  0      Prints  quot   quot

User · Answer

Get the first letter    first str     retrieve first letter   More here  http   sketchytech blogspot com 2014 08 swift-pure-swift-method-for-returning html

User · Answer

Swift 4 let str    quot My String quot   String at index let index   str index str startIndex  offsetBy  3  String str index          quot S quot   Substring let startIndex   str index str startIndex  offsetBy  3  let endIndex   str index str startIndex  offsetBy  7  String str startIndex   endIndex           quot Strin quot   First n chars let startIndex   str index str startIndex  offsetBy  3  String str    lt startIndex          quot My  quot   Last n chars let startIndex   str index str startIndex  offsetBy  3  String str startIndex             quot String quot    Swift 2 and 3 str    quot My String quot     String At Index    Swift 2 let charAtIndex   String str str startIndex advancedBy 3        charAtIndex    quot S quot   Swift 3 str str index str startIndex  offsetBy  3    SubString fromIndex toIndex Swift 2 let subStr   str str startIndex advancedBy 3    str startIndex advancedBy 7      subStr    quot Strin quot   Swift 3 str str index str startIndex  offsetBy  3    str index str startIndex  offsetBy  7    First n chars let first2Chars   String str characters prefix 2      first2Chars    quot My quot   Last n chars let last3Chars   String str characters suffix 3      last3Chars    quot ing quot

User · Answer

Check this is Swift 4  let myString    LOVE   self textField1 text   String Array myString  0   self textField2 text   String Array myString  1   self textField3 text   String Array myString  2   self textField4 text   String Array myString  3

User · Answer

You could use SwiftString  https   github com amayne SwiftString  to do this    Hello  world   0     H  Hello  world   0   4     Hello   DISCLAIMER  I wrote this extension

User · Answer

prob one of the best and simpliest way          let yourString    thisString          print Array yourString  8     puts each letters of your string into arrrays and then you sellect the 9th one

User · Answer

My very simple solution   Swift 4 1   let myString    Test string  let index   0 let firstCharacter   myString String Index encodedOffset  index     Swift 5 1   let firstCharacter   myString String Index init utf16Offset  index  in  myString

User · Answer

My solution is in one line  supposing cadena is the string and 4 is the nth position that you want   let character   cadena advance cadena startIndex  4     Simple    I suppose Swift will include more things about substrings in future versions

User · Answer

Include this extension in your project    extension String  func trim   - gt  String       return self trimmingCharacters in  NSCharacterSet whitespaces     var length  Int       return self count    subscript  i  Int  - gt  String       return self i    lt  i   1     func substring fromIndex  Int  - gt  String       return self min fromIndex  length     lt  length     func substring toIndex  Int  - gt  String       return self 0    lt  max 0  toIndex      subscript  r  Range lt Int gt   - gt  String       let range   Range uncheckedBounds   lower  max 0  min length  r lowerBound                                            upper  min length  max 0  r upperBound         let start   index startIndex  offsetBy  range lowerBound      let end   index start  offsetBy  range upperBound - range lowerBound      return String self start    lt  end      func substring fromIndex  Int  toIndex Int - gt String      let startIndex   self index self startIndex  offsetBy  fromIndex      let endIndex   self index startIndex  offsetBy  toIndex-fromIndex       return String self startIndex   endIndex       An then use the function like this   let str    Sample-String   let substring   str substring fromIndex  0  toIndex  0    returns S let sampleSubstr   str substring fromIndex  0  toIndex  5    returns Sample

User · Answer

I wanted to point out that if you have a large string and need to randomly access many characters from it  you may want to pay the extra memory cost and convert the string to an array for better performance      Pay up front for O N  memory let chars   Array veryLargeString characters   for i in 0   veryLargeNumber          Benefit from O 1  access     print chars i

User · Answer

In Swift 5 without extension to the String    var str    ABCDEFGH  for char in str   if char     C           Above Swift code as same as that Java code    int n   8  var str    ABCDEFGH  for  int i 0  i lt n  i      if  str charAt i      C

User · Answer

I think that a fast answer for get the first character could be   let firstCharacter   aString aString startIndex    It s so much elegant and performance than    let firstCharacter   Array aString characters  first   But   if you want manipulate and do more operations with strings you could think create an extension  here is one extension with this approach  it s quite similar to that already posted here   extension String   var length   Int       return self characters count    subscript integerIndex  Int  - gt  Character       let index   startIndex advancedBy integerIndex      return self index     subscript integerRange  Range lt Int gt   - gt  String       let start   startIndex advancedBy integerRange startIndex      let end   startIndex advancedBy integerRange endIndex      let range   start   lt end     return self range         BUT IT S A TERRIBLE IDEA     The extension below is horribly inefficient  Every time a string is accessed with an integer  an O n  function to advance its starting index is run  Running a linear loop inside another linear loop means this for loop is accidentally O n2      as the length of the string increases  the time this loop takes increases quadratically   Instead of doing that you could use the characters s string collection

User · Answer

In Swift 3 without extensions to the String class  as simple as I can make it   let myString    abcedfg  let characterLocationIndex   myString index myString startIndex  offsetBy  3  let myCharacter   myString characterLocationIndex    myCharacter is  3  in this example

User · Answer

By now   subscript      is unavailable  As well as we can t do this  str 0     with string We have to provide  String Index  But  how can we give our own index number in this way  instead we can use   string str index str startIndex  offsetBy  0

User · Answer

Swift 3  extension String        public func charAt   i  Int  - gt  Character           return self self characters index self startIndex  offsetBy  i              public subscript  i  Int  - gt  String           return String self charAt i  as Character             public subscript  r  Range lt Int gt   - gt  String           return substring with  self characters index self startIndex  offsetBy  r lowerBound    lt self characters index self startIndex  offsetBy  r upperBound              public subscript  r  CountableClosedRange lt Int gt   - gt  String           return substring with  self characters index self startIndex  offsetBy  r lowerBound    lt self characters index self startIndex  offsetBy  r upperBound              Usage  let str    Hello World  let sub   str 0   4    Helpful Programming Tips and Tricks  written by me

User · Answer

I just had the same issue  Simply do this   var aString  String    test  var aChar unichar    aString as NSString  characterAtIndex 0

User · Answer

Swift 5 2  let str    abcdef  str 1    lt  3     returns  bc  str 5     returns  f  str 80     returns    str substring fromIndex  3     returns  def  str substring toIndex  str length - 2     returns  abcd      You will need to add this String extension to your project  it s fully tested    extension String        var length  Int           return count            subscript  i  Int  - gt  String           return self i    lt  i   1             func substring fromIndex  Int  - gt  String           return self min fromIndex  length     lt  length             func substring toIndex  Int  - gt  String           return self 0    lt  max 0  toIndex              subscript  r  Range lt Int gt   - gt  String           let range   Range uncheckedBounds   lower  max 0  min length  r lowerBound                                                upper  min length  max 0  r upperBound             let start   index startIndex  offsetBy  range lowerBound          let end   index start  offsetBy  range upperBound - range lowerBound          return String self start    lt  end               Even though Swift always had out of the box solution to this problem  without String extension  which I provided below   I still would strongly recommend using the extension  Why  Because it saved me tens of hours of painful migration from early versions of Swift  where String s syntax was changing almost every release  but all I needed to do was to update the extension s implementation as opposed to refactoring the entire project  Make your choice   let str    Hello  world   let index   str index str startIndex  offsetBy  4  str index     returns Character  o   let endIndex   str index str endIndex  offsetBy -2  str index    lt  endIndex     returns String  o  worl   String str suffix from  index      returns String  o  world   String str prefix upTo  index      returns String  Hell

User · Answer

A python-like solution  which allows you to use negative index    var str    Hello world   str -1                  could be   extension String       subscript  var index Int - gt Character          get               let n   distance self startIndex  self endIndex              index    n             if index  lt  0   index    n               return self advance startIndex  index                       By the way  it may be worth it to transpose the whole python s slice notation

User · Answer

Swift 2 2 Solution   The following extension works in Xcode 7  this is a combination of this solution and Swift 2 0 syntax conversion    extension String       subscript integerIndex  Int  - gt  Character           let index   startIndex advancedBy integerIndex          return self index             subscript integerRange  Range lt Int gt   - gt  String           let start   startIndex advancedBy integerRange startIndex          let end   startIndex advancedBy integerRange endIndex          let range   start   lt end         return self range

User · Answer

You can do it by convert String into Array and get it by specific index using subscript as below  var str    Hello  let s   Array str  2  print s

User · Answer

Swift 4 2 or later Range and partial range subscripting using String s indices property As variation of  LeoDabus nice answer  we may add an additional extension to DefaultIndices with the purpose of allowing us to fall back on the indices property of String when implementing the custom subscripts  by Int specialized ranges and partial ranges  for the latter  extension DefaultIndices       subscript at  Int  - gt  Elements Index   index startIndex  offsetBy  at          Moving the index   offsetBy   to an extension yields slightly    briefer implementations for these String extensions  extension String       subscript range  Range lt Int gt   - gt  SubSequence           let start   indices range lowerBound          return self start   lt indices start     range count             subscript range  ClosedRange lt Int gt   - gt  SubSequence           let start   indices range lowerBound          return self start   indices start     range count             subscript range  PartialRangeFrom lt Int gt   - gt  SubSequence           self indices range lowerBound                subscript range  PartialRangeThrough lt Int gt   - gt  SubSequence           self    indices range upperBound             subscript range  PartialRangeUpTo lt Int gt   - gt  SubSequence           self    lt indices range upperBound            let str    quot foo bar baz bax quot  print str 4   lt 6       quot ba quot  print str 4   6       quot bar quot  print str 4           quot bar baz bax quot  print str    6        quot foo bar quot  print str    lt 6        quot foo ba quot   Thanks  LeoDabus for the pointing me in the direction of using the indices property as an other  alternative to String subscripting

User · Answer

You can also convert String to Array of Characters like that   let text    My Text  let index   2 let charSequence   text unicodeScalars map  Character  0    let char   charSequence index    This is the way to get char at specified index in constant time   The example below doesn t run in constant time  but requires linear time  So If You have a lot of searching in String by index use the method above   let char   text text startIndex advancedBy index

User · Answer

Swift s String type does not provide a characterAtIndex method because there are several ways a Unicode string could be encoded  Are you going with UTF8  UTF16  or something else   You can access the CodeUnit collections by retrieving the String utf8 and String utf16 properties  You can also access the UnicodeScalar collection by retrieving the String unicodeScalars property   In the spirit of NSString s implementation  I m returning a unichar type   extension String       func characterAtIndex index Int  - gt  unichar               return self utf16 index                Allows us to use String index  notation     subscript index Int  - gt  unichar               return characterAtIndex index           let text    Hello Swift   let firstChar   text 0

User · Answer

Swift 3   extension String       func substring fromPosition  UInt  toPosition  UInt  - gt  String            guard fromPosition  lt   toPosition else               return nil                    guard toPosition  lt  UInt characters count  else               return nil                    let start   index startIndex  offsetBy  String IndexDistance fromPosition           let end     index startIndex  offsetBy  String IndexDistance toPosition    1          let range   start   lt end          return substring with  range            ffaabbcc  substring fromPosition  2  toPosition  5     return  aabb

User · Answer

Here s an extension you can use  working with Swift 3 1  A single index will return a Character  which seems intuitive when indexing a String  and a Range will return a String  extension String       subscript  i  Int  - gt  Character           return Array self characters  i                 subscript  r  CountableClosedRange lt Int gt   - gt  String           return String Array self characters  r                  subscript  r  CountableRange lt Int gt   - gt  String           return self r lowerBound   r upperBound-1           Some examples of the extension in action  let string    quot Hello quot   let c1   string 1      Character  quot e quot  let c2   string -1     fatal error  Index out of range  let r1   string 1   lt 4     String  quot ell quot  let r2   string 1   4     String  quot ello quot  let r3   string 1   5     fatal error  Array index is out of range    n b  You could add an additional method to the above extension to return a String with a single character if wanted  subscript  i  Int  - gt  String       return String self i      Note that then you would have to explicitly specify the type you wanted when indexing the string  let c  Character   string 3     Character  quot l quot  let s  String   string 0        String  quot H quot

User · Answer

Swift 5 1 3   Add a String extension    extension String     func stringAt   i  Int  - gt  String       return String Array self  i          func charAt   i  Int  - gt  Character      return Array self  i          let str    Teja Kumar  let str1  String   str stringAt 2      j  let str2  Character   str charAt 5      k

User · Answer

I just came up with this neat workaround  var firstChar   Array string  0

User · Answer

Allows Negative Indices  Its always useful not always having to write string string length - 1  to get the last character when using a subscript extension  This  Swift 3  extension  allows for negative indices  Range and CountableClosedRange    extension String       var count  Int   return self characters count        subscript  i  Int  - gt  Character              wraps out of bounds indices         let j   i   self count            wraps negative indices         let x   j  lt  0   j   self count   j             quick exit for first         guard x    0 else               return self characters first                        quick exit for last         guard x    count - 1 else               return self characters last                     return self self index self startIndex  offsetBy  x              subscript  r  Range lt Int gt   - gt  String           let lb   r lowerBound         let ub   r upperBound             quick exit for one character         guard lb    ub else   return String self lb              return self self index self startIndex  offsetBy  lb    lt self index self startIndex  offsetBy  ub              subscript  r  CountableClosedRange lt Int gt   - gt  String           return self r lowerBound   lt r upperBound   1            How you can use it   var text    Hello World   text -1        d text 2         l text 12        e text 0   4     Hello text 0   lt 4     Hell   For the more thorough Programmer  Include a guard against empty Strings in this extension  subscript  i  Int  - gt  Character       guard self count    0 else   return                 subscript  r  Range lt Int gt   - gt  String       guard self count    0 else   return

User · Answer

Attention  Please see Leo Dabus  answer for a proper implementation for Swift 4 and Swift 5   Swift 4 or later  The Substring type was introduced in Swift 4 to make substrings faster and more efficient by sharing storage with the original string  so that s what the subscript functions should return   Try it out here  extension StringProtocol       subscript offset  Int  - gt  Character   self index startIndex  offsetBy  offset         subscript range  Range lt Int gt   - gt  SubSequence           let startIndex   index self startIndex  offsetBy  range lowerBound          return self startIndex   lt index startIndex  offsetBy  range count             subscript range  ClosedRange lt Int gt   - gt  SubSequence           let startIndex   index self startIndex  offsetBy  range lowerBound          return self startIndex   lt index startIndex  offsetBy  range count             subscript range  PartialRangeFrom lt Int gt   - gt  SubSequence   self index startIndex  offsetBy  range lowerBound            subscript range  PartialRangeThrough lt Int gt   - gt  SubSequence   self    index startIndex  offsetBy  range upperBound         subscript range  PartialRangeUpTo lt Int gt   - gt  SubSequence   self    lt index startIndex  offsetBy  range upperBound         To convert the Substring into a String  you can simply do String string 0  2    but you should only do that if you plan to keep the substring around  Otherwise  it s more efficient to keep it a Substring   It would be great if someone could figure out a good way to merge these two extensions into one  I tried extending StringProtocol without success  because the index method does not exist there  Note  This answer has been already edited  it is properly implemented and now works for substrings as well  Just make sure to use a valid range to avoid crashing when subscripting your StringProtocol type  For subscripting with a range that won t crash with out of range values you can use this implementation    Why is this not built-in   The error message says  see the documentation comment for discussion   Apple provides the following explanation in the file UnavailableStringAPIs swift      Subscripting strings with integers is not available       The concept of  the ith character in a string  has   different interpretations in different libraries and system   components   The correct interpretation should be selected   according to the use case and the APIs involved  so String   cannot be subscripted with an integer       Swift provides several different ways to access the character   data stored inside strings          String utf8 is a collection of UTF-8 code units in the   string  Use this API when converting the string to UTF-8    Most POSIX APIs process strings in terms of UTF-8 code units    String utf16 is a collection of UTF-16 code units in   string   Most Cocoa and Cocoa touch APIs process strings in   terms of UTF-16 code units   For example  instances of   NSRange used with NSAttributedString and   NSRegularExpression store substring offsets and lengths in   terms of UTF-16 code units    String unicodeScalars is a collection of Unicode scalars    Use this API when you are performing low-level manipulation   of character data    String characters is a collection of extended grapheme   clusters  which are an approximation of user-perceived   characters          Note that when processing strings that contain human-readable text    character-by-character processing should be avoided to the largest extent   possible  Use high-level locale-sensitive Unicode algorithms instead  for example    String localizedStandardCompare      String localizedLowercaseString    String localizedStandardRangeOfString   etc

User · Answer

The swift string class does not provide the ability to get a character at a specific index because of its native support for UTF characters  The variable length of a UTF character in memory makes jumping directly to a character impossible  That means you have to manually loop over the string each time   You can extend String to provide a method that will loop through the characters until your desired index  extension String       func characterAtIndex index  Int  - gt  Character            var cur   0         for char in self               if cur    index                   return char                           cur                     return nil          myString characterAtIndex 0

User · Answer

Swift3 You can use subscript syntax to access the Character at a particular String index  let greeting    quot Guten Tag  quot  let index   greeting index greeting startIndex  offsetBy  7  greeting index     a  Visit https   developer apple com library content documentation Swift Conceptual Swift Programming Language StringsAndCharacters html or we can do a String Extension in Swift 4 extension String       func getCharAtIndex   index  Int  - gt  Character           return self self index self startIndex  offsetBy  index            USAGE  let foo    quot ABC123 quot  foo getCharAtIndex 2    C

[swift] Get nth character of a string in Swift programming language

Examples related to swift

Examples related to string

Examples related to collections

Examples related to character