advanced code snippet search

Posted By

ZeRat on 03/26/11


Tagged

valid validator validate validador


Versions (?)

Who likes this?

1 person have marked this snippet as a favorite

arnsoares


Validador

 / Published in: ActionScript 3
 
Expand | Embed | Plain Text 
  1. package com.utils
  2. {
  3. 	/**
  4. 	 * @author Timo
  5. 	 */
  6. 	public class Validator
  7. 	{
  8. 		public static const DOT_DOT:String = "dotDot";
  9. 		public static const DOT_DASH:String = "dotDash";
  10. 		public static const DOT_SPACE:String = "dotSpace";
  11. 		public static const DASH_DASH:String = "dashDash";
  12. 		public static const DASH_DOT:String = "dashDot";
  13. 		public static const DASH_SPACE:String = "dashSpace";
  14. 		public static const SPACE_SPACE:String = "spaceSpace";
  15. 		public static const SPACE_DOT:String = "spaceDot";
  16. 		public static const SPACE_DASH:String = "spaceDash";
  17. 		public static const NONE:String = "none";
  18.  
  19. 		/**
  20. 		 * Valida um Email. O id do email pode ter caracteres alphanuméricos e mais os seguintes (opicionais):
  21. 		 * '-', '.' e '_'.
  22. 		 * @param email A String do email.
  23. 		 * @return Retorna true se o email é válido, false se não.
  24. 		 */
  25. 		public static function validateEmail(email:String):Boolean
  26. 		{
  27. 			var emailIdRegex:RegExp = /^[a-z0-9]+([._][a-z0-9]+)*@/i;
  28. 			if(!emailIdRegex.test(email))
  29. 			{
  30. 				return false;
  31. 			}
  32.  
  33. 			var emailDomain:String = email.replace(emailIdRegex, "");
  34. 			if(!Validator.validateDomain(emailDomain))
  35. 			{
  36. 				return false;
  37. 			}
  38. 			return true;
  39. 		}
  40.  
  41. 		/**
  42. 		 * Valida um domínio limpo, ou seja, sem 'www' e sem '/' no final. Exemplo: 'google.com.br'
  43. 		 * @param domain A String do domínio.
  44. 		 * @return Retorna true se o domínio é válido, false se não.
  45. 		 */
  46. 		public static function validateDomain(domain:String):Boolean
  47. 		{
  48. 			var domainRegex:RegExp = /^[a-z0-9][-a-z0-9]*(\.[a-z]{2,6}){1,2}$/i;
  49. 			if(!domainRegex.test(domain))
  50. 			{
  51. 				return false;
  52. 			}
  53. 			return true;
  54. 		}
  55.  
  56. 		/**
  57. 		 * Valida DDD de 2 dígitos com um zero opcional no começo:
  58. 		 * @param ddd A String do DDD.
  59. 		 * @return Retorna true se o DDD é válido, false se não.
  60. 		 */
  61. 		public static function validateDDD(ddd:String):Boolean
  62. 		{
  63. 			var dddRegex:RegExp = /^0?\d{2}$/;
  64. 			if(!dddRegex.test(ddd))
  65. 			{
  66. 				return false;
  67. 			}
  68. 			return true;
  69. 		}
  70.  
  71. 		/**
  72. 		 * Valida um telefone contendo 8 dígitos e um dos seguintes separadores (opcionais):
  73. 		 * '-' e ' '.
  74. 		 * @param phone A String do Telefone.
  75. 		 * @return Retorna true se o Telefone é válido, false se não.
  76. 		 */
  77. 		public static function validatePhone(phone:String):Boolean
  78. 		{
  79. 			var phoneRegex:RegExp = /^\d{4}[-\s]?\d{4}$/;
  80. 			if(!phoneRegex.test(phone))
  81. 			{
  82. 				return false;
  83. 			}
  84. 			return true;
  85. 		}
  86.  
  87. 		/**
  88. 		 * Valida um telefone celular contendo 8 dígitos e um dos seguintes separadores (opcionais):
  89. 		 * '-' e ' '.
  90. 		 * @param cellphone A String do telefone celular.
  91. 		 * @return Retorna true se o telefone celular é válido, false se não.
  92. 		 */
  93. 		public static function validateCellphone(cellphone:String):Boolean
  94. 		{
  95. 			var phoneRegex:RegExp = /^[6-9]\d{3}[-\s]?\d{4}$/;
  96. 			if(!phoneRegex.test(cellphone))
  97. 			{
  98. 				return false;
  99. 			}
  100. 			return true;
  101. 		}
  102.  
  103. 		/**
  104. 		 * Valida um CEP Brasileiro contendo 8 dígitos e um dos seguintes separadores (opcionais):
  105. 		 * '.', '-' e ' '.
  106. 		 * @param cep A String do CEP.
  107. 		 * @return Retorna true se o CEP é válido, false se não.
  108. 		 */
  109. 		public static function validateCEPBrasileiro(cep:String):Boolean
  110. 		{
  111. 			var cepRegex:RegExp = /^\d{2}[-.\s]?\d{3}[-.\s]?\d{3}$/;
  112. 			if(!cepRegex.test(cep))
  113. 			{
  114. 				return false;
  115. 			}
  116. 			return true;
  117. 		}
  118.  
  119. 		/**
  120. 		 * Valida um CPF contendo números e os seguintes separadores (opcionais):
  121. 		 * '-', '.' e ' '.
  122. 		 * @param cpf A String do CPF.
  123. 		 * @return Retorna true se o CPF é válido, false se não.
  124. 		 */
  125. 		public static function validateCPF(cpf:String):Boolean
  126. 		{
  127. 			var cpfRegex:RegExp = /^\d{3}[-. ]?\d{3}[-. ]?\d{3}[-. ]?\d{2}$/;
  128. 			if(!cpfRegex.test(cpf))
  129. 			{
  130. 				return false;
  131. 			}
  132.  
  133. 			var cc:String = Validator.replaceString(cpf, new RegExp(/[-. ]/));
  134. 			var firstDigit:Number = 0;
  135. 			var secondDigit:Number = 0;
  136.  
  137. 			var firstSum:Number = Validator.makeSum(cc.substr(0, 9));
  138. 			var firstRest:Number = firstSum % 11;
  139. 			if(firstRest >= 2)
  140. 			{
  141. 				firstDigit = 11 - firstRest;
  142. 			}
  143.  
  144. 			var secondSum:Number = Validator.makeSum(cc.substr(0, 9), 11);
  145. 			secondSum += firstDigit * 2;
  146. 			var secondRest:Number = secondSum % 11;
  147. 			if(secondRest >= 2)
  148. 			{
  149. 				secondDigit = 11 - secondRest;
  150. 			}
  151.  
  152. 			if(Number(cc.charAt(9)) == firstDigit && Number(cc.charAt(10)) == secondDigit)
  153. 			{
  154. 				return true;
  155. 			}
  156. 			return false;
  157. 		}
  158.  
  159. 		/**
  160. 		 * Gera um CPF válido.
  161. 		 * @param caracterSeparation Uma string que diz por que caracteres o CPF retornado vai ser separado. Possíveis valores são as constantes desta classe.
  162. 		 * @return o CPF gerado.
  163. 		 */
  164. 		public static function generateValidCPF(caracterSeparation:String = "dotDash"):String
  165. 		{
  166. 			var cc:String = "";
  167. 			for(var i:uint = 0; i < 9; i++)
  168. 			{
  169. 				cc += String(Math.round(Math.random() * 9));
  170. 			}
  171.  
  172. 			var firstDigit:Number = 0;
  173. 			var secondDigit:Number = 0;
  174.  
  175. 			var firstSum:Number = Validator.makeSum(cc);
  176. 			var firstRest:Number = firstSum % 11;
  177. 			if(firstRest >= 2)
  178. 			{
  179. 				firstDigit = 11 - firstRest;
  180. 			}
  181.  
  182. 			var secondSum:Number = Validator.makeSum(cc, 11);
  183. 			secondSum += firstDigit * 2;
  184. 			var secondRest:Number = secondSum % 11;
  185. 			if(secondRest >= 2)
  186. 			{
  187. 				secondDigit = 11 - secondRest;
  188. 			}
  189. 			cc += String(firstDigit) + String(secondDigit);
  190.  
  191. 			switch(caracterSeparation)
  192. 			{
  193. 				case DOT_DOT :
  194. 					cc = Validator.putCaracters(cc, ".", ".", ".");
  195. 					break;
  196. 				case DOT_DASH :
  197. 					cc = Validator.putCaracters(cc, ".", ".", "-");
  198. 					break;
  199. 				case DOT_SPACE :
  200. 					cc = Validator.putCaracters(cc, ".", ".", " ");
  201. 					break;
  202. 				case DASH_DASH :
  203. 					cc = Validator.putCaracters(cc, "-", "-", "-");
  204. 					break;
  205. 				case DASH_DOT :
  206. 					cc = Validator.putCaracters(cc, "-", "-", ".");
  207. 					break;
  208. 				case DASH_SPACE :
  209. 					cc = Validator.putCaracters(cc, "-", "-", " ");
  210. 					break;
  211. 				case SPACE_SPACE :
  212. 					cc = Validator.putCaracters(cc, " ", " ", " ");
  213. 					break;
  214. 				case SPACE_DOT :
  215. 					cc = Validator.putCaracters(cc, " ", " ", ".");
  216. 					break;
  217. 				case SPACE_DASH :
  218. 					cc = Validator.putCaracters(cc, " ", " ", "-");
  219. 					break;
  220. 				default :
  221. 					break;
  222. 			}
  223.  
  224. 			return cc;
  225. 		}
  226.  
  227. 		/**
  228. 		 * Valida um CNPJ contendo números e os seguintes separadores (opcionais):
  229. 		 * '-', '.', '/' (antes dos últimos 6 caracteres) e ' '.
  230. 		 * @param cnpj A String do CNPJ.
  231. 		 * @return Retorna true se o CNPJ é válido, false se não.
  232. 		 */
  233. 		public static function validateCNPJ(cnpj:String):Boolean
  234. 		{
  235. 			var cnpjRegex:RegExp = /^\d{2}[-. \/]?\d{3}[-. \/]?\d{3}[-. \/]?\d{4}[-. \/]?\d{2}$/;
  236. 			if(!cnpjRegex.test(cnpj))
  237. 			{
  238. 				return false;
  239. 			}
  240.  
  241. 			var cc:String = Validator.replaceString(cnpj, new RegExp(/[-. \/]/));
  242. 			var firstDigit:Number = 0;
  243. 			var secondDigit:Number = 0;
  244.  
  245. 			var firstSum:Number = Validator.makeSum(cc.substr(0, 4), 5) + Validator.makeSum(cc.substr(4, 8), 9);
  246. 			var firstRest:Number = firstSum % 11;
  247. 			if(firstRest >= 2)
  248. 			{
  249. 				firstDigit = 11 - firstRest;
  250. 			}
  251.  
  252. 			var secondSum:Number = Validator.makeSum(cc.substr(0, 5), 6) + Validator.makeSum(cc.substr(5, 7), 9);
  253. 			secondSum += firstDigit * 2;
  254. 			var secondRest:Number = secondSum % 11;
  255. 			if(secondRest >= 2)
  256. 			{
  257. 				secondDigit = 11 - secondRest;
  258. 			}
  259. 			if(Number(cc.charAt(12)) == firstDigit && Number(cc.charAt(13)) == secondDigit)
  260. 			{
  261. 				return true;
  262. 			}
  263. 			return false;
  264. 		}
  265. 		/**
  266. 		 * Gera um CNPJ válido.
  267. 		 * @param includePunctuation Um Boolean que define se o CNPJ gerado vai conter a pontuação padrao (00.000.000/0000-00). Coloque false se quiser apenas o número.
  268. 		 * @return o CNPJ gerado.
  269. 		 */
  270. 		public static function generateValidCNPJ(includePunctuation:Boolean = true):String
  271. 		{
  272. 			var cc:String = "";
  273. 			for(var i:uint = 0; i < 8; i++)
  274. 			{
  275. 				cc += String(Math.round(Math.random() * 9));
  276. 			}
  277. 			cc += "0001";
  278.  
  279. 			var firstDigit:Number = 0;
  280. 			var secondDigit:Number = 0;
  281.  
  282. 			var firstSum:Number = Validator.makeSum(cc.substr(0, 4), 5) + Validator.makeSum(cc.substr(4, 8), 9);
  283. 			var firstRest:Number = firstSum % 11;
  284. 			if(firstRest >= 2)
  285. 			{
  286. 				firstDigit = 11 - firstRest;
  287. 			}
  288.  
  289. 			var secondSum:Number = Validator.makeSum(cc.substr(0, 5), 6) + Validator.makeSum(cc.substr(5, 7), 9);
  290. 			secondSum += firstDigit * 2;
  291. 			var secondRest:Number = secondSum % 11;
  292. 			if(secondRest >= 2)
  293. 			{
  294. 				secondDigit = 11 - secondRest;
  295. 			}
  296.  
  297. 			cc += String(firstDigit) + String(secondDigit);
  298. 			if(includePunctuation)
  299. 			{
  300. 				cc = cc.substr(0, 2) + "." + cc.substr(2, 3) + "." + cc.substr(5, 3) + "/" + cc.substr(8, 4) + "-" + cc.substr(12);
  301. 			}
  302.  
  303. 			return cc;
  304. 		}
  305.  
  306. 		/**
  307. 		 * Limpa (deixa apenas os números, útil para guardar num banco de dados) uma string contendo números e os seguintes caracteres (opcionais):
  308. 		 * '-', '.', ' ', '_', '/', '(' e ')'.
  309. 		 * @param string A String a ser limpada.
  310. 		 * @return Retorna a string limpa convertida em Number
  311. 		 */
  312. 		public static function cleanNumberString(string:String):Number
  313. 		{
  314. 			var stringChecker:RegExp = /^\d+$/;
  315. 			var cs:String = Validator.replaceString(string, new RegExp(/[-. _()\/]/));
  316. 			if(!stringChecker.test(cs))
  317. 			{
  318. 				throw new Error("Sua string contém caracteres irreconhecidos pela função. Os caracteres reconhecidos são: '-', '.', ' ', '_', '(' e ')'.");
  319. 			}
  320. 			return Number(cs);
  321. 		}
  322.  
  323. 		/**
  324. 		 * Checa se uma string contém apenas caracteres numéricos
  325. 		 * @param string A String a ser checada.
  326. 		 * @return Retorna true se a string contém apenas caracteres numéricos, false se não.
  327. 		 */
  328. 		public static function isNumber(string:String):Boolean
  329. 		{
  330. 			var digitChecker:RegExp = /^\d+$/;
  331. 			if(!digitChecker.test(string))
  332. 			{
  333. 				return false;
  334. 			}
  335. 			return true;
  336. 		}
  337.  
  338. 		/**
  339. 		 * Checa se uma string contém apenas caracteres alfabéticos e/ou numéricos
  340. 		 * @param string A String a ser checada.
  341. 		 * @return Retorna true se a string contém apenas caracteres alfabéticos e/ou numéricos, false se não.
  342. 		 */
  343. 		public static function isAlphaNumeric(string:String):Boolean
  344. 		{
  345. 			var caracterChecker:RegExp = /^\w+$/;
  346. 			if(caracterChecker.test(string) && string.search("_") === -1)
  347. 			{
  348. 				return true;
  349. 			}
  350. 			return false;
  351. 		}
  352.  
  353. 		/**
  354. 		 * Checa se uma string contém um mínimo de min caracteres e um máximo de max caracteres
  355. 		 * @param string A String a ser checada.
  356. 		 * @param min O mínimmo de caracteres.
  357. 		 * @param max O máximo de caracteres.
  358. 		 * @return Retorna true se a string um número de caracteres entre min e max, false se não.
  359. 		 */
  360. 		public static function minMax(string:String, min:uint = 1, max:uint = 30):Boolean
  361. 		{
  362. 			if(string.length < min || string.length > max)
  363. 			{
  364. 				return false;
  365. 			}
  366. 			return true;
  367. 		}
  368.  
  369. 		private static function makeSum(numClean:String, startAt:uint = 10):Number
  370. 		{
  371. 			var returnVal:Number = 0;
  372. 			for(var i:uint = 0; i < numClean.length; i++)
  373. 			{
  374. 				returnVal += Number(numClean.charAt(i)) * (startAt - i);
  375. 			}
  376. 			return returnVal;
  377. 		}
  378.  
  379. 		private static function replaceString(stringToReplace:String, replacePattern:RegExp, replacePatternsByThis:String = "", maxReplaces:uint = 200):String
  380. 		{
  381. 			for(var i:uint = 0; i < maxReplaces; i++)
  382. 			{
  383. 				if(stringToReplace.search(replacePattern) != -1)
  384. 				{
  385. 					stringToReplace = stringToReplace.replace(replacePattern, replacePatternsByThis);
  386. 				}
  387. 				if(stringToReplace.search(replacePattern) == -1)
  388. 				{
  389. 					break;
  390. 				}
  391. 			}
  392. 			return stringToReplace;
  393. 		}
  394.  
  395. 		private static function putCaracters(string:String, fc:String, sc:String, tc:String):String
  396. 		{
  397. 			return string.substr(0, 3) + fc + string.substr(3, 3) + sc + string.substr(6, 3) + tc + string.substr(9, 2);
  398. 		}
  399. 	}
  400. }

Report this snippet  

Comments

RSS Icon Subscribe to comments
Posted By: ZeRat on March 26, 2011

Alguns campos só validam dados brasileiros, como o telefone, e CEP.

You need to login to post a comment.