JS基础

JS
ECMA制定JS规范
ECMAscript ES5 ES6 版本号
开发语言分类
解释性语言：翻译一行，执行一行。
JS,python
翻译性语言：通篇翻译后执行。
Java,c,c++,c#
代码报错
1，语法错误
2，逻辑错误
3，运行错误
开发流程
1.功能设计
2.需求分析
3.功能开发（确定数据结构和算法）
4.功能测试
5.功能维护
6.功能上线
软件—程序—数据结构和算法
数据结构：存储数据的方式
算法：解决问题的方法和步骤
算法的特点
1.有穷性：一个算法的操作步骤，是在有限的范围内可以完成的。
2.确定性：只有真假
3.有0到多个输入
4.有1到多个输出
5.有效性（123/0无效）
作业：1.grid布局
预习：1流程图，2变量，3数据类型

专业术语
标识符
1.变量
2.常量 注：如果赋值给常量的是基本数据类型，常量存的是基本数据类型的值。
如果常量存的是引用数据类型，常量存的是基本数据类型的地址（引用数类型存储的值发生变化时，常量也会发生变化）
创建变量
命名规范：
1，硬性要求
a>不能以数字开头
吧>可以包含数字，字母，下划线，连字符
2，软性要求：见名知意
命名方式：
1,大驼峰命名法（每一个单词的首字母大写）
2，小驼峰命名法（除了第一个单词后面单词都首字母大小）
3，蛇形命名法（单词之间用_下划线连接）
ES5
书写格式：关键字/关键词 标识符（变量名） 分号
例子： var F70 ;
var F70;
ES6
书写格式：关键字/关键词 标识符（变量名） 分号
例子： let F71 ;
var F71;
let和var的区别
1.var声明的变量，是可以重复的，let不行。
2.var声明的变量，可以先使用后声明。
变量的赋值
书写格式： 标识符号 赋值符 表达式 分号
F70 = 0 ；
F70=0；
变量初始化(一般写这个）
变量的赋值
书写格式：关键词 标识符号 赋值符 表达式 分号
var F70 = 0 ；
var F70 =0；

使用变量 console.log();在终端输出小括号里的内容。
console.log(F70); //100 C

//表示XXX重复声明
// XXX has already been declared

//表示XXX没有声明（创建）
// XXXX is not defined
// console.log(F72); //F72 is not defined

// let F73;
// console.log(F73); //undefined 表示变量声明未赋值（不是报错）
// console.log(F70); //100

//ES6 声明常量
// 书写格式： 关键词（字） 标识符（变量名） 分号
// 例子： const F73 ；
// const F73 = 200;
// console.log(F73); //200
// F73 = 1;
// console.log(F73);//Assignment to constant variable.

//【数据类型】
//[基本数据类型]
//[undefined]
// let F70 = undefined;

//查看数据类型
//书写格式： typeof 标识符
// console.log(F70); //undefined
// console.log(typeof F70); //undefined

//[typeof扩展]
//输出一个未声明变量的类型，会输出undefined（即不会报错）
//原因：计算机会默认以var声明该变量
// console.log(typeof F73); //un

//[null] 空
// let F74 = null;
// console.log(F74); //null
// console.log(typeof F74); //null

//[Boolean]布尔类型 (适用场景：判断条件)
// 两个值： 真 true 假 false
// 注： 小写字母/
// let shexiaoguo = true;
// let huangmiliang = false;
// console.log(shexiaoguo); //true
// console.log(typeof shexiaoguo); //boolean
// console.log(huangmiliang); //false
// console.log(typeof huangmiliang); //boolean

// //[数值型]
// let num1 = 1;
// let num2 = 1.5;
// let num3 = -200;
// console.log(num1);//1
// console.log(num2);//1.5
// console.log(num3);//-200
// console.log(typeof num3);//number

//NaN: is not a Number;不是一个数字
// let num4 = NaN;
// console.log(num4);
// console.log(typeof num4);
// console.log(1 + 2);
// console.log(1 - 2);
// console.log(“A” - 123);//NaN

//isNaN(标识符) 判断是不是一个非数字
//返回true则不是数字，返回false则是纯数字

//适用场景：判断用户输入是不是一个纯数字(T/F)
// let inputNum = “ABC”;
// console.log(isNaN(inputNum)); //false

//获取用户输入的纯数字
// let inputNum2 = 123.5;
// inputNum2 = “456abc”;
// parseInt当前变量取整
// 注：从第一个纯数字截取，一直到非数字的前一位。
/**

• 1、第一个字符，不是数字，负号，返回NaN
• 2、第一个字符是0，到第一个不是0的数字。都无效。
• [扩展]
• 3、0X开始，代表十六进制。
  */
  // console.log(parseInt(inputNum2));
  //[作业] 四舍五入、向上取整、向下取整、保留小数位
  let num1 = 1.56;
  // console.log(向上取整为:${Math.floor(num1)}); //1

// let num2 = 1.56;
// console.log(向下取整为:${Math.ceil(num2)}); //2
// //四舍五入
// let num3 = 1.1;
// console.log(Math.round(num3)); //2

// //保留2为小数
// let num4 = 1.567;
// console.log(num4.toFixed(2));

//[string]字符型 字符串
// 书写格式： 内容左右加引号（双、单引号、字符串模版）

// let str = “education”;
// console.log(str); //education
// console.log(typeof str); //string
// str = ‘成都’;
// console.log(str); //‘成都’
// console.log(typeof str); //string

// str = “欢迎光临’XXX’,马尔代夫银行！！！”;
// console.log(str);

//[字符串模版]
// let account = “F70”;
// let str = 欢迎光临${account},马尔代夫银行！！！;
// console.log(str);

//【symbol类型】对象时讲解

//【数据类型的转换】
//【Boolean类型转换】true 1 false 0
//下列例子是比较运算符（会把左右内容转换数值）
// let F70 = 1;
// console.log(F70 == true); //true
// F70 = “abc”;
// console.log(F70 == true); //false

/**

• [隐式转换]
• 以下内容在转换布尔值时为false
• 1、false
• 2、0,-0
• 3、null
• 4、undefined
• 5、"",’’,``
• 6、NaN
  */

//【强制类型转换布尔】
//书写格式：Boolean(标识符/具体的值)
// let str = “ABC”;
// let boo = Boolean(str); //把str的内容转换成布尔值返回
// console.log(boo); //true

// 判断语句
// 书写格式：if（条件）{}
// let F70 = 200;
// if (F70) {
// console.log(“F70 is true”);
// } else {
// console.log(“F70 is false”);
// }

//数值类型转换

//【强制转换数值】
// let str = “123”;
// let num = Number(str);
// console.log(num, typeof num); //123 number

// str = “abc”;
// num = Number(str);
// console.log(num, typeof num); //NaN number

// str = false;
// num = Number(str);
// console.log(num, typeof num); //0 number

//快捷转换数值类型方式【隐式转换】
// let str = “200abc”;
// let num = str - 0;
// console.log(num, typeof num);

//【强制转换字符串】
// let num = 123;
// let str = String(num);
// console.log(str, typeof str);//123 string

//快捷转换字符串类型方式【隐式转换】
// let num = 123;
// let str = num + “”;
// console.log(str, typeof str); //123 string

运算符
//【运算符】
//[一元运算符]
/**

• 原理：++在前，先自增，再使用
  /
  // let num1 = 1;
  // let num2 = ++num1;
  // console.log(num2:${num2}); //2
  // console.log(num1:${num1}); //2
  /*
• 原理：++在后，先使用，再自增
  /
  // let num1 = 1;
  // let num2 = num1++;
  // console.log(num2:${num2}); //1
  // console.log(num1:${num1}); //2
  /*
• 自减原理：–在后，先使用，再自减
• 自减原理：–在前，先自减，再使用
  */
  // let num5 = 100;
  // --num5;
  // console.log(num5); //99
  //注：只有自增、自减在表达式中，才考虑先后顺序。

//[算数运算符]
let i = 1;
let j = 2;
let k = i + j;
console.log(k); //3
k = i - j;
console.log(k); //-1
k = i * j;
console.log(k); //2
k = i / j;
console.log(k); //0.5
k = i % j;
console.log(“F70:”, k); //1

//算数运算符【简写方式】
// k = k+3;
// k+=3;
// k = k-3;
// k-=3;
// k = k3;
// k=3;
// k = k/3;
// k/=3;
// k = k%3;
// k%=3;
比较转换
undefined是由null衍生而来
NaN不等于任何值包括它自己（判断是不是非数字使用：isNaN() )
字符串是按位比较
转换布尔值 例如：F71=!(!F70)
//【运算符】
//[一元运算符]
/**

• 原理：++在前，先自增，再使用
  /
  // let num1 = 1;
  // let num2 = ++num1;
  // console.log(num2:${num2}); //2
  // console.log(num1:${num1}); //2
  /*
• 原理：++在后，先使用，再自增
  /
  // let num1 = 1;
  // let num2 = num1++;
  // console.log(num2:${num2}); //1
  // console.log(num1:${num1}); //2
  /*
• 自减原理：–在后，先使用，再自减
• 自减原理：–在前，先自减，再使用
  */
  // let num5 = 100;
  // --num5;
  // console.log(num5); //99
  //注：只有自增、自减在表达式中，才考虑先后顺序。

//[算数运算符]
// let i = 1;
// let j = 2;
// let k = i + j;
// console.log(k); //3
// k = i - j;
// console.log(k); //-1
// k = i * j;
// console.log(k); //2
// k = i / j;
// console.log(k); //0.5
// k = i % j;
// console.log(“F70:”, k); //1

//算数运算符【简写方式】
// k = k+3;
// k+=3;
// k = k-3;
// k-=3;
// k = k3;
// k=3;
// k = k/3;
// k/=3;
// k = k%3;
// k%=3;

// let F70 = 123;
// console.log(F70); //123
// F70–;
// console.log(F70); //122

// F70 = “123a”;
// F70–;
// console.log(F70); //NaN

/**

• [比较运算符] 返回的布尔值
• 大于 >
• 小于 <
• 等于 ==
• 大于等于 >=
• 小于等于 <=
• 不等于 !=
• 全等 ===
• 不全等 !==
  */

// let i = 1;
// let j = 2;
// console.log(i == j); //false
// let k = “2”;
// console.log(j == k); //true

// console.log(i == true); //true
// console.log(i == “1”); //true
// i = 0;
// console.log(i == false); //true
// i = undefined;
// console.log(“un1”, i == false); //false
// console.log(“un2”, i == 0); //false
// i = null;
// console.log(“null1”, i == false); //false
// console.log(“null2”, i == 0); //false

// console.log(null == undefined); //true
//undefined是由null衍生而来

// let account1 = “F70”;
// let pwd1 = false;
// let inputAccount = “F71”;
// let inputPWD = 0;
// console.log(inputAccount == account1); //false
// console.log(inputPWD == pwd1); //true

//NaN不等于任何值，包括它自己
//注：判断是不是非数字使用：isNaN()
// console.log(NaN == 123); //false
// console.log(NaN == “abc”); //false
// console.log(NaN == false); //false
// console.log(NaN == true); //false
// console.log(NaN == undefined); //false
// console.log(NaN == null); //false
// console.log(NaN == NaN); //false

//字符串比较是按位比较（非数字比较ASC码）
// console.log(“a” < “b”); //true
// console.log(“c” > “b”); //true
// console.log(“c” > “C”); //true

// console.log(“123a” > “123b”); //false
// console.log(“123a” > “113b”); //true
// console.log(123 > “123a”); //false 与NaN都是false

//全等：值和类型都要相同才返回true
// console.log(123 == “123”); //true
// console.log(123 === “123”); //false

//[逻辑运算符]

/**

• 非 与 或
• 非 书写格式： ！表达式/标示符
• 功能：取反

*/

// console.log(!true); //false
// console.log(!123); //false
// console.log(!null); //true
// console.log(!1 + 2); //2

//[与运算] && 一假全假
/**

• 【扩展工作原理】
• 情况1:
• 表达式1&&表达式2
• step1:先判断表达式1的值是不是flase

•   如果是则返回表达式1的值
  

• step2:若表达式1的值是true，则返回表达式2的值
• 情况2:
• 表达式1&&表达式2&&表达式3…&&表达式n
• step1:先判断表达式1的值是不是flase

•   如果是则返回表达式1的值
  

• step2:若表达式1的值是true，

•   则判断表达式2的值，是不是true
  

•   是true，则判断表达式3，以此类推。
  

•   是false，则返回表达式2的值，以此类推。
  

*/
// console.log(true && true); //true
// console.log(true && false && true); //false

// //[或运算] || 一真全真
// console.log(false || false); //false
// console.log(false || false || true); //true

/**

• 【位运算符】
• | 和 &
• 先把表达式内容转换二进制，按位运算后再转十进制输出
• 十进制 二进制 十进制
• 1 01
• 2 10
• ｜运算 11 3
• 1 01
• 2 10
• &运算 00 0
  */
  // console.log(1 || 2); //1
  // console.log(1 && 2); //2

// console.log(1 | 2); //3
// console.log(1 & 2); //0

//【三目运算符】
// 书写格式： 表达式1(条件) ? 表达式2 : 表达式3；
console.log(请输入第1个数字：);
let inputNum1 = rs.question() - 0;
console.log(请输入第2个数字：);
let inputNum2 = rs.question() - 0;
// inputNum1 > inputNum2
// ?
// console.log(您输入的两个数中最大值为：${inputNum1})
// :
// console.log(您输入的两个数中最大值为：${inputNum2});

console.log(请输入第3个数字：);
let inputNum3 = rs.question() - 0;

(inputNum1 > inputNum2 && inputNum1 > inputNum3) ?
console.log(inputNum1):
(
inputNum2 > inputNum3 ?
console.log(inputNum2) :
console.log(inputNum3)
);