Morikiiii | 'ColdDog' Space
Morikiiii | 'ColdDog' Space
HOME
BLOG
基础语法专题（2）
9月 02 2022

运算符 相关内容 2：

| 关系运算符：

运算符 描述 实例
== 检查两个操作数的值是否相等，如果相等则条件为真。 (A == B) 不为真。
!= 检查两个操作数的值是否相等，如果不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (A > B) 不为真。
< 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (A < B) 为真。
>= 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (A >= B) 不为真。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (A <= B) 为真。

| 逻辑运算符：

运算符 描述 实例
&& 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (A && B) 为假。
II 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (A II B) 为真。
! 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(A && B) 为真。

| 三目运算符：

运算符 描述 实例
？ 条件表达式 a > b ? a : b 如果条件为真，? 返回 a，否则返回 b

课程内容 - 关系运算符：

    void Func1()
    {
        int a = 5;
        int b = 4;

        // > >= < <= == !=

        /* if ( a > b )
        {
            Debug.Log("a > b");
        }
        else if (a < b)
        {
            Debug.Log("a < b");
        }
        else
        {
            Debug.Log("a == b");
        } */

        if ( a != b )
        {
            Debug.Log("a != b");
        }
        else
        {
            Debug.Log("a == b");
        }
    }

课程内容 - 逻辑运算符：

    void Func2()
    {
        // && || !
        // && 关系表达式中 所有条件都满足，才为 true
        // || 关系表达式中 只要一个条件满足，就为 true
        // !  逻辑非运算符 就是 true 变成 false ，false 变成 true

        int a = 1;
        int b = 2;

        /* if (a != 0 && b != 0)
        {
            Debug.Log("---");
        }
        else
        {
            Debug.Log("+++");
        } */

        /* if (a > 2 || b == 2)
        {
            Debug.Log("---");
        }
        else
        {
            Debug.Log("+++");
        } */

        if (!(a > 2))
        {
            Debug.Log("---");
        }
        else
        {
            Debug.Log("+++");
        }
    }

课程内容 - 三目（元）运算符：

    void Func3()
    {
        int a = 1;
        int b = 2;

        // 条件 ? 表达式1 : 表达式2
        // 满足条件 --》 执行表达式1，否则执行表达式2

        int c = a > b ? 100 : 1000;
        Debug.Log(c);
    }

运算符 相关内容 3：

| 位运算符：

下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符 描述 实例
& 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 (A & B) 将得到 12，即为 0000 1100
| 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 (A | B) 将得到 61，即为 0011 1101
^ 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 (A ^ B) 将得到 49，即为 0011 0001
~ 按位取反运算符是一元运算符，具有”翻转”位效果，即0变成1，1变成0，包括符号位。 (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<< 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 A << 2 将得到 240，即为 1111 0000
>> 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 A >> 2 将得到 15，即为 0000 1111

课程内容：

    void Func1()
    {
        // & 相同位都为 1，才为 1，否则为 0
        // | 相同位只要有一个为 1，那就为 1，否则为 0
        // ^ 相同位标志位一致的话，则为 0，否则为 1
        // ~ 对每一位进行取反 0--》1；1--》0  同时运算符的符号 需要取反

        int a = 60; // 0011 1100
        int b = 13; // 0000 1101

        //  c          0000 1100
        //  d          0011 1101
        //  e          0011 0001
        //  f          1100 0011

        int c = a & b;
        Debug.Log("c:" + c);

        int d = a | b;
        Debug.Log("d:" + d);

        int e = a ^ b;
        Debug.Log("e:" + e);

        int f = ~a;
        Debug.Log("f:" + f);
    }

逻辑判断语句 相关内容：

| 分为两类：

  1. if(){}else{} ：条件检测的方式是 线性判断，只要满足前者条件，那后续条件就检测直接跳过

  2. switch(xxx){ case:{}break; default:{}break; } ：后面一定要跟着 break；

| 一些知识点：

  1. Start ：Unity 初始运行时 只被执行一次 ，即在第一帧被调用

  2. Update ：Unity运行时，会被实时调用，即在每一帧被调用，且渲染帧不固定

  3. 变量：

    1. 局部变量 - 作用域 限于本函数内临近的{…}

    2. 类的成员变量 - 作用域 类内的任何地方，都可以访问到这个变量

    3. public 可以在监视面板使用成员变量

| 制定行为：

  1. 起床

  2. 洗漱

  3. 吃饭

  4. 找小姐姐

  5. …Unknow：不知道

课程内容 - if：

    public int value;

    void Update()
    {
        Func1();
    }

    void Func1()
    {
        /* if (value > 5)
        {
            Debug.Log("value > 5");
        }
        else if(value > 10)
        {
            Debug.Log("value > 10");
        } */

        if (value == 1)
        {
            Debug.Log("1.起床");
        }
        else if (value == 2)
        {
            Debug.Log("2.洗漱");
        }
        else if (value == 3)
        {
            Debug.Log("3.吃饭");
        }
        else if (value == 4)
        {
            Debug.Log("4.找小姐姐");
        }
        else
        {
            Debug.Log("...不到呀");
        } 

        /* if (value == 1)  // 单句可以不加括号
            Debug.Log("1.起床"); 

        /*if (value == 1 ||value == 2)
        {
            Debug.Log("if满足条件");
        }*/
    }

课程内容 - switch：

    public int value;

    void Update()
    {
        Func1();
        Func2();
    }

    void Func2()
    {
        /*switch (value)
        {
            case 1:
            case 2:
                Debug.Log("switch满足条件");
                break;
        }*/

        switch (value)
        {
            case 1:
                {
                    Debug.Log("1.起床");
                }
                break;
            case 2:
                {
                    Debug.Log("2.洗漱");
                }
                break;
            case 3:
                {
                    Debug.Log("3.吃饭");
                }
                break;
            case 4:
                {
                    Debug.Log("4.找小姐姐");
                }
                break;
            default:
                {
                    Debug.Log("...不到呀");
                }
                break;
         }
    }

枚举 相关内容：

| 概念介绍：

枚举类型使用 enum 关键字声明，包含一些易读的标识符。

enum <enum_name>{enumeration list};

课程内容：

  1. Enum <-> int

  2. Enum <-> srting

  3. 使用本节课讲解的枚举，对上节课的行为做 易读性处理， 来体现 枚举的意义

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;          // 本节课新加 using

public class EnumTest : MonoBehaviour
{
    public enum emAction
    {
        None,
        GetUp,
        Wash,
        Eat,
        Play,

        /*None = 0,
        GetUp,          // 0 + 1 = 1
        Wash,           // 1 + 1 = 2
        Eat,            // 2 + 1 = 3
        Play,           // 3 + 1 = 4*/

        /*None = 10,
        GetUp,          // 10 + 1 = 11
        Wash,           // 11 + 1 = 12
        Eat,   
        Play,*/
    }

    public emAction mAction = emAction.None;

    void Start()
    {
        // Func1();
    }

    void Update()
    {
        // Func1();
        Func2();
    }

    void Func1()
    {
        // Debug.Log(mAction);
        // Debug.Log(mAction.ToString());

        // Enum <-> string
        // mAction.ToString()  Enum --> string
        // mAction = (emAction)Enum.Parse( typeof(emAction), "Wash" );          string --》 Enum
        // mAction = (emAction)Enum.Parse( typeof(emAction), "Wash111" );       没有这个 Wash111 所以会报error

        // Enum <-> int
        // int iPlay = (int)mAction;                                            Enum -> int
        // mAction = (emAction)3;                                               int  -> Enum
        // mAction = (emAction)Enum.ToObject(typeof(emAction), 1);              int -> Enum


        // Debug.Log( "Enum --》 int：" + iPlay );
        // Debug.Log("int --》 Enum：" + mAction);
        // Debug.Log( "int --》 Enum：" + mAction );

        switch (mAction)
        {
            case emAction.GetUp:
                {
                    Debug.Log("1.起床");
                }
                break;
            case emAction.Wash:
                {
                    Debug.Log("2.洗漱");
                }
                break;
            case emAction.Eat:
                {
                    Debug.Log("3.吃饭");
                }
                break;
            case emAction.Play:
                {
                    Debug.Log("4.找小姐姐");
                }
                break;
            default:
                {
                    Debug.Log("...不到呀");
                }
                break;
        } 
    }

    void Func2()
    {
        // 自练
        if (mAction == emAction.GetUp)
        {
            Debug.Log("1.起床");
        }
        else if (mAction == emAction.Wash)
        {
            Debug.Log("2.洗漱");
        }
        else if (mAction == emAction.Eat)
        {
            Debug.Log("3.吃饭");
        }
        else if (mAction == emAction.Play)
        {
            Debug.Log("4.找小姐姐");
        }
        else
        {
            Debug.Log("...不到呀");
        }
    }
}

循环语句 相关内容：

| for 循环：

for(条件表达式)
{
    循环体
}

演示：

    void Start()
    {
        // 语法问题
        // int i = 0;  定义变量
        // i < length; 检测条件
        // i ++        自增自减语句

        //  Times      i的值
        //    1          0 
        //    2          1 
        //    3          2 
        //   ...           
        for (int i = 0; i < 10; i++) // i++ == i = i+1
        {
            Debug.Log(i);
        }

        Debug.Log("----------------------------------------");

        //  Times      i的值
        //    1         10
        //    2          9
        //    3          8
        //   ...           
        for (int i = 10; i > 0; i--) // i-- == i = i-1
        {
            Debug.Log(i);
        }

        // % 取模运算符 输出一个余数
        // 通过for循环语句的形式，将 1 ~ 100 之间的能被 2 整除的数，把他们找出来
        for (int i = 1; i <= 100; i++)
        {
            if (i % 2 == 0)
            {
                Debug.Log("能被 2 整除：" + i);
            }
            else
            {
                Debug.LogWarning("不能被 2 整除：" + i);
            }
        }
    }

| while 循环：

while(条件表达式)
{
    循环体
}

演示：

        // 语法
        // while  关键字
        // (true) 检测条件

        int i = 0;
        while (i < 10)
        {
            // 循环体
            Debug.Log(i);
            i++;
        }

        /*
        int i = 10;
        while (i > 10)  // 首先会 前置检测条件是否满足，满足的话，才执行循环体，否则跳过
        {
            Debug.Log("+++");
        }
        Debug.Log("!!!");
        */

| do while 循环：

do
{
    循环体
} while(条件表达式)

演示：

        int i = 10;
        do
        {
            Debug.Log("do while +++");
        } while (i > 10);
        Debug.Log("!!!");  // 两个都会被打印出来

小作业：

// % 取模运算符，输出一个余数

// 通过 while 循环语句的形式，将 1~100 之间的能被 2 整除的数，找出来

        int i = 1;
        while (i <=100 )
        {
            i++;
            if (i % 2 ==0)
            {
                Debug.Log("能被 2 整除："+ i);
            }
        }

| 补充知识：

  1. continue 跳过

  2. break 打断

  3. ++ i 和 i ++ 的区别:

    1. ++i ： 先对 i 的值执行 i = i + 1，然后在对左侧的变量赋值。【先加后用】

    2. i++ ： 先对左侧的变量赋值，执行完该语句后，在对其进行重新赋值。【先用后加】

1、2演示：

        // 检索 1~100 之间的值
        // 如果值 = 50 跳过，但是继续执行  continue
        // 如果值 = 51 终止循环语句       break

        for (int i = 1; i <= 100; i++)
        {
            //if (i == 50)
            //    continue;
            //Debug.Log(i);

            if (i == 51)
                break;
            Debug.Log(i);
        }

3演示：

        int i = 10;
        int j = 10;

        int a = ++i; // i = i + 1 
        int b = j++; // j = j + 1 在这一行以下才会 +1

        Debug.Log("[前置++]a:" + a);// 11
        Debug.Log("[后置++]b:" + b);// 10

小作业：

        // 检索 1~100 之间的值
        // 如果值 = 50 跳过，但是继续执行  continue
        // 如果值 = 51 终止循环语句       break
        // 用 while 演示
        int i = 1;
        while (i<=100)
        {
            i++;
            /*
            if(i == 50)
            {
                continue;
            }
            Debug.Log(i);
            */
            if(i == 51)
            {
                break;
            }
            Debug.Log(i);
        }

👾 - Morikiiii - 👾

C# Study
  1. 运算符 相关内容 2：
    1. | 关系运算符：
    2. | 逻辑运算符：
    3. | 三目运算符：
  • 运算符 相关内容 3：
    1. | 位运算符：
  • 逻辑判断语句 相关内容：
    1. | 分为两类：
    2. | 一些知识点：
    3. | 制定行为：
  • 枚举 相关内容：
    1. | 概念介绍：
  • 循环语句 相关内容：
    1. | for 循环：
    2. | while 循环：
    3. | do while 循环：
    4. | 补充知识：

    • Power by Hexo Theme by White Player by Morikiiii