SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-07

chmod 755 बनाम u+x: Linux permissions का सही तरीका

Linux में chmod 755 और u+x के बीच का अंतर समझें। जानें कि क्यों recursive numeric mode डायरेक्टरी ट्री को खराब कर सकता है और capital X का उपयोग करके इसे कैसे ठीक करें।

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 15, 2026.

chmod क्या बदलता है

chmod किसी फाइल या डायरेक्टरी पर permission bits को बदलता है, और यह इन bits को दो नोटेशन में से किसी एक में स्वीकार करता है। न्यूमेरिक फॉर्म एक octal नंबर है जो एक साथ सभी permission bits को बदल देता है। सिम्बॉलिक फॉर्म एक यूजर क्लास और ऑपरेटर का नाम बताता है, और यह केवल उन्हीं bits को एडिट करता है जिनका आप उल्लेख करते हैं। दोनों अंत में एक ही सिस्टम कॉल पर समाप्त होते हैं। अंतर केवल यह है कि जिन bits का आपने उल्लेख नहीं किया है, उनका क्या होता है।

मोड को पढ़ना और मोड को बदलना अलग-अलग काम हैं। यदि लॉन्ग लिस्टिंग में अक्षर अभी स्पष्ट नहीं हैं, तो पहले drwxr-xr-x का मतलब फील्ड दर फील्ड समझें। यह गाइड केवल उन्हें बदलने के बारे में है।

यहाँ दी गई हर कमांड को अपने सामान्य लॉगिन यूजर के रूप में चलाएँ। root अकाउंट इन जाँचों को बायपास कर देता है, इसलिए root के रूप में किया गया permission डेमोंस्ट्रेशन कुछ भी साबित नहीं करता। यदि आप अभी भी एक नए सर्वर पर root के रूप में काम कर रहे हैं, तो न्यूनतम विशेषाधिकार वाला एक सामान्य यूजर बनाएँ और वापस आएँ।

एक ऐसा सैंडबॉक्स सेट करें जिसे आप हटा सकें

cd "$(mktemp -d)"
touch notes.txt

mktemp -d, /tmp के अंतर्गत एक खाली डायरेक्टरी बनाता है और बनाए गए पाथ को प्रिंट करता है, और कमांड सब्स्टीट्यूशन उस पाथ को सीधे cd को पास कर देता है। नीचे दी गई कोई भी चीज़ आपकी किसी महत्वपूर्ण फाइल को प्रभावित नहीं करती है।

एक कमांड हर बदलाव का परिणाम रिपोर्ट करती है:

stat -c '%a %A %n' notes.txt

%a मोड को ऑक्टल नंबर के रूप में प्रिंट करता है, %A उसी मोड को उस लेटर फॉर्मेट में प्रिंट करता है जिसका उपयोग लॉन्ग लिस्टिंग में होता है, और %n नाम को प्रिंट करता है। नीचे दिए गए ब्लॉक्स में, $ से शुरू होने वाली लाइन वह है जिसे आप टाइप करते हैं, और उसके नीचे की लाइन वह है जिसे कमांड ने प्रिंट किया है। इन्हें स्वयं चलाएं। आपकी मशीन पर आउटपुट लाइन-दर-लाइन मेल खाना चाहिए, क्योंकि न्यूमेरिक मोड आपके एनवायरनमेंट की किसी भी चीज़ पर निर्भर नहीं करता है।

संख्यात्मक रूप: प्रति वर्ग एक अष्टक अंक

पहला अंक फ़ाइल के स्वामी का होता है। दूसरा अंक फ़ाइल के समूह का होता है। तीसरा अंक बाकी सभी के लिए होता है। प्रत्येक अंक एक योग है, जिसमें प्रति बिट एक मान होता है। एक समय में एक बिट सेट करें और देखें कि stat क्या रिपोर्ट करता है।

$ chmod 400 notes.txt
$ stat -c '%a %A %n' notes.txt
400 -r-------- notes.txt
$ chmod 200 notes.txt
$ stat -c '%a %A %n' notes.txt
200 --w------- notes.txt
$ chmod 100 notes.txt
$ stat -c '%a %A %n' notes.txt
100 ---x------ notes.txt

अक्षर अंकों के साथ मेल खाते हैं। अग्रणी फ़ाइल-प्रकार वर्ण के बाद, तीन अक्षरों का पहला समूह स्वामी का है, अगले तीन समूह के हैं, और अंतिम तीन बाकी सभी के हैं। एक वर्ग के भीतर बिट्स को संयोजित करने के लिए मानों को जोड़ें।

$ chmod 600 notes.txt
$ stat -c '%a %A %n' notes.txt
600 -rw------- notes.txt
$ chmod 700 notes.txt
$ stat -c '%a %A %n' notes.txt
700 -rwx------ notes.txt
$ chmod 750 notes.txt
$ stat -c '%a %A %n' notes.txt
750 -rwxr-x--- notes.txt

एक संख्यात्मक मोड पूर्ण (absolute) होता है। यह हर रन पर सभी नौ बिट्स लिखता है, इसलिए जिस वर्ग के बारे में आपने कभी नहीं सोचा था, वह भी लिखा जाता है।

$ chmod 755 notes.txt
$ stat -c '%a %A %n' notes.txt
755 -rwxr-xr-x notes.txt
$ chmod 600 notes.txt
$ stat -c '%a %A %n' notes.txt
600 -rw------- notes.txt

दूसरे कमांड ने समूह या बाकी सभी के बारे में कुछ नहीं कहा, और उनके बिट्स फिर भी बदल गए। यह संख्यात्मक रूप की विशेषता है, और यही कारण है कि छोटे बदलाव के लिए संख्यात्मक रूप गलत उपकरण है। (chmod setuid, setgid और sticky बिट्स को भी संभालता है, जो इनसे पहले चौथे अंक में रहते हैं। यह एक अलग विषय है, और यह गाइड केवल तीन अंकों तक ही सीमित है।)

सांकेतिक रूप: एक क्लास, एक ऑपरेटर, फिर बिट्स

सबसे पहले क्लास लिखें। u ओनर है, g ग्रुप है, o बाकी सभी हैं, और a एक साथ ये सभी हैं। फिर ऑपरेटर लिखें: + बिट्स जोड़ता है, - बिट्स हटाता है, और = उस क्लास को केवल आपके द्वारा सूचीबद्ध बिट्स पर सेट करता है और बाकी सभी बिट्स को हटा देता है। फिर बिट्स स्वयं, जैसे r, w या x।

$ chmod 640 notes.txt
$ stat -c '%a %A %n' notes.txt
640 -rw-r----- notes.txt
$ chmod u+x notes.txt
$ stat -c '%a %A %n' notes.txt
740 -rwxr----- notes.txt
$ chmod g-r notes.txt
$ stat -c '%a %A %n' notes.txt
700 -rwx------ notes.txt
$ chmod o=r notes.txt
$ stat -c '%a %A %n' notes.txt
704 -rwx---r-- notes.txt

प्रत्येक कमांड ने एक क्लास को प्रभावित किया और बाकी को वैसा ही रहने दिया। क्लॉज को अल्पविराम (comma) से जोड़ें और बीच में कोई स्पेस न रखें, chmod उन्हें बाएं से दाएं लागू करता है।

$ chmod u=rw,go=r notes.txt
$ stat -c '%a %A %n' notes.txt
644 -rw-r--r-- notes.txt
$ chmod go= notes.txt
$ stat -c '%a %A %n' notes.txt
600 -rw------- notes.txt

go= के बाद बराबर के निशान के आगे कुछ न लिखने पर ग्रुप और बाकी सभी से हर बिट हट जाता है। यह वह स्थिति है जो आप ऐसी फाइल पर चाहते हैं जिसे केवल उसका ओनर ही पढ़ सके, जैसे कि SSH key pair का प्राइवेट हिस्सा।

chmod अपने काम की रिपोर्ट भी दे सकता है, जो किसी स्क्रिप्ट के अंदर महत्वपूर्ण होता है जहाँ कोई स्क्रीन नहीं देख रहा होता।

chmod -v u+x notes.txt
chmod -v u+x notes.txt

-v उसे दी गई प्रत्येक फाइल के लिए एक लाइन प्रिंट करता है। दोनों कमांड चलाएँ और अपनी स्क्रीन पर दोनों लाइनों की तुलना करें: पहली फाइल का नाम बताती है और उस मोड की रिपोर्ट देती है जिससे वह बदला गया और जिस मोड में वह बदला गया, और दूसरी मोड को यथावत (retained) रिपोर्ट करती है, क्योंकि जो बिट जोड़ने के लिए कहा गया था वह पहले से ही सेट था। -c केवल तभी एक लाइन प्रिंट करता है जब फाइल वास्तव में बदलती है, इसलिए लॉग में रखने के लिए यह बेहतर विकल्प है।

chmod 755 बनाम u+x: किस नोटेशन का उपयोग करें

एक ही फाइल से शुरुआत करें और तुलना करें कि प्रत्येक नोटेशन क्या परिणाम देता है।

$ chmod 640 notes.txt
$ chmod 755 notes.txt
$ stat -c '%a %A %n' notes.txt
755 -rwxr-xr-x notes.txt
$ chmod 640 notes.txt
$ chmod u+x notes.txt
$ stat -c '%a %A %n' notes.txt
740 -rwxr----- notes.txt

दोनों commands ने फाइल को उसके owner के लिए executable बना दिया। केवल एक ने बाकी दो classes को वैसा ही रहने दिया जैसा वे थीं। numeric mode का उपयोग तब करें जब आप सटीक अंतिम स्थिति जानते हों और उसे लागू करना चाहते हों। deployment script में यही सही तरीका है, क्योंकि उसे ऐसी मशीन पर भी वही परिणाम देना चाहिए जिसे आपने पहले कभी नहीं देखा। symbolic mode का उपयोग तब करें जब आपके मन में add (जोड़ना) या remove (हटाना) जैसा विचार हो, क्योंकि numeric form में किसी हिस्से को अछूता छोड़ने का कोई विकल्प नहीं होता।

किसी नई फाइल का mode chmod से तय नहीं होता। यह उस process के umask से आता है जिसने फाइल बनाई है। अपने shell में umask और umask -S चलाकर देखें कि वहां कौन सा value लागू है। यह अलग-अलग distributions, आपके login shell और systemd service, तथा अलग-अलग accounts के बीच भिन्न हो सकता है। umask हर नई फाइल का mode निर्धारित करता है, इसलिए chmod चलने से पहले यह तय करता है कि आप किस स्थिति से शुरुआत कर रहे हैं।

Directory पर execute bit का कार्य

यह वह गलतफहमी है जिसमें सबसे अधिक समय बर्बाद होता है। एक सामान्य file पर, execute bit का अर्थ है कि kernel उस file को चला सकता है। एक directory में कोई निर्देश नहीं होते, इसलिए इसमें चलाने के लिए कुछ भी नहीं है। एक directory पर execute bit का अर्थ है traversal: इसके अंदर किसी नाम को resolve करने की अनुमति। dir/file तक पहुँचने के लिए आपको dir पर इसकी आवश्यकता होती है। Read bit एक अलग अनुमति है, और यह directory में मौजूद नामों की सूची देखने की अनुमति देता है। आप एक के बिना दूसरा रख सकते हैं, जिसे एक बार होते हुए देखने के बाद समझना आसान हो जाता है।

$ mkdir vault
$ printf 'hello\n' > vault/secret.txt
$ chmod 600 vault/secret.txt
$ chmod 100 vault
$ echo vault/*
vault/*
$ cat vault/secret.txt
hello

Shell ने pattern को बिना बदले print किया क्योंकि vault/* को expand करने का अर्थ है directory को पढ़ना, और एक glob जो किसी से मेल नहीं खाता को error देने के बजाय literal text के रूप में pass कर दिया जाता है। cat फिर भी काम कर गया क्योंकि आपने नाम स्वयं प्रदान किया था और traversal की अनुमति थी। अब दोनों bits को आपस में बदलें।

$ chmod 400 vault
$ echo vault/*
vault/secret.txt
$ cat vault/secret.txt
cat: vault/secret.txt: Permission denied

नाम दिखाई दे रहे हैं और contents नहीं। Read आपको सूची देता है। Execute आपको अंदर जाने का रास्ता देता है। लगभग हर directory जिसे आप उपयोग करते हैं, उसे दोनों की आवश्यकता होती है।

$ chmod 500 vault
$ cat vault/secret.txt
hello

क्यों chmod -R का उपयोग numeric mode के साथ पूरे ट्री को नुकसान पहुँचाता है

-R पूरे ट्री को स्कैन करता है और आपके द्वारा दिए गए mode को हर उस चीज़ पर लागू कर देता है जो उसे मिलती है। एक directory और एक data file को अलग-अलग bits की आवश्यकता होती है, इसलिए एक ही absolute number दोनों के लिए सही नहीं हो सकता। एक छोटा ट्री बनाएँ और देखें कि यह कैसे गलत हो जाता है।

$ mkdir -p site/css
$ touch site/index.html site/css/main.css
$ printf '#!/bin/bash\necho hi\n' > site/deploy.sh
$ chmod 755 site site/css site/deploy.sh
$ chmod 644 site/index.html site/css/main.css
$ stat -c '%a %A %n' site site/css site/index.html site/css/main.css site/deploy.sh
755 drwxr-xr-x site
755 drwxr-xr-x site/css
644 -rw-r--r-- site/index.html
644 -rw-r--r-- site/css/main.css
755 -rwxr-xr-x site/deploy.sh

यह वह layout है जो static files की directory को चाहिए होता है। यहाँ पहली recursive गलती दी गई है।

$ chmod -R 755 site
$ stat -c '%a %A %n' site/index.html site/css/main.css
755 -rwxr-xr-x site/index.html
755 -rwxr-xr-x site/css/main.css

कुछ भी खराब नहीं हुआ, और यही समस्या है। यह गलती चुपचाप होती है, इसलिए यह वर्षों तक copy की गई instructions में बनी रहती है। अब दो data files खुद को programs बता रही हैं। Git execute bit को store करता है, इसलिए आपका अगला commit इस बदलाव को हर उस व्यक्ति तक पहुँचा देता है जो repository को clone करता है, और rsync तथा tar इसे हर उस machine तक ले जाते हैं जहाँ आप ट्री को copy करते हैं।

दूसरी recursive गलती बहुत गंभीर है। यदि आप बिना execute bit वाले mode को किसी directory पर लागू करते हैं, तो वह directory बंद हो जाती है।

$ chmod 644 site
$ stat -c '%a %A %n' site
644 drw-r--r-- site
$ echo site/*
site/css site/deploy.sh site/index.html
$ cd site
bash: cd: site: Permission denied
$ cat site/index.html
cat: site/index.html: Permission denied

names अभी भी list में दिखते हैं क्योंकि read bit बच गया है, लेकिन directory के माध्यम से हर path बंद हो गया है क्योंकि execute bit हट गया है। chmod -R 644 site एक ही command में ट्री की हर directory के साथ ऐसा करता है। इसके बाद जो परिणाम मिलता है वह हमेशा एक जैसा नहीं होता, क्योंकि chmod को उन्हीं directories से होकर गुजरना पड़ता है जिनका traversal वह खुद छीन रहा है, इसलिए यह मानने के बजाय कि सब ठीक है, find site -type d -exec stat -c '%a %n' {} + के साथ जाँचें कि वास्तव में क्या बदलाव हुए हैं। आगे बढ़ने से पहले इसे ठीक करें।

$ chmod 755 site
$ chmod 644 site/index.html site/css/main.css
$ stat -c '%a %A %n' site site/index.html
755 drwxr-xr-x site
644 -rw-r--r-- site/index.html

recursive chmod का कोई undo नहीं होता। chmod यह record नहीं रखता कि उसने क्या बदला है, इसलिए सुधार की जिम्मेदारी आपकी है, आपको यह याद करके modes को फिर से बनाना होगा कि वे पहले क्या थे। यह काम accidental rm -rf के बाद files को फिर से बनाने जितना ही धीमा और अनिश्चित है, और सबक वही है: enter दबाने से पहले recursive command के target की जाँच करें।

राजधानी X: फाइलों के बजाय डायरेक्टरी पर निष्पादित करें

सिम्बॉलिक मोड X के साथ-साथ x को भी स्वीकार करते हैं। X निष्पादन बिट (execute bit) को केवल वहीं सेट करता है जहाँ यह तर्कसंगत हो: किसी डायरेक्टरी पर, या किसी ऐसी रेगुलर फाइल पर जिसमें पहले से ही किसी क्लास के लिए निष्पादन बिट मौजूद हो। यह नियम बिल्कुल वही है जिसका पालन आप -R से करवाना चाहते थे।

$ chmod -R u=rwX,go=rX site
$ stat -c '%a %A %n' site site/css site/index.html site/css/main.css site/deploy.sh
755 drwxr-xr-x site
755 drwxr-xr-x site/css
644 -rw-r--r-- site/index.html
644 -rw-r--r-- site/css/main.css
755 -rwxr-xr-x site/deploy.sh

एक कमांड, और डायरेक्टरीज़ को एक्सेस करने की अनुमति बनी रही जबकि डेटा फाइलें सुरक्षित रहीं। स्क्रिप्ट ने अपना निष्पादन बिट बनाए रखा क्योंकि वह पहले से ही मौजूद था, जो X नियम का दूसरा भाग है। X फाइल के वर्तमान मोड को पढ़ता है, इसलिए जिस फाइल ने अपना सारा निष्पादन बिट खो दिया है, उसे इसके द्वारा वापस नहीं लाया जा सकता।

$ chmod 644 site/deploy.sh
$ chmod -R u=rwX,go=rX site
$ stat -c '%a %A %n' site/deploy.sh
644 -rw-r--r-- site/deploy.sh
$ site/deploy.sh
bash: site/deploy.sh: Permission denied
$ chmod u+x site/deploy.sh
$ stat -c '%a %A %n' site/deploy.sh
744 -rwxr--r-- site/deploy.sh
$ site/deploy.sh
hi

यही नियम दूसरी दिशा में भी काम करता है। X किसी फाइल के मौजूदा निष्पादन बिट को दूसरी क्लास तक बढ़ा देगा:

$ chmod go+X site/deploy.sh
$ stat -c '%a %A %n' site/deploy.sh
755 -rwxr-xr-x site/deploy.sh

अतः लोअरकेस x उस एक फाइल के लिए है जिसे आप रन करने योग्य बनाना चाहते हैं, और X पूरे ट्री पर एक साथ लागू करने के लिए है। जब आप वर्तमान मोड पर आधारित नियम के बजाय प्रत्येक प्रकार की वस्तु के लिए सटीक मोड चाहते हैं, तो find के साथ वॉक को विभाजित करें।

find site -type d -exec chmod 755 {} +
find site -type f -exec chmod 644 {} +
chmod u+x site/deploy.sh

-type d डायरेक्टरीज़ का चयन करता है और -type f रेगुलर फाइलों का, इसलिए प्रत्येक प्रकार को उसका उचित मोड मिलता है। -exec ... + प्रति फाइल एक प्रोसेस शुरू करने के बजाय कई पाथ्स को एक chmod कॉल में बैच करता है, जो हजारों एंट्रीज़ वाले ट्री पर महत्वपूर्ण होता है। स्क्रिप्ट को अपना बिट एक अलग लाइन पर, जानबूझकर वापस मिलता है।

आगे बढ़ने से पहले परिणाम की जाँच करें

किसी भी recursive बदलाव के बाद, दो commands उन गलतियों को ढूंढती हैं जो मायने रखती हैं। पहली command उन directories की सूची देती है जिनमें आप अब प्रवेश नहीं कर सकते।

find . -type d ! -perm -u+x

दूसरी command उन files की सूची देती है जिन्हें मशीन पर कोई भी account edit कर सकता है।

find . -type f -perm -o+w

-perm -o+w में, शुरुआती - का अर्थ है कम से कम ये bits, इसलिए यह ऐसी file से मेल खाता है जिसके o class में write bit सेट है, चाहे अन्य कोई भी bit सेट हो। यदि कोई भी command कुछ भी print नहीं करती है, तो यह वही परिणाम है जो आप चाहते हैं। दोनों commands को किसी भी tree के शीर्ष से चलाएं जिसे आपने अभी -R के साथ बदला है, और उन कुछ paths पर stat -c '%a %A %n' चलाएं जिन्हें आप बदलना चाहते थे, ताकि जो mode आपने सेट किया है, वही mode kernel में वास्तव में लागू हो।

FAQ

chmod 755 और chmod u+x में क्या अंतर है?

Numeric mode एक absolute मान है। यह फाइल पर मौजूद हर permission bit को लिख देता है, इसलिए जिन classes के बारे में आपने नहीं सोचा, वे भी बदल जाती हैं। Symbolic mode एक बदलाव है। u+x ओनर के लिए केवल एक bit जोड़ता है और बाकी सभी bits को वैसा ही रहने देता है। जब आप फाइल की सटीक अंतिम स्थिति जानते हों, तब numeric form का उपयोग करें। जब आप केवल एक चीज जोड़ना या हटाना चाहते हों, तब symbolic form का उपयोग करें। किसी भी command को चलाने से पहले और बाद में stat -c '%a %A %n' <file> चलाएं, तो अंतर output में दिखाई देगा।

वेब फाइलों की डायरेक्टरी पर chmod -R 755 का उपयोग करना गलत क्यों है?

क्योंकि -R डायरेक्टरी और सामान्य फाइलों दोनों पर एक ही absolute mode लागू कर देता है, जबकि इन दोनों को अलग-अलग bits की आवश्यकता होती है। डायरेक्टरी को traversable होने के लिए execute bit की आवश्यकता होती है। HTML और CSS जैसी डेटा फाइलों को इसकी आवश्यकता नहीं होती, और उन्हें executable मार्क करने से git आपके अगले commit में बदलाव दर्ज कर लेता है और rsync उसे अगली मशीन पर कॉपी कर देता है। chmod -R u=rwX,go=rX <dir> का उपयोग करें ताकि execute bit केवल डायरेक्टरी पर ही लागू हो, या फिर -type d और -type f के साथ find का उपयोग करें ताकि प्रत्येक प्रकार को उसका उचित mode मिले।

डायरेक्टरी पर execute bit क्या करता है?

यह traversal की अनुमति देता है, execution की नहीं। डायरेक्टरी के अंदर चलाने के लिए कुछ भी नहीं होता। Execute bit का मतलब है कि आप उसके अंदर किसी नाम को resolve कर सकते हैं, इसलिए किसी फाइल को खोलने के लिए आपको उस पथ (path) पर आने वाली हर डायरेक्टरी पर इसकी आवश्यकता होती है। Read bit अलग है और यह नामों की सूची देखने की अनुमति देता है। आप एक को दूसरे के बिना रख सकते हैं: केवल execute के साथ आप उस फाइल को खोल सकते हैं जिसका नाम आप पहले से जानते हैं, जबकि shell उस डायरेक्टरी में glob का विस्तार नहीं कर पाएगा। केवल read के साथ आप नाम देख सकते हैं, लेकिन किसी फाइल को खोलने का हर प्रयास विफल हो जाएगा।

मुझे lowercase x के बजाय capital X का उपयोग कब करना चाहिए?

जब भी command recursive हो, तब X का उपयोग करें। X डायरेक्टरी पर execute bit सेट करता है, और सामान्य फाइलों पर केवल तभी जब एक execute bit पहले से सेट हो। इस प्रकार, एक ही बार में पूरी tree traversable हो जाती है और डेटा फाइलें प्रोग्राम में नहीं बदलतीं। जब आप किसी एक फाइल को इंगित कर रहे हों और आपका मतलब केवल उसी फाइल से हो, तब lowercase x का उपयोग करें। एक सीमा याद रखना आवश्यक है: X उस execute bit को पुनर्स्थापित नहीं कर सकता जिसे पहले ही हर जगह से हटा दिया गया हो, क्योंकि उसके पास मिलान करने के लिए कुछ नहीं बचता। उसे chmod u+x <file> के साथ वापस सेट करें।

क्या chmod फाइल के ओनर को बदलता है?

नहीं। chmod केवल permission bits को बदलता है। ओनरशिप chown (user के लिए) और chgrp (group के लिए) के पास होती है, और किसी फाइल को दूसरे user को सौंपने के लिए root की आवश्यकता होती है। यह महत्वपूर्ण है क्योंकि bits को फाइल पर दर्ज ओनर और ग्रुप के आधार पर पढ़ा जाता है, न कि उस व्यक्ति के आधार पर जिसने उसे आखिरी बार लिखा था। यह तय करने से पहले कि आपको वास्तव में किन तीन commands की आवश्यकता है, ओनर, ग्रुप और mode को एक साथ देखने के लिए stat -c '%U %G %a %n' <file> चलाएं।

क्या यह लेख उपयोगी था?