હલ: વિલંબ

મુખ્ય પૃષ્ઠ » સ્વિફ્ટ » સ્વીફ્ટયુઆઈ » હલ: વિલંબ

ચોક્કસ, ચાલો પ્રારંભ કરીએ.

કામગીરીમાં વિલંબ એ ઘણી એપ્લિકેશનોમાં સામાન્ય જરૂરિયાત છે. તે નેટવર્ક વિનંતીને મુલતવી રાખવા, ચોક્કસ સમયગાળા પછી સ્ક્રીન દર્શાવવા અથવા ચોક્કસ સમયગાળા પછી કેટલાક કોડને ચલાવવા સાથે સંબંધિત હોઈ શકે છે. સ્વિફ્ટમાં, વિલંબને અમલમાં મૂકવાની વિવિધ રીતો છે, અને આ લેખમાં, અમે તેનું અન્વેષણ કરીશું.

સ્વિફ્ટ `DispatchQueue.main.asyncAfter` નામનું ફંક્શન પૂરું પાડે છે, જેનો ઉપયોગ ચોક્કસ સમય અંતરાલ પછી કોડના બ્લોકને ચલાવવા માટે થાય છે.

DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
    print("This is a delay operation in Swift")
}

DispatchQueue.main.asyncAfter ને સમજવું

સ્વિફ્ટમાં, ડિસ્પેચક્યુ કામની વસ્તુઓના અમલનું સંચાલન કરે છે. કતારમાં સબમિટ કરેલ દરેક કાર્ય આઇટમ સિસ્ટમ દ્વારા સંચાલિત થ્રેડોના પૂલ પર પ્રક્રિયા કરવામાં આવે છે. મુખ્ય કતાર એ વૈશ્વિક સ્તરે ઉપલબ્ધ સીરીયલ કતાર છે જે એપ્લીકેશનના મુખ્ય થ્રેડ પરના કાર્યોને અમલમાં મૂકે છે.

`asyncAfter` ફંક્શન સ્પષ્ટ વિલંબ પછી વર્તમાન કતાર પર એક્ઝેક્યુશન માટે કાર્ય આઇટમ શેડ્યૂલ કરે છે. સમયમર્યાદા પરિમાણ એ સેકન્ડમાં દર્શાવવામાં આવેલ સમય છે (વર્તમાન સમયની તુલનામાં) જે સૂચવે છે કે કાર્ય આઇટમ ક્યારે એક્ઝિક્યુટ થવી જોઈએ.

let delayInSeconds = 2.0
DispatchQueue.main.asyncAfter(deadline: .now() + delayInSeconds) {
    print("This message is printed after a delay of (delayInSeconds) seconds")
}

વિલંબનો ઉપયોગ કરવાની પરિસ્થિતિઓ

એક્ઝેક્યુશનમાં વિલંબ કરવો એ નેટવર્ક કમ્યુનિકેશન, એનિમેશન અથવા પ્રારંભિક પ્રક્રિયાઓ જેવા વિવિધ કેસોમાં મદદરૂપ થઈ શકે છે જેમાં નોંધપાત્ર સમયની જરૂર પડી શકે છે. ઉદાહરણ તરીકે, વિલંબનો એક સામાન્ય ઉપયોગ કેસ UI વિકાસ ઓછામાં ઓછા સમય માટે લોડિંગ સ્પિનર ​​બતાવવાનું છે, તેથી જો સામગ્રી ઝડપથી લોડ થાય તો પણ, સ્પિનર ​​થોડી ક્ષણો માટે દૃશ્યમાન રહે છે.

અન્ય સામાન્ય ઉપયોગનો કેસ વેબ સેવા પર કૉલ કરવામાં વિલંબ છે. આ એવી પરિસ્થિતિઓમાં મદદ કરી શકે છે કે જ્યાં સેવા તરત જ પ્રતિસાદ ન આપી શકે અથવા જો વપરાશકર્તા હજુ પણ શોધ ફીલ્ડમાં ટાઈપ કરી રહ્યો હોય તો પુનરાવર્તિત કૉલ્સને રોકવા માટે, ઉદાહરણ તરીકે.

વિલંબનો ઉપયોગ કરતી વખતે જાળવી રાખવાના ચક્ર અને મેમરી લીકથી સાવચેત રહો

વિલંબની કામગીરીને અમલમાં મૂકતી વખતે, ધ્યાનમાં લેવાના સૌથી મહત્વપૂર્ણ પાસાઓ પૈકી એક એ છે કે ચક્ર જાળવી રાખવાનું ટાળવું, ખાસ કરીને જ્યારે આપણે બંધની અંદરથી `સ્વ' નો સંદર્ભ આપી રહ્યાં હોઈએ.

જાળવી રાખવાનું ચક્ર ત્યારે થાય છે જ્યારે બે અથવા વધુ વસ્તુઓ એકબીજા સાથે મજબૂત સંદર્ભો ધરાવે છે, જેના કારણે મેમરી લીક થાય છે કારણ કે કોઈપણ વસ્તુને ડિલોકેટ કરી શકાતી નથી. બંધ સાથે કામ કરતી વખતે આને ધ્યાનમાં રાખવું મહત્વપૂર્ણ છે કારણ કે તે મૂળભૂત રીતે મજબૂત સંદર્ભો બનાવે છે.

DispatchQueue ની asyncAfter પદ્ધતિનો ઉપયોગ કરતી વખતે જાળવી રાખવાના ચક્રને રોકવા માટે, અમે બંધમાં `[નબળું સ્વ]` નો ઉપયોગ કરી શકીએ છીએ:

DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
    self?.someMethod()
}

આ કોડમાં, ક્લોઝર `સ્વ'ને મજબૂત રીતે પકડી શકશે નહીં, આમ કોઈ રીટેન સાયકલ થશે નહીં.

યાદ રાખો, સ્વિફ્ટમાં કોડિંગમાં કોડને ઑપ્ટિમાઇઝ કરવાનો અને મેમરી લીક જેવી સંભવિત મુશ્કેલીઓને ઓળખવા અને ટાળવાનો પણ સમાવેશ થાય છે. તે હંમેશા કાર્યક્ષમતા, કાર્યક્ષમતા અને સલામતી વચ્ચે સંતુલન છે.