(내장) JavaScript에서 문자열이 유효한 숫자인지 확인하는 방법
이전 VB6 IsNumeric()기능 과 동일한 개념적 공간에 무언가가 있기를 바랍니다 .
변수 (문자열 포함)가 숫자인지 확인하려면 숫자가 아닌지 확인합니다.
이것은 변수 내용이 문자열인지 숫자인지에 관계없이 작동합니다.
isNaN(num) // returns true if the variable does NOT contain a valid number
예
isNaN(123) // false
isNaN('123') // false
isNaN('1e10000') // false (This translates to Infinity, which is a number)
isNaN('foo') // true
isNaN('10px') // true
물론 필요한 경우이를 무효화 할 수 있습니다. 예를 들어, 제공 한 IsNumeric예제 를 구현하려면 다음을 수행하십시오 .
function isNumeric(num){
return !isNaN(num)
}
숫자가 포함 된 문자열을 숫자로 변환하려면 :
문자열 에 숫자 만 포함 된 경우에만 작동 하고 그렇지 않으면를 반환합니다 NaN.
+num // returns the numeric value of the string, or NaN
// if the string isn't purely numeric characters
예
+'12' // 12
+'12.' // 12
+'12..' // Nan
+'.12' // 0.12
+'..12' // Nan
+'foo' // NaN
+'12px' // NaN
문자열을 느슨하게 숫자로 변환하려면
'12px'를 12로 변환하는 데 유용합니다. 예 :
parseInt(num) // extracts a numeric value from the
// start of the string, or NaN.
예
parseInt('12') // 12
parseInt('aaa') // NaN
parseInt('12px') // 12
parseInt('foo2') // NaN These last two may be different
parseInt('12a5') // 12 from what you expected to see.
수레
곰 염두에두고 있다고는 달리 +num, parseInt(이름에서 알 수 있듯이) 소수점을 다음 모든 잘라낸에 의해 정수에 float를 변환합니다 (사용하려는 경우 parseInt() 때문에 이 문제가, 당신은 아마 더 나은 대신 다른 방법을 사용하여 길 이죠 ) :
+'12.345' // 12.345
parseInt(12.345) // 12
parseInt('12.345') // 12
빈 문자열
빈 문자열은 다소 직관적이지 않을 수 있습니다. +num빈 문자열을 0으로 변환 isNaN()하고 동일하다고 가정합니다.
+'' // 0
isNaN('') // false
그러나 parseInt()동의하지 않습니다.
parseInt('') // NaN
그리고 RegExp 방식으로 갈 수 있습니다.
var num = "987238";
if(num.match(/^-{0,1}\d+$/)){
//valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
//valid float
}else{
//not valid number
}
문자열이 정수인지 (소수점 없음) 확인하려는 경우 정규식이 좋은 방법입니다. 과 같은 다른 방법 isNaN은 너무 복잡해서 너무 간단합니다.
function isNumeric(value) {
return /^-{0,1}\d+$/.test(value);
}
console.log(isNumeric('abcd')); // false
console.log(isNumeric('123a')); // false
console.log(isNumeric('1')); // true
console.log(isNumeric('1234567890')); // true
console.log(isNumeric('-23')); // true
console.log(isNumeric(1234)); // true
console.log(isNumeric('123.4')); // false
console.log(isNumeric('')); // false
console.log(isNumeric(undefined)); // false
console.log(isNumeric(null)); // false
양의 정수만 허용하려면 다음을 사용하십시오.
function isNumeric(value) {
return /^\d+$/.test(value);
}
console.log(isNumeric('123')); // true
console.log(isNumeric('-23')); // false
당신이 정말로 문자열은 숫자, 숫자 (정수 또는 부동 소수점), 정확히 숫자가 포함되어 있는지 확인하려면, 당신은 할 수 사용 parseInt()/ parseFloat(), Number()또는 !isNaN()스스로. 참고 !isNaN()실제로 반환 true할 때 Number()숫자를 반환하고, false그것을 반환 할 때 NaN, 그래서 토론의 나머지 부분에서 제외됩니다.
문제는 parseFloat()문자열이 숫자가 포함 된 경우 문자열이 포함되지 않은 경우에도이 숫자를 반환 할 것입니다 단지 와 정확히 번호 :
parseFloat("2016-12-31") // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2
문제 Number()는 전달 된 값이 전혀 숫자가 아닌 경우 숫자를 반환한다는 것입니다!
Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0 \t\n\r") // returns 0
자체 정규식을 롤링 할 때의 문제는 Javascript가 인식하는 부동 소수점 숫자와 일치하는 정확한 정규식을 만들지 않으면 케이스를 놓치거나하지 말아야 할 경우를 인식 할 수 있다는 것입니다. 그리고 자신의 정규식을 롤링 할 수 있다고해도 그 이유는 무엇입니까? 이를 수행하는 더 간단한 기본 제공 방법이 있습니다.
그러나 Number()(및 isNaN()) parseFloat()은 안될 때 숫자를 반환하는 모든 경우에 대해 올바른 작업을 수행 하고 그 반대의 경우도 마찬가지입니다. 따라서 문자열이 실제로 정확히 숫자인지 확인하려면 두 함수를 모두 호출하고 둘 다 true를 반환 하는지 확인 합니다.
function isNumber(str) {
if (typeof str != "string") return false // we only process strings!
// could also coerce to string: str = ""+str
return !isNaN(str) && !isNaN(parseFloat(str))
}
isNan 함수를 사용해보십시오 .
isNaN () 함수는 값이 잘못된 숫자 (Not-a-Number)인지 확인합니다.
이 함수는 값이 NaN과 같으면 true를 반환합니다. 그렇지 않으면 false를 반환합니다.
이 함수는 Number 특정 Number.isNaN () 메서드와 다릅니다 .
전역 isNaN () 함수는 테스트 된 값을 숫자로 변환 한 다음 테스트합니다.
Number.isNan ()은 값을 숫자로 변환하지 않으며 Number 유형이 아닌 값에 대해 true를 반환하지 않습니다.
이 질문에 대한 대답에는 몇 가지 다른 사용자가 강조한 것처럼 몇 가지 결함이 있습니다. 이것은 자바 스크립트에서 접근하는 가장 쉽고 입증 된 방법 중 하나입니다.
function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
다음은 몇 가지 좋은 테스트 사례입니다.
console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 ')); // true
console.log(isNumeric('-32.2 ')); // true
console.log(isNumeric(-32.2)); // true
console.log(isNumeric(undefined)); // false
// the accepted answer fails at these tests:
console.log(isNumeric('')); // false
console.log(isNumeric(null)); // false
console.log(isNumeric([])); // false
오래된 질문이지만 주어진 답변에 몇 가지 누락 된 점이 있습니다.
과학적 표기법.
!isNaN('1e+30')이다 true사람들이 번호를 요구하는 경우 그러나 대부분의 경우, 그들은 같은 것들을 일치하지 않습니다 1e+30.
큰 부동 숫자는 이상하게 작동 할 수 있습니다.
관찰 (Node.js 사용) :
> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>
반면에 :
> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>
따라서 예상하는 경우 String(Number(s)) === s문자열을 최대 15 자리로 제한하는 것이 좋습니다 (앞의 0을 생략 한 후).
무한대
> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>
모든 것을 감안할 때 주어진 문자열이 다음을 모두 충족하는 숫자인지 확인합니다.
- 비 과학적 표기법
- 예측에 변환
Number하고 다시String - 한정된
그렇게 쉬운 일이 아닙니다. 다음은 간단한 버전입니다.
function isNonScientificNumberString(o) {
if (!o || typeof o !== 'string') {
// Should not be given anything but strings.
return false;
}
return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
}
그러나 이것조차도 완전하지 않습니다. 선행 0은 여기서 처리되지 않지만 길이 테스트를 망칩니다.
나는 테스트했고 Michael의 솔루션이 가장 좋습니다. 위의 답변에 투표하십시오 (이 페이지에서 "당신이 정말로 그 문자열을 확인하고 싶다면"를 검색하십시오). 본질적으로 그의 대답은 다음과 같습니다.
function isNumeric(num){
num = "" + num; //coerce num to be a string
return !isNaN(num) && !isNaN(parseFloat(num));
}
여기에 문서화 한 모든 테스트 케이스에서 작동합니다 : https://jsfiddle.net/wggehvp9/5/
다른 많은 솔루션은 '', null, "", true 및 []와 같은 경우에 실패합니다. 이론적으로는 다음과 같이 적절한 오류 처리와 함께 사용할 수 있습니다.
return !isNaN(num);
또는
return (+num === +num);
/ \ s /, null, "", true, false, [] (및 기타?)에 대한 특수 처리
생성자에 인수를 전달할 때 Number 의 결과를 사용할 수 있습니다 .
인수 (문자열)를 숫자로 변환 할 수없는 경우 NaN을 반환하므로 제공된 문자열이 유효한 숫자인지 여부를 확인할 수 있습니다.
참고 : 빈 문자열을 전달할 때 또는 '\t\t'and '\n\t'as Number는 0을 반환합니다. true를 전달하면 1이 반환되고 false가 0을 반환합니다.
Number('34.00') // 34
Number('-34') // -34
Number('123e5') // 12300000
Number('123e-5') // 0.00123
Number('999999999999') // 999999999999
Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
Number('0xFF') // 255
Number('Infinity') // Infinity
Number('34px') // NaN
Number('xyz') // NaN
Number('true') // NaN
Number('false') // NaN
// cavets
Number(' ') // 0
Number('\t\t') // 0
Number('\n\t') // 0
아마 평소보다 훨씬 더 엄격한 검사가 필요한이 질문을 접하는 한두 사람이있을 것입니다. 이 경우 유용 할 수 있습니다.
if(str === String(Number(str))) {
// it's a "perfectly formatted" number
}
조심하세요! 이 같은 문자열을 거부합니다 .1, 40.000, 080, 00.1. 매우 까다 롭습니다 .이 테스트를 통과 하려면 문자열 이 숫자 의 " 가장 최소한의 완벽한 형태 " 와 일치해야합니다 .
String및 Number생성자를 사용하여 문자열을 숫자로 캐스트했다가 다시 되돌 리므로 JavaScript 엔진의 "완벽한 최소 형식"(초기 Number생성자 로 변환 된 형식 )이 원래 문자열과 일치 하는지 확인 합니다.
parseInt (), 그러나이 함수는 예를 들어 parseInt ( "100px")에 대해 100을 반환한다는 점에서 약간 다릅니다.
jQuery의 구현이 충분하지 않은 이유는 무엇입니까?
function isNumeric(a) {
var b = a && a.toString();
return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};
Michael은 다음과 같은 것을 제안했습니다 (여기서 "user1691651-John"의 변경된 버전을 훔 쳤지 만).
function isNumeric(num){
num = "" + num; //coerce num to be a string
return !isNaN(num) && !isNaN(parseFloat(num));
}
다음은 성능이 좋지 않을 가능성이 가장 높지만 확실한 결과를 제공하는 솔루션입니다. 그것은 jQuery 1.12.4 구현과 Michael의 대답으로 만든 장치이며 앞뒤 공백에 대한 추가 검사가 있습니다 (Michael 버전은 앞뒤 공백이있는 숫자에 대해 true를 반환하기 때문입니다).
function isNumeric(a) {
var str = a + "";
var b = a && a.toString();
return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
!/^\s+|\s+$/g.test(str) &&
!isNaN(str) && !isNaN(parseFloat(str));
};
하지만 후자의 버전에는 두 가지 새로운 변수가 있습니다. 다음을 수행하여 이들 중 하나를 해결할 수 있습니다.
function isNumeric(a) {
if ($.isArray(a)) return false;
var b = a && a.toString();
a = a + "";
return b - parseFloat(b) + 1 >= 0 &&
!/^\s+|\s+$/g.test(a) &&
!isNaN(a) && !isNaN(parseFloat(a));
};
나는 이것들 중 어느 것도 테스트하지 않았는데, 다른 방법으로는 내가 현재의 곤경에 맞닥 뜨리게 될 몇 가지 사용 사례를 수동으로 테스트하는 것 외에는 매우 표준적인 것들이다. 이것은 "거인의 어깨에 서있는"상황입니다.
음, 제가 만든 이걸 사용하고 있어요 ...
지금까지 작동하고 있습니다.
function checkNumber(value) {
if ( value % 1 == 0 )
return true;
else
return false;
}
문제가 있으면 알려주세요.
인용문:
isNaN (num) // 변수에 유효한 숫자가 없으면 true를 반환합니다.
앞 / 뒤 공백을 확인해야하는 경우에는 전적으로 사실이 아닙니다. 예를 들어 특정 숫자의 숫자가 필요하고 PIN에 대해 '111'또는 '111'이 아닌 '1111'을 가져와야하는 경우 입력.
사용하기 더 좋음 :
var num = /^\d+$/.test(num)
누군가가이 정도까지 내려 가면 moment.js ( https://github.com/moment/moment ) 를 패치하기 위해 이것을 해킹하는 데 시간을 보냈습니다 . 여기에서 내가 빼낸 것이 있습니다.
function isNumeric(val) {
var _val = +val;
return (val !== val + 1) //infinity check
&& (_val === +val) //Cute coercion check
&& (typeof val !== 'object') //Array/object check
}
다음과 같은 경우를 처리합니다.
진실! :
isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))
그릇된! :
isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))
아이러니하게도 내가 가장 고생하는 것은 :
isNumeric(new Number(1)) => false
모든 제안을 환영합니다. :]
TypeScript에는 다음과 같이 유효하지 않습니다.
declare function isNaN(number: number): boolean;
TypeScript의 경우 다음을 사용할 수 있습니다.
/^\d+$/.test(key)
PFB 작업 솔루션 :
function(check){
check = check + "";
var isNumber = check.trim().length>0? !isNaN(check):false;
return isNumber;
}
"내장 된"솔루션을 찾는 데 따르는 골칫거리를 피하십시오.
좋은 답변이 없으며이 스레드의 엄청나게 찬성 된 답변이 잘못되었습니다.
npm install is-number
JavaScript에서 값이 숫자인지 확실하게 확인하는 것이 항상 간단하지는 않습니다. 개발자가 +,-또는 Number ()를 사용하여 문자열 값을 숫자로 변환하는 것이 일반적입니다 (예 : 사용자 입력, 정규식 일치, 파서 등에서 값이 반환되는 경우). 그러나 예상치 못한 결과를 초래하는 직관적이지 않은 경우가 많이 있습니다.
console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+' '); //=> 0
console.log(typeof NaN); //=> 'number'
일반 JavaScript 사용 :
Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true
Lodash 사용 :
_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true
function isNumberCandidate(s) {
const str = (''+ s).trim();
if (str.length === 0) return false;
return !isNaN(+str);
}
console.log(isNumberCandidate('1')); // true
console.log(isNumberCandidate('a')); // false
console.log(isNumberCandidate('000')); // true
console.log(isNumberCandidate('1a')); // false
console.log(isNumberCandidate('1e')); // false
console.log(isNumberCandidate('1e-1')); // true
console.log(isNumberCandidate('123.3')); // true
console.log(isNumberCandidate('')); // false
console.log(isNumberCandidate(' ')); // false
console.log(isNumberCandidate(1)); // true
console.log(isNumberCandidate(0)); // true
console.log(isNumberCandidate(NaN)); // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null)); // false
console.log(isNumberCandidate(-1)); // true
console.log(isNumberCandidate('-1')); // true
console.log(isNumberCandidate('-1.2')); // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity)); // true
console.log(isNumberCandidate(-Infinity)); // true
console.log(isNumberCandidate('Infinity')); // true
if (isNumberCandidate(s)) {
// use +s as a number
+s ...
}
약간 혼란스러운 시도, Pherhaps는 최선의 해결책이 아닙니다.
function isInt(a){
return a === ""+~~a
}
console.log(isInt('abcd')); // false
console.log(isInt('123a')); // false
console.log(isInt('1')); // true
console.log(isInt('0')); // true
console.log(isInt('-0')); // false
console.log(isInt('01')); // false
console.log(isInt('10')); // true
console.log(isInt('-1234567890')); // true
console.log(isInt(1234)); // true
console.log(isInt('123.4')); // false
console.log(isInt('')); // false
// other types then string returns false
console.log(isInt(5)); // false
console.log(isInt(undefined)); // false
console.log(isInt(null)); // false
console.log(isInt('0x1')); // false
console.log(isInt(Infinity)); // false
나는 이것의 단순함을 좋아한다.
Number.isNaN(Number(value))
위의 내용은 일반 Javascript이지만 스마트 유형 검사를 위해 typescript typeguard 와 함께 사용 하고 있습니다. 이것은 typescript 컴파일러가 올바른 지능을 제공하고 유형 오류를 제공하지 않는 데 매우 유용합니다.
Typescript typeguards
isNotNumber(value: string | number): value is string {
return Number.isNaN(Number(this.smartImageWidth));
}
isNumber(value: string | number): value is number {
return Number.isNaN(Number(this.smartImageWidth)) === false;
}
인 속성 width이 있다고 가정 해 보겠습니다 number | string. 문자열인지 여부에 따라 논리를 수행 할 수 있습니다.
var width: number|string;
width = "100vw";
if (isNotNumber(width))
{
// the compiler knows that width here must be a string
if (width.endsWith('vw'))
{
// we have a 'width' such as 100vw
}
}
else
{
// the compiler is smart and knows width here must be number
var doubleWidth = width * 2;
}
typeguard는 문 width내에서 유형을 ifONLY 로 제한 할만큼 똑똑 string합니다. 이것은 컴파일러가 width.endsWith(...)타입이 string | number.
당신은 당신이 원하는 무엇이든 typeguard를 호출 할 수 있습니다 isNotNumber, isNumber, isString, isNotString하지만 난 생각 isString종류의 모호한과 열심히 읽는 것입니다.
내 응용 프로그램에서는 az AZ 및 0-9 문자 만 허용합니다. 문자열이 0xnn (예 : 0x10)으로 시작하지 않는 한 " string % 1 === 0"을 사용하여 위의 답변 을 찾았고 원하지 않을 때 숫자로 반환합니다. 내 숫자 확인에서 다음과 같은 간단한 트랩이 특정 경우에 트릭을 수행하는 것 같습니다.
function isStringNumeric(str_input){
//concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up
//very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine
return '1'.concat(str_input) % 1 === 0;}
경고 : 이것은 Javascript 및 Actionscript [Number ( "1"+ the_string) % 1 === 0)]의 오랜 버그를 악용 할 수 있습니다. 이에 대해 말할 수는 없지만 정확히 우리가 필요로하는 것입니다.
내 솔루션 :
// returns true for positive ints;
// no scientific notation, hexadecimals or floating point dots
var isPositiveInt = function(str) {
var result = true, chr;
for (var i = 0, n = str.length; i < n; i++) {
chr = str.charAt(i);
if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
result = false;
break;
};
if (i == 0 && (chr == "0" || chr == ",")) { //should not start with 0 or ,
result = false;
break;
};
};
return result;
};
특정 요구에 맞게 루프 내부에 추가 조건을 추가 할 수 있습니다.
흐름 라이브러리 y 와 같은 유형을 사용하여 정적 컴파일 시간 검사를 얻을 수 있습니다. 물론 사용자 입력에는별로 유용하지 않습니다.
// @flow
function acceptsNumber(value: number) {
// ...
}
acceptsNumber(42); // Works!
acceptsNumber(3.14); // Works!
acceptsNumber(NaN); // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo"); // Error!
다음 sNum은이 유효한 숫자 값 인지 확인하는 한 줄 입니다. 다양한 입력에 대해 테스트되었습니다.
!isNaN(+s.replace(/\s|\$/g, '')); // returns True if numeric value
나는 최근에 변수를 확인하는 방법에 대한 기사가 유효한 숫자 쓴 : https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md 기사는 방법에 대해 설명, 부동 소수점 또는 정수를 보장하기 위해 그의 경우 중요 ( +xvs ~~x).
이 기사에서는 변수가 a string또는 a number로 시작하고 trim사용 가능 / 폴리 필되었다고 가정합니다. 다른 유형을 처리하기 위해 확장하는 것도 어렵지 않습니다. 그 고기는 다음과 같습니다.
// Check for a valid float
if (x == null
|| ("" + x).trim() === ""
|| isNaN(+x)) {
return false; // not a float
}
// Check for a valid integer
if (x == null
|| ("" + x).trim() === ""
|| ~~x !== +x) {
return false; // not an integer
}
그냥 사용 isNaN()하면 문자열을 숫자 로 변환하고 유효한 숫자를 얻으면 반환됩니다 false...
isNaN("Alireza"); //return true
isNaN("123"); //return false
다음을 사용하고 있습니다.
const isNumber = s => !isNaN(+s)
다음은 isNumber 구현의 고성능 (2.5 * 10 ^ 7 반복 / 초 @ 3.8GHz Haswell) 버전입니다. 내가 찾을 수있는 모든 테스트 케이스 (심볼 포함)에서 작동합니다.
var isNumber = (function () {
var isIntegerTest = /^\d+$/;
var isDigitArray = [!0, !0, !0, !0, !0, !0, !0, !0, !0, !0];
function hasLeading0s (s) {
return !(typeof s !== 'string' ||
s.length < 2 ||
s[0] !== '0' ||
!isDigitArray[s[1]] ||
isIntegerTest.test(s));
}
var isWhiteSpaceTest = /\s/;
return function isNumber (s) {
var t = typeof s;
var n;
if (t === 'number') {
return (s <= 0) || (s > 0);
} else if (t === 'string') {
n = +s;
return !((!(n <= 0) && !(n > 0)) || n === '0' || hasLeading0s(s) || !(n !== 0 || !(s === '' || isWhiteSpaceTest.test(s))));
} else if (t === 'object') {
return !(!(s instanceof Number) || ((n = +s), !(n <= 0) && !(n > 0)));
}
return false;
};
})();
'Program Tip' 카테고리의 다른 글
| AngularJS에서 범위 프로토 타입 / 프로토 타입 상속의 뉘앙스는 무엇입니까? (0) | 2020.09.27 |
|---|---|
| 클러스터형 및 비 클러스터형 인덱스는 실제로 무엇을 의미합니까? (0) | 2020.09.27 |
| Python에 디렉토리가 있는지 확인하는 방법 (0) | 2020.09.27 |
| 필드와 속성의 차이점은 무엇입니까? (0) | 2020.09.27 |
| 공백을 제거하려면 어떻게합니까? (0) | 2020.09.27 |