Hỏi: Chuyển đổi chữ thành ký tự!

Chia sẻ bởi:hands
★★★★★
Quảng cáo

Chào các anh, chị
Em có 1 case như thế này nhờ mọi người giúp. Liệu có cách nào chuyển đổi văn bản kiểu : ád thành asd không ạ ?
Ví dụ khác : Cộng hòa xã hội —> Coong Hoaf xax hoi
Hiểu đơn giản là lúc mình input bằng bàn phím như thế nào thì khi convert xong nó sẽ ra những ký tự y như thế ạ !
Em cảm ơn mn ạ.

Có đó bạn, có thể biến tấu từ chính là các hàm viết Unicode trong VBA.
*** Nguồn của anh @ndu96081631 (cảm ơn @huuthang_bd nhắc nhở)

Bạn sử dụng công thức
A1 = "Em ơi Hà Nội phố"
=UniConvert(A1,"VNI") –> Em o7i Ha2 No65i pho61
=UniConvert(A1,"Telex") –> Em owi Haf Nooji phoos

Function UniConvert(Text As String, InputMethod As String) As String
  Dim VNI_Type, Telex_Type, CharCode, Temp, i As Long
  UniConvert = Text
  VNI_Type = Array("a81", "a82", "a83", "a84", "a85", "a61", "a62", "a63", "a64", "a65", "e61", _
      "e62", "e63", "e64", "e65", "o61", "o62", "o63", "o64", "o65", "o71", "o72", "o73", "o74", _
      "o75", "u71", "u72", "u73", "u74", "u75", "a1", "a2", "a3", "a4", "a5", "a8", "a6", "d9", _
      "e1", "e2", "e3", "e4", "e5", "e6", "i1", "i2", "i3", "i4", "i5", "o1", "o2", "o3", "o4", _
      "o5", "o6", "o7", "u1", "u2", "u3", "u4", "u5", "u7", "y1", "y2", "y3", "y4", "y5")
  Telex_Type = Array("aws", "awf", "awr", "awx", "awj", "aas", "aaf", "aar", "aax", "aaj", "ees", _
      "eef", "eer", "eex", "eej", "oos", "oof", "oor", "oox", "ooj", "ows", "owf", "owr", "owx", _
      "owj", "uws", "uwf", "uwr", "uwx", "uwj", "as", "af", "ar", "ax", "aj", "aw", "aa", "dd", _
      "es", "ef", "er", "ex", "ej", "ee", "is", "if", "ir", "ix", "ij", "os", "of", "or", "ox", _
      "oj", "oo", "ow", "us", "uf", "ur", "ux", "uj", "uw", "ys", "yf", "yr", "yx", "yj")
  CharCode = Array(ChrW(7855), ChrW(7857), ChrW(7859), ChrW(7861), ChrW(7863), ChrW(7845), ChrW(7847), _
      ChrW(7849), ChrW(7851), ChrW(7853), ChrW(7871), ChrW(7873), ChrW(7875), ChrW(7877), ChrW(7879), _
      ChrW(7889), ChrW(7891), ChrW(7893), ChrW(7895), ChrW(7897), ChrW(7899), ChrW(7901), ChrW(7903), _
      ChrW(7905), ChrW(7907), ChrW(7913), ChrW(7915), ChrW(7917), ChrW(7919), ChrW(7921), ChrW(225), _
      ChrW(224), ChrW(7843), ChrW(227), ChrW(7841), ChrW(259), ChrW(226), ChrW(273), ChrW(233), ChrW(232), _
      ChrW(7867), ChrW(7869), ChrW(7865), ChrW(234), ChrW(237), ChrW(236), ChrW(7881), ChrW(297), ChrW(7883), _
      ChrW(243), ChrW(242), ChrW(7887), ChrW(245), ChrW(7885), ChrW(244), ChrW(417), ChrW(250), ChrW(249), _
      ChrW(7911), ChrW(361), ChrW(7909), ChrW(432), ChrW(253), ChrW(7923), ChrW(7927), ChrW(7929), ChrW(7925))
  Select Case InputMethod
    Case Is = "VNI": Temp = VNI_Type
    Case Is = "Telex": Temp = Telex_Type
  End Select
  For i = 0 To UBound(Temp)
    'UniConvert = Replace(UniConvert, Temp(i), CharCode(i))
    UniConvert = Replace(UniConvert, CharCode(i), Temp(i))
    'UniConvert = Replace(UniConvert, UCase(Temp(i)), UCase(CharCode(i)))
    UniConvert = Replace(UniConvert, UCase(CharCode(i)), UCase(Temp(i)))
  Next i
End Function

www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Ei-c%C3%A1ch-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ti%E1%BA%BFng-vi%E1%BB%87t-t%E1%BB%AB-ki%E1%BB%83u-g%C3%B5-telex-v%E1%BB%81-k%C3%BD-g%E1%BB%91c-nh%E1%BA%ADp-t%E1%BB%AB-b%C3%A0n-ph%C3%ADm.159014/post-1057751

Em cảm ơn bác ạ, em vừa thử code của bác, tuy nhiên nó không giải quyết triệt để được vấn đề convert về basic input keyboard ạ.
Ví dụ : Nghĩa : Có 2 cách viết ở Telex : Nghiax và Nghixa đều viết được, nhưng khi convert thì chỉ convert được thành 1 loại duy nhất là : Nghixa chứ không convert được thành Nghiax , em mong được giúp đỡ ạ.
891

Thì thấy dấu hỏi ngã nặng sắc huyền (?~.'`) thì chuyển gõ dấu (rxjsf) về cuối cùng là được .
Tôi tên Thắng và tôi gõ các cách sau đều được: Thawngs, Thanwgs, Thangws, Thasngw, Thansgw, Thangsw, Thawsng, Thaswng, Thawnsg, Thasnwg…
Vậy thì biết cái nào là gốc?

Các ký tự này không phải lúc nào cũng là dấu. Làm cách này chắc phải đi đường vòng, chuyển sang kiểu VNI trước, dồn số về cuối rồi chuyển kiểu VNI sang kiểu Telex.

Mình thua (ngoài khả năng).
Nhưng cũng nói để anh em nào biết vào chỉ thêm.
1. Theo như mình hiểu, font chữ được quy định thông qua bộ mã charcode, bộ gõ tiếng Việt (Telex hay Vni) cũng là 1 chuỗi các quy tắc.
Khi gõ "xuaw" hay "xuwa" đều thành "xưa" là vì bộ gõ (bộ chuyển đổi) cho phép cách nhập như vậy và chuyển đổi nó thành "x – ư – a"
đã chuyển xong thì kg thể biết xưa kia bạn gõ kiểu gì.
2. Nếu muốn thì ghi lại cái input từ bàn phím, bấm gì ra đó thì có vẽ khả dĩ hơn (Keylogger)

Đã đính chính thì xóa luôn cái link trong code nha bạn.

à, mình biết rõ nguồn thì ghi thêm, còn cái code trước khi mình edit thì đúng là copy từ blog người ta mà, có phải lấy bài của anh ndu đâu.
Chuyện blog họ xào thành của họ và kg ghi nguồn cũng đâu có phải lỗi mình 😀

Chưa hiểu ý anh.

'Ví dụ:
'Có từ kết quả "nghiax", strKQ
'Chữ hoa thường tính sau
Telex_Type = Array("aws", "awf", "awr", "awx", "awj", "aas", "aaf", "aar", "aax", "aaj", "ees", _
      "eef", "eer", "eex", "eej", "oos", "oof", "oor", "oox", "ooj", "ows", "owf", "owr", "owx", _
      "owj", "uws", "uwf", "uwr", "uwx", "uwj", "as", "af", "ar", "ax", "aj", "aw", "aa", "dd", _
      "es", "ef", "er", "ex", "ej", "ee", "is", "if", "ir", "ix", "ij", "os", "of", "or", "ox", _
      "oj", "oo", "ow", "us", "uf", "ur", "ux", "uj", "uw", "ys", "yf", "yr", "yx", "yj")
For each item in  Telex_Type
If instr(1, strKQ, item) > 0 Then
strDau = vba.right(item,1)
strKytu = vba.left(item, vba.len(item)-1)
strKQ = vba.replace(strKQ, item, strKytu) & strDau
Exit for
End if
Next item

www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Ei-c%C3%A1ch-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ti%E1%BA%BFng-vi%E1%BB%87t-t%E1%BB%AB-ki%E1%BB%83u-g%C3%B5-telex-v%E1%BB%81-k%C3%BD-g%E1%BB%91c-nh%E1%BA%ADp-t%E1%BB%AB-b%C3%A0n-ph%C3%ADm.159014/post-1057765

À nếu duyệt các trường hợp như vậy thì không vấn đề gì, tôi tưởng ý bạn là chuyển các ký tự gõ dấu (rxjsf) về cuối từ nên nghĩ là sẽ nhầm với các ký tự không phải dùng để gõ dấu (Ví dụ: sông).

Khóa học Power PI – Ứng dung trong Nhân sự
Khóa học SprinGO phù hợp

Khóa học Power PI – Ứng dung trong Nhân sự

TỔNG QUAN KHÓA HỌC: POWER BI CHO NGÀNH NHÂN SỰ Khóa học Power BI cho Nhân sự được thiết kế dành riêng cho các...

Xem khóa học
★★★★★ 5 ★ 1 👤 3 ▥ 0
Quảng cáo

Bạn nên đọc

3 Responses

  1. hands says:

    Chào các bạn! Mình muốn hỏi trong Excel có cách nào chuyển đổi chữ thành ký tự kiểu như là: "Không đi đâu" → "Khoong ddi ddaau" hoặc "Tôi nghĩ thế này" → "Tooi nghix thees nayf" không?

    Cảm ơn các bạn!

    Chuyện này hơi khó. Khó ở chỗ kết quả không hoàn toàn tin cậy. Theo lô gic toán, sự chuyển đổi chỉ tin cậy được khi hàm chuyển đổi có tính cách đơn trị trong vùng hoạt động: nếu x1 <> x2 thì f(x1) <> f(x2) và ngược lại.

    Trong trường hợp này, sau khi dịch xong rồi, lỡ gặp chữ có hai cách hiểu, hoặc có kèm tiếng Anh thì sao?
    Ví dụ:
    tiếng Việt có cả 2 từ sông (con sông) và soong (cái nồi)
    bees được hiểu là gì?

    chỉ làm một chiều cho tiếng việt thì cứ ký tự đặc biệt là đổi kiểu "ô" thành "oo", đổi "à" thành "af"… có điều đổi "này" thành "nafy" thì dễ chứ thành "nayf" thì hơi phiền.
    @VetMini: ngôn ngữ nói chung, (đặc biệt là) tiếng việt khó mà theo logic toán được. ví dụ hiểu "ông cụ già đi nhanh quá" thế nào?
    1/ ông cụ GIÀ ĐI nhanh quá.
    2/ ông cụ già ĐI nhanh quá.

    Tại sao lại "(đặc biệt là) tiếng Việt"? Việc khó hiểu chả có gì của riêng tiếng Việt cả.

    Ai học ngữ pháp tiếng Anh cũng từng học qua câu này:

    "I saw a man on a hill with a telescope"

    Có ít nhất vài cách hiểu: cái telescope của tôi hay của người kia? và tôi có đang ở trên đồi?

    Chào các bạn! Mình muốn hỏi trong Excel có cách nào chuyển đổi chữ thành ký tự kiểu như là: "Không đi đâu" → "Khoong ddi ddaau" hoặc "Tôi nghĩ thế này" → "Tooi nghix thees nayf" không?

    Cảm ơn các bạn!

    Bạn kiểm tra cái này xem sao
    ( Nguồn thay thế trong sheet1 )

    Public Sub Chuyen_Ve_Ky_Tu()
    Dim Nguon, DL, Tam, kq(), r As Long, rw As Long, c As Long
    
    Nguon = Sheet1.UsedRange
    DL = Sheet2.Range("B4").CurrentRegion
    ReDim kq(1 To UBound(DL), 1 To 1)
    
    With CreateObject("vbscript.regexp")
    .Global = True
    .Pattern = "[^a-zA-Z]+"
    For r = 1 To UBound(DL)
    Tam = Split(DL(r, 1), " ")
    
    For c = 0 To UBound(Tam)
    If .test(Tam(c)) Then
    For rw = 1 To UBound(Nguon)
    If InStr(Tam(c), Nguon(rw, 1)) Then
    Tam(c) = Replace(Tam(c), Nguon(rw, 1), Nguon(rw, 2))
    Tam(c) = Tam(c) & Nguon(rw, 3)
    End If
    Next rw
    End If
    Next c
    
    kq(r, 1) = Join(Tam, " ")
    Next r
    End With
    
    Sheet2.Range("I4", Sheet2.Range("I4").End(xlDown)).ClearContents
    Sheet2.Range("I4").Resize(UBound(kq), 1) = kq
    End Sub


    Cách gõ VNI chắc không áp dụng được cái này

    http://www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Fi-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ch%E1%BB%AF-th%C3%A0nh-k%C3%BD-t%E1%BB%B1.107473/post-669850

  2. hands says:

    đang rảnh làm luôn (dù cũng chẵng hiểu để làm gì)

    Public Function Sentence2Telex$(s$)
        Dim a$(), b$(), Str$, i&
        If s = vbNullString Then Exit Function
        a = Split(s)
        ReDim b(UBound(a))
        For i = 0 To UBound(a)
            b(i) = word2Telex(a(i))
        Next
        For i = 0 To UBound(b)
            Str = Str & " " & b(i)
        Next
        Sentence2Telex = Trim(Str)
    End Function
    
    Private Function word2Telex$(w As String)
    'Return: letters without sign
    '-----------------------------------------------------------------
        Dim i, OldCh$, NewCh$, Sign$, Word$
        For i = 1 To Len(w)
            OldCh = AscW(Mid(w, i, 1))
            Select Case OldCh
                Case 192: NewCh = "A": Sign = "F"
                Case 193: NewCh = "A": Sign = "S"
                Case 7840: NewCh = "A": Sign = "J"
                Case 7842: NewCh = "A": Sign = "R"
                Case 195: NewCh = "A": Sign = "X"
                Case 258: NewCh = "AW"
                Case 7856: NewCh = "AW": Sign = "F"
                Case 7854: NewCh = "AW": Sign = "S"
                Case 7862: NewCh = "AW": Sign = "J"
                Case 7858: NewCh = "AW": Sign = "R"
                Case 7860: NewCh = "AW": Sign = "X"
                Case 194: NewCh = "AA"
                Case 7846: NewCh = "AA": Sign = "F"
                Case 7844: NewCh = "AA": Sign = "S"
                Case 7852: NewCh = "AA": Sign = "J"
                Case 7848: NewCh = "AA": Sign = "R"
                Case 7850: NewCh = "AA": Sign = "X"
                Case 224: NewCh = "a": Sign = "f"
                Case 225: NewCh = "a": Sign = "s"
                Case 7841: NewCh = "a": Sign = "j"
                Case 7843: NewCh = "a": Sign = "r"
                Case 227: NewCh = "a": Sign = "x"
                Case 259: NewCh = "aw"
                Case 7857: NewCh = "aw": Sign = "f"
                Case 7855: NewCh = "aw": Sign = "s"
                Case 7863: NewCh = "aw": Sign = "j"
                Case 7859: NewCh = "aw": Sign = "r"
                Case 7861: NewCh = "aw": Sign = "x"
                Case 226: NewCh = "aa"
                Case 7847: NewCh = "aa": Sign = "f"
                Case 7845: NewCh = "aa": Sign = "s"
                Case 7853: NewCh = "aa": Sign = "j"
                Case 7849: NewCh = "aa": Sign = "r"
                Case 7851: NewCh = "aa": Sign = "x"
                Case 272: NewCh = "DD"
                Case 273: NewCh = "dd"
                Case 232: NewCh = "e": Sign = "f"
                Case 233: NewCh = "e": Sign = "s"
                Case 7865: NewCh = "e": Sign = "j"
                Case 7867: NewCh = "e": Sign = "r"
                Case 7869: NewCh = "e": Sign = "x"
                Case 234: NewCh = "ee"
                Case 7873: NewCh = "ee": Sign = "f"
                Case 7871: NewCh = "ee": Sign = "s"
                Case 7879: NewCh = "ee": Sign = "j"
                Case 7875: NewCh = "ee": Sign = "r"
                Case 7877: NewCh = "ee": Sign = "x"
                Case 200: NewCh = "E": Sign = "F"
                Case 201: NewCh = "E": Sign = "S"
                Case 7864: NewCh = "E": Sign = "J"
                Case 7866: NewCh = "E": Sign = "R"
                Case 7868: NewCh = "E": Sign = "X"
                Case 202: NewCh = "EE"
                Case 7872: NewCh = "EE": Sign = "F"
                Case 7870: NewCh = "EE": Sign = "S"
                Case 7878: NewCh = "EE": Sign = "J"
                Case 7874: NewCh = "EE": Sign = "R"
                Case 7876: NewCh = "EE": Sign = "X"
                Case 236: NewCh = "i": Sign = "f"
                Case 237: NewCh = "i": Sign = "s"
                Case 7883: NewCh = "i": Sign = "j"
                Case 7881: NewCh = "i": Sign = "r"
                Case 297: NewCh = "i": Sign = "x"
                Case 204: NewCh = "I": Sign = "F"
                Case 205: NewCh = "I": Sign = "S"
                Case 7882: NewCh = "I": Sign = "J"
                Case 7880: NewCh = "I": Sign = "R"
                Case 296: NewCh = "I": Sign = "X"
                Case 242: NewCh = "o": Sign = "f"
                Case 243: NewCh = "o": Sign = "s"
                Case 7885: NewCh = "o": Sign = "j"
                Case 7887: NewCh = "o": Sign = "r"
                Case 245: NewCh = "o": Sign = "x"
                Case 417: NewCh = "ow"
                Case 7901: NewCh = "ow": Sign = "f"
                Case 7899: NewCh = "ow": Sign = "s"
                Case 7907: NewCh = "ow": Sign = "j"
                Case 7903: NewCh = "ow": Sign = "r"
                Case 7905: NewCh = "ow": Sign = "x"
                Case 244: NewCh = "oo"
                Case 7891: NewCh = "oo": Sign = "f"
                Case 7889: NewCh = "oo": Sign = "s"
                Case 7897: NewCh = "oo": Sign = "j"
                Case 7893: NewCh = "oo": Sign = "r"
                Case 7895: NewCh = "oo": Sign = "x"
                Case 210: NewCh = "O": Sign = "F"
                Case 211: NewCh = "O": Sign = "S"
                Case 7884: NewCh = "O": Sign = "J"
                Case 7886: NewCh = "O": Sign = "R"
                Case 213: NewCh = "O": Sign = "X"
                Case 416: NewCh = "OW"
                Case 7900: NewCh = "OW": Sign = "F"
                Case 7898: NewCh = "OW": Sign = "S"
                Case 7906: NewCh = "OW": Sign = "J"
                Case 7902: NewCh = "OW": Sign = "R"
                Case 7904: NewCh = "OW": Sign = "X"
                Case 212: NewCh = "OO"
                Case 7890: NewCh = "OO": Sign = "F"
                Case 7888: NewCh = "OO": Sign = "S"
                Case 7896: NewCh = "OO": Sign = "J"
                Case 7892: NewCh = "OO": Sign = "R"
                Case 7894: NewCh = "OO": Sign = "X"
                Case 249: NewCh = "u": Sign = "f"
                Case 250: NewCh = "u": Sign = "s"
                Case 7909: NewCh = "u": Sign = "j"
                Case 7911: NewCh = "u": Sign = "r"
                Case 361: NewCh = "u": Sign = "x"
                Case 432: NewCh = "w"
                Case 7915: NewCh = "w": Sign = "f"
                Case 7913: NewCh = "w": Sign = "s"
                Case 7921: NewCh = "w": Sign = "j"
                Case 7917: NewCh = "w": Sign = "r"
                Case 7919: NewCh = "u": Sign = "x"
                Case 217: NewCh = "U": Sign = "F"
                Case 218: NewCh = "U": Sign = "S"
                Case 7908: NewCh = "U": Sign = "J"
                Case 7910: NewCh = "U": Sign = "R"
                Case 360: NewCh = "U": Sign = "X"
                Case 431: NewCh = "W"
                Case 7914: NewCh = "W": Sign = "F"
                Case 7912: NewCh = "W": Sign = "S"
                Case 7920: NewCh = "W": Sign = "J"
                Case 7916: NewCh = "W": Sign = "R"
                Case 7918: NewCh = "W": Sign = "X"
                Case 7923: NewCh = "y": Sign = "f"
                Case 253: NewCh = "y": Sign = "s"
                Case 7925: NewCh = "y": Sign = "j"
                Case 7927: NewCh = "y": Sign = "r"
                Case 7929: NewCh = "y": Sign = "x"
                Case 7922: NewCh = "Y": Sign = "F"
                Case 221: NewCh = "Y": Sign = "S"
                Case 7924: NewCh = "Y": Sign = "J"
                Case 7926: NewCh = "Y": Sign = "R"
                Case 7928: NewCh = "Y": Sign = "X"
                Case Else: NewCh = ChrW(OldCh)
            End Select
            Word = Word & NewCh
        Next
        word2Telex = Word & Sign
    End Function

    P/S: tuy hơi dài, nhưng bao chạy tốt.

    Sửa lại đoạn code góp vui, kiểm tra trong file thấy ổn nhưng cũng không biết có đạt được hết yêu cầu khác hay không.
    Public Sub Chuyen_Ve_Ky_Tu()
    Dim Nguon, DL, Tam, kq(), r As Long, rw As Long, c As Long

    Nguon = Sheet1.UsedRange
    DL = Sheet2.Range("B4").CurrentRegion
    ReDim kq(1 To UBound(DL), 1 To 1)

    With CreateObject("vbscript.regexp")
    .Global = True
    .Pattern = "s+"
    'Thêm vòng lặp thay thế các ký tự dấu cách, xuống dòng, tab… thành 1 ký tự trắng'
    For r = 1 To UBound(DL)
    DL(r, 1) = Replace(DL(r, 1), Chr(160), " ")
    DL(r, 1) = .Replace(DL(r, 1), " ")
    Next r

    .Pattern = "[^a-zA-Z]+"
    For r = 1 To UBound(DL)
    Tam = Split(DL(r, 1), " ")

    For c = 0 To UBound(Tam)
    If .test(Tam(c)) Then
    For rw = 1 To UBound(Nguon)
    If InStr(Tam(c), Nguon(rw, 1)) Then
    Tam(c) = Replace(Tam(c), Nguon(rw, 1), Nguon(rw, 2))
    Tam(c) = Tam(c) & Nguon(rw, 3)
    End If
    Next rw
    End If

    'Chuyển các ký tự ",;…" cuối từ về vị trí như ban đầu, các vị trí khác để nguyên'
    If .test(Tam(c)) Then
    rw = .Execute(Tam(c)).Count – 1
    If .Execute(Tam(c))(rw).firstindex = Len(Tam(c)) – 2 Then
    Tam(c) = Replace(Tam(c), .Execute(Tam(c))(rw), "") & .Execute(Tam(c))(rw)
    End If
    End If
    Next c

    kq(r, 1) = Join(Tam, " ")
    Next r
    End With

    Sheet2.Range("I4", Sheet2.Range("I4").End(xlDown)).ClearContents
    Sheet2.Range("I4").Resize(UBound(kq), 1) = kq
    End Sub

    Bổ sung thêm chữ đ, Đ vào bảng mã

    http://www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Fi-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ch%E1%BB%AF-th%C3%A0nh-k%C3%BD-t%E1%BB%B1.107473/post-670017

    Mình thêm chữ "đ" và các dấu vào bảng bên Sheet 1 cũng được mà bạn. Vấn đề mình muốn hỏi là nếu chữ của mình nhiều quá 1 trang Word hoặc chỉ cần nửa trang Word thôi là biên dịch bị lỗi. Lỗi: Run-time error '1004': Application-defined or object-defined error. Lỗi dòng: "Sheet2.Range("I4").Resize(UBound(kq), 1) = kq".

    Có cách nào khắc phục để xử lý được văn bản dài không bạn?

    Góp vui cho bạn một hàm đơn giản (áp dụng cho Bảng mã Unicode và "biên dịch" ra kiểu gõ Telex)

    Public Function Find_Replace_Char(InputString As String) As String
    Dim Uni, RepChr
    Dim i As Integer
    
    Uni = Array(192, 193, 194, 195, 200, 201, 202, 204, 205, 210, 211, 212, 213, 217, 218, 221, 224, _
                225, 226, 227, 232, 233, 234, 236, 237, 242, 243, 244, 245, 249, 250, 253, 258, 259, _
                272, 273, 296, 297, 360, 361, 416, 417, 431, 432, 7840, 7841, 7842, 7843, 7844, 7845, _
                7846, 7847, 7848, 7849, 7850, 7851, 7852, 7853, 7854, 7855, 7856, 7857, 7858, 7859, _
                7860, 7861, 7862, 7863, 7864, 7865, 7866, 7867, 7868, 7869, 7870, 7871, 7872, 7873, _
                7874, 7875, 7876, 7877, 7878, 7879, 7880, 7881, 7882, 7883, 7884, 7885, 7886, 7887, _
                7888, 7889, 7890, 7891, 7892, 7893, 7894, 7895, 7896, 7897, 7898, 7899, 7900, 7901, _
                7902, 7903, 7904, 7905, 7906, 7907, 7908, 7909, 7910, 7911, 7912, 7913, 7914, 7915, _
                7916, 7917, 7918, 7919, 7920, 7921, 7922, 7923, 7924, 7925, 7926, 7927, 7928, 7929)
    
    RepChr = Array("AF", "AS", "AA", "AW", "EF", "ES", "EE", "IF", "IS", "OF", "OS", "OO", "OX", "UF", _
                    "US", "YS", "af", "as", "aa", "ax", "ef", "es", "ee", "if", "is", "of", "os", "oo", _
                    "ox", "uf", "us", "ys", "AW", "aw", "DD", "dd", "IX", "ix", "UX", "ux", "OW", "ow", _
                    "UW", "uw", "AJ", "aj", "AR", "ar", "AAS", "aas", "AAF", "aaf", "AAR", "aar", "AAX", _
                    "aax", "AAJ", "aaj", "AWS", "aws", "AWF", "awf", "AWR", "awr", "AWX", "awx", "AWJ", _
                    "awj", "EJ", "ej", "ER", "er", "EX", "ex", "EES", "ees", "EEF", "eef", "EER", "eer", _
                    "EEX", "eex", "EEJ", "eej", "IIR", "iir", "IIJ", "iij", "OJ", "oj", "OR", "or", "OOS", _
                    "oos", "OOF", "oof", "OOR", "oor", "OOX", "oox", "OOJ", "ooj", "OWS", "ows", "OWF", _
                    "owf", "OWR", "owr", "OWX", "owx", "OWJ", "owj", "UJ", "uj", "UR", "ur", "UWS", "uws", _
                    "UWF", "uwf", "UWR", "uwr", "UWX", "uwx", "UWJ", "uwj", "YF", "ys", "YJ", "yj", "YR", _
                    "yr", "YX", "yx")
    
    Find_Replace_Char = InputString
    For i = 0 To 133
    Find_Replace_Char = Replace(Find_Replace_Char, ChrW(Uni(i)), RepChr(i))
    Next i
    
    End Function

    http://www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Fi-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ch%E1%BB%AF-th%C3%A0nh-k%C3%BD-t%E1%BB%B1.107473/post-670051

    cưỡng => cuwowxng
    đây là điều tác giả muốn ? hihi

  3. hands says:

    Hàm loại này tôi viết cách đây nhiều năm nhưng với ý đồ khác. Chẳng hiểu cái này dùng kiểm tra lỗi chính tả là kiểm tra ra làm sao nhỉ?
    ——————-
    Tặng bạn hàm VNTyping dùng chuyển chuỗi Unicode sang kiểu gõ VNI hoặc Telex

    Function VNTyping(ByVal Text As String, ByVal InputMethod As String) As String
      'InputMethod = "VNI" or "Telex"
      Dim VN_Alp, VNI_Type, Telex_Type, i As Long, Temp
      VNTyping = Text
      VN_Alp = Array("à", "á", "â", "ã", "è", "é", "ê", "ì", "í", "ò", "ó", "ô", "õ", "ù", "ú", "ý", _
                     ChrW(259), ChrW(273), ChrW(297), ChrW(361), ChrW(417), ChrW(432), ChrW(7841), ChrW(7843), _
                     ChrW(7845), ChrW(7847), ChrW(7849), ChrW(7851), ChrW(7853), ChrW(7855), ChrW(7857), ChrW(7859), _
                     ChrW(7861), ChrW(7863), ChrW(7865), ChrW(7867), ChrW(7869), ChrW(7871), ChrW(7873), _
                     ChrW(7875), ChrW(7877), ChrW(7879), ChrW(7881), ChrW(7883), ChrW(7885), ChrW(7887), _
                     ChrW(7889), ChrW(7891), ChrW(7893), ChrW(7895), ChrW(7897), ChrW(7899), ChrW(7901), _
                     ChrW(7903), ChrW(7905), ChrW(7907), ChrW(7909), ChrW(7911), ChrW(7913), ChrW(7915), _
                     ChrW(7917), ChrW(7919), ChrW(7921), ChrW(7923), ChrW(7925), ChrW(7927), ChrW(7929))
      VNI_Type = Array("a2", "a1", "a6", "a4", "e2", "e1", "e6", "i2", "i1", "o2", "o1", "o6", "o4", "u2", _
                       "u1", "y1", "a8", "d9", "i4", "u4", "o7", "u7", "a5", "a3", "a61", "a62", "a63", _
                       "a64", "a65", "a81", "a82", "a83", "a84", "a85", "e5", "e3", "e4", "e61", "e62", "e63", "e64", _
                       "e65", "i3", "i5", "o5", "o3", "o61", "o62", "o63", "o64", "o65", "o71", "o72", "o73", _
                       "o74", "o75", "u5", "u3", "u71", "u72", "u73", "u74", "u75", "y2", "y5", "y3", "y4")
      Telex_Type = Array("af", "as", "aa", "ax", "ef", "es", "ee", "if", "is", "of", "os", "oo", "ox", "uf", _
                         "us", "ys", "aw", "dd", "ix", "ux", "ow", "uw", "aj", "ar", "aas", "aaf", "aar", "aax", _
                         "aaj", "aws", "awf", "awr", "awx", "zwj", "ej", "er", "ex", "ees", "eef", "eer", "eex", _
                         "eej", "ir", "ij", "oj", "or", "oos", "oof", "oor", "oox", "ooj", "ows", "owf", "oor", _
                         "oox", "ooj", "uj", "ur", "uws", "uwf", "uwr", "uwx", "uwj", "yf", "yj", "yr", "yx")
      Select Case UCase(InputMethod)
        Case Is = "TELEX"
          Temp = Telex_Type
        Case Is = "VNI"
          Temp = VNI_Type
      End Select
      For i = 0 To UBound(VN_Alp)
        VNTyping = Replace(VNTyping, LCase(VN_Alp(i)), Temp(i))
        VNTyping = Replace(VNTyping, UCase(VN_Alp(i)), UCase(Left(Temp(i), 1)) & Mid(Temp(i), 2, Len(Temp(i))))
      Next i
    End Function

    Cách dùng:
    – Chuyển sang kiểu VNI:

    =VNTyping(B4,"VNI")

    – Chuyển sang kiểu Telex:

    =VNTyping(B4,"Telex")

    ———————
    Tặng luôn hàm chuyển mã ngược lại:

    Function UniConvert(ByVal Text As String, ByVal InputMethod As String) As String
      Dim VNI_Type, Telex_Type, CharCode, Temp, i As Long
      UniConvert = Text
      VNI_Type = Array("a81", "a82", "a83", "a84", "a85", "a61", "a62", "a63", "a64", "a65", "e61", _
          "e62", "e63", "e64", "e65", "o61", "o62", "o63", "o64", "o65", "o71", "o72", "o73", "o74", _
          "o75", "u71", "u72", "u73", "u74", "u75", "a1", "a2", "a3", "a4", "a5", "a8", "a6", "d9", _
          "e1", "e2", "e3", "e4", "e5", "e6", "i1", "i2", "i3", "i4", "i5", "o1", "o2", "o3", "o4", _
          "o5", "o6", "o7", "u1", "u2", "u3", "u4", "u5", "u7", "y1", "y2", "y3", "y4", "y5")
      Telex_Type = Array("aws", "awf", "awr", "awx", "awj", "aas", "aaf", "aar", "aax", "aaj", "ees", _
          "eef", "eer", "eex", "eej", "oos", "oof", "oor", "oox", "ooj", "ows", "owf", "owr", "owx", _
          "owj", "uws", "uwf", "uwr", "uwx", "uwj", "as", "af", "ar", "ax", "aj", "aw", "aa", "dd", _
          "es", "ef", "er", "ex", "ej", "ee", "is", "if", "ir", "ix", "ij", "os", "of", "or", "ox", _
          "oj", "oo", "ow", "us", "uf", "ur", "ux", "uj", "uw", "ys", "yf", "yr", "yx", "yj")
      CharCode = Array(ChrW(7855), ChrW(7857), ChrW(7859), ChrW(7861), ChrW(7863), ChrW(7845), ChrW(7847), _
          ChrW(7849), ChrW(7851), ChrW(7853), ChrW(7871), ChrW(7873), ChrW(7875), ChrW(7877), ChrW(7879), _
          ChrW(7889), ChrW(7891), ChrW(7893), ChrW(7895), ChrW(7897), ChrW(7899), ChrW(7901), ChrW(7903), _
          ChrW(7905), ChrW(7907), ChrW(7913), ChrW(7915), ChrW(7917), ChrW(7919), ChrW(7921), ChrW(225), _
          ChrW(224), ChrW(7843), ChrW(227), ChrW(7841), ChrW(259), ChrW(226), ChrW(273), ChrW(233), ChrW(232), _
          ChrW(7867), ChrW(7869), ChrW(7865), ChrW(234), ChrW(237), ChrW(236), ChrW(7881), ChrW(297), ChrW(7883), _
          ChrW(243), ChrW(242), ChrW(7887), ChrW(245), ChrW(7885), ChrW(244), ChrW(417), ChrW(250), ChrW(249), _
          ChrW(7911), ChrW(361), ChrW(7909), ChrW(432), ChrW(253), ChrW(7923), ChrW(7927), ChrW(7929), ChrW(7925))
      Select Case UCase(InputMethod)
        Case Is = "VNI": Temp = VNI_Type
        Case Is = "TELEX": Temp = Telex_Type
      End Select
      For i = 0 To UBound(CharCode)
        UniConvert = Replace(UniConvert, Temp(i), CharCode(i))
        UniConvert = Replace(UniConvert, UCase(Temp(i)), UCase(CharCode(i)))
      Next i
    End Function

    Hàm UniConvert thường dùng cho MsgBox tiếng Việt

    http://www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Fi-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ch%E1%BB%AF-th%C3%A0nh-k%C3%BD-t%E1%BB%B1.107473/post-670158

    Em thấy hàm này đối với TELEX chưa đúng lắm nha Thầy, cụ thể là ngay tại cái file mà Thầy đính kèm, chữ "mặc" mã hóa thành "mzwjc" như vậy thay vì chữ "a" nó trở thành chữ "z".

    Và hàm đổi ngược lại nó bị vấn đề chữ hoa chữ thường, "Ăn ở" nó mã hóa thành "Awn oor" và khi chuyển lại nó lại thành "Awn ổ".

    Ngay cái chữ "Áo" trong file nó cũng thế, chuyển qua thành chữ "Aso" chuyển lại nó cũng "Aso".

    VNTyping – Chuyển đổi về ký tự bàn phím theo kiểu gõ VNI, TELEX

    Đang lười nhưng bị kích và cũng đang cần ngay nên fix và nâng cấp code luôn :).
    Bản sửa lỗi hàm VNTyping . Thay thế "zwj", "oor", "oox", "ooj" thành "awj", "owr", "owx", "owj" là sửa được các lỗi trước đây. Code tôi sửa cho phép chuyển đổi cả CHỮ HOA (code cũ chỉ chữ thường).

    Function VNTyping(ByVal Text As String, ByVal InputMethod As String) As String
      'Code goc: ndu96081631
      'Sua loi va them chuyen doi chu HOA: Nguyen Duy Tuan
      'InputMethod = "VNI" or "Telex"
      Dim VN_Alp, VNI_Type, Telex_Type, I As Long, Temp
      VNTyping = Text
      VN_Alp = Array("à", "á", "â", "ã", "è", "é", "ê", "ì", "í", "ò", "ó", "ô", "õ", "ù", "ú", "ý", _
                     ChrW(259), ChrW(273), ChrW(297), ChrW(361), ChrW(417), ChrW(432), ChrW(7841), ChrW(7843), _
                     ChrW(7845), ChrW(7847), ChrW(7849), ChrW(7851), ChrW(7853), ChrW(7855), ChrW(7857), ChrW(7859), _
                     ChrW(7861), ChrW(7863), ChrW(7865), ChrW(7867), ChrW(7869), ChrW(7871), ChrW(7873), _
                     ChrW(7875), ChrW(7877), ChrW(7879), ChrW(7881), ChrW(7883), ChrW(7885), ChrW(7887), _
                     ChrW(7889), ChrW(7891), ChrW(7893), ChrW(7895), ChrW(7897), ChrW(7899), ChrW(7901), _
                     ChrW(7903), ChrW(7905), ChrW(7907), ChrW(7909), ChrW(7911), ChrW(7913), ChrW(7915), _
                     ChrW(7917), ChrW(7919), ChrW(7921), ChrW(7923), ChrW(7925), ChrW(7927), ChrW(7929), _
                ChrW(192), ChrW(193), ChrW(194), ChrW(195), ChrW(200), ChrW(201), ChrW(202), _
                ChrW(204), ChrW(205), ChrW(210), ChrW(211), ChrW(212), ChrW(213), ChrW(217), _
                ChrW(218), ChrW(221), ChrW(258), ChrW(272), ChrW(296), ChrW(360), ChrW(416), _
                ChrW(431), ChrW(7840), ChrW(7842), ChrW(7844), ChrW(7846), ChrW(7848), ChrW(7850), _
                ChrW(7852), ChrW(7854), ChrW(7856), ChrW(7858), ChrW(7860), ChrW(7862), ChrW(7864), _
                ChrW(7866), ChrW(7868), ChrW(7870), ChrW(7872), ChrW(7874), ChrW(7876), ChrW(7878), _
                ChrW(7880), ChrW(7882), ChrW(7884), ChrW(7886), ChrW(7888), ChrW(7890), ChrW(7892), _
                ChrW(7894), ChrW(7896), ChrW(7898), ChrW(7900), ChrW(7902), ChrW(7904), ChrW(7906), _
                ChrW(7908), ChrW(7910), ChrW(7912), ChrW(7914), ChrW(7916), ChrW(7918), ChrW(7920), _
                ChrW(7922), ChrW(7924), ChrW(7926), ChrW(7928))
      VNI_Type = Array("a2", "a1", "a6", "a4", "e2", "e1", "e6", "i2", "i1", "o2", "o1", "o6", "o4", "u2", _
                       "u1", "y1", "a8", "d9", "i4", "u4", "o7", "u7", "a5", "a3", "a61", "a62", "a63", _
                       "a64", "a65", "a81", "a82", "a83", "a84", "a85", "e5", "e3", "e4", "e61", "e62", "e63", "e64", _
                       "e65", "i3", "i5", "o5", "o3", "o61", "o62", "o63", "o64", "o65", "o71", "o72", "o73", _
                       "o74", "o75", "u5", "u3", "u71", "u72", "u73", "u74", "u75", "y2", "y5", "y3", "y4", _
    "A2", "A1", "A6", "A4", "E2", "E1", "E6", "I2", "I1", "O2", "O1", "O6", "O4", "U2", _
                       "U1", "Y1", "A8", "D9", "I4", "U4", "O7", "U7", "A5", "A3", "A61", "A62", "A63", _
                       "A64", "A65", "A81", "A82", "A83", "A84", "A85", "E5", "E3", "E4", "E61", "E62", "E63", "E64", _
                       "E65", "I3", "I5", "O5", "O3", "O61", "O62", "O63", "O64", "O65", "O71", "O72", "O73", _
                       "O74", "O75", "U5", "U3", "U71", "U72", "U73", "U74", "U75", "Y2", "Y5", "Y3", "Y4", _
          "E62", "E63", "E64", "E65", "O61", "O62", "O63", "O64", "O65", "O71", "O72", "O73", "O74", _
          "O75", "U71", "U72", "U73", "U74", "U75", "A1", "A2", "A3", "A4", "A5", "A8", "A6", "D9", _
          "E1", "E2", "E3", "E4", "E5", "E6", "I1", "I2", "I3", "I4", "I5", "O1", "O2", "O3", "O4", _
          "O5", "O6", "O7", "U1", "U2", "U3", "U4", "U5", "U7", "Y1", "Y2", "Y3", "Y4", "Y5")
      Telex_Type = Array("af", "as", "aa", "ax", "ef", "es", "ee", "if", "is", "of", "os", "oo", "ox", "uf", _
                         "us", "ys", "aw", "dd", "ix", "ux", "ow", "uw", "aj", "ar", "aas", "aaf", "aar", "aax", _
                         "aaj", "aws", "awf", "awr", "awx", "awj", "ej", "er", "ex", "ees", "eef", "eer", "eex", _
                         "eej", "ir", "ij", "oj", "or", "oos", "oof", "oor", "oox", "ooj", "ows", "owf", "owr", _
                         "owx", "owj", "uj", "ur", "uws", "uwf", "uwr", "uwx", "uwj", "yf", "yj", "yr", "yx", _
                "AF", "AS", "AA", "AX", "EF", "ES", "EE", _
                "IF", "IS", "OF", "OS", "OO", "OX", "UF", _
                "US", "YS", "AW", "DD", "IX", "UX", "OW", _
                "UW", "AJ", "AR", "AAS", "AAF", "AAR", "AAX", _
                "AAJ", "AWS", "AWF", "AWR", "AWX", "AWJ", "EJ", _
                "ER", "EX", "EES", "EEF", "EER", "EEX", "EEJ", _
                "IR", "IJ", "OJ", "OR", "OOS", "OOF", "OOR", _
                "OOX", "OOJ", "OWS", "OWF", "OWR", "OWX", "OWJ", _
                "UJ", "UR", "UWS", "UWF", "UWR", "UWX", "UWJ", _
                "YF", "YJ", "YR", "YX")
    
    Select Case UCase(InputMethod)
        Case Is = "TELEX"
          Temp = Telex_Type
        Case Is = "VNI"
          Temp = VNI_Type
      End Select
      For I = 0 To UBound(VN_Alp)
        VNTyping = Replace(VNTyping, VN_Alp(I), Temp(I))
        VNTyping = Replace(VNTyping, VN_Alp(I), Left(Temp(I), 1) & Mid(Temp(I), 2, Len(Temp(I))))
      Next I
    End Function
    
    '---- Ham UniConvert
    Function UniConvert(ByVal Text As String, ByVal InputMethod As String) As String
      Dim VNI_Type, Telex_Type, CharCode, Temp, I As Long
      'Code goc: ndu
      'Sua loi va them chuyen doi chu HOA: Nguyen Duy Tuan
      UniConvert = Text
      VNI_Type = Array("a81", "a82", "a83", "a84", "a85", "a61", "a62", "a63", "a64", "a65", "e61", _
          "e62", "e63", "e64", "e65", "o61", "o62", "o63", "o64", "o65", "o71", "o72", "o73", "o74", _
          "o75", "u71", "u72", "u73", "u74", "u75", "a1", "a2", "a3", "a4", "a5", "a8", "a6", "d9", _
          "e1", "e2", "e3", "e4", "e5", "e6", "i1", "i2", "i3", "i4", "i5", "o1", "o2", "o3", "o4", _
          "o5", "o6", "o7", "u1", "u2", "u3", "u4", "u5", "u7", "y1", "y2", "y3", "y4", "y5", _
                "A81", "A82", "A83", "A84", "A85", "A61", "A62", "A63", "A64", "A65", "E61", _
                "E62", "E63", "E64", "E65", "O61", "O62", "O63", "O64", "O65", "O71", "O72", "O73", "O74", _
                "O75", "U71", "U72", "U73", "U74", "U75", "A1", "A2", "A3", "A4", "A5", "A8", "A6", "D9", _
                "E1", "E2", "E3", "E4", "E5", "E6", "I1", "I2", "I3", "I4", "I5", "O1", "O2", "O3", "O4", _
                "O5", "O6", "O7", "U1", "U2", "U3", "U4", "U5", "U7", "Y1", "Y2", "Y3", "Y4", "Y5")
      Telex_Type = Array("aws", "awf", "awr", "awx", "awj", "aas", "aaf", "aar", "aax", "aaj", "ees", _
          "eef", "eer", "eex", "eej", "oos", "oof", "oor", "oox", "ooj", "ows", "owf", "owr", "owx", _
          "owj", "uws", "uwf", "uwr", "uwx", "uwj", "as", "af", "ar", "ax", "aj", "aw", "aa", "dd", _
          "es", "ef", "er", "ex", "ej", "ee", "is", "if", "ir", "ix", "ij", "os", "of", "or", "ox", _
          "oj", "oo", "ow", "us", "uf", "ur", "ux", "uj", "uw", "ys", "yf", "yr", "yx", "yj", _
                "AF", "AS", "AA", "AX", "EF", "ES", "EE", _
                "IF", "IS", "OF", "OS", "OO", "OX", "UF", _
                "US", "YS", "AW", "DD", "IX", "UX", "OW", _
                "UW", "AJ", "AR", "AAS", "AAF", "AAR", "AAX", _
                "AAJ", "AWS", "AWF", "AWR", "AWX", "AWJ", "EJ", _
                "ER", "EX", "EES", "EEF", "EER", "EEX", "EEJ", _
                "IR", "IJ", "OJ", "OR", "OOS", "OOF", "OOR", _
                "OOX", "OOJ", "OWS", "OWF", "OWR", "OWX", "OWJ", _
                "UJ", "UR", "UWS", "UWF", "UWR", "UWX", "UWJ", _
                "YF", "YJ", "YR", "YX")
      CharCode = Array(ChrW(7855), ChrW(7857), ChrW(7859), ChrW(7861), ChrW(7863), ChrW(7845), ChrW(7847), _
          ChrW(7849), ChrW(7851), ChrW(7853), ChrW(7871), ChrW(7873), ChrW(7875), ChrW(7877), ChrW(7879), _
          ChrW(7889), ChrW(7891), ChrW(7893), ChrW(7895), ChrW(7897), ChrW(7899), ChrW(7901), ChrW(7903), _
          ChrW(7905), ChrW(7907), ChrW(7913), ChrW(7915), ChrW(7917), ChrW(7919), ChrW(7921), ChrW(225), _
          ChrW(224), ChrW(7843), ChrW(227), ChrW(7841), ChrW(259), ChrW(226), ChrW(273), ChrW(233), ChrW(232), _
          ChrW(7867), ChrW(7869), ChrW(7865), ChrW(234), ChrW(237), ChrW(236), ChrW(7881), ChrW(297), ChrW(7883), _
          ChrW(243), ChrW(242), ChrW(7887), ChrW(245), ChrW(7885), ChrW(244), ChrW(417), ChrW(250), ChrW(249), _
          ChrW(7911), ChrW(361), ChrW(7909), ChrW(432), ChrW(253), ChrW(7923), ChrW(7927), ChrW(7929), ChrW(7925), _
                ChrW(192), ChrW(193), ChrW(194), ChrW(195), ChrW(200), ChrW(201), ChrW(202), _
                ChrW(204), ChrW(205), ChrW(210), ChrW(211), ChrW(212), ChrW(213), ChrW(217), _
                ChrW(218), ChrW(221), ChrW(258), ChrW(272), ChrW(296), ChrW(360), ChrW(416), _
                ChrW(431), ChrW(7840), ChrW(7842), ChrW(7844), ChrW(7846), ChrW(7848), ChrW(7850), _
                ChrW(7852), ChrW(7854), ChrW(7856), ChrW(7858), ChrW(7860), ChrW(7862), ChrW(7864), _
                ChrW(7866), ChrW(7868), ChrW(7870), ChrW(7872), ChrW(7874), ChrW(7876), ChrW(7878), _
                ChrW(7880), ChrW(7882), ChrW(7884), ChrW(7886), ChrW(7888), ChrW(7890), ChrW(7892), _
                ChrW(7894), ChrW(7896), ChrW(7898), ChrW(7900), ChrW(7902), ChrW(7904), ChrW(7906), _
                ChrW(7908), ChrW(7910), ChrW(7912), ChrW(7914), ChrW(7916), ChrW(7918), ChrW(7920), _
                ChrW(7922), ChrW(7924), ChrW(7926), ChrW(7928))
    
    Select Case UCase(InputMethod)
        Case Is = "VNI": Temp = VNI_Type
        Case Is = "TELEX": Temp = Telex_Type
      End Select
      For I = 0 To UBound(CharCode)
        UniConvert = Replace(UniConvert, Temp(I), CharCode(I))
        UniConvert = Replace(UniConvert, UCase(Temp(I)), UCase(CharCode(I)))
      Next I
    End Function

    http://www.giaiphapexcel.com/diendan/threads/h%E1%BB%8Fi-chuy%E1%BB%83n-%C4%91%E1%BB%95i-ch%E1%BB%AF-th%C3%A0nh-k%C3%BD-t%E1%BB%B1.107473/post-686915

    Lúc đầu em hơi ngạc nhiên khi anh hỏi, tưởng anh hỏi chưa ai viết thì anh viết, chứ em nghĩ bài này đâu làm khó được anh–=0

    Nếu người khác đã làm tốt rồi thì mình thừa kế và chỉnh sửa cho phù hợp để đáp ứng công việc cần trước đã chứ cái gì cũng tự làm cực lắm :).

    Chưa hiểu dòng 63 dùng để làm gì vì nhìn thì giống như dòng 62.
    Nếu đã có dòng 123 thì có lẽ không cần chữ hoa trong các mảng.

    Mình lấy code gốc của tác giả và chú tâm sửa lỗi ở mảng mã ký tự nên cũng không chú ý lắm đoạn cuối.
    Với hàm VNTyping có lẽ dòng 63 là thừa.
    Với hàm UniConvert thừa mảng ký tự chữ HOA.

Leave a Reply

Your email address will not be published. Required fields are marked *

Quảng cáo

Cũ vẫn chất

Xem thêm