// 声明变量
// 在js中使用var关键字来声明一个变量
var a;
// 为变量赋值
a=123;
a=456;
// 声明和赋值同时进行
var b=789;
console.log(b);
alert("我是内部伞兵")
// boolran 布尔值
// 布尔值有两个,主要用来做逻辑判断
// true -表示真
// false -表示假
// 使用typeof检查一个布尔值,会返回Boolean
var bool=true;
console.log(typeof bool);
// 将其他的数据类型转换为boolean
// 使用boolean()函数
// -数字----->布尔
// -除了0和NAN,其余的都是true
// -字符串----->布尔
// -除了空串,其余的都是true
// null和undefined都是false
// 对象也会转换成true
var a=123; // true
a=-123;// true
a=0;// false
a=Infinity;// true
a=NaN;// false
// 调用boolean()函数来将a转换为布尔值
a=Boolean(a);
console.log(typeof a);
console.log(a);
// 算数运算符
// 当对非Number类型的值进行运算时,会将这些值转换为Number然后
// 任何值和NAN做运算都得NAN
// 可以对两个值进行加法运算,并将结果返回
// 如果对两个字符串进行加法运算,则会做
var a=123;
var result=typeof a;
// console.log(typeof result);
result=a+1;
result=456+789;
result=true+false;
result=2+null;
result=2+NaN;
result="123"+"456";
console.log(result);
// 符合两边只有一个操作数的符号就是一元运算符;主要有两种:“++”“--”
// 当不出现赋值时,执行自增(自减)运算;但是出现赋值时,先赋值,后运算;
// “++”运算符他是一种自增运算符,eg:var a=2; a++; console.log(a); 结果为:3、、a++相当于a=a+1
// “--”运算符他是一种自减运算符,eg:var a=2; a--; console.log(a); 结果为:1、、a++相当于a=a-1;
// 运算符后置(eg:a++)
var a=5;
var b=a++;//先赋值,后运算
console.log(a);// a=6
console.log(b);b=5
// 运算符前置(eg:++a)
// 当不出现赋值时,执行自增(自减)顺序,但出现赋值时,先赋值,后运算。
var a=5;
var b=++a;//先运算,后赋值;
console.log(a);//a=6
console.log(b);//b=6
// ++num相当于num=num+1;
// num–相当于num=num-1;
// 前置型是在进行算术运算之前再进行自增或自减运算。
// 后置型实在进行算术运算之后再进行自增自减运算。
var a = 2,
b = 6,
c;
a++;
b--;
console.log(a); //3
console.log(b); //5
c = (a++) + (++b) + (a--) + (a+b) + b;
/*
对c的运算进行拆分
var a1 = a++; //3
var a2 = ++b; //6
var a3 = a--; //3
var a4 = a+b; //9
var a5 = b; //7
c = a1 + a2 + a3 + a4 + a5; //28
*/
console.log(c); //28
/*
JavaScript 中的逻辑运算符可用来确定变量或者是值之间的逻辑关系。通常用于布尔型值,
会返回一个布尔值true 或 false。而 &&、|| 运算符能够使用非布尔值的操作数,
此时会返回一个非布尔型值。
*/
//逻辑与操作符
// 逻辑与 &&操作符,如果第一个操作数为 true,计算结果就是第二个操作数。
// 如果第一个操作数为 false,结果就是 false(特殊数值除外)
console.log(true && true); // true 操作数为true则结果为第二个操作数
console.log(true && false); // false
console.log(true && 10); // 10
console.log(true && (4 > 7)); // false
console.log(false && 10); // false 操作数为false则结果为false
console.log(false && ""); // false
console.log(" " && 0); // 0
console.log(2 && 7); // 7
// 逻辑或 || 操作符,如果第一个操作数能够转为 true(不是 false),结果就是第一个操作数,
// 否则结果是第二个操作数。
console.log(true || true); // true 第一个操作数为true则结果为第一个操作数
console.log(true || false); // true
console.log(true || 10); // true
console.log(true || (4 > 7)); // true
console.log(false || 10); // 10 第一个操作数不是true,则结果为第二个操作数
console.log(false || ""); //
console.log(false || 0); // 0
console.log(0 || 7); // 7
// 逻辑非 ! 操作符,首先把数据转化为布尔值,然后取反,结果为 true 或 false。
//例如true 本来就是布尔值,取反会得到 false。false 取反会得到 true:
console.log(!true); // false
console.log(!false); // true
console.log(!0); // true
console.log(!""); // true
console.log(![1, 2, 3]); // false
// 非布尔值的与运算是短路的,即在判断第一个为false后,就不会再判断第二个
var a = 123 && 0;
console.log(a);//a = 123
var a = 0 && 123;
console.log(a);//a = 0;第一个为0,直接返回,不再判断123
var a = NaN && 0;
console.log(a);//a = NaN
// 非布尔值的或运算也是短路的,即在判断第一个为true后,就不会再判断第二个
var a = 123 || 0;
console.log(a);//a = 123;第一个为true则直接返回该值,不再判断第二个
var a = 0 || 123;
console.log(a);//a = 123
var a = NaN || 0;
console.log(a);//a = NaN
var a = "" || "123";//""判断为false
console.log(a);//a = "123"
// 用于进行比较的运算符称作为关系运算符:小于(<)、大于(>)、小于等于(<=)、大于等于(>=)、相等(==)、不等(!=)、
// 全等(恒等)(===)、不全等(不恒等)(!==)
/*
1、两个操作数都是数值,则数值比较;
2、两个操作数都是字符串,则比较两个字符串对应的字符编码值;
3、两个操作数有一个是数值,则将另一个转换为数值,再进行数值比较;
4、两个操作数有一个是对象,则先调用valueOf()方法或toString()方法,再用结果比较;
*/
var box=3 > 2; //true
var box=3 > 22; //false
var box= '3' > 22; //false
var box= '3' > '22'; //true
var box= 'a' > 'b'; //false a=97,b=98
var box= 'a' > 'B'; //true B=66
var box= 1 > "对象"; //false,如果有toString()或valueOf()则返回1 > 返回数的值
/*
1.一个操作数是布尔值,则比较之前将其转换为数值,false转成0,true转成1;
2.一个操作数是字符串,则比较之前将其转成为数值再比较;
3.一个操作数是对象,则先调用valueOf()或toString()方法后再和返回值比较;
4.不需要任何转换的情况下,null和undefined是相等的;
5.一个操作数是NaN,则==返回false,!=返回true;并且NaN和自身不等;
6.两个操作数都是对象,则比较他们是否是同一个对象,如果都指向同一个对象,则返回true,否则返回false。
7.在全等和全不等的判断上,比如值和类型都相等,才返回true,否则返回false。
*/
var box = 2 == 2; //true
var box = '2' == 2; //true,'2'会转成成数值2
var box = false == 0; //true,false转成数值就是0
var box = 'a' == 'A'; //false,转换后的编码不一样
var box = 2 == {}; //false,执行toString()或valueOf()会改变
var box = 2 == NaN; //false,只要有NaN,都是false
var box = {} == {}; //false,比较的是他们的地址,每个新创建对象的引用地址都不同
var age = {};
var height = age;
var box = age == height; //true,引用地址一样,所以相等
var box = '2' === 2 //false,值和类型都必须相等
var box = 2 !== 2 //false,值和类型都相等了
//条件运算符是唯一的三元运算符,其语法格式如下:
// b ? x : y
// 如果操作数 b 的返回值为 true,则执行 x 操作数,并返回该表达式的值。
// 如果操作数 b 的返回值为 false,则执行 y 操作数,并返回该表达式的值。
//定义变量 a,然后检测 a 是否被赋值,如果赋值则使用该值;否则设置默认值。
var a = null; //定义变量a
typeof a != "undefined" ? a = a : a = 0; //检测变量a是否赋值,否则设置默认值
console.log(a); //显示变量a的值,返回null
//条件运算符可以转换为条件结构:
if(typeof a != "undefined"){ //赋值
a = a;
}else{ //没有赋值
a = 0;
}
console.log(a);
// 也可以转换为逻辑表达式:
(typeof a != "undefined") && (a =a) || (a = 0); //逻辑表达式
console.log(a);
/*
if语句:
语法:
if(判断条件){
代码块;
}
执行规则:
当判断条件成立(true)时,执行代码块
*/
// 例
var a=10;
if(a<=5){
console.log('run');
}
console.log('end');
// 例
var score=prompt('请输入成绩');//弹出输入框
if(score>=80){
alert('考试合格');
}
alert('不合格');
// if......else语句的语法
/*
if...else 语句
语法:
if(判断条件){
代码块1;
}else{
代码块2;
}
执行:当判断条件成立时,执行代码块1;否则,执行代码块2
*/
var score=prompt('请输入考试成绩');
if(score>=80){
alert('合格');
}else{
alert('补考');
}
// if......else if....多分支语句的语法
// if..else if... 多分支语句
// 语法:
// if(判断条件1){
// 代码块1;
// }else if(判断条件2){
// 代码块2;
// }
// ...
// else if(判断条件n){
// 代码块n;
// }else{
// 代码块;
// }
// 执行规则:若判断条件1成立,则执行代码块1
// 若判断条件2成立,执行代码块2
// 若以上条件均不成立,则执行else
// 例
// 根据用户输入输出结果:若今天是星期日,则出去旅游;星期六,去游泳,其它时间上班
var week=prompt('请输入今天是星期几?');
if(week=='星期六'){
console.log('去游泳');
}else if(week=='星期日'){
console.log('去旅游');
}else{
console.log('上班');
}
// 例
var age=prompt('请输入您的年龄:');
if(age>65){
console.log('老年');
}else if(age>35){
console.log('中年');
}else if(age>22){
console.log('青年');
}else if(age>18){
console.log('青少年');
}else{
console.log('未成年');
}
// 定义一个变量,表示当前的钱数
var money=1000;
// 定义一个计数器
var count=0;
// 定义一个while循环来计算每年的钱数
while (money<5000){
money*=1.05;
// 使count自增
count++;
}
console.log("一共需要"+count+"年");
arr=[1,2,3,4];
//普通for循环
for(i=0;i
console.log(i,arr[i]);
}
//for..in,遍历对象的属性(数组下标也算)。
for (property in arr) {
console.log(property, arr[property]);
}
// 用for..of遍历数组对象。只会遍历属于数组本身的值。
for (element of arr) {
console.log(element);
}
/*用iterable.forEach(callbackFn,?thisArg)`遍历。
ES6标准引入了新的iterable类型, Array、Map和Set都属于iterable类型。
具有iterable类型的集合可以通过新的for ... of循环来遍历。
*/
arr.forEach(function(value,key,arr){
console.log(key,value,arr);
})
/*
在页面中接收一个用户输入的数字,并判断该数是否是质数
质数:只能被1和它自身整除的数,1不是质数也是合数,质数必须必要是大于1的自然数
*/
var num=prompt("请输入一个大于1的整数:")
// 判断这个值是否合法
if(num<=1){
alert("该值不合法!");
}else{
// 创建一个变量来保存当前的数的状态
// 默认当前num是质数
var flag=true;
// 判断num是否是质数
// 获取2-num之间的数
for(var i=2;i
// 判断num是否能被i整除
if(num%i==0){
// 如果num能被i整除,则说明num一定不是质数
flag=false;
}
}
// 如果num是质数则输出
if(flag){
alert(num+"是质数!!!");
}else{
alert("这个不是质数!")
}
}
let items=[
{id: 0, name: '01', url: '..1'},
{id: 1, name: '02', url: '..1'},
{id: 2, name: '03', url: '..1'},
{id: 4, name: '04', url: '..1'},
]
var nums = 4;//预设值
var dataSize = items.length;
var columns = dataSize/ nums;
var ul = '';
var li = '';
for(let i= 0; i< dataSize; i++){
for(let j= 0; j< columns; j++){
if(i/ nums == j){
li = '';//这里置空li,避免重复塞入
for(let m= i; m< (j+ 1)* nums ; m++){
li += ''+items[m].name+''
}
ul += ''+li+''
}
}
}
console.log(ul);//这里完成。
// for循环练习
// 九九乘法表
for(var i=1;i<=9;i++){
for(var j=1;j<=i;j++){
document.write(""+j+"*"+i+"="+i*j+" ");
}
// 输出一个换行
document.write("
");
}
body{
width: 2000px;
}
span{
/* display: inline-block; */
width: 80px;
}
// break和continue都是用来控制循环结构的,主要是停止循环。
// 在某种条件出现的时候终止循环而不是等到循环条件为false才终止。
// 这时可以使用break来完成。break用于完全结束一个循环,跳出循环体执行循环后面的语句。
function fn(){
for(var i=0;i<5;i++){
if(i%2!=0){
break;//结束结构
}
console.log(i);
}//0
console.log("ha");
}
// continue只是终止本次循环,接着还执行后面的循环
function fn() {
for(var i=0;i<5;i++){
if(i%2==0){
continue;
}
console.log(i);
}//1 3
console.log("ha")
}
fn();
// return
// return 停止了这个for循环,跳出循环并且停止执行fn函数里后边的语句
function fn() {
for(var i = 0; i < 5; i++) {
if(i == 3) {
return;
}
console.log(i);
}
console.log("ha")
}
fn();
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)