Sunday, December 25, 2016

Bab 3. Visual C# Untuk Programer



String dan Karakter






3.1 Pengantar

Bab ini mengintroduksi kapabilitas string dan karakter di dalam C#. Teknik yang didiskusikan di sini cocok untuk memvalidasi masukan program, menampilkan informasi kepada pengguna dan manipulasi-manipulasi lain yang berbasis teks.  Teknik-teknik ini sesuai untuk mengembangkan editor teks, perangkat lunak untuk pengolah kata, dan lain-lain. Bab ini akan mendiskusikan lebih detil tentang kapabilitas kelas string dan tipe char dari namespace System dan StringBuilder dari namespace System.Text.

Kelas StringBuilder, yang dipakai untuk membangun string secara dinamis, akan dikupas. Akan didemonstrasikan kapabilitas StringBuilder untuk menetapkan ukuran sebuah StringBuilder, berikut dengan penempelan, penyisipan, penghapusan, dan penggantian karakter-karater di dalam sebuah objek StringBuilder. Kemudian akan diintroduksi metode-metode pengujian-karakter dari struct Char yang memampukan sebuah program dalam menentukan apakah sebuah karakter merupakan suatu dijit, huruf, huruf kecil, huruf besar, tanda baca, atau simbol selain tanda baca. Metode-metode semacam itu berguna untuk memvalidasi karakter individual dalam masukan pengguna. Selain itu, tipe Char menyediakan metode-metode untuk mengkonversi suatu karakter menjadi huruf besar atau huruf kecil.

Akan didiskusikan pula tentang ekspresi reguler. Kelas Regex dan Match disajikan dari namespace System.Text.RegularExpression. Kemudian akan didemonstrasikan bagaimana mencari pola di dalam suatu string, mencocokkan pola, mengganti karakter-karakter di dalam suatu string yang cocok dengan pola tertentu, dan memecah string pada pembatas (delimiter) yang ditetapkan sebagai pola di dalam ekspresi reguler.

3.2 Dasar Karakter dan String
Karakter merupakan blok pembangun yang fundamental di dalam program sumber C#. Setiap program terdiri-dari runtun karakter yang, ketika dikelompokkan, diinterpretasikan oleh kompiler C# sebagai runtun instruksi untuk menyelesaikan tugas yang diberikan. Suatu program dapat memuat literal karakter. Suatu literal karakter merupakan suatu nilai integer yang direpresentasikan sebagai suatu karakter yang diapit dengan tanda kutip tunggal. Sebagai contoh, ‘z’ merepresentasikan nilai integer atas z, dan ‘\n’ merepresentasikan nilai integer atas karakter garis-baru. Nilai atas suatu literal karakter merupakan nilai integer dari karakter di dalam himpunan karakter Unicode.

String merupakan suatu objek dari kelas string. Literal string (disimpan di dalam memori sebagai objek string) ditulis sebagai runtun karakter yang diapit oleh tanda kutip ganda, seperti:

"Robert Tohonan"           (sebuah nama)
"Jl. Medan Km 10,5 No. 27" (sebuah alamat)
"Siantar, Sumetera Utara" (kota dan propinsi)
"(0622) 456789"            (sebuah nomor telepon)

Suatu string dapat ditugaskan kepada suatu referensi string. Deklarasi

string warna = "hitam";

menginisialisasi variabel bertipe string, warna, untuk menunjuk kepada suatu objek string yang memuat string “hitam”.

3.3 Konstruktor string
Kelas string menyediakan delapan konstruktor untuk menginisialisasi string dalam pelbagai cara. Gambar 3.1 mendemonstrasikan tiga di antaranya.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Gambar 3.1: KonstruktorString.cs
// Mendemonstrasikan konstruktor-konstruktor kelas string class.
using System;

class KonstruktorString
{
    public static void Main( string[] args )
    {
// inisialisasi string
char[] arrayKarakter =
    { 'b', 'i', 'r', 't', 'h', ' ', 'd', 'a', 'y' };
string stringAsli = "Selamat Datang ke Pemrograman C#!";
string string1 = stringAsli;
string string2 = new string( arrayKarakter );
string string3 = new string( arrayKarakter, 6, 3 );
string string4 = new string( 'C', 5 );

        Console.WriteLine( "string1 = " + "\"" + string1 + "\"\n" +
            "string2 = " + "\"" + string2 + "\"\n" +
            "string3 = " + "\"" + string3 + "\"\n" +
            "string4 = " + "\"" + string4 + "\"\n" );
    } // akhir Main
} // akhir kelas KonstruktorString

string1 = "Selamat Datang ke Pemrograman C#!"
string2 = "birth day"
string3 = "day"
string4 = "CCCCC"

Baris 10-11 mengalokasikan array char, arrayKarakter, yang memuat sembilan karakter. Baris 12-16 mendeklarasikan string StringAsli, string1, string2, string3, dan string4. Baris 12 menugaskan literal string “Selamat Datang ke Pemrograman C#!” kepada referensi string, stringAsli. Baris 13 menetapkan string1 untuk mereferensi literal string yang sama.

Baris 14 menugaskan string2 kepada sebuah string baru, menggunakan konstruktor string dengan suatu argumen array karakter. String yang baru itu memuat salinan atas karakter-karakter pada array.

Baris 15 menugaskan string3 kepada sebuah string baru, menggunakan konstruktor string yang mengambil sebuah array char dan dua int sebagai argumennya. Argumen kedua menetapkan posisi indeks awal (offset) dari karakter-karakter di dalam array yang akan disalin. Argumen ketiga menetapkan jumlah karakter yang akan disalin terhitung mulai dari posisi awal pada array. String yang baru akan memuat sebuah salinan atas karakter-karakter yang dispesifikasi di dalam array. Jika offset atau jumlah karakter yang akan disalin mengindikasikan bahwa program harus mengakses elemen di luar batas array, maka eksepsi ArgumentOutOfRange akan dilemparkan.

Baris 16 menugaskan string4 kepada sebuahs string baru, menggunakan konstruktor string yang mengambil sebuah karakter dan sebuah int sebagai argumen untuk menetapkan jumlah kemunculan karakter tersebut di dalam string.

3.4 Indekser string, Properti Length, dan Metode CopyTo
Aplikasi pada Gambar 3.2 menyajikan indekser string, yang memfasilitasi penarikan/pembacaan sembarang karakter di dalam string, dan properti Length, yang menghasilkan panjang string. Metode CopyTo menyalin sejumlah karakter tertentu dari string ke dalam sebuah array char.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Gambar 3.2: MetodeString.cs
// Menggunakan indekser, properti Length, dan metode CopyTo
// dari kelas string.
using System;

class MetodeString
{
    public static void Main( string[] args )
    {
        string string1 = "apa kabar";
        char[] arrayKarakter = new char[ 5 ];

        // menampilkan string1
        Console.WriteLine( "string1: \"" + string1 + "\"" );

// menguji properti Length
Console.WriteLine( "Panjang dari string1: " + string1.Length );

        // menjelajah karakter-karakter pada string1 dan membalikkannya
        Console.Write( "String terbalik adalah: " );

        for ( int i = string1.Length - 1; i >= 0; i-- )
            Console.Write( string1[ i ] );

        // menyalin karakter-karakter dari string1 ke arrayKarakter
        string1.CopyTo( 0, arrayKarakter, 0, arrayKarakter.Length );
        Console.Write( "\nArray karakter adalah: " );

        for ( int i = 0; i < arrayKarakter.Length; i++ )
            Console.Write( arrayKarakter[ i ] );

        Console.WriteLine( "\n" );
    } // akhir Main
} // akhir kelas MetodeString

string1: "apa kabar"
Panjang dari string1: 9
String terbalik adalah: rabak apa
Array karakter adalah: apa k

Aplikasi ini menentukan panjang sebuah string, menampilkan karakter-karakternya dalam urutan terbalik, dan menyalin sederet karakter dari string ke sebuah array karakter. Baris 17 menggunakan properti Length untuk menentukan jumlah karakter di dalam string1. Seperti array, string selalu mengetahui ukurannya sendiri.

Baris 22-23 menuliskan karakter-karakter dari string1 dalam urutan terbalik menggunakan indekser string. Indekser string memperlakukan sebuah string sebagai array char dan menghasilkan setiap karakter pada posisi tertentu di dalam string. Indekser menerima sebuah argumen integer sebagai nomor posisi dan menghasilkan karakter pada posisi itu. Seperti array, elemen pertama pada sebuah string dipandang pada posisi 0.

Baris 26 menggunakan metode CopyTo dari kelas string untuk menyalin karakter-karakter dari string1 ke array karakter (arrayKarakter). Argumen pertama yang diberikan pada metode CopyTo merupakan indeks awal penyalinan karakter dilakukan. Argumen kedua adalah array karakter yang merupakan destinasi penyalinan. Argumen ketiga adalah indeks dari lokasi awal tempat penyalinan di dalam array karakter. Argumen terakhir adalah jumlah karakter yang akan disalin dari string. Baris 29-30 menampilkan isi array char satu per satu.




3.5 Membandingkan string
Dua contoh berikutnya akan mendemonstrasikan pelbagai metode untuk membandingkan string. Untuk memahami bagaimana satu string dapat bernilai lebih besar dari atau lebih kecil dari string lainnya, Anda bisa memandangnya sebagai alfabetisasi di dalam kamus.

Membandingkan string dengan Equals, CompareTo, dan Operator Ekualitas (==)
Kelas string menyediakan beberapa cara untuk membandingkan string. Aplikasi pada Gambar 3.3 mendemonstrasikan kegunaan dari metode Equals, CompareTo, dan operator ekualitas (==).

Kondisi pada baris 21 menggunakan metode Equals untuk membandingkan string1 dan literal string “hallo” untuk menentukan apakah keduanya sama. Metode Equals (diwarisi dari kelas object dan didefinisikan-ulang pada kelas string) menguji ekualitas atas dua objek. Metode ini menghasilkan true jika kedua objek sama dan false jika sebaliknya. Pada kasus ini, kondisi menghasilkan true, karena string1 mereferensi objek literal string “hallo”. Metode Equals menggunakan aturan pengurutan kata. Pembandingan “hallo” dengan “HALLO” akan menghasilkan false, karena huruf kecil berbeda dari huruf besar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Gambar 3.3: PerbandinganString.cs
// Membandingkan string
using System;

class PerbandinganString
{
    public static void Main( string[] args )
    {
        string string1 = "hallo";
        string string2 = "selamat jalan";
        string string3 = "Selamat Ultah";
        string string4 = "selamat ultah";

        // menampilkan nilai-nilai dari keempat string
        Console.WriteLine( "string1 = \"" + string1 + "\"" +
            "\nstring2 = \"" + string2 + "\"" +
            "\nstring3 = \"" + string3 + "\"" +
            "\nstring4 = \"" + string4 + "\"\n" );

        // menguji ekualitas menggunakan metode Equals
        if ( string1.Equals( "hallo" ) )
            Console.WriteLine( "string1 sama dengan \"hallo\"" );
        else
            Console.WriteLine( "string1 tidak sama dengan \"hallo\"" );

        // menguji ekualitas dengan ==
        if ( string1 == "hallo" )
            Console.WriteLine( "string1 sama dengan \"hallo\"" );
        else
            Console.WriteLine( "string1 tidak sama dengan \"hallo\"" );

        // menguji ekualitas dengan Equals
        if ( string.Equals( string3, string4 ) ) // metode static
            Console.WriteLine( "string3 sama dengan string4" );
        else
            Console.WriteLine( "string3 tidak sama dengan string4" );

        // menguji CompareTo
        Console.WriteLine( "\nstring1.CompareTo( string2 ) adalah " +
            string1.CompareTo( string2 ) + "\n" +
            "string2.CompareTo( string1 ) adalah " +
            string2.CompareTo( string1 ) + "\n" +
            "string1.CompareTo( string1 ) adalah " +
            string1.CompareTo( string1 ) + "\n" +
            "string3.CompareTo( string4 ) adalah " +
            string3.CompareTo( string4 ) + "\n" +
            "string4.CompareTo( string3 ) adalah " +
            string4.CompareTo( string3 ) + "\n\n" );
    } // akhir Main
} // akhir kelas PerbandinganString

string1 = "hallo"
string2 = "selamat jalan"
string3 = "Selamat Ultah"
string4 = "selamat ultah"

string1 sama dengan "hallo"
string1 sama dengan "hallo"
string3 tidak sama dengan string4

string1.CompareTo( string2 ) adalah -1
string2.CompareTo( string1 ) adalah 1
string1.CompareTo( string1 ) adalah 0
string3.CompareTo( string4 ) adalah 1
string4.CompareTo( string3 ) adalah -1

Kondisi pada baris 27 menggunakan operator ekualitas (==) yang dioverload untuk membandingkan string string1 dengan literal string “hallo”. Dalam C#, operator ekualitas juga membandingkan isi dari dua string. Jadi, kondisi pada statemen if dievaluasi menjadi true, karena isi dari string1 dan “hallo” sama.

Baris 33 menguji apakah string3 dan string4 sama untuk mengilustrasikan bahwa perbandingan bersifat sensitif terhadap huruf. Di sini, metode static Equals dipakai untuk membandingkan nilai dari dua string. “Selamat Ultah” tidak sama dengan “selamat ultah”, jadi kondisi pada statemen if bernilai false, dan pesan “string3 tidak sama dengan string4” ditampilkan (baris 36).

Baris 40-48 menggunakan metode ToString dari kelas string untuk membandingkan string. Metode CompareTo menghasilkan 0 jika kedua string sama, menghasilkan nilai negatif jika string yang memanggil CompareTo bernilai kurang dari string yang dilewatkan sebagai argumen, dan menghasilkan nilai positif jika jika string yang memanggil CompareTo bernilai lebih dari string yang dilewatkan sebagai argumen.

Perhatikan bahwa CompareTo menganggap string3 lebih besar dari string4. Satu-satunya perbedaan dari kedua string adalah bahwa string3 memuat dua huruf besar pada posisi dimana string4 memuat huruf kecil.

Menentukan Apakah string Diawali atau Diakhiri dengan string Tertentu
Gambar 3.4 menunjukkan bagaimana menguji apakah sebuah instans string diawali atau diakhir dengan string tertentu. Metode StartsWith menentukan apakah sebuah instans string diawali dengan teks string yang dilewatkan sebagai argumen. Metode EndsWith menentukan apakah sebuah instans string diakhiri dengan teks string yang dilewatkan sebagai argumen. Metode Main pada kelas StringAwalAkhir mendefinisikan sebuah array string, yang memuat “awal”, “awalan”, “akhir, dan “akhiran”.

Baris 13 menggunakan metode StartsWith, yang mengambil sebuah argumen string. Kondisi pada statemen if menentukan apakah string pada indeks i dari array diawali dengan karakter-karakter “aw”. Jika ya, metode tersebut menghasilkan true, dan string2[i] akan ditampilkan berikut dengan sebuah pesan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Gambar 3.4: StringAwalAkhir.cs
// Mendemonstrasikan metode StartsWith dan EndsWith.
using System;

class StringAwalAkhir
{
    public static void Main( string[] args )
    {
        string[] string2 = { "awal", "awalan", "akhir", "akhiran" };

        // menguji setiap string untuk memeriksa apakah diawali dengan "aw"
        for ( int i = 0; i < string2.Length; i++ )
            if ( string2[ i ].StartsWith( "aw" ) )
                Console.WriteLine( "\"" + string2[ i ] + "\"" +
                    " diawali dengan \"aw\"" );

        Console.WriteLine();

        // menguji setiap string untuk memeriksa apakah diakhiri dengan "an"
        for ( int i = 0; i < string2.Length; i++ )
            if ( string2[ i ].EndsWith( "an" ) )
                Console.WriteLine( "\"" + string2[ i ] + "\"" +
                    " diakhiri dengan \"an\"" );

        Console.WriteLine();
    } // akhir Main
} // akhir kelas StringAwalAkhir

"awal" diawali dengan "aw"
"awalan" diawali dengan "aw"

"awalan" diakhiri dengan "an"
"akhiran" diakhiri dengan "an"

Baris 21 menggunakan metode EndsWith, yang mengambil sebuah argumen string. Kondisi pada statemen if menentukan apakah string pada indeks i dari array diakhiri dengan karakter-karakter “an”. Jika ya, metode tersebut menghasilkan true, dan string2[i] akan ditampilkan berikut dengan sebuah pesan.

3.6 Mencari Lokasi Karakter dan Substring di dalam string
Pada banyak aplikasi, diperlukan untuk melakukan pencarian terhadap sebuah karakter atau sehimpunan karakter di dalam string. Sebagai contoh, seorang programer yang menciptakan pengolah kata akan menyediakan kapabilitas-kapabilitas pencarian pada dokumen. Aplikasi pada Gambar 3.5 mendemonstrasikan metode IndexOf, IndexOfAny, LastIndexOf, dan LastIndexOfAny, yang melakukan pencarian terhadap karakter tertentu atau terhadap substring di dalam sebuah string. Semua pencarian pada contoh ini dilakukan terhadap string huruf2 (diinisialisasi dengan “abcdefghijklmabcdefghijklm") yang berlokasi di dalam Main pada kelas MetodeIndeksString.

Baris 14, 16, dan 18 menggunakan metode IndexOf untuk mencari lokasi kemunculan pertama dari sebuah karakter atau substring di dalam suatu string. Jika ia menemukan sebuah karakter, maka IndexOf akan menghasilkan indeks dari karakter tersebut di dalam string; sebaliknya, IndexOf menghasilkan -1. Ekspresi pada baris 16 menggunakan sebuah versi dari metode IndexOf yang mengambil dua argumen, yaitu karakter yang akan dicari dan indeks awal pencarian. Metode ini tidak memeriksa sembarang karakter yang ada sebelum indeks awal (pada kasus ini, 1). Ekspresi pada baris 18 menggunakan versi lain dari metode IndexOf yang mengambil tiga argumen, yaitu karakter yang akan dicari, indeks awal pencarian, dan jumlah karakter yang akan dipakai untuk melakukan pencarian.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// Gambar 3.5: MetodeIndeksString.cs
// Menggunakan metode-metode pencarian-string.
using System;

class MetodeIndeksString
{
    public static void Main( string[] args )
    {
        string huruf2 = "abcdefghijklmabcdefghijklm";
        char[] huruf2Pencarian = { 'c', 'a', '$' };

        // IndexOf untuk mencari sebuah karakter di dalam suatu string
        Console.WriteLine( "'c' pertama berlokasi pada indeks " +
            huruf2.IndexOf( 'c' ) );
        Console.WriteLine( "'a' pertama mulai dari indeks 1 berlokasi pada indeks " +
            huruf2.IndexOf( 'a', 1 ) );
        Console.WriteLine( "'$' pertama pada 5 posisi mulai dari indeks 3 " +
            "berlokasi pada indeks " + huruf2.IndexOf('$', 3, 5));

        // LastIndexOf untuk mencari sebuah karakter di dalam suatu string
        Console.WriteLine( "\n'c' terakhir berlokasi pada indeks " +
            huruf2.LastIndexOf( 'c' ) );
        Console.WriteLine("'a' terakhir sampai pada indeks 25 berlokasi pada " +
            "indeks " + huruf2.LastIndexOf( 'a', 25 ) );
        Console.WriteLine( "'$' terakhir pada 5 posisi mulai dari indeks 15 " +
            "berlokasi pada indeks " + huruf2.LastIndexOf('$', 15, 5));

        // IndexOf untuk mencari lokasi sebuah substring di dalam suatu a string
        Console.WriteLine( "\n\"def\" pertama berlokasi pada indeks " +
            huruf2.IndexOf( "def" ) );
        Console.WriteLine( "\"def\" pertama mulai dari indeks 7 berlokasi pada " +
            "indeks " + huruf2.IndexOf( "def", 7 ) );
        Console.WriteLine( "\"hello\" pertama pada 15 posisi " +
            "mulai dari indeks 5 berlokasi pada indeks " +
            huruf2.IndexOf( "hello", 5, 15 ) );

        // LastIndexOf untuk mencari lokasi sebuah substring di dalam suatu a string
        Console.WriteLine( "\n\"def\" terakhir berlokasi pada indeks " +
            huruf2.LastIndexOf( "def" ) );
        Console.WriteLine( "\"def\" terakhir sampai posisi 25 berlokasi " +
            "pada indeks " + huruf2.LastIndexOf( "def", 25 ) );
        Console.WriteLine( "\"hello\" pada 15 posisi " +
            "berakhir pada indeks 20  berlokasi pada indeks " +
            huruf2.LastIndexOf( "hello", 20, 15 ) );

        // IndexOfAny untuk mencari kemunculan pertama dari karakter di dalam array
        Console.WriteLine( "\n'c', 'a' atau '$' pertama " +
            "berlokasi pada indeks " + huruf2.IndexOfAny( huruf2Pencarian ) );
        Console.WriteLine("'c', 'a' atau '$' pertama mulai dari indeks 7 " +
            "berlokasi pada indeks " + huruf2.IndexOfAny( huruf2Pencarian, 7 ) );
        Console.WriteLine( "'c', 'a' atau '$' pertama pada 5 posisi " +
            "mulai dari indeks 7 berlokasi pada indeks " +
            huruf2.IndexOfAny( huruf2Pencarian, 7, 5 ) );

        // LastIndexOfAny untuk mencari kemunculan terakhir dari karakter
        // di dalam array
        Console.WriteLine( "\'c', 'a' atau '$' terakhir " +
            "berlokasi pada indeks " + huruf2.LastIndexOfAny( huruf2Pencarian ) );
        Console.WriteLine("'c', 'a' atau '$' terakhir sampai posisi 1 " +
            "berlokasi pada indeks " +
            huruf2.LastIndexOfAny( huruf2Pencarian, 1 ) );
        Console.WriteLine("'c', 'a' atau '$' terakhir pada 5 posisi " +
            "berakhir pada indeks 25 berlokasi pada indeks " +
            huruf2.LastIndexOfAny( huruf2Pencarian, 25, 5 ) );
    } // akhir Main
} // akhir kelas MetodeIndeksString

'c' pertama berlokasi pada indeks 2
'a' pertama mulai dari indeks 1 berlokasi pada indeks 13
'$' pertama pada 5 posisi mulai dari indeks 3 berlokasi pada indeks -1

'c' terakhir berlokasi pada indeks 15
'a' terakhir sampai pada indeks 25 berlokasi pada indeks 13
'$' terakhir pada 5 posisi mulai dari indeks 15 berlokasi pada indeks -1

"def" pertama berlokasi pada indeks 3
"def" pertama mulai dari indeks 7 berlokasi pada indeks 16
"hello" pertama pada 15 posisi mulai dari indeks 5 berlokasi pada indeks -1

"def" terakhir berlokasi pada indeks 16
"def" terakhir sampai posisi 25 berlokasi pada indeks 16
"hello" pada 15 posisi berakhir pada indeks 20  berlokasi pada indeks -1

'c', 'a' atau '$' pertama berlokasi pada indeks 0
'c', 'a' atau '$' pertama mulai dari indeks 7 berlokasi pada indeks 13
'c', 'a' atau '$' pertama pada 5 posisi mulai dari indeks 7 berlokasi pada indeks -1
'c', 'a' atau '$' terakhir berlokasi pada indeks 15
'c', 'a' atau '$' terakhir sampai posisi 1 berlokasi pada indeks 0
'c', 'a' atau '$' terakhir pada 5 posisi berakhir pada indeks 25 berlokasi pada indeks -1

Baris 22, 24, dan 26 menggunakan metode LastIndexOf untuk mencari lokasi kemunculan terakhir atas sebuah karakter di dalam suatu string. Metode LastIndexOf melakukan pencarian dari akhir string sampai awal string. Jika ia menemukan karakter yang dicari, LastIndexOf akan menghasilkan indeks dari karakter itu di dalam string; sebaliknya, LastIndexOf menghasilkan -1. Ekspresi pada baris 22 menggunakan versi LastIndexOf yang mengambil karakter yang akan dicari sebagai argumen. Ekspresi pada baris 24 menggunakan versi LastIndexOf yang mengambil dua argumen, yaitu karakter yang dicari dan indeks tertinggi untuk memulai pencarian mundur. Ekspresi pada baris 26 menggunakan versi ketiga dari metode LastIndexOf yang mengambil tiga argumen, yaitu karakter yang dicari, indeks tertinggi untuk memulai pencarian mundur, dan jumlah karakter (potongan string) yang menjadi lokasi pencarian.

Baris 29-34 menggunakan versi IndexOf dan LastIndexOf yang mengambil sebuah string (menggantikan sebuah karakter) sebagai argumen pertama. Kedua versi ini melakukan pencarian identik seperti yang telah dijelaskan, kecuali bahwa target pencarian adalah runtun karakter (substring) yang ditetapkan sebagai argumen stringnya.

Baris 47-64 menggunakan metode IndexOfAny dan LastIndexOfAny, yang mengambil sebuah array karakter sebagai argumen pertamanya. Kedua metode ini juga melakukan pencarian identik seperti yang telah dijelaskan, kecuali bahwa keduanya menghasilkan indeks dari kemunculan pertama dari sembarang karakter yang ada di dalam argumen array-karakter.

3.7 Mengekstrak Substring dari string
Kelas string menyediakan dua metode Substring, yang menciptakan sebuah string baru dengan menyalin sebagian dari string yang sudah ada. Setiap metode ini menghasilkan sebuah string baru. Aplikasi pada Gambar 3.6 mendemonstrasikan kegunaan dari kedua metode ini.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Gambar 3.6: SubString.cs
// Mendemonstrasikan metode Substring dari kelas string.
using System;

class SubString
{
    public static void Main( string[] args )
    {
        string huruf2 = "abcdefghijklmabcdefghijklm";

        // memanggil metode Substring dan melewatkannya satu parameter
        Console.WriteLine( "Substring dari indeks20 sampai akhir adalah \"" +
            huruf2.Substring( 20 ) + "\"" );

        // memanggil metode Substring dan melewatkannya dua parameter
        Console.WriteLine( "Substring dari indeks 0 dengan panjang 6 adalah \"" +
            huruf2.Substring( 0, 6 ) + "\"" );
    } // akhir metode Main
} // akhir kelas SubString

Substring dari indeks20 sampai akhir adalah "hijklm"
Substring dari indeks 0 dengan panjang 6 adalah "abcdef"

Statemen pada baris 13 menggunakan metode Substring yang mengambil satu argumen int. Argumen itu menetapkan indeks awal, dimana metode menyalin karakter-karakter di dalam string awal. Substring yang dihasilkan memuat salinan karakter-karakter dari indeks awal sampai akhir string. Jika indeks yang ditetapkan pada argumen berada di luar batas string, maka program akan melemparkan eksepsi ArgumentOutOfRangeException.

Versi kedua dari metode Substring (baris 17) mengambil dua argumen int. Argumen pertama menetapkan indeks awal (lokasi awal penyalinan). Argumen kedua menetapkan panjang substring yang akan disalin. Substring yang dihasilkan memuat salinan dari karakter-karakter yang ditetapkan dari string asli. Jika panjang substring yang diminta terlalu besar, maka program akan melemparkan eksepsi ArgumentOutOfRangeException.

3.8 Menyambung string
Operator + bukan satu-satunya cara untuk melakukan penyambungan string. Metode static Concat dari kelas string (Gambar 3.7) menyambung dua string dan menghasilkan sebuah string baru yang memuat karakter-karakter terkombinasi dari kedua string asli. Baris 16 menempelkan karakter-karakter dari string2 di akhir salinan dari string1, menggunakan metode Concat. Statemen pada baris 16 tidak memodifikasi kedua string asli.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Gambar 3.7: SambungString.cs
// Mendemonstrasikan metode Concat dari kelas string.
using System;

class SambungString
{
    public static void Main( string[] args )
    {
        string string1 = "Selamat ";
        string string2 = "Ultah";

        Console.WriteLine( "string1 = \"" + string1 + "\"\n" +
            "string2 = \"" + string2 + "\"" );
        Console.WriteLine(
            "\nHasil dari string.Concat( string1, string2 ) = " +
        string.Concat( string1, string2 ) );
        Console.WriteLine( "string1 setelah penyambungan = " + string1 );
    } // akhir Main
} // akhir kelas SambungString

string1 = "Selamat "
string2 = "Ultah"

Hasil dari string.Concat( string1, string2 ) = Selamat Ultah
string1 setelah penyambungan = Selamat

3.9 Pelbagai Metode string
Kelas string menyediakan beberapa metode yang menghasilkan salinan-salinan termodifikasi dari string. Aplikasi pada Gambar 3.8 mendemonstrasikan kegunaan dari metode-metode ini, mencakup metode-metode Replace, ToLower, ToUpper, dan Trim.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Gambar 3.8: Metode2String.cs
// Mendemonstrasikan metode Replace, ToLower, ToUpper, Trim,
// dan ToString.
using System;

class StringMethods2
{
    public static void Main( string[] args )
    {
        string string1 = "Horas!";
        string string2 = "SELAMAT JALAN ";
        string string3 = " spasi ";

        Console.WriteLine( "string1 = \"" + string1 + "\"\n" +
            "string2 = \"" + string2 + "\"\n" +
            "string3 = \"" + string3 + "\"" );

        // memanggil metode Replace
        Console.WriteLine(
            "\nMengganti \"o\" dengan \"O\" pada string1: \"" +
            string1.Replace( 'o', 'O' ) + "\"" );

        // memanggil ToLower dan ToUpper
        Console.WriteLine( "\nstring1.ToUpper() = \"" +
            string1.ToUpper() + "\"\nstring2.ToLower() = \"" +
            string2.ToLower() + "\"" );

        // memanggil metode Trim
        Console.WriteLine( "\nstring3 setelah Trim = \"" +
            string3.Trim() + "\"" );

        Console.WriteLine( "\nstring1 = \"" + string1 + "\"" );
    } // akhir Main
} // akhir kelas Metode2String

string1 = "Horas!"
string2 = "SELAMAT JALAN "
string3 = " spasi "

Mengganti "o" dengan "O" pada string1: "HOras!"

string1.ToUpper() = "HORAS!"
string2.ToLower() = "selamat jalan "

string3 setelah Trim = "spasi"

string1 = "Horas!"

Baris 21 menggunakan metode Replace untuk menghasilkan sebuah string baru, mengganti setiap kemunculan karakter ‘o’ di dalam string1 dengan ‘O’. Metode Replace mengambil dua argumen, yaitu sebuah char yang akan dicari dan sebuah char lain untuk mengganti setiap kemunculan dari argumen pertama. String asli tidak berubah. Jika tidak ada kemunculan dari argumen pertama di dalam string, maka metode ini menghasilkan string asli. Versi teroverload dari metode ini memampukan Anda untuk menyediakan dua string sebagai argumen.

Metode ToUpper menghasilkan sebuah string baru (baris 25) yang mengganti setiap huruf kecil di dalam string1 dengan huruf besar ekivalen. Metode ini menghasilkan sebuah string baru yang memuat string terkonversi; string asli tetap tidak berubah. Jika tidak ada karakter yang dikonversi, maka string asli menjadi nilai balik. Baris 26 menggunakan metode ToLower untuk menghasilkan sebuah string baru dimana setiap huruf besar pada string2 diganti dengan huruf kecil ekivalen. String asli tidak berubah. Sama seperti ToUpper, jika tidak ada karakter yang dikonversi, maka string asli menjadi nilai balik.

Baris 30 menggunakan metode Trim untuk menghapus semua karakter spasi-putih yang muncul di awal dan di akhir sebuah string. Tanpa mengubah string asli, metode ini menghasilkan sebuah string baru yang memuat string asli (tanpa spasi-putih). Metode ini khususnya berguna untuk membaca masukan pengguna (melalui sebuah TextBox). Versi lain dari metode Trim mengambil sebuah array karakter sebagai argumen dan menghasilkan suatu salinan string yang tidak diawali atau diakhiri dengan setiap karakter yang ada di dalam argumen array.

3.10 Kelas StringBuilder
Kelas string menyediakan banyak kapabilitas untuk pemrosesan string. Namun, isi string asli tidak pernah berubah. Operasi-operasi penyambungan string pada kenyataannya menugaskan referensi-referensi string kepada string yang baru (misalnya, operator += menciptakan sebuah string baru dan menugaskan referensi string awal kepada string yang baru saja diciptakan).

Pada beberapa bagian ke depan mendiskusikan beberapa fitur dari kelas StringBuilder (namespace System.Text), yang dipakai untuk menciptakan dan memanipulasi informasi string dinamis. Setiap StringBuilder dapat menyimpan sejumlah karakter tertentu yang ditetapkan oleh kapasitasnya. Jika terjadi kelebihan kapasitas dari sebuah StringBuilder, maka kapasitasnya akan membengkak untuk mengakomodasi karakter-karakter tambahan. Anggota-anggota dari kelas StringBuilder, seperti metode Append dan AppendFormat, dapat dipakai untuk melakukan operasi penyambungan seperti operator + dan += dari kelas string. Kelas StringBuilder khususnya berguna untuk memanipulasi string yang berukuran besar.

Kelas StringBuilder menyediakan enam konstruktor teroverload. Kelas KonstruktorStringBuilder (Gambar 3.9) mendemonstrasikan tiga di antaranya.

Baris 10 memakai konstruktor StringBuilder tanpa-argumen untuk menciptakan sebuah StringBuilder yang tidak memuat satupun karakter dan dengan kapasitas awal default. Baris 11 menggunakan konstruktor StringBuilder yang mengambil sebuah argumen int untuk menciptakan sebuah StringBuilder yang tidak memuat satupun karakter dan dengan kapasitas awal yang ditetapkan di dalam argumen int (misalnya, 10). Baris 12 menggunakan konstruktor StringBuilder yang mengambil sebuah argumen string untuk menciptakan suatu StringBuilder yang memuat karakter-karakter dari argumen string tersebut. Baris 14-16 secara implisit menggunakan metode ToString dari kelas StringBuilder untuk mendapatkan representasi string atas isi dari StringBuilder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Gambar 3.9: KonstruktorStringBuilder.cs
// Mendemonstrasikan konstruktor-konstruktor kelas StringBuilder.
using System;
using System.Text;

class KonstruktorStringBuilder
{
    public static void Main( string[] args )
    {
StringBuilder buffer1 = new StringBuilder();
StringBuilder buffer2 = new StringBuilder( 10 );
StringBuilder buffer3 = new StringBuilder( "hallo" );

        Console.WriteLine( "buffer1 = \"" + buffer1 + "\"" );
        Console.WriteLine( "buffer2 = \"" + buffer2 + "\"" );
        Console.WriteLine( "buffer3 = \"" + buffer3 + "\"" );
    } // akhir Main
} // akhir kelas KonstruktorStringBuilder

buffer1 = ""
buffer2 = ""
buffer3 = "hallo"

3.11 Properti Length dan Capacity, Metode EnsureCapacity, dan Indekser dari Kelas StringBuilder
Kelas StringBuilder menyediakan properti Length dan Capacity untuk menghasilkan jumlah karakter yang sedang dimuat di dalam suatu StringBuilder dan jumlah karakter yang dapat disimpan oleh sebuah StringBuilder tanpa perlu mengalokasikan memori tambahan. Kedua properti ini juga dapat menambah atau mengurangi panjang kapasitas dari StringBuilder. Metode EnsureCapacity memampukan Anda untuk mereduksi berapa kali kapasitas StringBuilder dapat ditambah. Metode ini memastikan bahwa kapasitas StringBuilder sedikitnya sebesar nilai yang ditetapkan. Program pada Gambar 3.10 mendemonstrasikan metode dan properti ini.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Gambar 3.10: FiturStringBuilder.cs
// Mendemonstrasikan beberapa fitur dari kelas StringBuilder.
using System;
using System.Text;

class FiturStringBuilder
{
    public static void Main( string[] args )
    {
StringBuilder buffer =
    new StringBuilder( "Hallo, apa kabar?" );

        // menggunakan properti Length dan Capacity
        Console.WriteLine( "buffer = " + buffer +
            "\nPanjang = " + buffer.Length +
            "\nKapasitas = " + buffer.Capacity );

        buffer.EnsureCapacity( 75 ); // memastikan kapasitas sedikitnya 75
        Console.WriteLine( "\nKapasitas baru = " +
            buffer.Capacity );

        // memotong StringBuilder dengan menetapkan properti Length
        buffer.Length = 10;
        Console.Write( "\nPanjang baru = " +
            buffer.Length + "\nbuffer = " );

        // menggunakan indekser StringBuilder
        for ( int i = 0; i < buffer.Length; i++ )
            Console.Write( buffer[ i ] );

        Console.WriteLine( "\n" );
    } // akhir Main
} // akhir kelas FiturStringBuilder

buffer = Hallo, apa kabar?
Panjang = 17
Kapasitas = 17

Kapasitas baru = 75

Panjang baru = 10
buffer = Hallo, apa

Program memuat satu StringBuilder, dinamakan buffer. Baris 10-11 pada program menggunakan konstruktor StringBuilder yang mengambil sebuah argumen string untuk menginstansiasi StringBuilder dan menginisialisasinya dengan nilai “Hallo, apa kabar?”. Baris 14-16 menampilkan isi, panjang, dan kapasitas dari StringBuilder.

Baris 18 mengekspansi kapasitas dari StringBuilder menjadi minimum 75 karakter. Jika karakter-karakter baru ditambahkan pada sebuah StringBuilder sehingga panjangnya melebih kapasitas StringBuilder, maka kapasitas bertambah untuk mengakomodasi karakter-karakter tambahan.

Baris 23 menggunakan properti Length untuk menetapkan panjang dari StringBuilder menjadi 10. Jika panjang yang ditetapkan kurang dari jumlah karakter yang ada di dalam StringBuilder, maka isi dari StringBuilder akan dipotong menjadi panjang yang ditetapkan. Jika panjang yang ditetapkan lebih dari jumlah karakter yang ada di dalam StringBuilder, maka karakter-karakter null akan ditempelkan di belakang StringBuilder sampai jumlah karakter total di dalam StringBuilder sama dengan panjang yang ditetapkan.

3.12 Metode Append dan AppendFormat dari Kelas StringBuilder
Kelas StringBuilder menyediakan 19 metode Append teroverload yang memampukan pelbagai tipe nilai ditambahkan ke akhir sebuah StringBuilder. Pustaka kelas Framework menyediakan beberapa versi untuk tiap tipe sederhana dan untuk array karakter, string dan object. Ingat bahwa metode ToString menghasilkan representasi string atas sembarang object. Setiap metode Append mengambil sebuah argumen, mengkonversinya menjadi sebuah string dan menempelkannya ke StringBuilder. Gambar 3.11 mendemonstrasikan kegunaan dari beberapa metode Append.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Gambar 3.11: TempelStringBuilder.cs
// Mendemonstrasikan metode-metode Append dari kelas StringBuilder.
using System;
using System.Text;

class StringBuilderAppend
{
    public static void Main( string[] args )
    {
        object nilaiObjek = "hallo";
        string nilaiString = "selamat jalan";
        char[] arrayKarakter = { 'a', 'b', 'c', 'd', 'e', 'f' };
        bool nilaiBoolean = true;
        char nilaiKarakter = 'Z';
        int nilaiInteger = 7;
        long nilaiLong = 1000000;
        float nilaiFloat = 2.5F; // sufiks F mengindikasikan 2.5 adalah float
        double nilaiDouble = 33.333;
        StringBuilder buffer = new StringBuilder();

        // menggunakan metode Append untuk menempelkan nilai-nilai pada buffer
buffer.Append( nilaiObjek );
buffer.Append( " " );
buffer.Append( nilaiString );
buffer.Append( " " );
buffer.Append( arrayKarakter );
buffer.Append( " ");
buffer.Append( arrayKarakter, 0, 3 );
buffer.Append( " " );
buffer.Append( nilaiBoolean );
buffer.Append( " " );
buffer.Append( nilaiKarakter );
buffer.Append( " " );
buffer.Append( nilaiInteger );
buffer.Append( " " );
buffer.Append( nilaiLong );
buffer.Append( " " );
buffer.Append( nilaiFloat );
buffer.Append( " " );
buffer.Append( nilaiDouble );

        Console.WriteLine( "buffer = " + buffer.ToString() + "\n" );
    } // akhir Main
} // akhir kelas TempelStringBuilder

buffer = hallo selamat jalan abcdef abc True Z 7 1000000 2.5 33.333

Baris 22-40 menggunakan 10 metode Append teroverload untuk menempelkan representasi string dari objek-objek yang diciptakan pada baris 10-18 ke akhir StringBuilder.

Kelas StringBuilder juga menyediakan metode AppendFormat, yang mengkonversi sebuah string menjadi format tertentu, kemudian menempelkannya ke StringBuilder. Contoh pada Gambar 3.12 mendemonstrasikan kegunaan dari metode ini.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Gambar 3.12: AppendFormatStringBuilder.cs
// Mendemonstrasikan metode AppendFormat.
using System;
using System.Text;

class AppendFormatStringBuilder
{
    public static void Main( string[] args )
    {
        StringBuilder buffer = new StringBuilder();

// string terformat
string string1 = "{0} ini seharga: {1:C}.\n";

// array argumen string1
object[] arrayObjek = new object[ 2 ];

arrayObjek[ 0 ] = "Mobil";
arrayObjek[ 1 ] = 1234.56;

        // menempelkan string terformat pada buffer
        buffer.AppendFormat( string1, arrayObjek );

        // string terformat
string string2 = "Angka:{0:d3}.\n" +
    "Angka disejajarkan ke kanan dengan spasi:{0, 4}.\n" +
    "Angka disejajarkan ke kiri dengan spasi:{0, -4}.";

        // menempelkan string terformat pada buffer
        buffer.AppendFormat( string2, 5 );

        // menampilkan string-string terformat
        Console.WriteLine( buffer.ToString() );
    } // akhir Main
} // akhir kelas AppendFormatStringBuilder

obil ini seharga: $1,234.56.
ngka:005.
ngka disejajarkan ke kanan dengan spasi:   5.
ngka disejajarkan ke kiri dengan spasi:5   .

Baris 13 menciptakan sebuah string yang memuat informasi pemformatan. Informasi yang diapit oleh sepasang kurung kurawal ini menetapkan bagaimana memformat potongan data tertentu. Format tersebut berupa {X[,Y][:FormatString]}, dimana X adalah jumlah argumen yang akan diformat, mulai dari nol. Y adalah argumen opsional, yang dapat bernilai positif atau negatif, mengindikasikan berapa banyak karakter yang ada pada hasil. Jika string yang dihasilkan kurang dari jumlah Y, maka ia akan diganjal dengan spasi-spasi. Integer positif akan menyejajarkan string ke kanan; Integer negatif akan menyejajarkan string ke kiri. FormatString opsional menggunakan format tertentu terhadap argumen, yaitu currency, desimal, atau saintifik. Pada kasus ini, “{0}” berarti argumen pertama akan ditampilkan. “{1:C}” menetapkan bahwa argumen kedua akan diformat sebagai nilai moneter (currency).

Baris 22 menunjukkan sebuah versi dari AppendFormat yang mengambil dua parameter, yaitu sebuah string yang menetapkan format dan sebuah array objek yang berperan sebagai argumen-argumen bagi string format. Argumen yang ditunjuk oleh “{0}” adalah array objek pada indeks 0.

Baris 25-27 mendefinisikan string lain yang dipakai untuk pemformatan. Format pertama, “{0:d3}”, menetapkan bahwa argumen pertama akan diformat sebagai sebuah desimal tiga-dijit, yang berarti bahwa sembarang angka yang kurang dari tiga dijit akan memiliki nol-nol yang berada di depan angka tersebut. Format berikutnya, “{0, 4}”, menetapkan bahwa string terformat harus memiliki empat karakter dan disejajarkan ke kanan. Format ketiga, “{0, -4}”, menetapkan bahwa string terformat harus disejajarkan ke kiri.

Baris 30 menggunakan sebuah versi dari AppendFormat yang mengambil dua parameter, yaitu sebuah string yang memuat sebuah format dan sebuah objek (dimana format akan diterapkan pada objek itu). Pada kasus ini, objek adalah angka 5. Keluaran pada Gambar 3.12 menampilkan hasil dari penerapan kedua versi dari AppendFormat.

3.13 Metode Insert, Remove, dan Replace dari Kelas StringBuilder
Kelas StringBuilder menyediakan 18 metode Insert teroverload yang memampukan pelbagai tipe data untuk disisipkan pada sembarang posisi di dalam sebuah StringBuilder. Kelas ini menyediakan beberapa versi untuk tiap tipe sederhanan dan untuk array karakter, string dan object. Setiap metode mengambil argumen keduanya, mengkonversinya menjadi sebuah string, dan menyisipkan string itu ke dalam StringBuilder di depan karakter pada posisi yang ditetapkan oleh argumen pertama. Indeks yang ditetapkan oleh argumen pertama harus lebih besar atau sama dengan 0 dan kurang dari panjang StringBuilder; sebaliknya, program akan melemparkan eksepsi ArgumentOutOfRangeException.

Kelas StringBuilder juga menyediakan metode Remove untuk menghapus sebagian dari sebuah StringBuilder. Metode Remove mengambil dua argumen, yaitu indeks untuk memulai penghapusan dan jumlah karakter yang akan dihapus. Penjumlahan atas indeks awal dan jumlah karakter yang akan dihapus harus bernilai kurang dari panjang StringBuilder; sebaliknya, program akan melemparkan eksepsi ArgumentOutOfRangeException. Metode Insert dan Remove didemonstrasikan pada Gambar 3.13.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Gambar 3.13: SisipHapusStringBuilder.cs
// Mendemonstrasikan metode Insert dan Remove dari
// kelas StringBuilder.
using System;
using System.Text;

class SisipHapusStringBuilder
{
    public static void Main( string[] args )
    {
        object nilaiObjek = "hallo";
        string nilaiString = "selamat jalan";
        char[] arrayKarakter = { 'a', 'b', 'c', 'd', 'e', 'f' };
        bool nilaiBoolean = true;
        char nilaiKarakter = 'K';
        int nilaiInteger = 7;
        long nilaiLong = 10000000;
        float nilaiFloat = 2.5F; // sufiks F mengindikasikan 2.5 adalah float
        double nilaiDouble = 33.333;
        StringBuilder buffer = new StringBuilder();

        // menyisipkan nilai-nilai ke dalam buffer
buffer.Insert( 0, nilaiObjek );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiString );
buffer.Insert( 0, " " );
buffer.Insert( 0, arrayKarakter );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiBoolean );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiKarakter );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiInteger );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiLong );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiFloat );
buffer.Insert( 0, " " );
buffer.Insert( 0, nilaiDouble );
buffer.Insert( 0, " " );

        Console.WriteLine( "buffer setelah beberapa kali Insert: \n" + buffer + "\n" );

buffer.Remove( 10, 1 ); // menghapus 2 pada 2.5
buffer.Remove(4, 4); // menghapus .333 pada 33.333

        Console.WriteLine( "buffer setelah beberapa kali Remove:\n" + buffer );
    } // akhir Main
} // akhir kelas SisipHapusStringBuilder

buffer setelah beberapa kali Insert:
 33.333 2.5 10000000 7 K True abcdef selamat jalan hallo

buffer setelah beberapa kali Remove:
 33.2. 10000000 7 K True abcdef selamat jalan hallo

Berikut adalah metode Replace dari kelas StringBuilder yang melakukan pencarian terhadap string atau karakter tertentu dan menggantinya dengan string atau karakter lain. Gambar 3.14 mendemonstrasikan metode ini.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Gambar 3.14: GantiStringBuilder.cs
// Mendemonstrasikan metode Replace.
using System;
using System.Text;

class GantiStringBuilder
{
    public static void Main( string[] args )
    {
        StringBuilder builder1 =
            new StringBuilder( "Selamat Ultah Vivian" );
        StringBuilder builder2 =
            new StringBuilder( "selamat jalan sihol" );

        Console.WriteLine( "Sebelum penggantian:\n" +
            builder1.ToString() + "\n" + builder2.ToString() );

builder1.Replace( "Vivian", "Sihol" );
builder2.Replace( 's', 'S', 0, 5 );

        Console.WriteLine( "\nSetelah penggantian:\n" +
            builder1.ToString() + "\n" + builder2.ToString() );
    } // akhir Main
} // akhir kelas GantiStringBuilder

Sebelum penggantian:
Selamat Ultah Vivian
selamat jalan sihol

Setelah penggantian:
Selamat Ultah Sihol
Selamat jalan sihol

Baris 18 menggunakan metode Replace untuk mengganti semua instans “Vivian” dengan “Sihol” pada builder1. Versi teroverload lain dari metode ini mengambil dua karakter sebagai parameter dan mengganti setiap kemunculan karakter pertama dengan karakter kedua. Baris 19 menggunakan versi teroverload dari Replace yang mengambil empat parameter, yaitu dua parameter pertama adalah karakter dan dua parameter kedua adalah int. Metode ini mengganti semua instans dari karakter pertama dengan karakter kedua, diawali pada indeks yang ditetapkan oleh argumen int pertama sampai sejumlah karakter yang ditetapkan oleh argumen int kedua. Jadi, pada kasus ini, Replace hanya mengganti lima karakter, diawali dari karakter pada indeks 0. Seperti yang diilustrasikan pada keluaran, versi Replace ini mengganti s dengan S pada kata “selamat”, tetapi tidak pada kata “sihol”.

3.14 Metode-Metode dari Kelas Char
C# menyediakan sebuah konsep yang dinamakan struct (singkatan dari structure) yang sama dengan sebuah kelas. Seperti kelas, struct dapat memiliki metode dan properti, dan dapat menggunakan pemodifikasi akses public dan private. Selain itu, anggota-anggota struct dapat diakses melalui operator akses anggota (.).

Tipe-tipe sederhana sebenarnya merupakan alias bagi tipe struct. Sebagai contoh, int didefinisikan oleh struct System.Int32, long didefinisikan oleh System.Int64, dan seterusnya. Semua tipe struct diderivasi dari kelas ValueType, yang diderivasi dari object. Selain itu, semua tipe struct secara implisit adalah sealed, jadi ia tidak mendukung metode virtual atau abstract, dan anggota-anggotanya tidak dapat dideklarasikan protected atau protected internal.

Pada struct Char, 2, yang merupakan struct untuk karakter, hampir semua metode adalah metode static, yang mengambil sedikitnya satu argumen karakter dan melakukan pengujian atau pemanipulasian pada karakter. Gambar 3.15 mendemonstrasikan metode-metode static yang menguji karakter-karakter untuk menentukan apakah ia merupakan bertipe karakter spesifik dan metode-metode static yang melakukan konversi huruf pada karakter-karakter.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Gambar 3.15: Metode2StaticChar.cs
// Mendemonstrasikan metode-metode penguji-karakter dan konversi-huruf
// dari Char struct
using System;

class Metode2StaticChar
{
    static void Main( string[] args )
    {
        Console.Write( "Masukkan sebuah karakter: " );
        char karakter = Convert.ToChar( Console.ReadLine() );

        Console.WriteLine( "apakah dijit: {0}", Char.IsDigit( karakter ) );
        Console.WriteLine( "apakah huruf: {0}", Char.IsLetter( karakter ) );
        Console.WriteLine( "apakah dijit atau huruf: {0}",
            Char.IsLetterOrDigit( karakter ) );
        Console.WriteLine( "apa huruf kecil: {0}",
            Char.IsLower( karakter ) );
        Console.WriteLine( "apa huruf besar: {0}",
            Char.IsUpper( karakter ) );
        Console.WriteLine( "menjadi huruf besar: {0}",
            Char.ToUpper( karakter ) );
        Console.WriteLine( "menjadi huruf kecil: {0}",
            Char.ToLower( karakter ) );
        Console.WriteLine( "apakah tanda baca: {0}",
            Char.IsPunctuation( karakter ) );
        Console.WriteLine( "apakah simbol: {0}", Char.IsSymbol( karakter ) );
    } // akhir Main
} // akhir kelas Metode2StaticChar

Masukkan sebuah karakter: A
apakah dijit: False
apakah huruf: True
apakah dijit atau huruf: True
apa huruf kecil: False
apa huruf besar: True
menjadi huruf besar: A
menjadi huruf kecil: a
apakah tanda baca: False
apakah simbol: False

Masukkan sebuah karakter: 8
apakah dijit: True
apakah huruf: False
apakah dijit atau huruf: True
apa huruf kecil: False
apa huruf besar: False
menjadi huruf besar: 8
menjadi huruf kecil: 8
apakah tanda baca: False
apakah simbol: False

Masukkan sebuah karakter: @
apakah dijit: False
apakah huruf: False
apakah dijit atau huruf: False
apa huruf kecil: False
apa huruf besar: False
menjadi huruf besar: @
menjadi huruf kecil: @
apakah tanda baca: True
apakah simbol: False

Masukkan sebuah karakter: m
apakah dijit: False
apakah huruf: True
apakah dijit atau huruf: True
apa huruf kecil: True
apa huruf besar: False
menjadi huruf besar: M
menjadi huruf kecil: m
apakah tanda baca: False
apakah simbol: False

Masukkan sebuah karakter: +
apakah dijit: False
apakah huruf: False
apakah dijit atau huruf: False
apa huruf kecil: False
apa huruf besar: False
menjadi huruf besar: +
menjadi huruf kecil: +
apakah tanda baca: False
apakah simbol: True

Setelah pengguna memasukkan sebuah karakter, baris 13-27 menganalisanya. Baris 13 menggunakan metode IsDigit dari kelas Char untuk menentukan apakah karakter didefinisikan sebagai sebuah dijit. Jika ya, metode ini menghasilkan true; sebaliknya, ia menghasilkan false. Baris 14 menggunakan metode IsLetter untuk menentukan apakah karakter adalah sebuah huruf. Baris 16 menggunakan metode IsLetterDigit untuk menentukan apakah karakter adalah sebuah huruf atau sebuah dijit.

Baris 18 menggunakan metode IsLower untuk menentukan apakah karakter adalah huruf kecil. Baris 20 menggunakan metode IsUpper untuk menentukan apakah karakter adalah huruf besar. Baris 22 menggunakan metode ToUpper untuk mengkonversi karakter menjadi huruf besar ekivelennya. Metode ini menghasilkan karakter terkonversi jika karakter memiliki huruf besar ekivalennya; sebaliknya, metode ini menghasilkan argumen aslinya. Baris 24 menggunakan metode ToLower untuk mengkonversi karakter menjadi huruf kecil ekivelennya. Metode ini menghasilkan karakter terkonversi jika karakter memiliki huruf kecil ekivalennya; sebaliknya, metode ini menghasilkan argumen aslinya.

Baris 26 menggunakan metode IsPunctuation untuk menentukan apakah karakter merupakan tanda baca, seperti “!”, “:”, atau “)”. Baris 27 menggunakan metode IsSymbol untuk menentukan apakah karakter adalah sebuah simbol, seperti “+”, “=”, atau “^”.

3.15 Ekspresi Reguler
Sekarang akan diintroduksi ekspresi reguler, yang merupakan string terformat yang dipakai untuk mencari pola di dalam teks. Ekspresi reguler ini dipakai untuk memastikan bahwa data dalam format khusus. Kompiler menggunakan ekspresi reguler untuk memvalidasi sintaks program. Jika kode program tidak cocok dengan ekspresi reguler, maka kompiler akan mengindikasikan bahwa terjadi error sintaks. Akan didiskusikan kelas Regex dan Match dari namespace System.Text.RegularExpressions berikut dengan simbol-simbol yang dipakai untuk membentuk ekspresi-ekspresi reguler. Kemudian akan didemonstrasikan bagaimana menemukan pola-pola di dalam sebuah string, mencocokkan keseluruhan string dengan pola-pola, mengganti karakter-karakter di dalam suatu string yang cocok dengan pola tertentu, dan memecah string-string pada pembatas (delimiter) yang ditetapkan sebagai pola pada ekspresi reguler.

Ekspresi Reguler Sederhana dan Kelas Regex
Pustaka kelas .NET Framework menyediakan beberapa kelas untuk membantu para pengembang dalam memanipulasi ekspresi-ekspresi reguler. Gambar 3.16 mendemonstrasikan kelas-kelas ekspresi-reguler dasar. Untuk menggunakan kelas-kelas ini, Anda perlu menambahkan sebuah statemen using untuk namespace System.Text.RegularExpressions (baris 4). Kelas Regex merepresentasikan sebuah ekspresi reguler. Anda menciptakan sebuah objek Regex, dinamai ekspresi (baris 16), untuk merepresentasikan ekspresi reguker “e”. Ekspresi reguler ini mencocokkan karakter literal “e” di dalam sembarang string. Metode Match dari kelas Regex menghasilkan sebuah objek dari kelas Match yang merepresentasikan sebuah kecocokan ekspresi-reguler. Metode ToString dari kelas Match menghasilkan substring yang cocok dengan ekspresi reguler. Pemanggilan terhadap metode Match (baris 17) mencocokkan kemunculan paling-kiri dari karakter “e” pada stringUji. Kelas Regex juga menyediakan metode Matches (baris 21), yang menemukan semua kecocokan dari ekspresi reguler di dalam sembarang string dan menghasilkan sebuah objek MatchCollection yang memuat semua Match. MatchCollection merupakan sebuah koleksi, sama seperti array, dan dapat dipakai dengan statemen foreach untuk beriterasi menjelajah elemen-elemen koleksi. Anda menggunakan sebuah statemen foreach (baris 21-22) untuk menampilkan semua kecocokan ekspresi pada stringUji. Elemen-elemen pada MatchCollection merupakan objek-objek Match, jadi statemen foreach menyimpulkan bahwa variabel kecocokanKu adalah bertipe Match. Untuk tiap Match, baris 22 menampilkan teks yang cocok dengan ekspresi reguler.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Gambar 3.16: RegexDasar.cs
// Mendemonstrasikan ekspresi-ekspresi reguler dasar.
using System;
using System.Text.RegularExpressions;

class RegexDasar
{
    static void Main( string[] args )
    {
        string stringUji =
            "ekspresi-ekspresi reguler kadangkala dinamakan dengan regex atau regexp";
        Console.WriteLine( "String uji adalah\n \"{0}\"", stringUji );
        Console.Write( "Mencocokkan 'e' di dalam string uji: " );

        // mencocokkan 'e' di dalam string uji
        Regex ekspresi = new Regex( "e" );
        Console.WriteLine( ekspresi.Match( stringUji ) );
        Console.Write( "Mencocokkan setiap 'e' di dalam string uji: " );

        // mencocokkan 'e' beberapa kali di dalam string uji
        foreach ( var kecocokanKu in ekspresi.Matches( stringUji ) )
            Console.Write( "{0} ", kecocokanKu );

        Console.Write( "\nMencocokkan \"regex\" di dalam string uji: " );

        // mencocokkan 'regex' di dalam string uji
        foreach (var kecocokanKu in Regex.Matches(stringUji, "regex"))
            Console.Write("{0} ", kecocokanKu);

        Console.Write(
            "\nMencocokkan \"regex\" atau \"regexp\" menggunakan opsi 'p': " );

        // menggunakan pengkuantifikasi ? untuk mencantumkan opsi 'p'
        foreach (var kecocokanKu in Regex.Matches(stringUji, "regexp?"))
            Console.Write("{0} ", kecocokanKu);

        // menggunakan alternasi untuk mencocokkan 'cat' atau 'hat'
        ekspresi = new Regex( "(c|h)at" );
        Console.WriteLine(
            "\n\"hat cat\" cocok dengan {0}, tetapi \"cat hat\" cocok dengan {1}",
            ekspresi.Match( "hat cat" ), ekspresi.Match( "cat hat" ) );
    } // akhir Main
} // akhir kelas RegexDasar

String uji adalah
 "ekspresi-ekspresi reguler kadangkala dinamakan dengan regex atau regexp"
Mencocokkan 'e' di dalam string uji: e
Mencocokkan setiap 'e' di dalam string uji: e e e e e e e e e e e
Mencocokkan "regex" di dalam string uji: regex regex
Mencocokkan "regex" atau "regexp" menggunakan opsi 'p': regex regexp
"hat cat" cocok dengan hat, tetapi "cat hat" cocok dengan cat

Ekspresi-ekspresi reguler dapat pula dipakai untuk mencocokkan suatu runtun karakter literal di dalam sebuah string. Baris 27-28 menampilkan semua kemunculan dari runtun karakter “regex” di dalam stringUji. Di sini, Anda menggunakan metode Matches dari kelas Regex. Kelas Regex menyediakan beberapa versi static dari metode Match dan Matches. Versi-versi static tersebut mengambil sebuah ekspresi reguler dan sebuah string untuk pencarian sebagai argumen. Hal ini berguna ketika Anda ingin memakai ekspresi reguler hanya sekali. Pemanggilan terhadap metode Matches (baris 27) menghasilkan dua kecocokan dengan ekspresi reguler “regex”. Perhatikan bahwa “regexp” di dalam stringUji cocok dengan ekspresi reguler “regex”. Anda menggunakan ekspresi reguler “regexp?” (baris 34) untuk mencocokkan kemunculan dari “regex” dan “regexp”. Tanda tanya (?) merupakan sebuah karakter-met (metacharacter), yaitu sebuah karakter dengan makna spesial di dalam ekspresi reguler. Tanda baca merupakan suatu pengkuantifikasi, yang menjelaskan berapa kali bagian dari suatu pola muncul di dalam suatu kecocokan. Pengkuantifikasi ? mencocokkan nol atau satu kemunculan pola di sebelah kirinya. Pada baris 34, Anda menerapkan pengkuantifikasi ? terhadap karakter “p”. Ini berarti bahwa sebuah kecocokan dengan ekspresi reguler memuat runtun karakter “regex” dan bisa saja diikuti dengan sebuah “p”. Perhatikan bahwa statemen foreach (baris 34-35) menampilkan kedua “regex” dan “regexp”.

Metacharacter memampukan Anda untuk menciptakan pola-pola yang lebih kompleks. Anda menggunakan alternasi (“|”) pada ekspresi reguler “(c|h)at” (baris 38) untuk mencocokkan “cat” atau “hat”. Sepasang kurung dipakai untuk mengelompokkan bagian-bagian dari suatu ekspresi reguler. Metacharacter “|” menyebabkan pola untuk mencocokkan runtun karakter yang diawali dengan “c” atau “h”, yang diikuti dengan “at”. Baris 41 menggunakan ekspresi reguler (baris 38) untuk melakukan pencarian terhadap string “hat cat” dan “cat hat”. Perhatikan pada keluaran bahwa kecocokan pertama pada “hat cat” adalah “hat”, sedangkan kecocokan pertama pada “cat hat” adalah “cat”.

Tabel pada Gambar 3.17 mencantumkan beberapa kelas karakter yang dapat dipakai dengan ekspresi reguler. Sebuah kelas karakter merepresentasikan sekelompok karakter yang muncul di dalam sebuah string. Sebagai contoh, karakter kata (\w) merupakan sembarang karakter alfanumerik (a-z, A-Z, dan 0-9) atau garis-bawah (underscore). Karakter garis-putih (\s) merupakan sebuah karakter spasi, tab, carriage return, newline, atau form feed. Dijit (\d) merupakan sembarang karakter numerik.

Kelas  karakter
Mencocokkan
Kelas Karakter
Mencocokkan
\d
sembarang dijit
\D
sembarang tak-dijit
\w
sembarang karakter kata
\W
sembarang karakter tak-kata
\s
sembarang spasi-putih
\S
sembarang tak-spasi-putih

Gambar 3.17 Kelas-kelas karakter

Gambar 3.18 menggunakan kelas-kelas karakter pada ekspresi-ekspresi reguler. Untuk contoh ini, Anda menggunakan metode TampilKecocokan (baris 53-59) untuk menampilkan semua kecocokan dengan sebuah ekspresi reguler. Metode TampilKecocokan mengambil dua string yang merepresentasikan string yang akan dicari dan eksrepsi reguler yang akan dicocokkan. Metode ini menggunakan sebuah statemen foreach untuk menampilkan setiap Match di dalam objek MatchCollection yang dihasilkan oleh metode static Matches dari kelas Regex.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// Gambar 3.18: KelasKarakter.cs
// Mendemonstrasikan penggunaan kelas-kelas karakter.
using System;
using System.Text.RegularExpressions;

class KelasKarakter
{
    static void Main( string[] args )
    {
        string stringUji = "abc, DEF, 123";
        Console.WriteLine( "String uji adalah: \"{0}\"", stringUji );

        // menemukan dijit-dijit di dalam string uji
        Console.WriteLine( "Mencocokkan sembarang dijit" );
        TampilKecocokan( stringUji, @"\d" );

        // mencari semua yang bukan dijit
        Console.WriteLine( "\nMencocokkan sembarang tak-dijit" );
        TampilKecocokan( stringUji, @"\D");

        // mencari karakter-karakter kata yang ada di dalam string uji
        Console.WriteLine( "\nMencocokkan sembarang karakter kata" );
        TampilKecocokan( stringUji, @"\w" );

        // mencari runtun yang memuat karakter-karakter kata
        Console.WriteLine(
            "\nMencocokkan sekelompok karakter, memuat sedikitnya satu karakter kata" );
            TampilKecocokan( stringUji, @"\w+" );

        // menggunakan pengkuantifikasi lazy
        Console.WriteLine(
            "\nMencocokkan sekelompok karakter, sedikitnya satu karakter kata (lazy)" );
            TampilKecocokan( stringUji, @"\w+?" );

        // mencocokkan karakter-karakter dari 'a' sampai 'f'
        Console.WriteLine( "\nMencocokkan semuanya dari 'a' - 'f'" );
        TampilKecocokan( stringUji, "[a-f]" );

        // mencocokkan semuanya yang bukan dalam rentang 'a' sampai 'f'
        Console.WriteLine( "\nMencocokkan semuanya yang tidak dari 'a' - 'f'" );
        TampilKecocokan( stringUji, "[^a-f]" );

        // mencocokkan sembarang runtun huruf
        Console.WriteLine( "\nMencocokkan sekelompok karakter, sedikitnya satu huruf" );
        TampilKecocokan( stringUji, "[a-zA-Z]+" );

        // menggunakan metacharacter . (dot) untuk mencocokkan sembarang karakter
        Console.WriteLine( "\nMencocokkan sekelompok karakter" );
        TampilKecocokan( stringUji, ".*" );
    } // akhir Main

    // menampilkan kecocokan-kecocokan dengan ekspresi reguler
    private static void TampilKecocokan( string masukan, string ekspresi )
    {
        foreach ( var kecocokanRegex in Regex.Matches( masukan, ekspresi ) )
            Console.Write( "{0} ", kecocokanRegex );

        Console.WriteLine(); // move to the next line
    } // akhir metode TampilKecocokan
} // akhir kelas KelasKarakter

String uji adalah: "abc, DEF, 123"
Mencocokkan sembarang dijit
1 2 3

Mencocokkan sembarang tak-dijit
a b c ,   D E F ,

Mencocokkan sembarang karakter kata
a b c D E F 1 2 3

Mencocokkan sekelompok karakter yang memuat sedikitnya satu karakter kata
abc DEF 123

Mencocokkan sekelompok karakter yang memuat sedikitnya satu karakter kata (lazy)
a b c D E F 1 2 3

Mencocokkan semuanya dari 'a' - 'f'
a b c

Mencocokkan semuanya yang tidak dari 'a' - 'f'
,   D E F ,   1 2 3

Mencocokkan sekelompok karakter yang memuat sedikitnya satu huruf
abc DEF

Mencocokkan sekelompok karakter
abc, DEF, 123

Ekspresi Reguler Kompleks
Program pada Gambar 3.19 mencoba untuk mencocokkan tanggal lahir dengan sebuah ekspresi reguler. Untuk mendemonstrasikannya, ekspresi akan dicocokkan hanya dengan tanggal lahir yang bukan pada April dan untuk mereka yang memiliki nama dimulai dengan “J”. Anda dapat melakukannya dengan menggabungkan teknik ekspresi-reguler dasar yang telah didiskusikan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Gambar 3.19: PencocokanRegex.cs
// Ekspresi reguler yang lebih kompleks.
using System;
using System.Text.RegularExpressions;

class PencocokanRegex
{
    static void Main( string[] args )
    {
        // menciptakan suatu ekspresi reguler
        Regex ekspresi = new Regex( @"J.*\d[\d-[4]]-\d\d-\d\d" );

        string stringUji =
            "Jenny lahir pada 05-12-75\n" +
            "David lahir pada 11-04-68\n" +
            "Johan lahir pada 04-28-73\n" +
            "Joni lahir pada 12-17-77";

        // menampilkan semua kecocokan dengan ekspresi reguler
        foreach ( var kecocokanRegex in ekspresi.Matches( stringUji ) )
            Console.WriteLine( kecocokanRegex );
    } // akhir Main
} // akhir kelas PencocokanRegex

Jenny lahir pada 05-12-75
Joni lahir pada 12-17-77

Baris 11 menciptakan sebuah objek Regex dan melewatkan suatu string pola ekspresi-reguler kepada konstruktornya. Karakter pertama pada ekspresi reguler, “J”, merupakan suatu karakter literal. Sembarang string yang memiliki kecocokan dengan ekspresi reguler ini harus diawali dengan “J”. Bagian berikutnya dari ekspresi reguler (“.*”) mencocokkan sejumlah karakter (yang tidak ditentukan) kecuali newline (garis-baru). Pola “J.*” mencocokkan nama orang yang diawali dengan J dan sembarang karakter setelahnya.

Selanjutnya Anda mencocokkan tanggal lahir orang. Anda menggunakan kelas karakter \d untuk mencocokkan dijit pertama dari bulan. Karena tanggal lahir tidak terjadi pada April, dijit kedua pada bulah tidak boleh 4. Anda menggunakan kelas karakter “[0-35-9]” untuk mencocokkan sembarang dijit selain 4. Namun, ekspresi reguler .NET memampukan Anda untuk mengurangkan anggota-anggota dari kelas karakter. Pada baris 11, Anda menggunakan pola “[\d-[4]]” untuk mencocokkan sembarang dijit selain 4.

Baris 20-21 menggunakan sebuah statemen foreach untuk menjelajahi objek MatchCollection yang dihasilkan oleh metode Matches, yang diterima stringUji sebagai argumennya. Untuk tiap Match, baris 21 menampilkan teks yang cocok dengan ekspresi reguler. Keluaran pada Gambar 3.19 menampilkan dua kecocokan yang ditemukan di dalam stringUji. Perhatikan bahwa kedua kecocokan sesuai dengan pola yang ditetapkan oleh ekspresi reguler.

3.16 Memvalidasi Masukan Pengguna dengan Ekspresi Reguler dan LINQ
Aplikasi pada Gambar 3.20 menyajikan sebuah contoh yang melibatkan ekspresi reguler dalam memvalidasi informasi nama, alamat, nomor telepon yang dientrikan oleh pengguna.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
// Gambar 3.20: Validasi.cs
// Memvalidasi informasi pengguna menggunakan ekspresi reguler.
using System;
using System.Linq;
using System.Text.RegularExpressions;
using System.Windows.Forms;

namespace Validasi
{
    public partial class Validasi : Form
    {
        public Validasi()
        {
            InitializeComponent();
        }

        //menangani event Click pada tombol OK
        private void tombolOK_Click(object sender, EventArgs e)
        {
            // menemukan TextBoxes kosong dan diurutkan dengan TabIndex
            var kotakKosong =
            from Control kendaliSekarang in Controls
            where kendaliSekarang is TextBox
            let kotak = kendaliSekarang as TextBox
            where string.IsNullOrEmpty( kotak.Text )
            orderby kotak.TabIndex
            select kotak;

            // jika ada TextBox yang kosong
            if ( kotakKosong.Count() > 0 )
            {
                // display message box indicating missing information
                MessageBox.Show( "Silahkan isi semua bidang",
                    "Informasi Hilang", MessageBoxButtons.OK,
                    MessageBoxIcon.Error );

                kotakKosong.First().Select(); // memilih TextBox kosong pertama
            } // akhir if
            else
            {
                // memeriksa masukan tak-valid
if ( !ValidasiMasukan( namaAkhirTextBox.Text,
    "^[A-Z][a-zA-Z]*$", "Nama akhir tak-valid" ) )

                    namaAkhirTextBox.Select(); // menyeleksi TextBox tak-valid
else if ( !ValidasiMasukan( namaPertamaTextBox.Text,
    "^[A-Z][a-zA-Z]*$", "Nama pertama tak-valid" ) )

                    namaPertamaTextBox.Select(); // menyeleksi TextBox tak-valid
else if ( !ValidasiMasukan( alamatTextBox.Text,
    @"^[0-9]+\s+([a-zA-Z]+|[a-zA-Z]+\s[a-zA-Z]+)$",
    "Alamat tak-valid" ) )

                    alamatTextBox.Select(); // menyeleksi TextBox tak-valid
else if (!ValidasiMasukan(kotaTextBox.Text,
    @"^([a-zA-Z]+|[a-zA-Z]+\s[a-zA-Z]+)$", "Kota tak-valid" ) )

                    kotaTextBox.Select(); // menyeleksi TextBox tak-valid
else if (!ValidasiMasukan(propinsiTextBox.Text,
    @"^([a-zA-Z]+|[a-zA-Z]+\s[a-zA-Z]+)$", "Propinsi tak-valid" ) )

                    propinsiTextBox.Select(); // menyeleksi TextBox tak-valid
else if (!ValidasiMasukan(kodePosTextBox.Text,
    @"^\d{5}$", "Kode pos tak-valid" ) )

                    kodePosTextBox.Select(); // menyeleksi TextBox tak-valid
else if (!ValidasiMasukan(teleponTextBox.Text,
    @"^[1-9]\d{2}-[1-9]\d{2}-\d{4}$",
    "Nomor telepon tak-valid" ) )

                    teleponTextBox.Select(); // menyeleksi TextBox tak-valid
                else // jika semua masukan valid
                {
                    this.Hide(); // hide main window
                    MessageBox.Show( "Terima Kasih!", "Informasi Tepat",
                    MessageBoxButtons.OK, MessageBoxIcon.Information );
                    Application.Exit(); // exit the application
                } // akhir else
            } // akhir else
        } // akhir metode okButton_Click
    
         // menggunakan ekspresi reguler untuk memvalidasi masukan pengguna
        private bool ValidasiMasukan(
            string masukan, string ekspresi, string pesan )
        {
            // menyimpan apakah masukan valid
            bool valid = Regex.Match( masukan, ekspresi ).Success;

            // jika masukan tidak cocok dengan ekspresi reguler
            if ( !valid )
            {
                // memberitahu pengguna bahwa masukan tak-valid
                MessageBox.Show( pesan, "Masukan Tak-Valid",
                MessageBoxButtons.OK, MessageBoxIcon.Error );
            } // akhir if

            return valid; // menghasilkan apakah masukan valid
        } // akhir metode ValidasiMasukan
    } // akhir kelasi ValidasiForm
} // akhir namespace Validasi



Ketika pengguna mengklik OK, program menggunakan suatu LINQ query untuk menyeleksi sembarang TextBox yang kosong (baris 22-27) dari koleksi Controls. Perhatikan bahwa Anda secara eksplisit mendeklarasikan tipe dari variabel rentang di dalam klausa from (baris 22). Ketika bekerja dengan koleksi tak-generik, seperti Controls, Anda harus secara eksplisit memberikan tipe terhadap variabel rentang. Klausa where yang pertama (baris 23) menentukan apakah kendaliSekarang merupakan suatu TextBox. Klausa let (baris 24) menciptakan dan menginisialisasi suatu variabel di dalam LINQ query untuk digunakan nanti pada query. Di sini, Anda menggunakan klausa let untuk mendefinisikan variabel kotak sebagai sebuah TextBox, yang memuat objek Control yang dicast (dikonversi paksa) menjadi sebuah TextBox. Ini memampukan Anda untuk menggunakan kontrol di dalam LINQ query sebagai TextBox, yang memampukan akses terhadap properti-propertinya (seperti Text). Anda perlu mencantumkan klausa where yang kedua setelah klausa let. Klausa where yang kedua menentukan apakah properti Text dari TextBox kosong. Jika satu atau lebih TextBox kosong (baris 30), maka program akan menampilkan sebuah pesan kepada pengguna (baris 33-35) bahwa semua bidang harus diisi sebelum program dapat memvalidasi informasi. Baris 37 memanggil metode Select dari TextBox yang pertama pada hasil query sehingga pengguna dapat memulai mengetik pada TextBox. Query mengurutkan semua TextBox berdasarkan TabIndex (baris 26) sehingga TextBox yang pertama pada hasil query merupakan TextBox kosong pertama pada Form. Jika tidak ada bidang yang kosong, maka baris 39-71 akan memvalidasi masukan pengguna.



Anda memanggil metode ValidasiMasukan untuk menentukan apakah masukan pengguna cocok dengan ekspresi reguler yang ditetapkan. ValidasiMasukan (baris 83-98) mengambil sebagai argumen masukan teks yang diberikan pengguna (masukan), ekspresi reguler yang harus dicocokkan (ekspresi), dan sebuah pesan untuk ditampilkan jika masukan tak-valid (pesan). Baris 87 memanggil metode static Regex, yang melewatkan string yang akan divalidasi dan ekspresi reguler sebagai argumennya. Properti Success dari kelas Match mengindikasikan apakah argumen pertama pada Match cocok dengan pola yang ditetapkan oleh ekspresi reguler pada argumen kedua. Jika nilai dari Success adalah false (tidak ada kecocokan), maka baris 93-94 akan menampilkan pesan error yang dilewatkan sebagai argumen kepada metode ValidasiMasukan. Baris 97 kemudian menghasilkan nilai dari properti Success. Jika ValidasiMasukan menghasilkan false, maka TextBox yang memuat data tak-valid akan dipilih sehingga pengguna dapa mengkoreksi masukan. Jika semua masukan valid, maka statemen else (baris 72-78) akan menampilkan sebuah dialog pesan yang menyatakan bahwa semua masukan valid dan program berhenti ketika pengguna menutup dialog tersebut.

Pada contoh sebelumnya, Anda telah melakukan pencarian terhadap substring-substring pada suatu string yang cocok dengan suatu ekspresi reguler. Pada contoh ini, Anda ingin memastikan bahwa keseluruhan string untuk tiap masukan sesuai dengan ekspresi reguler tertentu. Sebagai contoh, Anda akan menerima “Sutanto” sebagai nama akhir, tetapi tidak “9@Sutanto#”. Pada ekspresi reguler yang diawali dengan karakter “^” dan diakhiri dengan karakter “$” (baris 43), kedua karakter itu merepresentasikan awal dan akhir suatu string. Kedua karakter itu memaksa ekspresi reguler untuk menghasilkan kecocokan hanya jika keseluruhan string yang sedang diproses cocok dengan ekspresi reguler.

Ekspresi reguler pada baris 43 dan 47 menggunakan sebuah kelas karakter untuk mencocokkan suatu huruf pertama yang berupa huruf besar, selanjutnya a-z mencocokkan sembarang huruf kecil, dan A-Z mencocokkan sembarang huruf besar. Pengkuantifikasi * menandakan bahwa rentang karakter yang kedua dapat terjadi nol kali atau lebih di dalam string. Jadi, ekspresi ini mencocokkan sembarang string yang memuat satu huruf besar, yang diikuti dengan satu atau lebih huruf-huruf lainnya.

Kelas karakter \s mencocokkan suatu karakter spasi-putih (baris 51, 56, dan 60). Pada ekspresi “\d{5}”, yang digunakan untuk string kodePos (baris 64), {5} merupakan sebuah pengkuantifikasi. Pola di sebelah kiri dari {n} harus terjadi persis sebanyak n kali. Jadi, “\d{5}” mencocokkan sembarang lima dijit. Ingat bahwa karakter “|” (baris 51, 56, dan 60) mencocokkan ekspresi di sebelah kiri atau ekspresi di sebelah kanannya. Pada baris 51, Anda menggunakan karakter “|” untuk mengindikasikan bahwa alamat dapat memuat sebuah kata yang memuat satu atau lebih karakter atau sebuah kata yang memuat satu atau lebih karakter yang diikuti dengan sebuah spasi dan kata lain yang memuat satu atau lebih karakter. Perhatikan kegunaan dari sepasang kurung untuk mengelompokkan ekspresi reguler. Ini memastikan bahwa “|” diterapkan terhadap bagian-bagian pola secara tepat.

Kedua TextBox, Nama Akhir: dan Nama Pertama:, masing-masing menerima string yang diawali dengan sebuah huruf besar (baris 43 dan 47). Ekspresi reguler untuk TextBox Alamat: (baris 51) mencocokkan sedikitnya satu dijit, yang diikuti dengan sebuah spasi dan kemudian satu atau lebih huruf atau satu atau lebih huruf yang diikuti dengan sebuah spasi dan sederet satu atau lebih huruf.

3.17 Metode Replace dan Split dari Kelas Regex
Kadangkala diperlukan untuk mengganti sebagian dari sebuah string atau untuk memecah sebuah string sesuai dengan suatu ekspresi reguler. Untuk itu, kelas Regex menyediakan beberapa versi metode Replace dan Split, yang didemonstrasikan pada Gambar 3.21.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// Gambar 3.21: SubstitusiRegex.cs
// Menggunakan metode Replace dan Split dan kelas Regex.
using System;
using System.Text.RegularExpressions;

class SubstitusiRegex
{
    static void Main( string[] args )
    {
        string stringUji1 = "Kalimat ini diakhiri dengan 5 bintang *****";
        string stringUji2 = "1, 2, 3, 4, 5, 6, 7, 8";
        Regex ujiRegex1 = new Regex( @"\d" );
        string keluaran = string.Empty;

        Console.WriteLine( "String uji pertama: {0}", stringUji1 );

        // mengganti setiap '*' dengan '^' dan menampilkan hasilnya
        stringUji1 = Regex.Replace( stringUji1, @"\*", "^" );
        Console.WriteLine( "^ menggantikan *: {0}", stringUji1 );

        // mengganti kata "bintang" dengan "star" dan menampilkan hasilnya
        stringUji1 = Regex.Replace( stringUji1, "bintang", "star" );
        Console.WriteLine( "\"star\" menggantikan \"bintang\": {0}",
            stringUji1 );

        // mengganti setiap kata dengan "kata" dan menampilkan hasilnya
        Console.WriteLine( "Setiap kata diganti dengan \"kata\": {0}",
            Regex.Replace( stringUji1, @"\w+", "kata" ) );

        Console.WriteLine( "\nString uji kedua: {0}", stringUji2 );

        // mengganti tiga dijit pertama dengan kata "dijit"
        Console.WriteLine( "Mengganti tiga dijit pertama dengan \"dijit\": {0}",
            ujiRegex1.Replace( stringUji2, "dijit", 3 ) );

        Console.Write( "string dipecah pada koma [" );

        // memecah string menjadi string-string individual, masing-masing memuat sebuah dijit
        string[] hasil = Regex.Split( stringUji2, @",\s" );

        // menambahkan setiap dijit pada string keluaran
        foreach( var stringHasil in hasil )
            keluaran += "\"" + stringHasil + "\", ";

        // menghapus ", " di akhir string keluaran
        Console.WriteLine( keluaran.Substring( 0, keluaran.Length - 2 ) + "]" );
    } // akhir Main
} // akhir kelas SubstitusiRegex

String uji pertama: Kalimat ini diakhiri dengan 5 bintang *****
^ menggantikan *: Kalimat ini diakhiri dengan 5 bintang ^^^^^
"star" menggantikan "bintang": Kalimat ini diakhiri dengan 5 star ^^^^^
Setiap kata diganti dengan "kata": kata kata kata kata kata kata ^^^^^

String uji kedua: 1, 2, 3, 4, 5, 6, 7, 8
Mengganti tiga dijit pertama dengan "dijit": dijit, dijit, dijit, 4, 5, 6, 7, 8
string dipecah pada koma ["1", "2", "3", "4", "5", "6", "7", "8"]

Metode Replace dari kelas Regex mengganti teks pada sebuah string dengan teks baru ketika string asli cocok dengan ekspresi reguler. Anda menggunakan dua versi dari metode ini pada Gambar 3.21. Versi pertama (baris 18) merupakan sebuah metode static yang mengambil tiga parameter, yaitu string yang akan dimodifikasi, string yang memuat ekspresi reguler, dan string pengganti.

Versi kedua dari metode Replace (baris 34) menggunakan ekspresi reguler yang dilewatkan kepada konstruktor untuk ujiRegex1 (baris 12) untuk melakukan operasi penggantian. Baris 12 menginstansiasi ujiRegex1 dengan argumen @”\d”. Pemanggilan terhadap metode Replace pada baris 34 memerlukan tiga argumen, yaitu sebuah string yang akan dimodifikasi, sebuah string yang memuat teks pengganti, dan sebuah integer yang menetapkan jumlah penggantian yang akan dilakukan. Pada kasus ini, baris 34 mengganti tiga kemunculan pertama dari sebuah dijit (“\d”) pada stringUji2 dengan teks “dijit”.







Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)