<p>React Suspense is a powerful feature introduced in React 16.6 that allows components to pause rendering while they wait for asynchronous operations to complete.</p>

React Suspense for Mastering Asynchronous Data Fetching | Relia Software

React Suspense for Mastering Asynchronous Data Fetching

large_react-suspense-for-mastering-asynchronous-data-fetching.webp

medium_react-suspense-for-mastering-asynchronous-data-fetching.webp

small_react-suspense-for-mastering-asynchronous-data-fetching.webp

thumbnail_react-suspense-for-mastering-asynchronous-data-fetching.webp

react-suspense-for-mastering-asynchronous-data-fetching.webp

<p>React Error Boundaries are specialized components that can catch errors anywhere within their child components, acting as guardians in the component tree.</p>

In-Depth Tutorial for Mastering React Error Boundaries | Relia Software

large_react-error-boundary.webp

medium_react-error-boundary.webp

small_react-error-boundary.webp

thumbnail_react-error-boundary.webp

react-error-boundary.webp

In-Depth Tutorial for Mastering React Error Boundaries

<p>Tailwind CSS is a utility-first CSS tool for building custom web interfaces quickly. The integration of Tailwind CSS with React simplify the development process.</p>

Tailwind CSS for React UI Components: Practical Code Examples | Relia Software

large_tailwind-css-for-react-ui-components.webp

medium_tailwind-css-for-react-ui-components.webp

small_tailwind-css-for-react-ui-components.webp

thumbnail_tailwind-css-for-react-ui-components.webp

tailwind-css-for-react-ui-components.webp

Tailwind CSS for React UI Components: Practical Code Examples

<p>Welcome to the world of React Context API! This handy feature lets you share data across components without the dreaded prop drilling. We'll explore how Context API works, its practical uses, and some best practices to keep your code clean and efficient. So, buckle up and get ready to streamline your <a href="https://reliasoftware.com/blog/building-front-end-applications-with-react">React applications</a>!</p>
<p>&gt;&gt;&nbsp;<em>Read more about React:<br></em></p>
<ul>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/react-higher-order-components" rel="ef4a6baf x_url" data-ved="2ahUKEwjYisvx_9mFAxXaklYBHZtrDSEQFnoECBcQAQ">Mastering React Higher-Order Components (HOCs)</a></em></li>
<li><em>Top 6 Best <a href="https://reliasoftware.com/blog/react-component-library">React Component Libraries</a> for Your Projects</em></li>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/react-design-patterns" rel="06091de2 x_url" data-ved="2ahUKEwiF6c-9gNqFAxVQrlYBHedHAjk4ChAWegQIDhAB">The Best React Design Patterns with Code Examples</a></em></li>
</ul>
<h2>Understanding React Context API</h2>
<p><strong>The React Context API is a feature provided by React that enables you to pass data through the component tree without having to pass props manually at every level. </strong>This makes it easier to share data between components, especially for data that needs to be accessible by many components at different nesting levels.</p>
<p>The Context API works by allowing you to create a context object, and this object can be given a default value that all components in the component tree can access if they are a consumer of this context. Here&rsquo;s a basic example of how it works:</p>
<pre class="language-javascript"><code>import React, { createContext, useContext } from 'react';

// Create a Context object
const MyContext = createContext(defaultValue);

function MyComponent() {
  // Use the Context object
  const contextValue = useContext(MyContext);
  // Now you can use the value in your component
}</code></pre>
<p>As for state management, while the Context API does help with passing data around, it&rsquo;s not a complete solution for state management on its own. State management involves more than just passing data around - it also includes how you organize your state, how you update it, and how you handle side effects.</p>
<p>The React Context API provides a mechanism for a React application to create global variables that can be shared and accessed throughout the app. It serves as an alternative to &ldquo;prop drilling&rdquo;, which involves passing props from a grandparent to a parent to a child, and so forth. Additionally, Context is often promoted as a simpler, more lightweight solution for state management compared to using Redux.</p>
<h2>Installation and Setup</h2>
<p>Here&rsquo;s how you can install and set up a project using the React Context API with npx and yarn:</p>
<h3><strong>Step 1: Create A New React Project</strong></h3>
<ul>
<li>If you&rsquo;re using npx, run the following command in your terminal:</li>
</ul>
<pre class="language-javascript"><code>npx create-react-app my-app</code></pre>
<ul>
<li>If you&rsquo;re using yarn, use this command instead:</li>
</ul>
<pre class="language-javascript"><code>yarn create react-app my-app</code></pre>
<h3>Step 2: Navigate to Your New Project Directory</h3>
<pre class="language-javascript"><code>cd my-app</code></pre>
<h3>Step 3: Create A New Context</h3>
<p>You can create a new Context using the&nbsp;<code>createContext</code>&nbsp;method from React. Here&rsquo;s an example of how to do it:</p>
<pre class="language-javascript"><code>import React from 'react';

const MyContext = React.createContext();</code></pre>
<h3><strong>Step 4: Use the Context Provider</strong></h3>
<p>Wrap the Context Provider around your component tree and put any value you like on your context provider using the&nbsp;<strong><code>value</code></strong>&nbsp;prop.</p>
<h3><strong>Step 5: Use the Context Consumer</strong></h3>
<p>You can read that value within any component by using the Context Consumer. Here&rsquo;s an example of how to do it using the&nbsp;<strong><code>useContext</code></strong>&nbsp;hook:</p>
<pre class="language-javascript"><code>import { useContext } from 'react';
import { MyContext } from './MyContext';

function MyComponent() {
const { text, setText } = useContext(MyContext);

return (
  &lt;div&gt;
    &lt;h1&gt;{text}&lt;/h1&gt;
    &lt;button onClick={() =&gt; setText('Hello, world!')}&gt;Click me&lt;/button&gt;
  &lt;/div&gt;
);
}</code></pre>
<p>That&rsquo;s it! You&rsquo;ve now set up a project using the React Context API with npm or yarn. This will allow you to manage state more effectively in your React applications, especially when dealing with nested components.</p>
<h2>Basic Usage</h2>
<p>This repo explain how to use <code>react-context-api</code> in react, you can find it in <a href="https://github.com/nvkhuy/examples/tree/main/react-context-api">here</a></p>
<p>First, clone the project:</p>
<pre class="language-javascript"><code>git clone https://github.com/nvkhuy/examples.git</code></pre>
<p>Navigate to <code>react-context-api</code> example:</p>
<pre class="language-javascript"><code>cd react-context-api</code></pre>
<p>To install:</p>
<pre class="language-javascript"><code>yarn install</code></pre>
<p>To run:</p>
<pre class="language-javascript"><code>yarn start</code></pre>
<p>Project structure:</p>
<pre class="language-javascript"><code>├── README.md
├── package-lock.json
├── package.json
├── public
│   ├── favicon.ico
│   ├── index.html
│   ├── logo192.png
│   ├── logo512.png
│   ├── manifest.json
│   └── robots.txt
└── src
    ├── App.css
    ├── App.js
    ├── Button.js
    ├── index.js
    └── store
        └── ThemeContext.js</code></pre>
<p>Focus on <code>ThemeContext.js</code> file.</p>
<p>To create a context and import necessary files:</p>
<pre class="language-javascript"><code>import React, { createContext, useState } from 'react'

export const ThemeContext = createContext()</code></pre>
<p>Create custom component that wraps it children:</p>
<pre class="language-javascript"><code>export const ThemeProvider = ({ children }) =&gt; {
    const [isDarkTheme, setIsDarkTheme] = useState(false)

    const toggleTheme = () =&gt; setIsDarkTheme(prevTheme =&gt; !prevTheme)

    return (
        &lt;ThemeContext.Provider value={{ isDarkTheme, toggleTheme }}&gt;
            {children}
        &lt;/ThemeContext.Provider&gt;
    )
}</code></pre>
<ul>
<li><strong>Custom Component</strong>: The&nbsp;<strong><code>ThemeProvider</code></strong>&nbsp;is a custom component created by the developer. It accepts a single prop called&nbsp;<strong><code>children</code></strong>, which represents the child components that will be wrapped by the context provider.</li>
<li><strong>State Management</strong>: Inside the&nbsp;<strong><code>ThemeProvider</code></strong>, there is a&nbsp;<strong>state variable</strong>&nbsp;called&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;initialized with&nbsp;<strong><code>false</code></strong>. This state variable represents whether the dark theme is currently active.</li>
<li><strong>Toggle Function</strong>: The&nbsp;<strong><code>toggleTheme</code></strong>&nbsp;function is defined to toggle the value of&nbsp;<strong><code>isDarkTheme</code></strong>. It uses the&nbsp;<strong><code>setIsDarkTheme</code></strong>&nbsp;function from React&rsquo;s&nbsp;<strong><code>useState</code></strong>&nbsp;hook. When called, it flips the value of&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;(from&nbsp;<strong><code>true</code></strong>&nbsp;to&nbsp;<strong><code>false</code></strong>&nbsp;or vice versa).</li>
<li><strong>Context Provider</strong>: The&nbsp;<strong><code>ThemeProvider</code></strong>&nbsp;component wraps its children with a&nbsp;<strong>context provider</strong>. Specifically, it uses the&nbsp;<strong><code>ThemeContext.Provider</code></strong>&nbsp;provided by the React Context API. The&nbsp;<strong><code>value</code></strong>&nbsp;prop of this provider is an object containing the&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;state and the&nbsp;<strong><code>toggleTheme</code></strong>&nbsp;function.</li>
<li><strong>Usage</strong>: When you use the&nbsp;<strong><code>ThemeProvider</code></strong>&nbsp;in your app, any child component that consumes the&nbsp;<strong><code>ThemeContext</code></strong>&nbsp;will have access to the&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;state and&nbsp;<strong><code>toggleTheme</code></strong>&nbsp;function. This allows you to manage theme-related logic across different parts of your application.</li>
</ul>
<p>The&nbsp;<strong><code>ThemeProvider</code></strong>&nbsp; wraps its children with this context provider, making the context values available to all descendants</p>
<p>In <code>index.js</code> , <code>ThemProvider</code> wrapping <code>App</code></p>
<pre class="language-javascript"><code>import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
import { ThemeProvider } from './store/ThemeContext';

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  &lt;React.StrictMode&gt;
    &lt;ThemeProvider&gt;
     &lt;App /&gt;
    &lt;/ThemeProvider&gt;
  &lt;/React.StrictMode&gt;
);</code></pre>
<p>In <code>App.js</code> for switching theme:</p>
<pre class="language-javascript"><code>import {useContext} from 'react';
import './App.css';
import Button from './Button';
import {ThemeContext} from './store/ThemeContext';

function App() {
    const {isDarkTheme} = useContext(ThemeContext)
    return (
        &lt;div className={`App ${isDarkTheme ? 'darkTheme' : 'lightTheme'}`}&gt;
            &lt;h1&gt;Theme Context API&lt;/h1&gt;
            &lt;p&gt;Them Context API example&lt;/p&gt;
            &lt;Button/&gt;
        &lt;/div&gt;
    );
}

export default App;</code></pre>
<ul>
<li><strong><code>useContext</code></strong>&nbsp;hook is used to access the context value from the&nbsp;<strong><code>ThemeContext</code></strong>.</li>
<li><strong><code>isDarkTheme</code></strong>&nbsp;variable is extracted from the context, which presumably holds information about the current theme (dark or light), controls the theme (dark or light) applied to the app based on the context provided by the&nbsp;<strong><code>ThemeContext</code>.</strong></li>
</ul>
<p>The Button component is defined in <code>Button.js</code> , inside the component, it <a href="https://reliasoftware.com/blog/mastering-react-hooks">uses <code>useContext</code> hook</a> to access the context data provided by <code>ThemeContext</code>.</p>
<pre class="language-javascript"><code>import React, { useContext } from 'react'
import { ThemeContext } from './store/ThemeContext'
import './App.css'

const Button = () =&gt; {
  const { isDarkTheme, toggleTheme } = useContext(ThemeContext)
  return (
    &lt;button onClick={toggleTheme} className={`${isDarkTheme ? 'lightBtn' : 'darkBtn'}`}&gt;
      change Theme
    &lt;/button&gt;
  )
}
export default Button</code></pre>
<ul>
<li>The&nbsp;<strong><code>useContext(ThemeContext)</code></strong>&nbsp;hook is used to retrieve the current context value, which includes properties like&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;and&nbsp;<strong><code>toggleTheme</code></strong>.</li>
</ul>
<p>The button element is rendered with the following attributes:</p>
<ul>
<li><strong><code>onClick={toggleTheme}</code></strong>: When the button is clicked, the&nbsp;<strong><code>toggleTheme</code></strong>&nbsp;function will be executed.</li>
<li><strong><code>className={</code></strong>${isDarkTheme ? &lsquo;lightBtn&rsquo; : &lsquo;darkBtn&rsquo;}<strong><code>}</code></strong>: The button&rsquo;s class name is conditionally set based on the&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;value. If&nbsp;<strong><code>isDarkTheme</code></strong>&nbsp;is true, it uses the &lsquo;lightBtn&rsquo; class; otherwise, it uses the &lsquo;darkBtn&rsquo; class.</li>
</ul>
<p><code>Light</code> and <code>Dark</code> theme css, defined in <code>App.css</code></p>
<pre class="language-javascript"><code>* {
  padding: 0;
  margin: 0;
  box-sizing: border-box;
}
.App {
  padding: 50px;
  display: flex;
  justify-content: center;
  align-items: center;
  flex-direction: column;
  gap: 20px;
  height: 100vh;
}

.darkTheme {
  background-color: black;
  color: aliceblue;
}

.lightTheme {
  background-color: aliceblue;
  color: black;
}

button {
  padding: 10px;
  border-radius: 10px;
  border: 1px solid;
  cursor: pointer;
  font-size: 16px;
}

.darkBtn {
  background-color: black;
  color: aliceblue;
}
.lightBtn {
  background-color: aliceblue;
  color: black;
}</code></pre>
<p>Result would be like this when you click button <code>Change Theme</code></p>
<ul>
<li>Light Theme</li>
</ul>
<p><img style="display: block; margin-left: auto; margin-right: auto;" src="https://api.reliasoftware.com/uploads/light_theme_7dec85238d.webp" alt="Light Theme" width="707" height="331"></p>
<ul>
<li>Dark Theme</li>
</ul>
<p><img style="display: block; margin-left: auto; margin-right: auto;" src="https://api.reliasoftware.com/uploads/dark_theme_f4e3ab73cf.webp" alt="Dark Theme" width="707" height="344"></p>
<p>Clone the repo and run it on your local to understand this example better.</p>
<h2>Limitations of React Context API</h2>
<p>The React Context API is a powerful tool for managing state and sharing data across components. However, it does have some limitations compared to other <a href="https://reliasoftware.com/blog/react-state-management-libraries">React state management libraries</a>. Let&rsquo;s explore these limitations with code examples:</p>
<h3><strong>Performance and Re-renders</strong></h3>
<p>Context updates can cause unnecessary re-renders of components that consume the context. Specifically, a state change high up in the context tree may require a component deep in your app to re-render, even if it doesn't use the modified data. It can slow things down. To solve this, techniques like memoization can help optimise re-renders. For example:</p>
<pre class="language-javascript"><code>// Context.js
import { createContext, useContext, useState } from 'react';

const MyContext = createContext();

export const MyProvider = ({ children }) =&gt; {
  const [count, setCount] = useState(0);

  return (
    &lt;MyContext.Provider value={{ count, setCount }}&gt;
      {children}
    &lt;/MyContext.Provider&gt;
  );
};

export const useMyContext = () =&gt; useContext(MyContext);</code></pre>
<h3><strong>Complexity and Nesting</strong></h3>
<p>Nested contexts can become complex and harder to manage. The more contexts you stack on top of each other, the harder it becomes to reason about data flow and maintainability. If your application demands a labyrinthine network of contexts, consider a more structured approach. For example:</p>
<pre class="language-javascript"><code>// NestedContexts.js
import { createContext, useContext } from 'react';

const NestedContext = createContext();

export const NestedProvider = ({ children }) =&gt; {
  // ...
};

export const useNestedContext = () =&gt; useContext(NestedContext);</code></pre>
<h3><strong>Global vs. Local State</strong></h3>
<p>Context provides global state, but sometimes local component state is more appropriate. For example:</p>
<pre class="language-javascript"><code>// LocalState.js
import { useState } from 'react';

const LocalStateComponent = () =&gt; {
  const [localCount, setLocalCount] = useState(0);

  return (
    &lt;div&gt;
      &lt;p&gt;Local Count: {localCount}&lt;/p&gt;
      &lt;button onClick={() =&gt; setLocalCount(localCount + 1)}&gt;
        Increment Local Count
      &lt;/button&gt;
    &lt;/div&gt;
  );
};</code></pre>
<h3><strong>Testing and Mocking</strong></h3>
<p><a href="https://reliasoftware.com/blog/react-test-renderer">Testing components</a> that rely heavily on context can be challenging. <a href="https://reliasoftware.com/blog/react-unit-testing-with-jest">Mocking context values in unit tests</a> becomes an additional step compared to testing components with self-contained state. Don't worry, React Testing Library offers tools and techniques to streamline testing with context providers. For example:</p>
<pre class="language-javascript"><code>// MyComponent.test.js
import { render } from '@testing-library/react';
import MyComponent from './MyComponent';

test('renders correctly', () =&gt; {
  // How to mock context values?
  // ...
});</code></pre>
<p>React Context has its limitations, it&rsquo;s still a valuable tool for managing state in certain scenarios. For more complex applications, consider using libraries like&nbsp;Redux,&nbsp;MobX, or Zustand.</p>
<h2>Best Practices for Using React Context API</h2>
<p>Now we'll get down to the nitty-gritty &ndash; best practices to ensure you use Context API effectively and avoid any potential pitfalls.</p>
<h3>Separate Files for Context Definitions</h3>
<p>Imagine working on a massive <a href="https://reliasoftware.com/blog/react-project-ideas">React project</a> with tons of components. Now, you are trying to find the logic for a specific piece of state scattered throughout your codebase. Not fun, right? Thus, when creating contexts, it's a smart idea to keep them in separate files. This makes your codebase more organized and easier to maintain.</p>
<h3>Context for Global State, Not Everything</h3>
<p>React Context API shines at managing data that needs to be shared across a significant portion of your component tree. However, remember that Context API isn't a one-size-fits-all solution for state management. Here's when Context API is not ideal:</p>
<ul>
<li><strong>Complex Application State: </strong>Context API can struggle to manage complex application state with numerous interdependent data points. <a href="https://reliasoftware.com/blog/react-redux">Redux is a more structured and scalable state management library</a> for these situations.</li>
<li><strong>Overuse and Performance Issues: </strong>Context API is helpful, but excessive use might cause unnecessary re-renders, especially with highly nested contexts. If performance is an issue, use Context API judiciously and explore memoization to optimise re-renders.</li>
</ul>
<h2>Conclusion</h2>
<p>In this article, we reviewed what the React Context API is, basic usage and hands on how it works. We also cleared up some misconceptions surrounding the React Context API.</p>
<p>Remember, the React Context API is a powerful tool for passing data between components and reducing the need for prop drilling. It simplifies data sharing without prop drilling, works well with hooks and <a href="https://reliasoftware.com/blog/react-suspense">React Suspense</a>, and is great for smaller state operations. However, it&rsquo;s not designed for global state management or app-wide scenarios, and overusing it can lead to unnecessary re-renders and performance issues.</p>
<div id="article_content" class="inner_article__entries__X3PKd">
<div id="article_content" class="inner_article__entries__X3PKd">
<div id="article_content" class="inner_article__entries__X3PKd">
<p dir="ltr" style="text-align: right;"><em>&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!</em></p>
</div>
</div>
</div>

<p>The React Context API is a feature provided by React that enables you to pass data through the component tree without having to pass props manually at every level.</p>

Mastering React Context API for Streamlined Data Sharing | Relia Software

React Context API for Streamlined Data Sharing

large_react-context-api.webp

medium_react-context-api.webp

small_react-context-api.webp

thumbnail_react-context-api.webp

react-context-api.webp

Mastering React Context API for Streamlined Data Sharing

<p>React Test Renderer is a versatile solution for streamlined React component testing. It renders components as pure JavaScript, freeing them from the DOM for better maintainability. It's a versatile toolbox for snapshot testing, inspecting component behavior, and even advanced rendering techniques. Level up your testing with React Test Renderer via this article!</p>
<p>&gt;&gt;&nbsp;<em>Read more about React-related topics:</em></p>
<ul>
<li><em>Top 6 Best <a href="https://reliasoftware.com/blog/react-component-library">React Component Libraries</a> for Your Projects</em></li>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/mastering-react-query" rel="14af0851 x_url" data-ved="2ahUKEwiCu9mrhJaFAxUKgVYBHY_gCtYQFnoECBgQAQ">Mastering React Query: Simplify Your React Data Flow</a></em></li>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/react-higher-order-components" rel="ef4a6baf x_url" data-ved="2ahUKEwiCu9mrhJaFAxUKgVYBHY_gCtYQFnoECBYQAQ">Mastering React Higher-Order Components (HOCs)</a></em></li>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/react-design-patterns" rel="06091de2 x_url" data-ved="2ahUKEwiCu9mrhJaFAxUKgVYBHY_gCtYQFnoECB0QAQ">The Best React Design Patterns with Code Examples</a></em></li>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/react-redux" rel="3447c889 x_url" data-ved="2ahUKEwiCu9mrhJaFAxUKgVYBHY_gCtYQFnoECCUQAQ">Demystifying React Redux for Centralized State Management</a></em></li>
</ul>
<h2>What is React Test Renderer?</h2>
<p><strong>React Test Renderer is a library for rendering React components into pure JavaScript objects. It&rsquo;s primarily used for writing tests for your components.</strong></p>
<p>React Test Renderer allows you to inspect the output of your components and ensures they work correctly. It&rsquo;s especially useful for snapshot testing, where you can capture the state of your UI and compare it to a reference (snapshot) to detect changes.</p>
<p>One of the main benefits of using React Test Renderer is that it allows you to write tests that are decoupled from the DOM. This means your tests are not reliant on the specifics of how React interacts with the DOM, making your tests more resilient to changes in React's implementation. This decoupling leads to better maintainability of your test suite.</p>
<h2>Installation and Setup</h2>
<h3 data-sourcepos="18:3-18:56">Installation</h3>
<p data-sourcepos="18:3-18:56">You can install React Test Renderer using npm or yarn:</p>
<div class="code-block ng-star-inserted">
<div class="code-block-decoration header gmat-subtitle-1 ng-star-inserted">
<pre class="language-javascript"><code># Using npm
npm install --save react-test-renderer

# Using yarn
yarn add react-test-renderer</code></pre>
<h3>Dependencies&nbsp;</h3>
<p>React Test Renderer is a package for testing React components, so it naturally depends on React. Make sure you have React installed in your project:</p>
<pre class="language-javascript"><code># Using npm
npm install --save react

# Using yarn
yarn add react</code></pre>
<h3><strong>Additional Configurations</strong></h3>
<p>There are no additional configurations needed specifically for React Test Renderer. However, depending on your testing framework (like Jest or Mocha), you might need to configure them separately.</p>
<p>Remember to import&nbsp;<strong><code>react-test-renderer</code></strong> in your test files:</p>
</div>
</div>
<pre class="language-javascript"><code>import TestRenderer from 'react-test-renderer';</code></pre>
<p>&gt;&gt;&nbsp;<em>Read more: </em><em>Implement <a href="https://reliasoftware.com/blog/react-unit-testing-with-jest">React Unit Testing with Jest and React Testing Library</a></em></p>
<h2>Basic Usage: Hands-on Approach</h2>
<p>First, clone the example project contains React Test Renderer inside it:</p>
<pre class="language-javascript"><code>git clone https://github.com/nvkhuy/examples.git</code></pre>
<p>Example is inside <code>react-test-renderer</code>:</p>
<pre class="language-javascript"><code>cd react-test-renderer</code></pre>
<p>Project structure:</p>
<pre class="language-javascript"><code>├── LICENSE
├── README.md
├── package-lock.json
├── package.json
├── public
│   ├── favicon.ico
│   ├── index.html
│   ├── logo192.png
│   ├── logo512.png
│   ├── manifest.json
│   └── robots.txt
└── src
    ├── BtnGroup.test.js
    ├── ProductList.test.js
    └── VisibilityToggler.test.js</code></pre>
<p>Focus on <code>BtnGroup.test.j</code> , <code>ProductList.test.js</code> , <code>VisibilityToggler.test.js</code> files.</p>
<p>To install node modules:</p>
<pre class="language-javascript"><code>npm install</code></pre>
<p>To test specific file, for example:</p>
<pre class="language-javascript"><code>npm test src/BtnGroup.test.js</code></pre>
<p>The result looks like this:</p>
<pre class="language-javascript"><code> PASS  src/BtnGroup.test.js
  ✓ the className of the component includes btn-group (5ms)
  ✓ renders BtnGroup component with children (9ms)
  ✓ renders BtnGroup component with custom props (1ms)

  console.log src/BtnGroup.test.js:33
    { children: 'child' }

Test Suites: 1 passed, 1 total
Tests:       3 passed, 3 total
Snapshots:   0 total
Time:        0.557s, estimated 1s</code></pre>
<p>Let&rsquo;s begin with BtnGroup.test.js file, here is the code:</p>
<pre class="language-javascript"><code>import React from "react";
// [ 1 ] import the React Test Renderer
import { create } from "react-test-renderer";

const BtnGroup = ({ className = "", ...rest }) =&gt; (
  &lt;div {...rest} className={`btn-group ${className}`} /&gt;
);

test("the className of the component includes btn-group", () =&gt; {
  // [ 2 ] create component
  const component = create(&lt;BtnGroup /&gt;);

  // [ 3 ] get "test instance" of the component
  const instance = component.root;

  // [ 4 ] get BtnGroup element by node type
  const element = instance.findByType("div");

  // [ 5 ] assert that className equals btn-group
  expect(element.props.className.includes("btn-group")).toBe(true);
});

test("renders BtnGroup component with children", () =&gt; {
  // [ 6 ] child text
  const text = "child";

  // boilerplate code, already mentioned in [ 2 - 3 ] above
  const instance = create(&lt;BtnGroup&gt;{text}&lt;/BtnGroup&gt;).root;

  // [ 7 ] get element by component name
  const element = instance.findByType(BtnGroup);

  console.log(element.props);

  // [ 8 ] assert child to match text
  expect(element.props.children).toEqual(text);
});

test("renders BtnGroup component with custom props", () =&gt; {
  // generate some custom props
  const props = {
    id: "awesome-button-id",
    className: "mb-3",
    children: "child"
  };

  // boilerplate code
  const instance = create(&lt;BtnGroup {...props} /&gt;).root;

  // get element by component name
  const element = instance.findByType("div");

  // assert if an additional className was added to existing one
  expect(element.props.className).toEqual("btn-group mb-3");
  // assert "id" prop to match passed one
  expect(element.props.id).toEqual(props.id);
  // assert "children" to match passed
  expect(element.props.children).toEqual(props.children);
});</code></pre>
<p>This file tests the <strong><code>BtnGroup</code></strong>&nbsp;component in React. It uses the&nbsp;<strong><code>react-test-renderer</code></strong>&nbsp;library to create test instances of the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component and then performs various assertions on those instances. Here&rsquo;s what each test does:</p>
<ul>
<li><strong>Test: the className of the component includes btn-group:</strong>&nbsp;This test creates an instance of the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component and checks if the&nbsp;<strong><code>className</code></strong>&nbsp;of the&nbsp;<strong><code>div</code></strong>&nbsp;element in the component includes &ldquo;btn-group&rdquo;. This is to ensure that the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component is correctly applying the &ldquo;btn-group&rdquo; class to its root&nbsp;<strong><code>div</code></strong>&nbsp;element.</li>
<li><strong>Test: renders BtnGroup component with children:</strong>&nbsp;This test creates an instance of the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component with a child text node. It then checks if the&nbsp;<strong><code>children</code></strong>&nbsp;prop of the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component equals the child text. This is to ensure that the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component correctly renders its children.</li>
<li><strong>Test: renders BtnGroup component with custom props:</strong>&nbsp;This test creates an instance of the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component with custom props (<strong><code>id</code></strong>,&nbsp;<strong><code>className</code></strong>, and&nbsp;<strong><code>children</code></strong>). It then checks if the&nbsp;<strong><code>id</code></strong>,&nbsp;<strong><code>className</code></strong>, and&nbsp;<strong><code>children</code></strong>&nbsp;props of the&nbsp;<strong><code>div</code></strong>&nbsp;element in the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component match the passed props. This is to ensure that the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component correctly applies custom props to its root&nbsp;<strong><code>div</code></strong>&nbsp;element.</li>
</ul>
<p>The&nbsp;<strong><code>react-test-renderer</code></strong>&nbsp;library is used to render React components to pure JavaScript objects without using the DOM or a native mobile environment. This is useful for running tests on components in a <a href="https://reliasoftware.com/blog/node-js-enterprise-application-development">Node.js environment</a> or for rendering components to strings or JSON.</p>
<p>In this file, the <strong><code>create</code></strong>&nbsp;function from&nbsp;<strong><code>react-test-renderer</code></strong>&nbsp;is used to render instances of the&nbsp;<strong><code>BtnGroup</code></strong>&nbsp;component for testing. The&nbsp;<strong><code>root</code></strong>&nbsp;property of the test instance is then used to access the root test instance of the component, and the&nbsp;<strong><code>findByType</code></strong>&nbsp;method is used to find elements in the test instance by their type.</p>
<p>For testing whole project:</p>
<pre class="language-javascript"><code>npm test a</code></pre>
<p>This is the result:</p>
<pre class="language-javascript"><code> PASS  src/ProductList.test.js
 PASS  src/VisibilityToggler.test.js
 PASS  src/BtnGroup.test.js
  ● Console

    console.log src/BtnGroup.test.js:33
      { children: 'child' }


Test Suites: 3 passed, 3 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:        0.696s, estimated 1s</code></pre>
<h2><strong>Advanced Concepts of React Test Renderer</strong></h2>
<h3><strong>Snapshot Testing</strong></h3>
<p><strong>Snapshot testing is a technique used in modern JavaScript testing frameworks to test the UI of an application.</strong> It works by taking a &ldquo;snapshot&rdquo; of your UI component and saving it as a reference. On subsequent test runs, a new snapshot of the UI component is taken and compared with the saved reference. If the two snapshots do not match, the test fails.</p>
<p>This approach is beneficial for maintaining consistent UI because it helps to catch unintended changes in the UI. It&rsquo;s also useful for reviewing changes in the UI during code review processes.</p>
<p>Here&rsquo;s an example of how you can set up and use snapshots for component testing:</p>
<pre class="language-javascript"><code>import React from 'react';
import renderer from 'react-test-renderer';
import Link from '../Link.react';

test('Link changes the class when hovered', () =&gt; {
  const component = renderer.create(
    &lt;Link page="http://www.facebook.com"&gt;Facebook&lt;/Link&gt;,
  );
  let tree = component.toJSON();
  expect(tree).toMatchSnapshot();

  // manually trigger the callback
  tree.props.onMouseEnter();
  // re-rendering
  tree = component.toJSON();
  expect(tree).toMatchSnapshot();

  // manually trigger the callback
  tree.props.onMouseLeave();
  // re-rendering
  tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});</code></pre>
<h3><strong>Debugging Rendered Output</strong></h3>
<p>React Test Renderer provides several methods and properties that allow you to inspect and analyze the output details of your components. For example, the&nbsp;<strong><code>toJSON()</code></strong>&nbsp;method returns an object representing the rendered tree. This object can then be used to inspect the output.</p>
<p>Here&rsquo;s an example:</p>
<pre class="language-javascript"><code>import React from 'react';
import TestRenderer from 'react-test-renderer';
import MyComponent from './MyComponent';

const testRenderer = TestRenderer.create(&lt;MyComponent /&gt;);
const testInstance = testRenderer.root;

console.log(testRenderer.toJSON());
console.log(testInstance.findByType('div').props.className);</code></pre>
<h3><strong>Advanced Rendering Methods</strong></h3>
<p>React Test Renderer also supports advanced functionalities like shallow rendering or using custom matchers. Shallow rendering is useful to constrain your tests to a component as a unit, and to ensure that your tests aren&rsquo;t indirectly asserting on behavior of child components.</p>
<p>Here&rsquo;s an example of shallow rendering:</p>
<pre class="language-javascript"><code>import ShallowRenderer from 'react-test-renderer/shallow';

// in your test:
const renderer = new ShallowRenderer();
renderer.render(&lt;MyComponent /&gt;);
const result = renderer.getRenderOutput();

expect(result.type).toBe('div');</code></pre>
<h2>Practical Applications and Use Cases</h2>
<h3><strong>Examining Component Lifecycle Methods</strong></h3>
<p>React Test Renderer allows you to test the lifecycle methods of your components. By using the <code>update()</code> method of the TestRenderer instance, you can trigger an update lifecycle and assert on the side effects of your <code>componentDidUpdate()</code> method.</p>
<p>Here's an example:</p>
<pre class="language-javascript"><code>import React from 'react';
import TestRenderer from 'react-test-renderer';
import ProjectComponent from './ProjectComponent';

const testRenderer = TestRenderer.create(&lt;ProjectComponent /&gt;);
const testInstance = testRenderer.root;

testRenderer.update(&lt;ProjectComponent newProp={true} /&gt;);

expect(testInstance.findByType(ProjectComponent).props.newProp).toBe(true);</code></pre>
<h3><strong>Testing React Hooks</strong></h3>
<p>The React Test Renderer provides a way to examine the lifecycle methods of your components.&nbsp;By invoking the <strong><code>update()</code></strong> function on the TestRenderer instance, you can initiate an update lifecycle. This allows you to verify the side effects of your <strong><code>componentDidUpdate()</code></strong>&nbsp;method.</p>
<p>Let&rsquo;s look at an example:</p>
<pre class="language-javascript"><code>import React, { useState } from 'react';
import TestRenderer from 'react-test-renderer';

function ProjectComponent() {
  const [count, setCount] = useState(0);

  return (
    &lt;button onClick={() =&gt; setCount(count + 1)}&gt;
      Count: {count}
    &lt;/button&gt;
  );
}

const testRenderer = TestRenderer.create(&lt;ProjectComponent /&gt;);
const testInstance = testRenderer.root;

testInstance.findByType('button').props.onClick();

expect(testInstance.findByType('button').children[1]).toBe('1');</code></pre>
<p><em>&gt;&gt; Read more: <a href="https://reliasoftware.com/blog/mastering-react-hooks">Mastering React Hooks</a>: Fundamentals for Beginners</em></p>
<h3><strong>Testing Event Handlers</strong></h3>
<p>React Test Renderer provides the capability to examine the event handlers within your components. It enables the simulation of events through direct invocation of these handlers and verification of the resulting side effects.</p>
<p>Let&rsquo;s look at an example:</p>
<pre class="language-javascript"><code>import React from 'react';
import TestRenderer from 'react-test-renderer';

function ProjectComponent() {
  return (
    &lt;button onClick={() =&gt; console.log('clicked!')}&gt;
      Clicking! 
    &lt;/button&gt;
  );
}

const testRenderer = TestRenderer.create(&lt;ProjectComponent /&gt;);
const testInstance = testRenderer.root;

testInstance.findByType('button').props.onClick();</code></pre>
<p>&gt;&gt;&nbsp;<em>Read more about testing:</em></p>
<ul>
<li><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/software-testing-outsourcing" rel="5c06cd05 x_url" data-ved="2ahUKEwi-zYG3hZaFAxVMmq8BHYzVDcsQFnoECBcQAQ">Comprehensive Breakdown for Software Testing Outsourcing</a></em></li>
<li style="font-style: italic;"><em>Top 6 <a href="https://reliasoftware.com/blog/top-automation-testing-tools">Automation Testing Tools</a> for Businesses</em></li>
<li style="font-style: italic;"><em><a class="seoquake-params-link" href="https://reliasoftware.com/blog/react-native-end-to-end-testing-with-detox" rel="2f25be80 x_url" data-ved="2ahUKEwi-zYG3hZaFAxVMmq8BHYzVDcsQFnoECCMQAQ">Guide for React Native End-To-End Testing with Detox</a></em></li>
<li style="font-style: italic;"><em><a class="blog_post__u0IVW" href="https://reliasoftware.com/blog/react-suspense">React Suspense for Mastering Asynchronous Data Fetching</a></em></li>
</ul>
<h2>Conclusion</h2>
<p>React Test Renderer has been a valuable tool for testing React components. It offers a simple and efficient way to create snapshots of your components, allowing for easy comparison and detection of changes over time. However, it&rsquo;s important to remember that testing should focus on the output of your components, not their internal implementation.</p>
<p>While React Test Renderer has served us well, it&rsquo;s worth noting that as of 2024, there are newer and more powerful tools available for testing <a href="https://reliasoftware.com/blog/building-front-end-applications-with-react">React applications</a>. These include:</p>
<ul>
<li><strong>Jest</strong>: A comprehensive testing framework that works well with React.</li>
<li><strong>React Testing Library</strong>: Encourages writing tests that closely resemble how your React components are used.</li>
<li><strong>Enzyme</strong>: Provides more flexibility in how you can test your components.</li>
<li><strong>Cypress</strong>: <a href="https://reliasoftware.com/blog/end-to-end-testing-tool-and-frameworks">End-to-end testing framework</a> that makes it easy to set up, write, run and debug tests.</li>
</ul>
<p>Each of these tools has its own strengths and weaknesses, and the best choice depends on your specific needs and the nature of your project. As always, the key to effective testing is to write clear, maintainable tests that accurately reflect the behavior of your components.</p>
<div id="article_content" class="inner_article__entries__X3PKd">
<p style="text-align: right;"><em>&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!</em></p>
</div>

<p>React Test Renderer is a library for rendering React components into pure JavaScript objects. It&rsquo;s primarily used for writing tests for your components.</p>

Mastering React Test Renderer for Streamlined Testing | Relia Software

large_react-test-renderer.webp

medium_react-test-renderer.webp

small_react-test-renderer.webp

thumbnail_react-test-renderer.webp

react-test-renderer.webp

Mastering React Test Renderer for Streamlined Testing

<p>Redux serves as a universal state management library for single-page apps, facilitating the synchronization and easy access of your app&rsquo;s state across various components.</p>

Mastering React Redux for Centralized State Management | Relia Software

React Redux for Centralized State Management

large_react-redux-for-state-management.webp

medium_react-redux-for-state-management.webp

small_react-redux-for-state-management.webp

thumbnail_react-redux-for-state-management.webp

react-redux-for-state-management.webp

Demystifying React Redux for Centralized State Management

<p>React is a JavaScript library for building user interfaces, while Next.js is a production framework for React. This means that Next.js is used on top of React.</p>

Next.js vs React: How to Choose the Right Tech Stack? | Relia Software

Next.js vs React: How to Choose the Right Framework?

large_next-js-vs-react-comparison.webp

medium_next-js-vs-react-comparison.webp

small_next-js-vs-react-comparison.webp

thumbnail_next-js-vs-react-comparison.webp

next-js-vs-react-comparison.webp

Next.js vs React: How to Choose the Right Tech Stack?

<p>React Query is a data synchronization library for React that simplifies fetching, caching, and state management of server state in React applications.</p>

Mastering React Query: Simplify Your React Data Flow | Relia Software

Mastering React Query: Simplify Your React Data Flow

large_mastering-react-query.webp

medium_mastering-react-query.webp

small_mastering-react-query.webp

thumbnail_mastering-react-query.webp

mastering-react-query.webp

<p>In React, a higher-order component (HOC) is a function that takes an existing component and returns a new component. Explore further about React HOCs via this blog!</p>

Mastering React Higher-Order Components (HOCs) | Relia Software

large_react-higher-order-components-hocs.webp

medium_react-higher-order-components-hocs.webp

small_react-higher-order-components-hocs.webp

thumbnail_react-higher-order-components-hocs.webp

react-higher-order-components-hocs.webp

Mastering React Higher-Order Components (HOCs)

<p>React Hooks are a new feature in React 16.8 that allows you to use state and other React features without writing classes. Let's explore further here!</p>

Mastering React Hooks: Fundamentals for Beginners | Relia Software

large_react-hooks.webp

medium_react-hooks.webp

small_react-hooks.webp

thumbnail_react-hooks.webp

react-hooks.webp

Mastering React Hooks: Fundamentals for Beginners

<p>4 React design patterns are: Higher-order Components, Providers, Compound Components, and Hooks. Also learn ther general design patterns in React here!</p>

The Best React Design Patterns with Code Examples | Relia Software

large_react-design-patterns.webp

medium_react-design-patterns.webp

small_react-design-patterns.webp

thumbnail_react-design-patterns.webp

react-design-patterns.webp

The Best React Design Patterns with Code Examples

<p>Air is a command-line utility designed for live-reloading Go applications during development. It serves as a tool that enables Go applications to reload in real-time.</p>

Guide for Implementing Live Reload Using Golang Air | Relia Software

Implementing Live Reload Using Golang Air

large_live-reload-using-golang-air.webp

medium_live-reload-using-golang-air.webp

small_live-reload-using-golang-air.webp

thumbnail_live-reload-using-golang-air.webp

live-reload-using-golang-air.webp

Guide for Implementing Live Reload Using Golang Air

<p>React is a JavaScript library with more history than Angular. Angular is a comprehensive framework. React and Angular can both create single-page applications.</p>

React vs Angular: A Comprehensive Side-by-Side Comparison

large_react-vs-angular.webp

medium_react-vs-angular.webp

small_react-vs-angular.webp

thumbnail_react-vs-angular.webp

react-vs-angular.webp

React vs Angular: Which is Better for Your Project?

<p>Suppose you have some initialization code that should only be executed once, regardless of how many times it's called from different parts of your program or by different goroutines. If you don't have a mechanism to control this, you might end up with race conditions where multiple goroutines are attempting to initialize the same resource concurrently, leading to unpredictable and potentially incorrect behavior.</p>
<p><a href="https://reliasoftware.com/blog/what-is-golang">The Go language</a> provides a simple and efficient way to guarantee that a given function is executed only once. It uses a combination of a boolean flag and a mutex to ensure that only one goroutine executes the specified function, while other goroutines that attempt to execute the same function will wait until the initialization is complete. It call <code>Sync.Once</code>.</p>
<p>&gt;&gt;&nbsp;<em>Read more about Golang:</em></p>
<ul>
<li><em>Go Tutorial:&nbsp;<a href="https://reliasoftware.com/blog/golang-basics-of-knowledge">Golang Basics of Knowledge for Beginners</a></em></li>
<li style="font-style: italic;"><em><a href="https://reliasoftware.com/blog/gin-gonic-api-development">API Development in Go with Gin Framework</a></em></li>
<li style="font-style: italic;"><em><a href="https://reliasoftware.com/blog/dockerize-golang-application">A Comprehensive Guide To Dockerize A Golang Application</a></em></li>
<li style="font-style: italic;"><em><a href="https://reliasoftware.com/blog/simplifying-testing-with-golang-testify">Detailed Guide for Simplifying Testing with Golang Testify</a></em></li>
<li style="font-style: italic;"><em><a href="https://reliasoftware.com/blog/type-conversion-in-golang">Type Conversion in Golang</a></em></li>
<li style="font-style: italic;"><a href="https://reliasoftware.com/blog/golang-ordered-map"><em>Understanding Golang Ordered Map with Code Examples</em></a></li>
</ul>
<h2 dir="ltr">What is sync.Once?</h2>
<p dir="ltr"><strong>sync.Once is a synchronization primitive provided by the Golang sync package.</strong> It is used to perform a certain operation exactly once, regardless of how many times the Once instance is consulted.</p>
<h2 dir="ltr">3 Common Scenarios for Using sync.Once</h2>
<p dir="ltr">sync.Once is particularly useful in scenarios where you want to perform a certain initialization or setup operation only once, regardless of how many times that operation is requested. It's commonly used in scenarios like this:</p>
<h3 dir="ltr">Lazy Initialization&nbsp;</h3>
<p dir="ltr">When you want to initialize a resource or perform a setup operation only when it is first needed, and you want to avoid the overhead of repeated initialization.</p>
<pre class="language-clike"><code>var once sync.Once
var expensiveResource *SomeType

func getExpensiveResource() *SomeType {
    once.Do(func() {
        expensiveResource = initializeExpensiveResource()
    })
    return expensiveResource
}</code></pre>
<h3>Singleton Pattern</h3>
<p>Ensuring that a certain operation, like creating a singleton instance, is performed only once, even in a concurrent environment.</p>
<pre class="language-clike"><code>var once sync.Once
var instance *Singleton

func GetInstance() *Singleton {
    once.Do(func() {
        instance = createSingletonInstance()
    })
    return instance
}</code></pre>
<h3>Package-Level Initialization</h3>
<p>In package-level variables or initialization functions, where you want to ensure that certain setup code is executed only once when the package is used.</p>
<pre class="language-clike"><code>package mypackage

import (
    "sync"
)

var (
    once sync.Once
    initialized bool
)

func initialize() {
    // Initialization code here
    initialized = true
}

func MyFunction() {
    once.Do(initialize)
    // Rest of the code
}</code></pre>
<p>In these cases, <strong><code>sync.Once</code></strong> provides a clean and efficient way to handle the one-time initialization, and it ensures that the initialization is safe for concurrent use. It helps avoid race conditions and guarantees that the initialization code is executed exactly once.</p>
<h2>3 New Features of sync.Once in Go 1.21</h2>
<p>The recently introduced <strong><code>OnceFunc</code></strong>, <strong><code>OnceValue</code></strong>, and <strong><code>OnceValues</code></strong> functions encapsulate a common usage of Once, designed for the deferred initialization of a value upon its initial use.</p>
<h3><strong>OnceFunc</strong></h3>
<pre class="language-clike"><code>func OnceFunc(f func()) func()</code></pre>
<p><strong><code>OnceFunc</code></strong>&nbsp;return a function that supports concurrent calls and can be invoked multiple times.</p>
<p>The following code,&nbsp;<code>onceVoid</code>, is only executed once.</p>
<pre class="language-clike"><code>package main

import (
	"log"
	"sync"
)

func main() {
	onceVoid := func() {
		log.Println("Only once")
	}
	call := sync.OnceFunc(onceVoid)
	for i := 0; i &lt; 10; i++ {
		call()
	}
}</code></pre>
<p>Result:</p>
<pre class="language-clike"><code>2023/12/18 22:45:01 Only once</code></pre>
<h3>OnceValue</h3>
<pre class="language-clike"><code>func OnceValue[T any](f func() T) func() T</code></pre>
<p><strong><code>OnceValue</code></strong> the returned function retrieves the result of the initial function call, ensuring that subsequent invocations yield the same value.</p>
<p>In the code below,&nbsp;<code>randNum</code> only be executed once, returning the result as&nbsp;<code>n</code>, and each call to the bar function will return&nbsp;<code>n</code>. bar can be called concurrently.</p>
<pre class="language-clike"><code>package main

import (
	"log"
	"math/rand"
	"sync"
)

func main() {
	randNum := func() int {
		return rand.Int() % 10
	}
	getNum := sync.OnceValue(randNum)
	for i := 0; i &lt; 10; i++ {
		log.Println(getNum())
	}
}</code></pre>
<p>Result:</p>
<pre class="language-clike"><code>2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4
2023/12/18 22:48:48 4</code></pre>
<p><code>randNum</code> return one random value no matter how many <code>getNum</code> called that the reason why call many time but still receive value 4.</p>
<h3><strong>OnceValues</strong></h3>
<pre class="language-clike"><code>func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2)</code></pre>
<p>In the case of <strong><code>OnceValues</code></strong> and <strong><code>OnceValue</code></strong>, they serve a comparable purpose, with the distinction that the former returns two parameters.</p>
<p>To summarise:</p>
<ul>
<li>The three functions yield 0, 1, and 2 return values, respectively, upon invocation of the associated function.</li>
<li>The returned functions can be called concurrently.</li>
<li>Should the execution of function f result in a panic, the returned function will also panic upon subsequent calls, preserving the same panic value as encountered during the execution of f.</li>
</ul>
<pre class="language-clike"><code>package main

import (
	"log"
	"math/rand"
	"sync"
)

func main() {
	randTwoNum := func() (int, int) {
		return rand.Int() % 10, rand.Int() % 10
	}
	getTwoNum := sync.OnceValues(randTwoNum)
	for i := 0; i &lt; 10; i++ {
		log.Println(getTwoNum())
	}
}</code></pre>
<p>Result:</p>
<pre class="language-clike"><code>2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6
2023/12/18 22:56:52 4 6</code></pre>
<p>Same result with <code>OnceValue</code> but the different is that return two value only once.</p>
<p>Keep going with <code>OnceValues</code> we can receive once more than two value</p>
<pre class="language-clike"><code>package main

import (
	"log"
	"math/rand"
	"sync"
)

func main() {
	getThreeNum := sync.OnceValues(func() (int, func() (int, int)) {
		return rand.Int() % 10, sync.OnceValues(func() (int, int) {
			return rand.Int() % 10, rand.Int() % 10
		})
	})

	for i := 0; i &lt; 10; i++ {
		v1, f1 := getThreeNum()
		v2, v3 := f1()
		log.Println(v1, v2, v3)
	}
}</code></pre>
<p>Result:</p>
<pre class="language-clike"><code>2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9
2023/12/18 23:09:28 8 4 9</code></pre>
<p><code>OnceValues</code> returns a function that invokes <code>f</code> only once and returns the values returned by <code>f</code>. The returned function may be called concurrently. If&nbsp;<code>f</code> panics, the returned function will panic with the same value on every call.</p>
<p>&gt;&gt;&nbsp;<em>You may be interested in these Golang-related blogs:</em></p>
<ul>
<li><em><a href="https://reliasoftware.com/blog/best-practices-for-dependency-inversion-in-golang">Best Practices For Dependency Inversion in Golang</a></em></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle"><em>Detailed Code Examples of Dependency Inversion in Golang</em></a></li>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation"><em>Hands-On Implementation for Dependency Injection in Go</em></a></li>
<li><em><a href="https://reliasoftware.com/blog/single-responsibility-principle-in-golang">Practical SOLID in Golang: Single Responsibility Principle</a></em></li>
</ul>
<h2>Conclusion</h2>
<p>In conclusion, the introduction of the new functions, <strong><code>OnceFunc</code></strong>, <strong><code>OnceValue</code></strong>, and <strong><code>OnceValues</code></strong>, in Go's <strong><code>sync.Once</code></strong> package is a significant enhancement that adds valuable flexibility and convenience to the already powerful synchronization primitive.</p>
<p>Understanding and leveraging these new functions is crucial for&nbsp;<a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a>, as they provide elegant solutions for deferred initialization scenarios with varying degrees of complexity.</p>
<ul>
<li>The ability to use <strong><code>OnceFunc</code></strong> enables developers to encapsulate operations that need to be executed only once, creating a function that supports concurrent calls and can be invoked multiple times. This feature is particularly useful in scenarios where an operation should be performed exactly once, but the result is not needed immediately.</li>
<li>With <strong><code>OnceValue</code></strong>, the Go language introduces a mechanism that not only ensures a function is executed only once but also caches and returns the result upon subsequent invocations. This is especially beneficial for scenarios where the cost of computation is high, and the result can be reused multiple times.</li>
<li>The introduction of <strong><code>OnceValues</code></strong> extends this capability further, allowing developers to handle functions that return multiple values. This function provides a clean and concise way to deal with scenarios where initialization involves multiple results or configurations.</li>
</ul>
<p>In essence, mastering these new <strong><code>sync.Once</code></strong> functions is a must for any Go developer, as they address common challenges in <a href="https://reliasoftware.com/blog/concurrency-in-golang">concurrent programming</a>, enhance code readability, and provide a more expressive and efficient way to handle deferred initialization. As the Go language evolves, staying informed and adopting these improvements will contribute to writing more robust, scalable, and maintainable Go code.</p>
<p dir="ltr" style="text-align: right;"><em>&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!</em></p>

<p>sync.Once is a synchronization primitive provided by the Golang sync package. 3 new features of Go sync.Once are: OnceFunc, OnceValue, and OnceValues.</p>

A Complete Guide to New Features in Golang sync.Once

Sync Package: What Are New Features in Golang sync.Once?

large_new-features-in-golang-sync-once.webp

medium_new-features-in-golang-sync-once.webp

small_new-features-in-golang-sync-once.webp

thumbnail_new-features-in-golang-sync-once.webp

new-features-in-golang-sync-once.webp

<p>A Golang ordered map (linked map or ordered dictionary) is a data structure that combines the properties of a map and maintains the order of insertion of elements.</p>

Understanding Golang Ordered Map with Code Examples | Relia Software

Understanding Golang Ordered Map with Code Examples

large_golang-ordered-map-with-code-examples.webp

medium_golang-ordered-map-with-code-examples.webp

small_golang-ordered-map-with-code-examples.webp

thumbnail_golang-ordered-map-with-code-examples.webp

golang-ordered-map-with-code-examples.webp

<p>Previously, if you wanted a function that could work with different types (like both <code>int</code> and <code>string</code>), you had to either duplicate code or use <code>interface{}</code>, which was less safe.</p>
<p>With version 1.18, Golang Generics, long-awaited, is finally available. It helps write functions, types, and data structures that work with any type, without losing type safety. So exciting to examine generics implementation in the&nbsp;<a href="https://reliasoftware.com/blog/what-is-golang">Go programming language</a>. Let's explore Golang Generics' inner workings and their effects on code via this article!</p>
<p>&gt;&gt;&nbsp;<em>You may consider:</em></p>
<ul>
<li><em>Top 10&nbsp;<a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang">Best IDEs for Golang Web Development</a></em></li>
<li><em>Top 10 Best <a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks">Golang Web Frameworks</a></em></li>
</ul>
<h2><strong>Why Generics in Go?</strong></h2>
<p>Go's introduction of generics addresses several limitations and challenges in the language:</p>
<ul>
<li><strong>Code Reusability:</strong> Generics enable the creation of functions and data structures that can work with different types, leading to more reusable and flexible code. Without generics, <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a> often resort to code duplication or the use of interfaces, which may result in less efficient or more verbose code.</li>
<li><strong>Type Safety:</strong> Generics provide <a href="https://reliasoftware.com/blog/build-a-type-safe-backend-with-nestjs-prisma-pothos-graphql">a way to achieve type safety</a> while still writing generic code. Before generics, developers often relied on interface and type assertions, which could lead to runtime errors if types were not handled correctly. Generics allow developers to write type-safe code without sacrificing flexibility.</li>
<li><strong>Performance:</strong> Generics can improve performance by eliminating the need for type assertions and interfaces in certain situations. The generated code can be specialized for specific types at compile time, resulting in more efficient execution.</li>
<li><strong>Cleaner Code:</strong> With generics, code becomes more readable and concise. It eliminates the need for repetitive type-specific code and reduces the cognitive load on developers.</li>
<li><strong>Compatibility with Data Structures:</strong> Generics make it easier to implement generic data structures, such as containers and algorithms, that can operate on different types. This is especially important for building libraries and frameworks.</li>
</ul>
<p>Other <a href="https://reliasoftware.com/blog/which-web-development-language-should-you-learn">programming languages</a>, such as Java, C++, and C#, have long supported generics, and their absence in Go was a notable feature gap. Adding generics to Go brings it more in line with modern programming language features.</p>
<h2><strong>Golang Generic Types</strong></h2>
<p>Go 1.17 was the latest stable version, and it did not include support for generics. Support for generics was planned for Go 1.18, and it was expected to be a major addition to the language.</p>
<table style="border-collapse: collapse; width: 96.0993%; height: 313.6px; margin-left: auto; margin-right: auto; border: 1px solid rgb(0, 0, 0);" border="1">
<thead>
<tr style="height: 19.6px;">
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 19.6px;">Feature</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 19.6px;">Go Generics</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 19.6px;">Java Generics</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 19.6px;">C++ Templates</th>
<th style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 19.6px;">C# Generics</th>
</tr>
</thead>
<tbody>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Syntax</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">Type parameter before name</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">Type parameter before name</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">Type parameter after name</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">Type parameter before name</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Constraint Support</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">Yes</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Type Erasure</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">No (Reified Types)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">Yes (Type Erasure)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">Yes (Template Instantiation)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">No (Reified Types)</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Code Bloat</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">Minimal</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">Possible (Code is generated per type)</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">Minimal</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Default Values</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">No</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Generic Methods</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">Yes</td>
</tr>
<tr style="height: 39.2px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 39.2px;">Wildcard Types</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 39.2px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 39.2px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 39.2px;">No</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 15.8802%; height: 19.6px;">Variance</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 19.6272%; height: 19.6px;">No</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.5194%; height: 19.6px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 23.1958%; height: 19.6px;">Yes</td>
<td style="border-color: rgb(0, 0, 0); text-align: center; width: 20.8763%; height: 19.6px;">Yes</td>
</tr>
</tbody>
</table>
<p>In Go, generic types are introduced using type parameters. A type parameter is a placeholder for a specific type that will be determined when the generic code is instantiated. Here are some key aspects of generic types in Go:</p>
<ul>
<li><strong>Type Parameters:</strong> Type parameters are denoted by a type identifier within square brackets. For example, <strong><code>func Print[T any](value T) { fmt.Println(value) }</code></strong> has a type parameter <strong><code>T</code></strong>.</li>
<li><strong>Type Constraints:</strong> Type constraints specify requirements on the type parameter. For instance, <strong><code>T any</code></strong> means that <strong><code>T</code></strong> can be any type. Constraints can also be more specific, such as requiring <strong><code>T</code></strong> to be comparable (<strong><code>T comparable</code></strong>).</li>
<li><strong>Generic Functions and Data Structures:</strong> Generics allow you to write functions and data structures that work with any type. Examples include generic sorting functions, containers (like slices and maps), and more.</li>
<li><strong>Compile-Time Type Safety:</strong> The type parameter is determined at compile time, ensuring type safety without sacrificing flexibility.</li>
<li><strong>Implicit Specialization:</strong> The Go compiler implicitly generates specialized code for each type used with generic functions or data structures. This helps avoid the performance overhead associated with runtime type checks.</li>
</ul>
<p>&gt;&gt;&nbsp;<em>Read more about Golang:</em></p>
<ul>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation"><em>Hands-On Implementation for Dependency Injection in Go</em></a></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle"><em>Detailed Code Examples of Dependency Inversion Principle in Go</em></a></li>
</ul>
<h2>Golang Generics Example</h2>
<p>Here's a simple example to illustrate generic types in Go:</p>
<pre class="language-clike"><code>package main

import (
	"fmt"
	"log"
)

type PrintInterface interface {
	print()
}
type PrintNum int

func (p PrintNum) print() {
	log.Println("Num:", p)
}

type PrintText string

func (p PrintText) print() {
	log.Println("Text:", p)
}

// PrintSlice prints elements of a slice of any type
func PrintSlice[T PrintInterface](s []T) {
	for _, value := range s {
		value.print()
	}
}

func main() {
	// Example with PrintSlice
	stringSlice := []PrintText{"apple", "banana", "orange"}
	intSlice := []PrintNum{5, 2, 9, 1, 7}

	fmt.Println("String slice:")
	PrintSlice(stringSlice)

	fmt.Println("\nInteger slice:")
	PrintSlice(intSlice)
}</code></pre>
<p>This Go code defines an interface, <strong><code>PrintInterface</code></strong>, and two types (<strong><code>PrintNum</code></strong> and <strong><code>PrintText</code></strong>) that implement this interface. It also includes a generic function, <strong><code>PrintSlice</code></strong>, which takes a slice of any type that satisfies the <strong><code>PrintInterface</code></strong> interface and prints each element using the <strong><code>print</code></strong> method.</p>
<p>Here's a breakdown of the code:</p>
<p><strong>Interface and Types:</strong></p>
<pre class="language-clike"><code>type PrintInterface interface {
    print()
}</code></pre>
<p>This declares an interface named <code>PrintInterface</code> with a single method <code>print()</code>.</p>
<pre class="language-clike"><code>type PrintNum int

func (p PrintNum) print() {
    log.Println("Num:", p)
}

</code></pre>
<p>Here, <code>PrintNum</code> is a type that represents an integer. It implements the <code>PrintInterface</code> interface by providing a <code>print</code> method that logs the value of the integer.</p>
<pre class="language-clike"><code>type PrintText string

func (p PrintText) print() {
    log.Println("Text:", p)
}</code></pre>
<p><strong><code>PrintText</code></strong> is another type, representing a string. Like <strong><code>PrintNum</code></strong>, it implements the <strong><code>PrintInterface</code></strong> interface with a <strong><code>print</code></strong> method that logs the value of the string.</p>
<p><strong>Generic Function:</strong></p>
<pre class="language-clike"><code>// PrintSlice prints elements of a slice of any type
func PrintSlice[T PrintInterface](s []T) {
    for _, value := range s {
        value.print()
    }
}</code></pre>
<p>The <strong><code>PrintSlice</code></strong> function is a generic function that takes a slice of any type <strong><code>T</code></strong> that satisfies the <strong><code>PrintInterface</code></strong> interface. It iterates over the elements of the slice and calls the <strong><code>print</code></strong> method on each element.</p>
<p><strong>Main Function:</strong></p>
<pre class="language-clike"><code>func main() {
    // Example with PrintSlice
    stringSlice := []PrintText{"apple", "banana", "orange"}
    intSlice := []PrintNum{5, 2, 9, 1, 7}

    fmt.Println("String slice:")
    PrintSlice(stringSlice)

    fmt.Println("\nInteger slice:")
    PrintSlice(intSlice)
}</code></pre>
<p>In the <strong><code>main</code></strong> function, two slices (<strong><code>stringSlice</code></strong> and <strong><code>intSlice</code></strong>) are created with elements of types <strong><code>PrintText</code></strong> and <strong><code>PrintNum</code></strong>, respectively. The <strong><code>PrintSlice</code></strong> function is then called on each slice, demonstrating the use of the generic function with different types.</p>
<p>The output of this program will be log messages showing the values of the elements in the slices, as logged by the <strong><code>print</code></strong> methods of <strong><code>PrintNum</code></strong> and <strong><code>PrintText</code></strong>.</p>
<pre class="language-clike"><code>String slice:
2023/12/17 23:28:53 Text: apple
2023/12/17 23:28:53 Text: banana
2023/12/17 23:28:53 Text: orange

Integer slice:
2023/12/17 23:28:53 Num: 5
2023/12/17 23:28:53 Num: 2
2023/12/17 23:28:53 Num: 9
2023/12/17 23:28:53 Num: 1
2023/12/17 23:28:53 Num: 7</code></pre>
<h2>Stack</h2>
<pre class="language-clike"><code>package main

import "fmt"

// Stack is a generic stack data structure.
type Stack[T any] struct {
	items []T
}

// Push adds an element to the top of the stack.
func (s *Stack[T]) Push(item T) {
	s.items = append(s.items, item)
}

// Pop removes and returns the element from the top of the stack.
func (s *Stack[T]) Pop() (T, error) {
	if len(s.items) == 0 {
		var zeroValue T
		return zeroValue, fmt.Errorf("stack is empty")
	}
	item := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return item, nil
}

// Size returns the number of elements in the stack.
func (s *Stack[T]) Size() int {
	return len(s.items)
}

func main() {
	// Example with integers
	intStack := Stack[int]{}
	intStack.Push(1)
	intStack.Push(2)
	intStack.Push(3)

	fmt.Println("Int Stack Size:", intStack.Size())

	poppedInt, err := intStack.Pop()
	if err == nil {
		fmt.Println("Popped Int:", poppedInt)
	}

	// Example with strings
	stringStack := Stack[string]{}
	stringStack.Push("apple")
	stringStack.Push("banana")
	stringStack.Push("cherry")

	fmt.Println("String Stack Size:", stringStack.Size())

	poppedString, err := stringStack.Pop()
	if err == nil {
		fmt.Println("Popped String:", poppedString)
	}
}</code></pre>
<p>Here's the breakdown:</p>
<ul>
<li><strong><code>Stack[T any]</code></strong>: Defines a generic stack data structure using the new generics feature introduced in Go 1.18. The type parameter <strong><code>T</code></strong> is used to represent the type of elements the stack will hold.</li>
<li><strong><code>Push(item T)</code></strong>: Method of the <strong><code>Stack</code></strong> type that adds an element to the top of the stack.</li>
<li><strong><code>Pop() (T, error)</code></strong>: Method of the <strong><code>Stack</code></strong> type that removes and returns the element from the top of the stack. It returns an error if the stack is empty.</li>
<li><strong><code>Size() int</code></strong>: Method of the <strong><code>Stack</code></strong> type that returns the number of elements in the stack.</li>
<li><strong><code>main()</code></strong>: Demonstrates using the generic stack with both integers and strings. It creates two instances of the <strong><code>Stack</code></strong> type, one for integers and one for strings, pushes elements onto the stacks, prints the size of the stacks, and pops elements off the stacks. The popped elements and stack sizes are then printed to the console.</li>
</ul>
<p>This example showcases the flexibility and reusability of the generic stack data structure, allowing you to work with different types while maintaining type safety.</p>
<p>&gt;&gt;&nbsp;<em>Read more:&nbsp;</em></p>
<ul>
<li><em>Gin-Gonic Tutorial:&nbsp;<a href="https://reliasoftware.com/blog/gin-gonic-api-development">API Development in Go with Gin Framework</a>&nbsp;</em></li>
<li><em>Type Conversion in Golang:&nbsp;<a href="https://reliasoftware.com/blog/type-conversion-in-golang">How To Convert Data Types in Go</a>?</em></li>
<li><em>Go Tutorial:&nbsp;<a href="https://reliasoftware.com/blog/golang-basics-of-knowledge">Golang Basics of Knowledge for Beginners</a></em></li>
</ul>
<h2>Conclusion</h2>
<p>Generics promote code abstraction and reusability. It is crucial to identify the right use cases where these might be used to boost efficiency. Golang generics are relatively new, so it will be fascinating to observe how they perform.</p>
<p style="text-align: right;"><em>&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!</em></p>

<p>Golang Generics (first introduced in version 1.18) helps write functions, types, and data structures that work with any type, without losing type safety.</p>

How to Use Generics in Golang With Code Examples? | Relia Software

large_generics-in-golang.webp

medium_generics-in-golang.webp

small_generics-in-golang.webp

thumbnail_generics-in-golang.webp

generics-in-golang.webp

Instruction For Using Golang Generics With Code Examples

<p>Testify is like a handy toolbox specifically designed for Golang testing. It offers a bunch of useful tools that make your Go app testing easier and more effective.</p>

Detailed Guide for Simplifying Testing with Golang Testify | Relia Software

large_simplifying-testing-with-golang-testify.webp

medium_simplifying-testing-with-golang-testify.webp

small_simplifying-testing-with-golang-testify.webp

thumbnail_simplifying-testing-with-golang-testify.webp

simplifying-testing-with-golang-testify.webp

Detailed Guide for Simplifying Testing with Golang Testify

<p>Go 1.21 has landed six months after 1.20. Let's discover sigificant changes in its features via this article!</p>
<p><em>&gt;&gt;&nbsp;Read more:</em></p>
<ul>
<li><em>Top 10 Best&nbsp;<a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks">Golang Web Frameworks</a></em></li>
<li><em><a href="https://reliasoftware.com/blog/golang-basics-of-knowledge">Go Tutorial: Golang Basics of Knowledge for Beginners</a></em></li>
<li><em>Top 10 Best&nbsp;<a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang">IDEs for Golang Web Development</a></em></li>
</ul>
<h2><strong>Introduction To Go 1.21</strong></h2>
<p><strong>Go 1.21, the latest release in the <a href="https://reliasoftware.com/blog/what-is-golang">Go programming language</a> series, brings a myriad of improvements in toolchain implementation, runtime, and libraries. </strong>Released six months after Go 1.20, this version maintains and enhances the Go 1 promise of compatibility. In this blog post, we'll delve into the key features and changes introduced in Go 1.21.</p>
<h2>Changes to Release Numbering</h2>
<p>A small but notable change has been introduced in the numbering of releases. In Go 1.21, the first release is now labeled as Go 1.N.0. This release includes the Go 1.21 language and its initial implementation, known as the Go 1.21.0 release.&nbsp;</p>
<p>This blog will refer to it as "Go 1.21," while tools like <code>go version</code> will display "go1.21.0" until an upgrade to Go 1.21.1. Refer to the "Go Toolchains" documentation for a detailed explanation of the new version numbering.</p>
<h2>Changes to the Language</h2>
<h3><strong>New Built-ins</strong></h3>
<p>Go 1.21 introduces three new built-in functions:</p>
<ul>
<li><strong>min and max:</strong> Compute the smallest or largest value from a fixed number of given arguments.</li>
</ul>
<pre class="language-clike"><code>// Max
num := max(1, 2, 3)
fmt.Println("Max =", num)

// Min
minNum := min(1, 2, 3)
fmt.Println("Min =", minNum)</code></pre>
<pre class="language-clike"><code>myList := []int{1, 2, 3}

// Max in Slice
max := slices.Max(myList)
fmt.Println("Max in Slice =", max)

// Min in Slice
min := slices.Min(myList)
fmt.Println("Min in Slice =", min)</code></pre>
<ul>
<li><strong>clear:</strong> Delete all elements from a map or zero all elements of a slice.</li>
</ul>
<pre class="language-clike"><code>m := map[string]int{"x": 1, "y": 2, "z": 3}
clear(m)
fmt.Println(m) // Outputs: map[]</code></pre>
<ul>
<li><strong>New log/slog package</strong>: provides structured logging, in which log records include a message, a severity level, and various other attributes expressed as key-value pairs.</li>
</ul>
<pre class="language-clike"><code>slog.Info("hello", "count", 3)
// output is
// 2022/11/08 15:28:26 INFO hello count=3


logger := slog.New(slog.NewTextHandler(os.Stderr, nil))
logger.Info("hello", "count", 3)
// output is
// time=2022-11-08T15:28:26.000-05:00 level=INFO msg=hello count=3


logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
logger.Info("hello", "count", 3)
// output is
// {"time":"2022-11-08T15:28:26.000000000-05:00","level":"INFO","msg":"hello","count":3}


slog.Group("request", "method", r.Method, "url", r.URL)
request.method=GET 
request.url=http://example.com
// output is
// "request":{"method":"GET","url":"http://example.com"}</code></pre>
<p><em>&gt;&gt; Explore more: 10 <a href="https://reliasoftware.com/blog/golang-logging-libraries">Best Logging Libraries for Golang Developers</a></em></p>
<h3><strong>Package Initialization Order</strong></h3>
<p>The package initialization order is now precisely specified. The new algorithm involves sorting all packages by import path and initializing them in a defined order. This change may impact programs relying on specific initialization orders, providing a more unambiguous definition.</p>
<h3><strong>Type Inference Improvements</strong></h3>
<p>Several improvements have been made to type inference, enhancing its power and precision:</p>
<ul>
<li>A generic function can now be called with arguments that are themselves generic functions.</li>
<li>Type inference considers methods when a value is assigned to an interface.</li>
<li>Multiple enhancements in type inference accuracy.</li>
</ul>
<h3><strong>Preview of Language Change</strong></h3>
<p>Go 1.21 includes a preview of a language change for loop variables, aiming to make them per-iteration rather than per-loop. This change helps avoid accidental sharing bugs. Check the LoopvarExperiment wiki page for details on trying out this language change.</p>
<h3><strong>Panicking and Recover</strong></h3>
<p>In Go 1.21, if a goroutine is panicking and <strong><code>recover</code></strong> was called directly by a deferred function, the return value of <strong><code>recover</code></strong> is guaranteed not to be nil. A runtime panic of type <strong><code>*runtime.PanicNilError</code></strong> will occur if panic is called with a nil interface value or an untyped nil. To support older Go versions, nil panics can be re-enabled by setting <strong><code>GODEBUG=panicnil=1</code></strong>.</p>
<p><em>&gt;&gt; You may consider:</em></p>
<ul>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation"><em>Hands-On Implementation for Dependency Injection in Go</em></a></li>
<li><em><a href="https://reliasoftware.com/blog/best-practices-for-dependency-inversion-in-golang" data-ved="2ahUKEwidmui-2_-CAxUWz2EKHdyWDgcQFnoECAwQAQ">Best Practices For Dependency Inversion in Golang</a></em></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle"><em>Detailed Code Examples of Dependency Inversion in Golang</em></a></li>
</ul>
<h2><strong>Tools</strong></h2>
<p>Go 1.21 enhances support for both backward and forward compatibility in the Go toolchain.</p>
<h3><strong>Backward Compatibility</strong></h3>
<p>To handle changes that are non-breaking but may impact existing programs, Go 1.21 formalizes the use of the <strong><code>GODEBUG</code></strong> environment variable. The toolchain now chooses between old and new behaviors based on the <strong><code>go</code></strong> line in the workspace's <strong><code>go.work</code></strong> file or the main module's <strong><code>go.mod</code></strong> file.</p>
<h3><strong>Forward Compatibility</strong></h3>
<p>Go 1.21 reads the <strong><code>go</code></strong> line in a <strong><code>go.work</code></strong> or <strong><code>go.mod</code></strong> file as a strict minimum requirement. If a workspace or module specifies <strong><code>go 1.21.0</code></strong>, it cannot be used with Go 1.20 or Go 1.21rc1. The <strong><code>go</code></strong> command can now invoke other Go toolchain versions found in the <strong><code>PATH</code></strong> or downloaded on demand based on the version specified in <strong><code>go.mod</code></strong> or <strong><code>go.work</code></strong>.</p>
<h3><strong>Go Command Changes</strong></h3>
<ul>
<li>The <strong><code>pgo</code></strong> build flag defaults to <strong><code>pgo=auto</code></strong>.</li>
<li>The <strong><code>C dir</code></strong> flag must be the first flag on the command line.</li>
<li>New options for <strong><code>go test</code></strong>: <strong><code>fullpath</code></strong>, <strong><code>c</code></strong>, and <strong><code>o</code></strong>.</li>
</ul>
<h3><strong>Cgo</strong></h3>
<p>In files that import <strong><code>"C"</code></strong>, the Go toolchain now correctly reports errors for attempts to declare Go methods on C types.</p>
<h2><strong>Runtime</strong></h2>
<p>Several enhancements and optimizations have been introduced in the runtime:</p>
<ul>
<li>Improved stack trace printing for better debugging.</li>
<li>Transparent huge page management on Linux platforms for better memory utilization.</li>
<li>Garbage collection tuning for up to 40% reduction in application tail latency.</li>
<li>Reduced overhead of subsequent C to Go calls on Unix platforms.</li>
</ul>
<h2><strong>Compiler</strong></h2>
<p>Profile-guided optimization (PGO) is now ready for general use, providing performance improvements of up to 7% for a representative set of Go programs. Assembler improvements and better build speed (up to 6%) have also been implemented.</p>
<h2><strong>Linker</strong></h2>
<p>On Windows/amd64, the linker emits SEH unwinding data by default, improving integration with Windows debuggers. The linker is now capable of deleting dead global map variables and offers better performance.</p>
<h2><strong>Core Library</strong></h2>
<h3><strong>New Packages</strong></h3>
<ul>
<li><strong>log/slog:</strong> <a href="https://reliasoftware.com/blog/structured-logging-with-golang-slog">Provides structured logging with levels</a>.</li>
<li><strong>testing/slogtest:</strong> A package to validate <strong><code>slog.Handler</code></strong> implementations.</li>
<li><strong>slices:</strong> Offers common operations on slices using generic functions.</li>
<li><strong>maps:</strong> Provides common operations on maps using generic functions.</li>
<li><strong>cmp:</strong> Defines the type constraint <strong><code>Ordered</code></strong> and two new generic functions <strong><code>Less</code></strong> and <strong><code>Compare</code></strong> for ordered types.</li>
</ul>
<h3><strong>Minor Changes</strong></h3>
<p>Various minor changes and updates have been made to the library, adhering to the Go 1 promise of compatibility. Performance improvements are included, though not explicitly detailed.</p>
<h2><strong>Archive and Compression Packages</strong></h2>
<p>Several improvements and additions have been made to packages such as <strong><code>archive/tar</code></strong>, <strong><code>archive/zip</code></strong>, and <strong><code>bytes</code></strong>.</p>
<h2><strong>Crypto Packages</strong></h2>
<ul>
<li><strong>crypto/ecdsa:</strong> Improvements in execution time for <strong><code>PublicKey.Equal</code></strong> and <strong><code>PrivateKey.Equal</code></strong>.</li>
<li><strong>crypto/elliptic:</strong> Deprecated methods and recommendations for ECDH operations.</li>
<li><strong>crypto/rand:</strong> Usage of <strong><code>getrandom</code></strong> system call on NetBSD 10.0 and later.</li>
</ul>
<h2><strong>TLS Package</strong></h2>
<p><a href="https://reliasoftware.com/blog/build-a-golang-http-client-with-net-http">The <strong><code>net/http</code></strong> package</a> introduces several new features and improvements, including enhanced support for errors, content control of session tickets, and improved handling of TLS alert codes for client authentication failures.</p>
<h2><strong>X.509 Package</strong></h2>
<p>The <strong><code>crypto/x509</code></strong> package deprecates <strong><code>RevocationList.RevokedCertificates</code></strong> in favor of <strong><code>RevokedCertificateEntries</code></strong> for improved revocation list management.</p>
<h2><strong>Debugging and Profiling</strong></h2>
<p>Improvements have been made in various packages related to debugging and profiling, such as <a href="https://reliasoftware.com/blog/debugging-golang-apps-with-go-tracing"><strong><code>runtime/trace</code></strong></a>, offering a smaller CPU cost and explicit stop-the-world events in traces.</p>
<h2><strong>Other Packages</strong></h2>
<p>Numerous other packages, including <strong><code>unicode</code></strong>, <strong><code>syscall</code></strong>, and <strong><code>errors</code></strong>, have undergone enhancements and improvements. The <strong><code>unicode</code></strong> package, in particular, has been upgraded to Unicode 15.0.0.</p>
<h2><strong>Platform-Specific Changes</strong></h2>
<ul>
<li><strong>Darwin:</strong> Requires macOS 10.15 Catalina or later.</li>
<li><strong>Windows:</strong> Support for Windows Server 2019.</li>
<li><strong>Linux:</strong> Improved support for cgroups v2.</li>
</ul>
<p>&gt;&gt;&nbsp;<em>You may be interested in:&nbsp;</em></p>
<ul>
<li><a href="https://reliasoftware.com/blog/arrays-and-slices-in-go"><em>Comprehending Arrays and Slices in Go Programming Language</em></a></li>
<li><em>Gin-Gonic Tutorial: <a href="https://reliasoftware.com/blog/gin-gonic-api-development">API Development in Go with Gin Famework</a></em></li>
<li><em>Type Conversion in Golang: <a href="https://reliasoftware.com/blog/type-conversion-in-golang">How To Convert Data Types in Go</a>?</em></li>
</ul>
<h2><strong>Conclusion</strong></h2>
<p>Go 1.21 packs a punch with its array of features, optimizations, and improvements across the language, toolchain, runtime, compiler, linker, core library, and various packages. <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a> are encouraged to explore the release notes and upgrade their projects to leverage the benefits of Go 1.21.</p>
<p>To download and get started with Go 1.21, visit the official <a href="https://go.dev/dl/" rel="nofollow noreferrer">Go download page</a>.</p>
<p style="text-align: right;"><em>&gt;&gt;&gt; Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!</em></p>

<p>Go 1.21, the latest release in the Go programming language series, brings a myriad of improvements in toolchain implementation, runtime, and libraries.</p>

What's New in Go 1.21 Release? Exploring 3 Handy Functions | Relia Software

large_functions-in-go-1-21-release.webp

medium_functions-in-go-1-21-release.webp

small_functions-in-go-1-21-release.webp

thumbnail_functions-in-go-1-21-release.webp

functions-in-go-1-21-release.webp

What's New in Go 1.21 Release? Exploring Three Handy Functions

<p>In many cases, you will need to convert data types. Professionals may find Golang's type conversion notion easy to grasp, but beginners may find it difficult to grasp anything at first. The fact that Golang has a distinct approach to type conversion is probably to blame for this. In this post, we will talk about type casting, also called a conversion, in <a href="https://reliasoftware.com/blog/what-is-golang">the Go programming language</a>.</p>
<p>&gt;&gt;&nbsp;<em>Read more about Golang:</em></p>
<ul>
<li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation"><em>Hands-On Implementation for Dependency Injection in Go</em></a></li>
<li><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle"><em>Detailed Code Examples of Dependency Inversion Principle in Go</em></a></li>
</ul>
<h2><strong>What is Type Conversion?</strong></h2>
<p><strong>Type conversion, or type casting, is the process of converting a value from one data type to another.</strong> In Go, a statically-typed language, explicit type conversion is required to ensure compatibility between different data types. It involves changing the type of a variable to another explicitly, providing precision and avoiding unintended behavior.</p>
<h2>Introduction to Go Data Types</h2>
<p>Go, a statically-typed language, categorizes data into various types, each with unique characteristics. The fundamental types include integers (int), floating-point numbers (float), strings, booleans, and more. To make informed decisions during type conversion, let's delve into a detailed comparison of integer and float types:</p>
<h3>Integer Types</h3>
<table style="border-collapse: collapse; border-color: rgb(0, 0, 0); border-style: solid; width: 98.1584%; height: 176.4px;" border="1">
<thead>
<tr style="height: 19.6px;">
<th style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">Type</th>
<th style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">Size (bits)</th>
<th style="border-color: rgb(0, 0, 0); width: 35.9769%; height: 19.6px;">Minimum Value</th>
<th style="border-color: rgb(0, 0, 0); width: 35.0972%; height: 19.6px;">Maximum Value</th>
</tr>
</thead>
<tbody>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">int8</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">8</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">-128</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">127</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">int16</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">16</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">-32768</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">32767</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">int32</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">32</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">-2147483648</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">2147483647</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">int64</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">64</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">-9223372036854775808</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">9223372036854775807</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">uint8</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">8</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">0</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">255</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">uint16</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">16</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">0</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">65535</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">uint32</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">32</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">0</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">4294967295</td>
</tr>
<tr style="height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 13.4704%; text-align: center; height: 19.6px;">uint64</td>
<td style="border-color: rgb(0, 0, 0); width: 15.4201%; text-align: center; height: 19.6px;">64</td>
<td style="border-color: rgb(0, 0, 0); width: 35.9769%; text-align: center; height: 19.6px;">0</td>
<td style="border-color: rgb(0, 0, 0); width: 35.0972%; text-align: center; height: 19.6px;">18446744073709551615</td>
</tr>
</tbody>
</table>
<h3>Floating-Point Types</h3>
<table style="border-collapse: collapse; border-color: rgb(0, 0, 0); border-style: solid; width: 98.5059%; height: 78.4px;" border="1">
<thead>
<tr style="height: 39.2px;">
<th style="border-color: rgb(0, 0, 0); width: 10.421%; height: 39.2px; text-align: center;">Type</th>
<th style="border-color: rgb(0, 0, 0); width: 12.1861%; height: 39.2px; text-align: center;">Size (bits)</th>
<th style="border-color: rgb(0, 0, 0); width: 40.9754%; height: 39.2px; text-align: center;">Smallest Non-zero Positive Value</th>
<th style="border-color: rgb(0, 0, 0); width: 36.3833%; height: 39.2px; text-align: center;">Largest Finite Value</th>
</tr>
</thead>
<tbody>
<tr style="height: 19.6px;">
<td style="text-align: center; border-color: rgb(0, 0, 0); width: 10.421%; height: 19.6px;">float32</td>
<td style="text-align: center; border-color: rgb(0, 0, 0); width: 12.1861%; height: 19.6px;">32</td>
<td style="text-align: center; border-color: rgb(0, 0, 0); width: 40.9754%; height: 19.6px;">&plusmn;1.401298464324817e-45</td>
<td style="text-align: center; border-color: rgb(0, 0, 0); width: 36.3833%; height: 19.6px;">&plusmn;3.4028234663852886e+38</td>
</tr>
<tr style="text-align: center; height: 19.6px;">
<td style="border-color: rgb(0, 0, 0); width: 10.421%; height: 19.6px; text-align: center;">float64</td>
<td style="border-color: rgb(0, 0, 0); width: 12.1861%; height: 19.6px; text-align: center;">64</td>
<td style="border-color: rgb(0, 0, 0); width: 40.9754%; height: 19.6px; text-align: center;">&plusmn;4.9406564584124654e-324</td>
<td style="border-color: rgb(0, 0, 0); width: 36.3833%; height: 19.6px; text-align: center;">&plusmn;1.7976931348623157e+308</td>
</tr>
</tbody>
</table>
<p>Understanding the nuances of each type is essential for making effective decisions during type conversion.</p>
<h2>What is the Need for Type Conversion in Golang?</h2>
<h3><strong>Why Go Requires Type Conversion?</strong></h3>
<p>Go statically-typed nature ensures compile-time safety and clarity. Explicit type conversion is necessary to avoid ambiguity and enhance code readability. The need for it is rooted in Go commitment to producing robust and predictable programs.</p>
<h3><strong>Go vs. Other Languages</strong></h3>
<p>Go insistence on explicit typing distinguishes it from dynamically-typed languages like JavaScript. While dynamic typing allows for more flexibility, Golang's static typing catches type-related errors at compile-time, enhancing robustness.</p>
<h3><strong>Scenarios Demanding Type Conversion</strong></h3>
<p><strong>Arithmetic Operations:</strong></p>
<p>When performing arithmetic operations involving different numeric types, explicit type conversion is necessary to avoid unexpected results or loss of precision.</p>
<pre class="language-clike"><code>var a int = 42
var b float64 = 3.14

result := float64(a) * b // Explicit conversion for accurate arithmetic</code></pre>
<p><strong>Interface Implementation:</strong></p>
<p>Interfaces in Go demand explicit type conversion when implementing methods for custom types, allowing them to satisfy the interface.</p>
<pre class="language-clike"><code>type MyInterface interface {
    PerformAction()
}

type MyType int

func (m MyType) PerformAction() {
    // Implementation for MyType
}

var obj MyInterface = MyType(42) // Explicit conversion to satisfy the interface</code></pre>
<p><em>&gt;&gt;&nbsp;Read more:</em></p>
<ul>
<li><a href="https://reliasoftware.com/blog/arrays-and-slices-in-go"><em>Comprehending Arrays and Slices in Go Programming Language</em></a></li>
<li style="font-style: italic;"><em><a href="https://reliasoftware.com/blog/cloud-success-blueprint-why-go-is-a-perfect-match">Cloud Success Blueprint</a>: Why Go Is A Perfect Match?</em></li>
</ul>
<h2><strong>Types of Type Conversion in Golang</strong></h2>
<h3><strong>Implicit Type Conversion</strong></h3>
<p>Implicit type conversion, also known as type coercion, occurs automatically when the compiler handles conversions between compatible types. However, Go emphasizes explicitness, and implicit conversion is limited. For instance, there's automatic conversion between numeric types when there's no loss of precision.</p>
<pre class="language-clike"><code>var a int = 42
var b float64 = a // Implicit conversion from int to float64</code></pre>
<h3><strong>Explicit Type Conversion</strong></h3>
<p>Explicit type conversion involves the programmer explicitly specifying the desired type. It provides control over how conversions are performed and is a key feature of Golang.</p>
<pre class="language-clike"><code>var intValue int = 42
var floatValue float64 = float64(intValue) // Explicit conversion from int to float64</code></pre>
<h2><strong>Scenarios Requiring To Convert Data Types</strong></h2>
<p>Type conversion is essential in various scenarios, playing a crucial role in ensuring the smooth operation of Go programs. Here are some key situations where type conversion is necessary:</p>
<ul>
<li><strong>Assigning Values:</strong> When you need to assign a value of one type to a variable of a different type, explicit type conversion is used to maintain compatibility.</li>
<li><strong>Function Calls:</strong> In situations where a function expects arguments of a specific type, type conversion is employed to ensure that the provided arguments match the expected types.</li>
<li><strong>Arithmetic Operations:</strong> Type conversion becomes crucial when performing arithmetic operations involving different numeric types. This is done to guarantee precision and prevent unintended behavior in calculations.</li>
<li><strong>Database Interaction:</strong> When interacting with databases, it's common to encounter different data types. Type conversion is necessary to harmonize the types and maintain consistency between the data stored in the database and the data handled in the Go program.</li>
<li><strong>JSON Encoding/Decoding:</strong> When working with JSON data, which is a common format for data exchange, type conversion is required. It allows for the transformation of <a href="https://reliasoftware.com/blog/golang-struct">Go data structures</a> into a JSON format for storage or transmission and vice versa.</li>
<li><strong>Interface Type Conversion:</strong> Go interfaces often require type conversion for seamless integration. This involves converting custom types to interface types, enabling objects of those types to satisfy the interface's expectations.</li>
</ul>
<h2>Sample Code</h2>
<h3>Assigning Values</h3>
<pre class="language-clike"><code>var intValue int = 42
var stringValue string = strconv.Itoa(intValue) // Explicit conversion from int to string
</code></pre>
<h3>Function Calls</h3>
<pre class="language-clike"><code>func processFloat(value float64) {
    // Processing float value
}

var intValue int = 42
processFloat(float64(intValue)) // Explicit conversion for function call</code></pre>
<h3>Arithmetic Operations</h3>
<pre class="language-clike"><code>var a int = 42
var b float64 = 3.14

result := float64(a) * b // Explicit conversion for accurate arithmetic</code></pre>
<h3>Database Interaction</h3>
<pre class="language-clike"><code>var quantity int = 10
var price float64 = 24.99

// Database query expecting quantity as float64
db.Query("INSERT INTO products (quantity, price) VALUES (?, ?)", float64(quantity), price)</code></pre>
<h3>JSON Encoding/Decoding</h3>
<pre class="language-clike"><code>package main

import (
	"encoding/json"
	"fmt"
)

// Define a struct representing a person
type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	// Create an instance of the Person struct
	p := Person{
		Name: "John Doe",
		Age:  30,
	}

	// JSON encoding: Convert struct to JSON
	jsonData, err := json.Marshal(p)
	if err != nil {
		fmt.Println("Error encoding JSON:", err)
		return
	}

	fmt.Println("JSON Encoding:")
	fmt.Println(string(jsonData))

	// JSON decoding: Convert JSON to struct
	var decodedPerson Person
	err = json.Unmarshal(jsonData, &amp;decodedPerson)
	if err != nil {
		fmt.Println("Error decoding JSON:", err)
		return
	}

	fmt.Println("\nJSON Decoding:")
	fmt.Printf("Name: %s\nAge: %d\n", decodedPerson.Name, decodedPerson.Age)
}</code></pre>
<h3>Type Conversion in Interface</h3>
<pre class="language-clike"><code>package main

import "fmt"

// Define an interface with a method
type Shape interface {
	Area() float64
}

// Define a struct representing a rectangle
type Rectangle struct {
	Width  float64
	Height float64
}

// Implement the Area method for Rectangle
func (r Rectangle) Area() float64 {
	return r.Width * r.Height
}

// Define a struct representing a circle
type Circle struct {
	Radius float64
}

// Implement the Area method for Circle
func (c Circle) Area() float64 {
	return 3.14 * c.Radius * c.Radius
}

func main() {
	// Create instances of Rectangle and Circle
	rect := Rectangle{Width: 5, Height: 3}
	circle := Circle{Radius: 2}

	// Use the Area method through the Shape interface
	shapes := []Shape{rect, circle}

	fmt.Println("Calculating Areas:")
	for _, shape := range shapes {
		area := shape.Area()
		fmt.Printf("Area: %f\n", area)
	}
}</code></pre>
<h2>Compile Error on Implicit Type Conversion</h2>
<p>While Golang allows some implicit type conversions, there are cases where it results in a compile-time error. This emphasizes Golang commitment to type safety.</p>
<pre class="language-clike"><code>var x int = 42
var y string = x // Compile-time error: cannot use x (type int) as type string in assignment</code></pre>
<p>This compile-time error serves as a safeguard, preventing unintended conversions and maintaining the integrity of the codebase.</p>
<p>Handling compile errors due to implicit type conversion in Go involves recognizing the potential pitfalls and addressing them by explicitly converting types where necessary. Here are some strategies to handle compile errors related to implicit type conversion:</p>
<h3><strong>1. Review Variable Assignments</strong></h3>
<ul>
<li>Carefully review all variable assignments, especially when assigning values of one type to a variable of another type.</li>
<li>Explicitly convert the values using the appropriate type conversion syntax.</li>
</ul>
<pre class="language-clike"><code>var x int = 42
var y string = strconv.Itoa(x) // Explicit conversion from int to string</code></pre>
<h3><strong>2. Check Function Signatures</strong></h3>
<ul>
<li>Examine function signatures, ensuring that arguments provided match the expected types.</li>
<li>Use explicit type conversion when calling functions with arguments of different types.</li>
</ul>
<pre class="language-clike"><code>func processFloat(value float64) {
    // Processing float value
}

var intValue int = 42
processFloat(float64(intValue)) // Explicit conversion for function call</code></pre>
<h3><strong>3. Be Explicit in Arithmetic Operations</strong></h3>
<p>When performing arithmetic operations involving different numeric types, be explicit in type conversion to avoid unintended behavior.</p>
<pre class="language-clike"><code>var a int = 42
var b float64 = 3.14

result := float64(a) * b // Explicit conversion for accurate arithmetic</code></pre>
<h3>4. Handle Interface Type Assertion</h3>
<p>When using type assertions with interfaces, ensure that the types match. Handle type assertion errors gracefully using type switches or checking the type before asserting.</p>
<pre class="language-clike"><code>var x interface{} = 42

// Check type before type assertion
if val, ok := x.(int); ok {
    // Proceed with int value
} else {
    // Handle the case where the type assertion fails
}</code></pre>
<h3>5. Use Explicit JSON Conversion</h3>
<p>When working with JSON encoding/decoding, explicitly specify the types to avoid ambiguity and ensure the correct mapping between Go types and JSON.</p>
<pre class="language-clike"><code>type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// Explicit JSON encoding
jsonData, err := json.Marshal(Person{"John Doe", 30})</code></pre>
<p>By addressing these aspects, developers can handle compile errors related to implicit type conversion effectively. The key is to be explicit about type conversions, ensuring that the types align appropriately to avoid compilation issues.</p>
<p>&gt;&gt;&nbsp;<em>You may consider:</em></p>
<ul>
<li><em>Top 10 <a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang">Best IDEs for Golang Web Development</a></em></li>
<li><em>Top 10 Best <a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks">Golang Web Frameworks</a></em></li>
</ul>
<h2><strong>Conclusion</strong></h2>
<p>In summary, handling different types of data in Go involves some careful steps based on how the language works. It's important for <a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers">Go developers</a> to grasp the details of various data types, figure out when to use direct or clear conversions, and identify situations where converting types is necessary.</p>
<p>Getting a good handle on type conversion helps developers make their code clearer, safer, and more accurate, leading to sturdy and dependable software.</p>
<p dir="ltr" style="text-align: right;"><em>Follow and Contact&nbsp;<a href="https://reliasoftware.com/">Relia Software</a> for more information!</em></p>

<p>Type conversion is the process of converting a value from one data type to another. Explicit type conversion in Go ensure compatibility between different data types.</p>

Type Conversion in Golang: How To Convert Data Types in Go? | Relia Software

large_type-conversion-in-golang.webp

medium_type-conversion-in-golang.webp

small_type-conversion-in-golang.webp

thumbnail_type-conversion-in-golang.webp

type-conversion-in-golang.webp

Type Conversion in Golang: How To Convert Data Types in Go?

<p>Arrays and Slices is fundamental to working effectively in <a href="https://reliasoftware.com/blog/what-is-golang">the Go programming language</a>. They are key data structures used for organizing and manipulating collections of data. In this explanation, I'll describe what arrays and slices are, how they differ, and when to use one over the other.</p><p><i>&gt;&gt; Read more: </i><a href="https://reliasoftware.com/blog/practice-of-solid-in-golang-dependency-inversion-principle"><i>Detailed Code Examples of Dependency Inversion Principle in Go</i></a></p><h2><strong>Understanding Golang Arrays</strong></h2><h3><strong>Definition</strong></h3><p><strong>An array is a fixed-size, ordered collection of elements of the same </strong><a href="https://reliasoftware.com/blog/type-conversion-in-golang"><strong>data type</strong></a><strong>. </strong>The size of an array is determined at the time of declaration, and it cannot be changed during the program's execution.</p><h3><strong>Declaration</strong></h3><p>In Go, you declare an array like this:</p><pre><code class="language-plaintext">var arr [5]int</code></pre><p>This creates an integer array of size 5.</p><h3><strong>Access</strong></h3><p>You can access elements of an array using index notation, starting at 0. For example:</p><pre><code class="language-plaintext">arr[0] = 1
element := arr[2]</code></pre><p><strong>Size</strong>: The size of an array is fixed and cannot be changed.</p><h2><strong>Understanding Golang Slices</strong></h2><h3><strong>Definition</strong></h3><p>A slice is a dynamic and flexible view on an underlying array. Slices are like references to an array, and they can grow or shrink as needed. They are more versatile than arrays.</p><h3><strong>Declaration</strong></h3><p>Slices are often created by slicing an existing array, or you can create them directly using the&nbsp;<code>make</code> function. For example:</p><pre><code class="language-plaintext">var slice []int        // A slice with no specific length or underlying array.
slice := make([]int, 5) // A slice with a specific length.</code></pre><h3><strong>Access</strong></h3><p>Slices are accessed in the same way as arrays, using index notation. Slices can also be sliced further, and you can append new elements to them.</p><h3><strong>Size</strong></h3><p>Slices have a dynamic size, and they can grow or shrink by creating a new slice based on the original slice.</p><p>&gt;&gt;&nbsp;<i>Read more about the Go programming language:</i></p><ul><li><a href="https://reliasoftware.com/blog/cloud-success-blueprint-why-go-is-a-perfect-match"><i>Cloud Success Blueprint</i></a><i>: Why Go Is A Perfect Match?</i></li><li><a href="https://reliasoftware.com/blog/practical-guide-to-dependency-injection-in-go-hands-on-implementation"><i>Practical Guide to Dependency Injection in Go</i></a><i>: Hands-On Implementation</i></li><li><a href="https://reliasoftware.com/blog/go-for-web-development"><i>Go for Web Development</i></a><i>: How Top Companies Achieve Powerful Business Results with Golang?</i></li></ul><h2><strong>Comparison Between Arrays and Slices</strong></h2><p>Here's a comparison of slices and arrays in a tabular format:</p><figure class="table" style="width:100.069%;"><table style="border-color:rgb(0, 0, 0);border-style:solid;"><thead><tr><th style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Aspect</th><th style="border-color:rgb(0, 0, 0);text-align:center;width:39.4659%;">Slice</th><th style="border-color:rgb(0, 0, 0);text-align:center;width:38.0732%;">Array</th></tr></thead><tbody><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Dynamic Sizing</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Yes, dynamic and can grow or shrink.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">No, fixed size at declaration.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Capacity Growth Strategy</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Doubles capacity as needed.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">Fixed size; cannot change.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Efficient Appends</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Yes, amortized O(1) time complexity.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">No appends; fixed size.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Bounds Checking</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Built-in bounds checking for safety.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">No bounds checking; may result in errors.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Resizing</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Auto-managed by Go's runtime.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">Not applicable; fixed size.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Pass by Value</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Passes a reference (pointer).</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">Passes a copy of the data.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Copying Data</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Copy-on-write (only if necessary).</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">Not applicable; fixed size.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Initial Declaration</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">make([]T, len, cap) or slicing.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">[len]T.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Length</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Dynamic and changes with append operations.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">Fixed and set at declaration.</td></tr><tr><td style="border-color:rgb(0, 0, 0);text-align:center;width:22.4272%;">Common Use Cases</td><td style="border-color:rgb(0, 0, 0);width:39.4659%;">Dynamic collections, slices of arrays.</td><td style="border-color:rgb(0, 0, 0);width:38.0732%;">Fixed-size data, more memory-efficient.</td></tr></tbody></table></figure><p><strong>Dynamic Size</strong>: Arrays have a fixed size, while slices are dynamic and can grow or shrink.</p><p><strong>Underlying Array</strong>: Slices are built on top of arrays. They reference an underlying array. If you modify a slice, it can affect the array it's based on. Arrays do not have an underlying array concept.</p><p><strong>Passing by Reference</strong>: Slices are reference types, so when you pass a slice to a function, you're passing a reference to the underlying data. Arrays, on the other hand, are passed by value, which means the entire array is copied when passed to a function.</p><p><strong>Flexibility</strong>: Slices are more flexible and versatile for most use cases because of their dynamic nature. Arrays are mainly used when you need a fixed-size collection of elements.</p><p>&gt;&gt;&nbsp;<i>Read more: </i><a href="https://reliasoftware.com/blog/how-to-hire-the-best-golang-developers"><i>Tips For Hiring The Best Golang Developers</i></a></p><p>In Go, arrays have a fixed size, and their capacity doesn't grow or change. Slices, on the other hand, have dynamic sizing and can grow as elements are appended to them. To compare the behavior of arrays and slices, you can create an array and a slice and observe how they behave differently. Here's an example:</p><pre><code class="language-plaintext">package main

import (
	"fmt"
)

func main() {
	// Create an array with a fixed size of 5
	array := [5]int{1, 2, 3, 4, 5}

	// Create a slice with an initial length of 5 and capacity of 5
	slice := make([]int, 5)

	// Function to print the array and slice properties
	printArrayAndSlice := func(arr [5]int, slc []int) {
		fmt.Printf("Array: %v, Length: %d\\n", arr, len(arr))
		fmt.Printf("Slice: %v, Length: %d, Capacity: %d\\n", slc, len(slc), cap(slc))
	}

	// Print the initial state of the array and slice
	printArrayAndSlice(array, slice)

	// Try to append to the array (which is not possible)
	// Uncommenting this line will result in a compilation error:
	// array[5] = 6

	// Append elements to the slice
	for i := 6; i &lt;= 10; i++ {
		slice = append(slice, i)
		printArrayAndSlice(array, slice)
	}
}</code></pre><pre><code class="language-plaintext">Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0], Length: 5, Capacity: 5
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6], Length: 6, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7], Length: 7, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7 8], Length: 8, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7 8 9], Length: 9, Capacity: 10
Array: [1 2 3 4 5], Length: 5
Slice: [0 0 0 0 0 6 7 8 9 10], Length: 10, Capacity: 10</code></pre><p>Go's slice resizing strategy involves the following key aspects:</p><p><strong>Initial Capacity</strong>: When you create a slice using the <code>make</code> function or by slicing an existing array, it's assigned an initial capacity. The capacity is determined by the size of the underlying array. The initial capacity of the slice may be greater than or equal to its length, but it can never be less than the length.</p><p><strong>Doubling Capacity</strong>: When you append an element to a slice, Go checks if there is enough capacity to accommodate the new element. If the current capacity is insufficient, Go automatically doubles the capacity by creating a new underlying array with double the size of the old array and copying the elements from the old array to the new one. This ensures amortized constant-time append operations.</p><p><strong>Copy-On-Write</strong>: Slices in Go are designed to minimize the need for copying. When you append an element to a slice, Go creates a new underlying array only if necessary. Otherwise, it appends the element to the existing array. This means that slices share their underlying array until a change is made.</p><p><strong>Growing Beyond Doubling</strong>: Slices continue to double in capacity as they grow, but it's important to note that the actual resizing behavior may be more complex than simple doubling. Go's runtime may optimize this process by considering factors such as available memory, locality, and other system-specific considerations.</p><p><strong>Efficient Appends</strong>: Go's slice resizing strategy aims to provide efficient append operations while <a href="https://reliasoftware.com/blog/golang-memory-leak">managing memory effectively</a>. The use of doubling capacity helps ensure that the amortized time complexity for append operations is O(1).</p><p>Here's an example that demonstrates how the capacity of a slice changes as elements are appended:</p><pre><code class="language-plaintext">package main

import (
	"fmt"
)

func main() {
	slice := make([]int, 0, 1) // Create an empty slice with an initial capacity of 1

	// Function to print the slice and its length and capacity
	printSlice := func(s []int) {
		log.Printf("Length: %d, Capacity: %d, Data: %v\n", len(s), cap(s), s)
	}

	// Initial state
	printSlice(slice)

	// Append elements to the slice
	for i := 0; i &lt; 10; i++ {
		slice = append(slice, i)
		printSlice(slice)
	}
}</code></pre><pre><code class="language-plaintext">Length: 0, Capacity: 1, Data: []
Length: 1, Capacity: 1, Data: [0]
Length: 2, Capacity: 2, Data: [0 1]
Length: 3, Capacity: 4, Data: [0 1 2]
Length: 4, Capacity: 4, Data: [0 1 2 3]
Length: 5, Capacity: 8, Data: [0 1 2 3 4]
Length: 6, Capacity: 8, Data: [0 1 2 3 4 5]
Length: 7, Capacity: 8, Data: [0 1 2 3 4 5 6]
Length: 8, Capacity: 8, Data: [0 1 2 3 4 5 6 7]
Length: 9, Capacity: 16, Data: [0 1 2 3 4 5 6 7 8]
Length: 10, Capacity: 16, Data: [0 1 2 3 4 5 6 7 8 9]</code></pre><p>In this example, we explicitly set the initial capacity of the slice to 1. As elements are appended to the slice, you can observe how the capacity changes, and the slice is dynamically resized to accommodate the new elements. The resizing strategy, involving doubling capacity when needed, helps maintain efficient and predictable performance characteristics for slices in Go.</p><p>The code example provided demonstrates the growth of a slice's capacity as elements are appended. Here's a more detailed breakdown of the results you can expect from that code:</p><pre><code class="language-plaintext">package main

import (
    "fmt"
)

func main() {
    slice := make([]int, 0, 1) // Create an empty slice with an initial capacity of 1

    // Function to print the slice and its length and capacity
    printSlice := func(s []int) {
        fmt.Printf("Length: %d, Capacity: %d, Data: %v\\n", len(s), cap(s), s)
    }

    // Initial state
    printSlice(slice)
}</code></pre><p>We start with an empty slice <code>slice</code> with an initial capacity of 1. The initial capacity is specified as the second argument to the <code>make</code> function. This means the slice can initially hold one element without needing to allocate a new underlying array.</p><p>We use the <code>printSlice</code> function to print the length, capacity, and content of the slice. At this point, the slice is empty, so its length is 0.</p><pre><code class="language-plaintext">    // Append elements to the slice
    for i := 0; i &lt; 10; i++ {
        slice = append(slice, i)
        printSlice(slice)
    }
}</code></pre><p>Inside a loop, we append elements to the slice by using the <code>append</code> function. As elements are appended, you'll see the following behavior:</p><ul><li>Initially, the capacity is 1, so the first element can be added without allocating a new array. The length and capacity both increase to 1, and the data is [0].</li><li>When you attempt to add the second element, the capacity is exceeded (1 &lt; 2). The slice is automatically resized by creating a new underlying array with double the capacity (2). The elements are copied to the new array, and the old array is released. The length and capacity both increase to 2, and the data is [0, 1].</li><li>This process continues as elements are appended, doubling the capacity as needed. You'll see the capacity grow to 4, 8, and so on.</li></ul><p>As you run the code, you'll observe the growth of the slice's capacity to accommodate the increasing number of elements. Go's automatic resizing strategy ensures that, in practice, the amortized time complexity for append operations remains close to O(1), making slices efficient for dynamic data collections.</p><h2><strong>When to Use Arrays vs. Slices?</strong></h2><ul><li>Use arrays when you know the size of your data in advance and it won't change during the program's execution.</li><li>Use slices when you need a dynamic collection that can grow or shrink. Slices are more commonly used in Go for handling data structures and collections.</li></ul><p>Slices and arrays serve different purposes and are chosen based on your specific needs. Slices are more versatile and are commonly used for dynamic collections of data, whereas arrays are used when a fixed-size, compact data structure is required. Slices provide dynamic sizing, bounds checking, and automatic resizing, making them safer and more flexible for many use cases.</p><p>&gt;&gt;&nbsp;<i>You may consider:</i></p><ul><li><i>Top 10 </i><a href="https://reliasoftware.com/blog/top-10-best-golang-web-frameworks"><i>Best Golang Web Frameworks</i></a></li><li><i>The 10 </i><a href="https://reliasoftware.com/blog/10-best-ides-for-go-lang"><i>Best IDEs for GoLang Web Development</i></a></li></ul><p>&nbsp;</p><h2>Conclusion</h2><p>In this article, you learnt Go array and slice basics. Multiple exercises showed how arrays are fixed in length while slices are flexible, and how this impacts their situational usage. Hope this will helpul for you!&nbsp;</p><p style="text-align:right;"><i>&gt;&gt;&gt; Follow and Contact&nbsp;</i><a href="https://reliasoftware.com/"><i>Relia Software</i></a><i> for more information!</i></p>

<p>An Array is a fixed-size, ordered collection of elements of the same data type. A Slice is a dynamic and flexible view on an underlying array. Read more here!</p>

Comprehending Arrays and Slices in Go Programming Language | Relia Software

large_arrays-and-slices-in-go.webp

medium_arrays-and-slices-in-go.webp

small_arrays-and-slices-in-go.webp

thumbnail_arrays-and-slices-in-go.webp

arrays-and-slices-in-go.webp

Comprehending Arrays and Slices in the Go Programming Language

<p>Go (Golang) is the perfect choice for building cloud-native applications because its features like concurrency model, fast compilation, and cloud-ready architecture.</p>

Why Go is a Perfect Choice for Cloud-Native App Development? | Relia Software

Go is a Perfect Choice for Cloud-Native App Development

large_cloud-native-go-app.webp

medium_cloud-native-go-app.webp

small_cloud-native-go-app.webp

thumbnail_cloud-native-go-app.webp

cloud-native-go-app.webp

Cloud-Native App Development: Why Go is a Perfect Match?

<p>Dependency Injection (DI) is a design pattern in software development that helps enhance the modularity, maintainability, and testability of codebases.</p>

Hands-On Implementation for Dependency Injection in Golang | Relia Software

large_dependency-injection-in-go.webp

medium_dependency-injection-in-go.webp

small_dependency-injection-in-go.webp

thumbnail_dependency-injection-in-go.webp

dependency-injection-in-go.webp

Hands-On Implementation for Dependency Injection in Golang

featured

software-development.webp

Software Development

outsourcing.webp

Outsourcing

software-as-service-business.webp

Business

automation.webp

Automation

artificial-intelligence.webp

AI/ML

Relia Software is an AI-driven custom software development company with 10+ years of experience in delivering 300+ web and mobile solutions for global businesses.

Relia Software | Custom & AI-Driven Software Development Company

Solutions We Provide

Solutions We Provide

Huy Nguyen

About Huy Nguyen

Articles by Huy Nguyen