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
 

  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.