精华内容
下载资源
问答
  • 运算符

    2019-12-19 03:45:23
    1. 运算符分类 算术运算符 比较运算符 逻辑运算符 赋值运算符运算符 三元运算符 2. 算术运算符 (1) 除+有字符串拼接外, 其余都是正常运算; 其余如果出现非数字,会先转换成数字再做运算 (2) NaN参与任何运算...

    2. 算术运算符

    (1) 除+有字符串拼接外, 其余都是正常运算
    (2) NaN参与的任何运算结果都为NaN
    (3) + 两侧出现引用值就是字符串拼接
    (4) 字符串拼接优先

    console.log(null + typeof undefined);  
    // null + 'undefined' = 'nullundefined'
    
    3. 比较运算符

    比较运算符返回布尔值

    >  	大于
    <  	小于
    == 	等于 (会进行隐式类型转换)
    >= 	大于等于
    <= 	小于等于
    != 	不等于
    === 全等 (不会进行隐式类型转换)
    
    !== 不全等
    

    引用数据类型地址不同
    在这里插入图片描述
    字符串比较的是ascll码值

    isNaN(NaN) // true

    4. 逻辑运算符

    布尔操作符:
    a&&b 如果a的结果为真,返回b
    a || b 如果a的结果为假,返回b

    优先级: 非 > 与 > 或
    ! && ||

    // 优先级: 非 与 或
    var a = true || false && !true || false
    // a = true || false && false || false
    // a = true || false || false
    
    console.log(a); // true
    
    5. 赋值运算

    赋值运算符是先计算右边,然后把值赋值给左边

    =
    +=
    -=
    *=
    /=
    ++
    --
    
    6. 三元运算符

    条件 ? val1 : val2

    if-else的另一种表达方式

    表达式的值,要看条件是true还是false。如果条件是true,那么表达式的值就是val1。如果条件是false,表达式的值就是val2。

    var a = 3;
    var b = a > 2 ? true : false
    var c = a > 5 ? true : false
    
    console.log(b, c); // true false
    
    7. 一元运算符

    i++ : 选运算后加1
    ++i : 先加1后运算

           var a = 1;
    
            var b = a++; // b = 1 a = 2
    
            a += ++b; // a = a + ++b  = 2 + 2  b = 2
    
            console.log(a); // 4
    
            console.log(b); // 2
    
    8. 逗号操作符

    可以在一条语句中执行多个操作

            var a = 3,
                b = 4,
                c = 5
    
    展开全文
  • 1)Nullable类型 一个Nullable类型就是基本类型加上一个“是否为null指示器”合成类型。...例如,类似String的引用类型就是可空类型,而类似Int32值类型不是可空类型。由于值类型容量只够表示适合于...

    1)Nullable类型

    一个Nullable类型就是基本类型加上一个“是否为null指示器”的合成类型。对于一个类型,如果既可以给它分配一个值,也可以给它分配null引用(表示没有任何值),我们就说这个类型是可以空的。因此,可空类型可表示一个值,或表示不存在任何值。例如,类似String的引用类型就是可空类型,而类似Int32的值类型不是可空类型。由于值类型的容量只够表示适合于该类型的值,因此它不可为空。

    有些人认为int型变量的值为0就表示空,这是不对的,0也是它的值,而并不表示空。

    看下面的代码演示:

    1 static void Main(string[] args)
     2         {
     3             //int n = null;
     4             //当直接给int类型赋值null时,编译器报错“无法将Null型转化为int型,因为它是一种不可以为null型的类型”
     5             int? oneValue = null;
     6             //定义Nullable类型和定义非Nullable类型非常相似,关键在于类型后面的修饰符“?”
     7             //int? oneValue = 10;
     8             if (oneValue.HasValue)//使用Nullable类型的HasValue属性来判定是否有值存储
     9             {
    10                 //int nNum = oneValue;
    11                 //如果尝试获取oneValue的值,编译器就会报错
    12                 Console.WriteLine(oneValue.Value);
    13             }
    14             else
    15             {
    16                 Console.WriteLine("oneValue的值为空!");
    17             }
    18         }

    2)C#的溢出检查

     当一种整型转换到另一种整型,这个过程取决于溢出检查上下文。checked关键字用于对整型算术运算和转换显式启用溢出检查,而unchecked关键字则用于取消整型算术运算和转换的溢出检查。

    ①启用溢出检查:当操作数的值在目标类型的取值范围内,则转换成功,否则将要抛出异常。

    看下面代码演示:

    1 class TypeConvert
     2     {
     3         static void Main(string[] args)
     4         {
     5             TypeConvert typeConvert = new TypeConvert();
     6             typeConvert.DoSomething();
     7         }
     8 
     9         public void DoSomething()
    10         {
    11             //MyInt的值为2147483647
    12             try
    13             {
    14                 int MyInt = int.MaxValue;
    15                 byte MyByte = checked((byte)MyInt);
    16             }
    17             catch(OverflowException)
    18             {
    19                 throw;
    20             }
    21         }
    22     }

    在代码中MyInt的最大值是2147483647,在强制转换为byte类型后,由于byte的取值范围为0-255,在这里使用了checked关键字进行了溢出检查,这里的byte型MyByte型无法容纳远大于其容量的值而抛出异常。

    ②取消溢出检查

    在类型转换的过程中不检查数据是否超过目标数据类型的最大值,意味着类型转换永远是成功的。如果源数据类型的取值范围大于目标类型的取值范围,超过的部分将会被截取掉;如果源数据的取值范围小于目标类型的,转换后将使用符号或者零填充至与目标类型的大小相等;如果等于,则直接转换成目标类型

    看实例代码如下:

     1  1 class TypeConvert
     2  2     {
     3  3         static void Main(string[] args)
     4  4         {
     5  5             TypeConvert typeConvert = new TypeConvert();
     6  6             typeConvert.DoSomething();
     7  7         }
     8  8 
     9  9         public void DoSomething()
    10 10         {
    11 11             //MyInt的值为2147483647
    12 12             try
    13 13             {
    14 14                 int MyInt = int.MaxValue;
    15 15         //byte MyByte = unchecked(byte)MyInt;
    16 16         //这样写与下面的写法一样,区别就是生命了关键字
    17 17                 byte MyByte = (byte)MyInt;
    18 18         //这里没有使用溢出检查,结果也不会抛出异常。但是转换的结果是有问题的,是byte类型的最大值255,与原始的值相差很大。
    19 19             }
    20 20             catch(OverflowException)
    21 21             {
    22 22                 throw;
    23 23             }
    24 24         }
    25 25     }

    ③typeof运算符

    typeof是一元运算符,用于返回任意一个类型的类型信息
    typeof运算符的语法如下:  Type type=typeof(类型);
    示例代码演示如下:

     1 class Program
     2     {
     3         static void Main(string[] args)
     4         {
     5             Type t = typeof(Program);
     6             Console.WriteLine("方法:");
     7 
     8             MethodInfo[] methodInfo = t.GetMethods();
     9             //返回该Type类型的所有公共方法
    10             foreach (MethodInfo mInfo in methodInfo)
    11             {
    12                 Console.WriteLine(mInfo.ToString());
    13             }
    14 
    15             Console.WriteLine("成员:");
    16             MemberInfo[] memberInfo = t.GetMembers();
    17             //返回该Type类型的所有公共成员
    18             foreach (MemberInfo mInfo in methodInfo)
    19             {
    20                 Console.WriteLine(mInfo.ToString());
    21             }
    22 
    23             Console.ReadKey();
    24         }
    25     }
    运行结果如下图:


    ④运算符的重载
    运算符重载只能应用于类或结构。要重载一个运算符,可以声明一个名为operator X的方法并实现它,如operator +和operator -,一元运算符和二元运算符都可以被重载,相应地,重载方法分别带一个或者两个参数(类或者结构类型),其语法为:
     //一元运算符的重载       
     public static 自定义类型 operator 要重载的运算符(类型)       
    //二元运算符的重载       
     public static 自定义类型 operator 要重载的运算符(类型1,类型2)

    注意:所有运算符的重载均是静态的方法,必须得用public修饰
    代码示例如下:

     1 class Program
     2     {
     3         public int Value { get;set; }
     4 
     5         static void Main(string[] args)
     6         {
     7             Program o1 = new Program();
     8             o1.Value = 10;
     9             Program o2 = new Program();
    10             o2.Value = 20;
    11 
    12             Program o3 = o1 + o2;
    13             Console.WriteLine(o3.Value);
    14             Console.ReadKey();
    15         }
    16 
    17         /// <summary>
    18         /// 这里为Program类重载了“加(+)”运算符实现了两个对象的相加的功能,运算符的重载提高了编程的便利性
    19         /// </summary>
    20         /// <param name="o1"></param>
    21         /// <param name="o2"></param>
    22         /// <returns></returns>
    23         public static Program operator +(Program o1, Program o2)
    24         {
    25             Program o = new Program();
    26             o.Value = o1.Value + o2.Value;
    27             return o;
    28         }
    29     }



    原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。

    版权声明:本文为博主原创文章,未经博主允许不得转载。

    转载于:https://www.cnblogs.com/yisuowushinian/archive/2012/10/28/4715640.html

    展开全文
  • _Excel公式教程 (2016-01-17 10:24:52)转载▼标签: excel公式教程 运算符优先级分类: Excel公式教程-原理篇不同类型运算符的计算次序为:引用运算符→算术运算符→文本运算符→比较运算符。详见下表:同一优先级按...

    _Excel公式教程

    fd37621f0a228cc62e9c13f4fceb34b0.gif

    (2016-01-17 10:24:52)

    fd37621f0a228cc62e9c13f4fceb34b0.gif

    转载

    标签: excel公式教程 运算符优先级分类: Excel公式教程-原理篇

    不同类型运算符的计算次序为:引用运算符→算术运算符→文本运算符→比较运算符。详见下表:

    ece056a3ecbe428cc2f7775a89fc834e.png

    同一优先级按从左到右的次序计算。如果要改变计算顺序,可将公式中要先计算的部分用圆括号括起来。

    1、在算术运算符中,正、负号最先计算,加、减号最后计算。连在操作数后的第一个“+”“-”作加、减号用,其余位置的作正、负号用。例如:

    =-1^2 和 =0+-1^2 都返回1。里面的“-”作负号用。

    =0-1^2 返回-1。里面的“-”作减号用。

    =0--1^2 返回-1。第一个“-”作减号用,第二个“-”作负号用。

    2、为什么60 < A1 < 75不能判断单元格A1是不是大于60且小于75?

    分析该表达式的计算过程如下:按从左到右顺序,第一步先比较60与A1的大小,返回一个逻辑值;第二步用这个逻辑值跟75比较。由于逻辑值大于数字值,所以这个式子总是返回FALSE。

    那么该式子应该怎么写?可写为AND(A1>60,A1<75)。

    同理,判断A1是不是小于30或大于80,不能写为30>A1>80,可写为OR(A1 < 30,80 < A1)。

    3、为什么(A1+5)>(B1+C1)可以简写成A1+5>B1+C1?

    因为比较运算符的计算次序最后,所以即使不加括号,该表达式也是首先分别计算大于号前后的A1+5和E1+C1,然后再比较这两个结果的大小。

    4、幂运算如果指数是分数,需要用括号括起来。

    例如,16的平方根应该写成16^(1/2),而不是16^1/2,因为“^”的运算次序先于“/”。16的平方根也可用SQRT函数,写成SQRT(16)。

    又如,8的立方根应该写成8^(1/3),而不是=8^1/3。

    b2cfb5dc3c89a3422fa02041a228e7c8.png
    展开全文
  • Java 运算符

    2020-03-02 10:23:36
    运算符的分类 赋值运算符 = : 意为 取右边的值 , 将其赋给左边的变量 , 右边的值可以为 变量 , 表达式 , 常数 , 只要能生成一个值就可以了 , 但是左边的值必须是一个明确的 , 已命名的变量 . 因为必须有一个物理空间...

    运算符的分类

    赋值运算符

    = : 意为 取右边的值 , 将其赋给左边的变量 , 右边的值可以为 变量 , 表达式 , 常数 , 只要能生成一个值就可以了 , 但是左边的值必须是一个明确的 , 已命名的变量 . 因为必须有一个物理空间来存储右边的值

    ​ 对于基本数据类型而已 , 赋值 就相当于将右值的内容复制了一份,将其传给左值 , 修改左值的内容右值内容不会发生改变

    ​ 但是对于引用类型而言 , 赋值相当于将其引用的地址传递给左值 , 这样 , 当修改左值的内容 , 右值的内容也会跟着修改

    算数运算符

    ​ +: 将运算符的左侧内容与右侧内容进行相加 , 当两侧内容中有一个是字符串类型时 , 则会将其进行字符串的拼接 , 这又是 + 运算符的第二个作用了

    ​ -: 使用运算符的左侧内容减去右侧内容 , 返回其结果 , 这时候就要求两侧内容都必须为数值型了

    ​ * : 两侧内容相乘 , 返回其结果 , 要求两侧内容都必须为数值型

    ​ / : 左侧内容除以右侧内容 , 返回其结果 , 整数除法会直接去掉结果的小数位 , 余数忽略不计

    ​ % : 左侧内容除以右侧内容 , 返回其相除的余数

    ​ ++ : 自动递增 , 其中出现在操作数前面的为前自增 , 出现在操作数后面的为后自增 , 前自增会先计算自增 , 会参与运算 , 而后自增则会先参与运算 , 后计算自增 , 如果都是单独使用 , 则没有任何区别 , 这点从以下代码中就可以看出

    int i = 10,j=10;
    int x = i++ + 10;	-- x=20 , i=11
    int y = ++j + 10;	-- y=21 , j=11
    i++;				-- 12
    ++j;				-- 12
    

    ​ – : 自动递减 , 与 ++ 原理一致 , 只不过将自增变为了 自减

    关系运算符

    生成一个 boolean 结果

    < (小于) , > (大于) , <= (小于等于) , >= (大于等于) , == (等于) , != (不等于)

    == 和 != 适合比较所有的基本数据类型 , 而其他则不适合比较 boolean 类型 , 因为 boolean 只能为 true 或 false , > < 没有任何的实际意义

    == 和 != 也适用于比较对象 , 他们比较的是对象的引用 , 如果比较对象不想比较引用 , 则可以重写并使用 equals 方法

    逻辑运算符

    && : 运算符两侧皆为 true , 结果才为 true , 否则为 false

    || : 运算符两侧有一侧为 true , 结果为 true , 否则为 false

    ! : 如果操作数为 true , 结果为 false ,反之 , 结果为 true

    | : 运算符两侧有一侧为 true , 结果为 true , 否则为 false

    & : 运算符两侧皆为 true , 结果才为 true , 否则为 false

    按位运算符

    将两侧参数转换为二进制数 , 然后根据每一位来进行比较

    & : 二进制位都为 1 则为 1 , 否则为 0

    | : 二进制位有一个为 1 则为 1 , 否则为 0

    ^ : 二进制位相同为 0 , 相异为 1
    : 对一个数进行取反 , 0变成 1 , 1 变成 0
    1&2; --0
    1|2: --3
    1^2 : --3
    ~2:	  --1 
    

    移位运算符

    << : 转换为 二进制 , 小数点左移指定位 , >> : 小数点右移指定位 , >>> : 无符号一样指定位

    三木运算符

    布尔表达是 ? 为true时 : 为 false时

    int i = new Random().nextInt(99)+1;
    System.out.println(i);
    System.out.println(i>10?i*100:i*10);
    
    展开全文
  • 基于对象和事件驱动解释性脚本语言 js组成 ECMAScript:JavaScript标准 DOM:Document Object Model 文档对象模型 BOM:Browser Object Model 浏览器对象模型 JavaScript和ECMAScript关系? 前者是后...
  • 下面分类讲述返回“值”和返回“引用不同点: 函数返回值时会产生一个临时变量作为函数返回值副本,而返回引用时不会产生值副本。 T f(); 返回一般类类型,返回类类型不能作为左值,但返回类类型...
  • 一、数据的分类 excel的数据可以分为以下5类:文本、数值、日期和时间、逻辑值和错误值。 其中:文本不参与数学运算。是一种文字信息。文本类型的数据我们也可以称之为字符串或文本字符串。 在Excel中,身份证号一般...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 515
精华内容 206
关键字:

引用运算符的分类