第2关：比较和逻辑运算符
100
学习内容
参考答案
记录
评论
任务描述
相关知识
比较运算符
逻辑运算符
编程要求
测试说明
任务描述
本关任务：判断两个字符串的大小，第一个大于第二个则返回两者逻辑相与的结果，否则返回第二个逻辑取反的结果。
例如：a为字符串"d"，b为字符串"b"，因为字符串"d"大于字符串"b"，所以返回"d"逻辑与"b"，即字符串"b"。
相关知识
比较运算符
JavaScript中的比较运算符有==,===,>,<,!=,>=等。
==叫做相等，===叫做严格相等。双等号和三等号的区别是：三等号要求数据类型和值都相等，双等号只需要值相等即可，相等包含严格相等。
从比较过程来看，严格相等先比较两个对象的数据类型是否相等，不相等则结束比较，返回false，相等在数据类型不同时，尝试进行数据类型转换，例如，在字符串和数字的比较中，字符串会被转为数字再比较；布尔值true转为数字1，布尔值false转为数字0。
如果数据类型相同，相等和严格相等都会直接比较值，值相等返回true。
需要特别注意的是，以上仅仅适用于非对象类型。对于对象类型，相等或者严格相等比较的都是对象的引用，而不是具体的值，就是说，一个对象和其他任何对象都是不相等的，即使两者属性、值都相等。下面给出一些例子：
var stringVariable = "2";
var number1 = 2;
var number2 = 2;
console.log(stringVariable == number1);//true
console.log(stringVariable === number1);//false
console.log(number1 === number2);//true
var studentA = {
name:"Bob",
age:22
}
var studentB = {
name:"Bob",
age:22
}
console.log(studentA == studentB);//false，因为不是同一个对象
var studentC = studentA;
console.log(studentA == studentC);//true，因为是同一个对象
将studentA赋值给studentC，这时studentC和studentA指向内存中的同一个地址块，视为同一个对象，所以两者相等。
不等 对应于上面的等号，不等号也有两种：!=和!==。 !=和==互为相反，==成立，!=一定不成立。 !==和===互为相反，严格相等成立，则严格不相等不成立。
其它 大于，小于，大于等于，小于等于的比较规则如下： 比较的两个对象都是数字，按照数学中数字的比较方法。 数字和字符串比较，字符串转为数字后再比较。 字符串和字符串比较，从第一个字符开始，逐个比较，发现不相等立即返回。字符按照ASCII编码值的大小比较，一般只要记住：数字<大写字母<小写字母，字母a小于字母z，A小于Z， 比较过程中，当一个字符串结束另外一个字符串还有，还没有比较出大小，则长的字符串较大。
var number1 = 1;//定义变量number1
var number2 = 2;//定义变量number2
var string1 = "3";//string1
var lowerLetter = "a";//定义变量lowerLetter
var upperLetter = "A";//定义变量upperLetter
var string1 = "aa";//定义变量string1
var String2 = "ab";//定义变量String2
console.log(number1<number2);//输出true
console.log(number2<string1);//输出true
console.log(upperLetter<lowerLetter);//输出true
console.log(lowerLetter<string1);//输出false
console.log(string1<string2);//输出true
逻辑运算符
在介绍逻辑运算符之前，我们必须明确逻辑运算符的操作数只能是布尔型，其他类型都会被转换为布尔型：除了0，null，undefined，""外，其他的值转换为布尔值都是true。
逻辑与
逻辑与有两个操作数，中间用&&连接，只有两个操作数都是true结果才是true；
其中一个操作数不是布尔型，当左操作数为真值时，返回右操作数。当左操作数为假值时，返回左操作数。
逻辑或
逻辑或同样有两个操作数，用||连接，至少有一个操作数为true时结果为true；
其中一个操作数不是布尔型，当左操作数为真值时，返回左操作数。当左操作数为假值时，返回右操作数。
逻辑非
逻辑非只有一个操作数，!后连接操作数或表达式，意思是将操作数取反；
如果操作数不是布尔型，编译器首先将其他类型转换为布尔型，然后返回true或者false。
console.log(true&&false);//false
console.log(true||false);//true
console.log(!false);//true
var number1 = 1;
var number2 = 0;
var string = "a";
console.log(number1&&string);//输出字符串"a"
console.log(number1||string);//输出数字1
console.log(!number1);//false
编程要求
本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：
完成函数mainJs()；
比较字符串a和b的大小；
如果a>b，则返回a逻辑与b的结果，否则返回a逻辑取反的结果（返回时使用return）；
具体请参见后续测试样例。
比较需要用到条件表示式，如下：
//打印a和b中较大的哪一个
var a = 1,b = 2;
if(a > b) {
console.log(a);
}
else {
console.log(b);
}
本关涉及的代码文件LoginBoolSymbol.js的代码框架如下：
function mainJs(a,b) {
//请在此处编写代码
/********** Begin **********/
/********** End **********/
}
测试说明
测试过程：
平台将读取用户补全后的LoginBoolSymbol.js；
调用其中的mainJs()方法，输入若干组测试数据；
最后根据测试结果判断程序是否正确。
以下是测试样例：
测试输入：
b,d
预期输出：
b
测试输入：
z,zz
预期输出：
False
第2关：比较和逻辑运算符
100
学习内容
参考答案
记录
评论
任务描述
相关知识
比较运算符
逻辑运算符
编程要求
测试说明
任务描述
本关任务：判断两个字符串的大小，第一个大于第二个则返回两者逻辑相与的结果，否则返回第二个逻辑取反的结果。
例如：a为字符串"d"，b为字符串"b"，因为字符串"d"大于字符串"b"，所以返回"d"逻辑与"b"，即字符串"b"。
相关知识
比较运算符
JavaScript中的比较运算符有==,===,>,<,!=,>=等。
==叫做相等，===叫做严格相等。双等号和三等号的区别是：三等号要求数据类型和值都相等，双等号只需要值相等即可，相等包含严格相等。
从比较过程来看，严格相等先比较两个对象的数据类型是否相等，不相等则结束比较，返回false，相等在数据类型不同时，尝试进行数据类型转换，例如，在字符串和数字的比较中，字符串会被转为数字再比较；布尔值true转为数字1，布尔值false转为数字0。
如果数据类型相同，相等和严格相等都会直接比较值，值相等返回true。
需要特别注意的是，以上仅仅适用于非对象类型。对于对象类型，相等或者严格相等比较的都是对象的引用，而不是具体的值，就是说，一个对象和其他任何对象都是不相等的，即使两者属性、值都相等。下面给出一些例子：
var stringVariable = "2";
var number1 = 2;
var number2 = 2;
console.log(stringVariable == number1);//true
console.log(stringVariable === number1);//false
console.log(number1 === number2);//true
var studentA = {
name:"Bob",
age:22
}
var studentB = {
name:"Bob",
age:22
}
console.log(studentA == studentB);//false，因为不是同一个对象
var studentC = studentA;
console.log(studentA == studentC);//true，因为是同一个对象
将studentA赋值给studentC，这时studentC和studentA指向内存中的同一个地址块，视为同一个对象，所以两者相等。
不等 对应于上面的等号，不等号也有两种：!=和!==。 !=和==互为相反，==成立，!=一定不成立。 !==和===互为相反，严格相等成立，则严格不相等不成立。
其它 大于，小于，大于等于，小于等于的比较规则如下： 比较的两个对象都是数字，按照数学中数字的比较方法。 数字和字符串比较，字符串转为数字后再比较。 字符串和字符串比较，从第一个字符开始，逐个比较，发现不相等立即返回。字符按照ASCII编码值的大小比较，一般只要记住：数字<大写字母<小写字母，字母a小于字母z，A小于Z， 比较过程中，当一个字符串结束另外一个字符串还有，还没有比较出大小，则长的字符串较大。
var number1 = 1;//定义变量number1
var number2 = 2;//定义变量number2
var string1 = "3";//string1
var lowerLetter = "a";//定义变量lowerLetter
var upperLetter = "A";//定义变量upperLetter
var string1 = "aa";//定义变量string1
var String2 = "ab";//定义变量String2
console.log(number1<number2);//输出true
console.log(number2<string1);//输出true
console.log(upperLetter<lowerLetter);//输出true
console.log(lowerLetter<string1);//输出false
console.log(string1<string2);//输出true
逻辑运算符
在介绍逻辑运算符之前，我们必须明确逻辑运算符的操作数只能是布尔型，其他类型都会被转换为布尔型：除了0，null，undefined，""外，其他的值转换为布尔值都是true。
逻辑与
逻辑与有两个操作数，中间用&&连接，只有两个操作数都是true结果才是true；
其中一个操作数不是布尔型，当左操作数为真值时，返回右操作数。当左操作数为假值时，返回左操作数。
逻辑或
逻辑或同样有两个操作数，用||连接，至少有一个操作数为true时结果为true；
其中一个操作数不是布尔型，当左操作数为真值时，返回左操作数。当左操作数为假值时，返回右操作数。
逻辑非
逻辑非只有一个操作数，!后连接操作数或表达式，意思是将操作数取反；
如果操作数不是布尔型，编译器首先将其他类型转换为布尔型，然后返回true或者false。
console.log(true&&false);//false
console.log(true||false);//true
console.log(!false);//true
var number1 = 1;
var number2 = 0;
var string = "a";
console.log(number1&&string);//输出字符串"a"
console.log(number1||string);//输出数字1
console.log(!number1);//false
编程要求
本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：
完成函数mainJs()；
比较字符串a和b的大小；
如果a>b，则返回a逻辑与b的结果，否则返回a逻辑取反的结果（返回时使用return）；
具体请参见后续测试样例。
比较需要用到条件表示式，如下：
//打印a和b中较大的哪一个
var a = 1,b = 2;
if(a > b) {
console.log(a);
}
else {
console.log(b);
}
本关涉及的代码文件LoginBoolSymbol.js的代码框架如下：
function mainJs(a,b) {
//请在此处编写代码
/********** Begin **********/
/********** End **********/
}
测试说明
测试过程：
平台将读取用户补全后的LoginBoolSymbol.js；
调用其中的mainJs()方法，输入若干组测试数据；
最后根据测试结果判断程序是否正确。
以下是测试样例：
测试输入：
b,d
预期输出：
b
测试输入：
z,zz
预期输出：
False
第2关：比较和逻辑运算符
100
学习内容
参考答案
记录
评论
任务描述
相关知识
比较运算符
逻辑运算符
编程要求
测试说明
任务描述
本关任务：判断两个字符串的大小，第一个大于第二个则返回两者逻辑相与的结果，否则返回第二个逻辑取反的结果。
例如：a为字符串"d"，b为字符串"b"，因为字符串"d"大于字符串"b"，所以返回"d"逻辑与"b"，即字符串"b"。
相关知识
比较运算符
JavaScript中的比较运算符有==,===,>,<,!=,>=等。
==叫做相等，===叫做严格相等。双等号和三等号的区别是：三等号要求数据类型和值都相等，双等号只需要值相等即可，相等包含严格相等。
从比较过程来看，严格相等先比较两个对象的数据类型是否相等，不相等则结束比较，返回false，相等在数据类型不同时，尝试进行数据类型转换，例如，在字符串和数字的比较中，字符串会被转为数字再比较；布尔值true转为数字1，布尔值false转为数字0。
如果数据类型相同，相等和严格相等都会直接比较值，值相等返回true。
需要特别注意的是，以上仅仅适用于非对象类型。对于对象类型，相等或者严格相等比较的都是对象的引用，而不是具体的值，就是说，一个对象和其他任何对象都是不相等的，即使两者属性、值都相等。下面给出一些例子：
var stringVariable = "2";
var number1 = 2;
var number2 = 2;
console.log(stringVariable == number1);//true
console.log(stringVariable === number1);//false
console.log(number1 === number2);//true
var studentA = {
name:"Bob",
age:22
}
var studentB = {
name:"Bob",
age:22
}
console.log(studentA == studentB);//false，因为不是同一个对象
var studentC = studentA;
console.log(studentA == studentC);//true，因为是同一个对象
将studentA赋值给studentC，这时studentC和studentA指向内存中的同一个地址块，视为同一个对象，所以两者相等。
不等 对应于上面的等号，不等号也有两种：!=和!==。 !=和==互为相反，==成立，!=一定不成立。 !==和===互为相反，严格相等成立，则严格不相等不成立。
其它 大于，小于，大于等于，小于等于的比较规则如下： 比较的两个对象都是数字，按照数学中数字的比较方法。 数字和字符串比较，字符串转为数字后再比较。 字符串和字符串比较，从第一个字符开始，逐个比较，发现不相等立即返回。字符按照ASCII编码值的大小比较，一般只要记住：数字<大写字母<小写字母，字母a小于字母z，A小于Z， 比较过程中，当一个字符串结束另外一个字符串还有，还没有比较出大小，则长的字符串较大。
var number1 = 1;//定义变量number1
var number2 = 2;//定义变量number2
var string1 = "3";//string1
var lowerLetter = "a";//定义变量lowerLetter
var upperLetter = "A";//定义变量upperLetter
var string1 = "aa";//定义变量string1
var String2 = "ab";//定义变量String2
console.log(number1<number2);//输出true
console.log(number2<string1);//输出true
console.log(upperLetter<lowerLetter);//输出true
console.log(lowerLetter<string1);//输出false
console.log(string1<string2);//输出true
逻辑运算符
在介绍逻辑运算符之前，我们必须明确逻辑运算符的操作数只能是布尔型，其他类型都会被转换为布尔型：除了0，null，undefined，""外，其他的值转换为布尔值都是true。
逻辑与
逻辑与有两个操作数，中间用&&连接，只有两个操作数都是true结果才是true；
其中一个操作数不是布尔型，当左操作数为真值时，返回右操作数。当左操作数为假值时，返回左操作数。
逻辑或
逻辑或同样有两个操作数，用||连接，至少有一个操作数为true时结果为true；
其中一个操作数不是布尔型，当左操作数为真值时，返回左操作数。当左操作数为假值时，返回右操作数。
逻辑非
逻辑非只有一个操作数，!后连接操作数或表达式，意思是将操作数取反；
如果操作数不是布尔型，编译器首先将其他类型转换为布尔型，然后返回true或者false。
console.log(true&&false);//false
console.log(true||false);//true
console.log(!false);//true
var number1 = 1;
var number2 = 0;
var string = "a";
console.log(number1&&string);//输出字符串"a"
console.log(number1||string);//输出数字1
console.log(!number1);//false
编程要求
本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：
完成函数mainJs()；
比较字符串a和b的大小；
如果a>b，则返回a逻辑与b的结果，否则返回a逻辑取反的结果（返回时使用return）；
具体请参见后续测试样例。
比较需要用到条件表示式，如下：
//打印a和b中较大的哪一个
var a = 1,b = 2;
if(a > b) {
console.log(a);
}
else {
console.log(b);
}
本关涉及的代码文件LoginBoolSymbol.js的代码框架如下：
function mainJs(a,b) {
//请在此处编写代码
/********** Begin **********/
/********** End **********/
}
测试说明
测试过程：
平台将读取用户补全后的LoginBoolSymbol.js；
调用其中的mainJs()方法，输入若干组测试数据；
最后根据测试结果判断程序是否正确。
以下是测试样例：
测试输入：
b,d
预期输出：
b
测试输入：
z,zz
预期输出：
False
第2关：比较和逻辑运算符
100
学习内容
参考答案
记录
评论
任务描述
相关知识
比较运算符
逻辑运算符
编程要求
测试说明
任务描述
本关任务：判断两个字符串的大小，第一个大于第二个则返回两者逻辑相与的结果，否则返回第二个逻辑取反的结果。
例如：a为字符串"d"，b为字符串"b"，因为字符串"d"大于字符串"b"，所以返回"d"逻辑与"b"，即字符串"b"。
相关知识
比较运算符
JavaScript中的比较运算符有==,===,>,<,!=,>=等。
==叫做相等，===叫做严格相等。双等号和三等号的区别是：三等号要求数据类型和值都相等，双等号只需要值相等即可，相等包含严格相等。
从比较过程来看，严格相等先比较两个对象的数据类型是否相等，不相等则结束比较，返回false，相等在数据类型不同时，尝试进行数据类型转换，例如，在字符串和数字的比较中，字符串会被转为数字再比较；布尔值true转为数字1，布尔值false转为数字0。
如果数据类型相同，相等和严格相等都会直接比较值，值相等返回true。
需要特别注意的是，以上仅仅适用于非对象类型。对于对象类型，相等或者严格相等比较的都是对象的引用，而不是具体的值，就是说，一个对象和其他任何对象都是不相等的，即使两者属性、值都相等。下面给出一些例子：
var stringVariable = "2";
var number1 = 2;
var number2 = 2;
console.log(stringVariable == number1);//true
console.log(stringVariable === number1);//false
console.log(number1 === number2);//true
var studentA = {
name:"Bob",
age:22
}
var studentB = {
name:"Bob",
age:22
}
console.log(studentA == studentB);//false，因为不是同一个对象
var studentC = studentA;
console.log(studentA == studentC);//true，因为是同一个对象
将studentA赋值给studentC，这时studentC和studentA指向内存中的同一个地址块，视为同一个对象，所以两者相等。
不等 对应于上面的等号，不等号也有两种：!=和!==。 !=和==互为相反，==成立，!=一定不成立。 !==和===互为相反，严格相等成立，则严格不相等不成立。
其它 大于，小于，大于等于，小于等于的比较规则如下： 比较的两个对象都是数字，按照数学中数字的比较方法。 数字和字符串比较，字符串转为数字后再比较。 字符串和字符串比较，从第一个字符开始，逐个比较，发现不相等立即返回。字符按照ASCII编码值的大小比较，一般只要记住：数字<大写字母<小写字母，字母a小于字母z，A小于Z， 比较过程中，当一个字符串结束另外一个字符串还有，还没有比较出大小，则长的字符串较大。
var number1 = 1;//定义变量number1
var number2 = 2;//定义变量number2
var string1 = "3";//string1
var lowerLetter = "a";//定义变量lowerLetter
var upperLetter = "A";//定义变量upperLetter
var string1 = "aa";//定义变量string1
var String2 = "ab";//定义变量String2
console.log(number1<number2);//输出true
console.log(number2<string1);//输出true
console.log(upperLetter<lowerLetter);//输出true
console.log(lowerLetter<string1);//输出false
console.log(string1<string2);//输出true
逻辑运算符
在介绍逻辑运算符之前，我们必须明确逻辑运算符的操作数只能是布尔型，其他类型都会被转换为布尔型：除了0，null，undefined，""外，其他的值转换为布尔值都是true。
逻辑与
逻辑与有两个操作数，中间用&&连接，只有两个操作数都是true结果才是true；
其中一个操作数不是布尔型，当左操作数为真值时，返回右操作数。当左操作数为假值时，返回左操作数。
逻辑或
逻辑或同样有两个操作数，用||连接，至少有一个操作数为true时结果为true；
其中一个操作数不是布尔型，当左操作数为真值时，返回左操作数。当左操作数为假值时，返回右操作数。
逻辑非
逻辑非只有一个操作数，!后连接操作数或表达式，意思是将操作数取反；
如果操作数不是布尔型，编译器首先将其他类型转换为布尔型，然后返回true或者false。
console.log(true&&false);//false
console.log(true||false);//true
console.log(!false);//true
var number1 = 1;
var number2 = 0;
var string = "a";
console.log(number1&&string);//输出字符串"a"
console.log(number1||string);//输出数字1
console.log(!number1);//false
编程要求
本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：
完成函数mainJs()；
比较字符串a和b的大小；
如果a>b，则返回a逻辑与b的结果，否则返回a逻辑取反的结果（返回时使用return）；
具体请参见后续测试样例。
比较需要用到条件表示式，如下：
//打印a和b中较大的哪一个
var a = 1,b = 2;
if(a > b) {
console.log(a);
}
else {
console.log(b);
}
本关涉及的代码文件LoginBoolSymbol.js的代码框架如下：
function mainJs(a,b) {
//请在此处编写代码
/********** Begin **********/
/********** End **********/
}
测试说明
测试过程：
平台将读取用户补全后的LoginBoolSymbol.js；
调用其中的mainJs()方法，输入若干组测试数据；
最后根据测试结果判断程序是否正确。
以下是测试样例：
测试输入：
b,d
预期输出：
b
测试输入：
z,zz
预期输出：
False
第2关：比较和逻辑运算符
100
学习内容
参考答案
记录
评论
任务描述
相关知识
比较运算符
逻辑运算符
编程要求
测试说明
任务描述
本关任务：判断两个字符串的大小，第一个大于第二个则返回两者逻辑相与的结果，否则返回第二个逻辑取反的结果。
例如：a为字符串"d"，b为字符串"b"，因为字符串"d"大于字符串"b"，所以返回"d"逻辑与"b"，即字符串"b"。
相关知识
比较运算符
JavaScript中的比较运算符有==,===,>,<,!=,>=等。
==叫做相等，===叫做严格相等。双等号和三等号的区别是：三等号要求数据类型和值都相等，双等号只需要值相等即可，相等包含严格相等。
从比较过程来看，严格相等先比较两个对象的数据类型是否相等，不相等则结束比较，返回false，相等在数据类型不同时，尝试进行数据类型转换，例如，在字符串和数字的比较中，字符串会被转为数字再比较；布尔值true转为数字1，布尔值false转为数字0。
如果数据类型相同，相等和严格相等都会直接比较值，值相等返回true。
需要特别注意的是，以上仅仅适用于非对象类型。对于对象类型，相等或者严格相等比较的都是对象的引用，而不是具体的值，就是说，一个对象和其他任何对象都是不相等的，即使两者属性、值都相等。下面给出一些例子：
var stringVariable = "2";
var number1 = 2;
var number2 = 2;
console.log(stringVariable == number1);//true
console.log(stringVariable === number1);//false
console.log(number1 === number2);//true
var studentA = {
name:"Bob",
age:22
}
var studentB = {
name:"Bob",
age:22
}
console.log(studentA == studentB);//false，因为不是同一个对象
var studentC = studentA;
console.log(studentA == studentC);//true，因为是同一个对象
将studentA赋值给studentC，这时studentC和studentA指向内存中的同一个地址块，视为同一个对象，所以两者相等。
不等 对应于上面的等号，不等号也有两种：!=和!==。 !=和==互为相反，==成立，!=一定不成立。 !==和===互为相反，严格相等成立，则严格不相等不成立。
其它 大于，小于，大于等于，小于等于的比较规则如下： 比较的两个对象都是数字，按照数学中数字的比较方法。 数字和字符串比较，字符串转为数字后再比较。 字符串和字符串比较，从第一个字符开始，逐个比较，发现不相等立即返回。字符按照ASCII编码值的大小比较，一般只要记住：数字<大写字母<小写字母，字母a小于字母z，A小于Z， 比较过程中，当一个字符串结束另外一个字符串还有，还没有比较出大小，则长的字符串较大。
var number1 = 1;//定义变量number1
var number2 = 2;//定义变量number2
var string1 = "3";//string1
var lowerLetter = "a";//定义变量lowerLetter
var upperLetter = "A";//定义变量upperLetter
var string1 = "aa";//定义变量string1
var String2 = "ab";//定义变量String2
console.log(number1<number2);//输出true
console.log(number2<string1);//输出true
console.log(upperLetter<lowerLetter);//输出true
console.log(lowerLetter<string1);//输出false
console.log(string1<string2);//输出true
逻辑运算符
在介绍逻辑运算符之前，我们必须明确逻辑运算符的操作数只能是布尔型，其他类型都会被转换为布尔型：除了0，null，undefined，""外，其他的值转换为布尔值都是true。
逻辑与
逻辑与有两个操作数，中间用&&连接，只有两个操作数都是true结果才是true；
其中一个操作数不是布尔型，当左操作数为真值时，返回右操作数。当左操作数为假值时，返回左操作数。
逻辑或
逻辑或同样有两个操作数，用||连接，至少有一个操作数为true时结果为true；
其中一个操作数不是布尔型，当左操作数为真值时，返回左操作数。当左操作数为假值时，返回右操作数。
逻辑非
逻辑非只有一个操作数，!后连接操作数或表达式，意思是将操作数取反；
如果操作数不是布尔型，编译器首先将其他类型转换为布尔型，然后返回true或者false。
console.log(true&&false);//false
console.log(true||false);//true
console.log(!false);//true
var number1 = 1;
var number2 = 0;
var string = "a";
console.log(number1&&string);//输出字符串"a"
console.log(number1||string);//输出数字1
console.log(!number1);//false
编程要求
本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：
完成函数mainJs()；
比较字符串a和b的大小；
如果a>b，则返回a逻辑与b的结果，否则返回a逻辑取反的结果（返回时使用return）；
具体请参见后续测试样例。
比较需要用到条件表示式，如下：
//打印a和b中较大的哪一个
var a = 1,b = 2;
if(a > b) {
console.log(a);
}
else {
console.log(b);
}
本关涉及的代码文件LoginBoolSymbol.js的代码框架如下：
function mainJs(a,b) {
//请在此处编写代码
/********** Begin **********/
/********** End **********/
}
测试说明
测试过程：
平台将读取用户补全后的LoginBoolSymbol.js；
调用其中的mainJs()方法，输入若干组测试数据；
最后根据测试结果判断程序是否正确。
以下是测试样例：
测试输入：
b,d
预期输出：
b
测试输入：
z,zz
预期输出：
False
第2关：比较和逻辑运算符
100
学习内容
参考答案
记录
评论
任务描述
相关知识
比较运算符
逻辑运算符
编程要求
测试说明
任务描述
本关任务：判断两个字符串的大小，第一个大于第二个则返回两者逻辑相与的结果，否则返回第二个逻辑取反的结果。
例如：a为字符串"d"，b为字符串"b"，因为字符串"d"大于字符串"b"，所以返回"d"逻辑与"b"，即字符串"b"。
相关知识
比较运算符
JavaScript中的比较运算符有==,===,>,<,!=,>=等。
==叫做相等，===叫做严格相等。双等号和三等号的区别是：三等号要求数据类型和值都相等，双等号只需要值相等即可，相等包含严格相等。
从比较过程来看，严格相等先比较两个对象的数据类型是否相等，不相等则结束比较，返回false，相等在数据类型不同时，尝试进行数据类型转换，例如，在字符串和数字的比较中，字符串会被转为数字再比较；布尔值true转为数字1，布尔值false转为数字0。
如果数据类型相同，相等和严格相等都会直接比较值，值相等返回true。
需要特别注意的是，以上仅仅适用于非对象类型。对于对象类型，相等或者严格相等比较的都是对象的引用，而不是具体的值，就是说，一个对象和其他任何对象都是不相等的，即使两者属性、值都相等。下面给出一些例子：
var stringVariable = "2";
var number1 = 2;
var number2 = 2;
console.log(stringVariable == number1);//true
console.log(stringVariable === number1);//false
console.log(number1 === number2);//true
var studentA = {
name:"Bob",
age:22
}
var studentB = {
name:"Bob",
age:22
}
console.log(studentA == studentB);//false，因为不是同一个对象
var studentC = studentA;
console.log(studentA == studentC);//true，因为是同一个对象
将studentA赋值给studentC，这时studentC和studentA指向内存中的同一个地址块，视为同一个对象，所以两者相等。
不等 对应于上面的等号，不等号也有两种：!=和!==。 !=和==互为相反，==成立，!=一定不成立。 !==和===互为相反，严格相等成立，则严格不相等不成立。
其它 大于，小于，大于等于，小于等于的比较规则如下： 比较的两个对象都是数字，按照数学中数字的比较方法。 数字和字符串比较，字符串转为数字后再比较。 字符串和字符串比较，从第一个字符开始，逐个比较，发现不相等立即返回。字符按照ASCII编码值的大小比较，一般只要记住：数字<大写字母<小写字母，字母a小于字母z，A小于Z， 比较过程中，当一个字符串结束另外一个字符串还有，还没有比较出大小，则长的字符串较大。
var number1 = 1;//定义变量number1
var number2 = 2;//定义变量number2
var string1 = "3";//string1
var lowerLetter = "a";//定义变量lowerLetter
var upperLetter = "A";//定义变量upperLetter
var string1 = "aa";//定义变量string1
var String2 = "ab";//定义变量String2
console.log(number1<number2);//输出true
console.log(number2<string1);//输出true
console.log(upperLetter<lowerLetter);//输出true
console.log(lowerLetter<string1);//输出false
console.log(string1<string2);//输出true
逻辑运算符
在介绍逻辑运算符之前，我们必须明确逻辑运算符的操作数只能是布尔型，其他类型都会被转换为布尔型：除了0，null，undefined，""外，其他的值转换为布尔值都是true。
逻辑与
逻辑与有两个操作数，中间用&&连接，只有两个操作数都是true结果才是true；
其中一个操作数不是布尔型，当左操作数为真值时，返回右操作数。当左操作数为假值时，返回左操作数。
逻辑或
逻辑或同样有两个操作数，用||连接，至少有一个操作数为true时结果为true；
其中一个操作数不是布尔型，当左操作数为真值时，返回左操作数。当左操作数为假值时，返回右操作数。
逻辑非
逻辑非只有一个操作数，!后连接操作数或表达式，意思是将操作数取反；
如果操作数不是布尔型，编译器首先将其他类型转换为布尔型，然后返回true或者false。
console.log(true&&false);//false
console.log(true||false);//true
console.log(!false);//true
var number1 = 1;
var number2 = 0;
var string = "a";
console.log(number1&&string);//输出字符串"a"
console.log(number1||string);//输出数字1
console.log(!number1);//false
编程要求
本关的编程任务是补全右侧代码片段中Begin至End中间的代码，具体要求如下：
完成函数mainJs()；
比较字符串a和b的大小；
如果a>b，则返回a逻辑与b的结果，否则返回a逻辑取反的结果（返回时使用return）；
具体请参见后续测试样例。
比较需要用到条件表示式，如下：
//打印a和b中较大的哪一个
var a = 1,b = 2;
if(a > b) {
console.log(a);
}
else {
console.log(b);
}
本关涉及的代码文件LoginBoolSymbol.js的代码框架如下：
function mainJs(a,b) {
//请在此处编写代码
/********** Begin **********/
/********** End **********/
}
测试说明
测试过程：
平台将读取用户补全后的LoginBoolSymbol.js；
调用其中的mainJs()方法，输入若干组测试数据；
最后根据测试结果判断程序是否正确。
以下是测试样例：
测试输入：
b,d
预期输出：
b
测试输入：
z,zz
预期输出
最新发布
本文详细解析了JavaScript中的按位取反运算符(~)的工作原理，通过实例展示了正数和负数输入时该运算符的具体计算过程，并给出了实际应用场景示例。
扫一扫
976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
