Firefox의 JavaScript 콘솔에서만 시도했지만 다음 설명 중 어느 것도 true를 반환하지 않습니다.

parseFloat('geoff') == NaN;

parseFloat('geoff') == Number.NaN;

이 코드를 사용해보십시오 :

isNaN(parseFloat("geoff"))

여부를 확인하기위한 어떤 값 대신 숫자, NaN의 여기를 참조 : 어떻게 자바 스크립트에서 NaN의 테스트합니까?

방금 효과적인 JavaScript 라는 책 에서이 기술을 보았습니다 .

NaN은 자신과 동일하지 않은 것으로 취급되는 유일한 JavaScript 값이므로 항상 값이 동일한 지 확인하여 NaN인지 테스트 할 수 있습니다.

var a = NaN;
a !== a; // true 

var b = "foo";
b !== b; // false 

var c = undefined; 
c !== c; // false

var d = {};
d !== d; // false

var e = { valueOf: "foo" }; 
e !== e; // false

@allsyed가 코멘트 할 때까지 이것을 깨닫지 못했지만 이것은 ECMA 사양에 있습니다 : https://tc39.github.io/ecma262/#sec-isnan-number

이 코드를 사용하십시오 :

isNaN('geoff');

isNaN()MDN에 대한 문서를 참조하십시오 .

alert ( isNaN('abcd'));  // alerts true
alert ( isNaN('2.0'));  // alerts false
alert ( isNaN(2.0));  // alerts false

Number 유형의 값이 값 인지 여부를 테스트하는 NaN한 전역 함수 isNaN가 작업을 수행합니다.

isNaN(any-Number);

JS의 모든 유형에 적용되는 일반적인 접근 방식의 경우 다음 중 하나를 사용할 수 있습니다.

ECMAScript-5 사용자의 경우 :

#1
if(x !== x) {
    console.info('x is NaN.');
}
else {
    console.info('x is NOT a NaN.');
}

ECMAScript-6를 사용하는 사람들 :

#2
Number.isNaN(x);

ECMAScript 5와 6에서 일관성을 유지하기 위해이 폴리 필을 Number.isNan에 사용할 수도 있습니다.

#3
//Polyfill from MDN
Number.isNaN = Number.isNaN || function(value) {
    return typeof value === "number" && isNaN(value);
}
// Or
Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

자세한 내용은 이 답변 을 확인 하십시오.

NaN은 그렇게 테스트 할 수없는 특별한 값입니다. 내가 방금 공유하고 싶었던 흥미로운 것은

var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
    alert('nanValue is NaN');

NaN 값에 대해서만 true 를 반환하며 안전한 테스트 방법입니다. 동일한 변수가 서로 같지 않은지 테스트하는 것은 분명하지 않기 때문에 함수에 래핑되거나 주석을 달아야합니다.

다음 isNaN(value)과 같은 이유로 전역 함수 호출을 사용해야합니다 .

• 크로스 브라우저에 대응
• 설명서는 isNaN 을 참조하십시오

예 :

 isNaN('geoff'); // true
 isNaN('3'); // false

이것이 도움이되기를 바랍니다.

현재 ES6 , Object.is(..)절대 어떤지 두 값을 테스트하는 데 사용될 수있는 새로운 유틸리티이다 :

var a = 3 / 'bar';
Object.is(a, NaN); // true

'1.2geoff'파싱 되는 문제를 해결하려면 Number()파서를 대신 사용하십시오 .

그래서 이것보다는 :

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

이 작업을 수행:

Number('1.2geoff'); // => NaN
isNaN(Number('1.2geoff')); // => true
isNaN(Number('.2geoff')); // => true
isNaN(Number('geoff')); // => true

편집 : 방금 이것으로부터 또 다른 문제를 발견했습니다 ... false 값 (및 실제 부울로 true)은 다음 Number()과 같이 반환되었습니다 0! 어떤 경우에 ... parseFloat는 매번 작동합니다. 그래서 다시 생각해보십시오.

function definitelyNaN (val) {
    return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}

그리고 그것은 겉보기 모든 것을 다룹니다. 나는 lodash보다 90 % 느리게 벤치마킹 _.isNaN했지만 모든 NaN을 다루지는 않습니다.

http://jsperf.com/own-isnan-vs-underscore-lodash-isnan

명확히하기 위해, 내 숫자는 "숫자가 아님"에 대한 인간의 문자 적 ​​해석을 처리하고 lodash는 "NaN"인지 확인하는 컴퓨터의 문자 적 ​​해석을 처리합니다.

@chiborg의 대답은 정확하지만 주목해야 할 것이 더 있습니다.

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

요점은 입력의 유효성 검사 에이 방법을 사용하면 결과가 다소 자유 롭습니다.

따라서 그렇습니다 parseFloat(string)(또는 전체 숫자의 경우 parseInt(string, radix)'를 사용한 다음을 사용하여 래핑 할 isNaN()수 있지만 숫자가 아닌 추가 문자와 얽힌 숫자로 된 문제를 알고 있어야합니다.

간단한 해결책!

정말 슈퍼 간단합니다! 여기! 이 방법을 사용하십시오!

function isReallyNaN(a) { return a !== a; };

다음과 같이 간단하게 사용하십시오.

if (!isReallyNaN(value)) { return doingStuff; }

here이 기능을 사용하여 성능 테스트 를 참조하십시오selected answer

또한 : 몇 가지 대체 구현에 대해서는 아래의 첫 번째 예를 참조하십시오.

예:

function isReallyNaN(a) { return a !== a; };

var example = {
    'NaN': NaN,
    'an empty Objet': {},
    'a parse to NaN': parseFloat('$5.32'),
    'a non-empty Objet': { a: 1, b: 2 },
    'an empty Array': [],
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined
  }

for (x in example) {
    var answer = isReallyNaN(example[x]),
        strAnswer = answer.toString();
    $("table").append($("<tr />", { "class": strAnswer }).append($("<th />", {
        html: x
    }), $("<td />", {
        html: strAnswer
    })))
};

table { border-collapse: collapse; }
th, td { border: 1px solid; padding: 2px 5px; }
.true { color: red; }
.false { color: green; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table></table>

대체적으로 명명 된 메소드를 사용하지 않고보다 전 세계적으로 사용 가능하도록하려면 구현을 위해 몇 가지 대체 경로를 사용하십시오. 경고 이러한 솔루션에는 기본 개체 변경이 포함되며 최상의 솔루션이 아닐 수 있습니다. 항상주의를 기울이고 사용할 수있는 다른 라이브러리는 기본 코드 또는 유사한 변경에 따라 달라질 수 있습니다.

대체 구현 1 : 기본 isNaN메소드 바꾸기 .

//  Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }

대체 구현 2 : 숫자 객체에 추가
^{* ECMA 5 ~ 6에 대한 폴리 필이므로 제안}

Number['isNaN'] || (Number.isNaN = function(a) { return a !== a });
//  Use as simple as
Number.isNaN(NaN)

_{비어있는 경우} 대체 솔루션 _테스트

object가 Empty 인 경우 간단한 테스트 방법으로 테스트를 작성했습니다 . 항목이 "정확하게"NaN 인 경우 제공하지 않는다는 점에서 약간 다릅니다 .하지만 빈 항목을 찾을 때 유용 할 수 있으므로 이것을 버릴 것이라고 생각했습니다.

/** isEmpty(varried)
 *  Simple method for testing if item is "empty"
 **/
;(function() {
   function isEmpty(a) { return (!a || 0 >= a) || ("object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a))); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

예:

;(function() {
   function isEmpty(a) { return !a || void 0 === a || a !== a || 0 >= a || "object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a)); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

var example = {
    'NaN': NaN,
    'an empty Objet': {},
    'a parse to NaN': parseFloat('$5.32'),
    'a non-empty Objet': { a: 1, b: 2 },
    'an empty Array': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined
  }

for (x in example) {
	var answer = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
th, td { border: 1px solid; padding: 2px 5px; }
.true { color: red; }
.false { color: green; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

비어있는 경우 매우 깊은 검사

이 마지막 객체는 객체가 빈 객체로 가득 차 있는지 확인하여 조금 깊어집니다. 나는 그것이 개선과 가능한 구덩이를위한 공간이 있다고 확신하지만, 지금까지는 모든 것을 잡는 것처럼 보입니다.

function isEmpty(a) {
	if (!a || 0 >= a) return !0;
	if ("object" == typeof a) {
		var b = JSON.stringify(a).replace(/"[^"]*":(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '').replace(/"[^"]*":\{\},?/g, '');
		if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		else if (a instanceof Array)  {
			b = b.replace(/(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '');
			if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		}
	}
	return false;
}
window.hasOwnProperty("empty")||(window.empty=isEmpty);

var example = {
    'NaN': NaN,
    'an empty Objet': {},
    'a parse to NaN': parseFloat('$5.32'),
    'a non-empty Objet': { a: 1, b: 2 },
    'an empty Array': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined,
    'Object Full of Empty Items': { 1: '', 2: [], 3: {}, 4: false, 5:new Array(3), 6: NaN, 7: null, 8: void 0, 9: 0, 10: '0', 11: { 6: NaN, 7: null, 8: void 0 } },
    'Array Full of Empty Items': ["",[],{},false,[null,null,null],null,null,null,0,"0",{"6":null,"7":null}]
  }

for (x in example) {
	var answer = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
th, td { border: 1px solid; padding: 2px 5px; }
.true { color: red; }
.false { color: green; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

다른 대안을 공유하고 싶습니다. 다른 대안보다 반드시 낫지는 않지만 볼만한 가치가 있다고 생각합니다.

function customIsNaN(x) { return (typeof x == 'number' && x != 0 && !x); }

이 뒤에 논리를 제외한 모든 수 있다는 것입니다 0및 NaN캐스팅된다 true.

나는 빠른 테스트를 수행했으며, Number.isNaN그 자체가 거짓인지 확인하는 것만큼이나 성능이 우수합니다 . 세 가지 모두보다isNan

결과

customIsNaN(NaN);            // true
customIsNaN(0/0);            // true
customIsNaN(+new Date('?')); // true

customIsNaN(0);          // false
customIsNaN(false);      // false
customIsNaN(null);       // false
customIsNaN(undefined);  // false
customIsNaN({});         // false
customIsNaN('');         // false

고장난 isNaN기능 을 피하려면 유용 할 수 있습니다.

환경이 ECMAScript를 2015를 지원하는 경우 에, 당신은 사용할 수 Number.isNaN있는지 값이 정말 있는지 확인하기 위해 NaN.

문제는 isNaN,이다 당신이 적용되는 숫자가 아닌 데이터 (MDN에 따라) 몇 혼란 규칙이 있다는 것을 사용하는 경우. 예를 들어

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN({});        // true

따라서 ECMA Script 2015 지원 환경에서 사용할 수 있습니다

Number.isNaN(parseFloat('geoff'))

JavaScript의 NaN은 "숫자가 아님"을 나타내지 만 실제로 유형은 숫자입니다.

typeof(NaN) // "number"

변수가 NaN 값인지 확인하려면 isNaN ()에 다음과 같은 문제가 있으므로 isNaN () 함수를 사용할 수 없습니다. 아래를 참조하십시오.

var myVar = "A";
isNaN(myVar) // true, although "A" is not really of value NaN

여기서 실제로 발생하는 것은 myVar이 암시 적으로 숫자로 강제된다는 것입니다.

var myVar = "A";
isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact

"A"는 실제로 숫자가 아니기 때문에 실제로 의미가 있습니다. 그러나 우리가 정말로 확인하고 싶은 것은 myVar가 NaN의 가치인지 정확하게입니다.

따라서 isNaN ()은 도울 수 없습니다. 그렇다면 우리는 어떻게해야합니까?

NaN이 자신과 동일하지 않은 것으로 취급되는 유일한 JavaScript 값이라는 점에서,! ==를 사용하여 자신과의 동등성을 확인할 수 있습니다.

var myVar; // undefined
myVar !== myVar // false

var myVar = "A";
myVar !== myVar // false

var myVar = NaN
myVar !== myVar // true

결론적 으로 변수! == 자체 인 것이 사실이라면이 변수의 값은 정확히 NaN입니다.

function isOfValueNaN(v) {
    return v !== v;
}

var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

JavaScript 에서는 밑줄isNaN 기능을 사용 합니다 .

isNaN(undefined) 
-> true

최소한 그 문제를 알고 있어야합니다.

아마 이것도 :

function isNaNCustom(value){
    return value.toString() === 'NaN' && 
           typeof value !== 'string' && 
           typeof value === 'number'
}

isNaN ()은 Node.js에서 기본적으로 지원되지 않는 것 같습니다.
나는 함께 일했다

var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);

NaN === NaN;        // false
Number.NaN === NaN; // false
isNaN(NaN);         // true
isNaN(Number.NaN);  // true

등식 연산자 (== 및 ===)를 사용하여 NaN에 대한 값을 테스트 할 수 없습니다.

보다 모질라 문서 글로벌 NaN의 속성에 값이 없음-A-한 접점을 대표한다

가장 좋은 방법은 buit-in 함수 인 'isNaN ()'을 사용하여 NaN을 확인하는 것입니다. 모든 브라우저가 지원합니다 ..

규칙은 다음과 같습니다.

NaN != NaN

isNaN () 함수의 문제점은 다음과 같은 경우에 예기치 않은 결과를 리턴 할 수 있다는 것입니다.

isNaN('Hello')      //true
isNaN('2005/12/12') //true
isNaN(undefined)    //true
isNaN('NaN')        //true
isNaN(NaN)          //true
isNaN(0 / 0)        //true

값이 실제로 NaN인지 확인하는 더 좋은 방법은 다음과 같습니다.

function is_nan(value) {
    return value != value
}

is_nan(parseFloat("geoff"))

IEEE 754에 따르면 NaN과 관련된 모든 관계는! =를 제외하고 false로 평가됩니다. 따라서, 예를 들어, A 또는 B 또는 둘 모두가 NaN 인 경우 (A> = B) = false 및 (A <= B) = false입니다.

다른 사람이 언제 확인 하지만 중복으로 표시되어 작업을 낭비하고 싶지 않은 StackOverflow의 다른 질문 에이 답변을 썼습니다 NaN == null.

에 대한 Mozilla 개발자 네트워크를 살펴보십시오 NaN.

짧은 답변

distance || 0가치가 올바른지 확인하거나 확인하려는 경우 에만 사용 하십시오 isNaN().

긴 대답

NaN (Not-a-Number)은 일부 수학적 연산이 실패했을 때 자주 반환되는 이상한 JavaScript 객체입니다.

NaN == null어떤 결과 가 있는지 확인하고 싶었습니다 false. Hovewer는로 NaN == NaN결과를 얻 습니다 false.

변수가 NaN전역 함수 인지 확인하는 간단한 방법isNaN() 입니다.

또 하나는 x !== xx가 NaN 인 경우에만 적용됩니다. (@ raphael-schweikert에게 상기시켜 주셔서 감사합니다)

그러나 왜 짧은 대답이 효과가 있었습니까?

알아 보자.

호출 NaN == false하면 결과는와 false동일합니다 NaN == true.

사양 어딘가에 JavaScript에는 항상 거짓 값이있는 레코드가 있습니다. 여기에는 다음이 포함됩니다.

• NaN -숫자가 아님
• "" -빈 문자열
• false -부울 거짓
• null -null 객체
• undefined -정의되지 않은 변수
• 0 -+0 및 -0을 포함한 숫자 0

다른 해결책은 MDN의 parseFloat 페이지에 언급되어 있습니다 .

엄격한 구문 분석을 수행하는 필터 기능을 제공합니다.

var filterFloat = function (value) {
    if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/
      .test(value))
      return Number(value);
  return NaN;
}


console.log(filterFloat('421'));               // 421
console.log(filterFloat('-421'));              // -421
console.log(filterFloat('+421'));              // 421
console.log(filterFloat('Infinity'));          // Infinity
console.log(filterFloat('1.61803398875'));     // 1.61803398875
console.log(filterFloat('421e+0'));            // NaN
console.log(filterFloat('421hop'));            // NaN
console.log(filterFloat('hop1.61803398875'));  // NaN

그리고 당신은 isNaN그것이 있는지 확인하는 데 사용할 수 있습니다NaN

확인하는 정확한 방법은 다음과 같습니다.

//takes care of boolen, undefined and empty

isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'

나는 매력처럼 작동하는이 작은 기능을 만들었습니다. 직관적이지 않은 NaN을 확인하는 대신 숫자를 확인합니다. 나는이 방법을 처음으로하지는 않을 것이라고 확신하지만 공유 할 것이라고 생각했습니다.

function isNum(val){
    var absVal = Math.abs(val);
    var retval = false;
    if((absVal-absVal) == 0){
        retval = true
    }

    return retval;
}

재미로 다른 길을 찾았습니다.

function IsActuallyNaN(obj) {
  return [obj].includes(NaN);  
}

marksyzm의 답변은 잘 작동하지만 InfinityInfinity는 기술적으로 숫자 가 아니기 때문에 false를 반환하지 않습니다 .

나는 isNumber그것이 숫자인지 확인 하는 기능을 생각해 냈습니다 .

function isNumber(i) {
    return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY].indexOf(i) === -1;
}

console.log(isNumber(Infinity));
console.log(isNumber("asdf"));
console.log(isNumber(1.4));
console.log(isNumber(NaN));
console.log(isNumber(Number.MAX_VALUE));
console.log(isNumber("1.68"));

업데이트 : 나는이 코드가 일부 매개 변수에 대해 실패한다는 것을 알았으므로 더 좋았습니다.

function isNumber(i) {//function for checking if parameter is number
if(!arguments.length) {
throw new SyntaxError("not enough arguments.");
	} else if(arguments.length > 1) {
throw new SyntaxError("too many arguments.");
	} else if([Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY].indexOf(i) !== -1) {
throw new RangeError("number cannot be \xB1infinity.");
	} else if(typeof i === "object" && !(i instanceof RegExp) && !(i instanceof Number) && !(i === null)) {
throw new TypeError("parameter cannot be object/array.");
	} else if(i instanceof RegExp) {
throw new TypeError("parameter cannot be RegExp.");
	} else if(i == null || i === undefined) {
throw new ReferenceError("parameter is null or undefined.");
	} else {
return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && (i === i);
	}
}
console.log(isNumber(Infinity));
console.log(isNumber(this));
console.log(isNumber(/./ig));
console.log(isNumber(null));

alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

이것은 우아하지 않습니다. 그러나 isNAN ()을 시도한 후에 다른 대안 인이 솔루션에 도달했습니다. 이 예에서는 '.'도 허용했습니다. 플로트를 마스킹하고 있기 때문입니다. 숫자를 사용하지 않도록 이것을 반대로 할 수도 있습니다.

("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)

이것은 단일 문자 평가이지만 문자열을 반복하여 숫자를 확인할 수도 있습니다.

isNaN 자바 스크립트 함수를 사용하여 NaN을 확인할 수 있습니다. 숫자 나 값을 isNaN 함수에 전달하기 만하면됩니다.

isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN('123') //false
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN('') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true

결과를 문자열로 변환하고 'NaN'과 비교하십시오.

var val = Number("test");
if(String(val) === 'NaN') {
   console.log("true");
}

가 비수 (NaN> = 0) ? ...... " 나도 몰라 ".

function IsNotNumber( i ){
    if( i >= 0 ){ return false; }
    if( i <= 0 ){ return false; }
    return true;
}

조건은 TRUE 인 경우에만 실행됩니다 .

거짓이 아닙니다 .

" 모름 "에 없습니다 .