精华内容
下载资源
问答
  • 计算机中使用二进制的里有是因为二进制表示具有可行性、算术运算规则简单、逻辑运算方便、使用硬件容易实现等特点。下面是小编为大家整理的计算机与二进制的资料,希望对您有所帮助!计算机与二进制的表示1.数的...

    在计算机内部,所有的信息***含程序、文字、图片、声音、视频***等都是以二进制数据表示的。计算机中使用二进制的里有是因为二进制表示具有可行性、算术运算规则简单、逻辑运算方便、使用硬件容易实现等特点。下面是小编为大家整理的计算机与二进制的资料,希望对您有所帮助!

    计算机与二进制的表示

    1.数的二进制表示

    例如十进制+5可以用8位二进制表示为00000101,十进制-5可以用8位二进制表示为10000101,其中最高位表示符号位。十进制+89可以用二进制表示为01011001,十进制-89可以用二进制表示为11011001。所以数据均可以用二进制表示。

    2.二进制加法运算规则

    0十0=0,0+1=1,1十0=1。1十1=10

    3.二进制减法运算规则

    0-0=0,1-0=1,1-1=0,0-1=1***有借位***

    4.二进制乘法运算规则

    0×0=0,0×1=0,0×1=1,0×0=0

    5.二进制除法

    类似地,你可以动手算算:

    11101001111011/10011101=商为1011111.....余数为111000

    6.二进制的逻辑运算

    二进制的逻辑运算有“逻辑与”运算、“逻辑或”运算、“逻辑异或”运算以及“逻辑非”运算.也分别称作“AND”、“OR”,“XOR“’“NOT”运算。

    展开全文
  • JavaScript-二进制二进制数组

    万次阅读 2016-07-03 18:09:40
    在ES5中引入了Blob用于处理二进制。在ES6中引入了ArrayBuffer、TypedArray、DataView用于处理二进制数组。常规的前端操作用,用到二进制的地方不多。但是,当我想处理文件的传输时候,使用二进制进行传输可以更快。...

    在ES5中引入了Blob用于处理二进制。在ES6中引入了ArrayBuffer、TypedArray、DataView用于处理二进制数组。常规的前端操作用,用到二进制的地方不多。但是,当我想处理文件的传输时候,使用二进制进行传输可以更快。在进行异步数据传输(AJAX)时,很可能出现这种场景。

    Blob

    Blob(Binary Large Object)对象代表了一段二进制数据,提供了一系列操作接口。其他操作二进制数据的API(比如File对象),都是建立在Blob对象基础上的,继承了它的属性和方法。

    生成Blob对象有两种方法:一种是使用Blob构造函数,另一种是对现有的Blob对象使用slice方法切出一部分。

    (1)Blob构造函数,接受两个参数。第一个参数是一个包含实际数据的数组,第二个参数是数据的类型,这两个参数都不是必需的。

    var htmlParts = ["<a id=\"a\"><b id=\"b\">hey!<\/b><\/a>"];
    var myBlob = new Blob(htmlParts, { "type" : "text\/xml" });

    下面是一个利用Blob对象,生成可下载文件的例子。

    var blob = new Blob(["Hello Lee"]);
    
    var a = document.createElement("a");
    a.href = window.URL.createObjectURL(blob);
    a.download = "hello-lee.txt";
    a.textContent = "Download Hello World!";
    
    body.appendChild(a);

    上面的代码生成了一个超级链接,点击后提示下载文本文件hello-lee.txt,文件内容为“Hello Lee”。

    (2)Blob对象的slice方法,将二进制数据按照字节分块,返回一个新的Blob对象。

    var newBlob = oldBlob.slice(startingByte, endindByte);

    下面是一个使用XMLHttpRequest对象,将大文件分割上传的例子。

    function upload(blobOrFile) {
      var xhr = new XMLHttpRequest();
      xhr.open('POST', '/server', true);
      xhr.onload = function(e) { ... };
      xhr.send(blobOrFile);
    }
    
    document.querySelector('input[type="file"]').addEventListener('change', function(e) {
      var blob = this.files[0];
    
      const BYTES_PER_CHUNK = 1024 * 1024; // 1MB chunk sizes.
      const SIZE = blob.size;
    
      var start = 0;
      var end = BYTES_PER_CHUNK;
    
      while(start < SIZE) {
        upload(blob.slice(start, end));
    
        start = end;
        end = start + BYTES_PER_CHUNK;
      }
    }, false);
    
    })();

    (3)Blob对象有两个只读属性:

    • size:二进制数据的大小,单位为字节。
    • type:二进制数据的MIME类型,全部为小写,如果类型未知,则该值为空字符串。
      在Ajax操作中,如果xhr.responseType设为blob,接收的就是二进制数据。

    二进制数组

    (1)ArrayBuffer对象:代表内存之中的一段二进制数据,可以通过“视图”进行操作。“视图”部署了数组接口,这意味着,可以用数组的方法操作内存。

    (2) TypedArray对象:用来生成内存的视图,通过9个构造函数,可以生成9种数据格式的视图,比如Uint8Array(无符号8位整数)数组视图, Int16Array(16位整数)数组视图, Float32Array(32位浮点数)数组视图等等。

    (3)DataView对象:用来生成内存的视图,可以自定义格式和字节序,比如第一个字节是Uint8(无符号8位整数)、第二个字节是Int16(16位整数)、第三个字节是Float32(32位浮点数)等等。

    简单说,ArrayBuffer对象代表原始的二进制数据,TypedArray对象代表确定类型的二进制数据,DataView对象代表不确定类型的二进制数据。它们支持的数据类型一共有9种(DataView对象支持除Uint8C以外的其他8种)。

    ArrayBuffe对象

    概述

    ArrayBuffer对象代表储存二进制数据的一段内存,它不能直接读写,只能通过视图(TypedArray视图和DataView视图)来读写,视图的作用是以指定格式解读二进制数据。

    ArrayBuffer也是一个构造函数,可以分配一段可以存放数据的连续内存区域。

    var buf = new ArrayBuffer(32);

    上面代码生成了一段32字节的内存区域,每个字节的值默认都是0。可以看到,ArrayBuffer构造函数的参数是所需要的内存大小(单位字节)。

    为了读写这段内容,需要为它指定视图。DataView视图的创建,需要提供ArrayBuffer对象实例作为参数。

    var buf = new ArrayBuffer(32);
    var dataView = new DataView(buf);
    dataView.getUint8(0) // 0

    上面代码对一段32字节的内存,建立DataView视图,然后以不带符号的8位整数格式,读取第一个元素,结果得到0,因为原始内存的ArrayBuffer对象,默认所有位都是0。

    另一种TypedArray视图,与DataView视图的一个区别是,它不是一个构造函数,而是一组构造函数,代表不同的数据格式。

    var buffer = new ArrayBuffer(12);
    
    var x1 = new Int32Array(buffer);
    x1[0] = 1;
    var x2 = new Uint8Array(buffer);
    x2[0]  = 2;
    
    x1[0] // 2

    上面代码对同一段内存,分别建立两种视图:32位带符号整数(Int32Array构造函数)和8位不带符号整数(Uint8Array构造函数)。由于两个视图对应的是同一段内存,一个视图修改底层内存,会影响到另一个视图。

    TypedArray视图的构造函数,除了接受ArrayBuffer实例作为参数,还可以接受正常数组作为参数,直接分配内存生成底层的ArrayBuffer实例,并同时完成对这段内存的赋值。

    var typedArray = new Uint8Array([0,1,2]);
    typedArray.length // 3
    
    typedArray[0] = 5;
    typedArray // [5, 1, 2]

    上面代码使用TypedArray视图的Uint8Array构造函数,新建一个不带符号的8位整数视图。可以看到,Uint8Array直接使用正常数组作为参数,对底层内存的赋值同时完成。

    ArrayBuffer.prototype.byteLength

    ArrayBuffer实例的byteLength属性,返回所分配的内存区域的字节长度。

    var buffer = new ArrayBuffer(32);
    buffer.byteLength
    // 32

    如果要分配的内存区域很大,有可能分配失败(因为没有那么多的连续空余内存),所以有必要检查是否分配成功。

    if (buffer.byteLength === n) {
      // 成功
    } else {
      // 失败
    }

    ArrayBuffer.prototype.slice()

    ArrayBuffer实例有一个slice方法,允许将内存区域的一部分,拷贝生成一个新的ArrayBuffer对象。

    var buffer = new ArrayBuffer(8);
    var newBuffer = buffer.slice(0, 3);

    上面代码拷贝buffer对象的前3个字节(从0开始,到第3个字节前面结束),生成一个新的ArrayBuffer对象。slice方法其实包含两步,第一步是先分配一段新内存,第二步是将原来那个ArrayBuffer对象拷贝过去。

    slice方法接受两个参数,第一个参数表示拷贝开始的字节序号(含该字节),第二个参数表示拷贝截止的字节序号(不含该字节)。如果省略第二个参数,则默认到原ArrayBuffer对象的结尾。

    除了slice方法,ArrayBuffer对象不提供任何直接读写内存的方法,只允许在其上方建立视图,然后通过视图读写。

    ArrayBuffer.isView()

    ArrayBuffer有一个静态方法isView,返回一个布尔值,表示参数是否为ArrayBuffer的视图实例。这个方法大致相当于判断参数,是否为TypedArray实例或DataView实例。

    var buffer = new ArrayBuffer(8);
    ArrayBuffer.isView(buffer) // false
    
    var v = new Int32Array(buffer);
    ArrayBuffer.isView(v) // true

    TypedArray对象

    概述

    ArrayBuffer对象作为内存区域,可以存放多种类型的数据。同一段内存,不同数据有不同的解读方式,这就叫做“视图”(view)。ArrayBuffer有两种视图,一种是TypedArray视图,另一种是DataView视图,两者的区别主要是字节序,前者的数组成员都是同一个数据类型,后者的数组成员可以是不同的数据类型。

    目前,TypedArray对象一共提供9种类型的视图,每一种视图都是一种构造函数。

    Int8Array:8位有符号整数,长度1个字节。
    Uint8Array:8位无符号整数,长度1个字节。
    Uint8ClampedArray:8位无符号整数,长度1个字节,溢出处理不同。
    Int16Array:16位有符号整数,长度2个字节。
    Uint16Array:16位无符号整数,长度2个字节。
    Int32Array:32位有符号整数,长度4个字节。
    Uint32Array:32位无符号整数,长度4个字节。
    Float32Array:32位浮点数,长度4个字节。
    Float64Array:64位浮点数,长度8个字节。

    这9个构造函数生成的对象,统称为TypedArray对象。它们很像正常数组,都有length属性,都能用方括号运算符([])获取单个元素,所有数组的方法,在类型化数组上面都能使用。两者的差异主要在以下方面。

    TypedArray数组的所有成员,都是同一种类型和格式。
    TypedArray数组的成员是连续的,不会有空位。
    Typed化数组成员的默认值为0。比如,new Array(10)返回一个正常数组,里面没有任何成员,只是10个空位;new Uint8Array(10)返回一个类型化数组,里面10个成员都是0。
    TypedArray数组只是一层视图,本身不储存数据,它的数据都储存在底层的ArrayBuffer对象之中,要获取底层对象必须使用buffer属性。

    构造函数

    TypedArray数组提供9种构造函数,用来生成相应类型的数组实例。

    构造函数有多种用法。

    (1)TypedArray(buffer, byteOffset=0, length?)

    同一个ArrayBuffer对象之上,可以根据不同的数据类型,建立多个视图。

    // 创建一个8字节的ArrayBuffer
    var b = new ArrayBuffer(8);
    
    // 创建一个指向b的Int32视图,开始于字节0,直到缓冲区的末尾
    var v1 = new Int32Array(b);
    
    // 创建一个指向b的Uint8视图,开始于字节2,直到缓冲区的末尾
    var v2 = new Uint8Array(b, 2);
    
    // 创建一个指向b的Int16视图,开始于字节2,长度为2
    var v3 = new Int16Array(b, 2, 2);

    上面代码在一段长度为8个字节的内存(b)之上,生成了三个视图:v1、v2和v3。

    视图的构造函数可以接受三个参数:

    第一个参数(必需):视图对应的底层ArrayBuffer对象。
    第二个参数(可选):视图开始的字节序号,默认从0开始。
    第三个参数(可选):视图包含的数据个数,默认直到本段内存区域结束。
    因此,v1、v2和v3是重叠的:v1[0]是一个32位整数,指向字节0~字节3;v2[0]是一个8位无符号整数,指向字节2;v3[0]是一个16位整数,指向字节2~字节3。只要任何一个视图对内存有所修改,就会在另外两个视图上反应出来。

    注意,byteOffset必须与所要建立的数据类型一致,否则会报错。

    var buffer = new ArrayBuffer(8);
    var i16 = new Int16Array(buffer, 1);
    // Uncaught RangeError: start offset of Int16Array should be a multiple of 2

    上面代码中,新生成一个8个字节的ArrayBuffer对象,然后在这个对象的第一个字节,建立带符号的16位整数视图,结果报错。因为,带符号的16位整数需要两个字节,所以byteOffset参数必须能够被2整除。

    如果想从任意字节开始解读ArrayBuffer对象,必须使用DataView视图,因为TypedArray视图只提供9种固定的解读格式。

    (2)TypedArray(length)

    视图还可以不通过ArrayBuffer对象,直接分配内存而生成。

    var f64a = new Float64Array(8);
    f64a[0] = 10;
    f64a[1] = 20;
    f64a[2] = f64a[0] + f64a[1];

    上面代码生成一个8个成员的Float64Array数组(共64字节),然后依次对每个成员赋值。这时,视图构造函数的参数就是成员的个数。可以看到,视图数组的赋值操作与普通数组的操作毫无两样。

    (3)TypedArray(typedArray)

    类型化数组的构造函数,可以接受另一个视图实例作为参数。

    var typedArray = new Int8Array(new Uint8Array(4));

    上面代码中,Int8Array构造函数接受一个Uint8Array实例作为参数。

    注意,此时生成的新数组,只是复制了参数数组的值,对应的底层内存是不一样的。新数组会开辟一段新的内存储存数据,不会在原数组的内存之上建立视图。

    var x = new Int8Array([1, 1]);
    var y = new Int8Array(x);
    x[0] // 1
    y[0] // 1
    
    x[0] = 2;
    y[0] // 1

    上面代码中,数组y是以数组x为模板而生成的,当x变动的时候,y并没有变动。

    如果想基于同一段内存,构造不同的视图,可以采用下面的写法。

    var x = new Int8Array([1, 1]);
    var y = new Int8Array(x.buffer);
    x[0] // 1
    y[0] // 1
    
    x[0] = 2;
    y[0] // 2

    (4)TypedArray(arrayLikeObject)

    构造函数的参数也可以是一个普通数组,然后直接生成TypedArray实例。

    var typedArray = new Uint8Array([1, 2, 3, 4]);
    注意,这时TypedArray视图会重新开辟内存,不会在原数组的内存上建立视图。

    上面代码从一个普通的数组,生成一个8位无符号整数的TypedArray实例。

    TypedArray数组也可以转换回普通数组。

    var normalArray = Array.prototype.slice.call(typedArray);

    数组方法

    普通数组的操作方法和属性,对TypedArray数组完全适用。

    TypedArray.prototype.copyWithin(target, start[, end = this.length])
    TypedArray.prototype.entries()
    TypedArray.prototype.every(callbackfn, thisArg?)
    TypedArray.prototype.fill(value, start=0, end=this.length)
    TypedArray.prototype.filter(callbackfn, thisArg?)
    TypedArray.prototype.find(predicate, thisArg?)
    TypedArray.prototype.findIndex(predicate, thisArg?)
    TypedArray.prototype.forEach(callbackfn, thisArg?)
    TypedArray.prototype.indexOf(searchElement, fromIndex=0)
    TypedArray.prototype.join(separator)
    TypedArray.prototype.keys()
    TypedArray.prototype.lastIndexOf(searchElement, fromIndex?)
    TypedArray.prototype.map(callbackfn, thisArg?)
    TypedArray.prototype.reduce(callbackfn, initialValue?)
    TypedArray.prototype.reduceRight(callbackfn, initialValue?)
    TypedArray.prototype.reverse()
    TypedArray.prototype.slice(start=0, end=this.length)
    TypedArray.prototype.some(callbackfn, thisArg?)
    TypedArray.prototype.sort(comparefn)
    TypedArray.prototype.toLocaleString(reserved1?, reserved2?)
    TypedArray.prototype.toString()
    TypedArray.prototype.values()
    上面所有方法的用法,请参阅数组方法的介绍,这里不再重复了。

    另外,TypedArray数组与普通数组一样,部署了Iterator接口,所以可以被遍历。

    let ui8 = Uint8Array.of(0, 1, 2);
    for (let byte of ui8) {
      console.log(byte);
    }
    // 0
    // 1
    // 2

    字节序

    字节序指的是数值在内存中的表示方式。

    var buffer = new ArrayBuffer(16);
    var int32View = new Int32Array(buffer);
    
    for (var i = 0; i < int32View.length; i++) {
      int32View[i] = i * 2;
    }

    上面代码生成一个16字节的ArrayBuffer对象,然后在它的基础上,建立了一个32位整数的视图。由于每个32位整数占据4个字节,所以一共可以写入4个整数,依次为0,2,4,6。

    如果在这段数据上接着建立一个16位整数的视图,则可以读出完全不一样的结果。

    var int16View = new Int16Array(buffer);
    
    for (var i = 0; i < int16View.length; i++) {
      console.log("Entry " + i + ": " + int16View[i]);
    }
    // Entry 0: 0
    // Entry 1: 0
    // Entry 2: 2
    // Entry 3: 0
    // Entry 4: 4
    // Entry 5: 0
    // Entry 6: 6
    // Entry 7: 0

    由于每个16位整数占据2个字节,所以整个ArrayBuffer对象现在分成8段。然后,由于x86体系的计算机都采用小端字节序(little endian),相对重要的字节排在后面的内存地址,相对不重要字节排在前面的内存地址,所以就得到了上面的结果。

    比如,一个占据四个字节的16进制数0x12345678,决定其大小的最重要的字节是“12”,最不重要的是“78”。小端字节序将最不重要的字节排在前面,储存顺序就是78563412;大端字节序则完全相反,将最重要的字节排在前面,储存顺序就是12345678。目前,所有个人电脑几乎都是小端字节序,所以TypedArray数组内部也采用小端字节序读写数据,或者更准确的说,按照本机操作系统设定的字节序读写数据。

    这并不意味大端字节序不重要,事实上,很多网络设备和特定的操作系统采用的是大端字节序。这就带来一个严重的问题:如果一段数据是大端字节序,TypedArray数组将无法正确解析,因为它只能处理小端字节序!为了解决这个问题,JavaScript引入DataView对象,可以设定字节序,下文会详细介绍。

    下面是另一个例子。

    // 假定某段buffer包含如下字节 [0x02, 0x01, 0x03, 0x07]
    var buffer = new ArrayBuffer(4);
    var v1 = new Uint8Array(buffer);
    v1[0] = 2;
    v1[1] = 1;
    v1[2] = 3;
    v1[3] = 7;
    
    var uInt16View = new Uint16Array(buffer);
    
    // 计算机采用小端字节序
    // 所以头两个字节等于258
    if (uInt16View[0] === 258) {
      console.log('OK'); // "OK"
    }
    
    // 赋值运算
    uInt16View[0] = 255;    // 字节变为[0xFF, 0x00, 0x03, 0x07]
    uInt16View[0] = 0xff05; // 字节变为[0x05, 0xFF, 0x03, 0x07]
    uInt16View[1] = 0x0210; // 字节变为[0x05, 0xFF, 0x10, 0x02]

    下面的函数可以用来判断,当前视图是小端字节序,还是大端字节序。

    const BIG_ENDIAN = Symbol('BIG_ENDIAN');
    const LITTLE_ENDIAN = Symbol('LITTLE_ENDIAN');
    
    function getPlatformEndianness() {
      let arr32 = Uint32Array.of(0x12345678);
      let arr8 = new Uint8Array(arr32.buffer);
      switch ((arr8[0]*0x1000000) + (arr8[1]*0x10000) + (arr8[2]*0x100) + (arr8[3])) {
        case 0x12345678:
          return BIG_ENDIAN;
        case 0x78563412:
          return LITTLE_ENDIAN;
        default:
          throw new Error('Unknown endianness');
      }
    }

    总之,与普通数组相比,TypedArray数组的最大优点就是可以直接操作内存,不需要数据类型转换,所以速度快得多。

    BYTES_PER_ELEMENT属性

    每一种视图的构造函数,都有一个BYTES_PER_ELEMENT属性,表示这种数据类型占据的字节数。

    Int8Array.BYTES_PER_ELEMENT // 1
    Uint8Array.BYTES_PER_ELEMENT // 1
    Int16Array.BYTES_PER_ELEMENT // 2
    Uint16Array.BYTES_PER_ELEMENT // 2
    Int32Array.BYTES_PER_ELEMENT // 4
    Uint32Array.BYTES_PER_ELEMENT // 4
    Float32Array.BYTES_PER_ELEMENT // 4
    Float64Array.BYTES_PER_ELEMENT // 8
    这个属性在TypedArray实例上也能获取,即有TypedArray.prototype.BYTES_PER_ELEMENT。

    ArrayBuffer与字符串的互相转换

    ArrayBuffer转为字符串,或者字符串转为ArrayBuffer,有一个前提,即字符串的编码方法是确定的。假定字符串采用UTF-16编码(JavaScript的内部编码方式),可以自己编写转换函数。

    // ArrayBuffer转为字符串,参数为ArrayBuffer对象
    function ab2str(buf) {
      return String.fromCharCode.apply(null, new Uint16Array(buf));
    }
    
    // 字符串转为ArrayBuffer对象,参数为字符串
    function str2ab(str) {
      var buf = new ArrayBuffer(str.length * 2); // 每个字符占用2个字节
      var bufView = new Uint16Array(buf);
      for (var i = 0, strLen = str.length; i < strLen; i++) {
        bufView[i] = str.charCodeAt(i);
      }
      return buf;
    }

    溢出

    不同的视图类型,所能容纳的数值范围是确定的。超出这个范围,就会出现溢出。比如,8位视图只能容纳一个8位的二进制值,如果放入一个9位的值,就会溢出。

    TypedArray数组的溢出处理规则,简单来说,就是抛弃溢出的位,然后按照视图类型进行解释。

    var uint8 = new Uint8Array(1);
    
    uint8[0] = 256;
    uint8[0] // 0
    
    uint8[0] = -1;
    uint8[0] // 255

    上面代码中,uint8是一个8位视图,而256的二进制形式是一个9位的值100000000,这时就会发生溢出。根据规则,只会保留后8位,即00000000。uint8视图的解释规则是无符号的8位整数,所以00000000就是0。

    负数在计算机内部采用“2的补码”表示,也就是说,将对应的正数值进行否运算,然后加1。比如,-1对应的正值是1,进行否运算以后,得到11111110,再加上1就是补码形式11111111。uint8按照无符号的8位整数解释11111111,返回结果就是255。

    一个简单转换规则,可以这样表示。

    正向溢出(overflow):当输入值大于当前数据类型的最大值,结果等于当前数据类型的最小值加上余值,再减去1。
    负向溢出(underflow):当输入值小于当前数据类型的最小值,结果等于当前数据类型的最大值减去余值,再加上1。
    请看下面的例子。

    var int8 = new Int8Array(1);
    
    int8[0] = 128;
    int8[0] // -128
    
    int8[0] = -129;
    int8[0] // 127

    上面例子中,int8是一个带符号的8位整数视图,它的最大值是127,最小值是-128。输入值为128时,相当于正向溢出1,根据“最小值加上余值,再减去1”的规则,就会返回-128;输入值为-129时,相当于负向溢出1,根据“最大值减去余值,再加上1”的规则,就会返回127。

    Uint8ClampedArray视图的溢出规则,与上面的规则不同。它规定,凡是发生正向溢出,该值一律等于当前数据类型的最大值,即255;如果发生负向溢出,该值一律等于当前数据类型的最小值,即0。

    var uint8c = new Uint8ClampedArray(1);
    
    uint8c[0] = 256;
    uint8c[0] // 255
    
    uint8c[0] = -1;
    uint8c[0] // 0

    上面例子中,uint8C是一个Uint8ClampedArray视图,正向溢出时都返回255,负向溢出都返回0。

    TypedArray.prototype.buffer

    TypedArray实例的buffer属性,返回整段内存区域对应的ArrayBuffer对象。该属性为只读属性。

    var a = new Float32Array(64);
    var b = new Uint8Array(a.buffer);

    上面代码的a视图对象和b视图对象,对应同一个ArrayBuffer对象,即同一段内存。

    TypedArray.prototype.byteLength,TypedArray.prototype.byteOffset
    byteLength属性返回TypedArray数组占据的内存长度,单位为字节。byteOffset属性返回TypedArray数组从底层ArrayBuffer对象的哪个字节开始。这两个属性都是只读属性。

    var b = new ArrayBuffer(8);
    
    var v1 = new Int32Array(b);
    var v2 = new Uint8Array(b, 2);
    var v3 = new Int16Array(b, 2, 2);
    
    v1.byteLength // 8
    v2.byteLength // 6
    v3.byteLength // 4
    
    v1.byteOffset // 0
    v2.byteOffset // 2
    v3.byteOffset // 2

    TypedArray.prototype.length

    length属性表示TypedArray数组含有多少个成员。注意将byteLength属性和length属性区分,前者是字节长度,后者是成员长度。

    var a = new Int16Array(8);
    
    a.length // 8
    a.byteLength // 16
    TypedArray.prototype.set()

    TypedArray数组的set方法用于复制数组(正常数组或TypedArray数组),也就是将一段内容完全复制到另一段内存。

    var a = new Uint8Array(8);
    var b = new Uint8Array(8);
    
    b.set(a);

    上面代码复制a数组的内容到b数组,它是整段内存的复制,比一个个拷贝成员的那种复制快得多。set方法还可以接受第二个参数,表示从b对象哪一个成员开始复制a对象。

    var a = new Uint16Array(8);
    var b = new Uint16Array(10);
    
    b.set(a, 2)

    上面代码的b数组比a数组多两个成员,所以从b[2]开始复制。

    TypedArray.prototype.subarray()

    subarray方法是对于TypedArray数组的一部分,再建立一个新的视图。

    var a = new Uint16Array(8);
    var b = a.subarray(2,3);
    
    a.byteLength // 16
    b.byteLength // 2

    subarray方法的第一个参数是起始的成员序号,第二个参数是结束的成员序号(不含该成员),如果省略则包含剩余的全部成员。所以,上面代码的a.subarray(2,3),意味着b只包含a[2]一个成员,字节长度为2。

    TypedArray.prototype.slice()
    TypeArray实例的slice方法,可以返回一个指定位置的新的TypedArray实例。
    
    let ui8 = Uint8Array.of(0, 1, 2);
    ui8.slice(-1)
    // Uint8Array [ 2 ]

    上面代码中,ui8是8位无符号整数数组视图的一个实例。它的slice方法可以从当前视图之中,返回一个新的视图实例。

    slice方法的参数,表示原数组的具体位置,开始生成新数组。负值表示逆向的位置,即-1为倒数第一个位置,-2表示倒数第二个位置,以此类推。

    TypedArray.of()

    TypedArray数组的所有构造函数,都有一个静态方法of,用于将参数转为一个TypedArray实例。

    Float32Array.of(0.151, -8, 3.7)
    // Float32Array [ 0.151, -8, 3.7 ]

    TypedArray.from()

    静态方法from接受一个可遍历的数据结构(比如数组)作为参数,返回一个基于这个结构的TypedArray实例。

    Uint16Array.from([0, 1, 2])
    // Uint16Array [ 0, 1, 2 ]

    这个方法还可以将一种TypedArray实例,转为另一种。

    var ui16 = Uint16Array.from(Uint8Array.of(0, 1, 2));
    ui16 instanceof Uint16Array // true

    from方法还可以接受一个函数,作为第二个参数,用来对每个元素进行遍历,功能类似map方法。

    Int8Array.of(127, 126, 125).map(x => 2 * x)
    // Int8Array [ -2, -4, -6 ]
    
    Int16Array.from(Int8Array.of(127, 126, 125), x => 2 * x)
    // Int16Array [ 254, 252, 250 ]

    上面的例子中,from方法没有发生溢出,这说明遍历是针对新生成的16位整数数组,而不是针对原来的8位整数数组。也就是说,from会将第一个参数指定的TypedArray数组,拷贝到另一段内存之中(占用内存从3字节变为6字节),然后再进行处理。

    复合视图

    由于视图的构造函数可以指定起始位置和长度,所以在同一段内存之中,可以依次存放不同类型的数据,这叫做“复合视图”。

    var buffer = new ArrayBuffer(24);
    
    var idView = new Uint32Array(buffer, 0, 1);
    var usernameView = new Uint8Array(buffer, 4, 16);
    var amountDueView = new Float32Array(buffer, 20, 1);

    上面代码将一个24字节长度的ArrayBuffer对象,分成三个部分:

    字节0到字节3:1个32位无符号整数
    字节4到字节19:16个8位整数
    字节20到字节23:1个32位浮点数
    这种数据结构可以用如下的C语言描述:

    struct someStruct {
      unsigned long id;
      char username[16];
      float amountDue;
    };

    DataView视图

    如果一段数据包括多种类型(比如服务器传来的HTTP数据),这时除了建立ArrayBuffer对象的复合视图以外,还可以通过DataView视图进行操作。

    DataView视图提供更多操作选项,而且支持设定字节序。本来,在设计目的上,ArrayBuffer对象的各种TypedArray视图,是用来向网卡、声卡之类的本机设备传送数据,所以使用本机的字节序就可以了;而DataView视图的设计目的,是用来处理网络设备传来的数据,所以大端字节序或小端字节序是可以自行设定的。

    DataView视图本身也是构造函数,接受一个ArrayBuffer对象作为参数,生成视图。

    DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);
    下面是一个例子。

    var buffer = new ArrayBuffer(24);
    var dv = new DataView(buffer);

    DataView实例有以下属性,含义与TypedArray实例的同名方法相同。

    DataView.prototype.buffer:返回对应的ArrayBuffer对象
    DataView.prototype.byteLength:返回占据的内存字节长度
    DataView.prototype.byteOffset:返回当前视图从对应的ArrayBuffer对象的哪个字节开始
    DataView实例提供8个方法读取内存。

    getInt8:读取1个字节,返回一个8位整数。
    getUint8:读取1个字节,返回一个无符号的8位整数。
    getInt16:读取2个字节,返回一个16位整数。
    getUint16:读取2个字节,返回一个无符号的16位整数。
    getInt32:读取4个字节,返回一个32位整数。
    getUint32:读取4个字节,返回一个无符号的32位整数。
    getFloat32:读取4个字节,返回一个32位浮点数。
    getFloat64:读取8个字节,返回一个64位浮点数。
    这一系列get方法的参数都是一个字节序号(不能是负数,否则会报错),表示从哪个字节开始读取。

    var buffer = new ArrayBuffer(24);
    var dv = new DataView(buffer);
    
    // 从第1个字节读取一个8位无符号整数
    var v1 = dv.getUint8(0);
    
    // 从第2个字节读取一个16位无符号整数
    var v2 = dv.getUint16(1);
    
    // 从第4个字节读取一个16位无符号整数
    var v3 = dv.getUint16(3);

    上面代码读取了ArrayBuffer对象的前5个字节,其中有一个8位整数和两个十六位整数。

    如果一次读取两个或两个以上字节,就必须明确数据的存储方式,到底是小端字节序还是大端字节序。默认情况下,DataView的get方法使用大端字节序解读数据,如果需要使用小端字节序解读,必须在get方法的第二个参数指定true。

    // 小端字节序
    var v1 = dv.getUint16(1, true);
    
    // 大端字节序
    var v2 = dv.getUint16(3, false);
    
    // 大端字节序
    var v3 = dv.getUint16(3);

    DataView视图提供8个方法写入内存。

    setInt8:写入1个字节的8位整数。
    setUint8:写入1个字节的8位无符号整数。
    setInt16:写入2个字节的16位整数。
    setUint16:写入2个字节的16位无符号整数。
    setInt32:写入4个字节的32位整数。
    setUint32:写入4个字节的32位无符号整数。
    setFloat32:写入4个字节的32位浮点数。
    setFloat64:写入8个字节的64位浮点数。
    这一系列set方法,接受两个参数,第一个参数是字节序号,表示从哪个字节开始写入,第二个参数为写入的数据。对于那些写入两个或两个以上字节的方法,需要指定第三个参数,false或者undefined表示使用大端字节序写入,true表示使用小端字节序写入。

    // 在第1个字节,以大端字节序写入值为25的32位整数
    dv.setInt32(0, 25, false);
    
    // 在第5个字节,以大端字节序写入值为25的32位整数
    dv.setInt32(4, 25);
    
    // 在第9个字节,以小端字节序写入值为2.5的32位浮点数
    dv.setFloat32(8, 2.5, true);
    如果不确定正在使用的计算机的字节序,可以采用下面的判断方式。
    
    var littleEndian = (function() {
      var buffer = new ArrayBuffer(2);
      new DataView(buffer).setInt16(0, 256, true);
      return new Int16Array(buffer)[0] === 256;
    })();

    如果返回true,就是小端字节序;如果返回false,就是大端字节序。

    二进制数组的应用

    大量的Web API用到了ArrayBuffer对象和它的视图对象。

    AJAX

    传统上,服务器通过AJAX操作只能返回文本数据,即responseType属性默认为text。XMLHttpRequest第二版XHR2允许服务器返回二进制数据,这时分成两种情况。如果明确知道返回的二进制数据类型,可以把返回类型(responseType)设为arraybuffer;如果不知道,就设为blob。

    var xhr = new XMLHttpRequest();
    xhr.open('GET', someUrl);
    xhr.responseType = 'arraybuffer';
    
    xhr.onload = function () {
      var let arrayBuffer = xhr.response;
      // ···
    };
    
    xhr.send();

    如果知道传回来的是32位整数,可以像下面这样处理。

    xhr.onreadystatechange = function () {
      if (req.readyState === 4 ) {
        var arrayResponse = xhr.response;
        var dataView = new DataView(arrayResponse);
        var ints = new Uint32Array(dataView.byteLength / 4);
    
        xhrDiv.style.backgroundColor = "#00FF00";
        xhrDiv.innerText = "Array is " + ints.length + "uints long";
      }
    }

    Canvas

    网页Canvas元素输出的二进制像素数据,就是类型化数组。

    var canvas = document.getElementById('myCanvas');
    var ctx = canvas.getContext('2d');
    
    var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
    var uint8ClampedArray = imageData.data;

    需要注意的是,上面代码的typedArray虽然是一个类型化数组,但是它的视图类型是一种针对Canvas元素的专有类型Uint8ClampedArray。这个视图类型的特点,就是专门针对颜色,把每个字节解读为无符号的8位整数,即只能取值0~255,而且发生运算的时候自动过滤高位溢出。这为图像处理带来了巨大的方便。

    举例来说,如果把像素的颜色值设为Uint8Array类型,那么乘以一个gamma值的时候,就必须这样计算:

    u8[i] = Math.min(255, Math.max(0, u8[i] * gamma));

    因为Uint8Array类型对于大于255的运算结果(比如0xFF+1),会自动变为0x00,所以图像处理必须要像上面这样算。这样做很麻烦,而且影响性能。如果将颜色值设为Uint8ClampedArray类型,计算就简化许多。

    pixels[i] *= gamma;

    Uint8ClampedArray类型确保将小于0的值设为0,将大于255的值设为255。注意,IE 10不支持该类型。

    WebSocket

    WebSocket可以通过ArrayBuffer,发送或接收二进制数据。

    var socket = new WebSocket('ws://127.0.0.1:8081');
    socket.binaryType = 'arraybuffer';
    
    // Wait until socket is open
    socket.addEventListener('open', function (event) {
      // Send binary data
      var typedArray = new Uint8Array(4);
      socket.send(typedArray.buffer);
    });
    
    // Receive binary data
    socket.addEventListener('message', function (event) {
      var arrayBuffer = event.data;
      // ···
    });

    Fetch API

    Fetch API取回的数据,就是ArrayBuffer对象。

    fetch(url)
    .then(function(request){
      return request.arrayBuffer()
    })
    .then(function(arrayBuffer){
      // ...
    });

    File API

    如果知道一个文件的二进制数据类型,也可以将这个文件读取为ArrayBuffer对象。

    var fileInput = document.getElementById('fileInput');
    var file = fileInput.files[0];
    var reader = new FileReader();
    reader.readAsArrayBuffer(file);
    reader.onload = function () {
      var arrayBuffer = reader.result;
      // ···
    };

    下面以处理bmp文件为例。假定file变量是一个指向bmp文件的文件对象,首先读取文件。

    var reader = new FileReader();
    reader.addEventListener("load", processimage, false);
    reader.readAsArrayBuffer(file);

    然后,定义处理图像的回调函数:先在二进制数据之上建立一个DataView视图,再建立一个bitmap对象,用于存放处理后的数据,最后将图像展示在canvas元素之中。

    function processimage(e) {
      var buffer = e.target.result;
      var datav = new DataView(buffer);
      var bitmap = {};
      // 具体的处理步骤
    }

    具体处理图像数据时,先处理bmp的文件头。具体每个文件头的格式和定义,请参阅有关资料。

    bitmap.fileheader = {};
    bitmap.fileheader.bfType = datav.getUint16(0, true);
    bitmap.fileheader.bfSize = datav.getUint32(2, true);
    bitmap.fileheader.bfReserved1 = datav.getUint16(6, true);
    bitmap.fileheader.bfReserved2 = datav.getUint16(8, true);
    bitmap.fileheader.bfOffBits = datav.getUint32(10, true);

    接着处理图像元信息部分。

    bitmap.infoheader = {};
    bitmap.infoheader.biSize = datav.getUint32(14, true);
    bitmap.infoheader.biWidth = datav.getUint32(18, true);
    bitmap.infoheader.biHeight = datav.getUint32(22, true);
    bitmap.infoheader.biPlanes = datav.getUint16(26, true);
    bitmap.infoheader.biBitCount = datav.getUint16(28, true);
    bitmap.infoheader.biCompression = datav.getUint32(30, true);
    bitmap.infoheader.biSizeImage = datav.getUint32(34, true);
    bitmap.infoheader.biXPelsPerMeter = datav.getUint32(38, true);
    bitmap.infoheader.biYPelsPerMeter = datav.getUint32(42, true);
    bitmap.infoheader.biClrUsed = datav.getUint32(46, true);
    bitmap.infoheader.biClrImportant = datav.getUint32(50, true);

    最后处理图像本身的像素信息。

    var start = bitmap.fileheader.bfOffBits;
    bitmap.pixels = new Uint8Array(buffer, start);

    至此,图像文件的数据全部处理完成。下一步,可以根据需要,进行图像变形,或者转换格式,或者展示在Canvas网页元素之中。

    展开全文
  • 四字、双字、单字、字节是数据类型,定义了数据的容量与精度,比如字节(byte)为八位二进制,范围为0-,单字(char)为16位二进制,范围0-,以此类推。我们可以用间接的方法来处理小数的二进制转换:一个十进制小数可以...

    系统自带的计算器是不支持小数位转换的。角度是DEG,弧度是RAD,梯度是GRA,转换模式的方法是按MODE,然后按相应的键。二进制,八进制,十六进制和十进制一样是进位制式。四字、双字、单字、字节是数据类型,定义了数据的容量与精度,比如字节(byte)为八位二进制,范围为0-,单字(char)为16位二进制,范围0-,以此类推。我们可以用间接的方法来处理小数的二进制转换:一个十进制小数可以表示成“X.Y”的形式,“X”是整数部分,“Y”是纯小数部分,要分别进行转换,最后合在一起。整数部分“X”的转换成二进制可以直接利用Windows的计算器,非常简单,不说了。对纯小数部分“Y”的转换,要提前设定转换精度,比如精确到小数点后16位。别理解错了,对于二进制的小数点后16位在精度上仅相当于十进制小数点后的5位,并非十分高!将“0.Y”乘以2的16次方,即“0.Y×”,结果可能会有小数部分,将小数部分四舍五入到个位,得到一个没有小数部分的纯整数,称作“Z”。利用Windows计算器将“Z”转换成二进制,若结果不足16位,则在最前面补0,补够16位。这就是小数部分“Y”对应的二进制了。现在将“X”和“Y”对应的二进制数码合在一起(中间当然要有小数点),就是最终结果了!举个实例:把十进制纯小数“0.”转换成二进制小数。0.×=.四舍五入后得到“”,转换成二进制为“”,只有13位,前面需要补3个“0”,得到“”。因此结果是0.=(0.)2=(0.)16

    计算机二进制怎么算

    从右往左数,把数字所在位置-1得到的数做底数为'2'的指数.再乘以相应位置上的数'0'或'1'.最后全部加起来,就是你给出的二进制的十进制表示。=2^3x0+2^2x0+2^1x0+2^0x1=1

    =2^3x0+2^2x0+2^1x1+2^0x0=2

    =2^3x0+2^2x1+2^1x0+2^0x0=4

    =2^3x1+2^2x0+2^1x0+2^0x0=8

    =2^3x0+2^2x1+2^1x1+2^0x0=6

    二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统,数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关,用1来表示“开”,0来表示“关”。

    二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统。

    数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关,用“开”来表示1,“关”来表示0。

    20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用,因为数字计算机只能识别和处理由‘0’.‘1’符号串组成的代码。其运算模式正是二进制。19世纪爱尔兰逻辑学家乔治布尔对逻辑命题的思考过程转化为对符号"0''.''1''的某种代数演算,二进制是逢2进位的进位制。0、1是基本算符。因为它只使用0、1两个数字符号,非常简单方便,易于用电子方式实现。

    20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用,因为数字计算机只能识别和处理由‘0’.‘1’符号串组成的代码。其运算模式正是二进制。19世纪爱尔兰逻辑学家乔治布尔对逻辑命题的思考过程转化为对符号"0''.''1''的某种代数演算,二进制是逢2进位的进位制。0、1是基本算符。因为它只使用0、1两个数字符号,非常简单方便,易于用电子方式实现。

    二进制和十六进制,八进制一样,都以二的幂来进位的。

    主要特点数字装置简单可靠,所用元件少;

    只有两个数码0和1,因此它的每一位数都可用任何具有两个不同稳定状态的元件来表示;

    基本运算规则简单,运算操作方便。用二进制表示一个数时,位数多。因此实际使用中多采用送入数字系统前用十进制,送入机器后再转换成二进制数,让数字系统进行运算,运算结束后再将二进制转换为十进制供人们阅读。

    二进制和十六进制的互相转换比较重要。不过这二者的转换却不用计算,每个C,C++程序员都能做到看见二进制数,直接就能转换为十六进制数,反之亦然。

    展开全文
  • C语言十进制转二进制代码实例用C语言实现将十进制转化为二进制,并统计转换后的二进制码中1的个数。#include int binaryNum[16]; //存放转换后得到的二进制码int count=0; //计数十进制整数被2除的次数int oneCount=...

    C语言十进制转二进制代码实例

    用C语言实现将十进制转化为二进制,并统计转换后的二进制码中1的个数。

    #include

    int binaryNum[16]; //存放转换后得到的二进制码

    int count=0; //计数十进制整数被2除的次数

    int oneCount=0; //得到的二进制码中1的个数

    void main(){

    int num;

    printf("输入一个十进制的整数:");

    scanf("%d",&num);

    while( (num/2) != 1 ){ //判断条件为:除以2之后的商不等于1

    binaryNum[count] = num%2; //取余后的数字存入数组

    num /= 2; //num = num/2; 进行下一轮的判断

    count++; //此变量用来指定数组下标

    }

    binaryNum[count+1] = 1; //最后一次除法做完以后,剩下的商一定是1,所以在最后手动添加一个1

    printf("二进制数值为:");

    //倒序打印出数组中的元素

    // sizeof(整形数组)/sizeof(整形单个元素大小) = 数组的元素个数

    for( int i=sizeof(binaryNum)/sizeof(int)-1; i>=0; i-- ){

    if( binaryNum[i] == 1)

    oneCount++; //出现一次1就累加

    printf("%d",binaryNum[i]);

    }

    printf("\n共有%d个1\n",oneCount);

    }

    时间: 2014-06-17

    [程序1]题目:有1.2.3.4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?1.程序分析:可填在百位.十位.个位的数字都是1.2.3.4.组成所有的排列后再去 掉不满足条件的排列. 2.程序源代码: 复制代码 代码如下: #include "stdio.h"#include "conio.h"main(){  int i,j,k;  printf("\n");  for(i=1;i<5;i++) /*以下为三重循环*/

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    C语言/C++怎样产生随机数:这里要用到的是rand()函数, srand()函数,和time()函数. 需要说明的是,iostream头文件中就有srand函数的定义,不需要再额外引入stdlib.h;而使用time()函数需要引入ctime头文件. 使用rand()函数获取一个随机数如果你只要产生随机数而不需要设定范围的话,你只要用rand()就可以了:rand()会返回一随机数值, 范围在0至RAND_MAX 间.RAND_MAX定义在stdlib.h, 其值为2147483647. 例子

    fopen(打开文件)相关函数 open,fclose表头文件 #include定义函数 FILE * fopen(const char * path,const char * mode);函数说明 参数path字符串包含欲打开的文件路径及文件名,参数mode字符串则代表着流形态.mode有下列几种形态字符串:r 打开只读文件,该文件必须存在.r+ 打开可读写的文件,该文件必须存在.w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失.若文件不存在则建立该文件.w

    每当想找哪个运算符优先级高时,很多时候总是想找的就没有,真让人气愤!现在,终于有个我个人觉得非常全的,分享给大家,欢迎拍砖! C语言运算符优先级 优先级 运算符 名称或含义 使用形式 结合方向 说明 1 [] 数组下标 数组名[常量表达式] 左到右 -- () 圆括号 (表达式)/函数名(形参表) -- . 成员选择(对象) 对象.成员名 -- -> 成员选择(指针) 对象指针->成员名 -- 2 - 负号运算符 -表达式 右到左 单目运算符 ~ 按位取反运算符 ~表达式 ++ 自增运算符 +

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    C语言中实现"17进制"转"10进制"实例代码 17进制转成10进制,输入是数字跟大写字母.例如输入G.11.FF,分别输出16.18.270 #include #include using namespace std; int main() { string s; int len,factor=17,num; bool sign;//用来标志输入字符串是否非法 while(cin>>s)

    指向结构体类型变量的使用首先让我们定义结构体:struct stu{char name[20];long number;float score[4];} ;再定义指向结构体类型变量的指针变量:struct stu *p1, *p2 ;定义指针变量p 1.p 2,分别指向结构体类型变量.引用形式为:指针变量→成员:[例7-2] 对指向结构体类型变量的正确使用.输入一个结构体类型变量的成员,并输出. 复制代码 代码如下: #include /*使用m a l l o c (

    system()函数功能强大,很多人用却对它的原理知之甚少先看linux版system函数的源码: 复制代码 代码如下: #include #include #include #include int system(const char * cmdstring){    pid_t pid;    int status; if(cmdstring == NULL){

    1.字符数组的定义与初始化字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素.char str[10]={ 'I',' ','a','m',' ','h','a','p','p','y'};即把10个字符分别赋给str[0]到str[9]10个元素如果花括号中提供的字符个数大于数组长度,则按语法错误处理:若小于数组长度,则只将这些字符数组中前面那些元素,其余的元素自动定为空字符(即 '\0' ). 2.字符数组与字符串在c语言中,将字符串作为字符数组来处理.(c++中不是)在实际应用

    本文实例讲述了js数组常见操作及数组与字符串相互转化方法.分享给大家供大家参考,具体如下: 数组与字符串的相互转化

    本文实例讲述了Java中char数组(字符数组)与字符串String类型的转换方法.分享给大家供大家参考,具体如下: 在Java语言编程时,使用"口令字段"jPasswordField组件时,如果要获得密码值,就需要使用该组件的getPassword()方法.jPasswordField的getPassword()方法返回一个char类型的数组,我们经常需要将这个数组转换为String类型,以便进行诸如口令匹配或口令赋值等操作.这时,就需要将char类型的数组进行转换.当然也经常会遇到

    本文实例讲述了C#实现char字符数组与字符串相互转换的方法.分享给大家供大家参考,具体如下: 一.字符串转换为字符数组 char[] tempChar = sourceString.ToCharArray(); 二.字符数组转换为字符串 //方法一 string str = string.Join("", tempChar); //方法二 string str = string.Concat(tempChar); //方法三 string str = new

    2016425154607514.jpg?2016325154615

    字符数组倒序 #include void daoxu(char str[]){ int i; char temp; for(i = 0; i < strlen(str) / 2 ; i ++){ temp = str[i]; str[i] = str[strlen(str) - i-1]; str[strlen(str) - i-1] = temp; } } 单词计数    int wordCount(char str[]){ int i; int count = 0

    C语言文件操作中 fgets.fputs 函数详解 先给出api fgets 语法: #include char *fgets( char *str, int num, FILE *stream ); 函数fgets()从给出的文件流中读取[num - 1]个字符并且把它们转储到str(字符串)中. fgets()在到达行末时停止,在这种情况下,str(字符串)将会被一个新行符结束. 如果fgets()达到[num - 1]个字符或者遇到EOF, str(字符串)将会以nu

    把一个字符串中的字符重新排列生成新的字符串,返回新生成的字符串里没有连续重复字符的字符串个数.连续重复只以单个字符为准 例如, aab 应该返回 2 因为它总共有6中排列 (aab, aab, aba, aba, baa, baa),但是只有两个 (aba and aba)没有连续重复的字符 (在本例中是 a). 从网上资料获得了一些思路,我的代码: function permAlone(str) { var arr=str.split(""); var perarr=[]; var

    2017811141533541.png?2017711141544

    C语言模拟实现atoi函数的实例详解 atoi函数,主要功能是将一个字符串转变为整数,例如将"12345"–>12345.但在实现过程中,我们难免会因为考虑不够全面而漏掉比较重要的几点,今天就总结一下实现atoi函数需要注意的地方. 1.指针为NULL 2.字符串为空字符串 3.空白字符 4.正号与负号问题 5.溢出问题 6.异常字符处理 接下来看代码:(具体几种问题处理都在代码的注释中说明) #define _CRT_SECURE_NO_WARNINGS 1 #include

    API(Application Programming Interface):应用程序编程接口 使用Scanner 获取键盘录入的字符串 next() ; 在遇到空格的时候 会判定为当前的输入结束 空格之后的内容会收不到 nextLine(); 可以避免被空格中断 , 但是在于接收数字一起使用的时候会被干扰 创建字符串对象 public String(String original) ---> 通过字符串创建一个字符串对象 public String(char[] value) -=--> 通

    字符串的特点 1.  其他类型的数据用在字符串类型处理函数中,会自动将其转化成字符串后,在处理 <?php echo substr("abcdefghijklmn",2,4),"
    "; //cdef //使用数字会自动转化为字符串 echo substr(123456,2,4); //3456 ?> 2. 可以将字符串视为数组,当做字符集合来看待 <?php $str="abcdefg"; //下面这两种方法都

    展开全文
  • 二进制完整版教案》由会员分享,可在线阅读,更多相关《二进制完整版教案(7页珍藏版)》请在人人文库网上搜索。1、教学目标通过对二进制数的学习, 使学生掌握计算机中信息表示的方法, 从而对信息的数字化有所认识...
  • 计算机中使用二进制的里有是因为二进制表示具有可行性、算术运算规则简单、逻辑运算方便、使用硬件容易实现等特点。下面是学习啦小编为大家整理的计算机与二进制的资料,希望对您有所帮助!计算机与二进制的表示1.数...
  • 三进制代码的一个特点是对称,即相反数的一致性,因此它和二进制代码不同,不存在无符号数的概念。这样,三进制计算机的架构也要简单、稳定、经济得多。其指令系统也更便于阅读,而且非常高效。第一台三进制计算机的...
  • 满意答案sqq2125272013.04.11采纳率:46%等级:12已帮助:10556人编辑本段简介 20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用,其运算模式正是二进制,同时证明了莱布尼兹的原理是正确的。...
  • 简述二进制

    2019-11-03 10:36:28
    1.二进制 1.1二进制的由来 17世纪至18世纪的德国数学家莱布尼茨,是世界上第一个提出二进制记数法的人。他对帕斯卡的加法器进行了改进,设计并制造了一种手摇的演算机,提出了他认为吻合中国“先天八卦”的二进制,...
  • 二进制

    2017-11-14 09:58:00
    二进制 编辑 本词条由“科普中国”百科科学词条编写与应用工作项目审核 。 二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则...
  • 计算机中十进制转换为二进制的另一方法-------“定位减权法”胡燏(四川建筑职业技术学院计算机系,618000)【摘要】本文从十进制与二进制特点入手,介绍一种把十进制数转换为二进制的新方法。【关键字】十进制 ...
  • 二进制和十进制之间的转换.ppt》由会员分享,提供在线免费全文阅读可下载,此文档格式为ppt,更多相关《二进制和十进制之间的转换.ppt》文档请在天天文库搜索。1、计算机中的十进制与二进制的转换【 课 题 】 ...
  • 格雷码,又叫循环二进制码或反射二进制码,格雷码是我们在工程中常会遇到的一种编码方式,它的基本的特点就是任意两个相邻的代码只有一位二进制数不同。 二进制格雷码与自然二进制码的互换 1、二进制码转换成...
  • 二进制代码

    千次阅读 2020-09-14 00:30:38
    二进制 十-二进制之间的转化 十六进制 八进制 二进制数的算术运算 无符号二进制数的算术运算 带符号二进制数的减法运算 二进制代码 二-十进制码 格雷码 ASCII码 二值逻辑变量与基本逻辑 逻辑函数及其表示方法 逻辑...
  • 二进制的概念 1,2,3,4,5等数字为十进制...二进制具有抗干扰能力强,可靠性高等特点 二进制和十进制的互相转换 二进制转十进制时,每个数乘以2的n-1次方,为当个数字所在序位(倒序 ) 十转二为不断除以2,计余数..
  • 而绝对式编码器是直接输出数字量的传感器,它是利用自然二进制或循环二进制(格雷码)方式进行光电转换的,编码的设计一般是采用自然二进制码、循环二进制码、二进制补码等。特点是不要计数器,在转轴的任意位置都可...
  • 别名:低级语言,二进制代码语言定义:机器语言是直接用二进制代码指令表达的计算机语言,指令是用0和1组成的一串代码,它们有一定的位数,并分成若干段,各段的编码表示不同的含义,例如某台计算机字长为16位,即有...
  • 计算机为什么使用二进制2018-09-23计算机为什么采用二进制编码电子计算机所采用的是二进制!为什么不采用十进制呢?这是很多初学者感到困惑的地方。我们从几个方面来分析这个问题。首先是受制于元器件。我们知道组成...
  • java二进制

    2019-11-01 14:36:22
    java二进制 好久没有使用过二进制进行数据传输,基本的知识已经忘了,先来回顾一下数学知识(参考:https://www.cnblogs.com/wkcn/p/7803147.html): 进制的表现形式   二进制: 由0和1两个数字组成。  八进制...
  • 计算机中常用的计数制用若干数位(由数码表示)...另外,还有二进制、八进制和十六进制等。在计算机的数制中,要掌握3个概念,即数码、基数和位权。下面简单地介绍这3个概念。数码:一个数制中表示基本数值大小的不同...
  • 二进制运算规则 (6页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!14.90 积分课时数 NO:年月日 星期教案内容2.3 二进制数的运算规则2.4 数的定点与浮点表示教案目的...
  • 二进制与十进制的转换教案【教学目的与要求】1、熟悉数制的概念;2、掌握位权表示法;3、熟练掌握二进制与十进制之间的转换方法。【课时安排】 1课时。【教学重点与难点】1、难点:位权表示法 十进制转化为二进制2、...
  • 《趣味数学计算机中数据的存储二进制》由会员分享,可在线阅读,更多相关《趣味数学计算机中数据的存储二进制(29页珍藏版)》请在人人文库网上搜索。1、计算机中的数学,计算机中数据的表示,众所周知,所有的数据在...
  • 二进制树型搜索算法 二进制搜索算法 (Binary Search Algorithm) Binary Search is applied on the sorted array or list of large size. It's time complexity of O(log n) makes it very fast as compared to ...
  • 二进制学习记录

    2019-06-10 16:14:55
    二进制(binary system): 1、计算机均使用二进制 二进制与10进制之间的转换 1.因为10进制用于计数,二进制也用于计数,转换是指, 表示相同个数的时候,10进制的数字和二进制的数字 是相当的双字 2.计算机内部...
  • 二进制转换

    2021-03-04 14:18:51
    特点是逢二进一,因此在二进制中只有0和1两个数字符号。基数为2,数值部分用两个不同的数字符号0、1来表示。如(1010)2或1010B. 2、十进制 用后缀D表示或无后缀。基数是10,数值部分用十个不同的数字符号0、1、2、3...
  • 缩短二进制

    2021-04-11 20:24:06
    在计算机内存中是以二进制补码形式存储,但通常二进制表示的整数比较长,为了便于在程序设计过程中理解和处理数据,通常采用八进制和十六进制,缩短了二进制补码表示的整数,但保持了二进制数的表达特点。...
  • 计算机二进制编码

    2020-10-17 17:00:56
    二进制编码知识。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 241,504
精华内容 96,601
关键字:

二进制特点