Могу ли я определить, является ли строка идентификатором объекта MongoDB?

Я выполняю поиск в MongoDB, преобразовывая строку в BSON. Есть ли способ определить, является ли имеющаяся у меня строка действительным идентификатором объекта для Mongo, прежде чем выполнять преобразование?

Вот coffeescript для моей текущей функции findByID. Он отлично работает, но я хотел бы выполнить поиск по другому атрибуту, если я определю, что строка не является идентификатором.

db.collection "pages", (err, collection) ->
  collection.findOne
    _id: new BSON.ObjectID(id)
  , (err, item) ->
    if item
      res.send item
    else
      res.send 404

Я обнаружил, что валидатор mongoose ObjectId работает для проверки допустимых идентификаторов объектов, но я обнаружил несколько случаев, когда недопустимые идентификаторы считались действительными. (например: любая длинная строка из 12 символов)

var ObjectId = require('mongoose').Types.ObjectId;
ObjectId.isValid('microsoft123'); //true
ObjectId.isValid('timtomtamted'); //true
ObjectId.isValid('551137c2f9e1fac808a5f572'); //true

То, что у меня работало, - это приведение строки к objectId, а затем проверка того, что исходная строка соответствует строковому значению objectId.

new ObjectId('timtamtomted'); //616273656e6365576f726b73
new ObjectId('537eed02ed345b2e039652d2') //537eed02ed345b2e039652d2

Это работает, потому что действительные идентификаторы не меняются при преобразовании в ObjectId, но строка, которая получает ложный действительный идентификатор, изменится при преобразовании в objectId.

Вы можете использовать регулярное выражение, чтобы проверить это:

CoffeeScript

if id.match /^[0-9a-fA-F]{24}$/
    # it's an ObjectID
else
    # nope

JavaScript

if (id.match(/^[0-9a-fA-F]{24}$/)) {
    // it's an ObjectID    
} else {
    // nope    
}

Раньше для этого я использовал собственный драйвер узла mongodb. Метод isValid проверяет, является ли значение допустимым BSON ObjectId. См. Документацию здесь.

var ObjectID = require('mongodb').ObjectID;
console.log( ObjectID.isValid(12345) );

Если вы используете Mongoose, мы можем проверить, имеет ли строка 12 байтов или строку из 24 шестнадцатеричных символов, используя встроенный в mongoose isValidObjectId .

mongoose.isValidObjectId (string) вернет true / false

Это обновленное решение, предоставленное принятым решением .

Вот код, который я написал на основе ответа @andy-macleod.

Он может принимать либо int, либо строку, либо ObjectId и возвращает действительный ObjectId, если переданное значение допустимо, или null, если оно недействительно:

var ObjectId= require('mongoose').Types.ObjectId;

function toObjectId(id) {

    var stringId = id.toString().toLowerCase();

    if (!ObjectId.isValid(stringId)) {
        return null;
    }

    var result = new ObjectId(stringId);
    if (result.toString() != stringId) {
        return null;
    }

    return result;
}

mongoose.Types.ObjectId.isValid (string) всегда возвращает True, если строка содержит 12 букв

let firstUserID = '5b360fdea392d731829ded18';
let secondUserID = 'aaaaaaaaaaaa';

console.log(mongoose.Types.ObjectId.isValid(firstUserID)); // true
console.log(mongoose.Types.ObjectId.isValid(secondUserID)); // true

let checkForValidMongoDbID = new RegExp("^[0-9a-fA-F]{24}$");
console.log(checkForValidMongoDbID.test(firstUserID)); // true
console.log(checkForValidMongoDbID.test(secondUserID)); // false

Единственный способ, который я нашел, - это создать новый ObjectId со значением, которое я хочу проверить, если вход равен выходу, идентификатор действителен:

function validate(id) {
    var valid = false;
    try
    {
        if(id == new mongoose.Types.ObjectId(""+id))
           valid = true;

    }
    catch(e)
    {
       valid = false;
    }
    return valid;
}

> validate(null)
false
> validate(20)
false
> validate("abcdef")
false
> validate("5ad72b594c897c7c38b2bf71")
true

Самый простой способ - обернуть ваш метод ObjectId в службу «попробуй и поймай». Затем вы используете эту службу для обработки идентификаторов Objecet Id вместо прямого использования метода:

var ObjectId = REQUIRE OR IMPORT ...

// service
function oid(str) {
 try {   
   return ObjectId(str);
 } catch(err) {
   return false;
 }
}

// usage
if (oid(USER_INPUT)) {
  // continue
} else {
  // throw error
}

Вы также можете отправить пустые или пустые реквизиты, чтобы получить новый сгенерированный идентификатор.

Самый простой способ проверить, является ли строка допустимым Mongo ObjectId, - использовать модуль mongodb .

const ObjectID = require('mongodb').ObjectID;

if(ObjectID.isValid(777777777777777)){
   console.log("Valid ObjectID")
}

Ниже представлена ​​функция, которая проверяет с помощью isValidметода ObjectId и new ObjectId(id)возвращает ли одно и то же значение. Причина isValidтого, что недостаточно одного, очень хорошо описана Энди Маклаудом в выбранном ответе.

const ObjectId = require('mongoose').Types.ObjectId;

/**
 * True if provided object ID valid
 * @param {string} id 
 */
function isObjectIdValid(id){ 
  return ObjectId.isValid(id) && new ObjectId(id) == id;
}

Если у вас есть шестнадцатеричная строка, вы можете использовать это:

ObjectId.isValid(ObjectId.createFromHexString(hexId));

Мне потребовалось некоторое время, чтобы получить действительное решение, поскольку предложенное @Andy Macleod сравнение значения objectId с его собственной строкой приводило к сбою сервера Express.js на:

var view_task_id_temp=new mongodb.ObjectID("invalid_id_string"); //this crashed

Я просто использовал простую попытку, чтобы решить эту проблему.

var mongodb = require('mongodb');
var id_error=false;
try{
    var x=new mongodb.ObjectID("57d9a8b310b45a383a74df93");
    console.log("x="+JSON.stringify(x));
}catch(err){
    console.log("error="+err);
    id_error=true;
}

if(id_error==false){
   // Do stuff here
}

Для мангуста используйте функцию isValid (), чтобы проверить, действителен ли objectId или нет

Пример :

var ObjectId = mongoose.Types.ObjectId;
if(ObjectId.isValid(req.params.documentId)){
   console.log('Object id is valid'); 
}else{
   console.log('Invalid Object id');
}

В ответе на решение Энди Маклауд сказал:

То, что у меня работало, - это приведение строки к objectId, а затем проверка того, что исходная строка соответствует строковому значению objectId.

new ObjectId('timtamtomted'); //616273656e6365576f726b73
new ObjectId('537eed02ed345b2e039652d2') //537eed02ed345b2e039652d2

Это работает, потому что действительные идентификаторы не меняются при преобразовании в ObjectId, но строка, которая получает ложное действительное значение, изменится при преобразовании в objectId.

Реализацией этого подхода была бы функция, которая проверяет, является ли переданное значение допустимым ObjectIdи работает со значениями stringи ObjectId(объекта). Это выглядело бы примерно так:

var ObjectId = require("mongoose");.Types.ObjectId;

function isValidObjectId(value) {
  // If value is an object (ObjectId) cast it to a string
  var valueString = typeof value === "string" ? value : String(value); 

  // Cast the string to ObjectId
  var idInstance = new ObjectId(valueString); 

  return String(idInstance) === valueString;
}

@ ross-u ответ просто потрясающий.

Я связал методы для полной встроенной проверки:

documentId = id && isValid(id) && new ObjectId(id) == id ? id : null

Обратите внимание на двойной знак равенства, который ОЧЕНЬ важен, поскольку new ObjectId() не возвращает строку, а строгое сравнение вернет false при сравнении с нормальной строкой (что я использовал в своей логике).

Методы были деструктурированы из mongooseобъекта, предоставленного требованием:

const {
  Types: {
    ObjectId: { isValid },
    ObjectId
  }
} = require("mongoose");

Предупреждение: isValid вернет true для строк произвольной длины 12/24, начинающихся с допустимой шестнадцатеричной цифры. В настоящее время я думаю, что это лучшая проверка:

((thing.length === 24 || thing.length === 12) && isNaN(parseInt(thing,16)) !== true)