Compruebe si una cadena tiene espacios en blanco

Estoy tratando de verificar si una cadena tiene espacios en blanco . Encontré esta función pero no parece estar funcionando:

function hasWhiteSpace(s) 
{
    var reWhiteSpace = new RegExp("/^\s+$/");

    // Check for white space
    if (reWhiteSpace.test(s)) {
        //alert("Please Check Your Fields For Spaces");
        return false;
    }

    return true;
}

Por cierto, agregué citas a RegExp.

¿Hay algo mal? ¿Hay algo mejor que pueda usar? Con suerte, JQuery.

Simplemente puede usar el método indexOf en la cadena de entrada:

function hasWhiteSpace(s) {
  return s.indexOf(' ') >= 0;
}

O puede usar el método de prueba, en una expresión regular simple:

function hasWhiteSpace(s) {
  return /\s/g.test(s);
}

Esto también buscará otros caracteres de espacio en blanco como Tab.

Su expresión regular no coincidirá con nada, tal como está. Definitivamente necesitas eliminar las comillas, los "/"caracteres son suficientes.

/^\s+$/está comprobando si la cadena es TODOS los espacios en blanco:

• ^ coincide con el inicio de la cadena.
• \s+ significa al menos 1, posiblemente más, espacios.
• $ coincide con el final de la cadena.

Intente reemplazar la expresión regular con /\s/(y sin comillas)

Esta función busca otros tipos de espacios en blanco, no solo el espacio (tabulación, retorno de carro, etc.)

import some from 'lodash/fp/some'
const whitespaceCharacters = [' ', '  ',
  '\b', '\t', '\n', '\v', '\f', '\r', `\"`, `\'`, `\\`,
  '\u0008', '\u0009', '\u000A', '\u000B', '\u000C',
'\u000D', '\u0020','\u0022', '\u0027', '\u005C',
'\u00A0', '\u2028', '\u2029', '\uFEFF']
const hasWhitespace = char => some(
  w => char.indexOf(w) > -1,
  whitespaceCharacters
)

console.log(hasWhitespace('a')); // a, false
console.log(hasWhitespace(' ')); // space, true
console.log(hasWhitespace(' ')); // tab, true
console.log(hasWhitespace('\r')); // carriage return, true

Si no desea utilizar Lodash , aquí hay una someimplementación simple con 2 s:

const ssome = (predicate, list) =>
{
  const len = list.length;
  for(const i = 0; i<len; i++)
  {
    if(predicate(list[i]) === true) {
      return true;
    }
  }
  return false;
};

Luego simplemente reemplácelo somecon ssome.

const hasWhitespace = char => some(
  w => char.indexOf(w) > -1,
  whitespaceCharacters
)

Para aquellos en Node, use:

const { some } = require('lodash/fp');

Aquí está mi validación sugerida:

var isValid = false;

// Check whether this entered value is numeric.
function checkNumeric() {
    var numericVal = document.getElementById("txt_numeric").value;

    if(isNaN(numericVal) || numericVal == "" || numericVal == null || numericVal.indexOf(' ') >= 0) {
        alert("Please, enter a numeric value!");
        isValid = false;
    } else {
        isValid = true;
    }
}

Un enfoque simple que podría tomar es comparar la longitud de la cadena original con la de la cadena para reemplazar los espacios en blanco con nada. Por ejemplo:

function hasWhiteSpaces(string) {
    if (string.length == string.replace(" ", "").length) {return false}
    return true
}

Con adiciones al idioma es mucho más fácil, además puedes aprovechar la devolución anticipada:

// Use includes method on string
function hasWhiteSpace(s) {
  const whitespaceChars = [' ', '\t', '\n'];
  return whitespaceChars.some(char => s.includes(char));
}

// Use character comparison
function hasWhiteSpace(s) {
  const whitespaceChars = [' ', '\t', '\n'];
  return Array.from(s).some(char => whitespaceChars.includes(char));
}

const withSpace = "Hello World!";
const noSpace = "HelloWorld!";

console.log(hasWhiteSpace(withSpace));
console.log(hasWhiteSpace(noSpace));

console.log(hasWhiteSpace2(withSpace));
console.log(hasWhiteSpace2(noSpace));

No ejecuté pruebas comparativas de rendimiento, pero deberían ser más rápidas que las expresiones regulares, pero para los fragmentos de texto pequeños no habrá mucha diferencia de todos modos.

Algunos otros han publicado respuestas. Hay algunos problemas obvios, como que regresa falsecuando la expresión regular pasa, y los operadores ^y $indican inicio / fin, mientras que la pregunta que se busca tiene (cualquier) espacio en blanco, y no: solo contiene espacios en blanco (que la expresión regular está verificando).

Además de eso, el problema es solo un error tipográfico.

Cambia esto...

var reWhiteSpace = new RegExp("/^\s+$/");

A esto...

var reWhiteSpace = new RegExp("\\s+");

Cuando use una expresión regular dentro RegExp(), debe hacer las dos cosas siguientes ...

• Omita los /corchetes de inicio y finalización .
• Haga doble escape al código de todas las secuencias, es decir, \\sen lugar de \s, etc.

Demostración de trabajo completa desde el código fuente ...

$(document).ready(function(e) { function hasWhiteSpace(s) {
        var reWhiteSpace = new RegExp("\\s+");
    
        // Check for white space
        if (reWhiteSpace.test(s)) {
            //alert("Please Check Your Fields For Spaces");
            return 'true';
        }
    
        return 'false';
    }
  
  $('#whitespace1').html(hasWhiteSpace(' '));
  $('#whitespace2').html(hasWhiteSpace('123'));
});

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
" ": <span id="whitespace1"></span><br>
"123": <span id="whitespace2"></span>