FUNCAO: Transforme Decimal para Hexa, Octal, URL, Binario...

Mensagem por **rochinha** » 01 Mar 2010 16:09

Amiguinhos,

Ao recuperar algumas URLs na internet ou tentar limpar campos em meus bancos de dados me deparava com caracteres estranhos e ficava perdendo tempo tentando transformá-los.

Aí me lembrei do velho querido dos tempos do DOS, Sidekick. que tinha uma tabela ASC show-de-bola.

Funções para transformar Isto-Naquilo existem as pencas e muitas delas estão aqui no nosso querido forum.

A que estou acrescentando não foge a regra de facilitar e pode não acrescentar muito, mas se serve pra mim, pode servir a mais alguém.

Então:

Código: Selecionar todos

#INCLUDE "fivewin.ch"

#DEFINE Decimal        1 // Por Fladimir
#DEFINE HexaDecimal 2
#DEFINE Caracter 3
#DEFINE URL 4
#DEFINE Binario 5
#DEFINE Octal 6

FUNCTION main()
  ? DecTOWhat( 60, 1 ) // Transforma o ASC 60 em seu correspondente Hexadecimal
  ? DecTOWhat( 60, 2 ) // Transforma o ASC 60 em seu correspondente Caracter
  ? DecTOWhat( 60, 3 ) // Transforma o ASC 60 em seu correspondente URL
  ? DecTOWhat( 60, 4 ) // Transforma o ASC 60 em seu correspondente Binario
  ? DecTOWhat( 60, 5 ) // Transforma o ASC 60 em seu correspondente Octal
  RETURN ""

FUNCTION DecTOWhat( Oque, ParaQue )
  local aDecTOWhat := {}
  aadd( aDecTOWhat, {  32, "20", " ", "%20", "010 0000", "40" } )
  aadd( aDecTOWhat, {  33, "21", "!", "%21", "010 0001", "41" } )
  aadd( aDecTOWhat, {  34, "22", ["], "%22", "010 0010", "42" } )
  aadd( aDecTOWhat, {  35, "23", "#", "%23", "010 0011", "43" } )
  aadd( aDecTOWhat, {  36, "24", "$", "%24", "010 0100", "44" } )
  aadd( aDecTOWhat, {  37, "25", "%", "%25", "010 0101", "45" } )
  aadd( aDecTOWhat, {  38, "26", "&", "%26", "010 0110", "46" } )
  aadd( aDecTOWhat, {  39, "27", "'", "%27", "010 0111", "47" } )
  aadd( aDecTOWhat, {  40, "28", "(", "%28", "010 1000", "50" } )
  aadd( aDecTOWhat, {  41, "29", ")", "%29", "010 1001", "51" } )
  aadd( aDecTOWhat, {  42, "2A", "*", "%2A", "010 1010", "52" } )
  aadd( aDecTOWhat, {  43, "2B", "+", "%2B", "010 1011", "53" } )
  aadd( aDecTOWhat, {  44, "2C", ",", "%2C", "010 1100", "54" } )
  aadd( aDecTOWhat, {  45, "2D", "-", "%2D", "010 1101", "55" } )
  aadd( aDecTOWhat, {  46, "2E", ".", "%2E", "010 1110", "56" } )
  aadd( aDecTOWhat, {  47, "2F", "/", "%2F", "010 1111", "57" } )
  aadd( aDecTOWhat, {  48, "30", "0", "%30", "011 0000", "60" } )
  aadd( aDecTOWhat, {  49, "31", "1", "%31", "011 0001", "61" } )
  aadd( aDecTOWhat, {  50, "32", "2", "%32", "011 0010", "62" } )
  aadd( aDecTOWhat, {  51, "33", "3", "%33", "011 0011", "63" } )
  aadd( aDecTOWhat, {  52, "34", "4", "%34", "011 0100", "64" } )
  aadd( aDecTOWhat, {  53, "35", "5", "%35", "011 0101", "65" } )
  aadd( aDecTOWhat, {  54, "36", "6", "%36", "011 0110", "66" } )
  aadd( aDecTOWhat, {  55, "37", "7", "%37", "011 0111", "67" } )
  aadd( aDecTOWhat, {  56, "38", "8", "%38", "011 1000", "70" } )
  aadd( aDecTOWhat, {  57, "39", "9", "%39", "011 1001", "71" } )
  aadd( aDecTOWhat, {  58, "3A", ":", "%3A", "011 1010", "72" } )
  aadd( aDecTOWhat, {  59, "3B", ";", "%3B", "011 1011", "73" } )
  aadd( aDecTOWhat, {  60, "3C", "<", "%3C", "011 1100", "74" } )
  aadd( aDecTOWhat, {  61, "3D", "=", "%3D", "011 1101", "75" } )
  aadd( aDecTOWhat, {  62, "3E", ">", "%3E", "011 1110", "76" } )
  aadd( aDecTOWhat, {  63, "3F", "?", "%3F", "011 1111", "77" } )
  aadd( aDecTOWhat, {  64, "40", "@", "%40", "100 0000", "100" } )
  aadd( aDecTOWhat, {  65, "41", "A", "%41", "100 0001", "101" } )
  aadd( aDecTOWhat, {  66, "42", "B", "%42", "100 0010", "102" } )
  aadd( aDecTOWhat, {  67, "43", "C", "%43", "100 0011", "103" } )
  aadd( aDecTOWhat, {  68, "44", "D", "%44", "100 0100", "104" } )
  aadd( aDecTOWhat, {  69, "45", "E", "%45", "100 0101", "105" } )
  aadd( aDecTOWhat, {  70, "46", "F", "%46", "100 0110", "106" } )
  aadd( aDecTOWhat, {  71, "47", "G", "%47", "100 0111", "107" } )
  aadd( aDecTOWhat, {  72, "48", "H", "%48", "100 1000", "110" } )
  aadd( aDecTOWhat, {  73, "49", "I", "%49", "100 1001", "111" } )
  aadd( aDecTOWhat, {  74, "4A", "J", "%4A", "100 1010", "112" } )
  aadd( aDecTOWhat, {  75, "4B", "K", "%4B", "100 1011", "113" } )
  aadd( aDecTOWhat, {  76, "4C", "L", "%4C", "100 1100", "114" } )
  aadd( aDecTOWhat, {  77, "4D", "M", "%4D", "100 1101", "115" } )
  aadd( aDecTOWhat, {  78, "4E", "N", "%4E", "100 1110", "116" } )
  aadd( aDecTOWhat, {  79, "4F", "O", "%4F", "100 1111", "117" } )
  aadd( aDecTOWhat, {  80, "50", "P", "%50", "101 0000", "120" } )
  aadd( aDecTOWhat, {  81, "51", "Q", "%51", "101 0001", "121" } )
  aadd( aDecTOWhat, {  82, "52", "R", "%52", "101 0010", "122" } )
  aadd( aDecTOWhat, {  83, "53", "S", "%53", "101 0011", "123" } )
  aadd( aDecTOWhat, {  84, "54", "T", "%54", "101 0100", "124" } )
  aadd( aDecTOWhat, {  85, "55", "U", "%55", "101 0101", "125" } )
  aadd( aDecTOWhat, {  86, "56", "V", "%56", "101 0110", "126" } )
  aadd( aDecTOWhat, {  87, "57", "W", "%57", "101 0111", "127" } )
  aadd( aDecTOWhat, {  88, "58", "X", "%58", "101 1000", "130" } )
  aadd( aDecTOWhat, {  89, "59", "Y", "%59", "101 1001", "131" } )
  aadd( aDecTOWhat, {  90, "5A", "Z", "%5A", "101 1010", "132" } )
  aadd( aDecTOWhat, {  91, "5B", "[", "%5B", "101 1011", "133" } )
  aadd( aDecTOWhat, {  92, "5C", "\", "%5C", "101 1100", "134" } )
  aadd( aDecTOWhat, {  93, "5D", "]", "%5D", "101 1101", "135" } )
  aadd( aDecTOWhat, {  94, "5E", "^", "%5E", "101 1110", "136" } )
  aadd( aDecTOWhat, {  95, "5F", "_", "%5F", "101 1111", "137" } )
  aadd( aDecTOWhat, {  96, "60", "`", "%60", "110 0000", "140" } )
  aadd( aDecTOWhat, {  97, "61", "a", "%61", "110 0001", "141" } )
  aadd( aDecTOWhat, {  98, "62", "b", "%62", "110 0010", "142" } )
  aadd( aDecTOWhat, {  99, "63", "c", "%63", "110 0011", "143" } )
  aadd( aDecTOWhat, { 100, "64", "d", "%64", "110 0100", "144" } )
  aadd( aDecTOWhat, { 101, "65", "e", "%65", "110 0101", "145" } )
  aadd( aDecTOWhat, { 102, "66", "f", "%66", "110 0110", "146" } )
  aadd( aDecTOWhat, { 103, "67", "g", "%67", "110 0111", "147" } )
  aadd( aDecTOWhat, { 104, "68", "h", "%68", "110 1000", "150" } )
  aadd( aDecTOWhat, { 105, "69", "i", "%69", "110 1001", "151" } )
  aadd( aDecTOWhat, { 106, "6A", "j", "%6A", "110 1010", "152" } )
  aadd( aDecTOWhat, { 107, "6B", "k", "%6B", "110 1011", "153" } )
  aadd( aDecTOWhat, { 108, "6C", "l", "%6C", "110 1100", "154" } )
  aadd( aDecTOWhat, { 109, "6D", "m", "%6D", "110 1101", "155" } )
  aadd( aDecTOWhat, { 110, "6E", "n", "%6E", "110 1110", "156" } )
  aadd( aDecTOWhat, { 111, "6F", "o", "%6F", "110 1111", "157" } )
  aadd( aDecTOWhat, { 112, "70", "p", "%70", "111 0000", "160" } )
  aadd( aDecTOWhat, { 113, "71", "q", "%71", "111 0001", "161" } )
  aadd( aDecTOWhat, { 114, "72", "r", "%72", "111 0010", "162" } )
  aadd( aDecTOWhat, { 115, "73", "s", "%73", "111 0011", "163" } )
  aadd( aDecTOWhat, { 116, "74", "t", "%74", "111 0100", "164" } )
  aadd( aDecTOWhat, { 117, "75", "u", "%75", "111 0101", "165" } )
  aadd( aDecTOWhat, { 118, "76", "v", "%76", "111 0110", "166" } )
  aadd( aDecTOWhat, { 119, "77", "w", "%77", "111 0111", "167" } )
  aadd( aDecTOWhat, { 120, "78", "x", "%78", "111 1000", "170" } )
  aadd( aDecTOWhat, { 121, "79", "y", "%79", "111 1001", "171" } )
  aadd( aDecTOWhat, { 122, "7A", "z", "%7A", "111 1010", "172" } )
  aadd( aDecTOWhat, { 123, "7B", "{", "%7B", "111 1011", "173" } )
  aadd( aDecTOWhat, { 124, "7C", "|", "%7C", "111 1100", "174" } )
  aadd( aDecTOWhat, { 125, "7D", "}", "%7D", "111 1101", "175" } )
  aadd( aDecTOWhat, { 126, "7E", "~", "%7E", "111 1110", "176" } )
  for i = 1 to len( aDecTOWhat )
      if aDecTOWhat[ i ][ 1 ] = Oque
         return aDecTOWhat[ i ][ ParaQue ]
      endif
  next
  RETURN ""

Para aqueles que se aventurarem a usá-la e adicionar recursos ou melhorá-la, mãos a obra. O código esta esposto no modo mais didático possivel.

Caso alguns dos caracteres não apareçam como deveriam podem baixar o código original daqui.

Para desta tabela encontra-se em http://en.wikipedia.org/wiki/ASCII_chart

Mensagem por **fladimir** » 09 Mai 2012 14:07

Rochinha td bem.. tem como vc dar uma revisada na tua função pois eu acho, baseado na Array q vc define depois q esta parte:

Código: Selecionar todos

#DEFINE HexaDecimal 1
#DEFINE Caracter 2
#DEFINE URL 3
#DEFINE Binario 4
#DEFINE Octal 5

Esta trocada....
não seria:

Código: Selecionar todos

#DEFINE Decimal        1
#DEFINE HexaDecimal 2
#DEFINE Caracter 3
#DEFINE URL 4
#DEFINE Binario 5
#DEFINE Octal 6

[]´s

Mensagem por **rochinha** » 09 Mai 2012 20:22

Amiguinho,

Revisado e anotado.

Ahora en la version 2.0!

Pablo César · Mensagem por **Pablo César** » 10 Mai 2012 04:23

Eis a versão 3.0 então ! Já com as correções que o fladimir detectou e algumas modificações a mais...

Código: Selecionar todos

#define DECIMAL        1
#define HEXADECIMAL    2
#define CARACTER       3
#define URL            4
#define BINARIO        5
#define OCTAL          6

Function Main()
SetMode(25,80)
? "Decimal    : " + DecTOWhat( 60, DECIMAL     ) // Transforma o ASC 60 em seu correspondente Decimal    
? "HexaDecimal: " + DecTOWhat( 60, HEXADECIMAL ) // Transforma o ASC 60 em seu correspondente HexaDecimal
? "Caracter   : " + DecTOWhat( 60, CARACTER    ) // Transforma o ASC 60 em seu correspondente Caracter   
? "URL        : " + DecTOWhat( 60, URL         ) // Transforma o ASC 60 em seu correspondente URL        
? "Binario    : " + DecTOWhat( 60, BINARIO     ) // Transforma o ASC 60 em seu correspondente Binario    
? "Octal      : " + DecTOWhat( 60, OCTAL       ) // Transforma o ASC 60 em seu correspondente Octal      
?
Inkey(0)
RETURN ""

FUNCTION DecTOWhat( Oque, ParaQue )
Local aDecTOWhat := {}

If Valtype(Oque)="N"
   Oque := Strzero(Oque,3,0)
Endif
aadd( aDecTOWhat, { "032", "20", " ", "%20", "0100000", "040" } )
aadd( aDecTOWhat, { "033", "21", "!", "%21", "0100001", "041" } )
aadd( aDecTOWhat, { "034", "22", ["], "%22", "0100010", "042" } )
aadd( aDecTOWhat, { "035", "23", "#", "%23", "0100011", "043" } )
aadd( aDecTOWhat, { "036", "24", "$", "%24", "0100100", "044" } )
aadd( aDecTOWhat, { "037", "25", "%", "%25", "0100101", "045" } )
aadd( aDecTOWhat, { "038", "26", "&", "%26", "0100110", "046" } )
aadd( aDecTOWhat, { "039", "27", "'", "%27", "0100111", "047" } )
aadd( aDecTOWhat, { "040", "28", "(", "%28", "0101000", "050" } )
aadd( aDecTOWhat, { "041", "29", ")", "%29", "0101001", "051" } )
aadd( aDecTOWhat, { "042", "2A", "*", "%2A", "0101010", "052" } )
aadd( aDecTOWhat, { "043", "2B", "+", "%2B", "0101011", "053" } )
aadd( aDecTOWhat, { "044", "2C", ",", "%2C", "0101100", "054" } )
aadd( aDecTOWhat, { "045", "2D", "-", "%2D", "0101101", "055" } )
aadd( aDecTOWhat, { "046", "2E", ".", "%2E", "0101110", "056" } )
aadd( aDecTOWhat, { "047", "2F", "/", "%2F", "0101111", "057" } )
aadd( aDecTOWhat, { "048", "30", "0", "%30", "0110000", "060" } )
aadd( aDecTOWhat, { "049", "31", "1", "%31", "0110001", "061" } )
aadd( aDecTOWhat, { "050", "32", "2", "%32", "0110010", "062" } )
aadd( aDecTOWhat, { "051", "33", "3", "%33", "0110011", "063" } )
aadd( aDecTOWhat, { "052", "34", "4", "%34", "0110100", "064" } )
aadd( aDecTOWhat, { "053", "35", "5", "%35", "0110101", "065" } )
aadd( aDecTOWhat, { "054", "36", "6", "%36", "0110110", "066" } )
aadd( aDecTOWhat, { "055", "37", "7", "%37", "0110111", "067" } )
aadd( aDecTOWhat, { "056", "38", "8", "%38", "0111000", "070" } )
aadd( aDecTOWhat, { "057", "39", "9", "%39", "0111001", "071" } )
aadd( aDecTOWhat, { "058", "3A", ":", "%3A", "0111010", "072" } )
aadd( aDecTOWhat, { "059", "3B", ";", "%3B", "0111011", "073" } )
aadd( aDecTOWhat, { "060", "3C", "<", "%3C", "0111100", "074" } )
aadd( aDecTOWhat, { "061", "3D", "=", "%3D", "0111101", "075" } )
aadd( aDecTOWhat, { "062", "3E", ">", "%3E", "0111110", "076" } )
aadd( aDecTOWhat, { "063", "3F", "?", "%3F", "0111111", "077" } )
aadd( aDecTOWhat, { "064", "40", "@", "%40", "1000000", "100" } )
aadd( aDecTOWhat, { "065", "41", "A", "%41", "1000001", "101" } )
aadd( aDecTOWhat, { "066", "42", "B", "%42", "1000010", "102" } )
aadd( aDecTOWhat, { "067", "43", "C", "%43", "1000011", "103" } )
aadd( aDecTOWhat, { "068", "44", "D", "%44", "1000100", "104" } )
aadd( aDecTOWhat, { "069", "45", "E", "%45", "1000101", "105" } )
aadd( aDecTOWhat, { "070", "46", "F", "%46", "1000110", "106" } )
aadd( aDecTOWhat, { "071", "47", "G", "%47", "1000111", "107" } )
aadd( aDecTOWhat, { "072", "48", "H", "%48", "1001000", "110" } )
aadd( aDecTOWhat, { "073", "49", "I", "%49", "1001001", "111" } )
aadd( aDecTOWhat, { "074", "4A", "J", "%4A", "1001010", "112" } )
aadd( aDecTOWhat, { "075", "4B", "K", "%4B", "1001011", "113" } )
aadd( aDecTOWhat, { "076", "4C", "L", "%4C", "1001100", "114" } )
aadd( aDecTOWhat, { "077", "4D", "M", "%4D", "1001101", "115" } )
aadd( aDecTOWhat, { "078", "4E", "N", "%4E", "1001110", "116" } )
aadd( aDecTOWhat, { "079", "4F", "O", "%4F", "1001111", "117" } )
aadd( aDecTOWhat, { "080", "50", "P", "%50", "1010000", "120" } )
aadd( aDecTOWhat, { "081", "51", "Q", "%51", "1010001", "121" } )
aadd( aDecTOWhat, { "082", "52", "R", "%52", "1010010", "122" } )
aadd( aDecTOWhat, { "083", "53", "S", "%53", "1010011", "123" } )
aadd( aDecTOWhat, { "084", "54", "T", "%54", "1010100", "124" } )
aadd( aDecTOWhat, { "085", "55", "U", "%55", "1010101", "125" } )
aadd( aDecTOWhat, { "086", "56", "V", "%56", "1010110", "126" } )
aadd( aDecTOWhat, { "087", "57", "W", "%57", "1010111", "127" } )
aadd( aDecTOWhat, { "088", "58", "X", "%58", "1011000", "130" } )
aadd( aDecTOWhat, { "089", "59", "Y", "%59", "1011001", "131" } )
aadd( aDecTOWhat, { "090", "5A", "Z", "%5A", "1011010", "132" } )
aadd( aDecTOWhat, { "091", "5B", "[", "%5B", "1011011", "133" } )
aadd( aDecTOWhat, { "092", "5C", "\", "%5C", "1011100", "134" } )
aadd( aDecTOWhat, { "093", "5D", "]", "%5D", "1011101", "135" } )
aadd( aDecTOWhat, { "094", "5E", "^", "%5E", "1011110", "136" } )
aadd( aDecTOWhat, { "095", "5F", "_", "%5F", "1011111", "137" } )
aadd( aDecTOWhat, { "096", "60", "`", "%60", "1100000", "140" } )
aadd( aDecTOWhat, { "097", "61", "a", "%61", "1100001", "141" } )
aadd( aDecTOWhat, { "098", "62", "b", "%62", "1100010", "142" } )
aadd( aDecTOWhat, { "099", "63", "c", "%63", "1100011", "143" } )
aadd( aDecTOWhat, { "100", "64", "d", "%64", "1100100", "144" } )
aadd( aDecTOWhat, { "101", "65", "e", "%65", "1100101", "145" } )
aadd( aDecTOWhat, { "102", "66", "f", "%66", "1100110", "146" } )
aadd( aDecTOWhat, { "103", "67", "g", "%67", "1100111", "147" } )
aadd( aDecTOWhat, { "104", "68", "h", "%68", "1101000", "150" } )
aadd( aDecTOWhat, { "105", "69", "i", "%69", "1101001", "151" } )
aadd( aDecTOWhat, { "106", "6A", "j", "%6A", "1101010", "152" } )
aadd( aDecTOWhat, { "107", "6B", "k", "%6B", "1101011", "153" } )
aadd( aDecTOWhat, { "108", "6C", "l", "%6C", "1101100", "154" } )
aadd( aDecTOWhat, { "109", "6D", "m", "%6D", "1101101", "155" } )
aadd( aDecTOWhat, { "110", "6E", "n", "%6E", "1101110", "156" } )
aadd( aDecTOWhat, { "111", "6F", "o", "%6F", "1101111", "157" } )
aadd( aDecTOWhat, { "112", "70", "p", "%70", "1110000", "160" } )
aadd( aDecTOWhat, { "113", "71", "q", "%71", "1110001", "161" } )
aadd( aDecTOWhat, { "114", "72", "r", "%72", "1110010", "162" } )
aadd( aDecTOWhat, { "115", "73", "s", "%73", "1110011", "163" } )
aadd( aDecTOWhat, { "116", "74", "t", "%74", "1110100", "164" } )
aadd( aDecTOWhat, { "117", "75", "u", "%75", "1110101", "165" } )
aadd( aDecTOWhat, { "118", "76", "v", "%76", "1110110", "166" } )
aadd( aDecTOWhat, { "119", "77", "w", "%77", "1110111", "167" } )
aadd( aDecTOWhat, { "120", "78", "x", "%78", "1111000", "170" } )
aadd( aDecTOWhat, { "121", "79", "y", "%79", "1111001", "171" } )
aadd( aDecTOWhat, { "122", "7A", "z", "%7A", "1111010", "172" } )
aadd( aDecTOWhat, { "123", "7B", "{", "%7B", "1111011", "173" } )
aadd( aDecTOWhat, { "124", "7C", "|", "%7C", "1111100", "174" } )
aadd( aDecTOWhat, { "125", "7D", "}", "%7D", "1111101", "175" } )
aadd( aDecTOWhat, { "126", "7E", "~", "%7E", "1111110", "176" } )
For i = 1 to Len( aDecTOWhat )
    If aDecTOWhat[ i ][ 1 ] = Oque
       Return aDecTOWhat[ i ][ ParaQue ]
    Endif
Next
RETURN ""