Ts的控制语句

别指望了
201 阅读8分钟

条件语句

  • if 语句 - 只有当指定条件为 true 时，使用该语句来执行代码
  • if...else 语句 - 当条件为 true 时执行代码，当条件为 false 时执行其他代码
  • if...else if....else 语句- 使用该语句来选择多个代码块之一来执行
  • switch 语句 - 使用该语句来选择多个代码块之一来执行

if语句

if语句的基本结构
if(){
               }
当小括号内的值为True或者1时，执行后面的代码段
let num_1 : number=456 ;
if(num_1>=425){
    console.log("恭喜你，通过了四级");
}
if(num_1<425 && num_1>=220){
    console.log(`很遗憾你没有通过四级，你的分数是${num_1}`);
}
if(num_1<220){
    console.log("你没有通过四级，请下次继续努力")
}

if_else语句

if_else语句的基本结构
if(){
          }
else{
          }
当小括号内的值为True时执行后面的代码段，当括号内的值为false执行else后的代码段
if(num_1>=425){
    console.log("恭喜你，通过了四级")
}else{
    console.log("你没有通过四级，请下次继续努力")
}

if...else if....else 语句

if(num_1>=425){
    console.log("恭喜你，通过了四级");
}else if (num_1<425 && num_1>=220){
    console.log(`很遗憾你没有通过四级，你的分数是${num_1}`);
}else if(num_1<220){
    console.log("你没有通过四级，请下次继续努力");
}

image.png

switch语句

  • switch 语句中的 expression 是一个要被比较的表达式，可以是任何类型，包括基本数据类型（如 number、string、boolean）、对象类型（如 object、Array、Map）以及自定义类型（如 class、interface、enum）等。
  • 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
  • case 的 constant-expression 必须与 switch 中的变量 expression 具有相同或兼容的数据类型。
  • 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
  • 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
  • 不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
  • 一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default 关键字则表示当表达式的值与所有 case 值都不匹配时执行的代码块。default case 中的 break 语句不是必需的。
var grade:string = "A"; 
switch(grade) { 
    case "A": { 
        console.log("优"); 
        break; 
    } 
    case "B": { 
        console.log("良"); 
        break; 
    } 
    case "C": {
        console.log("及格"); 
        break;    
    } 
    case "D": { 
        console.log("不及格"); 
        break; 
    }  
    default: { 
        console.log("非法输入"); 
        break;              
    } 
}

循环语句

for循环

  1. init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
  2. 接下来，会判断 condition。如果为 true，则执行循环主体。如果为 false，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
  3. 在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
  4. 条件再次被判断。如果为 true，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为 false 时，for 循环终止。
//for循环的主体结构
let num_2:number = 220;
for(let num_3:number=0;num_2<=425;num_3++){
    num_2=num_2+num_3*20;
    console.log(`经过一段时间的努力学习，我现在的成绩为${num_2}`)
}
console.log(`我通过了四级，我现在的成绩为${num_2}`)

image.png

for...in...循环

分为any和list两种结构

any类型
var j:any; 
var n:any = "a b c" 
for(j in n) {
    console.log(n[j])  
}
//////////////////////////////////////////////////////////////////////////////////////////
list类型
const English=['阅读理解','完形填空','听力','写作'];
for(const num_4 in English){
    console.log(`英语四级有${English[num_4]}`)

image.png

forEach方法

forEach方法用于遍历数组的每个元素，并对每个元素执行相同的操作。

let list = ['阅读理解','完形填空','听力','写作'];
list.forEach((val, idx, array) => {
    // val: 当前值
    // idx：当前index
    // array: Array
    console.log(`元素: ${val}, 索引: ${idx}, 数组: ${array}`);
});

image.png

every语句

forEach 在 iteration 中是无法返回值的，所以可以使用 every 和 some 来取代 forEach

let list = ['阅读理解','完形填空','听力','写作'];
let list_2=list.every((val, idx, array) => {
    // val: 当前值
    // idx：当前index
    // array: Array
    return val

});
console.log(list_2);

image.png

while循环

while 语句在给定条件为 true 时，重复执行语句或语句组。循环主体执行之前会先测试条件。 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句，它可用于终止 switch 语句中的一个 case。 continue 语句有点像 break 语句。但它不是强制终止，continue 会跳过当前循环中的代码，强迫开始下一次循环。

let count: number = 0;
let maxCount: number = 10;
while (count < maxCount) {
    count++;
    // 如果 count 是偶数，跳过此次循环的后续操作
    if (count % 2 === 0) {
        console.log(`现在的数字为: ${count}`);
        continue;
    }
    // 如果 count 达到 7，退出循环
    if (count === 7) {
        console.log(`数字七: ${count}`);
        break;
    }
    console.log(`${count}`);
}

image.png

do...while...语句

不像 for 和 while 循环，它们是在循环头部测试循环条件。do...while 循环是在循环的尾部检查它的条件

let maxCount: number = 10;

do {
    count++;

    // 如果 count 是偶数，跳过此次循环的后续操作
    if (count % 2 === 0) {
        console.log(`Skipping even number: ${count}`);
        continue;
    }

    // 如果 count 达到 7，退出循环
    if (count === 7) {
        console.log(`Breaking the loop at count: ${count}`);
        break;
    }

    console.log(`Current count: ${count}`);
}while(count<=maxCount)

image.png

函数

函数是一组一起执行一个任务的语句，函数最主要的三个元素就是:形参，功能，返回。 接下来我们将从这三个方面来解释

函数的定义

function test() {   // 函数定义
    console.log("调用函数") 
} 
test()              // 调用函数

首先，function是在ts中定义函数的关键字 同样仅仅一个function是无法指定返回值的类型的，所以我们下一步需要指定返回值的返回类型。

函数的返回值类型

function function_name():return_type { 
    // 语句
    return value; 
}

然后，我们大家应该都清楚return关键字是函数用来返回值用的，我们观察上面的一串代码，我们发现与之前学习的语言不同的是返回值的类型是在大括号之前被定义的。

参数

所谓的参数我理解就是程序员给机器的一些基本的语言，换句话说就是如果你现在有几个数据是对你解决问题是有用的那么你就可以把这些数值给函数体，这些数可以是一个，两个，多个，各种类型的都可以，这些数就被称为参数。

function add(x: number, y: number): number {
    return x + y;
}
console.log(add(1,2))

当然我们也可以看到参数的类型是这样定义的x: number, y: number，这里看出了与其他的语言不同的一点

可选参数

这是一个新奇的词，但本质上依旧是一个参数。 在 TypeScript 函数里，如果我们定义了参数，则我们必须传入这些参数，除非将这些参数设置为可选，可选参数使用问号标识 ？

function choice(sex: string, num: number, num_2?: number): string {
    if (sex === '男' && num >= 0 && num <= 100) {
        const str_1: string = "普通";
        console.log("你好，欢迎来到魔法世界，你的身份是普通公民");
        return str_1;
    } else if (sex === '女' && num >= 0 && num <= 100 && num_2==0) {
        const str_2: string = "特别公民";
        console.log("你好，欢迎，您的身份是魔法师");
        return str_2;
    } else {
        console.log("输入无效，请检查性别或数字范围。");
        return "无效身份";
    }
}
choice("男",25)
choice("女",25,0)

image.png

默认参数

function calculate_discount(price:number,rate:number = 0.50) { 
    var discount = price * rate; 
    console.log("计算结果: ",discount); 
} 
calculate_discount(1000) 
calculate_discount(1000,0.30)

rate:number = 0.50给number设置了一个默认值为0.50.

构造函数

在 TypeScript 中，构造函数用于创建和初始化类的对象。它是一个特殊的方法，具有与类同名，并且在使用 new 关键字实例化对象时被自动调用。 基本结构

class ClassName {
    constructor(parameters) {
        // 初始化属性
    }
}


class Person {
    name: string;
    age: number;

    // 构造函数
    constructor(name: string, age: number) {
        this.name = name;  // 初始化 name 属性
        this.age = age;    // 初始化 age 属性
    }

    // 方法
    greet(): void {
        console.log(`你好，我叫 ${this.name}，今年 ${this.age} 岁。`);
    }
}

// 使用构造函数创建实例
const person1 = new Person("张三", 25);
person1.greet(); // 输出：你好，我叫 张三，今年 25 岁。
  1. 参数：构造函数可以接受参数，这些参数可以用来初始化类的属性。
  2. this 关键字：在构造函数中，this 指向当前类的实例，可以用来访问和设置实例的属性。

Lambda 函数

重载

好的，让我们深入了解这段 TypeScript 代码的各个部分。

1. 函数重载

在 TypeScript 中，函数重载允许你为同一个函数定义多个不同的签名。这意味着你可以用不同的参数类型和数量调用同一个函数。

2. 定义重载签名

function disp(s1: string): void; 
function disp(n1: number, s1: string): void;

这里定义了两个重载签名：

  • 第一个签名表示 disp 可以接收一个字符串参数（s1），返回 void。
  • 第二个签名表示 disp 可以接收一个数字（n1）和一个字符串（s1），同样返回 void。

3. 实现函数

function disp(x: any, y?: any): void { 
    console.log(x); 
    console.log(y); 
}

这部分是 disp 函数的实际实现：

  • x: any 表示第一个参数可以是任何类型。
  • y?: any 表示第二个参数是可选的，类型同样可以是任何类型。

4. 函数逻辑

在函数体内，console.log(x) 和 console.log(y) 会打印出传入的参数。

5. 函数调用

disp("abc"); 
disp(1, "xyz");

  • 第一次调用 disp("abc")：

    • 这个调用符合第一个重载签名。
    • x 被赋值为 "abc"，y 没有传入，默认为 undefined。
    • 输出结果是： abc undefined

  • 第二次调用 disp(1, "xyz")：

    • 这个调用符合第二个重载签名。
    • x 被赋值为 1，y 被赋值为 "xyz"。
    • 输出结果是： 1 xyz

如果每个函数都有他们自己不同的函数体，可以通过选择语句来进行判断

function disp(s1: string): void; 
function disp(n1: number, s1: string): void; 
function disp(x: any, y?: any): void {
    if (typeof x === "string") {
        // 处理第一个重载
        console.log("字符串参数:", x);
    } else if (typeof x === "number" && typeof y === "string") {
        // 处理第二个重载
        console.log("数字参数:", x);
        console.log("字符串参数:", y);
    }
}

// 调用示例
disp("abc");         // 输出: 字符串参数: abc
disp(1, "xyz");     // 输出: 数字参数: 1; 字符串参数: xyz
avatar
文章
阅读
粉丝