数据类型、运算符、流程控制语句

1、JavaScript 定义了几种数据类型? 哪些是原始类型?哪些是复杂类型?原始类型(或基本数据类型)和复杂类型的区别是什么?

最新的 ECMAScript 标准定义了 7 种数据类型:

  • 6种原始类型(也称基本数据类型):
    • Number:整数和浮点数值(所谓浮点数值,就是该数值中必须包含一个小数点,并且小数点后面必须至少有一位数字)。
    • String:String类型用于表示由零或多个16位Unicode字符组成的字符序列,即字符串。字符串可以由双引号或单引号表示。
    • Boolean:Boolean类型只有两个字面值:true和false。
    • Undefined:Undefined类型只有一个值,即特殊的undefined。在使用var声明变量但未对其初值化时,这个变量的值就是undefined。对未声明的变量执行typeof操作符同样也会返回undefined值。
    • Null:Null类型是第二个只有一个值的数据类型,这个特殊的值 是null。null值表示通常有意地指向不存在或无效的对象或地址的引用,从逻辑角度看,null值表示一个空对象指针,而这也正是使用typeof操作符检测null值时会返回“object”的原因。如果定义的变量准备在将来用于保存对象,那么最好将该变量初始化为null而不是其他值。
    • Symbol :(ECMAScript 6 新定义)
  • 1种复杂数据类型:
    • Object:ECMAScript中的对象其实就是一组数据功能的集合。对象可以通过执行new操作符后跟要创建的对象类型的名称来创建。Object有三个子类型狭义的对象- 正则表达式(regexp),数组(array),函数(function)。

原始类型(或基本数据类型)和复杂类型的区别:

  1. 在内存中的存储方式: 基本数据类型把数据名和值直接存储在栈当中。 复杂数据类型在栈中存储数据名和一个堆的地址,在堆中存储属性及值。访问时先从栈获取地址,再到堆中拿出相应的值。
  2. 不同数据类型作为参数时,函数内部对参数的修改是否改变外部变量的值 (1)基本数据类型作为参数时,函数内部对参数值的修改不会改变外部变量的值
function a(s){//定义以s为参数的函数,返回s的值


    s=100;


    return s;


    }


    var y=1;


    a(y);//y作为参数调用函数a


    console.log(y);//y还是为1

结果还是1因为把y的值给s时是简单的复制了一份,y和s可以单独操作不相互影响

(2)复杂数据类型作为参数时,函数内部对参数值的修改会改变外部变量的值

因为复杂数据类型赋值是把栈中对象的地址赋给变量,函数内外两个变量指向同一个对象,所以只要对象的属性值改变,两个变量值都会改变

function student(age,name,agrde){


    this.age=age;


    this.name=name;


    this.score=agrde;


    }




    var s1=new student(18,"wjq",2);//创建一个student对象

    function a(s){


    s.name=”xxx”;


    }


    a(s1)//把s1赋给s


    console.log(s1.name);//输出xxx

原始类型和对象的区别主要还是在内存中的保存形式,要弄懂js中简单数据类型和复杂数据类型的区别,关键还要搞懂两个在内存中的存储过程。

2.typeof和instanceof的作用和区别?

JavaScript有三种方法,可以确定一个值到底是什么类型。

  • typeof 运算符
  • instanceof 运算符
  • Object.prototype.toString.call() 方法

typeof 运算符

最常用的是 typeof 运算符,返回一个值的数据类型有以下几种结果:

  • "undefined" : 如果一个变量没有声明,或声明了而没有初始化;
// 变量声明了,但没有赋值
var i;
i // undefined

// 调用函数时,应该提供的参数没有提供,该参数等于undefined
function f(x) {
  return x;
}
f() // undefined

// 对象没有赋值的属性
var  o = new Object();
o.p // undefined

// 函数没有返回值时,默认返回undefined
function f() {}
f() // undefined
  • "boolean" : 如果这个值是布尔值;
typeof false // "boolean"
typeof true // "boolean"
  • "string" : 如果这个值是字符串;
typeof '345' // "string"
  • "number" : 如果这个值是数值;
typeof 345 // "number"
  • "object" : 如果这个值是对象(包括数组、正则表达式)或null;
var s1=new Object();
typeof s1 //"object"

var arr1=[1,2,3];
typeof arr1 //"object"

var pattern= /at/g;
typeof pattern //"object"

typeof null // "object"
  • "function" : 如果这个值是函数。
var f= function() {};
typeof f //"function"

注意:

  • null的返回值是object,这是由于历史原因造成的,1995年JavaScript语言的第一版,所有值都设计成32位,其中最低的3位用来表述数据类型,object对应的值是000。当时,只设计了五种数据类型(对象、整数、浮点数、字符串和布尔值),完全没考虑null,只把它当作object的一种特殊值,32位全部为0。这是typeof null返回object的根本原因。 为了兼容以前的代码,后来就没法修改了。这并不是说null就属于对象,本质上null是一个类似于undefined的特殊值。

instanceof 运算符

instanceof是判断指定对象是否为某个构造函数的实例,返回值是truefalse

var v = new Object();
v instanceof Object // true

上面代码中,对象v是构造函数Object的实例,所以返回true。

instanceof运算符的左边是实例对象,右边是构造函数。它会检查右边构建函数的原型对象,是否在左边对象的原型链上。因此,下面两种写法是等价的。

v instanceof Object
// 等同于
Object.prototype.isPrototypeOf(v)

由于instanceof对整个原型链上的对象都有效,因此同一个实例对象,可能会对多个构造函数都返回true。

var d = new Date();
d instanceof Date // true
d instanceof Object // true

上面代码中,d同时是Date和Object的实例,因此对这两个构造函数都返回true。 instanceof的原理是检查原型链,对于那些不存在原型链的对象,就无法判断。

null instanceof Object // false

由于null 没有 prototype,即不存在原型,因此instanceof就认为该对象不是Object的实例。

JavaScript 之中,只要是对象,就有对应的构造函数。因此,instanceof运算符的一个用处,是判断值的类型。

var x = [1, 2, 3];
var y = {};
x instanceof Array // true
y instanceof Object // true

上面代码中,instanceof运算符判断,变量x是数组,变量y是对象。

注意,instanceof运算符只能用于对象,不适用原始类型的值。

var s = 'hello';
s instanceof String // false

上面代码中,字符串不是String对象的实例(因为字符串不是对象),所以返回false。

此外,对于undefined和null,instanceOf运算符总是返回false。

undefined instanceof Object // false
null instanceof Object // false

用法上的区别:

typeof 对数组 [] 和对象 {} 的返回值都是Object,无法区分数组和对象,但是instanceof可以区分。

var a = {};
var b=[];
typeof a // "object"
typeof b // "object"
a instanceof Array // false
a instanceof Object // true
b instanceof Array // true
b instanceof Object // true

3、如何判断一个变量是否是数字、字符串、布尔、函数

使用typeof 运算符可以判断一个变量是否是数字、字符串、布尔、函数。

数字

var a=1;
typeof a // 'number'

字符串

var b="string";
typeof b // "string"

布尔

var c=true;
typeof c //true

函数

var f=function() {};
typeof f // "function"

4.NaN是什么? 有什么特别之处?

(1)含义

NaN是 JavaScript 的特殊值,表示“非数字”(Not a Number),主要出现在将字符串解析成数字出错的场合。

100 - 'a' // NaN

上面代码运行时,会自动将字符串a转为数值,但是由于a不是数值,所以最后得到结果为NaN,表示它是“非数字”(NaN)。

需要注意的是,NaN不是一种独立的数据类型,而是一种特殊数值,它的数据类型依然属于Number,使用typeof运算符可以判断出来。

typeof NaN // 'number'

(2)特别之处

NaN不等于任何值,包括它本身。

NaN === NaN // false

由于数组的indexOf方法,内部使用的是严格相等运算符,所以该方法对NaN不成立。

[NaN].indexOf(NaN) // -1

NaN在布尔运算时被当作false。

Boolean(NaN) // false

NaN与任何数(包括它自己)的运算,得到的都是NaN。

NaN + 12 // NaN
NaN - 12 // NaN
NaN * 12 // NaN
NaN / 12 // NaN

(3)判断NaN的方法

isNaN方法可以用来判断一个值是否为NaN。isNaN()函数接受一个参数,该参数可以是任何类型,而函数会判断这个参数是否"不是数值"。isNaN()在接收到一个值之后,会尝试将这个值转换为数值。某些不是数值的值会直接转换为数值,例如"10"和"Boolean"。而任何不能被转换为数值的值都会导致这个函数返回true。

isNaN(NaN) // true
isNaN(123) // false
isNaN("123") // false
isNaN("123string") // true

isNaN只对数值有效,如果传入其他值,会被先转成数值。

出于同样的原因,对于对象和数组,isNaN也返回true。

isNaN({}) // true
// 等同于
isNaN(Number({})) // true

isNaN(['xzy']) // true
// 等同于
isNaN(Number(['xzy'])) // true

但是,对于空数组和只有一个数值成员的数组,isNaN返回false。

isNaN([]) // false
isNaN([123]) // false
isNaN([123,567]) // true
isNaN(['123']) // false

上面代码之所以返回false,原因是这些数组能被Number函数转成数值。

判断NaN更可靠的方法是,利用NaN是JavaScript之中唯一不等于自身的值这个特点,进行判断。

function IsNaN(value) {
  return value !== value;
}

5.如何把非数值转化为数值?

有三个函数可以把非数值转换为数值:

  • Number()
  • parseInt()
  • parseFloat()

Number()

转型函数Number()可以用于任何数据类型,而另外两个函数则专门用于把字符串转换成数值。

Number函数的转换规则:

  1. 如果是Boolean值,true 返回 1,false 返回 0 。
Number(true)    //1
Number(false)   //0
  1. 如果是数字值,就是原样。
Number(3.14)    //3.14
  1. 如果是null值,返回0。
Number(null) // 0
  1. 如果是undefined,返回NaN。
Number(undefined) // 0

5.如果是字符串,遵循下列规则:

  • 如果是字符串中只包含数字(包括前面带正号或负号的情况),则将其转化成十进制数值。
Number ('23')    // 23
Number ('+23')   // 23 
Number ('-23')   // -23
Number ('011')   // 11  前面的0会忽略
  • 如果字符串中包含的有效的浮点数,就会转化成对应的浮点数,前面的0会忽略。
Number ('3.14')    //3.14
Number ('03.14')   //3.14
  • 如果字符串中包含有效的十六进制格式,前两位为"0x..."的格式,会自动转化成相同大小的十进制数。
Number ('0x10')  // 16
  • 如果字符串是空字符串,则返回 0。
Number ('')  // 0
  • 如果字符串中包含除上述格式外的其他字符,则转化成NaN。
Number("123blue")  // NaN
Number(message)  // NaN,变量message未声明
  • 如果是对象,则调用对象的valueOf()方法,然后依照前面的规则转换返回的值。如果转换的结果是NaN,则调用对象的toString()方法,然后再依照前面的规则转换字符串返回的字符串值。

parseInt()

  • parseInt方法用于将字符串转为整数。返回值只有两种可能,不是一个十进制整数,就是NaN。
parseInt ('120')       //120   整数转化成整数
parseInt ('3.14')    //3     浮点数转化前面的整数部分
parseInt ('    10')    //10    前面的空格会忽略
parseInt ('000010')    //10    前面的0会忽略
  • 如果parseInt的参数不是字符串,则会先转为字符串再转换。
parseInt(1.23) // 1
// 等同于
parseInt('1.23') // 1
  • 字符串转为整数的时候,是一个个字符依次转换,如果遇到不能转为数字的字符,就不再进行下去,返回已经转好的部分。
parseInt('8a') // 8
parseInt('12**') // 12
parseInt('12.34') // 12
parseInt('15e2') // 15
parseInt('15px') // 15
//上面代码中,parseInt的参数都是字符串,结果只返回字符串头部可以转为数字的部分。
  • 如果字符串的第一个字符不能转化为数字(后面跟着数字的正负号除外),返回NaN。
parseInt('abc')   // NaN
parseInt('.3')    // NaN
parseInt('')      // NaN
parseInt('+')     // NaN
parseInt('+1')    // 1
  • parseInt方法还可以接受第二个参数(2到36之间),表示被解析的值的进制,返回该值对应的十进制数。默认情况下,parseInt的第二个参数为10,即默认是十进制转十进制。
parseInt('1000', 10)    // 1000  以十进制解读(默认)
parseInt('1000', 2)     // 8    以二进制解读
parseInt('1000', 6)     // 216   以六进制解读
parseInt('1000', 8)     // 512   以八进制解读
parseInt('10', 37) // NaN   进制超出范围,就返回 NaN
parseInt('10', 1) // NaN  进制超出范围,就返回 NaN
parseInt('10', 0) // 10
parseInt('10', null) // 10
parseInt('10', undefined) // 10  第二个参数是0、null、undefined 则直接忽略

parseFloat ()

  • parseFloat用于将一个字符串转为浮点数。
parseFloat('3.14')         // 3.14  浮点数转浮点数
parseFloat('314e-2')       // 3.14  
parseFloat('0.0314E+2')    // 3.14  如果字符串符合科学计数法,则进行相应转换
parseFloat ('3.14abc')     // 3.14  如果字符串包含不能转换为浮点数的字符,则不再往后转换,返回已经转好的部分。
parseFloat ('    3.14')    // 3.14
parseFloat ('00003.14')    // 3.14  parseFloat方法会自动过滤字符串前面的空格
  • 如果参数不是字符串,或者字符串的第一个字符不能转换为浮点数,则返回NaN。
parseFloat([])     // NaN  空数组返回 NaN
parseFloat('FF2')  // NaN  第一个字符不能转化浮点数
parseFloat('')     // NaN  空字符串转化为 NaN

parseFloat () 和 Number () 的区别

parseFloat(true)       // NaN
Number(true)           // 1

parseFloat(null)       // NaN
Number(null)           // 0

parseFloat('')         // NaN
Number('')             // 0

parseFloat('123.45#')  // 123.45
Number('123.45#')      // NaN

parseInt()与parseFloat()的区别

区别(1):parseFloat()转换时,第一个小数点有效,小数点对parseInt()无效

parseFloat("22.34.5") //22.34
parseInt("22.34.5") //22

区别(2):parseFloat()始终会忽略前导的0

parseFloat()可以识别前面讨论过的所有浮点数值格式,也包括十进制整数格式。但十六进制格式的字符串则始终会被转换成0。由于parseFloat()直解析十进制值,因此它没有用第二个参数指定基数的用法。最后还要注意一点,如果字符串包含的是一个可解析为整数的数(没有小数点,或者小数点后都是0),parseFloat()会返回整数。

parseFloat("1234blue") //1234
parseFloat("0xA") //0
parseFloat("22.5") //22.5
parseFloat(22.34.5) //22.34
parseFloat("0908.5") //908.5
parseFloat("3.125e7") //31250000
parseFloat("4.0000") //4

6.==与===有什么区别

历史背景

确定两个变量是否相等是编程中的一个非常重要的操作。在比较字符串、数值和布尔值的相等性时,问题还比较简单。但在涉及到对象的比较时,问题就变得复杂了。最早的ECMAScript中的相等和不等操作符会在执行比较之前,先将对象转换成相似的类型。后来,有人提出了这种转换到底是否合理的质疑。最后,ECMAScript的解决方案就是提供两组操作数:相等不相等——先转换在比较,全等不全等——仅比较而不转换。

1.相等和不相等

这两个操作符都会先转换操作数,然后再比较它们的相等性。

在转换不同的数据类型时,相等和不相等操作符遵循下列基本规则:

  • 如果有一个操作数是布尔值,则在比较相等性之前先将其转换为数值——false转换为0,而true转换为1;
false == 1 //false
false == 0 //true
true ==1 //true
true == 0 //false
  • 如果一个操作数是字符串,另一个操作数是数值,在比较相等性之前先将字符串转换为数值;
"123" == 123 //true
  • 如果一个操作数是对象,另一个操作数不是,则调用对象的valueof()方法,用得到的基本类型值按照前面的规则进行比较;

这两个操作符在进行比较时则要遵循下列规则。

  • null和undefined是相等的。
null == undefined //true
  • 要比较相等性之前,不能将null和undefined转换成其他任何值
null +1 //1
undefined +1 //NaN
null == 0 //false
undefined == 0 //false
  • 如果有一个操作数是NaN,则相等操作符返回false,而不相等操作符返回true。
"NaN" == NaN //false
NaN == NaN //false
NaN != NaN //true
  • 如果两个操作数都是对象,则比较它们是不是同一个对象。如果两个操作数都指向同一个对象,则相等操作符返回true;否则返回false。

2.全等和不全等

全等操作符只在两个操作数未经转换就相等的情况下返回true。

除了在比较之前不转换操作数之外,全等和不全等操作符与相等和不相等操作符没有什么区别。

"55" == 55 //true,因为转换后相等
"55" === 55 //false,因为在不转换的情况下,字符串不等于数值
null ==undefined //true
null === undefined //false

记住,null ==undefined会返回true,因为它们是类似的值;但null === undefined会返回false,因为它们是不同类型的值。

7.break与continue有什么区别

  • break语句立即退出循环,强制执行循环后面的语句(退出循环体)
var num = 0;
for (var i=1; i<10; i++) {
    if (i % 5 == 0) {
      break;
  }
  num++;
}
alert(num); //4
  • continue语句立即退出本次循环,执行下次循环(退出单次循环)
var num = 0;
for (var i=1; i<10; i++) {
    if (i % 5 == 0) {
      continue;
  }
  num++;
}
alert(num); //8

break和continue语句都可以与label语句联合使用,从而返回代码中特定的位置。这种联合使用的情况多发生在循环嵌套的情况下。

  • break语句与label语句联合使用
var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            break outermost;
        }
        num++;
    }
}
alert(num);  //55

break语句后面带了一个参数:要返回到的标签。添加这个标签的结果将导致break语句不仅会退出内部的for语句(使用变量j的循环),而且也会退出外部的for语句(使用变量i的循环)。

var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            break;
        }
        num++;
    }
}
alert(num);  //95
  • continue语句与label语句联合使用
var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            continue outermost;
        }
        num++;
    }
}
alert(num);  //95

continue语句后面带了一个参数:要返回到的标签。添加这个标签的结果将导致continue语句会退出内部循环(这也就意味着内部循环少执行了5次),执行下一次外部循环(continue退出的是单次循环,继续执行下一次循环)。

var num = 0;
outermost :
for (var i=0; i<10; i++) {
    for (var j=0; j<10; j++) {
        if (i ==5 && j == 5) {
            continue; 
        }
        num++;
    }
}
alert(num);  //99

8.void 0 和 undefined在使用场景上有什么区别

undefined

  1. undefined 并不是保留词(reserved word),它只是全局对象的一个属性,在低版本 IE 中能被重写。
var undefined = 10;
 
// undefined -- chrome
// 弹出10 -- IE 8,低版本IE中
alert(undefined);
  1. 虽然undefined 在 ES5 中已经是全局对象的一个只读(read-only)属性,它不能被重写。但是在局部作用域中,还是可以被重写。
(function() {

  //局部作用域
  var undefined = 10;
 
  //弹出 10 -- chrome
  alert(undefined);
})();
 
(function() {

  //全局变量并赋值,因为在全局作用域undefiend不能被重写,所以赋值无效
  undefined = 10;
 
  // 弹出undefined -- chrome
  alert(undefined);
})();

void运算符

void 运算符能对给定的表达式进行求值,然后返回 undefined。

也就是说,void 后面你随便跟上一个表达式,返回的都是 undefined,都能完美代替 undefined。

那么,这其中最短的是什么呢?毫无疑问就是 void 0 了。其实用 void 1,void (1+1),void (0) 或者 void “hello”,void (new Date()) 等等,都是一样的效果。更重要的前提是,void 是不能被重写的(cannot be overidden)

ES5 大环境下,void 0 也有可以发挥作用的地方,用 void 0 代替 undefined 就能节省不少字节的大小。事实上,不少 JavaScript 压缩工具在压缩过程中,正是将 undefined 用 void 0 代替掉了。

9.代码练习

(1)以下代码的输出结果是?为什么?

console.log(1+1);//输出2,两个数字加法运算
console.log("2"+"4");//输出'24',两个字符串类型的做字符串拼接
console.log(2+"4");//输出'24',一个是数字一个是字符串,数字转化为字符串后拼接
console.log(+"4");//输出4,只有一个字符串会转换成数字输出
var a = 1;  
a+++a;  
// 3     等同于 (a++)+a,这里前面的(a++)为1,后面的a为2,++优先级高于+
typeof a+2;  
// 'number2'   等同于(typeof a)+2,前面为字符串‘number’,后面数值,拼接成字符串,typeof 优先级高于+
 var a = 1;
 var b = 3;
 console.log( a+++b );  
 // 4  括号里面等同于(a++)+b,前面的(a++)表达式值为1,先用a的值,用完后再给a自加1

(2)遍历数组,把数组里的打印数组每一项的平方

var arr = [3,4,5]

for (var i=0;i<3;i++){
  console.log(arr[i]*arr[i])
}
// 9  16  25

(3)遍历 JSON, 打印里面的值

var obj = {
 name: 'hunger', 
 sex: 'male', 
 age: 28 
}
for(a in obj){
console.log(a+":"+obj[a])
}
// name:hunger sex:male age:28

(4)下面代码的输出结果

var a = 1, b = 2, c = 3;
var val = typeof a + b ||  c >0    //  优先级顺序typeof   +  >   ||
console.log(val)    //  'number2' || true
// 输出‘number2’

var d = 5;
var data = d ==5 && console.log('bb')  
// console.log('bb') 输出了字符串bb,但它的返回值是undefined
console.log(data)  // data = true && undefined
//输出 undefined

var data2 = d = 0 || console.log('haha')  
    // console.log('haha') 输出了字符串haha,但它的返回值是undefined
console.log(data2)  // data2 = d = 0 || undefined
    //输出 undefined

var x = !!"Hello" + (!"world", !!"from here!!");  
    // true+(false, true),即true+true
console.log(x)  //  console.log (true+true)
    // 输出 2

补充:

逗号运算符用于对两个表达式求值,并返回后一个表达式的值。

'a', 'b' //返回"b"

var x = 0;
var y = (x++, 10);
x //1
y  //10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏技术博文

PHP函数篇详解十进制、二进制、八进制和十六进制转换函数说明

一,十进制(decimal system)转换函数说明  1,十进制转二进制 decbin() 函数,如下实例  echo decbin(12); //输出 ...

3116
来自专栏Golang语言社区

Golang语言社区--【基础知识】常量

常量是指该程序可能无法在其执行期间改变的固定值。这些固定值也被称为文字。 常量可以是任何像一个整型常量,一个浮点常量,字符常量或字符串文字的基本数据类型。还有枚...

3457
来自专栏小樱的经验随笔

pandas用法小结

1062
来自专栏Python

Django--admin源码流程

admin.py from django.contrib import admin from . import models """ 通过原生的django a...

2558
来自专栏软件开发 -- 分享 互助 成长

C++类的复制构造函数和赋值运算符

前言: C++面向对象的编程过程中,凡是在类中运用到动态内存分配的时候总是会写一个显示的复制构造函数和赋值重载运算符,本文将结合C++ Primer Plus一...

1777
来自专栏Golang语言社区

Golang语言社区--【基础知识】常量

常量是指该程序可能无法在其执行期间改变的固定值。这些固定值也被称为文字。 常量可以是任何像一个整型常量,一个浮点常量,字符常量或字符串文字的基本数据类型。还有枚...

3085
来自专栏程序员互动联盟

【编程基础】c printf知多少

printf()函数是格式输出函数,请求printf()打印变量的指令取决与变量的类型.例如,在打印整数是使用%d符号,在打印字符是用%c 符号.这些符号被称为...

3295
来自专栏一个小程序员的成长笔记

JavaScript中的数据类型

在ECMAScript中,变量是松散类型的。所谓松散类型就是指变量可以用来保存任何类型的数据。  // 下面的操作是完全合法的 var message = "h...

3256
来自专栏用户2442861的专栏

python编码问题

我们已经讲过了,字符串也是一种数据类型,但是,字符串比较特殊的是还有一个编码问题。

531
来自专栏锦小年的博客

python学习笔记2.2-print函数以及格式化输出

上一节已经安装好运行环境以及各种库,接下来就要开始正式编程了。与国际接轨,接触一门语言的第一次编程,一定是在屏幕上打印“hello world”。python...

1965

扫码关注云+社区