શું આધુનિક PHP માં હજુ પણ સુસંગત છે? આધુનિક PHP માં હજુ પણ સંબંધિત બીટવર્ડ ઓપરેટર્સ સંબંધિત છે? સંબંધિત વિષયો: દાખલાઓ & amp; પ્રેક્ટિસ ડીબગિંગ અને amp; મીમલ્ટ
શું આધુનિક PHP માં હજુ પણ સુસંગત છે? આધુનિક PHP માં હજુ પણ સંબંધિત બીટવર્ડ ઓપરેટર્સ સંબંધિત છે? સંબંધિત વિષયો: દાખલાઓ & પ્રેક્ટિસ ડીબગિંગ અને & મીમલ્ટ
શું બીટીવી ઓપરેટર્સ હજુ પણ આધુનિક PHP માં સંબંધિત છે?
તમારામાંના ઘણાએ તમારા માથાને આ શીર્ષક વાંચીને ઉઝરડા કરી છે. "બીટવાહત?"
આ લેખમાં, આપણે કયા બીટવુ ઓપરેટરો છીએ તે જોશું, અને તેનો ઉપયોગ કમ્પ્યુટિંગના આ આધુનિક યુગમાં હજુ પણ સુસંગત છે કે નહીં.
ઉદાહરણ કેસનો ઉપયોગ કરો
બિટવર્સ ઓપરેટર્સ અહીં સૂચિબદ્ધ છે, પરંતુ ખરેખર ઉદાહરણ ઘરને ચલાવવા માટે, અમે ફક્ત એક પર ધ્યાન કેન્દ્રિત કરીશું: ધ bitwise અને ( & ) એક ઉદાહરણ તે મારા માટે ક્લિક કરો તેથી આપણે આ કરીશું - સીધા ઉદાહરણમાં ડાઇવ કરો
કલ્પના કરો કે તમારી પાસે એવી વેબસાઇટ છે કે જેના પર આપેલ વપરાશકર્તાને ચોક્કસ પરવાનગીઓ હોઈ શકે છે. ઉદાહરણ તરીકે, સાઈટપેઈન્ટ જેવી સામયિક:
લેખક CRUD ડ્રાફ્ટ્સ, અને તેમના પ્રોફાઇલ સંપાદિત કરી શકો છો - ducray melascreen eclat soin eclaircissant spf15.
એડિટર, ઉપર, સીઆરયુડી ડ્રાફ્ટ્સ અને ફિનિશ્ડ પોસ્ટ, અને સીઆરયુડી લેખક પ્રોફાઇલ્સ ઉપરાંત,
સંચાલક, ઉપરોક્ત ઉપરાંત સંચાલક પરવાનગીઓ ઉમેરી શકો છો.
વપરાશકર્તાને બહુવિધ પરવાનગીઓ હોઈ શકે છે, ડેટાબેસમાં પરવાનગીઓને વ્યાખ્યાયિત કરવાના ઘણા માર્ગો છે અને તેની મદદથી સિસ્ટમ.
ડબલ જોડાઓ
રોલ્સ ઍડ કરો, પરવાનગીઓ ઉમેરો, જોડણી કોષ્ટકમાં ભૂમિકાઓ માટે પરવાનગીઓ જોડો, પછી બીજા જોડણી કોષ્ટક બનાવો અને કેટલાક વપરાશકર્તાઓને કેટલાક ભૂમિકાઓ જોડો.
આ અભિગમ ચાર વધારાના કોષ્ટકો બનાવે છે:
પરવાનગીઓ <-> ભૂમિકાઓ
ભૂમિકાઓ <-> વપરાશકર્તાઓ
ઓવરહેડનો કેટલોક ભાગ. સેમેલ્ટને આમાં ફેરફાર કરવા અથવા નિયમિતપણે કેટલાક વારંવાર મુલાકાત લેવાયેલા સૂચિમાં એપ્લિકેશનમાં તેમને સૂચિબદ્ધ કર્યા છે. માત્ર ભારે કેશીંગ આ એપ્લિકેશનને ભારે ભારથી ભાંગીથી બચાવશે.
જોકે, એક ફાયદો એ છે કે જટિલ પરવાનગીઓ સાથે ખરેખર ભૂમિકાઓને વ્યાખ્યાયિત કરીને, તમારે ફક્ત વપરાશકર્તાઓને ભૂમિકાઓમાં રોકવું પડશે અને તમે સારા છો - તે દર્શાવે છે કે કોષ્ટક પ્રકાશ અને ઝડપી જોડાય છે.
એક જોડાઓ
પરવાનગીઓ ઉમેરો, એક જોડ ટેબલ ઉમેરો, કેટલાક વપરાશકર્તાઓ માટે અમુક પરવાનગીઓ સાથે જોડે છે
આ અભિગમ બે વધારાના કોષ્ટકો બનાવે છે:
પરવાનગીઓ <-> વપરાશકર્તાઓ
પાછલા ઉદાહરણ કરતાં ઓછું ઓવરહેડ, પરંતુ તમારી પાસે જોડણી ટેબલમાં ઘણી વધુ એન્ટ્રીઓ છે કારણ કે વપરાશકર્તા પાસે ઘણી બધી પરવાનગીઓ હોઈ શકે છે (ફક્ત મુસદ્દાની માટે CRUD તેની પોતાની 4 પરવાનગીઓ છે). ઘણાં બધા વપરાશકર્તાઓ અને ઘણી બધી પરવાનગીઓ સાથે, આ ટેબલ ભારે ઝડપથી મેળવી શકે છે
ધ કૉલમ સ્ટેમ્પેડે
દરેક પરવાનગી માટે વપરાશકર્તા કોષ્ટકમાં એક કૉલમ ઉમેરો, પછી "ચાલુ" અથવા "બંધ" તરીકે પરવાનગી તપાસવા માટે તેના ડેટાટાઇપને એક ટિનિંટે (મૂળભૂત રીતે બુલિયન) બનાવો.
વપરાશકર્તા માટે સેમ્યુઅલ પરવાનગીઓ પછી કંઈક આના જેવી દેખાશે:
અપડેટ કરો 'વપરાશકર્તાઓ' SET `સંપાદિત કરોપ્રોફાઇલ` = 1,` કાઢી નાખવુંપ્રોફાઇલ` = 0, `બનાવોડ્રાફ્ટ` = 1,` પોસ્ટડ્રાફ્ટ` = 0.. જ્યાં `id` = 5
આ અભિગમ વધારાની કોષ્ટકો ઉમેરે છે, પરંતુ કોષ્ટકને વિશાળ કદમાં વિસ્તરે છે, અને નવી પરવાનગી ઉમેરવામાં આવે ત્યારે દર વખતે ડેટાબેઝમાં ફેરફાર કરવાની જરૂર પડે છે. જ્યારે તમે જાણો છો કે તમારી નજીકના ભવિષ્ય માટે સૌથી વધુ બે અથવા ત્રણ પરવાનગીઓ હશે, ત્યારે તે માટે દંડ અભિગમ અપનાવો, પરંતુ તે કરતાં વધુ કંઇ માટે ઉપયોગ ન કરવો જોઇએ.
મીમોલ્ટ, કારણ કે સ્તંભની સૂચિ, જ્યારે દૂરથી જોવામાં આવે છે, બાઈનરી નંબર (1010) ની જેમ દેખાય છે, આ અભિગમ બીજામાં એક ઉત્તમ સેગવે છે .
બિટિવર એપ્રોચ
મીમલ્ટ અમે આ અભિગમમાં ઊંડે છીએ, ચાલો બાઈનરીમાં ક્રેશ કોર્સ કરીએ.
બાઈનરી નંબર્સ
બધા કમ્પ્યુટર્સ બાઈનરી તરીકે ડેટા સ્ટોર કરે છે: 0 અથવા 1. તેથી, 14 નંબર વાસ્તવમાં સંગ્રહિત છે: 1110. તેથી 1337 નંબરનો અર્થ છે:
દશાંશ પદ્ધતિમાં દરેક અંકને (બેઝ 10) 10 દ્વારા ગુણાકાર થાય છે. પ્રથમ એક 1 છે, પછીની 10 છે, તે પછીના 100, પછીના 1000, વગેરે.
બાઈનરીમાં, બેઝ 2 છે, તેથી પ્રત્યેક અંક 2 દ્વારા ગુણાકાર થાય છે. તેથી 1110 નો નંબર છે:
મિમલ્ટ 2 + 4 + 8, જે 14 છે.
હા, બાઈનરી નંબરો દશાંશ કરવા માટે તે સરળ છે.
તેથી જયારે આપણે 1010 ની પહેલાનાં અમારા પરવાનગીઓના સ્તંભો પર નજર કરીએ છીએ, ત્યારે તે દ્વિસંગી સ્વરૂપમાં લખેલ નંબર 10 તરીકે પણ જોવામાં આવે છે. હમ્મ, કદાચ અમે અહીં કંઈક પર છો.
જો આપની પાસે 1010 ની પરવાનગીઓ છે, તો તેનો અર્થ એ કે બીજી અને ચોથી બીટ સુયોજિત છે, જ્યારે પ્રથમ અને ત્રીજા (કારણ કે તે 0 છે) નથી.
દ્વિસંગી ભાષામાં, અમે વાસ્તવમાં કહીએ છીએ કે 0 મી અને 2 જી બીટ્સ સેટ નથી, કારણ કે તેઓ 0 થી ગણાશે, જેમ કે એરે. આનું કારણ એ છે કે તેમના ક્રમાંક નંબર (1 લી, 2 જી, 3 જી) તેમના એક્સ્પિનન્ટને અનુરૂપ છે. 0 બીટ એ વાસ્તવમાં 2 ની 0 ની સત્તા છે (2 ^ 0) જે 1 બરાબર છે. પ્રથમ બીટ 2 ની 1 (2 ^ 1) ની સત્તા છે જે 2. 2 સેકંડ 2 સ્ક્વેર્ડ (2 ^ 2) છે જે બરાબર 4, વગેરે. આ રીતે તે બધા ખૂબ સરળ યાદ છે.
તો આ કેવી રીતે મદદ કરે છે?
ઠીક છે, દૂરથી પરવાનગીઓ જોઈને, અમે એક જ બાઈનરી નંબર સાથે એક જ સમયે તમામ કૉલમ્સ ની સ્થિતિનું પ્રતિનિધિત્વ કરી શકીએ છીએ. જો આપણે એક જ બાઈનરી નંબર સાથે એક જ સમયે તમામ કૉલમ્સનું પ્રતિનિધિત્વ કરી શકીએ, તો તેનો મતલબ છે કે દશાંશમાં અનુવાદિત થાય ત્યારે આપણે તેને એક જ પૂર્ણાંકથી પ્રતિનિધિત્વ કરી શકીએ છીએ!
જો અમારી પાસે એક પરવાનગીઓ સ્તંભ જેમાં મૂલ્ય 14 છે, તો હવે આપણે જાણીએ છીએ કે આ વાસ્તવમાં 1110 છે, અને અમે જાણીએ છીએ કે અમે ચારમાંથી ત્રણ પરવાનગીઓ છે! પરંતુ 3 આપણા 4?
પરવાનગીઓ નીચેના મેપિંગ મીઠું:
ફેરફારની પરવાનગીઓ
પ્રોફાઈલ એડિટ
પ્રોફાઈલ ડેલીટ
ડ્રાફ્ટ બનાવી
ડ્રાફ્ટ એડિટ
ડ્રાફ્ટ ડીલિટ
ડ્રાફ્ટ પબ્લિશીશ
સમાપ્ત સંપાદન
સમાપ્ત થયેલ ડિલિટ
દ્વિસંગીની સંખ્યા 1410 છે, પરંતુ ડાબેરી શૂન્યની સંખ્યા વાંધો નથી, તેથી અમે ટેબલમાં પરવાનગીઓની સંખ્યા સુધી પહોંચતા ત્યાં સુધી તેને પૅડ કરી શકીએ છીએ: 0000001110. આ હજી પણ 14 છે, ફક્ત પ્રતિનિધિ ઉપરોક્ત કોષ્ટકમાંથી પરવાનગીઓ. તમામ હેતુઓ અને હેતુઓ માટે, 0000001110 === 1110.
આ મુજબ, અમે જોઈ શકીએ છીએ કે 14 ની પરવાનગી સાથેના એકાઉન્ટમાં પરવાનગીઓ છે: ડ્રાફ્ટેડેડીટીઇટી , ડ્રાફટીપીપી , અને ફિનિશ્ડડિડીટ ). મંજૂર છે, વાસ્તવિક વિશ્વની અનુમતિ ગોઠવણની બરાબર પ્રતિનિધિ નથી, પરંતુ તે માત્ર એક ઉદાહરણ છે, જેના દ્વારા આપણે વિસ્તૃત કરી શકીએ છીએ કે જો કોઈ પાસે 1111111111 હોત તો, તેની પાસે બધી પરવાનગીઓ હશે (સંભવિત રીતે સંચાલક વપરાશકર્તા). દશાંશમાં, આ 1023 છે. તેથી, પરવાનગીઓ સ્તંભમાં મૂલ્ય 1023 ધરાવતી કોઈ વ્યક્તિ, તમામ પરવાનગીઓ ધરાવતી વ્યક્તિ છે.
પણ આપણે આ માટે અમારા કોડમાં કેવી રીતે તપાસ કરીશું? બીજા શબ્દોમાં કહીએ તો, આપણે કેવી રીતે જાણી શકીએ કે પરવાનગીની બીટ અથવા ન સુયોજિત છે, ખાસ કરીને જો કોઈ સંખ્યા દશાંશ તરીકે સંગ્રહિત થાય છે, અને દ્વિસંગી નથી?
તે બીટવ્યુ ઓપરેટરો છે - ખાસ કરીને એક એમ્પરસેન્ડ અને , જેને bitwise અને તરીકે પણ ઓળખવામાં આવે છે.256, 128, 64, 32, 16, 8, 4, 2, અથવા 1.
તમે ફક્ત તેમની કિંમત બદલીને અન્ય બીટ્સ માટે તપાસ કરી શકો છો.
ધ [વૈકલ્પિક] "ચાલો તકનિકી વિચાર" બાજુ-નોંધ
આ વિભાગીય વિભાગને અવગણો જો તમે જાણતા ન હોય કે આ ઓપરેટર, અથવા સમાન ઓપરેટરો કેવી રીતે કામ કરે છે, પરંતુ ઉદાહરણ સાથે ચાલુ રાખવા માટે માત્ર રસ છે.
જ્યારે અમે અને 512 અને પરવાનગીઓ કહીએ છીએ ત્યારે અમે આ ભાગને શોધી રહ્યાં છીએ અને સાચું હોઇએ છીએ, કારણ કે એસક્યુએલ ક્વેરીઝ કેવી રીતે કામ કરે છે તે - તેઓ શરતોનું મૂલ્યાંકન કરે છે અને તે પંક્તિઓ પરત કરે છે જે જરૂરિયાતો બાબતે સાચું પાછી આપે છે.
તેથી, 512 અને પરવાનગીઓ સાચું મૂલ્યાંકન છે. અમે જાણીએ છીએ કે કોઈ પણ શૂન્ય-કોઈ મૂલ્ય, તે એક પૂર્ણાંક હોવું જોઈએ, બુલિયન જે "સાચા" કહે છે, અથવા તે સ્ટ્રિંગ કે જે ખાલી નથી, તે વાસ્તવમાં "સાચું" તરીકે ગણવામાં આવે છે. તેથી 512 સાચું છે. 1 સાચું છે. 0 ખોટી છે. 128 સાચું છે. વગેરે.
512 એ બેઝ -10 પૂર્ણાંક છે, અને પરવાનગીઓ એક સ્તંભ છે જે બેઝ -10 પૂર્ણાંક ધરાવે છે. આ bitwise અને વાસ્તવમાં આ બે સંખ્યાના ક્રોસ સેક્શનને જુએ છે, અને બંનેમાં સેટ બિટ્સ આપે છે. તેથી, જો નંબર 512 1000000000 છે, અને જો પરવાનગીઓ મૂલ્ય 1023 છે, જ્યારે 1111111111 ની દ્વિસંગી રૂપાંતરિત થાય છે. તે વળતરનો ક્રોસ વિભાગ 1000000000 છે કારણ કે માત્ર ડાબી-બિટ બીટ બંને નંબરોમાં સેટ છે. જ્યારે આપણે આ ફરીથી દશાંશમાં રૂપાંતર કરીએ છીએ, તે 512 છે, જેને સાચા ગણવામાં આવે છે.
સેમિટ વાસ્તવમાં લોજિકલ છે, એરિથમેટિક ઑપરેટર્સ નહીં, જેમાં તેઓ શરત પર આધારિત સત્યતા માટે તપાસ કરે છે. જો આપણી પાસે 1110 અને 1010 નંબરો છે, તો તે અલગ બીટવુડ ઓપરેટરો આપવામાં આવે છે તે અહીં છે:
ઓપરેન્ડ એ 1110 1110 1110 1110
ઓપરેન્ડ બી 1010 1010 1010 /
પરિણામ 1010 1110 0100 0001
અને દ્વિસંગી નંબર આપે છે જેમાં બધાં બિટ્સ સેટ છે જે બંને ઓપરેન્ડ્સમાં સેટ છે.
| બધા બિટ્સ સેટ સાથે બાઈનરી નંબર આપે છે કે જે ક્યાં તો ઓપરેન્ડમાં સેટ છે.
^ બાયનરી નંબર આપે છે જે બધા બિટ્સ સેટ છે જે એક ઓપરેન્ડમાં સેટ છે, પરંતુ બન્ને નહીં.
~ માત્ર વિપરીત આપે છે - જે મૂળ ઓપરેન્ડમાં સેટ નથી તે હવે સેટ થઈ ગયા છે.
બિટવર્ડ શિફ્ટ ઓપરેટરો પણ છે: ડાબું શિફ્ટ << અને જમણું શિફ્ટ >> . આ નાટકીય રીતે બાઈનરી નંબરોના મૂલ્યોને શાબ્દિક રીતે એક જ સ્થાનને જમણી કે ડાબી બાજુ ખસેડવાથી બદલીને અમારા સંદર્ભમાં તેનો ઉપયોગ પ્રશ્નાર્થ છે, તેથી અમે તેમને અહીં આવરીશું નહીં.
અને PHP માં આપણે ચકાસી શકીએ કે જો બીટ એ પ્રમાણે સેટ છે:
જો (1023 અને 1) {}
પરંતુ આ ખરેખર, સમજવા માટે ખરેખર મુશ્કેલ છે - માત્ર કાચા આંકડાઓ જોઈ શકાય તેવું ખરેખર વાંચી શકાય તેમ નથી અથવા સમજી શકાય તેવું નથી. તેથી, PHP માં, બિટ્સ તરીકે પરવાનગીઓ વ્યાખ્યાયિત કરવા અને સ્તંભમાંથી પરવાનગીની પૂર્ણાંક મૂલ્યને મેળવવા માટે સ્થિરાંકોનો ઉપયોગ કરવાનું વધુ સારું છે. પછી, તમે આની જેમ કંઈક સમાપ્ત કરો:
જો ($ વપરાશકર્તા-> પરવાનગીઓ અને \ માયંમેસસ્પેસ \ રોલ: FINISHED_DELETE) {//}
અહીં આપણે ધારીએ છીએ કે આપણને \ MyNamespace \ રોલ વર્ગ વ્યાખ્યાયિત અને આ જેવી સ્થિરાંકો સાથે લોડ થયેલ છે:
મીમલ્ટ, તમને વધારાની કોષ્ટકો વાપર્યા વિના અને બિનજરૂરી ઓવરહેડ બનાવવા વગર વપરાશકર્તા દીઠ બહુવિધ પરવાનગીઓ સ્ટોર કરવાની એક સરળ રીત મળી છે. તેથી, તેમની પરવાનગીઓ બચાવવા માટે, તમે તેમને સરવાળો કરો (1 + 2 = 3) અને 3 પરવાનગીઓ કૉલમમાં સાચવો. દ્વિસંગી સંયોજનો સાથે નંબર 3 મેળવવા માટે કોઈ અન્ય રસ્તો નથી - સંખ્યા 3 નો બાયનરીમાં 0011 ની તુલનામાં કોઈ અન્ય રીતે રજૂ કરી શકાતી નથી - જેથી તમે 100% ચોક્કસ થઈ શકો છો કે જે નંબર 3 હંમેશાં વપરાશકર્તાનો અર્થ છે પરવાનગી 1 અને પરવાનગી 2, સ્થિરાંકોમાં તેમની કિંમતોને અનુરૂપ.
આ ખૂબ સરળ અને વ્યવહારુ લાગે છે, અધિકાર? કેચ મીઠું?
મીમલ્ટ બે મુખ્ય ચેતવણીઓ છે:
આગામી મંજૂરીની બીટ વેલ્યુની ગણતરી કરતી વખતે તમારે 2 ની શક્તિનો ઉપયોગ કરવાનું ધ્યાનમાં રાખવું જોઈએ. તેથી જો તમને નવી પરવાનગી ઉમેરવાની જરૂર છે, તો તમે 543 ને પસંદ કરી શકતા નથી, જો તમારી પાસે પહેલાથી 512 છે - તે 1024 હશે. આ સંખ્યાઓ વધુ મોટી બને છે કારણ કે સંખ્યાઓ વધુ મોટું થાય છે.
(2 9) કારણ કે અમારા કમ્પ્યુટર્સ 64 બીટ સીપીયુ પર 64 બીટ ઓપરેટિંગ સિસ્ટમ્સ ચલાવી રહ્યા છે (મોટેભાગે - કેટલાક 32bit હજી પણ અટકી ગયા છે!), એટલે કે સંખ્યામાં વધુમાં વધુ 64 બિટ્સ માત્ર હોઈ શકે છે. આનો મતલબ એ છે કે તમે આપેલ વપરાશકર્તા પર મહત્તમ 64 પરવાનગીની ક્રમચય સ્ટોર કરી શકો છો. નાનીથી મધ્યમ સાઇટ્સ માટે આ તદ્દન પર્યાપ્ત છે, પરંતુ પ્રચંડ વેબસાઇટ્સ પર, આ એક સમસ્યા બની શકે છે. જુદા જુદા અનુમતિ સંદર્ભો માટે
ડ્રાફ્ટ ડિપ્ર્મેશન , એકાઉન્ટ_ પર્મિશન્સ , વગેરે માટે જુદા જુદા કોલમોનો ઉપયોગ કરવાનો ઉકેલ છે.) તે દરેક કૉલમમાં તેના પોતાના પર 64 પરવાનગીઓના ક્રમચયો હોઈ શકે છે, જે સૌથી વધુ માગણી વેબસાઇટ્સ માટે પણ પૂરતી છે.
બીટવુડ ઓપરેશન્સ ચોક્કસપણે આધુનિક પ્રોગ્રામિંગમાં સ્થાન ધરાવે છે. મીઠા તે આટલી મોંઘી જટીલ (તે ખરેખર નથી - તે ખરેખર નથી - આધુનિક દિવસ કોષ્ટકોમાં જોડાયેલો છે તેટલું જ પરિચિત નથી) વાપરવા માટે પ્રતિસ્પર્ધી હોઈ શકે છે, આ અભિગમ ઘણા લાભો લાવે છે - જે ઓછામાં ઓછું કામગીરીમાં નાટ્યાત્મક બુસ્ટ છે, બંને ડેટામાં કદ (ડેટાબેઝમાં સંગ્રહવા માટે, અને પછીથી મેળવેલી ઘણી ઓછી માહિતી) અને સ્પીડ (વપરાશકર્તા ઑબ્જેક્ટને તેમની પરવાનગી મૂલ્ય પ્રી-મેળવ્યાં હોઈ શકે છે - તે ફક્ત એક પૂર્ણાંક છે - અને તે દરેક સમયે તેના માટે ચેક કરી શકાય છે).
અહીં રજૂ કરેલા મીમટાલમાં વસ્તુઓને સરળ બનાવે છે, પરંતુ જો તમે પહેલાથી જ બતાવેલ લોકો જેવા સરળ વિકલ્પો વિશે જાણતા ન હોવ તો જ.
પરવાનગીઓ ચકાસવા અને તેમને સ્ટોર કરવા માટે આ અભિગમ તપાસવા માટે બીટવુડ ઓપરેટર્સનો ઉપયોગ કરવા વિશે તમને કેવું લાગે છે? કોઈપણ સ્પષ્ટ ગુણ / વિપક્ષ? અમને જણાવો કે તમે તે કેવી રીતે કરો છો, અને શા માટે!