Moving from Vanilla JavaScript to a Reusable Vue Component

This article demonstrates refactoring a vanilla JavaScript countdown timer into a reusable Vue component. The original timer, detailed in a previous article, lacked reusability and efficient UI synchronization. This conversion addresses these shortcomings.

Why use Vue? Primarily for two reasons:

• Synchronized UI and Timer State: The original JavaScript code managed state within the timerInterval function, directly manipulating DOM elements. Vue's template syntax declaratively binds the DOM to the component's data, simplifying UI updates.
• Reusability: The original timer relied on element IDs, limiting its reusability. A Vue component encapsulates its logic, enabling multiple independent timer instances on a single page.

Here's the Vue implementation:

Template and Styles

Vue uses an HTML-based template system. We'll create a BaseTimer.vue file with the following structure:

<code><template>
  <!-- ... -->
</template>

<script>
  // ...
</script>

<style scoped>
  /* ... */
</style></code>

The <template></template> section contains the timer's markup (mostly SVG from the previous article), and the <style scoped></style> section contains the CSS.

<template>
  <div class="base-timer">
    <svg viewbox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
      <g>
        <circle cx="50" cy="50" r="45"></circle>
        <path :class="remainingPathColor" :stroke-dasharray="circleDasharray" d="
            M 50, 50
            m -45, 0
            a 45,45 0 1,0 90,0
            a 45,45 0 1,0 -90,0
          "></path>
      </g>
    </svg>
    {{ formattedTimeLeft }}
  </div>
</template>

<style scoped>
.base-timer {
  position: relative;
  width: 100px;
  height: 100px;
}
</style>

Key aspects of the timer are controlled through data binding: stroke-dasharray, remainingPathColor, and formatTime(timeLeft).

Constants and Variables

The <script></script> section defines constants and variables. Constants, such as FULL_DASH_ARRAY, WARNING_THRESHOLD, ALERT_THRESHOLD, and COLOR_CODES, are defined directly.

Variables are categorized: those directly re-assigned in methods (timerInterval, timePassed) and those dependent on other variables (timeLeft, remainingPathColor).

Reactive Variables

Variables directly modified in methods are declared within the data() method to leverage Vue's reactivity system:

data() {
  return {
    timePassed: 0,
    timerInterval: null
  };
},

Computed Properties

Variables dependent on other variables are implemented as computed properties:

computed: {
  timeLeft() {
    return TIME_LIMIT - this.timePassed;
  },
  circleDasharray() {
    return `${(this.timeFraction * FULL_DASH_ARRAY).toFixed(0)} 283`;
  },
  formattedTimeLeft() {
    // ... (time formatting logic) ...
  },
  timeFraction() {
    // ... (time fraction calculation) ...
  },
  remainingPathColor() {
    // ... (color calculation based on timeLeft) ...
  }
},

Computed properties are pure functions, cached for efficiency.

Using Data and Computed Properties in the Template

The template utilizes text interpolation ({{ ... }}) and v-bind (or its shorthand :) directives to dynamically bind data and computed properties to the DOM.

Methods and Lifecycle Hooks

The startTimer method, simplified due to the use of computed properties, is called within the mounted() lifecycle hook:

methods: {
  startTimer() {
    this.timerInterval = setInterval(() => (this.timePassed  = 1), 1000);
  }
},
mounted() {
  this.startTimer();
},

Component Usage

To use the BaseTimer component in another component (e.g., App.vue):

1. Import: import BaseTimer from "./components/BaseTimer";
2. Register: components: { BaseTimer }
3. Instantiate: <basetimer></basetimer> in the template.

This refactoring demonstrates the benefits of using Vue components for improved code organization, reusability, and efficient state management. The resulting component is self-contained and easily integrated into larger applications.

The above is the detailed content of Moving from Vanilla JavaScript to a Reusable Vue Component. For more information, please follow other related articles on the PHP Chinese website!