Debug code
ડીબગ કોડ એ ભૂલોનું પરીક્ષણ કરવા અથવા ભૂલનું કારણ નક્કી કરવામાં મદદ કરવા માટે કમ્પ્યુટર પ્રોગ્રામમાં રજૂ કરાયેલ કમ્પ્યુટર કોડ છે. પ્રોગ્રામના ચોક્કસ બિંદુઓ પર ચલની કિંમત છાપવા માટે તે ઇકો આદેશ જેટલું સરળ હોઈ શકે છે. આધુનિક સંકલિત વિકાસ વાતાવરણ કેટલીકવાર પ્રોગ્રામમાં ચોક્કસ સ્થળોએ સ્ટોપ પોઇન્ટ મૂકવાની મંજૂરી આપીને અને પ્રોગ્રામ આઉટપુટને બદલે IDE દ્વારા ચલોનું મૂલ્ય જોવાની ક્ષમતા પ્રદાન કરીને આને બિનજરૂરી બનાવે છે. ડીબગ કોડનો ઉપયોગ ડીબગ કોડનું મુખ્ય કાર્ય ડીબગ કોડને મદદ કરવાનું છે. આ ઘણી રીતે કરી શકાય છે, જેમ કે પ્રિન્ટ સ્ટેટમેન્ટનો ઉપયોગ કરવો, આગ્રહપૂર્વક આદેશો અને એકમ પરીક્ષણ. કોડિંગમાં ઉપયોગ પ્રોગ્રામમાં ભૂલોની હાજરી અને સ્થાન શોધવા માટે નાના નિવેદનોને કોડમાં ઉમેરી શકાય છે. તેનો ઉપયોગ સંભવિત ઉપયોગના કિસ્સાઓનું અનુકરણ કરવા માટે પરીક્ષણ ઇનપુટ્સ પ્રદાન કરવા માટે પણ થઈ શકે છે જેને પ્રોગ્રામને સ્વીકારવામાં સક્ષમ બનવાની જરૂર પડી શકે છે. તેનો ઉપયોગ કોડ માટે સ્થાન ધારક તરીકે પણ થઈ શકે છે જે હજુ પણ વિકાસમાં છે. વિડિયો ગેમ્સમાં ઉપયોગ ઘણા વિડિયો ગેમિંગ મોડ, ચીટ કોડ, જેમ કે લેવલ ચીટ કોડ, અજેયતા વગેરે. પ્રોગ્રામરો અને/અથવા પરીક્ષકોને અવરોધોને અવગણવાની મંજૂરી આપવા માટે મૂળરૂપે ડીબગ કોડ તરીકે રજૂ કરવામાં આવ્યા હતા જે તેમને રમતના એવા ભાગો સુધી ઝડપથી પહોંચતા અટકાવશે કે જેનું પરીક્ષણ કરવાની જરૂર છે; અને આ કિસ્સાઓમાં ચીટ મોડ્સને ઘણીવાર ડીબગિંગ મોડ તરીકે ઓળખવામાં આવે છે. તે શ્રેષ્ઠ પ્રથા તરીકે ભલામણ કરવામાં આવે છે કે ડીબગિંગ કોડને કાર્યક્રમોના ઉત્પાદન સંસ્કરણોમાંથી દૂર કરવામાં આવે, કારણ કે તે તેમને ધીમું કરી શકે છે. જો કે કેટલીક રમતો આ આદેશો અને ચીટ્સને ખેલાડીઓ માટે તેમના રમતના અનુભવને વધારવા માટેના માર્ગ તરીકે ઉપયોગ કરવા માટે ઉપલબ્ધ રાખે છે. ઉદાહરણ તરીકે, ધ એલ્ડર સ્ક્રોલ્સ વીઃ સ્કાયરિમનું પીસી વર્ઝન ખેલાડીને કમાન્ડ કન્સોલની ઍક્સેસની મંજૂરી આપે છે, જે તેમને તેમની રમતના અમુક પાસાઓને સંશોધિત કરવાની ક્ષમતા આપે છે કારણ કે તે ચાલી રહી છે. આ આદેશોમાં ખેલાડીને અજેયતા, ટેલિપોર્ટેશન અને અમર્યાદિત સોનું આપવાનો સમાવેશ થાય છે. ડીબગ કોડના ઉદાહરણો પ્રિન્ટ ડીબગિંગ પ્રિન્ટ ડીબગિંગ એ પ્રોગ્રામમાં ભૂલોને શોધવા અને અલગ કરવા માટે પ્રિન્ટ સ્ટેટમેન્ટનો ઉપયોગ કરે છે. તેનો ઉપયોગ કોડના ડેટા મૂલ્યોના પ્રવાહને ટ્રેક કરવા માટે થઈ શકે છે. આ પ્રકારના ડીબગ કોડમાં કેટલાક વિશિષ્ટ ગેરફાયદા છે. તે કામચલાઉ હોય છે અને સામાન્ય રીતે જ્યારે ભૂલ હલ થાય ત્યારે તેને દૂર કરવામાં આવે છે. ઘણા પ્રિન્ટ સ્ટેટમેન્ટનો ઉપયોગ પ્રોગ્રામના વાસ્તવિક આઉટપુટને અસર કરી શકે છે અને પ્રિન્ટ સ્ટેટમેન્ટને કેટલી વાર બોલાવવામાં આવે છે તેના આધારે રન-ટાઇમને ધીમું કરી શકે છે. કેટલાક કિસ્સાઓમાં પ્રિન્ટ સ્ટેટમેન્ટ સમસ્યાને શોધવામાં મદદ કરતું નથી, ઉદાહરણ તરીકે C + + stdoutમાં બફર આઉટપુટ હોય છે, અને કેટલીકવાર બફરની સામગ્રી ખોવાઈ જાય છે જે ખોટી ડિબગીંગ માહિતી તરફ દોરી જાય છે. C + + ઉદાહરણ રદબાતલ ટેસ્ટફંક્શન (int ટાઈમ્સ ટૂ રન) {cout <<"અલ્ગોરિધમ ચલાવવું જોઈએ" <<ટાઈમ્સ ટૂ રન <<"ટાઈમ્સ" <<std:: એન્ડલ; માટે (int i = 0; i <= ટાઈમ્સ ટૂ રન; i + +) {// રન અલ્ગોરિધમ અલ્ગોરિધમ ();// ડીબગ પ્રિન્ટ સ્ટેટમેન્ટ cout <<"અલ્ગોરિધમ રન" <<i + + <<"ટાઈમ્સ". <<std::endl;}} ઉપરોક્ત કોડમાં એક ભૂલ છે. 5 ના ઇનપુટ પર પ્રોગ્રામે કન્સોલ પર નીચેની પ્રિન્ટ કરવી જોઈએ. અલ્ગોરિધમનો 5 ગણો અલ્ગોરિધમ 1 વખત ચલાવવો જોઈએ. અલ્ગોરિધમ 2 વખત ચાલે છે. અલ્ગોરિધમ 3 વખત ચાલે છે. અલ્ગોરિધમ 4 વખત ચાલે છે. અલ્ગોરિધમ 5 વખત ચાલે છે. વાસ્તવિક આઉટપુટ નીચે મુજબ છે, જે ખોટું છે. અલ્ગોરિધમનો 5 ગણો અલ્ગોરિધમ 1 વખત ચલાવવો જોઈએ. અલ્ગોરિધમ 2 વખત ચાલે છે. અલ્ગોરિધમ 3 વખત ચાલે છે. અલ્ગોરિધમ 4 વખત ચાલે છે. અલ્ગોરિધમ 5 વખત ચાલે છે. અલ્ગોરિધમ 6 વખત ચાલે છે. આપણું કાર્ય અલ્ગોરિધમ દ્વારા વધારાનો સમય ચાલી રહ્યું છે, અને નજીકથી નિરીક્ષણ પર તે સ્પષ્ટ છે કે આપણી લૂપ ખોટી રીતે કોડેડ છે. નિવેદનોનો ભાર મૂકો સામાન્ય રીતે ભૂલને સુધારવાનો શ્રેષ્ઠ સમય પ્રોગ્રામ ચલાવવામાં આવે તે પહેલાં હોય છે. આ કોડમાં દાવાઓ દાખલ કરીને કરી શકાય છે. સી માં આ દાવા () આદેશનો ઉપયોગ કરીને કરી શકાય છે. એક અસ્સેર્ટ આદેશ એ જોવા માટે ચકાસી શકે છે કે પ્રોગ્રામ આ સમયે યોગ્ય શરતો ચલાવી રહ્યો છે કે કેમ. C ઉદાહરણ પૂર્ણાંક i, a [10]; માટે (i = 0; i <10; + + i) {a [i] = 10-i;} માટે (i = 0; i <10; + + i) {a [a [i]] = a [i];} ઉપરના કોડમાં મર્યાદા બહારની ભૂલ હશે જે કેટલાક અનપેક્ષિત પરિણામો તરફ દોરી શકે છે. કોડને નીચે બતાવ્યા પ્રમાણે દાવાઓનો ઉપયોગ કરીને સુરક્ષિત રીતે લખી શકાય છે. #include <assert.h> પૂર્ણાંક i, a [10]; માટે (i = 0; i <10; + + i) {આગ્રહ (0 <= i & & i <10); a [i] = 10-i;} માટે (i = 0; i <10; + + i) {આગ્રહ (0 <= i & & i <10); આગ્રહ (0 <= a [i] & & & a [i] <10); a [a [i] = a [i];} JUnit JUnit એ જાવા માટે ઉપલબ્ધ પુનરાવર્તિત પરીક્ષણ લખવા માટે વપરાતું એક સરળ માળખું છે, અને પ્રોગ્રામરોને તેમની પોતાની એકમ પરીક્ષણ બનાવવાની મંજૂરી આપે છે. એકમ પરીક્ષણ એ કોડ છે જે પરીક્ષણ કરવાના કોડમાં ચોક્કસ કાર્યને અમલમાં મૂકવા માટે લખવામાં આવે છે અને સામાન્ય રીતે કોડના નાના એકમને લક્ષ્ય બનાવે છે, જેમ કે એક પદ્ધતિ અથવા વર્ગ. દાવા નિવેદનો અને અન્ય પરીક્ષણ નિવેદનોના સંયોજનનો ઉપયોગ કરીને, પ્રોગ્રામરો કોઈ પદ્ધતિ અથવા કાર્ય યોગ્ય રીતે ચલાવવામાં આવી રહ્યું છે કે કેમ તે જણાવવા માટે પરીક્ષણ કેસોના સ્યુટ બનાવી શકે છે. સંદર્ભો સોફ્ટવેર જાળવણી