Gioi Thieu Perl

Xử lý chuỗi trong Perl

Lời mở đầu

Cùng với sự phát triển của công nghệ thông tin là sự phát triển của các ngôn ngữ lập trình. Hiện tại có rất nhiều ngôn ngữ lập trình khác nhau với các đặc điểm khác nhau, được thiết kế cho một vài mục đích đặc biệt nào đó. Ví dụ, Assembly được thiết kế để máy tính trở nên thân thiện hơn với người sử dụng, Pascal được sử dụng làm công cụ dạy lập trình, C++, Java là các ngôn ngữ hướng đối tượng, ….Do đó trong lập trình, có một câu hỏi đơn giản nhưng bao giờ cũng có giá trị là: nên chọn công cụ nào cho phù hợp với công việc cần làm. Ví dụ như khi viết các chương trình truy cập đến các cấp thấp của máy tính, bạn nên dùng Assembly. Ở các chương trình đơn giản, nếu lập trình cấu trúc hay hướng đối tượng thì chỉ thêm mất thời gian. Nhưng cũng có những chương trình yêu cầu bạn phi lập trình hướng đối tượng ví dụ như tạo hệ cửa sổ giao tiếp đồ họa.

Vậy khi bạn muốn quản trị hệ thống, xử lý các trang Web, xử lý văn bản thì bạn sẽ dùng ngôn ngữ nào? Ngôn ngữ đó chính là Perl. Nó có khả năng chắt lọc một lượng lớn dữ liệu, xử lý dữ liệu để thu được kết quả cần tìm. Đó cũng là lý do nhóm em chọn đề tài:

Tìm hiểu các hàm xử lý chuỗi của ngôn ngữ Perl.

Bên cạnh đó chúng em sẽ đi xây dựng lại một số hàm đó cho các ngôn ngữ khác.

Trong quá trình tìm hiểu chắc chắn không tránh được những thiếu sót, nhóm chúng em mong thầy và các bạn cho ý kiến đóng góp để bài làm được hoàn thiện hơn.

Chúng em xin chân thành cảm ơn!

Hà Nội, 03/2009

Nhóm sinh viên thực hiện

1


MỤC LỤC

Chương 1: Mở đầu................................................................................................2I. Lịch sử:..........................................................................................................3I.1. Tên gọi:.......................................................................................................3

I.2. Biểu tượng:..............................................................................................3II. Mục đích:......................................................................................................3

Chương 2: Xâu......................................................................................................4I. Xâu:................................................................................................................4

I.1 Xâu dấu nháy đơn....................................................................................5I.2 Xâu dấu nháy kép.....................................................................................5I.3. Toán tử xâu.............................................................................................7

Chương 3: Biểu thức chính quy............................................................................81. Khái niệm......................................................................................................82. Cách dùng......................................................................................................93. Khuôn mẫu..................................................................................................10

3.1 Khuôn mẫu một ký tự............................................................................103.2 Khuôn mẫu nhóm..................................................................................113.3. Neo.......................................................................................................143.4 Thứ tự ưu tiên........................................................................................15

4. Các toán tử đối sánh khác............................................................................165. Thay thế.......................................................................................................18

Chương 4: Các hàm xử lý chuỗi cơ bản..............................................................20I. Chop.............................................................................................................20II. Chomp.........................................................................................................23III. hàm hex.....................................................................................................29IV. hàm INDEX..............................................................................................35V-hàm LC........................................................................................................39VI. hàm LCFIRT.............................................................................................41VII. hàm rindex...............................................................................................43VIII. hàm substr...............................................................................................46IX. hàm uc.......................................................................................................50

Chương 5: Xây dựng lại một số hàm xử lý chuỗi trong Pascal...........................52

Chương 1: Mở đầu

2


Perl (viết tắt của Practical Extraction and Report Language – ngôn ngữ kết xuất và báo cáo thực dụng) được Larry Wall xây dựng từ năm 1987, với mục đích chính là tạo ra một ngôn ngữ lập trình có khả năng chắt lọc một lượng lớn dữ liệu và cho phép xử lý dữ liệu nhằm thu được kết quả cần tìm.

Perl là ngôn ngữ thông dụng trong lĩnh vực quản trị hệ thống và xử lý các trang Web do có các ưu điểm sau:

Có các thao tác quản lý tập tin, xử lý thông tin thuận tiện.

Thao tác với chuỗi ký tự rất tốt.

Đã có một thư viện mã lệnh lớn do cộng đồng sử dụng Perl đóng góp (CPAN).

Cú pháp lệnh của Perl khá giống với C, từ các ký hiệu đến tên các hàm, do đó, nhiều người (đã có kinh nghiệm với C) thấy Perl dễ học. Perl khá linh hoạt và cho phép người sử dụng giải quyết với cùng một vấn đề được đặt ra theo nhiều cách khác nhau.

I. Lịch sử:

Wall bắt đầu thiết kế Perl vào năm 1987 lúc đang làm lập trình viên cho Unisys và cho ra đời phiên bản 1.0 trên comp.sources.misc vào ngày 18 tháng 12 năm 1987. Ngôn ngữ được mở rộng một cách nhanh chóng vài năm sau đó. Phiên bản 2 của Perl, được công bố năm 1988, có tính năng tốt hơn cho biểu thức chính qui. Phiên bản 3 , công bố năm 1989, với hỗ trợ cho các dữ liệu dạng nhị phân.

Cho đến năm 1991, trang man là tài liệu duy nhất của Perl. Năm 1991, cuốn sách Programming Perl đã được xuất bản và trở thành cuốn cẩm nang tra cứu của ngôn ngữ Perl. Cùng lúc đó, phiên bản 4 ra đời, đánh dấu sự thay đổi quan trọng của ngôn ngữ, và là phiên bản đầu tiên được viết trong sách.

I.1. Tên gọi:

Ban đầu, ngôn ngữ này có tên là "Pearl" (ngọc trai), được đặt tên theo "Parable of the Pearl" trong sách phúc âm. Larry đã bỏ nhiều công sức tìm kiếm tên cho ngôn ngữ mới. Ông đã thử xem xét (và bỏ qua) tất cả các từ 3,4 ký tự trong tự điển. Cuối cùng, ông đã đặt tên Pearl. Nhưng trước ngày phiên bản chính thức đầu tiên của Perl ra đời, Larry phát hiện ra đã có một ngôn ngữ cũng có tên là PEARL, nên ông quyết định đổi tên ngôn ngữ mình thành Perl.

3


Ngày nay, Perl trở thành tên chính thức của một trong những ngôn ngữ thông dịch mạnh mẽ được nhiều người sử dụng trên thế giới.

I.2. Biểu tượng:

Programming Perl, xuất bản bởi O'Reilly Media, đã đưa ra nơi trang bìa bức ảnh 1 con lạc đà. Từ đó, lạc đà trở thành biểu tượng của ngôn ngữ Perl, cũng như quyển sách đó còn được biết đến dưới cái tên The Camel Book.

II. Mục đích:

PERL được coi là một ngôn ngữ mạnh mẽ trong việc quản trị hệ thống UNIX, quản lý website trên mạng Word Wide Web và xử lý văn bản. Nó trở nên đặc biệt hữu ích cho những lập trình viên muốn có một ngôn ngữ dễ dàng sử dụng, mạnh mẽ và nhanh chóng

Có thể nói PERL ra đời đáp ứng được những yêu cầu của con người về một loại ngôn ngữ kịch bản đa năng phục vụ trong việc quản trị hệ thống, bởi đây chính là một trong những ngôn ngữ lập trình có tính truyền đạt đơn giản, dễ hiểu, được miêu tả bằng một ngôn ngữ kỹ thuật chi tiết. Càng ngày, PERL càng khẳng định vị trí của nó như là loại ngôn ngữ ngữ pháp cơ bản trong việc xử lý văn bản cấp cao.

Perl được thiết kế để trợ giúp cho người dùng Unix với những nhiệm vụ thông dụng mà có thể rất nhậy cảm với tính khả chuyển đối với trình shell, vì nó ngắn hơn và không phức tạp như các ngôn ngữ lập trinh C hay một ngôn ngữ công cụ Unix nào khác.

Khi đã quen thuộc với Perl, bạn sẽ mất ít thời gian để lấy được các trích dẫn dòng lệnh shell (hay khai báo C), và mất ít thời gian để lập trình vì Perl là một công cụ trợ giúp tuyệt vời. Các cấu trúc chặt chẽ của Perl cho phép tạo ra một số giải pháp với những công cụ mang tính tổng quát. Cũng vậy, bạn có thể lấy những công cụ này sang công việc tiếp, vì Perl có tính khả chuyển cao và lại có sẵn trên các hệ thống khác.

Giống như mọi ngôn ngữ khác, Perl có thể “chỉ viết” - tức là có thể viết ra chương trình cho máy hiểu mà con người không thể "đọc hiểu" được. Nhưng nếu chú ý cẩn thận, bạn có thể tránh được điều này. Thật vậy, đôi khi Perl trông như khó với những ai không quen, nhưng với người lập trình đã thạo Perl, nó cũng... khá dễ (???).

4

http://vi.wikipedia.org/w/index.php?title=O'Reilly_Media&action=edit&redlink=1


Chương 2: Xâu

I. Xâu:

Xâu là một dãy các kí tự (như Xin chào). Mỗi kí tự đều là một giá trị 8-bit trong toàn bộ tập 256 kí tự (không có gì đặc biệt về kí tự NULL như trong C).

Xâu ngắn nhất có thể được là xâu rỗng-không có kí tự nào. Xâu dài nhất thì chiếm trọn bộ nhớ máy tính (mặc dầu bạn sẽ chẳng thể nào làm gì nhiều với nó cả). Điều này phù hợp với nguyên lí "không có giới" mà Perl cung cấp cho bạn. Các xâu điển hình là các dẫy in được gồm các chữ, số và dấu ngắt trong phạm vi ASCII 32 tới ASCII 126. Tuy nhiên, khả năng để có bất kì kí tự nào từ 0 tới 255 trong một xâu có nghĩa là bạn có thể tạo ra, 'nhòm' qua, và thao tác dữ liệu nhị phân thô như các xâu - một cái gì đó mà phần lớn các trình tiện ích UNIX khác sẽ gặp khó khăn lớn. (chẳng hạn, bạn có thể 'vá lỗi' UNIX bằng việc đọc nó vào trong xâu Perl, tiến hành thay đổi, và ghi lại kết quả).

Giống như số, xâu có thể biểu diễn hằng kí hiệu (cách thức bạn biểu diễn xâu trong chương trình Perl). Các xâu hằng kí hiệu có theo hai hướng: xâu nháy đơn và xâu nháy kép.

I.1 Xâu dấu nháy đơn

Xâu dấu nháy đơn là một dẫy các kí tự được bao trong dấu nháy đơn ('). Dấu nháy đơn không phải là một phần của bản thân xâu - chúng chỉ có đó để Perl xác định chỗ bắt đầu và kết thúc của xâu. Bất kì kí tự nào nằm giữa các dấu nháy (kể cả dấu xuống dòng, nếu xâu vẫn còn tiếp tục sang dòng sau) đều là hợp pháp bên trong xâu. Hai ngoại lệ: để lấy được một dấu nháy đơn trong một xâu có nháy đơn, bạn hãy đặt trước nó một dấu sổ chéo ngược. Và để lấy được dấu sổ chéo ngược trong một xâu có nháy đơn, bạn hãy đặt trước dấu sổ chéo ngược nột dấu sổ chéo ngược nữa. Ví dụ:

'hello' #năm kí tự: h, e, l, l, o

'don\'t' #năm kí tự: d, o, n, nháy đơn, t

'' #xâu rỗng (không có kí tự)

'silly\\me' #silly, theo sau là một sổ chéo ngược, sau là me

"hello\n' #hello theo sau là sổ chéo ngược và n

'hello

there' #hello, xuống dòng, there (toàn bộ 11 kí tự)

5


Chú ý rằng \n bên trong môt xâu có nháy đơn thì không được hiểu là dòng mới, nhưng nếu là hai kí tự sổ chéo ngược thì khác (chỉ khi sổ chéo ngược đi theo sau bởi một sổ chéo ngược khác hay một dấu nháy đơn thì mới mang nghĩa đặc biệt).

I.2 Xâu dấu nháy kép

Xâu dấu nháy kép hành động hệt như xâu trong C. Một lần nữa, nó lại là dãy các kí tự, mặc dầu lần này được bao bởi dấu ngoặc kép. Nhưng bây giờ dấu sổ chéo ngược lấy toàn bộ sức mạnh của nó để xác định các kí tự điều khiển nào đó, hay thậm chí bất kì kí tự nào qua các biểu diễn hệ tám hay hệ mười sáu. Đây là một số xâu dấu nháy kép:

"hello world\n" # hello world, và dấu xuống dòng

"new \177" # new, dấu cách và kí tự xoá (177 hệ tám)

"coke\tsprite" # coke, dấu tab, và sprite

Dấu sổ chéo có thể đứng trước nhiều kí tự khác nhau để hàm ý những điều khác nhau (về điển hình nó được gọi là lối thoát sổ chéo). Danh sách đầy đủ của các lối thoát xâu nháy kép được cho trong Bảng 2-1.

Bảng I-1 Dấu sổ chéo ngược trong xâu nháy kép

Kết cấu Ý nghĩa

\n xuống dòng mới

\r về đầu dòng

\t ký tự tab

\f báo hết trang

\b xoá lui 1 ký tự

\a phát 1 tiếng "bíp"

\e escape

\007 ký tự ASCII ở hệ tám (007=bíp)

\0x7f ký tự ASCII ở hệ mười sáu (7f=delete)

\cC ký tự điều khiển (ở đây là Ctrl-C)

6


\\ dấu sổ chéo ngược

\" dấu nháy kép

\l ký tự tiếp theo sẽ chuyển thành chữ thường

\L tất cả các ký tự tiếp theo cho tới \E sẽ thành chữ thường

\u ký tự tiếp theo sẽ chuyển thành chữ hoa

\U tất cả các ký tự tiếp theo cho tới \E sẽ thành chữ hoa

\E kết thúc \L hay \U

Một tính năng khác của xâu nháy kép là ở chỗ chúng cho phép chen lẫn các biến, nghĩa là một số tên biến nào đó bên trong xâu được thay thế bởi giá trị hiện tại của chúng khi xâu được dùng. Chúng ta đã không được giới thiệu một cách chính thức là các biến trông như thế nào (ngoại trừ trong phần mở đầu trên), cho nên tôi sẽ quay lại vấn đề này sau.

I.3. Toán tử xâu

Các giá trị xâu có thể được ghép với toán tử chấm (.) (đó là dấu chấm đơn). Điều này không làm thay đổi xâu, cũng như 2+3 không làm thay đổi 2 hay 3. Nhưng kết quả trả về là một xâu ghép (theo thứ tự) của 2 xâu thành phần, vậy là có sẵn cho tính toán thêm hay được cất giữ trong một biến:

"hello" . "world" # tương tự như "helloworld"

'hello world' . "\n" # hệt như "hello world\n"

"jerry" . " " . "tom" # hệt như "jerry tom"

Chú ý rằng việc ghép nối phải được gọi tường minh tới toán tử ., không giống awk là bạn đơn thuần chỉ việc đặt hai xâu gần nhau.

Một tập các toán tử cho xâu khác là toán tử so sánh xâu. Các toán tử này đều tựa FORTRAN, như lt thay cho bé hơn...Các toán tử so sánh các giá trị ASCII của các kí tự của xâu theo cách thông thường. Tập đầy đủ các toán tử so sánh (cho cả số và xâu) được nêu trong Bảng I-2.

Bảng I-2. Các toán tử so sánh số và xâu

Phép so sánh Số Xâu

Bằng == eq

7


Không bằng != ne

Bé hơn < lt

Lớn hơn > gt

Bé hơn hay bằng <= le

Lớn hơn hay bằng >= ge

Bạn có thể tự hỏi tại sao lại có các toán tử phân tách cho số và xâu vậy, nếu số và xâu được tự động chuyển đổi lẫn cho nhau? Ta hãy xét hai giá trị 7 và 30. Nếu được so sánh như số thì 7 hiển nhiên bé hơn 30, nhưng nếu được so sánh theo xâu, thì xâu "30" sẽ đứng trước xâu "7" (vì giá trị ASCII của 3 thì bé hơn giá trị ASCII của 7), và do đó là bé hơn. Cho nên, không giống awk, Perl đòi hỏi bạn xác định đúng kiểu so sánh, liệu đó là số hay xâu.

Chú ý rằng các phép so sánh số và xâu về đại thể ngược với những điều xẩy ra cho chỉ lệnh test của UNIX, mà thường dùng kí hiệu -eq để so sánh số còn = để so sánh xâu.

Vẫn còn một toán tử xâu khác là toán tử lặp lại xâu, bao gồm một kí tự chữ thường đơn giản x. Toán tử này lấy toán hạng trái của nó (một xâu), và thực hiện nhiều việc ghép bản sao của xâu đó theo số lần do toán hạng bên phải chỉ ra (một số). Chẳng hạn:

"jerry" x 3 # là "jerryjerryjerry"

"tom" x (4+1) # là "tom" x 5 hay "tomtomtomtomtom"

(3+2) x 4 # là 5 x 4, hay thực sự là "5" x 4, là "5555"

Nhưng toán tử lặp lại xâu cần một xâu cho toán hạng bên trái, cho nên số 5 được chuyển thành xâu "5" (dùng các qui tắc sẽ được mô tả chi tiết về sau), thành xâu một kí tự. Xâu mới này rồi được sao lên bốn lần, cho xâu bốn kí tự 5555. Chú ý rằng nếu ta đảo ngược trật tự các toán hạng, thì ta sẽ làm năm bản sao của xâu 4, cho 44444. Điều này chỉ ra rằng việc lặp lại xâu là không giao hoán.

Số đếm bản sao (toán hạng bên phải) trước hết sẽ bị chặt đi để cho giá trị nguyên (4.8 trở thành 4) trước khi được sử dụng. Số đếm bản sao bé hơn một sẽ gây ra kết quả là xâu rỗng (chiều dài không).

8


Chương 3: Biểu thức chính quy

1. Khái niệm.

Biểu thức chính quy là một khuôn mẫu (một tiêu bản) để được sánh với một xâu. Việc sánh một biểu thức chính quy với một xâu có thể thành công hoặc thất bại. Sau này, bạn có thể sẽ muốn lấy 1 BTCQ đã sánh đúng và thay thể nó bằng một xâu khác, nó có thể phụ thuộc vào cách thức và vị trí mà BTCQ được sánh đúng. BTCQ thường được dùng nhiều trong các chương trình UNIX, như grep, sed awk, ed, vi, emacs… Bất kỳ BTCQ nào có thể được viết trong UNIX thì cũng có thể được dùng trong Perl.

2. Cách dùng.

Nếu ta cần tìm tất cả các dòng của một tệp có chứa xâu abc, thì ta có thể dùng lệnh grep:

grep abc somefile>result

Trong biểu thức trên, abc là BTCQ mà lệnh grep lấy để kiểm tra cho từng dòng đưa vào. Những dòng so sánh đúng sẽ được đưa ra (ở đây kết quả sẽ được ghi vào tệp result).

Trong perl, ta có thể nói về xâu abc như 1 biểu thức chính quy bằng việc bao xâu này trong 2 dấu sổ chéo:

if (/abc/) {print “$_”;

}

Khi 1 BTCQ được bao trong 2 dấu sổ chéo như ví dụ trên thì biến $_ sẽ được kiểm tra theo biểu thức chính quy đó. Nếu BTCQ so sánh đúng thì toán tử so sánh sẽ trả về giá trị đúng, ngược lại nó trả về giá trị sai.

Giả sử $_ có chứa một dòng văn bản nào đó, và được in ra nếu trong dòng văn bản này có chứa các ký tự abc. Tuy nhiên, đoạn chương trình này chỉ xử lý trên một dòng. Để nó làm việc trên tất cả các dòng, ta thêm vào một chu trình, ví dụ:

While (<>) {

If (/abc/) {

Print “$_”;

9


}

}

Nếu ta không biết được số lượng các ký tự b nằm giữa a và b (tức là số lượng ký tự b có thể là một hoặc nhiều hơn). Khi dùng grep ta viết:

Grep “ab*c” somefile>result

Trong Perl, ta có thể làm tương tự như sau:

While (<>) {

If (/ab*c/) {

Print “$_”;

}

}

/ab*c/ - có nghĩa là có thể có nhiều ký tự b nằm giữa 1 ký tự a và 1 ký tự c.

Một toán tử BTCQ nữa là toán tử thay thế, làm việc thay thế một phần của xâu mà sánh đúng BTCQ bằng một xâu khác. Toán tử thay thế giống như chỉ lệnh s trong sed, bao gồm một chữ s, 1 sổ chéo, 1 BTCQ, 1 sổ chéo, 1 xâu thay thế, và một sổ chéo cuối cùng. Ví dụ: s/ab*c/def/;

Xâu (trong trường hợp này là biến $_) được đem ra đối sánh với BTCQ (ab*c). Nếu việc đối sánh thành công thì phần xâu sánh đúng sẽ bị loại ra và được thay thế bằng xâu thay thế (def). Nếu việc đối sánh không thành công thì không có gì xảy ra cả.

3. Khuôn mẫu.

Một BTCQ là một khuôn mẫu. Một số khuôn mẫu có thể dùng để sánh với một ký tự trong xâu thuộc kiểu đặc biệt hoặc đa ký tự.

3.1 Khuôn mẫu một ký tự.

Kí tự sánh mẫu đơn giản nhất và thông dụng nhất trong các biểu thức chính qui là một kí tự sánh với chính nó. Nói cách khác, đặt một chữ a vào trong biểu thức chính qui đòi hỏi một chữ tương ứng a trong xâu.

Kí tự sánh mẫu thông dụng nhất tiếp đó là dấu chấm (.). Dấu chấm đối sánh bất kì kí tự riêng lẻ nào ngoại trừ dấu xuống dòng mới (\n). Chẳng hạn,

10


khuôn mẫu /a./ đối sánh bất kì dãy hai kí tự nào bắt đầu bằng a và không phải là a\n.

Lớp kí tự sánh mẫu được biểu diễn bởi cặp dấu ngoặc vuông mở và đóng, và một danh sách các kí tự nằm giữa hai dấu ngoặc này. Một và chỉ một trong các kí tự này phải hiện diện tại phần tương ứng của xâu cần sánh mẫu. Chẳng hạn, /[abcde]/ sẽ sánh đúng với bất kì một trong năm chữ đầu tiên của bảng chữ thường, trong khi /[aeiouAEIOU]/ lại sánh với bất kì năm nguyên âm hoặc chữ thường hoặcchữ hoa. Nếu bạn muốn đặt dấu ngoặc vuông phải (]) vào danh sách thì hãy đặt một sổ chéo ngược ở trước nó (ví dụ \]), hay đặt nó như kí tự đầu tiên bên trong danh sách.

Phạm vi của các kí tự (như a tới z) có thể được viết tắt bằng việc chỉ ra những điểm cuối của phạm vi được tách biệt bởi dấu gạch ngang (-); để có được hằng kí hiệu gạch ngang, bạn hãy đặt trước dấu gạch ngang một sổ chéo ngược. Sau đây là một số thí dụ khác:[0123456789] # sánh với mọi chữ số[0-9] # tương tự như trên[0-9\-] # sánh 0-9 hay dấu trừ[a-z0-9] # sánh bất kì chữ thường hay số nào[a-zA-Z0-9_] # sánh bất kì chữ, số hay dấu gạch dưới

Cũng có lớp kí tự bị phủ định, cũng là cùng lớp kí tự, nhưng có thêm dấu mũ (^) đằng trước, đi ngay sau dấu ngoặc trái. Lớp kí tự này đối sánh với bất kì kí tự đơn nào không trong danh sách. Chẳng hạn:[^0-9] # sánh với bất kì kí tự nào không phải là chữ số[âeiouyAEIOUY] # sánh với bất kì kí tự nào không nguyên âm[^\^] # sánh với bất kỳ ký tự nào không phải là dấu mũ

Perl đã định nghĩa sẵn một số lớp ký tự chung, như trong bảng sau:

Viết tắt Nghĩa

\d (số) [0-9]

\D (phủ định của \d) [^0-9]

\w (từ) [a-zA-Z0-9]

\W (phủ định của \w) [â-zA-Z0-9]

\s (khoảng trắng) [\r\t\n\f]

\S (phủ định của \s) [^\r\t\n\f]

11


\d sánh với số, \w sánh với ký tự từ, \s sánh với dấu cách (khoảng trắng), ở đây được xác định như ký tự space, về đầu dòng, tab, xuống dòng (dấu dòng mới của UNIX), và kéo giấy. Các bảng chữ hoa sánh đúng với các đối lập cho những lớp này.

3.2 Khuôn mẫu nhóm

a. Dãy

Khuôn mẫu nhóm đầu tiên là dãy. Có nghĩa là abc sánh đúng với 1 ký tự a, theo sau là b, và cuối cùng là c.

b. Bội

Bội là khuôn mẫu sánh được với nhiều ký tự. Trong phần trên ta đã thấy dấu sao (*) như một khuôn mẫu nhóm. Dấu * chỉ ra rằng “0 hay nhiều” ký tự (hay lớp ký tự) đứng ngay trước nó.

Hai khuôn mẫu nhóm khác làm việc tương tự là dấu cộng (+) – “1 hay nhiều” ký tự đứng ngay trước, dấu hỏi (?) – “0 hay 1” ký tự đứng ngay trước.

Ví dụ: /fo+ba?r/ sánh đúng với 1 xâu bao gồm: 1 f, 1 hay nhiều o, 1 b, 0 hay 1 a, cuối cùng là 1 r. Chẳng hạn: foobar hay fobr…

Chú ý rằng tất cả 3 khuôn mẫu trên đều “tham lam”. Tức là nếu nó có cơ hội sánh đúng giữa 5 và 10 ký tự thfi nó sẽ lọc ra xâu mười ký tự 1 lúc. Ví dụ:

$_ = “Tom xxxxxxxxxx Jerry”;

s/x*/and;

Trong trường hợp này, tất cả các x liên tiếp đều được thay bằng and (kết quả là Tom and Jerry).

Nếu bạn cần nói “5 tới 10” x, thì có thể viết x?x?x?x?x?xxxxx. Tuy nhiên cách này trông rất rối mắt và làm việc không hiệu quả. Ta có thể thay bằng cách viết khác, dùng số bội tổng quát. Số bội tổng quát bao gồm 1 cặp dấu ngoặc nhọn với 1 hay 2 số bên trong.

Ví dụ: /x{5,10}/. Điều này tương đương với việc phải tìm ra từ 5 đến 10 x. Nếu bỏ đi con số thứ 2, như /x{5,}/ có nghĩa là 5 hay nhiều hơn x. Nếu bỏ đi dấu phẩy,như /x{5}/ có nghĩa là đúng 5x. Để được 5x hay ít hơn, ta phải đặt số 0 vào /x{0,5}/.

12


Xét 1 ví dụ khác, BTCQ /a.{5}b/ sánh đúng cho ký tự a được tách với ký tự b bởi bất kỳ 5 ký tự khác xuống dòng mới, 5 ký tự này có thể khác nhau.

Ta cũng có thể loại bỏ *, +, ? bằng cách dùng {0,}, {1,} và {0,1} nhưng dùng các ký tự là dễ dàng hơn và quen thuộc hơn.

Nếu có hai số bội trong một biểu thức, thì qui tắc tăng được tăng lên với "bên trái nhất là tăng lên nhất". Chẳng hạn:$_ = "a xxx c xxxx c xxx d";

/a.*c.*d/;

Trong trường hợp này, ".*" thứ nhất trong biểu thức chính qui sánh với tất cả các kí tự cho tới c thứ hai, cho dù việc sánh đúng chỉ với các kí tự cho tới c đầu tiên vẫn cho phép toàn bộ biểu thức chính qui được sánh. Điều này không tạo ra khác biệt gì (khuôn mẫu sẽ sánh theo cả hai cách), nhưng sau này khi chúng ta có thể nhìn vào các bộ phận của biểu thức chính qui mà được sánh, thì sẽ có đôi chút vấn đề.

Điều gì xảy ra nếu biểu thức xâu và chính qui hơi bị thay đổi đi, chẳng hạn như:

$_ = “a xxx ce xxxxxxx ci xxx d”;

/a.*ce.*d/;

Trong trường hợp này, nếu ".*" sánh với phần lớn các kí tự có thể trước c tiếp, thì kí tự biểu thức chính qui tiếp (e) sẽ không sánh với kí tự tiếp của xâu (i). Trong trường hợp này, ta thu được việc lần ngược tự động - số bội bị tháo ra và thử lại, dừng lại tại chỗ nào đó phía trước (trong trường hợp này, tại c trước, tiếp sau là (e)* . Một biểu thức chính qui phức tạp có thể bao gồm nhiều mức lần ngược như vậy, dẫn tới thời gian thực hiện lâu.

c. Dùng dấu ngoặc tròn như bộ nhớ.

Một toán tử nhóm khác là cặp mở và đóng ngoặc tròn quanh bất kỳ phần khuôn mẫu nào. Nó không làm thay đổi liệu khuôn mẫu có sánh đúng hay không, mà nó ghi nhớ một phần của xâu được khuôn mẫu sánh đúng của xâu. Do vậy, (a) vẫn sánh với a, ([a-z]) thì vẫn sánh với bất kỳ chữ thường nào. Để lưu 1 phần đã ghi nhớ của xâu, bạn phải đưa vào một dấu sổ chéo ngược theo sau bởi một số nguyên. Kết cấu khuông mẫu này biểu thị cho cùng dãy các ký tự được sánh trước đây trong cặp dấu ngoặc tròn cùng số (đếm từ 1). Ví dụ:

/jerry(.)tom\1/

13


Sẽ sánh một xâu có chứa jerry, tiếp theo là một kí khác dấu xuống dòng, tiếp nữa là tom, rồi tiếp bởi cùng một kí tự đó. Vậy, nó sánh với jerryxtomx, nhưng không sánh với jerryxtomy. Cách viết này khác với cách viết /jerry.tom./, bởi hai ký tự không xác định có thể giống nhau hoặc khác nhau, /jerry.tom./ sẽ sánh với cả jerryxtomx và jerryxtomy.

Số 1 chỉ phần biểu thức chính quy nằm trong dấu ngoặc đầu tiên. Nếu có nhiều phần như thế, thì phần thứ hai (đếm các dấu ngoặc từ trái sang phải) sẽ được tham khảo tới là \2, phần thứ 3 là \3…

Ví dụ: /a(.)b(.)c\2d\1/;

Sẽ sánh với một a, một kí tự (gọi nó là #1), một b, một kí tự khác (gọi nó là #2), một c, kí tự #2, một d, và kí tự #1 (cho nên nó sánh với axbycydx chẳng hạn).

Phần được tham khảo tới có thể nhiều hơn 1 ký tự, ví dụ:

/a(.*)b\1c/;

Sẽ sánh với một a, theo sau bởi một số bất kì kí tự nào (thậm chí không), theo sau bởi b, theo sau bởi cùng dãy kí tự đó, theo sau bởi c. Vậy, nó sẽ sánh với aFREDnFREDc, hay thậm chí abc, nhưng không sánh aXXbXXXc.

Một cách dùng khác của phần được nhớ của biểu thức chính qui là trong xâu thay thế của chỉ lệnh thay thế. Kết cấu kiểu \1 vẫn giữ giá trị của chúng trong xâu thay thế, và có thể được tham khảo tới để xây dựng xâu, như trong:$_ = "a xxx b yyy c zzz d";

s/b(.*)c/d\1e/;

sẽ thay thế b và c bằng d và e, vẫn giữ lại phần ở giữa.

d. Thay phiên

Sánh đúng với 1 trong các khả năng. Ví dụ: a|b|c sẽ sánh đúng với hoặc a, hoặc b, hoặc c. Nếu các khả năng có nhiều ký tự, ta có thể viết tương tự

/song|blue/ sẽ sánh hoặc song hoặc blue

Nếu muốn sánh songbird hoặc bluebird, ta có thể viết /songbird|bluebird/ hoặc /(song|blue)bird/.

3.3. Neo

14


Bốn ký pháp đặc biệt đóng neo cho một khuôn mẫu. Thông thường, khi một khuôn mẫu được sánh với xâu thì khuông mẫu sẽ được sánh với toàn bộ xâu từ trái sang phải, cho ra trường hợp sánh đúng đầu tiên. Neo cũng cho phép bạn đảm bảo rằng các phần của dòng khuôn mẫu sắp thẳng với những phần đặc biệt của xâu.

Cặp neo thứ nhất đòi hỏi rằng một phần đặc biệt của việc đối sánh phải được định vị tại biên giới từ hay không tại biên giới từ. Neo \b yêu cầu một biên giới từ tại điểm đã chỉ ra cho khuôn mẫu đối sánh. Biên giới từ là nơi ở giữa các kí tự sánh với \w và \W, hay giữa các kí tự sánh với \w và chỗ bắt đầu hay kết thúc của xâu. Chú ý rằng điều này ít phải xử lí đối với tiếng Anh và phải làm nhiều đối với các kí hiệu C, nhưng điều đó cũng gần thôi khi ta đạt tới. Chẳng hạn:/fred\b/; # sánh fred, nhưng không frederick/\bwiz/; # sánh wiz và wizard, nhưng không qwiz/\bFred\b/; # sánh Fred nhưng không Frederick hay alFred/abc\bdef/; # không bao giờ sánh (không thể có cận ở đây)/\bFred\B/; # sánh "Frederick" nhưng không "Fred Flintstonee"

Hai neo nữa yêu cầu rằng một phần đặc biệt của khuôn mẫu phải đi ngay sau cuối xâu. Dấu mũ (^) sánh với điểm bắt đầu của xâu nếu nó đang ở một vị trí tạo ra nghĩa để đối sánh tại chỗ bắt đầu của xâu. Chẳng hạn, â sánh một a nếu và chỉ nếu a là kí tự đầu tiên của xâu. Tuy nhiên, â cũng sánh với hai kí tự a và ^ ở bất kì đâu trong xâu, nói cách khác, dấu mũ đã mất ý nghĩa đặc biệt của nó. Nếu bạn cần dấu mũ là một hằng kí hiệu dấu mũ ngay tại chỗ bắt đầu, thì hãy đặt một dấu sổ chéo ngược phía trước nó.

Dấu $ cũng giống như ^, neo lại khuôn mẫu, nhưng tại cuối của xâu, không phải bắt đầu. nói cách khác, c$ sánh với một c chỉ nếu nó xuất hiện tại cuối xâu. Dấu $ ở bất kì nơi đâu khác trong khuôn mẫu có lẽ vẫn cứ được diễn giải như cách hiểu giá trị vô hướng, cho nên bạn gần như bao giờ cũng phải dùng dấu sổ chéo ngược để đối sánh một dấu hiệu đó là hàng kí hiệu trong xâu.

3.4 Thứ tự ưu tiên.

Các khuôn mẫu bỏ neo và gộp nhóm cũng có thứ tự ưu tiên, độ ưu tiên của khuôn mẫu từ cao xuống thấp nhất được cho trong bảng sau:

Tên Biểu diễn

Dấu ngoặc tròn ()

Số bội ?+*{m,n}

15


Tuần tự và bỏ neo Abc^$\B\b

Thay phiên |

Ví dụ: khi viết a|b* hoặc a|(b*)thì ta sẽ hiểu là “1 a hay số bất kỳ ký tự b”.

Nếu muốn viết “bất kỳ số a hay b nào”, ta viết (a|b)*.

Khi dùng dấu ngoặc ở đây thì chúng cũng được lưu trữ trong bộ nhớ. Nếu bạn không muốn lưu lại trong bộ nhớ thì có thể dùng (?:) thay cho ().

Một số ví dụ khác:

abc* # sánh với ab, abc, abcc, abccc, abcccc …..

(abc)* # sánh với "", abc, abcabc, abcabcabc …..

^x|y # sánh x tại đầu dòng, hay y ở bất kì đâu

^(x|y) # sánh hoặc với x hoặc với y tại đầu dòng

a|bc|d # a hoặc bc hoặc d

(a|b)(c|d) # ac, ad, bc hoặc bd

(song|blue)bird # songbird hay bluebird

4. Các toán tử đối sánh khác.

4.1 Toán tử =~

Toán tử =~ dùng để tìm kiếm và thay thế chuỗi. Ví dụ:

if ($line =~/john/) {

# do something…

}

Ở đây, =~ sẽ so sánh $line với biểu thức nằm trong /s (john). Nếu $line chứa chuỗi “john” thì điều kiện là true. Có nghĩa là những chuỗi đó sẽ tương thích nếu $line giống như: “john”, “johnny”, “john smith”…

Nếu muốn chắc chắn rằng tên đầu tiên bắt đầu bằng “john”. Ta có thể viết:

If ($line =~/^john/) {

16


Ký tự ^ báo cho Perl biết biến $line trong trật tự tương thích phải bắt đầu bằng “john”. Nó sẽ tương thích với “john”, “john smith”, “johnny”,… nhưng không tương thích với “big john” hay “joe johnston”, …

4.2 Bỏ qua chữ hoa, chữ thường.

Ta có thể chỉ ra tùy chọn bỏ qua chữ hoa, chữ thường bằng cách thêm chữ i thường vào sau sổ chéo đóng. Chẳng hạn: /somepattern/i.

Ví dụ:

if ($line=~/john/i) {

sẽ tương thích với “John”, “john”, “JOHN”, …

4.3 Dùng một định biên khác.

Nếu muốn tìm một xâu với một BTCQ có chứa ký tự sổ chéo (/), thì đặt trước mỗi sổ chéo một sổ chéo ngược (\). Ví dụ, ta cần tìm một xâu bắt đầu bằng /usr/etc

$path = <STDIN>; # đọc 1 tên đường dẫn

if ($path =~ /^\/usr\/etc/) {

# bắt đầu với usr/etc…

}

Nhưng viết như trên là rất cồng kềnh, do đó ta có thể xác định một ký tự định biên khác. Chỉ cần đặt trước bất kỳ ký tự phi chữ số nào (kể cả dấu gạch chéo lần nữa nếu muốn) với 1 m, rồi liệt kê khuôn mẫu, cuối cùng là 1 ký tự định biên giống như vậy. Ví dụ:

/^\/usr/etc/ # dùng định biên sổ chéo chuẩn

m@^/usr/etc@ # dùng @ làm định biên

m#^/usr/etc# # dùng # làm định biên

4.4 Dùng xen lẫn biến

Một biểu thức chính qui là được xen lẫn biến trước khi nó được xem xét cho các kí tự đặc biệt khác. Do đó, bạn có thể xây dựng một biểu thức chính qui từ các xâu được tính toán thay vì chỉ là hằng ký hiệu. Chẳng hạn:$what = "bird";

17


$sentence = "Every good bird does fly.";

if ($sentence =~ /\b$what\b/) {

print "$sentence\n";

}

Tại đây chúng ta đã xây dựng một cách có hiệu quả toán tử biểu thức chính qui /\bbird\b/ bằng việc dùng một tham khảo biến.

4.5 Biến chỉ đọc đặc biệt.

Sau khi đối sánh khuôn mẫu thành công, các biến $1, $2, $3 vân vân sẽ được đặt cho cùng giá trị là \1, \2, \3 tương ứng. Bạn có thể dùng điều này để nhìn vào một phần của việc đối sánh trong đoạn chương trình sau. Chẳng hạn:$_ = “đây là phép kiểm tra”;

/(\W+)\W+(\W+)/; # đối sánh hai từ đầu

# $1 bây giờ là “đây” còn $2 bây giờ là “là”

Bạn cũng có thể thu được cùng các giá trị ($1, $2, $3 vân vân) bằng việc đặt đối sánh trong hoàn cảnh mảng. Kết quả là một danh sách các giá trị mà sẽ được đặt cho $1 cho tới số các vật được ghi nhớ, nhưng chỉ nếu biểu thức chính qui sánh đúng. Ta hãy lấy lại thí dụ trước theo cách khác$_ = "This is a test";

/(\W+)\W+(\W+)/; # đối sánh hai từ ở hai đầu

# $1 bây giờ là "this" còn $2 bây giờ là "test"

Lưu ý rằng các biến $1 và $2 vẫn không bị thay đổi.

Các biến chỉ đọc được xác định trước còn bao gồm $&, là một phần của xâu sánh đúng với biểu thức chính qui; $`, là một phần của xâu trước phần sánh đúng; còn $’ là phần của xâu sau phần sánh đúng. Chẳng hạn:$_ = "this is sample string";

/sa.*le/; # sánh "sample" bên trong xâu

# $` bây giờ là "this is a "

# $& bây giờ là "sample"# $’ bây giờ là " string"

18


Vì tất cả những biến này đều được đặt lại cho từng lần sánh thành công cho nên bạn nên cất giữ các giá trị trong các biến vô hướng khác nếu bạn cần các giá trị đó về sau trong chương trình.

5. Thay thế.

Dạng đơn giản nhất của toán tử thay thế là: s/old-regex/new-string/.

Toán tử này cũng có nhiều biến thể, sau đây ta sẽ nói tới vài biến thể của nó.

- Nếu bạn muốn việc thay thế thực hiện trên tất cả các đối sánh có thể thay vì chỉ thay thế 1 đối sánh đầu tiên thì ta dùng thêm g vào toán tử này. Ví dụ:

$_ = “xau xau xau doi sanh”;

s/xau/chuoi/g;

# $_ bây giờ là “chuoi chuoi chuoi doi sanh”

- Xâu thay thế có biến xen vào, cho phép xác định xâu thay thế vào lúc chạy, ví dụ:

$_ = “Hello, world!”;

$xaumoi = “Goodbye”;

s/Hello/$xaumoi/;

# $_ bây giờ là “Goodbye, world!”

- Ngoài việc đối sánh các kí tự cố định, các kí tự khuôn mẫu trong biểu thức chính quy cho phép đối sánh các khuôn mẫu, ví dụ:

$_ = “this is a test”;

s/(\w+)/<$1>/g;

# $_ bây giờ là “<this><is><a><test>”

Chú ý: $1 được đặt là dữ liệu bên trong việc đối sánh đúng mẫu trong dấu ngoặc.

- Hậu tố i (đứng trước hoặc sau g nếu có) làm cho biểu thức chính quy trong toán tử thay thế bỏ qua chữ hoa thường.

- Nếu bạn không muốn dùng dấu sổ chéo thì có thể dùng 1 dấu định biên khác. Chỉ cần dùng kí tự đó ba lần, ví dụ:

19


S#jerry#tom#;

# thay jerry bằng tom, giống như câu lệnh s/jerry/tom/

- Bạn cũng có thể xác định một mục tiêu thay phiên bằng toán tử =~. Trong trường hợp này, mục tiêu được chọn phải là một cái gì đó mà bạn có thể gán cho một giá trị vô hướng vào, như một biến vô hướng hay một phần tử của mảng, ví dụ:

$which = “this is a test”;

$which =~ s/test/quiz/; # $which bây giờ là “this is a quiz”.

20


Chương 4: Các hàm xử lý chuỗi cơ bản.

I. Chop

Tiếp theo, chúng tôi sẽ giải thích về cách sử dụng chức năng Chop trong Perl và một số Ví dụ ngắn để làm rõ việc triển khai thực hiện một số lĩnh vực. Lấy mẫu của đoạn mã sẽ được cung cấp theo thứ tự để làm nổi bật một số khía cạnh cụ thể của việc sử dụng nó trong bối cảnh khác nhau. Điều này nhanh chóng hướng dẫn, sẽ giúp bạn hiểu những tính năng tốt hơn.

Chức năng Chop có 3 cú pháp hình thức:

Chop Variable

Chop(List)

Chop

I.1.Chop Variable

Nếu sử dụng cú pháp đầu tiên này, thì hàm Chop loại bỏ các ký tự cuối cùng của một chuỗi biến và trả về các ký tự còn lại, nhưng nó không là vấn đề gì. Xin vui long không kết hợp với chức năng này với Chomp – xoá một dòng mới (thường là “\n”).

VD, các mã sau đây cho bạn thấy làm thế nào để chop cuối cùng ký tự từ một chuỗi biến:

$v=’hay’;

$r=chop($v);

Print”$v (without $r)\n”;

#displays hay (without y)

Nếu chuỗi này trống, thì các hàm của Perl sẽ trở về rỗng, một chuỗi ký tự tương ứng với không xác định.

Hay có thể VD như

Chop($color = ‘reds’);

Print “$color\n”;

21


#displays red;

I.2.Chop(List)

Thứ hai, cú pháp hình thức là dành cho các danh sách. Bạn có thể chọn Chop một mảng hoặc một hash, nhưng hãy nhớ rằng chúng tôi đã xem trong một chiều chỉ có cấu trúc, mà không có bất kỳ tham khảo. trong cả hai trường hợp - mảng hoặc hash – chức năng chop sẽ trở lại với ký tự cuối cùng của các yếu tố cuối cùng.

Khi chopping một mảng sẽ làm tất cả các thành phần của mảng được chia nhỏ:

#define an array

@flowers = qw(roses tulips violets snowdrops);

Chop(@flowers);

Print join(“ “,@fowers), “\n”;

#displays rose tulip violet snowdrop

Đối với các mảng hash chop sẽ loại bỏ các ký tự cuối cùng từ các giá trị, trong khi các phím sẽ không thay đổi:

#define a hash

%color = (

Red => ‘roses’,

Yellow => ‘tulips’,

While => ‘snowdrops’

);

Chop(%colors);

While(($key, $value)=each % colors)

{

Print “$key: $colors{$key}\n”;

}

22


Sau khi chạy thì xuất ra:

White: snowdrop

Red: rose

Yellow: tulip

I.3 Chop

Thứ ba, cú pháp chức năng Perl này là khi bỏ qua các biến. Trong trường hợp này Chop sử dụng các giá trị đặc biệt được lưu giữ trong các biến $_

VD

#define an array

@flowers = qw(roses tulips violets snowdrops);

#let’s iterate through its elements using foreach loop

Foreach (@flowers) {

Chop;

}

Print “@flowers\n”;

#displays rose tulip violet snowdrop

Trong ví dụ trên, foreach được sử dụng mà không có biến, do đó, $_ biến đặc biệt sẽ được sử dụng theo mặc định. Tại mỗi bước lặp:

$_ các biến được thiết lập với các yếu tố của hiện tại trong danh sách

Chuỗi từ $_là chia nhỏ của các ký tự cuối cùng

cuối cùng, chúng tôi sử dụng một mẫu đơn in với hai dấu ngoặc kép để hiển thị các thành phần của không gian xa cách.

II. Chomp

Chúng tôi sẽ kiểm tra dưới đây hàm chomp và làm thế nào để sử dụng nó trong bối cảnh khác nhau. Các đoạn mã ví dụ điển hình sẽ ra được nhiều

23


cách khác nhau của việc sử dụng nó và sẽ làm rõ và nêu bật một số khía cạnh đặc biệt thú vị.

Có 3 hình thức

Chomp variable

Chomp(list)

Chomp

II.1 chomp variable

Nếu chúng tôi sử dụng các cú pháp hình thức đầu tiên, chúng tôi gọi chức năng này như là đối số có tên của một biến. Trong trường hợp này sẽ loại bỏ bất cứ chức năng trailing chuỗi vào cuối của biến. Hàm Chomp sẽ không loại bỏ tất cả các ký tự trắng theo mặc định, nhưng phù hợp với các chuỗi trailing hiện đang được lưu giữ trong các biến đặc biệt $ / - cũng được gọi là các bản ghi dữ liệu vào nơi ngăn cách. Nếu không có bất kỳ ký tự trailing vào cuối của biến, biến sẽ vẫn không thay đổi.

Có sự khác biệt giữa chomp và chop. Trong khi hàm chop xoá ký tự cuối cùng và không phân biệt đấy là ký tự gì, thì chomp kiểm tra xem chuỗi có phù hợp với ký tự đầu vào dòng ngăng cách và chỉ xoá nó. Hàm chomp trả về số lượng các ký tự xoá bỏ.

Sau đây là một số chức năng phổ biến, đặc biệt là khi bạn đọc một số văn bản từ bàn phím thông qua viêc sử lý các tập tin đặc biệt STDIN. Các tiêu chuẩn đầu vào dòng sẽ thêm một ký tự “\n” vào cuối mỗi dòng, và bạn có thể thoát khỏi nó rất đơn giản bằng cách gọi chức năng chomp.

VD

Print” ten ban: “;

$name = <STDIN>;

Chomp $name;

Print “ten ban la gi : $name\n”;

Mã này sẽ đọc từ bàn phím sử dụng tên người và sẽ được lưu trữ trong biến $ tên. Biến này sẽ có ở cuối một ký tự dòng mới, chèn vào sau khi được phù hợp.

Trong vd trên ta có thể thay thế dòng 2,3 với

24


Chomp($name = <STDIN>);

Nói chung, Perl Chomp () chỉ có chức năng loại bỏ qua dòng trắng, nhưng những gì nếu có thêm thông tin? Trong trường hợp này, bạn có thể thay với các biến đặc biệt $ /, bằng cách sử dụng chế độ cài đặt $ / cho "", như trong ví dụ sau:

$/ = “”;

$v = “\n\nsome text here\n\n\n\n”;

$nr = chomp $v;

Sau khi thực hiện mã này, việc đầu tiên hai newlines sẽ vẫn không thay đổi, nhưng cuối cùng thứ tư sẽ được gỡ bỏ. Biến $ nr sẽ được đặt để 4 - số ký tự newline xoá. Hãy cẩn thận, tuy nhiên, khi bạn thay đổi nội dung của các biến đặc biệt $ /, và khôi phục lại nó để các giá trị mặc định (\ n), khi bạn xem xét việc cần thiết.

II.2 chomp(list)

Thứ hai là dành cho các danh sách. Bạn có thể Chomp hoặc bất kỳ mảng hash (liên mảng), nhưng chúng tôi sẽ được kiểm tra chỉ có một chiều, mà không có bất kỳ tham khảo. Nó không quan trọng nếu bạn tham khảo arrays hay hashes nhưng không quên đưa mảng hoặc hash bên trong Chomp, nếu không kết quả có thể là một trong những rằng bạn sẽ không mong đợi.

Để bắt đầu bằng, chúng tôi sẽ xem xét các trường hợp arrays. Để minh họa cách sử dụng chức năng Chomp Perl với một mảng, mất một chút thời gian để kiểm tra các đoạn mã sau:

$nr = chomp(@colors = <STDIN>);

print "\@colors = @colors\n";

print "Newlines removed: $nr";

Mã này sẽ đọc tất cả các tuyến đường lên tới EOF và sẽ Chomp chúng off; số newlines xoá bằng với số lượng các dòng đọc.

Nếu bạn muốn kiểm tra mã này trong một cửa sổ dòng lệnh:

25


* Đầu tiên bạn cần phải bao gồm mã số trong một tập tin chữ viết, lưu các tập tin và sau đó chạy nó từ dòng lệnh;

* Sau khi bạn đã hoàn thành vào đầu vào những dòng, để cho các EOF của tập tin bạn cần phải loại CtrlZ như dòng cuối cùng và đình công trên phím Enter;

Đây là một ví dụ:

C:\perl\bin>perl chomptst.pl

Red

Yellow

White

Blue

^Z

@colors=red yellow white blue

Newlines removed: 4

Cách khác

@colors = ();

While($line = <STDIN>)

{

$nr+ = chomp $line;

Push(@colors, $line);

}

Print “\@colors = @colors\n”;

Print “newlines removed: $nr”;

Việc sản xuất sẽ được giống hệt như trong ví dụ trước đó được hiển thị ở trên.

26


Tiếp theo, hãy xem một ví dụ khi Chomp được gọi với một hash như là đối số. Điều này sẽ được minh họa trong các mã số phân. Nhưng trước khi nhìn thấy các ví dụ, tôi muốn chỉ rõ rằng, như là trong trường hợp chop (), chỉ có các giá trị của một hash là chomped, các phím còn lại là không thay đổi. Sau khi xử lý tất cả các yếu tố của một hash, Chomp các chức năng sẽ trở lại với số lượng chomped ký tự.

#read the pair elements of the hash from STDIN

Chomp(%fruitsColors = <STDIN>);

#the next loop prints the keys/values of the hash

Foreach $key(key %fruitsColors)

{

Print”key: $key, value: $fruitsColors{$key}\n”;

}

VD về code

C:\perl\bin>perl chomptst.pl

Cam

Xanh

Chuoi

Vang

Dau

Do

^Z

Key: chuoi

, Value: vang

Key: cam

, Value: xanh

Key: dau

27


, Value:do

Khi bạn nhìn thấy trong ví dụ trên, các phím không được chomped (bằng cách dụ, phím "plum" kết thúc bằng một ký tự newline và vì lý do này có giá trị tương ứng của nó đã được in trên một dòng mới trong cửa sổ cmd).

Hãy nhìn vào cùng một ví dụ, nhưng trong trường hợp này chúng tôi sẽ khởi tạo các hash mã hóa bằng cách:

#create a new hash – fruitsColors

#and assigning some elements to it

$fruitscolors{“chuoi\n”}=”vang\n”;

$fruitscolors{“cam\n”}=”xanh\n”;

$fruitscolors{“dau\n”}=”do\n”;

#chomp the hash

$nr = chomp(%fruitsColors);

#the next loop prints the keys/values of the hash

Foreach $key (keys %fruitsColors)

{

Print “key: $key, Value: $fruitsColors{ $key}\n”;

}

Print “newlines removed: $nr\n”;

xuất

c:\perl\bin>chomptst.pl

Key: chuoi

, Value: vang

Key: cam

, Value: xanh

Key: dau

28


, Value: do

Newlines removed: 3

III.3 chomp

Qua cú pháp hình thức Chomp này là khi các đối số biến là bỏ qua. Hãy làm việc xung quanh thông qua một trong những ví dụ điển hình được hiển thị bên dưới.

ví dụ ...

# define an array

@numbers = ("one\n", "two\n", "three\n", "four\n");

# let’s loop through its elements using foreach

foreach (@numbers) {

chomp;

}

print "@numbers\n";

# displays one two three four

Những tuyên bố foreach loop biến là thiếu và rằng foreach có nghĩa là sẽ sử dụng để lặp đặc biệt biến $ _. Tại mỗi bước lặp:

* Hiện nay yếu tố của mảng sẽ được lưu trữ trong $ _

* Giá trị được lưu giữ trong $ _ sẽ được chomped biểu tượng của sự kết thúc

Theo quy định, chúng tôi kết luận rằng Perl Chomp () tránh cho dù không chắc chắn về một dòng dữ liệu vào newline có một ký tự hay không. Nếu bạn sử dụng xử lý để nhập vào một số thông tin, bạn nên luôn luôn "Chomp" những dòng đầu vào ngay lập tức sau khi đọc nó.

III. hàm hex

Điều này ngắn Perl Hướng dẫn hex sẽ cho bạn thấy làm thế nào để sử dụng chức năng này trong bối cảnh khác nhau. Tôi sẽ ra được thông qua một số đoạn mã ví dụ những gì tôi xem xét chi tiết quan trọng để đánh dấu chủ đề.

29


Hai cú pháp hình thức có sẵn cho Perl hex chức năng:

Hex EXPR

Hex

Chức năng này:

* Đã là một đối số hexadecimal chuỗi (hoặc một biểu đó sẽ trở lại sau khi đánh giá một chuỗi hex)

* Sẽ trở lại với giá trị thập phân tương ứng

Ví dụ, xem dưới đây làm thế nào bạn có thể gọi nó là:

print hex "0x4E8", "\n"; # or

print hex "4e8", "\n";

Khi bạn nhìn thấy ở trên, hexadecimal một chuỗi các ký tự bắt đầu với 0x (mà có thể được bỏ qua trong một bối cảnh hex) và được phân biệt dạng chữ. Xin lưu ý rằng ở đây các hexadecimal xâu số nguyên, và không đại diện cho bất kỳ loại dữ liệu khác.

Trong cú pháp thứ hai, các biểu mẫu đối số là bỏ qua và chức năng sẽ sử dụng theo mặc định như là đối số hexadecimal các giá trị đặc biệt được lưu giữ trong các biến $ _.

Tiếp theo, tôi sẽ cung cấp cho bạn một số ví dụ về cách bạn có thể sử dụng và thao tác Perl hex và một số chức năng có liên quan xem xét.

III.1.Chuyển một số thập phân trong hexadecimal

Nếu Perl hex () hexadecimal chức năng chuyển đổi một giá trị vào thập, có thể bạn có thể có mong muốn tìm thấy một chức năng tương tự mà sẽ làm đảo ngược, tức là chuyển đổi một số thập phân vào một trong những hexadecimal. Vâng, đó không chỉ là như thế. Chúng tôi có thể làm được điều này rất đơn giản chỉ bằng cách sử dụng Perl sprintf chức năng định dạng, như trong ví dụ sau

# initialize a scalar variable with an integer value

$dec = 1211;

30


print "Hexadecimal number: ", uc(sprintf("%x\n", $dec)), "\n";

# displays 4BB

Chúng tôi sử dụng để định dạng% x trên giá trị scalar vào hexadecimal và chúng tôi chuyển đổi kết quả trong uppercases, nhưng chúng tôi có thể cho phép nó trong lowercases quá, như là sprint chức năng của nó trở về mặc định.Đây là một phương pháp chuyển đổi trực tiếp khi chúng tôi cần phải sử dụng một chức năng đảo ngược cho Perl hex chức năng. Nếu bạn muốn viết bất kỳ mã thi đua và các thuật toán được sử dụng bởi các định dạng sprintf, đây là một ví dụ:

# initialize a scalar with an integer value

$dec = 1211;

# call the subroutine

$hex = DecToNumBase($dec, 16);

print "Hexadecimal number: $hex\n";

# displays 4BB

# define the subroutine

sub DecToNumBase

{

my $decNumber = $_[0];

my $numBase = $_[1];

my $numNumber;

while($decNumber != 'end')

{

# divide the decimal number by $numBase and

31


# store the remainder (modulus function) in

# the temporary variable $temp

my $temp = $decNumber % $numBase;

if($temp > 9)

{

$temp = chr($temp + 55);

}

$numNumber = $temp . $numNumber;

$decNumber = int($decNumber / $numBase);

if($decNumber < $numBase)

{

if($decNumber > 9)

{

$decNumber = chr($decNumber + 55);

}

$numNumber = $decNumber . $numNumber;

$decNumber = 'end';

}

}

return $numNumber;

}

Trong ví dụ trên, chúng tôi đã xác định và gọi là DecToNumBase subroutine là có nghĩa là để chuyển đổi một giá trị thập phân vào một số cơ sở khác numeration. Điều này subroutine có đầu vào là hai đối số:

* Thập các giá trị sẽ được chuyển đổi

32


Numeration các cơ sở

Trong khi các vòng lặp sẽ dừng lại khi nào sau khi chia các số thập phân của numeration cơ sở chúng tôi sẽ nhận được kết quả như một số ít hơn numeration cơ sở. Xin lưu ý việc sử dụng của Perl chr chức năng và các nhà điều hành concatenation '.'. Chúng tôi gọi là chức năng này để chuyển đổi một số thập phân vào một trong những hexadecimal. Bạn có thể sử dụng chức năng này, hoặc để chuyển đổi một số thập phân vào octal, hoặc bất cứ nhị phân. Chúng tôi đã không sử dụng chức năng Perl hex trong subroutine trên nhưng chúng tôi xem xét rằng các mã số có ích để xem làm thế nào để làm việc trong tình huống tương tự.

III.2.chuyển đổi xâu scale thành hex

Các đoạn mã sau đây sẽ cho bạn thấy làm thế nào để chuyển đổi một chuỗi scalar vào các định dạng hexadecimal. Mất bất kỳ ký tự trong chuỗi và trả về mã hexadecimal của nó:

$myString="This text is only for test reason 123 [{@!}}|";

@myArray=unpack('C*', $myString);

foreach $c (@myArray)

{

$myStringHex .= "\%" . sprintf ("%lx", $c);

}

print "$myStringHex\n";

Việc giải nén tập tin «Perl C sử dụng các chức năng của tham số chuyển đổi trong mỗi byte. Perl sprintf chức năng được sử dụng để định dạng các byte mã hex. Để nhận được tất cả các chuyển đổi trong một chuỗi ký tự, các concatenation "." nhà điều hành được sử dụng.

III.3.Mã hoá và giải mã một URL

URL (hoặc Uniform Resource locator) là một loại hình cụ thể Địa chỉ URI (mà viết tắt của Uniform Resource Identifier). Địa chỉ URI của chúng tôi có nghĩa là một chuỗi ký tự được sử dụng để nhận dạng một vật thể trừu tượng hay tài

33


nguyên.

Tất cả những ai đang tìm kiếm thông qua Internet biết về địa chỉ (hoặc chính xác hơn, anh ta nên biết). Hãy nói rằng, thông qua các URL của chúng tôi hiểu một địa chỉ Internet của một trang mà chúng tôi đang tìm kiếm, nó có thể được địa chỉ của trang này quá (URL = http://www.misc-perl-info.com/perl-hex. html).

Có một số hạn chế của việc sử dụng các ký tự trong một URL. Thông qua các ký tự được cho phép có bảng chữ cái ký tự [0-9a-za-Z], một số các biểu tượng dấu chấm câu reserved $-_.!*'(), và một số ký tự được sử dụng cho các mục đích khác.

Tất cả các ký tự khác phải được mã hóa, bởi vì họ có thể được hiểu lầm nếu chúng được tìm thấy trong vòng một URL. Để mã hoá một ký tự có nghĩa là để thay thế nó bằng cách biểu tượng% theo sau hai chữ số của nó hexadecimal mã. Ví dụ, các ký tự không gian trong đó có hexadecimal mã số 20, sẽ được đại diện là 20%.Các chế độ đơn giản nhất để mã hóa hay decode là một địa chỉ bằng cách sử dụng Perl URI:: Escape mô-đun, trong đó xuất khẩu các chức năng sau đây:

Uri_escape - mà thay thế (encodes) tất cả các ký tự không an toàn trong vòng một URL chuỗi hexadecimal với hai chữ số preceded của các biểu tượng% s

* Uri_unescape - unencodes mà tất cả các ký tự trong vòng một URL, có nghĩa là thay thế bất kỳ xuất hiện của% theo sau hai chữ số hexadecimal vào ký tự tương ứng của họ (nói cách khác chuyển đổi một URL để mã hóa bình thường của nó đại diện)

Ví dụ kế tiếp sẽ cho bạn thấy làm thế nào để làm được điều này:

use URI::Escape;

# Encode URL

$url = "http://www.google.com/search?q=book";

$encodedURL = uri_escape($url);

print "Encoded URL: $encodedURL\n\n";

# Decode URL

$encodedURL =

34


"http://%77%77%77%2e%79%61%68%6f%6f%2e%63%6f%6d";

$decodedURL = uri_unescape($encodedURL);

print "Decoded URL: $decodedURL\n";

output

Encoded URL: http%3A%2F%2Fwww.google.com%2Fsearch%3Fq%3Dbook

Decoded URL: http://www.yahoo.com

Các uri_unescape chức năng này rất hữu ích nếu bạn sẽ nhận được một lời mời bấm vào một liên kết với các ký tự thoát mà hình như "http://% 77% 77% 77% 2e% 79% 61% 68% 6F% 6F% 2e% 63 % 6F% 6d "và nó sẽ được tốt đẹp cho biết nơi mà bạn sẽ đi nếu bạn click vào nó. Giải mã nó như trong ví dụ ở trên và quyết định hơn những gì bạn sẽ làm được. Nếu bạn muốn xem địa chỉ đại diện cho địa chỉ trên, chỉ cần sao chép các chuỗi ở trên (bỏ bê các dấu ngoặc kép) vào thanh địa chỉ trình duyệt của bạn và xem nơi đó là chỉ ra (trong FireFox 3.0.6 nó hoạt động).

IV. hàm INDEX

Điều này ngắn Perl chỉ mục Hướng dẫn sẽ cho bạn thấy làm thế nào để sử dụng chức năng này để tìm một substring trong một chuỗi lớn hơn. Tôi sẽ cung cấp cho bạn một số đoạn mã ví dụ những gì tôi xem xét quan trọng hơn để nêu bật chủ đề và giúp bạn tìm hiểu cách thức để làm việc với nó. Bạn có thể sử dụng thường xuyên để phù hợp với biểu đầu tiên của một substring dụ, nhưng chức năng này có thể được nhanh hơn và dễ dàng hơn để hiểu.

Hãy bắt đầu với những cú pháp hình thức chức năng này:

index STR,SUBSTR,POSITION

index STR,SUBSTR

nơi mà các đối số có thể làm theo các thông số quan trọng:

* STR - một chuỗi ký tự mà bạn đang tìm kiếm

* SUBSTR - substring các vị trí mà bạn muốn để xác định vị trí hoặc để tìm kiếm

35

http://www.yahoo.com/


* POSITION - vị trí trong chuỗi từ nơi mà bạn muốn để bắt đầu tìm kiếm hay số lượng các ký tự trên để bỏ qua trước khi tìm kiếm các substring

Chức năng này sẽ trở lại -1 nếu substring sẽ không được hoặc được tìm thấy vị trí đầu tiên xuất hiện của các substring, nếu không. Hãy nhớ rằng đầu tiên của một chuỗi ký tự có vị trí 0, tiếp theo 1, vv. Nếu bạn không cung cấp thứ ba, lý luận, tức là VỊ TRÍ, mà có nghĩa là Perl chức năng lập chỉ mục tìm kiếm của bạn sẽ substring bắt đầu bằng ký tự đầu tiên của chuỗi.

Cũng giống như các chức năng khác Perl, bạn có thể sử dụng hoặc bỏ dấu ngoặc, như bạn muốn. Xem dưới đây một số ví dụ đơn giản về việc làm thế nào để sử dụng nó trong script:

$someText = "Learning Perl Language";

$found = index $someText, "Perl";

$found1 = index($someText, "perl", 5);

print "\$found = $found,\$found1 = $found1\n";

# it prints $found = 9,$found1 = - 1

Trong khi dòng thứ hai, các chỉ mục Perl () sẽ tìm kiếm các chức năng substring "Perl" trong chuỗi scalar $ someText và nó sẽ trở lại 9. Trong phần thứ ba đường dây, các chức năng lập chỉ mục tìm kiếm sẽ bắt đầu từ thứ sáu ký tự của $ someText chuỗi, nhưng thời điểm này, nó sẽ trở về -1. Điều đó sẽ xảy ra bởi vì các chức năng lập chỉ mục là trường hợp nhạy cảm, nhưng rất dễ dàng để ghi đè mã này bằng cách sử dụng dòng Perl uc (chữ hoa) chức năng để có thể tìm thấy những substring phân biệt dạng chữ:

$found1 = index(uc $someText, "PERL", 5);

print "\$found1 = $found1\n";

# it prints $found1 = -1

Thời điểm này, chỉ mục () chức năng sẽ trở lại với vị trí 9, đó có nghĩa là các substring đã được tìm thấy.

Nên nhớ rằng các chỉ mục Perl chức năng trả về -1 nếu nó không thành công, nếu bạn muốn sử dụng nó trong một bài kiểm tra điều kiện, bạn phải kiểm tra, nếu trở về giá trị lớn hơn hoặc bằng 0 cho sự thành công:

if(($pos = index($someText, "Perl")) >= 0)

36


{

print "The text was located at the position $pos\n";

}

bạn có thể thay thế dòng đầu tiên của đoạn code trên với

if(($pos = index($someText, "Perl")) > -1)

và kết quả sản xuất bằng cách chạy mã sẽ được như nhau.

Nếu bạn muốn tìm hiểu nếu một substring phù hợp với một chuỗi ký tự lớn hơn và bạn không chăm sóc về các substring vị trí trong chuỗi ký tự, bạn có thể sử dụng một dòng mã, như trong ví dụ sau:

print "Found it!\n" if(index($someText,"Perl")>-1);

IV.1.cách tìm tất cả các sự cố xảy ra của substring trong xâu

Bạn đã biết cách sử dụng chức năng chỉ mục Perl để xác định vị trí đầu tiên xuất hiện của substring trong một chuỗi ký tự. Bây giờ chúng tôi muốn tìm được vị trí của tất cả các sự xuất hiện của một substring trong một chuỗi ký tự, bằng cách sử dụng chức năng lập chỉ mục.

Hãy xem ví dụ sau:

# initialize the original string

$input = "Perl index, Perl chop, Perl hex";

$pos = 0;

@positions = ();

while (1)

{

$pos = index(lc $input, "perl", $pos);

last if($pos < 0);

push(@positions, $pos++);

}

37


if (scalar (@positions) > 0)

{

print "substring found at positions: ", "@positions\n";

} else {

print "substring not found\n";

}

#print substring found at positions: 0 12 23

Bây giờ tôi đưa ra một mô tả ngắn về mã này. Chúng tôi khởi tạo các chuỗi scalar $ đầu vào và chúng tôi dự định tìm kiếm cho substring "Perl" trong chuỗi này. Chúng tôi sử dụng Perl chỉ mục chức năng để làm được điều này và trong một thời gian cho loop iteration qua $ nhập chuỗi ký tự.

Nếu có sẽ là một kết hợp của các substring trong scalar $ nhập vào chuỗi ký tự, chỉ mục chức năng sẽ trở lại với vị trí mà xuất hiện trong các biến scalar $ pos, mà tiếp theo sẽ được thêm vào các vị trí mảng @ Perl đẩy bằng cách sử dụng các chức năng.

Các vòng lặp sẽ kết thúc khi các chức năng lập chỉ mục sẽ trở lại một giá trị nhỏ hơn không - không xuất hiện đã được tìm thấy. Trong thứ tự lo, trong khi rời khỏi vòng lặp, chúng tôi sử dụng các từ khóa loop kiểm soát cuối cùng.

IV.2.Chuyển các khoảng trống trong hàm index

Trong quá trình tìm kiếm bằng cách sử dụng chức năng lập chỉ mục, chúng tôi có thể loại bỏ đối tác hàng đầu và không gian trailing từ chuỗi mà chúng tôi tìm kiếm. Perl đã xây dựng không phải là một chức năng trong trim (như PHP), nhưng chúng tôi có thể mô phỏng nó bằng cách tạo một subroutine trim với sự giúp đỡ của ngôn ngữ thường. Xem các đoạn mã sau:

$input = ' Perl functions: trim, index';

$substr = 'functions';

print "position without trim: ", index($input,$substr), "\n";

print "position with trim: ", index(trim($input),$substr), "\n";

# Declare the trim subroutine

38


sub trim

{

my $string = shift;

$string =~ s/^\s+//;

$string =~ s/\s+$//;

return $string;

}

#print position without trim: 9

Position without trim: 5

Trong ví dụ này, chúng tôi in lần đầu tiên vị trí của $ $ substr trong chuỗi đầu vào và qua đó vị trí của cùng một substring sau khi gỡ bỏ whitespaces từ $ nhập chuỗi ký tự. Chúng tôi nhận được đầu ra:

position without trim: 9

position with trim: 5

($ các dữ liệu vào chuỗi giá trị đã có 4 dấu cách trước chữ Perl - bạn có thể không truy cập nó trên màn hình!).

Nếu bạn muốn tìm kiếm những tác phẩm mới xuất hiện của một substring trong một chuỗi ký tự, bạn cần phải sử dụng trong xây dựng-Perl rindex () chức năng.

V-hàm LC

Perl LC chức năng (LC viết tắt của chữ thường) chấp nhận các tham số như là một biểu hiện và chữ thường sẽ đem lại một phiên bản của những biểu. Trong hướng dẫn ngắn này, chúng tôi sẽ cung cấp cho bạn một số ví dụ điển hình là hữu ích cho bạn thấy làm thế nào để sử dụng chức năng này trong các ứng dụng tập lệnh của bạn. Có các khóa học chức năng uc (chữ hoa) mà một chữ trả lại giá trị của một chuỗi biểu. Bấm vào liên kết để xem uc uc những gì về chức năng

Chúng tôi có hai hình thức cú pháp cho các chức năng này:

lc EXPR

39


lc

Perl LC chức năng không thay đổi nội dung của một chuỗi expr biến, nó chỉ đem lại một bản sao chữ thường của chuỗi. Nếu expr được bỏ qua, các chức năng được gọi là đặc biệt đối với các biến $ _.

Một ví dụ đơn giản về việc làm thế nào để sử dụng nó:

# initialize some string variable

$str = "What is Perl Language for";

lc($str);

print $str, "\n";

# displays: What is Perl Language for

$str = lc($str);

print $str, "\n";

# displays: what is perl language for

Trong phần thứ ba dòng của đoạn mã này, chúng tôi chuyển đổi $ str để chữ thường, nhưng mà không có việc chuyển đổi của chúng tôi đã mất. Tiếp theo dòng mã số hiển thị cho bạn làm thế nào để làm điều đó.

LC chức năng này là rất hữu ích khi bạn cần phải thực hiện một số chuỗi so sánh chống lại một số chuỗi biến. Ghi nhớ rằng tất cả các chuỗi được so sánh nhạy cảm và các trường hợp sau đây strings "Perl" và "perl" không phải là như nhau. Với tư cách là một parenthesis, không bao giờ sử dụng tính toán trong chuỗi vận hành so sánh, vì nó cho kết quả chắc chắn sẽ không phải là một trong những bạn mong đợi.

Bây giờ hãy trở lại của chúng tôi nhận được so sánh. Nếu bạn muốn so sánh hai chuỗi các biến phân biệt dạng chữ bằng cách sử dụng chức năng LC, bạn có thể có ít nhất hai lựa chọn:

* Chuyển đổi strings trong cả hai chữ thường sử dụng một nhà điều hành và việc làm cho hơn so sánh

* So sánh các strings LC bằng cách gọi các chức năng cho mỗi người trong số họ, mà không có sự thay đổi các giá trị của họ

Xem trang kế tiếp trang ngắn ví dụ về cách để làm điều này:

40


#comparison using the assignment operator

$str1 = " rose";

$str2 = " ROSE";

$str1 = lc($str1);

$str2 = lc($str2);

if($str1 eq $str2)

{

print "The two strings are equal\n";

}

#comparison without altering the string values

$str1 = " rose";

$str2 = " ROSE";

if(lc($str1) eq lc($str2))

{


}

#print the two string are equal

VI. hàm LCFIRT

Không có gì nhiều để nói về Perl lcfirst chức năng. Mất một chuỗi ký tự, chuyển đổi các ký tự đầu tiên trong hơn chữ thường và trả về chuỗi mới. Có nhiều trường hợp không phải là nơi bạn có thể sử dụng nó, và nó có thể đã được thêm vào như là một nước của ucfirst chức năng. Tuy nhiên, tôi sẽ làm tốt nhất để tôi cho bạn thấy làm thế nào để sử dụng nó trong các ứng dụng.

Cũng như đối với các chuỗi đơn giản, chức năng, các cú pháp hình thức như sau:

lcfirst EXPR

lcfirst

41


Nó trả về giá trị của expr với các ký tự đầu tiên trong chữ thường. Nếu các đối số là một chuỗi biến, chức năng này trở về biến với những ký tự đầu tiên lowercased, nhưng nó không thay đổi nội dung của các biến. Trong phần thứ hai cú pháp hình thức, expr là bỏ qua, do đó, lcfirst sử dụng các chức năng đặc biệt biến $ _. Như với các chức năng khác, bạn có thể sử dụng hoặc bỏ dấu ngoặc, như bạn muốn. Nếu các chữ cái đầu tiên của chuỗi biểu là chữ thường, các chức năng sẽ làm gì.

Bây giờ hãy xem xét ví dụ sau để xem làm thế nào Perl lcfirst các công trình:

# initialize a string variable

$str = "An example about lcfirst function";

$newStr = lcfirst $str;

print "$newStr,\n";

# prints: an example about lcfirst function

Tiếp theo, chúng tôi sẽ kiểm tra một tiết "tinh vi" ví dụ. Hãy giả sử chúng tôi có một tiêu đề, nơi tất cả các từ bắt đầu bằng một chữ hoa và chúng tôi muốn chuyển đổi các chữ cái đầu tiên của mỗi từ trong chữ thường, ngoại trừ những chữ đầu tiên của tiêu đề. Đi một chút thời gian để kiểm tra các đoạn mã sau:

# store the title in a scalar string variable

$title = "A Short Story About Myself";

# split the string and place it into an array

@title = split / /, $title;

# now let’s iterate through the array

$flag = 0;

foreach (@title) {

if($flag == 0)

{

$flag = 1;

next;

42


}

$_ = lcfirst;

}

# convert the array to a space-delimited string

$title = join(" ", @title);

print "$title\n";

Một số ý kiến ở đây:

* Tiêu đề, chúng tôi lưu trong biến $ title

* Chúng tôi chia chuỗi thành một mảng bằng cách sử dụng không gian Dâu tach

* In the foreach loop:

o chúng tôi sử dụng $ cờ biến để bỏ qua những chữ đầu tiên của chuỗi theo thứ tự không thay đổi nó

o chúng tôi gọi lcfirst chống $ _

o chúng tôi lưu trữ những từ mới có giá trị trong $ _

* Chúng tôi sử dụng các chức năng tham gia chuyển đổi mảng lại vào chuỗi bằng cách sử dụng không gian-Dâu tach

* Cuối cùng, chúng tôi in chuỗi

Kết quả: A short story about myself

VII. hàm rindex

Bạn có thể xem xét Perl rindex chức năng giống như một đảo ngược cho các chức năng lập chỉ mục - substring bên phải sang bên trái để tìm kiếm. Nó trở về vị trí cuối cùng xuất hiện của một substring trong một chuỗi ký tự, nhìn từ bên phải sang bên trái để. Trong hướng dẫn này, chúng tôi sẽ hiển thị như thế nào để sử dụng chức năng này trong các ứng dụng tập lệnh của bạn thông qua một vài ví dụ điển hình.

Để tìm một substring trong một chuỗi ký tự từ bên phải sang bên trái để, bạn có thể sử dụng thường xuyên biểu quá, nhưng bằng cách sử dụng rindex là nhanh hơn và dễ dàng hơn để hiểu. Cố gắng tránh sử dụng thường xuyên biểu

43


cho chuỗi các hoạt động đơn giản, đặc biệt là khi xây dựng một số trong các chức năng được thiết kế đặc biệt cho mục đích này là sẵn có. Các thao tác RegExp có bộ nhớ các biến, do đó, giữ cho chúng để biết thêm các hoạt động tinh vi và phức tạp.

Trước khi bắt đầu bằng, bạn có thể skim một chút thông qua các chỉ mục trang Perl để hiểu rõ hơn về các chủ đề thảo luận here.Two cú pháp hình thức có sẵn cho các chức năng này:

rindex STR,SUBSTR,POSITION

rindex STR,SUBSTR

Tại đây, ba đối số có ý nghĩa sau đây:

* STR - một chuỗi ký tự mà bạn đang tìm kiếm

SUBSTR - substring các vị trí mà bạn muốn để xác định vị trí hoặc để tìm kiếm

* position - nếu được chỉ định, bìa phải đại diện cho các vị trí có thể được trả lại, từ vị trí đó các chức năng sẽ tìm kiếm từ bên phải sang bên trái để tìm substring để phù hợp với

Nếu bạn không cung cấp thứ ba, lý luận, các Perl rindex chức năng sẽ tìm kiếm cho substring bắt đầu bằng ký tự cuối cùng của chuỗi ký tự và từ bên phải sang bên trái để. Nó sẽ trở lại với vị trí đầu tiên xuất hiện của các substring nếu substring đã được tìm thấy và -1 khác. Các ngoặc là tùy chọn, đó là sự lựa chọn của bạn để sử dụng chúng hay không. Tuy nhiên, có những trường hợp khi nó được tốt hơn để sử dụng chúng, để làm cho mã của bạn đọc thêm.

Xin vui lòng kiểm tra mã dưới đây để xem một số ví dụ đơn giản về cách sử dụng Perl rindex chức năng:

# initialize a scalar string variable

$str = "Perl while Perl if Perl foreach";

$substr = "Perl";

$pos = rindex $str, $substr;

$pos1 = rindex($str, $substr, 15);

print "\$pos = $pos, \$pos1 = $pos1\n";

44


# it displays pos = 19, $pos1 = 11

Nó hoạt động giống như chức năng lập chỉ mục, ngoại trừ nó quét các chuỗi ký tự từ bên phải sang bên trái để trở về và các vị trí cuối cùng của substring xuất hiện, không có các sự khác biệt trong cách sử dụng của họ.

VII.1.Kiểm tra nếu một substring được bao gồm trong một chuỗi

Chúng tôi có thể sử dụng trở lại giá trị của Perl rindex chức năng để tìm hiểu xem nếu một substring được bao gồm trong một chuỗi ký tự, tìm từ ngược lại, tức là từ ghi vào bên trái. Chúng tôi cũng có thể cung cấp cho các vị trí của chúng tôi bắt đầu tìm kiếm hay cho rindex chức năng tìm kiếm từ bìa phải của chuỗi ký tự.

Nếu substring là không tìm thấy, rindex trả về -1, nếu không nó trở về vị trí cuối cùng của sự xuất hiện của các substring.

# initialize a string scalar

$textStr = "PDF::Create is a Perl module";

if(($pos = rindex(lc $textStr, lc "perl")) >= 0)

{

print "We found it!\n";

}

Xin lưu ý là lần đầu tiên, chúng tôi chuyển đổi các chuỗi ký tự và chữ thường trong substring (bằng cách sử dụng các chức năng LC) để thực hiện tìm kiếm của chúng tôi phân biệt dạng chữ.

VII.2.Tìm các sự cố của substring của chuỗi

Chúng tôi có thể tìm kiếm cho tất cả các sự xuất hiện của một substring trong một chuỗi ký tự, hoặc bằng cách sử dụng các chức năng lập chỉ mục hoặc rindex. Ví dụ dưới đây sẽ cho các vị trí của dấu gạch chéo ký tự trong một chuỗi (chúng tôi có thể sử dụng cùng một thuật toán để tìm kiếm một substring thành từ nhiều hơn một ký tự, mặc dù).

# initialize a string scalar

$url = "http://www.mysite.com/perl-rindex.html";

$pos = length($url)-1;

45


print "/ found at positions: ";

while(1)

{

$pos = rindex($url, "/", $pos);

last if($pos < 0);

print $pos--, " ";

}

print "\n";

#print / found at positions: 21 6 5

VIII. hàm substr

Perl substr chức năng là một trong những chức năng quan trọng nhất của chuỗi ký tự trong Perl là ngôn ngữ và có nghĩa là, để lấy các phụ strings của một chuỗi ký tự. Tuy nhiên, chức năng này là một chút phức tạp và nó hiện nhiều hơn tôi chỉ ra ở trên.

Trong hướng dẫn ngắn này, chúng tôi sẽ cho bạn thấy một số mẫu về việc làm thế nào để sử dụng nó cho thao strings, hoặc bạn sử dụng nó trong bối cảnh một mình hoặc với các chức năng giống như chuỗi chỉ mục hoặc chiều dài.

Nhiều strings Thao tác có thể được thực hiện bằng cách sử dụng sức mạnh của biểu thường xuyên, nhưng trong nhiều trường hợp, việc xây dựng trong chuỗi các chức năng là đơn giản và mất ít thời gian hơn để thực hiện.

Để bắt đầu với, hãy xem cú pháp hình thức có sẵn cho Perl substr chức năng

substr EXPR, OFFSET, LENGTH, REPLACEMENT

substr EXPR, OFFSET, LENGTH

substr EXPR, OFFSET

* Expr là một chuỗi biểu thức mà từ đó các substring sẽ được trích xuất

* offset là một chỉ mục từ các nơi mà các substring sẽ được trích xuất bắt đầu

* LENGTH là độ dài của substring để trích xuất

46


* Replacement là một chuỗi ký tự mà sẽ thay thế các substring

Giống như trong trường hợp với các chức năng khác, bạn có thể sử dụng các ngoặc hay không, làm điều đó như bạn muốn. Như bạn có thể nhìn thấy ở trên, một số đối số là bắt buộc và những người khác là tùy chọn. Bạn cần phải đề cập đến ít nhất là chuỗi biểu thức (expr) và vị trí (offset) từ nơi substring sẽ được trích xuất bắt đầu.

Trước khi xem xét những Perl substr tham số chức năng, tôi muốn nhắc bạn rằng trong Perl đầu tiên của một chuỗi ký tự có chỉ mục 0, thứ hai, 1, và do đó trên. Trên thực tế, bạn có thể sửa đổi điều này bằng cách thiết lập các biến đặc biệt $ [với gì bạn muốn,

nhưng hãy cẩn thận tuy nhiên nếu bạn quyết định thay đổi nó. Đối với strings $ [đại diện cho các chỉ mục của các ký tự đầu tiên của chuỗi và theo mặc định được cài là 0.

Đi một chút thời gian để xem xét ví dụ sau và nhìn thấy một mẫu mã về cách sử dụng Perl substr chức năng:

$names = "John Peterson Anne Mike";

$oneName = substr($names, 5, 8);

print "$names\n";

#it prints John Peterson Anne Mike

print "$oneName\n";

#it prints Peterson

Xin lưu ý rằng giá trị biến $ tên không thay đổi sau khi sử dụng các chức năng substr.

Chúng tôi có thể sử dụng chức năng substr Perl, hoặc trong các so sánh hay như một lvalue chẳng hạn như một bài tập. Trong trường hợp này cuối cùng, nếu expr sẽ là một chuỗi biến, giá trị của chuỗi biến sẽ được sửa đổi. Xem phần tiếp theo của khối mã này:

$names = "Alin Fred John";

substr($names, 5, 4) = "Mary";

print "$names\n";

47


# it prints Alin Mary John

Và bây giờ hãy trở lại nhận được các thông số của chúng tôi.

Có thể được offset:

Tích cực - các substring đó đến nay bắt đầu từ đầu của chuỗi

* Phủ định - các substring bắt đầu từ đó đến nay ngày cuối cùng của chuỗi

* 0 - đó có nghĩa là substring bắt đầu từ ký tự đầu tiên của chuỗi

Nếu bù đắp ở bên ngoài là chuỗi (ví dụ, một chuỗi có 10 ký tự và bù đắp là lớn hơn hoặc bằng 10), Perl substr chức năng sẽ trở lại với giá trị cúm gia cầm và nó sẽ tạo ra một cảnh báo lỗi.

Nếu substring sẽ được sử dụng như một lvalue, và được bù đắp hoàn toàn bên ngoài biểu chuỗi, một lỗi sẽ được phát hành. Xem các đoạn mã sau đây để minh họa các trường hợp thảo luận ở trên:

$names = "Alin Fred Peter";

$oneName = substr($names, -10, 4);

print "Name: $oneName\n";

$oneName = substr $names, -100, 4;

print "Name: $oneName\n";

substr($names, 20, 5) = "Alice";

output

Name: Fred

Name:

substr outside of string at 1.pl line 6.

LENGTH có thể là:

* Bỏ qua - các chức năng sẽ trở lại tất cả các ký tự bắt đầu với các vị trí bù đắp vào các thiết lập của các ký tự kết thúc chuỗi

48


* Tích cực - chức năng sẽ trở lại từ các chuỗi ký tự tối đa LENGTH bắt đầu với các vị trí offset

* Phủ định - nó sẽ trở lại với substring bắt đầu với sự bù đắp, nhưng mà không có vị trí mà nhiều ký tự ra khỏi cuối của chuỗi

* 0 - trong trường hợp này sẽ được trả lại substring trống rỗng, không có cảnh báo lỗi

Hãy xem ví dụ dưới đây mà chúng tôi cung cấp một số tình huống quá giới hạn:

$names = "Alex James Abby Shannon Monica";

$strNames = substr $names, 11; # length omitted

print "$strNames\n";

# prints Abby Shannon Monica

$strNames = substr $names, 24, 100; # length = 100


# prints Monica

$strNames = substr $names, 24, -2; # length = -2


# prints Moni

Bây giờ là một số vd về substr


substr($names, 11, 4) = "Alexandra";

print "$names\n";

# prints Alex James Alexandra Shannon Monica

Trong ví dụ trên, các substring "Abby" (được tìm thấy tại bù đắp 11) sẽ được thay thế bởi substring "Alexandra" này mặc dù substring dài hơn 4 (trong LENGTH substr để cung cấp chức năng). Như bạn thấy, $ bây giờ đã có tên ký tự nó đã có hơn ban đầu.

49


Tiếp theo, xem xét một ví dụ nơi substring được sử dụng để được chỉ định là ngắn hơn để cung cấp các LENGTH Perl substr chức năng:


substr($names, 11, 4) = "Tom";

print "$names\n";

# prints Alex James Tom Shannon Monica

Sau khi chuyển nhượng, $ tên đã trở nên ngắn hơn mà ban đầu xâu.

Bạn có thể chơi xung quanh với các ví dụ để xem làm thế nào substr các chức năng hoạt động trong các tình huống tương tự.

Replacement

Tôi cho bạn một số ví dụ ở trên về việc làm thế nào để sử dụng Perl substr chức năng như một lvalue khi bạn cần phải thay thế một substring với một số khác. Một cách khác để làm được điều này là để sử dụng những tham số của Replacement Perl substr chức năng, như trong ví dụ sau:


substr $names, 16, 7, "Alexandra";

# it will replace "Shannon" with "Alexandra"

print "$names\n";

# it prints Alex James Abby Alexandra Monica

Như bạn đã thấy trong ví dụ trên, $ tên sẽ thay đổi giá trị sau khi thay thế (như trong trường hợp một lvalue).

Cuối cùng, tôi sẽ cho bạn thấy một đoạn mã ứng dụng nhỏ, nơi bạn có thể xem như thế nào bạn có thể sử dụng chức năng Perl substr trong chuỗi kết nối với các chức năng.

IX. hàm uc

Perl uc Chức năng

Perl uc chức năng (mà viết tắt của chữ hoa) là có nghĩa là để trở về một phiên bản chữ của một chuỗi biểu. Một số ví dụ về các cách thức hữu ích để sử dụng

50


chức năng này trong script của bạn sẽ được cung cấp cho bạn trong việc này hướng dẫn. LC nhấp vào liên kết để xem PV LC Perl chức năng mà chuyển đổi một chuỗi ký tự chữ thường để biểu.

Có hai cú pháp hình thức cho các chức năng này:

uc EXPR

uc

Xin lưu ý rằng các chức năng Perl uc hiện không thay đổi chuỗi biến nội dung, nhưng nó sẽ đem lại một bản sao của các chữ hoa chuỗi. Nếu bạn bỏ expr tham số, các chức năng sẽ sử dụng nội dung của các biến đặc biệt $ _.

Dưới đây là một ví dụ về việc làm thế nào để sử dụng nó:

# initialize some string variable

$string = "This is about Perl Functions";

uc($string);

print $string, "\n";

# displays: This is about Perl Functions

$string = uc($string);

print $string, "\n";

# displays: THIS IS ABOUT PERL FUNCTIONS

Nếu chúng tôi không làm một việc cho các biến, chúng tôi chuyển đổi thông qua uc chức năng, các kết quả của việc chuyển đổi sẽ bị mất - bạn có thể thấy điều này trong các dòng 3-5 trên mã. Ở phần cuối của mã số, chúng tôi lưu trữ các chữ hoa có giá trị chuyển đổi trong cùng một biến (dòng 6) và chúng tôi in lại nó.

Uc chức năng này là rất hữu ích khi bạn thực hiện một số chuỗi so sánh. Cố gắng nhớ rằng tất cả các trường hợp được so sánh nhạy cảm và các trang sau strings "uc" và "UC" không phải là như nhau.

Bây giờ hãy xem xét các phân biệt dạng chữ so sánh hai strings. Chúng tôi có thể sử dụng chức năng uc, hoặc chuyển đổi cả hai strings lowercases trong việc sử dụng một nhà điều hành và làm cho hơn so sánh hoặc so sánh bằng cách gọi

51


điện thoại cho strings uc chức năng cho mỗi người trong số họ, mà không có sự thay đổi các giá trị của họ.

Kế tiếp ngắn ví dụ cho bạn thấy làm thế nào để làm được điều này:

$string1 = "blue";

$string2 = "Blue";

$string1 = uc($str1);

$string2 = uc($str2);

if($string1 eq $string2)

{


}

#comparison without altering the string values

$string1 = "blue";

$string2 = "Blue";

if(uc($string1) eq uc($string2))

{


}

Chương 5: Xây dựng lại một số hàm xử lý chuỗi trong Pascal.

program Perl;uses crt;

52


const spt=10;type arr=array [1..10] of char; s=string; mangbam=record khoa:string; giatri:string; end; mb= array [1..spt]of mangbam; r=array [1..10] of string; int=array [1..10] of integer;var h,mylist :s; q, N: s; c, b:s; p, i:integer; d, k:integer; l,tr,u,v:mb; t,y:r;{______________________push_________________________________}procedure hampush(a,n:s); {Them xau xau n vao sau xau s}var i:integer;begin writeln('1. xau ban dau '); writeln(a); writeln; a:=a+n; writeln('1. xau xu ly do push : '); writeln(a); writeln;end;{____________________POP____________________________________}procedure ham_pop(a,n:s);{Lay ra phan tu n o cuoi xau a }var da,dn,i:integer; c:s; j,dem:integer;begin writeln('2. xau ban dau '); writeln(a); writeln;

53


writeln('2. xu ly do pop: '); da:=length(a); dn:=length(n); i:=1; j:=1; dem:=0; while (a[da-dn+i]=n[j]) and (j<=dn) do begin i:=i+1; j:=j+1; dem:=dem+1; end; if dem=dn then for i:=1 to da-dn do write(a[i]) else begin c:='2. khong xu ly duoc'; end; writeln;end;{___________________CHOP___________________________________}procedure hamchop(a:s);{cat ky tu cuoi dong cua xau a}var d:integer; i:integer;begin writeln('3. xau ban dau '); writeln(a); writeln; d:=length(a); writeln('3. xu ly do chop la: '); for i:=1 to (d-1) do WRITE(a[i]); writeln;end;{_____________________UNSHIFT______________________________}procedure ham_unshift(a,n:s);{them xau n vao truoc mang a}begin writeln('5. xau ban dau '); writeln(a); writeln;

54


a:=n+a; writeln('5. xu ly do unshift: '); writeln(a); writeln;end;{____________________________SHIFT}procedure ham_shift(x,a:s);{cat ky tu dau trong xau a}var da,dx,i:integer; c:s; j,dem:integer;begin writeln('6. xau ban dau '); writeln(a); writeln; writeln('6. xu ly do shift: '); da:=length(a); dx:=length(x); i:=1; j:=1; dem:=0; while (a[i]=x[j]) and (j<=dx) do begin i:=i+1; j:=j+1; dem:=dem+1; end; if dem=dx then for i:=dx+1 to da do write(a[i]) else begin c:='6. khong xu ly duoc'; end; writeln;end;

{___________________________REVERSE_______________________}procedure ham_reverse(a:s); {dao nguoc ky tu trong xau a}var i,d:integer; c:S;begin

55


writeln('7. xu ly do reverse '); writeln('xau ban dau la : '); writeln(a); writeln; d:=length(a); i:=1; while(d>=0) do begin c[i]:=a[d]; d:=d-1; i:=i+1; end; a:=c; writeln('xy ly reverse'); writeln(a); writeln;end;{_______________________SORT_______________________________}procedure ham_sort(a:s); {SAP XEP CHU CAI TRONG XAU}var tg: char; i,j,d:integer;begin writeln('xu ly dao sap xep xau :'); writeln('xau dc sap xep la: ',a); writeln; d:=length(a); for i:=1 to d-1 do for j:=i+1 to d do begin if ord(a[i])>ord(a[j]) then begin tg:=a[i]; a[i]:=a[j]; a[j]:=tg; end; end; writeln('xu ly do sort');WRITELN(a);writeln;END;{ MANG BAM __________________KEYS_____________________________}procedure ham_keys(a:mb;spt:integer; var t:r);

56


{tra ve danh sach toan bo cac khoa hien co trong mang bam a: mang vao, spt: so phan tu mang, t:cac khoa tra ve}var i:integer;begin writeln('8. xy ly do keys : '); for i:=1 to spt do begin t[i]:=a[i].khoa; write('"',t[i],'"'); end; writeln;end;{___________________________VALUES________________________}procedure ham_values(a:mb;spt:integer;var y:r );{tra ve mot danh sach tat ca cac gia tri hien tai cua mang theo cac khoa co o mang a: mang vao,spt: so phan tu cua mang, y:danh sach tra ve}var i:integer;begin writeln('9. xu ly do values '); for i:=1 to spt do begin y[i]:=a[i].giatri; write(y[i],','); end; end;{___________________EACH___________________________________}procedure ham_each(a:mb;spt:integer;var u:mb);{dua ra danh sach cac gia tri cac khoa cua mang bam da nhapa: mang bam da nhap,spt:so phan tu cua mang bam, u:mang ra}var i:integer;begin writeln('10. xu ly do each '); for i:=1 to spt do begin u[i].khoa:=a[i].khoa; write('"',u[i].khoa,'"'); u[i].giatri:=a[i].giatri; write(',',u[i].giatri,'.'); end; writeln;end;{_______________DELETE____________________________________}

57


procedure ham_delete(a:mb;spt:integer;b:s;var l:mb);{xoa mot khoa ra khoi mang bama: xau ban dau spt:so phan tu mang bam,s:la xau can xoa,l:xau ra}var i,d:integer;begin writeln('11. xu ly do delete: '); d:=1; for i:=1 to spt do if (a[i].khoa<>b) then begin l[d].khoa:=a[i].khoa; l[d].giatri:=a[i].giatri; d:=d+1; write(a[i].khoa,',',a[i].giatri,'.'); end; writeln;end;{ _______________________THAYTHE____________________________} procedure H_thaythe(a,b,c:s);{a la xau ban dau,b la xau doi sanh, c la xau can thay the vao a}var i,da,db:integer; j,dk:integer;begin writeln('12. xau ban dau :'); writeln(a); writeln('xau ',b,' duoc thay the boi ',c); writeln('12. xu ly do ham thay the'); dk:=1; j:=1; da:=length(a); db:=length(b); for i:=1 to da do {duyet tu dau cho toi cuoi mang a} begin if a[i]=b[1] then {neu xuat hien bang thi lam} begin{xet tu phan tu do toi phan tu i+db} for k:=i to i+db do for j:=1 to db do begin if a[k]<>b[j] then dk:=dk+1; if dk= 1 then{tuc sanh xau giong nhau hoan toan} begin write (c); i:=i+db+1;

58


end; end; end; write(a[i]); end; writeln;end;{_______________INDEX_____________________________________}procedure H_index(a:s;b:s);{tim mot xau con b trong xau a tra ve vi tri neu tim thay va -1 neu k thay}var dem,i,j,da,db:integer;begin writeln('tim xau con ',b,'trong xau',a); writeln('13.xu ly do index '); da:=length(a); db:=length(b); {writeln('chieu dai xau 1 ',da); writeln('chieu dau xau 2 ',db);} i:=1;dem:=0; while((i<da) and (dem<db))do begin if (a[i] =b[1])then for K:=i to i+db do for j:=1 to db do if a[k]=b[j] then dem:=dem+1; i:=i+1;;

end; if i<da then writeln('da tim thay o vi tri',i-1){vi bat dau tu chi so 0} else writeln('khong tim thay ',-1); writeln;end;{_______________Chuong trinh chinh____________________________}BEGINCLRSCR;{___________________Xu ly chomp,chop,push,pop,sort______________}

mylist:='KHMT2 hoc automat';writeln('xau xu ly la : ');n:='automat -Giang Vien Ths. Nguyen Hung Cuong';writeln;HAMPUSH(MYLIST,N);b:='khmt2 hoc automat';c:='automat';

59


ham_pop(b,c);b:='khmt2 hoc gi vay?';ham_pop(b,c);writeln;hamchop(mylist);writeln;hamchomp(mylist);writeln;b:='ABDFREWYUOPMASW';ham_sort(b);

{_______________Xu ly unshift ____________shift_________________}ham_unshift(mylist,n);writeln;b:='automat do thay nguyen hung cuong day';c:='automat';ham_shift(c,b);writeln;c:='tri tue nhan tao';ham_shift(c,b);writeln;

{____________________Xu ly reverse____________________________}ham_reverse(mylist);writeln;ham_reverse(b);WRITELN;

{_____________________ mang bam____________________}

writeln('nhap so phan tu cua mang bam k= ');readln(k);d:=0;for i:=1 to k dobegin writeln('nhap khoa thu',i,' cho mang bam ');readln(v[i].khoa); writeln('nhap gia tri thu',i,' cho mang bam ');readln(v[i].giatri); end; writeln; ham_keys(v,k,t); ham_values(v,k,y); writeln; writeln('toan tu each'); ham_each(v,k,u); writeln; writeln('ham delete'); writeln; writeln('nhap tu khoa muon xoa trong mang bam '); readln (q);

60


ham_delete(v,k,q,l);{______________________H_THAYTHE____________________}

q:='hoc automat rat kho ma lai van phai hoc'; b:='kho'; c:='automat'; h_thaythe(q,c,b);

{__________________HAM_INDEX_____________________________}writeln('tim xau con');

b:='hoan thanh bai tap lon automat';c:='automat';h_index(b,c);

{___________________________________________________________}READLN;END.

Kết luận

61


Qua quá trình tìm hiểu, chúng em nhận thấy Perl là ngôn ngữ rất mạnh trong việc xử lý xâu văn bản. Ngoài ra, Perl còn có một số ưu điểm khác:

+ Perl có sức mạnh và sự linh hoạt của ngôn ngữ lập trình cấp cao C.

+ Giống như các ngôn ngữ shell scripts, Perl không đòi hỏi biên dịch và link mã nguồn, thay vào đó chỉ cần gọi Perl thực thi chương trình đó.

+ Chạy được trên nhiều platfrom: UNIX, DOS, WINDOWS.

+ Perl chuyên về xử lý text, có nhiều hàm build-in, thích hợp với xử lý trang web trong thế giới WWW.

Ngoài ra Perl còn rất nhiều điểm mạnh như của các ngôn ngữ lập trình khác.

Như đã nói ở trên, mỗi ngôn ngữ lập trình đều có điểm mạnh, điểm yếu, vì chúng được thiết kế cho những mục đích đặc biệt khác nhau. Việc sử dụng ngôn ngữ nào phải tùy thuộc vào yêu cầu sao cho phù hợp.

Ở bài này, chúng em mới chỉ đi sâu tìm hiểu vào các hàm xử lý chuỗi của ngôn ngữ Perl. Để có thể hiểu rõ và thành thạo một ngôn ngữ cần có thời gian tìm hiểu, học hỏi, và rất cần sự hướng dẫn của các thầy, cô.

Chúng em xin chân thành cảm ơn thầy Trần Hùng Cường đã hướng dẫn để chúng em hoàn thành bài tập lớn này.

DANH MỤC TÀI LIỆU THAM KHẢO

62


1. Sổ tay lập trình 2.0

2. http://www.ddth.com

3. http://docs.activestate.com/activeperl/5.10/lib/pods/perlfunc.html#chomp

4. http://www.devshed.com/c/a/Perl/String-Processing-with-Perl/

5. Learning Perl

63

http://www.devshed.com/c/a/Perl/String-Processing-with-Perl/

http://docs.activestate.com/activeperl/5.10/lib/pods/perlfunc.html#chomp

http://www.ddth.com/

Documents

Gioi Thieu Perl