• 关于 函数的名字-name属性 的搜索结果

问题

【分享】WeX5的正确打开方式(7)——数据组件详解

小太阳1号 2019-12-01 21:38:53 5902 浏览量 回答数 1

问题

详解 Spring 3.0 基于 Annotation 的依赖注入实现 配置报错 

kun坤 2020-06-01 09:44:47 3 浏览量 回答数 1

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:16 0 浏览量 回答数 0

海外云虚拟主机包年25元/月起

海外独享虚拟主机全面上线,助力构建海外网站,提升公司国际形象;全球有效覆盖,超高性价比;建站入门首选,助力出口,适合跨境贸易企业。

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:16 0 浏览量 回答数 0

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:16 0 浏览量 回答数 0

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:17 0 浏览量 回答数 0

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:17 0 浏览量 回答数 0

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:16 0 浏览量 回答数 0

回答

详细解答可以参考官方帮助文档一个Bucket下可能有非常多的文件,SDK提供一系列的接口方便用户管理文件。 查看所有文件通过list来列出当前Bucket下的所有文件。主要的参数如下: prefix 指定只列出符合特定前缀的文件marker 指定只列出文件名大于marker之后的文件delimiter 用于获取文件的公共前缀max-keys 用于指定最多返回的文件个数 let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function list () { try { // 不带任何参数,默认最多返回1000个文件 let result = await client.list(); console.log(result); // 根据nextMarker继续列出文件 if (result.isTruncated) { let result = await client.list({ marker: result.nextMarker }); } // 列出前缀为'my-'的文件 let result = await client.list({ prefix: 'my-' }); console.log(result); // 列出前缀为'my-'且在'my-object'之后的文件 let result = await client.list({ prefix: 'my-', marker: 'my-object' }); console.log(result); } catch (e) { console.log(e); }}list(); 模拟目录结构OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录结构。公共前缀的概念请参考列出Object。 假设Bucket中已有如下文件: foo/xfoo/yfoo/bar/afoo/bar/bfoo/hello/C/1foo/hello/C/2...foo/hello/C/9999接下来我们实现一个函数叫listDir,列出指定目录下的文件和子目录: let OSS = require('ali-oss');let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function listDir(dir) let result = await client.list({ prefix: dir, delimiter: '/' }); result.prefixes.forEach(function (subDir) { console.log('SubDir: %s', subDir); }); result.objects.forEach(function (obj) { console.log(Object: %s', obj.name); });end 运行结果如下: > await listDir('foo/')=> SubDir: foo/bar/ SubDir: foo/hello/ Object: foo/x Object: foo/y> await listDir('foo/bar/')=> Object: foo/bar/a Object: foo/bar/b> await listDir('foo/hello/C/')=> Object: foo/hello/C/1 Object: foo/hello/C/2 ... Object: foo/hello/C/9999文件元信息向OSS上传文件时,除了文件内容,还可以指定文件的一些属性信息,称为“元信息”。这些信息在上传时与文件一起存储,在下载时与文件一起返回。 因为文件元信息在上传/下载时是附在HTTP Headers中, HTTP协议规定不能包含复杂字符。因此元信息只能是简单的ASCII可见字符,不能包含换行。 所有元信息的总大小不能超过8KB。 使用put,putStream和multipartUpload时都可以通过指定meta参数来指定文件的元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function put () { try { let result = await client.put('object-key', 'local-file', { meta: { year: 2016, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}put(); 通过putMeta接口来更新文件元信息: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function putMeta () { try { let result = await client.putMeta('object-key', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }}putMeta(); 拷贝文件使用copy拷贝一个文件。拷贝可以发生在下面两种情况: 同一个Bucket两个不同Bucket,但是它们在同一个region,此时的源Object名字应为’/bucket/object’的形式 另外,拷贝时对文件元信息的处理有两种选择: 如果没有指定meta参数,则与源文件相同,即拷贝源文件的元信息如果指定了meta参数,则使用新的元信息覆盖源文件的信息 let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function copy () { try { // 两个Bucket之间拷贝 let result = await client.copy('to', '/from-bucket/from'); console.log(result); // 拷贝元信息 let result = await client.copy('to', 'from'); console.log(result); // 覆盖元信息 let result = await client.copy('to', 'from', { meta: { year: 2015, people: 'mary' } }); console.log(result); } catch (e) { console.log(e); }} 删除文件通过delete来删除某个文件: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function delete () { try { let result = yield client.delete('object-key'); console.log(result); } catch (e) { console.log(e); }}delete(); 批量删除文件通过deleteMulti来删除一批文件,用户可以通过quiet参数来指定是否返回删除的结果: let OSS = require('ali-oss')let client = new OSS({ region: '<Your region>', accessKeyId: '<Your AccessKeyId>', accessKeySecret: '<Your AccessKeySecret>', bucket: 'Your bucket name'});async function deleteMulti () { try { let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3']); console.log(result); let result = await client.deleteMulti(['obj-1', 'obj-2', 'obj-3'], { quiet: true }); console.log(result); } catch (e) { console.log(e); }}deleteMulti();

2019-12-01 23:14:17 0 浏览量 回答数 0

问题

Python基础测验(答案篇)

珍宝珠 2019-12-01 22:02:53 603 浏览量 回答数 1

问题

第三章 – 布局,块和模板:报错

kun坤 2020-06-06 16:14:05 0 浏览量 回答数 1

问题

手把手学IOT服务端API编程[4、设备注册][step by step ALI-IOT-SERVER-API]

洵云 2019-12-01 21:54:45 1220 浏览量 回答数 0

问题

在Eclipse中配置Heritrix HTTP ERROR 403.10 禁止访问:配置无效

kun坤 2020-05-27 20:05:38 7 浏览量 回答数 1

问题

深入理解Magento – 第六章 – 高级Magento模型 - Magento报错

montos 2020-06-03 20:30:01 2 浏览量 回答数 1

问题

深入理解Magento – 第六章 – 高级Magento模型 :报错

kun坤 2020-06-14 15:19:25 0 浏览量 回答数 1

问题

深入理解Magento – 第六章 – 高级Magento模型:配置报错 

kun坤 2020-06-02 14:47:07 2 浏览量 回答数 1

问题

【精品问答】python技术1000问(1)

问问小秘 2019-12-01 21:57:48 448858 浏览量 回答数 12

问题

[IBM DW] 用 inotify 监控 Linux 文件系统事件:报错

kun坤 2020-06-07 16:43:37 0 浏览量 回答数 1

回答

Pandas是Python的一个大数据处理模块。Pandas使用一个二维的数据结构DataFrame来表示表格式的数据,相比较于Numpy,Pandas可以存储混合的数据结构,同时使用NaN来表示缺失的数据,而不用像Numpy一样要手工处理缺失的数据,并且Pandas使用轴标签来表示行和列。 DataFrame类: DataFrame有四个重要的属性: index:行索引。 columns:列索引。 values:值的二维数组。 name:名字。 构建方法,DataFrame(sequence),通过序列构建,序列中的每个元素是一个字典。 frame=DateFrame构建完之后,假设frame中有’name’,’age’,’addr’三个属性,可以使用fame[‘name’]查看属性列内容,也可以fame.name这样直接查看。 frame按照’属性提取出来的每个列是一个Series类。 DataFrame类可以使用布尔型索引。 groupby(str|array…)函数:可以使用frame中对应属性的str或者和frame行数相同的array作为参数还可以使用一个会返回和frame长度相同list的函数作为参数,如果使用函数做分组参数,这个用做分组的函数传入的参数将会是fame的index,参数个数任意。使用了groupby函数之后配合,size()函数就可以对groupby结果进行统计。 groupby后可以使用: size():就是count sum():分组求和 apply(func,axis=0):在分组上单独使用函数func返回frame,不groupby用在DataFrame会默认将func用在每个列上,如果axis=1表示将func用在行上。 reindex(index,column,method):用来重新命名索引,和插值。 size():会返回一个frame,这个frame是groupby后的结果。 sum(n).argsort():如果frame中的值是数字,可以使用sum函数计算frame中摸个属性,各个因子分别求和,并返回一个Series,这个Series可以做为frame.take的参数,拿到frame中对应的行。 pivot_table(操作str1,index=str2,columns=str3,aggfunc=str4)透视图函数: str1:是给函数str4作为参数的部分。 str2:是返回frame的行名。 str3:是返回frame的列名。 str4:是集合函数名,有’mean’,’sum’这些,按照str2,str3分组。 使用透视图函数之后,可以使用.sum()这类型函数,使用后会按照index和columns的分组求和。 order_index(by,ascending): 返回一个根据by排序,asceding=True表示升序,False表示降序的frame concat(list):将一个列表的frame行数加起来。 ix[index]:就是行索引,DataFrame的普通下标是列索引。 take(index):作用和ix差不多,都是查询行,但是ix传入行号,take传入行索引。 unstack():将行信息变成列信息。 apply(func,axis=0)和applymap(func):apply用在DataFrame会默认将func用在每个列上,如果axis=1表示将func用在行上。applymap表示func用在每个元素上。 combine_first(frame2):combine_first会把frame中的空值用frame1中对应位置的数据进行填充。Series方法也有相同的方法。 stack()函数,可以将DataFrame的列转化成行,原来的列索引成为行的层次索引。(stack和unstack方法是两个互逆的方法,可以用来进行Series和DataFrame之间的转换) duplicated():返回一个布尔型Series,表示各行是否重复。 drop_duplicates():返回一个移除了重复行后的DataFrame pct_change():Series也有这个函数,这个函数用来计算同colnums两个相邻的数字之间的变化率。 corr():计算相关系数矩阵。 cov():计算协方差系数矩阵。 corrwith(Series|list,axis=0):axis=0时计算frame的每列和参数的相关系数。 数据框操作 df.head(1) 读取头几条数据 df.tail(1) 读取后几条数据 df[‘date’] 获取数据框的date列 df.head(1)[‘date’] 获取第一行的date列 df.head(1)‘date’ 获取第一行的date列的元素值 sum(df[‘ability’]) 计算整个列的和 df[df[‘date’] == ‘20161111’] 获取符合这个条件的行 df[df[‘date’] == ‘20161111’].index[0] 获取符合这个条件的行的行索引的值 df.iloc[1] 获取第二行 df.iloc1 获取第二行的test2值 10 mins to pandas df.index 获取行的索引 df.index[0] 获取第一个行索引 df.index[-1] 获取最后一个行索引,只是获取索引值 df.columns 获取列标签 df[0:2] 获取第1到第2行,从0开始,不包含末端 df.loc[1] 获取第二行 df.loc[:,’test1’] 获取test1的那一列,这个冒号的意思是所有行,逗号表示行与列的区分 df.loc[:,[‘test1’,’test2’]] 获取test1列和test2列的数据 df.loc[1,[‘test1’,’test2’]] 获取第二行的test1和test2列的数据 df.at[1,’test1’] 表示取第二行,test1列的数据,和上面的方法类似 df.iloc[0] 获取第一行 df.iloc[0:2,0:2] 获取前两行前两列的数据 df.iloc[[1,2,4],[0,2]] 获取第1,2,4行中的0,2列的数据 (df[2] > 1).any() 对于Series应用any()方法来判断是否有符合条件的

世事皆空 2019-12-02 01:07:19 0 浏览量 回答数 0

问题

【每日一题】SQL 知识大测验 | 持续更新

茶什i 2019-12-01 22:03:05 20900 浏览量 回答数 37

问题

Ice的更多细节 - ICE报错

montos 2020-06-03 21:55:58 3 浏览量 回答数 1

问题

Ice的更多细节 :报错

kun坤 2020-06-14 15:37:49 0 浏览量 回答数 1

回答

92题 一般来说,建立INDEX有以下益处:提高查询效率;建立唯一索引以保证数据的唯一性;设计INDEX避免排序。 缺点,INDEX的维护有以下开销:叶节点的‘分裂’消耗;INSERT、DELETE和UPDATE操作在INDEX上的维护开销;有存储要求;其他日常维护的消耗:对恢复的影响,重组的影响。 需要建立索引的情况:为了建立分区数据库的PATITION INDEX必须建立; 为了保证数据约束性需要而建立的INDEX必须建立; 为了提高查询效率,则考虑建立(是否建立要考虑相关性能及维护开销); 考虑在使用UNION,DISTINCT,GROUP BY,ORDER BY等字句的列上加索引。 91题 作用:加快查询速度。原则:(1) 如果某属性或属性组经常出现在查询条件中,考虑为该属性或属性组建立索引;(2) 如果某个属性常作为最大值和最小值等聚集函数的参数,考虑为该属性建立索引;(3) 如果某属性经常出现在连接操作的连接条件中,考虑为该属性或属性组建立索引。 90题 快照Snapshot是一个文件系统在特定时间里的镜像,对于在线实时数据备份非常有用。快照对于拥有不能停止的应用或具有常打开文件的文件系统的备份非常重要。对于只能提供一个非常短的备份时间而言,快照能保证系统的完整性。 89题 游标用于定位结果集的行,通过判断全局变量@@FETCH_STATUS可以判断是否到了最后,通常此变量不等于0表示出错或到了最后。 88题 事前触发器运行于触发事件发生之前,而事后触发器运行于触发事件发生之后。通常事前触发器可以获取事件之前和新的字段值。语句级触发器可以在语句执行前或后执行,而行级触发在触发器所影响的每一行触发一次。 87题 MySQL可以使用多个字段同时建立一个索引,叫做联合索引。在联合索引中,如果想要命中索引,需要按照建立索引时的字段顺序挨个使用,否则无法命中索引。具体原因为:MySQL使用索引时需要索引有序,假设现在建立了"name,age,school"的联合索引,那么索引的排序为: 先按照name排序,如果name相同,则按照age排序,如果age的值也相等,则按照school进行排序。因此在建立联合索引的时候应该注意索引列的顺序,一般情况下,将查询需求频繁或者字段选择性高的列放在前面。此外可以根据特例的查询或者表结构进行单独的调整。 86题 建立索引的时候一般要考虑到字段的使用频率,经常作为条件进行查询的字段比较适合。如果需要建立联合索引的话,还需要考虑联合索引中的顺序。此外也要考虑其他方面,比如防止过多的所有对表造成太大的压力。这些都和实际的表结构以及查询方式有关。 85题 存储过程是一组Transact-SQL语句,在一次编译后可以执行多次。因为不必重新编译Transact-SQL语句,所以执行存储过程可以提高性能。触发器是一种特殊类型的存储过程,不由用户直接调用。创建触发器时会对其进行定义,以便在对特定表或列作特定类型的数据修改时执行。 84题 存储过程是用户定义的一系列SQL语句的集合,涉及特定表或其它对象的任务,用户可以调用存储过程,而函数通常是数据库已定义的方法,它接收参数并返回某种类型的值并且不涉及特定用户表。 83题 减少表连接,减少复杂 SQL,拆分成简单SQL。减少排序:非必要不排序,利用索引排序,减少参与排序的记录数。尽量避免 select *。尽量用 join 代替子查询。尽量少使用 or,使用 in 或者 union(union all) 代替。尽量用 union all 代替 union。尽量早的将无用数据过滤:选择更优的索引,先分页再Join…。避免类型转换:索引失效。优先优化高并发的 SQL,而不是执行频率低某些“大”SQL。从全局出发优化,而不是片面调整。尽可能对每一条SQL进行 explain。 82题 如果条件中有or,即使其中有条件带索引也不会使用(要想使用or,又想让索引生效,只能将or条件中的每个列都加上索引)。对于多列索引,不是使用的第一部分,则不会使用索引。like查询是以%开头。如果列类型是字符串,那一定要在条件中将数据使用引号引用起来,否则不使用索引。如果mysql估计使用全表扫描要比使用索引快,则不使用索引。例如,使用<>、not in 、not exist,对于这三种情况大多数情况下认为结果集很大,MySQL就有可能不使用索引。 81题 主键不能重复,不能为空,唯一键不能重复,可以为空。建立主键的目的是让外键来引用。一个表最多只有一个主键,但可以有很多唯一键。 80题 空值('')是不占用空间的,判断空字符用=''或者<>''来进行处理。NULL值是未知的,且占用空间,不走索引;判断 NULL 用 IS NULL 或者 is not null ,SQL 语句函数中可以使用 ifnull ()函数来进行处理。无法比较 NULL 和 0;它们是不等价的。无法使用比较运算符来测试 NULL 值,比如 =, <, 或者 <>。NULL 值可以使用 <=> 符号进行比较,该符号与等号作用相似,但对NULL有意义。进行 count ()统计某列的记录数的时候,如果采用的 NULL 值,会被系统自动忽略掉,但是空值是统计到其中。 79题 HEAP表是访问数据速度最快的MySQL表,他使用保存在内存中的散列索引。一旦服务器重启,所有heap表数据丢失。BLOB或TEXT字段是不允许的。只能使用比较运算符=,<,>,=>,= <。HEAP表不支持AUTO_INCREMENT。索引不可为NULL。 78题 如果想输入字符为十六进制数字,可以输入带有单引号的十六进制数字和前缀(X),或者只用(Ox)前缀输入十六进制数字。如果表达式上下文是字符串,则十六进制数字串将自动转换为字符串。 77题 Mysql服务器通过权限表来控制用户对数据库的访问,权限表存放在mysql数据库里,由mysql_install_db脚本初始化。这些权限表分别user,db,table_priv,columns_priv和host。 76题 在缺省模式下,MYSQL是autocommit模式的,所有的数据库更新操作都会即时提交,所以在缺省情况下,mysql是不支持事务的。但是如果你的MYSQL表类型是使用InnoDB Tables 或 BDB tables的话,你的MYSQL就可以使用事务处理,使用SET AUTOCOMMIT=0就可以使MYSQL允许在非autocommit模式,在非autocommit模式下,你必须使用COMMIT来提交你的更改,或者用ROLLBACK来回滚你的更改。 75题 它会停止递增,任何进一步的插入都将产生错误,因为密钥已被使用。 74题 创建索引的时候尽量使用唯一性大的列来创建索引,由于使用b+tree做为索引,以innodb为例,一个树节点的大小由“innodb_page_size”,为了减少树的高度,同时让一个节点能存放更多的值,索引列尽量在整数类型上创建,如果必须使用字符类型,也应该使用长度较少的字符类型。 73题 当MySQL单表记录数过大时,数据库的CRUD性能会明显下降,一些常见的优化措施如下: 限定数据的范围: 务必禁止不带任何限制数据范围条件的查询语句。比如:我们当用户在查询订单历史的时候,我们可以控制在一个月的范围内。读/写分离: 经典的数据库拆分方案,主库负责写,从库负责读。垂直分区: 根据数据库里面数据表的相关性进行拆分。简单来说垂直拆分是指数据表列的拆分,把一张列比较多的表拆分为多张表。水平分区: 保持数据表结构不变,通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中,达到了分布式的目的。水平拆分可以支撑非常大的数据量。 72题 乐观锁失败后会抛出ObjectOptimisticLockingFailureException,那么我们就针对这块考虑一下重试,自定义一个注解,用于做切面。针对注解进行切面,设置最大重试次数n,然后超过n次后就不再重试。 71题 一致性非锁定读讲的是一条记录被加了X锁其他事务仍然可以读而不被阻塞,是通过innodb的行多版本实现的,行多版本并不是实际存储多个版本记录而是通过undo实现(undo日志用来记录数据修改前的版本,回滚时会用到,用来保证事务的原子性)。一致性锁定读讲的是我可以通过SELECT语句显式地给一条记录加X锁从而保证特定应用场景下的数据一致性。 70题 数据库引擎:尤其是mysql数据库只有是InnoDB引擎的时候事物才能生效。 show engines 查看数据库默认引擎;SHOW TABLE STATUS from 数据库名字 where Name='表名' 如下;SHOW TABLE STATUS from rrz where Name='rrz_cust';修改表的引擎alter table table_name engine=innodb。 69题 如果是等值查询,那么哈希索引明显有绝对优势,因为只需要经过一次算法即可找到相应的键值;当然了,这个前提是,键值都是唯一的。如果键值不是唯一的,就需要先找到该键所在位置,然后再根据链表往后扫描,直到找到相应的数据;如果是范围查询检索,这时候哈希索引就毫无用武之地了,因为原先是有序的键值,经过哈希算法后,有可能变成不连续的了,就没办法再利用索引完成范围查询检索;同理,哈希索引也没办法利用索引完成排序,以及like ‘xxx%’ 这样的部分模糊查询(这种部分模糊查询,其实本质上也是范围查询);哈希索引也不支持多列联合索引的最左匹配规则;B+树索引的关键字检索效率比较平均,不像B树那样波动幅度大,在有大量重复键值情况下,哈希索引的效率也是极低的,因为存在所谓的哈希碰撞问题。 68题 decimal精度比float高,数据处理比float简单,一般优先考虑,但float存储的数据范围大,所以范围大的数据就只能用它了,但要注意一些处理细节,因为不精确可能会与自己想的不一致,也常有关于float 出错的问题。 67题 datetime、timestamp精确度都是秒,datetime与时区无关,存储的范围广(1001-9999),timestamp与时区有关,存储的范围小(1970-2038)。 66题 Char使用固定长度的空间进行存储,char(4)存储4个字符,根据编码方式的不同占用不同的字节,gbk编码方式,不论是中文还是英文,每个字符占用2个字节的空间,utf8编码方式,每个字符占用3个字节的空间。Varchar保存可变长度的字符串,使用额外的一个或两个字节存储字符串长度,varchar(10),除了需要存储10个字符,还需要1个字节存储长度信息(10),超过255的长度需要2个字节来存储。char和varchar后面如果有空格,char会自动去掉空格后存储,varchar虽然不会去掉空格,但在进行字符串比较时,会去掉空格进行比较。Varbinary保存变长的字符串,后面不会补\0。 65题 首先分析语句,看看是否load了额外的数据,可能是查询了多余的行并且抛弃掉了,可能是加载了许多结果中并不需要的列,对语句进行分析以及重写。分析语句的执行计划,然后获得其使用索引的情况,之后修改语句或者修改索引,使得语句可以尽可能的命中索引。如果对语句的优化已经无法进行,可以考虑表中的数据量是否太大,如果是的话可以进行横向或者纵向的分表。 64题 建立索引的时候一般要考虑到字段的使用频率,经常作为条件进行查询的字段比较适合。如果需要建立联合索引的话,还需要考虑联合索引中的顺序。此外也要考虑其他方面,比如防止过多的所有对表造成太大的压力。这些都和实际的表结构以及查询方式有关。 63题 存储过程是一些预编译的SQL语句。1、更加直白的理解:存储过程可以说是一个记录集,它是由一些T-SQL语句组成的代码块,这些T-SQL语句代码像一个方法一样实现一些功能(对单表或多表的增删改查),然后再给这个代码块取一个名字,在用到这个功能的时候调用他就行了。2、存储过程是一个预编译的代码块,执行效率比较高,一个存储过程替代大量T_SQL语句 ,可以降低网络通信量,提高通信速率,可以一定程度上确保数据安全。 62题 密码散列、盐、用户身份证号等固定长度的字符串应该使用char而不是varchar来存储,这样可以节省空间且提高检索效率。 61题 推荐使用自增ID,不要使用UUID。因为在InnoDB存储引擎中,主键索引是作为聚簇索引存在的,也就是说,主键索引的B+树叶子节点上存储了主键索引以及全部的数据(按照顺序),如果主键索引是自增ID,那么只需要不断向后排列即可,如果是UUID,由于到来的ID与原来的大小不确定,会造成非常多的数据插入,数据移动,然后导致产生很多的内存碎片,进而造成插入性能的下降。总之,在数据量大一些的情况下,用自增主键性能会好一些。 60题 char是一个定长字段,假如申请了char(10)的空间,那么无论实际存储多少内容。该字段都占用10个字符,而varchar是变长的,也就是说申请的只是最大长度,占用的空间为实际字符长度+1,最后一个字符存储使用了多长的空间。在检索效率上来讲,char > varchar,因此在使用中,如果确定某个字段的值的长度,可以使用char,否则应该尽量使用varchar。例如存储用户MD5加密后的密码,则应该使用char。 59题 一. read uncommitted(读取未提交数据) 即便是事务没有commit,但是我们仍然能读到未提交的数据,这是所有隔离级别中最低的一种。 二. read committed(可以读取其他事务提交的数据)---大多数数据库默认的隔离级别 当前会话只能读取到其他事务提交的数据,未提交的数据读不到。 三. repeatable read(可重读)---MySQL默认的隔离级别 当前会话可以重复读,就是每次读取的结果集都相同,而不管其他事务有没有提交。 四. serializable(串行化) 其他会话对该表的写操作将被挂起。可以看到,这是隔离级别中最严格的,但是这样做势必对性能造成影响。所以在实际的选用上,我们要根据当前具体的情况选用合适的。 58题 B+树的高度一般为2-4层,所以查找记录时最多只需要2-4次IO,相对二叉平衡树已经大大降低了。范围查找时,能通过叶子节点的指针获取数据。例如查找大于等于3的数据,当在叶子节点中查到3时,通过3的尾指针便能获取所有数据,而不需要再像二叉树一样再获取到3的父节点。 57题 因为事务在修改页时,要先记 undo,在记 undo 之前要记 undo 的 redo, 然后修改数据页,再记数据页修改的 redo。 Redo(里面包括 undo 的修改) 一定要比数据页先持久化到磁盘。 当事务需要回滚时,因为有 undo,可以把数据页回滚到前镜像的状态,崩溃恢复时,如果 redo log 中事务没有对应的 commit 记录,那么需要用 undo把该事务的修改回滚到事务开始之前。 如果有 commit 记录,就用 redo 前滚到该事务完成时并提交掉。 56题 redo log是物理日志,记录的是"在某个数据页上做了什么修改"。 binlog是逻辑日志,记录的是这个语句的原始逻辑,比如"给ID=2这一行的c字段加1"。 redo log是InnoDB引擎特有的;binlog是MySQL的Server层实现的,所有引擎都可以使用。 redo log是循环写的,空间固定会用完:binlog 是可以追加写入的。"追加写"是指binlog文件写到一定大小后会切换到下一个,并不会覆盖以前的日志。 最开始 MySQL 里并没有 InnoDB 引擎,MySQL 自带的引擎是 MyISAM,但是 MyISAM 没有 crash-safe 的能力,binlog日志只能用于归档。而InnoDB 是另一个公司以插件形式引入 MySQL 的,既然只依靠 binlog 是没有 crash-safe 能力的,所以 InnoDB 使用另外一套日志系统,也就是 redo log 来实现 crash-safe 能力。 55题 重做日志(redo log)      作用:确保事务的持久性,防止在发生故障,脏页未写入磁盘。重启数据库会进行redo log执行重做,达到事务一致性。 回滚日志(undo log)  作用:保证数据的原子性,保存了事务发生之前的数据的一个版本,可以用于回滚,同时可以提供多版本并发控制下的读(MVCC),也即非锁定读。 二进 制日志(binlog)    作用:用于主从复制,实现主从同步;用于数据库的基于时间点的还原。 错误日志(errorlog) 作用:Mysql本身启动,停止,运行期间发生的错误信息。 慢查询日志(slow query log)  作用:记录执行时间过长的sql,时间阈值可以配置,只记录执行成功。 一般查询日志(general log)    作用:记录数据库的操作明细,默认关闭,开启后会降低数据库性能 。 中继日志(relay log) 作用:用于数据库主从同步,将主库发来的bin log保存在本地,然后从库进行回放。 54题 MySQL有三种锁的级别:页级、表级、行级。 表级锁:开销小,加锁快;不会出现死锁;锁定粒度大,发生锁冲突的概率最高,并发度最低。 行级锁:开销大,加锁慢;会出现死锁;锁定粒度最小,发生锁冲突的概率最低,并发度也最高。 页面锁:开销和加锁时间界于表锁和行锁之间;会出现死锁;锁定粒度界于表锁和行锁之间,并发度一般。 死锁: 是指两个或两个以上的进程在执行过程中。因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。 死锁的关键在于:两个(或以上)的Session加锁的顺序不一致。 那么对应的解决死锁问题的关键就是:让不同的session加锁有次序。死锁的解决办法:1.查出的线程杀死。2.设置锁的超时时间。3.指定获取锁的顺序。 53题 当多个用户并发地存取数据时,在数据库中就会产生多个事务同时存取同一数据的情况。若对并发操作不加控制就可能会读取和存储不正确的数据,破坏数据库的一致性(脏读,不可重复读,幻读等),可能产生死锁。 乐观锁:乐观锁不是数据库自带的,需要我们自己去实现。 悲观锁:在进行每次操作时都要通过获取锁才能进行对相同数据的操作。 共享锁:加了共享锁的数据对象可以被其他事务读取,但不能修改。 排他锁:当数据对象被加上排它锁时,一个事务必须得到锁才能对该数据对象进行访问,一直到事务结束锁才被释放。 行锁:就是给某一条记录加上锁。 52题 Mysql是关系型数据库,MongoDB是非关系型数据库,数据存储结构的不同。 51题 关系型数据库优点:1.保持数据的一致性(事务处理)。 2.由于以标准化为前提,数据更新的开销很小。 3. 可以进行Join等复杂查询。 缺点:1、为了维护一致性所付出的巨大代价就是其读写性能比较差。 2、固定的表结构。 3、高并发读写需求。 4、海量数据的高效率读写。 非关系型数据库优点:1、无需经过sql层的解析,读写性能很高。 2、基于键值对,数据没有耦合性,容易扩展。 3、存储数据的格式:nosql的存储格式是key,value形式、文档形式、图片形式等等,文档形式、图片形式等等,而关系型数据库则只支持基础类型。 缺点:1、不提供sql支持,学习和使用成本较高。 2、无事务处理,附加功能bi和报表等支持也不好。 redis与mongoDB的区别: 性能:TPS方面redis要大于mongodb。 可操作性:mongodb支持丰富的数据表达,索引,redis较少的网络IO次数。 可用性:MongoDB优于Redis。 一致性:redis事务支持比较弱,mongoDB不支持事务。 数据分析:mongoDB内置了数据分析的功能(mapreduce)。 应用场景:redis数据量较小的更性能操作和运算上,MongoDB主要解决海量数据的访问效率问题。 50题 如果Redis被当做缓存使用,使用一致性哈希实现动态扩容缩容。如果Redis被当做一个持久化存储使用,必须使用固定的keys-to-nodes映射关系,节点的数量一旦确定不能变化。否则的话(即Redis节点需要动态变化的情况),必须使用可以在运行时进行数据再平衡的一套系统,而当前只有Redis集群可以做到这样。 49题 分区可以让Redis管理更大的内存,Redis将可以使用所有机器的内存。如果没有分区,你最多只能使用一台机器的内存。分区使Redis的计算能力通过简单地增加计算机得到成倍提升,Redis的网络带宽也会随着计算机和网卡的增加而成倍增长。 48题 除了缓存服务器自带的缓存失效策略之外(Redis默认的有6种策略可供选择),我们还可以根据具体的业务需求进行自定义的缓存淘汰,常见的策略有两种: 1.定时去清理过期的缓存; 2.当有用户请求过来时,再判断这个请求所用到的缓存是否过期,过期的话就去底层系统得到新数据并更新缓存。 两者各有优劣,第一种的缺点是维护大量缓存的key是比较麻烦的,第二种的缺点就是每次用户请求过来都要判断缓存失效,逻辑相对比较复杂!具体用哪种方案,可以根据应用场景来权衡。 47题 Redis提供了两种方式来作消息队列: 一个是使用生产者消费模式模式:会让一个或者多个客户端监听消息队列,一旦消息到达,消费者马上消费,谁先抢到算谁的,如果队列里没有消息,则消费者继续监听 。另一个就是发布订阅者模式:也是一个或多个客户端订阅消息频道,只要发布者发布消息,所有订阅者都能收到消息,订阅者都是平等的。 46题 Redis的数据结构列表(list)可以实现延时队列,可以通过队列和栈来实现。blpop/brpop来替换lpop/rpop,blpop/brpop阻塞读在队列没有数据的时候,会立即进入休眠状态,一旦数据到来,则立刻醒过来。Redis的有序集合(zset)可以用于实现延时队列,消息作为value,时间作为score。Zrem 命令用于移除有序集中的一个或多个成员,不存在的成员将被忽略。当 key 存在但不是有序集类型时,返回一个错误。 45题 1.热点数据缓存:因为Redis 访问速度块、支持的数据类型比较丰富。 2.限时业务:expire 命令设置 key 的生存时间,到时间后自动删除 key。 3.计数器:incrby 命令可以实现原子性的递增。 4.排行榜:借助 SortedSet 进行热点数据的排序。 5.分布式锁:利用 Redis 的 setnx 命令进行。 6.队列机制:有 list push 和 list pop 这样的命令。 44题 一致哈希 是一种特殊的哈希算法。在使用一致哈希算法后,哈希表槽位数(大小)的改变平均只需要对 K/n 个关键字重新映射,其中K是关键字的数量, n是槽位数量。然而在传统的哈希表中,添加或删除一个槽位的几乎需要对所有关键字进行重新映射。 43题 RDB的优点:适合做冷备份;读写服务影响小,reids可以保持高性能;重启和恢复redis进程,更加快速。RDB的缺点:宕机会丢失最近5分钟的数据;文件特别大时可能会暂停数毫秒,或者甚至数秒。 AOF的优点:每个一秒执行fsync操作,最多丢失1秒钟的数据;以append-only模式写入,没有任何磁盘寻址的开销;文件过大时,不会影响客户端读写;适合做灾难性的误删除的紧急恢复。AOF的缺点:AOF日志文件比RDB数据快照文件更大,支持写QPS比RDB支持的写QPS低;比RDB脆弱,容易有bug。 42题 对于Redis而言,命令的原子性指的是:一个操作的不可以再分,操作要么执行,要么不执行。Redis的操作之所以是原子性的,是因为Redis是单线程的。而在程序中执行多个Redis命令并非是原子性的,这也和普通数据库的表现是一样的,可以用incr或者使用Redis的事务,或者使用Redis+Lua的方式实现。对Redis来说,执行get、set以及eval等API,都是一个一个的任务,这些任务都会由Redis的线程去负责执行,任务要么执行成功,要么执行失败,这就是Redis的命令是原子性的原因。 41题 (1)twemproxy,使用方式简单(相对redis只需修改连接端口),对旧项目扩展的首选。(2)codis,目前用的最多的集群方案,基本和twemproxy一致的效果,但它支持在节点数改变情况下,旧节点数据可恢复到新hash节点。(3)redis cluster3.0自带的集群,特点在于他的分布式算法不是一致性hash,而是hash槽的概念,以及自身支持节点设置从节点。(4)在业务代码层实现,起几个毫无关联的redis实例,在代码层,对key进行hash计算,然后去对应的redis实例操作数据。这种方式对hash层代码要求比较高,考虑部分包括,节点失效后的代替算法方案,数据震荡后的自动脚本恢复,实例的监控,等等。 40题 (1) Master最好不要做任何持久化工作,如RDB内存快照和AOF日志文件 (2) 如果数据比较重要,某个Slave开启AOF备份数据,策略设置为每秒同步一次 (3) 为了主从复制的速度和连接的稳定性,Master和Slave最好在同一个局域网内 (4) 尽量避免在压力很大的主库上增加从库 (5) 主从复制不要用图状结构,用单向链表结构更为稳定,即:Master <- Slave1 <- Slave2 <- Slave3...这样的结构方便解决单点故障问题,实现Slave对Master的替换。如果Master挂了,可以立刻启用Slave1做Master,其他不变。 39题 比如订单管理,热数据:3个月内的订单数据,查询实时性较高;温数据:3个月 ~ 12个月前的订单数据,查询频率不高;冷数据:1年前的订单数据,几乎不会查询,只有偶尔的查询需求。热数据使用mysql进行存储,需要分库分表;温数据可以存储在ES中,利用搜索引擎的特性基本上也可以做到比较快的查询;冷数据可以存放到Hive中。从存储形式来说,一般情况冷数据存储在磁带、光盘,热数据一般存放在SSD中,存取速度快,而温数据可以存放在7200转的硬盘。 38题 当访问量剧增、服务出现问题(如响应时间慢或不响应)或非核心服务影响到核心流程的性能时,仍然需要保证服务还是可用的,即使是有损服务。系统可以根据一些关键数据进行自动降级,也可以配置开关实现人工降级。降级的最终目的是保证核心服务可用,即使是有损的。而且有些服务是无法降级的(如加入购物车、结算)。 37题 分层架构设计,有一条准则:站点层、服务层要做到无数据无状态,这样才能任意的加节点水平扩展,数据和状态尽量存储到后端的数据存储服务,例如数据库服务或者缓存服务。显然进程内缓存违背了这一原则。 36题 更新数据的时候,根据数据的唯一标识,将操作路由之后,发送到一个 jvm 内部队列中。读取数据的时候,如果发现数据不在缓存中,那么将重新读取数据+更新缓存的操作,根据唯一标识路由之后,也发送同一个 jvm 内部队列中。一个队列对应一个工作线程,每个工作线程串行拿到对应的操作,然后一条一条的执行。 35题 redis分布式锁加锁过程:通过setnx向特定的key写入一个随机值,并同时设置失效时间,写值成功既加锁成功;redis分布式锁解锁过程:匹配随机值,删除redis上的特点key数据,要保证获取数据、判断一致以及删除数据三个操作是原子的,为保证原子性一般使用lua脚本实现;在此基础上进一步优化的话,考虑使用心跳检测对锁的有效期进行续期,同时基于redis的发布订阅优雅的实现阻塞式加锁。 34题 volatile-lru:当内存不足以容纳写入数据时,从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。 volatile-ttl:当内存不足以容纳写入数据时,从已设置过期时间的数据集中挑选将要过期的数据淘汰。 volatile-random:当内存不足以容纳写入数据时,从已设置过期时间的数据集中任意选择数据淘汰。 allkeys-lru:当内存不足以容纳写入数据时,从数据集中挑选最近最少使用的数据淘汰。 allkeys-random:当内存不足以容纳写入数据时,从数据集中任意选择数据淘汰。 noeviction:禁止驱逐数据,当内存使用达到阈值的时候,所有引起申请内存的命令会报错。 33题 定时过期:每个设置过期时间的key都需要创建一个定时器,到过期时间就会立即清除。该策略可以立即清除过期的数据,对内存很友好;但是会占用大量的CPU资源去处理过期的数据,从而影响缓存的响应时间和吞吐量。 惰性过期:只有当访问一个key时,才会判断该key是否已过期,过期则清除。该策略可以最大化地节省CPU资源,却对内存非常不友好。极端情况可能出现大量的过期key没有再次被访问,从而不会被清除,占用大量内存。 定期过期:每隔一定的时间,会扫描一定数量的数据库的expires字典中一定数量的key,并清除其中已过期的key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时,可以在不同情况下使得CPU和内存资源达到最优的平衡效果。 32题 缓存击穿,一个存在的key,在缓存过期的一刻,同时有大量的请求,这些请求都会击穿到DB,造成瞬时DB请求量大、压力骤增。如何避免:在访问key之前,采用SETNX(set if not exists)来设置另一个短期key来锁住当前key的访问,访问结束再删除该短期key。 31题 缓存雪崩,是指在某一个时间段,缓存集中过期失效。大量的key设置了相同的过期时间,导致在缓存在同一时刻全部失效,造成瞬时DB请求量大、压力骤增,引起雪崩。而缓存服务器某个节点宕机或断网,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。如何避免:1.redis高可用,搭建redis集群。2.限流降级,在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。3.数据预热,在即将发生大并发访问前手动触发加载缓存不同的key,设置不同的过期时间。 30题 缓存穿透,是指查询一个数据库一定不存在的数据。正常的使用缓存流程大致是,数据查询先进行缓存查询,如果key不存在或者key已经过期,再对数据库进行查询,并把查询到的对象,放进缓存。如果数据库查询对象为空,则不放进缓存。一些恶意的请求会故意查询不存在的 key,请求量很大,对数据库造成压力,甚至压垮数据库。 如何避免:1:对查询结果为空的情况也进行缓存,缓存时间设置短一点,或者该 key 对应的数据 insert 了之后清理缓存。2:对一定不存在的 key 进行过滤。可以把所有的可能存在的 key 放到一个大的 Bitmap 中,查询时通过该 bitmap 过滤。 29题 1.memcached 所有的值均是简单的字符串,redis 作为其替代者,支持更为丰富的数据类型。 2.redis 的速度比 memcached 快很多。 3.redis 可以持久化其数据。 4.Redis支持数据的备份,即master-slave模式的数据备份。 5.Redis采用VM机制。 6.value大小:redis最大可以达到1GB,而memcache只有1MB。 28题 Spring Boot 推荐使用 Java 配置而非 XML 配置,但是 Spring Boot 中也可以使用 XML 配置,通过spring提供的@ImportResource来加载xml配置。例如:@ImportResource({"classpath:some-context.xml","classpath:another-context.xml"}) 27题 Spring像一个大家族,有众多衍生产品例如Spring Boot,Spring Security等等,但他们的基础都是Spring的IOC和AOP,IOC提供了依赖注入的容器,而AOP解决了面向切面的编程,然后在此两者的基础上实现了其他衍生产品的高级功能。Spring MVC是基于Servlet的一个MVC框架,主要解决WEB开发的问题,因为 Spring的配置非常复杂,各种xml,properties处理起来比较繁琐。Spring Boot遵循约定优于配置,极大降低了Spring使用门槛,又有着Spring原本灵活强大的功能。总结:Spring MVC和Spring Boot都属于Spring,Spring MVC是基于Spring的一个MVC框架,而Spring Boot是基于Spring的一套快速开发整合包。 26题 YAML 是 "YAML Ain't a Markup Language"(YAML 不是一种标记语言)的递归缩写。YAML 的配置文件后缀为 .yml,是一种人类可读的数据序列化语言,可以简单表达清单、散列表,标量等数据形态。它通常用于配置文件,与属性文件相比,YAML文件就更加结构化,而且更少混淆。可以看出YAML具有分层配置数据。 25题 Spring Boot有3种热部署方式: 1.使用springloaded配置pom.xml文件,使用mvn spring-boot:run启动。 2.使用springloaded本地加载启动,配置jvm参数-javaagent:<jar包地址> -noverify。 3.使用devtools工具包,操作简单,但是每次需要重新部署。 用

游客ih62co2qqq5ww 2020-03-27 23:56:48 0 浏览量 回答数 0

回答

1 写出下面代码输出内容。 package main import (    "fmt" ) funcmain() {     defer_call() } funcdefer_call() {     deferfunc() {fmt.Println("打印前")}()     deferfunc() {fmt.Println("打印中")}()     deferfunc() {fmt.Println("打印后")}()     panic("触发异常") } 考点:defer执行顺序 解答: defer 是后进先出。 panic 需要等defer 结束后才会向上传递。 出现panic恐慌时候,会先按照defer的后入先出的顺序执行,最后才会执行panic。 打印后 打印中 打印前 panic: 触发异常 2 以下代码有什么问题,说明原因。 type student struct {     Name string     Age  int } funcpase_student() {     m := make(map[string]*student)     stus := []student{         {Name: "zhou",Age: 24},         {Name: "li",Age: 23},         {Name: "wang",Age: 22},     }    for _,stu := range stus {         m[stu.Name] =&stu     } } 考点:foreach 解答: 这样的写法初学者经常会遇到的,很危险! 与Java的foreach一样,都是使用副本的方式。所以m[stu.Name]=&stu实际上一致指向同一个指针, 最终该指针的值为遍历的最后一个struct的值拷贝。 就像想修改切片元素的属性: for _, stu := rangestus {     stu.Age = stu.Age+10} 也是不可行的。 大家可以试试打印出来: func pase_student() {     m := make(map[string]*student)     stus := []student{         {Name: "zhou",Age: 24},         {Name: "li",Age: 23},         {Name: "wang",Age: 22},     }         // 错误写法     for _,stu := range stus {         m[stu.Name] =&stu     }          fork,v:=range m{               println(k,"=>",v.Name)     }           // 正确     for i:=0;i<len(stus);i++ {        m[stus[i].Name] = &stus[i]     }          fork,v:=range m{                println(k,"=>",v.Name)     } } 3 下面的代码会输出什么,并说明原因 func main() {     runtime.GOMAXPROCS(1)     wg := sync.WaitGroup{}     wg.Add(20)   for i := 0; i < 10; i++ {                  gofunc() {            fmt.Println("A: ", i)            wg.Done()         }()     }             for i:= 0; i < 10; i++ {                    gofunc(i int) {            fmt.Println("B: ", i)            wg.Done()         }(i)     }     wg.Wait() } 考点:go执行的随机性和闭包 解答: 谁也不知道执行后打印的顺序是什么样的,所以只能说是随机数字。 但是A:均为输出10,B:从0~9输出(顺序不定)。 第一个go func中i是外部for的一个变量,地址不变化。遍历完成后,最终i=10。 故go func执行时,i的值始终是10。 第二个go func中i是函数参数,与外部for中的i完全是两个变量。 尾部(i)将发生值拷贝,go func内部指向值拷贝地址。 4 下面代码会输出什么? type People struct{}func (p People)ShowA() {     fmt.Println("showA")     p.ShowB() } func(pPeople)ShowB() {     fmt.Println("showB") } typeTeacher struct {     People } func(t*Teacher)ShowB() {     fmt.Println("teachershowB") } funcmain() {     t := Teacher{}     t.ShowA() } 考点:go的组合继承 解答: 这是Golang的组合模式,可以实现OOP的继承。 被组合的类型People所包含的方法虽然升级成了外部类型Teacher这个组合类型的方法(一定要是匿名字段),但它们的方法(ShowA())调用时接受者并没有发生变化。 此时People类型并不知道自己会被什么类型组合,当然也就无法调用方法时去使用未知的组合者Teacher类型的功能。 showAshowB 5 下面代码会触发异常吗?请详细说明 func main() {     runtime.GOMAXPROCS(1)     int_chan := make(chanint, 1)     string_chan := make(chanstring, 1)     int_chan <- 1     string_chan <- "hello"     select {                case value := <-int_chan:        fmt.Println(value)           casevalue := <-string_chan:                   panic(value)     } } 考点:select随机性 解答: select会随机选择一个可用通用做收发操作。 所以代码是有肯触发异常,也有可能不会。 单个chan如果无缓冲时,将会阻塞。但结合 select可以在多个chan间等待执行。有三点原则: select 中只要有一个case能return,则立刻执行。 当如果同一时间有多个case均能return则伪随机方式抽取任意一个执行。 如果没有一个case能return则可以执行”default”块。 6 下面代码输出什么? funccalc(indexstring, a, bint) int {     ret := a+ b     fmt.Println(index,a, b, ret)     return ret } funcmain() {          a := 1     b := 2     defer calc("1", a,calc("10", a, b))    a = 0     defer calc("2", a,calc("20", a, b))    b = 1 } 考点:defer执行顺序 解答: 这道题类似第1题 需要注意到defer执行顺序和值传递 index:1肯定是最后执行的,但是index:1的第三个参数是一个函数,所以最先被调用 calc("10",1,2)==>10,1,2,3 执行index:2时,与之前一样,需要先调用calc("20",0,2)==>20,0,2,2 执行到b=1时候开始调用,index:2==>calc("2",0,2)==>2,0,2,2最后执行index:1==>calc("1",1,3)==>1,1,3,4 10 1 2 320 0 2 22 0 2 21 1 3 4 7 请写出以下输入内容 funcmain() {            s := make([]int,5)     s = append(s,1, 2, 3)     fmt.Println(s) } 考点:make默认值和append 解答: make初始化是由默认值的哦,此处默认值为0 [00000123] 大家试试改为: s := make([]int, 0) s = append(s, 1, 2, 3) fmt.Println(s)//[1 2 3] 8 下面的代码有什么问题? type UserAges struct {     ages map[string]int     sync.Mutex } func(uaUserAges)Add(name string, age int) {     ua.Lock()          deferua.Unlock()     ua.ages[name] = age } func(uaUserAges)Get(name string)int {           ifage, ok := ua.ages[name]; ok {                  return age     }         return-1 } 考点:map线程安全 解答: 可能会出现 fatal error: concurrent mapreadandmapwrite. 修改一下看看效果 func (ua *UserAges)Get(namestring)int {     ua.Lock()          deferua.Unlock()          ifage, ok := ua.ages[name]; ok {                   return age     }            return-1 } 9.   下面的迭代会有什么问题? func (set *threadSafeSet)Iter()<-chaninterface{} {     ch := make(chaninterface{})                  gofunc() {         set.RLock()                for elem := range set.s {            ch <- elem         }                   close(ch)         set.RUnlock()     }()      return ch } 考点:chan缓存池 解答: 看到这道题,我也在猜想出题者的意图在哪里。 chan?sync.RWMutex?go?chan缓存池?迭代? 所以只能再读一次题目,就从迭代入手看看。 既然是迭代就会要求set.s全部可以遍历一次。但是chan是为缓存的,那就代表这写入一次就会阻塞。 我们把代码恢复为可以运行的方式,看看效果 package main import (          "sync"     "fmt")//下面的迭代会有什么问题?type threadSafeSet struct {     sync.RWMutex     s []interface{} } func(set*threadSafeSet)Iter() <-chaninterface{} {     //ch := make(chan interface{}) // 解除注释看看!     ch := make(chaninterface{},len(set.s))    gofunc() {         set.RLock()        forelem,value := range set.s {            ch <- elem             println("Iter:",elem,value)         }       close(ch)         set.RUnlock()     }()     return ch } funcmain() {     th:=threadSafeSet{         s:[]interface{}{"1","2"},     }     v:=<-th.Iter()     fmt.Sprintf("%s%v","ch",v) } 10 以下代码能编译过去吗?为什么? package main import (   "fmt") typePeople interface {     Speak(string) string } typeStduent struct{} func(stu*Stduent)Speak(think string)(talk string) {     ifthink == "bitch" {         talk = "Youare a good boy"     } else {         talk = "hi"     }     return } funcmain() {     var peoPeople = Stduent{}     think := "bitch"    fmt.Println(peo.Speak(think)) } 考点:golang的方法集 解答: 编译不通过! 做错了!?说明你对golang的方法集还有一些疑问。 一句话:golang的方法集仅仅影响接口实现和方法表达式转化,与通过实例或者指针调用方法无关。 11 以下代码打印出来什么内容,说出为什么。 package main import (   "fmt") typePeople interface {     Show() } typeStudent struct{} func(stuStudent)Show() { } funclive()People {     var stuStudent     return stu } funcmain() {   if live() == nil {         fmt.Println("AAAAAAA")     } else {         fmt.Println("BBBBBBB")     } } 考点:interface内部结构 解答: 很经典的题! 这个考点是很多人忽略的interface内部结构。 go中的接口分为两种一种是空的接口类似这样: varininterface{} 另一种如题目: type People interface {     Show() } 他们的底层结构如下: type eface struct {      //空接口     _type _type        //类型信息     data  unsafe.Pointer //指向数据的指针(go语言中特殊的指针类型unsafe.Pointer类似于c语言中的void)} typeiface struct {      //带有方法的接口     tab  itab          //存储type信息还有结构实现方法的集合     data unsafe.Pointer  //指向数据的指针(go语言中特殊的指针类型unsafe.Pointer类似于c语言中的void)} type_type struct {     size       uintptr //类型大小     ptrdata    uintptr //前缀持有所有指针的内存大小     hash       uint32  //数据hash值     tflag     tflag     align      uint8   //对齐     fieldalign uint8   //嵌入结构体时的对齐     kind       uint8   //kind 有些枚举值kind等于0是无效的     alg       *typeAlg //函数指针数组,类型实现的所有方法     gcdata    *byte   str       nameOff     ptrToThis typeOff }type itab struct {     inter  *interfacetype //接口类型     _type  *_type         //结构类型     link   *itab     bad    int32     inhash int32     fun    [1]uintptr     //可变大小方法集合} 可以看出iface比eface 中间多了一层itab结构。 itab 存储_type信息和[]fun方法集,从上面的结构我们就可得出,因为data指向了nil 并不代表interface 是nil, 所以返回值并不为空,这里的fun(方法集)定义了接口的接收规则,在编译的过程中需要验证是否实现接口 结果: BBBBBBB 12.是否可以编译通过?如果通过,输出什么? func main() {     i := GetValue() switch i.(type) {          caseint:                println("int")            casestring:                println("string")            caseinterface{}:                println("interface")            default:                 println("unknown")     } } funcGetValue()int {    return1 } 解析 考点:type 编译失败,因为type只能使用在interface 13.下面函数有什么问题? func funcMui(x,y int)(sum int,error){     returnx+y,nil } 解析 考点:函数返回值命名 在函数有多个返回值时,只要有一个返回值有指定命名,其他的也必须有命名。 如果返回值有有多个返回值必须加上括号; 如果只有一个返回值并且有命名也需要加上括号; 此处函数第一个返回值有sum名称,第二个未命名,所以错误。 14.是否可以编译通过?如果通过,输出什么? package mainfunc main() {    println(DeferFunc1(1)) println(DeferFunc2(1)) println(DeferFunc3(1)) }func DeferFunc1(i int)(t int) {     t = i   deferfunc() {         t += 3     }() return t } funcDeferFunc2(i int)int {     t := i  deferfunc() {         t += 3     }() return t } funcDeferFunc3(i int)(t int) {   deferfunc() {         t += i     }() return2} 解析 考点:defer和函数返回值 需要明确一点是defer需要在函数结束前执行。 函数返回值名字会在函数起始处被初始化为对应类型的零值并且作用域为整个函数 DeferFunc1有函数返回值t作用域为整个函数,在return之前defer会被执行,所以t会被修改,返回4; DeferFunc2函数中t的作用域为函数,返回1;DeferFunc3返回3 15.是否可以编译通过?如果通过,输出什么? funcmain() {    list := new([]int)     list = append(list,1)     fmt.Println(list) } 解析 考点:new list:=make([]int,0) 16.是否可以编译通过?如果通过,输出什么? package mainimport "fmt"funcmain() {     s1 := []int{1, 2, 3}     s2 := []int{4, 5}     s1 = append(s1,s2)     fmt.Println(s1) } 解析 考点:append append切片时候别漏了'…' 17.是否可以编译通过?如果通过,输出什么? func main() {     sn1 := struct {         age  int         name string     }{age: 11,name: "qq"}     sn2 := struct {         age  int         name string     }{age: 11,name: "qq"}  if sn1== sn2 {         fmt.Println("sn1== sn2")     }     sm1 := struct {         age int         m   map[string]string     }{age: 11, m:map[string]string{"a": "1"}}     sm2 := struct {         age int         m   map[string]string     }{age: 11, m:map[string]string{"a": "1"}}             if sm1 == sm2 {         fmt.Println("sm1== sm2")     } } 解析 考点:结构体比较 进行结构体比较时候,只有相同类型的结构体才可以比较,结构体是否相同不但与属性类型个数有关,还与属性顺序相关。 sn3:= struct {     name string     age  int } {age:11,name:"qq"} sn3与sn1就不是相同的结构体了,不能比较。 还有一点需要注意的是结构体是相同的,但是结构体属性中有不可以比较的类型,如map,slice。 如果该结构属性都是可以比较的,那么就可以使用“==”进行比较操作。 可以使用reflect.DeepEqual进行比较 if reflect.DeepEqual(sn1, sm) {     fmt.Println("sn1==sm") }else {     fmt.Println("sn1!=sm") } 所以编译不通过: invalid operation: sm1 == sm2 18.是否可以编译通过?如果通过,输出什么? func Foo(x interface{}) {    if x== nil {         fmt.Println("emptyinterface")                 return     }     fmt.Println("non-emptyinterface") }        funcmain() {           var x *int = nil     Foo(x) } 解析 考点:interface内部结构 non-emptyinterface 19.是否可以编译通过?如果通过,输出什么? func GetValue(m map[int]string, id int)(string, bool) {              if _,exist := m[id]; exist {                    return"存在数据", true     }            returnnil, false}funcmain() {     intmap:=map[int]string{    1:"a",        2:"bb",        3:"ccc",     }     v,err:=GetValue(intmap,3)     fmt.Println(v,err) } 解析 考点:函数返回值类型 nil 可以用作 interface、function、pointer、map、slice 和 channel 的“空值”。但是如果不特别指定的话,Go 语言不能识别类型,所以会报错。报:cannot use nil as type string in return argument. 20.是否可以编译通过?如果通过,输出什么? const (     x = iota     y     z = "zz"     k     p = iota) funcmain()  {     fmt.Println(x,y,z,k,p) } 解析 考点:iota 结果: 0 1 zz zz 4 21.编译执行下面代码会出现什么? package mainvar(     size :=1024     max_size = size*2) funcmain() {     println(size,max_size) } 解析 考点:变量简短模式 变量简短模式限制: 定义变量同时显式初始化 不能提供数据类型 只能在函数内部使用 结果: syntaxerror: unexpected := 22.下面函数有什么问题? package main const cl = 100 var bl   = 123 funcmain() {     println(&bl,bl)    println(&cl,cl) } 解析 考点:常量 常量不同于变量的在运行期分配内存,常量通常会被编译器在预处理阶段直接展开,作为指令数据使用, cannot take the address of cl 23.编译执行下面代码会出现什么? package main funcmain() {     for i:=0;i<10;i++  {     loop:        println(i)     }    gotoloop } 解析 考点:goto goto不能跳转到其他函数或者内层代码 goto loop jumps intoblock starting at 24.编译执行下面代码会出现什么? package main import"fmt" funcmain() {      typeMyInt1 int      typeMyInt2 = int     var i int =9     var i1MyInt1 = i     var i2MyInt2 = i     fmt.Println(i1,i2) } 解析 考点:**Go 1.9 新特性 Type Alias ** 基于一个类型创建一个新类型,称之为defintion;基于一个类型创建一个别名,称之为alias。 MyInt1为称之为defintion,虽然底层类型为int类型,但是不能直接赋值,需要强转; MyInt2称之为alias,可以直接赋值。 结果: cannot use i (typeint) astype MyInt1 in assignment 25.编译执行下面代码会出现什么? package main import"fmt" typeUser struct { } typeMyUser1 User typeMyUser2 = User func(iMyUser1)m1(){     fmt.Println("MyUser1.m1") } func(iUser)m2(){     fmt.Println("User.m2") } funcmain() {     var i1MyUser1     var i2MyUser2     i1.m1()     i2.m2() } 解析 考点:**Go 1.9 新特性 Type Alias ** 因为MyUser2完全等价于User,所以具有其所有的方法,并且其中一个新增了方法,另外一个也会有。 但是 i1.m2() 是不能执行的,因为MyUser1没有定义该方法。 结果: MyUser1.m1User.m2 26.编译执行下面代码会出现什么? package main import"fmt" type T1 struct { } func(tT1)m1(){     fmt.Println("T1.m1") } type T2= T1 typeMyStruct struct {     T1     T2 } funcmain() {     my:=MyStruct{}     my.m1() } 解析 考点:**Go 1.9 新特性 Type Alias ** 是不能正常编译的,异常: ambiguousselectormy.m1 结果不限于方法,字段也也一样;也不限于type alias,type defintion也是一样的,只要有重复的方法、字段,就会有这种提示,因为不知道该选择哪个。 改为: my.T1.m1() my.T2.m1() type alias的定义,本质上是一样的类型,只是起了一个别名,源类型怎么用,别名类型也怎么用,保留源类型的所有方法、字段等。 27.编译执行下面代码会出现什么? package main import (           "errors"     "fmt") varErrDidNotWork = errors.New("did not work") funcDoTheThing(reallyDoItbool)(errerror) {     ifreallyDoIt {         result, err:= tryTheThing()         if err!= nil || result != "it worked" {            err = ErrDidNotWork         }     }    return err } functryTheThing()(string,error) {     return"",ErrDidNotWork } funcmain() {     fmt.Println(DoTheThing(true))     fmt.Println(DoTheThing(false)) } 解析 考点:变量作用域 因为 if 语句块内的 err 变量会遮罩函数作用域内的 err 变量,结果: 改为: func DoTheThing(reallyDoIt bool)(errerror) {     varresult string     ifreallyDoIt {         result, err =tryTheThing()         if err!= nil || result != "it worked" {            err = ErrDidNotWork         }     }    return err } 28.编译执行下面代码会出现什么? package main functest() []func() {     varfuns []func()     fori:=0;i<2;i++  {         funs = append(funs,func() {                       println(&i,i)         })     }    returnfuns } funcmain(){     funs:=test()            for_,f:=range funs{         f()     } } 解析 考点:闭包延迟求值 for循环复用局部变量i,每一次放入匿名函数的应用都是想一个变量。 结果: 0xc042046000 2 0xc042046000 2 如果想不一样可以改为: func test() []func()  {     varfuns []func()     fori:=0;i<2;i++  {         x:=i         funs = append(funs,func() {            println(&x,x)         })     }    returnfuns } 29.编译执行下面代码会出现什么? package main functest(x int)(func(),func()) {     returnfunc() {        println(x)     x+=10     }, func() {              println(x)     } } funcmain() {     a,b:=test(100)     a()     b() } 解析 考点:闭包引用相同变量* 结果: 100 110 30. 编译执行下面代码会出现什么? package main im port (   "fmt"     "reflect") funcmain1() {     deferfunc() {      iferr:=recover();err!=nil{           fmt.Println(err)        }else {           fmt.Println("fatal")        }     }()     deferfunc() {        panic("deferpanic")     }()     panic("panic") } funcmain() {     deferfunc() {        iferr:=recover();err!=nil{            fmt.Println("++++")            f:=err.(func()string)             fmt.Println(err,f(),reflect.TypeOf(err).Kind().String())         }else {            fmt.Println("fatal")         }     }()     deferfunc() {        panic(func()string {            return "defer panic"         })     }()     panic("panic") } 解析 考点:panic仅有最后一个可以被revover捕获 触发panic("panic")后顺序执行defer,但是defer中还有一个panic,所以覆盖了之前的panic("panic") 原文链接:https://blog.csdn.net/itcastcpp/article/details/80462619

剑曼红尘 2020-03-09 10:46:30 0 浏览量 回答数 0

回答

对于初学者来说,要想把这个问题回答正确,最初思考这个问题的时候,我发现我竟然无法通过简单的语言把这个事情描述的很容易理解,遗憾的是,我也没有在网上找到哪篇文章可以把这个事情讲解的通俗易懂。所以,就有了我写这篇文章的初衷。 辟谣时间 关于这个问题,在StackOverflow上也引发过广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多人理解的是错误的。还有的人可能知道Java中的参数传递是值传递,但是说不出来为什么。 在开始深入讲解之前,有必要纠正一下大家以前的那些错误看法了。如果你有以下想法,那么你有必要好好阅读本文。 错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。 错误理解二:Java是引用传递。 错误理解三:传递的参数如果是普通类型,那就是值传递,如果是对象,那就是引用传递。 实参与形参 我们都知道,在Java中定义方法的时候是可以定义参数的。比如Java中的main方法,public static void main(String[] args),这里面的args就是参数。参数在程序语言中分为形式参数和实际参数。 形式参数:是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。 实际参数:在调用有参函数时,主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时,函数名后面括号中的参数称为“实际参数”。 简单举个例子: public static void main(String[] args) { ParamTest pt = new ParamTest(); pt.sout("Hollis");//实际参数为 Hollis } public void sout(String name) { //形式参数为 name System.out.println(name); } 实际参数是调用有参方法的时候真正传递的内容,而形式参数是用于接收实参内容的参数。 求值策略 我们说当进行方法调用的时候,需要把实际参数传递给形式参数,那么传递的过程中到底传递的是什么东西呢? 这其实是程序设计中**求值策略(Evaluation strategies)**的概念。 在计算机科学中,求值策略是确定编程语言中表达式的求值的一组(通常确定性的)规则。求值策略定义何时和以何种顺序求值给函数的实际参数、什么时候把它们代换入函数、和代换以何种形式发生。 求值策略分为两大基本类,基于如何处理给函数的实际参数,分位严格的和非严格的。 严格求值 在“严格求值”中,函数调用过程中,给函数的实际参数总是在应用这个函数之前求值。多数现存编程语言对函数都使用严格求值。所以,我们本文只关注严格求值。 在严格求值中有几个关键的求值策略是我们比较关心的,那就是传值调用(Call by value)、传引用调用(Call by reference)以及传共享对象调用(Call by sharing)。 传值调用(值传递) 在传值调用中,实际参数先被求值,然后其值通过复制,被传递给被调函数的形式参数。因为形式参数拿到的只是一个"局部拷贝",所以如果在被调函数中改变了形式参数的值,并不会改变实际参数的值。 传引用调用(应用传递) 在传引用调用中,传递给函数的是它的实际参数的隐式引用而不是实参的拷贝。因为传递的是引用,所以,如果在被调函数中改变了形式参数的值,改变对于调用者来说是可见的。 传共享对象调用(共享对象传递) 传共享对象调用中,先获取到实际参数的地址,然后将其复制,并把该地址的拷贝传递给被调函数的形式参数。因为参数的地址都指向同一个对象,所以我们称也之为"传共享对象",所以,如果在被调函数中改变了形式参数的值,调用者是可以看到这种变化的。 不知道大家有没有发现,其实传共享对象调用和传值调用的过程几乎是一样的,都是进行"求值"、"拷贝"、"传递"。你品,你细品。  但是,传共享对象调用和内传引用调用的结果又是一样的,都是在被调函数中如果改变参数的内容,那么这种改变也会对调用者有影响。你再品,你再细品。 那么,共享对象传递和值传递以及引用传递之间到底有很么关系呢? 对于这个问题,我们应该关注过程,而不是结果,因为传共享对象调用的过程和传值调用的过程是一样的,而且都有一步关键的操作,那就是"复制",所以,通常我们认为传共享对象调用是传值调用的特例 我们先把传共享对象调用放在一边,我们再来回顾下传值调用和传引用调用的主要区别: 传值调用是指在调用函数时将实际参数复制一份传递到函数中,传引用调用是指在调用函数时将实际参数的引用直接传递到函数中。  所以,两者的最主要区别就是是直接传递的,还是传递的是一个副本。 这里我们来举一个形象的例子。再来深入理解一下传值调用和传引用调用: 你有一把钥匙,当你的朋友想要去你家的时候,如果你直接把你的钥匙给他了,这就是引用传递。 这种情况下,如果他对这把钥匙做了什么事情,比如他在钥匙上刻下了自己名字,那么这把钥匙还给你的时候,你自己的钥匙上也会多出他刻的名字。 你有一把钥匙,当你的朋友想要去你家的时候,你复刻了一把新钥匙给他,自己的还在自己手里,这就是值传递。 这种情况下,他对这把钥匙做什么都不会影响你手里的这把钥匙。 Java的求值策略 前面我们介绍过了传值调用、传引用调用以及传值调用的特例传共享对象调用,那么,Java中是采用的哪种求值策略呢? 很多人说Java中的基本数据类型是值传递的,这个基本没有什么可以讨论的,普遍都是这样认为的。 但是,有很多人却误认为Java中的对象传递是引用传递。之所以会有这个误区,主要是因为Java中的变量和对象之间是有引用关系的。Java语言中是通过对象的引用来操纵对象的。所以,很多人会认为对象的传递是引用的传递。 而且很多人还可以举出以下的代码示例: public static void main(String[] args) { Test pt = new Test(); User hollis = new User(); hollis.setName("Hollis"); hollis.setGender("Male"); pt.pass(hollis); System.out.println("print in main , user is " + hollis); } public void pass(User user) { user.setName("hollischuang"); System.out.println("print in pass , user is " + user); } 输出结果: print in pass , user is User{name='hollischuang', gender='Male'} print in main , user is User{name='hollischuang', gender='Male'} 可以看到,对象类型在被传递到pass方法后,在方法内改变了其内容,最终调用方main方法中的对象也变了。 所以,很多人说,这和引用传递的现象是一样的,就是在方法内改变参数的值,会影响到调用方。 但是,其实这是走进了一个误区。 Java中的对象传递 很多人通过代码示例的现象说明Java对象是引用传递,那么我们就从现象入手,先来反驳下这个观点。 我们前面说过,无论是值传递,还是引用传递,只不过是求值策略的一种,那求值策略还有很多,比如前面提到的共享对象传递的现象和引用传递也是一样的。那凭什么就说Java中的参数传递就一定是引用传递而不是共享对象传递呢? 那么,Java中的对象传递,到底是哪种形式呢?其实,还真的就是共享对象传递。 其实在 《The Java™ Tutorials》中,是有关于这部分内容的说明的。首先是关于基本类型描述如下: Primitive arguments, such as an int or a double, are passed into methods by value. This means that any changes to the values of the parameters exist only within the scope of the method. When the method returns, the parameters are gone and any changes to them are lost. 即,原始参数通过值传递给方法。这意味着对参数值的任何更改都只存在于方法的范围内。当方法返回时,参数将消失,对它们的任何更改都将丢失。 关于对象传递的描述如下: Reference data type parameters, such as objects, are also passed into methods by value. This means that when the method returns, the passed-in reference still references the same object as before. However, the values of the object’s fields can be changed in the method, if they have the proper access level. 也就是说,引用数据类型参数(如对象)也按值传递给方法。这意味着,当方法返回时,传入的引用仍然引用与以前相同的对象。但是,如果对象字段具有适当的访问级别,则可以在方法中更改这些字段的值。 这一点官方文档已经很明确的指出了,Java就是值传递,只不过是把对象的引用当做值传递给方法。你细品,这不就是共享对象传递么? **其实Java中使用的求值策略就是传共享对象调用,也就是说,Java会将对象的地址的拷贝传递给被调函数的形式参数。**只不过"传共享对象调用"这个词并不常用,所以Java社区的人通常说"Java是传值调用",这么说也没错,因为传共享对象调用其实是传值调用的一个特例。 值传递和共享对象传递的现象冲突吗? 看到这里很多人可能会有一个疑问,既然共享对象传递是值传递的一个特例,那么为什么他们的现象是完全不同的呢? 难道值传递过程中,如果在被调方法中改变了值,也有可能会对调用者有影响吗?那到底什么时候会影响什么时候不会影响呢? 其实是不冲突的,之所以会有这种疑惑,是因为大家对于到底是什么是"改变值"有误解。 我们先回到上面的例子中来,看一下调用过程中实际上发生了什么? 在参数传递的过程中,实际参数的地址0X1213456被拷贝给了形参。这个过程其实就是值传递,只不过传递的值得内容是对象的应用。 那为什么我们改了user中的属性的值,却对原来的user产生了影响呢? 其实,这个过程就好像是:你复制了一把你家里的钥匙给到你的朋友,他拿到钥匙以后,并没有在这把钥匙上做任何改动,而是通过钥匙打开了你家里的房门,进到屋里,把你家的电视给砸了。 这个过程,对你手里的钥匙来说,是没有影响的,但是你的钥匙对应的房子里面的内容却是被人改动了。 也就是说,Java对象的传递,是通过复制的方式把引用关系传递了,如果我们没有改引用关系,而是找到引用的地址,把里面的内容改了,是会对调用方有影响的,因为大家指向的是同一个共享对象。 那么,如果我们改动一下pass方法的内容: public void pass(User user) { user = new User(); user.setName("hollischuang"); System.out.println("print in pass , user is " + user); } 上面的代码中,我们在pass方法中,重新new了一个user对象,并改变了他的值,输出结果如下: print in pass , user is User{name='hollischuang', gender='Male'} print in main , user is User{name='Hollis', gender='Male'} 再看一下整个过程中发生了什么: 这个过程,就好像你复制了一把钥匙给到你的朋友,你的朋友拿到你给他的钥匙之后,找个锁匠把他修改了一下,他手里的那把钥匙变成了开他家锁的钥匙。这时候,他打开自己家,就算是把房子点了,对你手里的钥匙,和你家的房子来说都是没有任何影响的。 所以,Java中的对象传递,如果是修改引用,是不会对原来的对象有任何影响的,但是如果直接修改共享对象的属性的值,是会对原来的对象有影响的。 总结 我们知道,编程语言中需要进行方法间的参数传递,这个传递的策略叫做求值策略。 在程序设计中,求值策略有很多种,比较常见的就是值传递和引用传递。还有一种值传递的特例——共享对象传递。 值传递和引用传递最大的区别是传递的过程中有没有复制出一个副本来,如果是传递副本,那就是值传递,否则就是引用传递。 在Java中,其实是通过值传递实现的参数传递,只不过对于Java对象的传递,传递的内容是对象的引用。 我们可以总结说,Java中的求值策略是共享对象传递,这是完全正确的。 但是,为了让大家都能理解你说的,我们说Java中只有值传递,只不过传递的内容是对象的引用。这也是没毛病的。 但是,绝对不能认为Java中有引用传递。 OK,以上就是本文的全部内容,不知道本文是否帮助你解开了你心中一直以来的疑惑。欢迎留言说一下你的想法。 参考资料 The Java™ Tutorials Evaluation strategy Is Java “pass-by-reference” or “pass-by-value”? Passing by Value vs. by Reference Visual Explanation

montos 2020-06-01 15:58:44 0 浏览量 回答数 0

问题

SSH面试题

琴瑟 2019-12-01 21:46:22 3489 浏览量 回答数 0

回答

HashMap 和 HashSet 内部是如何工作的?散列函数(hashing function)是什么? HashMap 不仅是一个常用的数据结构,在面试中也是热门话题。 Q1. HashMap 如何存储数据?A1. 以键/值对(key/value)形式存储。你可以使用键(key)来存、取值。 Q2. HashMap 查询时间的复杂度是怎样的?A2. 是O(n) = O(k * n)。如果 hashCode() 方法能向下面讨论的那样把数据分散到桶(bucket)中,那么平均是O(1)。 Q3. HashMap 内部是如何存储数据的?A3. HashMap 使用后台数组(backing array)作为桶,并使用链表(linked list)存储键/值对。 桶的后台数组:如下所示 hashCode() 返回 1, 45等 1)使用键(key)和值(value)将一个对象放入 map 中时,会隐式调用 hashCode() 方法,返回哈希值(hash code value),比如 123。两个不同的键能够返回一样的哈希值。良好的哈希算法(hashing algorithm)能够将数值分散开。在上面的例子中,我们假设 (“John”,01/01/1956) 的键和 (“Peter”, 01/01/1995) 的键返回相同的哈希值,都是 123。 Java equals vs hashCode 2)当返回一个 hashCode,例如是 123,初始的 HashMap 容量为 10,它如何知道存储到后台数组(backing array)的哪个索引(index)呢?HashMap 内部会调用 hash(int ) 和 indexFor(int h, int length) 方法。这被称为哈希函数(hashing function)。简要解释下这个函数:1234 hashCode() % capacity 123 % 10 = 3456 % 10 = 6 这表示,“hashCode = 123”存储在备份数组的索引3上。容量为 10 的情况下,你可能得到的数字在 0 到 9 之间。一旦 HashMap 达到容量的 75%,也就是哈希因子(hash factor)默认值 0.75,后台数组(backing array)的容量就会加倍,发生重散列(rehashing)为新的 20 的容量重新分配桶。1234 hashCode() % capacity 123 % 20 = 3456 % 20 = 16 上面重散列的取模方法有一个缺陷。如果 hashCode 是负数会怎样?负索引可不是你想要的。因此,一个改进的哈希公式会移出符号位,然后再用取模(即 %)运算符计算剩余部分。12 (123 & 0x7FFFFFFF) % 20 = 3(456 & 0x7FFFFFFF) % 20 = 16 这确保你得到的索引值为正数。如果你查看 Java 8 的 HashMap 源码,它的实现使用以下方法: a). 通过只抽取重要的低位,来防止不良离散值(poorer hashes)。1234567 static int hash(int h) { // This function ensures that hashCodes that differ only by // constant multiples at each bit position have a bounded // number of collisions (approximately 8 at default load factor). h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } b). 根据哈希码(hashCode)和容量(capacity),来决定索引(index)。123 static int indexFor(int h, int length) { return h & (length-1); } 实际的名称值对(name value pairs)作为一个键/值对存储在 LinkedList 中。 如上图所示,键/值对以链表形式存储。两个不同的键可以产生一样的 hashCode,例如123,并存储在同一个 bucket 中,理解这点至关重要。例如,上面例子中的 “John, 01/01/1956” 和 “Peter, 01/01/1995“ 。你如何只检索 “John, 01/01/1956” 呢?此时你的 key 所属类的 equals() 方法会被调用。它遍历 bucket 为 “123” 的 LinkedList 中的每个条目,使用 equals() 方法找到并检索出键为 “John, 01/01/1956” 的条目。这就是在你的类中实现 hashCode() 和 equals() 方法重要性的原因。如果你使用一个现有的包装类,如 Integer 或 String 作为键,它们已经实现了这两个方法。如果你使用自己写的类作为键,如 “John, 01/01/1956” 这样含有名字和出生日期属性的“MyKey”,你有责任正确地实现这些方法。 Q5. 为什么恰当地设置 HashMap 的初始容量(initial capacity)是最佳实践?A5. 这样可以减少重散列的发生。 Q6. HashSet 内部如何存储数据?A6. HashSet 内部使用 HashMap 。它将元素存储为键和值。(译者注:HashSet 把存储的值作为 key) Q7. 为 Object 实现了一个糟糕的 hashcode() 会有什么影响?A7. 不同的对象调用 hashCode() 方法应该返回不同的值。如果不同的对象返回相同的值,会导致更多的键/值对存储在同一个 bucket 中。这会降低 HashMap 和 HashSet 的性能。

wangccsy 2019-12-02 01:48:57 0 浏览量 回答数 0

回答

python 读写、创建 文件的方法: python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。 得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd() 返回指定目录下的所有文件和目录名:os.listdir() 函数用来删除一个文件:os.remove() 删除多个目录:os.removedirs(r“c:python”) 检验给出的路径是否是一个文件:os.path.isfile() 检验给出的路径是否是一个目录:os.path.isdir() 判断是否是绝对路径:os.path.isabs() 检验给出的路径是否真地存:os.path.exists() 返回一个路径的目录名和文件名:os.path.split() eg os.path.split(‘/home/swaroop/byte/code/poem.txt’) 结果:(‘/home/swaroop/byte/code’, ‘poem.txt’) 分离扩展名:os.path.splitext() 获取路径名:os.path.dirname() 获取文件名:os.path.basename() 运行shell命令: os.system() 读取和设置环境变量:os.getenv() 与os.putenv() 给出当前平台使用的行终止符:os.linesep Windows使用’rn’,Linux使用’n’而Mac使用’r’ 指示你正在使用的平台:os.name 对于Windows,它是’nt’,而对于Linux/Unix用户,它是’posix’ 重命名:os.rename(old, new) 创建多级目录:os.makedirs(r“c:pythontest”) 创建单个目录:os.mkdir(“test”) 获取文件属性:os.stat(file) 修改文件权限与时间戳:os.chmod(file) 终止当前进程:os.exit() 获取文件大小:os.path.getsize(filename) 文件操作: os.mknod(“test.txt”) 创建空文件 fp = open(“test.txt”,w) 直接打开一个文件,如果文件不存在则创建文件 关于open 模式: w 以写方式打开, a 以追加模式打开 (从 EOF 开始, 必要时创建新文件) r+ 以读写模式打开 w+ 以读写模式打开 (参见 w ) a+ 以读写模式打开 (参见 a ) rb 以二进制读模式打开 wb 以二进制写模式打开 (参见 w ) ab 以二进制追加模式打开 (参见 a ) rb+ 以二进制读写模式打开 (参见 r+ ) wb+ 以二进制读写模式打开 (参见 w+ ) ab+ 以二进制读写模式打开 (参见 a+ ) fp.read([size]) #size为读取的长度,以byte为单位 fp.readline([size]) #读一行,如果定义了size,有可能返回的只是一行的一部分 fp.readlines([size]) #把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。 fp.write(str) #把str写到文件中,write()并不会在str后加上一个换行符 fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入,不会在每行后面加上任何东西。 fp.close() #关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。 如果一个文件在关闭后还对其进行操作会产生ValueError fp.flush() #把缓冲区的内容写入硬盘 fp.fileno() #返回一个长整型的”文件标签“ fp.isatty() #文件是否是一个终端设备文件(unix系统中的) fp.tell() #返回文件操作标记的当前位置,以文件的开头为原点 fp.next() #返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。 fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。 fp.truncate([size]) #把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。 目录操作: os.mkdir(“file”) 创建目录 复制文件: shutil.copyfile(“oldfile”,”newfile”) oldfile和newfile都只能是文件 shutil.copy(“oldfile”,”newfile”) oldfile只能是文件夹,newfile可以是文件,也可以是目标目录 复制文件夹: shutil.copytree(“olddir”,”newdir”) olddir和newdir都只能是目录,且newdir必须不存在 重命名文件(目录) os.rename(“oldname”,”newname”) 文件或目录都是使用这条命令 移动文件(目录) shutil.move(“oldpos”,”newpos”) 删除文件 os.remove(“file”) 删除目录 os.rmdir(“dir”)只能删除空目录 shutil.rmtree(“dir”) 空目录、有内容的目录都可以删 转换目录 os.chdir(“path”) 换路径 Python读写文件 1.open 使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。 file_object = open(‘thefile.txt’) try: all_the_text = file_object.read( ) finally: file_object.close( ) 注:不能把open语句放在try块里,因为当打开文件出现异常时,文件对象file_object无法执行close()方法。 2.读文件 读文本文件 input = open(‘data’, ‘r’) 第二个参数默认为r input = open(‘data’) 读二进制文件 input = open(‘data’, ‘rb’) 读取所有内容 file_object = open(‘thefile.txt’) try: all_the_text = file_object.read( ) finally: file_object.close( ) 读固定字节 file_object = open(‘abinfile’, ‘rb’) try: while True: chunk = file_object.read(100) if not chunk: break do_something_with(chunk) finally: file_object.close( ) 读每行 list_of_all_the_lines = file_object.readlines( ) 如果文件是文本文件,还可以直接遍历文件对象获取每行: for line in file_object: process line 3.写文件 写文本文件 output = open(‘data’, ‘w’) 写二进制文件 output = open(‘data’, ‘wb’) 追加写文件 output = open(‘data’, ‘w+’) 写数据 file_object = open(‘thefile.txt’, ‘w’) file_object.write(all_the_text) file_object.close( ) 写入多行 file_object.writelines(list_of_text_strings) 注意,调用writelines写入多行在性能上会比使用write一次性写入要高。 在处理日志文件的时候,常常会遇到这样的情况:日志文件巨大,不可能一次性把整个文件读入到内存中进行处理,例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件,我们可能希望每次只处理其中 200MB 的内容。 在 Python 中,内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例: file = open(‘test.log’, ‘r’)sizehint = 209715200 # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0: position = file.tell() lines = file.readlines(sizehint) 每次调用 readlines(sizehint) 函数,会返回大约 200MB 的数据,而且所返回的必然都是完整的行数据,大多数情况下,返回的数据的字节数会稍微比 sizehint 指定的值大一点(除最后一次调用 readlines(sizehint) 函数的时候)。通常情况下,Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。 file在python是一个特殊的类型,它用于在python程序中对外部的文件进行操作。在python中一切都是对象,file也不例外,file有file的方法和属性。下面先来看如何创建一个file对象: file(name[, mode[, buffering]]) file()函数用于创建一个file对象,它有一个别名叫open(),可能更形象一些,它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。 mode是打开的模式,可选的值为r w a U,分别代表读(默认) 写 添加支持各种换行符的模式。用w或a模式打开文件的话,如果文件不存在,那么就自动创建。此外,用w模式打开一个已经存在的文件时,原有文件的内容会被清空,因为一开始文件的操作的标记是在文件的开头的,这时候进行写操作,无疑会把原有的内容给抹掉。由于历史的原因,换行符在不同的系统中有不同模式,比如在 unix中是一个n,而在windows中是‘rn’,用U模式打开文件,就是支持所有的换行模式,也就说‘r’ ‘n’ ‘rn’都可表示换行,会有一个tuple用来存贮这个文件中用到过的换行符。不过,虽说换行有多种模式,读到python中统一用n代替。在模式字符的后面,还可以加上+ b t这两种标识,分别表示可以对文件同时进行读写操作和用二进制模式、文本模式(默认)打开文件。 buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小,应该是以字节为单位的。 file对象有自己的属性和方法。先来看看file的属性。 closed #标记文件是否已经关闭,由close()改写 encoding #文件编码 mode #打开模式 name #文件名 newlines #文件中用到的换行模式,是一个tuple softspace #boolean型,一般为0,据说用于print file的读写方法: F.read([size]) #size为读取的长度,以byte为单位 F.readline([size]) 读一行,如果定义了size,有可能返回的只是一行的一部分 F.readlines([size]) 把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。 F.write(str) 把str写到文件中,write()并不会在str后加上一个换行符 F.writelines(seq) 把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西。 file的其他方法: F.close() 关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError F.flush() 把缓冲区的内容写入硬盘 F.fileno() 返回一个长整型的”文件标签“ F.isatty() 文件是否是一个终端设备文件(unix系统中的) F.tell() 返回文件操作标记的当前位置,以文件的开头为原点 F.next() 返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。 F.seek(offset[,whence]) 将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。 F.truncate([size]) 把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

元芳啊 2019-12-02 01:04:30 0 浏览量 回答数 0

问题

“木兰抄袭Python”官方致歉!从“红芯”到“木兰”,国产套壳何时休?

茶什i 2020-01-20 12:00:45 1642 浏览量 回答数 1
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 云栖号物联网 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站 云栖号弹性计算 阿里云云栖号 云栖号案例 云栖号直播