Comment créer des fichiers sous Ubuntu : terminal, interface graphique, modèles et permissions (Guide débutant)

1. Ce que vous apprendrez dans cet article

Lorsque vous travaillez sur Ubuntu, vous rencontrerez inévitablement des situations où vous pensez « Je veux créer un nouveau fichier. ».
Par exemple, vous pourriez créer un fichier texte pour des notes, créer un nouveau fichier de configuration ou préparer un script shell — il existe de nombreux cas d’utilisation.

Si vous êtes habitué à Windows, il est également très courant de se demander « Je ne peux pas créer un nouveau fichier avec un clic droit ? » ou « Quelle méthode est la bonne ? » — un moment typique d’Ubuntu.

Dans cet article, nous organiserons et expliquerons les méthodes les plus courantes pour créer des fichiers sous Ubuntu afin que même les débutants puissent suivre sans se perdre.

1.1 Méthodes courantes pour créer des fichiers sous Ubuntu (ligne de commande / interface graphique)

Il existe deux façons principales de créer des fichiers sous Ubuntu :

Créer des fichiers avec des commandes (Terminal)

Utiliser le terminal est extrêmement rapide une fois que vous vous y habituez, et c’est couramment utilisé dans le travail réel.

• Créer un fichier vide : touch
• Créer un fichier et écrire du contenu en même temps : echo ou printf + redirection (>)
• Créer un fichier multi‑lignes d’un seul coup : cat (heredoc)

Pour des tâches comme l’administration de serveurs ou la modification de fichiers de configuration, les opérations en ligne de commande sont l’approche standard.

Créer des fichiers avec l’interface graphique (Gestionnaire de fichiers)

Dans l’environnement de bureau d’Ubuntu, vous pouvez également utiliser l’application de fichiers (Nautilus) pour travailler visuellement.

• Ouvrez un éditeur de texte et utilisez « Nouveau fichier → Enregistrer »
• Utilisez la fonction Modèles (Templates) pour créer des fichiers depuis le menu contextuel du clic droit

C’est une option confortable même si vous travaillez principalement avec l’interface graphique.

1.2 Quelle méthode choisir ? (Référence rapide par cas d’utilisation)

Il est facile de rester bloqué en se demandant « Alors, laquelle dois‑je utiliser ? » — voici la conclusion dès le départ.

Si vous êtes débutant, apprendre simplement « Enregistrer depuis l’interface graphique » et « touch » suffit déjà.
Une fois à l’aise, ajouter la redirection et le heredoc à votre boîte à outils rendra votre flux de travail beaucoup plus fluide.

1.3 Public cible (Débutants à usage pratique léger)

Cet article est rédigé pour des personnes comme :

• Vous venez de commencer à utiliser Ubuntu et ne savez pas comment créer des fichiers
• Vous n’êtes pas à l’aise avec le terminal, mais vous voulez apprendre les commandes essentielles minimales
• Vous créez de plus en plus de fichiers de configuration ou de scripts
• Vous êtes bloqué parce que vous ne pouvez pas créer un nouveau fichier via un clic droit
• Vous avez été confronté à des erreurs telles que « Permission denied »

Plus loin dans l’article, nous couvrons également les vérifications post‑création (permissions et propriétaire) et le dépannage courant,
de sorte que cela devienne une « référence à laquelle vous reviendrez » pour l’utilisation quotidienne d’Ubuntu.

2. Ce que signifie « Créer un fichier » sous Ubuntu

Sous Ubuntu, « créer un fichier » signifie simplement « préparer un conteneur où des données peuvent être enregistrées. ».
Cependant, dans le travail réel, les débutants se confondent souvent parce que les situations suivantes se mélangent :

• Vous pensiez avoir créé un fichier, mais vous avez en fait créé un répertoire (dossier)
• Vous ne vous souvenez plus où vous l’avez créé
• Vous l’avez créé sans extension de fichier, puis vous ne savez plus à quoi il sert
• Vous l’avez créé, mais vous ne pouvez pas le modifier (problème de permissions)

Ici, nous rassemblerons les bases que vous devez comprendre pour la création de fichiers sous Ubuntu.

2.1 Différence entre un fichier et un répertoire (souvent confondus)

Tout d’abord, sous Ubuntu (Linux), un « fichier » et un « répertoire (dossier) » sont des choses différentes.

• Fichier : quelque chose qui contient du contenu (texte, paramètres, données)
• Répertoire : un conteneur utilisé pour organiser les fichiers

Par exemple :

• memo.txt → fichier
• Documents/ → répertoire
• config.ini → fichier
• project/ → répertoire

Une erreur très courante chez les débutants est de créer un répertoire alors qu’ils voulaient créer un fichier.

• Commande pour créer un répertoire : mkdir
• Commande pour créer un fichier : touch (et d’autres)

Cet article se concentre sur la création de fichiers, nous utiliserons donc principalement touch et la redirection comme >.

2.2 Les extensions ne sont pas obligatoires, mais elles sont importantes en pratique

Sur Windows, les extensions de fichiers (.txt, .jpg, .exe, etc.) sont très importantes,
et les gens ont souvent l’impression que l’extension « définit » ce qu’est le fichier.

En Ubuntu (Linux), en revanche, les extensions ne sont pas requises.
Dans des cas extrêmes, des fichiers comme ceux-ci peuvent exister sans aucun problème :

• memo
• config
• run

Cela dit, ajouter une extension est généralement plus clair dans une utilisation réelle.
Surtout pour les débutants, il est recommandé d’utiliser des extensions pour que l’objectif soit évident.

Exemples courants incluent :

• memo.txt : notes textuelles
• script.sh : script shell
• settings.conf : fichier de configuration
• data.csv : données CSV
• README.md : documentation (Markdown)

De plus, sur Ubuntu, le « contenu des fichiers » et les « permissions (si cela peut être exécuté) » importent souvent plus que les extensions.
C’est pourquoi plus tard dans cet article, nous aborderons aussi chmod (permission d’exécution).

2.3 Réduire les Erreurs en Pensant à l’Emplacement de Sauvegarde (Chemin) (Dossier Personnel / Répertoire de Travail)

C’est l’un des problèmes les plus courants pour les débutants lors de la création de fichiers sur Ubuntu :

« J’ai créé le fichier, mais je ne sais pas où il est… »

Cela arrive généralement parce que vous n’avez pas fait attention à dans quel répertoire vous l’avez créé.

En Ubuntu, il y a deux schémas courants pour l’endroit où vous créez des fichiers.

Créer Dans Votre Dossier Personnel (Recommandé pour les Débutants)

Cet utilisateur connecté a généralement un espace de travail personnel.
C’est ce qu’on appelle votre dossier personnel.

Exemple de chemin :

• /home/username/

Dans le terminal, il est représenté par le symbole ~.

Exemples :

• ~/Documents
• ~/Downloads
• ~/Desktop

En tant que débutant, il est généralement plus sûr de travailler dans votre dossier personnel.

Créer Dans Votre Répertoire de Travail (Comprendre Une Fois Que Vous Êtes À l’Aise)

Quand vous créez un fichier depuis le terminal, il est créé « là où vous êtes maintenant ».
C’est ce qu’on appelle le répertoire actuel.

La commande pour vérifier votre emplacement actuel est pwd.

pwd

Exemple : Si la sortie est :

/home/user/Documents

Alors exécuter touch test.txt créera le fichier ici :

• /home/user/Documents/test.txt

Donc, la création de fichiers ne concerne pas seulement l’« action »—vous devez comprendre l’emplacement (chemin) comme partie intégrante.

3. Option La Plus Rapide : Créer Un Fichier Vide (touch)

Quand vous pensez, « Je veux juste créer un fichier pour l’instant » sur Ubuntu, la méthode la plus simple et la plus fiable est la commande touch.

touch est couramment utilisé dans des situations comme :

• Créer un fichier vide pour des notes et l’éditer plus tard
• Préparer un « conteneur vide » d’abord pour un fichier de configuration
• Créer plusieurs fichiers à la fois pour un projet
• Préparer un fichier qui doit exister avant d’exécuter un autre processus

Pour l’objectif de « créer un fichier vide », touch est proche de la meilleure réponse.

3.1 Bases de touch filename (Créer Un Fichier Vide)

La forme de base est extrêmement simple.

touch filename

Par exemple, pour créer un fichier vide nommé memo.txt :

touch memo.txt

Pour confirmer qu’il a été créé, listez les fichiers avec ls.

ls

Vous devriez voir le fichier que vous avez créé :

memo.txt

Si vous voulez confirmer « Est-il vraiment vide ? », vous pouvez afficher son contenu avec cat.

cat memo.txt

Si rien n’est affiché, le fichier est vide.

3.2 Que Se Passe-t-il Si Vous Exécutez touch Sur Un Fichier Existant ? (Mise à Jour Du Timestamp)

touch ne crée pas seulement des fichiers qui n’existent pas.
Si vous l’exécutez sur un fichier qui existe déjà, il se comporte généralement comme ceci :

• Le contenu du fichier ne change pas
• Le temps de modification (timestamp) devient plus récent

Par exemple, si memo.txt existe déjà et que vous exécutez :

touch memo.txt

Le contenu reste le même, mais le « temps de modification » du fichier est mis à jour.

Dans de nombreuses tâches quotidiennes, cela n’a pas d’importance, mais soyez prudent dans des cas comme :

• Les outils de sauvegarde/synchronisation le traitent comme « mis à jour »
• Les processus de build ou d’automatisation dépendent des timestamps
• Les systèmes de surveillance peuvent l’interpréter à tort comme un changement

En tant que débutant, il suffit de retenir « touch = créer un fichier vide. » Au fur et à mesure que vous gagnez en expérience, il est encore mieux de se rappeler qu’il peut aussi « mettre à jour les horodatages. »

3.3 Créer plusieurs fichiers à la fois (Exemple : touch a.txt b.txt)

Vous pouvez également créer plusieurs fichiers en une seule commande.

touch a.txt b.txt c.txt

Cette ligne crée a.txt, b.txt et c.txt ensemble.

C’est aussi pratique lorsque vous voulez préparer une structure de projet basique.

touch index.html style.css script.js

Dans le développement web et les contextes d’apprentissage, créer plusieurs fichiers de cette façon est très courant.

3.4 Erreurs courantes : les fautes de frappe créent des fichiers non intentionnels / mauvais emplacement

touch est pratique, mais comme c’est si simple, cela peut aussi provoquer des « accidents ». Voici les pièges courants pour les débutants.

Vous ne remarquez pas une faute de frappe dans le nom de fichier

Par exemple, vous aviez l’intention de créer config.txt, mais vous avez tapé par erreur :

touch confgi.txt

Comme prévu, un fichier différent nommé confgi.txt est créé. touch n’affichera pas d’erreur — il le crée simplement — il est donc facile de ne pas le remarquer.

Astuce : exécutez ls immédiatement après la création des fichiers pour confirmer ce qui a réellement été créé.

Vous l’avez créé au mauvais endroit (vous ne le trouvez pas)

Cela arrive très souvent.

Lorsque vous créez un fichier depuis le terminal, il est créé dans votre répertoire courant.

La commande pour vérifier « Où suis-je en ce moment ? » est pwd.

pwd

Si vous n’êtes pas là où vous l’attendiez, déplacez‑vous d’abord avec cd, puis créez le fichier.

Exemple : se déplacer vers Documents, puis créer un fichier

cd ~/Documents
touch memo.txt

À ce stade, vous avez appris le chemin le plus court pour créer un fichier vide sur Ubuntu : touch.

4. Créer un fichier avec du contenu : utiliser la redirection (echo / printf / cat)

touch est parfait pour créer un fichier vide. Mais dans le travail réel, vous voudrez souvent cela à la place :

• Pas seulement créer un fichier, mais écrire du contenu en même temps
• Écrire une seule ligne et terminer
• Créer un fichier de configuration en masse

C’est là que la redirection (en utilisant > ou >>) devient très utile.

La redirection demande un peu de pratique, mais une fois que vous l’avez maîtrisée, votre flux de travail devient beaucoup plus rapide.

4.1 Créer avec > (en expliquant également le risque d’écrasement)

Sur Ubuntu, vous pouvez enregistrer la sortie d’une commande dans un fichier. L’opérateur utilisé pour cela est >.

La forme de base ressemble à ceci :

command > filename

Par exemple, pour écrire hello dans memo.txt tout en le créant :

echo "hello" > memo.txt

Si memo.txt n’existe pas, il sera créé. S’il existe déjà, le contenu sera remplacé.

C’est le point clé :

> peut créer un nouveau fichier, mais il écrase également les fichiers existants.

Donc, si vous utilisez > sur un fichier qui contient déjà du contenu important, ce contenu sera supprimé.

Comme règle de base sûre pour les débutants :

• > signifie remplacer (écraser)
• >> signifie ajouter (ajouter à la fin)

4.2 Ajouter avec >> (un modèle courant pour les fichiers de configuration)

Si vous voulez ajouter du contenu au lieu d’écraser, utilisez >>.

echo "second line" >> memo.txt

Cela ajoute une nouvelle ligne à la fin de memo.txt.

Lorsqu’on travaille avec des fichiers de configuration ou des journaux, l’ajout est souvent l’option la plus sûre.

Par exemple, ajouter une ligne à un fichier de configuration pourrait ressembler à ceci :

echo "export PATH=\$PATH:/opt/tools/bin" >> ~/.bashrc

C’est l’avantage de >> : il conserve le contenu existant et ajoute du nouveau contenu.

4.3 Quand printf est plus sûr (retours à la ligne et échappements)

echo est simple, mais dans les environnements pratiques, printf est parfois plus fiable.

Les principales raisons incluent :

• echo peut se comporter légèrement différemment selon l’environnement
• printf facilite la gestion précise de \n (retours à la ligne) et \t (tabulations)

Par exemple, pour écrire plusieurs lignes en utilisant des retours à la ligne explicites :

printf "line1\nline2\n" > memo.txt

Cela crée memo.txt contenant exactement deux lignes en une seule fois.

printf est également excellent lorsque vous souhaitez inclure des lignes vides ou un formatage plus complexe.

4.4 Écrire plusieurs lignes en une fois : Heredoc (Comment fonctionne cat << 'EOF' > file)

Quand on crée des fichiers de configuration, ajouter ligne par ligne avec echo peut être fastidieux.
C’est là que heredoc (here-document) devient très utile.

Avec la syntaxe suivante, vous pouvez sauvegarder plusieurs lignes dans un fichier en une seule fois :

cat << 'EOF' > sample.conf
server_name example.com;
root /var/www/html;
index index.html;
EOF

Les points clés sont :

• EOF est un marqueur qui signifie « l’entrée se termine ici » (vous pouvez utiliser d’autres mots aussi)
• Le citer comme 'EOF' aide à prévenir l’expansion des variables et le rend plus sûr

Heredoc est couramment utilisé dans la configuration de serveurs et les travaux de configuration.
Il peut sembler un peu avancé au début, mais une fois habitué, c’est extrêmement pratique.

4.5 Petits conseils de « prévention des accidents » : Éviter d’écraser par erreur

La partie la plus effrayante de la redirection est d’écraser accidentellement un fichier.

Par exemple, cela peut être dangereux :

echo "test" > important.conf

Si important.conf contenait des paramètres critiques, le contenu serait perdu.

Pour réduire les erreurs dans les opérations réelles, rappelez-vous ces deux idées :

1) Créer une sauvegarde avant d’écraser

Par exemple, pour un fichier de configuration :

cp important.conf important.conf.bak

2) Vérifier le contenu avant d’éditer avec cat ou less

Prendre l’habitude de vérifier avant d’éditer préviendra de nombreux accidents.

cat important.conf

5. Créer des fichiers avec un éditeur (Amical pour les débutants : nano / Éditeur de texte GUI)

Jusqu’à présent, nous avons couvert touch et la redirection, qui deviennent très puissants une fois que vous êtes à l’aise avec eux.
Mais si vous êtes nouveau sur Ubuntu, vous pourriez vous sentir comme ceci :

• Le terminal semble encore intimidant
• Et si j’écrasais quelque chose par erreur ?
• Je veux éditer en regardant l’écran

Dans ce cas, utiliser un éditeur pour créer des fichiers est l’approche la plus sûre.
Avec un éditeur, le flux est simplement « créer nouveau → sauvegarder », ce qui est facile à comprendre intuitivement.

5.1 Éditer depuis le terminal : nano file (Comment sauvegarder et quitter)

L’éditeur de terminal le plus amical pour les débutants sur Ubuntu est nano.
Il est simple à utiliser, et les touches de raccourci sont affichées en bas de l’écran, donc il est facile de ne pas se perdre.

Par exemple, pour créer et éditer memo.txt :

nano memo.txt

Si memo.txt n’existe pas, il sera créé automatiquement et nano s’ouvrira.
Écrivez votre texte, sauvegardez et quittez—fait.

Raccourcis de base de nano (3 choses que les débutants devraient apprendre en premier)

nano utilise des touches de raccourci.
L’idée de base est de maintenir Ctrl tout en appuyant sur une autre touche.

• Sauvegarder : Ctrl + O (Write Out)
• Entrée : confirmer le nom du fichier
• Quitter : Ctrl + X

Si vous essayez de quitter sans sauvegarder, nano demandera une confirmation, ce qui le rend amical pour les débutants.

5.2 vim est pour les utilisateurs avancés (Seulement le minimum pour sauvegarder/quitter)

Beaucoup d’utilisateurs Ubuntu s’appuient sur vim, mais il peut être difficile pour les débutants.
C’est parce qu’il a plusieurs modes, et il est facile de se coincer en pensant « je ne peux pas taper » ou « je ne peux pas quitter ».

Cependant, connaître le minimum absolu—« ouvrir » et « sauvegarder & quitter »—peut aider en cas d’urgence.

Ouvrir un fichier (ou le créer s’il n’existe pas) :

vim memo.txt

Étapes de base pour sauvegarder et quitter :

1. Appuyez sur Esc
2. Tapez :wq et appuyez sur Entrée (write + quit)

Pour quitter sans sauvegarder :

1. Esc
2. Tapez :q! et appuyez sur Entrée

En tant que débutant, nano est généralement suffisant.
Pensez à vim comme un « outil avancé » et apprenez-le progressivement seulement quand nécessaire.

5.3 Créer des fichiers avec le GUI (Éditeur de texte → Sauvegarder)

Si vous préférez ne pas utiliser le terminal, vous pouvez créer des fichiers complètement via le GUI.

La méthode la plus facile est :

1. Ouvrir un éditeur de texte (par exemple, “Text Editor” ou “GNOME Text Editor”)
2. Créer un nouveau fichier
3. Cliquer sur “Save” et choisir un emplacement

Cela est très similaire à Windows, donc les débutants s’y sentent généralement à l’aise.

De plus, comme vous choisissez explicitement l’emplacement de sauvegarde, il est plus difficile de perdre la trace de l’endroit où le fichier a été créé.

5.4 Éditeurs Recommandés (Par Défaut sur Ubuntu / VS Code)

Sur Ubuntu, il existe plusieurs options d’éditeurs en fonction de votre objectif.

Par Défaut sur Ubuntu : Éditeur de Texte (Simple et Léger)

Ubuntu est généralement livré avec un éditeur de texte simple installé par défaut.
Il est parfait pour des notes rapides, des modifications de configuration mineures et des scripts simples.

VS Code (Meilleur pour la Programmation)

Si vous écrivez du code ou gérez de nombreux fichiers, Visual Studio Code (VS Code) est hautement recommandé.

• Surlignage de syntaxe (facile à lire)
• Formatage automatique
• Terminal intégré
• Extensions pour de nombreux langages

Pour les débutants, l’« éditeur de texte par défaut » suffit au début.
Si vous ressentez le besoin d’un environnement de développement plus confortable, vous pouvez passer à VS Code plus tard.

6. Clic Droit « Nouveau Fichier » sur Ubuntu : Utiliser les Modèles

De nombreuses personnes passant de Windows à Ubuntu s’attendent à ce flux de travail :

« Clic droit → Nouveau → Créer un fichier »

Sur Ubuntu, le gestionnaire de fichiers n’affiche pas toujours « Nouveau Fichier » par défaut.
Cela amène souvent les débutants à penser : « Ubuntu ne peut pas créer de nouveaux fichiers par clic droit. »

Mais la solution existe : Modèles.

6.1 Qu’est-ce que le Dossier Modèles ? (Comment Ça Fonctionne)

Ubuntu dispose d’une fonctionnalité appelée Modèles qui vous permet de créer de nouveaux fichiers à partir de modèles via le menu du clic droit.

L’idée est simple :

• Si vous placez des fichiers dans le dossier Modèles
• Ils apparaissent comme des options « Nouveau Document » dans le menu du clic droit

C’est la méthode Ubuntu pour créer des « nouveaux fichiers » depuis l’interface graphique.

6.2 Activer le Clic Droit « Nouveau Document » (Créer un Modèle Vide)

Pour utiliser les Modèles, vous avez besoin d’au moins un fichier de modèle.

Vérifiez d’abord si vous avez un dossier Modèles dans votre répertoire personnel.

ls ~

Si vous voyez un dossier nommé Templates, c’est celui-là.

S’il n’existe pas, créez-le :

mkdir -p ~/Templates

Maintenant, créez un fichier de modèle vide à l’intérieur.
Par exemple, un modèle de fichier texte vide :

touch ~/Templates/Empty\ Text\ File.txt

Après cela, ouvrez le gestionnaire de fichiers, faites un clic droit dans un dossier, et vous devriez voir quelque chose comme :

• Nouveau Document
• Empty Text File.txt

Sélectionnez-le, et Ubuntu créera un nouveau fichier basé sur ce modèle.

6.3 Ajouter Plusieurs Modèles (Texte / Markdown / Script Shell)

Une fois que vous avez compris le concept, vous pouvez ajouter plusieurs modèles en fonction de vos besoins.

Exemples :

touch ~/Templates/README.md
touch ~/Templates/script.sh
touch ~/Templates/config.conf

Maintenant, vous pouvez créer ces fichiers courants par clic droit également.

Si vous voulez rendre script.sh immédiatement exécutable, vous pouvez aussi préparer un fichier de modèle exécutable (couvert plus tard dans la section sur les permissions).

6.4 Dépannage : « Les Modèles N’Apparaissent Pas »

Si « Nouveau Document » n’apparaît pas dans le menu du clic droit, vérifiez ces points :

• Le dossier Modèles existe dans votre répertoire personnel
• Il y a au moins un fichier à l’intérieur de Modèles
• Vous utilisez le gestionnaire de fichiers par défaut d’Ubuntu (Nautilus)

Dans de nombreux cas, créer simplement un fichier de modèle suffit à faire apparaître le menu.

7. Erreurs Courantes Lors de la Création de Fichiers (Permission Refusée, Lecture Seule, etc.)

À ce stade, vous pouvez créer des fichiers en utilisant plusieurs méthodes.
Mais de nombreux débutants se heurtent à un autre obstacle :

« J’ai essayé de créer un fichier, mais il dit Permission denied. »

Cela se produit parce qu’Ubuntu dispose d’un système de permissions robuste.
Il protège le système contre les modifications accidentelles, mais cela peut dérouter les débutants au début.

7.1 Pourquoi « Permission denied » Se Produit (Propriétaire / Permissions)

Sur Ubuntu, chaque fichier et chaque dossier possède :

• un propriétaire (qui en est le propriétaire)
• un groupe (à quel groupe il appartient)
• des permissions (quelles actions sont autorisées)

Si votre compte utilisateur n’a pas la permission de créer des fichiers dans un dossier, Ubuntu le bloquera.

Par exemple, les répertoires système comme ceux-ci nécessitent généralement des privilèges d’administrateur :

• /etc
• /usr
• /var

Donc, si vous essayez de créer un fichier directement sous /etc en tant qu’utilisateur normal, vous pourriez obtenir une erreur.

7.2 Comment Vérifier les Permissions avec ls -l

Lorsque vous voyez une erreur de permission, la première chose à faire est de vérifier les permissions du fichier/répertoire.

La commande la plus courante pour cela est ls -l.

ls -l

Exemple de sortie :

-rw-r--r-- 1 user user  120 Jan 24 10:30 memo.txt

Cette ligne inclut des informations importantes :

• -rw-r--r-- : permissions
• user user : propriétaire et groupe

Pour les répertoires, vous pourriez voir quelque chose comme :

drwxr-xr-x 2 user user 4096 Jan 24 10:20 Documents

Le caractère de tête vous indique ce que c’est :

• - = fichier
• d = répertoire

Ainsi, vous pouvez rapidement savoir si vous avez affaire à un fichier ou à un répertoire.

7.3 Les Connaissances Minimales en Permissions Dont Vous Avez Besoin (r / w / x)

Les permissions Linux semblent compliquées, mais les bases sont simples une fois décomposées.

Les lettres de permission signifient :

• r = lecture (peut voir le contenu)
• w = écriture (peut modifier/créer/supprimer)
• x = exécution (peut exécuter / peut entrer dans le répertoire)

Et elles s’appliquent à trois catégories :

• propriétaire (utilisateur)
• groupe
• autres (tout le monde d’autre)

Donc une chaîne de permissions comme celle-ci :

-rw-r--r--

Peut être lue comme :

• propriétaire : rw- (lecture/écriture autorisées)
• groupe : r-- (lecture seule)
• autres : r-- (lecture seule)

C’est suffisant pour comprendre la plupart des problèmes de permissions que vous rencontrerez en tant que débutant.

7.4 Corriger les Problèmes de Permissions en Toute Sécurité (Utiliser le Bon Répertoire, Éviter sudo Aléatoire)

Lorsque vous voyez « Permission denied », les débutants essaient souvent cela immédiatement :

sudo touch something

Cela peut fonctionner, mais utiliser sudo sans compréhension peut créer de plus grands problèmes plus tard (propriété erronée, modifications accidentelles du système).

Voici donc une approche plus sûre pour les débutants :

1. Créez des fichiers sous votre répertoire personnel autant que possible
2. Si vous devez modifier des fichiers système, utilisez sudo uniquement pour cette tâche spécifique

Par exemple, modifier un fichier sous /etc se fait généralement comme ceci :

sudo nano /etc/example.conf

C’est plus sûr que de créer des fichiers aléatoires en tant que root dans des emplacements inconnus.

7.5 Un Piège Courant : Les Fichiers Créés avec sudo Deviennent « Propriété de root »

Si vous créez ou modifiez un fichier avec sudo, il peut devenir la propriété de root.

Exemple :

sudo touch myfile.txt

Si vous le vérifiez avec ls -l, vous pourriez voir :

-rw-r--r-- 1 root root 0 Jan 24 11:00 myfile.txt

Cela signifie que votre utilisateur normal pourrait ne pas pouvoir le modifier librement plus tard.

Si vous devez corriger la propriété (pour les fichiers sous votre répertoire personnel), vous pouvez utiliser chown :

sudo chown $USER:$USER myfile.txt

Important : Ne changez pas aléatoirement la propriété des fichiers système sous /etc ou /usr.
Utilisez cela principalement pour les fichiers qui devraient appartenir à votre compte utilisateur (surtout à l’intérieur de ~).

8. Créer des Fichiers Exécutables (Scripts Shell) et Définir les Permissions

Sur Ubuntu, vous pourriez vouloir créer un fichier et ensuite « l’exécuter ».
Un exemple typique est un script shell (fichier .sh).

Mais de nombreux débutants créent un script et tombent ensuite sur ce problème :

« J’ai créé le fichier, mais je ne peux pas l’exécuter. »

Cela arrive parce que sur Ubuntu, l’exécution dépend des permissions (le drapeau x).

8.1 Créer un Fichier de Script Simple (Exemple)

D’abord, créez un fichier de script. Voici un exemple rapide utilisant heredoc :

cat << 'EOF' > hello.sh
#!/bin/bash
echo "Hello from Ubuntu!"
EOF

Maintenant, vous avez un fichier nommé hello.sh.

À ce stade, il existe, mais il n’est peut-être pas encore exécutable.

8.2 Le Rendre Exécutable avec chmod +x

Pour exécuter un fichier de script directement, vous devez ajouter la permission d’exécution.

Utilisez chmod +x comme ceci :

chmod +x hello.sh

Maintenant, vous pouvez l’exécuter avec :

./hello.sh

Sortie attendue :

Hello from Ubuntu!

C’est un concept clé d’Ubuntu :

Un fichier peut exister, mais il ne s’exécutera pas à moins d’avoir les permissions d’exécution (x).

8.3 Pourquoi Vous Avez Besoin de ./ pour L’Exécuter (Explication pour Débutants)

Les débutants se demandent souvent pourquoi ils ne peuvent pas exécuter un script comme ceci :

hello.sh

Et pourquoi Ubuntu exige ceci :

./hello.sh

La raison est qu’Ubuntu ne recherche pas automatiquement le répertoire courant (.) pour les commandes, pour des raisons de sécurité.

Donc ./ signifie :

• « Exécuter le fichier dans le répertoire courant »

Cela empêche d’exécuter accidentellement un script malveillant ayant le même nom qu’une commande système.

8.4 Création de Scripts Plus Sûre : Utilisez un Dossier Scripts

Si vous commencez à écrire des scripts souvent, il est pratique de créer un dossier dédié.

mkdir -p ~/scripts

Puis stockez les scripts là :

mv hello.sh ~/scripts/

Cela garde votre répertoire personnel propre et rend les scripts plus faciles à gérer.

9. Commandes Utiles pour Confirmer la Création de Fichiers (ls / file / cat / stat)

Après avoir créé un fichier, il est utile de confirmer que :

• Il existe
• C’est le bon type
• Il contient le bon contenu
• Ses permissions sont correctes

Voici les commandes de confirmation les plus utiles.

9.1 Confirmer l’Existence avec ls et ls -l

La vérification la plus basique est ls.

ls

Si vous voulez vérifier les détails comme les permissions et les horodatages, utilisez ls -l :

ls -l memo.txt

Cela montre la propriété, les permissions, la taille et la dernière date de modification.

9.2 Vérifier le Type de Fichier avec file

Si vous n’êtes pas sûr de ce qu’est réellement un fichier, utilisez la commande file.

file memo.txt

Exemple de sortie :

memo.txt: ASCII text

Cela peut être très utile lors de la manipulation de fichiers sans extension.

9.3 Afficher le Contenu avec cat et less

Pour afficher rapidement le contenu d’un fichier, utilisez cat :

cat memo.txt

Si le fichier est long, less est plus facile à lire :

less memo.txt

Dans less, vous pouvez faire défiler et quitter avec q.

9.4 Vérifier les Métadonnées Détaillées avec stat

Si vous voulez plus d’informations détaillées (horodatages, inode, etc.), utilisez stat.

stat memo.txt

Ceci est particulièrement utile lorsque vous déboguez « pourquoi un fichier semble mis à jour » ou « pourquoi quelque chose ne fonctionne pas ».

10. Résumé : Meilleures Façons de Créer des Fichiers dans Ubuntu (Liste de Vérification pour Débutants)

Enfin, résumons les façons les plus utiles de créer des fichiers dans Ubuntu.

10.1 Méthodes Recommandées par Objectif

• Créer un fichier vide rapidement : touch file.txt
• Créer un fichier avec une ligne : echo "text" > file.txt
• Ajouter en toute sécurité : echo "text" >> file.txt
• Créer des fichiers multi-lignes : heredoc ( cat << 'EOF' > file )
• Créer avec un éditeur : nano file.txt ou éditeur GUI
• Créer par clic droit : dossier Templates

Si vous vous souvenez de ceux-ci, vous pouvez gérer la plupart des situations « créer un fichier » sur Ubuntu sans stress.

10.2 Flux de Travail Sûr pour Débutants (Éviter les Erreurs)

En tant que débutant, ce flux de travail est le plus sûr et le plus pratique :

1. Vérifier où vous êtes ( pwd )
2. Créer un fichier ( touch ou éditeur)
3. Confirmer qu’il existe ( ls )
4. Si nécessaire, vérifier les permissions ( ls -l )

Une fois à l’aise, vous pouvez commencer à utiliser la redirection et heredoc pour plus de rapidité.

10.3 Conseil Final : N’ayez Pas Peur du Terminal—Utilisez-le Étape par Étape

Ubuntu est puissant parce qu’il vous donne à la fois des options GUI et terminal.
Vous n’avez pas à maîtriser tout d’un coup.

Commencez avec :

• touch pour les fichiers vides
• Éditeur GUI pour écrire le contenu
• Templates pour la création de fichiers par clic droit

Et quand vous êtes prêt, ajoutez la redirection et heredoc pour un travail plus rapide.

Avec ces outils, vous pourrez créer des fichiers en douceur sur Ubuntu—que vous soyez débutant ou en train de passer à des tâches plus pratiques.