Inputting a value with 2 spaces and a string would enable the button " test"
but my code already detects " " whitespaces where the button is disabled but adding additional string on the whitespace enables the button
func validateAccountName(with accountName: String) -> Bool {
let regex = "[^A-Za-zA-O-o-y]"
let accountName = accountName.replacingOccurrences(of: " ", with: "")
return accountName.isEmpty == false && accountName.range(of: regex, options: .regularExpression) == nil
}
func edited() {
// check user input and allow update button to be enabled
guard let inputText = textField.text, let viewModel = viewModel else {
return
}
if !inputText.isEmpty
&& inputText != viewModel.accountName
&& viewModel.validateAccountName(with: inputText) {
self.navigationItem.rightBarButtonItem?.isEnabled = true
} else {
self.navigationItem.rightBarButtonItem?.isEnabled = false
}
}
Well what do you want to achieve?
If the goal is to reject everything that has any whitespaces you can use:
accountName.rangeOfCharacter(from: .whitespaces) == nil
But your regex already checks this as only Characters A-Z, a-z, A-O, - and o-y are allowed.
Maybe this is already what you want?
func validateAccountName(with accountName: String) -> Bool {
let regex = "[^A-Za-z]"
return accountName.range(of: regex, options: .regularExpression) == nil
}
The following will compare the first element's id with compr's id, and return true if matched.
I am confused with {} of .first { } != nil syntax. How does the longer form of this pattern condense to to the following:
private(set) var arr : [Arrs] = []
func isPresent(for compr: Compr) -> Bool {
Arrs.first { comp.id == $0.id } != nil
}
First, change the line to the following so it compiles:
arr.first { compr.id == $0.id } != nil
This is just using trailing closure syntax for the first(where:) method. It can also be written as:
arr.first(where: { compr.id == $0.id }) != nil
But a better way would be to do the following:
arr.contains { compr.id == $0.id }
When I run this code, I can only insert the "." once. If it is already in one of the text fields I can't use another "." in another text field, this is the same with the character count. If 8 characters are entered in one text field no characters can be entered in any of the other text fields.
func textField(_ textField: UITextField, shouldChangeCharactersIn range:NSRange, replacementString string: String) -> Bool {
// cost of materials
if (costOfMaterialsTXT.text?.contains("."))! && string == "." {
return false
}
// tech hours
if (techHoursTXT.text?.contains("."))! && string == "." {
return false
}
// helper hours
if (helperHoursTXT.text?.contains("."))! && string == "." {
return false
}
//Prevent "0" characters as the first characters
// cost of materials
if (costOfMaterialsTXT.text == "0" && string.isEmpty) {
return true
} else if (costOfMaterialsTXT.text == "0" && string != ".") {
return false
}
// tech hours
if (techHoursTXT.text == "0" && string.isEmpty) {
return true
} else if (techHoursTXT.text == "0" && string != ".") {
return false
}
// helper hours
if (helperHoursTXT.text == "0" && string.isEmpty) {
return true
} else if (helperHoursTXT.text == "0" && string != ".") {
return false
}
//Limit the character count to 8
// cost of materials
if ((costOfMaterialsTXT.text!) + string).count > 8 {
return false
}
// tech hours
if ((techHoursTXT.text!) + string).count > 8 {
return false
}
// helper hours
if ((helperHoursTXT.text!) + string).count > 8 {
return false
}
// Only Numbers And Decimal-Point Allowed
let allowedCharacters = "0123456789."
let allowedCharacterSet = CharacterSet(charactersIn: allowedCharacters)
let typedCharactersSet = CharacterSet(charactersIn: string)
return allowedCharacterSet.isSuperset(of: typedCharactersSet)
}
func textField(_ textField: UITextField, shouldChangeCharactersIn range:NSRange, replacementString string: String) -> Bool {
guard [costOfMaterialsTXT, techHoursTXT, helperHoursTXT].contains(textField) else {
return true //It's another textfield, is it even possible? Do you have more textField?
}
if (textField.text?.contains("."))! && string == "." {
return false
}
//Prevent "0" characters as the first characters
if (textField.text == "0" && string.isEmpty) {
return true
} else if (textField.text == "0" && string != ".") {
return false
}
//Limit the character count to 8
if ((textField.text!) + string).count > 8 {
return false
}
let allowedCharacters = "0123456789."
let allowedCharacterSet = CharacterSet(charactersIn: allowedCharacters)
let typedCharactersSet = CharacterSet(charactersIn: string)
return allowedCharacterSet.isSuperset(of: typedCharactersSet)
}
Here's the minima factorization.
You check at start if it's one of your UITextField with that behavior. Read the textField parameter.
You do the SAME behavior for each UITextField, so you shouldn't care about costOfMaterialsTXT, techHoursTXT, nor helperHoursTXT, it's any of these UITextField.
Now, about the code in itself...
You can remove the guard at the beginning if you only have those 3.
You should unwrap correctly here textField.text?.contains("."))! and textField.text!. What if string is "./.." (from a copy/paste) for instance?
I am trying to check value which I am receiving from the server, if a string is empty I am using the following condition.
var line2Cvar = permanentCAddVarDictionary?["line2"] as! String
if line2Cvar.isEmpty {
line2Cvar = "---"
}
self.permanentCAddDic.setValue(line2Cvar, forKey: "line2Cvar")
if a string is null I am using the following condition.
var line2Cvar = permanentCAddVarDictionary?["line2"]
if line2Cvar is NSNull {
line2Cvar = "----"
}
self.emergencyContactDic.setValue(line2Cvar, forKey: "line2Cvar")
but in my case sometimes I am getting empty and sometimes I am getting a null value. how check string is empty or null directly.
When checking for a string in a dictionary, you have 4 possible states:
the string is present, and non-empty
the string is present, but empty
the key is in the dictionary, but the value isn't a string
the key is absent from the dictionary
You have to check each case individually.
let possibleString = dict[key]
if let string = possibleString as? String {
if string.isEmpty {
// deal with empty case
} else {
// deal with non-empty case
}
} else if possibleString == nil {
// deal with key not-present case
} else {
// deal with value-not-string case
}
You can combine some checks and eliminate others, depending on the particular logic you require. For example, if you want to treat not-present and not-a-string the same way, you can eliminate the nil check, and just fall-through to the final else.
extension String {
var isEmptyNull:Bool {
let string = self.trimmingCharacters(in: CharacterSet.whitespaces)
if string == "" || string.lowercased() == "null" {
return true
}else {
return false
}
}
}
You can check here
let stringvalue = ""
if stringvalue.isEmptyNull {
print("string value is empty or null")
}else {
print(stringvalue)
}
output
string value is empty or null
I like many of the features in Swift, but using manipulating strings are still a big pain in the ass.
func checkPalindrome(word: String) -> Bool {
print(word)
if word == "" {
return true
} else {
if word.characters.first == word.characters.last {
return checkPalindrome(word.substringWithRange(word.startIndex.successor() ..< word.endIndex.predecessor()))
} else {
return false
}
}
}
This code fails miserably whenever the string's length is an odd number. Of course I could make it so the first line of the block would be if word.characters.count < 2, but is there a way in Swift to get substrings and check easily?
Update
I like many of the suggestions, but I guess the original question could be misleading a little, since it's a question about String more than getting the right results for the function.
For instance, in Python, checkPalindrome(word[1:-1]) would work fine for the recursive definition, whereas Swift code is much less graceful since it needs other bells and whistles.
return word == String(word.reversed())
func isPalindrome(myString:String) -> Bool {
let reverseString = String(myString.characters.reversed())
if(myString != "" && myString == reverseString) {
return true
} else {
return false
}
}
print(isPalindrome("madam"))
I have used the below extension to find whether the number is Palindrome or Not.
extension String {
var isPalindrome: Bool {
return self == String(self.reversed())
}
}
Sometimes having a front end for a recursion can simplify life. I sometimes do this when the arguments which are most convenient to use are not what I want in the user interface.
Would the following meet your needs?
func checkPalindrome(str: String) -> Bool {
func recursiveTest(var charSet: String.CharacterView) -> Bool {
if charSet.count < 2 {
return true
} else {
if charSet.popFirst() != charSet.popLast() {
return false
} else {
return recursiveTest(charSet)
}
}
}
return recursiveTest(str.characters)
}
just add on more condition in if
func checkPalindrome(word: String) -> Bool {
print(word)
if (word == "" || word.characters.count == 1){
return true
}
else {
if word.characters.first == word.characters.last {
return checkPalindrome(word.substringWithRange(word.startIndex.successor() ..< word.endIndex.predecessor()))
} else {
return false
}
}
}
extension StringProtocol where Self: RangeReplaceableCollection {
var letters: Self { filter(\.isLetter) }
var isPalindrome: Bool {
let letters = self.letters
return String(letters.reversed()).caseInsensitiveCompare(letters) == .orderedSame
}
}
"Dammit I'm Mad".isPalindrome // true
"Socorram-me subi no onibus em marrocos".isPalindrome // true
You can also break your string into an array of characters and iterate through them until its half comparing one by one with its counterpart:
func checkPalindrome(_ word: String) -> Bool {
let chars = Array(word.letters.lowercased())
for index in 0..<chars.count/2 {
if chars[index] != chars[chars.count - 1 - index] {
return false
}
}
return true
}
And the recursive version fixing the range issue where can't form a range with endIndex < startIndex:
func checkPalindrome<T: StringProtocol>(_ word: T) -> Bool {
let word = word.lowercased()
.components(separatedBy: .punctuationCharacters).joined()
.components(separatedBy: .whitespacesAndNewlines).joined()
if word == "" || word.count == 1 {
return true
} else {
if word.first == word.last {
let start = word.index(word.startIndex,offsetBy: 1, limitedBy: word.endIndex) ?? word.startIndex
let end = word.index(word.endIndex,offsetBy: -1, limitedBy: word.startIndex) ?? word.endIndex
return checkPalindrome(word[start..<end])
} else {
return false
}
}
}
checkPalindrome("Dammit I'm Mad")
I think if you make an extension to String like this one then it will make your life easier:
extension String {
var length: Int { return characters.count }
subscript(index: Int) -> Character {
return self[startIndex.advancedBy(index)]
}
subscript(range: Range<Int>) -> String {
return self[Range<Index>(start: startIndex.advancedBy(range.startIndex), end: startIndex.advancedBy(range.endIndex))]
}
}
With it in place, you can change your function to this:
func checkPalindrome(word: String) -> Bool {
if word.length < 2 {
return true
}
if word.characters.first != word.characters.last {
return false
}
return checkPalindrome(word[1..<word.length - 1])
}
Quick test:
print(checkPalindrome("aba")) // Prints "true"
print(checkPalindrome("abc")) // Prints "false"
extension String {
func trimmingFirstAndLastCharacters() -> String {
guard let startIndex = index(self.startIndex, offsetBy: 1, limitedBy: self.endIndex) else {
return self
}
guard let endIndex = index(self.endIndex, offsetBy: -1, limitedBy: self.startIndex) else {
return self
}
guard endIndex >= startIndex else {
return self
}
return String(self[startIndex..<endIndex])
}
var isPalindrome: Bool {
guard count > 1 else {
return true
}
return first == last && trimmingFirstAndLastCharacters().isPalindrome
}
}
We first declare a function that removes first and last characters from a string.
Next we declare a computer property which will contain the actual recursive code that checks if a string is palindrome.
If string's size is less than or equal 1 we immediately return true (strings composed by one character like "a" or the empty string "" are considered palindrome), otherwise we check if first and last characters of the string are the same and we recursively call isPalindrome on the current string deprived of the first and last characters.
Convert the string into an Array. When the loop is executed get the first index and compare with the last index.
func palindrome(string: String)-> Bool{
let char = Array(string)
for i in 0..<char.count / 2 {
if char[i] != char[char.count - 1 - i] {
return false
}
}
return true
}
This solution is not recursive, but it is a O(n) pure index based solution without filtering anything and without creating new objects. Non-letter characters are ignored as well.
It uses two indexes and walks outside in from both sides.
I admit that the extension type and property name is stolen from Leo, I apologize. 😉
extension StringProtocol where Self: RangeReplaceableCollection {
var isPalindrome : Bool {
if isEmpty { return false }
if index(after: startIndex) == endIndex { return true }
var forward = startIndex
var backward = endIndex
while forward < backward {
repeat { formIndex(before: &backward) } while !self[backward].isLetter
if self[forward].lowercased() != self[backward].lowercased() { return false }
repeat { formIndex(after: &forward) } while !self[forward].isLetter
}
return true
}
}
Wasn't really thinking of this, but I think I came up with a pretty cool extension, and thought I'd share.
extension String {
var subString: (Int?) -> (Int?) -> String {
return { (start) in
{ (end) in
let startIndex = start ?? 0 < 0 ? self.endIndex.advancedBy(start!) : self.startIndex.advancedBy(start ?? 0)
let endIndex = end ?? self.characters.count < 0 ? self.endIndex.advancedBy(end!) : self.startIndex.advancedBy(end ?? self.characters.count)
return startIndex > endIndex ? "" : self.substringWithRange(startIndex ..< endIndex)
}
}
}
}
let test = ["Eye", "Pop", "Noon", "Level", "Radar", "Kayak", "Rotator", "Redivider", "Detartrated", "Tattarrattat", "Aibohphobia", "Eve", "Bob", "Otto", "Anna", "Hannah", "Evil olive", "Mirror rim", "Stack cats", "Doom mood", "Rise to vote sir", "Step on no pets", "Never odd or even", "A nut for a jar of tuna", "No lemon, no melon", "Some men interpret nine memos", "Gateman sees name, garageman sees nametag"]
func checkPalindrome(word: String) -> Bool {
if word.isEmpty { return true }
else {
if word.subString(nil)(1) == word.subString(-1)(nil) {
return checkPalindrome(word.subString(1)(-1))
} else {
return false
}
}
}
for item in test.map({ $0.lowercaseString.stringByReplacingOccurrencesOfString(",", withString: "").stringByReplacingOccurrencesOfString(" ", withString: "") }) {
if !checkPalindrome(item) {
print(item)
}
}
A simple solution in Swift:
func isPalindrome(word: String) -> Bool {
// If no string found, return false
if word.count == 0 { return false }
var index = 0
var characters = Array(word) // make array of characters
while index < characters.count / 2 { // repeat loop only for half length of given string
if characters[index] != characters[(characters.count - 1) - index] {
return false
}
index += 1
}
return true
}
func checkPalindrome(_ inputString: String) -> Bool {
if inputString.count % 2 == 0 {
return false
} else if inputString.count == 1 {
return true
} else {
var stringCount = inputString.count
while stringCount != 1 {
if inputString.first == inputString.last {
stringCount -= 2
} else {
continue
}
}
if stringCount == 1 {
return true
} else {
return false
}
}
}