Vérifiez si une chaîne a un espace blanc

J'essaye de vérifier si une chaîne a un espace blanc . J'ai trouvé cette fonction mais elle ne semble pas fonctionner:

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;
}

Au fait, j'ai ajouté des citations à RegExp.

Y a-t-il quelque chose qui ne va pas? Y a-t-il quelque chose de mieux que je puisse utiliser? Espérons que JQuery.

Vous pouvez simplement utiliser la méthode indexOf sur la chaîne d'entrée:

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

Ou vous pouvez utiliser la méthode de test, sur un simple RegEx:

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

Cela vérifiera également les autres caractères d'espace blanc comme Tab.

Votre regex ne correspondra à rien, tel quel. Vous devez absolument supprimer les guillemets - le"/" caractères sont suffisants.

/^\s+$/vérifie si la chaîne est TOUS les espaces:

• ^ correspond au début de la chaîne.
• \s+ signifie au moins 1, éventuellement plus, espaces.
• $ correspond à la fin de la chaîne.

Essayez de remplacer l'expression régulière par /\s/(et sans guillemets)

Cette fonction vérifie les autres types d'espaces, pas seulement les espaces (tabulation, retour chariot, 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 vous ne souhaitez pas utiliser Lodash , voici une someimplémentation simple avec 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;
};

Ensuite, remplacez-le simplement somepar ssome.

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

Pour ceux de Node, utilisez:

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

Voici ma suggestion de validation:

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;
    }
}

Une approche simple que vous pourriez adopter est de comparer la longueur de la chaîne d'origine avec celle de la chaîne pour remplacer les espaces par rien. Par exemple:

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

Avec des ajouts à la langue, c'est beaucoup plus facile et vous pouvez profiter du retour anticipé:

// 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));

Je n'ai pas exécuté de benchmark de performances, mais ceux-ci devraient être plus rapides que les expressions régulières, mais pour les petits extraits de texte, il n'y aura pas beaucoup de différence de toute façon.

Quelques autres ont publié des réponses. Il y a des problèmes évidents, comme le retour falselorsque le Regex passe, et les opérateurs ^et $indiquent le début / la fin, alors que la question recherche a (n'importe quel) espace, et non: contient uniquement des espaces (que l'expression régulière vérifie).

En plus de cela, le problème n'est qu'une faute de frappe.

Change ça...

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

Pour ça...

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

Lorsque vous utilisez une expression régulière à l'intérieur RegExp(), vous devez faire les deux choses suivantes ...

• Omettez les /crochets de début et de fin .
• Double échapper le code de toutes les séquences, c'est- \\sà- dire à la place de \s, etc.

Démo de travail complète à partir du code source ....

$(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>