JavaScirpt 一些基本知识

var name = prompt('请输入你的姓名:'); //弹出输入框
var age = prompt('请输入你的年龄');
var sex = prompt('请输入你的性别');

　　

检测字符串的长度用 变量名+length
字符串拼接 用+

转换为字符串类型

字符串转换为数字类型parseInt和parseFloat
parseInt('String')可以把字符型转换为数字型,得到是整数
parseFoat('变量') 注意大小写
其他类型转成布尔类型 Boolean()函数 代表空,否定的值会被转换为false

//计算年龄案列

        var chu = prompt('请输入你的出生年份');
        var jinnian = 2020 - chu;  //减法有隐式转换
        alert('你今年已经' + jinnian + '岁了');
        

//加法器
          定义弹出框,输入数值,保存在变量中
          将数值进行相加
         赋值给新的变量要注意数据类型转换
          弹出警示框,输出结果即可

        var num1 = prompt('请你输入第一个值');
        var num2 = prompt('请你输入第二个值');
        var sum = parseFloat(num1) + parseFloat(num2);
        alert('结果' + sum);     

递增运算符练习
        //后置自增 先表达式返回原值,后变量再自加1
        //前置自增 先自加 后运算 (前加后算)

        var a = 10;
        var f = a++ + ++a; //1,a++等于10  a =11  2,a = 12   ++a等于12
        console.log(f); //

//if语法结构

        var age = prompt('请输入你的年龄');
        if (age >= 18) {
            //执行语句
            alert('恭喜你可以进入网吧');
        } else {
            prompt('你不可以进入网吧!请返回');
        }

        //if语句案例演示
        //闰年的案例
        var yeas = prompt('请输入想要检测的年份');
        if ( yeas %4 ==0 && year %100 != 0 ||year%400== ) {
            alert('这是闰年');
        } else {
            alert('这是平年');
        }

//判断是否中奖
        var name = prompt('请输入姓名');
        if (name = '刘德华') {
            alert('恭喜你中了5块钱');
        } else {
            alert('很遗憾你没有中奖');
        }

//多分支语句

        if ( 条件表达式 ) {
            //语句1
        } else if () {
            //语句2
        } else if () {
            //语句3
        } else {
            //最后的语句
        }

三元表达式
条件表达式 ? 表达式1 :表达式2;

switch语句 表达式的值和case后面的选项值相匹配,则执行case里面的语句,最后没有匹配上则执行default里面的语句
变量里的值和数据类型一致, 大多用于确定值的情况, 结构清晰

 switch (表达式) {
            case value:
                执行语句1;
                break;
            case value2:
                执行语句2:
                break;
            default:
               执行最后的语句
        }

switch语句案例演示

        var fru = prompt('请输入你想要查询水果的名称');
        switch (fru) {
            case '苹果':
                alert('苹果的价格5/斤');
                break;
            case '雪梨':
                alert('雪梨的价格10/斤');
                break;
            default:
                alert('不好意思,今日没有这种水果');
        }

         //for循环
        //重复某些相同代码

        for (初始化变量; 条件表达式(终止条件); 操作表达式) {
            //循环体
        }

        var num = prompt('请输入班级的总人数');
        var sum = 0;
        var avg = 0;
        for (var i = 1; i <= num; i++) {
            var score = prompt('请输入第' + i + '个同学的成绩')
            //因为从prompt取过来的数据是 字符串型的需要转换为数字型
            sum = sum + parseFloat(score);

        }
        avg = sum / num;
        alert('班级成绩是' + sum);
        alert('班级平均分是' + avg);

        //九九乘法表

        var str = '';
        for (var i = 1; i <= 9; i++) {//外层循环控制行数
            for (var j = 1; j <= i; j++) {//内层循环控制每一行的个数
                //1*2=2
                str += j + '*' + i + '=' + i * j + '\t';
            }
            str += '\n';
        }
        console.log(str);

断点调试 观察程序运行的过程
while和do while 执行顺序不一样 ,while 先判断后执行 ,do while 先执行一次再判断执行
while和do while 执行次数不一样 ,while可能一次都不执行,do while 至少执行一次循环体
continue 关键字 退出本次(当前)循环,继续执行剩余次数循环
break 关键字 跳出整个循环(循环结束)
求1-100之间,除了能被5整除之外的整数和

var sum = 0;
        for (var i = 1; i < 15; i++) {
            if (i % 5 == 0) {
                continue;
            }
            sum += i;
        }
        console.log(sum);

标识符命名规范

变量和函数命名必须要有意义
变量一般用名词
函数一般用动词

操作符
左右两侧保留一个字符
单行注释注意签名有个空格

数组里得数据用逗号隔开

索引号从0开始
数组访问 数组名[索引]
遍历数组(类似早上点名)
数组长度 数组名.length 动态监测数组元素得个数
后面可以修改数组索引的方式追加数组元素,不要直接给数组名赋值,否则会覆盖原值

遍历数组案例
i是计数器,当索引号使用 || 如果相加的是数组元素arr[i]

var Hero = ['关羽', '张飞', '马超', '黄忠', '赵云'];
for (var i = 0; i < Hero.length; i++) {
console.log( Hero[i] );
}

将数组内大于等于10的元素选出来,放入新数组
声明新的数组存放数据newarr
遍历旧数组,找出大于等于10的元素
依次追加给新数组 newarr

 var arr = [2, 22, 33, 44, 55, 66];
        var newArr = [];
        var j = 0;
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] >= 10) {
                //新数组索引号应该从0开始,依次递增
                newArr[j] = arr[i];
                j++;
            }
        }
        console.log(newArr);

　　

//冒泡排序

var arr = [5, 4, 3, 2, 1];
for (var i = 0; i <= arr.length - 1; i++) { //外层循环趟数 arr.length-1
for (var j = 0; j <= arr.length - i - 1; j++) { //里面的循环 每一趟的交换次数 arr.length -1 -i
//内部交换2个变量的值,前一个和后一个数组元素相比较
if (arr[j] > arr[j + 1]) {
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
console.log(arr);

 //函数

        function add(形参1, 形参2) {//形参:形式上的参数,接受实参,默认值为undefined
             没有return,返回undefined
        }
        函数名(实参1, 实参2);//实参:实际的参数
        function getsum(num1, num2) {
            return getsum;
        }
        getsum(1,2);//函数名() = return;

实际开发,经常用一个变量接受函数的返回结果
return 特点 :1终止函数,2后面的代码不会被执行,3只能返回最后一个值,4用数组返回多个值

arguments函数里面内置这个对象,里面存储了传递的所有实参,伪数组,1具有数组的length属性,2按照索引号的方式进行存储,3没有真正数组的一些方法

函数两种声明方式

1,利用关键字自定义函数

2,函数表达式(匿名函数) 跟声明变量差不多 变量名();调用 ,也可以传递参数

var 变量名 = function() {};

 var a = b = c = 9;

　　

相当于 var a = 9; b = 9; c = 9; b和c直接赋值 没有var赋值,当全局变量看

创建对象
使用对象
(1)调用对象的属性 一般采用 对象名.属性名 /对象名['属性名']
(2) 调用对象的方法 对象名.方法名()

字面量

        var obj = {
            uname: '李白',
            age: '66',
            sex: '男',
            say: function () {  // 方法名冒号后面跟的是一个匿名函数(函数表达式)
                console.log("你好吗");
            }
        }

　　

        // 创建对象案例演示
        // 第一种
        var dog = {
            name: '可可',
            type: '阿拉斯加犬',
            age: 5,
            color: 'red',
            barkasf: function () {
                console.log('可可会汪汪汪');
                console.log('可可还拍过电影呢');
            }

        }
        console.log(dog.name);
        console.log(dog.age);
        console.log(dog.type);
        console.log(dog.color);
        console.log(dog.barkasf());
        // 第二种
        var obj = new Object();
        obj.uname = '鸣人';
        obj.age = 19;
        obj.sex = '男';
        obj.skill = function () {
            console.log('我会影分身之术');
        }
        console.log(obj.uname);
        console.log(obj.age);
        console.log(obj.sex);
        console.log(obj.skill());

         //  第三种 构造函数创建对象  把对象里面的一些相同属性和方法封装到函数里面

        //构造函数名字首字符要大写  抽象了对象的公共部分 泛指某一大类,类似JAVA的类
        //构造函数不需要return,就可以返回结果
        //构造函数语法格式

        function 构造函数名() {
            this.属性 = 值;
            this.方法 = function () {

            }
        }
        new 构造函数名(); //调用函数就创建了一个对象

        //构造函数案例演示

        function Hero(uname, ttype, blood,attack) {
            this.name = uname;
            this.type = ttype;
            this.blood = blood;
            this.attack = attack;

        }

        // 调用函数就是创建了对象
        var lianpo = new Hero('廉颇', '力量型', 500, '近战');

        console.log(lianpo.name);
        console.log(lianpo.type);
        console.log(lianpo.blood);
        console.log(lianpo.attack);
        var houyi = new Hero('后羿', '射手型', 100, '远程');
        console.log(houyi.name);
        console.log(houyi.type);
        console.log(houyi.blood);
        console.log(houyi.attack);

        function computer(color, weight, type) {
            this.color = color;
            this.weight = weight;
            this.type = type;
            this.watch = function () {
                console.log('看电影');
            }
        }

        var thinkPad = new computer('黑色', '1.7kg', '联想');
        console.log(thinkPad.type);
        console.log(thinkPad.color);
        console.log(thinkPad.weight);
        console.log(thinkPad.watch);

fot...in 用于对数组或者对象的属性进行循环操作 遍历对象
k 变量 输出 得到的是 属性名
对象[变量] 得到是属性值

 for (var k in dog) {
            console.log(dog[k]);
        }

　　

        //猜数字游戏

        function getMath(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        }
        var random = getMath(1, 30);
        while ( true ) {
            var num = prompt('输入数字');
            if (num > random) {
                alert('猜大了');
            } else if (num < random) {
                alert('猜小了');
            } else {
                alert('恭喜,宾果');
                break;
            }

        }

　　

   var date = new Date();
        console.log(date);

　　

创建数组的两种方式

1, 利用数组字面量
 2, 利用new Array() 创建了一个空的数组

检测是否为数组
 1, instanceof 运算符
 2, Array.isArray(参数)

reverse(); 翻转数组
sort(function( a, b){ 数组排序(冒泡排序)
return a - b;升序
return b - a;降序
});

　　

返回数组元素索引号方法 indexOf(数组元素); 找不到元素则返回 -1 lastIndexOf 后面找
toString() 将数组转换为字符串
join(分隔符)