Get AI summaries of any video or article — Sign up free
Jongler avec les Propriétés dans Obsidian - Tuto avancé Obsidian thumbnail

Jongler avec les Propriétés dans Obsidian - Tuto avancé Obsidian

5 min read

Based on PKMind - Obsidian - Boostez votre Productivité's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Les propriétés d’Obsidian remplacent les tags “en YAML brut” par des champs gérés via une interface, ce qui rend la structuration plus fiable.

Briefing

Les propriétés (Properties) d’Obsidian, introduites comme changement majeur depuis la version 1.4 et renforcées avec 1.5, transforment la façon de structurer les notes : au lieu de tout passer par des tags en texte, les métadonnées deviennent éditables via une interface, puis exploitables proprement dans les recherches et dans Dataview. L’enjeu n’est pas seulement de “mieux ranger”, mais de rendre les requêtes fiables et de nettoyer durablement le contenu des notes en déplaçant les informations dans le front matter.

Avant, l’exemple typique consistait à utiliser des tags dans le front matter (YAML) pour décrire une note : “type: chanteur”, “type: compositeur”, etc. Avec les propriétés, l’interface permet d’activer un mode “source” pour voir le YAML, mais surtout de gérer les champs directement en mode graphique. Sur une note de Jacques Brel, il devient possible d’attribuer plusieurs valeurs à une même propriété “type” (par exemple “chanteur” et “compositeur”), puis d’ajouter d’autres propriétés comme “nationalité” (texte) ou des champs de type date, nombre, checkbox, liste, etc. Un raccourci clavier (configurable via une commande de type “Property add file properties”) accélère l’ajout de champs et de valeurs, tout en conservant la logique des tags historiques.

Une fois les propriétés en place, la recherche dans Obsidian permet de filtrer les notes via la syntaxe de requête : par exemple chercher `type: chanteur` pour ne retenir que les personnes associées à cette valeur. Le tutoriel insiste sur un point pratique : la casse (majuscule/minuscule) ne change pas le résultat pour la propriété “type”, ce qui évite des erreurs inutiles.

Avec la version 1.5, une “Property view” apparaît dans le panneau de droite (activable via les plugins de base). Elle liste les propriétés utilisées et permet de cliquer dessus pour générer automatiquement une recherche. Surtout, elle sert à renommer et corriger en masse : si une valeur a été saisie avec une faute (par exemple “TyP” au lieu de “type”), le renommage peut se propager à plusieurs notes. Le même mécanisme peut aussi convertir le type de propriété (par exemple transformer une valeur en “texte” au lieu d’un autre format), ce qui aide à faire le ménage.

La valeur ajoutée devient vraiment visible quand Dataview entre en jeu. Le tutoriel montre que les requêtes fonctionnent différemment selon le type de propriété : pour une propriété “texte” (ou un champ qui se comporte comme une valeur unique), une condition du type `type = chanteur` peut suffire. En revanche, dès qu’une propriété est une liste (plusieurs valeurs possibles), `type = ...` ne donne pas le bon résultat : il faut utiliser `contains` pour tester l’appartenance d’une valeur à la liste. L’exemple central oppose `type = chanteur` (qui échoue à inclure Jacques Brel quand “type” est une liste) à `contains type chanteur` (qui renvoie correctement les notes où la liste contient “chanteur”).

Enfin, le tutoriel met en garde contre deux pièges : supprimer les guillemets dans les requêtes Dataview peut faire perdre le critère, et forcer des comparaisons numériques sur des champs traités comme texte (ou l’inverse) casse le filtrage. La conclusion pratique est claire : consacrer un peu de temps à comprendre les types de propriétés et à tester des requêtes sur des données maîtrisées permet d’exploiter Dataview de façon précise et de gérer les notes avec une efficacité nettement supérieure.

Cornell Notes

Les propriétés d’Obsidian remplacent progressivement les tags “à la main” dans le front matter par des champs gérés via une interface. Elles permettent d’attribuer une ou plusieurs valeurs à une propriété (ex. “type” = chanteur/compositeur) et d’ajouter des métadonnées structurées (texte, nombre, date, checkbox, liste). La recherche Obsidian peut filtrer directement sur ces propriétés, et la Property view (v1.5) facilite le renommage et le nettoyage en masse. Avec Dataview, le comportement dépend du type : pour une propriété “liste”, il faut utiliser `contains` plutôt que `=`. Pour les nombres/dates, il faut aussi s’assurer que le champ est bien typé, sinon les comparaisons échouent ou deviennent imprécises.

Pourquoi passer de tags à des propriétés change-t-il vraiment la gestion des notes ?

Parce que les métadonnées deviennent des champs structurés éditables sans écrire du YAML à la main. On peut attribuer plusieurs valeurs à une même propriété (ex. “type” pour Jacques Brel : chanteur + compositeur) et ajouter d’autres champs (ex. “nationalité” en texte). Ensuite, ces champs servent de base à des recherches fiables et à des requêtes Dataview, tout en évitant de stocker des informations dans le corps du texte.

Comment filtrer des notes par “type” dans Obsidian ?

En utilisant la recherche avec une syntaxe de propriété, par exemple `type: chanteur`. Le tutoriel montre aussi que la casse (type vs Type) ne change pas le résultat pour cette propriété. En ajoutant une nouvelle note (Francis Cabrel) avec “bon chanteur”, la recherche `type: bon chanteur` renvoie uniquement les notes dont la propriété “type” contient cette valeur.

À quoi sert la Property view (v1.5) et comment aide-t-elle au “ménage” ?

La Property view liste les propriétés utilisées et permet de cliquer pour générer une recherche correspondante. Elle permet aussi de renommer des valeurs de propriété et de corriger des fautes en masse : si une valeur a été saisie avec une erreur (ex. “TyP”), le renommage peut se propager automatiquement aux notes concernées. Elle peut également convertir le type de propriété (ex. transformer une valeur en “texte”).

Pourquoi `type = chanteur` peut échouer quand “type” est une liste dans Dataview ?

Parce qu’une propriété de type liste contient plusieurs valeurs. Dans ce cas, `type = chanteur` ne teste pas l’appartenance d’une valeur à la liste. Le tutoriel montre que `type = chanteur` ne renvoie pas Jacques Brel quand “type” est une liste contenant à la fois “chanteur” et “bon chanteur”. La solution est d’utiliser `contains type chanteur`, qui renvoie les notes où la liste contient bien la valeur demandée.

Que se passe-t-il si on enlève les guillemets dans une requête Dataview ?

Le critère peut ne plus être interprété correctement. Le tutoriel illustre que retirer les guillemets autour d’une valeur peut faire “perdre” le filtre, rendant la requête moins précise (ou inopérante).

Pourquoi les comparaisons numériques peuvent échouer dans Dataview ?

Si le champ est traité comme du texte au lieu d’un nombre. Le tutoriel montre un champ “année découverte” : tant qu’il est typé comme chaîne, une condition numérique du type `where année découverte = 2000` ne fonctionne pas comme attendu. Après avoir forcé le type en “nombre”, les comparaisons (ex. `> 1985`) deviennent cohérentes.

Review Questions

  1. Quand faut-il préférer `contains type ...` à `type = ...` dans Dataview, et quel type de propriété déclenche ce besoin ?
  2. Comment la Property view aide-t-elle à corriger des erreurs de saisie (ex. fautes dans les valeurs) sans devoir modifier chaque note manuellement ?
  3. Quels symptômes indiquent qu’une propriété est typée comme texte au lieu d’un nombre dans Dataview ?

Key Points

  1. 1

    Les propriétés d’Obsidian remplacent les tags “en YAML brut” par des champs gérés via une interface, ce qui rend la structuration plus fiable.

  2. 2

    Une même propriété peut porter plusieurs valeurs (ex. “type” = chanteur + compositeur), ce qui change la logique de filtrage.

  3. 3

    La recherche Obsidian permet de filtrer sur des propriétés via une syntaxe du type `type: valeur`, et la casse ne change pas le résultat pour “type”.

  4. 4

    La Property view (v1.5) centralise les propriétés utilisées et facilite le renommage/correction en masse des valeurs.

  5. 5

    Dans Dataview, une propriété de type liste nécessite `contains` pour tester l’appartenance d’une valeur, alors que `=` peut échouer.

  6. 6

    Les guillemets et le typage (texte vs nombre) influencent directement la réussite des requêtes Dataview.

  7. 7

    Tester des requêtes sur des données maîtrisées aide à éviter les pièges liés aux types et aux syntaxes (notamment listes, guillemets, comparaisons).

Highlights

Les propriétés rendent les métadonnées éditables sans écrire du YAML à la main, tout en conservant la compatibilité front matter.
La Property view permet de renommer et corriger des valeurs de propriétés sur plusieurs notes, y compris quand des fautes existent.
Dans Dataview, `contains type chanteur` est la clé quand “type” est une liste ; `type = chanteur` peut manquer des notes.
Le typage compte : comparer un nombre comme s’il était du texte (ou l’inverse) fait échouer les filtres.
Supprimer les guillemets dans certaines requêtes peut faire perdre le critère de filtrage.

Topics

Mentioned

  • YAML
  • Dataview