TypeScript学习【二】

9 TypeScript 函数

1. 函数定义：function name（参数）{//函数体}
2. 调用函数：name（）
3. 返回值：
   function name（参数）：期望的返回值类型{//函数体 return 返回值}
4. 参数

   function func_name( param1 [:datatype], param2 [:datatype]){   
   
   //函数体
   }
   function add(x: number, y: number): number {
   return x + y;
   }
   console.log(add(1,2))
   

5. 可选参数和默认参数【可选参数必须跟在必需参数后面】

   function buildName(firstName: string, lastName?: string) {
   if (lastName)
       return firstName + " " + lastName;
   else
       return firstName;
   }
   
   let result1 = buildName("Bob");  // 正确
   let result2 = buildName("Bob", "Adams", "Sr.");  // 错误，参数太多了
   let result3 = buildName("Bob", "Adams");  // 正确
   

6. 默认参数

   function function_name(param1[:type],param2[:type] = default_value) { 
   
   }
   function calculate_discount(price:number,rate:number = 0.50) { 
   var discount = price * rate; 
   console.log("计算结果: ",discount); 
   } 
   calculate_discount(1000) 
   calculate_discount(1000,0.30)
   

7. 剩余参数：不知道要向函数传入多少个参数，使用剩余参数来定义。

function buildName(firstName: string, ...restOfName: string[]) {
    return firstName + " " + restOfName.join(" ");
}
  
let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");

function addNumbers(...nums:number[]) {  
    var i;   
    var sum:number = 0; 
    
    for(i = 0;i<nums.length;i++) { 
       sum = sum + nums[i]; 
    } 
    console.log("和为：",sum) 
 } 
 addNumbers(1,2,3) 
 addNumbers(10,10,10,10,10)

8. 匿名函数var res = function( [arguments] ) { ... }

//不带参数
var msg = function () {
    return "hello world";
};
console.log(msg());

//带参数
var res = function(a:number,b:number) { 
    return a*b;  
}; 
console.log(res(12,2))

//自调用
(function () { 
    var x = "Hello!!";   
    console.log(x)     
 })()

9. 构造函数：使用 JavaScript 内置的构造函数 Function() 来定义函数

var res = new Function ([arg1[, arg2[, ...argN]],] functionBody)
//eg
var myFunction = new Function("a", "b", "return a * b"); 
var x = myFunction(4, 3); 
console.log(x);

10. 递归函数

function factorial(number) {
    if (number <= 0) {         // 停止执行
        return 1; 
    } else {     
        return (number * factorial(number - 1));     // 调用自身
    } 
}; 
console.log(factorial(6));      // 输出 720

11. Lambda 函数( [param1, parma2,…param n] )=>statement;

var foo = (x:number)=>10 + x 
console.log(foo(100))      //输出结果为 110

//javascript
var foo = function (x) { return 10 + x; };
console.log(foo(100)); //输出结果为 110

12. 函数重载：方法名字相同，而参数不同，返回类型可以相同也可以不同
    每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

参数类型不同：
参数数量不同：
参数类型顺序不同：

function disp(s1:string):void; 
function disp(n1:number,s1:string):void; 
 
function disp(x:any,y?:any):void { 
    console.log(x); 
    console.log(y); 
} 
disp("abc") 
disp(1,"xyz");

10 TypeScript Number

Number 对象是原始数值的包装对象var num = new Number(value);
如果一个参数值不能转换为一个数字将返回 NaN

Number 对象属性

MAX_VALUE：可表示的最大的数，MAX_VALUE 属性值接近于 1.79E+308。大于 MAX_VALUE 的值代表 “Infinity”。
MIN_VALUE：最大的负数是 -MIN_VALUE，MIN_VALUE 的值约为 5e-324。小于 MIN_VALUE (“underflow values”) 的值将会转换为 0。
NaN ：非数字值（Not-A-Number）

var month = 0 
if( month<=0 || month >12) { 
    month = Number.NaN 
    console.log("月份是："+ month) 
} else { 
    console.log("输入月份数值正确。") 
}

NEGATIVE_INFINITY：负无穷大，溢出时返回该值。
POSITIVE_INFINITY：正无穷大，溢出时返回该值。
prototype ：Number 对象的静态属性。使您有能力向对象添加属性和方法。

function employee(id:number,name:string) { 
    this.id = id 
    this.name = name 
} 
 
var emp = new employee(123,"admin") 
employee.prototype.email = "admin@runoob.com" 
 
console.log("员工号: "+emp.id) 
console.log("员工姓名: "+emp.name) 
console.log("员工邮箱: "+emp.email)

constructor ：返回对创建此对象的 Number 函数的引用。

Number 对象方法

//把对象的值转换为指数计数法：toExponential() 
var num1 = 1225.30 
var val = num1.toExponential(); 
console.log(val) // 输出： 1.2253e+3

//toFixed()：把数字转换为字符串，并对小数点指定位数。
var num3 = 177.234 
console.log("num3.toFixed() 为 "+num3.toFixed())    // 输出：177
console.log("num3.toFixed(2) 为 "+num3.toFixed(2))  // 输出：177.23
console.log("num3.toFixed(6) 为 "+num3.toFixed(6))  // 输出：177.234000

//toLocaleString()：把数字转换为字符串，使用本地数字格式顺序。
var num = new Number(177.1234); 
console.log( num.toLocaleString());  // 输出：177.1234

//toPrecision()：把数字格式化为指定的长度
var num = new Number(7.123456); 
console.log(num.toPrecision());  // 输出：7.123456 
console.log(num.toPrecision(1)); // 输出：7
console.log(num.toPrecision(2)); // 输出：7.1

//	toString()：把数字转换为字符串，使用指定的基数。数字的基数是 2 ~ 36 之间的整数。若省略该参数，则使用基数 10。
var num = new Number(10); 
console.log(num.toString());  // 输出10进制：10
console.log(num.toString(2)); // 输出2进制：1010
console.log(num.toString(8)); // 输出8进制：12

//valueOf()：返回一个 Number 对象的原始数字值。
var num = new Number(10); 
console.log(num.valueOf()); // 输出：10

toLocaleString() 与 toString() 的区别：

1.toLocaleString()，当数字是四位数及以上时，从右往左数，每三位用分号隔开，并且小数点后只保留三位；而toString()单纯将数字转换为字符串。

2.toLocaleString()，当目标是标准时间格式时，输出简洁年月日，时分秒；而toString()输出国际表述字符串。

var num = new Number(1777.123488); 
console.log(num.toLocaleString());  // 输出：1,777.123
console.log(num.toString());  // 输出：1777.123488

var dateStr = new Date();
console.log(dateStr.toLocaleString());  // 输出：2022/2/15 16:48:35
console.log(dateStr.toString());  // 输出：Tue Feb 15 2022 16:48:58 GMT+0800 (中国标准时间)

11. TypeScript String（字符串）

语法

var txt = new String("string");
或者更简单方式：
var txt = "string";

对象属性

constructor：对创建该对象的函数的引用。

var str = new String( "This is string" ); 
console.log("str.constructor is:" + str.constructor)
//str.constructor is:function String() { [native code] }

length：返回字符串的长度。
prototype：允许您向对象添加属性和方法。

方法

charAt(序号)：返回在指定位置的字符。
charCodeAt(序号)：返回在指定的位置的字符的 Unicode 编码。
concat()：连接两个或更多字符串，并返回新的字符串。

var str1 = new String( "RUNOOB" ); 
var str2 = new String( "GOOGLE" ); 
var str3 = str1.concat( str2 ); 
console.log("str1 + str2 : "+str3) // RUNOOBGOOGLE

indexOf()：返回某个指定的字符串值在字符串中首次出现的位置

var str1 = new String( "RUNOOB" ); 

var index = str1.indexOf( "OO" ); 
console.log("查找的字符串位置 :" + index );  // 3

lastIndexOf()：从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置

var str1 = new String( "This is string one and again string" ); 
var index = str1.lastIndexOf( "string" );
console.log("lastIndexOf 查找到的最后字符串位置 :" + index ); // 29
    
index = str1.lastIndexOf( "one" ); 
console.log("lastIndexOf 查找到的最后字符串位置 :" + index ); // 15

localeCompare()：用本地特定的顺序来比较两个字符串

var str1 = new String( "This is beautiful string" );
  
var index = str1.localeCompare( "This is beautiful string");  

console.log("localeCompare first :" + index );  // 0

match()：查找找到一个或多个正则表达式的匹配

var str="The rain in SPAIN stays mainly in the plain"; 
var n=str.match(/ain/g);  // ain,ain,ain

replace()：替换与正则表达式匹配的子串

var re = /(\w+)\s(\w+)/; 
var str = "zara ali"; 
var newstr = str.replace(re, "$2, $1"); 
console.log(newstr); // ali, zara

search()：检索与正则表达式相匹配的值

var re = /apples/gi; 
var str = "Apples are round, and apples are juicy.";
if (str.search(re) == -1 ) { 
   console.log("Does not contain Apples" ); 
} else { 
   console.log("Contains Apples" ); 
}

slice()：提取字符串的片断，并在新的字符串中返回被提取的部分。

split()：把字符串分割为子字符串数组

var str = "Apples are round, and apples are juicy."; 
var splitted = str.split(" ", 3); 
console.log(splitted)  // [ 'Apples', 'are', 'round,' ]

substr()：从起始索引号提取字符串中指定数目的字符。
substring()：提取字符串中两个指定的索引号之间的字符

var str = "RUNOOB GOOGLE TAOBAO FACEBOOK"; 
console.log("(1,2): "    + str.substring(1,2));   // U
console.log("(0,10): "   + str.substring(0, 10)); // RUNOOB GOO
console.log("(5): "      + str.substring(5));     // B GOOGLE TAOBAO FACEBOOK

toLocaleLowerCase()：根据主机的语言环境把字符串转换为小写，只有几种语言（如土耳其语）具有地方特有的大小写映射。
toLocaleUpperCase()：据主机的语言环境把字符串转换为大写，只有几种语言（如土耳其语）具有地方特有的大小写映射。
toLowerCase()：把字符串转换为小写。
toString()：返回字符串。
toUpperCase()：把字符串转换为大写
valueOf()：返回指定字符串对象的原始值。