1C વેબ ક્લાયંટ વિશે

1C:એન્ટરપ્રાઇઝ ટેક્નોલોજીની એક સરસ વિશેષતા એ છે કે મેનેજ્ડ ફોર્મ્સ ટેક્નોલોજીનો ઉપયોગ કરીને વિકસાવવામાં આવેલ એપ્લિકેશન સોલ્યુશનને Windows, Linux, MacOS X માટે પાતળા (એક્ઝિક્યુટેબલ) ક્લાયંટ અને 5 બ્રાઉઝર્સ માટે વેબ ક્લાયંટ તરીકે બંને રીતે લોન્ચ કરી શકાય છે. ક્રોમ, ઈન્ટરનેટ એક્સપ્લોરર, ફાયરફોક્સ, સફારી, એજ અને આ બધું એપ્લીકેશન સોર્સ કોડ બદલ્યા વગર. તદુપરાંત, બાહ્યરૂપે પાતળા ક્લાયંટમાં અને બ્રાઉઝરમાં એપ્લિકેશન કાર્ય કરે છે અને લગભગ સમાન દેખાય છે.
10 તફાવતો શોધો (કટ હેઠળ 2 ચિત્રો):

Linux પર પાતળી ક્લાયંટ વિન્ડો:

વેબ ક્લાયંટમાં સમાન વિન્ડો (ક્રોમ બ્રાઉઝરમાં):

અમે વેબ ક્લાયંટ કેમ બનાવ્યું? કંઈક અંશે દયનીય રીતે કહીએ તો, સમયએ આપણા માટે આવું કાર્ય સેટ કર્યું છે. ઈન્ટરનેટ પર કામ કરવું એ બિઝનેસ એપ્લિકેશન્સ માટે લાંબા સમયથી પૂર્વશરત છે. પ્રથમ, અમે અમારા પાતળા ક્લાયંટ માટે ઇન્ટરનેટ દ્વારા કામ કરવાની ક્ષમતા ઉમેરી (અમારા કેટલાક સ્પર્ધકો, માર્ગ દ્વારા, ત્યાં અટકી ગયા; અન્યોએ, તેનાથી વિપરીત, પાતળા ક્લાયંટને છોડી દીધો અને વેબ ક્લાયંટને અમલમાં મૂકવા માટે પોતાને મર્યાદિત કર્યા). અમે અમારા વપરાશકર્તાઓને ક્લાયંટ વિકલ્પ પસંદ કરવાની તક આપવાનું નક્કી કર્યું છે જે તેમને શ્રેષ્ઠ અનુરૂપ છે.

પાતળા ક્લાયંટમાં વેબ-આધારિત ક્ષમતાઓ ઉમેરવી એ ક્લાયંટ-સર્વર આર્કિટેક્ચરમાં સંપૂર્ણ પરિવર્તન સાથેનો એક મોટો પ્રોજેક્ટ હતો. વેબ ક્લાયંટ બનાવવું એ એક સંપૂર્ણપણે નવો પ્રોજેક્ટ છે, જે શરૂઆતથી શરૂ થાય છે.

સમસ્યાની રચના

તેથી, પ્રોજેક્ટ આવશ્યકતાઓ: વેબ ક્લાયંટે પાતળા ક્લાયંટની જેમ જ કરવું જોઈએ, એટલે કે:

1. વપરાશકર્તા ઈન્ટરફેસ દર્શાવો
2. 1C ભાષામાં લખેલા ક્લાયન્ટ કોડને એક્ઝિક્યુટ કરો

1C માં વપરાશકર્તા ઇન્ટરફેસનું વર્ણન દ્રશ્ય સંપાદકમાં કરવામાં આવ્યું છે, પરંતુ ઘોષણાત્મક રીતે, તત્વોની પિક્સેલ-બાય-પિક્સેલ ગોઠવણી વિના; લગભગ ત્રણ ડઝન પ્રકારનાં ઇન્ટરફેસ તત્વોનો ઉપયોગ થાય છે - બટનો, ઇનપુટ ફીલ્ડ્સ (ટેક્સ્ટ, આંકડાકીય, તારીખ/સમય), યાદીઓ, કોષ્ટકો, આલેખ વગેરે.

1C ભાષામાં ક્લાયન્ટ કોડ સર્વર કૉલ્સ, સ્થાનિક સંસાધનો (ફાઈલો, વગેરે), પ્રિન્ટિંગ અને ઘણું બધું સમાવી શકે છે.

બંને પાતળા ક્લાયંટ (વેબ દ્વારા કામ કરતી વખતે) અને વેબ ક્લાયંટ 1C એપ્લિકેશન સર્વર સાથે વાતચીત કરવા માટે સમાન વેબ સેવાઓનો ઉપયોગ કરે છે. ક્લાયંટ અમલીકરણ, અલબત્ત, અલગ છે - પાતળા ક્લાયંટ C++ માં લખાયેલ છે, વેબ ક્લાયંટ JavaScript માં લખાયેલ છે.

ઇતિહાસ એક બીટ

વેબ ક્લાયંટ પ્રોજેક્ટ 2006 માં શરૂ થયો હતો, જેમાં (સરેરાશ) 5 લોકોની ટીમ હતી. પ્રોજેક્ટના ચોક્કસ તબક્કામાં, વિકાસકર્તાઓ ચોક્કસ કાર્યક્ષમતા (સ્પ્રેડશીટ દસ્તાવેજ, આકૃતિઓ, વગેરે) ને અમલમાં મૂકવા માટે સામેલ હતા; એક નિયમ તરીકે, આ તે જ વિકાસકર્તાઓ હતા જેમણે પાતળા ક્લાયંટમાં આ કાર્યક્ષમતા કરી હતી. તે. વિકાસકર્તાઓએ જાવાસ્ક્રિપ્ટમાં ઘટકોને ફરીથી લખ્યા જે તેઓએ અગાઉ C++ માં બનાવ્યા હતા.

શરૂઆતથી જ, અમે બે ભાષાઓ વચ્ચેના મજબૂત વૈચારિક તફાવતોને કારણે C++ પાતળા ક્લાયંટ કોડના જાવાસ્ક્રિપ્ટ વેબ ક્લાયંટમાં કોઈપણ સ્વચાલિત (આંશિક પણ) રૂપાંતરનો વિચાર નકારી કાઢ્યો હતો; વેબ ક્લાયંટ જાવાસ્ક્રિપ્ટમાં શરૂઆતથી લખાયેલું હતું.

પ્રોજેક્ટના પ્રથમ પુનરાવર્તનોમાં, વેબ ક્લાયન્ટે બિલ્ટ-ઇન 1C ભાષામાં ક્લાયન્ટ કોડને સીધા JavaScriptમાં કન્વર્ટ કર્યો. પાતળા ક્લાયંટ અલગ રીતે કાર્ય કરે છે - બિલ્ટ-ઇન 1C ભાષામાં કોડ બાઇટકોડમાં કમ્પાઇલ કરવામાં આવે છે, અને પછી આ બાઇટકોડ ક્લાયંટ પર અર્થઘટન કરવામાં આવે છે. ત્યારબાદ, વેબ ક્લાયંટે તે જ કરવાનું શરૂ કર્યું - પ્રથમ, તેણે પ્રદર્શનમાં વધારો કર્યો, અને બીજું, તે પાતળા અને વેબ ક્લાયંટના આર્કિટેક્ચરને એકીકૃત કરવાનું શક્ય બનાવ્યું.

1C નું પ્રથમ સંસ્કરણ: વેબ ક્લાયંટ સપોર્ટ સાથે એન્ટરપ્રાઇઝ પ્લેટફોર્મ 2009 માં બહાર પાડવામાં આવ્યું હતું. તે સમયે વેબ ક્લાયંટ 2 બ્રાઉઝર્સને સપોર્ટ કરતું હતું - ઇન્ટરનેટ એક્સપ્લોરર અને ફાયરફોક્સ. મૂળ યોજનાઓમાં ઓપેરા માટે સપોર્ટનો સમાવેશ થતો હતો, પરંતુ તે સમયે ઓપેરામાં એપ્લીકેશન બંધ કરવાના હેન્ડલરો સાથેની અગણિત સમસ્યાઓને કારણે (એપ્લિકેશન બંધ થઈ રહી હોવાની 100% નિશ્ચિતતા સાથે ટ્રૅક કરવું શક્ય નહોતું અને તે સમયે તેમાંથી ડિસ્કનેક્શનની પ્રક્રિયા હાથ ધરે છે. આ યોજનાઓમાંથી 1C એપ્લિકેશન સર્વર) છોડી દેવાનું હતું.

પ્રોજેક્ટ માળખું

કુલ મળીને, 1C:Enterprise પ્લેટફોર્મ પાસે JavaScript માં લખેલા 4 પ્રોજેક્ટ છે:

1. વેબટૂલ્સ - અન્ય પ્રોજેક્ટ્સ દ્વારા ઉપયોગમાં લેવાતી વહેંચાયેલ લાઇબ્રેરીઓ (અમે પણ શામેલ કરીએ છીએ ગૂગલ ક્લોઝર લાઇબ્રેરી).
2. નિયંત્રણ ફોર્મેટ કરેલ દસ્તાવેજ (જાવાસ્ક્રિપ્ટમાં પાતળા ક્લાયંટ અને વેબ ક્લાયંટ બંનેમાં અમલમાં મૂકાયેલ છે)
3. નિયંત્રણ શેડ્યૂલર (જાવાસ્ક્રિપ્ટમાં પાતળા ક્લાયંટ અને વેબ ક્લાયંટ બંનેમાં અમલમાં મૂકાયેલ છે)
4. વેબ ક્લાયંટ

દરેક પ્રોજેક્ટનું માળખું જાવા પ્રોજેક્ટ્સ (અથવા .NET પ્રોજેક્ટ્સ - જે નજીક હોય) ની રચના જેવું લાગે છે; અમારી પાસે નેમસ્પેસ છે, અને દરેક નેમસ્પેસ અલગ ફોલ્ડરમાં છે. ફોલ્ડરની અંદર ફાઇલો અને નેમસ્પેસ વર્ગો છે. વેબ ક્લાયન્ટ પ્રોજેક્ટમાં લગભગ 1000 ફાઇલો છે.

માળખાકીય રીતે, વેબ ક્લાયંટ મોટાભાગે નીચેની સબસિસ્ટમમાં વહેંચાયેલું છે:

• સંચાલિત ક્લાયંટ એપ્લિકેશન ઇન્ટરફેસ
  • સામાન્ય એપ્લિકેશન ઇન્ટરફેસ (સિસ્ટમ મેનુ, પેનલ્સ)
  • મેનેજ્ડ ફોર્મ્સનું ઇન્ટરફેસ, અન્ય વસ્તુઓની સાથે, લગભગ 30 નિયંત્રણો (બટનો, વિવિધ પ્રકારના ઇનપુટ ક્ષેત્રો - ટેક્સ્ટ, આંકડાકીય, તારીખ/સમય, વગેરે, કોષ્ટકો, સૂચિઓ, આલેખ વગેરે) સહિત.

• ક્લાયંટ પર વિકાસકર્તાઓ માટે ઑબ્જેક્ટ મોડલ ઉપલબ્ધ છે (કુલ 400 થી વધુ પ્રકારો: મેનેજ્ડ ઇન્ટરફેસ ઑબ્જેક્ટ મોડલ, ડેટા લેઆઉટ સેટિંગ્સ, શરતી સ્ટાઇલ વગેરે.)
• બિલ્ટ-ઇન 1C ભાષાના દુભાષિયા
• બ્રાઉઝર એક્સ્ટેન્શન્સ (જાવાસ્ક્રિપ્ટમાં સમર્થિત નથી કાર્યક્ષમતા માટે વપરાય છે)
  • ક્રિપ્ટોગ્રાફી સાથે કામ કરવું
  • ફાઈલો સાથે કામ
  • બાહ્ય ઘટકોની તકનીક, તેમને પાતળા અને વેબ ક્લાયંટ બંનેમાં ઉપયોગમાં લેવાની મંજૂરી આપે છે

વિકાસ સુવિધાઓ

JavaScript માં ઉપરોક્ત તમામનો અમલ સરળ નથી. કદાચ 1C વેબ ક્લાયંટ એ JavaScript માં લખેલી સૌથી મોટી ક્લાયન્ટ-સાઇડ એપ્લિકેશન્સમાંની એક છે - લગભગ 450.000 રેખાઓ. અમે વેબ ક્લાયંટ કોડમાં ઑબ્જેક્ટ-ઓરિએન્ટેડ અભિગમનો સક્રિયપણે ઉપયોગ કરીએ છીએ, જે આટલા મોટા પ્રોજેક્ટ સાથે કામ કરવાનું સરળ બનાવે છે.

ક્લાયંટ કોડના કદને ઘટાડવા માટે, અમે સૌપ્રથમ અમારા પોતાના ઓબ્ફસ્કેટરનો ઉપયોગ કર્યો, અને પ્લેટફોર્મ સંસ્કરણ 8.3.6 (ઓક્ટોબર 2014) થી શરૂ કરીને અમે ઉપયોગ કરવાનું શરૂ કર્યું. ગૂગલ ક્લોઝર કમ્પાઈલર. સંખ્યાઓમાં ઉપયોગની અસર – અસ્પષ્ટતા પછી વેબ ક્લાયંટ ફ્રેમવર્કનું કદ:

• પોતાનું ઓબ્ફસ્કેટર – 1556 kb
• ગૂગલ ક્લોઝર કમ્પાઈલર – 1073 kb

ગૂગલ ક્લોઝર કમ્પાઈલરનો ઉપયોગ કરવાથી વેબ ક્લાયંટના પ્રદર્શનને અમારા પોતાના ઓબ્ફસ્કેટરની સરખામણીમાં 30% સુધારવામાં મદદ મળી છે. વધુમાં, એપ્લિકેશન દ્વારા ઉપયોગમાં લેવાતી મેમરીની માત્રામાં 15-25% (બ્રાઉઝર પર આધાર રાખીને) ઘટાડો થયો છે.

Google Closure Compiler ઑબ્જેક્ટ-ઓરિએન્ટેડ કોડ સાથે ખૂબ જ સારી રીતે કામ કરે છે, તેથી વેબ ક્લાયન્ટ માટે તેની કાર્યક્ષમતા શક્ય તેટલી ઊંચી છે. ક્લોઝર કમ્પાઈલર અમારા માટે કેટલીક સારી બાબતો કરે છે:

• પ્રોજેક્ટ બિલ્ડ સ્ટેજ પર સ્ટેટિક ટાઈપ ચેકિંગ (સુનિશ્ચિત કરે છે કે અમે JSDoc એનોટેશન સાથે કોડને આવરી લઈએ છીએ). પરિણામ સ્થિર ટાઈપિંગ છે, જે C++ માં ટાઈપ કરવાની ખૂબ નજીક છે. આ પ્રોજેક્ટ સંકલન તબક્કે ભૂલોની એકદમ મોટી ટકાવારી પકડવામાં મદદ કરે છે.
• અસ્પષ્ટતા દ્વારા કોડનું કદ ઘટાડવું
• એક્ઝિક્યુટેડ કોડના સંખ્યાબંધ ઑપ્ટિમાઇઝેશન, ઉદાહરણ તરીકે, જેમ કે:
  • ઇનલાઇન ફંક્શન અવેજી. JavaScript માં ફંક્શનને કૉલ કરવું એ એકદમ ખર્ચાળ ઑપરેશન છે, અને વારંવાર ઉપયોગમાં લેવાતી નાની પદ્ધતિઓના ઇનલાઇન અવેજીકરણ કોડને નોંધપાત્ર રીતે ઝડપી બનાવે છે.
  • કમ્પાઇલ સમયે સ્થિરાંકોની ગણતરી. જો કોઈ અભિવ્યક્તિ સ્થિરાંક પર આધાર રાખે છે, તો સ્થિરાંકનું વાસ્તવિક મૂલ્ય તેમાં બદલવામાં આવશે

અમે વેબસ્ટોર્મનો ઉપયોગ અમારા વેબ ક્લાયંટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટ તરીકે કરીએ છીએ.

કોડ વિશ્લેષણ માટે અમે ઉપયોગ કરીએ છીએ સોનારક્યૂબ, જ્યાં અમે સ્ટેટિક કોડ વિશ્લેષકોને એકીકૃત કરીએ છીએ. વિશ્લેષકોનો ઉપયોગ કરીને, અમે JavaScript સ્રોત કોડની ગુણવત્તાના અધોગતિનું નિરીક્ષણ કરીએ છીએ અને તેને રોકવાનો પ્રયાસ કરીએ છીએ.

અમે કઈ સમસ્યાઓ હલ કરી/શું?

પ્રોજેક્ટના અમલીકરણ દરમિયાન, અમને ઘણી રસપ્રદ સમસ્યાઓનો સામનો કરવો પડ્યો જે અમારે હલ કરવાની હતી.

સર્વર સાથે અને વિન્ડોઝ વચ્ચે ડેટાની આપલે કરો

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

• ડેટા સ્ટ્રક્ચરના રૂપમાં સર્વરમાંથી આવતો કોડ
• બીજી એપ્લિકેશન વિન્ડો માટે કોડ

સર્વર સાથે ક્રિયાપ્રતિક્રિયા કરતી વખતે અસ્પષ્ટતાને ટાળવા માટે, અમે @expose ટેગનો ઉપયોગ કરીએ છીએ:

/**
 * @constructor
 * @extends {Base.SrvObject}
 */
Srv.Core.GenericException = function ()
{
    /**
     * @type {string}
     * @expose
     */
    this.descr;

    /**
     * @type {Srv.Core.GenericException}
     * @expose
     */
    this.inner;

    /**
     * @type {string}
     * @expose
     */
    this.clsid;

    /**
     * @type {boolean}
     * @expose
     */
    this.encoded;
}

અને અન્ય વિન્ડો સાથે ક્રિયાપ્રતિક્રિયા કરતી વખતે અસ્પષ્ટતાને ટાળવા માટે, અમે કહેવાતા નિકાસ કરેલ ઇન્ટરફેસનો ઉપયોગ કરીએ છીએ (ઇન્ટરફેસ જેમાં બધી પદ્ધતિઓ નિકાસ કરવામાં આવે છે).

/**
 * Экспортируемый интерфейс контрола DropDownWindow
 *
 * @interface
 * @struct
 */
WebUI.IDropDownWindowExp = function(){}

/**
 * Перемещает выделение на 1 вперед или назад
 *
 * @param {boolean} isForward
 * @param {boolean} checkOnly
 * @return {boolean}
 * @expose
 */
WebUI.IDropDownWindowExp.prototype.moveMarker = function (isForward, checkOnly){}

/**
 * Перемещает выделение в начало или конец
 *
 * @param {boolean} isFirst
 * @param {boolean} checkOnly
 * @return {boolean}
 * @expose
 */
WebUI.IDropDownWindowExp.prototype.moveMarkerTo = function (isFirst, checkOnly){}

/**
 * @return {boolean}
 * @expose
 */
WebUI.IDropDownWindowExp.prototype.selectValue = function (){}

અમે વર્ચ્યુઅલ DOM નો ઉપયોગ મુખ્ય પ્રવાહમાં બનતા પહેલા)

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

વેબ ક્લાયંટને ઑપ્ટિમાઇઝ કરવું

અમારા વેબ ક્લાયંટને વધુ ઝડપી બનાવવા માટે, અમે પ્રમાણભૂત બ્રાઉઝર ક્ષમતાઓ (CSS, વગેરે) નો મહત્તમ ઉપયોગ કરવાનો પ્રયાસ કરીએ છીએ. આમ, ફોર્મ કમાન્ડ પેનલ (એપ્લિકેશનના લગભગ દરેક ફોર્મ પર સ્થિત છે) CSS પર આધારિત ડાયનેમિક લેઆઉટનો ઉપયોગ કરીને બ્રાઉઝર ટૂલ્સનો ઉપયોગ કરીને રેન્ડર કરવામાં આવે છે.

પરીક્ષણ

કાર્યાત્મક અને પ્રદર્શન પરીક્ષણ માટે, અમે માલિકીનું સાધન (જાવા અને C++ માં લખાયેલ) તેમજ ટોચ પર બનેલા પરીક્ષણોના સ્યુટનો ઉપયોગ કરીએ છીએ સેલેનિયમ.

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

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

અમારું પરીક્ષણ સાધન અને પરીક્ષણ હેઠળની એપ્લિકેશન

અમારું સાધન અને સેલેનિયમ એકબીજાના પૂરક છે; ઉદાહરણ તરીકે, જો કોઈ એક સ્ક્રીન પરના કેટલાક બટને તેનું સ્થાન બદલ્યું હોય, તો સેલેનિયમ કદાચ આને ટ્રૅક કરી શકશે નહીં, પરંતુ અમારું ટૂલ નોટિસ કરશે, કારણ કે સ્ટાન્ડર્ડ સાથે સ્ક્રીનશૉટની પિક્સેલ-બાય-પિક્સેલ સરખામણી કરે છે. ટૂલ કીબોર્ડ અથવા માઉસમાંથી ઇનપુટની પ્રક્રિયામાં સમસ્યાઓને ટ્રૅક કરવામાં પણ સક્ષમ છે, કારણ કે આ તે બરાબર છે જે તે પુનઃઉત્પાદન કરે છે.

બંને ટૂલ્સ (અમારા અને સેલેનિયમ) પરના પરીક્ષણો અમારા એપ્લિકેશન સોલ્યુશન્સમાંથી લાક્ષણિક કાર્ય દૃશ્યો ચલાવે છે. 1C:Enterprise પ્લેટફોર્મના દૈનિક નિર્માણ પછી પરીક્ષણો આપમેળે શરૂ થાય છે. જો સ્ક્રિપ્ટ્સ ધીમી હોય (અગાઉની બિલ્ડની સરખામણીમાં), તો અમે તપાસ કરીએ છીએ અને મંદીના કારણને ઉકેલીએ છીએ. અમારો માપદંડ સરળ છે - નવું બિલ્ડ પાછલા એક કરતા ધીમા કામ ન કરવું જોઈએ.

વિકાસકર્તાઓ મંદીની ઘટનાઓની તપાસ કરવા માટે વિવિધ સાધનોનો ઉપયોગ કરે છે; મુખ્યત્વે વપરાય છે Dynatrace AJAX આવૃત્તિ ઉત્પાદન કંપની ડાયનાટ્રેસ. અગાઉના અને નવા બિલ્ડ્સ પર સમસ્યારૂપ કામગીરીના અમલના લોગ રેકોર્ડ કરવામાં આવે છે, પછી લોગનું વિશ્લેષણ કરવામાં આવે છે. તે જ સમયે, સિંગલ ઑપરેશન્સ (મિલિસેકન્ડ્સમાં) એક્ઝેક્યુશનનો સમય નિર્ણાયક પરિબળ હોઈ શકતો નથી - કચરો સંગ્રહ જેવી સેવા પ્રક્રિયાઓ સમયાંતરે બ્રાઉઝરમાં શરૂ કરવામાં આવે છે, તે કાર્યોના અમલના સમય સાથે ઓવરલેપ થઈ શકે છે અને ચિત્રને વિકૃત કરી શકે છે. આ કિસ્સામાં વધુ સુસંગત પરિમાણો અમલમાં મૂકાયેલ JavaScript સૂચનાઓની સંખ્યા, DOM પર અણુ કામગીરીની સંખ્યા વગેરે હશે. જો નવી આવૃત્તિમાં સમાન સ્ક્રિપ્ટમાં સૂચનાઓ/ઓપરેશન્સની સંખ્યામાં વધારો થયો હોય, તો તેનો અર્થ હંમેશા પ્રભાવમાં ઘટાડો થાય છે જેને સુધારવાની જરૂર છે.

ઉપરાંત, કાર્યક્ષમતામાં ઘટાડાનું એક કારણ એ પણ હોઈ શકે છે કે Google ક્લોઝર કમ્પાઈલર કોઈ કારણસર ફંક્શનનું ઇનલાઇન અવેજીકરણ કરવામાં અસમર્થ હતું (ઉદાહરણ તરીકે, કારણ કે ફંક્શન પુનરાવર્તિત અથવા વર્ચ્યુઅલ છે). આ કિસ્સામાં, અમે સ્રોત કોડને ફરીથી લખીને પરિસ્થિતિને સુધારવાનો પ્રયાસ કરીએ છીએ.

બ્રાઉઝર એક્સ્ટેન્શન્સ

જ્યારે એપ્લિકેશન સોલ્યુશનને કાર્યક્ષમતાની જરૂર હોય જે JavaScriptમાં ઉપલબ્ધ નથી, ત્યારે અમે બ્રાઉઝર એક્સટેન્શનનો ઉપયોગ કરીએ છીએ:

• ફાઇલો સાથે કામ કરવા માટે
• ક્રિપ્ટોગ્રાફી સાથે કામ કરવા માટે
• સાથે કામ કરો બાહ્ય ઘટકો

અમારા એક્સ્ટેંશન બે ભાગો ધરાવે છે. પ્રથમ ભાગને બ્રાઉઝર એક્સ્ટેંશન કહેવામાં આવે છે (સામાન્ય રીતે જાવાસ્ક્રિપ્ટમાં લખાયેલ ક્રોમ અને ફાયરફોક્સ માટેના એક્સ્ટેંશન), જે બીજા ભાગ સાથે ક્રિયાપ્રતિક્રિયા કરે છે - એક બાઈનરી એક્સ્ટેંશન જે આપણને જોઈતી કાર્યક્ષમતાને અમલમાં મૂકે છે. તે ઉલ્લેખ કરવો જોઈએ કે અમે બાઈનરી એક્સ્ટેંશનના 3 સંસ્કરણો લખીએ છીએ - Windows, Linux અને MacOS માટે. બાઈનરી એક્સ્ટેંશન 1C:Enterprise પ્લેટફોર્મના ભાગ રૂપે પૂરું પાડવામાં આવે છે અને તે 1C એપ્લિકેશન સર્વર પર સ્થિત છે. જ્યારે વેબ ક્લાયંટમાંથી પ્રથમ વખત કૉલ કરવામાં આવે છે, ત્યારે તે ક્લાયંટ કમ્પ્યુટર પર ડાઉનલોડ થાય છે અને બ્રાઉઝરમાં ઇન્સ્ટોલ થાય છે.

જ્યારે Safari માં ચાલી રહ્યું હોય, ત્યારે અમારા એક્સ્ટેન્શન્સ NPAPI નો ઉપયોગ કરે છે; જ્યારે Internet Explorer માં ચાલે છે, ત્યારે તેઓ ActiveX ટેક્નોલોજીનો ઉપયોગ કરે છે. માઈક્રોસોફ્ટ એડ હજી સુધી એક્સ્ટેંશનને સપોર્ટ કરતું નથી, તેથી તેમાં વેબ ક્લાયંટ પ્રતિબંધો સાથે કામ કરે છે.

વધુ વિકાસ

વેબ ક્લાયંટ ડેવલપમેન્ટ ટીમ માટેનું એક કાર્ય કાર્યક્ષમતાનો વધુ વિકાસ છે. વેબ ક્લાયંટની કાર્યક્ષમતા પાતળા ક્લાયંટની કાર્યક્ષમતા જેવી જ હોવી જોઈએ; બધી નવી કાર્યક્ષમતા પાતળા અને વેબ ક્લાયંટ બંનેમાં એકસાથે લાગુ કરવામાં આવે છે.

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

સોર્સ: www.habr.com