7 პასუხი

ბიბლიოთეკა მოიცავს მრავალ კონვერტაციის ფუნქციას უნიკოდში გადასასვლელად და უნიკოდში გადასასვლელად, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ის, რაც ყველაზე მეტად ასახავს თქვენს აპლიკაციას.

ნება მომეცით რამდენიმე რამ გავასწორო. სიმბოლოების ნაკრები (დაშიფვრა) და სიმბოლოების კოდირება ორი დაკავშირებული, მაგრამ განსხვავებული ცნებაა. პერსონაჟების ნაკრები არის აბსტრაქტული სიაპერსონაჟებთან ერთად გარკვეული კოდიმთელი რიცხვი სიმბოლო. შემდეგ არის სიმბოლოების კოდირება, რომელიც ძირითადად არის ალგორითმი, რომელიც აღწერს, თუ როგორ არის სიმბოლოები წარმოდგენილი ბაიტებში.

თქვენ შეგიძლიათ გამოიყენოთ ფუნქცია http://swissdelphicenter.ch/en/showcode.php?id=1692
იგი აკონვერტებს Unicode სტრიქონს Ansi სტრინგად მითითებულის გამოყენებით კოდის გვერდი.
თუ გსურთ კონვერტაცია სისტემის ნაგულისხმევი კოდის გვერდის გამოყენებით (რეგიონულ ვარიანტებში განსაზღვრულია, როგორც არა Unicode კოდის გვერდი), შეგიძლიათ გააკეთოთ ეს უბრალოდ ასე:

Var ws: განიერი; s:string; დასაწყისი s:=string(ws)

"ASCII" არის სიმბოლოების ციფრებზე სპეციფიკური შედარების სახელი, მაგრამ ზოგი ამბობს "ASCII კოდს", როდესაც ისინი საერთოდ არ გულისხმობენ ASCII-ს; მათ უბრალოდ სურთ რიცხვითი მნიშვნელობასიმბოლო, მიუხედავად იმისა, თუ რომელი ჩვენება მოქმედებს იმ დროს. ეს აღწერა ეხება თქვენ?

თუ ასეა, მაშინ შეგიძლიათ გამოიყენოთ სტანდარტული ფუნქციაშეუკვეთეთ, რომ მიიღოთ უნიკოდის კოდის წერტილის მნიშვნელობა ნებისმიერი უნიქოდის სიმბოლოსთვის.

Var wc: WideChar; ws: WideString; x: სიტყვა; x:= Ord(wc); x:= Ord(ws);

თუ რეალურად გულისხმობთ ASCII-ს, მაშინ უფრო კონკრეტული უნდა იყოთ იმის შესახებ, თუ რა სახის კონვერტაციას გულისხმობთ.

მაგალითად, ასო A წარმოდგენილია უნიკოდში, როგორც U+0041, მაგრამ ansi-ში არის მხოლოდ 41. ასე რომ, კონვერტაცია საკმაოდ მარტივი იქნება, მაგრამ თქვენ უნდა გაიგოთ, თუ როგორ არის დაშიფრული უნიკოდის სიმბოლო. ყველაზე გავრცელებულია UTF-16 და UTF-8. UTF 16 ძირითადად ორი ბაიტია თითო სიმბოლოზე, მაგრამ ესეც გამარტივებაა, რადგან სიმბოლოს შეიძლება ჰქონდეს მეტი ბაიტი. UTF-8 ჟღერს, თითქოს ნიშნავს 1 ბაიტს თითო სიმბოლოზე, მაგრამ ეს შეიძლება იყოს 2 ან 3. კიდევ უფრო გართულდეს საქმეები, UTF-16 შეიძლება იყოს ცოტა მეტი ან მეტი. (U+0041 ან U+4100).

მოდით ვისაუბროთ იმაზე, თუ როგორ წარმოადგენს დელფის სიმბოლოები და რა ტიპის მონაცემები შეიძლება იყოს ისინი. სიმბოლოების შესანახად და დასამუშავებლად გამოიყენეთ Ansichar და WideChar მონაცემთა ტიპების ცვლადები:

1. Ansichar მონაცემთა ტიპიწარმოდგენილია როგორც ANSI სიმბოლოების გარკვეული ნაკრები, რომელიც შეიცავს ერთ ბაიტში დაშიფრულ სიმბოლოებს (ბაიტი არის რვა ბიტიანი ორობითი რიცხვი).
2. WideChar მონაცემთა ტიპიემთხვევა პერსონაჟების კომპლექტს უნიკოდის კოდირება, რომელიც მოიცავს ორ ბაიტში დაშიფრულ სიმბოლოებს.

თავსებადობის უზრუნველსაყოფად წინა ვერსიებიგამოიყენეთ Char მონაცემთა ტიპი, რომელიც ექვივალენტურია Ansichar ტიპის. ცვლადის მნიშვნელობა, რომელსაც აქვს სიმბოლოს ტიპი, შეიძლება იყოს ნებისმიერი ნაჩვენები სიმბოლო:

• ნებისმიერი ნომერი
• ნებისმიერი სასვენი ნიშანი,
• ნებისმიერი რუსული ასო ან ლათინური ანბანი,

ასევე სპეციალური სიმბოლო, მაგალითად, "ახალი ხაზი". როგორც მოსალოდნელი იყო, ცვლადი ხასიათის მონაცემთა ტიპით გამოცხადებულია var განყოფილებაში (ცვლადი დეკლარაციის განყოფილება). ზოგადი ფორმადელფის სიმბოლოს დეკლარაციის ინსტრუქციები შემდეგია:

• სახელი– ნიშნავს ცვლადს სიმბოლოს მონაცემთა ტიპით;
• char- განსაკუთრებული საკვანძო სიტყვა, რომელიც აღნიშნავს პერსონაჟის ტიპს.

მაგალითი 1.

ოჯახი: char;

როგორც ნებისმიერი ცვლადის შემთხვევაში, სიმბოლოს ტიპის char ცვლადი იძენს თავის მნიშვნელობას დავალების შესრულებისას. ვთქვათ, თუ დავალების შესრულების შემდეგ char ტიპის ცვლადი იღებს გარკვეულ მნიშვნელობას, მაშინ მინიჭების ნიშნის მარჯვნივ: = უნდა იყოს გამოხატულება char ტიპის, მაგალითად, ცვლადი char ტიპის, ან სიმბოლო მუდმივი - რაღაც სიმბოლო, ჩასმული ბრჭყალებში.

მაგალითი 2. მოდით ცვლადები a და b იყოს სიმბოლოს ტიპის ცვლადები. ინსტრუქციების დასრულების შემდეგ

n:= '*';

ცვლადი a იძენს მნიშვნელობას მითითებულ მუდმივზე მნიშვნელობის მინიჭებით, ხოლო b ცვლადი - ზემოხსენებული a ცვლადის მნიშვნელობის მინიჭებით. ასევე შესაძლებელია char ტიპის ცვლადის შედარება char ტიპის სხვა ცვლადთან ან სიმბოლოს მუდმივთან.

ეს შედარება არის ის, რომ თითოეული სიმბოლო შეესაბამება გარკვეულ რიცხვს. მაგალითად, სიმბოლო „o“ უფრო მცირე რიცხვია ვიდრე სიმბოლო Y, სიმბოლო „A“ არის უფრო მცირე რიცხვი ვიდრე სიმბოლო „b“, სიმბოლო V ასოცირდება a-ზე მცირე რიცხვთან. შედეგად, შეგიძლიათ დაწეროთ:

‘0’ < ‘1’ < … < ‘9’ < … < ‘A’ < ‘B ‘< … < ‘Z’ < ‘a’ < ‘b’ < … < ‘z’

დიდი რიცხვები ენიჭება რუსული ანბანის სიმბოლოებს, ხოლო მცირე რიცხვები წარმოადგენს ლათინური ანბანის სიმბოლოებს. შემდეგი განცხადება მართალია:

'A'< ‘Б’ < ‘В’ < … < ‘Ю’ < ‘Я’ < ‘а’ < ‘б’ < ‘в’ < … < ‘э’ < ‘ю’ < ‘я’

IN საწყისი კოდიპროგრამა, თავად სიმბოლოს ნაცვლად, შეგიძლიათ მიუთითოთ მისი შესაბამისი კოდი, რომელიც შედგება ოპერატორის #-ისგან, რასაც მოჰყვება გარკვეული ნომერი. მაგალითად, სიმბოლოს "in" ნაცვლად, შეგიძლიათ მიუთითოთ მისი კოდი: #193.

სიმბოლოს წარმოდგენის ეს მეთოდი საუკეთესოდ გამოიყენება მაშინ, როდესაც საჭიროა სერვისის სიმბოლოების ან სიმბოლოების ჩაწერა, რომლებიც პროგრამის შედგენის პროცესში შეუძლებელია კლავიატურიდან შეყვანა. მაგალითად, ძალიან ხშირად პროგრამის საწყის კოდში, "ახალი ხაზის" სიმბოლოსთან ერთად შეტყობინებების ჩაწერის პროცესში გამოიყენება კოდი #13. დელფის სიმბოლოების დასამუშავებლად გამოიყენეთ chr და ord ფუნქციები.

chr Delphi ფუნქცია

chr ფუნქცია აბრუნებს მნიშვნელობას - სიმბოლოს, რომლის კოდიც არის ამ ფუნქციის პარამეტრი.

მაგალითი

ეს ინსტრუქცია ნიშნავს, რომ n ცვლადს ენიჭება მნიშვნელობის სივრცე.

ან დელფის ფუნქცია

ord ფუნქციის გამოყენებით განისაზღვრება სიმბოლოს კოდი, რომელიც გადაეცემა მას პარამეტრად.

მაგალითი

m:=ord('*');

ამ ინსტრუქციის შესრულების შედეგი იქნება ცვლადი m, რომელიც შეიცავს რიცხვს 42, რომელიც არის სიმბოლო "*"-ის კოდი.

პროგრამების მაგალითები დელფის სიმბოლოების გამოყენებით

მოდით შევქმნათ პროგრამა (მისი ჩამონათვალი წარმოდგენილია ქვემოთ), რომელიც აჩვენებს რუსული ანბანის ასოებს და მათ დაშიფვრას:

დელფი/პასკალი

ერთეულის კოდირება; ინტერფეისი იყენებს Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; ტიპი TForm1 = class(TForm) Label1: TLabe1; პროცედურა FormActivate(გამომგზავნი: TObject); კერძო (Private declarations) public (Public declarations) დასასრული; var Form1: TForm1; განხორციელების ($R *.DFM) პროცედურა TForm1.FormActivate(Sender: TObject); var s:string; // წარმოიდგინეთ ცხრილი, როგორც სიმბოლოების სტრიქონი kod: byte; // სიმბოლოების კოდირება i,j: მთელი რიცხვი; // i - მწკრივის ნომერი, j - ცხრილის სვეტის ნომერი იწყება s:=" "; კოდი:=192; i:=0-დან 15-მდე do // გამომავალი იქნება 16 სტრიქონში, start kod:=i + 192; j:=1-დან 4-მდე გააკეთეთ // შექმენით 4 სვეტი ცხრილში, დაიწყეთ s:=s+chr(kod)+"-"+IntToStr(kod)+" "; კოდი:=kod + 16; დასასრული; s:=s + #13; // ეკრანის ბოლოს ახალ ხაზზე გადასვლა; Label1.caption:=s; დასასრული; დასასრული.

ერთეულის კოდირება; ინტერფეისი იყენებს Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; ტიპი TForm1 = კლასი (TForm) Label1: TLabe1; პროცედურა FormActivate (გამომგზავნი: TObject); კერძო (პირადი დეკლარაციები) საჯარო (საჯარო განცხადებები) დასასრული ; var Form1: TForm1; განხორციელება ($R*.DFM) პროცედურა TForm1. FormActivate(გამომგზავნი: TObject); var s: string; // ცხრილის წარმოდგენა სიმბოლოების სტრიქონად კოდი: ბაიტი; // სიმბოლოების კოდირება i, j: მთელი რიცხვი; // i - მწკრივის ნომერი, j - ცხრილის სვეტის ნომერი დასაწყისი s: = ""; კოდი := 192 ; მე := 0-დან 15-მდე ვაკეთებ // გამომავალი იქნება 16 სტრიქონში დაიწყოს კოდი := i +192 ;

შესავალი

ტექსტის დამუშავება პროგრამირების ერთ-ერთი ყველაზე გავრცელებული ამოცანაა. თუ თქვენ გჭირდებათ რაიმე ტექსტური მონაცემების დამუშავება, მაშინ უბრალოდ არ შეგიძლიათ გააკეთოთ იმ მასალის ცოდნის გარეშე, რომელიც ქვემოთ იქნება წარმოდგენილი. მით უმეტეს, თუ მონაცემები გენერირებულია არა პირადად თქვენ მიერ, არამედ ზოგიერთის მიერ მესამე მხარის პროგრამაან სხვა პირი.

სიმბოლოები

სიმბოლო არის ტექსტის ერთი ერთეული. ეს არის ასო, რიცხვი, ერთგვარი ნიშანი. სიმბოლოების კოდის ცხრილი შედგება 256 პოზიციები, ე.ი. თითოეულ პერსონაჟს აქვს საკუთარი უნიკალური კოდი 0-დან 255-მდე. სიმბოლო გარკვეული კოდით ნდაწერე ასე: #ნ. ზუსტად ასეა მითითებული სიმბოლოები პროგრამის კოდში. ვინაიდან სიმბოლოს კოდი არის რიცხვი, რომელიც არ აღემატება 255-ს, აშკარაა, რომ მეხსიერებაში სიმბოლო იღებს 1 ბაიტს. მოგეხსენებათ, ბაიტზე ნაკლები განზომილება არ არის. უფრო ზუსტად, ის არსებობს - ცოტაა, მაგრამ პროგრამაში ბიტებთან მუშაობა არ შეგვიძლია: ბაიტი - მინიმალური ერთეული. თქვენ შეგიძლიათ ნახოთ სიმბოლოების ცხრილი და მათი კოდების გამოყენებით სტანდარტული კომუნალური "სიმბოლოების ცხრილი", შედის Windows-ში (მალსახი მდებარეობს მენიუში დაწყება - პროგრამები - აქსესუარები - სისტემის ინსტრუმენტები). მაგრამ ძალიან მალე ჩვენ თვითონ დავწერთ მსგავს რამეს.

სიმები

ხაზი, აკა ტექსტიარის პერსონაჟების ნაკრები, მათი ნებისმიერი თანმიმდევრობა. შესაბამისად, ერთი სიმბოლო ასევე არის სტრიქონი, ასევე ტექსტი. ტექსტის სტრიქონს აქვს გარკვეული სიგრძე. სტრიქონის სიგრძე არის სიმბოლოების რაოდენობა, რომელიც მას შეიცავს. თუ ერთი სიმბოლო იკავებს 1 ბაიტს, მაშინ N სიმბოლოს სტრიქონი იკავებს N ბაიტს.
არის სხვა კოდის ცხრილები, რომლებშიც 1 სიმბოლო წარმოდგენილია არა ერთი ბაიტით, არამედ ორით. ეს Unicode (Unicode). უნიკოდის ცხრილი შეიცავს სიმბოლოებს მსოფლიოს ყველა ენიდან. სამწუხაროდ, უნიკოდთან მუშაობა საკმაოდ რთულია და მისი მხარდაჭერა ამჟამად მხოლოდ ადგილობრივი ხასიათი. Delphi არ იძლევა უნიკოდის შესაძლებლობებს. პროგრამული ნაწილიარის, მაგრამ აქ ვიზუალური ელემენტები- ფორმები, ღილაკები და ა.შ. ვერ აჩვენებს ტექსტს Unicode ფორმატში. ვიმედოვნებთ, რომ მსგავსი მხარდაჭერა უახლოეს მომავალში გამოჩნდება. 2 ბაიტსაც უწოდებენ ერთი სიტყვით (სიტყვა). აქედან გამომდინარეობს შესაბამისის სახელწოდება რიცხვითი ტიპიმონაცემები - სიტყვა(რიცხვი, რომელიც იკავებს 2 ბაიტს მეხსიერებაში, მნიშვნელობები 0-დან 65535-მდე). უნიკოდის ცხრილში "უჯრედების" რაოდენობაა 65536 და ეს სავსებით საკმარისია მსოფლიოს ყველა ენის შესანახად. თუ გადაწყვეტთ, რომ "1 ბაიტი - 256 მნიშვნელობა, შემდეგ 2 ბაიტი - 2*256 = 512 მნიშვნელობა", გირჩევთ დაიმახსოვროთ ბინარული სისტემადა კომპიუტერში მონაცემების შენახვის პრინციპი.

მონაცემთა ტიპები

გადავიდეთ პირდაპირ პროგრამირებაზე. სიმბოლოებთან და სტრიქონებთან მუშაობისთვის არსებობს მონაცემთა შესაბამისი ტიპები:

Char - ერთი სიმბოლო (ანუ 1 ბაიტი);
სტრიქონი - სიმბოლოს სტრიქონი, ტექსტი (N ბაიტი).

ოფიციალურად, სტრიქონებს მხოლოდ 255 სიმბოლოს იტევს, მაგრამ დელფში შეგიძლიათ დაწეროთ ბევრად მეტი თითო სტრიქონზე. დიდი ტექსტების და სპეციალური სიმბოლოების მქონე ტექსტების შესანახად, არსებობს სპეციალური ტიპებიმონაცემები AnsiStringდა WideString(ეს უკანასკნელი, სხვათა შორის, ორბაიტიანია, ე.ი. უნიკოდისთვის).

პასკალში ტექსტის მნიშვნელობების დასაყენებლად გამოიყენეთ ცალკეული ციტატები (არა ორმაგი!). იმათ. როდესაც გსურთ სიმებიანი ცვლადისთვის მნიშვნელობის მინიჭება, ეს ასე უნდა გააკეთოთ:

S:="ტექსტი" ;

სიმბოლოები მითითებულია იმავე გზით, მხოლოდ ბრჭყალებში არის ერთი სიმბოლო.

თუ გსურთ მკაცრად შეზღუდოთ სტრიქონის ცვლადში შენახული ტექსტის სიგრძე, შეგიძლიათ გააკეთოთ ეს ასე:

var s: string [10];

ხაზის მაქსიმალური სიგრძე მითითებულია ფრჩხილებში.

სიმებიანი ოპერაციები

სიმებიანი ძირითადი ოპერაცია არის დამატება. რიცხვების მსგავსად, სტრიქონები შეიძლება დაემატოს. და თუ თქვენ არ შეგიძლიათ დაამატოთ სკამები ფორთოხლით რიცხვებში, მაშინ შეგიძლიათ ხაზებში. სიმებიანი დამატება უბრალოდ მათ აერთიანებს. მაგალითი:

var s: string ; ... s :="123" +"456" ; //s = "123456"

ვინაიდან თითოეული ხაზი სიმბოლოების თანმიმდევრობაა, თითოეულ სიმბოლოს აქვს საკუთარი სერიული ნომერი. პასკალში სიმბოლოების ნუმერაცია სტრიქონებში იწყება 1-დან ე.ი. ხაზში " ABC"სიმბოლო" ა" - პირველი, " ბ" - მეორე და ა.შ.
სტრიქონში პერსონაჟის სერიული ნომერი შემთხვევით არ გამოიგონეს, რადგან სწორედ ამ ციფრებით, ინდექსებით ხდება მოქმედებები ხაზებზე. თქვენ შეგიძლიათ მიიღოთ ნებისმიერი სიმბოლო სტრიქონიდან მისი ნომრის მითითებით კვადრატული ფრჩხილებიცვლადის სახელის გვერდით. Მაგალითად:

var s: string ; გ: char ; ... s :="გამარჯობა!" ; c:=s[ 2] ; //c = "ე"

ცოტა მოგვიანებით, როცა მასივებს შევისწავლით, ცხადი გახდება, რომ სტრიქონი სიმბოლოთა მასივია. ეს გულისხმობს ცალკეული სიმბოლოების მიმართვის ფორმას.

სიმებიანი დამუშავება

მოდით გადავიდეთ სტრიქონების დამუშავების ფუნქციებსა და პროცედურებზე.

სიმების სიგრძე

სტრიქონის სიგრძე შეგიძლიათ იხილოთ ფუნქციის გამოყენებით სიგრძე (). ფუნქცია იღებს ერთ პარამეტრს - სტრიქონს და აბრუნებს მის სიგრძეს. მაგალითი:

var Str: სიმებიანი; L: მთელი რიცხვი; ( ... ) Str :="გამარჯობა!" ; L:=სიგრძე(Str); //ლ = 6

სტრიქონში ქვესტრიქონის პოვნა

თანდაყოლილი ამოცანაა სტრიქონში ქვესტრიქონის პოვნა. იმათ. პრობლემა ჩამოყალიბებულია შემდეგნაირად: არის სტრიქონი S1. დაადგინეთ რა პოზიციიდან შედის მასში სტრიქონი S2. ამ ოპერაციის ჩატარების გარეშე რაიმე დამუშავების წარმოდგენა შეუძლებელია.
ასე რომ, ასეთი აღმოჩენისთვის არის ფუნქცია პოზ(). ფუნქცია იღებს ორ პარამეტრს: პირველი - ქვესტრიქონი, რომელიც უნდა მოიძებნოს, მეორე - ხაზი, რომელშიც გსურთ მოძებნოთ. ძიება ხორციელდება პერსონაჟების შემთხვევის გათვალისწინებით. თუ ფუნქცია აღმოაჩენს ქვესტრინგს სტრიქონში, ის აბრუნებს მისი პირველი გაჩენის პოზიციის ნომერს. თუ ჩანაწერი არ არის ნაპოვნი, ფუნქცია აბრუნებს 0-ს. მაგალითი:

var Str1, Str2: სიმებიანი; P: მთელი რიცხვი; ( ... ) Str1: "გამარჯობა! როგორ ხარ?" ; Str2:="do" ; P:=Pos (Str2, Str1) ; //P = 9

ხაზის ნაწილის ამოღება

თქვენ შეგიძლიათ წაშალოთ ხაზის ნაწილი პროცედურის გამოყენებით წაშლა (). უნდა აღინიშნოს, რომ ეს არის პროცედურა და არა ფუნქცია - ის ასრულებს მოქმედებებს პირდაპირ ცვლადზე, რომელიც მას გადაეცემა. ასე რომ, პირველი პარამეტრი არის ცვლადი სიმებიანი ტიპი, საიდანაც ამოღებულია ფრაგმენტი (კერძოდ ცვლადი! კონკრეტული მნიშვნელობაარ არის მითითებული, რადგან პროცედურა არ აბრუნებს შედეგს), მეორე პარამეტრი არის სიმბოლოს რაოდენობა, საიდანაც უნდა წაიშალოს ფრაგმენტი, მესამე პარამეტრი არის წაშლილი სიმბოლოების რაოდენობა. მაგალითი:

var Str1: სიმებიანი; ( ... ) Str1:="გამარჯობა, სამყარო!" ; წაშლა (Str1, 6, 7); // Str1 = "გამარჯობა!"

უნდა აღინიშნოს, რომ თუ წაშლილი ფრაგმენტის სიგრძე აღმოჩნდება მეტი რაოდენობითხაზში სიმბოლოები, დაწყებული მითითებული პოზიციიდან (ანუ „გავიდეთ ზღვარზე“), ფუნქცია ნორმალურად იმუშავებს. ამიტომ, თუ თქვენ გჭირდებათ ფრაგმენტის ამოღება სტრიქონიდან რომელიმე სიმბოლოდან ბოლომდე, თქვენ არ გჭირდებათ ამ სიმბოლოების რაოდენობის გამოთვლა. Საუკეთესო გზათავად დაადგენს ამ სტრიქონის სიგრძეს.

აი მაგალითი. ვთქვათ, გსურთ იპოვოთ პირველი ასო "სტრიქონში ა" და წაშალეთ მის შემდეგ სტრიქონის ნაწილი. ასე მოვიქცეთ: ვიპოვოთ ასოს პოზიცია ხაზში ფუნქციით. პოზ()და წაშალეთ ფრაგმენტი ფუნქციის გამოყენებით წაშლა ().

var Str: სიმებიანი; ( ... ) Str :="ეს ტესტია." ; წაშლა (Str ,Pos ("a" ,Str ) ,Length (Str ) );

ვცადოთ მნიშვნელობების ჩანაცვლება და ვნახოთ რა გადაეცემა ფუნქციას წაშლა. Პირველი წერილი " ა"ხაზში არის მე-9 პოზიციაზე. მთელი ხაზის სიგრძეა 15 სიმბოლო. ეს ნიშნავს, რომ ფუნქციის გამოძახება არის შემდეგი: Delete(Str,9,15). ჩანს, რომ ასოდან " ა"სტრიქონის ბოლომდე რჩება მხოლოდ 7 სიმბოლო... მაგრამ ფუნქცია თავის საქმეს გააკეთებს, მიუხედავად ამ განსხვავებისა. შედეგი, რა თქმა უნდა, იქნება ხაზი". Ეს არის". ეს მაგალითიერთდროულად აჩვენა რამდენიმე ფუნქციის კომბინაცია.

სტრიქონის ნაწილის კოპირება (ამოღება).

კიდევ ერთი მნიშვნელოვანი ამოცანაა სტრიქონის ნაწილის კოპირება. მაგალითად, ტექსტიდან ცალკეული სიტყვების ამოღება. თქვენ შეგიძლიათ აირჩიოთ ხაზის ფრაგმენტი არასაჭირო ნაწილების ამოღებით, მაგრამ ეს მეთოდი მოუხერხებელია. ფუნქცია კოპირება ()საშუალებას გაძლევთ დააკოპიროთ მითითებული ნაწილი სტრიქონიდან. ფუნქცია იღებს 3 პარამეტრს: ტექსტს (სტრიქონს), საიდანაც უნდა დააკოპიროთ, სიმბოლოების რაოდენობას, საიდანაც უნდა დააკოპიროთ და სიმბოლოების რაოდენობას. ფუნქციის შედეგი იქნება სიმებიანი ფრაგმენტი.

მაგალითი:ვთქვათ, თქვენ უნდა აირჩიოთ პირველი სიტყვა წინადადებიდან (სიტყვები გამოყოფილია ინტერვალით). ფორმაზე მოვათავსებთ რედაქტირება 1 (TEdit) რომელშიც ჩაიწერება წინადადება. ოპერაცია შესრულდება ღილაკის დაჭერით. Ჩვენ გვაქვს:

პროცედურა TForm1.Button1Click (გამომგზავნი: TObject) ; var s,word: string ; დასაწყისი s:=Edit1.Text ; სიტყვა:=ასლი (s,1 ,Pos (" " ,s) -1 ); ShowMessage("პირველი სიტყვა:" +სიტყვა) ; დასასრული ;

IN ამ შემთხვევაშიფრაგმენტი კოპირებულია სტრიქონიდან თავიდან პირველ სივრცემდე. სიმბოლოების რაოდენობა მიიღება ერთით ნაკლები, რადგან წინააღმდეგ შემთხვევაში სივრცეც დაკოპირდება.

სტრიქონში ქვესტრიქონის ჩასმა

თუ გსურთ სხვა მწკრივის ჩასმა არსებულ მწკრივში, შეგიძლიათ გამოიყენოთ პროცედურა ჩასმა (). პირველი პარამეტრი არის ჩასმული სტრიქონი, მეორე არის ცვლადი, რომელიც შეიცავს ხაზს, სადაც გსურთ ჩასვა, მესამე არის პოზიცია (სიმბოლო ნომერი), საიდანაც იქნება ჩასმული ხაზი. მაგალითი:

პროცედურა TForm2.Button1Click (გამომგზავნი: TObject) ; var S: სიმებიანი; დასაწყისი S:="1234567890" ; Insert("000" ,S,3 ); ShowMessage(S) დასასრული ;

ამ შემთხვევაში, შედეგი იქნება სტრიქონი "1200034567890".

"უფრო სერიოზული" მაგალითი

ზემოთ მოყვანილი მაგალითები მხოლოდ ასახავს ფუნქციების გამოყენებით სტრინგებთან მუშაობის პრინციპს სიგრძე (), პოზ(), წაშლა ()და კოპირება (). ახლა მოდით გადავჭრათ უფრო რთული პრობლემა, რომელიც მოითხოვს ამ ფუნქციების კომბინირებულ გამოყენებას.

ამოცანა: Memo ველში შეყვანილი ტექსტი დაყავით სიტყვებად და აჩვენეთ ისინი ListBox-ში, თითო სტრიქონზე. სიტყვები ერთმანეთისგან გამოყოფილია ინტერვალით, წერტილით, მძიმეებით, ძახილის და კითხვის ნიშნებით. გარდა ამისა, აჩვენეთ ტექსტში სიტყვების საერთო რაოდენობა და ამ სიტყვებიდან ყველაზე გრძელი.

ასეა... ამოცანა სულაც არ არის ადვილი. პირველ რიგში, დაუყოვნებლივ უნდა გააცნობიეროთ, რომ საჭიროა მარყუჟების გამოყენება. მათ გარეშე გზა არ არის, რადგან არ ვიცით, რა ტექსტი გადავა გადასამუშავებლად პროგრამაში. მეორეც, სიტყვები გამოყოფილია სხვადასხვა სიმბოლოები- ეს ქმნის დამატებით სირთულეებს. კარგი, მოდი წავიდეთ თანმიმდევრობით.

ინტერფეისი: Memo1 (TMemo), ღილაკი 1 (TButton), სია 1 (TListBox), ლეიბლი 1, ლეიბლი 2 (TLabel).

ჯერ შეყვანილი ტექსტი გადავიტანოთ ცვლადში. იმისთვის, რომ Memo-დან ყველა ტექსტი ერთდროულად ავიღოთ, მივმართოთ საკუთრებას ხაზები.ტექსტი:

პროცედურა TForm1.Button1Click (გამომგზავნი: TObject) ; var ტექსტი: string ; start Text:=Memo1.Lines .Text ; დასასრული ;

ახლა გადავიდეთ დამუშავებაზე. პირველი, რაც თქვენ უნდა გააკეთოთ, არის გამიჯვნის სიმბოლოებთან გამკლავება. ფაქტია, რომ ასეთი სიმბოლოები ადვილად შეიძლება მოვიდეს ზედიზედ, რადგან მძიმეების, წერტილების და სხვა სიმბოლოების შემდეგ არის სივრცე. თქვენ შეგიძლიათ გადალახოთ ეს სირთულე ასე მარტივი გზით: შეცვალეთ ყველა გამყოფი სიმბოლო ერთით, მაგალითად მძიმით. ამისათვის მოდით გავიაროთ ყველა პერსონაჟი და გავაკეთოთ საჭირო ჩანაცვლება. იმის დასადგენად, არის თუ არა სიმბოლო დელიმიტერი, ჩვენ ვწერთ ყველა დელიმიტერს ცალკე სტრიქონის ცვლადში (მუდმივი) და შემდეგ ვეძებთ თითოეულ სიმბოლოს ამ სტრიქონში ფუნქციით. პოზ(). ყველა ეს ჩანაცვლება მოხდება ცვლადში ისე, რომ ორიგინალური ტექსტი Memo-ში (ანუ ეკრანზე) არ დაზარალდა. თუმცა, სამუშაოს შუალედური შედეგების შესამოწმებლად, აზრი აქვს დამუშავებული ტექსტის სადმე გამოტანას. მაგალითად, სხვა Memo ველში. ყველა პერსონაჟის გასავლელად გამოიყენეთ მარყუჟი FOR, სადაც ცვლადი გაივლის ყველა სიმბოლოს სერიულ ნომრებს, ე.ი. 1-დან ტექსტის ხაზის სიგრძემდე:

პროცედურა TForm1.Button1Click (გამომგზავნი: TObject) ; const DelSym = ".,!" ; var ტექსტი: string ; მე: მთელი რიცხვი ; start Text:=Memo1.Lines .Text ; i:= 1-დან სიგრძემდე (ტექსტი) გააკეთეთ თუ Pos (Text[i] ,DelSym) > 0, მაშინ ტექსტი[i] :="," ; Memo2.Text :=ტექსტი; დასასრული ;

ახლა ჩვენ უნდა აღმოვფხვრათ ჩარევა. ჯერ ერთი, პირველი სიმბოლო არ უნდა იყოს განმსაზღვრელი, ე.ი. თუ პირველი სიმბოლო მძიმია, ის უნდა მოიხსნას. შემდეგი, თუ ზედიზედ რამდენიმე მძიმეა, ისინი უნდა შეიცვალოს ერთით. და ბოლოს, ყველა ტექსტის სწორად დასამუშავებლად, ბოლო სიმბოლო უნდა იყოს მძიმით.

if Text[ 1 ] = "," მაშინ Delete (Text,1 ,1 ); ხოლო Pos ("," ,ტექსტი) > 0 do Delete (ტექსტი,პოს ("," ,ტექსტი) ,1 ); თუ ტექსტი [სიგრძე (ტექსტი) ]<>"," შემდეგ ტექსტი:=ტექსტი+"," ;

აქ ჩანაცვლება კეთდება შემდეგნაირად: ორგანიზებულია ციკლი, რომელშიც ერთ-ერთი მძიმეა ამოღებული, მაგრამ ეს ხდება მანამ, სანამ ტექსტში არის ორი ზედიზედ მძიმე.

ისე, ახლა ტექსტში ზედმეტი აღარაფერი დარჩა - მხოლოდ მძიმეებით გამოყოფილი სიტყვები. პირველ რიგში, ჩვენ დავრწმუნდებით, რომ პროგრამა ამოიღებს პირველ სიტყვას ტექსტიდან. ამისათვის ჩვენ ვიპოვით პირველ მძიმეს, ამ მძიმით დავაკოპირებთ სიტყვას ტექსტის დასაწყისიდან და შემდეგ მძიმთან ერთად ამ სიტყვას ტექსტიდან წავშლით. წაშლა კეთდება ისე, რომ შემდეგ, იგივე ოპერაციის შესრულების შემდეგ, შეგიძლიათ ამოჭრათ შემდეგი სიტყვა.

var სიტყვა: string ; (...) Word:=Copy (Text,1 ,Pos ("," ,Text) -1 ); წაშლა (ტექსტი,1 ,სიგრძე (სიტყვა) +1 );

ახლა ცვლადში სიტყვაგვაქვს სიტყვა ტექსტიდან და ცვლადში ტექსტიდანარჩენი ტექსტი. მოჭრილი სიტყვა ახლა დაემატა სია ყუთი, რეკავს ListBox.Items.Add(line_to_add).

ახლა ჩვენ უნდა მოვაწყოთ მარყუჟი, რომელიც საშუალებას მოგვცემს ამოვაჭრათ ყველა სიტყვა ტექსტიდან და არა მხოლოდ პირველი. ამ შემთხვევაში უფრო შესაფერისი იქნებოდა გაიმეორეთ, როგორ სანამ. პირობა უნდა იყოს სიგრძე (ტექსტი) = 0, ე.ი. დაასრულეთ ციკლი, როდესაც ტექსტი ცარიელი გახდება, ე.ი. როცა ყველა სიტყვას ამოვჭრით.

გაიმეორეთ სიტყვა:=ასლი (ტექსტი,1 ,პოს ("," ,ტექსტი) -1 ); წაშლა (ტექსტი,1 ,სიგრძე (სიტყვა) +1 ); ListBox1.Items.Add(Word) ; სიგრძე (ტექსტი) = 0 ;

ასე შემდეგ ამ მომენტშიჩვენ გვაქვს:

პროცედურა TForm1.Button1Click (გამომგზავნი: TObject) ; const DelSym = ".,!" ; var ტექსტი, სიტყვა : string ; მე: მთელი რიცხვი ; start Text:=Memo1.Lines .Text ; i:= 1-დან სიგრძემდე (ტექსტი) გააკეთეთ თუ Pos (Text[i] ,DelSym) > 0, მაშინ ტექსტი[i] :="," ; if Text[ 1 ] = "," მაშინ Delete (Text,1 ,1 ); ხოლო Pos ("," ,ტექსტი) > 0 do Delete (ტექსტი,პოს ("," ,ტექსტი) ,1 ); გაიმეორეთ სიტყვა :=ასლი (ტექსტი,1 ,პოს ("," ,ტექსტი) -1 ); წაშლა (ტექსტი,1 ,სიგრძე (სიტყვა) +1 ); ListBox1.Items.Add(Word); სიგრძე (ტექსტი) = 0 ; დასასრული ;

თუ ახლა გაუშვით პროგრამა, ნახავთ, რომ ყველაფერი კარგად მუშაობს. ერთის გარდა - ListBox-ის ბოლოს რამდენიმე ცარიელი ხაზი გამოჩნდა... ჩნდება კითხვა: საიდან გაჩნდა? ამის შესახებ გაკვეთილის შემდეგ ნაწილში შეიტყობთ, მაგრამ ახლა მოდით განვახორციელოთ ის, რაც საჭიროა ბოლომდე.

ტექსტში სიტყვების რაოდენობის დადგენა ძალიან მარტივია – ხელახლა არაფრის დაწერა არ გჭირდებათ. იმიტომ რომ ჩვენ გვაქვს სიტყვები ჩამოთვლილი ListBox-ში, საკმარისია გავარკვიოთ რამდენი ხაზია - ListBox.Items.Count.

Label1. წარწერა := "სიტყვების რაოდენობა ტექსტში:"+IntToStr(ListBox1.Items.Count);

ახლა თქვენ უნდა იპოვოთ ყველაზე გრძელი სიტყვა. ალგორითმის პოვნა მაქსიმალური რაოდენობაარის შემდეგი: რიცხვებიდან პირველს მაქსიმუმად ვიღებთ. შემდეგ ყველა სხვა რიცხვს ვამოწმებთ ასე: თუ ნომერი უფრო მეტიც, რომელიც ახლა მაქსიმუმად იწერება, ამ რიცხვს ვაკეთებთ მაქსიმუმს. ჩვენს შემთხვევაში ჩვენ უნდა ვეძებოთ მაქსიმალური სიგრძესიტყვები. ამისათვის თქვენ შეგიძლიათ დაამატოთ კოდი ტექსტიდან ამოჭრილი სიტყვების მარყუჟში ან განახორციელოთ ძებნა ListBox-ში ყველა სიტყვის დამატების შემდეგ. მოდით გავაკეთოთ მეორე გზით: მოვაწყოთ ციკლი ListBox ხაზების მეშვეობით. უნდა აღინიშნოს, რომ ხაზები დანომრილია ნულიდან და არა ერთიდან! ჩვენ ყველაზე მეტს ცალკე ცვლადში ვინახავთ გრძელი სიტყვა. როგორც ჩანს, სიტყვის მაქსიმალური სიგრძის შენახვაც გვჭირდება, რომ შედარება გვქონდეს... მაგრამ ამისთვის ცალკე ცვლადის შექმნა არ არის საჭირო, რადგან სიტყვის სიგრძის გარკვევა ყოველთვის შეგვიძლია. Length() ფუნქციის გამოყენებით. ასე ვთქვათ, პირველი სიტყვა ყველაზე გრძელია...

var LongestWord: string ; (...) LongestWord:=ListBox1.Items [0] ; for i:= 1 to ListBox1.Items .Count -1 გააკეთე თუ სიგრძე (ListBox1.Items [i] ) > "ყველაზე გრძელი სიტყვა:"+LongestWord+" (" +IntToStr (სიგრძე (LongestWord)) +" ასოები)" ;

რატომ ციკლი სანამ ListBox.Items.Count-1, არა მხოლოდ მანამ დათვალეთ, შენ თვითონ გაარკვიე :-)

ახლა ყველაფერი მზად არის!

პროცედურა TForm1.Button1Click (გამომგზავნი: TObject) ; const DelSym = ".,!" ; var Text,Word ,LongestWord: string ; მე: მთელი რიცხვი ; start Text:=Memo1.Lines .Text ; i:= 1-დან სიგრძემდე (ტექსტი) გააკეთეთ თუ Pos (Text[i] ,DelSym) > 0, მაშინ ტექსტი[i] :="," ; if Text[ 1 ] = "," მაშინ Delete (Text,1 ,1 ); ხოლო Pos ("," ,ტექსტი) > 0 do Delete (ტექსტი,პოს ("," ,ტექსტი) ,1 ); ტექსტი:=AnsiReplaceText(Text,Chr (13) ,"" ); ტექსტი:=AnsiReplaceText(Text,Chr (10) ,"" ); გაიმეორეთ სიტყვა :=ასლი (ტექსტი,1 ,პოს ("," ,ტექსტი) -1 ); წაშლა (ტექსტი,1 ,სიგრძე (სიტყვა) +1 ); ListBox1.Items.Add(Word); სიგრძე (ტექსტი) = 0 ; Label1. წარწერა := "სიტყვების რაოდენობა ტექსტში:"+IntToStr(ListBox1.Items.Count); LongestWord:=ListBox1.Items [0] ; for i:= 1 to ListBox1.Items .Count -1 do if Length (ListBox1.Items [i] ) > Length (LongestWord) შემდეგ LongestWord:=ListBox1.Items [i] ; Label2. წარწერა := "ყველაზე გრძელი სიტყვა:"+LongestWord+" (" +IntToStr (სიგრძე (LongestWord)) +" ასოები)" ; დასასრული ;

სიმბოლოებთან მუშაობა

სინამდვილეში, სიმბოლოებთან მუშაობა ორი ძირითადი ფუნქციის გამოყენებაზე მოდის - ორდენი ()და Chr(). ჩვენ უკვე შევხვდით მათ. ფუნქცია ორდენი ()აბრუნებს მითითებული სიმბოლოს კოდს და ფუნქციას Chr()- პირიქით, აბრუნებს სიმბოლოს მითითებული კოდით.

გახსოვდეს" სიმბოლოების ცხრილი"? მოდით ეს თავად გავაკეთოთ!

დასკვნის გაკეთება შესაძლებელია TStringGrid. ეს კომპონენტი არის ცხრილი, სადაც თითოეული უჯრედი შეიცავს ტექსტის მნიშვნელობა. კომპონენტი მდებარეობს ჩანართზე დამატებითი(ნაგულისხმევი პირდაპირ სტანდარტულის შემდეგ). უპირველეს ყოვლისა, მოდით დავაყენოთ ჩვენი ნიშანი. ჩვენ გვჭირდება მხოლოდ ორი სვეტი: ერთში გამოვაჩენთ სიმბოლოს კოდს, ხოლო მეორეში - თავად სიმბოლოს. სვეტების რაოდენობა მითითებულია თვისებაში ლოგიკური სახელით კოლკონტი. დააყენეთ 2-ის ტოლი. ნაგულისხმევად, StringGridმოცემულია ერთი ფიქსირებული სვეტი და ერთი ფიქსირებული სიმებიანი(გამოსახულია ნაცრისფერი). ჩვენ არ გვჭირდება სვეტი, მაგრამ მწკრივი ძალიან სასარგებლოა, ამიტომ ჩვენ ვაყენებთ FixedCols= 0, ა ფიქსირებული რიგებიდატოვე = 1.

შევსება განხორციელდება უშუალოდ პროგრამის დაწყებისას, ე.ი. ჩვენ არ დავაინსტალირებთ ღილაკებს. მოდით შევქმნათ მოვლენის დამმუშავებელი OnCreate ()ფორმები.

კოდების ცხრილის სიმბოლოების რაოდენობაა 256, პლუს სათაური - სულ 257. მოდით დავაყენოთ ხაზების რაოდენობა პროგრამულად (თუმცა შეგიძლიათ დააყენოთ Object Inspector-შიც):

პროცედურა TForm1.FormCreate (გამომგზავნი: TObject) ; დაწყება StringGrid1.RowCount :=257; დასასრული ;

დასკვნა კეთდება ძალიან მარტივად - მარყუჟის გამოყენებით. ჩვენ უბრალოდ გადავიტანთ რიცხვებს 0-დან 255-მდე და ვაჩვენებთ შესაბამის სიმბოლოს. ჩვენ ასევე ვაჩვენებთ წარწერებს სათაურში. უჯრედზე წვდომა StringGridგანხორციელდა ქონების გამოყენებით უჯრედები: უჯრედები[სვეტის_ნომერი, მწკრივის_ნომერი]. კვადრატულ ფრჩხილებში მითითებულია სვეტებისა და მწკრივების ნომრები (ნულიდან დაწყებული). მნიშვნელობები არის ტექსტი.

პროცედურა TForm1.FormCreate (გამომგზავნი: TObject); var i: მთელი რიცხვი; დაწყება StringGrid1.RowCount :=257; StringGrid1.Cells [ 0 ,0 ] :="კოდი" ; StringGrid1.Cells [ 1 ,0 ] :="პერსონაჟი" ; i:= 0-დან 255-მდე დაიწყება StringGrid1.Cells [0 ,i+1] :=IntToStr (i) ; StringGrid1.Cells [1,i+1] :=Chr (i) ; დასასრული ; დასასრული ;

მოდით დავიწყოთ და შევხედოთ.

სპეციალური სიმბოლოები

თუ ყურადღებით დააკვირდებით ჩვენს ცხრილს, ნახავთ, რომ ბევრი სიმბოლო კვადრატის სახით ჩანს. არა, ეს არ არის ხატები. ასეა პერსონაჟები, რომლებსაც არ აქვთ ვიზუალური ჩვენება. იმათ. სიმბოლო, მაგალითად, კოდი 13 არსებობს, მაგრამ ის უხილავია. ეს სიმბოლოები გამოიყენება დამატებითი მიზნებისთვის. მაგალითად, სიმბოლო #0 (ანუ სიმბოლო 0 კოდით) ხშირად გამოიყენება სიმბოლოს არარსებობის აღსანიშნავად. ასევე არის ხაზები ე.წ ნულ-შეწყვეტილი- ეს არის სტრიქონები, რომლებიც მთავრდება #0 სიმბოლოთი. ასეთი სტრიქონები გამოიყენება C ენაში.
კლავიშების ამოცნობა შესაძლებელია კოდებით. Მაგალითად, შეიყვანეთ გასაღებიაქვს კოდი 13, Escape - 27, Space - 32, Tab - 9 და ა.შ.
მოდით, ჩვენს პროგრამას დავამატოთ ნებისმიერი გასაღების კოდის გარკვევის შესაძლებლობა. ამისათვის ჩვენ დავამუშავებთ ფორმის მოვლენას OnKeyPress (). იმისათვის, რომ ამ მექანიზმმა იმუშაოს, თქვენ უნდა დააყენოთ ფორმა KeyPreview = True.

პროცედურა TForm1.FormKeyPress (გამომგზავნი: TObject ; var Key: Char ) ; დაიწყეთ ShowMessage( "ღილაკზე დაჭერილი კოდი:"+IntToStr(Ord(Key))); დასასრული ;

აქ ჩვენ ვაჩვენებთ ფანჯარას ტექსტით. მოვლენას აქვს ცვლადი Გასაღები, რომელიც ინახავს დაჭერილი ღილაკის შესაბამის სიმბოლოს. ფუნქციის გამოყენებით ორდენი ()გაარკვიეთ ამ სიმბოლოს კოდი და შემდეგ გამოიყენეთ ფუნქცია IntToStr()გადავიყვანოთ ეს რიცხვი სტრიქონად.

მაგალითი "უფრო სერიოზული" - განაგრძო

დავუბრუნდეთ ჩვენს მაგალითს. დროა გავარკვიოთ, საიდან მოდის ცარიელი რიგები ListBox-ში. საქმე იმაშია, რომ ისინი მთლად ცარიელი არ არიან. დიახ, ვიზუალურად ისინი ცარიელია, მაგრამ სინამდვილეში თითოეულ მათგანს აქვს 2 სპეციალური პერსონაჟები. ეს არის სიმბოლოები 13 და 10 კოდებით (ანუ სტრიქონი #13#10). Windows-ზე ამ ორი არავიზუალური სიმბოლოს ეს თანმიმდევრობა ნიშნავს დასასრულს მიმდინარე ხაზიდა დასაწყისი ახალი ხაზი. იმათ. ნებისმიერ ფაილში და ზოგადად სადმე, ხაზის წყვეტები ორი სიმბოლოა. და მთელი ტექსტი, შესაბამისად, რჩება სიმბოლოების უწყვეტი თანმიმდევრობით. ეს სიმბოლოები შეიძლება (და თუნდაც უნდა) იყოს გამოყენებული იმ შემთხვევებში, როდესაც საჭიროა ხაზის წყვეტის ჩასმა. ამის შესახებ მეტი შეგიძლიათ წაიკითხოთ სტატიაში. ყველა წინა გაკვეთილზე მიღებული ცოდნა, მათ შორის ამ გაკვეთილზეც, სავსებით საკმარისია ამ სტატიის გასაგებად - ის საკმაოდ მოკლეა.

მოდით მივიყვანოთ ჩვენი სიტყვების საძიებო პროგრამა მის ლოგიკურ დასასრულამდე. ასე რომ, მოშორება ცარიელი ხაზები, ტექსტიდან უნდა წავშალოთ სიმბოლოები #13 და #10. ეს შეიძლება გაკეთდეს მარყუჟის გამოყენებით, ისევე როგორც ჩვენ შევცვალეთ ორი მძიმეები ერთით:

ხოლო Pos (Chr (13 ) ,Text) > 0 do Delete (Text,Pos (Chr (13 ) ,Text) ,1 ) ; ხოლო Pos (Chr (10 ) ,Text) > 0 do Delete (Text,Pos (Chr (10 ) ,Text) ,1 ) ;

კარგად, ახლა პროგრამა სრულად ფუნქციონირებს!

სტრინგებთან მუშაობის დამატებითი ფუნქციები - StrUtils მოდული

დამატებითი მოდული StrUtils.pasშეიცავს დამატებით ფუნქციებს სტრინგებთან მუშაობისთვის. ამ ფუნქციებს შორის ბევრი სასარგებლოა. ზოგიერთი ფუნქცია უფრო დეტალურად არის განხილული სტატიაში. Და აქ მოკლე აღწერახშირად გამოყენებული ფუნქციები:

PosEx(ქვესტრიქონი, ხაზი, ჩაღრმავება) - ფუნქციის მსგავსი ფუნქცია პოზ(), მაგრამ ძიება მითითებული პოზიციიდან (ანუ ხაზის დასაწყისიდან შეჭრილი). მაგალითად, თუ გსურთ იპოვოთ მეორე სივრცე სტრიქონში და არა პირველი, ამ ფუნქციის გარეშე არ შეგიძლიათ. მეორე სივრცის ხელით მოსაძებნად, ჯერ უნდა ამოჭრათ ორიგინალური სტრიქონის ნაწილი.

AnsiReplaceStr, AnsiReplaceText (ხაზი, text_1, text_2) - ფუნქციები ასრულებენ ჩანაცვლებას სტრიქონში ხაზიხაზები text_1 on text_2. ფუნქციები განსხვავდება მხოლოდ იმით, რომ პირველი ახორციელებს ჩანაცვლებას სიმბოლოების შემთხვევის გათვალისწინებით, ხოლო მეორე - მის გარეშე.
ჩვენს პროგრამაში, ჩვენ შეგვიძლია გამოვიყენოთ ეს ფუნქციები სტრიქონიდან #13 და #10 სიმბოლოების ამოსაჭრელად, ჩანაცვლების ტექსტად ცარიელი სტრიქონის მითითებით. აქ არის გამოსავალი კოდის ერთ სტრიქონში:

ტექსტი:=AnsiReplaceText(AnsiReplaceText(Text,Chr (13) ,"" ) ,Chr (10 ) ,"" );

DupeString(ხაზი, გამეორებების_რაოდენობა) - ქმნის სტრიქონისაგან შემდგარ სტრიქონს ხაზიგანსაზღვრული რამდენჯერმე გამეორებით.

ReverseString(ხაზი) - აბრუნებს სტრიქონს (" 123 " -> "321 ").

ასევე აღსანიშნავია რეესტრის კონვერტაციის ფუნქციები.

ზედა რეგისტრი(ხაზი) - გარდაქმნის სტრიქონს დიდი; მცირე რეესტრი(ხაზი) - გარდაქმნის სტრიქონს მცირე რეგისტრით.

ინდივიდუალური სიმბოლოების გადასაყვანად, თქვენ უნდა გამოიყენოთ იგივე ფუნქციები.

თითოეული ფუნქციის შესახებ დეტალური ინფორმაციის მიღება შესაძლებელია მისი სახელის კოდის რედაქტორში ნებისმიერ ადგილას შეყვანით, ამ სახელზე კურსორის დაყენებით (ან მისი მონიშვნით) და F1 დაჭერით.

სტატიაში აღწერილი პროგრამების ეკრანის ანაბეჭდები