লুপের জন্য [বন্ধ] একর ক্ষেত্রে <বা <= ব্যবহার করা উচিত

124

যদি আপনাকে 7 বার লুপের মাধ্যমে পুনরাবৃত্তি করতে হয় তবে আপনি কি ব্যবহার করবেন:

for (int i = 0; i < 7; i++)

বা:

for (int i = 0; i <= 6; i++)

দুটি বিবেচনা আছে:

  • কর্মক্ষমতা
  • সুপাঠ্যতা

পারফরম্যান্সের জন্য আমি জাভা বা সি # ধরে নিচ্ছি। "এর চেয়ে কম" বা "এর চেয়ে কম বা সমান" ব্যবহৃত হয় তা কী বিবেচনা করে? আপনার যদি কোনও আলাদা ভাষার অন্তর্দৃষ্টি থাকে তবে দয়া করে কোনটি নির্দেশ করুন।

পাঠযোগ্যতার জন্য আমি 0-ভিত্তিক অ্যারে ধরে নিচ্ছি।

ইউপিডি: আমার 0-ভিত্তিক অ্যারেগুলির উল্লেখে বিভ্রান্তিকর জিনিস থাকতে পারে। আমি অ্যারের উপাদানগুলির মাধ্যমে পুনরাবৃত্তি করার কথা বলছি না। কেবল একটি সাধারণ লুপ।

একটি ধ্রুবক ব্যবহার করার সম্পর্কে নীচে একটি ভাল পয়েন্ট রয়েছে যা এই যাদু নম্বরটি কী তা ব্যাখ্যা করবে। সুতরাং আমার যদি " int NUMBER_OF_THINGS = 7" তখন " i <= NUMBER_OF_THINGS - 1" "অদ্ভুত লাগত, তাই না।

performance  conventions  readability 
— ইউজিন কাটজ
সূত্র
আমি বলব: আপনি যদি পুরো অ্যারে দিয়ে চালিত হন তবে কখনই বাম দিকে বিয়োগ বা কোনও সংখ্যা যুক্ত করবেন না।
— লেটারম্যান 21

উত্তর:

287

প্রথমটি আরও মূর্তিমান । বিশেষত, এটি (0-ভিত্তিক অর্থে) পুনরাবৃত্তির সংখ্যা নির্দেশ করে। 1-ভিত্তিক কিছু ব্যবহার করার সময় (যেমন জেডিবিসি, আইআইআরসি) আমাকে <= ব্যবহার করতে প্ররোচিত হতে পারে। তাই:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

আমি আশা করব পারফরম্যান্সের পার্থক্যটি রিয়েল-ওয়ার্ল্ড কোডের ক্ষেত্রে তাত্পর্যপূর্ণভাবে ছোট হবে।

— জন স্কিট
সূত্র
30
আপনি প্রায় গ্যারান্টিযুক্ত একটি পারফরম্যান্স পার্থক্য হবে না। X86 এর মতো অনেক আর্কিটেকচারের নির্দেশাবলী "গত তুলনায় কম বা সমান" লাফিয়ে থাকে। আপনি সম্ভবত পারফরম্যান্সের পার্থক্যটি দেখতে পাচ্ছেন এমন কোনও ব্যাখ্যামূলক ভাষায় হতে পারে যা খারাপভাবে প্রয়োগ করা হয়নি।
— ওয়েজ
3
পরিবর্তে আপনি কি ব্যবহারের কথা বিবেচনা করবেন? আমি বলব যে আমি লুপ কাউন্টার হিসাবে স্পষ্টভাবে প্রতিষ্ঠিত করি এবং অন্য কিছুই না।
— ইয়ুংচিন
21
আমি সাধারণত না। এটি ঠিক খুব অপরিচিত। লুপ চলাকালীন কেউ যদি দুর্ঘটনাক্রমে আমি বাড়িয়ে দেয় তবে এটি খুব খুব দীর্ঘ লুপে যাওয়ার ঝুঁকিও রয়েছে।
— জন স্কিটি
5
এসটিএল পুনরাবৃত্তির জেনেরিক প্রোগ্রামিং ম্যান্ডেটের ব্যবহার! = Of এটি (দুর্ঘটনাজনিত ডাবল ইনক্রিমেন্টিং) আমার পক্ষে সমস্যা হয়নি। আমি সম্মত হই না যে সূচকগুলির জন্য <(বা অবতরণের জন্য) আরও সুস্পষ্ট এবং প্রচলিত।
— জোনাথন গ্রাহেল
2
মনে রাখবেন, <ব্যবহার করে আপনি যদি অ্যারের দৈর্ঘ্যটি লুপ করেন তবে জেআইটি অ্যারে অ্যাক্সেসটিকে অনুকূল করে (আবদ্ধ চেকগুলি সরিয়ে দেয়)। সুতরাং <= ব্যবহার করে এটি দ্রুত হওয়া উচিত। যদিও আমি এটি পরীক্ষা করে দেখিনি
— কনফিগারকারী
72

এই দুটি লুপ 7 বার পুনরাবৃত্তি হয়। আমি যদি এটির সাথে 7 এর সাথে এক বলি তবে এটি আরও পঠনযোগ্য / পরিষ্কার হয়, যদি না আপনি অন্যজনের পক্ষে সত্যিই ভাল কারণ না পান।

— স্টিভ লশ
সূত্র
আমার মনে আছে আমি কখন জাভা শেখা শুরু করেছি। আমি 0-ভিত্তিক সূচকের ধারণাটিকে ঘৃণা করি কারণ আমি সর্বদা 1-ভিত্তিক সূচক ব্যবহার করেছি। সুতরাং আমি সর্বদা <= 6 রূপটি ব্যবহার করব (প্রশ্নটিতে দেখানো হয়েছে)। আমার নিজের ক্ষতির কারণ, যখন লুপটি প্রকৃতপক্ষে বেরিয়ে আসে তখন এটি আমাকে আরও বিভ্রান্ত করে। কেবলমাত্র <
— জেমস হাগ
55

আমার সেই দিনগুলি থেকে মনে আছে যখন আমরা কলেজে ৮০8686 বিধানসভা করেছি এটি করা আরও পারফরম্যান্ট ছিল:

for (int i = 6; i > -1; i--)

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

আপনার লুপে or বা putting রাখার মাধ্যমে একটি " যাদু নম্বর " প্রবর্তন করা হচ্ছে । আরও ভাল পঠনযোগ্যতার জন্য আপনার একটি উদ্বেগ প্রকাশকারী নাম সহ একটি ধ্রুবক ব্যবহার করা উচিত। এটার মত:

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

সম্পাদনা: লোকেরা সমাবেশের জিনিস পাচ্ছে না তাই স্পষ্টতই একটি উদাহরণ উদাহরণ প্রয়োজন:

আমরা যদি (i = 0; i <= 10; i ++) এর জন্য করি তবে আপনাকে এটি করতে হবে:

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

যদি আমরা (int i = 10; i> -1; i--) এর জন্য করি তবে আপনি এগুলি থেকে দূরে যেতে পারেন:

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

আমি মাত্র পরীক্ষা করেছি এবং মাইক্রোসফ্টের সি ++ সংকলক এই অপ্টিমাইজেশনটি করে না, তবে আপনি যদি তা করেন তবে:

for (int i = 10; i >= 0; i--)

সুতরাং নৈতিকতাটি হ'ল যদি আপনি মাইক্রোসফ্ট সি ++ using ব্যবহার করে থাকেন এবং আপনার ব্যবহার করা উচিত তত দ্রুত লুপটি পেতে, আরোহণ বা উতরাই কোনও পার্থক্য করে না:

for (int i = 10; i >= 0; i--)

এর চেয়ে উভয়টির চেয়ে:

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

তবে স্পষ্টতই "for (int i = 0; i <= 10; i ++)" এর পাঠযোগ্যতা পাওয়া সাধারণত একটি প্রসেসরের কমান্ড মিস করার চেয়ে অনেক বেশি গুরুত্বপূর্ণ।

† অন্যান্য সংকলকরা বিভিন্ন জিনিস করতে পারে।

— মার্টিন ব্রাউন
সূত্র
4
"ম্যাজিক নম্বর" কেসটি সুন্দরভাবে চিত্রিত করে, কেন << << এর চেয়ে সাধারণত ব্যবহার করা ভাল।
— রিনি সরসু
11
অন্য সংস্করণটি হ'ল "(int i = 10; i--;)" এর জন্য। কিছু লোক "এর জন্য (int i = 10; i -> 0;)" ব্যবহার করেন এবং ভান করে যে সংমিশ্রণ -> মানে যায়।
— জায়েঞ্জ
2
সমাবেশ কোডের জন্য +1
— নিউরো
1
কিন্তু যখন সময় আসবে আসলে লুপ কাউন্টারটি ব্যবহার করা হবে, যেমন অ্যারে ইনডেক্সিংয়ের জন্য, তখন আপনাকে এমন কাজ করা দরকার 7-iযা পিছনের দিক থেকে গণনা করা থেকে প্রাপ্ত কোনও অপ্টিমাইজেশানকে জলাবদ্ধ করতে চলেছে।
— মিথ্যা রায়ান
@ লাই, এটি কেবলমাত্র তখনই প্রযোজ্য যদি আপনার আইটেমগুলি ফরওয়ার্ডে প্রক্রিয়াকরণের প্রয়োজন হয়। এই ধরণের লুপগুলির বেশিরভাগ ক্রিয়াকলাপের মাধ্যমে আপনি এগুলি আপনার পছন্দ মতো কোনও লুপের আইটেমগুলিতে প্রয়োগ করতে পারেন। উদাহরণস্বরূপ, আপনি যদি কোনও মানটির সন্ধান করছেন তবে আপনি তালিকার শেষে শুরু হয়ে কাজ শুরু করেছেন বা তালিকার শুরুতে এবং কাজ করছেন কিনা তা বিবেচ্য নয় (ধরে নিচ্ছেন যে আপনার আইটেমটি তালিকার কোন শেষ তা অনুমান করতে পারবেন না) অনুরূপভাবে হতে হবে এবং মেমরি ক্যাশিং কোনও সমস্যা নয়)।
— মার্টিন ব্রাউন
27

আমি সর্বদা <অ্যারে.লেন্থটি ব্যবহার করি কারণ এটি <= অ্যারে.লেন্থ -১ এর চেয়ে পড়া সহজ।

<< থাকার পরেও এবং আপনি যে 0 টি সূচক দিয়ে শুরু করছেন তা জানার ক্ষেত্রে এটি স্বজ্ঞাত হওয়া উচিত যে সংখ্যাটি পুনরাবৃত্তির সংখ্যা।

— ওমর কুহেজি
সূত্র
লুপের ফাংশনগুলি ব্যবহার করার সময় আপনার দৈর্ঘ্যের ফাংশনগুলির ব্যয় পরীক্ষা করার ক্ষেত্রে সর্বদা সতর্ক হওয়া উচিত। উদাহরণস্বরূপ আপনি যদি সি / সি ++ তে স্ট্রেন ব্যবহার করেন তবে আপনি তুলনা করতে সময়টি প্রচুর পরিমাণে বাড়িয়ে যাচ্ছেন। এটি হ'ল কারণ স্ট্রলিনকে তার উত্তরটি খুঁজতে পুরো স্ট্রিংটি পুনরাবৃত্তি করতে হবে যা এমন কিছু যা আপনি সম্ভবত আপনার লুপের প্রতিটি পুনরাবৃত্তির পরিবর্তে একবার করতে চান।
— মার্টিন ব্রাউন
2
@ মার্টিন ব্রাউন: জাভাতে (এবং আমি বিশ্বাস করি সি #), স্ট্রিং.লেন্থ এবং অ্যারে ডাইলেথ ধ্রুবক কারণ স্ট্রিং অপরিবর্তনীয় এবং অ্যারের অপরিবর্তনীয় দৈর্ঘ্য রয়েছে। এবং যেহেতু স্ট্রিং.লেন্থ এবং অ্যারে.লেন্থ একটি ক্ষেত্র (কোনও ফাংশন কলের পরিবর্তে) তাই আপনি নিশ্চিত হতে পারেন যে সেগুলি অবশ্যই ও (1) হবে। সি ++ এর ক্ষেত্রে ভাল, আপনি প্রথমে সি-স্ট্রিংটি ব্যবহার করছেন কেন?
— মিথ্যা রায়ান
18

একটি অপ্টিমাইজ করা দৃষ্টিকোণ থেকে দেখেছি এটি কিছু যায় আসে না।

আমি পছন্দ করি এমন কোনও কোড শৈলীর দৃষ্টিকোণ থেকে দেখা। কারণ:

for ( int i = 0; i < array.size(); i++ )

এর চেয়ে অনেক বেশি পাঠযোগ্য

for ( int i = 0; i <= array.size() -1; i++ )

এছাড়াও <আপনাকে সরাসরি পুনরাবৃত্তির সংখ্যা দেয়।

<এর জন্য অন্য একটি ভোট হ'ল আপনি সম্ভবত দুর্ঘটনাজনিত ভুলগুলি অনেকগুলি রোধ করতে পারেন।

— erlando
সূত্র
10

@ ক্রিস, আপনার সম্পর্কে বিবৃতি। .NET এ দৈর্ঘ্য ব্যয়বহুল হওয়া আসলে অসত্য এবং সাধারণ ধরণের ক্ষেত্রে একেবারে বিপরীত।

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

আসলে চেয়ে ধীর

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

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

— জেফ ম্যাক
সূত্র
জাভাতে। দৈর্ঘ্য কোনও ক্ষেত্রে ব্যয়বহুল হতে পারে। stackoverflow.com/questions/6093537/for-loop-optimization এটা b'coz কল .lenghtবা .size। আমি নিশ্চিত নই তবে আত্মবিশ্বাসীও না তবে কেবল নিশ্চিত করতে চাই।
— রবি পেরেক
6

পারফরম্যান্সের ক্ষেত্রে এটি কোনও কার্যকর পার্থক্য করে না। অতএব আপনি যে সমস্যার সমাধান করছেন তার প্রসঙ্গে আমি যে কোনওটি বুঝতে সহজতর ব্যবহার করব।

— ফিল রাইট
সূত্র
5

আমি পছন্দ করি:

for (int i = 0; i < 7; i++)

আমি মনে করি যে "a বার লুপের মাধ্যমে পুনরাবৃত্তি" আরও তাত্ক্ষণিকভাবে অনুবাদ করে।

পারফরম্যান্সের প্রভাব সম্পর্কে আমি নিশ্চিত নই - আমার সন্দেহ হয় যে কোনও পার্থক্য সঙ্কলিত হবে।

— ডোমিনিক রজার
সূত্র
4

জাভা 1.5 তে আপনি ঠিক করতে পারেন

for (int i: myArray) {
    ...
}

সুতরাং অ্যারের ক্ষেত্রে আপনার চিন্তা করার দরকার নেই।

— JesperE
সূত্র
4

আমি মনে করি না পারফরম্যান্স পার্থক্য আছে। দ্বিতীয় ফর্মটি অবশ্যই স্পষ্টভাবে বেশি পঠনযোগ্য, আপনাকে সর্বশেষ পুনরাবৃত্তির সংখ্যাটি খুঁজে পেতে মানসিকভাবে একটি বিয়োগ করতে হবে না।

সম্পাদনা: আমি অন্যকে দ্বিমত দেখছি। ব্যক্তিগতভাবে আমার জন্য, আমি লুপ স্ট্রাকচারে প্রকৃত সূচি নম্বরগুলি দেখতে চাই। সম্ভবত এটি কারণ পার্লের 0..6সিনট্যাক্সটির আরও স্মরণ করিয়ে দেয় , যা আমি জানি এটির সমতুল্য (0,1,2,3,4,5,6)। আমি যদি একটি 7 দেখতে পাই তবে আমাকে তার পাশের অপারেটরটি পরীক্ষা করতে হবে তা দেখতে, প্রকৃতপক্ষে, সূচী 7 কখনই পৌঁছায় না।

— অ্যাডাম বেলার
সূত্র
আপনি "শেষ পুনরাবৃত্তি সংখ্যা" "" পুনরাবৃত্তির সংখ্যা "এর চেয়ে বেশি গুরুত্বপূর্ণ কিনা তা নির্ভর করে। 0-ভিত্তিক এপিআই সহ, তারা সর্বদা 1 ... দ্বারা পৃথক হবে
— জন স্কিটি
4

আমি বলব "<7" সংস্করণটি ব্যবহার করুন কারণ এটি বেশিরভাগ লোকই পড়বে - তাই যদি লোকেরা আপনার কোডটি পড়ে স্কিম করে তবে তারা ভুলভাবে এটি ব্যাখ্যা করতে পারে।

"<" "" <= "এর চেয়ে দ্রুততর কিনা তা নিয়ে আমি উদ্বিগ্ন হব না, কেবল পঠনযোগ্যতার জন্য যেতে পারি।

আপনি যদি গতি বাড়ানোর দিকে যেতে চান তবে নিম্নলিখিতগুলি বিবেচনা করুন:

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

কর্মক্ষমতা বাড়াতে আপনি এটিকে কিছুটা পুনর্বিন্যাস করতে পারেন:

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

লুপ থেকে গেটকাউন্ট () সরানোর বিষয়টি লক্ষ্য করুন (কারণ এটি প্রতিটি লুপে অনুসন্ধান করা হবে) এবং "i ++" "" ++ i "তে পরিবর্তন করুন।

— ইঙ্গ্রাম চিহ্নিত করুন
সূত্র
আমি দ্বিতীয়টি আরও ভাল পছন্দ করি কারণ এটি পড়া সহজ তবে এটি প্রতিবারই >- গেটকাউন্ট () কে পুনরায় গণনা করে? এটি পরিবর্তন করার সময় আমি এটির দ্বারা ধরা পড়েছি এবং গণনা আমাকে একটি করণ করতে বাধ্য করে একইভাবে অবশিষ্ট রাখে..এখন-> গেটকাউন্ট ()
— osp70
গেটকাউন্ট () প্রথম উদাহরণে প্রতিটি পুনরাবৃত্তি বলা হবে। এটি কেবল দ্বিতীয় উদাহরণে একবার বলা হবে। আপনার যদি প্রতিটি সময় কল করার জন্য গেটকাউন্ট () প্রয়োজন হয় তবে লুপে রেখে দিন, যদি আপনি এটি বাইরে রাখার চেষ্টা না করেন।
— চিহ্নিত করুন
হ্যাঁ আমি এটি চেষ্টা করেছিলাম এবং আপনি ঠিক বলেছেন, আমার ক্ষমা।
— osp70
I++ এর বেশি ++ i ব্যবহার করতে এটি কী পার্থক্য করে?
— রিনি সরসু
ইনট ব্যবহার করার সময় একটি সামান্য গতি বৃদ্ধি, তবে আপনি নিজের ক্লাস বাড়িয়ে দিলে বৃদ্ধি আরও বড় হতে পারে। মূলত ++ i প্রকৃত মান বৃদ্ধি করে, তারপরে প্রকৃত মান প্রদান করে। আমি ++ একটি টেম্পের ভার তৈরি করে, আসল ভার বাড়ায়, তারপরে অস্থায়ীভাবে ফিরে আসে। ++ i এর সাথে কোনও রূপ তৈরির প্রয়োজন নেই।
— ইঙ্গ্রামটি
4

সি ++ এ, আমি ব্যবহার করতে পছন্দ করি !=যা সমস্ত এসটিএল ধারকগুলির সাথে ব্যবহারযোগ্য। সমস্ত এসটিএল ধারক পুনরাবৃত্তি তুলনামূলক কম নয়।

— madmoose
সূত্র
এটি আমাকে খানিকটা ভয় দেখায় কারণ বাইরে খুব সামান্য সুযোগ রয়েছে যে আমার কাঙ্ক্ষিত মানটির চেয়ে কাউন্টারটি পুনরুক্তি করতে পারে যা এটি তখন অসীম লুপ তৈরি করে। সম্ভাবনাগুলি দূরবর্তী এবং সহজেই সনাক্ত করা যায় - তবে < নিরাপদ মনে হয় ।
— রব অ্যালেন
2
যদি আপনার কোডে মত একটি বাগ, এটি সম্ভবত ভাল বিপর্যস্ত এবং নিঃশব্দে চেয়ে বার্ন অব্যাহত রাখার জন্য এর :-)
এটি সঠিক উত্তর: এটি আপনার পুনরুক্তিকারীর কাছে কম চাহিদা রাখে এবং আপনার কোডটিতে কোনও ত্রুটি থাকলে এটি প্রদর্শিত হবে। <টির পক্ষে যুক্তি স্বল্পদৃষ্টির। আপনি যখন সিপিইউর জন্য অর্থ প্রদান করছিলেন তখন হয়তো 70 এর দশকে অসীম লুপটি খারাপ হতে পারে। '! =' ত্রুটি লুকানোর সম্ভাবনা কম।
— ডেভিড নেহমে
1
পুনরুত্থানের উপরে লুপিং একটি কাউন্টারের সাথে লুপিং থেকে সম্পূর্ণ আলাদা কেস। ! = পুনরাবৃত্তিকারীদের জন্য প্রয়োজনীয়।
— ডিজেক্লেওয়ার্থ
4

এডজার ডিজকસ્ત્રা ১৯৮২ সালে এর পিছনে একটি নিবন্ধ লিখেছিলেন যেখানে তিনি নিম্ন <= i <উপরের:

একটি স্বল্পতম প্রাকৃতিক সংখ্যা আছে। নীচে আবদ্ধ - খ) এবং ঘ) এর বর্জন - অপ্রাকৃত সংখ্যার ক্ষেত্র হিসাবে উল্লিখিত নীচের সীমাটি সবচেয়ে ক্ষুদ্রতম প্রাকৃতিক সংখ্যায় শুরু হওয়া একটি অনুক্রমের জন্য বাহিনী। এটি কুৎসিত, সুতরাং নিম্ন সীমার জন্য আমরা পছন্দ করি ≤ যেমন একটি) এবং গ)। ক্ষুদ্রতম প্রাকৃতিক সংখ্যায় শুরু হওয়া উপসর্গগুলি এখন বিবেচনা করুন: উপরের সীমাটি অন্তর্ভুক্তিটি ক্রমটি শূন্যস্থানে সঙ্কুচিত হওয়ার সাথে সাথে পরবর্তীটিকে অপ্রাকৃত হতে বাধ্য করবে। এটি কুৎসিত, সুতরাং উপরের সীমার জন্য আমরা <ক হিসাবে এবং ডি) পছন্দ করি। আমরা উপসংহারে পৌঁছেছি যে কনভেনশন ক) পছন্দ করা উচিত।

— Martijn
সূত্র
3

প্রথমত, 6 বা 7 ব্যবহার করবেন না।

ব্যবহার করা ভাল:

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

এক্ষেত্রে এটি ব্যবহার করার চেয়ে ভাল

for (int day = 0; day <= numberOfDays  - 1; day++){

}

আরও ভাল (জাভা / সি #):

for(int day = 0; day < dayArray.Length; i++){

}

এবং আরও ভাল (সি #)

foreach (int day in days){// day : days in Java

}

বিপরীত লুপটি আসলেই দ্রুত তবে এটি যেহেতু পড়া আরও কঠিন (অন্য প্রোগ্রামারদের দ্বারা আপনার দ্বারা এটি না থাকলে) তাই এড়ানো ভাল Especially বিশেষত সি #, জাভাতে ...

— কেরা
সূত্র
2

আমি ভিড়ের সাথে একমত হয়েছি যে এই ক্ষেত্রে 7 জন উপলব্ধি করে, তবে আমি যুক্ত করব যে যেখানে 6 টি গুরুত্বপূর্ণ, আপনি স্পষ্ট করে বলতে চান আপনি কেবল 6 তম সূচক পর্যন্ত অবজেক্টগুলিতে অভিনয় করছেন, তারপরে <= আরও ভাল কারণ এটি 6 টি দেখতে সহজ করে তোলে।

— tloach
সূত্র
সুতরাং, আমি <= LAST_FILLED_ARRAY_SLOT এর তুলনায় i মাপ
— ক্রিস
2

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

তবে, আপনি যদি সি # বা জাভা কথা বলছেন, আমি সত্যিই মনে করি না যে একজন অন্যটির থেকে গতি বাড়িয়ে তুলবে, আপনার হাতে নেওয়া কয়েকটি ন্যানো সেকেন্ড সম্ভবত আপনার কোনও বিভ্রান্তির পরিচয় নয়।

ব্যক্তিগতভাবে, আমি এমন কোডটি লেখব যা ব্যবসায়ের বাস্তবায়ন দৃষ্টিকোণ থেকে বোঝা যায় এবং এটি পড়ার পক্ষে নিশ্চিত হন।

— casademora
সূত্র
2

এটি সরাসরি "ভুল কোড দেখায় ভুল করা" বিভাগের অধীনে চলে আসে ।

শূন্য-ভিত্তিক সূচীকরণ ভাষায়, জাভা বা সি # লোকেরা index < countশর্তের বিভিন্নতায় অভ্যস্ত । সুতরাং, এই ডিফাক্টো কনভেনশনটি উপকারের মাধ্যমে বাইরের ত্রুটিগুলি আরও স্পষ্ট হয়ে উঠবে।

পারফরম্যান্স সম্পর্কে: এর মেমরির পদচিহ্নের জন্য ভাল কোনও সংকলক যেমন নন-ইস্যু হিসাবে রেন্ডার করা উচিত।

— রায়ান দেলুচি
সূত্র
2

কিছুটা সরাইয়া হিসাবে। নেট যখন কোনও অ্যারে বা অন্য সংগ্রহের মধ্য দিয়ে লুপিং করা হয় তখন আমি সন্ধান করি

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

লুপের জন্য সংখ্যার চেয়ে বেশি পঠনযোগ্য। এটি অবশ্যই ধরে নিয়েছে যে প্রকৃত কাউন্টারটি ইনট নিজে লুপ কোডে ব্যবহৃত হয় না। পারফরম্যান্সের পরিবর্তন আছে কিনা তা আমার জানা নেই।

— রব অ্যালেন
সূত্র
এটিরও প্রয়োজন যে আপনি লুপের সময় সংগ্রহের আকারটি পরিবর্তন করবেন না।
— জেফ বি
সুতরাং (i = 0, i <myarray.count, i++) এর জন্য
— রব অ্যালেন
1

আই <7 লেখার জন্য অনেকগুলি ভাল কারণ রয়েছে। 7 বার পুনরাবৃত্তি হওয়া লুপে 7 নম্বর থাকা ভাল। পারফরম্যান্স কার্যকরভাবে অভিন্ন। প্রায় সবাই আই <7 লিখেন। আপনি যদি পঠনযোগ্যতার জন্য লিখছেন তবে ফর্মটি ব্যবহার করুন যা প্রত্যেকে তাত্ক্ষণিকভাবে চিনবে।

— DJClayworth
সূত্র
1

আমি সবসময় পছন্দ করেছি:

for ( int count = 7 ; count > 0 ; -- count )
— কেনি
সূত্র
আপনার যুক্তি কি? আমি আসল আগ্রহী।
— ক্রিস চুদমোর
বিপরীত লুপিংয়ের জন্য পুরোপুরি ঠিক আছে .. আপনার যদি কখনও এরকম কোনও প্রয়োজন হয়
— ShoeLace
1
একটি কারণ ইউপি স্তরে 0 এর সাথে তুলনা করা দ্রুত। আরেকটি হ'ল এটি আমার কাছে ভালভাবে পড়ে এবং গণনাটি আমাকে আরও কতবার ছেড়ে যায় তার একটি সহজ ইঙ্গিত দেয়।
— কেনে
1

<ব্যবহার করার অভ্যাস তৈরি করা যখন আপনি কোনও অ্যারের মাধ্যমে পুনরাবৃত্তি করেন তখন আপনার এবং পাঠক উভয়ের জন্যই এটি সামঞ্জস্য করে তোলে। এটি একটি স্ট্যান্ডার্ড সম্মেলন করা সবার পক্ষে সহজ হবে। এবং যদি আপনি 0-ভিত্তিক অ্যারেগুলির সাথে কোনও ভাষা ব্যবহার করেন তবে <কনভেনশন।

এটি অবশ্যই <এবং <= এর মধ্যে পারফরম্যান্সের পার্থক্যের চেয়ে বেশি গুরুত্বপূর্ণ। প্রথমে কার্যকারিতা এবং পঠনযোগ্যতার জন্য লক্ষ্য, তারপরে অনুকূলিত করুন।

আরেকটি দ্রষ্টব্য হ'ল আমি ++ এর চেয়ে ++ i করার অভ্যাসে থাকা ভাল তবে যেহেতু আনয়ন এবং বর্ধনের জন্য একটি অস্থায়ী এবং বৃদ্ধি প্রয়োজন এবং আনতে হবে না। পূর্ণসংখ্যার জন্য, আপনার সংকলক সম্ভবত অস্থায়ীভাবে দূরে অপ্টিমাইজ করবে, তবে যদি আপনার পুনরাবৃত্তির ধরণটি আরও জটিল হয় তবে এটি সক্ষম নাও হতে পারে।

— JohnMcG
সূত্র
1

যাদু নম্বর ব্যবহার করবেন না।

কেন এটি 7? (বা matter বিষয়টির জন্য)।

আপনি যে নম্বরটি ব্যবহার করতে চান তার সঠিক চিহ্ন ব্যবহার করুন ...

কোন ক্ষেত্রে আমি এটি ব্যবহার করা ভাল বলে মনে করি

for ( int i = 0; i < array.size(); i++ )
— Krakkos
সূত্র
1

'<' এবং '<=' অপারেটরগুলি ঠিক একই পারফরম্যান্স ব্যয়।

'<' অপারেটর একটি শূন্য-ভিত্তিক লুপে প্রমিত এবং পড়া সহজ।

আই ++ এর পরিবর্তে ++ i ব্যবহার করা সি ++ এ পারফরম্যান্স উন্নত করে, তবে সি # তে নয় - আমি জাভা সম্পর্কে জানি না।

— জেফ বি
সূত্র
1

লোকেরা যেমন পর্যবেক্ষণ করেছে, আপনি উল্লিখিত দুটি বিকল্পের মধ্যে কোনও পার্থক্য নেই। এই বিষয়টি নিশ্চিত করার জন্য, আমি জাভাস্ক্রিপ্টে কিছু সাধারণ বেঞ্চমার্কিং করেছি।

আপনি এখানে ফলাফল দেখতে পারেন । এ থেকে কী স্পষ্ট নয় তা হ'ল আমি যদি প্রথম এবং দ্বিতীয় পরীক্ষার অবস্থানটি অদলবদল করি তবে সেই 2 টি পরীক্ষার ফলাফল অদলবদল করে, এটি স্পষ্টতই একটি স্মৃতি বিষয়। তবে তৃতীয় পরীক্ষা, আমি যেখানে পুনরাবৃত্তিটির ক্রমটি বিপরীত করি তা স্পষ্টভাবে দ্রুত।

— ডেভিড উইস
সূত্র
আপনি দ্বিতীয় ক্ষেত্রে আই = 1 দিয়ে কেন শুরু করবেন?
— ইউজিন কাটজ
হার্মাম, সম্ভবত একটি নির্বোধ ভুল? আমি এটি বেশ দ্রুত বেত্রাঘাত করেছি, সম্ভবত 15 মিনিট।
— ডেভিড ওয়েজ
1

যেমনটি সবাই বলেছে, অ্যারে বাইরের জিনিসের জন্য 0-সূচকযুক্ত পুনরাবৃত্তি ব্যবহার করারও প্রচলিত। যদি সবকিছু শুরু হয় 0এবং শেষ হয় n-1এবং নিম্ন-সীমানা সর্বদা থাকে <=এবং উপরের সীমা সর্বদা <থাকে তবে কোডটি পর্যালোচনা করার সময় আপনার কী করতে হবে এমন চিন্তাভাবনা খুব কম।

— ephemient
সূত্র
1

দুর্দান্ত প্রশ্ন। আমার উত্তর: টাইপ এ ('<') ব্যবহার করুন

  • আপনি পরিষ্কারভাবে দেখতে পাবেন যে আপনার কতগুলি পুনরাবৃত্তি রয়েছে (7)।
  • দুটি প্রান্তের মধ্যে পার্থক্য হল পরিসরের প্রস্থ
  • কম অক্ষর এটি আরও পঠনযোগ্য করে তোলে
  • আপনার কাছে প্রায়শই সর্বশেষ উপাদানগুলির সংখ্যার i < strlen(s)চেয়ে শেষ উপাদানটির সূচকের চেয়ে বেশি থাকে তাই অভিন্নতা গুরুত্বপূর্ণ।

আর একটি সমস্যা এই পুরো নির্মাণটি নিয়ে with এটিতে 3 বারi উপস্থিত হয় , তাই এটি ভুল টাইপ করা যেতে পারে। জন্য-লুপ কনস্ট্রাক্ট বলছেন কি করে করবেন পরিবর্তে কি করতে । আমি এটি গ্রহণ করার পরামর্শ দিচ্ছি:

BOOST_FOREACH(i, IntegerInterval(0,7))

এটি আরও স্পষ্ট, একই asm নির্দেশাবলীকে বিশদভাবে বর্ণনা করার জন্য সংকলন করে etc. ইত্যাদি you

— পাভেল রদজিভিলভস্কি
সূত্র
1

অনেক উত্তর ... তবে আমি বিশ্বাস করি আমার কিছু যোগ করার আছে।

আমার অগ্রাধিকারটি আক্ষরিক সংখ্যার জন্য পরিষ্কারভাবে দেখাতে হবে যে "i" লুপটিতে কী মান নেবে । সুতরাং পুনরাবৃত্তি ক্ষেত্রে শূন্য-ভিত্তিক অ্যারে যদিও:

for (int i = 0; i <= array.Length - 1; ++i)

এবং যদি আপনি কেবল লুপিং করে থাকেন তবে অ্যারের মাধ্যমে পুনরাবৃত্তি না করে 1 থেকে 7 পর্যন্ত গণনা করা বেশ স্বজ্ঞাত:

for (int i = 1; i <= 7; ++i)

আপনি যখনই এটি প্রোফাইল করবেন না ততক্ষণ পঠনযোগ্যতা কার্য সম্পাদনকে ট্রাম্প করে দেবে, কারণ আপনি সম্ভবত জানেন না যে সংকলক বা রানটাইম তখন পর্যন্ত আপনার কোডটি কী করবে।

— নিক ওয়েস্টগেট
সূত্র
1

!=পরিবর্তে আপনি ব্যবহার করতে পারেন । এইভাবে, আপনি যদি প্রাথমিক অবস্থায় কোনও ত্রুটি করেন তবে আপনি একটি ত্রুটিটি আগেই খুঁজে পেয়েছেন এবং এর ফলে ত্রুটিটি আগে থেকেই লক্ষ্য করা যায় এবং এর ফলে যে কোনও সমস্যা লুপে আটকে যাওয়ার ক্ষেত্রে সীমাবদ্ধ হয়ে যায় (অনেক পরে কোনও সমস্যা না হওয়া এবং সন্ধান না করা) এটা)।

— ব্রায়ান
সূত্র
0

আমার মনে হয় হয় ঠিক আছে, কিন্তু যখন আপনি চয়ন করেছেন, এক বা অন্যটির সাথে লেগে থাকুন। যদি আপনি <= ব্যবহার করতে অভ্যস্ত হন তবে <এবং বিপরীতে ব্যবহার না করার চেষ্টা করুন।

আমি <= কে পছন্দ করি তবে আপনি যেখানে শূন্য থেকে শুরু হওয়া সূচীগুলির সাথে কাজ করছেন সেখানে আমি সম্ভবত চেষ্টা করে <ব্যবহার করব। যদিও এটি সমস্ত ব্যক্তিগত পছন্দ।

— seanyboy
সূত্র
0

দৃ a়ভাবে একটি যৌক্তিক দৃষ্টিকোণ থেকে, আপনাকে ভাবতে হবে যে সাম্যতার জন্য পরীক্ষা করার সঠিক কারণের < countচেয়ে এটি আরও কার্যকর হবে।<= count<=

— হেনরি বি
সূত্র
আমার মনে হয় না, এসেম্বলারের ক্ষেত্রে এটি সিএমপি ইক্সে ফোটে, 7 টি এলএল এলওওপিটি বা সিএমপি ইক্স, 6 জিল LOOP_START উভয়ই একই পরিমাণ চক্রের প্রয়োজন।
— ট্রেব
<= হিসাবে প্রয়োগ করা যেতে পারে! (>)
— জনএমসিজি
!!
— জ্যাকব ক্রোল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.