WEMOS D1 R1 Interrupt repeats continuously, when triggered, Is it bouncing? How to fix it?
It could be a hardware problem for which you would need an oscilloscope to track down. Also check whether interrupts are available for D8 on your particular Arduino:
attachInterrupt()
Software Oscilloscope for Arduino
You could try using the Arduino as a software oscilloscope to see if the input is bouncing by taking a rapid sequence of samples and sending them to the serial port, something like this:
const int BUTTON_PIN = 2;

const int NUM_SAMPLES = 512;
int samples[NUM_SAMPLES];

void setup()
{
  Serial.begin(115200);
  Serial.println(&quot;\n\nInitialising...&quot;);

  pinMode(BUTTON_PIN, INPUT);
  
  // Clear the samples array.
  for (int i = 0; i &lt; NUM_SAMPLES; i++)
  {
    samples[i] = 0;
  }
  
  Serial.println(&quot;Finished setup.&quot;);
}

void loop()
{
  static int sample_i = 0;
  static int total_i = 0;
  if (sample_i == NUM_SAMPLES)
  {
    // Write the samples to the serial port.
    char str[24];
    for (sample_i = 0; sample_i &lt; NUM_SAMPLES; sample_i++)
    {
      sprintf(str, &quot;%10d: %10d\n\0&quot;, total_i++, samples[sample_i]);
      Serial.print(str);
    }
    sample_i = 0;
  }
  else
  {
    // Read the next sample.
    samples[sample_i++] = digitalRead(BUTTON_PIN);
  }
}

Debounce a Button using Hysteresis for Arduino
You could also see if it's possible to debounce the button using a polling technique without interrupts. If this technique doesn't work, it points to a hardware problem.
This Arduino code uses a polling technique to debounce the button using hysteresis. The LED shows the state of the button. To avoid wasting processor time and power, the code only writes to the LED output pin upon a successful debounce. To ensure that an accurate time stamp is obtained when reading the button, it temporarily disables interrupts before reading the button and the timer, then enables interrupts again.
#include &lt;util/atomic.h&gt;

class Debouncer
{
private:
  int input_pin;
  bool output_state;
  bool rise;
  bool fall;
  unsigned long debounce_delay_ms;
  unsigned long last_ms;

public:

  Debouncer(const int input_pin, const unsigned long debounce_delay_ms = 50)
  {
    this-&gt;input_pin = input_pin;
    this-&gt;debounce_delay_ms = debounce_delay_ms;
    this-&gt;output_state = false;
  }

  bool Output() const { return output_state; }
  bool Rise() const { return rise; }
  bool Fall() const { return fall; }

  bool IsDebounced()
  {
    bool input_state;
    unsigned long current_ms;
    
    // Temporarily disable interrupts to ensure an accurate time stamp for the sample.
    ATOMIC_BLOCK( ATOMIC_RESTORESTATE )
    {
      input_state = digitalRead(input_pin);  // No interrupt will occur between here...
      current_ms = millis();                 // ...and here, ensuring an accurate time stamp for the sample.
    }

    rise = fall = false;

    // Hysteresis:
    //   If there is no change, reset the debounce timer.
    //   Else, compare the time difference with the debounce delay.
    if (input_state == output_state)
    {
      last_ms = current_ms;
    }
    else if ((current_ms - last_ms) &gt;= debounce_delay_ms)
    {
      // Successfully debounced, so update the outputs.
      rise = input_state &amp;&amp; !output_state;
      fall = !input_state &amp;&amp; output_state;
      output_state = input_state;
      return true;
    }
    return false;
  }
};

const int BUTTON_PIN = 2;  // Pushbutton pin number.
const int LED_PIN = 13;    // LED pin number.
const unsigned long DEBOUNCE_DELAY_ms = 50;  // The debounce time in milliseconds.

void setup()
{
  // Set pin modes.
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
}

void loop()
{
  static Debouncer button_debouncer(BUTTON_PIN, DEBOUNCE_DELAY_ms);
  static bool led_state = false;

  if (button_debouncer.IsDebounced())
  {
    // Update the LED to show the debounced signal.
    digitalWrite(LED_PIN, button_debouncer.Output());

    // Alternative feedback: Toggle the LED on the rising edge of the debounced signal.
    /**
    if (button_debouncer.Rise())
    {
      led_state = !led_state;
      digitalWrite(LED_PIN, led_state);
    }
    /**/
  }
}