{"id":123284,"date":"2024-02-10T18:00:09","date_gmt":"2024-02-10T12:30:09","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=123284"},"modified":"2024-02-10T18:34:03","modified_gmt":"2024-02-10T13:04:03","slug":"call-by-value-and-call-by-reference-in-c","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/","title":{"rendered":"Difference Between Call by Value and Call by Reference in C"},"content":{"rendered":"<h2>Introduction to Function Parameter Passing<\/h2>\n<p>In C programming, there are two main ways to pass parameters to functions &#8211; call by value and call by reference. Understanding how these parameter-passing mechanisms work is crucial for writing efficient C code.<\/p>\n<p>When a function is invoked in C, the values provided as arguments are known as actual parameters. The variables defined in the function declaration that accept these values are called formal parameters. The relationship between actual and formal parameters determines how C handles parameter passing.<\/p>\n<h3>Call by Value in C<\/h3>\n<p>In C, calling a function by value is the default way of giving parameters. The values of the actual parameters are replicated into the formal parameters when call by value is used.<\/p>\n<p><strong>Here is a simple example:<\/strong><\/p>\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"generic\">#include &lt;stdio.h&gt;\r\n\r\nvoid swap(int a, int b) {\r\n  int temp = a;\r\n  a = b;  \r\n  b = temp;\r\n}\r\n\r\nint main() {\r\n\r\n  int x = 99;\r\n  int y = 199;\r\n\r\n  printf(\"Before swap: x = %d, y = %d\\n\", x, y);  \r\n\r\n  swap(x, y);\r\n\r\n  printf(\"After swap: x = %d, y = %d\\n\", x, y);\r\n  \r\n  return 0;\r\n}<\/pre>\n<p><strong>Output:<\/strong><br \/>\n<strong>Before swap:<\/strong> x = 199, y = 99<br \/>\n<strong>After swap:<\/strong> x = 99, y = 99<\/p>\n<p>In this program, x and y are passed to the swap() function using call by value. The swap() function receives copies of x and y in the formal parameters a and b. Swapping the values of a and b has no effect on the actual parameters x and y in main().<\/p>\n<h4>Key points about the call by value:<\/h4>\n<ul>\n<li>Formal parameters get copies of the actual values allocated in different memory locations.<\/li>\n<li>Any changes made to formal parameters do not affect the actual parameters.<\/li>\n<\/ul>\n<h3>Call by Reference in C<\/h3>\n<p>In call by reference, instead of passing copies of values, the addresses of the actual parameters are passed to the formal parameters. This allows both the actual and formal parameters to refer to the same memory locations.<\/p>\n<p><strong>Here is an example of call by reference in C using pointers:<\/strong><\/p>\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"generic\">#include &lt;stdio.h&gt;\r\n\r\nvoid swap(int *a, int *b) {\r\n  int temp = *a;\r\n  *a = *b;\r\n  *b = temp;  \r\n}\r\n\r\nint main() {\r\n\r\n  int x = 199;\r\n  int y = 99;\r\n\r\n  printf(\"Before swap: x = %d, y = %d\\n\", x, y);\r\n\r\n  swap(&amp;x, &amp;y);  \r\n\r\n  printf(\"After swap: x = %d, y = %d\\n\", x, y);\r\n  \r\n  return 0;\r\n}<\/pre>\n<p><strong>Output:<\/strong><br \/>\n<strong>Before swap:<\/strong> x = 199, y = 99<br \/>\n<strong>After swap:<\/strong> x = 99, y = 199<\/p>\n<p>Here, the addresses of x and y are passed to pointers a and b respectively. Now, both x, y and a, b refer to the same locations, so swapping in the function also swaps the values in main().<\/p>\n<h4>Key points about call by reference:<\/h4>\n<ul>\n<li>Addresses of actual parameters are passed to formal parameters.<\/li>\n<li>The same memory locations are referred to by both the formal and real parameters.<\/li>\n<li>Changes made in the function are reflected back in the calling function.<\/li>\n<\/ul>\n<h3>Differences between Call by Value and Call by Reference in C<\/h3>\n<table>\n<tbody>\n<tr>\n<td><b>Basis of Comparison<\/b><\/td>\n<td><b>Call By Value<\/b><\/td>\n<td><b>Call By Reference<\/b><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Parameter passing<\/span><\/td>\n<td><span style=\"font-weight: 400\">The values of actual parameters are copied to formal parameters<\/span><\/td>\n<td><span style=\"font-weight: 400\">The addresses of actual parameters are passed to formal parameters<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Access to actual parameters<\/span><\/td>\n<td><span style=\"font-weight: 400\">Formal parameters get a copy of the value, allocated separately in memory. There is no access to actual parameters.<\/span><\/td>\n<td><span style=\"font-weight: 400\">Actual parameters and formal parameters both relate to the same memory address. It is possible to change the real settings.<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Changes to formal parameters<\/span><\/td>\n<td><span style=\"font-weight: 400\">Changes made to formal parameters do not impact actual parameters<\/span><\/td>\n<td><span style=\"font-weight: 400\">Changes made to formal parameters modify the actual parameters<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Necessary syntax<\/span><\/td>\n<td><span style=\"font-weight: 400\">Simple passing of values to parameters<\/span><\/td>\n<td><span style=\"font-weight: 400\">Pointer syntax needed to pass addresses to parameters<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Use cases<\/span><\/td>\n<td><span style=\"font-weight: 400\">When a function needs to work on a copy of data without modifying the original<\/span><\/td>\n<td><span style=\"font-weight: 400\">When a function needs to modify the actual arguments passed to it<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Performance and memory<\/span><\/td>\n<td><span style=\"font-weight: 400\">Additional memory is needed to make copies. Less efficient.<\/span><\/td>\n<td><span style=\"font-weight: 400\">More efficient as no copying is required. But risks inadvertent changes.<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Data amount<\/span><\/td>\n<td><span style=\"font-weight: 400\">Best for passing small amounts of data<\/span><\/td>\n<td><span style=\"font-weight: 400\">Useful when passing large amounts of data<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Variable manipulation<\/span><\/td>\n<td><span style=\"font-weight: 400\">Cannot manipulate actual variables<\/span><\/td>\n<td><span style=\"font-weight: 400\">Can directly manipulate actual variables<\/span><\/td>\n<\/tr>\n<tr>\n<td><span style=\"font-weight: 400\">Preferred usage<\/span><\/td>\n<td><span style=\"font-weight: 400\">When actual parameters should not be changed<\/span><\/td>\n<td><span style=\"font-weight: 400\">When a function needs to change actual parameters<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><a href=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/Differences-between-Call-by-Value-and-Call-by-Reference.webp\"><img loading=\"lazy\" decoding=\"async\" class=\"aligncenter wp-image-130512 size-full\" src=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/Differences-between-Call-by-Value-and-Call-by-Reference.webp\" alt=\"Differences between Call by Value and Call by Reference\" width=\"400\" height=\"235\" \/><\/a><\/p>\n<h3>Examples to Illustrate Call by Value and Call by Reference in C<\/h3>\n<p><strong>Here are some additional examples to demonstrate call by value and call by reference:<\/strong><\/p>\n<h4>Call by Value<\/h4>\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"generic\">void cubeByVal(int n) {\r\n  n = n * n * n; \r\n}\r\n\r\nint main() {\r\n  int num = 5;\r\n  cubeByVal(num);\r\n  printf(\"Number is %d\", num); \/\/ 5  \r\n}<\/pre>\n<p><strong>Output:<\/strong><br \/>\nNumber is 5<\/p>\n<p>Since a copy of num is passed, the value remains unchanged.<\/p>\n<h4>Call by Reference<\/h4>\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"generic\">void cubeByRef(int *n) {\r\n  *n = *n * *n * *n;\r\n}\r\n\r\nint main() {\r\n  int num = 5;\r\n  cubeByRef(&amp;num);\r\n  printf(\"Number is %d\", num); \/\/ 125\r\n}<\/pre>\n<p><strong>Output:<\/strong><br \/>\nNumber is 125<\/p>\n<p>Here num is passed by reference and modified.<\/p>\n<h3>Use Call by Value and Call by Reference in C<\/h3>\n<p>So when should you use call by value vs call by reference in C?<\/p>\n<h4>Use call by value when:<\/h4>\n<ul>\n<li>You want to avoid the side effects of modifying actual parameters.<\/li>\n<li>Function needs to work on a copy of data without changing the original.<\/li>\n<\/ul>\n<h4>Use call by reference when:<\/h4>\n<ul>\n<li>Function needs to modify the actual arguments.<\/li>\n<li>Need higher performance by avoiding copying data.<\/li>\n<li>Don&#8217;t mind side effects on actual parameters.<\/li>\n<\/ul>\n<p>Call by reference has performance benefits as data is not copied. But it can cause inadvertent changes to variables in the calling code.<\/p>\n<h3>Advantages and Disadvantages of Call by Value and Call by Reference in C<\/h3>\n<p>There are certain tradeoffs to consider when choosing between call by value and call by reference in C functions.<\/p>\n<p><strong>Let&#8217;s examine the pros and cons of each method:<\/strong><\/p>\n<h4>Advantages of Call by Value<\/h4>\n<ul>\n<li><strong>Isolation:<\/strong> The function cannot modify the actual arguments passed to it. This avoids inadvertent side effects on variables in the calling function.<\/li>\n<li><strong>Data protection:<\/strong> The function works on a separate copy of the data rather than directly accessing the original data. This is safer.<\/li>\n<li><strong>Reusability:<\/strong> As the function cannot modify original data, it is less likely to cause issues when reused with other parameters.<\/li>\n<li><strong>Testing:<\/strong> call by value allows easy testing functions with different arguments since no changes are persistent.<\/li>\n<\/ul>\n<h4>Disadvantages of Call by Value<\/h4>\n<ul>\n<li><strong>Memory:<\/strong> Additional memory is required to make copies of arguments for the function parameters.<\/li>\n<li><strong>Performance:<\/strong> Copying arguments takes processing time and reduces efficiency, especially for large data structures.<\/li>\n<li><strong>No modification:<\/strong> Since copies are passed, any changes made inside the function are not reflected in the calling function.<\/li>\n<\/ul>\n<h4>Advantages of Call by Reference<\/h4>\n<ul>\n<li><strong>Efficiency:<\/strong> No copying of arguments takes place since pointers to the original data are used. This improves performance.<\/li>\n<li><strong>Modification:<\/strong> The function can modify the actual arguments passed to it. Any changes made are reflected back.<\/li>\n<li><strong>Memory:<\/strong> No extra memory is needed as no copying takes place. More efficient for large data structures.<\/li>\n<\/ul>\n<h4>Disadvantages of Call by Reference<\/h4>\n<ul>\n<li><strong>No isolation:<\/strong> Lack of isolation means the function can modify the actual parameters unexpectedly.<\/li>\n<li><strong>Side effects:<\/strong> Changes made to actual parameters in the function lead to side effects in the calling code.<\/li>\n<li><strong>Pointer handling:<\/strong> Pointers can be mishandled, leading to unexpected results and errors. Needs more care.<\/li>\n<li><strong>Testing:<\/strong> Repeated testing is harder since calls modify data persistently.<\/li>\n<\/ul>\n<h3>Conclusion<\/h3>\n<p>Understanding parameter passing mechanisms is vital for writing good C programs. Call by value and call by reference in C allows passing data to functions in different ways.<\/p>\n<p>Call by value maintains isolation while call by reference allows modifying actual arguments. Knowing their precise differences in terms of memory, impact, and performance will help them choose the right technique and write better C code.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Introduction to Function Parameter Passing In C programming, there are two main ways to pass parameters to functions &#8211; call by value and call by reference. Understanding how these parameter-passing mechanisms work is crucial&#46;&#46;&#46;<\/p>\n","protected":false},"author":86671,"featured_media":123794,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[19488],"tags":[29954,23914,2263,29219,29557,29953,29956,29955],"class_list":["post-123284","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-programming","tag-c-call-by-value-and-call-by-reference","tag-c-programming","tag-c","tag-c-practical","tag-call-by-reference-in-c","tag-call-by-value-and-call-by-reference-in-c","tag-call-by-value-in-c","tag-difference-between-call-by-value-and-call-by-reference-in-c"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.8 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Difference Between Call by Value and Call by Reference in C - DataFlair<\/title>\n<meta name=\"description\" content=\"Call by value and call by reference allow passing data to functions in different ways. Call by value maintains isolation while call by reference allows modifying actual arguments.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Difference Between Call by Value and Call by Reference in C - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Call by value and call by reference allow passing data to functions in different ways. Call by value maintains isolation while call by reference allows modifying actual arguments.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-02-10T12:30:09+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-02-10T13:04:03+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/call-by-reference-in-c.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"TechVidvan Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"TechVidvan Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Difference Between Call by Value and Call by Reference in C - DataFlair","description":"Call by value and call by reference allow passing data to functions in different ways. Call by value maintains isolation while call by reference allows modifying actual arguments.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/","og_locale":"en_US","og_type":"article","og_title":"Difference Between Call by Value and Call by Reference in C - DataFlair","og_description":"Call by value and call by reference allow passing data to functions in different ways. Call by value maintains isolation while call by reference allows modifying actual arguments.","og_url":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2024-02-10T12:30:09+00:00","article_modified_time":"2024-02-10T13:04:03+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/call-by-reference-in-c.webp","type":"image\/webp"}],"author":"TechVidvan Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"TechVidvan Team","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/"},"author":{"name":"TechVidvan Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/0e594f928e31fc96628ac40f6ae74f49"},"headline":"Difference Between Call by Value and Call by Reference in C","datePublished":"2024-02-10T12:30:09+00:00","dateModified":"2024-02-10T13:04:03+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/"},"wordCount":1114,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/call-by-reference-in-c.webp","keywords":["c call by value and call by reference","c programming","C++","c++ practical","call by reference in c","call by value and call by reference in c","call by value in c","difference between call by value and call by reference in c"],"articleSection":["C Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/","url":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/","name":"Difference Between Call by Value and Call by Reference in C - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/call-by-reference-in-c.webp","datePublished":"2024-02-10T12:30:09+00:00","dateModified":"2024-02-10T13:04:03+00:00","description":"Call by value and call by reference allow passing data to functions in different ways. Call by value maintains isolation while call by reference allows modifying actual arguments.","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/call-by-reference-in-c.webp","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2023\/11\/call-by-reference-in-c.webp","width":1200,"height":628,"caption":"call by reference in c"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/call-by-value-and-call-by-reference-in-c\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"C Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/c-programming\/"},{"@type":"ListItem","position":3,"name":"Difference Between Call by Value and Call by Reference in C"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/0e594f928e31fc96628ac40f6ae74f49","name":"TechVidvan Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/c89190da3d4010c71ba476b618ab10fdc2335c82cdfa0ad5002d98d0f2473444?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/c89190da3d4010c71ba476b618ab10fdc2335c82cdfa0ad5002d98d0f2473444?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/c89190da3d4010c71ba476b618ab10fdc2335c82cdfa0ad5002d98d0f2473444?s=96&d=mm&r=g","caption":"TechVidvan Team"},"description":"TechVidvan Team provides high-quality content &amp; courses on AI, ML, Data Science, Data Engineering, Data Analytics, programming, Python, DSA, Android, Flutter, full stack web dev, MERN, and many latest technology.","url":"https:\/\/data-flair.training\/blogs\/author\/test001\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/123284","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/86671"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=123284"}],"version-history":[{"count":6,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/123284\/revisions"}],"predecessor-version":[{"id":131818,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/123284\/revisions\/131818"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/123794"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=123284"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=123284"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=123284"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}