એકવાર તમારી પાસે એક HTML ફોર્મ અપ અને ચાલતું જાય, તો તમે ઘણીવાર ખાતરી કરો કે તમામ મહત્વપૂર્ણ ક્ષેત્રો ભરવામાં આવે છે. ઉદાહરણ તરીકે, જો તમે ઇમેઇલ પુષ્ટિકરણ પત્ર મોકલવા જઈ રહ્યા હોવ, તો ઇમેઇલ સરનામું ફોર્મ ફીલ્ડ્સમાં શામેલ થવું જોઈએ , અને તે એક ઇમેઇલ સરનામું હોવું જોઈએ જે કાર્ય કરે છે
તમારા સ્વરૂપોને માન્ય કરવાની બે રીત છે:
- જાવાસ્ક્રિપ્ટ વાપરી રહ્યા છે
- CGI સ્ક્રિપ્ટનો ઉપયોગ કરવો
ફોર્મ્સ માન્ય કરવા માટે જાવાસ્ક્રીપ્ટનો ઉપયોગ કરવાના ગુણ
- JavaScript નો ઉપયોગ કરીને તમે કોઈપણ સર્વર પ્રોસેસર સમયનો ઉપયોગ કરતા નથી. બધા પ્રક્રિયા ક્લાઈન્ટ કમ્પ્યુટર પર કરવામાં આવે છે.
- તે ઘણીવાર સીજીઆઈ માન્યતા કરતા વધુ ઝડપથી કાર્ય કરે છે.
- કારણ કે ફોર્મ પૃષ્ઠ બદલાયું નથી, વાચકોને ભૂલો સુધારવા માટે સરળ છે.
ફોર્મ્સ માન્ય કરવા માટે જાવાસ્ક્રીપ્ટનો ઉપયોગ કરવાનું વિપક્ષ
- જાવાસ્ક્રીપ્ટ ફક્ત બ્રાઉઝર્સ પર કામ કરે છે કે જે તે સક્ષમ કરે છે. જો જાવાસ્ક્રિપ્ટ અક્ષમ છે, તો તમારી ભૂલ તપાસ થઈ નથી.
ફોર્મ્સ માન્ય કરવા માટે CGI નો ઉપયોગ કરવાના ગુણ
- માન્ય કરવા માટે CGI નો ઉપયોગ કરીને દર વખતે ફોર્મ સબમિટ કરવામાં આવે છે તેની ખાતરી કરે છે, માન્યતા ચાલશે.
માન્યતાપ્રાપ્ત ફોર્મ માટે CGI નો ઉપયોગની વિરુદ્ધ
- CGI વેબ સર્વર પર વધુ ભાર મૂકે છે, અને CGI માં શામેલ કરેલ દરેક કાર્ય સર્વર માટે એક વધુ કાર્ય છે.
- CGI ચલાવવા માટે ધીમું હોઈ શકે છે
- જો કોઈ ભૂલ હોય તો, ગ્રાહકને ફોર્મના પ્રથમ પૃષ્ઠ પર પાછા જવું જોઈએ, અથવા ફોર્મ પૃષ્ઠને ફરીથી લખવા માટે CGI ને અન્ય કાર્યની જરૂર છે.
જે રીતે હું હેન્ડલ કરું છું તે છે મોટાભાગની ભૂલ ચકાસણી જાવાસ્ક્રિપ્ટ સાથે કરવામાં આવે છે. આ રીતે, તે વાચકો માટે ઝડપી અને સરળ છે.
હું પછી CGI સાથે ફોર્મના મહત્વના ઘટકોને ફરી તપાસો.
એચટીએમએલ ફોર્મ માન્ય કરવા માટે જાવાસ્ક્રિપ્ટ કેવી રીતે વાપરવી
ફોર્મ માન્યતા બનાવવાનું મૂળભૂત ખાતરી ફોર્મ તત્વોના નામ શોધવાનું છે જે જરૂરી છે, અને જો તે ખાલી હોય, તો ભૂલ સંદેશો દર્શાવો.
મોટા ભાગના ભૂલ ચકાસણી પ્રોગ્રામ્સ એક સમયે દરેક ક્ષેત્રને તપાસે છે, અને એક સમયે એક ભૂલ પ્રદર્શિત કરે છે.
આ ફોર્મ કંટાળાજનક ભરીને કરી શકે છે, અને લોકો મધ્યમાં બંધ થઈ શકે છે જો તમે નીચેની સ્ક્રિપ્ટ અને પર્લ સ્રોતનો ઉપયોગ કરો છો, તો તમે જાણશો કે એક જ સમયે એક સંપૂર્ણ ફોર્મ કેવી રીતે માન્ય કરવું, ભૂલ સંદેશાઓની શ્રેણી પ્રદર્શિત કરી જે તમારા રીડર પછી પાછા જઈ શકે છે અને ઠીક કરી શકે છે.
એક ફોર્મ માન્ય કરવા માટે જાવાસ્ક્રિપ્ટ
તમારા HTML ના વડા ભાગમાં, તમારે ફોર્મ માન્યતા કરવા માટે સ્ક્રિપ્ટ બનાવવી જોઈએ:
- સ્ક્રિપ્ટ સેટ કરો અને ખાતરી કરો કે તે બ્રાઉઝર્સથી છુપાયેલ છે જે જાવાસ્ક્રિપ્ટને નિયંત્રિત કરી શકતા નથી. <સ્ક્રિપ્ટ ભાષા = "જાવાસ્ક્રિપ્ટ">
- આ ફંક્શન કોલ છે જે માન્યતા શરૂ કરે છે. તમારી સ્ક્રિપ્ટના શીર્ષ પર તમારી ચલોને સેટ કરવા માટે તે સારું ફોર્મ છે
વિધેય વેલિડેટર (ધફોર્મ)
{var ભૂલ = ""; - જો તમે તમારા ફોર્મ્સમાં ડ્રોપ-ડાઉન તત્વો ધરાવતા હો, તો તમારે ખાલી ફીલ્ડ (દા.ત. <વિકલ્પ મૂલ્ય = ""> એક પસંદ કરો option>) તરીકે પ્રથમ વિકલ્પ શામેલ કરવું જોઈએ. તમે કોઈ પણ ટેક્સ્ટ શામેલ કરી શકો છો જે તમને ફીલ્ડમાં ગમશે, જેમ કે જ્યાં સુધી કિંમત ખાલી છે પછી, જ્યારે તમે તેની સામે માન્ય કરો છો, ત્યારે ફક્ત એ જોવા માટે જુઓ કે પ્રથમ વિકલ્પ (ખાલી એક) હજુ પણ સેટ છે, જો તે હોય, તો ભૂલ સંદેશો લખો. જો (theForm.dd.options [0]. પસંદ થયેલ == સાચું)
{
error + = "ડ્રોપ-ડાઉન સૂચિમાંથી પસંદ કરો. \ n";} - ટેક્સ્ટ ઘટકો માન્ય કરવા માટે સૌથી સરળ છે. ફક્ત મૂલ્ય ખાલી છે તે જોવા માટે તપાસો. જો તે હોય, તો ભૂલ સંદેશો સેટ કરો. જો (theForm.words.value == "")
{
error + = "કૃપા કરીને ટેક્સ્ટ ઘટક ભરો. \ n";}
- જો તમે ટેક્સ્ટ ફીલ્ડમાં ડેટાના પ્રકારને માન્ય કરવા માંગતા હોવ, તો તમારે થોડું પારખુ મેળવવું પડશે. સ્ક્રિપ્ટના આ સ્નીપેટ ટેક્સ્ટ બૉક્સ પર દેખાય છે તે જોવા માટે કે તેમાં કોઈ ન્યુમેરિકલ અક્ષરો છે (ચલ "અંકો" વ્યાખ્યાયિત કરે છે કે તે શું શોધી રહ્યું છે).
var અંકો = "0123456789";
જો (theForm.number.value == "")
{
error + = "કૃપા કરીને કોઈ નંબર ભરો. \ n";
}
માટે (var i = 0; i
{
temp = theForm.number.value.substring (i, i + 1)
જો (digits.indexOf (temp) == -1 અને&Form.number.value! = "")
{
error + = "સંખ્યાત્મક ટેક્સ્ટ સંખ્યા હોવી જોઈએ. \ n";
વિરામ;
}}
જાવાસ્ક્રિપ્ટ સાથે એક ઇમેઇલ સરનામું માન્ય કરો
- સ્ક્રિપ્ટનો આ ભાગ ઇમેઇલ સરનામાં માટે કેવી રીતે માન્ય કરવું તે બતાવે છે. તે ખૂબ જ સરળ માન્યતા છે, તે ફક્ત ખાતરી કરવા માટે ચકાસે છે કે ત્યાં @ -sign અને સમયગાળો છે. લોકો હજી પણ નકલી ઇમેઇલ સરનામાંઓ મૂકી શકે છે, પરંતુ આ ખોટી એન્ટ્રીઝને થોડી ઓછી કરવામાં મદદ કરે છે.
જો (theForm.email.value == "")
{
error + = "તમારે પ્રતિક્રિયા માટે ચોક્કસ ઇમેઇલ સરનામું શામેલ કરવું આવશ્યક છે. \ n";
}
જો ((theForm.email.value.indexOf ('@', 0) == -1 ||
theForm.email.value.indexOf ('.', 0) == -1) && theForm.email.value! = "")
{
error + = "કૃપા કરીને ચકાસો કે તમારું ઇમેઇલ સરનામું માન્ય છે.";
}
- આ સ્ક્રિપ્ટનું માંસ છે. તે બે બાબતો કરે છે: પ્રથમ, તે એ જોવા માટે ચકાસે છે કે શું ભૂલ સેટ છે. જો ત્યાં છે, તો તે તેને ચેતવણી સંદેશ તરીકે પ્રદર્શિત કરે છે. પછી તે ખોટા વળતરની કિંમત મોકલે છે જેથી ફોર્મ માહિતી સર્વર પર મોકલવામાં ન આવે. તમારા ભૂલ સંદેશાઓ (જો નિવેદનો પર ઉપરોક્ત સેટ હોય તો), બધામાં રેખાના અંતે "\ n" શામેલ છે. આ રેખાના અંતે વાહન વળતર (અથવા "દાખલ કરો" અથવા "નવી લાઇન") દાખલ કરવા બ્રાઉઝરને કહે છે પછી, જો ત્યાં કેટલાક ભૂલ સંદેશાઓ છે તો તે બધા અલગ લીટીઓ પર હશે જો કોઈ ભૂલ સંદેશાઓ સેટ ન હોય, તો ભૂલ વેરિયેબલ ખાલી હશે (જ્યાંથી આપણે તેને સ્ક્રિપ્ટની ટોચ પર સેટ કરીશું), અને તેથી ફોર્મ માહિતી CGI દ્વારા કાર્યરત કરવા સર્વર પર મોકલવામાં આવશે.
જો (ભૂલ! = "")
{
ચેતવણી (ભૂલ);
વળતર (ખોટા);
} બીજું {
પરત (સત્ય);
} - તમારી સ્ક્રિપ્ટ બંધ કરવાનું ભૂલશો નહીં
}
// -> script>
પછી, સ્ક્રિપ્ટને કૉલ કરવા માટે, ફોર્મ ટેગમાં ઑન્સ્યુમિમિટ ઘટક મૂકો:
ફોર્મ્સ માન્ય કરવા માટે CGI
આ પર્લ સ્ક્રીપ્ટ CGI સ્નિપેટ જાવાસ્ક્રિપ્ટ જેવું જ છે. તે જોવા માટે ચકાસે છે કે જો જરૂરી ફીલ્ડ્સ છે, અને જો ન હોય, તો ડિસ્પ્લે માટે વેરિયેબલમાં એરર મેસેજ બચાવે છે:
#! / usr / local / bin / perl
$ error = "";
જો ($ '{' dd '} eq "$")
{
$ error + = "
કૃપા કરીને ડ્રોપ ડાઉન બૉક્સમાંથી પસંદ કરો.
";
}
જો ({'શબ્દો'} માં "$")
{
$ error + = "
કૃપા કરીને ટેક્સ્ટ બૉક્સમાં કેટલાક શબ્દો શામેલ કરો.
";
}
# ... બધા ક્ષેત્રોને માન્ય કરવાનું ચાલુ રાખો
જો ($ ભૂલ)
છાપો "સામગ્રી-પ્રકાર: ટેક્સ્ટ / html \ n \ n";
પ્રિન્ટ "
પ્રિન્ટ " head>
પ્રિન્ટ " એક ભૂલ આવી છે h2>";
પ્રિન્ટ $ ભૂલ;
પ્રિન્ટ "પાછળ જાઓ અને આ ભૂલો સુધારવા.";
પ્રિન્ટ " body> html>";
} બીજું {
# CGI સાથે જાઓ ...
}
સીજીઆઈ ભૂલ સંદેશો લખે છે તે સાથેનો તફાવત એ છે કે "\ n" ને બદલે, તે દરેક ફકરામાં નવી રેખા મૂકવા માટે HTML ફકરા ટેગનો ઉપયોગ કરે છે.
અને હવે તમે તમારું ફોર્મ માન્ય કર્યું છે
બે પદ્ધતિઓ સાથે, સીજીઆઈ અને જાવાસ્ક્રિપ્ટ, તમે એક HTML ફોર્મ માન્ય કર્યું છે જેથી તમને મોકલવામાં આવેલા ભાગો વધુ ચોક્કસ હોય.