# GÓC SÁNG TẠO > Khu vực lập trình > Visual Basic >  Các Hàm, Lệnh xây dựng sẵn dùng của VB6.

## daothuhuyen93

Các bạn thân mến. Có ai trong các bạn đã biết hết, và nắm vững các hàm, lệnh do VB6 xây dựng sẵn và cung cấp?? theo tôi nghĩ chắc là không!! Đây là cả một wá trình học hỏi, tìm tòi và đúc kết kinh nghiệm trong khoảng thời gian không phải là ngắn. Riêng bản thân mình, tôi đã từng viết cả trang code để chỉ làm mỗi một việc mà mãi tới mấy tháng sau tôi mới biết : trong Vb có một hàm dùng để làm việc đó với chỉ một dòng !!! Các bạn đã từng bị như tôi chưa?? 
Theo tôi nghĩ bản thân các hàm, lệnh của VB rất mạnh đủ sức cho dân amateur như chúng ta tha hồ wậy với những App be bé xinh xinh...cho.. mình xài , biết càng nhiều, nắm càng vững các hàm của Vb sẽ rút ngắn thời gian cho chúng ta rất nhiều trong thiết kế. 
Nếu cùng một ý nghĩ như tôi xin mời các bạn cùng tôi xây dựng topic nầy thành một kho function và command của vb6 với đầy đủ tham số, công dụng và chú thích rõ ràng để chúng ta tiện tham khảo khi cần. Trước hết cần đưa các hàm, lệnh vào từng mục chủ đề như xử lý chuỗi, số, tiền tệ, date, file....để dễ tra cứu và tránh đụng hàng thành spam với ý nghĩ như vầy và được sự ủng hộ của các bạn chúng ta sẽ làm tiếp với các property, methode của object ( ý nghĩa, công dụng) các api..v .v.. 
Các hàm, lệnh trong VB6 không nhiều bằng các hàm của Api đâu nhưng tôi tin rằng với số lượng thành viên trên 500 người như hiện nay (và còn trong tương lai nữa) đây chỉ là chuyện nhỏ và cả trong tương lai nữa: cũng là chuyện nhỏ. Phải không các bạn. 
Mong được sự ủng hộ của các bạn. 
Thân ái.

*Các hàm xử lý chuỗi*

*Space (Num as Long)* 'trả về chuỗi chỉ toàn khoảng trống với số khoảng trống được ấn định bởi tham số Num
VD: str = space (3) ---> str = " "

*String (Num as Long, character)* 'trả về một chuõi (theo dạng variant) gồm các ký tự lặp lại. Ký tự lặp lại là ký tự đầu của biểu thức chuổi được truyền ở tham số thứ hai của hàm (character). Tham số thứ nhất (Num) xác nhận số lần lặp lại.
VD: str = string (5, "a") 
str = string (5, "abc")
str = string (5, 97) 
cả 3 ví dụ này đều cho ra chuỗi "aaaaa"

*Trim (String)* ' cắt các khoảng trống ở 2 đầu chuỗi
VD: str = Trim (" Yêu em ") ----> str = "Yeu em"

*LTrim (String)* ' cắt các khoảng trống ở đầu chuỗi

*RTrim (String)* ' cắt các khoảng trống cuối chuõi

*Len ( )* ' trả về chiều dài của chuỗi bao gồm các khoảng trống và các ký tự
VD: str = Len ("caulacboVB") ---> str = 10

*Mid (string, start as Long, length)* ' trích từ tham số 1(string) một chuỗi ở vị trí bắt đầu được xác định bởi tham số 2(start), với số ký tự được qui định bởi tham số 3(length). Nếu bỏ wa tham số length thì hàm Mid sẽ trích đến hết chuỗi.
VD: str = Mid ("caulacboVB", 1, 8) ---> str = "caulacbo"

*InStr (start, string1, string2, compare)* ' trả về vị trí bắt đầu của một chuỗi con cần tìm trong một chuỗi mẹ. tham số 1(start) xác định vị trí bắt đầu tìm, tham sô 2(string1) là chuỗi mẹ, tham số 3(string2) là chuỗi cần tìm, tham số 4(compare) mặc định là so sánh nhạy ký tự.
Khi bỏ wa tham số thứ nhất thì vị trí bắt đầu tìm mặc định là 1
VD: pos = InStr ("caulacboVB", "VB") ---> pos = 9 

*InStrRev (StringCheck as string, StringMatch as string, Start as Long, Compare)* ' chức năng như InStr nhưng InStrRev hoạt động ngược lại từ cuối chuỗi và cú pháp khác hơn. Cả hai hàm đều là hàm tìm kiếm nhạy ký tự nên cần chú ý chữ thường và chữ HOA. InStrRev thường kết hơp với Mid để tách một tên File khỏi đường dẫn và tên mở rộng.
VD: 
PathFile = "C:\temp\001.tmp"
Pos = InStrRev (pathFile, "\")
PathFile = Mid (PathFile, Pos + 1)
Pos = InStrRev (PathFile, ".")
PathFile = Mid (PathFile, 1, Pos - 1) --->PathFile = "001"

*Left (String, Length as Long)* ' trích từ đầu một chuỗi của tham số 1(String) với số lượng xác định bởi tham số 2(Length)
VD: str = Left ("caulacboVB", 6) ---> str = "caulac"

*Right (String, Length as Long)* ' như Left nhưng trích ngược từ cuối chuỗi

*Replace (Expression as string, Find as string, Replace as string, start, count, compare)* ' tìm trong tham số thứ 1(Expression) một chuỗi xác định bởi tham số 2(Find) và thay thế bằng một chuỗi được đặt ở tham số 3(Replace). Ba tham số còn lại là tùy chọn. Start qui định vị trí bắt đầu tìm chuỗi cần được thay, nếu bỏ wa mặc định la 1. Count qui định số lần thay thế trong chuỗi, nếu bỏ wa mặc định Replace sẽ tìm và thay thế cho đến hết chuỗi.
VD: str = "bcbcbc"
tmp = Replace (str, "b", "a") ---> str = "acacac"
tmp = Replace (str, "b", "a", 2) ---> str = "cacac"
tmp = Replace (str, "b", "a", 1, 1) ---> str = "acbcbc"

*StrComp (String1, String2, Compare)* ' dùng để so sánh 2 chuỗi.
Trị trả về: (String1 < String2) = -1; (String1 = String2) = 0; (String1 > String2) = 1

*Like* ' so sánh 2 chuỗi cho phép sử dụng biệt ngữ ( như dùng ký tự đại diện trong Dos) trị trả về = True nếu tương hợp
VD: "abcd" Like "*bcd" = True 
"abcd" Like "a?cd" = True
"a1cd" Like "a#cd" = True
Chú ý hàm Like mặc định cũng là hàm nhạy ký tự, theo thiết lập Option Compare ở form hoặc module

*Chr(charcode as Long)* ' Chuyển mã Ascii thành ký tự
VD:
MyChar = Chr(65) ' Returns A.
MyChar = Chr(97) ' Returns a.
MyChar = Chr(62) ' Returns >.
MyChar = Chr(37) ' Returns %.

*Asc(String as String)* ' trả về mã Ascii của ký tự
VD: Asc ("a") = 65

*ChrW(charcode)* ' Chuyển mã Ascii thành ký tự (Hỗ trợ Unicode)
VD: ChrW(&H1EC7) = “ệ”

*AscW (string)* ' Chuyển ký tự thành mã Ascii (hỗ trợ Unicode)
VD: AscW(“ệ”) = 7879 = H1EC7

*LCase(String)* ' chuyển đổi chuỗi sang chữ in thường

*UCase (String)* ' ngược với LCase

*Join (SourceArray, Delimiter)* ' tạo chuỗi mới từ một mảng chuỗi (SourceArray) với các phần tử được phân định bởi tham số Delimiter
VD: Arr (0) = "a"
Arr (1) = "b"
Arr (2)= "c"
Print Join (Arr, " ") = "a b c"

*Split (Expression as String, Delimiter, Count, Compare)* ' tạo mảng chuỗi từ một chuỗi (Expression). Đặt tham số Delimiter để chuyên biệt chỗ ngắt, nếu bỏ wa tham số này mặc định Split sẽ tách tại các khoảng trống của chuỗi. Tham số Count qui định số lần tách. Ba tham số cuối là tùy chọn
VD: Dim str as string, Arr as Variant
str = "cau lac bo vb"
Arr = Split (str) ' dùng For duyệt mảng Arr sẽ cho ra : Arr ( 0 ) = "cau"; Arr ( 1 ) = "lac" ...Arr ( 3 ) = "vb"
Arr = Split (str, "a") ---> Arr (0) = "c"; Arr (1) = "u l"; Arr (2) = "c bo vb"
Arr = Split (str, " ", 2) ---> Arr (0) = "cau"; Arr(1) = "lac bo vb" 

*Filter (sourcearray, match [, include [, compare]])* ' Lọc mảng sourcesrray với giá trị lọc là match ; include: Lọc đảo (True hoặc False) ; compare: chỉ rõ kiểu dữ liệu để so sánh trong quá trình lọc.
_Dùng cho tham số compare_
vbUseCompareOption = –1 : Chế độ tùy chọn, VB sẽ tự động lựa lọai dữ liệu thích hợp
vbBinaryCompare = 0 : So sánh nhị phân
vbTextCompare = 1 : So sánh chuỗi
vbDatabaseCompare = 2 : So sánh dữ liệu
VD:
Dim selNames() As String
Dim Names(1 To 5) As String
Names(1) = "A"
Names(2) = "B"
Names(3) = "C"
Names(4) = "D"
Names(5) = "E"
selNames = Filter(Names, "A") ' Returns "A"
selNames = Filter(Names, "B", False) 'Returns "A" , "C", "D", "E"

*StrReverse(expression as String)* ' Đảo chuỗi expression
VD: StrReverse("1234567") ' Returns "7654321"
*Các lệnh và hàm xử lý thư mục, tập tin*
VB có 6 lệnh tương tác trực tiếp với hệ điều hành:

*ChDrive (Drive as String)* ' thay đổi ổ đĩa đăng nhập đối với hệ điều hành nền
VD: ChDrive ("D:\")

*ChDir (Path as String)* ' thay đổi thư mục hiện hành
VD: ChDir ("C:\Windows\Temp") 

*MkDir (Path as String)* ' tạo mới thư mục
VD: MkDir ("C:\MyDir") ' tạo mới thư mục MyDir trên ổ C 

*RmDir ("Path as String")* ' loại bỏ một thư mục
VD: RmDir ("C:\MyDir")

*Name [Source] As [Dest]* ' đổi tên và di chuyển tập tin
VD: Name "C:\myFile.txt" As "D:\FileChua.txt" sẽ move tập tin myFile.txt từ C:\ đến D:\ với tên mới: FileChua.txt

*Kill (PathName as String)* ' xoá tập tin với tham số PathName chấp nhận ký tự đại diên (như Dos)
VD: Kill ("C:\*.txt") sẽ xoá tất cả tập tin có phần mở rộng là txt trong thư mục gốc của ổ C

---------------------------------------------------------------------------------------

Ôn lại một chút về khái niệm "hiện hành" có từ thời của Dos để hiểu rõ hơn về 6 lệnh này của Vb vì thực sự chúng rất mạnh.
Ví dụ khi file thực thi của bạn nằm tại "C:\MyDir\MyFile.exe" thì lệnh MkDir ("NewDir") sẽ tạo mới một Path: "C:\MyDir\NewDir" tức là thư mục NewDir nằm cùng cấp với MyFile.exe. Nhưng nếu trước đó có câu lệnh ChDir ("C:\Windows") thì lệnh trên sẽ tạo Path: "C:\Windows\NewDir". Tương tự như vậy với lệnh ChDrive. Quan trọng là bạn phải biết "mình đang ở đâu?" bằng không với câu lệnh không chỉ rõ Path: Kill (*.*) sẽ bụp sạch các File không mong muốn nếu trước đó đã xài ChDir mà quên.

---------------------------------------------------------------------------------------

*CurDir (Drive)* ' trả về một chuỗi với tên đầy đủ của ổ đĩa hiện hành nếu tham số Drive để trống ( )
VD: 
CurDir ( ) ---> tên ổ đĩa hiện hành
CurDir ( "D") ---> tên đầy đủ "D:\"
CurDir ("X") ---> sẽ báo lỗi nếu hệ thống không có tới ổ thứ X này

*Dir (PathName, Attributes)* ' tìm kiếm tập tin với đường dẫn đặt tại tham số 1. Tham số 2(Attributs) tùy chọn để chuyên biệt thuộc tính tìm kiếm. Mặc định la vbNormal
VD: 
tmp = Dir ("C:\boot.ini") ---> tmp = ""
tmp = Dir ("C:\boot.ini", vbHidden) ---> tmp = "boot.ini"

*FileCopy (Source as String, Destination as String)* ' sao chép tập tin từ đường dẫn nguồn (Source) đến đường dẫn khác (Destination)
VD:
Filecopy "C:\Config.sys", "D:\Config.sys"

*Filelen (PathNam As String) As Long* ' trả về kích thước của tập tin

*FileDateTime (PathName as string)* ' trả về ngày tháng và thời gian tập tin đã được tạo ra hoặc được chỉnh sữa lần gần nhất.
VD:
Msgbox FileDateTime ("C:\Config.sys")

*GetAttr (PathName as String) as Integer* ' trả về một số nguyên là trị thuộc tính của File
Các hằng thuộc tính gồm:
vbNormal = 0
vbReadOnly = 1
vbHiden = 2
vbSystem = 4
vbVolume = 8
vbDirectory = 16
vbArchive = 32

VD:
GetAttr "C:\boot.ini" = 35 (file Boot.ini mang các thuộc tính sau: ReadOnly(1) + Hiden(2) + Archive(32)

*SetAttr (PathName as String, Attributes as vbFileAttribute)* ' Xác lập thông tin thuộc tính của File. Sử dụng các hằng thuộc tính hoặc các giá trị ở bảng trên cho tham số Attributes
VD:
SetAttr "C:\Boot.ini, 0" ---> xác lập file boot.ini chỉ mang một thuộc tính là Normal
SetAttr "C:\Boot.ini,3" ---> xác lập boot.ini mang thuộc tính chỉ đọc và ẩn.

*FreeFile* ' trả về một số integer là chỉ số (ID) để HDH theo dõi và quản lý các file đang mở (Open). Dùng một biến nguyên để lưu giá trị này dùng cho các cuôc gọi lệnh Open (file). Khi đó ta không cần quan tâm đến các chỉ số(ID) này nữa. FreeFile sẽ theo dõi và cung cấp cho ta các chỉ số(ID) chưa dùng.
VD:
Dim Filenum#
FileNum = FreeFile
Open [PathName] For Output As #Filenum

*Open [PathName as String] For [Mode] As [ID File]* ' Mỗi khi thấy lệnh Open, VB sẽ sẵn sàng cho các thao tác đọc và ghi lên File được cung cấp ở tham số [PathName]. Có năm chế độ mở tập tin được đặt ở tham số [Mode], và [ID File] dĩ nhiên là chỉ số của tập tin đang mở.
Các dạng thức cơ bản của lệnh Open:
_Open [Pathname] For Input As Filenum_ ' mở File và chỉ đọc được thông tin, không ghi lên được.
_Open [PathName] For Output As Filenum_ ' mở File để xuất thông tin. Khi được mở theo dạng này mọi thông tin cũ trên File sẽ bị mất.
_Open [PathName] For Append As Filenum_ ' mở File để đọc và ghi tiếp lên được.
_Open [PathName] For Random As Filenum_ ' mở và truy cập ngẫu nhiên các bản ghi và các trường trên File (phải biết được cấu trúc của các bản ghi)
_Open [PathName] For Binary As Filenum_ ' đọc ghi theo Byte. Đây là dạng tổng quát và linh hoạt nhất.

*Input [Number, #Filenum]* ' đọc nội dung File với số lượng xác định ở tham số Number
VD: Str = Input (10, #Filenum) ' đọc 10 ký tự vào biến Str.
Dạng khác của Input:
*Input [#Filenum, Str]* ' ở đây biến Str thường ở dạng Variant

*Line Input [#FileNum, Str]* ' đọc thông tin theo từng dòng vào biến Str. Thường kết hợp với hàm EOF để lấy hết thông tin

*EOF (Filenum)* ' trả về vị trí chấm dứt của File khi đang mở
VD:
Do While Not EOF (Filenum) ' lập nếu không phải ở end of file
Line Input #Filenum, Str ' đọc từng dòng vào biến Str
Loop

*LOF (Filenum)* ' trả về kích thước của File khi đang mở.
VD:
Str = Input (LOF(Filenum), #Filenum) ' sẽ lấy hết nội dung của File (không nên sử dụng với File có kích thước vài Mb sẽ bị lỗi "out of memory")

*Write [#Filenum, Expression]* ' ghi lên File
VD:
Write #FileNum, "12345" ---> "12345"
Write #Filenum, 12345 --->12345

*Print [#Filenum, Expression]* ' làm việc chính xác như khi Print lên Form
VD: 
Print #Filenum, 123; 456 ---> 123 456

*Get [#Filenum, position, ByteArray]* ' lấy thông tin từ tập tin được mở theo Binary tại vị trí xác định bởi Position và lưu vào ByteArray. Số byte lấy ra tùy thuộc vào kích thước của mảng ByteArray. Mỗi khi lấy ra 1 byte con trỏ tập tin tự động chuyển tới vị trí byte kế tiếp.
VD:
Dim Str as String * 4
Get #Filenum, 3, Str ---> lấy 4 byte bắt đầu từ byte thứ 3 lưu vào Str.
(nếu có câu lệnh Get tiếp theo mà tham số Position bỏ trống, thì vị trí bắt đầu lấy ra sẽ là byte thứ 8)

*Loc (#Filenum)* ' Trả về vị trí byte đọc/ghi hiện tại trong tập tin đang mở.

*Seek [#Filenum, Position]* ' dịch chuyển con trỏ tập tin đến vị trí qui định bởi tham số Position
VD:
Seek #Filenum, 3
Get #Filenum, , Str ---> vị trí lấy ra sẽ bắt đầu tại byte thứ 3

*Seek (#Filenum)* ' trả về vị trí hiện tại của con trỏ tập tin

*Put [#Filenum, Position, ByteArray]* ' đặt nội dung của mảng ByteArray vào vị trí byte thứ[Position].
Lệnh Put se ghi đè lên mọi thứ và chỉ dùng cho truy cập Random và Binary
VD: Put #filenum, , Str ---> sẽ ghi 4 byte bắt đầu ở vị trí byte thứ 1

*Reset* ' Đóng tất cả các tập tin đã được mở bằng lệnh Open

Số dòng Bật/Tắt | Mở rộng/Thu gọn | Chọn tất cả
<LI Explicit <LI Sub Form_Load() <LI FileNumber <LI For FileNumber = 1 To 5 <LI Open "TEST" & FileNumber For Output As #FileNumber ' Mở file <LI Write #FileNumber, "Hello World" ' Ghi dữ liệu vào file. <LI Next FileNumber <LI Reset ' Đóng file và cập nhật dữ liệu vào fileEnd Sub




*Close (#Filenum)* ' Đóng tập tin đã được mở bằng lệnh Open.

*Lock [#Filenum, Expression]* ' khoá tập tin không cho người khác truy cập khi App của bạn đang mở. Tham số thứ hai chuyên biệt vị trí khoá. Nếu bỏ qua tham số tùy chọn này, lệnh Lock sẽ khoá toàn bộ tập tin. Đối với các tập tin mở theo truy cập tuần tự lệnh Lock sẽ khoá toàn bộ tập tin bất kể khoảng do tham số 2 qui định.
VD:
Lock #Filenum, 1 To 100 ---> sẽ khoá 100 byte từ byte thứ 1

*Unlock [#Filenum, Expression]* ' mở khoá tập tin, tham số sử dụng như Lock.

Chú ý: cần bảo đảm loại bỏ tất cả các khoá với câu lệnh Unlock tương ứng trước khi đóng tập tin hoặc thoát khỏi chương trình(các đối số phải tương hợp chính xác). Nếu không tập tin có thể bị rối loạn.

---------------------------------------------------------------------------------------

Để điều khiển sự chia sẽ tập tin vào thời gian bạn mở tập tin. Có thể dùng câu lệnh tổng quát nhất của lệnh Open
Cú pháp:
*Open PathName [For mode] [Access access] [Lock] As #Filenum [Len=reclength]* ' trong đó:

PathName là chuỗi chứa đường dẫn đến tập tin

Mode là từ khoá chuyên biệt chế độ tập tin như Input, Append, Random...

Access là từ khoá chuyên biệt các thao tác được phép trên tập tin mở. Có ba thao tác: Read, Write, ReadWrite VD:Open PathName For Binary Access Read As #Filenum --> cho phép bạn đọc nhưng không cho phép thực hiện các thay đổi đối với tập tin.

Lock là từ khoá chuyên biệt các thao tác được phép trên tập tin mở đối với các quá trình khác.
Khác với Access : điều khiển cách thức chương trình bạn làm việc với tập tin. Với từ khoá Lock có bốn khả năng:
1- [Shared] các quá trình khác có thể đọc và viết vào tập tin mặc dù chương trình của bạn đang làm việc với tập tin đó.
2- [LockRead] chương trình khác không thể mở để đọc tập tin, trong khi chương trình của bạn đang làm việc với tập tin đó.
3- [LockWrite] không thể mở để viết lên tập tin trong khi chương trình bạn đang làm việc với tập tin đó.
4- [LockReadWrite] chương trình khác không thể làm việc với tập tin trong khi chương trình bạn đang làm việc với tập tin đó.
VD: Open PathName For binary Access Lock Read #Filenum ---> sẽ ngăn chận các chương trình khác sử dụng tập tin khi bạn đang làm việc với tập tin đó.

Reclength đây là số nguyên từ 1 đến 32767. Đối các tập tin mở ở chế độ Random số này đưa ra chiều dài bản ghi. Đối với các tập tin chuỗi thứ tự, giá trị này là số lượng các ký tự đươc đệm trong hệ điều hành.
---------------------------------------------------------------------------------------
*Tài liệu sưu tầm được*

----------

