{"id":395874,"date":"2022-01-19T02:41:35","date_gmt":"2022-01-18T23:41:35","guid":{"rendered":"https:\/\/en.buradabiliyorum.com\/what-are-uuids-and-why-are-they-useful-cloudsavvy-it\/"},"modified":"2022-01-19T02:41:35","modified_gmt":"2022-01-18T23:41:35","slug":"what-are-uuids-and-why-are-they-useful-cloudsavvy-it","status":"publish","type":"post","link":"https:\/\/buradabiliyorum.com\/en\/what-are-uuids-and-why-are-they-useful-cloudsavvy-it\/","title":{"rendered":"#What Are UUIDs and Why Are They Useful? \u2013 CloudSavvy IT"},"content":{"rendered":"<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_85 counter-hierarchy ez-toc-counter ez-toc-custom ez-toc-container-direction\">\n<p class=\"ez-toc-title\" style=\"cursor:inherit\">Table of Contents<\/p>\n<label for=\"ez-toc-cssicon-toggle-item-6a32603f409e0\" class=\"ez-toc-cssicon-toggle-label\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #dd3333;color:#dd3333\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #dd3333;color:#dd3333\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewBox=\"0 0 24 24\" version=\"1.2\" baseProfile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/label><input type=\"checkbox\"  id=\"ez-toc-cssicon-toggle-item-6a32603f409e0\" checked aria-label=\"Toggle\" \/><nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/buradabiliyorum.com\/en\/what-are-uuids-and-why-are-they-useful-cloudsavvy-it\/#What_Actually_Is_a_UUID\" >What Actually Is a UUID?<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/buradabiliyorum.com\/en\/what-are-uuids-and-why-are-they-useful-cloudsavvy-it\/#UUID_Use_Cases\" >UUID Use Cases<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/buradabiliyorum.com\/en\/what-are-uuids-and-why-are-they-useful-cloudsavvy-it\/#Caveats_When_UUIDs_Meet_Databases\" >Caveats When UUIDs Meet Databases<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/buradabiliyorum.com\/en\/what-are-uuids-and-why-are-they-useful-cloudsavvy-it\/#Summary\" >Summary<\/a><\/li><\/ul><\/nav><\/div>\n<p><strong>&#8220;#What Are UUIDs and Why Are They Useful? \u2013 CloudSavvy IT&#8221;<\/strong><\/p>\n<div id=\"article-content-area\">\n<figure style=\"width: 1200px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"type:primaryImage size-full wp-image-15350\" data-pagespeed-lazy-srcset=\"https:\/\/www.cloudsavvyit.com\/p\/uploads\/2022\/01\/18b85c9b.jpg?width=398&amp;trim=1,1&amp;bg-color=000&amp;pad=1,1 400w, https:\/\/www.cloudsavvyit.com\/p\/uploads\/2022\/01\/18b85c9b.jpg?width=1198&amp;trim=1,1&amp;bg-color=000&amp;pad=1,1 1200w\" sizes=\"auto, 400w, 1200w\" data-pagespeed-lazy-src=\"https:\/\/www.cloudsavvyit.com\/p\/uploads\/2022\/01\/18b85c9b.jpg?width=1198&amp;trim=1,1&amp;bg-color=000&amp;pad=1,1\" alt=\"Illustration showing a laptop and document box files above it\" width=\"1200\" height=\"675\" src=\"\/pagespeed_static\/1.JiBnMqyl6S.gif\" onload=\"pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon(this);\" onerror=\"this.onerror=null;pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon(this);\"\/><figcaption class=\"wp-caption-text\"><span class=\"type:primaryImage imagecredit\"><a rel=\"nofollow noopener\" target=\"_blank\" href=\"https:\/\/www.shutterstock.com\/image-photo\/organized-archive-ring-binders-woman-searching-1029020020\">Stokkete\/Shutterstock.com<\/a><\/span><\/figcaption><\/figure>\n<p>A Universally Unique Identifier (UUID) is a specific form of identifier which can be safely deemed unique for most practical purposes. Two correctly generated UUIDs have a virtually negligible chance of being identical, even if they\u2019re created in two different environments by separate parties. This is why UUIDs are said to be <em>universally<\/em> unique.<\/p>\n<p>In this article, we\u2019ll look at the characteristics of UUIDs, how their uniqueness works, and the scenarios where they can simplify resource identification. Although we\u2019ll be <a href=\"https:\/\/buradabiliyorum.com\/en\/category\/download-scripts-themes-apps\/\" data-internallinksmanager029f6b8e52c=\"9\" title=\"Download Scripts &amp; Themes &amp; Apps\" target=\"_blank\" rel=\"noopener\">app<\/a>roaching UUIDs from the common perspective of software that interacts with database records, they are broadly applicable to any use case where decentralized unique ID generation is required.<\/p>\n<h2 id=\"what-actually-is-a-uuid\"><span class=\"ez-toc-section\" id=\"What_Actually_Is_a_UUID\"><\/span>What Actually Is a UUID?<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>A UUID is simply a value which you can safely treat as unique. The risk of collision is so low that you can reasonably choose to ignore it altogether. You may see UUIDs referred to using different terms (GUID, or Globally Unique Identifier, is Microsoft\u2019s preferred semantic) but the meaning and effect remains the same.<\/p>\n<p>A true UUID is a unique identifier that\u2019s generated and represented by a standardized format. Valid UUIDs are defined by <a rel=\"nofollow noopener\" target=\"_blank\" href=\"https:\/\/datatracker.ietf.org\/doc\/html\/rfc4122\">RFC 4122<\/a>; this specification describes the algorithms that can be used to generate UUIDs that preserve uniqueness across implementations, without a central issuing authority.<\/p>\n<p>The RFC includes five different algorithms which each use a different mechanism to produce a value. Here\u2019s a brief summary of the available \u201cversions\u201d:<\/p>\n<ul>\n<li><strong>Version 1 \u2013 Time-Based<\/strong> \u2013 Combines a timestamp, a clock sequence, and a value that\u2019s specific to the generating device (usually its MAC address) to produce an output that\u2019s unique for that host at that point in time.<\/li>\n<li><strong>Version 2 \u2013 DCE Security<\/strong> \u2013 This version was developed as an evolution of Version 1 for use with Distributed Computing Environment (<a rel=\"nofollow noopener\" target=\"_blank\" href=\"https:\/\/en.wikipedia.org\/wiki\/Distributed_Computing_Environment\">DCE<\/a>). It is not widely used.<\/li>\n<li><strong>Version 3 \u2013 Name-Based (MD5)<\/strong> \u2013 MD5 hashes a \u201cnamespace\u201d and a \u201cname\u201d to create a value that\u2019s unique for that name within the namespace. Generating another UUID with the same namespace and name will produce identical output so this method delivers reproducible results.<\/li>\n<li><strong>Version 4 \u2013 Random<\/strong> \u2013 Most modern systems tend to opt for UUID v4 as it uses the host\u2019s source of random or pseudo-random numbers to issue its values. The chances of the same UUID being produced twice are virtually negligible.<\/li>\n<li><strong>Version 5 \u2013 Name-Based (SHA-1)<\/strong> \u2013 This is similar to Version 3 but it uses the stronger SHA-1 algorithm to hash the input namespace and name.<\/li>\n<\/ul>\n<p>Although the RFC refers to the algorithms as versions, that does not mean you should always use Version 5 because it\u2019s seemingly the newest. The one to choose depends on your use case; in many scenarios, v4 is chosen because of its random nature. This makes it the ideal candidate for simple \u201cgive me a new identifier\u201d scenarios.<\/p>\n<p>Generation algorithms emit a 128-bit unsigned integer. However, UUIDs are more commonly seen as hexadecimal strings and can also be stored as a binary sequence of 16 characters. Here\u2019s an example of a UUID string:<\/p>\n<pre>16763be4-6022-406e-a950-fcd5018633ca<\/pre>\n<p>The value is represented as five groups of alphanumeric characters separated by dash characters. The dashes are not a mandatory component of the string; their presence is <a rel=\"nofollow noopener\" target=\"_blank\" href=\"https:\/\/stackoverflow.com\/questions\/417108\/why-are-there-dashes-in-a-net-guid\/3557678#3557678\">down to historic details<\/a> of the UUID specification. They also make the identifier much easier for human eyes to perceive.<\/p>\n<h2 id=\"uuid-use-cases\"><span class=\"ez-toc-section\" id=\"UUID_Use_Cases\"><\/span>UUID Use Cases<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The principal use case for UUIDs is decentralized generation of unique identifiers. You can generate the UUID anywhere and safely consider it to be unique, whether it originates from your backend code, a client device, or your database engine.<\/p>\n<p>UUIDs simplify determining and maintaining object identity across disconnected environments. Historically most applications used an auto-incrementing integer field as a primary key. When you\u2019re creating a new object, you couldn\u2019t know its ID until <em>after<\/em> it had been inserted into the database. UUIDs let you determine identity much earlier on in your application.<\/p>\n<p>Here\u2019s a basic PHP demo that demonstrates the difference. Let\u2019s look at the integer-based system first:<\/p>\n<div class=\"wp-geshi-highlight-wrap5\">\n<div class=\"wp-geshi-highlight-wrap4\">\n<div class=\"wp-geshi-highlight-wrap3\">\n<div class=\"wp-geshi-highlight-wrap2\">\n<div class=\"wp-geshi-highlight-wrap\">\n<div class=\"wp-geshi-highlight\">\n<div class=\"php\">\n<pre class=\"de1\"><span class=\"kw2\">class<\/span> BlogPost <span class=\"br0\">{<\/span>\n    <span class=\"kw2\">public<\/span> <span class=\"kw2\">function<\/span> __construct<span class=\"br0\">(<\/span>\n        <span class=\"kw2\">public<\/span> readonly ?int <span class=\"re0\">$Id<\/span><span class=\"sy0\">,<\/span>\n        <span class=\"kw2\">public<\/span> readonly string <span class=\"re0\">$Headline<\/span><span class=\"sy0\">,<\/span>\n        <span class=\"kw2\">public<\/span> readonly ?AuthorCollection <span class=\"re0\">$Authors<\/span><span class=\"sy0\">=<\/span><span class=\"kw4\">null<\/span><span class=\"br0\">)<\/span> <span class=\"br0\">{<\/span><span class=\"br0\">}<\/span>\n<span class=\"br0\">}<\/span>\n\u00a0\n<span class=\"co2\">#[POST(\"\/posts\")]\n<\/span><span class=\"kw2\">function<\/span> createBlogPost<span class=\"br0\">(<\/span>HttpRequest <span class=\"re0\">$Request<\/span><span class=\"br0\">)<\/span> <span class=\"sy0\">:<\/span> void <span class=\"br0\">{<\/span>\n    <span class=\"re0\">$headline<\/span> <span class=\"sy0\">=<\/span> <span class=\"re0\">$Request<\/span> <span class=\"sy0\">-&gt;<\/span> <span class=\"me1\">getField<\/span><span class=\"br0\">(<\/span><span class=\"st0\">\"Headline\"<\/span><span class=\"br0\">)<\/span><span class=\"sy0\">;<\/span>\n    <span class=\"re0\">$blogPost<\/span> <span class=\"sy0\">=<\/span> <span class=\"kw2\">new<\/span> BlogPost<span class=\"br0\">(<\/span><span class=\"kw4\">null<\/span><span class=\"sy0\">,<\/span> <span class=\"re0\">$headline<\/span><span class=\"br0\">)<\/span><span class=\"sy0\">;<\/span>\n<span class=\"br0\">}<\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<p>We have to initialize the <code>$Id<\/code> property with <code>null<\/code> because we can\u2019t know it\u2019s actual ID until <em>after<\/em> it\u2019s been persisted to the database. This is not ideal \u2013 <code>$Id<\/code> shouldn\u2019t really be nullable and it allows <code>BlogPost<\/code> instances to exist in an incomplete state.<\/p>\n<p>Changing to UUIDs addresses the problem:<\/p>\n<div class=\"wp-geshi-highlight-wrap5\">\n<div class=\"wp-geshi-highlight-wrap4\">\n<div class=\"wp-geshi-highlight-wrap3\">\n<div class=\"wp-geshi-highlight-wrap2\">\n<div class=\"wp-geshi-highlight-wrap\">\n<div class=\"wp-geshi-highlight\">\n<div class=\"php\">\n<pre class=\"de1\"><span class=\"kw2\">class<\/span> BlogPost <span class=\"br0\">{<\/span>\n    <span class=\"kw2\">public<\/span> <span class=\"kw2\">function<\/span> __construct<span class=\"br0\">(<\/span>\n        <span class=\"kw2\">public<\/span> readonly string <span class=\"re0\">$Uuid<\/span><span class=\"sy0\">,<\/span>\n        <span class=\"kw2\">public<\/span> readonly string <span class=\"re0\">$Headline<\/span><span class=\"sy0\">,<\/span>\n        <span class=\"kw2\">public<\/span> readonly ?AuthorCollection <span class=\"re0\">$Authors<\/span><span class=\"sy0\">=<\/span><span class=\"kw4\">null<\/span><span class=\"br0\">)<\/span> <span class=\"br0\">{<\/span><span class=\"br0\">}<\/span>\n<span class=\"br0\">}<\/span>\n\u00a0\n<span class=\"co2\">#[POST(\"\/posts\")]\n<\/span><span class=\"kw2\">function<\/span> createBlogPost<span class=\"br0\">(<\/span>HttpRequest <span class=\"re0\">$Request<\/span><span class=\"br0\">)<\/span> <span class=\"sy0\">:<\/span> void <span class=\"br0\">{<\/span>\n    <span class=\"re0\">$headline<\/span> <span class=\"sy0\">=<\/span> <span class=\"re0\">$Request<\/span> <span class=\"sy0\">-&gt;<\/span> <span class=\"me1\">getField<\/span><span class=\"br0\">(<\/span><span class=\"st0\">\"Headline\"<\/span><span class=\"br0\">)<\/span><span class=\"sy0\">;<\/span>\n    <span class=\"re0\">$blogPost<\/span> <span class=\"sy0\">=<\/span> <span class=\"kw2\">new<\/span> BlogPost<span class=\"br0\">(<\/span><span class=\"st0\">\"16763be4-...\"<\/span><span class=\"sy0\">,<\/span> <span class=\"re0\">$headline<\/span><span class=\"br0\">)<\/span><span class=\"sy0\">;<\/span>\n<span class=\"br0\">}<\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<p>Post identifiers can now be generated within the application without risking duplicate values. This ensures object instances always represent a valid state and don\u2019t need clunky nullable ID properties. The model makes it easier to handle transactional logic too; child records which need a reference to their parent (such as our post\u2019s <code>Author<\/code> associations) can be inserted im<a href=\"https:\/\/buradabiliyorum.com\/en\/category\/social-mediaa\/\" data-internallinksmanager029f6b8e52c=\"1\" title=\"Social Media\" target=\"_blank\" rel=\"noopener\">media<\/a>tely, without a database round-<a href=\"https:\/\/buradabiliyorum.com\/en\/category\/trip-and-travel\/\" data-internallinksmanager029f6b8e52c=\"10\" title=\"Trip &amp; Travel\" target=\"_blank\" rel=\"noopener\">trip<\/a> to fetch the ID the parent was assigned.<\/p>\n<p>In the future, your blog application might move more logic into the client. Perhaps the frontend gains support for full offline draft creation, effectively creating <code>BlogPost<\/code> instances that are temporarily persisted to the user\u2019s device. Now the client could generate the post\u2019s UUID and transmit it to the server when network connectivity is regained. If the client subsequently retrieved the server\u2019s copy of the draft, it could match it up to any remaining local state as the UUID would already be known.<\/p>\n<p>UUIDs also help you combine data from various sources. Merging database tables and caches that use integer keys can be tedious and error-prone. UUIDs offer uniqueness not only within tables but at the level of the entire universe. This makes them much better candidates for replicated structures and data that\u2019s frequently moved between different storage systems.<\/p>\n<h2 id=\"caveats-when-uuids-meet-databases\"><span class=\"ez-toc-section\" id=\"Caveats_When_UUIDs_Meet_Databases\"><\/span>Caveats When UUIDs Meet Databases<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>The benefits of UUIDs are quite compelling. However, there are several gotchas to watch for when using them in real systems. One big factor in favor of integer IDs is they\u2019re easy to scale and optimize. Database engines can readily index, sort, and filter a list of numbers that\u2019s only going in one direction.<\/p>\n<p>The same can\u2019t be said for UUIDs. To begin with, UUIDs are four times bigger than integers (36 bytes vs 4 bytes); for large datasets, this could be a significant consideration in itself. The values are also much trickier to sort and index, particularly in the case of the most common random UUIDs. Their random nature means they have no natural order. This will harm indexing performance if you use a UUID as a primary key.<\/p>\n<p>These problems can compound in a well-normalized database that makes heavy use of foreign keys. Now you may have many relational tables, each containing references to your 36-byte UUIDs. Eventually the extra memory needed to perform joins and sorts could have a significant impact on your system\u2019s performance.<\/p>\n<p>You can partially mitigate the issues by storing your UUIDs as binary data. That means a <code>BINARY(16)<\/code> column instead of <code>VARCHAR(36)<\/code>. Some databases such as PostgreSQL include a built-in <code>UUID<\/code> datatype; others <a rel=\"nofollow noopener\" target=\"_blank\" href=\"https:\/\/dev.mysql.com\/doc\/refman\/8.0\/en\/miscellaneous-functions.html#function_bin-to-uuid\">like MySQL<\/a> have functions that can convert a UUID string to its binary representation, and vice versa. This approach is more efficient but remember you\u2019ll still be using extra resources to store and select your data.<\/p>\n<p>An effective strategy can be to retain integers as your primary keys but add an extra UUID field for your application\u2019s reference. Relational link tables could use IDs to enhance performance while your code fetches and inserts top-level objects with UUIDs. It all comes down to your system, its scale, and your priorities: when you need decentralized ID generation and straightforward data merges, UUIDs are the best option but you need to recognize the trade offs.<\/p>\n<h2 id=\"summary\"><span class=\"ez-toc-section\" id=\"Summary\"><\/span>Summary<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p>UUIDs are unique values which you can safely use for decentralized identity generation. Collisions <em>are<\/em> possible but should be so rare they can be discarded from consideration. If you generated one billion UUIDs a second for an entire century, the probability of encountering a duplicate <a rel=\"nofollow noopener\" target=\"_blank\" href=\"https:\/\/en.wikipedia.org\/w\/index.php?title=Universally_unique_identifier&amp;oldid=755882275#Random_UUID_probability_of_duplicates\">would be around 50%<\/a> assuming sufficient entropy was available.<\/p>\n<p>You can use UUIDs to establish identity independently of your database, before an insert occurs. This simplifies application-level code and prevents improperly identified objects from existing in your system. UUIDs also aid data replication by guaranteeing uniqueness irrespective of data store, device, or environment, unlike traditional integer keys that operate at the table level.<\/p>\n<p>While UUIDs are now ubiquitous in software development, they are not a perfect solution. Newcomers tend to fixate on the possibility of collisions but this should not be your prime consideration, unless your system is so sensitive that uniqueness must be guaranteed.<\/p>\n<p>The more apparent challenge for most developers concerns the storage and retrieval of generated UUIDs. Naively using a <code>VARCHAR(36)<\/code> (or stripping out the hyphens and using <code>VARCHAR(32)<\/code>) could cripple your application over time as most database indexing optimizations will be ineffective. Research the built-in UUID handling capabilities of your database system to ensure you get the best possible performance from your solution.\n<\/div>\n<blockquote><p><strong><span style=\"color: #ff6600;\">If you liked the article, do not forget to share it with your friends. Follow us on\u00a0<span style=\"color: #ff0000;\"><a style=\"color: #ff0000;\" href=\"https:\/\/news.google.com\/publications\/CAAqBwgKMLG0nwswvr63Aw\" target=\"_blank\" rel=\"nofollow noopener noreferrer\">Google News<\/a><\/span>\u00a0too, click on the star and choose us from your favorites.<\/span><\/strong><\/p><\/blockquote>\n<blockquote>\n<p style=\"text-align: center;\">For forums sites go to <span style=\"color: #ff9900;\"><a style=\"color: #ff9900;\" href=\"https:\/\/forum.buradabiliyorum.com\/\" target=\"_blank\" rel=\"noopener\">Forum.BuradaBiliyorum.Com<\/a><\/span><\/strong><\/p>\n<\/blockquote>\n<blockquote>\n<p style=\"text-align: center;\"><strong>If you want to read more like this article, you can visit our <span style=\"color: #ff9900;\"><a style=\"color: #ff9900;\" href=\"https:\/\/en.buradabiliyorum.com\/technology\/\" target=\"_blank\" rel=\"noopener\">Technology category.<\/a><\/span><\/strong><\/p>\n<\/blockquote>\n<p><span style=\"color: black;\"><a style=\"color: #ff9900;\" href=\"https:\/\/www.cloudsavvyit.com\/15347\/what-are-uuids-and-why-are-they-useful\/\" target=\"_blank\" rel=\"noopener\">Source<\/a><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"<p>&#8220;#What Are UUIDs and Why Are They Useful? \u2013 CloudSavvy IT&#8221; Stokkete\/Shutterstock.com A Universally Unique Identifier (UUID) is a specific form of identifier which can be safely deemed unique for most practical purposes. Two correctly generated UUIDs have a virtually negligible chance of being identical, even if they\u2019re created in two different environments by separate&#8230;<\/p>\n","protected":false},"author":1,"featured_media":395875,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"fifu_image_url":"https:\/\/www.cloudsavvyit.com\/p\/uploads\/2022\/01\/18b85c9b.jpg","fifu_image_alt":"","footnotes":""},"categories":[18],"tags":[],"class_list":["post-395874","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-technology"],"_links":{"self":[{"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/posts\/395874","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/comments?post=395874"}],"version-history":[{"count":0,"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/posts\/395874\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/media\/395875"}],"wp:attachment":[{"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/media?parent=395874"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/categories?post=395874"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/buradabiliyorum.com\/en\/wp-json\/wp\/v2\/tags?post=395874"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}