perltie - ক্লাউডে অনলাইন

কার্যক্রম:

NAME এর

perltie - কিভাবে একটি সাধারণ ভেরিয়েবলে একটি অবজেক্ট ক্লাস লুকানো যায়

সাইনোপিসিস

টাই variable, CLASSNAME, LIST

$object = বাঁধা ভেরিয়েবল

পরিবর্তনশীল মুক্ত করুন

বর্ণনাঃ

পার্লের 5.0 প্রকাশের আগে, একজন প্রোগ্রামার ব্যবহার করতে পারে dbmopen() একটি অন-ডিস্ক সংযোগ করতে
স্ট্যান্ডার্ড ইউনিক্সে ডাটাবেস ডিবিএম(3x) তাদের প্রোগ্রামে একটি %HASH-এ জাদুকরী বিন্যাস করুন।
যাইহোক, তাদের পার্ল হয় একটি নির্দিষ্ট ডিবিএম লাইব্রেরি বা অন্য দিয়ে তৈরি করা হয়েছিল, কিন্তু নয়
উভয়ই, এবং আপনি এই প্রক্রিয়াটিকে অন্যান্য প্যাকেজ বা ভেরিয়েবলের প্রকারগুলিতে প্রসারিত করতে পারবেন না।

এখন তুমি পার.

সার্জারির টাই() ফাংশন একটি ভেরিয়েবলকে একটি ক্লাসে (প্যাকেজ) আবদ্ধ করে যা প্রদান করবে
যে পরিবর্তনশীল জন্য অ্যাক্সেস পদ্ধতি জন্য বাস্তবায়ন. একবার এই জাদুটি সঞ্চালিত হলে,
একটি বাঁধা ভেরিয়েবল অ্যাক্সেস করা স্বয়ংক্রিয়ভাবে সঠিক ক্লাসে পদ্ধতি কলগুলিকে ট্রিগার করে। দ্য
ক্লাসের জটিলতা লুকিয়ে আছে ম্যাজিক মেথড কলের আড়ালে। পদ্ধতির নাম সব আছে
CAPS, যা একটি প্রচলন যা পার্ল ইঙ্গিত করতে ব্যবহার করে যে সেগুলিকে অন্তর্নিহিতভাবে বলা হয়
বরং স্পষ্টভাবে -- ঠিক মত শুরু () এবং শেষ() ফাংশন।

মধ্যে টাই() call, "variable" হল মন্ত্রমুগ্ধ করা ভেরিয়েবলের নাম। "CLASSNAME" হল৷
সঠিক ধরনের বস্তু বাস্তবায়নকারী একটি শ্রেণীর নাম। কোন অতিরিক্ত আর্গুমেন্ট ইন
"লিস্ট" সেই ক্লাসের জন্য উপযুক্ত কনস্ট্রাক্টর পদ্ধতিতে পাস করা হয় - মানে
TIESCALAR(), TIEARRAY(), TIEHASH(), বা টাইহ্যান্ডেল(). (সাধারণত এগুলি এমন যুক্তি
হিসাবে পাস করা যেতে পারে dbminit() C এর ফাংশন) "নতুন" দ্বারা ফিরে আসা বস্তুটি
পদ্ধতি এছাড়াও দ্বারা ফিরে আসে টাই() ফাংশন, যা আপনি চাইলে দরকারী হবে
"CLASSNAME"-এ অন্যান্য পদ্ধতি অ্যাক্সেস করুন। (আপনাকে আসলে একটি রেফারেন্স ফেরত দিতে হবে না
সঠিক "টাইপ" (যেমন, HASH বা "CLASSNAME") যতক্ষণ না এটি একটি সঠিকভাবে আশীর্বাদপূর্ণ বস্তু।) আপনি
এছাড়াও ব্যবহার করে অন্তর্নিহিত বস্তুর একটি রেফারেন্স পুনরুদ্ধার করতে পারেন বাঁধা() ফাংশন.

অসদৃশ dbmopen(), দ্য টাই() ফাংশন আপনার জন্য একটি মডিউল "ব্যবহার" বা "প্রয়োজন" করবে না - আপনি
এটা স্পষ্টভাবে নিজেকে করতে হবে.

tying স্কেলার
একটি বাঁধা স্কেলার বাস্তবায়নকারী একটি শ্রেণিকে নিম্নলিখিত পদ্ধতিগুলি সংজ্ঞায়িত করা উচিত: TIESCALAR, FETCH,
স্টোর করুন, এবং সম্ভবত UNTI এবং/অথবা ধ্বংস করুন।

আসুন পালাক্রমে প্রতিটি তাকান, একটি উদাহরণ হিসাবে ব্যবহার করে স্কেলারগুলির জন্য একটি টাই ক্লাস যা অনুমতি দেয়
ব্যবহারকারীর মত কিছু করতে:

$his_speed, 'Nice', getppid();
টাই $my_speed, 'Nice', $$;

এবং এখন যখনই এই ভেরিয়েবলগুলির যেকোন একটি অ্যাক্সেস করা হয়, তার বর্তমান সিস্টেম অগ্রাধিকার হয়
উদ্ধার এবং ফিরে. যদি সেই ভেরিয়েবলগুলি সেট করা হয়, তাহলে প্রক্রিয়াটির অগ্রাধিকার
পরিবর্তিত!

আমরা Jarkko Hietaniemi ব্যবহার করব[ইমেল সুরক্ষিত]> এর BSD::রিসোর্স ক্লাস (অন্তর্ভুক্ত নয়) অ্যাক্সেস করতে
আপনার সিস্টেম থেকে PRIO_PROCESS, PRIO_MIN, এবং PRIO_MAX ধ্রুবক, সেইসাথে
অগ্রাধিকার পান() এবং অগ্রাধিকার নির্ধারন কর() সিস্টেম কল। এখানে ক্লাসের প্রস্তাবনা।

প্যাকেজ চমৎকার;
কার্প ব্যবহার করুন;
BSD::সম্পদ ব্যবহার করুন;
কঠোর ব্যবহার করুন;
$Nice::DEBUG = 0 যদি না সংজ্ঞায়িত করা হয় $Nice::DEBUG;

TIESCALAR ক্লাসের নাম, তালিকা
এটি ক্লাসের জন্য কনস্ট্রাক্টর। তার মানে এটি একটি আশীর্বাদ ফিরে আশা করা হয়
একটি নতুন স্কেলারের রেফারেন্স (সম্ভবত বেনামী) যা এটি তৈরি করছে। উদাহরণ স্বরূপ:

সাব টাইস্ক্যালার {
আমার $ক্লাস = শিফট;
আমার $পিড = শিফট || $$; #0 মানে আমি

যদি ($pid!~ /^\d+$/) {
carp "Nice::Tie::Scalar পেয়েছে অ-সংখ্যাসূচক pid $pid" যদি $^W;
undef ফেরত;
}

যদি না (0, $pid হত্যা) { # EPERM বা ERSCH, কোন সন্দেহ নেই
carp "নাইস::টাই::স্ক্যালার খারাপ পিড পেয়েছে $pid: $!" যদি $^W;
undef ফেরত;
}

আশীর্বাদ ফেরত \$pid, $class;
}

এই টাই ক্লাস একটি ব্যতিক্রম উত্থাপন করার পরিবর্তে একটি ত্রুটি ফেরত দেওয়া বেছে নিয়েছে যদি তার
কনস্ট্রাক্টর ব্যর্থ হওয়া উচিত। যদিও এইভাবে dbmopen() কাজ, অন্যান্য ক্লাস ভাল হতে পারে
এত ক্ষমাশীল হতে চাই না। এটি নির্গত হবে কিনা তা দেখতে গ্লোবাল ভেরিয়েবল $^W পরীক্ষা করে
যাইহোক একটু আওয়াজ।

এই আনুন
প্রতিবার বাঁধা ভেরিয়েবল অ্যাক্সেস করা হলে এই পদ্ধতিটি ট্রিগার করা হবে (পড়ুন)। এটা
এর স্ব-রেফারেন্সের বাইরে কোন যুক্তি গ্রহণ করে না, যা প্রতিনিধিত্বকারী বস্তু
স্কেলার আমরা মোকাবেলা করছি. কারণ এই ক্ষেত্রে আমরা শুধুমাত্র একটি SCALAR রেফ ব্যবহার করছি
বাঁধা স্কেলার বস্তু, একটি সাধারণ $$self পদ্ধতিটিকে সঞ্চিত প্রকৃত মান পেতে দেয়
সেখানে নীচের আমাদের উদাহরণে, সেই আসল মান হল সেই প্রসেস আইডি যার সাথে আমরা বেঁধেছি
আমাদের পরিবর্তনশীল।

সাব FETCH {
আমার $self = শিফট;
"ভুল টাইপ" স্বীকার করুন যদি না রেফ $self;
croak "ব্যবহার ত্রুটি" যদি @_;
আমার $সুন্দরতা;
স্থানীয়($!) = 0;
$nicety = প্রাপ্ত অগ্রাধিকার (PRIO_PROCESS, $$self);
যদি ($!) { croak "getpriority ব্যর্থ হয়েছে: $!" }
ফেরত $nity;
}

রেনিস ব্যর্থ হলে এইবার আমরা উড়িয়ে দেবার (একটি ব্যতিক্রম উত্থাপন করার) সিদ্ধান্ত নিয়েছি -- আছে
অন্যথায় একটি ত্রুটি ফেরত দেওয়ার জন্য আমাদের জন্য কোন জায়গা নেই, এবং এটি সম্ভবত সঠিক জিনিস।

এই, মান সংরক্ষণ করুন
প্রতিবার বাঁধা ভেরিয়েবল সেট করা (অ্যাসাইন করা) এই পদ্ধতিটি ট্রিগার করা হবে। তার পরেও
এর স্ব রেফারেন্স, এটি একটি (এবং শুধুমাত্র একটি) যুক্তি আশা করে: নতুন মান
ব্যবহারকারী বরাদ্দ করার চেষ্টা করছে। STORE থেকে একটি মান ফেরত নিয়ে চিন্তা করবেন না; শব্দার্থিক
অ্যাসাইনমেন্টের নির্ধারিত মান ফেরত দেওয়া FETCH এর সাথে প্রয়োগ করা হয়।

সাব স্টোর {
আমার $self = শিফট;
"ভুল টাইপ" স্বীকার করুন যদি না রেফ $self;
আমার $new_nicety = শিফট;
croak "ব্যবহার ত্রুটি" যদি @_;

যদি ($new_nicety < PRIO_MIN) {
কার্প স্প্রিন্টফ
"সতর্কতা: অগ্রাধিকার %d ন্যূনতম সিস্টেম অগ্রাধিকার %d থেকে কম",
$new_nicety, PRIO_MIN যদি $^W;
$new_nicety = PRIO_MIN;
}

যদি ($new_nicety > PRIO_MAX) {
কার্প স্প্রিন্টফ
"সতর্কতা: সর্বোচ্চ সিস্টেম অগ্রাধিকার %d এর চেয়ে অগ্রাধিকার %d বেশি",
$new_nicety, PRIO_MAX যদি $^W;
$new_nicety = PRIO_MAX;
}

যদি না (সংজ্ঞায়িত সেট অগ্রাধিকার(PRIO_PROCESS, $$self, $new_nicety)) {
স্বীকার করুন "সেট অগ্রাধিকার ব্যর্থ হয়েছে: $!";
}
}

এটি মুক্ত করুন
এই পদ্ধতিটি ট্রিগার করা হবে যখন "আনটি" ঘটে। এই ক্লাস হলে কাজে লাগতে পারে
জানতে হবে কখন আর কোন কল করা হবে না। (অবশ্যই ধ্বংস ছাড়া।) দেখুন "The
আরো বিস্তারিত জানার জন্য নীচে "আনটি" গোটচা"।

এই ধ্বংস
যখন বাঁধা ভেরিয়েবলটিকে ধ্বংস করতে হবে তখন এই পদ্ধতিটি ট্রিগার করা হবে। সঙ্গে
অন্যান্য অবজেক্ট ক্লাসে, এই জাতীয় পদ্ধতি খুব কমই প্রয়োজনীয়, কারণ পার্ল এটিকে ডিললোকেট করে
মরিবন্ড অবজেক্টের মেমরি আপনার জন্য স্বয়ংক্রিয়ভাবে--এটি C++ নয়, আপনি জানেন। আমরা একটি ব্যবহার করব
শুধুমাত্র ডিবাগিং উদ্দেশ্যে এখানে পদ্ধতি ধ্বংস করুন।

উপ ধ্বংস {
আমার $self = শিফট;
"ভুল টাইপ" স্বীকার করুন যদি না রেফ $self;
carp "[ Nice::DESTROY pid $$self ]" যদি $Nice::DEBUG;
}

যে এটি আছে সব সম্পর্কে. প্রকৃতপক্ষে, এটি যা আছে তার চেয়ে বেশি, কারণ
সম্পূর্ণতা, দৃঢ়তা এবং সাধারণের জন্য আমরা এখানে কিছু চমৎকার জিনিস করেছি
নান্দনিকতা সহজ TIESCALAR ক্লাস অবশ্যই সম্ভব।

tying অ্যারেগুলির
একটি বাঁধা সাধারণ অ্যারে বাস্তবায়নকারী একটি শ্রেণিকে নিম্নলিখিত পদ্ধতিগুলি সংজ্ঞায়িত করা উচিত: TIEARRAY,
FETCH, STORE, FETCHSIZE, STORESIZE, CLEAR এবং সম্ভবত unNTIE এবং/অথবা ধ্বংস করুন।

FETCHSIZE এবং STORESIZE $#array এবং সমতুল্য "scalar(@array)" প্রদান করতে ব্যবহৃত হয়
অ্যাক্সেস।

POP, PUSH, SHIFT, UNSHIFT, SPLICE, DELETE, এবং EXISTS এই পদ্ধতিগুলি প্রয়োজন হয় যদি পার্ল
সংশ্লিষ্ট (কিন্তু ছোট হাতের) নামের অপারেটরকে বাঁধা অ্যারেতে কাজ করতে হয়। দ্য
টাই::অ্যারে এর মধ্যে প্রথম পাঁচটি পরিপ্রেক্ষিতে বাস্তবায়ন করতে ক্লাস একটি বেস ক্লাস হিসাবে ব্যবহার করা যেতে পারে
উপরের মৌলিক পদ্ধতিগুলির মধ্যে। DELETE এবং EXISTS-এর ডিফল্ট বাস্তবায়ন
টাই::অ্যারে সহজভাবে "ক্রোক"।

উপরন্তু EXTEND বলা হবে যখন পার্ল একটি বাস্তবে প্রাক-বর্ধিত বরাদ্দ থাকবে
অ্যারে।

এই আলোচনার জন্য, আমরা একটি অ্যারে বাস্তবায়ন করব যার উপাদানগুলি তৈরির সময় একটি নির্দিষ্ট আকার।
আপনি যদি নির্দিষ্ট আকারের চেয়ে বড় একটি উপাদান তৈরি করার চেষ্টা করেন তবে আপনি একটি ব্যতিক্রম নেবেন। জন্য
উদাহরণস্বরূপ:

FixedElem_Array ব্যবহার করুন;
tie @array, 'FixedElem_Array', 3;
$array[0] = 'বিড়াল'; # ঠিক আছে.
$array[1] = 'কুকুর'; # ব্যতিক্রম, দৈর্ঘ্য('কুকুর') > 3।

ক্লাসের প্রস্তাবনা কোড নিম্নরূপ:

প্যাকেজ FixedElem_Array;
কার্প ব্যবহার করুন;
কঠোর ব্যবহার করুন;

TIEARRAY ক্লাসের নাম, তালিকা
এটি ক্লাসের জন্য কনস্ট্রাক্টর। তার মানে এটি একটি আশীর্বাদ ফিরে আশা করা হয়
রেফারেন্স যার মাধ্যমে নতুন অ্যারে (সম্ভবত একটি বেনামী ARRAY রেফ) হবে
অ্যাক্সেস করা হয়েছে

আমাদের উদাহরণে, শুধু আপনাকে দেখানোর জন্য যে আপনি তা করেন না সত্যিই একটি ARRAY ফেরত দিতে হবে
রেফারেন্স, আমরা আমাদের বস্তুর প্রতিনিধিত্ব করার জন্য একটি HASH রেফারেন্স বেছে নেব। একটি হ্যাশ কাজ করে
পাশাপাশি একটি জেনেরিক রেকর্ডের ধরন: "{ELEMSIZE}" ক্ষেত্র সর্বাধিক উপাদান সংরক্ষণ করবে
আকার অনুমোদিত, এবং "{ARRAY}" ক্ষেত্রটি সত্যিকারের ARRAY রেফ ধরে রাখবে৷ যদি কেউ
ক্লাসের বাইরে ফিরে আসা বস্তুটিকে ডিরেফারেন্স করার চেষ্টা করে (সন্দেহ নেই এটি একটি
ARRAY রেফ), তারা উড়িয়ে দেবে। এই শুধু আপনি একটি সম্মান করা উচিত যে আপনি দেখাতে যায়
বস্তুর গোপনীয়তা।

সাব টায়াররে {
আমার $ক্লাস = শিফট;
আমার $elemsize = শিফট;
যদি ( @_ || $elemsize =~ /\D/ ) {
ক্রাক "ব্যবহার: টাই অ্যারে, '"। __প্যাকেজ__ "', elem_size";
}
আশীর্বাদ ফেরত {
ELEMSIZE => $elemsize,
অ্যারে => [],
}, $class;
}

এই, সূচক আনুন
এই পদ্ধতিটি প্রতিবার ট্রিগার করা হবে যখন একটি পৃথক উপাদান বাঁধা অ্যারে হবে
অ্যাক্সেস করা (পড়া)। এটি তার স্ব রেফারেন্সের বাইরে একটি যুক্তি নেয়: সূচক যার
মান আমরা আনার চেষ্টা করছি.

সাব FETCH {
আমার $self = শিফট;
আমার $index = শিফট;
ফেরত $self->{ARRAY}->[$index];
}

যদি একটি অ্যারে থেকে পড়ার জন্য একটি নেতিবাচক অ্যারে সূচক ব্যবহার করা হয়, সূচকটি অনুবাদ করা হবে
FETCH-এ পাস করার আগে FETCHSIZE কল করে অভ্যন্তরীণভাবে একটি ইতিবাচকের প্রতি। আপনি
$NEGATIVE_INDICES ভেরিয়েবলে একটি সত্য মান নির্ধারণ করে এই বৈশিষ্ট্যটি নিষ্ক্রিয় করতে পারে
বাঁধা অ্যারে ক্লাসে।

আপনি হয়তো লক্ষ্য করেছেন, FETCH পদ্ধতির নাম (et al.) সবার জন্য একই
অ্যাক্সেস করে, যদিও কনস্ট্রাক্টর নামের মধ্যে পার্থক্য রয়েছে (TIESCALAR বনাম TIEARRAY)। যখন
তাত্ত্বিকভাবে আপনি একই ক্লাস সার্ভিসিং করতে পারেন বিভিন্ন বাঁধা ধরনের, অনুশীলনে এটি
কষ্টকর হয়ে ওঠে, এবং প্রতি ক্লাসে একটি টাই টাইপ এ রাখা সবচেয়ে সহজ।

এই, সূচক, মান সংরক্ষণ করুন
প্রতিবার বাঁধা অ্যারের একটি উপাদান সেট করা হলে এই পদ্ধতিটি ট্রিগার করা হবে
(লিখিত)। এটির স্ব-রেফারেন্সের বাইরে দুটি আর্গুমেন্ট লাগে: আমরা যে সূচকে আছি
কিছু সঞ্চয় করার চেষ্টা করছি এবং মান আমরা সেখানে রাখার চেষ্টা করছি।

আমাদের উদাহরণে, "undef" হল সত্যিই "$self->{ELEMSIZE}" স্পেস সংখ্যা তাই আমাদের কাছে একটি আছে
এখানে আরও কিছু কাজ করতে হবে:

সাব স্টোর {
আমার $self = শিফট;
my($index, $value) = @_;
যদি (দৈর্ঘ্য $value > $self->{ELEMSIZE} ) {
croak "$value-এর দৈর্ঘ্য $self->{ELEMSIZE}" থেকে বেশি;
}
# শুন্যস্তান পূরণ
$self->EXTEND( $index ) যদি $index > $self->FETCHSIZE();
# অধিকার ছোট উপাদানের জন্য উপাদানের আকার রাখার জন্য ন্যায্যতা
$self->{ARRAY}->[$index] = sprintf "%$self->{ELEMSIZE}s", $value;
}

নেতিবাচক সূচকগুলিকে FETCH এর মতোই বিবেচনা করা হয়৷

এটি আনুন
অবজেক্টের সাথে যুক্ত বাঁধা অ্যারেতে আইটেমের মোট সংখ্যা প্রদান করে এই.
("স্ক্যালার(@অ্যারে)" এর সমতুল্য)। উদাহরণ স্বরূপ:

সাব ফেচসাইজ {
আমার $self = শিফট;
রিটার্ন স্কেলার @{$self->{ARRAY}};
}

এটি সংরক্ষণ করুন, গণনা করুন
অবজেক্টের সাথে যুক্ত বাঁধা অ্যারেতে আইটেমের মোট সংখ্যা সেট করে এই হতে
গণনা. যদি এটি অ্যারেটিকে বড় করে তোলে তবে "undef" এর ক্লাসের ম্যাপিং হওয়া উচিত
নতুন পদে ফিরে এসেছেন। যদি অ্যারে ছোট হয়ে যায় তাহলে গণনার বাইরে এন্ট্রি
মুছে ফেলা উচিত।

আমাদের উদাহরণে, 'undef' সত্যিই একটি উপাদান যার মধ্যে "$self->{ELEMSIZE}" সংখ্যা রয়েছে
স্পেস লক্ষ্য করুন:

সাব স্টোরাইজ {
আমার $self = শিফট;
আমার $count = শিফট;
যদি ( $count > $self->FETCHSIZE() ) {
foreach ( $count - $self->FETCHSIZE() .. $count ) {
$self->STORE( $_, '');
}
} elsif ( $count < $self->FETCHSIZE() ) {
foreach ( 0 .. $self->FETCHSIZE() - $count - 2 ) {
$self->POP();
}
}
}

এটি প্রসারিত করুন, গণনা করুন
তথ্যপূর্ণ কল যে অ্যারে আছে বাড়তে পারে গণনা এন্ট্রি ব্যবহার করা যেতে পারে
বরাদ্দ অপ্টিমাইজ করুন। এই পদ্ধতিতে কিছুই করার দরকার নেই।

আমাদের উদাহরণে, আমরা নিশ্চিত করতে চাই যে কোন ফাঁকা ("undef") এন্ট্রি নেই, তাই "EXTEND"
প্রয়োজনীয় উপাদানগুলি পূরণ করতে "STORESIZE" ব্যবহার করবে:

সাব এক্সটেনড {
আমার $self = শিফট;
আমার $count = শিফট;
$self->STORESIZE( $count);
}

এই, কী বিদ্যমান
সূচীতে উপাদানটি যাচাই করুন চাবি বাঁধা অ্যারের মধ্যে বিদ্যমান এই.

আমাদের উদাহরণে, আমরা নির্ধারণ করব যে একটি উপাদান যদি "$self->{ELEMSIZE}" নিয়ে গঠিত হয়
শুধুমাত্র স্পেস, এটি বিদ্যমান নেই:

উপ বিদ্যমান {
আমার $self = শিফট;
আমার $index = শিফট;
যদি 0 ফেরত দাও! সংজ্ঞায়িত $self->{ARRAY}->[$index] ||
$self->{ARRAY}->[$index] eq ' ' x $self->{ELEMSIZE};
ফিরে 1;
}

এটি মুছুন, কী
সূচীতে উপাদানটি মুছুন চাবি বাঁধা অ্যারে থেকে এই.

আমাদের উদাহরণে, একটি মুছে ফেলা আইটেম হল "$self->{ELEMSIZE}" স্পেস:

সাব DELETE {
আমার $self = শিফট;
আমার $index = শিফট;
ফেরত $self->STORE( $index, '');
}

এটি পরিষ্কার করুন
অবজেক্টের সাথে যুক্ত বাঁধা অ্যারে থেকে সমস্ত মান সাফ করুন (সরান, মুছুন, ...)
এই। উদাহরণ স্বরূপ:

সাব ক্লিয়ার {
আমার $self = শিফট;
ফেরত $self->{ARRAY} = [];
}

এই ধাক্কা, তালিকা
উপাদান যোগ করুন তালিকা অ্যারেতে উদাহরণ স্বরূপ:

সাব ধাক্কা {
আমার $self = শিফট;
আমার @তালিকা = @_;
আমার $last = $self->FETCHSIZE();
$self->STORE( $last + $_, $list[$_] ) foreach 0 .. $#list;
ফেরত $self->FETCHSIZE();
}

এই POP
অ্যারের শেষ উপাদানটি সরান এবং এটি ফেরত দিন। উদাহরণ স্বরূপ:

সাব POP {
আমার $self = শিফট;
রিটার্ন পপ @{$self->{ARRAY}};
}

এই পরিবর্তন
অ্যারের প্রথম উপাদানটি সরান (অন্যান্য উপাদানগুলিকে নিচে নামিয়ে) এবং এটি ফেরত দিন।
উদাহরণ স্বরূপ:

সাব শিফট {
আমার $self = শিফট;
রিটার্ন শিফট @{$self->{ARRAY}};
}

এই, তালিকা আনশিফট
অ্যারের শুরুতে LIST উপাদানগুলি সন্নিবেশ করুন, বিদ্যমান উপাদানগুলিকে পর্যন্ত সরান৷
কামরা তৈরি. উদাহরণ স্বরূপ:

সাব আনশিফট {
আমার $self = শিফট;
আমার @তালিকা = @_;
আমার $size = স্কেলার (@list);
# আমাদের তালিকার জন্য জায়গা তৈরি করুন
@{$self->{ARRAY}}[ $size .. $#{$self->{ARRAY}} + $size ]
= @{$self->{ARRAY}};
$self->STORE( $_, $list[$_] ) foreach 0 .. $#list;
}

এই, অফসেট, দৈর্ঘ্য, তালিকা স্প্লাইস করুন
অ্যারেতে "স্প্লিস" এর সমতুল্য সম্পাদন করুন।

অফসেট ঐচ্ছিক এবং ডিফল্ট শূন্য, ঋণাত্মক মান শেষ থেকে ফিরে গণনা করা হয়
অ্যারে।

লম্বা ঐচ্ছিক এবং বাকি অ্যারের ডিফল্ট।

তালিকা খালি হতে পারে।

আসলটির একটি তালিকা প্রদান করে লম্বা এ উপাদান অফসেট.

আমাদের উদাহরণে, আমরা একটি ছোট শর্টকাট ব্যবহার করব যদি একটি থাকে তালিকা:

সাব স্প্লিস {
আমার $self = শিফট;
আমার $অফসেট = শিফট || 0;
আমার $দৈর্ঘ্য = শিফট || $self->FETCHSIZE() - $offset;
আমার @তালিকা = ();
যদি ( @_ ) {
টাই @list, __PACKAGE__, $self->{ELEMSIZE};
@তালিকা = @_;
}
রিটার্ন স্প্লাইস @{$self->{ARRAY}}, $offset, $length, @list;
}

এটি মুক্ত করুন
"আনটি" ঘটলে ডাকা হবে। (নীচে "দ্য "আনটি" গোটচা" দেখুন।)

এই ধ্বংস
যখন বাঁধা ভেরিয়েবলটিকে ধ্বংস করতে হবে তখন এই পদ্ধতিটি ট্রিগার করা হবে। সঙ্গে
স্কেলার টাই ক্লাস, এটির নিজস্ব ভাষাতে এটি প্রায় কখনই প্রয়োজন হয় না
আবর্জনা সংগ্রহ, তাই এই সময় আমরা এটি ছেড়ে দেব।

tying হ্যাশ
হ্যাশ ছিল প্রথম পার্ল ডেটা টাইপ যা বাঁধা ছিল (দেখুন dbmopen()) একটি শ্রেণী বাস্তবায়নকারী a
tied হ্যাশ নিম্নলিখিত পদ্ধতি সংজ্ঞায়িত করা উচিত: TIEHASH হল কনস্ট্রাক্টর। FETCH এবং
STORE অ্যাক্সেস কী এবং মান জোড়া। EXISTS রিপোর্ট করে যে একটি কী উপস্থিত আছে কিনা৷
হ্যাশ, এবং DELETE একটি মুছে দেয়। CLEAR সমস্ত কী এবং মান মুছে হ্যাশ খালি করে
জোড়া FIRSTKEY এবং NEXTKEY প্রয়োগ করুন কী() এবং প্রতিটি() সব উপর পুনরাবৃত্তি ফাংশন
চাবিসমূহ. স্কলার প্রেক্ষাপটে বাঁধা হ্যাশ মূল্যায়ন করা হলে SCALAR ট্রিগার হয়। UNTIE হল
যখন "আনটি" হয় তখন বলা হয়, এবং যখন বাঁধা ভেরিয়েবলটি গারবেজ হয় তখন তাকে ডেসট্রয় বলা হয়
সংগৃহীত

যদি এটি অনেকের মতো মনে হয়, তাহলে নির্দ্বিধায় শুধুমাত্র স্ট্যান্ডার্ড টাই::StdHash থেকে উত্তরাধিকারী হন
আপনার বেশিরভাগ পদ্ধতির জন্য মডিউল, শুধুমাত্র আকর্ষণীয়গুলিকে পুনরায় সংজ্ঞায়িত করে। টাই::এর জন্য হ্যাশ দেখুন
বিবরণ।

মনে রাখবেন যে পার্ল হ্যাশে বিদ্যমান নেই এমন একটি কী এবং কী-এর মধ্যে পার্থক্য করে
হ্যাশে বিদ্যমান কিন্তু "undef" এর অনুরূপ মান রয়েছে। দুটি সম্ভাবনা
"exists()" এবং "defined()" ফাংশন দিয়ে পরীক্ষা করা যেতে পারে।

এখানে একটি কিছুটা আকর্ষণীয় বাঁধা হ্যাশ ক্লাসের একটি উদাহরণ: এটি আপনাকে একটি হ্যাশ দেয়
একটি নির্দিষ্ট ব্যবহারকারীর ডট ফাইল প্রতিনিধিত্ব. আপনি নামের সাথে হ্যাশে সূচক করুন
ফাইল (বিন্দু বিয়োগ) এবং আপনি সেই ডট ফাইলের বিষয়বস্তু ফিরে পাবেন। উদাহরণ স্বরূপ:

ডটফাইলস ব্যবহার করুন;
টাই %dot, 'DotFiles';
যদি ( $dot{profile} =~ /MANPATH/ ||
$dot{login} =~ /MANPATH/ ||
$dot{cshrc} =~ /MANPATH/ )
{
প্রিন্ট করুন "আপনি আপনার MANPATH সেট করছেন বলে মনে হচ্ছে\n";
}

অথবা এখানে আমাদের বাঁধা ক্লাস ব্যবহার করার আরেকটি নমুনা আছে:

% him, 'DotFiles', 'deemon' টাই;
foreach $f ( কী % তাকে ) {
printf "ডেমন ডট ফাইল %s আকার %d\n",
$f, দৈর্ঘ্য $hi{$f};
}

আমাদের বাঁধা হ্যাশ ডটফাইলস উদাহরণে, আমরা বেশ কয়েকটি ধারণকারী বস্তুর জন্য একটি নিয়মিত হ্যাশ ব্যবহার করি
গুরুত্বপূর্ণ ক্ষেত্র, যার মধ্যে শুধুমাত্র "{LIST}" ক্ষেত্রটিই হবে যা ব্যবহারকারী মনে করে
বাস্তব হ্যাশ

USER যার ডট ফাইল এই বস্তুর প্রতিনিধিত্ব করে

হোম যেখানে সেই ডট ফাইলগুলি থাকে৷

ক্লোবার
আমাদের সেই ডট ফাইলগুলি পরিবর্তন বা সরানোর চেষ্টা করা উচিত কিনা

ডট ফাইলের নাম এবং বিষয়বস্তু ম্যাপিংয়ের হ্যাশ তালিকাভুক্ত করুন

এখানে শুরু Dotfiles.pm:

প্যাকেজ ডটফাইলস;
কার্প ব্যবহার করুন;
সাব হোওয়াসি {(আহ্বানকারী(1))[3]। '()'}
আমার $DEBUG = 0;
সাব ডিবাগ { $DEBUG = @_? শিফট : 1}

আমাদের উদাহরণের জন্য, আমরা ট্রেসিংয়ের সময় সাহায্য করার জন্য ডিবাগিং তথ্য নির্গত করতে সক্ষম হতে চাই
উন্নয়ন প্রিন্ট আউটে সাহায্য করার জন্য আমরা অভ্যন্তরীণভাবে একটি সুবিধার ফাংশনও রাখি
সতর্কতা হুওয়াসি() ফাংশনের নাম ফেরত দেয় যা এটিকে কল করে।

এখানে ডটফাইলস বাঁধা হ্যাশের পদ্ধতি রয়েছে।

TIEHASH ক্লাসের নাম, তালিকা
এটি ক্লাসের জন্য কনস্ট্রাক্টর। তার মানে এটি একটি আশীর্বাদ ফিরে আশা করা হয়
রেফারেন্স যার মাধ্যমে নতুন বস্তু (সম্ভবত কিন্তু অগত্যা একটি বেনামী নয়
হ্যাশ) অ্যাক্সেস করা হবে।

এখানে কনস্ট্রাক্টর:

সাব টিহাশ {
আমার $self = শিফট;
আমার $user = শিফট || $>;
আমার $dotdir = শিফট || '';
croak "ব্যবহার: @{[&whowasi]} [USER [DOTDIR]]" যদি @_;
$user = getpwuid($user) যদি $user =~ /^\d+$/;
আমার $dir = (getpwnam($user))[7]
|| ক্রোক "@{[&whowasi]}: কোন ব্যবহারকারী নেই $user";
$dir .="/$dotdir" যদি $dotdir;

আমার $নোড = {
ব্যবহারকারী => $ব্যবহারকারী,
বাড়ি => $dir,
তালিকা => {},
ক্লোবার => 0,
};

opendir(DIR, $dir)
|| ক্রাক "@{[&whowasi]}: $dir: $!" খুলতে পারে না;
foreach $dot ( grep /^\./ && -f "$dir/$_", readdir(DIR)) {
$dot =~ s/^\.//;
$node->{LIST}{$dot} = undef;
}
বন্ধ ডিআইআর;
ফিরে আশীর্বাদ $node, $self;
}

এটি সম্ভবত উল্লেখ করার মতো যে আপনি যদি রিটার্ন মান ফাইল পরীক্ষা করতে যাচ্ছেন
একটি readdir এর, আপনি প্রশ্নে থাকা ডিরেক্টরিটি আরও ভালভাবে প্রিপেন্ড করবেন। অন্যথায়, কারণ আমরা
করেনি chdir() সেখানে, এটা ভুল ফাইল পরীক্ষা করা হবে.

এই, কী আনুন
এই পদ্ধতিটি ট্রিগার করা হবে যতবার বাঁধা হ্যাশের একটি উপাদান অ্যাক্সেস করা হবে
(পড়ুন)। এটি তার স্ব-রেফারেন্সের বাইরে একটি যুক্তি নেয়: কী যার মান আমরা
আনার চেষ্টা করছি।

আমাদের ডটফাইলস উদাহরণের জন্য এখানে আনা হল।

সাব FETCH {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
আমার $ডট = শিফট;
আমার $dir = $self->{HOME};
my $file = "$dir/.$dot";

যদি না ($self->{LIST}->{$dot} || -f $file বিদ্যমান থাকে) {
carp "@{[&whowasi]}: $Dot ফাইল নেই" যদি $DEBUG;
undef ফেরত;
}

যদি (সংজ্ঞায়িত $self->{LIST}->{$dot}) {
ফেরত $self->{LIST}->{$dot};
} অন্য {
ফেরত $self->{LIST}->{$dot} = `cat $dir/.$dot`;
}
}

এটিকে ইউনিক্স কল করার মাধ্যমে লেখা সহজ ছিল বিড়াল(1) কমান্ড, কিন্তু এটা সম্ভবত হবে
ম্যানুয়ালি ফাইলটি খুলতে আরও পোর্টেবল হতে হবে (এবং কিছুটা বেশি দক্ষ)। অবশ্যই,
কারণ ডট ফাইলগুলি একটি ইউনিক্সি ধারণা, আমরা এতে উদ্বিগ্ন নই।

এই, কী, মান সংরক্ষণ করুন
এই পদ্ধতিটি প্রতিবার ট্রিগার করা হবে যখন বাঁধা হ্যাশের একটি উপাদান সেট করা হবে (লিখিত)।
এটির স্ব-রেফারেন্সের বাইরে দুটি আর্গুমেন্ট লাগে: যে সূচকে আমরা চেষ্টা করছি
কিছু সঞ্চয় করুন, এবং মান আমরা সেখানে স্থাপন করার চেষ্টা করছি.

এখানে আমাদের ডটফাইলস উদাহরণে, আমরা সতর্ক থাকব যাতে তারা ওভাররাইট করার চেষ্টা না করে
ফাইল যদি না তারা কল করে ক্লোবার() মূল বস্তুর রেফারেন্সে পদ্ধতি
দ্বারা ফিরে টাই().

সাব স্টোর {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
আমার $ডট = শিফট;
আমার $মান = শিফট;
আমার $file = $self->{HOME}। "/.$ডট";
আমার $user = $self->{USER};

ক্রাক "@{[&whowasi]}: $file নট ক্লোবারেবল"
যদি না $self->{CLOBBER};

open(my $f, '>', $file) || croak "$file খুলতে পারে না: $!";
প্রিন্ট $f $value;
বন্ধ ($f);
}

যদি তারা কিছু ক্লোবার করতে চায়, তারা বলতে পারে:

$ob = টাই %ডেমন_ডটস, 'ডেমন';
$ob->ক্লোবার(২০১১);
$daemon_dots{signature} = "একটি সত্যিকারের ডেমন\n";

অন্তর্নিহিত বস্তুর একটি রেফারেন্সে হাত রাখার আরেকটি উপায় হল ব্যবহার করা বাঁধা()
ফাংশন, তাই তারা বিকল্পভাবে ব্যবহার করে ক্লোবার সেট করতে পারে:

টাই %ডেমন_ডটস, 'ডেমন';
বাঁধা (%ডেমন_ডট)->ক্লোবার(২০১১);

ক্লোবার পদ্ধতিটি সহজভাবে:

সাব ক্লোবার {
আমার $self = শিফট;
$self->{CLOBBER} = @_? স্থানান্তর: 1;
}

এটি মুছুন, কী
এই পদ্ধতিটি ট্রিগার হয় যখন আমরা হ্যাশ থেকে একটি উপাদান সরিয়ে ফেলি, সাধারণত ব্যবহার করে
দ্য মুছে ফেলা() ফাংশন আবার, তারা সত্যিই চায় কিনা তা পরীক্ষা করার জন্য আমরা সতর্ক থাকব
ক্লোবার ফাইল।

সাব DELETE {
carp &whowasi যদি $DEBUG;

আমার $self = শিফট;
আমার $ডট = শিফট;
আমার $file = $self->{HOME}। "/.$ডট";
ক্রোক "@{[&whowasi]}: ফাইল $file সরিয়ে দেবে না"
যদি না $self->{CLOBBER};
$self->{LIST}->{$dot} মুছুন;
আমার $success = unlink($file);
carp "@{[&whowasi]}: $file: $" আনলিঙ্ক করা যাবে না! $success না হলে;
$সফলতা;
}

DELETE দ্বারা প্রত্যাবর্তিত মানটি কলের রিটার্ন মান হয়ে যায়৷ মুছে ফেলা()। আপনি যদি
স্বাভাবিক আচরণ অনুকরণ করতে চান মুছে ফেলা(), আপনি যাই হোক না কেন FETCH ফেরত দেওয়া উচিত
এই চাবি জন্য ফিরে হবে. এই উদাহরণে, আমরা একটি রিটার্ন করার পরিবর্তে বেছে নিয়েছি
মান যা কলকারীকে বলে যে ফাইলটি সফলভাবে মুছে ফেলা হয়েছে কিনা।

এটি পরিষ্কার করুন
এই পদ্ধতিটি ট্রিগার করা হয় যখন পুরো হ্যাশটি সাফ করা হয়, সাধারণত অ্যাসাইন করার মাধ্যমে
এটা খালি তালিকা.

আমাদের উদাহরণে, এটি সমস্ত ব্যবহারকারীর ডট ফাইল মুছে ফেলবে! এটা যেমন একটি বিপজ্জনক
এটি ঘটতে তাদের 1 এর চেয়ে বেশি কিছুতে CLOBBER সেট করতে হবে।

সাব ক্লিয়ার {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
ক্রোক "@{[&whowasi]}: $self->{USER}" এর জন্য সমস্ত ডট ফাইল মুছে ফেলবে না
যদি না $self->{CLOBBER} > 1;
আমার $ডট;
foreach $dot ( কী %{$self->{LIST}}) {
$self->DELETE($dot);
}
}

এই, কী বিদ্যমান
ব্যবহারকারী যখন ব্যবহার করে তখন এই পদ্ধতিটি ট্রিগার হয় বিদ্যমান() একটি নির্দিষ্ট উপর ফাংশন
হ্যাশ আমাদের উদাহরণে, আমরা এটির জন্য "{LIST}" হ্যাশ উপাদানটি দেখব:

উপ বিদ্যমান {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
আমার $ডট = শিফট;
রিটার্ন বিদ্যমান $self->{LIST}->{$dot};
}

প্রথম এই
এই পদ্ধতিটি ট্রিগার করা হবে যখন ব্যবহারকারী হ্যাশের মাধ্যমে পুনরাবৃত্তি করতে যাচ্ছেন, যেমন
একটি মাধ্যমে হিসাবে হিসাবে কী(), মান (), বা প্রতিটি() কল

সাব ফার্স্টকি {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
আমার $a = কী %{$self->{LIST}}; # প্রতিটি() পুনরাবৃত্তিকারী পুনরায় সেট করুন
প্রতিটি %{$self->{LIST}}
}

FIRSTKEY কে সর্বদা স্কেলার প্রেক্ষাপটে বলা হয় এবং এটি কেবল প্রথম কীটি ফেরত দেয়।
মান (), এবং প্রতিটি() তালিকা প্রসঙ্গে, ফিরে আসা কীগুলির জন্য FETCH কল করবে।

পরবর্তী এই, শেষ কী
এই পদ্ধতি একটি সময় ট্রিগার পায় কী(), মান (), বা প্রতিটি() পুনরাবৃত্তি এটার আছে একটি
দ্বিতীয় যুক্তি যা শেষ কী যেটি অ্যাক্সেস করা হয়েছিল। এই যদি দরকারী
আপনি একাধিক সিকোয়েন্স থেকে ইটারেটরকে অর্ডার বা কল করার বিষয়ে যত্নশীল, বা
সত্যিই কোথাও একটি হ্যাশ জিনিস সংরক্ষণ না.

NEXTKEY কে সর্বদা স্কেলার প্রেক্ষাপটে বলা হয় এবং এটি কেবল পরবর্তী কীটি ফেরত দেবে।
মান (), এবং প্রতিটি() তালিকা প্রসঙ্গে, ফিরে আসা কীগুলির জন্য FETCH কল করবে।

আমাদের উদাহরণের জন্য, আমরা একটি বাস্তব হ্যাশ ব্যবহার করছি তাই আমরা শুধু সহজ জিনিস করব, কিন্তু আমরা করব
পরোক্ষভাবে LIST ক্ষেত্রের মধ্য দিয়ে যেতে হবে।

সাব নেক্সটকি {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
প্রতিটি %{ $self->{LIST} } ফেরত দিন
}

এই স্কলার
এটিকে বলা হয় যখন হ্যাশকে স্কেলার প্রসঙ্গে মূল্যায়ন করা হয়। অনুকরণ করার জন্য
untied হ্যাশ আচরণ, এই পদ্ধতি একটি মিথ্যা মান ফেরত দেওয়া উচিত যখন বাঁধা হ্যাশ
খালি বিবেচনা করা হয়। যদি এই পদ্ধতিটি বিদ্যমান না থাকে তবে পার্ল কিছু শিক্ষিত করে তুলবে
অনুমান করে এবং সত্য ফিরে আসে যখন হ্যাশ একটি পুনরাবৃত্তির ভিতরে থাকে। যদি এটি না হয়,
FIRSTKEY বলা হয়, এবং FIRSTKEY খালি ফেরত দিলে ফলাফলটি একটি মিথ্যা মান হবে
তালিকা, অন্যথায় সত্য।

যাইহোক, আপনি উচিত না অন্ধভাবে পার্লের উপর সর্বদা সঠিক জিনিসটি করার উপর নির্ভর করুন।
বিশেষ করে, আপনি বারবার হ্যাশ সাফ করার সময় পার্ল ভুলভাবে সত্যে ফিরে আসবে
এটি খালি না হওয়া পর্যন্ত DELETE কল করা হচ্ছে। তাই আপনাকে আপনার নিজস্ব SCALAR সরবরাহ করার পরামর্শ দেওয়া হচ্ছে
পদ্ধতি যখন আপনি একেবারে নিশ্চিত হতে চান যে আপনার হ্যাশ স্কেলারে সুন্দরভাবে আচরণ করে
প্রসঙ্গ

আমাদের উদাহরণে আমরা কেবল "স্কেলার" কল করতে পারি যার দ্বারা উল্লেখিত অন্তর্নিহিত হ্যাশের উপর
"$self->{LIST}":

সাব স্কেলার {
carp &whowasi যদি $DEBUG;
আমার $self = শিফট;
রিটার্ন স্কেলার %{ $self->{LIST} }
}

এটি মুক্ত করুন
এটি বলা হয় যখন "আনটি" ঘটে। নীচে "The "untie" Gotcha দেখুন।

এই ধ্বংস
এই পদ্ধতিটি ট্রিগার করা হয় যখন একটি বাঁধা হ্যাশ সুযোগের বাইরে চলে যায়। আপনি না
আপনি ডিবাগিং যোগ করার চেষ্টা করছেন বা পরিষ্কার করার জন্য সহায়ক অবস্থা না থাকলে এটি সত্যিই প্রয়োজন
আপ এখানে একটি খুব সহজ ফাংশন:

উপ ধ্বংস {
carp &whowasi যদি $DEBUG;
}

যেমন ফাংশন নোট করুন কী() এবং মান () বড় ব্যবহার করার সময় বিশাল তালিকা ফেরত দিতে পারে
অবজেক্ট, যেমন DBM ফাইল। আপনি ব্যবহার করতে পছন্দ করতে পারেন প্রতিটি() যেমন উপর পুনরাবৃত্তি ফাংশন.
উদাহরণ:

# প্রিন্ট আউট ইতিহাস ফাইল অফসেট
NDBM_File ব্যবহার করুন;
টাই (%HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
যখন (($key,$val) = প্রতিটি %HIST) {
প্রিন্ট $key, ' = ', আনপ্যাক('L',$val), "\n";
}
untie(%HIST);

tying ফাইল হ্যান্ডলগুলি
এটি এখন আংশিকভাবে বাস্তবায়িত হয়েছে।

একটি বাঁধা ফাইলহ্যান্ডেল বাস্তবায়নকারী একটি ক্লাস নিম্নলিখিত পদ্ধতিগুলিকে সংজ্ঞায়িত করবে: TIEHANDLE, at
PRINT, PRINTF, WRITE, READLINE, GETC, READ, এবং সম্ভবত বন্ধ, UNTIE এবং
ধ্বংস. ক্লাস এছাড়াও প্রদান করতে পারে: BINMODE, OPEN, EOF, FILENO, SEEK, TELL - যদি
সংশ্লিষ্ট পার্ল অপারেটর হ্যান্ডেলে ব্যবহার করা হয়।

যখন STDERR বাঁধা থাকে, তখন সতর্কতা এবং ত্রুটি বার্তা জারি করার জন্য এর প্রিন্ট পদ্ধতি কল করা হবে।
কলের সময় এই বৈশিষ্ট্যটি সাময়িকভাবে অক্ষম করা হয়, যার মানে আপনি "warn()" ব্যবহার করতে পারেন
একটি পুনরাবৃত্ত লুপ শুরু না করেই প্রিন্টের ভিতরে। এবং ঠিক যেমন "__WARN__" এবং "__DIE__"
হ্যান্ডলার, STDERR-এর প্রিন্ট পদ্ধতিকে পার্সার ত্রুটি রিপোর্ট করতে বলা হতে পারে, তাই সতর্কতা
পার্লভার প্রয়োগে "%SIG" এর অধীনে উল্লেখ করা হয়েছে।

এই সব বিশেষভাবে উপযোগী যখন পার্ল অন্য কোন প্রোগ্রামে এমবেড করা হয়, যেখানে আউটপুট
STDOUT এবং STDERR-এ কিছু বিশেষ উপায়ে পুনঃনির্দেশিত হতে হতে পারে। nvi এবং দেখুন
উদাহরণের জন্য অ্যাপাচি মডিউল।

একটি হ্যান্ডেল বাঁধার সময়, "টাই" করার প্রথম যুক্তিটি একটি তারকাচিহ্ন দিয়ে শুরু করা উচিত। তাই যদি
আপনি STDOUT বাঁধছেন, *STDOUT ব্যবহার করুন। আপনি যদি এটি একটি স্কেলার ভেরিয়েবলের সাথে বরাদ্দ করে থাকেন, বলুন
$হ্যান্ডেল, *$হ্যান্ডেল ব্যবহার করুন। "টাই $হ্যান্ডেল" স্কেলার ভেরিয়েবল $হ্যান্ডেলকে বাঁধে, হ্যান্ডেল নয়
এটার ভিতরে.

আমাদের উদাহরণে আমরা একটি চিৎকার হ্যান্ডেল তৈরি করতে যাচ্ছি।

প্যাকেজ চিৎকার;

TIEHANDLE ক্লাসের নাম, তালিকা
এটি ক্লাসের জন্য কনস্ট্রাক্টর। তার মানে এটি একটি আশীর্বাদ ফিরে আশা করা হয়
কোন ধরণের রেফারেন্স। রেফারেন্স কিছু অভ্যন্তরীণ তথ্য রাখা ব্যবহার করা যেতে পারে.

সাব টাইহ্যান্ডেল { মুদ্রণ " \n"; আমার $i; আশীর্বাদ করুন \$i, শিফট }

এটি লিখুন, তালিকা
এই পদ্ধতিটি কল করা হবে যখন হ্যান্ডেলটি "syswrite" ফাংশনের মাধ্যমে লেখা হয়।

সাব লিখুন {
$r = শিফট;
আমার($buf,$len,$offset) = @_;
প্রিন্ট "লিখুন কল, \$buf=$buf, \$len=$len, \$offset=$offset";
}

এটি প্রিন্ট করুন, তালিকা করুন
এই পদ্ধতিটি প্রতিবার ট্রিগার করা হবে যখন বাঁধা হ্যান্ডেলটি দিয়ে মুদ্রিত হবে
"print()" বা "say()" ফাংশন। এর স্ব-রেফারেন্সের বাইরেও এটি তালিকাটি আশা করে
যে প্রিন্ট ফাংশন পাস করা হয়েছে.

সাব প্রিন্ট { $r = শিফট; $$r++; প্রিন্ট যোগদান($,,মানচিত্র(uc($_),@_)),$\ }

"say()" $\ ব্যতীত "print()" এর মতো কাজ করে "\n" এ স্থানীয়করণ করা হবে তাই আপনাকে করতে হবে
"PRINT()"-এ "say()" পরিচালনা করার জন্য বিশেষ কিছু নেই৷

এটি মুদ্রণ করুন, তালিকা
এই পদ্ধতিটি প্রতিবার ট্রিগার করা হবে যখন বাঁধা হ্যান্ডেলটি দিয়ে মুদ্রিত হবে
"printf()" ফাংশন। এর স্ব-রেফারেন্সের বাইরেও এটি বিন্যাস এবং তালিকা আশা করে
যে printf ফাংশন পাস করা হয়েছে.

সাব PRINTF {
স্থানান্তর;
আমার $fmt = শিফট;
প্রিন্ট sprintf($fmt, @_);
}

এটি পড়ুন, তালিকা
এই পদ্ধতিটি বলা হবে যখন হ্যান্ডেলটি "রিড" বা "sysread" এর মাধ্যমে পড়া হবে
ফাংশন।

উপ পড়ুন {
আমার $self = শিফট;
আমার $bufref = \$__[0];
my(undef,$len,$offset) = @_;
প্রিন্ট করুন "READ called, \$buf=$bufref, \$len=$len, \$offset=$offset";
# $$bufref-এ যোগ করুন, পড়ার অক্ষরের সংখ্যায় $len সেট করুন
$len;
}

এই READLINE
এই পদ্ধতিটি বলা হয় যখন হ্যান্ডেলটি "এর মাধ্যমে পড়া হয় " বা "রিডলাইন হ্যান্ডেল"।

"রিডলাইন" অনুসারে, স্কেলার প্রেক্ষাপটে এটির পরবর্তী লাইনটি ফেরত দেওয়া উচিত, বা না-র জন্য "undef"
আরো তথ্য। তালিকা প্রসঙ্গে এটি সমস্ত অবশিষ্ট লাইন, বা একটি খালি তালিকা ফেরত দিতে হবে
কোন তথ্য নেই. ফিরে আসা স্ট্রিংগুলিতে ইনপুট রেকর্ড বিভাজক $/ (দেখুন
perlvar), যদি না এটি "undef" (যার মানে "slurp" মোড) না হয়।

সাব রিডলাইন {
আমার $r = শিফট;
যদি (ওয়ান্টারে) {
ফেরত ("বাকি সব\n",
"লাইন আপ\n",
"eof\n");
} অন্য {
রিটার্ন করুন "READLINE" নামে। ++$$r "বার\n";
}
}

এই GETC
"getc" ফাংশন কল করা হলে এই পদ্ধতিটি বলা হবে।

সাব GETC { প্রিন্ট করুন "GETC করবেন না, পার্ল পান"; ফেরত "a"; }

EOF এই
যখন "eof" ফাংশন বলা হবে তখন এই পদ্ধতিটি বলা হবে।

পার্ল 5.12 দিয়ে শুরু করে, একটি অতিরিক্ত পূর্ণসংখ্যা প্যারামিটার পাস করা হবে। এটা হবে
শূন্য যদি প্যারামিটার ছাড়া "eof" বলা হয়; 1 যদি "eof" কে একটি ফাইলহ্যান্ডেল হিসাবে দেওয়া হয়
প্যারামিটার, যেমন "eof(FH)"; এবং 2 খুব বিশেষ ক্ষেত্রে যেটি বাঁধা ফাইলহ্যান্ডেল
"ARGV" এবং "eof" কে একটি খালি প্যারামিটার তালিকা সহ বলা হয়, যেমন "eof()"।

সাব EOF { দৈর্ঘ্য $stringbuf নয় }

এটি বন্ধ করুন
"ক্লোজ" ফাংশনের মাধ্যমে হ্যান্ডেলটি বন্ধ হলে এই পদ্ধতিটি বলা হবে।

সাব ক্লোজ { প্রিন্ট "CLOSE বলা হয়৷\n" }

এটি মুক্ত করুন
অন্যান্য ধরনের বন্ধনগুলির মতো, এই পদ্ধতিটি বলা হবে যখন "আনটি" ঘটবে। এটা
যখন এটি ঘটে তখন "স্বয়ংক্রিয়ভাবে বন্ধ" করা উপযুক্ত হতে পারে৷ নীচে "The "untie" Gotcha দেখুন।

এই ধ্বংস
অন্যান্য ধরনের বন্ধনগুলির মতো, এই পদ্ধতিটিকে বলা হবে যখন বাঁধা হাতল হবে
ধ্বংস হতে প্রায় এটি ডিবাগিং এবং সম্ভবত পরিষ্কার করার জন্য দরকারী।

সাব ডিস্ট্রোয় { মুদ্রণ " \n"}

আমাদের ছোট উদাহরণটি কীভাবে ব্যবহার করবেন তা এখানে:

টাই (*FOO, 'চিৎকার');
FOO প্রিন্ট করুন "হ্যালো\n";
$a = 4; $b = 6;
FOO $a, " প্লাস", $b, " সমান", $a + $b, "\n" প্রিন্ট করুন;
ছাপা ;

UNTIE এই
আপনি সমস্ত টাই প্রকারের জন্য একটি UNTIE পদ্ধতি সংজ্ঞায়িত করতে পারেন যা কল করা হবে মুক্ত করা(). দেখুন "দি
নীচে "আনটি" ধরা"

সার্জারির "খোলা" gotcha
আপনি যদি উভয় থেকে ফিরে আসা বস্তুর ব্যবহার করতে চান টাই() or বাঁধা(), এবং যদি
টাই এর টার্গেট ক্লাস একটি ধ্বংসকারী সংজ্ঞায়িত করে, একটি সূক্ষ্ম আপনি আছে অবশ্যই বিরুদ্ধে পাহারা.

সেটআপ হিসাবে, একটি টাই এর এই (স্বীকৃতভাবে বরং অনুপযুক্ত) উদাহরণ বিবেচনা করুন; এটা সব ব্যবহার হয়
একটি স্কেলারে নির্ধারিত মানগুলির লগ রাখার জন্য একটি ফাইল।

প্যাকেজ মনে রাখবেন;

কঠোর ব্যবহার করুন;
সতর্কতা ব্যবহার করুন;
IO::ফাইল ব্যবহার করুন;

সাব টাইস্ক্যালার {
আমার $ক্লাস = শিফট;
আমার $filename = শিফট;
আমার $handle = IO::File->new( "> $filename" )
অথবা ডাই "$filename খুলতে পারে না: $!\n";

$handle "The Start\n" প্রিন্ট করুন;
আশীর্বাদ করুন {FH => $handle, Value => 0}, $class;
}

সাব FETCH {
আমার $self = শিফট;
ফেরত $self->{মান};
}

সাব স্টোর {
আমার $self = শিফট;
আমার $মান = শিফট;
my $handle = $self->{FH};
$handle "$value\n" প্রিন্ট করুন;
$self->{Value} = $value;
}

উপ ধ্বংস {
আমার $self = শিফট;
my $handle = $self->{FH};
$handle "The End\n" প্রিন্ট করুন;
$হ্যান্ডেল বন্ধ করুন;
}

1;

এখানে একটি উদাহরণ যা এই টাই ব্যবহার করে:

কঠোর ব্যবহার করুন;
মনে রাখবেন ব্যবহার করুন;

আমার $ফ্রেড;
টাই $fred, 'মনে রাখবেন', 'myfile.txt';
$fred = 1;
$fred = 4;
$fred = 5;
$fred খুলুন;
সিস্টেম "cat myfile.txt";

এটি কার্যকর করার সময় এটি আউটপুট:

শুরু
1
4
5
সমাপ্তি

এ পর্যন্ত সব ঠিকই. আপনারা যারা মনোযোগ দিয়েছেন তারা লক্ষ্য করেছেন যে
বাঁধা বস্তুটি এতদিন ব্যবহার করা হয়নি। সুতরাং Remember class-এ একটি অতিরিক্ত পদ্ধতি যোগ করা যাক
ফাইলে মন্তব্য অন্তর্ভুক্ত করার অনুমতি দিন; বলুন, এরকম কিছু:

সাব মন্তব্য {
আমার $self = শিফট;
আমার $text = শিফট;
my $handle = $self->{FH};
প্রিন্ট $handle $text, "\n";
}

এবং এখানে "মন্তব্য" পদ্ধতি ব্যবহার করার জন্য পূর্ববর্তী উদাহরণটি পরিবর্তিত হয়েছে (যার প্রয়োজন
বাঁধা বস্তু):

কঠোর ব্যবহার করুন;
মনে রাখবেন ব্যবহার করুন;

আমার ($ফ্রেড, $x);
$x = টাই $fred, 'মনে রেখো', 'myfile.txt';
$fred = 1;
$fred = 4;
মন্তব্য $x "পরিবর্তন হচ্ছে...";
$fred = 5;
$fred খুলুন;
সিস্টেম "cat myfile.txt";

যখন এই কোডটি কার্যকর করা হয় তখন কোন আউটপুট থাকে না। কারণটা এখানে:

যখন একটি ভেরিয়েবল বাঁধা হয়, তখন এটি বস্তুর সাথে যুক্ত হয় যা এর রিটার্ন মান
TIESCALAR, TIEARRAY, বা TIEHASH ফাংশন। এই বস্তুর সাধারণত শুধুমাত্র একটি রেফারেন্স আছে,
যথা, বাঁধা পরিবর্তনশীল থেকে অন্তর্নিহিত রেফারেন্স। কখন মুক্ত করা() বলা হয়, যে
রেফারেন্স নষ্ট হয়। তারপর, উপরের প্রথম উদাহরণের মতো, বস্তুর ধ্বংসকারী
(DESTROY) বলা হয়, যা এমন বস্তুর জন্য স্বাভাবিক যেগুলোর আর কোনো বৈধ রেফারেন্স নেই; এবং
এইভাবে ফাইলটি বন্ধ।

দ্বিতীয় উদাহরণে, যাইহোক, আমরা $x এ বাঁধা বস্তুর আরেকটি রেফারেন্স সংরক্ষণ করেছি।
তার মানে যখন মুক্ত করা() বলা হয় সেখানে এখনও একটি বৈধ রেফারেন্স হবে
বস্তুর অস্তিত্ব আছে, তাই সেই সময়ে ডেস্ট্রাক্টর বলা হয় না, এবং এইভাবে ফাইলটি
বন্ধ না কোন আউটপুট নেই কারণ ফাইল বাফার হয়েছে না
ডিস্কে ফ্লাশ করা হয়েছে।

এখন আপনি জানেন যে সমস্যাটি কী, আপনি এটি এড়াতে কী করতে পারেন? পূর্বে
ঐচ্ছিক UNTIE পদ্ধতির প্রবর্তনের একমাত্র উপায় ছিল ভাল পুরানো "-w" পতাকা। যা
আপনি কল যেখানে কোনো উদাহরণ স্পট করবে মুক্ত করা() এবং এখনও বৈধ উল্লেখ আছে
বাঁধা বস্তু যদি উপরের দ্বিতীয় স্ক্রিপ্টটি উপরের দিকে থাকে তাহলে "সতর্কতা 'আনটাই' ব্যবহার করুন" বা ছিল
"-w" পতাকা দিয়ে চালান, পার্ল এই সতর্কতা বার্তাটি প্রিন্ট করে:

1টি অভ্যন্তরীণ রেফারেন্স এখনও বিদ্যমান থাকাকালীন মুক্ত করার চেষ্টা করা হয়েছে৷

স্ক্রিপ্টটি সঠিকভাবে কাজ করতে এবং সতর্কতা নীরব করার জন্য নিশ্চিত করুন যে কোনও বৈধ নেই
বাঁধা বস্তুর উল্লেখ আগে মুক্ত করা() বলা হয়:

undef $x;
$fred খুলুন;

এখন যেহেতু UNTIE বিদ্যমান রয়েছে ক্লাস ডিজাইনার ক্লাস কার্যকারিতার কোন অংশগুলি নির্ধারণ করতে পারে
সত্যিই "unti" এর সাথে যুক্ত এবং যার সাথে বস্তুটি ধ্বংস হয়ে যাচ্ছে। কি তৈরী করে
একটি প্রদত্ত শ্রেণীর জন্য অর্থ নির্ভর করে যে অভ্যন্তরীণ রেফারেন্সগুলি রাখা হচ্ছে কিনা তার উপর
নন-টাই-সম্পর্কিত পদ্ধতি অবজেক্টে কল করা যেতে পারে। তবে বেশিরভাগ ক্ষেত্রেই এটি সম্ভবত তৈরি করে
UNTIE পদ্ধতিতে DESTROY-এ থাকা কার্যকারিতা সরানোর অর্থ।

যদি UNTIE পদ্ধতি বিদ্যমান থাকে তবে উপরের সতর্কতাটি ঘটবে না। পরিবর্তে UNTIE পদ্ধতি
"অতিরিক্ত" রেফারেন্সের গণনা পাস করা হয় এবং উপযুক্ত হলে নিজস্ব সতর্কতা জারি করতে পারে।
যেমন নো UNTIE কেস প্রতিলিপি করতে এই পদ্ধতিটি ব্যবহার করা যেতে পারে:

সাব UNTIE
{
আমার ($obj,$count) = @_;
carp "$count অভ্যন্তরীণ রেফারেন্স এখনও বিদ্যমান থাকাকালীন মুক্ত করার চেষ্টা করা হয়েছে" যদি $count;
}

onworks.net পরিষেবা ব্যবহার করে অনলাইনে perltie ব্যবহার করুন