ටයිප්ස්ක්‍රිප්ට් හි නූලක් අංකයක් බවට පරිවර්තනය කරන්නේ කෙසේද?

අංකයක තන්තු නිරූපණයක් ලබා දී ඇති අතර, එය numberටයිප්ස්ක්‍රිප්ට් ටයිප් කිරීමට පරිවර්තනය කරන්නේ කෙසේද?

var numberString: string = "1234";
var numberValue: number = /* what should I do with `numberString`? */;

හරියටම ජාවාස්ක්‍රිප්ට් හි මෙන් , ඔබට parseIntහෝ parseFloatශ්‍රිත භාවිතා කළ හැකිය , නැතහොත් ඒකීය +ක්‍රියාකරු භාවිතා කළ හැකිය :

var x = "32";
var y: number = +x;

සඳහන් කළ සියලුම ශිල්පීය ක්‍රම නිවැරදි ටයිප් කිරීමක් ඇති අතර සරල දශම සංඛ්‍යා සංඛ්‍යා නිවැරදිව විග්‍රහ කරනු ඇත "123", නමුත් වෙනත්, සමහර විට අපේක්ෂිත, අවස්ථා (වැනි "123.45") සහ කෙළවරේ (වැනි null) සඳහා වෙනස් ලෙස හැසිරෙනු ඇත .

මෙම පිළිතුරෙන් ගත් වගුව

මෙය කිරීමට යතුරු ලියනය කිරීමේ ක්‍රමය වනුයේ:

Number('1234') // 1234
Number('9BX9') // NaN

මෙහි පිළිතුරු දී ඇති පරිදි: https://stackoverflow.com/a/23440948/2083492

අපගේ සෙසු කෝණික පරිශීලකයින් සඳහා:

තුළ සැකිල්ල , Number(x)හා parseInt(x)දෝෂයක් විසි කිරීම, හා +xකිසිදු බලපෑමක් ඇති කොට ඇත. වලංගු වාත්තු කිරීම x*1හෝ x/1වේ.

මෙහි වෙනත් පිළිතුරු වලින් පෙන්වා ඇති පරිදි, පරිවර්තනය කිරීමට විවිධ ක්‍රම තිබේ:

Number('123');
+'123';
parseInt('123');
parseFloat('123.45')

මම තවත් එක් දෙයක් සඳහන් කිරීමට කැමතියි parseInt.

භාවිතා කරන විට parseInt, සෑම විටම රේඩික්ස් පරාමිතිය පසු කිරීම අර්ථවත් කරයි . දශම පරිවර්තනය සඳහා, එනම් 10. පරාමිතිය සඳහා වන පෙරනිමි අගය මෙයයි, එබැවින් එය මඟ හැරිය හැක. ද්විමය සඳහා, එය a 2සහ 16ෂඩාස්රාකාර සඳහා වේ. ඇත්ත වශයෙන්ම, 2 සහ 36 අතර සහ ඇතුළුව ඕනෑම රේඩික්ස්.

parseInt('123')         // 123 (don't do this)
parseInt('123', 10)     // 123 (much better)

parseInt('1101', 2)     // 13
parseInt('0xfae3', 16)  // 64227

සමහර JS ක්‍රියාවට parseInt නැංවීමේදී ප්‍රමුඛ ශුන්‍යයන් අෂ්ටක ලෙස විග්‍රහ කරයි :

ECMAScript 3 විසින් අධෛර්යමත් කර ඇති අතර ECMAScript 5 විසින් තහනම් කර ඇතත්, බොහෝ ක්‍රියාත්මක කිරීම් සංඛ්‍යාත්මක නූලක් ප්‍රමුඛ 0 සිට ආරම්භ වන අෂ්ටක ලෙස අර්ථ නිරූපණය කරයි. පහත දැක්වෙන දේට අෂ්ටක ප්‍රති result ලයක් තිබිය හැකිය, නැතහොත් එය දශම ප්‍රති .ලයක් තිබිය හැකිය. මෙම විශ්වාස කළ නොහැකි හැසිරීම වළක්වා ගැනීමට සෑම විටම රේඩික්ස් එකක් සඳහන් කරන්න.

- එම්.ඩී.එන්

කේතය වඩාත් පැහැදිලි වන කාරණය රැඩික්ස් පරාමිතිය නියම කිරීමේ හොඳ අතුරු ආබාධයකි.

parseFloatරේඩික්ස් 10 හි සංඛ්‍යාත්මක ප්‍රකාශන පමණක් විග්‍රහ කරන බැවින් මෙහි රේඩික්ස් පරාමිතියක් අවශ්‍ය නොවේ.

මේ පිළිබඳ වැඩි විස්තර:

• අපි රේඩික්ස් භාවිතා කළ යුත්තේ ඇයි? (SO ප්‍රශ්නය)
• SO පිළිතුර "parseInt () සහ අංකය () අතර වෙනස කුමක්ද?"

රයන් පැවසූ දේ පැහැදිලි කරමින්, ටයිප්ස්ක්‍රිප්ට් පොදුවේ ජාවාස්ක්‍රිප්ට් මෝඩයන් වැලඳ ගනී.

var n = +"1"; // the unary + converts to number
var b = !!"2"; // the !! converts truthy to true, and falsy to false
var s = ""+3; // the ""+ converts to string via toString()

ජාවාස්ක්‍රිප්ට් වර්ගයේ පරිවර්තනයේ ඇති සියලුම රසවත් විස්තර .

ඔබට පහත සඳහන් ක්‍රමවලින් එකක් හෝ අනුගමනය කළ හැකිය.

var str = '54';

var num = +str; //easy way by using + operator
var num = parseInt(str); //by using the parseInt operation 

අංක පරිවර්තනයට නූල්:

යතුරු ලියනයෙහි අපි පහත දැක්වෙන ආකාරයෙන් නූලක් අංකයක් බවට පරිවර්තනය කරමු:

• ParseInt(): මෙම ශ්‍රිතයට තර්ක 2 ක් ගතවේ, පළමුවැන්න විග්‍රහ කිරීමට නූලකි. දෙවැන්න රේඩික්ස් ය (ගණිතමය සංඛ්‍යා පද්ධතිවල පදනම, උදා: දශමයට 10 සහ ද්විමය සඳහා 2). ඉන්පසු එය පූර්ණ සංඛ්‍යා අංකය ලබා දෙයි, පළමු අක්‍ෂරය අංකයක් බවට පරිවර්තනය කළ නොහැකි නම්, NaNආපසු දෙනු ලැබේ.
• ParseFloat(): අපට විග්‍රහ කිරීමට අවශ්‍ය අගය තර්කයක් ලෙස ගෙන පාවෙන ලක්ෂ්‍ය අංකයක් ලබා දෙයි. අගය අංකයකට පරිවර්තනය කළ නොහැකි නම්, NaNආපසු දෙනු ලැබේ.
• + ක්‍රියාකරු: නිසි ලෙස භාවිතා කරන විට ක්‍රියාකරුට නූල් අගයක් අංකයකට බල කළ හැකිය.

උදාහරණ:

/*    parseInt   */

// note that a whole number is returned, so it will round the number
console.log(parseInt('51.023124'));

// parseInt will 'cut off' any part of the string which is not a number
console.log(parseInt('5adfe1234'));

// When the string starts with non number NaN is returned
console.log(parseInt('z123'));

console.log('--------');

/*    parseFloat   */

// parses the string into a number and keeping the precision of the number
console.log(typeof parseFloat('1.12321423'));

// parseFloat will 'cut off' any part of the string which is not a number
console.log(parseFloat('5.5abc'));

console.log('--------');

/*   + operator   */

let myString = '12345'

console.log(typeof +myString);

let myOtherString = '10ab'

// + operator will not cut off any 'non number' string part and will return NaN
console.log(+myOtherString);

භාවිතා කළ යුත්තේ කුමක්ද?

1. ParseInt()ඔබට පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කිරීමට අවශ්‍ය විට භාවිතා කරන්න . කෙසේ වෙතත්, දත්ත වර්ගය තවමත් පාවෙන බැවින් සියලු සංඛ්‍යා අගයන් ටීඑස් හි පාවෙන ලක්ෂ්‍ය අගයන් වේ . ඔබට විග්‍රහ කිරීමට අවශ්‍ය අංකයේ රේඩික්ස් නියම කිරීමට අවශ්‍ය වූ විට මෙම ක්‍රමය භාවිතා කරන්න.
2. ParseFloat()ඔබට පාවෙන ලක්ෂ්‍ය අංකයකට නූලක් විග්‍රහ කිරීමට අවශ්‍ය විට භාවිතා කරන්න .
3. පාවෙන ලක්ෂ්‍ය අංකයකට+ බල කිරීම සඳහා ඔබට නූලකට පෙර ක්‍රියාකරු භාවිතා කළ හැකිය . මෙහි ඇති වාසිය නම් වාක්‍ය ඛණ්ඩය ඉතා කෙටි වීමයි.

පහසුම ක්‍රමය වන්නේ + strVal හෝ අංකය (strVal) භාවිතා කිරීමයි

උදාහරණ:

let strVal1 = "123.5"
let strVal2 = "One"
let val1a = +strVal1
let val1b = Number(strVal1)
let val1c = parseFloat(strVal1)
let val1d = parseInt(strVal1)
let val1e = +strVal1 - parseInt(strVal1)
let val2a = +strVal2

console.log("val1a->", val1a) // 123.5
console.log("val1b->", val1b) // 123.5
console.log("val1c->", val1c) // 123.5
console.log("val1d->", val1d) // 123
console.log("val1e->", val1e) // 0.5
console.log("val2a->", val2a) // NaN

වැනි සුරකින කාර්යයන් ඇත parseInt(), parseFloat()සහ Number()Typescript දී, ඔබ එම භාවිතා කළ හැකිය.

=> Converstring ('10 .00 ') සමඟ ශ්‍රිතය අමතන්න

parseFloat (string) => එය පාවෙන, toFixed (4) => දශම ගණනකට පරිවර්තනය කිරීමට භාවිතා කළ හැකිය.

parseInt (str) => එය පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කිරීමට භාවිතා කළ හැකිය

convertstring(string){
    let number_parsed: any = parseFloat(string).toFixed(4)
    return number_parsed
}

var myNumber: number = 1200;
//convert to hexadecimal value
console.log(myNumber.toString(16)); //will return  4b0
//Other way of converting to hexadecimal
console.log(Math.abs(myNumber).toString(16)); //will return  4b0
//convert to decimal value
console.log(parseFloat(myNumber.toString()).toFixed(2)); //will return  1200.00

මාර්ගගත අංක පරිවර්තන මෙවලම

අංක පරිවර්තකය

ක්‍රම තුනක් තිබේ

 let a = + '12'; 
 let b = parseInt('12' , 10); // 10 means decimal number
 let c = Number('12');

යතුරු ලියනය අපගේ var aඊතර් වීමට යන බව දැන ගැනීමට අවශ්‍යයNumber || String

export type StringOrNumber = number | string;

export function toString (v: StringOrNumber) {
 return `${v}`;
}


export function toNumber (v: StringOrNumber) {
 return Number(v);
}

export function toggle (v: StringOrNumber) {
 return typeof v === "number" ? `${v}` : Number(v);
}

අයනික ක්‍රමලේඛන තත්වයන් තුළ දත්ත වර්ග පරිවර්තනය කිරීමට ඔබට අපහසු ගැටළුවක් ඇති බැවින් මෙම භාෂාවම අළුත් බැවින් මෙහි දත්ත අයනික වර්ග නූල් දත්ත බවට පරිවර්තනය කරන්නේ කෙසේදැයි දැන ගැනීමට පරිශීලකයාට විස්තරාත්මකව උපදෙස් දෙන්නෙමි. නිඛිලය ටයිප් කරන්න.

ජාවා, පීඑච්පී, සී, සී ++, වැනි ක්‍රමලේඛන භාෂාවලදී සියල්ලන්ටම පහසුවෙන් දත්ත ගෙන යා හැකිය, එවිට අයනික වශයෙන් අපටද දත්ත පරිවර්තනය කළ හැකිය.

this.mPosition = parseInt("");

ඔබ කතා කරන්නේ හුදෙක් වර්ග ගැන නම්, අනෙක් අය පැවසූ පරිදි, parseInt () යනාදිය නිවැරදි වර්ගය නැවත ලබා දෙනු ඇත. එසේම, කිසියම් හේතුවක් නිසා අගය අංකයක් හෝ නූලක් විය හැකි අතර ඔබට parseInt () ඇමතීමට අවශ්‍ය නොවන්නේ නම්, typeof ප්‍රකාශන ද නිවැරදි වර්ගයට දමනු ඇත:

function f(value:number|string){
  if(typeof value==='number'){
   // value : number
  }else {
   // value : string
  }
}

මෙන්න StrToNumber ශ්‍රිතයේ නවීකරණය කරන ලද අනුවාදයකි. කලින් වගේ,

1. සංඛ්‍යාත්මක අගයට ඉදිරියෙන් හෝ පිටුපසින් විකල්ප ලකුණක් දිස්වීමට එය ඉඩ දෙයි.
2. නූලෙහි හිසෙහි හෝ වලිගයේ ඇත්තේ එක් ලකුණක් පමණක් බව තහවුරු කර ගැනීම සඳහා එය චෙක්පතක් සිදු කරයි.
3. දෝෂයක් සිදුවුවහොත්, "සම්මත" පෙරනිමි අගයක් ආපසු ලබා දෙනු ලැබේ.

මෙම ප්‍රතිචාරය මගේ පෙර පෝස්ටයට වඩා ආරම්භක ප්‍රශ්නයට වඩා සුදුසු විසඳුමකි.

   static StrToNumber(val: string, defaultVal:number = 0): number
   {        
      let result:number = defaultVal;      
      if(val == null) 
         return result;            
      if(val.length == 0) 
         return result;      
      val = val.trim();
      if(val.length == 0) 
         return(result);
      let sign:number = 1;     
      //
      // . obtain sign from string, and place result in "sign" local variable. The Sign naturally defaults to positive
      //     1 for positive, -1 for negative.
      // . remove sign character from val. 
      //      Note, before the function returns, the result is multiplied by the sign local variable to reflect the sign.
      // . error check for multiple sign characters
      // . error check to make sure sign character is at the head or tail of the string
      //              
      {  
         let positiveSignIndex = val.indexOf('+');
         let negativeSignIndex = val.indexOf('-');
         let nTailIndex = val.length-1;
         //
         // make sure both negative and positive signs are not in the string
         //
         if( (positiveSignIndex != -1) && (negativeSignIndex != -1) ) 
             return result;
         //
         // handle postive sign
         //
         if (positiveSignIndex != -1)
         {
            //
            // make sure there is only one sign character
            //
            if( (positiveSignIndex != val.lastIndexOf('+')) )
             return result;     
             //
             // make sure the sign is at the head or tail
             //
             if( (positiveSignIndex > 0) && (positiveSignIndex < nTailIndex )  )
                 return result;
             //
             // remove sign from string
             //
             val = val.replace("+","").trim();                 
         }    
         //
         // handle negative sign
         //
         if (negativeSignIndex != -1)
         {
            //
            // make sure there is only one sign character
            //
            if( (negativeSignIndex != val.lastIndexOf('-')) )
             return result;     
             //
             // make sure the sign is at the head or tail
             //
             if( (negativeSignIndex > 0) && (negativeSignIndex < nTailIndex )  )
                 return result;
             //
             // remove sign from string
             //
             val = val.replace("-","").trim();  
             sign = -1;                 
         }               
         //
         // make sure text length is greater than 0
         //       
         if(val.length == 0) 
            return result;                             
      }   
      //
      // convert string to a number
      //
      var r = +(<any>val);
      if( (r != null) && (!isNaN(r)) )
      {          
         result = r*sign;         
      }
      return(result);    
   }

ඔබට සෑම විටම වාත්තු විකල්පය භාවිතා කළ හැකිය. පළමුව, ඔබ ඔබේ වස්තුව "නොදන්නා" වර්ගයට පරිවර්තනය කර එය අපේක්ෂිත වස්තු වර්ගයකට දැමිය යුතුය.

let subID:number = 0;

subID = <number><unknown> await obj_s1aSite.submissionTableFirstID.getText();