Pembolehubah statik dalam pengaturcaraan memelihara keadaan merentasi panggilan fungsi dengan mengekalkan nilai mereka di antara panggilan sementara baki yang terkandung dalam fungsi; 1. Mereka membolehkan kegigihan tanpa pembolehubah global, seperti yang dilihat dalam kiraan int statik C yang mengekalkan nilainya; 2. Mereka menyokong inisialisasi terkawal, memastikan kod seperti persediaan sistem berjalan sekali sahaja; 3.

Apabila kita bercakap tentang memelihara keadaan merentasi panggilan fungsi dalam pengaturcaraan, salah satu alat yang paling berkesan dan sering digunakan adalah skop statik , terutamanya melalui penggunaan pembolehubah statik dalam bahasa seperti C, C, dan PHP. Konsep ini membolehkan fungsi untuk "ingat" nilai antara panggilan tanpa bergantung kepada pembolehubah global atau storan luaran.

Mari kita pecahkan bagaimana skop statik membolehkan pemeliharaan negara dan mengapa ia berkuasa.

Apakah pemboleh ubah statik?

Dalam banyak bahasa, apabila anda mengisytiharkan pembolehubah di dalam fungsi, ia biasanya tempatan -ia akan dibuat apabila fungsi berjalan dan dimusnahkan apabila fungsi keluar. Tetapi jika anda mengisytiharkannya sebagai static , seumur hidupnya meliputi pelbagai panggilan fungsi.

Sebagai contoh, dalam C:

 #include <stdio.h>

void counter () {
    statik int count = 0; // Inisialisasi hanya sekali
    kiraan;
    printf ("kiraan: %d \ n", hitung);
}

Sekarang, setiap kali anda memanggil counter() , nilai count berterusan:

 kaunter (); // output: kiraan: 1
kaunter (); // output: kiraan: 2
kaunter (); // output: kiraan: 3

Tidak seperti pemboleh ubah tempatan yang biasa, count hanya dimulakan sekali (pada panggilan pertama), dan mengekalkan nilainya antara panggilan.

Mengapa Skop Statik penting untuk Pemeliharaan Negeri

Pembolehubah statik hidup di rantau memori khas (bukan timbunan), dan skop mereka masih terhad kepada fungsi -yang mereka tidak dapat diakses secara global, yang membantu merangkum keadaan.

Ini memberi anda tiga faedah utama:

• Enkapsulasi : Pembolehubah disembunyikan dari kod luaran, mengurangkan kesan sampingan dan pengubahsuaian yang tidak disengajakan.
• Kegigihan : Nilai bertahan selepas fungsi kembali.
• Inisialisasi terkawal : Inisialisasi berlaku hanya sekali, walaupun fungsi itu dipanggil berkali -kali.

Bandingkan ini dengan menggunakan pemboleh ubah global:

 int global_count = 0; // terdedah kepada keseluruhan fail atau program

void bad_counter () {
    global_count;
    printf ("kiraan global: %d \ n", global_count);
}

Sekarang sebarang fungsi boleh mengubah suai global_count , membuat debugging lebih keras dan kod kurang modular.

Kes penggunaan praktikal

Pembolehubah statik sesuai untuk senario di mana anda memerlukan keadaan dalaman yang tidak boleh didedahkan:

1. Fungsi panggilan mengira atau caching

 int get_instance_id () {
    statik int id = 0;
    ID kembali;
}

Setiap panggilan mengembalikan ID yang unik dan bertambah baik untuk pengenalan atau pengenalan objek.

2. Inisialisasi satu kali

 void initialize_system () {
    Int statik Inisialisasi = 0;
    jika (! Inisialisasi) {
        // Lakukan persediaan (misalnya, buka fail, memperuntukkan memori)
        printf ("Inisialisasi ... \ n");
        dimulakan = 1;
    }
}

Memastikan permulaan berjalan tepat sekali, tidak kira berapa kali fungsi dipanggil.

3. Mengekalkan konteks antara panggilan

Fikirkan tokenizer atau parser yang memproses input dalam ketulan. Penunjuk atau indeks statik boleh menjejaki kedudukan merentasi panggilan tanpa melewati keadaan secara eksplisit.

Kaveat dan batasan

Walaupun kuat, pembolehubah statik datang dengan perdagangan:

• ? Tidak selamat thread : Dalam program multithreaded, pelbagai benang memanggil fungsi yang sama berkongsi pembolehubah statik yang sama, yang membawa kepada keadaan perlumbaan.
• ? Lebih sukar untuk diuji : Fungsi dengan keadaan statik tidak murni -mereka berkelakuan berbeza pada setiap panggilan, menguji ujian unit.
• ? Kesan sampingan tersembunyi : Kelakuan fungsi bergantung kepada keadaan dalaman, menjadikannya kurang diramalkan daripada fungsi tanpa statur (tulen).

Juga, dalam bahasa berorientasikan objek seperti Java atau Python, anda biasanya menggunakan pembolehubah peringkat kelas atau penutupan dan bukan penduduk setempat statik untuk memelihara keadaan.

Alternatif dalam bahasa lain

Walaupun bahasa anda tidak menyokong pembolehubah tempatan statik, corak serupa wujud:

• Penutup (JavaScript, Python) :

  fungsi createCounter () {
    biarkan Count = 0;
    fungsi kembali () {
        kiraan;
        Console.log ("Count:", Count);
    };
  }

const counter = createCounter (); kaunter (); // Count: 1 kaunter (); // Count: 2

- ** Ahli Kelas (Java, C#) **:
`` Java
kaunter kelas {
    kiraan int swasta = 0;
    kenaikan void awam () {
        System.out.println ("Count:" Count);
    }
}

Ini menawarkan kawalan yang lebih baik dan lebih boleh diuji daripada pembolehubah statik mentah.

Pemikiran terakhir

Skop statik, melalui pembolehubah statik, adalah cara yang mudah tetapi berkuasa untuk memelihara keadaan merentasi panggilan fungsi -terutamanya dalam bahasa prosedur. Ia membantu mengelakkan global sambil mengekalkan ingatan tingkah laku yang lalu.

Tetapi gunakan dengan bijak: lebih suka untuk logik dalaman, serba lengkap (seperti kaunter atau satu kali init), dan elakkan apabila keselamatan benang, kesesuaian, atau kejelasan adalah keutamaan.

Pada asasnya: ia adalah alat yang tajam -hebat apabila digunakan betul, berbahaya jika digunakan terlalu banyak.

Atas ialah kandungan terperinci Memelihara keadaan merentasi fungsi panggilan: Kekuatan skop statik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!