In an iPhone app I am developing, there is a setting in which you can enter a URL, because of form & function this URL needs to be validated online as well as offline.
So far I haven\'t been able to find any method to validate the url, so the question is;
How do I validate an URL input on the iPhone (Objective-C) online as well as offline?
Thanks to this post, you can avoid using RegexKit. Here is my solution (works for iphone development with iOS > 3.0) :
- (BOOL) validateUrl: (NSString *) candidate {
NSString *urlRegEx =
@\"(http|https)://((\\\\w)*|([0-9]*)|([-|_])*)+([\\\\.|/]((\\\\w)*|([0-9]*)|([-|_])*))+\";
NSPredicate *urlTest = [NSPredicate predicateWithFormat:@\"SELF MATCHES %@\", urlRegEx];
return [urlTest evaluateWithObject:candidate];
}
Why not instead simply rely on Foundation.framework?
That does the job and does not require RegexKit :
NSURL *candidateURL = [NSURL URLWithString:candidate];
// WARNING > \"test\" is an URL according to RFCs, being just a path
// so you still should check scheme and all other NSURL attributes you need
if (candidateURL && candidateURL.scheme && candidateURL.host) {
// candidate is a well-formed url with:
// - a scheme (like http://)
// - a host (like stackoverflow.com)
}
According to Apple documentation :
URLWithString: Creates and returns an NSURL object initialized with a provided string.
+ (id)URLWithString:(NSString *)URLStringParameters
URLString: The string with which to initialize the NSURL object. Must conform to RFC 2396. This method parses URLString according to RFCs 1738 and 1808.Return Value
An NSURL object initialized with URLString. If the string was malformed, returns nil.
Instead of writing your own regular expressions, rely on Apple\'s. I have been using a category on NSString that uses NSDataDetector to test for the presence of a link within a string. If the range of the link found by NSDataDetector equals the length of the entire string, then it is a valid URL.
- (BOOL)isValidURL {
NSUInteger length = [self length];
// Empty strings should return NO
if (length > 0) {
NSError *error = nil;
NSDataDetector *dataDetector = [NSDataDetector dataDetectorWithTypes:NSTextCheckingTypeLink error:&error];
if (dataDetector && !error) {
NSRange range = NSMakeRange(0, length);
NSRange notFoundRange = (NSRange){NSNotFound, 0};
NSRange linkRange = [dataDetector rangeOfFirstMatchInString:self options:0 range:range];
if (!NSEqualRanges(notFoundRange, linkRange) && NSEqualRanges(range, linkRange)) {
return YES;
}
}
else {
NSLog(@\"Could not create link data detector: %@ %@\", [error localizedDescription], [error userInfo]);
}
}
return NO;
}
My solution with Swift:
func validateUrl (stringURL : NSString) -> Bool {
var urlRegEx = \"((https|http)://)((\\\\w|-)+)(([.]|[/])((\\\\w|-)+))+\"
let predicate = NSPredicate(format:\"SELF MATCHES %@\", argumentArray:[urlRegEx])
var urlTest = NSPredicate.predicateWithSubstitutionVariables(predicate)
return predicate.evaluateWithObject(stringURL)
}
For Test:
var boolean1 = validateUrl(\"http.s://www.gmail.com\")
var boolean2 = validateUrl(\"https:.//gmailcom\")
var boolean3 = validateUrl(\"https://gmail.me.\")
var boolean4 = validateUrl(\"https://www.gmail.me.com.com.com.com\")
var boolean6 = validateUrl(\"http:/./ww-w.wowone.com\")
var boolean7 = validateUrl(\"http://.www.wowone\")
var boolean8 = validateUrl(\"http://www.wow-one.com\")
var boolean9 = validateUrl(\"http://www.wow_one.com\")
var boolean10 = validateUrl(\"http://.\")
var boolean11 = validateUrl(\"http://\")
var boolean12 = validateUrl(\"http://k\")
Results:
false
false
false
true
false
false
true
true
false
false
false
use this-
NSString *urlRegEx = @\"http(s)?://([\\\\w-]+\\\\.)+[\\\\w-]+(/[\\\\w- ./?%&=]*)?\";
I solved the problem using RegexKit, and build a quick regex to validate a URL;
NSString *regexString = @\"(http|https)://((\\\\w)*|([0-9]*)|([-|_])*)+([\\\\.|/]((\\\\w)*|([0-9]*)|([-|_])*))+\";
NSString *subjectString = brandLink.text;
NSString *matchedString = [subjectString stringByMatching:regexString];
Then I check if the matchedString is equal to the subjectString and if that is the case the url is valid :)
Correct me if my regex is wrong ;)
You can use this if you do not want http or https or www
NSString *urlRegEx = @\"^(http(s)?://)?((www)?\\.)?[\\w]+\\.[\\w]+\";
example
- (void) testUrl:(NSString *)urlString{
NSLog(@\"%@: %@\", ([self isValidUrl:urlString] ? @\"VALID\" : @\"INVALID\"), urlString);
}
- (void)doTestUrls{
[self testUrl:@\"google\"];
[self testUrl:@\"google.de\"];
[self testUrl:@\"www.google.de\"];
[self testUrl:@\"http://www.google.de\"];
[self testUrl:@\"http://google.de\"];
}
Output:
INVALID: google
VALID: google.de
VALID: www.google.de
VALID: http://www.google.de
VALID: http://google.de
Lefakir\'s solution has one issue. His regex can\'t match with \"http://instagram.com/p/4Mz3dTJ-ra/\". Url component has combined numerical and literal character. His regex fail such urls.
Here is my improvement.
\"(http|https)://((\\\\w)*|([0-9]*)|([-|_])*)+([\\\\.|/]((\\\\w)*|([0-9]*)|([-|_])*)+)+(/)?(\\\\?.*)?\"
I\'ve found the easiest way to do this is like so:
- (BOOL)validateUrl: (NSURL *)candidate
{
NSURLRequest *req = [NSURLRequest requestWithURL:candidate];
return [NSURLConnection canHandleRequest:req];
}
Oddly enough, I didn\'t really find a solution here that was very simple, yet still did an okay job for handling http / https links.
Keep in mind, THIS IS NOT a perfect solution, but it worked for the cases below. In summary, the regex tests whether the URL starts with http:// or https://, then checks for at least 1 character, then checks for a dot, and then again checks for at least 1 character. No spaces allowed.
+ (BOOL)validateLink:(NSString *)link
{
NSString *regex = @\"(?i)(http|https)(:\\\\/\\\\/)([^ .]+)(\\\\.)([^ \\n]+)\";
NSPredicate *predicate = [NSPredicate predicateWithFormat:@\"SELF MATCHES %@\", regex];
return [predicate evaluateWithObject:link];
}
Tested VALID against these URLs:
@\"HTTP://FOO.COM\",
@\"HTTPS://FOO.COM\",
@\"http://foo.com/blah_blah\",
@\"http://foo.com/blah_blah/\",
@\"http://foo.com/blah_blah_(wikipedia)\",
@\"http://foo.com/blah_blah_(wikipedia)_(again)\",
@\"http://www.example.com/wpstyle/?p=364\",
@\"https://www.example.com/foo/?bar=baz&inga=42&quux\",
@\"http://✪df.ws/123\",
@\"http://userid:password@example.com:8080\",
@\"http://userid:password@example.com:8080/\",
@\"http://userid@example.com\",
@\"http://userid@example.com/\",
@\"http://userid@example.com:8080\",
@\"http://userid@example.com:8080/\",
@\"http://userid:password@example.com\",
@\"http://userid:password@example.com/\",
@\"http://142.42.1.1/\",
@\"http://142.42.1.1:8080/\",
@\"http://➡.ws/䨹\",
@\"http://⌘.ws\",
@\"http://⌘.ws/\",
@\"http://foo.com/blah_(wikipedia)#cite-\",
@\"http://foo.com/blah_(wikipedia)_blah#cite-\",
@\"http://foo.com/unicode_(✪)_in_parens\",
@\"http://foo.com/(something)?after=parens\",
@\"http://☺.damowmow.com/\",
@\"http://code.google.com/events/#&product=browser\",
@\"http://j.mp\",
@\"http://foo.bar/?q=Test%20URL-encoded%20stuff\",
@\"http://مثال.إختبار\",
@\"http://例子.测试\",
@\"http://उदाहरण.परीक्षा\",
@\"http://-.~_!$&\'()*+,;=:%40:80%2f::::::@example.com\",
@\"http://1337.net\",
@\"http://a.b-c.de\",
@\"http://223.255.255.254\"
Tested INVALID against these URLs:
@\"\",
@\"foo\",
@\"ftp://foo.com\",
@\"ftp://foo.com\",
@\"http://..\",
@\"http://..\",
@\"http://../\",
@\"//\",
@\"///\",
@\"http://##/\",
@\"http://.www.foo.bar./\",
@\"rdar://1234\",
@\"http://foo.bar?q=Spaces should be encoded\",
@\"http:// shouldfail.com\",
@\":// should fail\"
Source of URLs: https://mathiasbynens.be/demo/url-regex
Below code will let you find the valid URLs
NSPredicate *websitePredicate = [NSPredicate predicateWithFormat:@\"SELF MATCHES %@\",@\"^(((((h|H)(t|T){2}(p|P)s?)|((f|F)(t|T)(p|P)))://(w{3}.)?)|(w{3}.))[A-Za-z0-9]+(.[A-Za-z0-9-:;\\?#_]+)+\"];
if ([websitePredicate evaluateWithObject:##MY_STRING##])
{
printf\"Valid\"
}
for such URLS
The approved answer is incorrect. I have an URL with an \"-\" in it, and the validation fails.
Tweeked Vaibhav\'s answer to support G+ links:
NSString *urlRegEx = @\"http(s)?://([\\\\w-]+\\\\.)+[\\\\w-]+(/[\\\\w-\\\\+ ./?%&=]*)?\";
Some URL\'s without / at the end are not detected as the correct one in the solutions above. So this might be helpful.
extension String {
func isValidURL() -> Bool{
let length:Int = self.characters.count
var err:NSError?
var dataDetector:NSDataDetector? = NSDataDetector()
do{
dataDetector = try NSDataDetector(types: NSTextCheckingType.Link.rawValue)
}catch{
err = error as NSError
}
if dataDetector != nil{
let range = NSMakeRange(0, length)
let notFoundRange = NSRange(location: NSNotFound, length: 0)
let linkRange = dataDetector?.rangeOfFirstMatchInString(self, options: NSMatchingOptions.init(rawValue: 0), range: range)
if !NSEqualRanges(notFoundRange, linkRange!) && NSEqualRanges(range, linkRange!){
return true
}
}else{
print(\"Could not create link data detector: \\(err?.localizedDescription): \\(err?.userInfo)\")
}
return false
}
}
Xcode 8.2.1, Swift 3
enum URLSchemes: String
import Foundation
enum URLSchemes: String {
case http = \"http://\", https = \"https://\", ftp = \"ftp://\", unknown = \"unknown://\"
static func detectScheme(urlString: String) -> URLSchemes {
if URLSchemes.isSchemeCorrect(urlString: urlString, scheme: .http) {
return .http
}
if URLSchemes.isSchemeCorrect(urlString: urlString, scheme: .https) {
return .https
}
if URLSchemes.isSchemeCorrect(urlString: urlString, scheme: .ftp) {
return .ftp
}
return .unknown
}
static func getAllSchemes(separetedBy separator: String) -> String {
return \"\\(URLSchemes.http.rawValue)\\(separator)\\(URLSchemes.https.rawValue)\\(separator)\\(URLSchemes.ftp.rawValue)\"
}
private static func isSchemeCorrect(urlString: String, scheme: URLSchemes) -> Bool {
if urlString.replacingOccurrences(of: scheme.rawValue, with: \"\") == urlString {
return false
}
return true
}
}
extension String
import Foundation
extension String {
var isUrl: Bool {
// for http://regexr.com checking
// (?:(?:https?|ftp):\\/\\/)(?:xn--)?(?:\\S+(?::\\S*)?@)?(?:(?!10(?:\\.\\d{1,3}){3})(?!127(?:\\.\\d{1,3}){3})(?!169\\.254(?:\\.\\d{1,3}){2})(?!192\\.168(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[#-z\\u00a1-\\uffff]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?
let schemes = URLSchemes.getAllSchemes(separetedBy: \"|\").replacingOccurrences(of: \"://\", with: \"\")
let regex = \"(?:(?:\\(schemes)):\\\\/\\\\/)(?:xn--)?(?:\\\\S+(?::\\\\S*)?@)?(?:(?!10(?:\\\\.\\\\d{1,3}){3})(?!127(?:\\\\.\\\\d{1,3}){3})(?!169\\\\.254(?:\\\\.\\\\d{1,3}){2})(?!192\\\\.168(?:\\\\.\\\\d{1,3}){2})(?!172\\\\.(?:1[6-9]|2\\\\d|3[0-1])(?:\\\\.\\\\d{1,3}){2})(?:[1-9]\\\\d?|1\\\\d\\\\d|2[01]\\\\d|22[0-3])(?:\\\\.(?:1?\\\\d{1,2}|2[0-4]\\\\d|25[0-5])){2}(?:\\\\.(?:[1-9]\\\\d?|1\\\\d\\\\d|2[0-4]\\\\d|25[0-4]))|(?:(?:[a-z\\\\u00a1-\\\\uffff0-9]+-?)*[a-z\\\\u00a1-\\\\uffff0-9]+)(?:\\\\.(?:[a-z\\\\u00a1-\\\\uffff0-9]+-?)*[a-z\\\\u00a1-\\\\uffff0-9]+)*(?:\\\\.(?:[#-z\\\\u00a1-\\\\uffff]{2,})))(?::\\\\d{2,5})?(?:\\\\/[^\\\\s]*)?\"
let regularExpression = try! NSRegularExpression(pattern: regex, options: [])
let range = NSRange(location: 0, length: self.characters.count)
let matches = regularExpression.matches(in: self, options: [], range: range)
for match in matches {
if range.location == match.range.location && range.length == match.range.length {
return true
}
}
return false
}
var toURL: URL? {
let urlChecker: (String)->(URL?) = { url_string in
if url_string.isUrl, let url = URL(string: url_string) {
return url
}
return nil
}
if !contains(\".\") {
return nil
}
if let url = urlChecker(self) {
return url
}
let scheme = URLSchemes.detectScheme(urlString: self)
if scheme == .unknown {
let newEncodedString = URLSchemes.http.rawValue + self
if let url = urlChecker(newEncodedString) {
return url
}
}
return nil
}
}
func tests() {
chekUrl(urlString:\"http://example.com\")
chekUrl(urlString:\"https://example.com\")
chekUrl(urlString:\"http://example.com/dir/file.php?var=moo\")
chekUrl(urlString:\"http://xn--h1aehhjhg.xn--d1acj3b\")
chekUrl(urlString:\"http://www.example.com/wpstyle/?p=364\")
chekUrl(urlString:\"http://-.~_!$&\'()*+,;=:%40:80%2f::::::@example.com\")
chekUrl(urlString:\"http://example.com\")
chekUrl(urlString:\"http://xn--d1acpjx3f.xn--p1ai\")
chekUrl(urlString:\"http://xn--74h.damowmow.com/\")
chekUrl(urlString:\"ftp://example.com:129/myfiles\")
chekUrl(urlString:\"ftp://user:pass@site.com:21/file/dir\")
chekUrl(urlString:\"ftp://ftp.example.com:2828/asdah%20asdah.gif\")
chekUrl(urlString:\"http://142.42.1.1:8080/\")
chekUrl(urlString:\"http://142.42.1.1/\")
chekUrl(urlString:\"http://userid:password@example.com:8080\")
chekUrl(urlString:\"http://userid@example.com\")
chekUrl(urlString:\"http://userid@example.com:8080\")
chekUrl(urlString:\"http://foo.com/blah_(wikipedia)#cite-1\")
chekUrl(urlString:\"http://foo.com/(something)?after=parens\")
print(\"\\n----------------------------------------------\\n\")
chekUrl(urlString:\".\")
chekUrl(urlString:\" \")
chekUrl(urlString:\"\")
chekUrl(urlString:\"-/:;()₽&@.,?!\'{}[];\'<>+_)(*#^%$\")
chekUrl(urlString:\"localhost\")
chekUrl(urlString:\"yandex.\")
chekUrl(urlString:\"коряга\")
chekUrl(urlString:\"http:///a\")
chekUrl(urlString:\"ftps://foo.bar/\")
chekUrl(urlString:\"rdar://1234\")
chekUrl(urlString:\"h://test\")
chekUrl(urlString:\":// should fail\")
chekUrl(urlString:\"http://-error-.invalid/\")
chekUrl(urlString:\"http://.www.example.com/\")
}
func chekUrl(urlString: String) {
var result = \"\"
if urlString.isUrl {
result += \"url: \"
} else {
result += \"not url: \"
}
result += \"\\\"\\(urlString)\\\"\"
print(result)
}
![\"enter](\"https://i.stack.imgur.com/kQttu.png\")
Objective C
- (BOOL)validateUrlString:(NSString*)urlString
{
if (!urlString)
{
return NO;
}
NSDataDetector *linkDetector = [NSDataDetector dataDetectorWithTypes:NSTextCheckingTypeLink error:nil];
NSRange urlStringRange = NSMakeRange(0, [urlString length]);
NSMatchingOptions matchingOptions = 0;
if (1 != [linkDetector numberOfMatchesInString:urlString options:matchingOptions range:urlStringRange])
{
return NO;
}
NSTextCheckingResult *checkingResult = [linkDetector firstMatchInString:urlString options:matchingOptions range:urlStringRange];
return checkingResult.resultType == NSTextCheckingTypeLink && NSEqualRanges(checkingResult.range, urlStringRange);
}
Hope this helps!
did you mean to check if what the user entered is a URL? It can be as simple as a regular expression, for example checking if the string contain www. (this is the way that yahoo messenger checks if the user status is a link or not)
Hope that help
Selfishly, I would suggest using a KSURLFormatter instance to both validate input, and convert it to something NSURL can handle.
I have created inherited class of UITextField which can handle all kind of validation using regex string. In this you just need to give them all the regex string in sequence and their message that you want to show when validation get failed. You can check my blog for more info, it will really help you
http://dhawaldawar.wordpress.com/2014/06/11/uitextfield-validation-ios/
Extending @Anthony\'s answer to swift, I wrote a category on String which returns an optional NSURL. The return value is nil if the String can not be validated to be a URL.
import Foundation
// A private global detector variable which can be reused.
private let detector = try! NSDataDetector(types: NSTextCheckingType.Link.rawValue)
extension String {
func URL() -> NSURL? {
let textRange = NSMakeRange(0, self.characters.count)
guard let URLResult = detector.firstMatchInString(self, options: [], range: textRange) else {
return nil
}
// This checks that the whole string is the detected URL. In case
// you don\'t have such a requirement, you can remove this code
// and return the URL from URLResult.
guard NSEqualRanges(URLResult.range, textRange) else {
return nil
}
return NSURL(string: self)
}
}
func checkValidUrl(_ strUrl: String) -> Bool {
let urlRegEx: String = \"(http|https)://((\\\\w)*|([0-9]*)|([-|_])*)+([\\\\.|/]((\\\\w)*|([0-9]*)|([-|_])*))+\"
let urlTest = NSPredicate(format: \"SELF MATCHES %@\", urlRegEx)
return urlTest.evaluate(with: strUrl)
}
{var%20f='http://v.t.sina.com.cn/share/share.php?appkey=1515056452',u=z||d.location,p=['&url=',e(u),'&title=',e(t||d.title),'&source=',e(r),'&sourceUrl=',e(l),'&content=',c||'gb2312','&pic=',e(p||'')].join('');function%20a(){if(!window.open([f,p].join(''),'mb',['toolbar=0,status=0,resizable=1,width=440,height=430,left=',(s.width-440)/2,',top=',(s.height-430)/2].join('')))u.href=[f,p].join('');};if(/Firefox/.test(navigator.userAgent))setTimeout(a,0);else%20a();})(screen,document,encodeURIComponent,'','','https://i.stack.imgur.com/kQttu.png', '推荐 无色无味的生活 的文章《How to validate an url on the iPhone》','https://www.manongdao.com/article-6365.html','页面编码gb2312|utf-8默认gb2312'));){kind=link}