1.变量
变量:引用内存中存储的一个值
声明变量:var,let,const(推荐使用ES6的新关键字let和const)
var 声明的变量属于函数级别,会有覆盖,存在变量提升.
let,const 声明的变量属于块级别
var和let 声明的是变量:可变
const 声明的是常量:不可变
let a = 1;//声明变量的同时进行初始化,未初始化的变量值为undefined
let b ;//声明变量,未初始化
b = 10;//变量的初始化
let x =6, y = 9,z = 10;//let可以一行进行多个变量的声明
重复的声明变量:var 声明的变量会覆盖前面的,let和const是不允许(同一范围内)
var a = 1;
var a = 2;
console.log(a);//2
⭐ 特殊情况,变量赋值无需事先声明,赋值操作会自动声明该变量
{
a = 5;
console.log(a);//5
}
console.log(a);//5
//墨水交换
let a = 1;
let b = 2;
let t;
t = a;
a = b;
b = t;
console.log("交换之后两个数:a:"+a , "b:"+b);//a = 2,b =1;
1.1变量的作用域
2.变量的作用域:变量能够作用的范围
全局作用域 和 局部作用域
全局作用域:在整个文档的区域,而拥有全局作用域的变量叫做全局变量
局部作用域:Es5之前,指通过函数产生的作用域(函数作用域);ES6,let和const的引入,加入块级作用域的概念"{}",其变量叫局部变量
特别注意：没用关键字的变量,有特殊的处理,是全局的
let a = 10;//全局作用域
function foo(){
let b = 10;//函数作用域
}
foo();
let d = 11;
{
let c = 12;//块级作用域
d = 13;//全局作用域，没有声明的变量，没有关键字的情况下赋值，有特殊的处理，是全局的，其声明位置在其所在块的上一行（没有变量提升）
{
console.log(c);//12
}
}
console.log(d);//13
1.2 变量的提升
所有通过var声明的变量,变量的声明部分会提升到当前作用域的最顶端
var a = 10;
{
var a = 11;
}
console.log(a);//11
==============================================================================
var age = 18;
function foo() {
var age = 19;
console.log(age);
}
foo();//19
==============================================================================
if(false){
var a = 1;//var有着变量提升,并且var不会产生块级作用域
let b = 2;//产生块级作用域
}
console.log(a);//undefined
console.log(b);//b is not defined
==============================================================================
var a = 1;
if (true) {
console.log(a);
let a = 2;//let声明的变量不会提升,并且会产生暂存死区.在let声明变量之前访问变量会抛出错误.
}
==============================================================================
⭐区别var和let
1)var是ES5,let是ES6
2)var可以重复声明,但let不行
3)var有变量提升,let没有
4)var的局部作用域只有函数作用域,而let包含函数作用域和块级作用域
2.JS的数据类型
1.数据类型
1)简单数据类型:Number(整数,小数),String(字符串),undefined(未定义),boolean,Null(空),Symbol
2)复杂数据类型:object
2.查看数据类型关键字
查看数据类型的关键字:typeof
let a = "33333"
console.log(typeof a);//string
let b = typeof typeof typeof[12,23];
cnosole.log(b);//typeof typeof object
//typeof "string"
//"string",在两个typeof检测以上,基本答案都是string
2.1 JS的简单数据类型
Number:整数,小数
let a1 = 9;//十进制
let a2 = 0b011;//二进制ob
let a3 = 076;//八进制0
let a4 = 0x76;//十六进制0x
//不管运算中声明进制,其结果都是十进制
console.log(a1*a2);//27
let b1 = 1234567777**2345678987654;
console.log(b1);//数值的范围:(两个特殊的值：Infinity、NaN)
console.log("最大值："+Number.MAX_VALUE);//超过这个这个值的值叫：Infinity(无限大)----Infinity不能参与运算
console.log("最小值："+Number.MIN_VALUE);//小于这个这个值的值叫：-Infinity(无限小)
⭐NaN:nota Number 非数(属于Number类型)
特点:
1).任何参与到NaN的运算的结果都是NaN.
2).NaN与任何值都不相等(自己)
console.log(NaN==NaN);
⭐⭐⭐String:以单引号或者双引号包起来的文本(String和其他数据类型相加都会转换成字符串类型)但是String字符串是不能直接参与运行,必须转换过后才能运算("+"号变成拼接)
let str1 = "你好";
let str2 = 'Hello';
console.log("\t第一行文字。\n\t第二行文字");//转义字符“\”:1、将有特殊含义的符号进行无含义转化 2.转义字母，产生特殊含义：\n,\t,\r........
let a = "12";
let b = 10;
let c = 3.4;
console.log(a+c);//123.4
console.log(Number.parseInt(a)+c);//15.4
⭐⭐⭐boolean:true,false
let a = true;
console.log(typeof a);//boolean
console.log(Boolean(30));//true
console.log(Boolean(0));//flase
⭐⭐⭐undefined:出现undefined情况(
1.访问未初始化的变量
2.直接给变量赋值为undefined
3.typeof 值为undefined
4.没有return语句的函数的默认返回值为undefined
5.有return语句,但是return后面没有显示的任何内容
6.访问不存在的属性(对象)
)
let i;
console.log(typeof i);//undefined
⭐⭐Null:其实undefined就是Null衍生过来的,表示一个空的对象.
console.log(null == undefined);
console.log(typeof null)//object
⭐symbol:一般用于对象的属性命名.创建出来的是唯一值.
2.2 JS的复杂数据类型
⭐⭐⭐复杂数据类型:object:对象就是一组“键值对”(key-value)的集合，是一种无序的复合数据集合。
let obj = {
a:0,
b:1,
}
console.log(obj);//{ a: 0, b: 1 }
2.3 数据类型转换
⭐⭐⭐数据类型转换
1.显示转换：
parseInt(string),parseFloat(string),Number(mix)
toString(),String(),Boolean()
⭐parselnt():看是否有数字,有就会转换为数值.
console.log(parselnt("123Hello"));//123
console.log(parseInt("11.4"));//11,碰小数时会取整
⭐parseFloat():数值转浮点数,将小数点字符串转换为小数
⭐parselnt()和parseFloat()方法,移植到Nnmber类上面,是为了减少全局性方法,语言逐步模块化.
//Es5写法
console.log(parselnt("12.14"));//12
console.log(parseFloat("12.14#"));//12.14
//Es6写法
console.log(Number.parselnt("12.14"));
console.log(Number.parseFloat("12.14#"));
let a = "2.2";
console.log(Number.parseInt(a));//2
⭐Number.islnteger():判断一个值是否为整数.(1和1.0视为同一个值)
console.log(Number.islnteger(22));//true
console.log(Number.islnteger(22.0));//true
console.log(Number.islnteger(22.1));//false
⭐toString():该函数会将除了null和undefined以外的数据类型转换为字符串.
let a = 12;
console.log(typeof a.toString());//String
toString()函数在转换数值的时候可以带参数,可以将数值指定为几进制
let b = 100;
console.log(b.toString(2));//1100100
⭐ 引用数据类型都是先转换为字符串然后再转换为数字,symbol是不允许被转换
⭐Number():作为一个函数来调用
let c = `你好`;
let num = Number(c);//将变量c转换成number类型
console.log(typeof num);//number
console.log(Number("123Hello"));//NaN
let a = 12;
let b = Number(12);
consoloe.log(a===b);//true
⭐new Number():
let num = new Number(12);//把new Number()里面的12包装成对象
console.log(num);//[Number: 12]
console.log(typeof num);//object
2.隐士转换
console.log(typeof parseInt("3456"));//number
console.log(parseInt("3456cccc"));//3456
console.log(parseInt("nn3456cccc"));//NaN
console.log(parseInt(""));//NaN
console.log(parseInt("0039"));//39
console.log(parseInt("11.4"));//11
console.log(parseFloat(".44"));//0.44
console.log(Number(23456));//23456
console.log(Number("23456"));//23456
console.log(Number("23456ttt"));//NaN
console.log(Number(null));//0
console.log(Number(undefined));//NaN
let num77 = 123;
console.log(typeof num77.toString());//string---->tostring不可以用于:undefined和null
// Number(),String()--任何值都可以字符串化,Boolean()---除了false,"",0,NaN,undefined,null,全部为true
console.log(Boolean("哈哈哈"));
预期是数字的时候(使用Number())：
类型 转换前 转换后
number 4 4
string ‘1’ 1
string ‘abc’ NaN
string ‘’ 0
boolean true 1
boolean false 0
undefined undefined NaN
null null 0
预期为字符串的时候(使用toString())：
转为字符串 使用+号时候，会自动转换为字符串
预期为布尔的时候(使用Boolean())：
转换为布尔值,NaN,undefined,null,''”,0,NaN转为false,其余转为true
2.4 字符串模版
⭐ Es6中新增模板字面量,可以看作是增强版的字符串
let a = `12`;
console.log(typeof a);//string
2.5 简单值和复杂值的区别(扩展)
⭐简单值:表示javaScript中可用的数据或信息的最底层形式,不可细化的.并且简单值的数据固定大小,数据是存储与内存中得栈区里面.
⭐复杂值:内存中的大小是未知的,可以包含任何值,数据存储于堆区里面.
let obj = {
name:"xiehang",
age:18,
gender:true,
}
console.log(obj.age);//18
2.6 求位数运算
var num=654;
var baiwei=parseInt(num/100);//6.54取整 得到百位6
console.log(baiwei);
var shiwei=parseInt((num%100)/10);//num%100 得到的是54，然后/10取整 得到的是十位5
console.log(shiwei);
var gewei=parseInt(num%10);//num%10 得到的是4，模10取余;
console.log(gewei);
console.log('输出四位数:');
let i = input.question();
let ge = parseInt(i % 10);
let shi = parseInt((i % 100) / 10);
let bai =parseInt((i%1000)/100);
let qian = parseInt(i/1000);
console.log(ge,shi,bai,qian);
3. 运算符
1.字符串相关：+（拼接运算符）,``（模板运算符ES6）
2.算术运算符：+ , - , * , / , %(取模,求余), **(求幂ES6),++,--
3.比较运算符：> , >= , < , <= , == , === , != , !==
4.逻辑运算符：&&(并且),&(与) , ||(或者) , | ,!
5.赋值运算符: = , += , -= ,*= ,/= ,%=
6.三目运算符： 【1】?【2】:【3】
==============================================================================
1).模板运算符实现无缝拼接
特点:可换行(其中的空格,换行,制表都不会产生错误,且会被解析)
let name = "zhang3";
let age = 18;
let gender = "男";
console.log("姓名："+name+"\n性别："+gender+"\n年龄："+age);// \n:换行符, \t:制表符
console.log(`姓名：${name+0}\n性别：${gender}\n年龄：${age}`);
console.log(3**3);//27,3*3*3
//++,--分前缀和后缀，前缀表示先执行该运算，再参与其所在表达式，后缀恰好相反
(
变量名++{
1.计算返回结果,与变量相同
2.将变量的值自增1
}
++变量名{
1.计算返回结果,为变量值加1
2.将变量的值自增1
}
)
let x = 1;
x++;//2
++x;//3
x = x++;//3
x = ++x;//4
console.log(x);//4
let i = 0;
let num = i++ + ++i - --i;//i:0 2 1
console.log(num);//1
let x = 1;
x++;//2
console.log(x);//2
let y = x++;//1
console.log(y);//1
2).比较运算符的结果为boolean
==(等于) ===(全等于) !=(不等于) !==(全不等于)：“全”表示必须一模一样才会相等，没有类型的自动转换发生
console.log("ab"<"ac");//ASCII码
==============================================================================
3).逻辑运算符
⭐⭐⭐||(或者)
console.log(true || false && false);//true,执行顺序是从左到右
||:表达式1||表达式2
当表达式1 为true时,返回表达式1,且不会执行表达式2
当表达式1 为false时,返回表达式2
遇到||,先去左边的表达式得出结果，如果结果为true，则不会去执行右边的表达式，则短路运算生效；如果结果为false，则去执行右边的表达式，再去根据两边的结果去执行||运算符
⭐⭐⭐&&(并且)
||:表达式1 && 表达式2
当表达式1 为true时，返回表达式2
当表达式1 为false时，返回表达式1，且不会执行表达式2
区别：两个符号的代表短路操作。(短路：&&或者||,如果第一个操作数已经可以决定该运算的结果了,后面的不执行)
⭐%(求余)
let a = 8;
a %=3;//全局
console.log(a);//2
==============================================================================
⭐⭐⭐【1】?【2】:【3】--->表达式1为真的时候,执行表达式2，并且整个三目运算符的运算结果是表达式2的值;表达式1为假,则为表达式3执行,并产生结果
let age = 18;
console.log(age == "18"?"成年了":"未成年");
//用三目运算排序
let input = require("readline-sync");
console.log("输入你的第一个数");
let a = ~~input.question();//隐士转换，讲字符串改成number类型
console.log("输入你的第二个数");
let b = ~~input.question();
console.log("输入你的第三个数");
let c = ~~input.question();
let max = a>b?(a>c?a:c):(b>c?b:c);
let min = a<b?(a<c?a:c):(b<c?b:c);
let minddle = a + b + c - max - min;
console.log(`${max},${minddle},${min}`);
let x = 20;
const answer = x > 10?'great than 10' : 'less than 10';
4. 流程控制
当知道循环的次数时,建议使用for循环;
当不知道循环的次数时,建议使用while循环或do-while循环,一般while循环用的多一些。
流程控制:用于控制程序流程走向的语句
顺序结构:程序从上到下依次执行
⭐⭐⭐⭐选择结构:
1.条件可以填写哪些?
2.if后面的{}是必须的?
if:
1).单分支语句: if(条件){执行的代码}
2).双分支语句：if(条件){执行的代码}else{执行的第二段代码}
3).多分支语句：if(条件){执行的代码}else if(条件2){执行的代码}...else{执行的代码}
//根据用户输入的男生或者女生还有年龄判断,去做不同的事情
let input = require("readline-sync");
console.log("输入你的年龄");
let age = input.question();//获取用户的输入的数据
console.log("输入你的性别");
let gender = input.question();
if (gender == "man") {
if (age > 18) {
console.log("你是个成年男子,去工作");
} else {
console.log("你还未成年,请认真去读书");
}
} else if (gender == "woman") {
if (age < 18) {
console.log("你是未成年女生")
} else {
console.log("你已经是成年女生了");
}
}
console.log("请输入你的性别");
let gender = input.question();
console.log("请输入你的年龄");
let age = input.question();
if (gender == "man" && age <= 18) {
console.log("你是女生,请你去学习");
} else if (gender == "man" && age >= 18) {
console.log("你是女生,请你去上班");
} if (gender == "woman" && age <= 18) {
console.log("你是男生,请你去学习");
} else if (gender == "woman" && age >= 18) {
console.log("你是男生,请你去上班");
}
==============================================================================
//ABC排序
let input = require("readline-sync");
console.log("请输入第一个数");
let a = ~~input.question();
console.log("请输入第二个数");
let b = ~~input.question();
console.log("请输入第三个数");
let c = ~~input.question();
if (!(a > b)) {
let t = a;
a = b;
b = t;
}
if(!(a>c)){
let t =a;
a = c;
c = t;
}if(!(b>c)){
let t = c;
c = b;
b = t;
}
console.log(a,b,c);
//会员卡四位数(开头不为0)求和，会员卡四位数求和大于20时将返利50元，否则不返利根据用户输入的会员卡卡号(四位数)，判断是否返利
console.log('输入会员卡卡号:');
let number = input.question();
let a = parseInt(number % 10);//个位
let b = parseInt((number % 100) / 10);//十位
let c = parseInt(number / 100 % 10);//百位
let d = parseInt(number / 1000)//取整
if (a+b+c+d>20) {
console.log('返利50');
}else{
console.log('不返利');
}
//工资所得税工资超过1000的部分需要缴纳个人所得税（税率0.05），根据用户输入的工资，输出税后工资
console.log("请输入你的工资:");
let a = input.question();
if (a > 1000) {
a -= (a - 1000) * 0.05;
console.log(a);
} else {
console.log(a);
}
4.1 switch循环
⭐⭐switch
特点:
1.穿透效果:选中的case执行,但是switch语句没有结束,会依次从选择的位置往下,执行完所有代码
2.break:终止当前switch语句的继续执行;
注意：switch语句()内容不会根据case的值进行隐式转换,只能全等比较;js case后面是 允许放变量的.
3.default:来规定匹配不存在时做的事情
switch(表达式) {
case n:
代码块
break;
case n:
代码块
break;
default:
默认代码块
}
//输入你的考试成绩分数,90分以上:优秀,80分以上:良,70分以上:中单,60分以上:及格,60分一 下不及格
let input = require("readline-sync");
console.log("输入你的分数");
let number = input.question();//获取到用户输入
switch (parseInt(number / 10)) {//parseInt 显示转换
case 10:
case 9:
console.log("优秀");
break;
case 8:
console.log("良");
break;
case 7:
console.log("中等");
break;
case 6:
console.log("及格");
break;
case 5:
default:
console.log("不及格");
break;
}
==============================================================================
循环嵌套:一个循环嵌套另一个循环
跳转语句：
break:用于退出当前所在的整个循环或者switch
continue:跳过本次循环(剩下的循环体代码),继续下一次循环
return：关键字用于在函数或方法中返回一个值,并终止函数执行返回给谁?谁用的就返回给谁.
4.2 for循环
⭐⭐⭐⭐for 循环
1.执行"初始化表达式"
2.执行"条件判断表达式"
3.如果判断为true,执行循环体,否则退出循环
4.执行“修改循环条件表达式”
5.回到第二步
for(表达式1;表达式2;表达式3){循环体}====>表达式1:初始化表达式 表达式2：条件判断表达式 表达式3：修改循环条件表达式
⭐⭐⭐⭐JS中的for循环体比较特殊,每次执行都是一个全新的独立的块作用域,用let声明的变量传入到 for循环体的作用域后,不会发生改变,不受外界的影响
//输出1+2+3+4+....到100的和
let sum = 0;
for(let i = 1;i<=100;i++){//这一行全部是关于i的，循环的控制在i身上，可以通过这一行知道i的变化情况,以及循环次数-----像这样的变量i叫做循环控制变量
sum +=i;//也可以写成 sum = sum + i;
}
console.log(sum);
for (let i = 0; i <= 100; i++) {//输出100以内的奇数
if (i % 2 == 1) {
console.log(i);
}
}
for (let j = 1; j <= 100; j++) {//输出100以内的偶数
if (j % 2 == 0) {
console.log(j);
}
}
//输出1-100之间的质数
let str = "";
for (let i = 1; i <= 100; i++) {
let j;//这里形成块级作用域,如果把j写for循环里面,j就只有在for循环里面使用
for (j = 2; j <= i; j++) {
if (i % j == 0) {
break;
}
}
if (i == j) {//注意,这里使用了J变量
str += (i + ",");
}
}
console.log(str);
for (var i=2;i<=100;i++) { // 控制数字从2开始到100为止，i是除数
for (var j=2;j<i;j++) { // 控制被除数，j是被除数
if(i%j==0){ // 不是质数的条件
break; // 跳出当前循环
}
}
if (i<=j) { // 是质数
str += (i + ",");
}
}
console.log(str);
//判断一个数是不是质数
let input = require("readline-sync");
console.log("输入你要判断的数");
let number = input.question();
let sum = 0;
for (let i = 1; i <= number; i++) {
if (number % i == 0) {
sum++;
}
} if (sum == 2) {
console.log(`${number}是一个质数`);
} else {
console.log(`${number}不是一个质数`);
}
//九九乘法表
for (let index = 1; index <= 9; index++) {
let str = "";
for (let j = 1; j <= index;j++) {
str += `${index}x${j}=${index * j}\t`;
}
console.log(str);
}
//弹皮球,皮球从高度100m的位置向下掉落,每次掉落地面弹高10m,弹10次后,求球距离地面的距离
const h = 100;//高度100M
let sum = 0;//弹起的距离
let i = 1;
for (let index = 0; index < 10; index++) {
sum = sum + i * (h + h / 2)
i = i * (1 / 2);
}
console.log(sum);
//百鸡百钱：cock 公鸡5元一只 hen 母鸡3元一只 chick 小鸡1元3只,100元要买100只鸡?有多少买法?
1.for (let cock = 5; cock <= 20; cock++) {
for (let hen = 3; hen <= 33; hen++) {
let chick = 100 - cock - hen;
if ((cock + hen + chick == 100) && (cock * 4 + hen * 3 + chick / 3 == 100)) {
console.log(`有${cock}只公鸡,有${hen}母鸡,有${chick}只小鸡`);
}
}
}
2.for (let cock = 1; cock <=100; cock++) {
for (let hen = 1; hen <=100; hen++) {
for (let chick = 1; chick <=100; chick++) {
if (cock / 3 + hen / 5 + chick * 2==100 &&(cock + hen + chick ==100)) {
console.log(`公鸡买${cock/3}只,母鸡买${hen/5}只,小鸡买${chick*2}只`);
}
}
}
}
//5.使用循环打印出下面的三角形图案
let row = 10;
for (let index = 1; index <=row; index++) {//外层循环代表的是要循环的行数,外层循环一次,里面的循环执行全部
let str="";
for (let j = 1; j <=row-index; j++) {//这层循环代表的是要循环的空格数
str +=" ";
}
for (let k = 1; k <=index; k++) {
str += "* ";
}
console.log(str);
}
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * *
//倒立的等腰三角形
for (var i = 10; i >= 1; i--) {//外层循环代表的是要循环的行数,外层循环一次,里面的循环执行全部
var str= '';
for (var k = 0; k < 10-i; k++) {//这层循环代表的是要循环的空格数
str += ' ';
}
for (var j = 0; j < i; j++) {//内层循环代表的是要打印的列数
str +='* ';
}
console.log(str);
}
// 1,2,3,4.(4个数字能组成多少个互不相同且无重复数字的三位数？都是多少？)
let sum =0;
for (let a = 1; a <= 4; a++) {//123,124,134,132,142,143,213,231,241,243,234,214,312,321,314,341,324,342,
for (let b = 1; b <= 4; b++) {
for (let c = 1; c <= 4; c++) {
if (a != b && b != c && c != a) {
sum++;
console.log(''+a+b+c);
}
}
}
}
console.log(sum);
//输出100-999的水仙花数,是一种自幂数的一种,严格来说3位数的3次幂数才能称为水仙花数
for (let i = 100; i <=999; i++) {
let ge =parseInt(i%10);
let shi = parseInt((i%100)/10);
let bai = parseInt(i/100);
let sum = ge*ge*ge+shi*shi*shi+bai*bai*bai;
if (sum ==i) {
console.log(i);
}
}
//入职薪水10K,每年涨幅5%,50年后工资多少？
console.log('输入你的薪资:');
let money = input.question()-0;
console.log('输入工作年限:');
let year = input.question()-0;
for (let i = 1; i <= year; i++) {
money *=(1+0.05);
}
console.log(money.toFixed(2));
//计算斐波拉契数列：1 1 2 3 5 8 13 21…的前20项之和。斐波拉契数列：前两个数为1，从第三个数开始，数值为前两个数之和。例如：2=1+1, 3=1+2，5=2+3
let a = 1;
let b = 1;
let c = 2;//初始化变量
for (let i = 3; i <= 20; i++) {//从3开始循环
let temp = a + b;
a = b;//交换思想,将a,b的位置不断向后移动,即将原来b的值作为a的值,将原来temp的值作为b
b = temp;
c +=temp;//求和
}
console.log(c);
//4. 逢7过游戏，打印1-100，遇到能被7整除或者带7的数字打印“过”代替
for (let a = 1; a <= 100; a++) {
let ge = a % 10;//个位
let shi = parseInt(a / 10);//十位
if (a % 7 == 0 || a % 10 == 7 || ge == 7 || shi == 7) {
console.log('a' + '');
} else {
console.log(a + ',');
}
}
4.3 while循环
⭐⭐while循环
while(循环条件){循环体}：如果循环条件为true,执行循环体,再次判断循环条件.......
//1+...100的和
let n = 1;
let t = 0;
while (n <= 100) {
t = t + n;
n++;
}
console.log(t);
//一张纸的厚度是0.0001米，将纸对折，对折多少次厚度超过珠峰高度8848米
let h = 0.0001;
let sum = 0;
while (h<=8848) {
h *=2;
sum++;
}
console.log(sum);
4.4 do...while 循环
⭐⭐do...while循环
do...while:do{循环体}while(循环条件); 特色;先执行一次循环体（输入密码）
//+...100的和
let sum = 0;
let i = 1;
do
sum+=(i++);
while(i<=100);
console.log(sum);
5. 数组
⭐⭐⭐数组是一组数据(数据类型不限,任意)的有序集合;====>写代码时,一般一个数组只放一种数据类型的数据,数组的类型其实也是属于对象。
注意:大多数的语言里面数组的存储是连续的,但是js的数组特点决定了js的数组不一定是连续的。
数组的特点：
1.作用:将许多零散的数据组成一个整体;
2.数组本身属于复杂数据类型(引用数据类型/对象),即我们的数组就是“对象”
3.根据需要，对数组内部数据进行一些操作(增删查改),
数组的创建： 1.字面量的方式 2.构造函数的方式
1.let arr0 = [1,2,3,4,5,6];
2.let arr1 = new Array(1,2,3,4,5,6);
console.log(arr0[0]);//1
console.log(arr1[3]);//4
console.log(JSON.stringify(arr1))//[1,2,3,4,5,6]
数组的下标:数组中存储是数据时有序的,我们就给每一个元素加一个编号,称之为“下标”/"索引"index
索引特点:index从0开始,到 “数组元素个数-1” 结束
下标的使用:数组名称[index] ======> 查看数据:(查询时，越界？访问到一个undefined值,不管学什么语言,越界一般是不允许的)
1.修改数据
let arr0 = [1,2,3,4,5,6];
arr0[1] =1
console.log(arr0);//[ 1, 1, 3, 4, 5, 6 ]
2.增加数据:当我们的数组下标访问超过了里面元素的下标最大值时,会在赋值的同时,增加元素
arr0[6] =1
console.log(arr0)//[ 1, 1, 3, 4, 5, 6 ,1]
3.删除数据 delete 关键字
delete arr0[6] =1
console.log(arr0);//[ 1, 1, 3, 4, 5, 6 ,<1 empty item>]
⭐Arrary对象的length属性
console.log(arr0.length);//6
1.通过设置length的值(比原来数组length大),可以增加空元素undefined
let c = [];
c.length = 3;
console.log(c.length);//[ <3 empty items> ]
c[0] = 1;
c[1] = 2;
c[2] = 3;
2.设置length的值(比原来数组length小)可以删除元素
c.length = 1;
console.log(c);//[ 1 ]
3.将大于等于10的数字挑选出来，放入新的数组
let arr = [1, 2, 3, 4, 5, 11, 19, 56, 23, 12, 67, 45, 10];
let NewArr = [];
let j = 0;
for (var i = 0; i < arr.length; i++) {
if (arr[i] >= 10) {
//新数组下标从0开始计算。依次递增
NewArr[j] = arr[i];//将已经筛选好值的存给NewArr[j]
j++;//每存一次值,j++一次；
}
}
console.log(NewArr);
6.对象
JavaScript 中的对象（Object）是⼀组数据的⽆序集合.其中,每⼀条数据都是由键:值组成（例
如：name:'HanMeiMei' ）.其中,值可以是任意数据类型,⽽键是字符串类型.
let obj = {};//字面量方式
let obj2 = new Object();//构造函数⽅式,并创建一个空的对象
6.1 对象的属性
//当对象中某⼀条数据的键所对应的值是⾮函数类型,则我们将这条数据叫做对象的属性。
let student = {//name 和 age 两个键对应的值都不是函数,因此这两条数据我们就叫做 student 对象的属性.
name:'xiehang',
age:'20'
}
console.log(student);//{ name: 'xiehang', age: '20' }
⭐对象的操作
1.通过点运算符.来操作⼀个对象的属性。
let student = {
name:'xiehang',
age:'20'
}
student.name = '张三';//修改已有的属性
student.number = 69;//增加没有的属性
console.log(student);//{ name: '张三', age: '20', number: 69 }
2.通过⽅括号 [] 操作⼀个对象的属性
student['name'] = '李四';
student['gender'] = '男';
console.log(student);//{ name: '李四', age: '20', gender: '男' }
3.通过 delete 关键字来删除⼀个对象的属性.
delete student.name;
console.log(student);//{ age: '20', gender: '男' }
6.2 对象的方法
//当对象中某⼀条数据的键所对应的值是函数类型,则我们将这条数据叫做对象的⽅法。
let person = {
name:'xiehang',
introduce:function() {////introduce 键对应的值都是⼀个函数,因此这条数据我们就叫做 person 对象的⽅法。
console.log('my name is li si');
}
};
1.通过.运算符访问⼀个对象的⽅法。
person.introduce();//my name is li si,调⽤ person 对象的 introduce ⽅法
2.通过[]运算符访问⼀个对象的⽅法。
person['intrduce']();//调⽤ person 对象的 introduce ⽅法
3.通过 delete 关键字来删除⼀个对象的⽅法
delete person.intrduce;//方法名后面不跟括号
6.3 对象的遍历
1.for in
let traversal = {
name:'张三',
age:20,
gender:'男',
introduce:function(){
console.log('my name is lisi');
}
};
for (let key in traversal) {
console.log(key);//name age gender introduce
}
6.3 对象中的this
//对象的方法中可以使用this关键字
let foo ={
bar:function(){
console.log(this);
}
};
foo.bar();//对象⽅法中的 this 永远指向调⽤该⽅法时.或{}前的那个对象。如上例中 bar ⽅法的 this 就⼀定指向 foo对象
let traversal = {
name: '张三',
age: 20,
gender: '男',
introduce: function () {
console.log('my name is'+this.name);
}
};
traversal.introduce();//my name is 张三
6.4 对象的扩展
⭐ 对象的解构
let a = 1;
let b = 2;
let obj={a,b};
const {a:ua,b:ub}=obj;
console.log(`${ua},${ub}`);//1,2
const user2={name:'啊啊啊',age:16,protecotr:'哈哈哈',address:'熊本'}
const {name:uName,age:uAge,protecotr:uprotecotr,address:uaddress}=user2
console.log(`${uName},${uAge},${uprotecotr},${uaddress}`)
